Warum läuft mein AWS Glue ETL-Job für eine lange Zeit?

Lösung

Zu den häufigen Faktoren, die dazu führen können, dass AWS Glue-Jobs sehr lange laufen, gehören Konfigurationseinstellungen und die Struktur der Daten und Skripte.

Die folgenden Schritte helfen bei der Optimierung der Leistung.

Metriken und Protokollierung einrichten

Verwende die integrierten Überwachungstools von AWS Glue, wie Amazon CloudWatch und Metriken zur Job-Beobachtbarkeit, um Probleme zu erkennen und die Leistung zu optimieren.

Richte außerdem Warnungen für Anomalien ein und aktiviere die Apache Spark-UI, um einen besseren Einblick in den AWS Glue-Job zu erhalten. Du kannst das Feature Einblicke in die Job-Ausführung von AWS Glue verwenden, um das Verhalten des Jobs während der Ausführung im Detail zu verstehen.

Führe einen der folgenden Schritte aus, um Metriken zu aktivieren.

Über AWS Glue-Konsole

1. Öffne die AWS Glue-Konsole.
2. Wähle im Navigationsbereich ETL Jobs aus.
3. Wähle den Job aus, für den du die Metriken aktivieren möchtest.
4. Wähle Aktion und dann Job bearbeiten aus.
5. Wähle auf der Registerkarte „Job-Details“ unter „Erweiterte Optionen“ die Optionen Job-Metriken, Metriken zur Job-Beobachtbarkeit, Kontinuierliche Protokollierung und Spark-UI aus.
6. Wähle Speichern aus.

Über CLI oder SDK

Hinweis: Wenn du beim Ausführen von AWS Command Line Interface (AWS CLI)-Befehlen Fehlermeldungen erhältst, findest du weitere Informationen dazu unter Problembehandlung bei der AWS CLI. Stelle außerdem sicher, dass du die neueste Version von AWS CLI verwendest.

Übergebe in den API-Aufrufen oder der CLI die folgenden Parameter im Parameter DefaultArguments:

'--enable-metrics' : 'true'
'--enable-observability-metrics' : 'true'
'--enable-continuous-cloudwatch-log' : 'true'
'--enable-spark-ui' : 'true'
'--spark-event-logs-path' : '<s3://path/to/log/>'

Engpässe identifizieren

Verwende Treiberprotokolle von CloudWatch, die durch den Job-Lauf generiert werden, oder verwende Spark-UI-Protokolle, um Engpässe zu finden. AWS Glue 3.0 und höher können schiefe Joins mit nativen Spark-Features wie AQE (Adaptive Query Execution, Adaptive Abfrageausführung) verarbeiten. Weitere Informationen findest du unter Web-UI auf der Apache-Website.

Treiberprotokolle

So überprüfst du Treiberprotokolle:

1. Öffne den Job in der AWS Glue-Konsole.
2. Wähle auf der Registerkarte Läufe den Joblauf aus, für den du die Protokolle prüfen möchtest.
3. Wähle in der CloudWatch-Protokollgruppe /aws-glue/jobs/error den Protokollstream aus, der denselben Namen wie die Job-Lauf-ID hat, für die du die Protokolle geöffnet hast. Suche nach Streams, deren Namen das Suffix „_g-xxxxxx“ enthalten – Dies sind die Executor-Protokolle.
4. Suche in den Treiberprotokollen nach Aufgaben, die sehr lange laufen, bevor sie abgeschlossen sind. Im folgenden Beispiel lief eine Aufgabe 34 Minuten lang, und der Spark-Job, für den diese Aufgabe erstellt wurde, endete nach 35 Minuten.

   2024-09-13 10:06:13,847 INFO [task-result-getter-0] scheduler.TaskSetManager (Logging.scala:logInfo(61)): Finished task 0.0 in stage 0.0 (TID 0) in 2054673 ms on 172.35.184.56 (executor 1) (1/1)
   2024-09-13 10:06:13,894 INFO [Thread-13] scheduler.DAGScheduler (Logging.scala:logInfo(61)): Job 0 finished: save at DataSink.scala:666, took 2164.67 s

