spark技术学习与思考（sparkcore&sparksql）

1.spark 基础

---

1.1 spark 发展历程

spark 是加州大学伯克利分校 AMP 实验室开发的基于内存的通用并行计算框架。

发展历程：

• 2009 年诞生于美国加州大学伯克利分校 AMP 实验室；
• 2010 年通过 BSD 许可协议开源发布；
• 2013 年 6 月进入 Apache 孵化器项目；
• 2014 年 2 月成为 Apache 的顶级项目（仅8个月时间）；
• 2014 年 5 月 spark1.0.0 发布；
• 2016 年 7 月 spark2.0.0 发布；
• 2020 年 6 月 spark3.0.0 发布；

既然已经有了 mapreduce，为什么还会流行 spark？

1.2 spark 与 mapreduce 对比

Spark 产生之前，已经有 MapReduce 这类非常成熟的并行计算框架存在了，并提供了高层次的 API(map/reduce)，它在集群上进行计算并提供容错能力，从而实现分布式计算。

所以为什么 spark 会流行呢？

• 原因 1：优秀的数据模型和丰富的算子

虽然 MapReduce 提供了对数据访问和计算的抽象，但是对于数据的复用就是简单的将中间数据写到一个稳定的文件系统中(例如 HDFS)，所以会产生数据的复制备份，磁盘的 I/O 以及数据的序列化，所以在遇到需要在多个计算之间复用中间结果的操作时效率就会非常的低。而这类操作是非常常见的，例如迭代式计算，交互式数据挖掘，图计算等。

所以在认识到这个问题后，AMPLab 提出了一个新的模型，叫做 RDD（弹性分布式数据集）。RDD 是一个可以容错且并行的数据结构(其实可以理解成分布式的集合，操作起来和操作本地集合一样简单)，它可以让用户显式的将中间结果数据集保存在内存中，并且通过控制数据集的分区来达到数据存放处理最优化。同时 RDD 也提供了丰富的算子 API (map、reduce、filter、foreach、redeceByKey…)来操作数据集。后来 RDD 被 AMPLab 放在一个叫做 Spark 的框架中并开源。

简而言之，Spark 借鉴了 MapReduce 思想发展而来，保留了其分布式并行计算的优点并改进了其明显的缺陷。让中间数据存储在内存中提高了运行速度、并提供丰富的操作数据的 API 提高了开发速度。

• 原因2：fullstack-完善的生态圈

spark 目前主要由五个组件构成， sparkcore 提供内存计算，sparksql 提供即时查询，spark streaming 提供实时计算，mlib提供机器学习，graphx提供图处理，spark 其他四个组件都会依赖于核心项目 sparkcore 中的组件模块。

• 原因3：运行模式多样化

由上图可知，spark 可以运行在多个资源管理调度平台上，其中包括 spark standalone、spark on yarn、mesos、k8s等，下面将对其中几个运行模式进行说明

1.3 spark 运行模式

• 本地模式

spark 本地模式是在一台计算机上的运行模式，一般用于学习与测试，例如在idea中：

var conf=new SparkConf().setMaster("local[*]").setAppName("test1")
var sc:SparkContext=...
sc.操作
sc.stop()

其中设置本地模式有三种方式：

setMaster(“local”) 表示用单线程来运行

setMaster(“local[number]”) 表示用 number 个线程并行

setMaster(“local[*]”) 表示该计算机的 cpu 核数个线程并行

• spark on yarn

spark on yarn 模式是在 yarn 集群中运行，适用于生产环境，其中包含 cluster 与 client 两种模式

i. spark on yarn 的 cluster 模式，指的是 driver 程序运行在 yarn 集群上，当用户提交了作业后，可以关闭 client，作业会继续在 yarn 上运行。

ii. spark on yarn 的 client 模式，指的是 driver 程序运行在提交任务的客户端上，当用户提交了作业后会在 client 上生成 sparksubmit 进程，client 不能中途离开。

