Spark编程基础2设计与运行原理、环境搭建和使用方法

第3章 Spark的设计与运行原理

3.1 Spark概述

3.1.1 Spark简介

Spark如今已吸引了国内外各大公司的注意，如腾讯、淘宝、百度、亚马逊等公司均不同程度地使用了Spark来构建大数据分析应用，并应用到实际的生产环境中。

3.1.2 Scala简介

Scala是一门现代的多范式编程语言，运行于Java平台（JVM，Java 虚拟机），并兼容现有的Java程序
Scala的特性：
1Scala具备强大的并发性，支持函数式编程，可以更好地支持分布式系统
2Scala语法简洁，能提供优雅的API
3Scala兼容Java，运行速度快，且能融合到Hadoop生态圈中

Scala是Spark的主要编程语言，但Spark还支持Java、Python、R作为编程语言
Scala的优势是提供了REPL（Read-Eval-Print Loop，交互式解释器），提高程序开发效率

3.1.3 Spark与Hadoop的比较

Hadoop存在如下一些缺点：
1表达能力有限
2磁盘IO开销大
3延迟高
任务之间的衔接涉及IO开销
在前一个任务执行完成之前，其他任务就无法开始，难以胜任复杂、多阶段的计算任务

Spark在借鉴Hadoop MapReduce优点的同时，很好地解决了MapReduce所面临的问题
相比于Hadoop MapReduce，Spark主要具有如下优点：
1Spark的计算模式也属于MapReduce，但不局限于Map和Reduce操作，还提供了多种数据集操作类型，编程模型比Hadoop MapReduce更灵活
2Spark提供了内存计算，可将中间结果放到内存中，对于迭代运算效率更高
3Spark基于DAG的任务调度执行机制，要优于Hadoop MapReduce的迭代执行机制

使用Hadoop进行迭代计算非常耗资源
Spark将数据载入内存后，之后的迭代计算都可以直接使用内存中的中间结果作运算，避免了从磁盘中频繁读取数据

3.2 Spark生态系统

在实际应用中，大数据处理主要包括以下三个类型：
1复杂的批量数据处理：通常时间跨度在数十分钟到数小时之间
2基于历史数据的交互式查询：通常时间跨度在数十秒到数分钟之间
3基于实时数据流的数据处理：通常时间跨度在数百毫秒到数秒之间

当同时存在以上三种场景时，就需要同时部署三种不同的软件
比如: MapReduce / Impala / Storm
这样做难免会带来一些问题：
1不同场景之间输入输出数据无法做到无缝共享，通常需要进行数据格式的转换
2不同的软件需要不同的开发和维护团队，带来了较高的使用成本
3比较难以对同一个集群中的各个系统进行统一的资源协调和分配

Spark的设计遵循“一个软件栈满足不同应用场景”的理念，逐渐形成了一套完整的生态系统
1既能够提供内存计算框架，也可以支持SQL即席查询、实时流式计算、机器学习和图计算等
2Spark可以部署在资源管理器YARN之上，提供一站式的大数据解决方案
3因此，Spark所提供的生态系统足以应对上述三种场景，即同时支持批处理、交互式查询和流数据处理

Spark生态系统已经成为伯克利数据分析软件栈BDAS（Berkeley Data Analytics Stack）的重要组成部分
Spark的生态系统主要包含了Spark Core、Spark SQL、Spark Streaming、MLLib和GraphX 等组件

3.3 Spark运行架构

3.3.1 基本概念

RDD：是Resillient Distributed Dataset（弹性分布式数据集）的简称，是分布式内存的一个抽象概念，提供了一种高度受限的共享内存模型
DAG：是Directed Acyclic Graph（有向无环图）的简称，反映RDD之间的依赖关系
Executor：是运行在工作节点（WorkerNode）的一个进程，负责运行Task
Application：用户编写的Spark应用程序
Task：运行在Executor上的工作单元
Job：一个Job包含多个RDD及作用于相应RDD上的各种操作
Stage：是Job的基本调度单位，一个Job会分为多组Task，每组Task被称为Stage，或者也被称为TaskSet，代表了一组关联的、相互之间没有Shuffle依赖关系的任务组成的任务集

