Docstoc

Cloud Computing - Einführung -

Document Sample
Cloud Computing - Einführung - Powered By Docstoc
					         Systemanalyse
- Cloud Computing (Architektur)-
           Carsten Binnig
         (DHBW Mannheim)
                      Übersicht
• Motivation

• Klassifikation

• Herausforderungen

• Anbieter

• Systementwicklung (Parallele Programmierung)
                      Übersicht
• Motivation

• Klassifikation

• Herausforderungen

• Anbieter

• Systementwicklung (Parallele Programmierung)
                   Cloud Computing

1. Geschäftsidee       2. Umsetzung    4. Erfolg!




                       3.3. Erfolg?:
                         Misserfolg!
Cloud Computing: Idee


  Dienst-Nutzung


                       Dienst
       Dienst            2
         1

                   Dienst
                     3


      SLA (Service Level Agreements)
          Cloud Computing: Details
Computing as a utility (englische Begriff „utility“ bezieht sich auf
Versorgungsleistungen v.A. Wasser, Strom, ...)

IT-Dienste (Infrastruktur, Systeme, Anwendungen) als
Versorgungsleistung über das Internet (bzw. Intranet)

Service Level Aggreements (SLAs) bestimmen die geforderte Dienst-
Güte (z.B. Anfragezeiten, Kosten)

Basiert auf der Idee von Service-orientierten Architekturen

Beispiele: Amazon WebServices, Google AppEngine, Microsoft Azure,
Salesforce.com
  Service-orientierte Architektur (SOA)
Begriffsdefinition: „Service-oriented Architecture (SOA) ist ein
Paradigma für die Organisation und Verwendung verteilter
Fähigkeiten, die unter der Kontrolle verschiedener
Besitzerdomänen stehen können.“

Use Cases:
         Cloud Computing: Analogie




Traditionell: „Kuh im Stall“   Neu: „Milch aus der Packung“
• Hohe Investitionskosten      • Bezahlung nach Nutzung
• Hohe Wartungskosten          • Geringe Investitions- und
                                 Wartungskosten (Kühlschrank, ...)
• Produziert fixe Menge        • Skaliert in kleinen Schritten
• Nur stufenweise skalierbar   • Fehlertolerant
• Hohes Fehlerrisiko
Cloud Computing: Marktpotential
Cloud Computing: Dienste

                                     ERP-Systeme, CRM-Systeme,
  SaaS (Software as a Service)
                                     Office-Lösungen, ...



                                     Datenbanken, Message Queues,
  PaaS (Platform as a Service)
                                     Applikationsserver, ...



IaaS (Infrastructure as a Service)   Virtuelle Maschinen, ...
        Infrastructure as a Service
Bereitstellung von IT-Infrastruktur Komponenten
• Rechner
• Betriebssysteme / Dateisysteme
• Firewalls, Router, …

Beispiel: Amazon EC2 (Elastic Compute Cloud)
• Anmieten virtueller Maschinen
• Installation und Ausführung beliebiger Software-Systeme
            Platform as a Service
Bereitstellung von Entwicklungs- und Hosting-Umgebungen

Beispiele:
• Google App Engine: Plattform zum Entwickeln und Ausführen
  von Webanwendungen
• Microsoft Azure: Plattform zum Entwickeln im Wesentlichen
  auf .NET Bases
          Application as a Service
Komplette Anwendungen werden als Dienste über das Internet
bereitgestellt
• Keine lokale Software-Installation, Datenhaltung
• Universeller Zugang mittels Browser/Thin Client

Beispiele:
• Google Apps: Google Mail, Google Docs, Google Calendar
• Salesforce.com: ERP-, CRM-Systeme
• SAP ByD: ERP-, CRM-Systeme
           Cloud: Betriebsmodelle
Öffentliche (Public) Clouds: Dienste über öffentliche Netzen
zugänglich (Anbieter und Anwender gehören zu
unterschiedlichen Unternehmen)

