大数据分析与挖掘
¶

08. How to deploy PySpark to a Kubernetes cluster
¶

主讲人：丁平尖

使用 Docker Compose 部署 PySpark¶

  • Docker Compose 简化了多容器应用程序的管理流程，并为在开发环境中搭建 Spark 集群提供了理想的解决方案。
  • Docker Compose 部署 Spark 集群时，实际上采用的是 Spark 的 standalone（独立）模式。
  • Docker Compose 只是用来编排和管理多个容器（如 master、worker），它本身不提供资源调度功能。
  • 在 Compose 文件中，通常会启动一个 Spark master 容器和多个 worker 容器，这些容器通过 Spark 自带的 standalone 集群管理器进行通信和资源调度。

如何创建用于构建 PySpark 镜像的 Dockerfile¶

  1. 创建Dockerfile
# Build spark image to run on Kubernetes
# See https://levelup.gitconnected.com/spark-on-kubernetes-3d822969f85b
# https://hub.docker.com/r/datamechanics/spark
# Currently is: 3.2.1-hadoop-3.3.1-java-8-scala-2.12-python-3.8-dm17
FROM datamechanics/spark:3.2-latest

# Run installation tasks as root
USER 0

# Ensure current patches (standard security practice)
RUN apt update \
    && apt --yes upgrade

# Specify the official Spark User, working directory, and entry point
WORKDIR /opt/spark/work-dir

# Offical UID for spark process
ARG spark_uid=185

# Specify the user info for spark_uid
RUN useradd -d /home/sparkuser -ms /bin/bash -u ${spark_uid} sparkuser \
    && chown -R sparkuser /opt/spark/work-dir \
    && mkdir /tmp/spark-events \
    && chown -R sparkuser /tmp/spark-events

# app dependencies AND path to openjdk11
ENV APP_DIR=/opt/spark/work-dir \
    PYTHON=python3 \
    PIP=pip3

# Preinstall dependencies
COPY requirements.txt ${APP_DIR}

RUN ${PIP} install --upgrade pip -i https://mirrors.aliyun.com/pypi/simple
RUN ${PIP} install --no-cache-dir -r ${APP_DIR}/requirements.txt -i https://mirrors.aliyun.com/pypi/simple
RUN rm -f ${APP_DIR}/requirements.txt

# Copy local files to image (ordered so that more likely to change is copied later)
# Python script to start the program
COPY --chown=sparkuser ./run.py ${APP_DIR}
COPY --chown=sparkuser ./runpi.py ${APP_DIR}
COPY --chown=sparkuser ./runjupyter.py ${APP_DIR}
# data will be local to image
COPY --chown=sparkuser ./data ${APP_DIR}/data
# Python code (using module name for directory)
COPY --chown=sparkuser k8spark ${APP_DIR}/k8spark

RUN chown -R sparkuser:sparkuser /opt/spark

