在 Kubernetes 上运行 Spark

• 安全
  • 用户身份
  • 卷挂载
• 先决条件
• 工作原理
• 向 Kubernetes 提交应用程序
  • Docker 镜像
  • 集群模式
  • 客户端模式
    • 客户端模式网络
    • 客户端模式执行器 Pod 垃圾回收
    • 身份验证参数
  • IPv4 和 IPv6
  • 依赖管理
  • 密钥管理
  • Pod 模板
  • 使用 Kubernetes 卷
    • 面向 PVC 的执行器 Pod 分配
  • 本地存储
    • 使用 RAM 作为本地存储
  • 自省和调试
    • 访问日志
    • 访问驱动程序 UI
    • 调试
  • Kubernetes 功能
    • 配置文件
    • 上下文
    • 命名空间
    • RBAC
  • Spark 应用程序管理
  • 未来工作
• 配置
  • Spark 属性
  • Pod 模板属性
  • Pod 元数据
  • Pod 规范
  • 容器规范
  • 资源分配和配置概述
  • 资源级别调度概述
    • 优先级调度
    • 用于 Spark on Kubernetes 的自定义 Kubernetes 调度器
    • 使用 Volcano 作为 Spark on Kubernetes 的自定义调度器
      • 先决条件
      • 构建
      • 用法
      • Volcano 功能步骤
      • Volcano PodGroup 模板
    • 使用 Apache YuniKorn 作为 Spark on Kubernetes 的自定义调度器
      • 先决条件
      • 入门
  • 阶段级别调度概述

Spark 可以运行在由 Kubernetes 管理的集群上。此功能利用了添加到 Spark 的原生 Kubernetes 调度器。

安全

安全功能（如身份验证）默认情况下未启用。在部署开放给互联网或不受信任网络的集群时，保护对集群的访问非常重要，以防止未经授权的应用程序在集群上运行。在运行 Spark 之前，请参阅 Spark 安全 以及本文档中的特定安全部分。

用户身份

从项目提供的 Dockerfile 构建的镜像包含一个默认的 USER 指令，其默认 UID 为 185。这意味着生成的镜像将在容器内以该 UID 运行 Spark 进程。注重安全的部署应考虑提供自定义镜像，其中 USER 指令指定其所需的非特权 UID 和 GID。生成的 UID 应在其补充组中包含 root 组，以便能够运行 Spark 可执行文件。使用提供的 docker-image-tool.sh 脚本构建自己的镜像的用户可以使用 -u <uid> 选项来指定所需的 UID。

或者，可以使用 Pod 模板 功能向 Spark 提交的 Pod 添加一个 安全上下文，其中包含一个 runAsUser。这可以用来覆盖镜像本身的 USER 指令。请记住，这需要用户配合，因此可能不适合共享环境。集群管理员应使用 Pod 安全策略，如果他们希望限制 Pod 可以运行的用户。

卷挂载

如本文档后面 使用 Kubernetes 卷 部分所述，Spark on K8S 提供了配置选项，允许将某些卷类型挂载到驱动程序和执行器 Pod 中。特别是，它允许使用 hostPath 卷，如 Kubernetes 文档中所述，这些卷存在已知的安全漏洞。

集群管理员应使用 Pod 安全策略 来限制在适当的环境中挂载 hostPath 卷的能力。

先决条件

• 一个运行的 Kubernetes 集群，版本 >= 1.24，并使用 kubectl 配置了对它的访问。如果您还没有一个可用的 Kubernetes 集群，可以使用 minikube 在本地机器上设置一个测试集群。
  • 我们建议使用最新版本的 minikube，并启用 DNS 附加组件。
  • 请注意，默认的 minikube 配置不足以运行 Spark 应用程序。我们建议使用 3 个 CPU 和 4 GB 内存，以便能够启动一个带有单个执行器的简单 Spark 应用程序。
  • 检查 kubernetes-client 库 的 Spark 环境版本及其与 Kubernetes 集群版本的兼容性。
• 您必须具有适当的权限才能在集群中列出、创建、编辑和删除 Pod。您可以通过运行 kubectl auth can-i <list|create|edit|delete> pods 来验证您是否可以列出这些资源。
  • 驱动程序 Pod 使用的服务帐户凭据必须被允许创建 Pod、服务和 ConfigMap。
• 您必须在集群中配置 Kubernetes DNS。

工作原理

spark-submit 可以直接用于将 Spark 应用程序提交到 Kubernetes 集群。提交机制的工作原理如下

• Spark 创建一个在 Kubernetes Pod 中运行的 Spark 驱动程序。
• 驱动程序创建执行器，它们也运行在 Kubernetes Pod 中，并连接到它们，并执行应用程序代码。
• 当应用程序完成时，执行器 Pod 会终止并被清理，但驱动程序 Pod 会保留日志并保持在 Kubernetes API 中的“已完成”状态，直到它最终被垃圾回收或手动清理。

请注意，在已完成状态下，驱动程序 Pod 不会 使用任何计算或内存资源。

驱动程序和执行器 Pod 的调度由 Kubernetes 处理。与 Kubernetes API 的通信通过 fabric8 完成。可以通过 节点选择器 使用其配置属性，在可用节点的子集上调度驱动程序和执行器 Pod。在将来的版本中，将可以使用更高级的调度提示，如 节点/Pod 亲和性。

