DevOps-Tools & Best Practices meistern - DevOps Knowledge Hub DevOps-Tools & Best Practices meistern - DevOps Knowledge Hub

Leitfaden zur Einrichtung eines hochverfügbaren Elasticsearch-Clusters

Richten Sie einen hochverfügbaren Elasticsearch-Cluster mit Knotenrollen, Discovery, Replikaten, JVM-Größenanpassung und Gesundheitschecks ein.

Leitfaden zur Einrichtung eines hochverfügbaren Elasticsearch-Clusters

Elasticsearch kann bei Knotenausfällen verfügbar bleiben, aber nur, wenn Sie Master-Wahlen, Datenplatzierung, Replikate und Discovery korrekt planen. Ein Einzelknoten-Cluster mag in der Entwicklung funktionieren, kann Ihre Such-Workload jedoch nicht vor Host-Ausfällen schützen.

Dieser Leitfaden zeigt Ihnen, wie Sie einen hochverfügbaren Elasticsearch-Cluster mit dedizierten master-fähigen Knoten, Datenknoten, Shard-Replikaten und grundlegenden Validierungsbefehlen einrichten.

Hochverfügbarkeit in Elasticsearch verstehen

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

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

Wesentliche Knotenrollen

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

  • Master-fähige Knoten: Diese Knoten sind für die Verwaltung des Cluster-Status verantwortlich, einschließlich Indexerstellung/-löschung, Verfolgung von Knoten und Shard-Zuweisung. Sie speichern keine Daten und bearbeiten keine Such-/Indexierungsanfragen direkt, es sei denn, sie haben auch die Rolle data. Für HA sollten Sie eine ungerade Anzahl (typischerweise 3) dedizierter master-fähiger Knoten haben, um ein Quorum zu bilden.
  • Datenknoten: Diese Knoten speichern Ihre indizierten Daten in Shards und führen datenbezogene Operationen wie Suche, Aggregation und Indexierung durch. Sie sind die Arbeitspferde Ihres Clusters.
  • Nur koordinierende Knoten: (Optional) Diese Knoten können verwendet werden, um Anfragen zu routen, Such-Reduce-Phasen zu verarbeiten und Bulk-Indexierung zu verwalten. Sie halten keine Daten oder Cluster-Status, können aber Arbeit von Daten- und Master-Knoten auslagern.

Shards und Replikate

Elasticsearch speichert Ihre Daten in Shards. Jeder Index besteht aus einem oder mehreren primären Shards. Um Hochverfügbarkeit zu erreichen, sollten Sie ein oder mehrere Replikat-Shards für jeden primären Shard konfigurieren. Replikat-Shards sind Kopien von primären Shards. Wenn ein Knoten, der einen primären Shard hostet, ausfällt, kann ein Replikat-Shard auf einem anderen Knoten zum neuen primären Shard befördert werden, was Datenverlust verhindert und den fortlaufenden Betrieb sicherstellt.

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:

  • Elasticsearch-Pakete oder -Archive: Offizielle Pakete enthalten in neueren Elasticsearch-Versionen ein gebündeltes JDK. Wenn Ihre Installation ein separates JDK verwendet, stellen Sie sicher, dass es mit Ihrer Elasticsearch-Version kompatibel ist.
  • Systemressourcen: Weisen Sie ausreichend RAM (z. B. 8-32 GB), CPU-Kerne und schnellen Festplattenspeicher (SSD empfohlen) für jeden Knoten zu, insbesondere für Datenknoten.
  • Netzwerkkonfiguration: Alle Knoten müssen über bestimmte Ports (Standard 9300 für die Kommunikation zwischen Knoten, 9200 für die HTTP-API) miteinander kommunizieren können. Stellen Sie sicher, dass Firewalls entsprechend konfiguriert sind.
  • Betriebssystem: Eine stabile Linux-Distribution (z. B. Ubuntu, CentOS, RHEL) wird für Produktionsbereitstellungen im Allgemeinen 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 über 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

Aktivieren und starten Sie nach der Installation 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, die sich normalerweise in /etc/elasticsearch/ befindet, ist der Ort, an dem Sie die Einstellungen Ihres Clusters definieren. Bearbeiten Sie diese Datei auf jedem Knoten mit den entsprechenden Konfigurationen.