Private Clouds: Dienste über private Netze zugänglich (Anbieter
und Anwender gehören zu gleichem Unternehmen)

Hybride Clouds: Dienste teilweise über öffentliche Netzen und
private Netze zugänglich
                    Hybride Clouds




                                                                Öffentliches Netz
                      Public Cloud

              Dienst 1                       Dienst 4




       „Cloud-Bursting“                        Dienst-Nutzung
(Replikation zu Lastverteilung)




                                                                Unternehmensnetz
                      Private Cloud
                                    Dienst
                  Dienst              2
                    1

                           Dienst
                             3
 Cloud Computing: Charakteristika
Ressourcen: Illusion unendlich verfügbarer Ressourcen

Virtualisierung: Gemeinsame Nutzung von Ressourcen durch
viele Nutzer

Elastizität: Schnelle Belegung/Freigabe von Ressourcen nach
Bedarf

Nutzungsabhängige Abrechnung: keine Anfangsinvestition und
Abrechnung nach Verbrauch (CPU, Speicherplatz, ...)
            Vorteile für Anwender
•   Kein Einrichten/Betreiben eigener Rechenzentren
•   Keine langfristige Ressourcenplanung
•   Automatische Anpassung an Nutzerlast (Elastizität)
•   Konzentration auf Kernkompetenzen
•   Kürzere „Time-to-Market“ Zyklen
•   Keine hohen Vorabinvestitionen: Anlagekosten können in
    Betriebskosten umgewandelt werden

Folge: Minimierung des unternehmerischen Risikos
     Vorteile für Anwender: Elastizität
Traditionell:                                Kapazität
                Rechenleistung




                                                                  Rechenleistung
                                                                                          Kapazität




                                                           Zeit                                           Zeit
                                     a) Overprovisioning                           b) Underprovisioning

                                              Kapazität
                    Rechenleistung




Cloud:




                                                           Zeit
             Vorteile für Anbieter
• Vermarktung schon verfügbarer Ressourcen durch zahlende
  Kunden (z.B. Amazon, Google, Facebook)
• Große Rechenzentren (50.000 Server) haben im Vergleich zu
  mittelgroßen (1000 Server) nur 1/5 - 1/7 der Kosten
• Bessere Auslastung der Rechenzentren gegenüber lokalen
  Rechenzentren
• Existierende Kunden halten / Migrationspfade (z.B. Microsoft
  Azure, SAP ByD)

Folge: Gewinn durch „Economy of Scale“ (Kostenvorteile)
   Vorteile für Anbieter: Kostenvorteile
Kostenart        Kosten (mittleres    Kosten (großes   Verhältnis
                 Rechenzentrum)       Rechenzentrum)
Netzwerk         $95 pro              $13 pro          7.1
                 Mbit/Sek/Monat       Mbit/Sek/Monat
Speicher         $2.20 pro            $0.40 pro        5.7
                 GB/Monat             GB/Monat
Administration   140 Server / Admin   >1000 Server /   7.1
                                      Admin
 Vorteile für Anbieter: Standortvorteile
Kosten pro KWH   Ort          Gründe
3.6 Cent         Idaho        Wasserkarftwerke, kurze Distanzen
10.0 Cent        California   Weite Distanzen, Hohe Steuern, Billige Energien
                              (Kohle) verboten
18.0 Cent        Hawaii       Sehr weite Distanzen
  Neue Anwendungsmöglichkeiten (1)
Parallele Batch-Prozessierung:
• Parallele Verarbeitung großer Datenmengen
• Beispiel: Automatische Suche nach Flugzeug-Absturzstellen in
  Satellitenbildern

Online-Analytics:
• Analyse großer Mengen von Unternehmensdaten
• Beispiel: Aktueller Jahres-/Monats-/Tagesumsatz nach
  Produkt/Region/...
  Neue Anwendungsmöglichkeiten (2)
Erweiterungen von Mobilen-Anwendungen:
• Auslagern von rechenintensiven Anwendungen in die „Cloud“
• Beispiel: Bilderkennung
• Zugriff auf aktuelle Daten
• Beispiel: Fahrplandaten mit aktuellen Verspätungen

