Elasticsearch-Cluster-Setup: Eine Schritt-für-Schritt-Konfigurationsanleitung

Das Einrichten eines Elasticsearch-Clusters besteht hauptsächlich darin, einige frühe Entscheidungen richtig zu treffen: Knotennamen, Discovery, Rollen, Netzwerk und Speicher. Wenn diese Grundlagen falsch sind, kann Ihr Cluster unzuverlässig werden, sich an der falschen Schnittstelle exponieren oder während Knotenneustarts Probleme verursachen.

Diese Anleitung führt durch die Kerneinstellungen, die Sie überprüfen sollten, bevor Sie Elasticsearch hinter echte Workloads setzen. Die Beispiele verwenden elasticsearch.yml und gehen von einem kleinen Drei-Knoten-Cluster aus, aber die gleichen Überprüfungen gelten, wenn Sie skalieren.

Voraussetzungen

Bevor Sie mit der Konfiguration beginnen, stellen Sie sicher, dass Folgendes vorhanden ist:

Java-Laufzeitumgebung: Viele Elasticsearch-Distributionen enthalten ein gebündeltes JDK. Wenn Sie eine eigene Java-Laufzeitumgebung bereitstellen, überprüfen Sie die Support-Matrix für Ihre Elasticsearch-Version.
```
java -version
```
Systemressourcen: Weisen Sie ausreichend RAM, CPU und Speicherplatz für Ihre Elasticsearch-Knoten zu. Die genauen Anforderungen hängen von Ihrem Datenvolumen und der Abfragekomplexität ab.
Netzwerkzugriff: Stellen Sie sicher, dass Knoten über die konfigurierten Transport-Ports (Standard ist 9300) miteinander kommunizieren können.

Installation

Während sich diese Anleitung auf die Konfiguration konzentriert, beginnt eine erfolgreiche Einrichtung mit einer korrekten Installation. Elasticsearch kann über Paketmanager (apt, yum), durch Herunterladen des Archivs oder mit Docker installiert werden. Lesen Sie die offizielle Elasticsearch-Dokumentation für detaillierte Installationsanweisungen, die für Ihr Betriebssystem oder Ihre Bereitstellungsmethode spezifisch sind.

Kernkonfigurationsdateien

Die primäre Konfigurationsdatei für Elasticsearch ist elasticsearch.yml, die sich normalerweise im config/-Verzeichnis Ihrer Elasticsearch-Installation befindet. Wichtige Einstellungen in dieser Datei bestimmen das Clusterverhalten.

Cluster-Setup: Wichtige Konfigurationsdirektiven

1. Clustername (`cluster.name`)

Diese Einstellung identifiziert Ihren Cluster eindeutig. Alle Knoten im selben Cluster müssen denselben cluster.name teilen. Wenn nicht gesetzt, lautet der Standardwert elasticsearch.

Wichtigkeit: Wesentlich, damit Knoten den richtigen Cluster finden und ihm beitreten können. Unterschiedliche Cluster im selben Netzwerk sollten unterschiedliche Namen haben.
Beispiel (elasticsearch.yml):
```
cluster.name: my-production-cluster
```

2. Knotenrolle (`node.roles`)

Elasticsearch-Knoten können bestimmte Rollen zugewiesen werden, um die Ressourcenzuweisung und Leistung zu optimieren. Häufige Rollen sind master, data, ingest und ml. Für kleinere Cluster kann ein einzelner Knoten mehrere Rollen haben.

Master-fähiger Knoten: Verantwortlich für clusterweite Aktionen wie das Erstellen/Löschen von Indizes, das Verfolgen von Knoten und das Zuweisen von Shards. Es wird empfohlen, in Produktionsumgebungen dedizierte Master-Knoten für Stabilität zu haben.
```
node.roles: [ master ]
```
Datenknoten: Speichert Daten und führt datenbezogene Operationen wie Indizierung und Suche durch. Dedizierte Datenknoten sind entscheidend für die Leistung.
```
node.roles: [ data ]
```
Ingest-Knoten: Wird für die Vorverarbeitung von Dokumenten vor der Indizierung verwendet (z. B. mit Ingest-Pipelines).
```
node.roles: [ ingest ]
```
Machine-Learning-Knoten: Führt Machine-Learning-Funktionen für Anomalieerkennung und andere Aufgaben aus.
```
node.roles: [ ml ]
```
Nur koordinierender Knoten: Bearbeitet Such- und Bulk-Anfragen, speichert jedoch keine Daten und nimmt nicht an der Master-Wahl teil. Nützlich, um schwere Abfragelasten von Daten- oder Master-Knoten zu entlasten.
```
node.roles: []
```

Best Practice: Widmen Sie in der Produktion Knoten bestimmten Rollen (z. B. separate Master-Knoten von Datenknoten) für eine bessere Fehlertoleranz und Leistung. Für kleinere Setups können Knoten kombinierte Rollen haben.

3. Netzwerkeinstellungen (`network.host`, `http.port`, `transport.port`)

Diese Einstellungen steuern, wie Ihre Elasticsearch-Knoten kommunizieren.

network.host: Die IP-Adresse oder der Hostname, an den der Knoten bindet. Für Multi-Node-Cluster setzen Sie dies auf eine IP-Adresse, die von anderen Knoten erreichbar ist. Die Verwendung von 0.0.0.0 bindet an alle verfügbaren Netzwerkschnittstellen.
```
network.host: 192.168.1.100
# oder
network.host: _site_
# oder
network.host: 0.0.0.0
```
http.port: Der Port für die HTTP-REST-API (Standard: 9200).
```
http.port: 9200
```
transport.port: Der Port für die Knoten-zu-Knoten-Kommunikation (Standard: 9300).
```
transport.port: 9300
```

