Spark的部署与使用

1.Spark基础

1.1 什么是 Spark?

1. 基本概念

• 定义: Spark 是为大数据设计的分布式计算框架，能够在分布式环境中高效处理数据。与 Hadoop 集成: 可替代 MapReduce

• 计算模型: 通过 RDD（内存中弹性分布式数据集），Spark 将数据分成多个分区，分布在集群节点上并行处理。

2. 什么是弹性？

• 简单理解: 弹性是指系统在面对变化或问题时仍能维持高效运行的能力。在 Spark 中，即使计算过程中部分节点出错或任务失败，系统可以通过历史操作记录自动恢复并完成任务。

• 在 RDD 中的弹性:即容错性: 如果在数据处理过程中某个分区的数据丢失，Spark 会根据 RDD 的血缘关系（操作历史记录），重新计算丢失的数据分区，而不需要重新运行整个任务。

3. RDD 的功能

• RDD 会将大数据集划分成多个分区，每个分区分布到不同的计算节点上进行并行处理。这种方式可以充分利用集群的计算资源，大大加快数据处理速度。

4. 举例

例子：统计单词出现次数

你有一本包含大量文本的电子书文件，想统计每个单词的出现次数。

传统方法：

1. 将文件逐行读入内存。

2. 对每一行进行单词分割，逐一统计。

3. 如果文件特别大，处理速度会很慢，甚至内存不够用。

使用 RDD 的方法：

1. 将文件加载为 RDD：Spark 会将电子书文件分成多个分区，每个分区存储一部分数据。

2. 转换操作：

• 对每行文本进行单词分割（flatMap 操作）。

• 为每个单词标记 1（map 操作）。

• 将相同单词的计数相加（reduceByKey 操作）。

3. 行动操作：

• 使用 collect 或 save 将结果保存或打印。

5. 数据处理特点

• 数据拆分: Spark 会把大数据集分成多个分区，并在多个计算节点上并行处理这些分区数据。

• 结果合并: 处理完每个分区的数据后，Spark 会把结果合并成一个完整的结果。

• 存储交互: Spark 只在需要读取数据和保存最终结果时与存储系统交互，其他时间在内存中处理数据。

6. 核心优势

• 速度: Spark 的处理速度比 Hadoop MapReduce 快很多，最多可达 100 倍。

• 内存计算: Spark 大部分时间在内存中处理数据，减少了读写磁盘的时间，所以速度很快。

• 批处理与流处理: Spark 不仅可以处理已经存储的数据，还能处理实时产生的数据。

总结

Spark 是一个高速、灵活且易于使用的大数据处理平台，能够处理各种类型的数据和任务。它是当今大数据领域的关键技术之一。

许多大公司已经在使用 Spark 作为大数据的计算框架，包括 eBay、Yahoo、BAT、网易、京东、华为等。同时，Spark 也得到了 IBM 和 Intel 等顶级 IT 厂商的支持。

1.2 Apache Spark其核心功能和组件

这张图展示了 Apache Spark 的核心功能和组件

1. Spark 的核心部分 - Spark Core

• Spark Core 是整个 Spark 平台的基础，Spark 的“心脏”。作用如下：

• 任务调度：负责将数据处理任务分配到集群中的不同节点上

• 内存管理：提供内存计算的支持，避免频繁读写磁盘，从而提升性能

• 错误恢复:   通过血缘关系，Spark Core 能在任务失败时重新计算丢失的数据分区，确保计算任务的可靠性。

• 分布式计算:Spark Core 支持将数据划分为多个分区，并在多个计算节点上并行处理。

• 数据存取:支持从多种存储系统中读取数据，比如 HDFS、本地文件系统

2. Spark 的功能模块

在 Spark Core 之上，Spark 提供了几个重要的功能模块，每个模块都有特定的用途：

1）Spark SQL:

• 功能: 使用 SQL 语言来查询和操作数据。

• 作用: 使用 Spark SQL 处理大数据，就像在传统数据库中运行查询一样。

2）Spark Streaming:

• 功能: 用于处理实时数据流。

• 作用: 它可以处理像传感器数据、网站点击流等实时生成的数据，并进行实时分析。

3）MLlib (机器学习库):

• 功能: 提供了常用的机器学习算法。

