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, consulta Creazione di ETL lavori visivi con AWS Glue Studio. Per ulteriori informazioni, sulle sessioni interattive, consulta Panoramica delle sessioni interattive in AWS Glue.

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 alle API Spark native e alle librerie AWS Glue che facilitano i flussi di lavoro di estrazione, trasformazione e caricamento (ETL) dall'interno di uno script Glue. AWS

In questo tutorial, estrai, trasformi e carichi 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 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 AWS CloudFormation modello.

  Questo modello utilizza il AWS Glue Data Catalog per gestire il set di dati dei biglietti di parcheggio disponibile ins3://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 preferisci saltare queste fasi, puoi 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.

2. Passa alla scheda Script nella pagina del processo, come mostrato nello screenshot seguente:

   

3. Copia tutto il contenuto della scheda Script. Impostando il linguaggio dello script nella sezione Job details (Dettagli del processo), puoi passare dalla generazione di codice Python a Scala e viceversa.

Fase 1: Creare un processo e incollare lo script

In questo passaggio, si crea un lavoro AWS Glue in AWS Management Console. Questo imposta una configurazione che consente a AWS Glue di eseguire lo script. e si crea contemporaneamente uno spazio dove archiviarlo e modificarlo.

Per creare un lavoro

1. Nel AWS Management Console, vai alla landing page di AWS Glue.

2. Nel riquadro di navigazione laterale, scegli Jobs (Processi).

3. Scegli Editor di script Spark in Creazione di processo, quindi scegli Crea.

4. Facoltativo: incolla il testo completo dello script nel riquadro Script. In alternativa, puoi seguire il tutorial.

Fase 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, procedi secondo quanto descritto di seguito.

• Importa e inizializza 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, consulta la pagina GlueContext classe.

• 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.

• Richiama getResolvedOptions per preparare gli argomenti del processo da utilizzare all'interno dello script. Per ulteriori informazioni sulla risoluzione dei parametri di processo, consulta Accesso ai parametri utilizzando getResolvedOptions.

• Inizializza un Job. L'Joboggetto 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.

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, fornisci 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 hai inizializzato un oggetto GlueContext Utilizzi 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. Scegli il metodo create_dynamic_frame.from_catalog. Richiama questo metodo in glueContext.

2. Esamina la documentazione relativa a create_dynamic_frame.from_catalog. Questo metodo richiede i parametri database e table_name. Fornisci 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.

3. Facoltativo: fornisci al metodo il parametro transformation_ctx per supportare i segnalibri di processo. Per informazioni sui segnalibri di processo, consulta la sezione Facoltativo - Abilita i segnalibri di processo.

Nota

Metodi comuni per l'estrazione dei dati

create_dynamic_frame_from_catalogviene utilizzato per connettersi alle tabelle nel AWS Glue Data Catalog.

Se hai bisogno di fornire direttamente al processo una configurazione che descriva la struttura e la posizione dell'origine, consulta il metodo create_dynamic_frame_from_options. Dovrai fornire parametri più dettagliati per la descrizione dei dati rispetto a quando utilizzi create_dynamic_frame.from_catalog.

Consulta 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, consulta la sezione Opzioni del formato dati per input e output in AWS Glue per Spark. Per una spiegazione su come fornire allo script informazioni sulla posizione dei dati di origine, consulta la sezione Tipi e opzioni di connessione per ETL in AWS Glue per Spark.

Se stai leggendo le informazioni da un'origine di streaming, fornisci al processo le informazioni di origine tramite i metodi create_data_frame_from_catalog o create_data_frame_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 aws-glue-libs.

Fase 4. Trasformare 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.

Esegui le trasformazioni seguenti.

• Rilascia le quattro chiavi location e province.

• Modifica il nome di officer in officer_name.

• Modifica 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 cambianoDynamicFrames.

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 SQL Guide.

I DynamicFrames, consentono di descrivere gli schemi del set di dati in modo dinamico. Consideriamo 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, consulta DynamicFrame classe.

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. Esamina la documentazione per identificare una trasformazione volta a modificare ed eliminare i campi. Per informazioni dettagliate, vedi Classe di base GlueTransform. Seleziona la trasformazione ApplyMapping. Per ulteriori informazioni su ApplyMapping, consulta Classe ApplyMapping. Richiama 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 nuovoDynamicFrame, 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, consulta apply_mapping.

