本文翻译自官方博客,略有添加:https://github.com/mesos/spark/wiki/Spark-Programming-Guide,谢谢师允tx的校正。希望能够给希望尝试Spark的朋友,带来一些帮助。目前的版本是0.5.0
从高的层面来看,其实每一个Spark的应用,都是一个Driver类,通过运行用户定义的main函数,在集群上执行各种并发操作和计算
Spark提供的最主要的抽象,是一个弹性分布式数据集(RDD),它是一种特殊集合,可以分布在集群的节点上,以函数式编程操作集合的方式,进行各种各样的并发操作。它可以由hdfs上的一个文件创建而来,或者是Driver程序中,从一个已经存在的集合转换而来。用户可以将数据集缓存在内存中,让它被有效的重用,进行并发操作。最后,分布式数据集可以自动的从结点失败中恢复,再次进行计算。
Spark的第二个抽象,是并行计算中使用的共享变量。默认来说,当Spark并发运行一个函数时,它是以多个的task,在不同的结点上运行,它传递每一个变量的一个拷贝,到每一个独立task使用到的函数中,因此这些变量并非共享的。然而有时候,我们需要在任务中能够被共享的变量,或者在任务与驱动程序之间共享。Spark支持两种类型的共享变量:
本指南通过一些样例展示这些特征。读者最好是熟悉Scala,尤其是闭包的语法。请留意,Spark可以通过Spark-Shell的解释器进行交互式运行。你可能会需要它。
为了写一个Spark的应用,你需要将Spark和它的依赖,加入到CLASSPATH中。最简单的方法,就是运行sbt/sbt assembly来编译Spark和它的依赖,打到一个Jar里面core/target/scala_2.9.1/spark-core-assembly-0.0.0.jar,然后将它加入到你的CLASSPATH中。或者你可以选择将spark发布到maven的本地缓存中,使用sbt/sbt publish。它将在组织org.spark-project下成为一个spark-core.
另外,你会需要导入一些Spark的类和隐式转换, 将下面几行加入到你程序的顶部
> import spark.SparkContext > > import SparkContext._写Spark程序需要做的第一件事情,就是创建一个SparkContext对象,它将告诉Spark如何访问一个集群。这个通常是通过下面的构造器来实现的:
> new SparkContext(master, jobName, [sparkHome], [jars])Master参数是一个字符串,指定了连接的Mesos集群,或者用特殊的字符串“local”来指明用local模式运行。如下面的描述一般,JobName是你任务的名称,当在集群上运行的时候,将会在Mesos的Web UI监控界面显示。后面的两个参数,是用在将你的代码,部署到mesos集群上运行时使用的,后面会提到。
在Spark的解释器中,一个特殊的SparkContext变量已经为你创建,变量名字叫sc。创建你自己的SparkContext是不会生效的。你可以通过设置MASTER环境变量,来让master连接到需要的上下文。
MASTER=local; ./spark-shell
Master的名字可以是以下3个格式中的一种
Master NameMeaning local 本地化运行Spark,使用一个Worker线程(没有并行) local[K] 本地化运行Spark,使用K个Worker线程(根据机器的CPU核数设定) HOST:PORT 将Spark连接到指定的Mesos Master,在集群上运行。Host参数是Mesos Master的Hostname, 端口是master配置的端口,默认为5050. 注意:在早期的Mesos版本(spark的old-mesos分支),你必须使用master@HOST:PORT.如果有一些类库是公用的,需要在不同的作业间共享,你可能需要手工拷贝到mesos的结点上,在conf/spark-env中,通过设置SPARK_CLASSPATH环境变量指向它们。详细信息可以参考配置
Spark围绕的核心概念,是弹性分布式数据集(RDD),一个有容错机制,可以被并行操作的集合。目前有两种类型的RDD: 并行集合(Parrallelized Collections),接收一个已经存在的Scala集合,在它上面运行各种并发计算; Hadoop数据集(Hadoop DataSets),在一个文件的每条记录上,运行各种函数。只要文件系统是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支持的其它文件系统(包括本地文件,Amazon S3, Hypertable, HBase等等)上的文件。 Spark可以支持Text File, 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作业一样的方法,来设置输入源就可以了。
## 分布式数据集操作分布式数据集支持两种操作:
例如,Map是一个转换,将数据集的每一个元素,都经过一个函数进行计算后,返回一个新的分布式数据集作为结果。而另一方面,Reduce是一个动作,将数据集的所有元素,用某个函数进行聚合,然后将最终结果返回驱动程序,而并行的reduceByKey还是返回一个分布式数据集
所有Spark中的转换都是惰性的,也就是说,并不会马上发生计算。相反的,它只是记住应用到基础数据集上的这些转换(Transformation)。而这些转换(Transformation),只会在有一个动作(Action)发生,要求返回结果给驱动应用时,才真正进行计算。这个设计让Spark更加有效率的运行。例如,我们可以实现,通过map创建一个数据集,然后再用reduce,而只返回reduce的结果给driver,而不是整个大的数据集。
spark提供的一个重要转换操作是Caching。当你cache一个分布式数据集时,每个节点会存储该数据集的所有片,并在内存中计算,并在其它操作中重用。这将会使得后续的计算更加的快速(通常是10倍),缓存是spark中一个构造迭代算法的关键工具,也可以在解释器中交互使用。
下面的表格列出目前支持的转换和动作:
调用RDD的cache()方法,可以让它在第一次计算后,将结果保持存储在内存。数据集的不同部分,将会被存储在计算它的不同的集群节点上,让后续的数据集使用更快。缓存是有容错功能的,如果任一分区的RDD数据丢失了,它会被使用原来创建它的转换,再计算一次(不需要全部重新计算,只计算丢失的分区)
一般来说,当一个函数被传递给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 accum = sc.accumulator(0) > > accum: spark.Accumulator[Int] = 0 > > scala> sc.parallelize(Array(1, 2, 3, 4)).foreach(x => accum += x) > > … > > 10/09/29 18:41:08 INFO SparkContext: Tasks finished in 0.317106 s > > scala> accum.value > > res2: Int = 10 本文来源于"阿里中间件团队播客",原文发表时间" 2012-07-20 " 相关资源:敏捷开发V1.0.pptx