Wie behebe ich Probleme mit hoher CPU-Auslastung in meinem OpenSearch Service-Cluster?

Kurzbeschreibung

Gehe wie folgt vor, um Probleme in Zusammenhang mit hoher CPU-Auslastung in deinem Cluster zu beheben:

• Verwende ein automatisiertes Runbook, um die Ursache für eine hohe CPU-Auslastung zu ermitteln.
• Verwende die Anomalieerkennung, um Muster zu identifizieren.
• Verwende die Nodes-Hot-Threads-API, um deine Ressourcennutzung zu verstehen.
• Überprüfe den Schreib-Vorgang oder den Sammel-API-Thread-Pool.
• Überprüfen Sie den Such-Thread-Pool.
• Überprüfe den Merge-Thread-Pool von Apache Lucene.
• Überprüfe den Speicherdruck der Java Virtual Machine (JVM).
• Überprüfe deine Shard-Strategie.
• Skaliere deinen Cluster.
• Optimiere deine Abfragen.

Es ist eine bewährte Methode, die CPU-Auslastung niedrig genug zu halten, damit OpenSearch Service seine Aufgaben ausführen kann. Bei einem Cluster mit konstant hoher CPU-Auslastung können Leistungsprobleme auftreten. OpenSearch Service reagiert nicht auf überlastete Cluster und du erhältst eine Timeout-Anfrage.

Lösung

Verwende ein automatisiertes Runbook

Voraussetzung: Stelle sicher, dass du über die erforderlichen AWS Identity and Access Management (IAM)-Berechtigungen verfügst, um das Runbook auszuführen. Weitere Informationen findest du in Erforderliche IAM-Berechtigungen in AWSSupport-TroubleshootOpenSearchHighCPU.

Führe das AWSSupport-TroubleshootOpenSearchHighCPU AWS Systems Manager Automation Runbook aus, um die hohe CPU-Auslastung in OpenSearch Service zu beheben.

Die Ausgabe zeigt die folgenden Informationen an:

• Hot Threads
• Laufende Aufgaben
• Thread-Pool-Statistiken für jeden Knoten in der Domain
• Informationen über die Knoten in der Domain, sortiert nach ihrer CPU-Auslastung
• Shard-Zuordnung zu jedem Datenknoten und seinem Festplattenspeicher
• Zustandsstatus und Informationen zum Zustand der OpenSearch-Service-Domain

Verwende die Runbook-Ausgabe, um die Ursache für die hohe CPU-Auslastung zu ermitteln.

Anomalieerkennung nutzen, um Muster zu identifizieren

Um potenzielle Probleme zu identifizieren, bevor sie zu Ausfällen führen, verwende die Anomalieerkennung in OpenSearch Service, um ungewöhnliche Muster in Metriken wie der CPU-Auslastung automatisch zu erkennen. Weitere Informationen findest du unter Tutorial: hohe CPU-Auslastung mit der Anomalieerkennung erkennen.

Verwende die Knoten-Hot-Threads-API

Wenn es in deinem OpenSearch Service-Cluster konstante CPU-Spitzen gibt, führe den folgenden Befehl aus, um Informationen für alle Knoten im Cluster anzuzeigen:

GET/_nodes/hot_threads

Die Länge deiner Ausgabe hängt davon ab, wie viele Knoten in deinem OpenSearch Service-Cluster ausgeführt werden. Weitere Informationen zur Node-Hot-Threads-API findest du unter Nodes-Hot-Threads-API auf der OpenSearch-Website.

Beispielausgabe:

GET _nodes/hot_threads
100.0% (131ms out of 500ms) cpu usage by thread 'opensearch[abc][search][T#62]'
10/10 snapshots sharing following 10
elements sun.misc.Unsafe.park(Native Method)
java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
java.util.concurrent.LinkedTransferQueue.awaitMatch(LinkedTransferQueue.java:737)

java.util.concurrent.LinkedTransferQueue.xfer(LinkedTransferQueue.java:647)

java.util.concurrent.LinkedTransferQueue.take(LinkedTransferQueue.java:1269)

org.opensearch.common.util.concurrent.SizeBlockingQueue.take(SizeBlockingQueue.java:162)

java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1067)

java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1127)

java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
java.lang.Thread.run(Thread.java:745)

Du kannst außerdem die Cat-Knoten-API verwenden, um die aktuelle Aufschlüsselung der Ressourcennutzung einzusehen. Führe den folgenden Befehl aus, um Knoten mit der höchsten CPU-Auslastung anzuzeigen:

GET _cat/nodes?v&s=cpu:desc

In der letzten Spalte der Ausgabe wird der Knotenname angezeigt. Weitere Informationen zur Cat-Nodes-API findest du unter CAT-Nodes-API auf der OpenSearch-Website.

