Tutorial: scrittura di uno script in AWS Glue per Spark

Questo tutorial mostra il processo di scrittura degli script in 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. Per ulteriori informazioni, sulle sessioni interattive, consultare Panoramica delle sessioni interattive in AWS Glue.

L'editor visivo di AWS Glue Studio offre un'interfaccia grafica, senza codice per la creazione di processi AWS Glue jobsAWS Gli script. Glue supportano i processi visivi. Danno accesso al set esteso di strumenti disponibili per lavorare con i programmi Apache Spark. È possibile accedere alle API Spark native e alle librerie AWS Glue che facilitano l'estrazione, la trasformazione e il caricamento dei flussi di lavoro (ETL) da uno script di AWS Glue.

In questo tutorial, si estrae, trasforma e carica un set di dati di multe per il parcheggio. Lo script che esegue questa operazione è identico nella forma e nella funzione a quello generato in Semplificazione di processi ETL con AWS Glue Studio nel blog dei Big Data di AWS, che introduce l'editor visivo di AWS Glue Studio. L'esecuzione di questo script all'interno di un processo consente di confrontarlo con i processi visivi e di comprendere come lavorano gli script ETL di AWS Glue. 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 concluso questo tutorial, sarà possibile generare e ispezionare uno script Scala di esempio per comprendere come eseguire il processo di scrittura di uno script ETL di AWS Glue in Scala.

Prerequisiti

Di seguito sono elencati i requisiti per questo tutorial:

Generazione di uno script di esempio

Per creare una struttura dello script, puoi utilizzare l'editor visivo di AWS Glue Studio come potente strumento di generazione del codice. Questo strumento verrà utilizzato per creare uno script di esempio.

Se si preferisce saltare queste fasi, è possibile utilizzare lo script seguente.

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()

Fase 1: Creare un processo e incollare lo script

Questa fase mostra la creazione di un processo AWS Glue nella Console di gestione AWS. Con questa operazione si imposta una configurazione che consente ad AWS Glue di eseguire lo script e si crea contemporaneamente uno spazio dove archiviarlo e modificarlo.

Fase 2: Importazione delle 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. Questa operazione viene svolta in background in AWS Glue Studio.

In questa fase, procedere secondo quanto descritto di seguito.

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)

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. Fornire queste informazioni nell'editor visivo di AWS Glue Studio creando un nodo Origine.

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"
    )

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

create_dynamic_frame.from_catalog fornisce un oggetto DynamicFrame. DynamicFrame rappresenta un set di dati in AWS Glue. Le trasformazioni di AWS Glue sono operazioni che modificano DynamicFrames.

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",
)

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 target (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 questa sezione di AWS Glue troverai i metodi usati per configurare le destinazioni e le origini.

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",
    )

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. Questa operazione viene svolta in background in 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()

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 di processo tengono traccia dell'avanzamento di una trasformazione AWS Glue su un set di dati rispetto alle esecuzioni precedenti. Tenendo traccia di dove le esecuzioni precedenti sono terminate, AWS Glue può limitare il lavoro alle righe non elaborate in precedenza. Per ulteriori informazioni sui segnalibri di processo, consultare Monitoraggio dei dati elaborati mediante segnalibri di processo.

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.

Fase 7. Esecuzione del codice come processo

In questa fase, esegui il processo per verificare di aver completato correttamente questo tutorial. Questa operazione viene eseguita con un semplice clic di un pulsante, ad esempio nell'editor visivo di AWS Glue Studio.

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

Ulteriori informazioni

Le librerie e i metodi di Apache Spark sono disponibili negli script di 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.

Per impostazione predefinita, AWS Glue 2.0+ include diverse librerie Python comuni. Esistono anche meccanismi per caricare le proprie dipendenze in un processo di AWS Glue in un ambiente Scala o Python. Per ulteriori informazioni sulle dipendenze Python, consultare Usare le librerie Python con Glue AWS.

Per ulteriori esempi di come utilizzare le funzionalità di AWS Glue in Python, consultare 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.