SparkCore

SparkCore

1. 认识Spark

官网地址 http://spark.apache.org/添加链接描述

  Spark是一种快速、通用、可扩展的大数据分析引擎，2009年诞生于加州大学伯克利分校AMPLab，2010年开源，2013年6月成为Apache孵化项目，2014年2月成为Apache顶级项目。项目是用Scala进行编写。
  2014年5月，Spark 1.0.0发布。
  2016年1月，Spark 1.6.0发布。
  2016年7月，Spark 2.0.0发布。
  2020年6月，Spark 3.0.0发布。
  截止2020年1月，1.x最终版本为1.6.3，2.x最后一个维护版本为2.4.8，3.x最新版本为3.2.0。

  Spark 官网将Spark 定义为一个大型可扩展数据的快速和通用处理引擎。

  首先，Spark 采用了先进的DAG执行引擎，支持循环数据流和内存计算，使得 Spark 速度更快，在内存中的速度是Hadoop MR的百倍，在磁盘上的速度是Hadoop MR的十倍(官网数据) 。
  其次，Spark 是一个通用的处理引擎， 被设计用来做批处理、迭代运算、交互式查询、流处理、机器学习等。
  另外，Spark “易用”，可以用Scala、Java、Python、R等开发分布式应用，Spark 提供了大量高级API，方便开发。
  最后，Spark 集成了多种数据源，并且可以通过local、Yarn、Mesos、Standalone（Spark 提供的部署方式）等各种模式运行。

2. Hadoop与Spark的关系及区别

2.1框架比较

	hadoop（MR）	spark
起源	2005	2009
起源地	MapReduce (Google) Hadoop (Yahoo)	University of California, Berkeley
数据处理引擎	Batch	Batch
处理	Slower than Spark and Flink	100x Faster than Hadoop
编程语言	Java, C, C++, Ruby, Groovy, Perl, Python	Java, Scala, python and R
编程模型	MapReduce	Resilient distributed Datasets (RDD)
Data Transfer	Batch	Batch
内存管理	Disk Based	JVM Managed
延迟	HIgh	Medium
吞吐量	Medium	High
优化机制	Manual	Manual
API	Low-level	High-level
流处理支持	NA	Spark Streaming/StructedStreaming
SQL支持	Hive, Impala	SparkSQL
Graph 支持	NA	GraphX
机器学习支持	NA	SparkML

2.2 处理流程比较

MR中的迭代:

Spark中的迭代:

总结：

1、Spark把运算的中间数据存放在内存，迭代计算效率更高；MapReduce的中间结果需要落地，需要保存到磁盘，这样必然会有磁盘io操做，影响性能。

2、Spark容错性高，它通过弹性分布式数据集RDD来实现高效容错，RDD是一组分布式的存储在节点内存中的只读性质的数据集，这些集合是弹性的，某一部分丢失或者出错，可以通过整个数据集的计算流程的血缘关系来实现重建；MapReduce的话容错可能只能重新计算了，成本较高。

3、Spark更加通用，spark提供了transformation和action这两大类的多个功能api，另外还有流式处理Spark Streaming模块、图计算GraphX等等；MapReduce只提供了map和reduce两种操作，流计算以及其他模块的支持比较缺乏。

4、Spark框架和生态更为复杂，首先有RDD、血缘lineage、执行时的有向无环图DAG、stage划分等等，很多时候spark作业都需要根据不同业务场景的需要进行调优已达到性能要求；MapReduce框架及其生态相对较为简单，对性能的要求也相对较弱，但是运行较为稳定，适合长期后台运行。

3. Spark 组件

Spark Core

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

Spark SQL

是 Spark 用来操作结构化数据的程序包。通过 Spark SQL，我们可以使用 SQL 或者 Apache Hive 版本的 SQL 方言(HQL)来查询数据。Spark SQL 支持多种数据源，比 如 Hive 表、Parquet 以及 JSON 等。

Spark Streaming

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

Spark MLlib

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

Spark GraphX

GraphX在Spark基础上提供了一站式的数据解决方案，可以高效地完成图计算的完整流水作业。GraphX是用于图计算和并行图计算的新的（alpha）Spark API。通过引入弹性分布式属性图（Resilient Distributed Property Graph），一种顶点和边都带有属性的有向多重图，扩展了Spark RDD。

Structured Streaming（2.X版本）

