Você está visualizando a documentação da versão de desenvolvimento, que pode estar incompleta.
Esta página foi traduzida automaticamente. Se você notar um erro, selecione-o e pressione Ctrl+Enter para reportá-lo aos editores.

8 Configuração do Elasticsearch

O suporte ao Elasticsearch é experimental!

O Zabbix suporta o armazenamento de dados históricos por meio do Elasticsearch em vez de um banco de dados. Os usuários podem escolher o local de armazenamento dos dados históricos entre um banco de dados compatível e o Elasticsearch. O procedimento de configuração descrito nesta seção é aplicável à versão 7.X do Elasticsearch. Caso uma versão anterior ou posterior do Elasticsearch seja usada, algumas funcionalidades podem não funcionar conforme o esperado.

1.Se todos os dados históricos forem armazenados no Elasticsearch, as tendências não são calculadas nem armazenadas no banco de dados. Sem tendências calculadas e armazenadas, o período de armazenamento do histórico pode precisar ser estendido.
2. Quando o Elasticsearch é usado, as consultas de intervalo que recuperam valores do banco de dados são limitadas pelo timestamp do período de armazenamento dos dados.

Configuração

Para garantir a comunicação adequada entre todos os elementos envolvidos, certifique-se de que os parâmetros do arquivo de configuração do server e do arquivo de configuração do frontend estejam devidamente configurados.

Zabbix server e frontend

Rascunho do arquivo de configuração do Zabbix server com parâmetros a serem atualizados:

### Option: HistoryStorageURL
       # URL HTTP[S] de armazenamento do histórico.
       #
       # Obrigatório: não
       # Padrão:
       # HistoryStorageURL= 
       ### Option: HistoryStorageTypes
       # Lista separada por vírgulas dos tipos de valores a serem enviados para o armazenamento do histórico.
       #
       # Obrigatório: não
       # Padrão:
       # HistoryStorageTypes=uint,dbl,str,log,text

Exemplo de valores de parâmetros para preencher o arquivo de configuração do Zabbix server:

HistoryStorageURL=http://test.elasticsearch.lan:9200
       HistoryStorageTypes=str,log,text

Esta configuração força o Zabbix Server a armazenar valores históricos de tipos numéricos no banco de dados correspondente e dados históricos textuais no Elasticsearch.

O Elasticsearch suporta os seguintes tipos de item:

uint,dbl,str,log,text

Explicação dos tipos de item suportados:

Tipo de valor do item Tabela do banco de dados Tipo do Elasticsearch
Numérico (sem sinal) history_uint uint
Numérico (float) history dbl
Caractere history_str str
Log history_log log
Texto history_text text

Rascunho do arquivo de configuração do Zabbix frontend (conf/zabbix.conf.php) com parâmetros a serem atualizados:

// URL do Elasticsearch (pode ser string se a mesma URL for usada para todos os tipos).
       $HISTORY['url']   = [
             'uint' => 'http://localhost:9200',
             'text' => 'http://localhost:9200'
       ];
       // Tipos de valores armazenados no Elasticsearch.
       $HISTORY['types'] = ['uint', 'text'];

Exemplo de valores de parâmetros para preencher o arquivo de configuração do Zabbix frontend:

$HISTORY['url']   = 'http://test.elasticsearch.lan:9200';
       $HISTORY['types'] = ['str', 'text', 'log'];

Esta configuração força o armazenamento de valores históricos de Texto, Caractere e Log no Elasticsearch.

Também é necessário tornar $HISTORY global em conf/zabbix.conf.php para garantir que tudo esteja funcionando corretamente (veja conf/zabbix.conf.php.example para saber como fazer isso):

// Arquivo de configuração da interface web do Zabbix.
       global $DB, $HISTORY;
Instalando o Elasticsearch e criando o mapeamento

Os dois últimos passos para fazer tudo funcionar são instalar o Elasticsearch e criar o processo de mapeamento.

Para instalar o Elasticsearch, consulte o guia de instalação do Elasticsearch.

Mapping é uma estrutura de dados no Elasticsearch (semelhante a uma tabela em um banco de dados). O mapeamento para todos os tipos de dados de histórico está disponível aqui: database/elasticsearch/elasticsearch.map.

A criação do mapeamento é obrigatória. Algumas funcionalidades não funcionarão se o mapeamento não for criado conforme as instruções.

Para criar o mapeamento para o tipo text, envie a seguinte requisição para o Elasticsearch:

curl -X PUT \
        http://your-elasticsearch.here:9200/text \
        -H 'content-type:application/json' \
        -d '{
          "settings": {
             "index": {
                "number_of_replicas": 1,
                "number_of_shards": 5
             }
          },
          "mappings": {
             "properties": {
                "itemid": {
                   "type": "long"
                },
                "clock": {
                   "format": "epoch_second",
                   "type": "date"
                },
                "value": {
                   "fields": {
                      "analyzed": {
                         "index": true,
                         "type": "text",
                         "analyzer": "standard"
                      }
                   },
                   "index": false,
                   "type": "text"
                }
             }
          }
       }'

