Chapitre III : MapReduce

PR NAOUFEL KRAIEM

Plan

MapReduce Design Patterns MapReduce

MapReduce

Imaginons le problème suivant :

Contexte : une chaîne de magasins dispersés à travers le monde

Objectif : calculer le total des ventes par magasin

Supposons que toutes les ventes sont stockées dans un « grand livre » sous la forme suivante :

Date

Ville

2016-01-01

London

2016-01-01

2016-01-02

…

Miami

…

Produit

Clothes

Music

Clothes

…

Prix

25.99

12.15

50.00

…

MapReduce

Solutions traditionnelles :

Pour chaque entrée, saisir la ville et le prix de vente. Si on trouve une entrée avec une ville déjà saisie, on les regroupe en faisant la somme des ventes. Méthode trop lente et peu efficace!

Dans un environnement de calcul traditionnel, on utilise généralement des Hashtables, sous forme de : Clef, Valeur Dans ce cas, la clef serait la ville, et la valeur le total des ventes

Date

Ville

Produit

2016-01-01

London

Clothes

2016-01-01

Miami

Music

2016-01-02

New York Toys

2016-01-02

Miami

Clothes

…

Prix

25.99

12.15

3,10

50.00

…

Clé

London

Miami

Valeur

25,99

62,15

New York

3,10

MapReduce

Si on utilise les hashtables sur 1To ?  Taille de la table => Problème de mémoire  Traitement séquentiel => temps de traitement trop long  Ça peut marcher quand même!

Autres solutions : MapReduce ! Moyen plus efficace et plus rapide pour traiter les données Au lieu d’avoir une seule « personne » qui parcourt le livre, on recrute plusieurs ?

MapReduce : Présentation (1/4)

•

Pour exécuter un problème large de manière distribuée, il faut pouvoir découper le problème en plusieurs problèmes de taille réduite à exécuter sur chaque machine du cluster (stratégie algorithmique dite du divide and conquer / diviser pour régner).

• De multiples approches existent et ont existé pour cette division d'un problème

plusieurs « sous-tâches ».

• MapReduce est un paradigme (un modèle) visant à généraliser les approches existantes

pour produire une approche unique applicable à tous les problèmes.

• MapReduce existait déjà depuis longtemps, notamment dans les langages

fonctionnels (Lisp, Scheme), mais la présentation du paradigme sous une forme « rigoureuse », généralisable à tous les problèmes et orientée calcul distribué est attribuable à un whitepaper issu du département de recherche de Google publié en 2004 (« MapReduce: Simplified Data Processing on Large Clusters »).

COURS BIG DATA - 2019

MapReduce : Présentation (2/4)

MapReduce définit deux opérations distinctes à effectuer sur les données d'entrée:

• La première, MAP, va transformer les données d'entrée en une série de couples clef/valeur. Elle va regrouper les données en les associant à des clefs, choisies de telle sorte que les couples clef/valeur aient un sens par rapport au problème à résoudre. Par ailleurs, cette opération doit être parallélisable: on doit pouvoir découper faire exécuter les données d'entrée en plusieurs fragments, et l'opération MAP à chaque machine du cluster sur un fragment distinct.

• La seconde, REDUCE, va appliquer un traitement à toutes les valeurs de chacune des clefs distinctes produite par l'opération MAP. Au terme de l'opération REDUCE, on aura un résultat pour chacune des clefs distinctes. Ici, on attribuera à chacune des machines du cluster une des clefs uniques produites par MAP, en lui donnant la liste des valeurs associées à la clef. Chacune des machines effectuera alors l'opération REDUCE pour cette clef.

COURS BIG DATA - 2019

MapReduce : Présentation (3/4)

On distingue donc 4 étapes distinctes dans un traitement MapReduce:

• Découper (split) les données d'entrée en plusieurs fragments.

• Mapper chacun de ces fragments pour obtenir des couples (clef ; valeur).

• Grouper (shuffle) ces couples (clef ; valeur) par clef.

• Réduire (reduce) les groupes indexés par clef en une forme finale, avec une

valeur pour chacune des clefs distinctes.

