Faculté Polydisciplinaire - Safi Filières : IIA & SD / Semestre : 6
Module : Big Data et NoSQL
TP3 : MapReduce — Exécution et Programmation
Résumé. Ce TP vous guide à travers deux étapes complémentaires de MapReduce. Dans la
première partie, vous exécuterez un programme MapReduce déjà fourni, sans écrire de
code, afin d’observer le déroulement complet d’un job : préparation des données dans
HDFS, lancement, consultation des résultats et supervision via YARN. Dans la seconde
partie, vous découvrirez la structure d’un programme MapReduce simple en Java, puis
vous le compilerez, le packagerez en JAR et l’exécuterez sur Hadoop.
1. Objectif du TP
L'objectif de ce TP est de maîtriser le modèle de programmation MapReduce à travers deux
approches progressives : l'utilisation d'un programme existant, puis l'écriture d'un programme
original.
À l'issue de ce TP, vous serez capables de :
• préparer des données d'entrée dans HDFS pour un job MapReduce ;
• lancer et surveiller un job MapReduce via la ligne de commande ;
• consulter les résultats d'un job dans HDFS ;
• observer l'exécution d'un job via l'interface YARN (ResourceManager) ;
• comprendre la structure d'un programme MapReduce (Mapper, Reducer, Driver) ;
• écrire, compiler et exécuter votre propre programme MapReduce en Java.
2. Prérequis
Avant de commencer ce TP, vérifier que l'environnement Hadoop est opérationnel :
• Hadoop 3.3.6 est installé et configuré (TP1 réalisé) ;
• les commandes HDFS de base ont déjà été manipulées (TP2 réalisé) ;
• les services HDFS et YARN sont démarrés ;
• jps affiche bien les 5 processus Hadoop attendus ;
• le JDK est installé (java, javac disponibles).
Démarrer les services si ce n'est pas encore fait :
[Link]
[Link]
Vérifier les processus actifs :
jps
REMARQUE
Les processus NameNode, DataNode, SecondaryNameNode, ResourceManager et
NodeManager doivent tous être présents.
1/14
Faculté Polydisciplinaire - Safi Filières : IIA & SD / Semestre : 6
3. Rappel : le modèle MapReduce
MapReduce est un modèle de programmation distribué utilisé dans Hadoop. Il permet de traiter
de grands volumes de données en répartissant le travail en plusieurs tâches.
DÉFINITION
MapReduce — Un job MapReduce se décompose en deux phases principales :
• Phase Map : chaque Mapper lit une portion de données en entrée et produit des
paires clé/valeur intermédiaires.
• Phase Reduce : chaque Reducer regroupe les paires par clé, les agrège et produit
le résultat final.
Entre les deux phases, une étape de tri et de regroupement (Shuffle & Sort) redistribue
les paires intermédiaires vers les bons Reducers.
Partie I — Exécuter un programme MapReduce existant
4. Présentation de l'exemple WordCount
WordCount est le programme de référence de l'écosystème Hadoop. Il compte le nombre
d'occurrences de chaque mot dans un ensemble de fichiers texte. Ce programme est livré avec
Hadoop et ne nécessite aucune compilation.
DÉFINITION
Principe de WordCount — Pour chaque ligne du fichier d'entrée :
• le Mapper découpe la ligne en mots et émet une paire (mot, 1) pour chaque
mot;
• le Shuffle & Sort regroupe toutes les paires ayant la même clé ;
• le Reducer additionne les valeurs pour chaque clé et émet (mot, total).
REMARQUE
Le JAR contenant WordCount est livré avec Hadoop. Il se trouve dans :
$HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-examples-
*.jar
5. Préparation des données d'entrée dans HDFS
Avant de lancer le job, il faut disposer d'un fichier texte dans HDFS. Nous allons créer un fichier
de données représentatif.
5.1 Créer le répertoire de travail dans HDFS
Créer un répertoire dédié à ce TP dans HDFS :
hdfs dfs -mkdir -p /tp3/input_wc
Vérifier la création :
hdfs dfs -ls /
2/14
Faculté Polydisciplinaire - Safi Filières : IIA & SD / Semestre : 6
5.2 Créer un fichier texte localement
Créer un répertoire local de travail :
mkdir -p ~/tp_mapreduce
Créer un fichier texte avec un contenu varié :
echo "Big Data designe les ensembles de donnees de tres grand
volume" > ~/tp_mapreduce/[Link]
echo "Hadoop et Spark sont les deux outils phares du Big Data" >>
~/tp_mapreduce/[Link]
echo "Le traitement distribue est au coeur du Big Data" >>
~/tp_mapreduce/[Link]
Vérifier le contenu du fichier :
cat ~/tp_mapreduce/[Link]
5.3 Importer le fichier dans HDFS
Copier le fichier vers HDFS :
hdfs dfs -put ~/tp_mapreduce/[Link] /tp3/input_wc/
Vérifier que le fichier est bien présent dans HDFS :
hdfs dfs -ls /tp3/input_wc/
ATTENTION
Le répertoire de sortie du job (/tp3/output_wc) ne doit pas exister avant le lancement.
Hadoop refuse d'écraser un répertoire de sortie existant et le job échoue avec une erreur.
6. Lancement du job MapReduce WordCount
Hadoop fournit un JAR d'exemples contenant plusieurs programmes MapReduce prêts à
l'emploi, dont WordCount.
6.1 Localiser le JAR d'exemples
Trouver le fichier JAR d'exemples :
ls $HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-examples-
*.jar
3/14
Faculté Polydisciplinaire - Safi Filières : IIA & SD / Semestre : 6
REMARQUE
La commande ls avec le joker * permet de trouver le JAR quel que soit le numéro de version
exact. Notez le chemin complet retourné — il sera utilisé pour lancer le job.
6.2 Lancer le job WordCount
Exécuter WordCount avec le répertoire d'entrée HDFS et un répertoire de sortie :
hadoop jar $HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-
[Link] wordcount /tp3/input_wc /tp3/output_wc
Hadoop affiche en temps réel dans le terminal la progression du job. Observer les lignes
suivantes :
• map 0% … map 100% : avancement de la phase Map ;
• reduce 0% … reduce 100% : avancement de la phase Reduce ;
• Job [job_XXXXXX_0001] completed successfully : confirmation de succès.
REMARQUE
Si le terminal affiche une erreur « Output directory already exists », supprimer
le répertoire avec hdfs dfs -rm -r /tp3/output_wc et relancer le job.
7. Consultation des résultats
7.1 Lister les fichiers de sortie
Lister le contenu du répertoire de sortie :
hdfs dfs -ls /tp3/output_wc/
Hadoop génère deux types de fichiers dans le répertoire de sortie :
• _SUCCESS : fichier vide indiquant que le job s'est terminé sans erreur ;
• part-r-00000 : fichier contenant les résultats produits par le Reducer.
REMARQUE
Le nombre de fichiers part-r-XXXXX correspond au nombre de Reducers utilisés. Par
défaut, Hadoop utilise 1 Reducer, ce qui produit un seul fichier part-r-00000.
7.2 Afficher les résultats
Lire le contenu du fichier de résultats depuis HDFS :
hdfs dfs -cat /tp3/output_wc/part-r-00000
Chaque ligne du résultat est de la forme : mot[TAB]nombre_occurrences. Les mots sont
triés par ordre alphabétique.
4/14
Faculté Polydisciplinaire - Safi Filières : IIA & SD / Semestre : 6
Récupérer le fichier de résultats sur le système local pour une analyse :
hdfs dfs -get /tp3/output_wc/part-r-00000
~/tp_mapreduce/resultats_wordcount.txt
cat ~/tp_mapreduce/resultats_wordcount.txt
8. Supervision via l'interface YARN
YARN fournit une interface web permettant de surveiller l'exécution des jobs MapReduce en
temps réel ou de consulter l'historique des jobs terminés.
Ouvrir un navigateur et accéder à l'adresse suivante :
[Link]
Ce que vous devez observer :
• ALL APPLICATIONS : liste de tous les jobs soumis avec leur statut (RUNNING,
SUCCEEDED, FAILED) ;
• Colonne State / FinalStatus : état final du job (SUCCEEDED) ;
• En cliquant sur le job ID : détails de l'Application Master, nombre de
Mappers/Reducers, journaux.
REMARQUE
L'interface YARN conserve l'historique des jobs récents. Si le job est terminé depuis
longtemps, il peut ne plus apparaître. Dans ce cas, consulter l'interface History Server
: [Link]
À RETENIR
• hadoop jar <chemin_jar> wordcount <input_hdfs> <output_hdfs>:
lancer un job WordCount ;
• hdfs dfs -ls <output> : lister les fichiers de sortie ;
• hdfs dfs -cat <output>/part-r-00000 : afficher les résultats ;
• [Link] : interface YARN pour surveiller les jobs.
5/14
Faculté Polydisciplinaire - Safi Filières : IIA & SD / Semestre : 6
Partie II — Écrire son propre programme MapReduce en Java
9. Structure d'un programme MapReduce en Java
Un programme MapReduce en Java est composé de trois classes obligatoires : le Mapper, le
Reducer et le Driver. Chacune joue un rôle précis dans le traitement distribué.
Commande / Élément Description
Mapper Lit les données d'entrée ligne par ligne et émet
des paires (clé, valeur) intermédiaires
Reducer Reçoit les paires regroupées par clé, les agrège
et produit le résultat final
Driver Configure le job : chemins d'entrée/sortie,
classes Mapper/Reducer, type des clés/valeurs
DÉFINITION
Signature des classes MapReduce
• Mapper<KEYIN, VALUEIN, KEYOUT, VALUEOUT> : classe générique
paramétrée par les types d'entrée et de sortie.
Pour WordCount : Mapper<Object, Text, Text, IntWritable>
o KEYIN (Object) : offset de la ligne dans le fichier (ignoré ici) ;
o VALUEIN (Text) : contenu de la ligne lue ;
o KEYOUT (Text) : mot émis comme clé intermédiaire ;
o VALUEOUT (IntWritable) : valeur 1 émise pour chaque mot.
• Reducer<KEYIN, VALUEIN, KEYOUT, VALUEOUT> : reçoit les paires
intermédiaires regroupées par clé et produit le résultat final.
Pour WordCount : Reducer<Text, IntWritable, Text, IntWritable>
o KEYIN (Text) : mot reçu comme clé — correspond exactement au
KEYOUT du Mapper ;
o VALUEIN (IntWritable) : liste des valeurs associées à ce mot —
correspond exactement au VALUEOUT du Mapper ;
o KEYOUT (Text) : mot émis dans le résultat final ;
• VALUEOUT (IntWritable) : nombre total d'occurrences du mot.
6/14
Faculté Polydisciplinaire - Safi Filières : IIA & SD / Semestre : 6
10. Écriture du code Java
10.1 Préparer le répertoire de travail
Créer le répertoire du projet Java :
mkdir -p ~/tp_mapreduce/wordcount/src
10.2 Le Mapper
Créer le fichier [Link] :
nano ~/tp_mapreduce/wordcount/src/[Link]
Saisir le code suivant :
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
public class WordCountMapper
extends Mapper<Object, Text, Text, IntWritable> {
private final static IntWritable one = new IntWritable(1);
private Text word = new Text();
@Override
public void map(Object key, Text value, Context context)
throws IOException, InterruptedException {
// Découper la ligne en mots (séparateurs : espaces,
tabulations)
StringTokenizer itr = new StringTokenizer([Link]());
while ([Link]()) {
[Link]([Link]());
// Émettre la paire (mot, 1)
[Link](word, one);
}
}
}
REMARQUE
La méthode map() est appelée une fois par ligne du fichier d'entrée. Elle découpe la ligne
en mots et émet une paire (mot, 1) pour chaque mot trouvé. Le tri et le regroupement
des paires par clé sont effectués automatiquement par Hadoop (phase Shuffle & Sort).
7/14
Faculté Polydisciplinaire - Safi Filières : IIA & SD / Semestre : 6
10.3 Le Reducer
Créer le fichier [Link] :
nano ~/tp_mapreduce/wordcount/src/[Link]
Saisir le code suivant :
import [Link];
import [Link];
import [Link];
import [Link];
public class WordCountReducer
extends Reducer<Text, IntWritable, Text, IntWritable> {
private IntWritable result = new IntWritable();
@Override
public void reduce(Text key, Iterable<IntWritable> values, Context
context)
throws IOException, InterruptedException {
int sum = 0;
// Additionner toutes les valeurs reçues pour ce mot
for (IntWritable val : values) {
sum += [Link]();
}
[Link](sum);
// Émettre la paire (mot, total)
[Link](key, result);
}
}
REMARQUE
La méthode reduce() reçoit un mot (clé) et la liste de toutes ses valeurs associées (une
suite de 1). Elle additionne ces valeurs pour obtenir le nombre total d'occurrences du mot,
puis émet la paire finale (mot, total).
8/14
Faculté Polydisciplinaire - Safi Filières : IIA & SD / Semestre : 6
10.4 Le Driver
Créer le fichier [Link] (Driver) :
nano ~/tp_mapreduce/wordcount/src/[Link]
Saisir le code suivant :
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
public class WordCount {
public static void main(String[] args) throws Exception {
if ([Link] != 2) {
[Link]("Usage: WordCount <input> <output>");
[Link](1);
}
Configuration conf = new Configuration();
Job job = [Link](conf, "WordCount");
// Définir les classes Mapper et Reducer
[Link]([Link]);
[Link]([Link]);
[Link]([Link]);
// Définir les types de la clé et de la valeur de sortie
[Link]([Link]);
[Link]([Link]);
// Définir les chemins d'entrée et de sortie
[Link](job, new Path(args[0]));
[Link](job, new Path(args[1]));
// Lancer le job et attendre la fin
[Link]([Link](true) ? 0 : 1);
}
}
ATTENTION
Le Driver configure l'ensemble du job. Les types de sortie définis via
setOutputKeyClass() et setOutputValueClass() doivent correspondre
exactement aux types KEYOUT et VALUEOUT du Reducer. Une incohérence provoque une
erreur à l'exécution.
9/14
Faculté Polydisciplinaire - Safi Filières : IIA & SD / Semestre : 6
11. Compilation et création du JAR
11.1 Définir le classpath Hadoop
Récupérer le classpath Hadoop (chemins vers les JARs nécessaires à la compilation) :
export HADOOP_CLASSPATH=$(hadoop classpath)
REMARQUE
La commande hadoop classpath retourne la liste de tous les JARs Hadoop nécessaires
à la compilation. En l'assignant à la variable HADOOP_CLASSPATH, on la rend disponible
pour javac.
11.2 Compiler les fichiers Java
Créer le répertoire des classes compilées :
mkdir -p ~/tp_mapreduce/wordcount/classes
Compiler les trois fichiers Java en une seule commande :
javac -classpath $HADOOP_CLASSPATH \
-d ~/tp_mapreduce/wordcount/classes \
~/tp_mapreduce/wordcount/src/*.java
Vérifier que les fichiers .class ont bien été générés :
ls ~/tp_mapreduce/wordcount/classes/
ATTENTION
En cas d'erreur de compilation, vérifier :
1. que la variable HADOOP_CLASSPATH est bien définie (echo
$HADOOP_CLASSPATH),
2. que les noms de fichiers et de classes correspondent exactement (Java est sensible à
la casse),
3. que les imports sont corrects.
11.3 Créer le fichier JAR
Packager les classes compilées dans un fichier JAR :
jar -cvf ~/tp_mapreduce/wordcount/[Link] -C
~/tp_mapreduce/wordcount/classes/ .
Vérifier le contenu du JAR :
jar -tf ~/tp_mapreduce/wordcount/[Link]
10/14
Faculté Polydisciplinaire - Safi Filières : IIA & SD / Semestre : 6
REMARQUE
L'option -cvf signifie : c (créer), v (verbose — afficher les fichiers ajoutés), f (spécifier le
nom du fichier JAR).
L'option -C change le répertoire de travail pour que les classes soient à la racine du JAR.
12. Exécution du programme sur Hadoop
12.1 Préparer les données d'entrée
Nous réutilisons le répertoire /tp3/input_wc déjà créé en Partie I avec [Link]. Il est
possible d'ajouter un second fichier pour enrichir le test.
Créer un second fichier texte localement :
echo "hadoop est une plateforme open source" >
~/tp_mapreduce/[Link]
echo "hadoop permet le stockage et le traitement distribue" >>
~/tp_mapreduce/[Link]
echo "mapreduce compte les mots dans un fichier texte" >>
~/tp_mapreduce/[Link]
echo "hadoop et mapreduce travaillent avec hdfs" >>
~/tp_mapreduce/[Link]
Importer ce fichier dans HDFS :
hdfs dfs -put ~/tp_mapreduce/[Link] /tp3/input_wc/
Vérifier le contenu du répertoire d'entrée :
hdfs dfs -ls /tp3/input_wc/
12.2 Supprimer l'ancien répertoire de sortie
Le répertoire /tp3/output_wc a été créé lors de la Partie 1. Il faut le supprimer avant de
relancer un job vers ce même chemin.
hdfs dfs -rm -r /tp3/output_wc
ATTENTION
Toujours supprimer le répertoire de sortie avant de relancer un job. Hadoop refuse d'écraser
un répertoire de sortie existant. C'est un comportement intentionnel pour éviter d'écraser
accidentellement des résultats.
11/14
Faculté Polydisciplinaire - Safi Filières : IIA & SD / Semestre : 6
12.3 Lancer le job
Exécuter le programme WordCount personnalisé :
hadoop jar ~/tp_mapreduce/wordcount/[Link] WordCount
/tp3/input_wc /tp3/output_wc
REMARQUE
Le second argument WordCount est le nom de la classe principale (Driver). Il doit
correspondre exactement au nom de la classe publique définie dans [Link].
12.4 Consulter et interpréter les résultats
Avant de comparer, supprimer le répertoire de sortie de référence s'il existe déjà :
hdfs dfs -rm -r /tp3/output_reference
Puis relancer le programme de référence Hadoop sur les mêmes données que la Partie 2
([Link] + [Link]) :
hadoop jar $HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-
[Link] \
wordcount /tp3/input_wc /tp3/output_reference
Afficher les résultats de votre programme :
hdfs dfs -cat /tp3/output_wc/part-r-00000
Récupérer les deux fichiers de résultats vers le système local et les comparer :
hdfs dfs -get /tp3/output_reference/part-r-00000
~/tp_mapreduce/resultat_reference.txt
hdfs dfs -get /tp3/output_wc/part-r-00000
~/tp_mapreduce/resultat_partie2.txt
diff ~/tp_mapreduce/resultat_reference.txt
~/tp_mapreduce/resultat_partie2.txt
Si diff ne retourne aucune ligne, les deux programmes produisent exactement les mêmes
résultats ; ce qui valide que votre implémentation est correcte.
Vérifier via l'interface YARN :
[Link]
Observer les trois jobs dans l'historique : le premier (Partie 1, programme de référence sur
[Link]), le second (Partie 2, votre propre programme), le troisième (programme de
référence relancé sur les mêmes données). Comparer leurs durées d'exécution.
12/14
Faculté Polydisciplinaire - Safi Filières : IIA & SD / Semestre : 6
13. Exercice récapitulatif
Réaliser les opérations suivantes de manière autonome :
Partie A — Utilisation du programme fourni :
1. Créer un répertoire /tp3/exercice/input_wc dans HDFS.
2. Créer localement un fichier [Link] contenant au moins 10 lignes de texte libre
(description d'une technologie Big Data par exemple).
3. Importer [Link] dans /tp3/exercice/input_wc/.
4. Lancer le WordCount fourni par Hadoop sur ce répertoire d'entrée, avec
/tp3/exercice/output_wc1 comme sortie.
Partie B — Programme personnalisé :
5. Modifier le Mapper de votre WordCount pour qu'il ignore la casse (convertir chaque
mot en minuscules avec [Link]() avant d'émettre la paire).
6. Recompiler et recréer le JAR.
7. Exécuter ce nouveau programme sur /tp3/exercice/input_wc avec
/tp3/exercice/output_wc2 comme sortie.
8. Comparer les résultats de output_wc1 et output_wc2. Expliquer les différences
observées.
14. Questions de compréhension
Répondre brièvement aux questions suivantes :
1. Quel est le rôle de la phase Shuffle & Sort entre Map et Reduce ?
2. Pourquoi le Mapper émet-il systématiquement la valeur 1 plutôt que de compter
directement les occurrences ?
3. Que se passe-t-il si l'on supprime la classe Reducer du Driver (setReducerClass)
? Quels seraient les résultats ?
4. Quelle est la différence entre le JAR d'exemples Hadoop et le JAR que vous avez créé?
5. Comment augmenter le nombre de Reducers dans votre programme Java ?
À RETENIR
Workflow complet d'un job MapReduce :
1. Préparer les données dans HDFS (hdfs dfs -put).
2. Lancer le job (hadoop jar <jar> <Classe> <input> <output>).
3. Consulter les résultats (hdfs dfs -cat <output>/part-r-00000).
4. Surveiller via YARN ([Link]
Structure Java d'un programme MapReduce :
• Mapper : étend Mapper<KIN,VIN,KOUT,VOUT>, méthode map().
• Reducer : étend Reducer<KIN,VIN,KOUT,VOUT>, méthode reduce().
• Driver : configure et soumet le job avec [Link]().
13/14
Faculté Polydisciplinaire - Safi Filières : IIA & SD / Semestre : 6
Conclusion
Dans ce TP, vous avez exécuté un programme MapReduce déjà fourni, puis vous avez écrit,
compilé et exécuté votre propre programme WordCount en Java. Vous avez ainsi découvert
les principales étapes d’un traitement MapReduce : préparation des données dans HDFS,
lancement du job, consultation des résultats et observation via YARN.
PROCHAIN TP
Dans le TP4, vous transformerez l'environnement mono-nœud actuel en un vrai mini-cluster
multi-nœud. Vous configurerez plusieurs machines, démarrerez HDFS et MapReduce dans
un cadre réellement distribué, et observerez concrètement l'intérêt du traitement parallèle
sur plusieurs nœuds.
14/14