Configuração de Cluster Elasticsearch: Um Guia de Configuração Passo a Passo

Configurar um cluster Elasticsearch envolve principalmente acertar algumas escolhas iniciais: nomes de nós, descoberta, funções, rede e memória. Se esses fundamentos estiverem errados, seu cluster pode se formar de forma não confiável, expor-se na interface errada ou ter dificuldades durante reinicializações de nós.

Este guia aborda as configurações principais que você deve revisar antes de colocar o Elasticsearch em cargas de trabalho reais. Os exemplos usam elasticsearch.yml e assumem um pequeno cluster de três nós, mas as mesmas verificações se aplicam quando você escala.

Pré-requisitos

Antes de mergulhar na configuração, certifique-se de ter o seguinte em vigor:

Runtime Java: Muitas distribuições do Elasticsearch incluem um JDK empacotado. Se você fornecer seu próprio runtime Java, verifique a matriz de suporte para sua versão do Elasticsearch.
```
java -version
```
Recursos do Sistema: Aloque RAM, CPU e espaço em disco suficientes para seus nós Elasticsearch. Os requisitos exatos dependem do volume de dados e da complexidade das consultas.
Acesso à Rede: Garanta que os nós possam se comunicar entre si nas portas de transporte configuradas (o padrão é 9300).

Instalação

Embora este guia se concentre na configuração, uma configuração bem-sucedida começa com uma instalação correta. O Elasticsearch pode ser instalado via gerenciadores de pacotes (apt, yum), baixando o arquivo ou usando Docker. Consulte a documentação oficial do Elasticsearch para obter instruções detalhadas de instalação específicas para seu sistema operacional ou método de implantação.

Arquivos de Configuração Principais

O arquivo de configuração principal do Elasticsearch é elasticsearch.yml, normalmente localizado no diretório config/ da sua instalação do Elasticsearch. As configurações-chave neste arquivo ditam o comportamento do cluster.

Configuração do Cluster: Diretrizes de Configuração Chave

1. Nome do Cluster (`cluster.name`)

Esta configuração identifica exclusivamente seu cluster. Todos os nós no mesmo cluster devem compartilhar o mesmo cluster.name. Se não for definido, o padrão é elasticsearch.

Importância: Essencial para que os nós descubram e se juntem ao cluster correto. Clusters diferentes na mesma rede devem ter nomes distintos.
Exemplo (elasticsearch.yml):
```
cluster.name: meu-cluster-de-producao
```

2. Função do Nó (`node.roles`)

Os nós Elasticsearch podem receber funções específicas para otimizar a alocação de recursos e o desempenho. As funções comuns incluem master, data, ingest e ml. Para clusters menores, um único nó pode ter várias funções.

Nó elegível a mestre: Responsável por ações em todo o cluster, como criar/excluir índices, rastrear nós e alocar fragmentos. Recomenda-se ter nós mestres dedicados em ambientes de produção para estabilidade.
```
node.roles: [ master ]
```
Nó de dados: Armazena dados e realiza operações relacionadas a dados, como indexação e pesquisa. Nós de dados dedicados são cruciais para o desempenho.
```
node.roles: [ data ]
```
Nó de ingestão: Usado para pré-processar documentos antes da indexação (por exemplo, usando pipelines de ingestão).
```
node.roles: [ ingest ]
```
Nó de Machine Learning: Executa recursos de machine learning para detecção de anomalias e outras tarefas.
```
node.roles: [ ml ]
```
Nó apenas coordenador: Lida com solicitações de pesquisa e bulk, mas não armazena dados nem participa da eleição de mestre. Útil para descarregar cargas de consulta pesadas de nós de dados ou mestres.
```
node.roles: []
```

Melhor Prática: Em produção, dedique nós a funções específicas (por exemplo, separe nós mestres de nós de dados) para melhor tolerância a falhas e desempenho. Para configurações menores, os nós podem ter funções combinadas.

3. Configurações de Rede (`network.host`, `http.port`, `transport.port`)

Essas configurações controlam como seus nós Elasticsearch se comunicam.

network.host: O endereço IP ou nome de host ao qual o nó se vincula. Para clusters de vários nós, defina como um endereço IP acessível por outros nós. Usar 0.0.0.0 vincula a todas as interfaces de rede disponíveis.
```
network.host: 192.168.1.100
# ou
network.host: _site_
# ou
network.host: 0.0.0.0
```
http.port: A porta para a API REST HTTP (padrão: 9200).
```
http.port: 9200
```
transport.port: A porta para comunicação nó a nó (padrão: 9300).
```
transport.port: 9300
```

Aviso: Esteja atento às regras de firewall para garantir que os nós possam se comunicar na transport.port.

4. Configurações de Descoberta (`discovery.seed_hosts`, `cluster.initial_master_nodes`)

Essas configurações são cruciais para que os nós encontrem e se juntem ao cluster.