En modélisant le problème à résoudre de la sorte, on le rend parallélisable – chacune de ces tâches à l'exception de la première seront effectuées de manière distribuée.

COURS BIG DATA - 2019

MapReduce : Présentation (4/4)

Pour résoudre un problème via la méthodologie MapReduce avec Hadoop, on devra donc:

• Choisir une manière de découper les données d'entrée de telle sorte que

l'opération MAP soit parallélisable.

• Définir quelle CLEF utiliser pour notre problème.

• Écrire le programme pour l'opération MAP.

• Écrire le programme pour l'opération REDUCE..

… et Hadoop se chargera du reste (problématiques calcul distribué, groupement par clef distincte entre MAP et REDUCE, etc.).

COURS BIG DATA - 2019

MapReduce : Exemple concret (1/8)

•

Imaginons qu'on nous donne un texte écrit en langue Française. On souhaite déterminer pour un travail de recherche quels sont les mots les plus utilisés au sein de ce texte (exemple Hadoop très répandu).

•

Ici, nos données d'entrée sont constituées du contenu du texte.

• Première étape: déterminer une manière de découper (split) les données d'entrée pour que chacune des machines puisse travailler sur une partie du texte.

• Notre problème est ici très simple – on peut par exemple décider de découper les données d'entrée ligne par ligne. Chacune des lignes du texte sera un fragment de nos données d'entrée.

COURS BIG DATA - 2019

MapReduce : Exemple concret (2/8)

• Nos données d'entrée (le texte):

Celui qui croyait au ciel Celui qui n'y croyait pas […] Fou qui fait le délicat Fou qui songe à ses querelles

(Louis Aragon, La rose et le Réséda, 1943, fragment)

• Pour simplifier les choses, on va avant le découpage supprimer toute ponctuation et tous les caractères accentués. On va également passer l'intégralité du texte en minuscules.

COURS BIG DATA - 2019

MapReduce : Exemple concret (3/8)

• Nos données d'entrée (le texte):

celui qui croyait au ciel

celui qui ny croyait pas

fou qui fait le delicat

fou qui songe a ses querelles

• … on obtient 4 fragments depuis nos données d'entrée.

COURS BIG DATA - 2019

MapReduce : Exemple concret (4/8)

• On doit désormais déterminer la clef à utiliser pour notre opération

MAP, et écrire le code de l'opération MAP elle-même.

• Puisqu'on s'intéresse aux occurrences des mots dans le texte, et qu'à terme on aura après l'opération REDUCE un résultat pour chacune des clefs distinctes, la clef qui s'impose logiquement dans notre cas est: le mot-lui même.

• Quand à notre opération MAP, elle sera elle aussi très simple: on va simplement parcourir le fragment qui nous est fourni et, pour chacun des mots, générer le couple clef/valeur: (MOT ; 1). La valeur indique ici l’occurrence pour cette clef - puisqu'on a croisé le mot une fois, on donne la valeur « 1 ».

COURS BIG DATA - 2019

MapReduce : Exemple concret (5/8)

• Le code de notre opération MAP sera donc (ici en pseudo code):

POUR MOT dans LIGNE, FAIRE : GENERER COUPLE (MOT; 1)

• Pour chacun de nos fragments, les couples (clef; valeur) générés seront

donc:

celui qui croyait au ciel

(celui;1) (qui;1) (croyait;1) (au;1) (ciel;1)

celui qui ny croyait pas

(celui;1) (qui;1) (ny;1) (croyait;1) (pas;1)

fou qui fait le delicat

(fou;1) (qui;1) (fait;1) (le;1) (delicat;1)

fou qui songe a ses querelles

(fou;1) (qui;1) (songe;1) (a;1) (ses;1) (querelles;1)

Cours Big Data - 2019

MapReduce : Exemple concret (6/8)

• Une fois notre opération MAP effectuée (de manière distribuée),

Hadoop groupera (shuffle) tous les couples par clef commune.

• Cette opération est effectuée automatiquement par Hadoop. Elle est, là aussi, effectuée de manière distribuée en utilisant un algorithme de tri distribué, de manière récursive. Après son exécution, on obtiendra les 15 groupes suivants:

