GB200 A4X 自建 Kubernetes 1.34.1
端到端部署与验证指南
DRANET + ComputeDomain(官方推荐路径)

日期:2026-06-19
平台:NVIDIA GB200 (A4X) · ARM64 · NVL72 · TLinux 4
Kubernetes:1.34.1 (kubeadm) + Calico v3.29.3
GPU 管理:nvidia-device-plugin v0.17.1 + DRA GPU Driver v25.12.0 (ComputeDomain)
RDMA 访问:DRANET v1.3.0(SIG DRA 网络驱动)
IMEX 管理:ComputeDomain CRD(DRA GPU Driver 原生,官方文档)
DRA:k8s 1.34 DRA GA · API resource.k8s.io/v1
容器:NGC pytorch:26.05-py3 · TransformerEngine v2.15 · Megatron-LM core_r0.16.0
网络:GIB v1.1.2 (NCCL 2.30.4+cuda13.0) · 4×CX-7 400Gbps MRDMA

架构说明:本文档采用 DRANET + ComputeDomain 单一路径—— 这是 NVIDIA 官方推荐的 k8s + DRA 原生路径,所有 MNNVL 资源(IMEX channel + RDMA NIC)均通过 ResourceClaim 声明式管理。
关于 ComputeDomain 与资源分配粒度:GB200 NVL72 以 Domain(18 节点 / 72 GPU)为最小资源分配单位。ComputeDomain 按物理域拓扑自动发现和管理 IMEX daemon。当 Domain 中仅部署部分节点时,ComputeDomain 仍会为全部 18 个物理位置生成 IMEX 配置,未部署的节点位置会产生连接重试日志(无害,可忽略)。
重要:一个 Domain 内同一时间只能有一个 ComputeDomain 实例,且同一节点只能加入一个 ComputeDomain(参考)。因此,日后生产环境中资源分配应以整个 Domain 为单位。

目录

0. 架构概述与核心概念

阅读建议:本章面向首次接触 GB200/A4X 的工程师,梳理硬件架构、GCP 机型差异、以及部署过程中频繁出现的核心概念。已有经验的读者可跳至第 1 章。

0.1 硬件架构对比

下表对比三代 GPU 平台的关键硬件差异——这些差异直接决定了部署方式和可达性能。

维度 GB200 (Blackwell) B200 (Blackwell) H200 (Hopper)
GPU 架构 Blackwell (sm_100) Blackwell (sm_100) Hopper (sm_90)
NVLink 代际 第 5 代 NVLink 第 5 代 NVLink 第 4 代 NVLink
NVSwitch 第 5 代 · 支持 MNNVL 跨节点 NVLink 第 5 代 · 支持 MNNVL(受限) 第 4 代 · 仅节点内 NVLink
NVLink 域大小 72 GPU(NVL72:18 节点跨节点互联) 16 GPU(NVL16:2 节点) 8 GPU(仅节点内)
CPU Grace ARM64 (aarch64) x86_64 x86_64
显存 HBM3e HBM3e HBM3e
关键差异:GB200 的 NVL72 域将 18 个节点的 72 块 GPU 通过 NVSwitch 互联,峰值双向带宽约 840 GB/s(每 GPU 对)。而跨域通信只能走 RDMA,峰值约 325 GB/s,差距约 2.5 倍。因此,将同一训练任务的所有节点放入同一 NVL72 域是性能优化的第一要务。

参考来源: NVIDIA GB200 NVL72 · NVIDIA NVLink(含各代带宽对比)

0.2 GCP 机型对比

GB200/B200/H200 在 GCP 上对应不同的 Accelerator-Optimized 机型系列,网络拓扑和部署方式存在显著差异。

维度 A4X (GB200) A4 (B200) A3 Ultra (H200)
机型示例 a4x-highgpu-4g a4-highgpu-8g a3-ultragpu-8g
GPU / 节点 4 (GB200) 8 (B200) 8 (H200)
CPU 架构 ARM64 (Grace) x86_64 x86_64
RDMA NIC 4 × CX-7 400Gbps 8 × CX-7 400Gbps 8 × CX-7 400Gbps
NVLink 域 18 节点 / 72 GPU(NVL72) 2 节点 / 16 GPU(NVL16) N/A(仅节点内 NVLink)
MNNVL 跨节点 NVLink 支持(需 IMEX daemon) 支持(受限,2 节点) 不支持
Placement Policy 拓扑 1x72 1x16 N/A
容器镜像注意事项 需 ARM64 / aarch64 镜像 标准 x86_64 镜像 标准 x86_64 镜像
A4X ARM64 注意:GB200 使用 Grace ARM64 CPU,所有容器镜像(包括 NCCL 插件、NVSHMEM 编译产物等)必须为 aarch64 架构。GIB NCCL 插件镜像名需带 -arm64 后缀。

参考来源: GCP Accelerator-Optimized Machines (A4X) · Placement Policy 概述

0.3 核心概念速查

下表汇总本指南中频繁出现的技术术语,方便随时查阅。

概念 说明
NVL72 Domain 18 个 A4X 节点(72 块 GB200 GPU)通过第 5 代 NVSwitch 组成的跨节点 NVLink 互联域。域内任意 GPU 对可通过 NVLink 直接通信,峰值双向带宽约 840 GB/s。域外通信只能走 RDMA(约 325 GB/s)。
MNNVL
(Multi-Node NVLink)
跨节点 NVLink 通信能力。GB200 NVL72 的核心特性——使同一域内不同物理节点的 GPU 像节点内一样通过 NVLink 互联。需要 IMEX daemon 运行才能启用。
IMEX Daemon
(Inter-node Memory Exchange)
管理跨节点 NVLink channel 的用户态守护进程 (nvidia-imex)。NVLS transport 的 cuMulticastCreate 依赖 IMEX 协调。若 IMEX 未运行,NCCL 会静默回退到 RDMA(带宽从 ~840 GB/s 降到 ~326 GB/s),且报 CUDA error 801。
ComputeDomain Kubernetes DRA CRD(由 DRA GPU Driver 提供),用于在 k8s 中声明式管理 IMEX daemon 生命周期。创建 ComputeDomain 后,域内每个节点自动启动 IMEX daemon pod,Pod 通过 ResourceClaimTemplate 引用 ComputeDomain 即可获得 MNNVL 能力。每个节点同一时间只能属于一个 ComputeDomain。
DRA
(Dynamic Resource Allocation)
Kubernetes 原生的硬件资源请求 API(k8s 1.33+ GA,API 版本 resource.k8s.io/v1)。Pod 通过 ResourceClaim 声明式申请 GPU、RDMA NIC 等设备,由 scheduler 和 DRA driver 协同分配。
DRANET 基于 DRA 的 RDMA NIC 分配驱动(GitHub,本指南使用 v1.3.0)。将 CX-7 RDMA NIC 作为 DRA 设备发布到 ResourceSlice,Pod 通过 ResourceClaim 请求 RDMA 设备,实现 GPU-NIC PCIe 拓扑感知的精确分配。
GIB
(NCCL/gIB)
Google 提供的 NCCL 通信插件套件(本指南使用 v1.1.2),包含三个 NCCL 插件:Net 插件(GPUDirect RDMA 传输)、Env 插件(平台自动检测与环境变量配置)、Profiler 插件(GPUViz 遥测)。内置 NCCL 2.30.4,以 init container 方式注入到 Pod。详见 0.4 节。
Placement Policy GCP 资源策略,确保一组 VM 被分配到同一个物理 NVL72 域。A4X 使用 --collocation=COLLOCATED --gpu-topology=1x72 创建,每个 NVL72 域绑定一个 Placement Policy。生产环境中 N 个域需创建 N 个 Policy。

概念关系图

┌─────────────────── NVL72 Domain (18 节点 / 72 GPU) ───────────────────┐
│                                                                        │
│  ┌─ Node 1 ──┐  ┌─ Node 2 ──┐       ┌─ Node 18 ─┐                    │
│  │ 4× GB200  │  │ 4× GB200  │  ...  │ 4× GB200  │                    │
│  │ 4× CX-7   │  │ 4× CX-7   │       │ 4× CX-7   │                    │
│  └─────┬─────┘  └─────┬─────┘       └─────┬─────┘                    │
│        │               │                    │                          │
│        └───── NVSwitch (MNNVL, ~840 GB/s) ──┘                         │
│                                                                        │
│  Placement Policy (1x72) ── 确保 VM 落在同一物理域                       │
│  ComputeDomain CRD ── 管理 IMEX daemon,启用 MNNVL                     │
│  DRANET ── 分配 CX-7 RDMA NIC 给 Pod                                  │
│  GIB ── NCCL 通信插件,优化 GPU RDMA                                    │
└────────────────────────────────────────────────────────────────────────┘
        │ 跨域通信 (RDMA only, ~325 GB/s)
┌───────┴──────── 另一个 NVL72 Domain ──────────────────────────────────┐
│  ...                                                                   │
└────────────────────────────────────────────────────────────────────────┘

0.4 GIB 与 A4X 网络拓扑

0.4.1 A4X 硬件网络拓扑

A4X(a4x-megagpu-8g)基于 NVIDIA GB200 NVL72 架构,每个物理域(domain)包含 18 台 VM,共 72 颗 GPU。网络互联分为两层:

互联层级技术带宽适用场景
域内(Intra-domain) NVSwitch + NVLink(MNNVL) ~840 GB/s(双向) 同域 18 节点间的 GPU-to-GPU 直接访问;由 ComputeDomain CRD 管理 IMEX daemon 启用
域间(Inter-domain) RoCEv2 over CX-7(GPUDirect RDMA) ~325 GB/s(4×CX-7 × 400Gbps) 跨域节点间通信;通过 DRANET 分配 CX-7 网卡给 Pod

Rail-Optimized 网络:每台 A4X VM 配备 4 块 ConnectX-7 RDMA 网卡(gpu-rdma-X),采用 Rail-Optimized 拓扑。在此拓扑中,每块 GPU 对应一条固定的 RDMA "rail"(通道),同一 rail 编号的 GPU 和 NIC 跨节点对齐。NCCL 的 PXN(Proxy through NVLink)机制允许 GPU 借助 NVLink 经由对端 GPU 的 NIC 发送数据,从而利用所有 rail 的带宽。GIB 通过 NCCL_PXN_C2C=1 启用此优化。

┌─── A4X Node (a4x-megagpu-8g) ───────────────────────────────────┐
│                                                                   │
│  ┌─ Grace CPU ──────────────────────────────────────────────────┐ │
│  │  ARM64 (Neoverse V2) · 72 cores · 480GB+ LPDDR5X            │ │
│  └──────────────┬───────────────────────────────────────────────┘ │
│                 │ C2C (Chip-to-Chip)                              │
│  ┌──────────────┴───────────────────────────────────────────────┐ │
│  │  4× GB200 GPU · 192GB HBM3e each · 768GB total              │ │
│  │     GPU0 ─── rail0 ─── CX-7 #0 (gpu-rdma-0, 400Gbps)       │ │
│  │     GPU1 ─── rail1 ─── CX-7 #1 (gpu-rdma-1, 400Gbps)       │ │
│  │     GPU2 ─── rail2 ─── CX-7 #2 (gpu-rdma-2, 400Gbps)       │ │
│  │     GPU3 ─── rail3 ─── CX-7 #3 (gpu-rdma-3, 400Gbps)       │ │
│  └──────────────────────────────────────────────────────────────┘ │
│        │               NVSwitch Fabric (MNNVL)                    │
│        └──── connects to other 17 nodes in same domain ──────    │
│                                                                   │
│  存储:12TB NVMe SSD(自动挂载,无需 --local-ssd)                 │
└───────────────────────────────────────────────────────────────────┘

GCP 物理拓扑层级(官方文档):GCP 将 GPU 实例的物理位置划分为四个层级,层级越低物理距离越近、延迟越低:

Placement Policy 的 max-distance=1 确保实例落在同一 sub-block(同一 NVL72 域),从而获得 NVSwitch MNNVL 互联。NCCL 通过 NCCL_MNNVL_ENABLE 环境变量控制是否启用 MNNVL 路径,ComputeDomain CRD 负责在域内节点上运行 IMEX daemon 使 MNNVL 可用。

0.4.2 GIB 架构与三插件体系

GIB(本指南使用 v1.1.2)是 Google 为 GCP GPU 实例优化的 NCCL 插件套件,以 init container 方式注入到 Pod 中,安装路径为 /usr/local/gib。它包含三个独立的 NCCL 插件:

插件库文件NCCL 插件类型功能
Net 插件 libnccl-net.so NCCL_NET(通过 NCCL_NET=gIB 激活) GPUDirect RDMA 传输层实现,替代默认的 IB Verbs 传输。针对 GCP 网络环境优化了 RDMA 数据路径,支持 Adaptive Routing 等特性。
Env 插件 libnccl-env-gcp.so NCCL_ENV(通过 NCCL_ENV_PLUGIN=gcp 或 set_nccl_env.sh 激活) 平台自动检测插件。运行时从 GCP Metadata Server 获取实例类型、拓扑信息,自动加载对应平台的最优 NCCL 环境变量。无需用户手动设置 NCCL 调优参数。
Profiler 插件 libnccl-profiler.so + libGPUViz.so NCCL_PROFILER 可选的性能分析插件。将 NCCL 集合通信操作的时间数据导出至 GPUViz 遥测系统,用于性能调优和问题诊断。

0.4.3 Env 插件的平台自动检测机制

GIB v1.1.2 的推荐使用方式是通过 set_nccl_env.sh 脚本,该脚本仅设置一个环境变量:

export NCCL_ENV_PLUGIN=gcp

当 NCCL 初始化时,libnccl-env-gcp.so 插件(Env 插件)被自动加载,执行以下流程:

  1. 查询 GCP Metadata Server 获取实例机型(如 a4x-megagpu-8g)
  2. 识别对应平台,加载 /usr/local/gib/configs/nccl.<platform>.conf 配置文件
  3. 将配置文件中的键值对设为 NCCL 环境变量
  4. 向 NCCL 传递 CliqueId/ClusterUUID 拓扑信息(用于 MNNVL 域识别)

GIB v1.1.2 内置的平台配置文件:

/usr/local/gib/configs/
├── nccl.a3.conf          # A3 (H100)
├── nccl.a3plus.conf      # A3+ (H200)
├── nccl.a3edge.conf      # A3 Edge
├── nccl.a4.conf          # A4 (B200 NVL)
├── nccl.a4x.conf         # A4X (GB200 NVL72)  ← 本指南使用
└── nccl.a4xmax.conf      # A4X Max

A4X 平台配置(nccl.a4x.conf 核心内容):

NCCL_NET=gIB                    # 使用 GIB Net 插件替代默认 IB Verbs
NCCL_PXN_C2C=1                  # 启用 PXN over C2C(Rail-Optimized 拓扑关键)
NCCL_IB_ADAPTIVE_ROUTING=1      # 启用 InfiniBand Adaptive Routing
NCCL_IB_QPS_PER_CONNECTION=4    # 每连接 4 个 QP(匹配 4 条 rail)
NCCL_IB_TC=52                   # 数据流量 Traffic Class
NCCL_IB_FIFO_TC=84              # 控制流量 Traffic Class
NCCL_TUNER_PLUGIN=none          # 禁用外部 tuner(使用 NCCL 内置调优)
为什么不手动设置这些参数? GIB v1.1.2 之前的版本需要用户在 Pod YAML 中手动设置大量 NCCL 环境变量(如 NCCL_NET、NCCL_IB_* 等)。Env 插件的引入使得用户只需设置 NCCL_ENV_PLUGIN=gcp(或运行 set_nccl_env.sh),即可获得 Google 针对特定平台验证过的最优配置。这种方式的优势:
• 避免手动配置错误(参数组合复杂且平台间差异大)
• 平台升级/新参数引入时只需更新 GIB 版本,无需修改 Pod YAML
• Env 插件可获取运行时拓扑信息(如 MNNVL 域标识),这些信息在 YAML 编写时不可知

0.4.4 GIB Init Container 使用模式

在 Kubernetes 中,GIB 以 init container 方式部署。典型配置:

initContainers:
- name: gib-installer
  image: us-docker.pkg.dev/gce-ai-infra/gpudirect-gib/nccl-plugin-gib:v1.1.2
  imagePullPolicy: Always
  command: ["/scripts/container_entry.sh", "install", "--nccl"]
  volumeMounts:
  - name: gib
    mountPath: /usr/local/gib
  env:
  - name: LD_LIBRARY_PATH
    value: /usr/local/gib/lib64

安装完成后,/usr/local/gib 目录包含:

/usr/local/gib/
├── lib64/
│   ├── libnccl.so.2.30.4      # 内置 NCCL 2.30.4+cuda13.0
│   ├── libnccl-net.so          # GIB Net 插件
│   ├── libnccl-env-gcp.so      # GIB Env 插件
│   ├── libnccl-profiler.so     # GIB Profiler 插件
│   └── libGPUViz.so            # GPUViz 遥测库
├── configs/
│   ├── nccl.a4x.conf           # 各平台 NCCL 配置
│   └── ...
└── scripts/
    └── set_nccl_env.sh         # 环境变量设置脚本

主容器需要设置以下环境变量以使 GIB 生效:

