Une plateforme de commerce en ligne collecte quotidiennement :
Les données sont actuellement stockées sur une seule machine. Cette architecture pose plusieurs problèmes :
Votre mission consiste à mettre en place une petite plateforme Hadoop permettant de :
1. stocker les données dans HDFS ; 2. observer leur distribution dans le cluster ; 3. vérifier la réplication et la tolérance aux pannes ; 4. comprendre le rôle de YARN ; 5. exécuter un traitement distribué.
À la fin du TD, vous devez être capables de :
+-----------------+
| ResourceManager |
| YARN |
+--------+--------+
|
+-------------------+-------------------+
| | |
+------v------+ +-------v-----+ +--------v------+
| NodeManager | | NodeManager | | NodeManager |
| DataNode 1 | | DataNode 2 | | DataNode 3 |
+--------------+ +-------------+ +---------------+
^ ^ ^
+-------------------+-------------------+
|
+--------v--------+
| NameNode |
| Métadonnées HDFS|
+-----------------+
| Composant | Rôle |
|---|---|
| NameNode | Gère les métadonnées HDFS |
| DataNode | Stocke les blocs de données |
| ResourceManager | Gère les ressources YARN |
| NodeManager | Gère les ressources d’un nœud |
| HDFS | Stocke les données |
| YARN | Attribue les ressources aux applications |
| MapReduce | Modèle de traitement distribué |
Installer :
Vérifier l’installation :
docker --version docker compose version git --version
Une dizaine de gigaoctets d’espace disque libre est recommandée.
Nous utilisons une image Docker Hadoop préconfigurée pour un environnement pédagogique.
git clone https://github.com/big-data-europe/docker-hadoop.git cd docker-hadoop
Démarrer l’environnement :
docker compose up -d
Vérifier l’état des conteneurs :
docker compose ps
Vous devez retrouver notamment des services proches de :
namenode datanode resourcemanager nodemanager historyserver
| Service | Adresse |
|---|---|
| NameNode | http://localhost:9870 |
| ResourceManager | http://localhost:8088 |
| NodeManager | http://localhost:8042 |
Pour ouvrir un terminal dans le NameNode :
docker compose exec namenode bash
Pour ouvrir un terminal dans le ResourceManager :
docker compose exec resourcemanager bash
Les commandes Hadoop sont exécutées dans le conteneur namenode, sauf indication contraire.
On considère l’architecture suivante :
Serveur unique | +-- ventes_j1.csv +-- ventes_j2.csv +-- clics_j1.csv +-- application.log
Répondre aux questions suivantes :
Conserver vos réponses dans un fichier reponses.md.
Sur votre machine hôte, créer un fichier generer_donnees.py :
import csv
import random
from datetime import date, timedelta
categories = ["informatique", "maison", "sport", "livres"]
villes = ["Paris", "Lyon", "Lille", "Nantes", "Bordeaux"]
with open("ventes.csv", "w", newline="") as fichier:
writer = csv.writer(fichier)
writer.writerow([
"date",
"commande_id",
"client_id",
"categorie",
"ville",
"montant"
])
date_depart = date(2026, 1, 1)
for i in range(200000):
jour = date_depart + timedelta(days=random.randint(0, 30))
commande_id = f"C{i:07d}"
client_id = f"CL{random.randint(1, 50000):05d}"
categorie = random.choice(categories)
ville = random.choice(villes)
montant = round(random.uniform(5, 500), 2)
writer.writerow([
jour,
commande_id,
client_id,
categorie,
ville,
montant
])
Exécuter :
python generer_donnees.py
Observer la taille du fichier :
ls -lh ventes.csv wc -l ventes.csv head ventes.csv
Répondre :
Dans le conteneur namenode :
hdfs dfs -mkdir -p /data/ecommerce/raw/ventes hdfs dfs -mkdir -p /data/ecommerce/raw/logs hdfs dfs -mkdir -p /data/ecommerce/processed
Depuis la machine hôte, copier le fichier dans le conteneur :
docker cp ventes.csv docker-hadoop-namenode-1:/tmp/ventes.csv
Le nom exact du conteneur peut être vérifié avec :
docker ps
Dans le conteneur namenode :
hdfs dfs -put /tmp/ventes.csv /data/ecommerce/raw/ventes/
Vérifier la présence du fichier :
hdfs dfs -ls -h /data/ecommerce/raw/ventes
Afficher quelques lignes :
hdfs dfs -cat /data/ecommerce/raw/ventes/ventes.csv | head
Répondre :
hdfs dfs -put ressemble-t-elle à une copie classique ?Exécuter :
hdfs fsck /data/ecommerce/raw/ventes/ventes.csv \ -files \ -blocks \ -locations
Relever :
| Élément | Valeur |
|---|---|
| Taille du fichier | |
| Nombre de blocs | |
| Facteur de réplication | |
| DataNodes utilisés | |
| Taille du bloc |
Répondre :
Dans un environnement réel, les blocs HDFS ont généralement une taille importante. Pour observer plus facilement le découpage, vous pouvez utiliser un fichier plus volumineux ou modifier la configuration du cluster avant son démarrage.
Dans hadoop.env, repérer ou ajouter :
HDFS_CONF_dfs_blocksize=1048576 HDFS_CONF_dfs_replication=2
Cette configuration correspond à :
Reconstruire l’environnement :
docker compose down -v docker compose up -d
Cette étape supprime les volumes Docker associés au cluster.
Recréer les répertoires HDFS et importer à nouveau le fichier.
Relancer :
hdfs fsck /data/ecommerce/raw/ventes/ventes.csv \ -files \ -blocks \ -locations
Dessiner un schéma représentant la répartition des blocs.
Exemple :
ventes.csv | +-- Bloc 0 -> DataNode 1, DataNode 2 +-- Bloc 1 -> DataNode 2, DataNode 3 +-- Bloc 2 -> DataNode 1, DataNode 3
Vérifier le facteur de réplication :
hdfs fsck /data/ecommerce/raw/ventes/ventes.csv \ -files \ -blocks \ -locations
Modifier la réplication du fichier :
hdfs dfs -setrep -w 3 \ /data/ecommerce/raw/ventes/ventes.csv
Vérifier le résultat :
hdfs fsck /data/ecommerce/raw/ventes/ventes.csv \ -files \ -blocks \ -locations
Répondre :
Dans le conteneur namenode :
hdfs dfsadmin -report
Relever :
Depuis la machine hôte :
docker compose ps
Identifier le conteneur correspondant à un DataNode.
Arrêter un DataNode :
docker compose stop datanode
Si plusieurs DataNodes portent un suffixe :
docker compose stop datanode1
ou :
docker compose stop datanode2
Vérifier l’état :
docker compose ps
Puis :
hdfs dfsadmin -report
Examiner le fichier :
hdfs fsck /data/ecommerce/raw/ventes/ventes.csv \ -files \ -blocks \ -locations
Lire le fichier :
hdfs dfs -cat /data/ecommerce/raw/ventes/ventes.csv | head
Répondre :
Redémarrer le DataNode :
docker compose start datanode
Puis vérifier :
hdfs dfsadmin -report
Deux équipes souhaitent lancer simultanément :
Répondre :
Dans le conteneur resourcemanager :
yarn node -list
Afficher les applications :
yarn application -list
Afficher les informations du cluster :
yarn cluster
Consulter l’interface :
http://localhost:8088
Identifier :
Compléter :
| Composant | Fonction observée |
|---|---|
| ResourceManager | |
| NodeManager | |
| ApplicationMaster | |
| Conteneur YARN |
Rechercher les exemples MapReduce :
find / -name "hadoop-mapreduce-examples*.jar" 2>/dev/null
Créer un petit fichier texte dans HDFS :
hdfs dfs -mkdir -p /data/ecommerce/test hdfs dfs -put /etc/hosts /data/ecommerce/test/
Lancer wordcount :
hadoop jar \ /usr/local/hadoop/share/hadoop/mapreduce/hadoop-mapreduce-examples-*.jar \ wordcount \ /data/ecommerce/test \ /data/ecommerce/processed/wordcount
Si le répertoire existe déjà :
hdfs dfs -rm -r /data/ecommerce/processed/wordcount
Afficher le résultat :
hdfs dfs -cat /data/ecommerce/processed/wordcount/part-r-00000
Pendant l’exécution, consulter :
yarn application -list
Puis :
yarn application -list -appStates ALL
Répondre :
Le code suivant correspond à un traitement Spark :
df = spark.read \
.option("header", True) \
.option("inferSchema", True) \
.csv("hdfs:///data/ecommerce/raw/ventes/ventes.csv")
df.printSchema()
df.show(5)
Comparer avec :
spark.read.csv("ventes.csv")
Répondre :
Créer analyse_ventes.py :
from pyspark.sql import SparkSession
from pyspark.sql.functions import sum, count, avg
spark = (
SparkSession.builder
.appName("AnalyseVentes")
.getOrCreate()
)
df = (
spark.read
.option("header", True)
.option("inferSchema", True)
.csv("hdfs:///data/ecommerce/raw/ventes/ventes.csv")
)
df.printSchema()
resultat = (
df.groupBy("categorie")
.agg(
count("commande_id").alias("nombre_commandes"),
sum("montant").alias("chiffre_affaires"),
avg("montant").alias("panier_moyen")
)
)
resultat.show()
resultat.write.mode("overwrite").parquet(
"hdfs:///data/ecommerce/processed/ca_par_categorie"
)
spark.stop()
Selon l’environnement Spark disponible :
spark-submit \ --master yarn \ --deploy-mode cluster \ --num-executors 2 \ --executor-memory 1G \ analyse_ventes.py
Observer l’application :
yarn application -list
Vérifier le résultat :
hdfs dfs -ls /data/ecommerce/processed/ca_par_categorie
Les fichiers Parquet doivent être relus avec Spark plutôt qu’avec cat.
Compléter :
Fichier de ventes
|
v
_________
_________
|
v
Découpage en blocs
|
v
_________
_________
|
v
Attribution de ressources
|
v
_________
|
v
Résultats stockés dans HDFS
Associer chaque composant à son rôle :
HDFS YARN NameNode DataNode ResourceManager Spark MapReduce
Un fichier compte_rendu.md contenant :
Répondre en une dizaine de lignes :
En quoi HDFS et YARN répondent-ils à des problèmes différents, et pourquoi sont-ils complémentaires pour exécuter un traitement distribué ?
# État des conteneurs docker compose ps # Entrer dans un conteneur docker compose exec namenode bash # Lister HDFS hdfs dfs -ls -h /chemin # Créer un répertoire hdfs dfs -mkdir -p /chemin # Copier vers HDFS hdfs dfs -put fichier /chemin/ # Lire un fichier hdfs dfs -cat /chemin/fichier # Supprimer hdfs dfs -rm -r /chemin # Examiner les blocs hdfs fsck /chemin/fichier -files -blocks -locations # État des DataNodes hdfs dfsadmin -report # Nœuds YARN yarn node -list # Applications YARN yarn application -list # Applications terminées yarn application -list -appStates ALL
YARN
+-------------------------+
| ResourceManager |
| NodeManagers |
| Allocation des ressources|
+------------+------------+
|
v
Spark
ou MapReduce
|
v
HDFS
+-------------------------+
| NameNode |
| DataNodes |
| Blocs et réplication |
+-------------------------+
HDFS stocke. YARN organise les ressources. Spark ou MapReduce traite.