1.4 弹性分布式数据集

Spark大数据分析实战

1.4 弹性分布式数据集
本节将介绍弹性分布式数据集RDD。Spark是一个分布式计算框架,而RDD是其对分布式内存数据的抽象,可以认为RDD就是Spark分布式算法的数据结构,而RDD之上的操作是Spark分布式算法的核心原语,由数据结构和原语设计上层算法。Spark最终会将算法(RDD上的一连串操作)翻译为DAG形式的工作流进行调度,并进行分布式任务的分发。

1.4.1 RDD简介
在集群背后,有一个非常重要的分布式数据架构,即弹性分布式数据集(Resilient Distributed Dataset,RDD)。它在集群中的多台机器上进行了数据分区,逻辑上可以认为是一个分布式的数组,而数组中每个记录可以是用户自定义的任意数据结构。RDD是Spark的核心数据结构,通过RDD的依赖关系形成Spark的调度顺序,通过对RDD的操作形成整个Spark程序。
(1)RDD创建方式
1)从Hadoop文件系统(或与Hadoop兼容的其他持久化存储系统,如Hive、Cassandra、HBase)输入(例如HDFS)创建。
2)从父RDD转换得到新RDD。
3)通过parallelize或makeRDD将单机数据创建为分布式RDD。
(2)RDD的两种操作算子
对于RDD可以有两种操作算子:转换(Transformation)与行动(Action)。
1)转换(Transformation):Transformation操作是延迟计算的,也就是说从一个RDD转换生成另一个RDD的转换操作不是马上执行,需要等到有Action操作的时候才会真正触发运算。
2)行动(Action):Action算子会触发Spark提交作业(Job),并将数据输出Spark系统。
(3)RDD的重要内部属性
通过RDD的内部属性,用户可以获取相应的元数据信息。通过这些信息可以支持更复杂的算法或优化。
1)分区列表:通过分区列表可以找到一个RDD中包含的所有分区及其所在地址。
2)计算每个分片的函数:通过函数可以对每个数据块进行RDD需要进行的用户自定义函数运算。
3)对父RDD的依赖列表:为了能够回溯到父RDD,为容错等提供支持。
4)对key-value pair数据类型RDD的分区器,控制分区策略和分区数。通过分区函数可以确定数据记录在各个分区和节点上的分配,减少分布不平衡。
5)每个数据分区的地址列表(如HDFS上的数据块的地址)。
如果数据有副本,则通过地址列表可以获知单个数据块的所有副本地址,为负载均衡和容错提供支持。
(4)Spark计算工作流
图1-5中描述了Spark的输入、运行转换、输出。在运行转换中通过算子对RDD进行转换。算子是RDD中定义的函数,可以对RDD中的数据进行转换和操作。
·输入:在Spark程序运行中,数据从外部数据空间(例如,HDFS、Scala集合或数据)输入到Spark,数据就进入了Spark运行时数据空间,会转化为Spark中的数据块,通过BlockManager进行管理。
·运行:在Spark数据输入形成RDD后,便可以通过变换算子fliter等,对数据操作并将RDD转化为新的RDD,通过行动(Action)算子,触发Spark提交作业。如果数据需要复用,可以通过Cache算子,将数据缓存到内存。
·输出:程序运行结束数据会输出Spark运行时空间,存储到分布式存储中(如saveAsTextFile输出到HDFS)或Scala数据或集合中(collect输出到Scala集合,count返回Scala Int型数据)。
[插图]
图1-5 Spark算子和数据空间
Spark的核心数据模型是RDD,但RDD是个抽象类,具体由各子类实现,如MappedRDD、ShuffledRDD等子类。Spark将常用的大数据操作都转化成为RDD的子类。

