Meistern von Hadoop MapReduce: Anpassen von Eingabe- und Ausgabeformaten

Einführung

In diesem Lab lernst du, wie du die Ausgabe- und Eingabeformate in Hadoop MapReduce anpassen kannst, um Daten effektiv zu verarbeiten. Mit der geführten Anleitung des Ghost Tutors wirst du die Fähigkeiten erwerben, mit verschiedenen Datentypen umzugehen und das volle Potenzial des Hadoop-Ekosystems zu entfalten. Bereite dich auf eine spannende Reise vor, um die Kunst der Berechnung im übernatürlichen Bereich zu meistern!

Schreiben des Mappers und Reducers

In diesem Schritt tauchen wir in das Herz von Hadoop MapReduce ein und erstellen unsere eigenen Mapper- und Reducer-Klassen.

Untersuchen der Datendatei

Verwende zunächst den Befehl su - hadoop, um die Identität zu wechseln. Die Datendatei data.txt ist im Verzeichnis /user/hadoop/input des HDFS gespeichert, das die Inhalte von Gesprächen einiger Personen enthält. Verwende den folgenden Befehl, um die Inhalte anzuzeigen:

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

Anpassender Mapper

Als nächstes erstellen wir eine benutzerdefinierte Mapper-Klasse namens WordCountMapper, die von Mapper erbt. Dieser Mapper verarbeitet die Eingabedaten und emittiert Schlüssel-Wert-Paare. Beachten Sie, dass die verarbeiteten Daten der Inhalt jeder Zeile des Gesprächs sind, nicht die Namen der Personen. Verweisen Sie auf das folgende Beispiel, um die map-Methode in WordCountMapper.java unter /home/hadoop/ zu ergänzen.

@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
    // Konvertiere das Text-Objekt in einen String
    String line = value.toString();
    // Tokenisiere den String mit StringTokenizer
    StringTokenizer tokenizer = new StringTokenizer(line);
    // Iteriere über jedes Token und schreibe es in den Kontext
    while (tokenizer.hasMoreTokens()) {
        // Setze das aktuelle Wort
        word.set(tokenizer.nextToken().trim());
        // Schreibe das Wort und seine Anzahl in den Kontext
        context.write(word, one);
    }
}

Verwende dann den folgenden Befehl, um den Code in der Java 8-Version zu kompilieren:

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

Anpassender Reducer

Schließlich erstellen wir eine benutzerdefinierte Reducer-Klasse namens WordCountReducer, die von Reducer erbt. Dieser Reducer aggregiert die Werte für jeden Schlüssel und emittiert das endgültige Ergebnis. Ergänzen Sie die reduce-Methode in WordCountReducer.java unter /home/hadoop/ mit dem folgenden Beispiel.

@Override
protected void reduce(Text key, Iterable<IntWritable> values, Context context)
        throws IOException, InterruptedException {
    // Initialisiere eine Variable, um die Summe der Zählungen für jedes Wort zu speichern
    int sum = 0;
    // Iteriere über alle Zählungen für das aktuelle Wort und berechne die Gesamtzahl
    for (IntWritable value : values) {
        sum += value.get();
    }
    // Setze die endgültige Anzahl für das aktuelle Wort
    result.set(sum);
    // Schreibe das Wort und seine endgültige Anzahl in den Kontext
    context.write(key, result);
}

Verwende dann den folgenden Befehl, um den Code in der Java 8-Version zu kompilieren:

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

Schreiben benutzerdefinierter Eingabe- und Ausgabeformate

In diesem Schritt werden wir die Eingabe- und Ausgabeformate für den MapReduce-Job angeben.

Benutzerdefinierte Eingabeformat

Zunächst erstellen wir ein benutzerdefiniertes Eingabeformat, um Daten aus einer bestimmten Quelle zu lesen. Wir definieren eine Klasse namens PersonInputFormat, die von TextInputFormat erbt und die getCurrentValue-Methode überschreibt, um das Eingabeformat zu behandeln. Ergänzen Sie die getCurrentValue-Methode in PersonInputFormat.java unter /home/hadoop/ mit dem folgenden Beispiel.

