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.
# Uso de un clúster con Iceberg
Esta sección incluye información sobre cómo usar Iceberg con Spark, Trino, Flink y Hive.
# Uso de un clúster de Iceberg con Spark
A partir de la versión 6.5.0 de Amazon EMR, puede usar Iceberg con su clúster de Spark sin necesidad de incluir acciones de arranque. Para las versiones 6.4.0 y anteriores de Amazon EMR, puede utilizar una acción de arranque para preinstalar todas las dependencias necesarias.
En este tutorial, utilizará el AWS CLI para trabajar con Iceberg en un clúster de Amazon EMR Spark. Para usar la consola para crear un clúster con Iceberg instalado, siga los pasos que se indican en [Crear un lago de datos de Apache Iceberg con Amazon Athena, Amazon EMR y AWS Glue](https://aws.amazon.com/blogs//big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
## Crear un clúster de Iceberg
Puede crear un clúster con Iceberg instalado mediante la Consola de administración de AWS, la AWS CLI o la API de Amazon EMR. En este tutorial, utilizará el AWS CLI para trabajar con Iceberg en un clúster de Amazon EMR. Para usar la consola para crear un clúster con Iceberg instalado, siga los pasos que se indican en [Crear un lago de datos de Apache Iceberg con Amazon Athena, Amazon EMR y AWS Glue](https://aws.amazon.com/blogs//big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
Para usar Iceberg en Amazon EMR con AWS CLI el, cree primero un clúster con los siguientes pasos. Para obtener información sobre cómo especificar la clasificación de Iceberg mediante la AWS CLI, consulte o. [Proporcione una configuración mediante la opción AWS CLI al crear un clúster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) [Proporcione una configuración mediante el SDK de Java al crear un clúster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk)
1. Cree un archivo `configurations.json`, con el siguiente contenido:
```
[{
"Classification":"iceberg-defaults",
"Properties":{"iceberg.enabled":"true"}
}]
```
1. A continuación, cree un clúster con la siguiente configuración. Sustituya la ruta del bucket de Amazon S3 de ejemplo y el ID de subred por los suyos propios.
```
aws emr create-cluster --release-label emr-6.5.0 \
--applications Name=Spark \
--configurations file://configurations.json \
--region us-east-1 \
--name My_Spark_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket/ \
--instance-type m5.xlarge \
--instance-count 2 \
--service-role EMR_DefaultRole_V2 \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,SubnetId=subnet-1234567890abcdef0
```
Como alternativa, puede crear un clúster de Amazon EMR que incluya la aplicación de Spark e incluir el archivo `/usr/share/aws/iceberg/lib/iceberg-spark3-runtime.jar` como una dependencia JAR en un trabajo de Spark. Para obtener más información, consulte [Envío de aplicaciones](https://spark.apache.org/docs/latest/submitting-applications.html#submitting-applications).
Para incluir el jar como una dependencia en un trabajo de Spark, agregue la siguiente propiedad de configuración a la aplicación de Spark:
```
--conf "spark.jars=/usr/share/aws/iceberg/lib/iceberg-spark3-runtime.jar"
```
Para obtener más información sobre las dependencias de los trabajos de Spark, consulte [Administración de dependencias](https://spark.apache.org/docs/latest/running-on-kubernetes.html#dependency-management) en el documento de Apache Spark [Ejecución de Spark en Kubernetes](https://spark.apache.org/docs/latest/running-on-kubernetes.html).
## Inicio de una sesión de Spark para Iceberg
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 Amazon EMR.
------
#### [ spark-shell ]
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. Introduzca el siguiente comando para iniciar el shell de Spark. Para usar la PySpark carcasa, sustitúyala por`spark-shell`. `pyspark`
```
spark-shell \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket/prefix/
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
------
#### [ spark-submit ]
1. 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. Ingrese el siguiente comando para iniciar la sesión de Spark para Iceberg.
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
------
#### [ EMR Studio notebooks ]
Para iniciar una sesión de Spark con los Cuadernos de Amazon EMR, configure su sesión de Spark con el comando mágico `%%configure` de su cuaderno de Amazon EMR, como en el siguiente ejemplo. Para obtener más información, consulte [Usar la magia de Cuadernos de Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-magics.html#emr-magics) en la *Guía de administración de Amazon EMR*.
```
%%configure -f{
"conf":{
"spark.sql.catalog.my_catalog":"org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.my_catalog.type":"glue",
"spark.sql.catalog.my_catalog.warehouse":"s3://amzn-s3-demo-bucket1/prefix/",
"spark.sql.defaultCatalog":"my_catalog",
"spark.sql.extensions":"org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions"
}
}
```
------
#### [ CLI ]
Ejecute el siguiente ejemplo para inicializar un clúster de Spark mediante la CLI y establecer todas las configuraciones predeterminadas de la sesión de Spark Iceberg. Para obtener más información sobre cómo especificar una clasificación de configuración mediante la API Amazon EMR AWS CLI y Amazon EMR, consulte [Configurar](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps.html) aplicaciones.
```
[
{
"Classification": "spark-defaults",
"Properties": {
"spark.sql.catalog.my_catalog":"org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.my_catalog.type":"glue",
"spark.sql.catalog.my_catalog.warehouse":"s3://amzn-s3-demo-bucket1/prefix/",
"spark.sql.defaultCatalog":"my_catalog",
"spark.sql.extensions":"org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions"
}
}
]
```
------
## Escribir en una tabla de Iceberg
En el siguiente ejemplo, se muestra cómo crear un conjunto de datos Iceberg DataFrame y cómo escribirlo como un conjunto de datos. En los ejemplos, se muestra cómo trabajar con conjuntos de datos mediante el intérprete de comandos de Spark mientras está conectado al nodo maestro usando SSH como usuario predeterminado de Hadoop.
**nota**
Para pegar muestras de código en el intérprete de comandos de Spark, escriba `:paste` en el símbolo del sistema, pegue el ejemplo y, a continuación, pulse `CTRL+D`.
------
#### [ PySpark ]
Spark incluye un intérprete de comandos basado en Python, `pyspark`, que puede utilizar para crear prototipos de programas de Spark escritos en Python. Invocar `pyspark` en el nodo maestro.
```
## Create a DataFrame.
data = spark.createDataFrame([
("100", "2015-01-01", "2015-01-01T13:51:39.340396Z"),
("101", "2015-01-01", "2015-01-01T12:14:58.597216Z"),
("102", "2015-01-01", "2015-01-01T13:51:40.417052Z"),
("103", "2015-01-01", "2015-01-01T13:51:40.519832Z")
],["id", "creation_date", "last_update_time"])
## Write a DataFrame as a Iceberg dataset to the Amazon S3 location.
spark.sql("""CREATE TABLE IF NOT EXISTS dev.db.iceberg_table (id string,
creation_date string,
last_update_time string)
USING iceberg
location 's3://amzn-s3-demo-bucket/example-prefix/db/iceberg_table'""")
data.writeTo("dev.db.iceberg_table").append()
```
------
#### [ Scala ]
```
import org.apache.spark.sql.SaveMode
import org.apache.spark.sql.functions._
// Create a DataFrame.
val data = Seq(
("100", "2015-01-01", "2015-01-01T13:51:39.340396Z"),
("101", "2015-01-01", "2015-01-01T12:14:58.597216Z"),
("102", "2015-01-01", "2015-01-01T13:51:40.417052Z"),
("103", "2015-01-01", "2015-01-01T13:51:40.519832Z")
).toDF("id", "creation_date", "last_update_time")
// Write a DataFrame as a Iceberg dataset to the Amazon S3 location.
spark.sql("""CREATE TABLE IF NOT EXISTS dev.db.iceberg_table (id string,
creation_date string,
last_update_time string)
USING iceberg
location 's3://amzn-s3-demo-bucket/example-prefix/db/iceberg_table'""")
data.writeTo("dev.db.iceberg_table").append()
```
------
## Leer desde una tabla de Iceberg
------
#### [ PySpark ]
```
df = spark.read.format("iceberg").load("dev.db.iceberg_table")
df.show()
```
------
#### [ Scala ]
```
val df = spark.read.format("iceberg").load("dev.db.iceberg_table")
df.show()
```
------
#### [ Spark SQL ]
```
SELECT * from dev.db.iceberg_table LIMIT 10
```
------
## Uso del catálogo de datos de AWS Glue con Spark Iceberg
Puedes conectarte al catálogo de datos de AWS Glue desde Spark Iceberg. En esta sección se muestran diferentes comandos para la conexión.
### Conéctate al catálogo AWS Glue predeterminado de tu región predeterminada
En este ejemplo se muestra cómo realizar la conexión mediante el tipo de catálogo de Glue. Si no especifica un ID de catálogo, se utiliza el valor predeterminado:
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
### Conectarse a un catálogo de AWS Glue con un identificador de catálogo específico
En este ejemplo se muestra cómo conectarse mediante un ID de catálogo:
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.catalog.my_catalog.glue.id=AWS Glue catalog ID \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
Este comando se puede utilizar para conectarse a un catálogo de AWS Glue de una cuenta diferente, a un catálogo de RMS o a un catálogo federado.
## Uso del catálogo de REST de Iceberg (IRC) con Spark Iceberg
En las secciones siguientes se detalla cómo configurar la integración de Iceberg con un catálogo.
### Conéctese al AWS terminal IRC de Glue Data Catalog
A continuación se muestra un comando `spark-submit` de ejemplo para utilizar Iceberg REST:
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=glue catalog ID \
--conf spark.sql.catalog.my_catalog.type=rest \
--conf spark.sql.catalog.my_catalog.uri=glue endpoint URI/iceberg \
--conf spark.sql.catalog.my_catalog.rest.sigv4-enabled=true \
--conf spark.sql.catalog.my_catalog.rest.signing-name=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
Para usarlo en un clúster con funciones de tiempo de ejecución habilitadas, se necesitan los siguientes ajustes de configuración adicionales de Spark:
```
"spark.hadoop.fs.s3.credentialsResolverClass": "software.amazon.glue.GlueTableCredentialsResolver",
"spark.hadoop.catalog-impl": "org.apache.iceberg.aws.glue.GlueCatalog",
"spark.hadoop.glue.id": glue catalog ID
"spark.hadoop.glue.endpoint": "glue endpoint"
```
Para ver la lista de URL de terminales de AWS Glue para cada región, consulta [Cuotas y puntos de conexión de AWS Glue](https://docs.aws.amazon.com/general/latest/gr/glue.html).
### Conéctese a un punto de conexión IRC arbitrario
A continuación se muestra un comando `spark-submit` de ejemplo para usar un punto de conexión de IRC:
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=warehouse name \
--conf spark.sql.catalog.my_catalog.type=rest \
--conf spark.sql.catalog.my_catalog.uri=your rest endpoint \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
## Diferencias de configuración cuando usas Iceberg SparkCatalog y SparkSessionCatalog
Iceberg ofrece dos formas de crear catálogos de Spark Iceberg. Puede ajustar la configuración de Spark en `SparkCatalog` o en `SparkSessionCatalog`.
### Uso de Iceberg SparkCatalog
A continuación se muestra el comando que se puede utilizar **SparkCatalog**como catálogo de Spark Iceberg:
```
spark-shell \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog
```
Consideraciones para este enfoque:
+ Puede acceder a las tablas de Iceberg, pero no a otras.
+ El nombre del catálogo no puede ser **spark\$1catalog**. Este es el nombre del catálogo inicial de Spark. Siempre se conecta a un metalmacén de Hive. Es el catálogo predeterminado en Spark, a menos que el usuario lo sobrescriba mediante `spark.sql.defaultCatalog`.
+ Puede establecer el `spark.sql.defaultCatalog` al nombre de su catálogo para convertirlo en el predeterminado.
### Uso de Iceberg SparkSessionCatalog
A continuación se muestra el comando que se puede utilizar **SparkSessionCatalog**como catálogo de Spark Iceberg:
```
spark-shell \
--conf spark.sql.catalog.spark_catalog=org.apache.iceberg.spark.SparkSessionCatalog \
--conf spark.sql.catalog.spark_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.spark_catalog.type=glue
```
Consideraciones para este enfoque:
+ Si una tabla no se encuentra como una tabla de Iceberg, Spark intentará comprobar si se trata de una tabla en el metalmacén de Hive. Consulte [Uso del catálogo de datos de AWS Glue como catálogo de Hive](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-hive-metastore-glue.html) para obtener más información.
+ El nombre del catálogo debe ser **spark\$1catalog**.
## Uso de extensiones de Iceberg Spark
Iceberg ofrece la extensión Spark `org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions` que los usuarios pueden ajustar a través de la configuración de extensiones de Spark `spark.sql.extensions`. Las extensiones permiten funciones clave de Iceberg, como ELIMINAR, ACTUALIZAR y FUSIONAR a nivel de fila, instrucciones y procedimientos del lenguaje de definición de datos de Spark específicos de Iceberg, como la compactación, la caducidad de las instantáneas, la ramificación y el etiquetado, etc. Para obtener más detalles, consulte lo siguiente.
+ Extensiones de escritura de Iceberg Spark: [Spark Writes](https://iceberg.apache.org/docs/nightly/spark-writes/)
+ Extensiones DDL de Iceberg Spark: [extensiones SQL de ALTER TABLE](https://iceberg.apache.org/docs/nightly/spark-ddl/#alter-table-sql-extensions/)
+ Extensiones de procedimientos de Iceberg Spark: [Spark Procedures](https://iceberg.apache.org/docs/nightly/spark-ddl/#alter-table-sql-extensions/)
## Consideraciones para el uso de Iceberg con Spark
+ De forma predeterminada, Amazon EMR 6.5.0 no admite la ejecución de Iceberg en Amazon EMR en EKS. Hay disponible una imagen personalizada de Amazon EMR 6.5.0 para que pueda pasar `--jars local:///usr/share/aws/iceberg/lib/iceberg-spark3-runtime.jar` como parámetro `spark-submit` para crear tablas de Iceberg en Amazon EMR en EKS. Para obtener más información, consulte [Enviar una carga de trabajo de Spark en Amazon EMR con una imagen personalizada](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-steps.html#docker-custom-images-submit) en la *Guía de desarrollo de Amazon EMR en EKS*. También puede contactar con Soporte si necesita ayuda. A partir de Amazon EMR 6.6.0, Iceberg es compatible con Amazon EMR en EKS.
+ Cuando utilice AWS Glue como catálogo de Iceberg, asegúrese de que la base de datos en la que va a crear la tabla esté en AWS Glue. Si utilizas servicios como estos AWS Lake Formation y no puedes cargar el catálogo, asegúrate de tener el acceso adecuado al servicio para ejecutar el comando.
+ Si usa Iceberg SparkSessionCatalog, como se describe en[Diferencias de configuración cuando usas Iceberg SparkCatalog y SparkSessionCatalog](#emr-iceberg-spark-catalog), debe seguir los pasos de configuración descritos en [Configurar el catálogo de datos de AWS Glue como el metaalmacén de Apache Hive](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-hive-metastore-glue.html), además de configurar los ajustes del catálogo de datos de Spark Iceberg AWS Glue.
# Usar un clúster de Iceberg con Trino
A partir de la versión 6.6.0 de Amazon EMR, puede usar Iceberg con su clúster de Trino.
En este tutorial, utilizará el AWS CLI para trabajar con Iceberg en un clúster Trino de Amazon EMR. Para usar la consola para crear un clúster con Iceberg instalado, siga los pasos que se indican en [Crear un lago de datos de Apache Iceberg con Amazon Athena, Amazon EMR y AWS Glue](https://aws.amazon.com/blogs//big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
## Crear un clúster de Iceberg
Para usar Iceberg en Amazon EMR con AWS CLI el, cree primero un clúster con los siguientes pasos. Para obtener información sobre cómo especificar la clasificación de Iceberg mediante la AWS CLI, consulte o. [Proporcione una configuración mediante la opción AWS CLI al crear un clúster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) [Proporcione una configuración mediante el SDK de Java al crear un clúster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk)
1. Cree un archivo `configurations.json` con el siguiente contenido. Por ejemplo, si quiere usar el metaalmacén de Hive como catálogo, su archivo debe tener el siguiente contenido.
```
[
{
"Classification": "trino-connector-iceberg",
"Properties": {
"connector.name": "iceberg",
"hive.metastore.uri": "thrift://localhost:9083"
}
}
]
```
Si quieres usar el catálogo de datos de AWS Glue como almacén, el archivo debe tener el siguiente contenido.
```
[
{
"Classification": "trino-connector-iceberg",
"Properties": {
"connector.name": "iceberg",
"iceberg.catalog.type": "glue"
}
}
]
```
A partir de Amazon EMR 7.7.0, incluya la propiedad *fs.native-s3.enabled=true*
```
[
{
"Classification": "trino-connector-iceberg",
"Properties": {
"connector.name": "iceberg",
"iceberg.catalog.type": "glue",
"fs.native-s3.enabled": "true"
}
}
]
```
1. Cree un clúster con la siguiente configuración, y sustituya el ejemplo de la ruta de su bucket de Amazon S3 y el nombre clave por el suyo.
```
aws emr create-cluster --release-label emr-6.7.0 \
--applications Name=Trino \
--region us-east-1 \
--name My_Trino_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket \
--configurations file://configurations.json \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=c3.4xlarge InstanceGroupType=CORE,InstanceCount=3,InstanceType=c3.4xlarge \
--use-default-roles \
--ec2-attributes KeyName=
```
## Inicializar una sesión de Trino para Iceberg
Para iniciar una sesión de Trino, ejecute el siguiente comando.
```
trino-cli --catalog iceberg
```
## Escribir en una tabla de Iceberg
Cree la siguiente tabla y escriba en ella con los siguientes comandos de SQL.
```
trino> SHOW SCHEMAS;
trino> CREATE TABLE default.iceberg_table (
id int,
data varchar,
category varchar)
WITH (
format = 'PARQUET',
partitioning = ARRAY['category', 'bucket(id, 16)'],
location = 's3://amzn-s3-demo-bucket/')
trino> INSERT INTO default.iceberg_table VALUES (1,'a','c1'), (2,'b','c2'), (3,'c','c3');
```
## Leer desde una tabla para Iceberg
Para leer desde su tabla de Iceberg, ejecute el siguiente comando.
```
trino> SELECT * from default.iceberg_table;
```
## Consideraciones para el uso de Iceberg con Trino
+ Amazon EMR 6.5 no ofrece compatibilidad nativa con Trino Iceberg Catalog para Iceberg. Trino necesita Iceberg v0.11, por lo que recomendamos lanzar un clúster de Amazon EMR para Trino independiente del clúster de Spark e incluir Iceberg v0.11 en ese clúster.
+ Cuando utilice AWS Glue como catálogo para Iceberg, asegúrese de que la base de datos en la que va a crear la tabla existe en AWS Glue. Si utilizas servicios como estos AWS Lake Formation y no puedes cargar el catálogo, asegúrate de tener el acceso adecuado al servicio para ejecutar el comando.
+ La integración de Iceberg y Glue no funciona con el catálogo de almacenamiento gestionado de Redshift.
# Usar un clúster de Iceberg con Flink
A partir de la versión 6.9.0 de Amazon EMR, puede utilizar Iceberg con un clúster de Flink sin los pasos de configuración necesarios al utilizar la integración de código abierto de Flink de Iceberg.
## Creación de un clúster de Iceberg
Puede crear un clúster con Iceberg instalado mediante la Consola de administración de AWS, la AWS CLI o la API de Amazon EMR. En este tutorial, utilizará el AWS CLI para trabajar con Iceberg en un clúster de Amazon EMR. Para usar la consola para crear un clúster con Iceberg instalado, siga los pasos que se indican en [Crear un lago de datos de Apache Iceberg con Amazon Athena, Amazon EMR y AWS Glue](https://aws.amazon.com/blogs/big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
Para usar Iceberg en Amazon EMR con AWS CLI el, cree primero un clúster con los siguientes pasos. Para obtener información sobre cómo especificar la clasificación de Iceberg mediante la AWS CLI, consulte o. [Proporcione una configuración mediante la opción AWS CLI al crear un clúster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) [Proporcione una configuración mediante el SDK de Java al crear un clúster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk) Cree un archivo denominado `configurations.json` con el siguiente contenido:
```
[{
"Classification":"iceberg-defaults",
"Properties":{"iceberg.enabled":"true"}
}]
```
A continuación, cree un clúster con la siguiente configuración y sustituya la ruta del bucket y el ID de subred de Amazon S3 de ejemplo por sus propios valores:
```
aws emr create-cluster --release-label emr-6.9.0 \
--applications Name=Flink \
--configurations file://iceberg_configurations.json \
--region us-east-1 \
--name My_flink_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket/ \
--instance-type m5.xlarge \
--instance-count 2 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,SubnetId=subnet-1234567890abcdef
```
Como alternativa, puede crear un clúster de Amazon EMR 6.9.0 con una aplicación de Flink y utilizar el archivo `/usr/share/aws/iceberg/lib/iceberg-flink-runtime.jar` como una dependencia JAR en un trabajo de Flink.
## Uso del cliente SQL de Flink
El script del cliente SQL se encuentra en `/usr/lib/flink/bin`. Puede ejecutar el script con el siguiente comando:
```
flink-yarn-session -d # starting the Flink YARN Session in detached mode
./sql-client.sh
```
Esto lanza un intérprete de comandos SQL de Flink.
## Ejemplos de Flink
### Crear una tabla de Iceberg
**SQL de Flink**
```
CREATE CATALOG glue_catalog WITH (
'type'='iceberg',
'warehouse'='',
'catalog-impl'='org.apache.iceberg.aws.glue.GlueCatalog',
'io-impl'='org.apache.iceberg.aws.s3.S3FileIO'
);
USE CATALOG glue_catalog;
CREATE DATABASE IF NOT EXISTS ;
USE ;
CREATE TABLE IF NOT EXISTS `glue_catalog`.``.`sample` (id int, data string);
```
**API de tabla**
```
EnvironmentSettings settings =
EnvironmentSettings.newInstance().inBatchMode().build();
TableEnvironment tEnv = TableEnvironment.create(settings);
String warehouse = "";
String db = "";
tEnv.executeSql(
"CREATE CATALOG glue_catalog WITH (\n"
+ " 'type'='iceberg',\n"
+ " 'warehouse'='"
+ warehouse
+ "',\n"
+ " 'catalog-impl'='org.apache.iceberg.aws.glue.GlueCatalog',\n"
+ " 'io-impl'='org.apache.iceberg.aws.s3.S3FileIO'\n"
+ " );");
tEnv.executeSql("USE CATALOG glue_catalog;");
tEnv.executeSql("CREATE DATABASE IF NOT EXISTS " + db + ";");
tEnv.executeSql("USE " + db + ";");
tEnv.executeSql(
"CREATE TABLE `glue_catalog`.`" + db + "`.`sample` (id bigint, data string);");
```
### Escribir en una tabla de Iceberg
**SQL de Flink**
```
INSERT INTO `glue_catalog`.``.`sample` values (1, 'a'),(2,'b'),(3,'c');
```
**API de tabla**
```
tEnv.executeSql(
"INSERT INTO `glue_catalog`.`"
+ db
+ "`.`sample` values (1, 'a'),(2,'b'),(3,'c');");
```
**API de Datastream**
```
final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
final StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);
String db = "";
String warehouse = "";
GenericRowData rowData1 = new GenericRowData(2);
rowData1.setField(0, 1L);
rowData1.setField(1, StringData.fromString("a"));
DataStream input = env.fromElements(rowData1);
Map props = new HashMap<();
props.put("type", "iceberg");
props.put("warehouse", warehouse);
props.put("io-impl", "org.apache.iceberg.aws.s3.S3FileIO");
CatalogLoader glueCatlogLoader =
CatalogLoader.custom(
"glue",
props,
new Configuration(),
"org.apache.iceberg.aws.glue.GlueCatalog");
TableLoader tableLoader =
TableLoader.fromCatalog(glueCatlogLoader, TableIdentifier.of(db, "sample"));
DataStreamSink dataStreamSink =
FlinkSink.forRowData(input).tableLoader(tableLoader).append();
env.execute("Datastream Write");
```
### Leer desde una tabla de Iceberg
**SQL de Flink**
```
SELECT * FROM `glue_catalog`.``.`sample`;
```
**API de tabla**
```
Table result = tEnv.sqlQuery("select * from `glue_catalog`.`" + db + "`.`sample`;");
```
**API de Datastream**
```
final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
final StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);
String db = "";
String warehouse = "";
Map props = new HashMap<>();
props.put("type", "iceberg");
props.put("warehouse", warehouse);
props.put("io-impl", "org.apache.iceberg.aws.s3.S3FileIO");
CatalogLoader glueCatlogLoader =
CatalogLoader.custom(
"glue",
props,
new Configuration(),
"org.apache.iceberg.aws.glue.GlueCatalog");
TableLoader tableLoader =
TableLoader.fromCatalog(glueCatlogLoader, TableIdentifier.of(db, "sample"));
DataStream batch =
FlinkSource.forRowData().env(env).tableLoader(tableLoader).streaming(false).build();
batch.print().name("print-sink");
```
## Uso del catálogo de Hive
Asegúrese de que las dependencias entre Flink y Hive se resuelvan como se describe en [Configuración de Flink con el metaalmacén de Hive y el Catálogo de Glue](flink-configure.md#flink-configure-hive).
## Ejecución de un trabajo de Flink
Una forma de enviar un trabajo a Flink es utilizar una sesión de Flink YARN por trabajo. Puede iniciarlo con el siguiente comando:
```
sudo flink run -m yarn-cluster -p 4 -yjm 1024m -ytm 4096m $JAR_FILE_NAME
```
## Consideraciones para el uso de Iceberg con Flink
+ Cuando utilice AWS Glue como catálogo de Iceberg, asegúrese de que la base de datos en la que va a crear la tabla esté en AWS Glue. Si utilizas servicios como estos AWS Lake Formation y no puedes cargar el catálogo, asegúrate de tener el acceso adecuado al servicio para ejecutar el comando.
+ La integración de Iceberg y Glue no funciona con el catálogo de almacenamiento gestionado de Redshift.
# Usar un clúster de Iceberg con Hive
A partir de la versión 6.9.0 de Amazon EMR, puede utilizar Iceberg con un clúster de Hive sin realizar los pasos de configuración necesarios al utilizar la integración de código abierto de Iceberg Hive. Para las versiones 6.8.0 y anteriores de Amazon EMR, puede utilizar una acción de arranque para instalar el jar `iceberg-hive-runtime` y configurar la compatibilidad de Hive con Iceberg.
Amazon EMR 6.9.0 incluye todas las características de la [integración de Hive 3.1.3 con Iceberg 0.14.1](https://iceberg.apache.org/releases/#0140-release) y también incluye características adicionales de Amazon EMR, como la selección automática de los motores de ejecución compatibles en tiempo de ejecución (Amazon EMR en EKS 6.9.0).
## Crear un clúster de Iceberg
Puede crear un clúster con Iceberg instalado mediante la Consola de administración de AWS, la AWS CLI o la API de Amazon EMR. En este tutorial, utilizará el AWS CLI para trabajar con Iceberg en un clúster de Amazon EMR. Para usar la consola para crear un clúster con Iceberg instalado, siga los pasos que se indican en [Crear un lago de datos de Iceberg con Amazon Athena, Amazon EMR y AWS Glue](https://aws.amazon.com/blogs/big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
Para usar Iceberg en Amazon EMR con AWS CLI el, cree primero un clúster siguiendo los pasos que se indican a continuación. Para obtener información sobre cómo especificar la clasificación de Iceberg mediante el SDK de Java AWS CLI o el SDK de Java, consulte o. [Proporcione una configuración mediante la opción AWS CLI al crear un clúster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) [Proporcione una configuración mediante el SDK de Java al crear un clúster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk) Cree un archivo denominado `configurations.json` con el siguiente contenido:
```
[{
"Classification":"iceberg-defaults",
"Properties":{"iceberg.enabled":"true"}
}]
```
A continuación, cree un clúster con la siguiente configuración y sustituya la ruta del bucket y el ID de subred de Amazon S3 de ejemplo por sus propios valores:
```
aws emr create-cluster --release-label emr-6.9.0 \
--applications Name=Hive \
--configurations file://iceberg_configurations.json \
--region us-east-1 \
--name My_hive_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket/ \
--instance-type m5.xlarge \
--instance-count 2 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,SubnetId=subnet-1234567890abcdef
```
Un clúster de Hive Iceberg hace lo siguiente:
+ Carga en Hive el archivo jar de tiempo de ejecución de Iceberg Hive y habilita la configuración relacionada con Iceberg para el motor Hive.
+ Permite la selección del motor de ejecución dinámico de Amazon EMR Hive para evitar que los usuarios configuren el motor de ejecución admitido para que sea compatible con Iceberg.
**nota**
Los clústeres de Hive Iceberg no son compatibles actualmente con AWS Glue Data Catalog. El catálogo de Iceberg predeterminado es `HiveCatalog`, que corresponde al metaalmacén configurado para el entorno de Hive. Para obtener más información sobre la administración de catálogos, consulte [Uso HCatalog](https://cwiki.apache.org/confluence/display/Hive/HCatalog+UsingHCat#HCatalogUsingHCat-UsingHCatalog) en la documentación de [Apache Hive](https://cwiki.apache.org/confluence/display/HIVE).
## Compatibilidad de características
Amazon EMR 6.9.0 es compatible con Hive 3.1.3 y con Iceberg 0.14.1. El soporte de características se limita a las características compatibles con Iceberg para Hive 3.1.2 y 3.1.3. Se admiten los siguientes comandos:
+ Con las versiones 6.9.0 a 6.12.x de Amazon EMR, debe incluir el archivo `libfb303` jar en el directorio `auxlib` de Hive. Ejecute el siguiente comando para incluirlo:
```
sudo /usr/bin/ln -sf /usr/lib/hive/lib/libfb303-*.jar /usr/lib/hive/auxlib/libfb303.jar
```
Con las versiones 6.13 y posteriores de Amazon EMR, el archivo `libfb303` jar se vincula de forma simbólica automáticamente al directorio `auxlib` de Hive.
+ **Creación de una tabla**
+ **Tabla no particionada**: se pueden crear tablas externas en Hive proporcionando el siguiente controlador de almacenamiento:
```
CREATE EXTERNAL TABLE x (i int) STORED BY 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler'
```
+ **Tabla particionada**: las tablas particionadas externas en Hive se pueden crear de la siguiente manera:
```
CREATE EXTERNAL TABLE x (i int) PARTITIONED BY (j int) STORED BY 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler'
```
**nota**
El formato de `STORED AS` archivo de no ORC/AVRO/PARQUET es compatible con Hive 3. La única opción por defecto es Parquet.
+ **Eliminación de una tabla**: el comando `DROP TABLE` se usa para eliminar tablas, como en el siguiente ejemplo:
```
DROP TABLE [IF EXISTS] table_name [PURGE];
```
+ **Lectura de una tabla**: las instrucciones `SELECT` se pueden usar para leer tablas de Iceberg en Hive, como en el siguiente ejemplo. Los motores de ejecución compatibles son MR y Tez.
```
SELECT * FROM table_name
```
[Para obtener información sobre la sintaxis de selección de Hive, consulte LanguageManual Select.](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Select) Para obtener información sobre determinadas instrucciones con tablas de Iceberg en Hive, consulte [Selección de Apache Iceberg](https://iceberg.apache.org/docs/latest/hive/#select).
+ **Inserción en una tabla**: la instrucción `INSERT INTO` de HiveQL solo funciona en tablas de Iceberg y solo es compatible con el motor de ejecución Map Reduce. Los usuarios de Amazon EMR no necesitan configurar de forma explícita el motor de ejecución porque Amazon EMR Hive selecciona el motor para tablas de Iceberg en tiempo de ejecución.
+ **Inserción de una sola tabla**: ejemplo:
```
INSERT INTO table_name VALUES ('a', 1);
INSERT INTO table_name SELECT...;
```
+ **Inserción de varias tablas**: se admite la inserción de varias tablas no atómicas en instrucciones. Ejemplo:
```
FROM source
INSERT INTO table_1 SELECT a, b
INSERT INTO table_2 SELECT c,d;
```
A partir de Amazon EMR 7.3.0, Hive with Iceberg admite el catálogo de datos de AWS Glue como metaalmacén. Para usar el catálogo de datos de AWS Glue como metaalmacén, defina la siguiente propiedad.
```
SET iceberg.catalog..catalog-impl=org.apache.iceberg.aws.glue.GlueCatalog;
```
Si lo desea, también puede especificar la siguiente propiedad.
```
SET iceberg.catalog..type=glue;
```
Puede crear una tabla utilizando el siguiente ejemplo.
```
CREATE EXTERNAL TABLE table_name (col1 type1, col2 type2,..)
ROW FORMAT SERDE 'org.apache.iceberg.mr.hive.HiveIcebergSerDe'
STORED BY 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler'
location ''
TBLPROPERTIES ('table_type'='iceberg', 'iceberg.catalog'='');
```
## Consideraciones para el uso de Iceberg con Hive
+ Iceberg admite los siguientes tipos de consultas:
+ Crear tabla
+ Eliminar tablas
+ Insertar en tabla
+ Leer tabla
+ Solo el motor de ejecución MR (MapReduce) es compatible con las operaciones de DML (lenguaje de manipulación de datos), y el MR está obsoleto en Hive 3.1.3.
+ En el caso de Amazon EMR anterior a la versión 7.3.0, actualmente el catálogo de datos de AWS Glue no es compatible con Iceberg with Hive.
+ La gestión de errores no es lo suficientemente sólida. En caso de configuración incorrecta, es posible que las inserciones en las consultas se completen correctamente. Sin embargo, la no actualización de los metadatos puede provocar la pérdida de datos.
+ La integración de Iceberg y Glue no funciona con el catálogo de almacenamiento gestionado de Redshift.