# Ensure owned by Spark
RUN chown -R sparkuser:sparkuser ${APP_DIR}/*

# 这两行代码的作用分别如下：
# 第一行用于将本地的 start-spark.sh 脚本复制到镜像的根目录下
# 第二行用于设置容器启动时执行 /start-spark.sh 脚本作为默认命令
COPY start-spark.sh /start-spark.sh
CMD ["/bin/bash", "/start-spark.sh"]

USER ${spark_uid}

# #选择官方的 datamechanics Spark 镜像作为基础镜像，
# 包含 Spark、Hadoop、Java、Scala 和 Python 环境，
# 适用于在 Kubernetes 上运行 PySpark
FROM datamechanics/spark:3.2-latest

# 以 root 用户身份执行后续命令
USER 0
# 更新软件包索引并升级已安装的软件包，确保系统为最新状态
RUN apt update && apt --yes upgrade

# 指定 Spark 官方用户、工作目录和入口点
WORKDIR /opt/spark/work-dir

# 为 Spark 进程指定官方 UID
ARG spark_uid=185

# 创建名为 sparkuser 的用户，指定家目录和 shell，并设置 UID
# 递归修改 Spark 工作目录的所有者为 sparkuser
# 递归修改事件日志目录的所有者为 sparkuser
RUN useradd -d /home/sparkuser -ms /bin/bash -u ${spark_uid} sparkuser \  
    && chown -R sparkuser /opt/spark/work-dir \  
    && mkdir /tmp/spark-events \  # 创建用于存放 Spark 事件日志的目录
    && chown -R sparkuser /tmp/spark-events

# 设置 APP_DIR 为 Spark 工作目录，PYTHON 和 PIP 分别指定 Python3 及其包管理器
ENV APP_DIR=/opt/spark/work-dir \
    PYTHON=python3 \
    PIP=pip3  

# 预安装依赖包
# 将本地 requirements.txt 复制到镜像的 APP_DIR 目录下
COPY requirements.txt ${APP_DIR}  

# 升级 pip 并安装 requirements.txt 中的依赖（使用阿里云镜像加速）
RUN ${PIP} install --upgrade pip -i https://mirrors.aliyun.com/pypi/simple
RUN ${PIP} install --no-cache-dir -r ${APP_DIR}/requirements.txt -i https://mirrors.aliyun.com/pypi/simple
RUN rm -f ${APP_DIR}/requirements.txt

requirements.txt 示例内容¶

# requirements.txt 示例内容
flask
ipywidgets
ipython
tornado
notebook==6.5.6
numpy
# pandas 2.x requires spark >3.4
pandas==1.5.3
wget
# Version must match version installed in Dockerfile
pyspark==3.2.1
matplotlib

COPY --chown=sparkuser ./run.py ${APP_DIR}
# 复制主运行脚本 run.py 到镜像的 APP_DIR 目录下，并设置所有者为 sparkuser

COPY --chown=sparkuser ./runpi.py ${APP_DIR}
# 复制辅助脚本 runpi.py 到 APP_DIR，设置所有者为 sparkuser

COPY --chown=sparkuser ./runjupyter.py ${APP_DIR}
# 复制 Jupyter 启动脚本 runjupyter.py 到 APP_DIR，设置所有者为 sparkuser

COPY --chown=sparkuser ./data ${APP_DIR}/data
# 复制本地 data 目录到镜像的 APP_DIR/data 路径下，设置所有者为 sparkuser

COPY --chown=sparkuser k8spark ${APP_DIR}/k8spark
# 复制本地 k8spark 目录（Python 代码模块）到镜像的 APP_DIR/k8spark 路径下，设置所有者为 sparkuser

RUN chown -R sparkuser:sparkuser ${APP_DIR}/*
# 递归修改 APP_DIR 下所有文件和目录的所有者为 sparkuser，确保权限正确

RUN chown -R sparkuser:sparkuser /opt/spark
# 递归修改 /opt/spark 目录下所有文件和目录的所有者为 sparkuser，确保 Spark 相关目录权限正确

# 这两行代码的作用分别如下：
# 第一行用于将本地的 start-spark.sh 脚本复制到镜像的根目录下
# 第二行用于设置容器启动时执行 /start-spark.sh 脚本作为默认命令
COPY start-spark.sh /start-spark.sh
CMD ["/bin/bash", "/start-spark.sh"]

USER ${spark_uid}
# 切换到 spark_uid 用户，确保后续操作以非 root 用户身份进行

如何配置入口脚本来管理 Spark 工作负载¶

  • start-spark.sh 脚本内容如下：
#!/bin/bash
# 加载 Spark 环境变量，确保后续命令可以访问 Spark 配置和依赖
. "/opt/spark/bin/load-spark-env.sh"  

if [ "$SPARK_WORKLOAD" == "master" ]; then
    # 如果 SPARK_WORKLOAD 为 master，则启动 Spark Master 节点
    SPARK_MASTER_LOG=${SPARK_MASTER_LOG:-/tmp/spark-master.log} 
    # 设置 master 日志文件路径（可通过环境变量覆盖） 
    export SPARK_MASTER_HOST=${SPARK_MASTER_HOST:-$(hostname)}   
    # 设置 master 主机名（默认使用容器主机名）
    export SPARK_MASTER_PORT=${SPARK_MASTER_PORT:-7077}          
    # 设置 master 端口（默认 7077）
    export SPARK_MASTER_WEBUI_PORT=${SPARK_MASTER_WEBUI_PORT:-8080} 
    # 设置 master Web UI 端口（默认 8080）
    cd /opt/spark/bin && ./spark-class org.apache.spark.deploy.master.Master --ip $SPARK_MASTER_HOST --port $SPARK_MASTER_PORT --webui-port $SPARK_MASTER_WEBUI_PORT >> $SPARK_MASTER_LOG
elif [ "$SPARK_WORKLOAD" == "worker" ]; then
    # 如果 SPARK_WORKLOAD 为 worker，则启动 Spark Worker 节点
    SPARK_WORKER_LOG=${SPARK_WORKER_LOG:-/tmp/spark-worker.log}  
    # 设置 worker 日志文件路径（可通过环境变量覆盖）
    cd /opt/spark/bin && ./spark-class org.apache.spark.deploy.worker.Worker $SPARK_MASTER >> $SPARK_WORKER_LOG
else
    # 未知的 SPARK_WORKLOAD 类型，输出错误并退出
    echo "Unknown SPARK_WORKLOAD: $SPARK_WORKLOAD"
    exit 1
fi
  • 打开终端并进入当前工作目录，然后运行
docker build -t our-own-apache-spark:3.2.1 .

# 这行命令的作用是使用当前目录下的 Dockerfile 构建一个新的 Docker 镜像，
# 并将其命名为 `our-own-apache-spark:3.2.1`。  
# - `docker build`：用于根据 Dockerfile 构建镜像的命令。  
# - `-t our-own-apache-spark:3.2.1`：为构建的镜像指定名称（仓库名）和标签（版本号）。  
# - `.`：表示 Dockerfile 位于当前目录。

image.png

In [4]:
!docker images

REPOSITORY             TAG       IMAGE ID       CREATED          SIZE
our-own-apache-spark   3.2.1     2b332713cf14   11 minutes ago   4.23GB
our-own-apache-spark   3.2.0     a4e445261f49   6 hours ago      3.64GB
kindest/node           <none>    89e7dc9f9131   2 years ago      932MB

运行容器¶

  • Dockerfile 没有指定入口（ENTRYPOINT 或 CMD）的话，你需要在运行容器时手动指定要执行的命令（如 bash），否则容器会立即退出。
  • 通常建议在 Dockerfile 中通过 CMD 或 ENTRYPOINT 指定默认启动命令，这样容器启动时会自动执行相应脚本，无需每次手动输入命令。上文 Dockerfile 已通过 CMD ["/bin/bash", "/start-spark.sh"] 设置了默认入口。

docker run -it --rm --name spark-master -e SPARK_WORKLOAD=master our-own-apache-spark:3.2.1 - docker run：运行一个新的容器实例。 - -it：以交互模式运行容器，并分配一个伪终端，方便输入命令和查看输出。 - --rm：容器退出后自动删除容器文件，避免产生无用的容器残留。 - --name spark-master：为容器指定名称，便于后续管理和操作。 - -e SPARK_WORKLOAD=master：设置环境变量 SPARK_WORKLOAD 为 master，用于指定容器角色（master节点）。 - our-own-apache-spark:3.2.1：指定要运行的镜像及其标签（版本号）。

运行容器¶

  • 如果没有在 Dockerfile 中通过 CMD 或 ENTRYPOINT 指定默认启动命令，则需要在运行容器时手动指定要执行的命令。例如：

docker run -it --rm --name our-own-apache-spark our-own-apache-spark:3.2.1 bash

  • 这条命令的含义如下：

    • docker run：运行一个新的容器实例。
    • -it：以交互模式运行容器，并分配一个伪终端。
    • --rm：容器退出后自动删除容器文件。
    • --name our-own-apache-spark：为容器指定名称，便于管理。
    • our-own-apache-spark:3.2.1：指定要运行的镜像及其标签。
    • bash：指定容器启动后执行的命令（此处为 bash shell）。

  • 这样可以进入容器内部进行调试或手动启动服务。

In [3]:
!docker ps -a

CONTAINER ID   IMAGE                        COMMAND                   CREATED              STATUS              PORTS                                                                                      NAMES
41f5bf56e6fb   our-own-apache-spark:3.2.1   "/opt/dm_entrypoint.…"   About a minute ago   Up About a minute                                                                                              spark-master
2a9dc855e155   our-own-apache-spark:3.2.1   "/opt/dm_entrypoint.…"   About a minute ago   Up About a minute                                                                                              our-own-apache-spark
78157500a277   our-own-apache-spark:3.2.1   "/opt/dm_entrypoint.…"   11 minutes ago       Up 11 minutes       0.0.0.0:7000->7000/tcp, [::]:7000->7000/tcp, 0.0.0.0:9091->8080/tcp, [::]:9091->8080/tcp   kind-spark-worker-a-1
199a861c5490   our-own-apache-spark:3.2.1   "/opt/dm_entrypoint.…"   11 minutes ago       Up 11 minutes       0.0.0.0:7001->7000/tcp, [::]:7001->7000/tcp, 0.0.0.0:9092->8080/tcp, [::]:9092->8080/tcp   kind-spark-worker-b-1
9cc52d921313   our-own-apache-spark:3.2.1   "/opt/dm_entrypoint.…"   11 minutes ago       Up 11 minutes       0.0.0.0:7077->7077/tcp, [::]:7077->7077/tcp, 0.0.0.0:9090->8080/tcp, [::]:9090->8080/tcp   kind-spark-master-1

docker exec 命令详解¶

docker exec -it our-own-apache-spark bash
  • docker exec：在运行中的容器内执行命令。
  • -it：以交互模式运行，分配伪终端，方便输入和输出。
  • our-own-apache-spark：目标容器的名称。
  • bash：在容器内启动 bash shell，进入命令行环境。

image.png

docker exec -it spark-master bash

如何创建 Docker Compose 文件来定义 Spark 集群的服务¶

  • 创建docker-compose.yaml文件
version: "3.3"
services:
  spark-master:
    image: our-own-apache-spark:3.2.1
    ports:
      - "9090:8080"
      - "7077:7077"
    volumes:
       - ./apps:/opt/spark-apps
       - ./data:/opt/spark-data
    environment:
      - SPARK_LOCAL_IP=spark-master
      - SPARK_WORKLOAD=master
  spark-worker-a:
    image: our-own-apache-spark:3.2.1
    ports:
      - "9091:8080"
      - "7000:7000"
    depends_on:
      - spark-master
    environment:
      - SPARK_MASTER=spark://spark-master:7077
      - SPARK_WORKER_CORES=1
      - SPARK_WORKER_MEMORY=1G
      - SPARK_DRIVER_MEMORY=1G
      - SPARK_EXECUTOR_MEMORY=1G
      - SPARK_WORKLOAD=worker
      - SPARK_LOCAL_IP=spark-worker-a
    volumes:
       - ./apps:/opt/spark-apps
       - ./data:/opt/spark-data
  spark-worker-b:
    image: our-own-apache-spark:3.2.1
    ports:
      - "9092:8080"
      - "7001:7000"
    depends_on:
      - spark-master
    environment:
      - SPARK_MASTER=spark://spark-master:7077
      - SPARK_WORKER_CORES=1
      - SPARK_WORKER_MEMORY=1G
      - SPARK_DRIVER_MEMORY=1G
      - SPARK_EXECUTOR_MEMORY=1G
      - SPARK_WORKLOAD=worker
      - SPARK_LOCAL_IP=spark-worker-b
    volumes:
        - ./apps:/opt/spark-apps
        - ./data:/opt/spark-data

yaml文件详解¶

version: "3.3"  # 指定 Docker Compose 文件的版本，3.3 支持大多数常用功能
services:       # 定义所有服务（容器），每个服务对应一个容器实例
  spark-master: # Spark 集群的 Master 节点服务
    image: our-own-apache-spark:3.2.1  # 使用自定义构建的 Spark 镜像
    ports:
      - "9090:8080"   # 将主机的 9090 端口映射到容器的 8080（Spark Master Web UI）
      - "7077:7077"   # 将主机的 7077 端口映射到容器的 7077（Spark Master 通信端口）
    volumes:
       - ./apps:/opt/spark-apps   # 挂载本地 apps 目录到容器，便于提交 Spark 应用
       - ./data:/opt/spark-data   # 挂载本地 data 目录到容器，便于访问数据
    environment:
      - SPARK_LOCAL_IP=spark-master   # 设置 Spark Master 的本地 IP（用于集群内部通信）
      - SPARK_WORKLOAD=master         # 指定该容器角色为 master 节点

yaml文件详解¶

spark-worker-a: # Spark 集群的第一个 Worker 节点服务
    image: our-own-apache-spark:3.2.1  # 使用同样的 Spark 镜像
    ports:
      - "9091:8080"   # 主机 9091 映射到容器 8080（Worker Web UI）
      - "7000:7000"   # 主机 7000 映射到容器 7000（Worker 通信端口）
    depends_on:
      - spark-master  # 启动前依赖 spark-master 服务
    environment:
      - SPARK_MASTER=spark://spark-master:7077   # 指定 Master 节点地址
      - SPARK_WORKER_CORES=1                    # Worker 分配的 CPU 核数
      - SPARK_WORKER_MEMORY=1G                  # Worker 分配的内存
      - SPARK_DRIVER_MEMORY=1G                  # Driver 分配的内存
      - SPARK_EXECUTOR_MEMORY=1G                # Executor 分配的内存
      - SPARK_WORKLOAD=worker                   # 指定该容器角色为 worker 节点
      - SPARK_LOCAL_IP=spark-worker-a           # 设置 Worker 的本地 IP
    volumes:
       - ./apps:/opt/spark-apps   # 挂载本地 apps 目录
       - ./data:/opt/spark-data   # 挂载本地 data 目录
  spark-worker-b: # Spark 集群的第二个 Worker 节点服务
    image: our-own-apache-spark:3.2.1  # 使用同样的 Spark 镜像
    ports:
      - "9092:8080"   # 主机 9092 映射到容器 8080（Worker Web UI）
      - "7001:7000"   # 主机 7001 映射到容器 7000（Worker 通信端口）
    depends_on:
      - spark-master  # 启动前依赖 spark-master 服务
    environment:
      - SPARK_MASTER=spark://spark-master:7077   # 指定 Master 节点地址
      - SPARK_WORKER_CORES=1                    # Worker 分配的 CPU 核数
      - SPARK_WORKER_MEMORY=1G                  # Worker 分配的内存
      - SPARK_DRIVER_MEMORY=1G                  # Driver 分配的内存
      - SPARK_EXECUTOR_MEMORY=1G                # Executor 分配的内存
      - SPARK_WORKLOAD=worker                   # 指定该容器角色为 worker 节点
      - SPARK_LOCAL_IP=spark-worker-b           # 设置 Worker 的本地 IP
    volumes:
        - ./apps:/opt/spark-apps   # 挂载本地 apps 目录
        - ./data:/opt/spark-data   # 挂载本地 data 目录

docker-compose up¶

  • docker-compose up 命令用于根据 docker-compose.yaml 文件启动并运行所有定义的服务（容器）。
  • 它会自动创建网络、挂载卷、设置环境变量，并按配置启动各个容器，实现多容器应用的一键部署。
  • 常用于本地或开发环境快速启动如 Spark 集群、Web 服务等多容器系统。
docker-compose up
In [5]:
!docker ps

CONTAINER ID   IMAGE                        COMMAND                   CREATED          STATUS          PORTS                                                                                      NAMES
41f5bf56e6fb   our-own-apache-spark:3.2.1   "/opt/dm_entrypoint.…"   33 minutes ago   Up 33 minutes                                                                                              spark-master
2a9dc855e155   our-own-apache-spark:3.2.1   "/opt/dm_entrypoint.…"   34 minutes ago   Up 34 minutes                                                                                              our-own-apache-spark
78157500a277   our-own-apache-spark:3.2.1   "/opt/dm_entrypoint.…"   43 minutes ago   Up 43 minutes   0.0.0.0:7000->7000/tcp, [::]:7000->7000/tcp, 0.0.0.0:9091->8080/tcp, [::]:9091->8080/tcp   kind-spark-worker-a-1
199a861c5490   our-own-apache-spark:3.2.1   "/opt/dm_entrypoint.…"   43 minutes ago   Up 43 minutes   0.0.0.0:7001->7000/tcp, [::]:7001->7000/tcp, 0.0.0.0:9092->8080/tcp, [::]:9092->8080/tcp   kind-spark-worker-b-1
9cc52d921313   our-own-apache-spark:3.2.1   "/opt/dm_entrypoint.…"   43 minutes ago   Up 43 minutes   0.0.0.0:7077->7077/tcp, [::]:7077->7077/tcp, 0.0.0.0:9090->8080/tcp, [::]:9090->8080/tcp   kind-spark-master-1

提交任务¶

docker exec -i -t 9cc52d921313 /bin/bash 
# 进入容器（ID为9cc52d921313），打开bash shell，进行交互式操作
/opt/spark/bin/spark-submit --master spark://0.0.0.0:7077 --name spark-runpy local:///opt/spark/work-dir/run.py
# 在容器内直接使用绝对路径提交Spark任务，指定master地址和任务名称
cd /opt/spark/bin
./spark-submit --master spark://0.0.0.0:7077 --name spark-runpy local:///opt/spark/work-dir/run.py
# 先切换到spark二进制目录再提交任务，效果等同于上面命令
  • ./spark-submit：Spark 的任务提交工具，用于启动 Spark 应用。
  • --master spark://0.0.0.0:7077：指定 Spark 集群 master 的地址和端口（此处为本地容器的 master）。
  • --name spark-runpy：为本次 Spark 任务指定名称，便于在 Web UI 或日志中识别。
  • local:///opt/spark/work-dir/run.py：指定要运行的 Python 脚本路径，local:// 表示容器本地绝对路径。

image.png

Deploying Apache Spark on a Local Kubernetes Cluster¶

  • Kubernetes 作为领先的容器编排平台，为部署和管理分布式应用程序提供了强大的环境。通过在 Kubernetes 上部署 Spark，可以充分利用 Kubernetes 的动态扩展、容错和资源分配等特性，从而确保最佳性能和资源利用率。
  • 使用 Kind（Kubernetes IN Docker）设置本地 Kubernetes 集群。Kind 是一款专为使用 Docker 容器“节点”运行 Kubernetes 集群而设计的工具。

Set up a Local Kubernetes Cluster¶

  1. 安装kind

Kind需要被安装在WSL中，只需要下载二进制文件并且拷贝到PATH中：

# 下载适用于 x86_64 架构的 kind 二进制文件 
[ $(uname -m) = x86_64 ] && curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.20.0/kind-linux-amd64   
chmod +x ./kind  # 添加执行权限  
# 移动到 PATH 路径，方便全局调用
sudo mv ./kind /usr/local/bin/kind

查看kind版本

kind version

image.png

Set up a Local Kubernetes Cluster¶

  1. 创建 Kubernetes 集群：
# 使用 kind 工具创建本地 Kubernetes 集群，方便后续 Spark 部署与测试。
kind create cluster --name kind

# 列出当前已创建的所有 kind 集群，确认集群是否创建成功。
kind get clusters

# 删除指定名称的 kind 集群，释放资源。
kind delete cluster --name kind

Build a Docker Image for Spark and Push it to Kubernetes Internal Repository¶

  1. 将镜像推送到 Kubernetes 内部仓库
# 将本地构建的 Spark 镜像加载到 Kind 管理的 Kubernetes 集群，使集群节点能够直接使用该镜像，无需从外部仓库拉取。
kind load docker-image our-own-apache-spark:3.2.1

Deploy a Spark program Using spark-submit¶

  1. Service Account
  • 创建 Service Account 让 Spark driver 和 executor 有权限访问 Kubernetes API（如创建/管理 Pod、获取日志等）。
  • 如果没有 Service Account 或没有绑定合适的权限，Spark 任务可能无法正常调度和运行。
# 下面命令用于创建 Service Account 及绑定权限，确保 Spark driver 能访问 Kubernetes API
kubectl create serviceaccount spark

# 为 Spark Service Account 绑定 edit 权限（允许管理资源），否则 driver 无法创建/管理 Pod
kubectl create clusterrolebinding spark-role --clusterrole=edit --serviceaccount=default:spark
  1. Spark-submit 提交并运行任务
# 查看集群信息
kubectl cluster-info
![image.png](attachment:image.png)

# 不要多行
# 注意修改Kubernetes API Server 地址为实际值
spark-submit   --master k8s://https://127.0.0.1:40593   --deploy-mode cluster   --name spark-runpy   --conf spark.executor.instances=2   --conf spark.kubernetes.container.image=our-own-apache-spark:3.2.1   --conf spark.kubernetes.container.image.pullPolicy=IfNotPresent   --conf spark.kubernetes.authenticate.driver.serviceAccountName=spark --conf spark.driver.memory=4g --conf spark.executor.memory=2g  local:///opt/spark/work-dir/run.py
  • --master k8s://https://127.0.0.1:40593：指定 Spark 集群的 master 为 Kubernetes，并设置 API Server 地址（需替换为实际值）。
  • --deploy-mode cluster：以集群模式运行，driver 在 Kubernetes 集群中启动。
  • --name spark-runpy：为本次 Spark 任务指定名称，便于识别和管理。
  • --conf spark.executor.instances=2：设置 executor 实例数量为 2。
  • --conf spark.kubernetes.container.image=our-own-apache-spark:3.2.1：指定用于运行 Spark 的容器镜像。
  • --conf spark.kubernetes.container.image.pullPolicy=IfNotPresent：镜像拉取策略，优先使用本地镜像，无则拉取。
  • --conf spark.kubernetes.authenticate.driver.serviceAccountName=spark：指定 driver 使用的 Kubernetes Service Account，确保有权限调度资源。
  • --conf spark.driver.memory=4g：为 driver 分配 4GB 内存。
  • --conf spark.executor.memory=2g：为每个 executor 分配 2GB 内存。
  • local:///opt/spark/work-dir/run.py：指定要运行的 Python 脚本路径，local:// 表示容器内的绝对路径。
  1. Monitor the application
  • 下面命令用于监控 Spark 任务在 Kubernetes 集群中的运行状态、查看日志、排查异常并进行端口转发访问 Web UI。
# 监控 Spark 应用运行状态与日志
# `kubectl get pods`：列出当前所有 Pod，查看任务是否已启动或完成。
kubectl get pods

# 详细查看 driver Pod 的状态、事件和资源分配情况。
kubectl describe pod spark-runpy-0780d39a4a5e0ce5-driver

# 获取 driver Pod 的标准输出日志，便于分析任务执行结果。
kubectl logs spark-runpy-0780d39a4a5e0ce5-driver

# 详细查看 executor Pod 的状态、事件和资源分配情况，便于定位异常或资源瓶颈。
kubectl describe pod air-bnb-88e7c59a4a62e043-exec-1

# 获取 executor Pod 的标准输出日志，分析任务执行过程和错误信息。
kubectl logs air-bnb-88e7c59a4a62e043-exec-1

# 批量删除已完成或异常状态的 Pod，释放资源，保持集群整洁。
kubectl delete pod $(kubectl get pod | grep -E 'Completed|OOMKilled|ImagePullBackOff|Pending' | awk '{print $1}')
  1. Monitor the application
#将本地 4040 端口映射到 driver Pod 的 4040 端口，访问 Spark Web UI 查看任务进度和详细信息。
kubectl port-forward spark-runpy-5f5aae9a48719876-driver 4040:4040

利用driver节点日志查看结果

image.png