MapReduce & Apache Hadoop

MapReduce & Apache Hadoop
Paralleles Rechnen in Clustern

Oliver Fischer Technische Universität Berlin
ofischer@swe-blog.net 22. Januar 2010

MapReduce & Apache Hadoop Folie 2

Inhalt

Einführung
MapReduce
Grundlagen
Funktionsweise
Beispiele
Zusammenfassung
Apache Hadoop
Geschichte
Architektur
MapReduce-Anwendungen mit Hadoop
Beispiele
Zusammenfassung
Fazit
Quellen

MapReduce
Programmiermodell zur parallelen Verarbeitung von großen Datenständen
Grundlagen∙ Funktionsweise ∙ Beispiele

Grundlagen ∙ Funktionsweise ∙ Beispiele

MapReduce vorgestellt

Was ist und kann MapReduce?
• Programmiermodell zur Verarbeitung und Erzeugung von großen
Datenbeständen
• Ausgelegt für die parallele Verarbeitung von Datenbeständen in großen
Clustern auf Standardhardware
• Auslegung auf hohe Fehlertoleranz

Woher kommt MapReduce?
• Entwickelt durch Google zur Verarbeitung von Rohdaten
• Inspiriert duch Lisp und dessen Funktionen map und reduce


map und reduce in Lisp

map-Funktion – Abbildung zwischen Listen
• Eingabe ist eine Sequenz von Werten und eine Funktion
• Übergebene Funktion verarbeitet sequentiell alle Werte
• Ergebnis der übergebenen Funktion wird durch map ebenfalls als
Sequenz zurückgegeben

reduce-Funktion – Zusammenfassung von Listen
• Eingabe ist eine Sequenz von Werten und eine binäre Funktion
• Binäre Funktion verbindet alle Werte der Eingabesequenz
• Ergebnis ist ein einfacher Wert


Notizen zu MapReduce

Grundannahme von MapReduce
Die Datenübertragungsrate (network bandwidth) ist die begrenzende
Ressource in Clustern. Es ist effizienter die Berechnung zu den Daten zu
bringen.

Was ist neu anders?
Klassischer Ansatz: Daten zum Programm

Was man vorher wissen sollte
• Google nutzt für MapReduce-Anwendungen ein verteiltes Dateisystem
(Google File System)
• Worker führen auf Map- und Reduce-Funktionen verteilt im Cluster aus
• Zentraler Master koordiniert Ausführung


MapReduce als Programmiermodell allgemein

Programmiermodell von MapReduce
• Map-Phase und Reduce-Phase
• Parallelisierung durch Phasen
• Jede Phase wird parallel ausgeführt
• Eingabedaten auf verschiedene Rechnern
• Voraussetzung ist Partitionierbarkeit

Beispiele
• Zähle alle Wörter in einem Text
• Zähle alle Referer im Logfile


Map-Phase von MapReduce

Aufgabe
• Verarbeitung von Eingabedaten und Erzeugung von Zwischenwerten

Signatur
map(k1,v1) → list(k2,v2)

Funktionsweise
• Eingabe ist Schlüssel-Wert-Paar
• Ausgabe beliebig vieler intermediate key/value pairs
• Map-Funktion wird vom Anwender implementiert

Beispiel
map(String key, String value):
// key: document name,
// value: document contents
for each word w in value:
EmitIntermediate(w, "1");


Reduce-Phase von MapReduce

Aufgabe
• Zusammenfassung der Zwischenergebnisse, Bereitstellung des Endergebnisses

Signatur
reduce(k2,list(v2)) → list(v2)

Reduce-Phase
• Eingabe ist Schlüssel und Werte-Menge zu diesem Schlüssel
• Ausgabe von Reduce meistens null oder ein Wert

Beispiel
reduce(String key, Iterator values):
// key: a word, values: a list of counts
int result = 0;
for each v in values:
result += ParseInt(v);
Emit(AsString(result));


MapReduce als Programmiermodell schematisch

Worker File
Split 0
map-Funktion File
Split 1 Worker
reduce- File
Funktion
Split 2
Eingabe

Split 3
Worker File
map-Funktion File
Split 4

Split 5 Worker
reduce- File
Split 6 Funktion
Worker File
Split 7 map-Funktion File

Eingabedateien Map-Phase Zwischen- Reduce-Phase Ergebnisse
ergebnisse


MapReduce-Beispiel

Aufgabe: Zähle die Wortvorkommen im folgenden Text: „Arme haben Arme. Arme
haben Beine. Beine haben keine Arme. Arme Beine!“

Worker
Arme haben Arme. Arme haben Beine. Beine haben

