Guia de como configurar o ELK Stack Multi Node
Tags: elk, elasticsearch, kibana, logstash
Published: 2020-11-13 17:18:48

O ELK Stack é a junção de três softwares, Elasticsearch, Logstash e Kibana. O Logstash vai ser responsável por filtrar logs, inclusive tem a capacidade de coletar vários tipos arquivo, em seguida ele manda esses logs para o Elasticsearch, que por sua vez irá indexar e armazenar os logs. O Kibana possui uma interface gráfica que permite criar dashboards com gráficos e consultas específicas com os logs do Elasticsearch. Neste post nós vamos configurar essa Stack com a arquitetura Multi Node, que é usada normalmente para lidar com grande volume de dados.

Nossa arquitetura terá 3 servidores com Elasticsearch, 2 servidores com o Logstash e 1 servidor com o Kibana.

A distro que irei usar nesses servers é o Debian 9. Vamos lá ;)

##Elasticsearch

###**Instalação**

Um pré-requisito é o Java, então vamos começar por ele :)
```
apt update && apt install default-jdk
```

Agora vamos baixar e instalar a signing key:
```
wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | apt-key add -
```

Salvar no repositório:
```
echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | tee /etc/apt/sources.list.d/elastic-7.x.list
```

Agora basta instalar o `apt-transport-https` e o Elasticsearch:
```
apt install apt-transport-https && apt update && apt install elasticsearch
```

Agora que instalamos o Elasticsearch, vamos para a configuração da arquitetura Multi Node.

###**Configuração**

```
# vim /etc/elasticsearch/elasticsearch.yml
…………………………………………
cluster.name: elk-cluster
node.name: elastic1.elk
network.host: 0.0.0.0
http.port: 9200
discovery.seed_hosts: ["elastic1.elk", "elastic2.elk", "elastic3.elk"]
cluster.initial_master_nodes: ["elastic1.elk", "elastic2.elk", "elastic3.elk"]
```

*obs:* Configurei os hostnames dos servidores no /etc/hosts

Uma vez configurado, agora basta iniciar o serviço:
```
# systemctl daemon-reload
# systemctl enable elasticsearch
# systemctl start elasticsearch
```

Você consegue verificar se está tudo ok batendo na api:
```
# curl 'http://elastic2.elk:9200'
{
  "name" : "elastic2.elk",
  "cluster_name" : "elk-cluster",
  "cluster_uuid" : "krxVRWInQtCzIhHdw1Mqkg",
  "version" : {
    "number" : "7.9.2",
    "build_flavor" : "default",
    "build_type" : "deb",
    "build_hash" : "d34da0ea4a966c4e49417f2da2f244e3e97b4e6e",
    "build_date" : "2020-09-23T00:45:33.626720Z",
    "build_snapshot" : false,
    "lucene_version" : "8.6.2",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}
```

Para verificar o status do cluster basta fazer a request:
```
# curl 'http://elastic1.elk:9200/_cluster/health?pretty'                                                   
{
  "cluster_name" : "elk-cluster",
  "status" : "green",
  "timed_out" : false,
  "number_of_nodes" : 3,
  "number_of_data_nodes" : 3,
  "active_primary_shards" : 0,
  "active_shards" : 0,
  "relocating_shards" : 0,
  "initializing_shards" : 0,
  "unassigned_shards" : 0,
  "delayed_unassigned_shards" : 0,
  "number_of_pending_tasks" : 0,
  "number_of_in_flight_fetch" : 0,
  "task_max_waiting_in_queue_millis" : 0,
  "active_shards_percent_as_number" : 100.0
}
```

##Logstash
###**Instalação**
O processo  de instalação vai ser basicamente da mesma forma que o elasticsearch:
```
# apt update && apt install default-jdk
# wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | apt-key add -
# echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | tee /etc/apt/sources.list.d/elastic-7.x.list
# apt install apt-transport-https && apt update && apt install logstash
```

###**Configuração**
Primeiro vamos copiar um arquivo de configuração padrão:
```
# cd /etc/logstash/ && cp logstash-sample.conf conf.d/logstash.conf
```

Agora vamos alterá-lo para inserir o tipo de log que ele irá coletar e inserir os endereços do elasticsearch:
```
# vim conf.d/logstash.conf

input {
  beats {
    port => 5044
  }
}

output {
  elasticsearch {
    hosts => ["http://elastic1.elk:9200", "http://elastic2.elk:9200", "http://elastic3.elk:9200"]
    index => "%{[@metadata][beat]}-%{[@metadata][version]}-%{+YYYY.MM.dd}"
    #user => "elastic"
    #password => "changeme"
  }
}
```
Agora vamos editar o arquivo de configuração para ativar o monitoramento do cluster no Kibana:
```
# vim /etc/logstash/logstash.yml
xpack.monitoring.enabled: true
xpack.monitoring.elasticsearch.hosts: ["http://elastic1.elk:9200", "http://elastic2.elk:9200", "http://elastic3.elk:9200"]
```

Após editar os arquivos de configuração, vamos iniciar o Logstash:
```
# systemctl daemon-reload
# systemctl enable logstash
# systemctl start logstash
```

Você consegue verificar os status do logstash através dos logs em `/var/log/logstash-stdout.log`.

