Pourquoi ma tâche ETL AWS Glue s'exécute-t-elle pendant une longue période ?

Résolution

Les facteurs courants susceptibles de provoquer l'exécution prolongée des tâches AWS Glue incluent les paramètres de configuration et la structure des données et des scripts.

Les étapes suivantes permettent d'optimiser les performances.

Configuration des métriques et de la journalisation

Pour identifier les problèmes et optimiser les performances, utilisez les outils de surveillance intégrés d'AWS Glue, tels qu'Amazon CloudWatch et les métriques d'observabilité des tâches.

Configurez également des alertes en cas d'anomalie et activez l'interface utilisateur Apache Spark pour mieux comprendre le fonctionnement de la tâche AWS Glue. Vous pouvez utiliser la fonctionnalité informations sur l’exécution de la tâche AWS Glue pour comprendre en détail le comportement de la tâche lors de son exécution.

Pour activer les métriques, effectuez l'une des opérations suivantes.

Depuis la console AWS Glue

1. Ouvrez la console AWS Glue.
2. Dans le volet de navigation, sélectionnez Tâches ETL.
3. Sélectionnez la tâche pour laquelle vous souhaitez activer les métriques.
4. Sélectionnez Action, puis Modifier la tâche.
5. Dans l'onglet Détails de la tâche, sous Options avancées, sélectionnez Métriques de tâche, Métriques d'observabilité de la tâche, Journalisation continue et Interface utilisateur Spark.
6. Sélectionnez Enregistrer.

Depuis la CLI ou le SDK

Remarque : Si des erreurs surviennent lorsque vous exécutez des commandes de l'interface de la ligne de commande AWS (AWS CLI), consultez la section Résoudre des erreurs liées à l’AWS CLI. Vérifiez également que vous utilisez bien la version la plus récente de l'interface.

À partir des appels d'API ou de la CLI, transmettez les paramètres suivants dans le paramètre 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/>'

Identifier les goulots d'étranglement

Pour identifier les goulots d'étranglement, utilisez les journaux de pilote CloudWatch générés par la tâche exécutée ou utilisez les journaux de l'interface utilisateur Spark. AWS Glue 3.0 et versions ultérieures peuvent gérer les jointures asymétriques grâce aux fonctionnalités natives de Spark, telles que l'exécution adaptative des requêtes (AQE). Pour plus d'informations, consultez la section Interface utilisateur Web sur le site Web d'Apache.

Journaux de pilote

Pour consulter les journaux de pilote :

1. Ouvrez la tâche depuis la console AWS Glue.
2. Dans l'onglet Exécutions, sélectionnez l'exécution de la tâche dont vous souhaitez consulter les journaux.
3. Dans le groupe de journaux CloudWatch /aws-glue/jobs/error, sélectionnez le flux de journaux qui porte le même nom que l'ID d'exécution de la tâche pour laquelle vous avez ouvert les journaux. Recherchez les flux dont le nom contient le suffixe « _g-xxxxxx ». Il s'agit des journaux du programme d’exécution.
4. Dans les journaux de pilote, recherchez les tâches qui s’exécutent depuis longtemps avant d’être terminées. Dans l'exemple suivant, une tâche a été exécutée pendant 34 minutes et la tâche Spark pour laquelle cette tâche a été créée s'est terminée en 35 minutes.

   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

Journaux de l'interface utilisateur Spark

Dans les journaux de l'interface utilisateur Spark, dans les onglets Tâches et Étapes, recherchez les étapes et les tâches qui ont été exécutées pendant une longue période.

Corriger les goulots d'étranglement

Partitionnez les données de manière plus efficace. Les tâches AWS Glue reposent sur un traitement distribué. Si les données ne sont pas partitionnées efficacement, les environnements de travail Spark peuvent être amenés à traiter de grandes partitions déséquilibrées. Ce délai de traitement entraîne des retards. Pour contrôler le nombre de partitions, utilisez les fonctions repartition() ou coalesce() de Spark. Assurez-vous que vos données sont correctement partitionnées pour tirer parti de la nature distribuée de Spark. Vous pouvez également configurer AWS Glue DynamicFrame pour partitionner les données avec splitFields ou des clés de partition personnalisées.

Augmentez la capacité en ajoutant des composants master. Si le nombre de composants master est insuffisant pour gérer le volume de données, la tâche s'exécute lentement en raison d'un parallélisme limité. Augmentez le nombre de composants master ou passez à un type d’environnement de travail plus important. Assurez-vous d'utiliser la taille d’environnement de travail appropriée et d'allouer suffisamment de DPU (unités de traitement des données) pour traiter vos données efficacement. Le nombre de tâches gérées par programme d’exécution est égal à quatre fois le nombre de DPU. Par exemple, un type d’environnement de travail G.1X possède un DPU et gère quatre tâches par programme d’exécution. Notez que les types d’environnements de travail G.4X et G.8X ne sont disponibles que pour les tâches Spark ETL d'AWS Glue version 3.0 ou ultérieure.

