Hadoop Shuffle Combiner

Introduction

Imaginez un scénario où vous êtes un ingénieur talentueux chargé de gérer les données dans un système de simulation de bataille spatiale. Votre objectif est d'optimiser les performances du système en mettant en œuvre la technique Hadoop Shuffle Combiner dans le processus MapReduce. En utilisant le Combiner, vous visez à réduire la circulation réseau et à améliorer l'efficacité globale dans le traitement des données pendant la simulation.

Skills Graph

Écrire le Mapper

Dans cette étape, vous allez écrire la classe Mapper pour traiter les données d'entrée et émettre des paires clé-valeur intermédiaires.

Ouvrez le terminal et suivez les étapes ci-dessous pour commencer.

Changez l'utilisateur en hadoop puis basculez dans le répertoire personnel de l'utilisateur hadoop:

su - hadoop

Créez un fichier Java pour la classe Mapper:

nano /home/hadoop/SpaceBattleMapper.java

Ensuite, ajoutez le code suivant au fichier SpaceBattleMapper.java:

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Mapper.Context;
import java.io.IOException;

public class SpaceBattleMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
    private final static IntWritable one = new IntWritable(1);
    private Text word = new Text();

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        // Divisez la ligne d'entrée en mots
        String[] words = value.toString().split("\\s+");
        // Émettez une paire clé-valeur pour chaque mot
        for (String w : words) {
            word.set(w);
            context.write(word, one);
        }
    }
}

Astuce: Vous pouvez copier le code dans la zone de saisie à droite et le coller avec Ctrl + Shift + V dans l'éditeur nano ouvert. Appuyez sur Ctrl + O pour enregistrer le fichier et appuyez sur Entrée pour confirmer lorsque le nano vous le demande. Enfin, utilisez Ctrl + X pour quitter l'éditeur.

La classe SpaceBattleMapper étend la classe Mapper du framework Hadoop. Elle est utilisée pour traiter des données d'entrée sous forme de paires clé-valeur, où la clé est un LongWritable représentant le décalage en octets de la ligne dans le fichier d'entrée, et la valeur est un objet Text représentant la ligne de texte.

La classe définit deux champs privés:

• one: Un objet IntWritable avec une valeur constante de 1. Cela est utilisé comme valeur dans les paires clé-valeur émises.
• word: Un objet Text utilisé pour stocker chaque mot extrait de la ligne d'entrée.

La méthode map est redéfinie pour fournir la logique de mappage spécifique:

• La valeur Text d'entrée est convertie en chaîne de caractères et divisée en mots en fonction des espaces blancs.
• Pour chaque mot dans le tableau, l'objet word est défini sur ce mot, et une paire clé-valeur est émise avec le mot comme clé et one comme valeur. Cela est fait à l'aide de la méthode context.write.

Cette classe Mapper est conçue pour émettre une paire clé-valeur pour chaque mot dans les données d'entrée, avec le mot comme clé et l'entier 1 comme valeur. Cette configuration est couramment utilisée dans les applications de comptage de mots, où l'objectif est de compter le nombre d'occurrences de chaque mot dans un ensemble de données.

Implémenter le Combiner

Dans cette étape, vous allez implémenter la classe Combiner pour effectuer une agrégation locale avant le tri des données.

Créez un fichier Java pour la classe Combiner:

nano /home/hadoop/SpaceBattleCombiner.java

Ensuite, ajoutez le code suivant au fichier SpaceBattleCombiner.java:

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;

public class SpaceBattleCombiner extends Reducer<Text, IntWritable, Text, IntWritable> {
    @Override
    protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
        int sum = 0;
        // Sommez les valeurs pour chaque clé
        for (IntWritable val : values) {
            sum += val.get();
        }
        // Émettez la clé et la somme de ses valeurs
        context.write(key, new IntWritable(sum));
    }
}

La classe SpaceBattleCombiner étend la classe Reducer du framework Hadoop. Elle est utilisée comme un combiner dans le processus MapReduce pour effectuer une agrégation locale des paires clé-valeur intermédiaires émises par le Mapper.

La classe redéfinit la méthode reduce pour fournir la logique spécifique du combiner:

• La méthode prend une clé de type Text et un itérable de valeurs de type IntWritable en entrée. La clé représente un mot, et l'itérable contient les comptes d'occurrences de ce mot.
• La méthode itère sur les valeurs, les additionnant pour obtenir le compte total du mot.
• Enfin, la méthode émet une paire clé-valeur avec le mot comme clé et le compte total comme valeur à l'aide de la méthode context.write.

