Hadoop et HDFS

Hadoop est un framework open-source né chez Yahoo! en 2006, conçu pour stocker et traiter d’immenses volumes de données sur des grappes de serveurs standards. Il a révolutionné la gestion du Big Data en rendant possible l’analyse de pétaoctets de données à moindre coût.

• Enjeux : traiter des données trop volumineuses ou variées pour les bases classiques, assurer la tolérance aux pannes, réduire les coûts d’infrastructure.
• Écosystème : Hadoop n’est pas seul ! Il s’intègre avec Hive, Pig, Spark, HBase, etc.
• Composants principaux :
  • HDFS : système de fichiers distribué, cœur du stockage.
  • MapReduce : moteur de traitement batch distribué.
  • YARN : gestionnaire de ressources et d’exécution des jobs.

Hadoop a posé les bases de la data moderne et reste utilisé pour l’archivage, le batch analytique et comme socle de clusters Big Data.

• Stockage de données massives
• Traitement batch distribué
• Archivage et sauvegarde

1. Commandes HDFS de base

• hdfs dfs -mkdir /data/mon_dossier : créer un dossier sur HDFS
• hdfs dfs -put fichier.txt /data/mon_dossier/ : uploader un fichier local vers HDFS
• hdfs dfs -ls /data/mon_dossier : lister les fichiers d’un dossier
• hdfs dfs -cat /data/mon_dossier/fichier.txt : afficher le contenu d’un fichier

Ces commandes permettent de manipuler HDFS en ligne de commande, comme un système de fichiers classique mais distribué.

2. Exemple WordCount en pseudo-code MapReduce

// MAP : pour chaque ligne du texte
pour chaque mot dans la ligne
    émettre (mot, 1)
// REDUCE : pour chaque mot unique
somme = 0
pour chaque valeur associée au mot
    somme += valeur
émettre (mot, somme)

Ce schéma est à la base de nombreux traitements distribués sur Hadoop.

3. Exemple WordCount Java (simplifié)

public static class Map extends Mapper<Object, Text, Text, IntWritable> {
    private final static IntWritable one = new IntWritable(1);
    private Text word = new Text();
    public void map(Object key, Text value, Context context) throws IOException, InterruptedException {
        StringTokenizer itr = new StringTokenizer(value.toString());
        while (itr.hasMoreTokens()) {
            word.set(itr.nextToken());
            context.write(word, one);
        }
    }
}

public static class Reduce extends Reducer<Text, IntWritable, Text, IntWritable> {
    public void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
        int sum = 0;
        for (IntWritable val : values) {
            sum += val.get();
        }
        context.write(key, new IntWritable(sum));
    }
}

• Mapper : découpe chaque ligne en mots, émet (mot, 1)
• Reducer : additionne les valeurs pour chaque mot

Ce programme Java est typique des premiers jobs MapReduce sur Hadoop.

1. Préparation
   Télécharge le fichier alice.txt (texte du livre « Alice au pays des merveilles ») depuis Project Gutenberg et place-le dans ton dossier local.
2. Upload sur HDFS
   hdfs dfs -mkdir /data/alice
hdfs dfs -put alice.txt /data/alice/
   Vérifie la présence du fichier :
   hdfs dfs -ls /data/alice
3. Lancer le job WordCount MapReduce
   hadoop jar /usr/lib/hadoop-mapreduce/hadoop-mapreduce-examples.jar wordcount /data/alice/alice.txt /data/alice/output
   (Adapte le chemin du jar si besoin)
4. Analyser les résultats
   hdfs dfs -ls /data/alice/output
hdfs dfs -cat /data/alice/output/part-r-00000 | head -20
   (Affiche les 20 premiers mots comptés)
5. Questions de réflexion
   • Quels sont les mots les plus fréquents dans le texte ?
   • Comment le système assure-t-il la tolérance aux pannes si un DataNode tombe pendant le job ?
   • Comment adapterais-tu le script pour ignorer la casse ou les mots très courts (<3 caractères) ?

Ce mini-lab permet de manipuler HDFS, de lancer un vrai job MapReduce, et de comprendre la logique du traitement distribué sur un cluster Hadoop.

• Tuning & performance :
  • Taille des blocs : augmenter (256 Mo, 512 Mo) pour de très gros fichiers, diminuer pour de nombreux petits fichiers.
  • Facteur de réplication : adapter selon la criticité (3 par défaut, plus pour la sécurité, moins pour économiser l’espace).
  • Mémoire et parallélisme : ajuster les paramètres YARN (RAM, CPU par conteneur) pour optimiser l’utilisation du cluster.
• Sécurité :
  • Authentification Kerberos : protège l’accès au cluster.
  • Chiffrement : possible au repos (HDFS) et en transit (SSL/TLS).
  • Contrôle d’accès : permissions POSIX, gestion fine par utilisateur/groupe.
• Formats avancés :
  • Parquet, ORC : formats colonnes, idéaux pour l’analytique (compression, lecture rapide de colonnes spécifiques).
  • Avro : format sérialisé, adapté à l’échange de données entre systèmes.
• Interopérabilité :
  • Spark : lit/écrit nativement sur HDFS, permet des traitements in-memory sur les données stockées.
  • Hive : datawarehouse SQL sur HDFS, facilite les requêtes analytiques.
• Pour aller plus loin :
  • Documentation officielle Apache Hadoop
  • Guide d’installation et tuning
  • Forum Cloudera