(celui;1) (celui;1)

(fou;1) (fou;1)

(fait;1)

(le;1)

(qui;1) (qui;1) (qui;1) (qui;1)

(delicat;1)

(songe;1)

(croyait;1) (croyait;1)

(a;1)

(ses;1)

(au;1)

(ciel;1)

(ny;1)

(pas;1)

(querelles;1)

Cours Big Data - 2019

MapReduce : Exemple concret (7/8)

•

Il nous reste à créer notre opération REDUCE, qui sera appelée pour chacun des groupes/clef distincte.

• Dans notre cas, elle va simplement consister à additionner toutes les

valeurs liées à la clef spécifiée:

TOTAL=0 POUR COUPLE dans GROUPE, FAIRE:

TOTAL=TOTAL+1

RENVOYER TOTAL

Cours Big Data - 2019

MapReduce : Exemple concret (8/8)

• Une fois l'opération REDUCE effectuée, on obtiendra donc une valeur unique pour chaque clef distincte. En l’occurrence, notre résultat sera:

qui : 4 celui : 2 croyait : 2 fou : 2 au : 1 ciel : 1 ny : 1 pas : 1 fait : 1 […]

•On constate que le mot le plus utilisé dans notre texte est « qui », avec 4 occurrences, suivi de « celui », « croyait » et « fou », avec 2 occurrences chacun.

Cours Big Data - 2019

MapReduce : Exemple concret - Conclusion

• Notre exemple est évidemment trivial, et son exécution aurait été instantanée même sur une machine unique, mais il est d'ores et déjà utile: on pourrait tout à fait utiliser les mêmes implémentations de MAP et REDUCE sur l'intégralité des textes d'une bibliothèque Française, et obtenir ainsi un bon échantillon des mots les plus utilisés dans la langue Française.

• L’intérêt du modèle MapReduce est qu'il nous suffit de développer les deux opérations réellement importantes du et de bénéficier traitement: MAP et automatiquement de la possibilité d'effectuer le traitement sur un nombre variable de machines de manière distribuée.

REDUCE,

Cours Big Data - 2019

MapReduce : Schéma général

Cours Big Data - 2019

MapReduce : Schéma général

Cours Big Data - 2019

Posté par Mirko Krivanek : « What Is MapReduce? », credit @Tgrall http://www.datasciencecentral.com/forum/topics/what-is-map-reduce

MapReduce : Exemple – Statistiques web

• Un autre exemple: on souhaite compter le nombre de visiteurs sur chacune des pages d'un site Internet. On dispose des fichiers de logs sous la forme suivante:

/index.html [19/05/2017:18:45:03 +0200] /contact.html [19/05/2017:18:46:15 +0200] /news.php?id=5 [24/05/2017:18:13:02 +0200] /news.php?id=4 [24/05/2017:18:13:12 +0200] /news.php?id=18 [24/05/2017:18:14:31 +0200] ...etc...

•

Ici, notre clef sera par exemple l'URL d’accès à la page, et nos opérations MAP et REDUCE seront exactement les mêmes que celles qui viennent d'être présentées: on obtiendra ainsi le nombre de vue pour chaque page distincte du site.

COURS BIG DATA - 2019

MapReduce : Exercice – Graphe social (1/8)

• Un autre exemple: on administre un réseau social comportant des

millions d'utilisateurs.

• Pour chaque utilisateur, on a dans notre base de données la liste des

utilisateurs qui sont ses amis sur le réseau (via une requête SQL).

• On souhaite afficher quand un utilisateur va sur la page d'un autre

utilisateur une indication « Vous avez N amis en commun ».

• On ne peut pas se permettre d'effectuer une série de requêtes SQL à chaque fois que la page est accédée (trop lourd en traitement). On va donc développer des programmes MAP et REDUCE pour cette opération et exécuter le traitement toutes les nuits sur notre base de données, en stockant le résultat dans une nouvelle table.

COURS BIG DATA - 2019

MapReduce : Exercice – Graphe social (2/8)

•

Ici, nos données d'entrée sous la forme Utilisateur =>Amis:

