【Spark 2.1.1 入门】Spark基础①入门 2019_12_4

基于 纯内存的 MapReduce的计算框架。相较 MR 极限提升100倍，硬盘提升10倍左右。
为什么快——实现了 高效DAG（有向无环图）执行引擎，并完全基于内存处理数据流。
为什么用——提升MR性能，并且为MR不擅长的领域：机器学习，图形计算，数据挖掘等循环迭代计算 补充强劲支持

资源：

Spark官网： http://spark.apache.org/
Spark官网下载： http://spark.apache.org/downloads.html
推荐版本 s2.4.4-h2.7：https://www.apache.org/dyn/closer.lua/spark/spark-2.4.4/spark-2.4.4-bin-hadoop2.7.tgz
最新版本 s3.0.0-h2.7/h3.2 and later

渊源由来

Hadoop	Spark
2008，Hadoop 0.x.y诞生；
	2009，Spark 0.x.y 诞生；
	2010，Spark 开源
2013.10，Hadoop 1.x.y Yarn诞生；	2013.6，加入Apache基金会；
	2014年，Spark 成为 Apache 顶级项目；

Hadoop - MapReduce，最重要的目标（优点）：在任何廉价机器上都能可靠运行。
缺点：不面向 循环重复 使用数据 场景，不适用 需要并行迭代的数据应用场景（机器学习，图形计算，数据挖掘）

Spark为此而生，基于MapReduce的计算框架，但改为内存计算，提升数据分析，挖掘，处理的速度。采用 Scala 编写

特点

快速

Spark 基于内存的运算，采用独有的 state-of-the-art DAG scheduler —— 查询优化器，物理执行引擎

语言接口丰富

支持 Scala, Java, Python, R 和 SQL 脚本

专业类库丰富

包括 SQL 和 DataFrames, 机器学习(MLlib), 图计算(GraphicX), 实时流处理(Spark Streaming)

插拔式组件

Spark可以将 Hadoop 的 YARN 和 Apache Mesos 作为它的资源管理和调度器。并且Spark计算框架支持所有 Hadoop 数据类型，包括 HDFS，HBase等

构架

从上至下

四大数据处理模块

Spark SQL

可使用 SQL 或者 Apache Hive 的 HQL 查询数据。Spark SQL 支持多种数据源，如 Hive 表、Parquet 以及 JSON 等。

Spark Streaming

对 实时数据 进行流式计算的组件。提供了用来操作数据流的 API，并且与 Spark Core 中的 RDD API 高度对应。

Spark MLlib

提供常见 机器学习 (ML) 程序库。包括分类、回归、聚类、协同过滤等，还提供了模型评估、数据导入等额外功能。

Spark Core

实现 Spark 的基本功能，包含任务调度、内存管理、错误恢复、与存储系统交互等模块。Spark Core 中还包含了对弹性分布式数据集(Resilient Distributed DataSet，简称RDD)的API定义。

Cluster Manager

Spark 设计为可以高效地在一个计算节点到数千个计算节点之间伸缩计算。

为了实现这样的要求，同时获得最大灵活性，Spark 支持在各种集群管理器(Cluster Manager)上运行，目前 Spark 支持 3 种集群管理器:

1. Hadoop YARN (在国内使用最广泛)
2. Apache Mesos (国内使用较少, 国外使用较多)
3. Standalone (Spark 自带的资源调度器, 需要在集群中的每台节点上配置 Spark)

模式部署

提前准备：上传 spark-2.1.1-bin-hadoop2.7.tgz 至 /opt/software，使用Secure 8.5，SFTP上传快捷键：Alt + P

Local 单节点模式

部署

$ cd /opt/software
$ tar -zxvf spark-2.1.1-bin-hadoop2.7.tgz -C /opt/module
$ cp -r spark-2.1.1-bin-hadoop2.7 spark-local

测试Shell命令

$ cd /opt/software/spark-local
$ bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master local[2] \
./examples/jars/spark-examples_2.11-2.1.1.jar 100

# 或
$ bin/run-example SparkPi 100

命令格式及解析：

