Big_Data_Cours.pdf

Environnement du Big Data
 Introduction au Big Data
 Base de données NoSQL

Chapitre 1 : Introduction au Big Data
Contexte
• Au total, 5,07 milliards de personnes dans le monde utilisent Internet
aujourd'hui, ce qui équivaut à 63,5 % de la population mondiale totale.
• La population mondiale connectée a augmenté de plus de 170 millions
au cours des 12 mois précédant octobre 2022.

Contexte

Data
 2020: 44 zettaoctets taille de l'univers numérique.
 2020: Chaque personne ajoute 1,7 mégaoctet par seconde à l'Internet.
 Chaque jour, 2 milliard d'utilisateurs visitent WhatsApp, Messenger, Instagram et
Facebook.
 2022: 91 % des utilisateurs d'Instagram interagissent avec des vidéos.
 2022: Les utilisateurs envoient environ 650 millions de Tweets par jour.
 2022: Chaque jour, Google reçoit plus de 3,5 milliards de recherches.
 2022: Jusqu'à 65 milliards de messages sont envoyés via WhatsApp chaque jour.
 2022: 340 millions d'emails sont envoyés chaque jour.
 2025, plus de 200 zettaoctets de données seront stockés dans le cloud dans le
monde entier.
1 Zettaoctets= 1 milliards de Teraoctets

Problématiques
On s'intéresse à 3 grandes problématiques :
 Difficulté pour sauvegarder toutes ces données
 Difficulté pour traiter ces données et les utiliser
 Les données sont créées rapidement
Les techniques traditionnelles de stockage de type bases de données
relationnelles ne permettant pas de stocker de telles quantité́ de données

Appropriée pour:
o Des données structurées
o Opérations et processus répétitifs
o Sources relativement stables
o Besoins bien compris et bien cadrés

Définition
Les big data ou mégadonnées désignent l'ensemble des données
numériques produites par l'utilisation des ressources numériques, comme
courriels, documents, bases de données... Aussi des contenus publiés sur le
web (images, vidéos, sons, textes), des transactions de commerce
électronique, des échanges sur les réseaux sociaux, des données transmises
par les objets connectés, des données géolocalisées, etc.

