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. # Mise à jour du schéma et ajout de nouvelles partitions dans le catalogue de données à l’aide des tâches AWS Glue ETL Votre travail d'extraction, de transformation et de chargement (ETL) peut créer de nouvelles partitions de table dans le magasin de données cible. Votre schéma de jeu de données peut évoluer et diverger du schéma de catalogue de données AWS Glue avec le temps. AWS Glue Les tâches ETL fournissent désormais plusieurs fonctions que vous pouvez utiliser dans votre script ETL pour mettre à jour votre schéma et vos partitions dans le catalogue de données. Ces fonctions vous permettent de voir les résultats de votre tâche ETL dans le catalogue de données, sans avoir à exécuter à nouveau l'crawler. ## Nouvelles partitions Si vous souhaitez afficher les nouvelles partitions dans le AWS Glue Data Catalog, vous pouvez effectuer l'une des opérations suivantes : + Une fois la tâche terminée, réexécutez l'crawler pour afficher les nouvelles partitions sur la console. + Une fois la tâche terminée, affichez immédiatement les nouvelles partitions sur la console, sans avoir à réexécuter l'crawler. Pour activer cette fonctionnalité, ajoutez quelques lignes de code au script ETL, comme illustré dans les exemples suivants. Le code utilise l'argument `enableUpdateCatalog` pour indiquer que le catalogue de données doit être mis à jour pendant l'exécution de la tâche lors de la création des partitions. **Méthode 1 :** Transmettez `enableUpdateCatalog` et `partitionKeys` dans un argument d'options. ``` additionalOptions = {"enableUpdateCatalog": True} additionalOptions["partitionKeys"] = ["region", "year", "month", "day"] sink = glueContext.write_dynamic_frame_from_catalog(frame=last_transform, database=, table_name=, transformation_ctx="write_sink", additional_options=additionalOptions) ``` ``` val options = JsonOptions(Map( "path" -> , "partitionKeys" -> Seq("region", "year", "month", "day"), "enableUpdateCatalog" -> true)) val sink = glueContext.getCatalogSink( database = , tableName = , additionalOptions = options)sink.writeDynamicFrame(df) ``` **Méthode 2 :** Transmettez `enableUpdateCatalog` et `partitionKeys` dans `getSink()` et appelez `setCatalogInfo()` au niveau de l'objet `DataSink`. ``` sink = glueContext.getSink( connection_type="s3", path="", enableUpdateCatalog=True, partitionKeys=["region", "year", "month", "day"]) sink.setFormat("json") sink.setCatalogInfo(catalogDatabase=, catalogTableName=) sink.writeFrame(last_transform) ``` ``` val options = JsonOptions( Map("path" -> , "partitionKeys" -> Seq("region", "year", "month", "day"), "enableUpdateCatalog" -> true)) val sink = glueContext.getSink("s3", options).withFormat("json") sink.setCatalogInfo(, ) sink.writeDynamicFrame(df) ``` Maintenant, vous pouvez créer des tables de catalogue, mettre à jour les tables existantes avec le schéma modifié et ajouter de nouvelles partitions de table au catalogue de données à l'aide d'une tâche ETL AWS Glue, sans avoir besoin de relancer les crawlers. ## Mise à jour du schéma de table Si vous souhaitez remplacer le schéma de la table du catalogue de données, vous pouvez effectuer l'une des opérations suivantes : + Une fois la tâche terminée, exécutez à nouveau l’crawler et assurez-vous que celui-ci est configuré pour mettre à jour également la définition de la table. Affichez les nouvelles partitions sur la console ainsi que les mises à jour de schéma lorsque l'crawler se termine. Pour plus d'informations, consultez [Configuration d'un crawler utilisant l'API](https://docs.aws.amazon.com/glue/latest/dg/crawler-configuration.html#crawler-configure-changes-api). + Une fois la tâche terminée, affichez immédiatement le schéma modifié sur la console, sans avoir à exécuter de nouveau l'crawler. Pour activer cette fonctionnalité, ajoutez quelques lignes de code au script ETL, comme illustré dans les exemples suivants. Le code utilise `enableUpdateCatalog` défini sur true et `updateBehavior` défini sur `UPDATE_IN_DATABASE`, ce qui indique que le schéma doit être remplacé et que de nouvelles partitions doivent être ajoutées au catalogue de données pendant l'exécution de la tâche. ------ #### [ Python ] ``` additionalOptions = { "enableUpdateCatalog": True, "updateBehavior": "UPDATE_IN_DATABASE"} additionalOptions["partitionKeys"] = ["partition_key0", "partition_key1"] sink = glueContext.write_dynamic_frame_from_catalog(frame=last_transform, database=, table_name=, transformation_ctx="write_sink", additional_options=additionalOptions) job.commit() ``` ------ #### [ Scala ] ``` val options = JsonOptions(Map( "path" -> outputPath, "partitionKeys" -> Seq("partition_0", "partition_1"), "enableUpdateCatalog" -> true)) val sink = glueContext.getCatalogSink(database = nameSpace, tableName = tableName, additionalOptions = options) sink.writeDynamicFrame(df) ``` ------ Vous pouvez également définir la valeur de `updateBehavior` sur `LOG` si vous souhaitez empêcher le remplacement du schéma de table, mais que vous souhaitez toujours ajouter les nouvelles partitions. Comme la valeur par défaut de `updateBehavior` est `UPDATE_IN_DATABASE`, si vous ne le définissez pas explicitement, le schéma de table est remplacé. Si `enableUpdateCatalog` n'a pas la valeur true, quelle que soit l'option sélectionnée pour `updateBehavior`, la tâche ETL ne mettra pas à jour la table dans le catalogue de données. ## Création de tables Vous pouvez également utiliser les mêmes options pour créer une table dans le catalogue de données. Vous pouvez spécifier la base de données et le nouveau nom de table avec `setCatalogInfo`. ------ #### [ Python ] ``` sink = glueContext.getSink(connection_type="s3", path="s3://path/to/data", enableUpdateCatalog=True, updateBehavior="UPDATE_IN_DATABASE", partitionKeys=["partition_key0", "partition_key1"]) sink.setFormat("") sink.setCatalogInfo(catalogDatabase=, catalogTableName=) sink.writeFrame(last_transform) ``` ------ #### [ Scala ] ``` val options = JsonOptions(Map( "path" -> outputPath, "partitionKeys" -> Seq("", ""), "enableUpdateCatalog" -> true, "updateBehavior" -> "UPDATE_IN_DATABASE")) val sink = glueContext.getSink(connectionType = "s3", connectionOptions = options).withFormat("") sink.setCatalogInfo(catalogDatabase = “”, catalogTableName = “”) sink.writeDynamicFrame(df) ``` ------ ## Restrictions Prenez note des restrictions suivantes : + Seules des cibles Amazon Simple Storage Service (Amazon S3) sont prises en charge. + La fonctionnalité `enableUpdateCatalog` n'est pas prise en charge pour les tables gouvernées. + Seuls les formats suivants sont pris en charge : `json`, `csv`, `avro` et `parquet`. + Pour créer ou mettre à jour des tableaux avec la `parquet` classification, vous devez utiliser le rédacteur de parquet AWS Glue optimisé pour DynamicFrames. Cela peut être réalisé à l'aide d'un des moyens suivants : + Si vous mettez à jour une table existante dans le catalogue avec la classification `parquet`, la propriété de la table `"useGlueParquetWriter"` doit être définie sur `true` avant que vous ne la mettiez à jour. Vous pouvez définir cette propriété via le AWS Glue APIs /SDK, via la console ou via une instruction Athena DDL. ![\[Champ d'édition des propriétés de la table de catalogue dans AWS Glue la console.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/edit-table-property.png) Une fois la propriété de la table de catalogue définie, vous pouvez utiliser l'extrait de code suivant pour mettre à jour la table de catalogue avec les nouvelles données : ``` glueContext.write_dynamic_frame.from_catalog( frame=frameToWrite, database="dbName", table_name="tableName", additional_options={ "enableUpdateCatalog": True, "updateBehavior": "UPDATE_IN_DATABASE" } ) ``` + Si la table n'existe pas déjà dans le catalogue, vous pouvez utiliser la méthode `getSink()` de votre script avec `connection_type="s3"` pour ajouter la table et ses partitions au catalogue, ainsi que pour écrire les données sur Amazon S3. Fournissez les `partitionKeys` et la `compression` appropriés pour votre flux de travail. ``` s3sink = glueContext.getSink( path="s3://bucket/folder/", connection_type="s3", updateBehavior="UPDATE_IN_DATABASE", partitionKeys=[], compression="snappy", enableUpdateCatalog=True ) s3sink.setCatalogInfo( catalogDatabase="dbName", catalogTableName="tableName" ) s3sink.setFormat("parquet", useGlueParquetWriter=True) s3sink.writeFrame(frameToWrite) ``` + La valeur de `glueparquet` format est une ancienne méthode permettant d'activer le rédacteur de AWS Glue parquet. + Quand `updateBehavior` a la valeur `LOG`, de nouvelles partitions sont ajoutées uniquement si le schéma `DynamicFrame` est équivalent ou qu'il contient un sous-ensemble des colonnes définies dans le schéma de la table du catalogue de données. + Les mises à jour du schéma ne sont pas prises en charge pour les tables non partitionnées (qui n'utilisent pas l'option « partitionKeys »). + Vos clés de partition (partitionKeys) doivent être équivalentes, et dans le même ordre, entre votre paramètre passé dans votre script ETL et les clés de partition (partitionKeys) du schéma de votre table du catalogue de données. + Cette fonctionnalité ne prend actuellement pas en charge updating/creating les tables dans lesquelles les schémas de mise à jour sont imbriqués (par exemple, les tableaux à l'intérieur des structures). Pour de plus amples informations, veuillez consulter [Programmation de scripts Spark](aws-glue-programming.md). # Utilisation des connexions MongoDB dans les tâches ETL Vous pouvez créer une connexion pour MongoDB, puis utiliser cette connexion dans votre tâche AWS Glue. Pour plus d'informations, consultez [Connexions MongoDB](aws-glue-programming-etl-connect-mongodb-home.md) le guide AWS Glue de programmation. Les connexions `url`, `username` et `password` sont stockées dans la connexion MongoDB. D'autres options peuvent être spécifiées dans votre script de tâche ETL à l'aide du paramètre `additionalOptions` de `glueContext.getCatalogSource`. Les autres options peuvent inclure : + `database`: (Obligatoire) La base de données MongoDB à lire. + `collection` : (Obligatoire) La collection MongoDB à lire. En plaçant les informations `database` et `collection` dans le script de tâche ETL, vous pouvez utiliser la même connexion pour plusieurs tâches. 1. Créez une AWS Glue Data Catalog connexion pour la source de données MongoDB. Consultez ["connectionType": "mongodb"](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-connect.html#aws-glue-programming-etl-connect-mongodb) pour obtenir une description des paramètres de connexion. Vous pouvez créer la connexion à l'aide de la console APIs ou de la CLI. 1. Créez une base de données dans le AWS Glue Data Catalog pour stocker les définitions de table pour vos données MongoDB. Pour plus d’informations, consultez [Création de bases de données](define-database.md). 1. Créez un crawler qui explore les données dans MongoDB en utilisant les informations de la connexion pour se connecter à MongoDB. Le robot crée les tables AWS Glue Data Catalog qui décrivent les tables de la base de données MongoDB que vous utilisez dans le cadre de votre travail. Pour plus d’informations, consultez [Utilisation de robots pour alimenter le catalogue de données](add-crawler.md). 1. Créez une tâche avec un script personnalisé. Vous pouvez créer la tâche à l'aide de la console APIs ou de la CLI. Pour plus d’informations, consultez [Ajout de tâches dans AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/add-job.html). 1. Choisissez les cibles de données de votre tâche. Les tables qui représentent les données cible peuvent être définies dans votre catalogue de données ou votre tâche peut créer les tables cible lors son exécution. Vous choisissez un emplacement cible lorsque vous créez la tâche. Si la cible nécessite une connexion, la connexion est également référencée dans votre tâche. Si votre tâche nécessite plusieurs cibles de données, vous pouvez les ajouter ensuite en modifiant le script. 1. Personnalisez l'environnement de traitement de tâche en fournissant des arguments pour votre tâche et le script généré. Voici un exemple de création de `DynamicFrame` à partir de la base de données MongoDB basée sur la structure de table définie dans le catalogue de données. Le code utilise `additionalOptions` pour fournir les informations supplémentaires sur la source de données : ------ #### [ Scala ] ``` val resultFrame: DynamicFrame = glueContext.getCatalogSource( database = catalogDB, tableName = catalogTable, additionalOptions = JsonOptions(Map("database" -> DATABASE_NAME, "collection" -> COLLECTION_NAME)) ).getDynamicFrame() ``` ------ #### [ Python ] ``` glue_context.create_dynamic_frame_from_catalog( database = catalogDB, table_name = catalogTable, additional_options = {"database":"database_name", "collection":"collection_name"}) ``` ------ 1. Exécutez la tâche, à la demande ou via un déclencheur..