TP N°2: Se Familiariser avec la Programmation Hadoop

 Objectif:

Le but de cet exercice est d'apprendre à commencer à créer des programmes MapReduce
utilisant le framework Hadoop Java. En particulier, vous apprendrez comment configurer
Eclipse environnement de développement intégré (IDE) pour le développement des
programmes utilisant Hadoop.

 Pré requis:
- Virtual Machine: VirtualBox
- Une version de GNU/LINUX accessible par la VM
- Eclipse Java (Java Neon) : http://www.eclipse.org/downloads/packages/release/neon/3

I. Vérification du bon fonctionnement de Hadoop

Nous allons utiliser un compte dédié utilisateur hduser pour l'exécution de Hadoop (crée dans
la séance précédente). Bien que ce n'est pas nécessaire, il est recommandé, car il permet de
séparer l'installation Hadoop à partir d'autres applications logicielles et les comptes d'utilisateur
en cours d'exécution sur la même machine (la sécurité, les autorisations, les sauvegardes, etc.)

1.1. Démarrer Hadoop

Démarrer le serveur localhost via le SSH

sudo /etc/init.d/ssh restart

ssh localhost

Démarrer Hadoop avec les commandes

start-dfs.sh
start-all.sh

1.2. Vérifier le bon fonctionnement de Hadoop

1
  Vérification Services Hadoop:
Vérifier que les services de hadoop sont démarrés par la commande suivante:

jps

//L'affichage sur ta console doit être comme suit:

4912 NameNode
5361 ResourceManager
5780 Jps
5209 SecondaryNameNode
5485 NodeManager
5251 DataNode
Aussi, on doit vérifier que le serveur local est bien fonctionnel tout en tapant l'url
suivant dans un navigateur:

http://localhost:50070/

L’interface affiché doit être la suivante

 Démarrage forcé d'un 'datanode':

2
Si vous rencontrez un problème en observant que le service de datanode ne figure pas dans la
liste renvoyée par la commande 'jps', procédez aux étapes suivantes:

hdfs dfsadmin -report

hadoop /usr/local/hadoop/bin datanode

II. Exercice N°1: le Hello World (Occurrences des

mots)
Nous allons maintenant compiler le code d'exemple Java du cours (compteur d’occurrence de
mots). Objectif: vérifier que l'environnement de compilation soit fonctionnel et que Hadoop
soit correctement à même d'exécuter des tâches, et se familiariser avec le processus de
compilation.
2.1. Configuration de répertoire d'entrée:
Créer un répertoire où hadoop va stocker ses travaux et donner une bonne permission de lui.
Aussi, changer le propriétaire de ces deux répertoires à hduser: UserName hadoop: groupName

sudo mkdir -p /usr/local/hadoop/yarn_data/hdfs/namenode

sudo mkdir -p /usr/local/hadoop/yarn_data/hdfs/datanode

sudo chmod 777 /usr/local/hadoop/yarn_data/hdfs/namenode

sudo chmod 777 /usr/local/hadoop/yarn_data/hdfs/datanode

sudo chown -R hduser:hadoop /usr/local/hadoop/yarn_data/hdfs/namenode

sudo chown -R hduser:hadoop /usr/local/hadoop/yarn_data/hdfs/datanode

2.2. Préparation des données:

3
En préparation de l'exécution de notre programme Hadoop, nous allons maintenant déplacer le
texte du poème sur HDFS. Déplacez-vous dans le dossier contenant les données d'entrée et
exécutez la commande:

hadoop fs -put poeme.txt /tmp/

Et vérifier sa présence avec la commande:

hadoop fs -ls /tmp

2.3. Ecrire le Programme

4
 Nous allons utiliser l'IDE 'Eclipse' comme notre éditeur, compilateur et générateur
de la bibliothèque JAR de nos exemples hadoop
 Programme Principal: (WordCount.java)
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.conf.*;
import org.apache.hadoop.io.*;
import org.apache.hadoop.mapred.*;
import org.apache.hadoop.util.*;

public class WordCount extends Configured implements Tool{

public int run(String[] args) throws Exception
{
//creating a JobConf object and assigning a job name for identification purposes
JobConf conf = new JobConf(getConf(), WordCount.class);
conf.setJobName("WordCount");

//Setting configuration object with the Data Type of output Key and Value
conf.setOutputKeyClass(Text.class);
conf.setOutputValueClass(IntWritable.class);

//Providing the mapper and reducer class names

conf.setMapperClass(WordCountMapper.class);
conf.setReducerClass(WordCountReducer.class);
//We wil give 2 arguments at the run time, one in input path and other is output path
Path inp = new Path(args[0]);
Path out = new Path(args[1]);
//the hdfs input and output directory to be fetched from the command line
FileInputFormat.addInputPath(conf, inp);
FileOutputFormat.setOutputPath(conf, out);

JobClient.runJob(conf);
return 0;
}

public static void main(String[] args) throws Exception

{
// this main function will call run method defined above.
int res = ToolRunner.run(new Configuration(), new WordCount(),args);
System.exit(res);
}  La Fonction Map: (WordCountMapper.java)
}
5
import java.io.IOException;
import java.util.StringTokenizer;

import org.apache.hadoop.io.*;
import org.apache.hadoop.mapred.*;

public class WordCountMapper extends MapReduceBase implements Mapper<LongWrita