• 作用: MLlib 可以实现大数据上进行机器学习，比如分类、回归、聚类等任务。

4）GraphX:  

• 功能: 用于处理图形数据和图计算。[ɡræf ˈeks]

• 作用: 适合分析复杂的网络关系，比如社交网络中的好友关系，交通网络中的路径优化等。

3. 集群管理器

Spark 可以在不同的集群环境中运行，集群管理器帮助 Spark 管理计算资源和任务调度：

• 本地运行模式: Spark 可以在一台机器上运行，适合开发和测试。

• 独立运行模式: Spark 可以独立组成一个集群，并自己管理资源和任务。

• YARN: 这是 Hadoop 的资源管理器，Spark 可以与 Hadoop 集成，使用 YARN 来管理集群资源。

4. 数据存储层

• 底层数据存储: Spark 可以从多种数据源读取和写入数据，比如 HDFS、HBase、Kafka、Hive、Mysql、csv/json、Nosql等数据类型。这些存储层为 Spark 提供了数据的存储和读取支持。

总结

通过这张图，你可以看到 Spark 是一个强大的大数据处理平台，它的核心部分是 Spark Core，上面集成了多种功能模块（如 SQL 查询、实时数据处理、机器学习、图计算等）。Spark 可以在多种集群环境中运行，并支持从多种数据存储系统中读取数据，这使得它非常灵活且易于使用。

这个图展示了 Spark 如何通过不同的功能模块和集群管理器，来处理和分析大规模数据的能力。无论是静态数据还是实时数据，Spark 都能轻松应对。

spark特点

1.3 Spark基本工作原理

这张图展示了Spark的基本工作原理：

1. 客户端提交任务：

• 图的左侧有一个蓝色方框，标注为“Client”，代表客户端。用户在客户端上编写程序，并将任务提交给Spark进行处理。这个任务可能是对大数据进行分析或处理。

2. 分布式集群处理任务：

• 中间绿色的区域代表“Spark分布式集群”，这个集群是由多台计算机组成的，每台计算机称为一个“节点”。

• 图中的每一个圆圈代表一个“节点”，这些节点会分担处理任务。每个节点上处理的内容被标注为“RDD分区”。RDD分区就是把大数据（RDD）拆分成的小块，每个小块在不同的节点上处理。

3. Map和Reduce操作：

• Map操作：当任务提交到Spark集群后，每个节点会首先对分配到的RDD分区进行Map操作。Map操作是一种数据转换，它会对数据进行初步的处理，比如过滤或转化。

• 比如，节点1处理的“数据10”经过Map操作后，生成“数据11”。

• Reduce操作：Map操作完成后，数据会继续进入Reduce阶段。Reduce操作会将之前处理后的数据进一步整合、汇总，生成最终的处理结果。

• 比如，节点4将Map操作后的“数据11”经过Reduce处理后，生成“数据12”。

4. 数据的读取与输出：

• Spark可以从不同的数据源读取数据，这些数据源可能包括HDFS（Hadoop分布式文件系统）、HBase（数据库）、Hive（数据仓库），甚至是MySQL等传统的数据库。

• 数据经过Map和Reduce操作处理后，会生成最终的结果。这些结果可以输出到不同的存储系统，如HDFS、Hive、HBase，或者直接返回给客户端供用户使用。

5. 总结数据流动过程：

• RDD分区：表示被拆分后的小数据块，这些块分别在不同的节点上处理。

• 节点：每个圆圈（节点）表示一台处理计算的计算机。

• 数据处理流程：数据首先经过Map阶段的初步处理，接着经过Reduce阶段的汇总处理，最终将处理结果保存或输出。

总结：

Spark通过将大数据集（RDD）分割成多个小块（RDD分区），并将这些小块分发到不同的节点（计算机）上进行并行处理。每个节点执行Map和Reduce操作来处理这些分区，最终将处理后的数据输出到指定的存储系统或直接返回给用户。这样，Spark能够快速、高效地处理大规模的数据任务。

重点：

RDD 是一个逻辑上的分布式数据集，Spark 将整个数据集（RDD）拆分成多个 分区（Partition）。

分区 是 RDD 的物理实现，一个 RDD 会被拆分成多个分区，每个分区存储在集群的不同的节点上。

