Entdeckungsreise durch die Wüstdaten

Einführung

In der weitläufigen Wüste eines Wüstengebietes begibt sich ein einzelner Kaufmann auf eine gefährliche Reise, um die Geheimnisse zu entwirren, die unter den brennenden Sands verborgen sind. Das Ziel des Kaufmanns ist es, alte Relikte und Artefakte zu entdecken und die Geheimnisse einer längst vergessenen Zivilisation zu enthüllen. Die enorme Menge an Daten, die in der Wüste verborgen ist, stellt jedoch eine gewaltige Herausforderung dar und erfordert die Macht von Hadoop MapReduce, um die Informationen effektiv zu verarbeiten und zu analysieren.

Skills Graph

Implementierung des Mappers

In diesem Schritt werden wir eine Mapper-Klasse erstellen, um die Rohdaten aus den Wüstenausgrabungen zu verarbeiten. Unser Ziel ist es, relevante Informationen aus den Daten zu extrahieren und sie für die weitere Analyse durch den Reducer vorzubereiten.

Verwenden Sie den Befehl su - hadoop, um sich als Benutzer hadoop zu wechseln und automatisch in das Verzeichnis /home/hadoop zu gelangen. Verwenden Sie dann den Befehl ls., um die Datendatei data*.txt zu sehen. Erstellen Sie dann in diesem Verzeichnis die Datei ArtifactMapper.java und füllen Sie sie gemäß dem folgenden Code:

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 {
        // Split the line into words
        String[] tokens = value.toString().split("\\s+");

        // Emit each word with a count of 1
        for (String token : tokens) {
            word.set(token);
            context.write(word, ONE);
        }
    }
}

In der Klasse ArtifactMapper erweitern wir die von Hadoop bereitgestellte Mapper-Klasse. Die map-Methode wird überschrieben, um jedes Eingabe-Schlüssel-Wert-Paar zu verarbeiten.

1. Der Eingabeschlüssel ist ein LongWritable, das den Byteoffset der Eingabezeile darstellt, und der Eingabewert ist ein Text-Objekt, das die Zeile aus dem Eingabedatei enthält.
2. Die map-Methode teilt die Eingabezeile in einzelne Wörter auf, indem sie die split-Methode und die reguläre Ausdruck "\s+" verwendet, um ein oder mehrere Leerzeichen zu finden.
3. Für jedes Wort erstellt die map-Methode ein Text-Objekt und gibt es als Schlüssel aus, zusammen mit einem konstanten LongWritable-Wert von 1 als Wert, was die Anzahl dieses Worts darstellt.

Implementierung des Reducers

In diesem Schritt werden wir eine Reducer-Klasse erstellen, um die von der Mapper-Klasse emittierten Daten zu aggregieren. Der Reducer wird die Vorkommen jedes Wortes zählen und die endgültige Ausgabe erzeugen.

Erstellen Sie in dem Verzeichnis /home/hadoop die Datei ArtifactReducer.java und füllen Sie sie gemäß dem folgenden Codeinhalt:

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));
    }
}

In der Klasse ArtifactReducer erweitern wir die von Hadoop bereitgestellte Reducer-Klasse. Die reduce-Methode wird überschrieben, um die mit jedem Schlüssel assoziierten Werte zu aggregieren.

1. Der Eingabeschlüssel ist ein Text-Objekt, das das Wort darstellt, und die Eingabewerte sind ein Iterable von LongWritable-Objekten, die die Zählungen dieses Wortes darstellen, die von den Mappern emittiert wurden.
2. Die reduce-Methode iteriert über die Werte und berechnet die Summe aller Zählungen für das gegebene Wort.
3. Die reduce-Methode gibt dann das Wort als Schlüssel und die Gesamtzahl als Wert aus, indem sie context.write verwendet.

Erstellung des Fahrers

In diesem Schritt werden wir eine Fahrer-Klasse erstellen, um die MapReduce-Aufgabe zu orchestrieren. Der Fahrer wird die Aufgabe konfigurieren, die Eingabe- und Ausgabepfade angeben und die Aufgabe an den Hadoop-Cluster übermitteln.

