RDD编程指引（二）（部分翻译Spark官网文章RDD Programming Guide）

本人刚开始入门学习Spark，打算先将Spark文档看一遍，顺便做点笔记，就进行一些翻译和记录。由于本人只会python，所以翻译都是以python部分代码进行。以下并非完全100%官网翻译，更多是个人理解+笔记+部分个人认为重要的内容的翻译，新手作品，请各位大神多多指正。
官网原文链接：http://spark.apache.org/docs/latest/rdd-programming-guide.html

RDD Operations

RDD支持两种类型操作：

1、转换（transformations），重新生成一个新的数据集

2、处理动作（actions），返回一个或者一些值

转换总是惰性的，并不会立即计算，直到处理动作需要其计算结果的时候才会计算。这样使得spark的效率比较高，例如，map生成的大数据集，在经过reduce处理后，只返回一个或者一些值，而不会返回整个庞大的map后生成的大数据集。

转换在每次运行处理动作的时候都会进行重新计算，但是也可以通过persist或者cache办法，让spark将其保存在内存中以便下次需要的时候快速获取。也可以将结果保存到磁盘或者多个节点中。

Basics

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

第一行定义了从外部文件创建一个RDD.这个文件不会马上加载到内存中，lines只是data.txt的指针。第二行定义了map转换。由于转换的惰性，lineLengths不会马上计算，直到运行reduce这个处理动作，spark会将计算分割成任务在多个机器运行，每个机器运行自己负责的map和reduce任务后，将结果返回给驱动程序。

如果需要在接下来继续使用lineLengths中，可以运行

lineLengths.persist()

Passing Functions to Spark

spark重度依赖传递给驱动程序的函数，函数定义有三种推荐方式：

1、lambda表达式，适用于单行简单函数（其不支持多行函数以及无返回值函数）

2、本地def定义

3、import module

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

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

也可以创建一个类，将map放入其中一个方法中，届时将整个实例传递给集群

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

以下map对self.file的处理会影响到整个类

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

最简单的处理办法是将self.field赋值给函数变量

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

Understanding closures

明白变量的范围和生命周期是理解spark的一大挑战。RDD操作可以修改超越其范围的变量常常引起很多人理解上的困惑。

Example

counter = 0
rdd = sc.parallelize(data)

# Wrong: Don't do this!!
def increment_counter(x):
    global counter
    counter += x
rdd.foreach(increment_counter)

print("Counter value: ", counter)

上述程序可能无法得到期望的结果（将rdd数值累加）。RDD将被分割为不同任务，每个任务由不同executor执行。而任务的闭包（closure）的计算先于实际运算执行。闭包指的是一些有自己作用域的变量和方法，它们必须被executor可见，这样才能在RDD中实现运算。而闭包都是通过序列化后传送到各个executor的，所以counter被序列化传送到executor后，被executor引用的counter并非驱动节点上的那个counter，虽然驱动节点上的counter依然在内存中，但对于其他executor并不可见。executors只能看见序列化后传输来的counter，因此,counter最终值是0，因为所有对counter的操作引用的counter都是来自于序列化的闭包。

Local vs. cluster modes

在本地模式中，某些情况下如果foreach函数在同一个jvm中执行，引用的是同一个counter，那么上述函数有可能能够达到预期效果。（实际本地测试，结果依然为0）

上述场景中最好使用累加器（Accumulators）。累加器提供了一种在分布式worker工作中安全地修改变量的值的机制。

总的来说，不要尝试在闭包体例如循环或者本地作用域中对全局状态进行修改，spark无法保证能够正确修改闭包体以外的对象。即使本地模式下，某些代码能够达到预期效果，但那是属于“意外”事件，在集群模式下就行不通了。如果确实要做全局汇聚，建议采用累加器（Accumulators）来实现。

Printing elements of an RDD

本地模式可以用rdd.foreach(println) 或者 rdd.map(println)等方式来输出RDD所有元素，但在集群模式下，输出被写入到executor的stdout中，所以在驱动节点查看stdout是不会有任何输出的。可以用collect()让驱动节点收集所有executors的结果，例如
rdd.collect().foreach(println)，但这样可能会消耗较多驱动节点的内存，因为其尝试将所有executors的结果汇集到一台机器上。所以，比较安全的办法是用take收集部分结果，例如rdd.take(100).foreach(println)

Working with Key-Value Pairs

大部分的操作对RDD均可有效，但部分操作是key-pairs类型RDD专属的。最常见的是通过key来分组，聚合元素的shuffle操作。
在Python中，包含了元组的RDD可以应用上述操作。

例子是通过reduceByKey来计算文件有多少行

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

可以用 counts.sortByKey()来让元素按照字母进行排序，最后通过counts.collect()来取回到驱动节点来作为一组对象呈现。

