Anleitung zur Einrichtung eines hochverfügbaren Elasticsearch-Clusters

Elasticsearch ist eine leistungsstarke, verteilte Such- und Analyse-Engine, die auf Skalierbarkeit und Ausfallsicherheit ausgelegt ist. In Produktionsumgebungen ist die Gewährleistung eines kontinuierlichen Betriebs und der Fehlertoleranz von größter Bedeutung. Diese Anleitung führt Sie durch die wesentlichen Schritte zur Konfiguration mehrerer Elasticsearch-Knoten, um einen robusten, hochverfügbaren (HA) Cluster zu erstellen. Indem Sie diesen Anweisungen folgen, lernen Sie, wie Sie Ihren Cluster so einrichten, dass er Knotenausfälle übersteht und die Datenzugänglichkeit aufrechterhält, wodurch Ihre Anwendungen reaktionsschnell und Ihre Daten sicher bleiben.

Die Einrichtung eines hochverfügbaren Elasticsearch-Clusters erfordert eine sorgfältige Planung der Knotenrollen, der Netzwerkkonfiguration und der Datenreplikationsstrategien. Ziel ist es, Arbeitslast und Daten redundant auf mehrere Maschinen zu verteilen, um einzelne Fehlerquellen zu eliminieren. Dieser Artikel behandelt die Kernkonzepte, praktische Konfigurationsschritte und Best Practices, um Ihnen beim Aufbau einer resilienten Elasticsearch-Infrastruktur zu helfen, die für anspruchsvolle Produktionsanwendungsfälle geeignet ist.

Hochverfügbarkeit in Elasticsearch verstehen

Hochverfügbarkeit in Elasticsearch wird durch mehrere Schlüsselmechanismen erreicht:

Verteilte Architektur: Elasticsearch verteilt Daten und Operationen inhärent auf mehrere Knoten.
Knotenrollen (Node Roles): Verschiedene Knoten können unterschiedliche Zwecke erfüllen, was eine spezialisierte Ressourcenzuweisung und Fehlertrennung ermöglicht.
Shard-Replikation: Jeder Index ist in Shards unterteilt, und jeder primäre Shard kann einen oder mehrere Replica-Shards haben, die auf verschiedenen Knoten gespeichert sind.
Master-Knoten-Wahl (Master Node Election): Ein robuster Wahlprozess stellt sicher, dass ein Master-Knoten immer verfügbar ist, um den Cluster-Status zu verwalten.
Zen Discovery (Zen2): Dieses Modul übernimmt die Knotenerkennung und die Master-Wahl, wodurch sichergestellt wird, dass Knoten sich gegenseitig finden und zuverlässig einen Cluster bilden können.

Essentielle Knotenrollen

In einem HA-Setup ist das Verständnis der Knotenrollen entscheidend. Die primären Rollen für HA sind:

Master-fähige Knoten (Master-eligible nodes): Diese Knoten sind für die Verwaltung des Cluster-Status verantwortlich, einschließlich der Indexerstellung/-löschung, der Knotenverfolgung und der Shard-Zuweisung. Sie speichern keine Daten und bearbeiten Such-/Indexanfragen nicht direkt, es sei denn, sie haben auch die data-Rolle. Für HA sollten Sie eine ungerade Anzahl (typischerweise 3) dedizierter Master-fähiger Knoten haben, um ein Quorum zu bilden.
Datenknoten (Data nodes): Diese Knoten speichern Ihre indexierten Daten in Shards und führen datenbezogene Operationen wie Suche, Aggregation und Indizierung durch. Sie sind die Arbeitspferde Ihres Clusters.
Nur-Koordinierende Knoten (Coordinating-only nodes): (Optional) Diese Knoten können verwendet werden, um Anfragen weiterzuleiten, Such-Reduktionsphasen zu verarbeiten und die Bulk-Indizierung zu verwalten. Sie speichern keine Daten oder den Cluster-Status, können aber die Arbeitslast von Daten- und Master-Knoten entlasten.

Shards und Replicas

Elasticsearch speichert Ihre Daten in Shards. Jeder Index besteht aus einem oder mehreren primären Shards. Um Hochverfügbarkeit zu erreichen, sollten Sie einen oder mehrere Replica-Shards für jeden primären Shard konfigurieren. Replica-Shards sind Kopien von primären Shards. Wenn ein Knoten, der einen primären Shard hostet, ausfällt, kann ein Replica-Shard auf einem anderen Knoten zum neuen primären Shard hochgestuft werden, wodurch kein Datenverlust und ein kontinuierlicher Betrieb gewährleistet sind.

Voraussetzungen für die Einrichtung eines HA-Clusters

Bevor Sie mit der Konfiguration beginnen, stellen Sie sicher, dass Ihre Umgebung diese grundlegenden Anforderungen erfüllt:

