Spark的资源管理以及YARN-Cluster Vs YARN-Client

原文：http://blog.cloudera.com/blog/2014/05/apache-spark-resource-management-and-yarn-app-models/

对于Mapreduce来说，最高级别的计算单元是Job。系统加载数据，执行Map定义的处理逻辑，shuffle Map的输出，再执行Reduce定义的处理逻辑，最后把reduce的结果写回持久化的存储空间（比如HDFS）。Spark有类似于job的概念，虽然spark的一个job可以包含多个stages，而不是只有一个Map和reduce。不过spark还有一个更高级别的组织对象叫做application。application可能需要线性或者并行的运行多个job。

如果熟悉spark API就会知道，一个application对应了一个SparkContext的实例。一个application可以是简单的一组job，一个包含多个独立job的相互式的会话，也可以是一个持续响应外部request的长期运行的server。 和Mapreduce不同，一个application有多个进程，我们称之为executor。就算当前没有任何job在执行，executor也运行着在spark集群上。这样的设计上的我可以快速的访问存在内存中的数据，迅速启动计算任务。而不像mapreduce每次执行都需要进行初始化。


Mapreduce在它自己的进程中执行计算任务。当任务完成了，进程也就退出了。在Spark中，多个不同的计算任务可以执行在同一个进程中。这些进程存活于application的整个生命空间，就算当时没有job在运行也不会退出。这种设计的好处是速度快。计算任务可以迅速启动并方便的访问已经在内存中的数据。缺点是低效的资源管理。如果一个application包含的executor的数量，以及每个executor分配的资源数量都是固定的，这个application将在它的至始至终占用全部这些资源。如果以后Yarn支持动态的空间管理，也许可以优化这个设计是的spark可以动态的申请和释放资源。


active driver
spark依赖于一个活动的driver进程来管理job和规划计算任务的。一般来说，这个driver进程就是那个触发job的客户端进程，虽然在Yarn 模式下，driver可能运行在cluster上。MapReduce则不同，客户端程序可能在触发job后就退出了，而job继续运行。在hadoop1.x中，jobtracker负责管理计算任务的规划，在hadoop2.x中，这个是由Mapreduce 程序的master来负责的。


spark支持可插拔的集群管理。集群的管理者负责启动executor。
spark支持YARN，Mesos以及他自有的standalone的集群管理方式。这三种模式都有两个模块。一个是中心话的master服务（Yarn resourceManager，Mesos Master, spark standalone master），有它来决定执行那个application可以去启动executor 进程，包括在哪里什么时候启动。另一个模块是运行在集群其他机器上的slave服务（YARN NodeManager, Mesos slave, 或者Spark standalone slave），executor进程实际上是由他们启动的。同时他们可能还需要监控executor的存活状况以及资源使用情况。


相对standalone和Mesos模式，Yarn模式有以下好处，
1. Yarn支持动态共享，允许集中配置同一个资源池用于所有的框架，比如先把所有资源供给Mapreduce job，然后再把一部分给impla query，同时把剩下的给spark。
2. 可以享用Yarn 任务规划方面的各种新功能。
3. standalone模式要求在每个节点上运行个executor，而yarn允许你制定多少个executor来运行。
4. 最后，yarn 是spark唯一一个支持安全认证的集群管理器。


在Yarn上运行spark的时候，每个executor相当于一个yarn container。Mapreduce是先获得一个container，然后再为每个计算任务启动一个独立的JVM。而spark是在一个container里执行多个计算任务。这样可以大量的节省计算任务的启动时间。


spark有两种运行在yarn上的模式，yarn-cluster和yarn-client。生产环境的任务一般用yarn-cluster模式。yarn-client一般用于交互式应用或者马上需要看到输出结果的debug场景，


了解这两种模式之间的不同之处，需要先理解yarn里面application master的概念。Yarn里面每个application都有个一个application master进程，它是该application的第一个yarn container。他负责从resourcemanager申请资源、分配资源，通知NodeManager去启动为该application服务的container。 Application master使得我们不需要一个活动的client。启动application的client可马上退出，后续执行的协调交给Yarn来管理。

在Yarn-cluster模式中，driver运行在application master中，这意味这驱动这个application和从yarn申请资源是同一个进程，在同一个yarn container中。启动application的客户端不需要继续运行。

不过yarn-cluster模式，并不适合交互式使用spark的场景。需要用户输入的spark application，比如spark-shell，pyspark，它需要spark driver运行在启动sparkcapplication的client程序中。在yarn-client模式中，application master只是用来申请yarn container给executor，后续有client（driver）来和这些container（executor）通信来协调他们的工作。

下面是分析Spark on YARN的Cluster模式，从用户提交作业到作业运行结束整个运行期间的过程分析。

客户端进行操作

　　1、根据yarnConf来初始化yarnClient，并启动yarnClient
　　2、创建客户端Application，并获取Application的ID，进一步判断集群中的资源是否满足executor和ApplicationMaster申请的资源，如果不满足则抛出IllegalArgumentException；
　　3、设置资源、环境变量：其中包括了设置Application的Staging目录、准备本地资源（jar文件、log4j.properties）、设置Application其中的环境变量、创建Container启动的Context等；
　　4、设置Application提交的Context，包括设置应用的名字、队列、AM的申请的Container、标记该作业的类型为Spark；
　　5、申请Memory，并最终通过yarnClient.submitApplication向ResourceManager提交该Application。
　　当作业提交到YARN上之后，客户端就没事了，甚至在终端关掉那个进程也没事，因为整个作业运行在YARN集群上进行，运行的结果将会保存到HDFS或者日志中。

