Configurazione del Cluster Elasticsearch: Guida Passo-Passo

Configurare un cluster Elasticsearch riguarda principalmente fare alcune scelte iniziali correttamente: nomi dei nodi, discovery, ruoli, rete e memoria. Se queste basi sono sbagliate, il tuo cluster potrebbe formarsi in modo inaffidabile, esporsi sull'interfaccia sbagliata o avere difficoltà durante i riavvii dei nodi.

Questa guida illustra le impostazioni principali che dovresti rivedere prima di mettere Elasticsearch dietro carichi di lavoro reali. Gli esempi usano elasticsearch.yml e presuppongono un piccolo cluster a tre nodi, ma gli stessi controlli si applicano quando si scala.

Prerequisiti

Prima di immergerti nella configurazione, assicurati di avere quanto segue:

Runtime Java: Molte distribuzioni Elasticsearch includono un JDK integrato. Se fornisci il tuo runtime Java, controlla la matrice di supporto per la tua versione di Elasticsearch.
```
java -version
```
Risorse di Sistema: Alloca RAM, CPU e spazio su disco sufficienti per i tuoi nodi Elasticsearch. I requisiti esatti dipendono dal volume dei dati e dalla complessità delle query.
Accesso di Rete: Assicurati che i nodi possano comunicare tra loro sulle porte di trasporto configurate (il default è 9300).

Installazione

Sebbene questa guida si concentri sulla configurazione, un setup di successo inizia con un'installazione corretta. Elasticsearch può essere installato tramite gestori di pacchetti (apt, yum), scaricando l'archivio o usando Docker. Fai riferimento alla documentazione ufficiale di Elasticsearch per istruzioni di installazione dettagliate specifiche per il tuo sistema operativo o metodo di distribuzione.

File di Configurazione Principali

Il file di configurazione principale per Elasticsearch è elasticsearch.yml, tipicamente situato nella directory config/ della tua installazione Elasticsearch. Le impostazioni chiave all'interno di questo file determinano il comportamento del cluster.

Setup del Cluster: Direttive di Configurazione Chiave

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

Questa impostazione identifica in modo univoco il tuo cluster. Tutti i nodi nello stesso cluster devono condividere lo stesso cluster.name. Se non impostato, il default è elasticsearch.

Importanza: Essenziale affinché i nodi scoprano e si uniscano al cluster corretto. Cluster diversi nella stessa rete dovrebbero avere nomi distinti.
Esempio (elasticsearch.yml):
```
cluster.name: my-production-cluster
```

2. Ruolo del Nodo (`node.roles`)

Ai nodi Elasticsearch possono essere assegnati ruoli specifici per ottimizzare l'allocazione delle risorse e le prestazioni. I ruoli comuni includono master, data, ingest e ml. Per cluster più piccoli, un singolo nodo può avere più ruoli.

Nodo eleggibile a master: Responsabile di azioni a livello di cluster come creare/eliminare indici, tracciare i nodi e allocare shard. Si consiglia di avere nodi master dedicati in ambienti di produzione per stabilità.
```
node.roles: [ master ]
```
Nodo dati: Memorizza i dati ed esegue operazioni relative ai dati come indicizzazione e ricerca. I nodi dati dedicati sono cruciali per le prestazioni.
```
node.roles: [ data ]
```
Nodo di ingest: Utilizzato per il pre-processamento dei documenti prima dell'indicizzazione (ad esempio, usando pipeline di ingest).
```
node.roles: [ ingest ]
```
Nodo di Machine Learning: Esegue funzionalità di machine learning per il rilevamento di anomalie e altre attività.
```
node.roles: [ ml ]
```
Nodo solo di coordinamento: Gestisce richieste di ricerca e bulk ma non memorizza dati né partecipa all'elezione del master. Utile per scaricare carichi di query pesanti dai nodi dati o master.
```
node.roles: []
```

Buona Pratica: In produzione, dedica i nodi a ruoli specifici (ad esempio, separa i nodi master dai nodi dati) per una migliore tolleranza ai guasti e prestazioni. Per setup più piccoli, i nodi possono avere ruoli combinati.

3. Impostazioni di Rete (`network.host`, `http.port`, `transport.port`)

Queste impostazioni controllano come i tuoi nodi Elasticsearch comunicano.

network.host: L'indirizzo IP o hostname a cui il nodo si lega. Per cluster multi-nodo, imposta un indirizzo IP raggiungibile dagli altri nodi. Usare 0.0.0.0 si lega a tutte le interfacce di rete disponibili.
```
network.host: 192.168.1.100
# oppure
network.host: _site_
# oppure
network.host: 0.0.0.0
```
http.port: La porta per l'API REST HTTP (default: 9200).
```
http.port: 9200
```
transport.port: La porta per la comunicazione nodo-a-nodo (default: 9300).
```
transport.port: 9300
```