最简单的理解： RDD就是源数据的抽象，或者叫映射也就是说，数据要被spark进行处理，在处理之前的首要任务就是要将数据映射成RDD，对于spark来说，RDD才是我们处理数据的规则，我只认RDD，只有RDD，通过我spark的计算引擎，才能发挥巨大的威力！

（1）分布式数据集 RDD是Spark提供的核心抽象，全称为Resillient Distributed Dataset，即弹性分布式数据集。

RDD在抽象上来说是一种元素集合，包含了数据。它是被分区的，分为多个分区，每个分区分布在集群中的不同节点上，从而让RDD中的数据可以被并行操作。

（2）RDD 的内存管理与溢写机制 RDD 的数据默认存储在内存中，但如果内存资源不足，Spark 会根据需要将 RDD 的数据 溢写到磁盘。这一过程并不是 "自动将 RDD 数据写入磁盘"，而是当内存不足时，Spark 会将一些数据写入磁盘以避免内存溢出，确保计算能继续进行。这种机制被称为 内存溢出（spill to disk）。

（3）迭代式处理

对节点1、2、3、4上的数据进行处理完成之后，可能会移动到其他的节点内存中继续处理！Spark 与Mr最大的不同在与迭代式计算模型：Mr分为两个阶段，map和reduce，两个阶段处理完了就结束了，所以我们在一个job中能做的处理很有限，只能在map和reduce中处理；而spark计算过程可以分为n个阶段，因为他是内存迭代式的，我们在处理完一个阶段之后，可以继续往下处理很多阶段，而不是两个阶段。所以Spark相较于MR，计算模型可以提供更强大的功能。

（4）弹性（容错性） R当某个节点的 RDD 分区因故障而丢失数据时，Spark 会根据 RDD 的血缘信息（即数据操作的执行历史记录）自动重新计算丢失的分区，而无需重新执行整个任务。这个过程对用户是透明的，用户无需干预，系统会自动恢复。

1.4 Spark 运行模式及集群角色

1.4.1 Spark运行模式

1.4.2 Spark集群角色

下图展示了Spark集群的角色组成，主要包括以下五个部分：集群管理器（Cluster Manager）、工作节点（Worker）、执行器（Executor）、驱动器（Driver） 和 应用程序（Application）。下面详细说明每个部分的作用和特点。

简单的例子：统计数据

假设你有一份大数据集，并且想要计算它的总和和平均值。Spark 会如何工作？

1. 创建 RDD：

• 假设数据存储在 HDFS 上，首先通过 SparkContext 将数据加载到 Spark 中。Driver Program（主控驱动程序）会根据数据大小和集群配置，将数据划分成多个分片（Partitions），这些分片一起组成一个 RDD。

• Driver 通过 SparkContext 与 Spark 集群交互，负责调度任务、管理资源和协调计算。

2. 分布式计算：

• 每个分片会被分配一个 Task（任务）。

• Task 会并行地计算每个分片的数据（例如计算每个分片的总和）。

• Cluster Manager 负责管理集群资源，根据 Driver 的请求分配计算资源，确保 Executor 在各个节点上执行任务。

3. 汇总结果：

• 每个 Executor 完成任务后，会将结果返回给 Driver。

• Driver 会将所有的结果汇总，最终得到整个数据集的总和和平均值，并返回给用户。

总结：

• Driver Program：主控程序，负责控制整个任务流程，依赖 SparkContext 进行资源请求和任务调度。

• SparkContext：与 Spark 集群交互，管理 RDD 和任务调度。

• Cluster Manager：管理集群资源，为 Executor 分配计算资源。

• Executor：执行分配的任务，处理数据的计算。

• Task：任务是对数据分片的具体操作，每个 Task 在 Executor 上执行，完成数据的处理计算。

• Worker Node：集群中的工作节点，运行 Executor，并负责执行任务的实际计算。

这张图展示了Spark中各个关键组件是如何协同工作的，下面是简单、条理的介绍：

Spark 集群的六个主要组成部分（包含 SparkContext）：

1. 集群管理器（Cluster Manager）：

• 作用: 管理整个集群的资源（如 CPU 和内存）。

• 角色: 决定任务运行在哪些工作节点上，并分配资源给工作节点。