Datenarchivierung:
• Archivierung von “kalten“ Anwendungsdaten in der Cloud
  (und nicht auf Band)
• Zugriff auf Daten bleibt erhalten (ohne Einspielen von Band)
        Top-10 Herausforderungen
(1) Verfügbarkeit der Dienste
(2) Lock-in Effekte
(3) Datensicherheit
(4) Datentransferzeiten (Latenzzeiten)
(5) Unvorhersagbarkeit der Performance
(6) Skalierbares Datenmanagement
(7) Fehler in verteilen Systemen
(8) Skalierbarkeit der Anwendung
(9) Qualitätskontrolle der Dienste (z.B., Bot-Netze)
(10)Softwarelizenzmodelle
            Verfügbarkeit der Dienste
Verfügbarkeit ist für die Reputation eines Dienstes sehr wichtig

Ist ein Dienst öfters nicht verfügbar kann es sich negativ auf den
Erfolg auswirken:
Dienstausfall      Ursache                                    Dauer
Amazon S3          Authentifikations-Dienst überlastet        2 Stunden
Amazon S3          Fehler im Gossip-Protokoll (Replikation)   6-8 Stunden
Google AppEngine   Programmierfehler (keine Details)          5 Stunden
Google Mail        Kontakt-Dienst nicht verfügbar             1,5 Stunden
Amazon EC2         Crash von EC2 mit Datenverlust (11h)!!     Mehrere Stunden
(28.4.2011)
  Verfügbarkeit der Dienste: Lösungen
Idee: Vielfalt der Dienste

Aus Anbietersicht: Unterschiedliche Software-Versionen bei
einem Anbieter („Canary“-Idee)

Aus Anwendersicht: Verteilung einer Anwendung auf
unterschiedliche Anbieter (Problem: proprietäre Schnittstellen)
         Verfügbarkeit der Dienste:
          Horizontale Integration

                                 Anwendung

     Proprietäre Schnittstelle            Proprietäre Schnittstelle

Amazon                           Google                               Microsoft
                                                     ...
 Cloud                           Cloud                                 Cloud
                      Lock-in Effekte
Schnittstellen und Garantien der einzelnen Anbieter sind proprietär

Anwendungen müssen stark an die Schnittstellen und Garantien der
einzelnen Anbieter angepasst werden

Wechsel von einem Anbieter zu einem anderen verursacht hohe
Kosten

Stellt ein Dienstanbieter seinen Dienst ein, sind evtl. alle Daten
verloren

Abhängigkeit von der Preispolitik eines Anbieters
         Lock-in Effekte: Lösungen
Standardisierte Schnittstellen und Garantien

Horizontale Integration oberhalb der proprietären Schnittstellen
              Lock-in Effekte:
           Horizontale Integration

                                 Anwendung

                      Standardisierte Schnittstelle

                            Integrationsschicht

     Proprietäre Schnittstelle            Proprietäre Schnittstelle

Amazon                           Google                               Microsoft
                                                     ...
 Cloud                           Cloud                                 Cloud
                 Datensicherheit
Unternehmen haben die Befürchtung, dass Sie die Hoheit über
ihre Daten verlieren

Unternehmen haben die Befürchtung, dass Daten Dritten über
öffentliche Netze zugänglich werden könnten

Daten werden aktuell meist unverschlüsselt gespeichert

Durch gesetzliche Bestimmungen dürfen bei bestimmten
Anwendungen Daten die nationale Grenzen nicht verlassen
        Datensicherheit: Lösungen
Zugang über VPN anstelle öffentliche Netze

Datenverschlüsselung anwenden, die eine Verarbeitung in
verschlüsselter Form ermöglicht

Lokalität ist eine Eigenschaft der Daten (in welchem
Rechenzentrum Daten liegen dürfen)

Betrieb privater Cloud-Infrastrukturen: Sicherheitsrelevante
Daten nur in privaten Clouds
            Datentransferzeiten