./bin/spark-submit \
--class <main-class> \
--master <master-url> \
--deploy-mode <deploy-mode> \
--conf <key>=<value> \
...
<application-jar> \
[application-arguments]

--class 指定 应用(.jar)的启动主类(.class)
--master 指定 master 主机地址，默认为 local 表示在本机运行
--deploy-mode 是否发布 Driver 到 worker节点(集群模式) 或者作为本地客户端 (client 模式) (default: client)
--conf 指定最高优先级的 Spark 属性配置， 格式 key=value. 如果值包含空格，可以加引号"key=value"
--executor-memory 1G 指定每个executor可用内存为1G
--total-executor-cores 6 指定所有executor使用的cpu核数为6个
--executor-cores 指定每个executor使用的 cpu 的核数

<application-jar> 指定应用jar包的路径,包含依赖。这个 URL 在集群中全局可见。
如 HDFS 共享存储系统 hdfs://path 。若是本地文件系统 file://path， 那么所有节点都应包含相同path的jar存在

[application-arguments] 指定传给 --class启动主类 main()方法的参数

补充：<master-url>

Master URL	Meaning
local	Run Spark locally with one worker thread (i.e. no parallelism at all).
local[K]	Run Spark locally with K worker threads (ideally, set this to the number of cores on your machine).
local[*]	Run Spark locally with as many worker threads as logical cores on your machine.
spark://HOST:PORT	Connect to the given Spark standalone cluster master. The port must be whichever one your master is configured to use, which is 7077 by default.
mesos://HOST:PORT	Connect to the given Mesos cluster. The port must be whichever one your is configured to use, which is 5050 by default. Or, for a Mesos cluster using ZooKeeper, use mesos://zk://… To submit with --deploy-mode cluster, the HOST:PORT should be configured to connect to the MesosClusterDispatcher.
yarn	Connect to a YARNcluster in client or cluster mode depending on the value of --deploy-mode. The cluster location will be found based on the HADOOP_CONF_DIR or YARN_CONF_DIR variable.

测试Spark-Shell交互命令

1.前期准备：在/opt/module/spark-local目录下创建目录及文件

$ cd /opt/module/spark-local
$ mkdir input/
$ cd input/
$ vim 1.txt
>>
hello spark
hello inbreeze
hello world
<<
$ cp 1.txt 2.txt

2.进入Spark-Shell 命令式交互客户端

$ cd /opt/module/spark-local
$ bin/spark-shell
scala> sc.textFile("input/").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect

打开 Spark-Shell 后即可查看 http://hadoop102:4040 ，此网站可以查看当前 运行的/结束的 Spark 任务Job

Spark通用运行流程

Spark-Shell测试命令解析

Word Count 流程解析

Spark核心概念

1.Driver Program 应用程序

每个 Spark 应用程序都包含一个驱动程序, 驱动程序负责把并行操作发布到集群上.
**Driver Program **包含 Spark 应用程序中的主函数, 定义RDD(对象分布式数据集)来在集群中使用.

上例使用 Spark-Shell 执行 Word Count 案例程序，spark-shell 就是驱动程序的一种，由其负责发布我们输入的函数的应用程序. 驱动程序通过 Spark Context 对象来访问 Spark 集群, Spark Context 对象相当于 Spark 集群 的连接对象. 在 Spark-Shell中, 会自动创建一个Spark Context对象, 并把这个对象命名为 sc.

2.Executor 执行器

Spark Context 对象 一旦成功连接到 集群管理器(Yarn.ResourceMananger/Standalone.Master), 就可以获取到集群中每个节点上的 Executor 执行器(Yarn.NodeManager/Standalone.Worker).

执行器是一个进程(进程名: ExecutorBackend, 运行在 Worker 上), 用来执行计算和为应用程序存储数据.

Spark 会发送 Driver Program 应用程序代码(如:jar包) 到 每个 Executor 执行器，
最后，Spark Context 对象发送 Task 到 Executor 执行器 开始执行.

驱动程序包含 Spark 应用程序中的主函数, 定义了分布式数据集以应用在集群中.

3.RDD(Resilient Distributed Dataset) 弹性分布式数据集

