Spark-----第 2 章 Spark 部署模式

Spark 支持多种集群管理器（Cluster Manager），分别为：

1. Standalone：独立模式，Spark 原生的简单集群管理器，自带完整的服务，可单独部署到
   一个集群中，无需依赖任何其他资源管理系统，使用 Standalone 可以很方便地搭建一个
   集群；
2. Hadoop YARN：统一的资源管理机制，在上面可以运行多套计算框架，如 MR、Storm
   等。根据 Driver 在集群中的位置不同，分为 yarn client（集群外）和 yarn cluster（集群
   内部）
3. Apache Mesos：一个强大的分布式资源管理框架，它允许多种不同的框架部署在其上，
   包括 Yarn。
4. K8S : 容器式部署环境。
   实际上，除了上述这些通用的集群管理器外，Spark 内部也提供了方便用户测试和学习
   的本地集群部署模式和 Windows 环境。由于在实际工厂环境下使用的绝大多数的集群管理
   器是 Hadoop YARN，因此我们关注的重点是 Hadoop YARN 模式下的 Spark 集群部署。

Spark支持多种集群管理器，用于管理和调度Spark应用程序在分布式计算集群上的运行。以下是几个常用的Spark集群管理器：

1. Apache Mesos：Mesos是一个通用的集群管理器，可以用于管理多种不同的计算框架，包括Spark。它提供了资源调度和任务管理的功能，并允许在共享资源的集群上同时运行多个应用程序。

2. Apache Hadoop YARN：YARN是Hadoop生态系统的核心组件之一，它提供了资源管理和作业调度的功能。Spark可以作为一个YARN应用程序在YARN集群上运行，从而与Hadoop生态系统的其他工具无缝集成。

3. Standalone模式：Spark还提供了一种独立的集群管理模式，称为Standalone模式。在Standalone模式下，Spark自身可以作为集群管理器，负责资源分配和任务调度。这种模式适用于较小规模的集群或单机测试环境。

4. Kubernetes：Kubernetes是一个开源的容器编排平台，可以用于管理和调度容器化的应用程序。Spark可以通过Kubernetes运行在Kubernetes集群上，从而实现资源的弹性分配和任务的自动调度。

这些集群管理器各有优势和适用场景，选择合适的集群管理器取决于具体的需求和环境。需要根据集群规模、资源管理方式、与其他工具的集成等因素进行评估和选择。同时，Spark也提供了灵活的配置选项，可以根据需要进行自定义和调整。

2.1 YARN 模式运行机制

2.1.1 YARN Cluster 模式

1. 执行脚本提交任务，实际是启动一个 SparkSubmit 的 JVM 进程；
2. SparkSubmit 类中的 main 方法反射调用 YarnClusterApplication 的 main 方法；
3. YarnClusterApplication 创建 Yarn 客户端，然后向 Yarn 服务器发送执行指令：bin/java
   ApplicationMaster；
4. Yarn 框架收到指令后会在指定的 NM 中启动 ApplicationMaster；
5. ApplicationMaster 启动 Driver 线程，执行用户的作业；
6. AM 向 RM 注册，申请资源；
7. 获取资源后 AM 向 NM 发送指令：bin/java YarnCoarseGrainedExecutorBackend；
8. CoarseGrainedExecutorBackend 进程会接收消息，跟 Driver 通信，注册已经启动的
   Executor；然后启动计算对象 Executor 等待接收任务
9. Driver 线程继续执行完成作业的调度和任务的执行。
10. Driver 分配任务并监控任务的执行。

注意：SparkSubmit、ApplicationMaster 和 CoarseGrainedExecutorBackend 是独立的进程；Driver是独立的线程；Executor 和 YarnClusterApplication 是对象。

1.SparkSubmit

spark-submit是Apache Spark提供的命令行工具，用于提交和运行Spark应用程序。它可以将Spark应用程序打包成一个可执行的JAR文件或Python脚本，并将其提交到Spark集群进行执行。

以下是spark-submit的一般用法：

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

其中，[options]表示一些可选的命令行选项，用于配置和调整Spark应用程序的运行参数。一些常用的选项包括：

