Chap 2

Chapitre 2
Big data : MapReduce
Big Data – 3TEL ENIT – Novembre 2017

Le problème des Big Data
Une seule machine n’est pas capable de traiter ou de stocker toutes les
données
La seule solution consiste à distribuer le traitement/stockage sur

plusieurs clusters
Qu’est ce qu’un Cluster ?

Que signifie Distribuer ? Et coment le faire ?
Quels sont les outils ?
Big Data – 3TEL 2 ENIT – Septembre 2018

Architectures parallèles
Machines contenant plusieurs unités de calcul
Machines multiprocesseur
Machines multicoeur
Processeurs graphiques (GPU)
Mémoire partagée
Mémoire distribuée
Disque partagé ou non
Hybride
Cluster de SMPs

Architecture à mémoire partagée
Bus d’interconnexion
CPU CPU CPU CPU
Mémoire partagée

Architecture à mémoire distribuée
Réseau d’interconnexion
CPU CPU CPU CPU
Mémoire Mémoire Mémoire Mémoire

Locale Locale Locale Locale

Architecture à disque partagé
CPU CPU CPU CPU
Mémoire Mémoire Mémoire Mémoire

Locale Locale Locale Locale
Système de partage de disque

Cluster de SMPs
CPU CPU CPU CPU CPU CPU CPU CPU
CPU CPU CPU CPU CPU CPU CPU CPU
4-way 4-way 4-way 4-way

SMP SMP SMP SMP

Cluster
• Grappe de PCs
• Ensemble de nœuds interconnectés par un réseau de
communication à haut débit
• Architecture de déploiement de services sur des Intranets
• Spécificités
Homogénéité
Forte localité
Confiance
Faible coût
Architecture du I-Cluster (INRIA / Lab. ID-IMAG)

Datacenter
Centre de données
Site physique sur lequel se trouvent regroupés des
équipements constituants du système d’information de
l’entreprise
Serveurs
Baies de stockage
Equipements réseaux

Supercomputer vs. Datacenter
Hopper Datacenter2
# Noeuds 6384 1000 à 10000
# CPU/noeud 2x12 cores ~2x6 cores
Mémoire/noeud 32-64GB ~48-128GB
Stockage ~4 PB 120-480 PB
Interconnection ~ 66.4 Gbps ~10Gbps
2http://blog.cloudera.com/blog/2013/08/how-to-select-the-right-hardware-for-your-new-hadoop-cluster/

En conclusion
Un Centre de données
Orienté plus stockage que puissance de calcul
Mise à l’échelle avec des ordinateurs bon marché
Modèle Pay-as-you-go
Maintenant, comment programmer ces machines ?

Modèles de programmation

Modèles de programmation
Parallélisme de données
Données partitionnées sur P processeurs
Chaque processeur effectue le même traitement sur sa partition locale
Parallélisme de tâches
Chaque processeur effectue un traitement différent des autres
Données répliquées (et/ou partitionnées)
Parallélisme hybride
Combinaison des deux stratégies
Amélioration des performances et de la scalabilité
Autre possibilité
Utiliser du pipeline

Tâche 1 Données Tâche 1 Tâche 1 Tâche 1
Données Données Données
Tâche 2 Données Broadcast
Tâche 2 Tâche 2 Tâche 2
Tâche 3 Données Données Données Données
Mono-processeur
Broadcast
Broadcast
P0 P1 P2
Tâche 1 Données
Tâche 2 Données
Tâche 3 Données
P0 P1
Mono-processeur
Tâche 1 Tâche 2
P0 P1 P2
Données Données
P2
Données Données Données Tâche 3
Données
Synthèse
Communication
Synchronisation
Parallélisme hybride
Compromis entre communication et synchronisation
Équilibrage de charge
Statique ou dynamique

Données partitionnées vs. répliquées
BD BD
BD1
BD2 BD
BD3
BD BD BD
BD1 BD2 BD3
Site 1 Site 2 Site 3 Site 1 Site 2 Site 3

Partitionnement horizontal
id Nom @
1002 Anis [email protected]
id Nom @ 1003 Hela hela@@gmail.com
1002 Anis [email protected] 1004 Rami [email protected]
1003 Hela hela@@gmail.com Partition 1
1004 Rami [email protected]
1005 Ons [email protected]
1006 Amna [email protected]
Partition 2
id Nom @
1005 Ons [email protected]
1006 Amna [email protected]

