Faculté polydisciplinaire de Taroudant

BIG Data
Lab 3 : MapReduce

Bouchhar Maryam & Adardour Naima

21/12/2023

Map-Reduce
  Exploration de Map-reduce (5WH) :

o Quoi:

Map-Reduce est Patron d’architecture de développement permettant de traiter des

données volumineuses de manière parallèle et distribuée.
Principe général :
Au lieu de traiter un ensemble de données séquentiellement, il est divisé en
sousensembles de données (morceaux) qui sont traités en parallèle. L’intérêt est
déploiement de traitements massivement parallèles sur des clusters.
Le modèle de programmation MapReduce et le framework de traitement MapReduce dans Hadoop sont
deux concepts liés mais distincts. Voyons en détail :

Modèle de programmation MapReduce : Le modèle de programmation MapReduce est une approche de

traitement parallèle de données, initialement popularisée par Google. Il divise une tâche de traitement de
données en deux phases principales : la phase de "map" et la phase de "reduce". La phase de "map" traite et
filtre les données en les associant à des paires clé-valeur, tandis que la phase de "reduce" agrège et consolide
ces paires clé-valeur. Ce modèle permet de traiter de grandes quantités de données de manière distribuée,
parallèle et évolutive.

Framework de traitement MapReduce dans Hadoop : Hadoop est un écosystème logiciel open source qui
prend en charge le stockage et le traitement distribués de données volumineuses. Dans le contexte de
Hadoop, le framework MapReduce est une implémentation spécifique du modèle de programmation
MapReduce. Il fournit un environnement de traitement distribué qui permet d'exécuter des programmes
MapReduce sur un grand cluster de machines. Le framework MapReduce de Hadoop gère la répartition des
tâches, l'ordonnancement, la gestion des erreurs, et la récupération en cas de défaillance, offrant ainsi une
solution évolutive pour le traitement de données massives.

Un job MapReduce est une unité de travail dans le modèle de programmation et de traitement de données
distribuées appelé MapReduce. C'est un concept clé dans les systèmes qui utilisent cette approche pour
traiter de grandes quantités de données parallèlement et de manière distribuée. L'architecture MapReduce
est souvent utilisée dans des environnements comme Apache Hadoop.

Un job MapReduce se compose généralement de deux phases principales : la phase de "map" et la phase de
"reduce".

Phase Map : Dans cette phase, les données d'entrée sont divisées en blocs et distribuées à plusieurs nœuds
de calcul. Chaque nœud exécute une fonction de map spécifiée par le développeur. Cette fonction prend une
paire clé-valeur en entrée et produit une liste de paires clé-valeur intermédiaires.

Shuffling and Sorting : Les paires clé-valeur intermédiaires produites par les différentes tâches de map sont
triées et regroupées par clé. Cela permet de regrouper toutes les valeurs associées à une même clé dans une
liste.
Phase Reduce : Les données regroupées sont ensuite envoyées à différentes tâches de reduce. Chaque tâche
de reduce prend une clé et la liste de ses valeurs associées en entrée, puis effectue une opération de
réduction spécifiée par le développeur pour produire une nouvelle paire clé-valeur.

o Qui :

Développé par Google : MapReduce a été introduit par Google pour traiter
efficacement des données sur ses infrastructures massivement distribuées.
Utilisé par les grands acteurs du Web notamment pour : construire les index
(Google Search), détection de spam (Yahoo), Data Mining (Facebook), ...
Autre utilisateurs :
- De l'analyse d'images astronomique, de la bio-informatique, de la simulation
métrologique, des statistiques, etc.
- Le calcul de la taille de plusieurs milliers de documents.
- Trouver le nombre d'occurrences d'un pattern dans un très grand volume de
données.
- Classifier de très grands volumes de données provenant par exemple de paniers
d'achats de clients (Data Mining)

o Où:

Utilisé dans des clusters informatiques : MapReduce est déployé sur des
clusters de serveurs, généralement au sein de centres de données, pour traiter des
données de manière parallèle.

o Quand :

Conçu dans les années 2000 : MapReduce a été initialement présenté dans un
document de recherche de Google en 2004 et a depuis été adopté et étendu par
d'autres systèmes, notamment dans le cadre du projet Hadoop.

o Comment :

Les étapes du processus :

Prétraitement (Pre-Process):
Nettoyer les données en entrée en éliminant la ponctuation, en normalisant les caractères
accentués, et en convertissant l'ensemble du texte en minuscules.

Découpage (Split) :
Fragmenter les données en plusieurs morceaux ou lots, généralement en les divisant ligne
par ligne, pour faciliter le traitement parallèle.

