1 Spark概述
Spark是一种基于内存的快速、通用、可扩展的大数据分析计算引擎。
1.1 Hadoop & Spark
- 时间节点对比:
2013年10月发布2.X (Yarn)版本;2013年6月,Spark成为了Apache基金会下的项目
- 功能对比:
Hadoop是由java语言编写的;Spark是由scala语言编写的
- Spark和Hadoop的根本差异是多个作业之间的数据通信问题 :
Spark多个作业之间数据通信是基于内存,而Hadoop是基于磁盘。
1.2 Spark核心模块
- Spark Core
提供了Spark最基础最核心的功能,Spark其他的功能如:Spark SQL,Spark Streaming,GraphX, MLlib都是在Spark Core的基础上进行扩展的
- Spark SQL
Spark SQL是Spark用来操作结构化数据的组件。通过Spark SQL,用户可以使用SQL或者Apache Hive版本的SQL方言(HQL)来查询数据。
- Spark Streaming
Spark Streaming是Spark平台上针对实时数据进行流式计算的组件,提供了丰富的处理数据流的API
- Spark MLlib
MLlib是Spark提供的一个机器学习算法库。MLlib不仅提供了模型评估、数据导入等额外的功能,还提供了一些更底层的机器学习原语。
- Spark GraphX
GraphX是Spark面向图计算提供的框架与算法库。
2 Spark入门
2.1 创建Maven项目
步骤1:增加Scala插件
Scala版本:2.12
Spark版本:3.0.0
步骤2:增加pom依赖
<dependencies>
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.12</artifactId>
<version>3.0.0</version>
</dependency>
</dependencies>
<build>
<plugins>
<!-- 该插件用于将Scala代码编译成class文件 -->
<plugin>
<groupId>net.alchim31.maven</groupId>
<artifactId>scala-maven-plugin</artifactId>
<version>3.2.2</version>
<executions>
<execution>
<!-- 声明绑定到maven的compile阶段 -->
<goals>
<goal>testCompile</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<version>3.1.0</version>
<configuration>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
2.2 案例WordCount
object WordCount1 {
def main(args: Array[String]): Unit = {
//步骤1:创建SparkConf,spark运行环境对象,设置Master、设置AppName
val conf: SparkConf = new SparkConf().setMaster("local").setAppName("WordCount")
//步骤2:创建SparkContext上下文环境对象
val sc: SparkContext = new SparkContext(conf)
//步骤3:读取数据文件
val lines: RDD[String] = sc.textFile("input/word.txt")
//步骤4:切割一行一行的数据,为一个一个的单词,扁平化
val words: RDD[String] = lines.flatMap(_.split(" "))
//步骤5:根据word分组
val groupRDD: RDD[(String, Iterable[String])] = words.groupBy(word => word)
//步骤6:统计各个单词的数量
val countRDD: RDD[(String, Int)] = groupRDD.map {
case (word, list) => (word, list.size)
}
//按照单词的数量倒序排序
val sortRDD: RDD[(String, Int)] = countRDD.sortBy(_._2, false)
//步骤7:将结果收集到内存中
val result = sortRDD.collect()
//步骤8:将结果打印到控制台上
result.foreach(println)
//步骤9:关闭spark连接
sc.stop()
}
}
使用Spark中ReduceByKey(),根据相同的key进行value的reduce集合;Spark中所有的byKey的方法必须保证处理的数据为kv类型的数据。
object WordCount2 {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setMaster("local").setAppName("WordCount")
val sc = new SparkContext(conf)
val lines = sc.textFile("input/word.txt")
val words = lines.flatMap(_.split(" "))
val wordToOne = words.map {
case word => (word, 1)
}
val wordToSum: RDD[(String, Int)] = wordToOne.reduceByKey((x, y) => x + y)
val sortRDD: RDD[(String, Int)] = wordToSum.sortBy {
case (word, count) => -count
}
val top3: Array[(String, Int)] = sortRDD.take(3)
top3.foreach(println)
sc.stop()
}
}
2.3 日志配置信息
执行过程会产生大量的执行日志,可以在resources目录创建log4j.properties文件,并添加下面的日志配置信息
log4j.rootCategory=ERROR, console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.target=System.err
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n
# Set the default spark-shell log level to ERROR. When running the spark-shell, the
# log level for this class is used to overwrite the root logger's log level, so that
# the user can have different defaults for the shell and regular Spark apps.
log4j.logger.org.apache.spark.repl.Main=ERROR
# Settings to quiet third party logs that are too verbose
log4j.logger.org.spark_project.jetty=ERROR
log4j.logger.org.spark_project.jetty.util.component.AbstractLifeCycle=ERROR
log4j.logger.org.apache.spark.repl.SparkIMain$exprTyper=ERROR
log4j.logger.org.apache.spark.repl.SparkILoop$SparkILoopInterpreter=ERROR
log4j.logger.org.apache.parquet=ERROR
log4j.logger.parquet=ERROR
# SPARK-9183: Settings to avoid annoying messages when looking up nonexistent UDFs in SparkSQL with Hive support
log4j.logger.org.apache.hadoop.hive.metastore.RetryingHMSHandler=FATAL
log4j.logger.org.apache.hadoop.hive.ql.exec.FunctionRegistry=ERROR
2.4 异常处理
如果本机操作系统是Windows,在程序中使用了Hadoop相关的东西,比如写入文件到HDFS,则会遇到如下异常
出现这个问题,并不是程序错误,而是windows系统用到了hadoop相关的服务,解决方法是通过配置关联到windows的系统依赖即可。
3 Spark运行环境
3.1 Local模式
之前在Idea中的Local模式,每次提交完成后,环境就没有了,所以并不是我们所说的本地Local模式。
步骤1:上传spark-local环境安装包到/opt/software/,然后解压到/opt/module
tar -zxvf spark-3.0.0-bin-hadoop3.2.tgz -C /opt/module
cd /opt/module
mv spark-3.0.0-bin-hadoop3.2 spark-local
步骤2:启动Local环境
bin/spark-shell
步骤3:启动后,可以输入网址进行Web UI监控页面访问
http://虚拟机地址:4040
步骤4:命令行工具
在解压缩文件夹的data目录中,添加文件word.txt文件,在里面输入几个单词。
可以在spark-shell内输入代码(和IDEA中代码简化版一致)
sc.textFile("data/data.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect
步骤5:提交应用
bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master local[2] \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10
- –class 表示要执行程序的主类,可以更改为自己的应用程序
- –master local[2],部署模式。默认为本地模式,数字表示分配的虚拟CPU核数量
- spark-examples_2.12-3.0.0.jar,运行的应用类所在的jar包,实际使用时,可以设定为咱们自己打的jar包
- 数字10表示程序的入口参数,用于设定当前应用的任务数量
步骤6:提交自己的编写的应用
注意读取文件路径,需要时Linux系统中的存在的文件。
object WordCount {
def main(args: Array[String]): Unit = {
//创建Spark运行配置对象
val conf: SparkConf = new SparkConf().setMaster("local").setAppName("WordCount")
//获取SparkContext上下文环境对象(连接对象)
val sc: SparkContext = new SparkContext(conf)
//读取文件数据
val fileRDD: RDD[String] = sc.textFile("data/data.txt")
//将文件数据进行分词
val words: RDD[String] = fileRDD.flatMap(_.split(" "))
//将数据按照单词进行分组
val groupRDD: RDD[(String, Iterable[String])] = words.groupBy(t => t)
//转换数据结构
val resultRDD: RDD[(String, Int)] = groupRDD.map {
case (word, list) => (word, list.size)
}
val sortRDD: RDD[(String, Int)] = resultRDD.sortBy(_._2, false)
//将转换后的结果采集到内存中
val collectRDD = sortRDD.collect()
//输出打印
collectRDD.foreach(println)
//关闭Spark连接
sc.stop()
}
}
需要运行一下,产生classes文件后,再打包。
3.2 Standalone模式
Spark的Standalone模式体现了经典的master-slave模式。
集群规划:
Linux1 | Linux2 | Linux3 | |
Spark | Worker Master | Worker | Worker |
步骤1:解压缩文件
将spark-3.0.0-bin-hadoop3.2.tgz文件上传到/opt/software目录,然后解压到opt/module。
tar -zxvf spark-3.0.0-bin-hadoop3.2.tgz -C /opt/module
cd /opt/module
mv spark-3.0.0-bin-hadoop3.2 spark-standalone
步骤2:修改配置文件
进入解压后路径的conf目录,修改slaves.template文件为slaves
mv slaves.template slaves
步骤3:修改slaves文件,添加work节点。
hadoop102
hadoop103
hadoop104
步骤4:修改spark-env.sh.template文件名为spark-env.sh
mv spark-env.sh.template spark-env.sh
添加JAVA_HOME环境变量和集群对应的master节点
export JAVA_HOME=/opt/module/jdk1.8.0_212
SPARK_MASTER_HOST=hadoop102
SPARK_MASTER_PORT=7077
注意:7077端口是,相当于hadoop3内部通信的8020端口
步骤5:分发spark-standalone目录
xsync spark-standalone
步骤6:启动集群
sbin/start-all.sh
查看三台服务器运行进程
查看Master资源监控Web UI界面 http://linux1:8080
步骤7:提交应用
bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://hadoop102:7077 \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10
- –class 表示要执行程序的主类
- –master spark://hadoop102:7077 独立部署模式,连接到spark集群
- spark-examples_2.12-3.0.0.jar 运行类所在的jar包
- 数字10表示程序的入口参数,用于设定当前引用的任务数量
执行任务时,会产生多个java进程
①提交参数说明
bin/spark-submit \
--class <main-class>
--master <master-url> \
... # other options
<application-jar> \
[application-arguments]
参数 | 解释 | 可选值举例 |
–class | Spark程序中包含主函数的类 | |
–master | Spark程序运行的模式(环境) | 模式:local[*]、spark://linux1:7077、 Yarn |
–executor-memory 1G | 指定每个executor可用内存为1G | 符合集群内存配置即可,具体情况具体分析。 |
–total-executor-cores 2 | 指定所有executor使用的cpu核数为2个 | |
–executor-cores | 指定每个executor使用的cpu核数 | |
application-jar | 打包好的应用jar,包含依赖。这个URL在集群中全局可见。 比如hdfs:// 共享存储系统,如果是file:// path,那么所有的节点的path都包含同样的jar | |
application-arguments | 传给main()方法的参数 |
②配置历史服务
由于spark-shell停止后,集群监控hadoop102:4040页面就看不到历史任务的运行情况,所以开发时都配置历史服务器记录任务运行情况。
步骤1:修改spark-defaults.conf.template文件名为spark-defaults.conf
mv spark-defaults.conf.template spark-defaults.conf
修改spark-default.conf文件,配置日志存储路径
spark.eventLog.enabled true
spark.eventLog.dir hdfs://hadoop102:8020/directory
注意:需要启动hadoop集群,HDFS上的directory目录需要提前存在
sbin/start-dfs.sh
hadoop fs -mkdir /directory
步骤2:修改spark-env.sh文件,添加日志配置
export SPARK_HISTORY_OPTS="
-Dspark.history.ui.port=18080
-Dspark.history.fs.logDirectory=hdfs://hadoop102:8020/directory
-Dspark.history.retainedApplications=30"
- 参数1含义:Web UI访问的端口为18080
- 参数2含义:指定历史服务器存储的HDFS路径
- 参数3含义:指定保存Application历史服务器的个数,如果超过这个值,旧的应用程序信息将被删除,这个是内存中的应用数,而不是页面上显示的应用数
步骤3:分发配置文件
xsync conf
步骤4:重新启动集群和历史服务
sbin/start-all.sh
sbin/start-history-server.sh
步骤5:重新执行任务
bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://hadoop102:7077 \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10
步骤6:查看历史服务:http://linux1:18080
③配置高可用(HA)
当前集群的master节点只有一个,所以会出现单点故障问题。为了解决单点故障问题,需要在集群中配置多个master节点。一旦一个处于活动状态的Master发生故障时,备用Master就会提供服务,这里的高可用一般采用Zookeeper配置。
步骤1:集群规划
Linux1 | Linux2 | Linux3 | |
Spark | Master Zookeeper Worker | Master Zookeeper Worker | Zookeeper Worker |
步骤2:停止集群
sbin/stop-all.sh
步骤3:启动zookeeper
myzk.sh start
步骤4:修改spark-env.sh文件内容,添加如下配置
# standalone模式需要配置的JAVA_HOME
export JAVA_HOME=/opt/module/jdk1.8.0_212
# 注释掉Master节点,因为采用zookeeper管理
# SPARK_MASTER_HOST=hadoop102
# SPARK_MASTER_PORT=7077
# 更改Master监控页面的Web端口。Master监控页面默认访问端口为8080,但是可能会和zookeeper冲突,所以改为8989,可以自定义,
SPARK_MASTER_WEBUI_PORT=8989
export SPARK_DAEMON_JAVA_OPTS="
-Dspark.deploy.recoveryMode=ZOOKEEPER
-Dspark.deploy.zookeeper.url=hadoop102,hadoop103,hadoop104
-Dspark.deploy.zookeeper.dir=/spark"
export SPARK_HISTORY_OPTS="
-Dspark.history.ui.port=18080
-Dspark.history.fs.logDirectory=hdfs://hadoop102:8020/directory
-Dspark.history.retainedApplications=30"
步骤5:分发配置文件
xsync conf/
步骤6:启动集群
sbin/start-all.sh
步骤7:在其他节点hadoop103上单独启动master节点
[atguigu@hadoop103 spark-standalone]$ sbin/start-master.sh
starting org.apache.spark.deploy.master.Master, logging to /opt/module/spark-standalone/logs/spark-atguigu-org.apache.spark.deploy.master.Master-1-hadoop103.out
可以看到hadoop103上的Master处于备用状态。当处于ALIVE状态的Master节点挂掉,会过一小段时间,hadoop103的Master就会成为ALIVE状态。
步骤8:提交任务到高可用集群
bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://hadoop102:7077,hadoop103:7077 \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10
步骤9:杀死hadoop102的Master进程
kill -9 12345
可以看到hadoop103的Master成为了ALIVE
3.3 Yarn模式
独立部署模式(Standalone)由Spark自身提供计算资源,无需其他框架提供资源。但是Spark是一个计算框架,不是资源调度框架,所以一般使用Yarn做资源调度。
步骤1:解压安装包到/opt/module
tar -zxvf spark-3.0.0-bin-hadoop3.2.tgz -C /opt/module
cd /opt/module
mv spark-3.0.0-bin-hadoop3.2 spark-yarn
步骤2:修改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>
步骤3:修改spark的spark-env.sh,添加JAVA_HOME和YARN_CONF_DIR配置信息
mv spark-env.sh.template spark-env.sh
export JAVA_HOME=/opt/module/jdk1.8.0_212
YARN_CONF_DIR=/opt/module/hadoop-3.1.3/etc/hadoop
步骤4:启动HDFS和YARN集群
[atguigu@hadoop102 conf]$ myhadoop.sh start
步骤5:提交应用
注意:spark-yarn模式,只需要启动HDFS和YARN集群后就可以直接提交任务了,不过需要指明运行模式master为yarn;还有deploy-mode为cluster集群模式。
- Yarn的client模式,会在控制台看到结果
- Yarn的cluster模式,不会在控制台的结果,结果提交到集群了。
bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master yarn \
--deploy-mode cluster \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10
查看http://hadoop103:8088/cluster页面,查看yarn的历史页面
① 配置历史服务器
上面的历史服务器是Hadoop的JobHistoryServer;下面配置的和Standalone模式的历史服务一样。
进程名为:HistoryServer
步骤1:spark-defaults.conf.template文件名为spark-defaults.conf
mv spark-defaults.conf.template spark-defaults.conf
配置日志存储的HDFS路径
spark.eventLog.enabled true
spark.eventLog.dir hdfs://hadoop102:8020/directory
注意:需要启动Hadoop集群,HDFS上的目录需要提前存在
sbin/start-dfs.sh
hadoop fd -mkdir /directory
步骤2:spark-env.sh文件,添加日志配置
export SPARK_HISTORY_OPTS="
-Dspark.history.ui.port=18080
-Dspark.history.fs.logDirectory=hdfs://hadoop102:8020/directory
-Dspark.history.retainedApplications=30"
步骤3:修改spark-default.conf
spark.yarn.historyServer.address=linux1:18080
spark.history.ui.port=18080
步骤4:启动历史服务
[atguigu@hadoop102 spark-yarn]$ sbin/start-history-server.sh
步骤5:重新提交应用
bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master yarn \
--deploy-mode client \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10
步骤6:查看Web页面
Hadoop的Yarn的Web信息:hadoop103:8088
SparkJob的Web信息:hadoop102:18080
3.4 K8S & Mesos模式
容器化部署是目前业界很流行的一项技术,基于Docker镜像运行能够让用户更加方便地对应用进行管理和运维。容器管理工具中最为流行的就是Kubernetes(k8s),而Spark也在最近的版本中支持了k8s部署模式。这里我们也不做过多的讲解。给个链接大家自己感受一下:https://spark.apache.org/docs/latest/running-on-kubernetes.html
3.5 Windows模式
步骤1:解压缩文件
将文件spark-3.0.0-bin-hadoop3.2.tgz解压缩到无中文无空格的路径中
步骤2:启动本地环境
- 执行解压缩文件路径下bin目录中的spark-shell.cmd文件,启动Spark本地环境
- 在bin目录中创建input目录,并添加word.txt文件, 在命令行中输入脚本代码
scala> sc.textFile("input/word.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect
步骤3:命令行提交应用
在DOS命令行窗口执行命令:
spark-submit --class org.apache.spark.examples.SparkPi --master local[2] ../examples/jars/spark-examples_2.12-3.0.0.jar 10
3.6 部署模式对比
模式 | Spark安装机器数 | 需启动的进程 | 所属者 | 应用场景 |
Local | 1 | 无 | Spark | 测试 |
Standalone | 3 | Master及Worker | Spark | 单独部署 |
Yarn | 1 | Yarn及HDFS | Hadoop | 混合部署 |
3.7 端口号
- Spark查看当前Spark-shell运行任务情况端口号:4040(计算)
- Spark Master内部通信服务端口RPC端口:7077
- Standalone模式下,Spark Master Web端口号:8080(资源)
- Spark历史服务器端口号:18080
- Hadoop YARN任务运行情况查看端口号:8088
4 Spark运行架构
Spark框架的核心是一个计算引擎,整体来说,它采用了标准的master-slave的结构。
--1. Spark框架可以理解三个部分组成
第一部分: Driver + Executor --> 任务执行和调度
第二部分: Master + Worker --> Saprk自身的资源调度框架
第三部分: Cluster Manager --> 集群管理,中间件
4.1 核心组件
①Drive & Executor
-- Driver:驱动器
1. 用于执行Spark任务中的main()方法,负责实际代码的执行
2. 将用户程序转化为job;
3. 调度Executor之间的任务(task);
4. 跟踪Executor的执行情况;
5. 通过UI展示查询运行的结果。
-- Executor: 执行器
1. 是worker的一个JVM进程,负责Spark执行具体的任务(task);
2. 负责运行组成Spark应用的任务,并将结果返回给驱动器进程;
3. 在执行器内有块管理器,为用户程序中要求缓存的RDD提供内存的缓存。
②Master & Worker
-- Master
1. 类似YARN中的RM;
2. 负责资源的调度和分配,并进行集群的监控
-- worker
1. 类似YARN中的NM;
2. 是一个进程,一个Worker运行在集群的一个服务器上,由Master分配资源对数据进行并行的处理和计算。
-- 只有独立部署的模式下才有Master和Worker.
③ApplicationMaster
Hadoop用户向YARN集群提交应用程序时,提交程序中应该包含ApplicationMaster,用于向资源调度器申请执行任务的资源容器Container,运行用户自己的程序任务job,监控整个任务的执行,跟踪整个任务的状态,处理任务失败等异常情况
ResourceManager(资源)和Driver(计算)之间的解耦合靠的就是ApplicationMaster。
4.2 核心概念
① Executor与Core
Spark Executor是集群中运行在工作节点(Worker)中的一个JVM进程,是整个集群中的专门用于计算的节点。在提交应用中,可以提供参数指定计算节点的个数,以及对应的资源。这里的资源一般指的是工作节点Executor的内存大小和使用的虚拟CPU核(Core)数量
名称 | 说明 |
–num-executors | 配置Executor的数量 |
–executor-memory | 配置每个Executor的内存大小 |
–executor-cores | 配置每个Executor的虚拟CPU core数量 |
②有向无环图(DAG)
-- 什么是有向无环图
DAG(Directed Acycli Graph):由点和线组成的拓扑图形,该图形具有方向,不会闭环。
-- tez :是作业和作业之间的有向无环图
-- Spark:是作业内部的有向无环图
4.3 提交流程
①Yarn Client模式
Yarn Client模式,Client模式将用于监控和调度Driver模块在客户端执行,而不是Yarn中,所以一般用于测试.
1) 执行脚本提交任务,实际是启动一个SparkSubmit的JVM进程;
2) SparkSubmit类中的main方法反射调用用户代码的main方法;
3) 启动Driver线程,执行用户的作业,并创建ScheduleBackend;
4) YarnClientSchedulerBackend向RM发送指令:bin/java ExecutorLauncher;
5) Yarn框架收到指令后会在指定的NM中启动ExecutorLauncher(实际上还是调用ApplicationMaster的main方法);
object ExecutorLauncher {
def main(args: Array[String]): Unit = {
ApplicationMaster.main(args)
}
}
6) AM向RM注册,申请资源;
7) 获取资源后AM向NM发送指令:bin/java CoarseGrainedExecutorBackend;
8) CoarseGrainedExecutorBackend进程会接收消息,跟Driver通信,注册已经启动的Executor;然后启动计算对象Executor等待接收任务
9) Driver分配任务并监控任务的执行。
-- 注意:SparkSubmit、ApplicationMaster和YarnCoarseGrainedExecutorBackend是独立的进程;Executor和Driver是对象。
②Yarn Cluster模式
1) 执行脚本提交任务,实际是启动一个SparkSubmit的JVM进程;
2) SparkSubmit类中的main方法反射调用YarnClusterApplication的main方法;
3) YarnClusterApplication创建Yarn客户端,然后向Yarn服务器发送执行指令:bin/java ApplicationMaster;
4) Yarn框架收到指令后会在指定的NM中启动ApplicationMaster;
5) ApplicationMaster启动Driver线程,执行用户的作业;
6) AM向RM注册,申请资源;
7) 获取资源后AM向NM发送指令:bin/java YarnCoarseGrainedExecutorBackend;
8) CoarseGrainedExecutorBackend进程会接收消息,跟Driver通信,注册已经启动的Executor;然后启动计算对象Executor等待接收任务
9) Driver线程继续执行完成作业的调度和任务的执行。
10) Driver分配任务并监控任务的执行。
--注意:SparkSubmit、ApplicationMaster和CoarseGrainedExecutorBackend是独立的进程;Driver是独立的线程;Executor和YarnClusterApplication是对象。