Spark运行架构包括集群资源管理器（Cluster Manager）、运行作业任务的工作节点（Worker Node）、每个应用的任务控制节点（Driver）和每个工作节点上负责具体任务的执行进程（Executor）
资源管理器可以自带或Mesos或YARN

Driver Program整个的任务控制节点，会通过Cluster Manager集群资源管理器完成整个资源的调度管理，会把不同的任务分到不同的Worker Node工作节点上去执行，每个工作节点上都回去启动一个Executer进程，这个进程又会启动很多线程，每个线程去执行一个Task任务。

与Hadoop MapReduce计算框架相比，Spark所采用的Executor有两个优点：
一是利用多线程来执行具体的任务，减少任务的启动开销
二是Executor中有一个BlockManager存储模块，会将内存和磁盘共同作为存储设备，有效减少IO开销

3.3.2 架构设计

一个Application由一个Driver和若干个Job构成，一个Job由多个Stage构成，一个Stage由多个没有Shuffle关系的Task组成
当执行一个Application时，Driver会向集群管理器申请资源，启动Executor，并向Executor发送应用程序代码和文件，然后在Executor上执行Task，运行结束后，执行结果会返回给Driver，或者写到HDFS或者其他数据库中

3.3.3 Spark运行基本流程

（1）首先为应用构建起基本的运行环境，即由Driver创建一个SparkContext，进行资源的申请、任务的分配和监控
SparkContext对象代表了和一个集群的连接
（2）资源管理器为Executor分配资源，并启动Executor进程
（3）SparkContext根据RDD的依赖关系构建DAG图，DAG图提交给DAGScheduler解析成Stage，然后把一个个TaskSet提交给底层调度器TaskScheduler处理；Executor向SparkContext申请Task，Task Scheduler将Task发放给Executor运行，并提供应用程序代码
计算向数据靠拢
（4）Task在Executor上运行，把执行结果反馈给TaskScheduler，然后反馈给DAGScheduler，运行完毕后写入数据并释放所有资源

总体而言，Spark运行架构具有以下特点：
（1）每个Application都有自己专属的Executor进程，并且该进程在Application运行期间一直驻留。Executor进程以多线程的方式运行Task
（2）Spark运行过程与资源管理器无关，只要能够获取Executor进程并保持通信即可
（3）Task采用了数据本地性和推测执行等优化机制

3.3.4 RDD的设计与运行原理

1.RDD设计背景

许多迭代式算法（比如机器学习、图算法等）和交互式数据挖掘工具，共同之处是，不同计算阶段之间会重用中间结果
1目前的MapReduce框架都是把中间结果写入到HDFS中，带来了大量的数据复制、磁盘IO和序列化开销
2RDD就是为了满足这种需求而出现的，它提供了一个抽象的数据架构，我们不必担心底层数据的分布式特性，只需将具体的应用逻辑表达为一系列转换处理，不同RDD之间的转换操作形成依赖关系，可以实现管道化，避免中间数据存储

2.RDD概念

一个RDD就是一个分布式对象集合，本质上是一个只读的分区记录集合（生成后就不可改变，只能从转换过程中更改），每个RDD可分成多个分区，每个分区就是一个数据集片段，并且一个RDD的不同分区可以被保存到集群中不同的节点上，从而可以在集群中的不同节点上进行并行计算

RDD提供了一种高度受限的共享内存模型（因为它只读），即RDD是只读的记录分区的集合，不能直接修改，只能基于稳定的物理存储中的数据集创建RDD，或者通过在其他RDD上执行确定的转换操作（如map、join和group by）而创建得到新的RDD

1RDD提供了一组丰富的操作以支持常见的数据运算，分为“动作”（Action）和“转换”（Transformation）两种类型
2RDD提供的转换接口都非常简单，都是类似map、filter、groupBy、join等粗粒度的数据转换操作，而不是针对某个数据项的细粒度修改（不适合网页爬虫）
3表面上RDD的功能很受限、不够强大，实际上RDD已经被实践证明可以高效地表达许多框架的编程模型（比如MapReduce、SQL、Pregel）
4Spark用Scala语言实现了RDD的API，程序员可以通过调用API实现对RDD的各种操作

