Spark基础入门

zjh_coding

已于 2023-07-23 01:28:48 修改

阅读量113

点赞数

分类专栏：大数据文章标签： spark

于 2023-07-17 14:02:51 首次发布

本文链接：https://blog.csdn.net/zjh17393161150/article/details/131764747

版权

大数据专栏收录该内容

6 篇文章 0 订阅

订阅专栏

文章目录

Spark概述
Spark 环境搭建（Local模式）
- 服务器环境介绍
- Local 模式搭建
Spark 环境搭建（Standalone 模式）
Spark 环境搭建（Standalone HA模式）
Spark 环境搭建（Spark on YARN）
PySpark 库
本机开发环境搭建
分布式代码执行分析

Spark概述

Spark 是什么

用于 大规模数据 处理的 分布式 统一 分析引擎

Spark借鉴了MapReduce的思想，将中间数据存储在内存中以提高运行速度

RDD：弹性分布式数据集，是Spark的核心数据结构，一种分布式内存抽象，使得程序员能够在大规模集群中进行内存运算，并且有一定的容错方式

Spark可以对任意类型的数据进行自定义计算，包括结构化、半结构化、非结构化数据，同时也支持Python、Java、SQL等语言去开发应用程序计算数据。因其适用面广被称为统一的分析引擎

Spark VS Hadoop (MapReduce)

在这里插入图片描述
计算层面：Spark相比于MR有巨大的性能优势
但Spark仅做计算，而Hadoop生态圈集计算、存储、资源调度于一体，HDFS和YARN仍是许多大数据体系的核心架构，Spark仅仅可以替代MR而已。

Spark 四大特点

速度快
Spark的中间处理结果存储在内存中，而Map和Reduce基于外存进行交互
Spark提供了丰富的算子(即API)，复杂任务在一个Spark程序中就可以完成；而MapReduce只有Map和Reduce两个算子
易用性
Spark是一个典型的概念多但编程简单的框架
通用性
Spark在核心API的基础上还提供了多个工具库
运行方式多
Spark支持在资源调度框架上 (如YARN)、容器中运行，也支持Standalone的独立运行模式
Spark还支持多种数据源，如HDFS、MySQL、redis等等

Spark 运行模式

Local 模式（单机）
以一个独立进程 ，通过内部的多个线程模拟Spark的运行时环境
一般用于开发测试环境
Standalone 模式（集群）
Spark的各个角色以独立进程的形式存在，并组成Spark集群环境
Hadoop YARN 模式（集群）
Spark的各个角色运行在YARN容器内部，这些容器组成Spark集群环境
Kubernetes 模式（容器集群）
Spark的各个角色运行在Kubernetes容器内部，这些容器组成Spark集群环境
云服务模式（运行在云平台上）

Spark 架构角色

资源管理层面：
Master：集群的资源管理者
Worker：单机上的资源管理者

任务运行层面：
Driver：单个任务的管理者（特殊的，Local运行模式下Driver既管理又干活）
Executor：单个任务的计算
在这里插入图片描述

总结

Spark 解决什么问题？
海量数据计算，可以进行离线批处理和实时流计算

Spark 有哪些模块？
核心SparkCore、SQL计算 (SparkSQL)、流计算 (SparkStreaming)、图计算 (GraphX)、机器学习 (MLlib)

Spark 的特点？
速度快、使用简单、通用性强、多种模式运行

Spark 运行模式？
本地模式
集群模式（Standalone、YARN、K8S）
云模式

Spark 的运行角色？
资源管理层面：Master（集群）、Worker（单机）
任务管理层面：Driver（管理）、Executor（执行）

Spark 环境搭建（Local模式）

服务器环境介绍

Local 模式搭建

基本原理：本质是启动一个JVM Process进程（包含多个线程），执行任务Task
注意是一个进程，把Master、worker、Driver的事都干了
Local 模式可以限制模拟Spark集群环境的线程数量，即 local[N] 或 local[*]
N表示线程数，一般和CPU的核数一致；* 表示按照CPU最多的核数设置线程数

Local 下的角色分布：

资源管理：
Master：Local进程本身
Worker：Local进程本身
任务执行
Driver：Local进程本身
Executor：不存在独立的角色，由Local进程（即Driver）的线程提供计算能力

一个Local进程只能运行一个Spark程序，多个Spark程序由多个进程执行

开箱即用：配置好Python、Spark环境和相关环境变量后，直接运行 spark bin 目录下的 pyspark(Python语言)、spark-shell(Scala语言) ，通过客户端工具交互式地执行spark程序
或者使用spark-submit提交运行写好的spark程序
注意：运行之前要确保hdfs和yarn跑起来了