A => B, C, D B => A, C, D, E C => A, B, D, E D => A, B, C, E E => B, C, D

• Puisqu'on est intéressé par l'information « amis en commun entre deux utilisateurs » et qu'on aura à terme une valeur par clef, on va choisir pour clef la concaténation entre deux utilisateurs. Par exemple, la clef « A-B » désignera « les amis en communs des utilisateurs A et B».

• On peut segmenter les données d'entrée là aussi par ligne.

COURS BIG DATA - 2019

MapReduce : Exercice – Graphe social (3/8)

• Notre opération MAP va se contenter de prendre la liste des amis fournie en entrée, et va générer toutes les clefs distinctes possibles à partir de cette liste. La valeur sera simplement la liste d'amis, telle quelle.

• On fait également en sorte que la clef soit toujours triée par ordre

alphabétique (clef « B-A » sera exprimée sous la forme « A-B »).

• Ce traitement peut paraître contre-intuitif, mais il va à terme nous permettre d'obtenir, pour couples chaque (clef;valeur): les deux listes d'amis de chacun des utilisateurs qui composent la clef.

clef distincte, deux

COURS BIG DATA - 2019

MapReduce : Exercice – Graphe social (4/8)

• Le pseudo code de notre opération MAP:

UTILISATEUR = [PREMIERE PARTIE DE LA LIGNE] POUR AMI dans [RESTE DE LA LIGNE], FAIRE:

SI UTILISATEUR < AMI:

CLEF = UTILISATEUR+"-"+AMI

SINON:

CLEF = AMI+"-"+UTILISATEUR

GENERER COUPLE (CLEF; [RESTE DE LA LIGNE])

• Par exemple, pour la première ligne:

A => B, C, D

 On obtiendra les couples (clef;valeur):

("A-B"; "B C D")

("A-C"; "B C D")

("A-D"; "B C D")

COURS BIG DATA - 2019

MapReduce : Exercice – Graphe social (5/8)

• Pour la seconde ligne :

B => A, C, D, E

 On obtiendra ainsi :

("A-B"; "A C D E")

("B-C"; "A C D E")

("B-D"; "A C D E")

("B-E"; " A C D E")

• Pour la troisième ligne :

C => A, B, D, E

 On aura :

("A-C"; "A B D E")

("B-C"; "A B D E")

("C-D"; "A B D E")

("C-E"; " A B D E")

•

...et ainsi de suite pour nos 5 lignes d'entrée.

COURS BIG DATA - 2019

MapReduce : Exercice – Graphe social (6/8)

• Une fois l'opération MAP effectuée, Hadoop va récupérer les couples (clef;valeur) de tous les fragments et les grouper par clef distincte. Le résultat sur la base de nos données d'entrée :

Pour la clef "A-B " : valeurs "A C D E" et "B C D" Pour la clef "A-C " : valeurs "A B D E" et "B C D" Pour la clef "A-D " : valeurs "A B C E" et "B C D" Pour la clef "B-C " : valeurs "A B D E" et "A C D E" Pour la clef "B-D " : valeurs "A B C E" et "A C D E" Pour la clef "B-E " : valeurs "A C D E" et "B C D" Pour la clef "C-D " : valeurs "A B C E" et "A B D E" Pour la clef "C-E " : valeurs "A B D E" et "B C D" Pour la clef "D-E " : valeurs "A B C E" et "B C D"

• … on obtient bien, pour chaque clef « USER1-USER2 », deux listes

d'amis: les amis de USER1 et ceux de USER2.

COURS BIG DATA - 2019

MapReduce : Exercice – Graphe social (7/8)

•

Il nous faut enfin écrire notre programme REDUCE. Il va recevoir en entrée toutes les valeurs associées à une clef. Son rôle va être très simple: déterminer quels sont les amis qui apparaissent dans les listes (les valeurs) qui nous sont fournies. Pseudo-code:

LISTE_AMIS_COMMUNS=[] // Liste vide au départ. SI LONGUEUR(VALEURS)!=2, ALORS: // Ne devrait pas se produire.

RENVOYER ERREUR

SINON :

POUR AMI DANS VALEURS[0], FAIRE :