Warnung: Achten Sie auf Firewall-Regeln, um sicherzustellen, dass Knoten auf dem transport.port kommunizieren können.

4. Discovery-Einstellungen (`discovery.seed_hosts`, `cluster.initial_master_nodes`)

Diese Einstellungen sind entscheidend, damit Knoten den Cluster finden und ihm beitreten können.

discovery.seed_hosts: Eine Liste von IP-Adressen oder Hostnamen anderer Knoten im Cluster, mit denen neue Knoten eine Verbindung herstellen können, um den Cluster zu entdecken.
```
discovery.seed_hosts:
  - "host1:9300"
  - "host2:9300"
  - "192.168.1.101:9300"
```
cluster.initial_master_nodes: Eine Liste von Master-fähigen Knotennamen, die nur zum Bootstrappen eines brandneuen Clusters verwendet werden. Entfernen Sie diese Einstellung, nachdem der Cluster gebildet wurde. Das Belassen veralteter Bootstrap-Einstellungen kann bei späteren Neuerstellungen oder versehentlicher Clusterbildung zu Verwirrung führen.
```
cluster.initial_master_nodes:
  - "node-1"
  - "node-2"
  - "node-3"
```

Tipp: Ziehen Sie in Cloud-Umgebungen oder dynamischen Netzwerken die Verwendung von Diensten wie DNS oder Cloud-Provider-Discovery-Mechanismen in Betracht.

Konfiguration eines Multi-Node-Clusters

Um einen Multi-Node-Cluster einzurichten, konfigurieren Sie die elasticsearch.yml-Datei jedes Knotens. Stellen Sie sicher, dass:

cluster.name auf allen Knoten identisch ist.
Jeder Knoten einen eindeutigen node.name hat (z. B. node-1, node-2).
network.host auf eine IP-Adresse gesetzt ist, die von anderen Knoten erreichbar ist.
discovery.seed_hosts die Adressen von mindestens einem Quorum von Master-fähigen Knoten auflistet.
cluster.initial_master_nodes die Namen der anfänglichen Master-fähigen Knoten nur während des ersten Cluster-Bootstraps enthält.

Beispiel für 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"

Beispiel für node-2 (ähnlich, mit 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. Heap-Größe (`jvm.options`)

Elasticsearch verwendet eine erhebliche Menge an Speicher. Die Java Virtual Machine (JVM) Heap-Größe wird in der Datei jvm.options (normalerweise im config/-Verzeichnis) konfiguriert. Es wird empfohlen, die minimale und maximale Heap-Größe auf denselben Wert zu setzen, um Leistungsprobleme durch Heap-Größenänderungen zu vermeiden.

Best Practice: Setzen Sie die Heap-Größe auf nicht mehr als etwa die Hälfte des System-RAM und lassen Sie Speicher für den Dateisystem-Cache übrig. Vermeiden Sie überdimensionierte Heaps; viele Bereitstellungen bleiben unter der Schwelle für komprimierte gewöhnliche Objektzeiger, die normalerweise im Bereich von niedrigen 30 GB liegt, aber von der JVM abhängt.

Beispiel (jvm.options):

-Xms4g
-Xmx4g

Dies setzt sowohl die anfängliche als auch die maximale Heap-Größe auf 4 Gigabyte.

6. Shard-Zuweisung und Replikation (`cluster.routing.*`)

Diese Einstellungen steuern, wie Shards auf Knoten verteilt und repliziert werden.

cluster.routing.allocation.disk.watermark.low, high, flood_stage: Schwellenwerte, um die Shard-Zuweisung auf Datenträgern zu verhindern, denen der Speicherplatz ausgeht.
cluster.routing.allocation.enable: Steuert die Shard-Zuweisung (z. B. all, primaries, new_primaries, none).

Beispiel:

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

Überprüfung der Cluster-Gesundheit

Sobald die Knoten gestartet sind, können Sie die Gesundheit und den Status des Clusters mit der Cluster-Health-API überprüfen.

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

Wichtige Ausgabefelder:

status: green (alle Shards zugewiesen), yellow (einige Replikate nicht zugewiesen), red (einige primäre Shards nicht zugewiesen).
number_of_nodes: Die Gesamtzahl der Knoten im Cluster.
number_of_data_nodes: Die Anzahl der als Datenknoten designierten Knoten.
active_shards, relocating_shards, initializing_shards, unassigned_shards.

Tipp: Streben Sie einen green-Status an. Ein yellow-Status zeigt an, dass Ihre Daten zwar sicher sind (primäre Shards sind zugewiesen), Ihnen aber möglicherweise ausreichende Replikate für Hochverfügbarkeit fehlen. Ein red-Status bedeutet, dass Daten gefährdet sind und sofortige Aufmerksamkeit erfordern.

Nächste Schritte

Nach erfolgreicher Einrichtung Ihres Elasticsearch-Clusters werden Sie in der Regel fortfahren mit:

Index-Erstellung: Definieren, wie Ihre Daten gespeichert und organisiert werden.
Mapping: Definieren des Schemas für Ihre Dokumente, Angabe von Datentypen für Felder.
Analysatoren: Konfigurieren der Textanalyse für eine effektive Volltextsuche.
Sicherheit: Implementieren von Authentifizierung und Autorisierung.

Diese Anleitung bietet die wesentliche Grundlage für einen stabilen und leistungsfähigen Elasticsearch-Cluster. Kontinuierliche Überwachung und Anpassung basierend auf Ihrer spezifischen Arbeitslast sind der Schlüssel zum langfristigen Erfolg.