RDD典型的执行过程如下：
1RDD读入外部数据源进行创建
2RDD经过一系列的转换（Transformation）操作，每一次都会产生不同的RDD，供给下一个转换操作使用
3最后一个RDD经过“动作”操作进行转换，并输出到外部数据源
这一系列处理称为一个Lineage（血缘关系），即DAG拓扑排序的结果
优点：惰性调用、管道化、避免同步等待、不需要保存中间结果、每次操作变得简单

3.RDD特性

Spark采用RDD以后能够实现高效计算的原因主要在于：
（1）高效的容错性
现有容错机制：数据复制或者记录日志
RDD：血缘关系、重新计算丢失分区、无需回滚系统、重算过程在不同节点之间并行、只记录粗粒度的操作
（2）中间结果持久化到内存，数据在内存中的多个RDD操作之间进行传递，避免了不必要的读写磁盘开销
（3）存放的数据可以是Java对象，避免了不必要的对象序列化和反序列化

4.RDD之间的依赖关系

Shuffle操作
1什么是Shuffle操作
2MapReduce中的Shuffle操作
3Spark中的Shuffle操作

Shuffle过程不仅会产生大量网络传输开销，也会带来大量的磁盘IO开销。Spark经常被认为是基于内存的计算框架，为什么也会产生磁盘IO开销呢？
对于这个问题，这里有必要做一个解释。

Spark经常被认为是基于内存的计算框架，为什么Shuffle过程也会产生磁盘IO开销呢？

窄依赖和宽依赖
是否包含Shuffle操作是区分窄依赖和宽依赖的根据

窄依赖表现为一个父RDD的分区对应于一个子RDD的分区或多个父RDD的分区对应于一个子RDD的分区
宽依赖则表现为存在一个父RDD的一个分区对应一个子RDD的多个分区

5.阶段的划分

Spark根据DAG图中的RDD依赖关系，把一个作业分成多个阶段。对于宽依赖和窄依赖而言，窄依赖对于作业的优化很有利。只有窄依赖可以实现流水线优化，宽依赖包含Shuffle过程，无法实现流水线方式处理。

Spark通过分析各个RDD的依赖关系生成了DAG，再通过分析各个RDD中的分区之间的依赖关系来决定如何划分Stage，具体划分方法是：
1在DAG中进行反向解析，遇到宽依赖就断开
2遇到窄依赖就把当前的RDD加入到Stage中
3将窄依赖尽量划分在同一个Stage中，可以实现流水线计算

被分成三个Stage，在Stage2中，从map到union都是窄依赖，这两步操作可以形成一个流水线操作

流水线操作实例
分区7通过map操作生成的分区9，可以不用等待分区8到分区10这个map操作的计算结束，而是继续进行union操作，得到分区13，这样流水线执行大大提高了计算的效率

6.RDD运行过程

通过上述对RDD概念、依赖关系和Stage划分的介绍，结合之前介绍的Spark运行基本流程，再总结一下RDD在Spark架构中的运行过程：
（1）创建RDD对象；
（2）SparkContext负责计算RDD之间的依赖关系，构建DAG；
（3）DAGScheduler负责把DAG图分解成多个Stage，每个Stage中包含了多个Task，每个Task会被TaskScheduler分发给各个WorkerNode上的Executor去执行。

3.4 Spark的部署方式

Spark支持三种不同类型的部署方式，包括：
1Standalone（类似于MapReduce1.0，slot为资源分配单位）
2Spark on Mesos（和Spark有血缘关系，更好支持Mesos）
3Spark on YARN