SI AMI EGALEMENT PRESENT DANS VALEURS[1], ALORS :

// Présent dans les deux listes d'amis, on l'ajoute. LISTE_AMIS_COMMUNS+=AMI

RENVOYER LISTE_AMIS_COMMUNS

COURS BIG DATA - 2019

MapReduce : Exercice – Graphe social (8/8)

• Après exécution de l'opération REDUCE pour les valeurs de chaque clef unique, on obtiendra donc, pour une clef « A-B », les utilisateurs qui apparaissent dans la liste des amis de A et dans la liste des amis de B. Autrement dit, on obtiendra la liste des amis en commun des utilisateurs A et B. Le résultat:

"A-B " : "C, D" "A-C " : "B, D" "A-D " : "B, C" "B-C " : "A, D, E" "B-D " : "A, C, E" "B-E " : "C, D" "C-D " : "A, B, E" "C-E " : "B, D" "D-E " : "B, C"

• On sait ainsi que A et B ont pour amis communs les utilisateurs C et D, ou encore que B et C ont pour amis communs les utilisateurs A, D et E.

COURS BIG DATA - 2019

MapReduce : Conclusion

• En utilisant

le modèle MapReduce, on a ainsi pu créer deux programmes très simples (nos programmes MAP et REDUCE) de quelques lignes de code seulement, qui permettent d'effectuer un traitement somme toute assez complexe.

• Mieux encore, notre traitement est parallélisable: même avec des dizaines de millions d'utilisateurs, du moment qu'on a assez de le traitement sera effectué machines au sein du cluster Hadoop, rapidement. Pour aller plus vite, il nous suffit de rajouter plus de machines.

• Pour notre réseau social, il suffira d'effectuer ce traitement toutes les nuits à heure fixe, et de stocker les résultats dans une table. Ainsi, lorsqu'un utilisateur visitera la page d'un autre utilisateur, un seul SELECT dans la base de données suffira pour obtenir la liste des amis en commun – avec un poids en traitement très faible pour le serveur.

COURS BIG DATA - 2019

Architecture Hadoop: Présentation (1/3)

Comme pour HDFS, la gestion des tâches de Hadoop se base sur deux serveurs (des daemons):

• Le JobTracker, qui va directement recevoir la tâche à exécuter (un .jar Java), ainsi que les données d'entrées (nom des fichiers stockés sur HDFS) et le répertoire où stocker les données de sortie (toujours sur HDFS). Il y a un seul JobTracker sur une seule machine du cluster Hadoop. Le JobTracker est en communication avec le NameNode de HDFS et sait donc où sont les données.

• Le TaskTracker, qui est en communication constante avec le JobTracker et va recevoir les opérations simples à effectuer (MAP/REDUCE) ainsi que les blocs de données correspondants (stockés sur HDFS). Il y a un TaskTracker sur chaque machine du cluster.

COURS BIG DATA - 2019

Architecture Hadoop: Présentation (2/3) • Comme le JobTracker est conscient de la position des données (grâce au NameNode), il peut facilement déterminer les meilleures machines auxquelles attribuer les sous-tâches (celles où les blocs de données correspondants sont stockés).

• Pour effectuer un traitement Hadoop, on va donc stocker nos d'entrée sur HDFS, créer un répertoire où Hadoop données stockera les résultats sur HDFS, et compiler nos programmes MAP et REDUCE au sein d'un .jar Java.

• On soumettra alors le nom des fichiers d'entrée,

le nom du répertoire des résultats, et le .jar lui-même au JobTracker: il s'occupera du reste (et notamment de transmettre les programmes MAP et REDUCE aux serveurs TaskTracker des machines du cluster).

COURS BIG DATA - 2019

Architecture Hadoop: Présentation (3/3)

COURS BIG DATA - 2019

Architecture Hadoop: Le JobTracker (1/3)

Le déroulement de l'exécution d'une tâche Hadoop suit les étapes suivantes du point de vue du JobTracker :

Le client (un outil Hadoop console) va soumettre le travail à effectuer au JobTracker: une archive java .jar implémentant les opérations Map et Reduce. Il va également soumettre le nom des fichiers d'entrée et l'endroit où stocker les résultats.