Uma requisição semelhante deve ser executada para a criação do mapeamento dos valores de histórico Character e Log, com a devida correção do tipo.

Para trabalhar com o Elasticsearch, consulte os Requisitos para informações adicionais.

O Housekeeper não exclui nenhum dado do Elasticsearch.

Armazenando dados históricos em vários índices baseados em data

Esta seção descreve as etapas adicionais necessárias para trabalhar com pipelines e ingest nodes.

Para começar, você deve criar templates para os índices.

O exemplo a seguir mostra uma solicitação para criar um template uint:

curl -X PUT \
        http://your-elasticsearch.here:9200/_template/uint_template \
        -H 'content-type:application/json' \
        -d '{
          "index_patterns": [
             "uint*"
          ],
          "settings": {
             "index": {
                "number_of_replicas": 1,
                "number_of_shards": 5
             }
          },
          "mappings": {
             "properties": {
                "itemid": {
                   "type": "long"
                },
                "clock": {
                   "format": "epoch_second",
                   "type": "date"
                },
                "value": {
                   "type": "long"
                }
             }
          }
       }'

Para criar outros templates, o usuário deve alterar a URL (a última parte é o nome do template), alterar o campo "index_patterns" para corresponder ao nome do índice e definir o mapeamento válido, que pode ser obtido em database/elasticsearch/elasticsearch.map.

Por exemplo, o comando a seguir pode ser usado para criar um template para o índice de texto:

curl -X PUT \
        http://your-elasticsearch.here:9200/_template/text_template \
        -H 'content-type:application/json' \
        -d '{
          "index_patterns": [
             "text*"
          ],
          "settings": {
             "index": {
                "number_of_replicas": 1,
                "number_of_shards": 5
             }
          },
          "mappings": {
             "properties": {
                "itemid": {
                   "type": "long"
                },
                "clock": {
                   "format": "epoch_second",
                   "type": "date"
                },
                "value": {
                   "fields": {
                      "analyzed": {
                         "index": true,
                         "type": "text",
                         "analyzer": "standard"
                      }
                   },
                   "index": false,
                   "type": "text"
                }
             }
          }
       }'

Isso é necessário para permitir que o Elasticsearch defina o mapeamento válido para índices criados automaticamente. Em seguida, é necessário criar a definição do pipeline. O pipeline é uma espécie de pré-processamento dos dados antes de armazená-los nos índices. O comando a seguir pode ser usado para criar um pipeline para o índice uint:

curl -X PUT \
        http://your-elasticsearch.here:9200/_ingest/pipeline/uint-pipeline \
        -H 'content-type:application/json' \
        -d '{
          "description": "daily uint index naming",
          "processors": [
             {
                "date_index_name": {
                   "field": "clock",
                   "date_formats": [
                      "UNIX"
                   ],
                   "index_name_prefix": "uint-",
                   "date_rounding": "d"
                }
             }
          ]
       }'

O usuário pode alterar o parâmetro de arredondamento ("date_rounding") para definir um período específico de rotação do índice. Para criar outros pipelines, o usuário deve alterar a URL (a última parte é o nome do pipeline) e alterar o campo "index_name_prefix" para corresponder ao nome do índice.

Veja também a documentação do Elasticsearch.

Além disso, o armazenamento de dados históricos em vários índices baseados em data também deve ser habilitado no novo parâmetro na configuração do Zabbix server:

### Option: HistoryStorageDateIndex
       # Habilita o pré-processamento dos valores históricos no armazenamento histórico para armazenar valores em diferentes índices com base na data.
       # 0 - desabilita
       # 1 - habilita
       #
       # Obrigatório: não
       # Padrão:
       # HistoryStorageDateIndex=0

Solução de problemas

As etapas a seguir podem ajudá-lo a solucionar problemas com a configuração do Elasticsearch:

  1. Verifique se o mapeamento está correto (solicitação GET para a URL do índice necessário como http://localhost:9200/uint).
  2. Verifique se os shards não estão em estado de falha (reiniciar o Elasticsearch pode ajudar).
  3. Verifique a configuração do Elasticsearch. A configuração deve permitir o acesso a partir do host do frontend do Zabbix e do host do server do Zabbix.
  4. Verifique os logs do Elasticsearch.
  5. LogSlowQueries pode ser usado para verificar consultas lentas no banco de dados Elasticsearch.

Se você ainda estiver enfrentando problemas com sua instalação, crie um relatório de bug com todas as informações desta lista (mapeamento, logs de erro, configuração, versão, etc.)