Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Hudi
[Apache Hudi](https://hudi.apache.org/) è un framework di gestione dei dati open source utilizzato per semplificare l'elaborazione dei dati incrementale e lo sviluppo della pipeline di dati fornendo funzionalità di inserimento, aggiornamento, upsert ed eliminazione a livello di record. *Upsert* si riferisce alla possibilità di inserire record in un set di dati esistente se non esistono già o di aggiornarli. Gestendo in modo efficiente il modo in cui i dati sono disposti in Amazon S3, Hudi consente di inserire e aggiornare i dati quasi in tempo reale. Hudi mantiene attentamente i metadati delle azioni eseguite sul set di dati per garantire che le azioni siano atomiche e coerenti.
Hudi è integrato con [Apache Spark](https://aws.amazon.com/emr/features/spark/), [Apache Hive](https://hive.apache.org/) e [Presto](https://prestodb.github.io). Nelle versioni Amazon EMR 6.1.0 e successive, Hudi è integrato anche con [Trino (PrestoSQL)](https://trino.io/).
Con la versione 5.28.0 e successive di Amazon EMR, EMR installa i componenti Hudi per impostazione predefinita quando sono installati Spark, Hive, Presto o Flink. Puoi usare Spark o l' DeltaStreamer utilità Hudi per creare o aggiornare set di dati Hudi. È possibile utilizzare Hive, Spark, Presto o Flink per per eseguire una query a un set di dati Hudi in modo interattivo o creare pipeline di elaborazione dati utilizzando *pull incrementali*. Il pull incrementale si riferisce alla possibilità di estrarre solo i dati che sono cambiati tra due azioni.
Queste caratteristiche rendono Hudi adatto per i seguenti casi d'uso:
+ Utilizzo di dati in streaming da sensori e altri dispositivi IoT (Internet of Things) che richiedono specifici eventi di inserimento e aggiornamento dei dati.
+ Rispetto delle norme sulla privacy dei dati nelle applicazioni in cui gli utenti possono scegliere di essere dimenticati o modificare il loro consenso per l'utilizzo dei loro dati.
+ Implementazione di un [sistema di acquisizione dati di modifica (CDC)](https://en.wikipedia.org/wiki/Change_data_capture) che consente di applicare modifiche a un set di dati nel tempo.
La seguente tabella indica la versione di Hudi inclusa nell'ultimo rilascio della serie Amazon EMR 7.x insieme ai componenti che Amazon EMR installa con Hudi.
[Per la versione dei componenti installati con Hudi in questa versione, vedi Versioni dei componenti della release 7.12.0.](emr-7120-release.md)
**Informazioni sulla versione Hudi per emr-7.12.0**
| Etichetta di rilascio di Amazon EMR | Versione di Hudi | Componenti installati con Hudi |
| --- | --- | --- |
| emr-7.12.0 | Hudi 1.0.2-amzn-1 | Not available. |
La seguente tabella indica la versione di Hudi inclusa nell'ultimo rilascio della serie Amazon EMR 6.x insieme ai componenti che Amazon EMR installa con Hudi.
Per la versione dei componenti installati con Hudi in questo rilascio, consulta la sezione [Versioni dei componenti del rilascio 6.15.0](emr-6150-release.md).
**Informazioni sulla versione di Hudi per emr-6.15.0**
| Etichetta di rilascio di Amazon EMR | Versione di Hudi | Componenti installati con Hudi |
| --- | --- | --- |
| emr-6.15.0 | Hudi 0.14.0-amzn-0 | Not available. |
**Nota**
Il rilascio 6.8.0 di Amazon EMR include [Apache Hudi](https://hudi.apache.org/) 0.11.1; tuttavia, i cluster Amazon EMR 6.8.0 sono compatibili anche con l'open source `hudi-spark3.3-bundle_2.12` di Hudi 0.12.0.
La seguente tabella indica la versione di Hudi inclusa nell'ultimo rilascio della serie Amazon EMR 5.x insieme ai componenti che Amazon EMR installa con Hudi.
[Per la versione dei componenti installati con Hudi in questa versione, vedere Versioni dei componenti della release 5.36.2.](emr-5362-release.md)
**Informazioni sulla versione Hudi per emr-5.36.2**
| Etichetta di rilascio di Amazon EMR | Versione di Hudi | Componenti installati con Hudi |
| --- | --- | --- |
| emr-5.36.2 | Hudi 0.10.1-amzn-1 | Not available. |
**Topics**
+ [
# Funzionamento di Hudi
](emr-hudi-how-it-works.md)
+ [
# Considerazioni e limitazioni per l'utilizzo di Hudi su Amazon EMR
](emr-hudi-considerations.md)
+ [
# Creazione di un cluster con Hudi installato
](emr-hudi-installation-and-configuration.md)
+ [
# Lavorare con un set di dati Hudi
](emr-hudi-work-with-dataset.md)
+ [
# Utilizzo della CLI Hudi
](emr-hudi-cli.md)
+ [
# Cronologia dei rilasci di Hudi
](Hudi-release-history.md)
# Funzionamento di Hudi
Quando usi Hudi con Amazon EMR, puoi scrivere dati sul set di dati utilizzando l'API Spark Data Source o l'utilità Hudi. DeltaStreamer Hudi organizza un set di dati in una struttura di directory partizionata sotto un `basepath` che è simile a una tradizionale tabella Hive. Le specifiche di come i dati vengono disposti come file in queste directory dipendono dal tipo di set di dati scelto. È possibile scegliere Copia in scrittura (Cow) o Unisci in lettura (mOr).
Indipendentemente dal tipo di set di dati, ogni partizione in un set di dati è identificata in modo univoco dal `partitionpath` relativo al `basepath`. All'interno di ogni partizione, i record vengono distribuiti in più file di dati. Per ulteriori informazioni, consulta [Gestione file](https://hudi.apache.org/docs/concepts.html#file-management) nella documentazione di Apache Hudi.
Ogni operazione in Hudi ha un commit corrispondente, identificato da un timestamp crescente in maniera monotona noto come *Instant*. Hudi dispone tutte le operazioni eseguite sul set di dati in serie su una timeline. Hudi si basa sulla timeline per fornire l'isolamento degli snapshot tra lettori e scrittori e per abilitare il rollback a un punto precedente. Per ulteriori informazioni sulle operazioni che Hudi registra e sul relativo stato, consulta [Timeline](https://hudi.apache.org/docs/concepts.html#timeline) nella documentazione di Apache Hudi.
## Informazioni sui tipi di archiviazione del set di dati: copia in scrittura rispetto a unisci in lettura
Quando si crea un set di dati Hudi, si specifica che il set di dati è copiato in scrittura o unito in lettura.
+ **Copia in scrittura (CoW)**: i dati vengono memorizzati in un formato colonnare (Parquet) e ogni aggiornamento crea una nuova versione dei file durante una scrittura. CoW è il tipo di archiviazione predefinito.
+ **Unisci in lettura (MoR)**: i dati vengono memorizzati utilizzando una combinazione di formati colonnare (Parquet) e basati su righe (Avro). Gli aggiornamenti vengono registrati nei file *delta* basati su righe e vengono compattati in base alle necessità per creare nuove versioni dei file colonnari.
Con i set di dati CoW, ogni volta che c'è un aggiornamento a un record, il file che contiene il record viene riscritto con i valori aggiornati. Quando si lavora con un set di dati MoR, ogniqualvolta è disponibile un aggiornamento Hudi scrive solo la riga per il registro modificato. MoR è più adatto per carichi di lavoro pesanti in scrittura o modifiche con meno letture. CoW è più adatto per carichi di lavoro pesanti di lettura su dati che cambiano meno frequentemente.
Hudi fornisce tre viste logiche per l'accesso ai dati:
+ **Visualizzazione ottimizzata in lettura**: fornisce l'ultimo set di dati con commit delle tabelle CoW e l'ultimo set di dati compattati dalle tabelle MoR.
+ **Visualizzazione incrementale**: fornisce un flusso di modifiche tra due operazioni da un set di dati CoW per alimentare i processi a valle ed estrarre, trasformare e caricare (ETL) flussi di lavoro.
+ **Visualizzazione in tempo reale**: fornisce i dati di commit più recenti da una tabella MoR unendo i file colonnari e basati su righe in linea.
Quando si esegue una query sulla visualizzazione ottimizzata di lettura, la query restituisce tutti i dati compattati ma non include i commit delta più recenti. Eseguire una query di questi dati offre buone prestazioni di lettura, ma omette i dati più aggiornati. Quando si esegue una query sulla visualizzazione in tempo reale, Hudi unisce i dati compattati con i commit delta in lettura. I dati più aggiornati sono disponibili per eseguire query, ma il sovraccarico di calcolo dell'unione rende la query meno performante. La possibilità di eseguire una query dei dati compattati o dati in tempo reale consente di scegliere tra prestazioni e flessibilità quando si esegue una query.
Per ulteriori informazioni sui compromessi tra i tipi di archiviazione, consulta [Tipi di archiviazione e visualizzazioni](https://hudi.apache.org/docs/concepts.html#storage-types--views) nella documentazione di Apache Hudi.
Hudi crea due tabelle nel metastore Hive per MoR: una tabella con il nome specificato, che è una vista ottimizzata per la lettura e una tabella con lo stesso nome aggiunto con `_rt`, che è una vista in tempo reale. È possibile eseguire una query a entrambe le tabelle.
## Registrazione di un set di dati Hudi con il metastore
Quando si registra una tabella Hudi con il metastore Hive, è possibile interrogare le tabelle Hudi utilizzando Hive, Spark SQL o Presto come si farebbe con qualsiasi altra tabella. Inoltre, puoi integrare Hudi con AWS Glue configurando Hive e Spark per utilizzare il AWS Glue Data Catalog come metastore. Per le tabelle MoR, Hudi registra il set di dati come due tabelle nel Metastore: una tabella con il nome specificato, che è una vista ottimizzata per la lettura e una tabella con lo stesso nome aggiunto con `_rt`, che è una vista in tempo reale.
Viene registrata una tabella Hudi con il metastore Hive quando si utilizza Spark per creare un set di dati Hudi impostando l'opzione `HIVE_SYNC_ENABLED_OPT_KEY` su `"true"` e fornendo altre proprietà richieste. Per ulteriori informazioni, consulta [Lavorare con un set di dati Hudi](emr-hudi-work-with-dataset.md). Inoltre, è possibile utilizzare l'utilità della riga di comando hive\$1sync\$1tool per registrare un set di dati Hudi come tabella nel metastore, separatamente.
# Considerazioni e limitazioni per l'utilizzo di Hudi su Amazon EMR
+ **Il campo della chiave di registro non può essere null o vuoto**: il campo specificato come chiave di registro non può avere valori `null` o vuoti.
+ **Schema aggiornato per impostazione predefinita su upsert e insert**: Hudi fornisce un'interfaccia `HoodieRecordPayload` che determina in che modo l'input DataFrame e il set di dati Hudi esistente vengono uniti per produrre un nuovo set di dati aggiornato. Hudi fornisce un'implementazione predefinita di questa classe`OverwriteWithLatestAvroPayload`, che sovrascrive i record esistenti e aggiorna lo schema come specificato nell'input. DataFrame Per personalizzare questa logica per l'implementazione di aggiornamenti di unione e parziali, è possibile fornire un'implementazione dell'interfaccia `HoodieRecordPayload` utilizzando il parametro `DataSourceWriteOptions.PAYLOAD_CLASS_OPT_KEY`.
+ **L'eliminazione richiede lo schema**: durante l'eliminazione, è necessario specificare la chiave di registro, la chiave di partizione e i campi chiave pre-combinati. Altre colonne possono essere rese `null` o vuote, ma è necessario lo schema completo.
+ **Limitazioni delle tabelle MoR**: le tabelle MoR non supportano il savepointing. È possibile interrogare le tabelle MoR utilizzando la vista ottimizzata per la lettura o la vista in tempo reale (`tableName_rt`) da Spark SQL, Presto o Hive. L'utilizzo della visualizzazione ottimizzata per la lettura espone solo i dati del file di base e non espone una vista unita dei dati di base e di log.
+ **Hive**
+ Per la registrazione delle tabelle nel metastore Hive, Hudi si aspetta che il server Hive Thrift sia in esecuzione sulla porta predefinita `10000`. Se si esegue l'override di questa porta con una porta personalizzata, passa l'opzione `HIVE_URL_OPT_KEY` come illustrato nell'esempio seguente.
```
.option(DataSourceWriteOptions.HIVE_URL_OPT_KEY, "jdbc:hive2://localhost:override-port-number
```
+ Il tipo di dati `timestamp` in Spark è registrato come tipo di dati `long` in Hive e non come tipo `timestamp` di Hive.
+ **Presto**
+ Presto non supporta la lettura di tabelle MoR in tempo reale nelle versioni Hudi precedenti alla 0.6.0.
+ Presto supporta solo le query degli snapshot.
+ Affinché Presto interpreti correttamente le colonne Hudi del set di dati, imposta il valore `hive.parquet_use_column_names` su `true`.
+ Per impostare il valore di una sessione, nella shell Presto, eseguire il comando seguente:
```
set session hive.parquet_use_column_names=true
```
+ Per impostare il valore a livello di cluster, utilizzare la classificazione di configurazione `presto-connector-hive` per impostare `hive.parquet.use_column_names` su `true`, come illustrato nell'esempio seguente. Per ulteriori informazioni, consulta [Configurazione delle applicazioni](emr-configure-apps.md).
```
[
{
"Classification": "presto-connector-hive",
"Properties": {
"hive.parquet.use-column-names": "true"
}
}
]
```
+ **HBase Indice**
+ La HBase versione usata per *creare* Hudi potrebbe essere diversa da quella elencata nella EMR Release Guide. Per inserire le dipendenze corrette per la sessione Spark, esegui il comando seguente.
```
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"
```
+ **Impostazioni per prestazioni ottimali**: per EMR 7.3\$1/Hudi 0.15\$1, si consiglia ai clienti di impostare questa configurazione per ridurre il sovraccarico di serializzazione Kryo:
```
--conf 'spark.kryo.registrator=org.apache.spark.HoodieKryoRegistrar'
```
**Nota**
Se si utilizza il controllo di accesso granulare (FGAC) su EMR Serverless, questa configurazione non è necessaria, poiché gli utenti devono utilizzare anziché. JavaSerializer KryoSerializer
# Creazione di un cluster con Hudi installato
Con la versione 5.28.0 e successive di Amazon EMR, Amazon EMR installa i componenti Hudi per impostazione predefinita quando sono installati Spark, Hive o Presto. Per utilizzare Hudi su Amazon EMR, crea un cluster con una o più delle seguenti applicazioni installate:
+ Hadoop
+ Hive
+ Spark
+ Presto
+ Flink
Puoi creare un cluster utilizzando l' Console di gestione AWS AWS CLI, the o l'API Amazon EMR.
## Per creare un cluster con Hudi utilizzando il Console di gestione AWS
1. Passa alla nuova console Amazon EMR e seleziona **Passa alla vecchia console** dalla barra di navigazione laterale. Per ulteriori informazioni su cosa aspettarti quando passi alla vecchia console, consulta [Utilizzo della vecchia console](https://docs.aws.amazon.com/emr/latest/ManagementGuide/whats-new-in-console.html#console-opt-in).
1. Seleziona **Create cluster** (Crea cluster), **Go to advanced options** (Vai alle opzioni avanzate).
1. In Configurazione software, scegli **emr-5.28.0** o versioni successive per **Release** (Rilascio) e seleziona **Hadoop**, **Hive**, **Spark**, **Presto** e **Tez** insieme ad altre applicazioni richieste dal cluster.
1. Configurare altre opzioni come richiesto per l'applicazione, quindi scegliere **Avanti**.
1. Configurare le opzioni per **Hardware** e **Impostazioni generali del cluster** come desiderato.
1. Per **Opzioni di protezione**, si consiglia di selezionare una **coppia di chiavi EC2** che è possibile utilizzare per connettersi alla riga di comando del nodo master utilizzando SSH. In questo modo è possibile eseguire i comandi della shell Spark, i comandi della CLI Hive e i comandi della CLI Hudi descritti in questa guida.
1. Configurare altre opzioni di sicurezza come desiderato, quindi scegliere **Crea cluster**.
# Lavorare con un set di dati Hudi
Hudi supporta l'inserimento, l'aggiornamento e l'eliminazione di dati nei set di dati Hudi tramite Spark. Per ulteriori informazioni, consulta [Scrittura delle tabelle Hudi](https://hudi.apache.org/docs/writing_data.html) nella documentazione di Apache Hudi.
Negli esempi seguenti viene illustrato come avviare la shell interattiva Spark, utilizzare Spark submit o utilizzare Amazon EMR Notebooks per lavorare con Hudi su Amazon EMR. È inoltre possibile utilizzare l' DeltaStreamer utilità Hudi o altri strumenti per scrivere su un set di dati. In questa sezione, gli esempi illustrano l'utilizzo di set di dati con la shell Spark connessi al nodo master utilizzando SSH come utente `hadoop` predefinito.
## Avvio della shell (interprete di comandi) Spark utilizzando Amazon EMR versione 6.7 e successive
Durante l'esecuzione di `spark-shell`, `spark-submit` o `spark-sql` utilizzando Amazon EMR versione 6.7.0 o successive, esegui i seguenti comandi.
**Nota**
Amazon EMR 6.7.0 impiega [Apache Hudi](https://hudi.apache.org/) 0.11.0-amzn-0, che contiene miglioramenti significativi rispetto alle versioni precedenti di Hudi. Per ulteriori informazioni, consulta la sezione [Apache Hudi 0.11.0 Migration Guide](https://hudi.apache.org/releases/release-0.11.0/#migration-guide) (Guida alla migrazione di Apache Hudi 0.11.0). Gli esempi in questa scheda riflettono tali modifiche.
**Per aprire la shell (interprete di comandi) Spark nel nodo primario**
1. Effettua la connessione al nodo primario tramite SSH. Per ulteriori informazioni, consulta la sezione [Connect to the primary node using SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) (Connessione al nodo primario tramite SSH) nella *Guida alla gestione di Amazon EMR*.
1. Immettere il seguente comando per avviare la shell Spark. Per usare la PySpark shell, *spark-shell* sostituiscila con. *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"
```
## Avvio della shell (interprete di comandi) Spark utilizzando Amazon EMR 6.6 e rilasci precedenti
Durante l'esecuzione di `spark-shell`, `spark-submit` o `spark-sql` utilizzando Amazon EMR 6.6.x o rilasci precedenti, esegui i seguenti comandi.
**Nota**
Amazon EMR versioni 6.2 e 5.31 e successive (Hudi versione 0.6.x e successive) può omettere `spark-avro.jar` dalla configurazione.
Amazon EMR rilasci 6.5 e 5.35 e successivi (Hudi rilascio 0.9.x e successivi) può omettere `spark.sql.hive.convertMetastoreParquet=false` dalla configurazione.
Amazon EMR versioni 6.6 e 5.36 e successive (Hudi versione 0.10.x e successive) deve includere la configurazione `HoodieSparkSessionExtension` descritta in [Version: 0.10.0 Spark Guide](https://hudi.apache.org/docs/0.10.0/quick-start-guide/) (Guida a Spark versione 0.10.0):
```
--conf "spark.sql.extensions=org.apache.spark.sql.hudi.HoodieSparkSessionExtension" \
```
**Per aprire la shell (interprete di comandi) Spark nel nodo primario**
1. Effettua la connessione al nodo primario tramite SSH. Per ulteriori informazioni, consulta la sezione [Connect to the primary node using SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) (Connessione al nodo primario tramite SSH) nella *Guida alla gestione di Amazon EMR*.
1. Immettere il seguente comando per avviare la shell Spark. Per usare la PySpark shell, sostituiscila *spark-shell* con*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
```
## Utilizzo di Hudi con i notebook Amazon EMR utilizzando Amazon EMR versione 6.7 e successive
Per utilizzare Hudi con Amazon EMR Notebooks, è necessario innanzitutto copiare i file jar Hudi dal file system locale in HDFS sul nodo master del cluster di notebook. È quindi possibile utilizzare l'editor del notebook per configurare EMR Notebooks per l'utilizzo di Hudi.
**Utilizzo di Hudi con Amazon EMR Notebooks**
1. Crea e avvia un cluster per Amazon EMR Notebooks. Per ulteriori informazioni, consulta [Creazione di cluster per i notebook Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-managed-notebooks-cluster.html) nella *Guida alla gestione di Amazon EMR*.
1. Connettersi al nodo master del cluster utilizzando SSH e quindi copiare i file jar dal filesystem locale in HDFS, come illustrato negli esempi seguenti. Nell'esempio, creiamo una directory in HDFS per chiarezza nella gestione dei file. È possibile scegliere la propria destinazione in HDFS, se lo si desidera.
```
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. Aprire l'editor del notebook, immettere il codice dall'esempio seguente ed eseguirlo.
```
%%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"
}}
```
## Utilizzo di Hudi con i notebook Amazon EMR utilizzando Amazon EMR 6.6 e rilasci precedenti
Per utilizzare Hudi con Amazon EMR Notebooks, è necessario innanzitutto copiare i file jar Hudi dal file system locale in HDFS sul nodo master del cluster di notebook. È quindi possibile utilizzare l'editor del notebook per configurare EMR Notebooks per l'utilizzo di Hudi.
**Utilizzo di Hudi con Amazon EMR Notebooks**
1. Crea e avvia un cluster per Amazon EMR Notebooks. Per ulteriori informazioni, consulta [Creazione di cluster per i notebook Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-managed-notebooks-cluster.html) nella *Guida alla gestione di Amazon EMR*.
1. Connettersi al nodo master del cluster utilizzando SSH e quindi copiare i file jar dal filesystem locale in HDFS, come illustrato negli esempi seguenti. Nell'esempio, creiamo una directory in HDFS per chiarezza nella gestione dei file. È possibile scegliere la propria destinazione in HDFS, se lo si desidera.
```
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. Aprire l'editor del notebook, immettere il codice dall'esempio seguente ed eseguirlo.
```
{ "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"
}}
```
## Inizializzazione di una sessione Spark per Hudi
Quando si utilizza Scala, è necessario importare le seguenti classi nella sessione Spark. Questo deve essere fatto una volta per sessione 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
```
## Scrittura in un set di dati Hudi
Gli esempi seguenti mostrano come creare un set di dati Hudi DataFrame e scriverlo come set di dati.
**Nota**
Per incollare gli esempi di codice nella shell Spark, digitare **:paste** al prompt, incollare l'esempio e premere **CTRL** \$1 **D**.
Ogni volta che si scrive un su un set di dati Hudi, è DataFrame necessario specificare. `DataSourceWriteOptions` Molte di queste opzioni sono probabilmente identiche tra le operazioni di scrittura. L'esempio seguente specifica le opzioni comuni utilizzando la variabile `hudiOptions`, che gli esempi successivi utilizzano.
### Scrittura utilizzando Scala con Amazon EMR versione 6.7 e successive
**Nota**
Amazon EMR 6.7.0 impiega [Apache Hudi](https://hudi.apache.org/) 0.11.0-amzn-0, che contiene miglioramenti significativi rispetto alle versioni precedenti di Hudi. Per ulteriori informazioni, consulta la sezione [Apache Hudi 0.11.0 Migration Guide](https://hudi.apache.org/releases/release-0.11.0/#migration-guide) (Guida alla migrazione di Apache Hudi 0.11.0). Gli esempi in questa scheda riflettono tali modifiche.
```
// 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/"))
```
### Scrittura utilizzando Scala con Amazon EMR 6.6 e rilasci precedenti
```
// 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/"))
```
### Scrivi usando 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/')
```
**Nota**
Potresti visualizzare "hoodie" invece di Hudi negli esempi di codice e nelle notifiche. La base di codice Hudi utilizza ampiamente la vecchia ortografia "hoodie".
**DataSourceWriteOptions riferimento per Hudi**
| Opzione | Description |
| --- | --- |
| TABLE\$1NAME | Il nome della tabella in cui registrare il set di dati. |
| TABLE\$1TYPE\$1OPT\$1KEY | Opzionale. Specificare se il set di dati viene creato come `"COPY_ON_WRITE"` o `"MERGE_ON_READ"`. Il valore predefinito è `"COPY_ON_WRITE"`. |
| RECORDKEY\$1FIELD\$1OPT\$1KEY | Il campo chiave record il cui valore verrà utilizzato come componente `recordKey` di `HoodieKey`. Il valore effettivo sarà ottenuto richiamando `.toString()` sul valore del campo. I campi nidificati possono essere specificati utilizzando la notazione con punti, ad esempio `a.b.c`. |
| PARTITIONPATH\$1FIELD\$1OPT\$1KEY | Il campo del percorso di partizione il cui valore verrà utilizzato come componente `partitionPath` di `HoodieKey`. Il valore effettivo sarà ottenuto richiamando `.toString()` sul valore del campo. |
| PRECOMBINE\$1FIELD\$1OPT\$1KEY | Il campo utilizzato nella pre-combinazione prima della scrittura effettiva. Quando due registri hanno lo stesso valore chiave, Hudi seleziona quello con il valore più grande per il campo di precombinazione come determinato da `Object.compareTo(..)`. |
Le seguenti opzioni sono necessarie solo per registrare la tabella del set di dati Hudi nel metastore. Se non si registra il set di dati Hudi come tabella nel metastore Hive, queste opzioni non sono necessarie.
**DataSourceWriteOptions riferimento per Hive**
| Opzione | Description |
| --- | --- |
| HIVE\$1DATABASE\$1OPT\$1KEY | Il database Hive da sincronizzare. Il valore predefinito è `"default"`. |
| HIVE\$1PARTITION\$1EXTRACTOR\$1CLASS\$1OPT\$1KEY | La classe utilizzata per estrarre i valori dei campi delle partizioni nelle colonne delle partizioni Hive. |
| HIVE\$1PARTITION\$1FIELDS\$1OPT\$1KEY | Campo nel set di dati da utilizzare per determinare le colonne di partizione Hive. |
| HIVE\$1SYNC\$1ENABLED\$1OPT\$1KEY | Quando impostato su `"true"`, registra il set di dati con il metastore Apache Hive. Il valore predefinito è `"false"`. |
| HIVE\$1TABLE\$1OPT\$1KEY | Obbligatorio. Il nome della tabella in Hive da sincronizzare. Ad esempio, `"my_hudi_table_cow"`. |
| HIVE\$1USER\$1OPT\$1KEY | Opzionale. Il nome utente Hive da utilizzare durante la sincronizzazione. Ad esempio, `"hadoop"`. |
| HIVE\$1PASS\$1OPT\$1KEY | Opzionale. La password Hive per l'utente specificato da `HIVE_USER_OPT_KEY`. |
| HIVE\$1URL\$1OPT\$1KEY | L'URL del metastore Hive. |
## Upsert dei dati
L'esempio seguente mostra come modificare i dati scrivendo un. DataFrame A differenza dell'esempio di inserimento precedente, il valore `OPERATION_OPT_KEY` è impostato su `UPSERT_OPERATION_OPT_VAL`. Inoltre, `.mode(SaveMode.Append)` è specificato per indicare che il record deve essere aggiunto.
### Upsert utilizzando Scala con Amazon EMR rilascio 6.7 e successivi
**Nota**
Amazon EMR 6.7.0 impiega [Apache Hudi](https://hudi.apache.org/) 0.11.0-amzn-0, che contiene miglioramenti significativi rispetto alle versioni precedenti di Hudi. Per ulteriori informazioni, consulta la sezione [Apache Hudi 0.11.0 Migration Guide](https://hudi.apache.org/releases/release-0.11.0/#migration-guide) (Guida alla migrazione di Apache Hudi 0.11.0). Gli esempi in questa scheda riflettono tali modifiche.
```
// 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 utilizzando Scala con Amazon EMR 6.6 e rilasci precedenti
```
// 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/"))
```
### Uso di Upsert 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/')
```
## Eliminazione di un registro
Per eliminare un registro, è possibile eseguire l'upsert di un payload vuoto. In questo caso, l'opzione `PAYLOAD_CLASS_OPT_KEY` specifica la classe `EmptyHoodieRecordPayload`. L'esempio utilizza lo stesso DataFrame`updateDF`, usato nell'esempio upsert per specificare lo stesso record.
### Eliminazione utilizzando Scala con Amazon EMR rilascio 6.7 e successivi
**Nota**
Amazon EMR 6.7.0 impiega [Apache Hudi](https://hudi.apache.org/) 0.11.0-amzn-0, che contiene miglioramenti significativi rispetto alle versioni precedenti di Hudi. Per ulteriori informazioni, consulta la sezione [Apache Hudi 0.11.0 Migration Guide](https://hudi.apache.org/releases/release-0.11.0/#migration-guide) (Guida alla migrazione di Apache Hudi 0.11.0). Gli esempi in questa scheda riflettono tali modifiche.
```
(updateDF.write
.format("hudi")
.options(hudiOptions)
.option(DataSourceWriteOptions.OPERATION_OPT_KEY, "delete")
.mode(SaveMode.Append)
.save("s3://amzn-s3-demo-bucket/myhudidataset/"))
```
### Eliminazione utilizzando Scala con Amazon EMR 6.6 e rilasci precedenti
```
(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/"))
```
### Elimina usando 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/')
```
È inoltre possibile eliminare i dati impostando `OPERATION_OPT_KEY ` su `DELETE_OPERATION_OPT_VAL` per rimuovere tutti i registri nel set di dati inviato. Per istruzioni sull'esecuzione delle eliminazioni soft e per ulteriori informazioni sull'eliminazione dei dati archiviati nelle tabelle Hudi, consulta [Deletes (Eliminazioni)](https://hudi.apache.org/docs/writing_data.html#deletes) nella documentazione di Apache Hudi.
## Lettura da un set di dati Hudi
Per recuperare i dati al momento attuale, Hudi esegue query degli snapshot per impostazione predefinita. Di seguito è riportato un esempio di interrogazione del set di dati scritto su S3 in [Scrittura in un set di dati Hudi](#emr-hudi-dataframe). Sostituisci *s3://amzn-s3-demo-bucket/myhudidataset* con il percorso della tabella e aggiungi asterischi con caratteri jolly per ogni livello di partizione, *più* un asterisco aggiuntivo. Dal momento che questo esempio mostra un livello di partizione, sono stati aggiunti due simboli jolly.
### Lettura utilizzando Scala con Amazon EMR rilascio 6.7 e successivi
**Nota**
Amazon EMR 6.7.0 impiega [Apache Hudi](https://hudi.apache.org/) 0.11.0-amzn-0, che contiene miglioramenti significativi rispetto alle versioni precedenti di Hudi. Per ulteriori informazioni, consulta la sezione [Apache Hudi 0.11.0 Migration Guide](https://hudi.apache.org/releases/release-0.11.0/#migration-guide) (Guida alla migrazione di Apache Hudi 0.11.0). Gli esempi in questa scheda riflettono tali modifiche.
```
val snapshotQueryDF = spark.read
.format("hudi")
.load("s3://amzn-s3-demo-bucket/myhudidataset")
.show()
```
### Lettura utilizzando Scala con Amazon EMR 6.6 e rilasci precedenti
```
(val snapshotQueryDF = spark.read
.format("org.apache.hudi")
.load("s3://amzn-s3-demo-bucket/myhudidataset" + "/*/*"))
snapshotQueryDF.show()
```
### Leggi usando PySpark
```
snapshotQueryDF = spark.read \
.format('org.apache.hudi') \
.load('s3://amzn-s3-demo-bucket/myhudidataset' + '/*/*')
snapshotQueryDF.show()
```
### Query incrementali
È inoltre possibile eseguire query incrementali con Hudi per ottenere un flusso di registri che hanno subito modifiche a partire da un dato timestamp di commit. Per fare questo, imposta il campo `QUERY_TYPE_OPT_KEY` su `QUERY_TYPE_INCREMENTAL_OPT_VAL`. Quindi, aggiungi un valore per `BEGIN_INSTANTTIME_OPT_KEY` per ottenere tutti i registri scritti dall'ora specificata. Le query incrementali sono in genere dieci volte più efficienti rispetto alle controparti batch poiché elaborano solo i registri modificati.
Quando si eseguono query incrementali, utilizza il percorso della tabella radice (di base) senza gli asterischi jolly utilizzati per le query degli snapshot.
**Nota**
Presto non supporta le query incrementali.
#### Query incrementali utilizzando 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()
```
#### Interrogazioni incrementali utilizzando 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()
```
Per ulteriori informazioni sulla lettura dai set di dati Hudi, consulta [Esecuzione di query sulle tabelle Hudi](https://hudi.apache.org/docs/querying_data.html) nella documentazione di Apache Hudi.
# Utilizzo della CLI Hudi
È possibile utilizzare la CLI Hudi per gestire i set di dati Hudi e visualizzare informazioni su commit, file system, statistiche e altro ancora. È inoltre possibile utilizzare la CLI per eseguire manualmente le compattazioni, pianificare le compattazioni o annullare le compattazioni pianificate. Per ulteriori informazioni, consulta [Interazione tramite CLI](https://hudi.apache.org/docs/cli/) nella documentazione di Apache Hudi.
**Avvio della CLI Hudi e connessione a un set di dati**
1. Connessione al nodo master tramite SSH Per ulteriori informazioni, consulta [Connessione al nodo master tramite SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) nella *Guida alla gestione di Amazon EMR*.
1. Nella riga di comando, digita `/usr/lib/hudi/cli/bin/hudi-cli.sh`.
Il prompt dei comandi viene modificato in `hudi->`.
1. Usa il seguente comando per connetterti a un set di dati. Sostituisci *s3://amzn-s3-demo-bucket/myhudidataset* con il percorso del set di dati con cui desideri lavorare. Il valore che usiamo è lo stesso del valore stabilito negli esempi precedenti.
```
connect --path s3://amzn-s3-demo-bucket/myhudidataset
```
Il prompt dei comandi cambia per includere il set di dati a cui si è connessi, come illustrato nell'esempio seguente.
```
hudi:myhudidataset->
```
Per impostazione predefinita, lo `hudi-cli.sh` script in Amazon EMR dalle release da 7.3.0 a 7.8.0 utilizza. `hudi-cli-bundle.jar` Se riscontri problemi, puoi tornare alla classica CLI di Hudi con il seguente comando:
```
/usr/lib/hudi/cli/bin/hudi-cli.sh --cliBundle false
```
Questo comando esegue lo `hudi-cli.sh` script, imposta il `--cliBundle` flag e indica alla CLI di utilizzare i singoli file JAR anziché il JAR in bundle. Per impostazione predefinita, `--cliBundle` è impostato su true, il che significa che la CLI utilizza invece il JAR in bundle.
## Utilizzo di Amazon EMR 7.9.0 e versioni successive
**Nota**
Lo script **hudi-cli.sh** è stato dichiarato obsoleto nella release EMR 7.9.0 e successive. **Amazon EMR versione 7.9.0 e successive utilizza.jar. hudi-cli-bundle**
**Per avviare la CLI Hudi e connettersi a un set di dati:**
1. Connessione al nodo master tramite SSH Per ulteriori informazioni, consulta [Connessione al nodo master tramite SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) nella *Guida alla gestione di Amazon EMR*.
1. **Nella riga di comando, digita**/usr/lib/hudi/cli-bundle/bin/hudi- cli-with-bundle .sh** o semplicemente digita o >hudi-cli. **hudi-cli-with-bundle****
**Il prompt dei comandi cambia in hudi- >.**
1. Utilizzate il comando seguente per connettervi a un set di dati. Sostituisci **s3://amzn-s3-demo-bucket/myhudidataset** con il percorso del set di dati con cui desideri lavorare. Il valore che usiamo è lo stesso del valore stabilito negli esempi precedenti.
```
connect --path s3://amzn-s3-demo-bucket/myhudidataset
```
1. Il prompt dei comandi cambia per includere il set di dati a cui si è connessi, come illustrato nell'esempio seguente.
```
hudi:myhudidataset->
```
# Cronologia dei rilasci di Hudi
La seguente tabella indica la versione di Hudi inclusa in ogni rilascio di Amazon EMR e i componenti installati con l'applicazione. Per le versioni dei componenti in ogni rilascio, consulta la sezione Versione componente per il rilascio in [Versioni del rilascio di Amazon EMR 7.x](emr-release-7x.md), [Versioni di rilascio di Amazon EMR 6.x](emr-release-6x.md) o [Versioni del rilascio di Amazon EMR 5.x](emr-release-5x.md).
**Informazioni sulla versione di Hudi**
| Etichetta di rilascio di Amazon EMR | Versione di Hudi | Componenti installati con 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. |
| emr-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. |