在Kubernetes上运行Spark

• 安全性
  • 用户身份
  • 卷挂载
• 前提条件
• 工作原理
• 将应用程序提交到 Kubernetes
  • Docker 镜像
  • 集群模式
  • 客户端模式
    • 客户端模式网络
    • 客户端模式执行器 Pod 垃圾回收
    • 身份验证参数
  • IPv4 和 IPv6
  • 依赖管理
  • 秘密管理
  • Pod 模板
  • 使用 Kubernetes 卷
    • PVC导向的执行器 Pod 分配
  • 本地存储
    • 使用 RAM 作为本地存储
  • 内省与调试
    • 访问日志
    • 访问驱动程序 UI
    • 调试
  • Kubernetes 特性
    • 配置文件
    • 上下文
    • 命名空间
    • RBAC
  • Spark 应用程序管理
  • 未来工作
• 配置
  • Spark 属性
  • Pod 模板属性
  • Pod 元数据
  • Pod 规格
  • 容器规格
  • 资源分配和配置概述
  • 资源级调度概述
    • 优先级调度
    • 针对 Kubernetes 上的 Spark 的定制 Kubernetes 调度器
    • 使用 Volcano 作为 Kubernetes 上 Spark 的定制调度器
      • 前提条件
      • 构建
      • 使用
      • 火山特性步骤
      • 火山 PodGroup 模板
    • 使用 Apache YuniKorn 作为 Kubernetes 上 Spark 的定制调度器
      • 前提条件
      • 开始使用
  • 阶段级调度概述

Spark可以在由 Kubernetes 管理的集群上运行。这个特性利用了已经被添加到Spark中的原生Kubernetes调度器。

安全

安全功能如身份验证默认情况下是未启用的。当部署一个开放的集群到互联网或不受信任的网络时，保护对集群的访问以防止未经授权的应用程序在集群上运行是很重要的。在运行Spark之前，请查看 Spark安全性 以及本文档中的具体安全部分。

用户身份

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

或者，可以使用 Pod 模板 功能为 Spark 提交的 pod 添加 安全上下文 ，其中包含 runAsUser 。这可以用来覆盖镜像中的 USER 指令。请注意，这需要用户的配合，因此可能不适合用于共享环境。如果集群管理员希望限制 pods 可以以哪些用户身份运行，应该使用 Pod 安全策略 。

卷挂载

如本文档后面在 使用Kubernetes卷 一节中所述，Spark在K8S上提供了配置选项，允许将某些卷类型挂载到驱动程序和执行程序的pod中。尤其是，它允许使用 hostPath 卷，正如Kubernetes文档中所描述的，这些卷存在已知的安全漏洞。

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

先决条件

• 一个运行版本 >= 1.24 的 Kubernetes 集群，且已配置使用 kubectl 进行访问。如果您还没有一个正常工作的 Kubernetes 集群， 您可以使用 minikube 在本地机器上设置一个测试集群。
  • 我们建议使用最新版本的 minikube，并启用 DNS 插件。
  • 请注意，默认的 minikube 配置不足以运行 Spark 应用。我们建议使用 3 个 CPU 和 4g 的内存，以便能够启动一个简单的 Spark 应用，并使用单个执行器。
  • 检查 kubernetes-client library 与您的 Spark 环境的版本，以及它与您 Kubernetes 集群版本的兼容性。
• 您必须具有适当的权限以列出、创建、编辑和删除 pods 在您的集群中。您可以通过运行 kubectl auth can-i pods 来验证您是否可以列出这些资源。
  • 驱动程序 pods 使用的服务账户凭证必须被允许创建 pods、服务和 configmaps。
• 您必须在集群中配置 Kubernetes DNS 。

它是如何工作的

spark-submit 可以直接用于向Kubernetes集群提交Spark应用程序。 提交机制如下：

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

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

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

向Kubernetes提交应用程序

Docker 镜像

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

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

示例用法为：

$ ./bin/docker-image-tool.sh -r  -t my-tag 构建
$ ./bin/docker-image-tool.sh -r  -t my-tag 推送

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

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

示例用法是