结构化流是构建在sparksql引擎上的可伸缩且容错的流处理引擎。在内部，默认情况下，结构化流式处理查询使用微批处理引擎进行处理，该引擎将数据流作为一系列小批处理作业进行处理，从而实现低至100毫秒的端到端延迟，并且只保证一次容错。

4. Spark特点

快

与Hadoop的MapReduce相比，Spark基于内存的运算要快100倍以上，基于硬盘的运算也要快10倍以上。Spark实现了高效的DAG执行引擎，可以通过基于内存来高效处理数据流。

易用

Spark支持Java、Python和Scala的API，还支持超过80种高级算法，使用户可以快速构建不同的应用。而且Spark支持交互式的Python和Scala的shell，可以非常方便地在这些shell中使用Spark集群来验证解决问题的方法。

通用

Spark提供了统一的解决方案。Spark可以用于批处理、交互式查询（Spark SQL）、实时流处理（Spark Streaming）、机器学习（Spark MLlib）和图计算（GraphX）。这些不同类型的处理都可以在同一个应用中无缝使用。Spark统一的解决方案非常具有吸引力，毕竟任何公司都想用统一的平台去处理遇到的问题，减少开发和维护的人力成本和部署平台的物力成本。

兼容性

Spark可以非常方便地与其他的开源产品进行融合。比如，Spark可以使用Hadoop的YARN和Apache Mesos作为它的资源管理和调度器，器，并且可以处理所有Hadoop支持的数据，包括HDFS、HBase和Cassandra等。这对于已经部署Hadoop集群的用户特别重要，因为不需要做任何数据迁移就可以使用Spark的强大处理能力。Spark也可以不依赖于第三方的资源管理和调度器，它实现了Standalone作为其内置的资源管理和调度框架，这样进一步降低了Spark的使用门槛，使得所有人都可以非常容易地部署和使用Spark。此外，Spark还提供了在EC2上部署Standalone的Spark集群的工具。

5. Spark 部署

5.1 Spark集群部署

5.1.1 Spark部署模式

Local 多用于本地测试，如在eclipse，idea中写程序测试等。

Standalone 是Spark自带的一个资源调度框架，它支持完全分布式。

**Yarn **生态圈里面的一个资源调度框架，Spark也是可以基于Yarn来计算的。

Mesos 资源调度框架，与Yarn类似。

5.1.2 环境准备

环境预准备，至少三台机器互通互联，免密登录，时间同步，安装好JDK1.8。

安装包下载：

注意：Spark 3.1.2需要的Hadoop环境建议是3.2(含)版本以上

其他下载方式：

http://archive.apache.org/dist

https://github.com/apache/spark

4.1.3 Standalone模式

Spark自身节点运行的集群模式，也就是我们所谓的独立部署（Standalone）模式。Spark的Standalone模式体现了经典的master-slave模式。

集群规划：

基本条件:同步时间、免密登录、关闭防火墙、安装JDK1.8

	qf01	qf02	qf03
spark	Master Worker	Worker	Worker

1)解压缩文件

将spark-3.1.2-bin-hadoop3.2.tgz文件上传到qianfeng01并解压缩在指定位置

tar -zxvf spark-3.0.0-bin-hadoop3.2.tgz -C /usr/local

2)修改配置文件

2.1) 进入解压缩后路径的conf目录，修改workers.template文件名为workers

mv workers.template workers

2.2) 修改workers文件，添加worker节点

qf01
qf02
qf03

2.3) 修改spark-env.sh.template文件名为spark-env.sh

mv spark-env.sh.template spark-env.sh

2.4) 修改spark-env.sh文件，添加JAVA_HOME环境变量和集群对应的master节点

export JAVA_HOME=/usr/local/jdk1.8.0_291
SPARK_MASTER_HOST=qf01
SPARK_MASTER_PORT=7077

注意：7077端口，相当于hadoop3内部通信的9820端口，此处的端口需要确认自己的Hadoop配置

3)分发配置好的内容到其他节点

scp -r /usr/local/spark-3.1.2-bin-hadoop3.2/ root@qf02:$PWD
scp -r /usr/local/spark-3.1.2-bin-hadoop3.2/ root@qf03:$PWD

spark启动集群:
进入到安装目录找sbin目录进入 /usr/local/spark-3.1.2-bin-hadoop3.2
启动 ./start-all.sh
spark提供webUI界面端口是一样8080或8081 内部通信7077

http://qf01:8080 或 http://qf01:8081

集群架构

5.1.4 配置Job History Server

由于spark-shell停止掉后，集群监控qf01:4040页面就看不到历史任务的运行情况，所以开发时都配置历史服务器记录任务运行情况。

