Découvrir les mystères des données du désert avec Hadoop

Introduction

Dans l'immensité d'un désert aride, un marchand solitaire entreprend un voyage périlleux, cherchant à dévoiler les mystères cachés sous les sables brûlants. Le but du marchand est de découvrir des reliques et des artefacts anciens, déverrouillant les secrets d'une civilisation oubliée depuis longtemps. Cependant, la quantité considérable de données enterrées dans le désert pose un défi redoutable, nécessitant le pouvoir de Hadoop MapReduce pour traiter et analyser efficacement les informations.

Implémentation du Mapper

Dans cette étape, nous allons créer une classe Mapper pour traiter les données brutes obtenues des fouilles dans le désert. Notre objectif est d'extraire des informations pertinentes des données et de les préparer pour une analyse ultérieure par le Réducteur.

Utilisez la commande su - hadoop pour vous connecter en tant qu'utilisateur hadoop et accéder automatiquement au répertoire /home/hadoop. À ce moment-là, utilisez la commande ls. pour voir le fichier de données data*.txt. Ensuite, créez et remplacez le fichier ArtifactMapper.java dans ce répertoire selon le code ci-dessous :

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

public class ArtifactMapper extends Mapper<LongWritable, Text, Text, LongWritable> {

    private final static LongWritable ONE = new LongWritable(1);
    private Text word = new Text();

    @Override
    public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        // Divisez la ligne en mots
        String[] tokens = value.toString().split("\\s+");

        // Émettez chaque mot avec un compte de 1
        for (String token : tokens) {
            word.set(token);
            context.write(word, ONE);
        }
    }
}

Dans la classe ArtifactMapper, nous étendons la classe Mapper fournie par Hadoop. La méthode map est redéfinie pour traiter chaque paire clé-valeur d'entrée.

La clé d'entrée est un LongWritable représentant le décalage en octets de la ligne d'entrée, et la valeur d'entrée est un objet Text contenant la ligne de texte du fichier d'entrée.
La méthode map divise la ligne d'entrée en mots individuels en utilisant la méthode split et l'expression régulière "\\s+" pour correspondre à un ou plusieurs caractères d'espace.
Pour chaque mot, la méthode map crée un objet Text et l'émite comme clé, ainsi qu'une valeur LongWritable constante de 1 comme valeur, représentant le compte de ce mot.

Implémentation du Réducteur

Dans cette étape, nous allons créer une classe Réducteur pour agréger les données émises par le Mapper. Le Réducteur comptabilisera les occurrences de chaque mot et produira la sortie finale.

Créez et remplacez le fichier ArtifactReducer.java dans le répertoire /home/hadoop selon le contenu du code suivant :

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

public class ArtifactReducer extends Reducer<Text, LongWritable, Text, LongWritable> {

    @Override
    public void reduce(Text key, Iterable<LongWritable> values, Context context)
            throws IOException, InterruptedException {
        long sum = 0;
        for (LongWritable value : values) {
            sum += value.get();
        }
        context.write(key, new LongWritable(sum));
    }
}

Dans la classe ArtifactReducer, nous étendons la classe Reducer fournie par Hadoop. La méthode reduce est redéfinie pour agréger les valeurs associées à chaque clé.

La clé d'entrée est un objet Text représentant le mot, et les valeurs d'entrée sont un Iterable d'objets LongWritable représentant les comptages de ce mot émis par les Mappers.
La méthode reduce itère sur les valeurs et calcule la somme de tous les comptages pour le mot donné.
La méthode reduce émet ensuite le mot comme clé et le comptage total comme valeur, en utilisant context.write.

Création du Pilote

Dans cette étape, nous allons créer une classe Pilote pour orchestrer le travail MapReduce. Le Pilote configurera le travail, spécifiera les chemins d'entrée et de sortie et soumettra le travail au cluster Hadoop.

