Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Integra Amazon EMR con AWS Lake Formation
AWS Lake Formation è un servizio gestito che ti aiuta a scoprire, catalogare, pulire e proteggere i dati in un data lake Amazon Simple Storage Service (S3). Lake Formation fornisce un accesso granulare a livello di colonna, riga o cella a database e tabelle nel AWS Glue Data Catalog. Per maggiori informazioni, consulta [Che cos’è AWS Lake Formation?](https://docs.aws.amazon.com/lake-formation/latest/dg/what-is-lake-formation.html)
Con Amazon EMR versione 6.7.0 e successive, puoi applicare il controllo degli accessi basato su Lake Formation ai processi Spark, Hive e Presto inviati ai cluster Amazon EMR. Per l'integrazione con Lake Formation, devi creare un cluster EMR con un *ruolo di runtime*. Un ruolo di runtime è un ruolo AWS Identity and Access Management (IAM) che puoi associare ai processi o alle query di Amazon EMR. Amazon EMR utilizza quindi questo ruolo per accedere AWS alle risorse. Per ulteriori informazioni, consulta [Ruoli di runtime per le fasi di Amazon EMR](emr-steps-runtime-roles.md).
## Funzionamento di Amazon EMR con Lake Formation
[Dopo aver integrato Amazon EMR con Lake Formation, puoi eseguire query sui cluster Amazon EMR con l'`Step`API o con AI Studio.](https://docs.aws.amazon.com/emr/latest/APIReference/API_Step.html) SageMaker Quindi, Lake Formation fornisce l'accesso ai dati tramite credenziali temporanee per Amazon EMR. Questo processo è denominato distribuzione di credenziali. Per maggiori informazioni, consulta [Che cos’è AWS Lake Formation?](https://docs.aws.amazon.com/lake-formation/latest/dg/what-is-lake-formation.html)
Di seguito è riportata una panoramica generale sul modo in cui Amazon EMR ottiene l'accesso ai dati protetti dalle policy di sicurezza Lake Formation.
![\[In che modo Amazon EMR accede ai dati protetti dalle policy di sicurezza di Lake Formation\]](http://docs.aws.amazon.com/it_it/emr/latest/ManagementGuide/images/lf-emr-security.png)
1. Un utente invia una query Amazon EMR per i dati in Lake Formation.
1. Amazon EMR richiede le credenziali temporanee da Lake Formation per consentire all'utente di accedere ai dati.
1. Lake Formation restituisce le credenziali temporanee.
1. Amazon EMR invia la richiesta di query per recuperare dati da Amazon S3.
1. Amazon EMR riceve i dati da Amazon S3, li filtra e restituisce i risultati in base alle autorizzazioni utente definite in Lake Formation.
Per ulteriori informazioni sull'aggiunta di utenti e gruppi ai policy di Lake Formation, consulta [Concessione delle autorizzazioni Data Catalog](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html).
## Prerequisiti
Prima di integrare Amazon EMR e Lake Formation, è necessario soddisfare i seguenti requisiti:
+ Attiva l'autorizzazione dei ruoli di runtime sul cluster Amazon EMR.
+ Usa il AWS Glue Data Catalog come archivio di metadati.
+ Definisci e gestisci le autorizzazioni in Lake Formation per accedere a database, tabelle e colonne in AWS Glue Data Catalog. Per maggiori informazioni, consulta [Che cos’è AWS Lake Formation?](https://docs.aws.amazon.com/lake-formation/latest/dg/what-is-lake-formation.html)
# Accesso a grana fine con Lake Formation
Le versioni 6.15.0 e successive di Amazon EMR includono il supporto per il controllo granulare degli accessi a livello di riga, colonna o cella basato su Lake Formation. AWS Gli argomenti di questa sezione spiegano come accedere alle tabelle del catalogo Glue Data protette da Lake Formation dai job EMR Spark o dalle sessioni interattive con controllo degli accessi granulare.
# Abilitazione di Amazon EMR con Lake Formation
Con Amazon EMR 6.15.0 e versioni successive, quando esegui job Spark su Amazon EMR su cluster EC2 che accedono ai dati nel AWS Glue Data Catalog, puoi AWS Lake Formation utilizzare per applicare autorizzazioni a livello di tabella, riga, colonna e cella su tabelle basate su Hudi, Iceberg o Delta Lake.
Questa sezione illustra come creare una configurazione di sicurezza e impostare Lake Formation per l'utilizzo con Amazon EMR. Descrive inoltre come avviare un cluster con la configurazione di sicurezza creata per Lake Formation.
## Passaggio 1: Impostazione di un ruolo di runtime per il cluster EMR
Per utilizzare un ruolo di runtime per il cluster EMR, devi prima creare una configurazione di sicurezza. Con una configurazione di sicurezza puoi applicare opzioni di sicurezza, autorizzazione e autenticazione coerenti in tutti i tuoi cluster.
1. Crea un file denominato `lf-runtime-roles-sec-cfg.json` con la seguente configurazione di sicurezza.
```
{
"AuthorizationConfiguration": {
"IAMConfiguration": {
"EnableApplicationScopedIAMRole": true,
"ApplicationScopedIAMRoleConfiguration": {
"PropagateSourceIdentity": true
}
},
"LakeFormationConfiguration": {
"AuthorizedSessionTagValue": "Amazon EMR"
}
},
"EncryptionConfiguration": {
"EnableAtRestEncryption": false,
"EnableInTransitEncryption": true,
"InTransitEncryptionConfiguration": {
"TLSCertificateConfiguration": {}
}
}
}
```
L'esempio seguente illustra come utilizzare un file zip con certificati in Amazon S3 per la configurazione dei certificati:
+ Un file zip con certificati in Amazon S3 viene utilizzato come fornitore di chiavi. (Vedi [Fornitura di certificati per la crittografia di dati in transito con Amazon EMR](emr-encryption-enable.md#emr-encryption-certificates) per i requisiti dei certificati).
```
"TLSCertificateConfiguration": {
"CertificateProviderType": "PEM",
"S3Object": "s3://MyConfigStore/artifacts/MyCerts.zip"
}
```
L'esempio seguente illustra come utilizzare un provider di chiavi personalizzate per la configurazione dei certificati:
+ Viene utilizzato un provider di chiavi personalizzato. (Vedi [Fornitura di certificati per la crittografia di dati in transito con Amazon EMR](emr-encryption-enable.md#emr-encryption-certificates) per i requisiti del certificato).
```
"TLSCertificateConfiguration": {
"CertificateProviderType": "Custom",
"S3Object": "s3://MyConfig/artifacts/MyCerts.jar",
"CertificateProviderClass": "com.mycompany.MyCertProvider"
}
```
1. Quindi, per assicurarti che il tag di sessione possa autorizzare Lake Formation, imposta la proprietà `LakeFormationConfiguration/AuthorizedSessionTagValue` su `Amazon EMR`.
1. Utilizza il seguente comando per creare una configurazione di sicurezza Amazon EMR.
```
aws emr create-security-configuration \
--name 'iamconfig-with-iam-lf' \
--security-configuration file://lf-runtime-roles-sec-cfg.json
```
In alternativa, puoi utilizzare la [console Amazon EMR](https://console.aws.amazon.com//emr) per creare una configurazione di sicurezza con impostazioni personalizzate.
## Fase 2: avvio di un cluster Amazon EMR
Ora puoi avviare un cluster EMR con la configurazione di sicurezza creata nel passaggio precedente. Per ulteriori informazioni sulle configurazioni di sicurezza, consulta le sezioni [Usa le configurazioni di sicurezza per configurare la sicurezza dei cluster Amazon EMR](emr-security-configurations.md) e [Ruoli di runtime per le fasi di Amazon EMR](emr-steps-runtime-roles.md).
## Fase 3: configurare le autorizzazioni a livello di colonna, riga o cella basate su Lake Formation con i ruoli di runtime di Amazon EMR
Per applicare un controllo granulare degli accessi a livello di colonna, riga o cella con Lake Formation, l'amministratore del data lake per Lake Formation deve impostare `Amazon EMR` come valore per la configurazione del tag di sessione,. `AuthorizedSessionTagValue` Lake Formation utilizza questo tag di sessione per autorizzare i chiamanti e fornire l'accesso al data lake. Puoi impostare questo tag di sessione nella sezione **Impostazioni di integrazione dell'applicazione** della console Lake Formation. Sostituiscilo *123456789012* con il tuo Account AWS ID.
## Fase 4: Configurazione delle sovvenzioni AWS Glue and Lake Formation per i ruoli di runtime di Amazon EMR
Per continuare con la configurazione del controllo degli accessi basato su Lake Formation con i ruoli di runtime di Amazon EMR, devi configurare le sovvenzioni AWS Glue and Lake Formation per i ruoli di runtime di Amazon EMR. Per permettere ai ruoli di runtime IAM di interagire con Lake Formation, concedi loro l'accesso con `lakeformation:GetDataAccess` e `glue:Get*`.
Le autorizzazioni di Lake Formation controllano l'accesso alle risorse di AWS Glue Data Catalog, alle sedi Amazon S3 e ai dati sottostanti in tali sedi. Le autorizzazioni IAM controllano l'accesso a Lake Formation and AWS Glue APIs e alle risorse. Anche se disponi dell'autorizzazione di Lake Formation per accedere a una tabella nel catalogo dati (SELECT), l'operazione fallisce se non disponi dell'autorizzazione IAM per l'API `glue:Get*`. Per maggiori dettagli sul controllo degli accessi in Lake Formation, consulta la sezione [Lake Formation access control overview](https://docs.aws.amazon.com/lake-formation/latest/dg/lf-permissions-overview.html) (Panoramica del controllo degli accessi a Lake Formation).
1. Crea il file `emr-runtime-roles-lake-formation-policy.json` con i seguenti contenuti.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "LakeFormationManagedAccess",
"Effect": "Allow",
"Action": [
"lakeformation:GetDataAccess",
"glue:Get*",
"glue:Create*",
"glue:Update*"
],
"Resource": [
"*"
]
}
]
}
```
------
1. Crea la policy IAM correlata.
```
aws iam create-policy \
--policy-name emr-runtime-roles-lake-formation-policy \
--policy-document file://emr-runtime-roles-lake-formation-policy.json
```
1. Per assegnare questa policy ai ruoli di runtime IAM, segui i passaggi in [Managing AWS Lake Formation permissions](https://docs.aws.amazon.com/lake-formation/latest/dg/managing-permissions.html).
Ora puoi utilizzare i ruoli di runtime e Lake Formation per applicare le autorizzazioni a livello di tabella e colonna. Puoi anche utilizzare un'identità di origine per controllare le azioni e monitorare le operazioni con AWS CloudTrail.
Per ogni ruolo IAM che intendi utilizzare come ruolo di runtime, imposta la seguente policy di attendibilità, sostituendo `EMR_EC2_DefaultRole` con il ruolo del profilo dell'istanza. Per modificare la policy di attendibilità di un ruolo IAM, consulta [Modifica di una policy di attendibilità del ruolo](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"
]
}
```
Per un end-to-end esempio dettagliato, consulta [Introducing runtime roles for Amazon EMR steps.](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/)
Per informazioni su come integrare Iceberg e AWS Glue Data Catalog per una gerarchia multicatalogo, vedi [Configurare Spark per accedere a una gerarchia multicatalogo in Glue Data Catalog](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-multi-catalog.html#emr-lakehouse-using-spark-access). AWS
# Supporto per il formato a tabella aperta
Le versioni 6.15.0 e successive di Amazon EMR includono il supporto per il controllo granulare degli accessi basato su tabelle Hive, Apache Iceberg, Apache Hudi e Delta Lake durante la lettura e la scrittura di dati AWS Lake Formation con Spark SQL. Amazon EMR supporta il controllo degli accessi a livello di tabella, riga, colonna e cella con Apache Hudi. Le versioni 6.15.0 e successive di Amazon EMR includono il supporto per il controllo granulare degli accessi a livello di riga, colonna o cella basato su Lake Formation. AWS A partire da EMR 7.12, le operazioni DML e DDL che modificano i dati delle tabelle sono supportate per le tabelle Apache Hive, Apache Iceberg e Delta Lake utilizzando le credenziali vendute di Lake Formation.
Gli argomenti di questa sezione spiegano come accedere alle tabelle registrate di Lake Formation in formati di tabelle aperte dai job EMR Spark o dalle sessioni interattive con controllo degli accessi granulare.
## Requisiti per l'autorizzazione
### Tabelle non registrate in AWS Lake Formation
Per le tabelle non registrate con AWS Lake Formation, il ruolo di job runtime accede sia al AWS Glue Data Catalog che ai dati della tabella sottostante in Amazon S3. Ciò richiede che il ruolo di job runtime disponga delle autorizzazioni IAM appropriate per le operazioni di AWS Glue e Amazon S3.
### Tabelle registrate in AWS Lake Formation
Per le tabelle registrate con AWS Lake Formation, il ruolo di job runtime accede ai metadati di AWS Glue Data Catalog, mentre le credenziali temporanee fornite da Lake Formation accedono ai dati della tabella sottostante in Amazon S3. Le autorizzazioni Lake Formation necessarie per eseguire un'operazione dipendono dalle chiamate API di AWS Glue Data Catalog e Amazon S3 avviate dal job Spark e possono essere riassunte come segue:
+ L'autorizzazione **DESCRIBE** consente al ruolo di runtime di leggere i metadati della tabella o del database nel Data Catalog
+ L'autorizzazione **ALTER** consente al ruolo di runtime di modificare i metadati di tabelle o database nel Data Catalog
+ L'autorizzazione **DROP** consente al ruolo di runtime di eliminare i metadati di tabelle o database dal Data Catalog
+ L'autorizzazione **SELECT** consente al ruolo di runtime di leggere i dati della tabella da Amazon S3
+ L'autorizzazione **INSERT** consente al ruolo di runtime di scrivere dati di tabella su Amazon S3
+ L'autorizzazione **DELETE** consente al ruolo di runtime di eliminare i dati della tabella da Amazon S3
**Nota**
Lake Formation valuta le autorizzazioni pigramente quando un job Spark chiama AWS Glue per recuperare i metadati della tabella e Amazon S3 per recuperare i dati della tabella. I lavori che utilizzano un ruolo di runtime con autorizzazioni insufficienti non falliranno finché Spark non effettuerà una chiamata AWS Glue o Amazon S3 che richiede l'autorizzazione mancante.
**Nota**
Nella seguente matrice di tabelle supportata:
Le operazioni **contrassegnate come Supported** utilizzano esclusivamente le credenziali di Lake Formation per accedere ai dati delle tabelle per le tabelle registrate con Lake Formation. Se le autorizzazioni di Lake Formation sono insufficienti, l'operazione non ricorrerà alle credenziali del ruolo di runtime. Per le tabelle non registrate con Lake Formation, le credenziali del ruolo di job runtime accedono ai dati della tabella.
Le operazioni **contrassegnate come Supportate con autorizzazioni IAM sulla posizione Amazon S3** non utilizzano le credenziali di Lake Formation per accedere ai dati delle tabelle sottostanti in Amazon S3. Per eseguire queste operazioni, il ruolo di job runtime deve disporre delle autorizzazioni IAM di Amazon S3 necessarie per accedere ai dati della tabella, indipendentemente dal fatto che la tabella sia registrata con Lake Formation.
------
#### [ Hive ]
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/emr/latest/ManagementGuide/emr-lf-fgac1.html)
------
#### [ Iceberg ]
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/emr/latest/ManagementGuide/emr-lf-fgac1.html)
**Configurazione Spark per Iceberg:** Se desideri utilizzare il formato Iceberg, imposta le seguenti configurazioni. Sostituisci `DB_LOCATION` con il percorso Amazon S3 in cui si trovano le tabelle Iceberg e sostituisci i segnaposto per regione e ID account con i tuoi valori.
```
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 desideri utilizzare il formato Iceberg nelle versioni precedenti di EMR, usa invece il seguente 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
```
**Esempi:**
Ecco alcuni esempi di utilizzo delle tabelle 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/it_it/emr/latest/ManagementGuide/emr-lf-fgac1.html)
**Configurazione Spark per Hudi:**
Per avviare la shell Spark su EMR 7.10 o versioni successive, usa il seguente comando:
```
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
```
Per avviare la shell Spark su versioni EMR precedenti, usa invece il comando seguente:
```
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
```
**Esempi:**
Ecco alcuni esempi di utilizzo delle tabelle 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;
```
Per interrogare l'ultima istantanea delle copy-on-write tabelle:
```
SELECT * FROM my_hudi_cow_table
```
```
spark.read.table("my_hudi_cow_table")
```
Per eseguire query sui dati compatti più recenti delle tabelle `MOR`, puoi eseguire query sulla tabella ottimizzata per la lettura che presenta il suffisso con `_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/it_it/emr/latest/ManagementGuide/emr-lf-fgac1.html)
**Configurazione Spark per Delta Lake:**
Per usare Delta Lake with Lake Formation su EMR 7.10 e versioni successive, esegui il seguente comando:
```
spark-sql \
--conf spark.sql.extensions=io.delta.sql.DeltaSparkSessionExtension \
--conf spark.sql.catalog.spark_catalog=org.apache.spark.sql.delta.catalog.DeltaCatalog
```
Per utilizzare Delta Lake with Lake Formation su EMR da 6.15 a 7.9, esegui quanto segue
```
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 desideri che Lake Formation utilizzi il server di registrazione per gestire il tuo catalogo Spark, imposta su `spark.sql.catalog..lf.managed` true.
**Esempi:**
Ecco alcuni esempi di utilizzo delle tabelle 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 *;
```
**Creazione di una tabella Delta Lake in AWS Glue Data Catalog**
Amazon EMR with Lake Formation non supporta i comandi DDL e la creazione di tabelle Delta nelle versioni EMR precedenti alla 7.12. Segui questi passaggi per creare tabelle nel AWS Glue Data Catalog.
1. Usa l'esempio seguente per creare una tabella Delta. Assicurati che la tua posizione S3 esista.
```
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. Per vedere i dettagli della tua tabella, vai a [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Nella barra di navigazione a sinistra, espandi **Data Catalog**, scegli **Tabelle**, quindi scegli la tabella che hai creato. In **Schema**, dovresti vedere che la tabella Delta che hai creato con Spark memorizza tutte le colonne in un tipo di dati di `array` AWS Glue.
1. Per definire filtri a livello di colonna e cella in Lake Formation, rimuovi la `col` colonna dallo schema, quindi aggiungi le colonne presenti nello schema della tabella. In questo esempio, aggiungi le colonne `x``y`, e. `z`
------
Con questa funzionalità, è possibile eseguire query istantanee sulle copy-on-write tabelle per interrogare l'istantanea più recente della tabella in un determinato commit o istante di compattazione. Attualmente, un cluster Amazon EMR abilitato a Lake Formation deve recuperare la colonna del tempo di commit di Hudi per eseguire query incrementali e query sui viaggi nel tempo. Non supporta la sintassi e la funzione di Spark. `timestamp as of` `Spark.read()` La sintassi corretta è. `select * from table where _hoodie_commit_time <= point_in_time` Per ulteriori informazioni, vedere [Query Point in time Time-Travel sulla](https://cwiki.apache.org/confluence/display/HUDI/RFC+-+07+%3A+Point+in+time+Time-Travel+queries+on+Hudi+table) tabella Hudi.
**Nota**
Le prestazioni delle letture possono essere più lente nei cluster Lake Formation a causa di ottimizzazioni non supportate. Queste funzioni includono l'elenco dei file basato sui metadati Hudi e i dati ignorati. È preferibile testare le prestazioni dell'applicazione per accertarsi che soddisfi i requisiti.
# Utilizzo delle viste del catalogo dati di Glue in Amazon EMR
**Nota**
La creazione e AWS la gestione delle viste di Glue Data Catalog da utilizzare con EMR su EC2 è disponibile con Amazon [EMR](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-7100-release.html) release 7.10.0 e successive.
Puoi creare e gestire viste nel AWS Glue Data Catalog da utilizzare con EMR su EC2. Queste sono note comunemente come viste del AWS Glue Data Catalog. Queste viste sono utili perché supportano più motori di query SQL, quindi puoi accedere alla stessa vista su AWS servizi diversi, come EMR su EC2 e Amazon Amazon Athena Redshift.
Creando una vista nel Data Catalog, puoi utilizzare le concessioni di risorse e i controlli di accesso basati su tag per concedere l'accesso AWS Lake Formation ad essa. Utilizzando questo metodo di controllo degli accessi, non è necessario configurare un accesso aggiuntivo alle tabelle a cui hai fatto riferimento durante la creazione della vista. Questo metodo di concessione delle autorizzazioni è chiamato semantica, mentre queste viste sono chiamate viste del definitore. Per ulteriori informazioni sul controllo degli accessi in Lake Formation, consulta [Concessione e revoca delle autorizzazioni sulle risorse del Data Catalog](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html) nella AWS Lake Formation Developer Guide.
Le viste del Catalogo dati sono utili per i seguenti casi d'uso:
+ **Controllo granulare degli accessi**: è possibile creare una vista che limiti l'accesso ai dati in base alle autorizzazioni necessarie per l'utente. Ad esempio, puoi utilizzare le viste nel Catalogo dati per impedire ai dipendenti che non lavorano nel reparto delle risorse umane di visualizzare le informazioni di identificazione personale (PII).
+ **Definizione completa della vista**: applicando filtri alla visualizzazione nel Data Catalog, ti assicuri che i record di dati disponibili in una visualizzazione del Data Catalog siano sempre completi.
+ **Sicurezza avanzata**: la definizione della query utilizzata per creare la vista deve essere completa. Questo vantaggio significa che le visualizzazioni del Data Catalog sono meno suscettibili ai comandi SQL di attori malintenzionati.
+ **Condivisione semplice dei dati**: condividi i dati con altri AWS account senza spostare i dati. Per ulteriori informazioni, consulta [Condivisione dei dati tra account in Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/cross-account-permissions.html).
## Creazione di una vista di Catalogo Dati
Esistono diversi modi per creare una visualizzazione del catalogo dati. Questi includono l'utilizzo di AWS CLI o Spark SQL. Seguono alcuni esempi.
------
#### [ Using SQL ]
Di seguito viene illustrata la sintassi per la creazione di una vista del catalogo dati. Nota il tipo di `MULTI DIALECT` visualizzazione. Ciò distingue la vista del catalogo dati dalle altre viste. Il `SECURITY` predicato è specificato come. `DEFINER` Ciò indica una vista del catalogo dati con `DEFINER` semantica.
```
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;
```
Di seguito è riportato un esempio di `CREATE` dichiarazione, che segue la sintassi:
```
CREATE PROTECTED MULTI DIALECT VIEW catalog_view
SECURITY DEFINER
AS
SELECT order_date, sum(totalprice) AS price
FROM source_table
GROUP BY order_date
```
È inoltre possibile creare una vista in modalità dry-run, utilizzando SQL, per testare la creazione della vista, senza creare effettivamente la risorsa. L'utilizzo di questa opzione comporta una «esecuzione a secco» che convalida l'input e, se la convalida ha esito positivo, restituisce il JSON dell'oggetto della tabella AWS Glue che rappresenterà la vista. In questo caso, la visualizzazione effettiva non viene creata.
```
CREATE [ OR REPLACE ] PROTECTED MULTI DIALECT VIEW view_name
SECURITY DEFINER
[ SHOW VIEW JSON ]
AS view-sql
```
------
#### [ Using the AWS CLI ]
**Nota**
Quando si utilizza il comando CLI, l'SQL utilizzato per creare la vista non viene analizzato. Ciò può causare un caso in cui la vista viene creata, ma le query non hanno esito positivo. Assicurati di testare la sintassi SQL prima di creare la vista.
Utilizzate il seguente comando CLI per creare una vista:
```
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"
}
]
}
}
}'
```
------
## Operazioni supportate per le viste
I seguenti frammenti di comandi mostrano vari modi di lavorare con le viste nel Catalogo dati:
+ **CREA VISTA**
Crea una vista data-catalog. Di seguito è riportato un esempio che mostra la creazione di una vista da una tabella esistente:
```
CREATE PROTECTED MULTI DIALECT VIEW catalog_view
SECURITY DEFINER AS SELECT * FROM my_catalog.my_database.source_table
```
+ **ALTER VIEW**
Sintassi disponibile:
+ `ALTER VIEW view_name [FORCE] ADD DIALECT AS query`
+ `ALTER VIEW view_name [FORCE] UPDATE DIALECT AS query`
+ `ALTER VIEW view_name DROP DIALECT`
È possibile utilizzare l'opzione `FORCE ADD DIALECT` per forzare l'aggiornamento dello schema e degli oggetti secondari secondo il nuovo dialetto del motore. Tieni presente che questa operazione può causare errori di query se non utilizzi anche `FORCE` per aggiornare altri dialetti del motore. Di seguito è riportato un esempio:
```
ALTER VIEW catalog_view FORCE ADD DIALECT
AS
SELECT order_date, sum(totalprice) AS price
FROM source_table
GROUP BY orderdate;
```
Quello che segue è un esempio di come modificare una vista per aggiornare il dialetto:
```
ALTER VIEW catalog_view UPDATE DIALECT AS
SELECT count(*) FROM my_catalog.my_database.source_table;
```
+ **DESCRIVI LA VISTA**
Sintassi disponibile per descrivere una vista:
+ `SHOW COLUMNS {FROM|IN} view_name [{FROM|IN} database_name]`— Se l'utente dispone delle autorizzazioni AWS Glue and Lake Formation necessarie per descrivere la vista, può elencare le colonne. Di seguito sono riportati un paio di comandi di esempio per la vista delle colonne:
```
SHOW COLUMNS FROM my_database.source_table;
SHOW COLUMNS IN my_database.source_table;
```
+ `DESCRIBE view_name`— Se l'utente dispone delle autorizzazioni AWS Glue and Lake Formation necessarie per descrivere la vista, può elencare le colonne della vista insieme ai relativi metadati.
+ **ELIMINA VISTA**
Sintassi disponibile:
+ `DROP VIEW [ IF EXISTS ] view_name`
L'esempio seguente mostra un'istruzione `DROP` che verifica l'esistenza di una vista prima di eliminarla:
```
DROP VIEW IF EXISTS catalog_view;
```
+ **MOSTRA CREA VISUALIZZAZIONE**
+ `SHOW CREATE VIEW view_name`: mostra l'istruzione SQL che crea la vista specificata. Di seguito è riportato un esempio che mostra la creazione di una vista data-catalog:
```
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)
```
+ **MOSTRA VISUALIZZAZIONI**
Elenca tutte le viste del catalogo, ad esempio viste regolari, visualizzazioni multidialettali (MDV) e MDV senza dialetto Spark. La sintassi disponibile è la seguente:
+ `SHOW VIEWS [{ FROM | IN } database_name] [LIKE regex_pattern]`:
Il seguente è un comando di esempio per mostrare le viste:
```
SHOW VIEWS IN marketing_analytics LIKE 'catalog_view*';
```
Per ulteriori informazioni sulla creazione e la configurazione delle viste del catalogo dati, consulta Building [AWS Glue Data Catalog views](https://docs.aws.amazon.com/lake-formation/latest/dg/working-with-views.html) nella Developer Guide. AWS Lake Formation
## Interrogazione di una vista di Catalogo Dati
Dopo aver creato una vista del catalogo dati, puoi interrogarla utilizzando un job Amazon EMR Spark con controllo granulare degli accessi AWS Lake Formation abilitato. Il ruolo di job runtime deve disporre dell'`SELECT`autorizzazione Lake Formation per la visualizzazione Data Catalog. Non è necessario concedere l'accesso alle tabelle sottostanti a cui si fa riferimento nella vista.
Dopo aver impostato tutto, è possibile eseguire query sulla vista. Ad esempio, dopo aver creato un'applicazione Amazon EMR in EMR Studio, puoi eseguire la seguente query per accedere a una vista.
```
SELECT * from my_database.catalog_view LIMIT 10;
```
Una funzione utile è la. `invoker_principal` Restituisce l'identificatore univoco del ruolo EMRS Job Runtime. Questo può essere usato per controllare l'output della vista, in base al principio di invocazione. Puoi usarlo per aggiungere una condizione nella tua vista che perfeziona i risultati della query, in base al ruolo chiamante. Il ruolo di job runtime deve disporre dell'autorizzazione all'azione `LakeFormation:GetDataLakePrincipal` IAM per utilizzare questa funzione.
```
select invoker_principal();
```
È possibile aggiungere questa funzione a una `WHERE` clausola, ad esempio, per perfezionare i risultati delle query.
## Considerazioni e limitazioni
Quando si creano viste del catalogo dati, si applica quanto segue:
+ Puoi creare viste del catalogo dati solo con Amazon EMR 7.10 e versioni successive.
+ Il definitore della vista di Catalogo dati deve avere l'accesso `SELECT` alle tabelle di base sottostanti a cui la vista accede. La creazione della vista di Catalogo dati non riesce se una tabella base specifica ha dei filtri Lake Formation imposti sul ruolo del definitore.
+ Le tabelle di base non devono avere l'autorizzazione del `IAMAllowedPrincipals` data lake in Lake Formation. Se presente, si verifica l'errore *Multi Dialect views può fare riferimento solo a tabelle senza le autorizzazioni IAMAllowed Principal.*
+ La posizione Amazon S3 della tabella deve essere registrata come posizione del data lake. Se la tabella non è registrata, si verifica l'errore Le *viste multidialettali possono fare riferimento solo alle tabelle gestite da Lake Formation*. Per informazioni su come registrare le sedi Amazon S3 in Lake Formation, consulta [Registrazione di una sede Amazon S3](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html) nella Developer Guide. AWS Lake Formation
+ Puoi creare solo viste `PROTECTED` in Catalogo dati. Le viste `UNPROTECTED` non sono supportate.
+ Non puoi fare riferimento alle tabelle di un altro AWS account in una definizione di visualizzazione del catalogo dati. Inoltre, non puoi fare riferimento a una tabella nello stesso account che si trova in una Regione separata.
+ Per condividere i dati tra un account o un'area geografica, l'intera visualizzazione deve essere condivisa tra account e regioni, utilizzando i link alle risorse di Lake Formation.
+ Le funzioni definite dall'utente (UDFs) non sono supportate.
+ È possibile utilizzare viste basate sulle tabelle Iceberg. Sono supportati anche i formati a tabella aperta Apache Hudi e Delta Lake.
+ Le viste di Catalogo Dati non possono fare riferimento ad altre viste.
+ Lo schema di visualizzazione di AWS Glue Data Catalog viene sempre memorizzato in lettere minuscole. Ad esempio, se si utilizza un'istruzione DDL per creare una vista del Glue Data Catalog con una colonna denominata`Castle`, la colonna creata nel Glue Data Catalog verrà composta in minuscolo, to. `castle` Se poi si specifica il nome della colonna in una query DML come `Castle` o`CASTLE`, EMR Spark renderà il nome in minuscolo per eseguire la query. Tuttavia, l'intestazione della colonna viene visualizzata utilizzando il maiuscolo specificato nella query.
Se si desidera che una query abbia esito negativo nel caso in cui il nome di colonna specificato nella query DML non corrisponda al nome della colonna nel Glue Data Catalog, è possibile impostare`spark.sql.caseSensitive=true`.
# Considerazioni su Amazon EMR con Lake Formation
Amazon EMR with Lake Formation è disponibile in tutte le regioni [disponibili](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-region.html).
## Considerazioni per Amazon EMR with Lake Formation per la versione 7.9 e precedenti
Considerare quanto segue quando AWS Lake Formation si utilizza EMR 7.9 e versioni precedenti.
+ Il [controllo granulare degli accessi](emr-lf-enable.md#emr-lf-fgac-perms) è disponibile sui cluster con Amazon EMR versioni 6.15 e successive.
+ Gli utenti con accesso a una tabella possono accedere a tutte le sue proprietà. Se disponi di un controllo degli accessi basato su Lake Formation su una tabella, controlla la tabella per assicurarti che le proprietà non contengano dati o informazioni sensibili.
+ I cluster Amazon EMR con Lake Formation non supportano il fallback di Spark su HDFS quando Spark raccoglie le statistiche delle tabelle. Questo di solito aiuta a ottimizzare le prestazioni delle query.
+ Le operazioni che supportano i controlli degli accessi basati su Lake Formation con tabelle Apache Spark non gestite includono `INSERT INTO` e `INSERT OVERWRITE`.
+ Le operazioni che supportano i controlli degli accessi basati su Lake Formation con Apache Spark e Apache Hive includono `SELECT`, `DESCRIBE`, `SHOW DATABASE`, `SHOW TABLE`, `SHOW COLUMN` e `SHOW PARTITION`.
+ Amazon EMR non supporta l'accesso alle seguenti operazioni basate su Lake Formation:
+ Scrive su tabelle regolate
+ Amazon EMR non supporta `CREATE TABLE`. Amazon EMR versione 6.10.0 e successive supporta `ALTER TABLE`.
+ Istruzioni DML diverse dai comandi `INSERT`.
+ Esistono differenze di prestazioni tra la stessa query con e senza il controllo degli accessi basato su Lake Formation.
+ Puoi usare Amazon EMR solo con Lake Formation per i lavori Spark.
+ La propagazione delle identità affidabili non è supportata con la gerarchia multicatalogo in Glue Data Catalog. Per ulteriori informazioni, consulta [Lavorare con una gerarchia multicatalogo in AWS Glue Data Catalog](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-multi-catalog.html).
## Considerazioni per Amazon EMR with Lake Formation per la versione 7.10 e successive
Considera quanto segue quando utilizzi Amazon EMR con AWS Lake Formation EMR 7.10 e versioni successive.
+ Amazon EMR supporta il controllo granulare degli accessi tramite Lake Formation solo per le tabelle Apache Hive, Apache Iceberg, Apache Delta e Apache Hudi. I formati Apache Hive includono Parquet, ORC e xSv CSV.
+ Per le applicazioni abilitate per Lake Formation, i log Spark vengono scritti su Amazon S3 in due gruppi: log dello spazio di sistema e log dello spazio utente. I log dello spazio di sistema possono contenere informazioni riservate come lo schema completo della tabella. Per proteggere questi dati, Amazon EMR archivia i log dello spazio di sistema in una posizione separata dai log dello spazio utente. Si consiglia vivamente agli amministratori degli account di non concedere agli utenti l'accesso ai registri dello spazio di sistema.
+ Se registri una posizione in una tabella con Lake Formation, l'accesso ai dati sarà controllato esclusivamente dalle autorizzazioni del ruolo utilizzato per la registrazione, anziché dal ruolo Job Runtime di Amazon EMR. Se il ruolo di registrazione non è configurato correttamente, i lavori che tentano di accedere alla tabella avranno esito negativo.
+ Non puoi smettere di lavorare `DynamicResourceAllocation` per Lake Formation.
+ Si può usare Lake Formation solo con i processi Spark.
+ Amazon EMR with Lake Formation supporta solo una singola sessione Spark durante un processo.
+ Amazon EMR with Lake Formation supporta solo query tabellari tra account condivise tramite link a risorse.
+ I seguenti elementi non sono supportati:
+ Resilient Distributed Dataset (RDD)
+ Streaming di Spark
+ Scrivere con le autorizzazioni concesse da Lake Formation
+ Controllo degli accessi per colonne annidate
+ Amazon EMR blocca funzionalità che potrebbero compromettere il completo isolamento dei driver di sistema, tra cui:
+ UDTs, Hive UDFs e qualsiasi funzione definita dall'utente che includa classi personalizzate
+ Origini dati personalizzate
+ Fornitura di jar aggiuntivi per l'estensione, il connettore o il metastore di Spark
+ Comando `ANALYZE TABLE`
+ Per applicare i controlli di accesso, `EXPLAIN PLAN` e le operazioni DDL, come `DESCRIBE TABLE` non espongono informazioni riservate.
+ Amazon EMR limita l'accesso ai log Spark dei driver di sistema sulle applicazioni abilitate per Lake Formation. Poiché il driver di sistema viene eseguito con autorizzazioni elevate, gli eventi e i log generati dal driver di sistema possono includere informazioni riservate. Per impedire a utenti o codici non autorizzati di accedere a questi dati sensibili, Amazon EMR disabilita l'accesso ai registri dei driver di sistema.
I log dei profili di sistema vengono sempre conservati nello storage gestito: si tratta di un'impostazione obbligatoria che non può essere disabilitata. Questi registri vengono archiviati in modo sicuro e crittografati utilizzando una chiave KMS gestita dal cliente o una chiave KMS gestita. AWS
[Se la tua applicazione Amazon EMR si trova in una sottorete privata con endpoint VPC per Amazon S3 e alleghi una policy di endpoint per controllare l'accesso, prima che i tuoi lavori possano inviare dati di log a Managed AWS Amazon S3, devi includere le autorizzazioni dettagliate in Managed Storage nella tua policy VPC all'endpoint gateway S3.](logging.html#jobs-log-storage-managed-storage) Per la risoluzione dei problemi relativi alle richieste, contatta l'assistenza. AWS
+ Se hai registrato una posizione in una tabella con Lake Formation, il percorso di accesso ai dati passa attraverso le credenziali archiviate di Lake Formation indipendentemente dall'autorizzazione IAM per il ruolo di job runtime di Amazon EMR. Se si configura erroneamente il ruolo registrato con la posizione della tabella, i processi inviati che utilizzano il ruolo con l'autorizzazione S3 IAM per la posizione della tabella avranno esito negativo.
+ La scrittura su una tabella Lake Formation utilizza l'autorizzazione IAM anziché le autorizzazioni concesse da Lake Formation. Se il ruolo di runtime del processo dispone delle autorizzazioni S3 necessarie, è possibile utilizzarlo per eseguire operazioni di scrittura.
Di seguito sono riportate considerazioni e limitazioni per l'utilizzo di Apache Iceberg:
+ È possibile utilizzare Apache Iceberg solo con il catalogo delle sessioni e non con i cataloghi con nomi arbitrari.
+ Le tabelle Iceberg registrate in Lake Formation supportano solo le tabelle di metadati`history`,`metadata_log_entries`,, `snapshots` `files``manifests`, e. `refs` Amazon EMR nasconde le colonne che potrebbero contenere dati sensibili, ad esempio`partitions`, `path` e. `summaries` Questa limitazione non si applica alle tabelle Iceberg che non sono registrate in Lake Formation.
+ Le tabelle non registrate in Lake Formation supportano tutte le stored procedure di Iceberg. Le procedure di `register_table` e `migrate` non sono supportate per nessuna tabella.
+ Ti consigliamo di utilizzare Iceberg DataFrameWriter V2 anziché V1.
## Considerazioni per Amazon EMR with Lake Formation per la versione 7.12 e successive
### Ambito generale
Esamina le seguenti limitazioni quando usi Lake Formation con Amazon EMR.
+ Non puoi smettere di lavorare `DynamicResourceAllocation` per Lake Formation.
+ Si può usare Lake Formation solo con i processi Spark.
+ Amazon EMR with Lake Formation supporta solo una singola sessione Spark durante un processo.
+ Amazon EMR with Lake Formation supporta solo query tabellari tra account condivise tramite link a risorse.
+ I seguenti elementi non sono supportati:
+ Resilient Distributed Dataset (RDD)
+ Streaming di Spark
+ Controllo degli accessi per colonne annidate
+ Amazon EMR blocca funzionalità che potrebbero compromettere il completo isolamento dei driver di sistema, tra cui:
+ UDTs, Hive UDFs e qualsiasi funzione definita dall'utente che includa classi personalizzate
+ Origini dati personalizzate
+ Fornitura di jar aggiuntivi per l'estensione, il connettore o il metastore di Spark
+ Comando `ANALYZE TABLE`
+ [Se la tua applicazione Amazon EMR si trova in una sottorete privata con endpoint VPC per Amazon S3 e alleghi una policy di endpoint per controllare l'accesso, prima che i tuoi lavori possano inviare dati di log a Managed AWS Amazon S3, devi includere le autorizzazioni dettagliate in Managed Storage nella tua policy VPC all'endpoint gateway S3.](logging.html#jobs-log-storage-managed-storage) Per la risoluzione dei problemi relativi alle richieste, contatta l'assistenza. AWS
+ A partire da Amazon EMR 7.9.0, Spark FGAC supporta il AFile sistema S3 se utilizzato con lo schema s3a://.
+ Amazon EMR 7.11 supporta la creazione di tabelle gestite tramite CTAS.
+ Amazon EMR 7.12 supporta la creazione di tabelle gestite ed esterne utilizzando CTAS.
## Permissions
+ Per applicare i controlli di accesso, le operazioni EXPLAIN PLAN e DDL come DESCRIBE TABLE non espongono informazioni riservate.
+ Quando registri una posizione in una tabella con Lake Formation, l'accesso ai dati utilizza le credenziali archiviate di Lake Formation anziché le autorizzazioni IAM del ruolo di job runtime EMR Serverless. I processi falliranno se il ruolo registrato per la posizione della tabella è configurato in modo errato, anche se il ruolo di runtime dispone delle autorizzazioni S3 IAM per quella posizione.
+ A partire da Amazon EMR 7.12, puoi scrivere su tabelle Hive e Iceberg esistenti utilizzando DataFrameWriter (V2) con credenziali Lake Formation in modalità di aggiunta. Per le operazioni di sovrascrittura o durante la creazione di nuove tabelle, EMR utilizza le credenziali del ruolo di runtime per modificare i dati della tabella.
+ Le seguenti limitazioni si applicano quando si utilizzano viste o tabelle memorizzate nella cache come dati di origine (queste limitazioni non si applicano alle viste del AWS Glue Data Catalog):
+ Per le operazioni MERGE, DELETE e UPDATE
+ Supportato: utilizzo di viste e tabelle memorizzate nella cache come tabelle di origine.
+ Non supportato: utilizzo di viste e tabelle memorizzate nella cache nelle clausole di assegnazione e condizione.
+ Per le operazioni CREATE OR REPLACE e REPLACE TABLE AS SELECT:
+ Non supportata: utilizzo di viste e tabelle memorizzate nella cache come tabelle di origine.
+ Le tabelle Delta Lake con UDFs dati di origine supportano le operazioni MERGE, DELETE e UPDATE solo quando il vettore di eliminazione è abilitato.
## Registri e debug
+ Amazon EMR limita l'accesso ai log Spark dei driver di sistema sulle applicazioni abilitate per Lake Formation. Poiché il driver di sistema funziona con autorizzazioni elevate, gli eventi e i log generati dal driver di sistema possono includere informazioni sensibili. Per impedire a utenti o codici non autorizzati di accedere a questi dati sensibili, Amazon EMR disabilita l'accesso ai registri dei driver di sistema.
I log dei profili di sistema vengono sempre conservati nello storage gestito: si tratta di un'impostazione obbligatoria che non può essere disabilitata. Questi registri vengono archiviati in modo sicuro e crittografati utilizzando una chiave KMS gestita dal cliente o una chiave KMS gestita. AWS
## Iceberg
Leggi le seguenti considerazioni quando usi Apache Iceberg:
+ È possibile utilizzare Apache Iceberg solo con il catalogo delle sessioni e non con i cataloghi con nomi arbitrari.
+ Le tabelle Iceberg registrate in Lake Formation supportano solo le tabelle di metadati`history`,`metadata_log_entries`,, `snapshots` `files``manifests`, e. `refs` Amazon EMR nasconde le colonne che potrebbero contenere dati sensibili, ad esempio`partitions`, `path` e. `summaries` Questa limitazione non si applica alle tabelle Iceberg che non sono registrate in Lake Formation.
+ Le tabelle non registrate in Lake Formation supportano tutte le stored procedure Iceberg. Le procedure di `register_table` e `migrate` non sono supportate per nessuna tabella.
+ Ti suggeriamo di utilizzare Iceberg DataFrameWriter V2 anziché V1.
# API a grana fine nativa di Spark per il controllo degli accessi PySpark
Per mantenere i controlli di sicurezza e accesso ai dati, il controllo granulare degli accessi di Spark (FGAC) limita determinate funzioni. PySpark Queste restrizioni vengono applicate tramite:
+ Blocco esplicito che impedisce l'esecuzione della funzione
+ Incompatibilità dell'architettura che rendono le funzioni non funzionali
+ Funzioni che possono generare errori, restituire messaggi di accesso negato o non eseguire alcuna operazione quando vengono chiamate
Le seguenti PySpark funzionalità non sono supportate in Spark FGAC:
+ Operazioni RDD (bloccate con Spark Exception) RDDUnsupported
+ Spark Connect (non supportato)
+ Spark Streaming (non supportato)
Sebbene abbiamo testato le funzioni elencate in un ambiente FGAC Spark nativo e confermato che funzionano come previsto, i nostri test in genere coprono solo l'utilizzo di base di ciascuna API. Le funzioni con più tipi di input o percorsi logici complessi possono presentare scenari non testati.
Per tutte le funzioni non elencate qui e che non rientrano chiaramente nelle categorie non supportate di cui sopra, consigliamo di:
+ Testarle prima in un ambiente gamma o in una distribuzione su piccola scala
+ Verifica del loro comportamento prima di utilizzarli in produzione
**Nota**
Se vedi elencato un metodo di classe ma non la sua classe base, il metodo dovrebbe comunque funzionare, significa solo che non abbiamo verificato esplicitamente il costruttore della classe base.
L' PySpark API è organizzata in moduli. Il supporto generale per i metodi all'interno di ciascun modulo è dettagliato nella tabella seguente.
| Nome del modulo | Stato | Note |
| --- | --- | --- |
| pyspark\$1core | Supportata | Questo modulo contiene le classi RDD principali e queste funzioni per lo più non sono supportate. |
| pyspark\$1sql | Supportata | |
| pyspark\$1testing | Supportata | |
| pyspark\$1resource | Supportata | |
| pyspark\$1streaming | Bloccato | L'utilizzo dello streaming è bloccato in Spark FGAC. |
| pyspark\$1mllib | sperimentale | Questo modulo contiene operazioni ML basate su RDD e queste funzioni per lo più non sono supportate. Questo modulo non è stato testato a fondo. |
| pyspark\$1ml | sperimentale | Questo modulo contiene operazioni di DataFrame machine learning basate e queste funzioni sono per lo più supportate. Questo modulo non è stato testato a fondo. |
| pyspark\$1pandas | Supportata | |
| pyspark\$1pandas\$1slow | Supportata | |
| pyspark\$1connect | Bloccato | L'utilizzo di Spark Connect è bloccato in Spark FGAC. |
| pyspark\$1pandas\$1connect | Bloccato | L'utilizzo di Spark Connect è bloccato in Spark FGAC. |
| pyspark\$1pandas\$1slow\$1connect | Bloccato | L'utilizzo di Spark Connect è bloccato in Spark FGAC. |
| pyspark\$1errors | sperimentale | Questo modulo non è stato testato a fondo. Le classi di errore personalizzate non possono essere utilizzate. |
**Elenco delle API consentite**
Per un elenco scaricabile e più facile da cercare, un file con i moduli e le classi è disponibile nelle [funzioni Python consentite](samples/Python functions allowed in Native FGAC.zip) in Native FGAC.
# Accesso completo alla tabella di Lake Formation per Amazon EMR su EC2
Con le versioni 7.8.0 e successive di Amazon EMR, puoi sfruttare AWS Lake Formation with Glue Data Catalog, dove il ruolo di job runtime dispone di autorizzazioni complete per le tabelle senza le limitazioni del controllo granulare degli accessi. Questa funzionalità ti consente di leggere e scrivere su tabelle protette da Lake Formation dal tuo batch Amazon EMR su EC2 Spark e dai lavori interattivi. Consulta le seguenti sezioni per saperne di più su Lake Formation e su come utilizzarlo con Amazon EMR su EC2.
## Utilizzo di Lake Formation con accesso completo ai tavoli
Puoi accedere alle tabelle del catalogo Glue Data protette da AWS Lake Formation da Amazon EMR su job EC2 Spark o sessioni interattive in cui il ruolo di runtime del job ha accesso completo alla tabella. Non è necessario abilitare AWS Lake Formation sull'applicazione Amazon EMR su EC2. Quando un job Spark è configurato per Full Table Access (FTA), le credenziali di AWS Lake Formation vengono utilizzate per i dati read/write S3 per le tabelle registrate di AWS Lake Formation, mentre le credenziali del ruolo di runtime del lavoro verranno utilizzate per le read/write tabelle non registrate con Lake Formation. AWS
**Importante**
Non abilitare AWS Lake Formation per il controllo granulare degli accessi. Un job non può eseguire contemporaneamente Full Table Access (FTA) e Fine-Grained Access Control (FGAC) sullo stesso cluster o applicazione EMR.
### Passaggio 1: abilitare l'accesso completo alla tabella in Lake Formation
Per utilizzare la modalità Full Table Access (FTA), devi consentire ai motori di query di terze parti di accedere ai dati senza la convalida del tag di sessione IAM in AWS Lake Formation. Per abilitarli, seguire i passaggi descritti in [Integrazione delle applicazioni per l'accesso completo alla tabella](https://docs.aws.amazon.com/lake-formation/latest/dg/full-table-credential-vending.html).
**Nota**
Quando si accede alle tabelle tra account diversi, è necessario abilitare l'accesso completo alla tabella sia negli account produttore che in quelli consumer. Allo stesso modo, quando si accede alle tabelle interregionali, questa impostazione deve essere abilitata sia nelle regioni produttrici che in quelle di consumo.
### Fase 2: Configurazione delle autorizzazioni IAM per il ruolo di runtime dei processi
Per l'accesso in lettura o scrittura ai dati sottostanti, oltre alle autorizzazioni di Lake Formation, un ruolo di job runtime richiede l'autorizzazione `lakeformation:GetDataAccess` IAM. Con questa autorizzazione, Lake Formation concede la richiesta di credenziali temporanee per accedere ai dati.
Di seguito è riportato un esempio di politica su come fornire le autorizzazioni IAM per accedere a uno script in Amazon S3, caricare i log su S3, le autorizzazioni dell'API AWS Glue e l'autorizzazione per accedere a Lake Formation.
#### Passaggio 2.1 Configurare i permessi di Lake Formation
+ I job Spark che leggono dati da S3 richiedono l'autorizzazione Lake Formation SELECT.
+ Spark rileva che write/delete i dati in S3 richiedono l'autorizzazione Lake Formation ALL (SUPER).
+ I lavori Spark che interagiscono con il catalogo Glue Data richiedono l'autorizzazione DESCRIBE, ALTER, DROP, a seconda dei casi.
Per ulteriori informazioni, consulta Concessione delle [autorizzazioni sulle risorse di Data Catalog](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html).
### Passaggio 3: inizializza una sessione Spark per l'accesso completo alla tabella utilizzando Lake Formation
#### Prerequisiti
AWS Glue Data Catalog deve essere configurato come metastore per accedere alle tabelle di Lake Formation.
Imposta le seguenti impostazioni per configurare il catalogo Glue come metastore:
```
--conf spark.sql.catalogImplementation=hive
--conf spark.hive.metastore.client.factory.class=com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory
```
Per ulteriori informazioni sull'attivazione di Data Catalog for Amazon EMR su EC2, consulta la configurazione [Metastore per Amazon](metastore-config.html) EMR su EC2.
Per accedere alle tabelle registrate con AWS Lake Formation, è necessario impostare le seguenti configurazioni durante l'inizializzazione di Spark per configurare Spark per utilizzare le credenziali di 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`: Configurare EMR Filesystem (EMRFS) o EMR S3A per utilizzare le credenziali di Lake Formation S3 per le tabelle registrate di Lake AWS Formation. Se la tabella non è registrata, utilizzare le credenziali del ruolo di runtime del processo.
+ `spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject=true` e `spark.hadoop.fs.s3.folderObject.autoAction.disabled=true`: configurano EMRFS per utilizzare l'applicazione di intestazione di tipo di contenuto/directory x invece del suffisso \$1folder\$1 durante la creazione di cartelle S3. Questo è necessario per leggere le tabelle di Lake Formation, poiché le credenziali di Lake Formation non consentono la lettura delle cartelle delle tabelle con il suffisso \$1folder\$1.
+ `spark.sql.catalog.skipLocationValidationOnCreateTable.enabled=true`: configura Spark per saltare la convalida del vuoto della posizione della tabella prima della creazione. Ciò è necessario per le tabelle registrate di Lake Formation, poiché le credenziali di Lake Formation per verificare la posizione vuota sono disponibili solo dopo la creazione della tabella Glue Data Catalog. Senza questa configurazione, le credenziali del ruolo di runtime del processo convalideranno la posizione della tabella vuota.
+ `spark.sql.catalog.createDirectoryAfterTable.enabled=true`: configura Spark per creare la cartella Amazon S3 dopo la creazione della tabella nel metastore Hive. Questo è necessario per le tabelle registrate di Lake Formation, poiché le credenziali di Lake Formation per creare la cartella S3 sono disponibili solo dopo la creazione della tabella Glue Data Catalog.
+ `spark.sql.catalog.dropDirectoryBeforeTable.enabled=true`: Configura Spark per eliminare la cartella S3 prima dell'eliminazione della tabella nel metastore Hive. Ciò è necessario per le tabelle registrate di Lake Formation, poiché le credenziali di Lake Formation per eliminare la cartella S3 non sono disponibili dopo l'eliminazione della tabella dal Glue Data Catalog.
+ `spark.sql.catalog..glue.lakeformation-enabled=true`: Configura il catalogo Iceberg per utilizzare le credenziali di AWS Lake Formation S3 per le tabelle registrate di Lake Formation. Se la tabella non è registrata, usare le credenziali di ambiente predefinite.
#### Configura la modalità di accesso completo alla tabella in Unified Studio SageMaker
Per accedere alle tabelle registrate di Lake Formation dalle sessioni interattive di Spark nei JupyterLab notebook, utilizza la modalità di autorizzazione alla compatibilità. Usa il comando magic %%configure per configurare la configurazione di Spark. Scegliere la configurazione in base al tipo di tabella:
------
#### [ 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"
}
}
```
------
Sostituire i segnaposto:
+ `S3_DATA_LOCATION`: Il percorso del tuo bucket S3
+ `REGION`: AWS regione (ad es. us-east-1)
+ `ACCOUNT_ID`: L'ID del tuo account AWS
**Nota**
È necessario impostare queste configurazioni prima di eseguire qualsiasi operazione Spark sul notebook.
#### Operazioni supportate
Queste operazioni utilizzeranno le credenziali di AWS Lake Formation per accedere ai dati della tabella.
+ CREATE TABLE
+ ALTER TABLE
+ INSERT INTO
+ INSERT OVERWRITE
+ UPDATE
+ MERGE INTO
+ DELETE FROM
+ ANALYZE TABLE
+ REPAIR TABLE
+ DROP TABLE
+ Query su origini dati Spark
+ Scritture di origini dati Spark
**Nota**
Le operazioni non elencate sopra continueranno a utilizzare le autorizzazioni IAM per accedere ai dati delle tabelle.
#### Considerazioni
+ Se una tabella Hive viene creata utilizzando un lavoro per cui non è abilitato l'accesso completo alla tabella e non viene inserito alcun record, le letture o scritture successive da un lavoro con accesso completo alla tabella avranno esito negativo. Questo perché EMR Spark senza accesso completo alla tabella aggiunge il `$folder$` suffisso al nome della cartella della tabella. Per risolvere questo problema, è possibile procedere in questi modi:
+ Inserire almeno una riga nella tabella da un processo che non ha FTA abilitato.
+ Configura il lavoro che non ha FTA abilitato in modo che non utilizzi il `$folder$` suffisso nel nome della cartella in S3. Ciò si può ottenere impostando la configurazione `spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject=true` di Spark.
+ Crea una cartella S3 nella posizione della tabella `s3://path/to/table/table_name` utilizzando la console AWS S3 o la CLI AWS S3.
+ L'accesso completo alla tabella è supportato con il file system EMR (EMRFS) a partire dalla versione 7.8.0 di Amazon EMR e con il file system S3A a partire dalla versione 7.10.0 di Amazon EMR.
+ L'accesso completo alle tabelle è supportato per le tabelle Hive, Iceberg, Delta e Hudi.
+ **Considerazioni su Hudi FTA Write Support:**
+ Le scritture Hudi FTA richiedono l'utilizzo HoodieCredentialedHadoopStorage per la vendita di credenziali durante l'esecuzione del lavoro. Imposta la seguente configurazione durante l'esecuzione dei job Hudi: `hoodie.storage.class=org.apache.spark.sql.hudi.storage.HoodieCredentialedHadoopStorage`
+ Il supporto di scrittura Full Table Access (FTA) per Hudi è disponibile a partire dalla release 7.12 di Amazon EMR.
+ Il supporto di scrittura Hudi FTA attualmente funziona solo con le configurazioni Hudi predefinite. Le impostazioni Hudi personalizzate o non predefinite potrebbero non essere completamente supportate e potrebbero causare comportamenti imprevisti.
+ Il clustering per le tabelle Hudi Merge-On-Read (MOR) non è supportato a questo punto in modalità di scrittura FTA.
+ I lavori che fanno riferimento alle tabelle con le regole Lake Formation Fine-Grained Access Control (FGAC) o Glue Data Catalog Views avranno esito negativo. Per interrogare una tabella con regole FGAC o Glue Data Catalog View, è necessario utilizzare la modalità FGAC. Puoi abilitare la modalità FGAC seguendo i passaggi descritti nella AWS documentazione: Utilizzo di [Amazon EMR su EC2 con Lake AWS Formation](emr-serverless-lf-enable.html) per un controllo granulare degli accessi.
+ L'accesso completo alla tabella non supporta Spark Streaming.
+ Quando si scrive Spark DataFrame su una tabella Lake Formation, è supportata solo la modalità APPEND per le tabelle Hive e Iceberg: `df.write.mode("append").saveAsTable(table_name)`
+ La creazione di tabelle esterne richiede autorizzazioni IAM.
+ Poiché Lake Formation memorizza temporaneamente nella cache le credenziali all'interno di un lavoro Spark, un processo batch Spark o una sessione interattiva attualmente in esecuzione potrebbero non riflettere le modifiche alle autorizzazioni.
+ È necessario utilizzare un ruolo definito dall'utente e non un ruolo collegato al servizio: [requisiti per i ruoli di Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/registration-role.html).
#### Hudi FTA Write Support - Operazioni supportate
La tabella seguente mostra le operazioni di scrittura supportate per le tabelle Hudi Copy-On-Write (COW) e Merge-On-Read (MOR) in modalità Full Table Access:
**Operazioni di scrittura supportate da Hudi FTA**
| Tipo tabella | Operation | Comando di scrittura SQL | Stato |
| --- | --- | --- | --- |
| MUCCA | INSERT | INSERT INTO TABLE | Supportata |
| MUCCA | INSERT | INSERISCI NELLA TABELLA - PARTIZIONE (statica, dinamica) | Supportata |
| MUCCA | INSERT | INSERT OVERWRITE | Supportata |
| MUCCA | INSERT | INSERT OVERWRITE - PARTIZIONE (statica, dinamica) | Supportata |
| UPDATE | UPDATE | UPDATE TABLE | Supportata |
| MUCCA | UPDATE | TABELLA DI AGGIORNAMENTO - Cambia partizione | Non supportato |
| DELETE | DELETE | DELETE FROM TABLE | Supportata |
| ALTER | ALTER | MODIFICA TABELLA: RINOMINA IN | Non supportato |
| MUCCA | ALTER | MODIFICA TABELLA - IMPOSTA TBLPROPERTIES | Supportata |
| MUCCA | ALTER | ALTER TABLE - ANNULLA TBLPROPERTIES | Supportata |
| MUCCA | ALTER | ALTERA TABELLA - MODIFICA COLONNA | Supportata |
| MUCCA | ALTER | ALTERA TABELLA - AGGIUNGI COLONNE | Supportata |
| MUCCA | ALTER | ALTER TABLE - AGGIUNGI UNA PARTIZIONE | Supportata |
| MUCCA | ALTER | ALTERA TABELLA - ELIMINA LA PARTIZIONE | Supportata |
| MUCCA | ALTER | ALTER TABLE - RECUPERA LE PARTIZIONI | Supportata |
| MUCCA | ALTER | RIPARA LE PARTIZIONI DI SINCRONIZZAZIONE DELLE TABELLE | Supportata |
| DROP | DROP | DROP TABLE | Supportata |
| MUCCA | DROP | DROP TABLE - PURGE | Supportata |
| CREATE | CREATE | CREATE TABLE - Gestito | Supportata |
| MUCCA | CREATE | CREA TABELLA - PARTIZIONA PER | Supportata |
| MUCCA | CREATE | CREA UNA TABELLA SE NON ESISTE | Supportata |
| MUCCA | CREATE | CREATE TABLE LIKE | Supportata |
| MUCCA | CREATE | CREATE TABLE AS SELECT | Supportata |
| CREATE | CREATE | CREA TABELLA con LOCATION - Tabella esterna | Non supportato |
| DATAFRAME (INSERIRE) | DATAFRAME (INSERIRE) | saveAsTable.Sovrascrivi | Supportata |
| MUCCA | DATAFRAME (INSERISCI) | saveAsTable.Aggiungi | Non supportato |
| MUCCA | DATAFRAME (INSERISCI) | saveAsTable.Ignora | Supportata |
| MUCCA | DATAFRAME (INSERISCI) | saveAsTable.ErrorIfExists | Supportata |
| MUCCA | DATAFRAME (INSERISCI) | saveAsTable - Tabella esterna (Path) | Non supportato |
| MUCCA | DATAFRAME (INSERISCI) | salva (percorso) - DF v1 | Non supportato |
| ALTRO | INSERT | INSERT INTO TABLE | Supportata |
| MOR | INSERT | INSERISCI NELLA TABELLA - PARTIZIONE (statica, dinamica) | Supportata |
| ALTRO | INSERT | INSERT OVERWRITE | Supportata |
| MOR | INSERT | INSERT OVERWRITE - PARTIZIONE (statica, dinamica) | Supportata |
| UPDATE | UPDATE | UPDATE TABLE | Supportata |
| ALTRO | UPDATE | TABELLA DI AGGIORNAMENTO - Cambia partizione | Non supportato |
| DELETE | DELETE | DELETE FROM TABLE | Supportata |
| ALTER | ALTER | MODIFICA TABELLA: RINOMINA IN | Non supportato |
| - ALTRO | ALTER | MODIFICA TABELLA - IMPOSTA TBLPROPERTIES | Supportata |
| ALTRO | ALTER | MODIFICA TABELLA - ANNULLA TBLPROPERTIES | Supportata |
| ALTRO | ALTER | MODIFICA TABELLA - MODIFICA COLONNA | Supportata |
| ALTRO | ALTER | ALTERA TABELLA - AGGIUNGI COLONNE | Supportata |
| - ALTRO | ALTER | ALTER TABLE - AGGIUNGI UNA PARTIZIONE | Supportata |
| - ALTRO | ALTER | ALTERA TABELLA - ELIMINA LA PARTIZIONE | Supportata |
| - ALTRO | ALTER | ALTER TABLE - RECUPERA LE PARTIZIONI | Supportata |
| - ALTRO | ALTER | RIPARA LE PARTIZIONI DI SINCRONIZZAZIONE DELLE TABELLE | Supportata |
| DROP | DROP | DROP TABLE | Supportata |
| ALTRO | DROP | DROP TABLE - PURGE | Supportata |
| CREATE | CREATE | CREATE TABLE - Gestito | Supportata |
| ALTRO | CREATE | CREA TABELLA - PARTIZIONA PER | Supportata |
| - ALTRO | CREATE | CREA UNA TABELLA SE NON ESISTE | Supportata |
| ALTRO | CREATE | CREATE TABLE LIKE | Supportata |
| MOR | CREATE | CREATE TABLE AS SELECT | Supportata |
| CREATE | CREATE | CREA TABELLA con LOCATION - Tabella esterna | Non supportato |
| DATAFRAME (UPSERT) | DATAFRAME (UPSERT) | saveAsTable.Sovrascrivi | Supportata |
| ALTRO | DATAFRAME (SCONVOLTO) | saveAsTable.Aggiungi | Non supportato |
| ALTRO | DATAFRAME (SCONVOLTO) | saveAsTable.Ignora | Supportata |
| ALTRO | DATAFRAME (SCONVOLTO) | saveAsTable.ErrorIfExists | Supportata |
| PIÙ | DATAFRAME (SCONVOLTO) | saveAsTable - Tabella esterna (Path) | Non supportato |
| - ALTRO | DATAFRAME (SCONVOLTO) | salva (percorso) - DF v1 | Non supportato |
| DATAFRAME (ELIMINA) | DATAFRAME (ELIMINA) | saveAsTable.Aggiungi | Non supportato |
| ALTRO | DATAFRAME (ELIMINA) | saveAsTable - Tabella esterna (Path) | Non supportato |
| - ALTRO | DATAFRAME (ELIMINA) | salva (percorso) - DF v1 | Non supportato |
| DATAFRAME (BULK\$1INSERT) | DATAFRAME (BULK\$1INSERT) | saveAsTable.Sovrascrivi | Supportata |
| ALTRO | DATAFRAME (BULK\$1INSERT) | saveAsTable.Aggiungi | Non supportato |
| ALTRO | DATAFRAME (BULK\$1INSERT) | saveAsTable.Ignora | Supportata |
| ALTRO | DATAFRAME (BULK\$1INSERT) | saveAsTable.ErrorIfExists | Supportata |
| PIÙ | DATAFRAME (BULK\$1INSERT) | saveAsTable - Tabella esterna (Path) | Non supportato |
| - ALTRO | DATAFRAME (BULK\$1INSERT) | salva (percorso) - DF v1 | Non supportato |