Partitionnement vertical
id Nom photo
1002 Anis [BLOB]
1003 Hela [BLOB]
1004 Rami [BLOB]
1005 Ons [BLOB]
1006 Amna [BLOB]
Partition 1 Partition 2
id Nom id photo
1002 Anis 1002 [BLOB]
1003 Hela 1003 [BLOB]
1004 Rami 1004 [BLOB]
1005 Ons 1005 [BLOB]
1006 Amna 1006 [BLOB]
Systèmes distribués
Pourquoi distribuer ?
Système distribué
Composants sont logés dans différentes machines sur le réseau
Communication et coordination via le passage de messages
Machines autonomes (OS, CPU, RAM)
Nécessite un middleware (intergiciel : entre l’application et l’OS)
Système de fichiers distribué

Données stockées au niveau du serveur (centralisé/distribué)
Accès aux données transparent au client
 Comme si elles étaient stockées sur la machine du client
Architecture client-serveur

STOCKAGE DISTRIBUÉ

Hadoop HDFS
Le système de fichiers distribué Hadoop (HDFS) est un

système de fichiers distribué conçu pour fonctionner sur
du matériel de base.
Par rapport aux autres DFS, HDFS :
est hautement tolérant aux pannes et conçu pour être déployé
sur du matériel à faible coût.
fournit un accès à haut débit aux données d'application et
convient aux applications disposant de grands ensembles de
données.
assouplit quelques conditions POSIX pour permettre l'accès en
continu aux données du système de fichiers.

Architecture de HDFS
HDFS a une architecture maître / esclave.

Un cluster HDFS se compose
D'un seul NameNode
un serveur maître qui gère l'espace de noms du système de fichiers
et régule l'accès aux fichiers par les clients.
De plusieurs DataNodes
généralement un DataNode par nœud dans le cluster
gèrent le stockage associé aux nœuds sur lesquels ils s'exécutent.

HDFS expose un espace de noms de système de fichiers et permet

aux données utilisateur d'être stockées dans des fichiers.
En interne, un fichier est divisé en un ou plusieurs blocs et ces blocs
sont stockés dans un ensemble de DataNodes.
Le NameNode
exécute des opérations d'espace de noms de système de fichiers telles
que l'ouverture, la fermeture et le changement de nom des fichiers et des
répertoires.
détermine également le mappage des blocs aux DataNodes.
Les DataNodes
sont chargés de traiter les demandes de lecture et d'écriture des clients
du système de fichiers.
effectuent également la création, la suppression et la réplication de blocs
sur instruction du NameNode.


Le NameNode et le DataNode
Le NameNode et le DataNode sont des logiciels conçus pour

fonctionner sur des machines de base. Ces machines exécutent
généralement un système d'exploitation Linux.
HDFS est construit en utilisant le langage Java
Toute machine prenant en charge Java peut exécuter le logiciel
NameNode ou DataNode.
L'utilisation de Java signifie que HDFS peut être déployé sur un large
éventail de machines (portabilité).
Un déploiement standard comporte une machine dédiée qui exécute
uniquement le logiciel NameNode. Chacune des autres machines du
cluster exécute une instance du logiciel DataNode.
L'existence d'un seul NameNode dans un cluster simplifie grandement
l'architecture du système. Le NameNode est l'arbitre et le référentiel
pour toutes les métadonnées HDFS.
Le système est conçu de telle manière que les données utilisateur ne
circulent jamais dans le NameNode.

L'espace de noms du système de fichiers
HDFS prend en charge une organisation de fichiers hiérarchique

traditionnelle.
Un utilisateur ou une application peut créer des répertoires et stocker
des fichiers dans ces répertoires.
HDFS prend en charge les quotas utilisateur et les autorisations
d'accès.
HDFS ne prend pas en charge les liens.
Le NameNode maintient l'espace de noms du système de fichiers. Toute
modification apportée à l'espace de noms du système de fichiers ou à
ses propriétés est enregistrée par NameNode.
Une application peut spécifier le nombre de répliques d'un fichier qui doit
être géré par HDFS. Le nombre de copies d'un fichier est appelé le
facteur de réplication de ce fichier. Cette information est stockée par le
NameNode.

Réplication de données
HDFS stocke chaque fichier sous la forme d'une séquence de blocs.

Les blocs d'un fichier sont répliqués pour la tolérance aux pannes.
La taille de bloc et le facteur de réplication sont configurables par fichier.
Une application peut spécifier le nombre de répliques d'un fichier. Le
facteur de réplication peut être spécifié lors de la création du fichier et
peut être modifié ultérieurement. Les fichiers dans HDFS sont en
écriture unique (à l'exception de l'ajout et de la troncature) et ont un
seul éditeur à la fois.