# 构建额外的 PySpark docker 镜像
$ ./bin/docker-image-tool.sh -r  -t my-tag -p ./kubernetes/dockerfiles/spark/bindings/python/Dockerfile build

# 构建额外的 SparkR docker 镜像
$ ./bin/docker-image-tool.sh -r  -t my-tag -R ./kubernetes/dockerfiles/spark/bindings/R/Dockerfile build

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

集群模式

要以集群模式启动 Spark Pi，

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

Spark 主节点可以通过将 --master 命令行参数传递给 spark-submit 或通过在应用程序的配置中设置 spark.master 来指定，必须是格式为 k8s:// : 的 URL。端口必须始终指定，即使是 HTTPS 端口 443。主节点字符串前面加上 k8s:// 将导致 Spark 应用程序在 Kubernetes 集群上启动，并且 API 服务器位于 api_server_url 。如果在 URL 中未指定 HTTP 协议，默认使用 https 。例如，将主节点设置为 k8s://example.com:443 相当于将其设置为 k8s://https://example.com:443 ，但要在不同端口上无 TLS 连接，则主节点应设置为 k8s://http://example.com:8080 。

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

如果您有一个 Kubernetes 集群设置，可以通过执行 kubectl cluster-info 来发现 apiserver 的 URL。

$ kubectl cluster-info
Kubernetes master 正在运行于 http://127.0.0.1:6443

在上面的示例中，可以通过将 spark-submit 的参数指定为 --master k8s://http://127.0.0.1:6443 来使用特定的 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 在客户端模式下所需的具体网络配置会因设置而异。如果您在 Kubernetes Pod 内运行驱动程序，可以使用一个 无头服务 来允许您的驱动程序 Pod 通过稳定的主机名从执行器进行路由。当部署您的无头服务时，确保服务的标签选择器仅匹配驱动程序 Pod，而不匹配其他 Pod；建议为您的驱动程序 Pod 分配一个足够独特的标签，并在无头服务的标签选择器中使用该标签。通过 spark.driver.host 指定驱动程序的主机名，并将您的 Spark 驱动程序的端口指定为 spark.driver.port 。

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

如果您在一个 pod 中运行 Spark 驱动程序，强烈建议将 spark.kubernetes.driver.pod.name 设置为该 pod 的名称。 当设置此属性时，Spark 调度程序将以带有 OwnerReference 的方式部署执行器 pod，这反过来将确保一旦驱动程序 pod 从集群中删除，应用程序的所有执行器 pod 也将被删除。驱动程序将在由 spark.kubernetes.namespace 指定的命名空间中查找给定名称的 pod，并且将一个指向该 pod 的 OwnerReference 添加到每个执行器 pod 的 OwnerReferences 列表中。请小心避免将 OwnerReference 设置为实际上不是该驱动程序 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的环境中运行，该功能允许为Pods和Services分配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:///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]= 。类似地，格式为 spark.kubernetes.executor.secrets.[SecretName]= 的配置属性可用于将用户指定的秘密挂载到执行器容器中。请注意，假设要挂载的秘密与驱动程序和执行器 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 开始。有关详细信息，请参见 完整列表 ，其中列出了将被 spark 覆盖的 pod 模板值。

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=<挂载路径>
--conf spark.kubernetes.driver.volumes.[VolumeType].[VolumeName].mount.readOnly=
--conf spark.kubernetes.driver.volumes.[VolumeType].[VolumeName].mount.subPath=<挂载子路径>

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

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

spark.kubernetes.driver.volumes.[卷类型].[卷名称].选项.[选项名称]=<值>

例如，一个名为 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=按需
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 Properties 部分。

基于PVC的执行器Pod分配

由于磁盘是重要的资源类型之一，Spark驱动程序通过一组配置提供了细粒度的控制。例如，默认情况下，按需PVC由执行器拥有，PVC的生命周期与其拥有者执行器紧密耦合。然而，在Spark作业的生命周期内，按需PVC可以由驱动程序拥有，并在执行器之间重复使用，方法如下。这减少了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=<挂载路径>
--conf spark.kubernetes.driver.volumes.[VolumeType].spark-local-dir-[VolumeName].mount.readOnly=false

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