1.4.2 RDD算子分类
本节将主要介绍Spark算子的作用,以及算子的分类。
Spark算子大致可以分为以下两类。
1)Transformation变换算子:这种变换并不触发提交作业,完成作业中间过程处理。
2)Action行动算子:这类算子会触发SparkContext提交Job作业。
下面分别对两类算子进行详细介绍。
1.Transformations算子
下文将介绍常用和较为重要的Transformation算子。
(1)map
将原来RDD的每个数据项通过map中的用户自定义函数f映射转变为一个新的元素。源码中map算子相当于初始化一个RDD,新RDD叫做MappedRDD(this,sc.clean(f))。
图1-7中每个方框表示一个RDD分区,左侧的分区经过用户自定义函数f:T->U映射为右侧的新RDD分区。但是,实际只有等到Action算子触发后这个f函数才会和其他函数在一个stage中对数据进行运算。在图1-6中的第一个分区,数据记录V1输入f,通过f转换输出为转换后的分区中的数据记录V'1。
(2)flatMap
将原来RDD中的每个元素通过函数f转换为新的元素,并将生成的RDD的每个集合中的元素合并为一个集合,内部创建FlatMappedRDD(this,sc.clean(f))。
[插图]
图1-6 map算子对RDD转换
图1-7表示RDD的一个分区进行flatMap函数操作,flatMap中传入的函数为f:T->U,T和U可以是任意的数据类型。将分区中的数据通过用户自定义函数f转换为新的数据。外部大方框可以认为是一个RDD分区,小方框代表一个集合。V1、V2、V3在一个集合作为RDD的一个数据项,可能存储为数组或其他容器,转换为V'1、V'2、V'3后,将原来的数组或容器结合拆散,拆散的数据形成为RDD中的数据项。
[插图]
图1-7 flapMap算子对RDD转换
(3)mapPartitions
mapPartitions函数获取到每个分区的迭代器,在函数中通过这个分区整体的迭代器对整个分区的元素进行操作。内部实现是生成MapPartitionsRDD。图1-8中的方框代表一个RDD分区。
图1-8中,用户通过函数f(iter)=>iter.filter(_>=3)对分区中所有数据进行过滤,大于和等于3的数据保留。一个方块代表一个RDD分区,含有1、2、3的分区过滤只剩下元素3。
[插图]
图1-8 mapPartitions算子对RDD转换
(4)union
使用union函数时需要保证两个RDD元素的数据类型相同,返回的RDD数据类型和被合并的RDD元素数据类型相同。并不进行去重操作,保存所有元素,如果想去重可以使用distinct()。同时Spark还提供更为简洁的使用union的API,通过++符号相当于union函数操作。
图1-9中左侧大方框代表两个RDD,大方框内的小方框代表RDD的分区。右侧大方框代表合并后的RDD,大方框内的小方框代表分区。合并后,V1、V2、V3……V8形成一个分区,其他元素同理进行合并。
(5)cartesian
对两个RDD内的所有元素进行笛卡尔积操作。操作后,内部实现返回CartesianRDD。图1-10中左侧大方框代表两个RDD,大方框内的小方框代表RDD的分区。右侧大方框代表合并后的RDD,大方框内的小方框代表分区。
例如:V1和另一个RDD中的W1、W2、Q5进行笛卡尔积运算形成(V1,W1)、(V1,W2)、(V1,Q5)。
[插图]
图1-9 union算子对RDD转换
[插图]
图1-10 cartesian算子对RDD转换
(6)groupBy
groupBy:将元素通过函数生成相应的Key,数据就转化为Key-Value格式,之后将Key相同的元素分为一组。
函数实现如下:
1)将用户函数预处理:

val cleanF = sc.clean(f)

2)对数据map进行函数操作,最后再进行groupByKey分组操作。

this.map(t =>(cleanF(t), t)).groupByKey(p)

其中,p确定了分区个数和分区函数,也就决定了并行化的程度。
图1-11中方框代表一个RDD分区,相同key的元素合并到一个组。例如V1和V2合并为V,Value为V1,V2。形成V,Seq(V1,V2)。
[插图]
图1-11 groupBy算子对RDD转换
(7)filter
filter函数功能是对元素进行过滤,对每个元素应用f函数,返回值为true的元素在RDD中保留,返回值为false的元素将被过滤掉。内部实现相当于生成FilteredRDD(this,sc.clean(f))。
下面代码为函数的本质实现:

deffilter(f:T=>Boolean):RDD[T]=newFilteredRDD(this,sc.clean(f))

