Erste Schritte mit AWS Glue: Die Schritt-für-Schritt-Anleitung

AWS Glue: Schritt für Schritt

Jetzt wird’s spannend: Lass uns lernen, wie du Glue für eine sehr gängige Aufgabe nutzt — die Konvertierung von CSV in Parquet.

1. AWS-Konto einrichten

Wenn du neu bei AWS bist, erstellst du zuerst ein Konto und meldest dich anschließend in der Management Console an.

• Gehe zu AWS und registriere dich.
• Melde dich danach in der AWS Management Console an.

2. IAM-Rolle erstellen

AWS Identity and Access Management (IAM) ermöglicht es, den Zugriff auf AWS-Services und -Ressourcen sicher zu verwalten.

Wir benötigen eine IAM-Rolle, damit Glue auf die relevanten Services zugreifen kann. In unserem Fall ist S3 der Hauptdienst, in dem unsere CSV-Dateien liegen.

Das AWS Storage Tutorial ist ein guter Einstieg für AWS-Neulinge, um Systeme wie S3 besser zu verstehen. 

Die wichtigsten Schritte zur Erstellung der IAM-Rolle ab der Management Console sind:

• Navigiere zum IAM-Service.
• Klicke in der linken Seitenleiste auf "Roles" und dann auf "Create role".
• Unter "Choose a use case" wähle "Glue" und klicke auf "Next: Permissions".
• Suche und wähle folgende Richtlinien aus:
• AWSGlueServiceRole
• AmazonS3FullAccess (Hinweis: In Produktionsumgebungen solltest du eine restriktivere Richtlinie verwenden).
• Gib deiner Rolle einen Namen (z. B. "GlueETLRole") und optional eine Beschreibung. Klicke abschließend auf "Create role".

Schritte zum Erstellen einer IAM-Rolle in der AWS-Konsole. Bild: Autor

Die komplette IAM-Anleitung zeigt dir Schritt für Schritt, wie du AWS-Umgebungen absicherst, Zugriffe mit Nutzern, Gruppen und Rollen verwaltest und Best Practices für robuste Sicherheit umsetzt.

3. S3-Bucket einrichten

Wir speichern sowohl die Eingabe-CSV-Dateien als auch die ausgegebenen Parquet-Dateien in Amazon S3.

Die Beispieldaten wurden zu Demonstrationszwecken erstellt und liegen im GitHub-Repository des Autors:

• athletes.csv: Enthält Informationen zu Athletinnen und Athleten, inkl. ID, Name, Land, Sportart und Alter.
• events.csv: Listet verschiedene Events mit Event-ID, Sportart, Eventname, Datum und Veranstaltungsort.
• medals.csv: Erfasst Medaillendaten und verknüpft Events und Athleten mit den gewonnenen Medaillen.

Jetzt richten wir den S3-Bucket wie folgt ein:

• Öffne in der AWS Management Console den S3-Service.
• Klicke auf "Create bucket" und gib einen eindeutigen Namen ein (z. B. "my-glue-csv-etl-bucket").
• Lass der Einfachheit halber die Standardeinstellungen und erstelle den Bucket.
• Erstelle im Bucket zwei Ordner: "input" und "output".

Ablauf: S3-Bucket und Ordner anlegen. Bild: Autor 

Nach dem Anlegen der beiden Ordner sollte dein Bucket so aussehen:

Ansicht der Ordner im S3-Bucket. Bild: Autor

Jetzt können wir diese CSV-Eingabedateien in den Ordner "input" hochladen.

Inhalt des Ordners “input” im S3-Bucket. Bild: Autor

4. Glue Crawler erstellen

Ein Glue Crawler erkennt und katalogisiert unsere Daten automatisch. In diesem Abschnitt erstellen wir einen Crawler, der alle CSV-Eingabedateien scannt.

Die wichtigsten Schritte:

• Öffne den AWS Glue Service in der AWS Management Console.
• Klicke in der linken Seitenleiste unter "Data catalog" auf "Crawlers".
• Klicke auf "Create crawler".
• Gib deinem Crawler einen Namen (z. B. "CSV-to-Parquet-Crawler") und lass die Beschreibung frei. Klicke dann auf "Next".
• Als Datenquelle wählen wir “S3”. Wähle dazu "Add data source" als Crawler Source Type und klicke auf "Next".

