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