图1-12中每个方框代表一个RDD分区,T可以是任意的类型。通过用户自定义的过滤函数f,对每个数据项操作,将满足条件、返回结果为true的数据项保留。例如,过滤掉V2和V3保留了V1,为区分命名为V'1。
(8)sample
sample将RDD这个集合内的元素进行采样,获取所有元素的子集。用户可以设定是否有放回的抽样、百分比、随机种子,进而决定采样方式。
内部实现是生成SampledRDD(withReplacement,fraction,seed)。
函数参数设置:
·withReplacement=true,表示有放回的抽样。
·withReplacement=false,表示无放回的抽样。
图1-13中的每个方框是一个RDD分区。通过sample函数,采样50%的数据。V1、V2、U1、U2……U4采样出数据V1和U1、U2形成新的RDD。
[插图]
图1-12 filter算子对RDD转换
[插图]
图1-13 sample算子对RDD转换
(9)cache
cache将RDD元素从磁盘缓存到内存。相当于persist(MEMORY_ONLY)函数的功能。
[插图]
图1-14 Cache算子对RDD转换
图1-14中每个方框代表一个RDD分区,左侧相当于数据分区都存储在磁盘,通过cache算子将数据缓存在内存。
(10)persist
persist函数对RDD进行缓存操作。数据缓存在哪里依据StorageLevel这个枚举类型进行确定。有以下几种类型的组合(见图1-14),DISK代表磁盘,MEMORY代表内存,SER代表数据是否进行序列化存储。
下面为函数定义,StorageLevel是枚举类型,代表存储模式,用户可以通过图1-14按需进行选择。

persist(newLevel:StorageLevel)

图1-15中列出persist函数可以进行缓存的模式。例如,MEMORY_AND_DISK_SER代表数据可以存储在内存和磁盘,并且以序列化的方式存储,其他同理。
[插图]
图1-15 persist算子对RDD转换
图1-16中方框代表RDD分区。disk代表存储在磁盘,mem代表存储在内存。数据最初全部存储在磁盘,通过persist(MEMORY_AND_DISK)将数据缓存到内存,但是有的分区无法容纳在内存,将含有V1、V2、V3的分区存储到磁盘。
(11)mapValues
mapValues:针对(Key,Value)型数据中的Value进行Map操作,而不对Key进行处理。
图1-17中的方框代表RDD分区。a=>a+2代表对(V1,1)这样的Key Value数据对,数据只对Value中的1进行加2操作,返回结果为3。
[插图]
图1-16 Persist算子对RDD转换
[插图]
图1-17 mapValues算子RDD对转换
(12)combineByKey
下面代码为combineByKey函数的定义:

combineByKey[C](createCombiner:(V)C,
mergeValue:(C, V)C,
mergeCombiners:(C, C)C,
partitioner:Partitioner,
mapSideCombine:Boolean=true,
serializer:Serializer=null):RDD[(K,C)]

说明:
·createCombiner:V=>C,C不存在的情况下,比如通过V创建seq C。
·mergeValue:(C,V)=>C,当C已经存在的情况下,需要merge,比如把item V加到seq C中,或者叠加。
·mergeCombiners:(C,C)=>C,合并两个C。
·partitioner:Partitioner,Shuffle时需要的Partitioner。
·mapSideCombine:Boolean=true,为了减小传输量,很多combine可以在map端先做,比如叠加,可以先在一个partition中把所有相同的key的value叠加,再shuffle。
·serializerClass:String=null,传输需要序列化,用户可以自定义序列化类:
例如,相当于将元素为(Int,Int)的RDD转变为了(Int,Seq[Int])类型元素的RDD。
图1-18中的方框代表RDD分区。如图,通过combineByKey,将(V1,2),(V1,1)数据合并为(V1,Seq(2,1))。
(13)reduceByKey
reduceByKey是比combineByKey更简单的一种情况,只是两个值合并成一个值,(Int,Int V)to(Int,Int C),比如叠加。所以createCombiner reduceBykey很简单,就是直接返回v,而mergeValue和mergeCombiners逻辑是相同的,没有区别。
[插图]
图1-18 comBineByKey算子对RDD转换
函数实现:

def reduceByKey(partitioner: Partitioner, func: (V, V) => V): RDD[(K, V)] = {
combineByKey[V]((v: V) => v, func, func, partitioner)
}

