7 Spark开荒_架构原理

比眉伴天荒 2022-12-02 04:11 157阅读 0赞

### 文章目录 ###

*  开荒
 *   *  1.1 Spark定义
     *  1.2 Spark and Hadoop
     *   *   *  1.2.1 时间线
             *  1.2.2 功能区别
     *  1.3 Spark核心模块
     *  1.4 Spark的运行环境
     *   *   *  1.4.1 Local模式
             *  1.4.2 Standalong模式
             *  1.4.3 Yarn模式
             *  1.4.4 K8S & Mesos模式
             *  1.4.5 Win模式
     *  1.5 Spark端口号
     *  2 Spark运行架构
     *   *  2.1 Driver & Executor
         *  2.2 Master & Worker
         *  2.3 核心概念
         *   *   *  2.3.1 Excutor & Core
                 *  2.3.2 并行度(Parallelism)
                 *  2.3.3 有向无环图(DAG)
         *  2.4 提交流程
         *   *   *  2.4.1 Yarn Client
                 *  2.4.2 Yarn Cluster
 *  3 Spark核心编程
 *   *   *  3.1 RDD
         *  3.1 IO 流
         *   *   *  字符流
         *  3.2 RDD 的执行原理 & IO流对比
     *  3.3 RDD创建
 *  4 算子

# 开荒 #

## 1.1 Spark定义 ##

![在这里插入图片描述][20200829165230642.png_pic_center]

![在这里插入图片描述][20200829165222831.png_pic_center]  
Spark : 基于内存的快速、 通用、可扩展的大数据分析计算引擎。

## 1.2 Spark and Hadoop ##

准确的说，这里的Hadoop指的是MR

#### 1.2.1 时间线 ####

	2006年1月，Doug Cutting加入Yahoo，领导Hadoop的开发
    	2008年1月，Hadoop成为Apache顶级项目
    		2009年，Spark诞生于伯克利大学的AMPLab实验室
    		2010年，伯克利大学正式开源了Spark项目
    	2011年，Hadoop 1.0正式发布
    	2012年3月，Hadoop稳定版发布
    		2013年6月，Spark成为了Apache基金会下的项目
    	2013年10月发布 Hadoop2.X (Yarn)版本
    		2014年2月，Spark以飞快的速度成为了Apache的顶级项目
    		2015年至今，Spark变得愈发火爆，大量的国内公司开始重点部署或者使用Spark

#### 1.2.2 功能区别 ####

	Hadoop
    		Hadoop是由java语言编写的，在分布式服务器集群上存储海量数据并运行分布式分析应用的开源框架
    		作为Hadoop分布式文件系统，HDFS处于Hadoop生态圈的最下层，存储着所有的数据，支持着Hadoop的所有服务。它的理论基础源于Google的TheGoogleFileSystem这篇论文，它是GFS的开源实现。
    		MapReduce是一种编程模型，Hadoop根据Google的MapReduce论文将其实现，作为Hadoop的分布式计算模型，是Hadoop的核心。基于这个框架，分布式并行程序的编写变得异常简单。综合了HDFS的分布式存储和MapReduce的分布式计算，Hadoop在处理海量数据时，性能横向扩展变得非常容易。
    		HBase是对Google的Bigtable的开源实现，但又和Bigtable存在许多不同之处。HBase是一个基于HDFS的分布式数据库，擅长实时地随机读/写超大规模数据集。它也是Hadoop非常重要的组件。
    	Spark
    		Spark是一种由Scala语言开发的快速、通用、可扩展的大数据分析引擎
    		Spark Core中提供了Spark最基础与最核心的功能
    		Spark SQL是Spark用来操作结构化数据的组件。通过Spark SQL，用户可以使用SQL或者Apache Hive版本的SQL方言（HQL）来查询数据。
    		Spark Streaming是Spark平台上针对实时数据进行流式计算的组件，提供了丰富的处理数据流的API。

## 1.3 Spark核心模块 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center]

