Ce este Comandele Spark Shell?
Spark shell este o interfață folosită pentru a scrie interogări adhoc pentru a funcționa și pentru a înțelege comportamentul lui Apache Spark. Se numește motorul de calcul open source, care poate face procesarea în memorie a datelor, cum ar fi analitice, ETL, învățare automată pentru seturi imense de date. În acest subiect, vom afla despre Comenzile Spark Shell.
Există diferite tipuri de shell Spark pentru diferite limbaje de programare, de exemplu:
- scânteia-coajă este scrisă în Scala
- pyspark este în Python și
- sparkR pentru limbajul R
Se poate dezvolta aplicația sa de sine stătătoare cu ajutorul Spark. Este utilizat pe scară largă datorită vitezei sale de calcul super-rapide. Acest lucru se datorează faptului că utilizează MapReduce pentru a procesa diverse interogări și transformări.
Pentru a rula comenzile spark-shell, este necesar ca Java și Scala să fie deja instalate în sistem.
Tipuri de comenzi Spark Shell
Diferitele tipuri de comenzi Spark-shell sunt următoarele:
1. Pentru a verifica dacă Spark este instalat și pentru a cunoaște versiunea sa, sub comanda, se utilizează (Toate comenzile în continuare vor fi indicate începând cu acest simbol „$”)
$ scânteie-coajă
Următoarea ieșire este afișată dacă este instalată scânteia:
$ scânteie-coajă
SPARK_MAJOR_VERSION este setat la 2, folosind Spark2
Setarea nivelului de jurnal implicit pe „WARN”.
Pentru a ajusta nivelul de logare, utilizați sc.setLogLevel (newLevel). Pentru SparkR, folosiți setLogLevel (newLevel).
Interfață Interfață Web Spark disponibilă la http://10.113.59.34:4040
Context de scânteie disponibil ca „sc” (master = local (*), id-ul aplicației = local-1568732886588).
Ședință de scânteie disponibilă ca „scânteie”.
Bun venit la
____ __
/ __ / __ ___ _____ / / __
_ \ \ / / \ \ / _ `/ __ / '_ /
/ ___ / .__ / \ _, _ / _ / / _ / \ _ \ versiunea 2.2.0.2.6.3.0-235
/ _ /
Utilizarea versiunii Scala 2.11.8 (Java HotSpot (TM) Server 64-bit VM, Java 1.8.0_112)
Tastați expresii pentru a le evalua.
Tip: ajutor pentru mai multe informații.
timpanică>
2. Structura de date de bază a Spark se numește RDD (Resilient Distributed Datasets) care conține o colecție imuabilă de obiecte pentru calculul distribuit al înregistrărilor. Toate seturile de date ale RDD sunt partiționate logic pe mai multe noduri ale unui cluster.
Un RDD poate fi creat doar citind dintr-un sistem de fișiere local sau transformând un RDD existent.
a) Pentru a crea un nou RDD folosim următoarea comandă:
scala> val examplefile = sc.textFile("file.txt")
Aici sc se numește obiectul SparkContext.
ieşire:
examplefile: org.apache.spark.rdd.RDD(String) = file.txt MapPartitionsRDD(3) at textFile at :24
b) Un RDD poate fi creat prin Colecția paralelă după cum urmează:
scala> val oddnum = Array(1, 3, 5, 7, 9)
ieşire:
oddnum: Array(Int) = Array(1, 3, 5, 7, 9)
scala> val value = sc.parallelize(oddnum)
ieşire:
value: org.apache.spark.rdd.RDD(Int) = ParallelCollectionRDD(4) at parallelize at :26
c) Pentru a crea din RDD-uri existente :
scala> val newRDD = oddnum.map(value => (value * 2))
ieşire:
newRDD: Array(Int) = Array(2, 6, 10, 14, 18)
3. Există două tipuri de operații Spark RDD care pot fi efectuate pe seturile de date create:
- acţiuni
- transformări
Acțiuni: Este utilizat pentru a efectua anumite operații necesare pe seturile de date existente. Următoarele sunt câteva dintre comenzile care pot fi utilizate pentru a efectua acțiunile de mai jos pe seturile de date create:
a) funcție numără () pentru a număra numărul de elemente din RDD:
scala> value.count()
ieşire:
res3: Long = 5
b) colectați funcția () pentru a afișa toate elementele tabloului:
scala> value.collect()
ieşire:
res5: Array(Int) = Array(1, 3, 5, 7, 9)
c) prima () funcție utilizată pentru afișarea primului element al setului de date:
scala> value.first()
ieşire:
res4: Int = 1
d) funcția take (n) afișează primele n elemente ale tabloului:
scala> value.take(3)
ieşire:
res6: Array(Int) = Array(1, 3, 5)
e) funcția takeSample (cuReplacement, num, (seed)) afișează un tablou aleatoriu de elemente „num” în care semința este destinată generatorului de numere aleatoare.
scala> value.takeSample(false, 3, System.nanoTime.toInt)
ieşire:
res8: Array(Int) = Array(3, 1, 7)
f) funcția saveAsTextFile (cale) salvează setul de date în calea specificată a locației hdfs
scala> value.saveAsTextFile("/user/valuedir")
g) partiții. funcția lungime poate fi utilizată pentru a găsi numărul de partiții în RDD
scala> value.partitions.length
ieşire:
res1: Int = 8
Transformări RDD
Transformarea este utilizată pentru a forma un nou RDD din cele existente. Deoarece intrările RDD sunt imuabile, rezultatul format la transformare poate fi unul sau mai multe RDD ca ieșire.
Există două tipuri de transformări:
- Transformări înguste
- Transformări largi
Transformări înguste - Fiecare CDD părinte este împărțit în diferite partiții și dintre acestea, o singură partiție va fi utilizată de RDD copil.
Exemplu: harta () și filtrul () sunt cele două tipuri de transformări de bază care sunt numite atunci când este apelată o acțiune.
- funcția map (func) operează pe fiecare dintre elementele din setul de date „valoare” iterativ pentru a produce RDD-ul de ieșire.
Exemplu: În acest exemplu, adăugăm valoarea 10 la fiecare dintre elementele valorii setului de date și afișăm ieșirea transformată cu ajutorul funcției de colectare.
scala> val mapfunc = value.map(x => x+10)
mapfunc: org.apache.spark.rdd.RDD(Int) = MapPartitionsRDD(3) at map at :28
scala> mapfunc.collect
res2: Array(Int) = Array(11, 13, 15, 17, 19)
funcția filter (func) este folosită practic pentru a filtra elementele care îndeplinesc o anumită condiție specificată folosind funcția.
Exemplu: În acest exemplu, încercăm să preluăm toate elementele, cu excepția numărului 2 din setul de date „valoare” și să obținem ieșirea prin funcția de colectare.
scala> val fill = value.filter(x => x!=2)
fill: org.apache.spark.rdd.RDD(Int) = MapPartitionsRDD(7) at filter at :28
scala> fill.collect
res8: Array(Int) = Array(4, 6, 8, 10)
Transformări largi - O partiție RDD monoparentală este partajată pe diferitele sale partiții RDD pentru copii multiple.
Exemplu: groupbykey și reducebyKey sunt exemple de transformări largi.
- funcția groupbyKey grupează valorile setului de date în perechi cheie-valoare în funcție de valorile cheie dintr-un alt RDD. Acest proces implică amestecarea să aibă loc atunci când grupul funcție colectează datele asociate cu o anumită cheie și le stochează într-o singură pereche cheie-valoare.
Exemplu: În acest exemplu, alocăm numerele întregi 5, 6 valorii șirului „cheie” și numărului întreg 8 alocat „8” care sunt afișate în același format pereche cheie-valoare în ieșire.
scala> val data = spark.sparkContext.parallelize(Array(("key", 5), ("val", 8), ("key", 6)), 3)
data: org.apache.spark.rdd.RDD((String, Int)) = ParallelCollectionRDD(13) at parallelize at :23
scala> val group = data.groupByKey().collect()
group: Array((String, Iterable(Int))) = Array((key, CompactBuffer(5, 6)), (val, CompactBuffer(8)))
scala> group.foreach(println)
(key, CompactBuffer(5, 6))
(val, CompactBuffer(8))
- Funcția reduceByKey combină, de asemenea, perechile cheie-valoare de la diferite RDD. Acesta combină tastele și valorile respective într-un singur element după efectuarea transformării menționate.
Exemplu: În acest exemplu, tastele comune ale tabloului „litere” sunt paralizate mai întâi de funcție și fiecare literă este asociată cu numărul 10. ReduceByKey va adăuga valorile cu taste similare și economisește valoarea variabilă2. Ieșirea este apoi afișată folosind funcția de colectare.
scala> val letters = Array("A", "B", "C", "D", "B", "C", "E", "D")
letters: Array(String) = Array(A, B, C, D, B, C, E, D)
scala> val value2 = spark.sparkContext.parallelize(letters).map(w => (w, 10)).reduceByKey(_+_)
value2: org.apache.spark.rdd.RDD((String, Int)) = ShuffledRDD(20) at reduceByKey at :25
scala> value2.foreach(println)
(C, 20)
(E, 10)
(D, 20)
(B, 20)
(A, 10)
Alături de acțiunile menționate mai sus, cum ar fi compartimentarea la RDD și efectuarea acțiunilor / transformărilor asupra lor, Spark acceptă, de asemenea, memorarea în cache care este utilă atunci când aceleași date sunt apelate recursiv.
Cu ajutorul tuturor acestor proprietăți, Apache Spark poate prelucra volume uriașe de date și poate efectua procesare prin loturi și procesare în streaming. Calculul în memorie realizat de Spark este responsabil pentru procesarea extrem de rapidă a aplicațiilor. Prin urmare, Spark este metoda perfectă datorită versatilității sale de programare pe diferite limbaje, ușurința de utilizare și capabilitățile de integrare.
Articole recomandate
Acesta este un ghid pentru Comenzile Spark Shell. Aici vom discuta despre diferitele tipuri de comenzi Spark Shell pentru diferite limbaje de programare. De asemenea, puteți consulta articolul următor pentru a afla mai multe -
- Comenzi de script de Shell
- Cum se instalează Spark
- Întrebări la interviu Spark
- Comenzi scânteie
- Testare adhoc
- Generator de număr aleatoriu în JavaScript
- Ghid pentru lista de comenzi Unix Shell
- PySpark SQL | Module și metode de PySpark SQL
- Pentru bucla în Scripturi Shell | Cum funcționează bucla?
- Comenzi de script pentru loturi cu exemple
- Prezentare completă a componentelor scânteie