Transformations

一些常用的转换函数：

Actions

Shuffle operations

某些在spark的操作会触发shuffle操作，shuffle是spark用来对数据进行重新排布的一种机制，因为牵涉到在executors之间拷贝数据，所以这是一种复杂和开销较大的操作。

Background

以reduceByKey为例，考虑shuffle操作的机制。reduceByKey操作将同一个key的值汇集到一个元组中并生成一个新的RDD，其操作难度在于并不是所有同一个key的元组都在同样一个分区或者同一节点上，所以必须将他们重新定位，以便可以顺利计算出最终结果。

数据一般来说并不会因为操作需要就分布在其所需要的位置。一个任务对应一个分区，为此，对于执行reduceByKey任务，spark必须从所有分区读取所有key的值，并将其汇聚到一起，计算每个key的最终结果。这就是shuffle操作。

尽管每个分区的元素在最新的shuffle操作后都会被确定下来，分区的顺序也可以被确定，但元素依然是无序的。如果需要对分区后的元素进行排序，可以用以下方法：

• 运行mapPartitions后，通过.sorted排序
• 通过repartitionAndSortWithinPartitions效率地进行重新分区时候排序
• 通过sortBy生成一个排序的RDD

导致shuffle的操作包括repartition, coalesce等重分区操作，groupByKey 和reduceByKey 等’ByKey‘类相关操作（除了count以外），cogroup和join等Join类型操作。

Performance Impact

Shuffle是一个代价高昂的操作，因为其中牵涉到disk开销，数据序列化开销，网络开销。spark通过map任务来组织数据，并通过reduce任务来汇聚结果。术语shuffle来自于MapReduce，并非直接与Spark的map和reduce操作相关。

map任务的结果会保存在内存中，直到出现内存不足的情况，就会在当前partitions进行排序后写到一个单独文件中。reduce任务则会读取相关已进行排序的blocks。

某些shuffle操作会消耗掉大量的内存，因为它们必须将数据在转换前/后都必须保留在内存中。特别是reduceByKey和aggregateByKey会在map端创建上述数据，其他ByKey操作在reduce端生成。当内存无法满足数据创建需求的时候，spark会将数据分割一部分数据到磁盘，从而增加了额外的读取开销以及垃圾回收开销。

shuffle会在磁盘生成大量的临时文件。spark1.3版本中，这些文件会保存直至RDD不再需要，然后就会被进行垃圾回收处理。如果相关计算要重新计算，这些文件不会被重复创建。垃圾回收一般会很久才进行一次。这意味着长时间运行的spark可能会占用大量磁盘空间。可以通过spark.local.dir设定临时文件目录。

shuffle可以配置一系列参数，参考配置手册可以了解更多。

RDD Persistence

Spark可以将操作过程中在内存中的产生数据集保存或者缓存下来，这样可以被再次利用，使得接下来的处理动作更快。
可以使用persist() 或者 cache()方法实现RDD的持久化。第一次计算后，结果保留在节点内存中。任何分区的RDD丢失，都会自动调用最初的转换操作重新生成该丢失的RDD。

此外，每个持久化RDD可以设置多种保存的方式，例如可以保存在磁盘中，或者以序列化java对象保存在内存中。可以通过在persist()指定存储的级别（即存储的方式）。cache()方法是使用内存保存的快速办法，也是默认的存储级别。

注意：在python，保存对象总是会通过pickle库进行序列化，支持的存储方式有MEMORY_ONLY, MEMORY_ONLY_2, MEMORY_AND_DISK, MEMORY_AND_DISK_2, DISK_ONLY, and DISK_ONLY_2.

Which Storage Level to Choose?

选择Spark的存储方式，需要衡量内存和CPU两类资源：
如果RDD在默认存储方式下工作良好，保持即可，这是CPU资源最高效的方式。

如果RDD较大内存资源紧张，可以尝试MEMORY_ONLY_SER并选用快速序列化库压缩保存的RDD所需的空间，如果行得通依然是一种较快的方式。(Java and Scala)

不要将RDD写入到磁盘中，除非处理RDD的函数对CPU资源消耗巨大，否则重新计算RDD可能并不会比从磁盘中重新读取这些RDD慢。

如果需要考虑快速故障恢复（例如用Spark处理一个web app的请求），可以使用提供冗余的存储方式。尽管所有的存储方式都可以通过重新计算来实现完整的故障恢复，但带有冗余的方式可以让服务不需要等待重新计算，保持连续。

Removing Data

spark会自动监控每个节点缓存的使用情况，并采用LRU算法自动清除旧的partitions。如果需要手动清理RDD，可以用RDD.unpersist()方法实现。

个人原创，欢迎转载