Introduzione ad AWS Glue: guida passo dopo passo

AWS Glue: guida passo dopo passo

Ed ecco la parte interessante: impariamo a usare Glue per un’attività di data processing molto comune, la conversione di file CSV in Parquet.

1. Configurazione dell’account AWS

Se sei nuovo su AWS, il primo passo è creare un account e poi accedere alla console di gestione.

• Vai su AWS e registrati.
• Una volta creato l’account, accedi all’AWS Management Console.

2. Creazione del ruolo IAM

AWS Identity and Access Management (IAM) consente di gestire in modo sicuro l’accesso ai servizi e alle risorse AWS.

Dobbiamo creare un ruolo IAM per consentire a Glue di accedere ai servizi rilevanti. Nel nostro caso, il servizio principale è S3, che ospita i nostri file CSV.

Il Tutorial sullo storage AWS è un ottimo modo per i nuovi utenti AWS di approfondire sistemi come S3. 

I passaggi principali per creare quel ruolo IAM sono descritti di seguito, a partire dalla Management Console:

• Vai al servizio IAM.
• Fai clic su "Roles" nella barra laterale sinistra, poi su "Create role".
• Sotto "Choose a use case", seleziona "Glue" e fai clic su "Next: Permissions".
• Cerca e seleziona le seguenti policy:
• AWSGlueServiceRole
• AmazonS3FullAccess (Nota: in produzione dovresti creare una policy più restrittiva).
• Dai un nome al ruolo (ad es. "GlueETLRole") ed eventualmente una descrizione, ma non è obbligatoria. Infine, fai clic su "Create role".

Passaggi per creare un ruolo IAM nella console AWS. Immagine dell’autore

La Guida completa a AWS IAM illustra i passaggi per usare IAM per mettere in sicurezza ambienti AWS, gestire l’accesso con utenti, gruppi e ruoli e descrivere le best practice per una sicurezza solida.

3. Configurazione del bucket S3

Salveremo sia i file CSV in input sia i file Parquet in output su Amazon S3.

I dati di input per questo esempio sono stati creati a scopo illustrativo e si trovano nel repository GitHub dell’autore:

• athletes.csv: contiene informazioni sugli atleti, inclusi ID, nome, paese, sport ed età.
• events.csv: elenca vari eventi, inclusi ID evento, sport, nome evento, data e sede.
• medals.csv: registra le informazioni sulle medaglie, collegando eventi e atleti alle medaglie vinte.

Ora possiamo configurare il nostro bucket S3 come segue:

• Vai al servizio S3 nell’AWS Management Console.
• Fai clic su "Create bucket" e dagli un nome univoco (ad es. "my-glue-csv-etl-bucket").
• Lascia le impostazioni predefinite del bucket per semplicità e crea il bucket.
• Crea due cartelle nel tuo bucket: "input" e "output".

Flusso di creazione del bucket e delle cartelle S3. Immagine dell’autore 

Dopo aver creato le due cartelle, il contenuto del tuo bucket dovrebbe apparire così:

Vista delle cartelle all’interno del bucket S3. Immagine dell’autore

Ora possiamo caricare questi file CSV di input nella cartella "input".

Contenuto della cartella “input” del bucket S3. Immagine dell’autore

4. Creazione di un crawler Glue

Un crawler Glue serve a scoprire e catalogare automaticamente i nostri dati. Questa sezione spiega come creare un crawler che scansioni tutti i file CSV in input.

I passaggi principali sono i seguenti:

• Vai al servizio AWS Glue nell’AWS Management Console.
• Nella barra laterale sinistra, sotto "Data catalog", fai clic su "Crawlers".
• Fai clic su "Create crawler".
• Dai un nome al crawler (ad es. "CSV-to-Parquet-Crawler") e lascia vuoto il campo descrizione, poi fai clic su "Next".
• Dobbiamo specificare “S3” come sorgente dati, scegliendo "Add data source" come tipo di sorgente del crawler e facendo clic su "Next".

Flusso di creazione del crawler AWS Glue nella console - parte 1. Immagine dell’autore

• Scegli "S3" come data store e specifica il percorso del tuo bucket S3, selezionando “Browse S3”. Poi fai clic su "Next".
• Seleziona “Crawl all sub-folders”.
• Seleziona “Add an S3 data source”, quindi fai clic su "Next".
• Prima di procedere, verifica il tipo di dati “S3”, poi “Next”.

Flusso di creazione del crawler AWS Glue nella console - parte 2. Immagine dell’autore

