Maîtriser Hadoop MapReduce : Personnaliser les Formats d'entrée et de Sortie

Introduction

Dans ce laboratoire, vous allez apprendre à personnaliser les formats de sortie et d'entrée dans Hadoop MapReduce pour traiter efficacement les données. Avec l'aide du Ghost Tutor, vous acquerrez les compétences nécessaires pour travailler avec différents types de données et débloquer tout le potentiel de l'écosystème Hadoop. Préparez-vous à entreprendre un voyage passionnant pour maîtriser l'art du calcul dans le domaine surnaturel!

Écrire le Mapper et le Reducer

Dans cette étape, nous plongerons au cœur de Hadoop MapReduce et créerons nos propres classes Mapper et Reducer.

Explorer le fichier de données

Tout d'abord, utilisez la commande su - hadoop pour basculer d'identité. Le fichier de données data.txt est stocké dans le répertoire /user/hadoop/input de HDFS, qui stocke le contenu de quelques conversations entre des personnes. Utilisez la commande suivante pour afficher le contenu :

hdfs dfs -cat /user/hadoop/input/data.txt

Mapper personnalisé

Ensuite, nous allons créer une classe Mapper personnalisée appelée WordCountMapper qui étend Mapper. Ce Mapper traitera les données d'entrée et émettra des paires clé-valeur. Notons que les données traitées sont le contenu de chaque ligne de la conversation, pas les noms des personnes. Reportez-vous à l'exemple suivant pour compléter la méthode map dans WordCountMapper.java dans /home/hadoop/.

@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
    // Convertir l'objet Text en une chaîne de caractères
    String line = value.toString();
    // Découper la chaîne en utilisant StringTokenizer
    StringTokenizer tokenizer = new StringTokenizer(line);
    // Parcourir chaque jeton et l'écrire dans le contexte
    while (tokenizer.hasMoreTokens()) {
        // Définir le mot actuel
        word.set(tokenizer.nextToken().trim());
        // Écrire le mot et son compte dans le contexte
        context.write(word, one);
    }
}

Ensuite, utilisez la commande suivante pour compiler le code en version java 8 :

javac -source 8 -target 8 -cp $HADOOP_HOME/share/hadoop/common/hadoop-common-3.3.6.jar:$HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.3.6.jar:. WordCountMapper.java

Reducer personnalisé

Enfin, nous allons créer une classe Reducer personnalisée appelée WordCountReducer qui étend Reducer. Ce Reducer aggregera les valeurs pour chaque clé et émettra le résultat final. Complétez la méthode reduce dans WordCountReducer.java dans /home/hadoop/ avec l'exemple suivant.

@Override
protected void reduce(Text key, Iterable<IntWritable> values, Context context)
        throws IOException, InterruptedException {
    // Initialiser une variable pour stocker la somme des comptes pour chaque mot
    int sum = 0;
    // Parcourir tous les comptes pour le mot actuel et calculer la somme totale
    for (IntWritable value : values) {
        sum += value.get();
    }
    // Définir le compte final pour le mot actuel
    result.set(sum);
    // Écrire le mot et son compte final dans le contexte
    context.write(key, result);
}

Ensuite, utilisez la commande suivante pour compiler le code en version java 8 :

javac -source 8 -target 8 -cp $HADOOP_HOME/share/hadoop/common/hadoop-common-3.3.6.jar:$HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.3.6.jar:. WordCountReducer.java

Écrire des formats d'entrée et de sortie personnalisés

Dans cette étape, nous allons spécifier les formats d'entrée et de sortie pour le travail MapReduce.

Format d'entrée personnalisé

Tout d'abord, créons un format d'entrée personnalisé pour lire des données à partir d'une source spécifique. Nous allons définir une classe appelée PersonInputFormat qui étend TextInputFormat et redéfinir la méthode getCurrentValue pour gérer le format d'entrée. Complétez la méthode getCurrentValue dans PersonInputFormat.java dans /home/hadoop/ avec l'exemple suivant.