• --class <class>：指定主类名，用于Java/Scala应用程序。
• --master <master-url>：指定Spark集群的Master URL，例如spark://host:port。
• --deploy-mode <mode>：指定应用程序的部署模式，可以是client或cluster。
• --executor-memory <mem>：指定每个Executor的内存分配。
• --num-executors <n>：指定要启动的Executor的数量。
• --conf <key>=<value>：通过配置键值对设置其他Spark配置属性。

<app jar | python file>表示要提交的Spark应用程序，可以是一个打包好的可执行JAR文件（对于Java/Scala应用程序），或者是一个Python脚本文件。

[app arguments]表示应用程序的命令行参数，可以在应用程序中访问这些参数。

使用spark-submit命令，可以将应用程序提交到Spark集群进行执行。Spark会根据配置的选项和参数进行应用程序的启动和执行，并将计算任务分发给集群中的Executor进行处理。

注意，具体的spark-submit命令的用法和选项可能因Spark的版本和配置而有所不同，请参考相应版本的官方文档或命令行帮助信息以获取准确的用法说明。

2.ApplicationMaster

ApplicationMaster（应用程序管理器）是Apache Hadoop YARN框架中的一个关键组件，用于管理和协调运行在YARN集群上的应用程序。它负责分配资源、监控任务执行、容错和错误恢复等任务。

在YARN中，每个运行的应用程序都由一个ApplicationMaster实例来管理。当应用程序被提交到YARN集群时，YARN会为该应用程序启动一个ApplicationMaster。ApplicationMaster运行在分配给该应用程序的一个容器（Container）中，并与YARN资源管理器（ResourceManager）通信。

ApplicationMaster的主要职责包括：

1. 资源调度和分配：ApplicationMaster与ResourceManager进行通信，请求分配所需的资源（如内存、CPU等）。它协调和管理应用程序所需的资源，并确保每个任务或容器在运行时获得足够的资源。

2. 任务执行和监控：ApplicationMaster负责启动应用程序的任务或容器，并监控其执行情况。它与每个任务或容器保持通信，收集任务的状态和进度信息，以及处理任务的失败和重试。

3. 容错和错误恢复：ApplicationMaster负责处理应用程序的容错和错误恢复。它会监控任务的执行情况，当某个任务失败或容器出现故障时，ApplicationMaster会通知ResourceManager，并请求重新启动任务或分配新的容器来替代失败的任务。

4. 应用程序完成和资源释放：当应用程序的所有任务或容器完成时，ApplicationMaster会通知ResourceManager应用程序已经完成，并释放所占用的资源。这样，ResourceManager可以重新分配这些资源给其他应用程序使用。

通过ApplicationMaster的管理和协调，YARN可以高效地运行多个并发的应用程序，实现了资源的共享和多任务的调度。它为运行在YARN上的各种应用程序提供了统一的资源管理和调度平台，包括Apache Spark、Apache Hadoop MapReduce等。

3.CoarseGrainedExecutorBackend

CoarseGrainedExecutorBackend（粗粒度执行器后端）是Apache Spark中的一个组件，用于在Spark集群中扮演执行器角色。它负责接收和执行由Spark驱动程序分配给它的任务，并将执行结果返回给驱动程序。

在Spark集群中，Spark应用程序的驱动程序负责将任务划分为不同的分区，并将这些任务分配给执行器进行并行执行。CoarseGrainedExecutorBackend是在执行器节点上运行的组件，它接收来自驱动程序的任务，并在本地执行这些任务。

CoarseGrainedExecutorBackend的主要功能包括：

1. 任务执行：CoarseGrainedExecutorBackend接收来自驱动程序的任务，并在本地执行这些任务。它通过与驱动程序的通信，接收任务的描述信息，包括任务的代码、输入数据和执行参数。然后，它会在本地执行这些任务，并将结果返回给驱动程序。

2. 资源管理：CoarseGrainedExecutorBackend管理本地资源的分配和使用情况。它会向资源管理器（如Apache Mesos或Apache Hadoop YARN）注册并请求分配所需的计算资源（如CPU核心和内存）。在任务执行期间，它会监控资源的使用情况，并与资源管理器通信，确保任务的资源需求得到满足。