• 常见管理器: Standalone、YARN、Mesos 等。

• 类比: “调度员”，负责协调任务资源。

2. 工作节点（Worker Node）：

• 是集群中的“工人”。

• 每个节点上有多个执行器（Executor），负责执行任务。

• 作用: 实际执行任务的节点。

• 结构: 每个工作节点运行多个任务（Task），处理分布式数据。

• 特点:

• 类比: 工厂中的“生产线”，负责完成具体的生产任务。

3. 执行器（Executor）：

• 运行任务（Task）。

• 提供存储功能（Cache）来保存中间计算结果。

• 作用: 执行具体任务并存储中间数据。

• 功能:

• 独立性: 每个执行器是独立的，一个执行器失败不会影响其他执行器。

• 类比: 工人手中的“工具”，直接完成操作任务。

4. 驱动器（Driver）：

• 分配任务给工作节点。

• 收集工作节点的计算结果。

• 作用: 是整个应用程序的主控程序，控制作业的执行。

• 功能:

• 位置: 通常运行在用户提交任务的机器上。

• 类比: “指挥官”，负责整个任务流程的指挥和协调。

5. SparkContext：

• 向集群管理器请求资源。

• 创建 RDD 并管理其血缘关系。

• 调度任务并跟踪任务的执行状态。

• 作用: 是驱动器（Driver）的核心组件，连接应用程序与集群管理器的桥梁。

• 功能:

• 类比: Driver 的“助手”，负责执行具体的调度、资源请求等底层操作。

6. 应用程序（Application）：

• 驱动器（Driver）程序。

• 在工作节点上运行的任务。

• 作用: 表示一个完整的 Spark 作业。

• 包含:

• 类比: “整个任务工程”，从规划到执行的完整流程。

简单理解：

1. Driver（指挥官）负责控制整个任务流程，依赖 SparkContext 进行资源请求和任务调度。

2. Cluster Manager（调度员）负责为任务分配资源。

3. Worker Nodes（工人）在实际节点上执行任务。

4. Executor（工具）运行具体任务，存储中间结果。

5. Application 是“从规划到执行”的整个作业。

通过这些角色的协作，Spark 高效地完成了分布式数据的计算。

工作流程举例

1. 使用Spark代码中定义了“统计关键词频率”的任务，并通过spark-submit提交到集群。

2. Driver程序启动，使用SparkContext将任务分解为多个小任务。

3. SparkContext联系Cluster Manager，申请资源来执行这些任务。

4. Cluster Manager分配资源后，多个Worker Node启动Executor进程。

5. 每个Worker Node负责处理日志文件的一部分，比如：

• Worker Node 1 处理第1到第5块日志文件。

• Worker Node 2 处理第6到第10块日志文件。

6. 每个Task在Executor中运行，处理数据并将中间结果（词频统计）存储到内存中（Cache）。

7. 最终，Driver程序汇总所有Task的结果，输出最终的关键词频率统计。

2. 安装 Spark

2.1 软件准备

下载Spark3.1.1安装文件。访问Spark官方下载地址下载。

本教程的具体运行环境如下：

• Hadoop 3.1.3 集群

• Java JDK 1.8

• Spark 3.1.1

2.2 Spark的三种部署方式

（1）Local

• 本地模式，即Spark运行在单机上，所有任务在同一台机器上完成。

• 适用于学习、开发或对小规模数据进行测试，主要用于快速验证和调试代码。

（2）Standalone

• 使用Spark自带的资源管理器搭建的独立集群模式，适用于不依赖其他资源调度工具的环境。。

• Master节点：负责资源管理和任务调度。Worker节点（Slave）：负责实际的任务执行。

（3）Yarn

• Spark运行在已有的Hadoop集群中，借助Hadoop的YARN进行资源管理和任务调度。

• YARN模式有两种运行方式：

• yarn-client：Driver程序运行在本地提交任务的机器上，适合交互式开发和调试场景。

• yarn-cluster：Driver程序运行在YARN集群中，由ApplicationMaster负责启动，适合生产环境中的批量任务。

Driver程序：它是Spark应用程序的“大脑”，负责管理和协调整个任务的执行。通常，Driver程序通常是用户编写的Spark应用程序的main方法所在的进程。

