Mi a Spark Shell parancsok?
A Spark shell egy felület, amely adhoc lekérdezések írására szolgál az Apache Spark működésének megértéséhez és megértéséhez. Fürtszámítástechnikai nyílt forrású motornak nevezzük, amely képes a memóriában végzett adatok feldolgozására, például elemzésre, ETL-re, gépi tanulásra hatalmas adatkészletekhez. Ebben a témában megismerjük a Spark Shell parancsokat.
Különböző típusú Spark shell létezik a különböző programozási nyelvek számára:
- A szikrahéj Scala nyelven íródott
- A pyspark Pythonban és
- sparkR az R nyelvre
A Spark segítségével elkészítheti önálló alkalmazását. Szupergyors számítási sebessége miatt széles körben használják. Ennek oka az, hogy a MapReduce segítségével különféle lekérdezéseket és átalakításokat dolgoz fel.
A szikra-parancs futtatásához a Java és a Scala telepítésére van szükség a rendszerben.
A Spark Shell parancsok típusai
A különféle Spark-shell parancsok a következők:
1. Annak ellenőrzéséhez, hogy a Spark telepítve van-e, és annak verziójának megismerése érdekében az alábbiakban ismertetett parancsot használják (a továbbiakban minden parancsot a „$” szimbólummal kezdve kell jelölni)
$ szikra-héj
A következő kimenet jelenik meg, ha a szikra telepítve van:
$ szikra-héj
Az SPARK_MAJOR_VERSION értéke 2, a Spark2 használatával
Az alapértelmezett naplószint beállítása „WARN”.
A naplózási szint beállításához használja az sc.setLogLevel (newLevel) alkalmazást. A SparkR esetén használja a setLogLevel (newLevel) alkalmazást.
Spark-kontextusú webes felhasználói felület elérhető a http://10.113.59.34:4040 oldalon
A szikra összefüggésben 'sc' formátumban érhető el (master = local (*), app id = local-1568732886588).
A szikra ülés 'szikra' formában kapható.
Isten hozott a
____ __
/ __ / __ ___ _____ / / __
_ \ \ / _ \ / _ `/ __ / '_ /
/ ___ / .__ / \ _, _ / _ / / _ / \ _ \ 2.2.0.2.6.3.0-235 verzió
/ _ /
A Scala 2.11.8 verziójának használata (Java HotSpot (TM) 64 bites kiszolgáló virtuális gép, Java 1.8.0_112)
Írja be a kifejezéseket, hogy értékelje őket.
Típus: súgó további információkért.
scala>
2. A Spark alapvető adatstruktúráját RDD-nek (Resilient Distributed Datasets) hívják, amely az objektumok változatlan gyűjteményét tartalmazza a rekordok elosztott számításához. Az RDD összes adatkészlete logikusan van particionálva a fürt több csomópontján.
Az RDD létrehozása csak egy helyi fájlrendszerből történő leolvasással vagy egy meglévő RDD átalakításával hozható létre.
a) Új RDD létrehozásához a következő parancsot használjuk:
scala> val examplefile = sc.textFile("file.txt")
Az sc neve a SparkContext objektuma.
Kimenet:
examplefile: org.apache.spark.rdd.RDD(String) = file.txt MapPartitionsRDD(3) at textFile at :24
b) RDD létrehozható a párhuzamos gyűjtés révén, az alábbiak szerint:
scala> val oddnum = Array(1, 3, 5, 7, 9)
Kimenet:
oddnum: Array(Int) = Array(1, 3, 5, 7, 9)
scala> val value = sc.parallelize(oddnum)
Kimenet:
value: org.apache.spark.rdd.RDD(Int) = ParallelCollectionRDD(4) at parallelize at :26
c) Létrehozás meglévő RDD-kből :
scala> val newRDD = oddnum.map(value => (value * 2))
Kimenet:
newRDD: Array(Int) = Array(2, 6, 10, 14, 18)
3. A Spark RDD műveleteknek két típusa létezik: a létrehozott adatkészleteken végrehajtható:
- Hozzászólások
- transzformációk
Műveletek: A szükséges műveletek végrehajtására szolgál a meglévő adatkészleteken. Az alábbiakban felsorolunk néhány parancsot, amelyek felhasználhatók az alábbi műveletek végrehajtására a létrehozott adatkészleteken:
a) count () függvény az RDD-ben lévő elemek számának kiszámításához:
scala> value.count()
Kimenet:
res3: Long = 5
b) a () függvény a tömb összes elemének megjelenítéséhez:
scala> value.collect()
Kimenet:
res5: Array(Int) = Array(1, 3, 5, 7, 9)
c) first () függvény az adatkészlet első elemének megjelenítéséhez:
scala> value.first()
Kimenet:
res4: Int = 1
d) take (n) függvény megjeleníti a tömb első n elemét:
scala> value.take(3)
Kimenet:
res6: Array(Int) = Array(1, 3, 5)
e) takeSample (withReplacement, num, (seed)) függvény egy „num” elemek véletlenszerű tömbjét jeleníti meg, ahol a vetőmag a véletlenszám-generátor számára van.
scala> value.takeSample(false, 3, System.nanoTime.toInt)
Kimenet:
res8: Array(Int) = Array(3, 1, 7)
f) saveAsTextFile (elérési út) függvény menti az adatkészletet a hdfs helyének megadott útvonalán
scala> value.saveAsTextFile("/user/valuedir")
g) partíciók. A hosszúság funkció felhasználható a partíciók számának megkeresésére az RDD-ben
scala> value.partitions.length
Kimenet:
res1: Int = 8
RDD transzformációk
Az átalakítás segítségével új RDD alakul ki a meglévőkről. Mivel az RDD bemenetei változatlanok, az átalakítás során kialakult eredmény lehet kimeneti egy vagy több RDD.
Kétféle transzformáció létezik:
- Keskeny transzformációk
- Széles átalakulások
Keskeny transzformációk - Minden szülő RDD különféle partíciókra van felosztva, és ezek között csak egy partíciót fogja használni a gyermek RDD.
Példa: a map () és a filter () az alapvető transzformációk két alapvető típusa, amelyeket egy művelet meghívásakor hívnak meg.
- A map (func) függvény az „érték” adatkészlet minden elemén iteratív módon működik a kimeneti RDD előállításához.
Példa: Ebben a példában a 10-es értéket hozzáadjuk az adatkészlet-érték minden eleméhez, és a transzformált kimenetet megjelenítjük a gyűjtési funkció segítségével.
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)
A szűrő (func) funkciót alapvetően arra a célra használják, hogy kiszűrje azokat az elemeket, amelyek kielégítik egy adott feltételt, amely a funkció használatával meghatározott.
Példa: Ebben a példában megpróbálunk minden elemet lekérni, kivéve az „érték” adatkészlet 2. számát, és a kimenetet a gyűjtési funkción keresztül töltsük le.
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)
Széles átalakítások - Az egyszülős RDD partíció megoszlik a különböző többszörös gyermek RDD partícióin.
Példa: a csoportgomb és a redukciós kulcs a széles átalakulások példái.
- groupbyKey függvény az adatkészlet értékeit kulcs-érték párokba csoportosítja egy másik RDD kulcsértékei szerint. Ez a folyamat magában foglalja a csoszogást, amikor a csoportonként funkció szerint gyűjti az adott kulcshoz tartozó adatokat, és egyetlen kulcs-érték párban tárolja azokat.
Példa: Ebben a példában az 5, 6 egész számot hozzárendeljük a „kulcs” karakterláncértékhez, és a 8 egész számot hozzárendeljük a „8” értékhez, amelyek ugyanabban a kulcs-érték pár formátumban jelennek meg a kimeneten.
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))
- A ReduyByKey funkció a különböző RDD-k kulcs-érték pároit is kombinálja. A kulcsokat és azok értékeit egyetlen elemre egyesíti, miután végrehajtotta az említett átalakítást.
Példa: Ebben a példában a „betűk” tömb általános gombjait először párhuzamosítja a függvény, és minden betűt 10-es számmal jelölnek meg. A csökkentőByKey hozzáadja a hasonló kulcsokkal rendelkező értékeket, és elmenti a 2. értékű változóba. A kimenetet ezután a gyűjtési funkcióval jelenítjük meg.
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)
A fent említett műveletek mellett, például az RDD-re történő particionálás és a műveletek / átalakítások végrehajtása mellett, a Spark támogatja a gyorsítótárazást is, amely akkor hasznos, ha ugyanazokat az adatokat rekurzívan hívják.
Ezen tulajdonságok segítségével az Apache Spark hatalmas mennyiségű adatot képes feldolgozni, kötegelt és streaming feldolgozást végez. A Spark által a memóriában végzett számítás felelős az alkalmazások rendkívül gyors feldolgozásáért. Ezért a Spark a legfontosabb módszer a különféle nyelveken történő programozás sokoldalúsága, a könnyű használat és az integrációs képességek miatt.
Ajánlott cikkek
Ez a Spark Shell parancsok útmutatója. Itt a Spark Shell parancsok különféle típusait tárgyaljuk a különböző programozási nyelvekhez. A következő cikkben további információkat is megnézhet -
- Héj parancsfájlok parancsai
- A Spark telepítése
- Spark Interjú Kérdések
- Spark parancsok
- Adhoc tesztelés
- Véletlenszám-generátor a JavaScript-ben
- Útmutató az Unix Shell parancsok listájához
- PySpark SQL | A PySpark SQL moduljai és módszerei
- Hurok a héj parancsfájlokban Hogyan működik a hurok?
- Kötegelt szkript parancsok példákkal
- A Spark alkatrészek teljes áttekintése