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.
# Iceberg
[Apache Iceberg](https://iceberg.apache.org/) est un format de tableau ouvert pour les grands jeux de données dans Amazon Simple Storage Service (Amazon S3). Il fournit des performances de requête rapides sur de grandes tables, des validations atomiques, des écritures simultanées et une évolution de table compatible avec SQL. À partir d'Amazon EMR 6.5.0, vous pouvez utiliser Apache Spark 3 sur des clusters Amazon EMR au format de table Iceberg.
Le tableau suivant répertorie la version d’Iceberg incluse dans la dernière version d’Amazon EMR série 7.x, ainsi que les composants qu’Amazon EMR installe avec Iceberg.
Pour la version des composants installés avec Iceberg dans cette version, consultez la [version 7.12.0](emr-7120-release.md) Versions des composants.
**Informations sur la version d'Iceberg pour emr-7.12.0**
| Étiquette de version Amazon EMR | Version Iceberg | Composants installés avec Iceberg |
| --- | --- | --- |
| emr-7,12.0 | Iceberg 1.10.0-amzn-0 | Not available. |
Le tableau suivant répertorie la version d'Iceberg incluse dans la dernière version d'Amazon EMR série 6.x, ainsi que les composants qu'Amazon EMR installe avec Iceberg.
Pour connaître la version des composants installés avec Iceberg dans cette version, consultez les [versions des composants de la version 6.15.0](emr-6150-release.md).
**Informations sur la version d’Iceberg pour emr-6.15.0**
| Étiquette de version Amazon EMR | Version Iceberg | Composants installés avec Iceberg |
| --- | --- | --- |
| emr-6.15.0 | Iceberg 1.4.0-amzn-0 | Not available. |
**Topics**
+ [Comment fonctionne Iceberg](emr-iceberg-how-it-works.md)
+ [Utiliser un cluster avec Iceberg](emr-iceberg-use-cluster.md)
+ [Historique des versions d'Iceberg](Iceberg-release-history.md)
# Comment fonctionne Iceberg
Iceberg suit les fichiers de données individuels dans une table plutôt que dans des répertoires. Ainsi, les rédacteurs peuvent créer des fichiers de données sur place (les fichiers ne sont ni déplacés ni modifiés). De plus, les rédacteurs ne peuvent ajouter des fichiers à la table que dans le cadre d'un commit explicite. L'état de la table est conservé dans les fichiers de métadonnées. Toutes les modifications apportées à l'état de la table créent un nouveau fichier de métadonnées qui remplace automatiquement les anciennes métadonnées. Le fichier de métadonnées de table suit le schéma de la table, la configuration du partitionnement et d'autres propriétés.
Il inclut également des instantanés du contenu du tableau. Chaque instantané est un ensemble complet de fichiers de données figurant dans le tableau à un moment donné. Les instantanés sont répertoriés dans le fichier de métadonnées, mais les fichiers d'un instantané sont stockés dans des fichiers manifestes distincts. Les transitions atomiques d'un fichier de métadonnées de table à l'autre permettent d'isoler les instantanés. Les lecteurs utilisent l'instantané actuel lorsqu'ils ont chargé les métadonnées de la table. Les lecteurs ne sont pas affectés par les modifications tant qu'ils n'ont pas actualisé et sélectionné un nouvel emplacement de métadonnées. Les fichiers de données des instantanés sont stockés dans un ou plusieurs fichiers manifestes qui contiennent une ligne pour chaque fichier de données de la table, ses données de partition et ses métriques. Un instantané est l'union de tous les fichiers contenus dans ses manifestes. Les fichiers manifestes peuvent également être partagés entre les instantanés afin d'éviter de réécrire des métadonnées peu modifiées.
**Schéma d'instantané d'Iceberg**
![\[Schéma de deux instantanés. Chaque instantané possède sa propre liste de manifestes, qui stocke les métadonnées relatives à plusieurs manifestes réutilisables. Chaque manifeste fait référence à un ou plusieurs fichiers de données.\]](http://docs.aws.amazon.com/fr_fr/emr/latest/ReleaseGuide/images/Iceberg-snapshot-diagram.png)
Iceberg offre les fonctionnalités suivantes :
+ Prend en charge les transactions ACID et les voyages dans le temps dans votre lac de données Amazon S3.
+ Les nouvelles tentatives de validation bénéficient des avantages en termes de performances d'une [simultanéité optimiste](https://iceberg.apache.org/spec/#optimistic-concurrency).
+ La résolution des conflits au niveau des fichiers entraîne une forte simultanéité.
+ Avec des statistiques min-max par colonne dans les métadonnées, vous pouvez ignorer des fichiers, ce qui améliore les performances des requêtes sélectives.
+ Vous pouvez organiser les tables selon des configurations de partition flexibles, l'évolution des partitions permettant de mettre à jour les schémas de partition. Les requêtes et les volumes de données peuvent alors changer sans recourir à des répertoires physiques.
+ Prend en charge l'[évolution des schémas](https://iceberg.apache.org/docs/latest/evolution/#schema-evolution) et leur application.
+ Les tables Iceberg agissent comme des puits idempotents et des sources rejouables. Cela permet le streaming et le support par lots avec des pipelines uniques. Les récepteurs idempotents suivent les opérations d'écriture réussies dans le passé. Par conséquent, le récepteur peut à nouveau demander des données en cas de panne et supprimer des données si elles ont été envoyées plusieurs fois.
+ Consultez l'historique et le lignage, y compris l'évolution des tables, l'historique des opérations et les statistiques pour chaque validation.
+ Migrez depuis un jeu de données existant avec un choix de format de données (Parquet, ORC, Avro) et de moteur d'analyse (Spark, Trino, PrestoDB, Flink, Hive).
# Utiliser un cluster avec Iceberg
Cette section contient des informations sur l'utilisation d'Iceberg avec Spark, Trino, Flink et Hive.
# Utiliser un cluster Iceberg avec Spark
À partir de la version 6.5.0 d'Amazon EMR, vous pouvez utiliser Iceberg avec votre cluster Spark sans avoir à inclure d'actions de démarrage. Pour les versions 6.4.0 et antérieures d'Amazon EMR, vous pouvez utiliser une action d'amorçage pour préinstaller toutes les dépendances nécessaires.
Dans ce didacticiel, vous allez utiliser le AWS CLI pour travailler avec Iceberg sur un cluster Amazon EMR Spark. Pour utiliser la console afin de créer un cluster avec Iceberg installé, suivez les étapes de la section [Création d'un lac de données Apache Iceberg à l'aide d'Amazon Athena, d'Amazon EMR et d' AWS Glue](https://aws.amazon.com/blogs//big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
## Création d'un cluster Iceberg
Vous pouvez créer un cluster avec Iceberg installé à l'aide de l' AWS Management Console API, AWS CLI ou de l'API Amazon EMR. Dans ce didacticiel, vous allez utiliser le AWS CLI pour travailler avec Iceberg sur un cluster Amazon EMR. Pour utiliser la console afin de créer un cluster avec Iceberg installé, suivez les étapes de la section [Création d'un lac de données Apache Iceberg à l'aide d'Amazon Athena, d'Amazon EMR et d' AWS Glue](https://aws.amazon.com/blogs//big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
Pour utiliser Iceberg sur Amazon EMR avec AWS CLI le, créez d'abord un cluster en suivant les étapes suivantes. Pour plus d'informations sur la spécification de la classification des icebergs à l'aide du AWS CLI, voir [Fournissez une configuration à l'aide du AWS CLI lorsque vous créez un cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) ou[Fournir une configuration à l'aide du kit SDK Java lors de la création d'un cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk).
1. Créez un fichier `configurations.json` avec le contenu suivant :
```
[{
"Classification":"iceberg-defaults",
"Properties":{"iceberg.enabled":"true"}
}]
```
1. Créez ensuite un cluster à l'aide de la configuration suivante. Remplacez l'exemple de chemin de compartiment Amazon S3 et l'ID de sous-réseau par les vôtres.
```
aws emr create-cluster --release-label emr-6.5.0 \
--applications Name=Spark \
--configurations file://configurations.json \
--region us-east-1 \
--name My_Spark_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket/ \
--instance-type m5.xlarge \
--instance-count 2 \
--service-role EMR_DefaultRole_V2 \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,SubnetId=subnet-1234567890abcdef0
```
Vous pouvez également créer un cluster Amazon EMR incluant l'application Spark et inclure le fichier `/usr/share/aws/iceberg/lib/iceberg-spark3-runtime.jar` en tant que dépendance JAR dans une tâche Spark. Pour plus d'informations, consultez [Soumission d'applications](https://spark.apache.org/docs/latest/submitting-applications.html#submitting-applications).
Pour inclure le fichier jar en tant que dépendance dans une tâche Spark, ajoutez la propriété de configuration suivante à l'application Spark :
```
--conf "spark.jars=/usr/share/aws/iceberg/lib/iceberg-spark3-runtime.jar"
```
Pour plus d'informations sur les dépendances des tâches Spark, consultez la section [Gestion des dépendances](https://spark.apache.org/docs/latest/running-on-kubernetes.html#dependency-management) dans le document d'Apache Spark [Running Spark on Kubernetes](https://spark.apache.org/docs/latest/running-on-kubernetes.html).
## Initialisation d'une session Spark pour Iceberg
Les exemples suivants montrent comment lancer le shell Spark interactif, utiliser Spark submit ou utiliser Blocs-notes EMR pour travailler avec Iceberg sur Amazon EMR.
------
#### [ spark-shell ]
1. Connexion au nœud principal à l'aide de SSH Pour plus d'informations, consultez [Connexion au nœud principal à l'aide de SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) dans le *Guide de gestion d'Amazon EMR*.
1. Entrez la commande suivante pour lancer le shell Spark. Pour utiliser la PySpark coque, remplacez-la `spark-shell` par`pyspark`.
```
spark-shell \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket/prefix/
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
------
#### [ spark-submit ]
1. Connexion au nœud principal à l'aide de SSH Pour plus d'informations, consultez [Connexion au nœud principal à l'aide de SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) dans le *Guide de gestion d'Amazon EMR*.
1. Entrez la commande suivante pour lancer la session Spark pour Iceberg.
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
------
#### [ EMR Studio notebooks ]
Pour initialiser une session Spark à l'aide des blocs-notes EMR Studio, configurez votre session Spark à l'aide de la commande magique `%%configure` de votre bloc-notes Amazon EMR, comme dans l'exemple suivant. Pour plus d'informations, consultez [Utilisation des magies de Blocs-notes EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-magics.html#emr-magics) dans le *Guide de gestion Amazon EMR*.
```
%%configure -f{
"conf":{
"spark.sql.catalog.my_catalog":"org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.my_catalog.type":"glue",
"spark.sql.catalog.my_catalog.warehouse":"s3://amzn-s3-demo-bucket1/prefix/",
"spark.sql.defaultCatalog":"my_catalog",
"spark.sql.extensions":"org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions"
}
}
```
------
#### [ CLI ]
Pour initialiser un cluster Spark à l'aide de la CLI et définir toutes les configurations par défaut de session Spark Iceberg, exécutez l'exemple suivant. Pour plus d'informations sur la spécification d'une classification de configuration à l'aide de l'API Amazon EMR AWS CLI et Amazon EMR, consultez [Configurer](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps.html) les applications.
```
[
{
"Classification": "spark-defaults",
"Properties": {
"spark.sql.catalog.my_catalog":"org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.my_catalog.type":"glue",
"spark.sql.catalog.my_catalog.warehouse":"s3://amzn-s3-demo-bucket1/prefix/",
"spark.sql.defaultCatalog":"my_catalog",
"spark.sql.extensions":"org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions"
}
}
]
```
------
## Écriture dans une table Iceberg
L'exemple suivant montre comment créer un jeu de données Iceberg DataFrame et l'écrire sous forme de jeu de données. Les exemples illustrent l'utilisation des jeux de données à l'aide du shell Spark lorsque vous êtes connecté au nœud principal à l'aide de SSH comme utilisateur hadoop par défaut.
**Note**
Pour coller des exemples de code dans le shell Spark, tapez `:paste` à l'invite, collez l'exemple, puis appuyez sur `CTRL+D`.
------
#### [ PySpark ]
Spark inclut un shell basé sur Python, `pyspark`, que vous pouvez utiliser pour créer un prototype de programmes Spark écrits en Python. Invoquez `pyspark` sur le nœud principal.
```
## Create a DataFrame.
data = spark.createDataFrame([
("100", "2015-01-01", "2015-01-01T13:51:39.340396Z"),
("101", "2015-01-01", "2015-01-01T12:14:58.597216Z"),
("102", "2015-01-01", "2015-01-01T13:51:40.417052Z"),
("103", "2015-01-01", "2015-01-01T13:51:40.519832Z")
],["id", "creation_date", "last_update_time"])
## Write a DataFrame as a Iceberg dataset to the Amazon S3 location.
spark.sql("""CREATE TABLE IF NOT EXISTS dev.db.iceberg_table (id string,
creation_date string,
last_update_time string)
USING iceberg
location 's3://amzn-s3-demo-bucket/example-prefix/db/iceberg_table'""")
data.writeTo("dev.db.iceberg_table").append()
```
------
#### [ Scala ]
```
import org.apache.spark.sql.SaveMode
import org.apache.spark.sql.functions._
// Create a DataFrame.
val data = Seq(
("100", "2015-01-01", "2015-01-01T13:51:39.340396Z"),
("101", "2015-01-01", "2015-01-01T12:14:58.597216Z"),
("102", "2015-01-01", "2015-01-01T13:51:40.417052Z"),
("103", "2015-01-01", "2015-01-01T13:51:40.519832Z")
).toDF("id", "creation_date", "last_update_time")
// Write a DataFrame as a Iceberg dataset to the Amazon S3 location.
spark.sql("""CREATE TABLE IF NOT EXISTS dev.db.iceberg_table (id string,
creation_date string,
last_update_time string)
USING iceberg
location 's3://amzn-s3-demo-bucket/example-prefix/db/iceberg_table'""")
data.writeTo("dev.db.iceberg_table").append()
```
------
## Lecture à partir d'une table Iceberg
------
#### [ PySpark ]
```
df = spark.read.format("iceberg").load("dev.db.iceberg_table")
df.show()
```
------
#### [ Scala ]
```
val df = spark.read.format("iceberg").load("dev.db.iceberg_table")
df.show()
```
------
#### [ Spark SQL ]
```
SELECT * from dev.db.iceberg_table LIMIT 10
```
------
## Utilisation du catalogue AWS de données Glue avec Spark Iceberg
Vous pouvez vous connecter à AWS Glue Data Catalog depuis Spark Iceberg. Cette section présente les différentes commandes de connexion.
### Connectez-vous au catalogue AWS Glue par défaut dans votre région par défaut
Cet exemple montre comment se connecter à l'aide du type de catalogue Glue. Si vous ne spécifiez pas d'ID de catalogue, il utilise la valeur par défaut :
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
### Connectez-vous à un catalogue AWS Glue avec un identifiant de catalogue spécifique
Cet exemple montre comment se connecter à l'aide d'un identifiant de catalogue :
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.catalog.my_catalog.glue.id=AWS Glue catalog ID \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
Cette commande peut être utilisée pour se connecter à un catalogue AWS Glue dans un autre compte, à un catalogue RMS ou à un catalogue fédéré.
## Utilisation du catalogue REST (IRC) d'Iceberg avec Spark Iceberg
Les sections suivantes expliquent comment configurer l'intégration d'Iceberg à un catalogue.
### Connect to AWS Glue Data Catalog (point de terminaison IRC)
Voici un exemple de `spark-submit` commande pour utiliser Iceberg REST :
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=glue catalog ID \
--conf spark.sql.catalog.my_catalog.type=rest \
--conf spark.sql.catalog.my_catalog.uri=glue endpoint URI/iceberg \
--conf spark.sql.catalog.my_catalog.rest.sigv4-enabled=true \
--conf spark.sql.catalog.my_catalog.rest.signing-name=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
Pour l'utiliser sur un cluster activé pour les rôles d'exécution, les paramètres de configuration Spark supplémentaires suivants sont nécessaires :
```
"spark.hadoop.fs.s3.credentialsResolverClass": "software.amazon.glue.GlueTableCredentialsResolver",
"spark.hadoop.catalog-impl": "org.apache.iceberg.aws.glue.GlueCatalog",
"spark.hadoop.glue.id": glue catalog ID
"spark.hadoop.glue.endpoint": "glue endpoint"
```
Pour AWS la liste des URL des points de terminaison Glue pour chaque région, consultez la section [Points de terminaison et quotas de AWS Glue](https://docs.aws.amazon.com/general/latest/gr/glue.html).
### Connectez-vous à un point de terminaison IRC arbitraire
Voici un exemple de `spark-submit` commande pour utiliser un point de terminaison IRC :
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=warehouse name \
--conf spark.sql.catalog.my_catalog.type=rest \
--conf spark.sql.catalog.my_catalog.uri=your rest endpoint \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
## Différences de configuration entre Iceberg SparkCatalog et SparkSessionCatalog
Iceberg propose deux méthodes pour créer des catalogues Spark Iceberg. Vous pouvez définir la configuration de Spark sur l'une `SparkCatalog` ou l'autre sur`SparkSessionCatalog`.
### Utilisation d'Iceberg SparkCatalog
Voici la commande à utiliser **SparkCatalog**comme catalogue Spark Iceberg :
```
spark-shell \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog
```
Considérations relatives à cette approche :
+ Vous pouvez accéder aux tables Iceberg, mais pas aux autres tables.
+ Le nom du catalogue ne peut pas être **spark\$1catalog**. Il s'agit du nom du catalogue initial dans Spark. Il se connecte toujours à un métastore Hive. Il s'agit du catalogue par défaut dans Spark, sauf si l'utilisateur le remplace à l'aide `spark.sql.defaultCatalog` de.
+ Vous pouvez définir le nom `spark.sql.defaultCatalog` de votre catalogue pour en faire le catalogue par défaut.
### Utilisation d'Iceberg SparkSessionCatalog
Voici la commande à utiliser **SparkSessionCatalog**comme catalogue Spark Iceberg :
```
spark-shell \
--conf spark.sql.catalog.spark_catalog=org.apache.iceberg.spark.SparkSessionCatalog \
--conf spark.sql.catalog.spark_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.spark_catalog.type=glue
```
Considérations relatives à cette approche :
+ Si aucune table n'est trouvée sous forme de table Iceberg, Spark essaiera de voir s'il s'agit d'une table dans le métastore Hive. Voir [Utiliser le catalogue de données AWS Glue comme catalogue pour Hive](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-hive-metastore-glue.html) pour plus d'informations.
+ Le nom du catalogue doit être **spark\$1catalog**.
## Utilisation des extensions Iceberg Spark
Iceberg propose une extension Spark `org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions` que les utilisateurs peuvent définir via la configuration `spark.sql.extensions` des extensions Spark. Les extensions activent les fonctionnalités clés d'Iceberg, telles que DELETE, UPDATE et MERGE au niveau des lignes, les instructions et procédures du langage de définition des données Spark spécifiques à Iceberg, telles que le compactage, l'expiration des instantanés, le branchement et le balisage, etc. Consultez ce qui suit pour plus de détails :
+ Extensions d'écriture d'Iceberg Spark : [Spark](https://iceberg.apache.org/docs/nightly/spark-writes/) Writes
+ Extensions DDL Iceberg Spark : extensions SQL [ALTER TABLE](https://iceberg.apache.org/docs/nightly/spark-ddl/#alter-table-sql-extensions/)
+ Extensions de procédure Iceberg Spark : Procédures [Spark](https://iceberg.apache.org/docs/nightly/spark-ddl/#alter-table-sql-extensions/)
## Considérations relatives à l'utilisation d'Iceberg avec Spark
+ Amazon EMR 6.5.0 ne prend pas en charge l'exécution d'Iceberg sur Amazon EMR sur EKS par défaut. Une image personnalisée Amazon EMR 6.5.0 est disponible afin que vous puissiez la transmettre `--jars local:///usr/share/aws/iceberg/lib/iceberg-spark3-runtime.jar` en tant que paramètre `spark-submit` pour créer des tables Iceberg sur Amazon EMR sur EKS. Pour plus d'informations, consultez [Soumettre une charge de travail Spark dans Amazon EMR à l'aide d'une image personnalisée](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-steps.html#docker-custom-images-submit) dans le *Guide de développement Amazon EMR sur EKS*. Vous pouvez également nous contacter Support pour obtenir de l'aide. À partir d'Amazon EMR 6.6.0, Iceberg est pris en charge sur Amazon EMR sur EKS.
+ Lorsque vous utilisez AWS Glue comme catalogue pour Iceberg, assurez-vous que la base de données dans laquelle vous créez une table existe dans AWS Glue. Si vous utilisez des services tels que AWS Lake Formation et que vous ne parvenez pas à charger le catalogue, assurez-vous de disposer d'un accès approprié au service pour exécuter la commande.
+ Si vous utilisez Iceberg SparkSessionCatalog, comme décrit dans[Différences de configuration entre Iceberg SparkCatalog et SparkSessionCatalog](#emr-iceberg-spark-catalog), vous devez suivre les étapes de configuration décrites dans [Configurer le catalogue de données AWS Glue en tant que métastore Apache Hive](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-hive-metastore-glue.html), en plus de configurer les paramètres du catalogue de données Spark Iceberg Glue AWS .
# Utiliser un cluster Iceberg avec Trino
À partir de la version 6.6.0 d'Amazon EMR, vous pouvez utiliser Iceberg avec votre cluster Trino.
Dans ce didacticiel, vous allez utiliser le AWS CLI pour travailler avec Iceberg sur un cluster Amazon EMR Trino. Pour utiliser la console afin de créer un cluster avec Iceberg installé, suivez les étapes de la section [Création d'un lac de données Apache Iceberg à l'aide d'Amazon Athena, d'Amazon EMR et d' AWS Glue](https://aws.amazon.com/blogs//big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
## Création d'un cluster Iceberg
Pour utiliser Iceberg sur Amazon EMR avec AWS CLI le, créez d'abord un cluster en suivant les étapes suivantes. Pour plus d'informations sur la spécification de la classification des icebergs à l'aide du AWS CLI, voir [Fournissez une configuration à l'aide du AWS CLI lorsque vous créez un cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) ou[Fournir une configuration à l'aide du kit SDK Java lors de la création d'un cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk).
1. Créez un `configurations.json` fichier avec le contenu suivant. Par exemple, si vous souhaitez utiliser le métastore Hive comme catalogue, le contenu de votre fichier doit être le suivant.
```
[
{
"Classification": "trino-connector-iceberg",
"Properties": {
"connector.name": "iceberg",
"hive.metastore.uri": "thrift://localhost:9083"
}
}
]
```
Si vous souhaitez utiliser le AWS Glue Data Catalog comme boutique, le contenu de votre fichier doit être le suivant.
```
[
{
"Classification": "trino-connector-iceberg",
"Properties": {
"connector.name": "iceberg",
"iceberg.catalog.type": "glue"
}
}
]
```
À partir d'Amazon EMR 7.7.0, incluez la propriété *fs.native-s3.enabled=true*
```
[
{
"Classification": "trino-connector-iceberg",
"Properties": {
"connector.name": "iceberg",
"iceberg.catalog.type": "glue",
"fs.native-s3.enabled": "true"
}
}
]
```
1. Créez un cluster avec la configuration suivante, en remplaçant l'exemple de chemin de compartiment Amazon S3 et le nom de clé par les vôtres.
```
aws emr create-cluster --release-label emr-6.7.0 \
--applications Name=Trino \
--region us-east-1 \
--name My_Trino_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket \
--configurations file://configurations.json \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=c3.4xlarge InstanceGroupType=CORE,InstanceCount=3,InstanceType=c3.4xlarge \
--use-default-roles \
--ec2-attributes KeyName=
```
## Initialisation d'une session Trino pour Iceberg
Pour initialiser une session Trino, exécutez la commande suivante.
```
trino-cli --catalog iceberg
```
## Écriture dans une table Iceberg
Créez et écrivez dans votre table à l'aide des commandes SQL suivantes.
```
trino> SHOW SCHEMAS;
trino> CREATE TABLE default.iceberg_table (
id int,
data varchar,
category varchar)
WITH (
format = 'PARQUET',
partitioning = ARRAY['category', 'bucket(id, 16)'],
location = 's3://amzn-s3-demo-bucket/')
trino> INSERT INTO default.iceberg_table VALUES (1,'a','c1'), (2,'b','c2'), (3,'c','c3');
```
## Lire à partir d'une table pour Iceberg
Pour lire les données de votre table Iceberg, exécutez la commande suivante.
```
trino> SELECT * from default.iceberg_table;
```
## Considérations relatives à l'utilisation d'Iceberg avec Trino
+ Amazon EMR 6.5 ne prend pas en charge le catalogue Trino Iceberg pour Iceberg en mode natif. Trino a besoin d'Iceberg v0.11. Nous vous recommandons donc de lancer un cluster Amazon EMR pour Trino distinct du cluster Spark et d'inclure Iceberg v0.11 sur ce cluster.
+ Lorsque vous utilisez AWS Glue comme catalogue pour Iceberg, assurez-vous que la base de données dans laquelle vous créez une table existe dans AWS Glue. Si vous utilisez des services tels que AWS Lake Formation et que vous ne parvenez pas à charger le catalogue, assurez-vous de disposer d'un accès approprié au service pour exécuter la commande.
+ L'intégration d'Iceberg Glue ne fonctionne pas avec le catalogue Redshift Managed Storage.
# Utiliser un cluster Iceberg avec Flink
À partir de la version 6.9.0 d'Amazon EMR, vous pouvez utiliser Iceberg avec un cluster Flink sans avoir à effectuer les étapes de configuration requises lors de l'utilisation de l'intégration open source Iceberg Flink.
## Création d'un cluster Iceberg
Vous pouvez créer un cluster avec Iceberg installé en utilisant la AWS Management Console, l' AWS CLI ou l'API Amazon EMR. Dans ce didacticiel, vous allez utiliser le AWS CLI pour travailler avec Iceberg sur un cluster Amazon EMR. Pour utiliser la console afin de créer un cluster avec Iceberg installé, suivez les étapes de la section [Création d'un lac de données Apache Iceberg à l'aide d'Amazon Athena, d'Amazon EMR et d' AWS Glue](https://aws.amazon.com/blogs/big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
Pour utiliser Iceberg sur Amazon EMR avec AWS CLI le, créez d'abord un cluster en suivant les étapes suivantes. Pour plus d'informations sur la spécification de la classification des icebergs à l'aide du AWS CLI, voir [Fournissez une configuration à l'aide du AWS CLI lorsque vous créez un cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) ou[Fournir une configuration à l'aide du kit SDK Java lors de la création d'un cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk). Créez un fichier nommé `configurations.json` avec le contenu suivant :
```
[{
"Classification":"iceberg-defaults",
"Properties":{"iceberg.enabled":"true"}
}]
```
Créez ensuite un cluster avec la configuration suivante, en remplaçant les exemples de chemin de compartiment et d'ID de sous-réseau Amazon S3 par vos propres valeurs :
```
aws emr create-cluster --release-label emr-6.9.0 \
--applications Name=Flink \
--configurations file://iceberg_configurations.json \
--region us-east-1 \
--name My_flink_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket/ \
--instance-type m5.xlarge \
--instance-count 2 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,SubnetId=subnet-1234567890abcdef
```
Vous pouvez également créer un cluster Amazon EMR 6.9.0 contenant une application Flink et utiliser le fichier `/usr/share/aws/iceberg/lib/iceberg-flink-runtime.jar` comme dépendance JAR dans une tâche Flink.
## Utilisation du client Flink SQL
Le script du client SQL se trouve sous `/usr/lib/flink/bin`. Vous pouvez exécuter le script à l'aide de la commande suivante :
```
flink-yarn-session -d # starting the Flink YARN Session in detached mode
./sql-client.sh
```
Cela lance un Flink SQL Shell.
## Exemples de Flink
### Création d'une table Iceberg
**Flink SQL**
```
CREATE CATALOG glue_catalog WITH (
'type'='iceberg',
'warehouse'='',
'catalog-impl'='org.apache.iceberg.aws.glue.GlueCatalog',
'io-impl'='org.apache.iceberg.aws.s3.S3FileIO'
);
USE CATALOG glue_catalog;
CREATE DATABASE IF NOT EXISTS ;
USE ;
CREATE TABLE IF NOT EXISTS `glue_catalog`.``.`sample` (id int, data string);
```
**API de table**
```
EnvironmentSettings settings =
EnvironmentSettings.newInstance().inBatchMode().build();
TableEnvironment tEnv = TableEnvironment.create(settings);
String warehouse = "";
String db = "";
tEnv.executeSql(
"CREATE CATALOG glue_catalog WITH (\n"
+ " 'type'='iceberg',\n"
+ " 'warehouse'='"
+ warehouse
+ "',\n"
+ " 'catalog-impl'='org.apache.iceberg.aws.glue.GlueCatalog',\n"
+ " 'io-impl'='org.apache.iceberg.aws.s3.S3FileIO'\n"
+ " );");
tEnv.executeSql("USE CATALOG glue_catalog;");
tEnv.executeSql("CREATE DATABASE IF NOT EXISTS " + db + ";");
tEnv.executeSql("USE " + db + ";");
tEnv.executeSql(
"CREATE TABLE `glue_catalog`.`" + db + "`.`sample` (id bigint, data string);");
```
### Écriture dans une table Iceberg
**Flink SQL**
```
INSERT INTO `glue_catalog`.``.`sample` values (1, 'a'),(2,'b'),(3,'c');
```
**API de table**
```
tEnv.executeSql(
"INSERT INTO `glue_catalog`.`"
+ db
+ "`.`sample` values (1, 'a'),(2,'b'),(3,'c');");
```
**API Datastream**
```
final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
final StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);
String db = "";
String warehouse = "";
GenericRowData rowData1 = new GenericRowData(2);
rowData1.setField(0, 1L);
rowData1.setField(1, StringData.fromString("a"));
DataStream input = env.fromElements(rowData1);
Map props = new HashMap<();
props.put("type", "iceberg");
props.put("warehouse", warehouse);
props.put("io-impl", "org.apache.iceberg.aws.s3.S3FileIO");
CatalogLoader glueCatlogLoader =
CatalogLoader.custom(
"glue",
props,
new Configuration(),
"org.apache.iceberg.aws.glue.GlueCatalog");
TableLoader tableLoader =
TableLoader.fromCatalog(glueCatlogLoader, TableIdentifier.of(db, "sample"));
DataStreamSink dataStreamSink =
FlinkSink.forRowData(input).tableLoader(tableLoader).append();
env.execute("Datastream Write");
```
### Lecture à partir d'une table Iceberg
**Flink SQL**
```
SELECT * FROM `glue_catalog`.``.`sample`;
```
**API de table**
```
Table result = tEnv.sqlQuery("select * from `glue_catalog`.`" + db + "`.`sample`;");
```
**API Datastream**
```
final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
final StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);
String db = "";
String warehouse = "";
Map props = new HashMap<>();
props.put("type", "iceberg");
props.put("warehouse", warehouse);
props.put("io-impl", "org.apache.iceberg.aws.s3.S3FileIO");
CatalogLoader glueCatlogLoader =
CatalogLoader.custom(
"glue",
props,
new Configuration(),
"org.apache.iceberg.aws.glue.GlueCatalog");
TableLoader tableLoader =
TableLoader.fromCatalog(glueCatlogLoader, TableIdentifier.of(db, "sample"));
DataStream batch =
FlinkSource.forRowData().env(env).tableLoader(tableLoader).streaming(false).build();
batch.print().name("print-sink");
```
## Utilisation du catalogue Hive
Assurez-vous que les dépendances de Flink et Hive sont résolues comme décrit dans [Configuration de Flink avec Hive Metastore et Glue Catalog](flink-configure.md#flink-configure-hive).
## Exécution d'une tâche Flink
Une façon de soumettre une tâche à Flink consiste à utiliser une session Flink YARN par tâche. Vous pouvez le lancer à l'aide de la commande suivante :
```
sudo flink run -m yarn-cluster -p 4 -yjm 1024m -ytm 4096m $JAR_FILE_NAME
```
## Considérations relatives à l'utilisation d'Iceberg avec Flink
+ Lorsque vous utilisez AWS Glue comme catalogue pour Iceberg, assurez-vous que la base de données dans laquelle vous créez une table existe dans AWS Glue. Si vous utilisez des services tels que AWS Lake Formation et que vous ne parvenez pas à charger le catalogue, assurez-vous de disposer d'un accès approprié au service pour exécuter la commande.
+ L'intégration d'Iceberg Glue ne fonctionne pas avec le catalogue Redshift Managed Storage.
# Utiliser un cluster Iceberg avec Hive
Avec les versions 6.9.0 et ultérieures d'Amazon EMR, vous pouvez utiliser Iceberg avec un cluster Hive sans avoir à effectuer les étapes de configuration requises pour l'intégration Open Source d'Iceberg Hive. Pour les versions 6.8.0 et antérieures d'Amazon EMR, vous pouvez utiliser une action d'amorçage pour installer le JAR `iceberg-hive-runtime` afin de configurer le support de Hive for Iceberg.
Amazon EMR 6.9.0 inclut toutes les fonctionnalités nécessaires à l'[intégration de Hive 3.1.3 à Iceberg 0.14.1](https://iceberg.apache.org/releases/#0140-release) et inclut également des fonctionnalités supplémentaires d'Amazon EMR telles que la sélection automatique des moteurs d'exécution pris en charge lors de l'exécution (Amazon EMR sur EKS 6.9.0).
## Création d'un cluster Iceberg
Vous pouvez créer un cluster avec Iceberg installé à l'aide de l' AWS Management Console API, AWS CLI ou de l'API Amazon EMR. Dans ce didacticiel, vous allez utiliser le AWS CLI pour travailler avec Iceberg sur un cluster Amazon EMR. Pour utiliser la console afin de créer un cluster avec Iceberg installé, suivez les étapes de la section [Création d'un lac de données Iceberg à l'aide d'Amazon Athena, d'Amazon EMR et d' AWS Glue](https://aws.amazon.com/blogs/big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
Pour utiliser Iceberg sur Amazon EMR avec AWS CLI le, créez d'abord un cluster en suivant les étapes ci-dessous. Pour plus d'informations sur la spécification de la classification Iceberg à l'aide du SDK Java AWS CLI ou du SDK Java, consultez [Fournissez une configuration à l'aide du AWS CLI lorsque vous créez un cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) ou. [Fournir une configuration à l'aide du kit SDK Java lors de la création d'un cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk) Créez un fichier nommé `configurations.json` avec le contenu suivant:
```
[{
"Classification":"iceberg-defaults",
"Properties":{"iceberg.enabled":"true"}
}]
```
Créez ensuite un cluster avec la configuration suivante, en remplaçant l'exemple de chemin de compartiment Amazon S3 et l'ID de sous-réseau par les vôtres :
```
aws emr create-cluster --release-label emr-6.9.0 \
--applications Name=Hive \
--configurations file://iceberg_configurations.json \
--region us-east-1 \
--name My_hive_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket/ \
--instance-type m5.xlarge \
--instance-count 2 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,SubnetId=subnet-1234567890abcdef
```
Un cluster Hive Iceberg effectue les opérations suivantes :
+ Charge le fichier JAR d'exécution Iceberg Hive dans Hive et active la configuration associée à Iceberg pour le moteur Hive.
+ Active la sélection dynamique du moteur d'exécution d'Amazon EMR Hive afin d'empêcher les utilisateurs de configurer le moteur d'exécution pris en charge pour la compatibilité avec Iceberg.
**Note**
Les clusters Hive Iceberg ne sont actuellement pas compatibles avec AWS Glue Data Catalog. Le catalogue Iceberg par défaut est `HiveCatalog`, ce qui correspond au métastore configuré pour l'environnement Hive. Pour plus d'informations sur la gestion des catalogues, consultez la section [Utilisation HCatalog](https://cwiki.apache.org/confluence/display/Hive/HCatalog+UsingHCat#HCatalogUsingHCat-UsingHCatalog) dans la [documentation d'Apache Hive](https://cwiki.apache.org/confluence/display/HIVE).
## Prise en charge des fonctionnalités
Amazon EMR 6.9.0 prend en charge Hive 3.1.3 et Iceberg 0.14.1. La prise en charge des fonctionnalités est limitée aux fonctionnalités compatibles avec Iceberg pour Hive 3.1.2 et 3.1.3. Les commandes suivantes sont prises en charge :
+ Avec les versions 6.9.0 à 6.12.x d'Amazon EMR, vous devez inclure le fichier jar `libfb303` dans le répertoire `auxlib` Hive. Utilisez la commande suivante pour l'inclure :
```
sudo /usr/bin/ln -sf /usr/lib/hive/lib/libfb303-*.jar /usr/lib/hive/auxlib/libfb303.jar
```
Avec les versions 6.13 et ultérieures d'Amazon EMR, le fichier jar `libfb303` est automatiquement lié symboliquement au répertoire `auxlib` Hive.
+ **Création d'une table**
+ **Table non partitionnée** – Les tables externes dans Hive peuvent être créées en fournissant le gestionnaire de stockage comme suit :
```
CREATE EXTERNAL TABLE x (i int) STORED BY 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler'
```
+ **Table partitionnée** – Les tables partitionnées externes dans Hive peuvent être créées comme suit :
```
CREATE EXTERNAL TABLE x (i int) PARTITIONED BY (j int) STORED BY 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler'
```
**Note**
Le format de `STORED AS` fichier de n'ORC/AVRO/PARQUETest pas pris en charge dans Hive 3. La seule option par défaut est Parquet.
+ **Suppression d'une table** – La commande `DROP TABLE` est utilisée pour supprimer des tables, comme dans l'exemple suivant :
```
DROP TABLE [IF EXISTS] table_name [PURGE];
```
+ **Lecture d'un tableau** : Les instructions `SELECT` peuvent être utilisées pour lire les tables Iceberg dans Hive, comme dans l'exemple suivant. Les moteurs d'exécution pris en charge sont MR et Tez.
```
SELECT * FROM table_name
```
Pour plus d'informations sur la syntaxe de sélection de Hive, voir [LanguageManual Select](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Select). Pour plus d'informations sur les instructions select associées aux tables Iceberg dans Hive, consultez [Apache Iceberg Select](https://iceberg.apache.org/docs/latest/hive/#select).
+ **Insertion dans une table** – L'instruction de HiveQL `INSERT INTO` fonctionne sur les tables Iceberg avec le support du moteur d'exécution Map Reduce uniquement. Les utilisateurs d'Amazon EMR n'ont pas besoin de définir explicitement le moteur d'exécution, car Amazon EMR Hive sélectionne le moteur pour Iceberg Tables au moment de l'exécution.
+ **Insert into d'une seul tableau** – Exemple :
```
INSERT INTO table_name VALUES ('a', 1);
INSERT INTO table_name SELECT...;
```
+ **Insert into multitables** – Les instructions d'insertion multitables non atomiques dans des instructions sont prises en charge. Exemple :
```
FROM source
INSERT INTO table_1 SELECT a, b
INSERT INTO table_2 SELECT c,d;
```
À partir d'Amazon EMR 7.3.0, Hive with Iceberg prend en charge le catalogue de données AWS Glue en tant que métastore. Pour utiliser le catalogue de données AWS Glue comme métastore, définissez la propriété suivante.
```
SET iceberg.catalog..catalog-impl=org.apache.iceberg.aws.glue.GlueCatalog;
```
Vous pouvez également définir la propriété suivante.
```
SET iceberg.catalog..type=glue;
```
Vous pouvez ensuite créer une table à l'aide de l'exemple suivant.
```
CREATE EXTERNAL TABLE table_name (col1 type1, col2 type2,..)
ROW FORMAT SERDE 'org.apache.iceberg.mr.hive.HiveIcebergSerDe'
STORED BY 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler'
location ''
TBLPROPERTIES ('table_type'='iceberg', 'iceberg.catalog'='');
```
## Considérations relatives à l'utilisation d'Iceberg avec Hive
+ Iceberg prend en charge les types de requêtes suivants :
+ Create table
+ Drop table
+ Insérer dans la table
+ Lire la table
+ Seul le moteur d'exécution MR (MapReduce) est pris en charge pour les opérations DML (langage de manipulation de données), et le MR est obsolète dans Hive 3.1.3.
+ Pour Amazon EMR antérieur à la version 7.3.0, AWS Glue Data Catalog n'est actuellement pas compatible avec Iceberg with Hive.
+ La gestion des erreurs n'est pas suffisamment robuste. En cas de mauvaise configuration, les insertions dans les requêtes peuvent se terminer correctement. Cependant, le fait de ne pas mettre à jour les métadonnées peut entraîner des pertes de données.
+ L'intégration d'Iceberg Glue ne fonctionne pas avec le catalogue Redshift Managed Storage.
# Historique des versions d'Iceberg
Le tableau suivant répertorie les versions d'Iceberg incluses dans chaque version d'Amazon EMR, ainsi que les composants installés avec l'application. Pour connaître les versions des composants de chaque version, consultez la section Version des composants de votre version dans [Versions Amazon EMR 7.x](emr-release-7x.md), [Versions Amazon EMR 6.x](emr-release-6x.md) ou [Versions Amazon EMR 5.x](emr-release-5x.md).
**Informations sur les versions d'Iceberg**
| Étiquette de version Amazon EMR | Version Iceberg | Composants installés avec Iceberg |
| --- | --- | --- |
| emr-7,12.0 | 1.10.0-amzn-0 | Not available. |
| emr-7.11.0 | 1.9.1-amzn-0 | Not available. |
| emr-7.10.0 | 1.8.1-amzn-0 | Not available. |
| emr-7.9.0 | 1.7.1-amzn-2 | Not available. |
| emr-7,8.0 | 1.7.1-amzn-1 | Not available. |
| emr-7,7.0 | 1.7.1-amzn-0 | Not available. |
| emr-7.6.0 | 1.6.1-amzn-2 | Not available. |
| emr-7.5.0 | 1.6.1-amzn-1 | Not available. |
| emr-7.4.0 | 1.6.1-amzn-0 | Not available. |
| emr-7.3.0 | 1.5.2-amzn-0 | Not available. |
| emr-7.2.0 | 1,5.0-amzn-0 | Not available. |
| emr-7.1.0 | 1.4.3-amzn-0 | Not available. |
| emr-7.0.0 | 1.4.2-amzn-0 | Not available. |
| emr-6.15.0 | 1.4.0-amzn-0 | Not available. |
| emr-6.14.0 | 1.3.1-amzn-0 | Not available. |
| emr-6.13.0 | 1.3.0-amzn-1 | Not available. |
| emr-6.12.0 | 1.3.0-amzn-0 | Not available. |
| emr-6.11.1 | 1.2.0-amzn-0 | Not available. |
| emr-6.11.0 | 1.2.0-amzn-0 | Not available. |
| emr-6.10.1 | 1.1.0-amzn-0 | Not available. |
| emr-6.10.0 | 1.1.0-amzn-0 | Not available. |
| emr-6.9.1 | 0.14.1-amzn-0 | Not available. |
| emr-6.9.0 | 0.14.1-amzn-0 | Not available. |
| emr-6.8.1 | 0.14.0-amzn-0 | Not available. |
| emr-6.8.0 | 0.14.0-amzn-0 | Not available. |
| emr-6.7.0 | 0.13.1-amzn-0 | Not available. |
| emr-6.6.0 | 0.13.1 | Not available. |
| emr-6.5.0 | 0.12.0 | Not available. |
# Notes de mise à jour d'Iceberg par version
+ [Amazon EMR 6.9.0 - Notes de mise à jour d'Iceberg](Iceberg-release-history-690.md)
# Amazon EMR 6.9.0 - Notes de mise à jour d'Iceberg
## Amazon EMR 6.9.0 - Changements apportés par Iceberg
| Type | Description |
| --- | --- |
| Fonctionnalité | Intégration d'Amazon EMR Flink à Iceberg. |
| Fonctionnalité | Intégration de Hive d'Amazon EMR avec Iceberg. |
| Fonctionnalité | Support pour mettre en cache les fichiers de métadonnées Iceberg sur Amazon FSx pour Lustre afin d'améliorer le temps de planification des requêtes. |
| Rétroportage | [PR 5050](https://github.com/apache/iceberg/pull/5050) : Flink 1.15 : Support des options d'écriture dans les commentaires SQL d'insertion en ligne. |
| Rétroportage | [PR 5282](https://github.com/apache/iceberg/pull/5282) : AWS : Corrigez les échecs de nouvelle tentative PUT en ouvrant de nouveaux flux de fichiers de données. |
| Rétroportage | [PR 5318](https://github.com/apache/iceberg/pull/5318) : Flink 1.15 : Combler le fossé entre FlinkSource et IcebergSource (FLIP-27) et ajout d'une configuration opt-in pour utiliser la source FLIP-27 dans Flink SQL. |
| Rétroportage | [PR 5344](https://github.com/apache/iceberg/pull/5344) : Flink 1.14 : Combler le fossé entre FlinkSource et IcebergSource (FLIP-27) et ajout d'une configuration opt-in pour utiliser la source FLIP-27 dans Flink SQL. |
| Rétroportage | [PR 5393](https://github.com/apache/iceberg/pull/5393) : Flink 1.14, 1.15 : évitez de convertir les métriques Iceberg en Flink dans le lecteur MetricContext de source FLIP-27. |
| Rétroportage | [PR 5401](https://github.com/apache/iceberg/pull/5401) : Flink 1.14, 1.15 : IcebergSourceReader groupe manquant dans PR \$15393 pour les métriques du lecteur de source FLIP-27. |
| Rétroportage | [PR 5679](https://github.com/apache/iceberg/pull/5679) : Spark 3.2, 3.3 : correction de la propagation de nullabilité pour le nœud. MergeRows |
| Rétroportage | [PR 5860](https://github.com/apache/iceberg/pull/5860) : Spark 3.3 : Correctif QueryFailure lors de l'exécution RewriteManifestProcedure sur des tables partitionnées par Date. |
| Rétroportage | [PR 5880](https://github.com/apache/iceberg/pull/5880) : Spark 3.3 : correction de la nullité dans les projections. merge-on-read |
| Rétroportage | [PR 5917](https://github.com/apache/iceberg/pull/5917) : Spark 3.2 : correction de la nullité dans les projections. merge-on-read |