这张图展示了Spark在YARN模式下的工作流程。

图中各个部分的含义：

1. Client（客户端）：

• 这是你提交Spark任务的地方，比如你在自己电脑上编写了一个Spark程序，并通过Client提交这个任务。

2. Resource Manager（资源管理器）：

• Resource Manager是YARN的资源调度器。它负责分配整个集群中的资源，比如决定哪些任务在哪些机器上运行。

3. Node Manager（节点管理器）：

• Node Manager是在每个集群节点上运行的组件。它负责管理该节点上的资源，并与Resource Manager保持通信，报告节点的资源使用情况（如CPU、内存等）。

4. App Master（应用主程序）：

• 当你提交一个Spark任务时，Resource Manager会启动一个App Master（应用主程序）。App Master负责管理这个任务的执行，分配具体的工作到集群中的各个节点上。

5. Container（容器）：

• 容器是执行任务的环境。当Node Manager接到Resource Manager的指令后，会在容器中运行实际的任务。容器就像是一个小的工作空间，专门用来处理特定的任务。

6. Task（任务）：

   
   

• Task是Spark应用中的具体工作单元。一个任务可以是计算一个数据集的一部分，或者是处理某些数据。在图中，每个Container里面会运行一个或多个Task。

图中的工作流程：

1. 任务提交：

• 你通过Client提交一个Spark任务（Job）。这个任务会被发送给Resource Manager。

2. 资源请求：

• Resource Manager决定如何分配集群中的资源，并启动App Master。App Master是专门为这个任务而启动的，它会管理这个任务的整个执行过程。

3. 任务分配：

• App Master与Node Manager沟通，向它们请求资源。Node Manager会在自己的节点上启动容器（Container），这些容器会运行具体的任务（Task）。

4. 任务执行：

• 每个Node Manager在它管理的节点上启动容器，并在这些容器中执行具体的任务。容器中的任务会处理数据，并将结果返回给App Master。

5. 任务状态报告：

• 在任务执行过程中，Node Manager会不断向Resource Manager报告节点的状态，以及任务的执行情况。

总结：

这张图展示了在YARN模式下，Spark任务从提交到执行的整个过程。Client提交任务后，Resource Manager分配资源，启动App Master。App Master管理任务的执行，并与Node Manager配合，启动容器来执行具体的任务（Task）。最终，每个任务会在容器中执行，并由Node Manager管理和报告任务的状态。

2.3 spark安装

2.3.1 搭建Standalone模式

standalone 作为 spark 自带的分布式部署模式，是最简单也是最基本的 spark 应用程序部署模式

在Standalone模式下，Spark自己管理计算资源，不依赖其他外部的资源管理框架。这种独立性使得Standalone模式非常适合构建简单的Spark集群。

• 在Standalone模式中，Spark集群由一个Master节点和多个Worker节点组成。Master节点负责管理资源和任务调度，Worker节点负责实际执行任务。

集群规划:

2.3.2 搭建Spark on YARN模式

Spark可以直接连接到YARN，不需要在本地构建独立的Spark集群。

这是运行大规模分布式计算任务的推荐模式，特别适合已经使用Hadoop集群的场景。

核心特点

1. 简易部署

• 在YARN模式下，只需要在Hadoop集群的一个节点上安装Spark，例如master节点。

2. 客户端功能

• 安装了Spark的节点可以作为客户端，用于通过spark-submit命令提交Spark任务到YARN集群中运行。

• 客户端只负责提交任务，不参与实际的任务执行，实际计算由YARN调度到集群中的工作节点完成。

3. 无需独立Spark集群

• YARN完全接管了资源管理和任务调度，因此不需要单独搭建Spark的Standalone集群。

Spark On Yarn 本质

• 在YARN模式下，Master角色由YARN的ResourceManager担任。

• Worker角色由YARN的NodeManager担任。

• Driver角色可以运行在YARN容器中，也可以在提交任务的客户端上运行。

• Executor实际运行在YARN分配的容器内，负责执行任务。

Spark On Yarn 需要啥?

• YARN集群：需要一个已经配置好的Hadoop YARN集群，用于资源管理和调度。

• Spark客户端工具：例如spark-submit，它用于将Spark程序提交到YARN集群中。