Dopo aver collegato il bucket S3, dobbiamo associare il ruolo IAM creato in precedenza per consentire a Glue di accedere ai bucket S3. Il nome del nostro ruolo è “GlueETLRole”.

• Scegli il nome del ruolo dal campo “Existing IAM role”.
• Fai clic su “Next”.

Flusso di creazione del crawler AWS Glue nella console - parte 3. Immagine dell’autore

Il passaggio successivo è creare un database. Il database “paris_olympics_db” che creeremo funge da repository centrale nell’AWS Glue Data Catalog per archiviare e organizzare i metadati dei nostri file CSV.

Il catalogo abiliterà una scoperta efficiente dei dati e semplificherà il nostro processo ETL per combinare e convertire i dati di atleti, eventi e medaglie in formato Parquet.

Al momento non abbiamo ancora alcun database e i passaggi per crearlo sono illustrati di seguito:

• Seleziona “Add database”, che aprirà una nuova finestra per la creazione del database. Assegnagli il nome “paris_olympics_db”, lasciando tutto il resto come predefinito, e fai clic su “Create database”.

Flusso di creazione del crawler AWS Glue nella console - parte 4. Immagine dell’autore

Dalla scheda originale in cui colleghiamo un database, aggiorna la sezione “Target database” e scegli il database appena creato. Poi fai clic su “Next”.

Flusso di creazione del crawler AWS Glue nella console - parte 5. Immagine dell’autore

Infine, rivedi tutto e fai clic su “Create crawler”.

Vista “Review and create” del crawler AWS Glue. Immagine dell’autore

Dopo aver creato il crawler, dovremmo vedere il seguente risultato che ne conferma la creazione:

Creazione del crawler Glue riuscita. Immagine dell’autore

5. Esecuzione di un crawler Glue

Ora che abbiamo creato il crawler, è il momento di eseguirlo e vedere come cataloga i nostri dati.

Pulsante “Run crawler” di Glue. Immagine dell’autore

• Seleziona il tuo crawler dall’elenco.
• Fai clic su "Run crawler".
• Attendi che il crawler finisca. Potrebbe richiedere alcuni minuti.
• Al termine, vai su "Databases" sotto "Data catalog" nella barra laterale sinistra.
• Fai clic sul database che è stato creato.
• Dovresti vedere una tabella che rappresenta la struttura dei tuoi dati CSV.

Vista delle tabelle create nel database dall’esecuzione del crawler Glue. Immagine dell’autore

6. Creazione ed esecuzione di un job Glue

Con il catalogo dati creato, possiamo ora creare un job Glue per combinare i nostri file CSV e convertirli in formato Parquet. Questa sezione ti guida nella creazione del job Glue e fornisce il codice Python necessario.

• Vai su "Jobs" sotto "ETL" nella console AWS Glue nella barra laterale sinistra.
• Seleziona lo Script editor per aprire un editor in cui scrivere codice Python e fai clic su “Create script”.

Creazione ed esecuzione di un job Glue - parte 1. Immagine dell’autore

La creazione dello script apre la seguente scheda in cui possiamo assegnare un nome al job, nel nostro caso “CS”.

• Nella sezione del codice, incolla il codice seguente, quindi fai clic su “Save”.

Creazione ed esecuzione di un job Glue - parte 2. Immagine dell’autore

Il codice Python corrispondente è riportato di seguito:

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
from pyspark.sql.functions import col, to_date

# Initialize the Spark and Glue contexts
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)

# Set Spark configurations for optimization
spark.conf.set("spark.sql.adaptive.enabled", "true")
spark.conf.set("spark.sql.adaptive.coalescePartitions.enabled", "true")

# Get job parameters
args = getResolvedOptions(sys.argv, ['JOB_NAME'])

# Set the input and output paths
input_path = "s3://glue-csv-etl-bucket/input/"
output_path = "s3://glue-csv-etl-bucket/output/"

# Function to read CSV and write Parquet
def csv_to_parquet(input_file, output_file):
    try:
        # Read CSV
        df = spark.read.option("header", "true") \
                       .option("inferSchema", "true") \
                       .option("mode", "PERMISSIVE") \
                       .option("columnNameOfCorruptRecord", "_corrupt_record") \
                       .csv(input_file)
        
        # Print schema for debugging
        print(f"Schema for {input_file}:")
        df.printSchema()
        
        # Convert date column if it exists (assuming it's in the format M/d/yyyy)
        if "date" in df.columns:
            df = df.withColumn("date", to_date(col("date"), "M/d/yyyy"))
        
        # Write Parquet
        df.write.mode("overwrite").parquet(output_file)
        
        print(f"Successfully converted {input_file} to Parquet at {output_file}")
        print(f"Number of rows processed: {df.count()}")
    except Exception as e:
        print(f"Error processing {input_file}: {str(e)}")