spark.kubernetes.executor.volumes.persistentVolumeClaim.spark-local-dir-1.options.claimName=按需
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 作为资源管理器时，Pods 将为 spark.local.dir 中列出的每个目录创建一个挂载了 emptyDir 卷的 Pod，或者使用环境变量 SPARK_LOCAL_DIRS 。如果没有显式指定目录，则会创建一个默认目录并进行适当配置。

emptyDir 卷使用了 Kubernetes 的临时存储功能，并且在 pod 的生命周期结束后不会持久化。

使用RAM进行本地存储

emptyDir 卷默认使用节点的后备存储作为临时存储，这种行为可能不适合某些计算环境。例如，如果您有无磁盘节点，并且通过网络挂载了远程存储，很多执行器对该远程存储进行IO操作实际上可能会降低性能。

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

内省和调试

这些是你可以用来调查正在运行/已完成的 Spark 应用程序、监控进度以及采取行动的不同方式。

访问日志

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

$ kubectl -n=<命名空间> logs -f <驱动程序pod名称>

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

当存在日志收集系统时，您可以在 Spark Driver Executors 选项卡 UI 中公开它。例如，

spark.executorEnv.SPARK_EXECUTOR_ATTRIBUTE_APP_ID='$(SPARK_APPLICATION_ID)'
spark.executorEnv.SPARK_EXECUTOR_ATTRIBUTE_EXECUTOR_ID='$(SPARK_EXECUTOR_ID)'
spark.ui.custom.executor.log.url='https://log-server/log?appId=&execId='

访问驱动程序用户界面

与任何应用程序相关的用户界面可以通过本地访问 kubectl port-forward 。

$ kubectl port-forward  4040:4040

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

调试

可能会有几种类型的失败。如果Kubernetes API服务器拒绝来自spark-submit的请求，或者出于其他原因拒绝连接，提交逻辑应指示所遇到的错误。然而，如果在应用程序运行过程中出现错误，通常，调查的最佳方法可能是通过Kubernetes CLI。

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

$ kubectl describe pod 

如果容器遇到了运行时错误，可以通过以下方式进一步探测状态：

$ kubectl logs 

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

Kubernetes 特性

配置文件

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

上下文

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

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

命名空间

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

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

基于角色的访问控制

在启用 RBAC 的Kubernetes集群中，用户可以配置Kubernetes RBAC角色和服务账户，以便不同的Spark on Kubernetes组件访问Kubernetes API服务器。

Spark 驱动程序 Pod 使用 Kubernetes 服务账号访问 Kubernetes API 服务器，以创建和监视执行程序 Pod。驱动程序 Pod 使用的服务账号必须具有适当的权限，以便驱动程序能够完成其工作。具体来说，服务账号至少必须被授予一个 Role 或 ClusterRole ，以允许驱动程序 Pod 创建 Pod 和服务。默认情况下，如果在 Pod 创建时未指定服务账号，驱动程序 Pod 将自动分配到 default 服务账号，该服务账号位于由 spark.kubernetes.namespace 指定的命名空间中。

根据部署的Kubernetes版本和设置，默认的 default 服务账户可能具有或不具有允许驱动程序pod在默认Kubernetes RBAC 策略下创建pod和服务的角色。有时用户可能需要指定一个拥有正确角色的自定义服务账户。Spark在Kubernetes上支持通过配置属性 spark.kubernetes.authenticate.driver.serviceAccountName= 指定用于驱动程序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 只能用于授予对单个命名空间内的资源（例如pods）的访问权限，而 ClusterRole 可以用于授予对集群范围内的资源（例如nodes）以及跨所有命名空间的命名空间资源（如pods）的访问权限。对于在Kubernetes上的Spark，由于驱动程序始终在同一命名空间中创建执行器pods，因此 Role 就足够了，尽管用户也可以使用 ClusterRole 。有关RBAC授权和如何为pods配置Kubernetes服务账户的更多信息，请参考 使用RBAC授权 和 为Pods配置服务账户 。

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 秒 ）。

未来工作

目前正在开发或计划开发多个在Kubernetes上的Spark特性。这些特性预计最终将会纳入未来版本的spark-kubernetes集成中。

