TP1 - Hadoop et Map Reduce
TP1 - Le traitement Batch avec Hadoop HDFS et Map Reduce
Télécharger PDF
Objectifs du TP
Initiation au framework hadoop et au patron MapReduce, utilisation de docker pour lancer un cluster hadoop de 3 noeuds.
Outils et Versions
Apache Hadoop Version: 2.7.2.
Docker Version 17.09.1
IntelliJ IDEA Version Ultimate 2016.1 (ou tout autre IDE de votre choix)
Java Version 1.8.
Unix-like ou Unix-based Systems (Divers Linux et MacOS)
Hadoop
Présentation
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.
Hadoop et Docker
Pour déployer le framework Hadoop, nous allons utiliser des contenaires Docker. L'utilisation des contenaires va garantir la consistance
entre les environnements de développement et permettra de réduire considérablement la complexité de configuration des machines (dans
le cas d'un accès natif) ainsi que la lourdeur d'exécution (si on opte pour l'utilisation d'une machine virtuelle).
Nous avons pour le déploiement des ressources de ce TP suivi les instructions présentées ici.
Installation
Nous allons utiliser tout au long de ce TP trois contenaires représentant respectivement un noeud maître (Namenode) et deux noeuds
esclaves (Datanodes).
Vous devez pour cela avoir installé docker sur votre machine, et l'avoir correctement configuré. Ouvrir la ligne de commande, et taper les
instructions suivantes:
1. Télécharger l'image docker uploadée sur dockerhub:
docker pull liliasfaxi/spark-hadoop:hv-2.7.2
2. Créer les trois contenaires à partir de l'image téléchargée. Pour cela: 2.1. Créer un réseau qui permettra de relier les trois contenaires:
docker network create --driver=bridge hadoop
2.2. Créer et lancer les trois contenaires (les instructions -p permettent de faire un mapping entre les ports de la machine hôte et ceux
du contenaire):
docker run -itd --net=hadoop -p 50070:50070 -p 8088:8088 -p 7077:7077 -p 16010:16010 \
--name hadoop-master --hostname hadoop-master \
liliasfaxi/spark-hadoop:hv-2.7.2
docker run -itd -p 8040:8042 --net=hadoop \
--name hadoop-slave1 --hostname hadoop-slave1 \
liliasfaxi/spark-hadoop:hv-2.7.2
docker run -itd -p 8041:8042 --net=hadoop \
--name hadoop-slave2 --hostname hadoop-slave2 \
liliasfaxi/spark-hadoop:hv-2.7.2
3. Entrer dans le contenaire master pour commencer à l'utiliser.
docker exec -it hadoop-master bash
Le résultat de cette exécution sera le suivant:
root@hadoop-master:~#
Vous vous retrouverez dans le shell du namenode, et vous pourrez ainsi manipuler le cluster à votre guise. La première chose à faire, une
fois dans le contenaire, est de lancer hadoop et yarn. Un script est fourni pour cela, appelé [Link]. Lancer ce script.
./[Link]
Le résultat devra ressembler à ce qui suit:
Premiers pas avec Hadoop
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 standard.
Créer un répertoire dans HDFS, appelé input. Pour cela, taper:
hadoop fs –mkdir -p input
Erreur
Si pour une raison ou une autre, vous n'arrivez pas à créer le répertoire input, avec un message ressemblant à ceci: ls: `.': No such file
or directory , veiller à construire l'arborescence de l'utilisateur principal (root), comme suit:
hadoop fs -mkdir -p /user/root
Nous allons utiliser le fichier [Link] comme entrée pour le traitement MapReduce. Ce fichier se trouve déjà sous le répertoire
principal de votre machine master.
Charger le fichier purchases dans le répertoire input que vous avez créé:
hadoop fs –put [Link] input
Pour afficher le contenu du répertoire input, la commande est:
hadoop fs –ls input
Pour afficher les dernières lignes du fichier purchases:
hadoop fs -tail input/[Link]
Le résultat suivant va donc s'afficher:
Nous présentons dans le tableau suivant les commandes les plus utilisées pour manipuler les fichiers dans HDFS:
Instruction Fonctionnalité
hadoop fs –ls Afficher le contenu du répertoire racine
hadoop fs –put [Link] Upload un fichier dans hadoop (à partir du répertoire courant linux)
hadoop fs –get [Link] Download un fichier à partir de hadoop sur votre disque local
hadoop fs –tail [Link] Lire les dernières lignes du fichier
hadoop fs –cat [Link] Affiche tout le contenu du fichier
hadoop fs –mv [Link] [Link] Renommer le fichier
Instruction Fonctionnalité
hadoop fs –rm [Link] Supprimer le fichier
hadoop fs –mkdir myinput Créer un répertoire
hadoop fs –cat [Link] \| less Lire le fichier page par page
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. Pour pouvoir publier tous les ports exposés, vous pouvez lancer votre contenaire en utilisant l'option -P .
En regardant le contenu du fichier [Link] fourni dans le projet, vous verrez que 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 à :
[Link] . Vous obtiendrez le résultat suivant:
Vous pouvez également visualiser l'avancement et les résultats de vos Jobs (Map Reduce ou autre) en allant à l'adresse:
[Link]
Map Reduce
Présentation
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...)
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 flux 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.
Commençons par créer un projet Maven dans IntelliJ IDEA. Nous utiliserons dans notre cas JDK 1.8.
Définir les valeurs suivantes pour votre projet:
GroupId: [Link]
ArtifactId: wordcount
Version: 1
Ouvrir le fichier [Link], et ajouter les dépendances suivantes pour Hadoop, HDFS et Map Reduce:
<dependencies>
<dependency>
<groupId>[Link]</groupId>
<artifactId>hadoop-common</artifactId>
<version>2.7.2</version>
</dependency>
<!-- [Link] -->
<dependency>
<groupId>[Link]</groupId>
<artifactId>hadoop-mapreduce-client-core</artifactId>
<version>2.7.2</version>
</dependency>
<!-- [Link] -->
<dependency>
<groupId>[Link]</groupId>
<artifactId>hadoop-hdfs</artifactId>
<version>2.7.2</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>hadoop-mapreduce-client-common</artifactId>
<version>2.7.2</version>
</dependency>
</dependencies>
Créer un package [Link].tp1 sous le répertoire src/main/java
Créer la classe TokenizerMapper, contenant ce code:
package [Link].tp1;
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
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, [Link] context
) throws IOException, InterruptedException {
StringTokenizer itr = new StringTokenizer([Link]());
while ([Link]()) {
[Link]([Link]());
[Link](word, one);
}
}
}
Créer la classe IntSumReducer:
package [Link].tp1;
import [Link];
import [Link];
import [Link];
import [Link];
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) {
[Link]("value: "+[Link]());
sum += [Link]();
}
[Link]("--> Sum = "+sum);
[Link](sum);
[Link](key, result);
}
}
Enfin, créer la classe WordCount:
package [Link].tp1;
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 {
Configuration conf = new Configuration();
Job job = [Link](conf, "word count");
[Link]([Link]);
[Link]([Link]);
[Link]([Link]);
[Link]([Link]);
[Link]([Link]);
[Link]([Link]);
[Link](job, new Path(args[0]));
[Link](job, new Path(args[1]));
[Link]([Link](true) ? 0 : 1);
}
}
TESTER MAP REDUCE EN LOCAL
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: [Link] dans lequel vous insèrerez les deux lignes:
Hello Wordcount!
Hello Hadoop!
Créer une configuration de type Application (Run->Edit Configurations...->+->Application).
Définir comme Main Class: [Link], et comme Program Arguments: src/main/resources/input/[Link]
src/main/resources/output
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
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 [Link] sera créé dans le répertoire target du projet.
Copier le fichier jar créé dans le contenaire master. Pour cela:
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/[Link] hadoop-master:/root/[Link]
Revenir au shell du contenaire master, et lancer le job map reduce avec cette commande:
hadoop jar [Link] [Link] input output
Le Job sera lancé sur le fichier [Link] 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 ressemblant au suivant:
En affichant les dernières lignes du fichier généré output/part-r-00000, avec hadoop fs -tail output/part-r-00000 , vous obtiendrez
l'affichage suivant:
Il vous est possible de monitorer vos Jobs Map Reduce, en allant à la page: [Link] . Vous trouverez votre Job dans la
liste des applications comme suit:
Il est également possible de voir le comportement des noeuds esclaves, en allant à l'adresse: [Link] pour slave1, et
[Link] pour slave2. Vous obtiendrez ce qui suit:
Application
É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
Veiller à toujours tester votre code en local avant de lancer un job sur le cluster!
Homework
Vous allez, pour ce cours, réaliser un projet en trinôme ou quadrinôme, qui consiste en la construction d'une architecture Big Data
supportant le streaming, le batch processing, et le dashboarding temps réel. Pour la séance prochaine, vous allez commencer par mettre
les premières pierres à l'édifice:
Choisir la source de données sur laquelle vous allez travailler. Je vous invite à consulter les datasets offerts par Kaggle par exemple,
ou chercher une source de streaming tel que Twitter.
Réfléchir à l'architecture cible. La pipeline devrait intégrer des traitements en batch, des traitements en streaming et une visualisation.
Last update: 2022-02-07
