Vous êtes sur la page 1sur 11

Atelier Big data Chebbi Ikram & Sana Ezzeddine & Moufida Jguirim

TP N° 1 : Le traitement Batch avec


Hadoop, HDFS et MapReduce

Objectifs :
- Initiation au framework Hadoop et au modèle de programmation MapReduce ;

- Utilisation de Docker pour lancer un cluster Hadoop de 3 nœuds

- Utilisation des commandes HDFS pour manipuler les fichiers

- Ecriture des fonctions Map et Reduce en Java

Outils utilisés :
- Apache Hadoop [http://hadoop.apache.org/] version 2.7.2
- Docker [https://www.docker.com/] Version 17.09.1
- IntelliJ IDEA [https://www.jetbrains.com/idea/download/]
- Java[http://www.oracle.com/technetwork/java/javase/downloads/index.html] Version
1.8.

Hadoop
Apache Hadoop est un framework open-source pour stocker et traiter les données
volumineuses sur un cluster. Il est utilisé par un grand nombre de contributeurs et
utilisateurs. Il a une licence Apache 2.0.

Docker
Le logiciel « Docker » est une technologie de containérisation qui permet la création et
l'utilisation de conteneurs Linux.

1
Dans ce TP, nous allons utiliser les conteneurs Docker pour pouvoir héberger notre cluster
Hadoop et simuler le comportement de l’ensemble des machines grâce à des conteneurs plus
légers.

NB : Dans ce TP nous utiliserons seulement les lignes de commande.

ère
1 partie : Mise en place de l’environnement Hadoop

Travail à réaliser :
Le but de cette première partie est de définir un mini-cluster composé de 3 machines
qui sont hébergées chacune dans un conteneur docker : une machine Master et deux
machines Slave. Ces machines seront reliées par un réseau que nous appellerons Hadoop qui
va leur permettre de communiquer.

Master

Hadoop
Slave Slave

Votre Machine
1. Installation de Docker :
1. Rendez-vous sur https://hub.docker.com/
2. Télécharger Docker Desktop et installer-le en suivant les instructions
3. Une fois installé, vous pouvez utiliser les commandes Docker.
4. Dans l’invite des commandes, tapez :

docker run hello-world

2
5. Si le message suivant apparaitra, votre installation marche bien. Hello From Docker !

2. Chargement de l’image liliasfaxi/spark-hadoop à partir de docker hub


Pour se faire, tapez la ligne de commande suivante :

docker pull liliasfaxi/spark-hadoop :hv-2.7.2

Le système va commencer à télécharger ce container, qui contient une image ubuntu et les
différents outils que nous allons utiliser tout au long de ce TP. Ce container est volumineux,
donc ça prendra du temps pour qu’il soit téléchargé.
Une fois cette étape terminée, vous pouvez vérifier l’existence de cette image sur votre
machine en tapant : docker images

3. Création des containers


Comme expliqué, nous visons la création d’un mini-cluster, contenant un Master qui sera
notre NameNode et deux slaves qui représenterons nos DataNodes.
Pour se faire, suivez les étapes suivantes :
a. Créez un réseau qui permettra de relier les trois contenaires:

docker network create --driver=bridge hadoop

b. Créer et lancer les trois contenaires :


Master
docker run -itd --net=hadoop -p 50070:50070 -p 8088:8088 -p 707
--name hadoop-master --hostname hadoop-master
liliasfaxi/spark-hadoop:hv-2.7.2

Slave1
docker run -itd -p 8040:8042 --net=hadoop --name hadoop-slave1
--hostname hadoop-slave1 liliasfaxi/spark-hadoop:hv-2.7.2

Slave2
docker run -itd -p 8041:8042 --net=hadoop --name hadoop-slave2
--hostname hadoop-slave2 liliasfaxi/spark-hadoop:hv-2.7.2

La commande docker run permet de créer un container à partir de l’image téléchargée et


l’exécuter.
--net=hadoop permet de spécifier que notre container fera partie du réseau Hadoop que nous
venons de créer
3
-p 50070:50070 -p 8088:8088 -p 707 : permet d’ouvrir ces ports pour pouvoir consulter les pages
web offertes par le cluster Hadoop pour visualiser l’activité HDFS, Spark,…et ceci à partir de
votre navigateur local.
--name hadoop-master : nous appelons notre container hadoop-master

les instructions -p permettent de faire un mapping entre les ports de la machine hôte et ceux
du contenaire.
On peut maintenant voir la liste des containers qui tournent sur la machine en tapant : docker ps

4. Entrer dans le contenaire Master pour commencer à l'utiliser :


Toutes les opérations que nous allons faire vont être à partir du Master parce qu’il est le seul
vis-à-vis de l’utilisateur. Pour se connecter au Master, tapez la commande suivante :
docker exec -it hadoop-master bash

Du coup, vous vous retrouvez sur le Master

Maintenant vous pouvez manipuler des fichiers avec HDFS.

2ème partie : Manipulation de fichiers dans HDFS


Travail à réaliser :
Le but de cette deuxième partie est de manipuler un fichier nommé Purchases.txt qui
est très volumineux, déjà stocké sur notre Master du cluster et sera divisé en blocs sur les
deux slaves et qu’on va copier sur HDFS et réaliser des opérations parallèle sur ce fichier.
(lecture, écriture, chargement)

4
Pour vérifier l’existence du fichier Purchases.txt dans votre Master, tapez la commande
suivante :

La commande hadoop fs permet de manipuler le système de fichiers HDFS comme si on est


sur une seule machine. Toutes les commandes interagissant avec le système Hadoop
commencent par hadoop fs. Ensuite, les options rajoutées sont très largement inspirées des
commandes Unix standards.
1. Lancement de hadoop et yarn :
Un script est fourni pour cela, appelé start-hadoop.sh. Lancez ce script. ./start-hadoop.sh
2. Création d’un répertoire input sur HDFS :
Pour ce faire, tapez la commande suivante : hadoop fs –mkdir -p input , l’option –p permet de
créer tout le path jusqu’à arriver au répertoire. Pour vérifier, taper hadoop fs –ls

3. Charger le fichier Purchases.txt dans le répertoire input que vous avez créé:
Tapez la commande hadoop fs –put purchases.txt input . Vous remarquez que cette étape prend
un peu du temps. En effet, HDFS est en train de découper le fichier en un ensemble de blocs
et de leur répartition sur l’ensemble des datanodes du cluster. En tapant hadoop fs –ls input

on obtient :

Nous présentons dans le tableau suivant les commandes les plus utilisées pour manipuler les
fichiers dans HDFS:

5
4. Interfaces web pour Hadoop
Hadoop offre plusieurs interfaces web pour pouvoir observer le comportement de ses
différentes composantes. Vous pouvez afficher ces pages en local sur votre machine grâce à
l'option -p de la commande docker run . En effet, cette option permet de publier un port du
contenaire sur la machine hôte.
Deux ports de la machine maître ont été exposés :
- Le port 50070 : qui permet d'afficher les informations de votre namenode.
- Le port 8088 : qui permet d'afficher les informations du resource manager de Yarn et
visualiser le comportement des différents jobs.
Une fois votre cluster lancé et prêt à l'emploi, vous pouvez, sur votre navigateur
préféré de votre machine hôte, aller à : http://localhost:50070. Vous obtiendrez le résultat
suivant:

6
Vous pouvez également visualiser l'avancement et les résultats de vos Jobs (Map Reduce ou
autre) en allant à l'adresse: http://localhost:8088

3ème partie : Map Reduce en Java

Le but de cette troisième partie est de créer un job Map Reduce sur notre cluster de
containers. Un Job Map-Reduce se compose principalement de deux types de programmes:
- Mappers : permettent d’extraire les données nécessaires sous forme de clef/valeur,
pour pouvoir ensuite les trier selon la clef
- Reducers : prennent un ensemble de données triées selon leur clef, et effectuent le
traitement nécessaire sur ces données (somme, moyenne, total...)

7
Wordcount
Nous allons tester un programme MapReduce grâce à un exemple très simple, le
WordCount, l'équivalent du HelloWorld pour les applications de traitement de données.
Le Wordcount permet de calculer le nombre de mots dans un fichier donné, en décomposant
le calcul en deux étapes:
- L'étape de Mapping, qui permet de découper le texte en mots et de délivrer en sortie
un fux textuel, où chaque ligne contient le mot trouvé, suivi de la valeur 1 (pour dire que le
mot a été trouvé une fois)
- L'étape de Reducing, qui permet de faire la somme des 1 pour chaque mot, pour
trouver le nombre total d'occurrences de ce mot dans le texte.
N’oubliez pas qu’entre le Mapping et le Reducing, il y a l’étape de Shuffle/sort
1. Création d’un projet Maven dans IntelliJ IDEA
Maven est un gestionnaire de dépendances, il va nous aider dans la gestion des .jar et de
toutes les bibliothèques dont nous avons besoin pour la création d’un projet Hadoop
fonctionnel.
- Commencez par créer un nouveau projet de type Maven
- Définir les valeurs suivantes pour votre projet:
GroupId: hadoop.mapreduce
ArtifactId: wordcount
Version: 1
- Ouvrir le fichier pom.xml, et ajouter les dépendances suivantes pour Hadoop, HDFS et
Map Reduce:

<dependencies>
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-common</artifactId>
<version>2.7.2</version>
</dependency>
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-mapreduce-client-core</artifactId>
<version>2.7.2</version>
</dependency>
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-hdfs</artifactId>
<version>2.7.2</version>
</dependency>
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-mapreduce-client-common</artifactId>
<version>2.7.2</version>
</dependency>
</dependencies>

8
- Créer un package isetma.bigdata.tp1 sous le répertoire src/main/java
- Créer la classe TokenizerMapper, contenant ce code:

package isetma.bigdata.tp1;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
import java.util.StringTokenizer;
public class TokenizerMapper
extends Mapper<Object, Text, Text,
IntWritable>{
private final static IntWritable one = new
IntWritable(1);
private Text word = new Text();
public void map(Object key, Text value,
Mapper.Context context
) throws IOException, InterruptedException {
StringTokenizer itr = new
StringTokenizer(value.toString());
while (itr.hasMoreTokens()) {
word.set(itr.nextToken());
context.write(word, one);
}
}
}

- Créer la classe IntSumReducer:

package isetma.bigdata.tp1;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
public class IntSumReducer
extends
Reducer<Text,IntWritable,Text,IntWritable> {
private IntWritable result = new IntWritable();
public void reduce(Text key, Iterable<IntWritable>
values,
Context context
) throws IOException, InterruptedException {
int sum = 0;
for (IntWritable val : values) {
System.out.println("value: "+val.get());
sum += val.get();
}
System.out.println("--> Sum = "+sum);
result.set(sum);
context.write(key, result);
}
}

9
- Créer la classe WordCount :

package isetma.bigdata.tp1;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import
org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import
org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.Job.*;

public class WordCount {


public static void main(String[] args) throws Exception
{
Configuration conf = new Configuration();
Job job = Job.getInstance(conf, "word count");
job.setJarByClass(WordCount.class);
job.setMapperClass(TokenizerMapper.class);
job.setCombinerClass(IntSumReducer.class);
job.setReducerClass(IntSumReducer.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);
FileInputFormat.addInputPath(job, new
Path(args[0]));
FileOutputFormat.setOutputPath(job, new
Path(args[1]));
System.exit(job.waitForCompletion(true) ? 0 : 1);
}
}

2. Tester Map Reduce en local

Il est fortement recommandé de tester le code Map Reduce en local pour la première fois
Dans votre projet sur IntelliJ:
- Créer un répertoire input sous le répertoire resources de votre projet.
- Créer un fichier de test: file.txt dans lequel vous insèrerez les deux lignes:

Hello
Wordcount!
Hello Hadoop!

- Créer une configuration de type Application (Run->Edit Con_gurations...->+-


>Application).
- Définir comme Main Class: isetma.bigdata.tp1.WordCount, et comme Program
Arguments: src/main/resources/input/file.txt src/main/resources/output

10
- Lancer le programme. Un répertoire output sera créé dans le répertoire resources,
contenant notamment un fichier part-r-00000, dont le contenu devrait être le suivant:

Hadoop! 1
Hello 2
Wordcount! 1

3. Lancer Map Reduce sur le cluster

Dans votre projet IntelliJ:


- Créer une configuration Maven avec la ligne de commande: package install
- Lancer la configuration. Un fichier wordcount-1.jar sera créé dans le répertoire target
du projet.
- Copier le fichier jar créé dans le contenaire master. Pour celà:
Ouvrir le terminal sur le répertoire du projet. Cela peut être fait avec IntelliJ en ouvrant
la vue Terminal située en bas à gauche de la fenêtre principale.
- Taper la commande suivante: docker cp target/wordcount-1.jar hadoop-master:/root/wordco

- Revenir au shell du contenaire master, et lancer le job map reduce avec cette
commande: hadoop jar wordcount-1.jar isetma.bigdata.WordCount input

- Le Job sera lancé sur le fichier purchases.txt que vous aviez préalablement chargé dans
le répertoire input de HDFS. Une fois le Job terminé, un répertoire output sera créé. Si tout se
passe bien, vous obtiendrez un affichage.
- Vous pouvez afficher les dernières lignes du fichier généré output/part-r-00000, avec

hadoop fs -tail output/part-r-00000

- Il vous est possible de monitorer vos Jobs Map Reduce, en allant à la page:
http://localhost:8088
- Il est également possible de voir le comportement des noeuds esclaves, en allant à
l'adresse: http://localhost:8041 pour slave1, et http://localhost:8042 pour slave2

A FAIRE :

Écrire un Job Map Reduce permettant, à partir du fichier purchases initial, de déterminer le
total des ventes par magasin. La structure du fichier purchases est de la forme suivante:
Date temps magasin produit cout paiement

11

Vous aimerez peut-être aussi