Welche Rolle spielen JobTracker und TaskTracker von Hadoop in MapReduce?
Im MapReduce-Framework von Hadoop sind JobTracker und TaskTracker zwei Schlüsselkomponenten, die jeweils unterschiedliche Rollen spielen.
-
JobTracker:
- JobTracker ist eine der Hauptkomponenten von MapReduce und verantwortlich für die Koordinierung und Verwaltung des Ausführungsprozesses des gesamten Jobs (Job).
- JobTracker empfängt von Kunden eingereichte Jobanfragen und unterteilt die Jobs in mehrere Aufgaben (Tasks).
- JobTracker verwaltet Job-Metadaten, einschließlich Jobstatus, Fortschritt, Aufgabenzuordnung und andere Informationen.
- JobTracker weist Aufgaben verschiedenen TaskTrackern zur Ausführung zu, basierend auf den im Cluster verfügbaren Ressourcen und den Anforderungen der Aufgaben.
- Der JobTracker ist auch dafür verantwortlich, den Status des TaskTrackers zu überwachen und bei Bedarf Aufgaben neu zuzuweisen oder fehlgeschlagene Aufgaben neu zu starten.
- JobTracker ist auch für die Wiederherstellung nach Jobfehlern verantwortlich, z. B. für die erneute Ausführung fehlgeschlagener Aufgaben oder die Neuzuweisung abgeschlossener Aufgaben.
-
TaskTracker:
- TaskTracker ist eine weitere Hauptkomponente von MapReduce, die für die Ausführung bestimmter Aufgaben verantwortlich ist.
- TaskTracker wird auf jedem Knoten im Cluster ausgeführt und empfängt von JobTracker zugewiesene Aufgaben.
- TaskTracker ist für die Ausführung der Map-Phase und der Reduce-Phase der Aufgabe und das Zurückschreiben der Ergebnisse in HDFS verantwortlich.
- TaskTracker meldet regelmäßig den Status und Fortschritt der Aufgabe an JobTracker.
- TaskTracker ist außerdem dafür verantwortlich, den Ausführungsstatus von Aufgaben zu überwachen und Aufgaben erneut auszuführen, wenn Aufgaben fehlschlagen.
- TaskTracker ist auch für die lokale Datenlokalisierung verantwortlich, d. h. für die Zuweisung von Aufgaben an Knoten, auf denen Eingabedaten gespeichert werden, um die Datennetzwerkübertragung zu reduzieren.
Das Folgende ist ein einfacher Beispielcode, der die Rolle von JobTracker und TaskTracker in MapReduce demonstriert:
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.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.TaskAttemptID;
import org.apache.hadoop.mapreduce.TaskType;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import java.io.IOException;
public class WordCount {
public static class WordCountMapper extends Mapper<Object, Text, Text, IntWritable> {
private final static IntWritable one = new IntWritable(1);
private Text word = new Text();
public void map(Object key, Text value, Context context) throws IOException, InterruptedException {
String[] words = value.toString().split(" ");
for (String w : words) {
word.set(w);
context.write(word, one);
}
}
}
public static class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
private IntWritable result = new IntWritable();
public void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
int sum = 0;
for (IntWritable val : values) {
sum += val.get();
}
result.set(sum);
context.write(key, result);
}
}
public static void main(String[] args) throws Exception {
Configuration conf = new Configuration();
Job job = Job.getInstance(conf, "word count");
job.setJarByClass(WordCount.class);
job.setMapperClass(WordCountMapper.class);
job.setCombinerClass(WordCountReducer.class);
job.setReducerClass(WordCountReducer.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);
}
}
Im obigen Beispiel verwenden wir Java-Code, um ein einfaches Word Count-Programm über die Hadoop-API zu implementieren. Zuerst haben wir ein Konfigurationsobjekt erstellt, um die Konfigurationsinformationen des Hadoop-Clusters anzugeben. Dann haben wir ein Job-Objekt erstellt, das einen MapReduce-Job darstellt.
Wir definieren eine Mapper-Klasse (WordCountMapper), um die Eingabedaten in mehrere Schlüssel-Wert-Paare aufzuteilen und für jedes Schlüssel-Wert-Paar eine Zuordnungsoperation durchzuführen. In diesem Beispiel teilen wir die Eingabedaten durch Leerzeichen in Wörter auf und ordnen jedes Wort einem Schlüssel-Wert-Paar (Wort, 1) zu.
Wir definieren auch eine Reducer-Klasse (WordCountReducer) zum Zusammenführen und Berechnen von Werten desselben Schlüssels. In diesem Beispiel akkumulieren wir die Zählwerte derselben Wörter und geben die Ergebnisse als Schlüssel-Wert-Paare (Wort, Gesamtzahl) aus.
In der Methode main() konfigurieren wir den Eingabe- und Ausgabepfad des Jobs und geben die Klassen Mapper und Reducer an. Anschließend rufen wir die Methode job.waitForCompletion() auf, um den Job zu übermitteln und auf den Abschluss der Jobausführung zu warten.
In diesem Prozess ist JobTracker dafür verantwortlich, Jobanfragen zu empfangen, den Job in mehrere Aufgaben aufzuteilen und die Aufgaben verschiedenen TaskTrackern zur Ausführung zuzuweisen. JobTracker ist außerdem dafür verantwortlich, den Status und Fortschritt von Aufgaben zu überwachen und bei Bedarf Aufgaben neu zuzuweisen oder fehlgeschlagene Aufgaben erneut auszuführen.
TaskTracker ist dafür verantwortlich, Aufgaben zu empfangen, die Kartenphase und die Reduzierungsphase der Aufgabe auszuführen und die Ergebnisse zurück in HDFS zu schreiben. TaskTracker meldet regelmäßig den Status und Fortschritt der Aufgabe an JobTracker. TaskTracker ist auch für die lokale Datenlokalisierung verantwortlich, d. h. für die Zuweisung von Aufgaben an Knoten, auf denen Eingabedaten gespeichert werden, um die Datennetzwerkübertragung zu reduzieren.
Auf diese Weise implementiert das MapReduce-Framework verteiltes Rechnen, kann große Datenmengen verarbeiten und paralleles Rechnen erreichen. Die Zusammenarbeit von JobTracker und TaskTracker ermöglicht die effiziente Ausführung des gesamten MapReduce-Jobs mit Fehlertoleranz und Skalierbarkeit.