向 Kubernetes 提交应用程序

Docker 镜像

Kubernetes 要求用户提供可以部署到 Pod 中容器的镜像。这些镜像被构建为在 Kubernetes 支持的容器运行时环境中运行。Docker 是一个容器运行时环境，经常与 Kubernetes 一起使用。Spark（从版本 2.3 开始）附带一个 Dockerfile，可以用于此目的，或者可以根据单个应用程序的需要进行自定义。它可以在 kubernetes/dockerfiles/ 目录中找到。

Spark 还附带一个 bin/docker-image-tool.sh 脚本，可以用来构建和发布与 Kubernetes 后端一起使用的 Docker 镜像。

示例用法是

$ ./bin/docker-image-tool.sh -r <repo> -t my-tag build
$ ./bin/docker-image-tool.sh -r <repo> -t my-tag push

这将使用项目提供的默认 Dockerfiles 进行构建。要查看此工具可用于自定义其行为的更多选项，包括提供自定义 Dockerfiles，请使用 -h 标志运行。

默认情况下，bin/docker-image-tool.sh 构建用于运行 JVM 作业的 docker 镜像。您需要选择加入以构建其他语言绑定 docker 镜像。

示例用法是

# To build additional PySpark docker image
$ ./bin/docker-image-tool.sh -r <repo> -t my-tag -p ./kubernetes/dockerfiles/spark/bindings/python/Dockerfile build

# To build additional SparkR docker image
$ ./bin/docker-image-tool.sh -r <repo> -t my-tag -R ./kubernetes/dockerfiles/spark/bindings/R/Dockerfile build

您也可以直接使用 Apache Spark Docker 镜像（例如 apache/spark:<version>）。

集群模式

要以集群模式启动 Spark Pi，

$ ./bin/spark-submit \
    --master k8s://https://<k8s-apiserver-host>:<k8s-apiserver-port> \
    --deploy-mode cluster \
    --name spark-pi \
    --class org.apache.spark.examples.SparkPi \
    --conf spark.executor.instances=5 \
    --conf spark.kubernetes.container.image=<spark-image> \
    local:///path/to/examples.jar

Spark 主节点（通过将 --master 命令行参数传递给 spark-submit 或通过在应用程序的配置中设置 spark.master 来指定）必须是一个具有格式 k8s://<api_server_host>:<k8s-apiserver-port> 的 URL。即使是 HTTPS 端口 443，也必须始终指定端口。在主字符串前面加上 k8s:// 将导致 Spark 应用程序在 Kubernetes 集群上启动，并与 api_server_url 处的 API 服务器进行通信。如果 URL 中没有指定 HTTP 协议，则默认为 https。例如，将主节点设置为 k8s://example.com:443 等效于将其设置为 k8s://https://example.com:443，但要在不同端口上连接而不使用 TLS，主节点将设置为 k8s://http://example.com:8080。

在 Kubernetes 模式下，由 spark.app.name 或 spark-submit 的 --name 参数指定的 Spark 应用程序名称默认情况下用于命名创建的 Kubernetes 资源，如驱动程序和执行器。因此，应用程序名称必须由小写字母数字字符、- 和 . 组成，并且必须以字母数字字符开头和结尾。

如果您有一个 Kubernetes 集群设置，则发现 API 服务器 URL 的一种方法是执行 kubectl cluster-info。

$ kubectl cluster-info
Kubernetes master is running at http://127.0.0.1:6443

在上面的示例中，可以通过指定 --master k8s://http://127.0.0.1:6443 作为 spark-submit 的参数来使用特定的 Kubernetes 集群。此外，还可以使用身份验证代理 kubectl proxy 与 Kubernetes API 进行通信。

可以通过以下方式启动本地代理：

$ kubectl proxy

如果本地代理在 localhost:8001 上运行，则可以使用 --master k8s://http://127.0.0.1:8001 作为 spark-submit 的参数。最后，请注意，在上面的示例中，我们指定了一个具有 local:// 方案的特定 URI 的 jar 文件。此 URI 是 Docker 镜像中已存在的示例 jar 文件的位置。

客户端模式

从 Spark 2.4.0 开始，可以在客户端模式下在 Kubernetes 上运行 Spark 应用程序。当您的应用程序在客户端模式下运行时，驱动程序可以在 Pod 内或物理主机上运行。在客户端模式下运行应用程序时，建议考虑以下因素：

客户端模式网络

Spark 执行器必须能够通过从 Spark 执行器可以路由的主机名和端口连接到 Spark 驱动程序。Spark 在客户端模式下工作所需的特定网络配置将因设置而异。如果您在 Kubernetes Pod 内运行驱动程序，可以使用 无头服务 允许您的驱动程序 Pod 通过稳定的主机名从执行器进行路由。部署无头服务时，请确保服务的标签选择器只匹配驱动程序 Pod，而不匹配其他 Pod；建议为您的驱动程序 Pod 分配一个足够唯一的标签，并在无头服务的标签选择器中使用该标签。通过 spark.driver.host 指定驱动程序的主机名，并将您的 Spark 驱动程序的端口指定为 spark.driver.port。

客户端模式执行器 Pod 垃圾回收