提交到YARN集群，YARN操作

　　1、运行ApplicationMaster的run方法；
　　2、设置好相关的环境变量。
　　3、创建amClient，并启动；
　　4、在Spark UI启动之前设置Spark UI的AmIpFilter；
　　5、在startUserClass函数专门启动了一个线程（名称为Driver的线程）来启动用户提交的Application，也就是启动了Driver。在Driver中将会初始化SparkContext；
　　6、等待SparkContext初始化完成，最多等待spark.yarn.applicationMaster.waitTries次数（默认为10），如果等待了的次数超过了配置的，程序将会退出；否则用SparkContext初始化yarnAllocator；

　　 怎么知道SparkContext初始化完成？
　　其实在5步骤中启动Application的过程中会初始化SparkContext，在初始化SparkContext的时候将会创建YarnClusterScheduler，在SparkContext初始化完成的时候，会调用YarnClusterScheduler类中的postStartHook方法，而该方法会通知ApplicationMaster已经初始化好了SparkContext

　　7、当SparkContext、Driver初始化完成的时候，通过amClient向ResourceManager注册ApplicationMaster
　　8、分配并启动Executeors。在启动Executeors之前，先要通过yarnAllocator获取到numExecutors个Container，然后在Container中启动Executeors。如果在启动Executeors的过程中失败的次数达到了maxNumExecutorFailures的次数，maxNumExecutorFailures的计算规则如下：

// Default to numExecutors * 2, with minimum of 3 private val maxNumExecutorFailures = sparkConf.getInt( "spark.yarn.max.executor.failures" ,      sparkConf.getInt( "spark.yarn.max.worker.failures" , math.max(args.numExecutors * 2 , 3 )))

　　那么这个Application将失败，将Application Status标明为FAILED，并将关闭SparkContext。其实，启动Executeors是通过ExecutorRunnable实现的，而ExecutorRunnable内部是启动CoarseGrainedExecutorBackend的。
　　9、最后，Task将在CoarseGrainedExecutorBackend里面运行，然后运行状况会通过Akka通知CoarseGrainedScheduler，直到作业运行完成。

Spark on yarn-Client

和yarn-cluster模式一样，整个程序也是通过spark-submit脚本提交的。但是yarn-client作业程序的运行不需要通过Client类来封装启动，而是直接通过反射机制调用作业的main函数。下面就来分析：
　　1、通过SparkSubmit类的launch的函数直接调用作业的main函数（通过反射机制实现），如果是集群模式就会调用Client的main函数。
　　2、而应用程序的main函数一定都有个SparkContent，并对其进行初始化；
　　3、在SparkContent初始化中将会依次做如下的事情：设置相关的配置、注册MapOutputTracker、BlockManagerMaster、BlockManager，创建taskScheduler和dagScheduler；其中比较重要的是创建taskScheduler和dagScheduler。在创建taskScheduler的时候会根据我们传进来的master来选择Scheduler和SchedulerBackend。由于我们选择的是yarn-client模式，程序会选择YarnClientClusterScheduler和YarnClientSchedulerBackend，并将YarnClientSchedulerBackend的实例初始化YarnClientClusterScheduler，上面两个实例的获取都是通过反射机制实现的，YarnClientSchedulerBackend类是CoarseGrainedSchedulerBackend类的子类，YarnClientClusterScheduler是TaskSchedulerImpl的子类，仅仅重写了TaskSchedulerImpl中的getRackForHost方法。
　　4、初始化完taskScheduler后，将创建dagScheduler，然后通过taskScheduler.start()启动taskScheduler，而在taskScheduler启动的过程中也会调用SchedulerBackend的start方法。在SchedulerBackend启动的过程中将会初始化一些参数，封装在ClientArguments中，并将封装好的ClientArguments传进Client类中，并client.runApp()方法获取Application ID。
　　5、client.runApp里面的做是和前面客户端进行操作那节类似，不同的是在里面启动是ExecutorLauncher（yarn-cluster模式启动的是ApplicationMaster）。
　　6、在ExecutorLauncher里面会初始化并启动amClient，然后向ApplicationMaster注册该Application。注册完之后将会等待driver的启动，当driver启动完之后，会创建一个MonitorActor对象用于和CoarseGrainedSchedulerBackend进行通信（只有事件AddWebUIFilter他们之间才通信，Task的运行状况不是通过它和CoarseGrainedSchedulerBackend通信的）。然后就是设置addAmIpFilter，当作业完成的时候，ExecutorLauncher将通过amClient设置Application的状态为FinalApplicationStatus.SUCCEEDED。
　　7、分配Executors，这里面的分配逻辑和yarn-cluster里面类似，就不再说了。
　　8、最后，Task将在CoarseGrainedExecutorBackend里面运行，然后运行状况会通过Akka通知CoarseGrainedScheduler，直到作业运行完成。
　　9、在作业运行的时候，YarnClientSchedulerBackend会每隔1秒通过client获取到作业的运行状况，并打印出相应的运行信息，当Application的状态是FINISHED、FAILED和KILLED中的一种，那么程序将退出等待。
　　10、最后有个线程会再次确认Application的状态，当Application的状态是FINISHED、FAILED和KILLED中的一种，程序就运行完成，并停止SparkContext。整个过程就结束了。

参考：https://www.iteblog.com/archives/1191

http://blog.csdn.net/syxz/article/details/50131907