讨论：Spark和Hadoop
1虽然Spark很快，但现在在生产环境中仍然不尽人意，无论扩展性、稳定性、管理性等方面都需要进一步增强
2同时，Spark在流处理领域能力有限，如果要实现亚秒级或大容量的数据获取或处理需要其他流处理产品。Cloudera宣布旨在让Spark流数据技术适用于80%的使用场合，就考虑到了这一缺陷。我们确实看到实时分析（而非简单数据过滤或分发）场景中，很多以前使用S4或Storm等流式处理引擎的实现已经逐渐被Kafka+Spark Streaming代替
3Spark的流行将逐渐让MapReduce、Tez走进博物馆
4Hadoop现在分三块HDFS/MR/YARN，Spark比Hadoop性能好，只是Spark作为一个计算引擎，比MR的性能要好。但它的存储和调度框架还是依赖于HDFS/YARN，Spark也有自己的调度框架，但仍然非常不成熟，基本不可商用

第4章 Spark环境搭建和使用方法

4.1 安装Spark

4.1.1 基础环境

安装Spark之前需要安装Linux系统、Java环境和Hadoop环境
如果没有安装Hadoop，请访问厦门大学数据库实验室建设的高校大数据课程公共服务平台，找到“Hadoop安装教程_单机/伪分布式配置_Hadoop2.6.0/Ubuntu14.04”（适用于Hadoop2.7.1/Ubuntu16.04）,依照教程学习安装即可
注意，在这个Hadoop安装教程中，就包含了Java的安装，所以，按照这个教程，就可以完成JDK和Hadoop这二者的安装
Hadoop安装教程地址：http://dblab.xmu.edu.cn/blog/install-hadoop/

4.1.2 下载安装文件

Spark安装包下载地址： http://spark.apache.org
进入下载页面后，点击主页右侧的“Download Spark”按钮进入下载页面，下载页面中提供了几个下载选项，主要是Spark release及Package type的选择，如下图所示。第1项Spark release一般默认选择最新的发行版本，如截至2017年3月份的最新版本为2.1.0。第2项package type则选择“Pre-build with user-provided Hadoop [can use with most Hadoop distributions]”，可适用于多数Hadoop版本。选择好之后，再点击第4项给出的链接就可以下载Spark了。

解压安装包spark-2.1.0-bin-without-hadoop.tgz至路径 /usr/local：

$ sudo tar -zxf ~/下载/spark-2.1.0-bin-without-hadoop.tgz -C /usr/local/
$ cd /usr/local
$ sudo mv ./spark-2.1.0-bin-without-hadoop/ ./spark   # 更改文件夹名
$ sudo chown -R hadoop ./spark                   # 此处的 hadoop 为系统用户名

4.1.3 配置相关文件

配置Spark 的classpath

$ cd /usr/local/spark
$ cp ./conf/spark-env.sh.template ./conf/spark-env.sh   #拷贝配置文件

编辑该配置文件，在文件最后面加上如下一行内容：

export SPARK_DIST_CLASSPATH=$(/usr/local/hadoop/bin/hadoop classpath) #这样才能组合使用hadoop

保存配置文件后，就可以启动、运行Spark了
若需要使用HDFS中的文件，则在使用Spark前需要启动Hadoop

4.1.4 Spark和Hadoop的交互

Spark部署模式包括：
Local模式：单机模式
Standalone模式：使用Spark自带的简单集群管理器
YARN模式：使用YARN作为集群管理器
Mesos模式：使用Mesos作为集群管理器

经过上面的步骤以后，就在单台机器上按照“Hadoop（伪分布式）+Spark（Local模式）”这种方式完成了Hadoop和Spark组合环境的搭建。
Hadoop和Spark可以相互协作，由Hadoop的HDFS、HBase等组件负责数据的存储和管理，由Spark负责数据的计算。

4.2 在spark-shell中运行代码

Spark Shell 提供了简单的方式来学习Spark API
Spark Shell可以以实时、交互的方式来分析数据
Spark Shell支持Scala和Python

一个Driver就包括main方法和分布式数据集
Spark Shell本身就是一个Driver，里面已经包含了main方法

spark-shell命令及其常用的参数如下：
./bin/spark-shell --master

Spark的运行模式取决于传递给SparkContext的Master URL的值。Master URL可以是以下任一种形式：

