目录

• 概述
• 链接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出品】