1. 修改spark-defaults.conf.template文件名为spark-defaults.conf

mv spark-defaults.conf.template spark-defaults.conf

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

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

hdfs dfs -mkdir /directory

spark.eventLog.enabled      true
spark.eventLog.dir       hdfs://qf01:9820/directory

3. 修改spark-env.sh文件, 添加日志配置

export SPARK_HISTORY_OPTS="
-Dspark.history.ui.port=18080 
-Dspark.history.fs.logDirectory=hdfs://qf01:9820/directory 
-Dspark.history.retainedApplications=30"

参数1含义：WEB UI访问的端口号为18080

参数2含义：指定历史服务器日志存储路径

参数3含义：指定保存Application历史记录的个数，如果超过这个值，旧的应用程序信息将被删除，这个是内存中的应用数，而不是页面上显示的应用数。

注意：上述配置历史服务器是非HA模式的Hadoop提供配置操作如果是HA模式的hadoop需要将qianfeng01替换成supercluster（hadoop-3.3.1/etc/hadoop/hdfs-site.xml 中dfs.nameservices配置的值），不需要指定端口

spark.eventLog.dir     hdfs://supercluster/directory
---------------------------------------------------------
export SPARK_HISTORY_OPTS="
-Dspark.history.ui.port=18080 
-Dspark.history.fs.logDirectory=hdfs://supercluster/directory 
-Dspark.history.retainedApplications=30"

4. 分发配置文件

scp -r /usr/local/spark-3.1.2-bin-hadoop3.2/conf root@qf02:$PWD
scp -r /usr/local/spark-3.1.2-bin-hadoop3.2/conf root@qf03:$PWD

5. 重新启动集群和历史服务

sbin/start-all.sh
sbin/start-history-server.sh

6. 重新执行任务

spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://qf01:7077 \
/usr/local/spark-standalone/examples/jars/spark-examples_2.12-3.1.2.jar \
10

7. 查看历史服务：http://qf:18080

5.1.5 配置高可用（HA）【选配】

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

集群规划：

	qf01	qf02	qf03
spark	Master Worker	Master Worker	Worker

1. 停止集群

sbin/stop-all.sh 
如果启动历史服务器也要停止stop-history-server.sh

2. 启动Zookeeper

zkServer.sh start

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

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

添加如下内容:
#Master监控页面默认访问端口为8080，但是可能会和Zookeeper冲突，所以改成8676，也可以自定义，访问UI监控页面时请注意
SPARK_MASTER_WEBUI_PORT=8676
export SPARK_DAEMON_JAVA_OPTS="
-Dspark.deploy.recoveryMode=ZOOKEEPER 
-Dspark.deploy.zookeeper.url=qf01,qf02,qf03 
-Dspark.deploy.zookeeper.dir=/spark"

4. 分发配置文件

scp -r /usr/local/spark-3.1.2-bin-hadoop3.2/conf root@qf02:$PWD
scp -r /usr/local/spark-3.1.2-bin-hadoop3.2/conf root@qf03:$PWD

5. 启动集群

sbin/start-all.sh 

6. 启动qf02的单独Master节点，此时qf02节点Master状态处于备用状态

sbin/start-master.sh 

7. 提交应用到高可用集群

spark-submit \
--class org.apache.spark.examples.SparkPi 
--master spark://qf01:7077,qf02:7077 \
/usr/local/spark-standalone/examples/jars/spark-examples_2.12-3.1.2.jar \
10

需要注意：提交的时候需要将master节点都写出

5.2 Yarn 模式

需要注意：配置yarn的文件中不要保留标签和队列，容易造成后续提交到Yarn中无法执行的效果，队列可以保留但是内存给的足够到时没有什么问题

独立部署（Standalone）模式由Spark自身提供计算资源，无需其他框架提供资源。这种方式降低了和其他第三方资源框架的耦合性，独立性非常强。Spark主要是计算框架，而不是资源调度框架，所以本身提供的资源调度并不是它的强项,所以可以使用Hadoop生态中Yarn进行资源调度操作

5.2.1 集群搭建

1)将spark-3.1.2-bin-hadoop3.2.tgz文件上传到qf01并解压缩在指定位置

tar -zxvf spark-3.0.0-bin-hadoop3.2.tgz -C /usr/local

2)修改hadoop中的配置文件/usr/local/hadoop-3.3.1/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>

分发到不同的节点