@Override
public synchronized Text getCurrentValue() {
    // Retourner la valeur de l'enregistrement actuel, le diviser selon ":", supprimer les espaces blancs du début et de la fin et le définir sur l'objet Text.
    Text value = new Text();
    Text line = super.getCurrentValue();
    String[] parts = line.toString().split(":");
    if (parts.length == 2) {
        value.set(parts[1].trim());
    }
    return value;
}

Ensuite, utilisez la commande suivante pour compiler le code en version java 8 :

javac -source 8 -target 8 -cp $HADOOP_HOME/share/hadoop/common/hadoop-common-3.3.6.jar:$HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.3.6.jar:. PersonInputFormat.java

Format de sortie personnalisé

Ensuite, créons un format de sortie personnalisé. Nous allons définir une classe appelée CSVOutputFormat qui étend TextOutputFormat. Complétez la méthode write dans CSVOutputFormat.java dans /home/hadoop/ avec l'exemple suivant.

// Écrire la paire clé-valeur dans le flux de sortie au format CSV
@Override
public void write(Text key, IntWritable value) throws IOException, InterruptedException {
    out.writeBytes(key.toString() + "," + value.toString() + "\n");
}

Ensuite, utilisez la commande suivante pour compiler le code en version java 8 :

javac -source 8 -target 8 -cp $HADOOP_HOME/share/hadoop/common/hadoop-common-3.3.6.jar:$HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.3.6.jar:. CSVOutputFormat.java

Intégration avec le Pilote

Dans cette dernière étape, nous modifierons la classe WordCountDriver pour utiliser les formats d'entrée et de sortie personnalisés que nous avons créés précédemment.

Pilote personnalisé

Complétez la fonction main de WordCountDriver.java dans /home/hadoop/ avec l'exemple suivant.

// Définir les classes Mapper et Reducer
job.setMapperClass(WordCountMapper.class);
job.setReducerClass(WordCountReducer.class);

// Définir la classe de format d'entrée sur le format d'entrée personnalisé PersonInputFormat
job.setInputFormatClass(PersonInputFormat.class);

// Définir la classe de format de sortie sur le format de sortie personnalisé CSVOutputFormat
job.setOutputFormatClass(CSVOutputFormat.class);

Exécution du travail

Pour exécuter le travail MapReduce Hadoop avec les formats d'entrée et de sortie personnalisés, suivez ces étapes :

Compiler WordCountDriver.java en utilisant les dépendances Hadoop appropriées.

javac -source 8 -target 8 -cp $HADOOP_HOME/share/hadoop/common/hadoop-common-3.3.6.jar:$HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.3.6.jar:. WordCountDriver.java

Créer un fichier JAR contenant les classes compilées.
```
jar -cvf mywordcount.jar *.class
```
Exécuter la classe WordCountDriver avec les chemins d'entrée et de sortie appropriés. Assurez-vous que le chemin de sortie n'existe pas précédemment.
```
hadoop jar./mywordcount.jar WordCountDriver /user/hadoop/input /output
```

Cette commande exécutera le travail MapReduce Hadoop en utilisant les formats d'entrée et de sortie personnalisés que nous avons définis.

Vérifier les résultats de la sortie

Utilisez la commande suivante pour vérifier si le fichier de résultat a été généré avec succès :

hdfs dfs -ls /output
hdfs dfs -cat /output/part.csv

Résumé

Félicitations! Dans ce laboratoire, vous avez réussi à explorer les subtilités de Hadoop MapReduce et à maîtriser la personnalisation des formats de sortie et d'entrée sous la direction du Ghost Tutor. De la création de classes Mapper et Reducer à la résolution de défis tels que la gestion de fichiers d'entrée non divisibles, vous avez acquis des connaissances précieuses. Grâce à des exercices pratiques, vous avez approfondi votre compréhension des capacités de Hadoop MapReduce et êtes désormais prêt à affronter les défis liés aux données avec confiance. Ce parcours n'a pas seulement amélioré vos compétences techniques, mais a également élargi votre vision du potentiel de Hadoop MapReduce pour le traitement des grands volumes de données.