Introduction à l'ecosystème Hadoop

Mise en place d'une plateforme Hadoop afin de :

• stocker des fichiers dans HDFS ;
• observer leur répartition ;
• vérifier la réplication ;
• simuler une panne ;
• lancer un traitement distribué.

Une plateforme e-commerce collecte quotidiennement :

• des commandes ;
• des événements de navigation ;
• des journaux applicatifs ;
• des données clients et produits.

Lorsque les volumes deviennent importants, une seule machine peut atteindre ses limites :

• capacité de stockage limitée ;
• temps de traitement trop important ;
• risque de perte en cas de panne ;
• difficulté à exécuter plusieurs traitements simultanément ;
• augmentation de capacité difficile.

Hadoop propose d’utiliser plusieurs machines pour :

• répartir le stockage ;
• répartir les calculs ;
• améliorer la tolérance aux pannes ;
• augmenter progressivement la capacité.

Hadoop regroupe plusieurs composants qui remplissent des rôles différents :

                    ┌───────────────┐
                    │ Application   │
                    │ MapReduce     │
                    │ ou Spark      │
                    └───────┬───────┘
                            │
                            ▼
                    ┌───────────────┐
                    │     YARN      │
                    │ Gestion des   │
                    │ ressources    │
                    └───────┬───────┘
                            │
                            ▼
                    ┌───────────────┐
                    │     HDFS      │
                    │ Stockage      │
                    │ distribué     │
                    └───────────────┘

Lorsqu’un fichier est déposé dans HDFS, il est découpé en blocs.

                 ventes.csv
                      │
      ┌───────────────┼───────────────┐
      │               │               │
      ▼               ▼               ▼
 ┌─────────┐     ┌─────────┐     ┌─────────┐
 │ Bloc 1  │     │ Bloc 2  │     │ Bloc 3  │
 └─────────┘     └─────────┘     └─────────┘

Les blocs sont ensuite répartis sur les différents DataNodes.

HDFS repose principalement sur deux types de nœuds :

• le NameNode ;
• les DataNodes.

                    ┌──────────────┐
                    │   NameNode   │
                    │ Métadonnées  │
                    └──────┬───────┘
                           │
          ┌────────────────┼────────────────┐
          │                │                │
          ▼                ▼                ▼
   ┌────────────┐   ┌────────────┐   ┌────────────┐
   │ DataNode 1 │   │ DataNode 2 │   │ DataNode 3 │
   │   Blocs    │   │   Blocs    │   │   Blocs    │
   └────────────┘   └────────────┘   └────────────┘

Le NameNode conserve les métadonnées du système de fichiers :

• noms des fichiers ;
• arborescence des répertoires ;
• taille des fichiers ;
• emplacement des blocs ;
• facteur de réplication.

Le NameNode ne contient généralement pas le contenu des fichiers.

Les DataNodes stockent physiquement les blocs de données.

Ils sont également chargés de :

• répondre aux demandes de lecture et d’écriture ;
• signaler régulièrement leur état au NameNode ;
• gérer les copies des blocs.

Pour éviter la perte de données en cas de panne, HDFS conserve plusieurs copies de chaque bloc.

                         Bloc 1
                           │
              ┌────────────┼────────────┐
              │            │            │
              ▼            ▼            ▼
       ┌────────────┐ ┌────────────┐ ┌────────────┐
       │ DataNode 1 │ │ DataNode 2 │ │ DataNode 3 │
       │   Copie 1  │ │   Copie 2  │ │   Copie 3  │
       └────────────┘ └────────────┘ └────────────┘

Avec un facteur de réplication égal à 3, chaque bloc possède trois copies.

Si un DataNode tombe en panne, HDFS peut encore lire le bloc depuis un autre DataNode.

YARN est chargé de gérer les ressources disponibles sur le cluster.

Il décide notamment :

• quelles applications peuvent s’exécuter ;
• sur quels nœuds elles s’exécutent ;
• quelle quantité de mémoire leur est attribuée ;
• combien de cœurs leur sont attribués.

                    ┌───────────────┐
                    │ Application   │
                    └───────┬───────┘
                            │
                            ▼
                    ┌───────────────┐
                    │ResourceManager│
                    └───────┬───────┘
                            │
              ┌─────────────┴─────────────┐
              │                           │
              ▼                           ▼
       ┌────────────┐                ┌────────────┐
       │NodeManager │                │NodeManager │
       │     1      │                │     2      │
       └────────────┘                └────────────┘

Le ResourceManager est le composant central de YARN.

Il :

• connaît les ressources disponibles ;
• attribue ces ressources aux applications ;
• planifie l’exécution des traitements.

Chaque machine exécutant des tâches possède un NodeManager.

Il est chargé de :

• surveiller les ressources utilisées ;
• lancer les tâches demandées ;
• transmettre des informations au ResourceManager.

MapReduce permet de traiter les données en plusieurs étapes :

┌──────────────┐
│ Données      │
│ d’entrée     │
└──────┬───────┘
       │
       ▼
┌──────────────┐
│     Map      │
│ Transformer  │
└──────┬───────┘
       │
       ▼
┌──────────────┐
│   Shuffle    │
│ Regrouper    │
└──────┬───────┘
       │
       ▼
┌──────────────┐
│    Reduce    │
│ Agréger      │
└──────┬───────┘
       │
       ▼
┌──────────────┐
│ Résultats    │
└──────────────┘

Données d’entrée :

informatique
maison
informatique
sport
maison

Chaque ligne devient une paire clé-valeur :

(informatique, 1)
(maison, 1)
(informatique, 1)
(sport, 1)
(maison, 1)

Hadoop regroupe les valeurs par clé :

(informatique, [1, 1])
(maison, [1, 1])
(sport, [1])

Le système additionne les valeurs :

informatique : 2
maison       : 2
sport        : 1

MapReduce permet de :

• traiter plusieurs blocs en parallèle ;
• répartir les calculs sur plusieurs machines ;
• relancer certaines tâches en cas de problème ;
• stocker les résultats dans HDFS.

Dans le TD, nous allons :

1. lancer les conteneurs Docker ;
2. observer les nœuds Hadoop ;
3. créer des répertoires HDFS ;
4. déposer un fichier dans HDFS ;
5. observer ses blocs et sa réplication ;
6. arrêter un DataNode ;
7. vérifier que les données restent accessibles ;
8. observer YARN ;
9. lancer un traitement ;
10. lire les résultats.

┌──────────────┐
│ ventes.csv   │
└──────┬───────┘
       │
       ▼
┌──────────────┐
│     HDFS     │
└──────┬───────┘
       │
       ├──────────────► NameNode
       │                 Métadonnées
       │
       └──────────────► DataNodes
                         Blocs et réplication
                                │
                                ▼
                         ┌──────────────┐
                         │     YARN     │
                         │ Gestion des  │
                         │ ressources   │
                         └──────┬───────┘
                                │
                                ▼
                         ┌──────────────┐
                         │  MapReduce   │
                         └──────┬───────┘
                                │
                                ▼
                         ┌──────────────┐
                         │ Résultats    │
                         │ dans HDFS    │
                         └──────────────┘

1. Hadoop est un écosystème de traitement distribué.
2. HDFS stocke les fichiers en les découpant en blocs répartis sur plusieurs DataNodes.
3. Le NameNode conserve les métadonnées et localise les blocs.
4. YARN attribue les ressources aux applications.
5. MapReduce traite les données avec les étapes Map, Shuffle et Reduce.