Spark Context 对象即可创建 RDD 对象，如通过 sc.textFile() 函数

4.Cluster Manager (集群管理器)

集群管理器负责跨 Driver Programs 分配资源.

Spark Context对象可以连接到 3 种集群管理器(Spark’s own Standalone, Mesos or YARN).

5.Job & Task & Stage

Task	A unit of work that will be sent to one executor【一个工作单元，被发送至一个Executor】
Job	A parallel computation consisting of multiple tasks that gets spawned in response to a Spark action (e.g. save, collect)【Job由多个Task组成的并行计算，这些Tasks在响应Spark Action 算子时产生】
Stage	Each job gets divided into smaller sets of tasks called stages that depend on each other (similar to the map and reduce stages in MapReduce);【每个Job作业被分成更小的Task任务集，称为阶段，这些阶段相互依赖(类似于MapReduce中的map和reduce阶段)

Standalone 自带集群模式

构建一个由 Spark 自主研发的 Master + Slave —— Spark 集群。
这里的提及的 Standalone 是指只用 Spark 框架来搭建一个 Spark 集群, 不需要借助其他的框架.

运行模式

配置流程

________________________________________
一、 配置 Standalone 模式
步骤1: 复制 spark, 并命名为spark-standalone
$ cd /opt/module
$ cp -r spark-2.1.1-bin-hadoop2.7 spark-standalone
步骤2: 进入配置文件目录conf, 配置spark-evn.sh
$ cd conf/
$ cp spark-env.sh.template spark-env.sh
$ vim spark-env.sh
<<
SPARK_MASTER_HOST=hadoop102
SPARK_MASTER_PORT=7077 # 默认端口就是7077, 可以省略不配
>>
步骤3: 修改 slaves 文件, 添加 worker 节点
$ cp slaves.template slaves
$ vim slaves
>>
Hadoop102
hadoop103
hadoop104
<<
步骤4: 分发spark-standalone
$ xsync /opt/module/spark-standalone
步骤5: 启动 Spark 集群
$ /opt/module/spark-standalonesbin/start-all.sh
步骤6: 在网页中查看 Spark 集群情况
地址: http://hadoop102:8080

可能碰到的问题
•	如果启动的时候报:JAVA_HOME is not set, 则在sbin/spark-config.sh中添加入JAVA_HOME变量 并 分发

________________________________________
二、测试 Standalone 集群
使用 Standalone 计算模式运行计算 PI值 程序

命令：
$ cd /opt/module/spark-standalone
$ bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://hadoop102:7077 \
--executor-memory 1G \
--total-executor-cores 6 \
--executor-cores 2 \
./examples/jars/spark-examples_2.11-2.1.1.jar 100
 
________________________________________
三、 在 Standalone 集群模式下启动 Spark-shell
命令：
$ cd /opt/module/spark-standalone
$ bin/spark-shell \
--master spark://hadoop102:7077

说明:
--master spark://hadoop102:7077 指定要连接的集群的master的Host地址
 
Standalone.Spark-Shell执行 WordCount 程序
命令：
sc.textFile("input/").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect

注意:
•	每个worker节点上要有相同的文件夹:input/, 否则会报文件不存在的异常(注意！集群环境下!!!)

________________________________________
四、 配置Job作业历史服务器
在 Spark-shell 没有退出之前, 可在 http://hadoop102:4040 看到正在执行的Spark Job的日志情况
但是退出 Spark-shell 之后, 执行的所有任务记录全部丢失.所以配置Job历史服务器

