Skip to content
Learni
Voir tous les tutoriels
AWS

Comment créer votre premier job AWS Glue en 2026

12 minBEGINNER
PySparkData EngineeringAWS GlueETLS3
Read in English

Introduction

AWS Glue est un service ETL serverless d'Amazon Web Services qui automatise la découverte, catalogage et transformation des données. Contrairement aux outils traditionnels comme Talend ou Informatica, Glue s'intègre nativement à S3, Athena et Redshift sans gérer d'infrastructures.

Pourquoi l'utiliser en 2026 ? Les pipelines data explosent avec l'IA et le big data : Glue génère du code PySpark/Scala à partir de votre catalog, réduit les coûts (paiement à l'usage) et scale automatiquement. Imaginez transformer 1 To de CSV en Parquet optimisé en minutes, sans cluster EMR.

Ce tutoriel beginner vous guide pour : créer un bucket S3, crawler des données CSV, générer un catalog et lancer un job ETL qui lit/transforme/écrit. À la fin, vous aurez un pipeline fonctionnel, bookmarkable pour tout data engineer junior. Temps estimé : 30 minutes. (132 mots)

Prérequis

  • Compte AWS gratuit (tier free éligible pour Glue basics).
  • AWS CLI v2 installé (télécharger).
  • Python 3.9+ pour tester localement (optionnel).
  • Région AWS : us-east-1 (par défaut, changez si besoin).
  • Permissions IAM : AWSGlueServiceRole ou custom policy avec glue:, s3:, iam:PassRole.

Installer et configurer AWS CLI

terminal
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install

aws configure
# Entrez : AWS Access Key ID, Secret Access Key, région us-east-1, output json

echo '{"Version": "2012-10-17","Statement": [{"Effect": "Allow","Principal": {"Service": "glue.amazonaws.com"},"Action": "sts:AssumeRole"}]}' > glue-role-trust-policy.json
aws iam create-role --role-name GlueBeginnerRole --assume-role-policy-document file://glue-role-trust-policy.json
aws iam attach-role-policy --role-name GlueBeginnerRole --policy-arn arn:aws:iam::aws:policy/service-role/AWSGlueServiceRole
aws iam attach-role-policy --role-name GlueBeginnerRole --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess

Ce script installe AWS CLI v2, configure vos credentials et crée un rôle IAM pour Glue avec politiques S3/Glue. Remplacez les keys par les vôtres lors de aws configure. Piège : sans iam:PassRole, les jobs échouent au lancement.

Préparer les données sources S3

Créez un bucket S3 pour simuler des données brutes. Nous uploaderons un CSV sample avec ventes : id,nom,prix. Glue crawlera ce bucket pour inférer le schéma (types, partitions).

Créer bucket S3 et données CSV

terminal
BUCKET_NAME=glue-tutorial-$(date +%s)
aws s3 mb s3://${BUCKET_NAME}/raw/

cat > ventes.csv << EOF
id,nom,prix,region
1,ProduitA,29.99,US
2,ProduitB,49.99,EU
3,ProduitC,19.99,ASIA
4,ProduitA,29.99,US
EOF
aws s3 cp ventes.csv s3://${BUCKET_NAME}/raw/
aws s3 ls s3://${BUCKET_NAME}/raw/

Génère un bucket unique, crée un CSV sample et l'upload. Utilisez $BUCKET_NAME partout ensuite. Analogie : comme un dossier Dropbox pour données brutes. Piège : noms de buckets globaux uniques, d'où le timestamp.

Créer la base de données Glue

terminal
aws glue create-database --database-input '{"Name": "tutorial_db"}' --region us-east-1
aws glue get-database --name tutorial_db --region us-east-1

Crée un Data Catalog logique pour stocker métadonnées. C'est comme un 'registre' des tables inférées. Vérifiez avec get-database. Sans ça, crawlers ne stockent pas les schémas.

Découvrir les données avec un Crawler

Les crawlers scannent S3, infèrent schémas (string/int/date) et partitions, populent le catalog. Pour beginner : un crawler = job serverless qui génère une 'table' virtuelle.

Créer et lancer le Crawler

terminal
cat > crawler-config.json << EOF
{"Name": "tutorial-crawler","Role": "GlueBeginnerRole","DatabaseName": "tutorial_db","Targets": {"S3Targets": [{"Path": "s3://${BUCKET_NAME}/raw/"}]},"SchemaChangePolicy": {"UpdateBehavior": "UPDATE_IN_DATABASE","DeleteBehavior": "DEPRECATE_IN_DATABASE"}}
EOF
aws glue create-crawler --cli-input-json file://crawler-config.json
aws glue start-crawler --name tutorial-crawler
aws glue get-crawler --name tutorial-crawler
# Attendre 1-2 min, puis :
aws glue get-table --database-name tutorial_db --name ventes

Définit un crawler JSON qui scanne S3/raw/, crée table 'ventes' dans catalog. start-crawler lance (payant ~0.44$/DPU-hour). Vérifiez table générée. Piège : rôle IAM manquant bloque le scan.

Écrire le script ETL PySpark

Cœur du tutoriel : Le job Glue utilise PySpark avec glueContext. On lit la table cataloguée, filtre region='US', agrège prix moyen, écrit Parquet partitionné.

Script complet du job Glue

glue_job.py
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)