env:
- name: LD_LIBRARY_PATH
  value: /usr/local/gib/lib64
- name: NCCL_NET_PLUGIN
  value: /usr/local/gib/lib64/libnccl-net.so
- name: NCCL_ENV_PLUGIN
  value: gcp                     # 触发 Env 插件自动检测
NCCL 版本注意:GIB v1.1.2 内置 NCCL 2.30.4(CUDA 13.0)。客户无需(也不应)在镜像中自行编译安装 NCCL 核心库,以防与 GIB 的 libnccl-net.so 产生符号冲突。如果容器基础镜像自带其他版本的 NCCL,需通过 LD_LIBRARY_PATH 确保优先加载 GIB 目录下的版本。版本不匹配会导致 NCCL 初始化失败或性能下降。

无公开仓库:截至本文写作时,GIB 没有公开的 GitHub 仓库或独立文档页面。配置参考以 GIB 容器镜像内置的配置文件为准。GIB 容器镜像托管在 us-docker.pkg.dev/gce-ai-infra/gpudirect-gib/。

0.4.5 域内 vs 域间通信路径总结

域内(Same Domain)域间(Cross Domain)
物理通道 NVSwitch(MNNVL)+ CX-7 RDMA 仅 CX-7 RDMA
带宽 ~840 GB/s (NVLink) + ~325 GB/s (RDMA) ~325 GB/s (RDMA only)
NCCL_MNNVL_ENABLE 1 或 2(自动检测) 0(禁用,否则 CUDA 801 错误)
NCCL_CUMEM_ENABLE 1(MNNVL 需要 cuMem 分配器) 0(不使用 MNNVL 时关闭)
ComputeDomain 必需(提供 IMEX channel) 不使用
GIB 配置 Env 插件自动配置(含 MNNVL 拓扑) Net 插件仍需(RDMA 传输),但需手动覆盖 MNNVL 相关变量

1. 环境准备

全局变量(请根据实际环境修改)

CIDR 规划说明:以下网段适用于 1800 GPU(450 A4X VM) 规模的集群。主管理子网使用 /21(2046 IP),其余子网使用 /22(1022 IP),均可容纳 450+ A4X VM 并留有余量(Control Plane、普通 VM、未来扩展)。
读者请根据内部网络团队分配的网段替换以下 CIDR 值。仅需修改变量值,后续所有命令自动引用。
# ===== GCP 项目与区域 =====
PROJECT="your-gcp-project"                # ← 请替换为您的 GCP 项目 ID
REGION="us-east5"                          # ← 请替换为您的区域
ZONE="us-east5-a"                          # ← 请替换为您的可用区
RESERVATION="your-gb200-reservation"       # ← 请替换为您的 GB200 预留名称

# ===== 机器与镜像 =====
MACHINE_TYPE="a4x-highgpu-4g"
IMAGE="tlinux-server-4-gb200-v1"           # ← 请替换为您的 VM 镜像名称
IMAGE_PROJECT="$PROJECT"                   # ← 镜像所在项目(如与 VM 项目不同请修改)

# ===== 网络名称 =====
GVNIC_NET="a4x-gvnic-net-0"               # ← 主 GVNIC 管理网络(MTU 8896)
GVNIC_SUB="a4x-gvnic-sub-0"               # ← 主 GVNIC 子网
GVNIC_NET_1="a4x-gvnic-net-1"             # ← 辅助 GVNIC 网络
GVNIC_SUB_1="a4x-gvnic-sub-1"             # ← 辅助 GVNIC 子网
RDMA_NET="a4x-rdma-net"                   # ← RDMA HPC 网络(需 network profile)

# ===== 网络 CIDR(请根据内部网络团队分配的网段调整) =====
# 以下规划适用于 1800 GPU (450 A4X VM) 规模的集群
# 主管理子网使用 /21, 其余子网使用 /22, 均可容纳 450+ VM 并留有余量
GVNIC_CIDR="10.0.0.0/21"                  # 主管理子网: /21 = 2046 IP — 450 A4X + CP + 普通 VM + 缓冲
GVNIC_1_CIDR="10.0.8.0/22"                # 辅助管理子网: /22 = 1022 IP
RDMA_CIDR_0="10.0.16.0/22"                # RDMA 子网 0 (CX-7 NIC 0): /22 = 1022 IP
RDMA_CIDR_1="10.0.20.0/22"                # RDMA 子网 1 (CX-7 NIC 1): /22 = 1022 IP
RDMA_CIDR_2="10.0.24.0/22"                # RDMA 子网 2 (CX-7 NIC 2): /22 = 1022 IP
RDMA_CIDR_3="10.0.28.0/22"                # RDMA 子网 3 (CX-7 NIC 3): /22 = 1022 IP
SUBNET_SUPERNET="10.0.0.0/16"             # ← 所有子网的超网, 用于防火墙规则(请按实际网段调整)

# ===== NVL72 Domain 配置 =====
NUM_DOMAINS=2                              # ← 部署的 NVL72 Domain 数量(生产环境可设 25+)
NODES_PER_DOMAIN=18                        # A4X NVL72 固定值,请勿修改
PLACEMENT_PREFIX="a4x-nvl72-domain"        # Placement Policy 名称前缀

# ===== 集群命名 =====
CP_NAME="gb200-cp"                         # Control Plane 节点名称
WORKER_PREFIX="gb200"                      # Worker 节点名称前缀(完整名: ${WORKER_PREFIX}-d${DOMAIN}-w${INDEX})

# ===== Kubernetes =====
K8S_VERSION="1.34"
POD_CIDR="10.244.0.0/16"

# ===== 组件版本 =====
GIB_VERSION="v1.1.2"
DEVICE_PLUGIN_VERSION="v0.17.1"
DRANET_VERSION="v1.3.0"
DRA_GPU_DRIVER_VERSION="v25.12.0"
CALICO_VERSION="v3.29.3"
PYTORCH_IMAGE="nvcr.io/nvidia/pytorch:26.05-py3"
GIB_IMAGE="us-docker.pkg.dev/gce-ai-infra/gpudirect-gib/nccl-plugin-gib-diagnostic-arm64:${GIB_VERSION}"

# ===== 共享存储 =====
GCSFUSE_BUCKET="your-training-bucket"      # ← 请替换为您的 GCS bucket 名称
LOCAL_SSD_MOUNT="/mnt/stateful_partition"   # Local SSD RAID0 挂载点(与 GKE+COS 一致)

1.1 前提条件

1.2 创建 VPC / 子网 / RDMA 网络

A4X 网络架构:每个 A4X 节点有 6 个网卡 — 2 个 GVNIC(管理网络)+ 4 个 CX-7 MRDMA(GPU RDMA 网络)。需要创建 3 个 VPC 网络和 6 个子网。
参考:GCP 官方文档 — Create custom A4X cluster

1.2.1 主 GVNIC 管理网络(MTU 8896)

MTU 必须设为 8896(Jumbo Frames)。默认 MTU 1460/1500 会导致 Lustre 吞吐量下降约 10%。MRDMA 网络的 MTU 由 Network Profile 自动配置,无需手动设置。
# 创建主 GVNIC 网络(MTU 8896)
gcloud compute networks create $GVNIC_NET \
  --subnet-mode=custom --mtu=8896 --project=$PROJECT

gcloud compute networks subnets create $GVNIC_SUB \
  --network=$GVNIC_NET \
  --region=$REGION \
  --range=$GVNIC_CIDR \
  --project=$PROJECT

1.2.2 辅助 GVNIC 网络

gcloud compute networks create $GVNIC_NET_1 \
  --subnet-mode=custom --project=$PROJECT

gcloud compute networks subnets create $GVNIC_SUB_1 \
  --network=$GVNIC_NET_1 \
  --region=$REGION \
  --range=$GVNIC_1_CIDR \
  --project=$PROJECT

1.2.3 RDMA HPC 网络(需 Network Profile)

Network Profile:RDMA 网络需要使用 --network-profile=${ZONE}-vpc-roce 创建。该 Network Profile 由 GCP 自动配置最优 MTU 和 RDMA 参数。
# 创建 RDMA HPC 网络
gcloud beta compute networks create $RDMA_NET \
  --network-profile=${ZONE}-vpc-roce \
  --subnet-mode=custom \
  --project=$PROJECT

# 创建 4 个 RDMA 子网(每个对应一块 CX-7 NIC)
RDMA_CIDRS=($RDMA_CIDR_0 $RDMA_CIDR_1 $RDMA_CIDR_2 $RDMA_CIDR_3)
for n in 0 1 2 3; do
  gcloud compute networks subnets create ${RDMA_NET}-sub-${n} \
    --network=$RDMA_NET \
    --region=$REGION \
    --range="${RDMA_CIDRS[$n]}" \
    --project=$PROJECT
done

1.2.4 防火墙规则

# SSH 防火墙(IAP 源 IP 范围)
gcloud compute firewall-rules create ${GVNIC_NET}-allow-iap-ssh \
  --network=$GVNIC_NET \
  --allow=tcp:22 \
  --source-ranges=35.235.240.0/20 \
  --project=$PROJECT

# 主 GVNIC 内部通信(含 Pod CIDR — ComputeDomain daemon pods 需要跨节点通信)
gcloud compute firewall-rules create ${GVNIC_NET}-allow-internal \
  --network=$GVNIC_NET \
  --allow=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=${SUBNET_SUPERNET},${POD_CIDR} \
  --project=$PROJECT

# 辅助 GVNIC 内部通信
gcloud compute firewall-rules create ${GVNIC_NET_1}-allow-internal \
  --network=$GVNIC_NET_1 \
  --allow=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=${SUBNET_SUPERNET} \
  --project=$PROJECT
防火墙注意:某些 GCP 组织策略会自动删除新建的防火墙规则。如果 SSH 或 Pod 通信失败,请先检查防火墙规则是否存在。建议使用 IAP SSH(--tunnel-through-iap)以绕过防火墙限制。

网络布局总览

网络子网CIDR用途
$GVNIC_NET$GVNIC_SUB$GVNIC_CIDR (/21, 2046 IP)主管理网络(SSH, k8s API, Pod CIDR)
$GVNIC_NET_1$GVNIC_SUB_1$GVNIC_1_CIDR (/22, 1022 IP)辅助管理网络
$RDMA_NET${RDMA_NET}-sub-0$RDMA_CIDR_0 (/22)GPU RDMA 计算网络
(每 NIC 一个子网, 各 1022 IP)
${RDMA_NET}-sub-1$RDMA_CIDR_1 (/22)
${RDMA_NET}-sub-2$RDMA_CIDR_2 (/22)
${RDMA_NET}-sub-3$RDMA_CIDR_3 (/22)

1.3 查看预留状态

gcloud compute reservations describe $RESERVATION \
  --zone=$ZONE --project=$PROJECT \
  --format="table(specificReservation.count, specificReservation.inUseCount)"

1.4 Placement Policy(每个 Domain 需要)

生产环境规模:每个 NVL72 Domain(18 节点 / 72 GPU)需要独立的 Placement Policy。例如 1800 GPU = 25 个 Domain,需创建 25 个 Policy。Placement Policy 与 Domain 一一绑定,确保该 Policy 下的 VM 被分配到同一个 NVSwitch Domain。
# 为每个 Domain 创建 collocated placement policy
# 示例:创建 N 个 Domain 的 Policy(生产环境用循环)
for d in $(seq 1 $NUM_DOMAINS); do
  gcloud beta compute resource-policies create group-placement \
    ${PLACEMENT_PREFIX}-${d} \
    --collocation=COLLOCATED \
    --gpu-topology=1x72 \
    --project=$PROJECT --region=$REGION
done

# 示例:2 个 Domain 会创建 a4x-nvl72-domain-1 和 a4x-nvl72-domain-2
# 生产环境 NUM_DOMAINS=25 会创建 25 个 Placement Policy

1.5 创建额外防火墙规则(可选)

# SSH 防火墙(IAP 源 IP 范围)
gcloud compute firewall-rules create allow-ssh-iap-k8s1341 \
  --network=$GVNIC_NET \
  --allow=tcp:22 \
  --source-ranges=35.235.240.0/20 \
  --project=$PROJECT

# 集群内部通信(含 Pod CIDR — ComputeDomain daemon pods 需要跨节点 pod 通信)
gcloud compute firewall-rules create allow-internal-k8s1341 \
  --network=$GVNIC_NET \
  --allow=tcp,udp,icmp \
  --source-ranges=${SUBNET_SUPERNET},${POD_CIDR} \
  --project=$PROJECT

# 注:Calico 使用 VXLAN 模式(UDP 4789),已被上方 allow-internal 规则覆盖,无需额外 IPIP 规则

2. 创建 k8s 1.34.1 集群

k8s 1.34 关键变化:DRA (Dynamic Resource Allocation) 在 k8s 1.34 中为 GA,默认启用,无需 feature gate。ResourceClaimTemplate/DeviceClass API 版本为 resource.k8s.io/v1(非 v1beta2)。

2.1 Control Plane 节点

CP 节点使用 x86_64 轻量 VM(无需 GPU),仅连接主 GVNIC 网络。

gcloud compute instances create $CP_NAME \
  --project=$PROJECT --zone=$ZONE \
  --machine-type=e2-standard-4 \
  --image-family=rocky-linux-9 --image-project=rocky-linux-cloud \
  --boot-disk-size=100GB \
  --network-interface=network=$GVNIC_NET,subnet=$GVNIC_SUB \
  --metadata-from-file=startup-script=scripts/kubeadm-control-plane-k8s134.sh \
  --scopes=cloud-platform

CP 启动脚本要点 (kubeadm-control-plane-k8s134.sh) 查看完整脚本

  1. 禁用 swap 和 SELinux
  2. 加载内核模块 (overlay, br_netfilter) + sysctl
  3. 安装 containerd (Docker CE repo, SystemdCgroup=true)
  4. 安装 kubeadm/kubelet/kubectl (pkgs.k8s.io v1.34 rpm repo)
  5. kubeadm init --pod-network-cidr=10.244.0.0/16
  6. 安装 Calico v3.29.3 CNI
  7. 生成 join token 和 SSH key pair
Calico vxlanMTU 配置(重要)
GVNIC 管理网络 MTU 为 8896,VXLAN 封装开销为 50 字节(IPv4),因此 Calico vxlanMTU 应设为 8846。如不显式设置,Calico 自动探测可能基于错误网卡(如 MRDMA)回退到 1450,导致 GCSFuse 等依赖管理网络的流量带宽严重下降。

Calico 安装完成后,在 CP 上执行:
# 方法 1:通过 FelixConfiguration CRD(推荐)
cat <<'EOF' | kubectl apply -f -
apiVersion: projectcalico.org/v3
kind: FelixConfiguration
metadata:
  name: default
spec:
  vxlanMTU: 8846
EOF

# 方法 2:通过 calico-config ConfigMap
kubectl patch configmap/calico-config -n kube-system --type merge \
  -p '{"data":{"veth_mtu": "8846"}}'

# 验证:重启 calico-node DaemonSet 使配置生效
kubectl rollout restart daemonset calico-node -n kube-system
kubectl exec -n kube-system $(kubectl get pod -n kube-system -l k8s-app=calico-node -o name | head -1) -- cat /etc/config/calico_vxlan_mtu 2>/dev/null || echo "check via calicoctl"
参考:Calico MTU 配置文档
Calico IP 自动检测(A4X Worker 必须)
Calico 默认 IP_AUTODETECTION_METHOD=interface=eth0。CP 节点(x86 Rocky Linux)主接口为 eth0,但 A4X Worker 节点(ARM64 TencentOS)主接口为 enp0s3。Worker 加入集群后 calico-node 会因找不到 eth0 而 CrashLoopBackOff。

Worker 节点加入集群后,需更新 Calico IP 检测规则以匹配两种接口名:
kubectl set env daemonset/calico-node -n kube-system \
  IP_AUTODETECTION_METHOD='interface=eth0|enp0s3'

# 等待 rollout 完成
kubectl rollout status daemonset/calico-node -n kube-system

获取 Join 信息

# SSH 到 CP 节点
gcloud compute ssh $CP_NAME --zone=$ZONE --project=$PROJECT --tunnel-through-iap

# 查看 join 命令
cat /root/kubeadm-join-command.txt

# 提取 token 和 hash
CP_IP=$(hostname -I | awk '{print $1}')
JOIN_TOKEN=$(kubeadm token list -o jsonpath='{.token}' | head -1)
JOIN_HASH=$(openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | \
  openssl rsa -pubin -outform der 2>/dev/null | sha256sum | awk '{print $1}')
echo "CP_IP=$CP_IP JOIN_TOKEN=$JOIN_TOKEN JOIN_HASH=$JOIN_HASH"

2.2 Placement Policy 与 Worker 节点 VM 创建

Domain 与 Placement Policy 的关系:

批量创建 Worker(每个 Domain 使用对应的 Placement Policy)

生产环境示例:25 个 Domain × 18 节点/Domain = 450 Worker VM。每个 Domain 的 Worker 使用该 Domain 的 Placement Policy 创建,确保同一 Domain 内的节点在同一 NVSwitch 拓扑中。

按 Domain 批量创建 Worker(每个 Domain 使用对应的 Placement Policy)

