Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Hudi
[Apache Hudi](https://hudi.apache.org/) es un marco de administración de datos de código abierto que se utiliza para simplificar el procesamiento incremental de los datos y el desarrollo de canalizaciones de datos, porque proporciona, en el nivel de registro, prestaciones de inserción, actualización, upsert y eliminación. *Upsert* se refiere a la capacidad de insertar registros en un dataset si aún no existen o de actualizarlos en caso de que ya estén presentes. Al administrar de manera eficiente la forma en que se establecen los datos en Amazon S3, Hudi permite que los datos se inserten y actualicen prácticamente en tiempo real. Hudi mantiene cuidadosamente los metadatos de las acciones realizadas en el conjunto de datos para ayudar a garantizar que las acciones sean atómicas y coherentes.
Hudi está integrado con [Apache Spark](https://aws.amazon.com/emr/features/spark/), [Apache Hive](https://hive.apache.org/) y [Presto](https://prestodb.github.io). En las versiones 6.1.0 y posteriores de Amazon EMR, Hudi también está integrado con [Trino (PrestoSQL)](https://trino.io/).
Con la versión 5.28.0 y posteriores de Amazon EMR, EMR instala los componentes de Hudi de forma predeterminada cuando se instalan Spark, Hive, Presto o Flink. Puedes usar Spark o la DeltaStreamer utilidad Hudi para crear o actualizar conjuntos de datos Hudi. Puede utilizar Hive, Spark, Presto o Flink para consultar un conjunto de datos de Hudi de forma interactiva o crear canalizaciones de procesamiento de datos mediante la *extracción incremental*. La extracción incremental se refiere a la capacidad de extraer únicamente los datos que han cambiado entre dos acciones.
Estas características hacen que Hudi sea adecuado para los siguientes casos de uso:
+ Trabajo con datos de transmisión desde sensores y otros dispositivos del Internet de las cosas (IoT) que requieren eventos específicos de inserción y actualización de datos.
+ Cumplimiento de la normativa de privacidad de datos en aplicaciones cuyos usuarios pueden ejercer su derecho al olvido o modificar su consentimiento para el uso de sus datos.
+ Implementación de un [sistema de captura de datos de cambio (CDC)](https://en.wikipedia.org/wiki/Change_data_capture) que permita aplicar cambios a un dataset a lo largo del tiempo.
En la siguiente tabla, se muestra la versión de Hudi incluida en la última versión de la serie 7.x de Amazon EMR, junto con los componentes que Amazon EMR instala con Hudi.
[Para ver la versión de los componentes instalados con Hudi en esta versión, consulta Versiones de componentes de la versión 7.12.0.](emr-7120-release.md)
**Información sobre la versión de Hudi para emr-7.12.0**
| Etiqueta de versión de Amazon EMR | Versión de Hudi | Componentes instalados con Hudi |
| --- | --- | --- |
| emr-7.12.0 | Hudi 1.0.2-amzn-1 | Not available. |
En la tabla siguiente, se muestra la versión de Hudi incluida en la última versión de la serie Amazon EMR 6.x, junto con los componentes que Amazon EMR instala con Hudi.
Para ver la versión de los componentes instalados con Hudi en esta versión, consulte [Versiones de los componentes de la versión 6.15.0](emr-6150-release.md).
**Información de la versión de Hudi para emr-6.15.0**
| Etiqueta de versión de Amazon EMR | Versión de Hudi | Componentes instalados con Hudi |
| --- | --- | --- |
| emr-6.15.0 | Hudi 0.14.0-amzn-0 | Not available. |
**nota**
Amazon EMR 6.8.0 viene con [Apache Hudi](https://hudi.apache.org/) 0.11.1; sin embargo, los clústeres de Amazon EMR 6.8.0 también son compatibles con el código abierto `hudi-spark3.3-bundle_2.12` de Hudi 0.12.0.
En la tabla siguiente, se muestra la versión de Hudi incluida en la última versión de la serie Amazon EMR 5.x, junto con los componentes que Amazon EMR instala con Hudi.
Para ver la versión de los componentes instalados con Hudi en esta versión, consulte [Versiones del componente de la versión 5.36.2](emr-5362-release.md).
**Información de la versión de Hudi para emr-5.36.2**
| Etiqueta de versión de Amazon EMR | Versión de Hudi | Componentes instalados con Hudi |
| --- | --- | --- |
| emr-5.36.2 | Hudi 0.10.1-amzn-1 | Not available. |
**Topics**
+ [Cómo funciona Hudi](emr-hudi-how-it-works.md)
+ [Consideraciones y limitaciones para usar Hudi en Amazon EMR](emr-hudi-considerations.md)
+ [Crear un clúster con Hudi instalado](emr-hudi-installation-and-configuration.md)
+ [Uso de un conjunto de datos de Hudi](emr-hudi-work-with-dataset.md)
+ [Usar la CLI de Hudi](emr-hudi-cli.md)
+ [Historial de versiones de Hudi](Hudi-release-history.md)
# Cómo funciona Hudi
Al usar Hudi con Amazon EMR, puede escribir datos en el conjunto de datos mediante la API de fuente de datos de Spark o la DeltaStreamer utilidad Hudi. Hudi organiza un conjunto de datos en una estructura de directorios particionada en una estructura similar a la de `basepath`, que es similar a una tabla de Hive tradicional. Los detalles de cómo se disponen los datos en archivos en estos directorios dependen del tipo de dataset que se elija. Puede elegir entre copiar al escribir (CoW, Copy on Write) o fusionar al leer (MOR, Merge on Read).
Independientemente del tipo de dataset, cada partición que contiene se identifica de forma única por su `partitionpath` relativa a `basepath`. Dentro de cada partición, los registros se distribuyen en varios archivos de datos. Para obtener más información, consulte el artículo sobre [administración de archivos](https://hudi.apache.org/docs/concepts.html#file-management) en la documentación de Apache Hudi.
Cada acción de Hudi tiene una confirmación correspondiente, que se identifica mediante una marca de tiempo que aumenta de forma monótona y se conoce como *Instant*. Hudi guarda una serie de todas las acciones hechas en el conjunto de datos en forma de cronología. Hudi se basa en la cronología para aislar instantáneamente a lectores y escritores, y para poder retroceder a un punto anterior en el tiempo. Para obtener más información acerca de las acciones que Hudi registra y el estado de las acciones, consulte [Cronologías](https://hudi.apache.org/docs/concepts.html#timeline) en la documentación de Apache Hudi.
## Descripción de los tipos de almacenamiento de conjuntos de datos: escribir frente a combinar al leer
Cuando se crea un conjunto de datos de Hudi, se especifica si será de tipo copiar al escribir o fusionar al leer.
+ **Copiar al escribir (CoW, Copy on Write)**: los datos se almacenan en un formato de columnas (Parquet) y cada actualización crea una nueva versión de los archivos durante una escritura. CoW es el tipo de almacenamiento predeterminado.
+ **Fusionar al leer (MoR, Merge on Read)**: los datos se almacenan utilizando un formato que combina columnas (Parquet) y filas (Avro). Las actualizaciones se registran en archivos *delta* basados en filas y se compactan según sea necesario para crear nuevas versiones de los archivos en columnas.
Con los datasets de tipo CoW, cada vez que se produce una actualización de un registro, el archivo que contiene el registro se vuelve a escribir con los valores actualizados. Con un conjunto de datos de tipo MoR, cada vez que hay una actualización, Hudi escribe solo la fila correspondiente al registro modificado. MoR es más adecuado para cargas de trabajo con gran cantidad de escrituras o cambios y menos lecturas. CoW es más adecuado para cargas de trabajo con gran cantidad de lecturas con datos que cambian con menos frecuencia.
Hudi proporciona tres vistas lógicas para acceder a los datos:
+ **Vista optimizada de lectura**: proporciona el último conjunto de datos confirmado a partir de las tablas CoW y el último conjunto de datos compactado a partir de las tablas MoR.
+ **Vista incremental**: proporciona una secuencia de cambios entre dos acciones procedentes de un conjunto de datos CoW para alimentar los trabajos posteriores y extraer, transformar y los flujos de trabajo de extracción, transformación y carga (ETL).
+ **Vista en tiempo real**: proporciona los datos confirmados más recientes de una tabla MoR; para ello, fusiona en línea los archivos en columnas y basados en filas.
Cuando se consulta la vista optimizada para lectura, la consulta devuelve todos los datos compactados, pero no incluye las últimas confirmaciones delta. La consulta de estos datos proporciona un buen rendimiento de lectura, pero omite los datos más recientes. Cuando se consulta la vista en tiempo real, Hudi fusiona los datos compactados con las confirmaciones delta durante la lectura. Los datos más recientes están disponibles para consultarlos, pero fusionarlos genera una sobrecarga computacional que hace que la consulta sea menos eficiente. La capacidad de consultar datos compactados o datos en tiempo real permite elegir entre rendimiento y flexibilidad al realizar consultas.
Para obtener más información acerca de las ventajas e inconvenientes de ambos los tipos de almacenamiento, consulte [Tipos y vistas de almacenamiento](https://hudi.apache.org/docs/concepts.html#storage-types--views) en la documentación de Apache Hudi.
Hudi crea dos tablas en el metaalmacén de Hive para MoR: una tabla con el nombre que especificó, que es una vista optimizada para lectura, y una tabla con el mismo nombre al que se ha anexado `_rt`, que es una vista en tiempo real. Puede consultar ambas tablas.
## Registro de un conjunto de datos de Hudi con su metaalmacén
Si registra una tabla de Hudi con el metaalmacén de Hive, puede consultar las tablas de Hudi mediante Hive, Spark SQL o Presto como haría con cualquier otra tabla. Además, puedes integrar Hudi con AWS Glue configurando Hive y Spark para que usen el catálogo de datos de AWS Glue como metaalmacén. Para las tablas de MoR, Hudi registra el conjunto de datos como dos tablas en el metaalmacén: una tabla con el nombre que especificó, que es una vista optimizada para lectura, y una tabla con el mismo nombre al que se ha anexado `_rt`, que es una vista en tiempo real.
Para registrar una tabla de Hudi con el metaalmacén de Hive al usar Spark para crear un conjunto de datos de Hudi, configure la opción `HIVE_SYNC_ENABLED_OPT_KEY` en `"true"` e indique otras propiedades requeridas. Para obtener más información, consulte [Uso de un conjunto de datos de Hudi](emr-hudi-work-with-dataset.md). Además, puede utilizar la utilidad de línea de comandos hive\$1sync\$1tool para registrar un conjunto de datos de Hudi como tabla en el metaalmacén, por separado.
# Consideraciones y limitaciones para usar Hudi en Amazon EMR
+ **El campo de clave de registro no puede ser nulo ni estar vacío**: el campo especificado como campo de clave de registro no puede tener valores `null` ni estar vacío.
+ **Esquema actualizado de forma predeterminada al insertar y colocar**: Hudi proporciona una interfaz `HoodieRecordPayload` que determina cómo se combinan el conjunto de datos Hudi de entrada DataFrame y el existente para producir un conjunto de datos nuevo y actualizado. Hudi proporciona una implementación predeterminada de esta clase`OverwriteWithLatestAvroPayload`, que sobrescribe los registros existentes y actualiza el esquema según se especifica en la entrada. DataFrame Para personalizar esta lógica con el fin de implementar actualizaciones parciales y fusiones, puede proporcionar una implementación de la interfaz `HoodieRecordPayload` mediante el parámetro `DataSourceWriteOptions.PAYLOAD_CLASS_OPT_KEY`.
+ **La eliminación requiere un esquema**: al eliminar, debe especificar la clave de registro, la clave de partición y los campos de clave de combinación previa. Se puede hacer que otras columnas sean `null` o estén vacías, pero se requiere el esquema completo.
+ **Limitaciones de las tablas MoR**: las tablas MoR no admiten puntos de guardado. Puede consultar las tablas MoR mediante la vista optimizada para lectura o la vista en tiempo real (`tableName_rt`) de Spark SQL, Presto o Hive. El uso de la vista optimizada para lectura solo expone los datos del archivo base y no expone una vista combinada de los datos base y de registro.
+ **Hive**
+ Para registrar tablas en el metaalmacén de Hive, Hudi espera que el servidor Hive Thrift se ejecute en el puerto predeterminado, `10000`. Si se sustituye este puerto por un puerto personalizado, es preciso pasar la opción `HIVE_URL_OPT_KEY` como se muestra en el siguiente ejemplo.
```
.option(DataSourceWriteOptions.HIVE_URL_OPT_KEY, "jdbc:hive2://localhost:override-port-number
```
+ El tipo de datos `timestamp` de Spark se registra como tipo de datos `long` en Hive, pero no como el tipo `timestamp` de Hive.
+ **Presto**
+ Presto no admite la lectura de tablas MoR en tiempo real en versiones de Hudi anteriores a 0.6.0.
+ Presto solo admite consultas de instantáneas.
+ Para que Presto interprete correctamente las columnas del conjunto de datos de Hudi, establezca el valor de `hive.parquet_use_column_names` en `true`.
+ Para establecer el valor de una sesión, en el shell de Presto, ejecute el siguiente comando:
```
set session hive.parquet_use_column_names=true
```
+ Para establecer el valor en el nivel de clúster, utilice la clasificación de configuración `presto-connector-hive` para establecer `hive.parquet.use_column_names` en `true`, como se muestra en el ejemplo siguiente. Para obtener más información, consulte [Configuración de aplicaciones](emr-configure-apps.md).
```
[
{
"Classification": "presto-connector-hive",
"Properties": {
"hive.parquet.use-column-names": "true"
}
}
]
```
+ **HBase Índice**
+ La HBase versión utilizada para *compilar* Hudi puede ser diferente de la que aparece en la Guía de versiones de EMR. Para obtener las dependencias correctas para la sesión de Spark, ejecute el siguiente comando.
```
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"
```
+ **Configuración para obtener el mejor rendimiento**: para EMR 7.3\$1/Hudi 0.15\$1, se recomienda a los clientes establecer esta configuración para reducir la sobrecarga de serialización de Kryo:
```
--conf 'spark.kryo.registrator=org.apache.spark.HoodieKryoRegistrar'
```
**nota**
Si utiliza un control de acceso detallado (FGAC) en EMR Serverless, esta configuración no es necesaria, ya que los usuarios deben utilizarla en lugar de. JavaSerializer KryoSerializer
# Crear un clúster con Hudi instalado
Con la versión 5.28.0 y posteriores de Amazon EMR, Amazon EMR instala los componentes de Hudi de forma predeterminada cuando se instalan Spark, Hive o Presto. Para utilizar Hudi en Amazon EMR, cree un clúster con una o varias de las siguientes aplicaciones instaladas:
+ Hadoop
+ Hive
+ Spark
+ Presto
+ Flink
Puede crear un clúster mediante la Consola de administración de AWS AWS CLI, la o la API de Amazon EMR.
## Para crear un clúster con Hudi mediante la Consola de administración de AWS
1. Vaya hasta la nueva consola de Amazon EMR y seleccione **Ir a la consola antigua** en el panel de navegación lateral. Para más información sobre lo que puede esperar al cambiar a la consola antigua, consulte [Uso de la consola antigua](https://docs.aws.amazon.com/emr/latest/ManagementGuide/whats-new-in-console.html#console-opt-in).
1. Elija **Crear clúster** e **Ir a las opciones avanzadas**.
1. En Configuración de software, elija **emr-5.28.0** o posterior para **Versión** y seleccione **Hadoop**, **Hive**, **Spark**, **Presto** y **Tez**, así como las demás aplicaciones que el clúster requiera.
1. Configure otras opciones según sea necesario para la aplicación y, a continuación, elija **Next (Siguiente)**.
1. Configure las opciones de **Hardware (Hardware)** y **General cluster settings (Configuración general del clúster)** según lo desee.
1. En **Security Options (Opciones de seguridad)**, recomendamos seleccionar un **EC2 key pair (Par de claves de EC2)** que pueda utilizar para conectarse a la línea de comandos del nodo principal mediante SSH. Esto le permitirá ejecutar los comandos del intérprete de comandos de Spark, los comandos de la CLI de Hudi y los comandos de la CLI de Hudi descritos en esta guía.
1. Configure las demás opciones de seguridad como desee y elija **Create cluster (Crear clúster)**.
# Uso de un conjunto de datos de Hudi
Hudi permite insertar, actualizar y eliminar datos de conjuntos de datos de Hudi a través de Spark. Para obtener más información, consulte [Escritura de tablas de Hudi](https://hudi.apache.org/docs/writing_data.html) en la documentación de Apache Hudi.
En los siguientes ejemplos, se muestra cómo iniciar el intérprete de comandos interactivo de Spark, utilizar el envío de Spark o usar Cuadernos de Amazon EMR para trabajar con Hudi en Amazon EMR. También puedes usar la DeltaStreamer utilidad Hudi u otras herramientas para escribir en un conjunto de datos. En esta sección, los ejemplos muestran cómo trabajar con datasets usando el shell de Spark mientras está conectado al nodo principal usando SSH como usuario predeterminado de `hadoop`.
## Iniciar el intérprete de comandos de Spark con Amazon EMR 6.7 y versiones posteriores
Cuando ejecute `spark-shell`, `spark-submit` o `spark-sql` con Amazon EMR 6.7.0 o una versión posterior, ejecute los siguientes comandos.
**nota**
Amazon EMR 6.7.0 usa [Apache Hudi](https://hudi.apache.org/) 0.11.0-amzn-0, que contiene mejoras significativas con respecto a las versiones anteriores de Hudi. Para obtener más información, consulte la [Guía de migración a Apache Hudi 0.11.0](https://hudi.apache.org/releases/release-0.11.0/#migration-guide). Los ejemplos de esta pestaña reflejan estos cambios.
**Para abrir el intérprete de comandos de Spark en el nodo principal**
1. Conéctese al nodo principal mediante SSH. Para obtener más información, consulte [Conectarse al nodo principal mediante SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) en la *Guía de administración de Amazon EMR*.
1. Introduzca el siguiente comando para iniciar el shell de Spark. Para usar la PySpark carcasa, sustitúyala por*spark-shell*. *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"
```
## Iniciar el intérprete de comandos de Spark con Amazon EMR 6.6 y versiones anteriores
Cuando ejecute `spark-shell`, `spark-submit` o `spark-sql` con Amazon EMR 6.6.x o una versión posterior, ejecute los siguientes comandos.
**nota**
Amazon EMR 6.2 y 5.31 y versiones posteriores (Hudi 0.6.x y versiones posteriores) pueden omitir `spark-avro.jar` en la configuración.
Amazon EMR 6.5 y 5.35 y versiones posteriores (Hudi 0.9.x y versiones posteriores) pueden omitir `spark.sql.hive.convertMetastoreParquet=false` en la configuración.
Amazon EMR 6.6 y 5.36 y versiones posteriores (Hudi 0.10.x y versiones posteriores) deben incluir la configuración de `HoodieSparkSessionExtension` descrita en la [Guía de la versión 0.10.0 de Spark](https://hudi.apache.org/docs/0.10.0/quick-start-guide/):
```
--conf "spark.sql.extensions=org.apache.spark.sql.hudi.HoodieSparkSessionExtension" \
```
**Para abrir el intérprete de comandos de Spark en el nodo principal**
1. Conéctese al nodo principal mediante SSH. Para obtener más información, consulte [Conectarse al nodo principal mediante SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) en la *Guía de administración de Amazon EMR*.
1. Introduzca el siguiente comando para iniciar el shell de Spark. Para usar la PySpark carcasa, *spark-shell* sustitúyala por*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
```
## Utilizar Hudi con Cuadernos de Amazon EMR que utilicen Amazon EMR 6.7 y versiones posteriores
Para utilizar Hudi con Cuadernos de Amazon EMR, antes debe copiar los archivos jar de Hudi del sistema de archivos local a HDFS en el nodo maestro del clúster de bloc de notas. A continuación, puede utilizar el editor de cuadernos para configurar el cuaderno de EMR de modo que utilice Hudi.
**Para usar Hudi con Cuadernos de Amazon EMR**
1. Cree y lance un clúster para Cuadernos de Amazon EMR. Para más información, consulte [Creación de clústeres de Amazon EMR para cuadernos](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-managed-notebooks-cluster.html) en la *Guía de administración de Amazon EMR*.
1. Conéctese al nodo principal del clúster mediante SSH y, a continuación, copie los archivos jar desde el sistema de archivos local a HDFS, como se muestra en los ejemplos siguientes. En el ejemplo, creamos un directorio en HDFS para que la administración de archivos resulte más clara. Puede elegir su propio destino en HDFS, si lo desea.
```
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. Abra el editor de bloc de notas, escriba el código del siguiente ejemplo y ejecútelo.
```
%%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"
}}
```
## Utilizar Hudi con Cuadernos de Amazon EMR que utilicen Amazon EMR 6.6 y versiones anteriores
Para utilizar Hudi con Cuadernos de Amazon EMR, antes debe copiar los archivos jar de Hudi del sistema de archivos local a HDFS en el nodo maestro del clúster de bloc de notas. A continuación, puede utilizar el editor de cuadernos para configurar el cuaderno de EMR de modo que utilice Hudi.
**Para usar Hudi con Cuadernos de Amazon EMR**
1. Cree y lance un clúster para Cuadernos de Amazon EMR. Para más información, consulte [Creación de clústeres de Amazon EMR para cuadernos](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-managed-notebooks-cluster.html) en la *Guía de administración de Amazon EMR*.
1. Conéctese al nodo principal del clúster mediante SSH y, a continuación, copie los archivos jar desde el sistema de archivos local a HDFS, como se muestra en los ejemplos siguientes. En el ejemplo, creamos un directorio en HDFS para que la administración de archivos resulte más clara. Puede elegir su propio destino en HDFS, si lo desea.
```
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. Abra el editor de bloc de notas, escriba el código del siguiente ejemplo y ejecútelo.
```
{ "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"
}}
```
## Iniciar una sesión de Spark para Hudi
Al usar Scala, debe importar las siguientes clases a su sesión de Spark. Esto debe hacerse una vez por cada sesión de 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
```
## Escribir en un conjunto de datos de Hudi
Los siguientes ejemplos muestran cómo crear un conjunto de datos de Hudi DataFrame y cómo escribirlo como tal.
**nota**
Para pegar muestras de código en el shell de Spark, escriba **:paste** en el símbolo del sistema, pegue el ejemplo y, a continuación, pulse **CTRL** \$1 **D**.
Cada vez que escribas DataFrame a en un conjunto de datos de Hudi, debes especificarlo. `DataSourceWriteOptions` Es probable que muchas de estas opciones sean idénticas en varias operaciones de escritura. En el ejemplo siguiente se especifican las opciones comunes mediante la variable `hudiOptions`, que se usa en los ejemplos posteriores.
### Escribir con Scala con Amazon EMR 6.7 y versiones posteriores
**nota**
Amazon EMR 6.7.0 usa [Apache Hudi](https://hudi.apache.org/) 0.11.0-amzn-0, que contiene mejoras significativas con respecto a las versiones anteriores de Hudi. Para obtener más información, consulte la [Guía de migración a Apache Hudi 0.11.0](https://hudi.apache.org/releases/release-0.11.0/#migration-guide). Los ejemplos de esta pestaña reflejan estos cambios.
```
// 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/"))
```
### Escribir con Scala con Amazon EMR 6.6 y versiones anteriores
```
// 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/"))
```
### Escribe 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**
Es posible que vea “hoodie” en lugar de Hudi en los ejemplos de código y las notificaciones. El código base de Hudi utiliza ampliamente la antigua palabra “hoodie”.
**DataSourceWriteOptions referencia para Hudi**
| Opción | Description (Descripción) |
| --- | --- |
| TABLE\$1NAME | Nombre de la tabla bajo la que se registra el dataset. |
| TABLE\$1TYPE\$1OPT\$1KEY | Opcional. Especifica si el dataset que se va a crear será de tipo `"COPY_ON_WRITE"` o `"MERGE_ON_READ"`. El valor predeterminado es `"COPY_ON_WRITE"`. |
| RECORDKEY\$1FIELD\$1OPT\$1KEY | Campo de clave de registro cuyo valor se utilizará como componente `recordKey` de `HoodieKey`. El valor real se obtendrá invocando `.toString()` para el valor del campo. Los campos anidados se pueden especificar mediante la notación de puntos; por ejemplo, `a.b.c`. |
| PARTITIONPATH\$1FIELD\$1OPT\$1KEY | Campo de la ruta de partición cuyo valor se utilizará como componente `partitionPath` de `HoodieKey`. El valor real se obtendrá invocando `.toString()` para el valor del campo. |
| PRECOMBINE\$1FIELD\$1OPT\$1KEY | Campo utilizado en la combinación previa antes de la escritura real. Cuando dos registros tienen el mismo valor de clave, Hudi selecciona el que tiene el valor mayor para el campo de combinación previa, según lo determinado por `Object.compareTo(..)`. |
Las siguientes opciones solo son necesarias para registrar la tabla del conjunto de datos de Hudi en su metaalmacén. Si no registra el conjunto de datos de Hudi como tabla en el metaalmacén de Hudi, estas opciones no son necesarias.
**DataSourceWriteOptions referencia para Hive**
| Opción | Description (Descripción) |
| --- | --- |
| HIVE\$1DATABASE\$1OPT\$1KEY | Base de datos Hive con la que se realizará la sincronización. El valor predeterminado es `"default"`. |
| HIVE\$1PARTITION\$1EXTRACTOR\$1CLASS\$1OPT\$1KEY | Clase utilizada para extraer valores de los campos de partición a las columnas de partición de Hive. |
| HIVE\$1PARTITION\$1FIELDS\$1OPT\$1KEY | Campo del dataset que se utilizará para determinar las columnas de partición de Hive. |
| HIVE\$1SYNC\$1ENABLED\$1OPT\$1KEY | Cuando se establece en `"true"`, registra el dataset en el metaalmacén de Apache Hive. El valor predeterminado es `"false"`. |
| HIVE\$1TABLE\$1OPT\$1KEY | Obligatorio. Nombre de la tabla de Hive con la que se va a realizar la sincronización. Por ejemplo, `"my_hudi_table_cow"`. |
| HIVE\$1USER\$1OPT\$1KEY | Opcional. Nombre de usuario de Hive que se va a utilizar al sincronizar. Por ejemplo, `"hadoop"`. |
| HIVE\$1PASS\$1OPT\$1KEY | Opcional. Contraseña de Hive para el usuario especificado por `HIVE_USER_OPT_KEY`. |
| HIVE\$1URL\$1OPT\$1KEY | Dirección URL del metaalmacén de Hive. |
## Datos de upsert
El siguiente ejemplo muestra cómo alterar los datos escribiendo un. DataFrame A diferencia del ejemplo de inserción anterior, el valor de `OPERATION_OPT_KEY` se establece en `UPSERT_OPERATION_OPT_VAL`. Además, se especifica `.mode(SaveMode.Append)` para indicar que el registro se debe anexar.
### Upsert con Scala con Amazon EMR 6.7 y versiones posteriores
**nota**
Amazon EMR 6.7.0 usa [Apache Hudi](https://hudi.apache.org/) 0.11.0-amzn-0, que contiene mejoras significativas con respecto a las versiones anteriores de Hudi. Para obtener más información, consulte la [Guía de migración a Apache Hudi 0.11.0](https://hudi.apache.org/releases/release-0.11.0/#migration-guide). Los ejemplos de esta pestaña reflejan estos cambios.
```
// 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 con Scala con Amazon EMR 6.6 y versiones posteriores
```
// 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/"))
```
### Interrumpir usando 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/')
```
## Eliminación de un registro
Para eliminar un registro de forma permanente, puede alterar una carga útil vacía. En este caso, la opción `PAYLOAD_CLASS_OPT_KEY` especifica la clase `EmptyHoodieRecordPayload`. En el ejemplo se utiliza lo mismo DataFrame que en el ejemplo de upsert para especificar el mismo registro. `updateDF`
### Eliminación con Scala con Amazon EMR 6.7 y versiones posteriores
**nota**
Amazon EMR 6.7.0 usa [Apache Hudi](https://hudi.apache.org/) 0.11.0-amzn-0, que contiene mejoras significativas con respecto a las versiones anteriores de Hudi. Para obtener más información, consulte la [Guía de migración a Apache Hudi 0.11.0](https://hudi.apache.org/releases/release-0.11.0/#migration-guide). Los ejemplos de esta pestaña reflejan estos cambios.
```
(updateDF.write
.format("hudi")
.options(hudiOptions)
.option(DataSourceWriteOptions.OPERATION_OPT_KEY, "delete")
.mode(SaveMode.Append)
.save("s3://amzn-s3-demo-bucket/myhudidataset/"))
```
### Eliminación con Scala con Amazon EMR 6.6 y versiones anteriores
```
(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/"))
```
### Elimine 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/')
```
También puede eliminar datos de forma permanente si configura `OPERATION_OPT_KEY ` como `DELETE_OPERATION_OPT_VAL` para eliminar todos los registros del conjunto de datos que envíe. Para obtener instrucciones sobre cómo llevar a cabo eliminaciones temporales y para obtener más información sobre cómo eliminar los datos almacenados en las tablas de Hudi, consulte [Eliminaciones](https://hudi.apache.org/docs/writing_data.html#deletes) en la documentación de Apache Hudi.
## Leer un conjunto de datos de Hudi
Para recuperar los datos en el momento actual, Hudi lleva a cabo consultas instantáneas de forma predeterminada. El siguiente es un ejemplo de consulta del conjunto de datos escrito en S3 en [Escribir en un conjunto de datos de Hudi](#emr-hudi-dataframe). *s3://amzn-s3-demo-bucket/myhudidataset*Sustitúyala por la ruta de la tabla y añada asteriscos comodín para cada nivel de partición, *además de un* asterisco adicional. En este ejemplo, hay un nivel de partición, por lo que hemos agregado dos símbolos comodín.
### Leer con Scala con Amazon EMR 6.7 y versiones posteriores
**nota**
Amazon EMR 6.7.0 usa [Apache Hudi](https://hudi.apache.org/) 0.11.0-amzn-0, que contiene mejoras significativas con respecto a las versiones anteriores de Hudi. Para obtener más información, consulte la [Guía de migración a Apache Hudi 0.11.0](https://hudi.apache.org/releases/release-0.11.0/#migration-guide). Los ejemplos de esta pestaña reflejan estos cambios.
```
val snapshotQueryDF = spark.read
.format("hudi")
.load("s3://amzn-s3-demo-bucket/myhudidataset")
.show()
```
### Leer con Scala con Amazon EMR 6.6 y versiones anteriores
```
(val snapshotQueryDF = spark.read
.format("org.apache.hudi")
.load("s3://amzn-s3-demo-bucket/myhudidataset" + "/*/*"))
snapshotQueryDF.show()
```
### Lea usando PySpark
```
snapshotQueryDF = spark.read \
.format('org.apache.hudi') \
.load('s3://amzn-s3-demo-bucket/myhudidataset' + '/*/*')
snapshotQueryDF.show()
```
### Consultas incrementales
También puede hacer consultas incrementales con Hudi para obtener un flujo de registros que han cambiado desde una fecha de confirmación determinada. Para ello, defina el campo `QUERY_TYPE_OPT_KEY` en `QUERY_TYPE_INCREMENTAL_OPT_VAL`. A continuación, agregue un valor para `BEGIN_INSTANTTIME_OPT_KEY` para obtener todos los registros escritos desde el momento especificado. Las consultas incrementales suelen ser diez veces más eficientes que las consultas por lotes, ya que solo procesan los registros modificados.
Al hacer consultas incrementales, utilice la ruta de la tabla raíz (base) sin los asteriscos comodín que se utilizan en las consultas instantáneas.
**nota**
Presto no admite consultas incrementales.
#### Consultas incrementales con 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()
```
#### Consultas incrementales mediante 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()
```
Para obtener más información acerca de la lectura de los conjuntos de datos de Hudi, consulte la sección sobre [Cómo consultar tablas de Hudi](https://hudi.apache.org/docs/querying_data.html) en la documentación de Apache Hudi.
# Usar la CLI de Hudi
Puede usar la CLI de Hudi para administrar conjuntos de datos de Hudi y ver información sobre confirmaciones, el sistema de archivos, estadísticas y otros datos. También puede utilizar la CLI para realizar compactaciones manualmente, programarlas o cancelarlas otras programadas. Para obtener más información, consulte [Interacción mediante la CLI](https://hudi.apache.org/docs/cli/) en la documentación de Apache Hudi.
**Para iniciar la CLI de Hudi y conectarse a un conjunto de datos**
1. Conéctese al nodo principal utilizando SSH. Para obtener más información, consulte [Conexión al nodo maestro mediante SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) en la *Guía de administración de Amazon EMR*.
1. En la línea de comandos, escriba `/usr/lib/hudi/cli/bin/hudi-cli.sh`.
El símbolo del sistema cambia a `hudi->`
1. Para conectarse al conjunto de datos, utilice el siguiente comando. *s3://amzn-s3-demo-bucket/myhudidataset*Sustitúyala por la ruta al conjunto de datos con el que quieres trabajar. El valor que usamos es el mismo que el valor establecido en ejemplos anteriores.
```
connect --path s3://amzn-s3-demo-bucket/myhudidataset
```
El símbolo del sistema cambia para incluir el dataset al que está conectado, como se muestra en el siguiente ejemplo.
```
hudi:myhudidataset->
```
De forma predeterminada, el script `hudi-cli.sh` de las versiones de 7.3.0 a 7.8.0 de Amazon EMR utiliza `hudi-cli-bundle.jar`. Si tiene dificultades, puede volver a la CLI Hudi clásica con el siguiente comando:
```
/usr/lib/hudi/cli/bin/hudi-cli.sh --cliBundle false
```
Este comando ejecuta el script `hudi-cli.sh`, establece el indicador `--cliBundle` e indica a la CLI que utilice los archivos JAR individuales en lugar del JAR agrupado. De forma predeterminada, `--cliBundle` se establece en true, lo que significa que la CLI utiliza el JAR agrupado en su lugar.
## Cómo usar la versión 7.9.0 y posteriores de Amazon EMR
**nota**
El script **hudi-cli.sh** quedó obsoleto en la versión 7.9.0 y posteriores de EMR. **La versión 7.9.0 y superior de Amazon EMR usa .jar. hudi-cli-bundle**
**Para iniciar la CLI de Hudi y conectarse a un conjunto de datos:**
1. Conéctese al nodo principal utilizando SSH. Para obtener más información, consulte [Conexión al nodo maestro mediante SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) en la *Guía de administración de Amazon EMR*.
1. **En la línea de comandos, escriba**/usr/lib/hudi/cli-bundle/bin/hudi- cli-with-bundle .sh** o simplemente escriba o >hudi-cli. **hudi-cli-with-bundle****
La petición del sistema cambia a **hudi- >**.
1. Para conectarse al conjunto de datos, utilice el siguiente comando. Reemplace **s3://amzn-s3-demo-bucket/myhudidataset** por la ruta del conjunto de datos con el que desea trabajar. El valor que usamos es el mismo que el valor establecido en ejemplos anteriores.
```
connect --path s3://amzn-s3-demo-bucket/myhudidataset
```
1. El símbolo del sistema cambia para incluir el dataset al que está conectado, como se muestra en el siguiente ejemplo.
```
hudi:myhudidataset->
```
# Historial de versiones de Hudi
En la siguiente tabla, se muestra la versión de Hudi incluida en cada versión de lanzamiento de Amazon EMR, junto con los componentes instalados con la aplicación. Para ver las versiones de los componentes de cada versión, consulte la sección Versiones de los componentes en la versión correspondiente de [Versiones de Amazon EMR 7.x](emr-release-7x.md), [Versiones de lanzamiento de Amazon EMR 6.x](emr-release-6x.md) o [Versiones de lanzamiento de Amazon EMR 5.x](emr-release-5x.md).
**Información de la versión de Hudi**
| Etiqueta de versión de Amazon EMR | Versión de Hudi | Componentes instalados 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. |