前言：
💞💞大家好，我是书生♡，本阶段和大家一起分享和探索大数据技术–spark计算引擎，本篇文章主要讲述了：spark的概念，spark的起源，Spark的计算框架，Spark组成架构，Spark部署方式，Spark开发方式等等。欢迎大家一起探索讨论！！！
💞💞代码是你的画笔，创新是你的画布，用它们绘出属于你的精彩世界，不断挑战，无限可能！
个人主页⭐： 书生♡
gitee主页🙋♂：闲客
专栏主页💞：大数据开发
博客领域💥：大数据开发，java编程，前端，算法，Python
写作风格💞：超前知识点，干货，思路讲解，通俗易懂
支持博主💖：关注⭐，点赞、收藏⭐、留言💬
目录
1. Spark的概念
定义：
- Apache Spark是专为大规模数据处理而设计的快速通用的分布式计算引擎（基于内存），是开源的类Hadoop MapReduce的通用分布式计算框架。和MapReduce一样，都是完成大规模数据的计算处理。
- Spark 被设计用于处理诸如批处理、流处理、机器学习、图计算等多种类型的数据处理任务，并且可以在各种数据源上运行，包括结构化与非结构化的数据。
RDD是整个 Spark 的核心数据结构，Spark整个平台都围绕着RDD进行
小结：
- Spark 保留了分布式并行计算的优点并改进了其明显的缺陷。
- 中间数据存储在内存中
- 提供丰富的操作数据的API提高了开发速度。
2. Spark的起源
3. Spark和Hadoop的区别
| Hadoop | Spark | |
|---|---|---|
类型 | 分布式存储和处理大规模数据的框架，包含计算、存储、调度 | 分布式计算引擎 |
场景 | 大规模数据的批处理（离线） | 迭代计算、交互式计算、流计算（实时） |
价格 | 对机器要求低，便宜 | 对内存有要求，相对较贵 |
编程范式 | Map+Reduce，API 较为底层，算法适应性差 | API 较为顶层，方便使用 |
数据存储结构 | MapReduce中间计算结果在HDFS磁盘上，速度慢 | RDD中间运算结果在内存中，速度快 |
运行方式 | Task以进程方式执行 | Task以线程方式执行 |
Spark能完全取代Hadoop？ —》不能
- Spark主要用于替代Hadoop中的MapReduce计算模型。存储依然可以使用HDFS，但是中间结果可以存放在内存中，内存数据的读写速度要比磁盘快的多，所以Spark的计算速度要比MapReduce快
- Spark已经很好地融入了Hadoop生态圈，它可以借助于YARN实现资源调度管理，借助于HDFS实现分布式存储
注意：Presto也是基于内存计算的，Presto不适合海量数据处理，而且不能创建库表。Spark对海量数据在内存上的计算做了优化，内存不足是会将结果存在磁盘上，适合海量数据处理，并且可以进行库表创建
面试题：Hadoop的基于进程计算和Spark的基于线程计算方式优缺点？
Hadoop MapReduce (基于进程)
- 优点:
容错性: MapReduce 框架提供了强大的容错机制，当任务失败时，它会自动重新调度失败的任务。 大规模数据处理:
适用于处理大规模的数据集，因为每个Map或Reduce任务都是独立运行的，可以并行执行。
- 缺点:
高延迟: MapReduce 中的进程启动和关闭成本较高，导致较高的延迟。 不适合迭代计算:
对于需要多次迭代的算法，每次迭代都需要读取和写入磁盘，效率较低。
Apache Spark (基于线程)
- 优点:
内存计算： Spark 可以将中间结果缓存在内存中，减少磁盘I/O操作，从而提高处理速度。
低延迟： 基于线程的执行模型减少了任务启动的开销，提高了整体性能。
支持多种类型的数据处理：如批处理、流处理、机器学习等。
- 缺点:
内存消耗：内存中的数据存储可能会导致较大的内存占用
线程安全问题：多线程并发访问共享资源时需要考虑线程安全问题。
资源竞争：在多任务环境下，多个Spark作业可能会竞争有限的资源，影响性能。
进程和线程的区别：
- 进程是操作系统资源分配的基本单位，分配资源需要花费时间
- 线程是处理器任务调度和执行的基本单位，使用进程创建的资源执行任务
- 一个进程一般包含多个线程, 一个进程下的多个线程共享进程的资源
- 进程之间不共享资源
- 不同进程之间的线程相互不可见
- 线程不能独立执行，必须依附在进程中执行
4. Spark特性
Spark四大特性：高效性、易用性、通用性和兼容性
-
高效性
计算速度快，由于Apache Spark支持内存计算，并且是通过线程执行计算任务，所以在内存中的运算速度要比Hadoop的MapReduce快100倍，在硬盘中要快10倍。
-
易用性
支持多种编程语言开发 （Python，Java，Scala，SQL，R等），降低了学习难度
-
通用性
- 支持多种计算方式
- RDD计算 -> Spark core
- SQL计算（离线计算）-> Spark SQL
- 图计算 -> Spark GraphX
- 机器学习计算 -> Spark MLlib
- 流式数据计算（实时数仓中使用）-> Spark Streaming
- 支持多种开发方式
- 交互式开发 -> 通过输入命令完成程序运行
- 脚本式开发 -> 通过编写代码文件完成程序运行
- 支持多种计算方式
-
兼容性
- 支持三方工具接入
- 数据存储工具
- hdfs
- kafka
- hbase
- es
- mysql
- 资源调度工具
- yarn
- standalone（spark自带）
- mesos
- 高可用工具
- zookeeper
- 数据存储工具
- 支持多种操作系统
- Linux
- Windows
- Mac
- 支持三方工具接入
5. Spark架构–流程
5.1 MapReduce架构–流程
- 客户端提交一个MR程序给ResourceManager(校验请求是否合法…)
- 如果请求合法,ResourceManager随机选择一个NodeManager用于生成appmaster(应用程序控制者,每个应用程序都单独有一个appmaster)
- appmaster会主动向ResourceManager应用管理器(application manager)注册自己,告知自己的状态信息,并且保持心跳
- appmaster会根据任务情况计算自己所需要的container资源(cpu,内存),主动向ResourceManager资源调度器(resource
scheduler)申请并获取这些container资源- appmaster获取到container资源后,把对应指令和container分发给其他NodeManager,让NodeManager启动task任务(maptask,reducetask)
- NodeManager要和appmaster保持心跳,把自己任务计算进度和状态信息等同步给appmaster,(注意当maptask任务完成后会通知appmaster,appmaster接到消息后会通知reducetask去maptask那儿拉取数据)直到最后任务完成
- appmaster会主动向ResourceManager注销自己(告知ResourceManager可以把自己的资源进行回收了,回收后自己就销毁了)
5.2 HIve计算流程
HIve就是将HIveSql语言转换为MR的计算语言，其他的和MR一样
5.3 Spark计算流程
Spark就是将SparkSql语言转换为Spark的RDD计算方式，中间数据存储在内存上，最终结果是存储在HDFS上的
5.4 Spark组成架构
- Spark Core: 基于RDD计算, 处理非结构化数据(多维数据), spark的核心数据结构, 所有组件基于RDD进行计算
- Spark SQL: 基于DataFrame/DataSet计算, 处理结构化数据, 提供了DSL方式和SQL两种编写方式。每个数据库表被当做一个RDD，Spark SQL查询被转换为Spark操作。
- Spark/Structured Streaming: 流计算, 进行实时计算。Spark Streaming允许程序能够像普通RDD一样处理实时数据
- Spark ML/MLlib: 机器学习, AI项目开发, 推荐系统 了解
- Spark Graphx: 图计算组件, 控制图、并行图操作和计算的一组算法和工具的集合
5.5 Spark Core 和RDD的关系
5.5.1 RDD是什么
- RDD (Resilient Distributed Datasets)
RDD 是 弹性分布式数据集 的缩写，它是 Apache Spark 中最基本的数据抽象。RDD 代表一个不可变的、可分区的、包含元素的集合，这些元素可以并行地在集群的不同节点上进行计算。
以下是 RDD 的一些关键特点：
- 不可变性：一旦创建，RDD 就不能改变其内部的状态或结构。
- 分区：RDD 可以被划分为多个分区，这些分区可以在集群的不同节点上进行并行处理。
- 容错性：RDD 具有自动恢复丢失数据的能力，并且能够从失败中恢复。
- 懒加载：许多 RDD 操作都是惰性的，这意味着它们不会立即执行，直到遇到一个行动（action）操作时才会触发实际的计算。
- 血统：RDD 之间的转换操作会形成一种依赖关系，这种依赖关系被称为“血统”，Spark 使用血统信息来重新计算丢失的数据分区。
5.5.1 Spark Core是什么
- Spark Core
Spark Core 是 Apache Spark 的核心组件，提供了 Spark 的基础功能，包括任务调度、内存管理、故障恢复以及与存储系统的交互等。Spark Core 提供了一个运行时环境，支持所有其他的 Spark 模块，例如 Spark SQL、Spark Streaming、MLlib（机器学习库）和 GraphX（图处理库）。
Spark Core 的主要组成部分包括：
- RDD API：提供了用于操作和处理数据集的功能。
- 任务调度器：负责任务的分配和执行。
- 内存管理器：管理应用程序使用的内存。
- 容错机制：确保即使在硬件故障的情况下也能正确执行程序。
5.5.3 Spark Core 和RDD的关系
通俗点来说就是：Spark Core是Spark的核心组件，他的底层引擎就是RDD ，Spark Core 的编程模型允许开发者以 RDD 为基础编写应用程序，SparkCore要遵守RDD的规则。
我们如果要使用SparkSQL去Sql语句的话，sql要遵守DataFrame/DataSet类型，然后转化为RDD能执行的代码（DataFrame 和 Dataset API 内部已经实现了对 RDD 的封装和优化。当你使用 DataFrame 或 Dataset API 时，Spark 会自动将这些操作转换为一系列的 RDD 转换操作），但是Spark Core不需要进行转化，即可以直接进行计算执行代码，因为他的底层引擎就是RDD
总结
- Spark Core 是 Spark 的核心组件，支持 RDD 作为其主要的数据抽象。
- RDD是一种低级别的数据抽象，适用于更细粒度的控制和自定义逻辑。
- DataFrame 和 Dataset是更高层次的抽象，提供了更简单的接口和更好的性能优化。
- 当使用 DataFrame 和 Dataset 时，Spark 会自动将操作转换为RDD 操作，但用户通常不需要关心这个细节。
6. Spark部署方式
Spark部署模式分为
Local模式(本地单机模式)和集群模式。
- Local 模式（本地模式）
- 本地模式部署，使用一台服务器进行部署，一般用于测试代码，在本地能运行成功的代码在集群下也能运行成功
- 集群模式
- spark on standalone模式
- Standalone模式被称为集群单机模式。Spark框架自带了完整的资源调度管理服务，可以独立部署到一个集群中，无需依赖任何其他的资源管理系统。在该模式下，Spark集群架构为主从模式，即一台Master节点与多台Slave节点，Slave节点启动的进程名称为Worker。此时集群会存在单点故障问题，利用Zookeeper搭建Spark HA集群解决单点问题。
集群主从架构
- cluster manager: 主节点, 管理集群，控制整个集群，监控worker。在YARN模式中为资源管理器
- worker: 从节点, 控制计算任务, 创建executor或driver进程
- driver: 进程程序, 负责管理计算任务, 当spark的计算代码程序运行Application的main()函数时就会产生一个drive。
- executor: 进程程序, 负责执行计算任务, 在executor进程中创建线程执行task
- spark on yarn模式
- Yarn模式被称为Spark on Yarn模式，即把Spark作为一个客户端，将作业提交给Yarn服务，由于在生产环境中，很多时候都要与Hadoop使用同一个集群，因此采用Yarn来管理资源调度，可以有效提高资源利用率，Yarn模式又分为Yarn Cluster模式和Yarn Client模式：
- yarn cluster模式: 由yarn自行选择资源充足的节点创建driver进程, 生成环境中使用
- yarn client模式: spark应用程序提交到哪台节点, 就由哪台节点创建driver进程, 测试环境中使用
- spark on mesos模式 了解
- mesos资源调度工具管理spark集群资源，Mesos模式被称为Spark on Mesos模式，Mesos与Yarn同样是一款资源调度管理系统，可以为Spark提供服务，由于Spark与Mesos存在密切的关系，因此在设计Spark框架时充分考虑到了对Mesos的集成，但如果你同时运行Hadoop和Spark，从兼容性的角度来看，Spark on Yarn是更好的选择。
7. spark开发方式
spark开发方式有两种：
- 交互式开发：交互式开发是指在开发过程中，程序员可以即时地测试代码片段或者函数的效果，而不必等到整个程序完成后再进行测试
- 脚本开发：脚本开发是一种传统的编程方式，程序员编写完整的脚本或程序文件，然后一次性运行整个脚本。这种方式适用于自动化任务和构建大型应用程序。
7.1 交互式开发
交互式开发有 2中模式：
- Scala交互式开发
- Python交互式开发
Scala 交互式开发 ：
Scala 是一种静态类型的函数式编程语言，同时兼容面向对象编程风格。在 Scala 中进行交互式开发通常涉及到使用
REPL（Read-Eval-Print Loop）环境，如 scala 命令行工具或集成开发环境中的 Scala REPL 特性。
Python 交互式开发：
Python 是一种动态类型的解释型语言，广泛应用于数据分析领域。在 Python 中进行交互式开发通常涉及到使用 Jupyter Notebook、Zeppelin 或 IPython shell 等工具。
准备前提：启动Hadoop集群 ,因为Spark的最终结果是存储在HDFS上面的因此我们其实要启动的是HDFS
# 启动Hadoop集群
start-all.sh
7.1.1 Scala交互式开发
- 输入spark-shell指令进入终端进行开发
spark-shell
7.1.2 Python交互式开发
注意：park依赖的Python解析器版本是Python3，系统中如果没有Python3会报如下错误
python3：没有那个文件或目录
- 安装Anaconda工具, 自带python3解析器
python3的安装可以借助Anconada工具完成，Anconada中自带Python3，同时还集成了各种Python的科学计算库(Pandas,Numpy等)Anconada的安装参考《部署文档》注意安装完成后需要重启服务
init 6
anaconda虚拟环境操作指令:
# 查看所有的虚拟环境
conda info --envs
# 创建新的虚拟环境, 并安装python解析器 conda create -n 虚拟环境名 python=版本号
conda create -n itcast python=3.9
# 切换进入虚拟环境 conda activate 虚拟环境名
conda activate itcast
# 退出虚拟环境
conda deactivate
# 删除 conda remove -n 虚拟环境名 --all
conda remove -n itcast --all
conda activate base # 要先进入base虚拟环境
输入pyspark
进入python终端
我们可以在这里进行计算（注意：相当在内存中进行了计算，结果不会保留）
7.2 脚本式开发
先写一个以.py 结尾的文件
然后执行
示例：要自信root下面的sparkshell1.py文件
我们既可以通过python3 来执行
注意：
我们需要在文件中 导入 pyspark这个模块，如果环境中没有，那么就会报错，这个时候我们只需要下载pyspark这个模块就可以了。
pip install pyspark==3.1.2 -i https://pypi.tuna.tsinghua.edu.cn/simple
然后再次运行程序，即可以正常的出结果。
注意：一般不同spark应用程序可以使用不同的spark和python解析器, 可以通过以下代码指定spark和python解析器
也可以将以下spark和python解析器路径添加到 /etc/bashrc 文件中, 此时就不需要在每个应用程序中手动指定spark和python解析器(练习时可以设置, 实际工作中不建议使用此方式)
我们在进入etc目录下会有一个bashrc文件
这个文件里面就存放我们的spark和python解析器的路径，这样我们就可以避免每一次都需要写路径
8. PyCharm远程开发配置
- 创建一个pycharm项目
- 创建好项目之后，我们点击“文件”–“设置”–“SSH连接”
这一步是为了我们的pycharm能够连接上我们的服务器
我们需要连接几台这里就连接几台 - 配置远程的Python环境
pycharm中点击File,选择Settings，选择项目python解析器: Python Interpreter, 添加新的python解析器
我们这里选择我们刚那个连接好的服务器，看python具体在那一台上面
一直点击下一步，然后选择系统解释器，我们可以修改服务器上同步文件夹的位置
最后点击创建就可以了 - 配置sftp服务
当配置Python远程环境时，指定了远程映射目录后，会自动配置sftp。
- 使用sftp操作远程服务器的文件
- 将本地开发的代码自动上传服务器
我们这里选择自动上传文件
下面这个配置是自动生成的，如果出现问题可以自行修改
- 第一个python spark开发程序
创建一个文件写入数据
右键执行查看结果，是否能正常运行
- 配置数据库
点击右边的数据库标识
点击加号，选择数据源
进入后填写数据库的链接信息，最后测试通过就可以。第一次连接时候需要下载驱动
9. 不同部署模式的Spark使用操作
我们的每一个部署模式都有交互式开发和脚本开发
不管哪一种部署模式，我们的结果数据都需要存储在HDFS上，因此我们都需要开启Hadoop集群。
start-all.sh
9.1 Local部署模式
9.1.1 Local本地模式交互式开发
我们的spark，默认就是local本地部署，当我们启动pyspark的时候不指定集群模式，默认就是local
如果我们要查看历史服务，可以开启历史服务
# 开启历史服务
/export/server/spark/sbin/start-history-server.sh
全部开启后，我们输入pyspark就可以进入到本地模式
此时我们通过访问4040端口号，就可以访问我们本次程序的web页面
注意：4040 端口仅仅是在程序运行中可以访问，仅限于交互式开发中，每个运行的Spark应用程序，以及在脚本开发中还没有结束的时候访问查看
- 我们在本地模式的时候，会默认使用服务器中所有可用的核数
- 指定核数：pyspark --master local[2] # 使用2个核
9.1.2 Local本地模式脚本开发
我们在进行“交互式开发的时候会默认创建sc对象”，但是在脚本开发的时候不会创建，需要我们手动创建SC对象
from pyspark import SparkContext
# 创建sc对象, 只能创建一个sc对象
# 不添加master参数, 默认使用local模式, 使用cpu所有可用的核数
sc = SparkContext() # 默认使用服务器中所有可用的核数
# 使用local模式, 核数2个
sc = SparkContext(master='local[2]')
rdd1 = sc.parallelize([1, 2, 3, 4])
print(rdd1.collect())
result = rdd1.reduce(lambda x, y: x + y)
print(result)
9.2 集群模式
spark中集群模式一共有三种，这里我们只介绍两种：Standalone集群模式和Yarn集群模式
9.2.1 Standalone集群模式
- Standalone集群模式
standalone是spark自带的资源调度管理服务,有两个节点：
- master 类似 yarn中的ResourceManger 负责管理资源服务
- worker 类似 yarn中的NodeManager 负责将每台机器上的资源给到计算任务
- spark master WEB UI:
http://192.168.88.100:8080/
我们的Standalone是一个独立的服务，因此我们需要再虚拟机上单独启动Standalone服务
node1上的启动指令
/export/server/spark/sbin/start-all.sh
- 分布式开发
启动完Standalone之后，我们就可以启动pyspark, 使用standalone资源调度
pyspark --master spark://node1:7077
2. 脚本开发
from pyspark import SparkContext
import os
# 指定spark和python3解析器路径
"""
SPARK_HOME = '/export/server/spark'
PYSPARK_PYTHON = '/export/server/anaconda3/bin/python3'
# 导入路径
os.environ['SPARK_HOME'] = SPARK_HOME
os.environ['PYSPARK_PYTHON'] = PYSPARK_PYTHON
"""
# # 创建sparkcontext
# sc= SparkContext()
# 创建sparkcontext，指定master地址，指定集群模式为standalone模式
sc = SparkContext(master='spark://node1:7077')
# 创建rdd
rdd= sc.parallelize([1,2,3,4])
# 打印rdd中的数据
print(rdd.collect())
# reduce操作
res = rdd.reduce(lambda x,y:x+y)
# 打印结果
print(res)
- Standalone 高可用集群模式
说明：启动多个master, 一个master出现问题可以使用其他master
三台服务器都需要启动zk服务 zkServer.sh start
启动standalone服务
- node1上的启动指令 /export/server/spark/sbin/start-all.sh
- node2上的启动指令 /export/server/spark/sbin/start-master.sh
- 交互式开发
pyspark --master spark://node1:7077,node2:7077
我们查看node1的状态，属于存活状态
2. 脚本开发
from pyspark import SparkContext
import os
sc = SparkContext(master='spark://node1:7077,node2:7077')
rdd1 = sc.parallelize([10,20,30,40])
print(rdd1.collect())
res= rdd1.reduce(lambda x,y:x+y)
print(res)
我们现在node1上跑程序
我们吧node1上面的master关掉，再次执行
此时node2会变为alive
执行程序会有任务正在执行
9.2.2 Standalone各个端口的意义和作用
- Master Web UI (8080):
- 意义与作用: 这个端口用于提供Master节点的Web界面。用户可以通过这个WebUI监控整个集群的状态，包括正在运行的应用程序、Worker节点的状态、任务进度等信息。
- Application Web UI (4040+):
- 意义与作用: 每个提交到集群的应用程序都会启动一个Web UI，通常从端口4040开始递增。这些WebUI提供了应用程序级别的监控信息，包括执行阶段（stages）、任务（tasks）的状态、运行时间统计等。
- Worker Web UI (8081):
- 意义与作用: Worker节点也有自己的WebUI，通常监听在8081端口。通过这个界面，用户可以看到每个Worker节点的资源使用情况、已分配的任务等信息。
- Spark History Server (18080):
- 意义与作用: Spark History Server是一个可选组件，用于存储已完成的应用程序的历史记录，并提供一个Web UI来查看这些历史记录。这有助于事后分析应用的性能问题或者审计应用的行为。
- Master 的 RPC 端口 (7077):
- 意义与作用:
Master节点监听的RPC端口，用于接收来自Worker节点和客户端的请求。Master通过这个端口与Worker节点通信，调度任务和管理资源。 - Worker 的 RPC 端口 (8081):
- 意义与作用: Worker节点监听的RPC端口，用于接收来自Master节点的指令，例如注册、心跳检测、任务分配等。
- Block Manager 的 HTTP 端口 (8082):
- 意义与作用: Block Manager负责管理内存中的数据块缓存。此端口用于提供有关缓存状态的信息
注意：为什么我们Standalone 执行的时候端口是7077，但是浏览器UI确实8088端口
spark://node1:7077: 用于Master节点内部通信。
http://node1:8080:用于访问Master节点的Web UI。
9.2.3 Yarn集群模式
集群中可以启动多个资源调度服务, 互相不影响
- 交互式开发
我们的Yran进行资源调度的时候：
第一步：需要先开启Hadoop集群，
第二步：启动pyspark, yarn资源调度
pyspark --master yarn
- 脚本开发
from pyspark import SparkContext
import os
sc = SparkContext(master='yarn')
rdd1 = sc.parallelize([10,20,30,40])
print(rdd1.collect())
res= rdd1.reduce(lambda x,y:x+y)
print(res)
10 spark指令参数
10.1 指令参数
交互式开发和脚本式开发:
- 交互式开发: 通过spark指令进入交互模式(终端)进行代码开发
- 脚本式开发: 通过python解析器运行python文件代码, pycharm中执行.py文件
在通过指令运行时，就是进入交互模式，来运行一个spark计算程序
注意点: 参数对spark所有指令都有效
–master:
作用: 指定运行应用程序的集群管理器的URL。例如，可以设置为 local, local[N], spark://master:port,
yarn, mesos://host:port 等。 用途: 定义应用程序将在何处运行以及如何与集群交互。
–deploy-mode:
作用: 指定应用程序的部署模式，可以选择 client 或 cluster。 用途: client
模式意味着Driver程序在提交应用程序的客户端机器上运行；cluster 模式意味着Driver程序在集群中的一个Worker节点上运行。
–name:
作用: 设置应用程序的名字。
用途: 为应用程序提供一个易于识别的名称。
–conf:
作用: 设置Spark配置属性。
用途: 调整Spark配置，以满足特定的需求，如内存管理、调度策略等。
–num-executors:
作用: 设置Executor的数量。
用途: 控制集群中启动的Executor进程的数量。
–executor-memory:
作用: 设置每个Executor的内存大小。
用途: 控制每个Executor可以使用的内存量。
–executor-cores:
作用: 设置每个Executor的核心数。
用途: 控制每个Executor可以使用的CPU核心数。
–driver-memory:
作用: 设置Driver程序的内存大小。
用途: 控制Driver程序可以使用的内存量。
–driver-cores:
作用: 设置Driver程序的核心数。
用途: 控制Driver程序可以使用的CPU核心数。
# 表示引用运行的模式，要么是本地local要么是集群（Standalone、YARN、Mesos）了
--master MASTER_URL
# 本地模式∶local[2] 数字表示可以使用到本地的cpu核心数, loacl[*] *表示自动判断
# Standalone集群∶spark∶//xxx∶7077，yyy∶7077
# YARN 集群∶ yarn
# 表示的是应用运行的名称，通常在应用开发的时候指定
--name NAME
# 表示应用运行时指定的某些参数配置，http∶//spark.apache.org/docs/2.2.0/configuration.html
# 当value中的值有空格组成的时候，使用双引号将key=value引起来
# 可以不用在bashrc写配置可以通过conf配置，每次运行都要指定很麻烦
--conf "PROP=VALUE"
# 第一种方式∶属性的值中没有空格
--conf spark.eventLog.enabled=false
# 第二种方式∶属性的值中有空格，将属性和值统一使用双引号引起来
--conf "spark.executor.extraJavaOptions=-XX:+PrintGCDetails -XX:+PrintGCTimestamps"
# Driver相关配置 对driver一般不用配置
# 指定Driver Program JVM进程内存大小，默认值为1g
--driver-memory MEM
# 表示Driver 运行CLASS PATH路径，使用不多
--driver-class-path
# Spark standalone with cluster deploy mode∶运行在standalone 中cluster Deploy Mode 默认值为1 cpu核心数量
# 运行在YARN in cluster mode，默认值是1
--driver-cores NUM
# 运行在standalone的 中cluster Deploy Mode下，表示当Driver运行异常失败，可以自己重启
--supervise
# Executor运行所需内存大小
--executor-memory MEM
# Executor 运行的CPU Cores，默认的情况下，在Standalone集群上为worker节点所有可用的Cpu Cores，在YARN集群下为1
--executor-cores NUM
# 表示运行在Standalone集群下，所有Executor的CPU Cores，结合--executor-cores计算出Executor个数
--total-executor-cores
# 表示在YARN集群下，Executor的个数，默认值为2
--num-executors
# 表示Driver Program运行的地方，也叫做应用部署模式，默认值为client，通常在生产环境中使用cluster
--deploy-mode DEPLOY_MODE
举例：
交互式开发
# 指定的参数中，主要是资源调度模式, 应用程序名称, python解析器配置
# --name: 应用程序名称
# --executor-memory: executor节点内存大小
# --num-executors: executor数量
# --conf: 其他参数
pyspark --master yarn --name yarn_demo --executor-memory 2G --num-executors 3 --conf PYSPARK_PYTHON=/export/server/anaconda3/bin/python3
脚本开发
from pyspark import SparkContext
from pyspark import SparkConf
# 创建conf对象, 设置参数
# key:参数名 str类型
# value:参数值 str类型
# executor参数在脚本中不生效
conf = (SparkConf().
set('executor-memory', '2g').
set('num-executors', '3'))
# 创建sc对象, 设置参数, 一些参数可以通过conf对象进行传递
sc = SparkContext(master='yarn', appName='yarn_demo', conf=conf)
rdd1 = sc.parallelize([1, 2, 3, 4])
print(rdd1.collect())
result = rdd1.reduce(lambda x, y: x + y)
print(result)
10.2 driver和executor参数
- driver
- 进程程序
- 在创建sc对象时(执行application main函数时), 会自动创建driver进程
- 管理计算任务
- 向资源调度工具的主服务申请计算资源, 创建出executor进程
- executor
- 进程程序
- 通过driver进程创建出executor进程
- 多少个executor进程对应着多少台从节点服务器
- 执行计算任务 -> 以线程方式执行
driver和executor参数设置
只能在交互式开发中生效
例如：
# 一般情况不调整driver参数, 只负责管理
pyspark --master yarn --driver-memory 2g --driver-cores 2 --executor-memory 2g --num-executors 3 --executor-cores 2
11. spark-submit指令
spark-submit 是一个通用的脚本，用于启动 Spark 应用程序。它支持多种语言（如 Scala、Java、Python 和 R）编写的 Spark 应用程序，并且可以将应用程序提交到不同的集群管理器（如 Spark Standalone、YARN、Mesos等）。
- 基本使用
spark-submit --参数名 参数值 .py
# executor数量为3, core数量为2
spark-submit --master yarn --num-executors 3 --executor-cores 2 Yarn集群模式.py
执行后查看有3个executors，每一个有2cores，一共是有6个Cores
park-submit结合--deploy-mode参数使用
- cluster模式要求部署模式为yarn集群模式
- pycharm运行yarn模式脚本时, 使用的是client模式
- –deploy-mode client(client模式): driver进程在提交服务器上创建, 默认是client模式
- –depoly-mode cluster(cluster模式): driver进程由yarn选择资源充足的服务器进行创建
- 常见错误
# 执行此语句发生报错
spark-submit --deploy-mode cluster b.py
#spark-submit 提交时未指定--master，程序认为是local本地提交 和--deploy-mode cluster产生冲突
#--deploy-mode cluster 指定的含义是将计算任务提交到集群执行
'====================================================='
# 执行此语句发生报错
# 使用standalone集群模式提交
spark-submit --master spark://node1:7077,node2:7077 --deploy-mode cluster b.py
# --deploy-mode cluster 针对yarn集群的提交模式指定,不支持standalone集群的提交
可以发现我们在指定模式为Standalone模式的时候 --deploy-mode client 是可以执行的，但是切换到cluster就不行
spark-submit --master yarn --num-executors 3 --executor-cores 2 --deploy-mode cluster Yarn集群模 式.py
我们会发现driver并不是我们提交的服务器，是其他的，那就说明cluster会找到空余的节点执行任务
spark-submit --master yarn --num-executors 3 --executor-cores 2 --deploy-mode client Yarn集群模式.py
我们会发现driver就是是我们提交的服务器，那就说明client会用自己的服务器去提交任务
小结：
- 生产环境中, 使用culster模式, 防止服务器资源不足导致driver创建失败
- cluster模式只能在yarn集群模式下使用
- pycharm提交yarn模式脚本默认使用的是client模式
- 可以通过定时调度工具调度spark-submit指令, 实现定时执行spark应用程序
- client模式下，Standalone模式也可以执行
扫一扫
768
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
