Introducere în Apache Spark

1. Introducere

Apache Spark este un cadru de calcul de sursă open-source . Oferă API-uri de dezvoltare elegante pentru Scala, Java, Python și R, care permit dezvoltatorilor să execute o varietate de sarcini de lucru intensive în date în diverse surse de date, inclusiv HDFS, Cassandra, HBase, S3 etc.

Din punct de vedere istoric, MapReduce de la Hadoop s-a dovedit a fi ineficient pentru unele locuri de muncă iterative și interactive, care au dus în cele din urmă la dezvoltarea Spark. Cu Spark, putem rula logica cu până la două ordine de mărime mai repede decât cu Hadoop în memorie sau cu o ordine de mărime mai rapidă pe disc .

2. Arhitectura Spark

Aplicațiile Spark rulează ca seturi independente de procese pe un cluster, așa cum este descris în diagrama de mai jos:

Aceste seturi de procese sunt coordonate de obiectul SparkContext din programul dvs. principal (numit programul driver). SparkContext se conectează la mai multe tipuri de manageri de cluster (fie managerul de cluster independent Spark, Mesos sau YARN), care alocă resurse între aplicații.

Odată conectat, Spark achiziționează executanți pe noduri din cluster, care sunt procese care execută calcule și stochează date pentru aplicația dvs.

Apoi, trimite codul aplicației (definit de fișierele JAR sau Python transmise către SparkContext ) executanților. În cele din urmă, SparkContext trimite sarcini executanților pentru a rula .

3. Componente de bază

Următoarea diagramă oferă o imagine clară a diferitelor componente ale Spark:

3.1. Spark Core

Componenta Spark Core este responsabilă pentru toate funcționalitățile de I / O de bază, programarea și monitorizarea lucrărilor pe clusterele de scânteie, distribuirea sarcinilor, rețeaua cu diferite sisteme de stocare, recuperarea defecțiunilor și gestionarea eficientă a memoriei.

Spre deosebire de Hadoop, Spark evită ca datele partajate să fie stocate în magazine intermediare precum Amazon S3 sau HDFS utilizând o structură specială de date cunoscută sub numele de RDD (Resilient Distributed Datasets).

Seturile de date distribuite rezistente sunt imuabile, o colecție partiționată de înregistrări care poate fi operată - în paralel și permite - calcule „în memorie” tolerante la erori .

RDD-urile acceptă două tipuri de operații:

  • Transformare - Transformarea Spark RDD este o funcție care produce RDD nouă din RDD-urile existente. Transformatorul ia RDD ca intrare și produce unul sau mai multe RDD ca ieșire . Transformările au o natură leneșă, adică se execută atunci când numim o acțiune
  • Acțiune - transformările creează RDD-uri unul de celălalt, dar atunci când vrem să lucrăm cu setul de date real, în acel moment se efectuează acțiune. Astfel, Acțiunile sunt operații Spark RDD care dau valori non-RDD. Valorile acțiunii sunt stocate în drivere sau în sistemul de stocare extern

O acțiune este una dintre modalitățile de trimitere a datelor de la Executor la șofer.

Executorii sunt agenți responsabili de executarea unei sarcini. În timp ce driverul este un proces JVM care coordonează lucrătorii și executarea sarcinii. Unele dintre acțiunile Spark sunt numărate și colectate.

3.2. Spark SQL

Spark SQL este un modul Spark pentru procesarea structurată a datelor. Este utilizat în principal pentru a executa interogări SQL. DataFrame constituie principala abstracție pentru Spark SQL. Colectarea distribuită de date comandate în coloane numite este cunoscută sub numele de DataFrame în Spark.

Spark SQL acceptă preluarea datelor din diferite surse, cum ar fi Hive, Avro, Parquet, ORC, JSON și JDBC. De asemenea, se ridică la mii de noduri și interogări de mai multe ore utilizând motorul Spark - care oferă o toleranță completă la erori la interogare.

3.3. Spark Streaming

Spark Streaming este o extensie a API-ului Spark de bază care permite procesarea scalabilă, cu randament ridicat, tolerant la erori a fluxurilor de date live. Datele pot fi ingerate din mai multe surse, cum ar fi socketele Kafka, Flume, Kinesis sau TCP.

În cele din urmă, datele procesate pot fi împinse în sisteme de fișiere, baze de date și tablouri de bord live.

3.4. Spark Mlib

MLlib este biblioteca de învățare automată (ML) a Spark. Obiectivul său este de a face învățarea practică automată scalabilă și ușoară. La un nivel ridicat, oferă instrumente precum:

  • Algoritmi ML - algoritmi de învățare obișnuiți, cum ar fi clasificarea, regresia, gruparea și filtrarea colaborativă
  • Caracterizare - extragerea, transformarea, reducerea dimensionalității și selecția caracteristicilor
  • Conducte - instrumente pentru construirea, evaluarea și reglarea conductelor ML
  • Persistență - salvarea și încărcarea algoritmilor, modelelor și conductelor
  • Utilități - algebră liniară, statistici, prelucrarea datelor etc.

3.5. Spark GraphX

GraphX ​​este o componentă pentru grafice și calcule paralele grafice. La un nivel ridicat, GraphX ​​extinde Spark RDD prin introducerea unei noi abstracții Graph: un multigraf direcționat cu proprietăți atașate la fiecare vârf și margine.

Pentru a sprijini calculul graficului, GraphX ​​expune un set de operatori fundamentali (de exemplu, subgraf , joinVertices și aggregateMessages ).

În plus, GraphX ​​include o colecție din ce în ce mai mare de algoritmi grafici și constructori pentru a simplifica sarcinile de analiză a graficelor.

4. „Hello World” în Spark

Acum că înțelegem componentele de bază, putem trece la un proiect Spark simplu bazat pe Maven - pentru calcularea numărului de cuvinte .

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. Cluster Manager alocă resurse pentru celelalte aplicații
  3. Spark achiziționează executanți pe noduri din cluster. Aici, aplicația noastră de numărare a cuvintelor va obține propriile procese de executare
  4. Codul aplicației (fișiere jar) este trimis executanților
  5. Sarcinile sunt trimise de SparkContext executanților.

În cele din urmă, rezultatul jobului scântei este returnat șoferului și vom vedea numărul de cuvinte din fișier ca ieșire:

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

5. Concluzie

În acest articol, am discutat despre arhitectura și diferitele componente ale Apache Spark. De asemenea, am demonstrat un exemplu de lucru al unui job Spark, care oferă numărul de cuvinte dintr-un fișier.

Ca întotdeauna, codul sursă complet este disponibil pe GitHub.