如果您在 Pod 中运行 Spark 驱动程序，强烈建议将 spark.kubernetes.driver.pod.name 设置为该 Pod 的名称。设置此属性后，Spark 调度程序将使用 所有者引用 部署执行器 Pod，这将确保一旦驱动程序 Pod 从集群中删除，应用程序的所有执行器 Pod 也将被删除。驱动程序将在由 spark.kubernetes.namespace 指定的命名空间中查找具有给定名称的 Pod，并将指向该 Pod 的所有者引用添加到每个执行器 Pod 的所有者引用列表中。注意不要将所有者引用设置为实际上不是该驱动程序 Pod 的 Pod，否则执行器可能会在错误的 Pod 被删除时过早地终止。

如果您的应用程序没有在 Pod 内运行，或者如果您的应用程序实际上在 Pod 内运行时未设置 spark.kubernetes.driver.pod.name，请记住，应用程序退出时，执行器 Pod 可能无法从集群中正确删除。Spark 调度程序会尝试删除这些 Pod，但如果由于任何原因对 API 服务器的网络请求失败，这些 Pod 将保留在集群中。执行器进程在无法连接到驱动程序时应该退出，因此执行器 Pod 应该在您的应用程序退出后不会消耗集群中的计算资源（CPU 和内存）。

您可以使用 spark.kubernetes.executor.podNamePrefix 完全控制执行器 Pod 名称。设置此属性时，强烈建议在同一命名空间中的所有作业中使其唯一。

身份验证参数

在客户端模式下，使用确切的前缀 spark.kubernetes.authenticate 用于 Kubernetes 身份验证参数。

IPv4 和 IPv6

从 3.4.0 开始，Spark 通过 IPv4/IPv6 双栈网络 功能支持仅 IPv6 环境，该功能允许为 Pod 和服务分配 IPv4 和 IPv6 地址。根据 K8s 集群功能，spark.kubernetes.driver.service.ipFamilyPolicy 和 spark.kubernetes.driver.service.ipFamilies 可以是 SingleStack、PreferDualStack 和 RequireDualStack 中的一个，以及 IPv4、IPv6、IPv4,IPv6 和 IPv6,IPv4 中的一个。默认情况下，Spark 使用 spark.kubernetes.driver.service.ipFamilyPolicy=SingleStack 和 spark.kubernetes.driver.service.ipFamilies=IPv4。

要仅使用 IPv6，您可以使用以下命令提交作业。

...
    --conf spark.kubernetes.driver.service.ipFamilies=IPv6 \

在 DualStack 环境中，您可能需要 java.net.preferIPv6Addresses=true 用于 JVM，以及 SPARK_PREFER_IPV6=true 用于 Python，才能使用 IPv6。

依赖管理

如果您的应用程序的依赖项都托管在远程位置（如 HDFS 或 HTTP 服务器），则可以通过其相应的远程 URI 引用它们。此外，应用程序依赖项可以预先安装到自定义构建的 Docker 镜像中。可以通过使用 local:// URI 引用这些依赖项，以及/或者在 Dockerfile 中设置 SPARK_EXTRA_CLASSPATH 环境变量，将它们添加到类路径中。在 spark-submit 中引用自定义构建的 Docker 镜像中的依赖项时，也需要 local:// 方案。我们支持来自提交客户端本地文件系统的依赖项，使用 file:// 方案或不使用方案（使用完整路径），其中目标应该是与 Hadoop 兼容的文件系统。使用 S3 的典型示例是通过传递以下选项：

...
--packages org.apache.hadoop:hadoop-aws:3.2.2
--conf spark.kubernetes.file.upload.path=s3a://<s3-bucket>/path
--conf spark.hadoop.fs.s3a.access.key=...
--conf spark.hadoop.fs.s3a.impl=org.apache.hadoop.fs.s3a.S3AFileSystem
--conf spark.hadoop.fs.s3a.fast.upload=true
--conf spark.hadoop.fs.s3a.secret.key=....
--conf spark.driver.extraJavaOptions=-Divy.cache.dir=/tmp -Divy.home=/tmp
file:///full/path/to/app.jar

应用程序 jar 文件将被上传到 S3，然后在启动驱动程序时，它将被下载到驱动程序 Pod 并添加到其类路径中。Spark 将在上传路径下生成一个具有随机名称的子目录，以避免与并行运行的 spark 应用程序发生冲突。用户可以根据自己的需要管理创建的子目录。

客户端方案支持应用程序 jar 文件以及由属性 spark.jars、spark.files 和 spark.archives 指定的依赖项。

重要提示：所有客户端依赖项都将以扁平目录结构上传到给定路径，因此文件名必须唯一，否则文件将被覆盖。另外，请确保在派生的 k8s 镜像中，默认的 ivy 目录具有所需的访问权限，或者修改上述设置。如果您在集群模式下使用 --packages，这一点也很重要。

密钥管理

Kubernetes 秘密 可用于为 Spark 应用程序提供访问安全服务的凭据。要将用户指定的秘密安装到驱动程序容器中，用户可以使用以下形式的配置属性：spark.kubernetes.driver.secrets.[SecretName]=<mount path>。类似地，可以使用以下形式的配置属性：spark.kubernetes.executor.secrets.[SecretName]=<mount path> 将用户指定的秘密安装到执行器容器中。请注意，假设要安装的秘密与驱动程序和执行器 Pod 位于同一个命名空间中。例如，要将名为 spark-secret 的秘密安装到驱动程序和执行器容器中的 /etc/secrets 路径上，请将以下选项添加到 spark-submit 命令中：