Führe dann den folgenden Befehl für Knoten mit hoher CPU-Auslastung aus:

GET _nodes/node_id/hot_threads

Hinweis: Ersetze node_id durch die Knoten-ID.

Die Ausgabe zeigt die OpenSearch Service-Prozesse in dem Knoten, der die meiste CPU beansprucht. Wenn du in der Ausgabe einen Apache Lucene-Merge-Thread siehst, findest du Informationen zur Fehlerbehebung unter Überprüfe den Merge-Thread-Pool von Apache Lucene.

Beispielausgabe:

percentage of cpu usage by thread 'opensearch[nodeName][thread-name]'

Überprüfe den Schreibvorgang oder den Sammel-API-Thread-Pool

Wenn du eine „429" -Fehlermeldung erhältst, hat der Cluster möglicherweise zu viele Sammelindexanfragen. Wenn in deinem Cluster ständige CPU-Spitzen auftreten, lehnt OpenSearch Service die Sammelindexanfragen ab.

Der Schreib-Thread-Pool verwaltet Indexanfragen und umfasst Bulk-API-Vorgänge. Um zu überprüfen, ob deine Domain aufgrund zu vieler Sammelindexanfragen belastet ist, überprüfe die IndexingRate-Amazon CloudWatch-Metrik.

Wenn dein Cluster zu viele Sammelindexanfragen hat, ergreife die folgenden Maßnahmen:

• Reduziere die Anzahl der Sammelanfragen in deinem Cluster.
• Reduziere die Größe jede Sammelanfrage, damit deine Knoten sie effizienter verarbeiten können.
• Wenn Logstash verwendet wird, um Daten in deinen OpenSearch-Service-Cluster hochzuladen, reduziere die Batchgröße oder die Anzahl der Worker.
• Wenn sich die Aufnahmerate deines Clusters verlangsamt, skaliere deinen Cluster horizontal oder vertikal.

Überprüfe den Such-Thread-Pool

Ein Such-Thread-Pool, der eine hohe CPU verwendet, zeigt, dass Suchabfragen deinen OpenSearch Service-Cluster überfordern. Eine einzige zeitaufwendige Abfrage kann deinen Cluster überlasten. Eine Zunahme der Abfragen, die dein Cluster durchführt, kann sich auch auf deinen Such-Thread-Pool auswirken.

Führe den folgenden Befehl aus, um zu überprüfen, ob eine einzelne Abfrage deine CPU-Auslastung erhöht:

GET _tasks?actions=*search&detailed

Die Task-Management-API zeigt alle aktiven Suchabfragen an, die auf deinem Cluster ausgeführt werden. Weitere Informationen findest du unter List-Tasks-API auf der OpenSearch-Website.

Überprüfe in der Ausgabe das Feld Beschreibung, um die gerade ausgeführte Abfrage zu ermitteln. Das Feld running_time_in_nanos zeigt an, wie lange eine Abfrage ausgeführt wird.

Beispielausgabe:

{    "nodes": {
        "U4M_p_x2Rg6YqLujeInPOw": {
            "name": "U4M_p_x",
            "roles": [
                "data",
                "ingest"
            ],
            "tasks": {
                "U4M_p_x2Rg6YqLujeInPOw:53506997": {
                    "node": "U4M_p_x2Rg6YqLujeInPOw",
                    "id": 53506997,
                    "type": "transport",
                    "action": "indices:data/read/search",
                    "description": """indices[*], types[], search_type[QUERY_THEN_FETCH], source[{"size":10000,"query":{"match_all":{"boost":1.0}}}]""",
                    "start_time_in_millis": 1541423217801,
                    "running_time_in_nanos": 1549433628,
                    "cancellable": true,
                    "headers": {}
                }
            }
        }
    }
}

Hinweis: Bei Suchaufgaben enthält die Ausgabe der Task-Management-API nur das Feld „Beschreibung“.

Um deine CPU-Auslastung zu verringern, führe den folgenden Befehl aus, um die Suchabfrage mit hoher CPU abzubrechen:

POST _tasks/U4M_p_x2Rg6YqLujeInPOw:53506997/_cancel

Hinweis: Ersetze U4M_p_x2Rg6YqLujeInPOw:53506997 durch deine Aufgaben-ID.

Die vorherige Abfrage markiert die Aufgabe als abgebrochen und gibt dann die abhängigen AWS-Ressourcen frei. Wenn mehrere Abfragen auf deinem Cluster ausgeführt werden, verwende den POST-Befehl, um jede Abfrage abzubrechen, bis dein Cluster wieder in einen normalen Zustand zurückkehrt.

Es empfiehlt sich auch, im Abfragetext einen Timeout-Wert festzulegen, um hohe CPU-Spitzen zu vermeiden. Weitere Informationen findest du unter Sucheinstellungen auf der OpenSearch-Website. Ob die Anzahl der aktiven Abfragen gesunken ist, verrät dir die SearchRate-CloudWatch-Metrik.