# Lire datasource cataloguée
ds = glueContext.create_dynamic_frame.from_catalog(database="tutorial_db", table_name="ventes")

df = ds.toDF()

# Transformer : filtre US, agrège prix moyen par nom
us_df = df.filter(df.region == "US")
agg_df = us_df.groupBy("nom").avg("prix").withColumnRenamed("avg(prix)", "prix_moyen")

# Écrire Parquet partitionné
glueContext.write_dynamic_frame.from_options(
    frame=DynamicFrame.fromDF(agg_df, glueContext, "agg_df"),
    connection_type="s3",
    connection_options={"path": f"s3://{BUCKET_NAME}/processed/", "partitionKeys": []},
    format="parquet"
)

job.commit()

Script PySpark complet : lit catalog, transforme (filtre/agrège), écrit Parquet optimisé. create_dynamic_frame utilise métadonnées inférées. Copiez-collez dans Glue console. Piège : oubliez job.commit() ou le job ne termine pas.

Créer et lancer le Job Glue

terminal
aws glue create-job --job-name tutorial-job --role GlueBeginnerRole --command '{"Name": "glueetl","ScriptLocation": "s3://${BUCKET_NAME}/scripts/glue_job.py","PythonVersion": "3"}' --default-arguments '{"--TempDir": "s3://${BUCKET_NAME}/temp/"}' --max-capacity 2.0 --timeout 10 --max-retries 0

# D'abord upload script :
aws s3 cp glue_job.py s3://${BUCKET_NAME}/scripts/

aws glue start-job-run --job-name tutorial-job
aws glue get-job-run --job-name tutorial-job --run-id $(aws glue get-job-runs --job-name tutorial-job --query 'JobRuns[0].Id' --output text)

# Vérifier sortie :
aws s3 ls s3://${BUCKET_NAME}/processed/

Crée job avec script S3, lance run (2 DPU, ~1$/run). get-job-run track status (SUCCEEDED). Vérifiez Parquet généré. Piège : --TempDir obligatoire pour scripts >512KB ou dépendances.

Vérification et query avec Athena

Connectez Athena au catalog tutorial_db. Query : SELECT * FROM tutorial_db.ventes LIMIT 10; pour valider. Output Parquet : columnar, 10x plus rapide que CSV.

Bonnes pratiques

  • Utilisez DynamicFrames : gèrent schémas évolutifs mieux que DataFrames.
  • Partitions S3 : Ajoutez partitionKeys=["region"] pour scans rapides (ex: WHERE region='US').
  • DPU scaling : Commencez à 2 DPU, monitorisez CloudWatch pour coûts.
  • Versioning scripts : Stockez en S3 avec tags, pas hardcoded.
  • Security : Least privilege IAM, encrypt S3 avec KMS.

Erreurs courantes à éviter

  • Crawler échoue : Vérifiez rôle IAM a s3:GetObject sur bucket.
  • Job timeout : Augmentez --max-capacity ou timeout pour gros data.
  • Schéma drift : Activez SchemaChangePolicy: LOG pour alerter sans casser.
  • Coûts cachés : Crawlers facturés/DPU-hour ; testez sur small data.

Pour aller plus loin