Spark-UI-Protokolle

Suche in den Spark-UI-Protokollen auf den Registerkarten Jobs und Phasen nach Phasen und Aufgaben, die sehr lange liefen.

Engpässe beheben

Partitioniere Daten effizienter. AWS Glue-Jobs basieren auf verteilter Verarbeitung. Wenn die Daten nicht effizient partitioniert sind, müssen die Spark-Worker möglicherweise große, unausgewogene Partitionen verarbeiten. Diese Bearbeitungszeit führt zu Verzögerungen. Verwende die Funktionen repartition() oder coalesce() in Spark, um die Anzahl der Partitionen zu steuern. Stelle sicher, dass deine Daten gut aufgeteilt sind, um die verteilte Natur von Spark zu nutzen. Du kannst den AWS Glue DynamicFrame auch so konfigurieren, dass er Daten mit splitFields oder benutzerdefinierten Partitionsschlüsseln partitioniert.

Erhöhe die Kapazität, indem du Worker-Knoten hinzufügst. Wenn nicht genügend Worker-Knoten vorhanden sind, um die Datenmenge zu bewältigen, läuft der Job aufgrund der begrenzten Parallelität langsam. Erhöhe die Anzahl der Worker-Knoten, oder wechsle zu einem größeren Worker-Typ. Stelle sicher, dass du die richtige Worker-Größe verwendest und dass du genügend DPUs (Data Processing Units) zugewiesen hast, um die Daten effizient zu verarbeiten. Die Anzahl der Aufgaben, die pro Executor bearbeitet werden, entspricht dem Vierfachen der Anzahl der DPUs. Ein G.1X Worker-Typ hat beispielsweise eine DPU und bearbeitet vier Aufgaben pro Executor. Beachte, dass die Worker-Typen G.4X und G.8X nur für AWS Glue Version 3.0 oder höher Spark ETL-Jobs verfügbar sind.

Verteile die Daten neu, um die Schieflage zwischen den Partitionen zu verringern. Datenschieflage tritt auf, wenn die Partitionen sehr unterschiedliche Datenmengen aufweisen. Knoten mit mehr Daten werden überlastet, während andere im Leerlauf sind. Identifiziere schiefe Schlüssel durch Analyse der Datenverteilung. Verteile die Daten neu oder gleichmäßig auf die Partitionen, oder nutze die Salting-Technik, um die Hotkeys zu verteilen. AWS Glue 3.0 und höher können schiefe Joins mit nativen Spark-Features wie AQE (Adaptive Query Execution, Adaptive Abfrageausführung) auf der Apache-Website verarbeiten. Aktiviere dazu AQE und setze spark.sql.adaptive.skewJoin.enabled auf „true“ (wahr). AQE ist ab Spark 3.2.0 standardmäßig aktiviert. Füge einen Parameter spark.sql.adaptive.enabled hinzu, um AQE für Glue 3.0 zu aktivieren, und setze ihn auf true (wahr).

Ersetze UDFs durch native Spark-Funktionen. Benutzerdefinierte UDFs (User-Defined Functions, Benutzerdefinierte Funktionen) oder komplexe Transformationen können teuer in der Ausführung sein und Spark-Jobs verlangsamen. Vermeide UDFs, wenn möglich, und nutze native Spark-Funktionen, die für die Leistung optimiert sind. Wenn UDFs erforderlich sind, solltest du sie in Scala und nicht in Python neu schreiben, da UDFs in Scala oft besser funktionieren. Zur besseren Optimierung kannst du auch Transformationen mit DataFrames oder DynamicFrames durchführen.

Minimiere Shuffle-Operationen. Shuffle-Operationen, wie „groupBy“, „join“ oder „orderBy“, übertragen Daten über Knoten hinweg. Diese können zu Engpässen werden, wenn sie übermäßig genutzt oder nicht richtig verwaltet werden. Minimiere Shuffle-Operationen, indem du Daten so früh wie möglich im Transformationsprozess filterst und aggregierst. Verwende gegebenenfalls Broadcast-Joins, um unnötige Datenübertragungen zu vermeiden. Stelle außerdem sicher, dass die geshuffelten Daten effizient partitioniert sind.