• local 使用一个Worker线程本地化运行SPARK(完全不并行)
• local[*] 使用逻辑CPU个数数量的线程来本地化运行Spark
• local[K] 使用K个Worker线程本地化运行Spark（理想情况下，K应该根据运行机器的CPU核数设定）
• spark://HOST:PORT 连接到指定的Spark standalone master。默认端口是7077
• yarn-client 以客户端模式连接YARN集群。集群的位置可以在HADOOP_CONF_DIR 环境变量中找到
• yarn-cluster 以集群模式连接YARN集群。集群的位置可以在HADOOP_CONF_DIR 环境变量中找到
• mesos://HOST:PORT 连接到指定的Mesos集群。默认接口是5050

在Spark中采用本地模式启动Spark Shell的命令主要包含以下参数：
--master：这个参数表示当前的Spark Shell要连接到哪个master，如果是local[*]，就是使用本地模式启动spark-shell，其中，中括号内的星号表示需要使用几个CPU核心(core)，也就是启动几个线程模拟Spark集群
--jars： 这个参数用于把相关的JAR包添加到CLASSPATH中；如果有多个jar包，可以使用逗号分隔符连接它们

比如，要采用本地模式，在4个CPU核心上运行spark-shell：
$ cd /usr/local/spark
$ ./bin/spark-shell --master local[4]
或者，可以在CLASSPATH中添加code.jar，命令如下：
$ cd /usr/local/spark
$ ./bin/spark-shell --master local[4] --jars code.jar
可以执行“spark-shell --help”命令，获取完整的选项列表，具体如下：
$ cd /usr/local/spark
$ ./bin/spark-shell --help

执行如下命令启动Spark Shell（默认是local模式）：
$ ./bin/spark-shell
启动Spark Shell成功后在输出信息的末尾可以看到“Scala >”的命令提示符

可以在里面输入scala代码进行调试：

可以使用命令“:quit”退出Spark Shell：

或者，也可以直接使用“Ctrl+D”组合键，退出Spark Shell

4.3 编写Spark独立应用程序

使用 Scala 编写的程序需要使用 sbt 进行编译打包
使用 Java编写的程序需要使用 Maven进行编译打包
使用 Python编写的程序需要使用 spark-submit进行编译打包

4.3.1 安装编译打包工具

1.安装sbt
sbt是一款Spark用来对scala编写程序进行打包的工具，Spark 中没有自带 sbt，需要下载安装

下载sbt安装包以后，执行如下命令拷贝至 /usr/local/sbt 中：

接着在 /usr/local/sbt 中创建 sbt 脚本（vim ./sbt），添加如下内容：

#!/bin/bash SBT_OPTS="-Xms512M -Xmx1536M -Xss1M -XX:+CMSClassUnloadingEnabled -XX:MaxPermSize=256M" java $SBT_OPTS -jar `dirname $0`/sbt-launch.jar "$@" 

保存后，为 ./sbt 脚本增加可执行权限：

最后运行如下命令，检验 sbt 是否可用（需要几分钟时间）：

只要能得到如下图的版本信息就没问题：

2. 安装Maven

$ sudo  unzip  ~/下载/apache-maven-3.3.9-bin.zip  -d  /usr/local
$ cd  /usr/local
$ sudo  mv  ./apache-maven-3.3.9  ./maven
$ sudo  chown  -R  hadoop  ./maven

4.3.2 编写Spark应用程序代码

在终端中执行如下命令创建一个文件夹 sparkapp 作为应用程序根目录：

在 ./sparkapp/src/main/scala 下建立一个名为 SimpleApp.scala 的文件，添加代码如下

SparkContext是连接到整个集群的入口

4.3.3 编译打包

1.使用sbt对Scala 程序进行编译打包
请在./sparkapp 中新建文件 simple.sbt（vim ./sparkapp/simple.sbt），添加内容如下，声明该独立应用程序的信息以及与 Spark 的依赖关系：

name := "Simple Project"
version := "1.0"
scalaVersion := "2.11.8"
libraryDependencies += "org.apache.spark" %% "spark-core" % "2.1.0"