Redistribuez les données pour réduire l'asymétrie entre les partitions. L'asymétrie des données se produit lorsque les partitions contiennent des quantités de données sensiblement différentes. Les nœuds contenant plus de données sont surchargés alors que les autres sont inactifs. Identifiez les clés asymétriques en analysant la distribution des données. Redistribuez ou équilibrez les données entre les partitions, ou utilisez la technique du salting pour répartir les touches de raccourci. AWS Glue 3.0 et versions ultérieures peuvent gérer les jointures asymétriques grâce aux fonctionnalités natives de Spark, telles que l'exécution adaptative des requêtes (AQE) sur le site Web d’Apache. Pour cela, activez l'exécution adaptative des requêtes (AQE) et définissez spark.sql.adaptive.skewJoin.enabled sur vrai. AQE est activé par défaut à partir de Spark 3.2.0. Pour activer AQE pour Glue 3.0, ajoutez un paramètre spark.sql.adaptive.enabled et définissez-le sur vrai.

Remplacez les UDF par des fonctions Spark natives. Les fonctions définies par l'utilisateur (UDF) personnalisées ou les transformations complexes peuvent être coûteuses à exécuter et peuvent ralentir les tâches Spark. Évitez les UDF dans la mesure du possible et utilisez les fonctions natives de Spark optimisées pour les performances. Si des UDF sont nécessaires, réécrivez en Scala plutôt qu'en Python, car les UDF Scala sont souvent plus performantes. De plus, pour une meilleure optimisation, appliquez des transformations à l'aide de DataFrames ou de DynamicFrames.

Minimisez les opérations de shuffle. Les opérations de shuffle, telles que GroupBy, join ou OrderBy, transfèrent des données entre les nœuds. Ces dernières peuvent devenir des goulots d'étranglement si elles sont utilisées de manière excessive ou si elles ne sont pas gérées correctement. Minimisez les opérations de shuffle en filtrant et en regroupant les données le plus tôt possible dans le processus de transformation. Pour éviter tout transfert de données inutile, utilisez les jointures de diffusion, le cas échéant. Assurez-vous également que les données redistribuées sont partitionnées efficacement.

Éliminez toute mise en cache inutile. Une utilisation excessive ou inappropriée de la mise en cache peut entraîner une augmentation de la consommation de mémoire et ralentir la tâche. Utilisez cache() ou persist() uniquement lorsque vous réutilisez un jeu de données plusieurs fois dans un flux de travail. Notez la mémoire disponible et effacez tous les jeux de données mis en cache avec unpersist() lorsque ces derniers ne sont plus nécessaires.

Décomposez les longues chaînes de dépendance. Si votre tâche comporte une longue chaîne de transformations, Spark recalcule la totalité de la chaîne de dépendances. Ces actions peuvent ralentir le traitement. Décomposez les tâches complexes en tâches de plus petite taille. Si nécessaire, conservez les résultats intermédiaires. Cela réduit les frais de recalcul et vous permet de déboguer et de surveiller les performances de chaque étape individuellement.

Réduisez la latence du réseau et les opérations d'I/O. La lecture et l'écriture de données vers des sources externes telles qu'Amazon Simple Storage Service (Amazon S3), Amazon Relational Database Service (Amazon RDS) ou Amazon Redshift peuvent entraîner une latence, en particulier pour les grands jeux de données. Utilisez les connecteurs intégrés d'AWS Glue. Stockez les données dans un format permettant des lectures et des écritures plus rapides, tel que Parquet ou ORC. Activez S3 Transfer Acceleration pour accélérer les taux de transfert de données, et utilisez le catalogue de données AWS Glue pour optimiser la récupération des métadonnées.

Optimisez les opérations natives. Les opérations natives de Glue, notamment les signets de tâche et les connecteurs d'exportation DynamoDB, peuvent augmenter les temps d'exécution d'une tâche AWS Glue. Pour vérifier les temps d'exécution, identifiez dans les journaux de pilote quand la tâche AWS Glue a commencé et quand les tâches de mise en signet de la tâche ou l'exportation depuis DynamoDB ont pris fin. Pour DynamoDB, recherchez des messages similaires à l'exemple suivant :

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

Réduisez l'effet des signets de tâche

• Pour réduire le nombre de fichiers analysés, consolidez les petits fichiers en fichiers plus volumineux.
• Supprimez les partitions à un emplacement d'archivage lorsque le traitement est déjà terminé.
• Utilisez des stratégies de partitionnement efficaces afin qu'AWS Glue puisse ignorer des partitions entières qui ne sont pas modifiées.
• Pour filtrer les données au début du processus, utilisez des prédicats pushdown.
• Désactivez temporairement les signets de tâche s'ils n'apportent aucune valeur ajoutée au processus de travail.

Réduisez l'effet des connecteurs DynamoDB

• Dans la mesure du possible, réduisez le volume de données exportées.
• Pour identifier les problèmes à l'origine des retards d'exportation, surveillez DynamoDB et AWS Glue.
• Pour accélérer les délais d'exportation, optimisez les configurations de table DynamoDB.
• Dans la mesure du possible, exportez les données en dehors de la tâche principale ou ajustez les planifications pour éviter les goulots d’étranglement.

Informations connexes

Utilisation des paramètres de tâche dans les tâches AWS Glue

Surveillance des tâches à l’aide de l’interface utilisateur Web d’Apache Spark

Surveillance pour la planification des capacités du DPU