目錄

• 概述
• 鏈接Spark
• 初始化Spark
  • 使用Shell
• 彈性分布式數據集 (RDDs)
  • 並行化集合
  • 外部數據集
  • RDD 操作
    • 基本操作
    • Spark回調函數
    • 使用 Key-Value 對
    • 轉換 (Transformations)
    • 動作 (Actions)
  • RDD 持久化
    • 選擇哪個存儲級別?
    • 刪除數據
• 共享變量
  • 廣播變量
  • 累加器
• 集群到部署
• 單元測試
• Spark版本遷移(pre-1.0)
• 接下來做什麽

概述

從概念上來說，每個spark程序都由一個驅動程序組成，驅動程序運行用戶的main函數並且在集群上執行各種並行操作. Spark中的主要抽象概念是彈性分布式數據集(RDD), RDD是分布在集群各節點上的可並行操作的元素集合。 RDD可以通過hdfs中的文件創建，也可以通過驅動程序中的集合(例如Python中的List)轉化而成。 用戶還可以把RDD保存在內存中，供後續的並行操作高效重複使用. 並且, RDD可以從節點失效中自動恢複.
Spark的另外一個抽象概念是可以並行操作的共享變量(shared variables). By default, when Spark runs a function in parallel as a set of tasks on different nodes默認情況下，Spark以任務(task)集的方式在不同節點上並行執行函數,每個任務都會獲得一份變量的拷貝。 有些情況下，變量需要在任務之間共享，或者再任務和驅動程序之間共享。為了解決這樣的應用場景，Spark支持兩種類型的共享變量：一種是廣播變量( broadcast variables), 這種變量可以緩存在所有節點的內存中；另外一種是累加器(accumulators)，種變量隻能增加，例如計數器或者求和.
本文將會以Python語言為例介紹Spark的這些特性。通過啟動Spark交互shell非常容易學習這些特性，Python版的交互shell是bin/pyspark 。

鏈接Spark

from pyspark import SparkContext, SparkConf

初始化Spark

conf = SparkConf().setAppName(appName).setMaster(master)
sc = SparkContext(conf=conf)

使用Shell

$ ./bin/pyspark --master local[4]

$ ./bin/pyspark --master local[4] --py-files code.py

Resilient Distributed Datasets (RDDs)

Spark是圍繞彈性分布式數據集（RDD）的概念展開的，RDD是一種容錯的可分布式操作的數據集合。有兩中方式可以創建RDD：一種是將驅動程序中的已有集合平行化；另外一種是引用外部存儲係統的數據集，例如共享文件係統，HDFS, HBase, 或者其他類似Hadoop的數據源。

並行化集合

data = [1, 2, 3, 4, 5]
distData = sc.parallelize(data)

外部數據集

distFile = sc.textFile("data.txt")

>>> rdd = sc.parallelize(range(1, 4)).map(lambda x: (x, "a" * x ))
>>> rdd.saveAsSequenceFile("path/to/file")
>>> sorted(sc.sequenceFile("path/to/file").collect())
[(1, u'a'), (2, u'aa'), (3, u'aaa')]

$ SPARK_CLASSPATH=/path/to/elasticsearch-hadoop.jar ./bin/pyspark
>>> conf = {"es.resource" : "index/type"}   # assume Elasticsearch is running on localhost defaults
>>> rdd = sc.newAPIHadoopRDD("org.elasticsearch.hadoop.mr.EsInputFormat",\
    "org.apache.hadoop.io.NullWritable", "org.elasticsearch.hadoop.mr.LinkedMapWritable", conf=conf)
>>> rdd.first()         # the result is a MapWritable that is converted to a Python dict
(u'Elasticsearch ID',
 {u'field1': True,
  u'field2': u'Some Text',
  u'field3': 12345})

RDD 操作

RDDs支持兩種類型的操作：一種是轉換(transformations), 該操作從已有數據集創建新的數據集；另外一種是動作(actions)，該操作在數據集上執行計算之後返回一個值給驅動程序。例如, map就是一個轉換，這個操作在數據集的每個元素上執行一個函數並返回一個處理之後新的RDD結果。另一方麵，reduce是一個動作，這個操作按照某個函數規則聚集RDD中的所有元素並且把最終結果返回給驅動程序。
Spark中的所有轉換操作都是lazy模式的，也就是說，不是立馬做轉換計算結果，而是將這些轉換操作記錄在相應的數據集上，當需要通過動作(action)把結果返回給驅動程序時才真正執行。這個設計使Spark運行起來更加高效。例如，如果通過map創建的數據集後續會被reduce用到，那麽隻有reduce的結果會返回給驅動程序，而不是更大的map結果。
默認情況下，RDD上的轉換操作在每次做動作時，都會重新執行計算一次。然而，我們可以使用persist(或者cache)函數將RDD存放在內存中，方便後續的快速訪問。另外，Spark也支持將RDD存放在磁盤上，或者在多個節點讓冗餘存儲。