ble, Text, Text, IntWritable>
{
//hadoop supported data types
private final static IntWritable one = new IntWritable(1);
private Text word = new Text();

//map method that performs the tokenizer job and framing the initial key value pairs
// after all lines are converted into key-value pairs, reducer is called.
public void map(LongWritable key, Text value, OutputCollector<Text, IntWritable> o
utput, Reporter reporter) throws IOException
{
//taking one line at a time from input file and tokenizing the same
String line = value.toString();
StringTokenizer tokenizer = new StringTokenizer(line);

//iterating through all the words available in that line and forming the key value pair
while (tokenizer.hasMoreTokens())
{
word.set(tokenizer.nextToken());
//sending to output collector which inturn passes the same to reducer
output.collect(word, one);
}
}
}

 La Fonction Reduce: (WordCountReducer.java)

6
import java.io.IOException;
import java.util.Iterator;

import org.apache.hadoop.io.*;
import org.apache.hadoop.mapred.*;

public class WordCountReducer extends MapReduceBase implements Reducer<Text, Int

Writable, Text, IntWritable>
{
//reduce method accepts the Key Value pairs from mappers, do the aggregation based on k
eys and produce the final out put
public void reduce(Text key, Iterator<IntWritable> values, OutputCollector<Text, IntWrit
able> output, Reporter reporter) throws IOException
{
int sum = 0;
/*iterates through all the values available with a key and add them together and give the
final result as the key and sum of its values*/

while (values.hasNext())
{
sum += values.next().get();
}
output.collect(key, new IntWritable(sum));
}
}

2.4. Supprimer les Dépendances:

Vous devez supprimer les dépendances en ajoutant des fichiers jar dans le dossier source
Hadoop. Maintenant, cliquez sur l'onglet Projet et allez à l'onglet 'Propriétés'.
Sous l'onglet Bibliothèques, cliquez sur Ajouter des fichiers JAR externes et sélectionnez tous
les fichiers dans le dossier se trouvant sous les chemins :
- '/usr/local/hadoop/share/hadoop/common' et
- '/usr/local/hadoop/share/hadoop/MapReduce'.

7
 2.5. Exécuter la configuration:
Maintenant, cliquez sur l'onglet Exécuter et cliquez sur Run-Configurations. Cliquez sur le
bouton Nouvelle configuration sur le côté supérieur gauche et Appliquer après avoir rempli les
propriétés suivantes. (Voir l'image)

Nom - Ex: WordCountConfig

Project - Parcourir et sélectionnez votre projet
Main Class - Sélectionnez WordCount.java - ceci est notre classe principale

8
 2.6. Exporter le projet en fichier *.JAR

Maintenant, cliquez sur l'onglet Fichier et sélectionnez Exporter. sous Java, sélectionnez Jar
Runnable. (Voir l'image)

Dans Launch Config - sélectionnez la fichier config vous avez créé à l'étape 6
(WordCountConfig).
Sélectionnez une destination à l'exportation (disons bureau.)
Sous l'onglet Bibliothèque, sélectionnez Extraire requis bibliothèques dans JAR généré et
cliquez sur Terminer.
Cliquez droit sur le fichier jar, allez à Propriétés et sous l'onglet Autorisations, cochez la case
Autoriser l'exécution de fichier comme un programme. et de donner lecture et en écriture à tous
les utilisateurs.

9
 2.7. Exécution du Projet *.JAR
- Déplacez-vous vers le dossier contenant le fichier .jar
- Par le biais de terminal, tapez la commande suivante:

hadoop jar wcount.jar /tmp/poeme.txt /tmp/results

Si tout s'est passé correctement, un message « mapreduce.Job: map 100% reduce 100% »
devrait s'afficher.

2.8. Récupération du résultat

 Vérification de l'existence des résultats:

hadoop fs -ls tmp/results

 Affichage des résultats sur l'écran:

hadoop fs -cat tmp/results/part-r-00000

10
 III. Un Deuxième Exercice: Feed Back Tweets

3.1. Enoncé

Une entreprise dispose d'un compte twitter pour son service aprés vente, recevant plusieurs
dizaines de milliers de tweets par jour. Elle cherche à déterminer le taux de satisfaction de ses
clients à partir du compte twitter.
3.2. Résolution

 Principe:

Clef: un descripteur de sentiment client (« satisfait », « insatisfait » ou « attente », «inconcluant

»).

 map: génère un couple (clef;valeur) par sentiment client détecté (mot correspondant à
une liste prédéfinie).
 Si deux sentiments contradictoires détectés: renvoyer inconcluant.
 On renvoie un couple (clef;valeur) pour chaque fragment des données d'entrée:
chaque tweet

 Pseudo-Algorithme 'Fonction MAP':

WORDS_BAD = ["nul", "insatisfait", "bof", "incompétents", …]

WORDS_GOOD = ["satisfait", "super", "excellent", …]
BAD=0; GOOD=0
POUR MOT dans [TWEET], FAIRE:
SI MOT PRESENT_DANS WORDS_BAD:
BAD=1
SINON SI MOT PRESENT_DANS WORDS_GOOD:
GOOD=1
SI BAD==1 ET GOOD==0:
RENVOYER("insatisfait",1)
SINON SI BAD==0 ET GOOD=1:
RENVOYER("satisfait",1)
SINON:
RENVOYER("inconcluant",1)

11
  Pseudo-Algorithme 'Fonction REDUCE':

reduce: additionne les valeurs associées à la clef unique; renvoie le total pour valeur (identique
au reducer du compteur d'occurences de mots).

3.3. Données à utiliser:

- Vous disposez d'un fichier texte (tweets.txt) téléchargeable sur le Google Drive
- Introduisez les commandes nécessaires pour que ces données soient stockées sous le
HDFS

12