Benchmarking von Elasticsearch: Werkzeuge und Techniken zur Leistungsvalidierung

Benchmarking von Elasticsearch beantwortet eine praktische Frage: Wird Ihr Cluster die Indizierungs- und Suchlast bewältigen, die Ihre Benutzer tatsächlich erzeugen? Ohne wiederholbare Tests können Sie einen warmen Cache, ein ruhiges Netzwerk oder eine glückliche Abfrageausführung fälschlicherweise für eine echte Leistungsverbesserung halten.

Der nützliche Benchmark ist derjenige, den Sie erneut ausführen können, nachdem Sie Mappings, Shard-Anzahlen, Hardware, JVM-Einstellungen oder Abfragecode geändert haben.

Warum Benchmarking unerlässlich ist

Benchmarking ist mehr als nur das Ausführen einiger weniger Abfragen. Es ist ein systematischer Prozess zur Messung der Leistung Ihres Elasticsearch-Clusters unter verschiedenen Arbeitslasten. Hier ist, warum es unverzichtbar ist:

Objektive Messung: Liefert quantifizierbare Daten zur Leistungsbewertung. Anstatt zu raten, wissen Sie genau, wie viel schneller oder langsamer eine Änderung war.
Identifizierung von Engpässen: Hilft, bestimmte Bereiche des Systems zu identifizieren, die die Leistung beeinträchtigen, wie z. B. langsame Abfragen, überlastete Knoten oder ineffiziente Indizierung.
Validierung von Optimierungen: Entscheidend, um zu bestätigen, dass Änderungen während der Leistungsoptimierung (z. B. Indexeinstellungen, Shard-Zuweisung, Hardware-Upgrades) die gewünschte Wirkung haben.
Kapazitätsplanung: Unterstützt Entscheidungen zur Skalierung Ihres Clusters, indem es seine aktuellen Grenzen und sein Verhalten unter zunehmender Last versteht.
Regressionstests: Stellt sicher, dass neue Code-Bereitstellungen oder Konfigurationsänderungen die Leistung nicht negativ beeinflussen.

Wichtige zu überwachende Metriken

Konzentrieren Sie sich beim Benchmarking auf Metriken, die direkt die Benutzererfahrung und die Systemgesundheit widerspiegeln. Diese können im Allgemeinen wie folgt kategorisiert werden:

Indizierungsmetriken

Indizierungsdurchsatz: Die Anzahl der pro Sekunde indizierten Dokumente. Höher ist im Allgemeinen besser.
Indizierungslatenz: Die Zeit, die ein Dokument benötigt, um nach der Indizierung durchsuchbar zu werden. Niedriger ist besser.
Auswirkung des Aktualisierungsintervalls: Wie sich Änderungen an der Einstellung refresh_interval auf die Indizierungsgeschwindigkeit und die Suchsichtbarkeit auswirken.

Suchmetriken

Suchdurchsatz: Die Anzahl der pro Sekunde verarbeiteten Suchanfragen.
Suchlatenz: Die Zeit, die benötigt wird, um auf eine Suchanfrage zu antworten. Diese wird oft unterteilt in:
- Gesamtlatenz: End-to-End-Zeit.
- Abfragelatenz: Zeit, die für die Ausführung der Suchabfrage selbst aufgewendet wird.
- Abruflatenz: Zeit, die für das Abrufen der tatsächlichen Dokumente aufgewendet wird.
Fehlerrate und Timeouts: Fehlgeschlagene Anfragen sind genauso wichtig wie schnelle erfolgreiche.

Metriken zur Cluster-Gesundheit

CPU-Auslastung: Hohe CPU kann auf ineffiziente Abfragen oder Indizierung hinweisen.
Speichernutzung: Entscheidend für den JVM-Heap und den OS-Dateisystem-Cache.
Festplatten-I/O: Engpässe hier können sowohl die Indizierung als auch die Suche erheblich beeinträchtigen.
Netzwerkverkehr: Wichtig in verteilten Umgebungen.
JVM-Heap-Nutzung: Überwacht die Garbage-Collection-Aktivität, die Pausen verursachen kann.

Beliebte Elasticsearch-Benchmarking-Tools

Mehrere Tools können bei der Simulation von Last und der Messung der Elasticsearch-Leistung helfen. Die Wahl des richtigen Tools hängt von Ihren spezifischen Anforderungen und Ihrem technischen Fachwissen ab.

1. Rally

Rally ist das offizielle Benchmarking-Tool für Elasticsearch. Es ist leistungsstark, flexibel und darauf ausgelegt, realistische Benutzerworkloads zu simulieren.

Hauptmerkmale:

Workload-Definition: Ermöglicht die Definition komplexer Indizierungs- und Suchaufgaben mit der Rally DSL.
Datengenerierung: Kann synthetische Daten generieren oder vorhandene Datensätze verwenden.
Metriksammlung: Sammelt detaillierte Leistungsmetriken während Testläufen.
Integration: Funktioniert nahtlos mit Elasticsearch und OpenSearch.

Beispiel: Ausführen eines grundlegenden Rally-Benchmarks