--conf spark.kubernetes.driver.secrets.spark-secret=/etc/secrets
--conf spark.kubernetes.executor.secrets.spark-secret=/etc/secrets

要通过环境变量使用秘密，请将以下选项添加到 spark-submit 命令中：

--conf spark.kubernetes.driver.secretKeyRef.ENV_NAME=name:key
--conf spark.kubernetes.executor.secretKeyRef.ENV_NAME=name:key

Pod 模板

Kubernetes 允许从 模板文件 定义 Pod。Spark 用户可以类似地使用模板文件来定义 Spark 配置不支持的驱动程序或执行器 Pod 配置。为此，请指定 spark 属性 spark.kubernetes.driver.podTemplateFile 和 spark.kubernetes.executor.podTemplateFile，以指向 spark-submit 进程可以访问的文件。

--conf spark.kubernetes.driver.podTemplateFile=s3a://bucket/driver.yml
--conf spark.kubernetes.executor.podTemplateFile=s3a://bucket/executor.yml

为了允许驱动程序 Pod 访问执行器 Pod 模板文件，该文件将在创建驱动程序 Pod 时自动安装到驱动程序 Pod 中的卷上。Spark 在取消序列化这些模板文件后不会进行任何验证，而是依赖 Kubernetes API 服务器进行验证。

重要的是要注意，Spark 对某些 Pod 配置有自己的看法，因此 Pod 模板中有一些值将始终被 Spark 覆盖。因此，使用此功能的用户应注意，指定 Pod 模板文件只允许 Spark 在 Pod 构建过程中使用模板 Pod 而不是空 Pod 开始。有关详细信息，请参阅 Pod 模板值的完整列表，这些值将被 spark 覆盖。

Pod 模板文件还可以定义多个容器。在这种情况下，您可以使用 spark 属性 spark.kubernetes.driver.podTemplateContainerName 和 spark.kubernetes.executor.podTemplateContainerName 来指示哪个容器应该用作驱动程序或执行器的基础。如果未指定，或者容器名称无效，Spark 将假设列表中的第一个容器将是驱动程序或执行器容器。

使用 Kubernetes 卷

用户可以将以下类型的 Kubernetes 卷 安装到驱动程序和执行器 Pod 中：

• hostPath：将主机节点文件系统中的文件或目录安装到 Pod 中。
• emptyDir：在 Pod 分配到节点时创建的初始为空的卷。
• nfs：将现有的 NFS（网络文件系统）安装到 Pod 中。
• persistentVolumeClaim：将 PersistentVolume 安装到 Pod 中。

注意：请参阅本文档的 安全 部分，了解与卷安装相关的安全问题。

要将上述任何类型的卷安装到驱动程序 Pod 中，请使用以下配置属性：

--conf spark.kubernetes.driver.volumes.[VolumeType].[VolumeName].mount.path=<mount path>
--conf spark.kubernetes.driver.volumes.[VolumeType].[VolumeName].mount.readOnly=<true|false>
--conf spark.kubernetes.driver.volumes.[VolumeType].[VolumeName].mount.subPath=<mount subPath>

具体来说，VolumeType 可以是以下值之一：hostPath、emptyDir、nfs 和 persistentVolumeClaim。 VolumeName 是您要在 pod 规范的 volumes 字段下使用的卷的名称。

每个支持的卷类型可能有一些特定的配置选项，可以使用以下形式的配置属性来指定。

spark.kubernetes.driver.volumes.[VolumeType].[VolumeName].options.[OptionName]=<value>

例如，可以使用以下属性指定具有卷名 images 的 nfs 的服务器和路径。

spark.kubernetes.driver.volumes.nfs.images.options.server=example.com
spark.kubernetes.driver.volumes.nfs.images.options.path=/data

并且，可以使用以下属性指定具有卷名 checkpointpvc 的 persistentVolumeClaim 的声明名称。

spark.kubernetes.driver.volumes.persistentVolumeClaim.checkpointpvc.options.claimName=check-point-pvc-claim

将卷挂载到执行器 pod 中的配置属性使用前缀 spark.kubernetes.executor. 而不是 spark.kubernetes.driver.。

例如，您可以通过使用 OnDemand 作为声明名称以及 storageClass 和 sizeLimit 选项来挂载每个执行器的动态创建的持久卷声明，如下所示。这在 动态分配 的情况下很有用。

spark.kubernetes.executor.volumes.persistentVolumeClaim.data.options.claimName=OnDemand
spark.kubernetes.executor.volumes.persistentVolumeClaim.data.options.storageClass=gp
spark.kubernetes.executor.volumes.persistentVolumeClaim.data.options.sizeLimit=500Gi
spark.kubernetes.executor.volumes.persistentVolumeClaim.data.mount.path=/data
spark.kubernetes.executor.volumes.persistentVolumeClaim.data.mount.readOnly=false

有关每个支持的卷类型的所有可用选项的完整列表，请参阅下面的 Spark 属性 部分。

