As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Usar um cluster com o Iceberg
Esta seção inclui informações sobre como usar o Iceberg com Spark, Trino, Flink e Hive.
# Usar um cluster do Iceberg com o Spark
A partir da versão 6.5.0 do Amazon EMR, é possível usar o Iceberg com o cluster do Spark sem a necessidade de incluir ações de bootstrap. Nas versões 6.4.0 e anteriores do Amazon EMR, é possível usar uma ação de bootstrap para pré-instalar todas as dependências necessárias.
Neste tutorial, você usa o AWS CLI para trabalhar com o Iceberg em um cluster do Amazon EMR Spark. Para usar o console para criar um cluster com o Iceberg instalado, siga as etapas em [Criar um data lake no Apache Iceberg usando o Amazon Athena, o Amazon EMR e o AWS Glue](https://aws.amazon.com/blogs//big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
## Criar um cluster do Iceberg
Você pode criar um cluster com o Iceberg instalado usando o Console de gerenciamento da AWS, o AWS CLI ou a API do Amazon EMR. Neste tutorial, você usa o AWS CLI para trabalhar com o Iceberg em um cluster do Amazon EMR. Para usar o console para criar um cluster com o Iceberg instalado, siga as etapas em [Criar um data lake no Apache Iceberg usando o Amazon Athena, o Amazon EMR e o AWS Glue](https://aws.amazon.com/blogs//big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
Para usar o Iceberg no Amazon EMR com AWS CLI o, primeiro crie um cluster com as etapas a seguir. Para obter informações sobre como especificar a classificação do Iceberg usando o AWS CLI, consulte [Forneça uma configuração usando o AWS CLI ao criar um cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) ou. [Fornecer uma configuração usando o SDK do Java ao criar um cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk)
1. Crie um arquivo `configurations.json`, com o seguinte conteúdo:
```
[{
"Classification":"iceberg-defaults",
"Properties":{"iceberg.enabled":"true"}
}]
```
1. Em seguida, crie um cluster com a configuração a seguir. Substitua o exemplo do caminho do bucket do Amazon S3 e o ID da sub-rede pelos seus.
```
aws emr create-cluster --release-label emr-6.5.0 \
--applications Name=Spark \
--configurations file://configurations.json \
--region us-east-1 \
--name My_Spark_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket/ \
--instance-type m5.xlarge \
--instance-count 2 \
--service-role EMR_DefaultRole_V2 \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,SubnetId=subnet-1234567890abcdef0
```
Como alternativa, é possível criar um cluster do Amazon EMR que inclua a aplicação do Spark e o arquivo `/usr/share/aws/iceberg/lib/iceberg-spark3-runtime.jar` como uma dependência do JAR em um trabalho do Spark. Para obter mais informações, consulte [Submitting Applications](https://spark.apache.org/docs/latest/submitting-applications.html#submitting-applications).
Para incluir o jar como uma dependência em um trabalho do Spark, adicione a seguinte propriedade de configuração à aplicação do Spark:
```
--conf "spark.jars=/usr/share/aws/iceberg/lib/iceberg-spark3-runtime.jar"
```
Para obter mais informações sobre as dependências de trabalho do Spark, consulte [Gerenciamento de dependências](https://spark.apache.org/docs/latest/running-on-kubernetes.html#dependency-management) no documento do Apache Spark [Executar o Spark no Kubernetes](https://spark.apache.org/docs/latest/running-on-kubernetes.html).
## Inicializar uma sessão do Spark para Iceberg
Os exemplos a seguir demonstram como iniciar o shell interativo do Spark, usar o envio do Spark ou usar os Cadernos do Amazon EMR para trabalhar com o Iceberg no Amazon EMR.
------
#### [ spark-shell ]
1. Conecte-se ao nó principal usando SSH. Para obter mais informações, consulte [Conectar-se ao nó principal usando SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) no *Guia de gerenciamento do Amazon EMR*.
1. Digite o seguinte comando para iniciar o shell do Spark. Para usar a PySpark concha, `spark-shell` substitua por`pyspark`.
```
spark-shell \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket/prefix/
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
------
#### [ spark-submit ]
1. Conecte-se ao nó principal usando SSH. Para obter mais informações, consulte [Conectar-se ao nó principal usando SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) no *Guia de gerenciamento do Amazon EMR*.
1. Insira o comando a seguir para iniciar a sessão do Spark no Iceberg.
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
------
#### [ EMR Studio notebooks ]
Para inicializar uma sessão do Spark usando Cadernos do EMR Studio, configure a sessão do Spark usando o comando mágico `%%configure` no Caderno do Amazon EMR, como no exemplo a seguir. Para obter mais informações, consulte [Use EMR Notebooks magics](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-magics.html#emr-magics) no *Guia de gerenciamento do Amazon EMR*.
```
%%configure -f{
"conf":{
"spark.sql.catalog.my_catalog":"org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.my_catalog.type":"glue",
"spark.sql.catalog.my_catalog.warehouse":"s3://amzn-s3-demo-bucket1/prefix/",
"spark.sql.defaultCatalog":"my_catalog",
"spark.sql.extensions":"org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions"
}
}
```
------
#### [ CLI ]
Para inicializar um cluster do Spark usando a CLI e definir todas as configurações padrão da sessão do Spark Iceberg, execute o exemplo a seguir. Para obter mais informações sobre como especificar uma classificação de configuração usando a AWS CLI API do Amazon EMR, [consulte](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps.html) Configurar aplicativos.
```
[
{
"Classification": "spark-defaults",
"Properties": {
"spark.sql.catalog.my_catalog":"org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.my_catalog.type":"glue",
"spark.sql.catalog.my_catalog.warehouse":"s3://amzn-s3-demo-bucket1/prefix/",
"spark.sql.defaultCatalog":"my_catalog",
"spark.sql.extensions":"org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions"
}
}
]
```
------
## Gravar em uma tabela do Iceberg
O exemplo a seguir mostra como criar um DataFrame e gravá-lo como um conjunto de dados do Iceberg. Os exemplos demonstram como trabalhar com conjuntos de dados usando o shell do Spark durante a conexão com o nó principal usando SSH como usuário padrão do hadoop.
**nota**
Para colar exemplos de código no shell do Spark, digite `:paste` no prompt, cole o exemplo e pressione `CTRL+D`.
------
#### [ PySpark ]
O Spark inclui um shell baseado em Python, `pyspark`, que você pode usar para gerar protótipos de programas Spark escritos em Python. Invoque `pyspark` no nó principal.
```
## Create a DataFrame.
data = spark.createDataFrame([
("100", "2015-01-01", "2015-01-01T13:51:39.340396Z"),
("101", "2015-01-01", "2015-01-01T12:14:58.597216Z"),
("102", "2015-01-01", "2015-01-01T13:51:40.417052Z"),
("103", "2015-01-01", "2015-01-01T13:51:40.519832Z")
],["id", "creation_date", "last_update_time"])
## Write a DataFrame as a Iceberg dataset to the Amazon S3 location.
spark.sql("""CREATE TABLE IF NOT EXISTS dev.db.iceberg_table (id string,
creation_date string,
last_update_time string)
USING iceberg
location 's3://amzn-s3-demo-bucket/example-prefix/db/iceberg_table'""")
data.writeTo("dev.db.iceberg_table").append()
```
------
#### [ Scala ]
```
import org.apache.spark.sql.SaveMode
import org.apache.spark.sql.functions._
// Create a DataFrame.
val data = Seq(
("100", "2015-01-01", "2015-01-01T13:51:39.340396Z"),
("101", "2015-01-01", "2015-01-01T12:14:58.597216Z"),
("102", "2015-01-01", "2015-01-01T13:51:40.417052Z"),
("103", "2015-01-01", "2015-01-01T13:51:40.519832Z")
).toDF("id", "creation_date", "last_update_time")
// Write a DataFrame as a Iceberg dataset to the Amazon S3 location.
spark.sql("""CREATE TABLE IF NOT EXISTS dev.db.iceberg_table (id string,
creation_date string,
last_update_time string)
USING iceberg
location 's3://amzn-s3-demo-bucket/example-prefix/db/iceberg_table'""")
data.writeTo("dev.db.iceberg_table").append()
```
------
## Ler em uma tabela do Iceberg
------
#### [ PySpark ]
```
df = spark.read.format("iceberg").load("dev.db.iceberg_table")
df.show()
```
------
#### [ Scala ]
```
val df = spark.read.format("iceberg").load("dev.db.iceberg_table")
df.show()
```
------
#### [ Spark SQL ]
```
SELECT * from dev.db.iceberg_table LIMIT 10
```
------
## Usando o AWS Glue Data Catalog com o Spark Iceberg
Você pode se conectar ao AWS Glue Data Catalog a partir do Spark Iceberg. Esta seção mostra diferentes comandos para conexão.
### Conecte-se ao catálogo padrão do AWS Glue em sua região padrão
Este exemplo mostra como se conectar usando o tipo de catálogo do Glue. Se você não especificar um ID do catálogo, ele usará o padrão:
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
### Conecte-se a um catálogo do AWS Glue com um ID de catálogo específico
Este exemplo mostra como se conectar usando um ID de catálogo:
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.catalog.my_catalog.glue.id=AWS Glue catalog ID \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
Esse comando pode ser usado para se conectar a um catálogo AWS Glue em uma conta diferente, a um catálogo RMS ou a um catálogo federado.
## Usar o Iceberg REST Catalog (IRC) com o Spark Iceberg
As seções a seguir detalham como configurar a integração do Iceberg com um catálogo.
### Conecte-se ao AWS endpoint IRC do Glue Data Catalog
Veja a seguir um exemplo que demonstra um comando `spark-submit` para uso do Iceberg REST:
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=glue catalog ID \
--conf spark.sql.catalog.my_catalog.type=rest \
--conf spark.sql.catalog.my_catalog.uri=glue endpoint URI/iceberg \
--conf spark.sql.catalog.my_catalog.rest.sigv4-enabled=true \
--conf spark.sql.catalog.my_catalog.rest.signing-name=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
Para utilizá-lo em um cluster habilitado para perfil de runtime, são necessárias as seguintes configurações adicionais do Spark:
```
"spark.hadoop.fs.s3.credentialsResolverClass": "software.amazon.glue.GlueTableCredentialsResolver",
"spark.hadoop.catalog-impl": "org.apache.iceberg.aws.glue.GlueCatalog",
"spark.hadoop.glue.id": glue catalog ID
"spark.hadoop.glue.endpoint": "glue endpoint"
```
Para ver a lista de URLs de endpoints do AWS Glue para cada região, consulte [Pontos de extremidade e AWS cotas do Glue](https://docs.aws.amazon.com/general/latest/gr/glue.html).
### Conectar-se a um endpoint IRC arbitrário
A seguir, é apresentado um exemplo de comando `spark-submit` para usar um endpoint IRC:
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=warehouse name \
--conf spark.sql.catalog.my_catalog.type=rest \
--conf spark.sql.catalog.my_catalog.uri=your rest endpoint \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
## Diferenças de configuração quando você usa o Iceberg versus SparkCatalog SparkSessionCatalog
O Iceberg disponibiliza duas maneiras de criar catálogos do Spark Iceberg. Você pode definir a configuração do Spark como `SparkCatalog` ou como `SparkSessionCatalog`.
### Usando o Iceberg SparkCatalog
A seguir, é mostrado o comando para usar **SparkCatalog**como catálogo do Spark Iceberg:
```
spark-shell \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog
```
Considerações sobre essa abordagem:
+ Você pode acessar as tabelas do Iceberg, mas nenhuma outra tabela.
+ O nome do catálogo não pode ser **spark\$1catalog**. Esse é o nome do catálogo inicial no Spark. Ele sempre se conecta a um metastore do Hive. É o catálogo padrão no Spark, a menos que o usuário o substitua usando `spark.sql.defaultCatalog`.
+ Você pode definir o `spark.sql.defaultCatalog` como o nome do seu catálogo para torná-lo o catálogo padrão.
### Usando o Iceberg SparkSessionCatalog
A seguir, é mostrado o comando para usar **SparkSessionCatalog**como catálogo do Spark Iceberg:
```
spark-shell \
--conf spark.sql.catalog.spark_catalog=org.apache.iceberg.spark.SparkSessionCatalog \
--conf spark.sql.catalog.spark_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.spark_catalog.type=glue
```
Considerações sobre essa abordagem:
+ Se uma tabela não for encontrada como uma tabela do Iceberg, o Spark tentará ver se é uma tabela no metastore do Hive. Consulte [Usando o AWS Glue Data Catalog como catálogo do Hive](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-hive-metastore-glue.html) para obter mais informações.
+ O nome do catálogo não deve ser **spark\$1catalog**.
## Usar extensões do Iceberg Spark
O Iceberg oferece a extensão Spark `org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions` que os usuários podem configurar por meio da configuração de extensões do Spark `spark.sql.extensions`. As extensões habilitam recursos essenciais do Iceberg, como DELETE, UPDATE e MERGE em nível de linha, instruções e procedimentos da linguagem de definição de dados Spark específicos do Iceberg, como compactação, expiração de snapshot, ramificação e marcação, entre outros. Consulte o seguinte para obter mais detalhes:
+ Extensões de gravação do Iceberg Spark: [Gravações do Spark](https://iceberg.apache.org/docs/nightly/spark-writes/)
+ Extensões DDL do Iceberg Spark: [extensões ALTER TABLE SQL](https://iceberg.apache.org/docs/nightly/spark-ddl/#alter-table-sql-extensions/)
+ Extensões do procedimento Iceberg Spark: [Procedimentos do Spark](https://iceberg.apache.org/docs/nightly/spark-ddl/#alter-table-sql-extensions/)
## Considerações sobre o uso do Iceberg com o Spark
+ Por padrão, o Amazon EMR 6.5.0 não é compatível com a execução do Iceberg no Amazon EMR no EKS. Uma imagem personalizada do Amazon EMR 6.5.0 está disponível para que você possa passar `--jars local:///usr/share/aws/iceberg/lib/iceberg-spark3-runtime.jar` como parâmetro `spark-submit` para criar tabelas do Iceberg no Amazon EMR no EKS. Para obter mais informações, consulte [Enviar uma workload do Spark no Amazon EMR usando uma imagem personalizada](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-steps.html#docker-custom-images-submit) no *Catálogo de desenvolvimento do Amazon EMR no EKS*. Você também pode entrar em contato com Suporte para obter assistência. Desde o Amazon EMR 6.6.0, o Iceberg é compatível com o Amazon EMR no EKS.
+ Ao usar o AWS Glue como um catálogo para o Iceberg, certifique-se de que o banco de dados no qual você está criando uma tabela exista no AWS Glue. Se você estiver usando serviços como AWS Lake Formation e não conseguir carregar o catálogo, verifique se você tem acesso adequado ao serviço para executar o comando.
+ Se você usa o Iceberg SparkSessionCatalog, conforme descrito em[Diferenças de configuração quando você usa o Iceberg versus SparkCatalog SparkSessionCatalog](#emr-iceberg-spark-catalog), você deve seguir as etapas de configuração descritas em [Configurar o catálogo de dados do AWS Glue como metastore do Apache Hive](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-hive-metastore-glue.html), além de definir as configurações do catálogo de dados do Spark Iceberg Glue. AWS
# Usar um cluster do Iceberg com o Trino
Desde a versão 6.6.0 do Amazon EMR, você pode usar o Iceberg com o cluster do Trino.
Neste tutorial, você usa o AWS CLI para trabalhar com o Iceberg em um cluster Trino do Amazon EMR. Para usar o console para criar um cluster com o Iceberg instalado, siga as etapas em [Criar um data lake no Apache Iceberg usando o Amazon Athena, o Amazon EMR e o AWS Glue](https://aws.amazon.com/blogs//big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
## Criar um cluster do Iceberg
Para usar o Iceberg no Amazon EMR com AWS CLI o, primeiro crie um cluster com as etapas a seguir. Para obter informações sobre como especificar a classificação do Iceberg usando o AWS CLI, consulte [Forneça uma configuração usando o AWS CLI ao criar um cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) ou. [Fornecer uma configuração usando o SDK do Java ao criar um cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk)
1. Crie um arquivo `configurations.json` com o seguinte conteúdo. Por exemplo, se você quiser usar a metastore do Hive como catálogo, o arquivo deverá ter o conteúdo a seguir.
```
[
{
"Classification": "trino-connector-iceberg",
"Properties": {
"connector.name": "iceberg",
"hive.metastore.uri": "thrift://localhost:9083"
}
}
]
```
Se você quiser usar o AWS Glue Data Catalog como sua loja, seu arquivo deve ter o seguinte conteúdo.
```
[
{
"Classification": "trino-connector-iceberg",
"Properties": {
"connector.name": "iceberg",
"iceberg.catalog.type": "glue"
}
}
]
```
A partir do Amazon EMR 7.7.0, inclua a propriedade *fs.native-s3.enabled=true*
```
[
{
"Classification": "trino-connector-iceberg",
"Properties": {
"connector.name": "iceberg",
"iceberg.catalog.type": "glue",
"fs.native-s3.enabled": "true"
}
}
]
```
1. Crie um cluster com a seguinte configuração, substituindo o caminho do bucket do S3 e do nome da chave do exemplo pelos seus próprios.
```
aws emr create-cluster --release-label emr-6.7.0 \
--applications Name=Trino \
--region us-east-1 \
--name My_Trino_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket \
--configurations file://configurations.json \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=c3.4xlarge InstanceGroupType=CORE,InstanceCount=3,InstanceType=c3.4xlarge \
--use-default-roles \
--ec2-attributes KeyName=
```
## Inicializar uma sessão do Trino para Iceberg
Para inicializar uma sessão no Trino, execute o comando a seguir.
```
trino-cli --catalog iceberg
```
## Gravar em uma tabela do Iceberg
Crie e grave na tabela com os comandos SQL a seguir.
```
trino> SHOW SCHEMAS;
trino> CREATE TABLE default.iceberg_table (
id int,
data varchar,
category varchar)
WITH (
format = 'PARQUET',
partitioning = ARRAY['category', 'bucket(id, 16)'],
location = 's3://amzn-s3-demo-bucket/')
trino> INSERT INTO default.iceberg_table VALUES (1,'a','c1'), (2,'b','c2'), (3,'c','c3');
```
## Ler em uma tabela do Iceberg
Para ler a tabela do Iceberg, execute o comando a seguir.
```
trino> SELECT * from default.iceberg_table;
```
## Considerações sobre o uso do Iceberg com o Trino
+ O Amazon EMR 6.5 não é nativamente compatível com o catálogo do Iceberg com o Trino. O Trino precisa do Iceberg v0.11, por isso recomendamos iniciar um cluster do Amazon EMR para Trino separado do cluster do Spark e incluir o Iceberg v0.11 neste cluster.
+ Ao usar o AWS Glue como um catálogo para o Iceberg, certifique-se de que o banco de dados no qual você está criando uma tabela exista no AWS Glue. Se você estiver usando serviços como AWS Lake Formation e não conseguir carregar o catálogo, verifique se você tem acesso adequado ao serviço para executar o comando.
+ A integração do Iceberg no Glue não funciona com o catálogo do Redshift Managed Storage.
# Usar um cluster do Iceberg com o Flink
Desde a versão 6.9.0 do Amazon EMR, você pode usar o Iceberg com um cluster do Flink sem as etapas de configuração necessárias ao usar a integração Iceberg-Flink de código aberto.
## Criar um cluster no Iceberg
É possível criar um cluster com o Iceberg instalado usando o Console de gerenciamento da AWS, a AWS CLI ou a API do Amazon EMR. Neste tutorial, você usa o AWS CLI para trabalhar com o Iceberg em um cluster do Amazon EMR. Para usar o console para criar um cluster com o Iceberg instalado, siga as etapas em [Criar um data lake no Apache Iceberg usando o Amazon Athena, o Amazon EMR e o AWS Glue](https://aws.amazon.com/blogs/big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
Para usar o Iceberg no Amazon EMR com AWS CLI o, primeiro crie um cluster com as etapas a seguir. Para obter informações sobre como especificar a classificação do Iceberg usando o AWS CLI, consulte [Forneça uma configuração usando o AWS CLI ao criar um cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) ou. [Fornecer uma configuração usando o SDK do Java ao criar um cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk) Crie um arquivo denominado `configurations.json` com o seguinte conteúdo:
```
[{
"Classification":"iceberg-defaults",
"Properties":{"iceberg.enabled":"true"}
}]
```
Em seguida, crie um cluster com a configuração a seguir, substituindo o exemplo de caminho do bucket do Amazon S3 e o ID da sub-rede pelos seus próprios valores:
```
aws emr create-cluster --release-label emr-6.9.0 \
--applications Name=Flink \
--configurations file://iceberg_configurations.json \
--region us-east-1 \
--name My_flink_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket/ \
--instance-type m5.xlarge \
--instance-count 2 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,SubnetId=subnet-1234567890abcdef
```
Como alternativa, é possível criar um cluster do Amazon EMR 6.9.0 contendo uma aplicação do Flink e usar o arquivo `/usr/share/aws/iceberg/lib/iceberg-flink-runtime.jar` como uma dependência do JAR em um trabalho do Flink.
## Usar o clinte SQL no Flink
O script do cliente SQL está localizado em `/usr/lib/flink/bin`. Você pode executar o script com o seguinte comando:
```
flink-yarn-session -d # starting the Flink YARN Session in detached mode
./sql-client.sh
```
Isso inicia um shell SQL no Flink.
## Exemplos do Flink
### Criar uma tabela no Iceberg
**SQL no Flink**
```
CREATE CATALOG glue_catalog WITH (
'type'='iceberg',
'warehouse'='',
'catalog-impl'='org.apache.iceberg.aws.glue.GlueCatalog',
'io-impl'='org.apache.iceberg.aws.s3.S3FileIO'
);
USE CATALOG glue_catalog;
CREATE DATABASE IF NOT EXISTS ;
USE ;
CREATE TABLE IF NOT EXISTS `glue_catalog`.``.`sample` (id int, data string);
```
**API de tabela**
```
EnvironmentSettings settings =
EnvironmentSettings.newInstance().inBatchMode().build();
TableEnvironment tEnv = TableEnvironment.create(settings);
String warehouse = "";
String db = "";
tEnv.executeSql(
"CREATE CATALOG glue_catalog WITH (\n"
+ " 'type'='iceberg',\n"
+ " 'warehouse'='"
+ warehouse
+ "',\n"
+ " 'catalog-impl'='org.apache.iceberg.aws.glue.GlueCatalog',\n"
+ " 'io-impl'='org.apache.iceberg.aws.s3.S3FileIO'\n"
+ " );");
tEnv.executeSql("USE CATALOG glue_catalog;");
tEnv.executeSql("CREATE DATABASE IF NOT EXISTS " + db + ";");
tEnv.executeSql("USE " + db + ";");
tEnv.executeSql(
"CREATE TABLE `glue_catalog`.`" + db + "`.`sample` (id bigint, data string);");
```
### Gravar em uma tabela do Iceberg
**SQL no Flink**
```
INSERT INTO `glue_catalog`.``.`sample` values (1, 'a'),(2,'b'),(3,'c');
```
**API de tabela**
```
tEnv.executeSql(
"INSERT INTO `glue_catalog`.`"
+ db
+ "`.`sample` values (1, 'a'),(2,'b'),(3,'c');");
```
**API de fluxo de dados**
```
final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
final StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);
String db = "";
String warehouse = "";
GenericRowData rowData1 = new GenericRowData(2);
rowData1.setField(0, 1L);
rowData1.setField(1, StringData.fromString("a"));
DataStream input = env.fromElements(rowData1);
Map props = new HashMap<();
props.put("type", "iceberg");
props.put("warehouse", warehouse);
props.put("io-impl", "org.apache.iceberg.aws.s3.S3FileIO");
CatalogLoader glueCatlogLoader =
CatalogLoader.custom(
"glue",
props,
new Configuration(),
"org.apache.iceberg.aws.glue.GlueCatalog");
TableLoader tableLoader =
TableLoader.fromCatalog(glueCatlogLoader, TableIdentifier.of(db, "sample"));
DataStreamSink dataStreamSink =
FlinkSink.forRowData(input).tableLoader(tableLoader).append();
env.execute("Datastream Write");
```
### Ler em uma tabela do Iceberg
**SQL no Flink**
```
SELECT * FROM `glue_catalog`.``.`sample`;
```
**API de tabela**
```
Table result = tEnv.sqlQuery("select * from `glue_catalog`.`" + db + "`.`sample`;");
```
**API de fluxo de dados**
```
final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
final StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);
String db = "";
String warehouse = "";
Map props = new HashMap<>();
props.put("type", "iceberg");
props.put("warehouse", warehouse);
props.put("io-impl", "org.apache.iceberg.aws.s3.S3FileIO");
CatalogLoader glueCatlogLoader =
CatalogLoader.custom(
"glue",
props,
new Configuration(),
"org.apache.iceberg.aws.glue.GlueCatalog");
TableLoader tableLoader =
TableLoader.fromCatalog(glueCatlogLoader, TableIdentifier.of(db, "sample"));
DataStream batch =
FlinkSource.forRowData().env(env).tableLoader(tableLoader).streaming(false).build();
batch.print().name("print-sink");
```
## Usar o catálogo do Hive
Certifique-se de que as dependências do Flink e do Hive sejam resolvidas conforme descrito em [Configurar o Flink com o Hive Metastore e o Catálogo do Glue](flink-configure.md#flink-configure-hive).
## Executar um trabalho do Flink
Uma forma de enviar um trabalho ao Flink é usar uma sessão do YARN do Flink por trabalho. Isso pode ser iniciado com o seguinte comando:
```
sudo flink run -m yarn-cluster -p 4 -yjm 1024m -ytm 4096m $JAR_FILE_NAME
```
## Considerações sobre o uso do Iceberg com o Flink
+ Ao usar o AWS Glue como um catálogo para o Iceberg, certifique-se de que o banco de dados no qual você está criando uma tabela exista no AWS Glue. Se você estiver usando serviços como AWS Lake Formation e não conseguir carregar o catálogo, verifique se você tem acesso adequado ao serviço para executar o comando.
+ A integração do Iceberg no Glue não funciona com o catálogo do Redshift Managed Storage.
# Usar um cluster do Iceberg com o Hive
Com as versões 6.9.0 e posteriores do Amazon EMR, você pode usar o Iceberg com um cluster do Hive sem precisar executar as etapas de configuração necessárias para a integração do IcebergHive de código aberto. Para as versões 6.8.0 e anteriores do Amazon EMR, você pode usar uma ação de bootstrap para instalar o jar `iceberg-hive-runtime` e configurar o suporte do Hive para Iceberg.
O Amazon EMR 6.9.0 inclui todos os atributos para a [integração do Hive 3.1.3 com o Iceberg 0.14.1](https://iceberg.apache.org/releases/#0140-release) e também inclui atributos adicionais do Amazon EMR, como seleção automática de mecanismos de execução compatíveis em runtime (Amazon EMR no EKS 6.9.0).
## Criar um cluster do Iceberg
Você pode criar um cluster com o Iceberg instalado usando o Console de gerenciamento da AWS, o AWS CLI ou a API do Amazon EMR. Neste tutorial, você usa o AWS CLI para trabalhar com o Iceberg em um cluster do Amazon EMR. Para usar o console para criar um cluster com o Iceberg instalado, siga as etapas em [Criar um data lake no Iceberg usando o Amazon Athena, o Amazon EMR e o AWS Glue](https://aws.amazon.com/blogs/big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
Para usar o Iceberg no Amazon EMR com AWS CLI o, primeiro crie um cluster usando as etapas abaixo. Para obter informações sobre como especificar a classificação Iceberg usando o AWS CLI ou o Java SDK, consulte ou. [Forneça uma configuração usando o AWS CLI ao criar um cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) [Fornecer uma configuração usando o SDK do Java ao criar um cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk) Crie um arquivo chamado `configurations.json` com o seguinte conteúdo:
```
[{
"Classification":"iceberg-defaults",
"Properties":{"iceberg.enabled":"true"}
}]
```
Em seguida, crie um cluster com a configuração a seguir, substituindo o exemplo de caminho do bucket do Amazon S3 e o ID da sub-rede pelos seus próprios:
```
aws emr create-cluster --release-label emr-6.9.0 \
--applications Name=Hive \
--configurations file://iceberg_configurations.json \
--region us-east-1 \
--name My_hive_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket/ \
--instance-type m5.xlarge \
--instance-count 2 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,SubnetId=subnet-1234567890abcdef
```
Um cluster do Iceberg no Hive faz o seguinte:
+ Carrega o jar de runtime do Hive no Iceberg no Hive e habilita a configuração relacionada ao Iceberg para o mecanismo do Hive.
+ Permite a seleção dinâmica do mecanismo de execução do Hive no Amazon EMR para impedir que os usuários configurem um mecanismo de execução compatível com o Iceberg.
**nota**
Atualmente, os clusters Hive Iceberg não são compatíveis com o AWS Glue Data Catalog. O catálogo padrão do Iceberg é `HiveCatalog`, que corresponde ao metastore configurado para o ambiente Hive. Para obter mais informações sobre gerenciamento de catálogos, consulte [Usando HCatalog](https://cwiki.apache.org/confluence/display/Hive/HCatalog+UsingHCat#HCatalogUsingHCat-UsingHCatalog) na documentação do [Apache Hive.](https://cwiki.apache.org/confluence/display/HIVE)
## Suporte a recursos
O Amazon EMR versão 6.9.0 é compatível com o Hive 3.1.3 e o Iceberg 0.14.1. O suporte a atributos é limitado aos atributos compatíveis com o Iceberg para o Hive 3.1.2 e 3.1.3. Os seguintes comandos são compatíveis:
+ Com as versões 6.9.0 a 6.12.x do Amazon EMR, você deve incluir o jar `libfb303` no diretório `auxlib` do Hive. Use o seguinte comando para instalar:
```
sudo /usr/bin/ln -sf /usr/lib/hive/lib/libfb303-*.jar /usr/lib/hive/auxlib/libfb303.jar
```
Com as versões 6.13 e posteriores do Amazon EMR, o jar `libfb303` é automaticamente vinculado ao diretório `auxlib` do Hive.
+ **Criar uma tabela**
+ **Tabela não particionada**: as tabelas externas no Hive podem ser criadas ao ser fornecido o manipulador de armazenamento da seguinte forma:
```
CREATE EXTERNAL TABLE x (i int) STORED BY 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler'
```
+ **Tabela particionada**: as tabelas externas particionadas no Hive podem ser criadas da seguinte forma:
```
CREATE EXTERNAL TABLE x (i int) PARTITIONED BY (j int) STORED BY 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler'
```
**nota**
O formato de `STORED AS` arquivo do não ORC/AVRO/PARQUET é suportado no Hive 3. A opção padrão e única é Parquet.
+ **Descartar uma tabela**: o comando `DROP TABLE` é usado para descartar tabelas, como no exemplo a seguir:
```
DROP TABLE [IF EXISTS] table_name [PURGE];
```
+ **Ler uma tabela**: as instruções `SELECT` podem ser usadas para ler tabelas do Iceberg no Hive, como no exemplo a seguir. Os mecanismos de execução compatíveis são MR e Tez.
```
SELECT * FROM table_name
```
[Para obter informações sobre a sintaxe de seleção do Hive, consulte LanguageManual Selecionar.](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Select) Para obter informações sobre instruções selecionadas com tabelas do Iceberg no Hive, consulte [Selecionar Apache Iceberg](https://iceberg.apache.org/docs/latest/hive/#select).
+ **Inserir em uma tabela**: a instrução `INSERT INTO` do HiveQL funciona em tabelas do Iceberg compatíveis somente com o mecanismo de execução do Map Reduce. Os usuários do Amazon EMR não precisam definir explicitamente o mecanismo de execução porque o Hive no Amazon EMR seleciona o mecanismo para tabelas do Iceberg no runtime.
+ **Inserção de tabela única**: exemplo:
```
INSERT INTO table_name VALUES ('a', 1);
INSERT INTO table_name SELECT...;
```
+ **Inserção de várias tabelas**: a inserção de várias tabelas não atômicas em instruções é compatível. Exemplo:
```
FROM source
INSERT INTO table_1 SELECT a, b
INSERT INTO table_2 SELECT c,d;
```
A partir do Amazon EMR 7.3.0, o Hive with Iceberg oferece suporte ao AWS Glue Data Catalog como metastore. Para usar o AWS Glue Data Catalog como metastore, defina a seguinte propriedade.
```
SET iceberg.catalog..catalog-impl=org.apache.iceberg.aws.glue.GlueCatalog;
```
Opcionalmente, você também pode definir a propriedade a seguir.
```
SET iceberg.catalog..type=glue;
```
Você pode então criar uma tabela usando o exemplo a seguir.
```
CREATE EXTERNAL TABLE table_name (col1 type1, col2 type2,..)
ROW FORMAT SERDE 'org.apache.iceberg.mr.hive.HiveIcebergSerDe'
STORED BY 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler'
location ''
TBLPROPERTIES ('table_type'='iceberg', 'iceberg.catalog'='');
```
## Considerações sobre o uso do Iceberg com o Hive
+ O Iceberg é compatível com os seguintes tipos de consulta:
+ Create table
+ Drop table
+ Inserir na tabela
+ Ler a tabela
+ Somente o mecanismo de execução MR (MapReduce) é suportado para operações de DML (linguagem de manipulação de dados), e o MR está obsoleto no Hive 3.1.3.
+ Para o Amazon EMR anterior à 7.3.0, o AWS Glue Data Catalog atualmente não é compatível com o Iceberg with Hive.
+ O tratamento de erros não é suficientemente robusto. Em casos de configuração incorreta, as inserções nas consultas podem ser concluídas com êxito. No entanto, a falha na atualização dos metadados pode resultar em perda de dados.
+ A integração do Iceberg no Glue não funciona com o catálogo do Redshift Managed Storage.