Spark 常见问题汇总-1
时间： 11:51:33
&&&& 阅读：869
&&&& 评论：
&&&& 收藏：0
标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&转自:&/Scott007/p/3889959.html, 博客时间
版本：未知
& & Spark的on Yarn模式，其资源分配是交给Yarn的ResourceManager来进行管理的，但是目前的Spark版本，Application日志的查看，只能通过Yarn的yarn logs命令实现。
&&& 在部署和运行Spark Application的过程中，如果不注意一些小的细节，也许会导致一些问题的出现。
&&& 部署好Spark的包和配置文件，on yarn的两种模式都无法运行，在NodeManager端的日志都是说Connection Refused，连接不上Driver所在的客户端节点，但是客户端的80端口可以正常访问！同时，在日志中有类似信息出现：
Initial job has not ac check your cluster UI to ensure that workers are registered and have sufficient memory
内存肯定是够的，但就是无法获取资源！检查防火墙，果然客户端只开启的对80端口的访问，其他都禁止了！如果你的程序在运行的时候也有类似连接被拒绝的情况，最好也是先检查下防火墙的配置！
3 Spark Driver程序host的指定
&&& 部署完Spark后，分别使用yarn-cluster模式和yarn-client模式运行Spark自带的计算pi的示例。
&&& Spark的一些配置文件除了一些基本属性外，均未做配置，结果运行的时候两种运行模式出现了不同的状况。yarn-cluster模式可以正常运行，yarn-client模式总是运行失败。查看ResourceManager、NodeManager端的日志，发现程序总是找不到ApplicationMaster，这就奇怪了！并且，客户端的Driver程序开启的端口，在NodeManager端访问被拒绝！非Spark的其他MR任务，能够正常执行。
检查客户端配置文件，发现原来在客户端的/etc/hosts文件中，客户端的一个IP对应了多个Host，Driver程序会默认去取最后对应的那个Host，比如是hostB，但是在NodeManager端是配置的其他Host，hostA，所以导致程序无法访问。为了不影响其他的程序使用客户端的Host列表，这里在Spark配置文件spark-defaults.conf中使用属性spark.driver.host来指定yarn-client模式运行中和Yarn通信的DriverHost，此时yarn-client模式可以正常运行。
上面配置完了之后，发现yarn-cluster模式又不能运行了！想想原因，肯定是上面那个配置参数搞的鬼，注释掉之后，yarn-cluster模式可以继续运行。原因是，yarn-cluster模式下，spark的入口函数是在客户端运行，但是Driver的其他功能是在ApplicationMaster中运行的，上面的那个配置相当于指定了ApplicationMaster的地址，实际上的ApplicationMaster在yarn-master模式下是由ResourceManager随机指定的。
4 on& Yarn日志的查看
&&& 测试环境下，通过yarn logs -applicationId xxx可以查看运行结束的Application的日志，但是搞到另一个环境下发现使用上述命令查看日志时，总是提示如下信息：
Logs not available at /tmp/nm/remote/logs/hadoop/logs/application_xxx_xxx
Log aggregation has not completed or is not enabled.
&&& 去对应的NodeManger目录下，确实找不到日志文件。但是/tmp/nm/remote/logs却是在yarn-site.xml中指定了的目录，这个是对的，到底什么原因呢？难道是Yarn的日志聚集没有起作用？
&&& 去NodeManager上查看对应Application的日志：
09:14:47,513 INFO org.apache.hadoop.yarn.server.nodemanager.containermanager.logaggregation.AppLogAggregatorImpl: Starting aggregate log-file for app application_xxx_xxx at /tmp/nm/remote/logs/spark/logs/application_xxx_xxx/hostB.tmp
09:14:47,525 INFO org.apache.hadoop.yarn.server.nodemanager.containermanager.logaggregation.AppLogAggregatorImpl: Uploading logs for container container_xxx_xxx_01_000007. Current good log dirs are /data/nm/log
09:14:47,526 INFO org.apache.hadoop.yarn.server.nodemanager.containermanager.logaggregation.AppLogAggregatorImpl: Uploading logs for container container_xxx_xxx_000001. Current good log dirs are /data/nm/log
09:14:47,526 INFO org.apache.hadoop.yarn.server.nodemanager.DefaultContainerExecutor: Deleting path : /data/nm/log/application_xxx_xxx
09:14:47,607 INFO org.apache.hadoop.yarn.server.nodemanager.containermanager.logaggregation.AppLogAggregatorImpl: Finished aggregate log-file for app application_xxx_xxx
&&& 可见，日志聚集确实起作用了，但是为什么通过命令不能查看！猛然见看到日志中&/tmp/nm/remote/logs/spark/logs/ application_xxx_xxx/hostB.tmp&，日志的路径有问题，在使用yarn logs命令查看的时候，用的是hadoop用户，实际Spark Application的提交执行用的是spark用户，而yarn logs命令默认去找的是当前用户的路径，这就是查看不到日志的原因。切换到spark用户再查看，日志终于出来了！
5 LZO相关问题
&&& 如果在Spark中使用了LZO作为EventLog的的压缩算法等，就得实现安装好LZO这个东东，否则会出现类似于如下的异常：
Caused by: java.lang.IllegalArgumentException: Compression codec pression.lzo.LzoCodec not found.
at org.apache.pressionCodecFactory.getCodecClasses(CompressionCodecFactory.java:134)
at org.apache.pressionCodecFactory.&init&(CompressionCodecFactory.java:174)
at org.apache.hadoop.mapred.TextInputFormat.configure(TextInputFormat.java:45)
... 66 more
Caused by: java.lang.ClassNotFoundException: Class pression.lzo.LzoCodec not found
at org.apache.hadoop.conf.Configuration.getClassByName(Configuration.java:1680)
at org.apache.pressionCodecFactory.getCodecClasses(CompressionCodecFactory.java:127)
... 68 more
[ERROR] [ 10:34:41 933] pression.lzo.GPLNativeCodeLoader [main] (GPLNativeCodeLoader.java:36) Could not load native gpl library
java.lang.UnsatisfiedLinkError: no gplcompression in java.library.path
&&& 解决办法就是得安装好LZO，并且在HDFS、SPARK中配置好相关的包、文件等，具体步骤见：
http://find.searchhub.org/document/afe4ec6
/twitter/hadoop-lzo/blob/master/README.md
/posts//enable-lzo-compression-on-hadoop-pig-and-spark/
6 Spark Hive无法访问Mysql的问题
&&& 生产环境下，节点之间肯定是有防火墙限制的，而且Hive的元数据库Mysql，更是对请求的IP和用户等限制的严格，如果在Spark集群中使用yarn-cluster模式进行提交Spark的Application，其运行时Driver是和ApplicationMaster运行在一起，由Yarn的ResourceManager负责分配到集群中的某个NodeManager节点上，如果在Hive-site.xml中只配置了Mysql数据库而没有配置MetaStore的话，也许会遇到连接元数据库失败的问题，此时，就得看下Hive-site.xml的配置，是否Mysql的相关权限配置正确、MetaStore服务是否可以正常连接。
7 内存溢出问题
& & 在Spark中使用hql方法执行hive语句时，由于其在查询过程中调用的是Hive的获取元数据信息、SQL解析，并且使用Cglib等进行序列化反序列化，中间可能产生较多的class文件，导致JVM中的持久代使用较多，如果配置不当，可能引起类似于如下的OOM问题：
Exception in thread "Thread-2" java.lang.OutOfMemoryError: PermGen space
& & 原因是实际使用时，如果用的是JDK1.6版本，Server模式的持久代默认大小是64M，Client模式的持久代默认大小是32M，而Driver端进行SQL处理时，其持久代的使用可能会达到90M，导致OOM溢出，任务失败。
解决方法就是在Spark的conf目录中的spark-defaults.conf里，增加对Driver的JVM配置，因为Driver才负责SQL的解析和元数据获取。配置如下：
spark.driver.extraJavaOptions -XX:PermSize=128M -XX:MaxPermSize=256M& &
　　但是，上述情况是在yarn-cluster模式下出现，yarn-client模式运行时倒是正常的，原来在$SPARK_HOME/bin/spark-class文件中已经设置了持久代大小：
JAVA_OPTS="-XX:MaxPermSize=256m $OUR_JAVA_OPTS"
& & 当以yarn-client模式运行时，driver就运行在客户端的spark-submit进程中，其JVM参数是取的spark-class文件中的设置，所谓未出现持久代溢出现象。
& & 总结一下Spark中各个角色的JVM参数设置：& &&
(1)Driver的JVM参数：-Xmx，-Xms，如果是yarn-client模式，则默认读取spark-env文件中的SPARK_DRIVER_MEMORY值，-Xmx，-Xms值一样大小；如果是yarn-cluster模式，则读取的是spark-default.conf文件中的spark.driver.extraJavaOptions对应的JVM参数值。PermSize，如果是yarn-client模式，则是默认读取spark-class文件中的JAVA_OPTS="-XX:MaxPermSize=256m $OUR_JAVA_OPTS"值；如果是yarn-cluster模式，读取的是spark-default.conf文件中的spark.driver.extraJavaOptions对应的JVM参数值。GC方式，如果是yarn-client模式，默认读取的是spark-class文件中的JAVA_OPTS；如果是yarn-cluster模式，则读取的是spark-default.conf文件中的spark.driver.extraJavaOptions对应的参数值。以上值最后均可被spark-submit工具中的--driver-java-options参数覆盖。
(2)Executor的JVM参数：-Xmx，-Xms，如果是yarn-client模式，则默认读取spark-env文件中的SPARK_EXECUTOR_MEMORY值，-Xmx，-Xms值一样大小；如果是yarn-cluster模式，则读取的是spark-default.conf文件中的spark.executor.extraJavaOptions对应的JVM参数值。PermSize，两种模式都是读取的是spark-default.conf文件中的spark.executor.extraJavaOptions对应的JVM参数值。GC方式，两种模式都是读取的是spark-default.conf文件中的spark.executor.extraJavaOptions对应的JVM参数值。
(3)Executor数目及所占CPU个数如果是yarn-client模式，Executor数目由spark-env中的SPARK_EXECUTOR_INSTANCES指定，每个实例的数目由SPARK_EXECUTOR_CORES指定；如果是yarn-cluster模式，Executor的数目由spark-submit工具的--num-executors参数指定，默认是2个实例，而每个Executor使用的CPU数目由--executor-cores指定，默认为1核。每个Executor运行时的信息可以通过yarn logs命令查看到，类似于如下：
14/08/13 18:12:59 INFO org.apache.spark.Logging$class.logInfo(Logging.scala:58): Setting up executor with commands: List($JAVA_HOME/bin/java, -server, -XX:OnOutOfMemoryError=‘kill %p‘, -Xms1024m -Xmx1024m , -XX:PermSize=256M -XX:MaxPermSize=256M -verbose:gc -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintHeapAtGC -Xloggc:/tmp/spark_gc.log, -Djava.io.tmpdir=$PWD/tmp, -Dlog4j.configuration=log4j-spark-container.properties, org.apache.spark.executor.CoarseGrainedExecutorBackend, akka.tcp::41606/user/CoarseGrainedScheduler, 1, sparktest2, 3, 1&, &LOG_DIR&/stdout, 2&, &LOG_DIR&/stderr)
& & 其中，akka.tcp::在节点，后面的1表示Executor编号，sparktest2表示ApplicationMaster的host，接着的3表示当前Executor所占用的CPU数目。
8 序列化异常
在Spark上执行hive语句的时候，出现类似于如下的异常：
org.apache.spark.SparkDriverExecutionException: Execution error
at org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:849)
at org.apache.spark.scheduler.DAGSchedulerEventProcessActor$$anonfun$receive$2.applyOrElse(DAGScheduler.scala:1231)
at akka.actor.ActorCell.receiveMessage(ActorCell.scala:498)
at akka.actor.ActorCell.invoke(ActorCell.scala:456)
at akka.dispatch.Mailbox.processMailbox(Mailbox.scala:237)
at akka.dispatch.Mailbox.run(Mailbox.scala:219)
at akka.dispatch.ForkJoinExecutorConfigurator$AkkaForkJoinTask.exec(AbstractDispatcher.scala:386)
at scala.concurrent.forkjoin.ForkJoinTask.doExec(ForkJoinTask.java:260)
at scala.concurrent.forkjoin.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:1339)
at scala.concurrent.forkjoin.ForkJoinPool.runWorker(ForkJoinPool.java:1979)
at scala.concurrent.forkjoin.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:107)
Caused by: java.lang.ClassCastException: scala.collection.mutable.HashSet cannot be cast to scala.collection.mutable.BitSet
at org.apache.spark.sql.execution.BroadcastNestedLoopJoin$$anonfun$7.apply(joins.scala:336)
at org.apache.spark.rdd.RDD$$anonfun$19.apply(RDD.scala:813)
at org.apache.spark.rdd.RDD$$anonfun$19.apply(RDD.scala:810)
at org.apache.spark.scheduler.JobWaiter.taskSucceeded(JobWaiter.scala:56)
at org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:845)
　　排查其前后的日志，发现大都是序列化的东西：
14/08/13 11:10:01 INFO org.apache.spark.Logging$class.logInfo(Logging.scala:58): Serialized task 8.0:3 as 20849 bytes in 0 ms
14/08/13 11:10:01 INFO org.apache.spark.Logging$class.logInfo(Logging.scala:58): Finished TID 813 in 25 ms on sparktest0 (progress: 3/200)
　　而在spark-default.conf中，事先设置了序列化方式为Kryo：
spark.serializer org.apache.spark.serializer.KryoSerializer
根据异常信息，可见是HashSet转为BitSet类型转换失败，Kryo把松散的HashSet转换为了紧凑的BitSet，把序列化方式注释掉之后，任务可以正常执行。难道Spark的Kryo序列化做的还不到位？此问题需要进一步跟踪。
9 Executor僵死问题
&&& 运行一个Spark任务，发现其运行速度远远慢于执行同样SQL语句的Hive的执行，甚至出现了OOM的错误，最后卡住达几小时！并且Executor进程在疯狂GC。
&&& 截取其一Task的OOM异常信息：
可以看到这是在序列化过程中发生的OOM。根据节点信息，找到对应的Executor进程，观察其Jstack信息：
Thread 36169: (state = BLOCKED)
- java.lang.Long.valueOf(long) @bci=27, line=557 (Compiled frame)
- com.esotericsoftware.kryo.serializers.DefaultSerializers$LongSerializer.read(com.esotericsoftware.kryo.Kryo, com.esotericsoftware.kryo.io.Input, java.lang.Class) @bci=5, line=113 (Compiled frame)
- com.esotericsoftware.kryo.serializers.DefaultSerializers$LongSerializer.read(com.esotericsoftware.kryo.Kryo, com.esotericsoftware.kryo.io.Input, java.lang.Class) @bci=4, line=103 (Compiled frame)
- com.esotericsoftware.kryo.Kryo.readClassAndObject(com.esotericsoftware.kryo.io.Input) @bci=158, line=732 (Compiled frame)
- com.esotericsoftware.kryo.serializers.DefaultArraySerializers$ObjectArraySerializer.read(com.esotericsoftware.kryo.Kryo, com.esotericsoftware.kryo.io.Input, java.lang.Class) @bci=158, line=338 (Compiled frame)
- com.esotericsoftware.kryo.serializers.DefaultArraySerializers$ObjectArraySerializer.read(com.esotericsoftware.kryo.Kryo, com.esotericsoftware.kryo.io.Input, java.lang.Class) @bci=4, line=293 (Compiled frame)
- com.esotericsoftware.kryo.Kryo.readObject(com.esotericsoftware.kryo.io.Input, java.lang.Class, com.esotericsoftware.kryo.Serializer) @bci=136, line=651 (Compiled frame)
- com.esotericsoftware.kryo.serializers.FieldSerializer$ObjectField.read(com.esotericsoftware.kryo.io.Input, java.lang.Object) @bci=143, line=605 (Compiled frame)
- com.esotericsoftware.kryo.serializers.FieldSerializer.read(com.esotericsoftware.kryo.Kryo, com.esotericsoftware.kryo.io.Input, java.lang.Class) @bci=44, line=221 (Compiled frame)
- com.esotericsoftware.kryo.Kryo.readObject(com.esotericsoftware.kryo.io.Input, java.lang.Class, com.esotericsoftware.kryo.Serializer) @bci=136, line=651 (Compiled frame)
- com.esotericsoftware.kryo.serializers.FieldSerializer$ObjectField.read(com.esotericsoftware.kryo.io.Input, java.lang.Object) @bci=143, line=605 (Compiled frame)
- com.esotericsoftware.kryo.serializers.FieldSerializer.read(com.esotericsoftware.kryo.Kryo, com.esotericsoftware.kryo.io.Input, java.lang.Class) @bci=44, line=221 (Compiled frame)
- com.esotericsoftware.kryo.Kryo.readClassAndObject(com.esotericsoftware.kryo.io.Input) @bci=158, line=732 (Compiled frame)
- org.apache.spark.serializer.KryoDeserializationStream.readObject(scala.reflect.ClassTag) @bci=8, line=118 (Compiled frame)
- org.apache.spark.serializer.DeserializationStream$$anon$1.getNext() @bci=10, line=125 (Compiled frame)
- org.apache.spark.util.NextIterator.hasNext() @bci=16, line=71 (Compiled frame)
- org.apache.spark.storage.BlockManager$LazyProxyIterator$1.hasNext() @bci=4, line=1031 (Compiled frame)
- scala.collection.Iterator$$anon$13.hasNext() @bci=4, line=371 (Compiled frame)
- org.apache.pletionIterator.hasNext() @bci=4, line=30 (Compiled frame)
- org.apache.spark.InterruptibleIterator.hasNext() @bci=22, line=39 (Compiled frame)
- scala.collection.Iterator$$anon$11.hasNext() @bci=4, line=327 (Compiled frame)
- org.apache.spark.sql.execution.HashJoin$$anonfun$execute$1.apply(scala.collection.Iterator, scala.collection.Iterator) @bci=14, line=77 (Compiled frame)
- org.apache.spark.sql.execution.HashJoin$$anonfun$execute$1.apply(java.lang.Object, java.lang.Object) @bci=9, line=71 (Interpreted frame)
- org.apache.spark.pute(org.apache.spark.Partition, org.apache.spark.TaskContext) @bci=48, line=87 (Interpreted frame)
- org.apache.spark.puteOrReadCheckpoint(org.apache.spark.Partition, org.apache.spark.TaskContext) @bci=26, line=262 (Interpreted frame)
有大量的BLOCKED线程，继续观察GC信息，发现大量的FULL GC。
&&& 分析，在插入Hive表的时候，实际上需要写HDFS，在此过程的HashJoin时，伴随着大量的Shuffle写操作，JVM的新生代不断GC，Eden Space写满了就往Survivor Space写，同时超过一定大小的数据会直接写到老生代，当新生代写满了之后，也会把老的数据搞到老生代，如果老生代空间不足了，就触发FULL GC，还是空间不够，那就OOM错误了，此时线程被Blocked，导致整个Executor处理数据的进程被卡住。
&当处理大数据的时候，如果JVM配置不当就容易引起上述问题。解决的方法就是增大Executor的使用内存，合理配置新生代和老生代的大小，可以将老生代的空间适当的调大点。
&&& 问题是比较严重，Application都直接无法运行了，但是引起问题的原因都比较小，归根结底还是部署的时候环境较为复杂，不够仔细！再接再砺！以后遇到相关的问题，会再这里持续更新，方便自己，也方便遇到类似问题的朋友们！标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&原文：/njuzhoubing/p/4171311.html
教程昨日排行
&&国之画&&&& &&&&&&
&& &&&&&&&&&&&&&&
鲁ICP备号-4
打开技术之扣，分享程序人生！Spark（4）
Spark 2.1.0支持的运行模式
　　Spark支持多种运行模式，可以在集群环境中运行，也可以单机本地运行，或者在单机上部署伪分布集群来运行Spark。
　　Spark 2.1.0原生支持三种集群：Spark原生提供的Standalone集群，以及外部资源调度框架Apache Mesos和Hadoop Yarn。
目前随着Kubernetes的火热，Spark on K8S的呼声也越来越高。预计不久将来Kube应该也会成为Spark原生支持的外部集群框架。
　　Spark应用程序通过设置SparkContext中的Master URL来指定运行模式，各种运行模式以及传递的Master URL总结如下：
Master URL
本地单线程运行Spark(无任何并行)
本地K条线程运行Spark(K的理想值为当前节点CPU核心数)
使用与本地CPU核心数一致的工作线程来运行Spark
spark://HOST:PORT
Standalone模式。HOST:PORT指定了集群Master的地址与端口（缺省端口7077）
mesos://HOST:PORT
Mesos模式，依赖Mesos来调度Spark使用的资源。HOST:PORT指定了Mesos集群MesosClusterDispatcher的地址与端口（缺省端口5050）。 如果Mesos集群使用了ZooKeeper ZooKeeper，则URL需要写成：“mesos://zk://…”
Yarn模式，依赖Apache Yarn来调度Spark使用的资源。 Yarn集群配置信息要存放到$HADOOP_CONF_DIR或者$YARN_CONF_DIR目录下
Spark的运行流程以及相关概念
Spark的运行流程简述
　　Spark应用在独立的集群中的一组进程上执行，Spark应用的Driver program生成SparkContext，SparkContext负责整个Spark应用运行时的协调，包括运行资源的申请、任务的分配和监控等。
　　Spark应用运行的逻辑流程图如下：
Driver启动后生成SparkContext，SparkContext连接至Cluster Manager，这里的Cluster Manager可以是Standalone cluster manager、Mesos或YARN；
Cluster Manager为Spark应用分配运行资源，即Worker节点上的Executor；
Spark发送Spark应用(Jar文件或Python文件)至Executor；
Spark分配Task给Executor，Executor执行Spark应用计算，存取Spark应用数据；
SparkContext监控Task执行结果；
Spark相关概念
Application
用户编写的Spark应用程序，包含一个Driver程序和一组分布在集群中多个节点上运行的Executor程序
Application jar
包含了用户Spark Application可执行程序的Jar文件。用户也可以创建一个包含Spark Application可执行程序以及全部依赖包的所谓”uber jar”。用户的Jar文件中不应包含Hadoop或者是Spark的类库
Driver program
运行Spark Application的main()函数并且创建SparkContext的一段程序
SparkContext
包含了Spark Application的运行环境和配置，负责与ClusterManager通信，进行资源的申请、任务的分配和监控等；当Executor部分运行完毕后，Driver负责将SparkContext关闭
Cluster manager
Spark外部的服务，负责为Spark Application分配运行资源 (比如Standalone、Mesos、YARN)
Deploy mode
用来指定Driver程序在哪里运行。”cluster”模式下Driver程序运行在集群内部；”client”模式下Driver程序在提交Spark应用的进程中，而不是在集群内部被执行
Worker node
Spark集群中任何用于运行Spark Application的节点。在Standalone模式中即通过start-slave.sh启动的工作节点；在Yarn模式中即NodeManager节点
Spark Application运行在Worker节点上的一个进程，该进程负责运行Task，并且负责将数据存在内存或者磁盘上，每个Application都有各自独立的一组Executor。
被分配到某Executor上执行的任务单位
包含若干Task的并行计算，由Spark Action(比如save、collect等)产生；在Driver的Log中可以查看Job的执行
每个Job会被拆分成多组Task集合，称之为Stage。与MapReduce中的map和reduce stage类似
Spark各运行模式的内部实现
本章内容引自：天戈朱
Standalone独立集群运行模式
　　Standalone模式使用Spark自带的资源调度框架，采用Master/Slaves的典型架构，选用ZooKeeper来实现Master的HA框架结构图如下:
　　该模式主要的节点有Client节点、Master节点和Worker节点。其中Driver既可以运行在Master节点上中，也可以运行在本地Client端。当用spark-shell交互式工具提交Spark的Job时，Driver在Master节点上运行；当使用spark-submit工具提交Job或者在Eclips、IDEA等开发平台上使用”new SparkConf.setManager(“spark://master:7077”)”方式运行Spark任务时，Driver是运行在本地Client端上的。
　　运行过程如下图：
SparkContext连接到Master，向Master注册并申请资源（CPU Core 和Memory）
Master根据SparkContext的资源申请要求和Worker心跳周期内报告的信息决定在哪个Worker上分配资源，然后在该Worker上获取资源，然后启动StandaloneExecutorBackend；
StandaloneExecutorBackend向SparkContext注册；
SparkContext将Applicaiton代码发送给StandaloneExecutorBackend；并且SparkContext解析Applicaiton代码，构建DAG图，并提交给DAG Scheduler分解成Stage（当碰到Action操作时，就会催生Job；每个Job中含有1个或多个Stage，Stage一般在获取外部数据和shuffle之前产生），然后以Stage（或者称为TaskSet）提交给Task Scheduler，Task Scheduler负责将Task分配到相应的Worker，最后提交给StandaloneExecutorBackend执行；
StandaloneExecutorBackend会建立Executor线程池，开始执行Task，并向SparkContext报告，直至Task完成
所有Task完成后，SparkContext向Master注销，释放资源
YARN-Client运行模式
　　Spark on YARN模式根据Driver在集群中的位置分为两种模式：一种是YARN-Client模式，另一种是YARN-Cluster（或称为YARN-Standalone模式）。
　　Yarn-Client模式中，Driver在客户端本地运行，这种模式可以使得Spark Application和客户端进行交互，因为Driver在客户端，所以可以通过webUI访问Driver的状态，默认是访问，而YARN通过http:// hadoop1:8088访问
　　YARN-client的工作流程步骤为：
Spark Yarn Client向YARN的ResourceManager申请启动Application Master。同时在SparkContent初始化中将创建DAGScheduler和TASKScheduler等，由于我们选择的是Yarn-Client模式，程序会选择YarnClientClusterScheduler和YarnClientSchedulerBackend
ResourceManager收到请求后，在集群中选择一个NodeManager，为该应用程序分配第一个Container，要求它在这个Container中启动应用程序的ApplicationMaster，与YARN-Cluster区别的是在该ApplicationMaster不运行SparkContext，只与SparkContext进行联系进行资源的分派
Client中的SparkContext初始化完毕后，与ApplicationMaster建立通讯，向ResourceManager注册，根据任务信息向ResourceManager申请资源（Container）
一旦ApplicationMaster申请到资源（也就是Container）后，便与对应的NodeManager通信，要求它在获得的Container中启动CoarseGrainedExecutorBackend，CoarseGrainedExecutorBackend启动后会向Client中的SparkContext注册并申请Task
client中的SparkContext分配Task给CoarseGrainedExecutorBackend执行，CoarseGrainedExecutorBackend运行Task并向Driver汇报运行的状态和进度，以让Client随时掌握各个任务的运行状态，从而可以在任务失败时重新启动任务
应用程序运行完成后，Client的SparkContext向ResourceManager申请注销并关闭自己
YARN-Cluster运行模式
　　在YARN-Cluster模式中，当用户向YARN中提交一个应用程序后，YARN将分两个阶段运行该应用程序：
1. 第一个阶段是把Spark的Driver作为一个ApplicationMaster在YARN集群中先启动；
2. 第二个阶段是由ApplicationMaster创建应用程序，然后为它向ResourceManager申请资源，并启动Executor来运行Task，同时监控它的整个运行过程，直到运行完成
　　YARN-cluster的工作流程分为以下几个步骤
Spark Yarn Client向YARN中提交应用程序，包括ApplicationMaster程序、启动ApplicationMaster的命令、需要在Executor中运行的程序等
ResourceManager收到请求后，在集群中选择一个NodeManager，为该应用程序分配第一个Container，要求它在这个Container中启动应用程序的ApplicationMaster，其中ApplicationMaster进行SparkContext等的初始化
ApplicationMaster向ResourceManager注册，这样用户可以直接通过ResourceManage查看应用程序的运行状态，然后它将采用轮询的方式通过RPC协议为各个任务申请资源，并监控它们的运行状态直到运行结束
一旦ApplicationMaster申请到资源（也就是Container）后，便与对应的NodeManager通信，要求它在获得的Container中启动CoarseGrainedExecutorBackend，CoarseGrainedExecutorBackend启动后会向ApplicationMaster中的SparkContext注册并申请Task。这一点和Standalone模式一样，只不过SparkContext在Spark Application中初始化时，使用CoarseGrainedSchedulerBackend配合YarnClusterScheduler进行任务的调度，其中YarnClusterScheduler只是对TaskSchedulerImpl的一个简单包装，增加了对Executor的等待逻辑等
ApplicationMaster中的SparkContext分配Task给CoarseGrainedExecutorBackend执行，CoarseGrainedExecutorBackend运行Task并向ApplicationMaster汇报运行的状态和进度，以让ApplicationMaster随时掌握各个任务的运行状态，从而可以在任务失败时重新启动任务
应用程序运行完成后，ApplicationMaster向ResourceManager申请注销并关闭自己
Spark Client模式和Cluster模式的区别:
理解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不能离开
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：2851次
排名：千里之外