Spark随谈——开发指南（译）

最新推荐文章于 2024-07-10 17:19:01 发布

weixin_33719619

最新推荐文章于 2024-07-10 17:19:01 发布

阅读量67

点赞数

文章标签： scala java 大数据

原文链接：http://blog.51cto.com/aliapp/1325732

版权

本文翻译自官方博客，略有添加：https://github.com/mesos/spark/wiki/Spark-Programming-Guide，谢谢师允tx的校正。希望能够给希望尝试Spark的朋友，带来一些帮助。目前的版本是0.5.0

Spark开发指南

从高的层面来看，其实每一个Spark的应用，都是一个Driver类，通过运行用户定义的main函数，在集群上执行各种并发操作和计算

Spark提供的最主要的抽象，是一个弹性分布式数据集(RDD)，它是一种特殊集合，可以分布在集群的节点上，以函数式编程操作集合的方式，进行各种各样的并发操作。它可以由hdfs上的一个文件创建而来，或者是Driver程序中，从一个已经存在的集合转换而来。用户可以将数据集缓存在内存中，让它被有效的重用，进行并发操作。最后，分布式数据集可以自动的从结点失败中恢复，再次进行计算。

Spark的第二个抽象，是并行计算中使用的共享变量。默认来说，当Spark并发运行一个函数时，它是以多个的task，在不同的结点上运行，它传递每一个变量的一个拷贝，到每一个独立task使用到的函数中，因此这些变量并非共享的。然而有时候，我们需要在任务中能够被共享的变量，或者在任务与驱动程序之间共享。Spark支持两种类型的共享变量：

广播变量：可以在内存的所有结点中被访问，用于缓存变量（只读）

累加器：只能用来做加法的变量，例如计数和求和

本指南通过一些样例展示这些特征。读者最好是熟悉Scala，尤其是闭包的语法。请留意，Spark可以通过Spark-Shell的解释器进行交互式运行。你可能会需要它。

接入Spark

为了写一个Spark的应用，你需要将Spark和它的依赖，加入到CLASSPATH中。最简单的方法，就是运行sbt/sbtassembly来编译Spark和它的依赖，打到一个Jar里面core/target/scala_2.9.1/spark-core-assembly-0.0.0.jar，然后将它加入到你的CLASSPATH中。或者你可以选择将spark发布到maven的本地缓存中，使用sbt/sbtpublish。它将在组织org.spark-project下成为一个spark-core.

另外，你会需要导入一些Spark的类和隐式转换，将下面几行加入到你程序的顶部

“
import spark.SparkContext
import SparkContext._

初始化Spark

写Spark程序需要做的第一件事情，就是创建一个SparkContext对象，它将告诉Spark如何访问一个集群。这个通常是通过下面的构造器来实现的：

“
new SparkContext(master, jobName, [sparkHome], [jars])

Master参数是一个字符串，指定了连接的Mesos集群，或者用特殊的字符串“local”来指明用local模式运行。如下面的描述一般，JobName是你任务的名称，当在集群上运行的时候，将会在Mesos的WebUI监控界面显示。后面的两个参数，是用在将你的代码，部署到mesos集群上运行时使用的，后面会提到。

在Spark的解释器中，一个特殊的SparkContext变量已经为你创建，变量名字叫sc。创建你自己的SparkContext是不会生效的。你可以通过设置MASTER环境变量，来让master连接到需要的上下文。

MASTER=local; ./spark-shell

Master的命名

Master的名字可以是以下3个格式中的一种

MasterName	Meaning
local	本地化运行Spark，使用一个Worker线程（没有并行）
local[K]	本地化运行Spark，使用K个Worker线程（根据机器的CPU核数设定）
HOST:PORT	将Spark连接到指定的MesosMaster，在集群上运行。Host参数是MesosMaster的Hostname，端口是master配置的端口，默认为5050. 注意：在早期的Mesos版本（spark的old-mesos分支），你必须使用master@HOST:PORT.

