spark教程(12)-生态与原理

spark 是目前非常流行的大数据计算框架。

spark 生态

Spark core：包含 spark 的基本功能，定义了 RDD 的 API，其他 spark 库都基于 RDD 和 spark core

SparkSQL：像 sql 一样操作数据

SparkStreaming：实时数据处理，像操作普通 RDD 一样处理流数据

Mlib：机器学习库，算法被实现为对 RDD 的操作

GraphX：控制图、并行图操作和计算的一组算法和工具的集合

spark 特点

快速：基于内存计算，官方数据表明，如果从磁盘读取文件，计算速度在 mr 10 倍以上，如果从内存直接读，计算速度在 mr 百倍以上

通用：spark 拥有强大的扩展，跟同类框架 strom 相比，正是由于 storm 扩展很少，逐渐被淘汰；

spark 拥有 SQL、Streaming、mlib、ml、Graphx 等组件，可用于各种场景；

　　// mlib 和 ml 都是机器学习领域的组件，区别在于 mlib 是基于 RDD 的，ml 基于 DataFrame，ml 更高效更方便，它会逐渐替代 mlib；

容错：RDD 弹性分布式数据集；

易用：API 齐全；

应用场景

当我们的计算超过了单机尺寸，也就是单机内存不够时，可选用 spark；

或者当我们计算非常复杂，需要大量时间，也可选用 spark；

批处理：复杂计算的批处理，重点在于海量，可忍受的计算速度为 几分钟到几小时

交互查询：海量历史数据的交互查询，计算速度为 几秒到几十分钟

实时数据：实时数据流的数据处理，计算速度为 几百毫秒到几秒

spark 架构

spark 有 3 种部署模式，单机模式，集群模式（Standalone），yarn 模式（spark on yarn）；

每个模式都是基于 master-slave 主从架构；

基本架构 - 粗略认识

Cluster Manager：主从架构中的 master；在 standalone 中叫 master 主节点，在 yarn 模式中叫 资源管理器，即 Resource Manager，yarn 的主节点；

Worker：主从架构中的 slave，从节点，负责控制计算节点，启动 Driver 和 Executor；

Driver：它是 application 中的 main 函数，可以理解为 给客户端发起的 request 临时启动的一个 进程，负责管理这个 request，或者说 task；

Executor：执行器，为 application 启动的一个进程；每个节点可以有多个 不同 application 的 Executor；负责运行 task；

基本运行流程 - 深入认识

1. 其实最左边还有个 Client，也就是用户发起请求，我们称之为 task；

2. 请求提交到集群，首先创建 Driver，一个进程，负责管理整个 task，这个进程里创建了 sparkContext 对象；

3. sparkContext 向资源管理器（standalone 主节点，yarn RM，mesos）申请资源；

4. 资源管理器向 所有从节点 询问各自使用情况，从节点汇报完毕后，资源管理器统计可用资源，同时要求被统计的资源启动 StandaloneExecutorBackend；

5. 资源管理器给 sparkContext 发送可用资源；

6. Executor 向 sparkContext 申请 task， sparkContext 给可用节点发送 task；

　　// SparkContext 构建成 DAG 图，将 DAG 图分解成Stage、将 Taskset 发送给Task Scheduler，最后由Task Scheduler 将 Task 发送给 Executor 运行；

　　// 简单理解下，就是把 task 进行分解，同时创建一个 任务调度器，把 分解后的 task 发给 Executor；

7. 从节点启动的 Executor 负责执行 task；

8. 计算完毕后释放所有资源；

概念完善

Application：用户编写的 spark 应用程序，包含 Driver 代码和  Executor 代码

Driver：运行 application 中 main 函数，并创建 sparkContext

1. Driver 里有个 任务调度器；

2. 调度的原则有一点是 把 task 分配给 存储计算所需数据的节点，这样可以避免数据传输；这叫 数据本地化和推测执行，是一种优化机制；

3. Driver 可以运行在 Client 上，此时 Client 上必须装有 spark；

4. Driver 可以理解为我们常说的 sc 或者 spark；

5. Driver 将 task 和 task 所依赖的 file 和 jars 序列化后传递给 Worker；

6. Driver 和 资源管理器通信，申请资源；

7. Driver 和 Executor 互相通信，协作运行；

Worker

1. 创建 Executor 的节点，也就是执行 task 的节点；

2. 也就是说 Worker 与 Client 会有大量的通信和数据传输，所以 Client 最好离 Worker “近” 一点；

Executor

1. 相当于创建了一个 容器，container，或者说一个虚拟环境；

2. 每个 task 都会新建一个 Executor，也就是说一个节点上可以有很多个 Executor，且彼此隔离；

3. 计算完毕后，Executor 会自动释放；

4. Executor 只与 任务调度器 通信，即 sparkContext，即 Driver，而这个 Driver 与 spark 无关，这也可以解释 为什么在 yarn 模式下，无需启动 spark 也能运行

5. 每个 Executor 中会有多个线程运行；

task 相关