为保证 sbt 能正常运行，先执行如下命令检查整个应用程序的文件结构：

文件结构应如下图所示：

接着，我们就可以通过如下代码将整个应用程序打包成 JAR（首次运行同样需要下载依赖包 ）：

打包成功的话，会输出类似如下信息：

hadoop@dblab:~/sparkapp$ /usr/local/sbt/sbt package
OpenJDK 64-Bit Server VM warning: ignoring option MaxPermSize=256M; support was removed in 8.0
[info] Set current project to Simple Project (in build file:/home/hadoop/sparkapp/)
[success] Total time: 2 s, completed 2017-2-19 15:45:29

生成的 jar 包的位置为 ~/sparkapp/target/scala-2.11/simple-project_2.11-1.0.jar

2.使用Maven对Scala 程序进行编译打包
为了和sbt打包编译的内容进行区分，这里再为Maven创建一个代码目录“_{/sparkapp2”，并在“}/sparkapp2/src/main/scala”下建立一个名为 SimpleApp.scala的Scala代码文件，放入和前面一样的代码。
在“~/sparkapp2”目录中新建文件pom.xml

<project>
    <groupId>cn.edu.xmu</groupId>
    <artifactId>simple-project</artifactId>
    <modelVersion>4.0.0</modelVersion>
    <name>Simple Project</name>
    <packaging>jar</packaging>
    <version>1.0</version>
    <repositories>
        <repository>
            <id>jboss</id>
            <name>JBoss Repository</name>
            <url>http://repository.jboss.com/maven2/</url>
        </repository>
    </repositories>
    <dependencies>
        <dependency> <!-- Spark dependency -->
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.11</artifactId>
            <version>2.1.0</version>
        </dependency>
    </dependencies>
  <build>
    <sourceDirectory>src/main/scala</sourceDirectory>
    <plugins>
      <plugin>
        <groupId>org.scala-tools</groupId>
        <artifactId>maven-scala-plugin</artifactId>
        <executions>
          <execution>
            <goals>
              <goal>compile</goal>
            </goals>
          </execution>
        </executions>
        <configuration>
          <scalaVersion>2.11.8</scalaVersion>
          <args>
            <arg>-target:jvm-1.5</arg>
          </args>
        </configuration>
	</plugin>
	</plugins>
</build>
</project> 

可以通过如下代码将整个应用程序打包成JAR包（注意：计算机需要保持连接网络的状态，而且首次运行打包命令时，Maven会自动下载依赖包，需要消耗几分钟的时间）：

$ cd  ~/sparkapp2    #一定把这个目录设置为当前目录
$ /usr/local/maven/bin/mvn  package 

如果屏幕返回如下信息，则说明生成JAR包成功：

[INFO] Building jar: /home/hadoop/sparkapp2/target/simple-project-1.0.jar
[INFO]----------------------------------------
[INFO] BUILD SUCCESS
[INFO]----------------------------------------
[INFO] Total time: 4.665 s
[INFO] Finished at: 2017-01-31T 15:57:09+08:00
[INFO] Final Memory: 30M/72M
[INFO]---------------------------------------- 

生成的应用程序JAR包的位置为“/home/hadoop/sparkapp2/target/simple-project-1.0.jar”。

4.3.4 通过spark-submit运行程序

可以通过spark-submit提交应用程序，该命令的格式如下：

./bin/spark-submit 
  --class <main-class>  //需要运行的程序的主类，应用程序的入口点
  --master <master-url>  //Master URL，下面会有具体解释
  --deploy-mode <deploy-mode>   //部署模式
  ... # other options  //其他参数
  <application-jar>  //应用程序JAR包
  [application-arguments] //传递给主类的主方法的参数