集群部署

如果你想你的任务运行在一个集群上，你需要指定2个可选参数：

SparkHome：Spark在集群机器上的安装路径（必须全部一致）
Jars：在本地机器上，包含了你任务的代码和依赖的Jars文件列表。Spark会把它们部署到所有的集群结点上。你需要使用自己的编译系统将你的作业，打包成一套jars文件。例如，如果你使用sbt，那么sbt-assembly插件是一个好方法，将你的代码和依赖，变成一个单一的jar文件。

如果有一些类库是公用的，需要在不同的作业间共享，你可能需要手工拷贝到mesos的结点上，在conf/spark-env中，通过设置SPARK_CLASSPATH环境变量指向它们。详细信息可以参考配置

分布式数据集

Spark围绕的核心概念，是弹性分布式数据集（RDD），一个有容错机制，可以被并行操作的集合。目前有两种类型的RDD：并行集合(ParrallelizedCollections)，接收一个已经存在的Scala集合，在它上面运行各种并发计算；Hadoop数据集（HadoopDataSets），在一个文件的每条记录上，运行各种函数。只要文件系统是Hdfs，或者hadoop支持的任意存储系统。这两种RDD都可以通过相同的方式进行操作。

并行集合

并行集合是通过调用SparkContext的parallelize方法，在一个已经存在的Scala集合（只要是seq对象就可以）上创建而来。集合的对象将会被拷贝来创建一个分布式数据集，可以被并行操作。下面通过spark解释器的例子，展示如何从一个数组创建一个并发集合

“
scala> val data = Array(1, 2, 3, 4, 5)
data: Array[Int] = Array(1, 2, 3, 4, 5)
scala> val distData = sc.parallelize(data)
distData: spark.RDD[Int] = spark.ParallelCollection@10d13e3e

一旦被创建，分布数据集（distData）可以被并行操作。例如，我们可以调用distData.reduce(_+＿)来将数组的元素相加。我们会在后续的分布式数据集做进一步描述。

创建并行集合的一个重要参数，是slices的数目，它指定了将数据集切分为几份。在集群模式中，Spark将会在一份slice上起一个Task。典型的，你可以在集群中的每个cpu上，起2-4个Slice（也就是每个cpu分配2-4个Task）。一般来说，Spark会尝试根据集群的状况，来自动设定slices的数目。然而，你也可以手动的设置它，通过parallelize方法的第二个参数（例如：sc.parallelize(data,10)).

Hadoop数据集

Spark可以创建分布式数据集，从任何存储在HDFS文件系统或者Hadoop支持的其它文件系统（包括本地文件，AmazonS3，Hypertable，HBase等等）上的文件。Spark可以支持TextFile,SequenceFiles及其它任何Hadoop输入格式

文本文件的RDDs可以通过SparkContext的textFile方法创建，该方法接受文件的URI地址（或者机器上的文件本地路径，或者一个hdfs://,sdn://,kfs://,其它URI).这里是一个调用例子：

“
scala> val distFile = sc.textFile(“data.txt”)
distFile: spark.RDD[String] = spark.HadoopRDD@1d4cee08

一旦被创建，distFile可以进行数据集操作。例如，我们可以使用如下的map和reduce操作将所有行数的长度相加：

“
distFile.map(_.size).reduce(_ + _ )

方法也接受可选的第二参数，来控制文件的分片数目。默认来说，Spark为每一块文件创建一个分片（HDFS默认的块大小为64MB)，但是你可以通过传入一个更大的值来指定更多的分片。注意，你不能指定一个比块个数更少的片值（和hadoop中，Map数不能小于Block数一样）

对于SequenceFiles，使用SparkContext的sequenceFile[K,V]方法，K和V是文件中的key和values类型。他们必须是Hadoop的Writable的子类，例如IntWritable和Text。另外，Spark允许你指定几种原生的通用Writable类型，例如：sequencFile[Int,String]会自动读取IntWritable和Texts