Task: 被送到某个Executor上的工作单元，但hadoopMR中的MapTask和ReduceTask概念一样，是运行Application的基本单位，多个Task组成一个Stage，而Task的调度和管理等是由TaskScheduler负责
Job: 包含多个Task组成的并行计算，往往由Spark Action触发生成， 一个Application中往往会产生多个Job
Stage: 每个Job会被拆分成多组Task， 作为一个TaskSet， 其名称为Stage，Stage的划分和调度是有DAGScheduler来负责的，Stage有非最终的Stage（Shuffle Map Stage）和最终的Stage（Result Stage）两种，Stage的边界就是发生shuffle的地方
DAGScheduler: 根据Job构建基于Stage的DAG（Directed Acyclic Graph有向无环图)，并提交Stage给TASkScheduler。 其划分Stage的依据是RDD之间的依赖的关系找出开销最小的调度方法，
TASKSedulter: 将TaskSET提交给worker运行，每个Executor运行什么Task就是在此处分配的. TaskScheduler维护所有TaskSet，当Executor向Driver发生心跳时，TaskScheduler会根据资源剩余情况分配相应的Task。
　　　　另外TaskScheduler还维护着所有Task的运行标签，重试失败的Task。

连起来就是这张图

完整架构图

网上没找到太好的图，将就着理解下吧

总结

1. 以上内容大多数是针对 Standalone 模式的，当然其他模式也类似，只是在某些环节略有差别；

2. 值得注意的是，在 Standalone 模式中，Driver 既可以运行在 master 节点上，也可以运行在 Client 客户端，

　　// 需要指定 master，否则是本地模式；

　　// 如果是在 master 节点上运行 spark-shell 或者 pyspark 等，Driver 运行在 master 节点上；

　　// 如果是 spark-submit 提交任务，或者在 Worker 上运行 spark-shell 或者 pyspark 等，Driver 运行在 Client 上；

　　// 也就是说 Worker 上也可以发起 spark 任务，只是有权限问题，比如计算结果无法保存到 master 上，没有权限；

spark on yarn

其实 yarn 模式大体流程等同于 Standalone 模式，只是有些特殊地方，而且在实际工作中，大多数用的是 yarn 模式，比较重要，所以单独算一节

两种模式的区别

在 yarn 模式中，根据 Driver 在集群中的位置分为两种模式：Yarn-Client 和 Yarn-Cluster（也就是 Yarn-Standalone 模式）；

介绍这两种模式之前，先解释一个概念 application master，在 yarn 中，每个 application 实例都有一个 Application Master 实例，它是 application 启动的第一个容器，

1. 因为 yarn 是负责资源管理的，它本身无法响应 spark 应用，当 application 过来时，它需要找个地方，启动 spark 应用，也就是在某个节点，传递 spark application；这就是 application master；

2. 它负责与 ResouceManager 通信，在获取资源之后，告诉 NodeManager 创建 Container；

3. Container 相当于在 Worker 中创建了虚拟机；

4. 相当于 Standalone 模式中的 master；

Yarn-Cluster 模式下，Driver 运行在 AM（application master）中，Client 端只是单纯发起来 spark 应用，yarn 把这个 spark 应用 交由 application master 代为发起，当用户提交了 task 之后，就可以关掉 Client，task 会继续运行，所以这种模式不适合交互类型的作业；

Yarn-Client 模式下，Driver 运行在 Client，AM 仅仅向 yarn 申请 Executor，或者说申请 Container，然后 Client 和 Container 通信，协作完成任务，也就是说 Client 不能关闭

Yarn-Cluster 流程图

1. 在 yarn 的 Client 端向 ResourceManager 提交申请，ResourceManager 会在 某个 NodeManager 创建一个 Container，在这个 Container 中 启动 application master；

2. 在 application master 中 完成 Driver 的一系列工作，包括 创建 sparkContext，分解任务，创立任务调度器，等；　　【vs Yarn-Cliet 区别】

3. 然后由 Driver 完成后续工作，与 Standalone 模式相同；

Yarn-Client 流程图

1. 在 yarn 的 Client 端向 ResourceManager 提交申请，并且在 Client 端完成 Driver 的一系列工作，包括 创建 sparkContext，分解任务，创立任务调度器，等；　　　　【vs Yarn-Cluster 区别】

2. ResourceManager 会在 某个 NodeManager 创建一个 Container，在这个 Container 中 启动 application master；

3. application master 向其他节点申请 Executor；

4. 由 Client 中的 Driver 完成 与 Executor 的通信；

5. 其他与 Standalone 模式相同；

Python 不支持 Yarn-Cluster 模式，只支持 Yarn-Client 模式；

经我测试，在 Yarn-Cluster 模式下，python 可以完成工作，但最后会报错；

上句代码吧

spark-submit --master yarn --deploy-mode cluster --class org.apache.spark.examples.SparkPi /usr/lib/spark/examples/jars/spark-examples_2.11-2.4.4.jar

spark shuffle

这个概念还是挺重要的，篇幅比较大，所以准备单独写一篇博客

参考资料：

https://www.cnblogs.com/liuliliuli2017/p/6809094.html

https://blog.csdn.net/swing2008/article/details/60869183

https://www.cnblogs.com/tgzhu/p/5818374.html