404 Not Found
The requested URL /q/6095 was not found on this server.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）通信来协调他们的工作。
下面是分析 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、标记该作业的类型为；
　　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的计算规则如下：
val maxNumExecutorFailures =
sparkConf.getInt("spark.yarn.max.executor.failures",
sparkConf.getInt("spark.yarn.max.worker.failures", math.max(args.numExecutors *
　　那么这个Application将失败，将Application Status标明为FAILED，并将关闭SparkContext。其实，启动Executeors是通过ExecutorRunnable实现的，而ExecutorRunnable内部是启动CoarseGrainedExecutorBackend的。
　　9、最后，Task将在CoarseGrainedExecutorBackend里面运行，然后运行状况会通过Akka通知CoarseGrainedScheduler，直到作业运行完成。
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模式，程序会选择ClientClusterScheduler和ClientSchedulerBackend，并将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/
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！当在YARN上运行Spark作业，每个Spark executor作为一个YARN容器运行。Spark可以使得多个Tasks在同一个容器里面运行。
以下参数配置为例子：
spark-submit
--master yarn-cluster&& 　　　　#使用集群调度模式(一般使用这个参数)
--num-executors& 132 &&&& 　　 # executor 数量
--executor-cores& 2 &&&&&& 　　　#设置单个executor能并发执行task数，根据job设置，推荐值2-16 （这里不是指CPU数，集群不限制CPU使用）
--driver-memory 4g& 　　　　　#driver的内存大小，推荐值2-6G，不宜太大
--executor-memory 6g& 　　　 #单个executor的内存大小，根据job需求以及并发数设置，最大不要超过30G
1、containers的最大值就是spark 设置的 num-executors值 ;
2、实际占用的总的vcores&（executor-cores）*containers（实际executors）
3、内存计算公式：((实际占用的总的containers)*(executor-memory+512M))+(driver-memory)。
以下是我实际执行的情况：
spark-submit --master yarn-cluster --class MyMain --num-executors 132 --executor-cores 2 --driver-memory 4g --executor-memory 6g xxx.jar
yarn resoruce manager监控的资源占用结果：
&基本上按照上边公式。
参考资料：
Spark On YARN内存分配 https://yq.aliyun.com/articles/25468
spark on yarn - job提交重要参数说明：http://www.tuicool.com/articles/7vuu22b
spark-submit提交参数设置:http://www.cnblogs.com/gnool/p/5643595.html
阅读(...) 评论()【Spark篇】---Spark中yarn模式两种提交任务方式
一、前述Spark可以和Yarn整合，将Application提交到Yarn上运行，和StandAlone提交模式一样，Yarn也有两种提交任务的方式。二、具体
1、yarn-client提交任务方式配置
在client节点配置中spark-env.sh添加Hadoop_HOME的配置目录即可提交yarn 任务，具体步骤如下：
注意client只需要有Spark的安装包即可提交任务，不需要其他配置（比如slaves）!!!提交命令
./spark-submit --master yarn
--class org.apache.spark.examples.SparkPi
../lib/spark-examples-1.6.0-hadoop2.6.0.jar 100
./spark-submit
--master yarn-lient
--class org.apache.spark.examples.SparkPi ../lib/spark-examples-1.6.0-hadoop2.6.0.jar 100
./spark-submit
--master yarn --deploy-mode
client --class org.apache.spark.examples.SparkPi ../lib/spark-examples-1.6.0-hadoop2.6.0.jar 100
执行原理图解 执行流程 客户端提交一个Application，在客户端启动一个Driver进程。Driver进程会向RS(ResourceManager)发送请求，启动AM(ApplicationMaster)的资源。RS收到请求，随机选择一台NM(NodeManager)启动AM。这里的NM相当于Standalone中的Worker节点。AM启动后，会向RS请求一批container资源，用于启动Executor.RS会找到一批NM返回给AM,用于启动Executor。AM会向NM发送命令启动Executor。Executor启动后，会反向注册给Driver，Driver发送task到Executor,执行情况和结果返回给Driver端。总结
1、Yarn-client模式同样是适用于测试，因为Driver运行在本地，Driver会与yarn集群中的Executor进行大量的通信，会造成客户机网卡流量的大量增加.
2、 ApplicationMaster的作用：
为当前的Application申请资源
给NodeManager发送消息启动Executor。
注意：ApplicationMaster有launchExecutor和申请资源的功能，并没有作业调度的功能。 2、yarn-cluster提交任务方式提交命令
./spark-submit --master yarn --deploy-mode cluster
--class org.apache.spark.examples.SparkPi ../lib/spark-examples-1.6.0-hadoop2.6.0.jar 100
./spark-submit
--master yarn-cluster
--class org.apache.spark.examples.SparkPi ../lib/spark-examples-1.6.0-hadoop2.6.0.jar 100
结果在yarn的日志里面：执行原理
执行流程客户机提交Application应用程序，发送请求到RS(ResourceManager),请求启动AM(ApplicationMaster)。RS收到请求后随机在一台NM(NodeManager)上启动AM（相当于Driver端）。AM启动，AM发送请求到RS，请求一批container用于启动Executor。RS返回一批NM节点给AM。AM连接到NM,发送请求到NM启动Executor。Executor反向注册到AM所在的节点的Driver。Driver发送task到Executor。总结
1、Yarn-Cluster主要用于生产环境中，因为Driver运行在Yarn集群中某一台nodeManager中，每次提交任务的Driver所在的机器都是随机的，不会产生某一台机器网卡流量激增的现象，缺点是任务提交后不能看到日志。只能通过yarn查看日志。
2.ApplicationMaster的作用：
为当前的Application申请资源
给nodemanager发送消息 启动Excutor。
任务调度。(这里和client模式的区别是AM具有调度能力，因为其就是Driver端，包含Driver进程)
3、 停止集群任务命令：yarn application -kill applicationID 自我最后总结：stand-alone模式中Master发送对应的命令启动Worker上的executor进程，而yarn模式中的applimaster也是负责启动worker中的Driver进程，可见都是master负责发送消息，然后再对应的节点上启动executor进程。菲官方证实，仅供理解！！！
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！Spark中yarn模式两种提交任务方式
Spark可以和Yarn整合，将Application提交到Yarn上运行，和StandAlone提交模式一样，Yarn也有两种提交任务的方式。
1、yarn-client提交任务方式
在client节点配置中spark-env.sh添加Hadoop_HOME的配置目录即可提交yarn 任务，具体步骤如下：
注意client只需要有Spark的安装包即可提交任务，不需要其他配置（比如slaves）!!!
./spark-submit --master yarn? --class org.apache.spark.examples.SparkPi? ../lib/spark-examples-1.6.0-hadoop2.6.0.jar 100
./spark-submit?? --master yarn-lient?? --class org.apache.spark.examples.SparkPi ../lib/spark-examples-1.6.0-hadoop2.6.0.jar 100
./spark-submit? --master yarn?--deploy-mode ?client?--class org.apache.spark.examples.SparkPi ../lib/spark-examples-1.6.0-hadoop2.6.0.jar?100
执行原理图解
客户端提交一个Application，在客户端启动一个Driver进程。Driver进程会向RS(ResourceManager)发送请求，启动AM(ApplicationMaster)的资源。RS收到请求，随机选择一台NM(NodeManager)启动AM。这里的NM相当于Standalone中的Worker节点。AM启动后，会向RS请求一批container资源，用于启动Executor.RS会找到一批NM返回给AM,用于启动Executor。AM会向NM发送命令启动Executor。Executor启动后，会反向注册给Driver，Driver发送task到Executor,执行情况和结果返回给Driver端。总结
1、Yarn-client模式同样是适用于测试，因为Driver运行在本地，Driver会与yarn集群中的Executor进行大量的通信，会造成客户机网卡流量的大量增加.
2、 ApplicationMaster的作用：
为当前的Application申请资源
给NodeManager发送消息启动Executor。
注意：ApplicationMaster有launchExecutor和申请资源的功能，并没有作业调度的功能。
2、yarn-cluster提交任务方式
./spark-submit?--master yarn?--deploy-mode cluster??--class org.apache.spark.examples.SparkPi ../lib/spark-examples-1.6.0-hadoop2.6.0.jar?100
./spark-submit?? --master yarn-cluster? --class org.apache.spark.examples.SparkPi ../lib/spark-examples-1.6.0-hadoop2.6.0.jar 100
结果在yarn的日志里面：
执行流程客户机提交Application应用程序，发送请求到RS(ResourceManager),请求启动AM(ApplicationMaster)。RS收到请求后随机在一台NM(NodeManager)上启动AM（相当于Driver端）。AM启动，AM发送请求到RS，请求一批container用于启动Executor。RS返回一批NM节点给AM。AM连接到NM,发送请求到NM启动Executor。Executor反向注册到AM所在的节点的Driver。Driver发送task到Executor。总结
1、Yarn-Cluster主要用于生产环境中，因为Driver运行在Yarn集群中某一台nodeManager中，每次提交任务的Driver所在的机器都是随机的，不会产生某一台机器网卡流量激增的现象，缺点是任务提交后不能看到日志。只能通过yarn查看日志。
2.ApplicationMaster的作用：
&为当前的Application申请资源
给nodemanager发送消息 启动Excutor。
任务调度。(这里和client模式的区别是AM具有调度能力，因为其就是Driver端，包含Driver进程)
3、 停止集群任务命令：yarn application -kill applicationID
自我最后总结：stand-alone模式中Master发送对应的命令启动Worker上的executor进程，而yarn模式中的applimaster也是负责启动worker中的Driver进程，可见都是master负责发送消息，然后再对应的节点上启动executor进程。菲官方证实，仅供理解！！！}