• 被提交的Spark任务：可以是Spark自带的示例程序，如pi.py，也可以是你自己编写的Spark应用程序。

Spark on YARN 安装和配置

1. 环境准备

• 已配置好 Hadoop 3.1.3 的完全分布式集群。

• 下载好 Spark 3.1.1-bin-hadoop3.2.tgz 安装包。

2. 安装Spark

• 已安装 Spark 的用户：

  如果之前已经按照Standalone模式的步骤安装并配置了Spark，可以跳过此步，直接执行第3步：配置 spark-env.sh

• 未安装 Spark 的用户：

  在Master节点上安装 Spark（YARN模式只需在一个节点安装Spark）。

  # 解压：在Master主机上操作
  cd /opt/software/
  tar -zxvf spark-3.1.1-bin-hadoop3.2.tgz -C /opt/apps/
  
  # 改名
  cd /opt/apps
  mv spark-3.1.1-bin-hadoop3.2/ spark

3. 配置spark-env.sh

cd /opt/apps/spark/conf/
cp spark-env.sh.template spark-env.sh
vi spark-env.sh

配置以下内容

# JDK安装路径
export JAVA_HOME=/opt/apps/jdk
# 指定hadoop的配置文件位置(yarn模式需要的，确保Spark与Hadoop正确通信)
export HADOOP_CONF_DIR=/opt/apps/hadoop/etc/hadoop

注意：原先在Standalone模式配置的spark-env.sh下面的配置项可以删除，只保留了上面两项

删除的内容如下：

• SPARK_MASTER_HOST 和 SPARK_MASTER_PORT 用于指定 Spark 主节点的主机名或 IP 地址以及端口号，用于内部通信。在 YARN 模式下，Spark 主节点由 YARN 的 ResourceManager 管理，因此不需要手动设置这些参数。

• SPARK_WORKER_CORES 和 SPARK_WORKER_MEMORY 用于设置每个 Spark 工作节点可使用的 CPU 核心数和内存大小。在 YARN 模式下，资源的分配由 YARN 负责，因此不需要手动设置这些参数。

• SPARK_MASTER_WEBUI_PORT 用于指定 Spark 主节点的 Web UI 端口号。在 YARN 模式下，Spark 主节点的 Web UI 端口通常是由 YARN ResourceManager 管理的，因此无需手动设置该参数。

因此，在 Spark on YARN 模式下，这些配置项都是不需要的，可以省略。Spark 应用程序会自动与 YARN 集成，并根据 YARN 的资源调度来分配资源和管理任务

4. 配置spark环境变量

vim /etc/profile

# 添加以下内容
# spark
export SPARK_HOME=/opt/apps/spark
export PATH=$PATH:$SPARK_HOME/bin

保存并退出，使环境变量生效：

source /etc/profile

查看PATH环境变量

echo $PATH

5. 配置spark的运行模式

• 在Master、slave1、slave2三台主机上修改yarn-site.xml文件

  # 在master节点上操作
  cd /opt/apps/hadoop/etc/hadoop/
  vi yarn-site.xml

  添加以下内容（禁用资源检查，避免任务因资源超限被杀掉）

      <!-- 控制 YARN NodeManager 是否启用对任务使用的物理内存和虚拟内存的检查 -->
      <!-- 如果pmem、vmem资源不够，运行任务会报错，此处将资源检查设置为false -->
      <!-- 禁止对任务使用的物理内存的检查（否则如果任务超出分配值，则直接将任务杀掉）-->
      <property>
          <name>yarn.nodemanager.pmem-check-enabled</name>
          <value>false</value>
      </property>
      <!-- 禁止对任务使用的虚拟内存的检查（否则如果任务超出分配值，则直接将任务杀掉）-->
      <property>
          <name>yarn.nodemanager.vmem-check-enabled</name>
          <value>false</value>
      </property>

  如图：

  

• 从master分发 yarn-site.xml 到slave1/slave2

  scp /opt/apps/hadoop/etc/hadoop/yarn-site.xml slave1://opt/apps/hadoop/etc/hadoop
  scp /opt/apps/hadoop/etc/hadoop/yarn-site.xml slave2://opt/apps/hadoop/etc/hadoop

  
  

保存退出，重启Hadoop集群