步骤1: 配置spark-default.conf文件
$ cd /opt/module/spark-standalone/conf
$ cp spark-defaults.conf.template spark-defaults.conf
$ vim spark-defaults.conf
>>
spark.master                     spark://hadoop102:7077
spark.eventLog.enabled           true
spark.eventLog.dir               hdfs://hadoop102:9000/spark-job-log
<<
注意:
hdfs://hadoop102:9000/spark-job-log HDFS目录必须提前存在, 名字任意
步骤2: 修改spark-env.sh文件
$ vim spark-env.sh
>>
export SPARK_HISTORY_OPTS="-Dspark.history.ui.port=18080 -Dspark.history.retainedApplications=30 -Dspark.history.fs.logDirectory=hdfs://hadoop102:9000/spark-job-log"
<<
步骤3: 分发配置文件
$ xsync /opt/module/spark-standalone/conf
步骤4: 启动历史服务
先启动 HDFS
$ start-dfs.sh
再启动 History-Server 
$ /opt/module/spark-standalone/sbin/start-history-server.sh
注：History Server Web 地址: http://hadoop102:18080
步骤5: 执行Job, 查看历史服务器
$ bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://hadoop102:7077 \
--executor-memory 1G \
--total-executor-cores 6 \
./examples/jars/spark-examples_2.11-2.1.1.jar 100
 
________________________________________
五、 HA 配置(为 Mater 配置)
由于 master 只有一个, 所以也有单点故障问题.
解决方法：启动多个 master, 先启动的处于 Active 状态, 其他的处于 Standby 状态

步骤1: 给 spark-env.sh 添加如下配置
$ cd /opt/module/spark-standalone/conf
$ vim spark-env.sh
>>
# 注释掉如下内容：
#SPARK_MASTER_HOST=hadoop102
#SPARK_MASTER_PORT=7077
# 添加上如下内容：
export SPARK_DAEMON_JAVA_OPTS="-Dspark.deploy.recoveryMode=ZOOKEEPER -Dspark.deploy.zookeeper.url=hadoop102:2181,hadoop103:2181,hadoop104:2181 -Dspark.deploy.zookeeper.dir=/spark"
<<
步骤2: 分发配置文件
$ xsync /opt/module/spark-standalone/conf
步骤3: 启动 Zookeeper
$ zk.sh start (个人写的群起脚本)
步骤4: 在 hadoop102 启动全部节点
$ /opt/module/spark-standalone/sbin/start-all.sh
注：会在当前节点启动一个 master
步骤5: 单独在 hadoop103 启动一个 master
$ /opt/module/spark-standalone/sbin/start-master.sh
步骤6: 查看 master 的状态，地址: http://hadoop102:8080
步骤7: 杀死 hadoop102 的 master 进程
$ kill -9 0000
hadoop103 的 master 会自动切换成 Active
________________________________________

Yarn 集群模式

Spark 客户端可以直接连接 Yarn，不需要额外构建Spark集群。
有 yarn-client 和 yarn-cluster 两种模式，主要区别在于：Driver 程序的运行节点不同。

• yarn-client：Driver 程序运行在客户端，适用于交互、调试，希望立即看到app的输出
• yarn-cluster：Driver 程序运行在由 RM 启动的 AM 上, 适用于生产环境

运行模式

配置流程

________________________________________
一、Yarn 模式配置
步骤1: 修改 hadoop 配置文件 yarn-site.xml, 添加如下内容：
若虚拟机内存太少, 防止任务被意外杀死, 需配置如下：
$ vim /opt/module/hadoop-2.7.2/etc/hadoop/yarn-site.xml
>>
<!--是否启动一个线程检查每个任务正使用的物理内存量，如果任务超出分配值，则直接将其杀掉，默认是true -->
<property>
    <name>yarn.nodemanager.pmem-check-enabled</name>
    <value>false</value>
</property>
<!--是否启动一个线程检查每个任务正使用的虚拟内存量，如果任务超出分配值，则直接将其杀掉，默认是true -->
<property>
    <name>yarn.nodemanager.vmem-check-enabled</name>
    <value>false</value>
</property>
<<
$ xsync /opt/module/hadoop-2.7.2/etc/hadoop/yarn-site.xml
步骤2: 复制 spark, 并命名为spark-yarn
$ cd /opt/module
$ cp -r spark-standalone spark-yarn
步骤3: 修改spark-evn.sh文件
去掉 master 的 HA 配置, 日志服务的配置保留着.
$ vim /opt/module/spark-yarn/conf/spark-evn.sh
>>
# 打开如下注解
SPARK_MASTER_HOST=hadoop102
SPARK_MASTER_PORT=7077
# 注释如下内容：
#export SPARK_DAEMON_JAVA_OPTS="-Dspark.deploy.recoveryMode=ZOOKEEPER -Dspark.deploy.zookeeper.url=hadoop102:2181,hadoop103:2181,hadoop104:2181 -Dspark.deploy.zookeeper.dir=/spark"
# 增添新属性配置
YARN_CONF_DIR=/opt/module/hadoop-2.7.2/etc/hadoop
<<
步骤4: 执行一段程序
命令：
$ bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master yarn \
--deploy-mode client \
./examples/jars/spark-examples_2.11-2.1.1.jar 100

