SparkCore 之 Spark 运行模式系统讲解

摘要：从 Local 本地调试到 YARN 生产集群、Kubernetes 云原生部署，系统讲解 Spark 五大运行模式的架构原理、配置方法、适用场景和模式选型决策树。配有 4 张原创架构图、各模式 spark-submit 命令模板、client vs cluster 深度对比。面向 Java、大数据及 AI 开发工程师。

一、Spark 运行模式全景架构

Spark 支持五种运行模式，从单机调试到万节点集群，覆盖了所有部署场景：

二、Local 模式 — 本地开发调试

Local 模式是开发阶段最常用的模式，所有组件运行在同一个 JVM 中，无需任何集群。

2.1 三种 Local 模式

2.2 代码中设置

// 方式1：代码中硬编码（仅开发用）
val conf = new SparkConf().setMaster("local[4]")

// 方式2：spark-submit 命令行（推荐）
// spark-submit --master local[4] ...

2.3 IDEA 调试配置

Run → Edit Configurations → Application
Main class:    com.example.MySparkJob
VM options:    -Dspark.master=local[4] -Xms512m -Xmx2048m

💡 Local 模式下可以直接在 Transformation 闭包内部打断点，因为 Driver 和 Executor 在同一 JVM。这是 Spark 开发效率远超 MR 的核心原因之一。

三、Standalone 模式 — 独立集群

Standalone 是 Spark 自带的集群管理器，无需依赖 Hadoop/YARN，适合中小团队独立部署。

3.1 架构

• Master：资源管理主节点，负责 Worker 注册、资源分配（类似 YARN 的 ResourceManager）
• Worker：工作节点，运行 Executor 进程（每个 Worker 可启动多个 Executor）
• Driver：客户端提交时指定 client/cluster 模式决定运行位置

3.2 启动集群

# 1. 启动 Master（在 master-node 上）
$SPARK_HOME/sbin/start-master.sh
# Master 默认监听 spark://master-node:7077
# Web UI 默认监听 http://master-node:8080

# 2. 启动 Worker（在每个 worker 节点上）
$SPARK_HOME/sbin/start-worker.sh spark://master-node:7077

# 3. 提交作业
spark-submit \
  --master spark://master-node:7077 \
  --deploy-mode cluster \
  --executor-memory 2G \
  --total-executor-cores 4 \
  my-app.jar

3.3 Master 高可用（ZooKeeper）

# spark-env.sh
export SPARK_DAEMON_JAVA_OPTS="
  -Dspark.deploy.recoveryMode=ZOOKEEPER
  -Dspark.deploy.zookeeper.url=zk1:2181,zk2:2181,zk3:2181
  -Dspark.deploy.zookeeper.dir=/spark-ha"

⚠️ Standalone 模式下--deploy-mode cluster时，Driver 运行在某个 Worker 上，该 Worker 宕机会导致 Driver 丢失。建议配置 supervise 模式自动重启。

3.4 关键配置

# spark-defaults.conf
spark.master                     spark://master-node:7077
spark.worker.cores               4          # 每个 Worker 的 CPU 核心数
spark.worker.memory              8g         # 每个 Worker 的内存总量
spark.executor.memory             2g        # 每个 Executor 的内存
spark.cores.max                   16         # 整个应用最大使用核心数
spark.deploy.spreadOut            true       # 尽量分散 Executor 到不同 Worker

四、YARN 模式 — 生产环境首选

YARN 是 Hadoop 生态的标准资源管理器，Spark on YARN 是目前最广泛使用的生产部署方式。

4.1 YARN 架构

4.2 client 模式 vs cluster 模式

这是 YARN 模式中最关键的决策——Driver 进程放在哪里：

4.3 spark-submit 命令模板

# === client 模式（调试/交互用） ===
spark-submit \
  --master yarn \
  --deploy-mode client \
  --executor-memory 4G \
  --executor-cores 2 \
  --num-executors 10 \
  --driver-memory 2G \
  --conf spark.dynamicAllocation.enabled=true \
  --conf spark.sql.shuffle.partitions=200 \
  --class com.example.MyApp \
  my-app.jar

# === cluster 模式（生产用） ===
spark-submit \
  --master yarn \
  --deploy-mode cluster \
  --name "Daily-ETL-Job" \
  --queue production \
  --executor-memory 4G \
  --executor-cores 2 \
  --num-executors 10 \
  --driver-memory 2G \
  --driver-cores 1 \
  --conf spark.dynamicAllocation.enabled=true \
  --conf spark.dynamicAllocation.minExecutors=5 \
  --conf spark.dynamicAllocation.maxExecutors=50 \
  --conf spark.serializer=org.apache.spark.serializer.KryoSerializer \
  --conf spark.eventLog.enabled=true \
  --jars mysql-connector-java.jar \
  --files log4j.properties \
  --class com.example.ETLJob \
  my-app.jar arg1 arg2

