# Elastic Stack

## Introdução

Este manual descreve o procedimento de instalação do **Elastic Stack (ELK)**.

## Preparativos para Instalação

Esta seção abrange as etapas essenciais necessárias para a instalação.

{% hint style="warning" %}
Todas as etapas devem ser executadas com privilégios de root em todos os nós, salvo indicação em contrário.
{% endhint %}

Para instalar o ELK, você precisará de:

* Permissão de root no servidor
* GBDS instalado no servidor

{% hint style="info" %}
Caso não tenha o arquivo, entre em contato com a equipe de suporte da Griaule.
{% endhint %}

Então, siga os passos apresentados abaixo.

1. Faça login no servidor como *root*.
2. [Prepare o Repositório](#prepare-o-repositorio).
3. [Instale e Configure o Elasticsearch](#instalando-e-configurando-o-elasticsearch).
4. [Instale e Configure o Kibana](#instalando-e-configurando-o-kibana).
5. [Instale e Configure o Logstash](#instalando-e-configurando-o-logstash).
6. [Configure o ELK com o SmartSense](#configurando-o-elk-com-o-smartsense).

## Prepare o Repositório

Para instalar o ELK, primeiro o repositório deve ser adicionado ao servidor.

Para isso, importe a chave GPG:

```bash
rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
```

Crie o arquivo do repositório:

```bash
vim /etc/yum.repos.d/elasticsearch.repo
```

Adicione o seguinte conteúdo ao arquivo e salve-o:

```properties
[elasticsearch]
name=Elasticsearch repository for 8.x packages
baseurl=https://artifacts.elastic.co/packages/8.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md
```

Então, atualize o cache do gerenciador de pacotes. Comece limpando o cache:

```bash
yum clean all
```

Finalmente, faça um rebuild do cache dos pacotes:

```bash
yum makecache
```

## Instalando o ELK

### Instalando e Configurando o Elasticsearch

Instale o pacote Elasticsearch:

```bash
yum install elasticsearch -y
```

Então, abra o arquivo de configuração do Elasticsearch:

```bash
vim /etc/elasticsearch/elasticsearch.yml
```

Na seção *Network*, procure pela linha que começa com `#network.host:`. Descomente a linha e e altere seu valor para:

{% hint style="info" %}
Certifique-se de substituir `<host-ip>` pelo endereço IP do servidor.
{% endhint %}

```yml
network.host: <host-ip>
              ^^^^^^^^^
```

Em seguida, desligue o SSL alterando as seguintes configurações para `false`:

```yml
xpack.security.enabled: false

xpack.security.enrollment.enabled: false

# Enable encryption for HTTP API client connections, such as Kibana, Logstash, and Agents
xpack.security.http.ssl:
  enabled: false
  keystore.path: certs/http.p12

# Enable encryption and mutual authentication between cluster nodes
xpack.security.transport.ssl:
  enabled: false
```

Então, inicie o serviço do Elasticsearch:

```bash
sudo systemctl start elasticsearch
```

E habilite o serviço do Elasticsearch para iniciar automaticamente na inicialização da máquina:

```bash
sudo systemctl enable elasticsearch
```

Finalmente, verifique se o serviço do Elasticsearch está em execução:

{% hint style="info" %}
Certifique-se de substituir `<host-ip>` pelo endereço IP do servidor.
{% endhint %}

```bash
curl -X GET "<host-ip>:9200"
             ^^^^^^^^^
```

O resultado deve ser semelhante a:

```json
{
	"name": "QDexH8a",
	"cluster_name": "elasticsearch",
	"cluster_uuid": "gAAIqERvS_msO7Y1_759Ja",
	"version": {
		"number": "6.8.23",
		"build_flavor": "default",
		"build_type": "rpm",
		"build_hash": "4f67856",
		"build_date": "2022-01-06T21:30:50.087716Z",
		"build_snapshot": false,
		"lucene_version": "7.7.3",
		"minimum_wire_compatibility_version": "5.6.0",
		"minimum_index_compatibility_version": "5.0.0"
	},
	"tagline": "You Know, for Search"
}
```

### Instalando e Configurando o Kibana

Instale o pacote Kibana:

```bash
yum install kibana -y
```

Então, abra o arquivo de configuração do Kibana:

```bash
vim /etc/kibana/kibana.yml
```

Procure pela linha que começa com `#server.host:`. Descomente a linha e altere seu valor para:

{% hint style="info" %}
Certifique-se de substituir `<hostname>` pelo nome de host do servidor. Mantenha as aspas duplas.
{% endhint %}

```yml
server.host: "<hostname>"
              ^^^^^^^^^^
```

Em seguida, procure pela linha que começa com `#elasticsearch.hosts:`. Descomente a linha e altere seu valor para:

{% hint style="info" %}
Certifique-se de substituir `<elasticsearch-host-ip>` pelo endereço IP configurado no Elasticsearch. Mantenha as aspas duplas.
{% endhint %}

```yml
elasticsearch.hosts: ["http://<elasticsearch-host-ip>:9200"]
                              ^^^^^^^^^^^^^^^^^^^^^^^
```

Então, inicie o serviço do Kibana:

```bash
sudo systemctl start kibana
```

E habilite o serviço do Kibana para iniciar automaticamente na inicialização da máquina:

```bash
sudo systemctl enable kibana
```

Em seguida, instale e configure o Nginx.

#### Instalando e Configurando o Nginx

Instale o pacote Nginx:

```bash
yum install nginx -y
```

Em seguida, crie um arquivo que conterá as credenciais de autenticação para o Kibana. Para isso, execute o seguinte comando e insira a senha desejada quando solicitado:

```bash
echo "kibanaadmin:`openssl passwd -apr1`" | tee -a /etc/nginx/htpasswd.users
```

Então, crie um novo arquivo de configuração para o Nginx:

{% hint style="info" %}
Certifique-se de substituir `<hostname>` pelo nome de host do servidor.
{% endhint %}

```bash
vim /etc/nginx/conf.d/<hostname>_kibana.conf
                      ^^^^^^^^^^
```

Adicione o seguinte conteúdo ao arquivo, fazendo as alterações apropriadas em `server_name` e `proxy_pass`:

{% hint style="info" %}
Certifique-se de substituir `<host-ip>` pelo endereço IP do servidor e `<kibana-host-ip>` pelo endereço IP do servidor em que o Kibana está instalado.
{% endhint %}

{% hint style="warning" %}
Abaixo, as linhas contendo **"^^^^^^^^^"** estão presentes apenas para destacar as alterações que devem ser feitas. Remova-as antes de salvar o arquivo.
{% endhint %}

```properties
server {
	listen 80;

	server_name <host-ip>;
	            ^^^^^^^^^

	auth_basic "Restricted Access";
	auth_basic_user_file /etc/nginx/htpasswd.users;

	location / {
		proxy_pass http://<kibana-host-ip>:5601;
		                  ^^^^^^^^^^^^^^^^
		proxy_http_version 1.1;
		proxy_set_header Upgrade $http_upgrade;
		proxy_set_header Connection 'upgrade';
		proxy_set_header Host $host;
		proxy_cache_bypass $http_upgrad;
	}
}
```

Teste o arquivo de configuração do Nginx:

```bash
nginx -t
```

Então, reinicie o serviço do Nginx:

```bash
systemctl restart nginx
```

Se necessário, configure a conexão no SE:

```bash
setsebool httpd_can_network_connect 1 -P
```

Finalmente, verifique se o serviço do Kibana está em execução, acessando a seguinte URL em um navegador:

{% hint style="info" %}
Certifique-se de substituir `<host-ip>` pelo endereço IP do servidor.
{% endhint %}

```bash
http://<host-ip>/status
       ^^^^^^^^^
```

{% hint style="success" %}
O nome de usuário é **kibanaadmin** e a senha é a criada acima.
{% endhint %}

### Instalando e Configurando o Logstash

Instale o pacote Logstash:

```bash
yum install logstash -y
```

Em seguida, instale o pacote MySQL Connector/J:

```bash
yum install mysql-connector-java -y
```

{% hint style="info" %}
Caso ele não seja encontrado, realize o download em: <https://dev.mysql.com/downloads/connector/j/>
{% endhint %}

Então, crie o arquivo de configuração do Logstash:

```bash
vim /etc/logstash/conf.d/smartsense.conf
```

Adicione o seguinte conteúdo ao arquivo, fazendo as alterações apropriadas em `jdbc_connection_string`, `jdbc_user`, `jdbc_password` e `hosts`:

{% hint style="info" %}
Certifique-se de substituir `<database-ip>`, `<database-username>`, `<database-password>` e `<elasticsearch-host-ip>` pelos valores apropriados. Mantenha as aspas duplas.
{% endhint %}

{% hint style="warning" %}
Abaixo, as linhas contendo **"^^^^^^^^^"** estão presentes apenas para destacar as alterações que devem ser feitas. Remova-as antes de salvar o arquivo.
{% endhint %}

```properties
input {
	jdbc {
		jdbc_driver_library => "/usr/share/java/mysql-connector-java.jar"
		jdbc_driver_class => "com.mysql.jdbc.Driver"
		jdbc_connection_string => "jdbc:mysql://<database-ip>:3306/"
		                                        ^^^^^^^^^^^^^
		jdbc_user => "<database-username>"
		              ^^^^^^^^^^^^^^^^^^^
		jdbc_password => "<database-password>"
		                  ^^^^^^^^^^^^^^^^^^^
		jdbc_validate_connection => true
		tracking_column => "id"
		use_column_value => true
		statement => "SELECT * FROM smartsense.load_balancing_count where id > :sql_last_value;"
		schedule => "*/2 * * * *"
		clean_run => false
	}
}
output {
	elasticsearch {
		hosts => ["<elasticsearch-host-ip>:9200"]
		           ^^^^^^^^^^^^^^^^^^^^^^^
		index => "smart_sense_index_pattern"
		document_id => "%{[id]}"
	}
	stdout {
		codec => rubydebug
	}
}
```

Em seguida, o arquivo systemd do Logstash precisa ser modificado para garantir que ele seja inicializado usando o arquivo de configuração criado anteriormente. Para isso, abra o arquivo:

```bash
vim /etc/systemd/system/logstash.service
```

{% hint style="info" %}
É possível que o arquivo esteja localizado em `/usr/lib/systemd/system/logstash.service`.
{% endhint %}

Procure a linha que começa com `ExecStart=`. Altere seu valor de:

```properties
ExecStart=/usr/share/logstash/bin/logstash "--path.settings" "/etc/logstash"
```

Para:

```properties
ExecStart=/usr/share/logstash/bin/logstash "--path.settings" "/etc/logstash" "-f" "/etc/logstash/conf.d/smartsense.conf"
```

Então, aplique as alterações recarregando a configuração do systemd:

```bash
systemctl daemon-reload
```

{% hint style="warning" %}
Se estiver instalando em um novo servidor que possui uma base de dados vazia, insira um valor fictício na tabela `smartsense.load_balancing_count` para evitar erros. Para isso, execute o seguinte comando e insira a senha do banco de dados:

Certifique-se de substituir `<database-username>` e `<mysql-database-ip>` pelos valores apropriados.

```bash
#        vvvvvvvvvvvvvvvvvvv       vvvvvvvvvvvvvvvvvvv
mysql -u <database-username> -p -h <mysql-database-ip> \
      -e "USE smartsense; INSERT INTO load_balancing_count
         (id, hostname, load_time, api_id, transaction_type,
         latent, ul, load_count, extraction_time_avg, extraction_quality_avg,
         match_avg, total_avg, extraction_time_min, extraction_quality_min, match_min,
         total_min, extraction_time_max, extraction_quality_max, match_max, total_max)
         VALUES
         (1, 'hostname', '2023-08-31 21:25:40', '8829E30D-4994-4D09-99AF-B6F818473928',
         'IDENTIFY', 'false', 'false', 1, '541.0', '0.0', '48.0', '599.0',
         '541', '0', '48', '599', '541', '0', '48', '599');"
```

{% endhint %}

Em seguida, habilite o serviço do Logstash para iniciar automaticamente na inicialização da máquina:

```bash
sudo systemctl enable logstash
```

Então, inicie o serviço do Logstash:

```bash
sudo systemctl start logstash
```

E acompanhe o log:

```bash
tail -f /var/log/logstash/logstash-plain.log
```

{% hint style="danger" %}
Se um erro ocorrer indicando que o Logstash não pode escrever no diretório `/var/lib/logstash/{folder}`, execute o seguinte comando para alterar seu *owner*:

```bash
chown -R logstash:logstash /var/lib/logstash
```

{% endhint %}

Finalmente, para verificar se o Logstash criou o índice no Elasticsearch, execute o seguinte comando:

{% hint style="info" %}
Certifique-se de substituir `<elasticsearch-host-ip>` pelo endereço IP do servidor em que o Elasticsearch está instalado.
{% endhint %}

```bash
curl -X GET "<elasticsearch-host-ip>:9200/_cat/indices?v"
             ^^^^^^^^^^^^^^^^^^^^^^^
```

A saída deve ser semelhante a:

```
health status index                     uuid                   pri rep docs.count docs.deleted store.size pri.store.size
yellow open   smart_sense_index_pattern 6Ux_yM25SvG2zWGdGR0HQw   5   1          1            0      6.7kb          6.7kb
green  open   .kibana_1                 BBO89yLnTUC3F7nhqKwf9w   1   0          4            0       18kb           18kb
green  open   .kibana_task_manager      sIMoATiBRsS8bXiVBCscrA   1   0          2            0     12.5kb         12.5kb
```

## Configurando o ELK com o SmartSense

### Configurando o Kibana

#### Criando a *Data View*

{% hint style="info" %}
Certifique-se de substituir `<kibana-host-ip>` pelo endereço IP do servidor em que o Kibana está instalado.
{% endhint %}

Em um navegador, acesse: `http://<kibana-host-ip>:5601`. Em seguida, abra a barra lateral de opções clicando neste ícone, localizado no canto superior esquerdo da tela:

![](/files/8PZdbdpFpzgWjkvWMF0N)

Clique em Management (última seção). Então, nas opções do lado esquerdo, na seção *Data*, clique em Index Management.

Ou acesse a seguinte URL diretamente:

```html
http://<kibana-host-ip>:5601/app/management/data/index_management/indices
       ^^^^^^^^^^^^^^^^
```

Certifique-se de que o índice `smart_sense_index_pattern` aparece na lista.

Em seguida, na seção *Kibana* das opções do lado esquerdo, clique em Data Views.

Clique no botão azul Create data view e preencha os campos com as seguintes informações:

* Name: `SS Pattern`
* Index pattern: `smart_sense_index_pattern`
* Timestamp field: `load_time`

Confirme a criação da *Data View* clicando em Save data view to Kibana.

#### Criando os *Dashboards*

Abra novamente a barra lateral de opções clicando no ícone no canto superior esquerdo da tela. Na seção Analytics, clique em Dashboards.

Ou acesse a seguinte URL diretamente:

```html
http://<kibana-host-ip>:5601/app/dashboards
       ^^^^^^^^^^^^^^^^
```

Clique no botão azul Create dashboard. Em seguida, clique em Create visualization. No lado direito, configure a *visualization* com as seguintes informações:

* Visualization type: `Bar vertical stacked`
* Data view: `SS Pattern`
* Horizontal Axis:
  * Functions: `Date histogram`
  * Field: `load_time`
* Vertical Axis:
  * Functions: `Sum`
  * Field: `load_count`

Então, clique no símbolo +, localizado no canto superior esquerdo da tela, para criar um novo filtro. Configure o filtro com as seguintes informações: `transaction_type` `is` `ENROLL`. Confirme clicando em Add filter.

Finalmente, salve o *dashboard* clicando em Save to library, localizado no canto superior direito da tela, e inserindo as seguintes informações:

* Title: `SS Enroll Dashboard`
* Tags: `smartsense-enroll`

Clique em Save and return.

Repita as operações acima para criar os seguintes *dashboards*:

{% hint style="info" %}
Readeque os nomes e tags conforme necessário.
{% endhint %}

* Para **VERIFY** adicione o filtro: `transaction_type` `is` `VERIFY`
* Para **UPDATE** adicione o filtro: `transaction_type` `is` `UPDATE`
* Para **IDENTIFY** adicione o filtro: `transaction_type` `is` `IDENTIFY` `and` `latent` `is` `false`
* Para **LATENT** adicione o filtro: `transaction_type` `is` `IDENTIFY` `and` `latent` `is` `true`

Com os cinco dashboards criados, entre em cada um deles e configure o intervalo de tempo a ser exibido, clicando no ícone de calendário, localizado no canto superior direito da tela.

Em seguida, clique em Share e em Copy link. Salve o link, pois ele será usado posteriormente.

Repita a operação para os cinco dashboards.

Ao final de cada link, adicione a seguinte informação:

```default
&hide-filter-bar=true&show-time-filter=true&embed=true
```

Por exemplo, o link:

```default
http://172.16.0.185:5601/app/lens#/edit/a0a936d5-4e92-4015-b3e7-37810c2a114a?_g=(filters:!(),refreshInterval:(pause:!t,value:60000),time:(from:now-7d/d,to:now))
```

Ficará:

```default
http://172.16.0.185:5601/app/lens#/edit/a0a936d5-4e92-4015-b3e7-37810c2a114a?_g=(filters:!(),refreshInterval:(pause:!t,value:60000),time:(from:now-7d/d,to:now))&hide-filter-bar=true&show-time-filter=true&embed=true
```

Repita a operação para os cinco links obtidos.

Salve os links, pois serão usados no passo seguinte.

### Configurando os Dashboards no SmartSense

Abra o arquivo de configuração do SmartSense, `config.properties`, localizado na pasta `/var/lib/tomcats/smart-sense/conf`:

```bash
vim /var/lib/tomcats/smart-sense/conf/config.properties
```

Encontre a seção **# SMARTSENSE - ELK CONFIGURATION**.

Para cada propriedade (`linkEnroll`, `linkIdentify`, `linkIdentifyLatent`, `linkUpdate`, `linkVerify`), insira o link do dashboard correspondente obtido anteriormente. Por exemplo:

```properties
linkEnroll=http://172.16.0.185:5601/app/lens#/edit/a0a936d5-4e92-4015-b3e7-37810c2a114a?_g=(filters:!(),refreshInterval:(pause:!t,value:60000),time:(from:now-7d/d,to:now))&hide-filter-bar=true&show-time-filter=true&embed=true

linkUpdate=http://172.16.0.185:5601/app/lens#/edit/25d53ee8-7adc-4b06-b05d-f38bfda39c66?_g=(filters:!(),refreshInterval:(pause:!t,value:60000),time:(from:now-7d/d,to:now))&hide-filter-bar=true&show-time-filter=true&embed=true

linkVerify=http://172.16.0.185:5601/app/lens#/edit/8bfa1546-7990-4ed3-baae-86e421a60aef?_g=(filters:!(),refreshInterval:(pause:!t,value:60000),time:(from:now-7d/d,to:now))&hide-filter-bar=true&show-time-filter=true&embed=true

linkIdentify=http://172.16.0.185:5601/app/lens#/edit/0d5edf08-ca78-40fc-ac5f-59ca91d07412?_g=(filters:!(),refreshInterval:(pause:!t,value:60000),time:(from:now-7d/d,to:now))&hide-filter-bar=true&show-time-filter=true&embed=true

linkIdentifyLatent=http://172.16.0.185:5601/app/lens#/edit/e3f84cc5-68dd-4c76-a84e-d209da2e777a?_g=(filters:!(),refreshInterval:(pause:!t,value:60000),time:(from:now-7d/d,to:now))&hide-filter-bar=true&show-time-filter=true&embed=true
```

Salve e feche o arquivo.

Após a conclusão de todas as etapas do procedimento de instalação do Elastic Stack, volte para o [manual de Configuração do SmartSense Server](/componentes-web/smartsenseconfig.md) para concluir a configuração.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.griaule.com/ferramentas-auxiliares/elk.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
