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.
# Hudi
[Apache Hudi](https://hudi.apache.org/) est une infrastructure de gestion des données open source utilisée pour simplifier le traitement des données incrémentielles et le développement de pipelines de données en fournissant des fonctionnalités d'insertion, de mise à jour, de mise à jour/insertion et de suppression au niveau de l'enregistrement. *Mise à jour/insertion* fait référence à la capacité à insérer des enregistrements dans un ensemble de données existant s'ils n'existent pas déjà ou de les mettre à jour s'ils existent. En gérant efficacement la façon dont les données sont présentées dans Amazon S3, Hudi permet d'ingérer et de mettre à jour des données quasiment en temps réel. Hudi gère soigneusement les métadonnées des actions effectuées sur l'ensemble de données pour faire en sorte que les actions soient atomiques et cohérentes.
Hudi est intégré à [Apache Spark](https://aws.amazon.com/emr/features/spark/), [Apache Hive](https://hive.apache.org/) et [Presto](https://prestodb.github.io). Dans les versions 6.1.0 et ultérieures d'Amazon EMR, Hudi est également intégré à [Trino (PrestoSQL)](https://trino.io/).
Avec la version 5.28.0 d'Amazon EMR et les versions ultérieures, EMR installe les composants Hudi par défaut lorsque Spark, Hive, Presto ou Flink sont installés. Vous pouvez utiliser Spark ou l' DeltaStreamer utilitaire Hudi pour créer ou mettre à jour des ensembles de données Hudi. Vous pouvez utiliser Hive, Spark, Presto ou Flink pour interroger un jeu de données Hudi de manière interactive ou créer des pipelines de traitement de données à l'aide de l'*extraction incrémentielle*. L'extraction incrémentielle fait référence à la possibilité d'extraire uniquement les données qui ont changé entre deux actions.
Ces fonctionnalités rendent Hudi adapté pour les cas d'utilisation suivants :
+ Utilisation des données de streaming provenant de capteurs et d'autres appareils IoT (Internet des objets) nécessitant des événements d'insertion et de mise à jour spécifiques.
+ Conformité aux règles de confidentialité des données dans des applications où les utilisateurs peuvent choisir d'être oubliés ou modifier leur consentement quant à la manière dont leurs données peuvent être utilisées.
+ Implémentation d'un [système de capture des données modifiées (CDC)](https://en.wikipedia.org/wiki/Change_data_capture) qui vous permet d'appliquer des modifications à un ensemble de données au fil du temps.
Le tableau suivant répertorie la version de Hudi incluse dans la dernière version d’Amazon EMR série 7.x, ainsi que les composants qu’Amazon EMR installe avec Hudi.
Pour la version des composants installés avec Hudi dans cette version, voir la [version 7.12.0](emr-7120-release.md) Versions des composants.
**Informations sur la version Hudi pour emr-7.12.0**
| Étiquette de version Amazon EMR | Version Hudi | Composants installés avec Hudi |
| --- | --- | --- |
| emr-7,12.0 | Hudi 1.0.2-amzn-1 | Not available. |
Le tableau suivant répertorie la version de Hudi incluse dans la dernière version d'Amazon EMR série 6.x, ainsi que les composants qu'Amazon EMR installe avec Hudi.
Pour connaître la version des composants installés avec Hudi dans cette version, consultez les [versions des composants de la version 6.15.0](emr-6150-release.md).
**Informations sur la version de Hudi pour emr-6.15.0**
| Étiquette de version Amazon EMR | Version Hudi | Composants installés avec Hudi |
| --- | --- | --- |
| emr-6.15.0 | Hudi 0.14.0-amzn-0 | Not available. |
**Note**
La version 6.8.0 d'Amazon EMR est fournie avec [Apache Hudi](https://hudi.apache.org/) 0.11.1 ; toutefois, les clusters Amazon EMR 6.8.0 sont également compatibles avec le `hudi-spark3.3-bundle_2.12` open source de Hudi 0.12.0.
Le tableau suivant répertorie la version de Hudi incluse dans la dernière version d'Amazon EMR série 5.x, ainsi que les composants qu'Amazon EMR installe avec Hudi.
Pour la version des composants installés avec Hudi dans cette version, voir la [version 5.36.2](emr-5362-release.md) Versions des composants.
**Informations sur la version Hudi pour emr-5.36.2**
| Étiquette de version Amazon EMR | Version Hudi | Composants installés avec Hudi |
| --- | --- | --- |
| emr-5.36.2 | Hudi 0.10.1-amzn-1 | Not available. |
**Topics**
+ [Comment fonctionne Hudi](emr-hudi-how-it-works.md)
+ [Considérations et limitations pour l'utilisation de Hudi sur Amazon EMR](emr-hudi-considerations.md)
+ [Créez un cluster avec Hudi installé](emr-hudi-installation-and-configuration.md)
+ [Travailler avec un jeu de données Hudi](emr-hudi-work-with-dataset.md)
+ [Utiliser la CLI Hudi](emr-hudi-cli.md)
+ [Historique des sorties de Hudi](Hudi-release-history.md)
# Comment fonctionne Hudi
Lorsque vous utilisez Hudi avec Amazon EMR, vous pouvez écrire des données dans l'ensemble de données à l'aide de l'API Spark Data Source ou de l' DeltaStreamer utilitaire Hudi. Hudi organise un jeu de données dans une structure de répertoire partitionnée sous `basepath` qui est similaire à une table Hive traditionnelle. Les spécificités de la façon dont les données sont présentées en tant que fichiers dans ces répertoires dépendent du type d'ensemble de données que vous choisissez. Vous pouvez choisir CoW (Copy on Write, copie sur écriture) ou MoR (Merge on Read, fusion sur lecture).
Quel que soit le type d'ensemble de données, chaque partition d'un ensemble de données est identifiée de manière unique par son chemin `partitionpath` relatif au chemin `basepath`. Au sein de chaque partition, les enregistrements sont répartis dans plusieurs fichiers de données. Pour de plus amples informations, veuillez consulter [File management](https://hudi.apache.org/docs/concepts.html#file-management) dans la documentation Apache Hudi.
Chaque action dans Hudi est associée à un commit correspondant, identifié par un horodatage croissant de façon monotone appelé *Instant*. Hudi conserve une série de toutes les actions effectuées sur le jeu de données sous forme de chronologie. Hudi s'appuie sur la chronologie pour isoler instantanément les lecteurs et les rédacteurs, et pour permettre de revenir à un point antérieur dans le temps. Pour plus d'informations sur les actions enregistrées par Hudi et l'état des actions, consultez [Timeline](https://hudi.apache.org/docs/concepts.html#timeline) dans la documentation Apache Hudi.
## Comprendre les types de stockage des jeux de données : copie en écriture ou fusion en lecture
Lorsque vous créez un jeu de données Hudi, vous spécifiez que celui-ci doit être copié en écriture ou fusionné en lecture.
+ **Copie sur écriture (CoW)** – Les données sont stockées dans un format en colonnes (Parquet) et chaque mise à jour crée une nouvelle version des fichiers lors d'une écriture. CoW est le type de stockage par défaut.
+ **Fusion sur lecture (MoR)** – Les données sont stockées en utilisant une combinaison de formats en colonnes (Parquet) et en lignes (Avro). Les mises à jour sont consignées dans des fichiers *delta* basés sur les lignes et sont compressées si nécessaire pour créer de nouvelles versions des fichiers en colonnes.
Avec les ensembles de données CoW, chaque fois qu’une mise à jour est apportée à un enregistrement, le fichier qui contient l’enregistrement est réécrit avec les valeurs mises à jour. Avec un jeu de données MoR, chaque fois qu’une mise à jour a lieu, Hudi écrit uniquement la ligne du registre modifié. Le type de stockage MoR est mieux adapté aux charges de travail donnant lieu à de nombreuses écritures ou modifications avec moins de lectures. Le type de stockage CoW est mieux adapté aux charges de travail donnant lieu à de nombreuses lectures sur des données qui changent moins souvent.
Hudi fournit trois vues logiques pour l'accès aux données :
+ **Vue optimisée en lecture** – Fournit le dernier ensemble de données validé de tables CoW et le dernier jeu de données compressé de tables MoR.
+ **Vue incrémentielle** – Fournit un flux de modification entre deux actions d'un ensemble de données CoW pour alimenter les tâches et les flux de travail ETL (extraction, transformation et chargement) en aval.
+ **Vue en temps réel** – Fournit les dernières données validées d'une table de MoR en fusionnant en ligne les fichiers de colonnes et les fichiers basés sur des lignes.
Lorsque vous interrogez la vue optimisée en lecture, la requête renvoie toutes les données compressées mais n'inclut pas les dernières validations delta. L'interrogation de ces données fournit de bonnes performances de lecture, mais ignore les données les plus à jour. Lorsque vous interrogez la vue en temps réel, Hudi fusionne les données compressées avec les validations delta sur lecture. Les données les plus à jour sont disponibles pour interrogation, mais la surcharge de calcul de la fusion rend la requête moins performante. La possibilité d'interroger des données compressées ou des données en temps réel vous permet de choisir entre performances et flexibilité lorsque vous exécutez des requêtes.
Pour plus d'informations sur les avantages et inconvénients des types de stockage, consultez [Storage Types & Views](https://hudi.apache.org/docs/concepts.html#storage-types--views) dans la documentation Apache Hudi.
Hudi crée deux tables dans le metastore Hive pour le type de stockage MoR : une table avec le nom que vous avez spécifié, qui est une vue optimisée en lecture, et une table avec le même nom auquel est ajouté `_rt`, qui est une vue en temps réel. Vous pouvez interroger les deux tables.
## Enregistrement d'un jeu de données Hudi auprès de votre métastore
Lorsque vous enregistrez une table Hudi auprès du metastore Hive, vous pouvez interroger des tables Hudi à l'aide de Hive, Spark SQL ou Presto comme vous le feriez pour n'importe quelle autre table. En outre, vous pouvez intégrer Hudi à AWS Glue en configurant Hive et Spark pour utiliser le catalogue de données AWS Glue comme métastore. Pour les tables MoR, Hudi enregistre le jeu de données sous la forme de deux tables dans le metastore : une table avec le nom que vous avez spécifié, qui est une vue optimisée en lecture, et une table avec le même nom auquel est ajouté `_rt`, qui est une vue en temps réel.
Vous enregistrez une table Hudi auprès du metastore Hive lorsque vous utilisez Spark pour créer un jeu de données Hudi en définissant l'option `HIVE_SYNC_ENABLED_OPT_KEY` sur `"true"` et en fournissant d'autres propriétés requises. Pour de plus amples informations, veuillez consulter [Travailler avec un jeu de données Hudi](emr-hudi-work-with-dataset.md). En outre, vous pouvez utiliser l'utilitaire de ligne de commande hive\$1sync\$1tool pour enregistrer un jeu de données Hudi en tant que table dans votre metastore, séparément.
# Considérations et limitations pour l'utilisation de Hudi sur Amazon EMR
+ **Le champ de clé d'enregistrement ne peut pas être nul ou vide** – Le champ que vous spécifiez comme champ de clé d'enregistrement ne peut pas avoir des valeurs `null` ou vides.
+ **Schéma mis à jour par défaut lors de l'insertion et de l'insertion** — Hudi fournit une interface `HoodieRecordPayload` qui détermine comment le jeu de données Hudi en entrée DataFrame et le jeu de données Hudi existant sont fusionnés pour produire un nouveau jeu de données mis à jour. Hudi fournit une implémentation par défaut de cette classe`OverwriteWithLatestAvroPayload`, qui remplace les enregistrements existants et met à jour le schéma tel que spécifié dans l'entrée. DataFrame Pour personnaliser cette logique en vue d'une implémentation de la fusion et des mises à jour partielles, vous pouvez fournir une implémentation de l'interface `HoodieRecordPayload` à l'aide du paramètre `DataSourceWriteOptions.PAYLOAD_CLASS_OPT_KEY`.
+ **La suppression exige un schéma** – Lors d'une suppression, vous devez spécifier les champs de clé d'enregistrement, de clé de partition et de clé de pré-combinaison. Les autres colonnes peuvent être `null` ou vides, mais le schéma complet est requis.
+ **Limites des tables MoR** – Les tables MoR ne prennent pas en charge le pointage de sauvegarde. Vous pouvez interroger les tables MoR à l'aide de la vue optimisée pour la lecture ou de la vue en temps réel (`tableName_rt`) de Spark SQL, Presto ou Hive. L'utilisation de la vue optimisée pour la lecture expose uniquement les données du fichier de base et n'expose pas une vue fusionnée des données de base et des données de journal.
+ **Hive**
+ Pour l'enregistrement des tables dans le metastore Hive, Hudi s'attend à ce que le serveur Hive Thrift s'exécute sur le port par défaut `10000`. Si vous remplacez ce port par un port personnalisé, transmettez l'option `HIVE_URL_OPT_KEY` comme indiqué dans l'exemple suivant.
```
.option(DataSourceWriteOptions.HIVE_URL_OPT_KEY, "jdbc:hive2://localhost:override-port-number
```
+ Le type de données `timestamp` dans Spark est enregistré comme type de données `long` dans Hive, et non comme type `timestamp` de Hive.
+ **Presto**
+ Presto ne prend pas en charge la lecture des tables MoR en temps réel dans les versions de Hudi inférieures à 0.6.0.
+ Presto ne prend en charge que les requêtes instantanées.
+ Pour que Presto interprète correctement les colonnes d'un ensemble de données, Hudi définissez la valeur de `hive.parquet_use_column_names` sur `true`.
+ Pour définir la valeur pour une session, dans le shell Presto, exécutez la commande suivante :
```
set session hive.parquet_use_column_names=true
```
+ Pour définir la valeur au niveau du cluster, utilisez la classification de configuration `presto-connector-hive` pour définir `hive.parquet.use_column_names` sur `true`, comme illustré dans l'exemple suivant. Pour de plus amples informations, veuillez consulter [Configuration des applications](emr-configure-apps.md).
```
[
{
"Classification": "presto-connector-hive",
"Properties": {
"hive.parquet.use-column-names": "true"
}
}
]
```
+ **HBase Index**
+ La HBase version utilisée pour *compiler* Hudi peut être différente de celle répertoriée dans le guide de publication de l'EMR. Pour extraire les dépendances correctes pour votre session Spark, exécutez la commande suivante.
```
spark-shell \
--jars /usr/lib/spark/external/lib/spark-avro.jar,/usr/lib/hudi/cli/lib/*.jar \
--conf "spark.serializer=org.apache.spark.serializer.KryoSerializer" \
--conf "spark.sql.hive.convertMetastoreParquet=false"
```
+ **Paramètres pour de meilleures performances** — Pour EMR 7.3\$1/Hudi 0.15\$1, il est recommandé aux clients de définir cette configuration afin de réduire la charge de sérialisation de Kryo :
```
--conf 'spark.kryo.registrator=org.apache.spark.HoodieKryoRegistrar'
```
**Note**
Si vous utilisez un contrôle d'accès fin (FGAC) sur EMR Serverless, cette configuration n'est pas nécessaire, car les utilisateurs doivent utiliser plutôt que. JavaSerializer KryoSerializer
# Créez un cluster avec Hudi installé
Avec Amazon EMR version 5.28.0 ou ultérieure, Amazon EMR installe les composants Hudi par défaut lorsque Spark, Hive ou Presto est installé. Pour utiliser Hudi sur Amazon EMR, créez un cluster avec une ou plusieurs des applications suivantes installées :
+ Hadoop
+ Hive
+ Spark
+ Presto
+ Flink
Vous pouvez créer un cluster à l'aide de l' AWS Management Console API, de AWS CLI, ou de l'API Amazon EMR.
## Pour créer un cluster avec Hudi à l'aide du AWS Management Console
1. Accédez à la nouvelle console Amazon EMR et sélectionnez **Changer pour l'ancienne console** depuis le menu latéral. Pour plus d'informations sur ce qu'implique le passage à l'ancienne console, consultez la rubrique [Utilisation de l'ancienne console](https://docs.aws.amazon.com/emr/latest/ManagementGuide/whats-new-in-console.html#console-opt-in).
1. Choisissez **Créer un cluster** et **Go to advanced options (Aller aux options avancées)**.
1. Sous Software Configuration (Configuration logicielle), choisissez **emr-5.28.0** ou version ultérieure pour **Release (Version)** et sélectionnez **Hadoop**, **Hive**, **Spark**, **Presto** et **Tez** avec les autres applications dont votre cluster a besoin.
1. Configurez d'autres options si nécessaire pour votre application, puis choisissez **Next (Suivant)**.
1. Configurez les options pour **Hardware (Matériel)** and **General cluster settings (Paramètres de cluster généraux)** à votre guise.
1. Pour **Security Options (Options de sécurité)**, nous vous recommandons de sélectionner une **EC2 key pair (Paire de clés EC2)** que vous pouvez utiliser pour vous connecter à la ligne de commande du nœud principal à l'aide de SSH. Cela vous permet d'exécuter les commandes du shell Spark, les commandes de l'interface de ligne de commande Hive et les commandes de l'interface de ligne de commande Hudi décrites dans ce guide.
1. Configurez les autres options de sécurité comme vous le souhaitez et choisissez **Create cluster (Créer un cluster)**.
# Travailler avec un jeu de données Hudi
Hudi prend en charge l'insertion, la mise à jour et la suppression de données dans des jeux de données Hudi via Spark. Pour plus d'informations, consultez [Writing Hudi tables](https://hudi.apache.org/docs/writing_data.html) dans la documentation Apache Hudi.
Les exemples suivants démontrent comment lancer le shell Spark interactif, utiliser Spark submit ou utiliser Blocs-notes EMR pour travailler avec Hudi sur Amazon EMR. Vous pouvez également utiliser l' DeltaStreamer utilitaire Hudi ou d'autres outils pour écrire dans un ensemble de données. Dans cette section, les exemples illustrent l'utilisation des ensembles 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.
## Lancez le shell Spark à l'aide d'Amazon EMR 6.7 et versions ultérieures
Lorsque vous exécutez `spark-shell`, `spark-submit` ou `spark-sql` ou utilisez Amazon EMR 6.7.0 ou version ultérieure, passez les commandes suivantes.
**Note**
Amazon EMR 6.7.0 utilise [Apache Hudi](https://hudi.apache.org/) 0.11.0-amzn-0, qui contient des améliorations significatives par rapport aux versions précédentes de Hudi. Pour plus d'informations, consultez le [Guide de migration Apache Hudi 0.11.0](https://hudi.apache.org/releases/release-0.11.0/#migration-guide). Les exemples de cet onglet reflètent ces changements.
**Pour ouvrir le shell Spark sur le nœud primaire**
1. Connexion au nœud primaire à l'aide de SSH. Pour plus d'informations, consultez [Connexion au nœud primaire à 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 --jars /usr/lib/hudi/hudi-spark-bundle.jar \
--conf "spark.serializer=org.apache.spark.serializer.KryoSerializer" \
--conf "spark.sql.catalog.spark_catalog=org.apache.spark.sql.hudi.catalog.HoodieCatalog" \
--conf "spark.sql.extensions=org.apache.spark.sql.hudi.HoodieSparkSessionExtension"
```
## Lancez le shell Spark à l'aide d'Amazon EMR 6.6 et versions antérieures
Lors de l'exécution `spark-shell`, `spark-submit` ou `spark-sql` ou utilisez d'Amazon EMR 6.6.x ou version antérieure, passez les commandes suivantes.
**Note**
Amazon EMR 6.2 et 5.31 et versions ultérieures (Hudi 0.6.x et versions ultérieures) peuvent omettre `spark-avro.jar` de la configuration.
Amazon EMR 6.5 et 5.35 et versions ultérieures (Hudi 0.9.x et versions ultérieures) peuvent omettre `spark.sql.hive.convertMetastoreParquet=false` de la configuration.
Amazon EMR 6.6 et 5.36 et versions ultérieures (Hudi 0.10.x et versions ultérieures) doivent inclure la configuration `HoodieSparkSessionExtension` telle que décrite dans le [Guide Spark de la version : 0.10.0](https://hudi.apache.org/docs/0.10.0/quick-start-guide/) :
```
--conf "spark.sql.extensions=org.apache.spark.sql.hudi.HoodieSparkSessionExtension" \
```
**Pour ouvrir le shell Spark sur le nœud primaire**
1. Connexion au nœud primaire à l'aide de SSH. Pour plus d'informations, consultez [Connexion au nœud primaire à 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.serializer=org.apache.spark.serializer.KryoSerializer" \
--conf "spark.sql.hive.convertMetastoreParquet=false" \
--jars /usr/lib/hudi/hudi-spark-bundle.jar,/usr/lib/spark/external/lib/spark-avro.jar
```
## Utiliser Hudi avec Blocs-notes Amazon EMR utilisant Amazon EMR 6.7 et versions ultérieures
Pour utiliser Hudi avec les blocs-notes Amazon EMR, vous devez d'abord copier les fichiers jar Hudi depuis le système de fichiers local vers HDFS sur le nœud principal du cluster de bloc-notes. Vous pouvez utiliser l'éditeur de bloc-notes pour configurer votre bloc-notes EMR afin d'utiliser Hudi.
**Pour utiliser Hudi avec Blocs-notes Amazon EMR**
1. Créez et lancez un cluster pour le Blocs-notes Amazon EMR. Pour plus d'informations, consultez [Création de clusters Amazon EMR pour les blocs-notes](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-managed-notebooks-cluster.html) dans le *Guide de gestion Amazon EMR*.
1. Connectez-vous au nœud principal du cluster à l'aide de SSH, puis copiez les fichiers jar depuis le système de fichiers local vers HDFS comme illustré dans les exemples suivants. Dans l'exemple, nous créons un répertoire dans HDFS pour plus de clarté dans la gestion des fichiers. Vous pouvez choisir votre propre destination dans HDFS si vous le souhaitez.
```
hdfs dfs -mkdir -p /apps/hudi/lib
```
```
hdfs dfs -copyFromLocal /usr/lib/hudi/hudi-spark-bundle.jar /apps/hudi/lib/hudi-spark-bundle.jar
```
1. Ouvrez l'éditeur de bloc-notes, entrez le code de l'exemple suivant et exécutez-le.
```
%%configure
{ "conf": {
"spark.jars":"hdfs:///apps/hudi/lib/hudi-spark-bundle.jar",
"spark.serializer":"org.apache.spark.serializer.KryoSerializer",
"spark.sql.catalog.spark_catalog": "org.apache.spark.sql.hudi.catalog.HoodieCatalog",
"spark.sql.extensions":"org.apache.spark.sql.hudi.HoodieSparkSessionExtension"
}}
```
## Utiliser Hudi avec Blocs-notes Amazon EMR utilisant Amazon EMR 6.6 et versions antérieures
Pour utiliser Hudi avec les blocs-notes Amazon EMR, vous devez d'abord copier les fichiers jar Hudi depuis le système de fichiers local vers HDFS sur le nœud principal du cluster de bloc-notes. Vous pouvez utiliser l'éditeur de bloc-notes pour configurer votre bloc-notes EMR afin d'utiliser Hudi.
**Pour utiliser Hudi avec Blocs-notes Amazon EMR**
1. Créez et lancez un cluster pour le Blocs-notes Amazon EMR. Pour plus d'informations, consultez [Création de clusters Amazon EMR pour les blocs-notes](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-managed-notebooks-cluster.html) dans le *Guide de gestion Amazon EMR*.
1. Connectez-vous au nœud principal du cluster à l'aide de SSH, puis copiez les fichiers jar depuis le système de fichiers local vers HDFS comme illustré dans les exemples suivants. Dans l'exemple, nous créons un répertoire dans HDFS pour plus de clarté dans la gestion des fichiers. Vous pouvez choisir votre propre destination dans HDFS si vous le souhaitez.
```
hdfs dfs -mkdir -p /apps/hudi/lib
```
```
hdfs dfs -copyFromLocal /usr/lib/hudi/hudi-spark-bundle.jar /apps/hudi/lib/hudi-spark-bundle.jar
```
```
hdfs dfs -copyFromLocal /usr/lib/spark/external/lib/spark-avro.jar /apps/hudi/lib/spark-avro.jar
```
1. Ouvrez l'éditeur de bloc-notes, entrez le code de l'exemple suivant et exécutez-le.
```
{ "conf": {
"spark.jars":"hdfs:///apps/hudi/lib/hudi-spark-bundle.jar,hdfs:///apps/hudi/lib/spark-avro.jar",
"spark.serializer":"org.apache.spark.serializer.KryoSerializer",
"spark.sql.hive.convertMetastoreParquet":"false"
}}
```
## Initialisation d'une session Spark pour Hudi
Lorsque vous utilisez Scala, vous devez importer les classes suivantes dans votre session Spark. Vous devez le faire une fois par session Spark.
```
import org.apache.spark.sql.SaveMode
import org.apache.spark.sql.functions._
import org.apache.hudi.DataSourceWriteOptions
import org.apache.hudi.DataSourceReadOptions
import org.apache.hudi.config.HoodieWriteConfig
import org.apache.hudi.hive.MultiPartKeysValueExtractor
import org.apache.hudi.hive.HiveSyncConfig
import org.apache.hudi.sync.common.HoodieSyncConfig
```
## Écrire dans un jeu de données Hudi
Les exemples suivants montrent comment créer un jeu de données Hudi DataFrame et l'écrire sous forme de jeu de données Hudi.
**Note**
Pour coller des exemples de code dans le shell Spark, tapez **:paste** à l'invite, collez l'exemple, puis appuyez sur **CTRL** \$1 **D**.
Chaque fois que vous écrivez un dans DataFrame un jeu de données Hudi, vous devez spécifier`DataSourceWriteOptions`. Beaucoup de ces options sont susceptibles d'être identiques dans les opérations d'écriture. L'exemple suivant spécifie les options communes à l'aide de la variable `hudiOptions`, que les exemples suivants utilisent.
### Écrire à l'aide de Scala avec Amazon EMR 6.7 et versions ultérieures
**Note**
Amazon EMR 6.7.0 utilise [Apache Hudi](https://hudi.apache.org/) 0.11.0-amzn-0, qui contient des améliorations significatives par rapport aux versions précédentes de Hudi. Pour plus d'informations, consultez le [Guide de migration Apache Hudi 0.11.0](https://hudi.apache.org/releases/release-0.11.0/#migration-guide). Les exemples de cet onglet reflètent ces changements.
```
// Create a DataFrame
val inputDF = 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"),
("104", "2015-01-02", "2015-01-01T12:15:00.512679Z"),
("105", "2015-01-02", "2015-01-01T13:51:42.248818Z")
).toDF("id", "creation_date", "last_update_time")
//Specify common DataSourceWriteOptions in the single hudiOptions variable
val hudiOptions = Map[String,String](
HoodieWriteConfig.TBL_NAME.key -> "tableName",
DataSourceWriteOptions.TABLE_TYPE.key -> "COPY_ON_WRITE",
DataSourceWriteOptions.RECORDKEY_FIELD_OPT_KEY -> "id",
DataSourceWriteOptions.PARTITIONPATH_FIELD_OPT_KEY -> "creation_date",
DataSourceWriteOptions.PRECOMBINE_FIELD_OPT_KEY -> "last_update_time",
DataSourceWriteOptions.HIVE_SYNC_ENABLED_OPT_KEY -> "true",
DataSourceWriteOptions.HIVE_TABLE_OPT_KEY -> "tableName",
DataSourceWriteOptions.HIVE_PARTITION_FIELDS_OPT_KEY -> "creation_date",
HoodieSyncConfig.META_SYNC_PARTITION_EXTRACTOR_CLASS.key -> "org.apache.hudi.hive.MultiPartKeysValueExtractor",
HoodieSyncConfig.META_SYNC_ENABLED.key -> "true",
HiveSyncConfig.HIVE_SYNC_MODE.key -> "hms",
HoodieSyncConfig.META_SYNC_TABLE_NAME.key -> "tableName",
HoodieSyncConfig.META_SYNC_PARTITION_FIELDS.key -> "creation_date"
)
// Write the DataFrame as a Hudi dataset
(inputDF.write
.format("hudi")
.options(hudiOptions)
.option(DataSourceWriteOptions.OPERATION_OPT_KEY,"insert")
.mode(SaveMode.Overwrite)
.save("s3://amzn-s3-demo-bucket/myhudidataset/"))
```
### Écrire à l'aide de Scala avec Amazon EMR 6.6 et versions antérieures
```
// Create a DataFrame
val inputDF = 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"),
("104", "2015-01-02", "2015-01-01T12:15:00.512679Z"),
("105", "2015-01-02", "2015-01-01T13:51:42.248818Z")
).toDF("id", "creation_date", "last_update_time")
//Specify common DataSourceWriteOptions in the single hudiOptions variable
val hudiOptions = Map[String,String](
HoodieWriteConfig.TABLE_NAME -> "tableName",
DataSourceWriteOptions.TABLE_TYPE_OPT_KEY -> "COPY_ON_WRITE",
DataSourceWriteOptions.RECORDKEY_FIELD_OPT_KEY -> "id",
DataSourceWriteOptions.PARTITIONPATH_FIELD_OPT_KEY -> "creation_date",
DataSourceWriteOptions.PRECOMBINE_FIELD_OPT_KEY -> "last_update_time",
DataSourceWriteOptions.HIVE_SYNC_ENABLED_OPT_KEY -> "true",
DataSourceWriteOptions.HIVE_TABLE_OPT_KEY -> "tableName",
DataSourceWriteOptions.HIVE_PARTITION_FIELDS_OPT_KEY -> "creation_date",
DataSourceWriteOptions.HIVE_PARTITION_EXTRACTOR_CLASS_OPT_KEY -> classOf[MultiPartKeysValueExtractor].getName
)
// Write the DataFrame as a Hudi dataset
(inputDF.write
.format("org.apache.hudi")
.option(DataSourceWriteOptions.OPERATION_OPT_KEY, DataSourceWriteOptions.INSERT_OPERATION_OPT_VAL)
.options(hudiOptions)
.mode(SaveMode.Overwrite)
.save("s3://amzn-s3-demo-bucket/myhudidataset/"))
```
### Écrivez en utilisant PySpark
```
# Create a DataFrame
inputDF = 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"),
("104", "2015-01-02", "2015-01-01T12:15:00.512679Z"),
("105", "2015-01-02", "2015-01-01T13:51:42.248818Z"),
],
["id", "creation_date", "last_update_time"]
)
# Specify common DataSourceWriteOptions in the single hudiOptions variable
hudiOptions = {
'hoodie.table.name': 'tableName',
'hoodie.datasource.write.recordkey.field': 'id',
'hoodie.datasource.write.partitionpath.field': 'creation_date',
'hoodie.datasource.write.precombine.field': 'last_update_time',
'hoodie.datasource.hive_sync.enable': 'true',
'hoodie.datasource.hive_sync.table': 'tableName',
'hoodie.datasource.hive_sync.partition_fields': 'creation_date',
'hoodie.datasource.hive_sync.partition_extractor_class': 'org.apache.hudi.hive.MultiPartKeysValueExtractor'
}
# Write a DataFrame as a Hudi dataset
inputDF.write \
.format('org.apache.hudi') \
.option('hoodie.datasource.write.operation', 'insert') \
.options(**hudiOptions) \
.mode('overwrite') \
.save('s3://amzn-s3-demo-bucket/myhudidataset/')
```
**Note**
Vous pouvez voir « hoodie » au lieu de Hudi dans les exemples de code et les notifications. La base de code Hudi utilise largement l'ancienne orthographe « hoodie ».
**DataSourceWriteOptions référence pour Hudi**
| Option | Description |
| --- | --- |
| TABLE\$1NAME | Nom de la table sous laquelle enregistrer l'ensemble de données. |
| TABLE\$1TYPE\$1OPT\$1KEY | Facultatif. Spécifie si l'ensemble de données est créé en tant que `"COPY_ON_WRITE"` ou `"MERGE_ON_READ"`. La valeur par défaut est `"COPY_ON_WRITE"`. |
| RECORDKEY\$1FIELD\$1OPT\$1KEY | Champ de clé d'enregistrement dont la valeur sera utilisée en tant que composant `recordKey` de `HoodieKey`. La valeur réelle sera obtenue en appelant `.toString()` sur la valeur de champ. Des champs imbriqués peuvent être spécifiés à l'aide de la notation par points, par exemple, `a.b.c`. |
| PARTITIONPATH\$1FIELD\$1OPT\$1KEY | Champ de chemin de partition dont la valeur sera utilisée en tant que composant `partitionPath` de `HoodieKey`. La valeur réelle sera obtenue en appelant `.toString()` sur la valeur de champ. |
| PRECOMBINE\$1FIELD\$1OPT\$1KEY | Champ utilisé dans la pré-combinaison avant l'écriture réelle. Lorsque deux enregistrements ont la même valeur de clé, Hudi sélectionne celui avec la plus grande valeur pour le champ de pré-combinaison, comme déterminé par `Object.compareTo(..)`. |
Les options suivantes sont nécessaires uniquement pour enregistrer la table du jeu de données Hudi dans votre metastore. Si vous n'enregistrez pas votre jeu de données Hudi en tant que table dans le metastore Hive, ces options ne sont pas requises.
**DataSourceWriteOptions référence pour Hive**
| Option | Description |
| --- | --- |
| HIVE\$1DATABASE\$1OPT\$1KEY | Base de données Hive avec laquelle synchroniser. La valeur par défaut est `"default"`. |
| HIVE\$1PARTITION\$1EXTRACTOR\$1CLASS\$1OPT\$1KEY | Classe utilisée pour extraire les valeurs de champ de partition dans les colonnes de partition Hive. |
| HIVE\$1PARTITION\$1FIELDS\$1OPT\$1KEY | Champ dans l'ensemble de données à utiliser pour déterminer les colonnes de partition Hive. |
| HIVE\$1SYNC\$1ENABLED\$1OPT\$1KEY | Lorsqu'elle est définie sur `"true"`, enregistre l'ensemble de données auprès du metastore Apache Hive. La valeur par défaut est `"false"`. |
| HIVE\$1TABLE\$1OPT\$1KEY | Obligatoire. Nom de la table dans Hive avec laquelle synchroniser. Par exemple, `"my_hudi_table_cow"`. |
| HIVE\$1USER\$1OPT\$1KEY | Facultatif. Nom d'utilisateur Hive à utiliser lors de la synchronisation. Par exemple, `"hadoop"`. |
| HIVE\$1PASS\$1OPT\$1KEY | Facultatif. Mot de passe Hive pour l'utilisateur spécifié par `HIVE_USER_OPT_KEY`. |
| HIVE\$1URL\$1OPT\$1KEY | URL du metastore Hive. |
## Données d'Upsert
L'exemple suivant montre comment insérer des données en écrivant un DataFrame. Contrairement à l'exemple d'insertion précédent, la valeur `OPERATION_OPT_KEY` est définie sur `UPSERT_OPERATION_OPT_VAL`. En outre, `.mode(SaveMode.Append)` est spécifié pour indiquer que l'enregistrement doit être ajouté.
### Upsert à l'aide de Scala avec Amazon EMR 6.7 et versions ultérieures
**Note**
Amazon EMR 6.7.0 utilise [Apache Hudi](https://hudi.apache.org/) 0.11.0-amzn-0, qui contient des améliorations significatives par rapport aux versions précédentes de Hudi. Pour plus d'informations, consultez le [Guide de migration Apache Hudi 0.11.0](https://hudi.apache.org/releases/release-0.11.0/#migration-guide). Les exemples de cet onglet reflètent ces changements.
```
// Create a new DataFrame from the first row of inputDF with a different creation_date value
val updateDF = inputDF.limit(1).withColumn("creation_date", lit("new_value"))
(updateDF.write
.format("hudi")
.options(hudiOptions)
.option(DataSourceWriteOptions.OPERATION_OPT_KEY, "upsert")
.mode(SaveMode.Append)
.save("s3://amzn-s3-demo-bucket/myhudidataset/"))
```
### Upsert en utilisant Scala avec Amazon EMR 6.6 et versions antérieures
```
// Create a new DataFrame from the first row of inputDF with a different creation_date value
val updateDF = inputDF.limit(1).withColumn("creation_date", lit("new_value"))
(updateDF.write
.format("org.apache.hudi")
.option(DataSourceWriteOptions.OPERATION_OPT_KEY, DataSourceWriteOptions.UPSERT_OPERATION_OPT_VAL)
.options(hudiOptions)
.mode(SaveMode.Append)
.save("s3://amzn-s3-demo-bucket/myhudidataset/"))
```
### Upsert en utilisant PySpark
```
from pyspark.sql.functions import lit
# Create a new DataFrame from the first row of inputDF with a different creation_date value
updateDF = inputDF.limit(1).withColumn('creation_date', lit('new_value'))
updateDF.write \
.format('org.apache.hudi') \
.option('hoodie.datasource.write.operation', 'upsert') \
.options(**hudiOptions) \
.mode('append') \
.save('s3://amzn-s3-demo-bucket/myhudidataset/')
```
## Supprimer un enregistrement
Pour supprimer définitivement un enregistrement, vous pouvez insérer une charge utile vide. Dans ce cas, l'option `PAYLOAD_CLASS_OPT_KEY` spécifie la classe `EmptyHoodieRecordPayload`. L'exemple utilise le même DataFrame,`updateDF`, utilisé dans l'exemple upsert pour spécifier le même enregistrement.
### Supprimer à l'aide de Scala avec Amazon EMR 6.7 et versions ultérieures
**Note**
Amazon EMR 6.7.0 utilise [Apache Hudi](https://hudi.apache.org/) 0.11.0-amzn-0, qui contient des améliorations significatives par rapport aux versions précédentes de Hudi. Pour plus d'informations, consultez le [Guide de migration Apache Hudi 0.11.0](https://hudi.apache.org/releases/release-0.11.0/#migration-guide). Les exemples de cet onglet reflètent ces changements.
```
(updateDF.write
.format("hudi")
.options(hudiOptions)
.option(DataSourceWriteOptions.OPERATION_OPT_KEY, "delete")
.mode(SaveMode.Append)
.save("s3://amzn-s3-demo-bucket/myhudidataset/"))
```
### Supprimer à l'aide de Scala avec Amazon EMR 6.6 et versions antérieures
```
(updateDF.write
.format("org.apache.hudi")
.option(DataSourceWriteOptions.OPERATION_OPT_KEY, DataSourceWriteOptions.UPSERT_OPERATION_OPT_VAL)
.option(DataSourceWriteOptions.PAYLOAD_CLASS_OPT_KEY, "org.apache.hudi.common.model.EmptyHoodieRecordPayload")
.mode(SaveMode.Append)
.save("s3://amzn-s3-demo-bucket/myhudidataset/"))
```
### Supprimer en utilisant PySpark
```
updateDF.write \
.format('org.apache.hudi') \
.option('hoodie.datasource.write.operation', 'upsert') \
.option('hoodie.datasource.write.payload.class', 'org.apache.hudi.common.model.EmptyHoodieRecordPayload') \
.options(**hudiOptions) \
.mode('append') \
.save('s3://amzn-s3-demo-bucket/myhudidataset/')
```
Vous pouvez également supprimer définitivement des données en définissant `OPERATION_OPT_KEY ` sur `DELETE_OPERATION_OPT_VAL` pour supprimer tous les enregistrements de le jeu de données que vous soumettez. Pour obtenir des instructions sur les suppressions logicielles et pour plus d'informations sur la suppression de données stockées dans des tables Hudi, consultez [Suppressions](https://hudi.apache.org/docs/writing_data.html#deletes) dans la documentation d'Apache Hudi.
## Lire à partir d'un jeu de données Hudi
Pour récupérer les données à l'heure actuelle, Hudi effectue des requêtes instantanées par défaut. Voici un exemple d'interrogation de le jeu de données écrit dans S3 dans [Écrire dans un jeu de données Hudi](#emr-hudi-dataframe). *s3://amzn-s3-demo-bucket/myhudidataset*Remplacez-le par le chemin de votre table et ajoutez des astérisques génériques pour chaque niveau de partition, *ainsi qu'un* astérisque supplémentaire. Dans cet exemple, il existe un niveau de partition. Nous avons donc ajouté deux symboles génériques.
### Lire à l'aide de Scala avec Amazon EMR 6.7 et versions ultérieures
**Note**
Amazon EMR 6.7.0 utilise [Apache Hudi](https://hudi.apache.org/) 0.11.0-amzn-0, qui contient des améliorations significatives par rapport aux versions précédentes de Hudi. Pour plus d'informations, consultez le [Guide de migration Apache Hudi 0.11.0](https://hudi.apache.org/releases/release-0.11.0/#migration-guide). Les exemples de cet onglet reflètent ces changements.
```
val snapshotQueryDF = spark.read
.format("hudi")
.load("s3://amzn-s3-demo-bucket/myhudidataset")
.show()
```
### Lire à l'aide de Scala avec Amazon EMR 6.6 et versions antérieures
```
(val snapshotQueryDF = spark.read
.format("org.apache.hudi")
.load("s3://amzn-s3-demo-bucket/myhudidataset" + "/*/*"))
snapshotQueryDF.show()
```
### Lisez en utilisant PySpark
```
snapshotQueryDF = spark.read \
.format('org.apache.hudi') \
.load('s3://amzn-s3-demo-bucket/myhudidataset' + '/*/*')
snapshotQueryDF.show()
```
### Requêtes incrémentielles
Vous pouvez également effectuer des requêtes incrémentielles avec Hudi pour obtenir un flux d'enregistrements modifiés depuis un horodatage de validation donné. Pour ce faire, définissez le champ `QUERY_TYPE_OPT_KEY` sur `QUERY_TYPE_INCREMENTAL_OPT_VAL`. Ajoutez ensuite une valeur pour `BEGIN_INSTANTTIME_OPT_KEY` pour obtenir tous les enregistrements écrits depuis l'heure spécifiée. Les requêtes incrémentielles sont généralement dix fois plus efficaces que leurs homologues par lots, car elles ne traitent que les enregistrements modifiés.
Lorsque vous effectuez des requêtes incrémentielles, utilisez le chemin de la table racine (de base) sans les astérisques génériques utilisés pour les requêtes Snapshot.
**Note**
Presto ne prend pas en charge les requêtes incrémentielles.
#### Requêtes incrémentielles à l'aide de Scala
```
val incQueryDF = spark.read
.format("org.apache.hudi")
.option(DataSourceReadOptions.QUERY_TYPE_OPT_KEY, DataSourceReadOptions.QUERY_TYPE_INCREMENTAL_OPT_VAL)
.option(DataSourceReadOptions.BEGIN_INSTANTTIME_OPT_KEY, )
.load("s3://amzn-s3-demo-bucket/myhudidataset")
incQueryDF.show()
```
#### Requêtes incrémentielles utilisant PySpark
```
readOptions = {
'hoodie.datasource.query.type': 'incremental',
'hoodie.datasource.read.begin.instanttime': ,
}
incQueryDF = spark.read \
.format('org.apache.hudi') \
.options(**readOptions) \
.load('s3://amzn-s3-demo-bucket/myhudidataset')
incQueryDF.show()
```
Pour plus d'informations sur la lecture d'jeux de données Hudi, consultez la rubrique [Interrogation de tables Hudi](https://hudi.apache.org/docs/querying_data.html) dans la documentation d'Apache Hudi.
# Utiliser la CLI Hudi
Vous pouvez utiliser l'interface de ligne de commande Hudi pour administrer les jeux de données Hudi afin d'afficher des informations sur les validations, le système de fichiers, les statistiques, etc. Vous pouvez également utiliser l'interface de ligne de commande pour effectuer manuellement des compressions, planifier des compressions ou annuler des compressions planifiées. Pour plus d'informations, consultez [Interaction via la CLI](https://hudi.apache.org/docs/cli/) dans la documentation Apache Hudi.
**Pour démarrer l'interface de ligne de commande Hudi et se connecter à un ensemble de données**
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. Sur la ligne de commande, tapez `/usr/lib/hudi/cli/bin/hudi-cli.sh`.
L'invite de commande devient `hudi->`.
1. Utilisez la commande suivante pour vous connecter à un ensemble de données. *s3://amzn-s3-demo-bucket/myhudidataset*Remplacez-le par le chemin d'accès au jeu de données avec lequel vous souhaitez travailler. La valeur que nous utilisons est la même que la valeur établie dans les exemples précédents.
```
connect --path s3://amzn-s3-demo-bucket/myhudidataset
```
L'invite de commandes change pour inclure l'ensemble de données auquel vous êtes connecté, comme illustré dans l'exemple suivant.
```
hudi:myhudidataset->
```
Par défaut, le `hudi-cli.sh` script utilisé dans les versions 7.3.0 à 7.8.0 d'Amazon EMR est utilisé. `hudi-cli-bundle.jar` Si vous rencontrez des problèmes, vous pouvez revenir à la CLI Hudi classique à l'aide de la commande suivante :
```
/usr/lib/hudi/cli/bin/hudi-cli.sh --cliBundle false
```
Cette commande exécute le `hudi-cli.sh` script, définit l'`--cliBundle`indicateur et indique à la CLI d'utiliser les fichiers JAR individuels au lieu du JAR groupé. Par défaut, le paramètre `--cliBundle` est défini sur true, ce qui signifie que la CLI utilise plutôt le fichier JAR groupé.
## Utilisation d'Amazon EMR 7.9.0 et versions ultérieures
**Note**
Le script **hudi-cli.sh** est devenu obsolète dans les versions 7.9.0 et supérieures d'EMR. **Les versions 7.9.0 et supérieures d'Amazon EMR utilisent le fichier .jar. hudi-cli-bundle**
**Pour démarrer la CLI Hudi et vous connecter à un ensemble de données :**
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. Sur la ligne de commande, tapez**/usr/lib/hudi/cli-bundle/bin/hudi- cli-with-bundle .sh **hudi-cli-with-bundle****ou tapez simplement **>hudi-cli**.
L'invite de commande devient **hudi- >**.
1. Utilisez la commande suivante pour vous connecter à un ensemble de données. Remplacez **s3://amzn-s3-demo-bucket/myhudidataset** par le chemin d'accès à l'ensemble de données avec lequel vous souhaitez travailler. La valeur que nous utilisons est la même que la valeur établie dans les exemples précédents.
```
connect --path s3://amzn-s3-demo-bucket/myhudidataset
```
1. L'invite de commandes change pour inclure l'ensemble de données auquel vous êtes connecté, comme illustré dans l'exemple suivant.
```
hudi:myhudidataset->
```
# Historique des sorties de Hudi
Le tableau suivant répertorie la version de Hudi incluse 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 la version de Hudi**
| Étiquette de version Amazon EMR | Version Hudi | Composants installés avec Hudi |
| --- | --- | --- |
| emr-7,12.0 | 1.0.2-amzn-1 | Not available. |
| emr-7.11.0 | 1.0.2-amzn-0 | Not available. |
| emr-7.10.0 | 0,15,0-amzn-7 | Not available. |
| emr-7.9.0 | 0,15,0-amzn-6 | Not available. |
| emr-7,8.0 | 0,15,0-amzn-5 | Not available. |
| emr-7,7.0 | 0,15,0-amzn-4 | Not available. |
| emr-7.6.0 | 0,15,0-amzn-3 | Not available. |
| emr-7.5.0 | 0,15,0-amzn-2 | Not available. |
| emr-7.4.0 | 0,15,0-amzn-1 | Not available. |
| emr-7.3.0 | 0,15,0-amzn-0 | Not available. |
| emr-7.2.0 | 0,14.1-amzn-1 | Not available. |
| emr-5.36.2 | 0.10.1-amzn-1 | Not available. |
| emr-7.1.0 | 0.14.1-amzn-0 | Not available. |
| emr-7.0.0 | 0.14.0-amzn-1 | Not available. |
| emr-6.15.0 | 0.14.0-amzn-0 | Not available. |
| emr-6.14.0 | 0.13.1-amzn-2 | Not available. |
| emr-6.13.0 | 0.13.1-amzn-1 | Not available. |
| emr-6.12.0 | 0.13.1-amzn-0 | Not available. |
| emr-6.11.1 | 0.13.0-amzn-0 | Not available. |
| emr-6.11.0 | 0.13.0-amzn-0 | Not available. |
| emr-6.10.1 | 0.12.2-amzn-0 | Not available. |
| emr-6.10.0 | 0.12.2-amzn-0 | Not available. |
| emr-6.9.1 | 0.12.1-amzn-0 | Not available. |
| emr-6.9.0 | 0.12.1-amzn-0 | Not available. |
| emr-6.8.1 | 0.11.1-amzn-0 | Not available. |
| emr-6.8.0 | 0.11.1-amzn-0 | Not available. |
| emr-6.7.0 | 0.11.0-amzn-0 | Not available. |
| emr-5.36.1 | 0.10.1-amzn-1 | Not available. |
| emr-5.36.0 | 0.10.1-amzn-1 | Not available. |
| emr-6.6.0 | 0.10.1-amzn-0 | Not available. |
| emr-5.35.0 | 0.9.0-amzn-2 | Not available. |
| emr-6.5.0 | 0.9.0-amzn-1 | Not available. |
| emr-6.4.0 | 0.8.0-amzn-0 | Not available. |
| emr-6.3.1 | 0.7.0-amzn-0 | Not available. |
| emr-6.3.0 | 0.7.0-amzn-0 | Not available. |
| emr-6.2.1 | 0.6.0-amzn-1 | Not available. |
| emr-6.2.0 | 0.6.0-amzn-1 | Not available. |
| emr-6.1.1 | 0.5.2-incubating-amzn-2 | Not available. |
| emr-6.1.0 | 0.5.2-incubating-amzn-2 | Not available. |
| emr-6.0.1 | 0.5.0-incubating-amzn-1 | Not available. |
| emr-6.0.0 | 0.5.0-incubating-amzn-1 | Not available. |
| emr-5.34.0 | 0.9.0-amzn-0 | Not available. |
| emr-5.33.1 | 0.7.0-amzn-1 | Not available. |
| emr-5.33.0 | 0.7.0-amzn-1 | Not available. |
| emr-5.32.1 | 0.6.0-amzn-0 | Not available. |
| emr-5.32.0 | 0.6.0-amzn-0 | Not available. |
| emr-5.31.1 | 0.6.0-amzn-0 | Not available. |
| emr-5.31.0 | 0.6.0-amzn-0 | Not available. |
| emr-5.30.2 | 0.5.2-incubating | Not available. |
| emr-5.30.1 | 0.5.2-incubating | Not available. |
| emr-5.30.0 | 0.5.2-incubating | Not available. |
| mr-5.29.0 | 0.5.0-incubating | Not available. |
| emr-5.28.1 | 0.5.0-incubating | Not available. |
| emr-5.28.0 | 0.5.0-incubating | Not available. |