Un data lake, c’est simplement un endroit où l’on stocke des données brutes à bas coût, puis où on les transforme pour les rendre faciles à analyser. Sur AWS, quatre services suffisent pour en construire un : S3 pour le stockage, Glue pour la transformation et le catalogue, Athena pour interroger les données en SQL, et Step Functions pour enchaîner le tout automatiquement.
Dans ce deuxième tutoriel Epsilon Cloud, nous allons construire un mini data lake de bout en bout à partir d’un simple fichier CSV de ventes. Si vous débutez avec Terraform, commencez par le premier article : Terraform : déployer son premier bucket S3 en 10 minutes.
L’architecture en un coup d’œil
- Zone raw : le fichier CSV arrive tel quel dans S3 (
raw/ventes/). - Transformation : un job AWS Glue nettoie les données, calcule le montant des ventes et les écrit au format Parquet, partitionnées par année et par mois.
- Zone curated : les données propres sont stockées dans
curated/ventes/et déclarées dans le Glue Data Catalog. - Analyse : Athena interroge ces données en SQL, sans serveur à gérer.
- Orchestration : Step Functions lance le job Glue puis met à jour les partitions dans Athena, avec relance automatique en cas d’erreur.
Prérequis
- Un compte AWS et l’AWS CLI configurée (voir le premier article).
- Des droits suffisants pour créer des ressources S3, Glue, Athena, Step Functions et IAM.
- Une région unique pour tout le tutoriel, par exemple
eu-west-3(Paris).
Côté coût : Glue est facturé à la durée d’exécution des workers et Athena au volume de données scanné. Avec un petit fichier et deux workers, le coût de ce tutoriel reste très faible. Pensez tout de même à tout supprimer à la fin.
Étape 1 : créer le bucket et déposer les données brutes
Créez un fichier ventes.csv avec ce contenu :
date_vente,magasin,produit,quantite,prix_unitaire
2026-01-05,Paris,Clavier,3,49.90
2026-01-12,Lyon,Souris,5,19.90
2026-01-20,Paris,Ecran,2,189.00
2026-02-03,Lille,Clavier,1,49.90
2026-02-14,Lyon,Ecran,4,189.00
2026-02-21,Paris,Souris,8,19.90
Créez ensuite le bucket (le nom doit être unique au monde) et envoyez le fichier dans la zone raw :
export BUCKET=epsilon-mini-datalake-VOTRE-SUFFIXE
aws s3 mb s3://$BUCKET --region eu-west-3
aws s3 cp ventes.csv s3://$BUCKET/raw/ventes/ventes.csv
Cette séparation en zones (raw pour le brut, curated pour le propre) est la base de tout data lake : on ne modifie jamais la donnée source, on la transforme vers une autre zone.
Étape 2 : créer la base du catalogue Glue
Le Glue Data Catalog est le répertoire central de vos tables : Athena s’en sert pour savoir où se trouvent les données et quel est leur schéma.
aws glue create-database --database-input '{"Name": "mini_datalake"}'
Étape 3 : écrire le job de transformation Glue
Commencez par créer un rôle IAM pour Glue (par exemple GlueMiniDatalakeRole) avec la politique gérée AWSGlueServiceRole et un accès en lecture et écriture limité à votre bucket.
Dans la console AWS Glue, ouvrez ETL jobs, choisissez l’éditeur de script Spark et collez ce code PySpark :
import sys
from awsglue.utils import getResolvedOptions
from awsglue.context import GlueContext
from pyspark.context import SparkContext
from pyspark.sql import functions as F
args = getResolvedOptions(sys.argv, ["BUCKET"])
bucket = args["BUCKET"]
glue_context = GlueContext(SparkContext.getOrCreate())
spark = glue_context.spark_session
# 1. Lecture des données brutes
ventes = (
spark.read
.option("header", "true")
.option("inferSchema", "true")
.csv(f"s3://{bucket}/raw/ventes/")
)
# 2. Nettoyage et enrichissement
ventes = (
ventes
.dropna(subset=["date_vente", "produit"])
.withColumn("date_vente", F.to_date("date_vente"))
.withColumn("montant", F.round(F.col("quantite") * F.col("prix_unitaire"), 2))
.withColumn("annee", F.year("date_vente"))
.withColumn("mois", F.month("date_vente"))
)
# 3. Écriture en Parquet, partitionné par année et par mois
(
ventes.write
.mode("overwrite")
.partitionBy("annee", "mois")
.parquet(f"s3://{bucket}/curated/ventes/")
)
Dans l’onglet Job details :
- Nom du job :
mini-datalake-ventes - Rôle IAM :
GlueMiniDatalakeRole - Version de Glue : la plus récente proposée
- Type de worker :
G.1X, avec 2 workers (largement suffisant ici) - Paramètre du job : clé
--BUCKET, valeur le nom de votre bucket
Enregistrez puis cliquez sur Run. Au bout d’une à deux minutes, le dossier curated/ventes/ contient des sous-dossiers annee=2026/mois=1/ et annee=2026/mois=2/ remplis de fichiers Parquet.
Pourquoi Parquet et des partitions ? Parquet est un format en colonnes et compressé : Athena ne lit que les colonnes utiles. Les partitions lui permettent en plus d’ignorer les mois qui ne concernent pas votre requête. Résultat : des requêtes plus rapides et une facture plus légère.
Étape 4 : interroger les données avec Athena
Dans la console Athena, définissez d’abord l’emplacement des résultats de requêtes (paramètres du workgroup primary), par exemple s3://VOTRE-BUCKET/athena-results/. Puis créez la table :
CREATE EXTERNAL TABLE mini_datalake.ventes (
date_vente date,
magasin string,
produit string,
quantite int,
prix_unitaire double,
montant double
)
PARTITIONED BY (annee int, mois int)
STORED AS PARQUET
LOCATION 's3://VOTRE-BUCKET/curated/ventes/';
Chargez les partitions existantes, puis lancez votre première analyse :
MSCK REPAIR TABLE mini_datalake.ventes;
SELECT magasin,
SUM(montant) AS chiffre_affaires
FROM mini_datalake.ventes
WHERE annee = 2026
GROUP BY magasin
ORDER BY chiffre_affaires DESC;
Vous obtenez le chiffre d’affaires par magasin, calculé directement sur les fichiers S3, sans base de données ni serveur.
Étape 5 : orchestrer le pipeline avec Step Functions
Lancer le job à la main, puis rafraîchir les partitions, ce n’est pas industriel. Step Functions va enchaîner les deux étapes, attendre la fin de chacune et relancer le job en cas d’erreur passagère.
Dans la console Step Functions, créez une machine à états de type Standard, passez en mode code et collez cette définition :
{
"Comment": "Pipeline du mini data lake Epsilon Cloud",
"StartAt": "TransformerVentes",
"States": {
"TransformerVentes": {
"Type": "Task",
"Resource": "arn:aws:states:::glue:startJobRun.sync",
"Parameters": {
"JobName": "mini-datalake-ventes"
},
"Retry": [
{
"ErrorEquals": ["States.ALL"],
"IntervalSeconds": 60,
"MaxAttempts": 2,
"BackoffRate": 2
}
],
"Next": "MettreAJourPartitions"
},
"MettreAJourPartitions": {
"Type": "Task",
"Resource": "arn:aws:states:::athena:startQueryExecution.sync",
"Parameters": {
"QueryString": "MSCK REPAIR TABLE mini_datalake.ventes",
"WorkGroup": "primary",
"ResultConfiguration": {
"OutputLocation": "s3://VOTRE-BUCKET/athena-results/"
}
},
"End": true
}
}
}
Le suffixe .sync est essentiel : il demande à Step Functions d’attendre la fin du job Glue (ou de la requête Athena) avant de passer à l’étape suivante.
À la création, la console propose de générer un rôle IAM pour la machine à états. Vérifiez qu’il autorise bien le lancement et le suivi du job Glue, l’exécution de requêtes Athena, la lecture du catalogue Glue et l’écriture dans le dossier athena-results/ du bucket.
Cliquez sur Start execution : le graphe s’affiche en direct, chaque étape passe au vert, et en cas d’échec vous voyez immédiatement laquelle et pourquoi.
Étape 6 : automatiser l’exécution
Pour que le pipeline tourne tout seul, deux options classiques :
- Planifié : une planification Amazon EventBridge Scheduler qui démarre la machine à états chaque nuit, par exemple.
- Événementiel : une règle EventBridge déclenchée à chaque dépôt de fichier dans
raw/ventes/(en activant l’envoi des notifications S3 vers EventBridge sur le bucket).
Étape 7 : tout nettoyer
Pour éviter toute facturation résiduelle, supprimez dans l’ordre : la machine à états Step Functions, le job Glue, la table puis la base mini_datalake, et enfin le bucket :
aws s3 rm s3://$BUCKET --recursive
aws s3 rb s3://$BUCKET
Les bonnes pratiques à retenir
- Ne jamais modifier la zone raw : elle permet de rejouer n’importe quelle transformation.
- Parquet et partitions pour réduire le volume scanné par Athena, donc le coût.
- Des rôles IAM au plus juste : chaque service n’accède qu’à ce dont il a besoin.
- Tout décrire en Terraform une fois le prototype validé, pour pouvoir recréer le data lake à l’identique.
- Gouvernance avec Lake Formation dès que plusieurs équipes accèdent aux données.
- Apache Iceberg quand il faut gérer des mises à jour et des suppressions (CDC) plutôt que de réécrire des partitions entières.
Et ensuite ?
Ce mini data lake reprend, en version simplifiée, l’architecture des plateformes de données que l’on retrouve en entreprise : zones S3, transformations Glue, catalogue, requêtes Athena et orchestration. Dans un prochain article, nous verrons comment le déployer entièrement avec Terraform et l’industrialiser dans un pipeline CI/CD.
Une question, un blocage ou un retour d’expérience ? Écrivez-moi depuis la page Contact.
