Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation 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, Martha
AnyCompany Developer Guide
Stiles, John
Style 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.