日期: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
hostNetwork: true)即可独占 RDMA 网卡,显著提升了多租户集群的安全性nvidia.com/gpu: 4)下表对比三代 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 |
参考来源: NVIDIA GB200 NVL72 · NVIDIA NVLink(含各代带宽对比)
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 镜像 |
-arm64 后缀。
参考来源: GCP Accelerator-Optimized Machines (A4X) · Placement Policy 概述
下表汇总本指南中频繁出现的技术术语,方便随时查阅。
| 概念 | 说明 |
|---|---|
| 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 ──────────────────────────────────┐
│ ... │
└────────────────────────────────────────────────────────────────────────┘
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 可用。
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 遥测系统,用于性能调优和问题诊断。 |
GIB v1.1.2 的推荐使用方式是通过 set_nccl_env.sh 脚本,该脚本仅设置一个环境变量:
export NCCL_ENV_PLUGIN=gcp
当 NCCL 初始化时,libnccl-env-gcp.so 插件(Env 插件)被自动加载,执行以下流程:
a4x-megagpu-8g)/usr/local/gib/configs/nccl.<platform>.conf 配置文件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 内置调优)
NCCL_NET、NCCL_IB_* 等)。Env 插件的引入使得用户只需设置 NCCL_ENV_PLUGIN=gcp(或运行 set_nccl_env.sh),即可获得 Google 针对特定平台验证过的最优配置。这种方式的优势:在 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 插件自动检测
libnccl-net.so 产生符号冲突。如果容器基础镜像自带其他版本的 NCCL,需通过 LD_LIBRARY_PATH 确保优先加载 GIB 目录下的版本。版本不匹配会导致 NCCL 初始化失败或性能下降。us-docker.pkg.dev/gce-ai-infra/gpudirect-gib/。
| 域内(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 相关变量 |
# ===== 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 一致)
gcloud CLI 并认证# 创建主 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
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
--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
# 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
--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) |
gcloud compute reservations describe $RESERVATION \
--zone=$ZONE --project=$PROJECT \
--format="table(specificReservation.count, specificReservation.inUseCount)"
# 为每个 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
# 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 规则
resource.k8s.io/v1(非 v1beta2)。
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
kubeadm init --pod-network-cidr=10.244.0.0/16# 方法 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 配置文档
IP_AUTODETECTION_METHOD=interface=eth0。CP 节点(x86 Rocky Linux)主接口为 eth0,但 A4X Worker 节点(ARM64 TencentOS)主接口为 enp0s3。Worker 加入集群后 calico-node 会因找不到 eth0 而 CrashLoopBackOff。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
# 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"
Placement Policy(1.3 节创建),--resource-policies 参数决定 VM 分配到哪个 Domaingcloud compute(不是 alpha/beta),不加 --local-ssd(A4X 自动挂载 12TB NVMe)no-address on MRDMA — 网络 profile 不允许 MRDMA 接口有 AccessConfig# 循环创建所有 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_PREFIX}-d${DOMAIN}-w${INDEX},例如 gb200-d1-w0 到 gb200-d1-w17 为 Domain 1 的 18 个节点。不同 Domain 的 Worker 使用不同的 Placement Policy,确保 VM 分配到对应的 NVSwitch Domain。
TLinux 4 Worker 使用 2 阶段设置脚本 tlinux4-k8s134-worker.sh 查看完整脚本:
NVreg_CreateImexChannel0=1) + dracut --force + 自动重启kubeadm join# 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)
baseurl=https://download.docker.com/linux/rhel/9/$(uname -m)/stable(TLinux 4 基于 RHEL 9)nvidia.github.io/libnvidia-container/stable/rpm repofindmnt 动态查找# 按 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
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
| 方式 | 端点 | 权限要求 | 返回值 |
|---|---|---|---|
| Metadata Server(推荐) | http://metadata.google.internal/.../physical_host_topology | 无(VM 内部直接访问) | 拓扑哈希字符串 |
| Compute API | gcloud compute instances describe --format='value(resourceStatus.physicalHostTopology.subblock)' | 需要 compute.instances.get IAM 权限 | 结构化的 subblock 标识 |
/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 管理风格,但两者技术上无差异。
resource.k8s.io/v1。
使用 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"
4 个 GPU。
# 安装 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
/dev/nvidia-caps-imex-channels/channel0 存在)。这在 Worker 启动脚本的 Phase 1 中已配置(NVreg_CreateImexChannel0=1 + dracut --force + reboot)。nvidia-imex.service 在运行,必须先停止:systemctl stop nvidia-imex && systemctl disable nvidia-imex
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
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
# 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
# 前提: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
nodeSelector 调度到其中 2 个节点,任务 B 调度到另外 4 个节点,两个任务都引用同一个 sd-compute-domain-channel ResourceClaimTemplate,均可使用 MNNVL。
Kubeflow MPI Operator v0.8.0 自动管理分布式 MPI 任务的 SSH 密钥分发、hostfile 注入和作业生命周期。在 5.2/5.3 节的多节点 NCCL 测试中使用 MPI Operator 可免去手动配置 SSH 互信和 nccl-tests 二进制分发的繁琐操作。
mpirun,Worker 运行 sshd + GPU 工作负载# 安装 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
sshd。NGC PyTorch 镜像自带 OpenMPI 但不含 openssh-server。本指南的 MPIJob YAML 通过 Worker 启动命令在运行时安装 sshd 并从源码编译 MPI 版 nccl-tests。详见 5.2 节。
每个 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 高速缓存
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
--file-cache-enable-parallel-downloads:启用文件级并行下载(v2 新增)--file-cache-parallel-downloads-per-file=16:每个文件最多 16 个并行块--file-cache-capacity-per-file-mb=-1:不限制单文件缓存大小--kernel-list-cache-ttl-secs=600:目录列表缓存 10 分钟,减少 metadata API 调用/mnt/stateful_partition/gcsfuse-cache),A4X 自带 ~12TB NVMe,提供极高的缓存 IOPS。
如果客户提供 Lustre 文件系统,使用 PV/PVC 方式挂载。lustre-pv-pvc.yaml
# 部署单节点测试 Pod
kubectl apply -f yamls/k8s1341-nccl-single-node.yaml # 查看 YAML
# 等待完成
kubectl logs nccl-single-node -f
| 指标 | 实测结果 |
|---|---|
| all_reduce 4 GPU @8G | 683.75 GB/s busbw |
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
nccl-mpi-sd-ssh)mpirun 在所有 Worker 上执行 all_reduce_perfkubectl exec 交换 SSH 密钥、无需手动 scp 二进制文件、无需手动拼接 --host 参数。
| 指标 | 实测结果 |
|---|---|
| all_reduce 8 GPU @8G (MNNVL) | 836.55 GB/s busbw |
| 平均 bus bandwidth | 750.61 GB/s |
跨域节点无 MNNVL,使用纯 RDMA (GPUDirect/GIB) 通信。不需要 ComputeDomain channel(无 IMEX)。与 5.2 节的 MPIJob 相比,主要差异:
compute-domain-channel(无 IMEX channel)NCCL_MNNVL_ENABLE=0,NCCL_CUMEM_ENABLE=0topology=cross-domain(分属不同物理域)# 部署跨域 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 |
生产环境中使用 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=0。
设置为 2(自动检测)时,NCCL 会在跨域节点(无 IMEX channel)上尝试探测 MNNVL 能力导致 CUDA error。
如需同时利用同域 MNNVL 和跨域 RDMA,应将同域与跨域分离为独立的通信组。
| 指标 | 实测结果 |
|---|---|
| all_reduce 16 GPU @8G (纯 RDMA) | 162.45 GB/s busbw |
在同域 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) |
DeepEP 是 DeepSeek 开源的 Expert Parallelism (EP) 通信库。本节提供两条并行部署路径供选择:
| 路径 | DeepEP 版本 | CUDA | Internode 后端 | NVSHMEM | NCCL |
|---|---|---|---|---|---|
| 路径 A(稳定/传统) | v1 | CUDA 12 | NVSHMEM IBGDA | 3.4.5(必需) | 2.25+ |
| 路径 B(推荐/新版) | v2 (main) | CUDA 13 | NCCL Gin | 可选/仅编译用 | ≥ 2.30.4 |
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) 的另一重要原因。| NVSHMEM 版本 | Struct 布局 | ibgda RC QP 索引 | DMABuf 支持 | DeepEP 兼容 | GB200 状态 |
|---|---|---|---|---|---|
| 3.3.9 | v1 | PE-major | 无 ibv_reg_dmabuf_mr | 兼容 | 失败(无 nvidia_peermem,无 DMABuf FD) |
| 3.4.5 | v1 | PE-major | ibv_reg_dmabuf_mr | 兼容 | 可用(GB200 推荐) |
| 3.5.x+ | v2 | QP-ID-major | ibv_reg_dmabuf_mr | 不兼容 | 失败(struct/索引与 DeepEP 不匹配) |
| GPU 平台 | 推荐 NVSHMEM 版本 | 原因 |
|---|---|---|
| GB200 (A4X) | 3.4.5 | GB200 不支持 POSIX FD handle(CUDA attr 92=0),nvidia_peermem 无法加载;3.4.5 通过 ibv_reg_dmabuf_mr 绕过此限制 |
| B200 / H200 | 3.3.9 | 支持 nvidia_peermem,无需 DMABuf;struct v1 兼容 DeepEP |
适用容器: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/
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
"
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
"
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 dispatch | 24/24 PASS,best 435.97 GB/s NVL (SMs=24, chunk=32) |
| Intranode FP8 dispatch | 24/24 PASS,best 288.07 GB/s NVL (SMs=24, chunk=32) |
| Intranode Combine | PASS,best 321.35 GB/s NVL (SMs=24, chunk=16) |
| Low-latency dispatch | 168-188 GB/s,延迟 ~20 us |
| Low-latency combine | 316-331 GB/s,延迟 ~22 us |
适用容器: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)。容器自带 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
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
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')"
LD_LIBRARY_PATH — GIB 自带 NCCL 2.28.9,与容器 NCCL 2.29.7 冲突,会导致编译链接错误。cd /scratch-data/DeepEP-v2
export LD_LIBRARY_PATH=/usr/local/nvidia/lib64:${LD_LIBRARY_PATH}
python tests/test_intranode.py --num-processes 4
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 BF16 | 24/24 PASS,best 460.87 GB/s NVL (SMs=24, chunk=32) |
| Intranode dispatch FP8 | 24/24 PASS,best 308.11 GB/s NVL (SMs=24, chunk=32) |
| Intranode Combine | PASS,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 |
DeepEP 默认假设每节点 8 GPU(NVLink peers = 8),但 A4X 每节点仅 4 GPU。若不修改会导致 assertion 失败或 bitmask 越界。需修改以下常量:
| 版本 | 常量名 | 修改文件 | 改动 |
|---|---|---|---|
| v1 | NUM_MAX_NVL_PEERS | csrc/kernels/configs.cuhcsrc/deep_ep.hppcsrc/deep_ep.cppcsrc/kernels/internode.cucsrc/kernels/layout.cu | 8 → 4 |
| v2 | LEGACY_NUM_MAX_NVL_PEERS | csrc/kernels/legacy/compiled.cuhcsrc/kernels/legacy/internode.cucsrc/kernels/legacy/layout.cu及 csrc/ 下所有引用文件 | 8 → 4 |
核心修改点:
#define NUM_MAX_NVL_PEERS 8 (或 LEGACY_NUM_MAX_NVL_PEERS 8) 改为 4static_assert(... == 8) 改为 == 4num_ranks > NUM_MAX_NVL_PEERS 改为 num_ranks >= NUM_MAX_NVL_PEERS(4 GPU 时 > 4 会跳过本应执行的分支)sizeof(bool) = 8 bytes = uint64_t;4 peers × sizeof(bool) = 4 bytes = uint32_t# 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"
# 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 (路径 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) |
# ① 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 # ← 上方 ① 手动创建的模板
resourceClaims 解决的是「资源分配」——向 K8s DRA 框架申请 IMEX channel(ComputeDomain)和 RDMA 网卡(DRANET)。但 DRA 不负责将多个 Pod 调度到同一 NVL72 域。nodeSelector: {topology: same-domain}(本章方法,适合验证)podset-required-topology 注解(详见 9.4 生产调度方案)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}')
单节点 EP=4(4 GPU expert 并行),使用 Qwen3 30B-A3B MoE 模型 + TransformerEngine FP8 充分利用 B200 算力。
--transformer-impl transformer_engine 启用 TE 融合算子(不要使用 local)--fp8-format hybrid + --fp8-recipe delayed 启用 FP8 训练NVTE_FUSED_ATTN=1 / NVTE_NORM_*_USE_CUDNN=1 启用 GB200 优化内核--expert-model-parallel-size 4(单节点 128 experts / 4 GPU = 32 experts/GPU)--moe-grouped-gemm 启用分组 GEMM 优化 MoE 计算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
"
GLOO_SOCKET_IFNAME=eth0 和 NCCL_SOCKET_IFNAME=eth0,避免 Gloo bootstrap 选错网络接口。如 Pod 设置了自定义 hostname,需在 /etc/hosts 中添加 hostname→IP 映射(见 14.6)。
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 GPU | Qwen3 30B-A3B MoE, EP=4, FP8+TE, mbs=1, seq=16K | ~356 TFLOP/s/GPU(稳态 iter 3-50 平均) |
| 多节点 2×4 GPU | Qwen3 30B-A3B MoE, EP=8, FP8+TE, mbs=1, MNNVL | ~274 TFLOP/s/GPU(稳态 iter 3-50 平均) |
当训练规模超过单个 NVL72 domain(72 GPU),需要跨 domain 调度。本章基于 2-domain 实验环境说明如何编排多 domain Megatron-LM 训练,并给出扩展到 4+ domain 的指导。
A4X/GB200 的通信带宽随拓扑层级递减,并行策略必须与带宽层级对齐:
| 层级 | 范围 | 互联技术 | 带宽 | 适合的并行维度 |
|---|---|---|---|---|
| L1 节点内 | 同节点 4 GPU | NVLink 5th gen (NVSwitch) | ~900 GB/s | TP(张量并行) |
| L2 域内跨节点 | 同 domain 18 节点 | MNNVL(跨节点 NVLink) | ~840 GB/s | EP(专家并行) |
| L3 跨域 | 不同 domain | RDMA over CX-7(4×200Gbps) | ~165 GB/s | DP(数据并行) |
核心原则:通信量大的并行维度映射到带宽高的层级。
| 并行维度 | 通信模式 | 通信量 | 推荐映射层级 |
|---|---|---|---|
| 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 |
parallel_state.py 注释明确写道 "the caller should make sure adjacent ranks are on the same DGX box"。因此,必须由调用方通过 NODE_RANK 编排确保 rank 顺序与物理拓扑对齐。torchrun 的 rank 计算公式:global_rank = NODE_RANK × nproc_per_node + LOCAL_RANK。Megatron-LM 按 rank 的连续性来切分并行组:
TP_SIZE 个 rank(TP=4 时:rank 0-3 = 1 个 TP group,对应 1 个节点的 4 GPU)EP_SIZE 个 rank 组成 EP group因此,同一 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)
以 Qwen3-30B-A3B(128 experts, topk=8)为例:
| 规模 | 节点数 | GPU 总数 | TP | EP | DP | 每 GPU 专家数 | 跨域通信 |
|---|---|---|---|---|---|---|---|
| 1 节点 | 1 | 4 | 1 | 4 | 1 | 32 | 无 |
| 1 domain (2 nodes) | 2 | 8 | 1 | 8 | 1 | 16 | 无(MNNVL) |
| 2 domain | 2×1 | 8 | 1 | 4 | 2 | 32 | DP 梯度同步 |
| 2 domain (满配) | 2×18 | 144 | 4 | 16 | ≥2 | 8 | DP 梯度同步 |
| 4 domain (满配) | 4×18 | 288 | 4 | 32 | ≥2 | 4 | DP 梯度同步 |
EP_SIZE 必须能整除 num_experts(128)。可用值:1, 2, 4, 8, 16, 32, 64, 128。域内 GPU 数不一定能整除 128(如 72),此时取域内最大可用 EP 值(如 EP=64,用 16 节点),剩余节点加入 DP。JobSet(v0.12+)管理多组 Job 作为整体,Kueue(v0.18+)的 TAS(Topology Aware Scheduling)确保每组 Pod 调度到同一拓扑域。相比手动 Pod + nodeSelector(9.5 节),此方案:
enableDNSHostnames: true 自动创建 headless Service,Pod 通过 DNS 互相发现(源码 Network struct)JOB_COMPLETION_INDEX 环境变量直接映射为 NODE_RANKpodset-required-topology 注解确保同一 ReplicatedJob 的 Pod 调度到同一 NVL72 domain,无需手动 nodeSelectorKueue 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 包含的节点列表
# 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.x-k8s.io/v1beta2 API(v1beta1 已弃用)ResourceFlavor 在设置 topologyName 时,必须同时提供 nodeLabels,否则创建失败ClusterQueue 需要 namespaceSelector: {},否则 Workload 会因 namespace 不匹配被拒绝每个 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 jsonpath | DNS hostname(enableDNSHostnames) |
| NODE_RANK | 手动编排 --node_rank=0/1 | JOB_COMPLETION_INDEX + DOMAIN_OFFSET |
| SSH 密钥交换 | 必须手动交换 ed25519 公钥 | 不需要(torchrun 使用 c10d/Gloo) |
| 故障恢复 | 手动重新部署 | Job 自动 restart(backoffLimit) |
| 扩展性 | 每 domain 一个 YAML | 修改 parallelism/completions 和 DOMAIN_OFFSET |
Kubeflow Trainer(v2.2+)的 TrainJob CRD 集成了 Kueue + JobSet,提供更高级的抽象(自动初始化 torchrun、分配 rank、挂载数据卷),适合已部署 Kubeflow 的团队。
以 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
| 参数 | 同域(第 8 章) | 跨域(本章) | 说明 |
|---|---|---|---|
NCCL_MNNVL_ENABLE | 2 | 0 | 跨域必须关闭 |
NCCL_CUMEM_ENABLE | 1 | 0 | cuMem 仅用于 MNNVL |
--expert-model-parallel-size | 8(跨 2 节点) | 4(仅节点内) | EP 限制在域内 |
| DP | 1 | 2 | 自动计算 = world/TP/PP/EP |
| ComputeDomain | 需要 | 仅 domain-0 | 跨域无共享 IMEX |
扩展多 domain 训练只需两个调整:NODE_RANK 连续编排 和 并行参数缩放。
# 确保同一 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) |
|---|---|---|---|
--nnodes | 2 | 36 | 72 |
--tensor-model-parallel-size | 1 | 4 | 4 |
--expert-model-parallel-size | 4 | 16 | 32 |
| DP (自动) | 2 | ≥2 | ≥2 |
| 每 GPU 专家数 | 32 | 8 | 4 |
NCCL_MNNVL_ENABLE | 0 | 0 | 0 |
NCCL_MNNVL_ENABLE=0。这会全局关闭 MNNVL,即使域内 EP communicator 也降级为 RDMA。参见 9.7 节的优化方案和待验证实验。Dense 模型(如 Llama)无 EP 维度,大规模训练的推荐映射:
当前跨域训练必须设置 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.x | MNNVL 探测失败时静默回退到 RDMA | — |
| 2.27.3+ | MNNVL 探测失败时 hard fail(ncclSystemError),不再静默回退。这是之前「必须设为 0」的直接原因 | Release Notes |
| 2.28.3+ | 新增 NCCL_MNNVL_CLIQUE_ID=-2:按机箱序列号(rack serial)自动分 clique | Release 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 P2P | Release 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 模型跨域训练吞吐显著提升。
kubectl apply -f yamls/spare-capacity-priority.yaml # 查看 YAML
kubectl get priorityclass
# gpu-training (1000) gpu-placeholder (-1)
kubectl apply -f yamls/spare-capacity-placeholder.yaml # 查看 YAML
# 验证 Placeholder Pod 已调度到 2 个节点
kubectl get pods -l app=gpu-placeholder -o wide
kubectl apply -f yamls/spare-capacity-training-job.yaml # 查看 YAML
# 验证:训练 Pod 会抢占 Placeholder
kubectl get pods -o wide
# training-preempt-test 应该 Running
# 某个 gpu-placeholder Pod 应该被驱逐
# 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>
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 | 含义 | 场景 |
|---|---|---|
PERFORMANCE | GPU 性能下降 | 无 Xid 错误但训练速度下降 |
UNRECOVERABLE_GPU_ERROR | 不可恢复 GPU 错误 | Xid 错误 |
SILENT_DATA_CORRUPTION | 静默数据损坏 | 训练结果异常 |
CHIP_ERROR | 芯片错误 | 硬件芯片级故障 |
# 查看拓扑结构
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
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"
)
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°C | GPU 过热 |
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。
| 类别 | 测试项 | 实际结果 |
|---|---|---|
| 基础设施 | GPU 检测 (4×GB200/node) | 4 GPU × 4 nodes = 16 total |
| ComputeDomain IMEX 管理 | daemon pods Ready, IMEX channel 可用 | |
| RDMA | ib_write_bw per NIC | ~381 Gbps |
| 4×NIC aggregate | ~1524 Gbps | |
| NCCL | 单节点 all_reduce 4 GPU @8G | 683.75 GB/s busbw |
| 同域 2 节点 MNNVL @8G (ComputeDomain) | 834.95 GB/s busbw | |
| 跨域 2 节点 RDMA @8G | 325.88 GB/s busbw | |
| 混合 4 节点 16GPU @8G (MNNVL=0) | 162.45 GB/s busbw | |
| DeepEP v2 | Intranode BF16 dispatch | 24/24 PASS, 435.97 GB/s NVL |
| Intranode FP8 dispatch | 24/24 PASS, 288.07 GB/s NVL | |
| Intranode Combine | 321.35 GB/s NVL | |
| Low-latency dispatch | 168-188 GB/s, ~20 us | |
| Low-latency combine | 316-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 抢占 Placeholder | Placeholder evicted, Training Pod scheduled |
| 问题 | 说明 |
|---|---|
| 启动盘设备名不固定 | 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 官方自动识别 |
| 项目 | 说明 |
|---|---|
| DRA API 版本 | ResourceClaimTemplate/DeviceClass 使用 resource.k8s.io/v1(GA API,非 v1beta2) |
| DRA 状态 | k8s 1.34 中 DRA 为 GA,默认启用,无需 feature gate |
| kubeadm Scheduler RBAC | kubeadm 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 会失败 |
本地 API Server 需要与 GCP Worker 双向通信(kubectl exec/logs、Webhook 回调、DRA 控制器通信)。需要配置:
192.168.0.0/16)和 Service CIDR(10.96.0.0/12)。通过 Cloud Router 发布路由,或在 VPN 网关上配置静态路由vxlanMTU 字段可调整此值。DRA GPU Driver 控制器(运行在 Worker 节点上)和 Scheduler(运行在 Control Plane 上)之间通过 API Server 通信。在混合云环境需确保:
kubeadm join 的 --discovery-token-ca-cert-hash 已处理此问题kube-scheduler 日志中的 DRA 相关超时错误如果客户的 Control Plane 使用了自定义 Admission Controller 或非标准用户体系(OIDC/LDAP),需确保:
resource.k8s.io/v1 的 ResourceClaim、ResourceClaimTemplate、DeviceClass)gpu-operator namespace)可正常创建 DaemonSet 和 PodGVNIC 管理网络的 MTU 必须设置为 8896(Jumbo Frames)。默认 MTU 1460/1500 会导致 Lustre 吞吐量下降约 10%。创建 VPC 时使用 --mtu=8896。
以下配置对 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-optimizer | ZeRO-1 优化器状态分片,降低显存占用 |
--overlap-grad-reduce | 梯度 all-reduce 与反向传播重叠 |
tests/functional_tests/test_cases/gpt/gpt3_15b_8t_release_gb200/model_config.yamlGCP A4X/GB200 的网络架构与物理服务器不同,使用两类虚拟网卡:
| 类型 | 设备名 | 数量 | 用途 | 冗余机制 |
|---|---|---|---|---|
| GVNIC | eth0, eth1 | 2 | 管理网络(SSH、k8s API、Pod CIDR) | GCP Andromeda SDN 在虚拟化层提供 HA,无需 bond |
| MRDMA | mlx5_0 .. mlx5_3 | 4 | GPU RDMA 计算网络(GPUDirect、NCCL) | SR-IOV VF 由 GCP RDMA 基础设施管理,通过 DRANET DRA 分配,不兼容 bond |
不适用的原因:
ibdev2netdev 输出为 mlx5_0 port 1 ==> rdma0(独立 RDMA 设备),而非 mlx5_bond_X ==> bondYGCP 替代方案:
deviceClassName: rdma-devicesGCP 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 服务。
tlinux-server-4-gb200-v3 已按此标准不再包含 FM。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。
| 维度 | 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) |
tlinux-server-4-gb200-v1。
| 适配项 | 客户标准 | 客户备注 | 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 默认主机名 |
| 适配项 | 客户标准 | 客户备注 | 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 |
| 适配项 | 客户标准 | 客户备注 | 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 注入 |
| 适配项 | 客户标准 | 客户备注 | 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 挂载 |
根据客户要求准备了两个版本的初始化脚本:
| 适配项 | 客户标准 | 客户备注 | 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 |
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 上失败。
DeepEP 需从源码编译(pip 版本无 SM_100 支持)。关键配置:
NCCL_DIR=/usr/local/gib(不是 NCCL_HOME)TORCH_CUDA_ARCH_LIST="10.0"pip install nvidia-nvshmem-cu12==3.4.5(必须使用 3.4.5,3.5.x+ 版本更改了 RC QP array 索引方式,会导致 low-latency 测试 NVSHMEM init 失败)ln -sf /usr/local/gib/lib64/libnccl.so.2 /usr/local/gib/lib64/libnccl.soGIB 的 libibverbs 库 (/usr/local/gib/lib64/) 可能覆盖系统版本。运行 ib_write_bw 前需切换:export LD_LIBRARY_PATH=/usr/lib/aarch64-linux-gnu。
--mock-data(不是 --use-mock-data)--eval-interval 和 --eval-iters 必须显式设置--no-async-tensor-model-parallel-allreduce 已移除--lr-warmup-samples 不能与 iteration-based 训练混用,需使用 --lr-warmup-itersMegatron-LM 使用 Gloo 进行进程通信。如果 Pod hostname 过长,会触发 File name too long 错误。解决方案:在 Pod spec 中设置 hostname 字段为短名称(如 mega-h1)。
Pod 设置自定义 hostname(如 mega-h1)时,NCCL bootstrap 和 Gloo 会调用 gethostbyname() 获取自身 IP。如果该 hostname 没有 DNS 记录,解析失败会导致 静默 hang。
症状:initialized tensor model parallel 后不再有输出,进程占用 100% CPU。
修复方案(任选一):
/etc/hosts 中添加 hostname→IP 映射hostname 字段,继承宿主机 hostnamesubdomain 字段使 k8s DNS 自动注册同时需设置 NCCL_SOCKET_IFNAME=eth0 和 GLOO_SOCKET_IFNAME=eth0。
| 精度 | GB200 官方数据 (TFLOP/s) | GCP A4X 实测 (TFLOP/s) |
|---|---|---|
| FP4 | 6507 | 6845 |
| FP8 | 2805 | 3063 |
| FP16 | 1372 | 1492 |
| BF16 | 1471 | 1592 |
| TF32 | 675 | 733 |
| FP32 | 75 | 75 |
Packet size = 16GB,单位 busbw (GB/s)。
| 配置 | AllReduce | All2All | AllGather | ReduceScatter |
|---|---|---|---|---|
| GB200 × 4 × 18(1 domain, 72 GPU) | 845.01 | 660.61 | 687.94 | 707.22 |
| GB200 × 4 × 36(2 domain, 144 GPU) | 749.56 | 65.47 | 749.56 | 689.05 |
| GB200 × 4 × 72(4 domain, 288 GPU) | 待测 | |||
| 模型 | seq_len | GPU 数 | mbs | gbs | 并行策略 | iteration_time (ms) | tokens/gpu/s | TFLOP/s/gpu | MFU |
|---|---|---|---|---|---|---|---|---|---|
| LLaMA2-7B | 4096 | 4 | 4 | 256 | tp1pp1 | 9406 | 27,870 | 1,127 | 45.08% |
| LLaMA2-7B | 4096 | 8 | 4 | 256 | tp1pp1 | 4881 | 26,854 | 1,086 | 43.44% |
| LLaMA2-13B | 4096 | 4 | 1 | 256 | tp1pp1 | 18978 | 13,813 | 1,065 | 42.60% |
| LLaMA2-13B | 4096 | 8 | 2 | 256 | tp1pp1 | 9614 | 13,633 | 1,065 | 42.60% |
| LLaMA3-70B | 4096 | 64 | 2 | 1024 | tp4pp2 | 28355 | 2,311 | 971 | 38.83% |
文档生成于 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