两种模式的本质区别是：driver 程序运行的位置

• k8s

k8s是 spark 上全新的集群管理和调度系统，spark2.3 后 spark 可以部署在 k8s 上

常用有两种方法可以将 spark 应用提交到 k8s 上:

i. 通过 spark 原生的 spark-submit 提交

ii. 通过谷歌提供的 spark-on-k8s operator 提交

两种模式区别是：spark-on-k8s operator 可以通过一系列的内置工具获取很多作业相关的信息，而spark-submit 则无法查看作业的运行信息。

• why spark on k8s？

spark on yarn 与 spark on k8s 都可以用于实际生产，但为什么很多大公司更倾向于 k8s 呢？

yarn 是资源管理工具，用于管理 cpu 与 memory 的资源隔离；

k8s 是容器编排工具，显然资源管理是其功能之一；

如果按照“编排”的概念方向去理解 yarn，那么 yarn 就是一个 JVM 负载的编排工具，而 k8s 是容器负载的编排工具。这么一比较，k8s 显然胜出一筹，因为容器在应用的支持方面更广泛，更不要说 k8s 能够实现比 yarn 好得多的多的隔离了。

简而言之，用了 k8s 之后，不仅仅可以在这个集群运行 spark 负载，显然也可以运行其他所有的基于容器的负载，那么只需要把应用都进行容器化即可。比如 BI 工具、报表工具、查询工具等都可以在一个 k8s 集群上运行，而 spark 只是作为其中的应用之一。

so why not k8s？

1.4 spark 常用命令

• spark-shell

spark 提供的终端命令，允许在终端中使用 scala、java、python 等语言编写 spark 程序。

• spark-sql

spark 提供的终端命令，允许在终端使用 sql 语言操作数据。

• spark-submit

spark 提供的终端作业提交命令，允许将打包好的程序提交到集群中运行。

常用语法：

1.spark-submit [options] <app jar | python file | R file> [app arguments]