# List of files to process
files = ["athletes", "events", "medals"]

# Process each file
for file in files:
    input_file = f"{input_path}{file}.csv"
    output_file = f"{output_path}{file}_parquet"
    csv_to_parquet(input_file, output_file)

job.commit()
print("Job completed.")

Vediamo brevemente cosa succede nel codice:

1. Import: importa le librerie necessarie da AWS Glue, PySpark e dalla libreria standard di Python.
2. Inizializzazione: inizializza i contesti Spark e Glue e imposta configurazioni Spark per l’ottimizzazione.
3. Parametri del job: recupera i parametri del job, in particolare il nome del job, dagli argomenti della riga di comando.
4. Percorsi: definisce i percorsi di input e output per i file CSV e Parquet nel bucket S3.
5. Definizione di funzione: definisce la funzione csv_to_parquet() per leggere un file CSV, stamparne lo schema, convertire una colonna di data se esiste e scrivere i dati come file Parquet. Gestisce le eccezioni durante l’elaborazione.
6. Elaborazione dei file: elabora un elenco di file (athletes, events, medals) chiamando la funzione csv_to_parquet() su ciascuno.
7. Commit del job: effettua il commit del job e stampa un messaggio di completamento.

Prima di eseguire il job, dobbiamo compilare le seguenti configurazioni aggiuntive nella sezione “Job details”:

• Fornisci il ruolo IAM creato in precedenza per consentire l’esecuzione del job.
• Imposta il “Type” del Job su “Spark”, lascia gli altri campi predefiniti e fai “Save”.
• Quindi, esegui il job!

Creazione ed esecuzione di un job Glue - parte 3. Immagine dell’autore

Dopo aver eseguito correttamente il job, possiamo vedere ulteriori dettagli sullo stato dell’esecuzione:

Vista dei dettagli di esecuzione del job AWS Glue. Immagine dell’autore

Accedere e monitorare i dettagli dell’esecuzione è importante per mantenere pipeline di dati efficienti e affidabili. Queste metriche forniscono informazioni preziose e aiutano a:

• Ottimizzazione delle prestazioni: tracciare i tempi di esecuzione per migliorare l’efficienza dei job e l’allocazione delle risorse.
• Gestione dei costi: monitorare l’uso delle risorse (DPU, worker) per allinearsi al budget e ottimizzare le spese.
• Pianificazione della capacità: usare le metriche di esecuzione per prevedere le esigenze di risorse e pianificare la scalabilità.

L’esecuzione riuscita di questo job ha convertito ciascun file CSV nel corrispondente file Parquet e li ha archiviati nella cartella “output” come mostrato di seguito:

• A sinistra troviamo cartelle con lo stesso nome del file CSV originale.
• La parte a destra corrisponde ai file Parquet per ciascun file CSV.

Contenuto della cartella di output all’interno del bucket S3. Immagine dell’autore

Conclusioni e prossimi passi

Questo tutorial ha trattato AWS Glue e le sue funzionalità. Ti ha guidato nella configurazione di un ambiente AWS e nell’esplorazione dell’interfaccia AWS Glue. Ti ha anche mostrato come creare ed eseguire un crawler Glue per catalogare i dati, creare un job Glue per trasformarli e convertire con successo i file CSV in formato Parquet.

Puoi ampliare quanto appreso impostando trigger per automatizzare i workflow, implementando gestione degli errori e logging e ottimizzando i file Parquet per prestazioni ancora migliori. Puoi anche esplorare l’esecuzione di query sui tuoi dati con AWS Athena o Amazon Redshift Spectrum.

Inoltre, monitora l’utilizzo e i costi AWS e pulisci le risorse quando non sono più necessarie per evitare addebiti inutili.

I corsi Introduction to AWS e AWS Cloud Technology and Services possono essere ottimi prossimi passi per continuare a imparare! 

Il primo offre basi solide su AWS e cloud computing, ideale per chi inizia o vuole ripassare i concetti chiave. Il secondo è incentrato sull’apprendimento pratico, per approfondire l’uso dei servizi AWS.