Entferne nicht benötigtes Caching. Eine übermäßige oder unsachgemäße Verwendung des Caching kann zu einem erhöhten Speicherverbrauch führen und den Job verlangsamen. Verwende cache() oder persist() nur, wenn du einen Datensatz mehrmals in einem Workflow wiederverwendest. Beachte den verfügbaren Speicher und lösche alle im Cache gespeicherten Datensätze mit unpersist(), wenn diese Datensätze nicht mehr benötigt werden.

Unterbrich lange Abhängigkeitsketten. Wenn ein Job eine lange Kette von Transformationen enthält, berechnet Spark die gesamte Abhängigkeitskette neu. Diese Aktionen können die Verarbeitung verlangsamen. Teile komplexe Jobs in kleinere Aufgaben auf. Behalte bei Bedarf die Zwischenergebnisse bei. Dadurch verringert sich der Aufwand für die Neuberechnung, und du kannst die Leistung jedes einzelnen Schritts prüfen und überwachen.

Reduziere Netzwerklatenz und I/O-Operationen. Das Lesen und Schreiben von Daten in externe Quellen wie Amazon Simple Storage Service (Amazon S3), Amazon Relational Database Service (Amazon RDS) oder Amazon Redshift kann zu Latenzzeiten führen, insbesondere bei großen Datensätzen. Verwende die in AWS Glue integrierten Konnektoren. Speichere Daten in einem Format, das schnellere Lese- und Schreibvorgänge unterstützt, wie z. B. Parquet oder ORC. Aktiviere S3 Transfer Acceleration für schnellere Datenübertragungsraten, und verwende den AWS-Glue-Datenkatalog, um den Abruf von Metadaten zu optimieren.

Optimiere native Operationen. Glue-native Operationen, einschließlich Job-Lesezeichen und DynamoDB-Exportkonnektoren, können die Laufzeiten für einen AWS Glue-Job erhöhen. Identifiziere zur Überprüfung der Laufzeiten in den Treiberprotokollen, wann der AWS Glue-Job gestartet und wann der Job, der Aufgaben mit Lesezeichen versieht oder aus DynamoDB exportiert, beendet wurde. Prüfe bei DynamoDB auf Meldungen ähnlich dem folgenden Beispiel:

2024-08-24 03:33:37.000Z connections.DynamoExportConnection (DynamoExportConnection.scala:dynamodbexport(129)): Dynamodb Export complete...exported 712948751 item(s) or 4859215204353 byte(s)

Reduziere die Auswirkungen von Job-Lesezeichen

• Fasse kleine Dateien zu größeren zusammen, um die Anzahl der gescannten Dateien zu reduzieren.
• Entferne die Partitionen in einen Archivspeicherort, wenn die Verarbeitung bereits abgeschlossen ist.
• Verwende effiziente Partitionsstrategien, damit AWS Glue ganze Partitionen, die nicht geändert werden, überspringen kann.
• Verwende Pushdown-Prädikate, um Daten frühzeitig zu filtern.
• Schalte Job-Lesezeichen vorübergehend aus, wenn sie keinen Mehrwert für den Job-Prozess bringen.

Reduziere die Auswirkungen von DynamoDB-Konnektoren

• Reduziere, wenn möglich, das Volumen der exportierten Daten.
• Überwache DynamoDB und AWS Glue, um Probleme zu identifizieren die zu den Exportverzögerungen führen.
• Optimiere DynamoDB-Tabellenkonfigurationen, um die Exportzeiten zu verkürzen.
• Exportiere, wenn möglich, Daten außerhalb des Hauptjobs, oder passe die Zeitpläne an, um Engpässe zu vermeiden.

Ähnliche Informationen

Verwenden von Jobparametern in AWS Glue-Jobs

Überwachen von Jobs mithilfe der Apache Spark-Web-Benutzeroberfläche

Überwachung für die DPU-Kapazitätsplanung