# Uso de marcos de lagos de datos con trabajos de ETL de AWS Glue
Los marcos de lagos de datos de código abierto simplifican el procesamiento incremental de los datos para los archivos que se almacenan en los lagos de datos creados en Amazon S3. AWS Glue 3.0 y versiones posteriores admiten los siguientes marcos de lagos de datos de código abierto:
+ Apache Hudi
+ Linux Foundation Delta Lake
+ Apache Iceberg
Proporcionamos compatibilidad nativa para estos marcos para que pueda leer y escribir los datos que almacena en Amazon S3 de manera coherente desde el punto de vista transaccional. No es necesario instalar ningún conector independiente ni completar pasos de configuración adicionales para utilizar estos marcos en los trabajos de ETL de AWS Glue.
Cuando administre conjuntos de datos mediante AWS Glue Data Catalog, puede utilizar los métodos AWS Glue para leer y escribir tablas de lagos de datos con DataFrames de Spark. También puede leer y escribir datos de Amazon S3 mediante la API de DataFrame de Spark.
En este video, puede obtener información básica sobre el trabajo de Apache Hudi, Apache Iceberg y Delta Lake. Verá cómo insertar, actualizar y eliminar datos en su lago de datos y cómo funciona cada uno de estos marcos.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/fryfx0Zg7KA)
**Topics**
+ [Limitaciones](aws-glue-programming-etl-datalake-native-frameworks-limitations.md)
+ [Uso del marco de Hudi en AWS Glue](aws-glue-programming-etl-format-hudi.md)
+ [Uso del marco de Delta Lake en AWS Glue](aws-glue-programming-etl-format-delta-lake.md)
+ [Uso del marco de Iceberg en AWS Glue](aws-glue-programming-etl-format-iceberg.md)
# Limitaciones
Tenga en cuenta las siguientes limitaciones antes de utilizar los marcos de lagos de datos con AWS Glue.
+ Los siguientes métodos de AWS Glue `GlueContext` para DynamicFrame no admiten la lectura ni la escritura de tablas de marcos del lagos de datos. En su lugar, utilice los métodos `GlueContext` para la API de DataFrame o Spark DataFrame.
+ `create_dynamic_frame.from_catalog`
+ `write_dynamic_frame.from_catalog`
+ `getDynamicFrame`
+ `writeDynamicFrame`
+ El control de permisos de Lake Formation admite los siguientes métodos de `GlueContext` para DataFrame:
+ `create_data_frame.from_catalog`
+ `write_data_frame.from_catalog`
+ `getDataFrame`
+ `writeDataFrame`
+ No se admite la [agrupación de archivos pequeños](grouping-input-files.md).
+ No se admiten los [marcadores de trabajo](monitor-continuations.md).
+ Apache Hudi 0.10.1 para AWS Glue 3.0 no admite las tablas Merge on Read (MoR, fusionar al leer) de Hudi.
+ `ALTER TABLE … RENAME TO` no está disponible para Apache Iceberg 0.13.1 para AWS Glue 3.0.
## Limitaciones de las tablas con formato de lago de datos administradas por los permisos de Lake Formation
Los formatos de lago de datos se integran con AWS Glue ETL a través de los permisos de Lake Formation. No se admite la creación de un DynamicFrame utilizando `create_dynamic_frame`. Para obtener más información, consulte los ejemplos siguientes:
+ [Ejemplo: Lea y escriba una tabla de iceberg con el control de permisos de Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-iceberg.html#aws-glue-programming-etl-format-iceberg-read-write-lake-formation-tables)
+ [Ejemplo: Lea y escriba una tabla Hudi con el control de permisos de Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-hudi.html#aws-glue-programming-etl-format-hudi-read-write-lake-formation-tables)
+ [Ejemplo: Lea y escriba la tabla de Delta Lake con el control de permisos de Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-delta-lake.html#aws-glue-programming-etl-format-delta-lake-read-write-lake-formation-tables)
**nota**
La integración con AWS Glue ETL mediante los permisos de Lake Formation para Apache Hudi, Apache Iceberg y Delta Lake solo se admite en la AWS Glue versión 4.0.
Apache Iceberg tiene la mejor integración con AWS Glue ETL a través de los permisos de Lake Formation. Es compatible con casi todas las operaciones e incluye soporte para SQL.
Hudi es compatible con la mayoría de las operaciones básicas, con la excepción de las operaciones administrativas. Esto se debe a que estas opciones generalmente se realizan mediante la escritura de marcos de datos y se especifican mediante `additional_options`. Debe usar las API AWS Glue para crear DataFrames para sus operaciones, ya que SparkSQL no es compatible.
Delta Lake solo admite la lectura, la adición y la sobrescritura de datos de tablas. Delta Lake requiere el uso de sus propias bibliotecas para poder realizar diversas tareas, como las actualizaciones.
Las siguientes funciones no están disponibles para las tablas Iceberg administradas por los permisos de Lake Formation.
+ Compactación mediante ETL AWS Glue
+ Soporte para Spark SQL a través de AWS Glue ETL
Las siguientes son limitaciones de las tablas Hudi administradas por los permisos de Lake Formation:
+ Eliminación de archivos huérfanos
Las siguientes son limitaciones de las tablas de Delta Lake administradas por los permisos de Lake Formation:
+ Todas las funciones, excepto la inserción y lectura de las tablas de Delta Lake.
# Uso del marco de Hudi en AWS Glue
AWS Glue 3.0 y versiones posteriores son compatibles con el marco de Apache Hudi para lagos de datos. Hudi es un marco de almacenamiento de lagos de datos de código abierto que simplifica el procesamiento progresivo de datos y el desarrollo de canalizaciones de datos. En este tema, se describen las características disponibles para usar los datos en AWS Glue al transportar o almacenar datos en una tabla de Hudi. Para más información sobre Hudi, consulte la [documentación oficial de Apache Hudi](https://hudi.apache.org/docs/overview/).
Puede usar AWS Glue para llevar a cabo operaciones de lectura y escritura en tablas de Hudi en Amazon S3, o trabajar con tablas de Hudi mediante el Catálogo de datos de AWS Glue. También se admiten operaciones adicionales, como insertar, actualizar y todas las [operaciones de Apache Spark](https://hudi.apache.org/docs/quick-start-guide/).
**nota**
La implementación de Apache Hudi 0.15.0 en AWS Glue 5.0 revierte internamente [HUDI-7001](https://github.com/apache/hudi/pull/9936). No muestra la regresión relacionada con la generación de claves complejas cuando la clave de registro consta de un solo campo. Sin embargo, este comportamiento es diferente al de OSS Apache Hudi 0.15.0.
Apache Hudi 0.10.1 para AWS Glue 3.0 no admite las tablas Merge on Read (MoR, fusionar al leer) de Hudi.
La siguiente tabla muestra la versión de Hudi que se incluye en cada versión de AWS Glue.
****
| Versión de AWS Glue | Versión de Hudi compatible |
| --- | --- |
| 5.1 | 1.0.2 |
| 5.0 | 0.15.0 |
| 4.0 | 0.12.1 |
| 3.0 | 0.10.1 |
Para más información sobre los marcos de lagos de datos compatibles con AWS Glue, consulte [Uso de marcos de lagos de datos con trabajos de ETL de AWS Glue](aws-glue-programming-etl-datalake-native-frameworks.md).
## Activación de Hudi
Para activar Hudi para AWS Glue, haga las siguientes tareas:
+ Especifique `hudi` como valor para el parámetro del trabajo `--datalake-formats`. Para obtener más información, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md).
+ Cree una clave con el nombre `--conf` para el trabajo de AWS Glue y establézcala en el siguiente valor. Como alternativa, puede establecer la siguiente configuración mediante `SparkConf` en su script. Esta configuración ayuda a Apache Spark a gestionar correctamente las tablas de Hudi.
```
spark.serializer=org.apache.spark.serializer.KryoSerializer
```
+ La compatibilidad con los permisos de Lake Formation para Hudi está habilitada de forma predeterminada en AWS Glue 4.0. No se necesita ninguna configuración adicional para leer o escribir en las tablas Hudi registradas en Lake Formation. Para leer una tabla Hudi registrada, el rol de IAM del trabajo de AWS Glue debe tener el permiso SELECT. Para escribir en una tabla Hudi registrada, el rol de IAM del trabajo de AWS Glue debe tener el permiso SUPER. Para obtener más información sobre la administración de los permisos de Lake Formation, consulte [Otorgar y revocar permisos en los recursos del catálogo de datos](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html).
**Uso de una versión diferente de Hudi**
Para usar una versión de Hudi que no sea compatible con AWS Glue, indique sus propios archivos JAR de Hudi mediante el parámetro de trabajo `--extra-jars`. No incluya `hudi` como valor para el parámetro de trabajo `--datalake-formats`. Si usa AWS Glue 5.0 o versiones posteriores, debe configurar el parámetro de trabajo `--user-jars-first true`.
## Ejemplo: escribir una tabla de Hudi en Amazon S3 y registrarla en el Catálogo de datos de AWS Glue
En este script de ejemplo, se muestra cómo escribir una tabla de Hudi en Amazon S3 y registrar la tabla en el Catálogo de datos de AWS Glue. En el ejemplo, se utiliza la [herramienta Hive Sync](https://hudi.apache.org/docs/syncing_metastore/) de Hudi para registrar la tabla.
**nota**
En este ejemplo, se requiere que establezca el parámetro de trabajo de `--enable-glue-datacatalog` para utilizar el Catálogo de datos de AWS Glue como metaalmacén de Apache Spark Hive. Para obtener más información, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
```
# Example: Create a Hudi table from a DataFrame
# and register the table to Glue Data Catalog
additional_options={
"hoodie.table.name": "",
"hoodie.database.name": "",
"hoodie.datasource.write.storage.type": "COPY_ON_WRITE",
"hoodie.datasource.write.operation": "upsert",
"hoodie.datasource.write.recordkey.field": "",
"hoodie.datasource.write.precombine.field": "",
"hoodie.datasource.write.partitionpath.field": "",
"hoodie.datasource.write.hive_style_partitioning": "true",
"hoodie.datasource.hive_sync.enable": "true",
"hoodie.datasource.hive_sync.database": "",
"hoodie.datasource.hive_sync.table": "",
"hoodie.datasource.hive_sync.partition_fields": "",
"hoodie.datasource.hive_sync.partition_extractor_class": "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc": "false",
"hoodie.datasource.hive_sync.mode": "hms",
"path": "s3://"
}
dataFrame.write.format("hudi") \
.options(**additional_options) \
.mode("overwrite") \
.save()
```
------
#### [ Scala ]
```
// Example: Example: Create a Hudi table from a DataFrame
// and register the table to Glue Data Catalog
val additionalOptions = Map(
"hoodie.table.name" -> "",
"hoodie.database.name" -> "",
"hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE",
"hoodie.datasource.write.operation" -> "upsert",
"hoodie.datasource.write.recordkey.field" -> "",
"hoodie.datasource.write.precombine.field" -> "",
"hoodie.datasource.write.partitionpath.field" -> "",
"hoodie.datasource.write.hive_style_partitioning" -> "true",
"hoodie.datasource.hive_sync.enable" -> "true",
"hoodie.datasource.hive_sync.database" -> "",
"hoodie.datasource.hive_sync.table" -> "",
"hoodie.datasource.hive_sync.partition_fields" -> "",
"hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc" -> "false",
"hoodie.datasource.hive_sync.mode" -> "hms",
"path" -> "s3://")
dataFrame.write.format("hudi")
.options(additionalOptions)
.mode("append")
.save()
```
------
## Ejemplo: leer una tabla de Hudi de Amazon S3 con el Catálogo de datos de AWS Glue
En este ejemplo, se lee la tabla de Hudi que creó en [Ejemplo: escribir una tabla de Hudi en Amazon S3 y registrarla en el Catálogo de datos de AWS Glue](#aws-glue-programming-etl-format-hudi-write) de Amazon S3.
**nota**
En este ejemplo, se requiere que establezca el parámetro de trabajo de `--enable-glue-datacatalog` para utilizar el Catálogo de datos de AWS Glue como metaalmacén de Apache Spark Hive. Para obtener más información, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
Para este ejemplo, utilice el método `GlueContext.create\$1data\$1frame.from\$1catalog()`.
```
# Example: Read a Hudi table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
dataFrame = glueContext.create_data_frame.from_catalog(
database = "",
table_name = ""
)
```
------
#### [ Scala ]
Para este ejemplo, utilice el método [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource).
```
// Example: Read a Hudi table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dataFrame = glueContext.getCatalogSource(
database = "",
tableName = ""
).getDataFrame()
}
}
```
------
## Ejemplo: actualizar e insertar un objeto `DataFrame` en una tabla de Hudi en Amazon S3
En este ejemplo, se utiliza el Catálogo de datos de AWS Glue para insertar un DataFrame en la tabla de Hudi que creó en [Ejemplo: escribir una tabla de Hudi en Amazon S3 y registrarla en el Catálogo de datos de AWS Glue](#aws-glue-programming-etl-format-hudi-write).
**nota**
En este ejemplo, se requiere que establezca el parámetro de trabajo de `--enable-glue-datacatalog` para utilizar el Catálogo de datos de AWS Glue como metaalmacén de Apache Spark Hive. Para obtener más información, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
Para este ejemplo, utilice el método `GlueContext.write\$1data\$1frame.from\$1catalog()`.
```
# Example: Upsert a Hudi table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
glueContext.write_data_frame.from_catalog(
frame = dataFrame,
database = "",
table_name = "",
additional_options={
"hoodie.table.name": "",
"hoodie.database.name": "",
"hoodie.datasource.write.storage.type": "COPY_ON_WRITE",
"hoodie.datasource.write.operation": "upsert",
"hoodie.datasource.write.recordkey.field": "",
"hoodie.datasource.write.precombine.field": "",
"hoodie.datasource.write.partitionpath.field": "",
"hoodie.datasource.write.hive_style_partitioning": "true",
"hoodie.datasource.hive_sync.enable": "true",
"hoodie.datasource.hive_sync.database": "",
"hoodie.datasource.hive_sync.table": "",
"hoodie.datasource.hive_sync.partition_fields": "",
"hoodie.datasource.hive_sync.partition_extractor_class": "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc": "false",
"hoodie.datasource.hive_sync.mode": "hms"
}
)
```
------
#### [ Scala ]
Para este ejemplo, utilice el método [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink).
```
// Example: Upsert a Hudi table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.JsonOptions
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getCatalogSink("", "",
additionalOptions = JsonOptions(Map(
"hoodie.table.name" -> "",
"hoodie.database.name" -> "",
"hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE",
"hoodie.datasource.write.operation" -> "upsert",
"hoodie.datasource.write.recordkey.field" -> "",
"hoodie.datasource.write.precombine.field" -> "",
"hoodie.datasource.write.partitionpath.field" -> "",
"hoodie.datasource.write.hive_style_partitioning" -> "true",
"hoodie.datasource.hive_sync.enable" -> "true",
"hoodie.datasource.hive_sync.database" -> "",
"hoodie.datasource.hive_sync.table" -> "",
"hoodie.datasource.hive_sync.partition_fields" -> "",
"hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc" -> "false",
"hoodie.datasource.hive_sync.mode" -> "hms"
)))
.writeDataFrame(dataFrame, glueContext)
}
}
```
------
## Ejemplo: leer una tabla de Hudi de Amazon S3 con Spark
En este ejemplo, se lee una tabla de Hudi de Amazon S3 con la API de DataFrame de Spark.
------
#### [ Python ]
```
# Example: Read a Hudi table from S3 using a Spark DataFrame
dataFrame = spark.read.format("hudi").load("s3://")
```
------
#### [ Scala ]
```
// Example: Read a Hudi table from S3 using a Spark DataFrame
val dataFrame = spark.read.format("hudi").load("s3://")
```
------
## Ejemplo: escribir una tabla de Hudi en Amazon S3 con Spark
En este ejemplo, se escribe una tabla de Hudi en Amazon S3 con Spark.
------
#### [ Python ]
```
# Example: Write a Hudi table to S3 using a Spark DataFrame
dataFrame.write.format("hudi") \
.options(**additional_options) \
.mode("overwrite") \
.save("s3://)
```
------
#### [ Scala ]
```
// Example: Write a Hudi table to S3 using a Spark DataFrame
dataFrame.write.format("hudi")
.options(additionalOptions)
.mode("overwrite")
.save("s3://")
```
------
## Ejemplo: Lea y escriba una tabla Hudi con el control de permisos de Lake Formation
En este ejemplo se lee y escribe una tabla Hudi con el control de permisos de Lake Formation.
1. Cree una tabla Hudi y regístrela en Lake Formation.
1. Para habilitar el control de permisos de Lake Formation, primero tendrá que registrar la tabla de la ruta Amazon S3 en Lake Formation. Para obtener más información, consulte [Registro de una ubicación de Amazon S3](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html). Puede registrarlo desde la consola de Lake Formation o mediante la AWS CLI:
```
aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region
```
Una vez que registre una ubicación de Amazon S3, cualquier tabla de AWS Glue que apunte a la ubicación (o a cualquiera de sus ubicaciones secundarias) devolverá el valor del parámetro `IsRegisteredWithLakeFormation` como verdadero en la llamada `GetTable`.
1. Cree una tabla Hudi que apunte a la ruta de Amazon S3 registrada a través de la API de marcos de datos de Spark:
```
hudi_options = {
'hoodie.table.name': table_name,
'hoodie.database.name': database_name,
'hoodie.datasource.write.storage.type': 'COPY_ON_WRITE',
'hoodie.datasource.write.recordkey.field': 'product_id',
'hoodie.datasource.write.table.name': table_name,
'hoodie.datasource.write.operation': 'upsert',
'hoodie.datasource.write.precombine.field': 'updated_at',
'hoodie.datasource.write.hive_style_partitioning': 'true',
'hoodie.upsert.shuffle.parallelism': 2,
'hoodie.insert.shuffle.parallelism': 2,
'path': ,
'hoodie.datasource.hive_sync.enable': 'true',
'hoodie.datasource.hive_sync.database': database_name,
'hoodie.datasource.hive_sync.table': table_name,
'hoodie.datasource.hive_sync.use_jdbc': 'false',
'hoodie.datasource.hive_sync.mode': 'hms'
}
df_products.write.format("hudi") \
.options(**hudi_options) \
.mode("overwrite") \
.save()
```
1. Conceda permiso a Lake Formation para el rol de IAM del trabajo de AWS Glue. Puede conceder permisos desde la consola de Lake Formation o mediante la AWS CLI. Para obtener más información, consulte [Concesión de permisos de tabla mediante la consola de Lake Formation y el método de recurso con nombre](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html)
1. Lea la tabla Hudi registrada en Lake Formation. El código es el mismo que leer una tabla Hudi no registrada. Tenga en cuenta que el rol de IAM del trabajo de AWS Glue debe tener el permiso SELECT para que la lectura se realice correctamente.
```
val dataFrame = glueContext.getCatalogSource(
database = "",
tableName = ""
).getDataFrame()
```
1. Escribe en una tabla Hudi registrada en Lake Formation. El código es el mismo que escribir en una tabla Hudi no registrada. Tenga en cuenta que el rol de IAM del trabajo de AWS Glue debe tener el permiso SUPER para que la escritura se realice correctamente.
```
glueContext.getCatalogSink("", "",
additionalOptions = JsonOptions(Map(
"hoodie.table.name" -> "",
"hoodie.database.name" -> "",
"hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE",
"hoodie.datasource.write.operation" -> "",
"hoodie.datasource.write.recordkey.field" -> "",
"hoodie.datasource.write.precombine.field" -> "",
"hoodie.datasource.write.partitionpath.field" -> "",
"hoodie.datasource.write.hive_style_partitioning" -> "true",
"hoodie.datasource.hive_sync.enable" -> "true",
"hoodie.datasource.hive_sync.database" -> "",
"hoodie.datasource.hive_sync.table" -> "",
"hoodie.datasource.hive_sync.partition_fields" -> "",
"hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc" -> "false",
"hoodie.datasource.hive_sync.mode" -> "hms"
)))
.writeDataFrame(dataFrame, glueContext)
```
# Uso del marco de Delta Lake en AWS Glue
AWS Glue 3.0 y versiones posteriores son compatibles con el marco de Linux Foundation Delta Lake. Delta Lake es un marco de almacenamiento de lagos de datos de código abierto para hacer transacciones de ACID, escalar el manejo de metadatos y unificar la transmisión y el procesamiento de datos por lotes. En este tema se describen las características disponibles para usar los datos en AWS Glue al transportar o almacenar datos en una tabla de Delta Lake. Para más información acerca de Delta Lake, consulte la [documentación oficial de Delta Lake](https://docs.delta.io/latest/delta-intro.html).
Puede usar AWS Glue para llevar a cabo operaciones de lectura y escritura en tablas de Delta Lake en Amazon S3, o trabajar con tablas de Delta Lake mediante el Catálogo de datos de AWS Glue. También se admiten operaciones adicionales, como la inserción, la actualización y las [lecturas y escrituras de tablas por lotes](https://docs.delta.io/0.7.0/api/python/index.html). Cuando usa tablas de Delta Lake, también tiene la opción de usar métodos de la biblioteca de Python de Delta Lake, como `DeltaTable.forPath`. Para obtener más información sobre la biblioteca de Python de Delta Lake, consulte la documentación de Python de Delta Lake.
En la siguiente tabla, se muestra la versión de Delta Lake que se incluye en cada versión de AWS Glue.
****
| Versión de AWS Glue | Versión de Delta Lake compatible |
| --- | --- |
| 5.1 | 3.3.2 |
| 5.0 | 3.3.0 |
| 4.0 | 2.1.0 |
| 3.0 | 1.0.0 |
Para más información sobre los marcos de lagos de datos compatibles con AWS Glue, consulte [Uso de marcos de lagos de datos con trabajos de ETL de AWS Glue](aws-glue-programming-etl-datalake-native-frameworks.md).
## Habilitar Delta Lake para AWS Glue
Para activar Delta Lake para AWS Glue, haga las siguientes tareas:
+ Especifique `delta` como valor para el parámetro del trabajo `--datalake-formats`. Para obtener más información, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md).
+ Cree una clave con el nombre `--conf` para el trabajo de AWS Glue y establézcala en el siguiente valor. Como alternativa, puede establecer la siguiente configuración mediante `SparkConf` en su script. Esta configuración ayuda a Apache Spark a gestionar correctamente las tablas de Delta Lake.
```
spark.sql.extensions=io.delta.sql.DeltaSparkSessionExtension --conf spark.sql.catalog.spark_catalog=org.apache.spark.sql.delta.catalog.DeltaCatalog --conf spark.delta.logStore.class=org.apache.spark.sql.delta.storage.S3SingleDriverLogStore
```
+ La compatibilidad con los permisos de Lake Formation para las tablas Delta está habilitada de forma predeterminada en AWS Glue 4.0. No se necesita ninguna configuración adicional para leer o escribir en las tablas Delta registradas en Lake Formation. Para leer una tabla Delta registrada, el rol de IAM del trabajo de AWS Glue debe tener el permiso SELECT. Para escribir en una tabla Delta registrada, el rol de IAM de AWS Glue debe tener el permiso SUPER. Para obtener más información sobre la administración de los permisos de Lake Formation, consulte [Otorgar y revocar permisos en los recursos del catálogo de datos](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html).
**Uso de una versión diferente de Delta Lake**
Para usar una versión de Delta Lake que no sea compatible con AWS Glue, indique sus propios archivos JAR de Delta Lake mediante el parámetro de trabajo `--extra-jars`. No incluya `delta` como valor para el parámetro de trabajo `--datalake-formats`. Si usa AWS Glue 5.0 o versiones posteriores, debe configurar el parámetro de trabajo `--user-jars-first true`. En este caso, para utilizar la biblioteca de Python de Delta Lake, debe especificar los archivos JAR de la biblioteca mediante el parámetro de trabajo `--extra-py-files`. La biblioteca de Python viene empaquetada en los archivos JAR de Delta Lake.
## Ejemplo: escribir una tabla de Delta Lake en Amazon S3 y regístrela en el Catálogo de datos de AWS Glue
El siguiente script ETL de AWS Glue muestra cómo escribir una tabla de Delta Lake en Amazon S3 y registrar la tabla en el Catálogo de datos de AWS Glue.
------
#### [ Python ]
```
# Example: Create a Delta Lake table from a DataFrame
# and register the table to Glue Data Catalog
additional_options = {
"path": "s3://"
}
dataFrame.write \
.format("delta") \
.options(**additional_options) \
.mode("append") \
.partitionBy("") \
.saveAsTable(".")
```
------
#### [ Scala ]
```
// Example: Example: Create a Delta Lake table from a DataFrame
// and register the table to Glue Data Catalog
val additional_options = Map(
"path" -> "s3://"
)
dataFrame.write.format("delta")
.options(additional_options)
.mode("append")
.partitionBy("")
.saveAsTable(".")
```
------
## Ejemplo: leer una tabla de Delta Lake de Amazon S3 con el Catálogo de datos de AWS Glue
El siguiente script de ETL de AWS Glue lee la tabla de Delta Lake que creó en [Ejemplo: escribir una tabla de Delta Lake en Amazon S3 y regístrela en el Catálogo de datos de AWS Glue](#aws-glue-programming-etl-format-delta-lake-write).
------
#### [ Python ]
Para este ejemplo, utilice el método [create\$1data\$1frame.from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-catalog).
```
# Example: Read a Delta Lake table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
df = glueContext.create_data_frame.from_catalog(
database="",
table_name="",
additional_options=additional_options
)
```
------
#### [ Scala ]
Para este ejemplo, utilice el método [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource).
```
// Example: Read a Delta Lake table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val df = glueContext.getCatalogSource("", "",
additionalOptions = additionalOptions)
.getDataFrame()
}
}
```
------
## Ejemplo: insertar un elemento `DataFrame` en una tabla de Delta Lake de Amazon S3 con el Catálogo de datos de AWS Glue
En este ejemplo, se insertan los datos en la tabla de Delta Lake que creó en [Ejemplo: escribir una tabla de Delta Lake en Amazon S3 y regístrela en el Catálogo de datos de AWS Glue](#aws-glue-programming-etl-format-delta-lake-write).
**nota**
En este ejemplo, se requiere que establezca el parámetro de trabajo de `--enable-glue-datacatalog` para utilizar el Catálogo de datos de AWS Glue como metaalmacén de Apache Spark Hive. Para obtener más información, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
Para este ejemplo, utilice el método [write\$1data\$1frame.from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_data_frame_from_catalog).
```
# Example: Insert into a Delta Lake table in S3 using Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
glueContext.write_data_frame.from_catalog(
frame=dataFrame,
database="",
table_name="",
additional_options=additional_options
)
```
------
#### [ Scala ]
Para este ejemplo, utilice el método [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink).
```
// Example: Insert into a Delta Lake table in S3 using Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getCatalogSink("", "",
additionalOptions = additionalOptions)
.writeDataFrame(dataFrame, glueContext)
}
}
```
------
## Ejemplo: leer una tabla de Delta Lake de Amazon S3 con la API de Spark
En este ejemplo, se lee una tabla de Delta Lake de Amazon S3 con la API de Spark.
------
#### [ Python ]
```
# Example: Read a Delta Lake table from S3 using a Spark DataFrame
dataFrame = spark.read.format("delta").load("s3://")
```
------
#### [ Scala ]
```
// Example: Read a Delta Lake table from S3 using a Spark DataFrame
val dataFrame = spark.read.format("delta").load("s3://")
```
------
## Ejemplo: escribir una tabla de Delta Lake en Amazon S3 con Spark
En este ejemplo, se escribe una tabla de Delta Lake en Amazon S3 con Spark.
------
#### [ Python ]
```
# Example: Write a Delta Lake table to S3 using a Spark DataFrame
dataFrame.write.format("delta") \
.options(**additional_options) \
.mode("overwrite") \
.partitionBy("")
.save("s3://")
```
------
#### [ Scala ]
```
// Example: Write a Delta Lake table to S3 using a Spark DataFrame
dataFrame.write.format("delta")
.options(additionalOptions)
.mode("overwrite")
.partitionBy("")
.save("s3://")
```
------
## Ejemplo: Lea y escriba la tabla de Delta Lake con el control de permisos de Lake Formation
En este ejemplo se lee y escribe una tabla de Delta Lake con el control de permisos de Lake Formation.
1. Cree una tabla Delta y regístrela en Lake Formation
1. Para habilitar el control de permisos de Lake Formation, primero tendrá que registrar la tabla de la ruta Amazon S3 en Lake Formation. Para obtener más información, consulte [Registro de una ubicación de Amazon S3](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html). Puede registrarlo desde la consola de Lake Formation o mediante la AWS CLI:
```
aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region
```
Una vez que registre una ubicación de Amazon S3, cualquier tabla de AWS Glue que apunte a la ubicación (o a cualquiera de sus ubicaciones secundarias) devolverá el valor del parámetro `IsRegisteredWithLakeFormation` como verdadero en la llamada `GetTable`.
1. Cree una tabla Delta que apunte a la ruta de Amazon S3 registrada a través de Spark:
**nota**
A continuación, se muestran algunos ejemplos de Python.
```
dataFrame.write \
.format("delta") \
.mode("overwrite") \
.partitionBy("") \
.save("s3://")
```
Una vez que los datos se hayan escrito en Amazon S3, utilice el rastreador AWS Glue para crear una nueva tabla de catálogo de Delta. Para obtener más información, consulte [Presentación del soporte de tabla nativa de Delta Lake con rastreadores AWS Glue](https://aws.amazon.com/blogs/big-data/introducing-native-delta-lake-table-support-with-aws-glue-crawlers/).
También puede crear la tabla manualmente a través de la API de AWS Glue.`CreateTable`
1. Conceda permiso a Lake Formation para el rol de IAM del trabajo de AWS Glue. Puede conceder permisos desde la consola de Lake Formation o mediante la AWS CLI. Para obtener más información, consulte [Concesión de permisos de tabla mediante la consola de Lake Formation y el método de recurso con nombre](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html)
1. Lea la tabla Delta registrada en Lake Formation. El código es el mismo que leer una tabla Delta no registrada. Tenga en cuenta que el rol de IAM del trabajo de AWS Glue debe tener el permiso SELECT para que la lectura se realice correctamente.
```
# Example: Read a Delta Lake table from Glue Data Catalog
df = glueContext.create_data_frame.from_catalog(
database="",
table_name="",
additional_options=additional_options
)
```
1. Escribe a una tabla Delta registrada en Lake Formation. El código es el mismo que escribir en una tabla Delta no registrada. Tenga en cuenta que el rol de IAM del trabajo de AWS Glue debe tener el permiso SUPER para que la escritura se realice correctamente.
De forma predeterminada, AWS Glue usa `Append` como SaveMode. Puede cambiarlo configurando la opción SaveMode en `additional_options`. Para obtener información sobre la compatibilidad con SaveMode en las tablas Delta, consulte [Escribir en una tabla](https://docs.delta.io/latest/delta-batch.html#write-to-a-table).
```
glueContext.write_data_frame.from_catalog(
frame=dataFrame,
database="",
table_name="",
additional_options=additional_options
)
```
# Uso del marco de Iceberg en AWS Glue
AWS Glue 3.0 y versiones posteriores son compatibles con el marco de Apache Iceberg para lagos de datos. Iceberg proporciona un formato de tabla de alto rendimiento que funciona igual que una tabla SQL. En este tema, se describen las características disponibles para usar los datos en AWS Glue al transportar o almacenar datos en una tabla de Iceberg. Para más información sobre Iceberg, consulte la [documentación oficial de Apache Iceberg](https://iceberg.apache.org/docs/latest/).
Puede usar AWS Glue para llevar a cabo operaciones de lectura y escritura en tablas de Iceberg en Amazon S3, o trabajar con tablas de Iceberg mediante el Catálogo de datos de AWS Glue. También se admiten operaciones adicionales, como insertar, y todas las [consultas de Spark](https://iceberg.apache.org/docs/latest/spark-queries/) [escrituras de Spark](https://iceberg.apache.org/docs/latest/spark-writes/). La actualización no es compatible con las tablas de Iceberg.
**nota**
`ALTER TABLE … RENAME TO` no está disponible para Apache Iceberg 0.13.1 para AWS Glue 3.0.
La siguiente tabla muestra la versión de Iceberg que se incluye en cada versión de AWS Glue.
****
| Versión de AWS Glue | Versión de Iceberg compatible |
| --- | --- |
| 5.1 | 1.10.0 |
| 5.0 | 1.7.1 |
| 4.0 | 1.0.0 |
| 3.0 | 0.13.1 |
Para más información sobre los marcos de lagos de datos compatibles con AWS Glue, consulte [Uso de marcos de lagos de datos con trabajos de ETL de AWS Glue](aws-glue-programming-etl-datalake-native-frameworks.md).
## Habilitar el marco de Iceberg
Para habilitar Iceberg para AWS Glue, haga las siguientes tareas:
+ Especifique `iceberg` como valor para el parámetro del trabajo `--datalake-formats`. Para obtener más información, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md).
+ Cree una clave con el nombre `--conf` para el trabajo de AWS Glue y establézcala en el siguiente valor. Como alternativa, puede establecer la siguiente configuración mediante `SparkConf` en su script. Esta configuración ayuda a Apache Spark a gestionar correctamente las tablas de Iceberg.
```
spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog
--conf spark.sql.catalog.glue_catalog.warehouse=s3:///
--conf spark.sql.catalog.glue_catalog.catalog-impl=org.apache.iceberg.aws.glue.GlueCatalog
--conf spark.sql.catalog.glue_catalog.io-impl=org.apache.iceberg.aws.s3.S3FileIO
```
Si lee o escribe en tablas de Iceberg registradas en Lake Formation, siga las indicaciones que aparecen en [Uso de AWS Glue con AWS Lake Formation para obtener un control de acceso detallado](security-lf-enable.md) en AWS Glue 5.0 y versiones posteriores. En AWS Glue 4.0, agregue la siguiente configuración para habilitar la compatibilidad con Lake Formation.
```
--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true
--conf spark.sql.catalog.glue_catalog.glue.id=
```
Si utiliza AWS Glue 3.0 con Iceberg 0.13.1, debe establecer las siguientes configuraciones adicionales para utilizar el administrador de bloqueos de Amazon DynamoDB y garantizar la transacción atómica. AWS Glue 4.0 y versiones posteriores utilizan el bloqueo positivo de forma predeterminada. Para obtener más información, consulte [Iceberg AWS Integrations](https://iceberg.apache.org/docs/latest/aws/#dynamodb-lock-manager) en la documentación oficial de Apache Iceberg.
```
--conf spark.sql.catalog.glue_catalog.lock-impl=org.apache.iceberg.aws.glue.DynamoLockManager
--conf spark.sql.catalog.glue_catalog.lock.table=
```
**Usar una versión diferente de Iceberg**
Para usar una versión de Iceberg que no sea compatible con AWS Glue, indique sus propios archivos JAR de Iceberg mediante el parámetro de trabajo `--extra-jars`. No incluya `iceberg` como valor para el parámetro `--datalake-formats`. Si usa AWS Glue 5.0 o versiones posteriores, debe configurar el parámetro de trabajo `--user-jars-first true`.
**Habilitar el cifrado para tablas de Iceberg**
**nota**
Las tablas de Iceberg tienen sus propios mecanismos para habilitar el cifrado del lado del servidor. Debe habilitar esta configuración además de la configuración de seguridad de Glue AWS.
Para habilitar el cifrado del lado del servidor en las tablas de Iceberg, consulte las instrucciones de la [documentación de Iceberg.](https://iceberg.apache.org/docs/latest/aws/#s3-server-side-encryption)
**Agregue la configuración de Spark para el acceso entre regiones de Iceberg**
Para añadir una configuración adicional de Spark para el acceso a tablas entre regiones de Iceberg con el catálogo de datos de AWS Glue y AWS Lake Formation, siga los pasos que se indican a continuación:
1. Creación de un [punto de acceso de varias regiones](https://docs.aws.amazon.com/AmazonS3/latest/userguide/multi-region-access-point-create-examples.html).
1. Defina las siguientes propiedades de Spark:
```
-----
--conf spark.sql.catalog.my_catalog.s3.use-arn-region-enabled=true \
--conf spark.sql.catalog.{CATALOG}.s3.access-points.bucket1", "arn:aws:s3:::accesspoint/.mrap \
--conf spark.sql.catalog.{CATALOG}.s3.access-points.bucket2", "arn:aws:s3:::accesspoint/.mrap
-----
```
## Ejemplo: escriba una tabla de Iceberg en Amazon S3 y regístrela en el Catálogo de datos de AWS Glue
En este script de ejemplo, se muestra cómo escribir una tabla de Iceberg en Amazon S3. En el ejemplo se usan [integraciones de AWS de Iceberg](https://iceberg.apache.org/docs/latest/aws/) para registrar la tabla en el Catálogo de datos de AWS Glue.
------
#### [ Python ]
```
# Example: Create an Iceberg table from a DataFrame
# and register the table to Glue Data Catalog
dataFrame.createOrReplaceTempView("tmp_")
query = f"""
CREATE TABLE glue_catalog..
USING iceberg
TBLPROPERTIES ("format-version"="2")
AS SELECT * FROM tmp_
"""
spark.sql(query)
```
------
#### [ Scala ]
```
// Example: Example: Create an Iceberg table from a DataFrame
// and register the table to Glue Data Catalog
dataFrame.createOrReplaceTempView("tmp_")
val query = """CREATE TABLE glue_catalog..
USING iceberg
TBLPROPERTIES ("format-version"="2")
AS SELECT * FROM tmp_
"""
spark.sql(query)
```
------
Como alternativa, puede escribir una tabla de Iceberg en Amazon S3 y en el Catálogo de datos con los métodos de Spark.
Requisitos previos: deberá disponer de un catálogo para su uso en la biblioteca Iceberg. Cuando se utiliza el AWS catálogo de datos de Glue AWS, Glue lo simplifica. El catálogo de datos de Glue AWS está preconfigurado para que lo utilicen las bibliotecas de Spark como `glue_catalog`. Las tablas del catálogo de datos se identifican mediante un *databaseName* y un *tableName*. Para obtener más información sobre el catálogo de datos de Glue AWS, consulte [Detección y catalogación de datos en AWS Glue](catalog-and-crawler.md).
Si no utiliza el catálogo de datos de Glue AWS, tendrá que aprovisionar un catálogo a través de las API de Spark. Para obtener más información, consulte [Configuración de Spark](https://iceberg.apache.org/docs/latest/spark-configuration/) en la documentación de Iceberg.
En este ejemplo, se escribe una tabla de Iceberg en Amazon S3 y el Catálogo de datos con Spark.
------
#### [ Python ]
```
# Example: Write an Iceberg table to S3 on the Glue Data Catalog
# Create (equivalent to CREATE TABLE AS SELECT)
dataFrame.writeTo("glue_catalog.databaseName.tableName") \
.tableProperty("format-version", "2") \
.create()
# Append (equivalent to INSERT INTO)
dataFrame.writeTo("glue_catalog.databaseName.tableName") \
.tableProperty("format-version", "2") \
.append()
```
------
#### [ Scala ]
```
// Example: Write an Iceberg table to S3 on the Glue Data Catalog
// Create (equivalent to CREATE TABLE AS SELECT)
dataFrame.writeTo("glue_catalog.databaseName.tableName")
.tableProperty("format-version", "2")
.create()
// Append (equivalent to INSERT INTO)
dataFrame.writeTo("glue_catalog.databaseName.tableName")
.tableProperty("format-version", "2")
.append()
```
------
## Ejemplo: leer una tabla de Iceberg de Amazon S3 con el Catálogo de datos de AWS Glue
En este ejemplo, se lee la tabla de Iceberg que creó en [Ejemplo: escriba una tabla de Iceberg en Amazon S3 y regístrela en el Catálogo de datos de AWS Glue](#aws-glue-programming-etl-format-iceberg-write).
------
#### [ Python ]
Para este ejemplo, utilice el método `GlueContext.create\$1data\$1frame.from\$1catalog()`.
```
# Example: Read an Iceberg table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
df = glueContext.create_data_frame.from_catalog(
database="",
table_name="",
additional_options=additional_options
)
```
------
#### [ Scala ]
Para este ejemplo, utilice el método [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource).
```
// Example: Read an Iceberg table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val df = glueContext.getCatalogSource("", "",
additionalOptions = additionalOptions)
.getDataFrame()
}
}
```
------
## Ejemplo: insertar un `DataFrame` en una tabla de Iceberg de Amazon S3 con el Catálogo de datos de AWS Glue
En este ejemplo, se insertan los datos en la tabla de Iceberg que creó en [Ejemplo: escriba una tabla de Iceberg en Amazon S3 y regístrela en el Catálogo de datos de AWS Glue](#aws-glue-programming-etl-format-iceberg-write).
**nota**
En este ejemplo, se requiere que establezca el parámetro de trabajo de `--enable-glue-datacatalog` para utilizar el Catálogo de datos de AWS Glue como metaalmacén de Apache Spark Hive. Para obtener más información, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
Para este ejemplo, utilice el método `GlueContext.write\$1data\$1frame.from\$1catalog()`.
```
# Example: Insert into an Iceberg table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
glueContext.write_data_frame.from_catalog(
frame=dataFrame,
database="",
table_name="",
additional_options=additional_options
)
```
------
#### [ Scala ]
Para este ejemplo, utilice el método [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink).
```
// Example: Insert into an Iceberg table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getCatalogSink("", "",
additionalOptions = additionalOptions)
.writeDataFrame(dataFrame, glueContext)
}
}
```
------
## Ejemplo: leer una tabla de Iceberg de Amazon S3 con Spark
Requisitos previos: deberá disponer de un catálogo para su uso en la biblioteca Iceberg. Cuando se utiliza el AWS catálogo de datos de Glue AWS, Glue lo simplifica. El catálogo de datos de Glue AWS está preconfigurado para que lo utilicen las bibliotecas de Spark como `glue_catalog`. Las tablas del catálogo de datos se identifican mediante un *databaseName* y un *tableName*. Para obtener más información sobre el catálogo de datos de Glue AWS, consulte [Detección y catalogación de datos en AWS Glue](catalog-and-crawler.md).
Si no utiliza el catálogo de datos de Glue AWS, tendrá que aprovisionar un catálogo a través de las API de Spark. Para obtener más información, consulte [Configuración de Spark](https://iceberg.apache.org/docs/latest/spark-configuration/) en la documentación de Iceberg.
En este ejemplo, se lee una tabla de Iceberg en Amazon S3 del catálogo de datos con Spark.
------
#### [ Python ]
```
# Example: Read an Iceberg table on S3 as a DataFrame from the Glue Data Catalog
dataFrame = spark.read.format("iceberg").load("glue_catalog.databaseName.tableName")
```
------
#### [ Scala ]
```
// Example: Read an Iceberg table on S3 as a DataFrame from the Glue Data Catalog
val dataFrame = spark.read.format("iceberg").load("glue_catalog.databaseName.tableName")
```
------
## Ejemplo: Lea y escriba una tabla de iceberg con el control de permisos de Lake Formation
En este ejemplo se lee y escribe una tabla de Iceberg con el control de permisos de Lake Formation.
**nota**
Este ejemplo solo funciona en AWS Glue 4.0. En AWS Glue 5.0 y versiones posteriores, siga las indicaciones que aparece en [Uso de AWS Glue con AWS Lake Formation para obtener un control de acceso detallado](security-lf-enable.md).
1. Cree una tabla de iceberg y regístrela en Lake Formation:
1. Para habilitar el control de permisos de Lake Formation, primero tendrá que registrar la tabla de la ruta Amazon S3 en Lake Formation. Para obtener más información, consulte [Registro de una ubicación de Amazon S3](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html). Puede registrarlo desde la consola de Lake Formation o mediante la AWS CLI:
```
aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region
```
Una vez que registre una ubicación de Amazon S3, cualquier tabla de AWS Glue que apunte a la ubicación (o a cualquiera de sus ubicaciones secundarias) devolverá el valor del parámetro `IsRegisteredWithLakeFormation` como verdadero en la llamada `GetTable`.
1. Cree una tabla de Iceberg que apunte a la ruta registrada mediante Spark SQL:
**nota**
A continuación, se muestran algunos ejemplos de Python.
```
dataFrame.createOrReplaceTempView("tmp_")
query = f"""
CREATE TABLE glue_catalog..
USING iceberg
AS SELECT * FROM tmp_
"""
spark.sql(query)
```
También puede crear la tabla manualmente mediante la API de AWS Glue.`CreateTable` Para obtener más información, consulte [Creación de tablas de Apache Iceberg](https://docs.aws.amazon.com/lake-formation/latest/dg/creating-iceberg-tables.html).
**nota**
Actualmente, la API `UpdateTable` no es compatible con el formato de tabla Iceberg como entrada para la operación.
1. Conceda permiso a Lake Formation para el rol de IAM. Puede conceder permisos desde la consola de Lake Formation o mediante la AWS CLI. Para obtener más información, consulte: https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html
1. Lea una tabla de Iceberg registrada en Lake Formation. El código es el mismo que leer una tabla de Icebergs no registrada. Tenga en cuenta que el rol de IAM de su trabajo de AWS Glue debe tener el permiso SELECT para que la lectura se realice correctamente.
```
# Example: Read an Iceberg table from the AWS Glue Data Catalog
from awsglue.context import GlueContextfrom pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
df = glueContext.create_data_frame.from_catalog(
database="",
table_name="",
additional_options=additional_options
)
```
1. Escriba en una tabla de Iceberg registrada en Lake Formation. El código es el mismo que escribir en una tabla Iceberg no registrada. Tenga en cuenta que su rol de IAM del trabajo de AWS Glue debe tener el permiso SUPER para que la escritura se realice correctamente.
```
glueContext.write_data_frame.from_catalog(
frame=dataFrame,
database="",
table_name="",
additional_options=additional_options
)
```