[]{#_Spark .anchor}Spark
[Spark 1](\l)
[1. 什么是Spark 3](\l)
[1.1. Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎
3](\l)
[1.2. Spark 拥有Hadoop MapReduce 所具有的优点；但不同于MapReduce 的是Job
中间输出结果可以缓存在内存中，从而不再需要读写HDFS ，减少磁盘数据交互
3](\l)
[1.3. ，因此Spark 能更好地适用于数据挖掘与机器学习等需要迭代的算法
3](\l)
[2. 总体技术栈讲解 3](\l)
[2.2. Spark 提供了Sparkcore RDD 、Spark SQL 、Spark Streaming 、Spark
MLlib 、Spark
GraphX等技术组件，可以一站式地完成大数据领域的离线批处理、交互式查询、流式计算、机器学习、图计算
等常见的任务。这就是spark 一站式开发的特点
3](\l)
[3. Spark 与MR 的区别 4](\l)
[3.1. 都是分布式计算框架， Spark 计算中间结果基于内存缓存， MapReduce
基于HDFS 存储。也正因此，Spark 处理数据的能力一般是MR 的三到五倍以上，
Spark 中除了基于内存计算这一个计算快的原因，还有DAG（DAGShecdule）
有向无环图来切分任务的执行先后顺序。
4](\l)
[4. Spark 运行模式 4](\l)
[4.1. Local 4](\l)
[4.2. Standalone 4](\l)
[4.3. Yarn 4](\l)
[4.4. Mesos 4](\l)
[5. SparkCore 4](\l)
[5.1. Partition 4](\l)
[5.2. 分区方式 5](\l)
[5.3. HashPartitioner 5](\l)
[5.4. RDD 5](\l)
[5.5. Lineage血统 8](\l)
[5.6. 系统架构 8](\l)
[6. 算子(单文件) 10](\l)
[6.1. Spark 记录了 RDD 之间的生成和依赖关系。但是只有当 F
进行行动操作时，Spark 才会根据 RDD的依赖关系生成
DAG，并从起点开始真正的计算
10](\l)
[6.3. 转换算子 11](\l)
[6.4. 行动算子 11](\l)
[6.5. 控制算子 12](\l)
[7. 任务提交方式 14](\l)
[7.1. Standalone-client 14](\l)
[7.2. Standalone-cluster 16](\l)
[7.3. yarn-client 17](\l)
[7.4. yarn-cluster 19](\l)
[8. 执行流程 21](\l)
多用于本地测试，如在eclipse ， idea 中写程序测试等 {#多用于本地测试如在eclipse-idea-中写程序测试等 .list-paragraph}
Standalone
Standalone 是Spark 自带的一个资源调度框架，它支持完全分布式。 {#standalone-是spark-自带的一个资源调度框架它支持完全分布式 .list-paragraph}
Yarn
Hadoop 生态圈里面的一个资源调度框架， Spark 也是可以基于Yarn 来计算的 {#hadoop-生态圈里面的一个资源调度框架-spark-也是可以基于yarn-来计算的 .list-paragraph}
Mesos
资源调度框架 {#资源调度框架 .list-paragraph}
Spark RDD 是一种分布式的数据集，由于数据量很大，因此要它被切分并存储在各个结点的分区当中。 {#spark-rdd-是一种分布式的数据集由于数据量很大因此要它被切分并存储在各个结点的分区当中 .list-paragraph}
Spark中，RDD（Resilient Distributed Dataset）是其最基本的抽象数据集，其中每个RDD是由若干个Partition组成。 {#spark中rddresilient-distributed-dataset是其最基本的抽象数据集其中每个rdd是由若干个partition组成 .list-paragraph}
分区方式
Spark包含两种数据分区方式：HashPartitioner（哈希分区）和RangePartitioner（范围分区） {#spark包含两种数据分区方式hashpartitioner哈希分区和rangepartitioner范围分区 .list-paragraph}
在Spark Shuffle阶段中，共分为Shuffle Write阶段和Shuffle Read阶段，其中在Shuffle Write阶段中，Shuffle Map Task对数据进行处理产生中间数据，然后再根据数据分区方式对中间数据进行分区。最终Shffle Read阶段中的Shuffle Read Task会拉取Shuffle Write阶段中产生的并已经分好区的中间数据 {#在spark-shuffle阶段中共分为shuffle-write阶段和shuffle-read阶段其中在shuffle-write阶段中shuffle-map-task对数据进行处理产生中间数据然后再根据数据分区方式对中间数据进行分区最终shffle-read阶段中的shuffle-read-task会拉取shuffle-write阶段中产生的并已经分好区的中间数据 .list-paragraph}
HashPartitioner
HashPartitioner采用哈希的方式对<Key，Value>键值对数据进行分区。 {#hashpartitioner采用哈希的方式对keyvalue键值对数据进行分区 .list-paragraph}
其数据分区规则为 partitionId = Key.hashCode % numPartitions {#其数据分区规则为-partitionid-key.hashcode-numpartitions .list-paragraph}
partitionId代表该Key对应的键值对数据应当分配到的Partition标识 {#partitionid代表该key对应的键值对数据应当分配到的partition标识 .list-paragraph}
Key.hashCode表示该Key的哈希值 {#key.hashcode表示该key的哈希值 .list-paragraph}
numPartitions表示包含的Partition个数。 {#numpartitions表示包含的partition个数 .list-paragraph}
RangePartitioner {#rangepartitioner .list-paragraph}
Spark引入RangePartitioner的目的是为了解决HashPartitioner所带来的分区倾斜问题，也即分区中包含的数据量不均衡问题 {#spark引入rangepartitioner的目的是为了解决hashpartitioner所带来的分区倾斜问题也即分区中包含的数据量不均衡问题 .list-paragraph}
在Job执行过程中，一个Partition对应一个Task，此时就会使得某几个Task运行过慢。 {#在job执行过程中一个partition对应一个task此时就会使得某几个task运行过慢 .list-paragraph}
RangePartitioner基于抽样的思想来对数据进行分区 {#rangepartitioner基于抽样的思想来对数据进行分区 .list-paragraph}
RDD
RDD(Resilient Distributed Dataset) 弹性分布式数据集。 {#rddresilient-distributed-dataset-弹性分布式数据集 .list-paragraph}
RDD五大属性 {#rdd五大属性 .list-paragraph}
A list of partitions {#a-list-of-partitions .list-paragraph}
RDD 是由一系列的partition 组成的 {#rdd-是由一系列的partition-组成的 .list-paragraph}
A function for computing each split {#a-function-for-computing-each-split .list-paragraph}
函数是作用在每一个partition/split 上。 {#函数是作用在每一个partitionsplit-上 .list-paragraph}
A list of dependencies on other RDDs {#a-list-of-dependencies-on-other-rdds .list-paragraph}
RDD 之间有一系列的依赖关系 {#rdd-之间有一系列的依赖关系 .list-paragraph}
Optionally, a Partitioner for key-value RDDs {#optionally-a-partitioner-for-key-value-rdds .list-paragraph}
分区器是作用在(K,V) 格式的RDD 上 {#分区器是作用在kv-格式的rdd-上 .list-paragraph}
Optionally, a list of preferred locations to compute each split on {#optionally-a-list-of-preferred-locations-to-compute-each-split-on .list-paragraph}
RDD 提供一系列最佳的计算位置 {#rdd-提供一系列最佳的计算位置 .list-paragraph}
RDD流程图 {#rdd流程图 .list-paragraph}
{#section-1 .list-paragraph}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kmn8Sh1W-1659491320282)(media/image2.png)]
注意： {#注意 .list-paragraph}
textFile 方法底层封装的是MR 读取文件的方式，读取文件之前先进行split 切片，默认split大小是一个block 大小 {#textfile-方法底层封装的是mr-读取文件的方式读取文件之前先进行split-切片默认split大小是一个block-大小 .list-paragraph}
RDD 实际上不存储数据，这里方便理解，暂时理解为存储数据。 {#rdd-实际上不存储数据这里方便理解暂时理解为存储数据 .list-paragraph}
什么是K,V格式的RDD ? {#什么是kv格式的rdd .list-paragraph}
如果RDD 里面存储的数据都是二元组对象，那么这个RDD 我们就叫做K,V格式的RDD 。 {#如果rdd-里面存储的数据都是二元组对象那么这个rdd-我们就叫做kv格式的rdd .list-paragraph}
哪里体现RDD 的弹性（容错）？ {#哪里体现rdd-的弹性容错 .list-paragraph}
partition 数量，大小没有限制，体现了RDD 的弹性。 {#partition-数量大小没有限制体现了rdd-的弹性 .list-paragraph}
RDD 之间依赖关系，可以基于上一个RDD 重新计算出RDD 。 {#rdd-之间依赖关系可以基于上一个rdd-重新计算出rdd .list-paragraph}
哪里体现RDD 的分布式？ {#哪里体现rdd-的分布式 .list-paragraph}
RDD 是由Partition 组成， partition 是分布在不同节点上的。 {#rdd-是由partition-组成-partition-是分布在不同节点上的 .list-paragraph}
RDD 提供计算最佳位置，体现了数据本地化。体现了大数据中"计算移动数据不移动"的理念 {#rdd-提供计算最佳位置体现了数据本地化体现了大数据中计算移动数据不移动的理念 .list-paragraph}
Lineage血统
RDD 的最重要的特性之一就是血缘关系（Lineage )，它描述了一个 RDD 是如何从父 RDD 计算得 {#rdd-的最重要的特性之一就是血缘关系lineage-它描述了一个-rdd-是如何从父-rdd-计算得 .list-paragraph}
来的。如果某个 RDD 丢失了，则可以根据血缘关系，从父 RDD 计算得来 {#来的如果某个-rdd-丢失了则可以根据血缘关系从父-rdd-计算得来 .list-paragraph}
系统架构
{#section-2 .list-paragraph}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8Vqv92fz-1659491320283)(media/image3.png)]
Master ( standalone 模式)：资源管理的主节点（进程）。 {#master-standalone-模式资源管理的主节点进程 .list-paragraph}
Cluster Manager ：在集群上获取资源的外部服务（例如： standalone ； yarn ； mesos ）。 {#cluster-manager-在集群上获取资源的外部服务例如-standalone-yarn-mesos .list-paragraph}
Worker ( standalone 模式）：资源管理的从节点（进程）或者说是是管理本机资源的进程。 {#worker-standalone-模式资源管理的从节点进程或者说是是管理本机资源的进程 .list-paragraph}
Application ：基于Spark 的用户程序，包含driver 程序和运行在集群上的executor 程序，即一个完整的spark 应用 。 {#application-基于spark-的用户程序包含driver-程序和运行在集群上的executor-程序即一个完整的spark-应用 .list-paragraph}
Dirver （ program ）：用来连接工作进程（ worker ）的程序 。 {#dirver-program-用来连接工作进程-worker-的程序 .list-paragraph}
Executor ：是在一个worker 进程所管理的节点上为某Application 启动的一个个进程，这个进程负责运行任务，并且负责将数据存在内存或者磁盘上，每个应用之间都有各自独立的 {#executor-是在一个worker-进程所管理的节点上为某application-启动的一个个进程这个进程负责运行任务并且负责将数据存在内存或者磁盘上每个应用之间都有各自独立的 .list-paragraph}
Task ：被发送到executor 上的工作单元。 {#task-被发送到executor-上的工作单元 .list-paragraph}
Job ：包含很多任务（ Task ）的并行计算，和action 算子对应。 {#job-包含很多任务-task-的并行计算和action-算子对应 .list-paragraph}
Stage ：一个job 会被拆分成很多组任务，每组任务被称为Stage （就像MapReduce 分为MapTask 和ReduceTask 一样）。 {#stage-一个job-会被拆分成很多组任务每组任务被称为stage-就像mapreduce-分为maptask-和reducetask-一样 .list-paragraph}
{#section-3 .list-paragraph}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t5Zm1ung-1659491320283)(media/image4.png)]
{#section-4 .list-paragraph}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nt5PPuVB-1659491320284)(media/image5.png)]
Transformations 类算子叫做转换算子（本质就是函数）， Transformations 算子是延迟执行，也叫懒加载执行 {#transformations-类算子叫做转换算子本质就是函数-transformations-算子是延迟执行也叫懒加载执行 .list-paragraph}
行动算子
Action 类算子叫做行动算子， Action 类算子是触发执行。 {#action-类算子叫做行动算子-action-类算子是触发执行 .list-paragraph}
一个application 应用程序中有几个Action 类算子执行，就有几个job 运行。 {#一个application-应用程序中有几个action-类算子执行就有几个job-运行 .list-paragraph}
控制算子
将RDD 持久化，持久化的单位是partition 。 {#将rdd-持久化持久化的单位是partition .list-paragraph}
控制算子有三种， cache , persist , checkpoint 。都是懒执行的。必须有一个action 类算子触发执行。 {#控制算子有三种-cache-persist-checkpoint-都是懒执行的必须有一个action-类算子触发执行 .list-paragraph}
checkpoint 算子不仅能将RDD 持久化到磁盘，还能切断RDD 之间的依赖关系。 {#checkpoint-算子不仅能将rdd-持久化到磁盘还能切断rdd-之间的依赖关系 .list-paragraph}
cache {#cache .list-paragraph}
默认将RDD 的数据缓存到内存中。cache 是懒执行。 {#默认将rdd-的数据缓存到内存中cache-是懒执行 .list-paragraph}
cache() = persist() = persist(StorageLevel.Memory_Only) {#cache-persist-persiststoragelevel.memory_only .list-paragraph}
rdd.cache().count() 返回的不是持久化的RDD，而是一个数值 {#rdd.cache.count-返回的不是持久化的rdd而是一个数值 .list-paragraph}
persist {#persist .list-paragraph}
可以指定持久化的级别。最常用的是MEMORY_ONLY 和MEMORY_AND_DISK {#可以指定持久化的级别最常用的是memory_only-和memory_and_disk .list-paragraph}
{#section-6 .list-paragraph}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S5HoLUj4-1659491320285)(media/image7.png)]
checkpoint {#checkpoint .list-paragraph}
checkpoint 将RDD 持久化到磁盘，还可以切断RDD 之间的依赖关系，也是懒执行 {#checkpoint-将rdd-持久化到磁盘还可以切断rdd-之间的依赖关系也是懒执行 .list-paragraph}
执行原理： {#执行原理 .list-paragraph}
当RDD 的job 执行完毕后，会从finalRDD 从后往前回溯。 {#当rdd-的job-执行完毕后会从finalrdd-从后往前回溯 .list-paragraph}
当回溯到某一个RDD 调用了checkpoint 方法，会对当前的RDD 做一个标记。 {#当回溯到某一个rdd-调用了checkpoint-方法会对当前的rdd-做一个标记 .list-paragraph}
Spark 框架会自动启动一个新的job ，重新计算这个RDD 的数据，将数据持久化到Checkpint目录中。 {#spark-框架会自动启动一个新的job-重新计算这个rdd-的数据将数据持久化到checkpint目录中 .list-paragraph}
使用checkpoint 时常用优化手段： {#使用checkpoint-时常用优化手段 .list-paragraph}
对RDD 执行checkpoint 之前，最好对这个RDD 先执行cache {#对rdd-执行checkpoint-之前最好对这个rdd-先执行cache .list-paragraph}
这样新启动的job 只需要将内存中的数据拷贝到Checkpint目录中就可以，省去了重新计算这一步。 {#这样新启动的job-只需要将内存中的数据拷贝到checkpint目录中就可以省去了重新计算这一步 .list-paragraph}
{#section-7 .list-paragraph}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OoK6H2tL-1659491320286)(media/image8.png)]
spark-submit --master spark://node01:7077 --deploy-mode client --class org.apache.spark.examples.SparkPi $SPARK_HOME/examples/jars/sparkexamples_2.12-2.4.6.jar 10 {#spark-submit—master-sparknode017077—deploy-mode-client—class-org.apache.spark.examples.sparkpi-spark_homeexamplesjarssparkexamples_2.12-2.4.6.jar-10 .list-paragraph}
执行流程 {#执行流程 .list-paragraph}
{#section-8 .list-paragraph}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BJwi3r0t-1659491320286)(media/image9.png)]
client 模式提交任务后，会在客户端启动Driver 进程。 {#client-模式提交任务后会在客户端启动driver-进程 .list-paragraph}
Driver 会向Master 申请启动Application 启动的资源。资源申请成功， {#driver-会向master-申请启动application-启动的资源资源申请成功 .list-paragraph}
Driver 端将task 分发到worker 端执行，启动executor 进程（任务的分发）。 {#driver-端将task-分发到worker-端执行启动executor-进程任务的分发 .list-paragraph}
Worker 端（ exectuor 进程）将task 执行结果返回到Driver 端（任务结果的回收） {#worker-端-exectuor-进程将task-执行结果返回到driver-端任务结果的回收 .list-paragraph}
总结 {#总结 .list-paragraph}
client 模式适用于测试调试程序。Driver 进程是在客户端启动的，这里的客户端就是指提 交应用程序的当前节点。在Driver 端可以看到task 执行的情况。 生产环境下不能使用client 模式，是因为：假设要提交100个application 到集群运行， Driver 每次都会在client 端启动，那么就会导致客户端100次网卡流量暴增的问题 {#client-模式适用于测试调试程序driver-进程是在客户端启动的这里的客户端就是指提-交应用程序的当前节点在driver-端可以看到task-执行的情况-生产环境下不能使用client-模式是因为假设要提交100个application-到集群运行-driver-每次都会在client-端启动那么就会导致客户端100次网卡流量暴增的问题 .list-paragraph}
Standalone-cluster
spark-submit --master spark://node01:7077 --deploy-mode cluster --class org.apache.spark.examples.SparkPi $SPARK_HOME/examples/jars/sparkexamples_2.12-2.4.6.jar 10 {#spark-submit—master-sparknode017077—deploy-mode-cluster—class-org.apache.spark.examples.sparkpi-spark_homeexamplesjarssparkexamples_2.12-2.4.6.jar-10 .list-paragraph}
执行流程 {#执行流程-1 .list-paragraph}
{#section-9 .list-paragraph}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ea435tN8-1659491320287)(media/image10.png)]
cluster 模式提交应用程序后，会向Master 请求启动Driver 。 {#cluster-模式提交应用程序后会向master-请求启动driver .list-paragraph}
Master 接受请求，随机在集群一台节点启动Driver 进程。 {#master-接受请求随机在集群一台节点启动driver-进程 .list-paragraph}
Driver 启动后为当前的应用程序申请资源。 {#driver-启动后为当前的应用程序申请资源 .list-paragraph}
Driver 端发送task 到worker 节点上执行（任务的分发）。 {#driver-端发送task-到worker-节点上执行任务的分发 .list-paragraph}
worker 上的executor 进程将执行情况和执行结果返回给Driver 端（任务结果的回收） {#worker-上的executor-进程将执行情况和执行结果返回给driver-端任务结果的回收 .list-paragraph}
总结 {#总结-1 .list-paragraph}
Standalone-cluster 提交方式，应用程序使用的所有jar 包和文件，必须保证所有的 {#standalone-cluster-提交方式应用程序使用的所有jar-包和文件必须保证所有的 .list-paragraph}
worker 节点都要有，因为此种方式， spark 不会自动上传包。 {#worker-节点都要有因为此种方式-spark-不会自动上传包 .list-paragraph}
将所有的依赖包和文件打到同一个包中，然后放在hdfs 上。 {#将所有的依赖包和文件打到同一个包中然后放在hdfs-上 .list-paragraph}
将所有的依赖包和文件各放一份在worker 节点上。 {#将所有的依赖包和文件各放一份在worker-节点上 .list-paragraph}
yarn-client
spark-submit --master yarn --class org.apache.spark.examples.SparkPi $SPARK_HOME/examples/jars/spark-examples_2.12-2.4.6.jar 10 spark-submit --master yarn–client --class org.apache.spark.examples.SparkPi $SPARK_HOME/examples/jars/sparkexamples_2.12-2.4.6.jar 10 spark-submit --master yarn --deploy-mode client --class org.apache.spark.examples.SparkPi $SPARK_HOME/examples/jars/sparkexamples_2.12-2.4.6.jar 10 {#spark-submit—master-yarn—class-org.apache.spark.examples.sparkpi-spark_homeexamplesjarsspark-examples_2.12-2.4.6.jar-10-spark-submit—master-yarnclient—class-org.apache.spark.examples.sparkpi-spark_homeexamplesjarssparkexamples_2.12-2.4.6.jar-10-spark-submit—master-yarn—deploy-mode-client—class-org.apache.spark.examples.sparkpi-spark_homeexamplesjarssparkexamples_2.12-2.4.6.jar-10 .list-paragraph}
执行流程 {#执行流程-2 .list-paragraph}
{#section-10 .list-paragraph}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3zGL2Evx-1659491320289)(media/image11.png)]
客户端提交一个Application ，在客户端启动一个Driver 进程。 {#客户端提交一个application-在客户端启动一个driver-进程 .list-paragraph}
应用程序启动后会向RS ( ResourceManager )（相当于standalone 模式下的master 进程）发送请求，启动AM ( ApplicationMaster )。 {#应用程序启动后会向rs-resourcemanager-相当于standalone-模式下的master-进程发送请求启动am-applicationmaster .list-paragraph}
RS 收到请求，随机选择一台NM ( NodeManager )启动AM 。这里的NM 相当于Standalone 中的Worker 进程。 {#rs-收到请求随机选择一台nm-nodemanager-启动am-这里的nm-相当于standalone-中的worker-进程 .list-paragraph}
AM 启动后，会向RS 请求一批container 资源，用于启动Executor 。 {#am-启动后会向rs-请求一批container-资源用于启动executor .list-paragraph}
RS 会找到一批NM （包含container ）返回给AM ,用于启动Executor 。 {#rs-会找到一批nm-包含container-返回给am-用于启动executor .list-paragraph}
AM 会向NM 发送命令启动Executor 。 {#am-会向nm-发送命令启动executor .list-paragraph}
Executor 启动后，会反向注册给Driver ， Driver 发送task 到Executor ,执行情况和结果返回给Driver 端。 {#executor-启动后会反向注册给driver-driver-发送task-到executor-执行情况和结果返回给driver-端 .list-paragraph}
总结 {#总结-2 .list-paragraph}
Yarn-client 模式同样是适用于测试，因为Driver 运行在本地， Driver 会与yarn 集群中 的Executor 进行大量的通信 {#yarn-client-模式同样是适用于测试因为driver-运行在本地-driver-会与yarn-集群中-的executor-进行大量的通信 .list-paragraph}
ApplicationMaster (executorLauncher)的在此模式中的作用： {#applicationmaster-executorlauncher的在此模式中的作用 .list-paragraph}
为当前的Application 申请资源 {#为当前的application-申请资源 .list-paragraph}
给NodeManager 发送消息启动Executor 。 {#给nodemanager-发送消息启动executor .list-paragraph}
注意： ApplicationMaster 在此种模式下没有作业调度的功能。 {#注意-applicationmaster-在此种模式下没有作业调度的功能 .list-paragraph}
yarn-cluster
spark-submit --master yarn --deploy-mode cluster --class org.apache.spark.examples.SparkPi $SPARK_HOME/examples/jars/sparkexamples_2.12-2.4.6.jar 10 spark-submit --master yarn-cluster --class org.apache.spark.examples.SparkPi $SPARK_HOME/examples/jars/sparkexamples_2.12-2.4.6.jar 10 {#spark-submit—master-yarn—deploy-mode-cluster—class-org.apache.spark.examples.sparkpi-spark_homeexamplesjarssparkexamples_2.12-2.4.6.jar-10-spark-submit—master-yarn-cluster—class-org.apache.spark.examples.sparkpi-spark_homeexamplesjarssparkexamples_2.12-2.4.6.jar-10 .list-paragraph}
执行流程 {#执行流程-3 .list-paragraph}
{#section-11 .list-paragraph}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-63SCzTX3-1659491320290)(media/image12.png)]
客户机提交Application 应用程序，发送请求到RS ( ResourceManager ),请求启动AM ( ApplicationMaster ) {#客户机提交application-应用程序发送请求到rs-resourcemanager-请求启动am-applicationmaster .list-paragraph}
RS 收到请求后随机在一台NM ( NodeManager )上启动AM （相当于Driver 端）。 {#rs-收到请求后随机在一台nm-nodemanager-上启动am-相当于driver-端 .list-paragraph}
AM 启动， AM 发送请求到RS ，请求一批container 用于启动Excutor {#am-启动-am-发送请求到rs-请求一批container-用于启动excutor .list-paragraph}
RS 返回一批NM 节点给AM 。 {#rs-返回一批nm-节点给am .list-paragraph}
AM 连接到NM ,发送请求到NM 启动Excutor 。 {#am-连接到nm-发送请求到nm-启动excutor .list-paragraph}
Excutor 反向注册到AM 所在的节点的Driver 。Driver 发送task 到Excutor 。 {#excutor-反向注册到am-所在的节点的driver-driver-发送task-到excutor .list-paragraph}
总结： {#总结-3 .list-paragraph}
Yarn-Cluster 主要用于生产环境中，因为Driver 运行在Yarn 集群中某一台nodeManager中，每次提交任务的Driver 所在的机器都是不再是提交任务的客户端机器，而是多个NM 节点中的一台，不会产生某一台机器网卡流量激增的现象，但同样也有缺点，任务提交后不能看到日志。只能通过yarn 查看日志 {#yarn-cluster-主要用于生产环境中因为driver-运行在yarn-集群中某一台nodemanager中每次提交任务的driver-所在的机器都是不再是提交任务的客户端机器而是多个nm-节点中的一台不会产生某一台机器网卡流量激增的现象但同样也有缺点任务提交后不能看到日志只能通过yarn-查看日志 .list-paragraph}
ApplicationMaster 在此模式中的的作 {#applicationmaster-在此模式中的的作 .list-paragraph}
为当前的Application 申请资源 {#为当前的application-申请资源-1 .list-paragraph}
给NodeManger 发送消息启动Executor 。 {#给nodemanger-发送消息启动executor .list-paragraph}
任务调度。 {#任务调度 .list-paragraph}
执行流程
为driver-运行在yarn-集群中某一台nodemanager中每次提交任务的driver-所在的机器都是不再是提交任务的客户端机器而是多个nm-节点中的一台不会产生某一台机器网卡流量激增的现象但同样也有缺点任务提交后不能看到日志只能通过yarn-查看日志 .list-paragraph}
扫一扫
2376
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