Caractéristiques de Big Data
Les Big Data sont des ressources d'information à Volume élevé, à grande Vitesse de
traitement et à grande Variété (structurée, semi- structurée et non structurée».
 V: Volume de données de plus en massif;
 V: Variété de ces données qui peuvent être brutes, non structurées ou semi-
structurées ;
 V: Vélocité qui désigne le fait que ces données sont produites, récoltées et
analysées en temps réel.
2 autres « V » complémentaires : Valeur et Validité

Caractéristiques de Big Data
Big
Data
Volume
Variété
Vitesse
Valeur
Validité

Stockage de Big data
Cloud: est une architecture composée de matériels de stockage, data centers, de
réseau et de logiciels fournissant des services que des utilisateurs peuvent exploiter.
Cloud est un support de stockage de big data.
Pour le stockage de big data sur le cloud, généralement on utilise, MapReduce. Est
modèle de programmation parallèle, exécuté dans un logiciel libre appelé
«Hadoop».
Les big data dans le cloud sont gérés via des systèmes de gestion de base de données
(SGBD) spécifiques de type NoSQL.

HDFS : Hadoop Distributed File System
HDFS est un système de fichiers distribué, extensible et portable. Il permet de stocker de très gros
volumes de données sur un grand nombre de machines (nœuds).
Chaque cluster comporte un Namenode individuel faisant office de serveur principal.
Le Namenode de chaque cluster centralise toute la gestion des dossiers et des fichiers afin d’éviter
toute ambiguité.
Chaque nœud comporte un ou plusieurs Datanode auquel est assignée la tâche de gérer le stockage
associé au nœud. Les blocs sont cartographiés par le Namenode pour les Datanodes.
Cluster
File

HDFS : Hadoop Distributed File System
Exemple Exemple:
Le fichier data.txt (taille 150 Mo) est enregistré dans HDFS, il
est décomposé en grands blocs (par défaut 64Mo), chaque bloc
ayant un nom unique: blk_1, blk_2…
auquel est assignée la tâche de gérer le stockage associé au
nœud. Les blocs sont cartographiés par le Namenode pour les
Datanodes.

Traitement des big data
Il est difficile de traiter des big data de manière rapide et efficace sur des
systèmes traditionnels. Le modèle de programmation MapReduce est l'une
des solutions qui permet de traiter des big data.
MapReduce : Le modèle de programmation MapReduce est l’un des principaux
composants du framework Hadoop. Il est utilisé pour accéder aux données Big Data
stockées au sein du Hadoop File System (HDFS).

L’intérêt de MapReduce est de faciliter le traitement des données. Pour cela, les big
data, sont décomposés en plusieurs parties.
Ces morceaux de données sont traités en parallèle, sur les serveurs Hadoop.
Hadoop est capable d’exécuter des programmes MapReduce écrits dans divers langages :
Java, Python, C++…
Exemple un big data de 10 terabytes. Si l’on répartit le traitement sur un cluster Hadoop de
10 000 serveurs, chacun doit traiter environ 1 Gegabytes de données.
Le big data peut donc être traité beaucoup plus rapidement qu’avec un traitement séquentiel
traditionnel.

Principes de base
• Au cœur de MapReduce se trouvent deux fonctions, Map et Reduce, qui sont
séquencées l'une après l'autre.
• La fonction Map transforme les entrées du disque en paires <key,value>, les
traite et génère un autre ensemble de paires <key,value> intermédiaires en sortie.
• La fonction Reduce transforme également les entrées en paires <key,value> et
génère une des paires <key,value> en sortie.

Principes de base

Principes de base
Combine et Partition
Il existe deux étapes intermédiaires entre Map et Reduce. Ces deux étapes sont appelées Combine et
Partition.
Le processus Combine permet de réduire les données sur chaque mapper, dans une forme simplifiée.
Ceci permet de simplifier l’organisation.
Le processus Partition décide comment les données doivent être présentées au reducer.

Exemple d'exécution de MapReduce
Un système e-commerce, reçoit chaque jour un million de demandes de traitement (paiements). Un
tel volume de demandes peut contenir plusieurs exceptions de type « paiement refusé par une
passerelle de paiement », « article non disponible en stock », « adresse incorrecte », etc.
Un développeur décide d'analyser les logs des quatre derniers jours pour déterminer le nombre
d'occurrences des différentes exceptions.
L'objectif consiste à isoler les cas d'usage qui déclenchent le plus grand nombre d'exceptions et
de prendre des mesures de correction en conséquence.

Exemple d'exécution de MapReduce
Passerelle de paiement
Article non disponible en stock
Adresse incorrecte
Solde insuffisant
Solde insuffisant
Passerelle de paiement , 1
Article non disponible en stock, 1
Passerelle de paiement, 1
Adresse incorrecte, 1
Solde insuffisant, 1
Article non disponible en stock,1
Adresse incorrecte
Solde insuffisant
Solde insuffisant

Les Big data nécessitent un stockage et une gestion des données fortement
distribuées sur des clusters (serveurs, data centers, …).
• On distingue 2 stratégies de traitement des big data :
• Distribution des données (« scaling » des données)
On distribue les données sur un nombre important de serveurs afin de stocker de très
grands volumes de données. Généralement en double pour prévenir une panne.

Distribution des données

Les Big data nécessitent un stockage et une gestion des données fortement
distribuées sur des clusters (serveurs, data centers, …).
• On distingue 2 stratégies de traitement des big data :
• Distribution des traitements (« scaling » des traitements)
L’exécution des programmes est également distribuée : ils sont exécutés sur une ou
plusieurs machines du réseau.

Distribution des traitements

• Imaginez 5000 ordinateurs connectés entre eux formant un cluster . Chacun de ces
PC peut ressembler à ceci (4 CPU multi-cœurs, 1 To de RAM, 24 To de disques
rapides )

• La plateforme hadoop
Hadoop est un Framework libre, écrit en java, créé et distribué par la fondation
Apache, et destiné au traitement de données volumineuses. Son objectif est de
fournir un système de stockage et de traitement de données distribué, évolutif et
extensible. Il permet de traiter un grand nombre de types de données (y compris les
données non structurées).

Hadoop contient deux composants de base, HDFS et MapReduce. Les deux sont liés
au calcul distribué comme suit :
HDFS est le responsable de stockage des données. un système de fichier qui
répartit les données sur de nombreuses machines.
MapReduce est le cœur de Hadoop qui effectue le traitement parallèle grâce
aux deux fonctions Map et Reduce.

Comment fonctionne HDFS ?
Comme avec de nombreux systèmes, chaque fichier HDFS est découpé en blocs de
taille fixe.
Un bloc HDFS = 64Mo. Selon la taille d’un fichier, il lui faudra un certain nombre
de blocs. Sur HDFS, le dernier bloc d’un fichier fait la taille restante.

Comment fonctionne HDFS ?
Les blocs d’un même fichier ne sont pas forcément tous sur la même machine. Ils
sont copiés chacun sur différentes machines afin d’y accéder simultanément par
plusieurs processus.
Par défaut, chaque bloc est copié sur 3 machines différentes (c’est configurable).
Cette réplication des blocs sur plusieurs machines permet aussi de se prémunir
contre les pannes. Chaque fichier se trouve donc en plusieurs exemplaires et à
différents endroits

Organisation des machines pour HDFS
Un cluster HDFS est constitué de machines jouant différents rôles exclusifs entre eux :
L’une des machines est le maître HDFS, appelé le namenode. Cette machine contient
tous les noms et blocs des fichiers, comme un gros annuaire téléphonique.
Une autre machine est le secondary namenode, une sorte de namenode de secours,
qui enregistre des sauvegardes de l’annuaire à intervalles réguliers.
Toutes les autres machines sont des datanodes. Elles stockent les blocs du contenu
des fichiers

Le namenode sait à la fois :
Sur quels blocs sont contenus les fichiers,
Sur quels datanodes se trouvent les blocs voulus.
On appelle cela les metadata.
Inconvénient majeur : panne du namenode = mort de HDFS, c’est pour éviter ça qu’il y
a le secondary namenode. Il archive les metadata, par exemple toutes les heures.

API pour utiliser HDFS en Java
Hadoop propose une API Java complète pour accéder aux fichiers de HDFS. Elle repose sur deux classes
principales :
 FileSystem représente l’arbre des fichiers (file system). Cette classe permet de copier des fichiers locaux
vers HDFS (et inversement), renommer, créer et supprimer des fichiers et des dossiers.
 FileStatus gère les informations d’un fichier ou dossier :
•Taille avec getLen()
•Nature avec isDirectory() et isFile()
Ces deux classes ont besoin de connaître la configuration du cluster HDFS, à l’aide de la classe
Configuration. D’autre part, les noms complets des fichiers sont représentés par la classe Path

Quelques manipulations sur un fichier :
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.Path;
Configuration conf = new Configuration();
FileSystem fs = FileSystem.get(conf);
Path nomcomplet = new Path("/user/etudiant1", "bonjour.txt");
FileStatus infos = fs.getFileStatus(nomcomplet);
System.out.println(Long.toString(infos.getLen())+" octets");
fs.rename(nomcomplet, new Path("/user/etudiant1","salut.txt"));

Exemple 1: Afficher la liste des blocs d’un fichier
public class HDFSinfo {
public static void main(String[] args) throws IOException {
Path nomcomplet = new Path("apitest.txt");
FileStatus infos = fs.getFileStatus(nomcomplet);
BlockLocation[] blocks = fs.getFileBlockLocations(infos, 0, infos.getLen());
for (BlockLocation blocloc: blocks)
System.out.println(blocloc.toString());
} }

Exemple 2: Lecture d’un fichier texte
import java.io.*;
public class HDFSread {
FSDataInputStream inStream = fs.open(nomcomplet);
InputStreamReader isr = new InputStreamReader(inStream);
BufferedReader br = new BufferedReader(isr);
String line = br.readLine();
System.out.println(line);
inStream.close(); fs.close();
}}