Ablauf: Glue Crawler in der Konsole erstellen — Teil 1. Bild: Autor

• Wähle "S3" als Datenspeicher und gib deinen S3-Bucket-Pfad an, z. B. über “Browse S3”. Klicke anschließend auf "Next".
• Wähle “Crawl all sub-folders”.
• Wähle “Add an S3 data source” und klicke auf "Next".
• Prüfe den Datentyp “S3” und klicke dann auf “Next”.

Ablauf: Glue Crawler in der Konsole erstellen — Teil 2. Bild: Autor

Nachdem der S3-Bucket verbunden ist, verknüpfen wir die zuvor erstellte IAM-Rolle, damit Glue auf S3-Buckets zugreifen kann. Unsere Rolle heißt “GlueETLRole”.

• Wähle den Rollennamen im Feld “Existing IAM role” aus.
• Klicke auf “Next”.

Ablauf: Glue Crawler in der Konsole erstellen — Teil 3. Bild: Autor

Als Nächstes erstellen wir eine Datenbank. Die Datenbank “paris_olympics_db” dient im AWS Glue Data Catalog als zentrales Repository, um Metadaten zu unseren CSV-Dateien zu speichern und zu organisieren.

Der Katalog ermöglicht effiziente Datenerkennung und vereinfacht unseren ETL-Prozess, um die Daten zu Athleten, Events und Medaillen zusammenzuführen und in Parquet zu konvertieren.

Aktuell existiert noch keine Datenbank. So legst du sie an:

• Wähle “Add database”. Im neuen Fenster gibst du “paris_olympics_db” als Namen ein, lässt die übrigen Felder auf Standard und klickst auf “Create database”.

Ablauf: Glue Crawler in der Konsole erstellen — Teil 4. Bild: Autor

Wechsle zurück in den ursprünglichen Tab zur Datenbankverknüpfung, aktualisiere den Bereich “Target database” und wähle die neu erstellte Datenbank aus. Klicke dann auf “Next”.

Ablauf: Glue Crawler in der Konsole erstellen — Teil 5. Bild: Autor

Prüfe alles und klicke abschließend auf “Create crawler”.

Glue Crawler “Review and create”-Ansicht. Bild: Autor

Nach dem Erstellen des Crawlers siehst du eine Bestätigung wie folgt:

Crawler erfolgreich erstellt. Bild: Autor

5. Glue Crawler ausführen

Nachdem der Crawler erstellt ist, führen wir ihn aus und sehen, wie er unsere Daten katalogisiert.

Glue-Schaltfläche “Run crawler”. Bild: Autor

• Wähle deinen Crawler aus der Liste.
• Klicke auf "Run crawler".
• Warte, bis der Crawler fertig ist. Das kann ein paar Minuten dauern.
• Gehe anschließend in der linken Seitenleiste unter "Data catalog" zu "Databases".
• Öffne die erstellte Datenbank.
• Du solltest eine Tabelle sehen, die die Struktur deiner CSV-Daten abbildet.

Ansicht der durch den Glue Crawler erstellten Tabellen in der Datenbank. Bild: Autor

6. Glue Job erstellen und ausführen

Mit dem erstellten Datenkatalog können wir nun einen Glue Job anlegen, der unsere CSV-Dateien zusammenführt und ins Parquet-Format konvertiert. Dieser Abschnitt führt dich durch die Erstellung des Jobs und liefert den benötigten Python-Code.

• Gehe in der linken Seitenleiste der AWS Glue-Konsole unter "ETL" zu "Jobs".
• Wähle den Script Editor, um Python-Code zu schreiben, und klicke auf “Create script”.

Glue Job erstellen und ausführen — Teil 1. Bild: Autor

Nach dem Anlegen öffnet sich ein Skript-Tab, in dem wir dem Job einen Namen geben, in unserem Fall “CS”.

• Füge den folgenden Code in den Editor ein und klicke auf “Save”.

