概述
什麼是Spark
- Spark是UC Berkeley AMP lab所開源的類Hadoop MapReduce的通用的平行計算框架,Spark基於map reduce演算法實現的分散式計算,擁有Hadoop MapReduce所具有的優點;但不同於MapReduce的是Job中間輸出和結果可以儲存在記憶體中,從而不再需要讀寫HDFS,因此Spark能更好地適用於資料探勘與機器學習等需要迭代的map reduce的演算法。其架構如下圖所示:
Spark與Hadoop的對比
- Spark的中間資料放到記憶體中,對於迭代運算效率更高。
- Spark更適合於迭代運算比較多的ML和DM運算。因為在Spark裡面,有RDD的抽象概念。
- Spark比Hadoop更通用。
- Spark提供的資料集操作型別有很多種,不像Hadoop只提供了Map和Reduce兩種操作。比如map, filter, flatMap, sample, groupByKey, reduceByKey, union, join, cogroup, mapValues, sort,partionBy等多種操作型別,Spark把這些操作稱為Transformations。同時還提供Count, collect, reduce, lookup, save等多種actions操作。
- 這些多種多樣的資料集操作型別,給給開發上層應用的使用者提供了方便。各個處理節點之間的通訊模型不再像Hadoop那樣就是唯一的Data Shuffle一種模式。使用者可以命名,物化,控制中間結果的儲存、分割槽等。可以說程式設計模型比Hadoop更靈活。
- 不過由於RDD的特性,Spark不適用那種非同步細粒度更新狀態的應用,例如web服務的儲存或者是增量的web爬蟲和索引。就是對於那種增量修改的應用模型不適合。
- 容錯性。
- 在分散式資料集計算時通過checkpoint來實現容錯,而checkpoint有兩種方式,一個是checkpoint data,一個是logging the updates。使用者可以控制採用哪種方式來實現容錯。
- 可用性。
- Spark通過提供豐富的Scala, Java,Python API及互動式Shell來提高可用性。
Spark與Hadoop的結合
- Spark可以直接對HDFS進行資料的讀寫,同樣支援Spark on YARN。Spark可以與MapReduce執行於同叢集中,共享儲存資源與計算,資料倉儲Shark實現上借用Hive,幾乎與Hive完全相容。
Spark的適用場景
- Spark是基於記憶體的迭代計算框架,適用於需要多次操作特定資料集的應用場合。需要反覆操作的次數越多,所需讀取的資料量越大,受益越大,資料量小但是計算密集度較大的場合,受益就相對較小
- 由於RDD的特性,Spark不適用那種非同步細粒度更新狀態的應用,例如web服務的儲存或者是增量的web爬蟲和索引。就是對於那種增量修改的應用模型不適合。
- 總的來說Spark的適用面比較廣泛且比較通用。
執行模式
- 本地模式
- Standalone模式
- Mesoes模式
- yarn模式
Spark生態系統
- Shark ( Hive on Spark): Shark基本上就是在Spark的框架基礎上提供和Hive一樣的H iveQL命令介面,為了最大程度的保持和Hive的相容性,Shark使用了Hive的API來實現query Parsing和 Logic Plan generation,最後的PhysicalPlan execution階段用Spark代替Hadoop MapReduce。通過配置Shark引數,Shark可以自動在記憶體中快取特定的RDD,實現資料重用,進而加快特定資料集的檢索。同時,Shark通過UDF使用者自定義函式實現特定的資料分析學習演算法,使得SQL資料查詢和運算分析能結合在一起,最大化RDD的重複使用。
- Spark streaming: 構建在Spark上處理Stream資料的框架,基本的原理是將Stream資料分成小的時間片斷(幾秒),以類似batch批量處理的方式來處理這小部分資料。Spark Streaming構建在Spark上,一方面是因為Spark的低延遲執行引擎(100ms+)可以用於實時計算,另一方面相比基於Record的其它處理框架(如Storm),RDD資料集更容易做高效的容錯處理。此外小批量處理的方式使得它可以同時相容批量和實時資料處理的邏輯和演算法。方便了一些需要歷史資料和實時資料聯合分析的特定應用場合。
- Bagel: Pregel on Spark,可以用Spark進行圖計算,這是個非常有用的小專案。Bagel自帶了一個例子,實現了Google的PageRank演算法。
在業界的使用
- Spark專案在2009年啟動,2010年開源, 現在使用的有:Berkeley, Princeton, Klout, Foursquare, Conviva, Quantifind, Yahoo! Research & others, 淘寶等,豆瓣也在使用Spark的python克隆版Dpark。
Spark核心概念
Resilient Distributed Dataset (RDD)彈性分佈資料集
- RDD是Spark的最基本抽象,是對分散式記憶體的抽象使用,實現了以操作本地集合的方式來操作分散式資料集的抽象實現。RDD是Spark最核心的東西,它表示已被分割槽,不可變的並能夠被並行操作的資料集合,不同的資料集格式對應不同的RDD實現。RDD必須是可序列化的。RDD可以cache到記憶體中,每次對RDD資料集的操作之後的結果,都可以存放到記憶體中,下一個操作可以直接從記憶體中輸入,省去了MapReduce大量的磁碟IO操作。這對於迭代運算比較常見的機器學習演算法, 互動式資料探勘來說,效率提升比較大。
- RDD的特點:
- 它是在叢集節點上的不可變的、已分割槽的集合物件。
- 通過並行轉換的方式來建立如(map, filter, join, etc)。
- 失敗自動重建。
- 可以控制儲存級別(記憶體、磁碟等)來進行重用。
- 必須是可序列化的。
- 是靜態型別的。
- RDD的好處
- RDD只能從持久儲存或通過Transformations操作產生,相比於分散式共享記憶體(DSM)可以更高效實現容錯,對於丟失部分資料分割槽只需根據它的lineage就可重新計算出來,而不需要做特定的Checkpoint。
- RDD的不變性,可以實現類Hadoop MapReduce的推測式執行。
- RDD的資料分割槽特性,可以通過資料的本地性來提高效能,這與Hadoop MapReduce是一樣的。
- RDD都是可序列化的,在記憶體不足時可自動降級為磁碟儲存,把RDD儲存於磁碟上,這時效能會有大的下降但不會差於現在的MapReduce。
- RDD的儲存與分割槽
- 使用者可以選擇不同的儲存級別儲存RDD以便重用。
- 當前RDD預設是儲存於記憶體,但當記憶體不足時,RDD會spill到disk。
- RDD在需要進行分割槽把資料分佈於叢集中時會根據每條記錄Key進行分割槽(如Hash 分割槽),以此保證兩個資料集在Join時能高效。
- RDD的內部表示
在RDD的內部實現中每個RDD都可以使用5個方面的特性來表示:- 分割槽列表(資料塊列表)
- 計算每個分片的函式(根據父RDD計算出此RDD)
- 對父RDD的依賴列表
- 對key-value RDD的Partitioner【可選】
- 每個資料分片的預定義地址列表(如HDFS上的資料塊的地址)【可選】
- RDD的儲存級別
RDD根據useDisk、useMemory、deserialized、replication四個引數的組合提供了11種儲存級別:
1 2 3 4 5 6 7 8 9 10 11 |
val NONE = new StorageLevel(false, false, false) val DISK_ONLY = new StorageLevel(true, false, false) val DISK_ONLY_2 = new StorageLevel(true, false, false, 2) val MEMORY_ONLY = new StorageLevel(false, true, true) val MEMORY_ONLY_2 = new StorageLevel(false, true, true, 2) val MEMORY_ONLY_SER = new StorageLevel(false, true, false) val MEMORY_ONLY_SER_2 = new StorageLevel(false, true, false, 2) val MEMORY_AND_DISK = new StorageLevel(true, true, true) val MEMORY_AND_DISK_2 = new StorageLevel(true, true, true, 2) val MEMORY_AND_DISK_SER = new StorageLevel(true, true, false) val MEMORY_AND_DISK_SER_2 = new StorageLevel(true, true, false, 2) |
- RDD定義了各種操作,不同型別的資料由不同的RDD類抽象表示,不同的操作也由RDD進行抽實現。
RDD的生成
- RDD有兩種建立方式:
1、從Hadoop檔案系統(或與Hadoop相容的其它儲存系統)輸入(例如HDFS)建立。
2、從父RDD轉換得到新RDD。 - 下面來看一從Hadoop檔案系統生成RDD的方式,如:
val file = spark.textFile("hdfs://...")
,file變數就是RDD(實際是HadoopRDD例項),生成的它的核心程式碼如下:
1 2 3 4 5 6 7 8 |
// SparkContext根據檔案/目錄及可選的分片數建立RDD, 這裡我們可以看到Spark與Hadoop MapReduce很像 // 需要InputFormat, Key、Value的型別,其實Spark使用的Hadoop的InputFormat, Writable型別。 def textFile(path: String, minSplits: Int = defaultMinSplits): RDD[String] = { hadoopFile(path, classOf[TextInputFormat], classOf[LongWritable], classOf[Text], minSplits) .map(pair => pair._2.toString) } // 根據Hadoop配置,及InputFormat等建立HadoopRDD new HadoopRDD(this, conf, inputFormatClass, keyClass, valueClass, minSplits) |
- 對RDD進行計算時,RDD從HDFS讀取資料時與Hadoop MapReduce幾乎一樣的:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
// 根據hadoop配置和分片從InputFormat中獲取RecordReader進行資料的讀取。 reader = fmt.getRecordReader(split.inputSplit.value, conf, Reporter.NULL) val key: K = reader.createKey() val value: V = reader.createValue() //使用Hadoop MapReduce的RecordReader讀取資料,每個Key、Value對以元組返回。 override def getNext() = { try { finished = !reader.next(key, value) } catch { case eof: EOFException => finished = true } (key, value) } |
RDD的轉換與操作
- 對於RDD可以有兩種計算方式:轉換(返回值還是一個RDD)與操作(返回值不是一個RDD)。
- 轉換(Transformations) (如:map, filter, groupBy, join等),Transformations操作是Lazy的,也就是說從一個RDD轉換生成另一個RDD的操作不是馬上執行,Spark在遇到Transformations操作時只會記錄需要這樣的操作,並不會去執行,需要等到有Actions操作的時候才會真正啟動計算過程進行計算。
- 操作(Actions) (如:count, collect, save等),Actions操作會返回結果或把RDD資料寫到儲存系統中。Actions是觸發Spark啟動計算的動因。
- 下面使用一個例子來示例說明Transformations與Actions在Spark的使用。
12345678910111213val sc = new SparkContext(master, "Example", System.getenv("SPARK_HOME"),Seq(System.getenv("SPARK_TEST_JAR")))val rdd_A = sc.textFile(hdfs://.....)val rdd_B = rdd_A.flatMap((line => line.split("\\s+"))).map(word => (word, 1))val rdd_C = sc.textFile(hdfs://.....)val rdd_D = rdd_C.map(line => (line.substring(10), 1))val rdd_E = rdd_D.reduceByKey((a, b) => a + b)val rdd_F = rdd_B.jion(rdd_E)rdd_F.saveAsSequenceFile(hdfs://....)
Lineage(血統)
- 利用記憶體加快資料載入,在眾多的其它的In-Memory類資料庫或Cache類系統中也有實現,Spark的主要區別在於它處理分散式運算環境下的資料容錯性(節點實效/資料丟失)問題時採用的方案。為了保證RDD中資料的魯棒性,RDD資料集通過所謂的血統關係(Lineage)記住了它是如何從其它RDD中演變過來的。相比其它系統的細顆粒度的記憶體資料更新級別的備份或者LOG機制,RDD的Lineage記錄的是粗顆粒度的特定資料轉換(Transformation)操作(filter, map, join etc.)行為。當這個RDD的部分分割槽資料丟失時,它可以通過Lineage獲取足夠的資訊來重新運算和恢復丟失的資料分割槽。這種粗顆粒的資料模型,限制了Spark的運用場合,但同時相比細顆粒度的資料模型,也帶來了效能的提升。
- RDD在Lineage依賴方面分為兩種Narrow Dependencies與Wide Dependencies用來解決資料容錯的高效性。Narrow Dependencies是指父RDD的每一個分割槽最多被一個子RDD的分割槽所用,表現為一個父RDD的分割槽對應於一個子RDD的分割槽或多個父RDD的分割槽對應於一個子RDD的分割槽,也就是說一個父RDD的一個分割槽不可能對應一個子RDD的多個分割槽。Wide Dependencies是指子RDD的分割槽依賴於父RDD的多個分割槽或所有分割槽,也就是說存在一個父RDD的一個分割槽對應一個子RDD的多個分割槽。對與Wide Dependencies,這種計算的輸入和輸出在不同的節點上,lineage方法對與輸入節點完好,而輸出節點當機時,通過重新計算,這種情況下,這種方法容錯是有效的,否則無效,因為無法重試,需要向上其祖先追溯看是否可以重試(這就是lineage,血統的意思),Narrow Dependencies對於資料的重算開銷要遠小於Wide Dependencies的資料重算開銷。
容錯
- 在RDD計算,通過checkpint進行容錯,做checkpoint有兩種方式,一個是checkpoint data,一個是logging the updates。使用者可以控制採用哪種方式來實現容錯,預設是logging the updates方式,通過記錄跟蹤所有生成RDD的轉換(transformations)也就是記錄每個RDD的lineage(血統)來重新計算生成丟失的分割槽資料。
資源管理與作業排程
- Spark對於資源管理與作業排程可以使用Standalone(獨立模式),Apache Mesos及Hadoop YARN來實現。 Spark on Yarn在Spark0.6時引用,但真正可用是在現在的branch-0.8版本。Spark on Yarn遵循YARN的官方規範實現,得益於Spark天生支援多種Scheduler和Executor的良好設計,對YARN的支援也就非常容易,Spark on Yarn的大致框架圖。
- 讓Spark執行於YARN上與Hadoop共用叢集資源可以提高資源利用率。
程式設計介面
- Spark通過與程式語言整合的方式暴露RDD的操作,類似於DryadLINQ和FlumeJava,每個資料集都表示為RDD物件,對資料集的操作就表示成對RDD物件的操作。Spark主要的程式語言是Scala,選擇Scala是因為它的簡潔性(Scala可以很方便在互動式下使用)和效能(JVM上的靜態強型別語言)。
- Spark和Hadoop MapReduce類似,由Master(類似於MapReduce的Jobtracker)和Workers(Spark的Slave工作節點)組成。使用者編寫的Spark程式被稱為Driver程式,Dirver程式會連線master並定義了對各RDD的轉換與操作,而對RDD的轉換與操作通過Scala閉包(字面量函式)來表示,Scala使用Java物件來表示閉包且都是可序列化的,以此把對RDD的閉包操作傳送到各Workers節點。 Workers儲存著資料分塊和享有叢集記憶體,是執行在工作節點上的守護程式,當它收到對RDD的操作時,根據資料分片資訊進行本地化資料操作,生成新的資料分片、返回結果或把RDD寫入儲存系統。
Scala
- Spark使用Scala開發,預設使用Scala作為程式語言。編寫Spark程式比編寫Hadoop MapReduce程式要簡單的多,SparK提供了Spark-Shell,可以在Spark-Shell測試程式。寫SparK程式的一般步驟就是建立或使用(SparkContext)例項,使用SparkContext建立RDD,然後就是對RDD進行操作。如:
1 2 3 |
val sc = new SparkContext(master, appName, [sparkHome], [jars]) val textFile = sc.textFile("hdfs://.....") textFile.map(....).filter(.....)..... |
Java
- Spark支援Java程式設計,但對於使用Java就沒有了Spark-Shell這樣方便的工具,其它與Scala程式設計是一樣的,因為都是JVM上的語言,Scala與Java可以互操作,Java程式設計介面其實就是對Scala的封裝。如:
1 2 3 4 5 6 7 8 9 |
JavaSparkContext sc = new JavaSparkContext(...); JavaRDD lines = ctx.textFile("hdfs://..."); JavaRDD words = lines.flatMap( new FlatMapFunction<String, String>() { public Iterable call(String s) { return Arrays.asList(s.split(" ")); } } ); |
Python
- 現在Spark也提供了Python程式設計介面,Spark使用py4j來實現python與java的互操作,從而實現使用python編寫Spark程式。Spark也同樣提供了pyspark,一個Spark的python shell,可以以互動式的方式使用Python編寫Spark程式。 如:
1 2 3 4 |
from pyspark import SparkContext sc = SparkContext("local", "Job Name", pyFiles=['MyFile.py', 'lib.zip', 'app.egg']) words = sc.textFile("/usr/share/dict/words") words.filter(lambda w: w.startswith("spar")).take(5) |
使用示例
Standalone模式
- 為方便Spark的推廣使用,Spark提供了Standalone模式,Spark一開始就設計執行於Apache Mesos資源管理框架上,這是非常好的設計,但是卻帶了部署測試的複雜性。為了讓Spark能更方便的部署和嘗試,Spark因此提供了Standalone執行模式,它由一個Spark Master和多個Spark worker組成,與Hadoop MapReduce1很相似,就連叢集啟動方式都幾乎是一樣。
- 以Standalone模式執行Spark叢集
- 下載Scala2.9.3,並配置SCALA_HOME
- 下載Spark程式碼(可以使用原始碼編譯也可以下載編譯好的版本)這裡下載 編譯好的版本(
http://spark-project.org/download/spark-0.7.3-prebuilt-cdh4.tgz
) - 解壓spark-0.7.3-prebuilt-cdh4.tgz安裝包
- 修改配置(conf/*) slaves: 配置工作節點的主機名 spark-env.sh:配置環境變數。
123456789SCALA_HOME=/home/spark/scala-2.9.3JAVA_HOME=/home/spark/jdk1.6.0_45SPARK_MASTER_IP=spark1SPARK_MASTER_PORT=30111SPARK_MASTER_WEBUI_PORT=30118SPARK_WORKER_CORES=2 SPARK_WORKER_MEMORY=4gSPARK_WORKER_PORT=30333SPARK_WORKER_WEBUI_PORT=30119SPARK_WORKER_INSTANCES=1 - 把Hadoop配置copy到conf目錄下
- 在master主機上對其它機器做ssh無密碼登入
- 把配置好的Spark程式使用scp copy到其它機器
- 在master啟動叢集
1 |
$SPARK_HOME/start-all.sh |
yarn模式
- Spark-shell現在還不支援Yarn模式,使用Yarn模式執行,需要把Spark程式全部打包成一個jar包提交到Yarn上執行。目錄只有branch-0.8版本才真正支援Yarn。
- 以Yarn模式執行Spark
- 下載Spark程式碼.
- 切換到branch-0.8
- 使用sbt編譯Spark並
- 把Hadoop yarn配置copy到conf目錄下
- 執行測試
1git clone git://github.com/mesos/spark12cd sparkgit checkout -b yarn --track origin/yarn123$SPARK_HOME/sbt/sbt> package> assembly123SPARK_JAR=./core/target/scala-2.9.3/spark-core-assembly-0.8.0-SNAPSHOT.jar \./run spark.deploy.yarn.Client --jar examples/target/scala-2.9.3/ \--class spark.examples.SparkPi --args yarn-standalone
使用Spark-shell
- Spark-shell使用很簡單,當Spark以Standalon模式執行後,使用
$SPARK_HOME/spark-shell
進入shell即可,在Spark-shell中SparkContext已經建立好了,例項名為sc可以直接使用,還有一個需要注意的是,在Standalone模式下,Spark預設使用的排程器的FIFO排程器而不是公平排程,而Spark-shell作為一個Spark程式一直執行在Spark上,其它的Spark程式就只能排隊等待,也就是說同一時間只能有一個Spark-shell在執行。 - 在Spark-shell上寫程式非常簡單,就像在Scala Shell上寫程式一樣。
1 2 3 4 5 6 7 8 |
scala> val textFile = sc.textFile("hdfs://hadoop1:2323/user/data") textFile: spark.RDD[String] = spark.MappedRDD@2ee9b6e3 scala> textFile.count() // Number of items in this RDD res0: Long = 21374 scala> textFile.first() // First item in this RDD res1: String = # Spark |
編寫Driver程式
- 在Spark中Spark程式稱為Driver程式,編寫Driver程式很簡單幾乎與在Spark-shell上寫程式是一樣的,不同的地方就是SparkContext需要自己建立。如WorkCount程式如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
import spark.SparkContext import SparkContext._ object WordCount { def main(args: Array[String]) { if (args.length ==0 ){ println("usage is org.test.WordCount ") } println("the args: ") args.foreach(println) val hdfsPath = "hdfs://hadoop1:8020" // create the SparkContext, args(0)由yarn傳入appMaster地址 val sc = new SparkContext(args(0), "WrodCount", System.getenv("SPARK_HOME"), Seq(System.getenv("SPARK_TEST_JAR"))) val textFile = sc.textFile(hdfsPath + args(1)) val result = textFile.flatMap(line => line.split("\\s+")) .map(word => (word, 1)).reduceByKey(_ + _) result.saveAsTextFile(hdfsPath + args(2)) } } |