Spark 环境搭建（Standalone 模式）

Standalone 架构

Standalone模式是 spark 自带的一种集群模式，真实的在多个机器之间搭建 Spark 集群环境，用于实际的大数据处理

Master 角色以 Master进程存在，Worker 角色以 Worker进程存在
Driver 角色运行时存在于Master进程内，Executor运行于Worker进程内

进程分析：Standalone集群中主要有三类进程
主节点Master进程：管理集群资源，托管运行各个任务的Driver（多个任务会开启多个Driver）
从节点Worker进程：管理单机资源，分配对应资源来运行Executor（Task）
历史服务器HistoryServer进程：（可选）Spark程序运行完后，保存事件日志到HDFS

在这里插入图片描述

环境安装

集群规划：1个Master进程 + 3个Worker进程
node1：Master进程 + Worker进程
node2：Worker进程
node3：Worker进程

前置条件：每天机器上都安装好Python环境(Anaconda)

在node1上安装spark环境，并修改相应的配置文件，然后将spark环境分发到每台设备上

集群启动

启动历史服务器：$SPARK_HOME/sbin/start-history-server.sh
会启动一个叫HistoryServer的进程，可以通过jps命令查看

启动Spark集群：$SPARK_HOME/sbin/start-all.sh
在每台设备上启动Worker进程，在一台设备上启动Master进程

连接到 Standalone 集群

通过pyspark客户端工具连接到集群
执行 $SPARK_HOME/bin/pyspark --master spark://node1:7077
集群的链接地址（spark://node1:7077）可以在master的webUI（Master的8080端口）中看到，在最上面
在这里插入图片描述

简例：单词计数

统计hdfs中words文件中各单词的出现次数
在这里插入图片描述

程序执行可视化流程：

Spark 运行的层次结构

Spark 中各端口的区别

4040：
一个Application在运行过程中临时绑定的端口（Driver注册的），用于查看当前任务状态，若被占用则会顺延4041、4042等
程序运行完成后，4040会被注销
8080：
Standalone下，Master 角色（进程） 的 web 端口，用于查看当前 Master 进程(集群)的状态
18080：
默认是历史服务器的端口，可以在程序运行结束后回看历史程序的运行状态

Spark 程序层级：

应用程序 Application
- 若干子任务 Job
  - 若干子阶段 Stage
    - 若干线程 Task

总结

Standalone 的运行原理：
Master 和 Worker 以独立进程的形式存在，相互通讯并组成Spark集群
Spark 角色在 Standalone 中的分布：
Master 角色：Master 进程
Worker 角色：Worker 进程
Driver 角色：以线程运行在 Master 中
Executor 角色：以线程运行在 Worker 中
Standalone 如何提交 Spark 应用程序：
$SPARK_HOME/bin/spark-submit --master spark://node1:7077
其中 node1 为 master 进程所在的设备 IP
4040、8080、18080端口的区别：
4040 单个程序运行时绑定的端口
8080 Master(集群) 的Web端口
18080 历史服务器端口
Job、Stage、Task的关系：
Task∈Stage∈Job∈App∈Spark环境
一个Spark环境 (如 pyspark) 中可以包含多个程序(Application)，一个 App 被分成多个子任务 (Job)，每个 Job 分成多个阶段 (Stage) 运行，每个 Stage 中分出来多个线程 (Task) 来执行具体任务

Spark 环境搭建（Standalone HA模式）

挖坑，还没搭，只有原理

Standalone 是典型的主从架构集群，由于Master只有一个，容易出现单点故障（SPOF）问题，Master 宕机后整个集群就会变成没头苍蝇

为解决单点故障问题，Spark 提出两种方案

基于文件系统的单点恢复 --只能用于开发测试环境
基于 zookeeper 的 Standby Master --可用于生产环境
Zookeeper提供一个leader election机制，多个Master中只有一个是active，其余都是standby。active出现故障时，另一个standby会被选举出来

运行原理

集群搭建

基于 ZooKeeper 实现 HA 模式部署

运行测试

Spark 环境搭建（Spark on YARN）

想要一个稳定的生产 Spark 环境，最优的选择是构建 Standalone HA 集群
但是企业资源要充分利用，有 YARN 集群的同时再单独准备 Standalone 集群就有点浪费资源
因此，多数场景下会将 Spark 运行到 YARN 集群中