Glue Job erstellen und ausführen — Teil 2. Bild: Autor

Der zugehörige Python-Code lautet:

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

Kurz erklärt, was der Code macht:

1. Imports: Bindet benötigte Bibliotheken aus AWS Glue, PySpark und der Python-Standardbibliothek ein.
2. Initialisierung: Initialisiert Spark- und Glue-Kontexte und setzt Spark-Optimierungen.
3. Job-Parameter: Liest Job-Parameter (insbesondere den Jobnamen) aus den Kommandozeilenargumenten.
4. Pfade: Definiert Eingabe- und Ausgabe-Pfade für CSV- und Parquet-Dateien im S3-Bucket.
5. Funktionsdefinition: csv_to_parquet() liest eine CSV-Datei, gibt das Schema aus, konvertiert ggf. eine Datumsspalte und schreibt die Daten als Parquet. Fehler werden abgefangen und geloggt.
6. Dateiverarbeitung: Verarbeitet die Dateiliste (athletes, events, medals) jeweils über csv_to_parquet().
7. Job-Abschluss: Commit des Jobs und Ausgabe einer Abschlussmeldung.

Bevor wir den Job ausführen, ergänzen wir im Bereich “Job details” noch folgende Einstellungen:

• Hinterlege die zuvor erstellte IAM-Rolle, damit der Job ausgeführt werden kann.
• Setze den Job-“Type” auf “Spark”, belasse den Rest bei den Standardwerten und klicke auf “Save”.
• Führe den Job aus!

Glue Job erstellen und ausführen — Teil 3. Bild: Autor

Nach erfolgreicher Ausführung siehst du detaillierte Informationen zum Status:

Detailansicht eines Glue Job Runs. Bild: Autor

Die Ausführungsdetails zu prüfen und zu überwachen ist entscheidend für effiziente und verlässliche Datenpipelines. Diese Kennzahlen helfen dir bei Folgendem:

• Performance optimieren: Ausführungszeiten verfolgen, um Job-Effizienz und Ressourceneinsatz zu verbessern.
• Kosten steuern: Ressourcennutzung (DPUs, Worker) überwachen, Budget einhalten und Ausgaben optimieren.
• Kapazitäten planen: Ausführungsmetriken zur Bedarfsplanung und Skalierung nutzen.

Die erfolgreiche Ausführung hat jede CSV-Datei in die entsprechende Parquet-Datei umgewandelt und im Ordner “output” gespeichert, wie unten zu sehen:

• Links siehst du Ordner mit dem gleichen Namen wie die ursprünglichen CSV-Dateien.
• Rechts befinden sich die Parquet-Dateien zu den jeweiligen CSVs.

Inhalt des Ordners “output” im S3-Bucket. Bild: Autor

Fazit und nächste Schritte

Dieses Tutorial hat AWS Glue und seine Funktionen vorgestellt. Du hast gelernt, eine AWS-Umgebung einzurichten und die AWS-Glue-Oberfläche zu nutzen. Außerdem hast du einen Glue Crawler aufgebaut, um Daten zu katalogisieren, und einen Glue Job erstellt, um sie zu transformieren — inklusive der erfolgreichen Konvertierung von CSV nach Parquet.

Du kannst darauf aufbauen, indem du Trigger einrichtest, um Workflows zu automatisieren, Fehlerbehandlung und Logging implementierst und Parquet-Dateien weiter optimierst. Erkunde außerdem Abfragen deiner Daten mit AWS Athena oder Amazon Redshift Spectrum.

Achte außerdem auf deine AWS-Nutzung und -Kosten und räume Ressourcen auf, die du nicht mehr brauchst, um unnötige Ausgaben zu vermeiden.

Die Kurse Introduction to AWS und AWS Cloud Technology and Services sind ideale nächste Schritte für dein Lernen! 

Der erste Kurs vermittelt eine solide Grundlage in AWS und Cloud-Computing — perfekt für Einsteiger oder zum Auffrischen. Der zweite Kurs ist praxisorientiert und vertieft dein anwendungsnahes Verständnis der AWS-Services.