Java Development Kit (JDK): Elasticsearch erfordert ein kompatibles JDK (typischerweise OpenJDK). Stellen Sie sicher, dass es auf allen Knoten installiert ist.
Systemressourcen: Weisen Sie jedem Knoten, insbesondere Datenknoten, ausreichend RAM (z.B. 8-32GB), CPU-Kerne und schnellen I/O-Festplattenspeicher (SSD empfohlen) zu.
Netzwerkkonfiguration: Alle Knoten müssen über bestimmte Ports miteinander kommunizieren können (Standard 9300 für die Inter-Knoten-Kommunikation, 9200 für die HTTP-API). Stellen Sie sicher, dass Firewalls entsprechend konfiguriert sind.
Betriebssystem: Eine stabile Linux-Distribution (z.B. Ubuntu, CentOS, RHEL) wird im Allgemeinen für Produktionsbereitstellungen bevorzugt.

Schritt-für-Schritt-Anleitung zur HA-Cluster-Einrichtung

Dieser Abschnitt beschreibt den Prozess der Installation und Konfiguration eines Multi-Node-Elasticsearch-Clusters.

Schritt 1: Elasticsearch auf allen Knoten installieren

Installieren Sie Elasticsearch auf jedem Server, der Teil Ihres Clusters sein wird. Sie können Paketmanager (APT für Debian/Ubuntu, YUM für RHEL/CentOS) verwenden oder das Archiv direkt herunterladen.

Beispiel (Debian/Ubuntu via APT):

wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/8.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-8.x.list
sudo apt update
sudo apt install elasticsearch

Nach der Installation aktivieren und starten Sie den Dienst (obwohl wir ihn zuerst konfigurieren werden).

sudo systemctl daemon-reload
sudo systemctl enable elasticsearch

Schritt 2: `elasticsearch.yml` auf jedem Knoten konfigurieren

Die Datei elasticsearch.yml, typischerweise unter /etc/elasticsearch/ zu finden, ist der Ort, an dem Sie die Einstellungen Ihres Clusters definieren. Bearbeiten Sie diese Datei auf jedem Knoten mit den entsprechenden Konfigurationen.

Allgemeine Konfiguration für alle Knoten

cluster.name: Dies muss für alle Knoten, die Sie demselben Cluster hinzufügen möchten, identisch sein.
yaml cluster.name: my-ha-cluster
node.name: Ein eindeutiger Name für jeden Knoten, hilfreich zur Identifizierung.
yaml node.name: node-1
network.host: Bindet Elasticsearch an eine bestimmte Netzwerkschnittstelle. Verwenden Sie 0.0.0.0, um an alle verfügbaren Schnittstellen zu binden, oder eine spezifische IP-Adresse.
yaml network.host: 0.0.0.0 # oder eine spezifische IP-Adresse für Sicherheits-/Multi-NIC-Setups # network.host: 192.168.1.101
http.port: Der Port für die HTTP-Client-Kommunikation (Standard 9200).
yaml http.port: 9200
transport.port: Der Port für die Inter-Knoten-Kommunikation (Standard 9300). Sollte konsistent sein.
yaml transport.port: 9300

Discovery-Einstellungen (Entscheidend für HA)

Diese Einstellungen teilen den Knoten mit, wie sie sich gegenseitig finden und einen Cluster bilden können.

discovery.seed_hosts: Eine Liste von Adressen der Master-fähigen Knoten in Ihrem Cluster. So entdecken Knoten anfängliche Master-fähige Knoten. Geben Sie die IP-Adressen oder Hostnamen aller Ihrer Master-fähigen Knoten an.
yaml discovery.seed_hosts: ["192.168.1.101", "192.168.1.102", "192.168.1.103"]
cluster.initial_master_nodes: Wird nur beim Bootstrapping eines brandneuen Clusters zum ersten Mal verwendet. Diese Liste sollte die node.name der Master-fähigen Knoten enthalten, die an der ersten Master-Wahl teilnehmen werden. Sobald der Cluster gebildet wurde, wird diese Einstellung ignoriert.
yaml cluster.initial_master_nodes: ["node-1", "node-2", "node-3"]
- Wichtiger Hinweis: Entfernen oder kommentieren Sie cluster.initial_master_nodes aus, nachdem der Cluster erfolgreich gebildet wurde, um unerwünschtes Verhalten zu verhindern, falls ein Knoten neu startet und versucht, einen neuen Cluster zu bilden.

Knotenrollen-Konfiguration

Geben Sie die Rolle(n) für jeden Knoten an. Ein typisches HA-Setup umfasst 3 dedizierte Master-Knoten und mehrere Datenknoten.