到此，安装完毕

6. Spark on YARN模式的两种运行方式

• yarn-client模式：

• Driver程序运行在客户端（提交任务的机器）上，例如你的本地电脑或一个集群节点。

• 客户端负责启动Driver程序，并与YARN的ResourceManager通信，分配任务和资源。

• 适用于开发和调试，因为Driver直接在客户端运行，便于查看日志和调试。

• yarn-cluster模式：

• Driver程序运行在YARN的容器内部，通常与ApplicationMaster在同一个容器中。

• 提交任务后，客户端退出或断开连接，Driver程序和任务完全由YARN管理。

• 适用于生产环境，因为Driver运行在集群内部，可以更好地利用资源和容错能力。

Driver进程：Driver进程是Spark作业的主进程，负责启动、调度和监控作业，它包含了程序的入口点main函数，并拥有SparkContext实例，用于与集群通信。

• Client模式：Driver运行在客户端进程中，比如Driver运行在spark-submit程序的进程中，适用于交互、调试，希望立即看到app的输出。

• Cluster模式：Driver运行在YARN的容器内，由YARN管理，通常和ApplicationMaster在同一个容器中。

Client模式 vs Cluster模式的核心区别

本质区别：Driver程序运行的位置不同。

7. 执行spark自带的案例

• 启动Hadoop集群

# 在master启动
start-dfs.sh
# 在slave1启动
start-yarn.sh

• 修改spark设置日志级别

# 编辑$Spark_HOME/conf下的log4j.properties文件，将日志级别设置为ERROR，减少冗余日志输出
# 如果没有此文件，复制临时文件生成
vi /opt/apps/spark/conf/log4j.properties

log4j.rootCategory=ERROR, console
......

3. 实验

实验1

实验任务：运行的是 Spark 的官方示例程序 SparkPi ,用来计算圆周率 π。

client模式运行

1. Driver运行在Client上的Spark-Submit进程中

2. 应用程序运行结果会在客户端显示

   # 在mastera节点运行，通过 spark-submit 提交一个任务到 Spark on YARN 集群中运行
   # 运行的是 Spark 的官方示例程序 SparkPi ,用来计算圆周率 π。
   spark-submit \
   --class org.apache.spark.examples.SparkPi \
   --master yarn \
   --deploy-mode client \
   /opt/apps/spark/examples/jars/spark-examples_2.12-3.1.1.jar \
   10

解释

• spark-submit:  Spark 提供的命令行工具，用于提交 Spark 应用程序到集群中运行。

• --class 指定了应用程序的主类。

• --master 指定了集群管理器为yarn,表示任务会运行在一个已有的 Hadoop YARN 集群中。

• --deploy-mode 指定 Driver 程序运行的位置。client模式Spark驱动程序将在提交应用程序的机器上运行，                                                             通常是用户的本地机器。

• JAR 包是 Spark 官方提供的 spark-examples 包，内含多个示例程序（如 SparkPi）。

• 10：表示使用 10 个分片（Partitions）来计算 π 值。一个分片对应一个任务,10 个分片意味着会有 10 个任务并行运行，每个任务负责生成和计算自己的一部分数据。

简化屏幕上日志输出的内容方法：

# 方法一
# 在执行时会输出非常多的运行信息，输出结果不容易找到，可以通过 grep 命令进行过滤
spark-submit \
--class org.apache.spark.examples.SparkPi \
--master yarn \
--deploy-mode client \
/opt/apps/spark/examples/jars/spark-examples_2.12-3.1.1.jar \
10 \
2>&1 | grep "Pi is"

解释：

• 2是标准错误的输出，1是标准输出。 2>&1表示将标准错误输出（stderr）重定向到标准输出（stdout）；通常，程序的输出会分别发送到标准输出和标准错误，但是通过这个操作，标准错误也会被发送到与标准输出相同的位置。

• |管道符：将一个命令的输出作为另外一个命令的输入

• grep 过滤和查找文件里符合条件的字符串

cluster模式运行

1. Driver 程序会在 YARN 集群中启动，并由 YARN 管理，客户端机器只是用于提交应用程序，并不直接参与应用程序的执行。