Créez et remplacez le fichier ArtifactDriver.java dans le répertoire /home/hadoop selon le contenu du code suivant :

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
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 ArtifactDriver {

    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf, "Artifact Word Count");

        // Spécifiez le fichier jar du travail par classe
        job.setJarByClass(ArtifactDriver.class);

        // Définissez les classes Mapper et Reducer
        job.setMapperClass(ArtifactMapper.class);
        job.setReducerClass(ArtifactReducer.class);

        // Définissez les types de clé et de valeur de sortie
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(LongWritable.class);

        // Définissez les chemins d'entrée et de sortie
        FileInputFormat.addInputPath(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));

        // Soumettez le travail et attendez sa fin
        System.exit(job.waitForCompletion(true)? 0 : 1);
    }
}

Dans la classe ArtifactDriver, nous créons un travail MapReduce et le configurons pour exécuter nos classes ArtifactMapper et ArtifactReducer.

La méthode main crée un nouvel objet Configuration et un objet Job avec un nom personnalisé "Artifact Word Count".
Les méthodes setMapperClass et setReducerClass sont utilisées pour spécifier les classes Mapper et Reducer à utiliser dans le travail.
Les méthodes setOutputKeyClass et setOutputValueClass sont utilisées pour spécifier les types de clé et de valeur de sortie pour le travail.
La méthode FileInputFormat.addInputPath est utilisée pour spécifier le chemin d'entrée pour le travail, qui est pris comme premier argument de ligne de commande.
La méthode FileOutputFormat.setOutputPath est utilisée pour spécifier le chemin de sortie pour le travail, qui est pris comme deuxième argument de ligne de commande.
La méthode job.waitForCompletion est appelée pour soumettre le travail et attendre sa fin. Le programme quitte avec un code de statut de 0 si le travail est réussi, ou 1 s'il échoue.

Compiler et exécuter le travail

Dans cette étape, nous allons compiler les classes Java et exécuter le travail MapReduce sur le cluster Hadoop.

Tout d'abord, nous devons compiler les classes Java :

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

Cette commande compile les classes Java et place les fichiers .class compilés dans le répertoire courant. L'option -classpath inclut les chemins de bibliothèque Hadoop, qui sont nécessaires pour compiler le code utilisant des classes Hadoop. Les paramètres -source et -target sont utilisés pour spécifier les versions de code source Java et de bytecode cible pour correspondre à la version de Java dans Hadoop

Ensuite, emballer un fichier class avec la commande jar :

jar -cvf Artifact.jar *.class

Enfin, nous pouvons exécuter le travail MapReduce, et toutes les données sur le désert sont déjà stockées dans le répertoire HDFS /input :

hadoop jar Artifact.jar ArtifactDriver /input /output

Après avoir exécuté la commande, vous devriez voir des journaux indiquant l'avancement du travail MapReduce. Une fois le travail terminé, vous pouvez trouver les fichiers de sortie dans le répertoire HDFS /output. Et utilisez la commande suivante pour afficher le résultat :

hdfs dfs -ls /output
hdfs dfs -cat /output/part-r-00000

Résumé

Félicitations ! Vous avez réussi à explorer le processus de codage des Mappers et des Réducteurs pour un travail MapReduce Hadoop. Guidé par un scénario impliquant un marchand du désert à la recherche de reliques anciennes, vous avez exploité le pouvoir de MapReduce Hadoop pour analyser de vastes données du désert. L'implémentation de la classe ArtifactMapper a extrait les données pertinentes, tandis que la classe ArtifactReducer a agrégé la sortie du Mapper. L'orchestration du processus avec la classe ArtifactDriver a encore renforcé votre compréhension. Tout au long, l'accent a été mis sur les meilleures pratiques, des exemples de code complets et des vérifications. Cette expérience pratique a approfondi votre compréhension de MapReduce Hadoop et mis en évidence une conception d'expérience d'apprentissage efficace.

Recherche de découvertes de données du désert