3. 任务状态和心跳：CoarseGrainedExecutorBackend与驱动程序保持心跳和状态更新的通信。它会定期向驱动程序发送心跳信号，以确认自己的存活状态，并报告任务的执行进度和状态更新。这样，驱动程序可以实时了解到执行器的状态，并做出相应的调度和决策。

通过CoarseGrainedExecutorBackend，Spark应用程序可以在集群中高效地执行并行任务，利用集群中的计算资源来处理大规模的数据处理和分析任务。它提供了任务执行、资源管理和与驱动程序的通信功能，以支持Spark应用程序的并行计算。

4.Driver

在Apache Spark中，“Driver”（驱动程序）是Spark应用程序的主要组件，它负责整个应用程序的控制和协调。

驱动程序是运行Spark应用程序的入口点，它通常是一个运行在客户端机器上的进程，负责与Spark集群进行通信，并指导集群中的执行器执行任务。

驱动程序的主要功能包括：

1. 任务划分和调度：驱动程序将应用程序的任务划分为不同的分区，并将这些任务分配给集群中的执行器进行并行执行。它根据应用程序的逻辑和需求，确定任务之间的依赖关系和执行顺序，以最大程度地利用集群资源和实现任务的并行计算。

2. 数据分发和分片：驱动程序负责将应用程序所需的数据分发到集群中的各个执行器。它根据数据分区的策略，将数据切片成多个部分，并将这些数据分片分发给执行器。这样，执行器在执行任务时就可以直接使用本地的数据分片，避免数据的网络传输和复制。

3. 状态管理和结果收集：驱动程序负责管理应用程序的状态和结果。它跟踪任务的执行进度、记录任务的状态和错误信息，并收集和聚合任务执行的结果。一旦任务完成，驱动程序将收集到的结果进行汇总和处理，并将最终的计算结果返回给应用程序或输出到外部存储系统。

4. 故障恢复和容错：驱动程序负责监控集群中的执行器和任务的执行情况，并处理执行过程中的错误和故障。它可以通过重新分配任务、重试失败的任务，或者从失败的任务中恢复数据，来实现应用程序的容错和故障恢复能力。

驱动程序是Spark应用程序的核心部分，它决定了应用程序的逻辑流程、任务的执行方式和资源的分配。通过驱动程序的协调和控制，Spark应用程序能够高效地利用集群资源，实现大规模数据处理和分析的并行计算。

5.Executor

在Apache Spark中，“Executor”（执行器）是运行在Spark集群中的工作节点上的进程，负责执行Spark应用程序中的任务。每个Executor都是独立运行的，它们接收来自驱动程序的任务，并在本地执行这些任务。

Executor的主要功能包括：

1. 任务执行：Executor接收来自驱动程序的任务，并在本地执行这些任务。它会加载任务所需的代码、数据和依赖项，并根据任务的逻辑进行计算和处理。每个Executor会执行分配给它的任务，并将结果返回给驱动程序或其他需要的组件。

2. 资源管理：Executor负责管理本地的计算资源，包括CPU、内存和磁盘等。它根据Spark应用程序的要求，将可用的资源分配给执行的任务，并监控资源的使用情况。在任务执行期间，Executor会根据任务的需求和资源的可用性，动态调整资源的分配和利用。

3. 任务状态和心跳：Executor与驱动程序保持心跳和状态更新的通信。它会定期向驱动程序发送心跳信号，以确认自己的存活状态，并报告任务的执行进度和状态更新。这样，驱动程序可以实时了解到Executor的状态，并做出相应的调度和决策。

4. 容错和错误恢复：Executor负责处理任务执行中的错误和故障。它会监控任务的执行情况，当任务失败或出现错误时，Executor会通知驱动程序，并请求重新执行任务或分配新的任务。通过容错机制，Executor能够保证Spark应用程序的健壮性和可靠性。