scp /usr/local/hadoop-3.3.1/etc/hadoop/yarn-site.xml root@qf02:$PWD
scp /usr/local/hadoop-3.3.1/etc/hadoop/yarn-site.xml root@qf03:$PWD

3. 进入解压缩后路径的conf目录，修改workers.template文件名为workers

修改spark-env.sh.template文件名为spark-env.sh

修改spark-defaults.conf.template文件名为spark-defaults.conf

mv workers.template workers
mv spark-env.sh.template spark-env.sh
mv spark-defaults.conf.template spark-defaults.conf

workers文件中添加

qf01
qf02
qf03

spark-env.sh文件中添加

export JAVA_HOME=/usr/local/jdk1.8.0_291
HADOOP_CONF_DIR=/usr/local/hadoop-3.3.1/etc/hadoop
YARN_CONF_DIR=/usr/local/hadoop-3.3.1/etc/hadoop
export SPARK_HISTORY_OPTS="
-Dspark.history.ui.port=18080 
-Dspark.history.fs.logDirectory=hdfs://qf01:9820/directory 
-Dspark.history.retainedApplications=30"

spark-defaults.conf文件中添加

spark.eventLog.enabled      true
spark.eventLog.dir       hdfs://qf01:9820/directory
spark.yarn.historyServer.address=qf01:18080
spark.history.ui.port=18080

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

start-dfs.sh
hdfs dfs -mkdir /directory

注意：上述配置历史服务器是非HA模式的Hadoop提供配置操作如果是HA模式的hadoop需要将qf01替换成supercluster（hadoop-3.3.1/etc/hadoop/hdfs-site.xml 中dfs.nameservices配置的值），不需要指定端口

spark.eventLog.dir     hdfs://supercluster/directory
---------------------------------------------------------
export SPARK_HISTORY_OPTS="
-Dspark.history.ui.port=18080 
-Dspark.history.fs.logDirectory=hdfs://supercluster/directory 
-Dspark.history.retainedApplications=30"

分发到不同的节点

scp -r /usr/local/spark-3.1.2-bin-hadoop3.2/ root@qf02:$PWD
scp -r /usr/local/spark-3.1.2-bin-hadoop3.2/ root@qf03:$PWD

启动集群

先启动zkServer.sh start
再起启动 start-all.sh  
       --》等价于 start-dfs.sh 和 start-yarn.sh
注意：请确保resourcemanager的正确启动
再启动spark-->sbin目录下执行 
./start-all.sh
./start-history-server.sh 

5.3 Spark作业提交原理

Spark作业（任务）提交就是使用spark中spark-sumbit命令将已经封装好成jar包的程序提交到spark集群中执行运行从而得到计算结果的过程，在提交过程中我们对提交的作业（任务）进行参数设置操作

spark提交作业的语法

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

参数	解释
–class	Spark程序中包含主函数的类 【必要】
–master	Spark程序运行的模式(环境) 【必要】
–deploy-mode	master设为为Yarn模式之后，使用的模式client 和 cluster 【如果指定Yarn模式 必要】
–driver-cores	master设为为Yarn模式之后，设置driver端的的cores个数
–driver-memory	master设为为Yarn模式之后，用于设置driver进程的内存（单位G或单位M）
–num-executors	master设为为Yarn模式之后，用于设置Spark作业总共要用多少个Executor进程来执行
–executor-memory	指定每个executor可用内存（单位G或单位M）
–total-executor-cores 2	指定所有executor使用的cpu核数为2个
–executor-cores	指定每个executor使用的cpu核数
application-jar	打包好的应用jar，包含依赖。这个URL在集群中全局可见。 比如hdfs:// 共享存储系统，如果是file:// path，那么所有的节点的path都包含同样的jar 【必要】
application-arguments	传给main()方法的参数 【必要】

5.3.1 spark提交作业方式（Standalone模式）

提交Spark提供的利用蒙特·卡罗算法求π的例子，其中100这个参数是计算因子

bin/spark-submit \
> --class org.apache.spark.examples.SparkPi \
> --master spark://qf01:7077 \
> --executor-memory 512m \
> --total-executor-cores 2 \
> /usr/local/spark-3.1.2-bin-hadoop3.2/examples/jars/spark-examples_2.12-3.1.2.jar 100

注意:在启动任务的时候并没有指定分配资源,而是有多少资源就使用了多少资源我们在跑任务的时候是可以指定资源的,可以在指定使用核数和内存资源

提交执行原理图

Standalone模式下存在的角色:

Client：客户端进程，负责提交作业到Master。