2. Driver 程序在集群中运行，应用程序的运行结果也将在集群中生成。在客户端机器上，你只能看到应用程序的提交信息和 YARN 的应用程序 ID，应用程序的运行结果可以通过 YARN 的 Web UI 或日志文件查看。

   spark-submit \
   --class org.apache.spark.examples.SparkPi \
   --master yarn \
   --deploy-mode cluster \
    /opt/apps/spark/examples/jars/spark-examples_2.12-3.1.1.jar \
   10

   spark-submit \
     --class org.apache.spark.examples.SparkPi \
     --master yarn \
     --deploy-mode cluster \
     --num-executors 3 \
     --executor-memory 4g \
     --executor-cores 2 \
     --driver-memory 2g \
     /opt/apps/spark/examples/jars/spark-examples_2.12-3.1.1.jar

   
   

查看运行结果

http: //slave1:8088/proxy/application_1673791169680_0003/

• http://slave1:8088: 这是 YARN ResourceManager 的 Web UI 地址，提供对 YARN 集群的监控和管理功能。Spark 作业作为 YARN 应用的一部分，运行在 YARN 集群上，因此所有提交到 YARN 的 Spark 任务都会在这个页面中显示。

• /proxy/application_1673791169680_0003/: 这个链接指向的是该 Spark 应用程序的详细页面，用户可以通过这个链接查看 Spark 任务的执行状态、日志、资源使用等信息

实验2

实验任务：通过 Spark 提交官方示例 JavaWordCount 应用程序，统计 HDFS 文件中每个单词的出现次数。

实验步骤

1. 准备输入文件

在 HDFS 上创建输入文件：

# 创建 HDFS 目录 /spark/wordcount，如果目录不存在则创建
hdfs dfs -mkdir -p /spark/wordcount

# 创建一个名为 input.txt 的文本文件，内容为三行文本
# -e 选项允许解释转义字符（例如换行符 \n）。
echo -e "Spark is fast\nSpark is great\nHadoop and Spark" > input.txt

# 将 input.txt 文件上传到 HDFS 的 /spark/wordcount 目录
hdfs dfs -put input.txt /spark/wordcount

文件内容：

Spark is fast
Spark is great
Hadoop and Spark

2. 使用 client 模式提交

使用 spark-submit 提交一个基于 YARN 管理的 Spark 作业，运行一个 WordCount 程序。该程序会从 HDFS 上指定的路径 (hdfs://master:9000/spark/wordcount) 读取输入数据，计算每个单词出现的频率，并在 YARN 集群上执行。驱动程序在提交作业的客户端机器上运行，计算任务会分配到集群的不同执行器中。

在 master 节点 上运行以下命令：

spark-submit \
--class org.apache.spark.examples.JavaWordCount \
--master yarn \
--deploy-mode client \
/opt/apps/spark/examples/jars/spark-examples_2.12-3.1.1.jar \
hdfs://master:9000/spark/wordcount

参数说明：

• spark-submit : 使用 spark-submit 提交一个 Spark 应用程序到集群

• --class org.apache.spark.examples.JavaWordCount : 指定 Spark 应用程序的主类，即包含 main 方法的类，这里是 JavaWordCount 示例程序

• --master yarn : 指定集群管理模式，这里使用 YARN 集群管理器

• --deploy-mode client : 指定应用程序的部署模式，client 模式表示驱动程序在客户端机器上运行

• /opt/apps/spark/examples/jars/spark-examples_2.12-3.1.1.jar : 指定包含 Spark 示例程序的 JAR 文件路径

• hdfs://master:9000/spark/wordcount : 指定输入数据的路径，这里是 HDFS 中的路径

运行结果：

3. 使用 cluster 模式提交

在 master 节点 上运行以下命令：

spark-submit \
--class org.apache.spark.examples.JavaWordCount \
--master yarn \
--deploy-mode cluster \
/opt/apps/spark/examples/jars/spark-examples_2.12-3.1.1.jar \
hdfs://master:9000/spark/wordcount

参数说明：

• --deploy-mode cluster：Driver 程序运行在 YARN 集群内部的容器中，客户端不参与任务执行。

2.4 Cluster 模式查看结果

查看任务日志： 在 cluster 模式下，结果不会直接输出到客户端终端。需要通过 YARN 日志查看：

两种模式对比