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. # Options de format pour les entrées et sorties dans AWS Glue pour Spark Ces pages fournissent des informations sur la prise en charge des fonctionnalités et les paramètres de configuration pour les formats de données pris en charge par AWS Glue pour Spark. Reportez-vous à la section suivante pour une description de l'utilisation et de l'applicabilité de ces informations. ## Prise en charge des fonctionnalités de tous les formats de données dans AWS Glue Chaque format de données peut prendre en charge différentes fonctionnalités AWS de Glue. Les fonctionnalités communes suivantes peuvent être prises en charge ou non en fonction de votre type de format. Reportez-vous à la documentation de votre format de données pour comprendre comment tirer parti de nos caractéristiques pour répondre à vos besoins. | | | | --- |--- | | Lecture | AWS Glue peut reconnaître et interpréter ce format de données sans ressources supplémentaires, telles que des connecteurs. | | Écrire | AWS Glue peut écrire des données dans ce format sans ressources supplémentaires. Vous pouvez inclure des bibliothèques tierces dans votre travail et utiliser les fonctions standard d'Apache Spark pour écrire des données, comme vous le feriez dans d'autres environnements Spark. Pour plus d'informations sur ces bibliothèques, consultez [Utiliser les bibliothèques Python avec AWS Glue](aws-glue-programming-python-libraries.md). | | Lecture en streaming | AWS Glue peut reconnaître et interpréter ce format de données à partir d'un flux de messages Apache Kafka, Amazon Managed Streaming for Apache Kafka ou Amazon Kinesis. Nous nous attendons à ce que les flux présentent les données dans un format cohérent, afin qu'elles soient lues comme DataFrames. | | Groupement des petits fichiers | AWS Glue peut regrouper des fichiers pour créer un travail par lots envoyé à chaque nœud lors de transformations avec AWS Glue. Cela peut améliorer considérablement les performances pour les charges de travail impliquant de grandes quantités de petits fichiers. Pour de plus amples informations, veuillez consulter [Lecture des fichiers en entrée dans des groupes de plus grande taille](grouping-input-files.md). | | Signets de tâche | AWS Glue peut suivre la progression des transformations effectuant le même travail sur le même jeu de données d'une exécution à l'autre à l'aide de signets de tâches. Cela peut améliorer les performances des charges de travail impliquant des jeux de données pour lesquels le travail doit uniquement être effectué sur les nouvelles données depuis la dernière exécution de la tâche. Pour de plus amples informations, veuillez consulter [Suivi des données traitées à l'aide de signets de tâche](monitor-continuations.md). | ## Paramètres utilisés pour interagir avec les formats de données dans AWS Glue Certains types de connexion AWS Glue prennent en charge plusieurs `format` types, ce qui vous oblige à spécifier des informations sur le format de vos données avec un `format_options` objet lorsque vous utilisez des méthodes telles que`GlueContext.write_dynamic_frame.from_options`. + `s3`— Pour plus d'informations, consultez 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 également afficher la documentation des méthodes facilitant ce type de connexion :[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) et [write\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options) en Python et dans les méthodes Scala correspondantes [getSourceWithFormat def](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat) et [getSinkWithFormat def](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat). + `kinesis`— Pour plus d'informations, consultez Types de connexion et options pour l'ETL dans AWS Glue :[Paramètres de connexion Kinesis](aws-glue-programming-etl-connect-kinesis-home.md#aws-glue-programming-etl-connect-kinesis). Vous pouvez également afficher la documentation de la méthode facilitant ce type de connexion :[create\$1data\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-options) et la méthode Scala correspondante [def createDataFrame FromOptions](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-createDataFrameFromOptions). + `kafka`— Pour plus d'informations, consultez Types de connexion et options pour l'ETL dans AWS Glue :[Paramètres de connexion de Kafka](aws-glue-programming-etl-connect-kafka-home.md#aws-glue-programming-etl-connect-kafka). Vous pouvez également afficher la documentation de la méthode facilitant ce type de connexion :[create\$1data\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-options) et la méthode Scala correspondante [def createDataFrame FromOptions](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-createDataFrameFromOptions). Certains types de connexion ne nécessitent pas`format_options`. Par exemple, dans le cadre d'une utilisation normale, une connexion JDBC à une base de données relationnelle récupère les données dans un format de données tabulaire cohérent. Par conséquent, la lecture à partir d'une connexion JDBC ne nécessiterait pas `format_options`. Certaines méthodes pour lire et écrire des données dans de la colle ne nécessitent pas`format_options`. Par exemple, en utilisant `GlueContext.create_dynamic_frame.from_catalog` les crawlers AWS Glue. Les robots d'exploration déterminent la forme de vos données. Lorsque vous utilisez des robots d'exploration, un classificateur AWS Glue examinera vos données afin de prendre des décisions éclairées quant à la manière de représenter le format de vos données. Il stockera ensuite une représentation de vos données dans le catalogue de données AWS Glue, qui peut être utilisé dans un script AWS Glue ETL pour récupérer vos données avec la `GlueContext.create_dynamic_frame.from_catalog` méthode. Les robots d'exploration éliminent la nécessité de spécifier manuellement des informations sur le format de vos données. Pour les tâches qui accèdent aux tables AWS Lake Formation gouvernées, AWS Glue prend en charge la lecture et l'écriture dans tous les formats pris en charge par les tables régies par Lake Formation. Pour consulter la liste actuelle des formats pris en charge pour les tables AWS Lake Formation gouvernées, consultez la section [Remarques et restrictions relatives aux tables gouvernées](https://docs.aws.amazon.com/lake-formation/latest/dg/governed-table-restrictions.html) dans le *guide du AWS Lake Formation développeur*. **Note** Pour écrire Apache Parquet, AWS Glue ETL prend uniquement en charge l'écriture dans une table régie en spécifiant une option pour un type de dispositif d'écriture Parquet personnalisé optimisé pour les cadres dynamiques. Lorsque vous écrivez sur une table régie avec le format `parquet`, vous devez ajouter la clé `useGlueParquetWriter` avec une valeur de `true` dans les paramètres de la table. **Topics** + [Prise en charge des fonctionnalités de tous les formats de données dans AWS Glue](#aws-glue-programming-etl-format-features) + [Paramètres utilisés pour interagir avec les formats de données dans AWS Glue](#aws-glue-programming-etl-format-parameters) + [Utilisation du format CSV dans AWS Glue](aws-glue-programming-etl-format-csv-home.md) + [Utilisation du format Parquet dans AWS Glue](aws-glue-programming-etl-format-parquet-home.md) + [Utilisation du format XML dans AWS Glue](aws-glue-programming-etl-format-xml-home.md) + [Utilisation du format Avro dans Glue AWS](aws-glue-programming-etl-format-avro-home.md) + [Utilisation du format GrokLog dans Glue AWS](aws-glue-programming-etl-format-grokLog-home.md) + [Utilisation du format Ion dans AWS Glue](aws-glue-programming-etl-format-ion-home.md) + [Utilisation du format JSON dans AWS Glue](aws-glue-programming-etl-format-json-home.md) + [Utilisation du format ORC dans Glue AWS](aws-glue-programming-etl-format-orc-home.md) + [Utilisation de frameworks de lacs de données avec des tâches AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md) + [Référence de configuration partagée](#aws-glue-programming-etl-format-shared-reference) # Utilisation du format CSV 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 CSV, ce document présente les fonctionnalités disponibles pour utiliser vos données dans AWS Glue. AWS Glue prend en charge l'utilisation du format CSV (valeurs séparées par des virgules). Il s'agit d'un format de données minimal basé sur des lignes. CSVs ne sont souvent pas strictement conformes à une norme, mais vous pouvez vous référer aux [RFC 4180 et RFC](https://tools.ietf.org/html/rfc4180) [7111](https://tools.ietf.org/html/rfc7111) pour plus d'informations. Vous pouvez utiliser AWS Glue pour lire CSVs depuis Amazon S3 et depuis des sources de streaming, ainsi que CSVs pour écrire sur Amazon S3. Vous pouvez lire et écrire des archives `bzip` et `gzip` contenant des fichiers CSV 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 CSV. | Lecture | Écrire | Lecture en streaming | Groupement des petits fichiers | Signets de tâche | | --- | --- | --- | --- | --- | | Pris en charge | Pris en charge | Pris en charge | Pris en charge | Pris en charge | ## Exemple : lecture de fichiers ou de dossiers CSV depuis S3 **Prérequis :** vous aurez besoin des chemins S3 (`s3path`) vers des fichiers ou dossiers CSV que vous souhaitez lire. **Configuration :** dans vos options de fonction, spécifiez `format="csv"`. Dans vos `connection_options`, utilisez la clé `paths` pour spécifier `s3path`. Vous pouvez configurer la manière dont le lecteur interagit avec S3 dans `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 CSV dans votre `format_options`. Pour plus d'informations, consultez [CSV Configuration Reference](#aws-glue-programming-etl-format-csv-reference) (Référence de configuration CSV). Le script AWS Glue ETL suivant montre le processus de lecture de fichiers ou de dossiers CSV à partir de S3. Nous fournissons un lecteur CSV personnalisé avec des optimisations de performances pour les flux de travail courants à travers la clé de configuration `optimizePerformance`. Pour déterminer si ce lecteur est adapté à votre charge de travail, consultez [Optimiser les performances de lecture avec un lecteur CSV SIMD vectorisé](#aws-glue-programming-etl-format-simd-csv-reader). ------ #### [ 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 CSV from S3 # For show, we handle a CSV with a header row. Set the withHeader option. # Consider whether optimizePerformance is right for your workflow. 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="csv", format_options={ "withHeader": True, # "optimizePerformance": True, }, ) ``` Vous pouvez également l'utiliser DataFrames dans un script (`pyspark.sql.DataFrame`). ``` dataFrame = spark.read\ .format("csv")\ .option("header", "true")\ .load("s3://s3path") ``` ------ #### [ Scala ] Pour cet exemple, utilisez l'opération [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` // Example: Read CSV from S3 // For show, we handle a CSV with a header row. Set the withHeader option. // Consider whether optimizePerformance 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) val dynamicFrame = glueContext.getSourceWithFormat( formatOptions=JsonOptions("""{"withHeader": true}"""), connectionType="s3", format="csv", options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""") ).getDynamicFrame() } } ``` Vous pouvez également l'utiliser DataFrames dans un script (`org.apache.spark.sql.DataFrame`). ``` val dataFrame = spark.read .option("header","true") .format("csv") .load("s3://s3path“) ``` ------ ## Exemple : écriture de fichiers et dossiers CSV dans S3 **Prérequis :** Vous aurez besoin d'un initialisé DataFrame (`dataFrame`) ou d'un DynamicFrame (`dynamicFrame`). Vous aurez également besoin de votre chemin de sortie S3, `s3path`. **Configuration :** dans vos options de fonction, spécifiez `format="csv"`. Dans vos `connection_options`, utilisez la clé `paths` pour spécifier `s3path`. Vous pouvez configurer la manière dont le scripteur interagit avec S3 dans `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 [CSV Configuration Reference](#aws-glue-programming-etl-format-csv-reference) (Référence de configuration CSV). Le script ETL AWS Glue suivant montre le processus d'écriture de fichiers et dossiers CSV vers S3. ------ #### [ 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 CSV to S3 # For show, customize how we write string type values. Set quoteChar to -1 so our values are not quoted. 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", connection_options={"path": "s3://s3path"}, format="csv", format_options={ "quoteChar": -1, }, ) ``` Vous pouvez également l'utiliser DataFrames dans un script (`pyspark.sql.DataFrame`). ``` dataFrame.write\ .format("csv")\ .option("quote", None)\ .mode("append")\ .save("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 CSV to S3 // For show, customize how we write string type values. Set quoteChar to -1 so our values are not quoted. 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="csv" ).writeDynamicFrame(dynamicFrame) } } ``` Vous pouvez également l'utiliser DataFrames dans un script (`org.apache.spark.sql.DataFrame`). ``` dataFrame.write .format("csv") .option("quote", null) .mode("Append") .save("s3://s3path") ``` ------ ## Référence de configuration CSV Vous pouvez utiliser ce qui suit `format_options` partout où les bibliothèques AWS Glue le spécifient `format="csv"` : + `separator` – spécifie le caractère délimiteur. La valeur par défaut est une virgule, mais tout autre caractère peut être spécifié. + **Type :** texte, **Valeur par défaut :** `","` + `escaper` – spécifie le caractère à utiliser pour l'échappement. Cette option est utilisée uniquement lors de la lecture de fichiers CSV, pas l'écriture. Si cette option est activée, le caractère qui suit immédiatement est utilisé tel quel, sauf pour un petit ensemble d'échappements connus (`\n`, `\r`, `\t` et `\0`). + **Type :** texte, **Valeur par défaut :** aucune + `quoteChar` – spécifie le caractère à utiliser pour les guillemets. La valeur par défaut est les guillemets doubles. Définissez ce champ sur `-1` pour désactiver entièrement les guillemets. + **Type :** texte, **Valeur par défaut :** `'"'` + `multiLine` – spécifie si un même enregistrement peut couvrir plusieurs lignes. Cela peut se produire lorsqu’un champ contient un caractère de nouvelle ligne. Vous devez définir cette option sur `True` si aucun enregistrement ne s’étend sur plusieurs lignes. L'activation de `multiLine` peut réduire les performances, car elle nécessite un fractionnement plus prudent des fichiers lors de l'analyse. + **Type :** Booléen, **Valeur par défaut :** `false` + `withHeader` – spécifie spécifie s'il convient de traiter la première ligne comme un en-tête. Cette option peut être utilisée dans la classe `DynamicFrameReader`. + **Type :** Booléen, **Valeur par défaut :** `false` + `writeHeader` – spécifie s'il convient d'écrire l'en-tête dans la sortie. Cette option peut être utilisée dans la classe `DynamicFrameWriter`. + **Type :** Booléen, **Valeur par défaut :** `true` + `skipFirst` – spécifie s'il convient d'ignorer la première ligne de données. + **Type :** Booléen, **Valeur par défaut :** `false` + `optimizePerformance` –spécifie s'il faut utiliser le lecteur CSV SIMD avancé avec les formats de mémoire en colonnes basés sur Apache Arrow. Disponible uniquement dans les versions 3.0 et ultérieures d'AWS Glue. + **Type :** Booléen, **Valeur par défaut :** `false` + `strictCheckForQuoting`— Lors de l'écriture CSVs, Glue peut ajouter des guillemets aux valeurs qu'elle interprète comme des chaînes. Cela est fait pour éviter toute ambiguïté dans ce qui est écrit. Pour gagner du temps au moment de décider quoi écrire, Glue peut ajouter des guillemets dans certaines situations où ils ne sont pas nécessaires. L'activation d'une vérification stricte effectuera un calcul plus intensif et n'ajoutera de guillemets qu'en cas de nécessité absolue. Disponible uniquement dans les versions 3.0 et ultérieures d'AWS Glue. + **Type :** Booléen, **Valeur par défaut :** `false` ## Optimiser les performances de lecture avec un lecteur CSV SIMD vectorisé La version 3.0 d'AWS Glue ajoute un lecteur CSV optimisé qui peut considérablement accélérer les performances globales des tâches par rapport aux lecteurs CSV basés sur des lignes. Le lecteur optimisé : + utilise les instructions SIMD du processeur pour lire sur le disque + ecrit immédiatement les enregistrements en mémoire dans un format en colonnes (Apache Arrow) + divise les enregistrements en lots Cette méthode permet de gagner du temps de traitement lorsque les enregistrements sont ultérieurement regroupés ou convertis en format en colonnes. Certains exemples concernent la modification de schémas ou la récupération de données par colonne. Pour utiliser le lecteur optimisé, définissez `"optimizePerformance"` sur `true` dans le `format_options` ou la propriété table. ``` glueContext.create_dynamic_frame.from_options( frame = datasource1, connection_type = "s3", connection_options = {"paths": ["s3://s3path"]}, format = "csv", format_options={ "optimizePerformance": True, "separator": "," }, transformation_ctx = "datasink2") ``` **Limitations du lecteur CSV vectorisé** Notez les limitations suivantes du lecteur CSV vectorisé : + Il ne prend pas en charge les options de formatage `multiLine` et `escaper`. Il utilise la valeur par défaut `escaper` du caractère guillemets doubles `'"'`. Lorsque ces options sont définies, AWS Glue revient automatiquement à l'utilisation du lecteur CSV basé sur les lignes. + Il ne prend pas en charge la création d'un DynamicFrame avec [ChoiceType](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-pyspark-extensions-types.html#aws-glue-api-crawler-pyspark-extensions-types-awsglue-choicetype). + Il ne prend pas en charge la création d'un DynamicFrame avec des [enregistrements d'erreur](https://docs.aws.amazon.com/glue/latest/dg/glue-etl-scala-apis-glue-dynamicframe-class.html#glue-etl-scala-apis-glue-dynamicframe-class-defs-errorsAsDynamicFrame). + Il ne prend pas en charge la lecture de fichiers CSV contenant des caractères multioctets tels que des caractères japonais ou chinois. # 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. # Utilisation du format XML 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 XML, ce document présente les fonctionnalités disponibles pour utiliser vos données dans AWS Glue. AWS Glue prend en charge l'utilisation du format XML. Ce format représente des structures de données hautement configurables et définies de manière rigide qui ne sont pas basées sur des lignes ou des colonnes. Le XML est hautement standardisé. Pour accéder à une présentation du format par l'autorité standard, consultez [XML Essentials](https://www.w3.org/standards/xml/core) (Essentiels XML). Vous pouvez utiliser AWS Glue pour lire des fichiers XML depuis Amazon S3, ainsi que `bzip` des `gzip` archives contenant des fichiers XML. 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 XML. | Lecture | Écrire | Lecture en streaming | Groupement des petits fichiers | Signets de tâche | | --- | --- | --- | --- | --- | | Pris en charge | Non pris en charge | Non pris en charge | Pris en charge | Pris en charge | ## Exemple : lecture de XML depuis S3 Le lecteur XML prend un nom de balise XML. Il examine les éléments comportant cette balise dans son entrée pour en déduire un schéma et remplit un DynamicFrame avec les valeurs correspondantes. La fonctionnalité AWS Glue XML se comporte de la même manière que la [source de données XML pour Apache Spark](https://github.com/databricks/spark-xml). Vous pourriez être en mesure de mieux comprendre le comportement de base en comparant ce lecteur à la documentation de ce projet. **Prérequis :**Vous aurez besoin des chemins S3 (`s3path`) vers les fichiers ou dossiers XML que vous souhaitez lire, ainsi qu'à certaines informations concernant votre fichier XML. Vous aurez également besoin de la balise pour l'élément XML que vous souhaitez lire, `xmlTag`. **Configuration :** dans vos options de fonction, spécifiez `format="xml"`. Dans vos `connection_options`, utilisez la clé `paths` pour spécifier `s3path`. Vous pouvez configurer plus en détail la manière dont le lecteur interagit avec S3 dans le `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). Dans vos `format_options`, utilisez la clé `rowTag` pour spécifier `xmlTag`. Vous pouvez configurer plus en détail la façon dont le lecteur interprète les fichiers XML dans votre `format_options`. Pour plus d'informations, consultez .[XML Configuration Reference](#aws-glue-programming-etl-format-xml-reference) (Référence de configuration XML). Le script AWS Glue ETL suvant montre le processus de lecture de fichiers ou dossiers XML à partir de 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 XML from S3 # Set the rowTag option to configure the reader. from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://s3path"]}, format="xml", format_options={"rowTag": "xmlTag"}, ) ``` Vous pouvez également l'utiliser DataFrames dans un script (`pyspark.sql.DataFrame`). ``` dataFrame = spark.read\ .format("xml")\ .option("rowTag", "xmlTag")\ .load("s3://s3path") ``` ------ #### [ Scala ] Pour cet exemple, utilisez l'opération [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` // Example: Read XML from S3 // Set the rowTag option to configure the reader. import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.GlueContext import org.apache.spark.sql.SparkSession val glueContext = new GlueContext(SparkContext.getOrCreate()) val sparkSession: SparkSession = glueContext.getSparkSession object GlueApp { def main(sysArgs: Array[String]): Unit = { val dynamicFrame = glueContext.getSourceWithFormat( formatOptions=JsonOptions("""{"rowTag": "xmlTag"}"""), connectionType="s3", format="xml", options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""") ).getDynamicFrame() } ``` Vous pouvez également l'utiliser DataFrames dans un script (`org.apache.spark.sql.DataFrame`). ``` val dataFrame = spark.read .option("rowTag", "xmlTag") .format("xml") .load("s3://s3path“) ``` ------ ## Référence de configurations XML Vous pouvez utiliser ce qui suit `format_options` partout où les bibliothèques AWS Glue le spécifient `format="xml"` : + `rowTag` – spécifie la balise XML du fichier à traiter comme ligne. Les balises de ligne ne se ferment pas automatiquement. + **Type :** Texte, **Obligatoire** + `encoding` – spécifie le codage de caractère. Il peut s'agir du nom ou de l'alias d'un[Charset](https://docs.oracle.com/javase/8/docs/api/java/nio/charset/Charset.html)pris en charge par notre environnement d'exécution. Nous ne donnons pas de garanties spécifiques concernant la prise en charge de l'encodage, mais les principaux codages devraient fonctionner. + **Type :** texte, **Valeur par défaut :** `"UTF-8"` + `excludeAttribute` –  spécifie si vous souhaitez ou pas exclure les attributs dans les éléments. + **Type :** Booléen, **Valeur par défaut :** `false` + `treatEmptyValuesAsNulls` –  pécifie s'il convient de traiter un espace blanc comme valeur nulle. + **Type :** Booléen, **Valeur par défaut :** `false` + `attributePrefix` – Un préfixe des attributs pour les différencier des éléments. Ce préfixe est utilisé pour les noms de champs. + **Type :** texte, **Valeur par défaut :** `"_"` + `valueTag` –  La balise utilisée pour une valeur lorsqu'il y a des attributs de l'élément qui n'ont pas d'enfant. + **Type :** texte, **Valeur par défaut :** `"_VALUE"` + `ignoreSurroundingSpaces` – spécifie si les espaces blancs qui entourent les valeurs doivent être ignorés. + **Type :** Booléen, **Valeur par défaut :** `false` + `withSchema` – Contient le schéma attendu, dans les cas où vous souhaitez remplacer le schéma déduit. Si vous n'utilisez pas cette option, AWS Glue déduit le schéma des données XML. + **Type :**Texte, **Par défaut:** Non applicable + La valeur doit être un objet JSON qui représente un `StructType`. ## Spécifier manuellement le schéma XML **Exemple de schéma XML manuel** Il s'agit d'un exemple d'utilisation de l'option format `withSchema` pour spécifier le schéma des données XML. ``` from awsglue.gluetypes import * schema = StructType([ Field("id", IntegerType()), Field("name", StringType()), Field("nested", StructType([ Field("x", IntegerType()), Field("y", StringType()), Field("z", ChoiceType([IntegerType(), StringType()])) ])) ]) datasource0 = create_dynamic_frame_from_options( connection_type, connection_options={"paths": ["s3://xml_bucket/someprefix"]}, format="xml", format_options={"withSchema": json.dumps(schema.jsonValue())}, transformation_ctx = "" ) ``` # Utilisation du format Avro dans Glue AWS 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 Avro, ce document présente les fonctionnalités disponibles pour utiliser vos données dans AWS Glue. AWS Glue supporte l'utilisation du format Avro. Ce format est un format de données en colonnes et orienté vers la performance. Pour accéder à une présentation du format par l'autorité standard, consultez [ documentation Apache Avro 1.8.2 ](https://avro.apache.org/docs/1.8.2/). Vous pouvez utiliser AWS Glue pour lire des fichiers Avro depuis Amazon S3 et depuis des sources de streaming, ainsi que pour écrire des fichiers Avro sur Amazon S3. Vous pouvez lire et écrire `bzip2` et `gzip`des archives contenant des fichiers Avro provenant de S3. De plus, vous pouvez écrire des archives `deflate`, `snappy` et `xz` contenant des fichiers Avro. 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 quelles opérations AWS Glue courantes prennent en charge l'option de format Avro. | Lecture | Écrire | Lecture en streaming | Groupement des petits fichiers | Signets de tâche | | --- | --- | --- | --- | --- | | Pris en charge | Pris en charge | Pris en charge\$1 | Non pris en charge | Pris en charge | \$1 Pris en charge avec des restrictions. Pour de plus amples informations, veuillez consulter [Notes et restrictions pour les sources en streaming Avro](add-job-streaming.md#streaming-avro-notes). ## Exemple : lecture de fichiers Avro ou de dossiers de S3 **Prérequis :** vous aurez besoin des chemins S3 (`s3path`) vers des fichiers ou dossiers Avro que vous souhaitez lire. **Configuration :** dans vos options de fonction, spécifiez `format="avro"`. Dans vos `connection_options`, utilisez la clé `paths` pour spécifier `s3path`. Vous pouvez configurer la manière dont le lecteur interagit avec S3 dans les `connection_options`. Pour plus de détails, voir Options de format de données pour les entrées et sorties ETL dans AWS Glue :[Référence des options de connexion Amazon 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 Avro dans votre `format_options`. Pour plus d'informations, consultez .[Référence de configuration Avro](#aws-glue-programming-etl-format-avro-reference). Le script AWS Glue ETL suivant montre le processus de lecture de fichiers ou de dossiers Avro 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). ``` from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://s3path"]}, format="avro" ) ``` ------ #### [ Scala ] Pour cet exemple, utilisez l'opération [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.GlueContext import org.apache.spark.sql.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="avro", options=JsonOptions("""{"paths": ["s3://s3path"]}""") ).getDynamicFrame() } ``` ------ ## Exemple : écriture de fichiers et dossiers Avro 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="avro"`. Dans vos `connection_options`, utilisez la clé `paths` pour spécifier votre `s3path`. Vous pouvez modifier davantage la manière dont le scripteur interagit avec S3 dans les `connection_options`. Pour plus de détails, voir Options de format de données pour les entrées et sorties ETL dans AWS Glue :[Référence des options de connexion Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Vous pouvez modifier la façon dont le rédacteur interprète les fichiers Avro dans votre `format_options`. Pour plus d'informations, consultez .[Référence de configuration Avro](#aws-glue-programming-etl-format-avro-reference). Le script AWS Glue ETL suivant montre le processus d'écriture de fichiers ou de dossiers Avro dans S3. ------ #### [ 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). ``` 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="avro", connection_options={ "path": "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). ``` 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="avro" ).writeDynamicFrame(dynamicFrame) } } ``` ------ ## Référence de configurations Avro Vous pouvez utiliser les `format_options` valeurs suivantes partout où les bibliothèques AWS Glue le spécifient `format="avro"` : + `version`— Spécifie la version du reader/writer format Apache Avro à prendre en charge. La valeur par défaut est 1.7. Vous pouvez spécifier `format_options={"version": “1.8”}` pour activer la lecture et l'écriture d'un type logique Avro. Pour plus d'informations, consultez les [spécifications Apache Avro 1.7.7](https://avro.apache.org/docs/1.7.7/spec.html) et les [spécifications Apache Avro 1.8.2](https://avro.apache.org/docs/1.8.2/spec.html). Le connecteur Apache Avro 1.8 prend en charge les conversions de type logique suivantes : Pour le lecteur : ce tableau montre la conversion entre le type de données Avro (type logique et type primitif Avro) et le type de données AWS Glue `DynamicFrame` pour le lecteur Avro 1.7 et 1.8. | Type de données Avro : Type logique | Type de données Avro : Type Avro primitif | GlueDynamicFrame Type de données :Avro Reader 1.7 | GlueDynamicFrame Type de données : Avro Reader 1.8 | | --- | --- | --- | --- | | Décimal | octets | BINAIRE | Décimal | | Décimal | corrigé(e)(s) | BINAIRE | Décimal | | Date | int | INT | Date | | Temps (milliseconde) | int | INT | INT | | Temps (microseconde) | long | LONG | LONG | | Horodatage (milliseconde) | long | LONG | Horodatage | | Horodatage (microseconde) | long | LONG | LONG | | Durée (pas un type logique) | corrigé(e)(s) sur 12 | BINAIRE | BINAIRE | Pour le dispositif d'écriture : ce tableau affiche la conversion entre le type de données AWS Glue `DynamicFrame` et le type de données Avro pour le dispositif d'écriture Avro 1.7 et 1.8. | Type de données AWS Glue `DynamicFrame` | Type de données Avro :Avro Writer 1.7 | Type de données Avro :Avro Writer 1.8 | | --- | --- | --- | | Décimal | String | decimal | | Date | String | date | | Horodatage | String | timestamp-micros | ## Assistance Avro Spark DataFrame Pour utiliser Avro depuis l' DataFrame API Spark, vous devez installer le plugin Spark Avro pour la version de Spark correspondante. La version de Spark disponible dans votre tâche est déterminée par votre version de AWS Glue. Pour plus d'informations sur les versions Spark, consultez [AWS Glue versions](release-notes.md). Ce plugin est maintenu par Apache, nous ne donnons pas de garanties spécifiques de support. Dans AWS Glue 2.0, utilisez la version 2.4.3 du plugin Spark Avro. Vous pouvez trouver ce fichier JAR sur Maven Central, voir[org.apache.spark:spark-avro\$12.12:2.4.3](https://search.maven.org/artifact/org.apache.spark/spark-avro_2.12/3.1.1/jar). Dans AWS Glue 3.0, utilisez la version 3.1.1 du plugin Spark Avro. Vous pouvez trouver ce fichier JAR sur Maven Central, voir[org.apache.spark : spark-avro\$12.12:3.1.1](https://search.maven.org/artifact/org.apache.spark/spark-avro_2.12/3.1.1/jar). Pour inclure des éléments supplémentaires JARs dans une tâche AWS Glue ETL, utilisez le paramètre `--extra-jars` job. Pour de plus amples informations sur la définition des paramètres de la tâche, consultez [Utilisation des paramètres des tâches dans les tâches AWS Glue](aws-glue-programming-etl-glue-arguments.md). Vous pouvez également configurer ce paramètre dans AWS Management Console. # Utilisation du format GrokLog dans Glue AWS 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 dans un format de texte brut peu structuré, ce document présente les fonctionnalités disponibles pour utiliser vos données dans les modèles AWS Glue through Grok. AWS Supports à colle utilisant des motifs Grok. Les modèles Grok sont similaires aux groupes de capture d'expressions régulières. Ils reconnaissent les modèles de séquences de caractères dans un fichier texte brut et leur donnent un type et un objectif. Dans AWS Glue, leur objectif principal est de lire les journaux. Pour une introduction au Grok par les auteurs, voir[Référence Logstash : plug-in de filtre Grok](https://www.elastic.co/guide/en/logstash/current/plugins-filters-grok.html). | Lecture | Écrire | Lecture en streaming | Groupement des petits fichiers | Signets de tâche | | --- | --- | --- | --- | --- | | Pris en charge | Ne s'applique pas | Pris en charge | Pris en charge | Non pris en charge | ## Référence de configuration grokLog Vous pouvez utiliser les valeurs `format_options` suivantes avec `format="grokLog"` : + `logFormat` — spécifie le modèle Grok correspondant au format du journal. + `customPatterns` — spécifie les modèles Grok supplémentaires utilisés ici. + `MISSING` — spécifie le signal à utiliser lors de l'identification des valeurs manquantes. La valeur par défaut est `'-'`. + `LineCount` — spécifie le nombre de lignes de chaque enregistrement de journal. La valeur par défaut est `'1'`, et actuellement seuls les enregistrements d'une ligne sont pris en charge. + `StrictMode` — valeur booléenne indiquant si le mode strict est activé. En mode strict, le lecteur n'exécute pas de conversion ou récupération de type automatique. La valeur par défaut est `"false"`. # Utilisation du format Ion 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 Ion, ce document présente les fonctionnalités disponibles pour utiliser vos données dans AWS Glue. AWS Glue supporte l'utilisation du format Ion. Ce format représente des structures de données (qui ne sont pas basées sur des lignes ou des colonnes) dans des représentations binaires et en texte brut interchangeables. Pour accéder à une présentation du format par les auteurs, consultez [Amazon Ion](https://amzn.github.io/ion-docs/). (Pour plus d'informations, consultez la [spécification Amazon Ion](https://amzn.github.io/ion-docs/spec.html).) Vous pouvez utiliser AWS Glue pour lire les fichiers Ion depuis Amazon S3. Vous pouvez lire`bzip` `gzip` et des archives contenant des fichiers lon 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 quelles opérations AWS Glue courantes prennent en charge l'option de format Ion. | Lecture | Écrire | Lecture en streaming | Groupement des petits fichiers | Signets de tâche | | --- | --- | --- | --- | --- | | Pris en charge | Non pris en charge | Non pris en charge | Pris en charge | Non pris en charge | ## Exemple : lecture de fichiers ou de dossiers lon de S3 ** Prérequis :** vous aurez besoin des chemins S3 (`s3path`) vers des fichiers ou dossiers lon que vous souhaitez lire. **Configuration :** dans vos options de fonction, spécifiez `format="json"`. 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 :[Référence des options de connexion Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Le script AWS Glue ETL suivant montre le processus de lecture de fichiers ou de dossiers Ion 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 ION from S3 from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://s3path"]}, format="ion" ) ``` ------ #### [ Scala ] Pour cet exemple, utilisez l'opération [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` // Example: Read ION from S3 import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.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="ion", options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""") ).getDynamicFrame() } } ``` ------ ## Référence de configurations lon Il n'y a aucune valeur `format_options` pour `format="ion"`. # Utilisation du format JSON 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 JSON, ce document vous présente les fonctionnalités disponibles pour utiliser vos données dans AWS Glue. AWS Glue prend en charge l'utilisation du format JSON. Ce format représente des structures de données avec une forme uniforme mais un contenu flexible qui ne sont pas basés sur des lignes ou des colonnes. Le JSON est défini par des normes parallelles émises par plusieurs autorités, dont l’ECMA-404. Pour accéder à une présentation du format par une source fréquemment référencée, consultez [Introducing JSON](https://www.json.org/) (Présentation de JSON). Vous pouvez utiliser AWS Glue pour lire des fichiers JSON depuis Amazon S3, ainsi que `bzip` des fichiers JSON `gzip` compressés. 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. | Lecture | Écrire | Lecture en streaming | Groupement des petits fichiers | Signets de tâche | | --- | --- | --- | --- | --- | | Pris en charge | Pris en charge | Pris en charge | Pris en charge | Pris en charge | ## Exemple : lecture de fichiers ou de dossiers JSON de S3 **Prérequis :** vous aurez besoin des chemins S3 (`s3path`) vers des fichiers ou dossiers JSON que vous souhaitez lire. **Configuration :** dans vos options de fonction, spécifiez `format="json"`. Dans vos `connection_options`, utilisez la clé `paths` pour spécifier votre `s3path`. Vous pouvez également modifier la façon dont votre opération de lecture traversera s3 dans les options de connexion, consultez [Référence des options de connexion Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) pour plus d’informations. Vous pouvez configurer la manière dont le lecteur interprète les fichiers JSON dans votre `format_options`. Pour plus d'informations, consultez [JSON Configuration Reference](#aws-glue-programming-etl-format-json-reference) (Référence de configuration JSON). Le script AWS Glue ETL suivant montre le processus de lecture de fichiers ou de dossiers JSON 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 JSON from S3 # For show, we handle a nested JSON file that we can limit with the JsonPath parameter # For show, we also handle a JSON where a single entry spans multiple lines # Consider whether optimizePerformance is right for your workflow. 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="json", format_options={ "jsonPath": "$.id", "multiline": True, # "optimizePerformance": True, -> not compatible with jsonPath, multiline } ) ``` Vous pouvez également l'utiliser DataFrames dans un script (`pyspark.sql.DataFrame`). ``` dataFrame = spark.read\ .option("multiline", "true")\ .json("s3://s3path") ``` ------ #### [ Scala ] Pour cet exemple, utilisez l'opération [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` // Example: Read JSON from S3 // For show, we handle a nested JSON file that we can limit with the JsonPath parameter // For show, we also handle a JSON where a single entry spans multiple lines // Consider whether optimizePerformance 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) val dynamicFrame = glueContext.getSourceWithFormat( formatOptions=JsonOptions("""{"jsonPath": "$.id", "multiline": true, "optimizePerformance":false}"""), connectionType="s3", format="json", options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""") ).getDynamicFrame() } } ``` Vous pouvez également l'utiliser DataFrames dans un script (`pyspark.sql.DataFrame`). ``` val dataFrame = spark.read .option("multiline", "true") .json("s3://s3path") ``` ------ ## Exemple : écriture de fichiers et dossiers JSON 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="json"`. 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 Options de format de données pour les entrées et sorties ETL dans AWS Glue :[Référence des options de connexion Amazon 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 JSON dans votre `format_options`. Pour plus d'informations, consultez [JSON Configuration Reference](#aws-glue-programming-etl-format-json-reference) (Référence de configuration JSON). Le script AWS Glue ETL suivant montre le processus d'écriture de fichiers ou de dossiers JSON à partir de S3 : ------ #### [ 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 JSON to S3 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", connection_options={"path": "s3://s3path"}, format="json" ) ``` Vous pouvez également l'utiliser DataFrames dans un script (`pyspark.sql.DataFrame`). ``` df.write.json("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 JSON to 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) glueContext.getSinkWithFormat( connectionType="s3", options=JsonOptions("""{"path": "s3://s3path"}"""), format="json" ).writeDynamicFrame(dynamicFrame) } } ``` Vous pouvez également l'utiliser DataFrames dans un script (`pyspark.sql.DataFrame`). ``` df.write.json("s3://s3path") ``` ------ ## Référence de configurations Json Vous pouvez utiliser les valeurs `format_options` suivantes avec `format="json"` : + `jsonPath`— [JsonPath](https://github.com/json-path/JsonPath)Expression qui identifie un objet à lire dans des enregistrements. Cette expression est particulièrement utile lorsqu’un fichier contient des enregistrements imbriqués à l’intérieur d’un tableau externe. Par exemple, l' JsonPath expression suivante cible le `id` champ d'un objet JSON. ``` format="json", format_options={"jsonPath": "$.id"} ``` + `multiline` — valeur booléenne qui spécifie si un même enregistrement peut couvrir plusieurs lignes. Cela peut se produire lorsqu’un champ contient un caractère de nouvelle ligne. Vous devez définir cette option sur `"true"` si aucun enregistrement ne s’étend sur plusieurs lignes. La valeur par défaut est `"false"`, qui permet un fractionnement en fichiers plus agressif pendant l’analyse. + `optimizePerformance` — valeur booléenne qui spécifie s’il faut utiliser le lecteur CSV SIMD avancé avec les formats de mémoire en colonnes basés sur Apache Arrow. Disponible uniquement dans AWS Glue 3.0. Non compatible avec `multiline` ou `jsonPath`. Si vous fournissez l'une ou l'autre de ces options, AWS Glue sera obligée de revenir au lecteur standard. + `withSchema` — Une valeur String qui spécifie un schéma de table au format décrit dans [Spécifier manuellement le schéma XML](aws-glue-programming-etl-format-xml-home.md#aws-glue-programming-etl-format-xml-withschema). Utilisé uniquement avec `optimizePerformance` lors de la lecture à partir de connexions hors catalogue. ## Utilisation d’un lecteur CSV SIMD vectorisé avec le format en colonnes Apache Arrow AWS Glue La version 3.0 ajoute un lecteur vectorisé pour les données JSON. Il fonctionne deux fois plus vite dans certaines conditions que le lecteur standard. Ce lecteur est livré avec certaines limitations dont les utilisateurs doivent être conscients avant utilisation, décrites dans cette section. Pour utiliser le lecteur optimisé, définissez `"optimizePerformance"` sur True dans le `format_options` ou la propriété table. Vous devrez également fournir `withSchema` sauf si vous lisez le catalogue. `withSchema` attend une entrée comme décrit dans le [Spécifier manuellement le schéma XML](aws-glue-programming-etl-format-xml-home.md#aws-glue-programming-etl-format-xml-withschema). ``` // Read from S3 data source glueContext.create_dynamic_frame.from_options( connection_type = "s3", connection_options = {"paths": ["s3://s3path"]}, format = "json", format_options={ "optimizePerformance": True, "withSchema": SchemaString }) // Read from catalog table glueContext.create_dynamic_frame.from_catalog( database = database, table_name = table, additional_options = { // The vectorized reader for JSON can read your schema from a catalog table property. "optimizePerformance": True, }) ``` Pour plus d'informations sur la création d'un *SchemaString* dans la bibliothèque AWS Glue, consultez[PySpark types d'extensions](aws-glue-api-crawler-pyspark-extensions-types.md). **Limitations du lecteur CSV vectorisé** Prenez en compte les limitations suivantes : + Les éléments JSON avec des objets imbriqués ou des valeurs de tableau ne sont pas pris en charge. S'il est fourni, AWS Glue retournera au lecteur standard. + Un schéma doit être fourni, soit à partir du catalogue, soit avec `withSchema`. + Non compatible avec `multiline` ou `jsonPath`. Si vous fournissez l'une ou l'autre de ces options, AWS Glue sera obligée de revenir au lecteur standard. + Le fait de fournir des enregistrements d’entrée qui ne correspondent pas au schéma d’entrée entraînera un dysfonctionnement du lecteur. + [Les enregistrements d’erreurs](https://docs.aws.amazon.com/glue/latest/dg/glue-etl-scala-apis-glue-dynamicframe-class.html#glue-etl-scala-apis-glue-dynamicframe-class-defs-errorsAsDynamicFrame) ne seront pas créés. + Les fichiers JSON contenant des caractères à plusieurs octets (tels que les caractères japonais ou chinois) ne sont pas pris en charge. # Utilisation du format ORC dans Glue AWS 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 ORC, ce document présente les fonctionnalités disponibles pour utiliser vos données dans AWS Glue. AWS Glue supporte l'utilisation du format ORC. 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 Orc](https://orc.apache.org/docs/). Vous pouvez utiliser AWS Glue pour lire des fichiers ORC depuis Amazon S3 et depuis des sources de streaming, ainsi que pour écrire des fichiers ORC sur Amazon S3. Vous pouvez lire et écrire des archives `bzip` et `gzip` contenant des fichiers CSV 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 quelles opérations AWS Glue courantes prennent en charge l'option de format ORC. | 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 de dossiers ORC à partir de S3 ** Prérequis :** vous aurez besoin des chemins S3 (`s3path`) vers des fichiers ou dossiers ORC que vous souhaitez lire. **Configuration :** dans vos options de fonction, spécifiez `format="orc"`. 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 :[Référence des options de connexion Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Le script AWS Glue ETL suivant montre le processus de lecture de fichiers ou de dossiers ORC 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). ``` from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://s3path"]}, format="orc" ) ``` Vous pouvez également l'utiliser DataFrames dans un script (`pyspark.sql.DataFrame`). ``` dataFrame = spark.read\ .orc("s3://s3path") ``` ------ #### [ Scala ] Pour cet exemple, utilisez l'opération [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.GlueContext import org.apache.spark.sql.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="orc", options=JsonOptions("""{"paths": ["s3://s3path"]}""") ).getDynamicFrame() } } ``` Vous pouvez également l'utiliser DataFrames dans un script (`pyspark.sql.DataFrame`). ``` val dataFrame = spark.read .orc("s3://s3path") ``` ------ ## Exemple : écriture de fichiers et dossiers ORC 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="orc"`. Dans vos options de connexion, utilisez`paths`touche à 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 Options de format de données pour les entrées et sorties ETL dans AWS Glue :[Référence des options de connexion Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). L'exemple de code suivant montre le processus : ------ #### [ 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). ``` 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="orc", connection_options={ "path": "s3://s3path" } ) ``` Vous pouvez également l'utiliser DataFrames dans un script (`pyspark.sql.DataFrame`). ``` df.write.orc("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). ``` 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="orc" ).writeDynamicFrame(dynamicFrame) } } ``` Vous pouvez également l'utiliser DataFrames dans un script (`pyspark.sql.DataFrame`). ``` df.write.orc("s3://s3path/") ``` ------ ## Référence de configuration ORC Il n'y a aucune valeur `format_options` pour `format="orc"`. Cependant, les options acceptées par le code SparkSQL sous-jacent peuvent lui être transmises au moyen du paramètre de carte `connection_options`. # Utilisation de frameworks de lacs de données avec des tâches AWS Glue ETL Les frameworks de lacs de données open source simplifient le traitement incrémentiel des données pour les fichiers que vous stockez dans des lacs de données basés sur Amazon S3. AWS Glue La version 3.0 et les versions ultérieures prennent en charge les frameworks de lacs de données open source suivants : + Apache Hudi + Linux Foundation Delta Lake + Apache Iceberg Nous fournissons une prise en charge native de ces cadres afin de vous permettre de lire et écrire les données à stocker dans Amazon S3 de manière cohérente sur le plan transactionnel. Il n'est pas nécessaire d'installer un connecteur distinct ou d'effectuer des étapes de configuration supplémentaires pour utiliser ces cadres dans les tâches AWS Glue ETL. Lorsque vous gérez des ensembles de données via le AWS Glue Data Catalog, vous pouvez utiliser AWS Glue des méthodes pour lire et écrire des tables de lacs de données avec Spark DataFrames. Vous pouvez également lire et écrire des données Amazon S3 à l'aide de l' DataFrame API Spark. Dans cette vidéo, vous découvrirez les principes de base du fonctionnement d'Apache Hudi, d'Apache Iceberg et de Delta Lake. Vous découvrirez comment insérer, mettre à jour et supprimer des données dans votre lac de données et comment chacun de ces cadres fonctionne. [![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/fryfx0Zg7KA/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/fryfx0Zg7KA) **Topics** + [Limitations](aws-glue-programming-etl-datalake-native-frameworks-limitations.md) + [Utilisation du framework Hudi dans Glue AWS](aws-glue-programming-etl-format-hudi.md) + [Utilisation du framework Delta Lake dans AWS Glue](aws-glue-programming-etl-format-delta-lake.md) + [Utilisation du framework Iceberg dans Glue AWS](aws-glue-programming-etl-format-iceberg.md) # Limitations Tenez compte des limites suivantes avant d'utiliser des frameworks de lacs de données avec AWS Glue. + Les AWS Glue `GlueContext` méthodes suivantes DynamicFrame ne prennent pas en charge la lecture et l'écriture de tables du framework Data Lake. Utilisez plutôt les `GlueContext` méthodes pour DataFrame ou DataFrame l'API Spark. + `create_dynamic_frame.from_catalog` + `write_dynamic_frame.from_catalog` + `getDynamicFrame` + `writeDynamicFrame` + Les `GlueContext` méthodes suivantes DataFrame sont prises en charge par le contrôle des autorisations de Lake Formation : + `create_data_frame.from_catalog` + `write_data_frame.from_catalog` + `getDataFrame` + `writeDataFrame` + Le [regroupement de petits fichiers](grouping-input-files.md) n'est pas pris en charge. + Les [signets de tâche](monitor-continuations.md) ne sont pas pris en charge. + Apache Hudi 0.10.1 pour AWS Glue 3.0 ne prend pas en charge les tables Hudi Merge on Read (MoR). + `ALTER TABLE … RENAME TO`n'est pas disponible pour Apache Iceberg 0.13.1 pour 3.0. AWS Glue ## Limitations des tables au format de lac de données gérées par les autorisations de Lake Formation Les formats de lac de données sont intégrés à l' AWS Glue ETL via les autorisations Lake Formation. La création d'un DynamicFrame utilisateur n'`create_dynamic_frame`est pas prise en charge. Pour plus d’informations, consultez les exemples suivants : + [Exemple : lecture et écriture d'une table Iceberg avec contrôle des autorisations de Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-iceberg.html#aws-glue-programming-etl-format-iceberg-read-write-lake-formation-tables) + [Exemple : lecture et écriture d'une table Hudi avec contrôle des autorisations de Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-hudi.html#aws-glue-programming-etl-format-hudi-read-write-lake-formation-tables) + [Exemple : lecture et écriture d'une table Delta Lake avec contrôle des autorisations de Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-delta-lake.html#aws-glue-programming-etl-format-delta-lake-read-write-lake-formation-tables) **Note** L'intégration avec les autorisations AWS Glue ETL via Lake Formation pour Apache Hudi, Apache Iceberg et Delta Lake n'est prise en charge que dans la AWS Glue version 4.0. Apache Iceberg offre la meilleure intégration avec l' AWS Glue ETL via les autorisations Lake Formation. Il prend en charge presque toutes les opérations et inclut la prise en charge de SQL. Hudi prend en charge la plupart des opérations de base à l'exception des opérations administratives. C'est parce que ces options sont généralement effectuées via l'écriture de dataframes et spécifiées via `additional_options`. Vous devez l'utiliser pour créer AWS Glue APIs DataFrames pour vos opérations car SparkSQL n'est pas supporté. Delta Lake prend uniquement en charge la lecture, l'ajout et le remplacement de données de table. Delta Lake nécessite l'utilisation de ses propres bibliothèques pour pouvoir effectuer diverses tâches telles que les mises à jour. Les fonctionnalités suivantes ne sont pas disponibles pour les tables Iceberg gérées par les autorisations de Lake Formation. + Compaction à l'aide AWS Glue de l'ETL + Support de Spark SQL via AWS Glue ETL Les limites des tables Hudi gérées par les autorisations de Lake Formation sont les suivantes : + Suppression de fichiers orphelins Les limites des tables Delta Lake gérées par les autorisations de Lake Formation sont les suivantes : + Toutes les fonctionnalités autres que l'insertion et la lecture à partir des tables de Delta Lake. # Utilisation du framework Hudi dans Glue AWS AWS Glue 3.0 et versions ultérieures prennent en charge le framework Apache Hudi pour les lacs de données. Hudi est un cadre de stockage de lac de données open source qui simplifie le traitement incrémentiel des données et le développement de pipelines de données. Cette rubrique décrit les fonctionnalités disponibles pour utiliser vos données dans AWS Glue lorsque vous transportez ou stockez vos données dans une table Hudi. Pour en savoir plus sur Hudi, consultez la [documentation officielle d'Apache Hudi](https://hudi.apache.org/docs/overview/). Vous pouvez utiliser AWS Glue pour effectuer des opérations de lecture et d'écriture sur des tables Hudi dans Amazon S3, ou travailler avec des tables Hudi à l'aide du catalogue de données AWS Glue. Des opérations supplémentaires, notamment l'insertion, la mise à jour et toutes les [opérations d'Apache Spark](https://hudi.apache.org/docs/quick-start-guide/), sont également prises en charge. **Note** [L'implémentation d'Apache Hudi 0.15.0 dans AWS Glue 5.0 rétablit en interne le HUDI-7001.](https://github.com/apache/hudi/pull/9936) Elle ne présente pas la régression liée à la génération de clés complexes lorsque la clé d’enregistrement est constituée d’un seul champ. Toutefois, ce comportement est différent de celui d’OSS Apache Hudi 0.15.0. Apache Hudi 0.10.1 pour AWS Glue 3.0 ne prend pas en charge les tables Hudi Merge on Read (MoR). Le tableau suivant répertorie la version Hudi incluse dans chaque version de AWS Glue. **** | AWS Version Glue | Version de Hudi prise en charge | | --- | --- | | 5.1 | 1.0.2 | | 5.0 | 0,15,0 | | 4.0 | 0.12.1 | | 3.0 | 0,1,1 | Pour en savoir plus sur les frameworks de lacs de données pris en charge par AWS Glue, consultez[Utilisation de frameworks de lacs de données avec des tâches AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md). ## Activation de Hudi Pour activer Hudi for AWS Glue, effectuez les tâches suivantes : + Spécifiez `hudi` comme valeur pour le paramètre de tâche `--datalake-formats`. Pour de plus amples informations, veuillez consulter [Utilisation des paramètres des tâches dans les tâches AWS Glue](aws-glue-programming-etl-glue-arguments.md). + Créez une clé nommée `--conf` d'après votre tâche AWS Glue et définissez-la sur la valeur suivante. Vous pouvez également définir la configuration suivante à l'aide de `SparkConf` dans votre script. Ces paramètres permettent à Apache Spark de gérer correctement les tables Hudi. ``` spark.serializer=org.apache.spark.serializer.KryoSerializer ``` + La prise en charge des autorisations de Lake Formation pour Hudi est activée par défaut pour AWS Glue 4.0. Aucune configuration supplémentaire n'est nécessaire pour les tables Hudi enregistrées pour reading/writing To Lake Formation. Pour lire une table Hudi enregistrée, le rôle IAM de la tâche AWS Glue doit disposer de l'autorisation SELECT. Pour écrire dans une table Hudi enregistrée, le rôle IAM de la tâche AWS Glue doit disposer de l'autorisation SUPER. Pour en savoir plus sur la gestion des autorisations de Lake Formation, consultez la section [Octroi et révocation d'autorisations liées aux ressources du catalogue de données](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html). **Utilisation d'une autre version de Hudi** Pour utiliser une version de Hudi non prise en charge par AWS Glue, spécifiez vos propres fichiers JAR Hudi à l'aide du paramètre `--extra-jars` job. N'incluez pas `hudi` comme valeur du paramètre de tâche `--datalake-formats`. Si vous utilisez AWS Glue 5.0 ou une version ultérieure, vous devez définir le paramètre de `--user-jars-first true` tâche. ## Exemple : écrire une table Hudi sur Amazon S3 et l'enregistrer dans le catalogue de données AWS Glue Cet exemple de script montre comment écrire une table Hudi sur Amazon S3 et enregistrer la table dans le catalogue de données AWS Glue. L'exemple utilise l'[outil de synchronisation Hive](https://hudi.apache.org/docs/syncing_metastore/) de Hudi pour enregistrer la table. **Note** Dans cet exemple, vous devez définir le paramètre `--enable-glue-datacatalog` job afin d'utiliser le catalogue de données AWS Glue comme métastore Apache Spark Hive. Pour en savoir plus, veuillez consulter la section [Utilisation des paramètres des tâches dans les tâches AWS Glue](aws-glue-programming-etl-glue-arguments.md). ------ #### [ Python ] ``` # Example: Create a Hudi table from a DataFrame # and register the table to Glue Data Catalog additional_options={ "hoodie.table.name": "", "hoodie.database.name": "", "hoodie.datasource.write.storage.type": "COPY_ON_WRITE", "hoodie.datasource.write.operation": "upsert", "hoodie.datasource.write.recordkey.field": "", "hoodie.datasource.write.precombine.field": "", "hoodie.datasource.write.partitionpath.field": "", "hoodie.datasource.write.hive_style_partitioning": "true", "hoodie.datasource.hive_sync.enable": "true", "hoodie.datasource.hive_sync.database": "", "hoodie.datasource.hive_sync.table": "", "hoodie.datasource.hive_sync.partition_fields": "", "hoodie.datasource.hive_sync.partition_extractor_class": "org.apache.hudi.hive.MultiPartKeysValueExtractor", "hoodie.datasource.hive_sync.use_jdbc": "false", "hoodie.datasource.hive_sync.mode": "hms", "path": "s3://" } dataFrame.write.format("hudi") \ .options(**additional_options) \ .mode("overwrite") \ .save() ``` ------ #### [ Scala ] ``` // Example: Example: Create a Hudi table from a DataFrame // and register the table to Glue Data Catalog val additionalOptions = Map( "hoodie.table.name" -> "", "hoodie.database.name" -> "", "hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE", "hoodie.datasource.write.operation" -> "upsert", "hoodie.datasource.write.recordkey.field" -> "", "hoodie.datasource.write.precombine.field" -> "", "hoodie.datasource.write.partitionpath.field" -> "", "hoodie.datasource.write.hive_style_partitioning" -> "true", "hoodie.datasource.hive_sync.enable" -> "true", "hoodie.datasource.hive_sync.database" -> "", "hoodie.datasource.hive_sync.table" -> "", "hoodie.datasource.hive_sync.partition_fields" -> "", "hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor", "hoodie.datasource.hive_sync.use_jdbc" -> "false", "hoodie.datasource.hive_sync.mode" -> "hms", "path" -> "s3://") dataFrame.write.format("hudi") .options(additionalOptions) .mode("append") .save() ``` ------ ## Exemple : lecture d'une table Hudi depuis Amazon S3 à l'aide du catalogue de données AWS Glue Cet exemple lit la table Hudi que vous avez créée dans [Exemple : écrire une table Hudi sur Amazon S3 et l'enregistrer dans le catalogue de données AWS Glue](#aws-glue-programming-etl-format-hudi-write) depuis Amazon S3. **Note** Dans cet exemple, vous devez définir le paramètre `--enable-glue-datacatalog` job afin d'utiliser le catalogue de données AWS Glue comme métastore Apache Spark Hive. Pour en savoir plus, veuillez consulter la section [Utilisation des paramètres des tâches dans les tâches AWS Glue](aws-glue-programming-etl-glue-arguments.md). ------ #### [ Python ] Pour cet exemple, utilisez la méthode `GlueContext.create\$1data\$1frame.from\$1catalog()`. ``` # Example: Read a Hudi table from Glue Data Catalog from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) dataFrame = glueContext.create_data_frame.from_catalog( database = "", table_name = "" ) ``` ------ #### [ Scala ] Pour cet exemple, utilisez la méthode [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource). ``` // Example: Read a Hudi table from Glue Data Catalog import com.amazonaws.services.glue.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 dataFrame = glueContext.getCatalogSource( database = "", tableName = "" ).getDataFrame() } } ``` ------ ## Exemple : mise à jour et insertion d'un `DataFrame` dans une table Hudi d'Amazon S3 Cet exemple utilise le catalogue de données AWS Glue pour DataFrame insérer un dans la table Hudi que vous avez créée dans[Exemple : écrire une table Hudi sur Amazon S3 et l'enregistrer dans le catalogue de données AWS Glue](#aws-glue-programming-etl-format-hudi-write). **Note** Dans cet exemple, vous devez définir le paramètre `--enable-glue-datacatalog` job afin d'utiliser le catalogue de données AWS Glue comme métastore Apache Spark Hive. Pour en savoir plus, veuillez consulter la section [Utilisation des paramètres des tâches dans les tâches AWS Glue](aws-glue-programming-etl-glue-arguments.md). ------ #### [ Python ] Pour cet exemple, utilisez la méthode `GlueContext.write\$1data\$1frame.from\$1catalog()`. ``` # Example: Upsert a Hudi table from Glue Data Catalog from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) glueContext.write_data_frame.from_catalog( frame = dataFrame, database = "", table_name = "", additional_options={ "hoodie.table.name": "", "hoodie.database.name": "", "hoodie.datasource.write.storage.type": "COPY_ON_WRITE", "hoodie.datasource.write.operation": "upsert", "hoodie.datasource.write.recordkey.field": "", "hoodie.datasource.write.precombine.field": "", "hoodie.datasource.write.partitionpath.field": "", "hoodie.datasource.write.hive_style_partitioning": "true", "hoodie.datasource.hive_sync.enable": "true", "hoodie.datasource.hive_sync.database": "", "hoodie.datasource.hive_sync.table": "", "hoodie.datasource.hive_sync.partition_fields": "", "hoodie.datasource.hive_sync.partition_extractor_class": "org.apache.hudi.hive.MultiPartKeysValueExtractor", "hoodie.datasource.hive_sync.use_jdbc": "false", "hoodie.datasource.hive_sync.mode": "hms" } ) ``` ------ #### [ Scala ] Pour cet exemple, utilisez la méthode [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink). ``` // Example: Upsert a Hudi table from Glue Data Catalog import com.amazonaws.services.glue.GlueContext import com.amazonaws.services.glue.util.JsonOptions import org.apacke.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getCatalogSink("", "", additionalOptions = JsonOptions(Map( "hoodie.table.name" -> "", "hoodie.database.name" -> "", "hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE", "hoodie.datasource.write.operation" -> "upsert", "hoodie.datasource.write.recordkey.field" -> "", "hoodie.datasource.write.precombine.field" -> "", "hoodie.datasource.write.partitionpath.field" -> "", "hoodie.datasource.write.hive_style_partitioning" -> "true", "hoodie.datasource.hive_sync.enable" -> "true", "hoodie.datasource.hive_sync.database" -> "", "hoodie.datasource.hive_sync.table" -> "", "hoodie.datasource.hive_sync.partition_fields" -> "", "hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor", "hoodie.datasource.hive_sync.use_jdbc" -> "false", "hoodie.datasource.hive_sync.mode" -> "hms" ))) .writeDataFrame(dataFrame, glueContext) } } ``` ------ ## Exemple : lecture d'une table Hudi depuis Amazon S3 à l'aide de Spark Cet exemple lit une table Hudi depuis Amazon S3 à l'aide de l' DataFrameAPI Spark. ------ #### [ Python ] ``` # Example: Read a Hudi table from S3 using a Spark DataFrame dataFrame = spark.read.format("hudi").load("s3://") ``` ------ #### [ Scala ] ``` // Example: Read a Hudi table from S3 using a Spark DataFrame val dataFrame = spark.read.format("hudi").load("s3://") ``` ------ ## Exemple : écriture d'une table Hudi sur Amazon S3 à l'aide de Spark Cet exemple écrit une table Hudi sur Amazon S3 à l'aide de Spark. ------ #### [ Python ] ``` # Example: Write a Hudi table to S3 using a Spark DataFrame dataFrame.write.format("hudi") \ .options(**additional_options) \ .mode("overwrite") \ .save("s3://) ``` ------ #### [ Scala ] ``` // Example: Write a Hudi table to S3 using a Spark DataFrame dataFrame.write.format("hudi") .options(additionalOptions) .mode("overwrite") .save("s3://") ``` ------ ## Exemple : lecture et écriture d'une table Hudi avec contrôle des autorisations de Lake Formation Cet exemple lit et écrit dans une table Hudi avec contrôle des autorisations de Lake Formation. 1. Créez une table Hudi et enregistrez-la dans Lake Formation. 1. Pour activer le contrôle des autorisations de Lake Formation, vous devez d'abord enregistrer le chemin d'accès Amazon S3 de la table sur 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). Vous pouvez l'enregistrer depuis la console Lake Formation ou à l'aide de la AWS CLI : ``` aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region ``` Une fois que vous avez enregistré un emplacement Amazon S3, toute table AWS Glue pointant vers cet emplacement (ou l'un de ses emplacements enfants) renverra la valeur du `IsRegisteredWithLakeFormation` paramètre comme vraie lors de l'`GetTable`appel. 1. Créez une table Hudi qui pointe vers le chemin Amazon S3 enregistré via l'API Spark dataframe : ``` hudi_options = { 'hoodie.table.name': table_name, 'hoodie.database.name': database_name, 'hoodie.datasource.write.storage.type': 'COPY_ON_WRITE', 'hoodie.datasource.write.recordkey.field': 'product_id', 'hoodie.datasource.write.table.name': table_name, 'hoodie.datasource.write.operation': 'upsert', 'hoodie.datasource.write.precombine.field': 'updated_at', 'hoodie.datasource.write.hive_style_partitioning': 'true', 'hoodie.upsert.shuffle.parallelism': 2, 'hoodie.insert.shuffle.parallelism': 2, 'path': , 'hoodie.datasource.hive_sync.enable': 'true', 'hoodie.datasource.hive_sync.database': database_name, 'hoodie.datasource.hive_sync.table': table_name, 'hoodie.datasource.hive_sync.use_jdbc': 'false', 'hoodie.datasource.hive_sync.mode': 'hms' } df_products.write.format("hudi") \ .options(**hudi_options) \ .mode("overwrite") \ .save() ``` 1. Accordez à Lake Formation l'autorisation d'accéder au rôle IAM AWS Glue Job. Vous pouvez accorder des autorisations à partir de la console Lake Formation ou à l'aide de la AWS CLI. Pour plus d'informations, consultez la rubrique [Octroi d'autorisations de table via la console Lake Formation et la méthode de ressource nommée](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html) 1. Lisez la table Hudi enregistrée dans Lake Formation. Le code est le même que celui de la lecture d'une table Hudi non enregistrée. Notez que le rôle IAM de la tâche AWS Glue doit disposer de l'autorisation SELECT pour que la lecture réussisse. ``` val dataFrame = glueContext.getCatalogSource( database = "", tableName = "" ).getDataFrame() ``` 1. Écrire dans une table Hudi enregistrée dans Lake Formation. Le code est le même que celui de l'écriture dans une table Hudi non enregistrée. Notez que le rôle IAM de la tâche AWS Glue doit disposer de l'autorisation SUPER pour que l'écriture réussisse. ``` glueContext.getCatalogSink("", "", additionalOptions = JsonOptions(Map( "hoodie.table.name" -> "", "hoodie.database.name" -> "", "hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE", "hoodie.datasource.write.operation" -> "", "hoodie.datasource.write.recordkey.field" -> "", "hoodie.datasource.write.precombine.field" -> "", "hoodie.datasource.write.partitionpath.field" -> "", "hoodie.datasource.write.hive_style_partitioning" -> "true", "hoodie.datasource.hive_sync.enable" -> "true", "hoodie.datasource.hive_sync.database" -> "", "hoodie.datasource.hive_sync.table" -> "", "hoodie.datasource.hive_sync.partition_fields" -> "", "hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor", "hoodie.datasource.hive_sync.use_jdbc" -> "false", "hoodie.datasource.hive_sync.mode" -> "hms" ))) .writeDataFrame(dataFrame, glueContext) ``` # Utilisation du framework Delta Lake dans AWS Glue AWS Glue 3.0 et versions ultérieures prennent en charge le framework Delta Lake de la Linux Foundation. Delta Lake est un cadre de stockage de lac de données open source qui vous permet d'effectuer des transactions ACID, d'adapter la gestion des métadonnées et d'unifier le streaming et le traitement des données par lots. Cette rubrique décrit les fonctionnalités disponibles pour utiliser vos données dans AWS Glue lorsque vous transportez ou stockez vos données dans une table Delta Lake. Pour en savoir plus sur Delta Lake, consultez la [documentation officielle de Delta Lake](https://docs.delta.io/latest/delta-intro.html). Vous pouvez utiliser AWS Glue pour effectuer des opérations de lecture et d'écriture sur des tables Delta Lake dans Amazon S3, ou travailler avec des tables Delta Lake à l'aide du catalogue de données AWS Glue. Des opérations supplémentaires telles que l'insertion, la mise à jour et la [lecture et l'écriture de tables par lots](https://docs.delta.io/0.7.0/api/python/index.html) sont également prises en charge. Lorsque vous utilisez des tables Delta Lake, vous avez également la possibilité d'avoir recours à des méthodes de la bibliothèque Python de Delta Lake, telles que `DeltaTable.forPath`. Pour plus d’informations sur la bibliothèque Python de Delta Lake, consultez la documentation Python de Delta Lake. Le tableau suivant répertorie les versions de Delta Lake incluses dans chaque version de AWS Glue. **** | AWS Version Glue | Version de Delta Lake prise en charge | | --- | --- | | 5.1 | 3.3.2 | | 5.0 | 3.3.0 | | 4.0 | 2.1.0 | | 3.0 | 1.0.0 | Pour en savoir plus sur les frameworks de lacs de données pris en charge par AWS Glue, consultez[Utilisation de frameworks de lacs de données avec des tâches AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md). ## Activer Delta Lake pour AWS Glue Pour activer Delta Lake for AWS Glue, effectuez les tâches suivantes : + Spécifiez `delta` comme valeur pour le paramètre de tâche `--datalake-formats`. Pour de plus amples informations, veuillez consulter [Utilisation des paramètres des tâches dans les tâches AWS Glue](aws-glue-programming-etl-glue-arguments.md). + Créez une clé nommée `--conf` d'après votre tâche AWS Glue et définissez-la sur la valeur suivante. Vous pouvez également définir la configuration suivante à l'aide de `SparkConf` dans votre script. Ces paramètres permettent à Apache Spark de gérer correctement les tables Delta Lake. ``` spark.sql.extensions=io.delta.sql.DeltaSparkSessionExtension --conf spark.sql.catalog.spark_catalog=org.apache.spark.sql.delta.catalog.DeltaCatalog --conf spark.delta.logStore.class=org.apache.spark.sql.delta.storage.S3SingleDriverLogStore ``` + La prise en charge des autorisations Lake Formation pour les tables Delta est activée par défaut pour AWS Glue 4.0. Aucune configuration supplémentaire n'est nécessaire reading/writing pour les tables Delta enregistrées par To Lake Formation. Pour lire une table Delta enregistrée, le rôle IAM de la tâche AWS Glue doit disposer de l'autorisation SELECT. Pour écrire dans une table Delta enregistrée, le rôle IAM de la tâche AWS Glue doit disposer de l'autorisation SUPER. Pour en savoir plus sur la gestion des autorisations de Lake Formation, consultez la section [Octroi et révocation d'autorisations liées aux ressources du catalogue de données](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html). **Utilisation d'une autre version de Delta Lake** Pour utiliser une version de Delta Lake non prise en charge par AWS Glue, spécifiez vos propres fichiers JAR Delta Lake à l'aide du paramètre `--extra-jars` job. N'incluez pas `delta` comme valeur du paramètre de tâche `--datalake-formats`. Si vous utilisez AWS Glue 5.0 ou une version ultérieure, vous devez définir le paramètre de `--user-jars-first true` tâche. Dans cette situation, pour utiliser la bibliothèque Python de Delta Lake, vous devez spécifier les fichiers JAR de la bibliothèque à l'aide du paramètre de tâche `--extra-py-files`. La bibliothèque Python est fournie dans les fichiers JAR de Delta Lake. ## Exemple : écrire une table Delta Lake sur Amazon S3 et l'enregistrer dans le catalogue de données AWS Glue Le script AWS Glue ETL suivant montre comment écrire une table Delta Lake sur Amazon S3 et enregistrer la table dans le catalogue de données AWS Glue. ------ #### [ Python ] ``` # Example: Create a Delta Lake table from a DataFrame # and register the table to Glue Data Catalog additional_options = { "path": "s3://" } dataFrame.write \ .format("delta") \ .options(**additional_options) \ .mode("append") \ .partitionBy("") \ .saveAsTable(".") ``` ------ #### [ Scala ] ``` // Example: Example: Create a Delta Lake table from a DataFrame // and register the table to Glue Data Catalog val additional_options = Map( "path" -> "s3://" ) dataFrame.write.format("delta") .options(additional_options) .mode("append") .partitionBy("") .saveAsTable(".") ``` ------ ## Exemple : lecture d'une table Delta Lake depuis Amazon S3 à l'aide du catalogue de données AWS Glue Le script AWS Glue ETL suivant lit la table Delta Lake que vous avez créée dans[Exemple : écrire une table Delta Lake sur Amazon S3 et l'enregistrer dans le catalogue de données AWS Glue](#aws-glue-programming-etl-format-delta-lake-write). ------ #### [ Python ] Pour cet exemple, utilisez la méthode [create\$1data\$1frame.from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-catalog). ``` # Example: Read a Delta Lake table from Glue Data Catalog from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) df = glueContext.create_data_frame.from_catalog( database="", table_name="", additional_options=additional_options ) ``` ------ #### [ Scala ] Pour cet exemple, utilisez la méthode [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource). ``` // Example: Read a Delta Lake table from Glue Data Catalog import com.amazonaws.services.glue.GlueContext import org.apacke.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val df = glueContext.getCatalogSource("", "", additionalOptions = additionalOptions) .getDataFrame() } } ``` ------ ## Exemple : insérez un `DataFrame` dans une table Delta Lake dans Amazon S3 à l'aide du catalogue de données AWS Glue Cet exemple insère des données dans la table Delta Lake que vous avez créée dans [Exemple : écrire une table Delta Lake sur Amazon S3 et l'enregistrer dans le catalogue de données AWS Glue](#aws-glue-programming-etl-format-delta-lake-write). **Note** Dans cet exemple, vous devez définir le paramètre `--enable-glue-datacatalog` job afin d'utiliser le catalogue de données AWS Glue comme métastore Apache Spark Hive. Pour en savoir plus, veuillez consulter la section [Utilisation des paramètres des tâches dans les tâches AWS Glue](aws-glue-programming-etl-glue-arguments.md). ------ #### [ Python ] Pour cet exemple, utilisez la méthode [write\$1data\$1frame.from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_data_frame_from_catalog). ``` # Example: Insert into a Delta Lake table in S3 using Glue Data Catalog from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) glueContext.write_data_frame.from_catalog( frame=dataFrame, database="", table_name="", additional_options=additional_options ) ``` ------ #### [ Scala ] Pour cet exemple, utilisez la méthode [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink). ``` // Example: Insert into a Delta Lake table in S3 using Glue Data Catalog import com.amazonaws.services.glue.GlueContext import org.apacke.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getCatalogSink("", "", additionalOptions = additionalOptions) .writeDataFrame(dataFrame, glueContext) } } ``` ------ ## Exemple : lecture d'une table Delta Lake depuis Amazon S3 à l'aide de l'API Spark Cet exemple lit une table Delta Lake depuis Amazon S3 à l'aide de l'API Spark. ------ #### [ Python ] ``` # Example: Read a Delta Lake table from S3 using a Spark DataFrame dataFrame = spark.read.format("delta").load("s3://") ``` ------ #### [ Scala ] ``` // Example: Read a Delta Lake table from S3 using a Spark DataFrame val dataFrame = spark.read.format("delta").load("s3://") ``` ------ ## Exemple : écriture d'une table Delta Lake sur Amazon S3 à l'aide de Spark Cet exemple écrit une table Delta Lake sur Amazon S3 à l'aide de Spark. ------ #### [ Python ] ``` # Example: Write a Delta Lake table to S3 using a Spark DataFrame dataFrame.write.format("delta") \ .options(**additional_options) \ .mode("overwrite") \ .partitionBy("") .save("s3://") ``` ------ #### [ Scala ] ``` // Example: Write a Delta Lake table to S3 using a Spark DataFrame dataFrame.write.format("delta") .options(additionalOptions) .mode("overwrite") .partitionBy("") .save("s3://") ``` ------ ## Exemple : lecture et écriture d'une table Delta Lake avec contrôle des autorisations de Lake Formation Cet exemple lit et écrit dans une table Delta Lake avec contrôle des autorisations de Lake Formation. 1. Créez une table Delta et enregistrez-la dans Lake Formation 1. Pour activer le contrôle des autorisations de Lake Formation, vous devez d'abord enregistrer le chemin d'accès Amazon S3 de la table sur 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). Vous pouvez l'enregistrer depuis la console Lake Formation ou à l'aide de la AWS CLI : ``` aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region ``` Une fois que vous avez enregistré un emplacement Amazon S3, toute table AWS Glue pointant vers cet emplacement (ou l'un de ses emplacements enfants) renverra la valeur du `IsRegisteredWithLakeFormation` paramètre comme vraie lors de l'`GetTable`appel. 1. Créez une table Delta qui pointe vers le chemin Amazon S3 enregistré via Spark : **Note** Voici des exemples Python. ``` dataFrame.write \ .format("delta") \ .mode("overwrite") \ .partitionBy("") \ .save("s3://") ``` Une fois les données écrites sur Amazon S3, utilisez le robot AWS Glue pour créer une nouvelle table de catalogue Delta. Pour plus d'informations, voir [Présentation du support de table natif de Delta Lake avec les robots AWS Glue](https://aws.amazon.com/blogs/big-data/introducing-native-delta-lake-table-support-with-aws-glue-crawlers/). Vous pouvez également créer le tableau manuellement via l'`CreateTable`API AWS Glue. 1. Accordez à Lake Formation l'autorisation d'accéder au rôle IAM AWS Glue Job. Vous pouvez accorder des autorisations depuis la console Lake Formation ou utiliser la AWS CLI. Pour plus d'informations, consultez la rubrique [Octroi d'autorisations de table via la console Lake Formation et la méthode de ressource nommée](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html) 1. Lisez la table Delta enregistrée dans Lake Formation. Le code est le même que celui de la lecture d'une table Delta non enregistrée. Notez que le rôle IAM de la tâche AWS Glue doit disposer de l'autorisation SELECT pour que la lecture réussisse. ``` # Example: Read a Delta Lake table from Glue Data Catalog df = glueContext.create_data_frame.from_catalog( database="", table_name="", additional_options=additional_options ) ``` 1. Écrire dans une table Delta enregistrée dans Lake Formation. Le code est le même que celui de l'écriture dans une table Delta non enregistrée. Notez que le rôle IAM de la tâche AWS Glue doit disposer de l'autorisation SUPER pour que l'écriture réussisse. Par défaut, AWS Glue utilise `Append` le mode SaveMode. Vous pouvez le modifier en définissant l'option saveMode dans `additional_options`. Pour plus d'informations sur la prise en charge du mode SaveMode dans les tables Delta, consultez [Écrire dans une table](https://docs.delta.io/latest/delta-batch.html#write-to-a-table). ``` glueContext.write_data_frame.from_catalog( frame=dataFrame, database="", table_name="", additional_options=additional_options ) ``` # Utilisation du framework Iceberg dans Glue AWS AWS Glue 3.0 et versions ultérieures prennent en charge le framework Apache Iceberg pour les lacs de données. Iceberg fournit un format de table hautement performant qui fonctionne exactement comme une table SQL. Cette rubrique décrit les fonctionnalités disponibles pour utiliser vos données dans AWS Glue lorsque vous transportez ou stockez vos données dans une table Iceberg. Pour en savoir plus sur Iceberg, consultez la [documentation officielle d'Apache Iceberg](https://iceberg.apache.org/docs/latest/). Vous pouvez utiliser AWS Glue pour effectuer des opérations de lecture et d'écriture sur des tables Iceberg dans Amazon S3, ou travailler avec des tables Iceberg à l'aide du catalogue de données AWS Glue. Des opérations supplémentaires, notamment l’insertion et toutes les [requêtes Spark](https://iceberg.apache.org/docs/latest/spark-queries/) et [écritures Spark](https://iceberg.apache.org/docs/latest/spark-writes/), sont également prises en charge. La mise à jour n’est pas prise en charge pour les tables Iceberg. **Note** `ALTER TABLE … RENAME TO` n'est pas disponible pour Apache Iceberg 0.13.1 pour AWS Glue 3.0. Le tableau suivant répertorie les versions d'Iceberg incluses dans chaque version de AWS Glue. **** | AWS Version Glue | Version d'Iceberg prise en charge | | --- | --- | | 5.1 | 1.10.0 | | 5.0 | 1.7.1 | | 4.0 | 1.0.0 | | 3.0 | 0.13.1 | Pour en savoir plus sur les frameworks de lacs de données pris en charge par AWS Glue, consultez[Utilisation de frameworks de lacs de données avec des tâches AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md). ## Activation du cadre Iceberg Pour activer Iceberg for AWS Glue, effectuez les tâches suivantes : + Spécifiez `iceberg` comme valeur pour le paramètre de tâche `--datalake-formats`. Pour de plus amples informations, veuillez consulter [Utilisation des paramètres des tâches dans les tâches AWS Glue](aws-glue-programming-etl-glue-arguments.md). + Créez une clé nommée `--conf` d'après votre tâche AWS Glue et définissez-la sur la valeur suivante. Vous pouvez également définir la configuration suivante à l'aide de `SparkConf` dans votre script. Ces paramètres permettent à Apache Spark de gérer correctement les tables Iceberg. ``` spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions --conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog --conf spark.sql.catalog.glue_catalog.warehouse=s3:/// --conf spark.sql.catalog.glue_catalog.catalog-impl=org.apache.iceberg.aws.glue.GlueCatalog --conf spark.sql.catalog.glue_catalog.io-impl=org.apache.iceberg.aws.s3.S3FileIO ``` Si vous lisez ou écrivez sur des tables Iceberg enregistrées auprès de Lake Formation, suivez les instructions de AWS Glue 5.0 et versions ultérieures. [Utiliser AWS Glue with AWS Lake Formation pour un contrôle d'accès précis](security-lf-enable.md) Dans AWS Glue 4.0, ajoutez la configuration suivante pour activer la prise en charge de Lake Formation. ``` --conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true --conf spark.sql.catalog.glue_catalog.glue.id= ``` Si vous utilisez AWS Glue 3.0 avec Iceberg 0.13.1, vous devez définir les configurations supplémentaires suivantes pour utiliser le gestionnaire de verrouillage Amazon DynamoDB afin de garantir une transaction atomique. AWS Glue 4.0 ou version ultérieure utilise le verrouillage optimiste par défaut. Pour plus d'informations, consultez [Iceberg AWS Integrations](https://iceberg.apache.org/docs/latest/aws/#dynamodb-lock-manager) dans la documentation officielle d'Apache Iceberg. ``` --conf spark.sql.catalog.glue_catalog.lock-impl=org.apache.iceberg.aws.glue.DynamoLockManager --conf spark.sql.catalog.glue_catalog.lock.table= ``` **Utilisation d'une autre version d'Iceberg** Pour utiliser une version d'Iceberg non prise en charge par AWS Glue, spécifiez vos propres fichiers JAR Iceberg à l'aide du paramètre `--extra-jars` job. N'incluez pas `iceberg` comme valeur du paramètre `--datalake-formats`. Si vous utilisez AWS Glue 5.0 ou une version ultérieure, vous devez définir le paramètre de `--user-jars-first true` tâche. **Activation du chiffrement pour les tables Iceberg** **Note** Les tables Iceberg possèdent leurs propres mécanismes pour activer le chiffrement côté serveur. Vous devez activer cette configuration en plus de la configuration de sécurité de AWS Glue. Pour activer le chiffrement côté serveur sur les tables Iceberg, consultez les conseils de la [documentation d'Iceberg](https://iceberg.apache.org/docs/latest/aws/#s3-server-side-encryption). **Ajouter une configuration Spark pour les différentes régions Iceberg** Pour ajouter une configuration Spark supplémentaire pour l'accès aux tables interrégionales d'Iceberg avec le AWS Glue Data Catalog AWS Lake Formation, suivez les étapes ci-dessous : 1. Créez un [point d’accès multi-régions](https://docs.aws.amazon.com/AmazonS3/latest/userguide/multi-region-access-point-create-examples.html). 1. Définissez les propriétés Spark suivantes : ``` ----- --conf spark.sql.catalog.my_catalog.s3.use-arn-region-enabled=true \ --conf spark.sql.catalog.{CATALOG}.s3.access-points.bucket1", "arn:aws:s3:::accesspoint/.mrap \ --conf spark.sql.catalog.{CATALOG}.s3.access-points.bucket2", "arn:aws:s3:::accesspoint/.mrap ----- ``` ## Exemple : écrire une table Iceberg sur Amazon S3 et l'enregistrer dans le catalogue de données AWS Glue Cet exemple de script montre comment écrire dans une table Iceberg dans Amazon S3. L'exemple utilise [Iceberg AWS Integrations](https://iceberg.apache.org/docs/latest/aws/) pour enregistrer la table dans le catalogue de données AWS Glue. ------ #### [ Python ] ``` # Example: Create an Iceberg table from a DataFrame # and register the table to Glue Data Catalog dataFrame.createOrReplaceTempView("tmp_") query = f""" CREATE TABLE glue_catalog.. USING iceberg TBLPROPERTIES ("format-version"="2") AS SELECT * FROM tmp_ """ spark.sql(query) ``` ------ #### [ Scala ] ``` // Example: Example: Create an Iceberg table from a DataFrame // and register the table to Glue Data Catalog dataFrame.createOrReplaceTempView("tmp_") val query = """CREATE TABLE glue_catalog.. USING iceberg TBLPROPERTIES ("format-version"="2") AS SELECT * FROM tmp_ """ spark.sql(query) ``` ------ Vous pouvez également écrire dans une table Iceberg sur Amazon S3 et dans le catalogue de données à l'aide des méthodes Spark. Conditions préalables : vous devez créer un catalogue pour que la bibliothèque Iceberg puisse l'utiliser. Lorsque vous utilisez le AWS catalogue de données AWS Glue, Glue simplifie les choses. Le catalogue de données AWS Glue est préconfiguré pour être utilisé par les bibliothèques Spark en tant que`glue_catalog`. Les tables du catalogue de données sont identifiées par a *databaseName* et *tableName* a. Pour plus d'informations sur le catalogue de données AWS Glue, consultez[Découverte et catalogage des données dans AWS Glue](catalog-and-crawler.md). Si vous n'utilisez pas le catalogue de données AWS Glue, vous devrez approvisionner un catalogue via le Spark APIs. Pour plus d'informations, consultez [Spark Configuration](https://iceberg.apache.org/docs/latest/spark-configuration/) dans la documentation Iceberg. Cet exemple écrit une table Iceberg dans Amazon S3 et le catalogue de données à l'aide de Spark. ------ #### [ Python ] ``` # Example: Write an Iceberg table to S3 on the Glue Data Catalog # Create (equivalent to CREATE TABLE AS SELECT) dataFrame.writeTo("glue_catalog.databaseName.tableName") \ .tableProperty("format-version", "2") \ .create() # Append (equivalent to INSERT INTO) dataFrame.writeTo("glue_catalog.databaseName.tableName") \ .tableProperty("format-version", "2") \ .append() ``` ------ #### [ Scala ] ``` // Example: Write an Iceberg table to S3 on the Glue Data Catalog // Create (equivalent to CREATE TABLE AS SELECT) dataFrame.writeTo("glue_catalog.databaseName.tableName") .tableProperty("format-version", "2") .create() // Append (equivalent to INSERT INTO) dataFrame.writeTo("glue_catalog.databaseName.tableName") .tableProperty("format-version", "2") .append() ``` ------ ## Exemple : lecture d'une table Iceberg depuis Amazon S3 à l'aide du catalogue de données AWS Glue Cet exemple lit la table Iceberg que vous avez créée dans [Exemple : écrire une table Iceberg sur Amazon S3 et l'enregistrer dans le catalogue de données AWS Glue](#aws-glue-programming-etl-format-iceberg-write). ------ #### [ Python ] Pour cet exemple, utilisez la méthode `GlueContext.create\$1data\$1frame.from\$1catalog()`. ``` # Example: Read an Iceberg table from Glue Data Catalog from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) df = glueContext.create_data_frame.from_catalog( database="", table_name="", additional_options=additional_options ) ``` ------ #### [ Scala ] Pour cet exemple, utilisez la méthode [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource). ``` // Example: Read an Iceberg table from Glue Data Catalog import com.amazonaws.services.glue.GlueContext import org.apacke.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val df = glueContext.getCatalogSource("", "", additionalOptions = additionalOptions) .getDataFrame() } } ``` ------ ## Exemple : `DataFrame` insérer un dans une table Iceberg dans Amazon S3 à l'aide du catalogue de données AWS Glue Cet exemple insère des données dans la table Iceberg que vous avez créée dans [Exemple : écrire une table Iceberg sur Amazon S3 et l'enregistrer dans le catalogue de données AWS Glue](#aws-glue-programming-etl-format-iceberg-write). **Note** Dans cet exemple, vous devez définir le paramètre `--enable-glue-datacatalog` job afin d'utiliser le catalogue de données AWS Glue comme métastore Apache Spark Hive. Pour en savoir plus, veuillez consulter la section [Utilisation des paramètres des tâches dans les tâches AWS Glue](aws-glue-programming-etl-glue-arguments.md). ------ #### [ Python ] Pour cet exemple, utilisez la méthode `GlueContext.write\$1data\$1frame.from\$1catalog()`. ``` # Example: Insert into an Iceberg table from Glue Data Catalog from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) glueContext.write_data_frame.from_catalog( frame=dataFrame, database="", table_name="", additional_options=additional_options ) ``` ------ #### [ Scala ] Pour cet exemple, utilisez la méthode [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink). ``` // Example: Insert into an Iceberg table from Glue Data Catalog import com.amazonaws.services.glue.GlueContext import org.apacke.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getCatalogSink("", "", additionalOptions = additionalOptions) .writeDataFrame(dataFrame, glueContext) } } ``` ------ ## Exemple : lecture d'une table Iceberg depuis Amazon S3 à l'aide de Spark Conditions préalables : vous devez créer un catalogue pour que la bibliothèque Iceberg puisse l'utiliser. Lorsque vous utilisez le AWS catalogue de données AWS Glue, Glue simplifie les choses. Le catalogue de données AWS Glue est préconfiguré pour être utilisé par les bibliothèques Spark en tant que`glue_catalog`. Les tables du catalogue de données sont identifiées par a *databaseName* et *tableName* a. Pour plus d'informations sur le catalogue de données AWS Glue, consultez[Découverte et catalogage des données dans AWS Glue](catalog-and-crawler.md). Si vous n'utilisez pas le catalogue de données AWS Glue, vous devrez approvisionner un catalogue via le Spark APIs. Pour plus d'informations, consultez [Spark Configuration](https://iceberg.apache.org/docs/latest/spark-configuration/) dans la documentation Iceberg. Cet exemple lit une table Iceberg dans Amazon S3 à partir du catalogue de données à l'aide de Spark. ------ #### [ Python ] ``` # Example: Read an Iceberg table on S3 as a DataFrame from the Glue Data Catalog dataFrame = spark.read.format("iceberg").load("glue_catalog.databaseName.tableName") ``` ------ #### [ Scala ] ``` // Example: Read an Iceberg table on S3 as a DataFrame from the Glue Data Catalog val dataFrame = spark.read.format("iceberg").load("glue_catalog.databaseName.tableName") ``` ------ ## Exemple : lecture et écriture d'une table Iceberg avec contrôle des autorisations de Lake Formation Cet exemple lit et écrit dans une table Iceberg avec contrôle des autorisations de Lake Formation. **Note** Cet exemple ne fonctionne que dans AWS Glue 4.0. Dans AWS Glue 5.0 et versions ultérieures, suivez les instructions fournies dans[Utiliser AWS Glue with AWS Lake Formation pour un contrôle d'accès précis](security-lf-enable.md). 1. Créez une table Iceberg et enregistrez-la dans Lake Formation : 1. Pour activer le contrôle des autorisations de Lake Formation, vous devez d'abord enregistrer le chemin d'accès Amazon S3 de la table sur 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). Vous pouvez l'enregistrer depuis la console Lake Formation ou à l'aide de la AWS CLI : ``` aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region ``` Une fois que vous avez enregistré un emplacement Amazon S3, toute table AWS Glue pointant vers cet emplacement (ou l'un de ses emplacements enfants) renverra la valeur du `IsRegisteredWithLakeFormation` paramètre comme vraie lors de l'`GetTable`appel. 1. Créez une table Iceberg qui pointe vers le chemin enregistré via Spark SQL : **Note** Voici des exemples Python. ``` dataFrame.createOrReplaceTempView("tmp_") query = f""" CREATE TABLE glue_catalog.. USING iceberg AS SELECT * FROM tmp_ """ spark.sql(query) ``` Vous pouvez également créer le tableau manuellement via l'`CreateTable`API AWS Glue. Pour plus d'informations, consultez la section [Création de tables Apache Iceberg](https://docs.aws.amazon.com/lake-formation/latest/dg/creating-iceberg-tables.html). **Note** L’API `UpdateTable` ne prend actuellement pas en charge le format de table Iceberg en tant qu’entrée de l’opération. 1. Accordez à Lake Formation l'autorisation d'accéder au rôle IAM da la tâche. Vous pouvez accorder des autorisations à partir de la console Lake Formation ou à l'aide de la AWS CLI. Pour plus d'informations, voir : https://docs.aws.amazon.com/lake-formation/ latest/dg/granting -table-permissions.html 1. Lisez une table Iceberg enregistrée dans Lake Formation. Le code est le même que celui de la lecture d'une table Iceberg non enregistrée. Notez que le rôle IAM de votre job AWS Glue doit disposer de l'autorisation SELECT pour que la lecture réussisse. ``` # Example: Read an Iceberg table from the AWS Glue Data Catalog from awsglue.context import GlueContextfrom pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) df = glueContext.create_data_frame.from_catalog( database="", table_name="", additional_options=additional_options ) ``` 1. Écrivez dans une table Iceberg enregistrée dans Lake Formation. Le code est le même que celui de l'écriture dans une table Iceberg non enregistrée. Notez que le rôle IAM de votre tâche AWS Glue doit disposer de l'autorisation SUPER pour que l'écriture réussisse. ``` glueContext.write_data_frame.from_catalog( frame=dataFrame, database="", table_name="", additional_options=additional_options ) ``` ## Référence de configuration partagée Vous pouvez utiliser les valeurs `format_options` suivantes avec tout type de format. + `attachFilename` : une chaîne au format approprié à utiliser comme nom de colonne. Si vous fournissez cette option, le nom du fichier source de l'enregistrement sera ajouté à l'enregistrement. La valeur du paramètre sera utilisée comme nom de colonne. + `attachTimestamp` : une chaîne au format approprié à utiliser comme nom de colonne. Si vous fournissez cette option, l'heure de la modification du fichier source de l'enregistrement sera ajoutée à l'enregistrement. La valeur du paramètre sera utilisée comme nom de colonne.