Exemple 3: Créer un fichier texte
public class HDFSwrite {
if (! fs.exists(nomcomplet)) {
FSDataOutputStream outStream = fs.create(nomcomplet);
outStream.writeUTF("Bonjour tout le monde !");
outStream.close();
}
fs.close();
}}

• Algorithmes « MapReduce »
Exemples sur une liste d’articles possédant un prix :
• Calculer le montant total des ventes d’un article,
• Trouver l’article le plus cher,
• Calculer le prix moyen des articles.
Pour chacun de ces exemples, le problème peut s’écrire sous la forme de la composition
de deux fonctions :
• map : extraction/calcul d’une information sur chaque n-uplet,
• reduce : regroupement de ces informations.

Exemples sur une liste d’articles possédant un prix

Parallélisation de Map
La fonction map est par nature parallélisable, car les calculs sont indépendants.
Exemple, pour 4 éléments à traiter :
• valeur1 = FonctionM(element1)
Les quatre calculs peuvent se faire simultanément, par exemple sur 4 machines
différentes, à condition que les données y soient copiées.

Parallélisation de Reduce
La fonction reduce se parallélise partiellement, sous une forme hiérarchique, par
exemple :
• inter1 et 2 = FonctionR(valeur1, valeur2)
• inter3 et 4 = FonctionR(valeur3, valeur4)
• resultat = FonctionR(inter1 et 2, inter3 et 4)
Seuls les deux premiers calculs peuvent être faits simultanément. Le 3eme doit attendre.

