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.
# Utilisation des tâches dans AWS Glue
Les sections suivantes renseignent sur les tâches ETL et Ray dans AWS Glue.
**Topics**
+ [AWS Glue versions](release-notes.md)
+ [Utilisation des jobs Spark dans AWS Glue](etl-jobs-section.md)
+ [Travailler avec Ray Jobs dans AWS Glue](ray-jobs-section.md)
+ [Configuration des propriétés pour les tâches shell Python dans AWS Glue](add-job-python.md)
+ [Surveillance AWS Glue](monitor-glue.md)
# AWS Glue versions
Vous pouvez configurer le paramètre de AWS Glue version lorsque vous ajoutez ou mettez à jour une tâche. La AWS Glue version détermine les versions d'Apache Spark et de Python prises AWS Glue en charge. La version de Python indique la version qui est prise en charge pour les tâches de type Spark. Le tableau suivant répertorie les versions d' AWS Glue Glue disponibles, les versions Spark et Python correspondantes, ainsi que les autres modifications de fonctionnalité.
Vous pouvez utiliser les [mises à niveau de Generative AI pour Apache Spark](upgrade-analysis.md) afin de mettre à niveau vos jobs Glue ETL des anciennes versions de Glue (≥ 2.0) vers la dernière version de Glue.
## AWS Glue versions
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/release-notes.html)
**Note**
Les versions de Glue suivantes sont compatibles avec les versions suivantes de PythonShell :
PythonShell La version 3.6 est prise en charge dans la version 1.0 de Glue.
PythonShell La version 3.9 est prise en charge dans la version 3.0 de Glue.
De plus, les points de terminaison de développement ne sont pris en charge que dans les versions 1.0 et 0.9 de Glue.
# Politique de prise en charge des versions AWS Glue
AWS Glue est un service d'intégration de données sans serveur qui facilite la découverte, la préparation et la combinaison de données pour l'analytique, le machine learning et le développement d'applications. Une *tâche AWS Glue* contient la logique métier qui effectue le travail d'intégration des données dans AWS Glue. Il existe trois types de tâches dans AWS Glue : *Spark (lot et streaming)* et *Ray* et *shell Python*. Lorsque vous définissez votre tâche, vous spécifiez la version de AWS Glue qui configure les versions dans l'environnement d'exécution sous-jacent Spark, Ray ou Python. Par exemple : une tâche Spark AWS Glue version 5.0 prend en charge Spark 3.5.4 et Python 3.11.
## Politique de prise en charge
AWS Glue les versions sont construites autour d'une combinaison de systèmes d'exploitation, de langages de programmation et de bibliothèques logicielles soumises à des mises à jour de maintenance et de sécurité. AWS Glue la politique de support des versions consiste à mettre fin au support d'une version lorsqu'un composant majeur de la version atteint la fin du support communautaire à long terme (LTS) et que les mises à jour de sécurité ne sont plus disponibles. AWS Glue la politique de support des versions inclut les statuts suivants :
**Fin du support (EOS) -** Lorsqu'une AWS Glue version atteint EOS :
+ AWS Glue n'appliquera plus de correctifs de sécurité ou d'autres mises à jour aux versions d'EOS.
+ AWS Glue les offres d'emploi sur les versions EOS ne sont pas éligibles au support technique.
+ AWS Glue peut ne pas être honoré SLAs lorsque les tâches sont exécutées sur des versions EOS.
**Fin de vie (EOL) -** Lorsqu'une AWS Glue version atteint la fin de vie :
+ Vous ne pouvez plus créer de nouvelles AWS Glue tâches ni de sessions interactives sur les versions EOL.
+ Vous ne pouvez plus démarrer l'exécution de tâches sur ces AWS Glue versions.
+ AWS Glue arrêtera les exécutions de tâches existantes et les sessions interactives sur les versions EOL.
+ Les versions EOL seront supprimées de AWS Glue SDKs et. APIs
Les versions suivantes d’AWS Glue ont atteint la fin du support et ne seront plus disponibles après la fin de vie. Les modifications du statut de support d’une version commencent à minuit (fuseau horaire du Pacifique) à la date spécifiée.
| **Type** | **Version Glue** | **Fin de l'assistance** | **Fin de vie** |
| --- | --- | --- | --- |
| **Type** | **Version Python** | **Fin de l'assistance** | **Fin de vie** |
| --- | --- | --- | --- |
| **Type** | **Version Notebook** | **Fin de l'assistance** | **Fin de vie** |
| --- | --- | --- | --- |
| Spark | Glue version 0.9 (Spark 2.2, Scala 2, Python 2) | 01/06/2022 | 01/04/2026 |
| Spark | Glue version 1.0 (Spark 2.4, Python 2) | 01/06/2022 | 01/04/2026 |
| Spark | Glue version 1.0 (Spark 2.4, Scala 2, Python 3) | 30/09/2022 | 01/04/2026 |
| Spark | Glue version 2.0 (Spark 2.4, Python 3) | 31/01/2024 | 01/04/2026 |
| (shell Python) | Python 2 (AWS Glue Version 1.0) | 01/06/2022 | 01/04/2026 |
| (shell Python) | PythonShell 3.6 (Glue version 1.0) | 31/03/2026 | NA |
| Point de terminaison de développement | Zeppelin notebook | 30/09/2022 | NA |
**Note**
La création de nouvelles tâches AWS Glue Python Shell 3.6 ne sera pas autorisée une fois le support terminé, le 31 mars 2026, mais vous pouvez continuer à mettre à jour et à exécuter les tâches existantes. Toutefois, les tâches exécutées sur des versions abandonnées ne sont pas éligibles au support technique. AWS Glue n'appliquera pas de correctifs de sécurité ou d'autres mises à jour aux versions abandonnées. AWS Glue ne sera pas non plus honoré SLAs lorsque les tâches sont exécutées sur des versions abandonnées.
AWS vous recommande fortement de migrer vos jobs vers des versions prises en charge.
Pour plus d'informations sur la migration de vos tâches Spark vers la dernière AWS Glue version, consultez la section [Migration des AWS Glue tâches vers la AWS Glue version 5.1](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-51.html).
Pour migrer vos tâches de shell Python vers la dernière version de AWS Glue :
+ Dans la console, choisissez `Python 3 (Glue Version 4.0)`.
+ Dans l'[UpdateJob](https://docs.aws.amazon.com/glue/latest/webapi/API_UpdateJob.html)API [CreateJob](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateJob.html)/, définissez le `GlueVersion` paramètre sur `2.0` et sur `PythonVersion` `3` sous le `Command` paramètre. La configuration `GlueVersion` n’affecte pas le comportement des tâches shell Python. L’incrémentation de `GlueVersion` ne présente donc aucun avantage.
+ Vous devez rendre votre script de tâche compatible avec Python 3.
# Migration AWS Glue des tâches Spark vers la AWS Glue version 5.1
Cette rubrique décrit les modifications apportées entre AWS Glue les versions 0.9, 1.0, 2.0, 3.0, 4.0 et 5.0 pour vous permettre de migrer vos applications Spark et vos tâches ETL vers la AWS Glue version 5.1. Il décrit également les fonctionnalités de la AWS Glue version 5.1 et les avantages de son utilisation.
Pour utiliser cette fonctionnalité avec vos tâches AWS Glue ETL, **5.1** choisissez-la `Glue version` lors de la création de vos tâches.
**Topics**
+ [Nouvelles fonctionnalités](#migrating-version-51-features)
+ [Actions pour migrer vers la AWS Glue version 5.1](#migrating-version-51-actions)
+ [Liste de contrôle de migration](#migrating-version-51-checklist)
+ [Migration de la AWS Glue version 5.0 vers AWS Glue la version 5.1](#migrating-version-51-from-50)
+ [Migration des anciennes AWS Glue versions vers AWS Glue la version 5.1](#migrating-older-versions-to-51)
+ [Migration du connecteur et du pilote JDBC pour 5.1 AWS Glue](#migrating-version-51-connector-driver-migration)
## Nouvelles fonctionnalités
Cette section décrit les nouvelles fonctionnalités et les avantages de la AWS Glue version 5.1.
+ Mise à jour d'Apache Spark de la version 3.5.4 en AWS Glue 5.0 à la version 3.5.6 en AWS Glue 5.1.
+ Open Table Formats (OTF) mis à jour vers Hudi 1.0.2, Iceberg 1.10.0 et Delta Lake 3.3.2
+ Vues **matérialisées d'icebergs - Créez et gérez des vues** matérialisées d'icebergs (MV). Pour plus d'informations, consultez le [billet de blog](https://aws.amazon.com/blogs/big-data/introducing-apache-iceberg-materialized-views-in-aws-glue-data-catalog/)
+ **Format Iceberg version 3.0** - Étend les types de données et les structures de métadonnées existantes pour ajouter de nouvelles fonctionnalités. Pour plus d'informations, consultez les [spécifications de la table Iceberg](https://iceberg.apache.org/spec/).
+ Accès **complet aux tables Hudi** - Contrôle de l'accès complet aux tables (FTA) pour Apache Hudi dans Apache Spark en fonction de vos politiques définies dans. AWS Lake Formation Cette fonctionnalité permet d'effectuer des opérations de lecture et d'écriture à partir de vos tâches AWS Glue ETL sur des tables AWS Lake Formation enregistrées lorsque le rôle de tâche dispose d'un accès complet aux tables.
+ **Supporte le contrôle d'accès fin natif (FGAC) à l'aide AWS Lake Formation** d' DDL/DML opérations (telles que CREATE, ALTER, DELETE, DROP) avec un contrôle d'accès fin pour les tables Apache Hive, Apache Iceberg et Delta Lake enregistrées dans. AWS Lake Formation
+ **Contexte d'audit pour les tâches Spark** - Le contexte d'audit pour les tâches AWS Glue ETL sera disponible AWS Glue et les appels AWS Lake Formation d'API seront disponibles dans les AWS CloudTrail journaux.
**Limites et problèmes connus**
Notez les problèmes et limitations connus suivants :
+ Support limité pour la clause View SQL pour la création de vues matérialisées, la réécriture de requêtes et l'actualisation incrémentielle. Vous trouverez plus de détails sur la page de documentation de la [fonctionnalité Iceberg Materialized Views](https://docs.aws.amazon.com/lake-formation/latest/dg/materialized-views.html#materialized-views-considerations-limitations).
+ Les **écritures Hudi FTA doivent être utilisées** HoodieCredentialedHadoopStorage pour la vente d'informations d'identification lors de l'exécution du travail. Définissez la configuration suivante lors de l'exécution des tâches Hudi :
`hoodie.storage.class=org.apache.spark.sql.hudi.storage.HoodieCredentialedHadoopStorage`
+ Le support d'écriture Hudi FTA fonctionne uniquement avec les configurations Hudi par défaut. Les paramètres Hudi personnalisés ou autres que ceux par défaut peuvent ne pas être entièrement pris en charge et peuvent entraîner un comportement inattendu. Le clustering pour les tables Hudi Merge-On-Read (MOR) n'est pas non plus pris en charge en mode d'écriture FTA.
**Évolutions**
Prenez note des modifications majeures suivantes :
+ Le système de fichiers S3A a remplacé EMRFS en tant que connecteur S3 par défaut. Pour plus d'informations sur la façon de migrer, consultez[Migration de la AWS Glue version 5.0 vers AWS Glue la version 5.1](#migrating-version-51-from-50).
## Actions pour migrer vers la AWS Glue version 5.1
Pour les tâches existantes, modifiez la `Glue version` depuis la version précédente vers `Glue 5.1` dans la configuration de la tâche.
+ Dans AWS Glue Studio, choisissez « `Glue 5.1 - Supports Spark 3.5.6, Scala 2, Python 3` in `Glue version` ».
+ Dans l’API, choisissez **5.1** dans le paramètre `GlueVersion` de l’opération d’API [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-UpdateJob](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-UpdateJob).
Pour les nouvelles tâches, choisissez `Glue 5.1` lorsque vous créez une tâche.
+ Dans la console, choisissez `Spark 3.5.6, Python 3 (Glue Version 5.1) or Spark 3.5.6, Scala 2 (Glue Version 5.1)` dans `Glue version`.
+ Dans AWS Glue Studio, choisissez « `Glue 5.1 - Supports Spark 3.5.6, Scala 2, Python 3` in `Glue version` ».
+ Dans l’API, choisissez **5.1** dans le paramètre `GlueVersion` de l’opération d’API [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-CreateJob](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-CreateJob).
Pour consulter les journaux d'événements Spark AWS Glue 5.1 issus de la AWS Glue version 2.0 ou d'une version antérieure, [lancez un serveur d'historique Spark mis à niveau pour AWS Glue 5.1 à l'aide CloudFormation de Docker](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-history.html).
## Liste de contrôle de migration
Consultez cette liste de contrôle pour la migration :
+ [Python] Mettez à jour les références de démarrage de la version 1.34 à la version 1.40.
## Migration de la AWS Glue version 5.0 vers AWS Glue la version 5.1
Tous les paramètres de travail existants et les fonctionnalités principales qui existent dans la AWS Glue version 5.0 existeront dans la AWS Glue version 5.1. Notez les modifications suivantes lors de la migration :
+ Dans la AWS Glue version 5.1, le système de fichiers S3A a remplacé EMRFS comme connecteur S3 par défaut. Si `spark.hadoop.fs.s3a.endpoint` les deux ne `spark.hadoop.fs.s3a.endpoint.region` sont pas définis, la région par défaut utilisée par S3A est`us-east-2`. Cela peut entraîner des problèmes, tels que des erreurs de délai de chargement dans S3, en particulier pour les tâches VPC. Pour atténuer les problèmes causés par cette modification, définissez la configuration `spark.hadoop.fs.s3a.endpoint.region` Spark lorsque vous utilisez le système de fichiers S3A dans la AWS Glue version 5.1.
+ Pour continuer à utiliser EMRFS au lieu de S3A, définissez les configurations Spark suivantes :
```
--conf spark.hadoop.fs.s3.impl=com.amazon.ws.emr.hadoop.fs.EmrFileSystem
--conf spark.hadoop.fs.s3n.impl=com.amazon.ws.emr.hadoop.fs.EmrFileSystem
--conf spark.hadoop.fs.AbstractFileSystem.s3.impl=org.apache.hadoop.fs.s3.EMRFSDelegate
```
Reportez-vous à la documentation sur la migration de Spark :
+ [Guide de migration : Spark Core](https://spark.apache.org/docs/3.5.6/core-migration-guide.html)
+ [Guide de migration : SQL, ensembles de données et DataFrame](https://spark.apache.org/docs/3.5.6/sql-migration-guide.html)
+ [Guide de migration : streaming structuré](https://spark.apache.org/docs/3.5.6/ss-migration-guide.html)
+ [Upgrading PySpark](https://spark.apache.org/docs/3.5.6/api/python/migration_guide/pyspark_upgrade.html)
## Migration des anciennes AWS Glue versions vers AWS Glue la version 5.1
+ Pour les étapes de migration liées à la AWS Glue version 4.0 vers la AWS Glue version 5.0, consultez la section [Migration de la AWS Glue version 4.0 vers la AWS Glue version 5.0](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-50.html#migrating-version-50-from-40).
+ Pour les étapes de migration liées à la AWS Glue version 3.0 vers la AWS Glue version 5.0, consultez la section [Migration de la AWS Glue version 3.0 vers la AWS Glue version 5.0](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-50.html#migrating-version-50-from-30).
+ Pour les étapes de migration liées à la version AWS Glue 2.0 vers la version AWS Glue 5.0 et la liste des différences de migration entre les AWS Glue versions 2.0 et 4.0, consultez la section [Migration de la version AWS Glue 2.0 vers la version AWS Glue 5.0](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-50.html#migrating-version-50-from-20).
## Migration du connecteur et du pilote JDBC pour 5.1 AWS Glue
Pour en savoir plus sur les versions des connecteurs JDBC et de lac de données qui ont été mises à niveau, consultez :
+ [Annexe B : Mises à niveau du pilote JDBC](#migrating-version-51-appendix-jdbc-driver)
+ [Annexe C : Mises à niveau des connecteurs](#migrating-version-51-appendix-connector)
+ [Annexe D : Mises à niveau du format de table ouverte](#migrating-version-51-appendix-open-table-formats)
Les modifications suivantes s'appliquent aux mises à niveau de la version OTF identifiées dans [Annexe D : Mises à niveau du format de table ouverte](#migrating-version-51-appendix-open-table-formats) la version AWS Glue 5.1.
**Apache Hudi**
Notez les modifications suivantes :
+ Support de l'accès en lecture et en écriture au FTA sur les tables enregistrées de Lake Formation.
**Apache Iceberg**
Notez les modifications suivantes :
+ Support du format Iceberg version 3. Les fonctionnalités suivantes sont prises en charge :
+ Transformations à arguments multiples pour le partitionnement et le tri.
+ Suivi du lignage des lignes.
+ Vecteurs de suppression. Pour en savoir plus, consultez [un article de blog](https://aws.amazon.com/blogs/big-data/unlock-the-power-of-apache-iceberg-v3-deletion-vectors-on-amazon-emr/)
+ Clés de chiffrement des tables.
+ Support des valeurs par défaut pour les colonnes.
+ Support les écritures FGAC natives de Spark sur AWS Lake Formation les tables enregistrées.
+ Compatibilité avec Athena SQL - Impossible de lire les tables Iceberg V3 créées par EMR Spark en raison d'une erreur : `GENERIC_INTERNAL_ERROR: Cannot read unsupported version 3`
**Delta Lake**
Notez les modifications suivantes :
+ Support de l'accès en lecture et en écriture au FTA sur les tables enregistrées de Lake Formation.
### Annexe A : Mises à niveau notables des dépendances
Voici les mises à niveau des dépendances :
| Dépendance | Version en AWS Glue 5.1 | Version en AWS Glue 5.0 | Version en AWS Glue 4.0 | Version en AWS Glue 3.0 | Version en AWS Glue 2.0 | Version en AWS Glue 1.0 |
| --- | --- | --- | --- | --- | --- | --- |
| Java | 17 | 17 | 8 | 8 | 8 | 8 |
| Spark | 3.5.6 | 3.5.4 | 3.3.0-amzn-1 | 3.1.1-amzn-0 | 2.4.3 | 2.4.3 |
| Hadoop | 3.4.1 | 3.4.1 | 3.3.3-amzn-0 | 3.2.1-amzn-3 | 2.8.5-amzn-5 | 2.8.5-amzn-1 |
| Scala | 2,1,18 | 2,1,18 | 2,12 | 2,12 | 2.11 | 2.11 |
| Jackson | 2.15.2 | 2.15.2 | 2,12 | 2,12 | 2.11 | 2.11 |
| Hive | 2.3.9-amzn-4. | 2.3.9-amzn-4. | 2.3.9-amzn-2 | 2.3.7-amzn-4 | 1.2 | 1.2 |
| EMRFS | 2,73,0 | 2,69,0 | 2,54,0 | 2,46,0 | 2.38.0 | 2.30.0 |
| Json4s | 3.7.0-M11 | 3.7.0-M11 | 3.7.0-M11 | 3.6.6 | 3.5.x | 3.5.x |
| Flèche | 12,0.1 | 12,0.1 | 7.0.0 | 2.0.0 | 0.10.0 | 0.10.0 |
| AWS Glue Client de catalogue de données | 4.9.0 | 4.5.0 | 3.7.0 | 3.0.0 | 1.10.0 | N/A |
| AWS SDK pour Java | 2,35,5 | 2,29,52 | 1.12 | 1.12 | | |
| Python | 3,11 | 3,11 | 3,10 | 3.7 | 2.7 et 3.6 | 2.7 et 3.6 |
| Boto | 1,40,61 | 1,34,131 | 1,26 | 1,18 | 1.12 | N/A |
| Connecteur EMR DynamoDB | 5.7.0 | 5.6.0 | 4,16,0 | | | |
### Annexe B : Mises à niveau du pilote JDBC
Voici les mises à niveau du pilote JDBC :
| Pilote | Version du pilote JDBC en 5.1 AWS Glue | Version du pilote JDBC en 5.0 AWS Glue | Version du pilote JDBC en 4.0 AWS Glue | Version du pilote JDBC en 3.0 AWS Glue | Version du pilote JDBC dans les versions précédentes AWS Glue |
| --- | --- | --- | --- | --- | --- |
| MySQL | 8,0,33 | 8,0,33 | 8.0.23 | 8.0.23 | 5.1 |
| Microsoft SQL Server | 10.2.0 | 10.2.0 | 9.4.0 | 7.0.0 | 6.1.0 |
| Oracle Databases | 23,3.0,23,09 | 23,3.0,23,09 | 21,7 | 21,1 | 11.2 |
| PostgreSQL | 42.7.3 | 42.7.3 | 42,3.6 | 42,2,18 | 42,10 |
| Amazon Redshift | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.16 | redshift-jdbc41-1.2.12.1017 | redshift-jdbc41-1.2.12.1017 |
| SAP Hana | 2,20,17 | 2,20,17 | 2,17,12 | | |
| Teradata | 20,00.00.33 | 20,00.00.33 | 20,00.00.06 | | |
### Annexe C : Mises à niveau des connecteurs
Les mises à niveau des connecteurs sont les suivantes :
| Pilote | Version du connecteur en AWS Glue 5.1 | Version du connecteur en AWS Glue 5.0 | Version du connecteur en AWS Glue 4.0 | Version du connecteur en AWS Glue 3.0 |
| --- | --- | --- | --- | --- |
| Connecteur EMR DynamoDB | 5.7.0 | 5.6.0 | 4,16,0 | |
| Amazon Redshift | 6.4.2 | 6.4.0 | 6.1.3 | |
| OpenSearch | 1.2.0 | 1.2.0 | 1.0.1 | |
| MongoDB | 10.3.0 | 10.3.0 | 10,0.4 | 3.0.0 |
| Snowflake | 3.1.1 | 3.0.0 | 2.12.0 | |
| Google BigQuery | 0,32,2 | 0,32,2 | 0,32,2 | |
| AzureCosmos | 4,33,0 | 4,33,0 | 4,22,0 | |
| AzureSQL | 1.3.0 | 1.3.0 | 1.3.0 | |
| Vertica | 3.3.5 | 3.3.5 | 3.3.5 | |
### Annexe D : Mises à niveau du format de table ouverte
Les mises à niveau du format de table ouverte sont les suivantes :
| OTF | Version du connecteur en AWS Glue 5.1 | Version du connecteur en AWS Glue 5.0 | Version du connecteur en AWS Glue 4.0 | Version du connecteur en AWS Glue 3.0 |
| --- | --- | --- | --- | --- |
| Hudi | 1.0.2 | 0,15,0 | 0.12.1 | 0,1,1 |
| Delta Lake | 3.3.2 | 3.3.0 | 2.1.0 | 1.0.0 |
| Iceberg | 1.10.0 | 1.7.1 | 1.0.0 | 0.13.1 |
# Migration AWS Glue des tâches Spark vers la AWS Glue version 5.0
Cette rubrique décrit les modifications apportées entre AWS Glue les versions 0.9, 1.0, 2.0, 3.0 et 4.0 pour vous permettre de migrer vos applications Spark et vos tâches ETL vers la AWS Glue version 5.0. Il décrit également les fonctionnalités de la AWS Glue version 5.0 et les avantages de son utilisation.
Pour utiliser cette fonctionnalité avec vos tâches AWS Glue ETL, **5.0** choisissez-la `Glue version` lors de la création de vos tâches.
**Topics**
+ [Nouvelles fonctionnalités](#migrating-version-50-features)
+ [Actions pour migrer vers la AWS Glue version 5.0](#migrating-version-50-actions)
+ [Liste de contrôle de migration](#migrating-version-50-checklist)
+ [AWS Glue Caractéristiques de la version 5.0](#migrating-version-50-features)
+ [Migration de la AWS Glue version 4.0 vers AWS Glue la version 5.0](#migrating-version-50-from-40)
+ [Migration de la AWS Glue version 3.0 à AWS Glue la version 5.0](#migrating-version-50-from-30)
+ [Migration de la AWS Glue version 2.0 vers AWS Glue la version 5.0](#migrating-version-50-from-20)
+ [Changements de comportement de journalisation dans la AWS Glue version 5.0](#enable-continous-logging-changes-glue-50)
+ [Migration du connecteur et du pilote JDBC pour la version 5.0 AWS Glue](#migrating-version-50-connector-driver-migration)
## Nouvelles fonctionnalités
Cette section décrit les nouvelles fonctionnalités et les avantages de la AWS Glue version 5.0.
+ Mise à jour d'Apache Spark de la version 3.3.0 dans la AWS Glue version 4.0 à la version 3.5.4 dans AWS Glue la version 5.0. Consultez [Améliorations majeures de Spark 3.3.0 à Spark 3.5.4](#migrating-version-50-features-spark).
+ Contrôle précis des accès (FGAC) natif Spark utilisant Lake Formation. Cela inclut FGAC pour les tables Iceberg, Delta et Hudi. Pour plus d'informations, consultez la section [Utilisation AWS Glue avec AWS Lake Formation pour un contrôle d'accès précis](https://docs.aws.amazon.com/glue/latest/dg/security-lf-enable.html).
Prenez note des considérations ou limites suivantes pour FGAC natif Spark :
+ Actuellement, les écritures de données ne sont pas prises en charge.
+ Pour écrire dans Iceberg via `GlueContext` en utilisant Lake Formation, vous devez plutôt utiliser le contrôle d’accès IAM.
Pour une liste complète des restrictions et des considérations relatives à l’utilisation de FGAC natif Spark, consultez [Considérations et restrictions](security-lf-enable-considerations.md).
+ Support des subventions d'accès Amazon S3 en tant que solution de contrôle d'accès évolutive à vos données Amazon S3 depuis AWS Glue. Pour de plus amples informations, veuillez consulter [Utilisation d'Amazon S3 Access Grants avec AWS Glue](security-s3-access-grants.md).
+ Open Table Formats (OTF) mis à jour vers Hudi 0.15.0, Iceberg 1.7.1 et Delta Lake 3.3.0
+ Support d'Amazon SageMaker Unified Studio.
+ Amazon SageMaker Lakehouse et intégration de l'abstraction de données. Pour de plus amples informations, veuillez consulter [Interrogation de catalogues de données de métastore à partir de l'ETL AWS Glue](#migrating-version-50-features-metastore).
+ Prise en charge pour installer des bibliothèques Python supplémentaires à l’aide de `requirements.txt`. Pour de plus amples informations, veuillez consulter [Installation de bibliothèques Python supplémentaires dans AWS Glue 5.0 ou version ultérieure à l'aide de requirements.txt](aws-glue-programming-python-libraries.md#addl-python-modules-requirements-txt).
+ AWS Glue La version 5.0 prend en charge le lignage des données sur Amazon DataZone. Vous pouvez configurer AWS Glue pour collecter automatiquement des informations de lignage lors de l'exécution des tâches Spark et envoyer les événements de lignage à visualiser sur Amazon. DataZone Pour plus d'informations, consultez la section [Lignage des données sur Amazon DataZone](https://docs.aws.amazon.com/datazone/latest/userguide/datazone-data-lineage.html).
Pour le configurer sur la AWS Glue console, activez **Generate lineage events** et saisissez votre identifiant de DataZone domaine Amazon dans l'onglet **Job details**.
![\[La capture d'écran montre l'activation du lignage des DataZone dates Amazon pour AWS Glue.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/glue-50-data-lineage.png)
Vous pouvez également fournir le paramètre de tâche suivant (indiquez votre ID de DataZone domaine) :
+ Clé : `--conf`
+ Valeur :
```
extraListeners=io.openlineage.spark.agent.OpenLineageSparkListener
—conf spark.openlineage.transport.type=amazon_datazone_api
-conf spark.openlineage.transport.domainId=
```
+ Mises à jour du connecteur et du pilote JDBC. Pour plus d’informations, consultez [Annexe B : Mises à niveau du pilote JDBC](#migrating-version-50-appendix-jdbc-driver) et [Annexe C : Mises à niveau des connecteurs](#migrating-version-50-appendix-connector).
+ Mise à jour de Java de la version 8 vers la version 17.
+ Stockage accru pour les `G.2X` employés AWS Glue `G.1X` et les employés, l'espace disque passant respectivement à 94 Go et 138 Go. De plus, de nouveaux types de `G.12X` travailleurs et des outils optimisés pour la mémoire `R.1X` `R.8X` sont disponibles dans les AWS Glue versions 4.0 et ultérieures. `G.16X` `R.2X` `R.4X` Pour de plus amples informations, consultez [Tâches](aws-glue-api-jobs-job.md).
+ **Support pour les tâches AWS SDK for Java, versions 2 AWS Glue à 5.0,** peuvent utiliser les [versions](https://github.com/aws/aws-sdk-java/tree/1.12.569) 1.12.569 [ou](https://github.com/aws/aws-sdk-java-v2/tree/2.28.8) 2.28.8 pour Java si la tâche prend en charge la version v2. Le AWS SDK pour Java 2.x est une réécriture majeure de la base de code de la version 1.x. Il repose sur Java 8\$1 et ajoute plusieurs fonctionnalités fréquemment demandées. Cela inclut la prise en charge d’E/S non bloquantes et la possibilité de brancher une implémentation HTTP différente au moment de l’exécution. Pour plus d’informations, notamment un Guide de migration du kit SDK pour la version 1 de Java vers la version 2, consultez le guide du [Kit SDK AWS pour Java, version 2](https://docs.aws.amazon.com/sdk-for-java).
**Évolutions**
Prenez note des modifications majeures suivantes :
+ Dans la AWS Glue version 5.0, lorsque vous utilisez le système de fichiers S3A et si `fs.s3a.endpoint` et `fs.s3a.endpoint.region` ne sont pas définis, la région par défaut utilisée par S3A est `us-east-2`. Cela peut entraîner des problèmes, tels que des erreurs de délai de chargement dans S3, en particulier pour les tâches VPC. Pour atténuer les problèmes causés par cette modification, définissez la configuration Spark `fs.s3a.endpoint.region` lorsque vous utilisez le système de fichiers S3A dans la version 5.0. AWS Glue
+ Contrôle précis des accès (FGAC) de Lake Formation
+ AWS Glue La version 5.0 prend uniquement en charge le nouveau FGAC natif de Spark utilisant Spark. DataFrames Il ne prend pas en charge l'utilisation AWS Glue DynamicFrames du FGAC.
+ L'utilisation de FGAC dans la version 5.0 nécessite une migration depuis Spark AWS Glue DynamicFrames DataFrames
+ Si vous n'avez pas besoin du FGAC, il n'est pas nécessaire de migrer vers Spark DataFrame et les GlueContext fonctionnalités, telles que les signets de tâches et les prédicats push down, continueront de fonctionner.
+ Les tâches avec FGAC natif Spark nécessitent un minimum de quatre travailleurs : un pilote utilisateur, un pilote système, un exécuteur système et un exécuteur utilisateur de secours.
+ Pour plus d'informations, consultez la section [Utilisation AWS Glue avec AWS Lake Formation pour un contrôle d'accès précis](https://docs.aws.amazon.com/glue/latest/dg/security-lf-enable.html).
+ Accès complet aux tables (FTA) Lake Formation
+ AWS Glue 5.0 prend en charge le FTA avec Spark native DataFrames (nouveau) et GlueContext DynamicFrames (ancien, avec des limitations)
+ FTA natif Spark
+ Si le script 4.0 l'utilise GlueContext, migrez vers Native Spark.
+ Cette fonctionnalité est limitée aux tables Hive et Iceberg.
+ Pour plus d’informations sur la configuration d’une tâche 5.0 pour utiliser FTA natif Spark, consultez
+ GlueContext DynamicFrame ALE
+ Aucune modification de code requise
+ Cette fonctionnalité est limitée aux tables non OTF. Elle ne fonctionnera pas avec Iceberg, Delta Lake et Hudi.
+ Le [lecteur CSV SIMD vectorisé](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-csv-home.html#aws-glue-programming-etl-format-simd-csv-reader) n’est pas pris en charge.
+ La [journalisation continue](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging-enable.html) dans le groupe de journaux de sortie n’est pas prise en charge. Utilisez plutôt un groupe de journaux `error`.
+ Le AWS Glue Job Run Insights `job-insights-rule-driver` est devenu obsolète. Le flux de journaux `job-insights-rca-driver` se trouve désormais dans le groupe des journaux d’erreurs.
+ Les custom/marketplace connecteurs basés sur Athena ne sont pas pris en charge.
+ Les connecteurs Adobe Marketo Engage, Facebook Ads, Google Ads, Google Analytics 4, Google Sheets, Hubspot, Instagram Ads, Intercom, Jira Cloud, Oracle, Salesforce, Salesforce Marketing Cloud NetSuite, Salesforce Marketing Cloud Account Engagement, SAP, Slack, Snapchat Ads OData ServiceNow, Stripe, Zendesk et Zoho CRM ne sont pas pris en charge.
+ Les propriétés log4j personnalisées ne sont pas prises en charge dans AWS Glue la version 5.0.
### Améliorations majeures de Spark 3.3.0 à Spark 3.5.4
Notez les améliorations suivantes :
+ Client Python pour Spark Connect ([SPARK-39375](https://issues.apache.org/jira/browse/SPARK-39375)).
+ Mise en œuvre de la prise en charge des valeurs DEFAULT pour les colonnes dans les tables ([SPARK-38334](https://issues.apache.org/jira/browse/SPARK-38334)).
+ Prise en charge de « Références d’alias de colonne latérale » ([SPARK-27561](https://issues.apache.org/jira/browse/SPARK-27561)).
+ Renforcement de l’utilisation de SQLSTATE pour les classes d’erreur ([SPARK-41994](https://issues.apache.org/jira/browse/SPARK-41994)).
+ Activation des jointures du filtre Bloom par défaut ([SPARK-38841](https://issues.apache.org/jira/browse/SPARK-38841)).
+ Amélioration de la capacité de mise à l’échelle de l’interface utilisateur Spark et de la stabilité des pilotes pour les applications de grande envergure ([SPARK-41053](https://issues.apache.org/jira/browse/SPARK-41053)).
+ Suivi de la progression asynchrone dans le streaming structuré ([SPARK-39591](https://issues.apache.org/jira/browse/SPARK-39591)).
+ Traitement avec état dynamique arbitraire Python dans le streaming structuré ([SPARK-40434](https://issues.apache.org/jira/browse/SPARK-40434)).
+ [Améliorations de la couverture de l'API Pandas ([SPARK-42882](https://issues.apache.org/jira/browse/SPARK-42882)) et de la prise en charge des NumPy entrées dans (SPARK-39405). PySpark ](https://issues.apache.org/jira/browse/SPARK-39405)
+ Fournissez un profileur de mémoire pour les fonctions PySpark définies par l'utilisateur ([SPARK-40281](https://issues.apache.org/jira/browse/SPARK-40281)).
+ PyTorch Distributeur d'outils ([SPARK-41589](https://issues.apache.org/jira/browse/SPARK-41589)).
+ Publication des artefacts SBOM ([SPARK-41893](https://issues.apache.org/jira/browse/SPARK-41893)).
+ Support IPv6 uniquement pour l'environnement ([SPARK-39457](https://issues.apache.org/jira/browse/SPARK-39457)).
+ [Planificateur K8s personnalisé (Apache YuniKorn et Volcano) GA (SPARK-42802).](https://issues.apache.org/jira/browse/SPARK-42802)
+ Prise en charge de client Scala et Go dans Spark Connect ([SPARK-42554](https://issues.apache.org/jira/browse/SPARK-42554)) et ([SPARK-43351](https://issues.apache.org/jira/browse/SPARK-43351)).
+ PyTorchSupport ML distribué basé sur Spark Connect ([SPARK-42471](https://issues.apache.org/jira/browse/SPARK-42471)).
+ Prise en charge du streaming structuré pour Spark Connect dans Python et Scala ([SPARK-42938](https://issues.apache.org/jira/browse/SPARK-42938)).
+ Prise en charge de l’API Pandas pour le client Python Spark Connect ([SPARK-42497](https://issues.apache.org/jira/browse/SPARK-42497)).
+ Présentez Arrow Python UDFs ([SPARK-40307](https://issues.apache.org/jira/browse/SPARK-40307)).
+ Prise en charge des fonctions de table définies par l’utilisateur dans Python ([SPARK-43798](https://issues.apache.org/jira/browse/SPARK-43798)).
+ Migrez PySpark les erreurs vers les classes d'erreurs ([SPARK-42986](https://issues.apache.org/jira/browse/SPARK-42986)).
+ PySpark cadre de test ([SPARK-44042](https://issues.apache.org/jira/browse/SPARK-44042)).
+ Ajout du support pour Datasketches HllSketch ([SPARK-16484](https://issues.apache.org/jira/browse/SPARK-16484)).
+ Amélioration de la fonction SQL intégrée ([SPARK-41231](https://issues.apache.org/jira/browse/SPARK-41231)).
+ Clause IDENTIFIER ([SPARK-43205](https://issues.apache.org/jira/browse/SPARK-43205)).
+ Ajout de fonctions SQL dans Scala, Python et R API ([SPARK-43907](https://issues.apache.org/jira/browse/SPARK-43907)).
+ Ajout de la prise en charge des arguments nommés pour les fonctions SQL ([SPARK-43922](https://issues.apache.org/jira/browse/SPARK-43922)).
+ Éviter de réexécuter une tâche inutile sur un exécuteur hors service en cas de migration des données réorganisées ([SPARK-41469](https://issues.apache.org/jira/browse/SPARK-41469)).
+ ML distribué <> spark connect ([SPARK-42471](https://issues.apache.org/jira/browse/SPARK-42471)).
+ DeepSpeed distributeur ([SPARK-44264](https://issues.apache.org/jira/browse/SPARK-44264)).
+ Mise en œuvre du point de contrôle du journal des modifications pour le magasin d’état RocksDB ([SPARK-43421](https://issues.apache.org/jira/browse/SPARK-43421)).
+ Introduction de la propagation des filigranes parmi les opérateurs ([SPARK-42376](https://issues.apache.org/jira/browse/SPARK-42376)).
+ Présentez dropDuplicatesWithin Watermark ([SPARK-42931](https://issues.apache.org/jira/browse/SPARK-42931)).
+ Améliorations apportées à la gestion de la mémoire du fournisseur de magasin d’état RocksDB ([SPARK-43311](https://issues.apache.org/jira/browse/SPARK-43311)).
## Actions pour migrer vers la AWS Glue version 5.0
Pour les tâches existantes, modifiez la `Glue version` depuis la version précédente vers `Glue 5.0` dans la configuration de la tâche.
+ Dans AWS Glue Studio, choisissez « `Glue 5.0 - Supports Spark 3.5.4, Scala 2, Python 3` in `Glue version` ».
+ Dans l’API, choisissez **5.0** dans le paramètre `GlueVersion` de l’opération d’API [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-UpdateJob](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-UpdateJob).
Pour les nouvelles tâches, choisissez `Glue 5.0` lorsque vous créez une tâche.
+ Dans la console, choisissez `Spark 3.5.4, Python 3 (Glue Version 5.0) or Spark 3.5.4, Scala 2 (Glue Version 5.0)` dans `Glue version`.
+ Dans AWS Glue Studio, choisissez « `Glue 5.0 - Supports Spark 3.5.4, Scala 2, Python 3` in `Glue version` ».
+ Dans l’API, choisissez **5.0** dans le paramètre `GlueVersion` de l’opération d’API [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-CreateJob](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-CreateJob).
Pour consulter les journaux d'événements Spark de la AWS Glue version 5.0 à partir de la version AWS Glue 2.0 ou d'une version antérieure, [lancez un serveur d'historique Spark mis à niveau pour la AWS Glue version 5.0 à l'aide CloudFormation de Docker](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-history.html).
## Liste de contrôle de migration
Consultez cette liste de contrôle pour la migration :
+ Mises à jour de Java 17
+ [Scala] Mettre à niveau les appels du AWS SDK de la v1 à la v2
+ Migration de Python 3.10 vers Python 3.11
+ [Python] Mise à jour des références boto de la version 1.26 vers la version 1.34
## AWS Glue Caractéristiques de la version 5.0
Cette section décrit les AWS Glue fonctionnalités de manière plus détaillée.
### Interrogation de catalogues de données de métastore à partir de l'ETL AWS Glue
Vous pouvez enregistrer votre AWS Glue travail pour accéder au AWS Glue Data Catalog, qui met les tables et autres ressources de métastore à la disposition de clients disparates. Le catalogue de données prend en charge une hiérarchie de catalogues multiples, qui unifie toutes vos données dans les lacs de données Amazon S3. Il fournit également une API de métastore Hive et une API Apache Iceberg open source pour accéder aux données. Ces fonctionnalités sont disponibles pour AWS Glue d'autres services axés sur les données tels qu'Amazon EMR, Amazon Athena et Amazon Redshift.
Lorsque vous créez des ressources dans le catalogue de données, vous pouvez y accéder à partir de n'importe quel moteur SQL prenant en charge l'API REST Apache Iceberg. AWS Lake Formation gère les autorisations. Après la configuration, vous pouvez tirer parti des capacités AWS Glue de l'application pour interroger des données disparates en interrogeant ces ressources de métastore avec des applications familières. Il s’agit notamment d’Apache Spark et de Trino.
#### Organisation des ressources de métadonnées
Les données sont organisées selon une hiérarchie logique de catalogues, de bases de données et de tables, à l' AWS Glue Data Catalog aide des éléments suivants :
+ Catalogue : conteneur logique qui contient des objets provenant d’un entrepôt de données, tels que des schémas ou des tables.
+ Base de données : organise les objets de données tels que les tables et les vues dans un catalogue.
+ Tables et vues : objets de données d’une base de données qui fournissent une couche d’abstraction avec un schéma compréhensible. Ils facilitent l’accès aux données sous-jacentes, qui peuvent être dans différents formats et à différents emplacements.
## Migration de la AWS Glue version 4.0 vers AWS Glue la version 5.0
Tous les paramètres de travail existants et les principales fonctionnalités qui existent dans la AWS Glue version 4.0 existeront dans la AWS Glue version 5.0, à l'exception des transformations liées à l'apprentissage automatique.
Les nouveaux paramètres suivants ont été ajoutés :
+ `--enable-lakeformation-fine-grained-access`: Active la fonctionnalité de contrôle d'accès détaillé (FGAC) dans les tables de AWS Lake Formation.
Reportez-vous à la documentation sur la migration de Spark :
+ [Guide de migration : Spark Core](https://spark.apache.org/docs/3.5.6/core-migration-guide.html)
+ [Guide de migration : SQL, ensembles de données et DataFrame](https://spark.apache.org/docs/3.5.6/sql-migration-guide.html)
+ [Guide de migration : streaming structuré](https://spark.apache.org/docs/3.5.6/ss-migration-guide.html)
+ [Upgrading PySpark](https://spark.apache.org/docs/3.5.6/api/python/migration_guide/pyspark_upgrade.html)
## Migration de la AWS Glue version 3.0 à AWS Glue la version 5.0
**Note**
Pour les étapes de migration liées à la AWS Glue version 4.0, voir[Migration de la AWS Glue version 3.0 à AWS Glue la version 4.0](migrating-version-40.md#migrating-version-40-from-30).
Tous les paramètres de travail existants et les fonctionnalités principales qui existent dans la AWS Glue version 3.0 existeront dans la AWS Glue version 5.0, à l'exception des transformations de machine learning.
## Migration de la AWS Glue version 2.0 vers AWS Glue la version 5.0
**Note**
Pour les étapes de migration liées à la version AWS Glue 4.0 et la liste des différences de migration entre les AWS Glue versions 3.0 et 4.0, voir[Migration de la AWS Glue version 3.0 à AWS Glue la version 4.0](migrating-version-40.md#migrating-version-40-from-30).
Notez également les différences de migration suivantes entre AWS Glue les versions 3.0 et 2.0 :
+ Tous les paramètres de travail existants et les principales fonctionnalités qui existent dans la AWS Glue version 2.0 existeront dans la AWS Glue version 5.0, à l'exception des transformations de machine learning.
+ Plusieurs modifications Spark peuvent à elles seules nécessiter une révision de vos scripts pour s’assurer que les fonctions supprimées ne sont pas référencées. Par exemple, Spark 3.1.1 et versions ultérieures n'activent pas Scala-Untyped, UDFs mais Spark 2.4 le permet.
+ Python 2.7 n’est pas pris en charge.
+ Tout fichier jar supplémentaire fourni dans les tâches AWS Glue 2.0 existantes peut entraîner des dépendances conflictuelles, car plusieurs dépendances ont été mises à niveau. Vous pouvez éviter les conflits de chemin de classe avec le paramètre de tâche `--user-jars-first`.
+ Modifications du comportement des fichiers loading/saving de from/to parquet horodatés. Pour plus de détails, veuillez consulter Mise à niveau de Spark SQL 3.0 vers 3.1.
+ Parallélisme différent des tâches Spark pour driver/executor la configuration. Vous pouvez ajuster le parallélisme des tâches en transmettant l’argument de la tâche `--executor-cores`.
## Changements de comportement de journalisation dans la AWS Glue version 5.0
Les modifications apportées au comportement de journalisation dans la AWS Glue version 5.0 sont les suivantes. Pour plus d'informations, consultez la section [Journalisation des AWS Glue tâches](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging.html).
+ Tous les journaux (journaux du système, journaux de démon Spark, journaux des utilisateurs et journaux Glue Logger) sont désormais écrits dans le groupe de journaux `/aws-glue/jobs/error` par défaut.
+ Le groupe de journaux `/aws-glue/jobs/logs-v2` utilisé pour la journalisation continue dans les versions précédentes n’est plus utilisé.
+ Vous ne pouvez plus renommer ou personnaliser les noms des groupes de journaux ou des flux de journaux à l’aide des arguments de journalisation continue supprimés. Consultez plutôt les nouveaux arguments de tâche dans la AWS Glue version 5.0.
### Deux nouveaux arguments de travail sont introduits dans la AWS Glue version 5.0
+ `––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`.
+ `––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.
Les règles de validation et les restrictions relatives aux préfixes personnalisés sont les suivantes :
+ Le nom complet du flux de journaux doit comporter entre 1 et 512 caractères.
+ Le préfixe personnalisé pour les noms des flux de journaux est limité à 400 caractères.
+ Les caractères autorisés dans les préfixes incluent les caractères alphanumériques, les traits de soulignement (« \$1 »), les traits d’union (« - ») et les barres obliques (« / »).
### Arguments de journalisation continue obsolètes dans la version 5.0 AWS Glue
Les arguments de tâche suivants pour la journalisation continue ont été déconseillés dans la version 5.0 AWS Glue
+ `––enable-continuous-cloudwatch-log`
+ `––continuous-log-logGroup`
+ `––continuous-log-logStreamPrefix`
+ `––continuous-log-conversionPattern`
+ `––enable-continuous-log-filter`
## Migration du connecteur et du pilote JDBC pour la version 5.0 AWS Glue
Pour en savoir plus sur les versions des connecteurs JDBC et de lac de données qui ont été mises à niveau, consultez :
+ [Annexe B : Mises à niveau du pilote JDBC](#migrating-version-50-appendix-jdbc-driver)
+ [Annexe C : Mises à niveau des connecteurs](#migrating-version-50-appendix-connector)
+ [Annexe D : Mises à niveau du format de table ouverte](#migrating-version-50-appendix-open-table-formats)
Les modifications suivantes s’appliquent aux versions du connecteur ou du pilote identifiées dans les annexes de Glue 5.0.
**Amazon Redshift**
Notez les modifications suivantes :
+ Ajoute la prise en charge des noms de table en trois parties pour permettre au connecteur d’interroger les tables de partage de données Redshift.
+ Corrige le mappage de Spark `ShortType` pour utiliser Redshift `SMALLINT` plutôt que `INTEGER`, afin de mieux correspondre à la taille de données attendue.
+ Ajout de la prise en charge des noms de cluster personnalisés (CNAME) pour Amazon Redshift sans serveur.
**Apache Hudi**
Notez les modifications suivantes :
+ Prise en charge des indices au niveau des enregistrements.
+ Prise en charge de la génération automatique de clés d’enregistrement. Vous n’avez plus besoin de spécifier le champ de clé d’enregistrement.
**Apache Iceberg**
Notez les modifications suivantes :
+ Support d'un contrôle d'accès précis avec. AWS Lake Formation
+ Prise en charge du branchement et du balisage, qui sont des références nommées à des instantanés dotés de leur propre cycle de vie indépendant.
+ Ajout d’une procédure d’affichage du journal des modifications qui génère une vue contenant les modifications apportées à une table au cours d’une période spécifiée ou entre des instantanés spécifiques.
**Delta Lake**
Notez les modifications suivantes :
+ Support du format Delta Universal (UniForm) qui permet un accès fluide via Apache Iceberg et Apache Hudi.
+ Support des vecteurs de suppression qui implémentent un Merge-on-Read paradigme.
**AzureCosmos**
Notez les modifications suivantes :
+ Ajout de la prise en charge des clés de partition hiérarchiques.
+ Ajout d'une option permettant d'utiliser un schéma personnalisé avec StringType (json brut) pour une propriété imbriquée.
+ Ajout d'une option `spark.cosmos.auth.aad.clientCertPemBase64` de configuration pour permettre d'utiliser l'authentification SPN (ServicePrincipal nom) avec un certificat au lieu du secret client.
Pour plus d’informations, consultez [Azure Cosmos DB Spark connector change log](https://github.com/Azure/azure-sdk-for-java/blob/main/sdk/cosmos/azure-cosmos-spark_3-2_2-12/CHANGELOG.md).
**Microsoft SQL Server**
Notez les modifications suivantes :
+ Le chiffrement TLS est activé par défaut.
+ Lorsque encrypt = false, mais que le serveur exige le chiffrement, le certificat est validé en fonction du paramètre de connexion `trustServerCertificate`.
+ `aadSecurePrincipalId` et `aadSecurePrincipalSecret` sont obsolètes.
+ API `getAADSecretPrincipalId` supprimée.
+ Résolution CNAME ajoutée lorsque le domaine est spécifié.
**MongoDB**
Notez les modifications suivantes :
+ Prise en charge du mode microlots avec Spark Structured Streaming.
+ Prise en charge des types de données BSON.
+ Ajout de la prise en charge de la lecture de plusieurs collections lors de l’utilisation des modes microlots ou de streaming continu.
+ Si le nom d’une collection utilisée dans votre option de configuration `collection` contient une virgule, le connecteur Spark la traite comme deux collections différentes. Pour éviter ceci, échappez la virgule en la faisant précéder d’une barre oblique inverse (\$1).
+ Si le nom d’une collection utilisée dans votre option de configuration `collection` est « \$1 », le connecteur Spark l’interprète comme une spécification pour analyser toutes les collections. Pour éviter ceci, échappez l’astérisque en le faisant précéder d’une barre oblique inverse (\$1).
+ Si le nom d’une collection utilisée dans votre option de configuration `collection` contient une barre oblique inverse (\$1), le connecteur Spark traite la barre oblique inverse comme un caractère d’échappement, ce qui peut modifier la façon dont il interprète la valeur. Pour éviter cela, vous devez échapper la barre oblique inverse en la faisant précéder d’une autre barre oblique inverse.
Pour plus d’informations, consultez [MongoDB connector for Spark release notes](https://www.mongodb.com/docs/spark-connector/current/release-notes/).
**Snowflake**
Notez les modifications suivantes :
+ Ajout d’un nouveau paramètre `trim_space` que vous pouvez utiliser pour réduire automatiquement les valeurs des colonnes `StringType` lors de l’enregistrement dans une table Snowflake. Valeur par défaut : `false`.
+ Le paramètre `abort_detached_query` a été désactivé par défaut au niveau de la session.
+ Suppression de l’exigence du paramètre `SFUSER` lors de l’utilisation d’OAUTH.
+ Suppression de la fonctionnalité Advanced Query Pushdown. Des alternatives à cette fonctionnalité sont disponibles. Par exemple, au lieu de charger des données à partir de tables Snowflake, les utilisateurs peuvent charger directement des données à partir de requêtes SQL Snowflake.
Pour plus d’informations, consultez [Snowflake Connector for Spark release notes](https://docs.snowflake.com/en/release-notes/clients-drivers/spark-connector-2024).
### Annexe A : Mises à niveau notables des dépendances
Voici les mises à niveau des dépendances :
| Dépendance | Version en AWS Glue 5.0 | Version en AWS Glue 4.0 | Version en AWS Glue 3.0 | Version en AWS Glue 2.0 | Version en AWS Glue 1.0 |
| --- | --- | --- | --- | --- | --- |
| Java | 17 | 8 | 8 | 8 | 8 |
| Spark | 3.5.4 | 3.3.0-amzn-1 | 3.1.1-amzn-0 | 2.4.3 | 2.4.3 |
| Hadoop | 3.4.1 | 3.3.3-amzn-0 | 3.2.1-amzn-3 | 2.8.5-amzn-5 | 2.8.5-amzn-1 |
| Scala | 2,1,18 | 2,12 | 2,12 | 2.11 | 2.11 |
| Jackson | 2.15.2 | 2,12 | 2,12 | 2.11 | 2.11 |
| Hive | 2.3.9-amzn-4. | 2.3.9-amzn-2 | 2.3.7-amzn-4 | 1.2 | 1.2 |
| EMRFS | 2,69,0 | 2,54,0 | 2,46,0 | 2.38.0 | 2.30.0 |
| Json4s | 3.7.0-M11 | 3.7.0-M11 | 3.6.6 | 3.5.x | 3.5.x |
| Flèche | 12,0.1 | 7.0.0 | 2.0.0 | 0.10.0 | 0.10.0 |
| AWS Glue Client de catalogue de données | 4.5.0 | 3.7.0 | 3.0.0 | 1.10.0 | N/A |
| AWS SDK pour Java | 2,29,52 | 1.12 | 1.12 | | |
| Python | 3,11 | 3,10 | 3.7 | 2.7 et 3.6 | 2.7 et 3.6 |
| Boto | 1,34,131 | 1,26 | 1,18 | 1.12 | N/A |
| Connecteur EMR DynamoDB | 5.6.0 | 4,16,0 | | | |
### Annexe B : Mises à niveau du pilote JDBC
Voici les mises à niveau du pilote JDBC :
| Pilote | Version du pilote JDBC en 5.0 AWS Glue | Version du pilote JDBC en 4.0 AWS Glue | Version du pilote JDBC en 3.0 AWS Glue | Version du pilote JDBC dans les versions précédentes AWS Glue |
| --- | --- | --- | --- | --- |
| MySQL | 8,0,33 | 8.0.23 | 8.0.23 | 5.1 |
| Microsoft SQL Server | 10.2.0 | 9.4.0 | 7.0.0 | 6.1.0 |
| Oracle Databases | 23,3.0,23,09 | 21,7 | 21,1 | 11.2 |
| PostgreSQL | 42.7.3 | 42,3.6 | 42,2,18 | 42,10 |
| Amazon Redshift | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.16 | redshift-jdbc41-1.2.12.1017 | redshift-jdbc41-1.2.12.1017 |
| SAP Hana | 2,20,17 | 2,17,12 | | |
| Teradata | 20,00.00.33 | 20,00.00.06 | | |
### Annexe C : Mises à niveau des connecteurs
Les mises à niveau des connecteurs sont les suivantes :
| Pilote | Version du connecteur en AWS Glue 5.0 | Version du connecteur en AWS Glue 4.0 | Version du connecteur en AWS Glue 3.0 |
| --- | --- | --- | --- |
| Connecteur EMR DynamoDB | 5.6.0 | 4,16,0 | |
| Amazon Redshift | 6.4.0 | 6.1.3 | |
| OpenSearch | 1.2.0 | 1.0.1 | |
| MongoDB | 10.3.0 | 10,0.4 | 3.0.0 |
| Snowflake | 3.0.0 | 2.12.0 | |
| Google BigQuery | 0,32,2 | 0,32,2 | |
| AzureCosmos | 4,33,0 | 4,22,0 | |
| AzureSQL | 1.3.0 | 1.3.0 | |
| Vertica | 3.3.5 | 3.3.5 | |
### Annexe D : Mises à niveau du format de table ouverte
Les mises à niveau du format de table ouverte sont les suivantes :
| OTF | Version du connecteur en AWS Glue 5.0 | Version du connecteur en AWS Glue 4.0 | Version du connecteur en AWS Glue 3.0 |
| --- | --- | --- | --- |
| Hudi | 0,15,0 | 0.12.1 | 0,1,1 |
| Delta Lake | 3.3.0 | 2.1.0 | 1.0.0 |
| Iceberg | 1.7.1 | 1.0.0 | 0.13.1 |
# Migration AWS Glue des tâches Spark vers la AWS Glue version 4.0
Cette rubrique décrit les modifications apportées entre AWS Glue les versions 0.9, 1.0, 2.0 et 3.0 pour vous permettre de migrer vos applications Spark et vos tâches ETL vers la AWS Glue version 4.0. Il décrit également les fonctionnalités de la AWS Glue version 4.0 et les avantages de son utilisation.
Pour utiliser cette fonctionnalité avec vos tâches AWS Glue ETL, **4.0** choisissez-la `Glue version` lors de la création de vos tâches.
**Topics**
+ [Nouvelles fonctionnalités prises en charge](#migrating-version-40-features)
+ [Actions pour migrer vers la AWS Glue version 4.0](#migrating-version-40-actions)
+ [Liste de contrôle de migration](#migrating-version-40-checklist)
+ [Migration de la AWS Glue version 3.0 à AWS Glue la version 4.0](#migrating-version-40-from-30)
+ [Migration de la AWS Glue version 2.0 vers AWS Glue la version 4.0](#migrating-version-40-from-20)
+ [Migration de la AWS Glue version 1.0 à AWS Glue la version 4.0](#migrating-version-40-from-10)
+ [Migration de la version AWS Glue 0.9 à AWS Glue la version 4.0](#migrating-version-40-from-09)
+ [Migration du connecteur et du pilote JDBC pour la version 4.0 AWS Glue](#migrating-version-40-connector-driver-migration)
+ [Annexe A : Mises à niveau notables des dépendances](#migrating-version-40-appendix-dependencies)
+ [Annexe B : Mises à niveau du pilote JDBC](#migrating-version-40-appendix-jdbc-driver)
+ [Annexe C : Mises à niveau des connecteurs](#migrating-version-40-appendix-connector)
## Nouvelles fonctionnalités prises en charge
Cette section décrit les nouvelles fonctionnalités et les avantages de la AWS Glue version 4.0.
+ Elle est basée sur Apache Spark 3.3.0, mais propose des optimisations dans AWS Glue et Amazon EMR, telles que les exécutions adaptatives de requêtes, les lecteurs vectorisés, les remaniements optimisées et la fusion de partitions.
+ Pilotes JDBC mis à niveau pour toutes les sources AWS Glue natives, notamment MySQL, Microsoft SQL Server, Oracle, PostgreSQL, MongoDB, ainsi que les bibliothèques et dépendances Spark mises à niveau introduites par Spark 3.3.0.
+ Utilisation d'un nouveau connecteur Amazon Redshift et d'un nouveau pilote JDBC.
+ Accès optimisé à Amazon S3 avec EMRFS (système de fichiers EMR) mis à niveau et validateurs de sortie optimisés Amazon S3 activés par défaut.
+ Accès optimisé au catalogue de données avec des index de partition, le déploiement des prédicats, une liste de partitions et un client de métastore Hive mis à niveau.
+ Intégration à Lake Formation pour les tables de catalogue régies avec filtrage au niveau des cellules et transactions de lac de données.
+ Réduction de la latence au démarrage afin d'améliorer les temps globaux de réalisation de tâche et l'interactivité.
+ Les tâches Spark sont facturées par incréments d'une seconde avec une durée de facturation minimale 10 fois inférieure, allant d'un minimum de 10 minutes à un minimum de 1 minute.
+ Prise en charge native des infrastructures de lacs de données ouverts avec Apache Hudi, Delta Lake et Apache Iceberg.
+ Prise en charge native du plug-in Cloud Shuffle Storage basé sur Amazon S3 (un plug-in Apache Spark) permettant d'utiliser Amazon S3 pour la réorganisation et la capacité de stockage élastique.
**Améliorations majeures de Spark 3.1.1 à Spark 3.3.0**
Notez les améliorations suivantes :
+ Filtrage d'exécution au niveau des lignes ([SPARK-32268](https://issues.apache.org/jira/browse/SPARK-32268)).
+ Améliorations ANSI ([SPARK-38860](https://issues.apache.org/jira/browse/SPARK-38860)).
+ Améliorations des messages d'erreur ([SPARK-38781](https://issues.apache.org/jira/browse/SPARK-38781)).
+ Prise en charge des types complexes pour le lecteur vectorisé Parquet ([SPARK-34863](https://issues.apache.org/jira/browse/SPARK-34863)).
+ Prise en charge des métadonnées de fichiers masqués pour Spark SQL ([SPARK-37273](https://issues.apache.org/jira/browse/SPARK-37273)).
+ Fournissez un profileur pour Python/Pandas UDFs ([SPARK-37443](https://issues.apache.org/jira/browse/SPARK-37443)).
+ Présentez Trigger. AvailableNow [pour exécuter des requêtes de streaming telles que Trigger.Once en plusieurs lots (SPARK-36533).](https://issues.apache.org/jira/browse/SPARK-36533)
+ Fonctionnalités pushdown de Datasource V2 plus complètes ([SPARK-38788](https://issues.apache.org/jira/browse/SPARK-38788)).
+ Migration de log4j 1 vers log4j 2 ([SPARK-37814](https://issues.apache.org/jira/browse/SPARK-37814)).
**Autres changements notables**
Notez les modifications suivantes :
+ Évolutions
+ Supprimez les références au support de Python 3.6 dans les documents et Python/docs ([SPARK-36977](https://issues.apache.org/jira/browse/SPARK-36977)).
+ Suppression du tuple hack nommé en remplaçant le pickle intégré par cloudpickle ([SPARK-32079](https://issues.apache.org/jira/browse/SPARK-32079)).
+ Passage de la version minimale de Pandas à 1.0.5 ([SPARK-37465](https://issues.apache.org/jira/browse/SPARK-37465)).
## Actions pour migrer vers la AWS Glue version 4.0
Pour les tâches existantes, modifiez la `Glue version` depuis la version précédente vers `Glue 4.0` dans la configuration de la tâche.
+ Dans AWS Glue Studio, choisissez « `Glue 4.0 - Supports Spark 3.3, Scala 2, Python 3` in `Glue version` ».
+ Dans l’API, choisissez **4.0** dans le paramètre `GlueVersion` de l’opération d’API [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-UpdateJob](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-UpdateJob).
Pour les nouvelles tâches, choisissez `Glue 4.0` lorsque vous créez une tâche.
+ Dans la console, choisissez `Spark 3.3, Python 3 (Glue Version 4.0) or Spark 3.3, Scala 2 (Glue Version 3.0)` dans `Glue version`.
+ Dans AWS Glue Studio, choisissez « `Glue 4.0 - Supports Spark 3.3, Scala 2, Python 3` in `Glue version` ».
+ Dans l’API, choisissez **4.0** dans le paramètre `GlueVersion` de l’opération d’API [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-CreateJob](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-CreateJob).
Pour consulter les journaux d'événements Spark AWS Glue 4.0 issus de la version AWS Glue 2.0 ou d'une version antérieure, [lancez un serveur d'historique Spark mis à niveau pour AWS Glue 4.0 à l'aide CloudFormation de Docker](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-history.html).
## Liste de contrôle de migration
+ Les bibliothèques Python externes de votre tâche dépendent-elles de Python 2.7/3.6 ?
+ Mettez à jour les bibliothèques dépendantes de Python 2.7/3.6 vers Python 3.10, car Spark 3.3.0 a supprimé la prise en charge de Python 2.7 et 3.6.
## Migration de la AWS Glue version 3.0 à AWS Glue la version 4.0
Notez les modifications suivantes lors de la migration :
+ Tous les paramètres de travail existants et les fonctionnalités principales qui existent dans la AWS Glue version 3.0 existeront dans la AWS Glue version 4.0.
+ AWS Glue La version 3.0 utilise Spark 3.1.1 optimisé pour Amazon EMR, et la version 4.0 AWS Glue utilise Spark 3.3.0 optimisé pour Amazon EMR.
Plusieurs modifications Spark pourraient à elles seules nécessiter une révision de vos scripts pour s'assurer que les fonctions supprimées ne sont pas référencées.
+ AWS Glue La version 4.0 inclut également une mise à jour d'EMRFS et de Hadoop. Pour en savoir plus sur cette version spécifique, consultez [Annexe A : Mises à niveau notables des dépendances](#migrating-version-40-appendix-dependencies).
+ Le AWS SDK fourni dans les tâches ETL est désormais mis à niveau de la version 1.11 à la version 1.12.
+ Toutes les tâches Python utiliseront la version 3.10 de Python. Auparavant, Python 3.7 était utilisé dans la AWS Glue version 3.0.
Par conséquent, certains pymodules proposés AWS Glue sont mis out-of-the-box à niveau.
+ Log4j a été mis à niveau vers Log4j2.
+ Pour plus d'informations sur le chemin de migration Log4j2, consultez la [documentation de Log4j](https://logging.apache.org/log4j/2.x/manual/migration.html#Log4j2API).
+ Vous devez plutôt renommer tout fichier log4j.properties personnalisé comme fichier log4j2.properties, avec les propriétés log4j2 appropriées.
+ Pour la migration de certains connecteurs, consultez [Migration du connecteur et du pilote JDBC pour la version 4.0 AWS Glue](#migrating-version-40-connector-driver-migration).
+ Le SDK de AWS chiffrement est mis à niveau de la version 1.x à la version 2.x. AWS Glue les tâches utilisant des configurations AWS Glue de sécurité et les tâches dépendantes de la dépendance du SDK de AWS chiffrement fournie lors de l'exécution sont affectées. Consultez les instructions relatives à la migration des AWS Glue tâches.
Vous pouvez mettre à niveau en toute sécurité une tâche AWS Glue 2.0/3.0 vers une tâche AWS Glue 4.0, car la version AWS Glue 2.0/3.0 contient déjà la version pont du SDK de AWS chiffrement.
Reportez-vous à la documentation sur la migration de Spark :
+ [Upgrading from Spark SQL 3.1 to 3.2](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-31-to-32)
+ [Upgrading from Spark SQL 3.2 to 3.3](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-32-to-33)
## Migration de la AWS Glue version 2.0 vers AWS Glue la version 4.0
Notez les modifications suivantes lors de la migration :
**Note**
Pour les étapes de migration liées à la AWS Glue version 3.0, voir[Migration de la AWS Glue version 3.0 à AWS Glue la version 4.0](#migrating-version-40-from-30).
+ Tous les paramètres de travail existants et les principales fonctionnalités qui existent dans la AWS Glue version 2.0 existeront dans la AWS Glue version 4.0.
+ Le validateur EMRFS S3 optimisé pour écrire des données Parquet dans Amazon S3 est activé par défaut depuis la version 3.0. AWS Glue Cependant, vous pouvez toujours le désactiver en définissant `--enable-s3-parquet-optimized-committer` sur `false`.
+ AWS Glue La version 2.0 utilise le logiciel libre Spark 2.4 et la AWS Glue version 4.0 utilise Spark 3.3.0 optimisé pour Amazon EMR.
+ Plusieurs modifications Spark peuvent à elles seules nécessiter une révision de vos scripts pour s'assurer que les fonctions supprimées ne sont pas référencées.
+ Par exemple, Spark 3.3.0 n'active pas Scala-Untyped UDFs, mais Spark 2.4 le permet.
+ Le AWS SDK fourni dans les tâches ETL est désormais mis à niveau de la version 1.11 à la version 1.12.
+ AWS Glue La version 4.0 inclut également une mise à jour d'EMRFS, des pilotes JDBC mis à jour et l'inclusion d'optimisations supplémentaires sur Spark lui-même fournies par. AWS Glue
+ Scala est mis à jour depuis la version 2.11 vers la version 2.12, et Scala 2.12 n'est pas rétrocompatible avec Scala 2.11.
+ Python 3.10 est la version utilisée par défaut pour les scripts Python, comme AWS Glue 2.0 utilisait uniquement Python 3.7 et 2.7.
+ Python 2.7 n'est pas pris en charge avec Spark 3.3.0. Toute tâche demandant Python 2 dans la configuration de la tâche échouera avec un IllegalArgumentException.
+ Un nouveau mécanisme d'installation de modules Python supplémentaires est disponible depuis la AWS Glue version 2.0.
+ Plusieurs mises à jour de dépendance, mises en évidence dans [Annexe A : Mises à niveau notables des dépendances](#migrating-version-40-appendix-dependencies).
+ Tout fichier JAR supplémentaire fourni dans les tâches AWS Glue 2.0 existantes peut entraîner des dépendances conflictuelles car plusieurs dépendances ont été mises à niveau dans la version 4.0 par rapport à la version 2.0. Vous pouvez éviter les conflits de chemin de classe dans la AWS Glue version 4.0 avec le paramètre `--user-jars-first` AWS Glue job.
+ AWS Glue La version 4.0 utilise Spark 3.3. À partir de Spark 3.1, il y a eu un changement dans le comportement loading/saving des fichiers from/to parquet horodatés. Pour plus de détails, veuillez consulter [Mise à niveau de Spark SQL 3.0 vers 3.1](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-30-to-31).
Nous vous recommandons de définir les paramètres suivants lorsque vous parcourez des reading/writing données contenant des colonnes d'horodatage. La définition de ces paramètres peut résoudre le problème d'incompatibilité du calendrier qui se produit lors de la mise à niveau de Spark 2 vers Spark 3, tant pour le AWS Glue Dynamic Frame que pour le Spark Data Frame. Utilisez l'option CORRECTED pour lire la valeur datetime telle quelle, et l'option LEGACY pour rebaser les valeurs datetime par rapport à la différence de calendrier pendant la lecture.
```
- Key: --conf
- Value: spark.sql.legacy.parquet.int96RebaseModeInRead=[CORRECTED|LEGACY] --conf spark.sql.legacy.parquet.int96RebaseModeInWrite=[CORRECTED|LEGACY] --conf spark.sql.legacy.parquet.datetimeRebaseModeInRead=[CORRECTED|LEGACY]
```
+ Pour la migration de certains connecteurs, consultez [Migration du connecteur et du pilote JDBC pour la version 4.0 AWS Glue](#migrating-version-40-connector-driver-migration).
+ Le SDK de AWS chiffrement est mis à niveau de la version 1.x à la version 2.x. AWS Glue les tâches utilisant des configurations AWS Glue de sécurité et les tâches dépendantes de la dépendance du SDK de AWS chiffrement fournie lors de l'exécution sont affectées. Consultez les instructions suivantes pour la migration des AWS Glue tâches :
+ Vous pouvez mettre à niveau une tâche AWS Glue 2.0 vers une tâche AWS Glue 4.0 en toute sécurité, car la version AWS Glue 2.0 contient déjà la version pont du SDK de AWS chiffrement.
Reportez-vous à la documentation sur la migration de Spark :
+ [Upgrading from Spark SQL 2.4 to 3.0](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-24-to-30)
+ [Upgrading from Spark SQL 3.1 to 3.2](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-31-to-32)
+ [Upgrading from Spark SQL 3.2 to 3.3](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-32-to-33)
+ [Changes in Datetime behavior to be expected since Spark 3.0.](https://issues.apache.org/jira/browse/SPARK-31408)
## Migration de la AWS Glue version 1.0 à AWS Glue la version 4.0
Notez les modifications suivantes lors de la migration :
+ AWS Glue La version 1.0 utilise le logiciel libre Spark 2.4 et la AWS Glue version 4.0 utilise Spark 3.3.0 optimisé pour Amazon EMR.
+ Plusieurs modifications Spark peuvent à elles seules nécessiter une révision de vos scripts pour s'assurer que les fonctions supprimées ne sont pas référencées.
+ Par exemple, Spark 3.3.0 n'active pas Scala-Untyped UDFs, mais Spark 2.4 le permet.
+ Toutes les tâches de la AWS Glue version 4.0 seront exécutées avec des temps de démarrage nettement améliorés. Les tâches Spark seront facturées par incréments d'une seconde avec une durée de facturation minimale 10 fois plus faible, puisque la latence de démarrage passera de 10 minutes maximum à 1 minute maximum.
+ Le comportement de journalisation a changé de manière significative dans la AWS Glue version 4.0, la configuration minimale requise pour Spark 3.3.0 est Log4j2.
+ Plusieurs mises à jour de dépendance, mises en évidence dans l'annexe.
+ Scala est également mis à jour depuis la version 2.11 vers la version 2.12, et Scala 2.12 n'est pas rétrocompatible avec Scala 2.11.
+ Python 3.10 est également la version utilisée par défaut pour les scripts Python, comme AWS Glue 0.9 utilisait uniquement Python 2.
Python 2.7 n'est pas pris en charge avec Spark 3.3.0. Toute tâche demandant Python 2 dans la configuration de la tâche échouera avec un IllegalArgumentException.
+ Un nouveau mécanisme d'installation de modules Python supplémentaires via pip est disponible depuis la AWS Glue version 2.0. Pour plus d'informations, consultez [Installing additional Python modules with pip in AWS Glue 2.0\$1](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-libraries.html#addl-python-modules-support).
+ AWS Glue La version 4.0 ne s'exécute pas sur Apache YARN, les paramètres YARN ne s'appliquent donc pas.
+ AWS Glue La version 4.0 ne possède pas de système de fichiers distribué Hadoop (HDFS).
+ Tout fichier JAR supplémentaire fourni dans les tâches AWS Glue 1.0 existantes peut entraîner des dépendances conflictuelles car plusieurs dépendances ont été mises à niveau dans la version 4.0 par rapport à la version 1.0. Pour éviter ce problème, nous activons la AWS Glue version 4.0 avec le paramètre `--user-jars-first` AWS Glue job par défaut.
+ AWS Glue La version 4.0 prend en charge la mise à l'échelle automatique. Par conséquent, la ExecutorAllocationManager métrique sera disponible lorsque la mise à l'échelle automatique sera activée.
+ Dans les tâches de la AWS Glue version 4.0, vous spécifiez le nombre de travailleurs et le type de travailleur, mais vous ne spécifiez pas de`maxCapacity`.
+ AWS Glue La version 4.0 ne prend pas encore en charge les transformations du machine learning.
+ Pour la migration de certains connecteurs, consultez [Migration du connecteur et du pilote JDBC pour la version 4.0 AWS Glue](#migrating-version-40-connector-driver-migration).
+ Le SDK de AWS chiffrement est mis à niveau de la version 1.x à la version 2.x. AWS Glue les tâches utilisant des configurations AWS Glue de sécurité et les tâches dépendantes de la dépendance du SDK de AWS chiffrement fournie lors de l'exécution sont affectées. Consultez ces instructions pour la migration des AWS Glue tâches.
+ Vous ne pouvez pas migrer AWS Glue directement une tâche 0.9/1.0 vers une tâche AWS Glue 4.0. En effet, lors de la mise à niveau directe vers la version 2.x ou ultérieure et de l'activation immédiate de toutes les nouvelles fonctionnalités, le SDK de AWS chiffrement ne sera pas en mesure de déchiffrer le texte chiffré dans les versions antérieures du SDK de chiffrement. AWS
+ Pour effectuer une mise à niveau en toute sécurité, nous vous recommandons d'abord de migrer vers une tâche AWS Glue 2.0/3.0 contenant la version pont du SDK AWS Encryption. Exécutez la tâche une fois pour utiliser la version pont du SDK de AWS chiffrement.
+ Une fois terminé, vous pouvez migrer en toute sécurité la tâche AWS Glue 2.0/3.0 vers AWS Glue la version 4.0.
Reportez-vous à la documentation sur la migration de Spark :
+ [Upgrading from Spark SQL 2.4 to 3.0](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-24-to-30)
+ [Upgrading from Spark SQL 3.0 to 3.1](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-30-to-31)
+ [Upgrading from Spark SQL 3.1 to 3.2](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-31-to-32)
+ [Upgrading from Spark SQL 3.2 to 3.3](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-32-to-33)
+ [Changes in Datetime behavior to be expected since Spark 3.0.](https://issues.apache.org/jira/browse/SPARK-31408)
## Migration de la version AWS Glue 0.9 à AWS Glue la version 4.0
Notez les modifications suivantes lors de la migration :
+ AWS Glue La version 0.9 utilise le logiciel libre Spark 2.2.1 et la AWS Glue version 4.0 utilise Spark 3.3.0 optimisé pour Amazon EMR.
+ Plusieurs modifications Spark pourraient à elles seules nécessiter une révision de vos scripts pour s'assurer que les fonctions supprimées ne sont pas référencées.
+ Par exemple, Spark 3.3.0 n'active pas Scala-Untyped UDFs, mais Spark 2.2 le permet.
+ Toutes les tâches de la AWS Glue version 4.0 seront exécutées avec des temps de démarrage nettement améliorés. Les tâches Spark seront facturées par incréments d'une seconde avec une durée de facturation minimale 10 fois plus faible, car la latence de démarrage passera de 10 minutes maximum à 1 minute maximum.
+ Le comportement de journalisation a changé de manière significative depuis la AWS Glue version 4.0, Spark 3.3.0 requiert au minimum Log4j2, comme indiqué ici (https://spark.apache.org/docs/latest/core-migration-guide.html\$1 -32-to-33). upgrading-from-core
+ Plusieurs mises à jour de dépendance, mises en évidence dans l'annexe.
+ Scala est également mis à jour depuis la version 2.11 vers la version 2.12, et Scala 2.12 n'est pas rétrocompatible avec Scala 2.11.
+ Python 3.10 est également la version utilisée par défaut pour les scripts Python, comme AWS Glue 0.9 utilisait uniquement Python 2.
+ Python 2.7 n'est pas pris en charge avec Spark 3.3.0. Toute tâche demandant Python 2 dans la configuration de la tâche échouera avec un IllegalArgumentException.
+ Un nouveau mécanisme d'installation de modules Python supplémentaires via pip est disponible.
+ AWS Glue La version 4.0 ne s'exécute pas sur Apache YARN, les paramètres YARN ne s'appliquent donc pas.
+ AWS Glue La version 4.0 ne possède pas de système de fichiers distribué Hadoop (HDFS).
+ Tout fichier JAR supplémentaire fourni dans les tâches AWS Glue 0.9 existantes peut entraîner des dépendances conflictuelles car plusieurs dépendances ont été mises à niveau dans la version 3.0 par rapport à la version 0.9. Vous pouvez éviter les conflits de chemin de classe dans la AWS Glue version 3.0 avec le paramètre `--user-jars-first` AWS Glue job.
+ AWS Glue La version 4.0 prend en charge la mise à l'échelle automatique. Par conséquent, la ExecutorAllocationManager métrique sera disponible lorsque la mise à l'échelle automatique sera activée.
+ Dans les tâches de la AWS Glue version 4.0, vous spécifiez le nombre de travailleurs et le type de travailleur, mais vous ne spécifiez pas de`maxCapacity`.
+ AWS Glue La version 4.0 ne prend pas encore en charge les transformations du machine learning.
+ Pour la migration de certains connecteurs, consultez [Migration du connecteur et du pilote JDBC pour la version 4.0 AWS Glue](#migrating-version-40-connector-driver-migration).
+ Le SDK de AWS chiffrement est mis à niveau de la version 1.x à la version 2.x. AWS Glue les tâches utilisant des configurations AWS Glue de sécurité et les tâches dépendantes de la dépendance du SDK de AWS chiffrement fournie lors de l'exécution sont affectées. Consultez ces instructions pour la migration des AWS Glue tâches.
+ Vous ne pouvez pas migrer AWS Glue directement une tâche 0.9/1.0 vers une tâche AWS Glue 4.0. En effet, lors de la mise à niveau directe vers la version 2.x ou ultérieure et de l'activation immédiate de toutes les nouvelles fonctionnalités, le SDK de AWS chiffrement ne sera pas en mesure de déchiffrer le texte chiffré dans les versions antérieures du SDK de chiffrement. AWS
+ Pour effectuer une mise à niveau en toute sécurité, nous vous recommandons d'abord de migrer vers une tâche AWS Glue 2.0/3.0 contenant la version pont du SDK AWS Encryption. Exécutez la tâche une fois pour utiliser la version pont du SDK de AWS chiffrement.
+ Une fois terminé, vous pouvez migrer en toute sécurité la tâche AWS Glue 2.0/3.0 vers AWS Glue la version 4.0.
Reportez-vous à la documentation sur la migration de Spark :
+ [Upgrading from Spark SQL 2.2 to 2.3](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-22-to-23)
+ [Upgrading from Spark SQL 2.3 to 2.4](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-23-to-24)
+ [Upgrading from Spark SQL 2.4 to 3.0](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-24-to-30)
+ [Upgrading from Spark SQL 3.0 to 3.1](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-30-to-31)
+ [Upgrading from Spark SQL 3.1 to 3.2](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-31-to-32)
+ [Upgrading from Spark SQL 3.2 to 3.3](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-32-to-33)
+ [Changes in Datetime behavior to be expected since Spark 3.0.](https://issues.apache.org/jira/browse/SPARK-31408)
## Migration du connecteur et du pilote JDBC pour la version 4.0 AWS Glue
Pour en savoir plus sur les versions des connecteurs JDBC et de lac de données qui ont été mises à niveau, consultez :
+ [Annexe B : Mises à niveau du pilote JDBC](#migrating-version-40-appendix-jdbc-driver)
+ [Annexe C : Mises à niveau des connecteurs](#migrating-version-40-appendix-connector)
### Hudi
+ Améliorations de la prise en charge de Spark SQL :
+ Cette commande `Call Procedure` permet de renforcer la prise en charge pour la mise à niveau, la rétrogradation, le démarrage, le nettoyage et la réparation. La syntaxe `Create/Drop/Show/Refresh Index` est autorisée dans Spark SQL.
+ Un écart de performance a été comblé entre les utilisations via Spark DataSource et Spark SQL. Dans le passé, les écritures Datasource étaient plus rapides qu'avec SQL.
+ Tous les générateurs de clés intégrés implémentent des opérations d'API spécifiques à Spark plus performantes.
+ Remplacement de la transformation UDF dans le cadre de l'`insert`opération en masse par des transformations RDD afin de réduire les coûts d'utilisation. SerDe
+ Spark SQL avec Hudi nécessite une `primaryKey` devant être spécifiée par `tblproperites` ou des options dans l'instruction SQL. Pour les opérations de mise à jour et de suppression, `preCombineField` est également obligatoire.
+ Toute table Hudi créée avant la version 0.10.0 sans avoir besoin de recréer un `primaryKey` avec un champ `primaryKey` depuis la version 0.10.0.
### PostgreSQL
+ Plusieurs vulnérabilités (CVEs) ont été corrigées.
+ Java 8 est pris en charge en mode natif.
+ Si la tâche utilise des tableaux de tableaux, à l'exception des tableaux d'octets, ce scénario peut être traité sous forme de tableaux multidimensionnels.
### MongoDB
+ Le connecteur MongoDB actuel prend en charge Spark version 3.1 ou ultérieure et MongoDB version 4.0 ou ultérieure.
+ En raison de la mise à niveau du connecteur, quelques noms de propriétés ont été modifiés. Par exemple, le nom de la propriété URI a été remplacé par `connection.uri`. Pour plus d'informations sur les options actuelles, consultez le [blog MongoDB Spark Connector](https://www.mongodb.com/docs/spark-connector/current/configuration/).
+ L'utilisation de MongoDB 4.0 hébergé par Amazon DocumentDB présente certaines différences fonctionnelles. Pour plus d’nformations, consultez les rubriques suivantes :
+ [Différences fonctionnelles : Amazon DocumentDB et MongoDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/functional-differences.html)
+ [MongoDB APIs, opérations et types de données pris en](https://docs.aws.amazon.com/documentdb/latest/developerguide/mongo-apis.html) charge.
+ L'option « partitionneur » est limitée à `ShardedPartitioner`, `PaginateIntoPartitionsPartitioner`, et `SinglePartitionPartitioner`. Elle ne peut pas utiliser les valeurs `SamplePartitioner` et `PaginateBySizePartitioner` par défaut pour Amazon DocumentDB, car l'opérateur de l'étape ne prend pas en charge l'API MongoDB. Pour plus d'informations, consultez [MongoDB APIs, Opérations et Types de données pris en charge](https://docs.aws.amazon.com/documentdb/latest/developerguide/mongo-apis.html).
### Delta Lake
+ Désormais, Delta Lake prend en charge les requêtes [Time Travel dans SQL](https://docs.delta.io/2.1.0/delta-batch.html#query-an-older-snapshot-of-a-table-time-travel) pour interroger facilement les données plus anciennes. Avec cette mise à jour, le voyage dans le temps est désormais disponible à la fois dans Spark SQL et via l' DataFrame API. La prise en charge de la version actuelle de TIMESTAMP dans SQL a été ajoutée.
+ Spark 3.3 présente [Trigger. AvailableNow](https://issues.apache.org/jira/browse/SPARK-36533)pour exécuter des requêtes de streaming comme équivalent à `Trigger.Once` des requêtes par lots. Cette prise en charge est également disponible en cas d'utilisation des tables Delta comme source de streaming.
+ Prise en charge de la fonction SHOW COLUMNS pour renvoyer la liste des colonnes d'une table.
+ Support de [DESCRIBE DETAIL](https://docs.delta.io/2.1.0/delta-utility.html#retrieve-delta-table-details) dans les DeltaTable API Scala et Python. Il récupère des informations détaillées sur une table Delta à l'aide de l' DeltaTable API ou de Spark SQL.
+ Prise en charge du renvoi de métriques d'opération à partir des commandes SQL [Delete](https://github.com/delta-io/delta/pull/1328), [Merge](https://github.com/delta-io/delta/pull/1327) et [Update](https://github.com/delta-io/delta/pull/1331). Auparavant, ces commandes SQL renvoyaient une valeur vide DataFrame, maintenant elles renvoient un DataFrame contenant des mesures utiles concernant l'opération effectuée.
+ Pour optimiser les améliorations de performances :
+ Définissez l'option de configuration `spark.databricks.delta.optimize.repartition.enabled=true` de manière à utiliser `repartition(1)` plutôt que `coalesce(1)` dans la commande Optimize afin de bénéficier de meilleures performances lors du compactage de nombreux petits fichiers.
+ [Performances améliorées](https://github.com/delta-io/delta/pull/1315) grâce à une approche basée sur la file d'attente afin d'exécuter en parallèle les tâches de compactage.
+ Autres changements notables :
+ [Prise en charge de l'utilisation de variables](https://github.com/delta-io/delta/issues/1267) dans les commandes SQL VACUUM et OPTIMIZE.
+ Améliorations apportées à CONVERT TO DELTA avec des tables de catalogue, notamment :
+ [Remplissez automatiquement le schéma de partition](https://github.com/delta-io/delta/commit/18d4d12ed06f973006501f6c39c8785db51e2b1f) à partir du catalogue s'il n'est pas fourni.
+ [Utilisez les informations de partition](https://github.com/delta-io/delta/commit/ebff29904f3ababb889897343f8f8f7a010a1f71) du catalogue pour rechercher les fichiers de données à valider au lieu d'effectuer une analyse complète du répertoire. Plutôt que de valider tous les fichiers de données du répertoire des tables, seuls les fichiers de données figurant dans les répertoires des partitions actives seront validés.
+ [Prise en charge de la lecture par lots du flux CDF](https://github.com/delta-io/delta/issues/1349) sur les tables permettant le mappage de colonnes lorsque DROP COLUMN et RENAME COLUMN n'ont pas été utilisés. Pour plus d'informations, consultez la [documentation de Delta Lake](https://docs.delta.io/2.1.0/delta-change-data-feed.html#known-limitations).
+ [Améliorez les performances de la commande Update](https://github.com/delta-io/delta/pull/1202) en activant le nettoyage du schéma dès le premier passage.
### Apache Iceberg
+ Ajout de plusieurs [améliorations des performances](https://iceberg.apache.org/releases/#performance-improvements) pour la planification des scans et les requêtes Spark.
+ Ajout d'un client de catalogue REST commun qui utilise des validations basées sur les modifications pour résoudre les conflits de validation côté service.
+ La syntaxe `AS OF` des requêtes SQL Time Travel est prise en charge.
+ Ajout merge-on-read du support pour les requêtes MERGE et UPDATE.
+ Ajout de la prise en charge de la réécriture des partitions à l'aide de Z-order.
+ Ajout d'une spécification et d'une implémentation pour Puffin, un format adapté aux statistiques volumineuses et aux blobs d'index, tels que les [esquisses Theta](https://datasketches.apache.org/docs/Theta/InverseEstimate.html) ou les filtres Bloom.
+ Ajout de nouvelles interfaces permettant de consommer les données par incréments (analyses des ajouts et du journal des modifications).
+ Ajout de la prise en charge des opérations en bloc et des lectures par plage sur les interfaces FileIO.
+ Ajout de tables de métadonnées supplémentaires pour afficher les fichiers supprimés dans l'arborescence des métadonnées.
+ Le comportement de suppression de la table a changé. Dans Iceberg 0.13.1, l'exécution de `DROP TABLE` supprime la table du catalogue ainsi que le contenu de la table. Dans Iceberg 1.0.0, `DROP TABLE` supprime uniquement la table du catalogue. Pour supprimer le contenu de la table, utilisez `DROP TABLE PURGE`.
+ Les lectures vectorisés Parquet sont activées par défaut dans Iceberg 1.0.0. Pour désactiver les lectures vectorisées, définissez `read.parquet.vectorization.enabled` sur `false`.
### Oracle
Les modifications sont mineures.
### MySQL
Les modifications sont mineures.
### Amazon Redshift
AWS Glue La version 4.0 intègre un nouveau connecteur Amazon Redshift avec un nouveau pilote JDBC. Pour plus d'informations sur les améliorations et sur la façon de migrer depuis AWS Glue les versions précédentes, consultez[Connexions Redshift](aws-glue-programming-etl-connect-redshift-home.md).
## Annexe A : Mises à niveau notables des dépendances
Voici les mises à niveau des dépendances :
| Dépendance | Version en AWS Glue 4.0 | Version en AWS Glue 3.0 | Version en AWS Glue 2.0 | Version en AWS Glue 1.0 |
| --- | --- | --- | --- | --- |
| Spark | 3.3.0-amzn-1 | 3.1.1-amzn-0 | 2.4.3 | 2.4.3 |
| Hadoop | 3.3.3-amzn-0 | 3.2.1-amzn-3 | 2.8.5-amzn-5 | 2.8.5-amzn-1 |
| Scala | 2,12 | 2,12 | 2.11 | 2.11 |
| Jackson | 2.13.3 | 2.10.x | 2.7.x | 2.7.x |
| Hive | 2.3.9-amzn-2 | 2.3.7-amzn-4 | 1.2 | 1.2 |
| EMRFS | 2,54,0 | 2,46,0 | 2.38.0 | 2.30.0 |
| Json4s | 3.7.0-M11 | 3.6.6 | 3.5.x | 3.5.x |
| Flèche | 7.0.0 | 2.0.0 | 0.10.0 | 0.10.0 |
| AWS Glue Client de catalogue de données | 3.7.0 | 3.0.0 | 1.10.0 | N/A |
| Python | 3,10 | 3.7 | 2.7 et 3.6 | 2.7 et 3.6 |
| Boto | 1,26 | 1,18 | 1.12 | N/A |
## Annexe B : Mises à niveau du pilote JDBC
Voici les mises à niveau du pilote JDBC :
| Pilote | Version du pilote JDBC dans les versions précédentes AWS Glue | Version du pilote JDBC en 3.0 AWS Glue | Version du pilote JDBC en 4.0 AWS Glue |
| --- | --- | --- | --- |
| MySQL | 5.1 | 8.0.23 | 8.0.23 |
| Microsoft SQL Server | 6,10 | 7.0.0 | 9.4.0 |
| Oracle Databases | 11.2 | 21,1 | 21,7 |
| PostgreSQL | 42,10 | 42,2,18 | 42,3.6 |
| MongoDB | 2.0.0 | 4.0.0 | 4.7.2 |
| Amazon Redshift | redshift-jdbc41-1.2.12.1017 | redshift-jdbc41-1.2.12.1017 | redshift-jdbc42-2.1.0.16 |
## Annexe C : Mises à niveau des connecteurs
Les mises à niveau des connecteurs sont les suivantes :
| Pilote | Version du connecteur en AWS Glue 3.0 | Version du connecteur en AWS Glue 4.0 |
| --- | --- | --- |
| MongoDB | 3.0.0 | 10,0.4 |
| Hudi | 0,1,1 | 0.12.1 |
| Delta Lake | 1.0.0 | 2.1.0 |
| Iceberg | 0.13.1 | 1.0.0 |
| DynamoDB | 1.11 | 1.12 |
# Améliorations génératives de l'IA pour Apache Spark in AWS Glue
Spark Upgrades in AWS Glue permet aux ingénieurs de données et aux développeurs de mettre à niveau et de migrer leurs tâches AWS Glue Spark existantes vers les dernières versions de Spark à l'aide de l'IA générative. Les ingénieurs de données peuvent l'utiliser pour scanner leurs tâches AWS Glue Spark, générer des plans de mise à niveau, exécuter des plans et valider les résultats. Cela permet de réduire le temps et le coût des mises à niveau de Spark en automatisant le travail indifférencié d’identification et de mise à jour des scripts, des configurations, des dépendances, des méthodes et des fonctionnalités de Spark.
![\[Le GIF montre la mise en œuvre de bout en bout d’un exemple de flux de travail d’analyse des mises à niveau.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/demo_lumos.gif)
## Comment ça marche
Lorsque vous utilisez l'analyse des mises à niveau, AWS Glue identifie les différences entre les versions et les configurations dans le code de votre tâche afin de générer un plan de mise à niveau. Le plan de mise à niveau détaille toutes les modifications du code et les étapes de migration requises. Ensuite, AWS Glue crée et exécute l'application mise à niveau dans un environnement pour valider les modifications et génère une liste de modifications de code afin que vous puissiez migrer votre travail. Vous pouvez consulter le script mis à jour, ainsi que le résumé détaillant les modifications proposées. Après avoir effectué vos propres tests, acceptez les modifications et le job AWS Glue sera automatiquement mis à jour vers la dernière version avec le nouveau script.
Le processus d’analyse de la mise à niveau peut prendre un certain temps, selon la complexité de la tâche et la charge de travail. Les résultats de l’analyse de la mise à niveau seront stockés dans le chemin Amazon S3 spécifié, qui pourra être consulté pour comprendre la mise à niveau et les éventuels problèmes de compatibilité. Après avoir examiné les résultats de l’analyse de la mise à niveau, vous pouvez décider de poursuivre la mise à niveau proprement dite ou d’apporter les modifications nécessaires à la tâche avant sa mise à niveau.
## Conditions préalables
Les prérequis suivants sont requis pour utiliser l'IA générative afin de mettre à niveau les jobs dans AWS Glue :
+ AWS Tâches Glue 2 PySpark : seules les tâches AWS Glue 2 peuvent être mises à niveau vers AWS Glue 5.
+ Les autorisations IAM sont nécessaires pour démarrer l’analyse, examiner les résultats et améliorer votre tâche. Pour plus d’informations, consultez les exemples dans la section [Permissions](#auto-upgrade-permissions) ci-dessous.
+ Si vous l'utilisez AWS KMS pour chiffrer des artefacts d'analyse, des AWS AWS KMS autorisations supplémentaires sont nécessaires. Pour plus d’informations, consultez les exemples dans la section [AWS KMS politique](#auto-upgrade-kms-policy) ci-dessous.
### Permissions
#### Pour démarrer une nouvelle analyse de la mise à niveau, vous devez disposer des autorisations suivantes :
1. Mettez à jour la politique IAM de l’appelant avec l’autorisation suivante :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:StartJobUpgradeAnalysis",
"glue:StartJobRun",
"glue:GetJobRun",
"glue:GetJob",
"glue:BatchStopJobRun"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:job/jobName"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/script-location/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/results/*"
]
},
{
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey"
],
"Resource": "arn:aws:kms:us-east-1:111122223333:key/key-id"
}
]
}
```
------
1. Mettez à jour le rôle d’exécution de la tâche que vous mettez à niveau pour inclure la politique en ligne suivante :
```
{
"Effect": "Allow",
"Action": ["s3:GetObject"],
"Resource": [
"ARN of the Amazon S3 path provided on API",
"ARN of the Amazon S3 path provided on API/*"
]
}
```
Par exemple, si vous utilisez le chemin d’accès à Amazon S3 `s3://amzn-s3-demo-bucket/upgraded-result`, la politique sera la suivante :
```
{
"Effect": "Allow",
"Action": ["s3:GetObject"],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/upgraded-result/",
"arn:aws:s3:::amzn-s3-demo-bucket/upgraded-result/*"
]
}
```
#### Pour récupérer les détails d’une analyse, vous devez disposer des autorisations suivantes :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetJobUpgradeAnalysis"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:job/jobName"
]
}
]
}
```
------
#### Pour arrêter une analyse en cours, vous devez disposer des autorisations suivantes :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:StopJobUpgradeAnalysis",
"glue:BatchStopJobRun"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:job/jobName"
]
}
]
}
```
------
#### Pour répertorier toutes les analyses soumises dans le cadre d’une tâche spécifique, vous devez disposer des autorisations suivantes :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:ListJobUpgradeAnalyses"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:job/jobName"
]
}
]
}
```
------
#### Pour accepter les modifications d’une analyse et mettre à niveau une tâche, vous devez disposer des autorisations suivantes :
### AWS KMS politique
Pour transmettre votre propre AWS KMS clé personnalisée lors du démarrage d'une analyse, reportez-vous à la section suivante pour configurer les autorisations appropriées sur les AWS KMS clés.
#### Configuration du chiffrement des artefacts obtenus à l'aide d'une AWS KMS clé :
Cette politique garantit que vous disposez à la fois des autorisations de chiffrement et de déchiffrement sur la AWS KMS clé.
```
{
"Effect": "Allow",
"Principal":{
"AWS": ""
},
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey",
],
"Resource": ""
}
```
## Exécution d’une analyse de la mise à niveau et application du script de mise à niveau
Vous pouvez exécuter une analyse de la mise à niveau, qui générera un plan de mise à niveau pour une tâche que vous sélectionnez dans la vue **Tâches**.
1. Dans **Jobs**, sélectionnez une tâche AWS Glue 2.0, puis choisissez **Run upgrade analysis** dans le menu **Actions**.
![\[La capture d’écran montre l’analyse de la mise à niveau avec l’IA depuis le menu d’action.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/upgrade-analysis-run-action-menu.png)
1. Dans la fenêtre modale, sélectionnez un chemin d’accès pour stocker votre plan de mise à niveau généré dans le **chemin d’accès aux résultats**. Il doit s’agir d’un compartiment Amazon S3 auquel vous pouvez accéder et sur lequel vous pouvez écrire.
![\[La capture d’écran montre l’analyse de la mise à niveau terminée. Le bouton Appliquer le script mis à niveau est visible.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/upgrade-analysis-configuration-options.png)
1. Configurez les options supplémentaires au besoin :
+ **Configuration d’exécution** (facultative) : la configuration d’exécution est un paramètre facultatif qui vous permet de personnaliser divers aspects des cycles de validation effectués lors de l’analyse de la mise à niveau. Cette configuration est utilisée pour exécuter le script mis à niveau et vous permet de sélectionner les propriétés de l’environnement de calcul (type de travailleur, nombre de travailleurs, etc.). Notez que vous devez utiliser vos comptes de développeur hors production pour exécuter les validations sur des exemples de jeux de données avant de vérifier, d’accepter les modifications et de les appliquer aux environnements de production. La configuration d’exécution comprend les paramètres personnalisables suivants :
+ Type de travailleur : vous pouvez spécifier le type de travailleur à utiliser pour les cycles de validation, ce qui vous permet de choisir les ressources de calcul appropriées en fonction de vos besoins.
+ Nombre de travailleurs : vous pouvez définir le nombre de travailleurs à affecter pour les cycles de validation, ce qui vous permet de mettre à l’échelle les ressources en fonction de vos besoins en matière de charge de travail.
+ Délai d’expiration des tâches (en minutes) : ce paramètre vous permet de définir une limite de temps pour les cycles de validation, en veillant à ce que les tâches se terminent après une durée spécifiée afin d’éviter une consommation excessive de ressources.
+ Configuration de la sécurité : vous pouvez configurer les paramètres de sécurité, tels que le chiffrement et le contrôle d’accès, pour garantir la protection de vos données et de vos ressources pendant les cycles de validation.
+ Paramètres de tâche supplémentaires : si nécessaire, vous pouvez ajouter de nouveaux paramètres de tâche afin de personnaliser davantage l’environnement d’exécution pour les cycles de validation.
En tirant parti de la configuration d’exécution, vous pouvez adapter les cycles de validation à vos besoins spécifiques. Par exemple, vous pouvez configurer les cycles de validation pour qu’ils utilisent un jeu de données plus petit, ce qui permet d’effectuer l’analyse plus rapidement et d’optimiser les coûts. Cette approche garantit que l’analyse de la mise à niveau est effectuée efficacement tout en minimisant l’utilisation des ressources et les coûts associés pendant la phase de validation.
+ **Configuration du chiffrement** (facultatif) :
+ **Activer le chiffrement des artefacts de mise à niveau** : activez le chiffrement au repos lorsque vous écrivez des données dans le chemin des résultats. Si vous ne souhaitez pas chiffrer vos artefacts de mise à niveau, laissez cette option désactivée.
1. Choisissez **Exécuter** pour démarrer l’analyse de la mise à niveau. Pendant que l’analyse est en cours, vous pouvez consulter les résultats dans l’onglet **Analyse de la mise à niveau**. La fenêtre des détails de l’analyse affiche des informations sur l’analyse, ainsi que des liens vers les artefacts de mise à niveau.
+ **Chemin d’accès au résultat** : c’est à cet endroit que le résumé des résultats et le script de mise à niveau sont stockés.
+ **Script mis à niveau dans Amazon S3** : emplacement du script de mise à niveau dans Amazon S3. Vous pouvez afficher le script avant d’appliquer la mise à niveau.
+ **Résumé de la mise à niveau dans Amazon S3** : l’emplacement du résumé de la mise à niveau dans Amazon S3. Vous pouvez consulter le résumé de la mise à niveau avant d’appliquer cette dernière.
1. Lorsque l’analyse de la mise à niveau se termine correctement, vous pouvez appliquer le script de mise à niveau pour mettre automatiquement à niveau votre tâche en choisissant **Appliquer le script mis à niveau**.
Une fois appliquée, la version AWS Glue sera mise à jour vers la version 4.0. Vous pouvez consulter le nouveau script dans l’onglet **Script**.
![\[La capture d’écran montre l’analyse de la mise à niveau terminée. Le bouton Appliquer le script mis à niveau est visible.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/upgrade-analysis-analysis-details-preview.png)
## Comprendre le résumé de votre mise à niveau
Cet exemple illustre le processus de mise à niveau d'une tâche AWS Glue de la version 2.0 à la version 4.0. L’exemple de tâche lit les données du produit depuis un compartiment Amazon S3, applique plusieurs transformations aux données à l’aide de Spark SQL, puis enregistre les résultats transformés dans un compartiment Amazon S3.
### Code original (AWS Glue 2.0) - avant la mise à niveau
```
from awsglue.transforms import *
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from pyspark.sql.types import *
from pyspark.sql.functions import *
from awsglue.job import Job
import json
from pyspark.sql.types import StructType
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
gdc_database = "s3://aws-glue-scripts-us-east-1-gamma/demo-database/"
schema_location = (
"s3://aws-glue-scripts-us-east-1-gamma/DataFiles/"
)
products_schema_string = spark.read.text(
f"{schema_location}schemas/products_schema"
).first()[0]
product_schema = StructType.fromJson(json.loads(products_schema_string))
products_source_df = (
spark.read.option("header", "true")
.schema(product_schema)
.option(
"path",
f"{gdc_database}products/",
)
.csv(f"{gdc_database}products/")
)
products_source_df.show()
products_temp_view_name = "spark_upgrade_demo_product_view"
products_source_df.createOrReplaceTempView(products_temp_view_name)
query = f"select {products_temp_view_name}.*, format_string('%0$s-%0$s', category, subcategory) as unique_category from {products_temp_view_name}"
products_with_combination_df = spark.sql(query)
products_with_combination_df.show()
products_with_combination_df.createOrReplaceTempView(products_temp_view_name)
product_df_attribution = spark.sql(
f"""
SELECT *,
unbase64(split(product_name, ' ')[0]) as product_name_decoded,
unbase64(split(unique_category, '-')[1]) as subcategory_decoded
FROM {products_temp_view_name}
"""
)
product_df_attribution.show()
product_df_attribution.write.mode("overwrite").option("header", "true").option(
"path", f"{gdc_database}spark_upgrade_demo_product_agg/"
).saveAsTable("spark_upgrade_demo_product_agg", external=True)
spark_upgrade_demo_product_agg_table_df = spark.sql(
f"SHOW TABLE EXTENDED in default like 'spark_upgrade_demo_product_agg'"
)
spark_upgrade_demo_product_agg_table_df.show()
job.commit()
```
### Nouveau code (Glue 4.0) : après la mise à niveau
```
from awsglue.transforms import *
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from pyspark.sql.types import *
from pyspark.sql.functions import *
from awsglue.job import Job
import json
from pyspark.sql.types import StructType
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
# change 1
spark.conf.set("spark.sql.adaptive.enabled", "false")
# change 2
spark.conf.set("spark.sql.legacy.pathOptionBehavior.enabled", "true")
job = Job(glueContext)
gdc_database = "s3://aws-glue-scripts-us-east-1-gamma/demo-database/"
schema_location = (
"s3://aws-glue-scripts-us-east-1-gamma/DataFiles/"
)
products_schema_string = spark.read.text(
f"{schema_location}schemas/products_schema"
).first()[0]
product_schema = StructType.fromJson(json.loads(products_schema_string))
products_source_df = (
spark.read.option("header", "true")
.schema(product_schema)
.option(
"path",
f"{gdc_database}products/",
)
.csv(f"{gdc_database}products/")
)
products_source_df.show()
products_temp_view_name = "spark_upgrade_demo_product_view"
products_source_df.createOrReplaceTempView(products_temp_view_name)
# change 3
query = f"select {products_temp_view_name}.*, format_string('%1$s-%1$s', category, subcategory) as unique_category from {products_temp_view_name}"
products_with_combination_df = spark.sql(query)
products_with_combination_df.show()
products_with_combination_df.createOrReplaceTempView(products_temp_view_name)
# change 4
product_df_attribution = spark.sql(
f"""
SELECT *,
try_to_binary(split(product_name, ' ')[0], 'base64') as product_name_decoded,
try_to_binary(split(unique_category, '-')[1], 'base64') as subcategory_decoded
FROM {products_temp_view_name}
"""
)
product_df_attribution.show()
product_df_attribution.write.mode("overwrite").option("header", "true").option(
"path", f"{gdc_database}spark_upgrade_demo_product_agg/"
).saveAsTable("spark_upgrade_demo_product_agg", external=True)
spark_upgrade_demo_product_agg_table_df = spark.sql(
f"SHOW TABLE EXTENDED in default like 'spark_upgrade_demo_product_agg'"
)
spark_upgrade_demo_product_agg_table_df.show()
job.commit()
```
### Explication du résumé de l’analyse
![\[La capture d’écran montre le résumé de l’analyse de la mise à niveau.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/upgrade-analysis-explanation-summary.png)
Sur la base du résumé, quatre modifications ont été proposées par AWS Glue afin de réussir la mise à niveau du script de AWS Glue 2.0 vers AWS Glue 4.0 :
1. **Configuration de Spark SQL (spark.sql.adaptive.enabled)** : cette modification vise à restaurer le comportement de l’application, car une nouvelle fonctionnalité d’exécution de requêtes adaptatives Spark SQL est introduite à partir de Spark 3.2. Vous pouvez inspecter cette modification de configuration et l’activer ou la désactiver selon les préférences.
1. **DataFrame Modification de l'API** : l'option path ne peut pas coexister avec d'autres DataFrameReader opérations telles que`load()`. Pour conserver le comportement précédent, AWS Glue a mis à jour le script pour ajouter une nouvelle configuration SQL **(spark.sql.legacy). pathOptionBehavior.activé).**
1. **Modification de l’API Spark SQL** : le comportement de `strfmt` dans `format_string(strfmt, obj, ...)` a été mis à jour pour interdire `0$` comme premier argument. Pour garantir la compatibilité, AWS Glue a modifié le script pour l'utiliser `1$` comme premier argument à la place.
1. **Modification de l’API Spark SQL** : la fonction `unbase64` n’autorise pas les entrées de chaîne mal formées. Pour conserver le comportement précédent, AWS Glue a mis à jour le script afin d'utiliser la `try_to_binary` fonction.
## Arrêt d’une analyse de la mise à niveau en cours
Vous pouvez annuler une analyse de la mise à niveau en cours ou simplement arrêter l’analyse.
1. Choisissez l’onglet **Analyse de la mise à niveau**.
1. Sélectionnez la tâche en cours d’exécution, puis choisissez **Arrêter**. Cela arrêtera l’analyse. Vous pouvez ensuite exécuter une autre analyse de la mise à niveau sur la même tâche.
![\[La capture d’écran montre l’onglet Analyse de la mise à niveau avec une tâche sélectionnée. La tâche est toujours en cours d’exécution.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/upgrade-analysis-tab.png)
## Considérations
Lorsque vous commencez à utiliser Spark Upgrades, vous devez prendre en compte plusieurs aspects importants pour une utilisation optimale du service.
+ **Étendue et limites du service** : La version actuelle se concentre sur les mises à niveau du PySpark code depuis les versions 2.0 de AWS Glue vers la version 5.0. À l'heure actuelle, le service gère le PySpark code qui ne repose pas sur des dépendances de bibliothèque supplémentaires. Vous pouvez exécuter des mises à niveau automatisées pour un maximum de 10 tâches simultanément dans un AWS compte, ce qui vous permet de mettre à niveau efficacement plusieurs tâches tout en préservant la stabilité du système.
+ Seuls les PySpark emplois sont pris en charge.
+ L’analyse de la mise à niveau expirera au bout de 24 heures.
+ Une seule analyse de la mise à niveau active peut être exécutée à la fois pour une tâche. Au niveau du compte, vous pouvez exécuter jusqu’à 10 analyses de la mise à niveau en même temps.
+ **Optimisation des coûts pendant le processus de mise à** niveau : étant donné que Spark Upgrades utilise l'IA générative pour valider le plan de mise à niveau par le biais de plusieurs itérations, chaque itération étant exécutée sous forme de tâche AWS Glue dans votre compte, il est essentiel d'optimiser les configurations d'exécution des tâches de validation pour des raisons de rentabilité. Pour ce faire, nous vous recommandons de spécifier une configuration d’exécution lors du lancement d’une analyse de la mise à niveau, comme suit :
+ Utilisez des comptes de développeur hors production et sélectionnez des exemples de jeux de données fictifs qui représentent vos données de production, mais dont la taille est réduite pour la validation avec Spark Upgrades.
+ Utilisez des ressources de calcul correctement dimensionnées, telles que des travailleurs G1X, et sélectionnez un nombre approprié de travailleurs pour traiter vos échantillons de données.
+ Activation de l'auto-scaling des tâches AWS Glue, le cas échéant, pour ajuster automatiquement les ressources en fonction de la charge de travail.
Par exemple, si votre tâche de production traite des téraoctets de données avec 20 travailleurs G.2X, vous pouvez configurer la tâche de mise à niveau pour traiter quelques gigaoctets de données représentatives avec 2 travailleurs G.2X et l’autoscaling activé pour la validation.
+ **Bonnes pratiques** : nous vous recommandons vivement de commencer votre processus de mise à niveau par des tâches non liées à la production. Cette approche vous permet de vous familiariser avec le flux de travail de mise à niveau et de comprendre comment le service gère les différents types de modèles de code Spark.
+ **Alarmes et notifications** : lorsque vous utilisez la fonction de mise à niveau de l'IA générative sur une tâche, assurez-vous qu' alarms/notifications elle est désactivée en cas d'échec des tâches. Au cours du processus de mise à niveau, il se peut que jusqu’à 10 tâches aient échoué dans votre compte avant que les artefacts mis à niveau ne soient fournis.
+ **Règles de détection des anomalies** : désactivez également les règles de détection des anomalies sur la tâche en cours de mise à niveau, car les données écrites dans les dossiers de sortie lors des exécutions de tâches intermédiaires risquent de ne pas être au format attendu pendant la validation de la mise à niveau.
+ **Utiliser l’analyse de la mise à niveau avec les tâches idempotentes** : utilisez l’analyse de la mise à niveau avec les tâches idempotentes pour vous assurer que chaque tentative d’exécution de tâche de validation suivante est similaire à la précédente et ne présente aucun problème. Les tâches idempotentes sont des tâches qui peuvent être exécutées plusieurs fois avec les mêmes données d’entrée et qui produiront à chaque fois le même résultat. Lorsque vous utilisez les mises à niveau de Generative AI pour Apache Spark in AWS Glue, le service exécutera plusieurs itérations de votre tâche dans le cadre du processus de validation. Au cours de chaque itération, il apportera des modifications à votre code et à vos configurations Spark afin de valider le plan de mise à niveau. Si votre tâche Spark n’est pas idempotente, l’exécuter plusieurs fois avec les mêmes données d’entrée peut entraîner des problèmes.
## Régions prises en charge
Les mises à niveau génératives de l'IA pour Apache Spark sont disponibles dans les régions suivantes :
+ **Asie-Pacifique** : Tokyo (ap-northeast-1), Séoul (ap-northeast-2), Mumbai (ap-southeast-1), Singapour (ap-southeast-1) et Sydney (ap-southeast-2)
+ **Amérique du** Nord : Canada (ca-central-1)
+ **Europe** : Francfort (eu-central-1), Stockholm (eu-nord-1), Irlande (eu-west-1), Londres (eu-west-2) et Paris (eu-west-3)
+ **Amérique du Sud** : São Paulo (sa-east-1)
+ **États-Unis** : Virginie du Nord (us-east-1), Ohio (us-east-2) et Oregon (us-west-2)
## Inférence entre régions dans Spark Upgrades
Spark Upgrades est alimenté par Amazon Bedrock et exploite l'inférence interrégionale (CRIS). Grâce à l’inférence entre régions, Spark Upgrades sélectionne automatiquement la région optimale au sein de votre zone géographique (comme décrit plus en détail [ici](https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html)) pour traiter votre demande d’inférence, optimisant ainsi les ressources de calcul disponibles et la disponibilité des modèles, et offrant la meilleure expérience client. L’utilisation de l’inférence entre régions n’entraîne aucun coût supplémentaire.
Les demandes d'inférence interrégionales sont conservées dans les AWS régions qui font partie de la zone géographique dans laquelle les données se trouvent à l'origine. Par exemple, une demande faite aux États-Unis est conservée dans les AWS régions des États-Unis. Bien que les données restent stockées uniquement dans la région principale, lorsque vous utilisez l’inférence entre régions, vos invites de saisie et les résultats de sortie peuvent être déplacés en dehors de votre région principale. Toutes les données seront transmises chiffrées sur le réseau sécurisé d’Amazon.
# Utilisation des jobs Spark dans AWS Glue
Fournit des informations sur AWS Glue les tâches ETL de Spark.
**Topics**
+ [Utilisation des paramètres des tâches dans les tâches AWS Glue](aws-glue-programming-etl-glue-arguments.md)
+ [AWS Glue Spark et PySpark jobs](spark_and_pyspark.md)
+ [AWS Glue types de travailleurs](worker-types.md)
+ [Tâches ETL en streaming dans AWS Glue](add-job-streaming.md)
+ [Record correspondant à AWS Lake Formation FindMatches](machine-learning.md)
+ [Migrer les programmes Apache Spark vers AWS Glue](glue-author-migrate-apache-spark.md)
# Utilisation des paramètres des tâches dans les tâches AWS Glue
Lorsque vous créez une tâche AWS Glue, vous définissez des champs standard, tels que `Role` et`WorkerType`. Vous pouvez fournir des informations de configuration supplémentaires par le biais des champs `Argument` (**Paramètres de la tâche** dans la console). Dans ces champs, vous pouvez fournir aux tâches AWS Glue les arguments (paramètres) répertoriés dans cette rubrique.
Pour plus d'informations sur l'API AWS Glue Job, consultez[Tâches](aws-glue-api-jobs-job.md).
**Note**
La taille maximale des arguments de tâche est de 260 Ko. Une vérification de validation génère une erreur si la taille de l’argument est supérieure à 260 Ko.
## Configuration des paramètres de tâche
Vous pouvez configurer une tâche via la console, dans les **Détails de la tâche**, sous l'en-tête **Paramètres des tâches**. Vous pouvez également configurer une tâche via le paramètre « AWS CLI en configurant » `DefaultArguments` ou `NonOverridableArguments` sur une tâche, ou en configurant `Arguments` l'exécution d'une tâche. Les arguments définis pour la tâche seront transmis à chaque exécution de la tâche, tandis que les arguments définis lors de l'exécution de la tâche ne seront transmis que pour cette exécution individuelle.
Par exemple, ce qui suit est la syntaxe pour exécuter une tâche en utilisant `--arguments` pour définir un paramètre de tâche.
```
$ aws glue start-job-run --job-name "CSV to CSV" --arguments='--scriptLocation="s3://my_glue/libraries/test_lib.py"'
```
## Accès aux paramètres des tâches
Lorsque vous écrivez des scripts AWS Glue, vous souhaiterez peut-être accéder aux valeurs des paramètres des tâches afin de modifier le comportement de votre propre code. Nous fournissons des méthodes d'aide pour ce faire dans nos bibliothèques. Ces méthodes résolvent les valeurs des paramètres d'exécution des tâches qui remplacent les valeurs des paramètres des tâches. Lors de la résolution de paramètres définis à plusieurs emplacements, la tâche `NonOverridableArguments` remplacera les `Arguments` de l'exécution de la tâche, qui remplacera les `DefaultArguments` de la tâche.
**Dans Python :**
Dans les tâches Python, nous fournissons une fonction nommée `getResolvedParameters`. Pour de plus amples informations, veuillez consulter [Accès aux paramètres à l'aide de `getResolvedOptions`](aws-glue-api-crawler-pyspark-extensions-get-resolved-options.md). Les paramètres de la tâche sont disponibles dans la variable `sys.argv`.
**Dans Scala :**
Dans les tâches Scala, nous fournissons un objet nommé `GlueArgParser`. Pour de plus amples informations, veuillez consulter [AWS GlueScala GlueArgParser APIs](glue-etl-scala-apis-glue-util-glueargparser.md). Les paramètres de la tâche sont disponibles dans la variable `sysArgs`.
## Référence des paramètres de la tâche
**AWS Glue reconnaît les noms d'arguments suivants que vous pouvez utiliser pour configurer l'environnement de script pour vos tâches et leurs exécutions :**
**`--additional-python-modules`**
une liste délimitée par des virgules représentant un ensemble de packages Python à installer. Vous pouvez installer des packages depuis PyPI ou fournir une distribution personnalisée. Une entrée de package PyPI sera au format `package==version`, avec le nom PyPI et la version de votre package cible. Une entrée de distribution personnalisée est le chemin S3 vers la distribution.
Les entrées utilisent la correspondance entre versions de Python pour faire correspondre le package et la version. Cela signifie que vous devrez utiliser deux signes d'égalité, comme `==`. Il existe d'autres opérateurs de correspondance de version. Pour plus d'informations, voir [PEP 440](https://peps.python.org/pep-0440/#version-matching).
Pour transmettre les options d'installation du module à `pip3`, utilisez le paramètre [--python-modules-installer-option](#python-modules-installer-option).
**`--auto-scale-within-microbatch`**
La valeur par défaut est True. Ce paramètre ne peut être utilisé que pour les tâches de streaming AWS Glue, qui traitent les données de streaming en une série de microlots, et le dimensionnement automatique doit être activé. Lorsque cette valeur est définie sur false, il calcule la moyenne mobile exponentielle de la durée du lot pour les microlots terminés et compare cette valeur à la taille de la fenêtre pour déterminer s'il convient d'augmenter ou de réduire le nombre d'exécuteurs. La mise à l'échelle ne se produit que lorsqu'un microlot est terminé. Lorsque cette valeur est définie sur true, lors d'un microlot, elle augmente lorsque le nombre de tâches Spark reste le même pendant 30 secondes ou que le traitement par lots en cours est supérieur à la taille de la fenêtre. Le nombre d'exécuteurs diminuera si un exécuteur est inactif depuis plus de 60 secondes ou si la moyenne mobile exponentielle de la durée du lot est faible.
**`--class`**
La classe Scala qui sert de point d'entrée à votre script Scala. Cela s'applique uniquement si votre `--job-language` est défini sur `scala`.
**`--continuous-log-conversionPattern`**
Spécifie un modèle de journal de conversion personnalisé pour une tâche activée pour la journalisation en continu. 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 de AWS Glue.
**`--continuous-log-logGroup`**
Spécifie un nom de groupe de CloudWatch journaux Amazon personnalisé pour une tâche activée pour la journalisation continue.
**`--continuous-log-logStreamPrefix`**
Spécifie un préfixe de flux de CloudWatch journal personnalisé pour une tâche activée pour la journalisation continue.
**`--customer-driver-env-vars` et `--customer-executor-env-vars`**
Ces paramètres définissent des variables d’environnement sur le système d’exploitation respectivement pour chaque travailleur (pilote ou exécuteur). Vous pouvez utiliser ces paramètres lorsque vous créez des plateformes et des frameworks personnalisés sur AWS Glue, afin de permettre à vos utilisateurs d'écrire des jobs dessus. L’activation de ces deux indicateurs vous permettra de définir des variables d’environnement différentes sur le pilote et sur l’exécuteur, respectivement, sans avoir à injecter la même logique dans le script de tâche lui-même.
**Exemple d’utilisation**
Voici un exemple de l’utilisation de ces paramètres :
```
"—customer-driver-env-vars", "CUSTOMER_KEY1=VAL1,CUSTOMER_KEY2=\"val2,val2 val2\"",
"—customer-executor-env-vars", "CUSTOMER_KEY3=VAL3,KEY4=VAL4"
```
Les définir dans l’argument d’exécution de tâche revient à exécuter les commandes suivantes :
Dans le pilote :
+ exporter CUSTOMER\$1 = KEY1 VAL1
+ export CUSTOMER\$1 KEY2 ="val2, val2 val2"
Dans l’exécuteur :
+ exporter CUSTOMER\$1 = KEY3 VAL3
Ensuite, dans le script de tâche lui-même, vous pouvez récupérer les variables d’environnement à l’aide de `os.environ.get("CUSTOMER_KEY1")` ou de `System.getenv("CUSTOMER_KEY1")`.
**Syntaxe appliquée**
Respectez les normes suivantes lors de la définition des variables d’environnement :
+ Chaque clé doit avoir le `CUSTOMER_ prefix`.
Par exemple : pour `"CUSTOMER_KEY3=VAL3,KEY4=VAL4"`, `KEY4=VAL4` sera ignoré et ne sera pas défini.
+ Chaque paire clé/valeur doit être délimitée par une simple virgule.
Par exemple : `"CUSTOMER_KEY3=VAL3,CUSTOMER_KEY4=VAL4"`
+ Si la « valeur » comporte des espaces ou des virgules, elle doit être définie entre guillemets.
Par exemple : `CUSTOMER_KEY2=\"val2,val2 val2\"`
Cette syntaxe modélise étroitement les normes de définition des variables d’environnement bash.
**`--datalake-formats` **
Pris en charge dans AWS Glue 3.0 et versions ultérieures.
Spécifie la structure du lac de données à utiliser. AWS Glue ajoute les fichiers JAR requis pour les frameworks que vous spécifiez dans le`classpath`. Pour de plus amples informations, veuillez consulter [Utilisation de frameworks de lacs de données avec des tâches AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
Vous pouvez spécifier une ou plusieurs des valeurs suivantes, séparées par une virgule :
+ `hudi`
+ `delta`
+ `iceberg`
Par exemple, transmettez l'argument suivant pour spécifier les trois infrastructures.
```
'--datalake-formats': 'hudi,delta,iceberg'
```
**`--disable-proxy-v2`**
Désactivez le proxy de AWS service pour autoriser les appels de service vers Amazon S3 et AWS Glue provenant de votre script via votre VPC. CloudWatch Pour plus d'informations, consultez [Configurer AWS les appels pour qu'ils passent par votre VPC](https://docs.aws.amazon.com/glue/latest/dg/connection-VPC-disable-proxy.html). Pour désactiver le proxy de service, définissez la valeur de ce paramètre sur `true`.
**`--enable-auto-scaling`**
Lorsque cette valeur est paramétrée sur `true`, active la mise à l'échelle automatique ainsi que la facturation par employé.
**`--enable-continuous-cloudwatch-log`**
Permet la journalisation continue en temps réel des tâches AWS Glue. Vous pouvez afficher les journaux de tâches Apache Spark en temps réel dans CloudWatch.
**`--enable-continuous-log-filter`**
Spécifie un filtre standard (`true`) ou aucun filtre (`false`) lorsque vous créez ou modifiez une tâche activée pour la journalisation continue. Le choix du filtre standard élimine les messages inutiles du journal des battements de cœur d'Apache Spark driver/executor et d'Apache Hadoop YARN. Ne choisir aucun filtre vous donne tous les messages de journaux.
**`--enable-glue-datacatalog`**
Vous permet d'utiliser le catalogue de données AWS Glue comme métastore Apache Spark Hive. Pour activer cette fonctionnalité, définissez la valeur sur `true`.
**`--enable-job-insights`**
Permet une surveillance supplémentaire de l'analyse des erreurs grâce à AWS Glue Job Run Insights. Pour en savoir plus, consultez [Surveillance à l'aide AWS Glue d'informations sur l'exécution des tâches](monitor-job-insights.md). Par défaut, cette valeur est définie sur `true` et les informations sur l'exécution des tâches sont activées.
Cette option est disponible pour les versions 2.0 et 3.0 de AWS Glue.
**`--enable-lakeformation-fine-grained-access`**
Permet un contrôle d'accès précis pour les tâches AWS Glue. Pour de plus amples informations, veuillez consulter [Utiliser AWS Glue with AWS Lake Formation pour un contrôle d'accès précis](security-lf-enable.md).
**`--enable-metrics`**
Permet de collecter des métriques de profilage de tâche pour l'exécution de cette tâche. Ces statistiques sont disponibles sur les consoles AWS Glue et Amazon CloudWatch . La valeur de ce paramètre n'est pas pertinente. Pour activer cette fonctionnalité, vous pouvez attribuer à ce paramètre n'importe quelle valeur, mais la valeur `true` est recommandée pour des raisons de clarté. Pour désactiver cette fonctionnalité, supprimez ce paramètre de la configuration de votre tâche.
**`--enable-observability-metrics`**
Active un ensemble de mesures d'observabilité pour générer des informations sur ce qui se passe dans chaque tâche exécutée sur la page Job Runs Monitoring sous AWS la console Glue et la Amazon CloudWatch console. Pour activer cette fonctionnalité, définissez la valeur de ce paramètre sur « true ». Pour désactiver cette fonctionnalité, définissez-la sur `false` ou supprimez ce paramètre de la configuration de votre tâche.
**`--enable-rename-algorithm-v2`**
Définit la version de l'algorithme de renommage EMRFS sur la version 2. Lorsqu'une tâche Spark utilise le mode d'écrasement de partition dynamique, il est possible qu'une partition en double soit créée. Par exemple, vous pouvez vous retrouver avec une partition dupliquée telle que `s3://bucket/table/location/p1=1/p1=1`. Ici, P1 est la partition en cours de remplacement. Renommer l'algorithme en version 2 résout ce problème.
Cette option n'est disponible que sur la version 1.0 de AWS Glue.
**`--enable-s3-parquet-optimized-committer`**
Active le validateur EMRFS optimisé pour S3 pour l'écriture de données Parquet dans Amazon S3. Vous pouvez fournir la parameter/value paire via la console AWS Glue lors de la création ou de la mise à jour d'une tâche AWS Glue. Définir la valeur sur **true** active le validateur. Par défaut, le drapeau est activé dans AWS Glue 3.0 et désactivé dans AWS Glue 2.0.
Pour de plus amples informations, veuillez consulter [Utilisation du validateur EMRFS optimisé pour S3](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-spark-s3-optimized-committer.html).
**`--enable-spark-ui`**
Lorsque ce paramètre est défini sur`true`, active la fonctionnalité permettant d'utiliser l'interface utilisateur de Spark pour surveiller et déboguer les tâches AWS Glue ETL.
**`--executor-cores`**
Nombre de tâches Spark pouvant être exécutées en parallèle. Cette option est prise en charge sur AWS Glue 3.0\$1. La valeur ne doit pas dépasser le double du nombre de v CPUs sur le type de travailleur, qui est 8 activé `G.1X``G.2X`, 16 activé`G.4X`, 32 activé`G.8X`, 64 activé`G.12X`, 96 activé`G.16X`, 128 activé et 8 activé`R.1X`, 16 activé`R.2X`, 32 activé`R.4X`, 64 activé`R.8X`. Vous devez faire preuve de prudence lors de la mise à jour de cette configuration, car cela peut avoir un impact sur les performances des tâches. En effet, l'augmentation du parallélisme des tâches entraîne une surcharge de la mémoire et des disques, ainsi qu'un ralentissement des systèmes source et cible (par exemple : cela entraînerait davantage de connexions simultanées sur Amazon RDS).
**`--extra-files`**
Chemins Amazon S3 vers des fichiers supplémentaires (par exemple, des fichiers de configuration) que AWS Glue copie vers le répertoire de travail de votre script sur le nœud du pilote avant de l’exécuter. Plusieurs valeurs doivent être des chemins entiers séparés par une virgule (`,`). La valeur peut être un fichier individuel ou des emplacements de répertoire. Cette option n'est pas prise en charge pour les types de tâches shell Python.
**`--extra-jars`**
Les chemins Amazon S3 mènent à des fichiers supplémentaires que AWS Glue copie vers le pilote et les exécuteurs. AWS Glue ajoute également ces fichiers au chemin de classe Java avant d'exécuter votre script. Plusieurs valeurs doivent être des chemins entiers séparés par une virgule (`,`). Il n’est pas nécessaire que l’extension soit `.jar`.
**`--extra-py-files`**
Les chemins Amazon S3 vers des modules Python supplémentaires que AWS Glue ajoute au chemin Python sur le nœud pilote avant d'exécuter votre script. Plusieurs valeurs doivent être des chemins entiers séparés par une virgule (`,`). Seuls les fichiers individuels sont pris en charge, et non un chemin de répertoire.
**`--job-bookmark-option`**
Contrôle le comportement d'un signet de tâche. Les valeurs d'option suivantes peuvent être définies.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html)
Par exemple, pour activer un marque-page de tâche, transmettez l'argument suivant :
```
'--job-bookmark-option': 'job-bookmark-enable'
```
**`--job-language`**
Langage de programmation des scripts. Cette valeur doit être `scala` ou `python`. Si le paramètre n'est pas présent, la valeur par défaut est `python`.
**`--python-modules-installer-option`**
Une chaîne de texte simple qui définit les options à transmettre à `pip3` lors de l'installation de modules avec [--additional-python-modules](#additional-python-modules). Fournissez des options comme vous le feriez dans la ligne de commande, séparées par des espaces et préfixées par des tirets. Pour plus d'informations sur l'utilisation, consultez [Installation de modules Python supplémentaires avec pip dans AWS Glue 2.0 ou version ultérieure](aws-glue-programming-python-libraries.md#addl-python-modules-support).
Cette option n'est pas prise en charge pour les tâches AWS Glue lorsque vous utilisez Python 3.9.
**`--scriptLocation`**
Emplacement Amazon Simple Storage Service (Amazon S3) dans lequel votre script ETL est situé (sous la forme `s3://path/to/my/script.py`). Ce paramètre remplace celui du script défini dans l'objet `JobCommand`.
**`--spark-event-logs-path`**
Spécifie un chemin d'accès Amazon S3. Lors de l'utilisation de la fonction de surveillance de l'interface utilisateur Spark, AWS Glue vide les journaux d'événements Spark vers ce chemin Amazon S3 toutes les 30 secondes dans un compartiment qui peut être utilisé comme répertoire temporaire pour stocker les événements de l'interface utilisateur Spark.
**`--TempDir`**
Spécifie un chemin Amazon S3 vers un compartiment qui peut être utilisé comme répertoire temporaire pour la tâche.
Par exemple, pour définir un répertoire temporaire, transmettez l'argument suivant :
```
'--TempDir': 's3-path-to-directory'
```
AWS Glue crée un compartiment temporaire pour les tâches s'il n'en existe pas déjà un dans une région. Ce compartiment peut permettre l’accès au public. Vous pouvez soit modifier le compartiment dans Amazon S3 pour définir le bloc d'accès public, soit supprimer le compartiment ultérieurement une fois toutes les tâches de cette région terminées.
**`--use-postgres-driver`**
Lorsque vous définissez cette valeur sur `true`, cela priorise le pilote JDBC Postgres dans le chemin de classe afin d'éviter tout conflit avec le pilote JDBC Amazon Redshift. Cette option n'est disponible que dans AWS la version 2.0 de Glue.
**`--user-jars-first`**
Lorsque vous définissez cette valeur sur `true`, cela priorise les fichiers JAR supplémentaires du client dans le chemin de classe. Cette option n'est disponible que dans AWS la version 2.0 ou ultérieure de Glue.
**`--conf`**
Contrôle les paramètres de configuration de Spark. Elle est destinée aux cas d'utilisation avancés.
**`--encryption-type`**
Paramètre hérité. Le comportement correspondant doit être configuré à l'aide des configurations de sécurité. Pour plus d'informations sur les configurations de sécurité, consultez [Chiffrement des données écrites par AWS Glue](encryption-security-configuration.md).
AWS Glue utilise les arguments suivants en interne et vous ne devez jamais les utiliser :
+ `--debug`— Interne à AWS Glue. Ne pas définir.
+ `--mode`— Interne à AWS Glue. Ne pas définir.
+ `--JOB_NAME`— Interne à AWS Glue. Ne pas définir.
+ `--endpoint`— Interne à AWS Glue. Ne pas définir.
##
AWS Glue permet de démarrer un environnement à l'aide du `site` module Python `sitecustomize` pour effectuer des personnalisations spécifiques au site. L'amorçage de vos propres fonctions d'initialisation est recommandé uniquement pour les cas d'utilisation avancés et est pris en charge dans toute la mesure du possible sur Glue 4.0. AWS
Le préfixe de la variable d'environnement, `GLUE_CUSTOMER`, est réservé à l'usage du client.
# AWS Glue Spark et PySpark jobs
AWS Glue soutenez Spark et PySpark jobs. Une tâche Spark est exécutée dans un environnement Apache Spark géré par AWS Glue. Elle traite les données par lots. Une tâche ETL en streaming est similaire à une tâche Spark, sauf qu'elle exécute ETL sur des flux de données. Elle utilise le cadre Apache Spark Structured Streaming. Certaines fonctionnalités de tâche Spark ne sont pas disponibles pour les tâches ETL en streaming.
Les sections suivantes fournissent des informations sur AWS Glue Spark et les PySpark jobs.
**Topics**
+ [Configuration des propriétés des tâches pour les tâches Spark dans AWS Glue](add-job.md)
+ [Modification de scripts Spark dans la consoleAWS Glue](edit-script-spark.md)
+ [Tâches (hérité)](console-edit-script.md)
+ [Suivi des données traitées à l'aide de signets de tâche](monitor-continuations.md)
+ [Stockage des données réorganisées Spark](monitor-spark-shuffle-manager.md)
+ [Surveillance des tâches Spark AWS Glue](monitor-spark.md)
+ [Résolution des problèmes liés à l'IA générative pour Apache Spark in AWS Glue](troubleshoot-spark.md)
+ [Utilisation de vues matérialisées avec Glue AWS](materialized-views.md)
# Configuration des propriétés des tâches pour les tâches Spark dans AWS Glue
Lorsque vous définissez votre tâche sur la AWS Glue console, vous fournissez des valeurs pour les propriétés permettant de contrôler l'environnement AWS Glue d'exécution.
## Définition des propriétés des tâches Spark
La liste suivante contient les propriétés d’une tâche Spark. Pour les propriétés d’une tâche shell Python, consultez [Définition des propriétés pour les tâches shell Python](add-job-python.md#create-job-python-properties). Pour les propriétés d’une tâche ETL en streaming, consultez [Définition des propriétés de tâche pour une tâche ETL en streaming](add-job-streaming.md#create-job-streaming-properties).
Les propriétés sont répertoriées dans l'ordre dans lequel elles apparaissent dans l'assistant **d'ajout d'une tâche** sur AWS Glue la console.
**Nom**
Fournit une chaîne UTF-8 d’une longueur maximale de 255 caractères
**Description**
Fournissez une description facultative de 2 048 caractères maximum.
**Rôle IAM**
Spécifiez le rôle IAM qui permet de définir les autorisations d’accès aux ressources utilisées pour exécuter la tâche et accéder aux magasins de données. Pour plus d'informations sur les autorisations relatives à l'exécution de tâches dans AWS Glue, consultez[Gestion des identités et des accès pour AWS Glue](security-iam.md).
**Type**
Le type de tâche ETL. Ce paramètre est défini automatiquement en fonction du type de sources de données que vous sélectionnez.
+ **Spark** exécute un script ETL Apache Spark avec la commande de tâche `glueetl`.
+ **Spark Streaming** exécute un script ETL Apache Spark en streaming avec la commande de tâche `gluestreaming`. Pour de plus amples informations, veuillez consulter [Tâches ETL en streaming dans AWS Glue](add-job-streaming.md).
+ **Python shell** (shell Python) exécute un script Python avec la commande de tâche `pythonshell`. Pour de plus amples informations, veuillez consulter [Configuration des propriétés pour les tâches shell Python dans AWS Glue](add-job-python.md).
**Version AWS Glue **
AWS Glue version détermine les versions d'Apache Spark et de Python disponibles pour la tâche, comme indiqué dans le tableau suivant.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/add-job.html)
**Language**
Le code inclus dans le script ETL permet de définir la logique de votre tâche. Le script peut être codé dans Python ou dans Scala. Vous pouvez choisir si le script exécuté par le job est généré par vous AWS Glue ou fourni par vous. Vous fournissez le nom et l'emplacement du script dans Amazon Simple Storage Service (Amazon S3). Vérifiez qu'il n'existe pas de fichier portant le même nom que le répertoire de script dans le chemin d'accès. Pour en savoir plus sur l’écriture de scripts, consultez [AWS Glue guide de programmation](edit-script.md).
**Type d’employé**
Les types d’employé suivantes sont disponibles :
Les ressources disponibles pour les AWS Glue travailleurs sont mesurées en DPUs. Un DPU est une mesure relative de la puissance de traitement composée de 4 V de capacité CPUs de calcul et de 16 Go de mémoire.
+ **G.025X** – Lorsque vous choisissez ce type, vous devez également fournir une valeur pour **Number of workers (Nombre d'employés)**. Chaque utilisateur est mappé sur 0,25 DPU (2 VCPUs, 4 Go de mémoire) avec un disque de 84 Go (environ 34 Go libres). Nous recommandons ce type d’employé pour les travaux de streaming à faible volume. Ce type de travailleur n'est disponible que pour les tâches de streaming en AWS Glue version 3.0 ou ultérieure.
+ **G.1X** – Lorsque vous choisissez ce type, vous devez également fournir une valeur pour **Number of workers (Nombre d'employés)**. Chaque utilisateur est mappé sur 1 DPU (4 VCPUs, 16 Go de mémoire) avec un disque de 94 Go (environ 44 Go libres). Nous recommandons ce type de travailleur pour les charges de travail telles que les transformations de données, les jointures et les requêtes, afin de proposer un moyen évolutif et rentable d'exécuter la plupart des tâches.
+ **G.2X** – Lorsque vous choisissez ce type, vous devez également fournir une valeur pour **Number of workers (Nombre d'employés)**. Chaque utilisateur mappe sur 2 processeurs (8 VCPUs, 32 Go de mémoire) avec un disque de 138 Go (environ 78 Go libres). Nous recommandons ce type de travailleur pour les charges de travail telles que les transformations de données, les jointures et les requêtes, afin de proposer un moyen évolutif et rentable d'exécuter la plupart des tâches.
+ **G.4X** – Lorsque vous choisissez ce type, vous devez également fournir une valeur pour **Number of workers (Nombre d'employés)**. Chaque utilisateur mappe sur 4 processeurs (16 VCPUs, 64 Go de mémoire) avec un disque de 256 Go (environ 230 Go libres). Nous recommandons ce type de travailleur pour les tâches dont les charges de travail contiennent les transformations, les agrégations, les jointures et les requêtes les plus exigeantes.
+ **G.8X** – Lorsque vous choisissez ce type, vous devez également fournir une valeur pour **Number of workers (Nombre d'employés)**. Chaque utilisateur mappe sur 8 DPU (32 VCPUs, 128 Go de mémoire) avec un disque de 512 Go (environ 485 Go libres). Nous recommandons ce type de travailleur pour les tâches dont les charges de travail contiennent les transformations, les agrégations, les jointures et les requêtes les plus exigeantes.
+ **G.12X** – Lorsque vous choisissez ce type, vous devez également fournir une valeur pour **Number of workers (Nombre d'employés)**. Chaque utilisateur mappe sur 12 DPU (48 VCPUs, 192 Go de mémoire) sur un disque de 768 Go (environ 741 Go libres). Nous recommandons ce type de travailleur pour les tâches comportant des charges de travail très importantes et gourmandes en ressources qui nécessitent une capacité de calcul importante.
+ **G.16X** – Lorsque vous choisissez ce type, vous devez également fournir une valeur pour **Number of workers (Nombre d'employés)**. Chaque utilisateur mappe sur 16 DPU (64 VCPUs, 256 Go de mémoire) avec un disque de 1024 Go (environ 996 Go libres). Nous recommandons ce type de travailleur pour les tâches comportant les charges de travail les plus importantes et les plus gourmandes en ressources et qui nécessitent une capacité de calcul maximale.
+ **R.1X** – Lorsque vous choisissez ce type, vous devez également fournir une valeur pour **Number of workers (Nombre d'employés)**. Chaque travailleur mappe vers 1 DPU avec une configuration optimisée pour la mémoire. Nous recommandons ce type de programme de travail pour les charges de travail gourmandes en mémoire qui rencontrent fréquemment des out-of-memory erreurs ou nécessitent des ratios élevés. memory-to-CPU
+ **R.2X** – Lorsque vous choisissez ce type, vous devez également fournir une valeur pour **Number of workers (Nombre d'employés)**. Chaque travailleur mappe vers 2 DPU avec une configuration optimisée pour la mémoire. Nous recommandons ce type de programme de travail pour les charges de travail gourmandes en mémoire qui rencontrent fréquemment des out-of-memory erreurs ou nécessitent des ratios élevés. memory-to-CPU
+ **R.4X** – Lorsque vous choisissez ce type, vous devez également fournir une valeur pour **Number of workers (Nombre d'employés)**. Chaque travailleur mappe vers 4 DPU avec une configuration optimisée pour la mémoire. Nous recommandons ce type de programme de travail pour les charges de travail gourmandes en mémoire qui rencontrent fréquemment des out-of-memory erreurs ou nécessitent des ratios élevés. memory-to-CPU
+ **R.8X** – Lorsque vous choisissez ce type, vous devez également fournir une valeur pour **Number of workers (Nombre d'employés)**. Chaque travailleur mappe vers 8 DPU avec une configuration optimisée pour la mémoire. Nous recommandons ce type de programme de travail pour les charges de travail gourmandes en mémoire très volumineuses qui rencontrent fréquemment des out-of-memory erreurs ou nécessitent des ratios élevés. memory-to-CPU
**Spécifications des types de travailleurs**
La table suivante fournit des spécifications détaillées pour tous les types de travailleurs G disponibles :
**Spécifications du type de travailleur G**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/add-job.html)
**Important :** les types de travailleurs G.12X et G.16X, ainsi que tous les types de travailleurs R (R.1X à R.8X), ont une latence de démarrage plus élevée.
Un taux horaire vous est facturé en fonction du nombre de tâches DPUs utilisées pour exécuter vos tâches ETL. Pour plus d'informations, consultez la page de tarification [AWS Glue](https://aws.amazon.com/glue/pricing/).
Pour les tâches de AWS Glue version 1.0 ou antérieures, lorsque vous configurez une tâche à l'aide de la console et que vous spécifiez un **type de travailleur** **Standard**, la **capacité maximale** est définie et le **nombre de travailleurs** devient la valeur de **Capacité maximale** - 1. Si vous utilisez le AWS Command Line Interface (AWS CLI) ou le AWS SDK, vous pouvez spécifier le paramètre **Capacité maximale**, ou vous pouvez spécifier à la fois le **type de travailleur** et le **nombre de travailleurs**.
Pour les tâches de AWS Glue la version 2.0 ou ultérieure, vous ne pouvez pas spécifier de **capacité maximale**. Au lieu de cela, vous devez spécifier le **Worker type (Type d’employé)** et le **Number of workers (Nombre d’employés)**.
**G.4X**et les types de **G.8X** travailleurs ne sont disponibles que pour les tâches Spark ETL AWS Glue version 3.0 ou ultérieure dans les AWS régions suivantes : USA Est (Ohio), USA Est (Virginie du Nord), USA Ouest (Californie du Nord), USA Ouest (Oregon), Asie-Pacifique (Mumbai), Asie-Pacifique (Séoul), Asie-Pacifique (Sydney), Asie-Pacifique (Tokyo), Canada (Centre), Europe (Francfort), Europe (Irlande), Europe (Londres), Europe (Espagne), Europe (Stockholm) et Amérique du Sud (São Paulo).
**G.12X****G.16X**, et les types de **R.8X** travailleurs **R.1X** intermédiaires ne sont disponibles que pour les jobs Spark ETL AWS Glue version 4.0 ou ultérieure dans les AWS régions suivantes : USA Est (Virginie du Nord), USA Ouest (Oregon), USA Est (Ohio), Europe (Irlande) et Europe (Francfort). D’autres régions seront prises en charge dans les prochaines versions.
**Nombre de travailleurs demandé**
Pour la plupart des types d’employés, vous devez spécifier le nombre de travailleurs qui sont alloués lors de l’exécution de la tâche.
**Marque-page de tâche**
Spécifiez la manière dont AWS Glue les informations d'état sont traitées lors de l'exécution de la tâche. Ce signet peut se souvenir des données traitées précédemment, mettre à jour les informations sur l’état ou ignorer les informations sur l’état. Pour de plus amples informations, veuillez consulter [Suivi des données traitées à l'aide de signets de tâche](monitor-continuations.md).
**Mise en file d’attente des tâches**
Spécifie si les exécutions de tâches sont mises en file d’attente pour être exécutées ultérieurement lorsqu’elles ne peuvent pas être exécutées immédiatement en raison de Service Quotas.
Lorsque cette case est cochée, la mise en file d’attente des tâches est activée pour les exécutions de tâches. Si cette option n’est pas cochée, les exécutions de tâches ne seront pas prises en compte pour la mise en file d’attente.
Si ce paramètre ne correspond pas à la valeur définie dans l’exécution de la tâche, la valeur du champ d’exécution de la tâche sera utilisée.
**Exécution flexible**
Lorsque vous configurez une tâche à l'aide de AWS Studio ou de l'API, vous pouvez spécifier une classe d'exécution de tâche standard ou flexible. Vos tâches peuvent avoir différents degrés de priorité et de sensibilité au temps. La classe d’exécution standard est idéale pour les charges de travail urgentes qui nécessitent un démarrage rapide des tâches et des ressources dédiées.
La classe d’exécution flexible convient aux tâches non urgentes telles que les tâches de pré-production, les tests et les chargements de données uniques. Les exécutions flexibles sont prises en charge pour les tâches utilisant AWS Glue la version 3.0 ou ultérieure et/ou les `G.1X` types de `G.2X` travailleurs. Les nouveaux types de travailleurs (`G.12X`, `G.16X` et `R.1X` à `R.8X`) ne permettent pas une exécution flexible.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/FnHCoTuDLXU)
Les exécutions de tâches flexibles sont facturées en fonction du nombre de travailleurs en cours d’exécution à un moment donné dans le temps. Le nombre de travailleurs peut être ajouté ou supprimé pour une exécution flexible en cours d’exécution. Au lieu de facturer comme un simple calcul de `Max Capacity` \$1 `Execution Time`, chaque travailleur contribuera pour le temps qu’il a effectué pendant l’exécution du travail. La facture est la somme de (`Number of DPUs per worker` \$1 `time each worker ran`).
Pour plus d'informations, consultez le panneau d'aide de AWS Studio, ou [Tâches](aws-glue-api-jobs-job.md) et[Exécutions de tâches](aws-glue-api-jobs-runs.md).
**Nombre de nouvelles tentatives**
Spécifiez le nombre de fois, de 0 à 10, qui AWS Glue devrait redémarrer automatiquement la tâche en cas d'échec. Les tâches qui atteignent la limite de délai d’expiration ne sont pas redémarrées.
**Délai d'expiration de la tâche**
Définit le délai d’exécution maximal en minutes. La valeur maximale est de 7 jours ou 10 080 minutes. Dans le cas contraire, les tâches déclencheront une exception.
Si aucune valeur n’est indiquée, le délai d’expiration est défini par défaut sur 2 880 minutes.
Toutes les AWS Glue tâches existantes dont le délai d'expiration est supérieur à 7 jours seront définies par défaut sur 7 jours. Par exemple, si vous avez spécifié un délai d’expiration de 20 jours pour un traitement par lots, celui-ci sera arrêté le 7e jour.
**Bonnes pratiques relatives aux délais d’expiration des tâches**
Les tâches sont facturées en fonction du temps d’exécution. Pour éviter des frais inattendus, configurez des délais d’expiration adaptés à la durée d’exécution prévue de votre tâche.
**Propriétés avancées**
**Nom du fichier de script**
Un nom de script unique pour votre tâche. Il ne peut pas être nommé **Tâche sans titre**.
**Chemin d’accès au script**
L’emplacement Amazon S3 du script. Le chemin doit être de la forme `s3://bucket/prefix/path/`. Il doit se terminer par une barre oblique (`/`) et ne pas inclure de fichiers.
**Métriques de tâche**
Activez ou désactivez la création de CloudWatch métriques Amazon lors de l'exécution de cette tâche. Pour afficher les données de profilage, vous devez activer cette option. Pour en savoir plus sur l’activation et la visualisation de métriques, consultez [Surveillance et débogage des tâches](monitor-profile-glue-job-cloudwatch-metrics.md).
**Métriques d’observabilité de la tâche**
Activez la création de CloudWatch mesures d'observabilité supplémentaires lors de l'exécution de cette tâche. Pour de plus amples informations, veuillez consulter [Surveillance à l'aide de métriques d'observabilité AWS Glue](monitor-observability.md).
**Journalisation continue**
Activez la journalisation continue sur Amazon CloudWatch. Si cette option n’est pas activée, les journaux ne sont disponibles qu’une fois la tâche terminée. Pour en savoir plus, consultez [Journalisation pour les AWS Glue emplois](monitor-continuous-logging.md).
**Interface utilisateur Spark**
Permettez l’utilisation de l’interface utilisateur Spark pour la surveillance de cette tâche. Pour de plus amples informations, veuillez consulter [Activation de l’interface utilisateur web Apache Spark pour les tâches AWS Glue](monitor-spark-ui-jobs.md).
**Chemin d’accès aux journaux de l’interface utilisateur Spark**
Le chemin pour écrire les journaux lorsque l’interface utilisateur Spark est activée.
**Configuration de journalisation et de surveillance de l’interface utilisateur Spark**
Choisissez l’une des options suivantes :
+ *Standard* : écrivez des journaux en utilisant l'ID AWS Glue d'exécution du job comme nom de fichier. Activez la surveillance de l'interface utilisateur Spark dans la AWS Glue console.
+ *Hérité* : écrivez des journaux en utilisant « spark-application-\$1timestamp\$1 » comme nom de fichier. N’activez pas la surveillance de l’interface utilisateur Spark.
+ *Standard et hérité* : écrivez des journaux à la fois dans les emplacements standard et hérités. Activez la surveillance de l'interface utilisateur Spark dans la AWS Glue console.
**Simultanéité maximum**
Définit le nombre maximal d’exécutions simultanées autorisées pour cette tâche. La valeur par défaut est 1. Une erreur est renvoyée lorsque ce seuil est atteint. La valeur maximale que vous pouvez spécifier est contrôlée par une limite de service. Par exemple, si une tâche est toujours en cours d’exécution lorsqu’une nouvelle instance est lancée, vous pouvez souhaiter le renvoi d’une erreur pour empêcher deux instances de la même tâche de s’exécuter simultanément.
**Chemin d’accès temporaire**
Indiquez l'emplacement d'un répertoire de travail dans Amazon S3 où les résultats intermédiaires temporaires sont écrits lors de l' AWS Glue exécution du script. Vérifiez qu’il n’existe pas de fichier portant le même nom que le répertoire temporaire dans le chemin d’accès. Ce répertoire est utilisé lors des opérations de AWS Glue lecture et d'écriture sur Amazon Redshift et lors de certaines AWS Glue transformations.
AWS Glue crée un compartiment temporaire pour les tâches s'il n'en existe pas déjà un dans une région. Ce compartiment peut permettre l’accès au public. Vous pouvez soit modifier le compartiment dans Amazon S3 pour définir le bloc d’accès public, soit supprimer le compartiment ultérieurement une fois toutes les tâches de cette région terminées.
**Seuil de notification de délai (minutes)**
Définit le seuil (en minutes) avant l’envoi d’une notification de dépassement de délai. Vous pouvez définir ce seuil pour envoyer des notifications lorsqu’une exécution de tâche `RUNNING`, `STARTING` ou `STOPPING` prend plus de temps que le nombre de minutes prévu.
**Configuration de sécurité**
Choisissez une configuration de sécurité dans la liste. Une configuration de sécurité spécifie la manière dont les données de la cible Amazon S3 sont chiffrées : pas de chiffrement, chiffrement côté serveur avec des clés gérées par AWS KMS(SSE-KMS) ou clés de chiffrement gérées par Amazon S3 (SSE-S3).
**Chiffrement côté serveur**
Si vous sélectionnez cette option, lorsque la tâche ETL écrit sur Amazon S3, les données sont chiffrées au repos à l’aide du chiffrement SSE-S3. Votre cible de données Amazon S3 et toutes les données qui sont écrites dans un répertoire temporaire Amazon S3 sont chiffrées. Cette option est transmise en tant que paramètre de tâche. Pour en savoir plus, consultez la section [Protecting Data Using Server-Side Encryption with Amazon S3-Managed Encryption Keys (SSE-S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingServerSideEncryption.html) (Protection des données à l’aide du chiffrement côté serveur avec des clés de chiffrement (SSE-S3) gérées par Amazon S3) dans le *guide de l’utilisateur Amazon Simple Storage Service*.
Cette option est ignorée si une configuration de sécurité est spécifiée.
**Utiliser le catalogue de données Glue en tant que metastore Hive**
Sélectionnez cette option pour utiliser le catalogue de AWS Glue données comme métastore Hive. Le rôle IAM utilisé pour la tâche doit disposer de l’autorisation `glue:CreateDatabase`. Une base de données appelée « default » est créée dans le catalogue de données si elle n’existe pas.
**Connexions**
Choisissez une configuration VPC pour accéder aux sources de données Amazon S3 situées dans votre cloud privé virtuel (VPC). Vous pouvez créer et gérer une connexion réseau dans AWS Glue. Pour de plus amples informations, veuillez consulter [Connexion aux données](glue-connections.md).
**Bibliothèques**
**Chemin de bibliothèque Python, JARs chemin dépendant et chemin des fichiers référencés**
Spécifiez ces options si votre script les requiert. Vous pouvez définir des chemins Amazon S3 séparés par des virgules pour ces options lorsque vous définissez la tâche. Vous pouvez remplacer ces chemins lorsque vous exécutez la tâche. Pour de plus amples informations, veuillez consulter [Fournir vos propres scripts personnalisés](console-custom-created.md).
**Paramètres du job**
Ensemble de paires clé-valeur transmises sous forme de paramètres nommés au script. Il s’agit de valeurs par défaut qui sont utilisées lors de l’exécution du script, mais vous pouvez les remplacer dans les déclencheurs ou lorsque vous exécutez la tâche. Vous devez préfixer le nom de la clé avec `--` ; par exemple : `--myKey`. Vous transmettez les paramètres de la tâche sous forme de carte lorsque vous utilisez le AWS Command Line Interface.
Pour accéder à des exemples, veuillez consulter les paramètres Python dans [Transmission de paramètres Python et accès à ces paramètres dans AWS Glue](aws-glue-programming-python-calling.md#aws-glue-programming-python-calling-parameters).
**Étiquettes**
Identifiez votre tâche avec une **clé d’identification** et avec une **valeur d’identification** facultative. Lorsque les clés d’identification sont créées, elles sont en lecture seule. Utilisez des identifications sur certaines ressources pour mieux les organiser et les identifier. Pour de plus amples informations, veuillez consulter [AWS tags dans AWS Glue](monitor-tags.md).
## Restrictions pour les tâches qui accèdent aux tables gérées par Lake Formation
Tenez compte des remarques et restrictions suivantes lorsque vous créez des tâches qui permettent de lire ou d'écrire dans des tables gérées par AWS Lake Formation :
+ Les fonctions suivantes ne sont pas prises en charge dans les tâches qui accèdent à des tables comportant des filtres au niveau des cellules :
+ [Marque-pages de tâche](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuations.html) et [exécution limitée](https://docs.aws.amazon.com/glue/latest/dg/bounded-execution.html)
+ [Prédicats pushdown](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html#aws-glue-programming-etl-partitions-pushdowns)
+ [Prédicats de partition de catalogue côté serveur](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html#aws-glue-programming-etl-partitions-cat-predicates)
+ [enableUpdateCatalog](https://docs.aws.amazon.com/glue/latest/dg/update-from-job.html)
# Modification de scripts Spark dans la consoleAWS Glue
Un script contient le code qui extrait les données des sources, les transforme et les charge dans des cibles. AWS Glue exécute un script lorsqu'il démarre une tâche.
Les scripts ETL AWS Glue peuvent être codés en Python ou Scala. Les scripts Python utilisent un langage qui est une extension du dialecte PySpark Python pour les tâches d'extraction, de transformation et de chargement (ETL). Le script contient des *structures étendues* pour gérer les transformations ETL. Lorsque vous générez automatiquement la logique de code source pour votre tâche, un script est créé. Vous pouvez modifier ce script ou fournir votre propre script personnalisé pour effectuer votre travail ETL.
Pour plus d'informations sur la définition et la modification de scripts dans AWS Glue, consultez [AWS Glue guide de programmation](edit-script.md).
## Bibliothèques ou fichiers supplémentaires
Si votre script nécessite des bibliothèques ou des fichiers supplémentaires, vous pouvez les spécifier comme suit :
**chemin de la bibliothèque Python**
Chemins Amazon Simple Storage Service (Amazon S3) séparés par des virgules vers les bibliothèques Python requises par le script.
Seules les bibliothèques Python pures peuvent être utilisées. Les bibliothèques reposant sur des extensions C, par exemple la bibliothèque d'analyse des données Python pandas, ne sont pas encore prises en charge.
**Chemin des fichiers jar dépendants**
Chemins Amazon S3 séparés par des virgules vers les fichiers JAR requis par le script.
À l'heure actuelle, seules les bibliothèques pures Java ou Scala (2.11) peuvent être utilisées.
**Chemin de fichiers référencés**
Chemins Amazon S3 séparés par des virgules vers les fichiers supplémentaires (par exemple, des fichiers de configuration) requis par le script.
# Tâches (hérité)
Un script contient le code qui permet d'effectuer un travail ETL (extraction, transformation et chargement). Vous pouvez fournir votre propre script, ou AWS Glue peut générer un script à partir de vos indications. Pour plus d'informations sur la création de vos propres scripts, consultez [Fournir vos propres scripts personnalisés](console-custom-created.md).
Vous pouvez modifier un script dans la console AWS Glue. Lorsque vous modifiez un script, vous pouvez ajouter des sources, des cibles et des transformations.
**Pour modifier un script**
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/). Ensuite, choisissez l'onglet **Jobs** (Tâches).
1. Choisissez une tâche dans la liste, puis choisissez **Action**, **Edit script** (Modifier le script) pour ouvrir l'éditeur de script.
Vous pouvez également accéder à l'éditeur de script à partir de la page des détails de la tâche. Sélectionnez l’onglet **Script**, puis **Edit script** (Modifier le script).
## Éditeur de script
L'éditeur de script AWS Glue vous permet d'insérer, de modifier et de supprimer des sources, des cibles et des transformations dans votre script. L'éditeur de script affiche à la fois le script et un diagramme pour vous aider à visualiser le flux de données.
Pour créer un diagramme pour le script, choisissez **Générer un diagramme**. AWS Glue utilise des lignes d'annotation dans le script commençant par **\$1 \$1** pour afficher le schéma. Pour représenter correctement votre script dans le diagramme, vous devez conserver la synchronisation entre les paramètres dans les annotations et les paramètres dans le code Apache Spark.
L'éditeur de script vous permet d'ajouter des modèles de code à chaque fois que votre curseur est positionné dans le script. Dans la partie supérieure de l'éditeur, choisissez l'une des options suivantes :
+ Pour ajouter une table source au script, choisissez **Source** (Source).
+ Pour ajouter une table cible au script, choisissez **Target** (Cible).
+ Pour ajouter un emplacement cible au script, choisissez **Target location** (Emplacement cible).
+ Pour ajouter une transformation au script, choisissez **Transform** (Transformation). Pour plus d'informations sur les fonctions appelées dans votre script, consultez [Programmez les scripts ETL AWS Glue dans PySpark](aws-glue-programming-python.md).
+ Pour ajouter une transformation Spigot au script, choisissez **Spigot**.
Dans le code inséré, modifiez l'élément `parameters` dans les annotations et dans le code Apache Spark. Par exemple, si vous ajoutez une transformation **Spigot**, vérifiez que l'élément `path` est remplacé dans la ligne d'annotation `@args` et dans la ligne de code `output`.
L'onglet **Logs** (Journaux) présente les journaux associés à votre travail pendant son exécution. Les 1 000 lignes les plus récentes sont affichées.
L'onglet **Schema** (Schéma) présente le schéma des sources et des cibles sélectionnées, lorsqu'elles sont disponibles dans Data Catalog.
# Suivi des données traitées à l'aide de signets de tâche
AWS Glue effectue le suivi des données qui ont déjà été traitées au cours d'une exécution précédente d'une tâche ETL par la persistance des informations d'état à partir de l'exécution de la tâche. Ces informations d'état permanentes sont appelées *marque-pages de tâches*. Les signes de tâche permettent à AWS Glue de conserver des informations d'état et d'empêcher le retraitement des anciennes données. Avec les marque-pages de tâche, vous pouvez traiter de nouvelles données lors de la réexécution sur un intervalle planifié. Un marque-page de tâche se compose des états des différents éléments de tâches, tels que les sources, les transformations et les cibles. Par exemple, votre tâche ETL peut lire de nouvelles partitions dans un fichier Amazon S3. AWS Glue suit les partitions qui ont été traitées avec succès par la tâche pour éviter le traitement des doublons et les doublons dupliqués dans le magasin de données cible de la tâche.
Les marque-pages de tâche sont implémentés pour les sources de données JDBC, la transformation Relationalize et certaines sources Amazon Simple Storage Service (Amazon S3). Le tableau suivant répertorie les formats source Amazon S3 pris en charge par AWS Glue pour les marque-pages de tâche.
| Version de l’AWS Glue | Formats source Amazon S3 |
| --- | --- |
| Version 0.9 | JSON, CSV, Apache Avro, XML |
| Version 1.0 et ultérieure | JSON, CSV, Apache Avro, XML, Parquet, ORC |
Pour plus d'informations sur les versions AWS Glue, veuillez consulter [Définition des propriétés des tâches Spark](add-job.md#create-job).
La fonction de signets de tâches comporte des fonctionnalités supplémentaires lorsqu'elle est accessible par le biais de AWS Glue scripts. Lorsque vous parcourez le script que vous avez généré, vous pouvez voir des contextes de transformation liés à cette fonctionnalité. Pour de plus amples informations, veuillez consulter [Utilisation des marque-pages de tâche](programming-etl-connect-bookmarks.md).
**Topics**
+ [Utilisation des marque-pages de tâche dans AWS Glue](#monitor-continuations-implement)
+ [Détails opérationnels de la fonctionnalité de signets de tâche](#monitor-continuations-script)
## Utilisation des marque-pages de tâche dans AWS Glue
L’option de marque-page de tâche est transmise sous forme de paramètre au démarrage de la tâche. Le tableau suivant décrit les options de définition des marque-pages de tâche sur la console AWS Glue.
****
| Marque-page de tâche | Description |
| --- | --- |
| Enable | La tâche met à jour l'état après une exécution pour suivre les données traitées précédemment. Si votre tâche a une source avec prise en charge du marque-page de tâche, elle suit les données traitées et, lorsqu'une tâche est exécutée, elle traite les nouvelles données depuis le dernier point de contrôle. |
| Désactiver | Les marque-pages de tâche ne sont pas utilisés et la tâche traite toujours la totalité du jeu de données. Vous êtes responsable de la gestion des résultats des précédentes exécutions de tâches. Il s’agit de l’option par défaut. |
| Pause | Traitez les données progressives depuis la dernière exécution réussie ou les données de la plage identifiée par les sous-options suivantes, sans mettre à jour l'état du dernier marque-page. Vous êtes responsable de la gestion des résultats des précédentes exécutions de tâches. Les deux sous-options sont les suivantes : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/monitor-continuations.html) L'état du marque-page de tâche n'est pas mis à jour lorsque ce jeu d'options est spécifié. Les sous-options sont facultatives, mais lorsqu'elles sont utilisées, les deux sous-options doivent être fournies. |
Pour plus d'informations sur les paramètres transmis à une tâche sur la ligne de commande, et plus particulièrement pour les marque-pages de tâche, consultez [Utilisation des paramètres des tâches dans les tâches AWS Glue](aws-glue-programming-etl-glue-arguments.md).
Pour les sources d'entrée Amazon S3, les marque-pages de tâche de AWS Glue vérifient l'heure de la dernière modification des objets afin de contrôler quels objets doivent être retraités. Si les données de la source d'entrée ont été modifiées depuis votre dernière exécution de tâche, les fichiers sont traités de nouveau lorsque vous exécutez la tâche à nouveau.
Pour les sources JDBC, les règles suivantes s'appliquent :
+ Pour chaque table, AWS Glue utilise une ou plusieurs colonnes comme clés de marque-page pour déterminer les données nouvelles et les données traitées. Les touches de marque-page se combinent pour former une seule clé composée.
+ AWS Glue utilise par défaut la clé primaire comme clé de signet, à condition qu'elle augmente ou diminue de manière séquentielle (sans aucun écart).
+ Vous pouvez spécifier les colonnes à utiliser comme clés de signet dans votre AWS Glue script. Pour plus d'informations sur l'utilisation des signets Job dans les AWS Glue scripts, consultez[Utilisation des marque-pages de tâche](programming-etl-connect-bookmarks.md).
+ AWS Glue ne prend pas en charge l'utilisation de colonnes dont les noms sont sensibles à la casse comme clés de signet de tâche.
Vous pouvez restaurer les marque-pages de tâche pour les tâches AWS Glue Spark ETL sur une exécution de tâche précédente. Les opérations de remplacement automatique de données sont mieux prises en charge : quand un marque-page de tâche déjà exécutée est restauré sur une exécution de tâche précédente, les exécutions de tâche ultérieures ne retraitent que les données à partir de l'exécution de tâche marquée par le marque-page.
Si vous avez l'intention de retraiter toutes les données à l'aide de la même tâche, réinitialisez le marque-page de tâche. Pour réinitialiser l'état d'un marque-page de tâche, utilisez la console AWS Glue, l'opération d'API [ResetJobBookmark action (Python : reset\$1job\$1bookmark)](aws-glue-api-jobs-runs.md#aws-glue-api-jobs-runs-ResetJobBookmark) ou le AWS CLI. Par exemple, entrez la commande suivante à l'aide de l' AWS CLI :
```
aws glue reset-job-bookmark --job-name my-job-name
```
Lorsque vous restaurez ou réinitialisez un marque-page, AWS Glue ne nettoie pas les fichiers cible, car il peut y avoir plusieurs cibles et les cibles ne sont pas suivies avec des marque-pages de tâche. Seuls les fichiers source sont suivis à l'aide de marque-pages de tâche. Vous pouvez créer différentes cibles de sortie lors de la restauration et du retraitement des fichiers source pour éviter les doublons de données dans votre sortie.
AWS Glue assure le suivi des marque-pages de tâche par tâche. Si vous supprimez une tâche, le marque-page de tâche est supprimé.
Dans certains cas, il se peut que vous ayez activé les marque-pages de tâche AWS Glue, mais que votre tâche ETL retraite les données qui ont déjà été traitées lors d'une exécution précédente. Pour plus d'informations sur la résolution des causes courantes de cette erreur, consultez [Résolution des erreurs de configuration courantes de Glue](glue-troubleshooting-errors.md).
## Détails opérationnels de la fonctionnalité de signets de tâche
Cette section décrit plus de détails opérationnels sur l'utilisation des marque-pages de tâche.
Les marque-pages de tâche stockent les états d'une tâche. Chaque instance de l'état est identifiée par un nom et un numéro de version. Lorsqu'un script appelle `job.init`, il extrait son état et obtient toujours la dernière version. Au sein d'un état, il y a plusieurs éléments d'état, qui sont spécifiques à chaque source, la transformation et l'instance de récepteur dans le script. Ces éléments d'état sont identifiés par un contexte de transformation qui est attaché à l'élément correspondant (source, transformation ou récepteur) dans le script. Les éléments d'état sont enregistrés de manière atomique lorsque `job.commit` est appelé depuis le script utilisateur. Le script obtient le nom de la tâche et l'option de contrôle pour les marque-pages de tâches depuis les arguments.
Les éléments d'état dans le marque-page de tâche sont les données de la source, de la transformation ou des données spécifiques au récepteur. Par exemple, supposons que vous souhaitiez lire des données progressives à partir d'un emplacement Amazon S3 qui est constamment écrit par une tâche ou un processus en amont. Dans ce cas, le script doit déterminer ce qui a été traité jusqu'à présent. L'implémentation du marque-page de tâche pour la source Amazon S3 enregistre des informations pour que, lors de la prochaine exécution de la tâche, elle puisse filtrer uniquement les nouveaux objets à l'aide des informations enregistrées et recalculer l'état de la prochaine exécution de la tâche. Un horodatage est utilisé pour filtrer les nouveaux fichiers.
Outre les éléments d'état, les marque-pages de tâche ont un *nombre d'exécutions*, un *nombre de tentatives* et un numéro de *version*. Le nombre d'exécutions suit l'exécution de la tâche et le nombre de tentatives enregistre les tentatives d'une exécution de tâche. Le nombre d'exécutions d'une tâche est un nombre croissant de façon monotone incrémenté pour chaque exécution réussie. Le nombre de tentatives suit les tentatives de chaque exécution, et il est incrémenté uniquement lorsqu'il y a une exécution après une tentative en échec. Le numéro de version augmente de façon monotone et effectue le suivi des mises à jour d'un marque-page de tâche.
Dans la base de données de AWS Glue service, les états des signets pour toutes les transformations sont stockés ensemble sous forme de paires clé-valeur :
```
{
"job_name" : ...,
"run_id": ...,
"run_number": ..,
"attempt_number": ...
"states": {
"transformation_ctx1" : {
bookmark_state1
},
"transformation_ctx2" : {
bookmark_state2
}
}
}
```
**Bonnes pratiques**
Les bonnes pratiques suivantes sont recommandées pour utiliser des signets de tâche.
+ *Ne modifiez pas la propriété de la source de données lorsque le marque-page est activé*. Par exemple, une source de données 0 pointe vers un chemin d'entrée A Amazon S3, et la tâche est en cours de lecture à partir d'une source exécutée pendant plusieurs tours avec le marque-page activé. Si vous remplacez le chemin d'entrée de datasource0 par le chemin B d'Amazon S3 sans le modifier`transformation_ctx`, la AWS Glue tâche utilisera l'ancien état des favoris enregistré. Cela entraînera l'absence ou l'omission de fichiers dans le chemin d'entrée B, comme cela AWS Glue supposerait que ces fichiers ont été traités lors d'exécutions précédentes.
+ *Utiliser un tableau de catalogue avec des marque-pages pour une meilleure gestion des partitions*. Les marque-pages fonctionnent à la fois pour les sources de données du catalogue de données ou à partir d'options. Cependant, il est difficile de créer de remove/add nouvelles partitions avec l'approche des options from. L'utilisation d'un tableau de catalogue avec des crawlers peut fournir une meilleure automatisation pour suivre les [partitions](https://docs.aws.amazon.com/glue/latest/dg/tables-described.html#tables-partition) nouvellement ajoutées et vous offre la flexibilité nécessaire pour sélectionner des partitions particulières avec un [prédicat pushdown](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html).
+ *Utiliser le [listeur de fichiers Amazon S3 AWS Glue](https://aws.amazon.com/premiumsupport/knowledge-center/glue-oom-java-heap-space-error/) pour les jeux de données volumineux*. Un marque-page répertorie tous les fichiers sous chaque partition d'entrée et effectue le filtrage. Par conséquent, s'il y a trop de fichiers sous une seule partition, le marque-page peut être exécuté dans le pilote OOM. Utilisez le listeur de fichiers AWS Glue Amazon S3 pour éviter de répertorier tous les fichiers en mémoire en une seule fois.
# Stockage des données réorganisées Spark
La réorganisation est une étape importante d'une tâche Spark chaque fois que les données sont réarrangées entre des partitions. Elle est nécessaire parce que de larges transformations telles que `join`, ` groupByKey`, `reduceByKey` et `repartition` ont besoin d'informations provenant d'autres partitions pour terminer le traitement. Spark rassemble les données requises de chaque partition et les combine dans une nouvelle partition. Lors d'une réorganisation, les données sont écrites sur le disque et transférées via le réseau. Par conséquent, l'opération de réorganisation est liée à la capacité du disque local. Spark émet une erreur `No space left on device` ou ` MetadataFetchFailedException` lorsqu'il n'y a pas assez d'espace disque sur le programme d'exécution et qu'il n'y a pas de récupération.
**Note**
AWS Glue Le plugin Spark shuffle avec Amazon S3 n'est pris en charge que pour les tâches AWS Glue ETL.
**Solution**
Avec AWS Glue, vous pouvez désormais utiliser Amazon S3 pour stocker des données de réorganisation Spark. Amazon S3 est un service de stockage d'objets qui offre une évolutivité, une disponibilité des données, une sécurité et des performances de pointe. Cette solution désagrège le calcul et le stockage pour vos tâches Spark, et offre une élasticité totale et un stockage économique de la réorganisation, ce qui vous permet d'exécuter vos applications les plus complexes de manière fiable.
![\[Spark workflow showing Map and Reduce stages using Amazon S3 for shuffle data storage.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/gs-s3-shuffle-diagram.png)
Nous introduisons un nouveau plug-in Cloud Shuffle Storage pour Apache Spark afin d'utiliser Amazon S3. Vous pouvez activer la réorganisation Amazon S3 pour exécuter vos tâches AWS Glue de manière fiable, sans échec, si elles sont liées par la capacité du disque local pour les opérations de réorganisation volumineuses. Dans certains cas, une réorganisation vers Amazon S3 est légèrement plus lente que vers un disque local (ou EBS) si vous avez un grand nombre de petites partitions ou de fichiers réorganisés écrits dans Amazon S3.
## Conditions préalables à l'utilisation du plug-in de stockage de réorganisation du cloud.
Pour utiliser le plug-in de stockage Cloud Shuffle avec des tâches AWS Glue ETL, vous avez besoin des éléments suivants :
+ Un compartiment Amazon S3 situé dans la même région que celle de votre exécution de tâche, pour stocker la réorganisation intermédiaire et les données déversées. Le préfixe Amazon S3 du stockage de réorganisation peut être spécifié avec `--conf spark.shuffle.glue.s3ShuffleBucket=s3://shuffle-bucket/prefix/`, comme dans l'exemple suivant :
```
--conf spark.shuffle.glue.s3ShuffleBucket=s3://glue-shuffle-123456789-us-east-1/glue-shuffle-data/
```
+ Définissez les stratégies de cycle de vie du stockage Amazon S3 sur le *préfixe* (tel que `glue-shuffle-data`), car le gestionnaire de réorganisation ne nettoie pas les fichiers une fois la tâche terminée. La réorganisation intermédiaire et les données déversées doivent être supprimées une fois la tâche terminée. Les utilisateurs peuvent définir des stratégies de cycle de vie court pour le préfixe. Les instructions de configuration d'une stratégie de cycle de vie Amazon S3 sont disponibles dans la section [Configuration du cycle de vie d'un compartiment](https://docs.aws.amazon.com//AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html) dans le Guide de l'utilisateur Amazon Simple Storage Service.
## Utilisation du gestionnaire de shuffle AWS Glue Spark depuis la console AWS
Pour configurer le gestionnaire de shuffle AWS Glue Spark à l'aide de la AWS Glue console ou de AWS Glue Studio lors de la configuration d'une tâche : choisissez le paramètre de tâche **-- write-shuffle-files-to -s3** pour activer le shuffle Amazon S3 pour la tâche.
![\[Job parameters interface showing --write-shuffle-files- parameter and option to add more.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/gs-s3-shuffle.png)
## Utilisation du plug-in de réorganisation Spark AWS Glue
Les paramètres de tâche suivants activent et affinent le gestionnaire de réorganisation AWS Glue. Ces paramètres étant des indicateurs, les valeurs fournies ne sont pas prises en compte.
+ `--write-shuffle-files-to-s3` : l'indicateur principal, qui active le gestionnaire de réorganisation AWS Glue Spark pour utiliser des compartiments Amazon S3 pour écrire et lire des données de réorganisation. Lorsque l'indicateur n'est pas spécifié, le gestionnaire de réorganisation n'est pas utilisé.
+ `--write-shuffle-spills-to-s3` – (Pris en charge uniquement dans AWS Glue version 2.0). Indicateur facultatif qui vous permet de décharger des fichiers de déversement dans des compartiments Amazon S3, pour une résilience supplémentaire de votre tâche Spark. Ceci n'est requis que pour les charges de travail volumineuses qui déversent beaucoup de données sur le disque. Lorsque l'indicateur n'est pas spécifié, aucun fichier de déversement intermédiaire n'est écrit.
+ ` --conf spark.shuffle.glue.s3ShuffleBucket=s3://` – autre indicateur facultatif spécifiant le compartiment Amazon S3 dans lequel vous écrivez les fichiers de réorganisation. Par défaut, `--TempDir` /shuffle-data. AWS Glue La version 3.0\$1 prend en charge l'écriture de fichiers shuffle dans plusieurs compartiments en spécifiant des compartiments avec un délimiteur par virgule, comme dans. `--conf spark.shuffle.glue.s3ShuffleBucket=s3://shuffle-bucket-1/prefix,s3://shuffle-bucket-2/prefix/` L'utilisation de plusieurs compartiments améliore les performances.
Vous devez fournir des paramètres de configuration de sécurité pour activer le chiffrement au repos des données de réorganisation. Pour plus d’informations sur les configurations de sécurité, consultez [Configuration du chiffrement dans AWS Glue](set-up-encryption.md). AWS Glue prend en charge toutes les autres configurations de réorganisation fournies par Spark.
**Binaires logiciels pour le plug-in Cloud Shuffle Storage**
Vous pouvez également télécharger les fichiers binaires du plug-in Cloud Shuffle Storage pour Apache Spark sous la licence Apache 2.0 et l'exécuter dans n'importe quel environnement Spark. Le nouveau plugin est compatible avec out-of-the Amazon S3 et peut également être facilement configuré pour utiliser d'autres formes de stockage dans le cloud, telles que [Google Cloud Storage et Microsoft Azure Blob Storage](https://github.com/aws-samples/aws-glue-samples/blob/master/docs/cloud-shuffle-plugin/README.md). Pour plus d'informations, consultez [Cloud Shuffle Storage Plugin for Apache Spark](https://docs.aws.amazon.com/glue/latest/dg/cloud-shuffle-storage-plugin.html) (Plug-in Cloud Shuffle Storage pour Apache Spark).
**Remarques et limitations**
Ci-dessous des remarques ou limitations concernant le gestionnaire de réorganisation AWS Glue.
+ AWS Glue le gestionnaire de shuffle ne supprime pas automatiquement les fichiers de données de shuffle (temporaires) stockés dans votre compartiment Amazon S3 une fois la tâche terminée. Pour garantir la protection des données, suivez les instructions fournies dans [Conditions préalables à l'utilisation du plug-in de stockage de réorganisation du cloud.](#monitor-spark-shuffle-manager-prereqs) avant d'activer le plug-in Cloud Shuffle Storage.
+ Vous pouvez utiliser cette fonction si vos données sont biaisées.
# Cloud Shuffle Storage Plugin pour Apache Spark
Cloud Shuffle Storage Plugin est un plug-in Apache Spark compatible avec l’[API `ShuffleDataIO`](https://github.com/apache/spark/blob/master/core/src/main/java/org/apache/spark/shuffle/api/ShuffleDataIO.java) qui permet de stocker des données aléatoires sur des systèmes de stockage cloud (tels qu’Amazon S3). Il vous permet de compléter ou de remplacer la capacité de stockage sur disque local pour les opérations de remaniement de grande envergure, généralement déclenchées par des transformations telles que `join``reduceByKey`, `groupByKey` et `repartition` dans vos applications Spark, réduisant ainsi les défaillances ou les price/performance dislocations fréquentes de vos tâches et pipelines d'analyse de données sans serveur.
**AWS Glue**
Sur les versions 3.0 et 4.0 de AWS Glue, le plug-in est préinstallé et prêt à autoriser la lecture aléatoire dans Amazon S3 sans aucune étape supplémentaire. Pour plus d’informations, consultez [AWS Glue Spark shuffle plugin with Amazon S3](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-shuffle-manager.html) afin d’activer cette fonctionnalité pour vos applications Spark.
**Autres environnements Spark**
Le plug-in exige que les configurations Spark suivantes soient définies sur d’autres environnements Spark :
+ `--conf spark.shuffle.sort.io.plugin.class=com.amazonaws.spark.shuffle.io.cloud.ChopperPlugin` : indique à Spark d’utiliser ce plug-in pour Shuffle IO.
+ `--conf spark.shuffle.storage.path=s3://bucket-name/shuffle-file-dir` : chemin de stockage de vos fichiers de lecture aléatoire.
**Note**
Le plug-in remplace une classe principale de Spark. Par conséquent, le fichier jar du plug-in doit être chargé avant les fichiers jar de Spark. Pour ce faire, utilisez `userClassPathFirst` dans des environnements YARN sur site si le plug-in est utilisé hors de AWS Glue.
## Création d’une offre groupée du plug-in pour vos applications Spark
Vous pouvez intégrer le plug-in à vos applications et distributions Spark (versions 3.1 et supérieures) en ajoutant la dépendance du plug-in dans votre fichier `pom.xml` Maven, tout en développant vos applications Spark en local. Pour plus d’informations sur les versions du plug-in et de Spark, consultez [Versions du plug-in](#cloud-shuffle-storage-plugin-versions).
```
...
aws-glue-etl-artifacts
https://aws-glue-etl-artifacts.s3.amazonaws.com/release/
...
com.amazonaws
chopper-plugin
3.1-amzn-LATEST
```
Vous pouvez également télécharger les fichiers binaires directement depuis les artefacts AWS Glue Maven et les inclure dans votre application Spark comme suit.
```
#!/bin/bash
sudo wget -v https://aws-glue-etl-artifacts.s3.amazonaws.com/release/com/amazonaws/chopper-plugin/3.1-amzn-LATEST/chopper-plugin-3.1-amzn-LATEST.jar -P /usr/lib/spark/jars/
```
Exemple d’utilisation de spark-submit
```
spark-submit --deploy-mode cluster \
--conf spark.shuffle.storage.s3.path=s3:/// \
--conf spark.driver.extraClassPath= \
--conf spark.executor.extraClassPath= \
--class s3:/// \
```
## Configurations facultatives
Il s’agit de valeurs de configuration facultatives qui contrôlent le comportement de lecture aléatoire d’Amazon S3.
+ `spark.shuffle.storage.s3.enableServerSideEncryption`: Enable/disable S3 SSE pour les fichiers shuffle et spill. La valeur par défaut est `true`.
+ `spark.shuffle.storage.s3.serverSideEncryption.algorithm` : algorithme SSE à utiliser. La valeur par défaut est `AES256`.
+ `spark.shuffle.storage.s3.serverSideEncryption.kms.key` : ARN de la clé KMS lorsque SSE aws:kms est activé.
Outre ces configurations, vous devrez peut-être définir des configurations telles que `spark.hadoop.fs.s3.enableServerSideEncryption` et **d’autres configurations spécifiques à l’environnement** pour garantir que le chiffrement approprié est appliqué à votre cas d’utilisation.
## Versions du plug-in
Ce plugin est pris en charge pour les versions de Spark associées à chaque AWS Glue version. Le tableau suivant indique la AWS Glue version, la version de Spark et la version du plugin associée avec l'emplacement Amazon S3 du binaire logiciel du plugin.
| Version de l’AWS Glue | Version de Spark | Version du plug-in | Emplacement Amazon S3 |
| --- | --- | --- | --- |
| 3.0 | 3.1 | 3.1-amzn-LATEST | s3 ://aws-glue-etl-artifacts/release/com/amazonaws/chopper-plugin/3.1-amzn-0/chopper-Plugin-3.1-amzn-Latest.jar |
| 4.0 | 3.3 | 3.3-amzn-LATEST | s3 ://aws-glue-etl-artifacts/release/com/amazonaws/chopper-plugin/3.3-amzn-0/chopper-Plugin-3.3-amzn-latest.jar |
## Licence
Le fichier binaire logiciel de ce plug-in est concédé sous licence dans le cadre de la licence Apache-2.0.
# 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. |
# Résolution des problèmes liés à l'IA générative pour Apache Spark in AWS Glue
La résolution des problèmes liés à l'IA générative pour les tâches Apache Spark dans AWS Glue est une nouvelle fonctionnalité qui aide les ingénieurs de données et les scientifiques à diagnostiquer et à résoudre facilement les problèmes dans leurs applications Spark. En utilisant les technologies de machine learning et d’IA générative, cette fonctionnalité analyse les problèmes liés aux tâches Spark et fournit une analyse détaillée des causes profondes, ainsi que des recommandations pratiques pour les résoudre. Le dépannage génératif de l'IA pour Apache Spark est disponible pour les jobs exécutés sur AWS Glue version 4.0 ou supérieure.
| |
| --- |
| Transformez votre résolution des problèmes liés à Apache Spark grâce à notre agent de résolution des problèmes basé sur l'IA, qui prend désormais en charge tous les principaux modes de déploiement, notamment AWS Glue, Amazon EMR-, EC2 Amazon EMR-Serverless et Amazon AI Notebooks. SageMaker Ce puissant agent élimine les processus de débogage complexes en combinant des interactions en langage naturel, une analyse de la charge de travail en temps réel et des recommandations de code intelligent dans une expérience fluide. Pour plus de détails sur l'implémentation, reportez-vous à la section [Qu'est-ce que l'agent de résolution des problèmes Apache Spark pour Amazon EMR ?](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/spark-troubleshoot.html) Consultez la deuxième démonstration dans la section Exemples de [résolution des problèmes liés à l'utilisation de l'agent](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/spark-troubleshooting-using-troubleshooting-agent.html) de dépannage pour AWS Glue. |
## Comment fonctionne la Résolution des problèmes à l’aide de l’IA générative pour Apache Spark ?
Pour les tâches Spark qui ont échoué, Generative AI Troubleshooting analyse les métadonnées des tâches ainsi que les indicateurs et journaux précis associés à la signature d'erreur de votre tâche afin de générer une analyse des causes premières, et recommande des solutions spécifiques et les meilleures pratiques pour aider à remédier aux échecs de tâches.
## Configuration de la Résolution des problèmes à l’aide de l’IA générative pour Apache Spark pour vos tâches
### Configuration des autorisations IAM
L'octroi d'autorisations à l'utilisateur APIs utilisé par Spark Troubleshooting pour vos tâches dans AWS Glue nécessite les autorisations IAM appropriées. Vous pouvez obtenir des autorisations en associant la AWS politique personnalisée suivante à votre identité IAM (comme un utilisateur, un rôle ou un groupe).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:StartCompletion",
"glue:GetCompletion"
],
"Resource": [
"arn:aws:glue:*:*:completion/*",
"arn:aws:glue:*:*:job/*"
]
}
]
}
```
------
**Note**
APIs Les deux éléments suivants sont utilisés dans la politique IAM pour permettre cette expérience via la console AWS Glue Studio : `StartCompletion` et`GetCompletion`.
### Attribution d’autorisations
Pour activer l’accès, ajoutez des autorisations à vos utilisateurs, groupes ou rôles :
+ Pour les utilisateurs et les groupes dans IAM Identity Center : créez un ensemble d’autorisations. Suivez les instructions de la rubrique [Create a permission set](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtocreatepermissionset.html) du Guide de l’utilisateur IAM Identity Center.
+ Pour les utilisateurs gérés dans IAM via un fournisseur d’identité : créez un rôle pour la fédération d’identité. Pour plus d’informations, consultez [Creating a role for a third-party identity provider (federation)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp.html) dans le Guide de l’utilisateur IAM.
+ Pour les utilisateurs IAM : créez un rôel que votre utilisateur peut endosser. Suivez les instructions de la rubrique [Creating a role for an IAM user](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) du Guide de l’utilisateur IAM.
## Exécution d’une analyse de résolution des problèmes suite à l’échec de l’exécution d’une tâche
Vous pouvez accéder à la fonctionnalité de résolution des problèmes via plusieurs chemins dans la console AWS Glue. Voici la procédure de démarrage :
### Option 1 : depuis la page Liste des tâches
1. Ouvrez la console AWS Glue à 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. Recherchez votre tâche qui a échoué dans la liste des tâches.
1. Sélectionnez l’onglet **Exécutions** dans la section des informations de la tâche.
1. Cliquez sur la tâche qui a échoué et que vous souhaitez analyser.
1. Choisissez **Résoudre les problèmes avec l’IA** pour démarrer l’analyse.
1. Lorsque l’analyse de résolution des problèmes est terminée, vous pouvez consulter l’analyse des causes premières et les recommandations dans l’onglet **Analyse de résolution des problèmes** en bas de l’écran.
![\[Le GIF montre l’implémentation de bout en bout d’une exécution échouée et le dépannage avec la fonctionnalité IA en cours d’exécution.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/troubleshoot_spark_option_1_jobs_list.gif)
### Option 2 : utilisation de la page Surveillance de l’exécution des tâches
1. Accédez à la page de **Surveillance de l’exécution des tâches**.
1. Localisez l’exécution de votre tâche qui a échoué.
1. Choisissez le menu déroulant **Actions**.
1. Choisissez **Résoudre les problèmes avec l’IA**.
![\[Le GIF montre l’implémentation de bout en bout d’une exécution échouée et le dépannage avec la fonctionnalité IA en cours d’exécution.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/troubleshoot_spark_option_2_job_monitoring.gif)
### Option 3 : depuis la page Détails de l’exécution des tâches
1. Accédez à la page de détails de l’exécution de la tâche qui a échoué en cliquant sur **Afficher les détails** d’une exécution échouée dans l’onglet **Exécutions** ou en sélectionnant l’exécution de la tâche sur la page **Surveillance de l’exécution des tâches**.
1. Sur la page des détails de l’exécution des tâches, recherchez l’onglet **Analyse de dépannage**.
## Catégories de dépannage prises en charge
Ce service se concentre sur trois catégories principales de problèmes que les ingénieurs de données et les développeurs rencontrent fréquemment dans leurs applications Spark :
+ **Erreurs de configuration et d'accès aux ressources :** lors de l'exécution d'applications Spark dans AWS Glue, les erreurs de configuration des ressources et d'accès figurent parmi les problèmes les plus courants mais les plus difficiles à diagnostiquer. Ces erreurs se produisent souvent lorsque votre application Spark tente d'interagir avec AWS des ressources mais rencontre des problèmes d'autorisation, des ressources manquantes ou des problèmes de configuration.
+ **Problèmes de mémoire liés au pilote et à l’exécuteur Spark :** les erreurs liées à la mémoire dans les tâches Apache Spark peuvent être complexes à diagnostiquer et à résoudre. Ces erreurs se produisent souvent lorsque vos exigences en matière de traitement des données dépassent les ressources de mémoire disponibles, que ce soit sur le nœud du pilote ou les nœuds d’exécuteur.
+ **Problèmes de capacité du disque Spark : les** erreurs liées au stockage dans les tâches AWS Glue Spark apparaissent souvent lors d'opérations de remaniement, de fuite de données ou lors de transformations de données à grande échelle. Ces erreurs peuvent être particulièrement délicates, car elles peuvent ne pas se manifester avant que votre tâche ne soit en cours d’exécution pendant une certaine durée, ce qui peut entraîner une perte de temps et de ressources de calcul précieux.
+ **Erreurs d'exécution des requêtes : les** échecs de requête dans Spark SQL et les DataFrame opérations peuvent être difficiles à résoudre car les messages d'erreur peuvent ne pas indiquer clairement la cause première, et les requêtes qui fonctionnent correctement avec de petits ensembles de données peuvent soudainement échouer à grande échelle. Ces erreurs deviennent encore plus difficiles lorsqu'elles se produisent au cœur de pipelines de transformation complexes, où le véritable problème peut être dû à des problèmes de qualité des données survenus aux étapes précédentes plutôt qu'à la logique de requête elle-même.
**Note**
Avant de mettre en œuvre les modifications suggérées dans votre environnement de production, examinez-les attentivement. Le service fournit des recommandations basées sur des modèles et des bonnes pratiques, mais votre cas d’utilisation spécifique peut nécessiter des considérations supplémentaires.
## Régions prises en charge
Le dépannage génératif de l'IA pour Apache Spark est disponible dans les régions suivantes :
+ **Afrique** : Le Cap (af-south-1)
+ **Asie-Pacifique** : Hong Kong (ap-east-1), Tokyo (ap-northeast-1), Séoul (ap-northeast-2), Osaka (ap-northeast-3), Mumbai (ap-south-1), Singapour (ap-southeast-1) ap-southeast-1), Sydney (ap-southeast-2) et Jakarta (ap-southeast-3)
+ **Europe** : Francfort (eu-central-1), Stockholm (eu-nord-1), Milan (eu-sud-1), Irlande (eu-west-1), Londres (eu-west-2) et Paris (eu-west-3)
+ **Moyen-Orient** : Bahreïn (me-south-1) et Émirats arabes unis (me-central-1)
+ **Amérique du** Nord : Canada (ca-central-1)
+ **Amérique du Sud** : São Paulo (sa-east-1)
+ **États-Unis** : Virginie du Nord (us-east-1), Ohio (us-east-2), Californie du Nord (us-west-1) et Oregon (us-west-2)
# Utilisation de vues matérialisées avec Glue AWS
AWS Les versions 5.1 et ultérieures de Glue permettent de créer et de gérer des vues matérialisées Apache Iceberg dans le catalogue de données AWS Glue. Une vue matérialisée est une table gérée qui stocke le résultat précalculé d'une requête SQL au format Apache Iceberg et qui est mise à jour progressivement à mesure que les tables sources sous-jacentes changent. Vous pouvez utiliser des vues matérialisées pour simplifier les pipelines de transformation des données et accélérer les performances des requêtes pour les charges de travail analytiques complexes.
Lorsque vous créez une vue matérialisée à l'aide de Spark in AWS Glue, la définition de la vue et les métadonnées sont stockées dans le catalogue de données AWS Glue. Les résultats précalculés sont stockés sous forme de tables Apache Iceberg dans des compartiments Amazon S3 Tables ou dans des compartiments à usage général Amazon S3 au sein de votre compte. Le catalogue de données AWS Glue surveille automatiquement les tables sources et actualise les vues matérialisées à l'aide d'une infrastructure informatique gérée.
**Topics**
+ [Comment fonctionnent les vues matérialisées avec Glue AWS](#materialized-views-how-they-work)
+ [Conditions préalables](#materialized-views-prerequisites)
+ [Configuration de Spark pour utiliser des vues matérialisées](#materialized-views-configuring-spark)
+ [Création de vues matérialisées](#materialized-views-creating)
+ [Interrogation de vues matérialisées](#materialized-views-querying)
+ [Actualisation de vues matérialisées](#materialized-views-refreshing)
+ [Gestion des vues matérialisées](#materialized-views-managing)
+ [Autorisations pour les vues matérialisées](#materialized-views-permissions)
+ [Surveillance des opérations de visualisation matérialisée](#materialized-views-monitoring)
+ [Exemple : flux de travail complet](#materialized-views-complete-workflow)
+ [Considérations et restrictions](#materialized-views-considerations-limitations)
## Comment fonctionnent les vues matérialisées avec Glue AWS
Les vues matérialisées s'intègrent à AWS Glue grâce au support Iceberg d'Apache Spark dans les tâches AWS Glue et les blocs-notes AWS Glue Studio. Lorsque vous configurez votre session Spark pour utiliser le catalogue de données AWS Glue, vous pouvez créer des vues matérialisées à l'aide de la syntaxe SQL standard. L'optimiseur Spark peut automatiquement réécrire les requêtes pour utiliser des vues matérialisées lorsqu'elles offrent de meilleures performances, éliminant ainsi le besoin de modifier manuellement le code de l'application.
Le catalogue de données AWS Glue gère tous les aspects opérationnels de la maintenance des vues matérialisées, notamment :
+ Détecter les modifications dans les tables sources à l'aide de la couche de métadonnées d'Apache Iceberg
+ Planification et exécution des opérations d'actualisation à l'aide du calcul géré par Spark
+ Déterminer s'il convient d'effectuer une actualisation complète ou incrémentielle en fonction des modifications apportées aux données
+ Stockage des résultats précalculés au format Apache Iceberg pour un accès multimoteur
Vous pouvez interroger des vues matérialisées à partir de AWS Glue en utilisant les mêmes interfaces SQL Spark que celles que vous utilisez pour les tables classiques. Les données précalculées sont également accessibles depuis d'autres services, notamment Amazon Athena et Amazon Redshift.
## Conditions préalables
Pour utiliser des vues matérialisées avec AWS Glue, vous devez :
+ Un compte
+ AWS Glue version 5.1 ou ultérieure
+ Tables sources au format Apache Iceberg enregistrées dans le catalogue de données AWS Glue
+ AWS Lake Formation autorisations configurées pour les tables sources et les bases de données cibles
+ Un bucket S3 Tables ou un bucket S3 à usage général enregistré auprès duquel sont AWS Lake Formation stockées des données de vue matérialisées
+ Rôle IAM autorisé à accéder à AWS Glue Data Catalog et à Amazon S3
## Configuration de Spark pour utiliser des vues matérialisées
Pour créer et gérer des vues matérialisées dans AWS Glue, configurez votre session Spark avec les extensions Iceberg et les paramètres de catalogue requis. La méthode de configuration varie selon que vous utilisez des tâches AWS Glue ou des blocs-notes AWS Glue Studio.
### Configuration des tâches AWS Glue
Lorsque vous créez ou mettez à jour une tâche AWS Glue, ajoutez les paramètres de configuration suivants en tant que paramètres de tâche :
#### Pour seaux S3 Tables
```
job = glue.create_job(
Name='materialized-view-job',
Role='arn:aws:iam::111122223333:role/GlueServiceRole',
Command={
'Name': 'glueetl',
'ScriptLocation': 's3://amzn-s3-demo-bucket/scripts/mv-script.py',
'PythonVersion': '3'
},
DefaultArguments={
'--enable-glue-datacatalog': 'true',
'--conf': 'spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions '
'--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog '
'--conf spark.sql.catalog.glue_catalog.type=glue '
'--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse '
'--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 '
'--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 '
'--conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 ',
'--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true ',
'--conf spark.sql.catalog.s3t_catalog=org.apache.iceberg.spark.SparkCatalog '
'--conf spark.sql.catalog.s3t_catalog.type=glue '
'--conf spark.sql.catalog.s3t_catalog.glue.id=111122223333:s3tablescatalog/my-table-bucket ',
'--conf spark.sql.catalog.s3t_catalog.glue.account-id=111122223333 ',
'--conf spark.sql.catalog.s3t_catalog.glue.lakeformation-enabled=true ',
'--conf spark.sql.catalog.s3t_catalog.warehouse=s3://amzn-s3-demo-bucket/mv-warehouse '
'--conf spark.sql.catalog.s3t_catalog.glue.region=us-east-1 '
'--conf spark.sql.defaultCatalog=s3t_catalog '
'--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true '
'--conf spark.sql.materializedViews.metadataCache.enabled=true'
},
GlueVersion='5.1'
)
```
#### Pour les godets à usage général S3
```
job = glue.create_job(
Name='materialized-view-job',
Role='arn:aws:iam::111122223333:role/GlueServiceRole',
Command={
'Name': 'glueetl',
'ScriptLocation': 's3://amzn-s3-demo-bucket/scripts/mv-script.py',
'PythonVersion': '3'
},
DefaultArguments={
'--enable-glue-datacatalog': 'true',
'--conf': 'spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions '
'--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog '
'--conf spark.sql.catalog.glue_catalog.type=glue '
'--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse '
'--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 '
'--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 ',
'--conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 ',
'--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true ',
'--conf spark.sql.defaultCatalog=glue_catalog '
'--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true '
'--conf spark.sql.materializedViews.metadataCache.enabled=true'
},
GlueVersion='5.1'
)
```
### Configuration des blocs-notes AWS Glue Studio
Dans les blocs-notes AWS Glue Studio, configurez votre session Spark à l'aide de la commande magique %%configure au début de votre bloc-notes :
```
%%configure
{
"conf": {
"spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions",
"spark.sql.catalog.glue_catalog": "org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.glue_catalog.type": "glue",
"spark.sql.catalog.glue_catalog.warehouse": "s3://amzn-s3-demo-bucket/warehouse",
"spark.sql.catalog.glue_catalog.glue.region": "us-east-1",
"spark.sql.catalog.glue_catalog.glue.id": "111122223333",
"spark.sql.catalog.glue_catalog.glue.account-id": "111122223333",
"spark.sql.catalog.glue_catalog.glue.lakeformation-enabled": "true",
"spark.sql.defaultCatalog": "glue_catalog",
"spark.sql.optimizer.answerQueriesWithMVs.enabled": "true",
"spark.sql.materializedViews.metadataCache.enabled": "true"
}
}
```
### Activation de l'actualisation incrémentielle
Pour activer l'optimisation de l'actualisation incrémentielle, ajoutez les propriétés de configuration suivantes aux paramètres de votre tâche ou à la configuration de votre bloc-notes :
```
--conf spark.sql.optimizer.incrementalMVRefresh.enabled=true
--conf spark.sql.optimizer.incrementalMVRefresh.deltaThresholdCheckEnabled=false
```
### Paramètres de configuration
Les paramètres de configuration suivants contrôlent le comportement des vues matérialisées :
+ `spark.sql.extensions`— Active les extensions de session Iceberg Spark requises pour la prise en charge des vues matérialisées.
+ `spark.sql.optimizer.answerQueriesWithMVs.enabled`— Permet la réécriture automatique des requêtes pour utiliser des vues matérialisées. Définissez ce paramètre sur true pour activer cette optimisation.
+ `spark.sql.materializedViews.metadataCache.enabled`— Active la mise en cache des métadonnées des vues matérialisées pour l'optimisation des requêtes. Définissez ce paramètre sur true pour améliorer les performances de réécriture des requêtes.
+ `spark.sql.optimizer.incrementalMVRefresh.enabled`— Permet une optimisation de l'actualisation incrémentielle. Définissez cette valeur sur true pour traiter uniquement les données modifiées lors des opérations d'actualisation.
+ `spark.sql.optimizer.answerQueriesWithMVs.decimalAggregateCheckEnabled`— Contrôle la validation des opérations d'agrégation décimale lors de la réécriture des requêtes. Définissez cette valeur sur false pour désactiver certains contrôles de dépassement de décimales.
## Création de vues matérialisées
Vous créez des vues matérialisées à l'aide de l'instruction SQL CREATE MATERIALIZED VIEW dans les jobs ou les AWS blocs-notes Glue. La définition de la vue spécifie la logique de transformation sous la forme d'une requête SQL qui fait référence à une ou plusieurs tables sources.
### Création d'une vue matérialisée de base dans les tâches AWS Glue
L'exemple suivant montre comment créer une vue matérialisée dans un script de tâche AWS Glue. Utilisez des noms de table complets avec une convention de dénomination en trois parties dans la définition de la vue :
```
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
# Create materialized view
spark.sql("""
CREATE MATERIALIZED VIEW customer_orders
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name
""")
```
### Création d'une vue matérialisée avec actualisation automatique
Pour configurer l'actualisation automatique, spécifiez un calendrier d'actualisation lors de la création de la vue, en utilisant des noms de table complets avec une convention de dénomination en trois parties dans la définition de la vue :
```
spark.sql("""
CREATE MATERIALIZED VIEW customer_orders
SCHEDULE REFRESH EVERY 1 HOUR
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name
""")
```
### Création d'une vue matérialisée avec des références croisées à des catalogues
Lorsque vos tables sources se trouvent dans un catalogue différent de celui de votre vue matérialisée, utilisez des noms de table complets avec une convention de dénomination en trois parties à la fois dans le nom de la vue et dans la définition de la vue :
```
spark.sql("""
CREATE MATERIALIZED VIEW s3t_catalog.analytics.customer_summary
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name
""")
```
### Création de vues matérialisées dans les blocs-notes AWS Glue Studio
Dans les blocs-notes AWS Glue Studio, vous pouvez utiliser la commande magique %%sql pour créer des vues matérialisées, en utilisant des noms de table complets avec une convention de dénomination en trois parties pour la définition des vues :
```
%%sql
CREATE MATERIALIZED VIEW customer_orders
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name
```
## Interrogation de vues matérialisées
Après avoir créé une vue matérialisée, vous pouvez l'interroger comme n'importe quelle autre table à l'aide des instructions SQL SELECT standard dans vos jobs AWS Glue ou vos carnets de notes.
### Effectuer des requêtes dans AWS Glue Jobs
```
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
# Query materialized view
result = spark.sql("SELECT * FROM customer_orders")
result.show()
```
### Effectuer des requêtes dans les AWS blocs-notes Glue Studio
```
%%sql
SELECT * FROM customer_orders
```
### Réécriture automatique des requêtes
Lorsque la réécriture automatique des requêtes est activée, l'optimiseur Spark analyse vos requêtes et utilise automatiquement des vues matérialisées lorsqu'elles peuvent améliorer les performances. Par exemple, si vous exécutez la requête suivante :
```
result = spark.sql("""
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM orders
GROUP BY customer_name
""")
```
L'optimiseur Spark réécrit automatiquement cette requête pour utiliser la vue matérialisée customer\$1orders au lieu de traiter la table des commandes de base, à condition que la vue matérialisée soit à jour.
### Vérification de la réécriture automatique des requêtes
Pour vérifier si une requête utilise la réécriture automatique des requêtes, utilisez la commande EXPLAIN EXTENDED :
```
spark.sql("""
EXPLAIN EXTENDED
SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount
FROM orders
GROUP BY customer_name
""").show(truncate=False)
```
Dans le plan d'exécution, recherchez le nom de la vue matérialisée dans l' BatchScan opération. Si le plan affiche BatchScan glue\$1catalog.analytics.customer\$1orders au lieu de glue\$1catalog.sales.orders, la requête a été automatiquement réécrite pour BatchScan utiliser la vue matérialisée.
Notez que la réécriture automatique des requêtes nécessite du temps pour que le cache de métadonnées Spark soit rempli après la création d'une vue matérialisée. Ce processus se termine généralement en 30 secondes.
## Actualisation de vues matérialisées
Vous pouvez actualiser les vues matérialisées à l'aide de deux méthodes : actualisation complète ou actualisation incrémentielle. L'actualisation complète recalcule l'intégralité de la vue matérialisée à partir de toutes les données de la table de base, tandis que l'actualisation incrémentielle traite uniquement les données modifiées depuis la dernière actualisation.
### Actualisation complète manuelle dans les tâches AWS Glue
Pour actualiser complètement une vue matérialisée :
```
spark.sql("REFRESH MATERIALIZED VIEW customer_orders FULL")
# Verify updated results
result = spark.sql("SELECT * FROM customer_orders")
result.show()
```
### Actualisation incrémentielle manuelle dans les tâches AWS Glue
Pour effectuer une actualisation incrémentielle, assurez-vous que l'actualisation incrémentielle est activée dans la configuration de votre session Spark, puis exécutez :
```
spark.sql("REFRESH MATERIALIZED VIEW customer_orders")
# Verify updated results
result = spark.sql("SELECT * FROM customer_orders")
result.show()
```
Le catalogue de données AWS Glue détermine automatiquement si une actualisation incrémentielle est applicable en fonction de la définition de la vue et de la quantité de données modifiées. Si l'actualisation incrémentielle n'est pas possible, l'opération revient à une actualisation complète.
### Rafraîchissant dans les blocs-notes AWS Glue Studio
Dans les ordinateurs portables, utilisez la commande magique %%sql :
```
%%sql
REFRESH MATERIALIZED VIEW customer_orders FULL
```
### Vérification de l'exécution de l'actualisation incrémentielle
Pour confirmer que l'actualisation incrémentielle a bien été exécutée, activez la journalisation du débogage dans votre tâche AWS Glue :
```
from awsglue.context import GlueContext
from pyspark.context import SparkContext
import logging
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
# Enable debug logging
logger = logging.getLogger('org.apache.spark.sql')
logger.setLevel(logging.DEBUG)
# Execute refresh
spark.sql("REFRESH MATERIALIZED VIEW customer_orders")
```
Recherchez le message suivant dans les journaux des tâches de AWS Glue :
```
DEBUG RefreshMaterializedViewExec: Executed Incremental Refresh
```
## Gestion des vues matérialisées
AWS Glue fournit des commandes SQL pour gérer le cycle de vie des vues matérialisées dans vos tâches et carnets de notes.
### Décrire une vue matérialisée
Pour afficher les métadonnées relatives à une vue matérialisée, notamment sa définition, son état d'actualisation et l'horodatage de la dernière actualisation :
```
spark.sql("DESCRIBE EXTENDED customer_orders").show(truncate=False)
```
### Modification d'une vue matérialisée
Pour modifier le calendrier d'actualisation d'une vue matérialisée existante :
```
spark.sql("""
ALTER MATERIALIZED VIEW customer_orders
ADD SCHEDULE REFRESH EVERY 2 HOURS
""")
```
Pour supprimer l'actualisation automatique :
```
spark.sql("""
ALTER MATERIALIZED VIEW customer_orders
DROP SCHEDULE
""")
```
### Supprimer une vue matérialisée
Pour supprimer une vue matérialisée :
```
spark.sql("DROP MATERIALIZED VIEW customer_orders")
```
Cette commande supprime la définition de la vue matérialisée du catalogue de données AWS Glue et supprime les données de la table Iceberg sous-jacente de votre compartiment S3.
### Répertorier les vues matérialisées
Pour répertorier toutes les vues matérialisées d'une base de données :
```
spark.sql("SHOW VIEWS FROM analytics").show()
```
## Autorisations pour les vues matérialisées
Pour créer et gérer des vues matérialisées, vous devez configurer AWS Lake Formation les autorisations. Le rôle IAM qui crée la vue matérialisée (le rôle de définition) nécessite des autorisations spécifiques sur les tables sources et les bases de données cibles.
### Autorisations requises pour le rôle de définisseur
Le rôle de définition doit disposer des autorisations Lake Formation suivantes :
+ Sur les tables sources : autorisations SELECT ou ALL sans filtres de ligne, de colonne ou de cellule
+ Sur la base de données cible : autorisation CREATE\$1TABLE
+ Sur le catalogue AWS de données Glue GetTable et les autorisations CreateTable d'API
Lorsque vous créez une vue matérialisée, l'ARN du rôle de définition est stocké dans la définition de la vue. Le catalogue de données AWS Glue assume ce rôle lorsqu'il exécute des opérations d'actualisation automatique. Si le rôle de définition perd l'accès aux tables sources, les opérations d'actualisation échoueront tant que les autorisations ne seront pas restaurées.
### Autorisations IAM pour les tâches AWS Glue
Le rôle IAM de votre tâche AWS Glue nécessite les autorisations suivantes :
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetCatalog",
"glue:GetCatalogs",
"glue:GetTable",
"glue:GetTables",
"glue:CreateTable",
"glue:UpdateTable",
"glue:DeleteTable",
"glue:GetDatabase",
"glue:GetDatabases",
"cloudwatch:PutMetricData"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket"
]
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:*:*:*:/aws-glue/*"
]
},
{
"Effect": "Allow",
"Action": [
"lakeformation:GetDataAccess"
],
"Resource": "*"
}
]
}
```
Le rôle que vous utilisez pour l'actualisation automatique de Materialized View doit disposer de l'PassRole autorisation iam : sur le rôle.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/materialized-view-role-name"
]
}
]
}
```
Pour que Glue actualise automatiquement la vue matérialisée pour vous, le rôle doit également respecter la politique de confiance suivante qui permet au service d'assumer le rôle.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/materialized-view-role-name"
]
}
]
}
```
Si la vue matérialisée est stockée dans des compartiments de tables S3, vous devez également ajouter l'autorisation suivante au rôle.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3tables:PutTableMaintenanceConfiguration"
],
"Resource": "arn:aws:s3tables:*:123456789012:*"
}
]
}
```
### Octroi de l'accès aux vues matérialisées
Pour autoriser d'autres utilisateurs à interroger une vue matérialisée, accordez l' AWS Lake Formation autorisation SELECT sur la table des vues matérialisées. Les utilisateurs peuvent interroger la vue matérialisée sans avoir besoin d'accéder directement aux tables sources sous-jacentes.
Pour des informations détaillées sur la configuration des autorisations de Lake Formation, consultez la section Octroi et révocation d'autorisations sur les ressources du catalogue de données dans le manuel du AWS Lake Formation développeur.
## Surveillance des opérations de visualisation matérialisée
Le AWS Glue Data Catalog publie des statistiques et des journaux pour les opérations d'actualisation des vues matérialisées sur Amazon CloudWatch. Vous pouvez surveiller l'état, la durée et le volume de données traités par le biais de CloudWatch métriques d'actualisation.
### Afficher les journaux des tâches
Pour consulter les journaux des tâches AWS Glue qui créent ou actualisent des vues matérialisées, procédez comme suit :
1. Ouvrez la console AWS Glue.
1. Choisissez Jobs dans le volet de navigation.
1. Sélectionnez votre tâche et choisissez Runs.
1. Sélectionnez une exécution spécifique et choisissez Logs pour afficher CloudWatch les journaux.
### Configuration des alarmes
Pour recevoir des notifications lorsque les opérations d'actualisation échouent ou dépassent la durée prévue, créez des CloudWatch alarmes sur les métriques des vues matérialisées. Vous pouvez également configurer les EventBridge règles Amazon pour déclencher des réponses automatisées afin d'actualiser les événements.
## Exemple : flux de travail complet
L'exemple suivant illustre un flux de travail complet pour créer et utiliser une vue matérialisée dans AWS Glue.
### Exemple de script AWS de tâche Glue
```
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
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)
# Create database and base table
spark.sql("CREATE DATABASE IF NOT EXISTS sales")
spark.sql("USE sales")
spark.sql("""
CREATE TABLE IF NOT EXISTS orders (
id INT,
customer_name STRING,
amount DECIMAL(10,2),
order_date DATE
)
""")
# Insert sample data
spark.sql("""
INSERT INTO orders VALUES
(1, 'John Doe', 150.00, DATE('2024-01-15')),
(2, 'Jane Smith', 200.50, DATE('2024-01-16')),
(3, 'Bob Johnson', 75.25, DATE('2024-01-17'))
""")
# Create materialized view
spark.sql("""
CREATE MATERIALIZED VIEW customer_summary
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name
""")
# Query the materialized view
print("Initial materialized view data:")
spark.sql("SELECT * FROM customer_summary").show()
# Insert additional data
spark.sql("""
INSERT INTO orders VALUES
(4, 'Jane Smith', 350.00, DATE('2024-01-18')),
(5, 'Bob Johnson', 100.25, DATE('2024-01-19'))
""")
# Refresh the materialized view
spark.sql("REFRESH MATERIALIZED VIEW customer_summary FULL")
# Query updated results
print("Updated materialized view data:")
spark.sql("SELECT * FROM customer_summary").show()
job.commit()
```
### Exemple de bloc-notes AWS Glue Studio
```
%%configure
{
"conf": {
"spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions",
"spark.sql.catalog.glue_catalog": "org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.glue_catalog.type": "glue",
"spark.sql.catalog.glue_catalog.warehouse": "s3://amzn-s3-demo-bucket/warehouse",
"spark.sql.catalog.glue_catalog.glue.region": "us-east-1",
"spark.sql.catalog.glue_catalog.glue.id": "111122223333",
"spark.sql.catalog.glue_catalog.glue.account-id": "111122223333",
"spark.sql.catalog.glue_catalog.glue.lakeformation-enabled": "true",
"spark.sql.defaultCatalog": "glue_catalog",
"spark.sql.optimizer.answerQueriesWithMVs.enabled": "true",
"spark.sql.materializedViews.metadataCache.enabled": "true"
}
}
```
```
%%sql
CREATE DATABASE IF NOT EXISTS sales
```
```
%%sql
USE sales
```
```
%%sql
CREATE TABLE IF NOT EXISTS orders (
id INT,
customer_name STRING,
amount DECIMAL(10,2),
order_date DATE
)
```
```
%%sql
INSERT INTO orders VALUES
(1, 'John Doe', 150.00, DATE('2024-01-15')),
(2, 'Jane Smith', 200.50, DATE('2024-01-16')),
(3, 'Bob Johnson', 75.25, DATE('2024-01-17'))
```
```
%%sql
CREATE MATERIALIZED VIEW customer_summary
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name
```
```
%%sql
SELECT * FROM customer_summary
```
```
%%sql
INSERT INTO orders VALUES
(4, 'Jane Smith', 350.00, DATE('2024-01-18')),
(5, 'Bob Johnson', 100.25, DATE('2024-01-19'))
```
```
%%sql
REFRESH MATERIALIZED VIEW customer_summary FULL
```
```
%%sql
SELECT * FROM customer_summary
```
## Considérations et restrictions
Lorsque vous utilisez des vues matérialisées avec AWS Glue, tenez compte des points suivants :
+ Les vues matérialisées nécessitent AWS la version 5.1 ou ultérieure de Glue.
+ Les tables sources doivent être des tables Apache Iceberg enregistrées dans le catalogue de données AWS Glue. Les tables Apache Hive, Apache Hudi et Linux Foundation Delta Lake ne sont pas prises en charge au lancement.
+ Les tables sources doivent résider dans la même région et dans le même compte que la vue matérialisée.
+ Toutes les tables sources doivent être régies par AWS Lake Formation. Les autorisations IAM uniquement et l'accès hybride ne sont pas pris en charge.
+ Les vues matérialisées ne peuvent pas faire référence aux vues AWS Glue Data Catalog, aux vues multidialectes ou à d'autres vues matérialisées en tant que tables sources.
+ Le rôle de définition de vues doit disposer d'un accès complet en lecture (autorisation SELECT ou ALL) sur toutes les tables sources sans appliquer de filtres de ligne, de colonne ou de cellule.
+ Les vues matérialisées sont finalement cohérentes avec les tables sources. Pendant la fenêtre d'actualisation, les requêtes peuvent renvoyer des données périmées. Exécutez une actualisation manuelle pour une cohérence immédiate.
+ L'intervalle d'actualisation automatique minimum est d'une heure.
+ L'actualisation incrémentielle prend en charge un sous-ensemble restreint d'opérations SQL. La définition de la vue doit être un seul bloc SELECT-FROM-WHERE-GROUP BY-HAVING et ne peut pas contenir d'opérations définies, de sous-requêtes, le mot clé DISTINCT dans SELECT ou de fonctions d'agrégation, de fonctions de fenêtre ou de jointures autres que INNER JOIN.
+ L'actualisation incrémentielle ne prend pas en charge les fonctions définies par l'utilisateur ni certaines fonctions intégrées. Seul un sous-ensemble des fonctions intégrées de Spark SQL est pris en charge.
+ La réécriture automatique des requêtes ne prend en compte que les vues matérialisées dont les définitions appartiennent à un sous-ensemble SQL restreint similaire aux restrictions d'actualisation incrémentielle.
+ Les identifiants contenant des caractères spéciaux autres que des caractères alphanumériques et des traits de soulignement ne sont pas pris en charge dans les requêtes CREATE MATERIALIZED VIEW. Cela s'applique à tous les types d'identifiant, y compris les catalog/namespace/table noms, les noms de colonnes et de champs de structure CTEs, ainsi que les alias.
+ Les colonnes de vues matérialisées commençant par le préfixe \$1\$1ivm sont réservées à l'utilisation du système. Amazon se réserve le droit de modifier ou de supprimer ces colonnes dans les futures versions.
+ Les clauses SORT BY, LIMIT, OFFSET, CLUSTER BY et ORDER BY ne sont pas prises en charge dans les définitions de vues matérialisées.
+ Les tables sources entre régions et entre comptes ne sont pas prises en charge.
+ Les tables référencées dans la requête de vue doivent utiliser une convention de dénomination en trois parties (par exemple, glue\$1catalog.my\$1db.my\$1table) car l'actualisation automatique n'utilise pas les paramètres de catalogue et de base de données par défaut.
+ Les opérations d'actualisation complète remplacent l'intégralité du tableau et rendent les instantanés précédents indisponibles.
+ Les fonctions non déterministes telles que rand () ou current\$1timestamp () ne sont pas prises en charge dans les définitions de vues matérialisées.
# AWS Glue types de travailleurs
## Présentation de
AWS Glue propose plusieurs types de travailleurs pour répondre aux différentes exigences de charge de travail, qu'il s'agisse de petites tâches de streaming ou de tâches de traitement de données à grande échelle nécessitant beaucoup de mémoire. Cette section fournit des informations complètes sur tous les types de travailleurs disponibles, leurs spécifications et les recommandations d’utilisation.
### Catégories de types de travailleur
AWS Glue propose deux catégories principales de types de travailleurs :
+ **Types de travailleurs G** : travailleurs de calcul polyvalents optimisés pour les charges de travail ETL standard
+ **Types de travailleurs R** : travailleurs optimisés pour la mémoire conçus pour les applications Spark gourmandes en mémoire
### Unités de traitement de données (DPUs)
Les ressources disponibles pour les AWS Glue travailleurs sont mesurées en DPUs. Un DPU est une mesure relative de la puissance de traitement composée de 4 V de capacité CPUs de calcul et de 16 Go de mémoire.
**Optimisé pour la mémoire DPUs (M-DPUs) :** les travailleurs de type R utilisent M-DPUs, qui fournit le double de l'allocation de mémoire pour une taille donnée par rapport à la norme. DPUs Cela signifie qu’alors qu’une DPU standard fournit 16 Go de mémoire, une M-DPU dans des travailleurs de type R fournit 32 Go de mémoire optimisée pour les applications Spark gourmandes en mémoire.
## Types de travailleurs disponibles
### G.1X
+ **DPU** : 1 DPU (4 VCPUs, 16 Go de mémoire)
+ **Stockage** : disque de 94 Go (environ 44 Go libres)
+ **Cas d’utilisation** : transformations, jointures et requêtes de données : évolutifs et économiques pour la plupart des tâches
### G.2X
+ **DPU** : 2 DPU (8 VCPUs, 32 Go de mémoire)
+ **Stockage** : disque de 138 Go (environ 78 Go libres)
+ **Cas d’utilisation** : transformations, jointures et requêtes de données : évolutifs et économiques pour la plupart des tâches
### G.4X
+ **Processeur :** 4 processeurs (16 VCPUs, 64 Go de mémoire)
+ **Stockage** : disque de 256 Go (environ 230 Go libres)
+ **Cas d’utilisation** : transformations, agrégations, jointures et requêtes exigeantes
### G.8X
+ **DPU** : 8 DPU (32 VCPUs, 128 Go de mémoire)
+ **Stockage** : disque de 512 Go (environ 485 Go libres)
+ **Cas d’utilisation** : transformations, agrégations, jointures et requêtes exigeantes
### G.12X
+ **DPU** : 12 DPU (48 VCPUs, 192 Go de mémoire)
+ **Stockage** : disque de 768 Go (environ 741 Go libres)
+ **Cas d’utilisation** : charges de travail très importantes et gourmandes en ressources nécessitant une capacité de calcul importante
### G.16X
+ **DPU** : 16 DPU (64 VCPUs, 256 Go de mémoire)
+ **Stockage** : disque de 1 024 Go (environ 996 Go libres)
+ **Cas d’utilisation** : charges de travail les plus importantes et gourmandes en ressources nécessitant une capacité de calcul maximale
### R.1X - Mémoire optimisée \$1
+ **DPU** : 1 M-DPU (4 VCPUs, 32 Go de mémoire)
+ **Cas d'utilisation** : charges de travail gourmandes en mémoire associées à des out-of-memory erreurs fréquentes ou à des exigences de ratio élevées memory-to-CPU
### R.2X - Mémoire optimisée \$1
+ **DPU** : 2 M-DPU (8 VCPUs, 64 Go de mémoire)
+ **Cas d'utilisation** : charges de travail gourmandes en mémoire associées à des out-of-memory erreurs fréquentes ou à des exigences de ratio élevées memory-to-CPU
### R.4X - Mémoire optimisée \$1
+ **DPU** : 4 M-DPU (16 VCPUs, 128 Go de mémoire)
+ **Cas d'utilisation** : grandes charges de travail gourmandes en mémoire avec des out-of-memory erreurs fréquentes ou des exigences de ratio élevées memory-to-CPU
### R.8X - Mémoire optimisée \$1
+ **DPU** : 8 M-DPU (32 VCPUs, 256 Go de mémoire)
+ **Cas d'utilisation** : très grandes charges de travail gourmandes en mémoire avec des out-of-memory erreurs fréquentes ou des exigences de ratio élevées memory-to-CPU
**\$1** Vous pouvez rencontrer une latence de démarrage plus élevée avec ces travailleurs. Pour résoudre ce problème, essayez ce qui suit :
+ Attendez quelques minutes et soumettez à nouveau votre tâche.
+ Soumettez une nouvelle tâche avec un nombre réduit de travailleurs.
+ Soumettez une nouvelle tâche en utilisant un type ou une taille de travailleur différents.
## Table de spécifications des types de travailleur
**Spécifications des types de travailleur**
| Type de travailleur | DPU par nœud | vCPU | Mémoire (Go) | Disque (Go) | Espace disque disponible approximatif (Go) | Exécuteurs Spark par nœud |
| --- | --- | --- | --- | --- | --- | --- |
| G.1X | 1 | 4 | 16 | 94 | 44 | 1 |
| G.2X | 2 | 8 | 32 | 138 | 78 | 1 |
| G.4X | 4 | 16 | 64 | 256 | 230 | 1 |
| G.8X | 8 | 32 | 128 | 512 | 485 | 1 |
| G.12X | 12 | 48 | 192 | 768 | 741 | 1 |
| G.16X | 16 | 64 | 256 | 1 024 | 996 | 1 |
| R.1 X | 1 | 4 | 32 | 94 | 44 | 1 |
| R.2X | 2 | 8 | 64 | 138 | 78 | 1 |
| R.4X | 4 | 16 | 128 | 256 | 230 | 1 |
| R.8X | 8 | 32 | 256 | 512 | 485 | 1 |
*Remarque* : Les types de travailleurs R ont des configurations optimisées pour la mémoire avec des spécifications optimisées pour les charges de travail gourmandes en mémoire.
## Considérations importantes
### Latence de démarrage
**Important**
Les types de travailleurs G.12X et G.16X, ainsi que tous les types de travailleurs R (R.1X à R.8X), peuvent subir une latence de démarrage plus élevée. Pour résoudre ce problème, essayez ce qui suit :
Attendez quelques minutes et soumettez à nouveau votre tâche.
Soumettez une nouvelle tâche avec un nombre réduit de travailleurs.
Soumettez une nouvelle tâche en utilisant un type et une taille de travailleur différents.
## Choix du type de travailleur approprié
### Pour les charges de travail ETL standard
+ **G.1X ou G.2X** : solution la plus rentable pour les transformations de données, les jointures et les requêtes classiques
+ **G.4X ou G.8X** : pour les charges de travail plus exigeantes avec des jeux de données plus volumineux
### Pour les charges de travail à grande échelle
+ **G.12X** : très grands jeux de données nécessitant d’importantes ressources de calcul
+ **G.16X** : capacité de calcul maximale pour les charges de travail les plus exigeantes
### Pour les charges de travail gourmandes en mémoire
+ **R.1X ou R.2X** : tâches gourmandes en mémoire de petite ou moyenne taille
+ **R.4X ou R.8X** : charges de travail gourmandes en mémoire, associées à des erreurs OOM fréquentes
## Considérations en matière d’optimisation des coûts
+ **Travailleurs G standard** : fournissent un équilibre entre les ressources de calcul, de mémoire et de mise réseau. Ils peuvent être utilisés pour diverses charges de travail à moindre coût.
+ **Travailleurs R** : spécialisés dans les tâches gourmandes en mémoire avec des performances rapides pour les charges de travail qui traitent de larges jeux de données en mémoire.
## Bonnes pratiques
### Consignes de sélection des travailleurs
1. **Commencez avec des travailleurs standard** (G.1X, G.2X) pour la plupart des charges de travail.
1. **Utilisez R Workers** en cas d' out-of-memoryerreurs ou de charges de travail fréquentes liées à des opérations gourmandes en mémoire telles que la mise en cache, le remaniement et l'agrégation
1. **Optez pour G.12X/G.16X** pour les charges de travail gourmandes en ressources informatiques nécessitant un maximum de ressources.
1. **Tenez compte des contraintes de capacité** lors de l’utilisation de nouveaux types de travailleurs dans des flux de travail urgents.
### Optimisation des performances
+ Surveillez CloudWatch les indicateurs pour comprendre l'utilisation des ressources
+ Utiliser un nombre de travailleurs approprié en fonction de la taille et de la complexité des données
+ Envisager des stratégies de partitionnement des données pour optimiser l’efficacité des travailleurs
# Tâches ETL en streaming dans AWS Glue
Vous pouvez créer des tâches Extract-transform-load (ETL) qui s’exécutent continu et consomment des données provenant de sources en streaming telles que Amazon Kinesis Data Streams, Apache Kafka et Amazon Managed Streaming pour Apache Kafka (Amazon MSK). Les tâches nettoient et transforment les données, puis chargent les résultats dans les lacs de données Amazon S3 ou les magasins de données JDBC.
En outre, vous pouvez produire des données pour des flux Amazon Kinesis Data Streams. Cette fonctionnalité n'est disponible que lors de l'écriture de AWS Glue scripts. Pour de plus amples informations, veuillez consulter [Connexions Kinesis](aws-glue-programming-etl-connect-kinesis-home.md).
Par défaut, AWS Glue traite et écrit les données dans des fenêtres de 100 secondes. Cela permet de traiter les données de manière efficace et d’effectuer des agrégations sur les données qui arrivent plus tard que prévu. Vous pouvez modifier cette taille de fenêtre temporelle pour augmenter la ponctualité ou la précision de l’agrégation. Les tâches de streaming AWS Glue utilisent des points de contrôle au lieu de signets de tâche pour suivre les données lues.
**Note**
AWS Glue facture à l’heure les tâches ETL en streaming.
Cette vidéo aborde les défis liés aux coûts du streaming ETL et les fonctionnalités de réduction des coûts dans AWS Glue.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/6ggTFOtfUxU)
La création d’une tâche ETL en streaming implique les étapes suivantes :
1. Pour une source de streaming Apache Kafka, créez une connection AWS Glue à la source Kafka ou au cluster Amazon MSK.
1. Créez manuellement une table du catalogue de données pour la source en streaming.
1. Créez une tâche ETL pour la source de données de streaming. Définissez des propriétés de tâche spécifiques au streaming et fournissez votre propre script ou modifiez éventuellement le script généré.
Pour de plus amples informations, consulter [Streaming d'ETL en AWS Glue](components-overview.md#streaming-etl-intro).
Lorsque vous créez une tâche ETL en streaming pour Amazon Kinesis Data Streams, vous n’avez pas besoin de créer une connexion AWS Glue. Toutefois, s’il existe une connexion attachée à la tâche ETL AWS Glue en streaming pointant sur une source Kinesis Data Streams, puis un point de terminaison de Virtual Private Cloud (VPC) vers Kinesis est requis. Pour plus d’informations, consultez [Création d’un point de terminaison d’interface](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#create-interface-endpoint) dans le *Guide de l’utilisateur Amazon VPC*. Lorsque vous spécifiez un Amazon Kinesis Data Streams dans un autre compte, vous devez configurer les rôles et les stratégies pour autoriser l’accès entre comptes. Pour de plus amples informations, veuillez consulter la rubrique [Exemple : Lire à partir d’un flux Kinesis dans un autre compte](https://docs.aws.amazon.com/kinesisanalytics/latest/java/examples-cross.html).
Les tâches ETL de streaming AWS Glue peuvent détecter automatiquement les données compressées, décompresser les données de streaming de manière transparente, effectuer les modifications habituelles sur la source d’entrée et charger vers le stockage de sortie.
AWS Glue prend en charge la décompression automatique pour les types de compression suivants, compte tenu du format d’entrée :
| Type de compression | Fichier Avro | Référence Avro | JSON | CSV | Grok |
| --- | --- | --- | --- | --- | --- |
| BZIP2 | Oui | Oui | Oui | Oui | Oui |
| GZIP | Non | Oui | Oui | Oui | Oui |
| SNAPPY | Oui (format Snappy brut) | Oui (format Snappy encadré) | Oui (format Snappy encadré) | Oui (format Snappy encadré) | Oui (format Snappy encadré) |
| XZ | Oui | Oui | Oui | Oui | Oui |
| ZSTD | Oui | Non | Non | Non | Non |
| DEFLATE | Oui | Oui | Oui | Oui | Oui |
**Topics**
+ [Création d’une connexion AWS Glue pour un flux de données Apache Kafka](#create-conn-streaming)
+ [Création d’un tableau de catalogue de données pour une source en streaming](#create-table-streaming)
+ [Notes et restrictions pour les sources en streaming Avro](#streaming-avro-notes)
+ [Application de modèles Grok à des sources de streaming](#create-table-streaming-grok)
+ [Définition des propriétés de tâche pour une tâche ETL en streaming](#create-job-streaming-properties)
+ [Restrictions et notes sur ETL en streaming](#create-job-streaming-restrictions)
## Création d’une connexion AWS Glue pour un flux de données Apache Kafka
Pour lire à partir d’un flux Apache Kafka, vous devez créer une connexion AWS Glue.
**Pour créer une connexion AWS Glue pour une source Kafka (Console)**
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, sous **Data catalog (Catalogue de données)**, choisissez **Connections (Connexions)**.
1. Choisissez **Add connection (Ajouter une connexion)**, et dans la page **Set up your connection’s properties (Configurer les propriétés de votre connexion)**, saisissez un nom de connexion.
**Note**
Pour plus d’informations sur la spécification des propriétés de connexion, veuillez consulter [Propriétés de connexion AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-connections).
1. Pour **Type de connexion**, choisissez **Kafka**.
1. Pour les **serveurs bootstrap Kafka URLs**, entrez l'hôte et le numéro de port des courtiers bootstrap pour votre cluster Amazon MSK ou votre cluster Apache Kafka. Utilisez uniquement des points de terminaison utilisant le protocole TLS (Transport Layer Security) pour établir la connexion initiale au cluster Kafka. Les points de terminaison en texte brut ne sont pas pris en charge.
Voici un exemple de liste de paires de nom d’hôte et de numéro de port pour un cluster Amazon MSK.
```
myserver1.kafka.us-east-1.amazonaws.com:9094,myserver2.kafka.us-east-1.amazonaws.com:9094,
myserver3.kafka.us-east-1.amazonaws.com:9094
```
Pour plus d’informations sur l’obtention des informations du broker d’amorçage, veuillez consulter la rubrique [Obtenir les brokers d’amorçage pour un cluster Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/msk-get-bootstrap-brokers.html) dans le *Guide du développeur Amazon Managed Streaming for Apache Kafka*.
1. Si vous souhaitez une connexion sécurisée à la source de données Kafka, sélectionnez **Require SSL connection (Connexion SSL obligatoire)**, et pour **Kafka private CA certificate location (Emplacement du certificat d’autorité de certification privée Kafka)**, entrez un chemin d’accès Amazon S3 valide vers un certificat SSL personnalisé.
Pour une connexion SSL à Kafka autogérée, le certificat personnalisé est obligatoire. Il est facultatif pour Amazon MSK.
Pour plus d’informations sur la spécification d’un certificat personnalisé pour Kafka, consulter [AWS Glue Propriétés de connexion SSL](connection-properties.md#connection-properties-SSL).
1. Utilisez AWS Glue Studio la AWS CLI pour spécifier une méthode d'authentification du client Kafka. Pour y accéder, AWS Glue Studio **AWS Glue**sélectionnez dans le menu **ETL** du volet de navigation de gauche.
Pour plus d’informations sur les méthodes d’authentification client Kafka, consultez [AWS Glue Propriétés de connexion Kafka pour l’authentification du client](#connection-properties-kafka-client-auth).
1. Saisissez éventuellement une description, puis choisissez **Suivant**.
1. Pour un cluster Amazon MSK, spécifiez son Virtual Private Cloud (VPC), son sous-réseau et son groupe de sécurité. Les informations du VPC sont facultatives pour Kafka autogéré.
1. Choisissez **Next** (Suivant) pour vérifier toutes les propriétés de connexion, puis choisissez **Finish** (Terminer).
Pour plus d’informations sur les connexions AWS Glue, consultez [Connexion aux données](glue-connections.md).
### AWS Glue Propriétés de connexion Kafka pour l’authentification du client
**Authentification SASL/GSSAPI (Kerberos)**
Le choix de cette méthode d’authentification vous permettra de spécifier les propriétés Kerberos.
**Kerberos Keytab**
Choisissez l’emplacement du fichier keytab. Un keytab stocke les clés à long terme pour un ou plusieurs principaux. Pour en savoir plus, consultez [Documentation du MIT Kerberos : Keytab](https://web.mit.edu/kerberos/krb5-latest/doc/basic/keytab_def.html).
**Fichier Kerberos krb5.conf**
Choisissez le fichier krb5.conf. Il contient le domaine par défaut (un réseau logique, similaire à un domaine, qui définit un groupe de systèmes sous le même KDC) et l’emplacement du serveur KDC. Pour en savoir plus, consultez [Documentation MIT Kerberos : krb5.conf](https://web.mit.edu/kerberos/krb5-1.12/doc/admin/conf_files/krb5_conf.html).
**Principal Kerberos et nom de service Kerberos**
Saisissez le principal Kerberos et le nom de service Kerberos. Pour plus d’informations, consultez [MIT Kerberos Documentation: Kerberos principal](https://web.mit.edu/kerberos/krb5-1.5/krb5-1.5.4/doc/krb5-user/What-is-a-Kerberos-Principal_003f.html) (Documentation du MIT Kerberos : principal Kerberos).
**Authentification SASL/SCRAM-SHA-512**
Le choix de cette méthode d’authentification vous permettra de spécifier les informations d’identification d’authentification.
**AWS Secrets Manager**
Recherchez votre jeton dans la zone Search (Rechercher) en saisissant son nom ou son ARN.
**Nom d’utilisateur et mot de passe du fournisseur directement**
Recherchez votre jeton dans la zone Search (Rechercher) en saisissant son nom ou son ARN.
**Authentification SSL client**
Le choix de cette méthode d’authentification vous permet de sélectionner l’emplacement du centre de stockage des clés client Kafka en naviguant sur Amazon S3. Vous pouvez également entrer le mot de passe du centre de stockage des clés client Kafka et le mot de passe de la clé client Kafka.
**Authentification IAM**
Cette méthode d’authentification ne nécessite aucune spécification supplémentaire et n’est applicable que lorsque la source de diffusion en direct est MSK Kafka.
**Authentification SASL/PLAIN**
Le choix de cette méthode d’authentification vous permet de spécifier les informations d’identification d’authentification.
## Création d’un tableau de catalogue de données pour une source en streaming
Une table du catalogue de données qui spécifie les propriétés du flux de données source, y compris le schéma de données, peut être créée manuellement pour une source de streaming. Cette table est utilisée comme source de données pour la tâche ETL en streaming.
Si vous ne connaissez pas le schéma des données dans le flux de données source, vous pouvez créer la table sans schéma. Ensuite, lorsque vous créez la tâche ETL en streaming, vous pouvez activer la fonction de détection de schéma AWS Glue. AWS Gluedétermine le schéma à partir des données en streaming.
Utilisez la [AWS Glueconsole](https://console.aws.amazon.com/glue/), le AWS Command Line Interface (AWS CLI) ou l'AWS GlueAPI pour créer la table. Pour plus d’informations sur la création manuelle d’une table avec la console AWS Glue, consultez [Création de tables](tables-described.md).
**Note**
Vous ne pouvez pas utiliser la AWS Lake Formation console pour créer la table ; vous devez utiliser la AWS Glue console.
Tenez également compte des informations suivantes pour les sources en streaming au format Avro ou pour les données de journal auxquelles vous pouvez appliquer des modèles Grok.
+ [Notes et restrictions pour les sources en streaming Avro](#streaming-avro-notes)
+ [Application de modèles Grok à des sources de streaming](#create-table-streaming-grok)
**Topics**
+ [Source de données Kinesis](#kinesis-source)
+ [Source de données Kafka](#kafka-source)
+ [Source AWS Glue de la table Schema Registry](#schema-registry-table)
### Source de données Kinesis
Lors de la création de la table, définissez les propriétés de streaming ETL suivantes (console).
**Type de source**
**Kinesis**
**Pour une source Kinesis dans le même compte :**
**Région**
AWS Région dans laquelle réside le service Amazon Kinesis Data Streams. Le nom de la région et du flux Kinesis sont convertis en un ARN de flux.
Exemple : https://kinesis.us-east-1.amazonaws.com
**Nom du flux Kinesis**
Nom du flux comme décrit dans [Création d’un flux](https://docs.aws.amazon.com/streams/latest/dev/kinesis-using-sdk-java-create-stream.html) dans le *Guide du développeur d’Amazon Kinesis Data Streams*.
**Pour obtenir une source Kinesis dans un autre compte, reportez-vous à [Cet exemple](https://docs.aws.amazon.com/kinesisanalytics/latest/java/examples-cross.html) pour configurer les rôles et les stratégies pour autoriser un accès entre comptes. Configurez ces paramètres :**
**ARN du flux de diffusion**
ARN du flux de données Kinesis auprès duquel le consommateur est enregistré. Pour plus d'informations, consultez les [sections Amazon Resource Names (ARNs) et AWS Service Namespaces](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) dans le *Références générales AWS*.
**ARN du rôle assumé**
Amazon Resource Name (ARN) du rôle à assumer.
**Nom de la séance (facultatif)**
Identifiant de la séance du rôle assumé.
Utilisez le nom de séance de rôle pour identifier de manière unique une séance lorsque le même rôle est assumé par différents principaux ou pour différentes raisons. Dans les scénarios impliquant plusieurs comptes, le nom de séance de rôle est visible et peut être enregistré par le compte propriétaire du rôle. Le nom de la séance de rôle est également utilisé dans l’ARN du principal de rôle présumé. Cela signifie que les demandes d'API inter-comptes ultérieures utilisant les informations d'identification de sécurité temporaires exposeront le nom de session du rôle au compte externe dans ses AWS CloudTrail journaux.
**Pour définir les propriétés ETL de streaming pour Amazon Kinesis Data Streams (API AWS Glue ou AWS CLI)**
+ Pour configurer les propriétés ETL de streaming pour une source Kinesis dans le même compte, spécifiez les paramètres `streamName` et `endpointUrl` dans la structure `StorageDescriptor` de l’opération d’API `CreateTable` ou de la commande `create_table` de la CLI.
```
"StorageDescriptor": {
"Parameters": {
"typeOfData": "kinesis",
"streamName": "sample-stream",
"endpointUrl": "https://kinesis.us-east-1.amazonaws.com"
}
...
}
```
Ou, spécifiez le `streamARN`.
**Example**
```
"StorageDescriptor": {
"Parameters": {
"typeOfData": "kinesis",
"streamARN": "arn:aws:kinesis:us-east-1:123456789:stream/sample-stream"
}
...
}
```
+ Pour configurer les propriétés ETL de streaming pour une source Kinesis dans un autre compte, spécifiez les paramètres `streamARN`, `awsSTSRoleARN` et `awsSTSSessionName` (facultatif) dans la structure`StorageDescriptor` de l’opération d’API `CreateTable` ou de la commande `create_table` de la CLI.
```
"StorageDescriptor": {
"Parameters": {
"typeOfData": "kinesis",
"streamARN": "arn:aws:kinesis:us-east-1:123456789:stream/sample-stream",
"awsSTSRoleARN": "arn:aws:iam::123456789:role/sample-assume-role-arn",
"awsSTSSessionName": "optional-session"
}
...
}
```
### Source de données Kafka
Lors de la création de la table, définissez les propriétés de streaming ETL suivantes (console).
**Type de source**
**Kafka**
**Pour une source Kafka :**
**Nom du sujet**
Nom de la rubrique tel que spécifié dans Kafka.
**Connexion**
Une connexion AWS Glue qui fait référence à une source Kafka, comme décrit dans [Création d’une connexion AWS Glue pour un flux de données Apache Kafka](#create-conn-streaming).
### Source AWS Glue de la table Schema Registry
Pour utiliser Registre de schémas pour les tâches de streaming AWS Glue, suivez les instructions de [Cas d'utilisation : AWS Glue Data Catalog](schema-registry-integrations.md#schema-registry-integrations-aws-glue-data-catalog) pour créer ou mettre à jour une table de Registre de schémas.
Présentement, le streaming AWS Glue prend uniquement en charge le format Glue Schema Registry Avro avec l’inférence de schéma définie sur `false`.
## Notes et restrictions pour les sources en streaming Avro
Les notes et restrictions suivantes s’appliquent aux sources en streaming au format Avro :
+ Lorsque la détection du schéma est activée, le schéma Avro doit être inclus dans la charge utile. Lorsqu’elle est désactivée, la charge utile ne doit contenir que des données.
+ Certains types de données Avro ne sont pas pris en charge dans les trames dynamiques. Vous ne pouvez pas spécifier ces types de données lors de la définition du schéma avec la page **Define a schema (Définir un schéma)** de l’assistant création de table dans la console AWS Glue. Lors de la détection de schéma, les types non pris en charge dans le schéma Avro sont convertis en types pris en charge comme suit :
+ `EnumType => StringType`
+ `FixedType => BinaryType`
+ `UnionType => StructType`
+ Si vous définissez le schéma de table à l’aide de la page **Define a schema (Définir un schéma)** dans la console, le type de l’élément racine implicite pour le schéma est `record`. Si vous voulez un type d’élément racine autre que `record`, par exemple, `array` ou `map`, vous ne pouvez pas spécifier le schéma à l’aide de la page **Define a schema (Définir un schéma)**. Au lieu de cela, vous devez ignorer cette page et spécifier le schéma en tant que propriété de table ou dans le script ETL.
+ Pour spécifier le schéma dans les propriétés de la table, complétez l’assistant de création de table, modifiez les détails de la table et ajoutez une nouvelle paire clé-valeur sous **Table properties (Propriétés de la table)**. Utilisez la clé `avroSchema` et saisissez un objet de schéma JSON pour la valeur, comme illustré dans la capture d’écran suivante.
![\[Sous l’en-tête Table properties (Propriétés de la table), il y a deux colonnes de champs de texte. L’en-tête de la colonne de gauche est Key (Clé), et l’en-tête de la colonne de droite est Value (Valeur). La key/value paire de la première ligne est la classification/avro. The key/value paire de la deuxième ligne est AvroSchema/ {"type » « array », "items » « string"}.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/table_properties_avro.png)
+ Pour spécifier le schéma dans le script ETL, modifiez l’instruction d’affectation `datasource0` et ajoutez la clé `avroSchema` à l’argument `additional_options`, comme indiqué dans les exemples Python et Scala suivants.
------
#### [ Python ]
```
SCHEMA_STRING = ‘{"type":"array","items":"string"}’
datasource0 = glueContext.create_data_frame.from_catalog(database = "database", table_name = "table_name", transformation_ctx = "datasource0", additional_options = {"startingPosition": "TRIM_HORIZON", "inferSchema": "false", "avroSchema": SCHEMA_STRING})
```
------
#### [ Scala ]
```
val SCHEMA_STRING = """{"type":"array","items":"string"}"""
val datasource0 = glueContext.getCatalogSource(database = "database", tableName = "table_name", redshiftTmpDir = "", transformationContext = "datasource0", additionalOptions = JsonOptions(s"""{"startingPosition": "TRIM_HORIZON", "inferSchema": "false", "avroSchema":"$SCHEMA_STRING"}""")).getDataFrame()
```
------
## Application de modèles Grok à des sources de streaming
Vous pouvez créer une tâche ETL en streaming pour une source de données de journalisation et utiliser des modèles Grok pour convertir les journaux en données structurées. La tâche ETL traite ensuite les données en tant que source de données structurée. Vous spécifiez les modèles Grok à appliquer lorsque vous créez la table du catalogue de données pour la source en streaming.
Pour plus d’informations sur les modèles Grok et les valeurs de chaînes de modèle personnalisées, veuillez consulter [Écriture de classifieurs personnalisés Grok](custom-classifier.md#custom-classifier-grok).
**Pour ajouter des modèles Grok au tableau du catalogue de données (console)**
+ Utilisez l’assistant de création de table et créez la table avec les paramètres spécifiés dans [Création d’un tableau de catalogue de données pour une source en streaming](#create-table-streaming). Spécifiez le format de données en tant que Grok, remplissez le champ **Grok pattern (Modèle Grok)**, et éventuellement ajouter des modèles personnalisés sous **Custom patterns (optional) (Modèles personnalisés – facultatif)**.
![\[*\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/grok-data-format-create-table.png)
Appuyez sur **Entrée** après chaque modèle personnalisé.
**Pour ajouter des modèles de grok à la table du catalogue de données (AWS GlueAPI ou AWS CLI)**
+ Ajoutez le paramètre `GrokPattern` et, éventuellement, le paramètre `CustomPatterns` à l’opération d’API `CreateTable` ou à la commande `create_table` de la CLI.
```
"Parameters": {
...
"grokPattern": "string",
"grokCustomPatterns": "string",
...
},
```
Formulez `grokCustomPatterns` en tant que chaîne et utilisez « \$1n » comme séparateur entre les motifs.
Voici un exemple de ces paramètres dans un fichier.
**Example**
```
"parameters": {
...
"grokPattern": "%{USERNAME:username} %{DIGIT:digit:int}",
"grokCustomPatterns": "digit \d",
...
}
```
## Définition des propriétés de tâche pour une tâche ETL en streaming
Lorsque vous définissez une tâche ETL en streaming dans la console AWS Glue, fournissez les propriétés spécifiques aux flux suivantes. Pour obtenir la description d’autres propriétés de la tâche, consulter [Définition des propriétés des tâches Spark](add-job.md#create-job).
**Rôle IAM**
Spécifiez le rôle Gestion des identités et des accès AWS (IAM) utilisé pour autoriser les ressources utilisées pour exécuter la tâche, accéder aux sources de streaming et accéder aux magasins de données cibles.
Pour accéder à Amazon Kinesis Data Streams, associez `AmazonKinesisFullAccess` AWS la politique gérée au rôle ou associez une politique IAM similaire qui permet un accès plus précis. Pour obtenir des exemples de stratégies, consultez [Controlling Access to Amazon Kinesis Data Streams Resources Using IAM](https://docs.aws.amazon.com/streams/latest/dev/controlling-access.html) (Contrôle de l’accès aux ressources Amazon Kinesis Data Streams à l’aide d’IAM).
Pour plus d'informations sur les autorisations requises pour exécuter des tâches dans AWS Glue, consultez [Gestion des identités et des accès pour AWS Glue](security-iam.md).
**Type**
Choisissez **Spark Streaming**.
**Version AWS Glue**
La version AWS Glue détermine les versions d’Apache Spark et Python ou Scala qui sont disponibles pour la tâche. Choisissez une sélection qui spécifie la version de Python ou Scala disponible pour la tâche. AWS Glue version 2.0 avec prise en charge de Python 3 est la valeur par défaut pour les tâches ETL en streaming.
**Fenêtre de maintenance**
Spécifie une fenêtre dans laquelle une tâche de streaming peut être redémarrée. Consultez [Fenêtres de maintenance pour le AWS Glue streaming](glue-streaming-maintenance.md).
**Délai d'expiration de la tâche**
Vous pouvez saisir une durée en minutes. La valeur par défaut est vide.
+ Les tâches de streaming doivent avoir un délai d’expiration inférieur à 7 jours ou 10 080 minutes.
+ Si aucun délai n’est indiqué, la tâche sera redémarrée au bout de sept jours, si vous n’avez pas défini de fenêtre de maintenance. Si vous avez défini une fenêtre de maintenance, la tâche sera redémarrée au cours de celle-ci au bout de sept jours.
**Source de données**
Spécifiez la table que vous avez créée dans [Création d’un tableau de catalogue de données pour une source en streaming](#create-table-streaming).
**Cible de données**
Effectuez l’une des actions suivantes :
+ Choisissez **Create tables in your data target** (Créer des tables dans votre cible de données) et spécifiez les propriétés de cible de données suivantes.
**Banque de données**
Choisissez Amazon S3 ou JDBC.
**Format**
Choisissez n’importe quel format. Tous sont pris en charge pour le streaming.
+ Choisissez **Use tables in the data catalog and update your data target** (Utiliser les tables du catalogue de données et mettre à jour votre cible de données) et choisissez une table pour un magasin de données JDBC.
**Définition du schéma en sortie**
Effectuez l’une des actions suivantes :
+ Choisissez **Automatically detect schema of each record** (Détection automatique du schéma de chaque enregistrement) pour activer la détection de schéma. AWS Glue détermine le schéma à partir des données en streaming.
+ Choisissez **Specify output schema for all records** (Spécifier le schéma de sortie pour tous les enregistrements) pour utiliser la transformation Apply Mapping (Appliquer le mappage) pour définir le schéma en sortie.
**Script**
Vous pouvez également fournir votre propre script ou modifier le script généré pour effectuer des opérations prises en charge par le moteur Apache Spark Structured Streaming. Pour plus d'informations sur les opérations disponibles, consultez la section [Opérations sur le DataFrames streaming/Datasets](https://spark.apache.org/docs/latest/structured-streaming-programming-guide.html#operations-on-streaming-dataframesdatasets).
## Restrictions et notes sur ETL en streaming
Gardez à l’esprit les notes et restrictions suivantes :
+ La décompression automatique pour les tâches ETL de streaming AWS Glue est uniquement disponible pour les types de compression pris en charge. Veuillez prendre en compte les points suivants :
+ Le format Framed Snappy fait référence au [format de trame](https://github.com/google/snappy/blob/main/framing_format.txt) officiel pour Snappy.
+ L’algorithme Deflate est pris en charge dans la version 3.0 de Glue et non dans la version 2.0.
+ Lorsque vous utilisez la détection de schéma, vous ne pouvez pas effectuer de jointures de données en streaming.
+ Les tâches ETL AWS Glue en streaming ne prennent pas en charge le type de données Union pour le Registre de schéma AWS Glue avec le format Avro.
+ Votre script ETL peut utiliser les transformations intégrées d’AWS Glue et les transformations natives d’Apache Spark Structured Streaming. Pour plus d'informations, consultez [Opérations sur le DataFrames streaming/Datasets](https://spark.apache.org/docs/latest/structured-streaming-programming-guide.html#operations-on-streaming-dataframesdatasets) sur le site Web Apache Spark ou. [AWS Glue PySpark transforme la référence](aws-glue-programming-python-transforms.md)
+ Les tâches ETL AWS Glue en streaming utilisent des points de contrôle pour garder la trace des données qui ont été lues. Par conséquent, une tâche arrêtée et redémarrée reprend là où elle s’est arrêtée dans le flux. Si vous souhaitez retraiter les données, vous pouvez supprimer le dossier du point de contrôle référencé dans le script.
+ Les signets de tâche ne sont pas pris en charge.
+ Pour utiliser la fonctionnalité de diffusion améliorée de Kinesis Data Streams dans tâche, consultez [Utilisation de la diffusion améliorée dans les tâches de streaming Kinesis](aws-glue-programming-etl-connect-kinesis-efo.md).
+ Si vous utilisez une table de catalogue de données créée à partir d’AWS Glue Schema Registry, lorsqu’une nouvelle version de schéma devient disponible, pour refléter le nouveau schéma, vous devez effectuer les opérations suivantes :
1. Arrêtez les tâches associées à la table.
1. Mettez à jour le schéma de la table Catalogue de données.
1. Redémarrez les tâches associées à la table.
# Record correspondant à AWS Lake Formation FindMatches
**Note**
Le rapprochement des records n'est actuellement pas disponible dans les régions suivantes de la AWS Glue console : Moyen-Orient (Émirats arabes unis), Europe (Espagne), Asie-Pacifique (Jakarta) et Europe (Zurich).
AWS Lake Formation fournit des fonctionnalités d'apprentissage automatique pour créer des transformations personnalisées afin de nettoyer vos données. Il existe actuellement une transformation disponible nommée FindMatches. La FindMatches transformation vous permet d'identifier les enregistrements dupliqués ou correspondants dans votre ensemble de données, même lorsque les enregistrements n'ont pas d'identifiant unique commun et qu'aucun champ ne correspond exactement. Cela ne nécessitera pas d'écrire de code ou de connaître le fonctionnement de l'apprentissage automatique. FindMatches peut être utile pour résoudre de nombreux problèmes, tels que :
+ **Correspondance de clients** : liaison des enregistrements clients entre différentes bases de données client, même lorsque de nombreux champs client ne correspondent pas exactement entre les bases de données (par exemple, orthographe de nom différentes, adresses différentes, données manquantes ou inexactes, etc.).
+ **Correspondance de produits** : correspondance des produits de votre catalogue par rapport à d'autres sources de produits, telle qu'un catalogue de produits par rapport au catalogue d'un concurrent, où les entrées sont structurées différemment.
+ **Amélioration de la détection des fraudes** : identification de comptes client en double, afin de déterminer quand un nouveau compte est (ou peut être) une correspondance pour un utilisateur frauduleux précédemment connu.
+ **Autres problèmes de correspondance** : correspondance d'adresses, de films, de listes de pièces, etc. En général, si un être humain pouvait examiner les lignes de votre base de données et déterminer si elles correspondent, il y a de fortes chances que la FindMatches transformation puisse vous aider.
Vous pouvez créer ces transformations lorsque vous créez une tâche. La transformation que vous créez est basée sur un schéma de magasin de données source et des exemples de données du jeu de données source que vous labélisez (nous appelons ce processus l'« enseignement » d'une transformation). Les enregistrements que vous labélisez doivent être présents dans le jeu de données source. Dans ce processus, nous générons un fichier que vous labélisez et chargez ensuite pour que la transformation apprenne d'une manière ou d'une autre. Après avoir enseigné votre transformation, vous pouvez l'appeler depuis votre AWS Glue tâche basée sur Spark (PySpark ou Scala Spark) et l'utiliser dans d'autres scripts dotés d'un magasin de données source compatible.
Une fois la transformation créée, elle est stockée dans AWS Glue. Sur la console AWS Glue, vous pouvez gérer les transformations que vous créez. Dans le volet de navigation sous **Intégration des données et ETL**, **Outils de classification des données > Correspondance des enregistrements**, vous pouvez modifier et continuer à entraîner votre transformation de machine learning. Pour de plus amples informations sur la gestion des transformations sur la console, veuillez consulter [Utilisation de transformations du machine learning](console-machine-learning-transforms.md).
**Note**
AWS Glueles FindMatches tâches de la version 2.0 utilisent le compartiment Amazon S3 `aws-glue-temp--` pour stocker des fichiers temporaires pendant que la transformation traite des données. Vous pouvez supprimer ces données une fois l'exécution terminée, soit manuellement, soit en définissant une règle de cycle de vie Amazon S3.
## Types de transformations Machine Learning
Vous pouvez créer des transformations de machine learning pour nettoyer vos données. Vous pouvez appeler ces transformations à partir de votre script ETL. Vos données passent d'une transformation à l'autre dans une structure de données appelée a *DynamicFrame*, qui est une extension d'un SQL Apache Spark`DataFrame`. Le `DynamicFrame` contient vos données, et vous référencez son schéma pour traiter vos données.
Les types de transformations de machine learning suivants sont disponibles :
*Recherche de correspondances*
Recherche des enregistrements en double dans les données source. Vous enseignez cette transformation Machine Learning par l'étiquetage des ensembles de données afin d'indiquer les lignes qui correspondent. La transformation de machine learning apprend quelles lignes doivent être des correspondances à mesure que vous l'entraînez à l'aide d'exemples de données étiquetées. En fonction de la manière dont vous configurez la transformation, la sortie peut ressembler à l'une des suivantes :
+ Une copie de la table d'entrée et une colonne `match_id` renseignée avec des valeurs qui indiquent des ensembles d'enregistrements correspondants. La colonne `match_id` est un identifiant arbitraire. Tous les enregistrements qui ont le même `match_id` ont été identifiés comme correspondant les uns aux autres. Les enregistrements avec des `match_id` différents ne correspondent pas.
+ Une copie de la table d'entrée dans laquelle les lignes en double ont été retirées. Si plusieurs doublons sont trouvés, l'enregistrement avec la clé primaire la plus faible est conservé.
*Rechercher des correspondances progressives*
La transformation FindMatches peut également être configurée pour rechercher des correspondances entre les trames existantes et progressives et renvoyer en sortie une colonne contenant un ID unique par groupe de correspondances.
Pour plus d'informations, voir : [Recherche de correspondances progressives](machine-learning-incremental-matches.md)
### Utilisation de la FindMatches transformation
Vous pouvez utiliser la transformation `FindMatches` pour rechercher les enregistrements en double dans les données source. Un fichier d'étiquetage des données est généré ou fourni pour vous aider à enseigner à la transformation.
**Note**
Actuellement, les transformations `FindMatches` utilisant une clé de chiffrement personnalisée ne sont pas prises en charge dans les régions suivantes :
Asie-Pacifique (Osaka) - `ap-northeast-3`
Pour commencer la FindMatches transformation, vous pouvez suivre les étapes ci-dessous. Pour un exemple plus avancé et détaillé, consultez le **blog AWS Big Data** : [Harmonize data using AWS Glue and AWS Lake Formation FindMatches ML to build a customer 360 view](https://aws.amazon.com/blogs/big-data/harmonize-data-using-aws-glue-and-aws-lake-formation-findmatches-ml-to-build-a-customer-360-view/).
#### Commencer à utiliser la transformation Recherche de correspondances
Suivez les étapes ci-après pour commencer à utiliser la transformation `FindMatches` :
1. Créez une table dans le AWS Glue Data Catalog pour les données source à nettoyer. Pour plus d'informations sur la façon de créer un crawler, veuillez consulter [Travailler avec des crawlers sur la console AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/console-crawlers.html).
Si vos données source sont dans un fichier texte, par exemple un fichier CSV (valeurs séparées par une virgule), tenez compte des éléments suivants :
+ Placez votre fichier CSV des enregistrements d'entrée et le fichier d'étiquetage des données dans des dossiers distincts. Dans le cas contraire, le crawler AWS Glue pourrait les considérer comme plusieurs parties de la même table et créer des tables dans le catalogue de données de manière incorrecte.
+ Sauf si votre fichier CSV inclut des caractères ASCII uniquement, assurez-vous que l'encodage UTF-8 sans marque d'ordre d'octet (BOM) est utilisé pour les fichiers CSV. Microsoft Excel ajoute souvent une marque d'ordre d'octet (BOM) au début de fichiers CSV UTF-8. Pour la retirer, ouvrez le fichier CSV dans un éditeur de texte, puis réenregistrez le fichier au format **UTF-8 sans marque d'ordre d'octet (BOM)**.
1. Sur la console AWS Glue, créez une tâche, puis choisissez le type de transformation **Recherche de correspondances**.
**Important**
La table de sources de données que vous choisissez pour la tâche ne peut pas avoir plus de 100 colonnes.
1. Demandez à AWS Glue de générer un fichier d'étiquetage des données en choisissant **Generate labeling file (Générer un fichier d'étiquetage)**. AWS Glue effectue une première passe en regroupant les enregistrements similaires pour chaque `labeling_set_id` afin que vous puissiez vérifier ces regroupements. Vous labélisez les correspondances dans la colonne `label`.
+ Si vous disposez déjà d'un fichier d'étiquetage, c'est-à-dire un exemple d'enregistrements qui indiquent des lignes qui correspondent l'une à l'autre, téléchargez le fichier dans Amazon Simple Storage Service (Amazon S3). Pour en savoir plus sur le format du fichier d'étiquetage, consultez [Format du fichier d'étiquetage](#machine-learning-labeling-file). Passez à l'étape 4.
1. Téléchargez le fichier d'étiquetage et labélisez le fichier comme décrit dans la section [Étiquetage](#machine-learning-labeling).
1. Chargez le fichier étiqueté corrigé. AWS Glue exécute des tâches pour enseigner à la transformation comment trouver des correspondances.
Sur la page de liste **Machine learning transforms(Transformations Machine Learning)**, choisissez l'onglet **History (Historique)**. Cette page indique quand AWS Glue effectue les tâches suivantes :
+ **Importer des étiquettes**
+ **Exporter des étiquettes**
+ **Générer des étiquettes**
+ **Estimation de la qualité**
1. Pour créer une meilleure transformation, vous pouvez télécharger, étiqueter, puis charger de manière itérative le fichier étiqueté. Lors des premières exécutions, beaucoup d'enregistrements peuvent ne pas correspondre. Cependant, AWS Glue apprend dès lors que vous continuez à lui enseigner en vérifiant le fichier d'étiquetage.
1. Évaluez et ajustez votre transformation en évaluant les performances et les résultats des correspondances trouvées. Pour de plus amples informations, veuillez consulter [Réglage des transformations Machine Learning dans AWS Glue](add-job-machine-learning-transform-tuning.md).
#### Étiquetage
Lorsque `FindMatches` génère un fichier d'étiquetage, les enregistrements sont sélectionnés à partir de votre table source. En fonction de l'entraînement précédent, `FindMatches` identifie les enregistrements les plus significatifs pouvant servir de base d'apprentissage.
L'acte d'*étiquetage* consiste à modifier un fichier d'étiquetage (nous vous suggérons d'utiliser une feuille de calcul Microsoft Excel, par exemple) et à ajouter des identifiants, ou étiquettes, dans la colonne `label` qui identifie les enregistrements correspondants ou non correspondants. Il est important d'avoir une définition claire et cohérente d'une correspondance dans vos données source. `FindMatches` apprend à partir des enregistrements que vous désignez comme correspondants (ou pas) et utilise vos décisions pour apprendre à rechercher des enregistrements en double.
Lorsqu'un fichier d'étiquetage est généré par `FindMatches`, environ 100 enregistrements sont générés. Ces 100 enregistrements sont généralement divisés en 10 *jeux d'étiquetage*, chaque jeu étant identifié par un `labeling_set_id` unique généré par `FindMatches`. Chaque jeu d'étiquetage doit être considéré comme une tâche d'étiquetage distincte indépendante des autres jeux d'étiquetage. Votre tâche consiste à identifier les enregistrements correspondants et non correspondants dans chaque jeu d'étiquetage.
##### Conseils pour modifier les fichiers d'étiquetage dans une feuille de calcul
Lorsque vous modifiez le fichier d'étiquetage dans une application de feuille de calcul, tenez compte des éléments suivants :
+ Le fichier peut ne pas s'ouvrir avec les champs de colonne entièrement développés. Vous devrez peut-être développer les colonnes `label` et `labeling_set_id` pour voir le contenu de ces cellules.
+ Si la colonne de clé primaire comporte un nombre, comme un type de données `long`, la feuille de calcul peut l'interpréter comme un nombre et modifier la valeur. La valeur de cette clé doit être traitée en tant que texte. Pour corriger ce problème, définissez le format **Texte** pour toutes les cellules de la colonne de clé primaire.
#### Format du fichier d'étiquetage
Le fichier d'étiquetage généré par AWS Glue pour l'apprentissage de votre transformation `FindMatches` utilise le format suivant. Si vous générez votre propre fichier pour AWS Glue, il doit également suivre ce format :
+ Il s'agit d'un fichier CSV (valeurs séparées par des virgules).
+ Il doit être encodé en `UTF-8`. Si vous modifiez le fichier à l'aide de Microsoft Windows, il peut être encodé avec `cp1252`.
+ Il doit se trouver dans un emplacement Amazon S3 pour sa transmission à AWS Glue.
+ Utilisez un nombre modéré de lignes pour chaque tâche d'étiquetage. Il est recommandé d'utiliser 10 à 20 lignes par tâche, même si 2 à 30 lignes par tâche sont acceptées. Les tâches de plus de 50 lignes ne sont pas recommandées et peuvent entraîner de mauvais résultats ou une défaillance du système.
+ Si vous disposez de données composées de paires d'enregistrements déjà marqués comme « correspondants » ou « non correspondants », cela ne pose pas de problème. Ces paires étiquetées peuvent être représentées sous forme de jeux d'étiquetage de taille 2. Dans ce cas, labélisez les deux enregistrements avec, par exemple, la lettre « A » s'ils correspondent, ou labélisez l'une avec la lettre « A » et l'autre avec la lettre « B » s'ils ne correspondent pas.
**Note**
Étant donné qu'il comporte des colonnes supplémentaires, le fichier d'étiquetage a un schéma différent d'un fichier qui contient vos données source. Placez le fichier d'étiquetage dans un dossier différent de celui de tout fichier CSV d'entrée de transformation, de sorte que le crawler AWS Glue n'en tienne pas compte lorsqu'il crée des tables dans le catalogue de données. Sinon, les tables créées par le crawler AWS Glue pourraient ne pas représenter correctement vos données.
+ Les deux premières colonnes (`labeling_set_id`, `label`) sont requises par AWS Glue. Les colonnes restantes doivent correspondre au schéma des données à traiter.
+ Pour chaque `labeling_set_id`, vous identifiez tous les enregistrements correspondants à l'aide de la même étiquette. Une étiquette est une chaîne unique placée dans la colonne `label`. Nous vous recommandons d'utiliser les étiquettes contenant des caractères simples, par exemple A, B, C, et ainsi de suite. Les étiquettes sont sensibles à la casse et sont saisies dans la colonne `label`.
+ Les lignes qui contiennent le même `labeling_set_id` et la même étiquette sont considérées comme formant une correspondance.
+ Les lignes qui contiennent le même `labeling_set_id` et une étiquette différente sont considérées comme *ne formant pas* une correspondance.
+ Les lignes qui contiennent un `labeling_set_id` différent sont considérées comme ne fournissant aucune information pour ou contre la correspondance.
Voici un exemple d'étiquetage de données :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/machine-learning.html)
+ Dans l'exemple ci-dessus, nous identifions John/Johnny/Jon Doe as being a match and we teach the system that these records do not match Jane Smith. Separately, we teach the system that Richard and Rich Jones are the same person, but that these records are not a match to Sarah Jones/Jones -Walker et Richie Jones Jr.
+ Comme vous pouvez le voir, la portée des étiquettes est limitée à l'élément `labeling_set_id`. Ainsi, les étiquettes ne dépassent pas les limites de `labeling_set_id`. Par exemple, une étiquette « A » dans `labeling_set_id` 1 n'a aucune relation avec l'étiquette « A » dans `labeling_set_id` 2.
+ Si un enregistrement n'a aucune correspondance dans un jeu d'étiquettes, affectez-lui une étiquette unique. Par exemple, Jane Smith ne correspond à aucun enregistrement du jeu d'étiquettes ABC123, c'est donc le seul enregistrement de ce jeu d'étiquettes portant l'étiquette B.
+ Le jeu d'étiquettes « GHI678 » indique qu'un ensemble d'étiquettes peut être composé uniquement de deux enregistrements auxquels est attribuée la même étiquette pour montrer qu'ils correspondent. De même, « XYZABC » montre deux enregistrements portant des étiquettes différentes pour montrer qu'ils ne correspondent pas.
+ Notez que parfois un jeu d'étiquetage peut ne pas contenir de correspondances (c'est-à-dire que vous donnez à chaque enregistrement du jeu d'étiquetage une étiquette différente) ou qu'un jeu d'étiquetage peut être globalement « identique » (vous leur donnez le même label). Ceci est correct tant que vos jeux d'étiquetage contiennent collectivement des exemples d'enregistrements qui sont et ne sont pas « identiques » selon vos critères.
**Important**
Confirmez que le rôle IAM que vous transmettez à AWS Glue a accès au compartiment Amazon S3 qui contient le fichier d'étiquetage. Par convention, les stratégies AWS Glue accordent une autorisation sur les enregistrements ou les dossiers Amazon S3 dont les noms sont préfixés avec **aws-glue-**. Si vos fichiers d'étiquetage se trouvent dans un emplacement différent, ajoutez l'autorisation sur cet emplacement dans le rôle IAM.
# Réglage des transformations Machine Learning dans AWS Glue
Vous pouvez régler vos transformations Machine Learning dans AWS Glue pour améliorer les résultats de vos tâches de nettoyage de données afin d'atteindre vos objectifs. Pour améliorer votre transformation, vous pouvez l'entraîner en générant un ensemble d'étiquetage, en ajoutant des étiquettes, puis en répétant ces étapes plusieurs fois jusqu'à obtention des résultats souhaités. Vous pouvez également procéder à un réglage en modifiant certains paramètres de machine learning.
Pour de plus amples informations sur les transformations Machine Learning, veuillez consulter [Record correspondant à AWS Lake Formation FindMatches](machine-learning.md).
**Topics**
+ [Mesures de Machine Learning](machine-learning-terminology.md)
+ [Choisir entre la précision et le rappel](machine-learning-precision-recall-tradeoff.md)
+ [Choisir entre l'exactitude et le coût](machine-learning-accuracy-cost-tradeoff.md)
+ [Estimation de la qualité des correspondances à l'aide des notes de confiance des correspondances](match-scoring.md)
+ [Entraîner la transformation à trouver des correspondances](machine-learning-teaching.md)
# Mesures de Machine Learning
Pour comprendre les mesures qui sont utilisés pour régler votre transformation Machine Learning, vous devez vous familiariser avec la terminologie suivante :
**Vrai positif (TP, True positive)**
Correspondance dans les données correctement trouvée par la transformation, parfois appelée *occurrence*.
**Vrai négatif (TN, True Negative)**
Non correspondance dans les données que la transformation a correctement rejetée.
**Faux positif (FP, False positive)**
Non correspondance dans les données que la transformation a classifiée de manière incorrecte en tant que correspondance, parfois appelée *fausse alarme*.
**Faux négatif (FN, False negative)**
Correspondance dans les données que la transformation n'a pas trouvée, parfois appelée *échec*.
Pour de plus amples informations sur la terminologie utilisée dans le Machine Learning, consultez [Confusion matrix](https://en.wikipedia.org/wiki/Confusion_matrix) dans Wikipedia.
Pour régler vos transformations Machine Learning, vous pouvez modifier la valeur des mesures suivantes dans les **propriétés avancées** de la transformation.
+ **Précision** (Précision) évalue dans quelle mesure la transformation trouve de vrais positifs parmi le nombre total d'enregistrements qu'elle identifie comme positifs (vrais positifs et faux positifs). Pour en savoir plus, consultez [Précision et rappel](https://en.wikipedia.org/wiki/Precision_and_recall) dans Wikipédia.
+ **Recall (Rappel)** mesure comment la transformation trouve des vrais positifs à partir du nombre total d'enregistrements dans les données source. Pour en savoir plus, consultez [Précision et rappel](https://en.wikipedia.org/wiki/Precision_and_recall) dans Wikipédia.
+ **Accuracy (Exactitude)** mesure comment la transformation trouve des vrais positifs et des vrais négatifs. L’augmentation de la précision nécessite plus de ressources machine et des coûts supérieurs. Mais elle entraîne également une augmentation du rappel. Pour en savoir plus, consulter [Précision et rappel](https://en.wikipedia.org/wiki/Accuracy_and_precision#In_information_systems) dans Wikipédia.
+ **Cost (Coût)** mesure le nombre de ressources de calcul (et par conséquent le coût) consommées pour l'exécution de la transformation.
# Choisir entre la précision et le rappel
Chaque transformation `FindMatches` contient un paramètre `precision-recall`. Vous utilisez ce paramètre pour spécifier l'un des éléments suivants :
+ Si vous êtes plus préoccupé par le fait que la transformation indique de manière erronée que deux enregistrements sont des correspondances alors que ce n'est pas le cas, vous devez alors mettre l'accent sur la *précision*.
+ Si vous êtes plus préoccupé par le fait que la transformation ne parvienne pas à détecter les enregistrements qui sont de réelles correspondances, vous devez mettre l'accent sur le *rappel*.
Vous pouvez effectuer un tel compromis sur la console AWS Glue ou à l'aide d'opérations d'API de Machine Learning AWS Glue.
**Dans quel cas favoriser la précision**
Privilégiez la précision si vous êtes plus préoccupé par le risque que `FindMatches` se traduise par une paire d'enregistrements correspondants alors qu'il n'y a aucune correspondance réelle. Pour favoriser la précision, choisissez une valeur de compromis précision-rappel *plus élevée*. Avec une valeur plus élevée, la transformation `FindMatches` a besoin de plus de preuves pour décider qu'une paire d'enregistrements doivent correspondre. La transformation est réglée sur une tendance à indiquer que les enregistrements ne correspondent pas.
Par exemple, supposons que vous utilisez `FindMatches` pour détecter des articles en double dans un catalogue vidéo, et que vous fournissez une valeur précision-rappel plus élevée à la transformation. Si votre transformation détecte de manière incorrecte détecte qu' *Star Wars : Un nouvel espoir* est identique à *Star Wars : L'Empire contre-attaque*, un client qui souhaite *Un nouvel espoir* peut voir s'afficher *L'Empire contre-attaque*. Cela constituerait une mauvaise expérience client.
Toutefois, si la transformation ne parvient pas à détecter que *Star Wars : Un nouvel espoir* et *Star Wars : Episode IV - Un nouvel espoir* sont un seul et même article, le client peut être un peu perdu au début mais il peut au final les reconnaître comme étant identiques. Il s'agirait là d'une erreur, mais pas aussi grave que dans le scénario précédent.
**Dans quel cas favoriser le rappel**
Privilégiez le rappel si vous êtes plus préoccupé par le risque que les résultats de la transformation `FindMatches` ne parviennent pas à détecter une paire d'enregistrements qui correspondent réellement. Pour favoriser le rappel, choisissez une valeur de compris précision-rappel *plus faible*. Avec une valeur plus faible, la transformation `FindMatches` a besoin de moins de preuves pour décider qu'une paire d'enregistrements doivent correspondre. La transformation est réglée sur une tendance à indiquer que les enregistrements correspondent.
Cela peut, par exemple, être une priorité pour une organisation de sécurité. Supposons que vous établissez des correspondances entre des clients et une liste de fraudeurs connus, et il est important de déterminer si un client est un fraudeur. Vous utilisez `FindMatches` pour établir des correspondances entre la liste de fraudeurs et la liste de clients. Chaque fois que `FindMatches` détecte une correspondance entre les deux listes, un auditeur humain est affecté pour vérifier que la personne est effectivement un fraudeur. Il se peut que votre organisation préfère le rappel à la précision. En d'autres termes, vous préférez plutôt avoir des auditeurs qui vérifient et rejettent manuellement certains cas lorsque le client n'est pas un fraudeur que de ne pas parvenir à identifier qu'un client est, effectivement, sur la liste de fraudeurs.
**Comment favoriser à la fois la précision et le rappel**
Le meilleur moyen d'améliorer à la fois la précision et le rappel est d'étiqueter davantage de données. Au fur et à mesure que vous étiquetez plus de données, l'exactitude globale de la transformation `FindMatches` s'améliore, ce qui améliore à la fois la précision et le rappel. Néanmoins, même avec la transformation la plus précise possible, il demeure toujours une zone grise où vous devez essayer de favoriser la précision ou le rappel, ou choisir une valeur intermédiaire.
# Choisir entre l'exactitude et le coût
Chaque transformation `FindMatches` contient un paramètre `accuracy-cost`. Vous pouvez utiliser ce paramètre pour spécifier l'un des éléments suivants :
+ Si vous êtes plus préoccupé par le fait que la transformation indique précisément que deux enregistrements correspondent, vous devez mettre l'accent sur la *précision*.
+ Si vous êtes plus préoccupé par le coût ou la vitesse d'exécution de la transformation, vous devez mettre l'accent sur la *réduction des coûts*.
Vous pouvez effectuer un tel compromis sur la console AWS Glue ou à l'aide d'opérations d'API de Machine Learning AWS Glue.
**Dans quel cas favoriser l'exactitude**
Privilégiez la précision si vous êtes plus préoccupé par le risque que les résultats de `find matches` ne contiennent des correspondances. Pour favoriser l'exactitude, choisissez une valeur de compromis exactitude-coût *plus élevée*. Avec une valeur plus élevée, la transformation `FindMatches` a besoin de plus de temps pour effectuer une recherche plus approfondie afin de trouver des enregistrements qui correspondent correctement. Notez que ce paramètre ne réduit pas le risque d'appeler de manière erronée une correspondance une paire d'enregistrements non correspondants. La transformation est réglée sur une tendance à consacrer plus de temps à la recherche de correspondances.
**Dans quel cas favoriser le coût**
Privilégiez le coût si vous être plus préoccupé par le coût d'exécution de la transformation `find matches` et moins préoccupé par le nombre de correspondances trouvées. Pour favoriser le coût, choisissez une valeur de compromis exactitude-coût *plus faible*. Avec une valeur plus faible, la transformation `FindMatches` a besoin de moins de ressources pour son exécution. La transformation est réglée sur une tendance à rechercher moins de correspondances. Si le fait de favoriser la réduction des coûts produit des résultats acceptables, utilisez ce paramètre.
**Comment favoriser à la fois l'exactitude et la réduction des coûts**
Un temps machine supérieur est nécessaire pour examiner davantage de paires d'enregistrements afin de déterminer s'il peut s'agir de correspondances. Si vous souhaitez réduire les coûts sans réduire la qualité, voici quelques conseils :
+ Éliminez dans votre source de données les enregistrements pour lesquels vous ne cherchez pas de correspondances.
+ Éliminez dans votre source de données les colonnes qui sont de manière certaine inutiles à la prise d'une décision correspondance/non correspondance. Une bonne manière de déterminer cela consiste à éliminer les colonnes qui n'affectent en rien votre décision quant il s'agit de déterminer si un ensemble d'enregistrements sont « identiques ».
# Estimation de la qualité des correspondances à l'aide des notes de confiance des correspondances
Les scores de confiance des correspondances fournissent une estimation de la qualité des correspondances trouvées FindMatches afin de faire la distinction entre les enregistrements correspondants dans lesquels le modèle d'apprentissage automatique est très sûr, incertain ou peu probable. Une note de confiance des correspondances sera comprise entre 0 et 1, alors qu'une note plus élevée signifie une similitude plus élevée. L'examen des notes de confiance des correspondances vous permet de distinguer les clusters de correspondances pour lesquels le système est très confiant (que vous pouvez décider de fusionner), les clusters dont le système est incertain (que vous pouvez décider de faire vérifier par un humain) et les clusters que le système juge improbables (que vous pouvez décider de rejeter).
Vous voudrez peut-être ajuster vos données d'entraînement dans des situations où vous constatez une note de confiance des correspondances élevées, mais déterminez qu'il n'y a pas de correspondances, ou lorsque vous voyez une note faible, mais déterminez qu'il y a en fait des correspondances.
Les scores de confiance sont particulièrement utiles lorsqu'il existe des ensembles de données industriels de grande taille, pour lesquels il est impossible de revoir chaque FindMatches décision.
Les notes de confiance des correspondances sont disponibles dans la version 2.0 ou ultérieure de AWS Glue.
## Génération des notes de confiance des correspondances
Vous pouvez générer des notes de confiance des correspondances en définissant la valeur booléenne de `computeMatchConfidenceScores` sur true (VRAI) lorsque vous appelez l'API `FindMatches` ou `FindIncrementalMatches`.
AWS Glue ajoute un nouveau `column match_confidence_score` à la sortie.
## Exemples de notation des correspondances
Prenons l'exemple des registres de correspondance suivant :
**Note >= 0,9**
Résumé des registres correspondants :
```
primary_id | match_id | match_confidence_score
3281355037663 85899345947 0.9823658302132061
1546188247619 85899345947 0.9823658302132061
```
Détails :
![\[Exemple de table de routage avec une passerelle Internet.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/match_score1.png)
Dans cet exemple, nous pouvons voir que deux registres sont très similaires et partagent `display_position`, `primary_name`, et `street name`.
**Note >= 0,8 et note < 0,9**
Résumé des registres correspondants :
```
primary_id | match_id | match_confidence_score
309237680432 85899345928 0.8309852373674638
3590592666790 85899345928 0.8309852373674638
343597390617 85899345928 0.8309852373674638
249108124906 85899345928 0.8309852373674638
463856477937 85899345928 0.8309852373674638
```
Détails :
![\[Exemple de table de routage avec une passerelle Internet.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/match_score2.png)
Dans cet exemple, nous pouvons voir que ces registres partagent le même`primary_name`, et `country`.
**Note >= 0,6 et note < 0,7**
Résumé des registres correspondants :
```
primary_id | match_id | match_confidence_score
2164663519676 85899345930 0.6971099896480333
317827595278 85899345930 0.6971099896480333
472446424341 85899345930 0.6971099896480333
3118146262932 85899345930 0.6971099896480333
214748380804 85899345930 0.6971099896480333
```
Détails :
![\[Exemple de table de routage avec une passerelle Internet.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/match_score3.png)
Dans cet exemple, nous pouvons voir que ces registres ne partagent que le même `primary_name`.
Pour en savoir plus, consultez :
+ [Étape 5 : Ajouter et exécuter une tâche avec votre transformation Machine Learning](machine-learning-transform-tutorial.md#ml-transform-tutorial-add-job)
+ PySpark: [FindMatches classe](aws-glue-api-crawler-pyspark-transforms-findmatches.md)
+ PySpark: [FindIncrementalMatches classe](aws-glue-api-crawler-pyspark-transforms-findincrementalmatches.md)
+ Scala : [FindMatches classe](glue-etl-scala-apis-glue-ml-findmatches.md)
+ Scala : [FindIncrementalMatches classe](glue-etl-scala-apis-glue-ml-findincrementalmatches.md)
# Entraîner la transformation à trouver des correspondances
Il est nécessaire d'entraîner chaque transformation `FindMatches` à déterminer ce qui est une correspondance et ce qui ne l'est pas. Vous entraînez votre transformation en ajoutant des étiquettes dans un fichier et en chargeant vos choix dans AWS Glue.
Vous pouvez effectuer un tel compromis sur la console AWS Glue ou à l'aide d'opérations d'API de Machine Learning AWS Glue.
**Combien de fois dois-je ajouter des étiquettes ? De combien d'étiquettes ai-je besoin ?**
Les réponses à ces questions dépendent essentiellement de vous. Vous devez évaluer si `FindMatches` offre le niveau d'exactitude dont vous avez besoin et si vous pensez qu'un effort d'étiquetage supplémentaire est utile pour vous. La meilleure façon de procéder pour cela consiste à examiner les métriques « Precision » « Recall » et « Area under the precision recall curve » que vous pouvez générer lorsque vous choisissez **Estimate quality (Estimation de la qualité)** sur la console AWS Glue. Une fois que vous avez étiqueté plusieurs ensembles de tâches, réexécutez ces métriques et vérifiez si elles présentent des améliorations. Si, après l'étiquetage de quelques ensembles de tâches, vous ne constatez pas une amélioration au niveau de la métrique concernée, il est vraisemblable que la qualité de la transformation a atteint son niveau maximum.
**Pourquoi les étiquettes Vrai positif et Vrai négatif sont-elles nécessaires ?**
La transformation `FindMatches` nécessite à la fois des exemples positifs et négatifs pour vous permettre d'enseigner ce que vous estimez être une correspondance. Si vous étiquetez des données de formation générées par `FindMatches` (par exemple, à l'aide de l'option **I do not have labels (Je ne dispose pas d'étiquettes)**, `FindMatches` essaie de générer un ensemble d'« ID d'ensemble d'étiquettes » pour vous. Au sein de chaque tâche, vous donnez la même « étiquette » à certains enregistrements et des « étiquettes » différentes à d'autres enregistrements. En d'autres termes, les tâches ne sont généralement pas toutes identiques ou toutes différentes (mais c'est normal si une tâche particulière est entièrement « identique » ou entièrement « non identique »).
Si vous entraînez votre transformation `FindMatches` à l'aide de l'option **Upload labels from S3 (Télécharger des étiquettes de S3)**, essayez d'inclure à la fois des exemples d'enregistrements correspondants et non correspondants. Il est acceptable d'avoir un seul type. Ces étiquettes vous aident à créer une transformation `FindMatches` plus exacte, mais vous devez quand-même étiqueter certains enregistrements que vous générez à l'aide de l'option **Generate labeling file (Générer un fichier d'étiquetage)**.
**Comment puis-je m'assurer que la transformation fasse exactement ce que je lui ai enseigné ?**
La transformation `FindMatches` apprend à partir des étiquettes que vous fournissez, elle peut donc générer des paires d'enregistrements qui ne respectent pas les étiquettes fournies. Pour garantir que la `FindMatches` transformation respecte vos étiquettes, sélectionnez « **EnforceProvidedLabels**in **FindMatchesParameter**».
**Quelles techniques puis-je utiliser lorsqu'une transformation ML identifie des éléments en tant que correspondances alors qu'elles n'en sont pas vraiment ?**
Vous pouvez utiliser les techniques suivantes :
+ Définir `precisionRecallTradeoff` sur une valeur plus élevée. Cela peut se traduire par la production d'un nombre de correspondances inférieur, mais cela peut également permettre de fractionner votre gros cluster lorsqu'il atteint une valeur suffisamment élevée.
+ Prenez les lignes de sortie correspondant aux résultats incorrects et reformatez-les en tant qu'ensemble d'étiquetage (en retirant la colonne `match_id` et en ajoutant une colonne `labeling_set_id` et `label`). Si nécessaire, fractionnez (subdivisez) en plusieurs ensembles d'étiquetage afin de vous assurer que l'étiqueteur peut continuer en gardant chaque étiquetage à l'esprit tout en affectant des étiquettes. Ensuite, étiquetez correctement les ensembles correspondants, puis chargez le fichier d'étiquettes et ajoutez-le à vos étiquettes existantes. Cela peut suffisamment entraîner votre transformateur à ce qu'il doit rechercher pour comprendre le modèle.
+ (Avancé) Enfin, examinez ces données pour voir si vous pouvez détecter un modèle que le système n'a pas remarqué. Prétraitez ces données à l'aide de fonctions AWS Glue standard pour *normaliser* les données. Mettez en évidence ce sur quoi l'algorithme doit se baser pour apprendre en séparant les données que vous jugez différemment importantes dans leurs propres colonnes. Vous pouvez aussi créer des colonnes combinées à partir de colonnes contenant des données connexes.
# Utilisation de transformations du machine learning
Vous pouvez l'utiliser AWS Glue pour créer des transformations d'apprentissage automatique personnalisées qui peuvent être utilisées pour nettoyer vos données. Vous pouvez utiliser ces transformations lorsque vous créez une tâche sur la console AWS Glue .
Pour de plus amples informations sur la création d’une transformation Machine Learning, veuillez consulter [Record correspondant à AWS Lake Formation FindMatches](machine-learning.md).
**Topics**
+ [Propriétés de transformation](#console-machine-learning-properties)
+ [Ajout et modification de transformations Machine Learning](#console-machine-learning-transforms-actions)
+ [Affichage des détails d’une transformation](#console-machine-learning-transforms-details)
+ [Entraîner les transformations à l’aide d’étiquettes](#console-machine-learning-transforms-teaching-transforms)
## Propriétés de transformation
Pour consulter une transformation d'apprentissage automatique existante, connectez-vous à la AWS Management ConsoleAWS Glue console et ouvrez-la à l'adresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/). Dans le volet de navigation, sous **Intégration des données et ETL**, choisissez **Outils de classification des données > Correspondance des enregistrements**.
Les propriétés de chaque transformation :
**Nom de transformation**
Nom unique donné à la transformation lors de sa création.
**ID**
Identifiant unique de la transformation.
**Nombre d’étiquettes**
Le nombre d’étiquettes dans le fichier d’étiquetage qui a été fourni pour aider à entraîner la transformation.
**Statut**
Indique si la transformation a le statut **Ready** (Prêt) ou **Needs teaching** (Entraînement nécessaire). Pour qu’une transformation machine learning puisse s’exécuter dans une tâche, elle doit avoir le statut **Ready** (Prêt).
**Créé**
Date de création de la transformation.
**Modifié**
Date de la dernière mise à jour de la transformation.
**Description**
Description fournie pour la transformation, le cas échéant.
**Version de l’AWS Glue**
La version de AWS Glue utilisée.
**ID d’exécution**
Nom unique donné à la transformation lors de sa création.
**Type de tâche**
Type de transformation Machine Learning ; par exemple, **Find matching records (Rechercher des enregistrements correspondants)**.
**Statut**
Indique le statut de l’exécution de la tâche. Les statuts possibles incluent :
+ Démarrage en cours
+ En cours d’exécution
+ Arrêt en cours
+ Arrêté(e)
+ Réussi(e)
+ Échec
+ Timeout
**Erreur**
Si le statut est Échec, un message d’erreur indiquant la raison de l’échec s’affiche.
## Ajout et modification de transformations Machine Learning
Vous pouvez afficher, supprimer, configurer et entraîner, ou encore régler une transformation sur la console AWS Glue. Cochez la case en regard de la transformation dans la liste, choisissez **Action**, puis choisissez l’action que vous souhaitez effectuer.
### Création d’une nouvelle transformation ML
Pour ajouter une nouvelle transformation machine learning, choisissez **Créer une transformation**. Suivez les instructions fournies dans l’assistant **Ajouter une tâche**. Pour de plus amples informations, veuillez consulter [Record correspondant à AWS Lake Formation FindMatches](machine-learning.md).
#### Étape 1. Définissez les propriétés de la transformation.
1. Saisissez un nom et une description de la tâche (facultatif).
1. Définissez éventuellement la configuration de sécurité. Consultez [Utilisation du chiffrement des données avec les transformations machine learning](#ml_transform_sec_config).
1. Définissez éventuellement les paramètres d’exécution des tâches. Les paramètres d’exécution des tâches vous permettent de personnaliser le mode d’exécution de la tâche. Sélectionnez le type de travailleur, le nombre de travailleurs, le délai d’expiration de la tâche (en minutes), le nombre de tentatives et la version de AWS Glue.
1. Vous pouvez éventuellement définir des balises. Les tags sont des libellés que vous pouvez attribuer à une AWS ressource. Chaque balise est constituée d'une clé et d'une valeur facultative. Les balises peuvent être utilisées pour rechercher et filtrer vos ressources ou pour suivre vos AWS coûts.
#### Étape 2. Choisissez la table et la clé primaire.
1. Choisissez la base de données et la table du catalogue AWS Glue.
1. Choisissez une clé primaire dans le tableau sélectionné. La colonne de clé primaire contient généralement un identifiant unique pour chaque enregistrement de la source de données.
#### Étape 3. Sélectionnez les options de réglage.
1. Pour **Rappel ou précision**, choisissez la valeur de réglage pour ajuster la transformation afin de favoriser le rappel ou la précision. Par défaut, **Équilibré** est sélectionné, mais vous pouvez choisir de privilégier le rappel ou la précision, ou choisir **Personnalisé** et saisir une valeur comprise entre 0,0 et 1,0 (inclus).
1. Pour **Réduire le coût ou la précision**, choisissez la valeur de réglage qui favorise la réduction des coûts ou de la précision, ou choisissez **Personnalisé** et saisissez une valeur comprise entre 0,0 et 1,0 (inclus).
1. Pour **Application de la correspondance**, choisissez **Forcer la sortie à correspondre aux étiquettes** si vous souhaitez entraîner la transformation ML en forçant la sortie à correspondre aux étiquettes utilisées.
#### Étape 4 : Vérifiez et créez.
1. Passez en revue les options des étapes 1 à 3.
1. Choisissez **Modifier** pour chaque étape qui doit être modifiée. Choisissez **Créer une transformation** pour terminer l’assistant de création de transformation.
### Utilisation du chiffrement des données avec les transformations machine learning
Lors de l’ajout d’une transformation Machine Learning à AWS Glue, vous pouvez éventuellement spécifier une configuration de sécurité associée à la source de données ou à la cible de données. Si le compartiment Amazon S3 utilisé pour stocker les données est chiffré avec une configuration de sécurité, spécifiez la même configuration de sécurité lors de la création de la transformation.
Vous pouvez également choisir d'utiliser le chiffrement côté serveur avec AWS KMS (SSE-KMS) pour chiffrer le modèle et les étiquettes afin d'empêcher des personnes non autorisées de l'inspecter. Si vous choisissez cette option, vous êtes invité à choisir le AWS KMS key nom, ou vous pouvez choisir **Enter a key ARN**. Si vous choisissez de saisir l’ARN de la clé KMS, un deuxième champ apparaît dans lequel vous pouvez saisir l’ARN de la clé KMS.
**Note**
Actuellement, les transformations ML utilisant une clé de chiffrement personnalisée ne sont pas prises en charge dans les régions suivantes :
Asie-Pacifique (Osaka) - `ap-northeast-3`
## Affichage des détails d’une transformation
### Affichage des propriétés de transformation
La page **Propriété de transformation** inclut les attributs de votre transformation. Il affiche les détails relatifs à la définition de transformation, y compris les éléments suivants :
+ **Transform name (Nom de la transformation)** indique le nom de la transformation.
+ **Type** répertorie le type de la transformation.
+ **Status (État)** affiche si la transformation est prête à être utilisée dans un script ou une tâche.
+ **Force output to match labels (Forcer la sortie pour faire correspondre les étiquettes)** affiche si la transformation force la sortie afin qu’elle fasse correspondre les étiquettes fournies par l’utilisateur.
+ La **version Spark** est liée à la version AWS Glue que vous avez choisie dans **Task run properties** (Propriétés d’exécution de la tâche) lors de l’ajout de la transformation. AWS Glue 1.0 et Spark 2.4 sont recommandés pour la plupart des clients. Pour plus d’informations, consultez [Version de AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/release-notes.html#release-notes-versions).
### Onglets Historique, Estimation de la qualité et Balises
Les détails d’une transformation incluent les informations que vous avez définies lors de la création de cette transformation. Pour afficher les détails d’une transformation, sélectionnez la transformation dans la liste **Machine learning transforms (Transformations Machine learning)**, puis consultez les informations sur les onglets suivants :
+ History (Historique)
+ Estimation de la qualité
+ Étiquettes
#### History (Historique)
L’onglet **History (Historique)** affiche l’historique d’exécution de votre tâche de transformation. Plusieurs types de tâches sont exécutées pour entraîner une transformation. Pour chaque tâche, les métriques d’exécution sont les suivantes :
+ **Run ID (ID d’exécution)** est un identifiant créé par AWS Glue pour chaque exécution de cette tâche.
+ **Task type (Type de tâche)** affiche le type de l’exécution de tâche.
+ **Run status (Statut d’exécution)** indique la réussite de chaque tâche répertoriée avec l’exécution la plus récente en haut de la liste.
+ **Error (Erreur)** affiche les détails d’un message d’erreur si l’exécution a échoué..
+ **Start time (Heure de début)** indique la date et l’heure (heure locale) auxquelles la tâche a démarré.
+ **Heure de fin** indique la date et l’heure (heure locale) auxquelles la tâche s’est terminée.
+ **Logs (Journaux)** fournit des liens vers les journaux écrits sur `stdout` pour cette exécution de tâche.
Le lien **Logs** permet d'accéder à Amazon CloudWatch Logs. Vous pouvez y consulter les détails relatifs aux tables créées dans le AWS Glue Data Catalog et aux éventuelles erreurs rencontrées. Vous pouvez gérer la période de conservation des journaux sur la CloudWatch console. La conservation des journaux par défaut est `Never Expire`. Pour plus d'informations sur la modification de la période de conservation, consultez la section [Conservation des données du journal des modifications dans CloudWatch les journaux](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention) dans le *guide de l'utilisateur Amazon CloudWatch Logs*.
+ **Fichier d’étiquettes** fournit un lien vers Amazon S3 pour un fichier d’étiquetage généré.
#### Estimation de la qualité
L’onglet **Estimate quality (Estimation de la qualité)** affiche les métriques que vous utilisez pour mesurer la qualité de la transformation. Les estimations sont calculées en comparant les prédictions de correspondance de transformation à l’aide d’un sous-ensemble de vos données étiquetées par rapport aux étiquettes que vous avez fournies. Ces estimations sont approximatives. Vous pouvez appeler une tâche **Estimate quality (Estimation de la qualité)** exécutée à partir de cet onglet.
L’onglet **Estimate quality (Estimation de la qualité)** affiche les métriques de la dernière **estimation de la qualité**, y compris les propriétés suivantes :
+ **Area under the Precision-Recall curve (Zone sous la courbe de précision-rappel** est un nombre unique qui estime la limite supérieure de la qualité globale de la transformation. Il est indépendant du choix effectué pour le paramètre de précision-rappel. Des valeurs plus élevées indiquent que vous avez un compromis précision-rappel plus attractif.
+ **Precision (Précision)** évalue la fréquence à laquelle la transformation est correcte lorsqu’elle prédit une correspondance.
+ **Recall upper limit (Limite supérieure de rappel)** évalue, pour une correspondance réelle, la fréquence à laquelle la transformation prédit la correspondance.
+ **F1** évalue la précision de la transformation comprise entre 0 et 1, où 1 est la meilleure précision. Pour plus d'informations, consultez la page Wikipedia relative au [score F1](https://en.wikipedia.org/wiki/F1_score).
+ La table **Column importance** (Importance de la colonne) affiche les noms de colonnes et le score d’importance de chaque colonne. L’importance des colonnes vous aide à comprendre comment elles contribuent à votre modèle, en identifiant les colonnes de vos enregistrements qui sont le plus utilisées pour effectuer la correspondance. Ces données peuvent vous inciter à ajouter ou à modifier votre jeu d’étiquettes pour augmenter ou réduire l’importance des colonnes.
La colonne Importance fournit un score numérique pour chaque colonne, sous la forme d’une décimale ne dépassant pas 1,0.
Pour de plus amples informations sur la compréhension des estimations de qualité et de la qualité réelle, veuillez consulter [Estimations de la qualité par rapport à la end-to-end (vraie) qualité](#console-machine-learning-quality-estimates-true-quality).
Pour de plus amples informations sur le réglage de votre transformation, veuillez consulter [Réglage des transformations Machine Learning dans AWS Glue](add-job-machine-learning-transform-tuning.md).
#### Estimations de la qualité par rapport à la end-to-end (vraie) qualité
AWS Glue estime la qualité de vos transformations en présentant le modèle interne appris par machine learning avec un certain nombre de paires d’enregistrements pour lesquels vous avez fourni des étiquettes correspondantes, mais que le modèle n’a jamais vus auparavant. Ces estimations de qualité sont une fonction de la qualité du modèle appris par la machine (qui est influencé par le nombre d’enregistrements que vous étiquetez pour « entraîner » la transformation). Le rappel end-to-end, ou *véritable* rappel (qui n'est pas automatiquement calculé par le`ML transform`) est également influencé par le mécanisme de `ML transform` filtrage qui propose une grande variété de correspondances possibles avec le modèle appris par machine.
Vous pouvez régler cette méthode de filtrage essentiellement en spécifiant la valeur de réglage **Réduction coût-précision**. À mesure que la valeur de réglage se rapproche de **Précision**, le système effectue une recherche plus approfondie et plus coûteuse des paires d’enregistrements qui pourraient être des correspondances. Un plus grand nombre de paires d'enregistrements sont introduites dans votre modèle d'apprentissage automatique, et votre `ML transform` rappel réel se rapproche de la métrique de rappel estimée. end-to-end Par conséquent, les modifications de la end-to-end qualité de vos correspondances résultant de modifications du compromis coût/précision de vos correspondances ne seront généralement pas prises en compte dans l'estimation de la qualité.
#### Étiquettes
Les tags sont des libellés que vous pouvez attribuer à une AWS ressource. Chaque balise est constituée d'une clé et d'une valeur facultative. Les balises peuvent être utilisées pour rechercher et filtrer vos ressources ou pour suivre vos AWS coûts.
## Entraîner les transformations à l’aide d’étiquettes
Vous pouvez entraîner votre transformation ML à l’aide d’étiquettes (exemples) en choisissant **Entraîner une transformation** sur la page de détails de la transformation ML. Lorsque vous entraînez votre algorithme de machine learning en fournissant des exemples (appelés étiquettes), vous pouvez choisir les étiquettes existantes à utiliser ou créer un fichier d’étiquetage.
![\[La capture d’écran montre un écran d’assistant pour Entraîner les transformations à l’aide d’étiquettes.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/machine-learning-teach-transform.png)
+ **Étiquetage** : si vous avez des étiquettes, choisissez **J’ai des étiquettes**. Si vous n’avez pas d’étiquettes, vous pouvez toujours passer à l’étape suivante pour générer un fichier d’étiquettes.
+ **Générer un fichier d’étiquetage** : AWS Glue extrait les enregistrements de vos données sources et suggère des enregistrements correspondants potentiels. Vous choisissez le compartiment Amazon S3 pour stocker le fichier d’étiquette généré. Choisissez **Générer un fichier d’étiquetage** pour démarrer le processus. Lorsque vous avez terminé, choisissez **Télécharger le fichier d’étiquetage**. Le fichier téléchargé comportera une colonne pour les étiquettes dans laquelle vous pourrez remplir les étiquettes.
+ **Charger des étiquettes depuis Amazon S3** : choisissez le fichier d’étiquetage complet dans le compartiment Amazon S3 dans lequel le fichier d’étiquetage est stocké. Choisissez ensuite d’ajouter les étiquettes à vos étiquettes existantes ou de les remplacer. Choisissez **Charger le fichier d’étiquetage depuis Amazon S3**.
# Tutoriel : Création d'une transformation de machine learning avec AWS Glue
Ce didacticiel vous guide tout au long des actions de création et de gestion d'une transformation Machine Learning (ML) à l'aide de AWS Glue. Avant d'utiliser ce tutoriel, vous devez être familiarisé avec l'utilisation de la console AWS Glue pour ajouter des crawlers et des tâches et modifier des scripts. Vous devez également être familiarisé avec la recherche et le téléchargement de fichiers sur la console Amazon Simple Storage Service (Amazon S3).
Dans cet exemple, vous allez créer une `FindMatches` transformation pour rechercher des enregistrements correspondants, l'entraîner à identifier les enregistrements correspondants et les non correspondants, puis l'utiliser dans une tâche AWS Glue. La tâche AWS Glue écrit un nouveau fichier Amazon S3 avec une colonne supplémentaire nommée `match_id`.
Les données source utilisées par ce tutoriel sont un fichier nommé `dblp_acm_records.csv`. Ce fichier est une version modifiée de publications universitaires (DBLP et ACM) disponibles à partir de l'ensemble de données DBLP ACM [ d'origine](https://doi.org/10.3886/E100843V2). Le fichier `dblp_acm_records.csv` est un fichier CSV (valeurs séparées par une virgule) au format UTF-8 sans marque d'ordre d'octet (BOM).
Un second fichier, `dblp_acm_labels.csv`, est un exemple de fichier d'étiquetage qui contient des enregistrements correspondants et non correspondants utilisés pour entraîner la transformation dans le cadre du didacticiel.
**Topics**
+ [Étape 1 : Analyse des données source](#ml-transform-tutorial-crawler)
+ [Étape 2 : Ajouter une transformation de Machine Learning](#ml-transform-tutorial-create)
+ [Étape 3 : Entraîner votre transformation Machine Learning](#ml-transform-tutorial-teach)
+ [Étape 4 : Estimer la qualité de votre transformation Machine Learning](#ml-transform-tutorial-estimate-quality)
+ [Étape 5 : Ajouter et exécuter une tâche avec votre transformation Machine Learning](#ml-transform-tutorial-add-job)
+ [Étape 6 : vérifier les données de sortie d'Amazon S3](#ml-transform-tutorial-data-output)
## Étape 1 : Analyse des données source
Tout d'abord, analysez le le fichier CSV source Amazon S3 pour créer une table de métadonnées correspondante dans Data Catalog.
**Important**
Pour indiquer à le crawler de créer une table pour seulement le fichier CSV, stockez les données source CSV dans un autre dossier Amazon S3 à partir d'autres fichiers.
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, sélectionnez **Crawlers**, **Ajouter un crawler**.
1. Suivez les instructions de l'assistant pour créer et exécuter un crawler nommé `demo-crawl-dblp-acm` avec une sortie dans une base de données `demo-db-dblp-acm`. Lorsque vous exécutez l'assistant, créez la base de données `demo-db-dblp-acm` si elle n'existe pas déjà. Choisissez un chemin d'inclusion Amazon S3 pour obtenir des échantillons de données dans la AWS région actuelle. Par exemple, pour `us-east-1`, le chemin d'inclusion Amazon S3 pour le fichier source est `s3://ml-transforms-public-datasets-us-east-1/dblp-acm/records/dblp_acm_records.csv`.
Si l'opération aboutit, le crawler crée la table `dblp_acm_records_csv` avec les colonnes suivantes : id, title, authors, venue, year et source.
## Étape 2 : Ajouter une transformation de Machine Learning
Ensuite, ajoutez une transformation de Machine Learning basée sur le schéma de votre table source de données créée par le crawler nommé `demo-crawl-dblp-acm`.
1. Sur la console AWS Glue, dans le volet de navigation sous **Intégration des données et ETL**, choisissez **Outils de classification des données > Correspondance des enregistrements**, puis **Ajouter une transformation**. Suivez les instructions de l'assistant pour créer une transformation `Find matches` avec les propriétés suivantes.
1. Pour **Transform name (Nom de transformation)**, entrez **demo-xform-dblp-acm**. Il s'agit du nom de la transformation qui est utilisée pour rechercher des correspondances dans les données source.
1. Pour **IAM role** (Rôle IAM), sélectionnez un rôle IAM qui dispose d'une autorisation sur les données source Amazon S3, le fichier d'étiquetage et les opérations d'API AWS Glue. Pour de plus amples informations, veuillez consulter [Création d'un rôle IAM pour AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/create-an-iam-role.html) dans le *Guide du développeur AWS Glue *.
1. Pour **Source de données**, choisissez la table nommée **dblp\$1acm\$1records\$1csv** dans la base de données. **demo-db-dblp-acm**
1. Pour **Primary key (Clé primaire)**, choisissez la colonne de clé primaire pour la table, **id**.
1. Dans l'assistant, choisissez, choisissez **Finish (Terminer)** et revenez à la liste **ML transforms (Transformations ML)**.
## Étape 3 : Entraîner votre transformation Machine Learning
Ensuite, vous entraînez votre transformation Machine Learning à l'aide du fichier d'étiquetage de l'exemple de didacticiel.
Vous ne pouvez pas utiliser une transformation Machine Language dans une tâche d'extraction, de transformation et de chargement (ETL) tant que son statut n'est pas **Ready for use (Prêt pour utilisation)**. Pour que votre transformation soit prête, vous devez l'entraîner à identifier les enregistrements correspondants et non correspondants en fournissant des exemples d'enregistrements correspondants et non correspondants. Pour entraîner votre transformation, vous pouvez **Générer un fichier d'étiquettes**, ajouter des étiquettes, puis **Télécharger le fichier d'étiquettes**. Dans ce didacticiel, vous pouvez utiliser l'exemple de fichier d'étiquetage nommé `dblp_acm_labels.csv`. Pour plus informations sur le processus d'étiquetage, veuillez consulter [Étiquetage](machine-learning.md#machine-learning-labeling).
1. Sur la console AWS Glue, dans le volet de navigation, sélectionnez **Correspondance des enregistrements**.
1. Choisissez la transformation`demo-xform-dblp-acm`, puis choisissez **Action**, **Teach (Entraîner)**. Suivez les instructions de l'assistant pour entraîner votre transformation `Find matches`.
1. Sur la page des propriétés de transformation, choisissez **I have labels (Je dispose d'étiquettes)**. Choisissez un chemin Amazon S3 vers l'exemple de fichier d'étiquetage dans la AWS région actuelle. Par exemple, pour `us-east-1`, chargez le fichier d'étiquetage fourni à partir du chemin Amazon S3 `s3://ml-transforms-public-datasets-us-east-1/dblp-acm/labels/dblp_acm_labels.csv` avec l'option de **remplacement** des étiquettes existantes. Le fichier d'étiquetage doit se trouver dans Amazon S3 dans la même région que la console AWS Glue.
Lorsque vous chargez un fichier d'étiquetage, une tâche est démarrée dans AWS Glue pour ajouter ou remplacer les étiquettes utilisées pour entraîner la transformation à traiter la source de données.
1. Sur la dernière page de l'assistant, choisissez **Terminer**, puis revenez à la liste **Transformations Machine Learning**.
## Étape 4 : Estimer la qualité de votre transformation Machine Learning
Ensuite, vous pouvez estimer la qualité de votre transformation Machine Learning. La qualité dépend de la quantité d'étiquetage que vous avez effectuée. Pour en savoir plus sur l'estimation de la qualité, consulter [Estimation de la qualité](console-machine-learning-transforms.md#console-machine-learning-transforms-metrics).
1. Sur la console AWS Glue, dans le volet de navigation sous **Intégration des données et ETL**, choisissez **Outils de classification des données > Correspondance des enregistrements**.
1. Choisissez la transformation `demo-xform-dblp-acm`, puis choisissez l'onglet **Estimate quality (Estimation de la qualité)**. Cet onglet affiche les estimations de qualité actuelles, le cas échéant, pour la transformation.
1. Choisissez **Estimation de la qualité** pour démarrer une tâche permettant d'estimer la qualité de la transformation. La précision de l'estimation de la qualité est basée sur l'étiquetage des données source.
1. Accédez à l'onglet **History** (Historique). Dans ce panneau, les exécutions de tâche sont répertoriées pour la transformation, y compris la tâche **Estimation de la qualité**. Pour plus de détails sur l'exécution, choisissez ** Journaux**. Vérifiez que le statut d'exécution est ** Réussite** lorsqu'elle se termine.
## Étape 5 : Ajouter et exécuter une tâche avec votre transformation Machine Learning
Au cours de cette étape, vous utilisez votre transformation Machine Learning pour ajouter et exécuter une tâche dans AWS Glue. Lorsque la transformation `demo-xform-dblp-acm` a le statut **Ready for use (Prête pour utilisation)**, vous pouvez l'utiliser dans une tâche ETL.
1. Sur la console AWS Glue, dans le panneau de navigation, sélectionnez ** Tâches**.
1. Choisissez **Ajouter une tâche**, et suivez les étapes de l'assistant pour créer une tâche ETL Spark avec un script généré. Choisissez les valeurs de propriété suivantes pour votre transformation :
1. Pour **Nom**, choisissez l'exemple de tâche dans ce didacticiel, **demo-etl-dblp-acm**.
1. Pour ** Rôle IAM**, choisissez un rôle IAM qui a une autorisation sur les données source Amazon S3, le fichier d'étiquetage et les opérations d'API AWS Glue. Pour plus informations, veuillez consulter [Création d'un rôle IAM pour AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/create-an-iam-role.html) dans le *Guide du développeur AWS Glue *.
1. Pour **Langage ETL**, choisissez **Scala**. Il s'agit du langage de programmation dans le script ETL.
1. Pour **le nom du fichier de script**, sélectionnez **demo-etl-dblp-acm**. Il s'agit du nom de fichier du script Scala (identique au nom de la tâche).
1. Pour **Data source (Source de données)**, choisissez **dblp\$1acm\$1records\$1csv**. La source de données que vous choisissez doit correspondre au schéma de source de données de la transformation Machine Learning.
1. Pour **Type de transformation**, choisissez **Rechercher des enregistrements correspondants** pour créer une tâche à l'aide d'une transformation Machine Learning.
1. Désactivez ** Enlever les enregistrements en double**. Vous ne souhaitez pas retirer les enregistrements en double car les enregistrements de sortie écrits comportent un champ `match_id` supplémentaire ajouté.
1. Pour **Transform **demo-xform-dblp-acm****, choisissez la transformation d'apprentissage automatique utilisée par la tâche.
1. Pour **Créer des tables dans votre cible de données**, choisissez de créer des tables avec les propriétés suivantes :
+ **Type de magasin de données** — **Amazon S3**
+ **Format** – **CSV**
+ **Type de compression** – **None**
+ **Chemin cible : chemin** Amazon S3 où est écrite la sortie de la tâche (dans la AWS région de console actuelle)
1. Choisissez **Enregistrer la tâche et modifier le script** pour afficher la page de l'éditeur de script.
1. Modifiez le script pour ajouter une instruction qui entraîne l'écriture de la sortie de tâche du **chemin d'accès cible** dans un seul fichier de partition. Ajoutez cette instruction immédiatement après l'instruction qui exécute la transformation `FindMatches`. L'instruction est similaire à ce qui suit.
```
val single_partition = findmatches1.repartition(1)
```
Vous devez modifier l'instruction `.writeDynamicFrame(findmatches1)` pour écrire la sortie en tant que `.writeDynamicFrame(single_partion)`.
1. Une fois que vous avez modifié le script, cliquez sur **Enregistrer**. Le script modifié ressemble au code qui suit, mais personnalisé pour votre environnement.
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.errors.CallSite
import com.amazonaws.services.glue.ml.FindMatches
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]) {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
// @params: [JOB_NAME]
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
// @type: DataSource
// @args: [database = "demo-db-dblp-acm", table_name = "dblp_acm_records_csv", transformation_ctx = "datasource0"]
// @return: datasource0
// @inputs: []
val datasource0 = glueContext.getCatalogSource(database = "demo-db-dblp-acm", tableName = "dblp_acm_records_csv", redshiftTmpDir = "", transformationContext = "datasource0").getDynamicFrame()
// @type: FindMatches
// @args: [transformId = "tfm-123456789012", emitFusion = false, survivorComparisonField = "", transformation_ctx = "findmatches1"]
// @return: findmatches1
// @inputs: [frame = datasource0]
val findmatches1 = FindMatches.apply(frame = datasource0, transformId = "tfm-123456789012", transformationContext = "findmatches1", computeMatchConfidenceScores = true)
// Repartition the previous DynamicFrame into a single partition.
val single_partition = findmatches1.repartition(1)
// @type: DataSink
// @args: [connection_type = "s3", connection_options = {"path": "s3://aws-glue-ml-transforms-data/sal"}, format = "csv", transformation_ctx = "datasink2"]
// @return: datasink2
// @inputs: [frame = findmatches1]
val datasink2 = glueContext.getSinkWithFormat(connectionType = "s3", options = JsonOptions("""{"path": "s3://aws-glue-ml-transforms-data/sal"}"""), transformationContext = "datasink2", format = "csv").writeDynamicFrame(single_partition)
Job.commit()
}
}
```
1. Appuyez sur **Exécuter la tâche)** pour démarrer l'exécution de la tâche. Vérifiez le statut de la tâche dans la liste des tâches. Une fois la tâche terminée, dans l'onglet **Transformation ML**, ** Historique**, une nouvelle ligne **exécution ID** de type ** Tâche ETL** est ajoutée.
1. Accédez à l'onglet **Jobs (Tâches)**, **Historique**. Dans ce panneau, les exécutions de tâches sont répertoriées. Pour plus de détails sur l'exécution, choisissez **Journaux**. Vérifiez que le statut d'exécution est **Réussite** lorsqu'elle se termine.
## Étape 6 : vérifier les données de sortie d'Amazon S3
Au cours de cette étape, vous vérifiez la sortie de la tâche exécutée dans le compartiment Amazon S3 que vous avez choisi lors de l'ajout à la tâche. Vous pouvez télécharger le fichier de sortie sur votre machine locale et vérifier que les enregistrements correspondants ont été identifiés.
1. Ouvrez la console Amazon S3 à l'adresse [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Téléchargez le fichier de sortie cible de la tâche `demo-etl-dblp-acm`. Ouvrez le fichier dans une application de feuille de calcul (vous devrez peut-être ajouter une extension de fichier `.csv` pour que le fichier s'ouvre correctement).
L'image suivante montre un extrait de la sortie dans Microsoft Excel.
![\[Feuille de calcul Excel affichant la sortie de la transformation.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/demo_output_dblp_acm.png)
La source de données et le fichier cible comportent tous deux 4 911 enregistrements. Toutefois, la transformation `Find matches` ajoute une autre colonne nommée `match_id` pour identifier les enregistrements correspondants dans la sortie. Les lignes avec le même `match_id` sont considérées comme des enregistrements correspondants. Le `match_confidence_score` est un nombre compris entre 0 et 1 qui fournit une estimation de la qualité des correspondances trouvées par `Find matches`.
1. Triez le fichier de sortie par `match_id` afin de voir facilement les enregistrements qui sont des correspondances. Comparez les valeurs des autres colonnes pour voir si les résultats de la transformation `Find matches` vous conviennent. Si ce n'est pas le cas, vous pouvez continuer à entraîner la transformation en ajoutant d'autres étiquettes.
Vous pouvez également trier le fichier sur un autre champ, par exemple `title`, pour voir si les enregistrements avec des titres similaires ont le même `match_id`.
# Recherche de correspondances progressives
La fonction Recherche de correspondances vous permet d'identifier les registres en double ou correspondants dans votre jeu de données, même lorsque les registres n'ont pas un identifiant unique commun et qu'aucun champ ne correspond exactement. La version initiale de la recherche de correspondances transforme les registres correspondants identifiés au sein d'un même jeu de données. Lorsque vous ajoutez de nouvelles données au jeu de données, vous deviez les fusionner avec le jeu de données propre existant et exécuter à nouveau la correspondance avec le jeu de données fusionné complet.
La fonction de correspondance progressive facilite la correspondance avec des registres progressifs en comparaison aux jeux de données appariés existants. Supposons que vous souhaitiez associer les données de prospects aux jeux de données clients existants. La fonctionnalité de correspondance progressive vous offre la flexibilité nécessaire pour associer des centaines de milliers de nouveaux prospects à une base de données existante de prospects et de clients en fusionnant les résultats en une seule base de données ou table. En faisant correspondre uniquement les jeux de données nouveaux et existants, l'optimisation de recherche de correspondances progressives réduit le temps de calcul, ce qui réduit également les coûts.
L'utilisation de la correspondance progressive est similaire à celle de la Recherche de correspondances décrite dans [Tutoriel : Création d'une transformation de machine learning avec AWS Glue](machine-learning-transform-tutorial.md). Cette rubrique identifie uniquement les différences avec la correspondance progressive.
Pour en savoir plus, consultez l'article de blog sur [Correspondance progressive des données](https://aws.amazon.com/blogs/big-data/incremental-data-matching-using-aws-lake-formation/).
## Exécution d'une tâche de correspondance progressive
Pour la procédure suivante, supposons la situation suivante :
+ Vous avez exploré le jeu de données existant dans la table *first\$1records*. Le jeu de données *first\$1records* doit être un jeu de données correspondant, ou la sortie de la tâche correspondante.
+ Vous avez créé et entraîné une transformation Recherche de correspondances avec AWS Glue version 2.0. Il s'agit de la seule version de AWS Glue qui prend en charge les correspondances progressives.
+ Le langage ETL est Scala. Notez que Python est également pris en charge.
+ Le modèle déjà généré s'appelle `demo-xform`.
1. Analyse du jeu de données progressif vers la table *second\$1records*.
1. Sur la console AWS Glue, dans le panneau de navigation, sélectionnez **Jobs (Tâches)**.
1. Choisissez **Ajouter une tâche**, et suivez les étapes de l'assistant pour créer une tâche ETL Spark avec un script généré. Choisissez les valeurs de propriété suivantes pour votre transformation :
1. Pour **Nom**, choisissez **demo-etl**.
1. Pour **Rôle IAM**, choisissez un rôle IAM disposant d'une autorisation sur les données source Amazon S3, le fichier d'étiquetage et les [ opérations d'APIAWS Glue](https://docs.aws.amazon.com/glue/latest/dg/create-an-iam-role.html).
1. Pour **Langage ETL**, choisissez **Scala**.
1. Pour **Nom du fichier script**, choisissez **demo-etl**. Il s'agit du nom de fichier du script Scala.
1. Pour **Source de données**, choisissez **first\$1records**. La source de données que vous choisissez doit correspondre au schéma de source de données de la transformation Machine Learning.
1. Pour **Type de transformation**, choisissez **Find matching records Rechercher des enregistrements correspondants** pour créer une tâche à l'aide d'une transformation Machine Learning.
1. Sélectionnez l'option de correspondance progressive, et pour **Source de données** sélectionnez la table nommée **second\$1records**.
1. Pour **Transformation**, choisissez **demo-xform**, la transformation de machine learning utilisée par la tâche.
1. Choisissez **Créer des tables dans votre cible de données** ou **Utiliser les tables du catalogue de données et mettre à jour votre cible de données**.
1. Choisissez **Enregistrer la tâche et modifier le script** pour afficher la page de l'éditeur de script.
1. Choisissez **Exécuter la tâche** pour démarrer l'exécution de la tâche.
# Utilisation FindMatches dans le cadre d'un travail visuel
Pour utiliser la **FindMatches**transformationAWS Glue Studio, vous pouvez utiliser le nœud **Custom Transform** qui appelle l' FindMatches API. Pour plus d'informations sur l'utilisation d'une transformation personnalisée, consultez [Creating a custom transformation](https://docs.aws.amazon.com/glue/latest/ug/transforms-custom.html).
**Note**
Actuellement, l' FindMatches API ne fonctionne qu'avec`Glue 2.0`. Pour exécuter une tâche avec la transformation personnalisée qui appelle l' FindMatches API, assurez-vous que la AWS Glue version se trouve `Glue 2.0` dans l'onglet **Détails de la tâche**. Si la version de ne l'AWS Glueest pas`Glue 2.0`, la tâche échouera lors de l'exécution avec le message d'erreur suivant : « Impossible d'importer le nom « FindMatches » depuis « awsglueml.transform ».
## Conditions préalables
+ Pour utiliser la transformation **Trouver des correspondances**, ouvrez la console AWS Glue Studio sur [https://console.aws.amazon.com/gluestudio/](https://console.aws.amazon.com/gluestudio/).
+ Créer une transformation de machine learning. Une fois créé, un transformId est généré. Vous aurez besoin de cet identifiant pour les étapes ci-dessous. Pour plus d'informations sur la création d'une transformation de machine learning, consultez [Adding and editing machine learning transforms](https://docs.aws.amazon.com/glue/latest/dg/console-machine-learning-transforms.html#console-machine-learning-transforms-actions).
## Ajouter une FindMatches transformation
**Pour ajouter une FindMatches transformation :**
1. Dans l'éditeur de tâches AWS Glue Studio, ouvrez le panneau Ressources en cliquant sur le symbole en forme de croix dans le coin supérieur gauche du graphique visuel des tâches et choisissez une source de données en choisissant l'onglet **Données**. Il s'agit de la source de données pour laquelle vous souhaitez vérifier les correspondances.
![\[La capture d'écran montre un symbole en forme de croix à l'intérieur d'un cercle. Lorsque vous cliquez dessus dans l'éditeur visuel de tâches, le panneau Ressources s'ouvre.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/resource-panel-blank-canvas.png)
1. Choisissez le nœud de source de données, puis ouvrez le panneau Ressources en cliquant sur le symbole en forme de croix dans le coin supérieur gauche du graphique visuel des tâches et recherchez « transformation personnalisée ». Choisissez le nœud **Transformation personnalisée** pour l'ajouter au graphique. La **Transformation personnalisée** est liée au nœud de source de données. Si ce n'est pas le cas, vous pouvez cliquer sur le nœud **Transformation personnalisée** et choisir l'onglet **Propriétés du nœud**, puis sous **Parents du nœud**, choisissez la source de données.
1. Cliquez sur le nœud de **Transformation personnalisée** dans le graphique visuel, puis choisissez l'onglet **Propriétés du nœud** et nommez la transformation personnalisée. Il est recommandé de renommer la transformation afin que son nom soit facilement identifiable dans le graphique visuel.
1. Choisissez l'onglet **Transformer**, dans lequel vous pouvez modifier le bloc de code. C'est ici que le code permettant d'invoquer l' FindMatches API peut être ajouté.
![\[La capture d'écran montre le bloc de code dans l'onglet Transformer lorsque le nœud Transformation personnalisée est sélectionné.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/custom-transform-code-block.png)
Le bloc de code contient un code prérempli pour vous aider à démarrer. Remplacez le code prérempli par le modèle ci-dessous. Le modèle comporte un espace réservé pour le **transformId**, que vous pouvez indiquer.
```
def MyTransform (glueContext, dfc) -> DynamicFrameCollection:
dynf = dfc.select(list(dfc.keys())[0])
from awsglueml.transforms import FindMatches
findmatches = FindMatches.apply(frame = dynf, transformId = "")
return(DynamicFrameCollection({"FindMatches": findmatches}, glueContext))
```
1. Cliquez sur le nœud **Transformation personnalisée** dans le graphique visuel, puis ouvrez le panneau Ressources en cliquant sur le symbole en forme de croix dans le coin supérieur gauche du graphique visuel des tâches et recherchez « Collection Sélectionner depuis ». Il n'est pas nécessaire de modifier la sélection par défaut puisqu'il n'y en a qu'une seule DynamicFrame dans la collection.
1. Vous pouvez continuer à ajouter des transformations ou stocker le résultat, qui est désormais enrichi par les colonnes supplémentaires de recherche de correspondances. Si vous souhaitez référencer ces nouvelles colonnes dans les transformations en aval, vous devez les ajouter au schéma de sortie de la transformation. Le moyen le plus simple est de choisir l'onglet **Aperçu des données**, puis de choisir « Utiliser le schéma d'aperçu des données » dans l'onglet Schéma.
1. Pour personnaliser FindMatches, vous pouvez ajouter des paramètres supplémentaires à transmettre à la méthode « appliquer ». Voir le [FindMatches cours](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-pyspark-transforms-findmatches.html).
## Ajouter une transformation FindMatches incrémentielle
Dans le cas de correspondances incrémentielles, le processus est identique à celui de l'**ajout d'une FindMatches transformation**, avec les différences suivantes :
+ Au lieu d'un nœud parent pour la transformation personnalisée, vous avez besoin de deux nœuds parents.
+ Le premier nœud parent doit être le jeu de données.
+ Le deuxième nœud parent doit être le jeu de données incrémentiel.
Remplacez le `transformId` par votre `transformId` dans le bloc de code du modèle :
```
def MyTransform (glueContext, dfc) -> DynamicFrameCollection:
dfs = list(dfc.values())
dynf = dfs[0]
inc_dynf = dfs[1]
from awsglueml.transforms import FindIncrementalMatches
findmatches = FindIncrementalMatches.apply(existingFrame = dynf, incrementalFrame = inc_dynf,
transformId = "")
return(DynamicFrameCollection({"FindMatches": findmatches}, glueContext))
```
+ Pour les paramètres facultatifs, voir [FindIncrementalMatches class](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-pyspark-transforms-findincrementalmatches.html).
# Migrer les programmes Apache Spark vers AWS Glue
Apache Spark est une plateforme open source pour les charges de travail informatiques distribuées et exécutées sur de vastes jeux de données. AWS Glue tire parti des capacités de Spark pour fournir une expérience optimisée pour l'ETL. Vous pouvez migrer des programmes Spark AWS Glue pour tirer parti de nos fonctionnalités. AWS Glue fournit les mêmes améliorations de performances que celles que vous attendez d'Apache Spark sur Amazon EMR.
## Exécuter le code Spark
Le code Spark natif peut être exécuté dans un AWS Glue environnement prêt à l'emploi. Les scripts sont souvent développés en modifiant une partie de code de manière itérative, afin d’offrir un flux de travail adapté à une session interactive. Cependant, le code existant est plus adapté à une exécution dans le cadre d'une AWS Glue tâche, ce qui vous permet de planifier et d'obtenir régulièrement des journaux et des métriques pour chaque exécution de script. Vous pouvez télécharger et modifier un script existant en utilisant la console.
1. Obtenir la source de votre script. Pour besoin de cet exemple, vous utiliserez un exemple de script du référentiel Apache Spark. [Exemple de binarizer](https://github.com/apache/spark/blob/master/examples/src/main/python/ml/binarizer_example.py)
1. **Dans la AWS Glue console, développez le volet de navigation de gauche et sélectionnez **ETL > Jobs****
Dans le panneau **Créer une tâche**, sélectionnez **Éditeur de script Spark**. Une section **Options** apparaîtra. Dans cette section **Options**, sélectionnez **Chargement et modification d'un script existant**.
Une section de **Chargement du fichier** apparaîtra. Dans cette section **Chargement du fichier**, cliquez sur **Choisissez un fichier**. Le sélecteur de fichiers de votre système s'affichera. Accédez à l'emplacement où vous avez enregistré `binarizer_example.py`, sélectionnez-le et confirmez votre choix.
Une touche **Créer** apparaîtra dans l'en-tête du panneau **Créer une tâche**. Cliquez sur cette touche.
![\[La page AWS Glue Studio Jobs avec le volet de l'éditeur de script Spark est sélectionné.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/migrate-apache-spark-01-upload-job.png)
1. Votre navigateur accèdera à l'éditeur de script. Dans l'en-tête, cliquez sur l’onglet **Détails de la tâche**. Définissez le **Nom** et le **Rôle IAM**. Pour obtenir des conseils sur les rôles AWS Glue IAM, consultez[Configuration des autorisations IAM pour AWS Glue](set-up-iam.md).
Facultativement, définissez le **Nombre de travailleurs** à `2` et**le Nombre de nouvelles tentatives** à `1`. Ces options sont utiles lors de l'exécution de tâches de production. Cependant, leur désactivation simplifiera votre expérience lors du test d'une fonctionnalité.
Dans la barre de titre, cliquez sur**Enregistrer**, puis sur ** Exécuter**
![\[La page des détails de la tâche contient les options définies comme indiquées.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/migrate-apache-spark-02-job-details.png)
1. Accédez à l’onglet **Exécutions**. Vous verrez un panneau correspondant à l’exécution de votre tâche. Patientez quelques minutes, la page devrait s'actualiser automatiquement pour afficher **Réussie** comme **Statut de l'exécution**.
![\[La page exécute la tâche avec un statut d’exécution réussie.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/migrate-apache-spark-03-job-runs.png)
1. Si vous souhaitez examiner votre sortie pour vérifier que le script Spark s'est exécuté comme prévu. Cet échantillon de script Apache Spark doit écrire une chaîne dans le flux de sortie. Vous pouvez le trouver en accédant aux **Journaux** sous **Cloudwatch logs** dans le panneau, pour l'exécution de tâche réussie. Notez l'ID d'exécution de la tâche, un identifiant généré sous le modèle **Id** commençant par`jr_`.
Cela ouvrira la CloudWatch console, configurée pour visualiser le contenu du groupe de AWS Glue journaux par défaut`/aws-glue/jobs/output`, filtré en fonction du contenu des flux de journaux pour l'identifiant d'exécution de la tâche. Chaque programme de travail aura généré un flux de journaux, affiché sous forme de lignes sous **Flux de journaux**. Un programme de travail aurait dû exécuter le code demandé. Vous devrez ouvrir tous les flux de journaux pour identifier le bon programme de travail. Une fois que vous avez trouvé le bon programme de travail, vous devriez voir la sortie du script, comme dans l'image suivante :
![\[La page de CloudWatch console contenant le résultat du programme Spark.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/migrate-apache-spark-04-log-output.png)
## Procédures communes requises pour la migration des programmes Spark
### Évaluation de la prise en charge de la version de Spark
AWS Glue les versions de version définissent la version d'Apache Spark et de Python disponible pour la AWS Glue tâche. Vous pouvez trouver nos AWS Glue versions et ce qu'elles prennent en charge à l'adresse suivante[AWS Glue versions](release-notes.md#release-notes-versions). Vous devrez peut-être mettre à jour votre programme Spark pour qu'il soit compatible avec une version plus récente de Spark afin d'accéder à certaines fonctionnalités AWS Glue .
### Intégration des bibliothèques tierces
De nombreux programmes Spark existants dépendront à la fois d'artefacts privés et publics. AWS Glue prend en charge les dépendances de style JAR pour les tâches Scala, ainsi que les dépendances Wheel et source Pure-Python pour les tâches Python.
**Python** - Pour plus d'informations sur les dépendances Python, consultez [Utiliser les bibliothèques Python avec AWS Glue](aws-glue-programming-python-libraries.md)
Les dépendances Python courantes sont fournies dans l' AWS Glue environnement, y compris la bibliothèque [Pandas](https://pandas.pydata.org/) couramment demandée. Les dépendances sont incluses dans la version 2.0 et les versions ultérieures de AWS Glue . Pour plus d'informations sur les modules fournis, consultez [Modules Python déjà fournis dans AWS Glue](aws-glue-programming-python-libraries.md#glue-modules-provided). Si vous devez fournir à une tâche une version différente d'une dépendance incluse par défaut, vous pouvez utiliser `--additional-python-modules`. Pour plus d'informations sur ces arguments, consultez [Utilisation des paramètres des tâches dans les tâches AWS Glue](aws-glue-programming-etl-glue-arguments.md).
Vous pouvez fournir des dépendances Python supplémentaires avec l’argument de tâche `--extra-py-files`. Si vous migrez une tâche depuis un programme Spark, ce paramètre est une bonne option car il est fonctionnellement équivalent au `--py-files` flag in PySpark, et il est soumis aux mêmes limites. Pour plus d'informations sur le paramètre `--extra-py-files`, consultez [Y compris des fichiers Python dotés de fonctionnalités PySpark natives](aws-glue-programming-python-libraries.md#extra-py-files-support)
Pour les nouvelles tâches, vous pouvez gérer les dépendances Python avec l’argument de tâche `--additional-python-modules`. L'utilisation de cet argument offre une expérience plus profonde de la gestion des dépendances. Ce paramètre prend en charge les dépendances de style Wheel, y compris celles comprenant des liaisons de codes natifs compatibles avec Amazon Linux 2.
**Scala**
Vous pouvez fournir des dépendances Scala supplémentaires avec l’Argument de tâche `--extra-jars`. Les dépendances doivent être hébergées dans Amazon S3, et la valeur de l'argument doit être une liste de chemins non-espacés Amazon S3 délimités par des virgules. Vous trouverez peut-être plus facile de gérer votre configuration en regroupant vos dépendances avant de les héberger et de les configurer. AWS Glue Les dépendances JAR contiennent du bytecode Java, qui peut être généré à partir de n'importe quel langage JVM. Il vous est possible d’utiliser d'autres langages JVM, tels que Java, pour écrire des dépendances personnalisées.
### Gestion des informations d'identification de la source de données
Les programmes Spark existants peuvent être fournis avec une configuration complexe ou personnalisée pour l’extraction des données de leurs sources de données. Les flux d'authentification des sources de données courants sont pris en charge par AWS Glue les connexions. Pour plus d’informations sur les connexions AWS Glue , consultez [Connexion aux données](glue-connections.md).
AWS Glue les connexions facilitent la connexion de votre Job à divers types de magasins de données de deux manières principales : via des appels de méthode vers nos bibliothèques et en configurant la **connexion réseau supplémentaire** dans la AWS console. Vous pouvez également appeler le AWS SDK depuis votre tâche pour récupérer des informations à partir d'une connexion.
**Appels de méthode** : les AWS Glue connexions sont étroitement intégrées au catalogue de AWS Glue données, un service qui vous permet de gérer les informations relatives à vos ensembles de données, et les méthodes disponibles pour interagir avec AWS Glue les connexions en tiennent compte. Si vous avez une configuration d'authentification existante que vous souhaitez réutiliser, pour les connexions JDBC, vous pouvez accéder à votre configuration de AWS Glue connexion via la `extract_jdbc_conf` méthode indiquée sur le. `GlueContext` Pour de plus amples informations, consultez [extract\$1jdbc\$1conf](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-extract_jdbc_conf).
**Configuration de la console** : les AWS Glue tâches utilisent AWS Glue les connexions associées pour configurer les connexions aux sous-réseaux Amazon VPC. Si vous gérez directement votre matériel de sécurité, vous devrez peut-être fournir un `NETWORK` type de **connexion réseau supplémentaire** dans la AWS console pour configurer le routage. Pour plus d'informations sur la connexion API AWS Glue , consultez [API de connexions](aws-glue-api-catalog-connections.md)
Si vos programmes Spark disposent d'un flux d'authentification personnalisé ou peu commun, vous devrez peut-être gérer vos supports de sécurité manuellement. Si AWS Glue les connexions ne vous conviennent pas, vous pouvez héberger en toute sécurité les documents de sécurité dans Secrets Manager et y accéder via le boto3 ou le AWS SDK, fournis dans le cadre de la tâche.
### Configuration d'Apache Spark
Les migrations complexes modifient souvent la configuration de Spark pour s'adapter à leurs charges de travail. Les versions modernes d'Apache Spark permettent de définir la configuration d'exécution à l'aide du`SparkSession`. AWS Glue Les jobs 3.0 et versions ultérieures sont fournis`SparkSession`, qui peuvent être modifiés pour définir la configuration d'exécution. [Configuration d'Apache Spark](https://spark.apache.org/docs/latest/configuration.html). Le réglage de Spark est complexe et AWS Glue ne garantit pas la prise en charge de la configuration de toutes les configurations de Spark. Si votre migration nécessite une configuration importante au niveau de Spark, contactez l'assistance.
### Définition de la configuration
Les programmes Spark migrés peuvent être conçus pour adopter une configuration personnalisée. AWS Glue permet de définir la configuration au niveau de la tâche et de son exécution, via les arguments de la tâche. Pour plus d'informations sur ces arguments, consultez [Utilisation des paramètres des tâches dans les tâches AWS Glue](aws-glue-programming-etl-glue-arguments.md). Vous pouvez accéder aux arguments de tâche dans le contexte d'une tâche par le biais de nos bibliothèques. AWS Glue fournit une fonction utilitaire fournissant une vue cohérente entre les arguments définis lors de la tâche et ceux définis lors de l'exécution de la tâche. Voir [Accès aux paramètres à l'aide de `getResolvedOptions`](aws-glue-api-crawler-pyspark-extensions-get-resolved-options.md) dans Python et [AWS GlueScala GlueArgParser APIs](glue-etl-scala-apis-glue-util-glueargparser.md) dans Scala.
### Migration du code Java
Comme expliqué dans [Intégration des bibliothèques tierces](#glue-author-migrate-apache-spark-third-party-libraries), vos dépendances peuvent contenir des classes générées par les langages JVM, tels que Java ou Scala. Vos dépendances peuvent inclure une Méthode`main`. Vous pouvez utiliser une `main` méthode dans une dépendance comme point d'entrée pour une tâche AWS Glue Scala. Cela vous permet de rédiger votre méthode `main` en langage Java, ou réutilisez une méthode `main` empaquetée selon les normes de votre propre bibliothèque.
Pour utiliser une méthode `main` à partir d'une dépendance, effectuez les opérations suivantes : Effacez le contenu du volet d'édition en fournissant la valeur par défaut de l’objet `GlueApp`. Fournissez le nom complet d'une classe dans une dépendance en tant qu'argument de travail avec la clé `--class`. Vous devez ensuite être en mesure de déclencher une exécution de la tâche.
Vous ne pouvez pas configurer l'ordre ou la structure des AWS Glue arguments transmis à la `main` méthode. Si votre code existant doit lire la configuration définie AWS Glue, cela entraînera probablement une incompatibilité avec le code précédent. Si vous utilisez `getResolvedOptions`, vous ne disposerez pas d’un espace approprié pour appeler cette méthode. Envisagez d'invoquer votre dépendance directement, à partir d'une méthode principale générée par AWS Glue. Le script AWS Glue ETL suivant en montre un exemple.
```
import com.amazonaws.services.glue.util.GlueArgParser
object GlueApp {
def main(sysArgs: Array[String]) {
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
// Invoke static method from JAR. Pass some sample arguments as a String[], one defined inline and one taken from the job arguments, using getResolvedOptions
com.mycompany.myproject.MyClass.myStaticPublicMethod(Array("string parameter1", args("JOB_NAME")))
// Alternatively, invoke a non-static public method.
(new com.mycompany.myproject.MyClass).someMethod()
}
}
```
# Travailler avec Ray Jobs dans AWS Glue
**Important**
AWS Glue for Ray ne sera plus ouvert aux nouveaux clients à compter du 30 avril 2026. Si vous souhaitez utiliser AWS Glue for Ray, inscrivez-vous avant cette date. Les clients existants peuvent continuer à utiliser le service normalement. Pour des fonctionnalités similaires à celles de AWS Glue for Ray, explorez Amazon EKS. Pour plus d'informations, consultez la section [AWS Glue relative à la fin du support de Ray](https://docs.aws.amazon.com/glue/latest/dg/awsglue-ray-jobs-availability-change.html).
Cette section fournit des informations sur l'utilisation AWS Glue des tâches For Ray. Pour plus d'informations sur l'écriture de scripts AWS Glue pour Ray, consultez la [Programmation de scripts Ray](aws-glue-programming-ray.md) section.
**Topics**
+ [Commencer avec AWS Glue For Ray](#author-job-ray-using)
+ [Environnements d'exécution Ray pris en charge](#author-job-ray-runtimes)
+ [Comptabilité pour les travailleurs dans les tâches Ray](#author-job-ray-worker-accounting)
+ [Utilisation des paramètres de tâche dans les tâches Ray](author-job-ray-job-parameters.md)
+ [Surveiller les tâches Ray à l'aide de métriques](author-job-ray-monitor.md)
## Commencer avec AWS Glue For Ray
Pour travailler avec AWS Glue for Ray, vous utilisez les mêmes AWS Glue tâches et sessions interactives que AWS Glue pour Spark. AWS Glue les tâches sont conçues pour exécuter le même script à une cadence récurrente, tandis que les sessions interactives sont conçues pour vous permettre d'exécuter des extraits de code de manière séquentielle sur les mêmes ressources provisionnées.
AWS Glue ETL et Ray sont différents en dessous, donc dans votre script, vous avez accès à différents outils, fonctionnalités et configurations. En tant que nouveau framework de calcul géré par AWS Glue, Ray possède une architecture différente et utilise un vocabulaire différent pour décrire ce qu'il fait. Pour plus d'informations, consultez les [livres blancs sur l'architecture](https://docs.ray.io/en/latest/ray-contribute/whitepaper.html) de la documentation Ray.
**Note**
AWS Glue for Ray est disponible dans l'est des États-Unis (Virginie du Nord), dans l'est des États-Unis (Ohio), dans l'ouest des États-Unis (Oregon), en Asie-Pacifique (Tokyo) et en Europe (Irlande).
### Ray Jobs dans la AWS Glue Studio console
Sur la **page** Tâches de la AWS Glue Studio console, vous pouvez sélectionner une nouvelle option lorsque vous créez une tâche dans AWS Glue Studio l'**éditeur de script Ray**. Choisissez cette option pour créer une tâche Ray sur la console. Pour plus d'informations sur ces tâches et leur utilisation, consultez [Création de tâches ETL visuelles](author-job-glue.md).
![\[La page Jobs AWS Glue Studio apparaît avec l'option Ray Script editor sélectionnée.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/ray_job_setup.png)
### Offres d'emploi Ray dans le SDK AWS CLI et
Les tâches Ray AWS CLI utilisent les mêmes actions et paramètres du SDK que les autres tâches. AWS Glue for Ray introduit de nouvelles valeurs pour certains paramètres. Pour plus d'informations sur l'API Tâches, consultez [Tâches](aws-glue-api-jobs-job.md).
## Environnements d'exécution Ray pris en charge
Dans les tâches Spark, `GlueVersion` détermine les versions d'Apache Spark et de Python disponibles dans une tâche AWS Glue pour Spark. La version de Python indique la version qui est prise en charge pour les tâches de type Spark. Les environnements d'exécution Ray ne sont pas configurés de cette manière.
Pour les tâches Ray vous devez définir `GlueVersion` sur `4.0` ou supérieur. Toutefois, les versions de Ray, de Python et des bibliothèques supplémentaires disponibles dans votre tâche Ray sont déterminées par le champ `Runtime` de la définition de la tâche.
L'environnement d'exécution `Ray2.4` sera disponible pendant au moins six mois après sa sortie. Au fur et à mesure de l'évolution rapide de Ray, vous pourrez intégrer les mises à jour et les améliorations de Ray dans les futures versions de l'environnement d'exécution.
Valeurs valides : `Ray2.4`
| Valeur d'exécution | Versions Ray et Python |
| --- | --- |
| Ray2.4 (pour la version 4.0 et ultérieure de AWS Glue) | Ray 2.4.0 Python 3.9 |
**Informations supplémentaires**
+ Pour les notes de publication qui accompagnent AWS Glue les versions de Ray, voir[AWS Glue versions](release-notes.md#release-notes-versions).
+ Pour les bibliothèques Python fournies dans un environnement d'exécution, consultez [Modules fournis avec les tâches Ray](edit-script-ray-env-dependencies.md#edit-script-ray-modules-provided).
## Comptabilité pour les travailleurs dans les tâches Ray
AWS Glue exécute des tâches Ray sur de nouveaux types de travailleurs EC2 basés sur Graviton, qui ne sont disponibles que pour les tâches Ray. Afin de bien approvisionner ces travailleurs pour les charges de travail pour lesquelles Ray est conçu, nous fournissons un rapport différent entre les ressources de calcul et les ressources de mémoire de la plupart des travailleurs. Afin de tenir compte de ces ressources, nous utilisons l'unité de traitement des données à mémoire optimisée (M-DPU) plutôt que l'unité de traitement de données standard (DPU).
+ Un M-DPU correspond à 4 V CPUs et à 32 Go de mémoire.
+ Un DPU correspond à 4 V CPUs et 16 Go de mémoire. DPUs sont utilisés pour prendre en compte les ressources dans AWS Glue les tâches Spark et les travailleurs correspondants.
Les tâches Ray ont actuellement accès à un type de travailleur : `Z.2X`. Le `Z.2X` worker correspond à 2 M- DPUs (8 VCPUs, 64 Go de mémoire) et dispose de 128 Go d'espace disque. Une machine `Z.2X` fournit huit travailleurs Ray (un par vCPU).
Le nombre de M- DPUs que vous pouvez utiliser simultanément dans un compte est soumis à un quota de service. Pour plus d'informations sur les limites de votre AWS Glue compte, consultez la section [AWS Glue Points de terminaison et quotas](https://docs.aws.amazon.com/general/latest/gr/glue.html).
Vous indiquez le nombre de composants master disponibles pour une tâche Ray avec `--number-of-workers (NumberOfWorkers)` dans la définition de la tâche. Pour plus d'informations sur les valeurs Ray dans l'API Tâches, consultez [Tâches](aws-glue-api-jobs-job.md).
Vous pouvez également indiquer le nombre minimum de travailleurs qu'une tâche Ray doit allouer avec le paramètre de tâche `--min-workers`. Pour de plus amples informations sur la définition des paramètres de la tâche, consultez [Référence](author-job-ray-job-parameters.md#author-job-ray-parameters-reference).
# Utilisation des paramètres de tâche dans les tâches Ray
**Important**
AWS Glue for Ray ne sera plus ouvert aux nouveaux clients à compter du 30 avril 2026. Si vous souhaitez utiliser AWS Glue for Ray, inscrivez-vous avant cette date. Les clients existants peuvent continuer à utiliser le service normalement. Pour des fonctionnalités similaires à celles de AWS Glue for Ray, explorez Amazon EKS. Pour plus d'informations, consultez la section [AWS Glue relative à la fin du support de Ray](https://docs.aws.amazon.com/glue/latest/dg/awsglue-ray-jobs-availability-change.html).
Vous définissez les arguments pour les tâches AWS Glue Ray de la même manière que AWS Glue pour les tâches Spark. Pour plus d'informations sur l' AWS Glue API, consultez[Tâches](aws-glue-api-jobs-job.md). Vous pouvez configurer les tâches AWS Glue Ray avec différents arguments, qui sont répertoriés dans cette référence. Vous pouvez également fournir vos propres arguments.
Vous pouvez configurer une tâche via la console, dans l'onglet **Job details** (Détails de la tâche), sous **Job Parameters** (Paramètres de la tâche). Vous pouvez également configurer une tâche AWS CLI par le biais du paramètre `DefaultArguments` sur une tâche ou `Arguments` sur une exécution de tâche. Les arguments par défaut et les paramètres de la tâche restent associés à la tâche au fil des exécutions.
Par exemple, ce qui suit est la syntaxe pour exécuter une tâche en utilisant `--arguments` pour définir un paramètre spécial.
```
$ aws glue start-job-run --job-name "CSV to CSV" --arguments='--scriptLocation="s3://my_glue/libraries/test_lib.py",--test-environment="true"'
```
Après avoir défini les arguments, vous pouvez accéder aux paramètres de la tâche depuis votre tâche Ray via des variables d'environnement. Vous pouvez ainsi configurer votre tâche pour chaque exécution. Le nom de la variable d'environnement correspond au nom de l'argument de la tâche sans le préfixe `--`.
Par exemple, dans l'exemple précédent, les noms des variables sont `scriptLocation` et `test-environment`. Vous pouvez ensuite récupérer l'argument via les méthodes disponibles dans la bibliothèque standard : `test_environment = os.environ.get('test-environment')`. Pour plus d'informations sur l'accès aux variables d'environnement avec Python, consultez le [module os](https://docs.python.org/3/library/os.html) dans la documentation Python.
## Configuration de la façon dont les tâches Ray génèrent des journaux
Par défaut, les tâches Ray génèrent des journaux et des métriques qui sont envoyés à CloudWatch Amazon S3. Vous pouvez utiliser le paramètre `--logging_configuration` pour modifier la façon dont les journaux sont générés. Vous pouvez actuellement l’utiliser pour empêcher les tâches Ray de générer différents types de journaux. Ce paramètre prend un objet JSON dont les clés correspondent à celles que logs/behaviors vous souhaitez modifier. Il prend en charge les clés suivantes :
+ `CLOUDWATCH_METRICS`— Configure des séries de CloudWatch métriques qui peuvent être utilisées pour visualiser l'état de santé au travail. Pour plus d'informations sur les métriques, consultez la section [Surveiller les tâches Ray à l'aide de métriques](author-job-ray-monitor.md).
+ `CLOUDWATCH_LOGS`— Configure les CloudWatch journaux qui fournissent des informations détaillées au niveau de l'application Ray sur l'état d'exécution de la tâche. Pour de plus amples informations sur les journaux, veuillez consulter [Résolution AWS Glue des erreurs Ray liées aux journaux](troubleshooting-ray.md).
+ `S3`— Configure ce qui est AWS Glue écrit sur Amazon S3, principalement des informations similaires aux CloudWatch journaux, mais sous forme de fichiers plutôt que de flux de journaux.
Pour désactiver un comportement de journalisation de Ray, indiquez la valeur `{\"IS_ENABLED\": \"False\"}`. Par exemple, pour désactiver CloudWatch les métriques et CloudWatch les journaux, fournissez la configuration suivante :
```
"--logging_configuration": "{\"CLOUDWATCH_METRICS\": {\"IS_ENABLED\": \"False\"}, \"CLOUDWATCH_LOGS\": {\"IS_ENABLED\": \"False\"}}"
```
## Référence
Les tâches Ray reconnaissent les noms d'arguments suivants que vous pouvez utiliser afin de configurer l'environnement de script pour vos tâches Ray et vos exécutions de tâche :
+ `--logging_configuration` : utilisé pour arrêter la génération de divers journaux créés par les tâches Ray. Ces journaux sont générés par défaut pour toutes les tâches Ray. Format : objet JSON en séquence d’échappement. Pour de plus amples informations, veuillez consulter [Configuration de la façon dont les tâches Ray génèrent des journaux](#author-job-ray-logging-configuration).
+ `--min-workers` : nombre minimum de composants master alloués à une tâche Ray. Un composant master peut exécuter plusieurs réplicas, un par processeur virtuel. Format : nombre entier. Minimum : 0. Maximum : valeur spécifiée dans `--number-of-workers (NumberOfWorkers)`, dans la définition de la tâche. Pour plus d'informations sur la comptabilisation des composants master, consultez [Comptabilité pour les travailleurs dans les tâches Ray](ray-jobs-section.md#author-job-ray-worker-accounting).
+ `--object_spilling_config`— AWS Glue for Ray prend en charge l'utilisation d'Amazon S3 pour étendre l'espace disponible dans le magasin d'objets de Ray. Pour activer ce comportement, vous pouvez fournir à Ray un objet de configuration JSON pour le *déversement d'objets* avec ce paramètre. Pour plus d'informations sur la configuration du déversement d'objets dans Ray, consulter [Object Spilling](https://docs.ray.io/en/latest/ray-core/objects/object-spilling.html) dans la documentation Ray. Format : objet JSON.
AWS Glue for Ray ne prend en charge que le déversement sur le disque ou le déversement sur Amazon S3 en une seule fois. Vous pouvez indiquer plusieurs emplacements pour le déversement, à condition qu'ils respectent cette limite. Lors du déversement sur Amazon S3, vous devez également ajouter des autorisations IAM à votre tâche pour ce compartiment.
Lorsque vous fournissez un objet JSON en tant que configuration avec la CLI, vous devez le fournir sous forme de chaîne, avec la chaîne de l'objet JSON échappée. Par exemple, une valeur de chaîne pour le déversement vers un chemin Amazon S3 ressemblerait à ce qui suit : `"{\"type\": \"smart_open\", \"params\": {\"uri\":\"s3path\"}}"`. Dans AWS Glue Studio, fournissez ce paramètre sous forme d'objet JSON sans mise en forme supplémentaire.
+ `--object_store_memory_head` : mémoire allouée au magasin d'objets Plasma sur le nœud principal Ray. Cette instance exécute des services de gestion de clusters, ainsi que des réplicas de travail. La valeur représente un pourcentage de mémoire disponible sur l'instance après un démarrage à chaud. Vous utilisez ce paramètre pour régler les charges de travail gourmandes en mémoire. Les valeurs par défaut sont acceptables pour la plupart des cas d'utilisation. Format : entier positif. Minimum : 1. Maximum : 100.
Pour plus d'informations sur Plasma, consultez [The Plasma In-Memory Object Store](https://ray-project.github.io/2017/08/08/plasma-in-memory-object-store.html) (Le magasin d'objets en mémoire Plasma) dans la documentation Ray.
+ `--object_store_memory_worker` : mémoire allouée au magasin d'objets Plasma sur les composants master Ray. Ces instances exécutent uniquement des réplicas de travail. La valeur représente un pourcentage de mémoire disponible sur l’instance après un démarrage à chaud. Ce paramètre est utilisé pour régler les charges de travail gourmandes en mémoire. Les valeurs par défaut sont acceptables pour la plupart des cas d'utilisation. Format : entier positif. Minimum : 1. Maximum : 100.
Pour plus d’informations sur Plasma, consultez [The Plasma In-Memory Object Store](https://ray-project.github.io/2017/08/08/plasma-in-memory-object-store.html) (Le magasin d’objets en mémoire Plasma) dans la documentation Ray.
+ `--pip-install` : ensemble de packages Python à installer. Vous pouvez installer des packages depuis PyPI en utilisant cet argument. Format : liste délimitée par des virgules.
Une entrée de package PyPI est au format `package==version`, avec le nom PyPI et la version de votre package cible. Les entrées utilisent la correspondance entre versions de Python pour faire correspondre le package et la version, comme `==` et non le signe `=` seul. Il existe d'autres opérateurs de mise en correspondance des versions. Pour plus d'informations, consultez [PEP 440](https://peps.python.org/pep-0440/#version-matching) sur le site Internet de Python. Vous pouvez également fournir des modules personnalisés avec `--s3-py-modules`.
+ `--s3-py-modules` : un ensemble de chemins Amazon S3 qui hébergent des distributions de modules Python. Format : liste délimitée par des virgules.
Vous pouvez l'utiliser pour distribuer vos propres modules à votre tâche Ray. Vous pouvez également fournir des modules à partir de PyPI avec `--pip-install`. Contrairement à l' AWS Glue ETL, les modules personnalisés ne sont pas configurés via pip, mais sont transmis à Ray pour distribution. Pour de plus amples informations, veuillez consulter [Modules Python supplémentaires pour les tâches Ray](edit-script-ray-env-dependencies.md#edit-script-ray-python-libraries-additional).
+ `--working-dir` : un chemin d'accès à un fichier .zip hébergé sur Amazon S3 contenant les fichiers à distribuer à tous les nœuds exécutant votre tâche Ray. Format : chaîne. Pour de plus amples informations, veuillez consulter [Fournir des fichiers à votre tâche Ray](edit-script-ray-env-dependencies.md#edit-script-ray-working-directory).
# Surveiller les tâches Ray à l'aide de métriques
**Important**
AWS Glue for Ray ne sera plus ouvert aux nouveaux clients à compter du 30 avril 2026. Si vous souhaitez utiliser AWS Glue for Ray, inscrivez-vous avant cette date. Les clients existants peuvent continuer à utiliser le service normalement. Pour des fonctionnalités similaires à celles de AWS Glue for Ray, explorez Amazon EKS. Pour plus d'informations, consultez la section [AWS Glue relative à la fin du support de Ray](https://docs.aws.amazon.com/glue/latest/dg/awsglue-ray-jobs-availability-change.html).
Vous pouvez suivre les jobs de Ray à l'aide AWS Glue Studio d'Amazon CloudWatch. CloudWatch collecte et traite les métriques brutes issues AWS Glue de Ray, ce qui les rend disponibles pour analyse. Ces mesures sont visualisées dans la AWS Glue Studio console, afin que vous puissiez surveiller votre tâche pendant son exécution.
Pour une présentation générale du mode de surveillance AWS Glue, voir[Surveillance AWS Glue à l'aide CloudWatch des métriques Amazon](monitoring-awsglue-with-cloudwatch-metrics.md). Pour un aperçu général de l'utilisation CloudWatch des métriques publiées par AWS Glue, voir[Surveillance avec Amazon CloudWatch](monitor-cloudwatch.md).
## Surveillance des tâches de Ray dans la AWS Glue console
Sur la page de détails d'une exécution de tâche, sous la section **Détails de l'exécution**, vous pouvez consulter des graphiques agrégés prédéfinis qui visualisent les indicateurs de vos tâches disponibles. AWS Glue Studio envoie des métriques de tâche CloudWatch pour chaque exécution de tâche. Vous pouvez ainsi créer un profil de votre cluster et de vos tâches, ainsi qu'accéder à des informations détaillées sur chaque nœud.
Pour plus d'informations sur les graphiques de métriques disponibles, consultez [Afficher Amazon CloudWatch les statistiques relatives à l'exécution d'une tâche Ray](view-job-runs.md#monitoring-job-run-metrics-ray).
## Vue d'ensemble des indicateurs de Ray Jobs dans CloudWatch
Nous publions les métriques Ray lorsque la surveillance détaillée est activée dans CloudWatch. Les métriques sont publiées dans l'espace de `Glue/Ray` CloudWatch noms.
+ **Métriques des instances**
Nous publions des métriques sur l'utilisation du processeur, de la mémoire et du disque des instances affectées à une tâche. Ces métriques sont identifiées par des fonctionnalités telles que `ExecutorId`, `ExecutorType` et `host`. Ces métriques constituent un sous-ensemble des métriques standard des CloudWatch agents Linux. Vous trouverez des informations sur les noms et les fonctionnalités des métriques dans la CloudWatch documentation. Pour plus d'informations, consultez la section [Mesures collectées par l' CloudWatch agent](https://docs.aws.amazon.com//AmazonCloudWatch/latest/monitoring/metrics-collected-by-CloudWatch-agent.html).
+ **Métriques du cluster Ray**
Nous transmettons les métriques des processus Ray qui exécutent votre script à cet espace de noms, puis nous vous fournissons celles qui sont les plus essentielles pour vous. Les mesures disponibles peuvent varier selon la version de Ray. Pour plus d'informations sur la version de Ray exécutée par votre tâche, consultez [AWS Glue versions](release-notes.md).
Ray collecte des métriques au niveau de l'instance. Il fournit également des métriques pour les tâches et le cluster. Pour plus d'informations sur la stratégie métrique sous-jacente de Ray, consultez [Metrics](https://docs.ray.io/en/latest/ray-observability/ray-metrics.html#system-metrics) dans la documentation Ray.
**Note**
Nous ne publions pas les métriques Ray dans l'espace de noms `Glue/Job Metrics/`, qui n'est utilisé que pour les tâches AWS Glue ETL.
# Configuration des propriétés pour les tâches shell Python dans AWS Glue
Vous pouvez utiliser une tâche shell Python pour exécuter des scripts Python en tant que shell dans AWS Glue. Avec une tâche shell Python, vous pouvez exécuter des scripts compatibles avec Python 3.6 ou Python 3.9.
**Note**
La prise en charge de Pyshell 3.6 prendra fin le 1er mars 2026. Pour migrer vos charges de travail, voir [Migrer depuis des tâches shell AWS Glue Python](https://docs.aws.amazon.com/glue/latest/dg/pyshell-migration.html). Si vous souhaitez continuer avec Python shell 3.9, consultez [Migration du shell Python 3.6 vers le shell Python 3.9](#migrating-version-pyshell36-to-pyshell39).
**Topics**
+ [Limitations](#python-shell-limitations)
+ [Environnement d’exécution](#python-shell-execution-environment)
+ [Définition des propriétés pour les tâches shell Python](#create-job-python-properties)
+ [Bibliothèques prises en charge pour les tâches shell Python](#python-shell-supported-library)
+ [Ajout de votre propre bibliothèque Python](#create-python-extra-library)
+ [À utiliser AWS CloudFormation avec les jobs shell Python dans AWS Glue](#python-shell-jobs-cloudformation)
+ [Migration du shell Python 3.6 vers le shell Python 3.9](#migrating-version-pyshell36-to-pyshell39)
+ [Migrer depuis les jobs shell AWS Glue Python](pyshell-migration.md)
## Limitations
Notez les limitations suivantes des tâches shell Python :
+ Vous ne pouvez pas utiliser les signets de tâche avec les tâches shell Python.
+ Vous ne pouvez pas conditionner les bibliothèques Python sous forme de fichiers `.egg` dans la version 3.9 de Python et les versions ultérieures. Utilisez à la place `.whl`.
+ L’option `--extra-files` ne peut pas être utilisée en raison de la limitation des copies temporaires des données S3.
## Environnement d’exécution
Les tâches shell Python s'exécutent dans un environnement d'exécution géré qui fournit un accès au stockage local pour le traitement temporaire des données :
**Stockage temporaire local**
Le `/tmp` répertoire est disponible pour un stockage temporaire pendant l'exécution de la tâche. Ce répertoire fournit environ 14 GiB d'espace libre que vous pouvez utiliser pour :
+ Traitement de fichiers temporaires
+ Stockage de données intermédiaire
+ Mise en cache de petits ensembles de données
Le `/tmp` répertoire est éphémère et est nettoyé une fois le travail terminé. Ne l'utilisez pas pour le stockage permanent de données importantes.
## Définition des propriétés pour les tâches shell Python
Ces sections décrivent la définition des propriétés des tâches dans AWS Glue Studio ou à l'aide de la AWS CLI.
### AWS Glue Studio
Lorsque vous définissez votre tâche Python shell dans AWS Glue Studio, vous indiquez les propriétés suivantes :
**Rôle IAM**
Spécifiez le rôle Gestion des identités et des accès AWS (IAM) utilisé pour autoriser les ressources utilisées pour exécuter le travail et accéder aux magasins de données. Pour plus d'informations sur les autorisations requises pour exécuter des tâches dans AWS Glue, consultez [Gestion des identités et des accès pour AWS Glue](security-iam.md).
**Type**
Choisissez **Python shell (shell Python)** pour exécuter un script Python avec la commande de tâche nommée `pythonshell`.
**Version de Python**
Choisissez la version Python. La valeur par défaut est Python 3.9. Les versions valides sont Python 3.6 et Python 3.9.
**Charger des bibliothèques d’analyse courantes (recommandé)**
Choisissez cette option pour inclure les bibliothèques courantes pour Python 3.9 dans le Python shell.
Si vos bibliothèques sont personnalisées ou si elles sont en conflit avec les bibliothèques préinstallées, vous pouvez choisir de ne pas installer de bibliothèques courantes. Cependant, vous pouvez installer des bibliothèques supplémentaires en plus des bibliothèques courantes.
Lorsque vous sélectionnez cette option, l’option `library-set` est définie sur `analytics`. Lorsque vous désélectionnez cette option, l’option `library-set` est définie sur `none`.
**Nom du fichier de script et chemin du script**
Le code inclus dans le script permet de définir la logique procédurale de votre tâche. Vous fournissez le nom et l'emplacement du script dans Amazon Simple Storage Service (Amazon S3). Vérifiez qu'il n'existe pas de fichier portant le même nom que le répertoire de script dans le chemin d'accès. Pour en savoir plus sur les scripts, consultez [AWS Glue guide de programmation](edit-script.md).
**Script**
Le code inclus dans le script permet de définir la logique procédurale de votre tâche. Vous pouvez coder ce script dans Python 3.6 ou Python 3.9. Vous pouvez modifier un script dans AWS Glue Studio.
**Unités de traitement de données**
Nombre maximal d'unités de traitement de AWS Glue données (DPUs) pouvant être allouées lors de l'exécution de cette tâche. Un DPU est une mesure relative de la puissance de traitement composée de 4 V de capacité CPUs de calcul et de 16 Go de mémoire. Pour en savoir plus, consultez [PricingAWS Glue](https://aws.amazon.com/glue/pricing/) (Tarification).
Vous pouvez affecter la valeur 0.0625 ou 1. La valeur par défaut est 0.0625. Dans les deux cas, le disque local de l’instance sera de 20 Go.
### INTERFACE DE LIGNE DE COMMANDE (CLI)
Vous pouvez également créer une tâche **shell Python** à l'aide de AWS CLI, comme dans l'exemple suivant.
```
aws glue create-job --name python-job-cli --role Glue_DefaultRole
--command '{"Name" : "pythonshell", "PythonVersion": "3.9", "ScriptLocation" : "s3://amzn-s3-demo-bucket/scriptname.py"}'
--max-capacity 0.0625
```
**Note**
Il n’est pas nécessaire de spécifier la version d’AWS Glue, puisque le paramètre `--glue-version` ne s’applique pas aux tâches shell AWS Glue. Toute version spécifiée sera ignorée.
Tâches que vous créez avec Python 3 AWS CLI par défaut. Les versions valides de Python sont 3 (correspondant à 3.6), et 3.9. Pour spécifier Python 3.6, ajoutez ce tuple au paramètre `--command` : `"PythonVersion":"3"`
Pour spécifier Python 3.9, ajoutez ce tuple au paramètre `--command` : `"PythonVersion":"3.9"`
Pour définir la capacité maximale utilisée par une tâche shell Python, définissez le paramètre `--max-capacity`. Pour les tâches shell Python, le paramètre `--allocated-capacity` ne peut pas être utilisé.
## Bibliothèques prises en charge pour les tâches shell Python
Dans le Python shell utilisant Python 3.9, vous pouvez choisir l’ensemble de bibliothèques qui utilisera les ensembles de bibliothèques préemballés selon vos besoins. Vous pouvez utiliser l’option `library-set` pour choisir l’ensemble de bibliothèques. Les valeurs valides sont `analytics`, et `none`.
L’environnement pour exécuter une tâche shell Python prend en charge les bibliothèques suivantes :
| Version de Python | Python 3.6 | Python 3.9 |
| --- | --- | --- |
| Ensemble de bibliothèques | S/O | analytique | Aucun(e) |
| avro | | 1.11.0 | |
| awscli | 116,242 | 1,23,5 | 1,23,5 |
| awswrangler | | 2.15.1 | |
| botocore | 1,12,232 | 1,24,21 | 1,23,5 |
| boto3 | 1,9,203 | 1,21,21 | |
| elasticsearch | | 8.2.0 | |
| numpy | 1.16,2 | 1.22.3 | |
| pandas | 0,24,2 | 1.4.2 | |
| psycopg2 | | 2.9.3 | |
| pyathena | | 2.5.3 | |
| PyGreSQL | 5.0.6 | | |
| PyMySQL | | 1.0.2 | |
| pyodbc | | 4,0,32 | |
| pyorc | | 0.6.0 | |
| redshift-connector | | 2,0.907 | |
| demandes | 2.22.0 | 2.27.1 | |
| scikit-learn | 0,20,3 | 1.0.2 | |
| scipy | 1.2.1 | 1.8.0 | |
| SQLAlchemy | | 1,4,36 | |
| s3fs | | 2022.3.0 | |
Vous pouvez utiliser la bibliothèque `NumPy` dans une tâche shell Python à des fins de calcul scientifique. Pour de plus amples informations, veuillez consulter [NumPy](http://www.numpy.org). L'exemple suivant montre un NumPy script qui peut être utilisé dans une tâche shell Python. Le script inscrit « Hello world » et les résultats de plusieurs calculs mathématiques.
```
import numpy as np
print("Hello world")
a = np.array([20,30,40,50])
print(a)
b = np.arange( 4 )
print(b)
c = a-b
print(c)
d = b**2
print(d)
```
## Ajout de votre propre bibliothèque Python
### Utilisation de PIP
Le Python shell utilisant Python 3.9 vous permet de fournir des modules Python supplémentaires ou des versions différentes au niveau de la tâche. Vous pouvez utiliser l’option `--additional-python-modules` avec une liste de modules Python séparés par des virgules pour ajouter un nouveau module ou modifier la version d’un module existant. Vous ne pouvez pas fournir de modules Python personnalisés hébergés sur Amazon S3 avec ce paramètre lorsque vous utilisez des tâches shell Python.
Par exemple, pour mettre à jour ou ajouter un nouveau module `scikit-learn`, utilisez la clé et la valeur suivantes : `"--additional-python-modules", "scikit-learn==0.21.3"`.
AWS Glue utilise le programme d’installation de package Python (pip3) pour installer les modules supplémentaires. Vous pouvez transmettre des options pip3 supplémentaires à l’intérieur de la valeur `--additional-python-modules`. Par exemple, `"scikit-learn==0.21.3 -i https://pypi.python.org/simple/"`. Toutes les incompatibilités ou limitations de pip3 s’appliquent.
**Note**
Pour éviter les incompatibilités à l’avenir, nous vous recommandons d’utiliser des bibliothèques créées pour Python 3.9.
### Utilisation d’un fichier Egg ou Whl
Vous avez peut-être déjà une ou plusieurs bibliothèques Python empaquetées sous la forme d’un fichier `.egg` ou `.whl`. Le cas échéant, vous pouvez les spécifier pour votre tâche à l’aide du AWS Command Line Interface (AWS CLI) sous l’indicateur « `--extra-py-files` », comme dans l’exemple suivant.
```
aws glue create-job --name python-redshift-test-cli --role role --command '{"Name" : "pythonshell", "ScriptLocation" : "s3://MyBucket/python/library/redshift_test.py"}'
--connections Connections=connection-name --default-arguments '{"--extra-py-files" : ["s3://amzn-s3-demo-bucket/EGG-FILE", "s3://amzn-s3-demo-bucket/WHEEL-FILE"]}'
```
Si vous n’êtes pas sûr de la façon de créer un fichier `.egg` ou `.whl` à partir d’une bibliothèque Python, procédez comme suit. Cet exemple est applicable sur macOS, Linux et WSL (sous-système Windows pour Linux).
**Pour créer un fichier Python .egg ou .whl**
1. Créez un cluster Amazon Redshift dans un Virtual Private Cloud (VPC) et ajoutez des données dans une table.
1. Créez une AWS Glue connexion pour la VPC-SecurityGroup-Subnet combinaison que vous avez utilisée pour créer le cluster. Testez le bon fonctionnement de cette connexion.
1. Créez un répertoire nommé `redshift_example` et un fichier nommé `setup.py`. Collez le code suivant dans .
```
from setuptools import setup
setup(
name="redshift_module",
version="0.1",
packages=['redshift_module']
)
```
1. Dans le répertoire `redshift_example`, créez un répertoire `redshift_module`. Dans le répertoire `redshift_module`, créez les fichiers `__init__.py` et `pygresql_redshift_common.py`.
1. Laissez le fichier `__init__.py` vide. Collez le code suivant dans `pygresql_redshift_common.py`. Remplacez *port**db\$1name*,*user*, et par *password\$1for\$1user* des informations spécifiques à votre cluster Amazon Redshift. Remplacez *table\$1name* par le nom de la table dans Amazon Redshift.
```
import pg
def get_connection(host):
rs_conn_string = "host=%s port=%s dbname=%s user=%s password=%s" % (
host, port, db_name, user, password_for_user)
rs_conn = pg.connect(dbname=rs_conn_string)
rs_conn.query("set statement_timeout = 1200000")
return rs_conn
def query(con):
statement = "Select * from table_name;"
res = con.query(statement)
return res
```
1. Si vous n’êtes pas déjà dans le répertoire `redshift_example`, accédez-y.
1. Effectuez l’une des actions suivantes :
+ Pour créer un fichier `.egg`, exécutez la commande suivante :
```
python setup.py bdist_egg
```
+ Pour créer un fichier `.whl`, exécutez la commande suivante.
```
python setup.py bdist_wheel
```
1. Installez les dépendances qui sont nécessaires à la commande précédente.
1. La commande crée un fichier dans le répertoire `dist` :
+ Si vous avez créé un fichier egg, il est nommé `redshift_module-0.1-py2.7.egg`.
+ Si vous avez créé un fichier Wheel, il est nommé `redshift_module-0.1-py2.7-none-any.whl`.
Téléchargez vos fichiers sur Amazon S3.
Dans cet exemple, le chemin du fichier chargé est *s3://amzn-s3-demo-bucket/EGG-FILE* ou *s3://amzn-s3-demo-bucket/WHEEL-FILE*.
1. Créez un fichier Python à utiliser comme script pour la tâche AWS Glue et ajoutez le code suivant au fichier.
```
from redshift_module import pygresql_redshift_common as rs_common
con1 = rs_common.get_connection(redshift_endpoint)
res = rs_common.query(con1)
print "Rows in the table cities are: "
print res
```
1. Téléchargez le fichier précédent sur Amazon S3. Dans cet exemple, le chemin du fichier chargé est *s3://amzn-s3-demo-bucket/scriptname.py*.
1. Créez une tâche shell Python à l’aide de ce script. Dans la console AWS Glue, dans la page **Propriétés de la tâche**, spécifiez le chemin d’accès au fichier `.egg/.whl` dans la zone **Chemin de la bibliothèque Python**. Si vous avez plusieurs fichiers `.egg/.whl` et fichiers Python, indiquez-les dans cette zone sous forme de liste de valeurs séparées par des virgules.
Lors de la modification ou du changement de nom de fichiers `.egg`, les noms de ces derniers doivent utiliser les noms par défaut générés par la commande « python setup.py bdist\$1egg » ou doivent respecter les conventions de dénomination du module Python. Pour plus d’informations, consultez [Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/) (Guide de style pour le code Python).
À l'aide de AWS CLI, créez une tâche avec une commande, comme dans l'exemple suivant.
```
aws glue create-job --name python-redshift-test-cli --role Role --command '{"Name" : "pythonshell", "ScriptLocation" : "s3://amzn-s3-demo-bucket/scriptname.py"}'
--connections Connections="connection-name" --default-arguments '{"--extra-py-files" : ["s3://amzn-s3-demo-bucket/EGG-FILE", "s3://amzn-s3-demo-bucket/WHEEL-FILE"]}'
```
Lorsque le job s'exécute, le script imprime les lignes créées dans la *table\$1name* table du cluster Amazon Redshift.
## À utiliser AWS CloudFormation avec les jobs shell Python dans AWS Glue
Vous pouvez les utiliser AWS CloudFormation avec des jobs shell Python dansAWS Glue. Voici un exemple :
```
AWSTemplateFormatVersion: 2010-09-09
Resources:
Python39Job:
Type: 'AWS::Glue::Job'
Properties:
Command:
Name: pythonshell
PythonVersion: '3.9'
ScriptLocation: 's3://bucket/location'
MaxRetries: 0
Name: python-39-job
Role: RoleName
```
Le groupe Amazon CloudWatch Logs pour les résultats des tâches shell Python est`/aws-glue/python-jobs/output`. Pour les erreurs, consultez le groupe de journaux `/aws-glue/python-jobs/error`.
## Migration du shell Python 3.6 vers le shell Python 3.9
Pour migrer vos jobs shell Python vers la dernière AWS Glue version :
1. Dans la AWS Glue console ([https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)), choisissez votre job shell Python existant.
1. Dans l’onglet de **Informations de la tâche**, définissez la version de Python sur `Python 3.9` et choisissez **Enregistrer**.
1. Assurez-vous que votre script de tâche est compatible avec Python 3.9 et qu’il s’exécute correctement.
# Migrer depuis les jobs shell AWS Glue Python
AWS a lancé les jobs shell AWS Glue Python en 2018 AWS a lancé les jobs shell AWS Glue Python en 2018 afin de permettre aux clients d'exécuter facilement des scripts Python pour des tâches ETL de small-to-medium grande taille et de déclencher des requêtes SQL. Cependant, il existe désormais des options plus modernes et plus flexibles pour faire face aux charges de travail actuelles. PythonShell Cette rubrique explique comment migrer vos charges de travail depuis les jobs shell AWS Glue Python vers l'une de ces options alternatives afin de tirer parti des nouvelles fonctionnalités disponibles.
Cette rubrique explique comment migrer des jobs shell AWS Glue Python vers des options alternatives.
## Migration de la charge de travail vers les tâches AWS Glue Spark
[AWS Glue Spark et les PySpark jobs](https://docs.aws.amazon.com/glue/latest/dg/spark_and_pyspark.html) vous permettent d'exécuter vos charges de travail de manière distribuée. Comme les jobs AWS Glue Python Shell et les jobs AWS Glue Spark s'exécutent sur la même plateforme, la migration est facile et vous pouvez continuer à utiliser les fonctionnalités AWS Glue existantes que vous utilisez avec les tâches Python Shell, telles que AWS Glue Workflows, AWS Glue Triggers, Amazon EventBridge l'intégration de AWS Glue, l'installation de packages basée sur \$1 Pip, etc.
Cependant, les tâches AWS Glue Spark sont conçues pour exécuter des charges de travail Spark, et le nombre minimum de travailleurs est de 2. Si vous migrez à partir de tâches shell Python sans modifier vos scripts, un seul travailleur sera réellement utilisé et les autres resteront inactifs. Cela augmentera vos coûts.
Pour que l’opération soit efficace, réécrivez votre script de tâche Python afin d’utiliser les fonctionnalités de Spark et de répartir la charge de travail entre plusieurs travailleurs. Si votre script Python est basé sur Pandas, il est facile de le migrer à l’aide de la nouvelle API Pandas sur Spark. Pour en savoir plus, consultez [le blog AWS Big Data : Dive deep into AWS Glue 4.0 pour Apache Spark](https://aws.amazon.com/blogs/big-data/dive-deep-into-aws-glue-4-0-for-apache-spark/).
## Migration de la charge de travail vers AWS Lambda
AWS Lambda est un service informatique sans serveur qui vous permet d'exécuter du code sans provisionner ni gérer de serveurs. Comme AWS Lambda a des temps de démarrage plus courts et des options de capacité de calcul plus flexibles, vous pouvez bénéficier de ces avantages. Pour gérer des bibliothèques Python supplémentaires, les tâches shell AWS Glue Python utilisent une installation basée sur PIP. Cependant, pour AWS Lambda, vous devez choisir l'une des options suivantes : une archive zip, une image de conteneur ou des couches Lambda.
En revanche, le délai maximum AWS Lambda est de 900 secondes (15 minutes). Si la durée de travail de votre charge de travail AWS Glue Python Shell existante est supérieure à ce montant, ou si votre charge de travail présente un schéma épineux susceptible de prolonger la durée des tâches, nous vous recommandons d'explorer d'autres options au lieu de. AWS Lambda
## Migration de la charge de travail vers Amazon ECS/Fargate
Amazon Elastic Container Service (Amazon ECS) est un service entièrement géré qui simplifie le déploiement, la gestion et le dimensionnement des applications conteneurisées. AWS Fargate est un moteur de calcul sans serveur pour les charges de travail conteneurisées exécutées sur Amazon ECS et ( Amazon Elastic Kubernetes Service Amazon EKS). Il n’y a pas de délai d’expiration maximal sur Amazon ECS et Fargate, c’est donc une bonne option pour les tâches de longue durée. Comme vous avez le contrôle total sur l’image de votre conteneur, vous pouvez importer votre script Python et des bibliothèques Python supplémentaires dans le conteneur et les utiliser. Cependant, vous devez conteneuriser votre script Python pour utiliser cette approche.
## Migration de la charge de travail vers Amazon Managed Workflows pour Apache Airflow Python Operator
Amazon Managed Workflows for Apache Airflow (Managed Workflows for Apache Airflow) est un service d'orchestration géré pour Apache Airflow qui facilite la configuration et l' end-to-endexploitation de pipelines de données dans le cloud à grande échelle. Si vous avez déjà un environnement MWAA, il sera facile d'utiliser l'opérateur Python au lieu des jobs AWS Glue Python Shell. L’opérateur Python est un opérateur qui exécute du code Python dans un flux de travail Airflow. Toutefois, si vous ne disposez pas d’un environnement MWAA existant, nous vous recommandons d’explorer d’autres options.
## Migration de la charge de travail vers des postes de formation en Amazon SageMaker AI IA
Amazon SageMaker AI La formation est un service d'apprentissage automatique (ML) entièrement géré Amazon SageMaker AI qui vous aide à entraîner efficacement un large éventail de modèles de machine learning à grande échelle. La conteneurisation des charges de travail de machine learning et la capacité de gérer AWS les ressources informatiques sont au cœur des métiers de l' Amazon SageMaker AI IA. Si vous préférez un environnement sans serveur où il n'y a pas de délai d'attente maximal, les emplois de formation en Amazon SageMaker AI IA pourraient vous convenir. Cependant, la latence de démarrage a tendance à être plus longue que celle des jobs AWS Glue Python Shell. Pour les tâches sensibles à la latence, nous vous recommandons d’explorer d’autres options.
# Surveillance AWS Glue
La surveillance joue un rôle important dans le maintien de la fiabilité, de la disponibilité AWS Glue et des performances de vos autres AWS solutions. AWS fournit des outils de surveillance que vous pouvez utiliser pour surveiller AWS Glue, signaler un problème et prendre des mesures automatiquement le cas échéant :
Vous pouvez utiliser les outils de surveillance automatique pour surveiller AWS Glue et signaler en cas de problème :
+ **Amazon CloudWatch Events** fournit un flux en temps quasi réel d'événements système décrivant les modifications apportées aux AWS ressources. CloudWatch Les événements permettent une informatique automatisée axée sur les événements. Vous pouvez rédiger des règles qui surveillent certains événements et déclenchent des actions automatisées dans d'autres AWS services lorsque ces événements se produisent. Pour plus d'informations, consultez le [guide de l'utilisateur d'Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/).
+ **Amazon CloudWatch Logs** vous permet de surveiller, de stocker et d'accéder à vos fichiers journaux à partir d' EC2 instances Amazon et d'autres sources. AWS CloudTrail CloudWatch Les journaux peuvent surveiller les informations contenues dans les fichiers journaux et vous avertir lorsque certains seuils sont atteints. Vous pouvez également archiver vos données de journaux dans une solution de stockage hautement durable. Pour plus d'informations, consultez le [guide de l'utilisateur d'Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/).
+ **AWS CloudTrail**capture les appels d'API et les événements associés effectués par ou pour le compte de votre AWS compte et envoie les fichiers journaux dans un compartiment Amazon S3 que vous spécifiez. Vous pouvez identifier les utilisateurs et les comptes qui appellent AWS, l'adresse IP source à partir de laquelle les appels sont effectués et le moment où les appels ont lieu. Pour plus d’informations, consultez le [Guide de l’utilisateur AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
En outre, vous avez accès aux informations suivantes dans la AWS Glue console pour vous aider à déboguer et à profiler les tâches :
+ Jobs Spark : vous pouvez voir une visualisation des séries de CloudWatch métriques sélectionnées, et les nouveaux jobs ont accès à l'interface utilisateur de Spark. Pour de plus amples informations, veuillez consulter [Surveillance des tâches Spark AWS Glue](monitor-spark.md).
+ Ray Jobs : vous pouvez voir une visualisation des séries de CloudWatch mesures sélectionnées. Pour de plus amples informations, veuillez consulter [Surveiller les tâches Ray à l'aide de métriques](author-job-ray-monitor.md).
**Topics**
+ [AWS tags dans AWS Glue](monitor-tags.md)
+ [Automatiser AWS Glue avec EventBridge](automating-awsglue-with-cloudwatch-events.md)
+ [AWS Glue Ressources de surveillance](monitor-resource-metrics.md)
+ [Journalisation des appels d'AWS GlueAPI avec AWS CloudTrail](monitor-cloudtrail.md)
# AWS tags dans AWS Glue
Pour mieux gérer vos ressources AWS Glue, vous pouvez éventuellement attribuer vos propres balises à certains types de ressources AWS Glue. Une étiquette est une étiquette que vous attribuez à une AWS ressource. Chaque balise est constituée d’une clé et d’une valeur facultative que vous définissez. Vous pouvez utiliser des balises dans AWS Glue pour identifier et organiser vos ressources. Des balises peuvent être utilisées pour créer des rapports de comptabilisation des coûts et limiter l'accès aux ressources. Si vous en utilisez Gestion des identités et des accès AWS, vous pouvez contrôler quels utilisateurs de votre AWS compte sont autorisés à créer, modifier ou supprimer des tags. Outre les autorisations d'appel liées à l'étiquette APIs, vous devez également être `glue:GetConnection` autorisée à étiqueter les appels APIs sur les connexions et à étiqueter les `glue:GetDatabase` appels sur les bases de données APIs . Pour de plus amples informations, veuillez consulter [ABAC avec Glue AWS](security_iam_service-with-iam.md#security_iam_service-with-iam-tags).
Dans AWS Glue, vous pouvez baliser les ressources suivantes :
+ Connexion
+ Base de données
+ crawler
+ Session interactive
+ Point de terminaison de développement
+ Tâche
+ Déclencheur
+ Flux de travail
+ Plan
+ Transformation de machine learning
+ Ensemble de règles de qualité des données
+ Schémas de flux
+ Registres de schémas de flux
**Note**
La bonne pratique afin d'autoriser le balisage de ces ressources AWS Glue consiste à toujours inclure l'action `glue:TagResource` dans vos politiques.
Tenez compte des éléments suivants lorsque vous utilisez des balises avec AWS Glue.
+ Un maximum de 50 balises sont prises en charge par entité.
+ Dans AWS Glue, vous spécifiez les balises sous la forme d'une liste de paires clé-valeur au format `{"string": "string" ...}`
+ Lorsque vous créez une balise sur un objet, la clé de balise est obligatoire et la valeur de balise est facultative.
+ La clé de balise et la valeur de balise sont sensibles à la casse.
+ La clé de balise et la valeur de balise ne doivent pas contenir le préfixe *aws*. Aucune opération n'est autorisée sur ces balises.
+ La longueur maximale des clés de balise est de 128 caractères Unicode en UTF-8. La clé de balise ne doit pas être vide ni null.
+ La longueur maximale des valeurs de balise est de 256 caractères Unicode en UTF-8. La valeur de balise peut être vide ou null.
## Support de balisage pour les connexions AWS Glue
Vous pouvez restreindre l'autorisation d'actions `CreateConnection`, `UpdateConnection`, `GetConnection` et `DeleteConnection` en fonction d'identification de ressources. Cela vous permet de mettre en œuvre le contrôle d'accès avec le moindre privilège sur les AWS Glue tâches comportant des sources de données JDBC qui doivent extraire les informations de connexion JDBC depuis le catalogue de données.
**Exemple d’utilisation**
Créez une AWS Glue connexion avec le tag ["connection-category », « dev-test"].
Spécifiez la condition de l'identification pour l'action `GetConnection` dans la politique IAM.
```
{
"Effect": "Allow",
"Action": [
"glue:GetConnection"
],
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"aws:ResourceTag/tagKey": "dev-test"
}
}
}
```
## Exemples
Les exemples suivants créent une tâche avec des balises attribuées.
**AWS CLI**
```
aws glue create-job --name job-test-tags --role MyJobRole --command Name=glueetl,ScriptLocation=S3://aws-glue-scripts//prod-job1
--tags key1=value1,key2=value2
```
**CloudFormation JSON**
```
{
"Description": "AWS Glue Job Test Tags",
"Resources": {
"MyJobRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"glue.amazonaws.com"
]
},
"Action": [
"sts:AssumeRole"
]
}
]
},
"Path": "/",
"Policies": [
{
"PolicyName": "root",
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "*",
"Resource": "*"
}
]
}
}
]
}
},
"MyJob": {
"Type": "AWS::Glue::Job",
"Properties": {
"Command": {
"Name": "glueetl",
"ScriptLocation": "s3://aws-glue-scripts//prod-job1"
},
"DefaultArguments": {
"--job-bookmark-option": "job-bookmark-enable"
},
"ExecutionProperty": {
"MaxConcurrentRuns": 2
},
"MaxRetries": 0,
"Name": "cf-job1",
"Role": {
"Ref": "MyJobRole",
"Tags": {
"key1": "value1",
"key2": "value2"
}
}
}
}
}
}
```
**CloudFormation YAML**
```
Description: AWS Glue Job Test Tags
Resources:
MyJobRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Principal:
Service:
- glue.amazonaws.com
Action:
- sts:AssumeRole
Path: "/"
Policies:
- PolicyName: root
PolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Action: "*"
Resource: "*"
MyJob:
Type: AWS::Glue::Job
Properties:
Command:
Name: glueetl
ScriptLocation: s3://aws-glue-scripts//prod-job1
DefaultArguments:
"--job-bookmark-option": job-bookmark-enable
ExecutionProperty:
MaxConcurrentRuns: 2
MaxRetries: 0
Name: cf-job1
Role:
Ref: MyJobRole
Tags:
key1: value1
key2: value2
```
Pour de plus amples informations, veuillez consulter [Politiques de balisage AWS](https://aws.amazon.com/answers/account-management/aws-tagging-strategies/).
Pour obtenir des informations sur la façon de contrôler l'accès à l'aide de balises, consultez [ABAC avec Glue AWS](security_iam_service-with-iam.md#security_iam_service-with-iam-tags).
# Automatiser AWS Glue avec EventBridge
Vous pouvez utiliser Amazon EventBridge pour automatiser vos AWS services et répondre automatiquement aux événements du système tels que les problèmes de disponibilité des applications ou les modifications des ressources. Les événements AWS liés aux services sont diffusés EventBridge en temps quasi réel. Vous pouvez écrire des règles simples pour indiquer quels événements vous intéressent et les actions automatisées à effectuer quand un événement correspond à une règle. Les actions pouvant être déclenchées automatiquement sont les suivantes :
+ Invoquer une fonction AWS Lambda
+ Invocation de la commande Amazon EC2 Run
+ Relais de l’événement à Amazon Kinesis Data Streams
+ Activation d'une machine à AWS Step Functions états
+ Notification d’une rubrique Amazon SNS ou d’une file d’attente Amazon SQS
Voici quelques exemples d'utilisation EventBridge avec AWS Glue :
+ Activation d’une fonction Lambda lorsqu’une tâche ETL réussit
+ Notification d’une rubrique Amazon SNS lorsqu’une tâche ETL échoue
Les éléments suivants EventBridge sont générés parAWS Glue.
+ Les événements pour `"detail-type":"Glue Job State Change"` sont générés pour `SUCCEEDED`, `FAILED`, `TIMEOUT` et `STOPPED`.
+ Les événements pour `"detail-type":"Glue Job Run Status"` sont générés pour les exécutions de tâche`RUNNING`, `STARTING` et `STOPPING` lorsqu’ils dépassent le seuil de notification de dépassement de délai de tâche. Vous devez définir la propriété du seuil de notification des retards de tâche pour recevoir ces événements.
Un seul événement est généré par statut d’exécution de tâche lorsque le seuil de notification de retard de tâche est dépassé.
+ Les événements pour `"detail-type":"Glue Crawler State Change"` sont générés pour `Started`, `Succeeded` et `Failed`.
+ Les événements pour `“detail_type”:“Glue Scheduled Crawler Invocation Failure”` sont générés lorsque le robot planifié ne démarre pas. Voici les informations figurant dans la notification :
+ `customerId` contient l’identifiant de compte du client.
+ `crawlerName` contient le nom du robot qui n’a pas pu démarrer.
+ `errorMessage` contient le message d’exception signalant l’échec de l’invocation.
+ Les événements pour `“detail_type”:“Glue Auto Statistics Invocation Failure“` sont générés lorsque l’exécution de la tâche de statistiques de colonne automatiquement gérée ne démarre pas. Voici les informations figurant dans la notification :
+ `catalogId` contient l’ID associé à un catalogue.
+ `databaseName` indique le nom de la base de données concernée.
+ `tableName` indique le nom de la table concernée.
+ `errorMessage` contient le message d’exception signalant l’échec de l’invocation.
+ Les événements pour `“detail_type”:“Glue Scheduled Statistics Invocation Failure”` sont générés lorsque la tâche de statistiques de colonne planifiée (cron) exécutée ne démarre pas. Voici les informations figurant dans la notification :
+ `catalogId` contient l’ID associé à un catalogue.
+ `databaseName` indique le nom de la base de données concernée.
+ `tableName` indique le nom de la table concernée.
+ `errorMessage` contient le message d’exception signalant l’échec de l’invocation.
+ Les événements pour `“detail_type”:“Glue Statistics Task Started”` sont générés lorsque l’exécution de la tâche de statistiques de colonne démarre.
+ Les événements pour `“detail_type”:“Glue Statistics Task Succeeded”` sont générés lorsque l’exécution de la tâche de statistiques de colonne aboutit.
+ Les événements pour `“detail_type”:“Glue Statistics Task Failed”` sont générés lorsque l’exécution de la tâche de statistiques de colonne échoue.
+ Les événements pour `"detail-type":"Glue Data Catalog Database State Change"` sont générés pour `CreateDatabase`, `DeleteDatabase`, `CreateTable`, `DeleteTable` et `BatchDeleteTable`. Par exemple, si une table est créée ou supprimée, une notification est envoyée à EventBridge. Notez que vous ne pouvez pas écrire un programme en fonction de la présence d’événements de notification ou de leur ordre, car il peut ne pas y en avoir ou ils peuvent ne pas être dans l’ordre défini. Les événements sont générés dans la mesure du possible. Voici les informations figurant dans la notification :
+ Le champ `typeOfChange` contient le nom de l’opération d’API.
+ Le champ `databaseName` indique le nom de la base de données concernée.
+ Le champ `changedTables` contient jusqu’à 100 noms de tables concernées par notification. Lorsque les noms de table sont longs, plusieurs notifications peuvent être créées.
+ Les événements pour `"detail-type":"Glue Data Catalog Table State Change"` sont générés pour `UpdateTable`, `CreatePartition`, `BatchCreatePartition`, `UpdatePartition`, `DeletePartition`, `BatchUpdatePartition` et `BatchDeletePartition`. Par exemple, si une table ou une partition est mise à jour, une notification est envoyée à EventBridge. Notez que vous ne pouvez pas écrire un programme en fonction de la présence d’événements de notification ou de leur ordre, car il peut ne pas y en avoir ou ils peuvent ne pas être dans l’ordre défini. Les événements sont générés dans la mesure du possible. Voici les informations figurant dans la notification :
+ Le champ `typeOfChange` contient le nom de l’opération d’API.
+ Le champ `databaseName` indique le nom de la base de données dont les ressources sont concernées.
+ Le champ `tableName` indique le nom de la table concernée.
+ Le champ `changedPartitions` spécifie jusqu’à 100 partitions concernées dans une notification. Lorsque les noms de partition sont longs, plusieurs notifications peuvent être créées.
Par exemple, s’il existe deux clés de partition, `Year` et `Month`, alors `"2018,01", "2018,02"` modifie la partition si `"Year=2018" and "Month=01"` et si `"Year=2018" and "Month=02"`.
```
{
"version":"0",
"id":"abcdef00-1234-5678-9abc-def012345678",
"detail-type":"Glue Data Catalog Table State Change",
"source":"aws.glue",
"account":"123456789012",
"time":"2017-09-07T18:57:21Z",
"region":"us-west-2",
"resources":["arn:aws:glue:us-west-2:123456789012:database/default/foo"],
"detail":{
"changedPartitions": [
"2018,01",
"2018,02"
],
"databaseName": "default",
"tableName": "foo",
"typeOfChange": "BatchCreatePartition"
}
}
```
Pour plus d'informations, consultez le [guide de l'utilisateur d'Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/). Pour des événements spécifiques à AWS Glue, consultez [Événements AWS Glue](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types).
# AWS Glue Ressources de surveillance
AWS Glue dispose de limites de service afin de protéger les clients contre les provisionnements excessifs inattendus et contre les actions malveillantes visant à augmenter votre facture. Les limites protègent également le service. En se connectant à la console AWS Service Quota, les clients peuvent consulter leurs limites de ressources actuelles et demander une augmentation (le cas échéant).
AWS Gluevous permet de visualiser l'utilisation des ressources du service sous forme de pourcentage dans Amazon CloudWatch et de configurer des CloudWatch alarmes pour surveiller l'utilisation. Amazon CloudWatch assure la surveillance des AWS ressources et des applications client exécutées sur l'infrastructure Amazon. Les métriques sont gratuites pour vous. Les métriques suivantes sont prises en charge :
+ Nombre de flux de travail par compte
+ Nombre de déclencheurs par compte
+ Nombre de tâches par compte
+ Nombre d'exécutions de tâches simultanées par compte
+ Nombre de plans par compte
+ Nombre de sessions interactives par compte
## Configuration et utilisation des métriques de ressources
Pour utiliser cette fonctionnalité, vous pouvez accéder à la CloudWatch console Amazon pour consulter les statistiques et configurer les alarmes. Les métriques se trouvent sous l'espace de noms AWS/Glue et représentent un pourcentage du nombre réel d'utilisation des ressources divisé par le quota de ressources. Les CloudWatch statistiques sont transmises à vos comptes, sans frais pour vous. Par exemple, si vous avez créé 10 flux de travail et que votre quota de service vous permet d'avoir 200 flux de travail au maximum, votre utilisation est de 10/200 = 5 %, et dans le graphique, vous verrez un point de données de cinq en tant que pourcentage. Pour être plus précis :
```
Namespace: AWS/Glue
Metric name: ResourceUsage
Type: Resource
Resource: Workflow (or Trigger, Job, JobRun, Blueprint, InteractiveSession)
Service: Glue
Class: None
```
![\[Métriques de ressource\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/resource_monitoring_1.png)
Pour créer une alarme sur une métrique dans la CloudWatch console, procédez comme suit :
1. Une fois que vous avez localisé la métrique, accédez à **Métriques graphiques**.
1. Cliquez sur **Créer une alarme** sous **Actions**.
1. Configurez l'alarme selon vos besoins.
Nous émettons des métriques chaque fois que l'utilisation de vos ressources change (augmentation ou diminution, par exemple). Mais si l'utilisation de vos ressources ne change pas, nous émettons des métriques toutes les heures, afin que vous disposiez d'un CloudWatch graphique continu. Pour éviter d'avoir des points de données manquants, nous vous déconseillons de configurer une période inférieure à une heure.
Vous pouvez également configurer les alarmes à AWS CloudFormation l'aide de l'exemple suivant. Dans cet exemple, une fois que l'utilisation des ressources du flux de travail atteint 80 %, une alarme est déclenchée pour envoyer un message à la rubrique SNS existante, à laquelle vous pouvez vous abonner pour recevoir des notifications.
```
{
"Type": "AWS::CloudWatch::Alarm",
"Properties": {
"AlarmName": "WorkflowUsageAlarm",
"ActionsEnabled": true,
"OKActions": [],
"AlarmActions": [
"arn:aws:sns:af-south-1:085425700061:Default_CloudWatch_Alarms_Topic"
],
"InsufficientDataActions": [],
"MetricName": "ResourceUsage",
"Namespace": "AWS/Glue",
"Statistic": "Maximum",
"Dimensions": [{
"Name": "Type",
"Value": "Resource"
},
{
"Name": "Resource",
"Value": "Workflow"
},
{
"Name": "Service",
"Value": "Glue"
},
{
"Name": "Class",
"Value": "None"
}
],
"Period": 3600,
"EvaluationPeriods": 1,
"DatapointsToAlarm": 1,
"Threshold": 80,
"ComparisonOperator": "GreaterThanThreshold",
"TreatMissingData": "notBreaching"
}
}
```
# Journalisation des appels d'AWS GlueAPI avec AWS CloudTrail
AWS Glueest intégré à AWS CloudTrail un service qui fournit un enregistrement des actions entreprises par un utilisateur, un rôle ou un AWS service dansAWS Glue. CloudTrail capture tous les appels d'API AWS Glue sous forme d'événements. Les appels capturés incluent des appels de la console AWS Glue et les appels de code vers les opérations d'API AWS Glue. Si vous créez un suivi, vous pouvez activer la diffusion continue d' CloudTrail événements vers un compartiment Amazon S3, y compris les événements pourAWS Glue. Si vous ne configurez pas de suivi, vous pouvez toujours consulter les événements les plus récents dans la CloudTrail console dans **Historique des événements**. À l'aide des informations collectées par CloudTrail, vous pouvez déterminer la demande qui a été faiteAWS Glue, l'adresse IP à partir de laquelle la demande a été faite, qui a fait la demande, quand elle a été faite et des détails supplémentaires.
Pour en savoir plus CloudTrail, consultez le [guide de AWS CloudTrail l'utilisateur](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
## AWS Glueinformations dans CloudTrail
CloudTrail est activé sur votre AWS compte lorsque vous le créez. Lorsqu'une activité se produit dansAWS Glue, cette activité est enregistrée dans un CloudTrail événement avec d'autres événements de AWS service dans **l'historique des événements**. Vous pouvez consulter, rechercher et télécharger les événements récents dans votre AWS compte. Pour plus d'informations, consultez la section [Affichage des événements à l'aide de l'historique des CloudTrail événements](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html).
Pour un enregistrement continu des événements de votre AWS compte, y compris des événements pourAWS Glue, créez un parcours. Un *suivi* permet CloudTrail de fournir des fichiers journaux à un compartiment Amazon S3. Par défaut, lorsque vous créez un parcours dans la console, celui-ci s'applique à toutes les AWS régions. Le journal enregistre les événements de toutes les régions de la AWS partition et transmet les fichiers journaux au compartiment Amazon S3 que vous spécifiez. En outre, vous pouvez configurer d'autres AWS services pour analyser plus en détail les données d'événements collectées dans les CloudTrail journaux et agir en conséquence. Pour plus d’informations, consultez les ressources suivantes :
+ [Création d'un parcours pour votre AWS compte](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html)
+ [CloudTrail services et intégrations pris en charge](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations)
+ [Configuration des notifications Amazon SNS pour CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html)
+ [Réception de fichiers CloudTrail journaux de plusieurs régions](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html) et [réception de fichiers CloudTrail journaux de plusieurs comptes](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html)
Toutes les AWS Glue actions sont enregistrées CloudTrail et documentées dans le[AWS Glue API](aws-glue-api.md). Par exemple, les appels au`CreateDatabase`, `CreateTable` et les `CreateScript` actions génèrent des entrées dans les fichiers CloudTrail journaux.
Chaque événement ou entrée de journal contient des informations sur la personne ayant initié la demande. Les informations relatives à l’identité permettent de déterminer les éléments suivants :
+ Si la demande a été effectuée avec des informations d’identification d’utilisateur root ou IAM.
+ Si la demande a été effectuée avec des informations d’identification de sécurité temporaires pour un rôle ou un utilisateur fédéré.
+ Si la demande a été faite par un autre AWS service.
Pour plus d’informations, consultez la section [Élément userIdentity CloudTrail ](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html).
Cependant, CloudTrail n'enregistre pas toutes les informations concernant les appels. Par exemple, il n'enregistre pas certaines informations sensibles, telles que celles `ConnectionProperties` utilisées dans les demandes de connexion, et il enregistre un `null` au lieu des réponses renvoyées par les éléments suivants APIs :
```
BatchGetPartition GetCrawlers GetJobs GetTable
CreateScript GetCrawlerMetrics GetJobRun GetTables
GetCatalogImportStatus GetDatabase GetJobRuns GetTableVersions
GetClassifier GetDatabases GetMapping GetTrigger
GetClassifiers GetDataflowGraph GetObjects GetTriggers
GetConnection GetDevEndpoint GetPartition GetUserDefinedFunction
GetConnections GetDevEndpoints GetPartitions GetUserDefinedFunctions
GetCrawler GetJob GetPlan
```
## Présentation des entrées des fichiers journaux AWS Glue
Un suivi est une configuration qui permet de transmettre des événements sous forme de fichiers journaux à un compartiment Amazon S3 que vous spécifiez. CloudTrail les fichiers journaux contiennent une ou plusieurs entrées de journal. Un événement représente une demande unique provenant de n'importe quelle source et inclut des informations sur l'action demandée, la date et l'heure de l'action, les paramètres de la demande, etc. CloudTrail les fichiers journaux ne constituent pas une trace ordonnée des appels d'API publics, ils n'apparaissent donc pas dans un ordre spécifique.
L'exemple suivant montre une entrée de CloudTrail journal illustrant l'`DeleteCrawler`action.
```
{
"eventVersion": "1.05",
"userIdentity": {
"type": "IAMUser",
"principalId": "AKIAIOSFODNN7EXAMPLE",
"arn": "arn:aws:iam::123456789012:user/johndoe",
"accountId": "123456789012",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "johndoe"
},
"eventTime": "2017-10-11T22:29:49Z",
"eventSource": "glue.amazonaws.com",
"eventName": "DeleteCrawler",
"awsRegion": "us-east-1",
"sourceIPAddress": "72.21.198.64",
"userAgent": "aws-cli/1.11.148 Python/3.6.1 Darwin/16.7.0 botocore/1.7.6",
"requestParameters": {
"name": "tes-alpha"
},
"responseElements": null,
"requestID": "b16f4050-aed3-11e7-b0b3-75564a46954f",
"eventID": "e73dd117-cfd1-47d1-9e2f-d1271cad838c",
"eventType": "AwsApiCall",
"recipientAccountId": "123456789012"
}
```
Cet exemple montre une entrée de CloudTrail journal illustrant une `CreateConnection` action.
```
{
"eventVersion": "1.05",
"userIdentity": {
"type": "IAMUser",
"principalId": "AKIAIOSFODNN7EXAMPLE",
"arn": "arn:aws:iam::123456789012:user/johndoe",
"accountId": "123456789012",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "johndoe"
},
"eventTime": "2017-10-13T00:19:19Z",
"eventSource": "glue.amazonaws.com",
"eventName": "CreateConnection",
"awsRegion": "us-east-1",
"sourceIPAddress": "72.21.198.66",
"userAgent": "aws-cli/1.11.148 Python/3.6.1 Darwin/16.7.0 botocore/1.7.6",
"requestParameters": {
"connectionInput": {
"name": "test-connection-alpha",
"connectionType": "JDBC",
"physicalConnectionRequirements": {
"subnetId": "subnet-323232",
"availabilityZone": "us-east-1a",
"securityGroupIdList": [
"sg-12121212"
]
}
}
},
"responseElements": null,
"requestID": "27136ebc-afac-11e7-a7d6-ab217e5c3f19",
"eventID": "e8b3baeb-c511-4597-880f-c16210c60a4a",
"eventType": "AwsApiCall",
"recipientAccountId": "123456789012"
}
```