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à.
# Tutorial: Scrivere uno script di AWS Glue for Spark
Questo tutorial ti introduce al processo di scrittura degli script AWS Glue. È possibile eseguire script in base a una pianificazione con processi o in modo interattivo con sessioni. Per ulteriori informazioni sui processi, consultare [Creazione di processi ETL visivi](author-job-glue.md). Per ulteriori informazioni, sulle sessioni interattive, consultare [Panoramica delle sessioni interattive in AWS Glue](interactive-sessions-chapter.md#interactive-sessions-overview).
L'editor visivo di AWS Glue Studio offre un'interfaccia grafica senza codice per la creazione di lavori AWS Glue. AWS Glue gli script ai lavori visivi. Danno accesso al set esteso di strumenti disponibili per lavorare con i programmi Apache Spark. Puoi accedere a Spark APIs native e alle librerie AWS Glue che facilitano i flussi di lavoro di estrazione, trasformazione e caricamento (ETL) dall'interno di uno script AWS Glue.
In questo tutorial, si estrae, trasforma e carica un set di dati di multe per il parcheggio. Lo script che esegue questo lavoro è identico nella forma e nella funzione a quello generato in [Making ETL easy with AWS Glue Studio](https://aws.amazon.com/blogs/big-data/making-etl-easier-with-aws-glue-studio/) sul AWS Big Data Blog, che introduce l'editor visivo di AWS Glue Studio. Eseguendo questo script in un job, è possibile confrontarlo con i lavori visivi e vedere come funzionano gli script AWS Glue ETL. Questo ti prepara a utilizzare funzionalità aggiuntive che non sono ancora disponibili nei processi visivi.
Questo tutorial utilizza il linguaggio e le librerie Python. Funzionalità simili sono disponibili in Scala. Dopo aver seguito questo tutorial, dovresti essere in grado di generare e ispezionare uno script Scala di esempio per capire come eseguire il processo di scrittura dello script Scala AWS Glue ETL.
## Prerequisiti
Di seguito sono elencati i requisiti per questo tutorial:
+ Gli stessi prerequisiti del post del blog di AWS Glue Studio, che ti spiega come eseguire un CloudFormation modello.
Questo modello utilizza il AWS Glue Data Catalog per gestire il set di dati dei biglietti di parcheggio disponibile in`s3://aws-bigdata-blog/artifacts/gluestudio/`. Questa operazione crea le risorse seguenti, a cui verrà fatto riferimento:
+ **AWS Glue StudioRuolo**: il ruolo IAM per eseguire i processi AWS Glue
+ **AWS Glue StudioBucket Amazon S3**: il nome del bucket Amazon S3 per archiviare i file relativi al blog
+ **AWS Glue StudioTicketsYYZDB**: il database del Catalogo dati di AWS Glue
+ **AWS Glue StudioTableTickets**— Tabella Data Catalog da utilizzare come fonte
+ **AWS Glue StudioTableTrials**— Tabella Data Catalog da utilizzare come fonte
+ **AWS Glue StudioParkingTicketCount **— Tabella Data Catalog da utilizzare come destinazione
+ Lo script generato nel post del blog di AWS Glue Studio. Nel caso in cui il post venga modificato, è possibile trovare lo script anche nel testo seguente.
### Generazione di uno script di esempio
Puoi usare l'editor visivo di AWS Glue Studio come potente strumento di generazione di codice per creare uno scaffold per lo script che desideri scrivere. Questo strumento verrà utilizzato per creare uno script di esempio.
Se si preferisce saltare queste fasi, è possibile utilizzare lo script seguente.
#### Script di esempio per il tutorial
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args["JOB_NAME"], args)
# Script generated for node S3 bucket
S3bucket_node1 = glueContext.create_dynamic_frame.from_catalog(
database="yyz-tickets", table_name="tickets", transformation_ctx="S3bucket_node1"
)
# Script generated for node ApplyMapping
ApplyMapping_node2 = ApplyMapping.apply(
frame=S3bucket_node1,
mappings=[
("tag_number_masked", "string", "tag_number_masked", "string"),
("date_of_infraction", "string", "date_of_infraction", "string"),
("ticket_date", "string", "ticket_date", "string"),
("ticket_number", "decimal", "ticket_number", "float"),
("officer", "decimal", "officer_name", "decimal"),
("infraction_code", "decimal", "infraction_code", "decimal"),
("infraction_description", "string", "infraction_description", "string"),
("set_fine_amount", "decimal", "set_fine_amount", "float"),
("time_of_infraction", "decimal", "time_of_infraction", "decimal"),
],
transformation_ctx="ApplyMapping_node2",
)
# Script generated for node S3 bucket
S3bucket_node3 = glueContext.write_dynamic_frame.from_options(
frame=ApplyMapping_node2,
connection_type="s3",
format="glueparquet",
connection_options={"path": "s3://DOC-EXAMPLE-BUCKET", "partitionKeys": []},
format_options={"compression": "gzip"},
transformation_ctx="S3bucket_node3",
)
job.commit()
```
**Generazione di uno script di esempio**
1. Completa il tutorial di AWS Glue Studio. Per completare questo tutorial, vedi [Creazione di un lavoro in AWS Glue Studio da un lavoro di esempio](https://docs.aws.amazon.com/glue/latest/dg/edit-nodes-chapter.html#create-jobs-start.html).
1. Passare alla scheda **Script** nella pagina del processo, come mostrato nello screenshot seguente:
![\[La scheda Script per un lavoro AWS Glue.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/programming-intro-generated-script.png)
1. Copiare tutto il contenuto della scheda **Script**. Impostando il linguaggio dello script nella sezione **Job details** (Dettagli del processo), è possibile passare dalla generazione di codice Python a Scala e viceversa.
## Passaggio 1. Creare un processo e incollare lo script
In questo passaggio, si crea un lavoro AWS Glue in Console di gestione AWS. Questo imposta una configurazione che consente a AWS Glue di eseguire lo script. e si crea contemporaneamente uno spazio dove archiviarlo e modificarlo.
**Come creare un processo**
1. Nel Console di gestione AWS, vai alla landing page di AWS Glue.
1. Nel riquadro di navigazione laterale, scegliere **Jobs (Processi)**.
1. Scegliere **Editor di script Spark** in **Creazione di processo**, quindi scegli **Crea**.
1. **Facoltativo**: incollare il testo completo dello script nel riquadro **Script**. In alternativa, è possibile seguire il tutorial.
## Passaggio 2. Importa librerie AWS Glue
È necessario impostare lo script in modo che interagisca con il codice e la configurazione che sono stati definiti all'esterno dello script. Questo lavoro viene svolto dietro le quinte di AWS Glue Studio.
In questa fase, procedere secondo quanto descritto di seguito.
+ Importare e inizializzare un oggetto `GlueContext`. Questa è l'importazione più importante dal punto di vista della scrittura dello script Ciò espone i metodi standard per la definizione dei set di dati di origine e di destinazione, ossia il punto di partenza per qualsiasi script ETL. Per ulteriori informazioni sulla classe `GlueContext`, consultare la pagina [GlueContext classe](aws-glue-api-crawler-pyspark-extensions-glue-context.md).
+ Inizializza `SparkContext` e `SparkSession`. Questi consentono di configurare il motore Spark disponibile all'interno del lavoro AWS Glue. Non sarà necessario utilizzarli direttamente negli script introduttivi di AWS Glue.
+ Richiamare `getResolvedOptions` per preparare gli argomenti del processo da utilizzare all'interno dello script. Per ulteriori informazioni sulla risoluzione dei parametri di processo, consultare [Accesso ai parametri utilizzando `getResolvedOptions`](aws-glue-api-crawler-pyspark-extensions-get-resolved-options.md).
+ Inizializzare un `Job`. L'`Job`oggetto imposta la configurazione e tiene traccia dello stato di varie funzioni opzionali di AWS Glue. Lo script può essere eseguito senza un oggetto `Job`, tuttavia la procedura consigliata consiste nell'inizializzarlo in modo da non essere confusi da un'eventuale integrazione successiva di queste funzionalità.
Una di queste è rappresentata dai segnalibri di processo, che puoi configurare facoltativamente in questo tutorial. Per informazioni sui segnalibri di processo, consulta la sezione [Facoltativo: abilita i segnalibri di processo](#aws-glue-programming-intro-tutorial-create-job-bookmarks).
In questa procedura si scriverà il codice seguente. Questo codice è una parte dello script di esempio generato.
```
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args["JOB_NAME"], args)
```
**Per importare le librerie AWS Glue**
+ Copia questa sezione del codice e incollala nell'editor **Script**.
**Nota**
La copia del codice potrebbe essere considerata una pratica di ingegneria non consigliata. In questo tutorial, ti suggeriamo questo per incoraggiarti a denominare in modo coerente le tue variabili principali in tutti gli script ETL di AWS Glue.
## Fase 3. Estrazione di dati da un'origine
In qualsiasi processo ETL, è innanzitutto necessario definire un set di dati di origine che si vuole modificare. Nell'editor visivo di AWS Glue Studio, fornisci queste informazioni creando un nodo **Source**.
In questa fase, fornire al metodo `create_dynamic_frame.from_catalog` i parametri `database` e `table_name` per estrarre i dati da un'origine configurata nel Data Catalog AWS Glue.
Nella fase precedente è stato inizializzato un oggetto `GlueContext` Utilizzare questo oggetto per trovare i metodi usati per configurare le origini, ad esempio `create_dynamic_frame.from_catalog`.
In questa procedura si scriverà il codice seguente utilizzando `create_dynamic_frame.from_catalog`. Questo codice è una parte dello script di esempio generato.
```
S3bucket_node1 = glueContext.create_dynamic_frame.from_catalog(
database="yyz-tickets", table_name="tickets", transformation_ctx="S3bucket_node1"
)
```
**Estrazione di dati da un'origine**
1. Esamina la documentazione per trovare un metodo `GlueContext` per estrarre dati da una fonte definita nel AWS Glue Data Catalog. Questi metodi sono documentati in [GlueContext classe](aws-glue-api-crawler-pyspark-extensions-glue-context.md). Scegliere il metodo [create\$1dynamic\$1frame.from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_catalog). Richiamare questo metodo in `glueContext`.
1. Esaminare la documentazione relativa a `create_dynamic_frame.from_catalog`. Questo metodo richiede i parametri `database` e `table_name`. Fornire i parametri necessari per `create_dynamic_frame.from_catalog`.
Il AWS Glue Data Catalog memorizza le informazioni sulla posizione e il formato dei dati di origine ed è stato impostato nella sezione dei prerequisiti. Non è necessario fornire direttamente allo script tali informazioni.
1. **Facoltativo**: fornisci al metodo il parametro `transformation_ctx` per supportare i segnalibri di processo. Per informazioni sui segnalibri di processo, consultare la sezione [Facoltativo: abilita i segnalibri di processo](#aws-glue-programming-intro-tutorial-create-job-bookmarks).
**Nota**
**Metodi comuni per l'estrazione dei dati**
[create\$1dynamic\$1frame\$1from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_catalog)viene utilizzato per connettersi alle tabelle nel AWS Glue Data Catalog.
Se è necessario fornire direttamente al processo una configurazione che descriva la struttura e la posizione dell'origine, consulta il metodo [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). È necessario fornire parametri più dettagliati per la descrizione dei dati rispetto a quando utilizzi `create_dynamic_frame.from_catalog`.
Consultare la documentazione supplementare su `format_options` e `connection_parameters` per identificare i parametri obbligatori. Per una spiegazione su come fornire allo script informazioni sul formato dei dati di origine, consultare la sezione [Opzioni del formato dati per input e output in AWS Glue per Spark](aws-glue-programming-etl-format.md). Per una spiegazione su come fornire allo script informazioni sulla posizione dei dati di origine, consultare la sezione [Tipi e opzioni di connessione per ETL in AWS Glue per Spark](aws-glue-programming-etl-connect.md).
Se si sta leggendo le informazioni da un'origine di streaming, fornire al processo le informazioni di origine tramite i metodi [create\$1data\$1frame\$1from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-catalog) o [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). Nota: questi metodi restituiscono `DataFrames` di Apache Spark.
Il codice generato effettua una chiamata a `create_dynamic_frame.from_catalog`, mentre la documentazione fa riferimento a `create_dynamic_frame_from_catalog`. Questi metodi richiamano in definitiva lo stesso codice e sono stati inclusi per consentire di scrivere un codice più pulito. Puoi verificarlo visualizzando il sorgente del nostro wrapper Python, disponibile all'indirizzo [https://github.com/awslabs/aws-glue-libs/blob/master/awsglue/context.py](https://github.com/awslabs/aws-glue-libs/blob/master/awsglue/context.py).
## Passaggio 4. Trasforma i dati con AWS Glue
Dopo aver estratto i dati di origine in un processo ETL, è necessario specificare il modo in cui modificare i dati. Fornisci queste informazioni creando un nodo **Transform** nell'editor visivo di AWS Glue Studio.
In questa fase, fornisci al metodo `ApplyMapping` una mappa dei nomi e dei tipi di campo attuali e desiderati per trasformare il `DynamicFrame`.
Eseguire le trasformazioni seguenti.
+ Rilasciare le quattro chiavi `location` e `province`.
+ Modificare il nome di `officer` in `officer_name`.
+ Modificare il tipo di `ticket_number` e `set_fine_amount` in `float`.
`create_dynamic_frame.from_catalog` fornisce un oggetto `DynamicFrame`. A `DynamicFrame` rappresenta un set di dati in AWS Glue. AWS Le Glue Transform sono operazioni che cambiano`DynamicFrames`.
**Nota**
Che cos'è una `DynamicFrame`?
Un `DynamicFrame` è un'astrazione che consente di collegare un set di dati con una descrizione dei nomi e dei tipi di voci presenti nei dati. In Apache Spark esiste un'astrazione simile chiamata a. DataFrame Per una spiegazione di DataFrames, consulta [Spark](https://spark.apache.org/docs/latest/sql-programming-guide.html) SQL Guide.
I `DynamicFrames`, consentono di descrivere gli schemi del set di dati in modo dinamico. Prendiamo in considerazione un set di dati con una colonna dei prezzi, in cui alcune voci memorizzano il prezzo come stringa e altre il prezzo come doppio. AWS Glue calcola uno schema on-the-fly: crea un record autodescrittivo per ogni riga.
I campi non coerenti (come il prezzo) sono rappresentati esplicitamente con un tipo (`ChoiceType`) nello schema del riquadro. Puoi affrontare il problema dei campi non coerenti eliminandoli con `DropFields` o risolvendoli con `ResolveChoice`. Queste trasformazioni che sono disponibili su `DynamicFrame`. Puoi quindi riscrivere i dati sul data lake con `writeDynamicFrame`.
È possibile richiamare la maggior parte di queste trasformazioni dai metodi della classe `DynamicFrame`, ottenendo così script più leggibili. Per ulteriori informazioni su `DynamicFrame`, consultare [DynamicFrame classe](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md).
In questa procedura si scriverà il codice seguente utilizzando `ApplyMapping`. Questo codice è una parte dello script di esempio generato.
```
ApplyMapping_node2 = ApplyMapping.apply(
frame=S3bucket_node1,
mappings=[
("tag_number_masked", "string", "tag_number_masked", "string"),
("date_of_infraction", "string", "date_of_infraction", "string"),
("ticket_date", "string", "ticket_date", "string"),
("ticket_number", "decimal", "ticket_number", "float"),
("officer", "decimal", "officer_name", "decimal"),
("infraction_code", "decimal", "infraction_code", "decimal"),
("infraction_description", "string", "infraction_description", "string"),
("set_fine_amount", "decimal", "set_fine_amount", "float"),
("time_of_infraction", "decimal", "time_of_infraction", "decimal"),
],
transformation_ctx="ApplyMapping_node2",
)
```
**Per trasformare i dati con AWS Glue**
1. Esaminare la documentazione per identificare una trasformazione volta a modificare ed eliminare i campi. Per informazioni dettagliate, vedi [GlueTransform classe base](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md). Selezionare la trasformazione `ApplyMapping`. Per ulteriori informazioni su `ApplyMapping`, consultare [ApplyMapping classe](aws-glue-api-crawler-pyspark-transforms-ApplyMapping.md). Richiamare `apply` nell'oggetto di trasformazione `ApplyMapping`.
**Nota**
Cos'è `ApplyMapping`?
`ApplyMapping` prende un `DynamicFrame` e lo trasforma. Prende un elenco di tuple che rappresentano le trasformazioni sui campi, una "mappatura". I primi due elementi della tupla, ovvero un nome e un tipo di campo, vengono utilizzati per identificare un campo nel riquadro. Anche gli altri due parametri rappresentano un nome e un tipo di campo.
ApplyMapping converte il campo di origine nel nome di destinazione e ne digita uno nuovo`DynamicFrame`, che restituisce. I campi non forniti verranno eliminati dal valore restituito.
Invece di effettuare una chiamata ad `apply`, è possibile richiamare la stessa trasformazione con il metodo `apply_mapping` nell'oggetto `DynamicFrame`, creando così un codice più fluido e leggibile. Per ulteriori informazioni, consultare [apply\$1mapping](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-apply_mapping).
1. Esaminare la documentazione relativa ad `ApplyMapping` per identificare i parametri obbligatori. Per informazioni, consulta [ApplyMapping classe](aws-glue-api-crawler-pyspark-transforms-ApplyMapping.md). Si noterà che questo metodo richiede i parametri `frame` e `mappings`. Fornire i parametri necessari per `ApplyMapping`.
1. **Facoltativo**: fornire `transformation_ctx` al metodo per supportare i segnalibri di processo. Per informazioni sui segnalibri di processo, consulta la sezione [Facoltativo: abilita i segnalibri di processo](#aws-glue-programming-intro-tutorial-create-job-bookmarks).
**Nota**
**Funzionalità di Apache Spark**
Forniamo trasformazioni per semplificare i flussi di lavoro ETL all'interno del tuo processo. Si avrà inoltre accesso alle librerie che sono state create per scopi più generali e disponibili in un programma Spark nel processo. Per utilizzarle, è necessario eseguire la conversione tra `DynamicFrame` e `DataFrame`.
È possibile creare un `DataFrame` con [toDF](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-toDF). Quindi, puoi utilizzare i metodi disponibili su DataFrame per trasformare il tuo set di dati. Per ulteriori informazioni su questi metodi, vedere [DataFrame](https://spark.apache.org/docs/3.1.1/api/python/reference/api/pyspark.sql.DataFrame.html). È quindi possibile eseguire la conversione all'indietro con [fromDF](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-fromDF) per utilizzare le operazioni AWS Glue per caricare la cornice su un bersaglio.
## Fase 5. Caricare i dati in una destinazione
In genere, i dati trasformati vengono archiviati in una posizione diversa da quella di origine. Questa operazione viene eseguita creando un nodo di **destinazione** nell'editor visivo di AWS Glue Studio.
In questa fase si forniscono al metodo `write_dynamic_frame.from_options` i parametri `connection_type`, `connection_options`, `format` e `format_options` per caricare i dati in un bucket di destinazione di Amazon S3.
Nella fase 1 hai inizializzato un oggetto `GlueContext`. In AWS Glue, è qui che troverai i metodi utilizzati per configurare gli obiettivi, proprio come i sorgenti.
In questa procedura si scriverà il codice seguente utilizzando `write_dynamic_frame.from_options`. Questo codice è una parte dello script di esempio generato.
```
S3bucket_node3 = glueContext.write_dynamic_frame.from_options(
frame=ApplyMapping_node2,
connection_type="s3",
format="glueparquet",
connection_options={"path": "s3://amzn-s3-demo-bucket", "partitionKeys": []},
format_options={"compression": "gzip"},
transformation_ctx="S3bucket_node3",
)
```
**Caricare i dati in una destinazione**
1. Esaminare la documentazione per trovare un metodo adatto a caricare i dati in un bucket Amazon S3 di destinazione. Questi metodi sono documentati in [GlueContext classe](aws-glue-api-crawler-pyspark-extensions-glue-context.md). Scegliere il metodo [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). Richiamare questo metodo in `glueContext`.
**Nota**
**Metodi comuni per il caricamento dei dati**
`write_dynamic_frame.from_options` è il metodo più comunemente usato per caricare i dati. Supporta tutti i target disponibili in AWS Glue.
Se stai scrivendo su un target JDBC definito in una connessione AWS Glue, usa il [write\$1dynamic\$1frame\$1from\$1jdbc\$1conf](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_jdbc_conf) metodo. AWS Le connessioni Glue memorizzano informazioni su come connettersi a un'origine dati. Ciò elimina la necessità di fornire tali informazioni in `connection_options`. Tuttavia, \$1 necessario comunque utilizzare `connection_options` per fornire `dbtable`.
`write_dynamic_frame.from_catalog` non è un metodo comune per caricare i dati. Questo metodo aggiorna il AWS Glue Data Catalog senza aggiornare il set di dati sottostante e viene utilizzato in combinazione con altri processi che modificano il set di dati sottostante. Per ulteriori informazioni, consulta [Aggiornamento dello schema e aggiunta di nuove partizioni nel catalogo dati usando processi ETL AWS Glue](update-from-job.md).
1. Esaminare la documentazione relativa a [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). Questo metodo richiede `frame`, `connection_type`, `format`, `connection_options`, `format_options`. Richiamare questo metodo in `glueContext`.
1. Consultare la documentazione aggiuntiva relativa a `format_options` e `format` per identificare i parametri necessari. Per una spiegazione dei formati di dati, consultare la sezione [Opzioni del formato dati per input e output in AWS Glue per Spark](aws-glue-programming-etl-format.md).
1. Consultare la documentazione aggiuntiva relativa a `connection_type` e `connection_options` per identificare i parametri necessari. Per una spiegazione delle connessioni, consulta la sezione [Tipi e opzioni di connessione per ETL in AWS Glue per Spark](aws-glue-programming-etl-connect.md).
1. Fornire i parametri necessari per `write_dynamic_frame.from_options`. Questo metodo ha una configurazione simile a `create_dynamic_frame.from_options`.
1. **Facoltativo:** fornire `transformation_ctx` al metodo `write_dynamic_frame.from_options` per supportare i segnalibri di processo. Per informazioni sui segnalibri di processo, consultare la sezione [Facoltativo: abilita i segnalibri di processo](#aws-glue-programming-intro-tutorial-create-job-bookmarks).
## Fase 6. Commit dell'oggetto `Job`
Nella fase 1 è stato inizializzato un oggetto `Job`. Potrebbe essere necessario terminarne manualmente il ciclo di vita alla fine dello script nel caso alcune funzionalità facoltative lo richiedano per funzionare correttamente, ad esempio quando si utilizzano i segnalibri di processo. Questo lavoro viene svolto dietro le quinte di AWS Glue Studio.
In questa fase, effettuare una chiamata al metodo `commit` nell'oggetto `Job`.
In questa procedura si scriverà il codice seguente. Questo codice è una parte dello script di esempio generato.
```
job.commit()
```
**Commit dell'oggetto `Job`**
1. Se non è stato già fatto, eseguire le fasi facoltative descritte nelle sezioni precedenti per includere `transformation_ctx`.
1. Chiama `commit`.
## Facoltativo: abilita i segnalibri di processo
In ogni fase precedente, ti è stato chiesto di impostare i parametri `transformation_ctx`. Questa operazione è correlata a una funzionalità denominata segnalibri di processo.
Con i segnalibri di processo risparmi tempo e denaro grazie a processi eseguiti su base ricorrente rispetto a set di dati in cui è possibile tracciare facilmente il lavoro precedente. I segnalibri Job tengono traccia dell'avanzamento di una trasformazione AWS Glue su un set di dati delle esecuzioni precedenti. Tracciando dove sono terminate le esecuzioni precedenti, AWS Glue può limitare il lavoro alle righe che non ha mai elaborato prima. Per ulteriori informazioni sui segnalibri di processo, consultare [Monitoraggio dei dati elaborati mediante segnalibri di processo](monitor-continuations.md).
Per abilitare i segnalibri di processo, aggiungere prima le informazioni `transformation_ctx` nelle funzioni fornite, come descritto negli esempi precedenti. Lo stato del segnalibro di processo viene mantenuto tra le esecuzioni. I parametri `transformation_ctx` sono chiavi utilizzate per accedere a tale stato. Da sole, queste istruzioni non servono a nulla. È necessario attivare la funzionalità nella configurazione del processo.
In questa procedura attivare i segnalibri di processo utilizzando la Console di gestione AWS.
**Abilitazione dei segnalibri di processo**
1. Passare alla sezione **Job details** (Dettagli del processo) del processo corrispondente.
1. Impostare **Job bookmark** (Segnalibro di processo) su **Enable** (Abilita).
## Fase 7. Esecuzione del codice come processo
In questa fase, esegui il processo per verificare di aver completato correttamente questo tutorial. Questo viene fatto con il clic di un pulsante, come nell'editor visivo di AWS Glue Studio.
**Esecuzione del codice come processo**
1. Scegliere **Untitled job** (Processo senza titolo) sulla barra del titolo per modificare e impostare il nome del processo.
1. Passare alla scheda **Job details** (Dettagli del lavoro). Assegna al processo un **Ruolo IAM**. Puoi usare quello creato dal CloudFormation modello nei prerequisiti per il tutorial di AWS Glue Studio. Se è stato completato quel tutorial, dovrebbe essere disponibile come `AWS Glue StudioRole`.
1. Scegliere **Save** (Salva) per salvare lo script.
1. Scegliere **Run** (Esegui) per eseguire il processo.
1. Passare alla scheda **Runs** (Esecuzioni) per verificare il completamento del processo.
1. Vai a*amzn-s3-demo-bucket*, l'obiettivo di`write_dynamic_frame.from_options`. Verificare che l'output corrisponda alle proprie aspettative.
Per ulteriori informazioni sulla configurazione e la gestione dei processi, consultare la sezione [Fornire i propri script personalizzati](console-custom-created.md).
## Ulteriori informazioni
Le librerie e i metodi Apache Spark sono disponibili negli script AWS Glue. Per comprendere quali operazioni è possibile eseguire con le librerie incluse, consulta la documentazione di Spark. Per ulteriori informazioni, consultare la [sezione esempi del repository di orgine di Spark](https://github.com/apache/spark/tree/master/examples/src/main/python).
AWS Glue 2.0\$1 include diverse librerie Python comuni per impostazione predefinita. Esistono anche meccanismi per caricare le proprie dipendenze in un lavoro AWS Glue in un ambiente Scala o Python. Per ulteriori informazioni sulle dipendenze Python, consultare [Usare le librerie Python con Glue AWS](aws-glue-programming-python-libraries.md).
Per altri esempi di come usare le funzionalità di AWS Glue in Python, vedi. [Esempi di codice Python in AWS Glue](aws-glue-programming-python-samples.md) I processi in Scala e Python presentano una condizione di parità di funzioni, per cui gli esempi relativi a Python consentono di comprendere l'esecuzione di un lavoro simile in Scala.