Master：Standalone模式中主控节点，负责接收Client提交的作业，管理Worker，并命令Worker启动Driver和Executor。

Worker：Standalone模式中slave节点上的守护进程，负责管理本节点的资源，定期向Master汇报心跳，接收Master的命令，启动Executor。

Driver： 一个Spark作业运行时包括一个Driver进程，也是作业的主进程，负责作业的解析、生成Stage并调度Task到Executor上。包括DAGScheduler，TaskScheduler。

Executor：即真正执行作业的地方，一个集群一般包含多个Executor，每个Executor接收Driver的命令Launch Task，一个Executor可以执行一到多个Task。

2.作业相关的名词解释

Stage：一个Spark作业一般包含一到多个Stage。

Task：一个Stage包含一到多个Task，通过多个Task实现并行运行的功能。

DAGScheduler： 实现将Spark作业分解成一到多个Stage，每个Stage根据RDD的Partition个数决定Task的个数，然后生成相应的Task set放到TaskScheduler中。

TaskScheduler：实现Task分配到Executor上执行

5.3.2 spark提交作业方式（YARN-client模式）

提交Spark提供的利用蒙特·卡罗算法求π的例子，其中100这个参数是计算因子

bin/spark-submit \
> --class org.apache.spark.examples.SparkPi \
> --master yarn \
> --deploy-mode client \ 
> --driver-cores 1 \
> --driver-memory 600M \ 
> --executor-memory 800M \ 
> --executor-cores 2  \
> /usr/local/spark-3.1.2-bin-hadoop3.2/examples/jars/spark-examples_2.12-3.1.2.jar 100

注意:在启动任务的时候并没有指定分配资源,而是有多少资源就使用了多少资源我们在跑任务的时候是可以指定资源的,可以在指定使用核数和内存资源

提交执行原理图

• 1. Spark Yarn Client向YARN的ResourceManager申请启动Application Master。同时在SparkContent初始化中将创建DAGScheduler和TASKScheduler等，由于我们选择的是Yarn-Client模式，程序会选择YarnClientClusterScheduler和YarnClientSchedulerBackend
• 2. ResourceManager收到请求后，在集群中选择一个NodeManager，为该应用程序分配第一个Container，要求它在这个Container中启动应用程序的ApplicationMaster，与YARN-Cluster区别的是在该ApplicationMaster不运行SparkContext，只与SparkContext进行联系进行资源的分派
• 3. Client中的SparkContext初始化完毕后，与ApplicationMaster建立通讯，向ResourceManager注册，根据任务信息向ResourceManager申请资源（Container）
• 4. 一旦ApplicationMaster申请到资源（也就是Container）后，便与对应的NodeManager通信，要求它在获得的Container中启动CoarseGrainedExecutorBackend，CoarseGrainedExecutorBackend启动后会向Client中的SparkContext注册并申请Task
• 5. client中的SparkContext分配Task给CoarseGrainedExecutorBackend执行，CoarseGrainedExecutorBackend运行Task并向Driver汇报运行的状态和进度，以让Client随时掌握各个任务的运行状态，从而可以在任务失败时重新启动任务
• 6. 应用程序运行完成后，Client的SparkContext向ResourceManager申请注销并关闭自己

  客户端的Driver将应用提交给Yarn后，Yarn会先后启动ApplicationMaster和executor，另外ApplicationMaster和executor都 是装载在container里运行，container默认的内存是1G，ApplicationMaster分配的内存是driver- memory，executor分配的内存是executor-memory。同时，因为Driver在客户端，所以程序的运行结果可以在客户端显 示，Driver以进程名为SparkSubmit的形式存在。

  注意：因为是与Client端通信，所以Client不能关闭。

5.3.3 spark提交作业方式（YARN-Cluster模式）

提交Spark提供的利用蒙特·卡罗算法求π的例子，其中100这个参数是计算因子

bin/spark-submit \
> --class org.apache.spark.examples.SparkPi \
> --master yarn \
> --deploy-mode cluster \ 
> --driver-cores 1 \
> --driver-memory 600M \ 
> --executor-memory 800M \ 
> --executor-cores 2  \
> /usr/local/spark-3.1.2-bin-hadoop3.2/examples/jars/spark-examples_2.12-3.1.2.jar 100

注意:在启动任务的时候并没有指定分配资源,而是有多少资源就使用了多少资源我们在跑任务的时候是可以指定资源的,可以在指定使用核数和内存资源

提交执行原理图