YARN 负责对运行在其内部的计算框架进行资源调度管理，运行在 YARN 中的 Spark 也是一样的

对于 SparkOnYARN，无需部署 Spark 集群，只要找一台服务器，充当 Spark的客户端，即可提交任务到YARN集群中去运行

SparkOnYARN 本质

Spark 专注于计算，资源管理托管给 YARN，将 Spark 计算任务运行到YARN 容器内部

Master 角色由 YARN 的 ResourceManager 担任
Worker 角色由 YARN 的 NodeManager 担任

Driver 角色运行在 YARN容器 或提交任务的客户端进程中
Executor 运行在YARN容器 内
在这里插入图片描述

需要啥？

YARN 集群
Spark 客户端工具，如 spark-submit，可以将 Spark 程序提交到 YARN 中
被提交的代码程序

配置 SparkOnYARN 环境

相较于之前的环境，不需要额外配置任何东西，只需要确保环境变量 HADOOP_CONF_DIR 和 YARN_CONF_DIR 在 spark-env.sh 和 环境变量配置文件中即可

启动SparkOnYARN
启动交互式环境
$SPARK_HOME/bin/pyspark --master yarn
启动提交式环境
$SPARK_HOME/bin/spark-submit --master yarn py文件路径 [参数]
在这里插入图片描述
在企业中，只需要准备 YARN 集群，然后选择一台服务器部署 Spark 环境，然后将代码提交给 YARN 即可

部署模式 DeployMode

SparkOnYARN 有两种运行模式：Cluster 和 Client
两种模式的区别在于 Driver 运行的位置

Cluster 模式：Driver 运行在 YARN容器 内部，和 ApplicationMaster 在同一个容器中，Executor 和 Driver 在 yarn 内部进行通讯，通讯成本低运行效率高
在这里插入图片描述
Client 模式：Driver 运行在 客户端进程 中，如 spark-submit程序的进程。Driver 和 Executor 跨集群进行通讯，从 yarn 内部通过网络请求和外部的客户端进行通讯，通讯成本高运行效率低

在这里插入图片描述

Client 模式

在这里插入图片描述

客户端模式下 yarn 中的 Driver 是没有日志的，日志都在客户端输出了（如程序运行结果）
在这里插入图片描述

Cluster 模式

在这里插入图片描述

集群模式下 yarn 中的 Driver 是有日志的，而客户端没有输出日志（如程序运行结果），因为 Driver 此时运行在容器内部，其日志被容器控制了 (注意要开启YARN的日志服务，不然只有日志入口，进不去日志内部)
在这里插入图片描述

两种模式总结

Client 和 Cluster 最 本质的区别 在于 Driver 运行在哪里

Client 学习测试时使用。生产不推荐（性能略低，稳定性略低）

Cluster 生产环境中使用。Driver 和集群的通信成本低；但Driver的输出结果不能在客户端显示；Driver 运行在 YARN 的 ApplicationMaster 这个节点上，出现问题 YARN 会重启 ApplicationMaster (YARN)

PySpark 库

框架 VS 类库

类库：别人写好的一堆代码，你可以导入使用，如 numpy
框架：可以独立运行，提供编程结构的一种软件产品，如 Spark 就是一个独立的框架

什么是PySpark

Spark 官方提供的一个 Python类库，内置了完全的 SparkAPI，可以通过该库来基于 Python 编写 Spark 应用程序，并将其提交到 Spark集群中运行
PySpark ∈ Spark，因为Spark还包含了Scala、java等API
在这里插入图片描述

安装

对集群中每台设备执行下面的操作：

切换到root用户，切换到pyspark虚拟环境下
在这里插入图片描述
用pip命令安装pyspark库

本机开发环境搭建

本机 PySpark 环境配置

安装几个后面会用到的包
在这里插入图片描述

在Pycharm中配置SSH解释器，远程连接到服务器的Python解释器
在这里插入图片描述

这样做会将当前工程中的文件及其修改在 Linux 中做同步，写完代码后可以选择在Linux中远程执行，将结果显示在pycharm中。
即便是虚拟机，Linux 运行 Spark 的速度也要快于 Windows，数据量上去之后更明显。
在这里插入图片描述

应用入口：SparkContext

在 Python 中，Spark 应用程序的入口为 SparkContext，任何应用都需要先构建一个 SparkContext 对象，步骤如下：

创建 SparkConf 对象。配置 Spark 的一些相关信息，如应用名称、运行的 Master (如local、Standalone、yarn)等
```
conf = SparkConf().setAppName(appName).setMaster(master)
```
基于 SparkConf 对象，创建 SparkContext 对象。
```
sc = SparkContext(conf=conf)
```