Spark应用程序通常会在集群中启动多个Executor，每个Executor运行在一个独立的工作节点上。通过并行执行任务，并将数据加载到内存中进行计算，Spark能够高效地利用集群资源，实现大规模数据处理和分析的并行计算。

6.YarnClusterApplication

在Apache Spark中，"YarnClusterApplication"是一种Spark应用程序运行模式，用于将Spark应用程序提交到基于Apache Hadoop YARN的集群上运行。

YARN（Yet Another Resource Negotiator）是Hadoop生态系统的一个核心组件，用于资源管理和作业调度。通过YARN，Spark应用程序可以与其他Hadoop工具（如Hadoop MapReduce）共享集群资源，并利用YARN的资源管理和调度功能来运行和管理Spark任务。

在YarnClusterApplication模式下，Spark应用程序的驱动程序运行在集群中的一个YARN容器中，负责与YARN资源管理器（ResourceManager）通信，并协调和管理应用程序的执行。

以下是使用YarnClusterApplication模式提交Spark应用程序的一般步骤：

1. 配置应用程序：创建一个Spark应用程序，并根据需要进行相应的配置，例如指定要使用的资源（内存、CPU等）、设置Spark属性等。

2. 打包应用程序：将Spark应用程序打包成一个可执行的JAR文件，或者是一个Python脚本文件，以便在集群上运行。

3. 提交应用程序：使用spark-submit命令，并指定--master yarn参数，将应用程序提交到YARN集群。例如：

   spark-submit --class com.example.MyApp --master yarn myapp.jar
   

4. YARN资源管理：YARN ResourceManager会分配资源给Spark应用程序，并启动相应数量的执行器（Executors）。每个执行器会在集群中的一个YARN容器中运行，并负责执行任务。

5. 任务执行和结果收集：驱动程序与执行器进行通信，将任务分配给执行器执行，并收集任务的结果。驱动程序还会处理任务的错误和故障，并根据需要重新分配任务或容器。

使用YarnClusterApplication模式，Spark应用程序可以充分利用YARN的资源管理和调度功能，实现任务的并行执行、容错和资源优化。它为Spark应用程序提供了一种在YARN集群上高效运行的方式，并与Hadoop生态系统的其他工具进行无缝集成。

2.1.2 YARN Client 模式

1. 执行脚本提交任务，实际是启动一个 SparkSubmit 的 JVM 进程；
2. SparkSubmit 类中的 main 方法反射调用用户代码的 main 方法；
3. 启动 Driver 线程，执行用户的作业，并创建 ScheduleBackend；
4. YarnClientSchedulerBackend 向 RM 发送指令：bin/java ExecutorLauncher；
5. Yarn 框架收到指令后会在指定的 NM 中启动 ExecutorLauncher（实际上还是调用
   ApplicationMaster 的 main 方法）；

object ExecutorLauncher {
  def main(args: Array[String]): Unit = {
 		ApplicationMaster.main(args)
  	}
}

6. AM 向 RM 注册，申请资源；
7. 获取资源后 AM 向 NM 发送指令：bin/java CoarseGrainedExecutorBackend；
8. CoarseGrainedExecutorBackend 进程会接收消息，跟 Driver 通信，注册已经启动的
   Executor；然后启动计算对象 Executor 等待接收任务
9. Driver 分配任务并监控任务的执行。

注意：SparkSubmit、ApplicationMaster 和 YarnCoarseGrainedExecutorBackend 是独立的进程；Executor 和 Driver 是对象。

2.2 Standalone 模式运行机制

Standalone模式是Apache Spark中一种简单的集群部署模式，它允许在独立的Spark集群上运行应用程序。在Standalone模式下，Spark应用程序不依赖于其他集群管理器，而是由Spark自身的内置组件来管理和调度任务。

下面是Standalone模式的运行机制：

1. 配置和启动Master节点：在Standalone模式下，需要先配置和启动一个Master节点，它负责整个集群的管理和协调。可以通过sbin/start-master.sh脚本启动Master节点，并设置相应的配置参数，如Master的IP地址、端口等。