Mapping (Map) :
Créer des paires clé-valeur à partir des données en entrée. Souvent, cela se traduit par
l'association de chaque mot avec le nombre d'occurrences, générant ainsi des couples (mot,
nombre d'occurrences).

Regroupement (Shuffle) :
Rassembler toutes les paires ayant la même clé (grouper par clé) et les transmettre au même
réducteur. Ce processus d'agrégation produit des résultats intermédiaires.

Réduction (Reduce) :
Fusionner les groupes indexés par clé en une forme finale. Par exemple, additionner toutes
les valeurs associées à une clé, ce qui aboutit à la production du résultat final.

Exemple :

Architecture du Map-Reduce :
 JobTracker :
Réserver et ordonnancer les slots.
Coordonner l’exécution des Jobs Map-Reduce.
Gérer les fautes en réallouant les slots au besoin.

TaskTracker :
Exécuter les tâches de Map-Reduce.
Traite en général les blocs qui se trouvent la même
machine(DataNode) que lui d’une tâche (Map ou Reduce)

o Pourquoi :

 Map-Reduce offre la capacité de distribuer le traitement sur un grand nombre

de serveurs au sein d'un cluster, ce qui contribue à accélérer le traitement de
données massives en parallèle.
 Permet d’ajouter des machines afin d’augmenter la performance (scalable
friendly)
 permet de décomposer des taches très complexes en opérations très simples,
de sorte qu’elles puissent être distribuées sur différents nœuds d'un cluster.

 Exercices de Coursera :

o Exercise 1 (leçon n°1):

Running Wordcount with Hadoop streaming, using Python code.

1. Creation des fichiers mapper et reducer :

touch wordcount_mapper.py
touch wordcount_reducer.py
 2. Ajout des contenus aux fichiers:

vim wordcount_mapper.py
vim wordcount_reducer.py

Une fois que le fichier est ouvert dans Vim, on est initialement en mode normal. On
appuye sur la touche "i" pour entrer en mode édition. On voit "INSERT" en bas de la
fenêtre et on colle le contenu des codes python.
Pour enregistrer les modifications, on appuye sur la touche "Esc" pour revenir au
mode normal. Ensuite, tapez ":wq" et appuyez sur "Entrée". Cela enregistre les
modifications et quitte Vim.
Aperçu sur les codes : wordcount_mapper.py

Le but général de ce script est de prendre des lignes d'entrée, de les diviser en mots
(ou clés), et pour chaque mot, de produire une paire clé-valeur où la clé est le mot
luimême et la valeur est toujours égale à 1.

wordcount_mapper.py
 L’objectif général est d'agréger les valeurs associées à chaque clé en provenance de
la phase de mappage.
3. Exécution des scripts :

chmod +x wordcount_mapper.py
chmod +x wordcount_reducer.py

Ces commandes permettent d'ajouter le droit d'exécution (+x) aux fichiers

wordcount_mapper.py et wordcount_reducer.py.
4. Création des fichiers de données :
On crée des fichiers textes comme suit :

touch testfile1.txt
touch testfile2.txt

On ajoute quelques contenues à ces fichiers :

echo "A long time ago in a galaxy far far away" > /testfile1
echo " Another episode of Star Wars " > testfile2
/
 5. Copier les fichiers des données du local vers HDFS :
On crée un répertoire sur HDFS c’est là où on va mettre nos fichiers copiés du locale :

hdfs dfs -mkdir /user/cloudera/input

hdfs dfs -put /testfile1 /user/cloudera/input

hdfs dfs -put /testfile2 /user/cloudera/input

Ces commandes copient le fichier nommé "testfile1" et " testfile1" depuis le répertoire
racine ("/") de votre système de fichiers local vers le répertoire HDFS
/user/cloudera/input.

6. Execution d’un job map-reduce :

Hadoop Streaming est un utilitaire inclus dans le framework Apache Hadoop qui permet
d'exécuter des jobs MapReduce en utilisant des scripts comme mappers et reducers. Il est conçu pour
prendre en charge des langages de programmation autres que Java, permettant ainsi aux développeurs
d'utiliser des langages plus familiers comme Python, Perl, Ruby, etc.

hadoop jar /usr/lib/hadoop-mapreduce/hadoop-streaming.jar \

-input /user/cloudera/input \
-output /user/cloudera/output_new \
-mapper /wordcount_mapper.py \
-reducer /wordcount_reducer.py

Cette commande utilise Hadoop Streaming pour exécuter un job MapReduce.

Hadoop Streaming est un utilitaire inclus dans la distribution Hadoop qui permet
d'utiliser des scripts (dans des langages comme Python, Perl, etc.) comme mappers et
reducers au lieu de programmes Java traditionnels.

Dans cette commande on a :

-input /user/cloudera/input: Spécifie le répertoire d'entrée sur HDFS où les données
pour le job MapReduce sont stockées.
-output /user/cloudera/output_new: Indique le répertoire de sortie sur HDFS où les
résultats du job MapReduce seront stockés.
-mapper /wordcount_mapper.py: Spécifie que le script Python wordcount_mapper.py
est utilisé comme le mapper.
-reducer /wordcount_reducer.py: Spécifie que le script Python wordcount_reducer.py
est utilisé comme le reducer.

Cette commande donne un résultat comme suit :

Ces lignes sont des messages de journal (logs) générés lors de l'exécution d'un travail
MapReduce dans le framework Hadoop. Ces messages fournissent des informations
sur la progression du travail.
Au début du travail, aucun des mappers ou reducers n'a encore commencé son travail.
Les pourcentages de complétion sont à 0%.Ensuite, ona tous les mappers ont terminé
leur travail. Enfin, tous les reducers ont également terminé C'est à ce stade que le
travail MapReduce est entièrement terminé.
Ces messages sont utiles pour surveiller la progression d'un travail MapReduce et
diagnostiquer d'éventuels problèmes s'ils surviennent pendant l'exécution.

Pour consulter le contenu du fichier Output_new on tape la commande suivante :

dfs dfs -cat /user/cloudera/output_new/part-00000

Cette commande affiche le contenu du premier fichier (part-00000) produit par le job
MapReduce dans le répertoire de sortie. Dans un job MapReduce, les résultats
peuvent être répartis en plusieurs fichiers de sortie, généralement nommés "part-xxxxx"
où "xxxxx" est une partie spécifique. Le fichier part-00000 est généralement le premier
et le seul fichier puisqu’on a pas assez de données à traités.

Le contenu du fichier part-00000 sera :

7. Option de Job Streaming :

 hadoop jar /usr/lib/hadoop-mapreduce/hadoop-streaming.jar \
-input /user/cloudera/input \
-output /user/cloudera/output_new_0 \
-mapper /wordcount_mapper.py \
-reducer /home/cloudera/wordcount_reducer.py \
-numReduceTasks 0

La commande utilise Hadoop Streaming pour exécuter un travail MapReduce et

change le nombre de tâches de réduction à 0. Cela signifie que le travail effectuera
uniquement la phase de mappage et n'aura pas de phase de réduction.
Cela peut être utile dans des scénarios où vous souhaitez voir la sortie intermédiaire
directe des mappers sans aucune réduction.

8. fusionner les fichier de sorties de Mapper au système locale :

hdfs dfs-getmerge /user/cloudera/output_new_0/* wordcount_num0_output.txt

Cette commande est utilisée pour fusionner le contenu des fichiers de sortie générés
par le travail Hadoop sans tâches de réduction en un seul fichier sur le système de
fichiers local.
9. Changer le nombre de Reducers :
On Change le nombre de reducers à 2 :

hadoop jar /usr/lib/hadoop-mapreduce/hadoop-streaming.jar \

-input /user/cloudera/input \
-output /user/cloudera/output_new_2 \
-mapper /wordcount_mapper.py \
-reducer /wordcount_reducer.py \
-numReduceTasks 2
Un seul Reducer : Lorsque on travaille avec un seul reducer, toutes les données sont
acheminées vers ce reducer unique pour être traitées. Cela peut être efficace pour des
volumes de données plus petits ou pour des tâches simples.
Deux Reducers : Si on a deux reducers, les données sont partitionnées entre ces deux
reducers en fonction de la clé. Chaque reducer traite une partie distincte des données.
Cela peut être plus efficace pour gérer des volumes de données plus importants en
parallèle.

 Autres exercices :

o Exercice 1 :

1. Creation des mappers et reducers:

Il est demandé de créer 3 mappers et 3 reducers comme suit :

Les données associées à chaque ville seront traitées indépendamment par chaque mapper.
Dans le mapper on met :
C’est pareil pour Reducer on met le code suivant :

2. Vérifier le fonctionnement du map-reduce en locale :

- La première commande permet juste d’afficher les résultats intermédiaire du

 mapper1 qui traite la ville de Paris tel que :

Cat /lab3/mapreduce /ex1/data.csv: Cette partie de la commande utilise cat pour

concaténer et afficher le contenu du fichier data.csv (qui contient généralement les
données d'entrée). Le résultat de cette opération est envoyé à la sortie standard (stdout).

| (pipe) : Cet opérateur de pipe prend la sortie (stdout) de la première commande (cat)
et la transmet comme entrée (stdin) à la deuxième commande (python mapper1.py).

python /lab3/mapreduce /ex1/mapper1.py: Cette partie de la commande lance le

programme Python spécifié en tant que mapper qui est responsable du traitement des
données d'entrée, de la génération de paires clé-valeur, et de l'envoi de ces paires sur la
sortie standard (stdout).

- La deuxième commande inclut également la réduction des données en donnant des

résultats finaux.
3. Execution du job Straming :

hadoop jar /usr/lib/hadoop-mapreduce/hadoop-streaming.jar \

-mapper /lab3/mapreduce/ex1/mapper1.py -reducer /lab3/mapreduce/ex1/reducer1.py \
-input /user/cloudera/input/data.csv -output /user/cloudera/input/output_path \
-numReduceTasks 3

La commande indique essentiellement à Hadoop d'exécuter un travail MapReduce en

utilisant les scripts Python spécifiés pour le mappage et la réduction. Le travail prend
en entrée /user/cloudera/input/data.csv, le traite à travers les scripts de mappage et de
réduction spécifiés, et produit la sortie dans le répertoire
/user/cloudera/output/output_path. Le travail est configuré pour utiliser trois tâches de
réduction.