Spark的运行模式取决于传递给SparkContext的Master URL的值。Master URL可以是以下任一种形式：
* local 使用一个Worker线程本地化运行SPARK(完全不并行)
* local[*] 使用逻辑CPU个数数量的线程来本地化运行Spark
* local[K] 使用K个Worker线程本地化运行Spark（理想情况下，K应该根据运行机器的CPU核数设定）
* spark://HOST:PORT 连接到指定的Spark standalone master。默认端口是7077
* yarn-client 以客户端模式连接YARN集群。集群的位置可以在HADOOP_CONF_DIR 环境变量中找到。
* yarn-cluster 以集群模式连接YARN集群。集群的位置可以在HADOOP_CONF_DIR 环境变量中找到。
* mesos://HOST:PORT 连接到指定的Mesos集群。默认接口是5050。

对于之前使用sbt工具编译打包得到的 jar 包，就可以通过 spark-submit 提交到 Spark 中运行了，命令如下：

$ /usr/local/spark/bin/spark-submit --class "SimpleApp" ~/sparkapp/target/scala-2.11/simple-project_2.11-1.0.jar
#上面命令执行后会输出太多信息，可以不使用上面命令，而使用下面命令查看想要的结果
$ /usr/local/spark/bin/spark-submit --class "SimpleApp" ~/sparkapp/target/scala-2.11/simple-project_2.11-1.0.jar 2>&1 | grep "Lines with a:"

最终得到的结果如下：

Lines with a: 62, Lines with b: 30

对于之前使用Maven工具编译打包得到的 jar 包，也可以通过 spark-submit 提交到 Spark 中运行了

4.3.5 使用开发工具编写Spark应用程序

安装必备软件说明
第1种方式：安装Scala IDE for Eclipse

第2种方式：
在现有的Eclipse基础之上，安装maven插件和scala插件

4.4第一个Spark应用程序：WordCount

flatMap就是把整个的单词拍扁，包含了文档中所有的单词
然后把所有单词用空格分开
用map把单词形成键值对，每个键值对都是单词,1
reduceByKey把里面的相同的键的值进行叠加
collect是把其他节点上的相同功能也都收集起来
最后打印出结果

spark-submit和应用程序里面都可以设置

4.5使用开发工具编写Spark应用程序

IntelliJ IDEA编写Spark应用程序

4.6 Spark集群环境搭建

4.6.1 集群概况

采用3台机器（节点）作为实例来演示如何搭建Spark集群
其中1台机器（节点）作为Master节点
另外两台机器（节点）作为Slave节点（即作为Worker节点），主机名分别为Slave01和Slave02

4.6.2 准备工作：搭建Hadoop集群环境

Spark+HDFS运行架构
请参考厦门大学数据库实验室建设的“高校大数据课程公共服务平台”里面的技术博客：《 Hadoop 2.7分布式集群环境搭建》
文章地址：http://dblab.xmu.edu.cn/blog/1177-2/

4.6.3 安装Spark

在Master节点上，访问Spark官网下载Spark安装包

sudo tar -zxf ~/下载/spark-2.1.0-bin-without-hadoop.tgz -C /usr/local/
cd /usr/local
sudo mv ./spark-2.1.0-bin-without-hadoop/ ./spark
sudo chown -R hadoop ./spark

4.6.4 配置环境变量

在Master节点主机的终端中执行如下命令：

$ vim ~/.bashrc

在.bashrc添加如下配置：

export SPARK_HOME=/usr/local/spark
export PATH=$PATH:$SPARK_HOME/bin:$SPARK_HOME/sbin

运行source命令使得配置立即生效：
$ source ~/.bashrc

4.6.5 Spark配置

（1）配置slaves文件
将 slaves.template 拷贝到 slaves

$ cd /usr/local/spark/
$ cp ./conf/slaves.template ./conf/slaves

slaves文件设置Worker节点。编辑slaves内容,把默认内容localhost替换成如下内容：

Slave01slave02 

（2）配置spark-env.sh文件
将 spark-env.sh.template 拷贝到 spark-env.sh

$ cp ./conf/spark-env.sh.template ./conf/spark-env.sh

编辑spark-env.sh,添加如下内容：

export SPARK_DIST_CLASSPATH=$(/usr/local/hadoop/bin/hadoop classpath) 
export HADOOP_CONF_DIR=/usr/local/hadoop/etc/hadoop
export SPARK_MASTER_IP=192.168.1.104 