2. 启动Worker节点：在集群中的每个节点上，需要启动一个Worker节点，它是执行实际任务的工作进程。可以通过sbin/start-worker.sh脚本启动Worker节点，并指定Master节点的地址。Worker节点会向Master节点注册自己，并接收Master节点分配的任务。

3. 提交应用程序：在Standalone模式下，可以使用spark-submit命令提交应用程序。在命令中指定--master spark://<master-ip>:<master-port>参数，将应用程序连接到Standalone集群的Master节点。

4. Master节点分配任务：一旦应用程序连接到Master节点，Master节点会接收应用程序的任务，并根据可用的Worker节点和资源情况，将任务分配给空闲的Worker节点。Master节点负责任务的调度和分配，以实现任务的并行执行。

5. Worker节点执行任务：Worker节点接收Master节点分配的任务，并在本地执行这些任务。每个Worker节点都会启动一个Executor进程，用于执行任务。Executor会加载任务所需的代码和数据，并根据任务的逻辑进行计算和处理。

6. 任务执行和结果收集：Worker节点上的Executor执行任务，并将任务的结果返回给Driver节点（即应用程序的主节点）。Driver节点负责任务的状态跟踪、结果收集和最终的计算结果处理。

7. 故障恢复和容错：Standalone模式下的Spark集群具有一定的容错能力。当Worker节点或Executor发生故障或失败时，Master节点会重新分配任务，并将任务重新分配给其他可用的Worker节点。

通过Standalone模式，可以轻松地部署和管理Spark集群，无需依赖其他集群管理器。它适用于较小规模的集群或在本地开发和测试环境中使用。然而，对于大规模集群或生产环境中的部署，建议使用更强大的集群管理器，如Apache Mesos或Apache Hadoop YARN。

Standalone 集群有 2 个重要组成部分，分别是： 1) Master(RM)：是一个进程，主要负责资源的调度和分配，并进行集群的监控等职责； 2) Worker(NM)：是一个进程，一个 Worker 运行在集群中的一台服务器上，主要负责两个 职责，一个是用自己的内存存储 RDD 的某个或某些 partition；另一个是启动其他进程 和线程（Executor），对 RDD 上的 partition 进行并行的处理和计算。

2.2.1 Standalone Cluster 模式

Standalone Cluster模式是Apache Spark中一种集群部署模式，用于在独立的Spark集群上运行应用程序。在Standalone Cluster模式下，Spark应用程序依赖于Spark的内置集群管理器来协调和管理任务的执行。

以下是Standalone Cluster模式的运行机制：

1. 配置和启动Master节点：在Standalone Cluster模式下，需要先配置和启动一个Master节点，它负责整个集群的管理和协调。可以通过sbin/start-master.sh脚本启动Master节点，并设置相应的配置参数，如Master的IP地址、端口等。

2. 配置和启动Worker节点：在集群中的每个节点上，需要配置和启动一个Worker节点，它是执行实际任务的工作进程。可以通过sbin/start-worker.sh脚本启动Worker节点，并指定Master节点的地址。Worker节点会向Master节点注册自己，并接收Master节点分配的任务。

3. 提交应用程序：在Standalone Cluster模式下，可以使用spark-submit命令提交应用程序。在命令中指定--master spark://<master-ip>:<master-port>参数，将应用程序连接到Standalone集群的Master节点。

4. Master节点分配任务：一旦应用程序连接到Master节点，Master节点会接收应用程序的任务，并根据可用的Worker节点和资源情况，将任务分配给空闲的Worker节点。Master节点负责任务的调度和分配，以实现任务的并行执行。

5. Worker节点执行任务：Worker节点接收Master节点分配的任务，并在本地执行这些任务。每个Worker节点都会启动一个Executor进程，用于执行任务。Executor会加载任务所需的代码和数据，并根据任务的逻辑进行计算和处理。

6. 任务执行和结果收集：Worker节点上的Executor执行任务，并将任务的结果返回给Driver节点（即应用程序的主节点）。Driver节点负责任务的状态跟踪、结果收集和最终的计算结果处理。

