Wie kann ich eine hohe CPU-Auslastung auf meinem Amazon-OpenSearch-Service-Cluster beheben?

Kurzbeschreibung

Es ist eine bewährte Methode, Ihre CPU-Auslastung aufrechtzuerhalten, um sicherzustellen, dass OpenSearch Service über genügend Ressourcen verfügt, um seine Aufgaben auszuführen. Ein Cluster, der durchgehend bei hoher CPU-Auslastung arbeitet, kann die Clusterleistung beeinträchtigen. Wenn Ihr Cluster überlastet ist, reagiert OpenSearch Service nicht mehr, was zu einer Timeout-Anforderung führt.

Im Folgenden beschreiben wir einige Ansätze, um eine hohe CPU-Auslastung in Ihrem Cluster zu beheben:

• Verwenden Sie die Hotthread-API der Knoten. (Weitere Informationen finden Sie unter Hotthreads-API für Knoten auf der Elasticsearch-Website.)
• Überprüfen Sie den Schreibvorgang oder den Massen-API-Thread-Pool. (Weitere Informationen finden Sie unter Massen-API auf der Elasticsearch-Website.)
• Überprüfen Sie den Such-Thread-Pool. (Weitere Informationen finden Sie unter Thread-Pools auf der Elasticsearch-Website.)
• Überprüfen Sie den merge-Thread-Pool von Amazon Lucene. (Weitere Informationen finden Sie unter Zusammenführung auf der Elasticsearch-Website.)

Auflösung

Verwenden Sie die Hot-Thread-API der Knoten

Wenn es in Ihrem OpenSearch-Service-Cluster konstante CPU-Spitzen gibt, verwenden Sie die Hot-Threads-API des Knotens. Die Hot-Threads-API des Knotens fungiert als Task-Manager und zeigt Ihnen die Aufschlüsselung aller ressourcenintensiven Threads, die auf Ihrem Cluster ausgeführt werden.

Hier ist eine Beispielausgabe der Hot-Threads-API für Knoten:

GET _nodes/hot_threads

100.0% (131ms out of 500ms) cpu usage by thread 'opensearch[xxx][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)

Hinweis: Die Ausgabe des Hot-Threads für Knoten listet Informationen für jeden Knoten auf. Die Länge Ihrer Ausgabe hängt davon ab, wie viele Knoten in Ihrem OpenSearch-Service-Cluster ausgeführt werden.

Verwenden Sie außerdem die Cat-Knoten-API, um die aktuelle Aufschlüsselung der Ressourcenauslastung anzuzeigen. Sie können die Teilmenge der Knoten mit der höchsten CPU-Auslastung mit dem folgenden Befehl eingrenzen:

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

Die letzte Spalte in Ihrer Ausgabe zeigt den Namen Ihres Knotens an. Weitere Informationen finden Sie unter Cat-Knoten-API auf der Elasticsearch-Website.

Übergeben Sie dann den entsprechenden Knotennamen an Ihre Hot-Threads-API:

GET _nodes/<node-name>/hot_threads

Weitere Informationen finden Sie unter Hot-Threads-API auf der Elasticsearch-Website.

Die Ausgabe der Hot-Threads für Knoten sieht wie folgt aus:

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

Der Thread-Name gibt an, welche OpenSearch-Service-Prozesse eine hohe CPU verbrauchen.

Überprüfen Sie den Schreibvorgang oder den Massen-API-Thread-Pool

Ein 429-Fehler im OpenSearch Service kann darauf hinweisen, dass Ihr Cluster zu viele Massenindizierungsanforderungen verarbeitet. Wenn es in Ihrem Cluster konstante CPU-Spitzen gibt, lehnt OpenSearch Service die Massenindizierungsanforderungen ab.

Der write-Thread-Pool verarbeitet Indizierungsanforderungen, die Bulk-API-Operationen beinhalten. Um zu bestätigen, ob Ihr Cluster zu viele Massenindizierungsanforderungen verarbeitet, überprüfen Sie die IndexingRate-Metrik in Amazon CloudWatch.

Wenn Ihr Cluster zu viele Massenindizierungsanforderungen verarbeitet, sollten Sie die folgenden Ansätze in Betracht ziehen:

• Reduzieren Sie die Anzahl der Massenanforderungen in Ihrem Cluster.
• Reduzieren Sie die Größe jeder Massenanforderung, damit Ihre Knoten sie effizienter verarbeiten können.
• Wenn Logstash verwendet wird, um Daten in Ihren OpenSearch Service-Cluster zu übertragen, reduzieren Sie die Stapelgröße oder die Anzahl der Mitarbeiter.
• Wenn sich die Aufschlussrate Ihres Clusters verlangsamt, skalieren Sie Ihren Cluster (entweder horizontal oder vertikal). Um Ihren Cluster zu skalieren, erhöhen Sie die Anzahl der Knoten und den Instance-Typ, damit OpenSearch Service die eingehenden Anfragen ordnungsgemäß verarbeiten kann.