# 循环创建所有 Domain 的 Worker VM
# 生产环境:NUM_DOMAINS=25, NODES_PER_DOMAIN=18 → 共 450 个 Worker
for d in $(seq 1 $NUM_DOMAINS); do
  echo "=== Creating workers for Domain ${d} ==="
  for i in $(seq 0 $((NODES_PER_DOMAIN - 1))); do
    gcloud compute instances create ${WORKER_PREFIX}-d${d}-w${i} \
      --project=$PROJECT --zone=$ZONE \
      --machine-type=$MACHINE_TYPE \
      --image=$IMAGE --image-project=$IMAGE_PROJECT \
      --boot-disk-size=1000GB --boot-disk-type=hyperdisk-balanced \
      --scopes=cloud-platform \
      --reservation-affinity=specific --reservation=$RESERVATION \
      --provisioning-model=RESERVATION_BOUND \
      --instance-termination-action=STOP \
      --maintenance-policy=TERMINATE \
      --restart-on-failure \
      --resource-policies=${PLACEMENT_PREFIX}-${d} \
      --network-interface=nic-type=GVNIC,network=$GVNIC_NET,subnet=$GVNIC_SUB \
      --network-interface=nic-type=GVNIC,network=$GVNIC_NET_1,subnet=$GVNIC_SUB_1,no-address \
      --network-interface=nic-type=MRDMA,network=$RDMA_NET,subnet=$RDMA_SUB_0,no-address \
      --network-interface=nic-type=MRDMA,network=$RDMA_NET,subnet=$RDMA_SUB_1,no-address \
      --network-interface=nic-type=MRDMA,network=$RDMA_NET,subnet=$RDMA_SUB_2,no-address \
      --network-interface=nic-type=MRDMA,network=$RDMA_NET,subnet=$RDMA_SUB_3,no-address \
      --metadata=cp-ip=$CP_IP,join-token=$JOIN_TOKEN,join-hash=$JOIN_HASH \
      --metadata-from-file=startup-script=scripts/tlinux4-k8s134-worker.sh &
  done
  wait  # 等待该 Domain 的 Worker 全部创建完成
done
命名规则:Worker 名称格式为 ${WORKER_PREFIX}-d${DOMAIN}-w${INDEX},例如 gb200-d1-w0 到 gb200-d1-w17 为 Domain 1 的 18 个节点。不同 Domain 的 Worker 使用不同的 Placement Policy,确保 VM 分配到对应的 NVSwitch Domain。

2.3 Worker 节点 k8s 加入

TLinux 4 Worker 使用 2 阶段设置脚本 tlinux4-k8s134-worker.sh 查看完整脚本:

# SSH 到每个 Worker,运行设置脚本(可批量并行)
for d in $(seq 1 $NUM_DOMAINS); do
  for i in $(seq 0 $((NODES_PER_DOMAIN - 1))); do
    WORKER="${WORKER_PREFIX}-d${d}-w${i}"
    gcloud compute ssh $WORKER --zone=$ZONE --project=$PROJECT --tunnel-through-iap \
      --command="sudo bash /root/scripts/tlinux4-k8s134-worker.sh" &
  done
done
wait

# Phase 1 完成后节点自动重启,重启后 Phase 2 自动运行并 join 集群
# 等待 ~5 分钟让所有 Worker 完成 Phase 2

# 在 CP 上验证
kubectl get nodes -o wide
# 应看到 1 CP + (NUM_DOMAINS × NODES_PER_DOMAIN) Worker 节点 (全部 Ready)
TLinux 4 注意事项:

2.4 节点标签

方法 A:手动标记(小规模 / 验证环境)

# 按 Domain 标记 Worker 节点
for d in $(seq 1 $NUM_DOMAINS); do
  for i in $(seq 0 $((NODES_PER_DOMAIN - 1))); do
    kubectl label node ${WORKER_PREFIX}-d${d}-w${i} \
      nvl72-domain=domain-${d} --overwrite
  done
done

# 验证
kubectl get nodes -L nvl72-domain

方法 B:Startup Script 自动注册(生产 / 大规模环境,推荐)

GCP VM 可通过 Metadata Server 获取物理拓扑信息,无需 IAM 权限。同一 NVL72 domain 内的 VM 返回相同的拓扑哈希值。利用此特性,可在 Worker 的 startup script 中自动传递 --node-labels 给 kubelet:

# 在 Worker startup script 中(kubeadm join 之前)添加:

# 1. 从 Metadata Server 获取物理拓扑哈希(同 domain 的 VM 返回相同值)
TOPO_HASH=$(curl -sf -H "Metadata-Flavor: Google" \
  "http://metadata.google.internal/computeMetadata/v1/instance/attributes/physical_host_topology" \
  | md5sum | cut -c1-8)  # 截取前 8 位作为域标识符

# 2. 配置 kubelet 启动参数,自动附带拓扑标签
mkdir -p /etc/systemd/system/kubelet.service.d
cat > /etc/default/kubelet <<KUBELET_EOF
KUBELET_EXTRA_ARGS=--node-labels=nvl72-domain=domain-${TOPO_HASH}
KUBELET_EOF
systemctl daemon-reload

# 3. kubeadm join 时节点自动携带标签
kubeadm join ${CP_IP}:6443 \
  --token "${JOIN_TOKEN}" \
  --discovery-token-ca-cert-hash "sha256:${JOIN_HASH}" \
  --node-name "${NODE_NAME}" \
  --ignore-preflight-errors=Hostname
拓扑发现的两种 API:
方式端点权限要求返回值
Metadata Server(推荐)http://metadata.google.internal/.../physical_host_topology无(VM 内部直接访问)拓扑哈希字符串
Compute APIgcloud compute instances describe --format='value(resourceStatus.physicalHostTopology.subblock)'需要 compute.instances.get IAM 权限结构化的 subblock 标识
注意:Metadata Server 返回的是哈希值(不可读但稳定),同 domain 的 VM 保证返回相同值。Compute API 返回可读的 subblock 名称,但需要额外 IAM 配置。
替代方式:kubeadm JoinConfiguration
上方示例使用 /etc/default/kubelet + KUBELET_EXTRA_ARGS 的 systemd drop-in 方式传递 --node-labels。另一种方式是通过 JoinConfiguration 的 nodeRegistration.kubeletExtraArgs 以声明式配置文件传递(注意 v1beta4 的 kubeletExtraArgs 为 []Arg 列表格式,非 v1beta3 的 map):
# kubeadm-join-config.yaml(声明式方式)
apiVersion: kubeadm.k8s.io/v1beta4
kind: JoinConfiguration
nodeRegistration:
  kubeletExtraArgs:
  - name: "node-labels"
    value: "nvl72-domain=domain-${TOPO_HASH}"
discovery:
  bootstrapToken:
    apiServerEndpoint: "${CP_IP}:6443"
    token: "${JOIN_TOKEN}"
    caCertHashes:
    - "sha256:${JOIN_HASH}"

# 使用方式:kubeadm join --config kubeadm-join-config.yaml
两种方式功能等价。--node-labels 在 k8s 1.34 中未被弃用(源码中无 deprecation 标记),且 KubeletConfiguration 中也没有原生 nodeLabels 字段——kubeadm 的 kubeletExtraArgs 本质上仍是传递 CLI 参数。配置文件方式更符合 IaC 管理风格,但两者技术上无差异。

3. 安装 GPU Stack + ComputeDomain

k8s 1.34 DRA 状态:DRA 在 k8s 1.34 中为 GA(正式发布),默认启用,无需 feature gate。ResourceClaimTemplate/DeviceClass API 版本为 resource.k8s.io/v1。

3.1 安装 nvidia-device-plugin

使用 nvidia-device-plugin DaemonSet 将 GPU 作为 nvidia.com/gpu 资源暴露给 k8s。

# 安装 Helm
curl -fsSL https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

# 安装 nvidia-device-plugin
helm repo add nvdp https://nvidia.github.io/k8s-device-plugin
helm repo update
helm install nvidia-device-plugin nvdp/nvidia-device-plugin \
  --namespace kube-system \
  --set-string nodeSelector."nvidia\.com/gpu\.present"=true \
  --wait --timeout 300s

# 验证 GPU 可见
kubectl get nodes -o custom-columns="NAME:.metadata.name,GPU:.status.allocatable.nvidia\.com/gpu"
预期输出:每个 Worker 节点显示 4 个 GPU。

3.2 DRA GPU Driver(含 ComputeDomain 控制器)

DRA GPU Driver(v25.12.0+)提供 ComputeDomain CRD 和控制器,用于管理 IMEX daemon 生命周期。安装后会部署 kubelet plugin(DaemonSet)和 controller(Deployment)。
参考:官方文档
# 安装 DRA GPU Driver via Helm
helm repo add nvidia-dra https://nvidia.github.io/k8s-dra-driver
helm repo update
helm install nvidia-dra-driver-gpu nvidia-dra/nvidia-dra-driver-gpu \
  --namespace gpu-operator \
  --create-namespace \
  --version ${DRA_GPU_DRIVER_VERSION} \
  --set gpuResourcesEnabledOverride=true \
  --wait --timeout 300s

# 验证 DRA GPU Driver 组件
kubectl -n gpu-operator get pods -o wide
# 应看到: controller Pod (1/1) + 每个 GPU Worker 一个 kubelet-plugin Pod (2/2)

# 验证 ComputeDomain CRD 已注册
kubectl get crd | grep computedomain
# 应有: computedomains.resource.nvidia.com
前提:Worker 节点的 IMEX channels 必须已创建(/dev/nvidia-caps-imex-channels/channel0 存在)。这在 Worker 启动脚本的 Phase 1 中已配置(NVreg_CreateImexChannel0=1 + dracut --force + reboot)。
互斥:ComputeDomain 与 nvidia-imex systemd 服务互斥。如 Worker 上有 nvidia-imex.service 在运行,必须先停止:systemctl stop nvidia-imex && systemctl disable nvidia-imex

3.3 安装 DRANET

DRANET v1.3.0 是 Kubernetes SIG 的 DRA 网络驱动,用于将 RDMA NIC 作为 DRA 设备分配给 Pod。

# 安装 DRANET v1.3.0 via Helm
helm install dranet oci://registry.k8s.io/networking/charts/dranet \
  --version $DRANET_VERSION \
  --namespace kube-system \
  --wait --timeout 300s

# 验证 DRANET DaemonSet
kubectl -n kube-system get ds dranet

# 验证 ResourceSlice(每个节点应发现 RDMA 设备)
kubectl get resourceslice -o wide | head -20

3.4 创建 RDMA DeviceClass

kubectl apply -f yamls/k8s1341-rdma-deviceclass.yaml
k8s1341-rdma-deviceclass.yaml

DeviceClass 内容(注意 API 为 resource.k8s.io/v1):

apiVersion: resource.k8s.io/v1
kind: DeviceClass
metadata:
  name: rdma-devices
spec:
  selectors:
  - cel:
      expression: |
        device.driver == "dra.net" &&
        has(device.attributes["dra.net"].rdma) && device.attributes["dra.net"].rdma == true

验证安装

kubectl get deviceclass
# 应有: rdma-devices

kubectl get resourceslice -o wide | head -20

3.5 Scheduler DRA RBAC(kubeadm 必需)

关键步骤:kubeadm 1.34.x 的默认 ClusterRole 未包含 DRA(Dynamic Resource Allocation)所需的 RBAC 权限。如果跳过此步骤,ComputeDomain daemon pods 会永久停留在 ContainerCreating(kubelet 无日志无报错,极难诊断)。
# Scheduler DRA RBAC — 必须在创建任何 ComputeDomain 之前执行
cat <<'EOF' | kubectl apply -f -
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: system:kube-scheduler:dra
rules:
- apiGroups: ["resource.k8s.io"]
  resources: ["resourceclaims"]
  verbs: ["get", "list", "watch", "update", "patch"]
- apiGroups: ["resource.k8s.io"]
  resources: ["resourceclaims/status"]
  verbs: ["get", "update", "patch"]
- apiGroups: ["resource.k8s.io"]
  resources: ["resourceslices"]
  verbs: ["get", "list", "watch"]
- apiGroups: ["resource.k8s.io"]
  resources: ["deviceclasses"]
  verbs: ["get", "list", "watch"]