Erstellen Sie in dem Verzeichnis /home/hadoop die Datei ArtifactDriver.java und füllen Sie sie gemäß dem folgenden Codeinhalt:

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");

        // Specify the job's jar file by class
        job.setJarByClass(ArtifactDriver.class);

        // Set the Mapper and Reducer classes
        job.setMapperClass(ArtifactMapper.class);
        job.setReducerClass(ArtifactReducer.class);

        // Set the output key and value types
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(LongWritable.class);

        // Set the input and output paths
        FileInputFormat.addInputPath(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));

        // Submit the job and wait for completion
        System.exit(job.waitForCompletion(true)? 0 : 1);
    }
}

In der Klasse ArtifactDriver erstellen wir eine MapReduce-Aufgabe und konfigurieren sie, um unsere Klassen ArtifactMapper und ArtifactReducer auszuführen.

1. Die main-Methode erstellt ein neues Configuration-Objekt und ein Job-Objekt mit einem benutzerdefinierten Namen "Artifact Word Count".
2. Die Methoden setMapperClass und setReducerClass werden verwendet, um die Mapper- und Reducer-Klassen anzugeben, die in der Aufgabe verwendet werden sollen.
3. Die Methoden setOutputKeyClass und setOutputValueClass werden verwendet, um die Ausgabeschlüssel- und -werttypen für die Aufgabe anzugeben.
4. Die Methode FileInputFormat.addInputPath wird verwendet, um den Eingabepfad für die Aufgabe anzugeben, der als erster Befehlszeilenparameter genommen wird.
5. Die Methode FileOutputFormat.setOutputPath wird verwendet, um den Ausgabepfad für die Aufgabe anzugeben, der als zweiter Befehlszeilenparameter genommen wird.
6. Die Methode job.waitForCompletion wird aufgerufen, um die Aufgabe zu übermitteln und auf deren Abschluss zu warten. Das Programm beendet sich mit einem Statuscode von 0, wenn die Aufgabe erfolgreich ist, oder 1, wenn sie fehlschlägt.

Kompilieren und Ausführen der Aufgabe

In diesem Schritt werden wir die Java-Klassen kompilieren und die MapReduce-Aufgabe auf dem Hadoop-Cluster ausführen.

Zunächst müssen wir die Java-Klassen kompilieren:

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

Dieser Befehl kompiliert die Java-Klassen und legt die kompilierten .class-Dateien im aktuellen Verzeichnis ab. Die Option -classpath enthält die Hadoop-Bibliothekswege, die erforderlich sind, um den Code zu kompilieren, der Hadoop-Klassen verwendet. Die Parameter -source und -target werden verwendet, um die Java-Quell- und Zielbytecode-Versionen anzugeben, um der Version von Java in Hadoop zu entsprechen.

Als nächstes packen wir die class-Dateien mit dem jar-Befehl:

jar -cvf Artifact.jar *.class

Schließlich können wir die MapReduce-Aufgabe ausführen. Alle Daten über die Wüste sind bereits im HDFS-Verzeichnis /input gespeichert:

hadoop jar Artifact.jar ArtifactDriver /input /output

Nach der Ausführung des Befehls sollten Sie Protokolle sehen, die den Fortschritt der MapReduce-Aufgabe anzeigen. Nachdem die Aufgabe abgeschlossen ist, können Sie die Ausgabedateien im HDFS-Verzeichnis /output finden. Und verwenden Sie den folgenden Befehl, um das Ergebnis anzuzeigen:

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

Zusammenfassung

Herzlichen Glückwunsch! Sie haben den Prozess des Codierens von Mappern und Reducern für eine Hadoop MapReduce-Aufgabe erfolgreich untersucht. Anhand eines Szenarios, in dem ein Wüstenhändler alte Relikte sucht, haben Sie die Macht von Hadoop MapReduce genutzt, um riesige Wüstendaten zu analysieren. Die Implementierung der Klasse ArtifactMapper hat relevante Daten extrahiert, während die Klasse ArtifactReducer die Mapper-Ausgabe aggregiert hat. Die Orchestrierung des Prozesses mit der Klasse ArtifactDriver hat Ihr Verständnis weiter verfestigt. Im gesamten Prozess wurde der Schwerpunkt auf bewährte Praktiken, vollständige Codebeispiele und Verifikationsprüfungen gelegt. Diese praktische Erfahrung hat Ihren Griff auf Hadoop MapReduce vertieft und eine effektive Lernumfahrungsmöglichkeit gezeigt.