Aan de slag met AWS Glue: een stapsgewijze gids

AWS Glue: een stapsgewijze gids

Nu begint het leuke deel: leren hoe je Glue gebruikt voor een heel algemene dataverwerkingstaak: CSV-bestanden converteren naar Parquet.

1. AWS-account instellen

Voor wie nieuw is met AWS: de eerste stap is een account aanmaken en vervolgens inloggen op de beheerconsole.

• Ga naar AWS en meld je aan.
• Log, zodra je een account hebt, in op de AWS Management Console.

2. IAM-rol aanmaken

AWS Identity and Access Management (IAM) stelt gebruikers in staat om veilig toegang tot AWS-services en -resources te beheren.

We moeten een IAM-rol maken zodat Glue toegang heeft tot de relevante services. In ons geval is de belangrijkste service waar we toegang toe nodig hebben S3, waar onze CSV-bestanden staan.

De AWS Storage Tutorial is een mooie manier voor nieuwe AWS-gebruikers om meer te leren over systemen zoals S3. 

De belangrijkste stappen om die IAM-rol te maken, zijn hieronder beschreven, startend vanuit de Management Console:

• Navigeer naar de IAM-service.
• Klik in de linkerzijbalk op "Roles" en klik daarna op "Create role".
• Selecteer onder "Choose a use case" de optie "Glue" en klik op "Next: Permissions".
• Zoek en selecteer de volgende policies:
• AWSGlueServiceRole
• AmazonS3FullAccess (Let op: in een productieomgeving maak je beter een restrictiever beleid).
• Geef je rol een naam (bijv. "GlueETLRole"), en desgewenst een beschrijving, maar dat is niet verplicht. Klik tot slot op "Create role".

Stappen om een IAM-rol te maken in de AWS-console. Afbeelding door de auteur

De Complete gids voor AWS IAM doorloopt de stappen om IAM te gebruiken om AWS-omgevingen te beveiligen, toegang te beheren met users, groups en roles, en beste praktijken voor sterke beveiliging te schetsen.

3. S3-bucket instellen

We slaan zowel de input-CSV-bestanden als de output-Parquet-bestanden op Amazon S3 op.

De inputdata voor dit voorbeeld is gemaakt ter illustratie en is te vinden in de GitHub-repository van de auteur:

• athletes.csv: Bevat informatie over atleten, inclusief hun ID, naam, land, sport en leeftijd.
• events.csv: Lijst met verschillende evenementen, inclusief event-ID, sport, eventnaam, datum en locatie.
• medals.csv: Registreert medaille-informatie, waarbij events en atleten worden gekoppeld aan de medailles die ze wonnen.

Nu kunnen we onze S3-bucket als volgt inrichten:

• Ga in de AWS Management Console naar de S3-service.
• Klik op "Create bucket" en geef hem een unieke naam (bijv. "my-glue-csv-etl-bucket").
• Laat de bucket-standaardinstellingen staan voor het gemak en maak de bucket.
• Maak twee mappen in je bucket: "input" en "output".

Flow voor het maken van S3-bucket en mappen. Afbeelding door de auteur 

Na het maken van de twee mappen zou de inhoud van je bucket er als volgt uit moeten zien:

Weergave van de mappen in de S3-bucket. Afbeelding door de auteur

Nu kunnen we deze CSV-inputbestanden uploaden naar de map "input".

Inhoud van de map "input" in de S3-bucket. Afbeelding door de auteur

4. Een Glue-crawler maken

Een Glue-crawler wordt gebruikt om onze data automatisch te ontdekken en te catalogiseren. In dit onderdeel leggen we uit hoe je een crawler maakt die alle CSV-inputbestanden scant. 

De belangrijkste stappen staan hieronder uitgelegd:

• Ga in de AWS Management Console naar de AWS Glue-service.
• Klik in de linkerzijbalk onder "Data catalog" op "Crawlers".
• Klik op "Create crawler".
• Geef je crawler een naam (bijv. "CSV-to-Parquet-Crawler") en laat het beschrijvingsveld leeg, klik vervolgens op "Next".
• We moeten "S3" als databron opgeven, wat je doet door "Add data source" te kiezen als crawlersourcetype en te klikken op "Next".