Überprüfen Sie den Such-Thread-Pool

Ein Such-Thread-Pool, der viel CPU verbraucht, zeigt an, dass Suchanfragen Ihren OpenSearch Service-Cluster überfordern. Ihr Cluster kann von einer einzigen lang andauernden Abfrage überfordert werden. Eine Zunahme der von Ihrem Cluster ausgeführten Abfragen kann sich auch auf Ihren search-Thread-Pool auswirken.

Verwenden Sie die Aufgabenverwaltungs-API, um zu überprüfen, ob eine einzelne Abfrage Ihre CPU-Auslastung erhöht. Beispiel:

GET _tasks?actions=*search&detailed

Die Aufgabenverwaltungs-API ruft alle aktiven Suchanfragen ab, die auf Ihrem Cluster ausgeführt werden. Weitere Informationen finden Sie unter Aufgabenverwaltungs-API auf der Elasticsearch-Website.

Hinweis: Die Ausgabe enthält nur dann das Beschreibungsfeld, wenn eine Suchaufgabe von der Aufgabenverwaltungs-API aufgeführt ist.

Hier ist eine 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": {}
                }
            }
        }
    }
}

Überprüfen Sie das Feld Beschreibung, um festzustellen, welche Abfrage genau ausgeführt wird. Das Feld running_time_in_nanos gibt an, wie lange eine Abfrage ausgeführt wurde. Brechen Sie die Suchanfrage ab, die viel CPU verbraucht, um Ihre CPU-Auslastung zu verringern. Die Aufgabenverwaltungs-API unterstützt auch einen Aufruf von _cancel.

Hinweis: Stellen Sie sicher, dass Sie die Aufgaben-ID aus Ihrer Ausgabe aufzeichnen, um eine bestimmte Aufgabe abzubrechen. In diesem Beispiel lautet die Aufgaben-ID „u4m_p_x2rg6YQLUJEINPOW:53506997".

Hier ist ein Beispiel für einen POST-Aufruf für die Aufgabenverwaltung:

POST _tasks/U4M_p_x2Rg6YqLujeInPOw:53506997/_cancel

Der POST-Aufruf für die Aufgabenverwaltung markiert die Aufgabe als „abgebrochen“ und gibt alle abhängigen AWS-Ressourcen frei. Wenn auf Ihrem Cluster mehrere Abfragen ausgeführt werden, verwenden Sie den POST-Aufruf, um Abfragen einzeln abzubrechen. Brechen Sie jede Abfrage ab, bis Ihr Cluster wieder in einen normalen Zustand zurückkehrt. Es ist auch eine bewährte Methode, einen korrekten Timeout-Wert im Abfragekörper festzulegen, um hohe CPU-Spitzen zu vermeiden. (Weitere Informationen finden Sie unter Suchparameter für Anforderungstext auf der Elasticsearch-Website.) Um zu überprüfen, ob die Anzahl der aktiven Abfragen gesunken ist, überprüfen Sie die SearchRate-Metrik in Amazon CloudWatch.

Hinweis: Das gleichzeitige Abbrechen aller aktiven Suchanfragen in Ihrem OpenSearch-Service-Cluster kann zu Fehlern auf der Seite der Clientanwendung führen.

Überprüfen Sie den Apache-Lucene-Zusammenführungs-Thread-Pool

OpenSearch Service verwendet Apache Lucene zum Indizieren und Suchen von Dokumenten in Ihrem Cluster. Apache Lucene führt Zusammenführungsvorgänge aus, um die effektive Anzahl von Segmenten zu reduzieren, die für jeden Shard benötigt werden, und um gelöschte Dokumente zu entfernen. Dieser Prozess wird immer dann ausgeführt, wenn neue Segmente in einem Shard erstellt werden.

Wenn Sie einen Apache Lucene-Zusammenführungs-Thread-Vorgang beobachten, der sich auf die CPU-Auslastung auswirkt, erhöhen Sie die refresh_interval-Einstellung Ihrer OpenSearch Service-Clusterindizes. Die Erhöhung der Einstellung refresh_interval verlangsamt die Segmenterstellung Ihres Clusters.

Hinweis: Ein Cluster, der Indizes auf UltraWarm-Speicher migriert, kann Ihre CPU-Auslastung erhöhen. Eine UltraWarm-Migration beinhaltet normalerweise einen Force-Merge-API-Vorgang, der CPU-intensiv sein kann.

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

GET _ultrawarm/migration/_status?v

---

Verwandte Informationen

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

Wie behebe ich Such- oder Schreibsperren bei Amazon OpenSearch Service?

Größenanpassung von Amazon-OpenSearch-Service-Domänen