Master-fähige Knoten (z.B. node-1, node-2, node-3):
yaml node.roles: [master]
Datenknoten (z.B. node-4, node-5, node-6):
yaml node.roles: [data]
Knoten mit gemischten Rollen (nicht empfohlen für große HA-Produktionsumgebungen):
yaml node.roles: [master, data]
- Best Practice: Für echte Hochverfügbarkeit und Stabilität in der Produktion widmen Sie separate Knoten für Master- und Datenrollen. Dies isoliert kritische Master-Prozesse von ressourcenintensiven Datenoperationen.

Schritt 3: JVM-Heap-Größe konfigurieren

Bearbeiten Sie /etc/elasticsearch/jvm.options, um die JVM-Heap-Größe festzulegen. Eine gute Faustregel ist, 50 % des verfügbaren RAM zuzuweisen, jedoch niemals 30-32 GB zu überschreiten. Wenn ein Server beispielsweise 16 GB RAM hat, weisen Sie 8 GB zu:

-Xms8g
-Xmx8g

Schritt 4: Systemeinstellungen

Für die Produktion erhöhen Sie den Wert für vm.max_map_count und ulimit für offene Dateien auf allen Knoten. Fügen Sie diese Zeilen zu /etc/sysctl.conf hinzu und wenden Sie sie an (sudo sysctl -p).

vm.max_map_count=262144

Und in /etc/security/limits.conf (oder /etc/security/limits.d/99-elasticsearch.conf):

elasticsearch - nofile 65536
elasticsearch - memlock unlimited

Schritt 5: Elasticsearch-Dienste starten

Starten Sie den Elasticsearch-Dienst auf allen konfigurierten Knoten. Es wird oft empfohlen, zuerst die Master-fähigen Knoten zu starten, aber mit der modernen Discovery-Methode ist die Reihenfolge weniger kritisch, solange discovery.seed_hosts korrekt konfiguriert ist.

sudo systemctl start elasticsearch

Überprüfen Sie den Dienststatus und die Logs auf Fehler:

sudo systemctl status elasticsearch
sudo journalctl -f -u elasticsearch

Schritt 6: Cluster-Zustand überprüfen

Sobald alle Knoten laufen, überprüfen Sie den Cluster-Zustand über die Elasticsearch API. Sie können jeden Knoten im Cluster abfragen.

curl -X GET "localhost:9200/_cat/health?v&pretty"

Erwartete Ausgabe:

epoch      timestamp cluster        status node.total node.data shards pri relo init unassign pending_tasks max_task_wait_time active_shards_percent
1678886400 12:00:00  my-ha-cluster  green      6          3       0    0    0    0        0             0                  -                 100.0%

status: Sollte green (alle primären und Replica-Shards sind zugewiesen) oder yellow (alle primären Shards sind zugewiesen, aber einige Replica-Shards noch nicht) sein. red deutet auf ein ernstes Problem hin.
node.total: Sollte der Gesamtzahl der gestarteten Knoten entsprechen.
node.data: Sollte der Anzahl der Datenknoten entsprechen.

Überprüfen Sie die Knoten, um sicherzustellen, dass sie alle dem Cluster beigetreten sind:

curl -X GET "localhost:9200/_cat/nodes?v&pretty"

Erwartete Ausgabe (Beispiel für 3 Master-, 3 Datenknoten):

ip         heap.percent ram.percent cpu load_1m load_5m load_15m node.role   master name
192.168.1.101          21          87   0    0.00    0.01     0.05 m           *      node-1
192.168.1.102          20          88   0    0.00    0.01     0.05 m           -      node-2
192.168.1.103          22          86   0    0.00    0.01     0.05 m           -      node-3
192.168.1.104          35          90   1    0.10    0.12     0.11 d           -      node-4
192.168.1.105          32          89   1    0.11    0.13     0.10 d           -      node-5
192.168.1.106          30          91   1    0.12    0.10     0.09 d           -      node-6

Dies zeigt node-1 als gewählten Master (* unter der Spalte master) und andere Knoten als Teil des Clusters.

Schritt 7: Index-Sharding und Replikation konfigurieren

Für neu erstellte Indizes verwendet Elasticsearch standardmäßig einen primären Shard und eine Replik (index.number_of_shards: 1, index.number_of_replicas: 1). Für HA möchten Sie typischerweise mindestens eine Replik, was bedeutet, dass Ihre Daten auf mindestens zwei verschiedenen Knoten vorhanden sind. Dies stellt sicher, dass, wenn ein Knoten ausfällt, eine Replik an anderer Stelle verfügbar ist.

Beim Erstellen eines Indexes geben Sie diese Einstellungen an:

```bash
curl -X PUT "localhost:9200/my_ha_index?pretty" -H 'Content-Type: application/json' -d'
{
"settings": {
"index": {
"number_of_shards": 3