面向 PVC 的执行器 Pod 分配

由于磁盘是重要的资源类型之一，Spark 驱动程序通过一组配置提供了细粒度的控制。例如，默认情况下，按需 PVC 由执行器拥有，并且 PVC 的生命周期与其拥有者执行器紧密耦合。但是，按需 PVC 可以由驱动程序拥有，并在 Spark 作业的生命周期内被其他执行器重用，方法是使用以下选项。这减少了 PVC 创建和删除的开销。

spark.kubernetes.driver.ownPersistentVolumeClaim=true
spark.kubernetes.driver.reusePersistentVolumeClaim=true

此外，从 Spark 3.4 开始，Spark 驱动程序能够进行面向 PVC 的执行器分配，这意味着 Spark 会计算作业可以拥有的已创建 PVC 的总数，并在驱动程序拥有最大数量的 PVC 时阻止新的执行器创建。这有助于将现有 PVC 从一个执行器转移到另一个执行器。

spark.kubernetes.driver.waitToReusePersistentVolumeClaim=true

本地存储

Spark 支持使用卷在混洗和其他操作期间溢出数据。要将卷用作本地存储，卷的名称应以 spark-local-dir- 开头，例如

--conf spark.kubernetes.driver.volumes.[VolumeType].spark-local-dir-[VolumeName].mount.path=<mount path>
--conf spark.kubernetes.driver.volumes.[VolumeType].spark-local-dir-[VolumeName].mount.readOnly=false

具体来说，如果作业需要在执行器中进行大量的混洗和排序操作，您可以使用持久卷声明。

spark.kubernetes.executor.volumes.persistentVolumeClaim.spark-local-dir-1.options.claimName=OnDemand
spark.kubernetes.executor.volumes.persistentVolumeClaim.spark-local-dir-1.options.storageClass=gp
spark.kubernetes.executor.volumes.persistentVolumeClaim.spark-local-dir-1.options.sizeLimit=500Gi
spark.kubernetes.executor.volumes.persistentVolumeClaim.spark-local-dir-1.mount.path=/data
spark.kubernetes.executor.volumes.persistentVolumeClaim.spark-local-dir-1.mount.readOnly=false

要通过内置的 KubernetesLocalDiskShuffleDataIO 插件启用混洗数据恢复功能，我们需要具备以下条件。您可能还想另外启用 spark.kubernetes.driver.waitToReusePersistentVolumeClaim。

spark.kubernetes.executor.volumes.persistentVolumeClaim.spark-local-dir-1.mount.path=/data/spark-x/executor-x
spark.shuffle.sort.io.plugin.class=org.apache.spark.shuffle.KubernetesLocalDiskShuffleDataIO

如果没有将任何卷设置为本地存储，Spark 会使用临时暂存空间将数据溢出到磁盘，以便在混洗和其他操作期间进行。当使用 Kubernetes 作为资源管理器时，pod 将使用 emptyDir 卷来创建，该卷为 spark.local.dir 中列出的每个目录或环境变量 SPARK_LOCAL_DIRS 挂载。如果没有明确指定目录，则会创建默认目录并进行适当配置。

emptyDir 卷使用 Kubernetes 的短暂存储功能，并且不会在 pod 的生命周期结束后持续存在。

使用 RAM 作为本地存储

emptyDir 卷默认使用支持节点的存储作为短暂存储，这种行为可能不适合某些计算环境。例如，如果您有使用通过网络挂载的远程存储的无盘节点，那么让大量执行器对该远程存储进行 IO 实际上可能会降低性能。

在这种情况下，您可能希望在配置中设置 spark.kubernetes.local.dirs.tmpfs=true，这将导致 emptyDir 卷被配置为 tmpfs，即 RAM 支持的卷。当以这种方式配置时，Spark 的本地存储使用量将计入您的 pod 内存使用量，因此您可能希望通过增加 spark.{driver,executor}.memoryOverheadFactor 的值来适当地增加您的内存请求。

自省和调试

这些是您可以用来调查正在运行/已完成的 Spark 应用程序、监控进度和采取操作的不同方法。

访问日志

可以使用 Kubernetes API 和 kubectl CLI 访问日志。当 Spark 应用程序正在运行时，可以使用以下命令从应用程序流式传输日志

$ kubectl -n=<namespace> logs -f <driver-pod-name>

如果在集群上安装了 Kubernetes 仪表板，也可以通过它访问相同的日志。

访问驱动程序 UI

可以使用 kubectl port-forward 在本地访问与任何应用程序关联的 UI。

$ kubectl port-forward <driver-pod-name> 4040:4040

然后，可以在 http://localhost:4040 上访问 Spark 驱动程序 UI。

调试

可能存在多种类型的故障。如果 Kubernetes API 服务器拒绝从 spark-submit 发出的请求，或者由于其他原因拒绝连接，则提交逻辑应指示遇到的错误。但是，如果在应用程序运行期间出现错误，通常，最好的调查方法可能是通过 Kubernetes CLI。

要获取有关驱动程序 pod 周围的调度决策的一些基本信息，您可以运行

$ kubectl describe pod <spark-driver-pod>

如果 pod 遇到运行时错误，可以使用以下命令进一步探测状态

$ kubectl logs <spark-driver-pod>