4.4 动态资源分配

# spark-defaults.conf（YARN 模式必开）
spark.dynamicAllocation.enabled           true
spark.dynamicAllocation.minExecutors      2      # 最小空闲 Executor
spark.dynamicAllocation.maxExecutors      100    # 最大 Executor 数
spark.dynamicAllocation.initialExecutors  5      # 初始数量
spark.dynamicAllocation.executorIdleTimeout  60s  # 空闲回收时间
spark.shuffle.service.enabled             true   # 必须开启 ExternalShuffleService

⚠️ 动态资源分配的前提：在所有 NodeManager 节点上启动 ExternalShuffleService（$SPARK_HOME/sbin/start-shuffle-service.sh），否则 Executor 回收时 Shuffle 数据会丢失。

五、Kubernetes 模式 — 云原生方向

5.1 K8s 架构

• Driver Pod：提交时创建，运行 SparkContext，负责 DAG 调度
• Executor Pod：由 Driver 动态创建，运行 Task
• 不需要：YARN RM/NM 或 Standalone Master/Worker

5.2 spark-submit on K8s

# 创建 ServiceAccount（一次性）
kubectl create serviceaccount spark
kubectl create clusterrolebinding spark-role \
  --clusterrole=edit --serviceaccount=default:spark

# 提交作业
spark-submit \
  --master k8s://https://k8s-api-server:6443 \
  --deploy-mode cluster \
  --name spark-pi \
  --class org.apache.spark.examples.SparkPi \
  --conf spark.kubernetes.authenticate.driver.serviceAccountName=spark \
  --conf spark.kubernetes.container.image=apache/spark:3.3.0 \
  --conf spark.kubernetes.namespace=spark-jobs \
  --conf spark.executor.instances=5 \
  --conf spark.executor.memory=2G \
  --conf spark.kubernetes.executor.request.cores=1 \
  local:///opt/spark/examples/jars/spark-examples_2.12-3.3.0.jar 1000

5.3 关键 K8s 配置

# Kubernetes 特有配置
spark.kubernetes.container.image                       apache/spark:3.3.0
spark.kubernetes.namespace                              spark-jobs
spark.kubernetes.authenticate.driver.serviceAccountName spark
spark.kubernetes.driver.pod.name                       spark-driver
spark.kubernetes.executor.deleteOnTermination           true
spark.kubernetes.driver.limit.cores                     2
spark.kubernetes.executor.limit.cores                   2
spark.kubernetes.file.upload.path                       hdfs:///spark-upload

💡 K8s 模式下，建议使用 Spark Operator（Google 开源）管理 Spark 作业生命周期，支持定时调度、重试、监控集成。

六、Mesos 模式（简要）

Mesos 是 Apache 的通用资源调度器，曾是 Spark 早期的重要运行平台。架构分为粗粒度（Coarse-Grained）和细粒度（Fine-Grained）两种模式：

spark-submit --master mesos://mesos-master:5050 --deploy-mode cluster ...

目前业界已大幅向 YARN 和 Kubernetes 迁移，Mesos 使用比例持续下降。新项目不建议选用 Mesos。

七、模式选型决策树

开始
 │
 ├─ 本地开发/调试？ ─── YES → Local 模式 (local[4])
 │
 ├─ 已有 Hadoop/YARN 集群？ ─── YES → YARN cluster 模式
 │
 ├─ 已有 Kubernetes 集群？ ─── YES → K8s cluster 模式
 │
 ├─ 小团队 / 不想搭 Hadoop？ ─── YES → Standalone 模式
 │
 └─ 遗留 Mesos 集群？ ─── YES → Mesos（建议迁移到 YARN/K8s）

八、最佳实践

写在最后

理解 Spark 五种运行模式，本质上是在回答一个问题："我的计算任务应该跑在哪里、由谁来管理资源？"

• 写代码时 → local[4]，IDE 里打断点
• 上测试环境 → yarn-client，看着日志调参数
• 上生产环境 → yarn-cluster，开动态分配、配 Shuffle Service
• 上云原生 → k8s-cluster，用 Operator 管理生命周期

模式的选择，决定了你的 Spark 作业有多稳定、多高效、多省钱。