Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation de 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.
[](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
)
```