可以以类似的方式检查失败的执行器 pod 的状态和日志。最后，删除驱动程序 pod 将清理整个 spark 应用程序，包括所有执行器、关联的服务等。驱动程序 pod 可以被认为是 Spark 应用程序的 Kubernetes 表示。

Kubernetes 功能

配置文件

您的 Kubernetes 配置文件通常位于主目录的 .kube/config 下，或者位于 KUBECONFIG 环境变量指定的某个位置。Kubernetes 上的 Spark 将尝试使用此文件对用于与 Kubernetes 集群交互的 Kubernetes 客户端进行初始自动配置。提供各种 Spark 配置属性，允许进一步自定义客户端配置，例如使用替代身份验证方法。

上下文

Kubernetes 配置文件可以包含多个上下文，允许在不同的集群和/或用户身份之间切换。默认情况下，Kubernetes 上的 Spark 在对 Kubernetes 客户端进行初始自动配置时将使用您的当前上下文（可以通过运行 kubectl config current-context 来检查）。

为了使用替代上下文，用户可以通过 Spark 配置属性 spark.kubernetes.context 指定所需的上下文，例如 spark.kubernetes.context=minikube。

命名空间

Kubernetes 有 命名空间 的概念。命名空间是将集群资源划分为多个用户（通过资源配额）的方法。Kubernetes 上的 Spark 可以使用命名空间来启动 Spark 应用程序。这可以通过 spark.kubernetes.namespace 配置来实现。

Kubernetes 允许使用 ResourceQuota 来设置对单个命名空间的资源、对象数量等的限制。管理员可以将命名空间和 ResourceQuota 结合使用来控制在运行 Spark 应用程序的 Kubernetes 集群中的共享和资源分配。

RBAC

在启用了 RBAC 的 Kubernetes 集群中，用户可以配置 Kubernetes RBAC 角色和 Kubernetes 上的 Spark 组件使用的服务帐户来访问 Kubernetes API 服务器。

Spark 驱动程序 pod 使用 Kubernetes 服务帐户来访问 Kubernetes API 服务器，以创建和监视执行器 pod。驱动程序 pod 使用的服务帐户必须具有驱动程序能够执行其工作所需的适当权限。具体来说，至少，必须向服务帐户授予 Role 或 ClusterRole，允许驱动程序 pod 创建 pod 和服务。默认情况下，驱动程序 pod 会自动分配 spark.kubernetes.namespace 指定的命名空间中的 default 服务帐户，如果在 pod 创建时没有指定服务帐户。

根据 Kubernetes 部署的版本和设置，此 default 服务帐户可能具有或可能没有允许驱动程序 pod 在默认 Kubernetes RBAC 策略下创建 pod 和服务的权限。有时，用户可能需要指定具有授予的正确角色的自定义服务帐户。Kubernetes 上的 Spark 支持通过配置属性 spark.kubernetes.authenticate.driver.serviceAccountName=<service account name> 指定驱动程序 pod 要使用的自定义服务帐户。例如，要使驱动程序 pod 使用 spark 服务帐户，用户只需将以下选项添加到 spark-submit 命令中

--conf spark.kubernetes.authenticate.driver.serviceAccountName=spark

要创建自定义服务帐户，用户可以使用 kubectl create serviceaccount 命令。例如，以下命令创建一个名为 spark 的服务帐户

$ kubectl create serviceaccount spark

要向服务帐户授予 Role 或 ClusterRole，需要 RoleBinding 或 ClusterRoleBinding。要创建 RoleBinding 或 ClusterRoleBinding，用户可以使用 kubectl create rolebinding（或 clusterrolebinding 用于 ClusterRoleBinding）命令。例如，以下命令在 default 命名空间中创建一个 edit ClusterRole，并将其授予上面创建的 spark 服务帐户

$ kubectl create clusterrolebinding spark-role --clusterrole=edit --serviceaccount=default:spark --namespace=default

请注意，Role 只能用于授予对单个命名空间内的资源（如 pod）的访问权限，而 ClusterRole 可以用于授予对跨所有命名空间的集群范围资源（如节点）以及命名空间资源（如 pod）的访问权限。对于 Kubernetes 上的 Spark，由于驱动程序始终在同一个命名空间中创建执行器 pod，因此 Role 就足够了，尽管用户可以使用 ClusterRole 代替。有关 RBAC 授权以及如何为 pod 配置 Kubernetes 服务帐户的更多信息，请参阅 使用 RBAC 授权 和 为 Pod 配置服务帐户。

Spark 应用程序管理

Kubernetes 在集群模式下通过 spark-submit CLI 工具提供简单的应用程序管理。用户可以通过提交作业时打印的提交 ID 来杀死作业。提交 ID 遵循格式 namespace:driver-pod-name。如果用户省略了命名空间，则使用当前 k8s 上下文中设置的命名空间。例如，如果用户设置了特定的命名空间，如下所示 kubectl config set-context minikube --namespace=spark，则默认情况下将使用 spark 命名空间。另一方面，如果特定上下文中没有添加命名空间，则默认情况下将考虑所有命名空间。这意味着操作将影响与给定提交 ID 匹配的所有 Spark 应用程序，无论命名空间如何。此外，用于应用程序管理的 spark-submit 使用与用于提交驱动程序相同的后端代码，因此相同的属性（如 spark.kubernetes.context 等）可以重复使用。

