Spark-3.0.0 重点归纳

第1章 Spark概述

1.1 什么是Spark

回顾：Hadoop主要解决，海量数据的存储和海量数据的分析计算。（基于磁盘，shuffle和reduce都要落盘，走MR多了磁盘落盘多，影响性能）
Spark是一种基于内存的快速、通用、可扩展的大数据分析计算引擎。

1.2 Hadoop与Spark历史

HDFS -> NM单点故障
MR -> 集群
JobTracker：负责资源管理和分配、负责任务的调度
TaskTracker：资源节点、任务执行节点

区别：

1. MR是基于磁盘，spark是基于内存
2. MR的task是进程（处理小文件JVM重用），spark的task是线程（Executor线程里启动的一个一个进程）
3. MR的task在container内执行，Executor直接在Worker内执行

Hadoop的Yarn框架比Spark框架诞生的晚，所以Spark自己也设计了一套资源调度框架。

1.3 Hadoop与Spark框架对比

一次性数据计算
框架在处理数据的时候，会从存储设备中读取数据，进行逻辑操作，然后将处理的结果重新存储到介质中

• 以上就是一次性数据计算，但这种数据的一次性计算在处理复杂逻辑的时候性能是非常低的，是因为hadoop中mapreduce的计算引擎中的计算模型比较简单，它里面只有map和reduce。这样对于上层应用来讲，就不得不想方设法去拆分算法，甚至于不得不在上层应用实现多个job的串联（导致reducer输出落盘的file要作为下一个job的数据源），这种感觉就像迭代式计算，上一次的计算结果要给下一次使用，它们之间作业的关联就靠的是磁盘交互，会非常影响性能，MR初期设计并不是为了满足循环迭代式数据的处理，因此在一些并行运行的数据处理场景当中比方说机器学习图形挖掘交互式数据挖掘这些计算中效率是非常低的
  

• 反观spark它里面提供了更加丰富的数据处理模型，而且它可以基于内存来做数据集的多次迭代，所以它就会更好的支持数据挖掘算法和图形计算。那么我们先不考虑他的一个业务复杂度的问题，我们只考虑他数据处理的过程，会发现spark它把作业的计算结果放到了内存当中，为下一次计算提供了更加便利的处理的方式，那么这种方式效率就非常的高，这里我们选择spark而非hadoop中的MR的原因就是因为速度，在内存计算策略和先进的调度机制的帮助下spark可以更加快速的处理相同的数据集，会遇到的问题就是spark如果部署在共享的集群当中，它可能会遇到资源不足的问题，它所占用的资源会更大一些，而且他会同时对其他任务产生影响，所以从本质上来看spark并不适合和hadoop堆栈的一些其他组件一起共同使用。

• 在绝大多数的数据计算场景当中，spark确实比hadoop更加有优势，但是spark是基于内存的，所以在实际的生产环境中由于内存的限制可能会由于内存资源的不足导致job执行失败，这个时候其实MR是更好的选择，所以不能说spark速度快就能代替MR，要根据实际的应用场景来进行选择

1.4 Spark内置模块

Spark Core：实现了Spark的基本功能，包含任务调度、内存管理、错误恢复、与存储系统交互等模块。Spark Core中还包含了对弹性分布式数据集(Resilient Distributed DataSet，简称RDD)的API定义。
Spark SQL：是Spark用来操作结构化数据的程序包。通过Spark SQL，我们可以使用 SQL或者Apache Hive版本的HQL来查询数据。Spark SQL支持多种数据源，比如Hive表、Parquet以及JSON等。
Spark Streaming：是Spark提供的对实时数据进行流式计算的组件。提供了用来操作数据流的API，并且与Spark Core中的 RDD API高度对应。
Spark MLlib：提供常见的机器学习功能的程序库。包括分类、回归、聚类、协同过滤等，还提供了模型评估、数据 导入等额外的支持功能。
Spark GraphX：主要用于图形并行计算和图挖掘系统的组件。
集群管理器：Spark设计为可以高效地在一个计算节点到数千个计算节点之间伸缩计算。为了实现这样的要求，同时获得最大灵活性，Spark支持在各种集群管理器（Cluster Manager）上运行，包括Hadoop YARN、Apache Mesos，以及Spark自带的一个简易调度器，叫作独立调度器。
Spark得到了众多大数据公司的支持，这些公司包括Hortonworks、IBM、Intel、Cloudera、MapR、Pivotal、百度、阿里、腾讯、京东、携程、优酷土豆。当前百度的Spark已应用于大搜索、直达号、百度大数据等业务；阿里利用GraphX构建了大规模的图计算和图挖掘系统，实现了很多生产系统的推荐算法；腾讯Spark集群达到8000台的规模，是当前已知的世界上最大的Spark集群。