Arme 3
Arme map-Funktion Beine 1
haben haben 2
Arme.
Arme
haben
Beine.
Arme 5
Worker Beine 3
reduce- haben 3
Funktion keine 1
keine Arme. Arme Beine!

Beine
haben
keine
Arme.
Arme
Beine! Arme 2
Worker Beine 2
map-Funktion haben 1
Keine 1

ergebnisse

Grundlagen ∙ Funktionsweise ∙ Beispiele ∙ Zusammenfassung

Zusammenfassung zur MapReduce

Zusammenfassung
• Wurzeln von MapReduce in funktionaler Programmierung
• MapReduce ist ein Programmiermodel, kein Algorithmus
• Zwei-Phasen-Modell: Map und Reduce
• Auslegung auf möglichst hohe Parallelität bei Verarbeitung
• Neuer Ansatz: Berechnung findet bei den Daten statt, nicht Daten
kommen zur Berechung
• Anwendbar bei allen Problemen mit partitionierbaren Eingaberaum
• Je kleiner mögliche Partitionen, desto höher erreichbare Parallelität

Apache Hadoop
Freies Framework für MapReduce-Anwendungen
Geschichte ∙ Architektur ∙ MapReduce-Anwendungen ∙ Beispiele

Geschichte ∙ Architektur ∙ MapReduce-Anwendungen ∙ Beispiele ∙ Zusammenfassung

Geschichte von Apache Hadoop

Entstehungsgeschichte von Apache Hadoop
• Februar 2003: erste Google-interne MapReduce-Implementierung
• Oktober 2003: The Google Filesystem veröffentlicht
• Dezember 2004, MapReduce: Simplifed Data Processing on Large
Clusters veröffentlicht
• 2005: Erste Implementierung im Suchmaschinen-Framework Nutch der
Apache Software Foundation(Doug Cutting)
• Februar 2006: Hadoop wird Subprojekt bei Apache Lucene
• 2008: Hadoop wird Apache Top-Level-Projekt
• 2009: Hadoop wird in Subprojekte aufgeteilt und neue Projekte auf
Hadoop-Basis entstehen
• Juli 2009: Ein Hadoop-Cluster gewinnt den Terabyte Sort Benchmark


Komponenten von Apache Hadoop

Hadoop Distributed File System
• Verteiltes Dateisystem nach den Vorbild des Google File
Systems
• Verteilung der Daten im Hadoop-Cluster
• Kernkomponenten sind NameNode und DataNodes

MapReduce
• Framework zur Entwicklung von Anwendungen nach dem
MapReduce-Programmiermodell
• Kernkompenten sind der JobTracker und TaskTracker


Das Hadoop Distributed File System (HDFS)

Eigenschaften
• Verteiltes Dateisystem, designt unter der Annahme, das
Hardwareausfälle normal sind
• Kapazität bis in den Petabyte-Bereich
• Grundnahme: Daten einmal geschrieben, oft gelesen, aber nicht mehr
verändert
• Blockorientiert, Dateien werden in Blöcke aufgeteilt, welche im Cluster
verteilt werden
• Datensicherheit durch Blockreplikation
• Komponenten sind NameNode, SecondaryNameNode und DataNodes


Komponenten des HDFS: NameNode und SecondaryNameNode

NameNode
• Verwaltet die Metadaten des HDFS
• Koordiniert die Verteilung von Dateien im HDFS
• Stellt nur Metadaten zur Verfügung, kein Datentransfer
• Regelt den Zugriff von Clients auf die Dateien im FileSystem
• Überwacht das HDFS auf Ausfälle von Nodes

SecondaryNameNode
• Backupt die Änderungen seit dem letzten Start des HDFS an den HDFS-
Metadaten


Komponenten des HDFS: DataNode

DataNode
• Verwaltet Blöcke der Dateien auf den Clusternodes
• Ein DataNode pro Clusternode
• Meldet seinen Zustand per Heartbeat an den NameNode
• Zuständig für den Datentransfer der Blöcke zu anderen DateNodes und
zu anfragenden Clients


Das MapReduce-Framework von Hadoop

Eigenschaften
• MapReduce-Programmiermodel
• Grundfunktionalität abgedeckt
• Entwickler stellt Map- und Reduce-Funktion
• Grundfunktionalität über eigene Implementierungen änderbar
• MapReduce-Anwendung wird als Job bezeichnet
• Kernkomponenten sind der JobTracker und der TaskTracker


JobTracker und TaskTracker

JobTracker
• Verteilt Map-Tasks und Reduce-Tasks auf Cluster-Nodes
• Steuert die Ausführung der Jobs im Cluster
• Überwacht die Ausführung der Tasks und startet ggf. Tasks neu
• Pro Cluster nur ein JobTracker