• Qu’est-ce que YARN ?
YARN (Yet Another Resource Negociator) est un outil dans Hadoop permettant de
gérer des travaux (jobs) sur un cluster de machines.
YARN permet aux utilisateurs de lancer des jobs MapReduce sur des données
présentes dans HDFS, et de suivre leur avancement, récupérer les messages (logs)
affichés par les programmes.

• Qu’est-ce que YARN ?
Éventuellement YARN peut déplacer un processus d’une machine à l’autre en cas de
défaillance ou d’avancement jugé trop lent.
En fait, YARN est transparent pour l’utilisateur. On lance l’exécution d’un
programme MapReduce et YARN fait en sorte qu’il soit exécuté le plus rapidement
possible.

• Job MapReduce
Pour réaliser un job, il y a plusieurs points à connaître :
• Principes d’un job MapReduce dans Hadoop
• Programmation de la fonction Map
• Programmation de la fonction Reduce
• Programmation d’un job MapReduce qui appelle les deux fonctions
• Lancement du job et récupération des résultats

• Job MapReduce
Commençons d’abord avec le type des données échangées entre Map et Reduce.
Les données échangées entre Map et Reduce, et plus encore, dans la totalité du job
sont des paires (clé, valeur)
Exemple:
• Un fichier texte est un ensemble de (Nligne, ligne)
• Un fichier vente est ensemble de (Article, Prix)
Les deux fonctions Map et Reduce reçoivent des paires (clé, valeur) et émettent
d’autres paires, selon les besoins du programme.

• Job MapReduce
Généralement, les paires que reçoit Map sont constituées ainsi :
• La valeur de type text est l’une des lignes du fichier à traiter
• La clé de type integer est la position de cette ligne dans le fichier
YARN lance une instance de Map pour chaque ligne de chaque fichier des données
à traiter. Chaque instance traite la ligne qu’on lui a attribuée et produit des paires en
sortie.