Große Datenmengen von Anwender zu Anbieter (und
umgekehrt) zu transferieren ist teuer

Lösungen:
• Höhere WAN-Bandbreiten => sehr teuer
• Daten nah zu den Anwendern (lokale Rechenzentren)
• Datentransfer minimieren: Anwendungsdaten liegen in der
  „Cloud“ und nur kleine Datenmengen müssen zum Benutzer
• Lokales Caching der „heißen“ Daten
                    Performance
I/O Performance der Hardware (insbesondere der Festplatten)
hängt stark von der Anzahl paralleler Prozesse (Anwender) ab

Starke Performance-Schwankungen bei Virtualisierung der
Rechner auf „billiger“ Hardware

Lösungen:
• Speichermedien mit besseren Zugriffsverhalten (z.B. Flash,
  Storage Class Memory, Hauptspeicher)
• Bessere Hardware-Komponenten und angepasste
  Betriebssysteme (wie bei IBM-Großrechner)
   Skalierbares Datenmanagement
Skalierbareres und hoch-verfügbares Datenmanagement ist
schwierig

Verteilte Datenbanken sind sehr aufwändig in Administration
und Betrieb bzw. nur begrenzt skalierbar

CAP-Theorem: Nur zwei der drei Eigenschaften (Consistency,
Availability, Network-Partitioning) gleichzeitig möglich!!!
       Skalierbares Datenmanagement:
        Partitionierung und Replikation
Replikation: Verfügbarkeit und Performance durch Kopie der Daten verbessern

Partitionierung: Höhere Datenmengen ermöglichen und Performance verbessern
durch Aufteilung der Daten (DB1 = DB1‘ + DB1‘‘ + DB1‘‘‘)


        DB1        DB1‘         DB1         DB1‘‘        DB1    DB1‘‘‘




                     Verteilte IT-Landschaft (Mehrere Knoten)
     Skalierbares Datenmanagement:
                Lösungen
Analyse der Benutzerlast und Automatische Anpassung der
Partitionierung und Replikation

Aufgeben/Einschränken bestimmter Eigenschaften
(meist: Konsistenz)

Weitere Ideen:
• Konsistenz nur für zusammengehörige Daten
• Partitionierung und keine Konsistenz für unabhängige Daten
      Fehler in verteilen Systemen
Fehler in verteilten Systemen sind nur schwer nachzustellen /
analysieren

Lösungen: Bessere Debugging- und Test-Werkzeuge
    Skalierbarkeit der Anwendung
Anwendungen lassen sich nur schwierig automatisch skalieren /
parallelisieren

Lösungen:
• Programmierparadigmen, die sich besser automatisch
  parallelisieren lassen (z.B. Funktionale Sprachen)
• Deklarative Beschreibung zur Datenpartitionierung
• Automatisches Analysieren von Anwendungen
      Weitere Herausforderungen
Qualitätskontrolle der Dienste
• Dienste mit schlechter Qualität / böswilligen Absichten
  können negative Auswirkungen auf andere Dienste haben
• Lösungen: Unabhängige Qualitätskontrolle, Strafen bei Nicht-
  Einhaltung von SLAs/Verträgen

Lizenzmodelle
• Aktuelle Lizenzmodelle sind häufig nicht an Hardware-
   Ressourcen gekoppelt
• Lösungen: Lizenzmodelle nach Nutzung
                      Übersicht
• Motivation

• Klassifikation

• Herausforderungen

• Anbieter

• Systementwicklung (Parallele Programmierung)
                       Anbieter
Große Anbieter (mit eigenen Rechenzentren):
• Amazon
• Facebook
• Google
• Microsoft
• Salesforce.com und Force.com
• SAP
• (Yahoo)

Viele kleine und mittlere Anbieter (ohne Rechenzentren)
               Anbieter: Klassifikation
                                                         Anforderungen / Beschränkungen
  Dienstkategorie
                                                                  für Anwender

