Bonjour à toutes et à tous !
Aujourd’hui 
Hadoop est donc un framework pour développer des applications distribuées qui peuvent traiter des pétaoctets de données.
Ce framework se compose de deux éléments : le Hadoop File System (HDFS), qui est un système de fichiers distribué, et le MapReduce, qui est un paradigme computationnel permettant d’effectuer des opérations sur les données.
Dans cet article, nous allons vous présenter le fonctionnement de MapReduce.
Le but de MapReduce est de diviser et traiter un grand nombre de données en parallèle grâce à un large cluster composé de serveurs standards, ce qui rend le programme tolérant aux pannes. Il est également rapide puisque les données sont traitées là où elles sont stockées, et le HDFS permet d’avoir une bande passante très élevée à travers le cluster.
MapReduce est divisé en deux étapes : Map et Reduce.
La première étape, Map, consiste à diviser les données en bloc et à assigner chaque bloc à un Mapper (un nœud du cluster). Pour ce faire, il y a un JobTracker, qui est le master du cluster, et un TaskTracker, qui est un esclave présent sur chaque nœud.
Le rôle du JobTracker est de programmer les tâches sur les esclaves, de les monitorer et de gérer les tâches en échec en demandant une nouvelle exécution. Le rôle du TaskTracker est quant à lui d’exécuter les tâches assignées par le master.
Le JobTracker va donc commencer par séparer les données et va assigner à chaque Mapper une ou plusieurs entrées. Le nombre total de ”maps” dépend généralement de la taille totale de l’entrée (c’est-à-dire, le nombre total de blocs de fichiers en entrée). Par nœud, on pourra faire entre 10 à 100 maps (voire 300 si la tâche est très légère pour le CPU). Par exemple, pour une entrée de 10TB avec une taille de bloc à 128MB, on aura 82 000 maps.
Chaque Mapper va donc se voir assigner un certain nombre d’entrées à traiter. Il va venir “mapper” les données contenues dans ces entrées et en ressortir une liste de paires de clé / valeur.
Par exemple, prenons ces trois entrées :
fichier1 (f1) : “ABC”
fichier2 (f2) : “ACD”
fichier3 (f3) : “BCD”
Les Mapper vont venir mapper leurs entrées comme suit :
Mapper 1 : A, f1 / B, f1 / C, f1
Mapper 2 : A, f2 / C, f2 / D, f2
Mapper 3 : B, f3 / C, f3 / D, f3
Chaque Mapper va donc ressortir une liste de paires de clé / valeur. Cette sortie sera l’entrée de l’étape suivante.
La seconde étape est le Reduce. Cette étape peut être divisée en plusieurs sous-étapes :
Shuffle, Sort et Reduce.
Concernant le Shuffle, il va donc récupérer (en HTTP) les partitions que les Mappers auront sorties et les transférer aux Reducers qui vont pouvoir passer à l’étape du Sort.
Pendant l’étape du Sort, le framework vient regrouper les entrées prévues pour le Reducer par clées, car différents mappers peuvent avoir la même clé en sortie. Cette phase, ainsi que la phase de Shuffle, ont lieu simultanément.
En reprenant l’exemple donné au-dessus, la sortie sera donc :
A, (f1, f2)
B, (f1, f3)
C, (f1, f2, f3)
D, (f2, f3)
Vient ensuite la dernière étape, celle du Reduce. Cette étape vient récupérer l’ensemble généré par la phase Shuffle, et le transformer une dernière fois en un ensemble avec des paires clé/valeur, où la valeur est égale à la taille de la liste associée à la clé. Pour terminer, il va l’enregistrer sur le système de fichiers (la sortie du Reducer n’est pas triée).
Avec notre exemple d’avant, nous avons donc :
A, 2
B, 2
C, 3
D, 2
D’après la documentation officielle, il est également possible de définir le nombre de tâches de reduce à 0 si l’on ne désire pas exécuter de réduction sur l’entrée.
Il existe également deux fonctionnalités en plus : Reporter et Counter.
On peut avoir un Reporter (optionnel) pour connaître la progression, envoyer des message de rapport du statut au niveau de l’application et mettre à jour les Counters. Les Mappers et les Reducer peuvent inclure le Reporter pour indiquer qu’ils sont en vie ou non.
Concernant les Counters, l’application peut définir arbitrairement des Counters, ils peuvent être de n’importe quel type d’Enum et seront regroupés et agrégés automatiquement par le framework. Enfin, comme mentionné plus tôt, les Reporters peuvent mettre à jour les Counters.
Pour résumer et conclure ce post, MapReduce et un moyen très efficace de traiter d’énorme quantité de données (on parle ici de l’ordre du petabyte) en utilisant le parallélisme et en distribuant les tâches ( JobTracker et TaskTracker) dans le cluster. Même si ce modèle permet de bonne performance, la scalabilité et une tolérance au panne, il est aujourd’hui obsolète et est remplacé par d’autres méthodes (tel que Spark). L’HDFS est quant à lui toujours très utilisé.
Merci de nous avoir lu !
Références utilisées :
https://hadoop.apache.org/docs/r1.2.1/mapred_tutorial.html
https://fr.wikipedia.org/wiki/Hadoop