Einführung in Apache Spark

Einführung in Apache Spark

1. Einführung

Apache Spark is an open-source cluster-computing framework. Es bietet elegante Entwicklungs-APIs für Scala, Java, Python und R, mit denen Entwickler eine Vielzahl datenintensiver Workloads über verschiedene Datenquellen hinweg ausführen können, darunter HDFS, Cassandra, HBase, S3 usw.

In der Vergangenheit erwies sich MapReduce von Hadoop als ineffizient für einige iterative und interaktive Computeraufträge, was schließlich zur Entwicklung von Spark führte. With Spark, we can run logic up to two orders of magnitude faster than with Hadoop in memory, or one order of magnitude faster on disk.

2. Funkenarchitektur

Spark-Anwendungen werden als unabhängige Sätze von Prozessen in einem Cluster ausgeführt, wie in den folgendendiagrambeschrieben:

image

 

Diese Prozesse werden vomSparkContext-Objekt in Ihrem Hauptprogramm (als Treiberprogramm bezeichnet) koordiniert. SparkContext stellt eine Verbindung zu verschiedenen Arten von Cluster-Managern her (entweder Spark's eigener eigenständiger Cluster-Manager, Mesos oder YARN), die Ressourcen anwendungsübergreifend zuweisen.

Sobald die Verbindung hergestellt ist, bezieht Spark Executors auf Knoten im Cluster. Hierbei handelt es sich um Prozesse, die Berechnungen ausführen und Daten für Ihre Anwendung speichern.

Als Nächstes sendet es Ihren Anwendungscode (definiert durch JAR- oder Python-Dateien, die anSparkContext übergeben wurden) an die Ausführenden. SchließlichSparkContext sends tasks to the executors to run.

3. Kernkomponenten

Die folgendendiagram geben ein klares Bild der verschiedenen Komponenten von Spark:

image

 

3.1. Funkenkern

Die Spark Core-Komponente ist verantwortlich für alle grundlegenden E / A-Funktionen, die Planung und Überwachung der Jobs in Spark-Clustern, die Aufgabenverteilung, die Vernetzung mit verschiedenen Speichersystemen, die Fehlerbehebung und das effiziente Speichermanagement.

Im Gegensatz zu Hadoop vermeidet Spark, dass freigegebene Daten in Zwischenspeichern wie Amazon S3 oder HDFS gespeichert werden, indem eine spezielle Datenstruktur verwendet wird, die als RDD (Resilient Distributed Datasets) bezeichnet wird.

Resilient Distributed Datasets are immutable, a partitioned collection of records that can be operated on – in parallel and allows – fault-tolerant ‘in-memory’ computations.

RDDs unterstützen zwei Arten von Operationen:

  • Transformation - Die Spark-RDD-Transformation ist eine Funktion, die aus den vorhandenen RDDs neue RDD erstellt. The transformer takes RDD as input and produces one or more RDD as output. Transformationen sind von Natur aus faul, d. H. Sie werden ausgeführt, wenn wir eine Aktion aufrufen

  • Die Transformationen von Aktionerzeugen RDDs voneinander, aber wenn wir mit dem tatsächlichen Datensatz arbeiten möchten, wird an diesem Punkt eine Aktion ausgeführt. Somit werdenActions are Spark RDD operations that give non-RDD values. Die Aktionswerte in Treibern oder im externen Speichersystem gespeichert

Eine Aktion ist eine der Möglichkeiten, Daten vom Executor an den Treiber zu senden.

Ausführende sind Agenten, die für die Ausführung einer Aufgabe verantwortlich sind. Während der Treiber ein JVM-Prozess ist, der die Mitarbeiter und die Ausführung der Aufgabe koordiniert. Einige der Aktionen von Spark sind zählen und sammeln.

3.2. Spark SQL

Spark SQL ist ein Spark-Modul für die strukturierte Datenverarbeitung. Es wird hauptsächlich zum Ausführen von SQL-Abfragen verwendet. DataFrame bildet die Hauptabstraktion für Spark SQL. Die verteilte Erfassung von Daten, die in benannten Spalten angeordnet sind, wird in Spark alsDataFrame bezeichnet.

Spark SQL unterstützt das Abrufen von Daten aus verschiedenen Quellen wie Hive, Avro, Parkett, ORC, JSON und JDBC. Mithilfe der Spark-Engine kann sie auch auf Tausende von Knoten und mehrstündige Abfragen skaliert werden. Dies bietet eine vollständige Fehlertoleranz für Abfragen in der Mitte.

3.3. Spark Streaming

Spark Streaming ist eine Erweiterung der zentralen Spark-API, die eine skalierbare, fehlertolerante Stream-Verarbeitung von Live-Datenströmen mit hohem Durchsatz ermöglicht. Daten können aus einer Reihe von Quellen wie Kafka, Flume, Kinesis oder TCP-Sockets aufgenommen werden.

Schließlich können verarbeitete Daten auf Dateisysteme, Datenbanken und Live-Dashboards übertragen werden.

3.4. Spark Mlib

MLlib ist die ML-Bibliothek (Machine Learning) von Spark. Ziel ist es, praktisches maschinelles Lernen skalierbar und einfach zu machen. Auf hohem Niveau bietet es Tools wie:

  • ML-Algorithmen - allgemeine Lernalgorithmen wie Klassifizierung, Regression, Clustering und kollaboratives Filtern

  • Featurization - Extrahieren, Transformieren, Reduzieren und Auswählen von Features

  • Pipelines - Tools zum Erstellen, Auswerten und Optimieren von ML-Pipelines

  • Persistenz - Speichern und Laden von Algorithmen, Modellen und Pipelines

  • Dienstprogramme - Lineare Algebra, Statistik, Datenverarbeitung usw.

3.5. Spark GraphX

GraphX is a component for graphs and graph-parallel computations. Auf hoher Ebene erweitert GraphX ​​die Spark-RDD um eine neue Graph-Abstraktion: einen gerichteten Multigraph mit Eigenschaften, die an jeden Scheitelpunkt und jede Kante angehängt sind.

Um die Graphberechnung zu unterstützen, macht GraphX ​​eine Reihe grundlegender Operatoren verfügbar (z. B.subgraph,joinVertices undaggregateMessages).

Darüber hinaus enthält GraphX ​​eine wachsende Sammlung von Diagrammalgorithmen und -erstellern, um die Aufgaben der Diagrammanalyse zu vereinfachen.

4. „Hallo Welt“ in Spark

Nachdem wir die Kernkomponenten verstanden haben, können wir mit einem einfachen Maven-basierten Spark-Projekt fortfahren -for calculating word counts.

Wir zeigen, wie Spark im lokalen Modus ausgeführt wird, in dem alle Komponenten lokal auf demselben Computer ausgeführt werden, auf dem sich der Masterknoten, die Executor-Knoten oder der eigenständige Cluster-Manager von Spark befinden.

4.1. Maven Setup

Richten wir ein Java Maven-Projekt mitSpark-related dependencies inpom.xml Datei ein:


    
        org.apache.spark
    spark-core_2.10
    1.6.0
    

4.2. Word Count - Spark Job

Schreiben wir nun einen Spark-Job, um eine Datei mit Sätzen zu verarbeiten und bestimmte Wörter und deren Anzahl in der Datei auszugeben:

public static void main(String[] args) throws Exception {
    if (args.length < 1) {
        System.err.println("Usage: JavaWordCount ");
        System.exit(1);
    }
    SparkConf sparkConf = new SparkConf().setAppName("JavaWordCount");
    JavaSparkContext ctx = new JavaSparkContext(sparkConf);
    JavaRDD lines = ctx.textFile(args[0], 1);

    JavaRDD words
      = lines.flatMap(s -> Arrays.asList(SPACE.split(s)).iterator());
    JavaPairRDD ones
      = words.mapToPair(word -> new Tuple2<>(word, 1));
    JavaPairRDD counts
      = ones.reduceByKey((Integer i1, Integer i2) -> i1 + i2);

    List> output = counts.collect();
    for (Tuple2 tuple : output) {
        System.out.println(tuple._1() + ": " + tuple._2());
    }
    ctx.stop();
}

Beachten Sie, dass wir den Pfad der lokalen Textdatei als Argument für einen Spark-Job übergeben.

DasSparkContext-Objekt ist der Haupteinstiegspunkt für Spark und stellt die Verbindung zu einem bereits ausgeführten Spark-Cluster dar. Es verwendet das ObjektSparkConfzur Beschreibung der Anwendungskonfiguration. SparkContext wird verwendet, um eine Textdatei im Speicher alsJavaRDD-Objekt zu lesen.

Als nächstes transformieren wir das Objekt der ZeilenJavaRDDin das Objekt der WörterJavaRDDunter Verwendung der Methodeflatmap, um zuerst jede Zeile in durch Leerzeichen getrennte Wörter zu konvertieren und dann die Ausgabe jeder Zeilenverarbeitung zu reduzieren.

Wir wenden erneut die TransformationsoperationmapToPair an, die im Grunde jedes Vorkommen des Wortes auf das Tupel von Wörtern und die Anzahl von 1 abbildet.

Dann wenden wir die OperationreduceByKeyan, um mehrere Vorkommen eines Wortes mit der Anzahl 1 zu einem Tupel von Wörtern zu gruppieren und die Anzahl zu summieren.

Zuletzt führen wir die RDD-Aktion von collectaus, um die endgültigen Ergebnisse zu erhalten.

4.3. Ausführen - Spark Job

Erstellen wir nun das Projekt mit Maven, umapache-spark-1.0-SNAPSHOT.jar im Zielordner zu generieren.

Als Nächstes müssen wir diesen WordCount-Job an Spark senden:

${spark-install-dir}/bin/spark-submit --class com.example.WordCount
  --master local ${WordCount-MavenProject}/target/apache-spark-1.0-SNAPSHOT.jar
  ${WordCount-MavenProject}/src/main/resources/spark_example.txt

Das Spark-Installationsverzeichnis und das WordCount Maven-Projektverzeichnis müssen aktualisiert werden, bevor der obige Befehl ausgeführt wird.

Bei der Einreichung passieren einige Schritte hinter den Kulissen:

  1. Über den Treibercode stelltSparkContext eine Verbindung zum Cluster-Manager her (in unserem Fall funken Sie den eigenständigen Cluster-Manager, der lokal ausgeführt wird).

  2. Der Cluster-Manager teilt die Ressourcen den anderen Anwendungen zu

  3. Spark erwirbt Executors auf Knoten im Cluster. Hier wird unsere Word Count-Anwendung ihre eigenen Executor-Prozesse bekommen

  4. Der Anwendungscode (JAR-Dateien) wird an die Ausführenden gesendet

  5. Aufgaben werden vonSparkContext an die Ausführenden gesendet.

Schließlich wird das Ergebnis des Zündjobs an den Treiber zurückgegeben, und die Anzahl der Wörter in der Datei wird als Ausgabe angezeigt:

Hello 1
from 2
Baledung 2
Keep 1
Learning 1
Spark 1
Bye 1

5. Fazit

In diesem Artikel haben wir die Architektur und die verschiedenen Komponenten von Apache Spark erläutert. Wir haben auch ein funktionierendes Beispiel für einen Spark-Job gezeigt, bei dem die Wortanzahl aus einer Datei ermittelt wird.

Wie immer ist der vollständige Quellcodeover on GitHub verfügbar.