Attenzione: Fai attenzione alle regole del firewall per garantire che i nodi possano comunicare sulla transport.port.

4. Impostazioni di Discovery (`discovery.seed_hosts`, `cluster.initial_master_nodes`)

Queste impostazioni sono cruciali affinché i nodi trovino e si uniscano al cluster.

discovery.seed_hosts: Un elenco di indirizzi IP o hostname di altri nodi nel cluster a cui i nuovi nodi possono connettersi per scoprire il cluster.
```
discovery.seed_hosts:
  - "host1:9300"
  - "host2:9300"
  - "192.168.1.101:9300"
```
cluster.initial_master_nodes: Un elenco di nomi di nodi eleggibili a master utilizzato solo per avviare un cluster nuovo di zecca. Rimuovi questa impostazione dopo che il cluster si è formato. Lasciare impostazioni di bootstrap obsolete può causare confusione durante ricostruzioni successive o formazione accidentale del cluster.
```
cluster.initial_master_nodes:
  - "node-1"
  - "node-2"
  - "node-3"
```

Suggerimento: In ambienti cloud o reti dinamiche, considera l'uso di servizi come DNS o meccanismi di discovery del provider cloud.

Configurazione di un Cluster Multi-Nodo

Per configurare un cluster multi-nodo, configurerai il file elasticsearch.yml di ogni nodo. Assicurati che:

cluster.name sia identico su tutti i nodi.
Ogni nodo abbia un node.name univoco (ad esempio, node-1, node-2).
network.host sia impostato su un indirizzo IP raggiungibile dagli altri nodi.
discovery.seed_hosts elenchi gli indirizzi di almeno un quorum di nodi eleggibili a master.
cluster.initial_master_nodes includa i nomi dei nodi master iniziali solo durante il primo bootstrap del cluster.

Esempio per node-1:

cluster.name: my-production-cluster
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"

Esempio per node-2 (simile, con node.name: node-2):

cluster.name: my-production-cluster
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. Dimensione Heap (`jvm.options`)

Elasticsearch utilizza una quantità significativa di memoria. La dimensione heap della Java Virtual Machine (JVM) è configurata nel file jvm.options (di solito nella directory config/). Si consiglia di impostare la dimensione heap minima e massima allo stesso valore per evitare problemi di prestazioni causati dal ridimensionamento dell'heap.

Buona Pratica: Imposta la dimensione heap a non più della metà della RAM di sistema e lascia memoria per la cache del filesystem. Evita heap sovradimensionati; molte distribuzioni rimangono al di sotto della soglia degli ordinary object pointer compressi, che è comunemente intorno ai 30 GB ma dipende dalla JVM.

Esempio (jvm.options):

-Xms4g
-Xmx4g

Questo imposta sia la dimensione heap iniziale che massima a 4 gigabyte.

6. Allocazione e Replica degli Shard (`cluster.routing.*`)

Queste impostazioni controllano come gli shard vengono distribuiti e replicati tra i nodi.

cluster.routing.allocation.disk.watermark.low, high, flood_stage: Soglie per prevenire l'allocazione degli shard su dischi che stanno esaurendo lo spazio.
cluster.routing.allocation.enable: Controlla l'allocazione degli shard (ad esempio, all, primaries, new_primaries, none).

Esempio:

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

Verifica della Salute del Cluster

Una volta avviati i nodi, puoi controllare la salute e lo stato del cluster utilizzando l'API Cluster Health.

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

Campi di output chiave:

status: green (tutti gli shard allocati), yellow (alcune repliche non assegnate), red (alcuni shard primari non assegnati).
number_of_nodes: Il numero totale di nodi nel cluster.
number_of_data_nodes: Il numero di nodi designati come nodi dati.
active_shards, relocating_shards, initializing_shards, unassigned_shards.

Suggerimento: Punta a uno stato green. Uno stato yellow indica che, sebbene i tuoi dati siano al sicuro (gli shard primari sono allocati), potresti non avere repliche sufficienti per un'alta disponibilità. Uno stato red significa che i dati sono a rischio e richiedono attenzione immediata.

Prossimi Passi

Dopo aver configurato con successo il tuo cluster Elasticsearch, procederai tipicamente a:

Creazione dell'Indice: Definisci come i tuoi dati saranno memorizzati e organizzati.
Mapping: Definisci lo schema per i tuoi documenti, specificando i tipi di dati per i campi.
Analizzatori: Configura l'analisi del testo per una ricerca full-text efficace.
Sicurezza: Implementa autenticazione e autorizzazione.

Questa guida fornisce le basi essenziali per un cluster Elasticsearch stabile e performante. Il monitoraggio continuo e la messa a punto basata sul tuo carico di lavoro specifico sono fondamentali per il successo a lungo termine.