Data & Big Data

AWS Data Engineering Bootcamp expliqué simplement (avec schémas et vrai code)

AWS Data Engineering Bootcamp : l'essentiel en un article — vrai code, schémas et étapes concrètes, extraits d'un cours de 17 leçons.

REHOUMA Haythem

• 14 min read
AWS Data Engineering Bootcamp expliqué simplement (avec schémas et vrai code)

Un guide qui va droit au but : AWS Data Engineering Bootcamp décortiqué avec des schémas, des exemples concrets et des commandes testées. Tout vient d'un cours structuré de 5 chapitres — en voici le meilleur.

tl;dr
  • Introduction a l'Ingenierie des Donnees AWS
  • Partitionnement et Bucketisation
  • Athena et Glue en Action
  • Cardinalite et Optimisation Avancee
  • Laboratoire guide Athena
~$ cat ./parcours.md # AWS Data Engineering Bootcamp — 5 chapitres
01
Introduction à l'Ingénierie des Données AWS
→ Chapitre 00 – Leçon 1 : Concepts Clés en Ingénierie des Données→ Chapitre 00 – Leçon 2 : Data Warehouses et leurs Équivalences Cloud+ 1 autres leçons
02
Partitionnement et Bucketisation
→ Chapitre 01 – Leçon 1 : Partitionnement et Buckétisation dans un Data Lake→ Chapitre 01 – Leçon 2 : La Buckétisation dans les Data Warehouses+ 1 autres leçons
03
Athena et Glue en Action
→ Chapitre 02 – Leçon 1 : Amazon Athena — Concepts Clés et Architecture→ Chapitre 02 – Leçon 2 : Configurer Athena et Créer une Base de Données Glue+ 2 autres leçons
04
Cardinalité et Optimisation Avancée
→ Chapitre 03 – Leçon 1 : Vues SQL, Requêtes Nommées et AWS CloudFormation→ Chapitre 03 – Leçon 2 : Permissions IAM pour Athena et Glue — Bonnes Pratiques+ 2 autres leçons
05
Laboratoire guide Athena
→ Chapitre 04 (OPTIONNEL) – Lab 1 : Créer une Base de Données et une Table AWS Glue dans Athena→ Chapitre 04 (OPTIONNEL) – Lab 2 : Bucketing, Partitionnement et Format Parquet+ 1 autres leçons
🏁
Projet final
→ Tu repars avec un projet concret et démontrable

Chapitre 02 – Leçon 3 : Optimisation par Bucketing et Partitionnement dans Athena

NOTEObjectif — Appliquer le bucketing et le partitionnement sur des données réelles dans Athena et mesurer l'amélioration des performances et la réduction des coûts.

Optimisation par Bucketing dans Athena

Pourquoi le Bucketing ?

Le bucketing répartit les données dans plusieurs fichiers selon une clé de hachage. Il améliore considérablement les performances quand vous travaillez sur des colonnes à haute cardinalité.

Réduire le scan

Athena cible uniquement les buckets nécessaires lors d'une requête.

Améliorer les jointures

Quand deux tables sont buckétisées sur la même clé, Athena fait des "bucket joins" très rapides.

Haute cardinalité

Idéal pour user_id, transaction_id, device_id.

Exemple Pratique : Transactions E-Commerce Buckétisées

output
-- Étape 1 : Configurer le bucketing lors de la création de la table
-- Remplacez user_id par votre colonne à haute cardinalité
CLUSTERED BY (user_id) INTO 8 BUCKETS

-- Exemple complet avec CTAS (Create Table As Select)
CREATE TABLE taxidata.transactions_bucketized
WITH (
    format = 'PARQUET',
    external_location = 's3://mon-bucket/transactions-bucketized/',
    bucketed_by = ARRAY['user_id'],
    bucket_count = 8
) AS
SELECT *
FROM taxidata.transactions_source;
TIPVérification dans S3 — Après la création, vous devriez voir 8 fichiers dans S3 : 
s3://mon-bucket/transactions-bucketized/
├── 000000_0.parquet
├── 000001_0.parquet
├── ...
└── 000007_0.parquet

Étapes pour Configurer le Bucketing

Optimisation par Partitionnement dans Athena

Structure des Partitions dans S3

Le partitionnement organise les données en répertoires distincts dans S3 selon les valeurs d'une colonne à faible cardinalité :

bash
# Structure des partitions dans S3 (format Hive)
s3://taxi-datalake/yellow/
├── year=2015/month=01/
│   └── data.parquet
├── year=2015/month=02/
│   └── data.parquet
├── year=2016/month=01/
│   └── data.parquet
└── year=2017/month=01/
    └── data.parquet