- apiGroups: [""]
  resources: ["persistentvolumeclaims"]
  verbs: ["get", "list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: system:kube-scheduler:dra
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:kube-scheduler:dra
subjects:
- apiGroup: rbac.authorization.k8s.io
  kind: User
  name: system:kube-scheduler
EOF

# 重启 Scheduler 使 informer 重新同步
kubectl delete pod -n kube-system -l component=kube-scheduler
kubectl get pods -n kube-system -l component=kube-scheduler -w
# 等待 Running 1/1

3.6 创建 ComputeDomain

ComputeDomain 是 DRA GPU Driver 提供的 CRD,声明式管理 IMEX daemon 生命周期(概念文档)。创建后,控制器自动:
1. 创建 daemon DaemonSet → 在域内节点上启动 IMEX daemon pods
2. 创建 ResourceClaimTemplate(Pod 通过此模板获取 IMEX channel)
3. IMEX daemon pods 通过 pod CIDR 互联(port 50000),建立 IMEX session
# 前提:nvidia-imex.service 必须已禁用(3.2 步骤已处理)

# 为每个 Domain 创建 ComputeDomain
for d in $(seq 1 $NUM_DOMAINS); do
  CD_NAME="domain-${d}-compute-domain"
  echo "=== Creating ComputeDomain: ${CD_NAME} ==="

  cat <<EOF | kubectl apply -f -
apiVersion: resource.nvidia.com/v1beta1
kind: ComputeDomain
metadata:
  name: ${CD_NAME}
spec:
  numNodes: 0
  channel:
    allocationMode: Single
    resourceClaimTemplate:
      name: ${CD_NAME}-channel
EOF

  # numNodes: 0 — 推荐值(IMEXDaemonsWithDNSNames=true 时),不门控 daemon 启动
  # allocationMode: Single — 每个 Pod 独占一个 IMEX channel

  # 获取 ComputeDomain UID 并标记域内节点
  CD_UID=$(kubectl get computedomain ${CD_NAME} -o jsonpath='{.metadata.uid}')
  echo "ComputeDomain UID: $CD_UID"

  for i in $(seq 0 $((NODES_PER_DOMAIN - 1))); do
    kubectl label node ${WORKER_PREFIX}-d${d}-w${i} \
      resource.nvidia.com/computeDomain=$CD_UID --overwrite
  done
done

# 等待 daemon pods 启动(通常 30-60 秒)
kubectl get pods -n gpu-operator -l app=computedomain-daemon -w

# 验证所有 ComputeDomain 状态
kubectl get computedomain -o wide
# 每个 ComputeDomain 状态应为 Ready
预期:ComputeDomain 状态 Ready,同域节点各有一个 daemon pod 在运行,IMEX session 建立成功。
注:daemon 日志中会不断尝试连接不存在的 peer(如 domain 共 18 节点但只使用 2 节点),属正常行为可忽略。
生产环境:每个物理 NVL72 域需要一个 ComputeDomain。1800 张卡 = 25 个域 × 18 节点/域 = 25 个 ComputeDomain + 25 个 Placement Policy。
域内多任务:ComputeDomain 支持域内多任务并存。每个节点最多属于一个 ComputeDomain(每节点只能运行一个 IMEX daemon),但同一 ComputeDomain 的 ResourceClaimTemplate 可被多个 Pod 共享。例如:创建一个覆盖 6 节点域的 ComputeDomain,任务 A 通过 nodeSelector 调度到其中 2 个节点,任务 B 调度到另外 4 个节点,两个任务都引用同一个 sd-compute-domain-channel ResourceClaimTemplate,均可使用 MNNVL。

3.7 安装 MPI Operator(多节点 NCCL 测试用)

Kubeflow MPI Operator v0.8.0 自动管理分布式 MPI 任务的 SSH 密钥分发、hostfile 注入和作业生命周期。在 5.2/5.3 节的多节点 NCCL 测试中使用 MPI Operator 可免去手动配置 SSH 互信和 nccl-tests 二进制分发的繁琐操作。

MPI Operator 关键特性:
# 安装 MPI Operator v0.8.0
kubectl apply --server-side -f \
  https://raw.githubusercontent.com/kubeflow/mpi-operator/v0.8.0/deploy/v2beta1/mpi-operator.yaml

# 验证
kubectl get pods -n mpi-operator
# NAME                            READY   STATUS    RESTARTS   AGE
# mpi-operator-xxxxxxxxx-xxxxx   1/1     Running   0          30s
Worker 镜像要求:MPI Operator 需要 Worker Pod 运行 sshd。NGC PyTorch 镜像自带 OpenMPI 但不含 openssh-server。本指南的 MPIJob YAML 通过 Worker 启动命令在运行时安装 sshd 并从源码编译 MPI 版 nccl-tests。详见 5.2 节。

4. GCSFuse + Lustre 共享存储

官方文档: Cloud Storage FUSE 概述 · GCSFuse GitHub · Cloud Parallelstore (Lustre) 概述

4.1 GCSFuse(已在 startup script 中配置)

每个 Worker 的 startup script (tlinux4-k8s134-worker.sh 查看完整脚本) 已包含 GCSFuse 安装和挂载:

# startup script 自动执行:
# 安装 gcsfuse
dnf install -y gcsfuse

# 挂载 GCS bucket(使用 Local SSD 作为文件缓存)
mkdir -p ${LOCAL_SSD_MOUNT}/shared
gcsfuse --implicit-dirs \
  --file-cache-dir=${LOCAL_SSD_MOUNT}/gcsfuse-cache \
  $GCSFUSE_BUCKET ${LOCAL_SSD_MOUNT}/shared

# Pod 中通过 hostPath 访问
volumes:
- name: shared-data
  hostPath:
    path: /mnt/stateful_partition/shared    # GCSFuse 挂载点
- name: scratch-data
  hostPath:
    path: /mnt/stateful_partition/scratch-data  # Local SSD 高速缓存

4.2 GCSFuse v2 高性能配置(可选)

GCSFuse v2 支持并行下载和内核缓存,可显著提升大模型 checkpoint 加载速度。

# 在 startup script 中启用 v2 高性能挂载(使用 Local SSD 作为文件缓存)
gcsfuse \
  --implicit-dirs \
  --file-cache-dir=${LOCAL_SSD_MOUNT}/gcsfuse-cache \
  --file-cache-capacity-per-file-mb=-1 \
  --file-cache-cache-file-for-range-read \
  --file-cache-enable-parallel-downloads \
  --file-cache-parallel-downloads-per-file=16 \
  --file-cache-download-chunk-size-mb=50 \
  --file-cache-max-parallel-downloads=64 \
  --kernel-list-cache-ttl-secs=600 \
  --metadata-cache-ttl-secs=600 \
  --stat-cache-capacity=20000 \
  --type-cache-max-size-mb=32 \
  --rename-dir-limit=200000 \
  $GCSFUSE_BUCKET ${LOCAL_SSD_MOUNT}/shared
关键参数说明: 注:文件缓存位于 Local SSD RAID0(/mnt/stateful_partition/gcsfuse-cache),A4X 自带 ~12TB NVMe,提供极高的缓存 IOPS。
关于 GCS FUSE CSI Driver
GKE 环境中,Google 提供了原生的 GCS FUSE CSI Driver,可将认证(Workload Identity)和缓存生命周期与 Pod 绑定,避免 hostPath 的节点状态残留问题。
但在自建 k8s 环境中,该 CSI Driver 不受官方支持(GitHub README 明确声明 "Manual deployment of the driver to your cluster is not officially supported by Google")。因此本指南采用节点级 gcsfuse 挂载 + hostPath 的方式,这是自建 k8s 上的推荐方案。GKE 用户请直接使用 CSI Driver。

4.3 Lustre(可选)

如果客户提供 Lustre 文件系统,使用 PV/PVC 方式挂载。lustre-pv-pvc.yaml

5. NCCL 通信测试

5.1 单节点 4 GPU (NVLink 基线)

# 部署单节点测试 Pod
kubectl apply -f yamls/k8s1341-nccl-single-node.yaml  # 查看 YAML

# 等待完成
kubectl logs nccl-single-node -f
指标实测结果
all_reduce 4 GPU @8G683.75 GB/s busbw
单节点 NCCL 测试通过:all_reduce 683.75 GB/s busbw。NVLink 通信正常。

5.2 同域 2 节点 MNNVL(MPI Operator + ComputeDomain + DRANET)

ComputeDomain(3.6 步骤已创建)管理 IMEX daemon 生命周期,Pod 通过 spec.resourceClaims 引用 ResourceClaimTemplate 获取 IMEX channel,启用 MNNVL。使用 MPI Operator(3.7 节已安装)自动管理 SSH 密钥分发和 hostfile 注入。

# Pod 通过 DRA 声明两类资源(在 MPIJob Worker template 中配置):
#   1. compute-domain-channel → ComputeDomain 自动生成的 ResourceClaimTemplate(提供 IMEX channel)
#   2. rdma-nics             → YAML 中定义的 ResourceClaimTemplate(提供 4 张 RDMA 网卡)
#
# MPI Operator 自动完成:
#   - 生成 ECDSA P-521 SSH 密钥对(K8s Secret)
#   - 将密钥和 authorized_keys 挂载到所有 Pod 的 /root/.ssh/
#   - 生成 hostfile 并注入 Launcher Pod
#   - Worker 就绪后才创建 Launcher(launcherCreationPolicy: WaitForWorkersReady)
# 一键部署 MPIJob(自动管理 SSH 和 hostfile)
kubectl apply -f yamls/k8s1341-nccl-mpi-same-domain.yaml  # 查看完整 YAML

# 查看 Worker 和 Launcher 状态(Launcher 在所有 Worker Ready 后自动创建)
kubectl get pods -l training.kubeflow.org/job-name=nccl-mpi-sd -w

# 查看测试结果
kubectl logs -l training.kubeflow.org/job-name=nccl-mpi-sd,training.kubeflow.org/replica-type=launcher

# 查看 MPIJob 状态
kubectl get mpijob nccl-mpi-sd -o jsonpath='{.status.conditions[-1].type}'
# 预期: Succeeded

# 清理
kubectl delete mpijob nccl-mpi-sd
kubectl delete resourceclaimtemplate rdma-nics-mpi-sd
MPIJob 工作流程:
  1. MPI Operator 自动生成 SSH 密钥 Secret (nccl-mpi-sd-ssh)
  2. Worker Pod 启动:GIB init container → 安装 openssh-server → 编译 MPI 版 nccl-tests → 启动 sshd
  3. 所有 Worker Ready 后,Launcher Pod 自动创建
  4. Launcher 编译 nccl-tests,然后通过 mpirun 在所有 Worker 上执行 all_reduce_perf
  5. 测试完成后 Launcher 退出,MPIJob 标记为 Succeeded
对比手动方式:无需 kubectl exec 交换 SSH 密钥、无需手动 scp 二进制文件、无需手动拼接 --host 参数。
指标实测结果
all_reduce 8 GPU @8G (MNNVL)836.55 GB/s busbw
平均 bus bandwidth750.61 GB/s
同域 MNNVL 测试通过:all_reduce 8GPU @8G 达到 836.55 GB/s busbw。MPI Operator 自动管理 SSH 互信,ComputeDomain 管理 IMEX daemon,MNNVL 通信正常。

5.3 跨域 2 节点 RDMA(MPI Operator + DRANET)

跨域节点无 MNNVL,使用纯 RDMA (GPUDirect/GIB) 通信。不需要 ComputeDomain channel(无 IMEX)。与 5.2 节的 MPIJob 相比,主要差异:

# 部署跨域 NCCL 测试 MPIJob
kubectl apply -f yamls/k8s1341-nccl-mpi-cross-domain.yaml  # 查看完整 YAML

# 查看进度
kubectl get pods -l training.kubeflow.org/job-name=nccl-mpi-cd -w

# 查看测试结果
kubectl logs -l training.kubeflow.org/job-name=nccl-mpi-cd,training.kubeflow.org/replica-type=launcher

# 清理
kubectl delete mpijob nccl-mpi-cd
kubectl delete resourceclaimtemplate rdma-nics-mpi-cd
指标实测结果
all_reduce 8 GPU @8G (RDMA)325.88 GB/s busbw
跨域 RDMA 测试通过:all_reduce 8GPU @8G 达到 325.88 GB/s busbw。纯 GPUDirect RDMA 通信正常,无需 ComputeDomain/IMEX。

5.4 混合 4 节点(2 同域 + 2 跨域)

生产环境中使用 MPI Operator 时,只需调整 MPIJob 的 replicas: 4 和 -np 16 即可扩展到 4 节点。本节保留参考 YAML 和测试数据:

# 参考:4 节点 Pod 配置
kubectl apply -f yamls/k8s1341-nccl-4node-mixed-dranet.yaml  # 查看 YAML
NCCL_MNNVL_ENABLE 注意:混合域测试中必须设置 NCCL_MNNVL_ENABLE=0。 设置为 2(自动检测)时,NCCL 会在跨域节点(无 IMEX channel)上尝试探测 MNNVL 能力导致 CUDA error。 如需同时利用同域 MNNVL 和跨域 RDMA,应将同域与跨域分离为独立的通信组。
指标实测结果
all_reduce 16 GPU @8G (纯 RDMA)162.45 GB/s busbw
混合 4 节点测试通过:all_reduce 16GPU @8G 达到 162.45 GB/s busbw(平均 156.7 GB/s)。所有 4 节点纯 RDMA 通信正常。

6. RDMA 带宽测试 (ib_write_bw)

在同域 NCCL 测试 Pod 中运行 RDMA 带宽测试。

# 安装 perftest
kubectl exec nccl-sd-h1 -- bash -c "apt-get update -qq && apt-get install -y -qq perftest"
kubectl exec nccl-sd-h2 -- bash -c "apt-get update -qq && apt-get install -y -qq perftest"

# 测试时需切换 LD_LIBRARY_PATH 避免 GIB libibverbs 覆盖系统版本
# 在 h2 上启动 server(每个 RDMA NIC 一个端口)
for port in 18515 18516 18517 18518; do
  kubectl exec nccl-sd-h2 -- bash -c \
    "LD_LIBRARY_PATH=/usr/lib/aarch64-linux-gnu ib_write_bw -p $port -d mlx5_0 -s 65536 --report_gbits -F" &
done

# 在 h1 上运行 client
HOST2_IP=$(kubectl get pod nccl-sd-h2 -o jsonpath='{.status.podIP}')
for port in 18515 18516 18517 18518; do
  kubectl exec nccl-sd-h1 -- bash -c \
    "LD_LIBRARY_PATH=/usr/lib/aarch64-linux-gnu ib_write_bw -p $port -d mlx5_0 -s 65536 --report_gbits -F $HOST2_IP"
done
指标实测结果
ib_write_bw per NIC~381 Gbps
4×NIC aggregate~1524 Gbps (4 × ~381 Gbps)

7. DeepEP 测试

版本选择指南:关于 DeepEP v1(CUDA 12)和 v2(CUDA 13)的详细对比与选择建议,请参阅 14.8 DeepEP v1 vs v2 选择建议。推荐使用 v2,因 v1 在 GCP 上无法支持跨节点 EP。

7.1 概述

DeepEP 是 DeepSeek 开源的 Expert Parallelism (EP) 通信库。本节提供两条并行部署路径供选择:

路径DeepEP 版本CUDAInternode 后端NVSHMEMNCCL
路径 A(稳定/传统)v1CUDA 12NVSHMEM IBGDA3.4.5(必需)2.25+
路径 B(推荐/新版)v2 (main)CUDA 13NCCL Gin可选/仅编译用≥ 2.30.4
Internode 限制:DeepEP v1 的 internode 通信依赖 NVSHMEM IBGDA,而 IBGDA 需要 GDRCopy。GKE/GCP 环境中 GDRCopy 无法使用(内核模块不可加载),因此 v1 internode 在 GKE 上受限。详见 GitHub Issue #579。
解决方案:DeepEP v2 (Elastic EP) 使用 NCCL Gin 后端进行 internode 通信,完全消除 NVSHMEM/GDRCopy 依赖,已在 2 节点 × 4 GPU 环境验证通过(144/144 PASS)。推荐使用路径 B。
CUDA 13 容器注意:NGC 26.04 (nvcr.io/nvidia/pytorch:26.04-py3) 容器自带 NVSHMEM 3.6.5,与 DeepEP v1 不兼容(struct v2 布局、QP-ID-major 索引变更)。在 CUDA 13 环境中使用 v1 internode 会因 NVSHMEM 版本冲突而阻塞。这是选择路径 B (v2) 的另一重要原因。

7.2 NVSHMEM 版本兼容矩阵

NVSHMEM 版本Struct 布局ibgda RC QP 索引DMABuf 支持DeepEP 兼容GB200 状态
3.3.9v1PE-major无 ibv_reg_dmabuf_mr兼容失败(无 nvidia_peermem,无 DMABuf FD)
3.4.5v1PE-majoribv_reg_dmabuf_mr兼容可用(GB200 推荐)
3.5.x+v2QP-ID-majoribv_reg_dmabuf_mr不兼容失败(struct/索引与 DeepEP 不匹配)
GPU 平台推荐 NVSHMEM 版本原因
GB200 (A4X)3.4.5GB200 不支持 POSIX FD handle(CUDA attr 92=0),nvidia_peermem 无法加载;3.4.5 通过 ibv_reg_dmabuf_mr 绕过此限制
B200 / H2003.3.9支持 nvidia_peermem,无需 DMABuf;struct v1 兼容 DeepEP

7.3 路径 A:DeepEP v1 + CUDA 12(稳定版)

适用容器:nvcr.io/nvidia/pytorch:25.04-py3(CUDA 12,NVSHMEM 兼容)

# 部署 DeepEP 测试 Pod(ComputeDomain + DRANET)
kubectl apply -f yamls/k8s1341-deepep-test-dranet.yaml  # 查看 YAML

# 等待 Pod 就绪
kubectl get pods -l name -w
kubectl logs deepep-h1 -f  # 确认 "Ready"

# 验证 IMEX channel
kubectl exec deepep-h1 -- ls /dev/nvidia-caps-imex-channels/

Step 1:安装 NVSHMEM 3.4.5 并编译 DeepEP v1

kubectl exec deepep-h1 -- bash -c "
  apt-get update -qq && apt-get install -y -qq git 2>/dev/null
  pip install nvidia-nvshmem-cu12==3.4.5 2>&1 | tail -3  # 必须 3.4.5,3.5.x+ 会导致 low-latency NVSHMEM init 失败
  ln -sf /usr/local/gib/lib64/libnccl.so.2 /usr/local/gib/lib64/libnccl.so

  cd /tmp && git clone --depth 1 https://github.com/deepseek-ai/DeepEP.git
  cd /tmp/DeepEP

  # 4-GPU 补丁(见 7.5 节详解)
  sed -i 's/#define NUM_MAX_NVL_PEERS 8/#define NUM_MAX_NVL_PEERS 4/' csrc/kernels/configs.cuh
  sed -i 's/NUM_MAX_NVL_PEERS == 8/NUM_MAX_NVL_PEERS == 4/g' csrc/deep_ep.hpp csrc/kernels/internode.cu
  sed -i 's/must be 8/must be 4/' csrc/deep_ep.hpp
  sed -i 's/num_ranks > NUM_MAX_NVL_PEERS/num_ranks >= NUM_MAX_NVL_PEERS/g' csrc/deep_ep.cpp csrc/kernels/layout.cu

  NCCL_DIR=/usr/local/gib TORCH_CUDA_ARCH_LIST='10.0' python setup.py build_ext --inplace 2>&1 | tail -5
  # 确认输出: deep_ep/_C.cpython-312-aarch64-linux-gnu.so
"

Step 2:运行 Intranode 测试

kubectl exec deepep-h1 -- bash -c "
  export NCCL_DIR=/usr/local/gib
  export LD_LIBRARY_PATH=/usr/local/gib/lib64:/usr/local/nvidia/lib64:\$LD_LIBRARY_PATH
  export PYTHONPATH=/tmp/DeepEP:\$PYTHONPATH
  cd /tmp/DeepEP/tests/legacy
  python test_intranode.py --num-processes 4 --num-experts 64 --num-topk 4
"

Step 3:运行 Low-latency 测试

kubectl exec deepep-h1 -- bash -c "
  export NCCL_DIR=/usr/local/gib PYTHONPATH=/tmp/DeepEP:\$PYTHONPATH
  export LD_LIBRARY_PATH=/usr/local/gib/lib64:/usr/local/nvidia/lib64:\$LD_LIBRARY_PATH
  cd /tmp/DeepEP/tests/legacy
  python test_low_latency.py --num-processes 4 --num-experts 64 --num-topk 4
"
测试实测结果
Intranode BF16 dispatch24/24 PASS,best 435.97 GB/s NVL (SMs=24, chunk=32)
Intranode FP8 dispatch24/24 PASS,best 288.07 GB/s NVL (SMs=24, chunk=32)
Intranode CombinePASS,best 321.35 GB/s NVL (SMs=24, chunk=16)
Low-latency dispatch168-188 GB/s,延迟 ~20 us
Low-latency combine316-331 GB/s,延迟 ~22 us

7.4 路径 B:DeepEP v2 + CUDA 13(推荐)

适用容器:nvcr.io/nvidia/pytorch:26.04-py3(CUDA 13.2,NCCL 2.29.7)。DeepEP v2 (Elastic EP) 使用 NCCL Gin 后端,消除了 NVSHMEM internode 依赖。

# 部署 CUDA 13 测试 Pod(ComputeDomain + DRANET)  查看参考 YAML
# ← 请根据实际环境修改 Pod YAML

# 等待 Pod 就绪
kubectl get pods -l name -w
镜像说明:使用 nvcr.io/nvidia/pytorch:26.04-py3,含 CUDA 13.2.1、PyTorch 2.12.0a0。init container 为 GIB NCCL plugin v1.1.0 (ARM64)。

Step 1:安装 NVSHMEM 3.4.5 + NCCL 2.30.4

容器自带 NVSHMEM 3.6.5(与 DeepEP 不兼容)和 NCCL 2.29.7(v2 需要 ≥ 2.30.4)。需额外安装:

# 在每个 CUDA 13 Pod 上执行:

# 安装 NVSHMEM 3.4.5(用于 legacy 代码编译,不影响 v2 运行时)
apt-get update && apt install -y cuda-keyring && apt update
apt install -y libnvshmem3-cuda-12=3.4.5-1 libnvshmem3-dev-cuda-12=3.4.5-1 libnvshmem3-static-cuda-12=3.4.5-1

# 修复 CUDA 13 CCCL 头文件路径(cuda/std/ 移至 cccl/cuda/std/)
ln -sf /usr/local/cuda/include/cccl/cuda /usr/local/cuda/include/cuda

# 创建 NVSHMEM 3.4.5 目录结构
mkdir -p /scratch-data/nvshmem345
ln -sf /usr/include/nvshmem_12 /scratch-data/nvshmem345/include
ln -sf /usr/lib/aarch64-linux-gnu/nvshmem/12 /scratch-data/nvshmem345/lib

# 安装 NCCL 2.30.4(DeepEP v2 GIN 后端要求 >= 2.30.4)
pip install "nvidia-nccl-cu13>=2.30.4" --no-deps

Step 2:克隆 DeepEP v2 并应用 4-GPU 补丁

cd /scratch-data
git clone --depth 1 https://github.com/deepseek-ai/DeepEP.git DeepEP-v2
cd DeepEP-v2

# DeepEP v2 使用 LEGACY_ 前缀的 NVL peer 常量,需要相应补丁
sed -i "s/#define LEGACY_NUM_MAX_NVL_PEERS 8/#define LEGACY_NUM_MAX_NVL_PEERS 4/" csrc/kernels/legacy/compiled.cuh

find csrc/ -name "*.cu" -o -name "*.cuh" -o -name "*.hpp" -o -name "*.cpp" -o -name "*.h" | \
  xargs sed -i "s/LEGACY_NUM_MAX_NVL_PEERS == 8/LEGACY_NUM_MAX_NVL_PEERS == 4/g"

sed -i "s/LEGACY_NUM_MAX_NVL_PEERS \* sizeof(bool) == sizeof(uint64_t)/LEGACY_NUM_MAX_NVL_PEERS * sizeof(bool) == sizeof(uint32_t)/" \
  csrc/kernels/legacy/internode.cu

sed -i "s/uint64_t cached_bitmask/uint32_t cached_bitmask/" csrc/kernels/legacy/internode.cu

sed -i "s/num_ranks > LEGACY_NUM_MAX_NVL_PEERS/num_ranks >= LEGACY_NUM_MAX_NVL_PEERS/" csrc/kernels/legacy/layout.cu

Step 3:编译 DeepEP v2

export NVSHMEM_DIR=/scratch-data/nvshmem345
export EP_NCCL_ROOT_DIR=/usr/local/lib/python3.12/dist-packages/nvidia/nccl
export TORCH_CUDA_ARCH_LIST="10.0"
export EP_JIT_CACHE_DIR=/scratch-data/deepep-jit-cache
mkdir -p /scratch-data/deepep-jit-cache

pip install -e . --no-build-isolation 2>&1 | tail -10

# 验证
python3 -c "import deep_ep; print('DeepEP v2 import OK')"
注意:编译时勿将 GIB 加入 LD_LIBRARY_PATH — GIB 自带 NCCL 2.28.9,与容器 NCCL 2.29.7 冲突,会导致编译链接错误。

Step 4:运行 Intranode 测试

cd /scratch-data/DeepEP-v2
export LD_LIBRARY_PATH=/usr/local/nvidia/lib64:${LD_LIBRARY_PATH}
python tests/test_intranode.py --num-processes 4

Step 5:运行 Internode 测试(2 节点 × 4 GPU,NCCL Gin)

注意:不要使用 tests/legacy/test_internode.py,该测试会因 LEGACY_NUM_MAX_NVL_PEERS=8 assertion 在 4-GPU A4X 上失败。请使用 v2 elastic 测试。
# 在两个 Pod 上创建启动脚本:
cat > /scratch-data/run_deepep_v2_test.sh << 'SCRIPT'
#!/bin/bash
export LD_PRELOAD=/usr/local/lib/python3.12/dist-packages/nvidia/nccl/lib/libnccl.so.2
export LD_LIBRARY_PATH=/usr/local/gib/lib64:/usr/local/nvidia/lib64:/usr/local/cuda/lib64:${LD_LIBRARY_PATH}
export PATH=/usr/local/nvidia/bin:/usr/local/cuda/bin:${PATH}
export CUDA_HOME=/usr/local/cuda
export CPATH=/usr/local/cuda/include
export NVSHMEM_DIR=/scratch-data/nvshmem345
export EP_NCCL_ROOT_DIR=/usr/local/lib/python3.12/dist-packages/nvidia/nccl
export EP_JIT_CACHE_DIR=/scratch-data/deepep-jit-cache
export NCCL_NET=gIB
export NCCL_PXN_C2C=1
export NCCL_IB_ADAPTIVE_ROUTING=1
export NCCL_IB_QPS_PER_CONNECTION=4
export NCCL_IB_TC=52
export NCCL_IB_FIFO_TC=84
export TRITON_PTXAS_PATH=/usr/local/cuda/bin/ptxas

export MASTER_ADDR=${MASTER_ADDR}
export MASTER_PORT=${MASTER_PORT:-8363}
export WORLD_SIZE=${WORLD_SIZE:-2}
export RANK=${RANK:-0}

cd /scratch-data/DeepEP-v2
python3 tests/elastic/test_ep.py --num-processes 4 --num-tokens 1024 --hidden 7168 --num-topk 6 --num-experts 256 "$@"
SCRIPT
chmod +x /scratch-data/run_deepep_v2_test.sh

# 获取 Pod 1 的 IP
HOST1_IP=$(kubectl get pod cuda13-dra-1 -o jsonpath='{.status.podIP}')

# 在 Pod 2 上启动(RANK=1)
kubectl exec cuda13-dra-2 -- bash -c "
  MASTER_ADDR=$HOST1_IP RANK=1 /scratch-data/run_deepep_v2_test.sh
" &

sleep 5

# 在 Pod 1 上启动(RANK=0)
kubectl exec cuda13-dra-1 -- bash -c "
  MASTER_ADDR=$HOST1_IP RANK=0 /scratch-data/run_deepep_v2_test.sh
"
关键环境变量说明:
• LD_PRELOAD:必须指定 NCCL 2.30.4,因为容器默认加载 NCCL 2.29.7,不含 Gin API。
• TRITON_PTXAS_PATH:防止 Triton JIT 在子进程中编译失败。
• NCCL_NET=gIB:启用 GPUDirect RDMA(GIB)进行跨节点通信。
测试实测结果
Intranode dispatch BF1624/24 PASS,best 460.87 GB/s NVL (SMs=24, chunk=32)
Intranode dispatch FP824/24 PASS,best 308.11 GB/s NVL (SMs=24, chunk=32)
Intranode CombinePASS,best 346.24 GB/s NVL (SMs=24, chunk=16)
Internode MNNVL Dispatch (SU)~580 GB/s,延迟 ~58 us
Internode MNNVL Combine (SU)~660 GB/s,延迟 ~99 us
全部配置(Internode Elastic EP)144/144 PASS
Internode v2 验证通过:NCCL Gin 将所有 8 GPU(2 × 4)统一管理,NVLink 负责节点内通信,RDMA (GIB) 负责跨节点通信。DeepEP v2 报告所有流量为 Scale-Up (SU),因为传输由 NCCL Gin 代理。

7.5 4-GPU 适配说明(A4X 补丁)

DeepEP 默认假设每节点 8 GPU(NVLink peers = 8),但 A4X 每节点仅 4 GPU。若不修改会导致 assertion 失败或 bitmask 越界。需修改以下常量:

版本常量名修改文件改动
v1NUM_MAX_NVL_PEERScsrc/kernels/configs.cuh
csrc/deep_ep.hpp
csrc/deep_ep.cpp
csrc/kernels/internode.cu
csrc/kernels/layout.cu
8 → 4
v2LEGACY_NUM_MAX_NVL_PEERScsrc/kernels/legacy/compiled.cuh
csrc/kernels/legacy/internode.cu
csrc/kernels/legacy/layout.cu
及 csrc/ 下所有引用文件
8 → 4

核心修改点:

  1. 常量定义:#define NUM_MAX_NVL_PEERS 8 (或 LEGACY_NUM_MAX_NVL_PEERS 8) 改为 4
  2. 断言:static_assert(... == 8) 改为 == 4
  3. 边界检查:num_ranks > NUM_MAX_NVL_PEERS 改为 num_ranks >= NUM_MAX_NVL_PEERS(4 GPU 时 > 4 会跳过本应执行的分支)
  4. Bitmask 类型:8 peers × sizeof(bool) = 8 bytes = uint64_t;4 peers × sizeof(bool) = 4 bytes = uint32_t
参考:A4X 每节点 4 GPU + 4 CX-7 NIC,1:1 映射(GPU 0 ↔ mlx5_0,GPU 1 ↔ mlx5_1,GPU 2 ↔ mlx5_2,GPU 3 ↔ mlx5_3)。标准 A3U (H200) 为 8 GPU,无需此补丁。

7.6 功能测试汇总

路径 A (v1 + CUDA 12) 测试命令

# Intranode(单节点 4 GPU)
cd /tmp/DeepEP/tests/legacy
python test_intranode.py --num-processes 4 --num-experts 64 --num-topk 4

# Low-latency(单节点 4 GPU,需 NVSHMEM 3.4.5)
python test_low_latency.py --num-processes 4 --num-experts 64 --num-topk 4

# Internode(需 NVSHMEM IBGDA,GKE 上受 GDRCopy 限制)
# 需设置:NVSHMEM_REMOTE_TRANSPORT=ibgda  NVSHMEM_DISABLE_CUDA_VMM=1
# 需设置:DEEP_EP_DEVICE_TO_HCA_MAPPING="0:mlx5_0,1:mlx5_1,2:mlx5_2,3:mlx5_3"

路径 B (v2 + CUDA 13) 测试命令

# Intranode(单节点 4 GPU)
cd /scratch-data/DeepEP-v2
python tests/test_intranode.py --num-processes 4

# Internode Elastic EP(2 节点 x 4 GPU,NCCL Gin 后端)
# 使用 /scratch-data/run_deepep_v2_test.sh 脚本(见 7.4 Step 5)
# Pod 2: MASTER_ADDR=<pod1_ip> RANK=1 /scratch-data/run_deepep_v2_test.sh
# Pod 1: MASTER_ADDR=<pod1_ip> RANK=0 /scratch-data/run_deepep_v2_test.sh

CUDA 12 vs CUDA 13 性能对比

指标CUDA 12 (路径 A)CUDA 13 (路径 B)
Intranode dispatch BF16~436 GB/s~461 GB/s
Intranode dispatch FP8~288 GB/s~308 GB/s
Intranode combine~321 GB/s~346 GB/s
Internode (v1 legacy)可用阻塞(NVSHMEM 版本冲突)
Internode (v2 elastic)N/A可用(NCCL Gin,144/144 PASS)
注:A4X 每节点仅 4 GPU,Expert 数量使用 64(非 256),dispatch 吞吐会低于 8 GPU 环境。核心验证目标是 SM_100 (Blackwell) 编译通过、数据正确性全部 PASS。

8. Megatron-LM 训练

DRA 资源声明模式(核心 YAML 结构):以下为训练 YAML 中 DRA 相关的关键字段精简展示。完整 YAML 见下方链接。
# ① ResourceClaimTemplate — 声明需要 4 张 RDMA 网卡(由 DRANET 分配)
apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: rdma-nics-mega-host-1
spec:
  spec:
    devices:
      requests:
      - name: rdma-nics
        exactly:
          deviceClassName: rdma-devices    # ← DeviceClass,由 DRANET 提供
          count: 4                         # ← A4X 每节点 4 张 RDMA NIC

---
# ② Pod spec — 通过 resourceClaims 引用 ComputeDomain 和 RDMA
apiVersion: v1
kind: Pod
metadata:
  name: mega-host-1
spec:
  nodeSelector:
    topology: same-domain                  # ← 手动调度到目标域(后续用 Kueue TAS 替代)
  containers:
  - name: pytorch
    image: nvcr.io/nvidia/pytorch:26.05-py3
    resources:
      limits:
        nvidia.com/gpu: 4                  # ← GPU 由 nvidia-device-plugin 分配
        cpu: "96"                          # ← limits = requests → Guaranteed QoS
        memory: 800Gi
      requests:
        cpu: "96"
        memory: 800Gi
      claims:
      - name: compute-domain-channel       # ← 引用下方 resourceClaims[0]
      - name: rdma-nics                    # ← 引用下方 resourceClaims[1]
    # ... 省略 volumeMounts/env/command ...

  resourceClaims:                          # ← Pod 级资源声明
  - name: compute-domain-channel
    resourceClaimTemplateName: sd-compute-domain-channel  # ← 3.6 步创建 ComputeDomain 时自动生成
  - name: rdma-nics
    resourceClaimTemplateName: rdma-nics-mega-host-1      # ← 上方 ① 手动创建的模板
DRA ≠ 调度:上述 resourceClaims 解决的是「资源分配」——向 K8s DRA 框架申请 IMEX channel(ComputeDomain)和 RDMA 网卡(DRANET)。但 DRA 不负责将多个 Pod 调度到同一 NVL72 域。

域级调度需要另外的机制:
QoS 与防驱逐
上方 YAML 中 requests 与 limits 数值完全相等(CPU 和内存),Pod 将获得 Guaranteed QoS 等级(官方文档)。Guaranteed Pod 在节点内存压力下是最后被驱逐的对象,大幅降低训练被意外中断的风险。
注:nvidia.com/gpu 和 DRA resourceClaims 不影响 QoS 计算,仅 cpu 和 memory 参与。cpu: "96" 和 memory: 800Gi 按 A4X 单节点资源(Grace CPU 72c + HBM)估算,请根据实际调整。
# 部署 Megatron 测试 Pod(ComputeDomain + DRANET)
kubectl apply -f yamls/k8s1341-megatron-train-dranet.yaml  # 查看完整 YAML

# 等待 Pod 就绪(自动 clone Megatron-LM + pip install)
kubectl get pods -l name -w
kubectl logs mega-h1 -f  # 确认 "Ready"

# 交换 SSH 密钥(ed25519)
HOST1_KEY=$(kubectl exec mega-h1 -- cat /root/.ssh/id_ed25519.pub)
HOST2_KEY=$(kubectl exec mega-h2 -- cat /root/.ssh/id_ed25519.pub)
kubectl exec mega-h1 -- bash -c "echo '$HOST2_KEY' >> /root/.ssh/authorized_keys"
kubectl exec mega-h2 -- bash -c "echo '$HOST1_KEY' >> /root/.ssh/authorized_keys"

# 获取 IP
MEGA_HOST1_IP=$(kubectl get pod mega-h1 -o jsonpath='{.status.podIP}')

8.1 单节点 Megatron 训练(Qwen3 30B-A3B MoE FP8,50 iterations)

单节点 EP=4(4 GPU expert 并行),使用 Qwen3 30B-A3B MoE 模型 + TransformerEngine FP8 充分利用 B200 算力。

关键配置:
kubectl exec mega-host-1 -- bash -c "
  source /usr/local/gib/scripts/set_nccl_env.sh 2>/dev/null
  export LD_LIBRARY_PATH=/usr/local/gib/lib64:\$LD_LIBRARY_PATH
  export PYTHONPATH=/scratch-data/Megatron-LM:\$PYTHONPATH
  export CUDA_DEVICE_MAX_CONNECTIONS=1
  export NVTE_ALLOW_NONDETERMINISTIC_ALGO=1
  export NVTE_NORM_FWD_USE_CUDNN=1
  export NVTE_NORM_BWD_USE_CUDNN=1
  export NVTE_FUSED_ATTN=1
  export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True

  cd /scratch-data/Megatron-LM

  torchrun --nproc_per_node=4 --nnodes=1 --node_rank=0 \
    --master_addr=127.0.0.1 --master_port=29502 \
    pretrain_gpt.py \
    --use-mcore-models \
    --transformer-impl transformer_engine \
    --num-layers 12 \
    --hidden-size 2048 \
    --ffn-hidden-size 6144 \
    --num-attention-heads 32 \
    --group-query-attention \
    --num-query-groups 4 \
    --kv-channels 128 \
    --qk-layernorm \
    --num-experts 128 \
    --moe-ffn-hidden-size 768 \
    --moe-router-topk 8 \
    --moe-router-dtype fp32 \
    --moe-token-dispatcher-type alltoall \
    --moe-grouped-gemm \
    --moe-router-force-load-balancing \
    --seq-length 16384 \
    --max-position-embeddings 16384 \
    --position-embedding-type rope \
    --rotary-base 1000000 \
    --rotary-percent 1.0 \
    --swiglu \
    --normalization RMSNorm \
    --disable-bias-linear \
    --untie-embeddings-and-output-weights \
    --attention-backend fused \
    --init-method-std 0.01 \
    --attention-dropout 0.0 \
    --hidden-dropout 0.0 \
    --micro-batch-size 1 \
    --global-batch-size 128 \
    --tensor-model-parallel-size 1 \
    --pipeline-model-parallel-size 1 \
    --expert-model-parallel-size 4 \
    --expert-tensor-parallel-size 1 \
    --sequence-parallel \
    --bf16 \
    --grad-reduce-in-bf16 \
    --fp8-format hybrid \
    --fp8-recipe delayed \
    --fp8-amax-history-len 1024 \
    --fp8-amax-compute-algo max \
    --fp8-param-gather \
    --cross-entropy-loss-fusion \
    --calculate-per-token-loss \
    --use-distributed-optimizer \
    --overlap-grad-reduce \
    --overlap-param-gather \
    --manual-gc \
    --empty-unused-memory-level 1 \
    --train-iters 50 \
    --lr 0.00015 \
    --min-lr 0.00001 \
    --lr-decay-style cosine \
    --lr-warmup-iters 10 \
    --clip-grad 1.0 \
    --weight-decay 0.1 \
    --adam-beta1 0.9 \
    --adam-beta2 0.95 \
    --mock-data \
    --tokenizer-type NullTokenizer \
    --vocab-size 128256 \
    --no-create-attention-mask-in-dataloader \
    --no-mmap-bin-files \
    --num-workers 1 \
    --split '99,1,0' \
    --log-interval 1 \
    --log-throughput \
    --eval-iters 0 \
    --eval-interval 10000 \
    --save-interval 10000 \
    --distributed-timeout-minutes 60
"

8.2 多节点 Megatron 训练(2 节点 EP=8,Qwen3 30B-A3B MoE FP8,MNNVL)

Hostname 解析注意:使用 Pod 网络时,确保 GLOO_SOCKET_IFNAME=eth0 和 NCCL_SOCKET_IFNAME=eth0,避免 Gloo bootstrap 选错网络接口。如 Pod 设置了自定义 hostname,需在 /etc/hosts 中添加 hostname→IP 映射(见 14.6)。
MNNVL:多节点 EP=8 跨 2 台 A4X 使用 NVLink 域互联(MNNVL),需 ComputeDomain + IMEX daemon 提供 CUDA_VISIBLE_DEVICES 多节点内存映射。128 experts / 8 GPU = 16 experts/GPU。
# 获取 Pod IP
MEGA_HOST1_IP=$(kubectl get pod mega-host-1 -o jsonpath='{.status.podIP}')

# 在 mega-host-2 上先启动(node_rank=1)— 后台运行
kubectl exec mega-host-2 -- bash -c "
  source /usr/local/gib/scripts/set_nccl_env.sh 2>/dev/null
  export LD_LIBRARY_PATH=/usr/local/gib/lib64:\$LD_LIBRARY_PATH
  export PYTHONPATH=/scratch-data/Megatron-LM:\$PYTHONPATH
  export CUDA_DEVICE_MAX_CONNECTIONS=1
  export NVTE_ALLOW_NONDETERMINISTIC_ALGO=1
  export NVTE_NORM_FWD_USE_CUDNN=1
  export NVTE_NORM_BWD_USE_CUDNN=1
  export NVTE_FUSED_ATTN=1
  export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
  export GLOO_SOCKET_IFNAME=eth0
  export NCCL_SOCKET_IFNAME=eth0
  export NCCL_MNNVL_ENABLE=2
  export NCCL_CUMEM_ENABLE=1
  export USE_MNNVL=1

  cd /scratch-data/Megatron-LM

  torchrun --nproc_per_node=4 --nnodes=2 --node_rank=1 \
    --master_addr=$MEGA_HOST1_IP --master_port=29503 \
    pretrain_gpt.py \
    --use-mcore-models \
    --transformer-impl transformer_engine \
    --num-layers 12 --hidden-size 2048 --ffn-hidden-size 6144 \
    --num-attention-heads 32 --group-query-attention --num-query-groups 4 \
    --kv-channels 128 --qk-layernorm \
    --num-experts 128 --moe-ffn-hidden-size 768 --moe-router-topk 8 \
    --moe-router-dtype fp32 --moe-token-dispatcher-type alltoall \
    --moe-grouped-gemm --moe-router-force-load-balancing \
    --seq-length 16384 --max-position-embeddings 16384 \
    --position-embedding-type rope --rotary-base 1000000 --rotary-percent 1.0 \
    --swiglu --normalization RMSNorm \
    --attention-dropout 0.0 --hidden-dropout 0.0 \
    --disable-bias-linear --untie-embeddings-and-output-weights \
    --attention-backend fused --init-method-std 0.01 \
    --micro-batch-size 1 --global-batch-size 128 \
    --tensor-model-parallel-size 1 --pipeline-model-parallel-size 1 \
    --expert-model-parallel-size 8 --expert-tensor-parallel-size 1 \
    --sequence-parallel \
    --bf16 --grad-reduce-in-bf16 \
    --fp8-format hybrid --fp8-recipe delayed \
    --fp8-amax-history-len 1024 --fp8-amax-compute-algo max --fp8-param-gather \
    --cross-entropy-loss-fusion --calculate-per-token-loss \
    --use-distributed-optimizer --overlap-grad-reduce --overlap-param-gather \
    --manual-gc --empty-unused-memory-level 1 \
    --train-iters 50 --lr 0.00015 --min-lr 0.00001 \
    --lr-decay-style cosine --lr-warmup-iters 10 \
    --clip-grad 1.0 --weight-decay 0.1 --adam-beta1 0.9 --adam-beta2 0.95 \
    --mock-data --tokenizer-type NullTokenizer --vocab-size 128256 \
    --no-create-attention-mask-in-dataloader --no-mmap-bin-files \
    --num-workers 1 --split '99,1,0' \
    --log-interval 1 --log-throughput --eval-iters 0 \
    --eval-interval 10000 --save-interval 10000 \
    --distributed-timeout-minutes 60
" &

# 在 mega-host-1 上运行(node_rank=0)— 同上但 --node_rank=0
场景配置实测结果
单节点 4 GPUQwen3 30B-A3B MoE, EP=4, FP8+TE, mbs=1, seq=16K~356 TFLOP/s/GPU(稳态 iter 3-50 平均)
多节点 2×4 GPUQwen3 30B-A3B MoE, EP=8, FP8+TE, mbs=1, MNNVL~274 TFLOP/s/GPU(稳态 iter 3-50 平均)
注:MoE 模型的 TFLOP/s 计算包含所有 expert 的 FLOPs(128 experts × topk=8),因此绝对值与 dense 模型(如 Llama2-7B ~785 TFLOP/s)不可直接对比。多节点 EP=8 跨域 alltoall 通信开销导致吞吐下降约 23%。B200 FP8 峰值算力约 4500 TFLOP/s。

9. 多 Domain 训练编排

当训练规模超过单个 NVL72 domain(72 GPU),需要跨 domain 调度。本章基于 2-domain 实验环境说明如何编排多 domain Megatron-LM 训练,并给出扩展到 4+ domain 的指导。

9.1 NVL72 带宽层级

A4X/GB200 的通信带宽随拓扑层级递减,并行策略必须与带宽层级对齐:

层级范围互联技术带宽适合的并行维度
L1 节点内同节点 4 GPUNVLink 5th gen (NVSwitch)~900 GB/sTP(张量并行)
L2 域内跨节点同 domain 18 节点MNNVL(跨节点 NVLink)~840 GB/sEP(专家并行)
L3 跨域不同 domainRDMA over CX-7(4×200Gbps)~165 GB/sDP(数据并行)
性能影响:实测 MoE 模型(Qwen3-30B-A3B)纯 EP=8 训练,同域 MNNVL 达 ~480 TFLOP/s/GPU,跨域 RDMA 降至 ~282 TFLOP/s/GPU(下降 37.7%)。原因是 MoE alltoall 通信量大,跨域 RDMA 带宽(~165 GB/s)远低于域内 MNNVL(~840 GB/s)。

9.2 并行策略与拓扑映射

核心原则:通信量大的并行维度映射到带宽高的层级。

并行维度通信模式通信量推荐映射层级
TP(张量并行)AllReduce,每层 2 次极高(每 iteration 多次)L1 节点内 (≤4)
EP(专家并行)AlltoAll,MoE 层每次 dispatch/combine高(MoE token 重分布)L2 域内 (≤72)
DP(数据并行)AllReduce,梯度同步中(每 iteration 1 次)L3 跨域
PP(流水线并行)点对点,逐 micro-batch低(仅激活值传递)L2 或 L3
Megatron-LM 不自动感知拓扑。parallel_state.py 注释明确写道 "the caller should make sure adjacent ranks are on the same DGX box"。因此,必须由调用方通过 NODE_RANK 编排确保 rank 顺序与物理拓扑对齐。

Rank 编排规则

torchrun 的 rank 计算公式:global_rank = NODE_RANK × nproc_per_node + LOCAL_RANK。Megatron-LM 按 rank 的连续性来切分并行组:

因此,同一 domain 内的节点必须获得连续的 NODE_RANK。例如 2 domain × 18 nodes:

# Domain 0: NODE_RANK = 0, 1, 2, ..., 17  (72 GPU, rank 0-71)
# Domain 1: NODE_RANK = 18, 19, ..., 35   (72 GPU, rank 72-143)
#
# TP=4: rank [0,1,2,3] = node 0 的 4 GPU (✓ 同节点 NVLink)
# EP=72: rank [0-71] 的对应 EP 位置 = domain 0 全部 GPU (✓ 域内 MNNVL)
# DP=2: rank 0 和 rank 72 组成 DP pair (✓ 跨域 RDMA)

9.3 推荐并行配置(MoE 模型)

以 Qwen3-30B-A3B(128 experts, topk=8)为例:

规模节点数GPU 总数TPEPDP每 GPU 专家数跨域通信
1 节点1414132无
1 domain (2 nodes)2818116无(MNNVL)
2 domain2×1814232DP 梯度同步
2 domain (满配)2×18144416≥28DP 梯度同步
4 domain (满配)4×18288432≥24DP 梯度同步
EP 取值约束:EP_SIZE 必须能整除 num_experts(128)。可用值:1, 2, 4, 8, 16, 32, 64, 128。域内 GPU 数不一定能整除 128(如 72),此时取域内最大可用 EP 值(如 EP=64,用 16 节点),剩余节点加入 DP。

9.4 生产调度方案:JobSet + Kueue TAS(推荐)

JobSet(v0.12+)管理多组 Job 作为整体,Kueue(v0.18+)的 TAS(Topology Aware Scheduling)确保每组 Pod 调度到同一拓扑域。相比手动 Pod + nodeSelector(9.5 节),此方案:

步骤 1:定义 Topology CRD

Kueue TAS 需要 Topology 资源定义集群拓扑层级。levels[].nodeLabel 对应节点上的标签(2.4 节已为节点打上 nvl72-domain 标签):

cat <<'EOF' | kubectl apply -f -
apiVersion: kueue.x-k8s.io/v1beta2
kind: Topology
metadata:
  name: gb200-nvl72-topology
spec:
  levels:
  - nodeLabel: "nvl72-domain"          # NVL72 domain 级别(2.4 节标签)
  - nodeLabel: "kubernetes.io/hostname" # 节点级别
EOF

# 验证节点拓扑发现
kubectl get topology gb200-nvl72-topology -o yaml
# 预期:status.levels 显示各 domain 包含的节点列表

步骤 2:创建 Kueue 队列

# ClusterQueue + LocalQueue(如已有可跳过)
cat <<'EOF' | kubectl apply -f -
apiVersion: kueue.x-k8s.io/v1beta2
kind: ResourceFlavor
metadata:
  name: gb200-flavor
spec:
  nodeLabels:                              # ← v1beta2 必须指定 nodeLabels
    nvl72-domain: domain-1                 # ← 按实际 domain 标签值调整
  topologyName: gb200-nvl72-topology       # ← 关联上方 Topology
---
apiVersion: kueue.x-k8s.io/v1beta2
kind: ClusterQueue
metadata:
  name: gpu-cluster-queue
spec:
  namespaceSelector: {}                    # ← 允许所有 namespace 提交(v0.18 必须显式设置)
  resourceGroups:
  - coveredResources: ["cpu", "memory", "nvidia.com/gpu"]
    flavors:
    - name: gb200-flavor
      resources:
      - name: "cpu"
        nominalQuota: 1000
      - name: "memory"
        nominalQuota: 4000Gi
      - name: "nvidia.com/gpu"
        nominalQuota: 288              # ← 4 domain × 72 GPU,按实际调整
---
apiVersion: kueue.x-k8s.io/v1beta2
kind: LocalQueue
metadata:
  name: default-queue
  namespace: default
spec:
  clusterQueue: gpu-cluster-queue
EOF
Kueue v0.18 注意事项(实测验证 2026-06-26):

步骤 3:提交 JobSet

每个 domain 一个 ReplicatedJob,Kueue TAS 保证同一 ReplicatedJob 的所有 Pod 落在同一 NVL72 domain。

apiVersion: jobset.x-k8s.io/v1alpha2
kind: JobSet
metadata:
  name: megatron-2domain
  labels:
    kueue.x-k8s.io/queue-name: default-queue     # ← Kueue 队列
spec:
  network:
    enableDNSHostnames: true                       # ← 自动创建 headless Service + DNS
    publishNotReadyAddresses: true
  replicatedJobs:
  - name: domain-0                                 # ← Domain 0
    replicas: 1
    template:
      spec:
        completionMode: Indexed
        parallelism: 1                             # ← 实验用 1 节点;生产改为 18
        completions: 1                             # ← 与 parallelism 一致
        template:
          metadata:
            annotations:
              # Kueue TAS: 本 PodSet 的所有 Pod 调度到同一 nvl72-domain
              kueue.x-k8s.io/podset-required-topology: "nvl72-domain"
          spec:
            containers:
            - name: pytorch
              image: nvcr.io/nvidia/pytorch:26.05-py3
              resources:
                limits:
                  nvidia.com/gpu: 4
                claims:
                - name: compute-domain-channel
                - name: rdma-nics
              env:
              - name: NNODES
                value: "2"                         # ← 总节点数
              - name: NPROC_PER_NODE
                value: "4"
              - name: DOMAIN_OFFSET
                value: "0"                         # ← domain-0 起始 NODE_RANK
              - name: MASTER_ADDR
                value: "megatron-2domain-domain-0-0-0"  # ← 第一个 pod 的 DNS 名
              - name: MASTER_PORT
                value: "29500"
              - name: NCCL_MNNVL_ENABLE
                value: "0"                         # ← 跨域训练必须关闭
              - name: NCCL_CUMEM_ENABLE
                value: "0"
              - name: GLOO_SOCKET_IFNAME
                value: "eth0"
              - name: NCCL_SOCKET_IFNAME
                value: "eth0"
              command: ["/bin/bash", "-c"]
              args:
              - |
                source /usr/local/gib/scripts/set_nccl_env.sh 2>/dev/null
                export LD_LIBRARY_PATH=/usr/local/gib/lib64:$LD_LIBRARY_PATH

                # NODE_RANK = DOMAIN_OFFSET + JOB_COMPLETION_INDEX
                NODE_RANK=$(( DOMAIN_OFFSET + JOB_COMPLETION_INDEX ))

                cd /scratch-data/Megatron-LM
                torchrun --nproc_per_node=$NPROC_PER_NODE --nnodes=$NNODES \
                  --node_rank=$NODE_RANK \
                  --master_addr=$MASTER_ADDR --master_port=$MASTER_PORT \
                  pretrain_gpt.py \
                  --use-mcore-models --transformer-impl transformer_engine \
                  --num-experts 128 --expert-model-parallel-size 4 \
                  --fp8-format hybrid --fp8-recipe delayed \
                  ...  # 其余参数同第 8 章
            resourceClaims:
            - name: compute-domain-channel
              resourceClaimTemplateName: domain-0-compute-domain-channel
            - name: rdma-nics
              resourceClaimTemplateName: rdma-nics-domain-0
  - name: domain-1                                 # ← Domain 1
    replicas: 1
    template:
      spec:
        completionMode: Indexed
        parallelism: 1                             # ← 实验用 1;生产用 18
        completions: 1
        template:
          metadata:
            annotations:
              kueue.x-k8s.io/podset-required-topology: "nvl72-domain"
          spec:
            containers:
            - name: pytorch
              # ... 同 domain-0,但修改以下字段:
              env:
              - name: DOMAIN_OFFSET
                value: "1"                         # ← 实验用 1;生产用 18
              - name: NCCL_MNNVL_ENABLE
                value: "0"
              # 其余环境变量同 domain-0
            resourceClaims:
            - name: compute-domain-channel
              resourceClaimTemplateName: domain-1-compute-domain-channel
            - name: rdma-nics
              resourceClaimTemplateName: rdma-nics-domain-1
关键机制说明:
特性手动 Pod(9.5 节)JobSet + Kueue TAS(本节)
域级调度nodeSelector 手动指定Kueue TAS podset-required-topology 自动
节点发现SSH + kubectl get pod -o jsonpathDNS hostname(enableDNSHostnames)
NODE_RANK手动编排 --node_rank=0/1JOB_COMPLETION_INDEX + DOMAIN_OFFSET
SSH 密钥交换必须手动交换 ed25519 公钥不需要(torchrun 使用 c10d/Gloo)
故障恢复手动重新部署Job 自动 restart(backoffLimit)
扩展性每 domain 一个 YAML修改 parallelism/completions 和 DOMAIN_OFFSET

Kubeflow Trainer

Kubeflow Trainer(v2.2+)的 TrainJob CRD 集成了 Kueue + JobSet,提供更高级的抽象(自动初始化 torchrun、分配 rank、挂载数据卷),适合已部署 Kubeflow 的团队。

9.5 简易验证方案(手动 Pod + nodeSelector)

本节方法仅适用于小规模实验验证。需要手动管理 SSH 密钥、Pod IP、NODE_RANK。生产环境请使用 9.4 节的 JobSet + Kueue TAS 方案。

以 2 domain × 1 node 为例(EP=4 域内 + DP=2 跨域),每个 domain 部署一个手动 Pod:

# 部署 Pod(Domain 0 使用 ComputeDomain,Domain 1 不使用)
kubectl apply -f yamls/k8s1341-megatron-train-dranet.yaml      # Domain 0  查看 YAML
kubectl apply -f yamls/k8s1341-megatron-cross-domain-pod.yaml  # Domain 1  查看 YAML

# 等待就绪 + 交换 SSH 密钥(同第 8 章)
MEGA_HOST1_IP=$(kubectl get pod mega-host-1 -o jsonpath='{.status.podIP}')

# 跨域关键环境变量
# NCCL_MNNVL_ENABLE=0(必须),NCCL_CUMEM_ENABLE=0,GLOO/NCCL_SOCKET_IFNAME=eth0

# 启动训练(Domain 1 先启动,NODE_RANK=1)
kubectl exec mega-host-2 -- bash -c "
  # ... 环境变量设置(同第 8 章 + 跨域变量)...
  torchrun --nproc_per_node=4 --nnodes=2 --node_rank=1 \
    --master_addr=$MEGA_HOST1_IP --master_port=29503 \
    pretrain_gpt.py \
    --expert-model-parallel-size 4 \   # EP=4 域内
    ...  # 其余同第 8 章
" &
# Domain 0 启动(NODE_RANK=0)— 同上但 --node_rank=0
关键参数对比(同域 vs 跨域):
参数同域(第 8 章)跨域(本章)说明
NCCL_MNNVL_ENABLE20跨域必须关闭
NCCL_CUMEM_ENABLE10cuMem 仅用于 MNNVL
--expert-model-parallel-size8(跨 2 节点)4(仅节点内)EP 限制在域内
DP12自动计算 = world/TP/PP/EP
ComputeDomain需要仅 domain-0跨域无共享 IMEX

9.6 扩展到 4+ Domain

扩展多 domain 训练只需两个调整:NODE_RANK 连续编排 和 并行参数缩放。

NODE_RANK 编排(4 domain × 18 nodes = 72 nodes)

# 确保同一 domain 的节点获得连续 NODE_RANK
#
# Domain 0: NODE_RANK = 0 .. 17   → rank 0-71   (72 GPU)
# Domain 1: NODE_RANK = 18 .. 35  → rank 72-143  (72 GPU)
# Domain 2: NODE_RANK = 36 .. 53  → rank 144-215 (72 GPU)
# Domain 3: NODE_RANK = 54 .. 71  → rank 216-287 (72 GPU)
#
# JobSet 方案:增加 ReplicatedJob(domain-2, domain-3),
# 每个设置 DOMAIN_OFFSET = 36, 54;parallelism/completions = 18
#
# 手动方案:
#   --nnodes=72 --nproc_per_node=4
#   --node_rank=<该节点在全局中的连续编号>
#   --master_addr=<domain 0 第一个节点的 IP/DNS>

并行参数缩放

参数2 domain (2 nodes)2 domain (36 nodes)4 domain (72 nodes)
--nnodes23672
--tensor-model-parallel-size144
--expert-model-parallel-size41632
DP (自动)2≥2≥2
每 GPU 专家数3284
NCCL_MNNVL_ENABLE000
当前保守策略:跨域训练设置 NCCL_MNNVL_ENABLE=0。这会全局关闭 MNNVL,即使域内 EP communicator 也降级为 RDMA。参见 9.7 节的优化方案和待验证实验。

Dense 模型的并行策略

Dense 模型(如 Llama)无 EP 维度,大规模训练的推荐映射:

9.7 待验证优化:Per-Communicator MNNVL(域内 MNNVL + 跨域 RDMA)

本节内容为调研结论,尚未在实验环境中验证。需要至少 2 个 domain 的节点才能测试。

问题

当前跨域训练必须设置 NCCL_MNNVL_ENABLE=0,导致所有通信(包括完全在域内的 EP alltoall)都降级为 RDMA。域内 EP alltoall 从 ~840 GB/s(MNNVL)降至 ~325 GB/s(RDMA),性能损失约 60%。

调研发现

NCCL 源码分析表明,MNNVL 检测实际上是 per-communicator 的(comm->MNNVL 每个 communicator 独立设置)。不同 NVL72 domain 有不同的 clusterUuid,NCCL 通过 clusterUuid + cliqueId 将跨域 rank 排除在 MNNVL clique 之外。

NCCL 版本变化影响来源
≤ 2.26.xMNNVL 探测失败时静默回退到 RDMA—
2.27.3+MNNVL 探测失败时 hard fail(ncclSystemError),不再静默回退。这是之前「必须设为 0」的直接原因Release Notes
2.28.3+新增 NCCL_MNNVL_CLIQUE_ID=-2:按机箱序列号(rack serial)自动分 cliqueRelease Notes: "Add new option NCCL_MNNVL_CLIQUE_ID=-2 which will use rack serial number to partition the MNNVL clique."
2.30.3+新增 NCCL_MNNVL_CROSS_CLIQUE=1:允许跨 clique P2PRelease Notes: "Add support for treating multiple cliques as the same NVLINK domain."
源码: src/init.cc — NCCL_PARAM(MNNVLCrossClique, "MNNVL_CROSS_CLIQUE", 0)
注意:上述环境变量(NCCL_MNNVL_CLIQUE_ID、NCCL_MNNVL_CROSS_CLIQUE)已在 NCCL 开源仓库的 Release Notes 和源码中确认存在,但截至 2026-06 尚未出现在 NCCL 官方环境变量文档页。使用前请确认您的 NCCL 版本 ≥ 对应要求。

GIB v1.1.2 包含 NCCL 2.30.4 和 libnccl-env-gcp.so 插件(向 NCCL 传递 CliqueId/ClusterUUID 拓扑信息),因此上述新特性均可用。理论上 NCCL_MNNVL_ENABLE=2(auto-detect)应能正确处理混合域场景:

验证计划

需要至少 2 个 domain 各 1+ 节点。验证步骤:

# 实验 1:MNNVL auto-detect 基础验证
# 在跨域 2 节点上运行 nccl-tests,观察 MNNVL 检测是否成功
NCCL_MNNVL_ENABLE=2 \
NCCL_DEBUG=INFO \
NCCL_DEBUG_SUBSYS=INIT,NVLS \
mpirun ... all_reduce_perf -b 1G -e 16G

# 观察日志中的关键信息:
#   "MNNVL clique size X, domain size Y"  → clique 是否正确分域
#   "Using NVLS transport"                → 域内是否走 NVLink
#   "Using NET transport"                 → 跨域是否走 RDMA

# 实验 2:Megatron EP=域内 + DP=跨域
# EP communicator 应走 MNNVL,DP communicator 应走 RDMA
NCCL_MNNVL_ENABLE=2 \
NCCL_DEBUG=INFO \
torchrun --nnodes=2 --nproc_per_node=4 \
  pretrain_gpt.py \
  --expert-model-parallel-size 4 \  # EP=4 域内
  ...  # 其余同第 8 章

# 实验 3:若实验 1 失败,尝试手动 clique 分区
NCCL_MNNVL_ENABLE=2 \
NCCL_MNNVL_CLIQUE_ID=-2 \
NCCL_DEBUG=INFO \
mpirun ... all_reduce_perf -b 1G -e 16G

# 对照组:NCCL_MNNVL_ENABLE=0(当前基线)

预期收益:如果验证通过,多 domain 训练中域内 EP alltoall 可从 ~325 GB/s 提升到 ~840 GB/s(+158%),MoE 模型跨域训练吞吐显著提升。

10. 64+8 备用容量管理

为什么需要备用容量?
大规模 GPU 训练中,硬件故障是常态而非例外。NVIDIA Fabric Manager 文档和 GCP GPU 故障排查指南指出,GPU 可能遇到 Xid 错误(如 Xid 79 GPU fault)、NVLink 降速、显存 ECC 错误等。对于 NVL72 域内任一节点故障,整个 MNNVL 训练任务都需要重启。

策略:72 GPU (18 节点 × 4 GPU) 中,64 GPU (16 节点) 做 pre-training,8 GPU (2 节点) 作为备用容量(~11% 冗余)。通过 PriorityClass + Placeholder Pod 实现自动容量管理:故障节点被隔离后,训练 Pod 自动抢占 Placeholder 所在的备用节点,恢复训练。

10.1 PriorityClass 定义

kubectl apply -f yamls/spare-capacity-priority.yaml  # 查看 YAML
kubectl get priorityclass
# gpu-training (1000)  gpu-placeholder (-1)

10.2 Placeholder Pod 部署

kubectl apply -f yamls/spare-capacity-placeholder.yaml  # 查看 YAML

# 验证 Placeholder Pod 已调度到 2 个节点
kubectl get pods -l app=gpu-placeholder -o wide

10.3 训练 Pod 抢占测试

kubectl apply -f yamls/spare-capacity-training-job.yaml  # 查看 YAML

# 验证:训练 Pod 会抢占 Placeholder
kubectl get pods -o wide
# training-preempt-test 应该 Running
# 某个 gpu-placeholder Pod 应该被驱逐

10.4 故障切换 (Cordon/Drain/Uncordon)

# Step 1: 隔离故障节点
kubectl cordon <NODE_NAME>
kubectl drain <NODE_NAME> --ignore-daemonsets --delete-emptydir-data --force

# Step 2: 验证 Pod 重调度
kubectl get pods -l app=gpu-placeholder -o wide

# Step 3: 节点修复后恢复
kubectl uncordon <NODE_NAME>

11. 故障上报 API (Report-Faulty)

官方文档: Report-Faulty API Reference · GKE 故障上报指南

11.1 单节点故障上报

gcloud compute instances report-host-as-faulty <INSTANCE_NAME> \
  --async \
  --disruption-schedule=IMMEDIATE \
  --fault-reasons=behavior=UNRECOVERABLE_GPU_ERROR,description="XID 79 detected" \
  --zone=$ZONE --project=$PROJECT
fault-reasons behavior含义场景
PERFORMANCEGPU 性能下降无 Xid 错误但训练速度下降
UNRECOVERABLE_GPU_ERROR不可恢复 GPU 错误Xid 错误
SILENT_DATA_CORRUPTION静默数据损坏训练结果异常
CHIP_ERROR芯片错误硬件芯片级故障

11.2 Sub-block 域级故障上报

# 查看拓扑结构
gcloud alpha compute reservations blocks list $RESERVATION \
  --zone=$ZONE --project=$PROJECT

gcloud alpha compute reservations sub-blocks list $RESERVATION \
  --block-name=<BLOCK_NAME> \
  --zone=$ZONE --project=$PROJECT

# Sub-block 故障上报
gcloud alpha compute reservations sub-blocks report-subblock-as-faulty $RESERVATION \
  --block-name=<BLOCK_NAME> \
  --sub-block-name=<SUBBLOCK_NAME> \
  --disruption-schedule=IMMEDIATE \
  --fault-reasons=behavior=SWITCH_FAILURE,description="NVSwitch failure" \
  --failure-component=NVLINK_SWITCH \
  --zone=$ZONE --project=$PROJECT

11.3 Python SDK

from google.cloud import compute_v1

def report_host_as_faulty(project_id, zone, instance_name, fault_behavior, description):
    client = compute_v1.InstancesClient()
    request_body = compute_v1.InstancesReportHostAsFaultyRequest(
        disruption_schedule="IMMEDIATE",
        fault_reasons=[
            compute_v1.FaultReason(
                behavior=fault_behavior,
                description=description
            )
        ]
    )
    operation = client.report_host_as_faulty(
        project=project_id, zone=zone, instance=instance_name,
        instances_report_host_as_faulty_request_resource=request_body
    )
    print(f"Operation started: {operation.name}")
    return operation

# 使用示例
report_host_as_faulty(
    project_id="your-gcp-project",       # ← 请替换为您的项目 ID
    zone="us-east5-a",                    # ← 请替换为您的可用区
    instance_name="gb200-d1-w0",          # ← 请替换为故障节点名称
    fault_behavior="UNRECOVERABLE_GPU_ERROR",
    description="XID 79 GPU error detected"
)

12. GPU 监控 (DCGM Exporter)

官方文档: DCGM Exporter GitHub · Grafana Dashboard: ID 12239
kubectl apply -f yamls/dcgm-exporter-daemonset.yaml  # 查看 YAML

# 验证
kubectl get pods -n kube-system -l app=dcgm-exporter
# 每个 GPU Worker 节点一个 Pod

# 测试指标
kubectl exec -n kube-system <DCGM_POD> -- wget -qO- http://localhost:9400/metrics | grep '^DCGM_FI' | head -20

关键监控指标

指标告警阈值含义
DCGM_FI_DEV_GPU_TEMP> 85°CGPU 过热
DCGM_FI_DEV_MEMORY_TEMP> 95°C显存过热
DCGM_FI_DEV_POWER_USAGE> 1000W功耗异常
DCGM_FI_DEV_UNCORRECTABLE_REMAPPED_ROWS> 0不可纠正 ECC 错误
DCGM_FI_DEV_ROW_REMAP_FAILURE> 0行重映射失败(需立即维修)
DCGM_FI_DEV_PCIE_REPLAY_COUNTER持续增长PCIe 链路质量问题

Prometheus + Grafana 集成:DCGM Exporter 默认暴露 :9400/metrics(Prometheus 格式),使用 NVIDIA 官方 Grafana Dashboard ID: 12239。

13. 测试结果汇总

类别测试项实际结果
基础设施GPU 检测 (4×GB200/node)4 GPU × 4 nodes = 16 total
ComputeDomain IMEX 管理daemon pods Ready, IMEX channel 可用
RDMAib_write_bw per NIC~381 Gbps
4×NIC aggregate~1524 Gbps
NCCL单节点 all_reduce 4 GPU @8G683.75 GB/s busbw
同域 2 节点 MNNVL @8G (ComputeDomain)834.95 GB/s busbw
跨域 2 节点 RDMA @8G325.88 GB/s busbw
混合 4 节点 16GPU @8G (MNNVL=0)162.45 GB/s busbw
DeepEP v2Intranode BF16 dispatch24/24 PASS, 435.97 GB/s NVL
Intranode FP8 dispatch24/24 PASS, 288.07 GB/s NVL
Intranode Combine321.35 GB/s NVL
Low-latency dispatch168-188 GB/s, ~20 us
Low-latency combine316-331 GB/s, ~22 us
Elastic EP internode (144 configs)144/144 PASS, dispatch ~750 GB/s SU
Megatron-LM单节点 Qwen3 30B-A3B MoE EP=4 FP8 50 iters~356 TFLOP/s/GPU
多节点 Qwen3 30B-A3B MoE EP=8 MNNVL FP8 50 iters~274 TFLOP/s/GPU
备用容量PriorityClass 创建 (gpu-training=1000, gpu-placeholder=-1)2 PriorityClass created
Placeholder 占位 2 节点2 pods Running
训练 Pod 抢占 PlaceholderPlaceholder evicted, Training Pod scheduled
环境:k8s 1.34.1 + ComputeDomain (DRA GPU Driver v25.12.0) + DRANET v1.3.0 + GIB v1.1.2 + pytorch:26.05-py3
注:k8s 版本变化不影响 GPU/RDMA 数据面性能。测试于 2026-06-19 完成验证。

14. 已知问题与注意事项

14.1 TLinux 4 特性

问题说明
启动盘设备名不固定NVMe 设备编号在不同启动间可能变化,需用 findmnt 动态查找
启动盘分区50GB OS 镜像安装到 1TB 盘后不自动扩展和分区。Startup script 使用 sgdisk 创建客户要求的 4 分区布局(/ 21.5G、/boot/efi 512M、/usr/local 20G、/data ~950G)
缺少基础组件sudo、gcloud CLI、perftest、CUDA Toolkit 均未预装,需手动安装
Docker CE repo需硬编码 RHEL 9 baseurl,TLinux 4 不被 Docker 官方自动识别

14.2 k8s 1.34 DRA + ComputeDomain 注意事项

项目说明
DRA API 版本ResourceClaimTemplate/DeviceClass 使用 resource.k8s.io/v1(GA API,非 v1beta2)
DRA 状态k8s 1.34 中 DRA 为 GA,默认启用,无需 feature gate
kubeadm Scheduler RBACkubeadm 1.34.x 默认 ClusterRole 缺少 DRA 权限(见 3.5 步骤),必须手动补充,否则 ComputeDomain daemon pods 会静默卡在 ContainerCreating
DRANET 版本v1.3.0,安装: helm install dranet oci://registry.k8s.io/networking/charts/dranet --version v1.3.0 -n kube-system
ComputeDomain 互斥ComputeDomain 与 nvidia-imex.service(systemd)和 IMEX Manager DaemonSet 互斥。必须先禁用所有其他 IMEX 管理方式(见 3.2 步骤)
ComputeDomain 节点标签创建后需手动 kubectl label node <NODE> resource.nvidia.com/computeDomain=<UID>,控制器通过此标签的 nodeSelector 调度 daemon pods
IMEX daemon 日志噪音ComputeDomain 按物理域大小(18 节点)配置 IMEX。<18 节点环境下 daemon 会持续尝试连接不存在的节点 — 无害可忽略
NCCL 测试二进制pytorch 镜像自带的 all_reduce_perf 未链接 MPI,多节点测试会退化为独立单 GPU 基准。必须从 nccl-tests 源码编译 MPI 版:make MPI=1 MPI_HOME=/usr/local/mpi NCCL_HOME=/usr/local/gib
mpirun 路径/usr/local/mpi/bin/mpirun(非 /usr/local/gib/bin/mpirun)
Calico 多网卡A4X Worker 有 6 个 NIC (2 GVNIC + 4 MRDMA)。Control Plane 主接口为 eth0,Worker 主接口为 enp0s3,需设置 IP_AUTODETECTION_METHOD=interface=eth0|enp0s3 以匹配两者。使用 VXLAN 模式(IPIP 受 VPC 防火墙限制)
SSH 密钥容器内必须用 ed25519(ssh-keygen -t ed25519),RSA 因无 /dev/tty 会失败

14.3 混合云场景注意事项(自建 Control Plane + GCP Worker)

本节针对 Control Plane 部署在本地 IDC、Worker 节点部署在 GCP 的混合云架构。如果 Control Plane 也在 GCP,可跳过本节。

14.3.1 API Server ↔ Worker 网络打通

本地 API Server 需要与 GCP Worker 双向通信(kubectl exec/logs、Webhook 回调、DRA 控制器通信)。需要配置:

Calico VXLAN 注意:本文档使用 Calico VXLAN 模式(2.2 节)。VXLAN 封装后,跨专线的 Pod 包需要在 MTU 减去 50 字节的 VXLAN overhead。如果专线 MTU 为 1500,Pod 内 MTU 应设为 1450。Calico 配置 vxlanMTU 字段可调整此值。

14.3.2 DRA 控制器跨网络认证

DRA GPU Driver 控制器(运行在 Worker 节点上)和 Scheduler(运行在 Control Plane 上)之间通过 API Server 通信。在混合云环境需确保:

14.3.3 自定义准入控制器兼容性

如果客户的 Control Plane 使用了自定义 Admission Controller 或非标准用户体系(OIDC/LDAP),需确保:

14.4 VPC 管理网卡 MTU

GVNIC 管理网络的 MTU 必须设置为 8896(Jumbo Frames)。默认 MTU 1460/1500 会导致 Lustre 吞吐量下降约 10%。创建 VPC 时使用 --mtu=8896。

14.5 Megatron-LM GB200 性能优化要点

以下配置对 B200 GPU 性能至关重要:

配置说明
--transformer-impl transformer_engine必须使用 TE(core_r0.16.0 默认值)。local 实现为未优化的纯 PyTorch 路径,无法使用 FP8/融合注意力
FP8 参数--fp8-format hybrid --fp8-recipe delayed。B200 FP8 Tensor Core 吞吐约为 BF16 的 2 倍
GB200 环境变量NVTE_FUSED_ATTN=1、NVTE_NORM_FWD_USE_CUDNN=1、NVTE_NORM_BWD_USE_CUDNN=1 启用 GB200 专属优化内核
移除 --no-*-fusion所有 --no-masked-softmax-fusion、--no-bias-gelu-fusion 等标志会禁用算子融合,严重影响性能
--sequence-parallel沿序列维度分布 LayerNorm/Dropout 计算
--use-distributed-optimizerZeRO-1 优化器状态分片,降低显存占用
--overlap-grad-reduce梯度 all-reduce 与反向传播重叠
参考:NVIDIA 官方 GB200 配置位于 Megatron-LM 仓库 tests/functional_tests/test_cases/gpt/gpt3_15b_8t_release_gb200/model_config.yaml

14.6 网卡绑定(Bond)不适用

结论:GCP A4X 实例不支持传统的 Linux bonding(bond0/bond1 等),无需配置。

GCP A4X/GB200 的网络架构与物理服务器不同,使用两类虚拟网卡:

类型设备名数量用途冗余机制
GVNICeth0, eth12管理网络(SSH、k8s API、Pod CIDR)GCP Andromeda SDN 在虚拟化层提供 HA,无需 bond
MRDMAmlx5_0 .. mlx5_34GPU RDMA 计算网络(GPUDirect、NCCL)SR-IOV VF 由 GCP RDMA 基础设施管理,通过 DRANET DRA 分配,不兼容 bond

不适用的原因:

GCP 替代方案:

注意:客户的《外 GPU 适配规范》中关于 bond1-bond5 的要求是针对物理服务器 / 自建 IDC 环境的标准。在 GCP A4X 上,这些网卡绑定配置不适用,对应的网络冗余和 RDMA 功能通过上述 GCP 原生机制实现。

14.7 nvidia-fabricmanager 不适用

GCP A4X 的 NVSwitch 由虚拟化层(hypervisor)管理,Guest VM 无需也不应运行 Fabric Manager 服务。

官方依据:根据 NVIDIA Fabric Manager User Guide 关于 Shared NVSwitch Virtualization 模式的说明:

GCP A4X 采用此架构:NVSwitch 由 GCP hypervisor 层的 Service VM 管理。在 Guest 内尝试启动 nvidia-fabricmanager 会报错:

Detected Pre-NVL5 system
request to query NVSwitch device information from NVSwitch driver failed with error:
WARNING Nothing to do [NV_WARN_NOTHING_TO_DO]

这是预期行为,NVLink/NVSwitch 通信正常工作(已验证 834.95 GB/s busbw),不受影响。

佐证:GCP 官方发布的 Rocky Linux 10 GPU 加速镜像(nvidia-580 和 nvidia-latest 变体,项目 rocky-linux-accelerator-cloud)均不包含 Fabric Manager 包,仅包含 IMEX 和 persistenced 服务。

总结:客户的《适配规范》中 fabric-manager 要求是针对物理 GB200 NVL72 机架的标准。在 GCP A4X 上,NVSwitch 管理由虚拟化层自动完成,无需安装 Fabric Manager。镜像 tlinux-server-4-gb200-v3 已按此标准不再包含 FM。

14.8 nvidia_peermem 不适用

GCP A4X 的 GPU Direct RDMA 通过 GIB 插件(nccl-plugin-gib)实现,不使用传统的 nvidia_peermem 内核模块。尝试加载该模块会返回 EINVAL。

这是预期行为。Pod 中通过 GIB initContainer 注入 RDMA 库(/usr/local/gib/),NCCL 通过 GIB 路径完成 GPU-NIC DMA 映射,不依赖 nvidia_peermem。

14.9 DeepEP v1 vs v2 选择建议

维度DeepEP v1 (CUDA 12)DeepEP v2 (CUDA 13)
Internode 后端NVSHMEM IBGDA — 需 GDRCopy(GCP 不可用)NCCL Gin — 完全兼容 GCP
Intranode正常工作正常工作
NVSHMEM 依赖严格要求 3.4.5(GB200)或 3.3.9(B200/H200)仅编译时需要,运行时不依赖
CUDA 容器pytorch:25.04-py3 (CUDA 12)pytorch:26.04-py3 / 26.05-py3 (CUDA 13)
GCP 推荐仅 intranode 场景推荐(internode 已验证 144/144 PASS)
核心决策:如需跨节点 Expert Parallelism(internode EP),必须使用 DeepEP v2。v1 的 internode 通信依赖 NVSHMEM IBGDA + GDRCopy,而 GDRCopy 在 GKE/GCP 环境中无法使用(内核模块不可加载)。v2 使用 NCCL Gin 后端完全消除此依赖。详见 GitHub Issue #579。

附录 A. VM 交付验收对照表

本表基于客户提供的《[对外]外GPU (GB) 适配规范-GCP》,逐项对照 GCP A4X 实例的实际状态与替代方案。 使用 TLinux 4 自定义镜像 tlinux-server-4-gb200-v1。

B.1 系统与安全配置

适配项客户标准客户备注GCP 适配状态GCP 说明
操作系统 TencentOS Server 4.0 ARM 满足 使用 tlinux-server-4-gb200-v1 自定义镜像,基于 TencentOS 4.0 aarch64
SELinux Disabled 满足 startup script 设置 SELINUX=disabled
Firewalld Disabled 满足 startup script 执行 systemctl disable --now firewalld
SSH 端口 仅允许 56000 满足 startup script 修改 sshd_config Port 56000
docker/kubelet 不安装 满足 客户版 startup script 不安装容器运行时和 k8s 组件
主机名 无特殊要求 满足 使用 GCE 默认主机名

B.2 网络与网卡配置

适配项客户标准客户备注GCP 适配状态GCP 说明
管理网卡 bond1 (2块管理网卡) 不适用 GCP A4X 使用 GVNIC 虚拟网卡 (eth0/eth1),由 Andromeda SDN 管理,不支持/不需要 bond。详见 14.5 网卡绑定不适用
RDMA 网卡 bond2-bond5 (4块 RDMA) 替代方案 4 块 MRDMA NIC (mlx5_0..mlx5_3),通过 DRANET DRA ResourceClaim 分配给 Pod,不使用 bond
ibdev2netdev mlx5_bond_X ==> bondY 左右两侧需按序号递增 替代方案 A4X 输出为 mlx5_0 port 1 ==> rdma0 格式(独立 RDMA 设备,非 bond)
网卡 MTU ≥ 4200 满足 GCP VPC 配置 MTU=8896(Jumbo Frames)
网卡驱动版本 ≥ 5.8 GPU/网卡驱动需要 TX 签名 满足 mlx5_core 版本 25.10-1.2.2

B.3 GPU 驱动与服务

适配项客户标准客户备注GCP 适配状态GCP 说明
GPU 驱动版本 ≥ 535.247.01 满足 NVIDIA 580.126.20(R580 Open)
nvidia 模块 已加载 满足 开机自动加载
nvidia_uvm 模块 已加载 满足 开机自动加载
nvidia_drm 模块 已加载 满足 开机自动加载
nvidia_modeset 模块 已加载 满足 开机自动加载
nvidia_peermem 模块 已加载 不适用 GCP A4X 使用 GIB 插件替代 nvidia_peermem 实现 GPUDirect RDMA。详见 14.7 nvidia_peermem 不适用
gdrdrv 模块 已加载 满足 startup script 从源码编译安装 GDRCopy v2.6,加载 gdrdrv 并持久化
gdrcopy 服务 active + 开机自启 满足 GDRCopy v2.6 systemd 服务,systemctl enable
nvidia-fabricmanager active + 开机自启 不适用 GCP A4X 采用 Shared NVSwitch 虚拟化架构,NVSwitch 由 hypervisor Service VM 管理。详见 14.7 nvidia-fabricmanager 不适用
NCCL/GIB 包含 GIB 1.1.2 满足 GIB v1.1.2 通过 Pod initContainer 注入

B.4 存储与磁盘

适配项客户标准客户备注GCP 适配状态GCP 说明
Boot disk 容量 1TB 满足 Boot disk 1TB (Hyperdisk Balanced)
分区格式 跟随系统默认 满足 ext4/xfs(TLinux 默认)
sda1 (/) 21.5G 根目录 21.5G lsblk: sda1 21.5G / 满足 startup script 分区 boot disk,根分区 21.5G
sda2 (/boot/efi) 512M EFI 分区 512M 满足 TLinux 镜像默认 EFI 分区 512M
sda3 (/usr/local) 20G 独立分区 20G lsblk: sda3 20G /usr/local 满足 startup script 在 boot disk 上创建独立分区 20G 并挂载到 /usr/local
sda4 (/data) 852.2G 数据分区 852.2G lsblk: sda4 852.2G /data 满足 startup script 在 boot disk 剩余空间创建 /data 分区(约 950G)
Local SSD — 满足 Local NVMe SSD RAID0 挂载到 /mnt/stateful_partition,用于 scratch/cache(临时数据,关机后清除)
Lustre 1PB 随 GB200 交付 满足 GCP Parallel Store (Lustre) 通过 CSI 驱动 PV/PVC 挂载

B.5 Startup Scripts

根据客户要求准备了两个版本的初始化脚本:

适配项客户标准客户备注GCP 适配状态GCP 说明
客户交付脚本 满足上述所有配置要求 满足 tlinux4-customer-init.sh — 不安装 docker/kubelet、SSH 56000、SELinux disabled、GDRCopy v2.6、boot disk 分区
内部测试脚本 — — tlinux4-internal-init.sh — 包含 containerd + NVIDIA Container Toolkit + kubeadm/kubelet/kubectl k8s 1.34
注意:以上对照表中标注"不适用"的项目(bond、nvidia_peermem、nvidia-fabricmanager)是针对物理服务器 / 自建 IDC 环境的标准。在 GCP A4X 上,对应功能通过 GCP 原生机制实现(Andromeda SDN、GIB 插件、虚拟化层 NVSwitch 管理),功能等价但实现方式不同。

附录 B. 集成调试记录

以下内容为集成验证过程中发现的工具级注意事项和框架参数变更记录,供调试参考。

B.1 DeepEP v2 Internode 测试注意事项

DeepEP v2 internode 使用 Elastic EP 测试 (tests/elastic/test_ep.py),基于 NCCL GIN 后端。不要使用 tests/legacy/test_internode.py,该测试会因 LEGACY_NUM_MAX_NVL_PEERS=8 assertion 在 4-GPU A4X 上失败。

B.2 DeepEP 构建配置

DeepEP 需从源码编译(pip 版本无 SM_100 支持)。关键配置:

B.3 ib_write_bw IBVERBS 路径冲突

GIB 的 libibverbs 库 (/usr/local/gib/lib64/) 可能覆盖系统版本。运行 ib_write_bw 前需切换:export LD_LIBRARY_PATH=/usr/lib/aarch64-linux-gnu。

B.4 Megatron-LM 参数变更记录

B.5 短主机名(Megatron 必需)

Megatron-LM 使用 Gloo 进行进程通信。如果 Pod hostname 过长,会触发 File name too long 错误。解决方案:在 Pod spec 中设置 hostname 字段为短名称(如 mega-h1)。

B.6 Megatron 多节点 hostname 解析

Pod 设置自定义 hostname(如 mega-h1)时,NCCL bootstrap 和 Gloo 会调用 gethostbyname() 获取自身 IP。如果该 hostname 没有 DNS 记录,解析失败会导致 静默 hang。

症状:initialized tensor model parallel 后不再有输出,进程占用 100% CPU。

修复方案(任选一):

同时需设置 NCCL_SOCKET_IFNAME=eth0 和 GLOO_SOCKET_IFNAME=eth0。

附录 C. 压测标准

本附录基于客户提供的《压测标准》,列出 GEMM、NCCL 和训练性能的验收指标与 GCP A4X 实测数据。

C.1 GEMM 性能

精度GB200 官方数据 (TFLOP/s)GCP A4X 实测 (TFLOP/s)
FP465076845
FP828053063
FP1613721492
BF1614711592
TF32675733
FP327575

压测工具:cublas_bench_gb2_3.sh

C.2 NCCL 性能

Packet size = 16GB,单位 busbw (GB/s)。

配置AllReduceAll2AllAllGatherReduceScatter
GB200 × 4 × 18(1 domain, 72 GPU)845.01660.61687.94707.22
GB200 × 4 × 36(2 domain, 144 GPU)749.5665.47749.56689.05
GB200 × 4 × 72(4 domain, 288 GPU)待测
2-domain All2All 带宽说明:跨 domain All2All 仅 65.47 GB/s,远低于同域 660 GB/s。这是预期行为——跨域通信走 RDMA(4×CX-7 200Gbps),AlltoAll 的通信模式对跨域带宽敏感度最高,因为每个 GPU 需要与所有其他 GPU 交换数据,跨域链路成为瓶颈。其他 collective(AllReduce/AllGather/ReduceScatter)可通过 ring/tree 算法在域内完成大部分计算,跨域仅传递部分数据,因此影响较小。

C.3 训练性能

模型seq_lenGPU 数mbsgbs并行策略iteration_time (ms)tokens/gpu/sTFLOP/s/gpuMFU
LLaMA2-7B409644256tp1pp1940627,8701,12745.08%
LLaMA2-7B409684256tp1pp1488126,8541,08643.44%
LLaMA2-13B409641256tp1pp11897813,8131,06542.60%
LLaMA2-13B409682256tp1pp1961413,6331,06542.60%
LLaMA3-70B40966421024tp4pp2283552,31197138.83%
环境:TransformerEngine v2.15 · Megatron-LM core_r0.16.0 · nvcr.io/nvidia/pytorch:26.05-py3
TFLOP/s 估算:6N 简化公式,B200 FP8 理论峰值 2500 TFLOP/s。

文档生成于 2026-06-23 · GCP GPU Infrastructure Team
基于 GCP GB200 A4X 集群验证
k8s 1.34.1 + ComputeDomain (DRA GPU Driver v25.12.0) + DRANET v1.3.0 + GIB v1.1.2 + pytorch:26.05-py3