Flow voor het maken van een AWS Glue-crawler in de console - deel 1. Afbeelding door de auteur

• Kies "S3" als datastore en specificeer het pad naar je S3-bucket, wat je kunt doen door "Browse S3" te selecteren. Klik daarna op "Next".
• Selecteer "Crawl all sub-folders"
• Selecteer "Add an S3 data source" en klik vervolgens op "Next".
• Controleer, voordat je verdergaat, het gegevenstype "S3" en klik dan op "Next".

Flow voor het maken van een AWS Glue-crawler in de console - deel 2. Afbeelding door de auteur

Zodra we de S3-bucket hebben verbonden, moeten we de eerder gemaakte IAM-rol koppelen om Glue toegang te geven tot S3-buckets. De naam van onze rol is "GlueETLRole".

• Kies de rolnaam in het veld "Existing IAM role".
• Klik op "Next".

Flow voor het maken van een AWS Glue-crawler in de console - deel 3. Afbeelding door de auteur

De volgende stap is het aanmaken van een database. De database "paris_olympics_db" die we zullen maken, dient als centrale repository in de AWS Glue Data Catalog om metadata over onze CSV-bestanden op te slaan en te organiseren. 

De catalogus maakt efficiënte data discovery mogelijk en vereenvoudigt ons ETL-proces voor het combineren en converteren van de data over atleten, events en medailles naar Parquet-indeling.

Op dit moment hebben we nog geen database; de stappen voor het aanmaken staan hieronder geïllustreerd:

• Selecteer "Add database"; er opent een nieuw venster om onze database te maken. Geef de naam "paris_olympics_db", laat de rest op standaard staan en klik op "Create database".

Flow voor het maken van een AWS Glue-crawler in de console - deel 4. Afbeelding door de auteur

Ga in het oorspronkelijke tabblad waar we een database verbinden naar de sectie "Target database", ververs deze en kies de zojuist aangemaakte database. Klik vervolgens op "Next".

Flow voor het maken van een AWS Glue-crawler in de console - deel 5. Afbeelding door de auteur

Controleer tot slot alles en klik op "Create crawler".

AWS Glue-crawler "Review and create"-weergave. Afbeelding door de auteur

Na het aanmaken van een crawler zouden we het volgende resultaat moeten zien dat de creatie bevestigt:

Glue-crawler succesvol aangemaakt. Afbeelding door de auteur

5. Een Glue-crawler uitvoeren

Nu we onze crawler hebben aangemaakt, is het tijd om hem uit te voeren en te zien hoe hij onze data catalogiseert.

Glue-knop "Run crawler". Afbeelding door de auteur

• Selecteer je crawler in de lijst.
• Klik op "Run crawler".
• Wacht tot de crawler klaar is. Dit kan een paar minuten duren.
• Ga na voltooiing in de linkerzijbalk naar "Databases" onder "Data catalog".
• Klik op de database die is aangemaakt.
• Je zou een tabel moeten zien die de structuur van je CSV-data vertegenwoordigt.

Weergave van tabellen die in de database zijn aangemaakt door de Glue-crawler. Afbeelding door de auteur

6. Een Glue-job maken en uitvoeren

Met onze datacatalogus gereed, kunnen we nu een Glue-job maken om onze CSV-bestanden te combineren en te converteren naar Parquet-indeling. Dit onderdeel leidt je door het maken van de Glue-job en geeft de benodigde Python-code.

• Ga in de AWS Glue-console in de linkerzijbalk naar "Jobs" onder "ETL".
• Selecteer de Script editor om een editor te openen voor het schrijven van Python-code en klik op "Create script".

Een Glue-job maken en uitvoeren - deel 1. Afbeelding door de auteur

Door het script te maken, opent het volgende scripttabblad waar we de job een naam kunnen geven; in ons geval is dat "CS".

• Plak in de codetsectie de volgende code en klik vervolgens op "Save".

