# Usar estruturas de data lake com trabalhos do AWS Glue ETL
As estruturas de data lake de código aberto simplificam o processamento incremental de dados para os arquivos que você armazena em data lakes criados no Amazon S3. O AWS Glue 3.0 e posteriores são compatíveis com as seguintes estruturas de data lake de código aberto:
+ Apache Hudi
+ Linux Foundation Delta Lake
+ Apache Iceberg
Fornecemos suporte nativo para essas estruturas para que você possa ler e gravar os dados que armazenar no Amazon S3 de maneira transacionalmente consistente. Não é necessário instalar um conector separado nem realizar etapas adicionais de configuração para usar essas estruturas em trabalhos do AWS Glue ETL.
Ao gerenciar conjuntos de dados por meio do AWS Glue Data Catalog, você pode usar os métodos do AWS Glue para ler e gravar tabelas de data lake com o Spark DataFrames. Você também pode ler e gravar dados do Amazon S3 usando a API DataFrame do Spark.
Neste vídeo, você pode aprender sobre os conceitos básicos de como o Apache Hudi, o Apache Iceberg e o Delta Lake funcionam. Você verá como inserir, atualizar e excluir dados no data lake e como cada uma dessas estruturas funciona.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/fryfx0Zg7KA)
**Topics**
+ [Limitações](aws-glue-programming-etl-datalake-native-frameworks-limitations.md)
+ [Usar a estrutura Hudi no AWS Glue](aws-glue-programming-etl-format-hudi.md)
+ [Usar a estrutura Delta Lake no AWS Glue](aws-glue-programming-etl-format-delta-lake.md)
+ [Usar a estrutura Iceberg no AWS Glue](aws-glue-programming-etl-format-iceberg.md)
# Limitações
Considere as seguintes limitações antes de usar estruturas de data lake com o AWS Glue.
+ Os métodos do `GlueContext` do AWS Glue a seguir não são compatíveis com leitura e escrita em tabelas de estrutura de data lake. Em vez disso, use os métodos `GlueContext` da API do DataFrame ou Spark DataFrame.
+ `create_dynamic_frame.from_catalog`
+ `write_dynamic_frame.from_catalog`
+ `getDynamicFrame`
+ `writeDynamicFrame`
+ Os métodos `GlueContext` a seguir para DataFrame são compatíveis com o controle de permissão do Lake Formation:
+ `create_data_frame.from_catalog`
+ `write_data_frame.from_catalog`
+ `getDataFrame`
+ `writeDataFrame`
+ [Agrupamento de arquivos pequenos](grouping-input-files.md) não é compatível.
+ [Marcadores de trabalho](monitor-continuations.md) não são compatíveis.
+ O Apache Hudi 0.10.1 para AWS Glue 3.0 não é compatível com tabelas Merge on Read (MoR) do Hudi.
+ `ALTER TABLE … RENAME TO` não está disponível para o Apache Iceberg 0.13.1 para o AWS Glue 3.0.
## Limitações para tabelas em formato de data lake gerenciadas pelas permissões do Lake Formation
Os formatos de data lake são integrados ao AWS Glue ETL por meio das permissões do Lake Formation. Não há suporte à criação de um DynamicFrame usando `create_dynamic_frame`. Para obter mais informações, veja os exemplos a seguir:
+ [Exemplo: ler e escrever na tabela do Iceberg com o controle de permissão do 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)
+ [Exemplo: ler e escrever na tabela do Hudi com o controle de permissão do 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)
+ [Exemplo: ler e escrever na tabela do Delta Lake com o controle de permissão do 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**
A integração com o AWS Glue ETL por meio das permissões do Lake Formation para o Apache Hudi, o Apache Iceberg e o Delta Lake só é possível no AWS Glue versão 4.0.
O Apache Iceberg tem a melhor integração com o AWS Glue ETL por meio das permissões do Lake Formation. Ele é compatível com quase todas as operações e inclui suporte a SQL.
O Hudi é compatível com a maioria das operações básicas, com exceção de operações administrativas. Isso ocorre porque essas opções geralmente são feitas por meio da gravação de dataframes e especificadas via `additional_options`. Você precisa usar APIs do AWS Glue para criar DataFrames para suas operações, pois não há suporte ao SparkSQL.
O Delta Lake é compatível somente com leitura, anexação e substituição de dados da tabela. O Delta Lake exige o uso de suas próprias bibliotecas para poder realizar várias tarefas, como atualizações.
Os recursos a seguir não estão disponíveis para tabelas do Iceberg gerenciadas por permissões do Lake Formation.
+ Compactação usando o AWS Glue ETL
+ Suporte ao Spark SQL via AWS Glue ETL
A seguir estão as limitações das tabelas do Hudi gerenciadas por permissões do Lake Formation:
+ Remoção de arquivos órfãos
A seguir estão as limitações das tabelas do Data Lake gerenciadas por permissões do Lake Formation:
+ Todos os recursos, exceto inserir e ler das tabelas do Delta Lake.
# Usar a estrutura Hudi no AWS Glue
O AWS Glue 3.0 e versões posteriores são compatíveis com a estrutura Apache Hudi para data lakes. Hudi é uma estrutura de armazenamento de data lake de código aberto que simplifica o processamento incremental de dados e o desenvolvimento de pipelines de dados. Este tópico aborda os recursos disponíveis para usar dados no AWS Glue ao transportar ou armazenar dados em uma tabela do Hudi. Para saber mais sobre o Hudi, consulte a [documentação do Apache Hudi](https://hudi.apache.org/docs/overview/).
Você pode usar o AWS Glue para realizar operações de leitura e gravação em tabelas do Hudi no Amazon S3 ou trabalhar com tabelas do Hudi usando o AWS Glue Data Catalog. Operações adicionais, incluindo inserção, atualização e todas as [operações do Apache Spark](https://hudi.apache.org/docs/quick-start-guide/) também são compatíveis.
**nota**
A implementação do Apache Hudi 0.15.0 no AWS Glue 5.0 reverte internamente o [HUDI-7001](https://github.com/apache/hudi/pull/9936). Ele não exibe a regressão relacionada à geração de chaves complexas quando a chave de registro consiste em um único campo. No entanto, esse comportamento difere do OSS Apache Hudi 0.15.0.
O Apache Hudi 0.10.1 para AWS Glue 3.0 não é compatível com tabelas Merge on Read (MoR) do Hudi.
A tabela a seguir lista a versão do Hudi incluída em cada versão do AWS Glue.
****
| Versão do AWS Glue | Versões compatíveis do Hudi |
| --- | --- |
| 5.1 | 1.0.2 |
| 5,0 | 0.15.0 |
| 4,0 | 0.12.1 |
| 3.0 | 0.10.1 |
Para saber mais sobre as estruturas de data lake compatíveis com o AWS Glue, consulte [Usar estruturas de data lake com trabalhos do AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
## Habilitar o Hudi
Para habilitar o Hudi para AWS Glue, faça as seguintes tarefas:
+ Especifique `hudi` como um valor para o parâmetro de trabalho `--datalake-formats`. Para obter mais informações, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md).
+ Crie uma chave denominada `--conf` para o trabalho do AWS Glue e defina-a com o seguinte valor. Ou então, você pode definir a configuração a seguir usando `SparkConf` no script. Essas configurações ajudam o Apache Spark a lidar corretamente com as tabelas do Hudi.
```
spark.serializer=org.apache.spark.serializer.KryoSerializer
```
+ O suporte à permissão do Lake Formation para tabelas do Hudi está habilitado por padrão para o AWS Glue 4.0. Nenhuma configuração adicional é necessária para leitura/escrita em tabelas do Hudi registradas no Lake Formation. Para ler uma tabela do Hudi registrada, o perfil do IAM do trabalho do AWS Glue deve ter a permissão SELECT. Para escrever em uma tabela do Hudi registrada, o perfil do IAM do trabalho do AWS Glue deve ter a permissão SUPER. Para saber mais sobre como gerenciar as permissões do Lake Formation, consulte [Conceder e revogar permissões nos recursos do Catálogo de Dados](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html).
**Usar uma versão diferente do Hudi**
Para usar uma versão do Hudi que não é compatível com o AWS Glue, especifique seus próprios arquivos JAR do Hudi usando o parâmetro de trabalho `--extra-jars`. Não inclua `hudi` como um valor para o parâmetro de trabalho `--datalake-formats`. Se você usa o AWS Glue 5.0 ou versões superiores, é necessário definir o parâmetro `--user-jars-first true` do trabalho.
## Exemplo: escrever uma tabela Hudi no Amazon S3 e registrá-la no AWS Glue Data Catalog
O exemplo a seguir demonstra como gravar uma tabela do Hudi no Amazon S3 e registrá-la no AWS Glue Data Catalog. O exemplo usa a [ferramenta Hive Sync](https://hudi.apache.org/docs/syncing_metastore/) do Hudi para registrar a tabela.
**nota**
Este exemplo exige que você defina o parâmetro de trabalho `--enable-glue-datacatalog` para usar o AWS Glue Data Catalog como metastore do Apache Spark Hive. Para saber mais, consulte [Usar parâmetros de tarefa em tarefas do 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()
```
------
## Exemplo: ler uma tabela do Hudi do Amazon S3 usando o AWS Glue Data Catalog
Este exemplo lê a tabela Hudi que você criou no [Exemplo: escrever uma tabela Hudi no Amazon S3 e registrá-la no AWS Glue Data Catalog](#aws-glue-programming-etl-format-hudi-write) do Amazon S3.
**nota**
Este exemplo exige que você defina o parâmetro de trabalho `--enable-glue-datacatalog` para usar o AWS Glue Data Catalog como metastore do Apache Spark Hive. Para saber mais, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
Para este exemplo, use o 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 ]
Neste exemplo, use o 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()
}
}
```
------
## Exemplo: atualizar e inserir um `DataFrame` a em uma tabela do Hudi no Amazon S3
Este exemplo usa o AWS Glue Data Catalog para inserir um DataFrame na tabela do Hudi que você criou em [Exemplo: escrever uma tabela Hudi no Amazon S3 e registrá-la no AWS Glue Data Catalog](#aws-glue-programming-etl-format-hudi-write).
**nota**
Este exemplo exige que você defina o parâmetro de trabalho `--enable-glue-datacatalog` para usar o AWS Glue Data Catalog como metastore do Apache Spark Hive. Para saber mais, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
Para este exemplo, use o 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 ]
Neste exemplo, use o 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)
}
}
```
------
## Exemplo: ler uma tabela do Hudi do Amazon S3 usando o Spark
Este exemplo lê uma tabela do Hudi do Amazon S3 usando a API do 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://")
```
------
## Exemplo: gravar uma tabela no Amazon S3 usando o Spark
Este exemplo grava uma tabela no Amazon S3 usando o 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://")
```
------
## Exemplo: ler e escrever na tabela do Hudi com o controle de permissão do Lake Formation
Este exemplo lê e escreve uma tabela do Hudi com o controle de permissão do Lake Formation
1. Criar uma tabela do Hudi e registrá-la no Lake Formation
1. Para habilitar o controle de permissão do Lake Formation, primeiro será necessário registrar o caminho da tabela do Amazon S3 no Lake Formation. Para obter mais informações, consulte [Registering an Amazon S3 location](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html) (Registrar um local do Amazon S3). É possível registrá-lo no console do Lake Formation ou usando a AWS CLI:
```
aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region
```
Depois de registrar uma localização no Amazon S3, qualquer tabela do AWS Glue apontando para a localização (ou qualquer uma de suas localizações secundárias) retornará o valor do parâmetro `IsRegisteredWithLakeFormation` como verdadeiro na chamada `GetTable`.
1. Crie uma tabela do Hudi que aponte para o caminho registrado do Amazon S3 por meio da API de dataframe do 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 permissão do Lake Formation para o perfil do IAM do trabalho do AWS Glue. Você pode conceder permissões no console do Lake Formation ou usando a AWS CLI. Para obter mais informações, consulte [Conceder permissões de banco de dados usando o console do Lake Formation e o método de recurso nomeado](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html)
1. Leia a tabela do Hudi registrada no Lake Formation. O código é o mesmo que o da leitura de uma tabela do Hudi não registrada. Observe que o perfil do IAM do trabalho do AWS Glue precisa ter a permissão SELECT para que a leitura seja bem-sucedida.
```
val dataFrame = glueContext.getCatalogSource(
database = "",
tableName = ""
).getDataFrame()
```
1. Escreva em uma tabela do Hudi registrada no Lake Formation. O código é o mesmo que o da escrita em uma tabela do Hudi não registrada. Observe que o perfil do IAM do trabalho do AWS Glue precisa ter a permissão SUPER para que a escrita seja bem-sucedida.
```
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)
```
# Usar a estrutura Delta Lake no AWS Glue
O AWS Glue 3.0 e versões posteriores são compatíveis com a estrutura Linux Foundation Delta Lake. Delta Lake é uma estrutura de armazenamento de data lake de código aberto que ajuda você a realizar transações ACID, escalar o tratamento de metadados e unificar o streaming e o processamento de dados em lote. Este tópico aborda os recursos disponíveis para usar dados no AWS Glue ao transportar ou armazenar dados em uma tabela do Delta Lake. Para saber mais sobre o Delta Lake, consulte a [documentação oficial do Delta Lake](https://docs.delta.io/latest/delta-intro.html).
Você pode usar o AWS Glue para realizar operações de leitura e gravação em tabelas do Delta Lake no Amazon S3 ou trabalhar com tabelas do Delta Lake usando o AWS Glue Data Catalog. Operações adicionais, como inserção, atualização e [leitura e gravação em lote de tabelas](https://docs.delta.io/0.7.0/api/python/index.html), também são compatíveis. Quando você usa tabelas do Delta Lake, também tem a opção de usar métodos da biblioteca do Delta Lake Python, como `DeltaTable.forPath`. Para obter mais informações sobre a biblioteca de Python do Delta Lake, consulte a documentação de Python do Delta Lake.
A tabela a seguir lista a versão do Delta Lake incluída em cada versão do AWS Glue.
****
| Versão do AWS Glue | Versão Delta Lake compatível |
| --- | --- |
| 5.1 | 3.3.2 |
| 5,0 | 3.3.0 |
| 4,0 | 2.1.0 |
| 3.0 | 1.0.0 |
Para saber mais sobre as estruturas de data lake compatíveis com o AWS Glue, consulte [Usar estruturas de data lake com trabalhos do AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
## Habilitar o Delta Lake para AWS Glue
Para habilitar o Delta Lake para AWS Glue, faça as seguintes tarefas:
+ Especifique `delta` como um valor para o parâmetro de trabalho `--datalake-formats`. Para obter mais informações, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md).
+ Crie uma chave denominada `--conf` para o trabalho do AWS Glue e defina-a com o seguinte valor. Ou então, é possível definir a configuração a seguir usando `SparkConf` no script. Essas configurações ajudam o Apache Spark a lidar corretamente com tabelas do 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
```
+ O suporte à permissão do Lake Formation para tabelas do Delta está habilitado por padrão para o AWS Glue 4.0. Nenhuma configuração adicional é necessária para leitura/escrita em tabelas do Delta registradas no Lake Formation. Para ler uma tabela do Delta registrada, o perfil do IAM do trabalho do AWS Glue deve ter a permissão SELECT. Para escrever em uma tabela do Delta registrada, o perfil do IAM do trabalho do AWS Glue deve ter a permissão SUPER. Para saber mais sobre como gerenciar as permissões do Lake Formation, consulte [Conceder e revogar permissões nos recursos do Catálogo de Dados](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html).
**Usar uma versão diferente do Delta Lake**
Para usar uma versão do Delta Lake que não seja compatível com o AWS Glue, especifique seus próprios arquivos JAR do Delta Lake usando o parâmetro de trabalho `--extra-jars`. Não inclua `delta` como um valor para o parâmetro de trabalho `--datalake-formats`. Se você usa o AWS Glue 5.0 ou versões superiores, é necessário definir o parâmetro `--user-jars-first true` do trabalho. Para usar a biblioteca do Delta Lake Python nesse caso, você deve especificar os arquivos JAR da biblioteca usando o parâmetro de trabalho `--extra-py-files`. A biblioteca do Python vem empacotada nos arquivos JAR do Delta Lake.
## Exemplo: escrever uma tabela Delta Lake no Amazon S3 e registrá-la no AWS Glue Data Catalog
O script do AWS Glue ETL a seguir demonstra como gravar uma tabela do Delta Lake no Amazon S3 e registrá-la no AWS Glue Data Catalog.
------
#### [ 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(".")
```
------
## Exemplo: ler uma tabela do Delta Lake do Amazon S3 usando o AWS Glue Data Catalog
O script do AWS Glue ETL a seguir lê a tabela do Delta Lake que você criou em [Exemplo: escrever uma tabela Delta Lake no Amazon S3 e registrá-la no AWS Glue Data Catalog](#aws-glue-programming-etl-format-delta-lake-write).
------
#### [ Python ]
Neste exemplo, use o 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 ]
Neste exemplo, use o 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()
}
}
```
------
## Exemplo: inserir um `DataFrame` em uma tabela do Delta Lake no Amazon S3 usando o AWS Glue Data Catalog
Este exemplo insere dados na tabela do Delta Lake que você criou em [Exemplo: escrever uma tabela Delta Lake no Amazon S3 e registrá-la no AWS Glue Data Catalog](#aws-glue-programming-etl-format-delta-lake-write).
**nota**
Este exemplo exige que você defina o parâmetro de trabalho `--enable-glue-datacatalog` para usar o AWS Glue Data Catalog como metastore do Apache Spark Hive. Para saber mais, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
Neste exemplo, use o 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 ]
Neste exemplo, use o 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)
}
}
```
------
## Exemplo: ler uma tabela do Delta Lake do Amazon S3 usando a API do Spark
Este exemplo lê uma tabela do Delta Lake do Amazon S3 usando a API do 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://")
```
------
## Exemplo: gravar uma tabela do Delta Lake no Amazon S3 usando o Spark
Exemplo: grava uma tabela do Delta Lake no Amazon S3 usando o 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://")
```
------
## Exemplo: ler e escrever na tabela do Delta Lake com o controle de permissão do Lake Formation
Este exemplo lê e escreve uma tabela do Delta Lake com o controle de permissão do Lake Formation.
1. Criar uma tabela do Delta e registrá-la no Lake Formation
1. Para habilitar o controle de permissão do Lake Formation, primeiro será necessário registrar o caminho da tabela do Amazon S3 no Lake Formation. Para obter mais informações, consulte [Registering an Amazon S3 location](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html) (Registrar um local do Amazon S3). É possível registrá-lo no console do Lake Formation ou usando a AWS CLI:
```
aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region
```
Depois de registrar uma localização no Amazon S3, qualquer tabela do AWS Glue apontando para a localização (ou qualquer uma de suas localizações secundárias) retornará o valor do parâmetro `IsRegisteredWithLakeFormation` como verdadeiro na chamada `GetTable`.
1. Crie uma tabela do Delta que aponte para o caminho registrado do Amazon S3 por meio do Spark:
**nota**
Os exemplos a seguir foram criados em Python.
```
dataFrame.write \
.format("delta") \
.mode("overwrite") \
.partitionBy("") \
.save("s3://")
```
Depois que os dados forem gravados no Amazon S3, use o crawler do AWS Glue para criar uma nova tabela de catálogo do Delta. Para obter mais informações, consulte [Introdução ao suporte a tabelas nativas do Delta Lake com crawlers do AWS Glue](https://aws.amazon.com/blogs/big-data/introducing-native-delta-lake-table-support-with-aws-glue-crawlers/).
Você também pode criar a tabela manualmente por meio da API `CreateTable` do AWS Glue.
1. Conceda permissão do Lake Formation para o perfil do IAM do trabalho do AWS Glue. Você pode conceder permissões no console do Lake Formation ou usando a AWS CLI. Para obter mais informações, consulte [Conceder permissões de banco de dados usando o console do Lake Formation e o método de recurso nomeado](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html)
1. Leia a tabela do Delta registrada no Lake Formation. O código é o mesmo que o da leitura de uma tabela do Delta não registrada. Observe que o perfil do IAM do trabalho do AWS Glue precisa ter a permissão SELECT para que a leitura seja bem-sucedida.
```
# 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. Escreva em uma tabela do Delta registrada no Lake Formation. O código é o mesmo que o da escrita em uma tabela do Delta não registrada. Observe que o perfil do IAM do trabalho do AWS Glue precisa ter a permissão SUPER para que a escrita seja bem-sucedida.
Por padrão, o AWS Glue usa `Append` como saveMode. Você pode alterá-lo configurando a opção saveMode em `additional_options`. Para obter informações sobre o suporte ao saveMode em tabelas do Delta, consulte [Escrever em uma tabela](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
)
```
# Usar a estrutura Iceberg no AWS Glue
O AWS Glue 3.0 e versões posteriores são compatíveis com a estrutura Apache Iceberg para data lakes. O Iceberg fornece um formato de tabela de alta performance que funciona exatamente como uma tabela SQL. Este tópico aborda os recursos disponíveis para usar dados no AWS Glue ao transportar ou armazenar dados em uma tabela do Iceberg. Para saber mais sobre o Iceberg, consulte a [documentação do Apache Iceberg](https://iceberg.apache.org/docs/latest/).
É possível usar o AWS Glue para realizar operações de leitura e gravação em tabelas do Iceberg no Amazon S3 ou trabalhar com tabelas do Iceberg usando o AWS Glue Data Catalog. Operações adicionais, incluindo inserção e todas as [consultas do Spark](https://iceberg.apache.org/docs/latest/spark-queries/) e [gravações do Spark](https://iceberg.apache.org/docs/latest/spark-writes/) também são compatíveis. Não há suporte à atualização de tabelas do Iceberg.
**nota**
`ALTER TABLE … RENAME TO` não está disponível para o Apache Iceberg 0.13.1 para AWS Glue 3.0.
A tabela a seguir lista a versão do Iceberg incluída em cada versão do AWS Glue.
****
| Versão do AWS Glue | Versão compatível do Iceberg |
| --- | --- |
| 5.1 | 1.10.0 |
| 5,0 | 1.7.1 |
| 4,0 | 1.0.0 |
| 3.0 | 0.13.1 |
Para saber mais sobre as estruturas de data lake compatíveis com o AWS Glue, consulte [Usar estruturas de data lake com trabalhos do AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
## Habilitar a estrutura Iceberg
Para habilitar o Iceberg para AWS Glue, faça as seguintes tarefas:
+ Especifique `iceberg` como um valor para o parâmetro de trabalho `--datalake-formats`. Para obter mais informações, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md).
+ Crie uma chave denominada `--conf` para o trabalho do AWS Glue e defina-a com o seguinte valor. Ou então, é possível definir a configuração a seguir usando `SparkConf` no script. Essas configurações ajudam o Apache Spark a lidar corretamente com as tabelas do 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
```
Se você estiver lendo ou gravando em tabelas do Iceberg registradas no Lake Formation, siga as orientações em [Usar o AWS Glue com AWS Lake Formation para controle de acesso refinado](security-lf-enable.md) no AWS Glue 5.0 e versões posteriores. No AWS Glue 4.0, adicione a configuração a seguir para habilitar o suporte ao Lake Formation.
```
--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true
--conf spark.sql.catalog.glue_catalog.glue.id=
```
Se você usar o AWS Glue 3.0 com o Iceberg 0.13.1, deverá definir as seguintes configurações adicionais para usar o gerenciador de bloqueios do Amazon DynamoDB para garantir a transação atômica. AWS O Glue 4.0 usa o bloqueio positivo por padrão. Para obter mais informações, consulte [Iceberg AWS Integrations](https://iceberg.apache.org/docs/latest/aws/#dynamodb-lock-manager) na documentação oficial do 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 uma versão diferente do Iceberg**
Para usar uma versão do Iceberg que não é compatível com o AWS Glue, especifique seus próprios arquivos JAR do Iceberg usando o parâmetro de trabalho `--extra-jars`. Não inclua `iceberg` como um valor para o parâmetro `--datalake-formats`. Se você usa o AWS Glue 5.0 ou versões superiores, é necessário definir o parâmetro `--user-jars-first true` do trabalho.
**Habilitar criptografia para tabelas do Iceberg**
**nota**
As tabelas do Iceberg têm seus próprios mecanismos para habilitar a criptografia no lado do servidor. Você deve habilitar essa configuração além da configuração de segurança do AWS Glue.
Para habilitar a criptografia do lado do servidor nas tabelas do Iceberg, consulte as orientações na [documentação do Iceberg.](https://iceberg.apache.org/docs/latest/aws/#s3-server-side-encryption)
**Adicionar configuração do Spark para acesso entre regiões do Iceberg**
Para adicionar uma configuração adicional do Spark para acesso à tabela entre regiões do Iceberg com o Catálogo de Dados do AWS Glue e o AWS Lake Formation, siga as etapas abaixo:
1. Crie um [ponto de acesso multirregional](https://docs.aws.amazon.com/AmazonS3/latest/userguide/multi-region-access-point-create-examples.html).
1. Defina as seguintes propriedades do 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
-----
```
## Exemplo: escrever uma tabela do Iceberg no Amazon S3 e registrá-la no AWS Glue Data Catalog
Esse exemplo de script demonstra como escrever uma tabela Iceberg no Amazon S3. O exemplo usa aso [integrações da AWS no Iceberg](https://iceberg.apache.org/docs/latest/aws/) para registrar a tabela no AWS Glue Data Catalog.
------
#### [ 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, é possível escrever uma tabela do Iceberg no Amazon S3 e no catálogo de dados usando os métodos do Spark.
Pré-requisitos: você precisará provisionar um catálogo para uso da biblioteca do Iceberg. Ao usar o catálogo de dados do AWS Glue, o AWS Glue simplifica essa operação. O catálogo de dados do AWS Glue é pré-configurado para ser usado pelas bibliotecas do Spark como `glue_catalog`. As tabelas do catálogo de dados são identificadas por um*databaseName* e um *tableName*. Para obter mais informações sobre o catálogo de dados do AWS Glue, consulte [Descoberta e catalogação de dados no AWS Glue](catalog-and-crawler.md).
Se você não estiver usando o catálogo de dados do AWS Glue, precisará provisionar um catálogo por meio das APIs do Spark. Para obter mais informações, consulte [Configuração do Spark](https://iceberg.apache.org/docs/latest/spark-configuration/) na documentação do Iceberg.
Este exemplo grava uma tabela Iceberg no Amazon S3 e no Data Catalog usando 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()
```
------
## Exemplo: ler uma tabela do Iceberg do Amazon S3 usando o AWS Glue Data Catalog
Este exemplo lê a tabela do Iceberg que você criou em [Exemplo: escrever uma tabela do Iceberg no Amazon S3 e registrá-la no AWS Glue Data Catalog](#aws-glue-programming-etl-format-iceberg-write).
------
#### [ Python ]
Para este exemplo, use o 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 ]
Neste exemplo, use o 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()
}
}
```
------
## Exemplo: inserir um `DataFrame` em um tabela do Iceberg no Amazon S3 usando o AWS Glue Data Catalog
Este exemplo insere dados na tabela do Iceberg que você criou em [Exemplo: escrever uma tabela do Iceberg no Amazon S3 e registrá-la no AWS Glue Data Catalog](#aws-glue-programming-etl-format-iceberg-write).
**nota**
Este exemplo exige que você defina o parâmetro de trabalho `--enable-glue-datacatalog` para usar o AWS Glue Data Catalog como metastore do Apache Spark Hive. Para saber mais, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
Para este exemplo, use o 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 ]
Neste exemplo, use o 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)
}
}
```
------
## Exemplo: ler uma tabela do Iceberg do Amazon S3 usando o Spark
Pré-requisitos: você precisará provisionar um catálogo para uso da biblioteca do Iceberg. Ao usar o catálogo de dados do AWS Glue, o AWS Glue simplifica essa operação. O catálogo de dados do AWS Glue é pré-configurado para ser usado pelas bibliotecas do Spark como `glue_catalog`. As tabelas do catálogo de dados são identificadas por um*databaseName* e um *tableName*. Para obter mais informações sobre o catálogo de dados do AWS Glue, consulte [Descoberta e catalogação de dados no AWS Glue](catalog-and-crawler.md).
Se você não estiver usando o catálogo de dados do AWS Glue, precisará provisionar um catálogo por meio das APIs do Spark. Para obter mais informações, consulte [Configuração do Spark](https://iceberg.apache.org/docs/latest/spark-configuration/) na documentação do Iceberg.
Este exemplo lê uma tabela do Iceberg no Amazon S3 do catálogo de dados usando o 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")
```
------
## Exemplo: ler e escrever na tabela do Iceberg com o controle de permissão do Lake Formation
Este exemplo lê e escreve uma tabela do Iceberg com o controle de permissão do Lake Formation.
**nota**
Este exemplo funciona apenas no AWS Glue 4.0. No AWS Glue 5.0 e versões posteriores, siga as orientações em [Usar o AWS Glue com AWS Lake Formation para controle de acesso refinado](security-lf-enable.md).
1. Crie uma tabela do Iceberg e registrá-la no Lake Formation:
1. Para habilitar o controle de permissão do Lake Formation, primeiro será necessário registrar o caminho da tabela do Amazon S3 no Lake Formation. Para obter mais informações, consulte [Registering an Amazon S3 location](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html) (Registrar um local do Amazon S3). É possível registrá-lo no console do Lake Formation ou usando a AWS CLI:
```
aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region
```
Depois de registrar uma localização no Amazon S3, qualquer tabela do AWS Glue apontando para a localização (ou qualquer uma de suas localizações secundárias) retornará o valor do parâmetro `IsRegisteredWithLakeFormation` como verdadeiro na chamada `GetTable`.
1. Crie uma tabela do Iceberg que aponte para o caminho registrado por meio do Spark:
**nota**
Os exemplos a seguir foram criados em Python.
```
dataFrame.createOrReplaceTempView("tmp_")
query = f"""
CREATE TABLE glue_catalog..
USING iceberg
AS SELECT * FROM tmp_
"""
spark.sql(query)
```
Você também pode criar a tabela manualmente por meio da API `CreateTable` do AWS Glue. Para obter mais informações, consulte [Criar tabelas do Apache Iceberg](https://docs.aws.amazon.com/lake-formation/latest/dg/creating-iceberg-tables.html).
**nota**
No momento, a API `UpdateTable` não oferece suporte ao formato de tabela do Iceberg como entrada para a operação.
1. Conceda permissão do Lake Formation para o perfil do IAM do trabalho. É possível conceder permissões no console do Lake Formation ou usando a AWS CLI. Para obter mais informações, consulte: https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html
1. Leia uma tabela do Iceberg registrada no Lake Formation. O código é o mesmo que o da leitura de uma tabela do Iceberg não registrada. Observe que o perfil do IAM do trabalho do AWS Glue precisa ter a permissão SELECT para que a leitura seja bem-sucedida.
```
# 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. Escreva em uma tabela do Iceberg registrada no Lake Formation. O código é o mesmo que o da escrita em uma tabela do Iceberg não registrada. Observe que o perfil do IAM do trabalho do AWS Glue precisa ter a permissão SUPER para que a escrita seja bem-sucedida.
```
glueContext.write_data_frame.from_catalog(
frame=dataFrame,
database="",
table_name="",
additional_options=additional_options
)
```