基本用法

lines = sc.textFile("data.txt")
lineLengths = lines.map(lambda s: len(s))
totalLength = lineLengths.reduce(lambda a, b: a + b)

Spark回調函數

"""MyScript.py"""
if __name__ == "__main__":
    def myFunc(s):
        words = s.split(" ")
        return len(words)

    sc = SparkContext(...)
    sc.textFile("file.txt").map(myFunc)

class MyClass(object):
    def func(self, s):
        return s
    def doStuff(self, rdd):
        return rdd.map(self.func)

class MyClass(object):
    def __init__(self):
        self.field = "Hello"
    def doStuff(self, rdd):
        return rdd.map(lambda s: self.field + x)

def doStuff(self, rdd):
    field = self.field
    return rdd.map(lambda s: field + x)

使用Key-Value對

lines = sc.textFile("data.txt")
pairs = lines.map(lambda s: (s, 1))
counts = pairs.reduceByKey(lambda a, b: a + b)

轉換(Transformations)

下表列出了Spark中一些常見的轉換操作。可以參考RDD API文檔(Python)查看細節。

動作(Actions)

下表列出了一些Spark中常用的動作(actions)。可以參考RDD API文檔(Python)查看細節。

RDD持久化

Spark中最重要的能力之一是將數據持久化到內存中方便後續操作。當持久化一個RDD的時候，一旦該RDD在內存中計算出來，每個節點保存RDD的部分分區，在其他動作中就可以重用內存中的這個RDD(以及源於它的新RDD)。這種機製使得後續的動作(actions)快很多（通常在10倍以上）。緩存是迭代算法或者快速交互的利器。
我們可以通過persist() 或者cache()兩個方法將RDD標記為持久化的。該RDD第一次在動作中計算出來之後，就會被保存在各節點的內存中。Spark的緩存是容錯的——任意RDD分區丟失之後，會自動使用原來的轉換動作重新計算出來。
另外，每個持久化的RDD可以按照不同的存儲等級來存儲。例如，可以持久化到磁盤，也可持久化到內存中，還可以放到外部緩存係統(off-Heap)。這些存儲等級可以通過傳一個StorageLevel對象給函數persist()來設置。方法cache()是使用默認存儲等級的快速寫法（Python中存儲等級設置為StorageLevel.MEMORY_ONLY_SER, Scala/Java中是StorageLevel.MEMORY_ONLY）。完整的存儲等級說明如下：

Note: In Python, stored objects will always be serialized with the Pickle library, so it does not matter whether you choose a serialized level. Spark也會自動持久化shuffle操作中的一些即時數據(例如reduceByKey的過程中)，即使用戶不顯示調用persist。這樣做可以避免shuffle過程中節點失效時重新計算整個輸入。不過我們還是建議顯示調用persist，如果需要計劃重用RDD的話。

選擇哪個存儲級別?

Spark的存儲級別是為了提供在內存使用CPU效率上的平衡。我們建議通過以下過程來做出選擇。

• 如果RDD能適應默認的存儲等級(MEORY_ONLY)，那就選這種方式。因為這是最利於CPU效率的選擇，允許盡可能快的操作RDD。
• 如果不行的話就使用(MEMORY_ONLY_SER)，並選擇一個快速序列化庫讓對象有更好的空間利用率，並且有相當快的訪問速度。
• 不要讓RDD溢出到磁盤上，除非計算數據的代價很高，或者產出的數據特別大。
• 如果想要快速的故障恢複就使用冗餘存儲等級。所有的存儲等級通過重新計算丟失的數據來提供完整的容錯，但是冗餘存儲讓我們可以繼續操作RDD，而不用等待重新計算丟失的分區。
• 在需要大量內存或者多個應用的環境中，實驗特性OFF_HEAP模式有以下幾個優點：
  • 多個執行器共享內存。
  • 顯劇減少垃圾收集的開銷
  • 個別執行器掛掉不會到值緩存數據丟失。

刪除數據

Spark自動監視每個節點上的緩存使用，並按ＬＲＵ（最近最少訪問）的方式踢掉數據。如果我們想要手動刪掉ＲＤＤ而不是等到被踢出緩存，使用RDD.unpersist()方法。

共享變量

通常，當一個函數被傳到遠程集群節點執行的Spark操作中（例如map或者reduce)時，所有的函數變量都會有獨立的工作副本。這些變量會被拷貝到每台機器，遠程機器上變量的修改不會回傳給驅動程序。在任務之間對一般讀寫共享變量的支持比較低效。但是，為了適應通用的引用場景，Spark還是提供了有兩個有限的共享變量類型：廣播變量和累加器。

廣播變量