最后，对于其他类型的Hadoop输入格式，你可以使用SparkContext.hadoopRDD方法，它可以接收任意类型的JobConf和输入格式类，键类型和值类型。按照对Hadoop作业一样的方法，来设置输入源就可以了。

分布式数据集操作

分布式数据集支持两种操作：

转换（transformation）:根据现有的数据集创建一个新的数据集

动作（actions）:在数据集上运行计算后，返回一个值给驱动程序

例如，Map是一个转换，将数据集的每一个元素，都经过一个函数进行计算后，返回一个新的分布式数据集作为结果。而另一方面，Reduce是一个动作，将数据集的所有元素，用某个函数进行聚合，然后将最终结果返回驱动程序，而并行的reduceByKey还是返回一个分布式数据集

所有Spark中的转换都是惰性的，也就是说，并不会马上发生计算。相反的，它只是记住应用到基础数据集上的这些转换（Transformation）。而这些转换（Transformation），只会在有一个动作（Action）发生，要求返回结果给驱动应用时，才真正进行计算。这个设计让Spark更加有效率的运行。例如，我们可以实现，通过map创建一个数据集，然后再用reduce，而只返回reduce的结果给driver，而不是整个大的数据集。

spark提供的一个重要转换操作是Caching。当你cache一个分布式数据集时，每个节点会存储该数据集的所有片，并在内存中计算，并在其它操作中重用。这将会使得后续的计算更加的快速（通常是10倍），缓存是spark中一个构造迭代算法的关键工具，也可以在解释器中交互使用。

下面的表格列出目前支持的转换和动作：

转换（Transformations）