Créer une Table Partitionnée via CTAS

output
-- CTAS (Create Table As Select) avec partitionnement
-- Conversion CSV → Parquet AVEC partitionnement
CREATE TABLE taxidata.yellow_partitioned
WITH (
    format = 'PARQUET',
    external_location = 's3://taxi-datalake/yellow-partitioned/',
    partitioned_by = ARRAY['year', 'month']
) AS
SELECT
    vendor, pickup, dropoff, count,
    distance, ratecode, storeflag, pulocid, dolocid,
    paytype, fare, extra, mta_tax, tip, tolls, surcharge, total,
    YEAR(pickup) AS year,
    MONTH(pickup) AS month
FROM taxidata.yellow;
NOTEImportant — Les colonnes de partition (year, month) doivent être listées en dernier dans le SELECT et dans le tableau partitioned_by.

Découvrir les Partitions

output
-- Après avoir ajouté des données, découvrir les nouvelles partitions
MSCK REPAIR TABLE taxidata.yellow_partitioned;

-- Ajouter manuellement une partition spécifique
ALTER TABLE taxidata.yellow_partitioned
ADD PARTITION (year='2017', month='02')
LOCATION 's3://taxi-datalake/yellow-partitioned/year=2017/month=02/';

Requêtes Optimisées avec le Partitionnement

output
-- Requête SANS partitionnement : scan de TOUTE la table
SELECT COUNT(*), SUM(fare) AS total_fares
FROM taxidata.yellow
WHERE YEAR(pickup) = 2017 AND MONTH(pickup) = 1;
-- → Scan : 100% des données (ex: 1 TB)

-- Requête AVEC partitionnement : scan seulement de la partition concernée
SELECT COUNT(*), SUM(fare) AS total_fares
FROM taxidata.yellow_partitioned
WHERE year = 2017 AND month = 1;
-- → Scan : ~1/36 des données (si 3 ans × 12 mois)
-- → Réduction de ~97% des données scannées !

Combinaison Optimale : Partitionnement + Bucketing

Chapitre 02 – Leçon 2 : Configurer Athena et Créer une Base de Données Glue

NOTEObjectif — Configurer l'environnement Athena, créer une base de données AWS Glue, définir une table externe sur des données S3 et exécuter les premières requêtes SQL.

Étape 1 — Configurer l'Environnement Athena

WARNINGPrérequis obligatoire — Avant toute requête Athena, configurez le bucket S3 pour les résultats. Sans cela, Athena refusera d'exécuter vos requêtes.
bash
# Alternative : configurer via AWS CLI
aws athena update-work-group \
  --work-group primary \
  --configuration-updates "ResultConfigurationUpdates={OutputLocation=s3://mon-bucket-athena-results/}"

Étape 2 — Créer une Base de Données Glue

Dans l'éditeur Athena, exécutez :

output
-- Créer la base de données taxidata dans AWS Glue Data Catalog
CREATE DATABASE taxidata;
TIPRésultat — Cette commande crée une base de données taxidata dans AWS Glue Data Catalog. Vous pouvez la voir dans la console Glue sous "Databases".
bash
# Vérifier la création via AWS CLI
aws glue get-database --name taxidata

# Lister toutes les bases de données
aws glue get-databases

Étape 3 — Définir le Schéma de la Table (Dataset Taxis NYC)

Créons la table externe yellow sur les données de taxis de New York stockées dans S3 :

output
-- Créer la table externe yellow sur les données S3
CREATE EXTERNAL TABLE IF NOT EXISTS taxidata.yellow (
   `vendor`    string,
   `pickup`    timestamp,
   `dropoff`   timestamp,
   `count`     int,
   `distance`  int,
   `ratecode`  string,
   `storeflag` string,
   `pulocid`   string,
   `dolocid`   string,
   `paytype`   string,
   `fare`      decimal,
   `extra`     decimal,
   `mta_tax`   decimal,
   `tip`       decimal,
   `tolls`     decimal,
   `surcharge` decimal,
   `total`     decimal
)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe'
WITH SERDEPROPERTIES (
   'serialization.format' = ',',
   'field.delim' = ','
) LOCATION 's3://aws-tc-largeobjects/CUR-TF-200-ACDSCI-1/Lab2/yellow/'
TBLPROPERTIES ('has_encrypted_data'='false');
NOTEExplication des paramètres clés :
  • CREATE EXTERNAL TABLE — la table pointe vers S3, Athena ne copie pas les données
  • LazySimpleSerDe — sérialiseur/désérialiseur pour les fichiers CSV délimités
  • field.delim = ',' — les champs sont séparés par des virgules
  • LOCATION — chemin S3 contenant les fichiers de données
  • has_encrypted_data='false' — les données ne sont pas chiffrées