WordCount 代码实战

"""
分布式下的 helloworld
需求：单词计数，读取HDFS上的words.txt，计数其内部参数
"""
from pyspark import SparkConf, SparkContext

if __name__ == '__main__':
    conf = SparkConf().setMaster('local[*]').setAppName('WordCountHelloWorld')
    # 通过 SparkConf对象 构建 SparkContext对象
    sc = SparkContext(conf=conf)

    # 1. 读取文件
    # file_rdd = sc.textFile('hdfs://node1:8020/input/words.txt')  # 从HDFS中读取
    # file_rdd = sc.textFile('../data/input/words.txt')  # 从Linux本地文件中读取(相对路径)
    file_rdd = sc.textFile('/tmp/pycharm_project_spark_learncode/data/input/words.txt')  # 从Linux本地文件中读取(绝对路径)
    
    # 2. 分割字符串，得到存储全部单词的集合
    words_rdd = file_rdd.flatMap(lambda line : line.split(" "))
    # 3. 将单词转换为元组对象，key为单词，value为1
    words_with_one_rdd = words_rdd.map(lambda x: (x, 1))
    # 4. 将元组的value按key分组，并聚合（相加）
    result_rdd = words_with_one_rdd.reduceByKey(lambda a, b: a +b )
    # 5. 通过collect收集RDD的数据
    print(result_rdd.collect())

在window环境下跑上面的程序也没有问题，但是会出现很多小Bug，如Windows中没有配PYSPARK_PYTHON环境变量导致报错等，可以配环境变量（需重启机器）或临时指定一下

import os
os.environ['PYSPARK_PYTHON'] =
 'E:\\Python3_9_10\\envs\\pyspark\\Scripts\\python.exe'
 # Python环境下python.exe的路径

在这里插入图片描述

提交WordCount到Linux集群运行

不能在程序中指定master为local，否则代码优先级比较高会和yarn模式冲突
文件只能从HDFS中读取，因为本地文件不一定能被集群中的所有设备访问到（有些设备上没有相应的文件），就会报错

用 spark-submit 实现提交操作
在这里插入图片描述

总结

Python 开发 Spark 程序的步骤？
主要是获取 SparkContext 对象作为执行环境的入口

如何提交 Spark 应用？
$SPARK_HOME/bin/spark-submit

注意：
代码中不要设置master，否则spark-submit的设置就无效了
集群模式运行时，读取的文件要确保集群中的机器都能访问到

分布式代码执行分析

Spark 集群角色回顾（YARN为例）

Master(ResourceManager)：集群大管家，全集群的资源管理和分配
Worker(NodeManager)：单设备管家，在单个服务器上提供运行容器，管理资源
Driver：单 Spark 任务的管家，管理 Executor 的任务分解分配和执行，类似 Yarn 的ApplicationMaster。负责构建 SparkContext 对象
Executor：具体干活的进程
在这里插入图片描述

分布式代码执行分析

在这里插入图片描述

Driver 构建 SparkContext 对象
Spark 将 SparkContext 对象以序列化的方式分发给每个 Executor
每个 Executor 通过 SC对象 读取处理数据 (一份代码在多个 Executor(机器) 上执行)
通过 collect() 将每个 Executor 上的处理结果汇总到 Driver，Driver 打印结果

始于 Driver，终于 Driver

Python On Spark 执行原理

Spark 是典型的 JVM 框架，为了适配 Python 他是做了一定的修改的
纯 Java 环境下，JVM进程实现 Driver 和 Executor 的角色，二者很容易可以通信，但是 Python 无法和 JVM进程通信，怎么办？目标就是实现Python和Java的通信！

在 Driver 端，通过 py4j 模块(封装了RPC(远程过程调用)的功能)，实现了 Python 对 Java 的调用，将 Python 的 Driver 转化为 JVM Driver 运行。
在 Executor 端，Py4j并不能实现Java代码对Python代码的调用，且Python的Spark算子和Java的不是完全相同的，直接调用可能会不兼容。解决方案是启动 pyspark 守护进程作为JVM Executor和Python Executor的通讯中转站，将JVM Executor收到的操作指令转发(Sockt通信)给Python Executor，由Python Executor执行具体操作
在这里插入图片描述
综上，PySpark在Spark架构的外套了一层Python API，通过Py4j实现Python调用Java，进而实现通过Python编写Spark程序，通过这种模式甚至可以实现所有编程语言版本的Spark框架