图1-19中的方框代表RDD分区。通过用户自定义函数(A,B)=>(A+B)函数,将相同key的数据(V1,2)和(V1,1)的value相加运算,结果为(V1,3)。
[插图]
图1-19 reduceByKey算子对RDD转换

(14)join
join对两个需要连接的RDD进行cogroup函数操作,将相同key的数据能够放到一个分区,在cogroup操作之后形成的新RDD对每个key下的元素进行笛卡尔积的操作,返回的结果再展平,对应key下的所有元组形成一个集合。最后返回RDD[(K,(V,W))]。
下面代码为join的函数实现,本质是通过cogroup算子先进行协同划分,再通过flatMapValues将合并的数据打散。

this.cogroup(other,partitioner).f?latMapValues{case(vs,ws)=>
for(v<-vs;w>-ws)yield(v,w) }

图1-20是对两个RDD的join操作示意图。大方框代表RDD,小方框代表RDD中的分区。函数对相同key的元素,如V1为key做连接后结果为(V1,(1,1))和(V1,(1,2))。
2.Actions算子
本质上在Action算子中通过SparkContext进行了提交作业的runJob操作,触发了RDD DAG的执行。
[插图]
图1-20 join算子对RDD转换
例如,Action算子collect函数的代码如下,感兴趣的读者可以顺着这个入口进行源码剖析:

  • /**
    • Return an array that contains all of the elements in this RDD.
      /
      def collect(): Array[T] = {
      /
      提交Job/
      val results = sc.runJob(this, (iter: Iterator[T]) => iter.toArray)
      Array.concat(results: _
      )
      }

下面将介绍常用和较为重要的Action算子。
(1)foreach
foreach对RDD中的每个元素都应用f函数操作,不返回RDD和Array,而是返回Uint。
图1-21表示foreach算子通过用户自定义函数对每个数据项进行操作。本例中自定义函数为println(),控制台打印所有数据项。
[插图]
图1-21 foreach算子对RDD转换
(2)saveAsTextFile
函数将数据输出,存储到HDFS的指定目录。
下面为saveAsTextFile函数的内部实现,其内部通过调用saveAsHadoopFile进行实现:

this.map(x => (NullWritable.get(), new Text(x.toString)))
.saveAsHadoopFileTextOutputFormat[NullWritable, Text]

将RDD中的每个元素映射转变为(null,x.toString),然后再将其写入HDFS。
图1-22中左侧方框代表RDD分区,右侧方框代表HDFS的Block。通过函数将RDD的每个分区存储为HDFS中的一个Block。
(3)collect
collect相当于toArray,toArray已经过时不推荐使用,collect将分布式的RDD返回为一个单机的scala Array数组。在这个数组上运用scala的函数式操作。
图1-23中左侧方框代表RDD分区,右侧方框代表单机内存中的数组。通过函数操作,将结果返回到Driver程序所在的节点,以数组形式存储。

图1-23中左侧方框代表RDD分区,右侧方框代表单机内存中的数组。通过函数操作,将结果返回到Driver程序所在的节点,以数组形式存储。
[插图]
图1-22 saveAsHadoopFile算子对RDD转换
[插图]
图1-23 Collect算子对RDD转换
(4)count
count返回整个RDD的元素个数。
内部函数实现为:

defcount():Long=sc.runJob(this,Utils.getIteratorSize_).sum

图1-24中,返回数据的个数为5。一个方块代表一个RDD分区。
[插图]
图1-24 count对RDD算子转换

1.5 本章小结
本章首先介绍了Spark分布式计算平台的基本概念、原理以及Spark生态系统BDAS之上的典型组件。Spark为用户提供了系统底层细节透明、编程接口简洁的分布式计算平台。Spark具有内存计算、实时性高、容错性好等突出特点。同时本章介绍了Spark的计算模型,Spark会将应用程序整体翻译为一个有向无环图进行调度和执行。相比MapReduce,Spark提供了更加优化和复杂的执行流。读者还可以深入了解Spark的运行机制与Spark算子,这样能更加直观地了解API的使用。Spark提供了更加丰富的函数式算子,这样就为Spark上层组件的开发奠定了坚实的基础。
相信读者已经想了解如何开发Spark程序,接下来将就Spark的开发环境配置进行阐述。

你可能感兴趣的:(1.4 弹性分布式数据集)