【Spark】部署流程的深度了解

文章目录

• Spark核心组件
• Driver
• Executor
• Spark通用运行流程图
• Standalone模式运行机制
• Client模式流程图
• Cluster模式流程图
• On-Yarn模式运行机制
• Client模式流程图
• Cluster模式流程图
• 源码解读（多图版）
• Spark On-Yarn Cluster模式示例
• 1.SparkSubmit
• 2.Client
• 3.ApplicationMaster
• 4.CoarseGrainedExecutorBackend
• 源码解读（无图版）

---

Spark核心组件

关于Spark的基本架构模块，在【Spark】一起了解一下大数据必不可少的Spark吧！ 这篇文章已经有所提及，这里主要要先明白两个主要运行角色Driver和Executor在整个部署流程的主要职责。

Driver

是Spark驱动器节点，主要用于执行Spark任务中的main方法，负责实际代码的执行。

详细职责：

1.将用户程序转化为作业(job)

2.在Executor之间调度任务(task)

3.跟踪Executor的执行情况

4.通过UI展示查询运行情况

Executor

其实Executor并不是一个进程，而是ExecutorBackend是一个进程，Executor是它的执行类，负责Spark作业中运行具体的任务，任务之间是彼此相互独立的。

Spark应用启动时，Executor节点同时启动，并且始终伴随整个Spark应用的生命周期而存在。如果Executor节点发生故障或者崩溃，Spark会将故障节点的任务调度到其他Executor节点上执行。

详细职责：

1.运行组成Spark应用的任务，并将结果返回给驱动器进程

2.通过自身的块管理器(Block Manager) 为用户程序中要求缓存的RDD提供内存式存储。RDD 是直接缓存在Executor进程内的，因此任务可以在运行时充分利用缓存数据加速运算。

---

Spark通用运行流程图

---

Standalone模式运行机制

Client模式流程图

Cluster模式流程图

---

On-Yarn模式运行机制

Client模式流程图

注：

1.ApplicationMaster是Yarn集群中的核心概念，任何要在Yarn集群上启动的Job类型（包括MR和Spark）都必须有一个ApplicationMaster。

2.每种计算框架（比如MR和Spark）如果想要在Yarn上执行自己的Application，就必须自己实现和提供一个ApplicationMaster，相当于自己实现了Yarn提供的接口，Spark自己开发的一个类。

3.Spark-On-Yarn在Client模式下，Application向ResourceManager申请资源和task的调度是分离的。

Cluster模式流程图

---

源码解读（多图版）

Spark On-Yarn Cluster模式示例

1.SparkSubmit

通过spark-submit提交任务，会在后台启动一个进程



然后就会调用spark-submit中的main方法

查看源码，在SparkSubmit的伴生对象中，我们可以看到其中要调用的main方法

代码如下

 override def main(args: Array[String]): Unit = {
   val appArgs = new SparkSubmitArguments(args)
   if (appArgs.verbose) {
     // scalastyle:off println
     printStream.println(appArgs)
     // scalastyle:on println
   }
   appArgs.action match {
     case SparkSubmitAction.SUBMIT => submit(appArgs)
     case SparkSubmitAction.KILL => kill(appArgs)
     case SparkSubmitAction.REQUEST_STATUS => requestStatus(appArgs)
   }
 }

从以上代码，可以看到val appArgs = new SparkSubmitArguments(args)，这表示它将参数都封装到一起，而args指的就是提交任务时输入的--master、--deploy-mode、--executor-memory等这些参数。

具体有哪些参数，我们也可以点进去查看,以下就是里面封装的参数



那么究竟是如何给这些参数，赋值的

其实它是将这些参数解析转换成了java。



并且其中有一个handle方法，对我们输入的参数进行模式匹配。



再回到SparkSubmit中，我们可以看到一个关于action的模式匹配。



action就和master一样，是我们上传jar包是需要配置的，如果不配置，它有方法默认为Submit。





那么就可以看一下submit方法里面具体是什么，首先就可以看到一个prepareSubmitEnvironment，也就是准备上传环境，又是采用了一个模式匹配，返回值就是括号里那四个childArgs、childClasspath、sysProps、childMainClass。



接着往下看，可以看到一个判断是否为standalone的Cluster模式，如果不是就会执行doRunMain方法。



doRunMain方法中主要是在判断代理用户参数是否为空，也就是有没有给代理用户的参数，不过无论是否给了这个参数，最终都会运行runMain方法，而runMain方法中需要的函数正是之前准备上传环境所返回的值。