例如

$ spark-submit --kill spark:spark-pi-1547948636094-driver --master k8s://https://192.168.2.8:8443

用户还可以使用 --status 标志列出应用程序状态

$ spark-submit --status spark:spark-pi-1547948636094-driver --master  k8s://https://192.168.2.8:8443

这两个操作都支持通配符模式。例如，用户可以运行

$ spark-submit --kill spark:spark-pi* --master  k8s://https://192.168.2.8:8443

以上操作将杀死所有具有特定前缀的应用程序。

用户可以通过 spark.kubernetes.appKillPodDeletionGracePeriod 属性指定 pod 终止的宽限期，使用 --conf 作为提供它的方式（所有 K8s pod 的默认值为 30 秒）。

未来工作

目前正在开发或计划开发一些 Spark on Kubernetes 功能。这些功能预计最终将包含在 spark-kubernetes 集成的未来版本中。

其中一些包括

• 外部 Shuffle 服务
• 作业队列和资源管理

配置

有关 Spark 配置的信息，请参见 配置页面。以下配置特定于 Spark on Kubernetes。

Spark 属性

Pod 模板属性

查看下表以获取将被 Spark 覆盖的 Pod 规范的完整列表。

Pod 元数据

Pod 规范

容器规范

以下内容会影响驱动程序和执行器容器。Pod 规范中的所有其他容器都不会受到影响。

资源分配和配置概述

请务必阅读 配置页面 上的自定义资源调度和配置概述部分。本节仅讨论资源调度的 Kubernetes 特定方面。

用户有责任正确配置 Kubernetes 集群以拥有可用的资源，并且理想情况下为每个容器隔离每个资源，以便资源不会在多个容器之间共享。如果资源未隔离，用户有责任编写发现脚本，以便资源不会在容器之间共享。有关使用 自定义资源 配置 Kubernetes 的详细信息，请参阅 Kubernetes 文档。

只要 Kubernetes 资源类型遵循 Kubernetes 设备插件格式的 vendor-domain/resourcetype，Spark 会自动处理将 Spark 配置 spark.{driver/executor}.resource.{resourceType} 转换为 Kubernetes 配置。用户必须使用 spark.{driver/executor}.resource.{resourceType}.vendor 配置指定供应商。如果您使用的是 Pod 模板，则用户无需显式添加任何内容。作为参考和示例，您可以查看 Kubernetes 文档以了解如何调度 GPU。Spark 仅支持设置资源限制。

Kubernetes 不会告诉 Spark 分配给每个容器的资源的地址。因此，用户必须指定一个发现脚本，该脚本在执行器启动时运行以发现哪些资源可用于该执行器。您可以在 examples/src/main/scripts/getGpusResources.sh 中找到示例脚本。该脚本必须设置执行权限，用户应设置权限以不允许恶意用户修改它。该脚本应将 ResourceInformation 类格式的 JSON 字符串写入 STDOUT。这包含资源名称和仅对该执行器可用的资源地址数组。

资源级别调度概述

Spark 在 Kubernetes 上支持几种资源级调度功能。

优先级调度

Kubernetes 默认支持 Pod 优先级。

Spark 在 Kubernetes 上允许通过 Pod 模板 定义作业的优先级。用户可以在驱动程序或执行器 Pod 模板的 spec 部分指定 priorityClassName。以下是一个示例，展示如何指定它

apiVersion: v1
Kind: Pod
metadata:
  labels:
    template-label-key: driver-template-label-value
spec:
  # Specify the priority in here
  priorityClassName: system-node-critical
  containers:
  - name: test-driver-container
    image: will-be-overwritten

用于 Spark on Kubernetes 的自定义 Kubernetes 调度器

Spark 允许用户指定自定义 Kubernetes 调度器。

1. 指定调度器名称。

   用户可以使用 spark.kubernetes.scheduler.name 或 spark.kubernetes.{driver/executor}.scheduler.name 配置指定自定义调度器。

2. 指定与调度器相关的配置。

   要配置自定义调度器，用户可以使用 Pod 模板，添加标签 (spark.kubernetes.{driver,executor}.label.*)、注释 (spark.kubernetes.{driver/executor}.annotation.*) 或特定于调度器的配置（例如 spark.kubernetes.scheduler.volcano.podGroupTemplateFile）。

3. 指定调度器功能步骤。

   用户还可以考虑使用 spark.kubernetes.{driver/executor}.pod.featureSteps 来支持更复杂的要求，包括但不限于

   • 为驱动程序/执行器调度创建额外的 Kubernetes 自定义资源。
   • 根据配置或现有 Pod 信息动态设置调度器提示。

使用 Volcano 作为 Spark on Kubernetes 的自定义调度器

先决条件

• 自 Spark v3.3.0 和 Volcano v1.7.0 起，支持使用 Volcano 作为自定义调度器的 Spark 在 Kubernetes 上。以下是一个安装 Volcano 1.7.0 的示例

  kubectl apply -f https://raw.githubusercontent.com/volcano-sh/volcano/v1.7.0/installer/volcano-development.yaml
  

构建