Le JobTracker communique avec le NameNode HDFS pour savoir où se trouvent les blocs correspondant aux noms de fichiers donnés par le client.

les noeuds Le JobTracker, à partir de ces informations, détermine quels sont TaskTracker les plus appropriés, c'est à dire ceux qui contiennent les données sur lesquelles travailler sur la même machine, ou le plus proche possible (même rack/rack proche).

Pour chaque « morceau » des données d'entrée, le JobTracker envoie au TaskTracker sélectionné le travail à effectuer (MAP/REDUCE, code Java) et les blocs de données correspondants.

COURS BIG DATA - 2019

Architecture Hadoop: Le JobTracker (2/3)

Pour chaque « morceau » des données d'entrée, le JobTracker envoie au TaskTracker sélectionné le travail à effectuer (MAP/REDUCE, code Java) et les blocs de données correspondants.

Le JobTracker communique avec les noeuds TaskTracker en train d'exécuter les tâches. Ils envoient régulièrement un « heartbeat », un message signalant qu'ils travaillent toujours sur la sous-tâche reçue. Si aucun heartbeat n'est reçu dans une le JobTracker considère la tâche comme ayant échouée et donne le même travail à effectuer à un autre TaskTracker.

période donnée,

Si par hasard une tâche échoue (erreur java, données incorrectes, etc.), le TaskTracker va signaler au JobTracker que la tâche n'a pas pu être exécutée. Le JobTracker va alors décider de la conduite à adopter : - Demander au même TaskTracker de ré-essayer. - Redonner la sous-tâche à un autre TaskTracker. - Marquer les données concernées comme invalides, etc.

Il pourra même blacklister le TaskTracker concerné comme non-fiable

Architecture Hadoop: Le JobTracker (3/3)

7. Une fois que toutes les opérations envoyées aux TaskTracker (MAP + REDUCE) ont été effectuées et confirmées comme effectuées par tous les noeuds, le JobTracker marque la tâche comme « effectuée ». Des informations détaillées sont disponibles (statistiques, TaskTracker ayant posé problème, etc.).

Remarques

• Par ailleurs, on peut également obtenir à tout moment de la part du JobTracker des informations sur les tâches en train d'être effectuées: étape actuelle (MAP, SHUFFLE, REDUCE), pourcentage de complétion, etc.

• La soumission du .jar, l'obtention de ces informations, et d'une manière générale toutes les opérations liées à Hadoop s'effectuent avec le même unique client console vu précédemment: hadoop (avec d'autres options que l'option fs vu précédemment).

COURS BIG DATA - 2019

Architecture Hadoop: Le TaskTracker

• Le TaskTracker dispose d'un nombre de « slots » d'exécution. A chaque « slot » correspond une tâche exécutable (configurable). Ainsi, une machine ayant par exemple un processeur à 8 cœurs pourrait avoir 16 slots d'opérations configurées.

• Lorsqu'il reçoit une nouvelle tâche à effectuer (MAP, REDUCE, SHUFFLE) depuis le JobTracker, le TaskTracker va démarrer une nouvelle instance de Java avec le fichier .jar fourni par le JobTracker, en appelant l'opération correspondante.

• Une fois la tâche démarrée, il enverra régulièrement au JobTracker ses messages heartbeats. En dehors d'informer le JobTracker qu'il est toujours fonctionnels, ces messages indiquent également le nombre de slots disponibles sur le TaskTracker concerné.

• Lorsqu'une sous-tâche est terminée,

le TaskTracker envoie un message au JobTracker pour l'en informer, que la tâche se soit bien déroulée ou non (il indique évidemment le résultat au JobTracker).

COURS BIG DATA - 2019

Architecture Hadoop: Remarques (1/2)

• De manière similaire au NameNode de HDFS,

il n'y a qu'un seul JobTracker et s'il tombe en panne, le cluster tout entier ne peut plus effectuer de tâches. Là aussi, des résolutions aux problèmes sont ajoutées dans la version 2 de Hadoop (explication dans la section suivante).