Étape 4 — Prévisualiser les Données

output
-- Prévisualiser les 10 premières lignes
SELECT * FROM taxidata.yellow LIMIT 10;

-- Compter le nombre total de trajets
SELECT COUNT(*) AS total_trajets FROM taxidata.yellow;

-- Vérifier les types de paiement disponibles
SELECT DISTINCT paytype, COUNT(*) AS nb_trajets
FROM taxidata.yellow
GROUP BY paytype
ORDER BY nb_trajets DESC;

Étape 5 — Créer une Table Optimisée (Janvier 2017)

output
-- Créer une table pour les données de janvier 2017 uniquement
-- Plus rapide pour les tests et la validation
CREATE EXTERNAL TABLE IF NOT EXISTS taxidata.jan (
   `vendor`    string,
   `pickup`    timestamp,
   `dropoff`   timestamp,
   `count`     int,
   `distance`  int,
   `ratecode`  string,
   `storeflag` string,
   `pulocid`   string,
   `dolocid`   string,
   `paytype`   string,
   `fare`      decimal,
   `extra`     decimal,
   `mta_tax`   decimal,
   `tip`       decimal,
   `tolls`     decimal,
   `surcharge` decimal,
   `total`     decimal
)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe'
WITH SERDEPROPERTIES (
   'serialization.format' = ',',
   'field.delim' = ','
) LOCATION 's3://aws-tc-largeobjects/CUR-TF-200-ACDSCI-1/Lab2/January2017/'
TBLPROPERTIES ('has_encrypted_data'='false');

Chapitre 03 – Leçon 1 : Vues SQL, Requêtes Nommées et AWS CloudFormation

NOTEObjectif — Créer des vues SQL dans Athena pour simplifier les analyses, définir des requêtes nommées réutilisables, et automatiser leur déploiement avec AWS CloudFormation.

Les Vues SQL dans Athena

Une vue SQL est une requête sauvegardée que vous pouvez utiliser comme une table. Elle n'stocke pas de données — elle exécute la requête sous-jacente à chaque appel.

TIPAvantage des vues — Simplifiez les requêtes complexes, créez des couches d'abstraction et partagez des analyses standardisées avec votre équipe.

Exemple 1 : Vue des Trajets par Carte de Crédit

output
-- Créer une vue pour les paiements par carte de crédit
-- paytype = '1' signifie paiement par carte
CREATE VIEW taxidata.cctrips AS
SELECT
    vendor,
    SUM(fare)  AS total_fares_cc,
    COUNT(*)   AS nb_trajets_cc,
    AVG(fare)  AS tarif_moyen_cc
FROM taxidata.yellow
WHERE paytype = '1'
GROUP BY vendor;

-- Utiliser la vue
SELECT * FROM taxidata.cctrips;

Exemple 2 : Vue des Trajets en Espèces

output
-- Créer une vue pour les paiements en espèces
-- paytype = '2' signifie paiement en espèces
CREATE VIEW taxidata.cashtrips AS
SELECT
    vendor,
    SUM(fare)  AS total_fares_cash,
    COUNT(*)   AS nb_trajets_cash,
    AVG(fare)  AS tarif_moyen_cash
FROM taxidata.yellow
WHERE paytype = '2'
GROUP BY vendor;

-- Utiliser la vue
SELECT * FROM taxidata.cashtrips;

Exemple 3 : Vue de Comparaison avec CTE (WITH)

output
-- Vue de comparaison combinant carte de crédit et espèces
-- Utilisation de CTE (Common Table Expressions) avec WITH
CREATE VIEW taxidata.comparepay AS
WITH
    cc AS (
        SELECT
            vendor,
            SUM(fare) AS cctotal,
            COUNT(*)  AS nb_cc
        FROM taxidata.yellow
        WHERE paytype = '1'
        GROUP BY vendor
    ),
    cash AS (
        SELECT
            vendor,
            SUM(fare) AS cashtotal,
            COUNT(*)  AS nb_cash
        FROM taxidata.yellow
        WHERE paytype = '2'
        GROUP BY vendor
    )