要创建与 Volcano 支持一起的 Spark 发行版（例如 Spark 下载页面 上分发的那些发行版），请参阅 “构建 Spark” 中的更多信息

./dev/make-distribution.sh --name custom-spark --pip --r --tgz -Psparkr -Phive -Phive-thriftserver -Pkubernetes -Pvolcano

用法

Spark 在 Kubernetes 上允许使用 Volcano 作为自定义调度器。用户可以使用 Volcano 来支持更高级的资源调度：队列调度、资源预留、优先级调度等等。

要使用 Volcano 作为自定义调度器，用户需要指定以下配置选项

# Specify volcano scheduler and PodGroup template
--conf spark.kubernetes.scheduler.name=volcano
--conf spark.kubernetes.scheduler.volcano.podGroupTemplateFile=/path/to/podgroup-template.yaml
# Specify driver/executor VolcanoFeatureStep
--conf spark.kubernetes.driver.pod.featureSteps=org.apache.spark.deploy.k8s.features.VolcanoFeatureStep
--conf spark.kubernetes.executor.pod.featureSteps=org.apache.spark.deploy.k8s.features.VolcanoFeatureStep

Volcano 功能步骤

Volcano 功能步骤帮助用户创建 Volcano PodGroup 并设置驱动程序/执行器 Pod 注释以链接到此 PodGroup。

请注意，目前 Volcano 功能步骤中仅支持驱动程序/作业级 PodGroup。

Volcano PodGroup 模板

Volcano 使用 CRD yaml 定义 PodGroup 规范。

与 Pod 模板 类似，Spark 用户可以使用 Volcano PodGroup 模板来定义 PodGroup 规范配置。为此，请指定 Spark 属性 spark.kubernetes.scheduler.volcano.podGroupTemplateFile 以指向 spark-submit 进程可访问的文件。以下是一个 PodGroup 模板示例

apiVersion: scheduling.volcano.sh/v1beta1
kind: PodGroup
spec:
  # Specify minMember to 1 to make a driver pod
  minMember: 1
  # Specify minResources to support resource reservation (the driver pod resource and executors pod resource should be considered)
  # It is useful for ensource the available resources meet the minimum requirements of the Spark job and avoiding the
  # situation where drivers are scheduled, and then they are unable to schedule sufficient executors to progress.
  minResources:
    cpu: "2"
    memory: "3Gi"
  # Specify the priority, help users to specify job priority in the queue during scheduling.
  priorityClassName: system-node-critical
  # Specify the queue, indicates the resource queue which the job should be submitted to
  queue: default

使用 Apache YuniKorn 作为 Spark on Kubernetes 的自定义调度器

Apache YuniKorn 是 Kubernetes 的资源调度器，它提供高级批处理调度功能，例如作业排队、资源公平性、最小/最大队列容量和灵活的作业排序策略。有关可用的 Apache YuniKorn 功能，请参阅 核心功能。

先决条件

安装 Apache YuniKorn

helm repo add yunikorn https://apache.github.io/yunikorn-release
helm repo update
helm install yunikorn yunikorn/yunikorn --namespace yunikorn --version 1.3.0 --create-namespace --set embedAdmissionController=false

以上步骤将在现有 Kubernetes 集群上安装 YuniKorn v1.3.0。

入门

使用以下额外选项提交 Spark 作业

--conf spark.kubernetes.scheduler.name=yunikorn
--conf spark.kubernetes.driver.label.queue=root.default
--conf spark.kubernetes.executor.label.queue=root.default
--conf spark.kubernetes.driver.annotation.yunikorn.apache.org/app-id={{APP_ID}}
--conf spark.kubernetes.executor.annotation.yunikorn.apache.org/app-id={{APP_ID}}

请注意，{{APP_ID}} 是内置变量，它将自动替换为 Spark 作业 ID。使用上述配置，作业将由 YuniKorn 调度器而不是默认的 Kubernetes 调度器调度。

阶段级别调度概述

Kubernetes 上支持阶段级调度

• 当动态分配被禁用时：它允许用户在阶段级别指定不同的任务资源需求，并将使用启动时请求的相同执行器。
• 当动态分配被启用时：它允许用户在阶段级别指定任务和执行器资源需求，并将请求额外的执行器。这也要求启用 spark.dynamicAllocation.shuffleTracking.enabled，因为 Kubernetes 目前不支持外部 shuffle 服务。从 Kubernetes 请求不同配置文件的容器的顺序不受保证。请注意，由于 Kubernetes 上的动态分配需要 shuffle 跟踪功能，这意味着来自先前阶段的执行器（使用不同的 ResourceProfile）可能不会因其上的 shuffle 数据而超时。这会导致使用更多集群资源，在最坏的情况下，如果 Kubernetes 集群上没有剩余资源，则 Spark 可能挂起。您可以考虑查看配置 spark.dynamicAllocation.shuffleTracking.timeout 以设置超时，但这会导致如果确实需要 shuffle 数据，则必须重新计算数据。请注意，基本默认配置文件和自定义 ResourceProfile 之间处理 Pod 模板资源的方式有所不同。Pod 模板文件中指定的任何资源仅与基本默认配置文件一起使用。如果您创建自定义 ResourceProfile，请确保在其中包含所有必要的资源，因为来自模板文件中的资源不会传播到自定义 ResourceProfile。