1.5 Spark特点

第2章 Spark运行模式

部署Spark集群大体上分为两种模式：单机模式与集群模式
大多数分布式框架都支持单机模式，方便开发者调试框架的运行环境。但是在生产环境中，并不会使用单机模式。因此，后续直接按照集群模式部署Spark集群。
下面详细列举了Spark目前支持的部署模式。
（1）Local模式：在本地部署单个Spark服务
（2）Standalone模式：Spark自带的任务调度模式。（国内常用）
（3）YARN模式：Spark使用Hadoop的YARN组件进行资源与任务调度。（国内最常用）
（4）Mesos模式：Spark使用Mesos平台进行资源与任务的调度。（国内很少用）

2.1 Spark安装地址

1）官网地址：http://spark.apache.org/
2）文档查看地址：https://spark.apache.org/docs/3.1.3/
3）下载地址：https://spark.apache.org/downloads.html
https://archive.apache.org/dist/spark/

2.2 Local模式

Local模式就是运行在一台计算机上的模式，通常就是用于在本机上练手和测试。

2.2.1 安装使用

1）上传并解压Spark安装包

[chenyunde@hadoop102 sorfware]$ tar -zxvf spark-3.1.3-bin-hadoop3.2.tgz -C /opt/module/

[chenyunde@hadoop102 module]$ mv spark-3.1.3-bin-hadoop3.2 spark-local

2）官方求PI案例

[chenyunde@hadoop102 spark-local]$ bin/spark-submit
–class org.apache.spark.examples.SparkPi
–master local[2] ./examples/jars/spark-examples_2.12-3.0.0.jar 10

可以查看spark-submit所有参数：

[chenyunde@hadoop102 spark-local]$ bin/spark-submit

• –class：表示要执行程序的主类；
• –master local[2]

（1）local: 没有指定线程数，则所有计算都运行在一个线程当中，没有任何并行计算
（2）local[K]:指定使用K个Core来运行计算，比如local[2]就是运行2个Core来执行

20/09/20 09:30:53 INFO TaskSetManager:
20/09/15 10:15:00 INFO Executor: Running task 1.0 in stage 0.0 (TID 1)
20/09/15 10:15:00 INFO Executor: Running task 0.0 in stage 0.0 (TID 0)

（3）local[*]：默认模式。自动帮你按照CPU最多核来设置线程数。比如CPU有8核，Spark帮你自动设置8个线程计算。

20/09/20 09:30:53 INFO TaskSetManager:
20/09/15 10:15:58 INFO Executor: Running task 1.0 in stage 0.0 (TID 1)
20/09/15 10:15:58 INFO Executor: Running task 0.0 in stage 0.0 (TID 0)
20/09/15 10:15:58 INFO Executor: Running task 2.0 in stage 0.0 (TID 2)
20/09/15 10:15:58 INFO Executor: Running task 4.0 in stage 0.0 (TID 4)
20/09/15 10:15:58 INFO Executor: Running task 3.0 in stage 0.0 (TID 3)
20/09/15 10:15:58 INFO Executor: Running task 5.0 in stage 0.0 (TID 5)
20/09/15 10:15:59 INFO Executor: Running task 7.0 in stage 0.0 (TID 7)
20/09/15 10:15:59 INFO Executor: Running task 6.0 in stage 0.0 (TID 6)