@Override
public synchronized Text getCurrentValue() {
    // Gib den Wert des aktuellen Datensatzes zurück, teile ihn nach ":" auf, entferne die ersten und letzten Leerzeichen und setze ihn auf das Text-Objekt.
    Text value = new Text();
    Text line = super.getCurrentValue();
    String[] parts = line.toString().split(":");
    if (parts.length == 2) {
        value.set(parts[1].trim());
    }
    return value;
}

Verwende dann den folgenden Befehl, um den Code in der Java 8-Version zu kompilieren:

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

Benutzerdefiniertes Ausgabeformat

Als nächstes erstellen wir ein benutzerdefiniertes Ausgabeformat. Wir definieren eine Klasse namens CSVOutputFormat, die von TextOutputFormat erbt. Ergänzen Sie die write-Methode in CSVOutputFormat.java unter /home/hadoop/ mit dem folgenden Beispiel.

// Schreibe das Schlüssel-Wert-Paar in das Ausgabestrom im CSV-Format
@Override
public void write(Text key, IntWritable value) throws IOException, InterruptedException {
    out.writeBytes(key.toString() + "," + value.toString() + "\n");
}

Verwende dann den folgenden Befehl, um den Code in der Java 8-Version zu kompilieren:

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

Integration mit dem Treiber

In diesem letzten Schritt werden wir die Klasse WordCountDriver ändern, um die zuvor erstellten benutzerdefinierten Eingabe- und Ausgabeformate zu nutzen.

Benutzerdefinierter Treiber

Ergänzen Sie die main-Funktion von WordCountDriver.java unter /home/hadoop/ mit dem folgenden Beispiel.

// Setze die Mapper- und Reducer-Klassen
job.setMapperClass(WordCountMapper.class);
job.setReducerClass(WordCountReducer.class);

// Setze die Eingabeformatklasse auf das benutzerdefinierte Eingabeformat PersonInputFormat
job.setInputFormatClass(PersonInputFormat.class);

// Setze die Ausgabeformatklasse auf das benutzerdefinierte Ausgabeformat CSVOutputFormat
job.setOutputFormatClass(CSVOutputFormat.class);

Ausführen des Jobs

Um den Hadoop MapReduce-Job mit den benutzerdefinierten Eingabe- und Ausgabeformaten auszuführen, führen Sie die folgenden Schritte aus:

Kompilieren Sie WordCountDriver.java mit den entsprechenden Hadoop-Abhängigkeiten.

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

Erstellen Sie eine JAR-Datei, die die kompilierten Klassen enthält.
```
jar -cvf mywordcount.jar *.class
```
Führen Sie die Klasse WordCountDriver mit den entsprechenden Eingabe- und Ausgabe-Pfaden aus. Stellen Sie sicher, dass der Ausgabe-Pfad zuvor nicht existiert.
```
hadoop jar./mywordcount.jar WordCountDriver /user/hadoop/input /output
```

Dieser Befehl wird den Hadoop MapReduce-Job mit den benutzerdefinierten Eingabe- und Ausgabeformaten ausführen, die wir definiert haben.

Anzeigen der Ausgabenergebnisse

Verwenden Sie den folgenden Befehl, um zu überprüfen, ob die Ergebnisdatei erfolgreich erzeugt wurde:

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

Zusammenfassung

Herzlichen Glückwunsch! In diesem Lab hast du erfolgreich die Komplexitäten von Hadoop MapReduce erkundet und unter der Anleitung des Ghost Tutors die Anpassung von Ausgabe- und Eingabeformaten beherrscht. Von der Erstellung von Mapper- und Reducer-Klassen bis hin zur Bewältigung von Herausforderungen wie der Behandlung von nicht aufteilbaren Eingabedateien hast du wertvolle Erkenntnisse gewonnen. Durch praktische Übungen hast du dein Verständnis der Fähigkeiten von Hadoop MapReduce vertieft und bist jetzt in der Lage, Datenherausforderungen mit Zuversicht anzugehen. Diese Reise hat nicht nur deine technischen Fähigkeiten verbessert, sondern auch deine Perspektive auf das Potenzial von Hadoop MapReduce für die Big-Data-Verarbeitung erweitert.