2.spark-submit --kill [submission ID] --master [spark://...]

3.spark-submit --status [submission ID] --master [spark://...]

可选配置：

--master 运行模式，默认为 local[*]

--class 主方法所在类名

--name 应用名称

--deploy-mode  指定 sparkonyarn 的客户端/集群模式，默认为 client，可以设置为 cluster

--executor-memory 执行器内存大小，默认为1g

--num-executors 执行器个数，默认为2

--executor-cores 每个执行器的 cpu 个数，默认为1

--driver-cores 驱动器的 cpu 个数，默认为1，只支持在 cluster 模式下修改

--jars 额外依赖的第三方 jar 包

--files 需要分发到各节点的数据文件

--total-executor-cores 执行器的 cpu 个数，默认为集群中全部可用的 cpu 个数

1.5 spark 底层执行原理

• 常用名词说明

RDD：一组分布式的存储在节点内存中的只读性数据集，spark 的基本计算单元

DAG：有向无环图，反应了 RDD 之间的依赖关系

STAGE：一个 stage 包含一组相同的 task，也叫做taskset，stage 包含的 task 个数取决于分区个数，一个分区对应一个 task

DAG Scheduler：有向无环图调度器，负责将 DAG 根据宽依赖划分 stage，并将 stage 交给 taskscheduler

taskscheduler：任务调度器，负责将 task 分发给 executor 执行

• spark 作业运行流程

1.用户在客户端 spark-submit 提交 spark 程序给 clustermanager；

2.clustermanager 接收到程序之后会找一个 worker 启动 driver ，driver 开始运行 spark 程序的主函数；

3.然后 driver 创建 sparkcontext，将其作为资源调度的总入口，还会初始化 DAGscheduler 与 taskScheduler 以及 sparkenv；

4.driver 开始执行 spark 程序中的各种算子，根据 action 算子划分 job，一个 job 产生一个 DAG,一个 DAG 交给一个 DAGscheduler，根据宽依赖划分 stage（stage 就是 task 集合），然后一个 stage 交给一个 taskscheduler，它会将每个 task 交给 worker 上的 executor 去执行，并且执行器会开启线程去执行这些 task；

5.sparkenv 会启动一些控制组件，进行 shuffle 管理或者广播变量等的管理；

6.当所有 task 完成后，driver 关闭 sc，spark 作业结束。

• stage 划分

Spark 的计算发生在 RDD 的 Action 操作，而对 Action 之前的所有 Transformation，Spark 只是记录下 RDD 生成的轨迹，而不会触发真正的计算。

划分依据：Stage 划分的依据就是宽依赖，像 reduceByKey，groupByKey 等产生shuffle的算子，会导致宽依赖的产生。

窄依赖：父 RDD 的一个分区只会被子 RDD 的一个分区所使用。即一对一的关系。常见的产生窄依赖的算子有：map、filter、union、mapPartitions等。
宽依赖：父 RDD 的一个分区会被子 RDD 的多个分区所使用(涉及到 shuffle)。即一对多的关系。常见的产生宽依赖的算子有 groupByKey、reduceByKey、join等。

核心算法：回溯算法

从后往前回溯，遇到窄依赖就加进当前 Stage，遇见宽依赖进行 Stage 切分。

Spark 内核会从触发 Action 操作的那个 RDD 开始从后往前推，首先会为最后一个 RDD 创建一个 Stage，然后继续倒推，如果发现它对某个 RDD 是宽依赖，那么就会将宽依赖的那个 RDD 创建一个新的 Stage，那个 RDD 就是新的 Stage 的最后一个 RDD。然后依次类推，继续倒推，根据宽依赖进行 Stage 的划分，直到所有的 RDD 全部遍历完成为止。

例如：

一个 Spark 程序可以有多个 DAG(有几个 Action，就有几个 job ，就有几个 DAG，上图最后只有一个 Action（图中未标出）,那么就是一个 DAG)。

一个 DAG 可以有多个 Stage(根据宽依赖/shuffle 进行划分)。

同一个 Stage 可以有多个 Task 并行执行(task 数=分区数，如上图，Stage1 中有三个分区 P1、P2、P3，对应的也有三个 Task)。

可以看到这个 DAG 中只有 reduceByKey 操作是一个宽依赖，Spark 内核会以此为边界将其前后划分成不同的 Stage。

同时我们可以注意到，在图中 Stage1 中，从 textFile 到 flatMap 到 map 都是窄依赖，这几步操作可以形成一个流水线操作，通过 flatMap 操作生成的 partition 可以不用等待整个 RDD 计算结束，而是继续进行 map 操作，这样大大提高了计算的效率。

2.sparkcore

---

2.1 SparkContext 介绍

Sparkcontext 是整个 spark 应用程序的上下文，控制应用的生命周期，它负责与 clustermanager 进行通信，并负责对资源的申请与任务分配，最重要的是它可以用来创建 RDD、累加器、广播变量，详情见源码

• sparkcore编程流程：

两种思路：

一种是在 idea 中编写 spark 代码，构建 Sparkcontext，然后 sc 进行各种操作（构建 RDD、调用一系列算子操作、关闭sc），打包上传到 spark client 上提交作业。

还一种是终端 spark-shell 中编写 spark 代码，不需要创建 sparkcontext，直接进行算子操作。

2.2 RDD 介绍

弹性分布式数据集是 spark 中最基本的数据抽象，主要属性包括：

1.数据分区

用来查看当前 rdd 的分区列表

2.计算函数

该函数由 spark 开发人员使用，用来编写 rdd 计算函数（如 map、flatMap 等算子）

3.依赖关系

展示分区间的依赖关系，可以用来构建血缘系统，当数据分区丢失后通过分区间的依赖关系进行恢复

4.分区方式