1.  Spark Core  
    SparkCore提供了最基础 最核心的功能  
    Spark其他功能 ：SQL、Streaming、GraphX、MLlib都是在 SparkCore的基础上进行扩展的
2.  Spark SQL  
    Spark SQL是Spark用来操作结构化数据的组件  
    通过Spark SQL 可以使用SQL or Hive SQL 来进行查询
3.  Spark Streaming  
    Spark针对实时数据进行流计算的组件，提供了丰富的处理数据流的API
4.  Saprk MLlib  
    MLlib是Spark提供的一个机器学习算法库。  
    不仅提供了模型评估、数据导入，  
    还提供了一些更底层的机器学习原语。
5.  Spark GraphX  
    GraphX 是 Spark面向图计算的框架与算法库。

## 1.4 Spark的运行环境 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_1_color_FFFFFF_t_70_pic_center]

#### 1.4.1 Local模式 ####

Local模式，就是不需要其他任何节点资源就可以在本地执行Spark代码的环境

修改spark-local/conf/spark-env.sh文件，增加如下内容
    SPARK_DIST_CLASSPATH=$(/opt/module/hadoop3/bin/hadoop classpath)

#### 1.4.2 Standalong模式 ####

local本地模式毕竟只是用来进行练习演示的，真实工作中还是要将应用提交到对应的集群中去执行，这里我们来看看只使用Spark自身节点运行的集群模式，也就是我们所谓的独立部署（Standalone）模式。Spark的Standalone模式体现了经典的master-slave模式。  
集群规划:

Linux1	Linux2	Linux3
    Spark	Worker    Master	Worker	Worker

#### 1.4.3 Yarn模式 ####

Standalone 模式由Spark 自身提供计算资源，无需其他框架提供资源 降低了耦合度  
但是 Spark 主要是计算框架，不擅长 资源调度  
所以 资源调度 交给Yran 更靠谱

修改conf/spark-env.sh，添加JAVA_HOME和YARN_CONF_DIR配置
    mv spark-env.sh.template spark-env.sh
    ...
    export JAVA_HOME=/opt/module/jdk1.8.0_144
    YARN_CONF_DIR=/opt/module/hadoop/etc/hadoop

#### 1.4.4 K8S & Mesos模式 ####

Mesos : Apache 下的开源分布式管理框架 ， Twitter 使用 Mesos 管理 30k 台服务器 ， 国内很少使用 。