Rally führt normalerweise benannte Tracks und Challenges aus. Um einen Standard-Benchmark gegen einen vorhandenen lokalen Cluster auszuführen, beginnen Sie mit einem integrierten Track:

esrally race --pipeline=benchmark-only --target-hosts=localhost:9200 --track=geonames

Listen Sie verfügbare Tracks auf, bevor Sie einen auswählen:

esrally list tracks

Erstellen Sie für anwendungsspezifische Workloads einen benutzerdefinierten Rally-Track, der Ihre Mappings, Dokumente und häufigen Abfragen widerspiegelt. Vermeiden Sie Ad-hoc-JSON-Schnipsel, es sei denn, Sie haben sie gegen das Track-Format Ihrer Rally-Version geprüft.

2. Logstash oder Beats für Ingestion-Last

Obwohl in erster Linie ein Ingestion-Tool, kann Logstash für grundlegende Indizierungslast verwendet werden, wenn Sie die Pipeline testen möchten, die Elasticsearch speist.

Hauptmerkmale:

Eingabe-Plugins: Kann die Datenerfassung aus verschiedenen Quellen simulieren.
Ausgabe-Plugins: Das elasticsearch-Ausgabe-Plugin wird verwendet, um Daten an Elasticsearch zu senden.
Filterung: Ermöglicht die Datentransformation vor der Indizierung.

Beispiel: Simulieren der Indizierungslast

Sie können eine Logstash-Pipeline konfigurieren, um Zufallsdaten zu generieren und an Elasticsearch zu senden:

logstash_indexer.conf:

input {
  generator {
    count => 1000000
    type => "event"
  }
}

filter {
  mutate {
    add_field => {
      "timestamp" => "%{+YYYY-MM-dd'T'HH:mm:ss.SSSZ}"
      "message" => "Dies ist eine Test-Logmeldung %{random}"
    }
    remove_field => ["random", "host"]
  }
}

output {
  elasticsearch {
    hosts => ["localhost:9200"]
    index => "logstash-benchmark-%{+YYYY.MM.dd}"
    # Erwägen Sie die Verwendung der Bulk-API für eine bessere Leistung
    # Erwägen Sie die Festlegung von document_id für Upserts, falls erforderlich
  }
}

Führen Sie Logstash mit dieser Konfiguration aus:

bin/logstash -f logstash_indexer.conf

Überwachen Sie Elasticsearch- und Logstash-Logs sowie Cluster-Metriken, um die Leistung zu bewerten.

3. Benutzerdefinierte Skripte (Python, Java, etc.)

Für hochspezifische oder komplexe Szenarien ist das Schreiben benutzerdefinierter Skripte mit Elasticsearch-Clients eine praktikable Option.

Hauptmerkmale:

Maximale Flexibilität: Passen Sie die Lasterzeugung genau an die Abfragemuster und Indizierungsanforderungen Ihrer Anwendung an.
Client-Bibliotheken: Elasticsearch bietet offizielle Client-Bibliotheken für viele gängige Sprachen (Python, Java, Go, .NET, etc.).

Beispiel: Python-Skript für Suchlast

from elasticsearch import Elasticsearch
import time
import threading

# Konfigurieren Sie Ihre Elasticsearch-Verbindung
ES_HOST = "localhost:9200"
es = Elasticsearch([ES_HOST])

# Definieren Sie Ihre Suchabfrage
SEARCH_QUERY = {
    "query": {
        "match": {
            "content": "Beispieldaten"
        }
    }
}

NUM_THREADS = 10
QUERIES_PER_THREAD = 100

ergebnisse = []

def suche_durchfuehren():
    for _ in range(QUERIES_PER_THREAD):
        startzeit = time.time()
        try:
            antwort = es.search(index="my-index-*", body=SEARCH_QUERY, size=10)
            endzeit = time.time()
            ergebnisse.append({
                "latenz": (endzeit - startzeit) * 1000, # in Millisekunden
                "erfolg": True,
                "treffer": antwort['hits']['total']['value']
            })
        except Exception as e:
            endzeit = time.time()
            ergebnisse.append({
                "latenz": (endzeit - startzeit) * 1000,
                "erfolg": False,
                "fehler": str(e)
            })
        time.sleep(0.1) # Kleine Verzögerung zwischen Abfragen

threads = []
for i in range(NUM_THREADS):
    thread = threading.Thread(target=suche_durchfuehren)
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

# Ergebnisse analysieren
erfolgreiche_suchen = [r for r in ergebnisse if r['erfolg']]
fehlgeschlagene_suchen = [r for r in ergebnisse if not r['erfolg']]

if erfolgreiche_suchen:
    durchschnittslatenz = sum(r['latenz'] for r in erfolgreiche_suchen) / len(erfolgreiche_suchen)
    gesamttreffer = sum(r['treffer'] for r in erfolgreiche_suchen)
    print(f"Durchschnittliche Latenz: {durchschnittslatenz:.2f} ms")
    print(f"Gesamttreffer: {gesamttreffer}")
    print(f"Erfolgreiche Suchen: {len(erfolgreiche_suchen)}")
else:
    print("Keine erfolgreichen Suchen durchgeführt.")

