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.
# Découverte et catalogage des données dans AWS Glue
AWS Glue Data Catalog Il s'agit d'un référentiel centralisé qui stocke les métadonnées relatives aux ensembles de données de votre organisation. Il sert d’index pour l’emplacement, le schéma et les métriques d’exécution de vos sources de données. Les métadonnées sont stockées dans des tables de métadonnées, chaque table représentant un seul entrepôt de données.
Vous pouvez remplir le catalogue de données à l’aide d’un robot, qui analyse automatiquement vos sources de données et extrait les métadonnées. Un robot peut se connecter à des sources de données internes (basées sur AWS) et externes à AWS.
Pour plus d’informations sur les sources de données prises en charge, consultez [Sources de données prises en charge pour l’indexation de site web](crawler-data-stores.md).
Vous pouvez également créer des tables manuellement dans le catalogue de données en définissant la structure des tables, le schéma et la structure de partitionnement en fonction de vos besoins spécifiques.
Pour plus d’informations sur la création manuelle de tables de métadonnées, consultez [Définition manuelle des métadonnées](populate-dg-manual.md).
Les informations du catalogue de données vous permettent de créer et de surveiller vos tâches ETL. Le catalogue de données s'intègre à d'autres services d' AWS analyse, fournissant une vue unifiée des sources de données, ce qui facilite la gestion et l'analyse des données.
+ Amazon Athena : stockez et interrogez les métadonnées des tables dans le catalogue de données pour les données Amazon S3 à l’aide de SQL.
+ AWS Lake Formation — Définissez et gérez de manière centralisée des politiques d'accès aux données précises et auditez l'accès aux données.
+ Amazon EMR : accédez aux sources de données définies dans le catalogue de données pour le traitement de big data.
+ Amazon SageMaker AI — Créez, formez et déployez des modèles d'apprentissage automatique rapidement et en toute confiance.Principales fonctionnalités du catalogue de données
Les principaux aspects du catalogue de données sont les suivants.
Référentiel de métadonnées
Le catalogue de données sert de référentiel de métadonnées central, stockant des informations sur l’emplacement, le schéma et les propriétés de vos sources de données. Ces métadonnées sont organisées en bases de données et en tables, comme dans un catalogue de base de données relationnelle traditionnel.
Découverte automatique des données
AWS Glue crawler s peut automatiquement découvrir et cataloguer des sources de données nouvelles ou mises à jour, réduisant ainsi la charge de travail liée à la gestion manuelle des métadonnées et garantissant la pérennité de votre catalogue de données up-to-date. En cataloguant vos sources de données, le catalogue de données permet aux utilisateurs et aux applications de découvrir et de comprendre plus facilement les ressources de données disponibles au sein de votre organisation, et favorise ainsi la réutilisation des données et la collaboration.
Le catalogue de données prend en charge un large éventail de sources de données, notamment Amazon S3, Amazon RDS, Amazon Redshift, Apache Hive, etc. Il peut automatiquement déduire et stocker les métadonnées de ces sources à l'aide de AWS Glue crawler s.
Pour plus d'informations, voir,[Utilisation de robots pour alimenter le catalogue de données](add-crawler.md).
Gestion des schémas
Le catalogue de données capture et gère automatiquement le schéma de vos sources de données, y compris l’inférence, l’évolution et la gestion des versions des schémas. Vous pouvez mettre à jour votre schéma et vos partitions dans le catalogue de données à l'aide de tâches AWS Glue ETL.
Optimisation des tables
Pour améliorer les performances de lecture des services AWS d'analyse tels qu'Amazon Athena et Amazon EMR, ainsi que pour les tâches AWS Glue ETL, le catalogue de données fournit un compactage géré (un processus qui compacte de petits objets Amazon S3 en objets plus grands) pour les tables Iceberg du catalogue de données. Vous pouvez utiliser une AWS Glue console, une AWS Lake Formation console ou une AWS API pour activer ou désactiver le compactage de tables Iceberg individuelles figurant dans le catalogue de données. AWS CLI
Pour de plus amples informations, veuillez consulter [Optimisation des tables Iceberg](table-optimizers.md).
Statistiques de colonne
Vous pouvez calculer des statistiques de colonne pour des tables du catalogue des données dans des formats de données tels que Parquet, ORC, JSON, ION, CSV et XML sans définir des pipelines de données supplémentaires. Les statistiques de colonne vous aident à comprendre les profils de données en obtenant des informations sur les valeurs d'une colonne. Le catalogue de données prend en charge la génération de statistiques pour les valeurs de colonne telles que la valeur minimale, la valeur maximale, le total des valeurs nulles, le total des valeurs distinctes, la longueur moyenne des valeurs et le nombre total d’occurrences de valeurs vraies.
Pour de plus amples informations, veuillez consulter [Optimisation des performances des requêtes à l’aide des statistiques de colonne](column-statistics.md).
Traçabilité des données
Le catalogue de données conserve un enregistrement des transformations et des opérations effectuées sur vos données, fournissant des informations sur la traçabilité des données. Ces informations de traçabilité sont précieuses pour la vérification, la conformité et la compréhension de la provenance des données.
Intégration avec d'autres AWS services
Le catalogue de données s'intègre parfaitement à d'autres AWS services AWS Lake Formation, tels qu'Amazon Athena, Amazon Redshift Spectrum et Amazon EMR. Cette intégration vous permet d’interroger et d’analyser des données dans différents entrepôts de données à l’aide d’une couche de métadonnées unique et cohérente.
Sécurité et contrôle d’accès
AWS Glue s'intègre AWS Lake Formation pour prendre en charge un contrôle d'accès précis aux ressources du catalogue de données, ce qui vous permet de gérer les autorisations et de sécuriser l'accès à vos actifs de données en fonction des politiques et des exigences de votre organisation. AWS Glue s'intègre à AWS Key Management Service (AWS KMS) pour chiffrer les métadonnées stockées dans le catalogue de données.
Vues matérialisées
Le catalogue de données prend en charge les vues matérialisées Apache Iceberg, qui sont des tables gérées qui stockent les résultats précalculés des requêtes SQL et s'actualisent automatiquement à mesure que les données sources sous-jacentes changent. Les vues matérialisées simplifient les pipelines de transformation des données et accélèrent les performances des requêtes en éliminant les calculs redondants.
Vous pouvez créer des vues matérialisées à l'aide d'Apache Spark SQL dans AWS Glue version 5.1 et ultérieure, Amazon EMR version 7.12.0 et versions ultérieures, et Amazon Athena. Le catalogue de données surveille automatiquement les tables Apache Iceberg sources et actualise les vues matérialisées à l'aide d'une infrastructure informatique gérée. Les moteurs Spark de AWS Glue, Amazon EMR et Amazon Athena peuvent automatiquement réécrire les requêtes afin d'utiliser des vues matérialisées lorsqu'elles offrent de meilleures performances.
Les vues matérialisées sont stockées 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, ce qui les rend accessibles depuis plusieurs moteurs de requêtes. Le catalogue de données gère tous les aspects du cycle de vie des vues matérialisées, notamment la planification automatique des actualisations, les mises à jour incrémentielles et la gestion des métadonnées.
Pour plus d'informations, consultez les sections Utilisation de vues matérialisées avec AWS Glue et Utilisation de vues matérialisées avec Amazon EMR.
**Topics**
+ [Remplissage du catalogue de AWS Glue données](populate-catalog-methods.md)
+ [Remplissage et gestion des tables transactionnelles](populate-otf.md)
+ [Gestion du catalogue de données](manage-catalog.md)
+ [Accès au catalogue de données](access_catalog.md)
+ [AWS Glue Bonnes pratiques en matière de catalogue de données](best-practice-catalog.md)
+ [Surveillance des métriques d'utilisation du catalogue de données dans Amazon CloudWatch](data-catalog-cloudwatch-metrics.md)
+ [Registre de schémas AWS Glue](schema-registry.md)
# Remplissage du catalogue de AWS Glue données
Vous pouvez remplir le fichier à l' AWS Glue Data Catalog aide des méthodes suivantes :
+ AWS Glue crawler — An AWS Glue crawler peut automatiquement découvrir et cataloguer des sources de données telles que des bases de données, des lacs de données et des données de streaming. Les robots constituent la méthode la plus courante et la plus recommandée pour remplir le catalogue de données, car ils peuvent automatiquement découvrir et déduire les métadonnées à partir d’une grande variété de sources de données.
+ Ajout manuel de métadonnées : vous pouvez définir manuellement les bases de données, les tables et les détails de connexion et les ajouter au catalogue de données à l'aide de la AWS Glue console, de la console Lake Formation ou AWS Glue APIs. AWS CLI La saisie manuelle est utile lorsque vous souhaitez cataloguer des sources de données qui ne peuvent pas être analysées.
+ Intégration à d'autres AWS services : vous pouvez remplir le catalogue de données avec des métadonnées provenant de services tels qu'Amazon AWS Lake Formation Athena. Ces services peuvent découvrir et enregistrer des sources de données dans le catalogue de données.
+ Remplissage à partir d'un référentiel de métadonnées existant : si vous disposez d'un magasin de métadonnées existant tel qu'Apache Hive Metastore, vous pouvez l'utiliser AWS Glue pour importer ces métadonnées dans le catalogue de données. Pour plus d'informations, consultez la section [Migration entre le métastore Hive et](https://github.com/aws-samples/aws-glue-samples/tree/master/utilities/Hive_metastore_migration) le on. AWS Glue Data Catalog GitHub
**Topics**
+ [Utilisation de robots pour alimenter le catalogue de données](add-crawler.md)
+ [Définition manuelle des métadonnées](populate-dg-manual.md)
+ [Intégration aux tables Amazon S3](glue-federation-s3tables.md)
+ [Intégration à d'autres AWS services](populate-dc-other-services.md)
+ [Paramètres du catalogue de données](console-data-catalog-settings.md)
# Utilisation de robots pour alimenter le catalogue de données
Vous pouvez utiliser an AWS Glue crawler pour les renseigner AWS Glue Data Catalog avec des bases de données et des tables. Il s'agit de la principale méthode utilisée par la plupart des AWS Glue utilisateurs. Un crawler peut analyser plusieurs magasins de données en une seule fois. À la fin de cette opération, l’crawler crée ou met à jour une ou plusieurs tables dans votre Data Catalog. Les tâches Extract-transform-load (ETL) que vous définissez dans AWS Glue utilisent ces tables Data Catalog en tant que sources et cibles. La tâche ETL lit et écrit dans les magasins de données qui sont spécifiés dans les tables Data Catalog sources et cibles.
## Flux de travail
Le diagramme de flux de travail suivant montre comment les crawlers AWS Glue interagissent avec magasins de données et d’autres éléments pour remplir le catalogue de données.
![\[Flux de travail montrant comment l’crawler AWS Glue remplit le catalogue de données en 5 étapes élémentaires.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/PopulateCatalog-overview.png)
Voici comment un crawler remplit le AWS Glue Data Catalog :
1. Un crawler exécute tous les *classifieurs* personnalisés que vous choisissez pour déduire le format et le schéma de vos données. Vous fournissez le code pour les classificateurs personnalisés, lesquels s’exécutent dans l’ordre que vous spécifiez.
Le premier classifieur personnalisé qui reconnaît avec succès la structure de vos données est utilisé pour créer un schéma. Les classifieurs personnalisés en bas de la liste sont ignorés.
1. Si aucun classifieur ne correspond au schéma de vos données, les classifieurs intégrés essaient de reconnaître le schéma de données. Un exemple de classifieur intégré est un classifieur qui reconnaît JSON.
1. L’crawler se connecte au magasin de données. Certains magasins de données nécessitent les propriétés de connexion pour l’accès de l’crawler.
1. Le schéma déduit est créé pour vos données.
1. L’crawler écrit les métadonnées dans le catalogue de données. Une définition de table contient les métadonnées sur les données de votre magasin de données. La table est écrite dans une base de données, qui est un conteneur de tables du catalogue de données. Les attributs d’une table incluent la classification, qui est une étiquette créé par le classificateur ayant déduit du schéma de la table.
**Topics**
+ [Flux de travail](#crawler-workflow)
+ [Fonctionnement des crawlers](#crawler-running)
+ [Comment un crawler détermine quand créer des partitions ?](#crawler-s3-folder-table-partition)
+ [Sources de données prises en charge pour l’indexation de site web](crawler-data-stores.md)
+ [Prérequis pour le crawler](crawler-prereqs.md)
+ [Définition et gestion des classificateurs](add-classifier.md)
+ [Configuration d’un robot](define-crawler.md)
+ [Planification d'un crawler](schedule-crawler.md)
+ [Affichage des résultats et des détails du crawler](console-crawlers-details.md)
+ [Personnalisation du comportement d’un robot](crawler-configuration.md)
+ [Didacticiel : Ajout d'un crawler AWS Glue](tutorial-add-crawler.md)
## Fonctionnement des crawlers
Lorsqu’un crawler s’exécute, il prend les actions suivantes pour interroger un magasin de données :
+ **Classe les données pour déterminer le format, le schéma et les propriétés associées des données brutes** – Vous pouvez configurer les résultats de la classification en créant un classifieur personnalisé.
+ **Groupes les données en tables ou en partitions ** – Les données sont regroupées en fonction de l’heuristique de l’crawler.
+ **Writes metadata to the Data Catalog ** (Écrit les métadonnées sur Data Catatlog) – vous pouvez configurer la façon dont l’crawler ajoute, met à jour et supprime les tables et les partitions.
Lorsque vous définissez un crawler, vous choisissez un ou plusieurs classifieurs qui évaluent le format de vos données pour déduire un schéma. Lorsque l’crawler s’exécute, le premier classificateur de la liste qui reconnaît correctement votre magasin de données est utilisé pour créer un schéma pour votre table. Vous pouvez utiliser des classifieurs intégrés ou définir les vôtres. Vous définissez vos classifieurs personnalisés dans une autre opération, avant de définir les crawlers. AWS Glue fournit des classifieurs intégrés pour déduire les schémas les plus répandus qui incluent les formats de fichiers JSON, CSV et Apache Avro. Pour obtenir la liste actuelle des classifieurs intégrés dans AWS Glue, consultez [Classifieurs intégrés](add-classifier.md#classifier-built-in).
Les tables de métadonnées créées par un crawler sont contenues dans une base de données lorsque vous définissez un crawler. Si votre crawler ne spécifie pas de base de données, vos tables sont placées dans la base de données par défaut. En outre, chaque table dispose d’une colonne de classification remplie par le premier classificateur qui reconnaît correctement le magasin de données.
Si le fichier analysé est compressé, l’crawler doit le télécharger afin de le traiter. Lorsqu’un crawler s’exécute, il interroge les fichiers pour déterminer leur format et leur type de compression, et écrit ces propriétés dans Data Catalog. Certains formats de fichier (Apache Parquet, par exemple), vous permettent de compresser des parties du fichier au moment de son écriture. Pour ces fichiers, les données compressées sont un composant interne du fichier et AWS Glue ne renseigne pas la propriété `compressionType` lors de l’écriture des tables dans Data Catalog. En revanche, si un *fichier complet* est compressé par un algorithme de compression (par exemple, gzip), la propriété `compressionType` est alors renseignée lorsque les tables sont écrites dans Data Catalog.
L’crawler génère les noms pour les tables qu’il crée. Les noms des tables stockées dans le sont conformes aux AWS Glue Data Catalog règles suivantes :
+ Seuls les caractères alphanumériques et les traits de soulignement (`_`) sont autorisés.
+ Un préfixe personnalisé ne doit pas comporter plus de 64 caractères.
+ La longueur maximale du nom ne doit pas dépasser 128 caractères. L’crawler tronque les noms générés pour les ajuster à la limite.
+ En cas de noms de table en double, l’crawler ajoute un suffixe de chaîne de hachage au nom.
Si votre crawler s’exécute plusieurs fois, par exemple sur un calendrier, il recherche les tables et les fichiers nouveaux ou modifiés dans votre magasin de données. La sortie de l’crawler inclut les nouvelles tables et partitions trouvées depuis l’exécution précédente.
## Comment un crawler détermine quand créer des partitions ?
Lorsqu'un AWS Glue robot d'exploration analyse le magasin de données Amazon S3 et détecte plusieurs dossiers dans un compartiment, il détermine la racine d'une table dans la structure des dossiers et les dossiers qui sont des partitions d'une table. Le nom de la table est basé sur le préfixe Amazon S3 ou le nom de dossier. Vous fournissez un **chemin Include** qui pointe vers le niveau de dossier à analyser. Lorsque la majorité des schémas au niveau d’un dossier sont similaires, l’crawler crée les partitions d’une table au lieu de tables distinctes. Pour influencer l’crawler et créer des tables distincts, ajoutez le dossier racine de chaque table en tant que magasin de données séparé lorsque vous définissez l’crawler.
Prenons l’exemple de la structure de dossiers Amazon S3 suivante.
![\[Les rectangles à plusieurs niveaux représentent une hiérarchie de dossiers dans Amazon S3. Le rectangle supérieur est étiqueté Sales (Ventes). Le rectangle en dessous est étiqueté year=2019 (année=2019). Deux rectangles ci-dessous sont étiquetés month=Jan (mois=janv.) et month=Feb (mois=Fév.). Chacun de ces rectangles a deux rectangles en dessous, étiquetés day=1 (jour=1) et day=2 (jour=2). Les quatre rectangles « day » (jour) (en bas) ont deux ou quatre fichiers placés sous eux. Tous les rectangles et fichiers sont reliés par des lignes.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/crawlers-s3-folders.png)
Les chemins d’accès aux quatre dossiers de niveau inférieur sont les suivants :
```
S3://sales/year=2019/month=Jan/day=1
S3://sales/year=2019/month=Jan/day=2
S3://sales/year=2019/month=Feb/day=1
S3://sales/year=2019/month=Feb/day=2
```
Supposons que la cible de l’crawler est définie sur `Sales` et que tous les fichiers des dossiers `day=n` ont le même format (par exemple, JSON, non chiffré) et ont des schémas identiques ou très similaires. L’crawler créera une seule table avec quatre partitions, avec les clés de partition `year`,`month` et `day`.
Dans l’exemple suivant, observez la structure Amazon S3 suivante :
```
s3://bucket01/folder1/table1/partition1/file.txt
s3://bucket01/folder1/table1/partition2/file.txt
s3://bucket01/folder1/table1/partition3/file.txt
s3://bucket01/folder1/table2/partition4/file.txt
s3://bucket01/folder1/table2/partition5/file.txt
```
Si les schémas pour les fichiers sous `table1` et `table2` sont similaires, et qu’un seul magasin de données est défini dans l’crawler avec **Include path** `s3://bucket01/folder1/`, l’crawler crée une seule table avec deux colonnes de clés de partition. La première colonne de clé de partition contient `table1` et `table2`, et la deuxième colonne de clé de partition contient `partition1` à `partition3` pour la partition `table1`, et `partition4` et `partition5` pour la partition `table2`. Pour créer deux tables distinctes, définissez l’crawler avec deux magasins de données. Dans cet exemple, définissez le premier **Include path** comme `s3://bucket01/folder1/table1/` et le second comme `s3://bucket01/folder1/table2`.
**Note**
Dans Amazon Athena, chaque table correspond à un préfixe Amazon S3 avec tous les objets qu’il contient. Si les objets ont des schémas différents, Athena ne reconnaît pas les différents objets au sein du même préfixe comme des tables distinctes. Cela peut se produire si un crawler crée plusieurs tables à partir du même préfixe Amazon S3. Il peut en résulter que des requêtes dans Athena ne renvoient aucun résultat. Pour qu’Athena reconnaisse et interroge correctement les tables, créez l’crawler avec un **Include path** (chemin d’inclusion) distinct pour chaque schéma de table différent dans la structure de dossier Amazon S3. Pour plus d’informations, consultez [Bonnes pratiques lors de l’utilisation d’Athena avec AWS Glue](https://docs.aws.amazon.com/athena/latest/ug/glue-best-practices.html) et cet [article du Centre de connaissances AWS](https://aws.amazon.com/premiumsupport/knowledge-center/athena-empty-results/).
# Sources de données prises en charge pour l’indexation de site web
Des crawlers peuvent analyser les magasins de données basés sur les fichiers et sur les tables suivants.
| Type d’accès utilisé par l’crawler | Magasins de données |
| --- | --- |
| Client en mode natif | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/crawler-data-stores.html) |
| JDBC | Amazon Redshift Snowflake Dans Amazon Relational Database Service (Amazon RDS) ou externe à Amazon RDS : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/crawler-data-stores.html) |
| Client MongoDB | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/crawler-data-stores.html) |
**Note**
Actuellement, AWS Glue ne prend pas en charge les crawlers pour les flux de données.
Pour les magasins de données JDBC, MongoDB, MongoDB Atlas et Amazon DocumentDB (compatible avec MongoDB), vous devez spécifier une *connexion* AWS Glue que le crawler peut utiliser pour se connecter au magasin de données. Pour Amazon S3, vous pouvez éventuellement spécifier une connexion de type Network (Réseau). Une connexion est un objet Data Catalog qui stocke les informations de connexion, telles que les informations d’identification, l’URL, les informations de Virtual Private Cloud Amazon, etc. Pour de plus amples informations, veuillez consulter [Connexion aux données](glue-connections.md).
Voici les versions des pilotes prises en charge par le robot :
| Produit (langue française non garantie) | Pilote pris en charge par le robot |
| --- | --- |
| PostgreSQL | 42.2.1 |
| Amazon Aurora | Identique aux pilotes de robots natifs |
| MariaDB | 8.0.13 |
| Microsoft SQL Server | 6.1.0 |
| MySQL | 8.0.13 |
| Oracle | 11.2.2 |
| Amazon Redshift | 4.1 |
| Snowflake | 3,13,20 |
| MongoDB | 4.7.2 |
| Atlas MongoDB | 4.7.2 |
Voici quelques remarques sur les différents magasins de données.
**Amazon S3**
Vous pouvez choisir d’explorer un chemin dans votre compte ou dans un autre compte. Si tous les fichiers Amazon S3 d’un dossier ont le même schéma, l’crawler crée une table. De plus, si l’objet Amazon S3 est partitionné, une seule table de métadonnées est créée et les informations de partition sont ajoutées à Data Catalog pour cette table.
**Amazon S3 et Amazon DynamoDB**
Les robots d'exploration utilisent un rôle Gestion des identités et des accès AWS (IAM) pour obtenir l'autorisation d'accéder à vos magasins de données. *Le rôle que vous transmettez à l’crawler doit avoir l’autorisation d’accéder aux chemins Amazon S3 et aux tables Amazon DynamoDB analysés.*
**Amazon DynamoDB**
Lorsque vous définissez un crawler à l’aide de la console AWS Glue, vous spécifiez une table DynamoDB. Si vous utilisez l’API AWS Glue, vous pouvez spécifier une liste des tables. Vous pouvez choisir d'analyser un petit échantillon des données uniquement pour réduire les temps d'exécution de l'crawler.
**Delta Lake**
Pour chaque magasin de données Delta Lake, vous précisez comment créer les tables Delta :
+ **Créer des tables natives** : permettre l’intégration avec les moteurs de requêtes qui prennent directement en charge l’interrogation du journal de transactions Delta. Pour plus d’informations, veuillez consulter la rubrique [Interrogation des tables Delta Lake](https://docs.aws.amazon.com/athena/latest/ug/delta-lake-tables.html).
+ **Créer des tables avec des liens symboliques** : créer un dossier `_symlink_manifest` avec les fichiers manifestes partitionnés par les clés de partition, en fonction des paramètres de configuration spécifiés.
**Iceberg**
Pour chaque magasin de données Iceberg, vous spécifiez un chemin Amazon S3 qui contient les métadonnées de vos tables Iceberg. Si le Crawler découvre des métadonnées de table Iceberg, il les enregistre dans le catalogue de données. Vous pouvez définir un calendrier pour que le Crawler mette à jour les tables.
Vous pouvez définir les paramètres suivants pour le magasin de données :
+ **Exclusions** : permet d'ignorer certains dossiers.
+ **Profondeur maximale d'indexation** : définit la limite de profondeur que le Crawler peut indexer dans votre compartiment Amazon S3. La profondeur maximale d'indexation par défaut est de 10 et la profondeur maximale que vous pouvez définir est de 20.
**Hudi**
Pour chaque magasin de données Hudi, vous spécifiez un chemin Amazon S3 qui contient les métadonnées de vos tables Hudi. Si le Crawler découvre des métadonnées de table Hudi, il les enregistre dans le catalogue de données. Vous pouvez définir un calendrier pour que le Crawler mette à jour les tables.
Vous pouvez définir les paramètres suivants pour le magasin de données :
+ **Exclusions** : permet d'ignorer certains dossiers.
+ **Profondeur maximale d'indexation** : définit la limite de profondeur que le Crawler peut indexer dans votre compartiment Amazon S3. La profondeur maximale d'indexation par défaut est de 10 et la profondeur maximale que vous pouvez définir est de 20.
Les colonnes d’horodatage avec `millis` en tant que types logiques seront interprétées comme `bigint`, en raison d’une incompatibilité avec Hudi 0.13.1 et les types d’horodatage. Une solution pourrait être fournie dans la prochaine version de Hudi.
Les tables Hudi sont classées comme suit, avec des implications spécifiques pour chacune d’entre elles :
+ Copie sur écriture (CoW) : les données sont stockées dans un format en colonnes (Parquet) et chaque mise à jour crée une version des fichiers lors d’une écriture.
+ Fusion sur lecture (MoR) : les données sont stockées à l’aide d’une combinaison des formats en colonnes (Parquet) et basés sur les lignes (Avro). Les mises à jour sont consignées dans des fichiers delta basés sur les lignes et sont compressées si nécessaire pour créer de nouvelles versions des fichiers en colonnes.
Avec les ensembles de données CoW, chaque fois qu’une mise à jour est apportée à un enregistrement, le fichier qui contient l’enregistrement est réécrit avec les valeurs mises à jour. Avec un jeu de données MoR, chaque fois qu’une mise à jour a lieu, Hudi écrit uniquement la ligne du registre modifié. Le type de stockage MoR est mieux adapté aux charges de travail donnant lieu à de nombreuses écritures ou modifications avec moins de lectures. Le type de stockage CoW est mieux adapté aux charges de travail lourdes en lecture sur des données qui changent moins fréquemment.
Hudi propose trois types de requêtes pour accéder aux données :
+ Requêtes d’instantané : requêtes qui affichent le dernier instantané de la table à partir d’une action de validation ou de compactage donnée. Pour les tables MoR, les requêtes d’instantané exposent l’état le plus récent de la table en fusionnant les fichiers de base et delta de la dernière tranche de fichiers au moment de la requête.
+ Requêtes progressives : les requêtes ne portent que sur les nouvelles données écrites dans la table, depuis une validation/un compactage donné. Cela fournit efficacement des flux de modifications pour activer les pipelines de données (Data Pipelines) progressives.
+ Requêtes à lecture optimisée : pour les tables MoR, les requêtes portent sur les dernières données compactées. Pour les tables CoW, les requêtes portent sur les dernières données validées.
Pour Copy-On-Write les tables, les robots créent une seule table dans le catalogue de données avec le ReadOptimized `org.apache.hudi.hadoop.HoodieParquetInputFormat` serde.
Pour Merge-On-Read les tables, le robot crée deux tables dans le catalogue de données pour le même emplacement de table :
+ Une table avec un suffixe `_ro` qui utilise le ReadOptimized `org.apache.hudi.hadoop.HoodieParquetInputFormat` serde.
+ Une table avec suffixe `_rt` qui utilise le RealTime Serde pour permettre les requêtes Snapshot :. `org.apache.hudi.hadoop.realtime.HoodieParquetRealtimeInputFormat`
**MongoDB and Amazon DocumentDB (compatible avec MongoDB)**
Les versions 3.2 et ultérieures de MongoDB sont prises en charge. Vous pouvez choisir d'analyser un petit échantillon des données uniquement pour réduire les temps d'exécution de l'crawler.
**Base de données relationnelle**
L’authentification est effectuée à l’aide d’un nom d’utilisateur et d’un mot de passe de base de données. En fonction du type de moteur de base de données, vous pouvez choisir quels objets sont analysés, comme les bases de données, les schémas et les tables.
**Snowflake**
Le crawler JDBC Snowflake prend en charge l’analyse de la table, de la table externe, de la vue et de la vue matérialisée. La définition de la vue matérialisée n’est pas renseignée.
Pour les tables externes Snowflake, le crawler n’effectue l’analyse que s’il pointe vers un emplacement Amazon S3. Outre le schéma de la table, le crawler analyse également l’emplacement, le format de fichier et la sortie d’Amazon S3 sous forme de paramètres de table dans la table du catalogue de données. Notez que les informations de partition de la table externe partitionnée ne sont pas renseignées.
Actuellement, ETL n’est pas pris en charge pour les tables du catalogue de données créées à l’aide du crawler Snowflake.
# Prérequis pour le crawler
Le robot d'exploration assume les autorisations du rôle Gestion des identités et des accès AWS (IAM) que vous spécifiez lorsque vous le définissez. Ce rôle IAM doit disposer d’autorisations pour extraire les données de votre magasin de données et écrire sur Data Catalog. La console AWS Glue répertorie uniquement les rôles IAM auxquels une politique d’approbation est attachée pour le service principal AWS Glue. Dans la console, vous pouvez également créer un rôle IAM avec une politique IAM permettant d’accéder aux magasins de données Amazon S3 auxquels l’crawler accède. Pour plus d’informations sur les rôles pour AWS Glue, consultez [Politiques basées sur l'identité pour Glue AWS](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies).
**Note**
Lorsque vous explorez un magasin de données de Delta Lake, vous devez être Read/Write autorisé à accéder à l'emplacement Amazon S3.
Pour votre crawler, vous pouvez créer un rôle et attacher les politiques suivantes :
+ La politique `AWSGlueServiceRole` AWS gérée, qui accorde les autorisations requises sur le catalogue de données
+ Politique en ligne qui accorde des autorisations sur la source de données.
+ Politique en ligne qui accorde l’autorisation `iam:PassRole` sur le rôle.
Si vous préférez une approche plus rapide, vous pouvez laisser l’assistant de l’crawler de la console AWS Glue créer un rôle pour vous. Le rôle qu'il crée est spécifique au robot d'exploration et inclut la politique `AWSGlueServiceRole` AWS gérée ainsi que la politique en ligne requise pour la source de données spécifiée.
Si vous spécifiez un rôle existant pour un crawler, assurez-vous qu’il inclut la politique `AWSGlueServiceRole` ou l’équivalent (ou une version limitée de cette politique), ainsi que les politiques en ligne requises. Par exemple, pour un magasin de données Amazon S3, la politique en ligne serait au minimum la suivante :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::bucket/object*"
]
}
]
}
```
------
Pour un magasin de données Amazon DynamoDB, la politique serait au minimum la suivante :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:DescribeTable",
"dynamodb:Scan"
],
"Resource": [
"arn:aws:dynamodb:us-east-1:111122223333:table/table-name*"
]
}
]
}
```
------
En outre, si le robot lit AWS Key Management Service (AWS KMS) des données Amazon S3 chiffrées, le rôle IAM doit disposer d'une autorisation de déchiffrement sur la clé. AWS KMS Pour de plus amples informations, veuillez consulter [Étape 2 : créer un rôle IAM pour AWS Glue](create-an-iam-role.md).
# Définition et gestion des classificateurs
Un classificateur lit les données d’un magasin de données. S’il reconnaît le format des données, il génère un schéma. Le classificateur renvoie également un pourcentage de certitude pour indiquer jusqu’à quel degré la reconnaissance du format était certaine.
AWS Glue fournit un ensemble de classificateurs intégrés, mais vous pouvez également créer classificateurs personnalisés. AWS Glue appelle les classificateurs personnalisés en premier, dans l’ordre que vous spécifiez dans votre définition d’crawler. Selon les résultats renvoyés par les classifieurs personnalisés, AWS Glue peut également appeler les classifieurs intégrés. Si un classificateur renvoie `certainty=1.0` pendant le traitement, cela indique qu’il est sûr à 100 % de pouvoir créer le schéma correct. AWS Glue utilise ensuite la sortie de ce classificateur.
Si aucun classifieur ne renvoie `certainty=1.0`, AWS Glue utilise la sortie du classifieur qui a la certitude la plus élevée. Si aucun classifieur ne renvoie une certitude supérieure à `0.0`, AWS Glue renvoie la chaîne de classification par défaut `UNKNOWN`.
## Quand dois-je utiliser un classifieur ?
Vous utilisez les classificateurs lorsque vous analysez un magasin de données pour définir les tables de métadonnées dans l’ AWS Glue Data Catalog. Vous pouvez configurer votre crawler avec un ensemble ordonné de classifieurs. Lorsque l’crawler appelle un classificateur, le classificateur détermine si les données sont reconnues. Si le classificateur ne peut pas reconnaître les données ou n’est pas certain à 100 %, l’crawler appelle le prochain classificateur de la liste pour déterminer s’il peut reconnaître les données.
Pour plus d’informations sur la création d’un classificateur à l’aide de la console AWS Glue, consultez [Création de classificateurs à l’aide de la console AWS Glue](console-classifiers.md).
## Classifieurs personnalisés
La sortie d’un classificateur comprend une chaîne qui indique la classification du fichier ou le format (par exemple, `json`) et le schéma du fichier. Pour les classifieurs personnalisés, vous définissez la logique de création du schéma en fonction du type de classifieur. Les types de classificateur incluent la définition de schémas basés sur les modèles grok, les balises XML et les chemins d’accès JSON.
Si vous modifiez une définition de classificateur, toutes les données précédemment analysées à l’aide du classificateur ne sont pas reclassées. Un crawler garde trace des données précédemment analysées. Les nouvelles données sont classées avec le classifieur mis à jour, ce qui peut entraîner une mise à jour du schéma. Si le schéma de vos données a évolué, mettez à jour le classificateur pour prendre en compte les modifications de schéma lorsque votre crawler s’exécute. Pour reclasser les données et corriger un classificateur incorrect, créez un nouvel crawler avec le classificateur mis à jour.
Pour plus d’informations sur la création de classificateurs personnalisés dans AWS Glue, consultez [Rédaction de classificateurs personnalisés pour divers formats de données](custom-classifier.md).
**Note**
Si votre format de données est reconnu par l’un des classificateurs intégrés, vous n’avez pas besoin de créer un classificateur personnalisé.
## Classifieurs intégrés
AWS Glue fournit des classifieurs intégrés pour différents formats, y compris JSON, CSV, les journaux web et de nombreux systèmes de bases de données.
Si AWS Glue ne trouve pas de classificateur personnalisé qui correspond au format des données en entrée avec 100 % de certitude, il fait appel aux classificateurs intégrés dans l’ordre indiqué dans le tableau suivant. Les classifieurs intégrés renvoient un résultat pour indiquer si le format correspond à (`certainty=1.0`) ou ne correspond à (`certainty=0.0`). Le premier classifieur qui a `certainty=1.0` fournit la chaîne de classification et le schéma pour une table de métadonnées de votre Data Catalog.
| Type de classificateur | Chaîne de classification | Remarques |
| --- | --- | --- |
| Apache Avro | avro | Lit le schéma au début du fichier pour déterminer le format. |
| Apache ORC | orc | Lit les métadonnées du fichier pour déterminer le format. |
| Apache Parquet | parquet | Lit le schéma à la fin du fichier pour déterminer le format. |
| JSON | json | Lit le début du fichier pour déterminer le format. |
| Binaire JSON | bson | Lit le début du fichier pour déterminer le format. |
| xml | xml | Lit le début du fichier pour déterminer le format. AWS Glue détermine le schéma de table en fonction des balises XML du document. Pour plus d’informations sur la création d’un classificateur XML personnalisé pour spécifier les lignes du document, reportez-vous à la section [Écriture de classifieurs XML personnalisés](custom-classifier.md#custom-classifier-xml). |
| Amazon Ion | ion | Lit le début du fichier pour déterminer le format. |
| Journal Apache combiné | combined\$1apache | Détermine les formats de journaux par le biais d'un modèle grok. |
| Journal Apache | apache | Détermine les formats de journaux par le biais d'un modèle grok. |
| Journal du noyau Linux | linux\$1kernel | Détermine les formats de journaux par le biais d'un modèle grok. |
| Journal Microsoft | microsoft\$1log | Détermine les formats de journaux par le biais d'un modèle grok. |
| Journal Ruby | ruby\$1logger | Lit le début du fichier pour déterminer le format. |
| Journal Squid 3.x | squid | Lit le début du fichier pour déterminer le format. |
| Journal de surveillance Redis | redismonlog | Lit le début du fichier pour déterminer le format. |
| Journal Redis | redislog | Lit le début du fichier pour déterminer le format. |
| CSV | csv | Recherche les séparateurs suivants : virgule (,), barre verticale (\$1), tabulation (\$1t), point-virgule (;) et Ctrl-A (\$1u0001). Ctrl-A est le caractère de contrôle Unicode pour Start Of Heading. |
| Amazon Redshift | redshift | Utilise la connexion JDBC pour importer les métadonnées. |
| MySQL | mysql | Utilise la connexion JDBC pour importer les métadonnées. |
| PostgreSQL | postgresql | Utilise la connexion JDBC pour importer les métadonnées. |
| Oracle Database | oracle | Utilise la connexion JDBC pour importer les métadonnées. |
| Microsoft SQL Server | sqlserver | Utilise la connexion JDBC pour importer les métadonnées. |
| Amazon DynamoDB | dynamodb | Lit les données de la table DynamoDB. |
Les fichiers aux formats compressés suivants peuvent être classés :
+ ZIP (pris en charge pour les archives contenant uniquement un fichier unique). Notez que Zip n’est pas correctement pris en charge dans d’autres services (en raison de l’archive).
+ BZIP
+ GZIP
+ LZ4
+ Snappy (pris en charge pour les formats Snappy standard et natifs Hadoop)
### Classifieur CSV intégré
Le classificateur CSV intégré analyse le contenu du fichier CSV pour déterminer le schéma d’une table AWS Glue. Le classifieur vérifie les délimiteurs suivants :
+ Virgule (,)
+ Pipe (\$1)
+ Tabulation (\$1t)
+ Point-virgule (;)
+ Ctrl-A (\$1u0001)
Ctrl-A est le caractère de contrôle Unicode pour `Start Of Heading`.
Pour être classé comme CSV, le schéma de table doit avoir au moins deux colonnes et deux lignes de données. Le classifieur CSV utilise un certain nombre de méthodes heuristiques pour déterminer si un en-tête est présent dans un fichier donné. Si le classifieur ne peut pas déterminer un en-tête à partir de la première ligne de données, les en-têtes de colonne sont affichés en tant que `col1`, `col2`, `col3`, et ainsi de suite. Le classificateur CSV intégré détermine s’il convient de déduire un en-tête en évaluant les caractéristiques suivantes du fichier :
+ Chaque colonne d’un en-tête potentiel s’analyse en tant que type de données STRING.
+ À l’exception de la dernière colonne, chaque colonne d’un en-tête potentiel a un contenu de moins de 150 caractères. Pour autoriser un délimiteur de fin, la dernière colonne peut être vide dans le fichier.
+ Chaque colonne d’un en-tête potentiel doit répondre aux exigences AWS Glue `regex` pour un nom de colonne.
+ La ligne d’en-tête doit être suffisamment différente des lignes de données. Pour le déterminer, une ou plusieurs lignes doivent s’analyser autrement que de type STRING. Si toutes les colonnes sont de type STRING, la première ligne de données n’est pas suffisamment différente des lignes suivantes pour être utilisée comme en-tête.
**Note**
Si le classificateur CSV intégré ne crée pas votre table AWS Glue comme vous le souhaitez, vous pouvez utiliser l’une des solutions suivantes :
Modifiez les noms de colonne du Data Catalog, définissez la structure `SchemaChangePolicy` sur LOG et définissez la configuration de sortie de la partition sur `InheritFromTable` pour les futures exécutions de l’crawler.
Créez un classifieur grok personnalisés pour analyser les données et attribuez les colonnes de votre choix.
Le classificateur CSV intégré crée les tables en faisant référence à `LazySimpleSerDe` comme bibliothèque de sérialisation, ce qui est un bon choix pour l’inférence du type. Toutefois, si les données CSV contiennent des chaînes entre guillemets, modifiez la définition de la table et remplacez la SerDe bibliothèque par`OpenCSVSerDe`. Ajustez les types déduits sur STRING, définissez la structure `SchemaChangePolicy` sur LOG et définissez la configuration de sortie des partitions sur `InheritFromTable` pour les futures exécutions de l’crawler. Pour plus d'informations sur SerDe les bibliothèques, consultez la section [SerDe Référence](https://docs.aws.amazon.com/athena/latest/ug/serde-reference.html) du guide de l'utilisateur Amazon Athena.
# Rédaction de classificateurs personnalisés pour divers formats de données
Vous pouvez fournir un classifieur personnalisé pour classer vos données dans AWS Glue. Vous pouvez créer un classificateur personnalisé à l'aide d'un modèle grok, d'une balise XML, d'une notation d' JavaScript objet (JSON) ou de valeurs séparées par des virgules (CSV). Un crawler AWS Glue appelle un classifieur personnalisé. Si le classifieur reconnaît les données, il renvoie la classification et le schéma des données à l'crawler. Il se peut que vous ayez besoin de définir un classifieur personnalisé si vos données ne correspondent à aucun classifieur intégré ou si vous souhaitez personnaliser les tables créées par l'crawler.
Pour plus d’informations sur la création d’un classificateur à l’aide de la console AWS Glue, consultez [Création de classificateurs à l’aide de la console AWS Glue](console-classifiers.md).
AWS Glue exécute les classifieurs personnalisés avant les classifieurs intégrés, dans l'ordre que vous spécifiez. Lorsqu'un crawler détecte un classifieur qui correspond aux données, la chaîne de classification et le schéma sont utilisés dans la définition des tables qui sont écrites dans votre AWS Glue Data Catalog.
**Topics**
+ [Écriture de classifieurs personnalisés Grok](#custom-classifier-grok)
+ [Écriture de classifieurs XML personnalisés](#custom-classifier-xml)
+ [Écriture de classifieurs JSON personnalisés](#custom-classifier-json)
+ [Écriture de classifieurs CSV personnalisés](#custom-classifier-csv)
## Écriture de classifieurs personnalisés Grok
Grok est un outil qui est utilisé pour analyser les données textuelles correspondant à un modèle donné. Une modèle grok est un ensemble nommé d'expressions régulières (regex) qui sont utilisées pour mettre en correspondance des données ligne par ligne. AWS Glue utilise les modèles grok pour déduire le schéma de vos données. Lorsqu'un modèle grok correspond à vos données, AWS Glue l'utilise pour déterminer la structure de vos données et la mapper aux champs.
AWS Glue propose de nombreux modèles intégrés ; vous pouvez aussi définir les vôtres. Vous pouvez créer un modèle grok à l'aide de modèles intégrés et de modèles personnalisés de votre définition de classifieur personnalisée. Vous pouvez personnaliser un modèle grok pour classer les formats de fichier texte personnalisés.
**Note**
Les classifieurs grok personnalisés AWS Glue utilisent la bibliothèque de sérialisation `GrokSerDe` pour les tables créées dans le AWS Glue Data Catalog. Si vous utilisez le AWS Glue Data Catalog avec Amazon Athena, Amazon EMR ou Redshift Spectrum, consultez la documentation relative à ces services pour obtenir des informations sur le support du. `GrokSerDe` Il est possible que vous rencontriez actuellement des problèmes lors de l'interrogation de tables créées avec le `GrokSerDe` à partir d'Amazon EMR et Redshift Spectrum.
Voici la syntaxe de base pour les composants d'un modèle grok :
```
%{PATTERN:field-name}
```
Les données correspondant au `PATTERN` nommé sont mises en correspondance avec la colonne `field-name` du schéma, avec le type de données par défaut `string`. Le cas échéant, le type de données du champ peut être converti en `byte`, `boolean`, `double`, `short`, `int`, `long`, ou `float` dans le schéma obtenu.
```
%{PATTERN:field-name:data-type}
```
Par exemple, pour convertir un champ `num` en type de données `int`, vous pouvez utiliser ce modèle :
```
%{NUMBER:num:int}
```
Les modèles peuvent être composés d'autres modèles. Par exemple, vous pouvez avoir un modèle pour un horodatage `SYSLOG` qui est défini par des modèles pour le mois, le jour du mois et l'heure (par exemple, `Feb 1 06:25:43`). Pour ces données, vous pourriez définir le schéma suivant:
```
SYSLOGTIMESTAMP %{MONTH} +%{MONTHDAY} %{TIME}
```
**Note**
Les modèles grok ne peuvent traiter qu'une ligne à la fois. Les modèles à plusieurs lignes ne sont pas pris en charge. De même, les sauts de ligne au sein d'un modèle ne sont pas pris en charge.
### Valeurs personnalisées pour le classificateur grok
Lorsque vous définissez un classificateur grok, vous fournissez les valeurs suivantes pour créer le classificeur personnalisé.
**Name**
Nom du classifieur.
**Classification**
Chaîne de texte écrite pour décrire le format des données qui est classé ; par exemple, `special-logs`.
**Modèle grok**
Ensemble des modèles appliqués au magasin de données afin de déterminer s'il y a une correspondance. Ces modèles proviennent des modèles AWS Glue [intégrés](#classifier-builtin-patterns) et de tous les modèles personnalisés que vous définissez.
Voici un exemple de modèle grok :
```
%{TIMESTAMP_ISO8601:timestamp} \[%{MESSAGEPREFIX:message_prefix}\] %{CRAWLERLOGLEVEL:loglevel} : %{GREEDYDATA:message}
```
Lorsque les données correspondent à `TIMESTAMP_ISO8601`, une colonne de schéma `timestamp` est créée. Le comportement est similaire aux autres modèles nommés de l'exemple.
**Modèles personnalisés**
Modèles personnalisés facultatifs que vous définissez. Ces modèles sont référencés par le modèle grok qui classifie vos données. Vous pouvez référencer ces modèles personnalisés dans le modèle grok appliqué à vos données. Chaque modèle de composant personnalisé doit être sur une ligne distincte. La syntaxe des [expressions régulières (regex)](http://en.wikipedia.org/wiki/Regular_expression) est utilisée pour définir le modèle.
Voici un exemple d'utilisation des modèles personnalisés :
```
CRAWLERLOGLEVEL (BENCHMARK|ERROR|WARN|INFO|TRACE)
MESSAGEPREFIX .*-.*-.*-.*-.*
```
Le premier modèle nommé personnalisé, `CRAWLERLOGLEVEL`, est une correspondance dans laquelle les données correspondent à l'une des chaînes énumérées. Le second modèle personnalisé, `MESSAGEPREFIX`, essaie de faire correspondre une chaîne de préfixe de message.
AWS Glue garde trace de l'heure de création, de la dernière heure de mise à jour et de la version de votre classifieur.
### Modèles intégrés
AWS Glue fournit de nombreux modèles courants que vous pouvez utiliser pour construire un classifieur personnalisé. Vous ajoutez un modèle nommé au `grok pattern` d'une définition de classifieur.
La liste suivante comprend une ligne pour chaque modèle. Dans chaque ligne, le nom du modèle est suivi de sa définition. La syntaxe des [expressions régulières (regex)](http://en.wikipedia.org/wiki/Regular_expression) est utilisée pour définir le modèle.
```
#&GLU; Built-in patterns
USERNAME [a-zA-Z0-9._-]+
USER %{USERNAME:UNWANTED}
INT (?:[+-]?(?:[0-9]+))
BASE10NUM (?[+-]?(?:(?:[0-9]+(?:\.[0-9]+)?)|(?:\.[0-9]+)))
NUMBER (?:%{BASE10NUM:UNWANTED})
BASE16NUM (?(?"(?>\\.|[^\\"]+)+"|""|(?>'(?>\\.|[^\\']+)+')|''|(?>`(?>\\.|[^\\`]+)+`)|``))
UUID [A-Fa-f0-9]{8}-(?:[A-Fa-f0-9]{4}-){3}[A-Fa-f0-9]{12}
# Networking
MAC (?:%{CISCOMAC:UNWANTED}|%{WINDOWSMAC:UNWANTED}|%{COMMONMAC:UNWANTED})
CISCOMAC (?:(?:[A-Fa-f0-9]{4}\.){2}[A-Fa-f0-9]{4})
WINDOWSMAC (?:(?:[A-Fa-f0-9]{2}-){5}[A-Fa-f0-9]{2})
COMMONMAC (?:(?:[A-Fa-f0-9]{2}:){5}[A-Fa-f0-9]{2})
IPV6 ((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?
IPV4 (?/(?>[\w_%!$@:.,~-]+|\\.)*)+
#UNIXPATH (?[A-Za-z]+:|\\)(?:\\[^\\?*]*)+
URIPROTO [A-Za-z]+(\+[A-Za-z+]+)?
URIHOST %{IPORHOST}(?::%{POSINT:port})?
# uripath comes loosely from RFC1738, but mostly from what Firefox
# doesn't turn into %XX
URIPATH (?:/[A-Za-z0-9$.+!*'(){},~:;=@#%_\-]*)+
#URIPARAM \?(?:[A-Za-z0-9]+(?:=(?:[^&]*))?(?:&(?:[A-Za-z0-9]+(?:=(?:[^&]*))?)?)*)?
URIPARAM \?[A-Za-z0-9$.+!*'|(){},~@#%&/=:;_?\-\[\]]*
URIPATHPARAM %{URIPATH}(?:%{URIPARAM})?
URI %{URIPROTO}://(?:%{USER}(?::[^@]*)?@)?(?:%{URIHOST})?(?:%{URIPATHPARAM})?
# Months: January, Feb, 3, 03, 12, December
MONTH \b(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\b
MONTHNUM (?:0?[1-9]|1[0-2])
MONTHNUM2 (?:0[1-9]|1[0-2])
MONTHDAY (?:(?:0[1-9])|(?:[12][0-9])|(?:3[01])|[1-9])
# Days: Monday, Tue, Thu, etc...
DAY (?:Mon(?:day)?|Tue(?:sday)?|Wed(?:nesday)?|Thu(?:rsday)?|Fri(?:day)?|Sat(?:urday)?|Sun(?:day)?)
# Years?
YEAR (?>\d\d){1,2}
# Time: HH:MM:SS
#TIME \d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?
# TIME %{POSINT<24}:%{POSINT<60}(?::%{POSINT<60}(?:\.%{POSINT})?)?
HOUR (?:2[0123]|[01]?[0-9])
MINUTE (?:[0-5][0-9])
# '60' is a leap second in most time standards and thus is valid.
SECOND (?:(?:[0-5]?[0-9]|60)(?:[:.,][0-9]+)?)
TIME (?!<[0-9])%{HOUR}:%{MINUTE}(?::%{SECOND})(?![0-9])
# datestamp is YYYY/MM/DD-HH:MM:SS.UUUU (or something like it)
DATE_US %{MONTHNUM}[/-]%{MONTHDAY}[/-]%{YEAR}
DATE_EU %{MONTHDAY}[./-]%{MONTHNUM}[./-]%{YEAR}
DATESTAMP_US %{DATE_US}[- ]%{TIME}
DATESTAMP_EU %{DATE_EU}[- ]%{TIME}
ISO8601_TIMEZONE (?:Z|[+-]%{HOUR}(?::?%{MINUTE}))
ISO8601_SECOND (?:%{SECOND}|60)
TIMESTAMP_ISO8601 %{YEAR}-%{MONTHNUM}-%{MONTHDAY}[T ]%{HOUR}:?%{MINUTE}(?::?%{SECOND})?%{ISO8601_TIMEZONE}?
TZ (?:[PMCE][SD]T|UTC)
DATESTAMP_RFC822 %{DAY} %{MONTH} %{MONTHDAY} %{YEAR} %{TIME} %{TZ}
DATESTAMP_RFC2822 %{DAY}, %{MONTHDAY} %{MONTH} %{YEAR} %{TIME} %{ISO8601_TIMEZONE}
DATESTAMP_OTHER %{DAY} %{MONTH} %{MONTHDAY} %{TIME} %{TZ} %{YEAR}
DATESTAMP_EVENTLOG %{YEAR}%{MONTHNUM2}%{MONTHDAY}%{HOUR}%{MINUTE}%{SECOND}
CISCOTIMESTAMP %{MONTH} %{MONTHDAY} %{TIME}
# Syslog Dates: Month Day HH:MM:SS
SYSLOGTIMESTAMP %{MONTH} +%{MONTHDAY} %{TIME}
PROG (?:[\w._/%-]+)
SYSLOGPROG %{PROG:program}(?:\[%{POSINT:pid}\])?
SYSLOGHOST %{IPORHOST}
SYSLOGFACILITY <%{NONNEGINT:facility}.%{NONNEGINT:priority}>
HTTPDATE %{MONTHDAY}/%{MONTH}/%{YEAR}:%{TIME} %{INT}
# Shortcuts
QS %{QUOTEDSTRING:UNWANTED}
# Log formats
SYSLOGBASE %{SYSLOGTIMESTAMP:timestamp} (?:%{SYSLOGFACILITY} )?%{SYSLOGHOST:logsource} %{SYSLOGPROG}:
MESSAGESLOG %{SYSLOGBASE} %{DATA}
COMMONAPACHELOG %{IPORHOST:clientip} %{USER:ident} %{USER:auth} \[%{HTTPDATE:timestamp}\] "(?:%{WORD:verb} %{NOTSPACE:request}(?: HTTP/%{NUMBER:httpversion})?|%{DATA:rawrequest})" %{NUMBER:response} (?:%{Bytes:bytes=%{NUMBER}|-})
COMBINEDAPACHELOG %{COMMONAPACHELOG} %{QS:referrer} %{QS:agent}
COMMONAPACHELOG_DATATYPED %{IPORHOST:clientip} %{USER:ident;boolean} %{USER:auth} \[%{HTTPDATE:timestamp;date;dd/MMM/yyyy:HH:mm:ss Z}\] "(?:%{WORD:verb;string} %{NOTSPACE:request}(?: HTTP/%{NUMBER:httpversion;float})?|%{DATA:rawrequest})" %{NUMBER:response;int} (?:%{NUMBER:bytes;long}|-)
# Log Levels
LOGLEVEL ([A|a]lert|ALERT|[T|t]race|TRACE|[D|d]ebug|DEBUG|[N|n]otice|NOTICE|[I|i]nfo|INFO|[W|w]arn?(?:ing)?|WARN?(?:ING)?|[E|e]rr?(?:or)?|ERR?(?:OR)?|[C|c]rit?(?:ical)?|CRIT?(?:ICAL)?|[F|f]atal|FATAL|[S|s]evere|SEVERE|EMERG(?:ENCY)?|[Ee]merg(?:ency)?)
```
## Écriture de classifieurs XML personnalisés
Le langage XML définit la structure d'un document avec l'utilisation de balises dans le fichier. Avec un classifieur XML personnalisé, vous pouvez spécifier le nom de la balise utilisé pour définir une ligne.
### Valeurs de classificateur personnalisées pour un classificateur XML
Lorsque vous définissez un classifieur XML, vous fournissez les valeurs suivantes à AWS Glue pour créer le classifieur. Le champ de classification du classifieur est défini sur `xml`.
**Name**
Nom du classifieur.
**Balise de ligne**
Nom de balise XML qui définit une ligne de table du document XML, sans crochets `< >`. Ce nom doit respecter les règles XML relatives aux balises.
L'élément contenant les données de ligne **ne peut pas** être un élément auto-fermant vide. Par exemple, cet élément vide n'est **pas** analysé par AWS Glue :
```
```
Les éléments vides peuvent être écrits comme suit :
```
```
AWS Glue garde trace de l'heure de création, de la dernière heure de mise à jour et de la version de votre classifieur.
Par exemple, supposons que vous disposez du fichier XML suivant. Pour créer une table AWS Glue qui contient uniquement les colonnes pour l'auteur et le titre, créez un classifieur dans la console AWS Glue avec une **balise de ligne** ayant comme valeur `AnyCompany`. Ensuite, ajoutez et exécutez un crawler qui utilise ce classifieur personnalisé.
```
Rivera, MarthaAnyCompany Developer GuideStiles, JohnStyle Guide for AnyCompany
```
## Écriture de classifieurs JSON personnalisés
JSON est un format d'échange de données. Il définit les structures de données avec des paires nom-valeur ou une liste ordonnée de valeurs. Grâce à un classifieur JSON personnalisé, vous pouvez spécifier le chemin d'accès JSON vers une structure de données utilisée pour définir le schéma de votre table.
### Valeurs de classifieur personnalisé dans AWS Glue
Lorsque vous définissez un classifieur JSON, vous fournissez les valeurs suivantes à AWS Glue pour créer le classifieur. Le champ de classification du classifieur est défini sur `json`.
**Name**
Nom du classifieur.
**Chemin JSON**
Chemin d'accès JSON qui pointe vers un objet utilisé pour définir un schéma de table. Le chemin JSON peut être écrit en notation point ou en notation crochet. Les opérateurs suivants sont pris en charge:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/custom-classifier.html)
AWS Glue garde trace de l'heure de création, de la dernière heure de mise à jour et de la version de votre classifieur.
**Example Utilisation d'un classifieur JSON pour extraire les enregistrements d'un tableau**
Supposons que vos données JSON soient un tableau d'enregistrements. Par exemple, les premières lignes de votre fichier peuvent se présenter ainsi :
```
[
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:ak",
"name": "Alaska"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:al\/cd:1",
"name": "Alabama's 1st congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:al\/cd:2",
"name": "Alabama's 2nd congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:al\/cd:3",
"name": "Alabama's 3rd congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:al\/cd:4",
"name": "Alabama's 4th congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:al\/cd:5",
"name": "Alabama's 5th congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:al\/cd:6",
"name": "Alabama's 6th congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:al\/cd:7",
"name": "Alabama's 7th congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:ar\/cd:1",
"name": "Arkansas's 1st congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:ar\/cd:2",
"name": "Arkansas's 2nd congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:ar\/cd:3",
"name": "Arkansas's 3rd congressional district"
},
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:ar\/cd:4",
"name": "Arkansas's 4th congressional district"
}
]
```
Lorsque vous exécutez un crawler à l'aide du classifieur JSON intégré, le fichier entier est utilisé pour définir le schéma. Comme vous ne spécifiez pas de chemin JSON, l'crawler traite les données comme un objet, en l'occurrence un simple tableau. Par exemple, le schéma pourrait s'apparenter à ce qui suit :
```
root
|-- record: array
```
Cependant, pour créer un schéma basé sur chaque enregistrement du tableau JSON, créez un classifieur JSON personnalisé et spécifiez le chemin JSON comme `$[*]`. Lorsque vous spécifiez ce chemin JSON, le classifieur interroge tous les 12 enregistrements du tableau pour déterminer le schéma. Le schéma obtenu contient des champs séparés pour chaque objet, comme dans l'exemple qui suit :
```
root
|-- type: string
|-- id: string
|-- name: string
```
**Example Utilisation d'un classifieur JSON pour n'examiner que certaines parties d'un fichier**
Supposons que vos données JSON suivent le modèle de l'exemple de fichier JSON `s3://awsglue-datasets/examples/us-legislators/all/areas.json` extrait de [http://everypolitician.org/](http://everypolitician.org/). Les exemples d'objets dans le fichier JSON se présentent comme suit :
```
{
"type": "constituency",
"id": "ocd-division\/country:us\/state:ak",
"name": "Alaska"
}
{
"type": "constituency",
"identifiers": [
{
"scheme": "dmoz",
"identifier": "Regional\/North_America\/United_States\/Alaska\/"
},
{
"scheme": "freebase",
"identifier": "\/m\/0hjy"
},
{
"scheme": "fips",
"identifier": "US02"
},
{
"scheme": "quora",
"identifier": "Alaska-state"
},
{
"scheme": "britannica",
"identifier": "place\/Alaska"
},
{
"scheme": "wikidata",
"identifier": "Q797"
}
],
"other_names": [
{
"lang": "en",
"note": "multilingual",
"name": "Alaska"
},
{
"lang": "fr",
"note": "multilingual",
"name": "Alaska"
},
{
"lang": "nov",
"note": "multilingual",
"name": "Alaska"
}
],
"id": "ocd-division\/country:us\/state:ak",
"name": "Alaska"
}
```
Lorsque vous exécutez un crawler à l'aide du classifieur JSON intégré, le fichier entier est utilisé pour créer le schéma. Vous pouvez vous retrouver avec un schéma tel que celui-ci :
```
root
|-- type: string
|-- id: string
|-- name: string
|-- identifiers: array
| |-- element: struct
| | |-- scheme: string
| | |-- identifier: string
|-- other_names: array
| |-- element: struct
| | |-- lang: string
| | |-- note: string
| | |-- name: string
```
Cependant, pour créer un schéma en n'utilisant que l'objet « `id` », créez un classifieur JSON personnalisé et spécifiez le chemin JSON comme `$.id`. Le schéma est donc basé uniquement sur le champ « `id` » :
```
root
|-- record: string
```
Les quelques premières lignes de données extraites avec ce schéma se présentent ainsi :
```
{"record": "ocd-division/country:us/state:ak"}
{"record": "ocd-division/country:us/state:al/cd:1"}
{"record": "ocd-division/country:us/state:al/cd:2"}
{"record": "ocd-division/country:us/state:al/cd:3"}
{"record": "ocd-division/country:us/state:al/cd:4"}
{"record": "ocd-division/country:us/state:al/cd:5"}
{"record": "ocd-division/country:us/state:al/cd:6"}
{"record": "ocd-division/country:us/state:al/cd:7"}
{"record": "ocd-division/country:us/state:ar/cd:1"}
{"record": "ocd-division/country:us/state:ar/cd:2"}
{"record": "ocd-division/country:us/state:ar/cd:3"}
{"record": "ocd-division/country:us/state:ar/cd:4"}
{"record": "ocd-division/country:us/state:as"}
{"record": "ocd-division/country:us/state:az/cd:1"}
{"record": "ocd-division/country:us/state:az/cd:2"}
{"record": "ocd-division/country:us/state:az/cd:3"}
{"record": "ocd-division/country:us/state:az/cd:4"}
{"record": "ocd-division/country:us/state:az/cd:5"}
{"record": "ocd-division/country:us/state:az/cd:6"}
{"record": "ocd-division/country:us/state:az/cd:7"}
```
Pour créer un schéma basé sur un objet profondément imbriqué, comme « `identifier` », dans le fichier JSON, vous pouvez créer un classifieur JSON personnalisé et spécifier le chemin JSON comme ainsi : `$.identifiers[*].identifier`. Bien que le schéma soit similaire à l'exemple précédent, il repose sur un autre objet du fichier JSON.
Le schéma se présente comme suit :
```
root
|-- record: string
```
L'affichage des quelques premières lignes de données de la table montre que le schéma est basé sur les données de l'objet « `identifier` » :
```
{"record": "Regional/North_America/United_States/Alaska/"}
{"record": "/m/0hjy"}
{"record": "US02"}
{"record": "5879092"}
{"record": "4001016-8"}
{"record": "destination/alaska"}
{"record": "1116270"}
{"record": "139487266"}
{"record": "n79018447"}
{"record": "01490999-8dec-4129-8254-eef6e80fadc3"}
{"record": "Alaska-state"}
{"record": "place/Alaska"}
{"record": "Q797"}
{"record": "Regional/North_America/United_States/Alabama/"}
{"record": "/m/0gyh"}
{"record": "US01"}
{"record": "4829764"}
{"record": "4084839-5"}
{"record": "161950"}
{"record": "131885589"}
```
Pour créer une table basée sur un autre objet profondément imbriqué, tel que le champ « `name` » du tableau « `other_names` » du fichier JSON, vous pouvez créer un classifieur JSON personnalisé et spécifier le chemin JSON ainsi : `$.other_names[*].name`. Bien que le schéma soit similaire à l'exemple précédent, il repose sur un autre objet du fichier JSON. Le schéma se présente comme suit :
```
root
|-- record: string
```
L'affichage des quelques premières lignes de données de la table montre qu'il est basé sur les données de l'objet « `name` » du tableau « `other_names` » :
```
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "Аляска"}
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "ألاسكا"}
{"record": "ܐܠܐܣܟܐ"}
{"record": "الاسكا"}
{"record": "Alaska"}
{"record": "Alyaska"}
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "Штат Аляска"}
{"record": "Аляска"}
{"record": "Alaska"}
{"record": "আলাস্কা"}
```
## Écriture de classifieurs CSV personnalisés
Les classifieurs CSV personnalisés vous permettent de spécifier des types de données pour chaque colonne dans le champ de classifieur CSV personnalisé. Vous pouvez spécifier le type de données de chaque colonne en les séparant par des virgules. En spécifiant les types de données, vous pouvez remplacer les types de données déduits par les Crawlers et vous assurer que les données seront classées de manière appropriée.
Vous pouvez définir le CSV SerDe pour le traitement dans le classificateur, qui sera appliqué dans le catalogue de données.
Lorsque vous créez un classifieur personnalisé, vous pouvez également le réutiliser pour différents Crawlers.
+ Les fichiers CSV contenant uniquement des en-têtes (pas de données) sont classés comme UNKNOWN (INCONNUS), car les informations fournies ne sont pas suffisantes. Si vous spécifiez « Has headings » (Comporte des en-têtes) pour le fichier CSV dans l'option *Column headings* (En-têtes de colonne) et que vous fournissez les types de données, nous pouvons classer ces fichiers correctement.
Vous pouvez utiliser un classifieur CSV personnalisé pour déduire le schéma de différents types de données CSV. Les attributs personnalisés que vous pouvez fournir à votre classificateur incluent des délimiteurs, une SerDe option CSV, des options concernant l'en-tête et l'opportunité d'effectuer certaines validations sur les données.
### Valeurs de classifieur personnalisé dans AWS Glue
Lorsque vous définissez un classifieur CSV, vous fournissez les valeurs suivantes à AWS Glue pour créer le classifieur. Le champ de classification du classifieur est défini sur `csv`.
**Nom du classifieur**
Nom du classifieur.
**SerDe CSV**
Définit le CSV SerDe pour le traitement dans le classificateur, qui sera appliqué dans le catalogue de données. Les options sont Open CSV SerDe, Lazy Simple SerDe et None. Vous pouvez spécifier la valeur None lorsque vous souhaitez que le Crawler effectue la détection.
**Délimiteur de colonne**
Symbole personnalisé pour indiquer ce qui sépare chaque entrée de colonne dans la ligne. Saisissez un caractère Unicode. Si vous ne parvenez pas à saisir votre délimiteur, vous pouvez le coller. Cela fonctionne pour les caractères imprimables, y compris ceux que votre système ne prend pas en charge (généralement affichés comme □).
**Symbole de guillemets**
Symbole personnalisé pour indiquer ce qui combine le contenu en une seule valeur de colonne. Doit être différent du délimiteur de colonne. Saisissez un caractère Unicode. Si vous ne parvenez pas à saisir votre délimiteur, vous pouvez le coller. Cela fonctionne pour les caractères imprimables, y compris ceux que votre système ne prend pas en charge (généralement affichés comme □).
**En-têtes de colonnes**
Indique le comportement à suivre pour détecter les en-têtes de colonnes dans le fichier CSV. Si votre fichier CSV personnalisé a des en-têtes de colonnes, entrez une liste séparée par des virgules de ces en-têtes de colonnes.
**Options de traitement : Autoriser les fichiers avec une seule colonne**
Active le traitement des fichiers qui ne contiennent qu'une seule colonne.
**Options de traitement : Supprimer l'espace blanc avant d'identifier les valeurs de colonne**
Spécifie s'il convient de couper les valeurs avant d'identifier le type des valeurs de colonne.
**Types de données personnalisés – *facultatif***
Saisissez le type de données personnalisé en le séparant par une virgule. Spécifie les types de données personnalisés dans le fichier CSV. Le type de données personnalisé doit être un type de données pris en charge. Les types de données pris en charge sont les suivants : « BINARY », « BOOLEAN », « DATE », « DECIMAL », « DOUBLE », « FLOAT », « INT », « LONG », « SHORT », « STRING », « TIMESTAMP ». Les types de données non pris en charge affichent une erreur.
# Création de classificateurs à l’aide de la console AWS Glue
Un classifieur détermine le schéma de vos données. Vous pouvez écrire un classificateur personnalisé et pointer dessus à partir d’ AWS Glue.
## Création de classifieurs
Pour ajouter un classifieur dans la console AWS Glue, choisissez **Add classifier** (Ajouter un classifieur). Lorsque vous définissez un classifieur, vous fournissez des valeurs pour les éléments suivants :
+ **Classifier name** (Nom du classifieur) – indiquez un nom unique pour votre classifieur.
+ **Classifier type** (Type de classifieur) – type de classification des tables déduites par ce classifieur.
+ **Last updated** (Dernière mise à jour) – heure de la dernière mise à jour de ce classifieur.
**Nom du classifieur**
Indiquez un nom unique pour votre classifieur.
**Type de classificateur**
Choisissez le type de classifieur à créer.
Selon le type de classificateur que vous choisissez, configurez les propriétés suivantes pour votre classificateur :
------
#### [ Grok ]
+ **Classement**
Décrivez le format ou le type des données classées ou fournissez une étiquette personnalisée.
+ **Modèle grok**
Cela est utilisé pour analyser vos données dans un schéma structuré. Le modèle grok est composé de modèles nommés qui décrivent le format de votre magasin de données. Vous écrivez ce modèle grok à l’aide des modèles intégrés nommés fournis par AWS Glue et des modèles personnalisés que vous avez écrits et inclus dans le champ **Modèles personnalisés**. Même si les résultats du débogueur grok peuvent ne pas correspondre exactement à ceux d’AWS Glue, nous vous suggérons d’essayer votre modèle en utilisant des exemples de données avec un débogueur grok. Vous pouvez trouver des débogueurs grok sur le Web. Les modèles intégrés nommés fournis par AWS Glue sont généralement compatibles avec les modèles grok disponibles sur le Web.
Créez votre modèle grok en ajoutant de manière itérative des modèles nommés et vérifiez vos résultats dans un débogueur. Cela permet de vous assurer que vos données peuvent être analysées lorsque l’crawler AWS Glue exécute votre modèle grok.
+ **Modèles personnalisés**
Pour les classificateurs grok, il s’agit de blocs de construction facultatifs pour le **Grok pattern** (Modèle grok) que vous écrivez. Lorsque les modèles intégrés ne peuvent pas analyser vos données, vous pouvez avoir besoin d’écrire un modèle personnalisé. Ces modèles personnalisés sont définis dans ce champ et référencés dans le champ **Grok pattern** (Modèle grok). Chaque modèle personnalisé est défini sur une ligne distincte. À l’image d’un modèle intégré, il se compose d’une définition de modèle nommé qui utilise une syntaxe d’[expression régulière (regex)](http://en.wikipedia.org/wiki/Regular_expression).
L’exemple suivant utilise le nom `MESSAGEPREFIX`, suivi d’une définition d’expression régulière à appliquer à vos données afin de déterminer si elles suivent le modèle.
```
MESSAGEPREFIX .*-.*-.*-.*-.*
```
------
#### [ XML ]
+ **Balise de ligne**
Pour les classificateurs XML, il s’agit du nom de la balise XML qui définit une ligne de table dans le document XML. Tapez le nom sans crochets `< >`. Ce nom doit respecter les règles XML relatives aux balises.
Pour de plus amples informations, veuillez consulter [Écriture de classifieurs XML personnalisés](custom-classifier.md#custom-classifier-xml).
------
#### [ JSON ]
+ **Chemin JSON**
Pour les classificateurs JSON, il s’agit du chemin d’accès JSON à l’objet, au tableau ou à la valeur qui définit une ligne de la table en cours de création. Tapez le nom en utilisant les opérateurs pris en charge par AWS Glue. Veillez à respecter la syntaxe JSON d’accolades ou de points.
Pour en savoir plus, consultez la liste des opérateurs dans [Écriture de classifieurs JSON personnalisés](custom-classifier.md#custom-classifier-json).
------
#### [ CSV ]
+ **Délimiteur de colonne**
Caractère ou symbole unique pour indiquer ce qui sépare chaque entrée de colonne dans la ligne. Choisissez le délimiteur dans la liste ou sélectionnez `Other` pour saisir un délimiteur personnalisé.
+ **Symbole de guillemets**
Caractère ou symbole unique pour indiquer ce qui combine le contenu en une seule valeur de colonne. Doit être différent du délimiteur de colonne. Choisissez le symbole de guillemet dans la liste ou sélectionnez `Other` pour saisir un caractère de guillemet personnalisé.
+ **En-têtes de colonnes**
Indique le comportement à suivre pour détecter les en-têtes de colonnes dans le fichier CSV. Vous pouvez choisir `Has headings`, `No headings` ou `Detect headings`. Si votre fichier CSV personnalisé a des en-têtes de colonnes, entrez une liste séparée par des virgules de ces en-têtes de colonnes.
+ **Autoriser les fichiers avec une seule colonne**
Pour être classé comme CSV, les données doivent avoir au moins deux colonnes et deux lignes de données. Utilisez cette option pour autoriser le traitement des fichiers qui ne contiennent qu’une seule colonne.
+ **Supprimer les espaces avant d’identifier les valeurs de colonne**
Cette option spécifie s’il convient de couper les valeurs avant d’identifier le type des valeurs de colonne.
+ **Type de données personnalisé**
(Facultatif) – Saisissez des types de données personnalisés dans une liste délimitée par des virgules. Les types de données pris en charge sont les suivants : « BINARY », « BOOLEAN », « DATE », « DECIMAL », « DOUBLE », « FLOAT », « INT », « LONG », « SHORT », « STRING », « TIMESTAMP ».
+ **SerDe CSV**
(Facultatif) - A SerDe pour le traitement du CSV dans le classificateur, qui sera appliqué dans le catalogue de données. Choisissez `Open CSV SerDe`, `Lazy Simple SerDe` ou `None`. Vous pouvez spécifier la valeur `None` lorsque vous souhaitez que le Crawler effectue la détection.
------
Pour de plus amples informations, veuillez consulter [Rédaction de classificateurs personnalisés pour divers formats de données](custom-classifier.md).
## Affichage des classifieurs
Pour afficher la liste de tous les classifieurs que vous avez créés, ouvrez la console AWS Glue à l'adresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/) et choisissez l'onglet **Classifieurs**.
La liste affiche les propriétés suivantes sur chaque classifieur :
+ **Classifier** (Classifieurs) – nom du classifieur. Lorsque vous créez un classifieur, vous devez indiquer un nom pour celui-ci.
+ **Classification** – type de classification des tables déduites par ce classifieur.
+ **Last updated** (Dernière mise à jour) – heure de la dernière mise à jour de ce classifieur.
## Gestion des classifieurs
À partir de la liste **Classifieurs** de la console AWS Glue, vous pouvez ajouter, modifier ou supprimer des classifieurs. Pour afficher plus de détails sur un classifieur, choisissez le nom du classifieur dans la liste. Les détails incluent les informations que vous avez définies lors de la création du classifieur.
# Configuration d’un robot
Un robot accède à votre entrepôt de données, identifie des métadonnées et crée des définitions de table dans l’ AWS Glue Data Catalog. Le volet **Crawlers** de la AWS Glue console répertorie tous les robots d'exploration que vous créez. La liste affiche le statut et les métriques de la dernière exécution de votre crawler.
Cette rubrique décrit le step-by-step processus de configuration d'un robot d'exploration, en abordant des aspects essentiels tels que la configuration des paramètres du robot, la définition des sources de données à explorer, le paramétrage de la sécurité et la gestion des données analysées.
**Topics**
+ [Étape 1 : Configurer les propriétés du crawler](define-crawler-set-crawler-properties.md)
+ [Étape 2 : Choisir des sources de données et des classificateurs.](define-crawler-choose-data-sources.md)
+ [Étape 3 : Configurer les paramètres de sécurité](define-crawler-configure-security-settings.md)
+ [Étape 4 : Configurer la sortie et la planification](define-crawler-set-output-and-scheduling.md)
+ [Étape 5 : vérification et création](define-crawler-review.md)
# Étape 1 : Configurer les propriétés du crawler
**Pour configurer un robot**
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\). Sélectionnez **Crawlers** dans le panneau de navigation.
1. Cliquez sur **Créer un Crawler**, puis suivez les instructions de l'assistant **Ajouter un Crawler**. L’assistant vous guidera à travers les étapes nécessaires à la création d’un robot. Si vous souhaitez ajouter des classifieurs personnalisés pour définir le schéma, consultez [Définition et gestion des classificateurs](add-classifier.md).
1. Saisissez un nom pour votre Crawler et une description (facultatif). Le cas échéant, vous pouvez baliser votre crawler avec une **clé de balise** et avec une **valeur de balise** facultative. Une fois créées, les clés de balise sont en lecture seule. Utilisez des identifications sur certaines ressources pour mieux les organiser et les identifier. Pour plus d'informations, consultez la section AWS tags in AWS Glue.
**Name**
Le nom peut contenir des lettres (A à Z), des chiffres (0 à 9), des tirets (-) ou des traits de soulignement (\$1) et jusqu'à 255 caractères.
**Description**
Les descriptions peuvent comporter jusqu'à 2 048 caractères.
**Étiquettes**
Utilisez des balises pour identifier et organiser vos ressources. Pour plus d’informations, consultez les ressources suivantes :
+ [AWS tags dans AWS Glue](monitor-tags.md)
# Étape 2 : Choisir des sources de données et des classificateurs.
Configurez ensuite les sources de données et les classificateurs pour le robot.
Pour plus d’informations sur les sources de données prises en charge, consultez [Sources de données prises en charge pour l’indexation de site web](crawler-data-stores.md).
**Configuration de source de données**
Sélectionnez l’option appropriée pour **Vos données sont-elles déjà mappées à des tables AWS Glue ?** et choisissez « Pas encore » ou « Oui ». Par défaut, Pas encore est déjà sélectionné.
L'crawler peut accéder aux magasins de données directement en tant que source de l'analyse, ou il peut utiliser des tables de Data Catalog existantes en tant que source. Si l'crawler utilise des tables de catalogue existantes, il analyse les magasins de données qui sont spécifiés par ces tables de catalogue.
+ Pas encore : Sélectionnez une ou plusieurs sources de données à analyser. Un crawler peut analyser plusieurs magasins de données de différents types (Amazon S3, JDBC, etc.).
Vous ne pouvez configurer qu'un seul magasin de données à la fois. Après avoir fourni les informations de connexion et inclus les chemins et les modèles d'exclusion, vous avez alors la possibilité d'ajouter un autre magasin de données.
+ Oui : Sélectionnez les tables existantes dans votre catalogue de données AWS Glue. Les tables de catalogue spécifient les magasins de données à analyser. L'crawler peut uniquement analyser des tables de catalogue en une seule exécution ; il ne peut pas combiner dans d'autres types de source.
Généralement, pour spécifier une table de catalogue en tant que source, c'est que vous avez créé la table manuellement (parce que vous connaissiez déjà la structure du magasin de données) et vous voulez qu'un crawler garde la table à jour, y compris ajouter de nouvelles partitions. Pour une discussion sur d'autres raisons, consultez [Mise à jour de tables Data Catalog créées manuellement à l’aide d’crawlers](tables-described.md#update-manual-tables).
Lorsque vous spécifiez des tables existantes en tant que type source d'crawler, les conditions suivantes s'appliquent :
+ Le nom de la base de données est facultatif.
+ Seules les tables de catalogue qui spécifient les entrepôts de données Amazon S3, Amazon DynamoDB ou Delta Lake sont autorisées.
+ Aucune nouvelle table de catalogue n'est créée lorsque l'crawler s'exécute. Les tables sont mises à jour selon les besoins, y compris en ajoutant de nouvelles partitions.
+ Les objets supprimés trouvés dans les magasins de données sont ignorés ; aucune table de catalogue n'est supprimée. Au lieu de cela, l'crawler rédige un message de journal. (`SchemaChangePolicy.DeleteBehavior=LOG`)
+ L'option de configuration de l'crawler pour créer un seul schéma pour chaque chemin Amazon S3 est activée par défaut et ne peut pas être désactivée. (`TableGroupingPolicy`=`CombineCompatibleSchemas`) Pour plus d'informations, consultez [Création d’un schéma unique pour chaque chemin d’inclusion Amazon S3](crawler-grouping-policy.md).
+ Vous ne pouvez pas combiner des tables de catalogue en tant que source avec d'autres types de source (par exemple, Amazon S3 ou Amazon DynamoDB).
Pour utiliser les tables Delta, créez d'abord une table Delta à l'aide d'Athena DDL ou de l'API. AWS Glue
À l’aide d’Athena, définissez l’emplacement de votre dossier Amazon S3 et le type de table sur « DELTA ».
```
CREATE EXTERNAL TABLE database_name.table_name
LOCATION 's3://bucket/folder/'
TBLPROPERTIES ('table_type' = 'DELTA')
```
À l'aide de l' AWS Glue API, spécifiez le type de table dans la carte des paramètres de table. Les paramètres de la table doivent inclure la key/value paire suivante. Pour plus d’informations sur la création d’une table, consultez la [documentation Boto3 pour create\$1table](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/glue/client/create_table.html).
```
{
"table_type":"delta"
}
```
**Sources de données**
Sélectionnez ou ajoutez la liste des sources de données à analyser par le crawler.
(Facultatif) Si vous choisissez JDBC comme source de données, vous pouvez utiliser vos propres pilotes JDBC lorsque vous spécifiez l'accès à la connexion où les informations du pilote sont stockées.
**Chemin à inclure**
Lors de l'évaluation des éléments à inclure ou exclure dans une analyse, un crawler commence par évaluer le chemin d'inclusion requis. Pour les magasins de données Amazon S3, MongoDB, MongoDB Atlas, Amazon DocumentDB (compatible avec MongoDB) et les magasins de données relationnelles, vous devez spécifier un chemin d'inclusion.
Pour un magasin de données Amazon S3
Déterminez si vous souhaitez spécifier un chemin dans ce compte ou dans un autre compte, puis parcourez les chemins Amazon S3 pour en choisir un.
Pour les magasins de données Amazon S3, la syntaxe de chemin d'accès inclut est `bucket-name/folder-name/file-name.ext`. Pour analyser tous les objets d'un compartiment, spécifiez juste le nom du compartiment dans le chemin d'inclusion. Le modèle d'exclusion est relatif au chemin d'inclusion
Pour un magasin de données Delta Lake
Spécifiez un ou plusieurs chemins Amazon S3 vers les tables Delta sous la forme s3 ://*bucket*/*prefix*/*object*.
Pour un magasin de données Iceberg ou Hudi
Spécifiez un ou plusieurs chemins Amazon S3 contenant des dossiers contenant des métadonnées de table Iceberg ou Hudi sous la forme s3 :///*bucket*. *prefix*
Pour les banques de données Iceberg et Hudi, le Iceberg/Hudi dossier peut se trouver dans un dossier enfant du dossier racine. Le Crawler examine tous les dossiers situés sous un chemin à la recherche d'un dossier Hudi.
Pour un magasin de données JDBC
Entrez**/**/*
*ou**/*
*, selon le produit de base de données. Oracle Database et MySQL ne prennent pas en charge le schéma dans le chemin. Vous pouvez remplacer le pourcentage (%) par ** ou*
*. Par exemple, pour une base de données Oracle avec l'identificateur système (SID) `orcl`, entrez `orcl/%` pour importer toutes les tables auxquelles l'utilisateur nommé dans la connexion a accès.
Ce champ est sensible à la casse.
Si vous choisissez d'utiliser vos propres versions de pilotes JDBC, les Crawlers AWS Glue consommeront des ressources dans les tâches AWS Glue et les compartiments Amazon S3 pour s'assurer que les pilotes que vous avez fournis sont exécutés dans votre environnement. L'utilisation supplémentaire des ressources sera reflétée sur votre compte. Les pilotes sont limités aux propriétés décrites dans [Adding an AWS Glue connection](https://docs.aws.amazon.com/glue/latest/dg/console-connections.html).
Pour un magasin de données MongoDB, MongoDB Atlas ou Amazon DocumentDB
Pour MongoDB, MongoDB Atlas et Amazon DocumentDB (compatible avec MongoDB), la syntaxe est `database/collection`.
Pour les magasins de données JDBC, la syntaxe est `database-name/schema-name/table-name` ou `database-name/table-name`. La syntaxe varie selon que le moteur de base de données prend en charge ou pas les schémas dans une base de données. Par exemple, pour les moteurs de base de données tels que MySQL ou Oracle, ne spécifiez pas `schema-name` dans votre chemin d'inclusion. Vous pouvez remplacer le signe pourcentage (`%`) d'un schéma ou d'une table dans le chemin d'inclusion pour représenter tous les schémas ou toutes les tables d'une base de données. Vous ne pouvez pas remplacer le signe pourcentage (`%`) pour la base de données dans le chemin d'inclusion.
**Profondeur maximale d'indexation (pour les magasins de données Iceberg ou Hudi uniquement)**
Définit la profondeur maximale du chemin Amazon S3 que le Crawler peut parcourir pour découvrir le dossier de métadonnées Iceberg ou Hudi dans votre chemin Amazon S3. L'objectif de ce paramètre est de limiter la durée d'exécution du Crawler. La valeur par défaut est 10 et la valeur maximale est 20.
**Modèles d'exclusion**
Ils vous permettent d'exclure certains fichiers ou tables de l'analyse. Le chemin à exclure est relatif par rapport au chemin à inclure. Par exemple, pour exclure une table de votre magasin de données JDBC, tapez le nom de la table dans le chemin d'exclusion.
Un crawler se connecte à un magasin de données JDBC à l'aide d'une connexion AWS Glue qui contient une chaîne de connexion d'URI JDBC. L'crawler a uniquement accès aux objets du moteur de base de données à l'aide du nom d'utilisateur et du mot de passe JDBC de la connexion AWS Glue. *L'crawler peut uniquement créer des tables auxquelles il peut accéder via la connexion JDBC.* Une fois que l'crawler a accédé au moteur de base de données avec l'URI JDBC, le chemin d'inclusion est utilisé pour déterminer quelles tables du moteur de base de données sont créées dans Data Catalog. Par exemple, avec MySQL, si vous spécifiez un chemin d'inclusion `MyDatabase/%`, toutes les tables de `MyDatabase` sont créées dans Data Catalog. Lors de l'accès à Amazon Redshift, si vous spécifiez un chemin d'inclusion `MyDatabase/%`, toutes les tables de tous les schémas de la base de données `MyDatabase` sont créées dans Data Catalog. Si vous spécifiez un chemin d'inclusion `MyDatabase/MySchema/%`, toutes les tables de la base de données `MyDatabase` et du schéma `MySchema` sont créées.
Après que vous avez spécifié un chemin d'inclusion, vous pouvez exclure les objets de l'analyse qui sinon seraient inclus dans votre chemin d'inclusion en spécifiant un ou plusieurs modèles d'exclusion `glob` de style Unix. Ces modèles sont appliqués à votre chemin d'inclusion afin de déterminer les objets exclus. Ces modèles sont également stockés en tant que propriété des tables créées par le robot d'exploration. AWS Glue PySpark les extensions, telles que`create_dynamic_frame.from_catalog`, lisent les propriétés de la table et excluent les objets définis par le modèle d'exclusion.
AWS Glue prend en charge les modèles `glob` suivants dans les modèles d’exclusion.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/define-crawler-choose-data-sources.html)
AWS Glue interprète les modèles d'exclusion `glob` comme suit :
+ La barre oblique (`/`) est le délimiteur qui permet de séparer les clés Amazon S3 dans une hiérarchie de dossiers.
+ L'astérisque (`*`) correspond à zéro ou plusieurs caractères d'un composant de nom sans dépasser les limites d'un dossier.
+ Deux astérisques (`**`) correspondent à zéro ou plusieurs caractères dépassant les limites d'un dossier ou d'un schéma.
+ Le point d'interrogation (`?`) correspond exactement à un caractère d'un composant de nom.
+ La barre oblique inverse (`\`) est utilisée pour échapper des caractères qui seraient sinon interprétés comme des caractères spéciaux. L'expression `\\` correspond à une barre oblique inverse, et `\{` correspond à une accolade gauche.
+ Les crochets `[ ]` créent une expression entre crochets qui correspond à un caractère unique d'un composant de nom dans un ensemble de caractères. Par exemple, `[abc]` correspond à `a`, `b` ou `c`. Le trait d'union (`-`) peut être utilisé pour spécifier une plage ; `[a-z]` spécifie une plage allant de `a` à `z` (inclus). Ces formulaires peuvent être mélangés ; [`abce-g`] correspond à `a`, `b`, `c`, `e`, `f` ou `g`. Si le caractère placé après le crochet (`[`) est un point d'exclamation (`!`), l'expression entre crochets est inversée. Par exemple, `[!a-c]` correspond à un caractère quelconque, à l'exception de `a`, `b` ou `c`.
Dans une expression entre crochets, les caractères `*`, `?` et `\` correspondent à eux-mêmes. Le trait d'union (`-`) correspond à lui-même lorsqu'il est placé en première position entre les crochets, ou s'il est le premier caractère placé après le point d'exclamation `!` lors d'une inversion.
+ Les accolades (`{ }`) entourent un groupe de sous-modèles, où le groupe correspond si un des sous-modèles du groupe correspond. La virgule (`,`) est utilisée pour séparer les sous-modèles. Les groupes ne peuvent pas être imbriqués.
+ Une virgule ou un point placé au début d'un nom de fichier est traité comme un caractère normal dans les opérations de correspondance. Par exemple, le modèle d'exclusion `*` correspond au nom de fichier `.hidden`.
**Example Modèles d'exclusion Amazon S3**
Chaque modèle d'exclusion est évalué par rapport au chemin d'inclusion. Par exemple, supposons que vous disposiez de la structure de répertoires Amazon S3 suivante :
```
/mybucket/myfolder/
departments/
finance.json
market-us.json
market-emea.json
market-ap.json
employees/
hr.json
john.csv
jane.csv
juan.txt
```
Soit le chemin d'inclusion `s3://mybucket/myfolder/`, voici quelques exemples de résultats pou les chemins d'exclusion :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/define-crawler-choose-data-sources.html)
**Example Exclusion d'un sous-ensemble de partitions Amazon S3**
Supposons que vos données soient partitionnées par jour, de telle sorte que chaque jour d'une année se trouve dans une partition Amazon S3 distincte. Pour le mois de janvier 2015, il y a 31 partitions. Maintenant, pour analyser uniquement les données de la première semaine de janvier, vous devez exclure toutes les partitions, à l'exception des jours 1 à 7 :
```
2015/01/{[!0],0[8-9]}**, 2015/0[2-9]/**, 2015/1[0-2]/**
```
Examinons les différentes parties de ce modèle glob. La première partie, ` 2015/01/{[!0],0[8-9]}**`, exclut tous les jours qui ne commencent pas par un « 0 », ainsi que le jour 08 et le jour 09 du mois 01 de l'année 2015. Notez que « \$1\$1 » est utilisé comme suffixe du modèle de numéro du jour et dépasse les limites de dossier vers les dossiers de niveau inférieur. Si « \$1 » est utilisé, les dossiers de niveau inférieur ne sont pas exclus.
La deuxième partie, ` 2015/0[2-9]/**`, exclut les jours des mois 02 à 09 de l'année 2015.
La troisième partie, `2015/1[0-2]/**`, exclut les jours des mois 10, 11 et 12 de l'année 2015.
**Example Modèles d'exclusion JDBC**
Supposons que vous analysiez une base de données JDBC avec la structure de schéma suivante :
```
MyDatabase/MySchema/
HR_us
HR_fr
Employees_Table
Finance
Market_US_Table
Market_EMEA_Table
Market_AP_Table
```
Soit le chemin d'inclusion `MyDatabase/MySchema/%`, voici quelques exemples de résultats pou les chemins d'exclusion :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/define-crawler-choose-data-sources.html)
**Paramètres de source d'crawler supplémentaires**
Chaque type de source requiert un jeu différent de paramètres supplémentaires.
**Connexion**
Sélectionnez ou ajoutez une connexion AWS Glue. Pour obtenir des informations sur les connexions, consultez [Connexion aux données](glue-connections.md).
**Métadonnées supplémentaires : facultatives (pour les magasins de données JDBC)**
Sélectionnez des propriétés de métadonnées supplémentaires à analyser par le crawler.
+ Commentaires : analysez des commentaires associés au niveau de la table et au niveau de la colonne.
+ Types bruts : conservez les types de données bruts des colonnes de la table dans les métadonnées supplémentaires. Par défaut, le crawler traduit les types de données bruts en types compatibles avec Hive.
**Nom de la classe de pilote JDBC – facultatif (pour les magasins de données JDBC)**
Saisissez un nom de classe de pilote JDBC personnalisé pour que le Crawler se connecte à la source de données :
+ Postgres : org.postgresql.Driver
+ MySQL : com.mysql.jdbc.Driver, com.mysql.cj.jdbc.Driver
+ Redshift : com.amazon.redshift.jdbc.Driver, com.amazon.redshift.jdbc42.Driver
+ Oracle : oracle.jdbc.driver. OracleDriver
+ Serveur SQL : com.microsoft.sqlserver.jdbc. SQLServerChauffeur
**Chemin S3 du pilote JDBC – facultatif (pour les magasins de données JDBC)**
Choisissez un chemin Amazon S3 existant vers un fichier `.jar`. C'est là que le fichier `.jar` est stocké lorsque vous utilisez un pilote JDBC personnalisé pour que le Crawler se connecte à la source de données.
**Activer l'échantillonnage de données (pour les magasins de données Amazon DynamoDB, MongoDB, MongoDB Atlas et Amazon DocumentDB uniquement)**
Indiquez si vous souhaitez analyser un échantillon de données uniquement. Si ce n'est pas sélectionné, la table entière est analysée. L'analyse de tous les enregistrements peut prendre beaucoup de temps lorsque la table n'est pas à haut débit.
**Créer des tables pour les requêtes (uniquement pour les magasins de données Delta Lake)**
Sélectionnez la façon dont vous souhaitez créer les tables Delta Lake :
+ Créer des tables natives : permettre l'intégration avec les moteurs de requêtes qui prennent directement en charge l'interrogation du journal de transactions Delta.
+ Créer des tables avec des liens symboliques : créer un dossier manifeste de lien symbolique avec les fichiers manifestes partitionnés par les clés de partition, en fonction des paramètres de configuration spécifiés.
**Taux d'analyse : facultatif (pour les magasins de données DynamoDB uniquement)**
Spécifiez le pourcentage des unités de capacité de lecture de la table DynamoDB à utiliser par le crawler. Unités de capacité de lecture est un terme défini par DynamoDB et est une valeur numérique qui sert de limiteur de vitesse pour le nombre de lectures pouvant être effectuées sur cette table par seconde. Saisissez une valeur comprise entre 0,1 et 1.5^63 - 1. Si ce n’est pas spécifié, la valeur par défaut est de 0,5 pour les tables provisionnées et de 1/4 de la capacité configurée maximale pour les tables à la demande. Notez que seul le mode de capacité provisionnée doit être utilisé avec les AWS Glue robots d'exploration.
Pour les magasins de données DynamoDB, définissez le mode de capacité provisionnée pour traiter les lectures et écritures dans vos tables. Le AWS Glue robot ne doit pas être utilisé avec le mode de capacité à la demande.
**Connexion réseau : facultatif (pour les entrepôts de données cibles Amazon S3, Delta, Iceberg, Hudi et Catalog)**
Vous pouvez également inclure une connexion réseau à utiliser avec cette cible Amazon S3. Notez que chaque crawler est limité à une connexion réseau et toutes les autres cibles Amazon S3 utilisent la même connexion (ou aucune, si ce champ est laissé vide).
Pour obtenir des informations sur les connexions, consultez [Connexion aux données](glue-connections.md).
**Échantillon portant sur un seul sous-ensemble de fichiers et taille de l'échantillon (pour les magasins de données Amazon S3 uniquement)**
Spécifiez le nombre de fichiers dans chaque dossier feuille à analyser lors de l'analyse d'échantillons de fichiers dans un jeu de données. Lorsque cette fonction est activée, au lieu d'analyser tous les fichiers de ce jeu de données, l'crawler sélectionne au hasard certains fichiers dans chaque dossier feuille à analyser.
Le crawler d'échantillonnage est le mieux adapté aux clients qui ont des connaissances préalables sur leurs formats de données et savent que les schémas de leurs dossiers ne changent pas. L'activation de cette fonction réduira considérablement le temps d'exécution de l'crawler.
Une valeur valide est un entier compris entre 1 et 249. Si ce n'est pas spécifié, tous les fichiers sont analysés.
**Exécutions ultérieures du crawler**
Ce champ est un champ global qui concerne toutes les sources de données Amazon S3.
+ Analyser tous les sous-dossiers : analyser à nouveau tous les dossiers à chaque analyse suivante.
+ Analyser uniquement les nouveaux sous-dossiers : seuls les dossiers Amazon S3 ajoutés depuis la dernière analyse sont analysés. Si les schémas sont compatibles, de nouvelles partitions sont ajoutées aux tables existantes. Pour plus d'informations, consultez [Planification d’analyses incrémentielles pour ajouter de nouvelles partitions.](incremental-crawls.md).
+ Analyse basée sur les événements : utiliser les événements Amazon S3 pour contrôler les dossiers à analyser. Pour de plus amples informations, veuillez consulter [Accélération des analyseurs à l’aide des notifications d’événements Amazon S3](crawler-s3-event-notifications.md).
**Classifieurs personnalisés - facultatif**
Définissez des classifieurs personnalisés avant de définir des crawlers. Un classifieur vérifie si un fichier donné est dans un format que le crawler peut gérer. Si c'est le cas, le classifieur crée un schéma sous la forme d'un objet `StructType` correspondant à ce format de données.
Pour de plus amples informations, veuillez consulter [Définition et gestion des classificateurs](add-classifier.md).
# Étape 3 : Configurer les paramètres de sécurité
**Rôle IAM**
L'crawler endosse ce rôle. Il doit disposer d'autorisations similaires à celles de la politique AWS gérée`AWSGlueServiceRole`. Pour les sources Amazon S3 et DynamoDB, il doit également disposer des autorisations pour accéder au magasin de données. Si le robot lit les données Amazon S3 chiffrées avec AWS Key Management Service (AWS KMS), le rôle doit disposer d'autorisations de déchiffrement sur la AWS KMS clé.
Pour un magasin de données Amazon S3, les autorisations supplémentaires attachées au rôle seraient similaires à ce qui suit :
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::bucket/object*"
]
}
]
}
```
Pour un magasin de données Amazon DynamoDB, les autorisations supplémentaires attachées au rôle seraient similaires à ce qui suit :
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:DescribeTable",
"dynamodb:Scan"
],
"Resource": [
"arn:aws:dynamodb:*:111122223333:table/table-name*"
]
}
]
}
```
Pour ajouter votre propre pilote JDBC, des autorisations supplémentaires doivent être ajoutées.
+ Accordez des autorisations pour les actions de tâches suivantes : `CreateJob`, `DeleteJob`, `GetJob`, `GetJobRun`, `StartJobRun`.
+ Accordez des autorisations pour les actions Amazon S3 : `s3:DeleteObjects`, `s3:GetObject`, `s3:ListBucket`, `s3:PutObject`.
**Note**
Le `s3:ListBucket` n'est pas nécessaire si la stratégie de compartiment Amazon S3 est désactivée.
+ Accordez l'accès principal au service bucket/folder dans la politique Amazon S3.
Exemple de stratégie Amazon S3 :
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:ListBucket",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/driver-parent-folder/driver.jar",
"arn:aws:s3:::amzn-s3-demo-bucket"
]
}
]
}
```
AWS Glue crée les dossiers suivants (`_crawler` et `_glue_job_crawler` au même niveau que le pilote JDBC) dans votre compartiment Amazon S3. Par exemple, si le chemin du pilote est ``, les dossiers suivants seront créés s'ils n'existent pas déjà :
+
+
Le cas échéant, vous pouvez ajouter une configuration de sécurité à un crawler pour spécifier les options de chiffrement au repos.
Pour plus d’informations, consultez [Étape 2 : créer un rôle IAM pour AWS Glue](create-an-iam-role.md) et [Gestion des identités et des accès pour AWS Glue](security-iam.md).
**Configuration de Lake Formation - Facultatif**
Autorisez le crawler à utiliser les informations d'identification de Lake Formation pour analyser la source de données.
Si vous cochez la case **Utiliser les informations d'identification Lake Formation pour analyser la source de données S3**, le crawler peut utiliser les informations d'identification Lake Formation pour analyser la source de données. Si la source de données appartient à un autre compte, vous devez fournir l'ID de compte enregistré. À défaut, le crawler n'analysera que les sources de données associées au compte. Applicable uniquement aux sources de données Amazon S3 et Data Catalog.
**Configuration de sécurité - Facultatif**
Les paramètres incluent les configurations de sécurité. Pour plus d’informations, consultez les ressources suivantes :
+ [Chiffrement des données écrites par AWS Glue](encryption-security-configuration.md)
Une fois qu’une configuration de sécurité a été définie sur un robot, vous pouvez la modifier, mais vous ne pouvez pas la supprimer. Pour réduire le niveau de sécurité d’un robot, définissez explicitement la fonctionnalité de sécurité sur `DISABLED` dans votre configuration ou créez un robot.
# Étape 4 : Configurer la sortie et la planification
**Configuration de la sortie**
Les options incluent la façon dont l'crawler doit gérer des modifications de schéma, les objets supprimés détectés dans le magasin de données, et plus encore. Pour de plus amples informations, consultez [Personnalisation du comportement d’un robot](crawler-configuration.md).
**Planificateur d'crawler**
Vous pouvez exécuter un crawler à la demande ou définir une planification temporelle pour vos crawlers et vos tâches dans AWS Glue. La définition de ces planifications utilise la syntaxe de type Unix cron. Pour de plus amples informations, veuillez consulter [Planification d'un crawler](schedule-crawler.md).
# Étape 5 : vérification et création
Passez en revue les paramètres du crawler que vous avez configurés et créez le crawler.
# Planification d'un crawler
Vous pouvez exécuter un crawler AWS Glue à la demande ou selon une planification régulière. Lorsque vous configurez un robot basé sur une planification, vous pouvez spécifier certaines contraintes, telles que la fréquence, les jours de la semaine et l’heure d’exécution du robot. Vous pouvez créer ces planifications personnalisées au format *cron*. Pour plus d'informations, consultez [cron](http://en.wikipedia.org/wiki/Cron) dans Wikipedia.
Lorsque vous configurez une planification d'crawler, prenez en compte les fonctions et limitations de cron. Par exemple, si vous choisissez d'exécuter votre crawler le 31 de chaque mois, n'oubliez pas que certains mois ne comportent pas 31 jours.
**Topics**
+ [Créer un calendrier du robot](create-crawler-schedule.md)
+ [Création d’un calendrier pour un robot existant](Update-crawler-schedule.md)
# Créer un calendrier du robot
Vous pouvez créer un calendrier pour le robot d'exploration à l'aide de la AWS Glue console ou AWS CLI.
------
#### [ AWS Management Console ]
1. Connectez-vous à et ouvrez AWS Management Console la AWS Glue console à l'adresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue\).
1. Sélectionnez **Crawlers** dans le panneau de navigation.
1. Suivez les étapes 1 à 3 dans la section [Configuration d’un robot](define-crawler.md).
1. Dans [Étape 4 : Configurer la sortie et la planification](define-crawler-set-output-and-scheduling.md), choisissez un **Calendrier du robot** pour définir la fréquence de l’exécution. Vous pouvez faire en sorte que le robot soit exécuté toutes les heures, tous les jours, toutes les semaines, tous les mois ou définir un calendrier personnalisé à l’aide d’expressions cron.
Une expression cron est une chaîne représentant un modèle de planification, composée de six champs séparés par des espaces : \$1 \$1 \$1 \$1 \$1
Par exemple, pour exécuter une tâche tous les jours à minuit, l’expression cron est : 0 0 \$1 \$1 ? \$1
Pour plus d’informations, consultez [Expressions Cron](https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html#CronExpressions).
1. Passez en revue les paramètres du robot que vous avez configurés et créez le robot pour qu’il s’exécute selon un calendrier.
------
#### [ AWS CLI ]
```
aws glue create-crawler
--name myCrawler \
--role AWSGlueServiceRole-myCrawler \
--targets '{"S3Targets":[{Path="s3://amzn-s3-demo-bucket/"}]}' \
--schedule cron(15 12 * * ? *)
```
------
Pour plus d’informations sur l’utilisation de cron pour planifier les tâches et les crawlers, reportez-vous à la section [Planifications temporelles pour les tâches et les crawlers](monitor-data-warehouse-schedule.md).
# Création d’un calendrier pour un robot existant
Procédez comme suit pour configurer un calendrier récurrent pour un robot existant.
------
#### [ AWS Management 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. Sélectionnez **Crawlers** dans le panneau de navigation.
1. Choisissez un robot que vous souhaitez planifier dans la liste disponible.
1. Dans le menu **Actions**, choisissez **Modifier**.
1. Faites défiler la page jusqu’à **Step 4: Set output and scheduling**, puis choisissez **Modifier**.
1. Mettez à jour le calendrier de votre robot sous le **Calendrier du robot**.
1. Choisissez **Mettre à jour**.
------
#### [ AWS CLI ]
Utilisez la commande de CLI suivante pour mettre à jour une configuration de robot existante.
```
aws glue update-crawler-schedule
--crawler-name myCrawler
--schedule cron(15 12 * * ? *)
```
------
# Affichage des résultats et des détails du crawler
Une fois que l’crawler s’exécute correctement, il crée des définitions de table dans Data Catalog. Sélectionnez **Tables** dans le panneau de navigation pour afficher les tables créées par votre crawler dans la base de données que vous avez spécifiée.
Vous pouvez afficher les informations relatives à l’crawler lui-même comme suit :
+ La page **Crawlers** de la AWS Glue console affiche les propriétés suivantes d'un robot d'exploration :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/console-crawlers-details.html)
+ Pour afficher l’historique d’un crawler, choisissez **Crawlers** dans le panneau de navigation pour voir les crawlers que vous avez créés. Choisissez un crawler dans la liste des crawlers disponibles. Vous pouvez consulter les propriétés du crawler et consulter l’historique du crawler dans l’onglet **Crawler runs** (Exécutions du crawler).
L’onglet Crawler s’exécute affiche des informations sur chaque exécution du crawler, notamment l’**heure de début (UTC),** l’**heure de fin (UTC)**, la **durée**, l’**état**, les **heures DPU**, et les **modifications apportées aux tables**.
L’onglet Exécutions du Crawler affiche uniquement les analyses qui ont eu lieu depuis la date de lancement de la fonction d’historique du Crawler et ne retient que jusqu’à 12 mois d’analyse. Les anciennes analyses ne seront pas renvoyées.
+ Pour voir des informations supplémentaires, choisissez un onglet sur la page de détails du crawler. Chaque onglet affiche les informations relatives au crawler.
+ **Schedule** (Programme) : tous les programmes créés pour le crawler seront visibles ici.
+ **Data sources** (Sources de données) : toutes les sources de données analysées par le crawler seront visibles ici.
+ **Classifiers** (Classifieurs) : tous les classifieurs assignés au crawler seront visibles ici.
+ **Balises** : toutes les balises créées et attribuées à une AWS ressource seront visibles ici.
# Paramètres définis sur les tables du Catalogue de données par un Crawler
Ces propriétés de table sont définies par les AWS Glue robots d'exploration. Nous nous attendons à ce que les utilisateurs consomment les propriétés `classification` et `compressionType`. D'autres propriétés, dont les estimations de la taille des tables, sont utilisées pour les calculs internes, et nous ne garantissons pas leur exactitude ou leur applicabilité aux cas d'utilisation des clients. La modification de ces paramètres peut modifier le comportement du Crawler. Nous ne prenons pas en charge ce flux.
| Clé de propriété | Valeur de la propriété |
| --- | --- |
| UPDATED\$1BY\$1CRAWLER | Nom du Crawler qui effectue la mise à jour. |
| connectionName | Nom de la connexion dans le catalogue de données pour le crawler utilisé pour se connecter au magasin de données. |
| recordCount | Estimation du nombre d'enregistrements dans la table, basée sur la taille des fichiers et des en-têtes. |
| skip.header.line.count | Lignes ignorées pour ignorer l'en-tête. Définie sur des tables classées au format CSV. |
| CrawlerSchemaSerializerVersion | Pour utilisation interne |
| classification | Format des données, déduit par le Crawler. Pour plus d'informations sur les formats de données pris en charge par les AWS Glue robots d'exploration, consultez[Classifieurs intégrés](add-classifier.md#classifier-built-in). |
| CrawlerSchemaDeserializerVersion | Pour utilisation interne |
| sizeKey | Taille combinée des fichiers dans la table indexée. |
| averageRecordSize | Taille moyenne des lignes dans la table, en octets. |
| compressionType | Type de compression utilisé sur les données de la table. Pour plus d'informations sur les types de compression pris en charge par les AWS Glue robots d'exploration, consultez[Classifieurs intégrés](add-classifier.md#classifier-built-in). |
| typeOfData | `file`, `table` ou `view`. |
| objectCount | Nombre d'objets sous le chemin Amazon S3 pour la table. |
Ces propriétés de table supplémentaires sont définies par les robots d' AWS Glue exploration pour les magasins de données Snowflake.
| Clé de propriété | Valeur de la propriété |
| --- | --- |
| aws:RawTableLastAltered | Enregistre le dernier horodatage modifié de la table Snowflake. |
| ViewOriginalText | Affichez l'Instruction SQL. |
| ViewExpandedText | Affichez l'instruction SQL codée au format Base64. |
| ExternalTable:S3Location | Emplacement Amazon S3 de la table externe Snowflake. |
| ExternalTable:FileFormat | Format de fichier Amazon S3 de la table externe Snowflake. |
Ces propriétés de table supplémentaires sont définies par des robots d' AWS Glue exploration pour les magasins de données de type JDBC tels qu'Amazon Redshift, Microsoft SQL Server, MySQL, PostgreSQL et Oracle.
| Clé de propriété | Valeur de la propriété |
| --- | --- |
| aws:RawType | Lorsqu'un crawler stocke les données dans le catalogue de données, il traduit les types de données en types compatibles avec Hive, ce qui entraîne souvent la perte des informations relatives au type de données natif. Le crawler génère le paramètre `aws:RawType` pour fournir le type de données de niveau natif. |
| aws:RawColumnComment | Si un commentaire est associé à une colonne de la base de données, le crawler génère le commentaire correspondant dans la table du catalogue. La chaîne de commentaire est tronquée à 255 octets. Les commentaires ne sont pas pris en charge pour Microsoft SQL Server. |
| aws:RawTableComment | Si un commentaire est associé à une table de la base de données, le crawler génère le commentaire correspondant dans la table du catalogue. La chaîne de commentaire est tronquée à 255 octets. Les commentaires ne sont pas pris en charge pour Microsoft SQL Server. |
# Personnalisation du comportement d’un robot
Lorsque vous configurez un AWS Glue crawler, vous disposez de plusieurs options pour définir le comportement de votre robot d'exploration.
+ **Analyses incrémentielles** : vous pouvez configurer un robot pour exécuter des analyses incrémentielles afin d’ajouter uniquement de nouvelles partitions au schéma de table.
+ **Index de partition** : un robot crée par défaut des index de partition pour les cibles Amazon S3 et Delta Lake afin de permettre une recherche efficace de partitions spécifiques.
+ **Accélérez le temps d’analyse à l’aide des événements Amazon S3** : vous pouvez configurer un robot pour qu’il utilise les événements Amazon S3 afin d’identifier les changements entre deux analyses. Ce processus s’effectue en répertoriant tous les fichiers du sous-dossier qui a déclenché l’événement au lieu de répertorier la cible Amazon S3 ou du catalogue de données complète.
+ **Gestion des modifications de schéma** : vous pouvez empêcher un robot d’apporter des modifications au schéma existant. Vous pouvez utiliser l'API AWS Management Console ou l'AWS GlueAPI pour configurer la manière dont votre robot traite certains types de modifications.
+ **Un seul schéma pour plusieurs chemins Amazon S3** : vous pouvez configurer un robot pour créer un seul schéma pour chaque chemin S3 si les données sont compatibles.
+ **Emplacement des tables et niveaux de partitionnement** : l’option de robot au niveau de la table vous offre la possibilité d’indiquer au robot où se trouvent les tables et comment vous souhaitez que les partitions soient créées.
+ **Seuil de table** : vous pouvez spécifier le nombre maximum de tables que le robot est autorisé à créer en spécifiant un seuil de table.
+ **AWS Lake Formation informations d'identification** — Vous pouvez configurer un robot d'exploration pour qu'il utilise les informations d'identification de Lake Formation pour accéder à un magasin de données Amazon S3 ou à une table du catalogue de données avec un emplacement Amazon S3 sous-jacent au même emplacement Compte AWS ou à un autre Compte AWS.
Pour plus d'informations sur l'utilisation de la console AWS Glue pour ajouter un crawler, consultez [Configuration d’un robot](define-crawler.md).
**Topics**
+ [Planification d’analyses incrémentielles pour ajouter de nouvelles partitions.](incremental-crawls.md)
+ [Génération des index de partition](crawler-configure-partition-indexes.md)
+ [Empêcher un robot de modifier un schéma existant](crawler-schema-changes-prevent.md)
+ [Création d’un schéma unique pour chaque chemin d’inclusion Amazon S3](crawler-grouping-policy.md)
+ [Spécification de l’emplacement de la table et du niveau de partitionnement](crawler-table-level.md)
+ [Spécification du nombre maximal de tables que le robot est autorisé à créer](crawler-maximum-number-of-tables.md)
+ [Configuration d’un robot pour utiliser les informations d’identification de Lake Formation](crawler-lf-integ.md)
+ [Accélération des analyseurs à l’aide des notifications d’événements Amazon S3](crawler-s3-event-notifications.md)
# Planification d’analyses incrémentielles pour ajouter de nouvelles partitions.
Vous pouvez configurer et AWS Glue crawler exécuter des analyses incrémentielles pour ajouter uniquement de nouvelles partitions au schéma de table. Lorsque le robot s’exécute pour la première fois, il effectue une analyse complète pour traiter l’intégralité de la source de données afin d’enregistrer le schéma complet et toutes les partitions existantes dans l’ AWS Glue Data Catalog.
Les analyses qui suivent l’analyse complète initiale seront incrémentielles, le robot identifiant et ajoutant uniquement les nouvelles partitions introduites depuis l’analyse précédente. Cette approche permet d’accélérer les temps d’analyse, car le robot n’a plus besoin de traiter l’intégralité de la source de données à chaque exécution. Il peut alors se concentrer uniquement sur les nouvelles partitions.
**Note**
Les analyses incrémentielles ne détectent pas les modifications ou les suppressions de partitions existantes. Cette configuration convient parfaitement aux sources de données dotées d’un schéma stable. En cas de modification majeure ponctuelle du schéma, il est conseillé de configurer temporairement le robot pour qu’il effectue une analyse complète afin de capturer le nouveau schéma avec précision, puis de revenir en mode d’analyse incrémentielle.
Le schéma suivant montre que lorsque le paramètre d’analyse incrémentielle est activé, le robot détecte et ajoute uniquement le dossier récemment ajouté, month=March, au catalogue.
![\[Le diagramme suivant montre que les fichiers du mois de mars ont été ajoutés.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/crawlers-s3-folders-new.png)
Procédez comme suit pour mettre à jour votre robot afin d’effectuer des analyses incrémentielles :
------
#### [ AWS Management 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. Choisissez **Robots** dans le **catalogue de données**.
1. Choisissez un robot que vous souhaitez configurer pour qu’il effectuer une analyse incrémentielle.
1. Choisissez **Modifier**.
1. Choisissez **Étape 2. Choisissez les sources de données et les classificateurs.**
1. Choisissez la source de données que vous souhaitez analyser de manière incrémentielle.
1. Choisissez **Modifier**.
1. Choisissez **Analyser les nouveaux sous-dossiers uniquement** sous **Exécutions ultérieures du robot**.
1. Choisissez **Mettre à jour**.
Pour créer un calendrier pour un robot, consultez [Planification d'un crawler](schedule-crawler.md).
------
#### [ AWS CLI ]
```
aws glue update-crawler \
--name myCrawler \
--recrawl-policy RecrawlBehavior=CRAWL_NEW_FOLDERS_ONLY \
--schema-change-policy UpdateBehavior=LOG,DeleteBehavior=LOG
```
------
**Notes et restrictions**
Lorsque cette option est activée, vous ne pouvez pas modifier les magasins de données cibles Amazon S3 lors de la modification de l'crawler. Cette option affecte certains paramètres de configuration de l'crawler. Lorsqu'il est activé, il force le comportement de mise à jour et le comportement de suppression de l'crawler à `LOG`. Cela signifie que :
+ S'il découvre des objets dont les schémas ne sont pas compatibles, le robot d'exploration n'ajoutera pas les objets dans le catalogue de données et ajoute ce détail sous forme de journal de connexion. CloudWatch
+ Il ne met pas à jour les objets supprimés dans le catalogue de données.
# Génération des index de partition
Le catalogue de données prend en charge la création d’index de partition afin de permettre une recherche efficace de partitions spécifiques. Pour en savoir plus, consultez [Creating partition indexes](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html). Le AWS Glue crawler crée des index de partition pour les cibles Amazon S3 et Delta Lake par défaut.
------
#### [ AWS Management 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. Choisissez **Robots** dans le **catalogue de données**.
1. Lorsque vous définissez un robot, l’option permettant de **créer automatiquement des index de partition** est activée par défaut sous **Options avancées**, sur la page **Définir la sortie et la planification**.
Pour désactiver cette option, vous pouvez décocher la case **Créer des index de partition automatiquement** dans la console.
1. Complétez la configuration du robot et choisissez **Créer un robot**.
------
#### [ AWS CLI ]
Vous pouvez également désactiver cette option en utilisant l’ AWS CLI et en définissant `CreatePartitionIndex ` dans le paramètre `configuration`. La valeur par défaut est True.
```
aws glue update-crawler \
--name myCrawler \
--configuration '{"Version": 1.0, "CreatePartitionIndex": false }'
```
------
## Notes d'utilisation pour les index de partition
+ Les tables créées par le Crawler ne contiennent pas la variable `partition_filtering.enabled` par défaut. Pour en savoir plus, consultez [AWS Glue partition indexing and filtering](https://docs.aws.amazon.com/athena/latest/ug/glue-best-practices.html#glue-best-practices-partition-index).
+ La création d'index de partition pour les partitions chiffrées n'est pas prise en charge.
# Empêcher un robot de modifier un schéma existant
Vous pouvez empêcher AWS Glue crawler s d'apporter des modifications de schéma au catalogue de données lors de son exécution. Par défaut, les robots mettent à jour le schéma du catalogue de données pour qu’il corresponde à la source de données analysée. Toutefois, dans certains cas, vous souhaiterez peut-être empêcher le robot de modifier le schéma existant, en particulier si vous avez transformé ou nettoyé les données et que vous ne souhaitez pas que le schéma d’origine remplace les modifications.
Suivez ces étapes pour configurer votre robot de manière à ne pas remplacer le schéma existant dans une définition de table.
------
#### [ AWS Management 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. Choisissez **Robots** dans le **catalogue de données**.
1. Choisissez un robot dans la liste, puis **Modifier**.
1. Choisissez **étape 4, Définir la sortie et la planification**.
1. Sous **Options avancées**, choisissez **Ajouter de nouvelles colonnes uniquement** ou **Ignorer la modification et ne pas mettre à jour la table dans le catalogue de données**.
1. En outre, vous pouvez définir une option de configuration sur **Mettre à jour toutes les partitions nouvelles et existantes avec les métadonnées de la table**. Cela définit les schémas de partition pour qu’ils héritent de la table.
1. Choisissez **Mettre à jour**.
------
#### [ AWS CLI ]
L’exemple suivant montre comment configurer un robot pour ne pas modifier le schéma existant, mais uniquement pour ajouter de nouvelles colonnes :
```
aws glue update-crawler \
--name myCrawler \
--configuration '{"Version": 1.0, "CrawlerOutput": {"Tables": {"AddOrUpdateBehavior": "MergeNewColumns"}}}'
```
L’exemple suivant montre comment configurer un robot pour ne pas modifier le schéma existant et ne pas ajouter de nouvelles colonnes :
```
aws glue update-crawler \
--name myCrawler \
--schema-change-policy UpdateBehavior=LOG \
--configuration '{"Version": 1.0, "CrawlerOutput": {"Partitions": { "AddOrUpdateBehavior": "InheritFromTable" }}}'
```
------
#### [ API ]
Si vous ne voulez pas qu’un schéma de table soit modifié lorsqu’un crawler s’exécute, définissez la politique de modification du schéma sur `LOG`.
Lorsque vous configurez l’crawler à l’aide de l’API, définissez les paramètres suivants :
+ Définissez le champ `UpdateBehavior` de la structure `SchemaChangePolicy` sur `LOG`.
+ Définissez le champ `Configuration` avec une représentation de chaîne de l'objet JSON suivant dans l'API de l'crawler ; par exemple :
```
{
"Version": 1.0,
"CrawlerOutput": {
"Partitions": { "AddOrUpdateBehavior": "InheritFromTable" }
}
}
```
------
# Création d’un schéma unique pour chaque chemin d’inclusion Amazon S3
Par défaut, lorsqu’un crawler définit des tables pour des données stockées dans Amazon S3, il prend en compte la compatibilité des données et la similitude de schéma. Parmi les facteurs de compatibilité des données, il prend en compte le fait que les données sont du même format (par exemple, JSON), le même type de compression (par exemple, GZIP), la structure du chemin d’accès Amazon S3 et d’autres caractéristiques de données. La similarité des schémas définit le degré de similarité des schémas d’objets Amazon S3 distincts.
Pour vous aider à illustrer cette option, supposons que vous définissez un crawler avec un chemin d’inclusion `s3://amzn-s3-demo-bucket/table1/`. Lorsque l’crawler s’exécute, il trouve deux fichiers JSON avec les caractéristiques suivantes :
+ **Fichier 1** – `S3://amzn-s3-demo-bucket/table1/year=2017/data1.json`
+ *Contenu du fichier* – `{“A”: 1, “B”: 2}`
+ *Schéma* – `A:int, B:int`
+ **Fichier 2** – `S3://amzn-s3-demo-bucket/table1/year=2018/data2.json`
+ *Contenu du fichier* – `{“C”: 3, “D”: 4}`
+ *Schéma* – `C: int, D: int`
Par défaut, l’crawler crée deux tables, nommées `year_2017` et `year_2018` car les schémas ne sont pas suffisamment similaires. Toutefois, si l’option **Create a single schema for each S3 path (Créer un seul schéma pour chaque chemin S3)** est sélectionnée, et si les données sont compatibles, l’crawler crée une table. La table comprend le schéma `A:int,B:int,C:int,D:int` et `partitionKey` `year:string`.
------
#### [ AWS Management 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. Choisissez **Robots** dans le **catalogue de données**.
1. Lorsque vous configurez un nouveau robot, sous **Sortie et planification**, sélectionnez l’option **Créer un schéma unique pour chaque chemin S3** sous Options avancées.
------
#### [ AWS CLI ]
Vous pouvez configurer un crawler pour `CombineCompatibleSchemas` dans une définition de table courante lorsque cela est possible. Avec cette option, l’crawler considère toujours la compatibilité des données, mais ignore la similarité des schémas spécifiques lors de l’évaluation des objets Amazon S3 dans le chemin d’inclusion (include path) spécifié.
Lorsque vous configurez le robot d'exploration à l'aide du AWS CLI, définissez l'option de configuration suivante :
```
aws glue update-crawler \
--name myCrawler \
--configuration '{"Version": 1.0, "Grouping": {"TableGroupingPolicy": "CombineCompatibleSchemas" }}'
```
------
#### [ API ]
Lorsque vous configurez l’crawler à l’aide de l’API, définissez les options de configuration suivantes :
Définissez le champ `Configuration` avec une représentation de chaîne de l'objet JSON suivant dans l'API de l'crawler ; par exemple :
```
{
"Version": 1.0,
"Grouping": {
"TableGroupingPolicy": "CombineCompatibleSchemas" }
}
```
------
# Spécification de l’emplacement de la table et du niveau de partitionnement
Par défaut, lorsqu’un robot définit des tables pour les données stockées dans Amazon S3, il tente de fusionner les schémas et de créer des tables de niveau supérieur (`year=2019`). Dans certains cas, vous pouvez vous attendre à ce que l’crawler crée une table pour le dossier `month=Jan`, mais à la place, l’crawler crée une partition puisqu’un dossier frère (`month=Mar`) a été fusionné dans la même table.
L’option d’crawler au niveau de la table vous offre la possibilité d’indiquer à l’crawler où se trouvent les tables et comment vous souhaitez que les partitions soient créées. Lorsque vous spécifiez un **Table level** (Niveau de la table), la table est créée à ce niveau absolu à partir du compartiment Amazon S3.
![\[Regroupement de l’crawler avec le niveau de table défini sur niveau 2.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/crawler-table-level1.jpg)
Lorsque vous configurez l’crawler sur la console, vous pouvez spécifier une valeur pour l’option d’crawler **Table level** (Niveau de la table). La valeur doit être un entier positif qui indique l’emplacement de la table (niveau absolu dans le jeu de données). Le niveau du dossier de niveau supérieur est 1. Par exemple, pour le chemin `mydataset/year/month/day/hour`, si le niveau est défini sur 3, la table est créée à l’emplacement `mydataset/year/month`.
------
#### [ AWS Management 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. Choisissez **Robots** dans le **catalogue de données**.
1. Lorsque vous configurez un robot, sous **Sortie et planification**, choisissez **Niveau de table** sous **Options avancées**.
![\[Spécification d’un niveau de table dans la configuration de l’crawler.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/crawler-configuration-console.png)
------
#### [ AWS CLI ]
Lorsque vous configurez le robot à l'aide du AWS CLI, définissez le `configuration` paramètre comme indiqué dans l'exemple de code :
```
aws glue update-crawler \
--name myCrawler \
--configuration '{"Version": 1.0, "Grouping": { "TableLevelConfiguration": 2 }}'
```
------
#### [ API ]
Lorsque vous configurez l’crawler à l’aide de l’API, définissez le champ `Configuration` avec une représentation de chaînes de l’objet JSON suivant ; par exemple :
```
configuration = jsonencode(
{
"Version": 1.0,
"Grouping": {
TableLevelConfiguration = 2
}
})
```
------
#### [ CloudFormation ]
Dans cet exemple, vous définissez l'option de **niveau de table** disponible dans la console au sein de votre CloudFormation modèle :
```
"Configuration": "{
\"Version\":1.0,
\"Grouping\":{\"TableLevelConfiguration\":2}
}"
```
------
# Spécification du nombre maximal de tables que le robot est autorisé à créer
Vous pouvez éventuellement spécifier le nombre maximum de tables que le robot d'exploration est autorisé à créer en spécifiant un `TableThreshold` via la AWS Glue console ou AWS CLI. Si les tables détectées par le crawler lors de son analyse sont supérieures à cette valeur d’entrée, l’analyse échoue et aucune donnée n’est écrite dans le catalogue de données.
Ce paramètre est utile lorsque les tables qui seraient détectées et créées par le crawler sont beaucoup plus grandes que vos prévisions. Cela peut être dû à plusieurs raisons, notamment :
+ Lorsque vous utilisez une AWS Glue tâche pour renseigner vos emplacements Amazon S3, vous pouvez vous retrouver avec des fichiers vides au même niveau qu'un dossier. Dans de tels cas, lorsque vous exécutez un crawler sur cet emplacement Amazon S3, le crawler crée plusieurs tables en raison de la présence de fichiers et de dossiers au même niveau.
+ Si vous ne configurez pas `"TableGroupingPolicy": "CombineCompatibleSchemas"`, vous pourriez vous retrouver avec plus de tables que prévu.
Vous devez spécifier la propriété `TableThreshold` sous forme d’une valeur de nombre entier supérieure à 0. Cette valeur est configurée par crawler. Cela signifie qu’elle est prise en compte pour chaque analyse. Par exemple : un crawler a la valeur `TableThreshold` définie sur 5. Lors de chaque analyse, AWS Glue compare le nombre de tables détectées à cette valeur seuil de table (5) et, si le nombre de tables détectées est inférieur à 5, AWS Glue écrit les tables dans le catalogue de données. Sinon, l'analyse échoue sans écriture dans le catalogue de données.
------
#### [ AWS Management Console ]
**Pour configurer à `TableThreshold` l'aide de AWS Management 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. Lors de la configuration d’un robot, dans **Sortie et planification**, définissez le **Seuil maximal de tables** sur le nombre de tables que le robot est autorisé à générer.
![\[La section Sortie et planification de la AWS console affiche le paramètre Maximum table threshold.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/crawler-max-tables.png)
------
#### [ AWS CLI ]
Pour configurer à `TableThreshold` l'aide de AWS CLI :
```
aws glue update-crawler \
--name myCrawler \
--configuration '{"Version": 1.0, "CrawlerOutput": {"Tables": { "TableThreshold": 5 }}}'
```
------
#### [ API ]
Pour définir `TableThreshold` à l’aide de l’API :
```
"{"Version":1.0,
"CrawlerOutput":
{"Tables":{"AddOrUpdateBehavior":"MergeNewColumns",
"TableThreshold":5}}}";
```
------
Les messages d’erreur sont consignés pour vous aider à identifier les chemins d’accès aux tables et à nettoyer vos données. Exemple de journal dans votre compte si le crawler échoue, parce que le nombre de tables était supérieur à la valeur du seuil de tables fournie :
```
Table Threshold value = 28, Tables detected - 29
```
Dans CloudWatch, nous enregistrons tous les emplacements de table détectés sous forme de message INFO. Une erreur est consignée comme motif de l’échec.
```
ERROR com.amazonaws.services.glue.customerLogs.CustomerLogService - CustomerLogService received CustomerFacingException with message
The number of tables detected by crawler: 29 is greater than the table threshold value provided: 28. Failing crawler without writing to Data Catalog.
com.amazonaws.services.glue.exceptions.CustomerFacingInternalException: The number of tables detected by crawler: 29 is greater than the table threshold value provided: 28.
Failing crawler without writing to Data Catalog.
```
# Configuration d’un robot pour utiliser les informations d’identification de Lake Formation
Vous pouvez configurer un robot d'exploration pour qu'il utilise des AWS Lake Formation informations d'identification pour accéder à un magasin de données Amazon S3 ou à une table de catalogue de données contenant un emplacement Amazon S3 sous-jacent au sein de la même Compte AWS ou d'une autre Compte AWS. Vous pouvez configurer une table du catalogue de données existante en tant que cible d’un crawler, si le crawler et la table du catalogue de données se trouvent dans le même compte. Actuellement, une seule cible de catalogue avec une seule table de catalogue est autorisée lors de l’utilisation d’une table du catalogue de données comme cible d’un robot.
**Note**
Lorsque vous définissez une table du catalogue de données en tant que cible du crawler, assurez-vous que l’emplacement sous-jacent de la table du catalogue de données est un emplacement Amazon S3. Les crawlers qui utilisent les informations d’identification Lake Formation ne prennent en charge que les cibles du catalogue de données avec des emplacements Amazon S3 sous-jacents
## Configuration requise lorsque le crawler et l’emplacement Amazon S3 enregistré ou la table du catalogue de données se trouvent dans le même compte (indexation de site web intégrée au compte)
Pour permettre au crawler d’accéder à un magasin de données ou à une table du catalogue de données à l’aide des informations d’identification de Lake Formation, vous devez enregistrer l’emplacement des données auprès de Lake Formation. En outre, le rôle IAM du crawler doit être autorisé à lire les données depuis la destination où le compartiment Amazon S3 est enregistré.
Vous pouvez effectuer les étapes de configuration suivantes à l'aide du AWS Management Console ou AWS Command Line Interface (AWS CLI).
------
#### [ AWS Management Console ]
1. Avant de configurer un crawler pour accéder à sa source, enregistrez l’emplacement des données du magasin de données ou du catalogue de données auprès de Lake Formation. Dans la console Lake Formation ([https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/)), enregistrez un emplacement Amazon S3 comme emplacement racine de votre lac de données dans l' Compte AWS endroit où le robot est défini. Pour plus d’informations, consultez la rubrique [Enregistrement d’un emplacement Amazon S3](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html).
1. Accordez des autorisations **Emplacement des données** au rôle IAM utilisé pour l’exécution du crawler afin que celui-ci puisse lire les données depuis la destination dans Lake Formation. Pour plus d’informations, consultez la rubrique [Octroi d’autorisations d’emplacement de données (même compte)](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-location-permissions-local.html).
1. Accordez les autorisations d’accès au rôle de crawler (`Create`) à la base de données, qui est spécifiée comme base de données de sortie. Pour plus d’informations, consultez la rubrique [Octroi d’autorisations de base de données via la console Lake Formation et la méthode de ressource nommée](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-database-permissions.html).
1. Dans la console IAM ([https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)), créez un rôle IAM pour le robot d'exploration. Ajoutez la stratégie `lakeformation:GetDataAccess` au rôle.
1. Dans la AWS Glue console ([https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)), lors de la configuration du robot d'exploration, sélectionnez l'option **Utiliser les informations d'identification de Lake Formation pour analyser la source de données Amazon S3**.
**Note**
Le champ accountId est facultatif pour l’indexation de site web intégrée au compte.
------
#### [ AWS CLI ]
```
aws glue --profile demo create-crawler --debug --cli-input-json '{
"Name": "prod-test-crawler",
"Role": "arn:aws:iam::111122223333:role/service-role/AWSGlueServiceRole-prod-test-run-role",
"DatabaseName": "prod-run-db",
"Description": "",
"Targets": {
"S3Targets":[
{
"Path": "s3://amzn-s3-demo-bucket"
}
]
},
"SchemaChangePolicy": {
"UpdateBehavior": "LOG",
"DeleteBehavior": "LOG"
},
"RecrawlPolicy": {
"RecrawlBehavior": "CRAWL_EVERYTHING"
},
"LineageConfiguration": {
"CrawlerLineageSettings": "DISABLE"
},
"LakeFormationConfiguration": {
"UseLakeFormationCredentials": true,
"AccountId": "111122223333"
},
"Configuration": {
"Version": 1.0,
"CrawlerOutput": {
"Partitions": { "AddOrUpdateBehavior": "InheritFromTable" },
"Tables": {"AddOrUpdateBehavior": "MergeNewColumns" }
},
"Grouping": { "TableGroupingPolicy": "CombineCompatibleSchemas" }
},
"CrawlerSecurityConfiguration": "",
"Tags": {
"KeyName": ""
}
}'
```
------
# Configuration requise lorsque le crawler et l'emplacement Amazon S3 enregistré se trouvent dans des comptes différents (indexation de site web entre comptes)
Pour permettre au crawler d'accéder à un magasin de données sur un autre compte à l'aide des informations d'identification Lake Formation, vous devez d'abord enregistrer l'emplacement des données Amazon S3 auprès de Lake Formation. Ensuite, vous accordez des autorisations de localisation des données au compte du crawler en procédant comme suit.
Vous pouvez effectuer les étapes suivantes à l'aide du AWS Management Console ou AWS CLI.
------
#### [ AWS Management Console ]
1. Dans le compte sur lequel l'emplacement Amazon S3 est enregistré (compte B) :
1. Enregistrez un chemin Amazon S3 dans Lake Formation. Pour plus d'informations, consultez la rubrique [Enregistrement d'un emplacement Amazon S3](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html).
1. Accordez des autorisations **Data location** (Emplacement des données) au compte (compte A) sur lequel le crawler sera exécuté. Pour plus d'informations, consultez la rubrique [Octroi d'autorisations d'emplacement de données](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-location-permissions-local.html).
1. Créez une base de données vide dans Lake Formation avec l'emplacement sous-jacent comme emplacement Amazon S3 cible. Pour plus d'informations, consultez la rubrique [Création d'une base de données](https://docs.aws.amazon.com/lake-formation/latest/dg/creating-database.html).
1. Accordez au compte A (le compte sur lequel le crawler sera exécuté) l'accès à la base de données que vous avez créée à l'étape précédente. Pour plus d'informations, consultez la rubrique [Octroi d'autorisations de base de données](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-database-permissions.html).
1. Dans le compte sur lequel le crawler est créé et sera exécuté (compte A) :
1. À l'aide de la AWS RAM console, acceptez la base de données partagée depuis le compte externe (compte B). Pour plus d'informations, consultez la section [Acceptation d'une invitation de partage de ressources provenant de AWS Resource Access Manager](https://docs.aws.amazon.com/lake-formation/latest/dg/accepting-ram-invite.html).
1. Créez un rôle IAM pour le crawler. Ajoutez une stratégie `lakeformation:GetDataAccess` au rôle.
1. Dans la console Lake Formation ([https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/)), accordez **des autorisations de localisation des données** sur l'emplacement Amazon S3 cible au rôle IAM utilisé pour l'exécution du robot d'exploration afin que celui-ci puisse lire les données depuis la destination dans Lake Formation. Pour plus d'informations, consultez la rubrique [Octroi d'autorisations d'emplacement de données](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-location-permissions-local.html).
1. Créez un lien de ressource sur la base de données partagée. Pour plus d'informations, consultez la rubrique [Création d'un lien de ressources](https://docs.aws.amazon.com/lake-formation/latest/dg/create-resource-link-database.html).
1. Accordez les autorisations d'accès au rôle de crawler (`Create`) sur la base de données partagée et (`Describe`) le lien de ressource. Le lien de ressource est spécifié dans la sortie du crawler.
1. Dans la AWS Glue console ([https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)), lors de la configuration du robot d'exploration, sélectionnez l'option **Utiliser les informations d'identification de Lake Formation pour analyser la source de données Amazon S3**.
Pour l'exploration entre comptes, spécifiez l' Compte AWS ID auquel l'emplacement Amazon S3 cible est enregistré auprès de Lake Formation. Le champ accountId est facultatif pour l'indexation de site web intégrée au compte.
![\[IAM role selection and Lake Formation configuration options for AWS Glue crawler security settings.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/cross-account-crawler.png)
------
#### [ AWS CLI ]
```
aws glue --profile demo create-crawler --debug --cli-input-json '{
"Name": "prod-test-crawler",
"Role": "arn:aws:iam::111122223333:role/service-role/AWSGlueServiceRole-prod-test-run-role",
"DatabaseName": "prod-run-db",
"Description": "",
"Targets": {
"S3Targets":[
{
"Path": "s3://amzn-s3-demo-bucket"
}
]
},
"SchemaChangePolicy": {
"UpdateBehavior": "LOG",
"DeleteBehavior": "LOG"
},
"RecrawlPolicy": {
"RecrawlBehavior": "CRAWL_EVERYTHING"
},
"LineageConfiguration": {
"CrawlerLineageSettings": "DISABLE"
},
"LakeFormationConfiguration": {
"UseLakeFormationCredentials": true,
"AccountId": "111111111111"
},
"Configuration": {
"Version": 1.0,
"CrawlerOutput": {
"Partitions": { "AddOrUpdateBehavior": "InheritFromTable" },
"Tables": {"AddOrUpdateBehavior": "MergeNewColumns" }
},
"Grouping": { "TableGroupingPolicy": "CombineCompatibleSchemas" }
},
"CrawlerSecurityConfiguration": "",
"Tags": {
"KeyName": ""
}
}'
```
------
**Note**
Un crawler utilisant les informations d'identification Lake Formation n'est pris en charge que pour les cibles Amazon S3 et du catalogue de données.
Pour les cibles utilisant le distributeur d'informations d'identification Lake Formation, les emplacements Amazon S3 sous-jacents doivent appartenir au même compartiment. Par exemple, les clients peuvent utiliser plusieurs cibles (s3://amzn-s3-demo-bucket1/folder1, s3://amzn-s3-demo-bucket1/folder2) à condition que tous les emplacements cibles se trouvent dans le même compartiment (amzn-s3-demo-bucket1). La spécification de différents compartiments (s3://amzn-s3-demo-bucket1/folder1, s3://amzn-s3-demo-bucket2/folder2) n’est pas autorisée.
Actuellement, pour les crawlers de cible du catalogue de données, une seule cible de catalogue avec une seule table de catalogue est autorisée.
# Accélération des analyseurs à l’aide des notifications d’événements Amazon S3
Au lieu de répertorier les objets d’une cible Amazon S3 ou de catalogue de données, vous pouvez configurer le Crawler pour qu’il utilise les événements Amazon S3 pour trouver les modifications éventuelles. Cette fonction améliore le temps de nouvelle analyse en utilisant les événements Amazon S3 pour identifier les changements entre deux analyses. Ce processus s’effectue en répertoriant tous les fichiers du sous-dossier qui a déclenché l’événement au lieu de répertorier la cible Amazon S3 ou du catalogue de données complète.
La première analyse répertorie tous les objets Amazon S3 de la cible. Après la première analyse réussie, vous pouvez choisir de faire une nouvelle analyse manuellement ou selon un calendrier défini. L’crawler indiquera uniquement les objets de ces événements au lieu de répertorier tous les objets.
Lorsque la cible est une table de catalogue de données, le robot met à jour les tables existantes du catalogue de données avec les modifications (par exemple, des partitions supplémentaires dans une table).
Passer à un crawler basé sur les événements Amazon S3 a les avantages suivants :
+ Une nouvelle analyse plus rapide, car la liste de tous les objets de la cible n’est pas nécessaire ; toutefois, la liste de dossiers spécifiques est effectuée là où des objets sont ajoutés ou supprimés.
+ Une réduction du coût global d’analyse étant donné que la liste de dossiers spécifiques est effectuée lorsque des objets sont ajoutés ou supprimés.
L’analyse des événements Amazon S3 s’exécute en consommant des événements Amazon S3 depuis la file d’attente SQS en fonction de la planification de l’crawler. Il n’y aura aucun coût s’il n’y a pas d’événements dans la file d’attente. Les événements Amazon S3 peuvent être configurés pour accéder directement à la file d’attente SQS ou, dans les cas où plusieurs consommateurs ont besoin du même événement, une combinaison de SNS et de SQS. Pour de plus amples informations, veuillez consulter [Configuration de votre compte pour les notifications d’événements Amazon S3](#crawler-s3-event-notifications-setup).
Après avoir créé et configuré le Crawler en mode événement, la première analyse s’exécute en mode de liste en répertoriant la liste de la cible Amazon S3 ou du catalogue de données complète. Le journal suivant confirme l’opération de l’analyse en consommant des événements Amazon S3 après la première analyse réussie : « L’analyse est exécutée en consommant des événements Amazon S3. »
Après avoir créé l’analyse des événements Amazon S3 et mis à jour les propriétés de l’crawler susceptibles d’avoir un impact sur l’analyse, l’analyse fonctionne en mode liste et le journal suivant est ajouté : « L’analyse n’est pas exécutée en mode événement S3 ».
**Note**
Le nombre maximum de messages à consommer est de 100 000 par analyse.
## Considérations et restrictions
Les considérations et restrictions suivantes s’appliquent lorsque vous configurez un robot pour qu’il utilise les notifications d’événements Amazon S3 afin de trouver les modifications éventuelles.
+ **Comportement important avec les partitions supprimées**
Lorsque vous utilisez les robots d’événements Amazon S3 avec les tables du catalogue de données :
+ Si vous supprimez une partition à l’aide de l’appel d’API `DeletePartition`, vous devez également supprimer tous les objets S3 sous cette partition et sélectionner **Tous les événements de suppression d’objets** lorsque vous configurez vos notifications d’événements S3. Si les événements de suppression ne sont pas configurés, le robot recrée la partition supprimée lors de sa prochaine exécution.
+ Seule une cible unique est prise en charge par le Crawler, que ce soit pour les cibles Amazon S3 ou du Catalogue de données.
+ Un SQS sur un VPC privé n’est pas pris en charge.
+ L’échantillonnage Amazon S3 n’est pas pris en charge.
+ La cible du Crawler doit être un dossier pour une cible Amazon S3, ou une ou plusieurs tables de Catalogue de données AWS Glue pour une cible de Catalogue de données.
+ Le caractère générique du chemin « tout » n’est pas pris en charge : s3://%
+ Pour une cible de Catalogue de données, toutes les tables du catalogue doivent pointer vers le même compartiment Amazon S3 pour le mode événement Amazon S3.
+ Pour une cible de Catalogue de données, une table de catalogue ne doit pas pointer vers un emplacement Amazon S3 au format Delta Lake (contenant des dossiers \$1symlink ou vérifiant le `InputFormat` de la table du catalogue).
**Topics**
+ [Considérations et restrictions](#s3event-crawler-limitations)
+ [Configuration de votre compte pour les notifications d’événements Amazon S3](#crawler-s3-event-notifications-setup)
+ [Configuration d’un robot pour les notifications d’événements Amazon S3 pour une cible Amazon S3](crawler-s3-event-notifications-setup-console-s3-target.md)
+ [Configuration d’un robot pour les notifications d’événements Amazon S3 à l’aide de la table du catalogue de données](crawler-s3-event-notifications-setup-console-catalog-target.md)
## Configuration de votre compte pour les notifications d’événements Amazon S3
Réalisez les tâches de configuration suivantes. Notez que les valeurs entre parenthèses font référence aux paramètres configurables du script.
1. Vous devez configurer les notifications d’événements pour votre compartiment Amazon S3.
Pour plus d’informations, consultez [Amazon S3 Event Notifications](https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html).
1. Pour utiliser le robot basé sur les événements Amazon S3, vous devez activer la notification d’événements sur le compartiment Amazon S3 avec des événements filtrés à partir du préfixe identique à la cible et au magasin S3 dans SQS. Vous pouvez configurer SQS et la notification d’événements via la console en suivant les étapes de [Walkthrough: Configuring a bucket for notifications](https://docs.aws.amazon.com/AmazonS3/latest/userguide/ways-to-add-notification-config-to-bucket.html).
1. Ajoutez la politique SQS suivante au rôle utilisé par le robot.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"sqs:DeleteMessage",
"sqs:GetQueueUrl",
"sqs:ListDeadLetterSourceQueues",
"sqs:ReceiveMessage",
"sqs:GetQueueAttributes",
"sqs:ListQueueTags",
"sqs:SetQueueAttributes",
"sqs:PurgeQueue"
],
"Resource": "arn:aws:sqs:us-east-1:111122223333:cfn-sqs-queue"
}
]
}
```
------
# Configuration d’un robot pour les notifications d’événements Amazon S3 pour une cible Amazon S3
Suivez ces étapes pour configurer un robot d'exploration pour les notifications d'événements Amazon S3 pour une cible Amazon S3 à l'aide du AWS Management Console ou AWS CLI.
------
#### [ AWS Management Console ]
1. Connectez-vous à la GuardDuty console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/guardduty/](https://console.aws.amazon.com/guardduty/).
1. Définissez les propriétés de votre crawler. Pour plus d'informations, consultez la rubrique [ Configuration des options de configuration du crawler dans la console AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/crawler-configuration.html#crawler-configure-changes-console).
1. Dans la section **Configuration de source de données**, la question *Is your data already mapped to AWS Glue tables?* (Vos données sont-elles déjà mappées aux tables ?) vous est posée.
Par défaut, la réponse **Not yet** (Pas encore) est déjà sélectionnée. Laissez cette réponse par défaut, car vous utilisez une source de données Amazon S3 et les données ne sont pas encore mappées aux tables AWS Glue.
1. Dans la section **Data sources** (Sources de données), choisissez **Add a data source** (Ajouter une source de données).
![\[Data source configuration interface with options to select or add data sources for crawling.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/crawler-s3-event-console1.png)
1. Dans le modal **Add data source** (Ajouter une source de données), configurez la source de données Amazon S3 :
+ **Data source** (Source de données) : Amazon S3 est sélectionné par défaut.
+ **Network connection** (Connexion réseau) (Facultatif) : sélectionnez **Add new connection** (Ajouter une nouvelle connexion).
+ **Location of Amazon S3 data** (Emplacement des données Amazon S3) : par défaut, l’option **In this account** (Dans ce compte) est sélectionnée.
+ **Amazon S3 path** (Chemin d’accès Amazon S3) : spécifiez le chemin d’accès Amazon S3 où les dossiers et les fichiers sont analysés.
+ **Subsequent crawler runs** (Exécutions ultérieures du crawler) : choisissez **Crawl based on events** (Analyse en fonction des événements) pour utiliser les notifications d'événements Amazon S3 pour votre crawler.
+ **Include SQS ARN** (Inclure un ARN SQS) : spécifiez les paramètres du magasin de données, y compris l'ARN SQS valide. (Par exemple, `arn:aws:sqs:region:account:sqs`.)
+ **Include dead-letter SQS ARN** (Inclure un ARN SQS de lettres mortes) (Facultatif) : spécifiez un ARN SQS de lettres mortes Amazon valide. (Par exemple, `arn:aws:sqs:region:account:deadLetterQueue`.)
+ Choisissez **Add an Amazon S3 data source** (Ajouter une source de données Amazon S3).
![\[Add data source dialog for S3, showing options for network connection and crawl settings.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/crawler-s3-event-console2.png)
------
#### [ AWS CLI ]
Voici un exemple d' AWS CLI appel Amazon S3 pour configurer un robot d'exploration afin qu'il utilise les notifications d'événements pour explorer un compartiment cible Amazon S3.
```
Create Crawler:
aws glue update-crawler \
--name myCrawler \
--recrawl-policy RecrawlBehavior=CRAWL_EVENT_MODE \
--schema-change-policy UpdateBehavior=UPDATE_IN_DATABASE,DeleteBehavior=LOG
--targets '{"S3Targets":[{"Path":"s3://amzn-s3-demo-bucket/", "EventQueueArn": "arn:aws:sqs:us-east-1:012345678910:MyQueue"}]}'
```
------
# Configuration d’un robot pour les notifications d’événements Amazon S3 à l’aide de la table du catalogue de données
Lorsque vous avez une table du catalogue de données, configurez un robot pour les notifications d’événements Amazon S3 à l’aide de la console AWS Glue :
1. Définissez les propriétés de votre crawler. Pour plus d'informations, consultez la rubrique [ Configuration des options de configuration du crawler dans la console AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/crawler-configuration.html#crawler-configure-changes-console).
1. Dans la section **Configuration de source de données**, la question *Is your data already mapped to AWS Glue tables?* (Vos données sont-elles déjà mappées aux tables ?) vous est posée.
Sélectionnez **Yes** (Oui) pour choisir les tables existantes de votre Catalogue de données comme source de données.
1. Dans la section **Glue tables** (Tables Glue), choisissez **Add tables** (Ajouter des tables).
![\[Data source configuration interface with options to select existing Glue tables or add new ones.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/crawler-s3-event-console1-cat.png)
1. Dans le modal **Add table** (Ajouter une table), configurez la base de données et les tables :
+ **Network connection** (Connexion réseau) (Facultatif) : sélectionnez **Add new connection** (Ajouter une nouvelle connexion).
+ **Database** (Base de données) : sélectionnez une base de données dans le Catalogue de données.
+ **Tables** : sélectionnez une ou plusieurs tables de cette base de données dans le Catalogue de données.
+ **Subsequent crawler runs** (Exécutions ultérieures du crawler) : choisissez **Crawl based on events** (Analyse en fonction des événements) pour utiliser les notifications d'événements Amazon S3 pour votre crawler.
+ **Include SQS ARN** (Inclure un ARN SQS) : spécifiez les paramètres du magasin de données, y compris l'ARN SQS valide. (Par exemple, `arn:aws:sqs:region:account:sqs`.)
+ **Include dead-letter SQS ARN** (Inclure un ARN SQS de lettres mortes) (Facultatif) : spécifiez un ARN SQS de lettres mortes Amazon valide. (Par exemple, `arn:aws:sqs:region:account:deadLetterQueue`.)
+ Choisissez **Confirmer**.
![\[Add Glue tables dialog with network, database, tables, and crawler options.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/crawler-s3-event-console2-cat.png)
# Didacticiel : Ajout d'un crawler AWS Glue
Pour ce AWS Glue, il vous est demandé d'analyser les données d'arrivée des principaux transporteurs aériens afin de calculer la popularité des aéroports de départ d'un mois à l'autre. Vous disposez de données de vols pour l'année 2016 au format CSV stockées dans Amazon S3. Avant de transformer et d'analyser vos données, vous cataloguez ses métadonnées dans AWS Glue Data Catalog.
Dans ce didacticiel, ajoutons un crawler qui déduit les métadonnées de ces journaux de vol dans Amazon S3 et crée une table dans votre catalogue de données.
**Topics**
+ [Conditions préalables](#tutorial-add-crawler-prerequisites)
+ [Étape 1 : Ajouter un crawler](#tutorial-add-crawler-step1)
+ [Étape 2 : Exécuter le crawler](#tutorial-add-crawler-step2)
+ [Étape 3 : Afficher les objets AWS Glue Data Catalog](#tutorial-add-crawler-step3)
## Conditions préalables
Ce didacticiel part du principe que vous disposez d'un AWS compte et que vous y avez accèsAWS Glue.
## Étape 1 : Ajouter un crawler
Procédez comme suit pour configurer et exécuter un crawler qui extrait les métadonnées d'un fichier CSV stocké dans Amazon S3.
**Pour créer un crawler qui lit les fichiers stockés sur Amazon S3**
1. Sur la console AWS Glue de service, dans le menu de gauche, choisissez **Crawlers**.
1. Sur la page Crawlers, sélectionnez **Créer un Crawler**. Cela démarre une série de pages qui vous invitent à saisir les détails du crawler.
![\[La capture d'écran montre la page du Crawler. À partir de là, vous pouvez créer un Crawler ou modifier, dupliquer, supprimer ou afficher un Crawler existant.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/crawlers-create_crawler.png)
1. Dans le champ Nom de l'analyseur, saisissez **Flights Data Crawler**, et sélectionnez **Suivant**.
Les crawlers invoquent les classifieurs pour déduire le schéma de vos données. Ce didacticiel utilise le classifieur intégré pour CSV par défaut.
1. Pour le type de source du crawler, sélectionnez **Data stores (Magasins de données)**, puis **Next (Suivant)**.
1. Maintenant, faisons pointer le crawler vers vos données. Sur la page **Add a data store (Ajouter un magasin de données)**, sélectionnez le magasin de données Amazon S3. Ce tutoriel n'utilise pas de connexion, alors laissez le champ **Connection (Connexion)** vide s'il est visible.
Pour l'option **Crawl data in (Analyser les données dans)**, sélectionnez **Specified path in another account (Chemin d'accès spécifié dans un autre compte)**. Ensuite, pour **Inclure le chemin**, saisissez le chemin où le crawler peut trouver les données de vol, qui est **s3://crawler-public-us-east-1/flight/2016/csv**. Après avoir saisi le chemin d'accès, le titre de ce champ devient **Include path (Inclure le chemin)**. Choisissez **Suivant**.
1. Vous pouvez analyser plusieurs magasins de données avec un seul crawler. Cependant, dans ce tutoriel, nous n'utilisons qu'un seul magasin de données, alors sélectionnez **No (Non)**, puis **Next (Suivant)**.
1. Le crawler a besoin d'autorisations pour accéder au magasin de données et créer des objets dans le répertoire AWS Glue Data Catalog. Pour configurer ces autorisations, sélectionnez **Create an IAM role (Créer un rôle IAM)**. Le nom du rôle IAM commence par `AWSGlueServiceRole-`, et dans le champ, vous saisissez la dernière partie du nom du rôle. Saisissez **CrawlerTutorial**, puis sélectionnez **Save (Enregistrer)**.
**Note**
Pour créer un rôle IAM, votre utilisateur AWS doit avoir les autorisations `CreateRole`, `CreatePolicy` et `AttachRolePolicy`.
L'assistant crée un rôle IAM nommé`AWSGlueServiceRole-CrawlerTutorial`, associe la politique AWS gérée `AWSGlueServiceRole` à ce rôle et ajoute une politique en ligne qui autorise l'accès en lecture à l'emplacement Amazon S3. `s3://crawler-public-us-east-1/flight/2016/csv`
1. Créez une planification pour le crawler. Pour **Frequency (Fréquence)**, sélectionnez **Run on demand (Exécuter à la demande)**, puis **Next (Suivant)**.
1. Les crawlers créent des tables dans votre catalogue de données. Les tables sont contenues dans une base de données dans le catalogue de données. Tout d'abord, sélectionnez **Add database (Ajouter une base de données)** pour créer une base de données. Dans la fenêtre contextuelle, saisissez **test-flights-db** pour le nom de la base de données, puis sélectionnez **Create (Créer)**.
Ensuite, saisissez **flights** pour **Prefix added to tables (Préfixe ajouté aux tables)**. Utilisez les valeurs par défaut pour le reste des champs et sélectionnez **Next (Suivant)**.
1. Vérifiez les choix que vous avez fait dans le panneau **Add crawler (Ajouter un analyseur)** de l'assistant. Si vous voyez des erreurs, vous pouvez choisir **Back (Retour)** pour revenir aux pages précédentes et apporter des modifications.
Après avoir examiné les informations, sélectionnez **Terminer** pour créer le crawler.
## Étape 2 : Exécuter le crawler
Après avoir créé un crawler, l'assistant vous envoie à la page d'affichage des Crawlers. Étant donné que vous créez le crawler avec une planification à la demande, vous avez la possibilité d'exécuter le crawler.
**Pour exécuter un crawler**
1. La bannière située en haut de cette page vous indique que le crawler a été créé et vous demande si vous souhaitez l'exécuter maintenant. Sélectionnez **Lancez-le maintenant ?** pour exécuter le crawler.
La bannière change pour afficher les messages « Tentative d'exécution » et « Exécution » pour votre crawler. Une fois que le crawler démarre, la bannière disparaît et l'affichage du crawler est mis à jour pour afficher l'état Starting (Démarrage) de celui-ci. Après une minute, vous pouvez cliquer sur l'icône Actualiser pour mettre à jour l'état du crawler qui s'affiche dans le tableau.
1. Une fois que le crawler a terminé sa tâche, une nouvelle bannière s'affiche qui décrit les modifications apportées par le crawler. Vous pouvez choisir le **test-flights-db**lien pour afficher les objets du catalogue de données.
## Étape 3 : Afficher les objets AWS Glue Data Catalog
Le crawler lit les données à l'emplacement source et crée des tables dans le catalogue de données. Une table est une définition de métadonnées qui représente vos données. Les tables du catalogue de données ne contiennent pas de données. Au lieu de cela, vous utilisez ces tables comme source ou cible dans une définition de tâche.
**Pour afficher les objets du catalogue de données créés par le crawler.**
1. Dans le panneau de navigation de gauche, sous **Data catalog (Catalogue de données)**, sélectionnez **Databases (Bases de données)**. Ici, vous pouvez voir la base de données `flights-db` qui est créée par le crawler.
1. Dans le panneau de navigation de gauche, sous **Data catalog (Catalogue de données)**, et sous **Databases (Bases de données)**, sélectionnez **Tables**. Ici, vous pouvez voir la table `flightscsv` qui est créée par le crawler. Si vous sélectionnez le nom de la table, vous pouvez afficher la configuration, les paramètres et les propriétés de la table. En faisant défiler cette vue vers le bas, vous pouvez afficher le schéma, qui est une information sur les colonnes et les types de données de la table.
1. Si vous sélectionnez **View partitions (Afficher les partitions)** sur la page d'affichage de la table, vous pouvez voir les partitions créées pour les données. La première colonne est la clé de partition.
# Définition manuelle des métadonnées
Le catalogue de AWS Glue données est un référentiel central qui stocke les métadonnées relatives à vos sources de données et à vos ensembles de données. Bien qu’un robot puisse automatiquement explorer et renseigner les métadonnées des sources de données prises en charge, il existe certains scénarios dans lesquels vous devrez peut-être définir les métadonnées manuellement dans le catalogue de données :
+ Formats de données non pris en charge : si certaines de vos sources de données ne sont pas prises en charge par le robot, vous devez définir manuellement les métadonnées de ces sources de données dans le catalogue de données.
+ Exigences relatives aux métadonnées personnalisées — Les métadonnées AWS Glue crawler sont déduites en fonction de règles et de conventions prédéfinies. Si vous avez des exigences spécifiques en matière de métadonnées qui ne sont pas couvertes par les métadonnées AWS Glue crawler déduites, vous pouvez définir manuellement les métadonnées pour répondre à vos besoins
+ Gouvernance des données et normalisation : dans certains cas, vous souhaiterez peut-être mieux contrôler les définitions des métadonnées pour des raisons de gouvernance, de conformité ou de sécurité des données. La définition manuelle des métadonnées vous permet de vous assurer que celles-ci sont conformes aux normes et aux politiques de votre organisation.
+ Espace réservé pour une future ingestion de données : si certaines de vos sources de données ne sont pas immédiatement disponibles ou accessibles, vous pouvez créer des tables de schéma vides en tant qu’espaces réservés. Une fois les sources de données disponibles, vous pouvez remplir les tables avec les données réelles, tout en conservant la structure prédéfinie.
Pour définir les métadonnées manuellement, vous pouvez utiliser la AWS Glue console, la console Lake Formation, AWS Glue l'API ou le AWS Command Line Interface (AWS CLI). Vous pouvez créer des bases de données, des tables et des partitions, et spécifier des propriétés de métadonnées telles que des noms de colonnes, des types de données, des descriptions et d’autres attributs.
# Création de bases de données
Les bases de données sont utilisées pour organiser les tables de métadonnées dans AWS Glue. Lorsque vous définissez une table dans le AWS Glue Data Catalog, vous l'ajoutez à une base de données. Une table ne peut se trouver que dans une seule base de données à la fois.
Votre base de données peut contenir des tables qui définissent les données de différents magasins de données. Ces données peuvent inclure des objets dans Amazon Simple Storage Service (Amazon S3) et des tables relationnelles dans Amazon Relational Database Service.
**Note**
Lorsque vous supprimez une base de données AWS Glue, toutes les tables que celle-ci contient sont également supprimées.
Pour consulter la liste des bases de données, 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/). Choisissez **Bases de données**, puis choisissez un nom de base de données dans la liste pour afficher les détails.
Sous l'onglet **Bases de données** de la console AWS Glue, vous pouvez ajouter, modifier ou supprimer des bases de données :
+ Pour créer une base de données, choisissez **Ajouter une base de données** et fournissez un nom et une description. Pour la compatibilité avec d'autres magasins de métadonnées, tels qu'Apache Hive, le nom est en lettres minuscules.
**Note**
Si vous prévoyez d'accéder à la base de données depuis Amazon Athena, fournissez un nom contenant uniquement des caractères alphanumériques et des traits de soulignement. Pour plus d'informations, consultez la rubrique [Noms Athena](https://docs.aws.amazon.com/athena/latest/ug/tables-databases-columns-names.html#ate-table-database-and-column-names-allow-only-underscore-special-characters).
+ Pour modifier la description d'une base de données, cochez la case située en regard du nom de base de données et choisissez **Edit** (Modifier).
+ Pour supprimer une base de données, cochez la case située en regard du nom de base de données et choisissez **Remove** (Supprimer).
+ Pour afficher la liste des tables contenues dans la base de données, choisissez le nom de la base de données et les propriétés de la base de données afficheront alors toutes les tables de la base de données.
Pour modifier la base de données sur laquelle un crawler écrit, vous devez modifier la définition de l'crawler. Pour de plus amples informations, veuillez consulter [Utilisation de robots pour alimenter le catalogue de données](add-crawler.md).
## Liens de ressources de base de données
| |
| --- |
| La console AWS Glue a été récemment mise à jour. La version actuelle de la console ne prend pas en charge les liens de ressources de base de données. |
Le catalogue de données peut également contenir des *liens de ressources* vers des bases de données. Un lien de ressource de base de données est un lien vers une base de données locale ou partagée. Actuellement, vous ne pouvez créer des liens de ressources que dans AWS Lake Formation. Après avoir créé un lien de ressource vers une base de données, vous pouvez utiliser le nom du lien de ressource partout où vous utiliseriez le nom de la base de données. Avec les bases de données que vous possédez ou qui sont partagées avec vous, les liens de ressources de base de données sont renvoyés par `glue:GetDatabases()` et apparaissent sous la forme d'entrées sur la page des **Bases de données** de la console AWS Glue.
Le catalogue de données peut également contenir des liens de ressources de table.
Pour plus d'informations sur les liens de ressources, veuillez consulter la rubrique [Création de liens de ressources](https://docs.aws.amazon.com/lake-formation/latest/dg/creating-resource-links.html) dans le *Guide du développeur AWS Lake Formation *.
# Création de tables
Même si l'exécution d'un robot est la méthode recommandée pour inventorier les données de vos magasins de données, vous pouvez y ajouter des tables de métadonnées AWS Glue Data Catalog manuellement. Cette approche vous permet de mieux contrôler les définitions des métadonnées et de les personnaliser en fonction de vos besoins spécifiques.
Vous pouvez également ajouter manuellement des tables au catalogue de données de la manière suivante :
+ Utilisez la console AWS Glue pour créer manuellement une table dans l’ AWS Glue Data Catalog. Pour de plus amples informations, veuillez consulter [Création de tables à l’aide de la console](#console-tables).
+ Utilisez l'opération `CreateTable` de l'[AWS Glue API](aws-glue-api.md) pour créer une table dans le AWS Glue Data Catalog. Pour de plus amples informations, veuillez consulter [CreateTable action (Python : créer\$1table)](aws-glue-api-catalog-tables.md#aws-glue-api-catalog-tables-CreateTable).
+ Utilisez CloudFormation des modèles. Pour de plus amples informations, veuillez consulter [AWS CloudFormation pour AWS Glue](populate-with-cloudformation-templates.md).
Lorsque vous définissez une table manuellement à l'aide de la console ou d’une API, vous spécifiez le schéma de table et la valeur d'un champ de classification qui indique le type et le format des données de la source de données. Si un crawler crée la table, le format et le schéma des données sont déterminés par un classifieur intégré ou un classifieur personnalisé. Pour plus d'informations sur la création d'une table à l'aide de la console AWS Glue, consultez [Création de tables à l’aide de la console](#console-tables).
**Topics**
+ [Partitions de table](#tables-partition)
+ [Liens de ressources de table](#tables-resource-links)
+ [Création de tables à l’aide de la console](#console-tables)
+ [Création d’index de partition](partition-indexes.md)
+ [Mise à jour de tables Data Catalog créées manuellement à l’aide d’crawlers](#update-manual-tables)
+ [Propriétés de la table Catalogue de données](#table-properties)
## Partitions de table
Une définition de table AWS Glue d'un dossier Amazon Simple Storage Service (Amazon S3) peut décrire une table partitionnée. Par exemple, pour améliorer la performance des requêtes, une table partitionnée peut séparer les données mensuelles dans différents fichiers en utilisant le nom du mois en tant que clé. Dans AWS Glue, les définitions de table incluent la clé de partitionnement d'une table. Lorsque AWS Glue évalue les données dans les dossiers Amazon S3 pour faire l'inventaire d'une table, il détermine si une table individuelle ou une table partitionnée est ajoutée.
Vous pouvez créer des index de partition sur une table pour récupérer un sous-ensemble des partitions au lieu de charger toutes les partitions de la table. Pour en savoir plus sur l'utilisation des index de partition, consultez [Création d’index de partition](partition-indexes.md).
Toutes les conditions suivantes doivent être remplies pour que AWS Glue crée une table partitionnée pour un dossier Amazon S3 :
+ Les schémas des fichiers sont similaires, comme déterminé par AWS Glue.
+ Le format de données des fichiers est le même.
+ Le format de compression des fichiers est le même.
Par exemple, imaginons que vous possédez un compartiment Amazon S3 nommé `my-app-bucket`, où vous stockez des données de vente d'applications iOS et Android. Les données sont partitionnées par année, mois et jour. Les fichiers de données pour les ventes iOS et Android ont le même schéma, format de données et format de compression. Dans le AWS Glue Data Catalog, le AWS Glue robot crée une définition de table avec des clés de partitionnement pour l'année, le mois et le jour.
La liste Amazon S3 `my-app-bucket` suivante présente certaines partitions. Le symbole `=` est utilisé pour attribuer des valeurs de clé de partition.
```
my-app-bucket/Sales/year=2010/month=feb/day=1/iOS.csv
my-app-bucket/Sales/year=2010/month=feb/day=1/Android.csv
my-app-bucket/Sales/year=2010/month=feb/day=2/iOS.csv
my-app-bucket/Sales/year=2010/month=feb/day=2/Android.csv
...
my-app-bucket/Sales/year=2017/month=feb/day=4/iOS.csv
my-app-bucket/Sales/year=2017/month=feb/day=4/Android.csv
```
## Liens de ressources de table
| |
| --- |
| La console AWS Glue a été récemment mise à jour. La version actuelle de la console ne prend pas en charge les liens de ressources de table. |
Le catalogue de données peut également contenir des *liens de ressources* vers des tables. Un lien de ressource de table est un lien vers une table locale ou partagée. Actuellement, vous ne pouvez créer des liens de ressources que dans AWS Lake Formation. Après avoir créé un lien de ressource vers une table, vous pouvez utiliser le nom du lien de ressource partout où vous utiliseriez le nom de la table. Avec les tables que vous possédez ou qui sont partagées avec vous, les liens de ressources de table sont renvoyés par `glue:GetTables()` et apparaissent sous la forme d'entrées sur la page **Tables** de la console AWS Glue.
Le catalogue de données peut également contenir des liens de ressources de base de données.
Pour plus d'informations sur les liens de ressources, veuillez consulter la rubrique [Création de liens de ressources](https://docs.aws.amazon.com/lake-formation/latest/dg/creating-resource-links.html) dans le *Guide du développeur AWS Lake Formation *.
## Création de tables à l’aide de la console
Un tableau figurant dans le AWS Glue Data Catalog est la définition des métadonnées qui représente les données d'un magasin de données. Vous créez des tables lorsque vous exécutez un crawler ; vous pouvez aussi créer une table manuellement dans la console AWS Glue . La liste **Tables** de la console AWS Glue affiche les valeurs des métadonnées de votre table. Les définitions de table vous permettent de spécifier des sources et des cibles lors de la création de tâches ETL (extraction, transformation et chargement).
**Note**
Compte tenu des récentes modifications apportées à la console de AWS gestion, il se peut que vous deviez modifier vos rôles IAM existants pour [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-SearchTables](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-SearchTables)obtenir l'autorisation. Pour la création de nouveaux rôles, l'autorisation d'API `SearchTables` a déjà été ajoutée par défaut.
Pour commencer, 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/). Choisissez l'onglet **Tables** et utilisez le bouton **Add tables** (Ajouter des tables) pour créer des tables avec un crawler ou en saisissant manuellement les attributs.
### Ajout de tableaux sur la console
Pour utiliser un crawler afin d'ajouter des tables, choisissez **Add tables** (Ajouter des tables), puis **Add tables using a crawler** (Ajouter des tables à l'aide d'un crawler). Ensuite, suivez les instructions fournies dans l'assistant **Add crawler** (Ajouter un crawler). Une fois que l'crawler s'exécute, les tables sont ajoutées à l' AWS Glue Data Catalog. Pour de plus amples informations, veuillez consulter [Utilisation de robots pour alimenter le catalogue de données](add-crawler.md).
Si vous connaissez les attributs requis pour créer une définition de table Amazon Simple Storage Service (Amazon S3) dans votre Data Catalog, vous pouvez la créer avec l'assistant de table. Choisissez **Add tables** (Ajouter des tables), **Add table manually** (Ajouter une table manuellement), et suivez les instructions fournies dans l'assistant **Add table** (Ajouter une table).
Lors de l'ajout manuel d'une table à l'aide de la console, tenez compte des points suivants :
+ Si vous prévoyez d'accéder à la table depuis Amazon Athena, fournissez un nom contenant uniquement des caractères alphanumériques et des traits de soulignement. Pour plus d'informations, consultez [Noms Athena](https://docs.aws.amazon.com/athena/latest/ug/tables-databases-columns-names.html#ate-table-database-and-column-names-allow-only-underscore-special-characters).
+ L'emplacement de vos données sources doit être un chemin d'accès Amazon S3.
+ Le format des données doit correspondre à l'un des formats répertoriés dans l'assistant. La classification correspondante et SerDe les autres propriétés du tableau sont automatiquement renseignées en fonction du format choisi. Vous pouvez définir des tables aux formats suivants :
**Avro**
Format binaire JSON Apache Avro.
**CSV**
Valeurs séparées par des caractères. Vous spécifiez également le délimiteur de virgule, de tube, de point-virgule, de tabulation ou de Ctrl-A.
**JSON**
JavaScript Notation d'objets.
**xml**
Format XML (Extensible Markup Language). Spécifiez la balise XML qui définit une ligne dans les données. Les colonnes sont définies dans des balises de ligne.
**Parquet**
Stockage en colonnes Apache Parquet.
**ORC**
Format de fichier Optimized Row Columnar (ORC). Un format conçu pour stocker efficacement les données Hive.
+ Vous pouvez définir une clé de partition pour la table.
+ Actuellement, les tables partitionnées que vous créez avec la console ne peuvent pas être utilisées dans les tâches ETL.
### Attributs des tables
Les attributs suivants font partie des plus importants de votre table :
**Nom**
Le nom est déterminé lorsque la table est créée, et vous ne pouvez pas le modifier. Vous vous référez à un nom de table dans de nombreuses opérations AWS Glue.
**Base de données**
Objet conteneur dans lequel se trouve votre table. Cet objet contient une organisation de vos tables qui existe au sein de votre banque de données AWS Glue Data Catalog et qui peut être différente de celle d'une organisation dans votre magasin de données. Lorsque vous supprimez une base de données, toutes les tables que celle-ci contient sont également supprimées de Data Catalog.
**Description**
Description de la table. Vous pouvez écrire une description vous aidant à comprendre le contenu de la table.
**Format de tableau**
Spécifiez la création d'une AWS Glue table standard ou d'une table au format Apache Iceberg.
Le catalogue de données fournit les options d’optimisation des tables suivantes pour gérer le stockage des tables et améliorer les performances des requêtes pour les tables Iceberg.
+ **Compactage** : les fichiers de données sont fusionnés et réécrits pour supprimer les données obsolètes et regrouper les données fragmentées dans des fichiers plus volumineux et plus efficaces.
+ **Conservation des instantanés** : les instantanés sont des versions horodatées d’une table Iceberg. Les configurations de conservation des instantanés permettent aux clients de définir la durée de conservation des instantanés et le nombre d’instantanés à conserver. La configuration d’un optimiseur de conservation des instantanés peut aider à gérer la charge de stockage en supprimant les instantanés plus anciens et inutiles, ainsi que leurs fichiers sous-jacents associés.
+ **Suppression de fichiers orphelins** : les fichiers orphelins sont des fichiers qui ne sont plus référencés par les métadonnées de la table Iceberg. Ces fichiers peuvent s’accumuler au fil du temps, en particulier après des opérations telles que la suppression de tables ou l’échec de tâches ETL. L'activation de la suppression des fichiers orphelins permet AWS Glue d'identifier et de supprimer périodiquement ces fichiers inutiles, libérant ainsi de l'espace de stockage.
Pour de plus amples informations, veuillez consulter [Optimisation des tables Iceberg](table-optimizers.md).
**Configuration de l’optimisation**
Vous pouvez utiliser les paramètres par défaut ou personnaliser les paramètres pour activer les optimiseurs de table.
**Rôle IAM**
Pour exécuter les optimiseurs de table, le service endosse un rôle IAM en votre nom. Vous pouvez choisir un rôle IAM à l'aide de la liste déroulante. Assurez-vous que le rôle dispose des autorisations requises pour activer le compactage.
Pour en savoir plus sur les autorisations requises pour le rôle IAM, consultez [Conditions préalables requises pour l’optimisation des tables](optimization-prerequisites.md).
**Location**
Pointeur de l'emplacement des données dans un magasin de données que cette définition de table représente.
**Classification**
Valeur de catégorie fournie lors de la création de la table. En général, elle est écrite lors de l'exécution d'un crawler et spécifie le format de la source des données.
**Dernière mise à jour**
Date et heure (UTC) auxquelles cette table a été mise à jour dans Data Catalog.
**Date ajoutée**
Date et heure (UTC) auxquelles cette table a été ajoutée dans Data Catalog.
**Obsolète**
Si AWS Glue détecte qu'une table du Data Catalog n'existe plus dans son magasin de données d'origine, il la marque comme obsolète dans le catalogue de données. Si vous exécutez une tâche qui fait référence à une table obsolète, la tâche peut échouer. Modifiez les tâches qui font référence à des tables obsolètes pour les supprimer en tant que sources et cibles. Nous vous recommandons de supprimer les tables obsolètes lorsqu'ils ne sont plus nécessaires.
**Connexion**
Si AWS Glue nécessite une connexion à votre magasin de données, le nom de la connexion est associé à la table.
### Affichage et gestion des détails d’une table
Pour afficher les détails d'une table existante, choisissez le nom de la table dans la liste, puis **Action, View details** (Action, Afficher les détails).
Les détails de la table comprennent les propriétés de votre table et son schéma. Cette vue affiche le schéma de la table, y compris les noms de colonnes dans l'ordre défini pour la table, les types de données et les colonnes de clés pour les partitions. Si une colonne est de type complexe, vous pouvez choisir **View properties** (Afficher les propriétés) pour afficher les détails de la structure de ce champ, comme illustré dans l'exemple suivant :
```
{
"StorageDescriptor":
{
"cols": {
"FieldSchema": [
{
"name": "primary-1",
"type": "CHAR",
"comment": ""
},
{
"name": "second ",
"type": "STRING",
"comment": ""
}
]
},
"location": "s3://aws-logs-111122223333-us-east-1",
"inputFormat": "",
"outputFormat": "org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat",
"compressed": "false",
"numBuckets": "0",
"SerDeInfo": {
"name": "",
"serializationLib": "org.apache.hadoop.hive.serde2.OpenCSVSerde",
"parameters": {
"separatorChar": "|"
}
},
"bucketCols": [],
"sortCols": [],
"parameters": {},
"SkewedInfo": {},
"storedAsSubDirectories": "false"
},
"parameters": {
"classification": "csv"
}
}
```
Pour plus d'informations sur les propriétés d'une table, comme `StorageDescriptor`, consultez [StorageDescriptor structure](aws-glue-api-catalog-tables.md#aws-glue-api-catalog-tables-StorageDescriptor).
Pour modifier le schéma d'une table, choisissez **Edit schema** (Modifier le schéma) pour ajouter et supprimer des colonnes, modifier les noms de colonnes et modifier les types de données.
Pour comparer différentes versions d'une table, y compris son schéma, choisissez **Comparer les versions** pour voir une side-by-side comparaison des deux versions du schéma d'une table. Pour de plus amples informations, veuillez consulter [Comparaison des versions de schéma de table](#console-tables-schema-comparison).
Pour afficher les fichiers qui constituent une partition Amazon S3, sélectionnez **View partition** (Afficher la partition). Pour les tables Amazon S3, la colonne **Key** (Clé) affiche les clés de partition qui sont utilisées pour partitionner la table dans le magasin de données source. Le partitionnement permet de diviser un tableau en parties connexes en fonction des valeurs d'une colonne clé, telle que la date, le lieu ou le département. Pour plus d'informations sur les partitions, effectuez une recherche sur Internet pour en savoir plus sur « le partitionnement Hive ».
**Note**
Pour obtenir step-by-step des conseils sur l'affichage des détails d'un tableau, consultez le didacticiel **Explore le tableau** dans la console.
### Comparaison des versions de schéma de table
Lorsque vous comparez deux versions de schémas de table, vous pouvez comparer les modifications des lignes imbriquées en développant et en réduisant les lignes imbriquées, comparer les schémas de deux versions et afficher les side-by-side propriétés des tables. side-by-side
Pour comparer les versions
1. Dans la console AWS Glue, choisissez **Tables**, puis **Actions** et choisissez **Comparer les versions**.
![\[La capture d'écran montre le bouton Actions lorsqu'il est sélectionné. Le menu déroulant affiche l'option Comparer les versions.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/catalog-table-compare-versions.png)
1. Choisissez une version à comparer en sélectionnant le menu déroulant des versions. Lorsque vous comparez des schémas, l'onglet Schéma est surligné en orange.
1. Lorsque vous comparez des tables entre deux versions, les schémas des tables s'affichent à gauche et à droite de l'écran. Cela vous permet de déterminer visuellement les modifications en comparant le nom de colonne, le type de données, la clé et les champs de commentaire side-by-side. En cas de modification, une icône colorée indique le type de modification apportée.
+ Supprimé : représenté par une icône rouge, indique l'endroit où la colonne a été supprimée d'une version précédente du schéma de table.
+ Modifié ou déplacé : représenté par une icône bleue, indique l'endroit où la colonne a été modifiée ou déplacée dans une version plus récente du schéma de table.
+ Ajouté : représenté par une icône verte, indique l'endroit où la colonne a été ajoutée à une version plus récente du schéma de table.
+ Modifications imbriquées : représentées par une icône jaune, indiquent où se trouvent les modifications dans la colonne imbriquée. Choisissez la colonne à développer et affichez les colonnes qui ont été supprimées, modifiées, déplacées ou ajoutées.
![\[La capture d'écran affiche la comparaison du schéma de table entre deux versions. L'ancienne version se trouve sur le côté gauche. La version plus récente est à droite. L'icône de suppression se trouve à côté d'une colonne qui a été supprimée de l'ancienne version et qui ne figure plus dans la nouvelle version.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/catalog-table-version-comparison.png)
1. Utilisez la barre de recherche des champs de filtre pour afficher les champs en fonction des caractères que vous saisissez ici. Si vous saisissez un nom de colonne dans l'une ou l'autre des versions de table, les champs filtrés s'affichent dans les deux versions de la table pour vous indiquer l'emplacement des modifications.
1. Pour comparer les propriétés, cliquez sur l'**onglet Propriétés**.
1. Pour arrêter la comparaison des versions, choisissez **Arrêter la comparaison** pour revenir à la liste des tables.
# Création d’index de partition
Au fil du temps, des centaines de milliers de partitions sont ajoutées à une table. L'[GetPartitions API](https://docs.aws.amazon.com/glue/latest/webapi/API_GetPartitions.html) est utilisée pour récupérer les partitions de la table. L’API renvoie des partitions qui correspondent à l’expression fournie dans la demande.
Prenons comme exemple une table *sales\$1data* qui est partitionnée par les clés *Country*, *Category*, *Year*, *Month* et *creationDate*. Si vous souhaitez obtenir des données de ventes pour tous les articles vendus pour la catégorie *Livres* en 2020, après le *2020-08-15*, vous devez faire une demande `GetPartitions` avec l’expression « Category = ’Books’ and creationDate > ’2020-08-15’ » au catalogue de données.
Si aucun index de partition n’est présent sur la table, AWS Glue charge toutes les partitions de la table, puis filtre les partitions chargées à l’aide de l’expression de requête fournie par l’utilisateur dans la demande `GetPartitions`. L’exécution de la requête prend plus de temps à mesure que le nombre de partitions augmente sur une table sans index. Avec un index, la requête `GetPartitions` essaiera de récupérer un sous-ensemble des partitions au lieu de charger toutes les partitions de la table.
**Topics**
+ [À propos des index de partition](#partition-index-1)
+ [Création d’un tableau avec index de partition](#partition-index-creating-table)
+ [Ajout d’un index de partition à une table existante](#partition-index-existing-table)
+ [Description des indexes de partition sur une table](#partition-index-describing)
+ [Limitations de l’utilisation des index de partition](#partition-index-limitations)
+ [Utilisation d'index pour un appel optimisé GetPartitions](#partition-index-getpartitions)
+ [Intégration avec les moteurs](#partition-index-integration-engines)
## À propos des index de partition
Lorsque vous créez un index de partition, vous spécifiez une liste de clés de partition qui existent déjà sur une table donnée. L’index de partition est une sous-liste des clés de partition définies dans la table. Un index de partition peut être créé sur n’importe quelle permutation de clés de partition définie sur la table. Pour la table *sales\$1data* ci-dessus, les index possibles sont (country, category, creationDate), (country, category, year), (country, category), (country), (category, country, year, month), etc.
Data Catalog concaténera les valeurs de partition dans l’ordre fourni au moment de la création de l’index. L’index est créé de manière cohérente à mesure que des partitions sont ajoutées à la table. Des index peuvent être créés pour les types de colonnes String (string, char et varchar) Numeric (int, bigint, long, tinyint, and smallint) et Date (yyyy-MM-dd).
**Types de données pris en charge**
+ Date : date au format ISO, par exemple `YYYY-MM-DD`. Par exemple, date `2020-08-15`. Le format utilise des tirets (‐) pour séparer l’année, le mois et le jour. La plage de dates autorisée pour l’indexation s’étend de `0000-01-01` à `9999-12-31`.
+ String : libellé chaîne entre guillemets simples ou doubles.
+ Char : données en caractères de longueur fixe, avec une longueur spécifiée entre 1 et 255, par exemple char(10).
+ Varchar : données en caractères de longueur variable, avec une longueur spécifiée entre 1 et 65535, par exemple varchar(10).
+ Numeric : int, bigint, long, tinyint, and smallint
Les index sur les types de données Numeric, String et Date prennent en charge les opérateurs =, >, >=, <, <= et BETWEEN. La solution d’indexation ne prend actuellement en charge que l’opérateur logique `AND`. Les sous-expressions avec les opérateurs « LIKE », « IN », « OR » et « NOT » sont ignorées dans l’expression pour le filtrage à l’aide d’un index. Le filtrage de la sous-expression ignorée est effectué sur les partitions récupérées après application du filtrage d’index.
Pour chaque partition ajoutée à une table, un élément d’index correspondant est créé. Pour une table avec ’n’ partitions, 1 index de partition entraînera ’n’ éléments d’index de partition. L’index de partition ’m’ sur la même table se traduira par des éléments d’index de partition ’m\$1n’. Chaque élément d’index de partition sera facturé selon la politique de tarification AWS Glue en vigueur pour le stockage du catalogue de données. Pour plus de détails sur la tarification des objets de stockage, consultez la [tarification AWS Glue](https://aws.amazon.com/glue/pricing/).
## Création d’un tableau avec index de partition
Vous pouvez créer un index de partition lors de la création d’une table. La demande `CreateTable` prend une liste d’[objets `PartitionIndex`](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-PartitionIndex) comme entrée. 3 index de partition au maximum peuvent être créés sur une table donnée. Chaque index de partition nécessite un nom et une liste de `partitionKeys` définie pour la table. Les index créés sur une table peuvent être récupérés à l’aide de l’[API `GetPartitionIndexes`](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-GetPartitionIndexes)
## Ajout d’un index de partition à une table existante
Pour ajouter un index de partition à une table existante, utilisez l’opération `CreatePartitionIndex`. Vous pouvez créer un `PartitionIndex` par opération `CreatePartitionIndex`. L’ajout d’un index n’affecte pas la disponibilité d’une table, car la table reste disponible pendant la création des index.
L’état d’index d’une partition ajoutée est défini sur CREATING et la création des données d’index est lancée. Si le processus de création des index réussit, l’indexStatus est mis à jour sur ACTIVE et pour un processus infructueux, l’état de l’index est mis à jour sur FAILED. La création d’index peut échouer pour plusieurs raisons et vous pouvez utiliser l’opération `GetPartitionIndexes` pour récupérer les détails de l’échec. Les échecs possibles sont :
+ ENCRYPTED\$1PARTITION\$1ERROR – la création d’index sur une table avec des partitions chiffrées n’est pas prise en charge.
+ INVALID\$1PARTITION\$1TYPE\$1DATA\$1ERROR – observé lorsque la valeur `partitionKey` n’est pas une valeur valide pour le type de données `partitionKey` correspondant. Par exemple : un `partitionKey` avec le type de données ’int’ a une valeur ’foo’.
+ MISSING\$1PARTITION\$1VALUE\$1ERROR – observé lorsque le for `partitionValue` pour un `indexedKey` est absent. Cela peut se produire lorsqu’une table n’est pas partitionnée de manière cohérente.
+ UNSUPPORTED\$1PARTITION\$1CHARACTER\$1ERROR – observé lorsque la valeur d’une clé de partition indexée contient les caractères \$1u0000, \$1u0001 ou \$1u0002
+ INTERNAL\$1ERROR – une erreur interne s’est produite lors de la création des index.
## Description des indexes de partition sur une table
Pour extraire les index de partition créés sur une table, utilisez l’opération `GetPartitionIndexes`. La réponse renvoie tous les index de la table, ainsi que le statut actuel de chaque index (`IndexStatus`).
Le `IndexStatus` pour un index de partition sera l’un des suivants :
+ `CREATING` – l’index est en cours de création et n’est pas encore disponible pour utilisation.
+ `ACTIVE` – l’index est prêt à l’emploi. Les requêtes peuvent utiliser l’index pour effectuer une requête optimisée.
+ `DELETING` – l’index est actuellement en cours de suppression et ne peut plus être utilisé. Un index à l’état actif peut être supprimé à l’aide de la demande `DeletePartitionIndex`, qui fait passer l’état de ACTIVE à DELETING.
+ `FAILED` – échec de la création d’index sur une table existante. Chaque table stocke les 10 derniers index ayant échoué.
Les transitions d’état possibles pour les index créés sur une table existante sont :
+ CREATING → ACTIVE → DELETING
+ CREATING → FAILED
## Limitations de l’utilisation des index de partition
Une fois que vous avez créé un index de partition, notez ces modifications apportées aux fonctionnalités de table et de partition :
**Création d’une partition (après ajout d’index)**
Une fois qu’un index de partition est créé sur une table, toutes les nouvelles partitions ajoutées à la table seront validées pour les vérifications de type de données pour les clés indexées. La valeur de partition des clés indexées sera validée pour le format de type de données. Si la vérification du type de données échoue, l’opération de création de partition échouera. Pour la table *sales\$1data*, si un index est créé pour les clés (category, year) où la catégorie est de type `string` et l’année de type `int`, la création de la nouvelle partition avec une valeur de YEAR telle que "foo" échouera.
Une fois les index activés, l’ajout de partitions avec des valeurs de clé indexées ayant les caractères U\$10000, U\$100001 et U\$10002 commencera à échouer.
**Mises à jour des tables**
Une fois qu’un index de partition est créé sur une table, vous ne pouvez pas modifier les noms de clé de partition pour les clés de partition existantes, et vous ne pouvez pas changer le type ou l’ordre des clés qui sont enregistrées avec l’index.
## Utilisation d'index pour un appel optimisé GetPartitions
Lorsque vous appelez `GetPartitions` une table avec un index, vous pouvez inclure une expression et, le cas échéant, Data Catalog utilisera un index si possible. La première clé de l’index doit être passée dans l’expression pour les index à utiliser dans le filtrage. L’optimisation de l’index dans le filtrage est appliquée au mieux. Data Catalog essaie d’utiliser l’optimisation d’index autant que possible, mais en cas d’index manquant ou d’opérateur non pris en charge, il revient à l’implémentation existante de chargement de toutes les partitions.
Pour la table *sales\$1data* ci-dessus, ajoutons l’index [Country, Category, Year]. Si « Country » (Pays) n’est pas passé dans l’expression, l’index enregistré ne pourra pas filtrer les partitions à l’aide d’index. Vous pouvez ajouter jusqu’à 3 index pour prendre en charge divers modèles de requête.
Prenons quelques exemples d’expressions et voyons comment les index fonctionnent dessus :
| Expressions | Comment l’index sera utilisé |
| --- | --- |
| Country = ’US’ | Index sera utilisé pour filtrer les partitions. |
| Country = ’US’ and Category = ’Shoes’ | Index sera utilisé pour filtrer les partitions. |
| Category = ’Shoes’ | Les index ne seront pas utilisés, car la valeur « country » (pays) n’est pas fournie dans l’expression. Toutes les partitions seront chargées pour renvoyer une réponse. |
| Country = ’US’ and Category = ’Shoes’ and Year > ’2018’ | Index sera utilisé pour filtrer les partitions. |
| Country = ’US’ and Category = ’Shoes’ and Year > ’2018’ and month = 2 | L’index sera utilisé pour récupérer toutes les partitions avec pays = "US" and category = "shoes" and year > 2018. Ensuite, le filtrage sur l’expression du mois sera effectué. |
| Country = ’US’ AND Category = ’Shoes’ OR Year > ’2018’ | Les index ne seront pas utilisés, car un opérateur `OR` est présent dans l’expression. |
| Country = ’US’ AND Category = ’Shoes’ AND (Year = 2017 OR Year = ’2018’) | Index sera utilisé pour récupérer toutes les partitions avec country = "US" and category = "shoes", puis un filtrage sur l’expression de l’année sera effectué. |
| Country in (’US’, ’UK’) AND Category = ’Shoes’ | Les index ne seront pas utilisés pour le filtrage, car l’opérateur `IN` n’est pas pris en charge actuellement. |
| Country = ’US’ AND Category in (’Shoes’, ’Books’) | L’index sera utilisé pour récupérer toutes les partitions avec country = "US", puis un filtrage sur l’expression Category sera effectué. |
| Country = ’US’ AND Category in (’Shoes’, ’Books’) AND (creationDate > ’2023-9-01’ | L’index sera utilisé pour récupérer toutes les partitions avec country = "US", avec creationDate > ’2023-9-01’, puis un filtrage sur l’expression Category sera effectué. |
## Intégration avec les moteurs
Redshift Spectrum, Amazon EMR et AWS Glue ETL Spark peuvent utiliser des index pour récupérer des partitions une fois que les index DataFrames sont à l'état ACTIF dans. AWS Glue [Athena](https://docs.aws.amazon.com/athena/latest/ug/glue-best-practices.html#glue-best-practices-partition-index) et les [trames dynamiques AWS Glue d’extraction, de transfert et de chargement](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html#aws-glue-programming-etl-partitions-cat-predicates) vous obligent à suivre des étapes supplémentaires pour utiliser les index à des fins d’amélioration des requêtes.
### Activation du filtrage de partition
Pour activer le filtrage de partition dans Athena, vous devez mettre à jour les propriétés de la table comme suit :
1. Dans la AWS Glue console, sous **Catalogue de données**, sélectionnez **Tables**.
1. Choisissez une table .
1. Sous **Actions**, choisissez **Modifier la table**.
1. Sous **Propriétés de la table**, ajoutez ce qui suit :
+ Clé : `partition_filtering.enabled`
+ Valeur : `true`
1. Cliquez sur **Appliquer**.
Vous pouvez également définir ce paramètre en exécutant une requête [ALTER TABLE SET PROPERTIES](https://docs.aws.amazon.com/athena/latest/ug/alter-table-set-tblproperties.html) dans Athena.
```
ALTER TABLE partition_index.table_with_index
SET TBLPROPERTIES ('partition_filtering.enabled' = 'true')
```
## Mise à jour de tables Data Catalog créées manuellement à l’aide d’crawlers
Vous souhaiterez peut-être créer des AWS Glue Data Catalog tables manuellement, puis les mettre à jour à l'aide de AWS Glue robots d'exploration. Les crawlers respectant un calendrier peuvent ajouter de nouvelles partitions et mettre à jour les tables avec des modifications de schéma. Cela s'applique également aux tables migrées depuis un métastore Apache Hive.
Pour ce faire, lorsque vous définissez un crawler, au lieu de spécifier un ou plusieurs magasins de données en tant que source d'une analyse, vous spécifiez une ou plusieurs tables Data Catalog existantes. L'crawler analyse ensuite les magasins de données spécifiés par les tables du catalogue. Dans ce cas, aucune nouvelle table n’est créée ; au lieu de cela, vos tables créées manuellement sont mises à jour.
Voici d'autres raisons qui peuvent vous amener à vouloir créer manuellement des tables de catalogue et spécifier les tables de catalogue en tant qu'crawler source :
+ Vous voulez choisir le nom de la table de catalogue et de ne pas vous fier à l'algorithme d'attribution de noms de la table de catalogue.
+ Vous souhaitez empêcher de nouvelles tables d'être créées au cas où des fichiers dont le format pourrait perturber la détection de partition soient enregistrés par erreur dans le chemin de la source de données.
Pour de plus amples informations, veuillez consulter [Étape 2 : Choisir des sources de données et des classificateurs.](define-crawler-choose-data-sources.md).
## Propriétés de la table Catalogue de données
Les propriétés de table, ou paramètres, comme on les appelle dans la AWS CLI, sont des chaînes de clés et de valeurs non validées. Vous pouvez définir vos propres propriétés sur la table pour prendre en charge les utilisations du Catalogue de données en dehors d' AWS Glue. D'autres services utilisant le catalogue de données peuvent également le faire. AWS Glue définit certaines propriétés de table lors de l'exécution de jobs ou de robots d'exploration. Sauf indication contraire, ces propriétés sont destinées à un usage interne. Nous ne garantissons pas le fait qu'elles continueront d'exister sous leur forme actuelle, et nous ne garantissons pas le comportement du produit si ces propriétés sont modifiées manuellement.
Pour plus d'informations sur les propriétés de table définies par AWS Glue les robots d'exploration, consultez[Paramètres définis sur les tables du Catalogue de données par un Crawler](table-properties-crawler.md).
# Intégration aux tables Amazon S3
AWS Glue L'intégration du catalogue de données à Amazon S3 Tables vous permet de découvrir, d'interroger et de joindre des tables S3 aux données des lacs de données Amazon S3 à l'aide d'un seul catalogue. Lorsque vous intégrez des tables S3 au catalogue de données, le service crée une structure de catalogue fédérée qui mappe les ressources des tables S3 aux objets du AWS Glue catalogue :
+ Un bucket de table S3 devient un catalogue dans le catalogue de données
+ Un espace de noms S3 devient une AWS Glue base de données
+ Une table S3 devient une AWS Glue table
## Contrôles d’accès
Le catalogue de données prend en charge deux modes de contrôle d'accès pour l'intégration des tables S3 :
+ **Contrôle d'accès IAM** — Utilise les politiques IAM pour contrôler l'accès aux tables S3 et au catalogue de données. Dans cette approche, vous devez disposer d'autorisations IAM sur les ressources des tables S3 et sur les objets du catalogue de données pour accéder aux ressources.
+ **AWS Lake Formation contrôle d'accès** — Utilise AWS Lake Formation des autorisations en plus des autorisations AWS Glue IAM pour contrôler l'accès aux tables S3 via le catalogue de données. Dans ce mode, les principaux ont besoin d'autorisations IAM pour interagir avec le catalogue de données, et les AWS Lake Formation autorisations déterminent les ressources du catalogue (bases de données, tables, colonnes, lignes) auxquelles le principal peut accéder. Ce mode prend en charge à la fois un contrôle d'accès grossier (autorisations au niveau de la base de données et au niveau de la table) et un contrôle d'accès détaillé (sécurité au niveau des colonnes et au niveau des lignes). Lorsqu'un rôle enregistré est configuré et que la vente d'informations d'identification est activée, les autorisations IAM de S3 Tables ne sont pas requises pour le principal, car il vend des informations AWS Lake Formation d'identification au nom du principal en utilisant le rôle enregistré. AWS Lake Formation le contrôle d'accès prend également en charge la vente d'informations d'identification pour les moteurs d'analyse tiers. Pour plus d'informations, consultez la section [Création d'un catalogue de tables S3](https://docs.aws.amazon.com/lake-formation/latest/dg/create-s3-tables-catalog.html) dans le *manuel du AWS Lake Formation développeur*.
Vous pouvez passer d'un mode de contrôle d'accès à un autre au fur et à mesure de l'évolution de vos besoins.
## Hiérarchie du catalogue pour le montage automatique
Lorsque vous intégrez des tables S3 au catalogue de données à l'aide de la console de gestion Amazon S3, la console crée un catalogue fédéré appelé `s3tablescatalog` dans le catalogue de données de votre compte dans cette AWS région. Ce catalogue fédéré sert de catalogue parent pour tous les compartiments de tables S3 existants et futurs de ce compte et de cette région. L'intégration mappe les ressources du bucket de tables Amazon S3 dans la hiérarchie suivante :
+ **Catalogue fédéré** — `s3tablescatalog` (créé automatiquement)
+ **Catalogues enfants** : chaque compartiment de table S3 devient un catalogue enfant sous `s3tablescatalog`
+ **Bases de données** : chaque espace de noms S3 dans un compartiment de table devient une base de données
+ **Tables** — Chaque table S3 au sein d'un espace de noms devient une table
Par exemple, si vous avez un compartiment de table S3 nommé « analytics-bucket » avec un espace de noms « sales » contenant une table « transactions », le chemin complet du catalogue de données serait le suivant : `s3tablescatalog/analytics-bucket/sales/transactions`
Cette hiérarchie en quatre parties s'applique aux scénarios de même compte dans lesquels les tables S3 et le catalogue de données se trouvent dans le même compte. AWS Pour les scénarios entre comptes, vous montez manuellement des compartiments de table S3 individuels dans le catalogue de données, ce qui crée une hiérarchie en trois parties.
## Régions prises en charge
L'intégration des tables S3 au catalogue de données est disponible dans les AWS régions suivantes :
| Code région | Nom de la région |
| --- | --- |
| us-east-1 | USA Est (Virginie du Nord) |
| us-east-2 | USA Est (Ohio) |
| us-west-1 | USA Ouest (Californie du Nord) |
| us-west-2 | USA Ouest (Oregon) |
| af-south-1 | Afrique (Le Cap) |
| ap-east-1 | Asie-Pacifique (Hong Kong) |
| ap-east-2 | Asie-Pacifique (Taipei) |
| ap-northeast-1 | Asie-Pacifique (Tokyo) |
| ap-northeast-2 | Asie-Pacifique (Séoul) |
| ap-northeast-3 | Asie-Pacifique (Osaka) |
| ap-south-1 | Asie-Pacifique (Mumbai) |
| ap-south-2 | Asie-Pacifique (Hyderabad) |
| ap-southeast-1 | Asie-Pacifique (Singapour) |
| ap-southeast-2 | Asie-Pacifique (Sydney) |
| ap-southeast-3 | Asie-Pacifique (Jakarta) |
| ap-southeast-4 | Asie-Pacifique (Melbourne) |
| ap-southeast-5 | Asie-Pacifique (Malaisie) |
| ap-southeast-6 | Asie-Pacifique (Nouvelle Zélande) |
| ap-southeast-7 | Asie-Pacifique (Thaïlande) |
| ca-central-1 | Canada (Centre) |
| ca-west-1 | Canada-Ouest (Calgary) |
| eu-central-1 | Europe (Francfort) |
| eu-central-2 | Europe (Zurich) |
| eu-north-1 | Europe (Stockholm) |
| eu-south-1 | Europe (Milan) |
| eu-south-2 | Europe (Espagne) |
| eu-west-1 | Europe (Irlande) |
| eu-west-2 | Europe (Londres) |
| eu-west-3 | Europe (Paris) |
| il-central-1 | Israël (Tel Aviv) |
| mx-central-1 | Mexique (Centre) |
| sa-east-1 | Amérique du Sud (Sao Paulo) |
**Topics**
+ [Contrôles d’accès](#s3-tables-access-controls)
+ [Hiérarchie du catalogue pour le montage automatique](#s3-tables-catalog-hierarchy)
+ [Régions prises en charge](#s3-tables-supported-regions)
+ [Conditions préalables](s3tables-catalog-prerequisites.md)
+ [Activation de l'intégration des tables S3 au catalogue de données](enable-s3-tables-catalog-integration.md)
+ [Ajout de bases de données et de tables au catalogue de tables S3](create-databases-tables-s3-catalog.md)
+ [Partage d'objets du catalogue S3 Tables](share-s3-tables-catalog.md)
+ [Gestion de l'intégration des tables S3](manage-s3-tables-catalog-integration.md)
# Conditions préalables
Avant de créer un catalogue fédéré pour les tables S3 dans le catalogue de AWS Glue données, assurez-vous que votre principal IAM (utilisateur ou rôle) dispose des autorisations requises.
## Autorisations IAM requises
Votre principal IAM a besoin des autorisations suivantes pour activer l'intégration des tables S3 :
**AWS Glue autorisations** :
+ `glue:CreateCatalog`— Nécessaire pour créer le `s3tablescatalog` catalogue fédéré
+ `glue:GetCatalog`— Nécessaire pour consulter les détails du catalogue
+ `glue:GetDatabase`— Nécessaire pour afficher les espaces de noms S3 sous forme de bases de données
+ `glue:GetTable`— Nécessaire pour afficher les tables S3
+ `glue:passConnection`— Accorde au principal appelant le droit de déléguer la `aws:s3tables` connexion au AWS Glue service
**Autorisations S3 Tables** (pour le contrôle d'accès IAM) :
+ `s3tables:CreateTableBucket`
+ `s3tables:GetTableBucket`
+ `s3tables:CreateNamespace`
+ `s3tables:GetNamespace`
+ `s3tables:ListNamespaces`
+ `s3tables:CreateTable`
+ `s3tables:GetTable`
+ `s3tables:ListTables`
+ `s3tables:UpdateTableMetadataLocation`
+ `s3tables:GetTableMetadataLocation`
+ `s3tables:GetTableData`
+ `s3tables:PutTableData`
## Exemple de politique IAM
La politique IAM suivante fournit les autorisations minimales requises pour permettre l'intégration des tables S3 au catalogue de données en mode IAM :
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "GlueDataCatalogPermissions",
"Effect": "Allow",
"Action": [
"glue:CreateCatalog",
"glue:GetCatalog",
"glue:GetDatabase",
"glue:GetTable"
],
"Resource": [
"arn:aws:glue:region:account-id:catalog/s3tablescatalog",
"arn:aws:glue:region:account-id:database/s3tablescatalog/*/*",
"arn:aws:glue:region:account-id:table/s3tablescatalog/*/*/*"
]
},
{
"Sid": "S3TablesDataAccessPermissions",
"Effect": "Allow",
"Action": [
"s3tables:GetTableBucket",
"s3tables:GetNamespace",
"s3tables:GetTable",
"s3tables:GetTableMetadataLocation",
"s3tables:GetTableData"
],
"Resource": [
"arn:aws:s3tables:region:account-id:bucket/*",
"arn:aws:s3tables:region:account-id:bucket/*/table/*"
]
}
]
}
```
# Activation de l'intégration des tables S3 au catalogue de données
Vous pouvez activer l'intégration des tables S3 au catalogue de AWS Glue données à l'aide de la console de gestion Amazon S3 ou AWS CLI. Lorsque vous activez l'intégration à l'aide de la console, vous AWS créez un catalogue fédéré nommé `s3tablescatalog` qui découvre et monte automatiquement tous les compartiments de table S3 de votre AWS compte et de votre région.
## Activer l'intégration des tables S3 à l'aide de la console de gestion Amazon S3
1. Ouvrez la console Amazon S3 à l'adresse [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Dans le volet de navigation de gauche, choisissez **Compartiments de tables**.
1. Choisissez **Créer un compartiment de tables**.
1. Saisissez un **Nom du compartiment de table** et veillez à ce que la case **Activer l’intégration** soit cochée.
1. Choisissez **Créer un compartiment de tables**.
Amazon S3 intègre automatiquement vos compartiments de table dans cette région. La première fois que vous intégrez des compartiments de table dans une région, Amazon S3 les crée `s3tablescatalog` dans le catalogue de données de cette région.
Une fois le catalogue créé, tous les compartiments de tables S3 de votre compte et de votre région sont automatiquement montés en tant que catalogues enfants. Vous pouvez consulter les bases de données (espaces de noms) et les tables en accédant au catalogue dans le catalogue de données.
## Activez l'intégration des tables S3 à l'aide de AWS CLI
Utilisez la `glue create-catalog` commande pour créer le `s3tablescatalog` catalogue.
```
aws glue create-catalog \
--name "s3tablescatalog" \
--catalog-input '{
"Description": "Federated catalog for S3 Tables",
"FederatedCatalog": {
"Identifier": "arn:aws:s3tables:region:account-id:bucket/*",
"ConnectionName": "aws:s3tables"
},
"CreateDatabaseDefaultPermissions": [{
"Principal": {
"DataLakePrincipalIdentifier": "IAM_ALLOWED_PRINCIPALS"
},
"Permissions": ["ALL"]
}],
"CreateTableDefaultPermissions": [{
"Principal": {
"DataLakePrincipalIdentifier": "IAM_ALLOWED_PRINCIPALS"
},
"Permissions": ["ALL"]
}]
}'
```
Remplacez *region* par votre AWS région et *account-id* par votre numéro de AWS compte.
## Vérification de l'intégration
Après avoir créé le catalogue, vous pouvez vérifier que les compartiments de table S3 sont montés en répertoriant les catalogues enfants :
```
aws glue get-catalogs \
--parent-catalog-id s3tablescatalog
```
# Ajout de bases de données et de tables au catalogue de tables S3
Assurez-vous de disposer des autorisations nécessaires pour répertorier et créer des catalogues, des bases de données et des tables dans le catalogue de données de votre région. Assurez-vous que l'intégration de S3 Tables est activée dans votre AWS compte et dans votre région.
## Ajouter une base de données au catalogue de tables S3
### Ajouter une base de données (console)
1. Ouvrez la AWS Glue console à la [https://console.aws.amazon.com/glue/maison](https://console.aws.amazon.com/glue/home).
1. Dans le panneau de navigation de gauche, sélectionnez **Bases de données**.
1. Choisissez **Ajouter une base de données**.
1. Choisissez **Glue Database dans S3 Tables Federated Catalog**.
1. Entrez un nom unique pour la base de données.
1. Sélectionnez le catalogue cible qui correspond à un compartiment de tables dans S3 Tables.
1. Choisissez **Create database** (Créer une base de données).
### Ajouter une base de données (AWS CLI)
```
aws glue create-database \
--region region \
--catalog-id "account-id:s3tablescatalog/my-catalog" \
--database-input '{"Name": "my-database"}'
```
## Ajouter une table au catalogue de tables S3
### Ajouter une table (console)
1. Ouvrez la AWS Glue console à la [https://console.aws.amazon.com/glue/maison](https://console.aws.amazon.com/glue/home).
1. Dans le volet de navigation de gauche, choisissez **Tables**.
1. Sélectionnez le catalogue S3 Tables approprié dans la liste déroulante du catalogue.
1. Choisissez **Ajouter un tableau**.
1. Entrez un nom unique pour votre table.
1. Vérifiez que le catalogue S3 Tables correct est sélectionné dans la liste déroulante du catalogue.
1. Sélectionnez la base de données dans la liste déroulante des bases de données.
1. Entrez le schéma de table en saisissant un code JSON ou en ajoutant chaque colonne individuellement.
1. Choisissez **Créer un tableau**.
### Ajouter un tableau (AWS CLI)
```
aws glue create-table \
--region region \
--catalog-id "account-id:s3tablescatalog/my-catalog" \
--database-name "my-database" \
--table-input '{
"Name": "my-table",
"Parameters": {
"classification": "",
"format": "ICEBERG"
},
"StorageDescriptor": {
"Columns": [
{"Name": "id", "Type": "int", "Parameters": {}},
{"Name": "val", "Type": "string", "Parameters": {}}
]
}
}'
```
# Partage d'objets du catalogue S3 Tables
Lorsque vous utilisez le contrôle d'accès IAM, vous pouvez partager des objets du catalogue S3 Tables avec d'autres utilisateurs à l'aide de liens de AWS Glue ressources pour le partage entre les mêmes comptes. Pour le partage entre comptes, vous pouvez partager des compartiments de table S3 avec un autre AWS compte et le rôle ou l'utilisateur IAM du compte destinataire peut créer un objet de AWS Glue catalogue à l'aide du compartiment de table partagé.
## Partage au sein d'un même compte à l'aide de liens vers des ressources
Les liens vers les ressources vous permettent de créer des références aux AWS Glue bases de données et aux `s3tablescatalog` tables figurant dans votre catalogue AWS Glue par défaut. Cela est utile pour organiser l'accès aux données ou créer des groupements logiques de tables.
### Création d'un lien vers une ressource (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, sélectionnez **Catalogues**.
1. Dans la liste **Catalogue**, sélectionnez **s3tablescatalog**.
1. Sélectionnez le tableau que vous souhaitez partager dans le`s3tablescatalog`.
1. Choisissez **Actions**, puis sélectionnez **Créer un lien vers une ressource**.
1. Dans **Nom du lien de ressource**, entrez un nom pour le lien de ressource.
1. Pour la **base de données cible**, sélectionnez la base de données dans laquelle vous souhaitez créer le lien de ressource.
1. (Facultatif) Sous **Description**, entrez une description.
1. Choisissez **Créer**.
Le lien vers la ressource apparaît dans la base de données cible et pointe vers la table d'origine dans`s3tablescatalog`.
### Créer des liens vers des ressources (AWS CLI)
Créez un lien vers une ressource de base de données :
```
aws glue create-database \
--database-name "my-database-resource-link" \
--database-input '{
"Name": "sales_data_link",
"TargetDatabase": {
"CatalogId": "account-id:s3tablescatalog/analytics-bucket",
"DatabaseName": "sales"
}
}'
```
Créez un lien vers une ressource de table :
```
aws glue create-table \
--table-name "my-table-resource-link" \
--table-input '{
"Name": "sales_data_link",
"TargetTable": {
"CatalogId": "account-id:s3tablescatalog/analytics-bucket",
"DatabaseName": "sales",
"Name": "transactions"
}
}'
```
# Gestion de l'intégration des tables S3
## Activer AWS Lake Formation
Vous pouvez activer votre catalogue AWS Lake Formation de tables S3 lorsque vous souhaitez adapter vos exigences en matière de gouvernance des données. AWS Lake Formation fournit des autorisations de type base de données pour gérer un accès précis, dimensionner les autorisations à l'aide d'un accès basé sur des balises et octroyer des autorisations en fonction d'attributs utilisateur tels que les associations de groupes à vos tables dans S3 Tables.
Accédez à la console AWS Lake Formation de gestion AWS Lake Formation pour activer votre catalogue de tables S3 dans AWS Glue. Pour plus d'informations, consultez la section [Création d'un catalogue de tables S3](https://docs.aws.amazon.com/lake-formation/latest/dg/create-s3-tables-catalog.html) dans le *manuel du AWS Lake Formation développeur*.
## Supprimer l'intégration des tables S3
Vous pouvez supprimer l'intégration des tables S3 en supprimant l'intégration du catalogue dans le catalogue de données. Cette opération supprime uniquement les métadonnées du catalogue de données et non les ressources des tables S3.
Assurez-vous de disposer des autorisations nécessaires pour répertorier, modifier et supprimer des objets du catalogue AWS Glue.
### Supprimer l'intégration (console)
1. Ouvrez la AWS Glue console à la [https://console.aws.amazon.com/glue/maison](https://console.aws.amazon.com/glue/home).
1. Dans le volet de navigation, sélectionnez **Catalogues**.
1. Dans la liste **Catalogue**, sélectionnez **s3tablescatalog**.
1. Sélectionnez **Delete (Supprimer)**.
1. Vérifiez que la suppression du catalogue entraîne également la suppression de tous les objets de catalogue associés dans le catalogue de données.
1. Sélectionnez **Delete (Supprimer)**.
### Supprimer l'intégration (AWS CLI)
```
aws glue delete-catalog \
--region region \
--catalog-id "s3tablescatalog"
```
# Intégration à d'autres AWS services
Bien que vous puissiez utiliser AWS Glue crawler s pour remplir le catalogue AWS Glue Data Catalog, plusieurs AWS services peuvent automatiquement s'intégrer au catalogue et le remplir pour vous. Les sections suivantes fournissent des informations supplémentaires sur les cas d'utilisation spécifiques pris en charge par AWS les services qui peuvent alimenter le catalogue de données.
**Topics**
+ [AWS Lake Formation](#lf-dc)
+ [Amazon Athena](#ate-dc)
## AWS Lake Formation
AWS Lake Formation est un service qui facilite la configuration d'un lac de données sécurisé dans AWS. Lake Formation est construite sur AWS Glue, et Lake Formation et AWS Glue partage la même chose AWS Glue Data Catalog. Vous pouvez enregistrer l'emplacement de vos données Amazon S3 auprès de Lake Formation et utiliser la console Lake Formation pour créer des bases de données et des tables dans le catalogue de AWS Glue données, définir des politiques d'accès aux données et auditer l'accès aux données dans votre lac de données à partir d'un emplacement central. Vous pouvez utiliser le contrôle précis des accès de Lake Formation pour gérer les ressources de votre catalogue de données existantes et les emplacements de données Amazon S3.
Avec les données enregistrées auprès de Lake Formation, vous pouvez partager en toute sécurité les ressources du catalogue de données entre les principaux responsables, les AWS comptes, les AWS organisations et les unités organisationnelles d'IAM.
Pour plus d'informations sur la création de ressources de catalogue de données à l'aide de Lake Formation, consultez la section [Création de tables et de bases de données de catalogue de données](https://docs.aws.amazon.com/lake-formation/latest/dg/populating-catalog.html) dans le guide du AWS Lake Formation développeur.
## Amazon Athena
Amazon Athena utilise le catalogue de données pour stocker et récupérer les métadonnées des tables correspondant aux données Amazon S3 de votre AWS compte. Les métadonnées de la table permettent au moteur de requête Athena de savoir comment trouver, lire et traiter les données que vous souhaitez interroger.
Vous pouvez remplir le AWS Glue Data Catalog en utilisant directement les instructions `CREATE TABLE` Athena. Vous pouvez définir et remplir manuellement le schéma et les métadonnées de partition dans le catalogue de données sans avoir à exécuter un robot.
1. Dans la console Athena, créez une base de données qui stockera les métadonnées de la table dans le catalogue de données.
1. Utilisez l’instruction `CREATE EXTERNAL TABLE` pour définir le schéma de votre source de données.
1. Utilisez la clause `PARTITIONED BY` pour définir les clés de partition si vos données sont partitionnées.
1. Utilisez la clause `LOCATION` pour spécifier le chemin d’accès à Amazon S3 où vos fichiers de données réels sont stockés.
1. Exécutez l'instruction `CREATE TABLE`.
Cette requête crée les métadonnées de table dans le catalogue de données en fonction du schéma et des partitions que vous avez définis, sans réellement analyser les données.
Vous pouvez interroger la table dans Athena, qui utilisera les métadonnées du catalogue de données pour accéder à vos fichiers de données et les interroger dans Amazon S3.
Pour plus d’informations, consultez [Creating databases and tables](https://docs.aws.amazon.com/athena/latest/ug/work-with-data.html) dans le Guide de l’utilisateur Amazon Athena.
# Paramètres du catalogue de données
Les paramètres du catalogue de données contiennent des options permettant de définir les options de chiffrement et d’autorisations pour le catalogue de données de votre compte.
![\[La capture d'écran montre le modal des paramètres du catalogue de données.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/data_catalog_settings.png)
**Pour modifier le contrôle d'accès détaillé du catalogue de données.**
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. Choisissez une option de chiffrement.
+ **Chiffrement des métadonnées** : cochez cette case pour chiffrer les métadonnées dans votre catalogue de données. Les métadonnées sont chiffrées au repos à l'aide de la clé AWS Key Management Service (AWS KMS) que vous spécifiez. Pour de plus amples informations, veuillez consulter [Chiffrement de votre catalogue de données](encrypt-glue-data-catalog.md).
+ **Chiffrer les mots de passe de connexion** : cochez cette case pour chiffrer les mots de passe dans l'objet de connexion AWS Glue lorsque la connexion est créée ou mise à jour. Les mots de passe sont chiffrés à l'aide de la AWS KMS clé que vous spécifiez. Lorsque les mots de passe sont renvoyés, ils sont chiffrés. Cette option dispose d'un paramètre global pour toutes les connexions AWS Glue dans le catalogue de données. Si vous décochez cette case, les mots de passe précédemment chiffrés restent chiffrés à l'aide de la clé utilisée lors de leur création ou de leur mise à jour. Pour plus d’informations sur les connexions AWS Glue, consultez [Connexion aux données](glue-connections.md).
Lorsque vous activez cette option, choisissez une AWS KMS clé ou choisissez **Enter a key ARN** et fournissez le Amazon Resource Name (ARN) pour la clé. Entrez l'ARN sous la forme ` arn:aws:kms:region:account-id:key/key-id `. Vous pouvez également fournir l'ARN sous la forme d'un alias de clé, (par exemple, ` arn:aws:kms:region:account-id:alias/alias-name `).
**Important**
Si cette option est sélectionnée, tout utilisateur ou rôle qui crée ou met à jour une connexion doit dispose d'une autorisation `kms:Encrypt` sur la clé KMS spécifiée.
Pour de plus amples informations, veuillez consulter [Chiffrement des mots de passe de connexion](encrypt-connection-passwords.md).
1. Sélectionnez **Settings (Paramètres)**, puis dans l'éditeur **Permissions (Autorisations)**, ajoutez l'instruction de politique pour modifier le contrôle d'accès détaillé du catalogue de données pour votre compte. Une seule politique peut être attachée à un catalogue de données à la fois. Vous pouvez coller une politique ressource JSON dans ce contrôle. Pour de plus amples informations, veuillez consulter [Politiques basées sur les ressources au sein de Glue AWS](security_iam_service-with-iam.md#security_iam_service-with-iam-resource-based-policies).
1. Sélectionnez **Enregistrer** pour mettre à jour le catalogue de données avec les modifications que vous avez apportées.
Vous pouvez également utiliser les opérations d'API AWS Glue pour placer, obtenir et supprimer des politiques de ressources. Pour de plus amples informations, veuillez consulter [Sécurité APIs dans AWS Glue](aws-glue-api-jobs-security.md).
# Remplissage et gestion des tables transactionnelles
[Apache Iceberg](https://iceberg.apache.org/), [Apache Hudi](https://hudi.incubator.apache.org/) et Linux Foundation [Delta Lake](https://delta.io/) sont des formats de table open source conçus pour gérer l’analytique des données à grande échelle et les charges de travail des lacs de données dans Apache Spark.
Vous pouvez remplir les tables Iceberg, Hudi et Delta Lake à l' AWS Glue Data Catalog aide des méthodes suivantes :
+ AWS Glue crawler; — AWS Glue crawler s peut automatiquement découvrir et renseigner les métadonnées des tables Iceberg, Hudi et Delta Lake dans le catalogue de données. Pour de plus amples informations, veuillez consulter [Utilisation de robots pour alimenter le catalogue de données](add-crawler.md).
+ AWS Glue Tâches ETL : vous pouvez créer des tâches ETL pour écrire des données dans les tables Iceberg, Hudi et Delta Lake et renseigner leurs métadonnées dans le catalogue de données. Pour plus d'informations, consultez la section [Utilisation de frameworks de lacs de données avec des tâches AWS Glue ETL](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-datalake-native-frameworks.html).
+ AWS Glue console, AWS Lake Formation console AWS CLI ou API : vous pouvez utiliser la AWS Glue console, la console Lake Formation ou l'API pour créer et gérer les définitions de tables Iceberg dans le catalogue de données.
**Topics**
+ [Création de tables Apache Iceberg](#creating-iceberg-tables)
+ [Optimisation des tables Iceberg](table-optimizers.md)
+ [Optimisation des performances des requêtes pour les tables Iceberg](iceberg-column-statistics.md)
## Création de tables Apache Iceberg
Vous pouvez créer des tables Apache Iceberg qui utilisent le format de données Apache Parquet dans l’ AWS Glue Data Catalog avec des données résidant dans Amazon S3. Une table dans le catalogue de données correspond à la définition des métadonnées qui représente les données dans un entrepôt de données. Par défaut, AWS Glue crée des tables Iceberg v2. Pour connaître la différence entre les tables v1 et v2, consultez la section [Modifications de version de format](https://iceberg.apache.org/spec/#appendix-e-format-version-changes) dans la documentation Apache Iceberg.
[Apache Iceberg](https://iceberg.apache.org/) est un format de table ouvert pour les jeux de données analytiques très volumineux. Iceberg permet de modifier facilement votre schéma, également ce que l’on appelle l’évolution du schéma, ce qui signifie que les utilisateurs peuvent ajouter, renommer ou supprimer des colonnes d’une table de données sans perturber les données sous-jacentes. Iceberg fournit également une prise en charge pour la gestion des versions des données, ce qui permet aux utilisateurs de suivre les modifications apportées aux données au fil du temps. Cela active la fonctionnalité Time Travel, qui permet aux utilisateurs d’accéder aux versions historiques des données, de les interroger, mais aussi d’analyser les modifications apportées aux données entre les mises à jour et les suppressions.
Vous pouvez utiliser AWS Glue la console Lake Formation ou l'`CreateTable`opération de l' AWS Glue API pour créer une table Iceberg dans le catalogue de données. Pour plus d'informations, consultez [CreateTable action (Python : create\$1table](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-CreateTable)).
Lorsque vous créez une table Iceberg dans le catalogue de données, vous devez spécifier le format de la table et le chemin d’accès au fichier de métadonnées dans Amazon S3 pour pouvoir effectuer des lectures et des écritures.
Vous pouvez utiliser Lake Formation pour sécuriser votre table Iceberg à l'aide d'autorisations de contrôle d'accès précises lorsque vous enregistrez l'emplacement des données Amazon S3 auprès de celui-ci. AWS Lake Formation Pour les données source dans Amazon S3 et les métadonnées qui ne sont pas enregistrées auprès de Lake Formation, l'accès est déterminé par les politiques d'autorisation IAM pour Amazon S3 et AWS Glue les actions. Pour plus d’informations, consultez [Managing permissions](https://docs.aws.amazon.com/lake-formation/latest/dg/managing-permissions.html).
**Note**
Le catalogue de données ne prend pas en charge la création de partitions ni l’ajout de propriétés de table Iceberg.
### Conditions préalables
Pour créer des tables Iceberg dans le catalogue de données et configurer les autorisations d’accès aux données de Lake Formation, vous devez remplir les conditions suivantes :
1.
**Autorisations requises pour créer des tables Iceberg sans les données enregistrées auprès de Lake Formation :**
Outre les autorisations requises pour créer une table dans le catalogue de données, le créateur de table exige les autorisations suivantes :
+ `s3:PutObject` sur la ressource arn:aws:s3:::\$1bucketName\$1
+ `s3:GetObject` sur la ressource arn:aws:s3:::\$1bucketName\$1
+ `s3:DeleteObject` sur la ressource arn:aws:s3:::\$1bucketName\$1
1.
**Autorisations requises pour créer des tables Iceberg avec des données enregistrées auprès de Lake Formation :**
Pour utiliser Lake Formation afin de gérer et de sécuriser les données de votre lac de données, enregistrez votre site Amazon S3 contenant les données pour les tables auprès de Lake Formation. Cela permet à Lake Formation de vendre des informations d'identification à AWS des services d'analyse tels qu'Athena, Redshift Spectrum et Amazon EMR pour accéder aux données. Pour plus d’informations sur l’enregistrement d’un emplacement Amazon S3, consultez [Adding an Amazon S3 location to your data lake](https://docs.aws.amazon.com/lake-formation/latest/dg/register-data-lake.html).
Un principal qui lit et écrit les données sous-jacentes enregistrées auprès de Lake Formation doit disposer des autorisations suivantes :
+ `lakeformation:GetDataAccess`
+ `DATA_LOCATION_ACCESS`
Un principal qui possède des autorisations de localisation des données sur un emplacement possède également des autorisations d’emplacement sur tous les sites enfant.
Pour plus d’informations sur les autorisations d’emplacement des données, consultez l’ulink [Underlying data access control](https://docs.aws.amazon.com/lake-formation/latest/dg/access-control-underlying-data.html#data-location-permissions).
Pour activer le compactage, le service doit endosser un rôle IAM autorisé à mettre à jour les tables dans le catalogue de données. Pour plus d’informations, consultez [Conditions préalables requises pour l’optimisation des tables](optimization-prerequisites.md).
### Création d’une table Iceberg
Vous pouvez créer des tables Iceberg v1 et v2 à l'aide AWS Glue de la console Lake Formation ou AWS Command Line Interface comme indiqué sur cette page. Vous pouvez également créer des tables Iceberg à l’aide d’ AWS Glue crawler. Pour plus d’informations, consultez [Data Catalog and Crawlers](https://docs.aws.amazon.com/glue/latest/dg/catalog-and-crawler.html) dans le Guide du développeur AWS Glue .
**Pour créer une table Iceberg**
------
#### [ 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. Sous catalogue de données, choisissez **Tables**, puis utilisez le bouton **Créer une table** pour spécifier les attributs suivants :
+ **Nom de table** : saisissez un nom pour la table. Si vous utilisez Athena pour accéder à des tables, utilisez ces [conseils de dénomination](https://docs.aws.amazon.com/athena/latest/ug/tables-databases-columns-names.html) figurant dans le Guide de l’utilisateur Amazon Athena.
+ **Base de données** : choisissez une base de données existante ou créez-en une.
+ **Description** : description de la table. Vous pouvez écrire une description vous aidant à comprendre le contenu de la table.
+ **Format de tableau** : pour **Format de tableau**, choisissez Apache Iceberg.
+ **Activer le compactage** : choisissez **Activer le compactage** pour compacter les petits objets Amazon S3 de la table en objets plus grands.
+ **Rôle IAM** : pour exécuter le compactage, le service endosse un rôle IAM en votre nom. Vous pouvez choisir un rôle IAM à l'aide de la liste déroulante. Assurez-vous que le rôle dispose des autorisations requises pour activer le compactage.
Pour en savoir plus sur les autorisations nécessaires, consultez [Conditions préalables requises pour l’optimisation des tables](optimization-prerequisites.md).
+ **Emplacement** : indiquez le chemin d’accès au dossier dans Amazon S3 qui stocke la table de métadonnées. Iceberg a besoin d’un fichier de métadonnées et d’un emplacement dans le catalogue de données pour pouvoir effectuer des lectures et des écritures.
+ **Schéma** : choisissez **Ajouter des colonnes** pour ajouter des colonnes et les types de données des colonnes. Vous avez la possibilité de créer une table vide et de mettre à jour le schéma ultérieurement. Le catalogue de données prend en charge les types de données Hive. Pour plus d’informations, consultez [Hive data types](https://cwiki.apache.org/confluence/plugins/servlet/mobile?contentId=27838462#content/view/27838462).
Iceberg vous permet de faire évoluer le schéma et la partition après avoir créé la table. Vous pouvez utiliser des [requêtes Athena](https://docs.aws.amazon.com/athena/latest/ug/querying-iceberg-evolving-table-schema.html) pour mettre à jour le schéma de table et des [requêtes Spark](https://iceberg.apache.org/docs/latest/spark-ddl/#alter-table-sql-extensions) pour mettre à jour les partitions.
------
#### [ AWS CLI ]
```
aws glue create-table \
--database-name iceberg-db \
--region us-west-2 \
--open-table-format-input '{
"IcebergInput": {
"MetadataOperation": "CREATE",
"Version": "2"
}
}' \
--table-input '{"Name":"test-iceberg-input-demo",
"TableType": "EXTERNAL_TABLE",
"StorageDescriptor":{
"Columns":[
{"Name":"col1", "Type":"int"},
{"Name":"col2", "Type":"int"},
{"Name":"col3", "Type":"string"}
],
"Location":"s3://DOC_EXAMPLE_BUCKET_ICEBERG/"
}
}'
```
------
**Topics**
+ [Conditions préalables](#iceberg-prerequisites)
+ [Création d’une table Iceberg](#create-iceberg-table)
# Optimisation des tables Iceberg
AWS Glue prend en charge plusieurs options d'optimisation des tables afin d'améliorer la gestion et les performances des tables Apache Iceberg utilisées par les moteurs AWS d'analyse et les tâches ETL. Ces optimiseurs permettent d’utiliser efficacement le stockage, d’améliorer les performances des requêtes et de gérer efficacement les données. Il existe trois types d'optimiseurs de table disponibles dans AWS Glue :
+ **Compactage** : le compactage des données compacte les petits fichiers de données afin de réduire l’utilisation du stockage et d’améliorer les performances de lecture. Les fichiers de données sont fusionnés et réécrits pour supprimer les données obsolètes et regrouper les données fragmentées dans des fichiers plus volumineux et plus efficaces. Vous pouvez configurer le compactage pour qu’il s’exécute automatiquement.
Binpack est la stratégie de compactage par défaut d’Apache Iceberg. Elle combine des fichiers de données plus petits dans des fichiers plus volumineux pour des performances optimales. Le compactage prend également en charge les stratégies de tri et d’ordre Z qui regroupent des données similaires. Le tri organise les données en fonction de colonnes spécifiées, améliorant ainsi les performances des requêtes pour les opérations filtrées. L’ordre Z crée des jeux de données triés qui améliorent les performances des requêtes lorsque plusieurs colonnes sont interrogées simultanément. Les trois stratégies de compactage (Binpak, Tri et Ordre Z) réduisent la quantité de données numérisées par les moteurs de requêtes, réduisant ainsi les coûts de traitement des requêtes.
+ **Conservation des instantanés** : les instantanés sont des versions horodatées d’une table Iceberg. Les configurations de conservation des instantanés permettent aux clients de définir la durée de conservation des instantanés et le nombre d’instantanés à conserver. La configuration d’un optimiseur de conservation des instantanés peut aider à gérer la charge de stockage en supprimant les instantanés plus anciens et inutiles, ainsi que leurs fichiers sous-jacents associés.
+ **Suppression de fichiers orphelins** : les fichiers orphelins sont des fichiers qui ne sont plus référencés par les métadonnées de la table Iceberg. Ces fichiers peuvent s’accumuler au fil du temps, en particulier après des opérations telles que la suppression de tables ou l’échec de tâches ETL. L'activation de la suppression des fichiers orphelins permet AWS Glue d'identifier et de supprimer périodiquement ces fichiers inutiles, libérant ainsi de l'espace de stockage.
La configuration d'optimisation au niveau du catalogue est disponible via la console Lake Formation et à l'aide de l'opération AWS Glue `UpdateCatalog` API. Vous pouvez activer ou désactiver le compactage, la conservation des instantanés et les optimiseurs de suppression de fichiers orphelins pour les tables Iceberg individuelles du catalogue de données à l'aide de la AWS Glue console ou des opérations de l'API AWS CLI. AWS Glue
La vidéo suivante montre comment configurer des optimiseurs pour les tables Iceberg dans le catalogue de données.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/xOXE7AS-pNA?si=lKvt_TSlPkoc6OXn)
**Topics**
+ [Conditions préalables requises pour l’optimisation des tables](optimization-prerequisites.md)
+ [Optimiseurs de tables au niveau du catalogue](catalog-level-optimizers.md)
+ [Optimisation du compactage](compaction-management.md)
+ [Optimisation de la conservation des instantanés](snapshot-retention-management.md)
+ [Suppression des fichiers orphelins](orphan-file-deletion.md)
+ [Affichage des détails de l’optimisation](view-optimization-status.md)
+ [Afficher Amazon CloudWatch les métriques](view-optimization-metrics.md)
+ [Suppression d'un optimiseur](delete-optimizer.md)
+ [Considérations et restrictions](optimizer-notes.md)
+ [Régions prises en charge pour les optimiseurs de tables](regions-optimizers.md)
# Conditions préalables requises pour l’optimisation des tables
L'optimiseur de table utilise les autorisations du rôle Gestion des identités et des accès AWS (IAM) que vous spécifiez lorsque vous activez les options d'optimisation (compactage, conservation des instantanés et suppression de fichiers orphelins) pour une table. Vous pouvez soit créer un rôle unique pour tous les optimiseurs, soit créer des rôles distincts pour chaque optimiseur.
**Note**
L’optimiseur de suppression de fichiers orphelins ne nécessite pas les autorisations `glue:updateTable` ou `s3:putObject`. Les optimiseurs d’expiration et de compactage des instantanés nécessitent le même ensemble d’autorisations.
Le rôle IAM doit être autorisé à lire les données et à mettre à jour les métadonnées dans le catalogue de données. Vous pouvez créer un rôle IAM et y attacher les stratégies en ligne suivantes :
+ Ajoutez la politique intégrée suivante qui accorde à Amazon S3 des read/write autorisations sur l'emplacement pour les données qui ne sont pas enregistrées auprès AWS Lake Formation de celui-ci. Cette politique inclut également des autorisations pour mettre à jour le tableau dans le catalogue de données, ainsi que AWS Glue pour autoriser l'ajout de journaux dans les Amazon CloudWatch journaux et la publication de métriques. Pour les données sources dans Amazon S3 qui ne sont pas enregistrées auprès de Lake Formation, l’accès est déterminé par les stratégies d’autorisation IAM pour Amazon S3 et les actions AWS Glue .
Dans les stratégies en ligne suivantes, remplacez le `bucket-name` par le nom de votre compartiment Amazon S3, `aws-account-id` et `region` par un numéro valide du compte AWS et une région du catalogue de données, `database_name` par le nom de votre base de données et `table_name` par le nom de la table.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"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": [
"glue:UpdateTable",
"glue:GetTable"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:table//",
"arn:aws:glue:us-east-1:111122223333:database/",
"arn:aws:glue:us-east-1:111122223333:catalog"
]
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/aws-glue/iceberg-compaction/logs:*",
"arn:aws:logs:us-east-1:111122223333:log-group:/aws-glue/iceberg-retention/logs:*",
"arn:aws:logs:us-east-1:111122223333:log-group:/aws-glue/iceberg-orphan-file-deletion/logs:*"
]
}
]
}
```
------
+ Utilisez la stratégie suivante pour activer le compactage des données enregistrées auprès de Lake Formation.
Si le rôle d’optimisation ne dispose pas d’autorisations de groupe `IAM_ALLOWED_PRINCIPALS` accordées sur la table, le rôle nécessite des autorisations Lake Formation `ALTER`, `DESCRIBE`, `INSERT` et `DELETE` sur la table.
Pour plus d’informations sur l’enregistrement d’un compartiment Amazon S3 auprès de Lake Formation, consultez [Adding an Amazon S3 location to your data lake](https://docs.aws.amazon.com/lake-formation/latest/dg/register-data-lake.html).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lakeformation:GetDataAccess"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"glue:UpdateTable",
"glue:GetTable"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:table/databaseName/tableName",
"arn:aws:glue:us-east-1:111122223333:database/databaseName",
"arn:aws:glue:us-east-1:111122223333:catalog"
]
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/aws-glue/iceberg-compaction/logs:*",
"arn:aws:logs:us-east-1:111122223333:log-group:/aws-glue/iceberg-retention/logs:*",
"arn:aws:logs:us-east-1:111122223333:log-group:/aws-glue/iceberg-orphan-file-deletion/logs:*"
]
}
]
}
```
------
+ (Facultatif) Pour optimiser des tables Iceberg avec des données contenues dans des compartiments Amazon S3 chiffrés à l’aide du [chiffrement côté serveur](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html), le rôle de compactage nécessite des autorisations pour déchiffrer les objets Amazon S3 et générer une nouvelle clé de données pour écrire des objets dans les compartiments chiffrés. Ajoutez la politique suivante à la AWS KMS clé souhaitée. Nous prenons uniquement en charge le chiffrement au niveau du compartiment.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam:::role/"
},
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey"
],
"Resource": "*"
}
```
+ (Facultatif) Pour l’emplacement des données enregistré auprès de Lake Formation, le rôle utilisé pour enregistrer l’emplacement nécessite des autorisations pour déchiffrer les objets Amazon S3 et générer une nouvelle clé de données pour écrire des objets dans les compartiments chiffrés. Pour plus d’informations, consultez la rubrique [Enregistrement d’un emplacement Amazon S3 chiffré](https://docs.aws.amazon.com/lake-formation/latest/dg/register-encrypted.html).
+ (Facultatif) Si la AWS KMS clé est stockée dans un autre AWS compte, vous devez inclure les autorisations suivantes pour le rôle de compactage.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey"
],
"Resource": [
"arn:aws:kms:us-east-1:111122223333:key/key-id"
]
}
]
}
```
------
+ Le rôle que vous utilisez pour exécuter le compactage doit disposer de l’autorisation `iam:PassRole` correspondante.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/"
]
}
]
}
```
------
+ Ajoutez la politique de confiance suivante au rôle afin que le AWS Glue service assume le rôle IAM pour exécuter le processus de compactage.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
+ (Facultatif) Pour mettre à jour les paramètres du catalogue de données afin de permettre l'optimisation des tables au niveau du catalogue, le rôle IAM utilisé doit disposer de l'`glue:UpdateCatalog`autorisation ou AWS Lake Formation `ALTER CATALOG` de l'autorisation sur le catalogue racine. Vous pouvez utiliser l’API `GetCatalog` pour vérifier les propriétés du catalogue.
# Optimiseurs de tables au niveau du catalogue
Avec une configuration de catalogue unique, vous pouvez configurer des optimiseurs automatiques tels que le compactage, la conservation des instantanés et la suppression des fichiers orphelins pour toutes les tables Apache Iceberg nouvelles et mises à jour dans l’ AWS Glue Data Catalog. Les configurations d’optimiseur au niveau du catalogue vous permettent d’appliquer des paramètres d’optimisation cohérents à toutes les tables d’un catalogue, éliminant ainsi le besoin de configurer les optimiseurs individuellement pour chaque table.
Les administrateurs de lac de données peuvent configurer les optimiseurs de table en sélectionnant le catalogue par défaut dans la console Lake Formation et en activant les optimiseurs à l’aide de l’option `Table optimization`. Lorsque vous créez des tables ou que vous mettez à jour des tables existantes dans le catalogue de données, ce dernier exécute automatiquement les optimisations des tables afin de réduire la charge opérationnelle.
Si vous avez configuré l’optimisation au niveau de la table ou si vous avez précédemment supprimé les paramètres d’optimisation des tables pour une table, ces paramètres propres à la table ont priorité sur les paramètres du catalogue par défaut pour l’optimisation des tables. Si aucun paramètre de configuration n’est défini au niveau de la table ou du catalogue, la valeur de propriété de la table Iceberg sera appliquée. Ce paramètre s’applique à la conservation des instantanés et à l’optimiseur de suppression de fichiers orphelins.
Tenez compte des éléments suivants lorsque vous activez les optimisateurs au niveau du catalogue :
+ Lorsque vous configurez les paramètres d’optimisation au moment de la création du catalogue, puis que vous désactivez les optimisations par le biais d’une demande de mise à jour du catalogue, l’opération se répercute sur toutes les tables du catalogue.
+ Si vous avez déjà configuré des optimiseurs pour une table donnée, l’opération de désactivation au niveau du catalogue n’aura aucun impact sur cette table.
+ Lorsque vous désactivez les optimiseurs au niveau du catalogue, les tables présentant des configurations d’optimiseur existantes conservent leurs paramètres spécifiques et ne sont pas affectées par les modifications apportées au niveau du catalogue. Toutefois, les tables dépourvues de leur propre configuration d’optimiseur hériteront de l’état désactivé au niveau du catalogue.
+ Étant donné que les optimiseurs de conservation des instantanés et de suppression de fichiers orphelins peuvent être basés sur un calendrier, les mises à jour introduiront un retard aléatoire dans le début de leur calendrier. Cela entraînera le démarrage de chaque optimiseur à des heures légèrement différentes, répartissant ainsi la charge et réduisant le risque de dépassement des limites de service.
+ Les paramètres de l'optimiseur au niveau du catalogue ne sont pas automatiquement hérités par les tables lorsque le AWS Glue Data Catalog chiffrement est activé. Si le chiffrement des métadonnées est activé dans votre catalogue, vous devez configurer les optimiseurs de table individuellement pour chaque table. Pour utiliser l'héritage de l'optimiseur au niveau du catalogue, le chiffrement des métadonnées doit être désactivé dans le catalogue.
**Topics**
+ [Activation de l’optimisation automatique des tables au niveau du catalogue](enable-auto-table-optimizers.md)
+ [Affichage des optimisations au niveau du catalogue](view-catalog-optimizations.md)
+ [Désactivation de l’optimisation des tables au niveau du catalogue](disable-auto-table-optimizers.md)
# Activation de l’optimisation automatique des tables au niveau du catalogue
Vous pouvez activer l’optimisation automatique des tables pour toutes les nouvelles tables Apache Iceberg du catalogue de données. Après avoir créé la table, vous pouvez également mettre à jour manuellement de manière explicite les paramètres d’optimisation des tables.
Pour mettre à jour les paramètres du catalogue de données afin de permettre l’optimisation des tables au niveau du catalogue, le rôle IAM utilisé doit disposer de l’autorisation `glue:UpdateCatalog` sur le catalogue racine. Vous pouvez utiliser l’API `GetCatalog` pour vérifier les propriétés du catalogue.
Pour les tables gérées par Lake Formation, le rôle IAM sélectionné lors de la configuration d’optimisation du catalogue a besoin des autorisations Lake Formation `ALTER`, `DESCRIBE`, `INSERT` et `DELETE` pour toute nouvelle table ou pour les tables mises à jour.
## Pour activer les optimiseurs au niveau du catalogue (console)
1. Ouvrez la console Lake Formation à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Dans le panneau de navigation, choisissez **catalogue de données**.
1. Sélectionnez l’onglet **Catalogues**.
1. Choisissez le catalogue au niveau du compte.
1. Choisissez **Optimisations des tables**, puis **Modifier** sous l’onglet **Optimisations des tables**. Vous pouvez également choisir **Modifier les optimisations** dans **Actions**.
![\[La capture d’écran montre l’option de modification permettant d’activer les optimisations au niveau du catalogue.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/catalog-edit-optimizations.png)
1. Sur la page **Optimisation des tables**, configurez les options suivantes :
![\[La capture d’écran montre les options d’optimisation au niveau du catalogue.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/catalog-optimization-options.png)
1. Configurez les paramètres de **compactage** :
+ Activez/désactivez le compactage.
+ Choisissez le rôle IAM disposant des autorisations nécessaires pour exécuter les optimiseurs.
Pour en savoir plus sur les autorisations requises pour le rôle IAM, consultez [Conditions préalables requises pour l’optimisation des tables](optimization-prerequisites.md).
1. Configurez les paramètres de **conservation des instantanés** :
+ Activez/désactivez la conservation.
+ Définissez la période de conservation des instantanés en jours. La valeur par défaut est de cinq jours.
+ Définissez le nombre d’instantanés à retenir. La valeur par défaut est d’un instantané.
+ Activez/désactivez le nettoyage des fichiers expirés.
1. Configurez les paramètres de **suppression des fichiers orphelins** :
+ Activez/désactivez la suppression des fichiers orphelins.
+ Définissez la période de conservation des fichiers orphelins en jours. La valeur par défaut est de trois jours.
1. Choisissez **Enregistrer**.
## Activation des optimiseurs au niveau du catalogue via AWS CLI
Utilisez la commande CLI suivante pour mettre à jour un catalogue existant avec les paramètres de l’optimiseur :
**Example Mise à jour du catalogue avec les paramètres de l’optimiseur**
```
aws glue update-catalog \
--name catalog-id \
--catalog-input \
'{
"CatalogId": "111122223333",
"CatalogInput": {
"CatalogProperties": {
"CustomProperties": {
"ColumnStatistics.Enabled": "false",
"ColumnStatistics.RoleArn": "arn:aws:iam::111122223333:role/service-role/stats-role-name"
},
"IcebergOptimizationProperties": {
"RoleArn": "arn:aws:iam::111122223333:role/optimizer-role-name",
"Compaction": {
"enabled": "true"
},
"Retention": {
"enabled": "true",
"snapshotRetentionPeriodInDays": "10",
"numberOfSnapshotsToRetain": "5",
"cleanExpiredFiles": "true"
},
"OrphanFileDeletion": {
"enabled": "true",
"orphanFileRetentionPeriodInDays": "3"
}
}
}
}
}'
```
Si vous rencontrez des problèmes avec les optimiseurs au niveau du catalogue, vérifiez les points suivants :
+ Assurez-vous que le rôle IAM dispose des autorisations appropriées, comme indiqué dans la section Conditions préalables.
+ Consultez les CloudWatch journaux pour détecter tout message d'erreur lié aux opérations de l'optimiseur.
Pour de plus amples informations, consultez [Affichage des métriques disponibles](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/viewing_metrics_with_cloudwatch.html) dans le *Guide de l'utilisateur Amazon CloudWatch *.
+ Vérifiez que les paramètres du catalogue ont été correctement appliqués en vérifiant la configuration du catalogue.
+ En cas d'échec d'accès aux tables, consultez les CloudWatch journaux et EventBridge les notifications pour obtenir des informations détaillées sur les erreurs.
# Affichage des optimisations au niveau du catalogue
Lorsque l'optimisation des tables au niveau du catalogue est activée, chaque fois qu'une table Apache Iceberg est créée ou mise à jour via le `CreateTable` SDK ou AWS Glue crawler qu'un paramètre de niveau de table équivalent est créé pour cette table. `UpdateTable` APIs AWS Management Console
Après avoir créé ou mis à jour une table, vous pouvez vérifier ses détails pour confirmer son optimisation. `Table optimization` affiche la propriété `Configuration source` définie comme `Catalog`.
![\[Une image d’une table Apache Iceberg avec une configuration d’optimisation au niveau du catalogue a été appliquée.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/catalog-optimization-enabled.png)
# Désactivation de l’optimisation des tables au niveau du catalogue
Vous pouvez désactiver l'optimisation des tables pour les nouvelles tables à l'aide de la AWS Lake Formation console, l'`glue:UpdateCatalog`API.
**Pour désactiver les optimisations des tables au niveau du catalogue**
1. Ouvrez la console Lake Formation à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Dans la barre de navigation de gauche, choisissez **Catalogues**.
1. Sur la page **Résumé du catalogue**, choisissez **Modifier** sous **Optimisations des tables**.
1. Sur la page **Modifier l’optimisation**, désélectionnez les **options d’optimisation**.
1. Choisissez **Enregistrer**.
# Optimisation du compactage
Les lacs de données Amazon S3 utilisant des formats de table ouverts comme Apache Iceberg stockent les données sous forme d’objets S3. La présence de milliers de petits objets Amazon S3 dans une table de lac de données augmente la surcharge de métadonnées et affecte les performances de lecture. AWS Glue Data Catalog fournit un compactage géré pour les tables Iceberg, en compactant de petits objets en de plus grands objets pour améliorer les performances de lecture grâce à des services AWS d'analyse tels qu' Amazon Athena Amazon EMR et à des tâches ETL. AWS Glue Le catalogue de données effectue le compactage sans interférer avec les requêtes simultanées et prend en charge le compactage uniquement pour les tables au format Parquet.
L’optimiseur de table surveille en permanence les partitions des tables et lance le processus de compactage lorsque le seuil du nombre et de la taille des fichiers est dépassé.
Dans le catalogue de données, le processus de compactage démarre lorsqu’une table ou l’une de ses partitions contient plus de 100 fichiers. Chaque fichier doit être inférieur à 75 % de la taille du fichier cible. La taille du fichier cible est définie par la propriété de la table `write.target-file-size-bytes`, qui est par défaut de 512 Mo si elle n’est pas définie explicitement.
Pour connaître les limitations, veuillez consulter [Formats pris en charge et restrictions pour le compactage de données géré](optimizer-notes.md#compaction-notes).
**Topics**
+ [Activation de l’optimiseur de compactage](enable-compaction.md)
+ [Désactivation de l’optimiseur de compactage](disable-compaction.md)
# Activation de l’optimiseur de compactage
Vous pouvez utiliser AWS Glue la console ou l' AWS API pour activer le compactage de vos tables Apache Iceberg dans le catalogue de AWS Glue données. AWS CLI Pour les nouvelles tables, vous pouvez choisir Apache Iceberg comme format de table et activer le compactage lors de la création de la table. Le compactage est désactivé par défaut pour les nouvelles tables.
------
#### [ Console ]
**Pour activer le compactage**
1. Ouvrez la AWS Glue console [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)et connectez-vous en tant qu'administrateur du lac de données, créateur de table ou utilisateur ayant obtenu les `lakeformation:GetDataAccess` autorisations `glue:UpdateTable` et sur la table.
1. Dans le panneau de navigation, sous **Catalogue de données**, choisissez **Tables**.
1. Sur la page **Tables**, choisissez une table au format ouvert pour laquelle vous souhaitez activer le compactage, puis dans le menu **Actions**, choisissez **Optimisation**, puis **Activer**.
Vous pouvez également activer le compactage en sélectionnant l’onglet **Optimisation des tables** sur la page **Détails de la table**. Choisissez l’onglet **Optimisation des tables** dans la partie inférieure de la page, puis sélectionnez **Activer le compactage**.
L’option **Activer l’optimisation** est également disponible lorsque vous créez une table Iceberg dans le catalogue de données.
1. Sur la page **Activer l’optimisation**, sélectionnez **Compactage** sous **Options d’optimisation**.
![\[Page de détails des tables Apache Iceberg avec l’option Activer le compactage.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/table-enable-compaction.png)
1. Sélectionnez ensuite un rôle IAM dans le menu déroulant avec les autorisations indiquées dans la section [Conditions préalables requises pour l’optimisation des tables](optimization-prerequisites.md).
Vous pouvez aussi choisir l’option **Créer un rôle IAM** pour créer un rôle personnalisé avec des autorisations requises pour exécuter le compactage.
Suivez les étapes ci-dessous pour mettre à jour un rôle IAM existant :
1. Pour mettre à jour la stratégie d’autorisation pour le rôle IAM, dans la console IAM, accédez au rôle IAM utilisé pour exécuter le compactage.
1. Dans la section **Ajouter des autorisations**, choisissez Créer une politique. Dans la fenêtre du navigateur nouvellement ouverte, créez une nouvelle stratégie à utiliser avec votre rôle.
1. Sur la page Créer une politique, choisissez l’onglet `JSON`. Copiez le code JSON affiché dans les prérequis dans le champ de l’éditeur de politique.
1. Si vous avez des configurations de politique de sécurité dans lesquelles l'optimiseur de table Iceberg doit accéder aux compartiments Amazon S3 à partir d'un Virtual Private Cloud (VPC) spécifique, créez AWS Glue une connexion réseau ou utilisez une connexion réseau existante.
Si aucune connexion AWS Glue VPC n'est déjà configurée, créez-en une nouvelle en suivant les étapes de la section [Création de connexions pour les connecteurs](https://docs.aws.amazon.com/glue/latest/dg/creating-connections.html) à l'aide de la AWS Glue console ou du /SDK. AWS CLI
1. Choisissez une politique de compactage. Les options disponibles sont les suivantes :
+ **Binpack** : Binpack est la stratégie de compactage par défaut d’Apache Iceberg. Elle combine des fichiers de données plus petits dans des fichiers plus volumineux pour des performances optimales.
+ **Tri** : le tri dans Apache Iceberg est une technique d’organisation des données qui regroupe les informations au sein de fichiers en fonction de colonnes spécifiées, ce qui améliore considérablement les performances des requêtes en réduisant le nombre de fichiers à traiter. Vous définissez l’ordre de tri dans les métadonnées d’Iceberg à l’aide du champ d’ordre de tri, et lorsque plusieurs colonnes sont spécifiées, les données sont triées dans l’ordre dans lequel les colonnes apparaissent dans l’ordre de tri, ce qui garantit que les enregistrements présentant des valeurs similaires sont stockés ensemble dans des fichiers. La stratégie de tri du compactage va plus loin dans l’optimisation en triant les données dans tous les fichiers d’une partition.
+ **Ordre Z** : l’ordre Z est un moyen d’organiser les données lorsque vous devez trier selon plusieurs colonnes de la même importance. Contrairement au tri traditionnel qui donne la priorité à une colonne par rapport aux autres, l’ordre Z donne une pondération équilibrée à chaque colonne, ce qui permet à votre moteur de requête de lire moins de fichiers lors de la recherche de données.
La technique fonctionne en combinant les chiffres binaires de valeurs issues de différentes colonnes. Par exemple, si vous avez les chiffres 3 et 4 sur deux colonnes, l’ordre Z les convertit d’abord en binaire (3 devient 011 et 4 devient 100), puis entrelace ces chiffres pour créer une valeur : 011010. Cet entrelacement crée un modèle qui maintient les données associées physiquement proches les unes des autres.
L’ordre Z est particulièrement efficace pour les requêtes multidimensionnelles. Par exemple, une table client triée en Z par revenu, État et code postal peut offrir des performances supérieures à celles d’un tri hiérarchique lors d’une interrogation portant sur plusieurs dimensions. Cette organisation permet aux requêtes ciblant des combinaisons spécifiques de revenus et de situation géographique de localiser rapidement les données pertinentes tout en minimisant les analyses de fichiers inutiles.
1. **Minimum de fichiers d’entrée** : nombre de fichiers de données requis dans une partition avant le déclenchement du compactage.
1. **Seuil de suppression de fichiers** : nombre minimum d’opérations de suppression requises dans un fichier de données avant qu’il ne soit éligible au compactage.
1. Choisissez **Activer l’optimisation**.
------
#### [ AWS CLI ]
L’exemple suivant montre comment activer le compactage. Remplacez l'identifiant de compte par un identifiant de AWS compte valide. Remplacez le nom de la base de données et le nom de la table par un nom réel de la table Iceberg et le nom de la base de données. Remplacez le `roleArn` par l’ARN (Amazon Resource Name) AWS du rôle IAM et le nom du rôle IAM qui dispose des autorisations requises pour exécuter le compactage. Vous pouvez remplacer la stratégie de compactage `sort` par d’autres stratégies prises en charge, telles que `z-order` ou `binpack`.
commander en fonction de vos besoins.
```
aws glue create-table-optimizer \
--catalog-id 123456789012 \
--database-name iceberg_db \
--table-name iceberg_table \
--table-optimizer-configuration '{
"roleArn": "arn:aws:iam::123456789012:role/optimizer_role",
"enabled": true,
"vpcConfiguration": {"glueConnectionName": "glue_connection_name"},
"compactionConfiguration": {
"icebergConfiguration": {"strategy": "sort"}
}
}'\
--type compaction
```
------
#### [ AWS API ]
Appelez une opération [CreateTableOptimizer](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-table-optimizers.html#aws-glue-api-table-optimizers-CreateTableOptimizer) pour activer le compactage d'une table.
------
Après avoir activé le compactage, l’onglet **Optimisation des tables** affiche les détails de compactage suivants une fois le compactage terminé :
L’heure de début
Heure à laquelle le processus de compactage a commencé dans le catalogue de données. La valeur est un horodatage selon le fuseau UTC.
L’heure de fin
Heure à laquelle le processus de compactage a pris fin dans le catalogue de données. La valeur est un horodatage selon le fuseau UTC.
Statut
L’état d’exécution du compactage. Les valeurs sont la réussite ou l'échec.
Fichiers compactés
Nombre total de fichiers compactés.
Octets compactés
Nombre total d’octets compactés.
# Désactivation de l’optimiseur de compactage
Vous pouvez désactiver le compactage automatique pour une table Apache Iceberg particulière à l'aide de AWS Glue la console ou. AWS CLI
------
#### [ 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 panneau de navigation de gauche, sous **Catalogue de données**, choisissez **Tables**.
1. Dans la liste des tables, choisissez la table Iceberg dont vous souhaitez désactiver le compactage.
1. Choisissez l’onglet **Optimisation des tables** dans la section inférieure de la page **Détails des tables**.
1. Dans **Actions**, choisissez **Désactiver**, puis sélectionnez **Compactage**.
1. Choisissez **Désactiver le compactage** dans le message de confirmation. Vous pouvez réactiver le compactage ultérieurement.
Une fois que vous avez confirmé, le compactage est désactivé et l'état de compactage de la table revient à `Disabled`.
------
#### [ AWS CLI ]
Dans l'exemple suivant, remplacez l'ID de compte par un ID de AWS compte valide. Remplacez le nom de la base de données et le nom de la table par un nom réel de la table Iceberg et le nom de la base de données. Remplacez le `roleArn` par le nom de AWS ressource (ARN) du rôle IAM et le nom réel du rôle IAM disposant des autorisations requises pour exécuter le compactage.
```
aws glue update-table-optimizer \
--catalog-id 123456789012 \
--database-name iceberg_db \
--table-name iceberg_table \
--table-optimizer-configuration '{"roleArn":"arn:aws:iam::123456789012:role/optimizer_role", "enabled":'false', "vpcConfiguration":{"glueConnectionName":"glue_connection_name"}}'\
--type compaction
```
------
#### [ AWS API ]
Appelez l'opération [UpdateTableOptimizer](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-table-optimizers.html#aws-glue-api-table-optimizers-UpdateTableOptimizer) pour désactiver le compactage d'une table spécifique.
------
# Optimisation de la conservation des instantanés
La fonctionnalité de conservation des instantanés Apache Iceberg permet aux utilisateurs d’interroger les données historiques à des moments précis et d’annuler les modifications indésirables apportées à leurs tables. Dans le catalogue de AWS Glue données, la configuration de conservation des instantanés contrôle la durée de conservation de ces instantanés (versions des données de table) avant leur expiration et leur suppression. Cela permet de gérer les coûts de stockage et la surcharge de métadonnées en supprimant automatiquement les anciens instantanés en fonction d’une période de conservation configurée ou du nombre maximal d’instantanés à conserver.
Vous pouvez configurer la période de conservation en jours et le nombre maximal de clichés à conserver pour une table. AWS Glue supprime les instantanés antérieurs à la période de rétention spécifiée des métadonnées de la table, tout en préservant les instantanés les plus récents dans les limites configurées. Après avoir supprimé les anciens instantanés des métadonnées, AWS Glue supprime les données et les fichiers de métadonnées correspondants qui ne sont plus référencés et uniques aux instantanés expirés. Cela permet d’autoriser les requêtes Time Travel uniquement jusqu’aux instantanés conservés restants, tout en récupérant l’espace de stockage utilisé par les données d’instantanés expirés.
**Topics**
+ [Activation de l’optimiseur de conservation des instantanés](enable-snapshot-retention.md)
+ [Mise à jour de l’optimiseur de conservation des instantanés](update-snapshot-retention.md)
+ [Désactivation de l’optimiseur de conservation des instantanés](disable-snapshot-retention.md)
# Activation de l’optimiseur de conservation des instantanés
Vous pouvez utiliser AWS Glue la console ou l' AWS API pour activer les optimiseurs de rétention des instantanés pour vos tables Apache Iceberg dans le catalogue de données. AWS CLI Pour les nouvelles tables, vous pouvez choisir Apache Iceberg comme format de table et activer l’optimiseur de conservation des instantanés lors de la création de la table. La conservation des instantanés est désactivée par défaut pour les nouvelles tables.
------
#### [ Console ]
**Pour activer l’optimiseur de conservation des instantanés**
1. Ouvrez la AWS Glue console [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)et connectez-vous en tant qu'administrateur du lac de données, créateur de table ou utilisateur ayant obtenu les `lakeformation:GetDataAccess` autorisations `glue:UpdateTable` et sur la table.
1. Dans le panneau de navigation, sous **Catalogue de données**, choisissez **Tables**.
1. Sur la page **Tables**, choisissez une table Iceberg pour laquelle vous souhaitez activer l’optimiseur de conservation des instantanés, puis dans le menu **Actions**, choisissez **Activer** sous **Optimisation**.
Vous pouvez également activer l’optimisation en sélectionnant la table et en ouvrant la page **Détails de la table**. Choisissez l’onglet **Optimisation des tables** dans la partie inférieure de la page, puis sélectionnez **Activer la conservation des instantanés**.
1. Sur la page **Activer l’optimisation**, sous **Configuration de l’optimisation**, vous avez deux options : **Utiliser les paramètres par défaut** ou **Personnaliser les paramètres**. Si vous choisissez d'utiliser les paramètres par défaut, AWS Glue utilise les propriétés définies dans la configuration de la table Iceberg pour déterminer la période de conservation des instantanés et le nombre de clichés à conserver. En l'absence de cette configuration, AWS Glue conserve un instantané pendant cinq jours et supprime les fichiers associés aux instantanés expirés.
1. Ensuite, choisissez un rôle IAM qui AWS Glue peut assumer en votre nom l'exécution de l'optimiseur. Pour en savoir plus sur les autorisations requises pour le rôle IAM, consultez la section [Conditions préalables requises pour l’optimisation des tables](optimization-prerequisites.md).
Suivez les étapes ci-dessous pour mettre à jour un rôle IAM existant :
1. Pour mettre à jour la stratégie d’autorisation pour le rôle IAM, dans la console IAM, accédez au rôle IAM utilisé pour exécuter le compactage.
1. Dans la section Ajouter des autorisations, choisissez Créer une politique. Dans la fenêtre du navigateur nouvellement ouverte, créez une nouvelle stratégie à utiliser avec votre rôle.
1. Sur la page Créer une politique, choisissez l’onglet JSON. Copiez le code JSON affiché dans les prérequis dans le champ de l’éditeur de politique.
1. Si vous préférez définir les valeurs de la **configuration de conservation des instantanés** manuellement, choisissez **Personnaliser les paramètres**.
![\[Page de détails de la table Apache Iceberg avec l’option Activer la conservation > Personnaliser les paramètres.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/table-enable-retention.png)
1. Cochez la case **Appliquer le rôle IAM sélectionné aux optimiseurs sélectionnés** pour utiliser un seul rôle IAM pour tout en activant tous les optimiseurs.
1. Si vous avez des configurations de politique de sécurité dans lesquelles l'optimiseur de table Iceberg doit accéder aux compartiments Amazon S3 à partir d'un Virtual Private Cloud (VPC) spécifique, créez AWS Glue une connexion réseau ou utilisez une connexion réseau existante.
Si aucune connexion AWS Glue VPC n'est déjà configurée, créez-en une nouvelle en suivant les étapes de la section [Création de connexions pour les connecteurs](https://docs.aws.amazon.com/glue/latest/dg/creating-connections.html) à l'aide de la AWS Glue console ou du /SDK. AWS CLI
1. Ensuite, sous **Configuration de conservation des instantanés**, choisissez d'utiliser les valeurs spécifiées dans la [configuration de la table Iceberg](https://iceberg.apache.org/docs/1.5.2/configuration/#table-behavior-properties) ou de spécifier des valeurs personnalisées pour la période de conservation des instantanés (history.expire). max-snapshot-age-ms), nombre minimum de clichés (history.expire. min-snapshots-to-keep) à conserver, ainsi que le délai en heures entre deux exécutions consécutives de suppression d'instantanés.
1. Choisissez **Supprimer les fichiers associés** pour supprimer les fichiers sous-jacents lorsque l’optimiseur de table supprime les anciens instantanés des métadonnées de la table.
Si vous ne choisissez pas cette option, lorsque les anciens instantanés sont supprimés des métadonnées de la table, les fichiers associés resteront dans le stockage en tant que fichiers orphelins.
1. Ensuite, lisez la mise en garde, puis choisissez **Je confirme** pour continuer.
**Note**
Dans le catalogue de données, l’optimiseur de conservation des instantanés respecte le cycle de vie contrôlé par les politiques de conservation au niveau des branches et des balises. Pour plus d’informations, consultez la section [Branching and tagging](https://iceberg.apache.org/docs/latest/branching/#overview) dans la documentation Iceberg.
1. Examinez la configuration et choisissez **Activer l’optimisation**.
Attendez quelques minutes que l’optimiseur de conservation s’exécute et que les anciens instantanés expirent en fonction de la configuration.
------
#### [ AWS CLI ]
Pour activer la conservation des instantanés pour les nouvelles tables Iceberg dans AWS Glue, vous devez créer un optimiseur de table de type `retention` et définir le `enabled` champ sur `true` dans le. `table-optimizer-configuration` Vous pouvez le faire à l'aide de la AWS CLI commande `create-table-optimizer` ou`update-table-optimizer`. En outre, vous devez spécifier les champs de configuration de conservation tels que `snapshotRetentionPeriodInDays` et `numberOfSnapshotsToRetain` en fonction de vos besoins.
L’exemple suivant montre comment activer l’optimiseur de conservation des instantanés. Remplacez l'identifiant de compte par un identifiant de AWS compte valide. Remplacez le nom de la base de données et le nom de la table par un nom réel de la table Iceberg et le nom de la base de données. Remplacez le `roleArn` par le nom de AWS ressource (ARN) du rôle IAM et le nom du rôle IAM disposant des autorisations requises pour exécuter l'optimiseur de rétention des instantanés.
```
aws glue create-table-optimizer \
--catalog-id 123456789012 \
--database-name iceberg_db \
--table-name iceberg_table \
--table-optimizer-configuration '{"roleArn":"arn:aws:iam::123456789012:role/optimizer_role","enabled":'true', "vpcConfiguration":{
"glueConnectionName":"glue_connection_name"}, "retentionConfiguration":{"icebergConfiguration":{"snapshotRetentionPeriodInDays":7,"numberOfSnapshotsToRetain":3,"cleanExpiredFiles":'true'}}}'\
--type retention
```
Cette commande crée un optimiseur de conservation pour la table Iceberg spécifiée dans le catalogue, la base de données et la région donnés. table-optimizer-configurationSpécifie l'ARN du rôle IAM à utiliser, active l'optimiseur et définit la configuration de rétention. Dans cet exemple, il conserve les instantanés pendant sept jours, garde au moins trois instantanés et nettoie les fichiers expirés.
+ snapshotRetentionPeriodInDays : le nombre de jours pendant lesquels les instantanés sont conservés avant leur expiration. La valeur par défaut est `5`.
+ numberOfSnapshotsToRetain — Le nombre minimum de clichés à conserver, même s'ils sont antérieurs à la période de conservation. La valeur par défaut est `1`.
+ cleanExpiredFiles — Un booléen indiquant s'il faut supprimer les fichiers de données expirés après l'expiration des instantanés. La valeur par défaut est `true`.
Lorsque ce paramètre est défini sur true, les anciens instantanés sont supprimés des métadonnées de la table et leurs fichiers sous-jacents sont supprimés. Si ce paramètre est défini sur false, les anciens instantanés sont supprimés des métadonnées de la table, mais leurs fichiers sous-jacents restent dans le stockage en tant que fichiers orphelins..
------
#### [ AWS API ]
[CreateTableOptimizer](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-table-optimizers.html#aws-glue-api-table-optimizers-CreateTableOptimizer)Opération d'appel pour activer l'optimiseur de rétention des instantanés pour une table.
------
Après avoir activé le compactage, l’onglet **Optimisation des tables** affiche les détails de compactage suivants (après environ 15 à 20 minutes) :
L’heure de début
L’heure à laquelle l’optimiseur de conservation des instantanés a démarré. La valeur est un horodatage selon le fuseau UTC.
Durée de l'exécution
Le temps indique la durée nécessaire à l’optimiseur pour terminer la tâche. La valeur est un horodatage selon le fuseau UTC.
Statut
L’état d’exécution de l’optimiseur. Les valeurs sont la réussite ou l'échec.
Fichiers de données supprimés
Nombre total de fichiers supprimés.
Fichiers manifestes supprimés
Nombre total de fichiers manifestes supprimés.
Listes de manifestes supprimées
Nombre total de listes de manifestes supprimées.
# Mise à jour de l’optimiseur de conservation des instantanés
Vous pouvez mettre à jour la configuration existante d'un optimiseur de rétention des instantanés pour une table Apache Iceberg particulière à l'aide de la AWS Glue console ou de l' UpdateTableOptimizerAPI. AWS CLI
------
#### [ Console ]
**Pour mettre à jour la configuration de la conservation des instantanés**
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. Choisissez **Catalogue de données**, puis choisissez **Tables**. Dans la liste des tables, choisissez la table Iceberg dont vous souhaitez mettre à jour la configuration de l’optimiseur de conservation des instantanés.
1. Dans la section inférieure de la page **Détails des tables**, sélectionnez l’onglet **Optimisation des tables**, puis **Modifier**. Vous pouvez également choisir **Modifier** sous **Optimisation** dans le menu **Actions** situé dans le coin supérieur droit de la page.
1. Sur la page **Modifier l’optimisation**, apportez les modifications souhaitées.
1. Choisissez **Enregistrer**.
------
#### [ AWS CLI ]
Pour mettre à jour un optimiseur de conservation des instantanés à l'aide de AWS CLI, vous pouvez utiliser la commande suivante :
```
aws glue update-table-optimizer \
--catalog-id 123456789012 \
--database-name iceberg_db \
--table-name iceberg_table \
--table-optimizer-configuration '{"roleArn":"arn:aws:iam::123456789012:role/optimizer_role"","enabled":'true', "vpcConfiguration":{"glueConnectionName":"glue_connection_name"},"retentionConfiguration":{"icebergConfiguration":{"snapshotRetentionPeriodInDays":7,"numberOfSnapshotsToRetain":3,"cleanExpiredFiles":'true'}}}' \
--type retention
```
Cette commande met à jour la configuration de rétention pour la table spécifiée dans le catalogue, la base de données et la région donnés. Les principaux paramètres sont les suivants :
+ snapshotRetentionPeriodInDays : le nombre de jours pendant lesquels les instantanés sont conservés avant leur expiration. La valeur par défaut est `1`.
+ numberOfSnapshotsToRetain — Le nombre minimum de clichés à conserver, même s'ils sont antérieurs à la période de conservation. La valeur par défaut est `5`.
+ cleanExpiredFiles — Un booléen indiquant s'il faut supprimer les fichiers de données expirés après l'expiration des instantanés. La valeur par défaut est `true`.
Lorsque ce paramètre est défini sur true, les anciens instantanés sont supprimés des métadonnées de la table et leurs fichiers sous-jacents sont supprimés. Si ce paramètre est défini sur false, les anciens instantanés sont supprimés des métadonnées de la table, mais leurs fichiers sous-jacents restent dans le stockage en tant que fichiers orphelins..
------
#### [ API ]
Pour mettre à jour un optimiseur de table, vous pouvez utiliser l’API `UpdateTableOptimizer`. Cette API vous permet de mettre à jour la configuration d’un optimiseur de table existant pour le compactage, la conservation ou la suppression de fichiers orphelins. Les paramètres de demande comprennent :
+ catalogId (obligatoire) : l’ID du catalogue contenant la table
+ databaseName (facultatif) : le nom de la base de données contenant la table
+ tableName (facultatif) : le nom de la table
+ type (obligatoire) : le type d’optimiseur de table (compaction, retention ou orphan\$1file\$1delete)
+ retentionConfiguration (obligatoire) : configuration mise à jour de l’optimiseur de table, y compris l’ARN du rôle, l’état activé, la configuration de la conservation et la configuration de suppression des fichiers orphelins
------
# Désactivation de l’optimiseur de conservation des instantanés
Vous pouvez désactiver l'optimiseur de rétention des instantanés pour une table Apache Iceberg particulière à l'aide de AWS Glue la console ou. AWS CLI
------
#### [ Console ]
**Pour désactiver la conservation des instantanés**
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. Choisissez **Catalogue de données**, puis choisissez **Tables**. Dans la liste des tables, choisissez la table Iceberg dont vous souhaitez désactiver l’optimiseur pour la conservation des instantanés.
1. Dans la section inférieure de la page des **Détails des tables**, choisissez **Optimisation des tables** et **Désactiver**, **Conservation des instantanés** sous **Actions**.
Vous pouvez également choisir **Désactiver** sous **Optimisation** dans le menu **Actions** situé dans le coin supérieur droit de la page.
1. Choisissez **Désactiver** dans le message de confirmation. Vous pouvez réactiver l’optimiseur de conservation des instantanés ultérieurement.
Une fois que vous avez confirmé, l’optimiseur de conservation des instantanés est désactivé et l’état de conservation des instantanés revient à `Not enabled`.
------
#### [ AWS CLI ]
Dans l'exemple suivant, remplacez l'ID de compte par un ID de AWS compte valide. Remplacez le nom de la base de données et le nom de la table par un nom réel de la table Iceberg et le nom de la base de données. Remplacez le `roleArn` par le nom de AWS ressource (ARN) du rôle IAM et le nom réel du rôle IAM disposant des autorisations requises pour exécuter l'optimiseur de rétention.
```
aws glue update-table-optimizer \
--catalog-id 123456789012 \
--database-name iceberg_db \
--table-name iceberg_table \
--table-optimizer-configuration '{"roleArn":"arn:aws:iam::123456789012:role/optimizer_role", "vpcConfiguration":{"glueConnectionName":"glue_connection_name"}, "enabled":'false'}'\
--type retention
```
------
#### [ AWS API ]
[UpdateTableOptimizer](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-table-optimizers.html#aws-glue-api-table-optimizers-UpdateTableOptimizer)Opération d'appel pour désactiver l'optimiseur de rétention des instantanés pour une table spécifique.
------
# Suppression des fichiers orphelins
AWS Glue Data Catalog vous permet de supprimer les fichiers orphelins de vos tables Iceberg. Les fichiers orphelins sont des fichiers non référencés qui existent dans votre source de données Amazon S3 à l’emplacement de la table spécifié, qui ne sont pas suivis par les métadonnées de la table Iceberg et qui sont plus anciens que la limite d’âge que vous avez configurée. Ces fichiers orphelins peuvent s’accumuler au fil du temps en cas d’échec d’opérations telles que le compactage, la suppression de partitions ou la réécriture de tables, et occuper un espace de stockage inutile.
L'optimiseur de suppression des fichiers orphelins AWS Glue analyse les métadonnées de la table et les fichiers de données réels, identifie les fichiers orphelins et les supprime pour récupérer de l'espace de stockage. L’optimiseur supprime uniquement les fichiers créés après la date de création de l’optimiseur qui répondent également aux critères de suppression configurés. Les fichiers créés avant ou à la date de création de l’optimiseur ne sont jamais supprimés.
**Logique de suppression de fichiers orphelins**
1. Vérification de la date : compare la date de création du fichier avec la date de création de l’optimiseur. Si le fichier est antérieur ou égal à la date de création de l’optimiseur, il est ignoré.
1. Vérification de la configuration de l’optimiseur : si le fichier est plus récent que la date de création de l’optimiseur, il évalue le fichier par rapport à la limite d’âge configurée. L’optimiseur supprime le fichier s’il répond aux critères de suppression. Ignore le fichier s’il ne correspond pas aux critères.
Vous pouvez initier la suppression des fichiers orphelins en créant un optimiseur de table de suppression de fichiers orphelins dans le catalogue de données.
**Important**
Par défaut, la suppression des fichiers orphelins évalue les fichiers situés à l'emplacement de votre AWS Glue table. Bien que vous puissiez configurer un sous-préfixe pour limiter la portée de l’évaluation à l’aide d’un paramètre d’API, vous devez vous assurer que l’emplacement de votre table ne contient pas de fichiers provenant d’autres sources de données ou tables. Si l’emplacement de votre table chevauche celui d’autres sources de données, le service peut identifier et supprimer des fichiers non liés en tant qu’orphelins.
**Topics**
+ [Activation de la suppression des fichiers orphelins](enable-orphan-file-deletion.md)
+ [Mise à jour de l’optimiseur de suppression de fichiers orphelins](update-orphan-file-deletion.md)
+ [Désactivation de la suppression des fichiers orphelins](disable-orphan-file-deletion.md)
# Activation de la suppression des fichiers orphelins
Vous pouvez utiliser AWS Glue la console ou l' AWS API pour activer la suppression des fichiers orphelins pour vos tables Apache Iceberg dans le catalogue de données. AWS CLI Pour les nouvelles tables, vous pouvez choisir Apache Iceberg comme format de table et activer l’optimiseur de suppression de fichiers orphelins lors de la création de la table. La conservation des instantanés est désactivée par défaut pour les nouvelles tables.
------
#### [ Console ]
**Pour activer la suppression des fichiers orphelins**
1. Ouvrez la AWS Glue console [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)et connectez-vous en tant qu'administrateur du lac de données, créateur de table ou utilisateur ayant obtenu les `lakeformation:GetDataAccess` autorisations `glue:UpdateTable` et sur la table.
1. Dans le panneau de navigation, sous **Catalogue de données**, choisissez **Tables**.
1. Sur la page **Tables**, choisissez une table Iceberg dans laquelle vous souhaitez activer la suppression des fichiers orphelins.
Choisissez l’onglet **Optimisation des tables** dans la partie inférieure de la page, puis sélectionnez **Activer**, **Suppression des fichiers orphelins** dans **Actions**.
Vous pouvez également choisir **Activer** sous **Optimisation** dans le menu **Actions** situé dans le coin supérieur droit de la page.
1. Sur la page **Activer l’optimisation**, sélectionnez **Suppression des fichiers orphelins** sous **Options d’optimisation**.
1. Si vous choisissez d’utiliser les **paramètres par défaut**, tous les fichiers orphelins seront supprimés au bout de trois jours. Si vous souhaitez conserver les fichiers orphelins pendant un certain nombre de jours, choisissez **Personnaliser les paramètres**.
1. Choisissez ensuite un rôle IAM avec les autorisations requises pour supprimer les fichiers orphelins.
1. Si vous avez des configurations de politique de sécurité dans lesquelles l'optimiseur de table Iceberg doit accéder aux compartiments Amazon S3 à partir d'un Virtual Private Cloud (VPC) spécifique, créez AWS Glue une connexion réseau ou utilisez une connexion réseau existante.
Si aucune connexion AWS Glue VPC n'est déjà configurée, créez-en une nouvelle en suivant les étapes de la section [Création de connexions pour les connecteurs](https://docs.aws.amazon.com/glue/latest/dg/creating-connections.html) à l'aide de la AWS Glue console ou du /SDK. AWS CLI
1. Si vous choisissez **Personnaliser les paramètres**, entrez le nombre de jours pendant lesquels les fichiers doivent être conservés avant leur suppression dans **Configuration de la suppression des fichiers orphelins**. Vous pouvez également indiquer l’intervalle entre deux exécutions d’optimiseur consécutives. La valeur par défaut est 24 heures.
1. Choisissez **Activer l’optimisation**.
------
#### [ AWS CLI ]
Pour activer la suppression des fichiers orphelins pour une table Iceberg dans AWS Glue, vous devez créer un optimiseur de table de type `orphan_file_deletion` et définir le `enabled` champ sur true. Pour créer un optimiseur de suppression de fichiers orphelins pour une table Iceberg à l'aide de AWS CLI, vous pouvez utiliser la commande suivante :
```
aws glue create-table-optimizer \
--catalog-id 123456789012 \
--database-name iceberg_db \
--table-name iceberg_table \
--table-optimizer-configuration '{"roleArn":"arn:aws:iam::123456789012:role/optimizer_role","enabled":true, "vpcConfiguration":{
"glueConnectionName":"glue_connection_name"}, "orphanFileDeletionConfiguration":{"icebergConfiguration":{"orphanFileRetentionPeriodInDays":3, "location":'S3 location'}}}'\
--type orphan_file_deletion
```
Cette commande crée un optimiseur de suppression de fichiers orphelins pour la table Iceberg spécifiée. Les principaux paramètres sont les suivants :
+ roleArn : l’ARN du rôle IAM autorisé à accéder au compartiment S3 et aux ressources Glue.
+ enabled : définissez cette valeur sur true pour activer l’optimiseur.
+ orphanFileRetentionPeriodInDays — Le nombre de jours pendant lesquels les fichiers orphelins sont conservés avant de les supprimer (minimum 1 jour).
+ type : définissez la valeur sur orphan\$1file\$1deletion pour créer un optimiseur de suppression de fichiers orphelins.
Après avoir créé l’optimiseur de table, les fichiers orphelins seront supprimés périodiquement (une fois par jour si cette option reste activée). Vous pouvez vérifier les exécutions à l’aide de l’API `list-table-optimizer-runs`. La tâche de suppression des fichiers orphelins identifiera et supprimera les fichiers qui ne sont pas suivis dans les métadonnées Iceberg de la table.
------
#### [ API ]
[CreateTableOptimizer](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-table-optimizers.html#aws-glue-api-table-optimizers-CreateTableOptimizer)Opération d'appel pour créer l'optimiseur de suppression de fichiers orphelins pour une table spécifique.
------
# Mise à jour de l’optimiseur de suppression de fichiers orphelins
Vous pouvez modifier la configuration de l'optimiseur de suppression de fichiers orphelins, par exemple en modifiant la période de conservation des fichiers orphelins ou le rôle IAM utilisé par l'optimiseur à l'aide de la AWS Glue console ou de l'opération. AWS CLI`UpdateTableOptimizer`
------
#### [ AWS Management Console ]
**Pour mettre à jour l’optimiseur de suppression de fichiers orphelins**
1. Choisissez **Catalogue de données**, puis choisissez **Tables**. Dans la liste des tables, choisissez la table dont vous souhaitez mettre à jour la configuration de l’optimiseur de suppression des fichiers orphelins.
1. Dans la section inférieure de la page **Détails des tables**, choisissez **Optimisation des tables**, puis sélectionnez **Modifier**.
1. Sur la page **Modifier l’optimisation**, apportez les modifications souhaitées.
1. Choisissez **Enregistrer**.
------
#### [ AWS CLI ]
Vous pouvez utiliser l'`update-table-optimizer`appel pour mettre à jour l'optimiseur de suppression de fichiers orphelins dans AWS Glue, vous pouvez utiliser l'appel. Cela vous permet de modifier la `OrphanFileDeletionConfiguration` dans le champ `icebergConfiguration` dans lequel vous pouvez spécifier la `OrphanFileRetentionPeriodInDays` mise à jour pour définir le nombre de jours pendant lesquels les fichiers orphelins seront conservés, afin de spécifier l’emplacement de la table Iceberg dans laquelle les fichiers orphelins seront supprimés.
```
aws glue update-table-optimizer \
--catalog-id 123456789012 \
--database-name iceberg_db \
--table-name Iceberg_table \
--table-optimizer-configuration '{"roleArn":"arn:aws:iam::123456789012:role/optimizer_role","enabled":true, "vpcConfiguration":{"glueConnectionName":"glue_connection_name"},"orphanFileDeletionConfiguration":{"icebergConfiguration":{"orphanFileRetentionPeriodInDays":5}}}' \
--type orphan_file_deletion
```
------
#### [ API ]
Appelez l'[UpdateTableOptimizer](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-table-optimizers.html#aws-glue-api-table-optimizers-UpdateTableOptimizer)opération pour mettre à jour l'optimiseur de suppression de fichiers orphelins pour une table.
------
# Désactivation de la suppression des fichiers orphelins
Vous pouvez désactiver l'optimiseur de suppression de fichiers orphelins pour une table Apache Iceberg particulière à l'aide AWS Glue de la console ou. AWS CLI
------
#### [ Console ]
**Pour désactiver la suppression des fichiers orphelins**
1. Choisissez **Catalogue de données**, puis choisissez **Tables**. Dans la liste des tables, choisissez la table Iceberg dont vous souhaitez désactiver l’optimiseur pour la suppression des fichiers orphelins.
1. Dans la section inférieure de la page des **Détails des tables**, choisissez l’onglet **Optimisation des tables**.
1. Choisissez **Actions**, puis sélectionnez **Désactiver**, **Suppression des fichiers orphelins**.
Vous pouvez également choisir **Désactiver** sous **Optimisation** depuis le menu **Actions**.
1. Choisissez **Désactiver** dans le message de confirmation. Vous pouvez réactiver l’optimiseur de suppression des fichiers orphelins ultérieurement.
Une fois que vous avez confirmé, l’optimiseur de suppression des fichiers orphelins est désactivé et l’état de suppression des fichiers orphelins revient à `Not enabled`.
------
#### [ AWS CLI ]
Dans l'exemple suivant, remplacez l'ID de compte par un ID de AWS compte valide. Remplacez le nom de la base de données et le nom de la table par un nom réel de la table Iceberg et le nom de la base de données. Remplacez le `roleArn` par le nom de AWS ressource (ARN) du rôle IAM et le nom réel du rôle IAM disposant des autorisations requises pour désactiver l'optimiseur.
```
aws glue update-table-optimizer \
--catalog-id 123456789012 \
--database-name iceberg_db \
--table-name iceberg_table \
--table-optimizer-configuration '{"roleArn":"arn:aws:iam::123456789012:role/optimizer_role", "enabled":'false'}'\
--type orphan_file_deletion
```
------
#### [ API ]
Appelez l'[UpdateTableOptimizer](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-table-optimizers.html#aws-glue-api-table-optimizers-UpdateTableOptimizer)opération pour désactiver l'optimiseur de rétention des instantanés pour une table spécifique.
------
# Affichage des détails de l’optimisation
Vous pouvez consulter l'état d'optimisation des tables Apache Iceberg dans la AWS Glue console ou à l'aide des opérations d' AWS API. AWS CLI
------
#### [ Console ]
**Pour afficher l’état d’optimisation des tables Iceberg (console)**
+ Vous pouvez consulter l'état d'optimisation des tables Iceberg sur la AWS Glue console en choisissant une table Iceberg dans la liste des **tables** sous Catalogue de **données**. Sous **Optimisation des tables**. Choisissez l’option **Afficher tout**.
![\[Page de détails des tables Apache Iceberg avec l’option Activer le compactage.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/table-list-compaction-status.png)
------
#### [ AWS CLI ]
Vous pouvez consulter les détails de l'optimisation à l'aide de AWS CLI.
Dans les exemples suivants, remplacez l'ID de compte par un ID de AWS compte valide, le nom de la base de données et le nom de la table par le nom réel de la table Iceberg. Pour `type`, indiquez un type d’optimisation. Les valeurs acceptables sont `compaction`, `retention` et `orphan-file-deletion`.
+ **Pour obtenir les détails de la dernière exécution du compactage d’une table**
```
aws get-table-optimizer \
--catalog-id 123456789012 \
--database-name iceberg_db \
--table-name iceberg_table \
--type compaction
```
+ Utilisez l’exemple suivant pour récupérer l’historique d’un optimiseur pour une table spécifique.
```
aws list-table-optimizer-runs \
--catalog-id 123456789012 \
--database-name iceberg_db \
--table-name iceberg_table \
--type compaction
```
+ L’exemple suivant montre comment récupérer les détails de l’exécution de l’optimisation et de la configuration de plusieurs optimiseurs. Vous pouvez spécifier un maximum de 20 optimiseurs.
```
aws glue batch-get-table-optimizer \
--entries '[{"catalogId":"123456789012", "databaseName":"iceberg_db", "tableName":"iceberg_table", "type":"compaction"}]'
```
------
#### [ API ]
+ Utilisez l’opération `GetTableOptimizer` pour récupérer les détails de la dernière exécution d’un optimiseur.
+ Utilisez l’opération `ListTableOptimizerRuns` pour récupérer l’historique d’un optimiseur donné sur une table spécifique. Vous pouvez spécifier 20 optimiseurs en un seul appel d’API.
+ Utilisez cette [BatchGetTableOptimizer](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-table-optimizers.html#aws-glue-api-table-optimizers-BatchGetTableOptimizer)opération pour récupérer les détails de configuration de plusieurs optimiseurs de votre compte.
------
# Afficher Amazon CloudWatch les métriques
Après avoir exécuté les optimisateurs de tables avec succès, le service crée des métriques Amazon CloudWatch sur les performances de la tâche d’optimisation. Vous pouvez accéder aux **CloudWatch métriques** et choisir **Metrics**, **All metrics**. Vous pouvez filtrer les métriques en fonction de l'espace de noms spécifique (par exemple AWS Glue), du nom de la table ou du nom de la base de données.
Pour de plus amples informations, consultez [Affichage des métriques disponibles](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/viewing_metrics_with_cloudwatch.html) dans le *Guide de l'utilisateur Amazon CloudWatch *.
****Compactage****
+ Nombre d’octets compactés
+ Nombre de fichiers compactés
+ Nombre de DPU allouées à la tâche
+ Durée de la tâche (heures)
****Conservation des instantanés****
+ Nombre de fichiers de données supprimés
+ Nombre de fichiers manifestes supprimés
+ Nombre de listes de manifestes supprimées
+ Durée de la tâche (heures)
****Suppression de fichiers orphelins****
+ Nombre de fichiers orphelins supprimés
+ Durée de la tâche (heures)
# Suppression d'un optimiseur
Vous pouvez supprimer un optimiseur et les métadonnées associées à la table à l'aide d' AWS CLI une opération d' AWS API.
Exécutez la AWS CLI commande suivante pour supprimer l'historique d'optimisation d'une table. Vous devez spécifier l’optimiseur `type`, ainsi que l’ID du catalogue, le nom de la base de données et le nom de la table. Les valeurs acceptables sont `compaction`, `retention` et `orphan_file_deletion`.
```
aws glue delete-table-optimizer \
--catalog-id 123456789012 \
--database-name iceberg_db \
--table-name iceberg_table \
--type compaction
```
Utilisez l'opération `DeleteTableOptimizer` pour supprimer un optimiseur pour une table.
# Considérations et restrictions
Cette section inclut les éléments à prendre en compte lors de l’utilisation d’optimiseurs de tables dans AWS Glue Data Catalog.
## Durabilité et exactitude
**Emplacements des tables S3 :**
Lorsque plusieurs AWS Glue Data Catalog tables partagent le même emplacement Amazon S3 et que les optimiseurs sont activés, l'optimiseur de conservation des instantanés ou de suppression de fichiers orphelins pour une table peut supprimer les fichiers qui sont toujours référencés par l'autre table. Assurez-vous que chaque table sur laquelle les optimiseurs sont activés possède un emplacement Amazon S3 unique qui n'est partagé avec aucune autre table, y compris les tables de différentes bases de données.
**Expiration du cycle de vie S3 :**
Les règles d'expiration du cycle de vie d'Amazon S3 qui s'appliquent aux emplacements de stockage des tables Iceberg peuvent supprimer le manifeste et les fichiers de données qui sont toujours référencés par des instantanés actifs. Si votre bucket comporte des règles d'expiration du cycle de vie, assurez-vous qu'elles excluent le chemin de stockage des tables Iceberg.
## Formats pris en charge et restrictions pour le compactage de données géré
Le compactage des données prend en charge divers types de fichiers et formats de compression pour la lecture et l’écriture de données, y compris la lecture de données provenant de tables chiffrées.
**Contrôle de la simultanéité :**
Apache Iceberg prend en charge un contrôle de simultanéité optimiste, permettant à plusieurs rédacteurs d'effectuer des opérations simultanément. Les conflits sont détectés et résolus au moment de la validation. Lorsque vous travaillez avec des pipelines de streaming, configurez les paramètres de nouvelle tentative appropriés via les propriétés des tables et les paramètres de compactage afin de gérer efficacement les écritures simultanées. Pour obtenir des conseils détaillés, consultez le blog AWS Big Data sur la [gestion des écritures simultanées dans les tables Iceberg](https://aws.amazon.com/blogs/big-data/manage-concurrent-write-conflicts-in-apache-iceberg-on-the-aws-glue-data-catalog/).
**Nouvelles tentatives de compactage :**
Lorsque les opérations de compactage échouent quatre fois de suite, l'optimisation de la table de AWS Glue catalogue suspend automatiquement l'optimiseur pour éviter une consommation inutile de ressources informatiques. Examinez d'abord les journaux et essayez de comprendre pourquoi le compactage échoue à plusieurs reprises. Pour reprendre l'optimisation du compactage, vous pouvez réactiver l'optimiseur via la AWS Glue console ou l'API.
**Le compactage des données prend en charge :**
+ **Chiffrement** : le compactage des données prend uniquement en charge le chiffrement Amazon S3 (SSE-S3) et le chiffrement KMS côté serveur (SSE-KMS).
+ **Stratégies de compactage** : binpack, tri et tri par ordre Z
+ Vous pouvez exécuter le compactage depuis le compte où réside le catalogue de données lorsque le compartiment Amazon S3 qui stocke les données sous-jacentes se trouve dans un autre compte. Pour ce faire, le rôle de compactage nécessite l’accès au compartiment Amazon S3.
**Le compactage des données ne prend pas en charge actuellement :**
+ **Compactage sur des tables entre comptes** : vous ne pouvez pas exécuter le compactage sur des tables entre comptes.
+ **Compactage sur des tables entre régions** : vous ne pouvez pas exécuter le compactage sur des tables entre régions.
+ **Activation du compactage sur des liens de ressources**
+ **Tables de la classe de stockage Amazon S3 Express One Zone** : vous ne pouvez pas exécuter le compactage sur les tables Amazon S3 Express One Zone Iceberg.
+ **La stratégie de compactage par ordre Z ne prend pas en charge les types de données suivants :**
+ Décimal
+ TimestampWithoutZone
## Considérations relatives à la conservation des instantanés et aux optimiseurs de suppression de fichiers orphelins
Les considérations suivantes s’appliquent à la conservation des instantanés et aux optimiseurs de suppression des fichiers orphelins.
+ Les processus de conservation des instantanés et de suppression de fichiers orphelins ont une limite maximale de suppression de 1 000 000 fichiers par exécution. Lorsque vous supprimez des instantanés expirés, si le nombre de fichiers éligibles à la suppression dépasse 1 000 000, tous les fichiers restants au-delà de ce seuil continueront d’exister dans le stockage de la table en tant que fichiers orphelins.
+ Les instantanés sont conservés par l’optimiseur de conservation d’instantanés seulement lorsque les deux critères suivants sont remplis : le nombre minimum d’instantanés à conserver et la période de conservation spécifiée.
+ L’optimiseur de conservation d’instantanés supprime les métadonnées des instantanés expirés d’Apache Iceberg, empêchant ainsi les requêtes d’historique d’instantanés expirés et supprimant éventuellement les fichiers de données associés.
+ L’optimiseur de suppression des fichiers orphelins supprime les fichiers de données et de métadonnées qui ne sont plus référencés par les métadonnées Iceberg si leur date de création est antérieure à la période de conservation des fichiers orphelins à compter de l’exécution de l’optimiseur.
+ Apache Iceberg facilite le contrôle des versions grâce à des branches et des balises, qui sont des pointeurs nommés vers des états d’instantanés spécifiques. Chaque branche et balise suit son propre cycle de vie indépendant, régi par des politiques de conservation définies à leurs niveaux respectifs. Les AWS Glue Data Catalog optimiseurs tiennent compte de ces politiques de cycle de vie, garantissant ainsi le respect des règles de conservation spécifiées. Les politiques de conservation au niveau des branches et des balises ont priorité sur les configurations de l’optimiseur.
Pour plus d’informations, consultez [Branching and Tagging](https://iceberg.apache.org/docs/nightly/branching/) dans la documentation Apache Iceberg.
+ Les optimiseurs de conservation des instantanés et de suppression de fichiers orphelins supprimeront les fichiers éligibles au nettoyage conformément aux paramètres configurés. Améliorez votre contrôle sur la suppression de fichiers en mettant en œuvre des politiques de gestion des versions et de cycle de vie S3 sur les compartiments appropriés.
Pour obtenir des instructions détaillées sur la configuration de la gestion des versions et la création de règles de cycle de vie, consultez [https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html).
+ Pour déterminer correctement les fichiers orphelins, assurez-vous que l’emplacement de la table fourni et les éventuels sous-chemins ne se chevauchent pas ou ne contiennent pas de données provenant d’autres tables ou sources de données. Si les chemins se chevauchent, vous risquez une perte de données irrécupérable en cas de suppression involontaire de fichiers.
## Exception de débogage OversizedAllocationException
Pour résoudre une exception `OversizedAllocationException` :
+ Réduisez la taille du lot du lecteur vectorisé et vérifiez. La taille du lot par défaut est de 5 000. Ceci est contrôlé dans `read.parquet.vectorization.batch-size`.
+ Si cela ne fonctionne pas même après plusieurs variations, désactivez la vectorisation. Ceci est contrôlé dans `read.parquet.vectorization.enabled`.
# Régions prises en charge pour les optimiseurs de tables
Les fonctionnalités d'optimisation des tables (compactage, conservation des instantanés et suppression de fichiers orphelins) pour AWS Glue Data Catalog sont disponibles dans les versions suivantes : Régions AWS
+ Asie-Pacifique (Tokyo)
+ Asie-Pacifique (Séoul)
+ Asie-Pacifique (Mumbai)
+ Asie-Pacifique (Singapour)
+ Asie-Pacifique (Sydney)
+ Asie-Pacifique (Jakarta)
+ Canada (Centre)
+ Europe (Irlande)
+ Europe (Londres)
+ Europe (Francfort)
+ Europe (Stockholm)
+ USA Est (Virginie du Nord)
+ USA Est (Ohio)
+ USA Ouest (Oregon)
+ Amérique du Sud (São Paulo)
# Optimisation des performances des requêtes pour les tables Iceberg
Apache Iceberg est un format de table ouverte très performant pour de grands ensembles de données analytiques. AWS Glue prend en charge le calcul et la mise à jour du nombre de valeurs distinctes (NDVs) pour chaque colonne des tables Iceberg. Ces statistiques peuvent améliorer l’optimisation des requêtes, la gestion des données et l’efficacité des performances pour les ingénieurs et les scientifiques de données travaillant avec des jeux de données à grande échelle.
AWS Glue estime le nombre de valeurs distinctes dans chaque colonne de la table Iceberg et les stocke dans des fichiers [Puffin](https://iceberg.apache.org/puffin-spec/) sur Amazon S3 associés à des instantanés de table Iceberg. Puffin est un format de fichier Iceberg conçu pour stocker des métadonnées telles que des index, des statistiques et des croquis. Le stockage de croquis dans des fichiers Puffin liés à des instantanés garantit la cohérence transactionnelle et l’actualité des statistiques NDV.
Vous pouvez configurer pour exécuter la tâche de génération de statistiques de colonne à l'aide de AWS Glue la console ou AWS CLI. Lorsque vous lancez le processus, AWS Glue démarre une tâche Spark en arrière-plan et met à jour les métadonnées de la AWS Glue table dans le catalogue de données. Vous pouvez consulter les statistiques des colonnes à l'aide de la AWS Glue console AWS CLI ou en appelant l'opération [GetColumnStatisticsForTable](https://docs.aws.amazon.com/glue/latest/webapi/API_GetColumnStatisticsForTable.html)API.
**Note**
Si vous utilisez AWS Lake Formation des autorisations pour contrôler l'accès à la table, le rôle assumé par la tâche de statistiques sur les colonnes nécessite un accès complet à la table pour générer des statistiques.
**Topics**
+ [Conditions préalables à la génération de statistiques de colonne](iceberg-column-stats-prereqs.md)
+ [Génération de statistiques de colonne pour les tables Iceberg](iceberg-generate-column-stats.md)
+ [Consultez aussi](#see-also-iceberg-stats)
# Conditions préalables à la génération de statistiques de colonne
Pour générer ou mettre à jour des statistiques de colonne pour les tables Iceberg, la tâche de génération de statistiques assume un rôle Gestion des identités et des accès AWS (IAM) en votre nom. Sur la base des autorisations accordées au rôle, la tâche de génération de statistiques de colonne peut lire les données à partir du magasin de données Amazon S3.
Lorsque vous configurez la tâche de génération de statistiques de AWS Glue colonne, vous pouvez créer un rôle qui inclut la politique `AWSGlueServiceRole` AWS gérée ainsi que la politique en ligne requise pour la source de données spécifiée.
Si vous spécifiez un rôle existant pour la génération de statistiques de colonne, assurez-vous qu’il inclut la politique `AWSGlueServiceRole` ou l’équivalent (ou une version limitée de cette politique), ainsi que les politiques en ligne requises.
Pour plus d’informations sur les autorisations requises, consultez [Conditions préalables à la génération de statistiques de colonne](column-stats-prereqs.md).
# Génération de statistiques de colonne pour les tables Iceberg
Procédez comme suit pour configurer un calendrier de génération de statistiques dans le catalogue de données à l'aide de la AWS Glue console AWS CLI ou de l'opération ou exécutez l'**StartColumnStatisticsTaskRun**opération.
**Pour générer des statistiques de colonne**
1. Connectez-vous à la AWS Glue console à l'adresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Sélectionnez **Tables** sous Catalogue de données.
1. Choisissez une table Iceberg dans la liste.
1. Choisissez **Statistiques de colonne**, **Générer à la demande** dans le menu **Actions**.
Vous pouvez également choisir le bouton **Générer des statistiques** sous l'onglet **Statistiques de colonne** dans la section inférieure de la page **Tables**.
1. Sur la page **Générer des statistiques**, fournissez les détails relatifs à la génération des statistiques. Suivez les étapes 6 à 11 de la section [Génération de statistiques de colonne selon un calendrier](generate-column-stats.md) pour configurer un calendrier de génération de statistiques pour les tables Iceberg.
Vous pouvez également choisir de générer des statistiques de colonnes à la demande en suivant les instructions de [Génération de statistiques de colonne à la demande](column-stats-on-demand.md).
**Note**
L’option d’échantillonnage n’est pas disponible pour les tables Iceberg.
AWS Glue calcule le nombre de valeurs distinctes pour chaque colonne de la table Iceberg dans un nouveau fichier Puffin validé avec l'ID de snapshot spécifié dans votre emplacement Amazon S3.
## Consultez aussi
+ [Affichage des statistiques de colonne](view-column-stats.md)
+ [Affichage des exécutions de tâches de statistiques de colonne](view-stats-run.md)
+ [Arrêt d'exécution de la tâche de statistiques de colonne](stop-stats-run.md)
+ [Supprimer les statistiques de colonne](delete-column-stats.md)
# Gestion du catalogue de données
AWS Glue Data Catalog Il s'agit d'un référentiel de métadonnées central qui stocke les métadonnées structurelles et opérationnelles de vos ensembles de données Amazon S3. La gestion efficace du catalogue de données est essentielle au maintien de la qualité, des performances, de la sécurité et de la gouvernance des données.
En comprenant et en appliquant ces pratiques de gestion du catalogue de données, vous pouvez vous assurer que vos métadonnées restent précises, performantes, sécurisées et bien gouvernées au fil de l’évolution de votre environnement de données.
Cette section couvre les aspects suivants de la gestion du catalogue de données :
+ *Mise à jour du schéma de table et des partitions* : à mesure de l’évolution de vos données, vous devrez peut-être mettre à jour le schéma de table ou la structure de partition définis dans le catalogue de données. Pour plus d'informations sur la façon d'effectuer ces mises à jour par programmation à l'aide de l' AWS Glue ETL, consultez. [Mise à jour du schéma et ajout de nouvelles partitions dans le catalogue de données à l’aide des tâches AWS Glue ETL](update-from-job.md)
+ *Gestion des statistiques de colonne* : des statistiques précises sur les colonnes permettent d’optimiser les plans de requêtes et d’améliorer les performances. Pour plus d’informations sur la façon de générer, de mettre à jour et de gérer les statistiques de colonne, consultez [Optimisation des performances des requêtes à l’aide des statistiques de colonne](column-statistics.md).
+ *Chiffrement du catalogue de données* Pour protéger les métadonnées sensibles, vous pouvez chiffrer votre catalogue de données à l'aide de AWS Key Management Service ()AWS KMS. Cette section explique comment activer et gérer le chiffrement de votre catalogue de données.
+ *Sécurisation du catalogue de données avec AWS Lake Formation* : Lake Formation fournit une approche globale de la sécurité des lacs de données et du contrôle d’accès. Vous pouvez utiliser Lake Formation pour sécuriser et régir l’accès à votre catalogue de données et aux données sous-jacentes.
**Topics**
+ [Mise à jour du schéma et ajout de nouvelles partitions dans le catalogue de données à l’aide des tâches AWS Glue ETL](update-from-job.md)
+ [Optimisation des performances des requêtes à l’aide des statistiques de colonne](column-statistics.md)
+ [Chiffrement de votre catalogue de données](catalog-encryption.md)
+ [Sécurisation de votre catalogue de données à l’aide de Lake Formation](secure-catalog.md)
+ [Utilisation des AWS Glue Data Catalog vues dans AWS Glue](catalog-views.md)
# 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..
# Optimisation des performances des requêtes à l’aide des statistiques de colonne
Vous pouvez calculer des statistiques au niveau des colonnes pour AWS Glue Data Catalog des tables dans des formats de données tels que Parquet, ORC, JSON, ION, CSV et XML sans configurer de pipelines de données supplémentaires. Les statistiques de colonne vous aident à comprendre les profils de données en obtenant des informations sur les valeurs d'une colonne.
Le catalogue de données prend en charge la génération de statistiques pour les valeurs de colonne telles que la valeur minimale, la valeur maximale, le total des valeurs nulles, le total des valeurs distinctes, la longueur moyenne des valeurs et le nombre total d'occurrences de valeurs vraies. AWS des services analytiques tels qu'Amazon Redshift et Amazon Athena peuvent utiliser ces statistiques de colonne pour générer des plans d'exécution des requêtes et choisir le plan optimal qui améliore les performances des requêtes.
Il existe trois scénarios pour générer des statistiques de colonne :
**Automatique**
AWS Glue prend en charge la génération automatique de statistiques sur les colonnes au niveau du catalogue afin de pouvoir générer automatiquement des statistiques pour les nouvelles tables du. AWS Glue Data Catalog
**Programmé**
AWS Glue prend en charge la génération de statistiques de colonne de planification afin qu'elle puisse être exécutée automatiquement selon un calendrier récurrent.
Avec le calcul planifié des statistiques, la tâche de statistiques sur les colonnes met à jour les statistiques globales au niveau de la table, telles que min, max et avg, avec les nouvelles statistiques, fournissant aux moteurs de requêtes des statistiques précises et up-to-date permettant d'optimiser l'exécution des requêtes.
**À la demande**
Utilisez cette option pour générer des statistiques de colonnes à la demande chaque fois que cela s’avère nécessaire. Cela est utile pour les analyses ad hoc ou lorsque les statistiques doivent être calculées immédiatement.
Vous pouvez configurer pour exécuter une tâche de génération de statistiques de colonne à l'aide des AWS CLI opérations de AWS Glue console et AWS Glue d'API. Lorsque vous lancez le processus, AWS Glue démarre une tâche Spark en arrière-plan et met à jour les métadonnées de la AWS Glue table dans le catalogue de données. Vous pouvez consulter les statistiques des colonnes à l'aide de la AWS Glue console AWS CLI ou en appelant l'opération [GetColumnStatisticsForTable](https://docs.aws.amazon.com/glue/latest/webapi/API_GetColumnStatisticsForTable.html)API.
**Note**
Si vous utilisez les autorisations de Lake Formation pour contrôler l'accès à la table, le rôle assumé par la tâche de statistiques de colonne nécessite un accès complet à la table pour générer des statistiques.
La vidéo suivante montre comment améliorer les performances des requêtes à l’aide des statistiques de colonne.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/zUHEXJdHUxs?si=HjyhpoALR6RXJz2i)
**Topics**
+ [Conditions préalables à la génération de statistiques de colonne](column-stats-prereqs.md)
+ [Génération automatique de statistiques de colonne](auto-column-stats-generation.md)
+ [Génération de statistiques de colonne selon un calendrier](generate-column-stats.md)
+ [Génération de statistiques de colonne à la demande](column-stats-on-demand.md)
+ [Affichage des statistiques de colonne](view-column-stats.md)
+ [Affichage des exécutions de tâches de statistiques de colonne](view-stats-run.md)
+ [Arrêt d'exécution de la tâche de statistiques de colonne](stop-stats-run.md)
+ [Supprimer les statistiques de colonne](delete-column-stats.md)
+ [Considérations et restrictions](column-stats-notes.md)
# Conditions préalables à la génération de statistiques de colonne
Pour générer ou mettre à jour les statistiques de colonne, la tâche de génération de statistiques assume un rôle (IAM) Gestion des identités et des accès AWS en votre nom. Sur la base des autorisations accordées au rôle, la tâche de génération de statistiques de colonne peut lire les données à partir du magasin de données Amazon S3.
Lorsque vous configurez la tâche de génération de statistiques de AWS Glue colonne, vous pouvez créer un rôle qui inclut la politique `AWSGlueServiceRole` AWS gérée ainsi que la politique en ligne requise pour la source de données spécifiée.
Si vous spécifiez un rôle existant pour la génération de statistiques de colonne, assurez-vous qu’il inclut la politique `AWSGlueServiceRole` ou un équivalent (ou une version limitée de cette politique), en plus des politiques en ligne requises. Pour créer un rôle IAM, procédez comme suit :
**Note**
Pour générer des statistiques pour les tables gérées par Lake Formation, le rôle IAM utilisé pour générer des statistiques nécessite un accès complet à la table.
Lorsque vous configurez la tâche de génération de statistiques de AWS Glue colonne, vous pouvez créer un rôle qui inclut la politique `AWSGlueServiceRole` AWS gérée ainsi que la politique en ligne requise pour la source de données spécifiée. Vous pouvez également créer un rôle et associer les autorisations répertoriées dans la politique ci-dessous, et ajouter ce rôle à la tâche de génération de statistiques de colonne.
**Pour créer un rôle IAM pour générer des statistiques de colonne**
1. Pour créer un rôle IAM, consultez [Création d'un rôle IAM pour AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/create-an-iam-role.html).
1. Pour mettre à jour un rôle existant, dans la console IAM, accédez au rôle IAM utilisé par le processus de génération de statistiques de colonne.
1. Dans la section **Ajouter des autorisations**, choisissez **Attacher des stratégies**. Dans la fenêtre du navigateur qui vient d'être ouverte, choisissez la politique `AWSGlueServiceRole` AWS gérée.
1. Vous devez également inclure les autorisations pour lire les données à partir de l’emplacement de données Amazon S3.
Dans la section **Ajouter des autorisations**, choisissez **Créer une stratégie**. Dans la fenêtre du navigateur nouvellement ouverte, créez une nouvelle stratégie à utiliser avec votre rôle.
1. Sur la page **Créer une stratégie**, choisissez l’onglet **JSON**. Copiez le code `JSON` suivant dans le champ de l’éditeur de stratégie.
**Note**
Dans les politiques suivantes, remplacez l'ID de compte par un identifiant valide Compte AWS, puis `region` remplacez-le par la région du tableau et `bucket-name` par le nom du compartiment Amazon S3.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "S3BucketAccess",
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket"
]
}
]
}
```
------
1. (Facultatif) Si vous utilisez les autorisations Lake Formation pour accéder à vos données, le rôle IAM nécessite des autorisations `lakeformation:GetDataAccess`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "LakeFormationDataAccess",
"Effect": "Allow",
"Action": "lakeformation:GetDataAccess",
"Resource": [
"*"
]
}
]
}
```
------
Si l’emplacement des données Amazon S3 est enregistré auprès de Lake Formation et que le rôle IAM assumé par la tâche de génération de statistiques de colonne ne dispose pas d’autorisations de groupe `IAM_ALLOWED_PRINCIPALS` accordées sur la table, le rôle nécessite Lake Formation `ALTER` et des autorisations `DESCRIBE` sur la table. Le rôle utilisé pour enregistrer le compartiment Amazon S3 nécessite Lake Formation `INSERT` et des autorisations `DELETE` sur la table.
Si l’emplacement des données Amazon S3 n’est pas enregistré auprès de Lake Formation et que le rôle IAM ne dispose pas d’autorisations de groupe `IAM_ALLOWED_PRINCIPALS` accordées sur la table, le rôle nécessite les autorisations Lake Formation `ALTER`, `DESCRIBE`, `INSERT` et `DELETE` sur la table.
1. Si vous avez activé l’option `Automatic statistics generation` au niveau du catalogue, le rôle IAM doit disposer de l’autorisation `glue:UpdateCatalog` ou de l’autorisation `ALTER CATALOG` Lake Formation sur le catalogue de données par défaut. Vous pouvez utiliser l’opération `GetCatalog` pour vérifier les propriétés du catalogue.
1. (Facultatif) La tâche de génération de statistiques de colonne qui écrit Amazon CloudWatch Logs chiffré nécessite les autorisations suivantes dans la stratégie de clé.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CWLogsKmsPermissions",
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:AssociateKmsKey"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/aws-glue:*"
]
},
{
"Sid": "KmsPermissions",
"Effect": "Allow",
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt",
"kms:Encrypt"
],
"Resource": [
"arn:aws:kms:us-east-1:111122223333:key/arn of key used for ETL cloudwatch encryption"
],
"Condition": {
"StringEquals": {
"kms:ViaService": [
"glue.us-east-1.amazonaws.com"
]
}
}
}
]
}
```
------
1. Le rôle que vous utilisez pour exécuter les statistiques de colonne doit disposer de l’autorisation `iam:PassRole` correspondante.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/columnstats-role-name"
]
}
]
}
```
------
1. Lorsque vous créez un rôle IAM pour générer des statistiques de colonne, ce rôle doit également avoir la stratégie d’approbation suivante qui permet au service d’assumer le rôle.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "TrustPolicy",
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
# Génération automatique de statistiques de colonne
La génération automatique de statistiques de colonne vous permet de planifier et de calculer automatiquement les statistiques sur les nouvelles tables de l’ AWS Glue Data Catalog. Lorsque vous activez la génération automatique de statistiques, le catalogue de données découvre de nouvelles tables avec des formats de données spécifiques tels que Parquet, JSON, CSV, XML, ORC, ION et Apache Iceberg, ainsi que leurs chemins d’accès aux compartiments individuels. Avec une configuration de catalogue unique, le catalogue de données génère des statistiques pour ces tables.
Les administrateurs de lac de données peuvent configurer la génération de statistiques en sélectionnant le catalogue par défaut dans la console Lake Formation et en activant les statistiques des tables à l’aide de l’option `Optimization configuration`. Lorsque vous créez de nouvelles tables ou que vous mettez à jour des tables existantes dans le catalogue de données, le catalogue de données collecte le nombre de valeurs distinctes (NDVs) pour les tables Apache Iceberg, ainsi que des statistiques supplémentaires telles que le nombre de valeurs nulles, la longueur maximale, minimale et moyenne pour les autres formats de fichiers pris en charge sur une base hebdomadaire.
Si vous avez configuré la génération de statistiques au niveau de la table ou si vous avez précédemment supprimé les paramètres de génération de statistiques d’une table, ces paramètres propres à la table ont priorité sur les paramètres de catalogue par défaut pour la génération automatique de statistiques de colonne.
La tâche de génération automatique de statistiques analyse 50 % des enregistrements des tables pour calculer les statistiques. La génération automatique de statistiques de colonne garantit que le catalogue de données conserve des métriques hebdomadaires qui peuvent être utilisées par les moteurs de requêtes tels qu’Amazon Athena et Amazon Redshift Spectrum pour améliorer les performances des requêtes et réaliser des économies potentielles. Il permet de planifier la génération de statistiques à l'aide AWS Glue APIs de la console, fournissant ainsi un processus automatisé sans intervention manuelle.
**Topics**
+ [Activation de la génération automatique de statistiques au niveau du catalogue](enable-auto-column-stats-generation.md)
+ [Affichage des paramètres au niveau de la table automatisés](view-auto-column-stats-settings.md)
+ [Désactivation de la génération de statistiques de colonne au niveau du catalogue](disable-auto-column-stats-generation.md)
# Activation de la génération automatique de statistiques au niveau du catalogue
Vous pouvez activer la génération automatique de statistiques de colonne pour toutes les nouvelles tables Apache Iceberg et les tables dans des formats de table autres que OTF (Parquet, JSON, CSV, XML, ORC, ION) dans le catalogue de données. Après avoir créé la table, vous pouvez également mettre à jour manuellement de manière explicite les paramètres des statistiques de colonne.
Pour mettre à jour les paramètres du catalogue de données afin de les activer au niveau du catalogue, le rôle IAM utilisé doit disposer de l'`glue:UpdateCatalog`autorisation ou de l' AWS Lake Formation `ALTER CATALOG`autorisation sur le catalogue racine. Vous pouvez utiliser l’API `GetCatalog` pour vérifier les propriétés du catalogue.
------
#### [ AWS Management Console ]
**Pour activer la génération automatique de statistiques de colonne au niveau du compte**
1. Ouvrez la console Lake Formation à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Dans la barre de navigation de gauche, choisissez **Catalogues**.
1. Sur la page **Résumé du catalogue**, choisissez **Modifier** sous **Configuration de l’optimisation**.
![\[La capture d'écran montre les options disponibles pour générer des statistiques de colonne.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/edit-column-stats-auto.png)
1. Sur la page de **Configuration de l’optimisation des tables**, choisissez l’option **Activer la génération automatique de statistiques pour les tables du catalogue**.
![\[La capture d'écran montre les options disponibles pour générer des statistiques de colonne.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/edit-optimization-option.jpg)
1. Choisissez un rôle IAM existant ou créez-en un autre avec les autorisations nécessaires pour exécuter la tâche de statistiques de colonne.
1. Sélectionnez **Soumettre**.
------
#### [ AWS CLI ]
Vous pouvez également activer la collecte de statistiques au niveau du catalogue via l’ AWS CLI. Pour configurer la collecte de statistiques au niveau des tables à l'aide de AWS CLI, exécutez la commande suivante :
```
aws glue update-catalog --cli-input-json '{
"name": "123456789012",
"catalogInput": {
"description": "Updating root catalog with role arn",
"catalogProperties": {
"customProperties": {
"ColumnStatistics.RoleArn": "arn:aws:iam::"123456789012":role/service-role/AWSGlueServiceRole",
"ColumnStatistics.Enabled": "true"
}
}
}
}'
```
La commande ci-dessus appelle AWS Glue l'`UpdateCatalog`opération, qui prend en compte une `CatalogProperties` structure avec les paires clé-valeur suivantes pour la génération de statistiques au niveau du catalogue :
+ ColumnStatistics. RoleArn — L'ARN du rôle IAM doit être utilisé pour toutes les tâches déclenchées pour la génération de statistiques au niveau du catalogue
+ ColumnStatistics.Enabled — Booléen indiquant si les paramètres au niveau du catalogue sont activés ou désactivés
------
# Affichage des paramètres au niveau de la table automatisés
Lorsque la collecte de statistiques au niveau du catalogue est activée, chaque fois qu'une table Apache Hive ou Apache Iceberg est créée ou mise à jour via le SDK `CreateTable` ou `UpdateTable` APIs qu'un paramètre de niveau de table équivalent est créé pour cette table. AWS Management Console AWS Glue crawler
Les tables pour lesquelles la génération automatique de statistiques est activée doivent respecter l’une des propriétés suivantes :
+ Utiliser une `InputSerdeLibrary` qui commence par org.apache.hadoop et `TableType` égal à `EXTERNAL_TABLE`
+ Utiliser une `InputSerdeLibrary` qui commence par `com.amazon.ion` et `TableType` égal à `EXTERNAL_TABLE`
+ Contenir table\$1type : « ICEBERG » dans sa structure de paramètres
Après avoir créé ou mis à jour une table, vous pouvez vérifier ses détails pour confirmer la génération de statistiques. `Statistics generation summary` affiche la propriété `Schedule` définie comme `AUTO` et la valeur `Statistics configuration` est `Inherited from catalog`. Tout paramètre de table avec le paramètre suivant serait automatiquement déclenché par Glue en interne.
![\[Une image d’une table Hive avec collecte de statistiques au niveau du catalogue a été appliquée et des statistiques ont été collectées.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/auto-stats-summary.png)
# Désactivation de la génération de statistiques de colonne au niveau du catalogue
Vous pouvez désactiver la génération automatique de statistiques de colonne pour les nouvelles tables à l'aide de la AWS Lake Formation console, de l'`glue:UpdateCatalogSettings`API ou de l'`glue:DeleteColumnStatisticsTaskSettings`API.
**Pour désactiver la génération automatique de statistiques de colonne au niveau du compte**
1. Ouvrez la console Lake Formation à l'adresse [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Dans la barre de navigation de gauche, choisissez **Catalogues**.
1. Sur la page **Résumé du catalogue**, choisissez **Modifier** sous **Configuration de l’optimisation**.
1. Sur la page de **Configuration de l’optimisation des tables**, désélectionnez l’option **Activer la génération automatique de statistiques pour les tables du catalogue**.
1. Sélectionnez **Soumettre**.
# Génération de statistiques de colonne selon un calendrier
Suivez ces étapes pour configurer un calendrier de génération de statistiques de colonne à l' AWS Glue Data Catalog aide de la AWS Glue console, de l' AWS CLI opération ou de l'[CreateColumnStatisticsTaskSettings](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-CreateColumnStatisticsTaskSettings)opération.
------
#### [ Console ]
**Pour générer des statistiques de colonne à l'aide de la console**
1. Connectez-vous à la AWS Glue console à l'adresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Choisissez des tables du catalogue de donnée.
1. Choisissez une table dans la liste.
1. Dans la partie inférieure de la page **Tables**, choisissez **Statistiques de colonne**.
1. Vous pouvez également sélectionner **Générer selon le calendrier** sous **Statistiques de colonne** depuis **Actions**.
1. Sur la page **Générer des statistiques selon le calendrier** configurez un calendrier récurrent pour exécuter la tâche de statistiques de colonne en choisissant la fréquence et l’heure de début. Vous pouvez choisir une fréquence horaire, quotidienne, hebdomadaire ou définir une expression cron pour spécifier le calendrier.
Une expression cron est une chaîne représentant un modèle de planification, composée de 6 champs séparés par des espaces :\$1 \$1 \$1 \$1 \$1 \$1 Par exemple, pour exécuter une tâche tous les jours à minuit, l'expression cron serait : 0 0 \$1 \$1 ? \$1
Pour plus d’informations, consultez [Expressions Cron](https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html#CronExpressions).
![\[La capture d'écran montre les options disponibles pour générer des statistiques de colonne.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/generate-column-stats-schedule.png)
1. Ensuite, choisissez l’option de colonne pour générer des statistiques.
+ **Toutes les colonnes** : choisissez cette option pour générer des statistiques pour toutes les colonnes de la table.
+ **Colonnes sélectionnées** : choisissez cette option pour générer des statistiques pour des colonnes spécifiques. Vous pouvez sélectionner les colonnes dans la liste déroulante.
1. Choisissez un rôle IAM ou créez un rôle existant autorisé à générer des statistiques. AWS Glue assume ce rôle pour générer des statistiques de colonne.
Une approche plus rapide consiste à laisser la AWS Glue console créer un rôle pour vous. Le rôle qu'il crée est spécifiquement destiné à générer des statistiques sur les colonnes et inclut la politique `AWSGlueServiceRole` AWS gérée ainsi que la politique en ligne requise pour la source de données spécifiée.
Si vous spécifiez un rôle existant pour la génération de statistiques de colonne, assurez-vous qu’il inclut la politique `AWSGlueServiceRole` ou un équivalent (ou une version limitée de cette politique), en plus des politiques en ligne requises.
1. (Facultatif) Choisissez ensuite une configuration de sécurité pour activer le chiffrement au repos des journaux.
1. (Facultatif) Vous pouvez choisir une taille d’échantillon en indiquant uniquement un pourcentage spécifique de lignes dans la table pour générer des statistiques. La valeur par défaut est toutes les lignes. Utilisez les flèches haut et bas pour augmenter ou diminuer la valeur en pourcentage.
Nous vous recommandons d'inclure toutes les lignes de la table pour calculer des statistiques précises. Utilisez des exemples de lignes pour générer des statistiques de colonne uniquement lorsque des valeurs approximatives sont acceptables.
1. Choisissez **Générer des statistiques** pour exécuter la tâche de génération des statistiques de colonne.
------
#### [ AWS CLI ]
Vous pouvez utiliser l' AWS CLI exemple suivant pour créer un calendrier de génération de statistiques de colonnes. Le nom de la base de données, le nom de la table et le rôle sont des paramètres obligatoires, tandis que les paramètres facultatifs sont le planning, l'identifiant du catalogue column-name-list, la taille de l'échantillon et la configuration de sécurité.
```
aws glue create-column-statistics-task-settings \
--database-name 'database_name' \
--table-name table_name \
--role 'arn:aws:iam::123456789012:role/stats-role' \
--schedule 'cron(0 0-5 14 * * ?)' \
--column-name-list 'col-1' \
--catalog-id '123456789012' \
--sample-size '10.0 ' \
--security-configuration 'test-security'
```
Vous pouvez également générer des statistiques de colonne en appelant l'[StartColumnStatisticsTaskRun](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-StartColumnStatisticsTaskRun)opération.
------
# Gestion du calendrier de génération des statistiques de colonne
Vous pouvez gérer les opérations de planification telles que la mise à jour, le démarrage, l’arrêt et la suppression des planifications pour les statistiques de colonne générées dans AWS Glue. Vous pouvez utiliser les [opérations de l'API de statistiques de AWS Glue console ou de AWS Glue colonne](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html) pour effectuer ces tâches. AWS CLI
**Topics**
+ [Mise à jour du calendrier de génération des statistiques de colonne](#update-column-stats-shedule)
+ [Arrêt du calendrier de génération des statistiques de colonne](#stop-column-stats-schedule)
+ [Reprise du calendrier pour la génération des statistiques de colonne](#resume-column-stats-schedule)
+ [Suppression du calendrier de génération de statistiques de colonne](#delete-column-stats-schedule)
## Mise à jour du calendrier de génération des statistiques de colonne
Vous pouvez mettre à jour le calendrier pour déclencher la tâche de génération des statistiques de colonne après sa création. Vous pouvez utiliser la AWS Glue console ou exécuter l'[UpdateColumnStatisticsTaskSettings](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-UpdateColumnStatisticsTaskSettings)opération pour mettre à jour le calendrier d'une table. AWS CLI Vous pouvez modifier les paramètres d’un calendrier existant, tels que le type de calendrier (à la demande ou planifié) et d’autres paramètres facultatifs.
------
#### [ AWS Management Console ]
**Pour mettre à jour les paramètres d’une tâche de génération de statistiques de colonne**
1. Connectez-vous à la AWS Glue console à l'adresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Choisissez la table que vous voulez mettre à jour dans la liste.
1. Dans la partie inférieure de la page de détails de la table, choisissez **Statistiques de colonne**.
1. Sous **Actions**, choisissez **Modifier** pour mettre à jour le calendrier.
1. Apportez les modifications souhaitées au calendrier, puis cliquez sur **Enregistrer**.
------
#### [ AWS CLI ]
Si vous n'utilisez pas la fonction AWS Glue de génération de statistiques de la console, vous pouvez mettre à jour le calendrier manuellement à l'aide de la `update-column-statistics-task-settings` commande. L'exemple suivant montre comment mettre à jour les statistiques de colonne à l'aide de la AWS CLI.
```
aws glue update-column-statistics-task-settings \
--database-name 'database_name' \
--table-name 'table_name' \
--role arn:aws:iam::123456789012:role/stats_role \
--schedule 'cron(0 0-5 16 * * ?)' \
--column-name-list 'col-1' \
--sample-size '20.0' \
--catalog-id '123456789012'\
--security-configuration 'test-security'
```
------
## Arrêt du calendrier de génération des statistiques de colonne
Si vous n’avez plus besoin des statistiques incrémentielles, vous pouvez arrêter la génération planifiée pour économiser des ressources et des coûts. La suspension du calendrier n’a aucune incidence sur les statistiques générées précédemment. Vous pouvez reprendre le calendrier à votre convenance.
------
#### [ AWS Management Console ]
**Pour arrêter le calendrier pour une tâche de génération des statistiques de colonne**
1. Sur AWS Glue la console, sélectionnez **Tables** sous Catalogue de données.
1. Sélectionnez une table avec des statistiques de colonne.
1. Sur la page **Détails de la table**, choisissez **Statistiques de colonne**.
1. Sous **Actions**, choisissez **Génération planifiée**, puis **Pause**.
1. Choisissez **Pause** pour confirmer.
------
#### [ AWS CLI ]
Pour arrêter le calendrier d'exécution d'une tâche de statistiques de colonne à l'aide de AWS CLI, vous pouvez utiliser la commande suivante :
```
aws glue stop-column-statistics-task-run-schedule \
--database-name ''database_name' \
--table-name 'table_name'
```
Remplacez les valeurs `database_name` et `table_name` par les noms réels de la base de données et de la table pour lesquelles vous souhaitez arrêter le calendrier d’exécution de la tâche de statistiques de colonne.
------
## Reprise du calendrier pour la génération des statistiques de colonne
Si vous avez suspendu le calendrier de génération des statistiques, vous AWS Glue permet de le reprendre à votre convenance. Vous pouvez reprendre le planning à l'aide de la AWS Glue AWS CLI console ou de l'[StartColumnStatisticsTaskRunSchedule](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-StartColumnStatisticsTaskRunSchedule)opération.
------
#### [ AWS Management Console ]
**Pour reprendre le calendrier de génération des statistiques de colonne**
1. Sur AWS Glue la console, sélectionnez **Tables** sous Catalogue de données.
1. Sélectionnez une table avec des statistiques de colonne.
1. Sur la page **Détails de la table**, choisissez **Statistiques de colonne**.
1. Sous **Actions**, choisissez **Génération planifiée**, puis **Reprendre**.
1. Choisissez **Reprendre** pour confirmer.
------
#### [ AWS CLI ]
Remplacez les valeurs `database_name` et `table_name` par les noms réels de la base de données et de la table pour lesquelles vous souhaitez arrêter le calendrier d’exécution de la tâche de statistiques de colonne.
```
aws glue start-column-statistics-task-run-schedule \
--database-name 'database_name' \
--table-name 'table_name'
```
------
## Suppression du calendrier de génération de statistiques de colonne
Bien que la gestion up-to-date des statistiques soit généralement recommandée pour optimiser les performances des requêtes, il existe des cas d'utilisation spécifiques dans lesquels la suppression du calendrier de génération automatique peut être bénéfique.
+ Si les données restent relativement statiques, les statistiques des colonnes existantes peuvent rester précises pendant une période prolongée, ce qui réduit le besoin de mises à jour fréquentes. La suppression du calendrier permet d’éviter la consommation inutile de ressources et les frais généraux associés à la régénération des statistiques sur des données immuables.
+ Lorsque le contrôle manuel de la génération de statistiques est préférable. En supprimant le calendrier automatique, les administrateurs peuvent mettre à jour de manière sélective les statistiques de colonne à des intervalles spécifiques ou après des modifications importantes des données, en alignant le processus sur leurs stratégies de maintenance et leurs besoins d’allocation de ressources.
------
#### [ AWS Management Console ]
**Pour supprimer le calendrier de génération des statistiques de colonne**
1. Sur AWS Glue la console, sélectionnez **Tables** sous Catalogue de données.
1. Sélectionnez une table avec des statistiques de colonne.
1. Sur la page **Détails de la table**, choisissez **Statistiques de colonne**.
1. Sous **Actions**, choisissez **Génération planifiée**, puis **Supprimer**.
1. Choisissez **Supprimer** pour confirmer.
------
#### [ AWS CLI ]
Remplacez les valeurs `database_name` et `table_name` par les noms réels de la base de données et de la table pour lesquelles vous souhaitez arrêter le calendrier d’exécution de la tâche de statistiques de colonne.
Vous pouvez supprimer le calendrier des statistiques des colonnes à l'aide de l'opération [DeleteColumnStatisticsTaskSettings](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-DeleteColumnStatisticsTaskSettings)API ou AWS CLI. L'exemple suivant montre comment supprimer le calendrier de génération de statistiques de colonne à l'aide de AWS Command Line Interface (AWS CLI).
```
aws glue delete-column-statistics-task-settings \
--database-name 'database_name' \
--table-name 'table_name'
```
------
# Génération de statistiques de colonne à la demande
Vous pouvez exécuter la tâche de statistiques de colonnes pour la tâche de AWS Glue Data Catalog tables à la demande sans planification définie. Cette option est utile pour les analyses ad hoc ou lorsque les statistiques doivent être calculées immédiatement.
Procédez comme suit pour générer des statistiques de colonne à la demande pour les tables du catalogue de données à l'aide de AWS Glue la console ou AWS CLI.
------
#### [ AWS Management Console ]
**Pour générer des statistiques de colonne à l'aide de la console**
1. Connectez-vous à la AWS Glue console à l'adresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Choisissez des tables du catalogue de donnée.
1. Choisissez une table dans la liste.
1. Choisissez **Générer des statistiques** dans le menu **Actions**.
Vous pouvez également choisir l’option **Générer**, **Générer à la demande** sous l’onglet **Statistiques de colonne** dans la section inférieure de la page **Table**.
1. Suivez les étapes 7 à 11 dans [Génération de statistiques de colonne selon un calendrier](generate-column-stats.md) pour générer des statistiques de colonne pour la table.
1. Sur la page **Générer des statistiques**, spécifiez les options suivantes :
![\[La capture d'écran montre les options disponibles pour générer des statistiques de colonne.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/generate-column-stats.png)
+ **Toutes les colonnes** : choisissez cette option pour générer des statistiques pour toutes les colonnes de la table.
+ **Colonnes sélectionnées** : choisissez cette option pour générer des statistiques pour des colonnes spécifiques. Vous pouvez sélectionner les colonnes dans la liste déroulante.
+ **Rôle IAM** : choisissez **Créer un rôle IAM** doté des politiques d’autorisation requises pour exécuter la tâche de génération de statistiques de colonne. Choisissez Afficher les détails des autorisations pour examiner la déclaration de politique. Vous pouvez également sélectionner un rôle IAM dans la liste. Pour plus d’informations sur les autorisations requises, consultez [Conditions préalables à la génération de statistiques de colonne](column-stats-prereqs.md).
AWS Glue assume les autorisations du rôle que vous spécifiez pour générer des statistiques.
Pour plus d'informations sur la fourniture de rôles pour AWS Glue, consultez la section [Politiques basées sur l'identité](https://docs.aws.amazon.com/glue/latest/dg/security_iam_service-with-iam.html#security_iam_service-with-iam-id-based-policies) pour. AWS Glue.
+ (Facultatif) Choisissez ensuite une configuration de sécurité pour activer le chiffrement au repos des journaux.
+ **Exemples de lignes** : choisissez uniquement un pourcentage spécifique de lignes dans la table pour générer des statistiques. La valeur par défaut est toutes les lignes. Utilisez les flèches haut et bas pour augmenter ou diminuer la valeur en pourcentage.
**Note**
Nous vous recommandons d'inclure toutes les lignes de la table pour calculer des statistiques précises. Utilisez des exemples de lignes pour générer des statistiques de colonne uniquement lorsque des valeurs approximatives sont acceptables.
Choisissez **Générer des statistiques** pour exécuter la tâche.
------
#### [ AWS CLI ]
Cette commande déclenchera l’exécution d’une tâche de statistiques de colonne pour la table spécifiée. Vous devez indiquer le nom de la base de données, le nom de la table, un rôle IAM autorisé à générer des statistiques, et éventuellement fournir des noms de colonnes et un pourcentage de taille d’échantillon pour le calcul des statistiques.
```
aws glue start-column-statistics-task-run \
--database-name 'database_name \
--table-name 'table_name' \
--role 'arn:aws:iam::123456789012:role/stats-role' \
--column-name 'col1','col2' \
--sample-size 10.0
```
Cette commande lancera une tâche visant à générer des statistiques de colonne pour la table spécifiée.
------
## Mise à jour des statistiques de colonne sur demande
La gestion des statistiques des up-to-date colonnes est essentielle pour que l'optimiseur de requêtes génère des plans d'exécution efficaces, garantissant des performances de requête améliorées, une consommation de ressources réduite et de meilleures performances globales du système. Ce processus est particulièrement important après des modifications importantes des données, telles que des chargements groupés ou des modifications majeurs, qui peuvent rendre les statistiques existantes obsolètes.
Vous devez exécuter explicitement la tâche **Générer des statistiques** depuis la AWS Glue console pour actualiser les statistiques des colonnes. Le catalogue de données n'actualise pas automatiquement les statistiques.
Si vous n'utilisez pas la fonction AWS Glue de génération de statistiques de la console, vous pouvez mettre à jour manuellement les statistiques des colonnes à l'aide de l'opération [UpdateColumnStatisticsForTable](https://docs.aws.amazon.com/glue/latest/webapi/API_UpdateColumnStatisticsForTable.html)API ou AWS CLI. L'exemple suivant montre comment mettre à jour les statistiques de colonne à l'aide de la AWS CLI.
```
aws glue update-column-statistics-for-table --cli-input-json:
{
"CatalogId": "111122223333",
"DatabaseName": "database_name",
"TableName": "table_name",
"ColumnStatisticsList": [
{
"ColumnName": "col1",
"ColumnType": "Boolean",
"AnalyzedTime": "1970-01-01T00:00:00",
"StatisticsData": {
"Type": "BOOLEAN",
"BooleanColumnStatisticsData": {
"NumberOfTrues": 5,
"NumberOfFalses": 5,
"NumberOfNulls": 0
}
}
}
]
}
```
# Affichage des statistiques de colonne
Une fois les statistiques générées avec succès, Data Catalog stocke ces informations pour les optimiseurs basés sur les coûts Amazon Athena et Amazon Redshift afin de faire des choix optimaux lors de l'exécution de requêtes. Les statistiques varient en fonction du type de colonne.
------
#### [ AWS Management Console ]
**Pour afficher les statistiques de colonne d'une table**
+ Après avoir exécuté la tâche de statistiques de colonne, l'onglet **Statistiques de colonne** de la page **Détails de la table** affiche les statistiques pour la table.
![\[La capture d'écran montre les colonnes générées à partir de la dernière exécution.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/view-column-stats.png)
Les statistiques suivantes sont disponibles :
+ Nom de colonne : nom de colonne utilisé pour générer des statistiques
+ Dernière mise à jour : date et heure de génération des statistiques
+ Longueur moyenne : longueur moyenne des valeurs dans la colonne
+ Valeurs distinctes : nombre total de valeurs distinctes dans la colonne. Nous estimons le nombre de valeurs distinctes dans une colonne avec une erreur relative de 5 %.
+ Valeur maximale : la plus grande valeur de la colonne.
+ Valeur minimale : la plus petite valeur de la colonne.
+ Longueur maximale : longueur de la valeur la plus élevée dans la colonne.
+ Valeurs nulles : nombre total de valeurs nulles dans la colonne.
+ Valeurs réelles : nombre total de valeurs réelles dans la colonne.
+ Valeurs fausses : nombre total de valeurs fausses dans la colonne.
+ numFiles : nombre total de fichiers dans la table. Cette valeur est disponible sous l’onglet **Propriétés avancées**.
------
#### [ AWS CLI ]
L'exemple suivant montre comment récupérer les statistiques de colonne à l'aide de la AWS CLI.
```
aws glue get-column-statistics-for-table \
--database-name database_name \
--table-name table_name \
--column-names
```
Vous pouvez également consulter les statistiques des colonnes à l'aide de l'opération [GetColumnStatisticsForTable](https://docs.aws.amazon.com/glue/latest/webapi/API_GetColumnStatisticsForTable.html)API.
------
# Affichage des exécutions de tâches de statistiques de colonne
Après avoir exécuté une tâche de statistiques de colonne, vous pouvez explorer les détails de l'exécution de la tâche pour une table à l'aide de AWS Glue la console AWS CLI ou à l'aide d'une [GetColumnStatisticsTaskRuns](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-GetColumnStatisticsTaskRun)opération.
------
#### [ Console ]
**Pour afficher les détails de l'exécution de la tâche de statistiques de colonne**
1. Sur AWS Glue la console, sélectionnez **Tables** sous Catalogue de données.
1. Sélectionnez une table avec des statistiques de colonne.
1. Sur la page **Détails de la table**, choisissez **Statistiques de colonne**.
1. Choisissez **Afficher les exécutions**.
Vous pouvez voir des informations sur toutes les exécutions associées à la table spécifiée.
![\[La capture d'écran montre les options disponibles pour générer des statistiques de colonne.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/view-column-stats-task-runs.png)
------
#### [ AWS CLI ]
Dans l'exemple suivant, remplacez les valeurs pour `DatabaseName` et `TableName` par le nom réel de la base de données et de la table.
```
aws glue get-column-statistics-task-runs --input-cli-json file://input.json
{
"DatabaseName": "database_name",
"TableName": "table_name"
}
```
------
# Arrêt d'exécution de la tâche de statistiques de colonne
Vous pouvez arrêter une tâche de statistiques de colonne exécutée pour une table à l'aide de AWS Glue la console AWS CLI ou à l'aide d'une [StopColumnStatisticsTaskRun](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-StopColumnStatisticsTaskRun)opération.
------
#### [ Console ]
**Pour arrêter l'exécution d'une tâche de statistiques de colonne**
1. Sur AWS Glue la console, sélectionnez **Tables** sous Catalogue de données.
1. Sélectionnez la table dans laquelle l'exécution de la tâche de statistiques de colonne est en cours.
1. Sur la page **Détails de la table**, choisissez **Statistiques de colonne**.
1. Choisissez **Arrêter**.
Si vous arrêtez la tâche avant la fin de l'exécution, aucune statistique de colonne ne sera générée pour la table.
------
#### [ AWS CLI ]
Dans l'exemple suivant, remplacez les valeurs pour `DatabaseName` et `TableName` par le nom réel de la base de données et de la table.
```
aws glue stop-column-statistics-task-run --input-cli-json file://input.json
{
"DatabaseName": "database_name",
"TableName": "table_name"
}
```
------
# Supprimer les statistiques de colonne
Vous pouvez supprimer les statistiques des colonnes à l'aide de [DeleteColumnStatisticsForTable](https://docs.aws.amazon.com/glue/latest/webapi/API_DeleteColumnStatisticsForTable.html)l'opération API ou AWS CLI. L'exemple suivant montre comment supprimer des statistiques de colonne à l'aide de AWS Command Line Interface (AWS CLI).
```
aws glue delete-column-statistics-for-table \
--database-name 'database_name' \
--table-name 'table_name' \
--column-name 'column_name'
```
# Considérations et restrictions
Les considérations et limites suivantes s'appliquent à la génération de statistiques de colonne.
**Considérations**
+ L'utilisation de l'échantillonnage pour générer des statistiques réduit le temps d'exécution, mais peut générer des statistiques inexactes.
+ Le catalogue de données ne stocke pas les différentes versions des statistiques.
+ Vous ne pouvez exécuter qu'une seule tâche de génération de statistiques à la fois par table.
+ Si une table est chiffrée à l'aide d'une AWS KMS clé client enregistrée dans Data Catalog, AWS Glue utilise la même clé pour chiffrer les statistiques.
**La tâche de statistiques de colonne prend en charge la génération de statistiques :**
+ Lorsque le rôle IAM dispose d'autorisations complètes sur les tables (IAM ou Lake Formation).
+ Lorsque le rôle IAM dispose d'autorisations sur la table en utilisant le mode d'accès hybride de Lake Formation.
**La tâche de statistiques de colonne ne prend pas en charge la génération de statistiques pour :**
+ Tables avec contrôle d’accès basé sur les cellules de Lake Formation
+ Lacs de données transactionnels : Linux Foundation Delta Lake, Apache Hudi.
+ Tables dans des bases de données fédérées - Hive metastore, unités de partage des données d'Amazon Redshift
+ Colonnes imbriquées, tableaux et types de données struct.
+ Table partagée avec vous depuis un autre compte
# Chiffrement de votre catalogue de données
Vous pouvez protéger vos métadonnées stockées dans l' AWS Glue Data Catalog at rest à l'aide de clés de chiffrement gérées par AWS Key Management Service (AWS KMS). Vous pouvez activer le chiffrement du catalogue de données pour le nouveau catalogue de données à l’aide des **paramètres du catalogue de données**. Vous pouvez activer ou désactiver le chiffrement pour le catalogue de données existant selon vos besoins. Lorsque cette option est activée, elle AWS Glue chiffre toutes les nouvelles métadonnées écrites dans le catalogue, tandis que les métadonnées existantes restent non chiffrées.
Pour obtenir des informations détaillées sur le chiffrement de votre catalogue de données, consultez [Chiffrement de votre catalogue de données](encrypt-glue-data-catalog.md).
# Sécurisation de votre catalogue de données à l’aide de Lake Formation
AWS Lake Formation est un service qui facilite la configuration d'un lac de données sécurisé dans AWS. Il fournit un emplacement central pour créer et gérer en toute sécurité vos lacs de données en définissant des autorisations de contrôle d’accès précises. Lake Formation utilise le catalogue de données pour stocker et extraire les métadonnées relatives à votre lac de données, telles que les définitions de tables, les informations de schéma et les paramètres de contrôle d’accès aux données.
Vous pouvez enregistrer l’emplacement de vos données Amazon S3 dans la table de métadonnées ou la base de données avec Lake Formation et l’utiliser pour définir des autorisations au niveau des métadonnées sur les ressources du catalogue de données. Vous pouvez utiliser Lake Formation pour gérer les autorisations d’accès au stockage sur les données sous-jacentes stockées dans Amazon S3 pour le compte de moteurs d’analytique intégrés.
Pour plus d'informations, voir [Qu'est-ce que c'est AWS Lake Formation ?](lake-formation/latest/dg/what-is-lake-formation.html) .
# Utilisation des AWS Glue Data Catalog vues dans AWS Glue
Vous pouvez créer et gérer des vues dans le AWS Glue Data Catalog, communément appelé AWS Glue Data Catalog vues. Ces vues sont utiles car elles prennent en charge plusieurs moteurs de requêtes SQL, ce qui vous permet d'accéder à la même vue sur différents AWS services Amazon Athena, tels que Amazon Redshift, et AWS Glue. Vous pouvez utiliser des vues basées sur Apache Iceberg, Apache Hudi et Delta Lake.
En créant une vue dans le catalogue de données, vous pouvez utiliser des autorisations de ressources et des contrôles d'accès basés sur des balises AWS Lake Formation pour autoriser l'accès à celui-ci. Avec cette méthode de contrôle d’accès, il n’est pas nécessaire de configurer un accès supplémentaire aux tables référencées lors de la création de la vue. Cette méthode d’octroi d’autorisations est appelée sémantique du définisseur, et ces vues sont appelées vues du définisseur. Pour plus d'informations sur le contrôle d'accès dans AWS Lake Formation, consultez la section [Octroi et révocation d'autorisations sur les ressources du catalogue de données](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html) dans le guide du AWS Lake Formation développeur.
Les vues du catalogue de données sont utiles dans les cas d’utilisation suivants :
+ **Contrôle précis des accès** : vous pouvez créer une vue qui restreint l’accès aux données en fonction des autorisations dont l’utilisateur a besoin. Par exemple, vous pouvez utiliser des vues du catalogue de données pour empêcher les employés qui ne travaillent pas dans le service des ressources humaines (RH) de voir des données d’identification personnelle (PII).
+ **Définition complète de vue** : en appliquant des filtres aux vues du catalogue de données, vous vous assurez que les enregistrements de données disponibles dans la vue sont toujours complets.
+ **Sécurité renforcée** : la définition de requête utilisée pour créer la vue doit être complète, afin que les vues du catalogue de données soient moins vulnérables aux commandes SQL provenant d’acteurs malveillants.
+ **Partage de données simplifié** — Partagez des données avec d'autres AWS comptes sans déplacer de données, grâce au partage de données entre comptes. AWS Lake Formation
## Création d’un affichage du Catalogue de données
Vous pouvez créer des vues de catalogue de données à l'aide des scripts AWS Glue ETL AWS CLI et de Spark SQL. La syntaxe permettant de créer une vue du catalogue de données consiste à spécifier le type de vue en tant que `MULTI DIALECT` et le prédicat `SECURITY` en tant que `DEFINER`, en indiquant une vue plus précise.
Exemple d’instruction SQL permettant de créer une vue du catalogue de données :
```
CREATE PROTECTED MULTI DIALECT VIEW database_name.catalog_view SECURITY DEFINER
AS SELECT order_date, sum(totalprice) AS price
FROM source_table
GROUP BY order_date;
```
Après avoir créé une vue du catalogue de données, vous pouvez utiliser un rôle IAM doté de l'autorisation AWS Lake Formation « SELECT » sur la vue pour l'interroger à partir de services tels que des tâches ETL ou des tâches Amazon Athena Amazon Redshift ETL. AWS Glue Il n’est pas nécessaire d’accorder l’accès aux tables sous-jacentes référencées dans la vue.
Pour plus d'informations sur la création et la configuration des vues du catalogue de données, voir [Création de vues du catalogue de AWS Glue données](https://docs.aws.amazon.com/lake-formation/latest/dg/working-with-views.html) dans le guide du AWS Lake Formation développeur.
## Opérations de vue prises en charge
Les fragments de commande suivants vous montrent différentes manières d’utiliser les vues du catalogue de données :
**CRÉER UNE VUE**
Crée une vue du catalogue de données. Voici un exemple qui montre comment créer une vue à partir d’une table existante :
```
CREATE PROTECTED MULTI DIALECT VIEW catalog_view
SECURITY DEFINER AS SELECT * FROM my_catalog.my_database.source_table
```
**MODIFIER LA VUE**
Syntaxe disponible :
```
ALTER VIEW view_name [FORCE] ADD DIALECT AS query
ALTER VIEW view_name [FORCE] UPDATE DIALECT AS query
ALTER VIEW view_name DROP DIALECT
```
Vous pouvez utiliser l’option `FORCE ADD DIALECT` pour forcer la mise à jour du schéma et des sous-objets conformément au nouveau dialecte du moteur. Notez que cela peut entraîner des erreurs de requête si vous n’utilisez pas également `FORCE` pour mettre à jour d’autres dialectes du moteur. Voici un exemple :
```
ALTER VIEW catalog_view FORCE ADD DIALECTAS
SELECT order_date, sum(totalprice) AS priceFROM source_tableGROUP BY orderdate;
```
Voici comment modifier une vue afin de mettre à jour le dialecte :
```
ALTER VIEW catalog_view UPDATE DIALECT AS
SELECT count(*) FROM my_catalog.my_database.source_table;
```
**DÉCRIRE LA VUE**
Syntaxe disponible pour décrire une vue :
`SHOW COLUMNS {FROM|IN} view_name [{FROM|IN} database_name]`— Si l'utilisateur dispose AWS Glue des AWS Lake Formation autorisations requises pour décrire la vue, il peut répertorier les colonnes. Voici quelques exemples de commandes permettant d’afficher des colonnes :
```
SHOW COLUMNS FROM my_database.source_table;
SHOW COLUMNS IN my_database.source_table;
```
`DESCRIBE view_name`— Si l'utilisateur dispose AWS Glue des AWS Lake Formation autorisations requises pour décrire la vue, il peut répertorier les colonnes de la vue ainsi que ses métadonnées.
**SUPPRIMER LA VUE**
Syntaxe disponible :
```
DROP VIEW [ IF EXISTS ] view_name
```
L’exemple suivant montre une instruction `DROP` qui teste si une vue existe avant de la supprimer :
```
DROP VIEW IF EXISTS catalog_view;
```
`SHOW CREATE VIEW view_name` : affiche l’instruction SQL qui crée la vue spécifiée. Voici un exemple qui montre comment créer une vue du catalogue de données :
```
SHOW CREATE TABLE my_database.catalog_view;CREATE PROTECTED MULTI DIALECT VIEW my_catalog.my_database.catalog_view (
net_profit,
customer_id,
item_id,
sold_date)
TBLPROPERTIES (
'transient_lastDdlTime' = '1736267222')
SECURITY DEFINER AS SELECT * FROM
my_database.store_sales_partitioned_lf WHERE customer_id IN (SELECT customer_id from source_table limit 10)
```
**AFFICHER LES VUES**
Répertoriez toutes les vues du catalogue, comme les vues normales, les vues multidialectes (MDV) et les vues MDV sans le dialecte Spark. La syntaxe disponible est la suivante :
```
SHOW VIEWS [{ FROM | IN } database_name] [LIKE regex_pattern]:
```
Voici un exemple de commande permettant d’afficher les vues :
```
SHOW VIEWS IN marketing_analytics LIKE 'catalog_view*';
```
Pour plus d'informations sur la création et la configuration de vues de catalogue de données, voir [Création de vues de catalogue de AWS Glue données](https://docs.aws.amazon.com/lake-formation/latest/dg/working-with-views.html) dans le guide du AWS Lake Formation développeur.
## Interrogation d’un affichage du Catalogue de données
Après avoir créé une vue du catalogue de données, vous pouvez l’interroger. Le rôle IAM configuré dans vos AWS Glue tâches doit disposer de l'autorisation Lake Formation **SELECT** dans la vue du catalogue de données. Il n’est pas nécessaire d’accorder l’accès aux tables sous-jacentes référencées dans la vue.
Une fois que tout est configuré, vous pouvez interroger votre vue. Par exemple, vous pouvez exécuter la requête suivante pour accéder à une vue.
```
SELECT * from my_database.catalog_view LIMIT 10;
```
## Limitations
Tenez compte des restrictions suivantes lorsque vous utilisez les vues du catalogue de données.
+ Vous ne pouvez créer des vues de catalogue de données qu'avec la AWS Glue version 5.0 et les versions ultérieures.
+ Le définisseur de vues du catalogue de données doit disposer de l’accès `SELECT` aux tables de base sous-jacentes accessibles par la vue. La création de la vue du catalogue de données échoue si des filtres Lake Formation sont imposés au rôle de définisseur d’une table de base spécifique.
+ Les tables de base ne doivent pas disposer de l’autorisation de lac de données `IAMAllowedPrincipals` dans AWS Lake Formation. Le cas échéant, l'erreur **Multi Dialect views ne peut référencer que des tables sans les autorisations IAMAllowed Principaux se produit.**
+ L'emplacement Amazon S3 de la table doit être enregistré en tant qu'emplacement de lac de AWS Lake Formation données. Si la table n’est pas enregistrée, l’erreur `Multi Dialect views may only reference AWS Lake Formation managed tables` se produit. Pour plus d'informations sur la façon d'enregistrer des sites Amazon S3 dans AWS Lake Formation, consultez la section [Enregistrement d'un site Amazon S3](https://docs.aws.amazon.com/lake-formation/latest/dg/register-data-lake.html) dans le guide du AWS Lake Formation développeur.
+ Vous pouvez uniquement créer des vues du catalogue de données `PROTECTED`. Les vues `UNPROTECTED` ne sont pas prises en charge.
+ Vous ne pouvez pas référencer les tables d'un autre AWS compte dans une définition de vue du catalogue de données. Vous ne pouvez pas non plus référencer une table dans le même compte situé dans une région distincte.
+ Pour partager des données entre un compte ou une région, l’affichage complet doit être partagé entre les comptes et les régions, à l’aide de liens vers des ressources AWS Lake Formation .
+ Les fonctions définies par l'utilisateur (UDFs) ne sont pas prises en charge.
+ Les vues du catalogue de données ne peuvent pas référencer d’autres vues.
# Accès au catalogue de données
Vous pouvez utiliser le AWS Glue Data Catalog (catalogue de données) pour découvrir et comprendre vos données. Le catalogue de données fournit un moyen cohérent de gérer les définitions de schéma, les types de données, les emplacements et d’autres métadonnées. Vous pouvez accéder au catalogue de données à l’aide des méthodes suivantes :
+ AWS Glue console — Vous pouvez accéder au catalogue de données et le gérer via la AWS Glue console, une interface utilisateur Web. La console vous permet de parcourir et de rechercher des bases de données, des tables et leurs métadonnées associées, ainsi que de créer, mettre à jour et supprimer des définitions de métadonnées.
+ AWS Glue crawler — Les crawlers sont des programmes qui analysent automatiquement vos sources de données et alimentent le catalogue de données avec des métadonnées. Vous pouvez créer et exécuter des robots d'exploration pour découvrir et cataloguer des données provenant de diverses sources telles qu'Amazon S3, Amazon RDS, Amazon DynamoDB Amazon CloudWatch et de bases de données relationnelles compatibles JDBC telles que MySQL et PostgreSQL, ainsi que de plusieurs sources non sources telles que Snowflake et Google.AWS BigQuery
+ AWS Glue APIs — Vous pouvez accéder au catalogue de données par programmation à l'aide du. AWS Glue APIs Ils vous APIs permettent d'interagir avec le catalogue de données par programmation, ce qui permet l'automatisation et l'intégration avec d'autres applications et services.
+ AWS Command Line Interface (AWS CLI) — Vous pouvez utiliser le AWS CLI pour accéder au catalogue de données et le gérer à partir de la ligne de commande. La CLI fournit des commandes pour créer, mettre à jour et supprimer des définitions de métadonnées, ainsi que pour interroger et récupérer des informations de métadonnées.
+ Intégration avec d'autres AWS services — Le catalogue de données s'intègre à divers autres AWS services, vous permettant d'accéder aux métadonnées stockées dans le catalogue et de les utiliser. Par exemple, vous pouvez utiliser Amazon Athena pour interroger des sources de données à l'aide des métadonnées du catalogue de données et pour gérer l'accès aux données et la gouvernance des ressources du catalogue de données. AWS Lake Formation
**Topics**
+ [Connexion au catalogue de données à l'aide du point de terminaison AWS Glue Iceberg REST](connect-glu-iceberg-rest.md)
+ [Connexion au catalogue de données à l'aide du point de terminaison de l'extension AWS Glue Iceberg REST](connect-glue-iceberg-rest-ext.md)
+ [AWS Glue Spécifications REST APIs pour Apache Iceberg](iceberg-rest-apis.md)
+ [Connexion au catalogue de données à partir d’une application Spark autonome](connect-gludc-spark.md)
+ [Mappage de données entre Amazon Redshift et Apache Iceberg](data-mapping-rs-iceberg.md)
+ [Considérations et limites relatives à l'utilisation du catalogue REST d' AWS Glue Iceberg APIs](limitation-glue-iceberg-rest-api.md)
# Connexion au catalogue de données à l'aide du point de terminaison AWS Glue Iceberg REST
Le point de terminaison REST Iceberg d’ AWS Glue prend en charge les opérations API spécifiées dans la spécification REST Apache Iceberg. À l’aide d’un client REST Iceberg, vous pouvez connecter votre application exécutée sur un moteur analytique au catalogue REST hébergé dans le catalogue de données.
Le point de terminaison prend en charge les deux spécifications des tables Apache Iceberg : v1 et v2, la valeur par défaut étant v2. Lorsque vous utilisez la spécification de la table Iceberg v1, vous devez spécifier v1 dans l’appel d’API. À l’aide de l’opération d’API, vous pouvez accéder aux tables Iceberg stockées à la fois dans le stockage d’objets Amazon S3 et dans le stockage de tableaux Amazon S3.
**Configuration du point de terminaison**
Vous pouvez accéder au catalogue REST d' AWS Glue Iceberg via le point de terminaison du service. Reportez-vous au [guide de référence des points de terminaison de service AWS Glue](https://docs.aws.amazon.com/general/latest/gr/glue.html#glue_region) pour le point de terminaison spécifique à la région. Par exemple, lorsque vous vous connectez à AWS Glue dans la région us-east-1, vous devez configurer la propriété d’URI du point de terminaison comme suit :
```
Endpoint : https://glue.us-east-1.amazonaws.com/iceberg
```
**Propriétés de configuration supplémentaires** : lorsque vous utilisez le client Iceberg pour connecter un moteur d’analytique tel que Spark au point de terminaison du service, vous devez indiquer les propriétés de configuration d’application suivantes :
```
catalog_name = "mydatacatalog"
aws_account_id = "123456789012"
aws_region = "us-east-1"
spark = SparkSession.builder \
... \
.config("spark.sql.defaultCatalog", catalog_name) \
.config(f"spark.sql.catalog.{catalog_name}", "org.apache.iceberg.spark.SparkCatalog") \
.config(f"spark.sql.catalog.{catalog_name}.type", "rest") \
.config(f"spark.sql.catalog.{catalog_name}.uri", "https://glue.{aws_region}.amazonaws.com/iceberg") \
.config(f"spark.sql.catalog.{catalog_name}.warehouse", "{aws_account_id}") \
.config(f"spark.sql.catalog.{catalog_name}.rest.sigv4-enabled", "true") \
.config(f"spark.sql.catalog.{catalog_name}.rest.signing-name", "glue") \
.config("spark.sql.extensions","org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions") \
.getOrCreate()
```
AWS Glue Les supports de point de terminaison Iceberg prennent en ` https://glue.us-east-1.amazonaws.com/iceberg` charge le REST Iceberg suivant : APIs
+ GetConfig
+ ListNamespaces
+ CreateNamespace
+ LoadNamespaceMetadata
+ UpdateNamespaceProperties
+ DeleteNamespace
+ ListTables
+ CreateTable
+ LoadTable
+ TableExists
+ UpdateTable
+ DeleteTable
## Paramètres du chemin d’accès au préfixe et au catalogue
Le catalogue REST d'Iceberg APIs comporte un préfixe de forme libre dans sa demande. URLs Par exemple, l'appel `ListNamespaces` d'API utilise le format `GET/v1/{prefix}/namespaces` URL. AWS Glue Le préfixe suit toujours la `/catalogs/{catalog}` structure pour garantir que le chemin REST aligne la hiérarchie des catalogues AWS Glue multiples. Le paramètre de chemin `{catalog}` peut être dérivé en fonction des règles suivantes :
| **Modèle d’accès** | **Style d’ID du catalogue Glue** | **Style de préfixe** | **Exemple d’ID de catalogue par défaut** | **Exemple de route REST** |
| --- | --- | --- | --- | --- |
| Accéder au catalogue par défaut dans le compte actuel | facultatif | : | ne s’applique pas | GET /v1/catalogs/:/namespaces |
| Accéder au catalogue par défaut dans un compte spécifique | accountID | accountID | 111122223333 | GET /v1/catalogs/111122223333/namespaces |
| Accéder à un catalogue imbriqué dans le compte actuel | catalog1/catalog2 | catalog1/catalog2 | rmscatalog1:db1 | OBTENEZ /v1/ catalogs/rmscatalog1:db1/namespaces |
| Accéder à un catalogue imbriqué dans un compte spécifique | accountId:catalog1/catalog2 | accountId:catalog1/catalog2 | 123456789012/rmscatalog1:db1 | GET /v1/catalogs/123456789012:rmscatalog1:db1/namespaces |
Le mappage de cet ID de catalogue vers le préfixe n'est requis que lorsque vous appelez directement le REST APIs. Lorsque vous utilisez le catalogue REST d' AWS Glue Iceberg APIs via un moteur, vous devez spécifier l'ID du AWS Glue catalogue dans le `warehouse` paramètre de l'API de votre catalogue REST Iceberg ou dans le `glue.id` paramètre de l'API de vos AWS Glue extensions. Par exemple, découvrez comment vous pouvez l’utiliser avec EMR Spark dans [Use an Iceberg cluster with Spark](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-iceberg-use-spark-cluster.html).
## Paramètre de chemin d’accès à l’espace de noms
Les espaces de noms du APIs chemin du catalogue REST d'Iceberg peuvent comporter plusieurs niveaux. Toutefois, AWS Glue ne prend en charge que les espaces de noms à un seul niveau. Pour accéder à un espace de noms dans une hiérarchie de catalogue à plusieurs niveaux, vous pouvez vous connecter à un catalogue à plusieurs niveaux situé au-dessus de l’espace de noms pour référencer l’espace de noms. Cela permet à tout moteur de requête prenant en charge la notation en 3 parties d'accéder `catalog.namespace.table` aux objets de la hiérarchie AWS Glue du catalogue à plusieurs niveaux sans problèmes de compatibilité par rapport à l'utilisation de l'espace de noms à plusieurs niveaux.
# Connexion au catalogue de données à l'aide du point de terminaison de l'extension AWS Glue Iceberg REST
AWS Glue Le point de terminaison d'extension Iceberg REST fournit des fonctionnalités supplémentaires APIs, qui ne figurent pas dans la spécification REST d'Apache Iceberg, et fournit des fonctionnalités de planification des scans côté serveur. Ces informations supplémentaires APIs sont utilisées lorsque vous accédez aux tables stockées dans le stockage géré Amazon Redshift. Le point de terminaison est accessible depuis une application utilisant les AWS Glue Data Catalog extensions Apache Iceberg.
**Configuration du point de terminaison** : un catalogue contenant des tables dans le stockage géré Redshift est accessible via le point de terminaison de service. Reportez-vous au [guide de référence des points de terminaison de service AWS Glue](https://docs.aws.amazon.com/general/latest/gr/glue.html#glue_region) pour le point de terminaison spécifique à la région. Par exemple, lorsque vous vous connectez AWS Glue à la région us-east-1, vous devez configurer la propriété URI du point de terminaison comme suit :
```
Endpoint : https://glue.us-east-1.amazonaws.com/extensions
```
```
catalog_name = "myredshiftcatalog"
aws_account_id = "123456789012"
aws_region = "us-east-1"
spark = SparkSession.builder \
.config("spark.sql.defaultCatalog", catalog_name) \
.config(f"spark.sql.catalog.{catalog_name}", "org.apache.iceberg.spark.SparkCatalog") \
.config(f"spark.sql.catalog.{catalog_name}.type", "glue") \
.config(f"spark.sql.catalog.{catalog_name}.glue.id", "{123456789012}:redshiftnamespacecatalog/redshiftdb") \
.config("spark.sql.extensions","org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions") \
.getOrCreate()
```
# AWS Glue Spécifications REST APIs pour Apache Iceberg
Cette section contient les spécifications relatives au catalogue et à l' AWS Glue extension AWS Glue Iceberg REST APIs, ainsi que les considérations relatives à leur utilisation. APIs
Les demandes d'API adressées aux AWS Glue Data Catalog points de terminaison sont authentifiées à l'aide de AWS Signature Version 4 (SigV4). Consultez [AWS la section Signature version 4 pour les demandes d'API](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) pour en savoir plus sur AWS SigV4.
Lors de l'accès au point de terminaison du AWS Glue service et aux AWS Glue métadonnées, l'application assume un rôle IAM qui nécessite une action `glue:getCatalog` IAM.
L’accès au catalogue de données et à ses objets peut être géré à l’aide des autorisations IAM, Lake Formation ou du mode hybride Lake Formation.
Les catalogues fédérés dans le catalogue de données contiennent des emplacements de données enregistrés pour Lake Formation. Lake Formation utilise le catalogue de données pour fournir des autorisations de type base de données afin de gérer l’accès des utilisateurs aux objets du catalogue de données.
Vous pouvez utiliser les autorisations du mode hybride IAM ou Lake Formation pour gérer l'accès au catalogue de données par défaut et à ses objets. AWS Lake Formation
Pour créer, insérer ou supprimer des données dans les objets gérés Lake Formation, vous devez configurer des autorisations spécifiques pour l’utilisateur ou le rôle IAM.
+ CREATE\$1CATALOG : nécessaire pour créer des catalogues
+ CREATE\$1DATABASE : nécessaire pour créer des bases de données
+ CREATE\$1TABLE : nécessaire pour créer des tables
+ DELETE : nécessaire pour supprimer des données d’une table
+ DESCRIBE : nécessaire pour lire les métadonnées
+ DROP — Obligatoire pour drop/delete une table ou une base de données
+ INSERT : nécessaire lorsque le principal doit insérer des données dans une table
+ SELECT : nécessaire lorsque le principal doit sélectionner des données d’une table
Pour plus d'informations, consultez la [référence sur les autorisations de Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/lf-permissions-reference.html) dans le Guide du AWS Lake Formation développeur.
# GetConfig
**Informations générales**
| | |
| --- |--- |
| Nom de l'opération | GetConfig |
| Type | API de catalogue REST Iceberg |
| Chemin REST | OBTENEZ/iceberg/v1/config |
| Action IAM | colle : GetCatalog |
| Autorisations Lake Formation | Non applicable |
| CloudTrail event | colle : GetCatalog |
| Définition Open API | https://github.com/apache/iceberg/blob/apache-iceberg-1.6.1/open-api/rest- catalog-open-api .yaml \$1L67 |
****Considérations et restrictions****
+ Le paramètre de `warehouse` requête doit être défini sur l'ID du AWS Glue catalogue. S’il n’est pas défini, le catalogue racine du compte courant est utilisé pour renvoyer la réponse. Pour de plus amples informations, veuillez consulter [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
# GetCatalog
**Informations générales**
| | |
| --- |--- |
| Nom de l'opération | GetCatalog |
| Type | AWS Glue API d'extension |
| Chemin REST | GET/extensions/v1/catalogs/\$1catalogue\$1 |
| Action IAM | colle : GetCatalog |
| Autorisations Lake Formation | DESCRIBE |
| CloudTrail event | colle : GetCatalog |
| Définition Open API | https://github.com/awslabs/glue-extensions-for-iceberg/blob/main/glue-extensions-api.yaml \$1L40 |
****Considérations et restrictions****
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
# ListNamespaces
**Informations générales**
| | |
| --- |--- |
| Nom de l'opération | ListNamespaces |
| Type | API de catalogue REST Iceberg |
| Chemin REST | GET/iceberg/v1/catalogs/\$1catalog\$1/namespaces |
| Action IAM | colle : GetDatabase |
| Autorisations Lake Formation | ALL, DESCRIBE, SELECT |
| CloudTrail event | colle : GetDatabase |
| Définition Open API | https://github.com/apache/iceberg/blob/apache-iceberg-1.6.1/open-api/rest- catalog-open-api .yaml \$1L205 |
****Considérations et restrictions****
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Seuls les espaces de noms du niveau suivant sont affichés. Pour répertorier les espaces de noms à des niveaux plus profonds, spécifiez l’ID de catalogue imbriqué dans le paramètre de chemin d’accès au catalogue.
# CreateNamespace
**Informations générales**
| | |
| --- |--- |
| Nom de l'opération | CreateNamespace |
| Type | API de catalogue REST Iceberg |
| Chemin REST | POST/iceberg/v1/catalogs/\$1catalog\$1/namespaces |
| Action IAM | colle : CreateDatabase |
| Autorisations Lake Formation | ALL, DESCRIBE, SELECT |
| CloudTrail event | colle : CreateDatabase |
| Définition Open API | https://github.com/apache/iceberg/blob/apache-iceberg-1.6.1/open-api/rest- catalog-open-api .yaml \$1L256 |
****Considérations et restrictions****
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Seul un espace de noms à niveau unique peut être créé. Pour créer un espace de noms à plusieurs niveaux, vous devez créer chaque niveau de manière itérative et vous connecter au niveau à l’aide du paramètre de chemin du catalogue.
# StartCreateNamespaceTransaction
**Informations générales**
| | |
| --- |--- |
| Nom de l'opération | StartCreateNamespaceTransaction |
| Type | AWS Glue API d'extensions |
| Chemin REST | POST/extensions/v1/catalogs/\$1catalog\$1/namespaces |
| Action IAM | colle : CreateDatabase |
| Autorisations Lake Formation | ALL, DESCRIBE, SELECT |
| CloudTrail event | colle : CreateDatabase |
| Définition Open API | https://github.com/apache/iceberg/blob/apache-iceberg-1.6.1/open-api/rest- catalog-open-api .yaml \$1L256 |
****Considérations et restrictions****
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Vous ne pouvez créer qu’un espace de noms à niveau unique. Pour créer un espace de noms à plusieurs niveaux, vous devez créer chaque niveau de manière itérative et vous connecter au niveau à l’aide du paramètre de chemin du catalogue.
+ L’API est asynchrone et renvoie un ID de transaction que vous pouvez utiliser pour le suivi à l’aide de l’appel d’API `CheckTransactionStatus`.
+ Vous pouvez appeler cette API uniquement si l’appel d’API `GetCatalog` contient le paramètre `use-extensions=true` dans la réponse.
## LoadNamespaceMetadata
**Informations générales**
| | |
| --- |--- |
| Nom de l'opération | LoadNamespaceMetadata |
| Type | API de catalogue REST Iceberg |
| Chemin REST | GET/iceberg/v1/catalogs/\$1catalog\$1/namespaces/\$1ns\$1 |
| Action IAM | colle : GetDatabase |
| Autorisations Lake Formation | ALL, DESCRIBE, SELECT |
| CloudTrail event | colle : GetDatabase |
| Définition Open API | https://github.com/apache/iceberg/blob/apache-iceberg-1.6.1/open-api/rest- catalog-open-api .yaml \$1L302 |
****Considérations et restrictions****
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Vous ne pouvez spécifier qu’un espace de noms à un seul niveau dans le paramètre de chemin d’accès REST. Pour plus d’informations, consultez la section [Paramètre de chemin d’accès à l’espace de noms](connect-glu-iceberg-rest.md#ns-path-param).
## UpdateNamespaceProperties
**Informations générales**
| | |
| --- |--- |
| Nom de l'opération | UpdateNamespaceProperties |
| Type | API de catalogue REST Iceberg |
| Chemin REST | POSTER/iceberg/v1/catalogs/\$1catalog\$1/namespaces/\$1ns\$1/properties |
| Action IAM | colle : UpdateDatabase |
| Autorisations Lake Formation | ALL, ALTER |
| CloudTrail event | colle : UpdateDatabase |
| Définition Open API | https://github.com/apache/iceberg/blob/apache-iceberg-1.6.1/open-api/rest- catalog-open-api .yaml \$1L400 |
****Considérations et restrictions****
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Vous ne pouvez spécifier qu’un espace de noms à un seul niveau dans le paramètre de chemin d’accès REST. Pour plus d’informations, consultez la section [Paramètre de chemin d’accès à l’espace de noms](connect-glu-iceberg-rest.md#ns-path-param).
# DeleteNamespace
**Informations générales**
| | |
| --- |--- |
| Nom de l'opération | DeleteNamespace |
| Type | API de catalogue REST Iceberg |
| Chemin REST | DELETE/iceberg/v1/catalogs/\$1catalog\$1/namespces/\$1ns\$1 |
| Action IAM | colle : DeleteDatabase |
| Autorisations Lake Formation | ALL, DROP |
| CloudTrail event | colle : DeleteDatabase |
| Définition Open API | https://github.com/apache/iceberg/blob/apache-iceberg-1.6.1/open-api/rest- catalog-open-api .yaml \$1L365 |
****Considérations et restrictions****
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Vous ne pouvez spécifier qu’un espace de noms à un seul niveau dans le paramètre de chemin d’accès REST. Pour plus d’informations, consultez la section [Paramètre de chemin d’accès à l’espace de noms](connect-glu-iceberg-rest.md#ns-path-param).
+ Si la base de données contient des objets, l’opération échouera.
+ L’API est asynchrone et renvoie un ID de transaction que vous pouvez utiliser pour le suivi à l’aide de l’appel d’API `CheckTransactionStatus`.
+ L’API ne peut être utilisée que si l’appel d’API `GetCatalog` indique `use-extensions=true` dans la réponse.
# StartDeleteNamespaceTransaction
**Informations générales**
| | |
| --- |--- |
| Nom de l'opération | StartDeleteNamespaceTransaction |
| Type | AWS Glue API d'extensions |
| Chemin REST | SUPPRIMER/extensions/v1/catalogs/\$1catalog\$1/namespces/\$1ns\$1 |
| Action IAM | colle : DeleteDatabase |
| Autorisations Lake Formation | ALL, DROP |
| CloudTrail event | colle : DeleteDatabase |
| Définition Open API | https://github.com/awslabs/glue-extensions-for-iceberg/blob/main/glue-extensions-api.yaml \$1L85 |
****Considérations et restrictions****
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Vous ne pouvez spécifier qu’un espace de noms à un seul niveau dans le paramètre de chemin d’accès REST. Pour plus d’informations, consultez la section [Paramètre de chemin d’accès à l’espace de noms](connect-glu-iceberg-rest.md#ns-path-param).
+ Si la base de données contient des objets, l’opération échouera.
+ L’API est asynchrone et renvoie un ID de transaction que vous pouvez utiliser pour le suivi à l’aide de l’appel d’API `CheckTransactionStatus`.
+ L’API ne peut être utilisée que si l’appel d’API `GetCatalog` indique `use-extensions=true` dans la réponse.
# ListTables
**Informations générales**
| | |
| --- |--- |
| Nom de l'opération | ListTables |
| Type | API de catalogue REST Iceberg |
| Chemin REST | OBTENEZ/iceberg/v1/catalogs/\$1catalog\$1/namespaces/\$1ns\$1/tables |
| Action IAM | colle : GetTables |
| Autorisations Lake Formation | ALL, SELECT, DESCRIBE |
| CloudTrail event | colle : GetTables |
| Définition Open API | https://github.com/apache/iceberg/blob/apache-iceberg-1.6.1/open-api/rest- catalog-open-api .yaml \$1L463 |
****Considérations et restrictions****
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Vous ne pouvez spécifier qu’un espace de noms à un seul niveau dans le paramètre de chemin d’accès REST. Pour plus d’informations, consultez la section [Paramètre de chemin d’accès à l’espace de noms](connect-glu-iceberg-rest.md#ns-path-param).
+ Toutes les tables, y compris les tables non Iceberg, seront répertoriées. Pour déterminer si une table peut être chargée en tant que table Iceberg ou non, appelez l’opération `LoadTable`.
# CreateTable
**Informations générales**
| | |
| --- |--- |
| Nom de l'opération | CreateTable |
| Type | API de catalogue REST Iceberg |
| Chemin REST | OBTENEZ/iceberg/v1/catalogs/\$1catalog\$1/namespaces/\$1ns\$1/tables |
| Action IAM | colle : CreateTable |
| Autorisations Lake Formation | ALL, CREATE\$1TABLE |
| CloudTrail event | colle : CreateTable |
| Définition Open API | https://github.com/apache/iceberg/blob/apache-iceberg-1.6.1/open-api/rest- catalog-open-api .yaml \$1L497 |
****Considérations et restrictions****
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Vous ne pouvez spécifier qu’un espace de noms à un seul niveau dans le paramètre de chemin d’accès REST. Pour plus d’informations, consultez la section [Paramètre de chemin d’accès à l’espace de noms](connect-glu-iceberg-rest.md#ns-path-param).
+ `CreateTable` avec copie intermédiaire n’est pas prise en charge. Si le paramètre de requête `stageCreate` est spécifié, l’opération échouera. Cela signifie que les opérations comme `CREATE TABLE AS SELECT` ne sont pas prises en charge et que vous pouvez utiliser une combinaison de `CREATE TABLE` et de `INSERT INTO` comme solution de contournement.
+ L’opération d’API `CreateTable` ne prend pas en charge l’option `state-create = TRUE`.
# StartCreateTableTransaction
**Informations générales**
| | |
| --- |--- |
| Nom de l'opération | CreateTable |
| Type | AWS Glue API d'extensions |
| Chemin REST | POST/extensions/v1/catalogs/\$1catalog\$1/namespaces/\$1ns\$1/tables |
| Action IAM | colle : CreateTable |
| Autorisations Lake Formation | ALL, CREATE\$1TABLE |
| CloudTrail event | colle : CreateTable |
| Définition Open API | https://github.com/awslabs/glue-extensions-for-iceberg/blob/main/glue-extensions-api.yaml \$1L107 |
****Considérations et restrictions****
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Vous ne pouvez spécifier qu’un espace de noms à un seul niveau dans le paramètre de chemin d’accès REST. Pour plus d’informations, consultez la section [Paramètre de chemin d’accès à l’espace de noms](connect-glu-iceberg-rest.md#ns-path-param).
+ `CreateTable` avec copie intermédiaire n’est pas prise en charge. Si le paramètre de requête `stageCreate` est spécifié, l’opération échouera. Cela signifie que les opérations comme `CREATE TABLE AS SELECT` ne sont pas prises en charge et que l’utilisateur doit utiliser une combinaison de `CREATE TABLE` et de `INSERT INTO` comme solution de contournement.
+ L’API est asynchrone et renvoie un ID de transaction que vous pouvez utiliser pour le suivi à l’aide de l’appel d’API `CheckTransactionStatus`.
+ L’API ne peut être utilisée que si l’appel d’API `GetCatalog` indique `use-extensions=true` dans la réponse.
# LoadTable
**Informations générales**
| | |
| --- |--- |
| Nom de l’opération | LoadTable |
| Type | API de catalogue REST Iceberg |
| Chemin REST | OBTENIR/iceberg/v1/catalogs/\$1catalog\$1/namespaces/\$1ns\$1/tables/\$1table\$1 |
| Action IAM | colle : GetTable |
| Autorisations Lake Formation | ALL, SELECT, DESCRIBE |
| CloudTrail événement | colle : GetTable |
| Définition Open API | https://github.com/apache/iceberg/blob/apache-iceberg-1.6.1/open-api/rest- catalog-open-api .yaml \$1L616 |
**Considérations**
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Vous ne pouvez spécifier qu’un espace de noms à un seul niveau dans le paramètre de chemin d’accès REST. Pour plus d’informations, consultez la section [Paramètre de chemin d’accès à l’espace de noms](connect-glu-iceberg-rest.md#ns-path-param).
+ `CreateTable` avec copie intermédiaire n’est pas prise en charge. Si le paramètre de requête `stageCreate` est spécifié, l’opération échouera. Cela signifie que les opérations comme `CREATE TABLE AS SELECT` ne sont pas prises en charge et que l’utilisateur doit utiliser une combinaison de `CREATE TABLE` et de `INSERT INTO` comme solution de contournement.
+ L’API est asynchrone et renvoie un ID de transaction que vous pouvez utiliser pour le suivi à l’aide de l’appel d’API `CheckTransactionStatus`.
+ L’API ne peut être utilisée que si l’appel d’API `GetCatalog` indique `use-extensions=true` dans la réponse.
# ExtendedLoadTable
**Informations générales**
| | |
| --- |--- |
| Nom de l’opération | LoadTable |
| Type | AWS Glue API d'extensions |
| Chemin REST | OBTENIR/extensions/v1/catalogs/\$1catalog\$1/namespaces/\$1ns\$1/tables/\$1table\$1 |
| Action IAM | colle : GetTable |
| Autorisations Lake Formation | ALL, SELECT, DESCRIBE |
| CloudTrail événement | colle : GetTable |
| Définition Open API | https://github.com/awslabs/glue-extensions-for-iceberg/blob/main/glue-extensions-api.yaml \$1L134 |
**Considérations**
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Vous ne pouvez spécifier qu’un espace de noms à un seul niveau dans le paramètre de chemin d’accès REST. Pour plus d’informations, consultez la section [Paramètre de chemin d’accès à l’espace de noms](connect-glu-iceberg-rest.md#ns-path-param).
+ Seul le mode `all` est pris en charge pour le paramètre de requête des instantanés.
+ Par rapport à l’API `LoadTable`, l’API `ExtendedLoadTable` se distingue des manières suivantes :
+ Elle n’impose pas strictement que tous les champs soient disponibles.
+ Elle fournit les paramètres supplémentaires suivants dans le champ de configuration de la réponse :
**Paramètres supplémentaires**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/extended-load-table.html)
# PreplanTable
**Informations générales**
| | |
| --- |--- |
| Nom de l’opération | PreplanTable |
| Type | AWS Glue API d'extensions |
| Chemin REST | POSTER/extensions/v1/catalogs/\$1catalog\$1/namespaces/\$1ns\$1/tables/\$1table\$1/preplan |
| Action IAM | colle : GetTable |
| Autorisations Lake Formation | ALL, SELECT, DESCRIBE |
| CloudTrail événement | colle : GetTable |
| Définition Open API | https://github.com/awslabs/glue-extensions-for-iceberg/blob/main/glue-extensions-api.yaml \$1L211 |
**Considérations**
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Vous ne pouvez spécifier qu’un espace de noms à un seul niveau dans le paramètre de chemin d’accès REST. Pour plus d’informations, consultez la section [Paramètre de chemin d’accès à l’espace de noms](connect-glu-iceberg-rest.md#ns-path-param).
+ L’appelant de cette API doit toujours déterminer s’il reste des résultats à récupérer en fonction du jeton de page. Une réponse avec un élément de page vide, mais un jeton de pagination, est possible si le côté serveur est toujours en cours de traitement, mais n’est pas en mesure de produire un résultat dans le temps de réponse donné.
+ Vous ne pouvez utiliser cette API que si la réponse de l’API `ExtendedLoadTable` contient `aws.server-side-capabilities.scan-planning=true`.
# PlanTable
**Informations générales**
| | |
| --- |--- |
| Nom de l’opération | PlanTable |
| Type | AWS Glue API d'extensions |
| Chemin REST | POSTER/extensions/v1/catalogs/\$1catalog\$1/namespaces/\$1ns\$1/tables/\$1table\$1/plan |
| Action IAM | colle : GetTable |
| Autorisations Lake Formation | ALL, SELECT, DESCRIBE |
| CloudTrail événement | colle : GetTable |
| Définition Open API | https://github.com/awslabs/glue-extensions-for-iceberg/blob/main/glue-extensions-api.yaml \$1L243 |
**Considérations**
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Vous ne pouvez spécifier qu’un espace de noms à un seul niveau dans le paramètre de chemin d’accès REST. Pour plus d’informations, consultez la section [Paramètre de chemin d’accès à l’espace de noms](connect-glu-iceberg-rest.md#ns-path-param).
+ L’appelant de cette API doit toujours déterminer s’il reste des résultats à récupérer en fonction du jeton de page. Une réponse avec un élément de page vide, mais un jeton de pagination, est possible si le côté serveur est toujours en cours de traitement, mais n’est pas en mesure de produire un résultat dans le temps de réponse donné.
+ Vous ne pouvez utiliser cette API que si la réponse de l’API `ExtendedLoadTable` contient `aws.server-side-capabilities.scan-planning=true`.
# TableExists
**Informations générales**
| | |
| --- |--- |
| Nom de l’opération | TableExists |
| Type | API de catalogue REST Iceberg |
| Chemin REST | HEAD/iceberg/v1/catalogs/\$1catalog\$1/namespaces/\$1ns\$1/tables/\$1tableau\$1 |
| Action IAM | colle : GetTable |
| Autorisations Lake Formation | ALL, SELECT, DESCRIBE |
| CloudTrail événement | colle : GetTable |
| Définition Open API | https://github.com/apache/iceberg/blob/apache-iceberg-1.6.1/open-api/rest- catalog-open-api .yaml \$1L833 |
**Considérations**
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Vous ne pouvez spécifier qu’un espace de noms à un seul niveau dans le paramètre de chemin d’accès REST. Pour plus d’informations, consultez la section [Paramètre de chemin d’accès à l’espace de noms](connect-glu-iceberg-rest.md#ns-path-param).
# UpdateTable
**Informations générales**
| | |
| --- |--- |
| Nom de l’opération | UpdateTable |
| Type | API de catalogue REST Iceberg |
| Chemin REST | POST/iceberg/v1/catalogs/\$1catalog\$1/namespaces/\$1ns\$1/tables/\$1tableau\$1 |
| Action IAM | colle : UpdateTable |
| Autorisations Lake Formation | ALL, ALTER |
| CloudTrail événement | colle : UpdateTable |
| Définition Open API | https://github.com/apache/iceberg/blob/apache-iceberg-1.6.1/open-api/rest- catalog-open-api .yaml \$1L677 |
**Considérations**
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Vous ne pouvez spécifier qu’un espace de noms à un seul niveau dans le paramètre de chemin d’accès REST. Pour plus d’informations, consultez la section [Paramètre de chemin d’accès à l’espace de noms](connect-glu-iceberg-rest.md#ns-path-param).
# StartUpdateTableTransaction
**Informations générales**
| | |
| --- |--- |
| Nom de l’opération | StartUpdateTableTransaction |
| Type | AWS Glue API d'extension |
| Chemin REST | POST/extensions/v1/catalogs/\$1catalog\$1/namespaces/\$1ns\$1/tables/\$1tableau\$1 |
| Action IAM | colle : UpdateTable |
| Autorisations Lake Formation | ALL, ALTER |
| CloudTrail événement | colle : UpdateTable |
| Définition Open API | https://github.com/awslabs/glue-extensions-for-iceberg/blob/main/glue-extensions-api.yaml \$1L154 |
**Considérations**
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Vous ne pouvez spécifier qu’un espace de noms à un seul niveau dans le paramètre de chemin d’accès REST. Pour plus d’informations, consultez la section [Paramètre de chemin d’accès à l’espace de noms](connect-glu-iceberg-rest.md#ns-path-param).
+ L’API est asynchrone et renvoie un ID de transaction que vous pouvez utiliser pour le suivi à l’aide de l’appel d’API `CheckTransactionStatus`.
+ Une opération `RenamTable` peut également être effectuée par le biais de cette API. Dans ce cas, l'appelant doit également disposer de l'autorisation glue : CreateTable ou LakeFormation CREATE\$1TABLE pour renommer la table.
+ Vous ne pouvez utiliser cette API que si la réponse de l’API `ExtendedLoadTable` contient `aws.server-side-capabilities.scan-planning=true`.
# DeleteTable
**Informations générales**
| | |
| --- |--- |
| Nom de l’opération | DeleteTable |
| Type | API de catalogue REST Iceberg |
| Chemin REST | DELETE/iceberg/v1/catalogs/\$1catalog\$1/namespaces/\$1ns\$1/tables/\$1tableau\$1 |
| Action IAM | colle : DeleteTable |
| Autorisations Lake Formation | ALL, DROP |
| CloudTrail événement | colle : DeleteTable |
| Définition Open API | https://github.com/apache/iceberg/blob/apache-iceberg-1.6.1/open-api/rest- catalog-open-api .yaml \$1L793 |
**Considérations**
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Vous ne pouvez spécifier qu’un espace de noms à un seul niveau dans le paramètre de chemin d’accès REST. Pour plus d’informations, consultez la section [Paramètre de chemin d’accès à l’espace de noms](connect-glu-iceberg-rest.md#ns-path-param).
+ Le fonctionnement de l’API `DeleteTable` prend en charge une option de purge. Lorsque la purge est définie sur `true`, les données de la table sont supprimées ; dans le cas contraire, elles ne le sont pas. Pour les tables dans Amazon S3, l’opération ne supprime pas les données des tables. L’opération échoue lorsque la table est stockée dans Amazon S3 et `purge = TRUE,`.
Pour les tables stockées dans le stockage géré par Amazon Redshift, l’opération supprimera les données des tables, de la même manière que le comportement `DROP TABLE` dans Amazon Redshift. L’opération échoue lorsque la table est stockée dans Amazon Redshift et `purge = FALSE`.
+ `purgeRequest=true` n’est pas pris en charge.
# StartDeleteTableTransaction
**Informations générales**
| | |
| --- |--- |
| Nom de l’opération | StartDeleteTableTransaction |
| Type | AWS Glue API d'extensions |
| Chemin REST | SUPPRIMER/extensions/v1/catalogs/\$1catalog\$1/namespaces/\$1ns\$1/tables/\$1table\$1 |
| Action IAM | colle : DeleteTable |
| Autorisations Lake Formation | ALL, DROP |
| CloudTrail événement | colle : DeleteTable |
| Définition Open API | https://github.com/apache/iceberg/blob/apache-iceberg-1.6.1/open-api/rest- catalog-open-api .yaml \$1L793 |
**Considérations**
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
+ Vous ne pouvez spécifier qu’un espace de noms à un seul niveau dans le paramètre de chemin d’accès REST. Pour plus d’informations, consultez la section [Paramètre de chemin d’accès à l’espace de noms](connect-glu-iceberg-rest.md#ns-path-param).
+ `purgeRequest=false` n’est pas pris en charge.
+ L’API est asynchrone et renvoie un identifiant de transaction qui peut être suivi via `CheckTransactionStatus`.
# CheckTransactionStatus
**Informations générales**
| | |
| --- |--- |
| Nom de l’opération | CheckTransactionStatus |
| Type | AWS Glue API d'extensions |
| Chemin REST | POST/extensions/v1/transactions/status |
| Action IAM | La même autorisation que l’action qui initie la transaction |
| Autorisations Lake Formation | La même autorisation que l’action qui initie la transaction |
| Définition Open API | https://github.com/awslabs/glue-extensions-for-iceberg/blob/main/glue-extensions-api.yaml \$1L273 |
**Considérations**
+ Le paramètre du chemin d’accès au catalogue doit suivre le style décrit dans la section [Paramètres du chemin d’accès au préfixe et au catalogue](connect-glu-iceberg-rest.md#prefix-catalog-path-parameters).
# Connexion au catalogue de données à partir d’une application Spark autonome
Vous pouvez vous connecter au catalogue de données à partir d’une application standard à l’aide d’un connecteur Apache Iceberg.
1. Créez un rôle IAM pour l’application Spark.
1. Connectez-vous au point de terminaison AWS Glue Iceberg Rest à l'aide du connecteur Iceberg.
```
# configure your application. Refer to https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html for best practices on configuring environment variables.
export AWS_ACCESS_KEY_ID=$(aws configure get appUser.aws_access_key_id)
export AWS_SECRET_ACCESS_KEY=$(aws configure get appUser.aws_secret_access_key)
export AWS_SESSION_TOKEN=$(aws configure get appUser.aws_secret_token)
export AWS_REGION=us-east-1
export REGION=us-east-1
export AWS_ACCOUNT_ID = {specify your aws account id here}
~/spark-3.5.3-bin-hadoop3/bin/spark-shell \
--packages org.apache.iceberg:iceberg-spark-runtime-3.4_2.12:1.6.0 \
--conf "spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions" \
--conf "spark.sql.defaultCatalog=spark_catalog" \
--conf "spark.sql.catalog.spark_catalog=org.apache.iceberg.spark.SparkCatalog" \
--conf "spark.sql.catalog.spark_catalog.type=rest" \
--conf "spark.sql.catalog.spark_catalog.uri=https://glue.us-east-1.amazonaws.com/iceberg" \
--conf "spark.sql.catalog.spark_catalog.warehouse = {AWS_ACCOUNT_ID}" \
--conf "spark.sql.catalog.spark_catalog.rest.sigv4-enabled=true" \
--conf "spark.sql.catalog.spark_catalog.rest.signing-name=glue" \
--conf "spark.sql.catalog.spark_catalog.rest.signing-region=us-east-1" \
--conf "spark.sql.catalog.spark_catalog.io-impl=org.apache.iceberg.aws.s3.S3FileIO" \
--conf "spark.hadoop.fs.s3a.aws.credentials.provider=org.apache.hadoop.fs.s3a.SimpleAWSCredentialProvider"
```
1. Interrogez les données du catalogue de données.
```
spark.sql("create database myicebergdb").show()
spark.sql("""CREATE TABLE myicebergdb.mytbl (name string) USING iceberg location 's3://bucket_name/mytbl'""")
spark.sql("insert into myicebergdb.mytbl values('demo') ").show()
```
# Mappage de données entre Amazon Redshift et Apache Iceberg
Redshift et Iceberg prennent en charge différents types de données. La matrice de compatibilité suivante décrit la prise en charge et les restrictions lors du mappage de données entre ces deux systèmes de données. Reportez-vous aux [Types de données Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/c_Supported_data_types.html) et aux [Spécifications des tables Apache Iceberg](https://iceberg.apache.org/spec/#primitive-types) pour plus de détails sur les types de données pris en charge par chaque système de données.
| Type de données Redshift | les alias ; | Type de données Iceberg |
| --- | --- | --- |
| SMALLINT | INT2 | int |
| INTEGER | ENTIER, INT4 | int |
| BIGINT | INT8 | long |
| DECIMAL | NUMERIC | decimal |
| REAL | FLOAT4 | float |
| REAL | FLOAT4 | float |
| DOUBLE PRECISION | FLOAT8, FLOTTEUR | double |
| CHAR | CHARACTER, NCHAR | chaîne |
| VARCHAR | CHARACTER VARYING, NVARCHAR | chaîne |
| BPCHAR | | chaîne |
| TEXT | | chaîne |
| DATE | | date |
| TIME | TIME WITHOUT TIMEZONE | time |
| TIME | TIME WITH TIMEZONE | non pris en charge |
| TIMESTAMP | TIMESTAMP WITHOUT TIMEZONE | TIMESTAMP |
| TIMESTAMPZ | TIMESTAMP WITH TIMEZONE | TIMESTAMPZ |
| INTERVAL YEAR TO MONTH | | Non pris en charge |
| INTERVAL DAY TO SECOND | | Non pris en charge |
| BOOLEAN | BOOL | bool |
| HLLSKETCH | | Non pris en charge |
| SUPER | | Non pris en charge |
| VARBYTE | VARBINARY, BINARY VARYING | binary |
| GEOMETRY | | Non pris en charge |
| GEOGRAPHY | | Non pris en charge |
# Considérations et limites relatives à l'utilisation du catalogue REST d' AWS Glue Iceberg APIs
Voici les considérations et les restrictions liées à l’utilisation du comportement d’opération du langage de définition de données (DDL) du catalogue REST d’Apache Iceberg.
**Considérations**
+ **Comportement de l’API `RenameTable`** : l’opération `RenameTable` est prise en charge dans les tables d’Amazon Redshift, mais pas dans Amazon S3.
+ **Opérations DDL pour les espaces de noms et les tables dans Amazon Redshift** : les opérations de création, de mise à jour, de suppression pour les espaces de noms et les tables dans Amazon Redshift sont des opérations asynchrones, car elles dépendent du moment où le groupe de travail géré par Amazon Redshift est disponible, du fait qu’une transaction DDL et DML conflictuelle est en cours et que l’opération doit attendre le verrouillage, puis essayer de valider les modifications.
**Limitations**
+ Les vues de APIs la spécification REST d'Apache Iceberg ne sont pas prises en charge dans le catalogue REST d' AWS Glue Iceberg.
# AWS Glue Bonnes pratiques en matière de catalogue de données
Cette section présente les meilleures pratiques pour gérer et utiliser efficacement le AWS Glue Data Catalog. Il met l'accent sur des pratiques telles que l'utilisation efficace des robots d'exploration, l'organisation des métadonnées, la sécurité, l'optimisation des performances, l'automatisation, la gouvernance des données et l'intégration avec d'autres AWS services.
+ **Utilisez les robots d'exploration de manière efficace** : exécutez régulièrement des robots d'exploration pour tenir le catalogue de données en fonction up-to-date des modifications apportées à vos sources de données. Utilisez des analyses incrémentielles pour modifier fréquemment les sources de données afin d’améliorer les performances. Configurez les robots pour ajouter automatiquement de nouvelles partitions ou mettre à jour les schémas lorsque des modifications sont détectées.
+ **Organiser et nommer les tables de métadonnées** : établissez une convention de dénomination cohérente pour les bases de données et les tables du catalogue de données. Regroupez les sources de données associées dans des bases de données ou des dossiers logiques pour une meilleure organisation. Utilisez des noms descriptifs qui indiquent le but et le contenu de chaque table.
+ **Gérez les schémas de manière efficace** : tirez parti des fonctionnalités d'inférence de schémas des robots d' AWS Glue exploration. Examinez et mettez à jour les modifications du schéma avant de les appliquer afin d’éviter de perturber les applications en aval. Utilisez les fonctionnalités d’évolution du schéma pour gérer correctement les modifications de schéma.
+ **Sécuriser le catalogue de données** : activez le chiffrement des données au repos et en transit pour le catalogue de données. Mettez en œuvre des politiques de contrôle précis des accès pour restreindre l’accès aux données sensibles. Vérifiez et examinez régulièrement les autorisations et les journaux d’activité du catalogue de données.
+ **Intégration à d'autres AWS services** Catalogue de données Utilisez le catalogue de données comme couche de métadonnées centralisée pour des services tels qu'Amazon Athena, Redshift Spectrum et. AWS Lake Formation Tirez parti des tâches ETL AWS Glue pour transformer et charger des données dans différents entrepôts de données tout en conservant les métadonnées dans le catalogue de données.
+ **Surveillez et optimisez les performances** Catalogue de données Surveillez les performances des robots d'exploration et des tâches ETL à l'aide de Amazon CloudWatch métriques. Partitionnez les grands jeux de données dans le catalogue de données pour améliorer les performances des requêtes. Mettez en œuvre des optimisations des performances pour les métadonnées fréquemment consultées.
+ **Restez à jour grâce à AWS Glue la documentation et au catalogue de données des meilleures pratiques** Consultez régulièrement la AWS Glue documentation et les AWS Glue ressources pour connaître les dernières mises à jour, les meilleures pratiques et les recommandations. Participez à AWS Glue des webinaires, à des ateliers et à d'autres événements pour apprendre auprès d'experts et rester au courant des nouvelles fonctionnalités et capacités.
# Surveillance des métriques d'utilisation du catalogue de données dans Amazon CloudWatch
AWS Glue Data Catalog les métriques d'utilisation sont désormais disponibles Amazon CloudWatch, ce qui simplifie la surveillance et la compréhension de l'utilisation des ressources dans votre catalogue de données. Vous avez désormais une visibilité immédiate sur l’utilisation des catalogues, des bases de données, des tables, des partitions et des connexions par l’API du catalogue Glue, ce qui facilite le suivi de votre catalogue de données.
## Vue d’ensemble des métriques du catalogue de données
AWS Glue Data Catalog publie automatiquement les statistiques d'utilisation sur Amazon CloudWatch. Grâce à l'intégration CloudWatch des métriques, vous pouvez suivre les indicateurs de performance critiques à chaque minute, notamment :
+ Demandes de table
+ Index de partition créés
+ Connexions mises à jour
+ Statistiques mises à jour
Ces métriques vous aident à identifier les goulets d’étranglement, à détecter les anomalies et à prendre des décisions basées sur les données afin d’améliorer la fiabilité globale du catalogue de données. Vous pouvez également configurer des CloudWatch alarmes pour recevoir des notifications lorsque les métriques dépassent les seuils spécifiés, ce qui permet une gestion proactive de votre déploiement.
## Ajouter des métriques à votre CloudWatch tableau de bord
Vous pouvez créer des tableaux de bord personnalisés pour surveiller vos AWS Glue Data Catalog ressources et configurer des alarmes pour être averti de toute activité inhabituelle.
Vous pouvez ajouter les métriques du catalogue de données à votre CloudWatch tableau de bord en suivant ces étapes :
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 **Toutes les métriques**.
1. Choisissez **Utilisation>Par ressource AWS **.
1. Filtrez par **Glue** pour voir les métriques disponibles.
1. Sélectionnez les métriques à ajouter à votre tableau de bord.
1. Ajoutez des métriques pour les catalogues, les bases de données, les tables, les partitions et les connexions à votre CloudWatch graphique.
![\[AWS Glue Data Catalog métriques dans le CloudWatch tableau de bord\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/glue-cloudwatch-metrics.png)
Vous pouvez configurer des alarmes personnalisées qui se déclenchent automatiquement lorsque l’utilisation de l’API dépasse vos seuils définis afin d’identifier les anomalies dans l’utilisation de votre catalogue de données.
Pour obtenir des instructions détaillées sur la configuration des alarmes, voir [Création d'une CloudWatch alarme Metrics Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-metrics-insights-alarm-create.html).
# Registre de schémas AWS Glue
**Note**
AWS GlueLe registre des schémas n'est pas pris en charge dans les régions suivantes de la AWS Glue console : Moyen-Orient (Émirats arabes unis).
Le registre de schémas AWS Glue vous permet de découvrir, de contrôler et de faire évoluer de manière centralisée les schémas de flux de données. Un *schéma* définit la structure et le format d'un enregistrement de données. Avec le registre de schémas AWS Glue, vous pouvez gérer et appliquer des schémas à vos applications de streaming de données en utilisant des intégrations pratiques avec Apache Kafka, [Amazon Managed Streaming pour Apache Kafka](https://aws.amazon.com/msk/), [Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/), [Service géré Amazon pour Apache Flink](https://aws.amazon.com/kinesis/data-analytics/) et [AWS Lambda](https://aws.amazon.com/lambda/).
Le registre de schémas prend en charge le format de données AVRO (v1.11.4), le format de données JSON avec le [format de schéma JSON](https://json-schema.org/) pour le schéma (spécifications Draft-04, Draft-06 et Draft-07) avec la validation de schéma JSON, à l’aide de la [bibliothèque Everit](https://github.com/everit-org/json-schema), de Protocol Buffers (Protobuf) versions proto2 et proto3, sans la prise en charge des `extensions` ou des `groups` et la prise en charge du langage Java, avec d’autres formats de données et de langages à venir. Les fonctionnalités prises en charge incluent la compatibilité, l’utilisation de schémas via des métadonnées, l’enregistrement automatique des schémas, la compatibilité IAM et la compression ZLIB facultative pour réduire le stockage et le transfert de données. Le registre de schémas est sans serveur et son utilisation est gratuite.
L'utilisation d'un schéma comme contrat de format de données entre applications producteur et consommateur conduit à une meilleure gouvernance des données, à une meilleure qualité des données, et permet aux applications consommateur de données d'être résilientes face aux changements compatibles en amont.
Le registre de schémas permet aux systèmes disparates de partager un schéma pour la sérialisation et la désérialisation. Par exemple, supposons que vous ayez un producteur et un consommateur de données. Le producteur connaît le schéma lorsqu'il publie les données. Le registre de schémas fournit un sérialiseur et un désérialiseur pour certains systèmes tels qu'Amazon MSK ou Apache Kafka.
Pour de plus amples informations, veuillez consulter [Fonctionnement du registre de schémas](schema-registry-works.md).
**Topics**
+ [Schémas](#schema-registry-schemas)
+ [Registres](#schema-registry-registries)
+ [Gestion des versions et compatibilité des schémas](#schema-registry-compatibility)
+ [Bibliothèques Serde en open source](#schema-registry-serde-libraries)
+ [Quotas du registre des schémas](#schema-registry-quotas)
+ [Fonctionnement du registre de schémas](schema-registry-works.md)
+ [Démarrage avec le registre de schémas](schema-registry-gs.md)
## Schémas
Un *schéma* définit la structure et le format d'un enregistrement de données. Un schéma est une spécification versionnée pour la publication, la consommation ou le stockage des données fiables.
Dans cet exemple de schéma pour Avro, le format et la structure sont définis par la disposition et les noms de champs, tandis que le format des noms de champs est défini par les types de données (par exemple, `string`, `int`).
```
{
"type": "record",
"namespace": "ABC_Organization",
"name": "Employee",
"fields": [
{
"name": "Name",
"type": "string"
},
{
"name": "Age",
"type": "int"
},
{
"name": "address",
"type": {
"type": "record",
"name": "addressRecord",
"fields": [
{
"name": "street",
"type": "string"
},
{
"name": "zipcode",
"type": "int"
}
]
}
}
]
}
```
Dans cet exemple JSON Schema Draft-07 pour JSON, le format est défini par l’[organisation du schéma JSON](https://json-schema.org/).
```
{
"$id": "https://example.com/person.schema.json",
"$schema": "http://json-schema.org/draft-07/schema#",
"title": "Person",
"type": "object",
"properties": {
"firstName": {
"type": "string",
"description": "The person's first name."
},
"lastName": {
"type": "string",
"description": "The person's last name."
},
"age": {
"description": "Age in years which must be equal to or greater than zero.",
"type": "integer",
"minimum": 0
}
}
}
```
Dans cet exemple pour Protobuf, le format est défini par la [version 2 du langage Protocol Buffers (proto2)](https://developers.google.com/protocol-buffers/docs/reference/proto2-spec).
```
syntax = "proto2";
package tutorial;
option java_multiple_files = true;
option java_package = "com.example.tutorial.protos";
option java_outer_classname = "AddressBookProtos";
message Person {
optional string name = 1;
optional int32 id = 2;
optional string email = 3;
enum PhoneType {
MOBILE = 0;
HOME = 1;
WORK = 2;
}
message PhoneNumber {
optional string number = 1;
optional PhoneType type = 2 [default = HOME];
}
repeated PhoneNumber phones = 4;
}
message AddressBook {
repeated Person people = 1;
}
```
## Registres
Un *registre* est un conteneur logique de schémas. Les registres vous permettent d'organiser vos schémas, ainsi que de gérer le contrôle des accès pour vos applications. Un registre possède un Amazon Resource Name (ARN) qui vous permet d'organiser et de définir différentes autorisations d'accès aux opérations de schéma dans le registre.
Vous pouvez utiliser le registre par défaut ou créer autant de registres que nécessaire.
**Hiérarchie du registre de schémas AWS Glue**
| |
| --- |
| [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/schema-registry.html) |
| [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/schema-registry.html) |
| [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/schema-registry.html) |
| [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/schema-registry.html) |
## Gestion des versions et compatibilité des schémas
Chaque schéma peut avoir plusieurs versions. La gestion des versions est régie par une règle de compatibilité appliquée à un schéma. Les demandes d'enregistrement de nouvelles versions de schéma sont vérifiées par rapport à cette règle par le registre de schémas avant qu'elles ne puissent aboutir.
Une version de schéma qui est marquée comme point de contrôle est utilisée pour déterminer la compatibilité de l'enregistrement de nouvelles versions d'un schéma. Lorsqu'un schéma est créé pour la première fois, le point de contrôle par défaut sera la première version. Au fur et à mesure que le schéma évolue avec de nouvelles versions, vous pouvez utiliser le CLI/SDK pour remplacer le point de contrôle par une version d'un schéma à l'aide de l'`UpdateSchema`API qui respecte un ensemble de contraintes. Dans la console, la modification de la définition du schéma ou du mode de compatibilité modifiera le point de contrôle vers la dernière version par défaut.
Les modes de compatibilité vous permettent de contrôler la manière dont les schémas peuvent ou ne peuvent pas évoluer au fil du temps. Ces modes constituent le contrat entre les applications produisant et consommant des données. Lorsqu'une nouvelle version d'un schéma est envoyée au registre, la règle de compatibilité appliquée au nom du schéma est utilisée pour déterminer si la nouvelle version peut être acceptée. Il existe huit modes de compatibilité : NONE, DISABLED, BACKWARD, BACKWARD\$1ALL, FORWARD\$1ALL, FULL, FULL\$1ALL.
Au format de données Avro, les champs peuvent être facultatifs ou obligatoires. Un champ facultatif est celui dans lequel le champ `Type` inclut une valeur null. Les champs obligatoires n'ont pas de valeur nulle comme `Type`.
Dans le format de données Protobuf, les champs peuvent être facultatifs (y compris ceux répétés) ou obligatoires dans la syntaxe proto2, tandis que tous les champs sont facultatifs (y compris ceux répétés) dans la syntaxe proto3. Toutes les règles de compatibilité sont déterminées en fonction de la compréhension des spécifications de Protocol Buffers, ainsi que des directives de la [Documentation Protocol Buffers de Google ](https://developers.google.com/protocol-buffers/docs/overview#updating).
+ *NONE (AUCUN)* : aucun mode de compatibilité ne s'applique. Vous pouvez utiliser ce choix dans les scénarios de développement ou si vous ne connaissez pas les modes de compatibilité que vous souhaitez appliquer aux schémas. Toute nouvelle version ajoutée sera acceptée sans faire l'objet d'un contrôle de compatibilité.
+ *DISABLED (DÉSACTIVÉ)* : ce choix de compatibilité empêche la gestion des versions pour un schéma particulier. Aucune nouvelle version ne peut être ajoutée.
+ *BACKWARD (DESCENDANT)* : ce choix de compatibilité est recommandé, car il permet aux applications consommateur de lire à la fois la version actuelle et la version précédente du schéma. Vous pouvez utiliser ce choix pour vérifier la compatibilité par rapport à la version précédente du schéma lorsque vous supprimez des champs ou ajoutez des champs facultatifs. Un cas d'utilisation typique pour BACKWARD (DESCENDANT) est lorsque votre application a été créée pour le schéma le plus récent.
**AVRO**
Par exemple, supposons que vous avez un schéma défini par le prénom (obligatoire), le nom (obligatoire), l'adresse électronique (obligatoire) et le numéro de téléphone (facultatif).
Si votre prochaine version de schéma supprime le champ d'adresse électronique requis, l'enregistrement s'effectue correctement. La compatibilité BACKWARD (DESCENDANT) exige que les applications consommateur soient en mesure de lire la version actuelle et précédente du schéma. Vos applications consommateur seront en mesure de lire le nouveau schéma, car le champ d'adresse électronique supplémentaire des anciens messages est ignoré.
Si vous avez proposé une nouvelle version de schéma qui ajoute un champ obligatoire, par exemple, le code postal, elle ne s'enregistrerait pas avec la compatibilité BACKWARD (DESCENDANT). Vos applications consommateur sur la nouvelle version ne seraient pas en mesure de lire les anciens messages avant la modification du schéma, car elles ne disposent pas du champ de code postal requis. Toutefois, si le champ de code postal a été défini comme facultatif dans le nouveau schéma, la version proposée s'enregistrerait avec succès, car les applications consommateur peuvent lire l'ancien schéma sans le champ de code postal facultatif.
**JSON**
Par exemple, supposons que vous avez une version de schéma définie par le prénom (facultatif), le nom de famille (facultatif), l'adresse électronique (facultatif) et le numéro de téléphone (facultatif).
Si votre prochaine version de schéma ajoute la propriété de numéro de téléphone facultative, elle s'enregistrera avec succès tant que la version de schéma d'origine n'autorise aucune propriété supplémentaire en définissant le champ `additionalProperties` sur false. La compatibilité BACKWARD (DESCENDANT) exige que les applications consommateur soient en mesure de lire la version actuelle et précédente du schéma. Vos applications consommateur seront en mesure de lire les données produites avec le schéma d'origine où la propriété de numéro de téléphone n'existe pas.
Si vous avez une proposition de nouvelle version de schéma qui ajoute la propriété de numéro de téléphone facultative, elle ne s'enregistrerait pas correctement avec la compatibilité BACKWARD (DESCENDANT) lorsque la version de schéma d'origine définit le champ `additionalProperties` sur true, à savoir autoriser toute propriété supplémentaire. Vos applications consommateur sur la nouvelle version ne seraient pas en mesure de lire les anciens messages avant le changement de schéma, car elles ne peuvent pas lire les données avec la propriété de numéro de téléphone dans un type différent, par exemple une chaîne au lieu d'un numéro.
**PROTOBUF**
Par exemple, imaginez que vous avez une version de schéma définie par un message `Person` avec `first name` (obligatoire), `last name` (obligatoire), `email` (obligatoire) et le champ `phone number` (facultatifs) sous la syntaxe proto2.
Similaire aux scénarios AVRO, si la version de schéma suivante supprime le champ requis `email`, l'enregistrement s'effectue correctement. La compatibilité BACKWARD (DESCENDANT) exige que les applications consommateur soient en mesure de lire la version actuelle et précédente du schéma. Les consommateurs seront en mesure de lire le nouveau schéma, car le champ supplémentaire `email` des anciens messages est ignoré.
Si vous avez proposé une nouvelle version de schéma qui ajoute un champ obligatoire, par exemple, `zip code`, l'enregistrement ne s'effectue pas correctement avec la compatibilité DESCENDANTE. Les consommateurs sur la nouvelle version ne seraient pas en mesure de lire les anciens messages avant la modification du schéma, car ils ne disposent pas du champ requis `zip code`. Toutefois, si le champ `zip code` a été défini comme facultatif dans le nouveau schéma, l'enregistrement de la version proposée s'effectue correctement, car les consommateurs peuvent lire l'ancien schéma sans le champ facultatif `zip code`.
Dans le cas d'un cas d'utilisation de gRPC, l'ajout d'un nouveau service RPC ou d'une nouvelle méthode RPC est une modification de compatibilité descendante. Par exemple, imaginez que vous avez une version de schéma définie par un service RPC `MyService` avec deux méthodes RPC, `Foo` et `Bar`.
Si la version de schéma suivante ajoute une nouvelle méthode RPC appelée `Baz`, l'enregistrement s'effectue correctement. Les consommateurs seront en mesure de lire les données produites avec le schéma d'origine, en fonction de la compatibilité DESCENDANTE, car la nouvelle méthode RPC ajoutée `Baz` est facultative.
Si vous avez proposé une nouvelle version de schéma qui supprime la méthode RPC existante `Foo`, l'enregistrement ne s'effectue pas correctement avec la compatibilité DESCENDANTE. Les consommateurs sur la nouvelle version ne seraient pas en mesure de lire les anciens messages avant la modification du schéma, car ils ne peuvent pas comprendre et lire les données avec la méthode RPC inexistante `Foo` dans une application gRPC.
+ *BACKWARD\$1ALL (DESCENDANT\$1TOUT)* : ce choix de compatibilité permet aux applications consommateur de lire à la fois la version actuelle et toutes les versions antérieures du schéma. Vous pouvez utiliser ce choix pour vérifier la compatibilité avec toutes les versions de schéma précédentes lorsque vous supprimez des champs ou ajoutez des champs facultatifs.
+ *FORWARD (ASCENDANT)* : ce choix de compatibilité permet aux applications consommateur de lire à la fois la version actuelle et les versions suivantes du schéma, mais pas nécessairement les versions ultérieures. Vous pouvez utiliser ce choix pour vérifier la compatibilité avec la dernière version de schéma lorsque vous ajoutez des champs ou supprimez des champs facultatifs. Un cas d'utilisation typique pour FORWARD (ASCENDANT) est lorsque votre application a été créée pour un schéma précédent et devrait être capable de traiter un schéma plus récent.
**AVRO**
Par exemple, supposons que vous avez une version de schéma définie par le prénom (obligatoire), le nom (obligatoire) et l'adresse électronique (facultatif).
Si vous disposez d'une nouvelle version de schéma qui ajoute un champ obligatoire ; par exemple, un numéro de téléphone, l'enregistrement s'effectue correctement. La compatibilité FORWARD (ASCENDANT) exige que les applications consommateur puissent lire les données produites avec le nouveau schéma à l'aide de la version précédente.
Si vous avez une version de schéma proposée qui supprime le champ de prénom obligatoire, elle ne s'enregistrerait pas avec la compatibilité FORWARD (ASCENDANT). Vos applications consommateur sur la version précédente ne seraient pas en mesure de lire les schémas proposés, car elles ne disposent pas du champ de prénom obligatoire. Toutefois, si le champ de prénom était initialement facultatif, le nouveau schéma proposé s'enregistrerait correctement, car les applications consommateur peuvent lire des données basées sur le nouveau schéma qui ne dispose pas du champ de prénom facultatif.
**JSON**
Par exemple, supposons que vous avez une version de schéma définie par le prénom (facultatif), le nom de famille (facultatif), l'adresse électronique (facultatif) et le numéro de téléphone (facultatif).
Si vous disposez d'une nouvelle version de schéma qui supprime la propriété de numéro de téléphone facultative, elle s'enregistrera avec succès tant que la nouvelle version de schéma n'autorise aucune propriété supplémentaire en définissant le champ `additionalProperties` sur false. La compatibilité FORWARD (ASCENDANT) exige que les applications consommateur puissent lire les données produites avec le nouveau schéma à l'aide de la version précédente.
Si vous avez une proposition de version de schéma qui supprime la propriété de numéro de téléphone facultative, elle ne s'enregistrerait pas correctement avec la compatibilité FORWARD (ASCENDANT) lorsque la nouvelle version de schéma définit le champ `additionalProperties` sur true, à savoir autoriser toute propriété supplémentaire. Vos applications consommateur sur la version précédente ne seraient pas en mesure de lire les schémas proposés, car elles pourraient avoir la propriété de numéro de téléphone dans un type différent, par exemple une chaîne au lieu d'un numéro.
**PROTOBUF**
Par exemple, imaginez que vous avez une version de schéma définie par un message `Person` avec des champs `first name` (obligatoire), `last name` (obligatoire), `email` (facultatif) sous la syntaxe proto2.
Similaire aux scénarios AVRO, si vous disposez d'une nouvelle version de schéma qui ajoute un champ obligatoire ; par exemple `phone number`, l'enregistrement s'effectue correctement. La compatibilité FORWARD (ASCENDANT) exige que les applications consommateur puissent lire les données produites avec le nouveau schéma à l'aide de la version précédente.
Si vous avez une version de schéma proposée qui supprime le champ obligatoire `first name`, l'enregistrement ne s'effectue pas correctement avec la compatibilité ASCENDANTE. Les consommateurs sur la version précédente ne seraient pas en mesure de lire les schémas proposés, car le champ obligatoire `first name` est absent. Toutefois, si le champ `first name` était initialement facultatif, l'enregistrement du nouveau schéma proposé s'effectue correctement, car les consommateurs peuvent lire des données basées sur le nouveau schéma où le champ facultatif `first name` est absent.
Dans le cas d'un cas d'utilisation de gRPC, la suppression d'un service RPC ou d'une méthode RPC est une modification de compatibilité ascendante. Par exemple, imaginez que vous avez une version de schéma définie par un service RPC `MyService` avec deux méthodes RPC, `Foo` et `Bar`.
Si la version de schéma suivante supprime la méthode RPC existante nommée `Foo`, l'enregistrement s'effectue correctement en fonction de la compatibilité ASCENDANTE, car les consommateurs peuvent lire les données produites avec le nouveau schéma à l'aide de la version précédente. Si vous avez une nouvelle version de schéma proposée qui ajoute une méthode RPC `Baz`, l'enregistrement ne s'effectue pas correctement avec la compatibilité ASCENDANTE. Les consommateurs sur la version précédente ne seraient pas en mesure de lire les schémas proposés, car ils ne disposent pas de la méthode RPC `Baz`.
+ *FORWARD\$1ALL (ASCENDANT\$1TOUT)* : ce choix de compatibilité permet aux applications consommateur de lire les données écrites par les applications producteur de tout nouveau schéma enregistré. Vous pouvez utiliser ce choix lorsque vous devez ajouter des champs ou supprimer des champs facultatifs, et vérifier la compatibilité avec à toutes les versions de schéma précédentes.
+ *FULL (COMPLET)* : ce choix de compatibilité permet aux applications consommateur de lire les données écrites par les applications producteur en utilisant la version précédente ou suivante du schéma, mais pas les versions antérieures ou ultérieures. Vous pouvez utiliser ce choix pour vérifier la compatibilité avec la dernière version de schéma lorsque vous ajoutez ou supprimez des champs facultatifs.
+ *FULL\$1ALL (COMPLET\$1TOUT)* : ce choix de compatibilité permet aux applications consommateur de lire les données écrites par les applications producteur utilisant toutes les versions de schéma précédentes. Vous pouvez utiliser ce choix pour vérifier la compatibilité par rapport à toutes les versions de schéma précédentes lorsque vous ajoutez ou supprimez des champs facultatifs.
## Bibliothèques Serde en open source
AWS fournit des bibliothèques Serde open source comme framework pour la sérialisation et la désérialisation des données. La conception open source de ces bibliothèques permet aux applications et aux cadres open source communs de prendre en charge ces bibliothèques dans leurs projets.
Pour plus de détails sur le fonctionnement des bibliothèques Serde, veuillez consulter [Fonctionnement du registre de schémas](schema-registry-works.md).
## Quotas du registre des schémas
Les quotas, également appelés limites dans AWS, sont les valeurs maximales pour les ressources, les actions et les éléments de votre AWS compte. Voici des limites logicielles pour le registre de schémas dans AWS Glue.
**Paires clé-valeur des métadonnées de version de schéma**
Vous pouvez avoir jusqu'à 10 paires clé-valeur SchemaVersion par région. AWS
Vous pouvez afficher ou définir les paires de métadonnées clé-valeur à l'aide du [QuerySchemaVersionMetadata action (Python : query\$1schema\$1version\$1metadata)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-QuerySchemaVersionMetadata) ou. [PutSchemaVersionMetadata action (Python : put\$1schema\$1version\$1metadata)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-PutSchemaVersionMetadata) APIs
Voici des limites matérielles pour le registre de schémas dans AWS Glue.
**Registres**
Vous pouvez avoir jusqu'à 100 registres par AWS région pour ce compte.
**SchemaVersion**
Vous pouvez avoir jusqu'à 10 000 versions de schéma par AWS région pour ce compte.
Chaque nouveau schéma crée une version de schéma, de sorte que vous pouvez théoriquement avoir jusqu’à 10 000 schémas par compte et par région, si chaque schéma ne dispose que d’une seule version.
**Charges utiles de schéma**
Il existe une limite de taille de 170 Ko pour les charges utiles de schéma.
# Fonctionnement du registre de schémas
Cette section décrit le fonctionnement des processus de sérialisation et de désérialisation dans le registre de schémas.
1. Enregistrer un schéma : si le schéma n'existe pas encore dans le registre, le schéma peut être enregistré avec un nom de schéma égal au nom de la destination (par exemple, test\$1topic, test\$1stream, prod\$1firehose) ou le producteur peut fournir un nom personnalisé pour le schéma. Les producteurs peuvent également ajouter des paires clé-valeur au schéma sous forme de métadonnées, telles que source : MSK\$1Kafka\$1Topic\$1A, ou appliquer des balises aux schémas lors de la création du schéma. AWS Une fois qu'un schéma est enregistré, le registre de schémas renvoie l'ID de version de schéma au sérialiseur. Si le schéma existe, mais que le sérialiseur utilise une nouvelle version qui n'existe pas, le registre de schémas vérifie que le schéma fait référence à une règle de compatibilité pour s'assurer que la nouvelle version est compatible avant de l'enregistrer en tant que nouvelle version.
Il existe deux méthodes d'enregistrement d'un schéma : l'enregistrement manuel et l'enregistrement automatique. Vous pouvez enregistrer un schéma manuellement via la console AWS Glue ou la CLI/le SDK.
Lorsque l'enregistrement automatique est activé dans les paramètres du sérialiseur, l'enregistrement automatique du schéma est effectué. Si la valeur `REGISTRY_NAME` n'est pas fournie dans les configurations du producteur, l'enregistrement automatique enregistrera alors la nouvelle version du schéma sous le registre par défaut (default-registry). Voir [Installation de SerDe bibliothèques](schema-registry-gs-serde.md) pour plus d'informations sur la spécification de la propriété d'enregistrement automatique.
1. Le sérialiseur valide les enregistrements de données par rapport au schéma : lorsque l'application produisant des données a enregistré son schéma, le sérialiseur du registre de schémas valide l'enregistrement produit par l'application structurée avec les champs et les types de données correspondant à un schéma enregistré. Si le schéma de l'enregistrement ne correspond pas à un schéma enregistré, le sérialiseur renvoie une exception et l'application ne parvient pas à livrer l'enregistrement à la destination.
Si aucun schéma n'existe et si le nom du schéma n'est pas fourni via les configurations du producteur, le schéma est créé avec le même nom que le nom de la rubrique (s'il s'agit d'Apache Kafka ou d'Amazon MSK) ou le nom du flux (s'il s'agit de Kinesis Data Streams).
Chaque enregistrement a une définition de schéma et des données. La définition du schéma est interrogée par rapport aux schémas et versions existants dans le registre de schémas.
Par défaut, les producteurs mettent en cache les définitions des schémas et les versions IDs des schémas enregistrés. Si la définition de version de schéma d'un enregistrement ne correspond pas à ce qui est disponible dans le cache, le producteur tentera de valider le schéma avec le registre de schémas. Si la version du schéma est valide, son ID de version et sa définition seront alors mis en cache localement sur le producteur.
Vous pouvez ajuster la période de mise en cache par défaut (24 heures) dans les propriétés facultatives du producteur à l'étape 3 de [Installation de SerDe bibliothèques](schema-registry-gs-serde.md).
1. Sérialiser et livrer des enregistrements : si l'enregistrement est conforme au schéma, le sérialiseur décore chaque enregistrement avec l'ID de version du schéma, sérialise l'enregistrement en fonction du format de données sélectionné (AVRO, JSON, Protobuf ou autres formats prochainement disponibles), compresse l'enregistrement (configuration du producteur facultative) et le livre à la destination.
1. Les applications consommateur désérialisent les données : les applications consommateur qui lisent ces données utilisent la bibliothèque du désérialiseur du registre de schémas qui analyse l'ID de version du schéma à partir de la charge utile de l'enregistrement.
1. Le désérialiseur peut demander le schéma à partir du registre de schémas : si c'est la première fois que le désérialiseur a constaté des enregistrements avec un ID de version de schéma particulier, à l'aide de l'ID de version de schéma, il demandera le schéma à partir du registre de schémas et mettra en cache le schéma localement sur l'application consommateur. Si le registre de schémas ne peut pas désérialiser l'enregistrement, l'application consommateur peut journaliser les données de l'enregistrement et continuer, mais aussi arrêter l'application.
1. Le désérialiseur utilise le schéma pour désérialiser l'enregistrement : lorsque le désérialiseur récupère l'ID de version de schéma auprès du registre de schémas, le désérialiseur décompresse l'enregistrement (si l'enregistrement envoyé par le producteur est compressé) et utilise le schéma pour désérialiser l'enregistrement. L'application traite à présent l'enregistrement.
**Note**
Chiffrement : vos clients communiquent avec le registre de schémas via des appels d'API qui chiffrent les données en transit à l'aide du chiffrement TLS sur HTTPS. Les schémas stockés dans le registre des schémas sont toujours chiffrés au repos à l'aide d'une clé gérée par le service AWS Key Management Service ()AWS KMS.
**Note**
Autorisation de l'utilisateur : le registre de schémas prend en charge les politiques IAM basées sur l'identité.
# Démarrage avec le registre de schémas
Les sections suivantes fournissent une présentation et vous expliquent comment configurer et utiliser le registre de schémas. Pour plus d’informations sur les concepts et les composants du registre de schémas, consultez [Registre de schémas AWS Glue](schema-registry.md).
**Topics**
+ [Installation de SerDe bibliothèques](schema-registry-gs-serde.md)
+ [Intégration au registre de schémas AWS Glue](schema-registry-integrations.md)
+ [Migration d'un registre de schémas tiers vers le registre de schémas AWS Glue](schema-registry-integrations-migration.md)
# Installation de SerDe bibliothèques
Les SerDe bibliothèques fournissent un cadre pour la sérialisation et la désérialisation des données.
Vous allez installer le sérialiseur open source pour vos applications produisant des données (collectivement les « sérialiseurs »). Le sérialiseur gère la sérialisation, la compression et l'interaction avec le registre de schémas. Le sérialiseur extrait automatiquement le schéma d'un enregistrement en cours d'écriture vers une destination compatible avec le registre de schémas, telle qu'Amazon MSK. De même, vous allez installer le désérialiseur open source sur vos applications consommant des données.
# Implémentation Java
**Note**
Prérequis : avant d'effectuer les étapes suivantes, vous devez avoir un Amazon Managed Streaming pour Apache Kafka (Amazon MSK) ou un cluster Apache Kafka en cours d'exécution. Vos applications producteur et consommateur doivent utiliser Java 8 ou une version supérieure.
Pour installer les bibliothèques sur les applications producteur et consommateur :
1. Dans les fichiers pom.xml des applications producteur et consommateur, ajoutez cette dépendance via le code ci-dessous :
```
software.amazon.glueschema-registry-serde1.1.5
```
Vous pouvez également cloner le [référentiel Github du registre de schémas AWS Glue](https://github.com/awslabs/aws-glue-schema-registry).
1. Configurez vos applications producteur avec les propriétés requises suivantes :
```
props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName()); // Can replace StringSerializer.class.getName()) with any other key serializer that you may use
props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, GlueSchemaRegistryKafkaSerializer.class.getName());
props.put(AWSSchemaRegistryConstants.AWS_REGION, "us-east-2");
properties.put(AWSSchemaRegistryConstants.DATA_FORMAT, "JSON"); // OR "AVRO"
```
S'il n'existe aucun schéma existant, l'enregistrement automatique doit être activé (étape suivante). Si vous avez un schéma que vous souhaitez appliquer, remplacez « my-schema » par le nom de votre schéma. La valeur « registry-name » doit également être fournie si l'enregistrement automatique du schéma est désactivé. Si le schéma est créé sous la valeur « default-registry », le nom du registre peut être omis.
1. (Facultatif) Définissez l'une de ces propriétés de producteur facultatives. Pour une description détaillée des propriétés, consultez [le ReadMe fichier](https://github.com/awslabs/aws-glue-schema-registry/blob/master/README.md).
```
props.put(AWSSchemaRegistryConstants.SCHEMA_AUTO_REGISTRATION_SETTING, "true"); // If not passed, uses "false"
props.put(AWSSchemaRegistryConstants.SCHEMA_NAME, "my-schema"); // If not passed, uses transport name (topic name in case of Kafka, or stream name in case of Kinesis Data Streams)
props.put(AWSSchemaRegistryConstants.REGISTRY_NAME, "my-registry"); // If not passed, uses "default-registry"
props.put(AWSSchemaRegistryConstants.CACHE_TIME_TO_LIVE_MILLIS, "86400000"); // If not passed, uses 86400000 (24 Hours)
props.put(AWSSchemaRegistryConstants.CACHE_SIZE, "10"); // default value is 200
props.put(AWSSchemaRegistryConstants.COMPATIBILITY_SETTING, Compatibility.FULL); // Pass a compatibility mode. If not passed, uses Compatibility.BACKWARD
props.put(AWSSchemaRegistryConstants.DESCRIPTION, "This registry is used for several purposes."); // If not passed, constructs a description
props.put(AWSSchemaRegistryConstants.COMPRESSION_TYPE, AWSSchemaRegistryConstants.COMPRESSION.ZLIB); // If not passed, records are sent uncompressed
```
L'enregistrement automatique enregistre la version du schéma sous le registre par défaut (« default-registry »). Si une valeur `SCHEMA_NAME` n'est pas spécifiée à l'étape précédente, le nom de la rubrique est alors déduit comme étant `SCHEMA_NAME`.
Pour de plus amples informations sur les modes de compatibilité, veuillez consulter [Gestion des versions et compatibilité des schémas](schema-registry.md#schema-registry-compatibility).
1. Configurez vos applications consommateur avec les propriétés requises suivantes :
```
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, GlueSchemaRegistryKafkaDeserializer.class.getName());
props.put(AWSSchemaRegistryConstants.AWS_REGION, "us-east-2"); // Pass an Région AWS
props.put(AWSSchemaRegistryConstants.AVRO_RECORD_TYPE, AvroRecordType.GENERIC_RECORD.getName()); // Only required for AVRO data format
```
1. (Facultatif) Définissez ces propriétés d'application consommateur facultatives. Pour une description détaillée des propriétés, consultez [le ReadMe fichier](https://github.com/awslabs/aws-glue-schema-registry/blob/master/README.md).
```
properties.put(AWSSchemaRegistryConstants.CACHE_TIME_TO_LIVE_MILLIS, "86400000"); // If not passed, uses 86400000
props.put(AWSSchemaRegistryConstants.CACHE_SIZE, "10"); // default value is 200
props.put(AWSSchemaRegistryConstants.SECONDARY_DESERIALIZER, "com.amazonaws.services.schemaregistry.deserializers.external.ThirdPartyDeserializer"); // For migration fall back scenario
```
# Implémentation en C\$1
**Note**
Prérequis : avant d'effectuer les étapes suivantes, vous devez avoir un Amazon Managed Streaming pour Apache Kafka (Amazon MSK) ou un cluster Apache Kafka en cours d'exécution. Vos producteurs et consommateurs doivent utiliser .NET 8.0 ou une version ultérieure.
## Installation
Pour les applications C\$1, installez le SerDe NuGet package AWS Glue Schema Registry en utilisant l'une des méthodes suivantes :
**CLI .NET :**
Utilisez la commande suivante pour installer le package :
```
dotnet add package Aws.Glue.SchemaRegistry --version 1.0.0-
```
où `` cela pourrait être`1.0.0-linux-x64`, `1.0.0-linux-musl-x64` ou `1.0.0-linux-arm64`
**PackageReference (dans votre fichier .csproj) :**
Ajoutez ce qui suit à votre fichier de projet :
```
```
où `` cela pourrait être`1.0.0-linux-x64`, `1.0.0-linux-musl-x64` ou `1.0.0-linux-arm64`
## Configuration du fichier de configuration
Créez un fichier de propriétés de configuration (par exemple,`gsr-config.properties`) avec les paramètres requis :
**Configuration minimale :**
Voici un exemple de configuration minimale :
```
region=us-east-1
registry.name=default-registry
dataFormat=AVRO
schemaAutoRegistrationEnabled=true
```
## Utilisation de la bibliothèque cliente C\$1 Glue Schema pour Kafka SerDes
**Exemple d'utilisation du sérialiseur :**
L'exemple suivant montre comment utiliser le sérialiseur :
```
private static readonly string PROTOBUF_CONFIG_PATH = "";
var protobufSerializer = new GlueSchemaRegistryKafkaSerializer(PROTOBUF_CONFIG_PATH);
var serialized = protobufSerializer.Serialize(message, message.Descriptor.FullName);
// send serialized bytes to Kafka using producer.Produce(serialized)
```
**Exemple d'utilisation du désérialiseur :**
L'exemple suivant montre comment utiliser le désérialiseur :
```
private static readonly string PROTOBUF_CONFIG_PATH = "";
var dataConfig = new GlueSchemaRegistryDataFormatConfiguration(
new Dictionary
{
{
GlueSchemaRegistryConstants.ProtobufMessageDescriptor, message.Descriptor
}
}
);
var protobufDeserializer = new GlueSchemaRegistryKafkaDeserializer(PROTOBUF_CONFIG_PATH, dataConfig);
// read message from Kafka using serialized = consumer.Consume()
var deserializedObject = protobufDeserializer.Deserialize(message.Descriptor.FullName, serialized);
```
## Utilisation de la bibliothèque cliente C\$1 Glue Schema avec for KafkaFlow SerDes
**Exemple d'utilisation du sérialiseur :**
L'exemple suivant montre comment configurer KafkaFlow avec le sérialiseur :
```
services.AddKafka(kafka => kafka
.UseConsoleLog()
.AddCluster(cluster => cluster
.WithBrokers(new[] { "localhost:9092" })
.AddProducer(producer => producer
.DefaultTopic("customer-events")
.AddMiddlewares(m => m
.AddSerializer>(
() => new GlueSchemaRegistryKafkaFlowProtobufSerializer("config/gsr-config.properties")
)
)
)
)
);
```
**Exemple d'utilisation du désérialiseur :**
L'exemple suivant montre comment configurer KafkaFlow avec le désérialiseur :
```
.AddConsumer(consumer => consumer
.Topic("customer-events")
.WithGroupId("customer-group")
.WithBufferSize(100)
.WithWorkersCount(10)
.AddMiddlewares(middlewares => middlewares
.AddDeserializer>(
() => new GlueSchemaRegistryKafkaFlowProtobufDeserializer("config/gsr-config.properties")
)
.AddTypedHandlers(h => h.AddHandler())
)
)
```
## Propriétés facultatives du producteur
Vous pouvez étendre votre fichier de configuration avec des propriétés facultatives supplémentaires :
```
# Auto-registration (if not passed, uses "false")
schemaAutoRegistrationEnabled=true
# Schema name (if not passed, uses topic name)
schema.name=my-schema
# Registry name (if not passed, uses "default-registry")
registry.name=my-registry
# Cache settings
cacheTimeToLiveMillis=86400000
cacheSize=200
# Compatibility mode (if not passed, uses BACKWARD)
compatibility=FULL
# Registry description
description=This registry is used for several purposes.
# Compression (if not passed, records are sent uncompressed)
compressionType=ZLIB
```
## Formats de données pris en charge
Les implémentations Java et C\$1 prennent en charge les mêmes formats de données :
+ *AVRO : format* binaire Apache Avro
+ *JSON* : format de schéma JSON
+ *PROTOBUF : format des* tampons de protocole
## Remarques
+ Pour commencer à utiliser la bibliothèque, rendez-vous sur [https://www.nuget. org/packages/AWS.Colle. SchemaRegistry](https://www.nuget.org/packages/AWS.Glue.SchemaRegistry)
+ Le code source est disponible à l'adresse suivante : [https://github.com/awslabs/aws-glue-schema-registry](https://github.com/awslabs/aws-glue-schema-registry)
# Création d'un registre
Vous pouvez utiliser le registre par défaut ou créer autant de nouveaux registres que nécessaire à l'aide de la AWS Glue console AWS Glue APIs or.
**AWS Glue APIs**
Vous pouvez suivre ces étapes pour effectuer cette tâche à l'aide du AWS Glue APIs.
Pour utiliser le AWS CLI registre des AWS Glue schémas APIs, assurez-vous de mettre à jour votre version AWS CLI à la plus récente.
Pour ajouter un nouveau registre, utilisez l'API [CreateRegistry action (Python : create\$1registry)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-CreateRegistry). Spécifiez `RegistryName` comme nom du registre à créer, avec une longueur maximale de 255, contenant uniquement des lettres, des chiffres, des traits d'union, des traits de soulignement, le symbole dollar ou le dièse.
Spécifiez une valeur `Description` comme une chaîne d’une longueur maximale de 2 048 octets, correspondant au [modèle de chaîne à plusieurs lignes d’adresse URI](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-common.html#aws-glue-api-common-_string-patterns).
Vous pouvez également spécifier une ou plusieurs `Tags` pour votre registre, sous forme de tableau de mappage de paires clé-valeur.
```
aws glue create-registry --registry-name registryName1 --description description
```
Lorsque votre registre est créé, il se voit attribuer un Amazon Resource Name (ARN), que vous pouvez consulter dans le `RegistryArn` de la réponse de l'API. Maintenant que vous avez créé un registre, créez un ou plusieurs schémas pour ce registre.
**Console AWS Glue **
Pour ajouter un nouveau registre dans la console AWS Glue :
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, sous **Data catalog (Catalogue de données)**, choisissez **Schema registries (Registres de schémas)**.
1. Choisissez **Add registry (Ajouter un registre)**.
1. Saisissez un **nom du registre** à donner au registre, composé de lettres, de chiffres, de traits d'union et de traits de soulignement. Ce nom ne peut pas être modifié.
1. Saisissez une **description** (facultatif) pour le registre.
1. Si vous le souhaitez, appliquez une ou plusieurs balises à votre registre. Choisissez **Add new tag (Ajouter une nouvelle balise)** et spécifiez une **clé de balise**, et éventuellement une **valeur de balise**.
1. Choisissez **Add registry (Ajouter un registre)**.
![\[Exemple de création d'un registre.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/schema_reg_create_registry.png)
Lorsque votre registre est créé, un Amazon Resource Name (ARN) lui est attribué, que vous pouvez consulter en choisissant le registre dans la liste **Schema registries (Registres de schémas)**. Maintenant que vous avez créé un registre, créez un ou plusieurs schémas pour ce registre.
# Traiter un enregistrement spécifique (JAVA POJO) pour JSON
Vous pouvez utiliser un ancien objet Java simple (POJO) et transmettre l'objet en tant qu'enregistrement. Ceci est similaire à la notion d'enregistrement spécifique dans AVRO. Ils [mbknor-jackson-jsonschema](https://github.com/mbknor/mbknor-jackson-jsonSchema)peuvent générer un schéma JSON pour le POJO transmis. Cette bibliothèque peut également injecter des informations supplémentaires dans le schéma JSON.
La bibliothèque de registre de schémas AWS Glue utilise le champ « ClassName » injecté dans le schéma pour fournir un nom de classe entièrement classifié. Le champ « ClassName » est utilisé par le désérialiseur pour désérialiser dans un objet de cette classe.
```
Example class :
@JsonSchemaDescription("This is a car")
@JsonSchemaTitle("Simple Car Schema")
@Builder
@AllArgsConstructor
@EqualsAndHashCode
// Fully qualified class name to be added to an additionally injected property
// called className for deserializer to determine which class to deserialize
// the bytes into
@JsonSchemaInject(
strings = {@JsonSchemaString(path = "className",
value = "com.amazonaws.services.schemaregistry.integrationtests.generators.Car")}
)
// List of annotations to help infer JSON Schema are defined by https://github.com/mbknor/mbknor-jackson-jsonSchema
public class Car {
@JsonProperty(required = true)
private String make;
@JsonProperty(required = true)
private String model;
@JsonSchemaDefault("true")
@JsonProperty
public boolean used;
@JsonSchemaInject(ints = {@JsonSchemaInt(path = "multipleOf", value = 1000)})
@Max(200000)
@JsonProperty
private int miles;
@Min(2000)
@JsonProperty
private int year;
@JsonProperty
private Date purchaseDate;
@JsonProperty
@JsonFormat(shape = JsonFormat.Shape.NUMBER)
private Date listedDate;
@JsonProperty
private String[] owners;
@JsonProperty
private Collection serviceChecks;
// Empty constructor is required by Jackson to deserialize bytes
// into an Object of this class
public Car() {}
}
```
# Création d'un schéma
Vous pouvez créer un schéma à l'aide de la console AWS Glue APIs ou de la AWS Glue console.
**AWS Glue APIs**
Vous pouvez suivre ces étapes pour effectuer cette tâche à l'aide du AWS Glue APIs.
Pour ajouter un nouveau schéma, utilisez l'API [CreateSchema action (Python : créer\$1schéma)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-CreateSchema).
Spécifiez une structure `RegistryId` pour indiquer un registre pour le schéma. Ou, omettez la valeur `RegistryId` pour utiliser le registre par défaut.
Spécifiez une valeur `SchemaName` composée de lettres, de chiffres, de traits d'union et de traits de soulignement, ainsi qu'une valeur `DataFormat` comme **AVRO** ou **JSON**. Une fois la valeur `DataFormat` définie sur un schéma, elle n'est pas modifiable.
Spécifiez un mode `Compatibility` :
+ *Backward (Descendant) (recommandé)* — L'application consommateur peut lire à la fois la version actuelle et précédente.
+ *Backward all (Descendant tout)* — L'application consommateur peut lire les versions actuelles et toutes les versions précédentes.
+ *Forward (Ascendant)* — L'application consommateur peut lire à la fois la version actuelle et la version ultérieure.
+ *Forward all (Ascendant tout)* — L'application consommateur peut lire à la fois les versions actuelles et les versions ultérieures.
+ *Full (Complet)* — Combinaison de Forward (Ascendant) et de Backward (Descendant).
+ *Full all (Complet tout)* — Combinaison de Backward all (Descendant tout) et de Forward all (Ascendant tout).
+ *None (Aucun)* — Aucune vérification de compatibilité n'est effectuée.
+ *Disabled (Désactivé)* — Empêche toute gestion des versions pour ce schéma.
Le cas échéant, spécifiez `Tags` pour votre schéma.
Spécifiez une valeur `SchemaDefinition` pour définir le schéma au format de données Avro, JSON ou Protobuf. Veuillez consulter les exemples.
Pour le format de données Avro :
```
aws glue create-schema --registry-id RegistryName="registryName1" --schema-name testschema --compatibility NONE --data-format AVRO --schema-definition "{\"type\": \"record\", \"name\": \"r1\", \"fields\": [ {\"name\": \"f1\", \"type\": \"int\"}, {\"name\": \"f2\", \"type\": \"string\"} ]}"
```
```
aws glue create-schema --registry-id RegistryArn="arn:aws:glue:us-east-2:901234567890:registry/registryName1" --schema-name testschema --compatibility NONE --data-format AVRO --schema-definition "{\"type\": \"record\", \"name\": \"r1\", \"fields\": [ {\"name\": \"f1\", \"type\": \"int\"}, {\"name\": \"f2\", \"type\": \"string\"} ]}"
```
Pour le format de données JSON :
```
aws glue create-schema --registry-id RegistryName="registryName" --schema-name testSchemaJson --compatibility NONE --data-format JSON --schema-definition "{\"$schema\": \"http://json-schema.org/draft-07/schema#\",\"type\":\"object\",\"properties\":{\"f1\":{\"type\":\"string\"}}}"
```
```
aws glue create-schema --registry-id RegistryArn="arn:aws:glue:us-east-2:901234567890:registry/registryName" --schema-name testSchemaJson --compatibility NONE --data-format JSON --schema-definition "{\"$schema\": \"http://json-schema.org/draft-07/schema#\",\"type\":\"object\",\"properties\":{\"f1\":{\"type\":\"string\"}}}"
```
Pour le format de données Protobuf :
```
aws glue create-schema --registry-id RegistryName="registryName" --schema-name testSchemaProtobuf --compatibility NONE --data-format PROTOBUF --schema-definition "syntax = \"proto2\";package org.test;message Basic { optional int32 basic = 1;}"
```
```
aws glue create-schema --registry-id RegistryArn="arn:aws:glue:us-east-2:901234567890:registry/registryName" --schema-name testSchemaProtobuf --compatibility NONE --data-format PROTOBUF --schema-definition "syntax = \"proto2\";package org.test;message Basic { optional int32 basic = 1;}"
```
**Console AWS Glue **
Pour ajouter un nouveau schéma à l'aide de la console AWS Glue :
1. Connectez-vous à la console AWS de gestion et ouvrez-la à l'AWS Glueadresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue\).
1. Dans le panneau de navigation, sous **Data catalog (Catalogue de données)**, choisissez **Schemas (Schémas)**.
1. Choisissez **Add schema (Ajouter un schéma)**.
1. Saisissez un **nom de schéma**, composé de lettres, de chiffres, de traits d'union, de traits de soulignement, de symboles dollar ou de dièses. Ce nom ne peut pas être modifié.
1. Cliquez sur l'onglet **Registry (Registre)** où le schéma sera stocké à partir du menu déroulant. Le registre parent ne peut pas être modifié après la création.
1. Quitter le **format de données** en tant qu'*Apache Avro* ou *JSON*. Ce format s'applique à toutes les versions de ce schéma.
1. Choisissez un **mode de compatibilité**.
+ *Backward (Descendant) (recommandé)* — Le récepteur peut lire à la fois les versions actuelles et précédentes.
+ *Backward All (Descendant tout)* — Le récepteur peut lire les versions actuelles et toutes les versions précédentes.
+ *Forward (Ascendant)* — L'expéditeur peut écrire à la fois les versions actuelles et précédentes.
+ *Forward all (Ascendant tout)* — L'expéditeur peut écrire la version actuelle et toutes les versions précédentes.
+ *Full (Complet)* — Combinaison de Forward (Ascendant) et de Backward (Descendant).
+ *Full All (Complet tout)* — Combinaison de Backward All (Descendant tout) et de Forward All (Ascendant tout).
+ *None (Aucun)* — Aucune vérification de compatibilité n'est effectuée.
+ *Disabled (Désactivé)* — Empêche toute gestion des versions pour ce schéma.
1. Saisissez une **description** facultative pour le registre de 250 caractères maximum.
![\[Exemple de création d'un schéma.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/schema_reg_create_schema.png)
1. Si vous le souhaitez, appliquez une ou plusieurs balises à votre schéma. Choisissez **Add new tag (Ajouter une nouvelle balise)** et spécifiez une **clé de balise**, et éventuellement une **valeur de balise**.
1. Dans la case **First schema version (Première version de schéma)**, saisissez ou collez votre schéma initial.
Pour le format Avro, voir [Utilisation du format de données Avro](#schema-registry-avro)
Pour le format JSON, voir [Utilisation du format de données JSON](#schema-registry-json)
1. Choisissez éventuellement **Add metadata (Ajouter des métadonnées)** pour ajouter des métadonnées de version afin d'annoter ou de classer votre version de schéma.
1. Choisissez **Create schema and version (Créer un schéma et une version)**.
![\[Exemple de création d'un schéma.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/schema_reg_create_schema2.png)
Le schéma est créé et apparaît dans la liste sous **Schemas (Schémas)**.
## Utilisation du format de données Avro
Avro fournit des services de sérialisation et d'échange de données. Avro stocke la définition des données au format JSON, ce qui la rend facile à lire et à interpréter. Les données elles-mêmes sont stockées au format binaire.
Pour plus d'informations sur la définition d'un schéma Apache Avro, veuillez consulter la [spécification d'Apache Avro](http://avro.apache.org/docs/current/spec.html).
## Utilisation du format de données JSON
Les données peuvent être sérialisées au format JSON. Le [format de schéma JSON](https://json-schema.org/) définit la norme pour le format de schéma JSON.
# Mise à jour d'un schéma ou d'un registre
Une fois créés, vous pouvez modifier vos schémas, vos versions de schéma ou votre registre.
## Mise à jour d'un registre
Vous pouvez mettre à jour un registre à l'aide de la console AWS Glue APIs ou de la AWS Glue console. Le nom d'un registre existant ne peut pas être modifié. Vous pouvez modifier la description d'un registre.
**AWS Glue APIs**
Pour mettre à jour un registre existant, utilisez l'API [UpdateRegistry action (Python : update\$1registry)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-UpdateRegistry).
Spécifiez une structure `RegistryId` pour indiquer le registre que vous souhaitez mettre à jour. Transmettez une `Description` pour modifier la description d'un registre.
```
aws glue update-registry --description updatedDescription --registry-id RegistryArn="arn:aws:glue:us-east-2:901234567890:registry/registryName1"
```
**Console AWS Glue **
Pour mettre à jour un registre à l'aide de la console AWS Glue :
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, sous **Data catalog (Catalogue de données)**, choisissez **Schema registries (Registres de schémas)**.
1. Sélectionnez un registre dans la liste des registres, en cochant sa case.
1. Dans le menu **Action**, choisissez **Edit registry (Modifier un registre)**.
# Mise à jour d'un schéma
Vous pouvez mettre à jour le paramètre de description ou de compatibilité pour un schéma.
Pour mettre à jour un schéma existant, utilisez l'API [UpdateSchema action (Python : update\$1schema)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-UpdateSchema).
Spécifiez une structure `SchemaId` pour indiquer le schéma que vous souhaitez mettre à jour. `VersionNumber` ou `Compatibility` doit être fourni.
Exemple de code 11 :
```
aws glue update-schema --description testDescription --schema-id SchemaName="testSchema1",RegistryName="registryName1" --schema-version-number LatestVersion=true --compatibility NONE
```
```
aws glue update-schema --description testDescription --schema-id SchemaArn="arn:aws:glue:us-east-2:901234567890:schema/registryName1/testSchema1" --schema-version-number LatestVersion=true --compatibility NONE
```
# Ajout d'une version de schéma
Lorsque vous ajoutez une version de schéma, vous devez comparer les versions pour vous assurer que le nouveau schéma sera accepté.
Pour ajouter une nouvelle version à un schéma existant, utilisez l'API [RegisterSchemaVersion action (Python : register\$1schema\$1version)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-RegisterSchemaVersion).
Spécifiez une structure `SchemaId` pour indiquer le schéma pour lequel vous souhaitez ajouter une version, ainsi qu'une valeur `SchemaDefinition` pour définir le schéma.
Exemple de code 12 :
```
aws glue register-schema-version --schema-definition "{\"type\": \"record\", \"name\": \"r1\", \"fields\": [ {\"name\": \"f1\", \"type\": \"int\"}, {\"name\": \"f2\", \"type\": \"string\"} ]}" --schema-id SchemaArn="arn:aws:glue:us-east-1:901234567890:schema/registryName/testschema"
```
```
aws glue register-schema-version --schema-definition "{\"type\": \"record\", \"name\": \"r1\", \"fields\": [ {\"name\": \"f1\", \"type\": \"int\"}, {\"name\": \"f2\", \"type\": \"string\"} ]}" --schema-id SchemaName="testschema",RegistryName="testregistry"
```
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, sous **Data catalog (Catalogue de données)**, choisissez **Schemas (Schémas)**.
1. Sélectionnez le schéma dans la liste des schémas, en cochant sa case.
1. Sélectionnez un ou plusieurs schémas dans la liste, en cochant les cases.
1. Dans le menu **Action**, choisissez **Register new version (Enregistrer une nouvelle version)**.
1. Dans **New version (Nouvelle version)**, saisissez ou collez votre nouveau schéma.
1. Choisissez **Compare with previous version (Comparer avec la version précédente)** pour voir les différences avec la version de schéma précédente.
1. Choisissez éventuellement **Add metadata (Ajouter des métadonnées)** pour ajouter des métadonnées de version afin d'annoter ou de classer votre version de schéma. Saisissez une **clé** et une **valeur** facultative.
1. Choisissez **Register version (Version de registre)**.
![\[Ajout d'une version de schéma.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/schema_reg_add_schema_version.png)
La version du ou des schémas s'affiche dans la liste des versions. Si la version a changé le mode de compatibilité, la version sera marquée comme point de contrôle.
## Exemple de comparaison d'une version de schéma
Lorsque vous choisissez **Compare with previous version (Comparer avec la version précédente)**, vous verrez les versions précédentes et les nouvelles versions affichées ensemble. Les informations modifiées seront mises en évidence comme suit :
+ *Jaune* : indique les informations modifiées.
+ *Vert* : indique le contenu ajouté à la dernière version.
+ *Rouge* : indique le contenu supprimé dans la dernière version.
Vous pouvez également comparer les versions antérieures.
![\[Exemple de comparaison d'une version de schéma.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/schema_reg_version_comparison.png)
# Suppression d'un schéma ou d'un registre
La suppression d'un schéma, d'une version de schéma ou d'un registre est une action permanente qui ne peut pas être annulée.
## Suppression d'un schéma
Vous souhaiterez peut-être supprimer un schéma lorsqu'il ne sera plus utilisé dans un registre, à l'aide de l' AWS Management Console API ou de l'[DeleteSchema action (Python : supprimer\$1schéma)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-DeleteSchema)API.
La suppression d'un ou plusieurs schémas est une action permanente qui ne peut pas être annulée. Assurez-vous que le ou les schémas ne sont plus nécessaires.
Pour supprimer un schéma du registre, appelez l'API [DeleteSchema action (Python : supprimer\$1schéma)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-DeleteSchema), en spécifiant la structure `SchemaId` pour identifier le schéma.
Par exemple :
```
aws glue delete-schema --schema-id SchemaArn="arn:aws:glue:us-east-2:901234567890:schema/registryName1/schemaname"
```
```
aws glue delete-schema --schema-id SchemaName="TestSchema6-deleteschemabyname",RegistryName="default-registry"
```
**Console AWS Glue **
Pour supprimer un schéma de la console AWS Glue :
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, sous **Data catalog (Catalogue de données)**, choisissez **Schema registries (Registres de schémas)**.
1. Choisissez le registre qui contient votre schéma dans la liste des registres.
1. Sélectionnez un ou plusieurs schémas dans la liste, en cochant les cases.
1. Dans le menu **Action**, sélectionnez **Delete schema (Supprimer un schéma)**.
1. Saisissez le texte **Delete** dans le champ pour confirmer la suppression.
1. Choisissez **Delete** (Supprimer).
Le ou les schémas que vous avez spécifiés sont supprimés du registre.
## Suppression d'une version de schéma
Au fur et à mesure que les schémas s'accumulent dans le registre, vous souhaiterez peut-être supprimer les versions de schéma indésirables à l'aide de l' AWS Management Console API ou de l'[DeleteSchemaVersions action (Python : delete\$1schema\$1versions)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-DeleteSchemaVersions)API. La suppression d'une ou de plusieurs versions de schéma est une action permanente qui ne peut pas être annulée. Assurez-vous que les versions de schéma ne sont plus nécessaires.
Lorsque vous supprimez des versions de schéma, veuillez tenir compte des contraintes suivantes :
+ Vous ne pouvez pas supprimer une version comportant un point de contrôle.
+ La gamme de versions contiguës ne peut pas dépasser 25.
+ La version de schéma la plus récente ne doit pas être dans un état en attente.
Spécifiez la structure `SchemaId` pour identifier le schéma et spécifiez `Versions` comme une plage de versions à supprimer. Pour plus d'informations sur la spécification d'une version ou d'une plage de versions, veuillez consulter [DeleteRegistry action (Python : supprimer\$1registre)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-DeleteRegistry). Les versions de schéma que vous avez spécifiées sont supprimées du registre.
En appelant l'API [ListSchemaVersions action (Python : list\$1schema\$1versions)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-ListSchemaVersions) après cet appel, vous obtiendrez la liste de l'état des versions supprimées.
Par exemple :
```
aws glue delete-schema-versions --schema-id SchemaName="TestSchema6",RegistryName="default-registry" --versions "1-1"
```
```
aws glue delete-schema-versions --schema-id SchemaArn="arn:aws:glue:us-east-2:901234567890:schema/default-registry/TestSchema6-NON-Existent" --versions "1-1"
```
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, sous **Data catalog (Catalogue de données)**, choisissez **Schema registries (Registres de schémas)**.
1. Choisissez le registre qui contient votre schéma dans la liste des registres.
1. Sélectionnez un ou plusieurs schémas dans la liste, en cochant les cases.
1. Dans le menu **Action**, sélectionnez **Delete schema (Supprimer un schéma)**.
1. Saisissez le texte **Delete** dans le champ pour confirmer la suppression.
1. Sélectionnez **Delete (Supprimer)**.
Les versions de schéma que vous avez spécifiées sont supprimées du registre.
# Suppression d'un registre
Vous pouvez supprimer un registre lorsque les schémas qu'il contient ne doivent plus être organisés sous ce registre. Vous devrez réaffecter ces schémas à un autre registre.
La suppression d'un ou de plusieurs registres est une action permanente qui ne peut pas être annulée. Assurez-vous que le ou les registres ne sont plus requis.
Le registre par défaut peut être supprimé à l'aide de la AWS CLI.
**API AWS Glue**
Pour supprimer l'intégralité du registre, y compris le schéma et toutes ses versions, appelez l'API [DeleteRegistry action (Python : supprimer\$1registre)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-DeleteRegistry). Spécifiez une structure `RegistryId` pour identifier le registre.
Par exemple :
```
aws glue delete-registry --registry-id RegistryArn="arn:aws:glue:us-east-2:901234567890:registry/registryName1"
```
```
aws glue delete-registry --registry-id RegistryName="TestRegistry-deletebyname"
```
Pour obtenir le statut de l'opération de suppression, vous pouvez appeler l'API `GetRegistry` après l'appel asynchrone.
**Console AWS Glue **
Pour supprimer un registre de la console AWS Glue :
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, sous **Data catalog (Catalogue de données)**, choisissez **Schema registries (Registres de schémas)**.
1. Sélectionnez un registre dans la liste en cochant une case.
1. Dans le menu **Action**, choisissez **Delete registry (Supprimer un registre)**.
1. Saisissez le texte **Delete** dans le champ pour confirmer la suppression.
1. Sélectionnez **Delete (Supprimer)**.
Les registres que vous avez sélectionnés sont supprimés de AWS Glue.
## Exemples d'IAM pour les sérialiseurs
**Note**
AWS les politiques gérées accordent les autorisations nécessaires pour les cas d'utilisation courants. Pour plus d'informations sur l'utilisation des politiques gérées pour gérer le registre de schéma, veuillez consulter [AWS politiques gérées (prédéfinies) pour AWS Glue](security-iam-awsmanpol.md#access-policy-examples-aws-managed).
Pour les sérialiseurs, vous devez créer une politique minimale similaire à celle ci-dessous pour vous donner la possibilité de trouver le `schemaVersionId` pour une définition de schéma donnée. Notez que vous devez disposer des autorisations de lecture sur le registre afin de lire les schémas dans le registre. Vous pouvez limiter les registres qui peuvent être lus à l'aide de la clause `Resource`.
Exemple de code 13 :
```
{
"Sid" : "GetSchemaByDefinition",
"Effect" : "Allow",
"Action" :
[
"glue:GetSchemaByDefinition"
],
"Resource" : ["arn:aws:glue:us-east-2:012345678:registry/registryname-1",
"arn:aws:glue:us-east-2:012345678:schema/registryname-1/schemaname-1",
"arn:aws:glue:us-east-2:012345678:schema/registryname-1/schemaname-2"
]
}
```
En outre, vous pouvez également autoriser les applications producteur à créer des schémas et versions en incluant les méthodes supplémentaires suivantes. Notez que vous devriez être en mesure d'inspecter le registre afin de vérifier add/remove/evolve les schémas qu'il contient. Vous pouvez limiter les registres qui peuvent être inspectés à l'aide de la clause `Resource`.
Exemple de code 14 :
```
{
"Sid" : "RegisterSchemaWithMetadata",
"Effect" : "Allow",
"Action" :
[
"glue:GetSchemaByDefinition",
"glue:CreateSchema",
"glue:RegisterSchemaVersion",
"glue:PutSchemaVersionMetadata",
],
"Resource" : ["arn:aws:glue:aws-region:123456789012:registry/registryname-1",
"arn:aws:glue:aws-region:123456789012:schema/registryname-1/schemaname-1",
"arn:aws:glue:aws-region:123456789012:schema/registryname-1/schemaname-2"
]
}
```
## Exemples d'IAM pour les désérialiseurs
Pour les désérialiseurs (côté application consommateur), vous devez créer une politique similaire à celle ci-dessous pour autoriser le désérialiseur à récupérer le schéma à partir du registre de schéma pour la désérialisation. Notez que vous devriez être en mesure d'inspecter le registre afin d'extraire les schémas qu'il contient.
Exemple de code 15 :
```
{
"Sid" : "GetSchemaVersion",
"Effect" : "Allow",
"Action" :
[
"glue:GetSchemaVersion"
],
"Resource" : ["*"]
}
```
## Connectivité privée à l'aide de AWS PrivateLink
Vous pouvez l'utiliser AWS PrivateLink pour connecter le VPC de votre producteur de données AWS Glue en définissant un point de terminaison VPC d'interface pour. AWS Glue Lorsque vous utilisez un point de terminaison de VPC, la communication entre votre VPC et AWS Glue est gérée au sein du réseau AWS . Pour plus d'informations, veuillez consulter [Utilisation d'AWS Glue avec les points de terminaison d'un VPC](https://docs.aws.amazon.com/glue/latest/dg/vpc-endpoint.html).
# Accès aux CloudWatch métriques d'Amazon
Les CloudWatch statistiques Amazon sont disponibles dans le cadre CloudWatch de l'offre gratuite. Vous pouvez accéder à ces métriques dans la CloudWatch console. Les indicateurs au niveau de l'API incluent CreateSchema (succès et latence) GetSchemaByDefinition, (succès et latence), GetSchemaVersion (succès et latence), RegisterSchemaVersion (succès et latence), PutSchemaVersionMetadata (succès et latence). Les métriques au niveau des ressources incluent le registre. ThrottledByLimit, SchemaVersion. ThrottledByLimit, SchemaVersion .Taille.
# Exemple de CloudFormation modèle pour le registre de schémas
Voici un exemple de modèle pour créer des ressources de registre de schémas dans CloudFormation. Pour créer cette pile dans votre compte, copiez le modèle ci-dessus dans un fichier `SampleTemplate.yaml` et exécutez la commande suivante :
```
aws cloudformation create-stack --stack-name ABCSchemaRegistryStack --template-body "'cat SampleTemplate.yaml'"
```
Cet exemple utilise `AWS::Glue::Registry` pour créer un registre, `AWS::Glue::Schema` pour créer un schéma, `AWS::Glue::SchemaVersion` pour créer une version de schéma et `AWS::Glue::SchemaVersionMetadata` pour renseigner les métadonnées de version de schéma.
```
Description: "A sample CloudFormation template for creating Schema Registry resources."
Resources:
ABCRegistry:
Type: "AWS::Glue::Registry"
Properties:
Name: "ABCSchemaRegistry"
Description: "ABC Corp. Schema Registry"
Tags:
Project: "Foo"
ABCSchema:
Type: "AWS::Glue::Schema"
Properties:
Registry:
Arn: !Ref ABCRegistry
Name: "TestSchema"
Compatibility: "NONE"
DataFormat: "AVRO"
SchemaDefinition: >
{"namespace":"foo.avro","type":"record","name":"user","fields":[{"name":"name","type":"string"},{"name":"favorite_number","type":"int"}]}
Tags:
Project: "Foo"
SecondSchemaVersion:
Type: "AWS::Glue::SchemaVersion"
Properties:
Schema:
SchemaArn: !Ref ABCSchema
SchemaDefinition: >
{"namespace":"foo.avro","type":"record","name":"user","fields":[{"name":"status","type":"string", "default":"ON"}, {"name":"name","type":"string"},{"name":"favorite_number","type":"int"}]}
FirstSchemaVersionMetadata:
Type: "AWS::Glue::SchemaVersionMetadata"
Properties:
SchemaVersionId: !GetAtt ABCSchema.InitialSchemaVersionId
Key: "Application"
Value: "Kinesis"
SecondSchemaVersionMetadata:
Type: "AWS::Glue::SchemaVersionMetadata"
Properties:
SchemaVersionId: !Ref SecondSchemaVersion
Key: "Application"
Value: "Kinesis"
```
# Intégration au registre de schémas AWS Glue
Ces sections décrivent les intégrations au registre de schémas AWS Glue. Les exemples présentés dans cette section montrent un schéma au format de données AVRO. Pour d'autres exemples, notamment des schémas au format de données JSON, consultez les tests d'intégration et les ReadMe informations dans le [référentiel open source du registre des AWS Glue schémas](https://github.com/awslabs/aws-glue-schema-registry).
**Topics**
+ [Cas d'utilisation : connexion du registre de schémas à Amazon MSK ou à Apache Kafka](#schema-registry-integrations-amazon-msk)
+ [Cas d'utilisation : intégration d'Amazon Kinesis Data Streams au registre de schémas AWS Glue](#schema-registry-integrations-kds)
+ [Cas d’utilisation : Service géré Amazon pour Apache Flink](#schema-registry-integrations-kinesis-data-analytics-apache-flink)
+ [Cas d'utilisation : intégration avec AWS Lambda](#schema-registry-integrations-aws-lambda)
+ [Cas d'utilisation : AWS Glue Data Catalog](#schema-registry-integrations-aws-glue-data-catalog)
+ [Cas d'utilisation : streaming AWS Glue](#schema-registry-integrations-aws-glue-streaming)
+ [Cas d'utilisation : Apache Kafka Streams](#schema-registry-integrations-apache-kafka-streams)
## Cas d'utilisation : connexion du registre de schémas à Amazon MSK ou à Apache Kafka
Supposons que vous écrivez des données sur une rubrique Apache Kafka, et que vous pouvez suivre ces étapes pour commencer.
1. Créez un cluster Amazon Managed Streaming pour Apache Kafka (Amazon MSK) ou Apache Kafka avec au moins un sujet. Si vous créez un cluster Amazon MSK, vous pouvez utiliser la AWS Management Console. Suivez les instructions ci-après : [Mise en route avec Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/getting-started.html) dans le *Guide du développeur Amazon Managed Streaming for Apache Kafka*.
1. Suivez l'étape [Installation de SerDe bibliothèques](schema-registry-gs-serde.md) ci-dessus.
1. Pour créer des registres de schéma, des schémas ou des versions de schéma, suivez les instructions sous la section [Démarrage avec le registre de schémas](schema-registry-gs.md) de ce document.
1. Faites en sorte que vos producteurs et consommateurs utilisent le registre des schémas pour écrire et lire des enregistrements sur to/from le sujet Amazon MSK ou Apache Kafka. Des exemples de code producteur et consommateur se trouvent dans [le ReadMe fichier](https://github.com/awslabs/aws-glue-schema-registry/blob/master/README.md) des bibliothèques Serde. La bibliothèque du registre de schémas du producteur sérialisera automatiquement l'enregistrement et décorera l'enregistrement avec un ID de version de schéma.
1. Si le schéma de cet enregistrement a été saisi, ou si l'enregistrement automatique est activé, le schéma aura été enregistré dans le registre de schémas.
1. La lecture de l'application consommateur à partir de la rubrique Amazon MSK ou Apache Kafka, à l'aide de la bibliothèque du registre de schémas AWS Glue, recherche automatiquement le schéma à partir du registre de schémas.
## Cas d'utilisation : intégration d'Amazon Kinesis Data Streams au registre de schémas AWS Glue
Cette intégration nécessite que vous ayez un flux de données Amazon Kinesis existant. Pour plus d'informations, veuillez consulter [Présentation des Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/getting-started.html) dans le *Guide du développeur Amazon Kinesis Data Streams*.
Il existe deux façons d'interagir avec les données d'un flux de données Kinesis.
+ Via les bibliothèques Kinesis Producer Library (KPL) et Kinesis Client Library (KCL) en Java. La prise en charge multilingue n'est pas fournie.
+ Grâce au `PutRecords``PutRecord`, et aux `GetRecords` Kinesis Data APIs Streams disponibles dans le AWS SDK pour Java.
Si vous utilisez actuellement les KPL/KCL bibliothèques, nous vous recommandons de continuer à utiliser cette méthode. Il existe des versions KCL et KPL mises à jour avec le registre de schémas intégré, comme illustré dans les exemples. Sinon, vous pouvez utiliser l'exemple de code pour tirer parti du registre des AWS Glue schémas si vous utilisez APIs directement le KDS.
L'intégration du registre de schémas n'est disponible qu'avec KPL version 0.14.2 ou ultérieure et avec KCL version 2.3 ou ultérieure. L'intégration du registre de schémas avec le format de données JSON est disponible avec KPL version 0.14.8 ou ultérieure et avec KCL version 2.3.6 ou ultérieure.
### Interagir avec les données à l'aide du kit SDK Kinesis V2
Cette section décrit l'interaction avec Kinesis à l'aide du kit SDK Kinesis V2
```
// Example JSON Record, you can construct a AVRO record also
private static final JsonDataWithSchema record = JsonDataWithSchema.builder(schemaString, payloadString);
private static final DataFormat dataFormat = DataFormat.JSON;
//Configurations for Schema Registry
GlueSchemaRegistryConfiguration gsrConfig = new GlueSchemaRegistryConfiguration("us-east-1");
GlueSchemaRegistrySerializer glueSchemaRegistrySerializer =
new GlueSchemaRegistrySerializerImpl(awsCredentialsProvider, gsrConfig);
GlueSchemaRegistryDataFormatSerializer dataFormatSerializer =
new GlueSchemaRegistrySerializerFactory().getInstance(dataFormat, gsrConfig);
Schema gsrSchema =
new Schema(dataFormatSerializer.getSchemaDefinition(record), dataFormat.name(), "MySchema");
byte[] serializedBytes = dataFormatSerializer.serialize(record);
byte[] gsrEncodedBytes = glueSchemaRegistrySerializer.encode(streamName, gsrSchema, serializedBytes);
PutRecordRequest putRecordRequest = PutRecordRequest.builder()
.streamName(streamName)
.partitionKey("partitionKey")
.data(SdkBytes.fromByteArray(gsrEncodedBytes))
.build();
shardId = kinesisClient.putRecord(putRecordRequest)
.get()
.shardId();
GlueSchemaRegistryDeserializer glueSchemaRegistryDeserializer = new GlueSchemaRegistryDeserializerImpl(awsCredentialsProvider, gsrConfig);
GlueSchemaRegistryDataFormatDeserializer gsrDataFormatDeserializer =
glueSchemaRegistryDeserializerFactory.getInstance(dataFormat, gsrConfig);
GetShardIteratorRequest getShardIteratorRequest = GetShardIteratorRequest.builder()
.streamName(streamName)
.shardId(shardId)
.shardIteratorType(ShardIteratorType.TRIM_HORIZON)
.build();
String shardIterator = kinesisClient.getShardIterator(getShardIteratorRequest)
.get()
.shardIterator();
GetRecordsRequest getRecordRequest = GetRecordsRequest.builder()
.shardIterator(shardIterator)
.build();
GetRecordsResponse recordsResponse = kinesisClient.getRecords(getRecordRequest)
.get();
List