• Job MapReduce
Schéma de Map
Les tâches MAP traitent chacune une paire et
produisent 0..n paires.
Il se peut que les mêmes clés et/ou valeurs
soient produites.

• Job MapReduce
Schéma de Reduce
La fonction Reduce reçoit une liste de paires en entrée. Ce sont les paires produites
par les instances de Map. Reduce peut produire un nombre quelconque de paires en
sortie, mais la plupart du temps, c’est une seule.
Par contre, le point crucial, c’est que les paires d’entrée traitées par une instance de
Reduce ont toutes la même clé.

• Job MapReduce
Schéma de Reduce
YARN lance une instance de Reduce pour chaque clé différente que les instances
de Map ont produit, et leur fournit uniquement les paires ayant la même clé. C’est
ce qui permet d’agréger les valeurs.
Généralement, Reduce doit faire un traitement sur les valeurs, comme additionner
toutes les valeurs entre elles, ou déterminer la plus grande des valeurs. . .

• Job MapReduce
Schéma de Reduce
Les tâches Reduce reçoivent une liste de paires
ayant toutes la même clé et produisent une paire qui
contient le résultat attendu.
Cette paire en sortie peut avoir la même clé que
celle de l’entrée.

• Job MapReduce
Exemple
Une entreprise de téléphonie veut calculer la durée totale des appels téléphoniques d’un abonné à
partir d’un fichier CSV contenant tous les appels de tous les abonnés (n° d’abonné, n° appelé, date,
durée d’appel). Chaque appel est enregistré dans une nouvelle ligne.

• Job MapReduce
Exemple
1. En entrée, on a le fichier des appels (1 appel par ligne)
2. Pour chaque ligne, YARN lance une instance de la fonction Map.
3. Chaque instance de Map reçoit une paire (NLig, ligne) et produit une paire (n° abonné, durée).
4. YARN envoie toutes les paires ayant la même clé, vers une seule instance de Reduce
5. Chaque instance de Reduce additionne toutes les valeurs des paires qu’elle reçoit et produit
une seule paire en sortie (n° abonné, durée totale)

• Job MapReduce
Exemple

• Job MapReduce
Exemple
En réalité, il n’y a pas une instance de Map par ligne de données. C’est la vision qu’on
peut avoir en tant que programmeur, mais ça conduirait à un nombre gigantesque
d’instances pour traiter un énorme fichier.
YARN instancie un seul « Mappeur » par machine esclave et appelle sa méthode map à
plusieurs reprises pour traiter les données séquentiellement.

• Job MapReduce
La programmation d’un job MapReduce en Java
Pour programmer un Job en Java, il faut définir trois classes :
Une sous-classe de Mapper. Elle contient une seule méthode, appelée map qui reçoit
une paire clé-valeur en paramètre. Elle génère un nombre quelconque de paires.
Une sous-classe de Reducer. Elle contient également une seule méthode, appelée
reduce qui reçoit une liste de paires en paramètre. Elle génère une seule paire.
Une classe générale qui crée un Job faisant référence aux deux précédentes classes.

• Job MapReduce
Squelette de Mapper
public class TraitementMapper extends Mapper<TypCleE,TypValE, TypCleI,TypValI> {
@Override public void map(TypCleE cleE, TypValE valE, Context context) throws Exception {
/** traitement: cleI = ..., valI = ... **/
TypCleI cleI = new TypCleI(...);
TypValI valI = new TypValI(...);
context.write(cleI, valI);
}}

• Job MapReduce
Squelette de Mapper
Explications
La classe Mapper est une classe générique, paramétrée par 4 types. Ils sont spéciaux,
afin de transmettre efficacement des données entre les différents ordinateurs du cluster.