##Kibana
###**Instalação**
Novamente o processo  de instalação vai ser da mesma forma que o elasticsearch:
```
# apt update && apt install default-jdk
# wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | apt-key add -
# echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | tee /etc/apt/sources.list.d/elastic-7.x.list
# apt install apt-transport-https && apt update && apt install kibana
```

###**Configuração**

Agora vamos editar o arquivo de configuração:
```
# vim /etc/kibana/kibana.yml

server.host: "kibana.elk"
server.name: "kibana.elk"
elasticsearch.hosts: ["http://elastic1.elk:9200", "http://elastic2.elk:9200", "http://elastic3.elk:9200"]
```

Após configurar, vamos iniciar o Kibana:
```
# systemctl daemon-reload
# systemctl enable Kibana
# systemctl start Kibana
```

Após alguns segundos a interface estará disponível `http://kibana.elk:5601`:
![kibana.elk:5601](https://dev-to-uploads.s3.amazonaws.com/i/ugda8fh46fdxglxcfygw.png)


No Kibana, nós conseguimos verificar o status do nosso cluster, basta acessar o menu hamburguer que fica localizado no canto superior esquerdo. Na seção *"Management"* clique em *"Stack Monitoring"*. Na primeira vez que acessar a página ele irá aparecer a opção de realizar o monitoramento com o *"MetricBeat"* e a opção *"or, set up with self monitoring"*. Vamos clicar nesta segunda. Após alguns segundos irá aparecer esta página:
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/4tt6knlky6uuitg1w410.png)


##Enviando logs com Filebeat
Para mostrar um pouco do que podemos fazer no Kibana, temos que configurar o envio de algum log. Como este é um lab de teste, irei enviar o log do próprio Kibana para monitorarmos.

Para isso vamos utilizar o Filebeat, para instalar basta rodar os seguintes comandos:
```
# curl -L -O https://artifacts.elastic.co/downloads/beats/filebeat/filebeat-7.9.2-amd64.deb
# dpkg -i filebeat-7.9.2-amd64.deb
```

Uma vez instalado, vamos configurá-lo. No arquivo de configuração do filebeat, vc vai inserir o diretórios dos logs que seram enviados e o endereço do logstash (descomente o bloco de output do elasticsearch):
```
# vim /etc/filebeat/filebeat.yml
filebeat.inputs:
- type: log
  enabled: true
  paths:
    - /var/log/kibana/kibana.stdout
#output.elasticsearch:
  #  hosts: ["localhost:9200"]

output.logstash:
    hosts: ["logstash1.elk:5044", "logstash2.elk:5044"]
    loadbalance: true
```

Agora que configuramos o Filebeat, vamos configurá-lo no Kibana.

Acesse o menu, vá em *"Management"* e clique em *"Stack Management"*. No lado esquerdo irá aparecer algumas opções, vamos clicar em *"Index Management"*:
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/8udar86yq6q5osae26yz.png)

Já conseguimos ver que o index do filebeat está disponível. Agora vamos criar um padrão de index. No canto esquerdo, clique em *"Index Patterns"*, após isso clique em *"Create index pattern"*. Vamos inserir um nome para o nosso index:
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/88tu4sbc7i2kdjk9tlmq.png)


No passo dois selecione a opção *"@timestamp"* e clique em *"Create index pattern"*.

Agora que criamos, retorne a página de *"Discover"* e verá as mensagens de log do próprio Kibana:
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/60t0usiit8mdwqs2h13l.png)

Stopei o Elasticsearch para que o Kibana reportasse mensagens de erro, com essas mensagens podemos fazer alguns gráficos.

##Criando Gráficos e Dashboards

No menu lateral do Kibana temos a opção Dashboad. Vamos criar uma nova para salvarmos consultas dos logs do Kibana.

Clique em *"New Dashboard"*. Após isso clique em *"Create new"*. Escolha a opção *"Metric"* e selecione o index filebeat.

Vamos adicionar a query *message : "Unable to revive connection"* e pegar quantas vezes o Kibana tentou reconectar com o Elasticsearch na última hora:
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/2205n9mwq4v3288as48g.png)

Clique em *"Save"*, insira um nome para o seu card e clique em *"Save and return"*.

Voltamos para a nossa página de Dashboard, vamos salvá-la e inserir um nome (inseri o nome "Cluster State"):
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/l8lmjqld0acg0ksr1qbx.png)

Agora vamos adicionar 2 gráficos. Na página de Dashboard, clique em *"Edit"* e logo depois *"Create new"*.

Adicionei um pie chart para mostrar a porcentagem de disponibilidade dos nodes do Elastic, ficou desta forma:
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/4vn4yi6i46fd6jwe0dho.png)

O último gráfico que irei colocar é um area chart com o status das mensagens por faixa de tempo:
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/f8mky1qpxjrbj0iv1iy8.png)

Na página de Dashboard, tem o botão "Edit"(canto superior esquerdo), essa opção permite que você edite as consultas salvas e também permite redimensionar e arrastar cada widget que nós criamos nesse guia. A minha dashboard, após fazer os três gráficos, ficou desta forma:
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/doulhr6x9bt1wqlga4qi.png)

Este guia apenas coloquei o log do Kibana mas você consegue acrescentar novos tipos de logs, criar novas dashboards e deixar sua ELK stack ainda mais produtiva. Espero que tenha gostado! Até mais :)