Réplication de données
Le NameNode prend toutes les décisions concernant la réplication des

blocs.
Il reçoit périodiquement un signal de présence et un rapport de bloc de
chacun des DataNodes du cluster. La réception d'un signal de présence
implique que le DataNode fonctionne correctement.
Un Blockreport contient une liste de tous les blocs d'un DataNode.

Blocs de données
HDFS est conçu pour prendre en charge de très gros fichiers. Les
applications compatibles avec HDFS sont celles qui traitent de
grands ensembles de données.
Ces applications n'écrivent leurs données qu'une seule fois, mais
elles les lisent une ou plusieurs fois et exigent que ces lectures
soient satisfaites à des vitesses de streaming.
HDFS prend en charge la sémantique write-once-read-many sur les
fichiers.
Une taille de bloc typique utilisée par HDFS est de 128 Mo. Ainsi,
un fichier HDFS est découpé en blocs de 128 Mo et, si possible,
chaque fragment réside sur un DataNode différent.

CALCUL DISTRIBUÉ

Parallélisme de données : Modèle
Restreindre l’interface de programmation

Le système peut automatiser plus facilement
Exécuter une opération sur toutes les données
Sans tenir compte de l’emplacement de l’exécution
(l’ordonnanceur s’en occupe)
Possibilité de dupliquer l’exécution sur deux nœuds
L’exemple le plus répandu : MapReduce

MapReduce
Le paradigme (modèle) de programmation le

plus populaire pour les applications data-
intensive sur les clusters
Publié par Google en 2004
traite 20 PB de données / jour
Popularisé par le projet open-source Hadoop
40 000 noeuds chez Yahoo!
70 PB chez Facebook

MapReduce : Modèle de programmation
Une tâche simple qu’on veut executer :

On dispose d’un fichier texte très volumineux
On veut compter le nombre d’occurences
(apparitions) de chaque mot dans ce fichier
Exemple d’application :
Analyser le fichier log d’un serveur web pour trouver
les URLs les plus populaires

Tâche : Word Count
Calculer les occurences des mots

words(log.txt) | sort | uniq -c
La fonction words génère à partir du fichier en entrée
tous les mots qu’il contient, un mot par ligne
Problème : la mémoire ne peut pas contenir le fichier
en entrée, mais peut contenir toutes les paires
<word, count>
Solution : partitionner le fichier pour le traiter
parallélisme de données
MapReduce

MapReduce : utilisation
3 étapes de MapReduce
Lire les données séquentiellement
Map:
Extraire les informations utiles
Grouper par clé : trier et mêler
Reduce :
Aggréger, résumer, filtrer ou transformer
Produire le résultat

MapReduce : Modèle de programmation
Type de données en entrée : clé-valeur (key-value)
Fonction Map :
(Kin, Vin)  list(Kinter, Vinter)
Fonction Reduce :
(Kinter, list(Vinter))  list(Kout, Vout)

Word Count
def mapper(line):
foreach word in line.split():
output(word, 1)
def reducer(word, values):

output(word, sum(values))

Exécution de Word Count
Input Map Shuffle & Sort Reduce Output
the, 1
brown, 1
the quick brown, 2
brown fox Map fox, 1
fox, 2
Reduce how, 1
the, 1 now, 1
fox, 1 the, 3
the, 1
the fox ate
the mouse Map
quick, 1
how, 1
ate, 1
now, 1 ate, 1
brown, 1
cow, 1
mouse, 1 Reduce mouse, 1
how now
brown Map cow, 1 quick, 1
cow

Word Count : Exécution
Soumettre un Job
JobTracker
Diviser le travail Affecte les tâches aux

automatiquement noeuds d’exécution
Map Map Map
the fox how now

the quick ate the brown
brown mouse cow
fox

Récupération après fautes
Si une tâche plante :
Réessayer sur un autre noeud
Si la même tâche plante plusieurs fois, arrêter le job
Map Map Map
the quick the fox how now

brown ate the brown
fox mouse cow
Nécessite que le code utilisateur soit

déterministe
Si un noeud plante:
Relancer ses tâches courates sur un autre noeud
Relancer les tâches dont les résultats sont perdus
Map Map Map
the quick the fox how now

brown ate the brown
fox mouse cow

Si une tâche avance lentement (straggler):