if fehlgeschlagene_suchen:
    print(f"Fehlgeschlagene Suchen: {len(fehlgeschlagene_suchen)}")
    for r in fehlgeschlagene_suchen:
        print(f"  - Fehler: {r['fehler']} (Latenz: {r['latenz']:.2f} ms)")

Dieses Skript verwendet den Python-Client elasticsearch-py, um gleichzeitige Suchanfragen zu simulieren und deren Latenz zu messen.

Entwerfen wiederholbarer Lasttests

Um aussagekräftige Ergebnisse zu erhalten, müssen Ihre Lasttests wiederholbar und repräsentativ für Ihre tatsächlichen Nutzungsmuster sein.

1. Definieren Sie realistische Workloads

Indizierung: Wie hoch ist die Rate der Datenerfassung? Wie groß und komplex sind die Dokumente? Führen Sie eine Bulk-Indizierung oder eine Einzeldokument-Indizierung durch?
Suche: Was sind die typischen Abfragetypen (z. B. match, term, range, Aggregationen)? Wie komplex sind diese Abfragen? Wie hoch ist die erwartete Parallelität?
Datenverteilung: Wie sind Ihre Daten über Indizes und Shards verteilt? Verwenden Sie nach Möglichkeit eine produktionsähnliche Datenverteilung.

2. Legen Sie eine Basislinie fest

Bevor Sie Änderungen vornehmen, führen Sie Ihr ausgewähltes Benchmark-Tool aus, um eine Basisleistung zu ermitteln. Diese Basislinie ist Ihr Referenzpunkt für die Messung der Auswirkungen von Optimierungen.

3. Isolieren Sie Variablen

Nehmen Sie jeweils nur eine Änderung vor. Wenn Sie mehrere Optimierungen testen, führen Sie nach jeder einzelnen Änderung Benchmarks durch. Dies hilft Ihnen zu verstehen, welche spezifische Änderung zu einer Leistungsverbesserung (oder -verschlechterung) geführt hat.

4. Konsistente Umgebung

Stellen Sie sicher, dass die Testumgebung über Benchmark-Läufe hinweg so konsistent wie möglich ist. Dies beinhaltet:

Hardware: Verwenden Sie dieselben Knoten mit identischen Spezifikationen.
Software: Verwenden Sie dieselbe Elasticsearch-Version, JVM-Einstellungen und Betriebssystemkonfigurationen.
Netzwerk: Halten Sie konsistente Netzwerkbedingungen aufrecht.
Daten: Verwenden Sie denselben Datensatz oder dieselbe Datengenerierungsmethode.

5. Ausreichende Testdauer und Aufwärmphase

Aufwärmphase: Lassen Sie den Cluster vor Beginn der Messungen aufwärmen. Dies beinhaltet das Ausführen einer anfänglichen Last, um Caches zu füllen und die JVM zu stabilisieren.
Testdauer: Führen Sie Tests lange genug durch, um aussagekräftige Durchschnittswerte zu erfassen und etwaige vorübergehende Systemverhaltensweisen zu berücksichtigen. Kurze Tests können irreführend sein.

6. Überwachen Sie Systemressourcen

Überwachen Sie immer die Systemressourcen (CPU, RAM, Festplatten-I/O, Netzwerk) sowohl auf den Elasticsearch-Knoten als auch auf allen Client-Knoten, die die Benchmark-Tools ausführen. Dies hilft, Leistungsmetriken mit der Ressourcennutzung zu korrelieren und Engpässe zu identifizieren.

Best Practices für das Benchmarking

Automatisieren: Integrieren Sie Benchmarking in Ihre CI/CD-Pipeline, um Regressionen frühzeitig zu erkennen.
Einfach beginnen: Beginnen Sie mit grundlegenden Indizierungs- und Such-Benchmarks, bevor Sie zu komplexen Szenarien übergehen.
Verstehen Sie Ihre Daten: Die Art Ihrer Daten (Dokumentgröße, Feldtypen) hat erhebliche Auswirkungen auf die Leistung.
Berücksichtigen Sie die Indizierungsstrategie: Testen Sie verschiedene refresh_interval-, translog-Einstellungen und Shard-Größen.
Optimieren Sie Abfragen: Stellen Sie sicher, dass Ihre Suchabfragen effizient sind. Verwenden Sie die profile-API, um langsame Abfragen zu analysieren.
Überwachen Sie die JVM: Achten Sie genau auf Garbage-Collection-Logs und Heap-Nutzung.

Benchmarken Sie, was Sie tatsächlich ausführen werden

Benchmarken Sie Elasticsearch mit der gleichen Art von Daten, Mappings, Abfragen und Parallelität, die Ihre Produktionsworkload verwendet. Beginnen Sie mit einer Basislinie, ändern Sie eine Variable, führen Sie lange genug aus, um Aufwärm- und stationären Zustand einzuschließen, und halten Sie Knotenmetriken neben dem Benchmark-Bericht fest. Das liefert Ihnen Nachweise, die Sie für die Optimierung, Kapazitätsplanung und Regressionsprüfungen verwenden können.