spark-examples_2.12-3.0.0.jar：要运行的程序；
10：要运行程序的输入参数（计算圆周率π的次数，计算次数越多，准确率越高）；
3）结果展示
该算法是利用蒙特·卡罗算法求PI。

2.2.2 官方WordCount案例

1）需求：读取多个输入文件，统计每个单词出现的总次数。
2）需求分析

3）代码实现：
（1）准备文件

[chenyunde@hadoop102 spark-local]$ mkdir input

在input下创建2个文件1.txt和2.txt，并输入以下内容。

hello chenyunde
hello spark

（2）启动spark-shell

[chenyunde@hadoop102 spark-local]$ bin/spark-shell

[chenyunde@hadoop102 spark-local]$ bin/spark-shell
22/06/10 13:37:59 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
Using Spark's default log4j profile: org/apache/spark/log4j-defaults.properties
Setting default log level to "WARN".
To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
22/06/10 13:38:06 WARN Utils: Service 'SparkUI' could not bind on port 4040. Attempting port 4041.
Spark context Web UI available at http://hadoop102:4041
Spark context available as 'sc' (master = local[*], app id = local-1654839486733).
Spark session available as 'spark'.
Welcome to
      ____              __
     / __/__  ___ _____/ /__
    _\ \/ _ \/ _ `/ __/  '_/
   /___/ .__/\_,_/_/ /_/\_\   version 3.0.0
      /_/

Using Scala version 2.12.10 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_212)
Type in expressions to have them evaluated.
Type :help for more information.
       
scala> sc.textFile("data/words.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect
res0: Array[(String, Int)] = Array((scala,2), (hello,3), (spark,1))

scala>

注意：sc是SparkCore程序的入口；spark是SparkSQL程序入口；master = local[*]表示本地模式运行。

（3）再开启一个hadoop102远程连接窗口，发现了一个SparkSubmit进程

[chenyunde@hadoop102 spark-local]$ jps
3627 SparkSubmit
4047 Jps

运行任务方式说明：spark-submit，是将jar上传到集群，执行Spark任务；spark-shell，相当于命令行工具，本身也是一个Application。
（4）登录hadoop102:4040，查看程序运行情况（注意：spark-shell窗口关闭掉，则hadoop102:4040页面关闭）

说明：本地模式下，默认的调度器为FIFO。
（5）运行WordCount程序

scala> sc.textFile("data/words.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect

res0: Array[(String, Int)] = Array((scala,2), (hello,3), (spark,1))

注意：只有collect开始执行时，才会加载数据。
可登录hadoop102:4040查看程序运行结果

2.3 Standalone模式

Standalone模式是Spark自带的资源调度引擎，构建一个由Master + Worker构成的Spark集群，Spark运行在集群中。
这个要和Hadoop中的Standalone区别开来。这里的Standalone是指只用Spark来搭建一个集群，不需要借助Hadoop的Yarn和Mesos等其他框架。

2.3.1集群角色

2.3.1.1 Master和Worker集群资源管理

Master和Worker是Spark的守护进程、集群资源管理者，即Spark在特定模式(Standalone)下正常运行必须要有的后台常驻进程。

2.3.1.2 Driver和Executor任务的管理者

Driver和Executor是临时程序，当有具体任务提交到Spark集群才会开启的程序。Standalone模式是Spark自带的资源调度引擎，构建一个由Master + Worker构成的Spark集群，Spark运行在集群中。
这个要和Hadoop中的Standalone区别开来。这里的Standalone是指只用Spark来搭建一个集群，不需要借助Hadoop的Yarn和Mesos等其他框架。

2.3.2 安装使用

1）集群规划

	hadoop102	hadoop103	hadoop104
Spark	Master Worker	Worker	Worker

2）再解压一份Spark安装包，并修改解压后的文件夹名称为spark-standalone

[chenyunde@hadoop102 sorfware]$ tar -zxvf
spark-3.1.3-bin-hadoop3.2.tgz -C /opt/module/

[chenyunde@hadoop102 module]$ mv spark-3.1.3-bin-hadoop3.2
spark-standalone

3）进入Spark的配置目录/opt/module/spark-standalone/conf

[chenyunde@hadoop102 spark-standalone]$ cd conf

4）修改slave文件，添加work节点：

[chenyunde@hadoop102 conf]$ mv slaves.template slaves
[chenyunde@hadoop102 conf]$ vim slaves
hadoop102
hadoop103
hadoop104

5）修改spark-env.sh文件，添加master节点

[chenyunde@hadoop102 conf]$ mv spark-env.sh.template spark-env.sh
[chenyunde@hadoop102 conf]$ vim spark-env.sh

SPARK_MASTER_HOST=hadoop102
SPARK_MASTER_PORT=7077

6）分发spark-standalone包

[chenyunde@hadoop102 module]$ xsync spark-standalone/

7）启动spark集群

[chenyunde@hadoop102 spark-standalone]$ sbin/start-all.sh

查看三台服务器运行进程（xcall.sh是以前数仓项目里面讲的脚本）。

[chenyunde@hadoop102 spark-standalone]$ xcall.sh jps

注意：如果遇到 “JAVA_HOME not set” 异常，可以在sbin目录下的spark-config.sh 文件中加入如下配置。
export JAVA_HOME=XXXX
8）网页查看：hadoop102:8080（master web的端口，相当于yarn的8088端口）
目前还看不到任何任务的执行信息。
9）官方求PI案例
[chenyunde@hadoop102 spark-standalone]$ bin/spark-submit
–class org.apache.spark.examples.SparkPi
–master spark://hadoop102:7077
./examples/jars/spark-examples_2.12-3.0.0.jar
10
参数：–master spark://hadoop102:7077指定要连接的集群的master。
10）页面查看http://hadoop102:8080/，发现执行本次任务，默认采用三台服务器节点的总核数24核，每个节点内存1024M。
8080：master的webUI
4040：application的webUI的端口号

2.3.3 参数说明

1）配置Executor可用内存为2G，使用CPU核数为2个
[chenyunde@hadoop102 spark-standalone]$ bin/spark-submit
–class org.apache.spark.examples.SparkPi
–master spark://hadoop102:7077
–executor-memory 2G
–total-executor-cores 2
./examples/jars/spark-examples_2.12-3.0.0.jar
10
2）页面查看http://hadoop102:8080/

3）基本语法

bin/spark-submit \
--class class>
--master  \
... # other options
 \
[application-arguments]

4）参数说明

参数	解释	可选值举例
--class	Spark程序中包含主函数的类
--master	Spark程序运行的模式	本地模式：local[*]、spark://hadoop102:7077、Yarn
--executor-memory 1G	指定每个executor可用内存为1G	符合集群内存配置即可，具体情况具体分析。
--total-executor-cores 2	指定所有executor使用的cpu核数为2个
application-jar	打包好的应用jar，包含依赖。这个URL在集群中全局可见。 比如hdfs:// 共享存储系统，如果是file:// path，那么所有的节点的path都包含同样的jar
application-arguments	传给main()方法的参数

2.3.4 配置历史服务

由于spark-shell停止掉后，hadoop102:4040页面就看不到历史任务的运行情况，所以开发时都配置历史服务器记录任务运行情况。
1）修改spark-default.conf.template名称

[chenyunde@hadoop102 conf]$ mv spark-defaults.conf.template spark-defaults.conf

2）修改spark-default.conf文件，配置日志存储路径（写）

[chenyunde@hadoop102 conf]$ vim spark-defaults.conf
spark.eventLog.enabled true
spark.eventLog.dir hdfs://hadoop102:8020/sparklog

注意：需要启动Hadoop集群，HDFS上的目录需要提前存在。

[chenyunde@hadoop102 hadoop-3.1.3]$ sbin/start-dfs.sh
[chenyunde@hadoop102 hadoop-3.1.3]$ hadoop fs -mkdir /sparklog

3）修改spark-env.sh文件，添加如下配置：

[chenyunde@hadoop102 conf]$ vim spark-env.sh

export SPARK_HISTORY_OPTS="
-Dspark.history.ui.port=18080 
-Dspark.history.fs.logDirectory=hdfs://hadoop102:8020/sparklog 
-Dspark.history.retainedApplications=30"
# 参数1含义：WEBUI访问的端口号为18080
# 参数2含义：指定历史服务器日志存储路径（读）
# 参数3含义：指定保存Application历史记录的个数，如果超过这个值，旧的应用程序信息将被删除，这个是内存中的应用数，而不是页面上显示的应用数。

4）分发配置文件

[chenyunde@hadoop102 conf]$ xsync spark-defaults.conf spark-env.sh

5）启动历史服务

[chenyunde@hadoop102 spark-standalone]$ sbin/start-history-server.sh

6）再次执行任务

[chenyunde@hadoop102 spark-standalone]$ bin/spark-submit
–class org.apache.spark.examples.SparkPi
–master spark://hadoop102:7077
–executor-memory 1G
–total-executor-cores 2 \ ./examples/jars/spark-examples_2.12-3.0.0.jar \ 10

7）查看Spark历史服务地址：hadoop102:18080

2.3.5 配置高可用（HA）

1）高可用原理

所谓的高可用是因为当前集群中的Master节点只有一个，所以会存在单点故障问题。所以为了解决单点故障问题，需要在集群中配置多个Master节点，一旦处于活动状态的Master发生故障时，由备用Master提供服务，保证作业可以继续执行。这里的高可用一般采用Zookeeper设置

2）配置高可用
（0）停止集群
[chenyunde@hadoop102 spark-standalone]$ sbin/stop-all.sh
（1）Zookeeper正常安装并启动（基于以前讲的数仓项目脚本）

[chenyunde@hadoop102 zookeeper-3.4.10]$ zk.sh start

（2）修改spark-env.sh文件添加如下配置：

[chenyunde@hadoop102 conf]$ vim spark-env.sh

#注释掉如下内容：
#SPARK_MASTER_HOST=hadoop102
#SPARK_MASTER_PORT=7077

#添加上如下内容。配置由Zookeeper管理Master，在Zookeeper节点中自动创建/spark目录，用于管理：
export SPARK_DAEMON_JAVA_OPTS="
-Dspark.deploy.recoveryMode=ZOOKEEPER 
-Dspark.deploy.zookeeper.url=hadoop102,hadoop103,hadoop104 
-Dspark.deploy.zookeeper.dir=/spark"

#添加如下代码
#Zookeeper3.5的AdminServer默认端口是8080，和Spark的WebUI冲突
export SPARK_MASTER_WEBUI_PORT=8989

（3）分发配置文件

[chenyunde@hadoop102 conf]$ xsync spark-env.sh

（4）在hadoop102上启动全部节点

[chenyunde@hadoop102 spark-standalone]$ sbin/start-all.sh

（5）在hadoop103上单独启动master节点

[chenyunde@hadoop103 spark-standalone]$ sbin/start-master.sh

（6）在启动一个hadoop102窗口，将/opt/module/spark-local/input数据上传到hadoop集群的/input目录

[chenyunde@hadoop102 spark-standalone]$ hadoop fs -put
/opt/module/spark-local/input/ /input

（7）Spark HA集群访问

[chenyunde@hadoop102 spark-standalone]$ bin/spark-shell
–master spark://hadoop102:7077,hadoop103:7077
–executor-memory 2g
–total-executor-cores 2

参数：–master spark://hadoop102:7077指定要连接的集群的master。
注：一旦配置了高可用以后，master后面要连接多个master。
（8）执行WordCount程序

scala>sc.textFile("hdfs://hadoop102:8020/input").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect

res0: Array[(String, Int)] = Array((hello,4), (chenyunde,2), (spark,2))

2.3.6 运行流程

Spark有standalone-client和standalone-cluster两种模式，主要区别在于：Driver程序的运行节点。
1）客户端模式

[chenyunde@hadoop102 spark-standalone]$ bin/spark-submit
–class org.apache.spark.examples.SparkPi
–master spark://hadoop102:7077,hadoop103:7077
–executor-memory 2G
–total-executor-cores 2
–deploy-mode client \ ./examples/jars/spark-examples_2.12-3.0.0.jar \ 10

–deploy-mode client，表示Driver程序运行在本地客户端，默认模式。

2）集群模式模式

[chenyunde@hadoop102 spark-standalone]$ bin/spark-submit
–class org.apache.spark.examples.SparkPi
–master spark://hadoop102:7077,hadoop103:7077
–executor-memory 2G
–total-executor-cores 2
–deploy-mode cluster \ ./examples/jars/spark-examples_2.12-3.1.3.jar \ 10

–deploy-mode cluster，表示Driver程序运行在集群。

2.4 Yarn模式（重点）

Spark客户端直接连接Yarn，不需要额外构建Spark集群。

独立部署（Standalone）模式由Spark自身提供计算资源，无需其他框架提供资源。这种方式降低了和其他第三方资源框架的耦合性，独立性非常强。但是Spark主要是计算框架而不是资源调度框架，所以本身提供的资源调度并不是它的强项，所以还是和其他专业的资源调度框架集成会更靠谱一些。所以接下来我们学习在强大的Yarn环境下Spark是如何工作的（国内工作环境中Yarn使用的非常多）

2.4.1 安装使用

0）停止Standalone模式下的spark集群

[chenyunde@hadoop102 spark-standalone]$ sbin/stop-all.sh

[chenyunde@hadoop102 spark-standalone]$ zk.sh stop

[chenyunde@hadoop103 spark-standalone]$ sbin/stop-master.sh

1）为了防止和Standalone模式冲突，再单独解压一份spark

[chenyunde@hadoop102 software]$ tar -zxvf
spark-3.1.3-bin-hadoop3.2.tgz -C /opt/module/

2）进入到/opt/module目录，修改spark-3.1.3-bin-hadoop3.2名称为spark-yarn

[chenyunde@hadoop102 module]$ mv spark-3.1.3-bin-hadoop3.2/ spark-yarn

3）修改hadoop配置文件/opt/module/hadoop-3.1.3/etc/hadoop/yarn-site.xml，添加如下内容
因为测试环境虚拟机内存较少，防止执行过程进行被意外杀死，做如下配置

[chenyunde@hadoop102 hadoop]$ vim yarn-site.xml

<!--是否启动一个线程检查每个任务正使用的物理内存量，如果任务超出分配值，则直接将其杀掉，默认是true -->

     yarn.nodemanager.pmem-check-enabled</name>
     false</value>
</property>

<!--是否启动一个线程检查每个任务正使用的虚拟内存量，如果任务超出分配值，则直接将其杀掉，默认是true -->

     yarn.nodemanager.vmem-check-enabled</name>
     false</value>
</property>

4）分发配置文件

[chenyunde@hadoop102 conf]$ xsync /opt/module/hadoop-3.1.3/etc/hadoop/yarn-site.xml

5）修改/opt/module/spark-yarn/conf/spark-env.sh，添加YARN_CONF_DIR配置，保证后续运行任务的路径都变成集群路径

[chenyunde@hadoop102 conf]$ mv spark-env.sh.template spark-env.sh

[chenyunde@hadoop102 conf]$ vim spark-env.sh

YARN_CONF_DIR=/opt/module/hadoop-3.1.3/etc/hadoop

6）启动HDFS以及YARN集群

[chenyunde@hadoop102 hadoop-3.1.3]$ sbin/start-dfs.sh

[chenyunde@hadoop103 hadoop-3.1.3]$ sbin/start-yarn.sh

7）执行一个程序

[chenyunde@hadoop102 spark-yarn]$ bin/spark-submit --class org.apache.spark.examples.SparkPi --master yarn ./examples/jars/spark-examples_2.12-3.0.0.jar 10

参数：–master yarn，表示Yarn方式运行；–deploy-mode表示客户端方式运行程序
8）查看hadoop103:8088页面，点击History，查看历史页面
思考：目前是Hadoop的作业运行日志展示，如果想获取Spark的作业运行日志，怎么办？

2.4.2 配置历史服务

由于是重新解压的Spark压缩文件，所以需要针对Yarn模式，再次配置一下历史服务器。
1）修改spark-default.conf.template名称

[chenyunde@hadoop102 conf]$ mv spark-defaults.conf.template
spark-defaults.conf

2）修改spark-default.conf文件，配置日志存储路径（写）

[chenyunde@hadoop102 conf]$ vim spark-defaults.conf

spark.eventLog.enabled          true
spark.eventLog.dir               hdfs://hadoop102:8020/sparklog 

3）修改spark-env.sh文件，添加如下配置：

[chenyunde@hadoop102 conf]$ vim spark-env.sh

export SPARK_HISTORY_OPTS="
-Dspark.history.ui.port=18080 
-Dspark.history.fs.logDirectory=hdfs://hadoop102:8020/sparklog 
-Dspark.history.retainedApplications=30"


# 参数1含义：WEBUI访问的端口号为18080
# 参数2含义：指定历史服务器日志存储路径（读）
# 参数3含义：指定保存Application历史记录的个数，如果超过这个值，旧的应用程序信息将被删除，这个是内存中的应用数，而不是页面上显示的应用数。

2.4.3 配置查看历史日志

为了能从Yarn上关联到Spark历史服务器，需要配置spark历史服务器关联路径。
目的：点击yarn（8088）上spark任务的history按钮，进入的是spark历史服务器（18080），而不再是yarn历史服务器（19888）。
1）修改配置文件/opt/module/spark-yarn/conf/spark-defaults.conf
添加如下内容：

spark.yarn.historyServer.address=hadoop102:18080
spark.history.ui.port=18080

2）重启Spark历史服务

[chenyunde@hadoop102 spark-yarn]$ sbin/stop-history-server.sh

[chenyunde@hadoop102 spark-yarn]$ sbin/start-history-server.sh

3）提交任务到Yarn执行

[chenyunde@hadoop102 spark-yarn]$ bin/spark-submit --class org.apache.spark.examples.SparkPi --master yarn ./examples/jars/spark-examples_2.12-3.1.3.jar 10

4）Web页面查看日志：http://hadoop103:8088/cluster

点击“history”跳转到http://hadoop102:18080/

2.4.4 运行流程

Spark有yarn-client和yarn-cluster两种模式，主要区别在于：Driver程序的运行节点。
yarn-client：Driver程序运行在客户端，适用于交互、调试，希望立即看到app的输出。
yarn-cluster：Driver程序运行在由ResourceManager启动的APPMaster，适用于生产环境。
1）客户端模式（默认）

[chenyunde@hadoop102 spark-yarn]$ bin/spark-submit --class org.apache.spark.examples.SparkPi --master yarn --deploy-mode client ./examples/jars/spark-examples_2.12-3.1.3.jar 10

2）集群模式
[chenyunde@hadoop102 spark-yarn]$ bin/spark-submit --class org.apache.spark.examples.SparkPi --master yarn --deploy-mode cluster ./examples/jars/spark-examples_2.12-3.1.3.jar 10
（1）查看http://hadoop103:8088/cluster页面，点击History按钮，跳转到历史详情页面

（2）http://hadoop102:18080点击Executors->点击driver中的stdout

注意：如果在yarn日志端无法查看到具体的日志，则在yarn-site.xml中添加如下配置并启动Yarn历史服务器

yarn.log.server.url http://hadoop102:19888/jobhistory/logs

注意：hadoop历史服务器也要启动 mr-jobhistory-daemon.sh start historyserver

2.5 Mesos模式（了解）

Spark客户端直接连接Mesos；不需要额外构建Spark集群。国内应用比较少，更多的是运用Yarn调度。

2.6 几种部署模式对比

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

2.7 端口号总结

1）Spark查看当前Spark-shell运行任务情况端口号：4040
2）Spark Master内部通信服务端口号：7077 （类比于yarn的8032(RM和NM的内部通信)端口）
3）Spark Standalone模式Master Web端口号：8080（类比于Hadoop YARN任务运行情况查看端口号：8088）
4）Spark历史服务器端口号：18080 （类比于Hadoop历史服务器端口号：19888）

第3章 Spark 运行架构

3.1 运行架构

Spark 框架的核心是一个计算引擎，整体来说，它采用了标准 master-slave 的结构。 如下图所示，它展示了一个 Spark 执行时的基本结构。图形中的 Driver 表示 master，
负责管理整个集群中的作业任务调度。图形中的 Executor 则是 slave，负责实际执行任务。

3.2 核心组件

由上图可以看出，对于 Spark 框架有两个核心组件：

3.2.1 Driver

Spark 驱动器节点，用于执行 Spark 任务中的 main 方法，负责实际代码的执行工作。
Driver 在 Spark 作业执行时主要负责：
➢ 将用户程序转化为作业（job） ➢ 在 Executor 之间调度任务(task)
➢ 跟踪 Executor 的执行情况
➢ 通过 UI 展示查询运行情况
实际上，我们无法准确地描述 Driver 的定义，因为在整个的编程过程中没有看到任何有关
Driver 的字眼。所以简单理解，所谓的 Driver 就是驱使整个应用运行起来的程序，也称之为
Driver 类。

3.2.2 Executor

Spark Executor 是集群中工作节点（Worker）中的一个 JVM 进程，负责在 Spark 作业
中运行具体任务（Task），任务彼此之间相互独立。Spark 应用启动时，Executor 节点被同时启动，并且始终伴随着整个 Spark 应用的生命周期而存在。如果有 Executor 节点发生了
故障或崩溃，Spark 应用也可以继续执行，会将出错节点上的任务调度到其他 Executor 节点
上继续运行。
Executor 有两个核心功能：
➢ 负责运行组成 Spark 应用的任务，并将结果返回给驱动器进程
➢ 它们通过自身的块管理器（Block Manager）为用户程序中要求缓存的 RDD 提供内存
式存储。RDD 是直接缓存在 Executor 进程内的，因此任务可以在运行时充分利用缓存
数据加速运算。

3.2.3 Master & Worker

Spark 集群的独立部署环境中，不需要依赖其他的资源调度框架，自身就实现了资源调
度的功能，所以环境中还有其他两个核心组件：Master 和 Worker，这里的 Master 是一个进
程，主要负责资源的调度和分配，并进行集群的监控等职责，类似于 Yarn 环境中的 RM, 而
Worker 呢，也是进程，一个 Worker 运行在集群中的一台服务器上，由 Master 分配资源对
数据进行并行的处理和计算，类似于 Yarn 环境中 NM。 4.2.4 ApplicationMaster
Hadoop 用户向 YARN 集群提交应用程序时,提交程序中应该包含 ApplicationMaster，用
于向资源调度器申请执行任务的资源容器 Container，运行用户自己的程序任务 job，监控整
个任务的执行，跟踪整个任务的状态，处理任务失败等异常情况。
说的简单点就是，ResourceManager（资源）和 Driver（计算）之间的解耦合靠的就是
ApplicationMaster。

3.3 核心概念

3.3.1 Executor 与 Core

Spark Executor 是集群中运行在工作节点（Worker）中的一个 JVM 进程，是整个集群中
的专门用于计算的节点。在提交应用中，可以提供参数指定计算节点的个数，以及对应的资
源。这里的资源一般指的是工作节点 Executor 的内存大小和使用的虚拟 CPU 核（Core）数
量。
应用程序相关启动参数如下：
名称 说明
–num-executors 配置 Executor 的数量
–executor-memory 配置每个 Executor 的内存大小
–executor-cores 配置每个 Executor 的虚拟 CPU core 数量

未完待续