discovery.seed_hosts: Uma lista de endereços IP ou nomes de host de outros nós no cluster aos quais novos nós podem se conectar para descobrir o cluster.
```
discovery.seed_hosts:
  - "host1:9300"
  - "host2:9300"
  - "192.168.1.101:9300"
```
cluster.initial_master_nodes: Uma lista de nomes de nós elegíveis a mestre usados apenas para inicializar um cluster novo. Remova esta configuração após o cluster ser formado. Deixar configurações de inicialização obsoletas pode causar confusão durante reconstruções posteriores ou formação acidental de cluster.
```
cluster.initial_master_nodes:
  - "node-1"
  - "node-2"
  - "node-3"
```

Dica: Em ambientes de nuvem ou redes dinâmicas, considere usar serviços como DNS ou mecanismos de descoberta do provedor de nuvem.

Configurando um Cluster de Vários Nós

Para configurar um cluster de vários nós, você configurará o arquivo elasticsearch.yml de cada nó. Certifique-se de que:

cluster.name seja idêntico em todos os nós.
Cada nó tenha um node.name único (por exemplo, node-1, node-2).
network.host seja definido como um endereço IP acessível por outros nós.
discovery.seed_hosts liste os endereços de pelo menos um quórum de nós elegíveis a mestre.
cluster.initial_master_nodes inclua os nomes dos nós elegíveis a mestre iniciais apenas durante a primeira inicialização do cluster.

Exemplo para node-1:

cluster.name: meu-cluster-de-producao
node.name: node-1
node.roles: [ master, data ]
network.host: 192.168.1.100
http.port: 9200
transport.port: 9300
discovery.seed_hosts:
  - "192.168.1.100:9300"
  - "192.168.1.101:9300"
  - "192.168.1.102:9300"
cluster.initial_master_nodes:
  - "node-1"
  - "node-2"
  - "node-3"

Exemplo para node-2 (semelhante, com node.name: node-2):

cluster.name: meu-cluster-de-producao
node.name: node-2
node.roles: [ master, data ]
network.host: 192.168.1.101
http.port: 9200
transport.port: 9300
discovery.seed_hosts:
  - "192.168.1.100:9300"
  - "192.168.1.101:9300"
  - "192.168.1.102:9300"
cluster.initial_master_nodes:
  - "node-1"
  - "node-2"
  - "node-3"

5. Tamanho do Heap (`jvm.options`)

O Elasticsearch usa uma quantidade significativa de memória. O tamanho do heap da Máquina Virtual Java (JVM) é configurado no arquivo jvm.options (geralmente no diretório config/). Recomenda-se definir o tamanho mínimo e máximo do heap para o mesmo valor para evitar problemas de desempenho causados pelo redimensionamento do heap.

Melhor Prática: Defina o tamanho do heap para não mais que cerca de metade da RAM do sistema e deixe memória para o cache do sistema de arquivos. Evite heaps superdimensionados; muitas implantações permanecem abaixo do limite de ponteiros de objetos comuns compactados, que geralmente está na faixa de 30 GB, mas depende da JVM.

Exemplo (jvm.options):

-Xms4g
-Xmx4g

Isso define o tamanho inicial e máximo do heap para 4 gigabytes.

6. Alocação e Replicação de Fragmentos (`cluster.routing.*`)

Essas configurações controlam como os fragmentos são distribuídos e replicados entre os nós.

cluster.routing.allocation.disk.watermark.low, high, flood_stage: Limiares para evitar a alocação de fragmentos em discos que estão ficando sem espaço.
cluster.routing.allocation.enable: Controla a alocação de fragmentos (por exemplo, all, primaries, new_primaries, none).

Exemplo:

cluster.routing.allocation.disk.watermark.low: "85%"
cluster.routing.allocation.disk.watermark.high: "90%"
cluster.routing.allocation.disk.watermark.flood_stage: "95%"

Verificando a Saúde do Cluster

Depois que os nós forem iniciados, você pode verificar a saúde e o status do cluster usando a API de Saúde do Cluster.

curl -X GET "localhost:9200/_cluster/health?pretty"

Campos de saída principais:

status: green (todos os fragmentos alocados), yellow (algumas réplicas não atribuídas), red (alguns fragmentos primários não atribuídos).
number_of_nodes: O número total de nós no cluster.
number_of_data_nodes: O número de nós designados como nós de dados.
active_shards, relocating_shards, initializing_shards, unassigned_shards.

Dica: Busque um status green. Um status yellow indica que, embora seus dados estejam seguros (fragmentos primários alocados), você pode não ter réplicas suficientes para alta disponibilidade. Um status red significa que os dados estão em risco e requer atenção imediata.

Próximos Passos

Após configurar com sucesso seu cluster Elasticsearch, você normalmente prosseguirá para:

Criação de Índice: Defina como seus dados serão armazenados e organizados.
Mapeamento: Defina o esquema para seus documentos, especificando tipos de dados para campos.
Analisadores: Configure a análise de texto para pesquisa de texto completo eficaz.
Segurança: Implemente autenticação e autorização.

Este guia fornece a base essencial para um cluster Elasticsearch estável e de alto desempenho. O monitoramento contínuo e o ajuste com base em sua carga de trabalho específica são fundamentais para o sucesso a longo prazo.