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á.
# Integre o Amazon EMR com AWS Lake Formation
AWS Lake Formation é um serviço gerenciado que ajuda você a descobrir, catalogar, limpar e proteger dados em um data lake do Amazon Simple Storage Service (S3). O Lake Formation fornece acesso refinado no nível da coluna, linha ou célula aos bancos de dados e tabelas no AWS Glue Data Catalog. Para ter mais informações, consulte [O que é o AWS Lake Formation?](https://docs.aws.amazon.com/lake-formation/latest/dg/what-is-lake-formation.html)
Com o Amazon EMR 6.7.0 e versões posteriores, você pode aplicar o controle de acesso baseado no Lake Formation a trabalhos do Spark, Hive e Presto enviados aos clusters do Amazon EMR. Para se integrar ao Lake Formation, é necessário criar um cluster do EMR com um *perfil de runtime*. O perfil de runtime é um perfil do AWS Identity and Access Management (IAM) que você associa a trabalhos ou consultas do Amazon EMR. Em seguida, o Amazon EMR usa essa função para acessar AWS recursos. Para obter mais informações, consulte [Perfis de runtime para etapas ao Amazon EMR](emr-steps-runtime-roles.md).
## Como o Amazon EMR funciona com o Lake Formation
Depois de integrar o Amazon EMR com o Lake Formation, você pode executar consultas nos clusters do Amazon EMR com a [`Step`API](https://docs.aws.amazon.com/emr/latest/APIReference/API_Step.html) ou com o AI Studio. SageMaker Em seguida, o Lake Formation fornecerá acesso aos dados por meio de credenciais temporárias para o Amazon EMR. Esse processo chamado de fornecimento de credenciais. Para ter mais informações, consulte [O que é o AWS Lake Formation?](https://docs.aws.amazon.com/lake-formation/latest/dg/what-is-lake-formation.html)
Veja a seguir uma visão geral de alto nível sobre como o Amazon EMR obtém acesso aos dados protegidos pelas políticas de segurança do Lake Formation.
![\[Como o Amazon EMR acessa dados protegidos por meio de políticas de segurança do Lake Formation\]](http://docs.aws.amazon.com/pt_br/emr/latest/ManagementGuide/images/lf-emr-security.png)
1. O usuário envia uma consulta do Amazon EMR para obter dados no Lake Formation.
1. O Amazon EMR solicita credenciais temporárias do Lake Formation para dar acesso aos dados para o usuário.
1. O Lake Formation retorna credenciais temporárias.
1. O Amazon EMR envia a solicitação de consulta para recuperar dados do Amazon S3.
1. O Amazon EMR recebe os dados do Amazon S3, filtra-os e retorna os resultados com base nas permissões de usuário que o usuário definiu no Lake Formation.
Para obter mais informações sobre como adicionar usuários e grupos às políticas do Lake Formation, consulte [Granting Data Catalog permissions](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html).
## Pré-requisitos
É necessário atender aos seguintes requisitos para integrar o Amazon EMR e o Lake Formation:
+ Ative a autorização do perfil de runtime no cluster do Amazon EMR.
+ Use o AWS Glue Data Catalog como seu armazenamento de metadados.
+ Defina e gerencie permissões no Lake Formation para acessar bancos de dados, tabelas e colunas no AWS Glue Data Catalog. Para ter mais informações, consulte [O que é o AWS Lake Formation?](https://docs.aws.amazon.com/lake-formation/latest/dg/what-is-lake-formation.html)
# Acesso refinado com o Lake Formation
As versões 6.15.0 e superiores do Amazon EMR incluem suporte para controle de acesso refinado no nível de linha, coluna ou célula com base no Lake Formation. AWS Os tópicos desta seção abordam como você pode acessar tabelas do Catálogo de dados do Glue protegidas pelo Lake Formation a partir de trabalhos Spark do EMR ou sessões interativas com controle de acesso refinado.
# Habilitar o Lake Formation com o Amazon EMR
Com o Amazon EMR 6.15.0 e versões posteriores, quando você executa trabalhos do Spark no Amazon EMR em clusters EC2 que acessam dados no AWS Glue Data Catalog, você pode AWS Lake Formation usar para aplicar permissões em nível de tabela, linha, coluna e célula em tabelas baseadas em Hudi, Iceberg ou Delta Lake.
Nesta seção, abordamos como criar uma configuração de segurança e configurar o Lake Formation para trabalhar com o Amazon EMR. Também veremos como iniciar um cluster com a configuração de segurança criada para o Lake Formation.
## Etapa 1: configurar um perfil de runtime para o cluster do EMR
Para usar um perfil de runtime para o cluster do EMR, é necessário criar uma configuração de segurança. Com uma configuração de segurança, você pode aplicar opções consistentes de segurança, autorização e autenticação nos clusters.
1. Crie um arquivo chamado `lf-runtime-roles-sec-cfg.json` com a configuração a seguir.
```
{
"AuthorizationConfiguration": {
"IAMConfiguration": {
"EnableApplicationScopedIAMRole": true,
"ApplicationScopedIAMRoleConfiguration": {
"PropagateSourceIdentity": true
}
},
"LakeFormationConfiguration": {
"AuthorizedSessionTagValue": "Amazon EMR"
}
},
"EncryptionConfiguration": {
"EnableAtRestEncryption": false,
"EnableInTransitEncryption": true,
"InTransitEncryptionConfiguration": {
"TLSCertificateConfiguration": {}
}
}
}
```
O exemplo abaixo ilustra como usar um arquivo zip com certificados no Amazon S3 para configuração de certificados:
+ Um arquivo zip com certificados no Amazon S3 é usado como provedor de chaves. (Consulte [Fornecer certificados para criptografia de dados em trânsito com a criptografia do Amazon EMR](emr-encryption-enable.md#emr-encryption-certificates) para conhecer os requisitos necessários.)
```
"TLSCertificateConfiguration": {
"CertificateProviderType": "PEM",
"S3Object": "s3://MyConfigStore/artifacts/MyCerts.zip"
}
```
O exemplo abaixo ilustra como usar um provedor de chaves personalizado para a configuração do certificado:
+ Um provedor de chave personalizado é usado. (Consulte [Fornecer certificados para criptografia de dados em trânsito com a criptografia do Amazon EMR](emr-encryption-enable.md#emr-encryption-certificates) para conhecer os requisitos necessários.)
```
"TLSCertificateConfiguration": {
"CertificateProviderType": "Custom",
"S3Object": "s3://MyConfig/artifacts/MyCerts.jar",
"CertificateProviderClass": "com.mycompany.MyCertProvider"
}
```
1. Em seguida, para garantir que a etiqueta da sessão possa autorizar o Lake Formation, defina a propriedade `LakeFormationConfiguration/AuthorizedSessionTagValue` como `Amazon EMR`.
1. Use o comando a seguir para criar uma configuração de segurança do Amazon EMR.
```
aws emr create-security-configuration \
--name 'iamconfig-with-iam-lf' \
--security-configuration file://lf-runtime-roles-sec-cfg.json
```
Como alternativa, é possível usar o [console do Amazon EMR](https://console.aws.amazon.com//emr) para criar uma configuração de segurança com configurações personalizadas.
## Etapa 2: iniciar um cluster do Amazon EMR
Agora, você já pode iniciar um cluster do EMR com a configuração de segurança criada na etapa anterior. Para obter mais informações sobre configurações de segurança, consulte [Uso de configurações de segurança para definir a segurança do cluster do Amazon EMR](emr-security-configurations.md) e [Perfis de runtime para etapas ao Amazon EMR](emr-steps-runtime-roles.md).
## Etapa 3: configurar permissões no nível de coluna, linha ou célula baseadas no Lake Formation com perfis de runtime do Amazon EMR
Para aplicar um controle de acesso refinado no nível de coluna, linha ou célula com o Lake Formation, o administrador do data lake no Lake Formation deve definir `Amazon EMR` como valor da configuração da etiqueta de sessão, `AuthorizedSessionTagValue`. O Lake Formation usa essa etiqueta de sessão para autorizar os chamadores e fornecer acesso ao data lake. É possível definir essa etiqueta de sessão na seção **Configurações de integração de aplicações** do console do Lake Formation. *123456789012*Substitua por seu próprio Conta da AWS ID.
## Etapa 4: Configurar subsídios do AWS Glue e do Lake Formation para funções de tempo de execução do Amazon EMR
Para continuar com a configuração do controle de acesso baseado em Lake Formation com funções de tempo de execução do Amazon EMR, você deve configurar subsídios do AWS Glue e do Lake Formation para funções de tempo de execução do Amazon EMR. Para permitir que os perfis de runtime do IAM interajam com o Lake Formation, conceda a eles acesso com `lakeformation:GetDataAccess` e `glue:Get*`.
As permissões do Lake Formation controlam o acesso aos recursos do AWS Glue Data Catalog, aos locais do Amazon S3 e aos dados subjacentes nesses locais. As permissões do IAM controlam o acesso ao Lake Formation, ao AWS Glue APIs e aos recursos. Embora você possa ter a permissão do Lake Formation para acessar uma tabela no catálogo de dados (SELECT), a operação falhará se você não tiver a permissão do IAM na API `glue:Get*`. Para obter mais detalhes sobre o controle de acesso do Lake Formation, consulte a [visão geral do controle de acesso do Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/lf-permissions-overview.html).
1. Crie o arquivo `emr-runtime-roles-lake-formation-policy.json` com o conteúdo a seguir.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "LakeFormationManagedAccess",
"Effect": "Allow",
"Action": [
"lakeformation:GetDataAccess",
"glue:Get*",
"glue:Create*",
"glue:Update*"
],
"Resource": [
"*"
]
}
]
}
```
------
1. Crie a política do IAM relacionada ao IAM.
```
aws iam create-policy \
--policy-name emr-runtime-roles-lake-formation-policy \
--policy-document file://emr-runtime-roles-lake-formation-policy.json
```
1. Para atribuir essa política aos perfis de runtime do IAM, siga as etapas descritas em [Managing AWS Lake Formation permissions](https://docs.aws.amazon.com/lake-formation/latest/dg/managing-permissions.html).
Já é possível usar perfis de runtime e o Lake Formation para aplicar permissões em nível de tabela e coluna. Você também pode usar uma identidade de origem para controlar ações e monitorar operações com AWS CloudTrail.
Para cada perfil do IAM que você pretende usar como perfil de runtime, defina a política de confiança a seguir, substituindo `EMR_EC2_DefaultRole` pelo perfil do perfil de instância. Para modificar a política de confiança de um perfil do IAM, consulte [Modificar a política de confiança de um perfil](https://docs.aws.amazon.com//IAM/latest/UserGuide/roles-managingrole-editing-console.html).
```
{
"Sid":"AllowAssumeRole",
"Effect":"Allow",
"Principal":{
"AWS":"arn:aws:iam:::role/EMR_EC2_DefaultRole"
},
"Action":[
"sts:AssumeRole",
"sts:TagSession"
]
}
```
Para obter um end-to-end exemplo detalhado, consulte [Introdução às funções de tempo de execução para as etapas do Amazon EMR.](https://aws.amazon.com/blogs/big-data/introducing-runtime-roles-for-amazon-emr-steps-use-iam-roles-and-aws-lake-formation-for-access-control-with-amazon-emr/)
Para obter informações sobre como fazer a integração com o Iceberg e o AWS Glue Data Catalog para uma hierarquia de vários catálogos, consulte [Configurar o Spark para acessar uma hierarquia de vários catálogos no Glue Data Catalog](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-multi-catalog.html#emr-lakehouse-using-spark-access). AWS
# Suporte ao formato de tabela aberta
As versões 6.15.0 e superiores do Amazon EMR incluem suporte para controle de acesso refinado AWS Lake Formation com base em tabelas do Hive, Apache Iceberg, Apache Hudi e Delta Lake quando você lê e grava dados com o Spark SQL. O Amazon EMR oferece suporte ao controle de acesso no nível de tabela, linha, coluna e célula com o Apache Hudi. As versões 6.15.0 e superiores do Amazon EMR incluem suporte para controle de acesso refinado em nível de linha, coluna ou célula com base no AWS Lake Formation. A partir do EMR 7.12, as operações DML e DDL que modificam os dados da tabela são suportadas nas tabelas Apache Hive, Apache Iceberg e Delta Lake usando credenciais vendidas do Lake Formation.
Os tópicos desta seção abordam como você pode acessar as tabelas registradas do Lake Formation em formatos de tabela aberta a partir de trabalhos do EMR Spark ou sessões interativas com controle de acesso refinado.
## Requisitos de permissão
### Tabelas não registradas em AWS Lake Formation
Para tabelas não registradas AWS Lake Formation, a função de tempo de execução do trabalho acessa o AWS Glue Data Catalog e os dados da tabela subjacente no Amazon S3. Isso exige que a função de tempo de execução do trabalho tenha as permissões apropriadas do IAM para as operações do AWS Glue e do Amazon S3.
### Tabelas cadastradas em AWS Lake Formation
Para tabelas registradas com AWS Lake Formation, a função de tempo de execução do trabalho acessa os metadados do AWS Glue Data Catalog, enquanto as credenciais temporárias fornecidas pela Lake Formation acessam os dados da tabela subjacente no Amazon S3. As permissões do Lake Formation necessárias para executar uma operação dependem do AWS Glue Data Catalog e das chamadas de API do Amazon S3 iniciadas pelo trabalho do Spark e podem ser resumidas da seguinte forma:
+ A permissão **DESCRIBE** permite que a função de tempo de execução leia os metadados da tabela ou do banco de dados no Catálogo de Dados
+ A permissão **ALTER** permite que a função de tempo de execução modifique os metadados da tabela ou do banco de dados no Catálogo de Dados
+ A permissão **DROP** permite que a função de tempo de execução exclua metadados da tabela ou do banco de dados do Catálogo de Dados
+ A permissão **SELECT** permite que a função de tempo de execução leia os dados da tabela do Amazon S3
+ A permissão **INSERT** permite que a função de tempo de execução grave dados de tabela no Amazon S3
+ A permissão **DELETE** permite que a função de tempo de execução exclua dados da tabela do Amazon S3
**nota**
O Lake Formation avalia as permissões preguiçosamente quando um trabalho do Spark chama o AWS Glue para recuperar os metadados da tabela e o Amazon S3 para recuperar os dados da tabela. Trabalhos que usam uma função de tempo de execução com permissões insuficientes não falharão até que o Spark faça uma chamada ao AWS Glue ou ao Amazon S3 que exija a permissão ausente.
**nota**
Na seguinte matriz de tabela suportada:
As operações marcadas como **Suportadas** usam exclusivamente as credenciais do Lake Formation para acessar os dados das tabelas registradas no Lake Formation. Se as permissões do Lake Formation forem insuficientes, a operação não retornará às credenciais da função de tempo de execução. Para tabelas não registradas no Lake Formation, as credenciais da função de tempo de execução do trabalho acessam os dados da tabela.
As operações marcadas como **compatíveis com permissões do IAM na localização do Amazon S3** não usam as credenciais do Lake Formation para acessar os dados da tabela subjacente no Amazon S3. Para executar essas operações, a função de tempo de execução do trabalho deve ter as permissões necessárias do Amazon S3 IAM para acessar os dados da tabela, independentemente de a tabela estar registrada no Lake Formation.
------
#### [ Hive ]
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/emr/latest/ManagementGuide/emr-lf-fgac1.html)
------
#### [ Iceberg ]
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/emr/latest/ManagementGuide/emr-lf-fgac1.html)
**Configuração do Spark para Iceberg:** Se você quiser usar o formato Iceberg, defina as seguintes configurações. Substitua `DB_LOCATION` pelo caminho do Amazon S3 onde suas tabelas do Iceberg estão localizadas e os espaços reservados para a região e o ID da conta por seus próprios valores.
```
spark-sql \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
--conf spark.sql.catalog.spark_catalog=org.apache.iceberg.spark.SparkSessionCatalog
--conf spark.sql.catalog.spark_catalog.warehouse=s3://DB_LOCATION
--conf spark.sql.catalog.spark_catalog.catalog-impl=org.apache.iceberg.aws.glue.GlueCatalog
--conf spark.sql.catalog.spark_catalog.io-impl=org.apache.iceberg.aws.s3.S3FileIO
--conf spark.sql.catalog.spark_catalog.glue.account-id=ACCOUNT_ID
--conf spark.sql.catalog.spark_catalog.glue.id=ACCOUNT_ID
--conf spark.sql.catalog.spark_catalog.client.region=AWS_REGION
```
Se quiser usar o formato do Iceberg em versões anteriores do EMR, use o seguinte comando:
```
spark-sql \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions,com.amazonaws.emr.recordserver.connector.spark.sql.RecordServerSQLExtension
--conf spark.sql.catalog.spark_catalog=org.apache.iceberg.spark.SparkCatalog
--conf spark.sql.catalog.spark_catalog.warehouse=s3://DB_LOCATION
--conf spark.sql.catalog.spark_catalog.catalog-impl=org.apache.iceberg.aws.glue.GlueCatalog
--conf spark.sql.catalog.spark_catalog.io-impl=org.apache.iceberg.aws.s3.S3FileIO
--conf spark.sql.catalog.spark_catalog.glue.account-id=ACCOUNT_ID
--conf spark.sql.catalog.spark_catalog.glue.id=ACCOUNT_ID
--conf spark.sql.catalog.spark_catalog.client.assume-role.region=AWS_REGION
--conf spark.sql.catalog.spark_catalog.lf.managed=true
```
**Exemplos:**
Aqui estão alguns exemplos de como trabalhar com tabelas Iceberg:
```
-- Create an Iceberg table
CREATE TABLE my_iceberg_table (
id BIGINT,
name STRING,
created_at TIMESTAMP
) USING ICEBERG;
-- Insert data
INSERT INTO my_iceberg_table VALUES (1, 'Alice', current_timestamp());
-- Query the table
SELECT * FROM my_iceberg_table;
```
------
#### [ Hudi ]
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/emr/latest/ManagementGuide/emr-lf-fgac1.html)
**Configuração do Spark para Hudi:**
Para iniciar o shell Spark no EMR 7.10 ou versões superiores, use o comando a seguir:
```
spark-sql
--jars /usr/lib/hudi/hudi-spark-bundle.jar \
--conf spark.sql.catalog.spark_catalog=org.apache.spark.sql.hudi.catalog.HoodieCatalog \
--conf spark.sql.extensions=org.apache.spark.sql.hudi.HoodieSparkSessionExtension
```
Para iniciar o shell Spark em versões anteriores do EMR, use o comando abaixo em vez disso:
```
spark-sql
--jars /usr/lib/hudi/hudi-spark-bundle.jar \
--conf spark.serializer=org.apache.spark.serializer.KryoSerializer \
--conf spark.sql.catalog.spark_catalog=org.apache.spark.sql.hudi.catalog.HoodieCatalog \
--conf spark.sql.extensions=org.apache.spark.sql.hudi.HoodieSparkSessionExtension,com.amazonaws.emr.recordserver.connector.spark.sql.RecordServerSQLExtension \
--conf spark.sql.catalog.spark_catalog.lf.managed=true
```
**Exemplos:**
Aqui estão alguns exemplos de como trabalhar com tabelas Hudi:
```
-- Create a Hudi table
CREATE TABLE my_hudi_table (
id BIGINT,
name STRING,
created_at TIMESTAMP
) USING HUDI
TBLPROPERTIES (
'type' = 'cow',
'primaryKey' = 'id'
);
-- Insert data
INSERT INTO my_hudi_table VALUES (1, 'Alice', current_timestamp());
-- Query the latest snapshot
SELECT * FROM my_hudi_table;
```
Para consultar o último instantâneo das copy-on-write tabelas:
```
SELECT * FROM my_hudi_cow_table
```
```
spark.read.table("my_hudi_cow_table")
```
Para consultar os dados compactados mais recentes das tabelas `MOR`, você pode consultar a tabela otimizada para leitura que tem o sufixo `_ro`:
```
SELECT * FROM my_hudi_mor_table_ro
```
```
spark.read.table("my_hudi_mor_table_ro")
```
------
#### [ Delta Lake ]
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/emr/latest/ManagementGuide/emr-lf-fgac1.html)
**Configuração do Spark para Delta Lake:**
Para usar o Delta Lake com o Lake Formation no EMR 7.10 e superior, execute o seguinte comando:
```
spark-sql \
--conf spark.sql.extensions=io.delta.sql.DeltaSparkSessionExtension \
--conf spark.sql.catalog.spark_catalog=org.apache.spark.sql.delta.catalog.DeltaCatalog
```
Para usar o Delta Lake com o Lake Formation no EMR 6.15 a 7.9, execute o seguinte
```
spark-sql \
--conf spark.sql.extensions=io.delta.sql.DeltaSparkSessionExtension,com.amazonaws.emr.recordserver.connector.spark.sql.RecordServerSQLExtension \
--conf spark.sql.catalog.spark_catalog=org.apache.spark.sql.delta.catalog.DeltaCatalog \
--conf spark.sql.catalog.spark_catalog.lf.managed=true
```
Se quiser que o Lake Formation use o servidor de registros para gerenciar o catálogo do Spark, defina `spark.sql.catalog..lf.managed` como verdadeiro.
**Exemplos:**
Aqui estão alguns exemplos de como trabalhar com tabelas Delta Lake:
```
-- Create a Delta Lake table
CREATE TABLE my_delta_table (
id BIGINT,
name STRING,
created_at TIMESTAMP
) USING DELTA;
-- Insert data
INSERT INTO my_delta_table VALUES (1, 'Alice', current_timestamp());
-- Query the table
SELECT * FROM my_delta_table;
-- Update data
UPDATE my_delta_table SET name = 'Alice Smith' WHERE id = 1;
-- Merge data
MERGE INTO my_delta_table AS target
USING (SELECT 2 as id, 'Bob' as name, current_timestamp() as created_at) AS source
ON target.id = source.id
WHEN MATCHED THEN UPDATE SET *
WHEN NOT MATCHED THEN INSERT *;
```
**Criação de uma tabela Delta Lake no AWS Glue Data Catalog**
O Amazon EMR com Lake Formation não oferece suporte a comandos DDL e à criação de tabelas Delta em versões do EMR anteriores à 7.12. Siga estas etapas para criar tabelas no AWS Glue Data Catalog.
1. Use o exemplo a seguir para criar uma tabela do Delta. Certifique-se de que sua localização no S3 exista.
```
spark-sql \
--conf "spark.sql.extensions=io.delta.sql.DeltaSparkSessionExtension" \
--conf "spark.sql.catalog.spark_catalog=org.apache.spark.sql.delta.catalog.DeltaCatalog"
> CREATE DATABASE if not exists LOCATION 's3:///transactionaldata/native-delta//';
> CREATE TABLE (x INT, y STRING, z STRING) USING delta;
> INSERT INTO VALUES (1, 'a1', 'b1');
```
1. Para ver os detalhes da sua mesa, acesse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. No painel de navegação à esquerda, expanda **Data Catalog**, escolha **Tabelas** e a tabela que você criou. Em **Esquema**, você verá que a tabela Delta que você criou com o Spark armazena todas as colunas em um tipo de dados do `array` AWS Glue.
1. Para definir filtros em nível de coluna e célula no Lake Formation, remova a coluna `col` do esquema e, em seguida, adicione as colunas que estão no esquema da tabela. Neste exemplo, adicione as colunas `x`, `y` e `z`.
------
Com esse recurso, você pode executar consultas de instantâneos em copy-on-write tabelas para consultar o instantâneo mais recente da tabela em um determinado instante de confirmação ou compactação. Atualmente, um cluster do Amazon EMR habilitado pelo Lake Formation deve recuperar a coluna de tempo de confirmação do Hudi para realizar consultas incrementais e consultas de viagem no tempo. Ele não é compatível com a sintaxe `timestamp as of` e a função `Spark.read()` do Spark. A sintaxe correta é `select * from table where _hoodie_commit_time <= point_in_time`. Para obter mais informações, consulte [Point in time Time-Travel queries on Hudi table](https://cwiki.apache.org/confluence/display/HUDI/RFC+-+07+%3A+Point+in+time+Time-Travel+queries+on+Hudi+table).
**nota**
A performance das leituras nos clusters do Lake Formation pode ser mais lenta devido às otimizações sem suporte. Esses atributos incluem listagem de arquivos com base nos metadados do Hudi e salto de dados. É recomendável testar a performance da aplicação para garantir que ela atenda aos seus requisitos.
# Trabalho com vizualizações do Catálogo de dados do Glue no Amazon EMR
**nota**
A criação e o gerenciamento de visualizações do AWS Glue Data Catalog para uso com o EMR no EC2 estão disponíveis com o Amazon [EMR](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-7100-release.html) versão 7.10.0 e posterior.
Você pode criar e gerenciar visualizações no AWS Glue Data Catalog para uso com o EMR no EC2. Elas são comumente conhecidas como visualizações do AWS Glue Data Catalog. Essas visualizações são úteis porque oferecem suporte a vários mecanismos de consulta SQL, para que você possa acessar a mesma visualização em diferentes AWS serviços, como EMR no EC2 e Amazon Redshift. Amazon Athena
Ao criar uma exibição no Catálogo de Dados, você pode usar concessões de recursos e controles de acesso baseados em tags AWS Lake Formation para conceder acesso a ela. Usando esse método de controle de acesso, você não precisa configurar acesso adicional às tabelas referenciadas ao criar a exibição. Esse método de concessão de permissões é chamado de semântica definidora, e essas exibições são chamadas de vizualizações definidoras. Para obter mais informações sobre o controle de acesso no Lake Formation, consulte [Conceder e revogar permissões nos recursos do Catálogo de Dados no](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html) Guia do Desenvolvedor do AWS Lake Formation.
As vizualizações do Data Catalog são úteis para os seguintes casos de uso:
+ **Controle de acesso granular**: é possível criar uma visualização que restringe o acesso aos dados com base nas permissões necessárias ao usuário. Por exemplo, você pode usar as exibições do Data Catalog para evitar que funcionários que não trabalham no departamento de RH vejam informações de identificação pessoal (PII).
+ **Definição completa da exibição**: ao aplicar filtros à sua visualização no Catálogo de dados, você garante que os registros de dados em uma exibição do Catálogo de dados estejam sempre completos.
+ **Segurança aprimorada**: a definição da consulta usada para criar a exibição deve estar completa. Esse benefício significa que as vizualizações no Data Catalog não são suscetíveis a comandos SQL de acessos mal-intencionados.
+ **Compartilhamento simples de dados** — compartilhe dados com outras AWS contas sem mover dados. Para obter mais informações, consulte [Cross-account data sharing in Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/cross-account-permissions.html).
## Criação de uma visualização do Catálogo de Dados
Há maneiras diferentes de criar uma exibição do Catálogo de dados. Isso inclui o uso do AWS CLI ou do Spark SQL. Veja alguns exemplos.
------
#### [ Using SQL ]
Veja a seguir a sintaxe para a criação de uma exibição do Catálogo de dados. Observe o tipo de visualização `MULTI DIALECT`. Isso distingue a exibição do Catálogo de dados de outras visualizações. O predicado `SECURITY` é especificado como `DEFINER`. Isso indica uma visualização do Catálogo de dados com semântica `DEFINER`.
```
CREATE [ OR REPLACE ] PROTECTED MULTI DIALECT VIEW [IF NOT EXISTS] view_name
[(column_name [COMMENT column_comment], ...) ]
[ COMMENT view_comment ]
[TBLPROPERTIES (property_name = property_value, ... )]
SECURITY DEFINER
AS query;
```
Veja a seguir um exemplo de instrução `CREATE`, seguindo a sintaxe:
```
CREATE PROTECTED MULTI DIALECT VIEW catalog_view
SECURITY DEFINER
AS
SELECT order_date, sum(totalprice) AS price
FROM source_table
GROUP BY order_date
```
Você também pode criar uma exibição no modo de simulação, usando SQL, para testar a criação da exibição, sem realmente criar o recurso. O uso dessa opção resulta em uma “execução seca” que valida a entrada e, se a validação for bem-sucedida, retorna o JSON do objeto da tabela AWS Glue que representará a visualização. Nesse caso, a visualização real não é criada.
```
CREATE [ OR REPLACE ] PROTECTED MULTI DIALECT VIEW view_name
SECURITY DEFINER
[ SHOW VIEW JSON ]
AS view-sql
```
------
#### [ Using the AWS CLI ]
**nota**
Quando você usa o comando da CLI, o SQL usado para criar a exibição não é analisado. Isso pode resultar em um caso em que a exibição é criada, mas as consultas não são bem-sucedidas. Certifique-se de testar sua sintaxe SQL antes de criar a exibição.
Use o seguinte comando da CLI para criar uma visualização:
```
aws glue create-table --cli-input-json '{
"DatabaseName": "database",
"TableInput": {
"Name": "view",
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "data-type"
},
...
{
"Name": "col_n",
"Type": "data-type"
}
],
"SerdeInfo": {}
},
"ViewDefinition": {
"SubObjects": [
"arn:aws:glue:aws-region:aws-account-id:table/database/referenced-table1",
...
"arn:aws:glue:aws-region:aws-account-id:table/database/referenced-tableN",
],
"IsProtected": true,
"Representations": [
{
"Dialect": "SPARK",
"DialectVersion": "1.0",
"ViewOriginalText": "Spark-SQL",
"ViewExpandedText": "Spark-SQL"
}
]
}
}
}'
```
------
## Operações compatíveis para visualizações
Os fragmentos de comandos apresentados a seguir mostram como é possível trabalhar com as visualizações do Catálogo de Dados de diferentes formas:
+ **CREATE VIEW**
Cria uma visualização do Catálogo de Dados. A seguir, um exemplo que demonstra a criação da visualização usando uma tabela existente:
```
CREATE PROTECTED MULTI DIALECT VIEW catalog_view
SECURITY DEFINER AS SELECT * FROM my_catalog.my_database.source_table
```
+ **ALTER VIEW**
Sintaxe disponível:
+ `ALTER VIEW view_name [FORCE] ADD DIALECT AS query`
+ `ALTER VIEW view_name [FORCE] UPDATE DIALECT AS query`
+ `ALTER VIEW view_name DROP DIALECT`
É possível usar a opção `FORCE ADD DIALECT` para aplicar a atualização do esquema e dos objetos secundários de acordo com o novo dialeto do mecanismo. Lembre-se de que essa ação pode resultar em erros de consulta, caso a opção `FORCE` não seja usada para atualizar os demais dialetos do mecanismo. A seguir, um exemplo que demonstra a aplicação:
```
ALTER VIEW catalog_view FORCE ADD DIALECT
AS
SELECT order_date, sum(totalprice) AS price
FROM source_table
GROUP BY orderdate;
```
A seguir, um exemplo que demonstra a alteração de uma visualização para a atualização do dialeto:
```
ALTER VIEW catalog_view UPDATE DIALECT AS
SELECT count(*) FROM my_catalog.my_database.source_table;
```
+ **DESCRIBE VIEW**
Sintaxe disponível para descrever uma visualização:
+ `SHOW COLUMNS {FROM|IN} view_name [{FROM|IN} database_name]`— Se o usuário tiver as permissões necessárias de AWS Glue e Lake Formation para descrever a visualização, ele poderá listar as colunas. A seguir, alguns exemplos de comandos que demonstram como visualizar colunas:
```
SHOW COLUMNS FROM my_database.source_table;
SHOW COLUMNS IN my_database.source_table;
```
+ `DESCRIBE view_name`— Se o usuário tiver as permissões necessárias de AWS Glue e Lake Formation para descrever a visualização, ele poderá listar as colunas na exibição junto com seus metadados.
+ **DROP VIEW**
Sintaxe disponível:
+ `DROP VIEW [ IF EXISTS ] view_name`
A seguir, um exemplo de instrução `DROP` que demonstra como realizar um teste para verificar a existência da visualização antes de sua remoção:
```
DROP VIEW IF EXISTS catalog_view;
```
+ **MOSTRAR CRIAR VISUALIZAÇÃO**
+ `SHOW CREATE VIEW view_name`: mostra a instrução SQL responsável pela criação da visualização especificada. A seguir, um exemplo que demonstra o processo de criação de uma visualização no Catálogo de Dados:
```
SHOW CREATE TABLE my_database.catalog_view;
CREATE PROTECTED MULTI DIALECT VIEW my_catalog.my_database.catalog_view (
net_profit,
customer_id,
item_id,
sold_date)
TBLPROPERTIES (
'transient_lastDdlTime' = '1736267222')
SECURITY DEFINER AS SELECT * FROM
my_database.store_sales_partitioned_lf WHERE customer_id IN (SELECT customer_id from source_table limit 10)
```
+ **SHOW VIEWS**
Lista todas as visualizações existentes no catálogo, incluindo as visualizações regulares, as visualizações com múltiplos dialetos (MDV, na sigla em inglês) e as MDVs sem suporte ao dialeto Spark. A sintaxe disponível é a seguinte:
+ `SHOW VIEWS [{ FROM | IN } database_name] [LIKE regex_pattern]`:
A seguir, um exemplo que demonstra um comando para mostrar as visualizações:
```
SHOW VIEWS IN marketing_analytics LIKE 'catalog_view*';
```
Para obter mais informações sobre como criar e configurar visualizações do catálogo de dados, consulte Como criar visualizações do catálogo de [dados do AWS Glue no Guia](https://docs.aws.amazon.com/lake-formation/latest/dg/working-with-views.html) do AWS Lake Formation desenvolvedor.
## Consulta de uma visualização do Catálogo de Dados
Depois de criar uma visualização do catálogo de dados, você pode consultá-la usando uma tarefa do Amazon EMR Spark que tenha um controle de acesso AWS Lake Formation refinado ativado. O perfil de runtime do trabalho deve ter a permissão `SELECT` do Lake Formation na visualização do Catálogo de dados. Não é necessário conceder acesso às tabelas subjacentes referenciadas na visualização.
Depois de configurar tudo, você pode consultar sua exibição. Por exemplo, depois de criar uma aplicação do Amazon EMR no EMR Studio, é possível executar a consulta a seguir para acessar uma exibição.
```
SELECT * from my_database.catalog_view LIMIT 10;
```
Uma função útil é `invoker_principal`. Ela retorna o identificador exclusivo do perfil de runtime do trabalho do EMRS. Isso pode ser usado para controlar a saída da visualização, com base na entidade principal de invocação. Você pode usar isso para adicionar uma condição à sua visualização que refina os resultados da consulta, com base no perfil de chamada. O perfil de runtime do trabalho deve ter permissão para a ação `LakeFormation:GetDataLakePrincipal` do IAM usar essa função.
```
select invoker_principal();
```
Você pode adicionar essa função a uma cláusula `WHERE`, por exemplo, para refinar os resultados da consulta.
## Considerações e limitações
Quando você cria exibições do Catálogo de dados, o seguinte se aplica:
+ Você só pode criar exibições do Catálogo de dados com o Amazon EMR 7.10 e versões superiores.
+ O responsável pela definição da visualização do Catálogo de Dados deve ter permissão de acesso `SELECT` nas tabelas de base subjacentes acessadas pela visualização. A operação de criação da visualização do Catálogo de Dados não será bem-sucedida caso uma das tabelas de base tenha filtros do Lake Formation atribuídos ao perfil “definer”.
+ As tabelas de base não devem ter a permissão de data lake `IAMAllowedPrincipals` no Lake Formation. Se presente, o erro de *visualizações de vários dialetos só pode fazer referência a tabelas sem a permissão do IAMAllowed Principal.*
+ A localização da tabela no Amazon S3 deve ser registrada como uma localização de data lake do Lake Formation. Se a tabela não estiver registrada, o erro *Visualizações de vários dialetos só podem fazer referência a tabelas gerenciadas pelo Lake Formation* ocorrerá. Para obter informações sobre como registrar locais do Amazon S3 em Lake Formation, consulte [Registro de um local do Amazon S3](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html) no Guia do desenvolvedor. AWS Lake Formation
+ Você só pode criar vizualizações `PROTECTED` do Data Catalog. Não há suporte para exibições `UNPROTECTED`.
+ Você não pode referenciar tabelas em outra AWS conta em uma definição de exibição do Catálogo de Dados. Além disso, não é possível referenciar uma tabela da mesma conta que esteja em uma região diferente.
+ Para compartilhar dados entre contas ou regiões, a visualização inteira deve ser compartilhada entre contas e entre regiões, usando links de recurso do Lake Formation.
+ As funções definidas pelo usuário (UDFs) não são suportadas.
+ É possível usar visualizações baseadas em tabelas do Iceberg. Os formatos de tabela aberta Apache Hudi e Delta Lake também são compatíveis.
+ Não é possível fazer referência a outras vizualizações nas exibições do Data Catalog.
+ Um esquema de visualização do AWS Glue Data Catalog é sempre armazenado em letras minúsculas. Por exemplo, se você usar uma instrução DDL para criar uma exibição do Catálogo de dados do Glue com uma coluna chamada `Castle`, a coluna criada no Catálogo de dados do Glue será transformada em minúsculas, para `castle`. Se você especificar o nome da coluna em uma consulta DML como `Castle` ou `CASTLE`, o EMR Spark mudará o nome para letras minúsculas para você executar a consulta. Porém, o título da coluna é exibido usando as letras maiúsculas e minúsculas que você especificou na consulta.
Se quiser que uma consulta falhe em um caso em que o nome da coluna especificado na consulta DML não corresponda ao nome da coluna no Catálogo de dados do Glue, você pode definir `spark.sql.caseSensitive=true`.
# Considerações sobre o Amazon EMR com o Lake Formation
O Amazon EMR com Lake Formation está disponível em [todas as regiões disponíveis](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-region.html).
## Considerações sobre o Amazon EMR com Lake Formation para a versão 7.9 e anteriores
Considere o seguinte ao usar AWS Lake Formation no EMR 7.9 e versões anteriores.
+ O [controle de acesso refinado](emr-lf-enable.md#emr-lf-fgac-perms) no nível de linha, coluna e célula está disponível em clusters com versões 6.15 e superiores do Amazon EMR.
+ Os usuários com acesso a uma tabela podem acessar todas as propriedades da tabela. Se você tiver controle de acesso baseado no Lake Formation em uma tabela, revise a tabela para garantir que as propriedades não contenham dados ou informações sigilosas.
+ Os clusters do Amazon EMR com Lake Formation não oferecem suporte ao retorno do Spark para o HDFS quando o Spark coleta estatísticas de tabelas. Isso normalmente ajuda a otimizar a performance da consulta.
+ As operações que oferecem suporte a controles de acesso baseados no Lake Formation com tabelas não governadas do Apache Spark incluem `INSERT INTO` e `INSERT OVERWRITE`.
+ As operações que oferecem suporte a controles de acesso baseados no Lake Formation com Apache Spark e Apache Hive incluem `SELECT`, `DESCRIBE`, `SHOW DATABASE`, `SHOW TABLE`, `SHOW COLUMN` e `SHOW PARTITION`.
+ O Amazon EMR não oferece suporte ao controle de acesso às seguintes operações baseadas no Lake Formation:
+ Grava em tabelas controladas
+ O Amazon EMR não oferece suporte a `CREATE TABLE`. O Amazon EMR 6.10.0 e versões superiores oferecem suporte a `ALTER TABLE`.
+ Instruções DML que não sejam comandos `INSERT`.
+ Há diferenças de performance entre a mesma consulta com e sem controle de acesso baseado no Lake Formation.
+ Você só pode usar o Amazon EMR com o Lake Formation para trabalhos do Spark.
+ A propagação de identidades confiáveis não é compatível com a hierarquia de vários catálogos no Catálogo de dados do Glue. Para obter mais informações, consulte [Trabalhando com uma hierarquia de vários catálogos no AWS Glue Data Catalog](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-multi-catalog.html).
## Considerações sobre o Amazon EMR com Lake Formation para a versão 7.10 e posteriores
Considere o seguinte ao usar o Amazon EMR com o AWS Lake Formation EMR 7.10 e versões posteriores.
+ O Amazon EMR oferece suporte ao controle de acesso refinado por meio do Lake Formation apenas para tabelas Apache Hive, tabelas do Iceberg, Apache Delta e Apache Hudi. Os formatos do Apache Hive incluem Parquet, ORC e xSV CSV.
+ Para aplicações habilitadas para o Lake Formation, os logs do Spark são gravados no Amazon S3 em dois grupos: logs de espaço do sistema e logs de espaço do usuário. Os logs de espaço do sistema podem conter informações confidenciais, como o esquema completo da tabela. Para proteger esses dados, o Amazon EMR armazena os logs de espaço do sistema em um local separado dos logs de espaço do usuário. É altamente recomendável que os administradores de contas não concedam aos usuários acesso aos logs de espaço do sistema.
+ Se você registrar um local de tabela no Lake Formation, o acesso aos dados será controlado exclusivamente pelas permissões da função usada para registro, e não pela função de runtime do trabalho do Amazon EMR. Se o perfil de registro estiver incorretamente configurado, os trabalhos que tentarem acessar a tabela falharão.
+ Você não pode desativar `DynamicResourceAllocation` para trabalhos do Lake Formation.
+ Você só pode usar o Lake Formation com trabalhos do Spark.
+ O Amazon EMR com Lake Formation oferece suporte apenas a uma única sessão do Spark durante todo o trabalho.
+ O Amazon EMR com Lake Formation só oferece suporte a consultas de tabelas entre contas compartilhadas por meio de links de recursos.
+ As seguintes opções não são compatíveis:
+ Conjuntos de dados distribuídos resilientes (RDD)
+ Streaming do Spark
+ Gravação com as permissões concedidas pelo Lake Formation
+ Controle de acesso para colunas aninhadas
+ O Amazon EMR bloqueia funcionalidades que podem prejudicar o isolamento completo do driver do sistema, incluindo as seguintes:
+ UDTs, Hive UDFs e qualquer função definida pelo usuário que envolva classes personalizadas
+ Fontes de dados personalizadas
+ Fornecimento de JARs adicionais para extensão, conector ou metastore do Spark
+ Comando `ANALYZE TABLE`
+ Para impor controles de acesso, `EXPLAIN PLAN` e operações de DDL, como `DESCRIBE TABLE`, não expõem informações restritas.
+ O Amazon EMR restringe o acesso aos logs do Spark do driver do sistema em aplicações habilitadas para Lake Formation. Como o driver do sistema é executado com permissões elevadas, os eventos e logs que o driver do sistema gera podem incluir informações confidenciais. Para impedir que usuários ou códigos não autorizados acessem esses dados sensíveis, o Amazon EMR desabilita o acesso aos logs do driver do sistema.
Os logs do perfil do sistema são sempre mantidos no armazenamento gerenciado: essa é uma configuração obrigatória que não pode ser desabilitada. Esses registros são armazenados com segurança e criptografados usando uma chave KMS gerenciada pelo cliente ou uma chave KMS AWS gerenciada.
[Se seu aplicativo Amazon EMR estiver em uma sub-rede privada com endpoints VPC para o Amazon S3 e você anexar uma política de endpoint para controlar o acesso, antes que seus trabalhos possam enviar dados de log para o AWS Amazon S3 gerenciado, você deve incluir as permissões detalhadas em Armazenamento gerenciado em sua política de VPC para o endpoint do gateway S3.](logging.html#jobs-log-storage-managed-storage) Para solicitações de solução de problemas, entre em contato com AWS o suporte.
+ Se você registrou uma localização de tabela no Lake Formation, o caminho de acesso aos dados passa pelas credenciais armazenadas do Lake Formation, independentemente da permissão do IAM para o perfil de runtime do trabalho do Amazon EMR. Se você configurar incorretamente o perfil registrado com a localização da tabela, os trabalhos enviados que usam o perfil com a permissão do IAM para o S3 na localização da tabela falharão.
+ Gravar em uma tabela do Lake Formation usa a permissão do IAM em vez das permissões concedidas pelo Lake Formation. Se o runtime do trabalho tiver as permissões necessárias do S3, será possível usá-lo para executar operações de gravação.
Observe estas considerações e limitações ao usar o Apache Iceberg:
+ Você só pode usar o Apache Iceberg com o catálogo de sessões e não com catálogos nomeados arbitrariamente.
+ As tabelas do Iceberg registradas no Lake Formation oferecem suporte apenas às tabelas de metadados `history`, `metadata_log_entries`, `snapshots`, `files`, `manifests` e `refs`. O Amazon EMR oculta as colunas que podem conter dados confidenciais, como `partitions`, `path` e `summaries`. Essa limitação não se aplica às tabelas do Iceberg que não estão registradas no Lake Formation.
+ As tabelas que você não registra no Lake Formation oferecem suporte a todos os procedimentos armazenados do Iceberg. Os procedimentos `register_table` e `migrate` não são compatíveis com nenhuma tabela.
+ Recomendamos que você use o Iceberg DataFrameWriter V2 em vez do V1.
## Considerações sobre o Amazon EMR com Lake Formation para a versão 7.12 e posterior
### Geral
Analise as seguintes limitações ao usar o Lake Formation com o Amazon EMR.
+ Você não pode desativar `DynamicResourceAllocation` para trabalhos do Lake Formation.
+ Você só pode usar o Lake Formation com trabalhos do Spark.
+ O Amazon EMR com Lake Formation oferece suporte apenas a uma única sessão do Spark durante todo o trabalho.
+ O Amazon EMR com Lake Formation só oferece suporte a consultas de tabelas entre contas compartilhadas por meio de links de recursos.
+ As seguintes opções não são compatíveis:
+ Conjuntos de dados distribuídos resilientes (RDD)
+ Streaming do Spark
+ Controle de acesso para colunas aninhadas
+ O Amazon EMR bloqueia funcionalidades que podem prejudicar o isolamento completo do driver do sistema, incluindo as seguintes:
+ UDTs, Hive UDFs e qualquer função definida pelo usuário que envolva classes personalizadas
+ Fontes de dados personalizadas
+ Fornecimento de JARs adicionais para extensão, conector ou metastore do Spark
+ Comando `ANALYZE TABLE`
+ [Se seu aplicativo Amazon EMR estiver em uma sub-rede privada com endpoints VPC para o Amazon S3 e você anexar uma política de endpoint para controlar o acesso, antes que seus trabalhos possam enviar dados de log para o AWS Amazon S3 gerenciado, você deve incluir as permissões detalhadas em Armazenamento gerenciado em sua política de VPC para o endpoint do gateway S3.](logging.html#jobs-log-storage-managed-storage) Para solicitações de solução de problemas, entre em contato com AWS o suporte.
+ A partir do Amazon EMR 7.9.0, o Spark FGAC oferece suporte ao AFile sistema S3 quando usado com o esquema s3a://.
+ O Amazon EMR 7.11 oferece suporte à criação de tabelas gerenciadas usando CTAS.
+ O Amazon EMR 7.12 oferece suporte à criação de tabelas gerenciadas e externas usando CTAS.
## Permissões
+ Para aplicar controles de acesso, as operações EXPLAIN PLAN e DDL, como DESCRIBE TABLE, não expõem informações restritas.
+ Quando você registra a localização de uma tabela no Lake Formation, o acesso aos dados usa as credenciais armazenadas do Lake Formation em vez das permissões IAM da função de tempo de execução de trabalho do EMR Serverless. Os trabalhos falharão se a função registrada para a localização da tabela estiver configurada incorretamente, mesmo quando a função de tempo de execução tiver permissões do S3 IAM para essa localização.
+ A partir do Amazon EMR 7.12, você pode gravar nas tabelas existentes do Hive e do Iceberg usando DataFrameWriter (V2) com as credenciais do Lake Formation no modo de acréscimo. Para operações de substituição ou ao criar novas tabelas, o EMR usa as credenciais da função de tempo de execução para modificar os dados da tabela.
+ As seguintes limitações se aplicam ao usar exibições ou tabelas em cache como dados de origem (essas limitações não se aplicam às visualizações do AWS Glue Data Catalog):
+ Para operações MERGE, DELETE e UPDATE
+ Compatível: uso de visualizações e tabelas em cache como tabelas de origem.
+ Não suportado: uso de visualizações e tabelas em cache em cláusulas de atribuição e condição.
+ Para as operações CREATE OR REPLACE e REPLACE TABLE AS SELECT:
+ Não suportado: uso de visualizações e tabelas em cache como tabelas de origem.
+ As tabelas Delta Lake com dados UDFs na fonte suportam as operações MERGE, DELETE e UPDATE somente quando o vetor de exclusão está ativado.
## Registros e depuração
+ O Amazon EMR restringe o acesso aos logs do Spark do driver do sistema em aplicações habilitadas para Lake Formation. Como o driver do sistema é executado com permissões elevadas, os eventos e logs que o driver do sistema gera podem incluir informações confidenciais. Para impedir que usuários ou códigos não autorizados acessem esses dados sensíveis, o Amazon EMR desabilita o acesso aos logs do driver do sistema.
Os logs do perfil do sistema são sempre mantidos no armazenamento gerenciado: essa é uma configuração obrigatória que não pode ser desabilitada. Esses registros são armazenados com segurança e criptografados usando uma chave KMS gerenciada pelo cliente ou uma chave KMS AWS gerenciada.
## Iceberg
Analise as seguintes considerações ao usar o Apache Iceberg:
+ Você só pode usar o Apache Iceberg com o catálogo de sessões e não com catálogos nomeados arbitrariamente.
+ As tabelas do Iceberg registradas no Lake Formation oferecem suporte apenas às tabelas de metadados `history`, `metadata_log_entries`, `snapshots`, `files`, `manifests` e `refs`. O Amazon EMR oculta as colunas que podem conter dados confidenciais, como `partitions`, `path` e `summaries`. Essa limitação não se aplica às tabelas do Iceberg que não estão registradas no Lake Formation.
+ As tabelas não registradas no Lake Formation oferecem suporte a todos os procedimentos armazenados do Iceberg. Os procedimentos `register_table` e `migrate` não são compatíveis com nenhuma tabela.
+ Sugerimos que você use o Iceberg DataFrameWriter V2 em vez do V1.
# API de controle de acesso refinado nativo do Spark permitida PySpark
Para manter a segurança e os controles de acesso aos dados, o controle de acesso refinado (FGAC) do Spark restringe determinadas funções. PySpark Essas restrições são aplicadas por meio de:
+ Bloqueio explícito que impede a execução da função
+ Incompatibilidades de arquitetura que tornam as funções não funcionais
+ Funções que podem gerar erros, retornar mensagens de acesso negado ou não fazer nada quando chamadas
Os seguintes PySpark recursos não são compatíveis com o Spark FGAC:
+ Operações RDD (bloqueadas com a exceção do Spark) RDDUnsupported
+ Spark Connect (não suportado)
+ Spark Streaming (não suportado)
Embora tenhamos testado as funções listadas em um ambiente Native Spark FGAC e confirmado que elas funcionam conforme o esperado, nossos testes normalmente abrangem apenas o uso básico de cada API. Funções com vários tipos de entrada ou caminhos lógicos complexos podem ter cenários não testados.
Para qualquer função não listada aqui e que não faça parte claramente das categorias não suportadas acima, recomendamos:
+ Testando-os primeiro em um ambiente gama ou em uma implantação em pequena escala
+ Verificando seu comportamento antes de usá-los na produção
**nota**
Se você ver um método de classe listado, mas não sua classe base, o método ainda deve funcionar — significa apenas que não verificamos explicitamente o construtor da classe base.
A PySpark API é organizada em módulos. O suporte geral para métodos em cada módulo está detalhado na tabela abaixo.
| Nome do módulo | Status | Observações |
| --- | --- | --- |
| pyspark\$1core | Compatível | Este módulo contém as principais classes do RDD e, na maioria das vezes, essas funções não são suportadas. |
| pyspark\$1sql | Compatível | |
| teste\$1de\$1pyspark | Compatível | |
| pyspark\$1resource | Compatível | |
| pyspark\$1streaming | Bloqueado | O uso do streaming está bloqueado no Spark FGAC. |
| pyspark\$1mllib | Experimental | Este módulo contém operações de ML baseadas em RDD, e essas funções geralmente não são suportadas. Este módulo não foi totalmente testado. |
| pyspark\$1ml | Experimental | Esse módulo contém operações de ML DataFrame baseadas, e essas funções são suportadas principalmente. Este módulo não foi totalmente testado. |
| pyspark\$1pandas | Compatível | |
| pyspark\$1pandas\$1slow | Compatível | |
| pyspark\$1connect | Bloqueado | O uso do Spark Connect está bloqueado no Spark FGAC. |
| pyspark\$1pandas\$1connect | Bloqueado | O uso do Spark Connect está bloqueado no Spark FGAC. |
| pyspark\$1pandas\$1slow\$1connect | Bloqueado | O uso do Spark Connect está bloqueado no Spark FGAC. |
| pyspark\$1errors | Experimental | Este módulo não foi totalmente testado. Classes de erro personalizadas não podem ser utilizadas. |
**Lista de permissões da API**
Para uma lista que pode ser baixada e mais fácil de pesquisar, um arquivo com os módulos e classes está disponível nas [funções do Python permitidas no](samples/Python functions allowed in Native FGAC.zip) FGAC nativo.
# Acesso completo à tabela do Lake Formation para o Amazon EMR no EC2
Com as versões 7.8.0 e superiores do Amazon EMR, você pode aproveitar o Lake AWS Formation com o Glue Data Catalog, onde a função de tempo de execução do trabalho tem permissões completas de tabela sem as limitações do controle de acesso refinado. Esse recurso permite que você leia e grave em tabelas protegidas pelo Lake Formation a partir do Amazon EMR em trabalhos em lote e interativos do EC2 Spark. Consulte as seções a seguir para saber mais sobre o Lake Formation e como usá-lo com o Amazon EMR no EC2.
## Como usar o Lake Formation com acesso total à tabela
Você pode acessar as tabelas do catálogo do Glue Data protegidas pelo AWS Lake Formation do Amazon EMR em trabalhos do EC2 Spark ou sessões interativas em que a função de tempo de execução do trabalho tem acesso total à tabela. Você não precisa habilitar o AWS Lake Formation no aplicativo Amazon EMR no EC2. Quando um trabalho do Spark é configurado para Full Table Access (FTA), as credenciais do AWS Lake Formation são usadas para os dados do read/write S3 das tabelas registradas do AWS Lake Formation, enquanto as credenciais da função de tempo de execução do trabalho são usadas para read/write tabelas não registradas no Lake Formation. AWS
**Importante**
Não ative o AWS Lake Formation para um controle de acesso refinado. Um trabalho não pode executar simultaneamente o Acesso total à tabela (FTA) e o Controle de acesso refinado (FGAC) no mesmo cluster ou aplicação EMR.
### Etapa 1: habilitar o acesso total à tabela no Lake Formation
Para usar o modo Full Table Access (FTA), você deve permitir que mecanismos de consulta de terceiros acessem dados sem a validação da tag de sessão do IAM no AWS Lake Formation. Para habilitar, siga as etapas em [Application integration for full table access](https://docs.aws.amazon.com/lake-formation/latest/dg/full-table-credential-vending.html).
**nota**
Ao acessar tabelas entre contas, o acesso completo à tabela deve ser habilitado nas contas de produtor e consumidor. Da mesma forma, ao acessar tabelas entre regiões, essa configuração deve ser habilitada nas regiões produtora e consumidora.
### Etapa 2: configurar permissões do IAM para o perfil de runtime do trabalho
Para acesso de leitura ou gravação aos dados subjacentes, além das permissões do Lake Formation, um perfil de runtime do trabalho precisa da permissão `lakeformation:GetDataAccess` do IAM. Com essa permissão, o Lake Formation concede a solicitação de credenciais temporárias para acessar os dados.
Confira a seguir um exemplo de política de como fornecer permissões do IAM para acesso a um script no S3, upload de logs no Amazon S3, permissões da API do AWS Glue e permissão para acessar o Lake Formation.
#### Etapa 2.1: configurar permissões do Lake Formation
+ Os trabalhos Spark que leem dados do S3 necessitam de permissão SELECT do Lake Formation.
+ O Spark faz com que write/delete os dados no S3 exijam a permissão Lake Formation ALL (SUPER).
+ Os trabalhos do Spark que interagem com o Catálogo de dados do Glue exigem as permissões DESCRIBE, ALTER, DROP, conforme apropriado.
Para obter mais informações, consulte [Conceder permissões em recursos do Catálogo de dados](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html).
### Etapa 3: inicializar uma sessão do Spark para acesso total à tabela usando o Lake Formation
#### Pré-requisitos
AWS O Glue Data Catalog deve ser configurado como um metastore para acessar as tabelas do Lake Formation.
Defina as seguintes configurações para configurar o catálogo do Glue como umo metastore:
```
--conf spark.sql.catalogImplementation=hive
--conf spark.hive.metastore.client.factory.class=com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory
```
Para obter mais informações sobre como habilitar o catálogo de dados para o Amazon EMR no EC2, consulte Configuração do [Metastore para o Amazon](metastore-config.html) EMR no EC2.
Para acessar tabelas registradas no AWS Lake Formation, as seguintes configurações precisam ser definidas durante a inicialização do Spark para configurar o Spark para usar as credenciais do Lake Formation AWS .
------
#### [ Hive ]
```
‐‐conf spark.hadoop.fs.s3.credentialsResolverClass=com.amazonaws.glue.accesscontrol.AWSLakeFormationCredentialResolver
--conf spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject=true
--conf spark.hadoop.fs.s3.folderObject.autoAction.disabled=true
--conf spark.sql.catalog.skipLocationValidationOnCreateTable.enabled=true
--conf spark.sql.catalog.createDirectoryAfterTable.enabled=true
--conf spark.sql.catalog.dropDirectoryBeforeTable.enabled=true
```
------
#### [ Iceberg ]
```
--conf spark.sql.catalog.spark_catalog=org.apache.iceberg.spark.SparkSessionCatalog
--conf spark.sql.catalog.spark_catalog.warehouse=S3_DATA_LOCATION
--conf spark.sql.catalog.spark_catalog.client.region=REGION
--conf spark.sql.catalog.spark_catalog.type=glue
--conf spark.sql.catalog.spark_catalog.glue.account-id=ACCOUNT_ID
--conf spark.sql.catalog.spark_catalog.glue.lakeformation-enabled=true
--conf spark.sql.catalog.dropDirectoryBeforeTable.enabled=true
```
------
#### [ Delta Lake ]
```
‐‐conf spark.hadoop.fs.s3.credentialsResolverClass=com.amazonaws.glue.accesscontrol.AWSLakeFormationCredentialResolver
--conf spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject=true
--conf spark.hadoop.fs.s3.folderObject.autoAction.disabled=true
--conf spark.sql.catalog.skipLocationValidationOnCreateTable.enabled=true
--conf spark.sql.catalog.createDirectoryAfterTable.enabled=true
--conf spark.sql.catalog.dropDirectoryBeforeTable.enabled=true
```
------
#### [ Hudi ]
```
‐‐conf spark.hadoop.fs.s3.credentialsResolverClass=com.amazonaws.glue.accesscontrol.AWSLakeFormationCredentialResolver
--conf spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject=true
--conf spark.hadoop.fs.s3.folderObject.autoAction.disabled=true
--conf spark.sql.catalog.skipLocationValidationOnCreateTable.enabled=true
--conf spark.sql.catalog.createDirectoryAfterTable.enabled=true
--conf spark.sql.catalog.dropDirectoryBeforeTable.enabled=true
--conf spark.jars=/usr/lib/hudi/hudi-spark-bundle.jar
--conf spark.sql.extensions=org.apache.spark.sql.hudi.HoodieSparkSessionExtension
--conf spark.sql.catalog.spark_catalog=org.apache.spark.sql.hudi.catalog.HoodieCatalog
--conf spark.serializer=org.apache.spark.serializer.KryoSerializer
```
------
+ `spark.hadoop.fs.s3.credentialsResolverClass=com.amazonaws.glue.accesscontrol.AWSLakeFormationCredentialResolver`: Configure o EMR Filesystem (EMRFS) ou o EMR S3A para usar as credenciais do Lake Formation S3 para tabelas registradas do Lake AWS Formation. Se a tabela não estiver registrada, use as credenciais do perfil de runtime do trabalho.
+ `spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject=true` e `spark.hadoop.fs.s3.folderObject.autoAction.disabled=true`: configure o EMRFS para usar o cabeçalho do tipo de conteúdo application/x-directory em vez do sufixo \$1folder\$1 ao criar pastas do S3. Isso é necessário ao ler tabelas do Lake Formation, pois as credenciais do Lake Formation não permitem a leitura de pastas de tabelas com o sufixo \$1folder\$1.
+ `spark.sql.catalog.skipLocationValidationOnCreateTable.enabled=true`: configure o Spark para ignorar a validação da ausência do local da tabela antes da criação. Isso é necessário para tabelas registradas do Lake Formation, pois as credenciais do Lake Formation para verificar o local vazio só estão disponíveis após a criação da tabela do Catálogo de dados do Glue. Sem essa configuração, as credenciais do perfil de runtime do trabalho validarão o local da tabela vazia.
+ `spark.sql.catalog.createDirectoryAfterTable.enabled=true`: configure o Spark para criar a pasta do Amazon S3 após a criação da tabela no metastore do Hive. Isso é necessário para tabelas registradas no Lake Formation, pois as credenciais do Lake Formation para criar a pasta do S3 só ficam disponíveis após a criação da tabela no Catálogo de dados do Glue.
+ `spark.sql.catalog.dropDirectoryBeforeTable.enabled=true`: configure o Spark para encerrar a pasta do S3 antes da exclusão da tabela no metastore do Hive. Isso é necessário para tabelas registradas do Lake Formation, pois as credenciais do Lake Formation para encerrar a pasta do S3 não estão disponíveis após a exclusão da tabela do Catálogo de dados do Glue.
+ `spark.sql.catalog..glue.lakeformation-enabled=true`: Configure o catálogo do Iceberg para usar as credenciais do AWS Lake Formation S3 para tabelas registradas do Lake Formation. Se a tabela não estiver registrada, use as credenciais de ambiente padrão.
#### Configurar o modo de acesso total à tabela no SageMaker Unified Studio
Para acessar as tabelas registradas do Lake Formation a partir de sessões interativas do Spark em JupyterLab notebooks, use o modo de permissão de compatibilidade. Use o comando mágico %%configure para definir sua configuração do Spark. Escolha a configuração com base no seu tipo de tabela:
------
#### [ For Hive tables ]
```
%%configure -f
{
"conf": {
"spark.hadoop.fs.s3.credentialsResolverClass": "com.amazonaws.glue.accesscontrol.AWSLakeFormationCredentialResolver",
"spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject": true,
"spark.hadoop.fs.s3.folderObject.autoAction.disabled": true,
"spark.sql.catalog.skipLocationValidationOnCreateTable.enabled": true,
"spark.sql.catalog.createDirectoryAfterTable.enabled": true,
"spark.sql.catalog.dropDirectoryBeforeTable.enabled": true
}
}
```
------
#### [ For Iceberg tables ]
```
%%configure -f
{
"conf": {
"spark.sql.catalog.spark_catalog": "org.apache.iceberg.spark.SparkSessionCatalog",
"spark.sql.catalog.spark_catalog.warehouse": "S3_DATA_LOCATION",
"spark.sql.catalog.spark_catalog.client.region": "REGION",
"spark.sql.catalog.spark_catalog.type": "glue",
"spark.sql.catalog.spark_catalog.glue.account-id": "ACCOUNT_ID",
"spark.sql.catalog.spark_catalog.glue.lakeformation-enabled": "true",
"spark.sql.catalog.dropDirectoryBeforeTable.enabled": "true",
}
}
```
------
#### [ For Delta Lake tables ]
```
%%configure -f
{
"conf": {
"spark.hadoop.fs.s3.credentialsResolverClass": "com.amazonaws.glue.accesscontrol.AWSLakeFormationCredentialResolver",
"spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject": true,
"spark.hadoop.fs.s3.folderObject.autoAction.disabled": true,
"spark.sql.catalog.skipLocationValidationOnCreateTable.enabled": true,
"spark.sql.catalog.createDirectoryAfterTable.enabled": true,
"spark.sql.catalog.dropDirectoryBeforeTable.enabled": true
}
}
```
------
#### [ For Hudi tables ]
```
%%configure -f
{
"conf": {
"spark.hadoop.fs.s3.credentialsResolverClass": "com.amazonaws.glue.accesscontrol.AWSLakeFormationCredentialResolver",
"spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject": true,
"spark.hadoop.fs.s3.folderObject.autoAction.disabled": true,
"spark.sql.catalog.skipLocationValidationOnCreateTable.enabled": true,
"spark.sql.catalog.createDirectoryAfterTable.enabled": true,
"spark.sql.catalog.dropDirectoryBeforeTable.enabled": true,
"spark.jars": "/usr/lib/hudi/hudi-spark-bundle.jar",
"spark.sql.extensions": "org.apache.spark.sql.hudi.HoodieSparkSessionExtension",
"spark.sql.catalog.spark_catalog": "org.apache.spark.sql.hudi.catalog.HoodieCatalog",
"spark.serializer": "org.apache.spark.serializer.KryoSerializer"
}
}
```
------
Substitua os espaços reservados:
+ `S3_DATA_LOCATION`: caminho do bucket do S3
+ `REGION`: AWS região (por exemplo, us-east-1)
+ `ACCOUNT_ID`: ID AWS da sua conta
**nota**
Você precisa definir essas configurações antes de executar qualquer operação do Spark em seu caderno.
#### Operações com Suporte
Essas operações usarão as credenciais do AWS Lake Formation para acessar os dados da tabela.
+ CRIAR TABELA
+ ALTER TABLE
+ INSERT INTO
+ INSERT OVERWRITE
+ UPDATE
+ MERGE INTO
+ DELETE FROM
+ ANALYZE TABLE
+ REPAIR TABLE
+ DESCARTAR TABELA
+ Consultas de fontes de dados do Spark
+ Gravações na fonte de dados do Spark
**nota**
As operações não listadas acima continuarão usando as permissões do IAM para acessar os dados da tabela.
#### Considerações
+ Se uma tabela do Hive for criada usando um trabalho que não tem acesso total à tabela habilitado e nenhum registro for inserido, as leituras ou gravações subsequentes de um trabalho com acesso total à tabela falharão. Isso ocorre porque o EMR Spark sem acesso total à tabela adiciona o sufixo `$folder$` ao nome da pasta da tabela. Para resolver isso, você tem as seguintes opções:
+ Insira pelo menos uma linha na tabela diretamente de um trabalho no qual o FTA não esteja habilitado.
+ Configure o trabalho no qual o FTA não está habilitado para não usar o sufixo `$folder$` no nome da pasta no S3. É possível fazer isso definindo a configuração `spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject=true` do Spark.
+ Crie uma pasta S3 no local da tabela `s3://path/to/table/table_name` usando o console AWS S3 ou a CLI do AWS S3.
+ O acesso total à tabela é compatível com o sistema de arquivos do EMR (EMRFS) a partir da versão 7.8.0 do Amazon EMR e com o sistema de arquivos S3A a partir da versão 7.10.0 do Amazon EMR.
+ O Full Table Access é compatível com as tabelas Hive, Iceberg, Delta e Hudi.
+ **Considerações sobre o Hudi FTA Write Support:**
+ As gravações do Hudi FTA exigem o uso HoodieCredentialedHadoopStorage para venda de credenciais durante a execução do trabalho. Defina a seguinte configuração ao executar trabalhos do Hudi: `hoodie.storage.class=org.apache.spark.sql.hudi.storage.HoodieCredentialedHadoopStorage`
+ O suporte de gravação do Full Table Access (FTA) para Hudi está disponível a partir da versão 7.12 do Amazon EMR.
+ Atualmente, o suporte de gravação do Hudi FTA funciona apenas com as configurações padrão do Hudi. As configurações Hudi personalizadas ou não padrão podem não ser totalmente compatíveis e podem resultar em um comportamento inesperado.
+ O agrupamento para tabelas Hudi Merge-On-Read (MOR) não é suportado neste momento no modo de gravação FTA.
+ Os trabalhos que mencionam tabelas com regras de controle de acesso de alta granularidade (FGAC) do Lake Formation ou visualizações do catálogo de dados do Glue falharão. Para consultar uma tabela com regras de FGAC ou uma visualização do Catálogo de dados do Glue, você precisará usar o modo FGAC. Você pode ativar o modo FGAC seguindo as etapas descritas na AWS documentação: Usando o [Amazon EMR no EC2 com o Lake AWS Formation](emr-serverless-lf-enable.html) para um controle de acesso refinado.
+ O acesso total à tabela não é compatível com Spark Streaming.
+ Ao gravar o Spark DataFrame em uma tabela do Lake Formation, somente o modo APPEND é compatível com as tabelas Hive e Iceberg: `df.write.mode("append").saveAsTable(table_name)`
+ A criação de tabelas externas requer permissões do IAM.
+ Como o Lake Formation armazena temporariamente as credenciais em um trabalho Spark, um trabalho em lote do Spark ou uma sessão interativa em execução no momento pode não refletir as alterações de permissão.
+ Você deve usar um perfil definido pelo usuário e não um perfil vinculado ao serviço:[Requisitos do Lake Formation para perfis](https://docs.aws.amazon.com/lake-formation/latest/dg/registration-role.html).
#### Hudi FTA Write Support - Operações suportadas
A tabela a seguir mostra as operações de gravação suportadas para tabelas Hudi Copy-On-Write (COW) e Merge-On-Read (MOR) no modo Full Table Access:
**Operações de gravação suportadas pelo Hudi FTA**
| Tipo de tabela | Operation | Comando SQL Write | Status |
| --- | --- | --- | --- |
| VACA | INSERT | INSERT INTO TABLE | Compatível |
| VACA | INSERT | INSERIR NA TABELA - PARTIÇÃO (estática, dinâmica) | Compatível |
| VACA | INSERT | INSERT OVERWRITE | Compatível |
| VACA | INSERT | INSERIR SUBSTITUIÇÃO - PARTIÇÃO (estática, dinâmica) | Compatível |
| UPDATE | UPDATE | UPDATE TABLE | Compatível |
| VACA | UPDATE | TABELA DE ATUALIZAÇÃO - Alterar partição | Não suportado |
| DELETE | DELETE | DELETE FROM TABLE | Compatível |
| ALTER | ALTER | ALTERAR TABELA - RENOMEAR PARA | Não suportado |
| VACA | ALTER | ALTERE A TABELA - DEFINA AS PROPRIEDADES DA TABELA | Compatível |
| VACA | ALTER | ALTERAR TABELA - DESDEFINIR TBLPROPERTIES | Compatível |
| VACA | ALTER | ALTERAR TABELA - ALTERAR COLUNA | Compatível |
| VACA | ALTER | ALTERAR TABELA - ADICIONAR COLUNAS | Compatível |
| VACA | ALTER | ALTERAR TABELA - ADICIONAR PARTIÇÃO | Compatível |
| VACA | ALTER | ALTERAR TABELA - SOLTAR PARTIÇÃO | Compatível |
| VACA | ALTER | ALTERAR TABELA - RECUPERAR PARTIÇÕES | Compatível |
| VACA | ALTER | REPARAR PARTIÇÕES DE SINCRONIZAÇÃO DE TABELAS | Compatível |
| DROP | DROP | DESCARTAR TABELA | Compatível |
| VACA | DROP | TABELA SUSPENSA - PURGA | Compatível |
| CREATE | CREATE | CRIAR TABELA - Gerenciado | Compatível |
| VACA | CREATE | CRIAR TABELA - PARTICIONAR POR | Compatível |
| VACA | CREATE | CRIAR TABELA SE NÃO EXISTIR | Compatível |
| VACA | CREATE | CREATE TABLE LIKE | Compatível |
| VACA | CREATE | CRIAR TABELA COMO SELEÇÃO | Compatível |
| CREATE | CREATE | CRIAR TABELA com LOCALIZAÇÃO - Tabela externa | Não suportado |
| QUADRO DE DADOS (INSERIR) | QUADRO DE DADOS (INSERIR) | saveAsTable.Sobrescrever | Compatível |
| VACA | QUADRO DE DADOS (INSERIR) | saveAsTable.Anexar | Não suportado |
| VACA | QUADRO DE DADOS (INSERIR) | saveAsTable.Ignorar | Compatível |
| VACA | QUADRO DE DADOS (INSERIR) | saveAsTable.ErrorIfExists | Compatível |
| VACA | QUADRO DE DADOS (INSERIR) | saveAsTable - Tabela externa (Caminho) | Não suportado |
| VACA | QUADRO DE DADOS (INSERIR) | salvar (caminho) - DF v1 | Não suportado |
| MAIS | INSERT | INSERT INTO TABLE | Compatível |
| MAIS | INSERT | INSERIR NA TABELA - PARTIÇÃO (estática, dinâmica) | Compatível |
| MAIS | INSERT | INSERT OVERWRITE | Compatível |
| MAIS | INSERT | INSERIR SUBSTITUIÇÃO - PARTIÇÃO (estática, dinâmica) | Compatível |
| UPDATE | UPDATE | UPDATE TABLE | Compatível |
| MAIS | UPDATE | TABELA DE ATUALIZAÇÃO - Alterar partição | Não suportado |
| DELETE | DELETE | DELETE FROM TABLE | Compatível |
| ALTER | ALTER | ALTERAR TABELA - RENOMEAR PARA | Não suportado |
| MAIS | ALTER | ALTERE A TABELA - DEFINA AS PROPRIEDADES DA TABELA | Compatível |
| MAIS | ALTER | ALTERAR TABELA - DESDEFINIR TBLPROPERTIES | Compatível |
| MAIS | ALTER | ALTERAR TABELA - ALTERAR COLUNA | Compatível |
| MAIS | ALTER | ALTERAR TABELA - ADICIONAR COLUNAS | Compatível |
| MAIS | ALTER | ALTERAR TABELA - ADICIONAR PARTIÇÃO | Compatível |
| MAIS | ALTER | ALTERAR TABELA - SOLTAR PARTIÇÃO | Compatível |
| MAIS | ALTER | ALTERAR TABELA - RECUPERAR PARTIÇÕES | Compatível |
| MAIS | ALTER | REPARAR PARTIÇÕES DE SINCRONIZAÇÃO DE TABELAS | Compatível |
| DROP | DROP | DESCARTAR TABELA | Compatível |
| MAIS | DROP | TABELA SUSPENSA - PURGA | Compatível |
| CREATE | CREATE | CRIAR TABELA - Gerenciado | Compatível |
| MAIS | CREATE | CRIAR TABELA - PARTICIONAR POR | Compatível |
| MAIS | CREATE | CRIAR TABELA SE NÃO EXISTIR | Compatível |
| MAIS | CREATE | CREATE TABLE LIKE | Compatível |
| MAIS | CREATE | CRIAR TABELA COMO SELEÇÃO | Compatível |
| CREATE | CREATE | CRIAR TABELA com LOCALIZAÇÃO - Tabela externa | Não suportado |
| QUADRO DE DADOS (UPSERT) | QUADRO DE DADOS (UPSERT) | saveAsTable.Sobrescrever | Compatível |
| MAIS | QUADRO DE DADOS (UPSERT) | saveAsTable.Anexar | Não suportado |
| MAIS | QUADRO DE DADOS (UPSERT) | saveAsTable.Ignorar | Compatível |
| MAIS | QUADRO DE DADOS (UPSERT) | saveAsTable.ErrorIfExists | Compatível |
| MAIS | QUADRO DE DADOS (UPSERT) | saveAsTable - Tabela externa (Caminho) | Não suportado |
| MAIS | QUADRO DE DADOS (UPSERT) | salvar (caminho) - DF v1 | Não suportado |
| DATAFRAME (EXCLUIR) | DATAFRAME (EXCLUIR) | saveAsTable.Anexar | Não suportado |
| MAIS | DATAFRAME (EXCLUIR) | saveAsTable - Tabela externa (Caminho) | Não suportado |
| MAIS | DATAFRAME (EXCLUIR) | salvar (caminho) - DF v1 | Não suportado |
| QUADRO DE DADOS (BULK\$1INSERT) | QUADRO DE DADOS (BULK\$1INSERT) | saveAsTable.Sobrescrever | Compatível |
| MAIS | QUADRO DE DADOS (BULK\$1INSERT) | saveAsTable.Anexar | Não suportado |
| MAIS | QUADRO DE DADOS (BULK\$1INSERT) | saveAsTable.Ignorar | Compatível |
| MAIS | QUADRO DE DADOS (BULK\$1INSERT) | saveAsTable.ErrorIfExists | Compatível |
| MAIS | QUADRO DE DADOS (BULK\$1INSERT) | saveAsTable - Tabela externa (Caminho) | Não suportado |
| MAIS | QUADRO DE DADOS (BULK\$1INSERT) | salvar (caminho) - DF v1 | Não suportado |