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à.
# Utilizzo del framework Delta Lake in AWS Glue
AWS Glue 3.0 e versioni successive supportano il framework Linux Foundation Delta Lake. Delta Lake è un framework di archiviazione di data lake open source che consente di eseguire transazioni ACID, scalare la gestione dei metadati e unificare lo streaming e l'elaborazione dei dati in batch. Questo argomento descrive le funzionalità disponibili per l'utilizzo dei dati in AWS Glue durante il trasporto o l'archiviazione dei dati in una tabella Delta Lake. Per saperne di più su Delta Lake, consulta la [documentazione ufficiale di Delta Lake](https://docs.delta.io/latest/delta-intro.html).
Puoi usare AWS Glue per eseguire operazioni di lettura e scrittura sulle tabelle Delta Lake in Amazon S3 o lavorare con le tabelle Delta Lake utilizzando il AWS Glue Data Catalog. Sono supportate anche operazioni aggiuntive come inserimento, aggiornamento e [letture e scritture in batch di tabelle](https://docs.delta.io/0.7.0/api/python/index.html). Quando usi le tabelle Delta Lake, hai anche la possibilità di utilizzare metodi della libreria Python di Delta Lake come `DeltaTable.forPath`. Per ulteriori informazioni sulla libreria Python di Delta Lake, consultare la documentazione Python di Delta Lake.
La tabella seguente elenca la versione di Delta Lake inclusa in ogni versione di AWS Glue.
****
| AWS Versione Glue | Versione Delta Lake supportata |
| --- | --- |
| 5.1 | 3.3.2 |
| 5.0 | 3.3.0 |
| 4.0 | 2.1.0 |
| 3.0 | 1.0.0 |
Per ulteriori informazioni sui framework di data lake supportati da AWS Glue, consulta. [Utilizzo di framework di data lake con AWS Glue processi ETL](aws-glue-programming-etl-datalake-native-frameworks.md)
## Attivazione di Delta Lake for AWS Glue
Per abilitare Delta Lake for AWS Glue, completa le seguenti attività:
+ Specifica `delta` come valore per i parametri del processo `--datalake-formats`. Per ulteriori informazioni, consulta [Utilizzo dei parametri del lavoro nei lavori AWS Glue](aws-glue-programming-etl-glue-arguments.md).
+ Crea una chiave denominata `--conf` per il tuo lavoro AWS Glue e impostala sul seguente valore. In alternativa, puoi impostare la seguente configurazione usando `SparkConf` nel tuo script. Queste impostazioni consentono ad Apache Spark di gestire correttamente le tabelle Delta Lake.
```
spark.sql.extensions=io.delta.sql.DeltaSparkSessionExtension --conf spark.sql.catalog.spark_catalog=org.apache.spark.sql.delta.catalog.DeltaCatalog --conf spark.delta.logStore.class=org.apache.spark.sql.delta.storage.S3SingleDriverLogStore
```
+ Il supporto delle autorizzazioni Lake Formation per le tabelle Delta è abilitato di default per AWS Glue 4.0. Non è necessaria alcuna configurazione aggiuntiva reading/writing per le tabelle Delta registrate da Lake Formation. Per leggere una tabella Delta registrata, il ruolo IAM di AWS Glue job deve disporre dell'autorizzazione SELECT. Per scrivere su una tabella Delta registrata, il ruolo IAM di AWS Glue job deve disporre dell'autorizzazione SUPER. Per ulteriori informazioni sulla gestione delle autorizzazioni di Lake Formation, consulta [Concessione e revoca delle autorizzazioni del catalogo dati](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html).
**Utilizzo di una versione differente di Delta Lake**
Per utilizzare una versione di Delta Lake non supportata da AWS Glue, specifica i tuoi file JAR Delta Lake utilizzando il parametro `--extra-jars` job. Non includere `delta` come valore per il parametro del processo `--datalake-formats`. Se si utilizza AWS Glue 5.0 o versioni successive, è necessario impostare `--user-jars-first true` il parametro del lavoro. Per utilizzare la libreria Python Delta Lake in questo caso, è necessario specificare i file JAR della libreria utilizzando il parametro del processo `--extra-py-files`. La libreria Python è contenuta nei file JAR di Delta Lake.
## Esempio: scrivere una tabella Delta Lake su Amazon S3 e registrarla nel AWS Glue Data Catalog
Il seguente script AWS Glue ETL dimostra come scrivere una tabella Delta Lake su Amazon S3 e registrarla nel AWS Glue Data Catalog.
------
#### [ Python ]
```
# Example: Create a Delta Lake table from a DataFrame
# and register the table to Glue Data Catalog
additional_options = {
"path": "s3://{{}}"
}
dataFrame.write \
.format("delta") \
.options(**additional_options) \
.mode("append") \
.partitionBy("{{}}") \
.saveAsTable("{{}}.{{}}")
```
------
#### [ Scala ]
```
// Example: Example: Create a Delta Lake table from a DataFrame
// and register the table to Glue Data Catalog
val additional_options = Map(
"path" -> "s3://{{}}"
)
dataFrame.write.format("delta")
.options(additional_options)
.mode("append")
.partitionBy("{{}}")
.saveAsTable("{{}}.{{}}")
```
------
## Esempio: leggere una tabella Delta Lake da Amazon S3 utilizzando il AWS Glue Data Catalog
Il seguente script AWS Glue ETL legge la tabella Delta Lake in cui è stata creata. [Esempio: scrivere una tabella Delta Lake su Amazon S3 e registrarla nel AWS Glue Data Catalog](#aws-glue-programming-etl-format-delta-lake-write)
------
#### [ Python ]
Per questo esempio, utilizza il metodo [create\_data\_frame.from\_catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-catalog).
```
# Example: Read a Delta Lake table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
df = glueContext.create_data_frame.from_catalog(
database="{{}}",
table_name="{{}}",
additional_options=additional_options
)
```
------
#### [ Scala ]
Per questo esempio, usa il metodo [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource).
```
// Example: Read a Delta Lake table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val df = glueContext.getCatalogSource("{{}}", "{{}}",
additionalOptions = additionalOptions)
.getDataFrame()
}
}
```
------
## Esempio: inserire un `DataFrame` in una tabella Delta Lake in Amazon S3 utilizzando il AWS Glue Data Catalog
Questo esempio inserisce i dati nella tabella Delta Lake creata in [Esempio: scrivere una tabella Delta Lake su Amazon S3 e registrarla nel AWS Glue Data Catalog](#aws-glue-programming-etl-format-delta-lake-write).
**Nota**
Questo esempio richiede di impostare il parametro `--enable-glue-datacatalog` job per utilizzare AWS Glue Data Catalog come metastore Apache Spark Hive. Per ulteriori informazioni, consulta [Utilizzo dei parametri del lavoro nei lavori AWS Glue](aws-glue-programming-etl-glue-arguments.md).
------
#### [ Python ]
Per questo esempio, utilizza il metodo [write\_data\_frame.from\_catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_data_frame_from_catalog).
```
# Example: Insert into a Delta Lake table in S3 using Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
glueContext.write_data_frame.from_catalog(
frame=dataFrame,
database="{{}}",
table_name="{{}}",
additional_options=additional_options
)
```
------
#### [ Scala ]
Per questo esempio, usa il metodo [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink).
```
// Example: Insert into a Delta Lake table in S3 using Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getCatalogSink("{{}}", "{{}}",
additionalOptions = additionalOptions)
.writeDataFrame(dataFrame, glueContext)
}
}
```
------
## Esempio: lettura di una tabella Delta Lake da Amazon S3 tramite l'API Spark
In questo esempio viene letta una tabella Delta Lake da Amazon S3 tramite l'API Spark.
------
#### [ Python ]
```
# Example: Read a Delta Lake table from S3 using a Spark DataFrame
dataFrame = spark.read.format("delta").load("s3://{{}}")
```
------
#### [ Scala ]
```
// Example: Read a Delta Lake table from S3 using a Spark DataFrame
val dataFrame = spark.read.format("delta").load("s3://{{}}")
```
------
## Esempio: scrittura di una tabella Delta Lake su Amazon S3 tramite Spark
In questo esempio viene scritta una tabella Delta Lake su Amazon S3 tramite Spark.
------
#### [ Python ]
```
# Example: Write a Delta Lake table to S3 using a Spark DataFrame
dataFrame.write.format("delta") \
.options(**additional_options) \
.mode("overwrite") \
.partitionBy("{{}}")
.save("s3://{{}}")
```
------
#### [ Scala ]
```
// Example: Write a Delta Lake table to S3 using a Spark DataFrame
dataFrame.write.format("delta")
.options(additionalOptions)
.mode("overwrite")
.partitionBy("{{}}")
.save("s3://{{}}")
```
------
## Esempio: lettura e scrittura della tabella Delta Lake con il controllo delle autorizzazioni di Lake Formation
Questo esempio legge da e scrive su una tabella Delta Lake con il controllo delle autorizzazioni di Lake Formation.
1. Crea una tabella Delta e registrala in Lake Formation
1. Per abilitare il controllo delle autorizzazioni di Lake Formation, devi prima registrare il percorso della tabella Amazon S3 su Lake Formation. Per ulteriori informazioni, consulta la pagina [Registrazione di una posizione Amazon S3](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html). Puoi registrarlo dalla console di Lake Formation o utilizzando la AWS CLI:
```
aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region
```
Una volta registrata una posizione Amazon S3, qualsiasi tabella AWS Glue che punta alla posizione (o a una delle sue sedi secondarie) restituirà il valore del `IsRegisteredWithLakeFormation` parametro come true nella chiamata. `GetTable`
1. Crea una tabella Delta che punti al percorso registrato di Amazon S3 tramite Spark:
**Nota**
Di seguito vengono mostrati gli esempi Python.
```
dataFrame.write \
.format("delta") \
.mode("overwrite") \
.partitionBy("") \
.save("s3://")
```
Dopo aver scritto i dati su Amazon S3, usa il crawler AWS Glue per creare una nuova tabella del catalogo Delta. Per ulteriori informazioni, consulta [Introduzione al supporto per tabelle Delta Lake nativo con i crawler AWS Glue](https://aws.amazon.com/blogs/big-data/introducing-native-delta-lake-table-support-with-aws-glue-crawlers/).
Puoi anche creare la tabella manualmente tramite l'`CreateTable`API AWS Glue.
1. Concedi a Lake Formation l'autorizzazione per il ruolo IAM di AWS Glue job. Puoi concedere le autorizzazioni dalla console di Lake Formation o utilizzando la AWS CLI. Per ulteriori informazioni, consulta la pagina [Concessione delle autorizzazioni alla tabella tramite la console di Lake Formation e il metodo delle risorse denominate](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html)
1. Leggi la tabella Delta registrata in Lake Formation. Il codice equivale a leggere una tabella Delta non registrata. Tieni presente che il ruolo IAM di AWS Glue job deve disporre dell'autorizzazione SELECT affinché la lettura abbia esito positivo.
```
# Example: Read a Delta Lake table from Glue Data Catalog
df = glueContext.create_data_frame.from_catalog(
database="",
table_name="",
additional_options=additional_options
)
```
1. Scrivi sulla tabella Delta registrata in Lake Formation. Il codice equivale a scrivere su una tabella Delta non registrata. Tieni presente che il ruolo IAM di AWS Glue job deve disporre dell'autorizzazione SUPER affinché la scrittura abbia esito positivo.
Per impostazione predefinita, AWS Glue utilizza `Append` come SaveMode. È possibile modificarlo impostando l'opzione saveMode in `additional_options`. Per informazioni sul supporto saveMode nelle tabelle Delta, consulta [Scrivi su una tabella](https://docs.delta.io/latest/delta-batch.html#write-to-a-table).
```
glueContext.write_data_frame.from_catalog(
frame=dataFrame,
database="",
table_name="",
additional_options=additional_options
)
```