TaskTracker
• Führt Map- oder Reduce-Task lokal auf einem Node im Cluster aus
• Sendet Statusinformationen an JobTracker
• Beliebig viele TaskTracker möglich


Beispiel-Mini-Hadoop-Cluster
«flow »

sl01.h ado o p : Server sl03.h ado o p : Server
z eus.h ad o op : S erver

: TaskTr acke r : TaskTr acke r

: JobTrack er
«flow »

: Data Node : Data Node

: Name Node

«flow » «flow » «flow »
«flow »

«flow »
«flow »
sl02.h ado o p : Server sl04.h ado o p : Server
: Se condar yName Node

: Data Node : Data Node

: TaskTr acke r : TaskTr acke r

«flow »

Ein Mini-Cluster mit fünf Knoten


MapReduce-Anwendungen mit Hadoop

Allgemeines
• Hadoop stellt komplettes Framework für MR-Anwendung bereit
• Funktionsweise im Wesentlichen analog zu Googles MapReduce-
Programmiermodell
• Entwickler kann sich auf Map- und Reduce-Funktion beschränken
• Entwickler kann durch eigene Implementierungen Hadoop-Verhalten
ändern
• Ausführung von Jobs erfolgt sequentiell (Standardverhalten)


Zuständigkeiten in einem MapReduce-Job

Eingabe lesen;
Job Configuration Aufteilung in Splits
Format und Ort der Input Splitting &
Distribution
Eingabe Input Format Verarbeitung der
Input Location Splits (einer pro Task)
Start of Map Tasks

Map-Funktion Mapper
Sortierung Map-
Ausgabe;
Shuffle, Partition/Sort per
Zuordnung der Map Output
Partitionierung für
Mapper-Ausgabe Partitioner Reducer
zu Reducer-Task
Anzahl der Reducer Merge Sort for Map Zusammenfügen der
Outputs for each Map-Partitionen für
Reducer-Funktion Reducer Reduce Task
jeden Reducer

Ausgabetyp der Output Key Type
Map-Funktion Start of Reduce Tasks
Zusammenfassung
Output Key Value der Ergebnisse einer
Partition
Format und Ort Output Format
der Ausgabe Output Location
Collection of Final Output Ausgabe der
Ergebnisse

Benutzer Hadoop-
Framework Quelle: Nach Venner


Zuständigkeiten in einem MapReduce-Job

Worker File
Split 0
map-Funktion File
Split 1 Worker
reduce- File
Funktion
Split 2
Eingabe

Split 3
Worker File
map-Funktion File
Split 4

Split 5 Worker
reduce- File
Split 6 Funktion
Worker File
Split 7 map-Funktion File

ergebnisse

Mapper.class Reducer.class
Framework Partitioner.class Framework


Erstellung einer MapReduce-Anwendung

MapReduce-Anwendungen schreiben
• Zentrale Framework-Klassen sind Job und Configuration
• Job stellt die „Sicht des Ausführenden auf den Job“ dar
• Über Job-Klasse legt Entwickler fest:
• Eingabe- und Ausgabeformate
• Implementierung der Map- und Reduce-Funktion
• Anzahl der Reducer
• Partionierungsfunktion
• Configuration dient zur Übergabe von Ressourcen an den Job
• Anwendung selber normale Klasse mit main()-Methode
• Anwendung wird über Shell-Skript an Hadoop übergeben


Beispielanwendung: Logfile-Sortierung

Anwendungsszenario (etwas konstruiert…)
• Eine Anwendung läuft verteilt auf unterschiedlichen Servern
• Anwendung setzt Geschäftsprozesse um
• Einzelne Schritte eines Geschäftsprozesses können auf
unterschiedlichen Servern ausgeführt werden
• Jeder Prozesschritt wird in ein lokales Logfile geschrieben
• Regelmäßig müssen alles Schritte eines Prozesses zusammengesucht
werden, um die Prozesse analysieren zu können
• Problem: Logfile-Einträge sind auf unterschiedliche Files aufgeteilt und
da wir natürlich sehr erfolgreich sind, sind unsere Logfiles riesig…


LogFileSorter – Der Mapper