Lancer une seconde copie de la tâche sur un autre
noeud
Prendre le résultat de celle qui fini avant
Map Map Map
the quick the quick the fox how now

brown brown ate the brown
fox fox mouse cow

Exemples d’Applications

1. Recherche
Entrée : enregistrements (numLigne, ligne)

Sortie : lignes qui correspondent à un critère donné
Map:
if(ligne correspond au critère):
output(line)
Reduce: fonction identité
– Alternativement: on n’a pas besoin de reducer

2. Trie
Entrée : enregistrements de type (clé, valeur)

Sortie : des enregistrements triés par clé
Map: fonction identité
(k, v) (k, _) ant, bee
Map
Reduce [A-M]
Reduce: fonction identité zebra aardvark
ant
(k’, _)  (k’, “”) cow bee
cow
Map elephant
pig
Astuce: choisir la fonction de Reduce [N-Z]
aardvark,
elephant pig
partitionnement p telque sheep
Map sheep, yak yak
clé1 < clé2 => p(clé1) < p(clé2) zebra
Mapper vs. Reducer

3. Index Inversé
Entrée : enregistrements (nomFichier, text)
Sortie : liste des fichiers contenant chaque mot
hamlet.txt to, hamlet.txt
to be or be, hamlet.txt
not to be or, hamlet.txt afraid, (12th.txt)
not, hamlet.txt be, (12th.txt, hamlet.txt)
be, hamlet.txt greatness, (12th.txt)
not, (12th.txt, hamlet.txt)
of, (12th.txt)
12th.txt be, 12th.txt or, (hamlet.txt)
not, 12th.txt to, (hamlet.txt)
be not afraid, 12th.txt
afraid of of, 12th.txt
greatness greatness, 12th.txt

3. Index Inversé

Sortie : liste des fichiers contenant chaque mot
Map:
foreach mot in text.split():
output(mot, nomFichier)
Reduce:
def reduce(mot, nomFichiers):
output(mot, unique(nomFichiers))

4. Mots les plus populaires

Sortie : les 100 mots qui apparaissent le plus dans tous les
fichiers
Solution à 2 niveaux :
– Job 1:
• Utiliser l’inversion d’index, pour obtenir des
enregistrements de type (mot, liste(nomFichier))
– Job 2:
• Mapper chaque (mot, liste(nomFichier)) à la paire
(occurence, mot)
• Trier ces enregistrement par la clé occurence

Constats
En pratique, on a besoin de composer
La plus part des applications réelles nécessitent
plusieurs blocks MR
Google indexing pipeline: 21 blocks
Analytics queries (e.g. sessions, top K): 2-5 blocks
Iterative algorithms (e.g. PageRank): 10’s of blocks
Problèmes: programmabilité & performance

Spark
Traite les 2 problèmes

Programmabilité
Transformations en collections
5-10x moins de code que Hadoop
Langages : Scala, Java and Python
Performance
In-memory computing
Optimisation automatique sur les operateurs

Word count : Hadoop
public class WordCount {
public static class TokenizerMapper public static class IntSumReducer
extends
extends Mapper<Object, Text, Text,
IntWritable>{ Reducer<Text,IntWritable,Text,IntWritable> {
private IntWritable result = new IntWritable();
private final static IntWritable one = new
IntWritable(1);
public void reduce(Text key,
private Text word = new Text();
Iterable<IntWritable> values,
public void map(Object key, Text value, Context Context context ) throws IOException,
context ) throws IOException, InterruptedException
InterruptedException {
{
int sum = 0;
StringTokenizer itr = new for (IntWritable val : values) {
StringTokenizer(value.toString());
sum += val.get();
while (itr.hasMoreTokens()) { }
word.set(itr.nextToken()); result.set(sum);
context.write(word, one); context.write(key, result);
} } } } }

Word count : Hadoop
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);
}
}