查询 Yarn Job 运行情况：http://hadoop103:8088
 
二、日志服务
在前面的页面中点击 history 无法直接连接到 spark 的日志.
可以在spark-default.conf中添加如下配置达到上述目的
$ vim /opt/module/spark-yarn/conf/spark-default.conf
>>
spark.yarn.historyServer.address=hadoop102:18080
spark.history.ui.port=18080
<<

可能碰到的问题:
如果在 yarn 日志端无法查看到具体的日志, 则在yarn-site.xml中添加如下配置
$ vim /opt/module/hadoop-2.7.2/etc/hadoop/yarn-site.xml
<property>
    <name>yarn.log.server.url</name>
    <value>http://hadoop102:19888/jobhistory/logs</value>
</property>
________________________________________

注：Mesos 集群模式：Spark客户端直接连接 Mesos；不需要额外构建 Spark 集群。国内应用较少，更多使用 yarn 调度

3种模式对比

模式	Spark安装机器数	需启动的进程	所属者
Local	1	无	Spark
Standalone	多台	Master及Worker	Spark
Yarn	1	Yarn及HDFS	Hadoop

Word Count 1

Word Count Job 为 Scala 编写的 Driver，在编写完成后，package 成 Jar 包，通过 Spark-Yarn Linux集群环境下，使用 spark-submit 命令 将 Driver 发布至 Yarn ，RM 建立 AM 后，由 AM 运行Driver并派发 Task 至 多个 NM（多个Executor）
当然，一个 NM 可以有 多个 Executor

1. Maven 依赖

<dependencies>
    <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-core_2.11</artifactId>
        <version>2.1.1</version>
    </dependency>
</dependencies>
<build>
    <plugins>
        <!-- 打包插件, 否则 scala 类不会编译并打包进去 -->
        <plugin>
            <groupId>net.alchim31.maven</groupId>
            <artifactId>scala-maven-plugin</artifactId>
            <version>3.4.6</version>
            <executions>
                <execution>
                    <goals>
                        <goal>compile</goal>
                        <goal>testCompile</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

2. Driver

object Spark01_WordCount {
  def main(args: Array[String]): Unit = {
    //0.创建Spark运行配置
    val conf = new SparkConf().setMaster("local[*]").setAppName("Spark_WordCount1")
    //1.创建Spark链接对象
    val sc = new SparkContext(conf)
    //2.令SC读取指定位置文件并创建RDD对象(Hadoop.TextInputFormat)
    val lineRDD: RDD[String] = sc.textFile("input/")
    lineRDD.foreach(println)
    //3.将读取到的 一行，一行，… 数据先通过map映射（拆分成一个个单词形成 Array(Arrary(),...,Array())），然后flatten扁平化
    val wordRDD: RDD[String] = lineRDD.flatMap(_.split(" "))
    wordRDD.foreach(println)
    //4.为进行频次计数，就需要先将 一个个单词进行标记，使用map将一个单词，映射成 (单词,1) 的元组格式
    val wordToOneRDD: RDD[(String, Int)] = wordRDD.map((_,1))
    wordToOneRDD.foreach(println)
    //5.对标记进行归约化简 reduce
    val wordToSumRDD: RDD[(String, Int)] = wordToOneRDD.reduceByKey(_ + _)
    wordToSumRDD.foreach(println)
    //6.收集多个Executor规约的单词结果总结成一个 Array 数组
    val wordToCountArray: Array[(String, Int)] = wordToSumRDD.collect()
    //7.遍历Array，输出至控制台
    wordToCountArray.foreach(println)
    //8.关闭SC对象
    sc.stop()
  }
}