Einführung in Apache Spark

1. Einleitung

Apache Spark ist ein Open-Source-Cluster-Computing-Framework . Es bietet elegante Entwicklungs-APIs für Scala, Java, Python und R, mit denen Entwickler eine Vielzahl datenintensiver Workloads in verschiedenen Datenquellen wie HDFS, Cassandra, HBase, S3 usw. ausführen können.

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. Mit Spark können wir Logik bis zu zwei Größenordnungen schneller ausführen als mit Hadoop im Speicher oder eine Größenordnung schneller auf der Festplatte .

2. Spark-Architektur

Spark-Anwendungen werden als unabhängige Sätze von Prozessen in einem Cluster ausgeführt, wie in der folgenden Abbildung beschrieben:

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

Sobald die Verbindung hergestellt ist, erfasst Spark Executoren 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 an SparkContext übergeben werden ) an die Ausführenden. Schließlich sendet SparkContext Aufgaben zur Ausführung an die Ausführenden .

3. Kernkomponenten

Das folgende Diagramm gibt ein klares Bild der verschiedenen Komponenten von Spark:

3.1. Funkenkern

Die Spark Core-Komponente ist für alle grundlegenden E / A-Funktionen verantwortlich, plant und überwacht die Jobs in Spark-Clustern, verteilt Aufgaben, vernetzt sich mit verschiedenen Speichersystemen, behebt Fehler und sorgt für eine effiziente Speicherverwaltung.

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

Ausfallsichere verteilte Datensätze sind unveränderlich, eine partitionierte Sammlung von Datensätzen, die parallel verarbeitet werden können und fehlertolerante In-Memory-Berechnungen ermöglichen .

RDDs unterstützen zwei Arten von Operationen:

  • Transformation - Die Spark-RDD-Transformation ist eine Funktion, die aus den vorhandenen RDDs eine neue RDD erzeugt. Der Transformator nimmt RDD als Eingang und erzeugt einen oder mehrere RDD als Ausgang . Transformationen sind von Natur aus faul, dh sie werden ausgeführt, wenn wir eine Aktion aufrufen
  • Aktion - Transformationen erstellen RDDs voneinander, aber wenn wir mit dem tatsächlichen Datensatz arbeiten möchten, wird an diesem Punkt eine Aktion ausgeführt. Daher sind Aktionen Spark-RDD-Operationen, die Nicht-RDD-Werte ergeben. Die Aktionswerte werden in Treibern oder im externen Speichersystem gespeichert

Eine Aktion ist eine der Möglichkeiten, Daten von 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 werden gezählt und gesammelt.

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 Sammlung von Daten, die in benannten Spalten angeordnet sind, wird in Spark als DataFrame bezeichnet .

Spark SQL unterstützt das Abrufen von Daten aus verschiedenen Quellen wie Hive, Avro, Parkett, ORC, JSON und JDBC. Mit der Spark-Engine können auch Tausende von Knoten und mehrstündige Abfragen skaliert werden. Dies bietet eine vollständige Fehlertoleranz während der Abfrage.

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 in 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 - gängige Lernalgorithmen wie Klassifizierung, Regression, Clustering und kollaborative Filterung
  • Featurization - Extraktion, Transformation, Reduzierung der Dimensionalität und Auswahl von Features
  • Pipelines - Tools zum Erstellen, Bewerten 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 ​​ist eine Komponente für Diagramme und graphparallele Berechnungen. 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.

Zur Unterstützung der Diagrammberechnung stellt GraphX ​​eine Reihe grundlegender Operatoren zur Verfügung (z. B. Subgraph , joinVertices und aggregateMessages ).

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

4. "Hallo Welt" in Spark

Nachdem wir die Kernkomponenten verstanden haben, können wir mit dem einfachen Maven-basierten Spark-Projekt fortfahren - zur Berechnung der Wortanzahl .

We'll be demonstrating Spark running in the local mode where all the components are running locally on the same machine where it's the master node, executor nodes or Spark's standalone cluster manager.

4.1. Maven Setup

Let's set up a Java Maven project with Spark-related dependencies in pom.xml file:

  org.apache.spark spark-core_2.10 1.6.0  

4.2. Word Count – Spark Job

Let's now write Spark job to process a file containing sentences and output distinct words and their counts in the file:

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(); }
    

Notice that we pass the path of the local text file as an argument to a Spark job.

A SparkContext object is the main entry point for Spark and represents the connection to an already running Spark cluster. It uses SparkConf object for describing the application configuration. SparkContext is used to read a text file in memory as a JavaRDD object.

Next, we transform the lines JavaRDD object to words JavaRDD object using the flatmap method to first convert each line to space-separated words and then flatten the output of each line processing.

We again apply transform operation mapToPair which basically maps each occurrence of the word to the tuple of words and count of 1.

Then, we apply the reduceByKey operation to group multiple occurrences of any word with count 1 to a tuple of words and summed up the count.

Lastly, we execute collect RDD action to get the final results.

4.3. Executing – Spark Job

Let's now build the project using Maven to generate apache-spark-1.0-SNAPSHOT.jar in the target folder.

Next, we need to submit this WordCount job to Spark:

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

Spark installation directory and WordCount Maven project directory needs to be updated before running above command.

On submission couple of steps happens behind the scenes:

  1. From the driver code, SparkContext connects to cluster manager(in our case spark standalone cluster manager running locally)
  2. Der Cluster-Manager weist Ressourcen auf die anderen Anwendungen zu
  3. Spark erwirbt Executoren auf Knoten im Cluster. Hier erhält unsere Wortzählanwendung ihre eigenen Executor-Prozesse
  4. Anwendungscode (JAR-Dateien) wird an Ausführende gesendet
  5. Aufgaben werden vom SparkContext an die Ausführenden gesendet .

Schließlich wird das Ergebnis des Funkenauftrags 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. Schlussfolgerung

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 Anzahl der Wörter aus einer Datei angegeben wird.

Wie immer ist der vollständige Quellcode auf GitHub verfügbar.