配置好后，将Master主机上的/usr/local/spark文件夹复制到各个节点上在Master主机上执行如下命令：

cd /usr/local/
tar -zcf ~/spark.master.tar.gz ./spark
cd ~
scp ./spark.master.tar.gz slave01:/home/hadoop
scp ./spark.master.tar.gz slave02:/home/hadoop

在slave01,slave02节点上分别执行下面同样的操作：

sudo rm -rf /usr/local/spark/
sudo tar -zxf ~/spark.master.tar.gz -C /usr/local
sudo chown -R hadoop /usr/local/spark

4.6.6 启动Spark集群

（1）首先启动Hadoop集群。在Master节点主机上运行如下命令：

$ cd /usr/local/hadoop/
$ sbin/start-all.sh

（2）启动Master节点
在Master节点主机上运行如下命令：

$ cd /usr/local/spark/
$ sbin/start-master.sh

（3）启动所有Slave节点
在Master节点主机上运行如下命令：
$ sbin/start-slaves.sh

（4）在浏览器上查看Spark独立集群管理器的集群信息
在Master主机上打开浏览器，访问http://master:8080,如下图：

4.6.7 关闭Spark集群

在Master节点上执行下面命令
（1）关闭Master节点

$ sbin/stop-master.sh

（2）关闭Worker节点

$ sbin/stop-slaves.sh

（3）关闭Hadoop集群

$ cd /usr/local/hadoop/
$ sbin/stop-all.sh

4.7 在集群上运行Spark应用程序

4.7.1 启动Spark集群

请登录Linux系统，打开一个终端启动Hadoop集群

$ cd /usr/local/hadoop/
$ sbin/start-all.sh

启动Spark的Master节点和所有slaves节点

$ cd /usr/local/spark/
$ sbin/start-master.sh
$ sbin/start-slaves.sh

4.7.2 采用独立集群管理器

（1）在集群中运行应用程序JAR包
向独立集群管理器提交应用，需要把spark://master:7077作为主节点参数递给spark-submit
可以运行Spark安装好以后自带的样例程序SparkPi，它的功能是计算得到pi的值（3.1415926）

$ bin/spark-submit  \
> --class org.apache.spark.examples.SparkPi  \
> --master spark://master:7077  \
> examples/jars/spark-examples_2.11-2.0.2.jar 100 2>&1 | grep "Pi is roughly"

（2）在集群中运行spark-shell
也可以用spark-shell连接到独立集群管理器上

$ bin/spark-shell --master spark://master:7077

scala> val textFile = sc.textFile("hdfs://master:9000/README.md")
textFile: org.apache.spark.rdd.RDD[String] = hdfs://master:9000/README.md MapPartitionsRDD[1] at textFile at <console>:24
scala> textFile.count()
res0: Long = 99 
scala> textFile.first()
res1: String = # Apache Spark

用户在独立集群管理Web界面查看应用的运行情况
http://master:8080/

4.7.3 采用Hadoop YARN管理器

（1）在集群中运行应用程序JAR包
向Hadoop YARN集群管理器提交应用，需要把yarn-cluster作为主节点参数递给spark-submit。

$ bin/spark-submit  \
> --class org.apache.spark.examples.SparkPi   \
> --master yarn-cluster   \
> examples/jars/spark-examples_2.11-2.0.2.jar

运行后，根据在Shell中得到输出的结果地址查看，如下图：

复制结果地址到浏览器，点击查看Logs，再点击stdout，即可查看结果，如下图：


（2）在集群中运行spark-shell
也可以用spark-shell连接到独立集群管理器上

$ bin/spark-shell --master yarn

scala> val textFile = sc.textFile("hdfs://master:9000/README.md")
textFile: org.apache.spark.rdd.RDD[String] = hdfs://master:9000/README.md MapPartitionsRDD[3] at textFile at <console>:24
 
scala> textFile.count()
res2: Long = 99 
 
scala> textFile.first()
res3: String = # Apache Spark

（3）查看集群信息
用户在Hadoop Yarn集群管理Web界面查看所有应用的运行情况
http://master:8088/cluster