7. 故障恢复和容错：Standalone Cluster模式下的Spark集群具有一定的容错能力。当Worker节点或Executor发生故障或失败时，Master节点会重新分配任务，并将任务重新分配给其他可用的Worker节点。

Standalone Cluster模式相对简单，并适用于小规模的Spark集群或本地开发和测试环境。然而，对于大规模集群或生产环境中的部署，建议使用更强大的集群管理器，如Apache Mesos或Apache Hadoop YARN，以提供更高的可靠性、容错性和资源管理功能。

在 Standalone Cluster 模式下，任务提交后，Master 会找到一个 Worker 启动 Driver。
Driver 启动后向 Master 注册应用程序，Master 根据 submit 脚本的资源需求找到内部资源至
少可以启动一个 Executor 的所有 Worker，然后在这些 Worker 之间分配 Executor，Worker 上
的 Executor 启动后会向 Driver 反向注册，所有的 Executor 注册完成后，Driver 开始执行 main
函数，之后执行到 Action 算子时，开始划分 Stage，每个 Stage 生成对应的 taskSet，之后将Task 分发到各个 Executor 上执行。

2.2.2 Standalone Client 模式

Standalone Client模式是Apache Spark中一种集群部署模式，用于在独立的Spark集群上运行应用程序。在Standalone Client模式下，Spark应用程序的驱动程序运行在客户端机器上，而任务的执行发生在集群中的Worker节点上。

以下是Standalone Client模式的运行机制：

1. 配置和启动Master节点：在Standalone Cluster模式下，需要先配置和启动一个Master节点，它负责整个集群的管理和协调。可以通过sbin/start-master.sh脚本启动Master节点，并设置相应的配置参数，如Master的IP地址、端口等。

2. 配置和启动Worker节点：在集群中的每个节点上，需要配置和启动一个Worker节点，它是执行实际任务的工作进程。可以通过sbin/start-worker.sh脚本启动Worker节点，并指定Master节点的地址。Worker节点会向Master节点注册自己，并接收Master节点分配的任务。

3. 提交应用程序：在Standalone Client模式下，可以使用spark-submit命令提交应用程序。在命令中指定--master spark://<master-ip>:<master-port>参数，并加上--deploy-mode client参数，以将应用程序连接到Standalone集群的Master节点，并在客户端运行驱动程序。

4. 驱动程序执行：驱动程序运行在客户端机器上，它负责与Master节点通信，并协调应用程序的执行。驱动程序会将任务发送给Master节点，并将任务分发给集群中的Worker节点进行执行。

5. Worker节点执行任务：Worker节点接收Master节点分配的任务，并在本地执行这些任务。每个Worker节点都会启动一个Executor进程，用于执行任务。Executor会加载任务所需的代码和数据，并根据任务的逻辑进行计算和处理。

6. 任务执行和结果收集：Worker节点上的Executor执行任务，并将任务的结果返回给驱动程序。驱动程序负责任务的状态跟踪、结果收集和最终的计算结果处理。

7. 故障恢复和容错：Standalone Cluster模式下的Spark集群具有一定的容错能力。当Worker节点或Executor发生故障或失败时，Master节点会重新分配任务，并将任务重新分配给其他可用的Worker节点。

Standalone Client模式允许驱动程序在客户端机器上执行，这样可以方便地与应用程序进行交互和调试。然而，它也意味着驱动程序的运行受限于客户端机器的资源和性能。对于大规模集群或需要更高的可靠性和容错性的情况，可以考虑使用其他集群管理器，如Apache Mesos或Apache Hadoop YARN。

在 Standalone Client 模式下，Driver 在任务提交的本地机器上运行。 Driver 启动后向Master 注册应用程序，Master 根据 submit 脚本的资源需求找到内部资源至少可以启动一个Executor 的所有 Worker，然后在这些 Worker 之间分配 Executor，Worker 上的 Executor 启动后会向 Driver 反向注册，所有的 Executor 注册完成后，Driver 开始执行 main 函数，之后执行到 Action 算子时，开始划分 Stage，每个 Stage 生成对应的 TaskSet，之后将 Task 分发到各个 Executor 上执行。