• Job MapReduce
Types de données MapReduce
Les types Text, IntWritable. . . sont des implémentations d’une
interface appelée Writable. Cette interface comprend :
• Un constructeur. On peut mettre la valeur initiale en paramètre.
IntWritable val = new IntWritable(34);
• Un modificateur : void set(nouvelle valeur);
val.set(35);
• Un accesseur : type get()
int v = val.get();

• Job MapReduce
Interface Writable
Elle permet la sérialisation, c’est à dire l’écriture d’une structure de données sous
forme d’octets et l’opération inverse, la désérialisation qui permet de reconstruire une
structure de données à partir d’octets.
On ne peut pas simplement échanger les octets internes car les machines du cluster ne
sont pas obligatoirement toutes pareilles : nombre d’octets, ordre des octets.
. .

• Job MapReduce
Squelette de Reducer
public class TraitementReducer extends Reducer<TypCleI,TypValI, TypCleS,TypValS> {
@Override public void reduce(TypCleI cleI, Iterable<TypValI> listeI, Context context) throws
Exception {
TypCleS cleS = new TypCleS();
TypValS valS = new TypValS();
for (TypValI val: listeI) {
/** traitement: cleS.set(...), valS.set(...) **/
}
context.write(cleS, valS);
}}

• Job MapReduce
Explications
Comme pour map, la classe Reducer est une classe générique paramétrée par les types
des clés et des valeurs à manipuler. Ce sont des Writable : Text, IntWritable. . .
La méthode reduce reçoit une collection de valeurs venant du Mapper. CleI et ValeursI
sont les clés et valeurs intermédiaires. Il faut itérer sur chacune pour produire la valeur
de sortie du réducteur.

• Job MapReduce
Remarque
Il est obligatoire que les types des clés TypCleI et valeurs d’entrée TypValI du
Reducer soient exactement les mêmes que les types des clés et valeurs de sortie du
Mapper. Si vous mettez des types différents, ça passera à la compilation mais plantera
à l’exécution.

• Job MapReduce
Squelette de la classe principale
La classe principale est la classe qui crée et lance le job MapReduce
public class TraitementDriver extends Configured implements Tool {
public static void main(String[] args) throws Exception {
if (args.length != 2)
System.exit(-1);
TraitementDriver traitement = new TraitementDriver();
System.exit(ToolRunner.run(traitement, args) );
}
public int run(String[] args) throws Exception {
/* voir transparent suivant */
}}

• Job MapReduce
La méthode run
public int run(String[] args) throws Exception {
Configuration conf = this.getConf();
Job job = Job.getInstance(conf, "traitement");
job.setJarByClass(TraitementDriver.class);
job.setMapperClass(TraitementMapper.class);
job.setReducerClass(TraitementReducer.class);
FileInputFormat.addInputPath(job, new Path(args[0]));
FileOutputFormat.setOutputPath(job, new Path(args[1]));
boolean success = job.waitForCompletion(true);
return success ? 0 : 1;
}

• Job MapReduce
Explications
La méthode run est chargée de créer et lancer un Job. Elle permet de :
1. Obtenir une instance de Configuration. Elle contient les options telles que les
formats des fichiers, leur nom HDFS complet, leur codec de compression. . .
2. Créer un Job, lui indiquer les classes concernées : mapper et reducer.
3. Fournir les noms complets des fichiers à traiter et à produire.
4. Indiquer les types des clés et valeurs. Par défaut, ce sont des Text.
5. Attendre la fin du job et retourner un code d’erreur

• Job MapReduce
Explications
Spécification des entrées
Les lignes suivantes spécifient ce qu’on veut traiter :
• FileInputFormat.addInputPath(job, new Path(args[0]));
• job.setInputFormatClass(TextInputFormat.class);
La première ligne indique quels sont les fichiers HDFS à traiter, La seconde ligne indique le
type de contenu de ces fichiers.

