Cours de « Big Data »: HDFS et MapReduce

Ce cours aborde les fondamentaux de HDFS (Hadoop Distributed File System) et du modèle de programmation mapreduce-6e20911580">MapReduce, deux composants essentiels du traitement Big Data. Il s’inscrit dans un cursus dédié aux systèmes distribués et à l’analyse de grandes quantités de données, en expliquant l’architecture, la gestion des données, ainsi que la tolérance aux pannes.

Architecture et fonctionnement de HDFS

HDFS est un système de fichiers distribué conçu pour stocker de très larges volumes de données sur un ensemble de nœuds (nodes). Chaque fichier est découpé en blocs, généralement de 64 Mo par défaut dans Hadoop (ou 128 Mo dans certaines distributions comme BigInsights). Ces blocs sont physiquement répartis sur différents DataNodes, qui sont des nœuds esclaves responsables du stockage réel des données.

Le système repose sur une architecture maître/esclave. Le NameNode joue le rôle de maître et gère le système de fichiers, notamment l’espace de noms et les métadonnées. Il maintient deux fichiers essentiels : le FsImage, qui est une image complète du système de fichiers, et l’EditLog, qui enregistre les modifications récentes. Le NameNode régule aussi l’accès des clients aux fichiers.

Les DataNodes, nombreux dans un cluster, gèrent le stockage local et rapportent périodiquement leur état au NameNode. Ils stockent les blocs de données et exécutent les opérations de lecture et d’écriture demandées.

Gestion des blocs et réplication

Chaque fichier est divisé en blocs de taille fixe, et ces blocs sont répliqués sur plusieurs DataNodes pour assurer la tolérance aux pannes. Le facteur de réplication est configurable, avec une valeur par défaut de 3, ce qui signifie que chaque bloc est copié sur trois nœuds différents. Cette réplication garantit que si un DataNode devient défectueux, les données restent accessibles via les autres copies.

Au démarrage, le NameNode charge le FsImage en mémoire, applique les modifications enregistrées dans l’EditLog, puis attend les rapports des DataNodes concernant les blocs qu’ils hébergent. Le NameNode entre en mode « safemode » tant que 99,9 % des blocs n’ont pas au moins une copie reconnue.

Ajout et gestion des fichiers dans HDFS

Lorsqu’un fichier est ajouté, il est d’abord enregistré dans la mémoire du NameNode et persisté dans l’EditLog. Ensuite, les données sont découpées en blocs qui sont écrits sur les DataNodes. L’écriture se fait en chaîne : un DataNode écrit le bloc et le transmet à deux autres DataNodes pour réplication. L’écriture est considérée comme réussie si au moins une copie de chaque bloc est correctement enregistrée.

Le modèle MapReduce : architecture et fonctionnement

MapReduce est un modèle de programmation parallèle destiné à traiter de grandes quantités de données distribuées sur un cluster. Son architecture est également maître/esclave. Le JobTracker est le maître unique qui contrôle l’exécution des tâches sur plusieurs TaskTrackers esclaves.

Le JobTracker reçoit les travaux soumis par les clients, répartit les tâches Map et Reduce aux TaskTrackers, et veille à ce que les traitements soient effectués au plus près des données pour optimiser les performances. Il contrôle l’état de chaque TaskTracker et gère la planification des tâches.

Les TaskTrackers exécutent les tâches Map et Reduce, rapportent leur statut au JobTracker, et gèrent le stockage ainsi que la transmission des résultats intermédiaires.

Étapes du traitement MapReduce

Le traitement MapReduce se décompose en plusieurs phases :

• Map : La fonction Map reçoit en entrée des couples <Clé, Valeur>. Si aucune clé n’est disponible, elle doit être créée. L’association entre les données d’entrée (fichiers, liens internet, etc.) et les couples <Clé, Valeur> est réalisée via la classe InputFormat.
• Dans un exemple de compteur de mots, la tâche Map filtre les lignes ne correspondant pas aux critères (par exemple, les noms d’animaux spécifiques) et transforme chaque occurrence en un couple <texte (nom), entier (1)> pour préparer le comptage.
• Shuffle : Cette phase déplace toutes les valeurs associées à une même clé vers un même nœud. La distribution est contrôlée par une classe Partitioner. Les tâches Reduce peuvent s’exécuter sur des nœuds arbitraires du cluster. Les résultats intermédiaires sont stockés dans des blocs HDFS sur les machines exécutant les tâches Reduce.
• Reduce : La fonction Reduce agrège les valeurs pour chaque clé et écrit la sortie finale dans un système de fichiers distribué (DFS).

Tolérance aux pannes dans HDFS et MapReduce

La tolérance aux pannes est un aspect crucial de ces systèmes distribués. Dans HDFS, la réplication des blocs garantit que la perte d’un DataNode n’entraîne pas la perte des données.

Dans MapReduce, si une tâche enfant échoue, la JVM enfant signale l’échec au TaskTracker et se termine. La tentative est alors marquée comme échouée, et une autre tâche est prise en charge. Si une tâche se bloque, elle est tuée, et le JobTracker replanifie la tâche sur une autre machine. Si la tâche continue à échouer, le travail est considéré comme échoué.

En cas d’échec d’un TaskTracker (absence de battement de cœur), le JobTracker le supprime de la liste des nœuds disponibles et planifie les tâches sur d’autres TaskTrackers.

Points clés

• HDFS stocke les données en les divisant en blocs répartis sur plusieurs DataNodes, avec réplication pour assurer la fiabilité.
• L’architecture maître/esclave comprend un NameNode maître gérant les métadonnées et plusieurs DataNodes esclaves stockant les blocs.
• Le facteur de réplication par défaut est de 3, ce qui assure la tolérance aux pannes.
• MapReduce utilise un JobTracker maître et plusieurs TaskTrackers esclaves pour exécuter les tâches Map et Reduce.
• Le traitement MapReduce se compose des phases Map, Shuffle et Reduce, permettant de traiter efficacement de grandes quantités de données distribuées.
• La tolérance aux pannes est gérée par la réplication dans HDFS et par la replanification automatique des tâches en cas d’échec dans MapReduce.