Hinweis: Das gleichzeitige Abbrechen aller aktiven Suchanfragen in deinem OpenSearch-Service-Cluster kann zu Fehlern bei der Client-Anwendung führen.

Überprüfe den Merge-Thread-Pool von Apache Lucene

OpenSearch Service verwendet Apache Lucene, um Dokumente in deinem Cluster zu indizieren und zu durchsuchen. Wenn du neue Shard-Segmente erstellst, führt Apache Lucene Zusammenführungsvorgänge durch, um die effektive Anzahl von Segmenten zu reduzieren, die für jeden Shard benötigt werden, und um gelöschte Dokumente zu entfernen. Weitere Informationen findest du unter Einstellungen für das Zusammenführen auf der Elastic-Website.

Wenn sich ein Apache Lucene-Merge-Thread auf deine CPU-Auslastung auswirkt, führe den folgenden Befehl aus, um die Einstellung refresh_interval deiner Indizes zu erhöhen:

PUT /your-index-name/_settings
{
  "index": {
    "refresh_interval": "value"
  }
}

Hinweis: Ersetze value durch dein neues Anfragenintervall. Dieses Update verlangsamt die Erstellung von Cluster-Segmenten. Weitere Informationen findest du unter Refresh-Index-API auf der OpenSearch-Website.

Wenn ein Cluster Indizes in den UltraWarm-Speicher migriert, kann sich deine CPU-Auslastung erhöhen. Eine UltraWarm-Migration verwendet normalerweise einen Force-Merge-API-Vorgang, der die CPU intensiv auslasten kann. Weitere Informationen findest du unter Force-Merge-API auf der OpenSearch-Website.

Verwende den folgenden Befehl, um nach UltraWarm-Migrationen zu suchen:

GET _ultrawarm/migration/_status?v

Überprüfe den JVM-Speicherdruck

Überprüfe den Prozentsatz des JVM-Speicherdrucks des Java-Heaps in einem Cluster-Knoten. Im folgenden Beispielprotokoll bewegt sich die JVM innerhalb des empfohlenen Bereichs, der Cluster wird jedoch durch die zeitaufwendige Garbage Collection beeinträchtigt:

[2022-06-28T10:08:12,066][WARN ][o.o.m.j.JvmGcMonitorService] [515f8f06f23327e6df3aad7b2863bb1f] [gc][6447732] overhead, spent [9.3s]collecting in the last [10.2s]

Informationen zur Lösung von Problemen mit hohem JVM-Speicherdruck findest du unter Wie behebe ich einen hohen JVM-Speicherdruck in meinem OpenSearch Service-Cluster?

Shard-Strategie überprüfen

Je nach Clustergröße kann sich deine Cluster-Leistung aufgrund zu vieler Shards verringern. Es hat sich bewährt, 25 Shards pro GiB Java-Heap zu nutzen.

Standardmäßig hat OpenSearch Service eine Shard-Strategie von 5:1, wobei jeder Index fünf primäre Shards hat. Innerhalb jedes Indizes hat jeder primäre Shard sein eigenes Replikat. OpenSearch Service weist primäre Shards und Replikat-Shards automatisch separaten Datenknoten zu und stellt sicher, dass im Falle eines Fehlers ein Backup vorhanden ist.

Informationen zur Verteilung deiner Shards findest du unter Wie stelle ich die ungleichmäßige Shard-Verteilung in meinem OpenSearch-Service-Cluster wieder her?

Cluster skalieren

Stelle sicher, dass der Cluster über genügend CPU, Arbeitsspeicher und Festplattenspeicher für deine Anforderungen verfügt. Wenn deine Anwendung umfangreiche Abfragen oder häufige Schreibvorgänge durchführt, passe die Größe deines Clusters oder deiner Knoten an die Leistungsanforderungen an.

Verwende außerdem dedizierte Hauptknoten, um die Cluster-Stabilität und -Resilienz zu verbessern, insbesondere bei größeren Bereitstellungen. Diese Konfiguration entzieht den Datenknoten die Verantwortung für die Cluster-Verwaltung.

Abfragen optimieren

Starke Aggregationen, Platzhalterabfragen wie vorangestellte Platzhalter und Regex-Abfragen (regulärer Ausdruck) können zu Spitzen bei der CPU-Auslastung führen. Um diese Abfragen zu diagnostizieren, überprüfe deine langsamen OpenSearch-Protokolle.

Ähnliche Informationen

Wie kann ich die Indexierungsleistung in meinem OpenSearch Service-Cluster verbessern?

Wie behebe ich Ablehnungen von Such- oder Schreibanforderungen in OpenSearch Service?

OpenSearch Service-Domains dimensionieren