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à.
# Opzioni del formato dati per input e output in AWS Glue per Spark
Queste pagine offrono informazioni sul supporto delle funzionalità e sui parametri di configurazione per i formati di dati supportati da AWS Glue per Spark. Consulta quanto riportato di seguito per una descrizione dell'uso e dell'applicabilità di queste informazioni.
## Supporto delle funzionalità per tutti i formati di dati in AWS Glue
Ogni formato di dati può supportare diverse funzionalità di AWS Glue. Le funzioni comuni indicate di seguito possono essere supportate o meno in base al tipo di formato. Consulta la documentazione relativa al formato dati per capire come sfruttare le nostre funzioni per soddisfare i tuoi requisiti.
| | |
| --- |--- |
| Lettura | AWS Glue è in grado di riconoscere e interpretare questo formato di dati senza risorse aggiuntive, come i connettori. |
| Scrittura | AWS Glue può scrivere dati in questo formato senza risorse aggiuntive. Puoi includere librerie di terzi nel tuo processo e utilizzare funzioni standard di Apache Spark per scrivere i dati, come con altri ambienti Spark. Per ulteriori informazioni sull’inclusione di librerie, consulta [Usare le librerie Python con Glue AWS](aws-glue-programming-python-libraries.md). |
| Lettura in streaming | AWS Glue è in grado di riconoscere e interpretare questo formato di dati da un flusso di messaggi Apache Kafka, Amazon Managed Streaming for Apache Kafka o Amazon Kinesis. Prevediamo che i flussi presentino i dati in un formato coerente, quindi vengano letti come DataFrames. |
| Gruppo di file piccoli | AWS Glue può raggruppare i file per il lavoro in batch inviato a ciascun nodo durante l'esecuzione delle trasformazioni di AWS Glue. Ciò può migliorare significativamente le prestazioni per carichi di lavoro che implicano grandi quantità di file piccoli. Per ulteriori informazioni, consulta [Lettura di file di input in gruppi di grandi dimensioni](grouping-input-files.md). |
| Segnalibri di processo | AWS Glue è in grado di monitorare l'avanzamento delle trasformazioni che eseguono lo stesso lavoro sullo stesso set di dati in tutte le esecuzioni di lavoro con i segnalibri dei lavori. Ciò può migliorare le prestazioni per carichi di lavoro che implicano set di dati in cui occorre operare solo su nuovi dati dall'ultima esecuzione del processo. Per ulteriori informazioni, consulta [Monitoraggio dei dati elaborati mediante segnalibri di processo](monitor-continuations.md). |
## Parametri utilizzati per interagire con i formati di dati in AWS Glue
Alcuni tipi di connessione AWS Glue supportano più `format` tipi, pertanto è necessario specificare informazioni sul formato dei dati con un `format_options` oggetto quando si utilizzano metodi come`GlueContext.write_dynamic_frame.from_options`.
+ `s3`— Per ulteriori informazioni, vedere Tipi di connessione e opzioni per ETL in AWS Glue:[Parametri di connessione di S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Puoi anche visualizzare la documentazione relativa ai metodi che facilitano questo tipo di connessione: [create\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options) e [write\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options) in Python e i metodi Scala corrispondenti [formato def getSourceWith](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat) e [Formato def getSinkWith](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat).
+ `kinesis`— Per ulteriori informazioni, vedere Tipi di connessione e opzioni per ETL in AWS Glue:[Parametri di connessione Kinesis](aws-glue-programming-etl-connect-kinesis-home.md#aws-glue-programming-etl-connect-kinesis). Puoi anche visualizzare la documentazione relativa ai metodi che facilitano questo tipo di connessione: [create\$1data\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-options) e il metodo Scala corrispondente [def createDataFrame FromOptions](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-createDataFrameFromOptions).
+ `kafka`— Per ulteriori informazioni, vedere Tipi di connessione e opzioni per ETL in AWS Glue:[Parametri di connessione Kafka](aws-glue-programming-etl-connect-kafka-home.md#aws-glue-programming-etl-connect-kafka). Puoi anche visualizzare la documentazione relativa ai metodi che facilitano questo tipo di connessione: [create\$1data\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-options) e il metodo Scala corrispondente [def createDataFrame FromOptions](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-createDataFrameFromOptions).
Alcuni tipi di connessione non richiedono `format_options`. Ad esempio, nell'utilizzo normale, una connessione JDBC a un database relazionale recupera i dati in un formato dati tabulare coerente. Pertanto, la lettura da una connessione JDBC non richiedere `format_options`.
Alcuni metodi per la lettura e la scrittura di dati in Glue non richiedono `format_options`. Ad esempio, utilizzando `GlueContext.create_dynamic_frame.from_catalog` con i crawler AWS Glue. I crawler determinano la forma dei dati. Quando si utilizzano i crawler, un classificatore AWS Glue esaminerà i dati per prendere decisioni intelligenti su come rappresentare il formato dei dati. Quindi memorizzerà una rappresentazione dei dati nel AWS Glue Data Catalog, che può essere utilizzata all'interno di uno script AWS Glue ETL per recuperare i dati con il `GlueContext.create_dynamic_frame.from_catalog` metodo. I crawler eliminano la necessità di specificare manualmente informazioni sul formato dati.
Per i lavori che accedono a tabelle AWS Lake Formation gestite, AWS Glue supporta la lettura e la scrittura di tutti i formati supportati dalle tabelle governate da Lake Formation. Per l'elenco corrente dei formati supportati per le tabelle AWS Lake Formation governate, consulta [Notes and Restrictions for Governed Tables](https://docs.aws.amazon.com/lake-formation/latest/dg/governed-table-restrictions.html) nella *AWS Lake Formation Developer Guide*.
**Nota**
Per scrivere Apache Parquet, AWS Glue ETL supporta solo la scrittura su una tabella governata, specificando un'opzione per un tipo di scritture Parquet personalizzata ottimizzata per Dynamic Frames. Quando scrivi su una tabella governata con il formato `parquet`, è necessario aggiungere la chiave `useGlueParquetWriter` con un valore di `true` nei parametri della tabella.
**Topics**
+ [Supporto delle funzionalità per tutti i formati di dati in AWS Glue](#aws-glue-programming-etl-format-features)
+ [Parametri utilizzati per interagire con i formati di dati in AWS Glue](#aws-glue-programming-etl-format-parameters)
+ [Utilizzo del formato CSV in AWS Glue](aws-glue-programming-etl-format-csv-home.md)
+ [Utilizzo del formato Parquet in AWS Glue](aws-glue-programming-etl-format-parquet-home.md)
+ [Utilizzo del formato XML in AWS Glue](aws-glue-programming-etl-format-xml-home.md)
+ [Utilizzo del formato Avro in AWS Glue](aws-glue-programming-etl-format-avro-home.md)
+ [Utilizzo del formato GrokLog in Glue AWS](aws-glue-programming-etl-format-grokLog-home.md)
+ [Utilizzo del formato Ion in AWS Glue](aws-glue-programming-etl-format-ion-home.md)
+ [Utilizzo del formato JSON in AWS Glue](aws-glue-programming-etl-format-json-home.md)
+ [Utilizzo del formato ORC in AWS Glue](aws-glue-programming-etl-format-orc-home.md)
+ [Utilizzo di framework di data lake con AWS Glue processi ETL](aws-glue-programming-etl-datalake-native-frameworks.md)
+ [Riferimento alla configurazione condivisa](#aws-glue-programming-etl-format-shared-reference)
# Utilizzo del formato CSV in AWS Glue
AWS Glue recupera i dati dalle fonti e li scrive su destinazioni archiviate e trasportate in vari formati di dati. Se i dati vengono archiviati o trasportati nel formato dati CSV, questo documento presenta le funzionalità disponibili per l'utilizzo dei dati in Glue. AWS
AWS Glue supporta l'utilizzo del formato con valori separati da virgole (CSV). Questo formato è un formato di dati minimo basato su righe. CSVs spesso non sono strettamente conformi a uno standard, ma puoi fare riferimento a [RFC 4180 e [RFC](https://tools.ietf.org/html/rfc7111) 7111](https://tools.ietf.org/html/rfc4180) per ulteriori informazioni.
Puoi usare AWS Glue per leggere CSVs da Amazon S3 e da fonti di streaming, nonché CSVs scrivere su Amazon S3. Puoi leggere e scrivere gli archivi `bzip` e `gzip` contenenti file CSV da S3. Puoi configurare il comportamento di compressione sul [Parametri di connessione di S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) invece che nella configurazione discussa in questa pagina.
La tabella seguente mostra quali funzioni comuni di AWS Glue supportano l'opzione di formato CSV.
| Lettura | Scrittura | Lettura in streaming | Gruppo di file piccoli | Segnalibri di processo |
| --- | --- | --- | --- | --- |
| Supportata | Supportato | Supportato | Supportato | Supportata |
## Esempio: lettura di file CSV o cartelle da S3
**Prerequisiti:** avrai bisogno dei percorsi S3 (`s3path`) nei file CSV o nelle cartelle che desideri leggere.
**Configurazione :** nelle opzioni della funzione, specifica `format="csv"`. In `connection_options`, utilizzare la chiave `paths` per specificare `s3path`. Puoi configurare il modo in cui il reader interagisce con S3 in `connection_options`. Per i dettagli, vedi Tipi di connessione e opzioni per ETL in AWS Glue:[Parametri di connessione di S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Puoi configurare il modo in cui il reader interpreta i file CSV nel tuo `format_options`. Per maggiori dettagli, consulta .[Riferimento alla configurazione CSV](#aws-glue-programming-etl-format-csv-reference).
Il seguente script AWS Glue ETL mostra il processo di lettura di file o cartelle CSV da S3.
Forniamo un reader CSV personalizzato con ottimizzazioni delle prestazioni per i flussi di lavoro comuni attraverso la chiave di configurazione `optimizePerformance`. Per determinare se questo reader è adatto al tuo carico di lavoro, consulta [Ottimizza le prestazioni di lettura con il reader CSV SIMD vettorizzato](#aws-glue-programming-etl-format-simd-csv-reader).
------
#### [ Python ]
Per questo esempio, utilizzare il metodo [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
# Example: Read CSV from S3
# For show, we handle a CSV with a header row. Set the withHeader option.
# Consider whether optimizePerformance is right for your workflow.
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="csv",
format_options={
"withHeader": True,
# "optimizePerformance": True,
},
)
```
Puoi anche usarlo DataFrames in uno script (). `pyspark.sql.DataFrame`
```
dataFrame = spark.read\
.format("csv")\
.option("header", "true")\
.load("s3://s3path")
```
------
#### [ Scala ]
Per questo esempio, utilizzate l'operazione [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
// Example: Read CSV from S3
// For show, we handle a CSV with a header row. Set the withHeader option.
// Consider whether optimizePerformance is right for your workflow.
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, GlueContext}
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dynamicFrame = glueContext.getSourceWithFormat(
formatOptions=JsonOptions("""{"withHeader": true}"""),
connectionType="s3",
format="csv",
options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""")
).getDynamicFrame()
}
}
```
È inoltre possibile utilizzare DataFrames in uno script (`org.apache.spark.sql.DataFrame`).
```
val dataFrame = spark.read
.option("header","true")
.format("csv")
.load("s3://s3path“)
```
------
## Esempio: scrittura di file e cartelle CSV su S3
**Prerequisiti:** è necessario un comando inizializzato DataFrame (`dataFrame`) o un DynamicFrame (`dynamicFrame`). È necessario anche del tuo percorso di output S3 previsto, `s3path`.
**Configurazione:** nelle opzioni della funzione, specifica `format="csv"`. In `connection_options`, utilizzare la chiave `paths` per specificare `s3path`. Puoi configurare il modo in cui il writer interagisce con S3 in `connection_options`. Per i dettagli, vedi Tipi di connessione e opzioni per ETL in AWS Glue:[Parametri di connessione di S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Puoi configurare il modo in cui l'operazione scrive il contenuto dei file in `format_options`. Per maggiori dettagli, consulta .[Riferimento alla configurazione CSV](#aws-glue-programming-etl-format-csv-reference). Il seguente script ETL di AWS Glue mostra il processo di scrittura di file o cartelle CSV da S3.
------
#### [ Python ]
Per questo esempio, utilizza il metodo [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options).
```
# Example: Write CSV to S3
# For show, customize how we write string type values. Set quoteChar to -1 so our values are not quoted.
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="s3",
connection_options={"path": "s3://s3path"},
format="csv",
format_options={
"quoteChar": -1,
},
)
```
Puoi anche usare DataFrames in uno script (`pyspark.sql.DataFrame`).
```
dataFrame.write\
.format("csv")\
.option("quote", None)\
.mode("append")\
.save("s3://s3path")
```
------
#### [ Scala ]
Per questo esempio, utilizzate il metodo [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat).
```
// Example: Write CSV to S3
// For show, customize how we write string type values. Set quoteChar to -1 so our values are not quoted.
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, GlueContext}
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getSinkWithFormat(
connectionType="s3",
options=JsonOptions("""{"path": "s3://s3path"}"""),
format="csv"
).writeDynamicFrame(dynamicFrame)
}
}
```
È inoltre possibile utilizzare DataFrames in uno script (`org.apache.spark.sql.DataFrame`).
```
dataFrame.write
.format("csv")
.option("quote", null)
.mode("Append")
.save("s3://s3path")
```
------
## Riferimento alla configurazione CSV
Puoi usare quanto segue `format_options` ovunque le librerie AWS Glue lo specifichino`format="csv"`:
+ `separator`: specifica il carattere delimitatore. L'impostazione predefinita è una virgola, ma è possibile specificare qualsiasi altro carattere.
+ **Tipo:** testo, **Valore predefinito:** `","`
+ `escaper`: specifica un carattere da utilizzare per l'escape. Questa opzione viene utilizzata solo durante la lettura di file CSV e non durante la scrittura. Se questa opzione è abilitata, il carattere immediatamente seguente viene usato così come è, ad eccezione di un piccolo set di caratteri escape ben noti (`\n`, `\r`, `\t` e `\0`).
+ **Tipo:** testo, **Valore predefinito:** nessuno
+ `quoteChar`: specifica il carattere da usare per le virgolette. Per impostazione predefinita, vengono usate le virgolette doppie. Imposta questo valore su `-1` per disattivare completamente le virgolette.
+ **Tipo:** testo, **Valore predefinito:** `'"'`
+ `multiLine`: specifica se un singolo record può estendersi su più righe. Ciò può accadere quando un campo contiene un carattere di nuova riga tra virgolette. Imposta questa opzione su `True` se i registri si estendono su più righe. L'abilitazione di `multiLine` potrebbe ridurre le prestazioni perché richiede una divisione dei file più cauta durante l'analisi.
+ **Tipo:** booleano, **Valore predefinito:** `false`
+ `withHeader`: specifica se trattare la prima riga come intestazione. Questa opzione può essere usata nella classe `DynamicFrameReader`.
+ **Tipo:** booleano, **Valore predefinito:** `false`
+ `writeHeader`: specifica se scrivere l'intestazione nell'output. Questa opzione può essere usata nella classe `DynamicFrameWriter`.
+ **Tipo:** booleano, **Valore predefinito:** `true`
+ `skipFirst`: specifica se ignorare la prima riga di dati.
+ **Tipo:** booleano, **Valore predefinito:** `false`
+ `optimizePerformance`: specifica se utilizzare il reader CSV SIMD avanzato insieme ai formati di memoria colonnare basati su Apache Arrow. Disponibile solo in AWS Glue versione 3.0 o successiva.
+ **Tipo:** booleano, **Valore predefinito:** `false`
+ `strictCheckForQuoting`— Durante la scrittura CSVs, Glue può aggiungere virgolette ai valori che interpreta come stringhe. Questo viene fatto per evitare ambiguità in ciò che viene scritto. Per risparmiare tempo nella decisione su cosa scrivere, Glue può utilizzare le virgolette in determinate situazioni in cui in realtà non sono necessarie. L'attivazione di un controllo rigoroso eseguirà un calcolo più intensivo e ricorrerà alle virgolette solo quando strettamente necessario. Disponibile solo in AWS Glue versione 3.0 o successiva.
+ **Tipo:** booleano, **Valore predefinito:** `false`
## Ottimizza le prestazioni di lettura con il reader CSV SIMD vettorizzato
AWS Glue versione 3.0 aggiunge un lettore CSV ottimizzato che può velocizzare significativamente le prestazioni complessive del lavoro rispetto ai reader CSV basati su righe.
Il reader ottimizzato:
+ Usa le istruzioni SIMD della CPU per leggere dal disco
+ Scrive immediatamente i record in memoria in un formato colonnare (Apache Arrow)
+ Divide i record in batch
Ciò consente di risparmiare tempo di elaborazione quando i record verranno raggruppati in batch o convertiti in un formato colonnare in un secondo momento. Alcuni esempi sono quando si modificano schemi o si recuperano i dati in base alla colonna.
Per utilizzare il reader ottimizzato, imposta `"optimizePerformance"` su `true` nelle `format_options` o nella proprietà della tabella.
```
glueContext.create_dynamic_frame.from_options(
frame = datasource1,
connection_type = "s3",
connection_options = {"paths": ["s3://s3path"]},
format = "csv",
format_options={
"optimizePerformance": True,
"separator": ","
},
transformation_ctx = "datasink2")
```
**Limitazioni per il reader CSV vettorizzato**
Tieni presente le seguenti limitazioni del reader CSV vettorizzato:
+ Non supporta il le opzioni di formato `multiLine` e `escaper`. Utilizza l'`escaper` predefinito del carattere doppia virgoletta `'"'`. Quando queste opzioni sono impostate, AWS Glue torna automaticamente a utilizzare il reader CSV basato su righe.
+ Non supporta la creazione di un con DynamicFrame . [ChoiceType](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-pyspark-extensions-types.html#aws-glue-api-crawler-pyspark-extensions-types-awsglue-choicetype)
+ Non supporta la creazione di [record DynamicFrame di errori](https://docs.aws.amazon.com/glue/latest/dg/glue-etl-scala-apis-glue-dynamicframe-class.html#glue-etl-scala-apis-glue-dynamicframe-class-defs-errorsAsDynamicFrame).
+ Non supporta la lettura di file CSV con caratteri multibyte, come i caratteri giapponesi o cinesi.
# Utilizzo del formato Parquet in AWS Glue
AWS Glue recupera i dati dalle fonti e li scrive su destinazioni archiviate e trasportate in vari formati di dati. Se i dati vengono archiviati o trasportati nel formato dati Parquet, questo documento presenta le funzionalità disponibili per l'utilizzo dei dati in AWS Glue.
AWS Glue supporta l'utilizzo del formato Parquet. Questo formato è un formato dati basato su colonne orientato alle prestazioni. Per un'introduzione al formato da parte dell'autorità standard, consulta [Panoramica della documentazione di Apache Parquet](https://parquet.apache.org/docs/overview/).
Puoi usare AWS Glue per leggere file Parquet da Amazon S3 e da sorgenti di streaming, nonché scrivere file Parquet su Amazon S3. Puoi leggere e scrivere gli archivi `bzip` e `gzip` contenenti file Parquet da S3. Puoi configurare il comportamento di compressione sul [Parametri di connessione di S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) invece che nella configurazione discussa in questa pagina.
La tabella seguente mostra quali funzioni comuni di AWS Glue supportano l'opzione di formato Parquet.
| Lettura | Scrittura | Lettura in streaming | Gruppo di file piccoli | Segnalibri di processo |
| --- | --- | --- | --- | --- |
| Supportata | Supportato | Supportata | Non supportato. | Supportato\$1 |
\$1 Supportato nella versione AWS Glue 1.0\$1
## Esempio: lettura di file Parquet o cartelle da S3
**Prerequisiti:** avrai bisogno dei percorsi S3 (`s3path`) nei file Parquet o nelle cartelle che desideri leggere.
**Configurazione:** nelle opzioni della funzione, specifica `format="parquet"`. Nelle tue `connection_options`, utilizza la chiave `paths` per specificare `s3path`.
Puoi configurare il modo in cui il reader interagisce con S3 in `connection_options`. Per i dettagli, vedi Tipi di connessione e opzioni per ETL in AWS Glue:[Parametri di connessione di S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3).
Puoi configurare il modo in cui il reader interpreta i file Parquet nel tuo `format_options`. Per maggiori dettagli, consulta [Riferimento alla configurazione Parquet](#aws-glue-programming-etl-format-parquet-reference).
Il seguente script AWS Glue ETL mostra il processo di lettura dei file o delle cartelle Parquet da S3:
------
#### [ Python ]
Per questo esempio, utilizzare il metodo [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
# Example: Read Parquet from S3
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type = "s3",
connection_options = {"paths": ["s3://s3path/"]},
format = "parquet"
)
```
Puoi anche usarlo DataFrames in uno script ()`pyspark.sql.DataFrame`.
```
dataFrame = spark.read.parquet("s3://s3path/")
```
------
#### [ Scala ]
Per questo esempio, utilizzate il metodo [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
// Example: Read Parquet from S3
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, GlueContext}
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType="s3",
format="parquet",
options=JsonOptions("""{"paths": ["s3://s3path"]}""")
).getDynamicFrame()
}
}
```
È inoltre possibile utilizzare DataFrames in uno script (`org.apache.spark.sql.DataFrame`).
```
spark.read.parquet("s3://s3path/")
```
------
## Esempio: scrittura di file e cartelle Parquet su S3
**Prerequisiti:** è necessario un DataFrame (`dataFrame`) o DynamicFrame (`dynamicFrame`) inizializzato. È necessario anche del tuo percorso di output S3 previsto, `s3path`.
**Configurazione:** nelle opzioni della funzione, specifica `format="parquet"`. In `connection_options`, utilizzare la chiave `paths` per specificare `s3path`.
È possibile modificare ulteriormente il modo in cui il writer interagisce con S3 nelle `connection_options`. Per i dettagli, vedi Tipi di connessione e opzioni per ETL in AWS Glue:[Parametri di connessione di S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Puoi configurare il modo in cui l'operazione scrive il contenuto dei file in `format_options`. Per maggiori dettagli, consulta .[Riferimento alla configurazione Parquet](#aws-glue-programming-etl-format-parquet-reference).
Il seguente script AWS Glue ETL mostra il processo di scrittura di file e cartelle Parquet su S3.
Forniamo uno scrittore Parquet personalizzato con ottimizzazioni delle prestazioni DynamicFrames, tramite la `useGlueParquetWriter` chiave di configurazione. Per determinare se questo writer è adatto al tuo carico di lavoro, consulta [Scrittore Glue Parquet](#aws-glue-programming-etl-format-glue-parquet-writer).
------
#### [ Python ]
Per questo esempio, utilizza il metodo [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options).
```
# Example: Write Parquet to S3
# Consider whether useGlueParquetWriter is right for your workflow.
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="s3",
format="parquet",
connection_options={
"path": "s3://s3path",
},
format_options={
# "useGlueParquetWriter": True,
},
)
```
Puoi anche usarlo DataFrames in uno script (`pyspark.sql.DataFrame`).
```
df.write.parquet("s3://s3path/")
```
------
#### [ Scala ]
Per questo esempio, utilizzate il metodo [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat).
```
// Example: Write Parquet to S3
// Consider whether useGlueParquetWriter is right for your workflow.
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, GlueContext}
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getSinkWithFormat(
connectionType="s3",
options=JsonOptions("""{"path": "s3://s3path"}"""),
format="parquet"
).writeDynamicFrame(dynamicFrame)
}
}
```
È inoltre possibile utilizzare DataFrames in uno script (`org.apache.spark.sql.DataFrame`).
```
df.write.parquet("s3://s3path/")
```
------
## Riferimento alla configurazione Parquet
Puoi usare quanto segue `format_options` ovunque le librerie AWS Glue lo specifichino`format="parquet"`:
+ `useGlueParquetWriter`— Speciifica l'uso di un writer Parquet personalizzato con ottimizzazioni delle prestazioni per DynamicFrame i flussi di lavoro. Per informazioni dettagliate sull'utilizzo, consulta [Writer Glue Parquet](#aws-glue-programming-etl-format-glue-parquet-writer).
+ **Tipo:** booleano, **Valore predefinito:** `false`
+ `compression`: specifica il codec di compressione utilizzato. I valori sono pienamente compatibili con `org.apache.parquet.hadoop.metadata.CompressionCodecName`.
+ **Tipo:** testo enumerato, **Valore predefinito:** `"snappy"`
+ Valori: `"uncompressed"`, `"snappy"`, `"gzip"` e `"lzo"`
+ `blockSize`: specifica la dimensione in byte di un gruppo di righe memorizzate nel buffer in memoria. Utilizzi questo valore per ottimizzare le prestazioni. Le dimensioni dovrebbero dividersi esattamente in un numero di megabyte.
+ **Tipo:** numerico, **Valore predefinito:** `134217728`
+ Il valore predefinito è 128 MB.
+ `pageSize`: specifica le dimensioni in byte di una pagina. Utilizzi questo valore per ottimizzare le prestazioni. Una pagina è l'unità più piccola che deve essere letta interamente per accedere a un singolo record.
+ **Tipo:** numerico, **Valore predefinito:** `1048576`
+ Il valore predefinito è 1 MB.
**Nota**
Inoltre, tutte le opzioni accettate dal codice SparkSQL sottostante possono essere passate tramite il parametro mappa `connection_options`. Ad esempio, puoi impostare una configurazione Spark come [mergeSchema](https://spark.apache.org/docs/latest/sql-data-sources-parquet.html#schema-merging) per il reader Spark di AWS Glue per unire lo schema di tutti i file.
## Ottimizza le prestazioni di scrittura con AWS Glue Parquet writer
**Nota**
Storicamente si accedeva al writer AWS Glue Parquet tramite il tipo di `glueparquet` formato. Questo schema di accesso non è più raccomandato. Utilizza invece il tipo `parquet` con `useGlueParquetWriter` abilitato.
Il AWS masterizzatore Glue Parquet presenta miglioramenti delle prestazioni che consentono una scrittura più rapida dei file Parquet. Il writer tradizionale calcola uno schema prima della scrittura. Il formato Parquet non memorizza lo schema in un modo recuperabile rapidamente, quindi questa operazione potrebbe richiedere del tempo. Con lo scrittore AWS Glue Parquet, non è necessario uno schema precalcolato. Quando arrivano i dati, il writer calcola e modifica lo schema in modo dinamico.
Quando specifichi `useGlueParquetWriter`, tieni presente le seguenti limitazioni:
+ Il writer supporta solo l'evoluzione dello schema, come l'aggiunta o la rimozione di colonne, ma non la modifica dei tipi di colonna, ad esempio con `ResolveChoice`.
+ Lo scrittore non supporta la scrittura vuota, ad esempio DataFrames per scrivere un file contenente solo uno schema. Quando si esegue l'integrazione con AWS Glue Data Catalog tramite impostazione`enableUpdateCatalog=True`, il tentativo di scrivere uno spazio vuoto non DataFrame aggiornerà il Data Catalog. Il nome di una tabella nel Catalogo dati.
Se la trasformazione non richiede queste limitazioni, l'attivazione dello scrittore AWS Glue Parquet dovrebbe aumentare le prestazioni.
# Utilizzo del formato XML in AWS Glue
AWS Glue recupera i dati dalle fonti e li scrive su destinazioni archiviate e trasportate in vari formati di dati. Se i dati vengono archiviati o trasportati nel formato di dati XML, questo documento presenta le funzionalità disponibili per l'utilizzo dei dati in AWS Glue.
AWS Glue supporta l'utilizzo del formato XML. Questo formato rappresenta strutture dati altamente configurabili e rigidamente definite che non sono basate su righe o colonne. XML è altamente standardizzato. Per un'introduzione al formato da parte dell'autorità di standard, consulta [Informazioni essenziali su XML](https://www.w3.org/standards/xml/core).
Puoi usare AWS Glue per leggere file XML da Amazon S3 `bzip` e `gzip` archivi contenenti file XML. Puoi configurare il comportamento di compressione sul [Parametri di connessione di S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) invece che nella configurazione discussa in questa pagina.
La tabella seguente mostra quali funzioni comuni di AWS Glue supportano l'opzione di formato XML.
| Lettura | Scrittura | Lettura in streaming | Gruppo di file piccoli | Segnalibri di processo |
| --- | --- | --- | --- | --- |
| Supportata | Non supportato. | Non supportato. | Supportata | Supportata |
## Esempio: lettura di XML da S3
Il reader XML assume un nome di tag XML. Esamina gli elementi con quel tag all'interno del relativo input per dedurre uno schema e compila un DynamicFrame con i valori corrispondenti. La funzionalità AWS Glue XML si comporta in modo simile alla [sorgente dati XML per Apache](https://github.com/databricks/spark-xml) Spark. Potresti essere in grado di ottenere informazioni sul comportamento di base confrontando questo reader con la documentazione di quel progetto.
**Prerequisiti:** avrai bisogno dei percorsi S3 (`s3path`) nei file XML o nelle cartelle che desideri leggere e di alcune informazioni sul file XML. Avrai bisogno anche del tag per l'elemento XML che desideri leggere, `xmlTag`.
**Configurazione:** nelle opzioni della funzione, specifica `format="xml"`. In `connection_options`, utilizza la chiave `paths` per specificare `s3path`. Puoi configurare il modo in cui il reader interagisce con S3 in `connection_options`. Per i dettagli, vedi Tipi di connessione e opzioni per ETL in AWS Glue:[Parametri di connessione di S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). In `format_options`, utilizza la chiave `rowTag` per specificare `xmlTag`. Puoi configurare il modo in cui il reader interpreta i file XML nel tuo `format_options`. Per maggiori dettagli, consulta [Riferimento alla configurazione XML](#aws-glue-programming-etl-format-xml-reference).
Il seguente script ETL di AWS Glue mostra il processo di lettura di file o cartelle XML da S3.
------
#### [ Python ]
Per questo esempio, utilizza il metodo [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
# Example: Read XML from S3
# Set the rowTag option to configure the reader.
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="xml",
format_options={"rowTag": "xmlTag"},
)
```
Puoi anche usare DataFrames in uno script (`pyspark.sql.DataFrame`).
```
dataFrame = spark.read\
.format("xml")\
.option("rowTag", "xmlTag")\
.load("s3://s3path")
```
------
#### [ Scala ]
Per questo esempio, utilizzate l'operazione [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
// Example: Read XML from S3
// Set the rowTag option to configure the reader.
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.GlueContext
import org.apache.spark.sql.SparkSession
val glueContext = new GlueContext(SparkContext.getOrCreate())
val sparkSession: SparkSession = glueContext.getSparkSession
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val dynamicFrame = glueContext.getSourceWithFormat(
formatOptions=JsonOptions("""{"rowTag": "xmlTag"}"""),
connectionType="s3",
format="xml",
options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""")
).getDynamicFrame()
}
```
È inoltre possibile utilizzare DataFrames in uno script (`org.apache.spark.sql.DataFrame`).
```
val dataFrame = spark.read
.option("rowTag", "xmlTag")
.format("xml")
.load("s3://s3path“)
```
------
## Riferimento alla configurazione XML
Puoi usare quanto segue `format_options` ovunque le librerie AWS Glue lo specifichino`format="xml"`:
+ `rowTag`: specifica il tag XML nel file da trattare come riga. I tag di riga non possono essere con chiusura automatica.
+ **Tipo:** testo, **obbligatorio**
+ `encoding`: specifica la codifica dei caratteri. Può essere il nome o l'alias di un [Charset](https://docs.oracle.com/javase/8/docs/api/java/nio/charset/Charset.html) supportato dal nostro ambiente di runtime. Non forniamo garanzie specifiche sul supporto della codifica, ma le codifiche principali dovrebbero funzionare.
+ **Tipo:** testo, **Valore predefinito:** `"UTF-8"`
+ `excludeAttribute`: specifica se escludere o meno gli attributi negli elementi.
+ **Tipo:** booleano, **Valore predefinito:** `false`
+ `treatEmptyValuesAsNulls`: specifica se trattare uno spazio vuoto come valore null.
+ **Tipo:** booleano, **Valore predefinito:** `false`
+ `attributePrefix`: un prefisso per gli attributi, per differenziarli dal testo degli elementi figlio. Questo prefisso viene usato per i nomi di campi.
+ **Tipo:** testo, **Valore predefinito:** `"_"`
+ `valueTag`: il tag usato per un valore quando ci sono attributi nell'elemento che non hanno elementi figlio.
+ **Tipo:** testo, **Valore predefinito:** `"_VALUE"`
+ `ignoreSurroundingSpaces`: specifica se lo spazio vuoto intorno ai valori deve essere ignorato.
+ **Tipo:** booleano, **Valore predefinito:** `false`
+ `withSchema`: contiene lo schema previsto, in situazioni in cui si desidera sovrascrivere lo schema dedotto. Se non utilizzi questa opzione, AWS Glue deduce lo schema dai dati XML.
+ **Tipo:** testo, **Valore predefinito:** non applicabile
+ Il valore deve essere un oggetto JSON che rappresenta un `StructType`.
## Specifica manuale dello schema XML
**Esempio di schema XML manuale**
Questo è un esempio dell'utilizzo di `withSchema` per specificare lo schema per i dati XML.
```
from awsglue.gluetypes import *
schema = StructType([
Field("id", IntegerType()),
Field("name", StringType()),
Field("nested", StructType([
Field("x", IntegerType()),
Field("y", StringType()),
Field("z", ChoiceType([IntegerType(), StringType()]))
]))
])
datasource0 = create_dynamic_frame_from_options(
connection_type,
connection_options={"paths": ["s3://xml_bucket/someprefix"]},
format="xml",
format_options={"withSchema": json.dumps(schema.jsonValue())},
transformation_ctx = ""
)
```
# Utilizzo del formato Avro in AWS Glue
AWS Glue recupera i dati dalle fonti e li scrive su destinazioni archiviate e trasportate in vari formati di dati. Se i dati vengono archiviati o trasportati nel formato dati Avro, questo documento presenta le funzionalità disponibili per l'utilizzo dei dati in Glue. AWS
AWS Glue supporta l'utilizzo del formato Avro. Questo formato è un formato dati basato su righe orientato alle prestazioni. Per un'introduzione al formato da parte dell'autorità degli standard, consulta la [Documentazione di Apache Avro 1.8.2](https://avro.apache.org/docs/1.8.2/).
Puoi usare AWS Glue per leggere file Avro da Amazon S3 e da sorgenti di streaming, nonché scrivere file Avro su Amazon S3. Puoi leggere e scrivere archivi `bzip2` e `gzip` contenenti file Avro da S3. Inoltre, è possibile scrivere archivi `deflate`, `snappy` e `xz` contenenti file Avro. Puoi configurare il comportamento di compressione sul [Parametri di connessione di S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) invece che nella configurazione discussa in questa pagina.
La tabella seguente mostra quali operazioni comuni di AWS Glue supportano l'opzione di formato Avro.
| Lettura | Scrittura | Lettura in streaming | Gruppo di file piccoli | Segnalibri di processo |
| --- | --- | --- | --- | --- |
| Supportata | Supportata | Supportato\$1 | Non supportato. | Supportata |
\$1 Supportato con restrizioni. Per ulteriori informazioni, consulta [Note e restrizioni per le origini di streaming Avro](add-job-streaming.md#streaming-avro-notes).
## Esempio: lettura di cartelle o file Avro da S3
**Prerequisiti:** occorrono i percorsi S3 (`s3path`) nelle cartelle o nei file Avro da leggere.
**Configurazione:** nelle opzioni della funzione, specifica `format="avro"`. In `connection_options`, utilizzare la chiave `paths` per specificare `s3path`. Puoi configurare il modo in cui il reader interagisce con S3 in `connection_options`. Per i dettagli, vedi Opzioni di formato dei dati per ingressi e uscite ETL in AWS Glue:. [Indicazioni di riferimento alle opzioni di connessione ad Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) Puoi configurare la modalità con cui il reader interpreta i file Avro CSV in `format_options`. Per i dettagli, consulta [Documentazione di riferimento della configurazione Avro](#aws-glue-programming-etl-format-avro-reference).
Il seguente script AWS Glue ETL mostra il processo di lettura dei file o delle cartelle Avro da S3:
------
#### [ Python ]
Per questo esempio, utilizzare il metodo [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="avro"
)
```
------
#### [ Scala ]
[Per questo esempio, utilizzate l'operazione Format. getSourceWith](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat)
```
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.GlueContext
import org.apache.spark.sql.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType="s3",
format="avro",
options=JsonOptions("""{"paths": ["s3://s3path"]}""")
).getDynamicFrame()
}
```
------
## Esempio: scrittura di file e cartelle Avro in S3
**Prerequisiti:** è necessario un DataFrame (`dataFrame`) o DynamicFrame (`dynamicFrame`) inizializzato. È necessario anche del tuo percorso di output S3 previsto, `s3path`.
**Configurazione:** nelle opzioni della funzione, specifica `format="avro"`. Nelle tue `connection_options`, utilizza la chiave `paths` per specificare `s3path`. È possibile modificare ulteriormente il modo in cui il writer interagisce con S3 nelle `connection_options`. Per i dettagli, vedi Opzioni di formato dei dati per ingressi e uscite ETL in AWS Glue:. [Indicazioni di riferimento alle opzioni di connessione ad Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) Puoi modificare la modalità con cui il writer interpreta i file Avro in `format_options`. Per i dettagli, consulta [Documentazione di riferimento della configurazione Avro](#aws-glue-programming-etl-format-avro-reference).
Il seguente script AWS Glue ETL mostra il processo di scrittura di file o cartelle Avro su S3.
------
#### [ Python ]
Per questo esempio, utilizza il metodo [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options).
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="s3",
format="avro",
connection_options={
"path": "s3://s3path"
}
)
```
------
#### [ Scala ]
[Per questo esempio, utilizzate il metodo Format. getSinkWith](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat)
```
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, GlueContext}
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getSinkWithFormat(
connectionType="s3",
options=JsonOptions("""{"path": "s3://s3path"}"""),
format="avro"
).writeDynamicFrame(dynamicFrame)
}
}
```
------
## Documentazione di riferimento della configurazione Avro
È possibile utilizzare i seguenti `format_options` valori ovunque specifichino le librerie AWS Glue`format="avro"`:
+ `version`— Speciifica la versione del reader/writer formato Apache Avro da supportare. Il valore predefinito è 1.7. Puoi specificare `format_options={"version": “1.8”}` per abilitare la lettura e la scrittura del tipo logico Avro. Per ulteriori informazioni, consulta [Specifiche di Apache Avro 1.7.7](https://avro.apache.org/docs/1.7.7/spec.html) e [Specifiche di Apache Avro 1.8.2](https://avro.apache.org/docs/1.8.2/spec.html).
Il connettore Apache Avro 1.8 supporta le seguenti conversioni di tipo logico:
Per le operazioni di lettura: questa tabella mostra la conversione tra il tipo di dati Avro (tipo logico e tipo primitivo Avro) e il tipo di dati AWS Glue `DynamicFrame` per le operazioni di lettura Avro 1.7 e 1.8.
| Tipo di dati Avro: Tipo logico | Tipo di dati Avro: Tipi primitivi .NET | GlueDynamicFrame Tipo di dati:Avro Reader 1.7 | GlueDynamicFrame Tipo di dati: Avro Reader 1.8 |
| --- | --- | --- | --- |
| Decimale | bytes | BINARY | Decimale |
| Decimale | fisso | BINARY | Decimale |
| Data | int | INT | Data |
| Tempo (millisecondi) | int | INT | INT |
| Tempo (microsecondi) | Long | LONG | LONG |
| Timestamp (millisecondi) | Long | LONG | Time stamp |
| Timestamp (microsecondi) | Long | LONG | LONG |
| Durata (non un tipo logico) | fisso di 12 | BINARY | BINARY |
Per le operazioni di scrittura: questa tabella mostra la conversione tra il tipo di dati AWS Glue `DynamicFrame` e il tipo di dati Avro per le operazioni di scrittura Avro 1.7 e 1.8.
| Tipo di dati AWS Glue `DynamicFrame` | Tipo di dati Avro:Avro Writer 1.7 | Tipo di dati Avro:Avro Writer 1.8 |
| --- | --- | --- |
| Decimale | Stringa | decimal |
| Data | Stringa | data |
| Time stamp | Stringa | timestamp-micros |
## Supporto Avro Spark DataFrame
Per utilizzare Avro dall' DataFrame API Spark, devi installare il plug-in Spark Avro per la versione Spark corrispondente. La versione di Spark disponibile nel tuo job è determinata dalla versione di AWS Glue in uso. Per ulteriori informazioni sulle versioni di Spark, consulta [AWS Glue versioni](release-notes.md). Questo plugin è gestito da Apache; non forniamo garanzie specifiche sul supporto.
In AWS Glue 2.0, usa la versione 2.4.3 del plugin Spark Avro. Puoi trovare questo JAR su Maven Central, consulta [org.apache.spark:spark-avro\$12.12:2.4.3](https://search.maven.org/artifact/org.apache.spark/spark-avro_2.12/3.1.1/jar).
In AWS Glue 3.0, usa la versione 3.1.1 del plugin Spark Avro. Puoi trovare questo JAR su Maven Central, consulta [org.apache.spark:spark-avro\$12.12:3.1.1](https://search.maven.org/artifact/org.apache.spark/spark-avro_2.12/3.1.1/jar).
Per includere elementi aggiuntivi JARs in un lavoro AWS Glue ETL, utilizzate il parametro `--extra-jars` job. Per ulteriori informazioni sui parametri di processo, consulta [Utilizzo dei parametri del lavoro nei lavori AWS Glue](aws-glue-programming-etl-glue-arguments.md). Puoi configurare questo parametro anche nella Console di gestione AWS.
# Utilizzo del formato GrokLog in Glue AWS
AWS Glue recupera i dati dalle fonti e li scrive su destinazioni archiviate e trasportate in vari formati di dati. Se i dati vengono archiviati o trasportati in un formato di testo semplice strutturato in modo lasco, questo documento presenta le funzionalità disponibili per l'utilizzo dei dati nei modelli AWS Glue through Grok.
AWS Glue supporta utilizzando modelli Grok. I modelli Grok sono simili a gruppi di acquisizione di espressioni regolari. Riconoscono modelli di sequenze di caratteri in un file di testo semplice e forniscono loro un tipo e uno scopo. In AWS Glue, il loro scopo principale è leggere i log. Per un'introduzione a Grok da parte degli autori, consulta [Documentazione di riferimento di Logstash: plugin per filtri Grok](https://www.elastic.co/guide/en/logstash/current/plugins-filters-grok.html).
| Lettura | Scrittura | Lettura in streaming | Gruppo di file piccoli | Segnalibri di processo |
| --- | --- | --- | --- | --- |
| Supportata | Non applicabile | Supportata | Supportata | Non supportato. |
## Documentazione di riferimento sulla configurazione grokLog
È possibile usare i valori di `format_options` seguenti con `format="grokLog"`:
+ `logFormat`: specifica il pattern grok corrispondente al formato del log.
+ `customPatterns`: specifica ulteriori pattern Grok usati.
+ `MISSING`: specifica il segnale da usare per identificare i valori mancanti. Il valore predefinito è `'-'`.
+ `LineCount`: specifica il numero di righe in ogni record di log. Il valore predefinito è `'1'` e attualmente sono supportati solo record a riga singola.
+ `StrictMode`: valore booleano che specifica se la modalità strict è abilitata. In modalità strict, il lettore non esegue la conversione o il ripristino automatico dei tipi. Il valore predefinito è `"false"`.
# Utilizzo del formato Ion in AWS Glue
AWS Glue recupera i dati dalle fonti e li scrive su destinazioni archiviate e trasportate in vari formati di dati. Se i dati vengono archiviati o trasportati nel formato dati Ion, questo documento presenta le funzionalità disponibili per l'utilizzo dei dati in AWS Glue.
AWS Glue supporta l'utilizzo del formato Ion. Questo formato rappresenta strutture di dati (che non sono basate su righe o colonne) in rappresentazioni binarie e di testo semplice intercambiabili. Per un'introduzione al formato da parte degli autori, consulta [Amazon Ion](https://amzn.github.io/ion-docs/). Per ulteriori informazioni consulta la [specifica Amazon Ion](https://amzn.github.io/ion-docs/spec.html).
Puoi usare AWS Glue per leggere file Ion da Amazon S3. Puoi leggere e scrivere archivi `bzip` e `gzip` contenenti file Ion da S3. Puoi configurare il comportamento di compressione sul [Parametri di connessione di S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) invece che nella configurazione discussa in questa pagina.
La tabella seguente mostra quali operazioni comuni di AWS Glue supportano l'opzione di formato Ion.
| Lettura | Scrittura | Lettura in streaming | Gruppo di file piccoli | Segnalibri di processo |
| --- | --- | --- | --- | --- |
| Supportata | Non supportato. | Non supportato. | Supportata | Non supportato. |
## Esempio: lettura di cartelle e file Ion da S3
**Prerequisiti:** occorreranno i percorsi S3 (`s3path`) nelle cartelle o nei file Ion da leggere.
**Configurazione:** nelle opzioni della funzione, specifica `format="json"`. Nelle tue `connection_options`, utilizza la chiave `paths` per specificare `s3path`. Puoi configurare il modo in cui il reader interagisce con S3 in `connection_options`. Per i dettagli, vedi Tipi di connessione e opzioni per ETL in AWS Glue:[Indicazioni di riferimento alle opzioni di connessione ad Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3).
Il seguente script AWS Glue ETL mostra il processo di lettura di file o cartelle Ion da S3:
------
#### [ Python ]
Per questo esempio, utilizzare il metodo [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
# Example: Read ION from S3
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="ion"
)
```
------
#### [ Scala ]
Per questo esempio, utilizzate l'operazione [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
// Example: Read ION from S3
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.GlueContext
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType="s3",
format="ion",
options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""")
).getDynamicFrame()
}
}
```
------
## Documentazione di riferimento della configurazione Ion
Non ci sono valori di `format_options` per `format="ion"`.
# Utilizzo del formato JSON in AWS Glue
AWS Glue recupera i dati dalle fonti e li scrive su destinazioni archiviate e trasportate in vari formati di dati. Se i dati vengono archiviati o trasportati nel formato dati JSON, questo documento presenta le funzionalità disponibili per l'utilizzo dei dati in Glue. AWS
AWS Glue supporta l'utilizzo del formato JSON. Questo formato rappresenta strutture di dati con forma coerente ma contenuti flessibili, che non sono basate su righe o colonne. JSON è definito tramite standard paralleli emessi da diverse autorità, una delle quali è ECMA-404. Per un'introduzione al formato da una fonte di riferimento comune, consulta [Introduzione a JSON](https://www.json.org/).
Puoi usare AWS Glue per leggere file JSON da Amazon S3 `gzip` e file JSON compressi. `bzip` Puoi configurare il comportamento di compressione sul [Parametri di connessione di S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) invece che nella configurazione discussa in questa pagina.
| Lettura | Scrittura | Lettura in streaming | Gruppo di file piccoli | Segnalibri di processo |
| --- | --- | --- | --- | --- |
| Supportata | Supportato | Supportato | Supportato | Supportata |
## Esempio: lettura di cartelle o file JSON da S3
**Prerequisiti:** occorrono i percorsi S3 (`s3path`) nelle cartelle o nei file JSON da leggere.
**Configurazione:** nelle opzioni della funzione, specifica `format="json"`. Nelle tue `connection_options`, utilizza la chiave `paths` per specificare `s3path`. Puoi modificare ulteriormente la modalità con cui l'operazione di lettura attraversa s3 nelle opzioni di connessione; consulta [Indicazioni di riferimento alle opzioni di connessione ad Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) per dettagli. Puoi configurare la modalità con cui il reader interpreta i file JSON in `format_options`. Per i dettagli, consulta la [Documentazione di riferimento della configurazione JSON](#aws-glue-programming-etl-format-json-reference).
Il seguente script AWS Glue ETL mostra il processo di lettura di file o cartelle JSON da S3:
------
#### [ Python ]
Per questo esempio, utilizzare il metodo [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
# Example: Read JSON from S3
# For show, we handle a nested JSON file that we can limit with the JsonPath parameter
# For show, we also handle a JSON where a single entry spans multiple lines
# Consider whether optimizePerformance is right for your workflow.
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="json",
format_options={
"jsonPath": "$.id",
"multiline": True,
# "optimizePerformance": True, -> not compatible with jsonPath, multiline
}
)
```
Puoi anche usarlo DataFrames in uno script (). `pyspark.sql.DataFrame`
```
dataFrame = spark.read\
.option("multiline", "true")\
.json("s3://s3path")
```
------
#### [ Scala ]
Per questo esempio, utilizzate l'operazione [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
// Example: Read JSON from S3
// For show, we handle a nested JSON file that we can limit with the JsonPath parameter
// For show, we also handle a JSON where a single entry spans multiple lines
// Consider whether optimizePerformance is right for your workflow.
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, GlueContext}
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dynamicFrame = glueContext.getSourceWithFormat(
formatOptions=JsonOptions("""{"jsonPath": "$.id", "multiline": true, "optimizePerformance":false}"""),
connectionType="s3",
format="json",
options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""")
).getDynamicFrame()
}
}
```
È inoltre possibile utilizzare DataFrames in uno script (`pyspark.sql.DataFrame`).
```
val dataFrame = spark.read
.option("multiline", "true")
.json("s3://s3path")
```
------
## Esempio: scrittura di file e cartelle JSON su S3
**Prerequisiti:** è necessario un DataFrame (`dataFrame`) o DynamicFrame (`dynamicFrame`) inizializzato. È necessario anche del tuo percorso di output S3 previsto, `s3path`.
**Configurazione:** nelle opzioni della funzione, specifica `format="json"`. In `connection_options`, utilizzare la chiave `paths` per specificare `s3path`. È possibile modificare ulteriormente il modo in cui il writer interagisce con S3 nelle `connection_options`. Per i dettagli, vedi Opzioni di formato dei dati per ingressi e uscite ETL in AWS Glue:. [Indicazioni di riferimento alle opzioni di connessione ad Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) È possibile configurare la modalità con cui il writer interpreta i file JSON in `format_options`. Per i dettagli, consultare la [Documentazione di riferimento della configurazione JSON](#aws-glue-programming-etl-format-json-reference).
Il seguente script AWS Glue ETL mostra il processo di scrittura di file o cartelle JSON da S3:
------
#### [ Python ]
Per questo esempio, utilizza il metodo [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options).
```
# Example: Write JSON to S3
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="s3",
connection_options={"path": "s3://s3path"},
format="json"
)
```
Puoi anche usarlo DataFrames in uno script (). `pyspark.sql.DataFrame`
```
df.write.json("s3://s3path/")
```
------
#### [ Scala ]
Per questo esempio, utilizzate il metodo [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat).
```
// Example: Write JSON to S3
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, GlueContext}
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getSinkWithFormat(
connectionType="s3",
options=JsonOptions("""{"path": "s3://s3path"}"""),
format="json"
).writeDynamicFrame(dynamicFrame)
}
}
```
È inoltre possibile utilizzare DataFrames in uno script (`pyspark.sql.DataFrame`).
```
df.write.json("s3://s3path")
```
------
## Documentazione di riferimento della configurazione JSON
È possibile usare i valori di `format_options` seguenti con `format="json"`:
+ `jsonPath`— Un'[JsonPath](https://github.com/json-path/JsonPath)espressione che identifica un oggetto da leggere nei record. È particolarmente utile quando un file contiene registri annidati in una matrice esterna. Ad esempio, l' JsonPath espressione seguente si rivolge al `id` campo di un oggetto JSON.
```
format="json", format_options={"jsonPath": "$.id"}
```
+ `multiline`: un valore booleano che specifica se un singolo registro può estendersi su più righe. Ciò può accadere quando un campo contiene un carattere di nuova riga tra virgolette. Imposta questa opzione su `"true"` se i registri si estendono su più righe. Il valore di default è `"false"`, che consente una divisione dei file più netta durante l'analisi.
+ `optimizePerformance`: valore booleano che specifica se utilizzare il lettore JSON SIMD avanzato insieme ai formati di memoria colonnare basati su Apache Arrow. Disponibile solo in AWS Glue 3.0. Non compatibile con `multiline` o `jsonPath`. Fornendo una di queste opzioni, AWS Glue tornerà al lettore standard.
+ `withSchema`: un valore di stringa che specifica uno schema di tabella nel formato descritto in [Specifica manuale dello schema XML](aws-glue-programming-etl-format-xml-home.md#aws-glue-programming-etl-format-xml-withschema). Utilizzato solo con `optimizePerformance` durante la lettura da connessioni non di catalogo.
## Utilizzo del lettore JSON SIMD vettorizzato con formato colonnare Apache Arrow
La versione AWS Glue 3.0 aggiunge un lettore vettorizzato per i dati JSON. Funziona 2 volte più velocemente in determinate condizioni, rispetto al lettore standard. Questo lettore presenta alcune limitazioni di cui gli utenti dovrebbero essere consapevoli prima dell'uso, documentate in questa sezione.
Per utilizzare il lettore ottimizzato, impostare `"optimizePerformance"` a True nella `format_options` o nella proprietà della tabella. È necessario anche fornire `withSchema` a meno che non venga letto dal catalogo. `withSchema` prevede un input come descritto nel [Specifica manuale dello schema XML](aws-glue-programming-etl-format-xml-home.md#aws-glue-programming-etl-format-xml-withschema)
```
// Read from S3 data source
glueContext.create_dynamic_frame.from_options(
connection_type = "s3",
connection_options = {"paths": ["s3://s3path"]},
format = "json",
format_options={
"optimizePerformance": True,
"withSchema": SchemaString
})
// Read from catalog table
glueContext.create_dynamic_frame.from_catalog(
database = database,
table_name = table,
additional_options = {
// The vectorized reader for JSON can read your schema from a catalog table property.
"optimizePerformance": True,
})
```
Per ulteriori informazioni sull'edificio a *SchemaString* nella libreria AWS Glue, vedere[PySpark tipi di estensione](aws-glue-api-crawler-pyspark-extensions-types.md).
**Limitazioni per il lettore CSV vettorizzato**
Nota i seguenti limiti:
+ Gli elementi JSON con oggetti nidificati o valori di array non sono supportati. Se fornito, AWS Glue tornerà al lettore standard.
+ È necessario fornire uno schema, dal catalogo o con `withSchema`.
+ Non compatibile con `multiline` o `jsonPath`. Fornendo una di queste opzioni, AWS Glue tornerà al lettore standard.
+ Fornire registri di input che non corrispondono allo schema di input provocherà il fallimento del lettore.
+ I [registri di errori](https://docs.aws.amazon.com/glue/latest/dg/glue-etl-scala-apis-glue-dynamicframe-class.html#glue-etl-scala-apis-glue-dynamicframe-class-defs-errorsAsDynamicFrame) non verranno creati.
+ Non supporta file JSON con caratteri multibyte (come caratteri giapponesi o cinesi).
# Utilizzo del formato ORC in AWS Glue
AWS Glue recupera i dati dalle fonti e li scrive su destinazioni archiviate e trasportate in vari formati di dati. Se i dati vengono archiviati o trasportati nel formato dati ORC, questo documento presenta le funzionalità disponibili per l'utilizzo dei dati in Glue. AWS
AWS Glue supporta l'utilizzo del formato ORC. Questo formato è un formato dati basato su colonne orientato alle prestazioni. Per un'introduzione al formato da parte dell'autorità degli standard, consulta [Apache Orc](https://orc.apache.org/docs/).
Puoi usare AWS Glue per leggere file ORC da Amazon S3 e da sorgenti di streaming, nonché scrivere file ORC su Amazon S3. Puoi leggere e scrivere archivi `bzip` e `gzip` contenenti file ORC da S3. Puoi configurare il comportamento di compressione sul [Parametri di connessione di S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) invece che nella configurazione discussa in questa pagina.
La tabella seguente mostra quali operazioni comuni di AWS Glue supportano l'opzione di formato ORC.
| Lettura | Scrittura | Lettura in streaming | Gruppo di file piccoli | Segnalibri di processo |
| --- | --- | --- | --- | --- |
| Supportata | Supportato | Supportata | Non supportato. | Supportato\$1 |
\$1 Supportato nella versione AWS Glue 1.0\$1
## Esempio: lettura di cartelle o file ORC da S3
**Prerequisiti:** occorreranno i percorsi S3 (`s3path`) nelle cartelle o nei file ORC da leggere.
**Configurazione:** nelle opzioni della funzione, specifica `format="orc"`. Nelle tue `connection_options`, utilizza la chiave `paths` per specificare `s3path`. Puoi configurare il modo in cui il reader interagisce con S3 in `connection_options`. Per i dettagli, vedi Tipi di connessione e opzioni per ETL in AWS Glue:[Indicazioni di riferimento alle opzioni di connessione ad Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3).
Il seguente script AWS Glue ETL mostra il processo di lettura di file o cartelle ORC da S3:
------
#### [ Python ]
Per questo esempio, utilizzare il metodo [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="orc"
)
```
Puoi anche usarlo DataFrames in uno script (). `pyspark.sql.DataFrame`
```
dataFrame = spark.read\
.orc("s3://s3path")
```
------
#### [ Scala ]
Per questo esempio, utilizzate l'operazione [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).
```
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.GlueContext
import org.apache.spark.sql.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType="s3",
format="orc",
options=JsonOptions("""{"paths": ["s3://s3path"]}""")
).getDynamicFrame()
}
}
```
È inoltre possibile utilizzare DataFrames in uno script (`pyspark.sql.DataFrame`).
```
val dataFrame = spark.read
.orc("s3://s3path")
```
------
## Esempio: scrittura di cartelle e file ORC in S3
**Prerequisiti:** è necessario un DataFrame (`dataFrame`) o DynamicFrame (`dynamicFrame`) inizializzato. È necessario anche del tuo percorso di output S3 previsto, `s3path`.
**Configurazione:** nelle opzioni della funzione, specifica `format="orc"`. Nelle opzioni di connessione, usa la chiave `paths` per specificare `s3path`. È possibile modificare ulteriormente il modo in cui il writer interagisce con S3 nelle `connection_options`. Per i dettagli, vedi Opzioni di formato dei dati per ingressi e uscite ETL in AWS Glue:. [Indicazioni di riferimento alle opzioni di connessione ad Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) L'esempio di codice seguente mostra il processo:
------
#### [ Python ]
Per questo esempio, utilizza il metodo [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options).
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="s3",
format="orc",
connection_options={
"path": "s3://s3path"
}
)
```
Puoi anche usare DataFrames in uno script (). `pyspark.sql.DataFrame`
```
df.write.orc("s3://s3path/")
```
------
#### [ Scala ]
Per questo esempio, utilizzate il metodo [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat).
```
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, GlueContext}
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getSinkWithFormat(
connectionType="s3",
options=JsonOptions("""{"path": "s3://s3path"}"""),
format="orc"
).writeDynamicFrame(dynamicFrame)
}
}
```
È inoltre possibile utilizzare DataFrames in uno script (`pyspark.sql.DataFrame`).
```
df.write.orc("s3://s3path/")
```
------
## Riferimento alla configurazione XML
Non ci sono valori di `format_options` per `format="orc"`. Tutte le opzioni accettate dal codice SparkSQL sottostante possono tuttavia essere passate tramite il parametro mappa `connection_options`.
# Utilizzo di framework di data lake con AWS Glue processi ETL
I framework di data lake open source semplificano l'elaborazione incrementale dei dati per i file archiviati in data lake basati su Amazon S3. AWS Glue 3.0 e versioni successive supportano i seguenti framework di data lake open source:
+ Apache Hudi
+ Linux Foundation Delta Lake
+ Apache Iceberg
Forniamo supporto nativo per questi framework in modo che sia possibile leggere e scrivere i dati archiviati in Amazon S3 in modo coerente dal punto di vista transazionale. Non è necessario installare un connettore separato o completare passaggi di configurazione aggiuntivi per utilizzare questi framework nei processi ETL di AWS Glue .
Quando gestisci i set di dati tramite AWS Glue Data Catalog, puoi utilizzare AWS Glue metodi per leggere e scrivere tabelle di data lake con Spark. DataFrames Puoi anche leggere e scrivere dati Amazon S3 utilizzando l'API DataFrame Spark.
Questo video illustra le basi del funzionamento di Apache Hudi, Apache Iceberg e Delta Lake. Scoprirai come inserire, aggiornare ed eliminare i dati nel tuo data lake e come funziona ciascuno di questi framework.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/fryfx0Zg7KA)
**Topics**
+ [Limitazioni](aws-glue-programming-etl-datalake-native-frameworks-limitations.md)
+ [Utilizzo del framework Hudi in AWS Glue](aws-glue-programming-etl-format-hudi.md)
+ [Utilizzo del framework Delta Lake in AWS Glue](aws-glue-programming-etl-format-delta-lake.md)
+ [Utilizzo del framework Iceberg in AWS Glue](aws-glue-programming-etl-format-iceberg.md)
# Limitazioni
Considera le seguenti limitazioni prima di utilizzare i framework di data lake con. AWS Glue
+ I seguenti AWS Glue `GlueContext` metodi DynamicFrame non supportano la lettura e la scrittura di tabelle del framework Data Lake. Utilizza invece i `GlueContext` metodi DataFrame per l' DataFrame API Spark.
+ `create_dynamic_frame.from_catalog`
+ `write_dynamic_frame.from_catalog`
+ `getDynamicFrame`
+ `writeDynamicFrame`
+ I seguenti `GlueContext` metodi DataFrame sono supportati con il controllo dei permessi di Lake Formation:
+ `create_data_frame.from_catalog`
+ `write_data_frame.from_catalog`
+ `getDataFrame`
+ `writeDataFrame`
+ Il [raggruppamento di file di piccole dimensioni](grouping-input-files.md) non è supportato.
+ I [segnalibri dei processi](monitor-continuations.md) non sono supportati.
+ Apache Hudi 0.10.1 per AWS Glue 3.0 non supporta le tabelle Hudi Merge on Read (MoR).
+ `ALTER TABLE … RENAME TO`non è disponibile per Apache Iceberg 0.13.1 for 3.0. AWS Glue
## Limitazioni per le tabelle in formato data lake gestite dalle autorizzazioni di Lake Formation
I formati data lake sono integrati con AWS Glue ETL tramite le autorizzazioni di Lake Formation. La creazione di un DynamicFrame utilizzo non `create_dynamic_frame` è supportata. Per maggiori informazioni, consulta i seguenti esempi:
+ [Esempio: lettura e scrittura della tabella Iceberg con il controllo delle autorizzazioni di Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-iceberg.html#aws-glue-programming-etl-format-iceberg-read-write-lake-formation-tables)
+ [Esempio: lettura e scrittura della tabella Hudi con il controllo delle autorizzazioni di Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-hudi.html#aws-glue-programming-etl-format-hudi-read-write-lake-formation-tables)
+ [Esempio: lettura e scrittura della tabella Delta Lake con il controllo delle autorizzazioni di Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-delta-lake.html#aws-glue-programming-etl-format-delta-lake-read-write-lake-formation-tables)
**Nota**
L'integrazione con AWS Glue ETL tramite le autorizzazioni Lake Formation per Apache Hudi, Apache Iceberg e Delta Lake è supportata solo nella versione 4.0. AWS Glue
Apache Iceberg ha la migliore integrazione con AWS Glue ETL tramite le autorizzazioni di Lake Formation. Supporta quasi tutte le operazioni e include il supporto per SQL.
Hudi supporta la maggior parte delle operazioni di base, ad eccezione di quelle amministrative. Queste opzioni generalmente vengono eseguite tramite la scrittura di dataframe e specificate tramite `additional_options`. È necessario utilizzare per creare AWS Glue APIs DataFrames per le proprie operazioni poiché SparkSQL non è supportato.
Delta Lake supporta solo la lettura, l'aggiunta e la sovrascrittura dei dati delle tabelle. Delta Lake richiede l'uso delle proprie librerie per poter eseguire varie attività come gli aggiornamenti.
Le seguenti funzionalità non sono disponibili per le tabelle Iceberg gestite dai permessi di Lake Formation.
+ Compattazione tramite ETL AWS Glue
+ Supporto Spark SQL tramite ETL AWS Glue
Di seguito, sono riportate le limitazioni delle tabelle Hudi gestite dai permessi di Lake Formation:
+ Rimozione di file orfani
Di seguito, sono riportate le limitazioni delle tabelle Delta Lake gestite dai permessi di Lake Formation:
+ Tutte le funzionalità diverse dall'inserimento e dalla lettura dalle tabelle Delta Lake.
# Utilizzo del framework Hudi in AWS Glue
AWS Glue 3.0 e versioni successive supportano il framework Apache Hudi per i data lake. Hudi è un framework di archiviazione di data lake open source che semplifica l'elaborazione incrementale dei dati e lo sviluppo di pipeline di dati. Questo argomento descrive le funzionalità disponibili per l'utilizzo dei dati in AWS Glue quando si trasportano o si archiviano i dati in una tabella Hudi. Per ulteriori informazioni su Hudi, consulta la [documentazione ufficiale di Apache Hudi](https://hudi.apache.org/docs/overview/).
Puoi usare AWS Glue per eseguire operazioni di lettura e scrittura sulle tabelle Hudi in Amazon S3 o lavorare con le tabelle Hudi utilizzando il AWS Glue Data Catalog. Sono supportate anche operazioni aggiuntive, tra cui inserimento, aggiornamento e tutte [le operazioni di Apache Spark](https://hudi.apache.org/docs/quick-start-guide/).
**Nota**
[L'implementazione di Apache Hudi 0.15.0 in AWS Glue 5.0 ripristina internamente HUDI-7001.](https://github.com/apache/hudi/pull/9936) Non mostra la regressione relativa alla generazione Complex Key quando la chiave di registrazione è costituita da un singolo campo. Tuttavia, questo comportamento è diverso da OSS Apache Hudi 0.15.0.
Apache Hudi 0.10.1 per AWS Glue 3.0 non supporta le tabelle Hudi Merge on Read (MoR).
La tabella seguente elenca la versione Hudi inclusa in ogni versione di AWS Glue.
****
| AWS Versione Glue | Versione Hudi supportata |
| --- | --- |
| 5.1 | 1.0.2 |
| 5.0 | 0.15.0 |
| 4.0 | 0.12.1 |
| 3.0 | 0,10,1 |
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)
## Abilitazione di Hudi
Per abilitare Hudi for AWS Glue, completa le seguenti attività:
+ Specifica `hudi` 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 Hudi.
```
spark.serializer=org.apache.spark.serializer.KryoSerializer
```
+ Il supporto delle autorizzazioni Lake Formation per Hudi è abilitato di default per AWS Glue 4.0. Non è necessaria alcuna configurazione aggiuntiva per le tabelle reading/writing Hudi registrate in Lake Formation. Per leggere una tabella Hudi registrata, il ruolo IAM di AWS Glue job deve disporre dell'autorizzazione SELECT. Per scrivere su una tabella Hudi registrata, il ruolo IAM di AWS Glue job deve avere l'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 Hudi**
Per utilizzare una versione di Hudi non supportata da AWS Glue, specificate i vostri file JAR Hudi utilizzando il parametro `--extra-jars` job. Non includere `hudi` 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.
## Esempio: scrivere una tabella Hudi su Amazon S3 e registrarla nel AWS Glue Data Catalog
Questo script di esempio dimostra come scrivere una tabella Hudi su Amazon S3 e registrarla nel AWS Glue Data Catalog. Per registrare la tabella, viene utilizzato lo [strumento Hive Sync](https://hudi.apache.org/docs/syncing_metastore/) di Hudi.
**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 ]
```
# Example: Create a Hudi table from a DataFrame
# and register the table to Glue Data Catalog
additional_options={
"hoodie.table.name": "",
"hoodie.database.name": "",
"hoodie.datasource.write.storage.type": "COPY_ON_WRITE",
"hoodie.datasource.write.operation": "upsert",
"hoodie.datasource.write.recordkey.field": "",
"hoodie.datasource.write.precombine.field": "",
"hoodie.datasource.write.partitionpath.field": "",
"hoodie.datasource.write.hive_style_partitioning": "true",
"hoodie.datasource.hive_sync.enable": "true",
"hoodie.datasource.hive_sync.database": "",
"hoodie.datasource.hive_sync.table": "",
"hoodie.datasource.hive_sync.partition_fields": "",
"hoodie.datasource.hive_sync.partition_extractor_class": "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc": "false",
"hoodie.datasource.hive_sync.mode": "hms",
"path": "s3://"
}
dataFrame.write.format("hudi") \
.options(**additional_options) \
.mode("overwrite") \
.save()
```
------
#### [ Scala ]
```
// Example: Example: Create a Hudi table from a DataFrame
// and register the table to Glue Data Catalog
val additionalOptions = Map(
"hoodie.table.name" -> "",
"hoodie.database.name" -> "",
"hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE",
"hoodie.datasource.write.operation" -> "upsert",
"hoodie.datasource.write.recordkey.field" -> "",
"hoodie.datasource.write.precombine.field" -> "",
"hoodie.datasource.write.partitionpath.field" -> "",
"hoodie.datasource.write.hive_style_partitioning" -> "true",
"hoodie.datasource.hive_sync.enable" -> "true",
"hoodie.datasource.hive_sync.database" -> "",
"hoodie.datasource.hive_sync.table" -> "",
"hoodie.datasource.hive_sync.partition_fields" -> "",
"hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc" -> "false",
"hoodie.datasource.hive_sync.mode" -> "hms",
"path" -> "s3://")
dataFrame.write.format("hudi")
.options(additionalOptions)
.mode("append")
.save()
```
------
## Esempio: leggere una tabella Hudi da Amazon S3 utilizzando il AWS Glue Data Catalog
In questo esempio viene letta la tabella Hudi che hai creato in [Esempio: scrivere una tabella Hudi su Amazon S3 e registrarla nel AWS Glue Data Catalog](#aws-glue-programming-etl-format-hudi-write) da Amazon S3.
**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, usa il metodo `GlueContext.create\$1data\$1frame.from\$1catalog()`.
```
# Example: Read a Hudi table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
dataFrame = glueContext.create_data_frame.from_catalog(
database = "",
table_name = ""
)
```
------
#### [ Scala ]
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 Hudi table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dataFrame = glueContext.getCatalogSource(
database = "",
tableName = ""
).getDataFrame()
}
}
```
------
## Esempio: aggiornamento e inserimento di un `DataFrame` in una tabella Hudi in Amazon S3
Questo esempio utilizza il AWS Glue Data Catalog per inserire un DataFrame nella tabella Hudi in [Esempio: scrivere una tabella Hudi su Amazon S3 e registrarla nel AWS Glue Data Catalog](#aws-glue-programming-etl-format-hudi-write) cui è stato creato.
**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, usa il metodo `GlueContext.write\$1data\$1frame.from\$1catalog()`.
```
# Example: Upsert a Hudi table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
glueContext.write_data_frame.from_catalog(
frame = dataFrame,
database = "",
table_name = "",
additional_options={
"hoodie.table.name": "",
"hoodie.database.name": "",
"hoodie.datasource.write.storage.type": "COPY_ON_WRITE",
"hoodie.datasource.write.operation": "upsert",
"hoodie.datasource.write.recordkey.field": "",
"hoodie.datasource.write.precombine.field": "",
"hoodie.datasource.write.partitionpath.field": "",
"hoodie.datasource.write.hive_style_partitioning": "true",
"hoodie.datasource.hive_sync.enable": "true",
"hoodie.datasource.hive_sync.database": "",
"hoodie.datasource.hive_sync.table": "",
"hoodie.datasource.hive_sync.partition_fields": "",
"hoodie.datasource.hive_sync.partition_extractor_class": "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc": "false",
"hoodie.datasource.hive_sync.mode": "hms"
}
)
```
------
#### [ Scala ]
Per questo esempio, usa il metodo [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink).
```
// Example: Upsert a Hudi table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.JsonOptions
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getCatalogSink("", "",
additionalOptions = JsonOptions(Map(
"hoodie.table.name" -> "",
"hoodie.database.name" -> "",
"hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE",
"hoodie.datasource.write.operation" -> "upsert",
"hoodie.datasource.write.recordkey.field" -> "",
"hoodie.datasource.write.precombine.field" -> "",
"hoodie.datasource.write.partitionpath.field" -> "",
"hoodie.datasource.write.hive_style_partitioning" -> "true",
"hoodie.datasource.hive_sync.enable" -> "true",
"hoodie.datasource.hive_sync.database" -> "",
"hoodie.datasource.hive_sync.table" -> "",
"hoodie.datasource.hive_sync.partition_fields" -> "",
"hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc" -> "false",
"hoodie.datasource.hive_sync.mode" -> "hms"
)))
.writeDataFrame(dataFrame, glueContext)
}
}
```
------
## Esempio: lettura di una tabella Hudi da Amazon S3 tramite Spark
Questo esempio legge una tabella Hudi da Amazon S3 utilizzando l'API Spark. DataFrame
------
#### [ Python ]
```
# Example: Read a Hudi table from S3 using a Spark DataFrame
dataFrame = spark.read.format("hudi").load("s3://")
```
------
#### [ Scala ]
```
// Example: Read a Hudi table from S3 using a Spark DataFrame
val dataFrame = spark.read.format("hudi").load("s3://")
```
------
## Esempio: scrittura di una tabella Hudi su Amazon S3 tramite Spark
In questo esempio viene scritta una tabella Hudi su Amazon S3 tramite Spark.
------
#### [ Python ]
```
# Example: Write a Hudi table to S3 using a Spark DataFrame
dataFrame.write.format("hudi") \
.options(**additional_options) \
.mode("overwrite") \
.save("s3://)
```
------
#### [ Scala ]
```
// Example: Write a Hudi table to S3 using a Spark DataFrame
dataFrame.write.format("hudi")
.options(additionalOptions)
.mode("overwrite")
.save("s3://")
```
------
## Esempio: lettura e scrittura della tabella Hudi con il controllo delle autorizzazioni di Lake Formation
Questo esempio legge da e scrive su una tabella Hudi con il controllo delle autorizzazioni di Lake Formation.
1. Crea una tabella Hudi 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 Hudi che punti al percorso registrato di Amazon S3 tramite l'API Spark DataFrame:
```
hudi_options = {
'hoodie.table.name': table_name,
'hoodie.database.name': database_name,
'hoodie.datasource.write.storage.type': 'COPY_ON_WRITE',
'hoodie.datasource.write.recordkey.field': 'product_id',
'hoodie.datasource.write.table.name': table_name,
'hoodie.datasource.write.operation': 'upsert',
'hoodie.datasource.write.precombine.field': 'updated_at',
'hoodie.datasource.write.hive_style_partitioning': 'true',
'hoodie.upsert.shuffle.parallelism': 2,
'hoodie.insert.shuffle.parallelism': 2,
'path': ,
'hoodie.datasource.hive_sync.enable': 'true',
'hoodie.datasource.hive_sync.database': database_name,
'hoodie.datasource.hive_sync.table': table_name,
'hoodie.datasource.hive_sync.use_jdbc': 'false',
'hoodie.datasource.hive_sync.mode': 'hms'
}
df_products.write.format("hudi") \
.options(**hudi_options) \
.mode("overwrite") \
.save()
```
1. 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 Hudi registrata in Lake Formation. Il codice equivale a leggere una tabella Hudi non registrata. Tieni presente che il ruolo IAM di AWS Glue job deve disporre dell'autorizzazione SELECT affinché la lettura abbia esito positivo.
```
val dataFrame = glueContext.getCatalogSource(
database = "",
tableName = ""
).getDataFrame()
```
1. Scrivi sulla tabella Hudi registrata in Lake Formation. Il codice equivale a scrivere su una tabella Hudi non registrata. Tieni presente che il ruolo IAM di AWS Glue job deve disporre dell'autorizzazione SUPER affinché la scrittura abbia esito positivo.
```
glueContext.getCatalogSink("", "",
additionalOptions = JsonOptions(Map(
"hoodie.table.name" -> "",
"hoodie.database.name" -> "",
"hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE",
"hoodie.datasource.write.operation" -> "",
"hoodie.datasource.write.recordkey.field" -> "",
"hoodie.datasource.write.precombine.field" -> "",
"hoodie.datasource.write.partitionpath.field" -> "",
"hoodie.datasource.write.hive_style_partitioning" -> "true",
"hoodie.datasource.hive_sync.enable" -> "true",
"hoodie.datasource.hive_sync.database" -> "",
"hoodie.datasource.hive_sync.table" -> "",
"hoodie.datasource.hive_sync.partition_fields" -> "",
"hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor",
"hoodie.datasource.hive_sync.use_jdbc" -> "false",
"hoodie.datasource.hive_sync.mode" -> "hms"
)))
.writeDataFrame(dataFrame, glueContext)
```
# 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\$1data\$1frame.from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-catalog).
```
# Example: Read a Delta Lake table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
df = glueContext.create_data_frame.from_catalog(
database="",
table_name="",
additional_options=additional_options
)
```
------
#### [ Scala ]
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\$1data\$1frame.from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_data_frame_from_catalog).
```
# Example: Insert into a Delta Lake table in S3 using Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
glueContext.write_data_frame.from_catalog(
frame=dataFrame,
database="",
table_name="",
additional_options=additional_options
)
```
------
#### [ Scala ]
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
)
```
# Utilizzo del framework Iceberg in AWS Glue
AWS Glue 3.0 e versioni successive supportano il framework Apache Iceberg per i data lake. Iceberg fornisce un formato di tabella ad alte prestazioni che funziona proprio come una tabella SQL. Questo argomento descrive le funzionalità disponibili per l'utilizzo dei dati in AWS Glue quando si trasportano o si archiviano i dati in una tabella Iceberg. Per ulteriori informazioni su Iceberg, consulta la [documentazione ufficiale di Apache Iceberg](https://iceberg.apache.org/docs/latest/).
Puoi usare AWS Glue per eseguire operazioni di lettura e scrittura sulle tabelle Iceberg in Amazon S3 o lavorare con le tabelle Iceberg utilizzando il AWS Glue Data Catalog. Sono supportate anche operazioni aggiuntive, tra cui inserimenti e tutte le [query Spark](https://iceberg.apache.org/docs/latest/spark-queries/) e [scritture Spark](https://iceberg.apache.org/docs/latest/spark-writes/). L'aggiornamento non è supportato per le tabelle Iceberg.
**Nota**
`ALTER TABLE … RENAME TO` non è disponibile per Apache Iceberg 0.13.1 per AWS Glue 3.0.
La tabella seguente elenca la versione di Iceberg inclusa in ogni versione di AWS Glue.
****
| AWS Versione Glue | Versione Iceberg supportata |
| --- | --- |
| 5.1 | 1.10.0 |
| 5.0 | 1.7.1 |
| 4.0 | 1.0.0 |
| 3.0 | 0.13.1 |
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)
## Abilitazione del framework Iceberg
Per abilitare Iceberg for AWS Glue, completa le seguenti attività:
+ Specifica `iceberg` 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 Iceberg.
```
spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog
--conf spark.sql.catalog.glue_catalog.warehouse=s3:///
--conf spark.sql.catalog.glue_catalog.catalog-impl=org.apache.iceberg.aws.glue.GlueCatalog
--conf spark.sql.catalog.glue_catalog.io-impl=org.apache.iceberg.aws.s3.S3FileIO
```
Se stai leggendo o scrivendo su tabelle Iceberg registrate con Lake Formation, segui le indicazioni contenute [Utilizzo di AWS Glue with AWS Lake Formation per un controllo degli accessi a grana fine](security-lf-enable.md) in AWS Glue 5.0 e versioni successive. In AWS Glue 4.0, aggiungi la seguente configurazione per abilitare il supporto di Lake Formation.
```
--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true
--conf spark.sql.catalog.glue_catalog.glue.id=
```
Se usi AWS Glue 3.0 con Iceberg 0.13.1, devi impostare le seguenti configurazioni aggiuntive per utilizzare Amazon DynamoDB lock manager e garantire una transazione atomica. AWS Glue 4.0 o versione successiva utilizza il blocco ottimistico per impostazione predefinita. Per ulteriori informazioni, consulta [Iceberg AWS Integrations](https://iceberg.apache.org/docs/latest/aws/#dynamodb-lock-manager) nella documentazione ufficiale di Apache Iceberg.
```
--conf spark.sql.catalog.glue_catalog.lock-impl=org.apache.iceberg.aws.glue.DynamoLockManager
--conf spark.sql.catalog.glue_catalog.lock.table=
```
**Utilizzo di una versione differente di Iceberg**
Per utilizzare una versione di Iceberg non supportata da AWS Glue, specifica i tuoi file JAR Iceberg utilizzando il parametro `--extra-jars` job. Non includere `iceberg` come valore per il parametro `--datalake-formats`. Se si utilizza AWS Glue 5.0 o versioni successive, è necessario impostare `--user-jars-first true` il parametro del lavoro.
**Abilitazione della crittografia per le tabelle Iceberg**
**Nota**
Le tabelle Iceberg dispongono di meccanismi propri per abilitare la crittografia lato server. È necessario abilitare questa configurazione oltre alla configurazione di sicurezza di AWS Glue.
Per abilitare la crittografia lato server sulle tabelle Iceberg, consulta le indicazioni contenute nella [documentazione di Iceberg](https://iceberg.apache.org/docs/latest/aws/#s3-server-side-encryption).
**Aggiungere la configurazione Spark per Iceberg su più Regioni**
Per aggiungere una configurazione spark aggiuntiva per l'accesso alle tabelle interregionali di Iceberg con il AWS Glue Data Catalog AWS Lake Formation, procedi nel seguente modo:
1. Creare un [punto di accesso multi-regione](https://docs.aws.amazon.com/AmazonS3/latest/userguide/multi-region-access-point-create-examples.html).
1. Configurare le seguenti proprietà Spark:
```
-----
--conf spark.sql.catalog.my_catalog.s3.use-arn-region-enabled=true \
--conf spark.sql.catalog.{CATALOG}.s3.access-points.bucket1", "arn:aws:s3:::accesspoint/.mrap \
--conf spark.sql.catalog.{CATALOG}.s3.access-points.bucket2", "arn:aws:s3:::accesspoint/.mrap
-----
```
## Esempio: scrivere una tabella Iceberg su Amazon S3 e registrarla nel AWS Glue Data Catalog
Questo script di esempio dimostra come scrivere una tabella Iceberg su Amazon S3. L'esempio utilizza [Iceberg AWS Integrations](https://iceberg.apache.org/docs/latest/aws/) per registrare la tabella nel AWS Glue Data Catalog.
------
#### [ Python ]
```
# Example: Create an Iceberg table from a DataFrame
# and register the table to Glue Data Catalog
dataFrame.createOrReplaceTempView("tmp_")
query = f"""
CREATE TABLE glue_catalog..
USING iceberg
TBLPROPERTIES ("format-version"="2")
AS SELECT * FROM tmp_
"""
spark.sql(query)
```
------
#### [ Scala ]
```
// Example: Example: Create an Iceberg table from a DataFrame
// and register the table to Glue Data Catalog
dataFrame.createOrReplaceTempView("tmp_")
val query = """CREATE TABLE glue_catalog..
USING iceberg
TBLPROPERTIES ("format-version"="2")
AS SELECT * FROM tmp_
"""
spark.sql(query)
```
------
In alternativa, è possibile scrivere una tabella Iceberg su Amazon S3 e catalogo dati tramite metodi Spark.
Prerequisiti: è necessario fornire un catalogo per l'utilizzo della libreria Iceberg. Quando si utilizza il AWS Glue Data Catalog, AWS Glue lo rende semplice. Il AWS Glue Data Catalog è preconfigurato per essere utilizzato dalle librerie Spark come. `glue_catalog` Le tabelle del Data Catalog sono identificate da a *databaseName* e a. *tableName* Per ulteriori informazioni sul AWS Glue Data Catalog, vedere[Scoperta e catalogazione dei dati in AWS Glue](catalog-and-crawler.md).
Se non utilizzi il AWS Glue Data Catalog, dovrai fornire un catalogo tramite Spark APIs. Per ulteriori informazioni, consulta la pagina [Spark Configuration](https://iceberg.apache.org/docs/latest/spark-configuration/) nella documentazione di Spark.
In questo esempio viene scritta una tabella Iceberg in Amazon S3 e il catalogo dati tramite Spark.
------
#### [ Python ]
```
# Example: Write an Iceberg table to S3 on the Glue Data Catalog
# Create (equivalent to CREATE TABLE AS SELECT)
dataFrame.writeTo("glue_catalog.databaseName.tableName") \
.tableProperty("format-version", "2") \
.create()
# Append (equivalent to INSERT INTO)
dataFrame.writeTo("glue_catalog.databaseName.tableName") \
.tableProperty("format-version", "2") \
.append()
```
------
#### [ Scala ]
```
// Example: Write an Iceberg table to S3 on the Glue Data Catalog
// Create (equivalent to CREATE TABLE AS SELECT)
dataFrame.writeTo("glue_catalog.databaseName.tableName")
.tableProperty("format-version", "2")
.create()
// Append (equivalent to INSERT INTO)
dataFrame.writeTo("glue_catalog.databaseName.tableName")
.tableProperty("format-version", "2")
.append()
```
------
## Esempio: leggere una tabella Iceberg da Amazon S3 utilizzando il AWS Glue Data Catalog
Questo esempio legge la tabella Iceberg che creata in [Esempio: scrivere una tabella Iceberg su Amazon S3 e registrarla nel AWS Glue Data Catalog](#aws-glue-programming-etl-format-iceberg-write).
------
#### [ Python ]
Per questo esempio, usa il metodo `GlueContext.create\$1data\$1frame.from\$1catalog()`.
```
# Example: Read an Iceberg table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
df = glueContext.create_data_frame.from_catalog(
database="",
table_name="",
additional_options=additional_options
)
```
------
#### [ Scala ]
Per questo esempio, usa il metodo [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource).
```
// Example: Read an Iceberg table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val df = glueContext.getCatalogSource("", "",
additionalOptions = additionalOptions)
.getDataFrame()
}
}
```
------
## Esempio: inserire un `DataFrame` in una tabella Iceberg in Amazon S3 utilizzando il AWS Glue Data Catalog
Questo esempio inserisce i dati nella tabella Iceberg creata in [Esempio: scrivere una tabella Iceberg su Amazon S3 e registrarla nel AWS Glue Data Catalog](#aws-glue-programming-etl-format-iceberg-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, usa il metodo `GlueContext.write\$1data\$1frame.from\$1catalog()`.
```
# Example: Insert into an Iceberg table from Glue Data Catalog
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
glueContext.write_data_frame.from_catalog(
frame=dataFrame,
database="",
table_name="",
additional_options=additional_options
)
```
------
#### [ Scala ]
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 an Iceberg table from Glue Data Catalog
import com.amazonaws.services.glue.GlueContext
import org.apacke.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getCatalogSink("", "",
additionalOptions = additionalOptions)
.writeDataFrame(dataFrame, glueContext)
}
}
```
------
## Esempio: lettura di una tabella Iceberg da Amazon S3 tramite Spark
Prerequisiti: è necessario fornire un catalogo per l'utilizzo della libreria Iceberg. Quando si utilizza il AWS Glue Data Catalog, AWS Glue lo rende semplice. Il AWS Glue Data Catalog è preconfigurato per essere utilizzato dalle librerie Spark come. `glue_catalog` Le tabelle del Data Catalog sono identificate da a *databaseName* e a. *tableName* Per ulteriori informazioni sul AWS Glue Data Catalog, vedere[Scoperta e catalogazione dei dati in AWS Glue](catalog-and-crawler.md).
Se non utilizzi il AWS Glue Data Catalog, dovrai fornire un catalogo tramite Spark APIs. Per ulteriori informazioni, consulta la pagina [Spark Configuration](https://iceberg.apache.org/docs/latest/spark-configuration/) nella documentazione di Spark.
In questo esempio viene letta una tabella Iceberg in Amazon S3 da Catalogo dati tramite Spark.
------
#### [ Python ]
```
# Example: Read an Iceberg table on S3 as a DataFrame from the Glue Data Catalog
dataFrame = spark.read.format("iceberg").load("glue_catalog.databaseName.tableName")
```
------
#### [ Scala ]
```
// Example: Read an Iceberg table on S3 as a DataFrame from the Glue Data Catalog
val dataFrame = spark.read.format("iceberg").load("glue_catalog.databaseName.tableName")
```
------
## Esempio: lettura e scrittura della tabella Iceberg con il controllo delle autorizzazioni di Lake Formation
Questo esempio legge da e scrive su una tabella Iceberg con il controllo delle autorizzazioni di Lake Formation.
**Nota**
Questo esempio funziona solo in AWS Glue 4.0. In AWS Glue 5.0 e versioni successive, segui le istruzioni riportate in[Utilizzo di AWS Glue with AWS Lake Formation per un controllo degli accessi a grana fine](security-lf-enable.md).
1. Crea una tabella Iceberg 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 Iceberg che punti al percorso registrato tramite Spark SQL:
**Nota**
Di seguito vengono mostrati gli esempi Python.
```
dataFrame.createOrReplaceTempView("tmp_")
query = f"""
CREATE TABLE glue_catalog..
USING iceberg
AS SELECT * FROM tmp_
"""
spark.sql(query)
```
Puoi anche creare la tabella manualmente tramite AWS Glue `CreateTable` API. Per ulteriori informazioni, consulta [Creazione di tabelle Apache Iceberg](https://docs.aws.amazon.com/lake-formation/latest/dg/creating-iceberg-tables.html).
**Nota**
Attualmente, l'API `UpdateTable` non supporta il formato di tabella Iceberg come input per l'operazione.
1. Concedi a Lake Formation l'autorizzazione per il ruolo IAM del processo. Puoi concedere le autorizzazioni dalla console di Lake Formation o utilizzando la AWS CLI. Per ulteriori informazioni, consulta: -table-permissions.html https://docs.aws.amazon.com/lake-formation/ latest/dg/granting
1. Leggi una tabella Iceberg registrata con Lake Formation. Il codice equivale a leggere una tabella Iceberg non registrata. Tieni presente che il tuo ruolo IAM di AWS Glue job deve disporre dell'autorizzazione SELECT affinché la lettura abbia esito positivo.
```
# Example: Read an Iceberg table from the AWS Glue Data Catalog
from awsglue.context import GlueContextfrom pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
df = glueContext.create_data_frame.from_catalog(
database="",
table_name="",
additional_options=additional_options
)
```
1. Scrivi su una tabella Iceberg registrata con Lake Formation. Il codice equivale a scrivere su una tabella Iceberg non registrata. Tieni presente che il tuo ruolo IAM di AWS Glue job deve disporre dell'autorizzazione SUPER affinché la scrittura abbia esito positivo.
```
glueContext.write_data_frame.from_catalog(
frame=dataFrame,
database="",
table_name="",
additional_options=additional_options
)
```
## Riferimento alla configurazione condivisa
È possibile utilizzare i seguenti valori di `format_options` con ogni tipo di formato.
+ `attachFilename`: una stringa nel formato appropriato da utilizzare come nome di colonna. Se si fornisce questa opzione, il nome del file di origine del record verrà aggiunto al record. Il valore del parametro verrà utilizzato come nome della colonna.
+ `attachTimestamp`: una stringa nel formato appropriato da utilizzare come nome di colonna. Se si fornisce questa opzione, l'ora di modifica del file di origine del record verrà aggiunta al record. Il valore del parametro verrà utilizzato come nome della colonna.