Gemeinsame Konfiguration für alle Knoten

  1. cluster.name: Dies muss für alle Knoten identisch sein, die demselben Cluster beitreten sollen.

    cluster.name: my-ha-cluster

  2. node.name: Ein eindeutiger Name für jeden Knoten, hilfreich zur Identifizierung.

    node.name: node-1

  3. network.host: Bindet Elasticsearch an eine bestimmte Netzwerkschnittstelle. Verwenden Sie 0.0.0.0, um an alle verfügbaren Schnittstellen zu binden, oder eine bestimmte IP-Adresse.

    network.host: 0.0.0.0
# oder eine bestimmte IP-Adresse für Sicherheit/Multi-NIC-Setups
# network.host: 192.168.1.101

  4. http.port: Der Port für die HTTP-Client-Kommunikation (Standard 9200).

    http.port: 9200

  5. transport.port: Der Port für die Kommunikation zwischen Knoten (Standard 9300). Sollte konsistent sein.

    transport.port: 9300

Discovery-Einstellungen (entscheidend für HA)

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

  1. discovery.seed_hosts: Eine Liste von Adressen master-fähiger 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.

    discovery.seed_hosts: ["192.168.1.101", "192.168.1.102", "192.168.1.103"]

  2. cluster.initial_master_nodes: Wird nur beim erstmaligen Bootstrapping eines brandneuen Clusters 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 ist, wird diese Einstellung ignoriert.

    cluster.initial_master_nodes: ["node-1", "node-2", "node-3"]
    • Wichtiger Tipp: Entfernen oder kommentieren Sie cluster.initial_master_nodes aus, nachdem der Cluster erfolgreich gebildet wurde. Setzen Sie es nicht für Neustarts oder zum Hinzufügen neuer Knoten erneut.

Konfiguration der Knotenrollen

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

  • Master-fähige Knoten (z. B. node-1, node-2, node-3):
    node.roles: [master]
  • Datenknoten (z. B. node-4, node-5, node-6):
    node.roles: [data]
  • Knoten mit gemischten Rollen (nicht empfohlen für große Produktions-HA):
    node.roles: [master, data]
    • Bewährte Praxis: Widmen Sie für echte Hochverfügbarkeit und Stabilität in der Produktion 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 Faustregel ist, 50 % des verfügbaren RAMs 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

Erhöhen Sie für die Produktion vm.max_map_count und das 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 master-fähige Knoten zu starten, aber mit modernem Discovery ist die Reihenfolge weniger kritisch, solange discovery.seed_hosts korrekt konfiguriert ist.

sudo systemctl start elasticsearch

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

sudo systemctl status elasticsearch
sudo journalctl -f -u elasticsearch

Schritt 6: Cluster-Health überprüfen

Sobald alle Knoten laufen, überprüfen Sie die Cluster-Health mit der 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 Replikat-Shards sind zugewiesen) oder yellow (alle primären Shards sind zugewiesen, aber einige Replikat-Shards noch nicht) sein. red weist 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 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 (* in der Spalte master) und andere Knoten als Teil des Clusters.

Schritt 7: Index-Sharding und Replikation konfigurieren

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

Geben Sie beim Erstellen eines Index diese Einstellungen an:

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

Wenn die Sicherheit aktiviert ist, verwenden Sie HTTPS und Anmeldeinformationen oder einen API-Schlüssel in Ihrem curl-Befehl. Zum Beispiel:

curl --cacert /etc/elasticsearch/certs/http_ca.crt -u elastic "https://localhost:9200/_cluster/health?pretty"

Betriebsprüfungen

Nachdem der Cluster grün ist, überprüfen Sie das Ausfallverhalten, bevor der Produktionsverkehr davon abhängt:

  • Stoppen Sie einen Datenknoten und bestätigen Sie, dass Replikate befördert werden und Primäre verfügbar bleiben.
  • Stoppen Sie den gewählten Master-Knoten und bestätigen Sie, dass ein anderer master-fähiger Knoten gewählt wird.
  • Überprüfen Sie _cat/shards?v auf nicht zugewiesene Shards, nachdem sich der Cluster beruhigt hat.
  • Bestätigen Sie, dass Clients über mehrere Knoten oder einen Load Balancer statt über einen einzelnen HTTP-Endpunkt verbinden.

Abschließende Erkenntnis

Elasticsearch-Hochverfügbarkeit ergibt sich aus drei praktischen Entscheidungen: Halten Sie ein zuverlässiges Master-Quorum aufrecht, platzieren Sie Shard-Replikate auf verschiedenen Knoten und machen Sie Clients widerstandsfähig gegen Knotenverluste. Beginnen Sie mit drei dedizierten master-fähigen Knoten, genügend Datenknoten, um primäre und Replikat-Shards zu halten, und einer getesteten Wiederherstellungsprozedur für Knotenneustarts und -ausfälle.