容器化管理方便管理与运维 ， Spark 2.3 or above 支持K8S的快速部署  
[https://spark.apache.org/docs/latest/running-on-kubernetes.html][https_spark.apache.org_docs_latest_running-on-kubernetes.html]

#### 1.4.5 Win模式 ####

不用虚拟机Linux 直接在Win 下也可以启动本地模式 ， 仅限学习

## 1.5 Spark端口号 ##

**4040 计算**

查看当前Spark-shell运行任务情况

**7077**

SparkMaster内部通信的服务端口号

**8080 资源**

Standalone 模式下，Spark Master Web端口号

**18080**

Spark 历史服务器端口

**8088**

Hadoop Yarn 任务运行情况查看的端口号

## 2 Spark运行架构 ##

核心 是一个计算引擎 ，Master-Slave 的结构

![在这里插入图片描述][20200829194322802.png_pic_center]

### 2.1 Driver & Executor ###

1.  Driver ：master 管理整个集群的作业调度
    
    用于执行Spark任务中的main方法，负责实际代码的执行工作
    
    Driver在Spark作业执行时负责：

1 讲用户程序转换为作业
    2 在Executor之间调度任务(task)
    3 跟踪Executor的执行情况
    4 通过UI展示查询运行情况

实际上，无法准确描述Driver的定义，整个编程没有Drive  
简单理解，驱动整个应用运行起来的程序，也称为Driver类

1.  Executor ： Slave 执行任务
    
    Spark Executor 是集群中Worker中的一个 JVM 进程 ， 负责Spark作业中运行具体Task，Task之间相互独立。
    
    Executor核心功能

1 负责组成Spark应用的任务，并将结果返回给驱动器进程
    2 通过自身块管理(Block Manager)为用户程序中RDD提供内存式存储。 RDD直接在Excutor进程内，内存中 速度快

### 2.2 Master & Worker ###

Spark集群的独立部署环境中，不需要依赖其他的资源调度框架，  
所以需要有Master & Worker

1.  Master ：类似于YARN中的RM  
    负责资源调度 & 分配
2.  Worker : 类似于YARN中的NM  
    进程，一个Worker运行在集群中的一台服务器中，  
    获取Master分配的资源

### 2.3 核心概念 ###

##### 2.3.1 Excutor & Core #####

Executor 是集群中 Worker的一个JVM进程，

提交任务时，可以指定资源的量

--num-executors		配置Executor的数量
    --executor-memory	配置每个Executor的内存大小
    --executor-cores	配置每个Executor的虚拟CPU core数量

##### 2.3.2 并行度(Parallelism) #####

多个任务分布在多节点，真正实现多任务并行执行

并行(多个任务同时执行) > 并发 (并发协调多个任务顺序执行)

并行度 ： 就是同时执行的数量(可修改)

##### 2.3.3 有向无环图(DAG) #####

![在这里插入图片描述][20200830020154952.png_pic_center]

迭代计算，催生了 支持DAG产生。

Job内的DAG支持，实现流计算

DAG（Directed Acyclic Graph）有向无环图是由点和线组成的拓扑图形，该图形具有方向，不会闭环。

### 2.4 提交流程 ###

Spark on yarn

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_1_color_FFFFFF_t_70_pic_center 1]  
Spark应用程序提交到Yarn环境中执行的时候，一般会有两种部署执行的方式：Client和Cluster。两种模式，主要区别在于：Driver程序的运行节点。

##### 2.4.1 Yarn Client #####

Client模式将用于监控和调度的Driver模块在客户端执行，而不是Yarn中，所以一般用于测试。

	Driver在任务提交的本地机器上运行
    	Driver启动后会和ResourceManager通讯申请启动ApplicationMaster
    	ResourceManager分配container，在合适的NodeManager上启动ApplicationMaster，负责向ResourceManager申请Executor内存
    	ResourceManager接到ApplicationMaster的资源申请后会分配container，然后ApplicationMaster在资源分配指定的NodeManager上启动Executor进程
    	Executor进程启动后会向Driver反向注册，Executor全部注册完成后Driver开始执行main函数
    	之后执行到Action算子时，触发一个Job，并根据宽依赖开始划分stage，每个stage生成对应的TaskSet，之后将task分发到各个Executor上执行。

##### 2.4.2 Yarn Cluster #####

Cluster模式将用于监控和调度的Driver模块启动在Yarn集群资源中执行。一般应用于实际生产环境。

1 任务提交后和ResourceManager通讯申请AM
    2 RM分配Container ， 在NM 上启动AM ， 此时的AM就是Driver
    3 Driver 向RM申请Executor内存 ， RM 接到Dirver申请后，分配内存给Container ， 启动Executor进程
    4 Executor向Driver反向注册， Executor全部注册完成后Driver开始执行main函数
    5 执行到Action算子时，触发一个Job ， 根据宽依赖划分stage， 每个stage生成对应的TaskSet ，task 被分发到Executor上执行

# 3 Spark核心编程 #

Spark计算框架为了能够进行 高并发 & 高吞吐 的数据处理，封装了三大数据结构，用于处理不同的应用场景

*  RDD ： 弹性分布式数据集
 *  累加器 ：分布式只写变量
 *  广播变量 ： 分布式共享只读变量

### 3.1 RDD ###

Resilient Distributed Dataset  
弹性 、 不可变 、 可分区 、 里面的元素并行计算