Standard-Implementierung als Identitätsfunktion
protected void map(KEYIN key, VALUEIN value,
Context context) throws IOException, InterruptedException {
context.write((KEYOUT) key, (VALUEOUT) value);
} Input Format erzeugt Eingabe-Schlüssel und
-Werte
Mapper für die Logfile-Sortierung (Klasse TextInputFormat übergibt
public class LFSMapperSort Zeilennummer als Key und die Zeile selbst als
extends Mapper<LongWritable, Text, LFSBPKey, Text> { Value)
private LFSBPKey bpKey = new LFSBPKey();

protected void map(LongWritable key, Text value, Context context)
throws IOException, InterruptedException
{ Ermittlung der Business Process ID und des
String logLine = value.toString();
Schritts
int firstBlank = logLine.indexOf(" ");
int firstSlash = logLine.indexOf("/");

String bpidAsString = logLine.substring(3, firstSlash);
String step = logLine.substring(firstSlash + 1, firstBlank);

bpKey.set(Integer.valueOf(bpidAsString), Integer.valueOf(step));

context.write(bpKey, value);
}
Erzeugung des Keys für die Ausgabe
} Key vom Framework für Sortierung vor der
Ausgabe von erzeugtem Schlüssel und Wert Reduce-Phase benutzt


LogFileSorter – Der Reducer

Standard-Implementierung als Identitätsfunktion
protected void reduce(KEYIN key, Iterable<VALUEIN> values, Context context)
throws IOException, InterruptedException {
for (VALUEIN value: values) {
context.write((KEYOUT) key, (VALUEOUT) value);
}
}

Reducer für die Logfile-Sortierung
public class LFSReducer
extends Reducer<LFSBPKey, Text, Text, Text> {

protected void reduce(LFSBPKey key, Iterable<Text> values, Context context)
throws IOException, InterruptedException
{ Eingabe: vom Mapper erzeugte Schlüssel und
for (Text value: values) {
context.write(null, value); alle Werte zum gleichen Schlüssel
}
}
}

Reducer arbeitet immer auf allen Werten
eines Schlüssels
Key wird verworfen
Ausgabe nur eigentliche Logzeile


LogFileSorter – Der Job

public class LogFileSorter {
Auswertung der Befe
public static void main(String[] args)
throws IOException, ClassNotFoundException, InterruptedException
{
Configuration conf = new Configuration();
String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();

Job job = new Job(conf, LogFileSearch.class.getSimpleName());

job.setJarByClass(LogFileSearch.class);
job.setInputFormatClass(TextInputFormat.class);
job.setMapperClass(LFSMapperSearch.class);
job.setOutputKeyClass(LFSBPKey.class); Konfiguration des Jobs
job.setOutputValueClass(Text.class); (Zuweisung der Zuständigkeiten)
job.setPartitionerClass(LFSBPPartioner.class);
job.setReducerClass(LFSReducer.class);

FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
FileInputFormat.setInputPathFilter(job, LFSPathFilter.class); Konfiguration der Job-
FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
Eingabe und der Job-
System.exit(job.waitForCompletion(true) ? 0 : 1); Ausgabe
}
}


Zusammenfassung zur Apache Hadoop

Zusammenfassung
• Vollständiges Framework für MapReduce-Anwendungen
• Führendes freies MapReduce-Framework
• Anpassbar durch Austausch von Komponenten durch eigene
Implementierungen
• Basis für viele Hadoop-Subprojekte
• Praxis-Einsatz bei Yahoo!, Facebook, last.fm


Fazit

Fazit zu MapReduce
• MapReduce ist ein Programmiermodell für parallele Datenverarbeitung
in Rechnerclustern
• Sehr gut geeignet für Probleme die sich partitionieren lassen
• Nicht für alle Probleme (z.B. Wettersimulation)

Fazit zu Apache Hadoop
• Apache Hadoop stellt kompletes MapReduce-Framework frei zur
Verfügung
• Erfolg von MapReduce und Apache Hadoop durch
Komplexitätsreduktion (z.B. durch Akzeptanz von Ausfällen im System)


Quellen

Verwendete Quellen
• Sanjay Ghemawat, Howard Gobioff, Shun-Tak Leung. The Google
Filesystem. In: ACM SIGOPS Operating Systems Review, Volume 37,
Issue 5, December 2003, ISSN 0163-5980, Seiten 29-43, ACM, New York,
NY, USA
• Jeffrey Dean, Sanjay Ghemawat. MapReduce: simplied data processing
on large clusters. In: Communications of the ACM, Volume 51, Issue 1,
Januar 2008, ISSN 0001-0782, Seiten 107-113, ACM, New York, NY, USA
• Jason Venner. Pro Hadoop, Build scalable, distributed applications in the
cloud. ISBN 978-1-4302-1942-2, Apress, 2009
• Webseite des Hadoop-Projekts (http://hadoop.apache.org)
• Source-Code des Hadoop-Projekts

MapReduce & Apache Hadoop

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Andere mochten auch

Andere mochten auch (20)

MapReduce & Apache Hadoop