2. Esamina la documentazione relativa ad ApplyMapping per identificare i parametri obbligatori. Per informazioni, consulta Classe ApplyMapping. Noterai che questo metodo richiede i parametri frame e mappings. Fornisci i parametri necessari per ApplyMapping.

3. Facoltativo – Fornisci 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.

Nota

Funzionalità di Apache Spark

Forniamo trasformazioni per semplificare i flussi di lavoro ETL all'interno del tuo processo. Avrai 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. Quindi, puoi utilizzare i metodi disponibili su DataFrame per trasformare il tuo set di dati. Per ulteriori informazioni su questi metodi, vedere DataFrame. È quindi possibile eseguire la conversione all'indietro con 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 fornisci 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://DOC-EXAMPLE-BUCKET", "partitionKeys": []},
    format_options={"compression": "gzip"},
    transformation_ctx="S3bucket_node3",
    )

Caricare i dati in una destinazione

1. Esamina 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. Scegli il metodo write_dynamic_frame_from_options. Richiama 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_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, devi 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 Data Catalog utilizzando processi AWS Glue ETL.

2. Esamina la documentazione relativa a write_dynamic_frame_from_options. Questo metodo richiede frame, connection_type, format, connection_options, format_options. Richiama questo metodo in glueContext.

   1. Consulta la documentazione aggiuntiva relativa a format_options e format per identificare i parametri necessari. Per una spiegazione dei formati di dati, consulta la sezione Opzioni del formato dati per input e output in AWS Glue per Spark.

   2. Consulta 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.

   3. Fornisci i parametri necessari per write_dynamic_frame.from_options. Questo metodo ha una configurazione simile a create_dynamic_frame.from_options.

3. Facoltativo – Fornisci transformation_ctx al metodo write_dynamic_frame.from_options per supportare i segnalibri di processo. Per informazioni sui segnalibri di processo, consulta la sezione Facoltativo - Abilita i segnalibri di processo.

Fase 6. Commit dell'oggetto Job

Nella fase 1 hai inizializzato un oggetto Job. Dovrai concludere manualmente il suo ciclo di vita alla fine dello script. Alcune funzionalità facoltative richiedono tale oggetto per funzionare correttamente. Questo lavoro viene svolto dietro le quinte di AWS Glue Studio.

In questa fase, effettua 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 l'hai già fatto, esegui le fasi facoltative descritte nelle sezioni precedenti per includere transformation_ctx.

2. 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.

Per abilitare i segnalibri di processo, aggiungi 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 attivi i segnalibri di processo utilizzando la AWS Management Console.

Abilitazione dei segnalibri di processo

1. Passa alla sezione Job details (Dettagli del processo) del processo corrispondente.

2. Imposta 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. Scegli Untitled job (Processo senza titolo) sulla barra del titolo per modificare e impostare il nome del processo.

2. Passa alla scheda Job details (Dettagli del lavoro). Assegna al processo un IAM Role (Ruolo IAM). Puoi usare quello creato dal AWS CloudFormation modello nei prerequisiti per il tutorial di AWS Glue Studio. Se hai completato quel tutorial, dovrebbe essere disponibile come AWS Glue StudioRole.

3. Scegli Save (Salva) per salvare lo script.

4. Scegli Run (Esegui) per eseguire il processo.

5. Passa alla scheda Runs (Esecuzioni) per verificare il completamento del processo.

6. Passa a DOC-EXAMPLE-BUCKET, vale a dire la destinazione di write_dynamic_frame.from_options. Verifica che l'output corrisponda alle tue aspettative.

Per ulteriori informazioni sulla configurazione e la gestione dei processi, consulta la sezione Fornire i propri script personalizzati.

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, consulta la sezione esempi del repository di orgine di Spark.

AWS Glue 2.0+ 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, consulta Uso di librerie Python con AWS Glue.

Per altri esempi di come usare le funzionalità di AWS Glue in Python, vedi. Esempi di codice Python in AWS Glue 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.