• Job MapReduce
Explications
Fichiers d’entrée
Cette instruction indique où prendre les fichiers à traiter :
FileInputFormat.addInputPath(job, new path("NOMCOMPLET"));
C’est un appel à une méthode statique dans la classe FileInputFormat.
Si le chemin fourni est un dossier, alors tous ses fichiers sont employés, Si les fichiers
trouvés sont compressés (extensions .gz, .bz2, .lzo. . . ), ils sont automatiquement
décompressés.

• Job MapReduce
Explications
Format des données d’entrée
L'instruction suivante, spécifie le type des fichiers à lire et implicitement, les clés et les valeurs
rencontrées :
job.setInputFormatClass(TextInputFormat.class);
Important: les types des clés et valeurs du Mapper doivent coïncider avec la classe indiquée pour le
fichier. Ici, la classe TextInputFormat est une sous-classe de FileInputFormat<LongWritable,Text>.
Donc il faut écrire:
public class TraitementMapper extends Mapper<LongWritable,Text, TypCleI,TypValI> {
@Override public void map(LongWritable cleE, Text valE, ... )

• Job MapReduce
Explications
Autres formats d’entrée
Il existe d’autres formats d’entrée, comme KeyValueTextInputFormat qui est capable de lire des
fichiers déjà au format (clé, valeur) :
Les lignes se finissent par un 'n'. Chaque ligne est un couple (clé, valeur)
Tabulation 't' qui sépare la clé et la valeur ces deux informations sont des Text
job.setInputFormatClass(KeyValueTextInputFormat.class);
public class TraitementMapper
extends Mapper<Text,Text, TypCleI,TypValI>

• Job MapReduce
Explications
Format des données intermédiaires
Les types des clés et valeurs sortant du mapper et allant au reducer, notés TypCleI et TypValI, sont
définis par les instructions suivantes :
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(IntWritable.class);
Elles forcent la définition du mapper et du reducer ainsi :
class TraitementMapper extends Mapper<..., Text, IntWritable>
class TraitementReducer extends Reducer<Text, IntWritable,...>
Elles sont absolument obligatoires quand ce ne sont pas les types par défaut, ClassCastException lors du
lancement du reducer sinon

• Job MapReduce
Explications
Format des données de sortie
Les instructions qui spécifient le format du fichier de sortie sont :
job.setOutputFormatClass(TextOutputFormat.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(DoubleWritable.class);
Ce doivent être les types de sortie du Reducer :
class TraitementReducer extends Reducer<..., Text, DoubleWritable>
La classe TextOutputFormat<K,V> est paramétrée par les types des clés et des valeurs. Par défaut, ce
sont tous deux des Text. Il existe d’autres classes pour produire les données de sortie.

• Job MapReduce
Explications
Fichiers de sortie
Les résultats du job sont enregistrés dans des fichiers situés dans le dossier indiqué par :
FileOutputFormat.setOutputPath(job, new Path("DOSSIER"));
YARN enregistre un fichier par Reducer final. Leurs noms sont part-r-00000, part-r-00001,. . .
La classe Path possède plusieurs constructeurs qui permettent de concaténer des chemins :
Path sortie1 = new Path("/tmp", "MonAppli", "etape1");
Définit sortie1 valant /tmp/MonAppli/etape1

• Job MapReduce
Explications
Fichiers de sortie
Au lieu de récupérer un simple fichier, on peut afficher proprement le résultat final :
job.setOutputFormatClass(SequenceFileOutputFormat.class);
if (job.waitForCompletion(true)) {
SequenceFile.Reader.Option fichier =SequenceFile.Reader.file(new Path(sortie,"part-r-00000"));
SequenceFile.Reader reader =new SequenceFile.Reader(conf, fichier);
IntWritable annee = new IntWritable();
FloatWritable temperature = new FloatWritable();
while (reader.next(annee, temperature)) {
System.out.println(annee + " : " + temperature);}
reader.close(); }

Big_Data_Cours.pdf

Contenu connexe

Similaire à Big_Data_Cours.pdf

Big_Data_Cours.pdf