Word count : Spark
val file = spark.textFile(“hdfs://...”)
val counts = file.flatMap(line => line.split(“ ”))

.map(word => (word, 1))
.reduceByKey(_ + _)
counts.save(“out.txt”)

Spark : Performance
Algorithmes iteratifs
K-means Clustering
121 Hadoop MR
4.1 Spark
0 50 100 150 sec
Logistic Regression
80 Hadoop MR
0.96 Spark
0 50 100 sec

Spark : Concepts
Resilient distributed datasets (RDDs)
Collections d’objets Immutables et partitionnés
Peut être mis en cache dans la mémoire pour accélérer l’accés
Opérations sur RDDs
Transformations : construire de nouvelles RDDs
Actions : calculer des résultats
Restricted shared variables
Broadcast, accumulateurs

Example : Log Mining
Charger les messages d’erreur du fichier log dans
la memoire, puis chercher de motifs particuliers.
BaseTransformed
RDD Cache 1
lines = spark.textFile(“hdfs://...”) RDD
Worker
results
errors = lines.filter(_.startsWith(“ERROR”))
messages = errors.map(_.split(‘\t’)(2)) tasks Block 1
Driver
messages.cache()
Action
messages.filter(_.contains(“access”)).count
messages.filter(_.contains(“right”)).count Cache 2
Worker
. . .
Cache 3
Resultat: recherche dans 1 TB Block 2
Worker
on-memory : 7 sec
on-disk : 170 sec
Block 3

Recuperation après pannes
RDDs permettent de faire le suivi du chainage afin de reconstruire les
partitions perdues.
Ex:
messages = textFile(...).filter(_.startsWith(“ERROR”))
.map(_.split(‘\t’)(2))
HDFS File Filtered RDD Mapped RDD

filter map
(func = _.contains(...)) (func = _.split(...))

Chap 2

Transféré par

Droits d'auteur :

Formats disponibles

Chap 2

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chap 2

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre 2

Big data : MapReduce

Big Data – 3TEL ENIT – Novembre 2017

La seule solution consiste à distribuer le traitement/stockage sur

Qu’est ce qu’un Cluster ?

Big Data – 3TEL 2 ENIT – Septembre 2018

Big Data – 3TEL 3 ENIT – Septembre 2018

CPU CPU CPU CPU

Big Data – 3TEL 4 ENIT – Septembre 2018

CPU CPU CPU CPU

Mémoire Mémoire Mémoire Mémoire

Big Data – 3TEL 5 ENIT – Septembre 2018

CPU CPU CPU CPU

Mémoire Mémoire Mémoire Mémoire

Système de partage de disque

Big Data – 3TEL 6 ENIT – Septembre 2018

CPU CPU CPU CPU CPU CPU CPU CPU

CPU CPU CPU CPU CPU CPU CPU CPU

4-way 4-way 4-way 4-way

Big Data – 3TEL 7 ENIT – Septembre 2018

Architecture du I-Cluster (INRIA / Lab. ID-IMAG)

Big Data – 3TEL 8 ENIT – Septembre 2018

Big Data – 3TEL 9 ENIT – Septembre 2018

# Noeuds 6384 1000 à 10000

# CPU/noeud 2x12 cores ~2x6 cores

Mémoire/noeud 32-64GB ~48-128GB

Interconnection ~ 66.4 Gbps ~10Gbps

Big Data – 3TEL 10 ENIT – Septembre 2018

Maintenant, comment programmer ces machines ?

Big Data – 3TEL 11 ENIT – Septembre 2018

Big Data – 3TEL 12 ENIT – Septembre 2018

Tâche 1 Données Tâche 1 Tâche 1 Tâche 1

Données Données Données

Tâche 2 Données Broadcast

Tâche 2 Tâche 2 Tâche 2

Tâche 3 Données Données Données Données

Tâche 3 Tâche 3 Tâche 3

Données Données Données

Big Data – 3TEL 15 ENIT – Septembre 2018

Big Data – 3TEL 16 ENIT – Septembre 2018

Big Data – 3TEL 17 ENIT – Septembre 2018

Système de fichiers distribué

Big Data – 3TEL 19 ENIT – Septembre 2018

Big Data – 3TEL 20 ENIT – Septembre 2018

Le système de fichiers distribué Hadoop (HDFS) est un

Big Data – 3TEL 21 ENIT – Septembre 2018

HDFS a une architecture maître / esclave.

Big Data – 3TEL 22 ENIT – Septembre 2018

HDFS expose un espace de noms de système de fichiers et permet

Big Data – 3TEL 23 ENIT – Septembre 2018

Big Data – 3TEL 24 ENIT – Septembre 2018

Le NameNode et le DataNode sont des logiciels conçus pour

Big Data – 3TEL 25 ENIT – Septembre 2018

HDFS prend en charge une organisation de fichiers hiérarchique

Big Data – 3TEL 26 ENIT – Septembre 2018

HDFS stocke chaque fichier sous la forme d'une séquence de blocs.

Big Data – 3TEL 27 ENIT – Septembre 2018

Le NameNode prend toutes les décisions concernant la réplication des

Big Data – 3TEL 28 ENIT – Septembre 2018