SaaS                Facebook, Google (Apps), Microsoft (Office),          Automatisierung
                                 Salesforce.com




                                                                           (z.B. Skalierbarkeit)
PaaS           Amazon (SimpleDB, ...), Facebook API, Force.com,
                   Google (AppEngine), Microsoft (Azure)




IaaS                               Amazon (EC2)                           Freiheit
      Amazon Web Services (AWS)
Viele unterschiedliche Dienste: IaaS (EC2) / PaaS (SimpleDB, S3,
EBS, RDS, DB2, SQS, ...)

Basis ist EC2 (Elastic Computing Cloud): virtuelle Rechner-
Instanzen (die von Benutzer gestartet und gestoppt werden)

EC2 Instanzen erlauben Installation beliebiger Software-Systeme

Weitere höherwertige Dienste: S3 = Simple Storage Service,
SimpleDB, RDS
     Amazon Web Services (AWS)
Programmiermodell: X86-Befehlssatz via Xen VM (EC2)
• Skalierbarkeit durch Start neuer EC2-Instanzen
• Parallelität muss von der Anwendung manuell umgesetzt
   werden

Speichermodell: Unterschiedliche Lösungen
• Einfache Storage-Dienste (EBS, S3)
• Datenbankdienste (SimpleDB, RDS, DB2)
                 Microsoft Azure
PaaS-Angebot für die Entwicklung eigener Anwendungen

Programmiermodell:
• Alle Programmiersprachen der Microsoft Common Language
   Runtime (CLR)
• Deklarative Beschreibung definiert Verteilung, Replikation,
   Lastverteilung, ... der Anwendung

Speichermodell:
• Azure storage services: Key/Value-Store
• Azure SQL: SQL-Server (relationale Datenbank)
               Google AppEngine
PaaS-Angebot für die Entwicklung eigener Anwendungen

Programmiermodell:
• Erweiterbares Framework für Web-Anwendung basierend auf
   Python / Java
• Unterstützt automatische Skalierbarkeit der Anwendung

Speichermodell:
• BigTable: Key/Value-Store mit Atomarität pro Datensatz
• MegaStore: Datenbank mit Transaktionen (beschränkt)
                      Übersicht
• Motivation

• Klassifikation

• Herausforderungen

• Anbieter

• Systementwicklung (Parallele Programmierung)
                   Cloud Computing:
                  Softwareentwicklung
Cloud Computing verspricht Elastizität von Ressourcen (Rechenleistung)

(Automatische) Parallelisierung der Anwendungen erforderlich um Elastizität
zu ermöglichen



App         App        App         App         App        App            App
 1           1          1           1           1          1              1
                                       CPU Trends (1)