共享變量允許程序員將一個隻讀的變量緩存在每台機器上，而不是讓每個任務隨帶一個變量的副本。廣播變量為在每個節點上提供海量的輸入數據集提供了一種高效的方式。Spark會嘗試使用高效餓廣播算法來減少分發廣播變量的通信消耗。
廣播變量通過調用SparkContext.broacase(v)創建, v是一個變量。廣播變量是v的封裝, v的值可以通過value方法訪問。下麵的代碼說明了這個用法：

>>> broadcastVar = sc.broadcast([1, 2, 3])
<pyspark.broadcast.Broadcast object at 0x102789f10>

>>> broadcastVar.value
[1, 2, 3]

廣播變量創建之後，應該在所有函數中替代v來使用，以免v多次被發送到集群節點。另外，對象v廣播之後，不應該被修改，從而保證所有的節點看到的是相同的廣播變量值。

累計器

累計器是隻能通過關聯操作做“加”運算的變量，從而可以高效支持並行。它可以用來實現計數器或者求和。Spark原生支持數字類型的累計器，程序員可以增加對新類型的支持。 如果累加器創建時賦給了一個名字，那麽這個累加器會在Spark的UI上展現。這個有利於理解程序的執行過程（遺憾的是這個功能Python中暫不支持）。 累計器通過調用函數SparContext.accumulator(v)並賦予一個初值來創建。然後跑在集群上的任務就可以使用add方法或者+=運算符增加累計器的值。但是，任務是不能讀這個累計器的值得，隻有驅動程序才可以通過方法value來讀。
下麵的代碼展示了將一個數組中的元素都添加到累計器的過程：

>>> accum = sc.accumulator(0)
Accumulator<id=0, value=0>

>>> sc.parallelize([1, 2, 3, 4]).foreach(lambda x: accum.add(x))
...
10/09/29 18:41:08 INFO SparkContext: Tasks finished in 0.317106 s

scala> accum.value
10

這段代碼使用的是內置的整數類型累加器，程序員也可以通過子類AccumulatorParam創建自己的類型。AccumulatorParam接口有兩個方法：zero用於提供零值, addInPlace用於將兩個值求和。例如，假設我們要使用Vector類表示數學向量，可以編寫下麵的代碼：

class VectorAccumulatorParam(AccumulatorParam):
    def zero(self, initialValue):
        return Vector.zeros(initialValue.size)

    def addInPlace(self, v1, v2):
        v1 += v2
        return v1

# Then, create an Accumulator of this type:
vecAccum = sc.accumulator(Vector(...), VectorAccumulatorParam())

由於累計器的修改隻能在動作(actions)內執行，Spark可以保證每個任務對累計器的修改隻會執行一次，重啟任務(tasks)也不會導致修改累計器的值。在轉換(transformations）中，如果任務重新執行，用戶需要意識到每個任務中的修改操作都會被執行多次。
累計器不會改變Spark的lazy模式。如果累計器在RDD操作中被修改了，累計器的值隻會在RDD做為動作（actions）操作進行計算時才會被修改。所以，在想map()這樣的lazy轉換中，不能保證累計器的修改被執行完成。下麵的代碼片段說明了這個特性：

accum = sc.accumulator(0)
data.map(lambda x => acc.add(x); f(x))
# Here, acc is still 0 because no actions have cause the `map` to be computed.

部署到集群

程序提交指南描述了如何將程序提交到集群。總之，一旦我們把程序打包成.py文件集或者.zip文件， bin/spark-submit腳本就可以幫助我們將程序提交到任意支持的集群管理器。

單元測試

Spark可以很方便地使用任意流行的UT框架做單元測試。在測試中簡單創建SparkContext並將master URL設置成local，執行操作，然後調用SparkContext.stop()停止Context。確保在結束時停止context或者在測試框架的的tearDown函數中停止context，因為Spark不支持兩個context在同一個程序中運行。

Spark版本遷移(pre-1.0)

Spark 1. 0凍結了Spark 1.X係列的核心API, 也就是說所有現在可用且沒有被標記為實驗性(experimenttal)的或者開發中的API未來版本中也會支持。Python中唯一變化是分組(grouping)操作, 例如groupByKey/cogroup/join, 這些操不再返回(key, list of values)，而是返回(key, iterable of values)。其他部分的遷移指南參見：Spark Streaming, MLlib and GraphX.

接下來做什麽

我們可以在Spark網站上閱讀一些Spark程序的例子。另外，Spark安裝目錄下的examples下麵包含了幾個例程，運行方法如下(Python版)：

./bin/spark-submit examples/src/main/python/pi.py

為了幫助優化我們的程序，配置和優化指南提供了最佳實踐信息。特別重要的是，要確保數據數據在內存中以高效的格式保存。為了幫助我們理解如果部署程序，集群模式總覽介紹了跟分布式操作和集群管理器相關的組件。
Finally, full API documentation is available in Scala, Java and Python.
最後，完整的API文檔參見：Python。
【轉載請注明：純淨的天空https://vimsky.com出品】