点进去查看runMain方法，最主要的就是这个反射加载类。



同样，还有这个查找提交的jar包中是否有main方法，并作了一个是否有static修饰符的判断，其实就是在查找main方法，invoke就是在调用main方法。



现在了解到这，就需要知道反射加载类中的childMainClass是什么，它的首次出现，是作为prepareSubmitEnvironment返回的元祖中的最后一个元素。



那么就要弄明白，childMainClass是如何进行赋值的。

在prepareSubmitEnvironment方法中，是经过多个判断方法，判断当前是什么运行模式，来对childMainClass进行赋值，第一张图为yarn模式的Cluster模式，第二张是Client模式。Cluster给childMainClass赋值为 “org.apache.spark.deploy.yarn.Client”，Client则是args.mainClass，也就是启动时输入的--class的命令行参数（比如org.apache.spark.examples.SparkPi）。





实际工作中，一般用的都是yarn-Cluster模式，所以现在要弄清楚 “org.apache.spark.deploy.yarn.Client” 是什么，在这之前，现在pom.xml中添加以下包

<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-yarn_2.11</artifactId>
    <version>2.1.1</version>
</dependency>

查找类后，找到其中的main方法，那么我们发现，已经不再是SparkSubmit类了，已经到了Client类。

2.Client

Client类的第一步同样也是封装参数。





第二步就是new了一个Client对象。



我们需要看看这么做的原因，由下图就能知道，它首先就是想创建一个YarnClient。



创建成功后，它立即进行了run方法，run方法点进去，第一件事就是submitApplication，提交应用，并且把最后返回的值赋值为appID，这就是在spark-shell界面登录时看到的appID。



submitApplication方法中，最重要的一步就是yarnClient.submitApplication(appContext)，作用是向Yarn提交应用，它的参数是appContext，往上推，appContext的是createApplicationSubmissionContext方法返回的值，而此方法需要的参数containerContext是 createContainerLaunchContext方法返回的值，这两个方法的作用是设置适当的context启动ApplicationMaster，接下来的重点就是看这两个方法。



点进createContainerLaunchContext方法，可以看到的submitApplication提交的不是真实的应用，而是提交的command——指令。command中封装的指令，根据上面args的判断后赋值，可以确定有client和cluster两种模式，cluster模式的指令为 /bin/java org.apache.spark.deploy.yarn.ApplicationMaster，client模式的指令为org.apache.spark.deploy.yarn.ExecutorLauncher。

3.ApplicationMaster

现在我们就可以来看ApplicationMaster这个类，查看它的main方法。



在这之前，首先要搞明白，client模式下org.apache.spark.deploy.yarn.ExecutorLauncher和ApplicationMaster有什么区别，所以先看一下ExecutorLauncher类，发现它和ApplicationMaster其实没有区别，甚至直接调用了ApplicationMaster的Main方法。



好，现在回到ApplicationMaster的main方法，第一步还是对参数进行了封装，第二步就是new了一个ApplicationMaster，并且可以看到里面有两个参数，第一个amArgs就是第一步封装的参数，第二个new YarnRMClient是创建了一个yarn的ResourceManager的客户端，这么做是因为ApplicationMaster会向ResourceManager申请资源进行交互。第三步就是让ApplicationMaster运行起来。



先点进ApplicationMaster看一下，在这里，我们需要明白两个东西，一个是RPC，一个是Endpoint，其实很简单，RPC就是Remote Procedure Call——远程过程调用，主要是通过网络从远程计算机程序上请求服务，而Endpoint就是终端。

这里rpcEnv中的Env就是Environment，amEndpoint是ApplicationMaster的终端。



接下来，进入到run方法，里面最重要的就是判断是否是cluster模式，如果是cluster模式，执行runDriver方法，如果不是，执行runExecutorLauncher方法。



那就该进入到runDriver方法，第一个就是startUserApplication方法，顾名思义，启动用户应用，点进去，可以看到，userClassLoader.loadClass(args.userClass).getMethod(“main”, classOf[Array[String]])，这一步主要就是要获取我们输入命令行参数时--class中类的main方法。





获取到用户类的main方法，下一步当然就是执行，它new了一个Thread，进行启动，我们可以看到它的名字就是Driver，所以Driver是一个线程，我们写的SparkContext、StreamingContext，就是Driver。