10m



                 • Transitors (#)                               CPU-Performancesteigerung:
                 • Clock-speed (MHz)
                 • Power (W)                     Montecito      •   Taktfrequenz
                                                                •
10k 0.1m 1m




                 • Perf/Clock (ILP)                                 Cache-Größen
                                                                •   ILP (instruction level
                                                                    parallelism)

                                                                Bisher: Freie Steigerung der
                                Pentium                         Software-Performance
100 1k




                         386                                    Aktuell: Geringere Steigerung
                                                                der CPU-Performance
10




                                                                „The Free Lunch is Over“
                                                                 (Herb Sutter, Microsoft)
1




               1970 1980 1990 2000 2010
              Quelle: Software and the Concurrency Revolution
                           (Herb Sutter, Microsoft)
                           CPU Trends (2)
      # Cores / CPU                                Aktuell:
32




                                                   •   Mehrere Kerne pro Chip
                                                   •   Größere lokale /gemeinsame Caches
16




                                                   •   Hyperthreading
8




                                                   Probleme:
                                                   •   Anwendungen meist sequentiell
                                                       (Ausnahmen: DBMS, Compiler, …)
4




                                                   •   Parallelität kommt nicht umsonst
2




                                                    Re-Design (Parallelisierung) von
                                     Jahr            Anwendungen wird notwendig
1




     2006      2008      2010       2012
 Quelle: Software and the Concurrency Revolution
              (Herb Sutter, Microsoft)
          Beispiel: Worthäufigkeiten
Zähle Anzahl gleicher Wörter in n Dokumenten:
map<String, int> word_count;

void count_words(vector<Document> documents){
  for each document in documents{
    for each word in document{
      count = word_count[word];
      word_count[word] = count+1;
    }
  }
}

Eingabe:                  Ausgabe:
Dokument 1: „This is a foo text“     {<„bar“, 1>, … , <„This“, 2>}
Dokument 2: „This is a bar text“
       Ansätze zur Nebenläufigkeit
Explizite Parallelisierung (z.B. mehrere Threads)
• Meist hart-codierte Anpassungen der Anwendung
• Explizite Synchronisation, Fehlerbehandlung, Skalierung, ….

Implizite Parallelisierung (z.B. durch funktionale Sprachen)
• Parallelisierung durch Compiler (abhängig vom
  Programmiermodell)
• Automatische Synchronisation, Fehlerbehandlung ,
  Skalierung, …
        Beispiel: Worthäufigkeiten
Zähle Anzahl gleicher Wörter (Multi-Threaded):
//globale Variable
map<String, int> word_count;

//master Thread
void count_words(vector<Document> documents){
  for each document in documents{
     start_thread(count_doc, document);
  }
}

//worker Thread
void count_doc(Document document){
  for each word in document{
    count = word_count[word];
    word_count[word] = count+1;
}
                 Herausforderungen
Synchronisation:
• Mehrere Threads schreiben / lesen gleiche globale Variablen
• Wie halte ich meine Daten konsistent?

Deadlocks:
• Wie vermeide ich dass mehrere Threads sich gegenseitig sperren?
• Synchronisation kann über „Locks“ erfolgen

Fehlerbehandlung:
• Was passiert, wenn ein Thread einen Fehler liefert?

Skalierbarkeit:
• Wie viele Threads sind optimal für das aktuelle Problem?
• Wie viele Threads sind optimal auf der aktuellen Hardware?
            Problem: Synchronisation
//globale Variable
map<String, int> word_count;               => Ergebnis hängt von
                                           globaler Reihenfolge
//worker Thread                            paralleler Aktivitäten ab
void count_doc(Document document){
  for each word in document{
    count = word_count[word];
    word_count[word] = count+1;
}

Worker 1:
1:word="This"   3:count=0   5:word_count["This"]=1




Worker 2:
    2:word="This"   4:count=0   6:word_count["This"]=1
      Lösung: Sperrmechanismen
//globale Variable
map<String, int> word_count;

mutex lock; //globales lock
void count_doc(Document document){
  for each word in document{
    aquire(lock);
    count = word_count[word];
    word_count[word] = count+1;
    release(lock);
}
Worker 1:
1:word="This"   3:aquire_lock    5:word_count["This"]= 6:release
                (word_count)     count+1



Worker 2:                  4:aquire_lock      wait for lock
    2:word="This"          (word_count)
             Sperr-Mechanismen
Explizite durch Mutexe (=Mutual Exclusion) bzw. Locks

Implizit durch Monitore („synchronized“ Blöcke in Java)

Idee: Atomare Änderung während der Sperre

Verfeinerung:
• Lese-Locks: Andere Lese-Locks sind erlaubt, aber keine
  Schreib-Locks
• Schreib-Locks: Keine anderen Locks sind erlaubt
                  Problem: Deadlock
 Worker 1:
                  3:aquire_lock   5:aquire_lock       wait for lock (word_count)
  1:word="This"   (count)         (word_count)




 Worker 2:                                            wait for lock (count)
                      4:aquire_lock   6:aquire_lock
      2:word="This"   (word_count)    (count)



Problem: „Worker 1“ und „Worker 2“ sperren sich gegenseitig

Lösung: Abbrechen eines „Workers“ nach Timeout und neuen
Versuch starten
       Problem: Fehlerbehandlung
 Worker 1:
                  3:aquire
  1:word="This"   (count)      5:word_count["This"]=count+1   Thread stürzt ab



 Worker 2:
                    4:aquire           wait for lock
      2:word="This" (count)



Probleme: „Worker 1“ hat globalen Zustand verändert bzw. Lock
wird nicht freigegeben

Lösung: Rücksetzen des Zustandes, Freigabe aller Locks
(Timeout) und Neustart des „Workers 1“
          Problem: Skalierbarkeit
Zähle Anzahl gleicher Wörter (Multi-Threaded):
//globale Variable
map<String, int> word_count;

//master Thread
void count_words(vector<Document> documents){
  for each document in documents{
     start_thread(count_doc, document);
  }
}

Problem: Optimale Aufteilung des Problems für gegebene
Konfiguration finden (# CPU-Cores, Cache-Größen ,…)
Lösungen: Ein Thread pro Dokument? Was passiert bei
unterschiedlich großen Dokumenten?
         Implizite Parallelisierung
Idee:
 • Problem wird einmal formuliert (ohne explizite
    Synchronisation, Fehlerbehandlung, …)
 • Parallelisierung erfolgt automatisch

Beispiel:
• Map-Reduce Programmiermodell (auch bekannt aus
  funktionalen Sprachen)
• Aktuell von Google, Yahoo „Hadoop“, ... verwendet (z.B. zur
  parallelen Analyse von Datenmengen)
 Programmiermodell: Map-Reduce
Algorithmen mit Hilfe von aufeinanderfolgenden Map-/Reduce-
Schritten beschrieben:
• Map(V1) -> list(k2, v2)
• Reduce(k2, list(v2)) -> (k2, v3)

Ausführungsmodell beinhaltet:
• Daten-Partitionierungsfunktion
• Lastverteilung der Funktionen
• Fehlerbehandlung bzw. Neustart
          Beispiel: Worthäufigkeiten
Phase 1: Map(v1) -> list(k2, v2)
void map(String sentence){
  for each word in sentence{
      emit(word, 1);
  }
}



Eingabe:               Ausgabe:
„This is a foo text“   {<„This“,1>, <„is“,1>, <„a“,1>, <„foo“,1>,<„text“,1>}
„This is a bar text“   {<„This“,1>, <„is“,1>, <„a“,1>, <„bar“,1>,<„text“,1>}
          Beispiel: Worthäufigkeiten
Phase 2: Gruppieren nach gleichen Schlüsseln k2 (automatisch )

Eingabe: list(k2, v2)
{<„This“,1>, <„is“,1>, <„a“,1>, <„foo“,1>,<„text“,1>}
{<„This“,1>, <„is“,1>, <„a“,1>, <„bar“,1>,<„text“,1>}


Ausgabe: (k2, list(v2))
<„This“, {1,1}>
<„is“, {1,1}>
<„a“, {1,1}>
<„foo“, {1}>
<„bar“, {1}>
<„text“, {1,1}>
          Beispiel: Worthäufigkeiten
Phase 3: Reduce(k2, list(v2)) -> v3
void reduce(String word, List counts){
  int result = 0;
  for each count in counts{
      result = result + count;
  }
  emit(word, result);
}


Eingabe:          Ausgabe:
<„This“, {1,1}>        <„This“, 2>
<„is“, {1,1}>     <„is“, 2>
<„a“, {1,1}>      <„a“, 2>
<„foo“, {1}>      <„foo“, 1>
…                 …
Map-Reduce Ausführungsmodell
        Input 1      Input 2         …       Input n



       Map 1          Map 2                     Map n



   Group 1      Group 2    Group 3       …         Group m



       Reduce        Reduce                    Reduce
         1             2                         m


       Output 1     Output 2         …         …
               Zusammenfassung
• Motivation

• Klassifikation

• Herausforderungen

• Anbieter

• Systementwicklung (Parallele Programmierung)

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:4
posted:2/20/2013
language:Unknown
pages:68