Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Surveillance des tâches Spark AWS Glue **Topics** + [ ## Spark Metrics est disponible dans AWS Glue Studio ](#console-jobs-details-metrics-spark) + [ # Surveillance des tâches à l’aide de l’interface utilisateur web Apache Spark ](monitor-spark-ui.md) + [ # Surveillance à l'aide AWS Glue d'informations sur l'exécution des tâches ](monitor-job-insights.md) + [ # Surveillance avec Amazon CloudWatch ](monitor-cloudwatch.md) + [ # Surveillance et débogage des tâches ](monitor-profile-glue-job-cloudwatch-metrics.md) ## Spark Metrics est disponible dans AWS Glue Studio L'onglet **Metrics (Métriques)** montre les métriques collectées lorsqu'une tâche s'exécute et que le profilage est activé. Les graphiques suivants sont affichés dans les tâches Spark : + Déplacement de données ETL + Profil de la mémoire : pilote et programmes d'exécution Choisissez **View Additional Metrics (Afficher des métriques supplémentaires)** pour afficher les graphiques suivants : + Déplacement de données ETL + Profil de la mémoire : pilote et programmes d'exécution + Remaniement de données sur les programmes d'exécution + Chargement de l'UC : pilote et programmes d'exécution + Exécution de tâche : programmes d'exécution actifs, étapes achevées et nombre de programmes d'exécution maximum nécessaires Les données de ces graphiques sont transférées vers CloudWatch des métriques si la tâche est configurée pour collecter des métriques. Pour plus d'informations sur l'activation de métriques et l'interprétation de graphiques, veuillez consulter [Surveillance et débogage des tâches](monitor-profile-glue-job-cloudwatch-metrics.md). **Example Graphique du déplacement de données ETL** Le graphique du Déplacement de données ETL montre les métriques suivantes : + Le nombre d'octets lus à partir d'Amazon S3 par tous les programmes d'exécution—[`glue.ALL.s3.filesystem.read_bytes`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes) + Le nombre d'octets écrits à partir d'Amazon S3 par tous les programmes d'exécution – [`glue.ALL.s3.filesystem.write_bytes`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes) ![\[Le graphique du déplacement de données ETL dans l'onglet Métriques de la console AWS Glue.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/job_detailed_etl.png) **Example Graphique du profil de mémoire** Le graphique du profil de la mémoire montre les métriques suivantes : + La portion de mémoire utilisée par la pile de la JVM pour ce pilote (mise à l'échelle : 0-1) par le pilote, un programme d'exécution identifié par *executorId* ou tous les exécuteurs – + [`glue.driver.jvm.heap.usage`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.jvm.heap.usage) + [`glue.executorId.jvm.heap.usage`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.jvm.heap.usage) + [`glue.ALL.jvm.heap.usage`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage) ![\[Le graphique du profil de la mémoire dans l'onglet Métriques de la console AWS Glue.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/job_detailed_mem.png) **Example Graphique de remaniement de données sur les programmes d'exécution** Le graphique de remaniement de données sur les programmes d'exécution montre les métriques suivantes : + Le nombre d'octets lus par tous les programmes d'exécution pour remanier des données sur ceux-ci - [`glue.driver.aggregate.shuffleLocalBytesRead`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleLocalBytesRead) + Le nombre d'octets écrits par tous les programmes d'exécution pour remanier des données sur ceux-ci - [`glue.driver.aggregate.shuffleBytesWritten`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleBytesWritten) ![\[Le graphique de brassage de données sur les programmes d'exécution dans l'onglet Métriques de la console AWS Glue.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/job_detailed_data.png) **Example Graphique de chargement de l'UC** Le graphique de chargement de l'UC montre les métriques suivantes : + La fraction de la charge du système CPU utilisée (mise à l'échelle : 0-1) par le pilote, un programme d'exécution identifié par *executorId* ou tous les exécuteurs – + [`glue.driver.system.cpuSystemLoad`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.system.cpuSystemLoad) + [`glue.executorId.system.cpuSystemLoad`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.system.cpuSystemLoad) + [`glue.ALL.system.cpuSystemLoad`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.system.cpuSystemLoad) ![\[Le graphique de la charge du système CPU dans l'onglet Métriques de la console AWS Glue.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/job_detailed_cpu.png) **Example Graphique d'exécution de tâche** Le graphique d'exécution de tâche montre les métriques suivantes : + Le nombre de programmes d'exécution actifs en cours d'exécution - [`glue.driver.ExecutorAllocationManager.executors.numberAllExecutors`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberAllExecutors) + Le nombre d'étapes terminées - [`glue.aggregate.numCompletedStages`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.numCompletedStages) + Le nombre maximum de programmes d'exécution nécessaires - [`glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors) ![\[Le graphique de l'exécution de tâche dans l'onglet Métriques de la console AWS Glue.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/job_detailed_exec.png) # Surveillance des tâches à l’aide de l’interface utilisateur web Apache Spark Vous pouvez utiliser l’interface utilisateur web Apache Spark pour surveiller et déboguer les tâches ETL AWS Glue en cours d’exécution sur le système de tâches AWS Glue, ainsi que les applications Spark en cours d’exécution sur les points de terminaison de développement AWS Glue. L’interface utilisateur Spark vous permet de vérifier les éléments suivants pour chaque tâche : + La chronologie des événements de chaque phase Spark + Un graphe orienté acyclique (DAG) de la tâche + Les plans physiques et logiques des requêtes SparkSQL + Les variables environnementales Spark sous-jacentes pour chaque tâche Pour plus d'informations sur l'utilisation de l'interface utilisateur web Spark, consultez l'[Interface utilisateur web](https://spark.apache.org/docs/3.3.0/web-ui.html) dans la documentation Spark. Pour obtenir des conseils sur la façon d'interpréter les résultats de l'interface utilisateur Spark afin d'améliorer les performances de votre tâche, consultez les [meilleures pratiques en matière de réglage des performances AWS Glue pour les tâches Apache Spark](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/introduction.html) dans le guide AWS prescriptif. Vous pouvez voir l'interface utilisateur de Spark dans la AWS Glue console. Ceci est disponible lorsqu'une AWS Glue tâche s'exécute sur des versions AWS Glue 3.0 ou ultérieures avec des journaux générés au format standard (plutôt qu'ancien), qui est le format par défaut pour les nouvelles tâches. Si vos fichiers journaux sont supérieurs à 0,5 Go, vous pouvez activer la prise en charge des journaux progressifs pour les exécutions de tâches sur les versions AWS Glue 4.0 ou ultérieures afin de simplifier l'archivage, l'analyse et le dépannage des journaux. Vous pouvez activer l'interface utilisateur Spark à l'aide de la AWS Glue console ou du AWS Command Line Interface (AWS CLI). Lorsque vous activez l’interface utilisateur Spark, les tâches ETL AWS Glue et les applications Spark sur les points de terminaison de développement AWS Glue peuvent sauvegarder les journaux d’événements Spark dans un emplacement que vous spécifiez dans Amazon Simple Storage Service (Amazon S3). Vous pouvez utiliser les journaux d’événements sauvegardés dans Amazon S3 avec l’interface utilisateur Spark à la fois en temps réel, lorsque la tâche est en cours de fonctionnement, et une fois celle-ci terminée. Tant que les journaux restent dans Amazon S3, l'interface utilisateur Spark de la AWS Glue console peut les consulter. ## Permissions Pour utiliser l'interface utilisateur Spark dans la AWS Glue console, vous pouvez utiliser `UseGlueStudio` ou ajouter tous les services individuels APIs. Tous APIs sont nécessaires pour utiliser complètement l'interface utilisateur Spark, mais les utilisateurs peuvent accéder aux fonctionnalités de SparkUI en ajoutant son service APIs dans leur autorisation IAM pour un accès détaillé. `RequestLogParsing` est la plus essentielle, car elle effectue l’analyse des journaux. Le reste APIs est destiné à la lecture des données analysées respectives. Par exemple, `GetStages` permet d’accéder aux données relatives à toutes les étapes d’une tâche Spark. La liste des services Spark UI APIs `UseGlueStudio` mappés se trouve ci-dessous dans l'exemple de politique. La politique ci-dessous permet d’utiliser uniquement les fonctionnalités de l’interface utilisateur de Spark. Pour ajouter d'autres autorisations, telles qu'Amazon S3 et IAM, consultez la section [Création de politiques IAM personnalisées](https://docs.aws.amazon.com/glue/latest/dg/getting-started-min-privs.html#getting-started-all-gs-privs.html) pour. AWS Glue Studio La liste des services Spark UI APIs mappés se `UseGlueStudio` trouve ci-dessous dans l'exemple de politique. Lorsque vous utilisez une API de service de l’interface utilisateur de Spark, utilisez l’espace de noms suivant : `glue:`. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowGlueStudioSparkUI", "Effect": "Allow", "Action": [ "glue:RequestLogParsing", "glue:GetLogParsingStatus", "glue:GetEnvironment", "glue:GetJobs", "glue:GetJob", "glue:GetStage", "glue:GetStages", "glue:GetStageFiles", "glue:BatchGetStageFiles", "glue:GetStageAttempt", "glue:GetStageAttemptTaskList", "glue:GetStageAttemptTaskSummary", "glue:GetExecutors", "glue:GetExecutorsThreads", "glue:GetStorage", "glue:GetStorageUnit", "glue:GetQueries", "glue:GetQuery" ], "Resource": [ "*" ] } ] } ``` ------ ## Limitations + L'interface utilisateur Spark de la AWS Glue console n'est pas disponible pour les exécutions de tâches effectuées avant le 20 novembre 2023 car elles sont dans l'ancien format de journal. + L'interface utilisateur Spark de la AWS Glue console prend en charge les journaux AWS Glue évolutifs pour la version 4.0, tels que ceux générés par défaut dans les tâches de streaming. La somme maximale de tous les fichiers d’événement du journal propagé est de 2 Go. Pour les AWS Glue tâches ne prenant pas en charge les journaux cumulés, la taille maximale du fichier journal des événements pris en charge par SparkUI est de 0,5 Go. + L’interface utilisateur de Spark sans serveur n’est pas disponible pour les journaux d’événements Spark stockés dans un compartiment Amazon S3 auquel seul votre VPC peut accéder. ## Exemple : interface utilisateur web Apache Spark Cet exemple vous montre comment utiliser l’interface utilisateur Spark pour comprendre vos performances pour la tâche. Les captures d’écran montrent l’interface utilisateur web Spark telle que fournie par un serveur d’historique Spark autogéré. L'interface utilisateur Spark de la AWS Glue console fournit des vues similaires. Pour plus d'informations sur l'utilisation de l'interface utilisateur web Spark, consultez l'[Interface utilisateur web](https://spark.apache.org/docs/3.3.0/web-ui.html) dans la documentation Spark. Voici un exemple d’application Spark qui lit à partir de deux sources de données, effectue une transformation de jointure et écrit le tout dans Amazon S3 au format Parquet. ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job from pyspark.sql.functions import count, when, expr, col, sum, isnull from pyspark.sql.functions import countDistinct from awsglue.dynamicframe import DynamicFrame args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME']) df_persons = spark.read.json("s3://awsglue-datasets/examples/us-legislators/all/persons.json") df_memberships = spark.read.json("s3://awsglue-datasets/examples/us-legislators/all/memberships.json") df_joined = df_persons.join(df_memberships, df_persons.id == df_memberships.person_id, 'fullouter') df_joined.write.parquet("s3://aws-glue-demo-sparkui/output/") job.commit() ``` La visualisation DAG suivante montre les différentes phases de cette tâche Spark. ![\[Capture d’écran de l’interface utilisateur Spark montrant 2 phases terminées pour la tâche 0.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/spark-ui1.png) La chronologie d’événements suivante pour une tâche montre le début, l’exécution et la résiliation de différents exécuteurs Spark. ![\[Capture d’écran de l’interface utilisateur Spark montrant les phases terminées, en échec et actives des différents exécuteurs Spark.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/spark-ui2.png) L’écran suivant montre les détails des plans de requête SparkSQL : + Plan logique analysé + Plan logique d’analyse + Plan logique optimisé + Plan physique d’exécution ![\[Plans de requête SparkSQL : plans logiques analysé, d'analyse et optimisé et plan physique d'exécution.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/spark-ui3.png) **Topics** + [ ## Permissions ](#monitor-spark-ui-limitations-permissions) + [ ## Limitations ](#monitor-spark-ui-limitations) + [ ## Exemple : interface utilisateur web Apache Spark ](#monitor-spark-ui-limitations-example) + [ # Activation de l’interface utilisateur web Apache Spark pour les tâches AWS Glue ](monitor-spark-ui-jobs.md) + [ # Lancement du serveur d'historique Spark ](monitor-spark-ui-history.md) # Activation de l’interface utilisateur web Apache Spark pour les tâches AWS Glue Vous pouvez utiliser l’interface utilisateur web Apache Spark pour surveiller et déboguer les tâches ETL AWS Glue en cours d’exécution sur le système de tâches AWS Glue. Vous pouvez configurer l’interface utilisateur Spark à l’aide de la console AWS Glue ou de l’ AWS Command Line Interface (AWS CLI). Toutes les 30 secondes, AWS Glue sauvegarde les journaux d’événements Spark à l’emplacement correspondant au chemin Amazon S3 que vous spécifiez. **Topics** + [ ## Configuration de l’interface utilisateur Spark (console) ](#monitor-spark-ui-jobs-console) + [ ## Configuration de l’interface utilisateur Spark (AWS CLI) ](#monitor-spark-ui-jobs-cli) + [ ## Configuration de l’interface utilisateur Spark pour des sessions utilisant des blocs-notes ](#monitor-spark-ui-sessions) + [ ## Activer les journaux propagés ](#monitor-spark-ui-rolling-logs) ## Configuration de l’interface utilisateur Spark (console) Suivez ces étapes pour configurer l’interface utilisateur Spark à l’aide de la AWS Management Console. Lors de la création d'une AWS Glue tâche, l'interface utilisateur Spark est activée par défaut. **Pour activer l’interface utilisateur Spark lorsque vous créez ou modifiez une tâche** 1. Connectez-vous à la AWS Glue console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/). 1. Dans le volet de navigation, sélectionnez **Tâches**. 1. Choisissez **Ajouter une tâche** ou sélectionnez-en une existante. 1. Dans **Détails de la tâche**, ouvrez les **Propriétés avancées**. 1. Sous l’onglet **Interface utilisateur Spark**, choisissez **Écrire des journaux de l’interface utilisateur Spark sur Amazon S3**. 1. Spécifiez un chemin Amazon S3 pour stocker les journaux d’événements Spark pour la tâche. Notez que si vous utilisez une configuration de sécurité dans la tâche, le chiffrement s’applique également au fichier journal de l’interface utilisateur Spark. Pour de plus amples informations, veuillez consulter [Chiffrement des données écrites par AWS Glue](encryption-security-configuration.md). 1. Dans la **Configuration de journalisation et de surveillance de l’interface utilisateur Spark** : + Sélectionnez **Standard** si vous générez des journaux à afficher dans la AWS Glue console. + Sélectionnez **Hérité** si vous générez des journaux à afficher sur un serveur d’historique Spark. + Vous pouvez également choisir de générer les deux. ## Configuration de l’interface utilisateur Spark (AWS CLI) Pour générer des journaux à consulter avec l'interface utilisateur de Spark, dans la AWS Glue console, utilisez le AWS CLI pour transmettre les paramètres de tâche suivants aux AWS Glue tâches. Pour de plus amples informations, veuillez consulter [Utilisation des paramètres des tâches dans les tâches AWS Glue](aws-glue-programming-etl-glue-arguments.md). ``` '--enable-spark-ui': 'true', '--spark-event-logs-path': 's3://s3-event-log-path' ``` Pour distribuer les journaux dans leurs anciens emplacements, définissez le paramètre `--enable-spark-ui-legacy-path` sur `"true"`. Si vous ne souhaitez pas générer de journaux dans les deux formats, supprimez le paramètre `--enable-spark-ui`. ## Configuration de l’interface utilisateur Spark pour des sessions utilisant des blocs-notes **Avertissement** AWS Glue les sessions interactives ne prennent actuellement pas en charge l'interface utilisateur Spark dans la console. Configurez un serveur d’historique Spark. Si vous utilisez des AWS Glue blocs-notes, configurez la configuration de SparkUI avant de démarrer la session. Pour ce faire, utilisez le magic cellulaire de `%%configure` : ``` %%configure { “--enable-spark-ui”: “true”, “--spark-event-logs-path”: “s3://path” } ``` ## Activer les journaux propagés L'activation de SparkUI et des fichiers d'événements du journal continu pour les AWS Glue tâches présentent plusieurs avantages : + Fichiers journaux d'événements continus : lorsque les fichiers journaux d'événements sont activés, des fichiers journaux distincts sont AWS Glue générés pour chaque étape de l'exécution de la tâche, ce qui facilite l'identification et le dépannage des problèmes spécifiques à une étape ou à une transformation en particulier. + Meilleure gestion des journaux : les fichiers d’événement du journal propagé permettent de gérer plus efficacement les fichiers journaux. Au lieu d’avoir un seul fichier journal potentiellement volumineux, les journaux sont divisés en fichiers plus petits et plus faciles à gérer en fonction des étapes d’exécution des tâches. Cela peut simplifier l’archivage, l’analyse et le dépannage des journaux. + Tolérance aux pannes améliorée — Si une AWS Glue tâche échoue ou est interrompue, les fichiers d'événements du journal continu peuvent fournir des informations précieuses sur la dernière étape réussie, ce qui permet de reprendre plus facilement la tâche à partir de ce point plutôt que de repartir de zéro. + Optimisation des coûts : en activant les fichiers d’événement du journal propagé, vous pouvez économiser sur les coûts de stockage associés aux fichiers journaux. Au lieu de stocker un seul fichier journal potentiellement volumineux, vous stockez des fichiers journaux plus petits et plus faciles à gérer, ce qui peut être plus rentable, en particulier pour les tâches complexes ou de longue durée. Dans un nouvel environnement, les utilisateurs peuvent activer explicitement les journaux propagés via : ``` '—conf': 'spark.eventLog.rolling.enabled=true' ``` or ``` '—conf': 'spark.eventLog.rolling.enabled=true —conf spark.eventLog.rolling.maxFileSize=128m' ``` Lorsque les journaux propagés sont activés, `spark.eventLog.rolling.maxFileSize` spécifie la taille maximale du fichier journal des événements avant qu’il ne soit reporté. La valeur par défaut de ce paramètre facultatif, s’il n’est pas spécifié, est de 128 Mo. Le minimum est de 10 Mo. La somme maximale de tous les fichiers d’événement du journal propagé est de 2 Go. Pour les AWS Glue tâches sans support de journalisation continue, la taille maximale du fichier journal des événements pris en charge par SparkUI est de 0,5 Go. Vous pouvez désactiver les journaux propagés pour une tâche de streaming en fournissant une configuration supplémentaire. Notez que la maintenance de fichiers journaux très volumineux peut coûter cher. Pour désactiver les journaux propagés, fournissez la configuration suivante : ``` '--spark-ui-event-logs-path': 'true', '--conf': 'spark.eventLog.rolling.enabled=false' ``` # Lancement du serveur d'historique Spark Vous pouvez utiliser un serveur d’historique Spark pour visualiser les journaux Spark sur votre propre infrastructure. Vous pouvez voir les mêmes visualisations dans la AWS Glue console pour les exécutions de AWS Glue tâches sur les versions AWS Glue 4.0 ou ultérieures avec des journaux générés au format standard (plutôt qu'ancien). Pour de plus amples informations, veuillez consulter [Surveillance des tâches à l’aide de l’interface utilisateur web Apache Spark](monitor-spark-ui.md). Vous pouvez lancer le serveur d'historique Spark à l'aide d'un AWS CloudFormation modèle hébergeant le serveur sur une instance EC2, ou le lancer localement à l'aide de Docker. **Topics** + [ ## Lancement du serveur d'historique Spark et affichage de l'interface utilisateur de Spark à l'aide de AWS CloudFormation ](#monitor-spark-ui-history-cfn) + [ ## Lancement du serveur d'historique Spark et affichage de l'interface utilisateur Spark à l'aide de Docker ](#monitor-spark-ui-history-local) ## Lancement du serveur d'historique Spark et affichage de l'interface utilisateur de Spark à l'aide de AWS CloudFormation Vous pouvez utiliser un AWS CloudFormation modèle pour démarrer le serveur d'historique Apache Spark et afficher l'interface utilisateur Web de Spark. Ces modèles sont des exemples que vous devez modifier pour répondre à vos besoins. **Pour démarrer le serveur d'historique Spark et afficher l'interface utilisateur de Spark à l'aide de CloudFormation** 1. Choisissez l'un des boutons **Launch Stack** (Lancer la pile) du tableau suivant. Cela lance la pile sur la CloudFormation console. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitor-spark-ui-history.html) 1. Sur la page **Specify template** (Spécifier un modèle), choisissez **Next** (Suivant). 1. Sur la page **Specify stack details (Spécifier les détails de la pile)**, entrez le **nom de la pile (Stack name)**. Saisissez des informations supplémentaires sous **Paramètres**. 1. **Configuration de l'interface utilisateur Spark** Saisissez les informations suivantes : + **IP address range (Plage d'adresses IP)** – Plage d'adresses IP pouvant être utilisée pour afficher l'interface utilisateur Spark. Pour limiter l'accès à partir d'une plage d'adresses IP spécifique, vous devez utiliser une valeur personnalisée. + **History server port (Historique du serveur)** – Port de l'interface utilisateur Spark. Vous pouvez utiliser la valeur par défaut. + **Event log directory (Répertoire des journaux d'événements)** – Choisissez l'emplacement où les journaux d'événements Spark sont stockés en provenance de la tâche AWS Glue ou des points finaux de développement. Vous devez utiliser **s3a://** pour le schéma de chemin des journaux d'événements. + **Spark package location (Emplacement du package Spark)** – Vous pouvez utiliser la valeur par défaut. + Chemin du **keystore : chemin** du SSL/TLS keystore pour HTTPS. Si vous souhaitez utiliser un fichier de magasin de clés personnalisé, vous pouvez spécifier le chemin S3 `s3://path_to_your_keystore_file` ici. Si vous laissez ce paramètre vide, un magasin de clés auto-signé basé sur un certificat est généré et utilisé. + **Mot de passe KeyStore** — Saisissez le mot de passe du magasin de clés SSL/TLS pour HTTPS. 1. **Configuration des instances EC2** Saisissez les informations suivantes : + **Instance type (Type d'instance)** – Type d'instance Amazon EC2 qui héberge le serveur d'historique Spark. Étant donné que ce modèle lance une instance Amazon EC2 dans votre compte, le coût d'Amazon EC2 sera facturé séparément dans votre compte. + **Latest AMI ID (Dernier ID AMI)** – ID AMI d'Amazon Linux 2 pour l'instance du serveur d'historique Spark. Vous pouvez utiliser la valeur par défaut. + **VPC ID (ID VPC)** – ID du cloud privé virtuel (VPC) pour l'instance du serveur d'historique Spark. Vous pouvez utiliser n'importe lequel des éléments VPCs disponibles dans votre compte. Il n'est pas recommandé d'utiliser un VPC [par défaut avec une ACL réseau par défaut](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html#default-network-acl). Pour plus d'informations, veuillez consulter les rubriques [VPC par défaut et sous-réseaux par défaut](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html) et [Créer un VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#Create-VPC) dans le *Guide de l'utilisateur Amazon VPC*. + **Subnet ID (ID de sous-réseau)** – ID de l'instance du serveur d'historique Spark. Vous pouvez utiliser n'importe quel sous-réseau de votre VPC. Vous devez être en mesure d'atteindre le réseau depuis votre client vers le sous-réseau. Pour y accéder via Internet, vous devez utiliser un sous-réseau public dont la table de routage comporte la passerelle Internet. 1. Choisissez **Suivant**. 1. Sur la page **Configurer les options de la pile**, pour utiliser les informations d'identification utilisateur actuelles afin de déterminer CloudFormation comment créer, modifier ou supprimer des ressources dans la pile, choisissez **Next**. Vous pouvez également spécifier un rôle dans la section **Autorisations** à utiliser au lieu des autorisations utilisateur actuelles, puis choisissez **Suivant**. 1. Sur la page **Review (Révision)**, vérifiez le modèle. Sélectionnez **Je reconnais que cela CloudFormation pourrait créer des ressources IAM**, puis choisissez **Create stack**. 1. Attendez que la pile soit créée. 1. Ouvrez l'onglet **Sorties**. 1. Copiez l'URL de **SparkUiPublicUrl**si vous utilisez un sous-réseau public. 1. Copiez l'URL de **SparkUiPrivateUrl**si vous utilisez un sous-réseau privé. 1. Ouvrez un navigateur web et collez-y l'URL. Cela vous permet d'accéder au serveur à l'aide de HTTPS sur le port spécifié. Votre navigateur peut ne pas reconnaître le certificat du serveur ; dans ce cas, vous devez outrepasser sa protection et continuer tout de même. ## Lancement du serveur d'historique Spark et affichage de l'interface utilisateur Spark à l'aide de Docker Si vous préférez un accès local (pour ne pas avoir d'instance EC2 pour le serveur d'historique Apache Spark), vous pouvez également utiliser Docker pour démarrer le serveur d'historique Apache Spark et afficher l'interface utilisateur Spark localement. Ce fichier Dockerfile est un exemple que vous devez modifier pour répondre à vos besoins. **Conditions préalables** Pour plus d'informations sur l'installation de Docker sur votre ordinateur portable, consultez la [communauté Docker Engine](https://docs.docker.com/install/). **Pour démarrer le serveur d'historique Spark et afficher l'interface utilisateur Spark localement à l'aide de Docker** 1. Téléchargez des fichiers depuis GitHub. Téléchargez les fichiers Dockerfile et `pom.xml` à partir des [exemples de code AWS Glue](https://github.com/aws-samples/aws-glue-samples/tree/master/utilities/Spark_UI/). 1. Déterminez si vous souhaitez utiliser vos informations d'identification utilisateur ou vos informations d'identification utilisateur fédéré pour accéder à AWS. + Pour utiliser les informations d'identification utilisateur actuelles pour accéder AWS, obtenez les valeurs à utiliser pour ` AWS_ACCESS_KEY_ID` et `AWS_SECRET_ACCESS_KEY` dans la `docker run` commande. Pour plus d’informations, consultez [Gestion des clés d’accès pour les utilisateurs IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) dans le *Guide de l’utilisateur IAM*. + Pour utiliser les utilisateurs fédérés SAML 2.0 pour l'accès AWS, obtenez les valeurs pour ` AWS_ACCESS_KEY_ID``AWS_SECRET_ACCESS_KEY`, et. ` AWS_SESSION_TOKEN` Pour en savoir plus, consultez [Requesting temporary security credentials](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html) (Demander d'informations d'identification temporaires de sécurité). 1. Déterminez l'emplacement de votre répertoire de journaux d'événements, à utiliser dans la commande `docker run`. 1. Créez l'image Docker à l'aide des fichiers du répertoire local, en utilisant le nom ` glue/sparkui` et l'identification `latest`. ``` $ docker build -t glue/sparkui:latest . ``` 1. Créez et démarrez le conteneur Docker. Dans les commandes suivantes, utilisez les valeurs obtenues précédemment aux étapes 2 et 3. 1. Pour créer le conteneur Docker à l'aide de vos informations d'identification utilisateur, utilisez une commande similaire à ce qui suit : ``` docker run -itd -e SPARK_HISTORY_OPTS="$SPARK_HISTORY_OPTS -Dspark.history.fs.logDirectory=s3a://path_to_eventlog -Dspark.hadoop.fs.s3a.access.key=AWS_ACCESS_KEY_ID -Dspark.hadoop.fs.s3a.secret.key=AWS_SECRET_ACCESS_KEY" -p 18080:18080 glue/sparkui:latest "/opt/spark/bin/spark-class org.apache.spark.deploy.history.HistoryServer" ``` 1. Pour créer le conteneur Docker à l'aide d'informations d'identification temporaires, utilisez ` org.apache.hadoop.fs.s3a.TemporaryAWSCredentialsProvider` en tant que fournisseur, et fournissez les valeurs d'identification obtenues à l'étape 2. Pour plus d'informations, consultez la section [Utilisation des informations d'identification de session avec un AWSCredentials fournisseur temporaire](https://hadoop.apache.org/docs/stable/hadoop-aws/tools/hadoop-aws/index.html#Using_Session_Credentials_with_TemporaryAWSCredentialsProvider) dans la *documentation Hadoop : intégration avec Amazon Web Services*. ``` docker run -itd -e SPARK_HISTORY_OPTS="$SPARK_HISTORY_OPTS -Dspark.history.fs.logDirectory=s3a://path_to_eventlog -Dspark.hadoop.fs.s3a.access.key=AWS_ACCESS_KEY_ID -Dspark.hadoop.fs.s3a.secret.key=AWS_SECRET_ACCESS_KEY -Dspark.hadoop.fs.s3a.session.token=AWS_SESSION_TOKEN -Dspark.hadoop.fs.s3a.aws.credentials.provider=org.apache.hadoop.fs.s3a.TemporaryAWSCredentialsProvider" -p 18080:18080 glue/sparkui:latest "/opt/spark/bin/spark-class org.apache.spark.deploy.history.HistoryServer" ``` **Note** Ces paramètres de configuration proviennent du[ Hadoop-AWSModule](https://hadoop.apache.org/docs/stable/hadoop-aws/tools/hadoop-aws/index.html). Il se peut que vous ayez besoin d'ajouter une configuration spécifique en fonction des cas d'utilisation. Par exemple : les utilisateurs des régions isolées devront configurer le ` spark.hadoop.fs.s3a.endpoint`. 1. Ouvrez `http://localhost:18080` dans votre navigateur pour afficher localement l'interface utilisateur Spark. # Surveillance à l'aide AWS Glue d'informations sur l'exécution des tâches AWS Glue Job Run Insights est une fonctionnalité AWS Glue qui simplifie le débogage des tâches et l'optimisation de vos AWS Glue tâches. AWS Glue fournit l'[interface utilisateur Spark](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui.html), ainsi que [CloudWatch des journaux et des indicateurs](https://docs.aws.amazon.com/glue/latest/dg/monitor-cloudwatch.html) pour surveiller vos AWS Glue tâches. Grâce à cette fonctionnalité, vous obtenez les informations suivantes concernant l'exécution de votre AWS Glue tâche : + Numéro de ligne de votre script de AWS Glue tâche qui a échoué. + L'action Spark exécutée en dernier dans le plan de requête Spark juste avant l'échec de votre tâche. + Les événements d'exception Spark liés à l'échec présenté dans un flux de journal classé par ordre chronologique. + L'analyse des causes racines et l'action recommandée (telle que le réglage de votre script) pour résoudre le problème. + Les événements Spark courants (messages de journaux relatifs à une action Spark) avec une action recommandée qui traite la cause racine. Toutes ces informations sont mises à votre disposition à l'aide de deux nouveaux flux de journaux dans les CloudWatch journaux de vos AWS Glue tâches. ## Exigences La fonctionnalité AWS Glue Job Run Insights est disponible pour AWS Glue les versions 2.0 et supérieures. Vous pouvez suivre le [guide de migration](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-30.html) de vos tâches existantes pour les mettre à niveau à partir d'anciennes AWS Glue versions. ## Activation des informations relatives à l'exécution des tâches pour une tâche AWS Glue ETL Vous pouvez activer les informations relatives à l'exécution des tâches via l'interface de ligne de commande AWS Glue Studio ou la CLI. ### AWS Glue Studio Lorsque vous créez une tâche via AWS Glue Studio, vous pouvez activer ou désactiver les informations relatives à l'exécution des tâches dans l'onglet **Détails de la tâche**. Vérifiez que la case **Générer des informations sur les tâches** est cochée. ![\[Activation des informations sur l'exécution de la tâche dans AWS Glue Studio.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-job-run-insights-1.png) ### Ligne de commande Si vous créez une tâche via le CLI, vous pouvez démarrer l'exécution d'une tâche avec un seul nouveau [paramètre de tâche](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html) :`--enable-job-insights = true`. Par défaut, les flux de journaux des informations sur l'exécution de la tâche sont créés sous le même groupe de journaux par défaut utilisé par [AWS Glue journalisation continue](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging.html), c'est-à-dire, `/aws-glue/jobs/logs-v2/`. Vous pouvez configurer un nom de groupe de journaux personnalisé, des filtres de journaux et des configurations de groupes de journaux à l'aide du même ensemble d'arguments que pour la journalisation continue. Pour plus d'informations, consultez la section [Activation de la journalisation continue pour les AWS Glue tâches](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging-enable.html). ## Accès aux flux de journaux Job Run Insights dans CloudWatch Lorsque la fonctionnalité des informations sur l'exécution de la tâche est activée, deux flux de journaux peuvent être créés en cas d'échec d'une exécution de tâche. Lorsqu'une tâche se termine correctement, aucun des flux n'est généré. 1. *Flux de journaux d'analyse des exceptions* :`-job-insights-rca-driver`. Ce flux fournit les informations suivantes : + Numéro de ligne du script de AWS Glue tâche à l'origine de l'échec. + L'action Spark exécutée en dernier dans le plan de requête Spark (DAG). + Les événements chronologiques concis provenant du pilote Spark et les programmes d'exécution associés à l'exception. Vous pourrez trouver des détails tels que des messages d'erreur complets, la tâche Spark qui a échoué et l'ID de ses programmes d'exécution. Ces informations vous aident à vous concentrer sur le flux de journal du programme d'exécution spécifique pour une analyse plus approfondie si nécessaire. 1. *Flux d'informations basé sur des règles* : + Analyse des causes racines et recommandations sur la manière de corriger les erreurs (telles que l'utilisation d'un paramètre de tâche spécifique pour optimiser les performances). + Les événements Spark pertinents servant de base à l'analyse des causes racines et à une action recommandée. **Note** Le premier flux n'existera que si des événements Spark d'exception sont disponibles pour une exécution de tâche qui a échoué, et le second flux n'existera que si des informations sont disponibles pour l'exécution de la tâche qui a échoué. Par exemple, si votre tâche se termine correctement, aucun des flux ne sera généré. Si votre tâche échoue, mais qu'aucune règle définie par le service ne correspond à votre scénario d'échec, seul le premier flux sera généré. Si la tâche est créée à partir de AWS Glue Studio, les liens vers les flux ci-dessus sont également disponibles sous l'onglet Détails de l'exécution du travail (Job run insights) sous la forme « Journaux d'erreurs concis et consolidés » et « Analyse des erreurs et conseils ». ![\[La page détails de l'exécution de la tâche contient des liens vers les flux de journaux.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-job-run-insights-2.png) ## Exemple d'analyse de l'exécution des AWS Glue tâches Dans cette section, nous vous présentons un exemple de la façon dont la fonctionnalité d'informations sur l'exécution de la tâche peut vous aider à résoudre un problème lié à votre tâche qui a échoué. Dans cet exemple, un utilisateur a oublié d'importer le module requis (tensorflow) dans une AWS Glue tâche pour analyser et créer un modèle d'apprentissage automatique à partir de ses données. ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job from pyspark.sql.types import * from pyspark.sql.functions import udf,col args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME'], args) data_set_1 = [1, 2, 3, 4] data_set_2 = [5, 6, 7, 8] scoresDf = spark.createDataFrame(data_set_1, IntegerType()) def data_multiplier_func(factor, data_vector): import tensorflow as tf with tf.compat.v1.Session() as sess: x1 = tf.constant(factor) x2 = tf.constant(data_vector) result = tf.multiply(x1, x2) return sess.run(result).tolist() data_multiplier_udf = udf(lambda x:data_multiplier_func(x, data_set_2), ArrayType(IntegerType(),False)) factoredDf = scoresDf.withColumn("final_value", data_multiplier_udf(col("value"))) print(factoredDf.collect()) ``` La tâche échoue et ,sans la fonctionnalité informations sur l'exécution de la tâche, vous ne voyez que ce message généré par Spark : `An error occurred while calling o111.collectToPython. Traceback (most recent call last):` Le message est ambigu et limite votre expérience de débogage. Dans ce cas, cette fonctionnalité vous fournit des informations supplémentaires dans deux flux de CloudWatch journaux : 1. Le flux de journal `job-insights-rca-driver` : + *Événements d'exception *: ce flux de journal fournit les événements d'exception Spark liés à l'échec collecté à partir du pilote Spark et de différents travailleurs distribués. Ces événements vous aident à comprendre la propagation chronologique de l'exception lorsque le code défectueux s'exécute sur les tâches Spark, les exécuteurs et les étapes réparties entre les travailleurs. AWS Glue + *Numéros de ligne*: ce flux de journal identifie la ligne 21, qui a appelé à importer le module Python manquant à l'origine de l'échec. Il identifie également la ligne 24, l'appel à l'action Spark `collect()`, en tant que dernière ligne exécutée dans votre script. ![\[Le flux du job-insights-rca-driver journal.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-job-run-insights-3.png) 1. Le flux de journal `job-insights-rule-driver` : + *Cause première et recommandation* : Outre le numéro de ligne et le numéro de ligne de la dernière exécution correspondant à l'erreur dans votre script, ce flux de journal indique l'analyse des causes profondes et vous recommande de suivre le AWS Glue document et de configurer les paramètres de tâche nécessaires afin d'utiliser un module Python supplémentaire dans votre AWS Glue tâche. + *Événement récurrent* : ce flux de journal affiche également l'événement d'exception Spark qui a été évalué avec la règle définie par le service afin d'en déduire la cause racine et de fournir une recommandation. ![\[Le flux du job-insights-rule-driver journal.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-job-run-insights-4.png) # Surveillance avec Amazon CloudWatch Vous pouvez effectuer un suivi AWS Glue à l'aide d'Amazon CloudWatch, qui collecte et traite les données brutes sous AWS Glue forme de near-real-time métriques lisibles. Ces statistiques sont enregistrées pour une durée de deux semaines afin de pouvoir accéder aux informations historiques vous permettant d'acquérir un meilleur point de vue sur la façon dont votre service ou application web s'exécute. Par défaut, AWS Glue les données des métriques sont envoyées CloudWatch automatiquement à. Pour plus d'informations, consultez [Qu'est-ce qu'Amazon CloudWatch ?](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/WhatIsCloudWatch.html) dans le *guide de CloudWatch l'utilisateur Amazon*, et[AWS Glue métriques](monitoring-awsglue-with-cloudwatch-metrics.md#awsglue-metrics). **Journalisation continue** AWS Glue prend également en charge la journalisation continue en temps réel pour les tâches AWS Glue. Lorsque la journalisation continue est activée pour une tâche, vous pouvez consulter les journaux en temps réel sur la AWS Glue console ou sur le tableau de bord de la CloudWatch console. Pour de plus amples informations, veuillez consulter [Journalisation pour les AWS Glue emplois](monitor-continuous-logging.md). **Métriques d'observabilité** Lorsque les **métriques d'observabilité du Job** sont activées, des Amazon CloudWatch métriques supplémentaires sont générées lors de l'exécution du job. Utilisez les métriques d'observabilité AWS Glue pour générer des informations sur ce qui se passe au sein de votre AWS Glue afin d'améliorer le triage et l'analyse des problèmes. **Topics** + [ # Surveillance AWS Glue à l'aide CloudWatch des métriques Amazon ](monitoring-awsglue-with-cloudwatch-metrics.md) + [ # Configuration des CloudWatch alarmes Amazon sur les profils AWS Glue d'emploi ](monitor-profile-glue-job-cloudwatch-alarms.md) + [ # Journalisation pour les AWS Glue emplois ](monitor-continuous-logging.md) + [ # Surveillance à l'aide de métriques d'observabilité AWS Glue ](monitor-observability.md) # Surveillance AWS Glue à l'aide CloudWatch des métriques Amazon Vous pouvez surveiller les opérations d'AWS Glue à l'aide du profileur de tâche AWS Glue. Il collecte et traite les données brutes des AWS Glue tâches pour en faire des métriques lisibles en temps quasi réel stockées sur Amazon CloudWatch. Ces statistiques sont conservées et agrégées CloudWatch afin que vous puissiez accéder aux informations historiques pour avoir une meilleure idée des performances de votre application. **Note** Des frais supplémentaires peuvent vous être facturés lorsque vous activez les indicateurs relatifs aux tâches et que CloudWatch des indicateurs personnalisés sont créés. Pour plus d'informations, consultez les [ CloudWatch tarifs Amazon](https://aws.amazon.com/cloudwatch/pricing/). ## Présentation des métriques AWS Glue Lorsque vous interagissez avecAWS Glue, il envoie des métriques à CloudWatch. Vous pouvez consulter ces statistiques à l'aide de la AWS Glue console (méthode préférée), du tableau de bord de la CloudWatch console ou du AWS Command Line Interface (AWS CLI). **Pour afficher des métriques à l'aide du tableau de bord de la console AWS Glue** Vous pouvez afficher un résumé ou des graphiques détaillés des métriques pour une tâche ou des graphiques détaillés pour l'exécution d'une tâche. 1. Connectez-vous à la AWS Glue console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/). 1. Dans le panneau de navigation, choisissez **Surveillance de l'exécution des tâches**. 1. Dans **Exécutions de tâches**, choisissez **Actions** pour arrêter une tâche en cours d'exécution, afficher une tâche ou restaurer le signet d'une tâche. 1. Sélectionnez une tâche, puis choisissez **Afficher les informations de l'exécution** pour afficher des informations supplémentaires sur l'exécution de la tâche. **Pour consulter les statistiques à l'aide du tableau de bord de CloudWatch la console** Les métriques sont d’abord regroupées par espace de noms de service, puis par les différentes combinaisons de dimension au sein de chaque espace de noms. 1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. Dans le panneau de navigation, sélectionnez ‎**Métriques**. 1. Sélectionnez l'espace de noms **Glue**. **Pour consulter les statistiques à l'aide du AWS CLI** + À partir d’une invite de commande, utilisez la commande suivante : ``` 1. aws cloudwatch list-metrics --namespace Glue ``` AWS Gluerapporte les métriques CloudWatch toutes les 30 secondes, et les tableaux de bord des CloudWatch métriques sont configurés pour les afficher toutes les minutes. Les métriques AWS Glue représentent des valeurs delta des valeurs précédemment rapportées. Le cas échéant, les tableaux de bord de métriques regroupent (additionnent) les valeurs de plages de 30 secondes pour obtenir une valeur pour la totalité de la dernière minute. ### AWS Glue comportement des métriques pour les tâches Spark Les métriques AWS Glue sont activées à l'initialisation d'un `GlueContext` dans un script et sont généralement mises à jour uniquement à la fin d'une tâche Apache Spark. Elles représentent les valeurs regroupées sur l'ensemble des tâches Spark terminées jusqu'alors. Cependant, les métriques Spark AWS Glue transmises à CloudWatch sont généralement des valeurs absolues représentant l'état actuel au moment où elles sont signalées. AWS Glueles rapporte CloudWatch toutes les 30 secondes, et les tableaux de bord des métriques indiquent généralement la moyenne des points de données reçus au cours de la dernière minute. Les noms des métriques AWS Glue sont tous précédés par l'un des types suivants de préfixe : + `glue.driver.` – Les métriques dont les noms commencent par ce préfixe représentent des métriques AWS Glue regroupées à partir de tous les programmes d'exécution dans le pilote Spark ou des métriques Spark correspondant au pilote Spark. + `glue.`*executorId*`.` – L'*executorId* correspond au numéro d'un programme d'exécution Spark spécifique. Il correspond aux programmes d'exécution répertoriés dans les journaux. + `glue.ALL.` - Les métriques dont les noms commencent par ce préfixe regroupent des valeurs de tous les programmes d'exécution Spark. ## AWS Glue métriques AWS Glue établit le profil et envoie les métriques suivantes CloudWatch toutes les 30 secondes, et le tableau de bord AWS Glue des métriques les indique une fois par minute : | Métrique | Description | | --- | --- | | `glue.driver.aggregate.bytesRead` | Nombre d'octets lus à partir de toutes les sources de données par toutes les tâches Spark exécutées dans tous les programmes d'exécution. Dimensions valides : `JobName` (le nom du AWS Glue Job), `JobRunId` (l' JobRun ID ou`ALL`) et `Type` (le nombre). Statistiques valides : SUM. Cette métrique est une valeur delta par rapport à la dernière valeur signalée. Par conséquent, sur le tableau de bord AWS Glue des mesures, une statistique SUM est utilisée pour l'agrégation. Unité : octets Peut être utilisé pour contrôler ce qui suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Cette métrique peut être utilisée de la même manière que la métrique `glue.ALL.s3.filesystem.read_bytes`, à la différence qu'elle est mise à jour à la fin d'une tâche Spark et qu'elle capture également les sources de données non S3. | | `glue.driver.aggregate.elapsedTime` | Le temps écoulé ETL en millisecondes (n'inclut pas les temps d'amorçage de la tâche). Dimensions valides : `JobName` (le nom du AWS Glue Job), `JobRunId` (l' JobRun ID ou`ALL`) et `Type` (le nombre). Statistiques valides : SUM. Cette métrique est une valeur delta par rapport à la dernière valeur signalée. Par conséquent, sur le tableau de bord AWS Glue des mesures, une statistique SUM est utilisée pour l'agrégation. Unité : millisecondes Peut être utilisé pour déterminer combien le temps moyen requis pour une exécution de tâche. Voici quelques façons d'utiliser les données : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.numCompletedStages` | Le nombre d'étapes terminées dans la tâche. Dimensions valides : `JobName` (le nom du AWS Glue Job), `JobRunId` (l' JobRun ID ou`ALL`) et `Type` (le nombre). Statistiques valides : SUM. Cette métrique est une valeur delta par rapport à la dernière valeur signalée. Par conséquent, sur le tableau de bord AWS Glue des mesures, une statistique SUM est utilisée pour l'agrégation. Unité : nombre Peut être utilisé pour contrôler ce qui suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Voici quelques façons d'utiliser les données : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.numCompletedTasks` | Le nombre de tâches terminées dans la tâche. Dimensions valides : `JobName` (le nom du AWS Glue Job), `JobRunId` (l' JobRun ID ou`ALL`) et `Type` (le nombre). Statistiques valides : SUM. Cette métrique est une valeur delta par rapport à la dernière valeur signalée. Par conséquent, sur le tableau de bord AWS Glue des mesures, une statistique SUM est utilisée pour l'agrégation. Unité : nombre Peut être utilisé pour contrôler ce qui suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.numFailedTasks` | Nombre de tâches ayant échoué. Dimensions valides : `JobName` (le nom du AWS Glue Job), `JobRunId` (l' JobRun ID ou`ALL`) et `Type` (le nombre). Statistiques valides : SUM. Cette métrique est une valeur delta par rapport à la dernière valeur signalée. Par conséquent, sur le tableau de bord AWS Glue des mesures, une statistique SUM est utilisée pour l'agrégation. Unité : nombre Peut être utilisé pour contrôler ce qui suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Les données peuvent être utilisées pour définir des alarmes pour des échecs accrus qui pourraient suggérer des anomalies dans les données, les clusters ou les scripts. | | `glue.driver.aggregate.numKilledTasks` | Nombre de tâches supprimées. Dimensions valides : `JobName` (le nom du AWS Glue Job), `JobRunId` (l' JobRun ID ou`ALL`) et `Type` (le nombre). Statistiques valides : SUM. Cette métrique est une valeur delta par rapport à la dernière valeur signalée. Par conséquent, sur le tableau de bord AWS Glue des mesures, une statistique SUM est utilisée pour l'agrégation. Unité : nombre Peut être utilisé pour contrôler ce qui suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Voici quelques façons d'utiliser les données : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.recordsRead` | Nombre d'enregistrements lus à partir de toutes les sources de données par toutes les tâches Spark terminées exécutées dans tous les programmes d'exécution. Dimensions valides : `JobName` (le nom du AWS Glue Job), `JobRunId` (l' JobRun ID ou`ALL`) et `Type` (le nombre). Statistiques valides : SUM. Cette métrique est une valeur delta par rapport à la dernière valeur signalée. Par conséquent, sur le tableau de bord AWS Glue des mesures, une statistique SUM est utilisée pour l'agrégation. Unité : nombre Peut être utilisé pour contrôler ce qui suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Cette métrique peut être utilisée de manière similaire à la métrique `glue.ALL.s3.filesystem.read_bytes`, à la différence qu'elle est mise à jour à la fin d'une tâche Spark. | | `glue.driver.aggregate.shuffleBytesWritten` | Nombre d'octets écrits par tous les exécuteurs pour mélanger les données entre eux depuis le rapport précédent (agrégé par le tableau de bord des AWS Glue mesures sous la forme du nombre d'octets écrits à cette fin au cours de la minute précédente). Dimensions valides : `JobName` (le nom du AWS Glue Job), `JobRunId` (l' JobRun ID ou`ALL`) et `Type` (le nombre). Statistiques valides : SUM. Cette métrique est une valeur delta par rapport à la dernière valeur signalée. Par conséquent, sur le tableau de bord AWS Glue des mesures, une statistique SUM est utilisée pour l'agrégation. Unité : octets Peut être utilisé pour contrôler le remaniement de données dans les tâches (jointures volumineuses, GroupBy, répartition, coalesce). Voici quelques façons d'utiliser les données : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.shuffleLocalBytesRead` | Nombre d'octets lus par tous les exécuteurs pour mélanger les données entre eux depuis le rapport précédent (agrégé par le tableau de bord des AWS Glue mesures sous la forme du nombre d'octets lus à cette fin au cours de la minute précédente). Dimensions valides : `JobName` (le nom du AWS Glue Job), `JobRunId` (l' JobRun ID ou`ALL`) et `Type` (le nombre). Statistiques valides : SUM. Cette métrique est une valeur delta par rapport à la dernière valeur signalée. Par conséquent, sur le tableau de bord AWS Glue des mesures, une statistique SUM est utilisée pour l'agrégation. Unité : octets Peut être utilisé pour contrôler le remaniement de données dans les tâches (jointures volumineuses, GroupBy, répartition, coalesce). Voici quelques façons d'utiliser les données : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.BlockManager.disk.diskSpaceUsed_MB` | Nombre de mégaoctets d'espace disque utilisés sur tous les programmes d'exécution. Dimensions valides : `JobName` (le nom du AWS Glue Job), `JobRunId` (l' JobRun identifiant ou`ALL`) et `Type` (la jauge). Statistiques valides : moyenne Il s'agit d'une métrique Spark, rapportée en tant que valeur absolue. Unité : mégaoctets Peut être utilisé pour contrôler ce qui suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Voici quelques façons d'utiliser les données : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.ExecutorAllocationManager.executors.numberAllExecutors` | Le nombre de programmes d'exécution de tâches actifs en cours d'exécution. Dimensions valides : `JobName` (le nom du AWS Glue Job), `JobRunId` (l' JobRun identifiant ou`ALL`) et `Type` (la jauge). Statistiques valides : moyenne Il s'agit d'une métrique Spark, rapportée en tant que valeur absolue. Unité : nombre Peut être utilisé pour contrôler ce qui suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Voici quelques façons d'utiliser les données : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors` | Nombre maximal de programmes d'exécution de tâches (en cours d'exécution et en attente) nécessaires pour satisfaire la charge actuelle. Dimensions valides : `JobName` (le nom du AWS Glue Job), `JobRunId` (l' JobRun identifiant ou`ALL`) et `Type` (la jauge). Statistiques valides : maximum Il s'agit d'une métrique Spark, rapportée en tant que valeur absolue. Unité : nombre Peut être utilisé pour contrôler ce qui suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Voici quelques façons d'utiliser les données : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.jvm.heap.usage` `glue.`*executorId*`.jvm.heap.usage` `glue.ALL.jvm.heap.usage` | La fraction de mémoire utilisée par la pile de la JVM pour ce pilote (échelle : 0-1) pour le pilote, un programme d'exécution identifié par executorId ou TOUS les programmes d'exécution. Dimensions valides : `JobName` (le nom du AWS Glue Job), `JobRunId` (l' JobRun identifiant ou`ALL`) et `Type` (la jauge). Statistiques valides : moyenne Il s'agit d'une métrique Spark, rapportée en tant que valeur absolue. Unité : pourcentage Peut être utilisé pour contrôler ce qui suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Voici quelques façons d'utiliser les données : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.jvm.heap.used` `glue.`*executorId*`.jvm.heap.used` `glue.ALL.jvm.heap.used` | le nombre d'octets de mémoire utilisés par la pile JVM pour le pilote, le programme d'exécution identifié par *executorId*, ou TOUS les programmes d'exécution. Dimensions valides : `JobName` (le nom du AWS Glue Job), `JobRunId` (l' JobRun identifiant ou`ALL`) et `Type` (la jauge). Statistiques valides : moyenne Il s'agit d'une métrique Spark, rapportée en tant que valeur absolue. Unité : octets Peut être utilisé pour contrôler ce qui suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Voici quelques façons d'utiliser les données : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.s3.filesystem.read_bytes` `glue.`*executorId*`.s3.filesystem.read_bytes` `glue.ALL.s3.filesystem.read_bytes` | Le nombre d'octets lus depuis Amazon S3 par le pilote, un exécuteur identifié par *ExecutoriD* ou TOUS les exécuteurs depuis le rapport précédent (agrégé par le tableau de bord des métriques sous la forme du nombre d'octets lus AWS Glue au cours de la minute précédente). Dimensions valides :`JobName`, `JobRunId`, et `Type` (jauge). Statistiques valides : SUM. Cette métrique est une valeur delta par rapport à la dernière valeur signalée. Par conséquent, sur le tableau de bord AWS Glue des mesures, une statistique SUM est utilisée pour l'agrégation. La zone située sous la courbe sur le tableau de bord AWS Glue des métriques peut être utilisée pour comparer visuellement les octets lus lors de deux exécutions de tâches différentes. Unité : octets. Peut être utilisé pour contrôler ce qui suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Les données résultantes peuvent être utilisées pour ce qui suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.s3.filesystem.write_bytes` `glue.`*executorId*`.s3.filesystem.write_bytes` `glue.ALL.s3.filesystem.write_bytes` | Le nombre d'octets écrits sur Amazon S3 par le pilote, un exécuteur identifié par *ExecutoriD* ou TOUS les exécuteurs depuis le rapport précédent (agrégé par le tableau de bord des métriques sous la forme du nombre d'octets écrits AWS Glue au cours de la minute précédente). Dimensions valides :`JobName`, `JobRunId`, et `Type` (jauge). Statistiques valides : SUM. Cette métrique est une valeur delta par rapport à la dernière valeur signalée. Par conséquent, sur le tableau de bord AWS Glue des mesures, une statistique SUM est utilisée pour l'agrégation. La zone située sous la courbe sur le tableau de bord AWS Glue des métriques peut être utilisée pour comparer visuellement les octets écrits lors de deux exécutions de tâches différentes. Unité : octets Peut être utilisé pour contrôler ce qui suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Voici quelques façons d'utiliser les données : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.streaming.numRecords` | Nombre d'enregistrements reçus dans un micro-lot. Cette métrique n'est disponible que pour les jobs de AWS Glue streaming dotés de AWS Glue la version 2.0 ou supérieure. Dimensions valides : `JobName` (le nom de la AWS Glue tâche), `JobRunId` (l' JobRun identifiant ou`ALL`) et `Type` (nombre). Statistiques valides : somme, minimum, maximum, moyenne, percentile Unité : nombre Peut être utilisé pour contrôler ce qui suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.streaming.batchProcessingTimeInMs` | Temps nécessaire pour traiter les lots en millisecondes. Cette métrique n'est disponible que pour les jobs de AWS Glue streaming dotés de AWS Glue la version 2.0 ou supérieure. Dimensions valides : `JobName` (le nom de la AWS Glue tâche), `JobRunId` (l' JobRun identifiant ou`ALL`) et `Type` (nombre). Statistiques valides : somme, minimum, maximum, moyenne, percentile Unité : nombre Peut être utilisé pour contrôler ce qui suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.system.cpuSystemLoad` `glue.`*executorId*`.system.cpuSystemLoad` `glue.ALL.system.cpuSystemLoad` | La fraction de chargement du système UC utilisée (échelle : 0-1) par le pilote, un programme d'exécution identifié par *executorId* ou tous les programmes d'exécution. Dimensions valides : `JobName` (le nom de la AWS Glue tâche), `JobRunId` (l' JobRun identifiant ou`ALL`) et `Type` (la jauge). Statistiques valides : moyenne Cette métrique est rapportée en tant que valeur absolue. Unité : pourcentage Peut être utilisé pour contrôler ce qui suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Voici quelques façons d'utiliser les données : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | ## Dimensions pour les AWS Glue métriques AWS Glue les métriques utilisent l'espace de AWS Glue noms et fournissent des métriques pour les dimensions suivantes : | Dimension | Description | | --- | --- | | `JobName` | Cette dimension filtre les métriques de toutes les exécutions d'une AWS Glue tâche spécifique. | | `JobRunId` | Cette dimension filtre les métriques d'une AWS Glue tâche spécifique exécutée par un JobRun ID, ou`ALL`. | | `Type` | Cette dimension filtre les métriques par `count` (un nombre agrégé) ou `gauge` (une valeur à un moment donné). | Pour plus d'informations, consultez le [guide de CloudWatch l'utilisateur Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/). # Configuration des CloudWatch alarmes Amazon sur les profils AWS Glue d'emploi AWS Glueles statistiques sont également disponibles sur Amazon CloudWatch. Vous pouvez configurer des alarmes sur n'importe quelle métrique AWS Glue pour des tâches planifiées. Voici quelques scénarios courants de configuration d'alarmes : + Tâches manquant de mémoire (OOM - out of memory) : définissez une alarme lorsque l'utilisation de la mémoire dépasse la moyenne normale pour le pilote ou pour le programme d'exécution d'une tâche AWS Glue. + Programmes d'exécution en retard : définissez une alarme lorsque le nombre de programmes d'exécution passe au‑dessous d'un certain seuil durant un long moment dans une tâche AWS Glue. + Retard ou retraitement des données : comparez les indicateurs des tâches individuelles d'un flux de travail à l'aide d'une expression CloudWatch mathématique. Vous pouvez ensuite déclencher une alarme sur la valeur résultant de l'expression (comme le ratio entre les octets écrits par une tâche et les octets lus par une tâche suivante). Pour obtenir des instructions détaillées sur la configuration des alarmes, consultez la section [Créer ou modifier une CloudWatch alarme](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ConsoleAlarms.html) dans le *[guide de l'utilisateur Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/)*. Pour les scénarios de surveillance et de débogage utilisant CloudWatch, voir[Surveillance et débogage des tâches](monitor-profile-glue-job-cloudwatch-metrics.md). # Journalisation pour les AWS Glue emplois Dans la AWS Glue version 5.0, toutes les tâches disposent de fonctionnalités de journalisation en temps réel. En outre, vous pouvez spécifier des options de configuration personnalisées pour personnaliser le comportement de la journalisation. Ces options incluent la définition du nom du groupe de Amazon CloudWatch journaux, du préfixe du flux de Amazon CloudWatch journal (qui précédera l'ID et l'ID AWS Glue d'exécution de la tâche) et driver/executor du modèle de conversion des journaux pour les messages de journal. Ces configurations vous permettent d’agréger les journaux dans des groupes de journaux Amazon CloudWatch personnalisés avec différentes politiques d’expiration. En outre, vous pouvez analyser les journaux plus efficacement en utilisant des préfixes de flux de journaux et des modèles de conversion personnalisés. Ce niveau de personnalisation vous permet d’optimiser la gestion et l’analyse des journaux en fonction de vos besoins spécifiques. ## Comportement de journalisation en AWS Glue version 5.0 Par défaut, les journaux du système, les journaux du démon Spark et les journaux de l'utilisateur AWS Glue sont écrits dans le groupe de `/aws-glue/jobs/error` journaux. Amazon CloudWatch D’autre part, les journaux utilisateur stdout (sortie standard) et stderr (erreur standard) sont écrits dans le groupe de journaux `/aws-glue/jobs/output` par défaut. ## Journalisation personnalisée Vous pouvez personnaliser le groupe de journaux par défaut et les préfixes de flux de journaux à l’aide des arguments de tâche suivants : + `--custom-logGroup-prefix` : vous permet de spécifier un préfixe personnalisé pour les groupes de journaux `/aws-glue/jobs/error` et `/aws-glue/jobs/output`. Si vous fournissez un préfixe personnalisé, les noms des groupes de journaux seront au format suivant : + `/aws-glue/jobs/error` sera `/error` + `/aws-glue/jobs/output ` sera `/output` + `--custom-logStream-prefix` : vous permet de spécifier un préfixe personnalisé pour les noms des flux de journaux au sein des groupes de journaux. Si vous fournissez un préfixe personnalisé, les noms des flux de journaux seront au format suivant : + `jobrunid-driver` sera `-driver` + `jobrunid-executorNum` sera `-executorNum` Règles de validation et restrictions relatives aux préfixes personnalisés : + La longueur du nom complet du flux de journaux doit être comprise entre 1 et 512 caractères. + Le préfixe personnalisé lui-même est limité à 400 caractères. + Le préfixe personnalisé doit correspondre au modèle d’expression régulière `[^:\$1] \$1` (les caractères spéciaux autorisés sont « \$1 », « - » et « / »). ## Journalisation des messages spécifiques aux applications à l’aide de l’enregistreur de script personnalisé Vous pouvez utiliser l' AWS Glue enregistreur pour enregistrer tous les messages spécifiques à l'application dans le script qui sont envoyés en temps réel au flux de journal du pilote. L'exemple suivant illustre un script Python. ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) logger = glueContext.get_logger() logger.info("info message") logger.warn("warn message") logger.error("error message") ``` L'exemple suivant illustre un script Scala. ``` import com.amazonaws.services.glue.log.GlueLogger object GlueApp { def main(sysArgs: Array[String]) { val logger = new GlueLogger logger.info("info message") logger.warn("warn message") logger.error("error message") } } ``` ## Activation de la barre de progression pour afficher la progression d’une tâche AWS Glue fournit une barre de progression en temps réel sous le flux du `JOB_RUN_ID-progress-bar` journal pour vérifier l'état AWS Glue d'exécution des tâches. Actuellement, il prend en charge uniquement les tâches qui initialisent `glueContext`. Si vous exécutez une tâche Spark pure sans l'initialiser`glueContext`, la barre de AWS Glue progression n'apparaît pas. La barre de progression indique une mise à jour de la progression suivante toutes les 5 secondes. ``` Stage Number (Stage Name): > (numCompletedTasks + numActiveTasks) / totalNumOfTasksInThisStage] ``` ## Configuration de sécurité avec Amazon CloudWatch journalisation Lorsqu'une configuration de sécurité est activée pour les Amazon CloudWatch journaux, AWS Glue crée des groupes de journaux avec des modèles de dénomination spécifiques qui incorporent le nom de la configuration de sécurité. ### Dénomination des groupes de journaux avec configuration de sécurité Les groupes de journaux par défaut et personnalisés seront les suivants : + **Groupe de journaux d’erreurs par défaut :** `/aws-glue/jobs/Security-Configuration-Name-role/glue-job-role/error` + **Groupe de journaux de sortie par défaut :** `/aws-glue/jobs/Security-Configuration-Name-role/glue-job-role/output` + **Groupe de journaux d'erreurs personnalisé (AWS Glue 5.0) :** `custom-log-group-prefix/Security-Configuration-Name-role/glue-job-role/error` + **Groupe de journaux de sortie personnalisé (AWS Glue 5.0) :** `custom-log-group-prefix/Security-Configuration-Name-role/glue-job-role/output` ### Autorisations IAM nécessaires Vous devez ajouter l’autorisation `logs:AssociateKmsKey` à vos autorisations de rôle IAM, si vous activez une configuration de sécurité avec Amazon CloudWatch Logs. Si cette autorisation n’est pas incluse, la journalisation continue sera désactivée. De plus, pour configurer le chiffrement des Amazon CloudWatch journaux, suivez les instructions de la section [Chiffrer les données des Amazon CloudWatch journaux dans les journaux à l'aide AWS Key Management Service](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/encrypt-log-data-kms.html) du guide de l'utilisateur Amazon Amazon CloudWatch Logs. ### Informations supplémentaires Pour plus d'informations sur la création de configurations de sécurité, consultez [la section Gestion des configurations de sécurité sur la AWS Glue console](https://docs.aws.amazon.com/glue/latest/dg/console-security-configurations.html). **Topics** + [ ## Comportement de journalisation en AWS Glue version 5.0 ](#monitor-logging-behavior-glue-50) + [ ## Journalisation personnalisée ](#monitor-logging-custom) + [ ## Journalisation des messages spécifiques aux applications à l’aide de l’enregistreur de script personnalisé ](#monitor-logging-script) + [ ## Activation de la barre de progression pour afficher la progression d’une tâche ](#monitor-logging-progress) + [ ## Configuration de sécurité avec Amazon CloudWatch journalisation ](#monitor-security-config-logging) + [ # Activation de la journalisation continue pour les tâches AWS Glue 4.0 et antérieures ](monitor-continuous-logging-enable.md) + [ # Afficher les journaux des AWS Glue offres d'emploi ](monitor-continuous-logging-view.md) # Activation de la journalisation continue pour les tâches AWS Glue 4.0 et antérieures **Note** Dans les versions AWS Glue 4.0 et antérieures, la journalisation continue était une fonctionnalité disponible. Cependant, avec l'introduction de la AWS Glue version 5.0, toutes les tâches disposent d'une fonctionnalité de journalisation en temps réel. Pour plus de détails sur les fonctionnalités de journalisation et les options de configuration de la AWS Glue version 5.0, consultez la section [Journalisation des AWS Glue tâches](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging.html). Vous pouvez activer la journalisation continue à l'aide de la AWS Glue console ou via le AWS Command Line Interface (AWS CLI). Vous pouvez activer la journalisation continue lorsque vous créez une tâche, modifiez une tâche existante, ou vous pouvez l’activer via l’ AWS CLI. Vous pouvez également spécifier des options de configuration personnalisées telles que le nom du groupe de Amazon CloudWatch journaux, le préfixe du flux de CloudWatch journal avant l' driver/executor ID AWS Glue d'exécution de la tâche et le modèle de conversion des journaux pour les messages de journal. Ces configurations vous permettent de définir des journaux agrégés dans des groupes de CloudWatch journaux personnalisés avec différentes politiques d'expiration, et de les analyser plus en détail à l'aide de préfixes de flux de journaux et de modèles de conversion personnalisés. **Topics** + [ ## À l'aide du AWS Management Console ](#monitor-continuous-logging-enable-console) + [ ## Journalisation des messages spécifiques aux applications à l’aide de l’enregistreur de script personnalisé ](#monitor-continuous-logging-script) + [ ## Activation de la barre de progression pour afficher la progression d’une tâche ](#monitor-continuous-logging-progress) + [ ## Configuration de sécurité avec la journalisation continue ](#monitor-logging-encrypt-log-data) ## À l'aide du AWS Management Console Procédez comme suit pour utiliser la console afin d'activer la journalisation continue lors de la création ou de la modification d'une AWS Glue tâche. **Pour créer une nouvelle AWS Glue tâche grâce à la journalisation continue** 1. Connectez-vous à la AWS Glue console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/). 1. Dans le volet de navigation, sélectionnez **Tâches ETL**. 1. Choisissez **ETL visuel**. 1. Dans l’onglet **Détails de la tâche**, développez la section **Propriétés avancées**. 1. Sous **Journalisation continue**, sélectionnez **Activer les connexions CloudWatch**. **Pour activer la journalisation continue d'une AWS Glue tâche existante** 1. Ouvrez la AWS Glue console à l'adresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/). 1. Dans le volet de navigation, sélectionnez **Tâches**. 1. Choisissez une tâche existante à partir de la liste des **Tâches**. 1. Choisissez **Action**, **Modifier la tâche**. 1. Dans l’onglet **Détails de la tâche**, développez la section **Propriétés avancées**. 1. Sous **Journalisation continue**, sélectionnez **Activer les connexions CloudWatch**. ### À l'aide du AWS CLI Pour activer la journalisation continue, vous devez transmettre les paramètres d'une tâche à une AWS Glue tâche. Transmettez les paramètres de tâche spéciaux suivants, similaires aux autres paramètres de AWS Glue tâche. Pour de plus amples informations, veuillez consulter [Utilisation des paramètres des tâches dans les tâches AWS Glue](aws-glue-programming-etl-glue-arguments.md). ``` '--enable-continuous-cloudwatch-log': 'true' ``` Vous pouvez spécifier un nom de groupe de CloudWatch journaux Amazon personnalisé. Si aucune valeur n’est spécifiée, le nom par défaut du groupe de journaux est `/aws-glue/jobs/logs-v2`. ``` '--continuous-log-logGroup': 'custom_log_group_name' ``` Vous pouvez spécifier un préfixe de flux de CloudWatch journal Amazon personnalisé. Si aucune valeur n’est spécifiée, le préfixe de flux de journal par défaut est l’ID d’exécution du travail. ``` '--continuous-log-logStreamPrefix': 'custom_log_stream_prefix' ``` Vous pouvez spécifier un modèle de conversion de journalisation continue personnalisé. Si aucune valeur n’est spécifiée, le modèle de conversion par défaut est `%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n`. Notez que le modèle de conversion s’applique uniquement aux journaux des pilotes et des programmes d’exécution. Cela n’affecte pas la barre de progression AWS Glue . ``` '--continuous-log-conversionPattern': 'custom_log_conversion_pattern' ``` ## Journalisation des messages spécifiques aux applications à l’aide de l’enregistreur de script personnalisé Vous pouvez utiliser l' AWS Glue enregistreur pour enregistrer tous les messages spécifiques à l'application dans le script qui sont envoyés en temps réel au flux de journal du pilote. L'exemple suivant illustre un script Python. ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) logger = glueContext.get_logger() logger.info("info message") logger.warn("warn message") logger.error("error message") ``` L'exemple suivant illustre un script Scala. ``` import com.amazonaws.services.glue.log.GlueLogger object GlueApp { def main(sysArgs: Array[String]) { val logger = new GlueLogger logger.info("info message") logger.warn("warn message") logger.error("error message") } } ``` ## Activation de la barre de progression pour afficher la progression d’une tâche AWS Glue fournit une barre de progression en temps réel sous le flux du `JOB_RUN_ID-progress-bar` journal pour vérifier l'état AWS Glue d'exécution des tâches. Actuellement, il prend en charge uniquement les tâches qui initialisent `glueContext`. Si vous exécutez une tâche Spark pure sans l'initialiser`glueContext`, la barre de AWS Glue progression n'apparaît pas. La barre de progression indique une mise à jour de la progression suivante toutes les 5 secondes. ``` Stage Number (Stage Name): > (numCompletedTasks + numActiveTasks) / totalNumOfTasksInThisStage] ``` ## Configuration de sécurité avec la journalisation continue Si une configuration de sécurité est activée pour CloudWatch les journaux, AWS Glue créera un groupe de journaux nommé comme suit pour les journaux continus : ``` - ``` Les groupes de journaux par défaut et personnalisés seront les suivants : + Le groupe de journaux continus par défaut sera `/aws-glue/jobs/error-` + Le groupe de journaux continus personnalisé sera `-` Vous devez ajouter les autorisations `logs:AssociateKmsKey` à votre rôle IAM, si vous activez une configuration de sécurité avec CloudWatch Logs. Si cette autorisation n’est pas incluse, la journalisation continue sera désactivée. De plus, pour configurer le chiffrement des CloudWatch journaux, suivez les instructions de la section [Chiffrer les données des CloudWatch journaux dans les journaux à l'aide AWS Key Management Service](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/encrypt-log-data-kms.html) du *guide de l'utilisateur Amazon CloudWatch Logs*. Pour plus d’informations sur la création de configurations de sécurité, veuillez consulter [Gestion des configurations de sécurité sur la console AWS Glue](console-security-configurations.md). **Note** Des frais supplémentaires peuvent vous être facturés lorsque vous activez la journalisation et que des événements de CloudWatch journalisation supplémentaires sont créés. Pour plus d'informations, consultez les [ CloudWatch tarifs Amazon](https://aws.amazon.com/cloudwatch/pricing/). # Afficher les journaux des AWS Glue offres d'emploi Vous pouvez consulter les journaux en temps réel à l'aide de la AWS Glue console ou de la CloudWatch console Amazon. **Pour consulter les journaux en temps réel à l'aide du tableau de bord de AWS Glue la console** 1. Connectez-vous à la AWS Glue console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/). 1. Dans le volet de navigation, sélectionnez **Tâches**. 1. Ajouter ou démarrer une tâche existante. Choisissez **Action**, **Exécuter la tâche**. Lorsque vous démarrez l’exécution d’une tâche, vous accédez à une page qui contient des informations sur la tâche en cours d’exécution : + L’onglet **Journaux** affiche les journaux des applications agrégés plus anciens. + L’onglet **Journaux** affiche une barre de progression en temps réel lorsque la tâche est en cours d’exécution avec `glueContext` initialisé. + L'onglet **Logs** contient également les journaux des **pilotes, qui capturent les journaux** des pilotes Apache Spark en temps réel, et les journaux des applications à partir du script enregistré à l'aide de l'enregistreur d' AWS Glue applications lorsque le job est en cours d'exécution. 1. Pour les anciennes tâches, vous pouvez également afficher les journaux en temps réel sous la vue **Job History (Historique des tâches)** en choisissant **Journaux**. Cette action vous amène à la CloudWatch console qui affiche tous les flux de log du pilote Spark, de l'exécuteur et de la barre de progression pour cette tâche exécutée. **Pour consulter les journaux en temps réel à l'aide du tableau de bord de CloudWatch la console** 1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. Dans le volet de navigation, sélectionnez **Journaux**. 1. Choisissez le groupe de **journaux /aws-glue/jobs/error/**. 1. Dans la zone **Filtre**, collez l’ID d’exécution de la tâche Vous pouvez afficher les journaux du pilote, les journaux du programme d’exécution et la barre de progression (si vous utilisez le **Standard filter (Filtre standard)**). # Surveillance à l'aide de métriques d'observabilité AWS Glue **Note** Les métriques d’observabilité AWS Glue sont disponibles dans AWS Glue 4.0 et les versions ultérieures. Utilisez les métriques d'observabilité AWS Glue pour générer des informations sur ce qui se passe au sein de votre AWS Glue pour les tâches Apache Spark afin d'améliorer le triage et l'analyse des problèmes. Les métriques d'observabilité sont visualisées via des tableaux de bord Amazon CloudWatch et peuvent être utilisées pour analyser les causes racines des erreurs et pour diagnostiquer les goulots d'étranglement en matière de performance. Vous pouvez réduire le temps passé à déboguer les problèmes à l'échelle afin de vous concentrer sur leur résolution plus rapide et plus efficace. AWS GlueL'observabilité fournit des Amazon CloudWatch métriques classées dans les quatre groupes suivants : + **Fiabilité (par exemple, classes d'erreurs)** : identifier facilement les motifs d'échec les plus courants sur une plage de temps donnée que vous souhaiterez remédier. + **Performance (par exemple, asymétrie)** : identifier un goulot d'étranglement en matière de performance et appliquer des techniques de réglage. Par exemple, lorsque vos performances sont dégradées en raison de l'asymétrie des tâches, vous pouvez activer l'Exécution adaptative des requêtes Spark et affiner le seuil de jointure asymétrique. + **Débit (c'est-à-dire par source/sink débit)** : surveillez les tendances en matière de lecture et d'écriture de données. Vous pouvez également configurer des Amazon CloudWatch alarmes en cas d'anomalie. + **Utilisation des ressources (c'est-à-dire utilisation du personnel, de la mémoire et du disque)** : trouver de manière efficace les tâches dont l'utilisation des capacités est faible. Vous souhaiterez peut-être activer la mise à l'échelle automatique AWS Glue pour ces tâches. ## Mise en route avec les métriques d'observabilité AWS Glue **Note** Les nouvelles métriques sont disponibles par défaut dans la console AWS Glue Studio. **Pour configurer les métriques d’observabilité dans AWS Glue Studio :** 1. Connectez-vous à la console AWS Glue et choisissez les **tâches ETL** dans le menu de la console. 1. Choisissez une tâche en cliquant sur le nom de la tâche dans la section **Vos tâches**. 1. Sélectionnez l'onglet **Job details** (Détails de la tâche). 1. Faites défiler l'écran vers le bas et choisissez **Propriétés avancées**, puis **Metriques d'observabilité de la tâche**. ![\[La capture d'écran montre l'onglet Détails de la tâche Propriétés avancées. L'option Metriques d'observabilité de la tâche est mise en surbrillance.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/job-details-observability-metrics.png) **Pour activer les métriques AWS Glue d'observabilité à l'aide AWS CLI de :** + Ajoutez à la carte `--default-arguments` la valeur clé suivante dans le fichier JSON d'entrée : ``` --enable-observability-metrics, true ``` ## Utiliser l'observabilité AWS Glue Les métriques AWS Glue d'observabilité étant fournies via Amazon CloudWatch, vous pouvez utiliser la Amazon CloudWatch console AWS CLI, le SDK ou l'API pour interroger les points de données des métriques d'observabilité. Consultez la rubrique [Utilisation de l’observabilité Glue pour surveiller l’utilisation des ressources afin de réduire les coûts](https://aws.amazon.com/blogs/big-data/enhance-monitoring-and-debugging-for-aws-glue-jobs-using-new-job-observability-metrics/) pour un exemple de cas d’utilisation des métriques d’observabilité AWS Glue. ### Utilisation de l'AWS Glueobservabilité dans la console Amazon CloudWatch **Pour interroger et visualiser les métriques dans la Amazon CloudWatch console :** 1. Ouvrez la Amazon CloudWatch console et choisissez **Toutes les mesures**. 1. Sous Espaces de noms personnalisés, sélectionnez **AWS Glue**. 1. Choisissez les **métriques d'observabilité de la tâche, les métriques d'observabilité par source ou les métriques d'observabilité par récepteur**. 1. Recherchez le nom de la métrique, le nom de la tâche, l'ID d'exécution de la tâche spécifiques, puis sélectionnez-les. 1. Sous l'onglet **Métriques sous forme de graphique**, configurez vos statistiques, périodes et autres options préférées. ![\[La capture d'écran montre la Amazon CloudWatch console et le graphique des métriques.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/cloudwatch-console-metrics.png) **Pour interroger une métrique d'observabilité à l'aide AWS CLI de :** 1. Créez un fichier JSON de définition de métrique et remplacez `your-Glue-job-name` et `your-Glue-job-run-id` par les vôtres. ``` $ cat multiplequeries.json [ { "Id": "avgWorkerUtil_0", "MetricStat": { "Metric": { "Namespace": "Glue", "MetricName": "glue.driver.workerUtilization", "Dimensions": [ { "Name": "JobName", "Value": "" }, { "Name": "JobRunId", "Value": "" }, { "Name": "Type", "Value": "gauge" }, { "Name": "ObservabilityGroup", "Value": "resource_utilization" } ] }, "Period": 1800, "Stat": "Minimum", "Unit": "None" } }, { "Id": "avgWorkerUtil_1", "MetricStat": { "Metric": { "Namespace": "Glue", "MetricName": "glue.driver.workerUtilization", "Dimensions": [ { "Name": "JobName", "Value": "" }, { "Name": "JobRunId", "Value": "" }, { "Name": "Type", "Value": "gauge" }, { "Name": "ObservabilityGroup", "Value": "resource_utilization" } ] }, "Period": 1800, "Stat": "Minimum", "Unit": "None" } } ] ``` 1. Exécutez la commande `get-metric-data` : ``` $ aws cloudwatch get-metric-data --metric-data-queries file: //multiplequeries.json \ --start-time '2023-10-28T18: 20' \ --end-time '2023-10-28T19: 10' \ --region us-east-1 { "MetricDataResults": [ { "Id": "avgWorkerUtil_0", "Label": "", "Timestamps": [ "2023-10-28T18:20:00+00:00" ], "Values": [ 0.06718750000000001 ], "StatusCode": "Complete" }, { "Id": "avgWorkerUtil_1", "Label": "", "Timestamps": [ "2023-10-28T18:50:00+00:00" ], "Values": [ 0.5959183673469387 ], "StatusCode": "Complete" } ], "Messages": [] } ``` ## Métriques d'observabilité AWS GlueL'observabilité établit des profils et envoie les métriques suivantes Amazon CloudWatch toutes les 30 secondes, et certaines de ces métriques peuvent être visibles sur la page de surveillance des AWS Glue Studio Job Runs. | Métrique | Description | Catégorie | | --- | --- | --- | | glue.driver.skewness.stage | Catégorie de métrique : job\$1performance L’asymétrie d’exécution des étapes Spark : cette métrique indique la durée maximale d’une tâche à une étape donnée par rapport à la durée médiane d’une tâche à cette étape. Elle capture l’asymétrie d’exécution, qui peut être causée par une asymétrie des données d’entrée ou par une transformation (par exemple, une jointure asymétrique). Les valeurs de cette métrique se situent dans l’intervalle [0, infini], où 0 signifie que le rapport entre le temps d’exécution maximum et médian des tâches, parmi toutes les tâches de l’étape, est inférieur à un certain facteur d’asymétrie d’étape. Le facteur d’asymétrie d’étape par défaut est « 5 » et il peut être modifié via la configuration Spark : spark.metrics.conf.driver.source.glue.jobPerformance.skewnessFactor Une valeur d’asymétrie d’étape de 1 signifie que le rapport est le double du facteur d’asymétrie d’étape. La valeur de l’asymétrie d’étape est mise à jour toutes les 30 secondes pour refléter l’asymétrie actuelle. La valeur en fin d’étape reflète l’asymétrie finale de l’étape. Cette métrique au niveau de l’étape est utilisée pour calculer la métrique `glue.driver.skewness.job` au niveau de la tâche. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (job\$1performance) Statistiques valides : moyenne, maximum, minimum, centile Unité : nombre | job\$1performance | | glue.driver.skewness.job | Catégorie de métrique : job\$1performance L’asymétrie de la tâche est le maximum de l’asymétrie pondérée de toutes les étapes. L’asymétrie d’étape (glue.driver.skewness.stage) est pondérée en fonction de la durée de l’étape. Cela permet d’éviter le cas particulier où une étape très asymétrique s’exécute en réalité pendant un temps très court par rapport aux autres étapes (et donc son asymétrie n’est pas significative pour la performance globale de la tâche et ne mérite pas l’effort de tenter de la corriger). Cette métrique est mise à jour à la fin de chaque étape. La dernière valeur reflète donc l’asymétrie globale réelle de la tâche. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (job\$1performance) Statistiques valides : moyenne, maximum, minimum, centile Unité : nombre | job\$1performance | | glue.succeed.ALL | Catégorie de métrique : erreur Nombre total d’exécutions de tâches réussies, pour compléter le tableau des catégories d’échec Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (nombre) et ObservabilityGroup (erreur) Statistiques valides : SUM Unité : nombre | error | | glue.error.ALL | Catégorie de métrique : erreur Nombre total d’erreurs d’exécution de tâche, pour compléter le tableau des catégories d’échec Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (nombre) et ObservabilityGroup (erreur) Statistiques valides : SUM Unité : nombre | error | | glue.error.[error category] | Catégorie de métrique : erreur Il s’agit en fait d’un ensemble de métriques, qui sont mises à jour uniquement lorsqu’une exécution de tâche échoue. La catégorisation des erreurs facilite le triage et le débogage. Lorsqu’une exécution de tâche échoue, l’erreur à l’origine de l’échec est catégorisée et la métrique de la catégorie d’erreur correspondante est définie à 1. Cela permet d’effectuer une analyse des échecs au fil du temps, ainsi qu’une analyse des erreurs sur l’ensemble des tâches, afin d’identifier les catégories d’échec les plus courantes et de commencer à y remédier. AWS Glue compte 28 catégories d’erreur, dont OUT\$1OF\$1MEMORY (manque de mémoire) (pilote et exécuteur), PERMISSION (autorisation), SYNTAX (syntaxe) et THROTTLING (limitation). Les catégories d’erreur incluent également les catégories d’erreur COMPILATION, LAUNCH et TIMEOUT. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (nombre) et ObservabilityGroup (erreur) Statistiques valides : SUM Unité : nombre | error | | glue.driver.workerUtilization | Catégorie de métrique : resource\$1utilization Le pourcentage des travailleurs affectés qui sont réellement utilisés. Si ce n’est pas bon, l’autoscaling peut vous aider. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (resource\$1utilization) Statistiques valides : moyenne, maximum, minimum, centile Unité : pourcentage | resource\$1utilization | | glue.driver.memory.heap.[available \$1 used] | Catégorie de métrique : resource\$1utilization Tas disponible/utilisé par le pilote pendant l’exécution de la tâche. Cela aide à comprendre les tendances d’utilisation de la mémoire, particulièrement au fil du temps, ce qui peut contribuer à éviter des échecs potentiels, en plus de déboguer les échecs liés à la mémoire. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (resource\$1utilization) Statistiques valides : moyenne Unité : octets | resource\$1utilization | | glue.driver.memory.heap.used.percentage | Catégorie de métrique : resource\$1utilization Tas utilisé (%) par le pilote pendant l’exécution de la tâche. Cela aide à comprendre les tendances d’utilisation de la mémoire, particulièrement au fil du temps, ce qui peut contribuer à éviter des échecs potentiels, en plus de déboguer les échecs liés à la mémoire. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (resource\$1utilization) Statistiques valides : moyenne Unité : pourcentage | resource\$1utilization | | glue.driver.memory.non-heap.[available \$1 used] | Catégorie de métrique : resource\$1utilization Mémoire hors tas disponible/utilisée par le pilote pendant l’exécution de la tâche. Cela aide à comprendre les tendances d’utilisation de la mémoire, particulièrement au fil du temps, ce qui peut contribuer à éviter des échecs potentiels, en plus de déboguer les échecs liés à la mémoire. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (resource\$1utilization) Statistiques valides : moyenne Unité : octets | resource\$1utilization | | glue.driver.memory.non-heap.used.percentage | Catégorie de métrique : resource\$1utilization Mémoire hors tas utilisée (%) par le pilote pendant l’exécution de la tâche. Cela aide à comprendre les tendances d’utilisation de la mémoire, particulièrement au fil du temps, ce qui peut contribuer à éviter des échecs potentiels, en plus de déboguer les échecs liés à la mémoire. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (resource\$1utilization) Statistiques valides : moyenne Unité : pourcentage | resource\$1utilization | | glue.driver.memory.total.[available \$1 used] | Catégorie de métrique : resource\$1utilization Mémoire totale disponible/utilisée par le pilote pendant l’exécution de la tâche. Cela aide à comprendre les tendances d’utilisation de la mémoire, particulièrement au fil du temps, ce qui peut contribuer à éviter des échecs potentiels, en plus de déboguer les échecs liés à la mémoire. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (resource\$1utilization) Statistiques valides : moyenne Unité : octets | resource\$1utilization | | glue.driver.memory.total.used.percentage | Catégorie de métrique : resource\$1utilization Mémoire totale utilisée (%) par le pilote pendant l’exécution de la tâche. Cela aide à comprendre les tendances d’utilisation de la mémoire, particulièrement au fil du temps, ce qui peut contribuer à éviter des échecs potentiels, en plus de déboguer les échecs liés à la mémoire. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (resource\$1utilization) Statistiques valides : moyenne Unité : pourcentage | resource\$1utilization | | glue.ALL.memory.heap.[available \$1 used] | Catégorie de métrique : resource\$1utilization Le tas de mémoire des exécuteurs testamentaires available/used . ALL signifie tous les exécuteurs. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (resource\$1utilization) Statistiques valides : moyenne Unité : octets | resource\$1utilization | | glue.ALL.memory.heap.used.percentage | Catégorie de métrique : resource\$1utilization Tas utilisé (%) par les exécuteurs. ALL signifie tous les exécuteurs. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (resource\$1utilization) Statistiques valides : moyenne Unité : pourcentage | resource\$1utilization | | glue.ALL.memory.non-heap.[available \$1 used] | Catégorie de métrique : resource\$1utilization La mémoire available/used hors tas des exécuteurs. ALL signifie tous les exécuteurs. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (resource\$1utilization) Statistiques valides : moyenne Unité : octets | resource\$1utilization | | glue.ALL.memory.non-heap.used.percentage | Catégorie de métrique : resource\$1utilization Mémoire hors tas /utilisée (%) par les exécuteurs. ALL signifie tous les exécuteurs. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (resource\$1utilization) Statistiques valides : moyenne Unité : pourcentage | resource\$1utilization | | glue.ALL.memory.total.[available \$1 used] | Catégorie de métrique : resource\$1utilization Mémoire available/used totale des exécuteurs. ALL signifie tous les exécuteurs. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (resource\$1utilization) Statistiques valides : moyenne Unité : octets | resource\$1utilization | | glue.ALL.memory.total.used.percentage | Catégorie de métrique : resource\$1utilization Mémoire totale utilisée (%) par les exécuteurs. ALL signifie tous les exécuteurs. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (resource\$1utilization) Statistiques valides : moyenne Unité : pourcentage | resource\$1utilization | | glue.driver.disk.[available\$1GB \$1 used\$1GB] | Catégorie de métrique : resource\$1utilization L'espace available/used disque du pilote pendant l'exécution de la tâche. Cela aide à comprendre les tendances d’utilisation du disque, particulièrement au fil du temps, ce qui peut contribuer à éviter des échecs potentiels, en plus de déboguer les échecs liés à un espace disque insuffisant. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (resource\$1utilization) Statistiques valides : moyenne Unité : gigaoctets | resource\$1utilization | | glue.driver.disk.used.percentage] | Catégorie de métrique : resource\$1utilization L'espace available/used disque du pilote pendant l'exécution de la tâche. Cela aide à comprendre les tendances d’utilisation du disque, particulièrement au fil du temps, ce qui peut contribuer à éviter des échecs potentiels, en plus de déboguer les échecs liés à un espace disque insuffisant. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (resource\$1utilization) Statistiques valides : moyenne Unité : pourcentage | resource\$1utilization | | glue.ALL.disk.[available\$1GB \$1 used\$1GB] | Catégorie de métrique : resource\$1utilization L' available/used espace disque des exécuteurs. ALL signifie tous les exécuteurs. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (resource\$1utilization) Statistiques valides : moyenne Unité : gigaoctets | resource\$1utilization | | glue.ALL.disk.used.percentage | Catégorie de métrique : resource\$1utilization Espace disque available/used/used (%) des exécuteurs. ALL signifie tous les exécuteurs. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (gauge) et ObservabilityGroup (resource\$1utilization) Statistiques valides : moyenne Unité : pourcentage | resource\$1utilization | | glue.driver.bytesRead | Catégorie de métrique : débit Nombre d’octets lus par source d’entrée lors de cette exécution de tâche, ainsi que pour TOUTES les sources. Cela aide à comprendre le volume de données et ses variations au fil du temps, ce qui est utile pour résoudre des problèmes tels que l’asymétrie des données. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (jauge), ObservabilityGroup (resource\$1utilization) et la source (emplacement des données source) Statistiques valides : moyenne Unité : octets | débit | | glue.driver.[recordsRead \$1 filesRead] | Catégorie de métrique : débit Le nombre de records/files lectures par source d'entrée dans ce travail exécuté, ainsi que pour TOUTES les sources. Cela aide à comprendre le volume de données et ses variations au fil du temps, ce qui est utile pour résoudre des problèmes tels que l’asymétrie des données. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (jauge), ObservabilityGroup (resource\$1utilization) et la source (emplacement des données source) Statistiques valides : moyenne Unité : nombre | débit | | glue.driver.partitionsRead | Catégorie de métrique : débit Nombre de partitions lues par source d’entrée Amazon S3 dans cette exécution de tâche, ainsi que pour TOUTES les sources. Dimensions valides : JobName (le nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), le type (jauge), ObservabilityGroup (resource\$1utilization) et la source (emplacement des données source) Statistiques valides : moyenne Unité : nombre | débit | | glue.driver.bytesWrittten | Catégorie de métrique : débit Nombre d’octets écrits par récepteur de sortie dans cette exécution de tâche, ainsi que pour TOUS les récepteurs. Cela aide à comprendre le volume de données et son évolution au fil du temps, ce qui est utile pour résoudre des problèmes tels que l’asymétrie de traitement. Dimensions valides : JobName (nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), Type (gauge), (resource\$1utilization) et Sink ObservabilityGroup (emplacement des données du récepteur) Statistiques valides : moyenne Unité : octets | débit | | glue.driver.[recordsWritten \$1 filesWritten] | Catégorie de métrique : débit Le nombre de récepteurs records/files écrits par récepteur de sortie lors de cette exécution de travail, ainsi que pour TOUS les récepteurs. Cela aide à comprendre le volume de données et son évolution au fil du temps, ce qui est utile pour résoudre des problèmes tels que l’asymétrie de traitement. Dimensions valides : JobName (nom du AWS Glue Job), JobRunId (l' JobRun ID ou ALL), Type (gauge), (resource\$1utilization) et Sink ObservabilityGroup (emplacement des données du récepteur) Statistiques valides : moyenne Unité : nombre | débit | ## Catégories d’erreur | Catégories d’erreur | Description | | --- | --- | | COMPILATION\$1ERROR | Des erreurs surviennent lors de la compilation du code Scala. | | CONNECTION\$1ERROR | Des erreurs se produisent lors de la connexion à un service/remote hébergeur ou à un service de base de données, etc. | | DISK\$1NO\$1SPACE\$1ERROR | Des erreurs surviennent lorsqu’il n’y a plus d’espace disponible sur le disque du pilote/de l’exécuteur. | | OUT\$1OF\$1MEMORY\$1ERROR | Des erreurs surviennent lorsqu’il n’y a plus d’espace disponible dans la mémoire du pilote/de l’exécuteur. | | IMPORT\$1ERROR | Des erreurs surviennent lors de l’importation de dépendances. | | INVALID\$1ARGUMENT\$1ERROR | Des erreurs surviennent lorsque les arguments d’entrée ne sont pas valides/sont illégaux. | | PERMISSION\$1ERROR | Les erreurs surviennent en cas d’absence d’autorisation d’accès au service, aux données, etc. | | RESOURCE\$1NOT\$1FOUND\$1ERROR | Des erreurs surviennent lorsque les données, l’emplacement, etc. ne sont pas disponibles. | | QUERY\$1ERROR | Des erreurs surviennent lors de l’exécution de requêtes SQL dans Spark. | | SYNTAX\$1ERROR | Des erreurs surviennent lorsqu’il y a une erreur de syntaxe dans le script. | | THROTTLING\$1ERROR | Des erreurs surviennent lorsqu’une limite de simultanéité de service est atteinte ou qu’une limitation de quota de service est dépassée. | | DATA\$1LAKE\$1FRAMEWORK\$1ERROR | Des erreurs surviennent à partir d’un environnement de lac de données pris en charge nativement par AWS Glue, comme Hudi, Iceberg, etc. | | UNSUPPORTED\$1OPERATION\$1ERROR | Des erreurs surviennent lors d’une opération non prise en charge. | | RESOURCES\$1ALREADY\$1EXISTS\$1ERROR | Des erreurs surviennent lorsqu’une ressource à créer ou à ajouter existe déjà. | | GLUE\$1INTERNAL\$1SERVICE\$1ERROR | Les erreurs surviennent lorsqu’il y a un problème de service interne de AWS Glue. | | GLUE\$1OPERATION\$1TIMEOUT\$1ERROR | Des erreurs surviennent lorsqu’une opération AWS Glue dépasse le délai imparti. | | GLUE\$1VALIDATION\$1ERROR | Des erreurs surviennent lorsqu’une valeur requise ne peut pas être validée pour la tâche AWS Glue. | | GLUE\$1JOB\$1BOOKMARK\$1VERSION\$1MISMATCH\$1ERROR | Des erreurs surviennent lorsque le même job exécute le même bucket source et écrit simultanément sur la same/different destination (simultanéité >1) | | LAUNCH\$1ERROR | Des erreurs surviennent lors de la phase de lancement de la tâche AWS Glue. | | DYNAMODB\$1ERROR | Les erreurs génériques proviennent du Amazon DynamoDB service. | | GLUE\$1ERROR | Les erreurs génériques proviennent du service AWS Glue. | | LAKEFORMATION\$1ERROR | Les erreurs génériques proviennent du AWS Lake Formation service. | | REDSHIFT\$1ERROR | Les erreurs génériques proviennent du Amazon Redshift service. | | S3\$1ERROR | Les erreurs génériques proviennent du service Amazon S3. | | SYSTEM\$1EXIT\$1ERROR | Erreur de sortie du système générique. | | TIMEOUT\$1ERROR | Des erreurs génériques surviennent lorsque la tâche échoue en raison du dépassement du délai d’exécution de l’opération. | | UNCLASSIFIED\$1SPARK\$1ERROR | Les erreurs génériques proviennent de Spark. | | UNCLASSIFIED\$1ERROR | Catégorie d’erreur par défaut. | ## Limitations **Note** `glueContext` doit être initialisé pour publier les métriques. Dans la dimension source, la valeur est soit le chemin Amazon S3, soit le nom de la table, selon le type de source. En outre, si la source est JDBC et que l’option de requête est utilisée, la chaîne de requête est définie dans la dimension source. Si la valeur est supérieure à 500 caractères, elle est réduite à 500  caractères maximum. Les limites de la valeur sont les suivantes : + Les caractères non ASCII seront supprimés. + Si le nom de la source ne contient aucun caractère ASCII, il est converti en . ### Limites et considérations relatives aux métriques de débit + DataFrame et DataFrame basés DynamicFrame (par exemple JDBC, lecture depuis parquet sur Amazon S3) sont pris en charge, mais les fichiers basés sur RDD DynamicFrame (par exemple, lecture de csv, de json sur Amazon S3, etc.) ne sont pas pris en charge. Techniquement, toutes les lectures et écritures visibles sur l’interface utilisateur de Spark sont prises en charge. + La métrique `recordsRead` sera émise si la source de données est une table de catalogue et que le format est JSON, CSV, texte ou Iceberg. + Les métriques `glue.driver.throughput.recordsWritten`, `glue.driver.throughput.bytesWritten` et `glue.driver.throughput.filesWritten` ne sont pas disponibles dans les tables JDBC et Iceberg. + Les métriques peuvent être retardées. Si le travail se termine dans environ une minute, il se peut qu'il n'y ait aucune métrique de débit dans Amazon CloudWatch Metrics. # Surveillance et débogage des tâches Vous pouvez collecter des statistiques sur les AWS Glue offres d'emploi et les visualiser sur les AWS Glue CloudWatch consoles Amazon afin d'identifier et de résoudre les problèmes. Le profilage de vos tâches AWS Glue requiert les étapes suivantes : 1. Activation des métriques : 1. Activer l'option de **métriques de tâche** dans la définition de la tâche. Vous pouvez activer le profilage dans la console AWS Glue ou en tant que paramètre de la tâche. Pour plus d'informations, consultez [Définition des propriétés des tâches Spark](add-job.md#create-job) ou [Utilisation des paramètres des tâches dans les tâches AWS Glue](aws-glue-programming-etl-glue-arguments.md). 1. Activez l’option **Métriques d’observabilité AWS Glue** dans la définition de la tâche. Vous pouvez activer l’observabilité dans la console AWS Glue ou en tant que paramètre de la tâche. Pour de plus amples informations, veuillez consulter [Surveillance à l'aide de métriques d'observabilité AWS Glue](monitor-observability.md). 1. Vérifiez que le script de la tâche initialise un `GlueContext`. Par exemple, l'extrait de script suivant initialise un `GlueContext` et indique où le code profilé est placé dans le script. Ce format général est utilisé dans les scénarios de débogage suivants. ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job import time ## @params: [JOB_NAME] args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME'], args) ... ... code-to-profile ... ... job.commit() ``` 1. Exécutez la tâche. 1. Visualisez les métriques : 1. Visualisez les métriques sur la console AWS Glue et identifiez les métriques anormales pour le pilote ou un exécuteur. 1. Consultez les indicateurs d'observabilité sur la page de surveillance des tâches, sur la page des détails de l'exécution des tâches ou sur Amazon CloudWatch. Pour de plus amples informations, veuillez consulter [Surveillance à l'aide de métriques d'observabilité AWS Glue](monitor-observability.md). 1. Précisez la cause première à l'aide de la métrique identifiée. 1. Confirmez éventuellement la cause première à l'aide du flux de journaux du pilote identifié ou du programme d'exécution. **Cas d’utilisation des métriques d’observabilité AWS Glue** + [Débogage des exceptions OOM et des anomalies de tâches](monitor-profile-debug-oom-abnormalities.md) + [Débogage d'étapes exigeantes et de tâches de ralentissement](monitor-profile-debug-straggler.md) + [Surveillance de la progression des tâches multiples](monitor-debug-multiple.md) + [Surveillance de la planification des capacités de DPU](monitor-debug-capacity.md) + [Utilisation de l’observabilité AWS Glue pour surveiller l’utilisation des ressources afin de réduire les coûts](https://aws.amazon.com/blogs/big-data/enhance-monitoring-and-debugging-for-aws-glue-jobs-using-new-job-observability-metrics) # Débogage des exceptions OOM et des anomalies de tâches Vous pouvez déboguer les exceptions out-of-memory (OOM) et les anomalies de tâches dans. AWS Glue Les sections suivantes décrivent les scénarios de débogage des out-of-memory exceptions du pilote Apache Spark ou d'un exécuteur Spark. + [Débogage d'un pilote d'exception OOM](#monitor-profile-debug-oom-driver) + [Débogage d'un programme d’exécution d'exception OOM](#monitor-profile-debug-oom-executor) ## Débogage d'un pilote d'exception OOM Dans ce scénario, une tâche Spark lit un grand nombre de petits fichiers d'Amazon Simple Storage Service (Amazon S3). Il convertit les fichiers au format Apache Parquet, puis les écrit dans Amazon S3. Le pilote Spark manque de mémoire. Les données d'entrées Amazon S3 comptent plus d'un million de fichiers dans différentes partitions Amazon S3. Le code profilé est le suivant : ``` data = spark.read.format("json").option("inferSchema", False).load("s3://input_path") data.write.format("parquet").save(output_path) ``` ### Visualisez les métriques profilées sur la console AWS Glue Le graphique suivant illustre l'utilisation de la mémoire sous forme de pourcentage pour le pilote et les programmes d'exécution. Cette utilisation est déterminée par un point de données qui est moyenné sur les valeurs rapportées au cours de la dernière minute. Vous pouvez voir dans le profil de la mémoire de la tâche que le [pilote de la mémoire](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.jvm.heap.usage) dépasse le seuil de sécurité de 50 % d'utilisation rapidement. D'autre part, l' [utilisation moyenne de la mémoire](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage) sur l'ensemble des programmes d'exécution reste inférieure à 4 %. Ceci montre clairement l'anomalie de l'exécution du pilote dans cette tâche Spark. ![\[L' utilisation de la mémoire (en %) pour le pilote et les programmes d'exécution.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-oom-memoryprofile.png) L'exécution de la tâche ne tarde pas à échouer et l'erreur suivante apparaît dans l'onglet **Historique** de la console AWS Glue : Command Failed with Exit Code 1. Cette chaîne d'erreur signifie que la tâche a échoué en raison d'une erreur systémique ; dans le cas présent, le pilote manque de mémoire. ![\[Le message d'erreur affiché sur la console AWS Glue.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-oom-errorstring.png) Sur la console, cliquez sur le lien **Journaux d'erreurs** dans **l'onglet Historique** pour confirmer les conclusions relatives au pilote OOM contenues dans les CloudWatch journaux. Recherchez « **Error** » dans les journaux d'erreurs de la tâche pour vérifier que c'est bien à cause d'une exception OOM que la tâche a échoué : ``` # java.lang.OutOfMemoryError: Java heap space # -XX:OnOutOfMemoryError="kill -9 %p" # Executing /bin/sh -c "kill -9 12039"... ``` Dans l'onglet **Historique** de la tâche, choisissez **Journaux**. Vous pouvez trouver la trace suivante de l'exécution du pilote dans les CloudWatch journaux au début de la tâche. Le pilote Spark essaie de répertorier tous les fichiers dans tous les répertoires, il génère un `InMemoryFileIndex`et lance une tâche par fichier. Par conséquent, le pilote Spark doit conserver une grande quantité d'état en mémoire pour suivre toutes les tâches. Il met en cache une liste complète comprenant un grand nombre de fichiers pour l'index en mémoire, ce qui se traduit par un pilote OOM. ### Corriger le traitement de fichiers multiples grâce au regroupement Vous pouvez corriger le traitement de plusieurs fichiers en utilisant la fonction de *regroupement* dans AWS Glue. Le regroupement est automatiquement activé lorsque vous utilisez des images dynamiques et lorsque l'ensemble des données d'entrée compte un grand nombre de fichiers (plus de 50 000). Le regroupement vous permet de fusionner plusieurs fichiers en un groupe, et il permet à une tâche de traiter l'ensemble du groupe plutôt qu'un seul fichier. Par conséquent, le pilote Spark stocke nettement moins d'état en mémoire pour suivre moins de tâches. Pour plus d'informations sur l'activation manuelle du regroupement pour votre ensemble de données, consultez [Lecture des fichiers en entrée dans des groupes de plus grande taille](grouping-input-files.md). Pour consulter le profil de la mémoire de la tâche AWS Glue, profilez le code suivant avec la fonction de regroupement activée : ``` df = glueContext.create_dynamic_frame_from_options("s3", {'paths': ["s3://input_path"], "recurse":True, 'groupFiles': 'inPartition'}, format="json") datasink = glueContext.write_dynamic_frame.from_options(frame = df, connection_type = "s3", connection_options = {"path": output_path}, format = "parquet", transformation_ctx = "datasink") ``` Vous pouvez surveiller le profil de la mémoire et le déplacement des données ETL dans le profil AWS Glue de la tâche. Le pilote s'exécute sous le seuil de 50 % d'utilisation de la mémoire sur toute la durée de la tâche AWS Glue. Les programmes d'exécution diffusent des données depuis Amazon S3, les traitent et les écrivent dans Amazon S3. Par conséquent, ils consomment moins de 5 % de mémoire, quel que soit le moment. ![\[Le profil de la mémoire affichant que le problème est résolu.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-oom-memoryprofile-fixed.png) Le profil de déplacement des données ci-dessous montre le nombre total d'octets d'Amazon S3 [lus](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes) et [écrits](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes) au cours de la dernière minute par tous les programmes d'exécution à mesure que la tâche progresse. Les deux suivent un modèle similaire car les données sont diffusées sur tous les programmes d'exécution. La tâche finir de traiter le million de fichiers en moins de trois heures. ![\[Le profil de déplacement des données affichant que le problème est résolu.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-oom-etlmovement.png) ## Débogage d'un programme d’exécution d'exception OOM Dans ce scénario, vous pouvez apprendre à déboguer des exceptions OOM pouvant se produire dans les programmes d'exécution d'Apache Spark. Le code suivant utilise le lecteur MySQL Spark pour lire une grande table d'environ 34 millions de lignes dans une tramedonnées Spark. Il l'écrit ensuite sur Amazon S3 au format Parquet. Vous pouvez fournir les propriétés de connexion et utiliser les configurations Spark par défaut pour lire la table. ``` val connectionProperties = new Properties() connectionProperties.put("user", user) connectionProperties.put("password", password) connectionProperties.put("Driver", "com.mysql.jdbc.Driver") val sparkSession = glueContext.sparkSession val dfSpark = sparkSession.read.jdbc(url, tableName, connectionProperties) dfSpark.write.format("parquet").save(output_path) ``` ### Voir les métriques profilées sur la console AWS Glue Si la pente du graphique d'utilisation de la mémoire est positive et dépasse 50 %, si la tâche échoue avant l'émission de la métrique suivante, l'épuisement de la mémoire peut en être à l’origine. Le graphique suivant montre qu'en une minute d'exécution, l'[utilisation moyenne de la mémoire](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage) sur tous les programmes d'exécution dépasse rapidement 50 %. L'utilisation peut atteindre 92 % et le conteneur qui exécute le programme d'exécution est arrêté par Apache Hadoop YARN. ![\[L'utilisation moyenne de la mémoire sur tous les programmes d'exécution.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-oom-2-memoryprofile.png) Comme le montre le graphique suivant, un [programme d'exécution unique](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberAllExecutors) s'exécute toujours jusqu'à ce que la tâche échoue. En effet, un nouveau programme d'exécution est lancé pour remplacer celui qui a été arrêté. Les lectures de la source de données JDBC ne sont pas parallélisées par défaut, car cela nécessiterait le partitionnement de la table sur une colonne et d'ouvrir plusieurs connexions. Par conséquent, seul un programme d'exécution lit dans la table complète de manière séquentielle. ![\[L'exécution de la tâche montre un programme d'exécution unique jusqu'à ce que la tâche échoue.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-oom-2-execution.png) Comme le montre le graphique suivant, Spark tente de lancer une nouvelle tâche quatre fois avant l'échec de la tâche. Vous pouvez voir le [profil de la mémoire](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.used) de trois programmes d'exécution. Chaque programme d'exécution utilise rapidement toute sa mémoire. La quatrième programme d'exécution manque de mémoire et la tâche échoue. Par conséquent, sa métrique n'est pas immédiatement reportée. ![\[Les profils de mémoire des programmes d'exécution.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-oom-2-exec-memprofile.png) À partir de la chaîne d'erreur sur la console AWS Glue, vous pouvez vérifier que la tâche a échoué en raison d'exceptions OOM, comme le montre l'image suivante. ![\[Le message d'erreur affiché sur la console AWS Glue.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-oom-2-errorstring.png) **Journaux de sortie des tâches :** pour confirmer la découverte d'une exception OOM de l'exécuteur, consultez les CloudWatch journaux. Lorsque vous recherchez **Error**, vous trouvez les quatre programme d'exécution arrêtés en à peu près le même temps que la fenêtre l'affiche sur le tableau de bord des métriques. Ils sont tous résiliés par YARN à mesure qu'ils excèdent les limites de mémoire. Programme d'exécution 1 ``` 18/06/13 16:54:29 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:54:29 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:54:29 ERROR YarnClusterScheduler: Lost executor 1 on ip-10-1-2-175.ec2.internal: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:54:29 WARN TaskSetManager: Lost task 0.0 in stage 0.0 (TID 0, ip-10-1-2-175.ec2.internal, executor 1): ExecutorLostFailure (executor 1 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. ``` Programme d'exécution 2 ``` 18/06/13 16:55:35 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:55:35 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:55:35 ERROR YarnClusterScheduler: Lost executor 2 on ip-10-1-2-16.ec2.internal: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:55:35 WARN TaskSetManager: Lost task 0.1 in stage 0.0 (TID 1, ip-10-1-2-16.ec2.internal, executor 2): ExecutorLostFailure (executor 2 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. ``` Programme d'exécution 3 ``` 18/06/13 16:56:37 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:56:37 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:56:37 ERROR YarnClusterScheduler: Lost executor 3 on ip-10-1-2-189.ec2.internal: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:56:37 WARN TaskSetManager: Lost task 0.2 in stage 0.0 (TID 2, ip-10-1-2-189.ec2.internal, executor 3): ExecutorLostFailure (executor 3 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. ``` Programme d'exécution 4 ``` 18/06/13 16:57:18 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:57:18 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:57:18 ERROR YarnClusterScheduler: Lost executor 4 on ip-10-1-2-96.ec2.internal: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:57:18 WARN TaskSetManager: Lost task 0.3 in stage 0.0 (TID 3, ip-10-1-2-96.ec2.internal, executor 4): ExecutorLostFailure (executor 4 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. ``` ### Corriger le paramètre de taille d'extraction à l'aide des images dynamiques AWS Glue Le programme d'exécution est arrivé à court de mémoire lors de la lecture de la table JDBC, car la configuration par défaut de la taille d'extraction du JDBC de Spark est zéro. Cela signifie que le pilote JDBC sur le programme d'exécution Spark tente d'extraire les 34 millions de lignes de la base de données et de les mettre en cache, même si Spark diffuse les lignes une par une. Avec Spark, vous pouvez éviter ce scénario en définissant le paramètre de taille d'extraction par une valeur autre que zéro. Vous pouvez également résoudre ce problème en utilisant des images dynamiques AWS Glue. Par défaut, les images dynamiques utilisent une taille d'extraction de 1 000 lignes, qui est généralement une valeur suffisante. Par conséquent, le programme d'exécution n'utilise pas plus de 7 % de la mémoire totale. La tâche AWS Glue s'achève en moins de deux minutes avec un seul programme d'exécution. L'utilisation des images dynamiques AWS Glue est l'approche recommandée, mais il est également possible de définir la taille d'extraction à l'aide de la propriété Apache Spark `fetchsize`. Consultez le [guide de Spark SQL DataFrames et des ensembles de données](https://spark.apache.org/docs/2.2.0/sql-programming-guide.html#jdbc-to-other-databases). ``` val (url, database, tableName) = { ("jdbc_url", "db_name", "table_name") } val source = glueContext.getSource(format, sourceJson) val df = source.getDynamicFrame glueContext.write_dynamic_frame.from_options(frame = df, connection_type = "s3", connection_options = {"path": output_path}, format = "parquet", transformation_ctx = "datasink") ``` **Métriques profilées normales :** La [mémoire du programme d'exécution](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage) avec les images dynamiques d'AWS Glue ne dépasse jamais le seuil de sécurité, comme le montre l'image suivante. Il diffuse dans les lignes depuis la base de données et met en cache 1 000 lignes seulement dans le pilote JDBC quel que soit le moment. Une exception de mémoire insuffisante ne se produit pas. ![\[La console AWS Glue montrant la mémoire du programme d'exécution en dessous du seuil de sécurité.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-oom-2-memoryprofile-fixed.png) # Débogage d'étapes exigeantes et de tâches de ralentissement Vous pouvez utiliser le profilage de tâche AWS Glue pour identifier les étapes exigeantes et les tâches de ralentissement dans vos tâches ETL (extraction, transformation et chargement). Un tâche de ralentissement prend beaucoup plus de temps que le reste des tâches dans l'étape d'une tâche AWS Glue. Par conséquent, l'étape s'effectue plus lentement, ce qui retarde aussi la durée d'exécution totale de la tâche. ## Fusion de petits fichiers d'entrée pour obtenir de plus grands fichiers de sortie Une tâche de ralentissement a lieu lorsque la distribution du travail au sein des différentes tâches n'est pas uniforme, ou qu'une asymétrie de données entraîne un plus important traitement de données par une tâche. Vous pouvez profiler le code suivant un modèle commun dans Apache Spark pour fusionner un grand nombre de petits fichiers en de plus grands fichiers de sortie. Pour cet exemple, l'ensemble de données d'entrée est de 32 Go de fichiers compressés Gzip JSON. L'ensemble de données de sortie a environ 190 Go de fichiers JSON décompressés. Le code profilé est le suivant : ``` datasource0 = spark.read.format("json").load("s3://input_path") df = datasource0.coalesce(1) df.write.format("json").save(output_path) ``` ### Voir les métriques profilées sur la console AWS Glue Vous pouvez profiler votre tâche pour examiner quatre différents ensembles de métriques : + Déplacement de données ETL + Remaniement de données sur les programmes d'exécution + Exécution d’une tâche + Profil de mémoire **Déplacement des données ETL** : Dans le profil du **Déplacement des données ETL**, les octets sont [lus](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes) assez rapidement par tous les programmes d'exécution lors de la première étape qui se termine au cours des six premières minutes. Toutefois, la durée totale d'exécution de la tâche est d'environ une heure, et elle est principalement constituée des [écritures](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes) de données. ![\[Graphique affichant le profil du déplacement des données ETL.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-straggler-1.png) **Remaniement de données sur les programmes d'exécution :** Le nombre d'octets [lus](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleLocalBytesRead) et [écrits](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleBytesWritten) au cours du remaniement montre également un pic avant la fin de l'étape 2, comme le montrent les métriques de l'**Exécution de tâche** et du **Remaniement de données**. Suite au remaniement des données de tous les programmes d'exploitation, toutes les lectures et les écritures proviennent uniquement du programme d'exécution n°3. ![\[Les métriques pour le remaniement des données sur les programmes d'exploitation.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-straggler-2.png) **Exécution de tâche :** Comme le montre le graphique ci-dessous, tous les autres programmes d'exécution sont inactifs et sont finalement abandonnés avant 10:09. A ce stade, le nombre total de programmes d'exécution diminue et il n'en reste qu'un. Ceci montre clairement que le programme d'exécution numéro 3 se compose de la tâche de ralentissement, dont la durée d'exécution est la plus longue, et contribue à la plus grande partie de la durée d'exécution de la tâche. ![\[Les métriques d'exécution pour les programmes d'exécution actifs.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-straggler-3.png) **Profil de la mémoire :** Après les deux premières étapes, seul [le programme d'exécution n°3](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.jvm.heap.used) consomme activement de la mémoire pour traiter les données. Les autres programmes d'exécution sont simplement inactifs ou ont été abandonnés peu de temps après la fin des deux premières étapes. ![\[Les métriques du profil de la mémoire après les deux premières étapes.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-straggler-4.png) ### Corriger les programmes d'exécution en retard à l'aide du regroupement Vous pouvez éviter les programmes d'exécution en retard en utilisant la fonction de *regroupement* dans AWS Glue. Utilisez le regroupement pour répartir les données uniformément sur tous les programmes d'exécution et fusionner des fichiers en fichiers plus volumineux à l'aide de tous les programmes d'exécution disponibles sur le cluster. Pour de plus amples informations, veuillez consulter [Lecture des fichiers en entrée dans des groupes de plus grande taille](grouping-input-files.md). Pour consulter les déplacements de données ETL dans la tâche AWS Glue, profilez le code suivant avec la fonction de regroupement activée : ``` df = glueContext.create_dynamic_frame_from_options("s3", {'paths': ["s3://input_path"], "recurse":True, 'groupFiles': 'inPartition'}, format="json") datasink = glueContext.write_dynamic_frame.from_options(frame = df, connection_type = "s3", connection_options = {"path": output_path}, format = "json", transformation_ctx = "datasink4") ``` **Déplacement de données ETL :** Les écritures de données sont désormais diffusées en parallèle avec les lectures de données pendant toute la durée d'exécution de la tâche. Par conséquent, la tâche est réalisée en huit minutes, soit beaucoup plus rapidement qu'avant. ![\[Les déplacements de données ETL affichant que le problème est résolu.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-straggler-5.png) **Remaniement des données sur les programmes d'exécution :** Les données d'entrée ayant fusionné lors des lectures grâce à la fonction de regroupement, il n'y a pas de remaniement de données coûteux suite aux lectures de données. ![\[Les métriques du remaniement de données affichant que le problème est résolu.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-straggler-6.png) **Exécution de tâche :** Les métriques d'exécution de tâche montrent que le nombre total de programmes d'exécution actifs s'exécutant et traitant des données reste relativement constant. Il n'y a pas de ralentissement dans la tâche. Tous les programmes d'exécution restent actifs et ne sont pas abandonnés tant que la tâche n'est pas terminée. Comme il n'existe pas de remaniement intermédiaire de données sur les programmes d'exécution, il n'y a qu'une seule étape dans la tâche. ![\[Les métriques du widget d'exécution de tâche montrant que la tâche ne comporte pas de ralentisseurs.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-straggler-7.png) **Memory profile** (Profil de la mémoire) : les métriques montrent la [consommation de mémoire active](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.jvm.heap.used) par l'ensemble des programmes d'exécution, confirmant une nouvelle fois qu'il existe une activité sur l'ensemble des programmes d'exécution. Les données étant parallèlement envoyées et reçues, l'espace mémoire total de tous les programmes d'exécution est à peu près uniforme et bien au-dessous du seuil de sécurité pour tous les programmes d'exécution. ![\[Les métriques du profil de la mémoire montrant la consommation de mémoire active sur tous les programmes d'exécution.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-straggler-8.png) # Surveillance de la progression des tâches multiples Vous pouvez profiler plusieurs AWS Glue tâches ensemble et surveiller le flux de données entre elles. Il s'agit d'un modèle de flux de travail courant qui nécessite la surveillance de la progression de chaque tâche, du journal de traitement des données, du retraitement des données et des signets de tâche. **Topics** + [ ## Code profilé ](#monitor-debug-multiple-profile) + [ ## Voir les métriques profilées sur la console AWS Glue ](#monitor-debug-multiple-visualize) + [ ## Corriger le traitement des fichiers ](#monitor-debug-multiple-fix) ## Code profilé Ce flux de travail comprend deux tâches : une tâche d'entrée et une tâche de sortie. La tâche d'entrée est planifiée pour s'exécuter toutes les 30 minutes au moyen d'un déclencheur périodique. La tâche de sortie est planifiée pour s'exécuter après chaque exécution réussie de la tâche d'entrée. Ces tâches planifiées sont contrôlées au moyen de déclencheurs de tâche. ![\[Capture d'écran de la console affichant les déclencheurs de tâche qui contrôlent la planification des tâches d'entrée et de sortie.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-multiple-1.png) **Input job** (Tâche d’entrée) : cette tâche lit les données à partir d'un emplacement Amazon Simple Storage Service (Amazon S3), les transforme à l'aide d'`ApplyMapping` et les écrit à un emplacement Amazon S3 intermédiaire. Le code suivant est le code profilé pour la tâche d'entrée : ``` datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": ["s3://input_path"], "useS3ListImplementation":True,"recurse":True}, format="json") applymapping1 = ApplyMapping.apply(frame = datasource0, mappings = [map_spec]) datasink2 = glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": staging_path, "compression": "gzip"}, format = "json") ``` **Output job** (Tâche de sortie) : cette tâche lit la sortie de la tâche d'entrée à partir de l'emplacement intermédiaire dans Amazon S3, les transforme à nouveau et les écrit dans une destination : ``` datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": [staging_path], "useS3ListImplementation":True,"recurse":True}, format="json") applymapping1 = ApplyMapping.apply(frame = datasource0, mappings = [map_spec]) datasink2 = glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": output_path}, format = "json") ``` ## Voir les métriques profilées sur la console AWS Glue Le tableau de bord suivant superpose la métrique d'octets Amazon S3 écrits de la tâche d'entrée sur la métrique d'octets Amazon S3 lus selon la même chronologie pour la tâche de sortie. La chronologie montre différentes exécutions de tâche des tâches d'entrée et de sortie. La tâche d'entrée (en rouge) démarre toutes les 30 minutes. La tâche de sortie (en marron) démarre lorsque la tâche d'entrée se termine, avec une simultanéité max. de 1. ![\[Graphique montrant les données lues et écrites.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-multiple-4.png) Dans cet exemple, les [signets de tâche](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuations.html) ne sont pas activés. Aucun contexte de transformation n'est utilisé pour activer les signets de tâche dans le code de script. **Historique de tâche** : les tâches d'entrée et de sortie s'exécutent plusieurs fois, à partir de 12 h 00, comme le montre l'onglet **Historique**. La tâche d'entrée sur la console AWS Glue se présente comme suit : ![\[Capture d'écran de la console affichant l'onglet Historique de la tâche d'entrée.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-multiple-2.png) L'image suivante montre la tâche de sortie : ![\[Capture d'écran de la console affichant l'onglet Historique de la tâche de sortie.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-multiple-3.png) **Première exécution de tâche** : comme le montre le graphique Octets de données lues et écrites ci-dessous, les premières exécutions des tâches d'entrée et de sortie entre 12 h 00 et 12 h 30 montrent à peu près la même zone sous les courbes. Ces zones représentent les octets Amazon S3 écrits par la tâche d'entrée et les octets Amazon S3 lus par la tâche de sortie. Ces données sont également confirmées par le taux d'octets Amazon S3 écrits (additionnés sur 30 minutes, la fréquence du déclencheur de tâche pour la tâche d'entrée). Le point de données pour le ratio d'exécution de la tâche d'entrée qui a commencé à 12 h 00 est également 1. Le graphique suivant montre le taux de flux de données pour toutes les exécutions de tâches : ![\[Graphique montrant le ratio du flux de données : octets écrits et octets lus.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-multiple-5.png) **Deuxième exécution de tâche** : dans la deuxième exécution de tâche, il existe une différence claire entre le nombre d'octets lus par la tâche de sortie et le nombre d'octets écrits par la tâche d'entrée. (Comparez la zone sous la courbe des deux exécutions de tâche de la tâche de sortie ou comparez les zones de la deuxième exécution des tâches d'entrée et de sortie.) Le ratio entre le nombre d'octets lus et écrits montre que la tâche de sortie lit environ 2,5x les données écrites par la tâche d'entrée dans la seconde période de 30 minutes, de 12 h 30 à 13 h 00. C'est parce que la tâche de sortie a retraité la sortie de la première exécution de la tâche d'entrée car les signets de tâche n'étaient pas activés. Un ratio supérieur à 1 indique qu'un backlog de données supplémentaire a été traité par la tâche de sortie. **Troisième exécution de tâche** : la tâche d'entrée est assez cohérente quant au nombre d'octets écrits (voir la zone sous les courbes rouges). Toutefois, la troisième exécution de la tâche d'entrée a duré plus longtemps que prévu (voir la longue queue de la courbe rouge). Par conséquent, la troisième exécution de la tâche de sortie a démarré en retard. La troisième exécution de tâche n'a traité qu'une fraction des données cumulées à l'emplacement intermédiaire dans les 30 minutes restantes entre 13 h 00 et 13 h 30. Le taux de débit d'octets indique que seules 0,83 des données écrites ont été traitées par la troisième exécution de la tâche d'entrée (voir le ratio à 13 h 00). **Chevauchement des tâches d'entrée et de sortie** : la quatrième exécution de la tâche d'entrée a démarré à 13 h 30 comme prévu, avant la fin de la troisième exécution de la tâche de sortie. Ces deux exécutions de tâche se chevauchement partiellement. Toutefois, la troisième exécution de la tâche de sortie ne capture que les fichiers répertoriés dans l'emplacement intermédiaire d'Amazon S3, lorsqu'elle a commencé vers 13:17. Cela comprend toutes les sorties de données de la première exécution de la tâche d'entrée. Le ratio réel à 13 h 30 est d'environ 2,75. La troisième exécution de la tâche de sortie a traité environ 2,75x de données écrites par la quatrième exécution de la tâche d'entrée, de 13 h 30 à 14 h 00. Comme le montrent ces images, la tâche de sortie retraite des données de toutes les précédentes exécutions de la tâche d'entrée à partir de l'emplacement intermédiaire. Par conséquent, la quatrième exécution de la tâche de sortie est la plus longue et elle chevauche la totalité de la cinquième exécution de la tâche d'entrée. ## Corriger le traitement des fichiers Vous devez vous assurer que la tâche de sortie ne traite les fichiers qui n'ont pas été traités par de précédentes exécutions de la tâche de sortie. Pour ce faire, activez les signets de tâche et configurez le contexte de transformation dans la tâche de sortie de la façon suivante : ``` datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": [staging_path], "useS3ListImplementation":True,"recurse":True}, format="json", transformation_ctx = "bookmark_ctx") ``` Lorsque les signets de tâche sont activés, la tâche de sortie ne retraite pas les données dans l'emplacement intermédiaire pour toutes les précédentes exécutions de la tâche d'entrée. Dans l'image suivante montrant les données lues et écrites, la zone sous la courbe marron est assez cohérente et similaire aux courbes rouges. ![\[Graphique montrant les données lues et écrites sous forme de lignes rouge et marron.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-multiple-6.png) Le rapports du flux d'octets reste également proche de 1, car des données supplémentaires ne sont pas traitées. ![\[Graphique montrant le ratio du flux de données : octets écrits et octets lus\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-multiple-7.png) Une exécution de la tâche de sortie démarre et capture les fichiers dans l'emplacement intermédiaire avant que la prochaine exécution de la tâche d'entrée ne commence à placer d'autres données dans l'emplacement intermédiaire. Tant que c'est le cas, elle ne traite que les fichiers capturés lors de la précédente exécution de tâche de sortie, et le ratio reste proche de 1. ![\[Graphique montrant le ratio du flux de données : octets écrits et octets lus\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-multiple-7.png) Supposons que la tâche d'entrée dure plus longtemps que prévu et que, par conséquent, la tâche de sortie capture des fichiers dans l'emplacement intermédiaire à partir de deux exécutions de tâche d'entrée. Le ratio est supérieur à 1 pour cette exécution de tâche de sortie. Toutefois, les exécutions de tâches de sortie suivantes ne traitent aucun fichier déjà traité par les précédentes exécutions de la tâche de sortie. # Surveillance de la planification des capacités de DPU Vous pouvez utiliser les métriques des tâches AWS Glue pour estimer le nombre d'unités de traitement des données (DPUs) qui peuvent être utilisées pour étendre une AWS Glue tâche. **Note** Cette page s'applique uniquement à AWS Glue versions 0.9 et 1.0. Les versions ultérieures de AWS Glue contiennent des fonctionnalités économiques qui introduisent des considérations supplémentaires lors de la planification des capacités. **Topics** + [ ## Code profilé ](#monitor-debug-capacity-profile) + [ ## Voir les métriques profilées sur la console AWS Glue ](#monitor-debug-capacity-visualize) + [ ## Déterminer la capacité DPU optimale ](#monitor-debug-capacity-fix) ## Code profilé Le script suivant lit une partition Amazon Simple Storage Service (Amazon S3) contenant 428 fichiers JSON compressés avec gzip. Le script applique un mappage pour modifier les noms de champs, les convertit et les écrit dans Amazon S3 au format Apache Parquet. Vous DPUs en attribuez 10 par défaut et vous exécutez cette tâche. ``` datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": [input_path], "useS3ListImplementation":True,"recurse":True}, format="json") applymapping1 = ApplyMapping.apply(frame = datasource0, mappings = [(map_spec]) datasink2 = glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": output_path}, format = "parquet") ``` ## Voir les métriques profilées sur la console AWS Glue **Exécution de tâche 1 :** Dans cette exécution de tâche, nous montrons comment déterminer si le cluster est sous-approvisionné DPUs . La fonctionnalité d'exécution de tâches dans AWS Glue indique le [nombre total de programmes d'exécution actifs en cours d'exécution](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberAllExecutors), le [nombre d'étapes terminées](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.numCompletedStages) et le [nombre maximum de programmes d'exécution nécessaires](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors). Le nombre maximum de programmes d'exécution nécessaires est calculé en ajoutant le nombre total de tâches en cours d'exécution et de tâches en attente, puis en divisant ce nombre par le nombre de tâches par programme d'exécution. Ce résultat est une mesure du nombre total d'exécuteurs requises pour satisfaire la charge du moment. En revanche, le nombre de programmes d'exécution actifs en cours d'exécution mesure le nombre de programmes d'exécution qui exécutent des tâches Apache Spark. À mesure que la tâche progresse, le nombre maximum de programmes d'exécution nécessaires peut varier et baisse généralement vers la fin de la tâche à mesure que diminue la file d'attente de tâches en attente. La ligne rouge horizontale du graphique suivant indique le nombre maximum d'exécuteurs alloués, qui dépend du nombre d'exécuteurs DPUs que vous allouez à la tâche. Dans ce cas, vous allouez 10 points DPUs à l'exécution du job. Une DPU est réservée à la gestion. Neuf DPUs exécuteurs exécutent deux exécuteurs chacun et un exécuteur est réservé au pilote Spark. Le pilote Spark s'exécute dans l'application principale. Par conséquent, le nombre maximum de programmes d'exécution alloués est de 2 x 9 - 1 = 17 programmes d'exécution. ![\[Les métriques de la tâche affichant les programmes d'exécution actifs et les programmes d'exécution nécessaires maximum.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-capacity-1.png) Comme le montre le graphique, le nombre maximum de programmes d'exécution nécessaires commence à 107 au début de la tâche, alors que le nombre de programmes d'exécution actifs reste 17. C'est le même que le nombre maximum d'exécuteurs alloués, soit 10 DPUs. Le ratio entre le nombre maximum de programmes d'exécution nécessaires et le nombre maximum de programmes d'exécution alloués (en ajoutant 1 à chacun des pilotes Spark) donne le facteur sous-alloué : 108/18 = 6x. Vous pouvez en configurer 6 (sous le ratio de provisionnement) \$19 (capacité actuelle du DPU - 1) \$1 1 DPUs = 55 DPUs pour étendre le travail afin de l'exécuter avec un parallélisme maximal et de terminer plus rapidement. La console AWS Glue affiche le détail des métriques des tâches sous la forme d'une ligne statique qui représente le nombre maximal de programmes d'exécution alloués au départ. Pour ces métriques, la console calcule le nombre maximum de programme d'exécution alloués à partir de la définition de la tâche. En revanche, pour les métriques détaillées d'exécution des tâches, la console calcule le nombre maximum d'exécuteurs alloués à partir de la configuration d'exécution des tâches, en particulier le nombre DPUs alloué pour l'exécution des tâches. Pour afficher les métriques d'une exécution de tâche spécifique, sélectionnez l'exécution et choisissez **View run metrics (Afficher les métriques de l'exécution)**. ![\[Les métriques de la tâche montrant le déplacement de données ETL.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-capacity-2.png) Si l'on regarde les octets Amazon S3 [lus](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes) et [écrits](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes), on remarque que la tâche prend six minutes complètes pour diffuser les données à partir d’Amazon S3 et les écrire en parallèle. Tous les cœurs alloués DPUs lisent et écrivent sur Amazon S3. Le nombre maximum de programmes d'exécution nécessaires (107) correspond également au nombre de fichiers dans le chemin d'accès d'entrée Amazon S3 (428). Chaque programme d'exécution peut lancer quatre tâches Spark pour traiter quatre fichiers d'entrée (JSON compressées avec gzip). ## Déterminer la capacité DPU optimale Sur la base des résultats de l'exécution de la tâche précédente, vous pouvez augmenter le nombre total de tâches allouées DPUs à 55 et suivre les performances de la tâche. La tâche se termine en moins de trois minutes, soit la moitié du temps auparavant nécessaire. La montée en charge de la tâche n'est pas linéaire dans ce cas, car il s'agit d'une tâche d'exécution courte. Les tâches comportant des tâches de longue durée ou un grand nombre de tâches (un grand nombre d'exécuteurs maximum nécessaires) bénéficient d'une accélération des performances du close-to-linear DPU grâce à la scale-out. ![\[Graphique montrant l'augmentation du nombre total de DPUs\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-capacity-3.png) Comme le montre l'image ci-dessus, le nombre total de programmes d'exécution actifs atteint le nombre maximum de programmes d'exécution alloués (107). De même, le nombre maximum de programmes d'exécution nécessaires ne dépasse jamais le nombre maximum de programmes d'exécution alloués. Le nombre maximum de programmes d'exécution nécessaires est calculé à partir du nombre de tâches en cours d'exécution et en attente, il doit donc être inférieur au nombre de programmes d'exécution actifs. Ceci est dû au fait que des programmes d'exécution peuvent être partiellement ou complètement inactifs pour une courte période de temps et ne sont pas encore démagnétisés. ![\[Graphique montrant le nombre total de programmes d'exécution actifs atteignant le nombre alloué maximum.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-capacity-4.png) Cette exécution de tâche utilise 6 fois plus de programmes d'exécution pour lire et écrire en parallèle depuis Amazon S3. Par conséquent, cette exécution de tâche utilise plus de bande passante Amazon S3 pour les lectures et les écritures, et se termine plus rapidement. ### Identifiez le surprovisionnement DPUs Ensuite, vous pouvez déterminer si le fait d'étendre la tâche à 100 DPUs (99 \$1 2 = 198 exécuteurs) permet de poursuivre l'extension. Comme le montre le graphique suivant, la tâche se termine toujours après trois minutes. De même, la tâche ne dépasse pas 107 exécuteurs ( DPUsconfiguration 55), et les 91 exécuteurs restants sont surapprovisionnés et ne sont pas du tout utilisés. Cela montre que l'augmentation du nombre de n' DPUs améliore pas toujours les performances, comme en témoigne le nombre maximal d'exécuteurs nécessaires. ![\[Graphique montrant que les performances au travail n'augmentent pas toujours en augmentant le nombre de DPUs.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/monitor-debug-capacity-5.png) ### Comparer des différences de temps Les trois cycles de travail présentés dans le tableau suivant résument les temps d'exécution des travaux pour 10 DPUs DPUs, 55 et 100 DPUs. Vous pouvez trouver la capacité de DPU pour améliorer la durée d'exécution de la tâche en utilisant l'estimation que vous avez réalisée en surveillant la première exécution de tâche. | ID de tâche | Nombre de DPUs | Durée d’exécution | | --- | --- | --- | | jr\$1c894524c8ef5048a4d9... | 10 | 6 min. | | jr\$11a466cf2575e7ffe6856... | 55 | 3 min. | | jr\$134fa1ed4c6aa9ff0a814... | 100 | 3 min. |