ApplicationMaster启动后，ResourceManager要和AM进行交互，所以要registerAM，它们两个都是进程，所以我们看到了参数中有RPC。

点进去registerAM，可以看到有一个client的注册，这个client就是YarnRMClient，所以这个过程就是ApplicationMaster向ResourceManager申请资源的过程。







那么，究竟是怎么分配资源的呢？我们可以看allocateResources这个方法。

点进去可以看到，主要就是分配RM中的container，allocatedContainers.size > 0就意味着RM中有资源可以分配，接下来就会进行资源的处理——handleAllocatedContainers。





点进去handleAllocatedContainers，首先进行一个节点分配的操作，然后开始运行——runAllocatedContainers。

点进去可以看到，最终的目的就是启动Executor——new ExecutorRunnable().run。

ApplicationMaster申请资源完毕后，通知NodeManager启动Container，而startContainer中又出现了prepareComand，command就是 /bin/java "org.apache.spark.executor.CoarseGrainedExecutorBackend"

4.CoarseGrainedExecutorBackend

打开CoarseGrainedExecutorBackend类，找到它的main方法，直接看其中的run方法，它又在run些什么呢？



点进去我们发现，Executor其实是ExecutorBackend的一个计算对象，真正运行的进程应该是ExecutorBackend





这里继承了一个ThreadSafeRpcEndpoint，它又继承自RpcEndpoint，RpcEndpoint类中讲到，一个Endpoint的生命周期就是constructor -> onStart -> receive* -> onStop







ExecutorBackend继承自它，那说明ExecutorBackend也是一个进程，它也有同样的生命周期。

回到CoarseGrainedExecutorBackend类中，我们看到它确实有，在onStart阶段，它主要干了一件事，ref.ask[Boolean](RegisterExecutor——这就是前面一直说的Executor启动后会向Driver进行反向注册。在receive阶段，它干的就是上面说的new Executor，这么做就是创建了一个计算对象，来处理拿到的数据。

---

源码解读（无图版）

1. SparkSubmit

    // 启动进程
    -- main

        // 封装参数
        -- new SparkSubmitArguments

        // 提交
        -- submit

            // 准备提交环境
            -- prepareSubmitEnvironment

                // Cluster
                -- childMainClass = "org.apache.spark.deploy.yarn.Client"
                // Client
                -- childMainClass = args.mainClass (SparkPi)

            -- doRunMain (runMain)

                // 反射加载类
                -- Utils.classForName(childMainClass)
                // 查找main方法
                -- mainClass.getMethod("main", new Array[String](0).getClass)
                // 调用main方法
                -- mainMethod.invoke

2. Client

    -- main

        -- new ClientArguments(argStrings)

        -- new Client

            -- yarnClient = YarnClient.createYarnClient

        -- client.run

                -- submitApplication

                    // 封装指令 command = bin/java org.apache.spark.deploy.yarn.ApplicationMaster (Cluster)
                    // command = bin/java org.apache.spark.deploy.yarn.ExecutorLauncher  (client)
                    -- createContainerLaunchContext

                    -- createApplicationSubmissionContext

                    // 向Yarn提交应用，提交指令
                    -- yarnClient.submitApplication(appContext)

3. ApplicationMaster

    // 启动进程
    -- main

        -- new ApplicationMasterArguments(args)

        // 创建应用管理器对象
        -- new ApplicationMaster(amArgs, new YarnRMClient)

        // 运行
        -- master.run

            // Cluster
            -- runDriver

                // 启动用户应用
                -- startUserApplication

                    // 获取用户应用的类的main方法
                    -- userClassLoader.loadClass(args.userClass)
      .getMethod("main", classOf[Array[String]])

                    // 启动Driver线程，执行用户类的main方法，
                    -- new Thread().start()

                // 注册AM
                -- registerAM

                    // 获取yarn资源
                    -- client.register

                    // 分配资源
                    -- allocator.allocateResources()
                    	// 处理资源
                        -- handleAllocatedContainers
                        	// 启动container
                            -- runAllocatedContainers

                                -- new ExecutorRunnable().run

                                    -- startContainer

                                        // command = bin/java org.apache.spark.executor.CoarseGrainedExecutorBackend
                                        -- prepareCommand

4. CoarseGrainedExecutorBackend
    // 启动进程
    -- main

        -- run

            -- onStart
            	// 反向注册
                -- ref.ask[Boolean](RegisterExecutor

            -- receive

                --  case RegisteredExecutor
                	// 创建计算对象
                    -- new Executor