Le but du SpaceBattleCombiner est d'effectuer une agrégation locale des comptes pour chaque mot avant que les données ne soient triées sur le réseau vers le Réducteur. Cela réduit la quantité de données transférées entre les phases Mapper et Réducteur, améliorant l'efficacité du travail MapReduce.

Implémenter le Réducteur

Dans cette étape, vous allez implémenter la classe Réducteur pour effectuer l'agrégation finale des paires clé-valeur.

1. Créez un fichier Java pour la classe Réducteur:

nano /home/hadoop/SpaceBattleReducer.java

Ensuite, ajoutez le code suivant au fichier SpaceBattleReducer.java:

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;

public class SpaceBattleReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
    @Override
    protected 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));
    }
}

La classe SpaceBattleReducer étend la classe Reducer du framework Hadoop. Elle est utilisée pour effectuer l'agrégation finale des paires clé-valeur intermédiaires émises par le Mapper et éventuellement traitées par le Combiner.

La classe redéfinit la méthode reduce pour fournir la logique spécifique du réducteur:

• La méthode prend une clé de type Text et un itérable de valeurs de type IntWritable en entrée. La clé représente un mot, et l'itérable contient les comptes d'occurrences de ce mot.
• La méthode itère sur les valeurs, les additionnant pour obtenir le compte total du mot.
• Enfin, la méthode émet une paire clé-valeur avec le mot comme clé et le compte total comme valeur à l'aide de la méthode context.write.

Le SpaceBattleReducer effectue l'agrégation finale des données, additionnant les comptes pour chaque mot sur toutes les sorties du Mapper. Cela fournit le compte final d'occurrences pour chaque mot dans les données d'entrée.

Écrire le Pilote

Dans cette étape, vous allez créer un fichier Java pour gérer le travail MapReduce, y compris la configuration du travail et la spécification des classes Mapper, Combiner et Réducteur.

Créez un fichier Java pour la classe Pilote:

nano /home/hadoop/SpaceBattleDriver.java

Ensuite, ajoutez le code suivant au fichier SpaceBattleDriver.java:

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class SpaceBattleDriver {
    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf, "Space Battle Simulation");
        job.setJarByClass(SpaceBattleDriver.class);
        job.setMapperClass(SpaceBattleMapper.class);
        job.setCombinerClass(SpaceBattleCombiner.class);
        job.setReducerClass(SpaceBattleReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        FileInputFormat.addInputPath(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));
        System.exit(job.waitForCompletion(true)? 0 : 1);
    }
}

La classe SpaceBattleDriver est responsable de configurer et d'exécuter le travail MapReduce pour la simulation de bataille spatiale.

• La classe commence par créer un nouvel objet Configuration et une instance de Job avec cette configuration. Le travail est donné un nom, "Space Battle Simulation", pour l'identification.

• La méthode setJarByClass est appelée avec la classe SpaceBattleDriver pour définir le fichier jar qui contient les classes nécessaires pour le travail.

• Les méthodes setMapperClass, setCombinerClass et setReducerClass sont utilisées pour spécifier les classes qui effectueront respectivement les tâches de mappage, de combinaison et de réduction.

• Les méthodes setOutputKeyClass et setOutputValueClass définissent les types de la clé et de la valeur de sortie, qui sont Text et IntWritable dans ce cas.

• Les méthodes FileInputFormat.addInputPath et FileOutputFormat.setOutputPath définissent les chemins pour les données d'entrée et de sortie. Ces chemins sont passés en tant qu'arguments de ligne de commande à la méthode principale.

• Enfin, la méthode job.waitForCompletion est appelée pour soumettre le travail et attendre sa fin. La méthode renvoie true si le travail se termine avec succès et false sinon. Le programme quitte avec un code de statut de 0 si le travail est réussi et 1 s'il ne l'est pas.

Cette classe pilote relie tous les composants du travail MapReduce et est le point d'entrée pour exécuter le travail.

Sommaire

Dans ce laboratoire, vous avez parcouru l'implémentation de la technique Hadoop Shuffle Combiner dans un scénario de simulation de bataille spatiale. En suivant les étapes pour créer les classes Mapper, Combiner, Réducteur et Pilote, vous avez acquis une expérience pratique dans l'optimisation du traitement des données dans un environnement Hadoop MapReduce. Ce laboratoire avait pour but d'améliorer votre compréhension de la réduction de la surcharge réseau et de l'amélioration de l'efficacité de calcul dans les tâches de traitement de gros volumes de données.