• Généralement, on place le JobTracker et le NameNode HDFS sur la même machine (une machine plus puissante que les autres), sans y placer de TaskTracker/DataNode HDFS pour limiter la charge. Cette les deux machine particulière «gestionnaires», de tâches et de fichiers) est communément appelée le noeud maître (« Master Node »). Les autres noeuds (contenant TaskTracker + DataNode) sont communément appelés noeuds esclaves (« slave node »).

au sein du cluster

contient

(qui

COURS BIG DATA - 2019

Architecture Hadoop: Remarques (2/2)

• Même si le JobTracker est situé sur une seule machine, le « client » qui envoie la tâche au JobTracker initialement peut être exécuté sur n'importe quelle machine du cluster – comme les TaskTracker sont présents sur la machine, ils indiquent au client comment joindre le JobTracker.

• La même remarque est valable pour l'accès au système de fichiers: les

DataNodes indiquent au client comment accéder au NameNode.

• Enfin,

tout changement de configuration Hadoop peut s'effectuer facilement simplement en changeant la configuration sur la machine où sont situés les serveurs NameNode et JobTracker: ils répliquent les changements de configuration sur tout le cluster automatiquement.

COURS BIG DATA - 2019

Architecture Hadoop: Architecture générale

COURS BIG DATA - 2019

YARN (MapReduce 2) : Présentation

• YARN (Yet-Another-Resource-Negotiator)

est aussi appelé MRv2 (MapReduce 2). Ce n’est pas une refonte mais une évolution du framework MapReduce.

• YARN répond aux problématiques suivantes du Map Reduce :

– Problème de limite de “Scalability” notamment par une meilleure

séparation de la gestion de l’état du cluster et des ressources.

 ~ 4000 Noeuds, 40 000 Tâches concourantes.

– Problème d’allocation des ressources.

COURS BIG DATA - 2019

YARN (MapReduce 2) : Architecture (1/7) Le JobTracker a trop de responsabilités. • Gérer les ressources du cluster. • Gérer tous les jobs

JobTracker

– Allouer les tâches et les ordonnancer. – Monitorer l'exécution des tâches. – Gérer le fail-over.

RessourceManager

ApplicationMaster

AM AM

Re-penser l’architecture du JobTracker. •

Séparer la gestion des ressources du cluster de la coordination des jobs.

• Utiliser les noeuds esclaves pour gérer les jobs.

ResourceManager et ApplicationMaster. • ResourceManager remplace le JobTracker et ne

gère que les ressources du Cluster.

• Une entité ApplicationMaster est allouée par

Application pour gérer les tâches.

• ApplicationMaster est déployée sur les noeuds

esclaves.

Cours Big Data - 2019

YARN (MapReduce 2) : Architecture (2/7)

• Cette nouvelle version contient aussi un autre composant :

Le NodeManager (NM) – Permet d’exécuter plus de tâches qui ont du sens pour l’Application

Master, pas seulement du Map et du Reduce.

– La taille des ressources est variable (RAM, CPU, network….). Il y aura

plus de valeurs codées en dur qui nécessitent un redémarrage.

RessourceManager

AM AM ApplicationMaster

NodeManager

NM NM

COURS BIG DATA - 2019

YARN (MapReduce 2) : Architecture (3/7)

• Le JobTracker a disparu de l’architecture, ou plus précisément, ses

rôles ont été répartis différemment.

• L’architecture est maintenant organisée autour d’un ResourceManager dont le périmètre d’action est global au cluster et à des ApplicationMaster locaux dont le périmètre est celui d’un job ou d’un groupe de jobs.

• En terme de responsabilités, on peut donc dire que :

JobTracker = ResourceManager +ApplicationMaster.

• La différence, de part le découplage, se trouve dans la multiplicité. En effet, Un ResourceManager gère n ApplicationMaster, lesquels gèrent chacun n jobs.

COURS BIG DATA - 2019

YARN (MapReduce 2) : Architecture (4/7)

COURS BIG DATA - 2019

YARN (MapReduce 2) : Architecture (5/7)

1. ResourceManager • Le ResourceManager est le remplaçant du JobTracker du point de vue du client qui soumet des jobs (ou plutôt des applications en Hadoop 2) à un cluster Hadoop. Il n’a maintenant plus que deux tâches bien distinctes à accomplir : – Scheduler – ApplicationsManager

•

a. Scheduler • Le Scheduler est responsable de l’allocation des ressources des applications

tournant sur le cluster. Il s’agit uniquement d’ordonnancement et d’allocation de ressources.

• • Les ressources allouées aux applications par le Scheduler pour leur permettre de

s’exécuter sont appelées des Containers.

COURS BIG DATA - 2019

YARN (MapReduce 2) : Architecture (6/7)

 Container • Un Container désigne un regroupement de mémoire, de cpu, d’espace disque, de

bande passante réseau, …

b. ApplicationsManager • L’ApplicationsManager accepte les soumissions d’applications. • Une application n’étant pas gérée par

la partie ApplicationsManager ne s’occupe que de négocier le premier Container que le Scheduler allouera sur un noeud du cluster. La particularité de ce premier Container est qu’il contient l’ApplicationMaster (diapo suivant).

le ResourceManager,

2. NodeManager • Les NodeManager sont des agents tournant sur chaque nœud et

le Scheduler au fait de l’évolution des ressources disponibles. Ce dernier peut ainsi prendre ses décisions d’allocation des Containers en prenant en compte des demandes de ressources cpu, disque, réseau, mémoire, …

tenant

Cours Big Data - 2019

YARN (MapReduce 2) : Architecture (7/7)

3. ApplicationMaster • L’ApplicationMaster est le composant spécifique à chaque application, il est en

charge des jobs qui y sont associés. – Lancer et au besoin relancer des jobs – Négocier les Containers nécessaires auprès du Scheduler – Superviser l’état et la progression des jobs.

• Un ApplicationMaster gère donc un ou plusieurs jobs tournant sur un framework donné. Dans le cas de base, c’est donc un ApplicationMaster qui lance un job MapReduce. De ce point de vue, il remplit un rôle de TaskTracker.

 L’ApplicationsManager est l’autorité qui gère les ApplicationMaster du

cluster. A ce titre, c’est donc via l’ApplicationsManager que l’on peut – Superviser l’état des ApplicationMaster – Relancer des ApplicationMaster

COURS BIG DATA - 2019

YARN (MapR2): Déroulement de l’exécution

•

Le déroulement de l'exécution d'une tâche Hadoop suit les étapes suivantes:

(un outil Hadoop console) va soumettre le travail à effectuer au Le client ResourceManager: une archive java .jar implémentant les opérations Map et Reduce, et également une classe driver (qu’on peut considérer comme le « main » du programme).

Le ResourceManager alloue un container, « Application Master », sur le cluster et y lance la classe « driver » du programme.

Cet « application master » va se lancer et confirmer au ResourceManager qu’il tourne correctement.

Pour chacun des fragments des données d’entrée sur lesquelles travailler, l’Application Master va demander au Resource Manager d’allouer un container en lui indiquant les données sur lesquelles celui-ci va travailler et le code à exécuter.

COURS BIG DATA - 2019

YARN (MapR2): Déroulement de l’exécution

L’Application Master va alors lancer le code en question (une classe Java, générallement map ou reduce) sur le container alloué. Il communiquera avec la tâche directement (via un protocole potentiellement propre au programme lancé), le ResourceManager.

sans passer par

Ces tâches vont régulièrement contacter l’Application Master du programme pour transmettre des informations de progression, de statut, etc. parallèlement, chacun des NodeManager communique en permanence avec le ResourceManager pour lui indiquer son statut en terme de ressources (containers lancés, RAM, CPU), mais sans information spécifique aux tâches exécutées.

Pendant l’exécution du programme, le client peut à tout moment contacter le programme en cours d’exécution; pour ce faire, il communique directement avec l’Application Master du programme en contactant le container correspondant sans passer par le ResourceManager du cluster.

8. A l’issue de l’exécution du programme, l’Application Master s’arrète; son container est

libéré et est à nouveau disponible pour de futures tâches.

COURS BIG DATA - 2019