Een Glue-job maken en uitvoeren - deel 2. Afbeelding door de auteur

De bijbehorende Python-code staat hieronder:

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

Laten we kort bekijken wat er in de code gebeurt:

1. Imports: Importeert de benodigde libraries uit AWS Glue, PySpark en de standaardbibliotheek van Python.
2. Initialisatie: Initialiseert de Spark- en Glue-contexten en stelt Spark-configuraties in voor optimalisatie.
3. Jobparameters: Haalt jobparameters op, specifiek de jobnaam, uit de commandoregelargumenten.
4. Paden: Definieert de input- en outputpaden voor de CSV- en Parquet-bestanden in de S3-bucket.
5. Functiedefinitie: Definieert de functie csv_to_parquet() om een CSV-bestand te lezen, het schema te printen, een datumkolom te converteren als die bestaat, en de data als Parquet te schrijven. Verwerkt uitzonderingen tijdens het proces.
6. Bestandsverwerking: Verwerkt een lijst met bestanden (athletes, events, medals) door de functie csv_to_parquet() op elk bestand aan te roepen.
7. Jobcommit: Commit de job en print een voltooiingsbericht.

Voordat we de job uitvoeren, moeten we de volgende extra configuraties invullen in de sectie "Job details":

• Geef de IAM-rol op die we eerder hebben aangemaakt om de jobuitvoering toe te staan.
• Stel het jobtype in op "Spark", laat de rest van de velden op standaard staan en klik op "Save".
• Voer daarna de job uit!

Een Glue-job maken en uitvoeren - deel 3. Afbeelding door de auteur

Na het succesvol uitvoeren van de job kunnen we meer details zien over de status van de uitvoering:

Weergave van jobrundetails in AWS Glue. Afbeelding door de auteur

Toegang tot en monitoring van de rundetails is belangrijk om efficiënte en betrouwbare datapijplijnen te onderhouden. Deze statistieken geven waardevolle inzichten en helpen bij het volgende:

• Prestatieoptimalisatie: Volg uitvoeringstijden om de efficiëntie van jobs en resourceallocatie te verbeteren.
• Kostenbeheer: Monitor het resourcegebruik (DPU's, workers) om binnen het budget te blijven en kosten te optimaliseren.
• Capaciteitsplanning: Gebruik uitvoeringmetrics om resourcebehoeften te voorspellen en voor schaalbaarheid te plannen.

De succesvolle uitvoering van deze job heeft elk CSV-bestand geconverteerd naar het bijbehorende Parquet-bestand en deze opgeslagen in de map "output", zoals hieronder weergegeven:

• Links staan de mappen met dezelfde naam als het oorspronkelijke CSV-bestand.
• Rechts staan de Parquet-bestanden voor elk CSV-bestand.

Inhoud van de map "output" in de S3-bucket. Afbeelding door de auteur

Conclusie en volgende stappen

Deze tutorial besprak AWS Glue en de functies ervan. Je leerde een AWS-omgeving in te richten en de AWS Glue-interface te verkennen. Ook liet hij zien hoe je een Glue-crawler bouwt en uitvoert om data te catalogiseren, een Glue-job maakt om die te transformeren, en succesvol CSV-bestanden naar Parquet-indeling converteert.

Je kunt voortbouwen op wat je hebt geleerd door triggers in te stellen om workflows te automatiseren, foutafhandeling en logging te implementeren en Parquet-bestanden te optimaliseren voor nog betere prestaties. Je kunt je data ook query'en met AWS Athena of Amazon Redshift Spectrum.

Houd bovendien je AWS-gebruik en -kosten in de gaten en ruim resources op wanneer ze niet meer nodig zijn om onnodige kosten te voorkomen.

De cursussen Introduction to AWS en AWS Cloud Technology and Services zijn uitstekende volgende stappen om verder te leren! 

De eerste biedt een solide basis in AWS en cloud computing, ideaal voor beginners of wie kernconcepten wil opfrissen. De tweede richt zich op praktijkgericht leren en helpt je je praktische kennis van AWS-services te verdiepen.