Transformation	Meaning
map(func)	返回一个新的分布式数据集，由每个原元素经过func函数转换后组成
filter(func)	返回一个新的数据集，由经过func函数后返回值为true的原元素组成
flatMap(func)	类似于map，但是每一个输入元素，会被映射为0到多个输出元素（因此，func函数的返回值是一个Seq，而不是单一元素）
sample(withReplacement,frac,seed)	根据给定的随机种子seed，随机抽样出数量为frac的数据
union(otherDataset)	返回一个新的数据集，由原数据集和参数联合而成
groupByKey([numTasks])	在一个由（K,V）对组成的数据集上调用，返回一个（K，Seq[V])对的数据集。注意：默认情况下，使用8个并行任务进行分组，你可以传入numTask可选参数，根据数据量设置不同数目的Task （groupByKey和filter结合，可以实现类似Hadoop中的Reduce功能）
reduceByKey(func,[numTasks])	在一个（K，V)对的数据集上使用，返回一个（K，V）对的数据集，key相同的值，都被使用指定的reduce函数聚合到一起。和groupbykey类似，任务的个数是可以通过第二个可选参数来配置的。
join(otherDataset,[numTasks])	在类型为（K,V)和（K,W)类型的数据集上调用，返回一个（K,(V,W))对，每个key中的所有元素都在一起的数据集
groupWith(otherDataset,[numTasks])	在类型为（K,V)和(K,W)类型的数据集上调用，返回一个数据集，组成元素为（K,Seq[V],Seq[W])Tuples。这个操作在其它框架，称为CoGroup
cartesian(otherDataset)	笛卡尔积。但在数据集T和U上调用时，返回一个(T，U）对的数据集，所有元素交互进行笛卡尔积。
sortByKey([ascendingOrder])	在类型为(K,V)的数据集上调用，返回以K为键进行排序的（K，V）对数据集。升序或者降序由boolean型的ascendingOrder参数决定（类似于Hadoop的Map-Reduce中间阶段的Sort，按Key进行排序）

Actions（动作）

Action	Meaning
reduce(func)	通过函数func聚集数据集中的所有元素。Func函数接受2个参数，返回一个值。这个函数必须是关联性的，确保可以被正确的并发执行
collect()	在Driver的程序中，以数组的形式，返回数据集的所有元素。这通常会在使用filter或者其它操作后，返回一个足够小的数据子集再使用，直接将整个RDD集Collect返回，很可能会让Driver程序OOM
count()	返回数据集的元素个数
take(n)	返回一个数组，由数据集的前n个元素组成。注意，这个操作目前并非在多个节点上，并行执行，而是Driver程序所在机器，单机计算所有的元素 (Gateway的内存压力会增大，需要谨慎使用）
first()	返回数据集的第一个元素（类似于take（1））
saveAsTextFile(path)	将数据集的元素，以textfile的形式，保存到本地文件系统，hdfs或者任何其它hadoop支持的文件系统。Spark将会调用每个元素的toString方法，并将它转换为文件中的一行文本
saveAsSequenceFile(path)	将数据集的元素，以sequencefile的格式，保存到指定的目录下，本地系统，hdfs或者任何其它hadoop支持的文件系统。RDD的元素必须由key-value对组成，并都实现了Hadoop的Writable接口，或隐式可以转换为Writable（Spark包括了基本类型的转换，例如Int，Double，String等等）
foreach(func)	在数据集的每一个元素上，运行函数func。这通常用于更新一个累加器变量，或者和外部存储系统做交互

缓存

调用RDD的cache()方法，可以让它在第一次计算后，将结果保持存储在内存。数据集的不同部分，将会被存储在计算它的不同的集群节点上，让后续的数据集使用更快。缓存是有容错功能的，如果任一分区的RDD数据丢失了，它会被使用原来创建它的转换，再计算一次（不需要全部重新计算，只计算丢失的分区）

SharedVariables

共享变量

一般来说，当一个函数被传递给Spark操作（例如map和reduce），通常是在集群结点上运行，在函数中使用到的所有变量，都做分别拷贝，供函数操作，而不会互相影响。这些变量会被拷贝到每一台机器，而在远程机器上，在对变量的所有更新，都不会被传播回Driver程序。然而，Spark提供两种有限的共享变量，供两种公用的使用模式：广播变量和累加器

广播变量

广播变量允许程序员保留一个只读的变量，缓存在每一台机器上，而非每个任务保存一份拷贝。他们可以使用，例如，给每个结点一个大的输入数据集，以一种高效的方式。Spark也会尝试，使用一种高效的广播算法，来减少沟通的损耗。

广播变量是从变量V创建的，通过调用SparkContext.broadcast(v)方法。这个广播变量是一个v的分装器，它的只可以通过调用value方法获得。如下的解释器模块展示了如何应用：

“
scala> val broadcastVar = sc.broadcast(Array(1, 2, 3))
broadcastVar: spark.Broadcast[Array[Int]] = spark.Broadcast(b5c40191-a864-4c7d-b9bf-d87e1a4e787c)
scala> broadcastVar.value
res0: Array[Int] = Array(1, 2, 3)

在广播变量被创建后，它能在集群运行的任何函数上，被取代v值进行调用，从而v值不需要被再次传递到这些结点上。另外，对象v不能在被广播后修改，是只读的，从而保证所有结点的变量，收到的都是一模一样的。

累加器

累加器是只能通过组合操作“加”起来的变量，可以高效的被并行支持。他们可以用来实现计数器（如同MapReduce中）和求和。Spark原生就支持Int和Double类型的计数器，程序员可以添加新的类型。

一个计数器，可以通过调用SparkContext.accumulator(V)方法来创建。运行在集群上的任务，可以使用+=来加值。然而，它们不能读取计数器的值。当Driver程序需要读取值的时候，它可以使用.value方法。

如下的解释器，展示了如何利用累加器，将一个数组里面的所有元素相加

“
scala> val broadcastVar = sc.broadcast(Array(1, 2, 3))
broadcastVar: spark.Broadcast[Array[Int]] = spark.Broadcast(b5c40191-a864-4c7d-b9bf-d87e1a4e787c)
scala> broadcastVar.value
res0: Array[Int] = Array(1, 2, 3)