*  弹性
    
     *  存储弹性，内存于磁盘自动切换
     *  容错弹性，丢失数据自动回复
     *  计算弹性，计算出错重试机制
     *  分片弹性，根据需要重新分片
 *  分布式 ：数据存在不同节点
 *  数据集 ： RDD封装了计算逻辑，并不保存数据
 *  数据抽象 ： RDD是一个抽象类 ， 需要子类实现
 *  不可变 ： RDD封装的计算逻辑，是不能改变的，想改变只能再产生新的RDD
 *  可分区、 并行计算

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 1]

**核心属性**  
![在这里插入图片描述][20200830022920772.png_pic_center]

**分区列表**  
![在这里插入图片描述][20200830022947842.png_pic_center]  
**执行原理**

1.  启动Yarn集群环境  
    ![在这里插入图片描述][20200830023145533.png_pic_center]
2.  Spark通过申请资源创建调度节点和计算节点

![在这里插入图片描述][20200830023232319.png_pic_center]

1.  根据需求将计算逻辑根据分区换分成不同的任务  
    ![在这里插入图片描述][20200830023359967.png_pic_center]
2.  调度节点将任务根据计算节点状态发送到对应计算节点  
    ![在这里插入图片描述][20200830023456734.png_pic_center]

### 3.1 IO 流 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 2]  
数据是一个一个处理

**装饰流模式**  
装饰：在原有的功能上扩展

类似于批处理

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 3]

##### 字符流 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 4]

### 3.2 RDD 的执行原理 & IO流对比 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 5]

也是 采用装饰者模式

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 6]

## 3.3 RDD创建 ##

**分区计算原理**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 8]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 9]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 10]

读取数据只读取一次

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 11]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 12]

# 4 算子 #

所谓的RDD的转换算子，其实就是旧的RDD通过方法调用产生新的RDD

[20200829165230642.png_pic_center]: /images/20221123/4e69e983c899442099ebba01f4f90893.png
[20200829165222831.png_pic_center]: /images/20221123/1abf6928344248cdb20bc4a3d20fa0fe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/5abd33022d4e4d4d89105a9f72efd810.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_1_color_FFFFFF_t_70_pic_center]: /images/20221123/7a21f390aed8436aa8fd7b108aca22b4.png
[https_spark.apache.org_docs_latest_running-on-kubernetes.html]: https://spark.apache.org/docs/latest/running-on-kubernetes.html
[20200829194322802.png_pic_center]: /images/20221123/1141d30a5cd9467389bb6ad7440ed8c4.png
[20200830020154952.png_pic_center]: /images/20221123/8362a7ecafc840d0acffeaa1b7ad1659.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_1_color_FFFFFF_t_70_pic_center 1]: /images/20221123/7ab44df1f2b545ef8b545dc4d12da365.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/79bb3295eff04eafba63ba8724a84514.png
[20200830022920772.png_pic_center]: /images/20221123/ab9d4f365a11484d92b341ebe39456b1.png
[20200830022947842.png_pic_center]: /images/20221123/12f9bb969447430f9e032012af0b511a.png
[20200830023145533.png_pic_center]: /images/20221123/b4e8165a2aba492298287d069cb4f781.png
[20200830023232319.png_pic_center]: /images/20221123/b930fbe0751b4fa48e54f5f2d0018c73.png
[20200830023359967.png_pic_center]: /images/20221123/b3286241f5dd4c758811d0bd27f1c477.png
[20200830023456734.png_pic_center]: /images/20221123/bfe7022e0a614c739919e90ce4626310.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/a07294f904524211abe2f28be873eb40.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/ddd6f2ba6fc74ddebc0e854235cedb92.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/b939fc6ea18d4bdfb41ea46c87fde534.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/a981eccee60a4ecbb10507623ddc0f10.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/ce6399b428f84e1bb13bb9485a5d3742.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221123/3aad7cc8e4364049800dd519ef739707.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221123/b34d171c99aa461cae32552588d73fc9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221123/6a503a5fa1b14235b14789a2851c5d01.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221123/7dff3656a8364935a6fcad2322638b23.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221123/d8cea65a68c847a68513c417bd43240e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20221123/a45c7c66ebab4106b002204257c37c5f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20221123/850f5c1a645d478485e7a7ad7ccaa541.png