SELECT
    cc.vendor,
    cc.cctotal,
    cc.nb_cc,
    cash.cashtotal,
    cash.nb_cash,
    ROUND(cc.cctotal / cash.cashtotal, 2) AS ratio_cc_cash
FROM cc
JOIN cash ON cc.vendor = cash.vendor;

-- Requête sur la vue
SELECT * FROM taxidata.comparepay ORDER BY ratio_cc_cash DESC;

Gestion des Vues

output
-- Lister les vues disponibles
SHOW VIEWS IN taxidata;

-- Voir la définition d'une vue
SHOW CREATE VIEW taxidata.comparepay;

-- Remplacer une vue existante
CREATE OR REPLACE VIEW taxidata.cctrips AS
SELECT
    vendor,
    SUM(fare) AS total_fares_cc,
    COUNT(*) AS nb_trajets_cc
FROM taxidata.yellow
WHERE paytype = '1'
GROUP BY vendor;

-- Supprimer une vue
DROP VIEW taxidata.cashtrips;

Les Requêtes Nommées dans Athena

Les requêtes nommées (Named Queries) permettent de sauvegarder des requêtes SQL fréquemment utilisées directement dans Athena. Elles sont partagées au sein de votre compte AWS.

Avantages

Limitation

Automatiser avec AWS CloudFormation

Plutôt que de créer manuellement les requêtes nommées via la console, vous pouvez les déployer comme du code avec AWS CloudFormation.

Template CloudFormation pour une Requête Nommée

Créez un fichier nommé athenaquery.cf.yml :

output
AWSTemplateFormatVersion: 2010-09-09
Description: "Requête Athena nommée pour l'analyse des taxis NYC"

Resources:
  AthenaNamedQuery:
    Type: AWS::Athena::NamedQuery
    Properties:
      Database: "taxidata"
      Description: "Sélection des trajets dont le montant dépasse 100 $"
      Name: "FaresOver100DollarsUS"
      QueryString: >
        SELECT
            distance,
            paytype,
            fare,
            tip,
            tolls,
            surcharge,
            total
        FROM yellow
        WHERE total >= 100.0
        ORDER BY total DESC

Outputs:
  AthenaNamedQuery:
    Description: "L'ID de la requête nommée Athena créée"
    Value: !Ref AthenaNamedQuery

Déployer le Template CloudFormation via AWS CLI

bash
# Étape 1 : Valider le template avant déploiement
aws cloudformation validate-template \
    --template-body file://athenaquery.cf.yml

# Étape 2 : Créer la stack CloudFormation
aws cloudformation create-stack \
    --stack-name mon-athena-stack \
    --template-body file://athenaquery.cf.yml \
    --capabilities CAPABILITY_IAM

# Étape 3 : Vérifier l'état de la création
aws cloudformation describe-stacks \
    --stack-name mon-athena-stack \
    --query 'Stacks[0].StackStatus'

# Étape 4 : Lister les requêtes nommées créées
aws athena list-named-queries \
    --work-group primary

# Étape 5 : Récupérer les détails d'une requête nommée
aws athena get-named-query \
    --named-query-id "ID_RETOURNÉ_PAR_LIST"
va-plus-loin

Cet article couvre les extraits les plus utiles — le cours complet AWS Data Engineering Bootcamp (5 chapitres, 17 leçons, exercices corrigés et projet final) t'emmène jusqu'au bout.

./acceder-au-cours-complet cours gratuit : Maîtriser Claude Code

FAQ

Combien de temps pour apprendre AWS Data Engineering Bootcamp ?
Avec une progression structurée (5 chapitres, 17 leçons courtes et pratiques), on atteint un niveau opérationnel en quelques semaines à raison de 30 à 60 minutes par jour. L'important est de pratiquer chaque notion immédiatement.
Faut-il des prérequis ?
Des bases en informatique suffisent. Si tu sais utiliser un terminal et lire du code simple, tu es prêt.
Par où commencer concrètement ?
Reproduis les commandes de cet article, puis suis le cours complet AWS Data Engineering Bootcamp : il enchaîne les 17 leçons dans l'ordre, avec exercices et projet final.
./a-lire-aussi
→ Lance-toi en AWS Données Temps Réel : ton premier pas concret aujourd'hui→ Python Data Science : les 9 étapes clés pour passer de zéro à opérationnel→ Python NumPy en pratique : le code et les commandes qui comptent vraiment

📬 Tu veux recevoir ce type de guide chaque semaine ? Abonne-toi gratuitement — code réel, zéro blabla.

Stay up to date

Enter your email
Subscribe