其中一些包括：

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

配置

请查看 配置页面 获取有关Spark配置的信息。以下配置是针对Kubernetes上的Spark特定的。

Spark 属性

Pod 模板属性

请查看下表以获取将被spark覆盖的pod规格的完整列表。

Pod 元数据

Pod 规范

容器规范

以下内容会影响驱动程序和执行程序容器。其他在 pod 规格中的容器将不受影响。

资源分配与配置概述

请确保您已阅读 配置页面 上的自定义资源调度和配置概述部分。本节仅讲述与Kubernetes特定的资源调度相关的内容。

用户负责正确配置Kubernetes集群，以确保资源可用，并理想上为每个容器隔离每个资源，以便资源不会在多个容器之间共享。如果资源没有被隔离，用户需要负责编写发现脚本，以确保资源不在容器之间共享。有关如何使用 自定义资源 配置Kubernetes的详细信息，请参阅Kubernetes文档。

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

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

资源水平调度概述

Spark在Kubernetes上支持几种资源级调度特性。

优先级调度

Kubernetes 默认支持 Pod 优先级 。

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

apiVersion: v1
Kind: Pod
metadata:
labels:
template-label-key: driver-template-label-value
spec:
# 在这里指定优先级
priorityClassName: system-node-critical
containers:
- name: test-driver-container
image: will-be-overwritten

针对Kubernetes上Spark的定制化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 信息动态设置调度器提示。

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

先决条件

• 自 Spark v3.3.0 和 Volcano v1.7.0 以来，支持在 Kubernetes 上使用 Volcano 作为自定义调度程序。下面是安装 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 自定义-spark --pip --r --tgz -Psparkr -Phive -Phive-thriftserver -Pkubernetes -Pvolcano

用法

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

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

# 指定火山调度器和 PodGroup 模板
--conf spark.kubernetes.scheduler.name=volcano
--conf spark.kubernetes.scheduler.volcano.podGroupTemplateFile=/path/to/podgroup-template.yaml
# 指定驱动程序/执行程序 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

火山特征步骤

火山功能步骤帮助用户创建一个火山 PodGroup，并设置驱动程序/执行器 pod 注解以链接此 PodGroup 。

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

火山 PodGroup 模板

火山通过使用 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:
# 将 minMember 设置为 1 以创建驱动程序 Pod
minMember: 1
# 指定 minResources 以支持资源预留（驱动程序 Pod 资源和执行器 Pod 资源应予以考虑）
# 这对于确保可用资源满足 Spark 作业的最低要求以及避免
# 驱动程序已调度，但无法调度足够的执行器以实现进展的情况。
minResources:
cpu: "2"
memory: "3Gi"
# 指定优先级，帮助用户在调度时指定队列中的作业优先级。
priorityClassName: system-node-critical
# 指定队列，表示作业应提交到的资源队列
queue: default

在 Kubernetes 上使用 Apache YuniKorn 作为 Spark 的定制调度器

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

先决条件

安装 Apache YuniKorn：

helm repo add yunikorn https://apache.github.io/yunikorn-release
helm repo update
helm 安装 yunikorn yunikorn/yunikorn --命名空间 yunikorn --版本 1.3.0 --创建命名空间 --设置 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不支持外部洗牌服务。从Kubernetes请求不同配置文件的容器的顺序是不保证的。请注意，由于Kubernetes上的动态分配需要洗牌跟踪功能，这意味着来自先前阶段的使用了不同资源配置文件的执行器可能不会因为有洗牌数据在上面而空闲超时。这可能会导致使用更多的集群资源，最糟糕的情况是，如果Kubernetes集群上没有剩余资源，则Spark可能会挂起。您可以考虑查看配置 spark.dynamicAllocation.shuffleTracking.timeout 来设置超时，但如果洗牌数据确实需要，这可能会导致数据必须重新计算。 注意，基本默认配置文件和自定义资源配置文件之间的pod模板资源处理方式是不同的。在pod模板文件中指定的任何资源将仅与基本默认配置文件一起使用。如果您创建自定义资源配置文件，请务必在其中包含所有必要的资源，因为模板文件中的资源不会传播到自定义资源配置文件。