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 du format Parquet dans AWS Glue AWS Glue récupère les données des sources et écrit les données sur des cibles stockées et transportées dans différents formats de données. Si vos données sont stockées ou transportées au format de données Parquet, ce document présente les fonctionnalités disponibles pour utiliser vos données dans AWS Glue. AWS Supports à colle au format Parquet. Ce format est un format de données en colonnes, orienté vers la performance. Pour accéder à une présentation du format par l'autorité standard, consultez [Apache Parquet Documentation Overview](https://parquet.apache.org/docs/overview/) (Présentation de la documentation Apache Parquet). Vous pouvez utiliser AWS Glue pour lire des fichiers Parquet depuis Amazon S3 et depuis des sources de streaming, ainsi que pour écrire des fichiers Parquet sur Amazon S3. Vous pouvez lire et écrire des archives `bzip` et `gzip` contenant des fichiers Parquet provenant de S3. Vous configurez le comportement de compression sur [Paramètres de connexion S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) plutôt que dans la configuration décrite sur cette page. Le tableau suivant indique les fonctionnalités courantes de AWS Glue compatibles avec l'option de format Parquet. | Lecture | Écrire | Lecture en streaming | Groupement des petits fichiers | Signets de tâche | | --- | --- | --- | --- | --- | | Pris en charge | Pris en charge | Pris en charge | Non pris en charge | Pris en charge\$1 | \$1 Supporté dans la version 1.0\$1 de AWS Glue ## Exemple : lecture de fichiers ou dossiers Parquet depuis S3 ** Prérequis :** vous aurez besoin des chemins S3 (`s3path`) vers des fichiers ou dossiers Parquet que vous souhaitez lire. **Configuration :** dans vos options de fonction, spécifiez `format="parquet"`. Dans vos `connection_options`, utilisez la clé `paths` pour spécifier votre `s3path`. Vous pouvez configurer la manière dont le lecteur interagit avec S3 dans les `connection_options`. Pour plus de détails, voir Types de connexion et options pour l'ETL dans AWS Glue :[Paramètres de connexion S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Vous pouvez configurer la manière dont le lecteur interprète les fichiers Parquet dans votre `format_options`. Pour plus d'informations, consultez [Parquet Configuration Reference](#aws-glue-programming-etl-format-parquet-reference) (Référence de configuration Parquet). Le script AWS Glue ETL suivant montre le processus de lecture des fichiers ou dossiers Parquet depuis S3 : ------ #### [ Python ] Pour cet exemple, utilisez la méthode [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options). ``` # Example: Read Parquet from S3 from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) spark = glueContext.spark_session dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type = "s3", connection_options = {"paths": ["s3://s3path/"]}, format = "parquet" ) ``` Vous pouvez également l'utiliser DataFrames dans un script (`pyspark.sql.DataFrame`). ``` dataFrame = spark.read.parquet("s3://s3path/") ``` ------ #### [ Scala ] Pour cet exemple, utilisez la méthode [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` // Example: Read Parquet from S3 import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val dynamicFrame = glueContext.getSourceWithFormat( connectionType="s3", format="parquet", options=JsonOptions("""{"paths": ["s3://s3path"]}""") ).getDynamicFrame() } } ``` Vous pouvez également l'utiliser DataFrames dans un script (`org.apache.spark.sql.DataFrame`). ``` spark.read.parquet("s3://s3path/") ``` ------ ## Exemple : écriture de fichiers et dossiers Parquet dans S3 **Prérequis :** Vous aurez besoin d'un initialisé DataFrame (`dataFrame`) ou DynamicFrame (`dynamicFrame`). Vous aurez également besoin de votre chemin de sortie S3, `s3path`. **Configuration :** dans vos options de fonction, spécifiez `format="parquet"`. Dans vos `connection_options`, utilisez la clé `paths` pour spécifier `s3path`. Vous pouvez modifier davantage la manière dont le scripteur interagit avec S3 dans les `connection_options`. Pour plus de détails, voir Types de connexion et options pour l'ETL dans AWS Glue :[Paramètres de connexion S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Vous pouvez configurer la manière dont votre opération écrit le contenu de vos fichiers dans `format_options`. Pour plus d'informations, consultez [Parquet Configuration Reference](#aws-glue-programming-etl-format-parquet-reference) (Référence de configuration Parquet). Le script AWS Glue ETL suivant montre le processus d'écriture de fichiers et de dossiers Parquet dans S3. Nous fournissons un rédacteur de parquet personnalisé avec des optimisations de performances DynamicFrames, grâce à la clé de `useGlueParquetWriter` configuration. Pour déterminer si ce scripteur est adapté à votre charge de travail, consultez [Glue Parquet Writer](#aws-glue-programming-etl-format-glue-parquet-writer) (Scripteur Parquet Glue). ------ #### [ Python ] Pour cet exemple, utilisez la méthode [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options). ``` # Example: Write Parquet to S3 # Consider whether useGlueParquetWriter is right for your workflow. from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) glueContext.write_dynamic_frame.from_options( frame=dynamicFrame, connection_type="s3", format="parquet", connection_options={ "path": "s3://s3path", }, format_options={ # "useGlueParquetWriter": True, }, ) ``` Vous pouvez également l'utiliser DataFrames dans un script (`pyspark.sql.DataFrame`). ``` df.write.parquet("s3://s3path/") ``` ------ #### [ Scala ] Pour cet exemple, utilisez la méthode [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat). ``` // Example: Write Parquet to S3 // Consider whether useGlueParquetWriter is right for your workflow. import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getSinkWithFormat( connectionType="s3", options=JsonOptions("""{"path": "s3://s3path"}"""), format="parquet" ).writeDynamicFrame(dynamicFrame) } } ``` Vous pouvez également l'utiliser DataFrames dans un script (`org.apache.spark.sql.DataFrame`). ``` df.write.parquet("s3://s3path/") ``` ------ ## Référence de configuration Parquet Vous pouvez utiliser ce qui suit `format_options` partout où les bibliothèques AWS Glue le spécifient `format="parquet"` : + `useGlueParquetWriter`— Spécifie l'utilisation d'un rédacteur Parquet personnalisé doté d'optimisations des performances pour DynamicFrame les flux de travail. Pour plus d'informations, consultez [Glue Parquet Writer](#aws-glue-programming-etl-format-glue-parquet-writer) (Scripteur Parquet Glue). + **Type :** Booléen, **Valeur par défaut :**`false` + `compression` – spécifie le codec de compression utilisé. Les valeurs sont entièrement compatibles avec `org.apache.parquet.hadoop.metadata.CompressionCodecName`. + **Type :** Texte énuméré, **Valeur par défaut :** `"snappy"` + Valeurs : `"uncompressed"`, `"snappy"`, `"gzip"`, et `"lzo"` + `blockSize` – spécifie la taille en octets d'un groupe de lignes mis en mémoire. Vous l'utilisez pour régler les performances. La taille doit être divisée exactement en un certain nombre de mégaoctets. + **Type :** Numérique, **Valeur par défaut :**`134217728` + La valeur par défaut est égale à 128 Mo. + `pageSize` – spécifie la taille d'une page en octets. Vous l'utilisez pour régler les performances. Une page est la plus petite unité qui doit être lue entièrement pour accéder à un enregistrement unique. + **Type :** Numérique, **Valeur par défaut :**`1048576` + La valeur par défaut est égale à 1 Mo. **Note** De plus, toutes les options acceptées par le code SparkSQL sous-jacent peuvent être transmises à ce format via le paramètre map `connection_options`. Par exemple, vous pouvez définir une configuration Spark telle que [mergeSchema](https://spark.apache.org/docs/latest/sql-data-sources-parquet.html#schema-merging) pour le dispositif d'écriture AWS Glue Spark pour fusionner le schéma de tous les fichiers. ## Optimisez les performances d'écriture avec AWS Glue Parquet Writer **Note** Le rédacteur AWS Glue Parquet a toujours été accessible via le type de `glueparquet` format. Ce modèle d'accès n'est plus préconisé. Utilisez plutôt le type `parquet` avec `useGlueParquetWriter` activé. Le graveur AWS Glue Parquet présente des améliorations de performances qui permettent d'écrire plus rapidement les fichiers Parquet. Le scripteur traditionnel calcule un schéma avant d'écrire. Le format Parquet ne stocke pas le schéma de manière rapidement récupérable, ce qui peut prendre un certain temps. Avec le rédacteur AWS Glue Parquet, aucun schéma précalculé n'est requis. Au fur et à mesure que les données sont introduites, le scripteur calcule et modifie le schéma de manière dynamique. Notez les limitations suivantes lorsque vous spécifiez `useGlueParquetWriter` : + Le dispositif d'écriture prend uniquement en charge l'évolution du schéma, comme l'ajout ou la suppression de colonnes, mais pas la modification des types de colonnes, par exemple avec `ResolveChoice`. + Le rédacteur ne prend pas en charge l'écriture vide DataFrames, par exemple pour écrire un fichier contenant uniquement des schémas. Lors de l'intégration au catalogue de données AWS Glue via un paramètre`enableUpdateCatalog=True`, toute tentative d'écriture d'un fichier vide ne DataFrame mettra pas à jour le catalogue de données. Cela entraînera la création d’une table sans schéma dans le catalogue de données. Si votre transformation ne nécessite pas ces limitations, l'activation du graveur AWS Glue Parquet devrait améliorer les performances.