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.
# Connexions Amazon S3
Vous pouvez utiliser AWS Glue for Spark pour lire et écrire des fichiers dans Amazon S3. AWS Glue for Spark prend en charge de nombreux formats de données courants stockés dans Amazon S3 prêts à l'emploi, notamment CSV, Avro, JSON, Orc et Parquet. Pour de plus amples informations sur les formats de données pris en charge, consultez [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md). Chaque format de données peut prendre en charge un ensemble différent de fonctionnalités de AWS Glue. Consultez la page de votre format de données pour connaître les spécificités de la prise en charge des fonctionnalités. En outre, vous pouvez lire et écrire des fichiers versionnés stockés dans les cadres de lacs de données Hudi, Iceberg et Delta Lake. Pour plus d'informations sur les cadres de lac de données, consultez [Utilisation de frameworks de lacs de données avec des tâches AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
Avec AWS Glue, vous pouvez partitionner vos objets Amazon S3 dans une structure de dossiers pendant l'écriture, puis les récupérer par partition pour améliorer les performances grâce à une configuration simple. Vous pouvez également définir la configuration pour regrouper les petits fichiers lors de la transformation de vos données afin d'améliorer les performances. Vous pouvez lire et écrire des archives `bzip2` et `gzip` dans Amazon S3.
**Topics**
+ [Configuration de connexions S3](#aws-glue-programming-etl-connect-s3-configure)
+ [Référence des options de connexion Amazon S3](#aws-glue-programming-etl-connect-s3)
+ [Syntaxes de connexion obsolètes pour les formats de données](#aws-glue-programming-etl-connect-legacy-format)
+ [Exclusion des classes de stockage Amazon S3](aws-glue-programming-etl-storage-classes.md)
+ [Gestion des partitions pour la sortie ETL dans AWS Glue](aws-glue-programming-etl-partitions.md)
+ [Lecture des fichiers en entrée dans des groupes de plus grande taille](grouping-input-files.md)
+ [Types de points de terminaison d'un VPC pour Amazon S3](vpc-endpoints-s3.md)
## Configuration de connexions S3
Pour vous connecter à Amazon S3 dans le cadre d'une tâche AWS Glue with Spark, vous aurez besoin de certaines conditions préalables :
+ La tâche AWS Glue doit disposer d'autorisations IAM pour les buckets Amazon S3 concernés.
Dans certains cas, vous devrez configurer des prérequis supplémentaires :
+ Lorsque vous configurez un accès intercompte, il convient de mettre en place des contrôles d'accès appropriés sur le compartiment Amazon S3.
+ Pour des raisons de sécurité, vous pouvez choisir d'acheminer vos requêtes Amazon S3 via un Amazon VPC. Cette approche peut engendrer des problèmes en matière de bande passante et de disponibilité. Pour de plus amples informations, veuillez consulter [Types de points de terminaison d'un VPC pour Amazon S3](vpc-endpoints-s3.md).
## Référence des options de connexion Amazon S3
Désigne une connexion à Amazon S3.
Comme Amazon S3 gère des fichiers plutôt que des tables, en plus de spécifier les propriétés de connexion fournies dans ce document, vous devrez indiquer une configuration supplémentaire concernant votre type de fichier. Vous indiquez ces informations par le biais des options de format de données. Pour plus d'informations sur ces options de format, consultez [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md). Vous pouvez également spécifier ces informations en les intégrant au catalogue de données AWS Glue.
Pour illustrer la distinction entre les options de connexion et les options de format, considérez comment la méthode [create\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options) utilise `connection_type`, `connection_options`, `format` et `format_options`. Cette section traite spécifiquement des paramètres fournis à `connection_options`.
Utilisez les options de connexion suivantes avec `"connectionType": "s3"` :
+ `"paths"` : (obligatoire) une liste de chemins Amazon S3 à lire.
+ `"exclusions"` : (Facultatif) Chaîne contenant une liste JSON des modèles glob de style Unix à exclure. Par exemple, `"[\"**.pdf\"]"` permet d'exclure tous les fichiers PDF. Pour plus d'informations sur la syntaxe glob qui prend en charge AWS Glue, consultez [Inclure et Exclure les modèles](https://docs.aws.amazon.com/glue/latest/dg/define-crawler.html#crawler-data-stores-exclude).
+ `"compressionType"` : ou « `compression` » : (facultatif) spécifie la manière dont les données sont comprimées. Utilisez `"compressionType"` pour les sources Amazon S3 et `"compression"` pour les cibles Amazon S3. Ce n'est généralement pas nécessaire si le fichier de données a une extension standard. Les valeurs possibles sont `"gzip"` et `"bzip2"`). Des formats de compression supplémentaires peuvent être pris en charge pour des formats spécifiques. Pour connaître les spécificités de la prise en charge des fonctionnalités, consultez la page sur le format des données.
+ `"groupFiles"` : (facultatif) le groupement de fichiers est activé par défaut lorsque l'entrée contient plus de 50 000 fichiers. Pour activer le groupement lorsqu'il y a moins de 50 000 fichiers, définissez ce paramètre sur `"inPartition"`. Pour désactiver le groupement lorsqu'il y a plus de 50 000 fichiers, définissez ce paramètre sur `"none"`.
+ `"groupSize"` : (Facultatif) Taille du groupe cible, en octets. La valeur par défaut est calculée en fonction de la dimension des données en entrée et de la dimension de votre cluster. Lorsqu'il y a moins de 50 000 fichiers en entrée, `"groupFiles"` doit être défini sur `"inPartition"` pour que cela prenne effet.
+ `"recurse"` : (Facultatif) Si ce paramètre est défini sur « true », les fichiers sont lus de manière récursive dans tous les sous-répertoires des chemins spécifiés.
+ `"maxBand"` : (facultatif, avancé) cette option permet de contrôler la durée, en millisecondes, au delà de laquelle la liste `s3` est susceptible d'être cohérente. Les fichiers dont l'horodatage de modification se situe dans les dernières `maxBand` millisecondes sont suivis lorsque des `JobBookmarks` sont utilisés pour prendre en compte une cohérence éventuelle Amazon S3. La plupart des utilisateurs n'ont pas besoin de définir cette option. La valeur par défaut est 900 000 millisecondes, soit 15 minutes.
+ `"maxFilesInBand"` : (Facultatif, avancé) Cette option spécifie le nombre maximal de fichiers à enregistrer à partir des dernières `maxBand` secondes. Si ce nombre est dépassé, les fichiers supplémentaires sont ignorés et traités dans l'exécution de tâche suivante. La plupart des utilisateurs n'ont pas besoin de définir cette option.
+ `"isFailFast"` : (facultatif) cette option détermine si une tâche ETL AWS Glue Glue lance des exceptions d'analyse de lecteur. Si elle est définie sur `true`, les tâches échouent rapidement si quatre tentatives de la tâche Spark échouent à analyser correctement les données.
+ `"catalogPartitionPredicate"` : (facultatif) utilisé pour la lecture. Le contenu d'une clause `WHERE` SQL. Utilisé lors de la lecture de tables du catalogue de données comportant un très grand nombre de partitions. Récupère les partitions correspondantes à partir des index du catalogue de données. Utilisé avec `push_down_predicate`, une option sur la méthode [create\$1dynamic\$1frame\$1from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_catalog) (et d'autres méthodes similaires). Pour de plus amples informations, veuillez consulter [Filtrage côté serveur à l'aide de prédicats de partition de catalogue](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-cat-predicates).
+ `"partitionKeys"` : (facultatif) utilisé pour l'écriture. Un tableau de chaînes d'étiquettes de colonnes. AWS Glue partitionnera vos données conformément à cette configuration. Pour de plus amples informations, veuillez consulter [Écriture des partitions](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-writing).
+ `"excludeStorageClasses"` : (facultatif) utilisé pour la lecture. Tableau de chaînes spécifiant les classes de stockage Amazon S3. AWS Glue exclura les objets Amazon S3 en fonction de cette configuration. Pour de plus amples informations, veuillez consulter [Exclusion des classes de stockage Amazon S3](aws-glue-programming-etl-storage-classes.md).
## Syntaxes de connexion obsolètes pour les formats de données
Certains formats de données sont accessibles à l'aide d'une syntaxe de type de connexion spécifique. Cette syntaxe est obsolète. Nous vous recommandons de spécifier vos formats en utilisant le type de connexion `s3` et les options de format fournies dans [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md) à la place.
### « connectionType » : « orc »
Désigne une connexion à des fichiers stockés dans Amazon S3 au format de fichier [Apache Hive Optimized Row Columnar (ORC)](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+ORC).
Utilisez les options de connexion suivantes avec `"connectionType": "orc"` :
+ `paths` : (obligatoire) une liste de chemins Amazon S3 à lire.
+ *(Autres name/value paires d'options)* : Toutes les options supplémentaires, y compris les options de formatage, sont transmises directement au SparkSQL`DataSource`.
### « connectionType » : « parquet »
Désigne une connexion aux fichiers stockés dans Amazon S3 au format de fichier [Apache Parquet](https://parquet.apache.org/docs/).
Utilisez les options de connexion suivantes avec `"connectionType": "parquet"` :
+ `paths` : (obligatoire) une liste de chemins Amazon S3 à lire.
+ *(Autres name/value paires d'options)* : Toutes les options supplémentaires, y compris les options de formatage, sont transmises directement au SparkSQL`DataSource`.
# Exclusion des classes de stockage Amazon S3
Si vous exécutez des tâches ETL AWS Glue qui lisent des fichiers ou des partitions à partir d'Amazon Simple Storage Service (Amazon S3), vous pouvez exclure certains types de classe de stockage Amazon S3.
Les classes de stockage suivantes sont disponibles dans Amazon S3 :
+ `STANDARD` — pour le stockage à usage général des données fréquemment consultées.
+ `INTELLIGENT_TIERING` — pour les données ayant des modèles d'accès inconnus ou variables.
+ `STANDARD_IA` et `ONEZONE_IA` — pour les données à longue durée de vie, mais consultées moins fréquemment.
+ `GLACIER`, `DEEP_ARCHIVE` et `REDUCED_REDUNDANCY` — pour l'archivage à long terme et la conservation numérique.
Pour de plus amples informations, veuillez consulter [Classes de stockage Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html) dans le *Guide du développeur Amazon S3*.
Les exemples de cette section montrent comment exclure les classes de stockage `GLACIER` et `DEEP_ARCHIVE`. Ces classes vous permettent de répertorier les fichiers, mais ne vous permettent pas de les lire, sauf s'ils sont restaurés. (Pour de plus amples informations, veuillez consulter [Restauration d'objets archivés](https://docs.aws.amazon.com/AmazonS3/latest/dev/restoring-objects.html) dans le *Guide du développeur Amazon S3*.)
En utilisant les exclusions de classe de stockage, vous pouvez garantir que vos tâches AWS Glue fonctionnent sur les tables ayant des partitions sur ces niveaux de classe de stockage. Sans exclusion, les tâches qui lisent les données de ces niveaux échouent avec l'erreur suivante : AmazonS3Exception: The operation is not valid for the object's storage class (AmazonS3Exception : l'opération n'est pas valide pour la classe de stockage de l'objet).
Vous pouvez filtrer les classes de stockage Amazon S3 de différentes façons dans AWS Glue.
**Topics**
+ [Exclusion des classes de stockage Amazon S3 lors de la création d'une image dynamique](#aws-glue-programming-etl-storage-classes-dynamic-frame)
+ [Exclusion de classes de stockage Amazon S3 d'une table Data Catalog](#aws-glue-programming-etl-storage-classes-table)
## Exclusion des classes de stockage Amazon S3 lors de la création d'une image dynamique
Pour exclure les classes de stockage Amazon S3 lors de la création d'une image dynamique, utilisez `excludeStorageClasses` dans `additionalOptions`. AWS Glue utilise automatiquement sa propre implémentation de `Lister` Amazon S3 pour répertorier et exclure les fichiers correspondant aux classes de stockage spécifiées.
Les exemples Python et Scala suivants montrent comment exclure les classes de stockage `GLACIER` et `DEEP_ARCHIVE` lors de la création d'une image dynamique.
Exemple Python :
```
glueContext.create_dynamic_frame.from_catalog(
database = "my_database",
tableName = "my_table_name",
redshift_tmp_dir = "",
transformation_ctx = "my_transformation_context",
additional_options = {
"excludeStorageClasses" : ["GLACIER", "DEEP_ARCHIVE"]
}
)
```
Exemple Scala :
```
val* *df = glueContext.getCatalogSource(
nameSpace, tableName, "", "my_transformation_context",
additionalOptions = JsonOptions(
Map("excludeStorageClasses" -> List("GLACIER", "DEEP_ARCHIVE"))
)
).getDynamicFrame()
```
## Exclusion de classes de stockage Amazon S3 d'une table Data Catalog
Vous pouvez spécifier les exclusions de classe de stockage à utiliser par une tâche AWS Glue ETL en tant que paramètre de table dans le catalogue de données AWS Glue. Vous pouvez inclure ce paramètre dans l'`CreateTable`opération à l'aide du AWS Command Line Interface (AWS CLI) ou par programmation à l'aide de l'API. Pour plus d'informations, voir [Structure du tableau](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-Table) et [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html).
Vous pouvez également spécifier des classes de stockage exclues sur la console AWS Glue.
**Pour exclure des classes de stockage Amazon S3 (console)**
1. Connectez-vous à la AWS Glue console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Dans le panneau de navigation de gauche, sélectionnez **Tables**.
1. Choisissez le nom de la table dans la liste, puis choisissez **Modifier la table**.
1. Dans **Propriétés de la table**, ajoutez **excludeStorageClasses** en tant que clé et **[\$1"GLACIER\$1",\$1"DEEP\$1ARCHIVE\$1"]** en tant que valeur.
1. Cliquez sur **Appliquer**.
# Gestion des partitions pour la sortie ETL dans AWS Glue
Le partitionnement est une technique importante technique pour organiser les ensembles de données afin qu'ils puissent être interrogés de manière efficace. Il organise les données en une structure de répertoires hiérarchique fondée sur les valeurs distinctes d'une ou de plusieurs colonnes.
Par exemple, vous pouvez décider de partitionner vos journaux d'application dans Amazon Simple Storage Service (Amazon S3) par date, réparties par année, par mois et par jour. Les fichiers qui correspondent à une seule journée de données sont ensuite placés sous un préfixe, tel que `s3://my_bucket/logs/year=2018/month=01/day=23/`. Les systèmes comme Amazon Athena, Amazon Redshift Spectrum, et maintenant AWS Glue peuvent utiliser ces partitions pour filtrer les données en fonction de la valeur de partition, sans avoir à lire toutes les données sous-jacentes depuis Amazon S3.
Les robots d'exploration ne se contentent pas de déduire les types de fichiers et les schémas, ils identifient également automatiquement la structure de partition de votre ensemble de données lorsqu'ils alimentent le catalogue de données AWS Glue. Les colonnes de partition résultantes sont disponibles pour l'interrogation dans les tâches ETL AWS Glue ou les moteurs de requête tels qu'Amazon Athena.
Après avoir analysé une table, vous pouvez afficher les partitions créées par l'crawler. Dans la console AWS Glue, dans le panneau de navigation de gauche, sélectionnez **Tables**. Sélectionnez la table créée par l'crawler, puis **View partitions** (Afficher les partitions).
Pour les chemins partitionnés de style Apache Hive de type `key=val`, les crawlers remplissent automatiquement le nom de la colonne à l'aide du nom de clé. Sinon, ils utilisent des noms par défaut comme `partition_0`, `partition_1`, etc. Vous pouvez modifier les noms par défaut sur la console. Pour ce faire, accédez à la table. Vérifiez si des index existent sous l'onglet **Index**. Si tel est le cas, vous devez les supprimer pour continuer (vous pourrez ensuite les recréer en utilisant les nouveaux noms de colonnes). Choisissez ensuite **Modifier le schéma** et modifiez les noms des colonnes de partition qui s'y trouvent.
Dans vos scripts ETL, vous pouvez ensuite filtrer sur les colonnes de partition. Étant donné que les informations de partition sont stockées dans le catalogue de données, utilisez les appels d'API `from_catalog` pour inclure les colonnes de partition dans le fichier `DynamicFrame`. Par exemple, utilisez `create_dynamic_frame.from_catalog` plutôt que `create_dynamic_frame.from_options`.
Le partitionnement est une technique d'optimisation qui réduit l'analyse des données. Pour plus d'informations sur le processus permettant d'identifier le moment où cette technique est appropriée, consultez la section [Réduire la quantité de données analysées dans le guide](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/reduce-data-scan.html) des *meilleures pratiques pour le réglage des performances de AWS Glue pour les tâches Apache Spark* sur le guide AWS prescriptif.
## Préfiltrage à l'aide des prédicats pushdown
Dans de nombreux cas, vous pouvez utiliser un prédicat pushdown pour filtrer les partitions sans avoir à répertorier et à lire tous les fichiers de votre ensemble de données. Au lieu de lire l'ensemble de données et de filtrer ensuite un DynamicFrame fichier, vous pouvez appliquer le filtre directement sur les métadonnées de partition dans le catalogue de données. Ensuite, vous ne listez et ne lisez que ce dont vous avez réellement besoin dans un DynamicFrame.
Par exemple, en Python, vous pouvez écrire ce qui suit.
```
glue_context.create_dynamic_frame.from_catalog(
database = "my_S3_data_set",
table_name = "catalog_data_table",
push_down_predicate = my_partition_predicate)
```
Cela crée un DynamicFrame qui charge uniquement les partitions du catalogue de données qui répondent à l'expression de prédicat. En fonction de la taille d'un sous-ensemble de vos données de chargement, vous pouvez économiser beaucoup de temps de traitement.
L'expression de prédicat peut être n'importe quelle expression booléenne prise en charge par Spark SQL. Tout ce que vous pouvez placer dans une clause `WHERE` d'une requête SQL Spark fonctionne. Par exemple, l'expression de prédicat `pushDownPredicate = "(year=='2017' and month=='04')"` charge uniquement les partitions dans Data Catalog qui disposent à la fois d'une `year` égale à 2017 et un `month` égal à 04. Pour plus d'informations, consultez la documentation [Apache Spark SQL](https://spark.apache.org/docs/2.1.1/sql-programming-guide.html), en particulier le document [Référence des fonctions Scala SQL](https://spark.apache.org/docs/2.1.1/api/scala/index.html#org.apache.spark.sql.functions$).
## Filtrage côté serveur à l'aide de prédicats de partition de catalogue
L'option `push_down_predicate` est appliquée après avoir répertorié toutes les partitions du catalogue et avant de répertorier les fichiers d'Amazon S3 pour ces partitions. Si vous disposez d'un grand nombre de partitions pour une table, la liste des partitions du catalogue peut encore entraîner une surcharge de temps supplémentaire. Pour remédier à cette surcharge, vous pouvez utiliser l'élagage des partitions côté serveur avec l'`catalogPartitionPredicate`option qui utilise les [index de partition dans](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html) le catalogue de données Glue AWS . Cela accélère considérablement le filtrage des partitions lorsque vous avez des millions de partitions dans une table. Vous pouvez utiliser à la fois `push_down_predicate` et `catalogPartitionPredicate` dans `additional_options` si votre `catalogPartitionPredicate` a besoin d'une syntaxe de prédicat qui n'est pas encore prise en charge avec les index de partition de catalogue.
Python :
```
dynamic_frame = glueContext.create_dynamic_frame.from_catalog(
database=dbname,
table_name=tablename,
transformation_ctx="datasource0",
push_down_predicate="day>=10 and customer_id like '10%'",
additional_options={"catalogPartitionPredicate":"year='2021' and month='06'"}
)
```
Scala :
```
val dynamicFrame = glueContext.getCatalogSource(
database = dbname,
tableName = tablename,
transformationContext = "datasource0",
pushDownPredicate="day>=10 and customer_id like '10%'",
additionalOptions = JsonOptions("""{
"catalogPartitionPredicate": "year='2021' and month='06'"}""")
).getDynamicFrame()
```
**Note**
`push_down_predicate` et `catalogPartitionPredicate` utilisent des syntaxes différentes. Le premier utilise la syntaxe standard SQL Spark et le dernier utilise l'analyseur JSQL.
## Écriture des partitions
Par défaut, a n' DynamicFrame est pas partitionné lors de son écriture. Tous les fichiers de sortie sont écrits au niveau supérieur du chemin de sortie spécifié. Jusqu'à récemment, le seul moyen d'écrire un DynamicFrame dans des partitions était de le convertir en SQL Spark DataFrame avant de l'écrire.
Cependant, vous pouvez DynamicFrames désormais prendre en charge le partitionnement natif à l'aide d'une séquence de clés, en utilisant l'`partitionKeys`option lorsque vous créez un récepteur. Par exemple, le code Python suivant écrit un ensemble de données sur Amazon S3 au format Parquet, dans les répertoires partitionnés par le type de champ. À partir de là, vous pouvez traiter ces partitions à l'aide d'autres systèmes, comme Amazon Athena.
```
glue_context.write_dynamic_frame.from_options(
frame = projectedEvents,
connection_type = "s3",
connection_options = {"path": "$outpath", "partitionKeys": ["type"]},
format = "parquet")
```
# Lecture des fichiers en entrée dans des groupes de plus grande taille
Vous pouvez définir les propriétés de vos tables pour activer une tâche ETL AWS Glue regroupant les fichiers lorsqu'ils sont lus à partir d'un magasin de données Amazon S3. Ces propriétés permettent à chaque tâche ETL de lire un groupe de fichiers d'entrée en une seule partition en mémoire, ce qui est particulièrement utile lorsqu'il y a un grand nombre de petits fichiers dans votre magasin de données Amazon S3. Lorsque vous définissez certaines propriétés, vous demandez à AWS Glue de regrouper les fichiers au sein d'une partition de données Amazon S3 et de définir la taille des groupes à lire. Vous pouvez également définir ces options lors de la lecture à partir d'un magasin de données Amazon S3 avec la méthode `create_dynamic_frame.from_options`.
Pour activer le regroupement de fichiers pour une table, vous définissez les paires clé-valeur dans le champ des paramètres de la structure de votre table. Utilisez la notation JSON pour définir une valeur pour le champ des paramètres de votre table. Pour plus d'informations sur la modification des propriétés d'une table, consultez [Affichage et gestion des détails d’une table](tables-described.md#console-tables-details).
Vous pouvez utiliser cette méthode pour activer le regroupement des tables dans Data Calalog avec les magasins de données Amazon S3.
**groupFiles**
Définissez **groupFiles** sur `inPartition` afin d'activer le regroupement de fichiers au sein d'une partition de données Amazon S3. AWS Glue active automatiquement le regroupement s'il y a plus de 50 000 fichiers d'entrée, comme dans l'exemple suivant.
```
'groupFiles': 'inPartition'
```
**groupSize**
Définissez **groupSize** sur la taille cible des groupes en octets. La propriété **groupSize** est facultative. Si aucune valeur n'est définie, AWS Glue calcule une taille pour utiliser tous les cœurs d'UC dans le cluster tout en réduisant le nombre total de tâches ETL et les partitions en mémoire.
Par exemple, ce qui suit définit une taille de groupe de 1 Mo.
```
'groupSize': '1048576'
```
Notez que le `groupsize` doit être défini avec le résultat d'un calcul. Par exemple, 1024 \$1 1024 = 1048576.
**recurse**
Définissez **recurse (récursif)** à `True` pour lire les fichiers de manière récursive dans tous les sous-répertoires lorsque vous spécifiez `paths` en tant que liste de chemins. Vous n'avez pas besoin de définir **recurse** si `paths` est un tableau de clés d'objet dans Amazon S3, ou si le format d'entrée est parquet/orc, comme dans l'exemple suivant.
```
'recurse':True
```
Si vous lisez à partir d'Amazon S3 directement à l'aide de la méthode `create_dynamic_frame.from_options`, ajoutez ces options de connexion. Par exemple, ce qui suit tente de placer les fichiers par groupes de 1 Mo.
```
df = glueContext.create_dynamic_frame.from_options("s3", {'paths': ["s3://s3path/"], 'recurse':True, 'groupFiles': 'inPartition', 'groupSize': '1048576'}, format="json")
```
**Note**
`groupFiles`est pris en charge pour les formats de données DynamicFrames créés à partir des formats de données suivants : csv, ion, GrokLog, json et xml. Cette option n'est pas prise en charge pour avro, parquet et orc.
# Types de points de terminaison d'un VPC pour Amazon S3
Pour des raisons de sécurité, de nombreux AWS clients exécutent leurs applications dans un environnement Amazon Virtual Private Cloud (Amazon VPC). Avec Amazon VPC, vous pouvez lancer des EC2 instances Amazon dans un cloud privé virtuel, qui est logiquement isolé des autres réseaux, y compris de l'Internet public. Avec un VPC Amazon, vous contrôlez sa plage d’adresses IP, ses sous-réseaux, ses tables de routage, ses passerelles réseau et ses paramètres de sécurité.
**Note**
Si vous avez créé votre AWS compte après le 04/12/2013, vous disposez déjà d'un VPC par défaut dans chaque région. AWS Vous pouvez commencer immédiatement à utiliser votre VPC par défaut sans configuration supplémentaire.
Pour plus d'informations, veuillez consulter [Vos VPC et sous-réseaux par défaut](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html) dans le Guide de l'utilisateur Amazon VPC.
De nombreux clients ont des préoccupations légitimes liées à la confidentialité et la sécurité lors de l’envoi et de la réception de données via le réseau Internet public. Les clients peuvent faire face à ces préoccupations en utilisant un réseau VPN pour acheminer l'ensemble du trafic réseau d'Amazon S3 via leur propre infrastructure réseau d'entreprise. Toutefois, cette approche peut engendrer des problèmes en matière de bande passante et de disponibilité.
Les points de terminaison d'un VPC pour Amazon S3 peuvent atténuer ces problèmes. Un point de terminaison d'un VPC pour Amazon S3 permet à AWS Glue d'utiliser des adresses IP privées pour accéder à Amazon S3 sans exposition au réseau Internet public. AWS Glue ne nécessite pas d'adresses IP publiques et vous n'avez pas besoin de passerelle Internet, de périphérique NAT ou de passerelle réseau privé virtuel dans votre VPC. Vous utilisez des politiques de point de terminaison pour contrôler l'accès à Amazon S3. Le trafic entre votre VPC et le AWS service ne quitte pas le réseau Amazon.
Lorsque vous créez un point de terminaison d'un VPC pour Amazon S3, toutes les demandes envoyées à un point de terminaison Amazon S3 au sein de la région (par exemple, *s3.us-west-2.amazonaws.com*) sont acheminées vers un point de terminaison Amazon S3 privé dans le réseau Amazon. Vous n'avez pas besoin de modifier vos applications exécutées sur les EC2 instances Amazon de votre VPC : le nom du point de terminaison reste le même, mais le chemin vers Amazon S3 reste entièrement au sein du réseau Amazon et n'accède pas à l'Internet public.
Pour plus d'informations sur les points de terminaison d'un VPC, veuillez consulter [Points de terminaison d'un VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html) dans le Guide de l'utilisateur Amazon VPC.
Le diagramme suivant montre comment AWS Glue peut utiliser un point de terminaison d'un VPC pour accéder à Amazon S3.
![\[Flux de trafic réseau montrant une connexion VPC vers Amazon S3.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/PopulateCatalog-vpc-endpoint.png)
**Pour configurer l'accès à Amazon S3**
1. Connectez-vous à la console Amazon VPC AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)
1. Dans le panneau de navigation de gauche, sélectionnez **Points de terminaison**.
1. Sélectionnez **Create Endpoint (Créer un point de terminaison)** et suivez les étapes pour créer un point de terminaison d'un VPC Amazon S3 de type Passerelle.