• 1. Spark Yarn Client向YARN中提交应用程序，包括ApplicationMaster程序、启动ApplicationMaster的命令、需要在Executor中运行的程序等
• 2. ResourceManager收到请求后，在集群中选择一个NodeManager，为该应用程序分配第一个Container，要求它在这个Container中启动应用程序的ApplicationMaster，其中ApplicationMaster进行SparkContext等的初始化
• 3. ApplicationMaster向ResourceManager注册，这样用户可以直接通过ResourceManage查看应用程序的运行状态，然后它将采用轮询的方式通过RPC协议为各个任务申请资源，并监控它们的运行状态直到运行结束
• 4. 一旦ApplicationMaster申请到资源（也就是Container）后，便与对应的NodeManager通信，要求它在获得的Container中启动CoarseGrainedExecutorBackend，而Executor对象的创建及维护是由CoarseGrainedExecutorBackend负责的，CoarseGrainedExecutorBackend启动后会向ApplicationMaster中的SparkContext注册并申请Task。这一点和Standalone模式一样，只不过SparkContext在Spark Application中初始化时，使用CoarseGrainedSchedulerBackend配合YarnClusterScheduler进行任务的调度，其中YarnClusterScheduler只是对TaskSchedulerImpl的一个简单包装，增加了对Executor的等待逻辑等
• 5. ApplicationMaster中的SparkContext分配Task给CoarseGrainedExecutorBackend执行，CoarseGrainedExecutorBackend运行Task并向ApplicationMaster汇报运行的状态和进度，以让ApplicationMaster随时掌握各个任务的运行状态，从而可以在任务失败时重新启动任务
• 6. 应用程序运行完成后，ApplicationMaster向ResourceManager申请注销并关闭自己

5.3.4 YARN-Cluster和YARN-Client的区别

• 理解YARN-Client和YARN-Cluster深层次的区别之前先清楚一个概念：Application Master。在YARN中，每个Application实例都有一个ApplicationMaster进程，它是Application启动的第一个容器。它负责和ResourceManager打交道并请求资源，获取资源之后告诉NodeManager为其启动Container。从深层次的含义讲YARN-Cluster和YARN-Client模式的区别其实就是ApplicationMaster进程的区别
• YARN-Cluster模式下，Driver运行在AM(Application Master)中，它负责向YARN申请资源，并监督作业的运行状况。当用户提交了作业之后，就可以关掉Client，作业会继续在YARN上运行，因而YARN-Cluster模式不适合运行交互类型的作业
• YARN-Client模式下，Application Master仅仅向YARN请求Executor，Client会和请求的Container通信来调度他们工作，也就是说Client不能离开

总结：

（1）Yarn-Cluster的Driver是在集群的某一台NM上，但是Yarn-Client就是在RM的机器上；
（2）Driver会和Executors进行通信，所以Yarn_Cluster在提交App之后可以关闭Client，而Yarn-Client不可以；
（3）Yarn-Cluster适合生产环境，Yarn-Client适合交互和调试。

5.4 SparkShell

spark-shell是Spark自带的交互式Shell程序，方便用户进行交互式编程，用户可以在该命令行下用Scala编写Spark程序。

spark-shell程序一般用作Spark程序【测试练习】来用。spark-shell属于Spark的特殊应用程序，我们可以在这个特殊的应用程序中提交应用程序

spark-shell启动有两种模式，local模式和cluster模式。

5.4.1 Local模式

spark-shell 

local模式仅在本机启动一个SparkSubmit进程，没有与集群建立联系,虽然进程中有SparkSubmit但是不会被提交到集群

5.4.2 Cluster模式(集群模式)

spark-shell \
--master spark://qf01:7077

5.4.3 Yarn模式（YARN-client模式）

spark-shell \
--master yarn

注意，这里的–master必须使用yarn-client模式，不是yarn-cluster因为spark-shell作为一个与用户交互的命令行

总结：

1.spark-shell会创建两个对象：sc和spark，分别表示两个重要的上下文环境：SparkContext和SparkSession。
2.master=local[ * ]*表示运行在Local模式，[ * ]*表示CPU的核心数量
3.spark-shell模式会启用WebUI端口4040，如果同一时间启动多个spark-shell，该端口依次递增

5.4.4 退出spark-shell

正确退出 :quit 千万不要ctrl+c退出，这样是错误的。若使用了ctrl+c退出，使用命令查看监听端口：

netstat -apn | grep 4040

再使用kill -9 端口号 杀死进程。