AI 平台运维技能体系

面向角色：AI 平台运维工程师 / GPU 集群运维 / MLOps 工程师 / LLMOps 基础设施工程师
适用场景：企业内部 AI 平台建设、GPU 集群管理、大模型训练/推理基础设施运维

第一部分：技能体系全景图

图 1：AI 平台运维工程师十大技能体系全景图

1.1. 十大技能域权重分布

技能域	权重	入门要求	精通要求	日常占比
Linux 系统与性能调优	★★★★★	必须	核心	40%
容器与 Kubernetes 编排	★★★★★	必须	核心	35%
GPU 基础设施与算力管理	★★★★★	必须	核心	30%
AI 框架运行环境管理	★★★★☆	必须	重要	25%
MLOps / LLMOps 平台	★★★★☆	必须	重要	25%
分布式存储与高速网络	★★★★☆	了解	重要	20%
监控可观测性与告警	★★★★☆	必须	核心	25%
IaC 与自动化	★★★☆☆	必须	重要	20%
安全与合规	★★★☆☆	了解	一般	10%
成本优化 FinOps	★★★☆☆	了解	重要	15%

第二部分：分阶段学习计划

图 2：AI 平台运维工程师 6 个月学习路线图

总体路线

第一月：基础设施地基（Week 1-4）

目标：建立扎实的 Linux + 网络 + Python 基础，能够独立排查系统级问题

周次	主题	关键技能	实践任务
W1	Linux 核心	进程管理、内存管理、文件系统、systemd	搭建故障排查实验环境
W2	网络基础	TCP/IP、DNS、HTTP/2、TLS、抓包分析	使用 tcpdump/Wireshark 分析 AI 训练流量
W3	Shell + Python	Bash 脚本、Python 运维自动化、Go 入门	编写 GPU 资源监控脚本
W4	Git + CI 基础	Git 工作流、Docker 基础、Jenkins/GitLab CI	搭建个人 CI 流水线

第二月：容器编排与基础监控（Week 5-8）

目标：掌握 Docker/K8s 核心，能够在 K8s 上部署和管理 AI 工作负载

周次	主题	关键技能	实践任务
W5	Docker 深入	多阶段构建、Dockerfile 优化、镜像安全	构建优化的 PyTorch 镜像
W6	K8s 核心	Pod/Deployment/Service/Ingress/ConfigMap	部署 JupyterHub 到 K8s
W7	K8s 调度	Scheduler、亲和性、GPU 调度、ResourceQuota	配置 GPU 工作负载调度策略
W8	监控入门	Prometheus + Grafana + AlertManager	搭建 K8s 集群全栈监控

第三月：GPU 与 AI 框架纵深（Week 9-12）

目标：深入 GPU 硬件和 AI 框架运行环境，能独立运维 GPU 集群

周次	主题	关键技能	实践任务
W9	GPU 硬件	NVIDIA 架构、CUDA 工具链、NVML API	使用 nvidia-smi/dcgmi 深入诊断 GPU
W10	GPU Operator	NVIDIA GPU Operator、MIG 配置、GPU 共享	部署 GPU Operator 并配置 MIG
W11	多卡训练	NCCL、分布式训练拓扑、PyTorch DDP	手配 4 卡分布式训练环境
W12	推理引擎	vLLM、TensorRT-LLM、量化技术	搭建 vLLM 推理服务

第四月：MLOps 平台建设（Week 13-16）

目标：掌握 MLOps/LLMOps 全链路，能搭建企业级 AI 平台

周次	主题	关键技能	实践任务
W13	实验管理	MLflow、W&B、TensorBoard	搭建 MLflow 实验追踪平台
W14	流水线编排	Kubeflow Pipelines、Argo Workflows	构建端到端 ML Pipeline
W15	模型服务	KServe/Triton/BentoML、自动扩缩	部署弹性推理服务
W16	数据与特征	Feast、向量数据库、数据版本管理	搭建特征平台 + Milvus

第五月：存储网络与高级监控（Week 17-20）

目标：掌握 AI 场景专用存储和网络技术，建立高级可观测性

周次	主题	关键技能	实践任务
W17	分布式存储	CephFS/Lustre/ JuiceFS、CSI Driver	部署 JuiceFS 作为 AI 训练存储
W18	高速网络	RDMA/RoCE/InfiniBand、Multus CNI	配置 RDMA 网络用于 NCCL
W19	高级监控	DCGM Exporter、eBPF、分布式追踪	搭建 GPU 全维度监控体系
W20	日志与追踪	Loki/ELK、OpenTelemetry、GPU Trace	实现训练任务全链路追踪

第六月：综合实战与纵深（Week 21-24）

目标：实战企业级 AI 平台运维，建立安全与成本管理体系

周次	主题	关键技能	实践任务
W21	安全合规	RBAC、网络策略、镜像扫描、审计	实施 K8s + AI 平台安全加固
W22	FinOps	GPU 成本分析、Spot 实例、资源优化	搭建 GPU 成本可视化看板
W23	故障演练	混沌工程、GPU 故障注入、灾难恢复	模拟 GPU 节点宕机自愈
W24	综合项目	全栈 AI 平台搭建与运维	从零搭建可运营的 AI 平台

第三部分：推荐学习材料

3.1 核心书籍

领域	书名	作者	推荐理由
Linux	《鸟哥的 Linux 私房菜：基础学习篇》	鸟哥	最经典的 Linux 入门，运维工程师必读
Linux	《Linux 性能优化》	Brendan Gregg	系统性能分析的圣经，必读
K8s	《Kubernetes in Action》	Marko Luksa	K8s 最佳入门书，深入原理
K8s	《Programming Kubernetes》	Michael Hausenblas	K8s 深入扩展开发
GPU	《CUDA C++ Programming Guide》	NVIDIA 官方	CUDA 编程权威参考
GPU	《Professional CUDA C Programming》	John Cheng	CUDA 高级编程
ML	《动手学深度学习》	李沐	最好的深度学习入门，有代码
MLOps	《Designing Machine Learning Systems》	Chip Huyen	MLOps 系统设计经典
网络	《TCP/IP 详解（卷一）》	Stevens	网络协议基石
SRE	《SRE: Google 运维解密》	Google	SRE 方法论与实践

3.2 在线课程

课程	平台	链接/搜索关键词	时长
Linux 性能调优	B 站/YouTube	Brendan Gregg Linux Performance	10h
K8s 从入门到精通	B 站	Kubernetes 入门实战尚硅谷	20h
Certified Kubernetes Administrator	Udemy/Killer.sh	CKA 认证课程 Mumshad	30h
deeplearning.ai GPU 专项	Coursera	NVIDIA DLI	15h
PyTorch 深度学习	B 站	李沐动手学深度学习	40h
MLOps 专项课程	Coursera	MLOps Specialization deeplearning.ai	20h
CUDA 编程入门	NVIDIA DLI	Fundamentals of Accelerated Computing	8h
Terraform 入门到精通	B 站	Terraform 实战	10h

3.3 官方文档必读列表

文档	链接	核心程度
Kubernetes 官方文档	kubernetes.io/docs	★★★★★
NVIDIA GPU Operator 文档	docs.nvidia.com/datacenter/cloud-native/gpu-operator	★★★★★
NVIDIA DCGM 文档	docs.nvidia.com/datacenter/dcgm	★★★★★
NCCL 文档	docs.nvidia.com/deeplearning/nccl	★★★★☆
CUDA Toolkit 文档	docs.nvidia.com/cuda	★★★★☆
vLLM 文档	docs.vllm.ai	★★★★☆
Prometheus 文档	prometheus.io/docs	★★★★☆
Kubeflow 文档	kubeflow.org/docs	★★★★☆
Docker 官方文档	docs.docker.com	★★★☆☆
Helm 文档	helm.sh/docs	★★★☆☆
Terraform 文档	developer.hashicorp.com/terraform	★★★☆☆

3.4 开源项目（动手实践）

项目	GitHub	学习重点	难度
kubespray	kubernetes-sigs/kubespray	手搭 K8s 集群	★★★★
gpu-operator	NVIDIA/gpu-operator	GPU 在 K8s 中的管理	★★★
kubeflow	kubeflow/kubeflow	MLOps 平台搭建	★★★★
mlflow	mlflow/mlflow	实验追踪与模型管理	★★
ray	ray-project/ray	分布式计算框架	★★★
vllm	vllm-project/vllm	大模型推理引擎	★★★
kube-prometheus	prometheus-operator/kube-prometheus	K8s 监控体系	★★★
volcano	volcano-sh/volcano	批量调度器（AI 场景）	★★★
juicefs	juicedata/juicefs	分布式文件系统	★★★
loki	grafana/loki	日志聚合系统	★★

第四部分：详细学习文档

模块一：Linux 系统与性能调优

1.1 进程与线程管理

核心概念

AI 训练任务通常是多进程（PyTorch DDP）或多线程（DataLoader）的，理解进程/线程模型是排查问题的起点。

Linux 进程模型：
┌──────────────────────────────────────────┐
│  进程 (Process)                           │
│  ├── PID / PPID                          │
│  ├── 虚拟地址空间                          │
│  ├── 文件描述符表                          │
│  └── 线程组                               │
│      ├── 线程 1 (LWP)                     │
│      │   ├── CPU 亲和性 (affinity)         │
│      │   ├── 调度策略 (SCHED_OTHER/FIFO)   │
│      │   └── 栈空间                       │
│      └── 线程 2-N                         │
└──────────────────────────────────────────┘

关键命令速查

# === 进程管理 ===
ps auxf                          # 树形显示进程关系
ps -eo pid,ppid,cmd,%mem,%cpu    # 自定义列
top -H -p <PID>                  # 查看某进程的所有线程
pstree -p <PID>                  # 进程树

# === CPU 信息 ===
lscpu                            # CPU 架构信息（核心数、NUMA 节点、缓存）
cat /proc/cpuinfo                # 详细 CPU 信息
lstopo                           # 硬件拓扑图（需安装 hwloc）
numactl --hardware               # NUMA 节点拓扑

# === 内存信息 ===
free -h                          # 内存使用概览
cat /proc/meminfo                # 详细内存信息
smem -t -k                       # PSS/USS/RSS 分析（含共享内存）
vmstat 1                         # 实时虚拟内存统计

# === 文件系统 ===
df -h                            # 磁盘使用
iostat -x 1                      # IO 性能（await, util, r/s, w/s）
lsblk                            # 块设备信息
fdisk -l                         # 磁盘分区

# === 系统调用追踪（AI 排障利器）===
strace -f -p <PID> -e trace=network  # 追踪网络系统调用
strace -f -p <PID> -c             # 统计各系统调用耗时
perf top -p <PID>                 # CPU 性能热点分析

实战：GPU 训练进程卡死排查

# 1. 确认进程状态
ps aux | grep python | grep train
# State: D (不可中断睡眠) → 可能是 IO 瓶颈
# State: R (运行中) → 可能是死循环
# State: S (可中断睡眠) → 可能在等待 GPU 同步

# 2. 查看线程堆栈
cat /proc/<PID>/stack             # 内核态调用栈
gdb -p <PID> -batch -ex "thread apply all bt"  # 用户态调用栈

# 3. 查看打开的文件
lsof -p <PID>                     # 文件句柄、网络连接
ls -la /proc/<PID>/fd/            # 文件描述符

# 4. 查看资源限制
cat /proc/<PID>/limits            # 检查是否达到了 nofile/memlock 限制

1.2 内存管理深度解析

虚拟内存与物理内存

AI 训练中最常见的内存问题：OOM、内存泄漏、大页配置不当。

# 查看进程内存分布
cat /proc/<PID>/smaps | grep -E "^(Rss|Pss|Shared|Swap|Size)" 

# Rss  (Resident Set Size):    实际物理内存
# Pss  (Proportional Set Size): 按比例分摊共享内存
# Swap:                         被交换到磁盘的内存

HugePages（大页内存）配置

AI 训练（尤其是 DeepSpeed ZeRO-3、vLLM KV Cache）大量使用大页内存以减少 TLB miss。

# 查看大页配置
cat /proc/meminfo | grep -i huge
# HugePages_Total:    1024     # 已预留的大页数量
# HugePages_Free:      512     # 空闲大页
# Hugepagesize:       2048 kB  # 每个大页 2MB

# 配置 2MB 大页（运行时）
echo 1024 > /proc/sys/vm/nr_hugepages

# 永久配置（修改内核启动参数）
# /etc/default/grub 添加：
# GRUB_CMDLINE_LINUX="... hugepagesz=2M hugepages=1024 default_hugepagesz=2M"

# 在 K8s Pod 中使用大页
# resources:
#   limits:
#     hugepages-2Mi: 2Gi
#     memory: 64Gi

NUMA 优化（AI 训练性能关键）

# 查看 NUMA 拓扑
numactl --hardware
# node 0 cpus: 0-31     # 前 32 核属于 NUMA node 0
# node 1 cpus: 32-63    # 后 32 核属于 NUMA node 1

# GPU 与 CPU/内存的 NUMA 亲和性
nvidia-smi topo -m       # 查看 GPU 拓扑（PXB/NODE/SYS 连接类型）

# 绑定进程到特定 NUMA 节点
numactl --cpunodebind=0 --membind=0 python train.py

# 在 K8s 中配置 NUMA 亲和性
# 使用 Topology Manager + CPU Manager
# kubelet 配置：
# topologyManagerPolicy: single-numa-node
# cpuManagerPolicy: static

1.3 性能分析工具链

性能观测层次（Brendan Gregg 方法论）：

应用层     ← PyTorch Profiler / TensorBoard
系统调用层  ← strace / perf
内核层     ← ftrace / eBPF
硬件层     ← nvidia-smi / DCGM / perf stat

常用组合：
  CPU 热点    → perf record + FlameGraph
  内存泄漏    → valgrind / heaptrack / eBPF memleak
  IO 瓶颈     → iostat / biolatency (bcc)
  网络延迟    → tcpdump / ss / bcc-tcplife
  GPU 利用率  → nvidia-smi dmon / DCGM

模块二：容器与 Kubernetes 编排

2.1 Docker 镜像优化（AI 场景）

AI 镜像体积通常很大（10-30GB），优化至关重要。

# ❌ 不推荐的写法
FROM nvidia/cuda:12.1.0-runtime-ubuntu22.04
RUN pip install torch torchvision  # 这一步可能产生大量中间文件
COPY . /app
CMD ["python", "train.py"]

# ✅ AI 镜像最佳实践
FROM nvidia/cuda:12.1.0-devel-ubuntu22.04 AS builder
# 构建阶段：仅保留必要的构建产物
RUN --mount=type=cache,target=/root/.cache/pip \
    pip install --no-cache-dir torch==2.1.0 torchvision==0.16.0

FROM nvidia/cuda:12.1.0-runtime-ubuntu22.04 AS runtime
# 运行时阶段：最小化体积
RUN apt-get update && apt-get install -y --no-install-recommends \
    python3.10 python3-pip libgomp1 \
    && rm -rf /var/lib/apt/lists/*

# 从 builder 阶段复制
COPY --from=builder /usr/local/lib/python3.10/dist-packages /usr/local/lib/python3.10/dist-packages
COPY . /app
WORKDIR /app

# 非 root 运行
RUN useradd -m -u 1000 ai
USER ai
CMD ["python3", "train.py"]

镜像分层策略（减少拉取时间）

Layer 5: 业务代码      (经常变更, ~100MB)
Layer 4: 模型权重      (偶尔变更, ~5GB)
Layer 3: Python 依赖   (偶尔变更, ~3GB)
Layer 2: CUDA/cuDNN   (极少变更, ~3GB)
Layer 1: Ubuntu Base  (几乎不变, ~80MB)

2.2 Kubernetes GPU 调度

核心资源对象

apiVersion: v1
kind: Pod
metadata:
  name: gpu-training-pod
spec:
  # GPU 节点亲和性
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: nvidia.com/gpu.product
                operator: In
                values: ["NVIDIA-A100-SXM4-80GB"]
  
  # GPU 资源请求
  containers:
    - name: trainer
      image: pytorch:2.1.0-cuda12.1
      resources:
        limits:
          nvidia.com/gpu: 4          # 请求 4 块 GPU
          nvidia.com/mig-1g.10gb: 2  # 或请求 MIG 实例
        requests:
          nvidia.com/gpu: 4
      
      # 环境变量（NCCL 相关）
      env:
        - name: NCCL_DEBUG
          value: "INFO"
        - name: NCCL_SOCKET_IFNAME
          value: "eth0"
        - name: NCCL_IB_DISABLE
          value: "0"                 # 启用 InfiniBand
        - name: CUDA_VISIBLE_DEVICES
          value: "0,1,2,3"
      
      volumeMounts:
        - name: shm
          mountPath: /dev/shm        # PyTorch DataLoader 需要大共享内存
        - name: training-data
          mountPath: /data
  
  volumes:
    - name: shm
      emptyDir:
        medium: Memory
        sizeLimit: 64Gi              # DatLoader workers * batch 内存
    - name: training-data
      persistentVolumeClaim:
        claimName: training-data-pvc

K8s GPU 调度器对比

调度器	特点	适用场景
默认 Scheduler + Device Plugin	基础 GPU 调度	简单场景
NVIDIA GPU Operator	MIG、Time-Slicing	企业级 GPU 管理
Volcano	批调度、Gang Scheduling	分布式训练
Yunikorn	公平调度、层级队列	多租户 GPU 平台
Run:ai	动态 GPU 分片	GPU 虚拟化

分布式训练 Gang Scheduling

# Volcano Job 示例：PyTorch 分布式训练
apiVersion: batch.volcano.sh/v1alpha1
kind: Job
metadata:
  name: pytorch-distributed-training
spec:
  minAvailable: 4               # Gang Scheduling：4 个 Worker 全部就绪才启动
  schedulerName: volcano
  plugins:
    svc: []                     # 自动创建 headless service
  tasks:
    - replicas: 1
      name: master
      template:
        spec:
          containers:
            - name: master
              image: pytorch:2.1.0
              command:
                - torchrun
                - --nnodes=1
                - --nproc_per_node=4
                - train.py
              resources:
                limits:
                  nvidia.com/gpu: 4
    - replicas: 3
      name: worker
      template:
        spec:
          containers:
            - name: worker
              image: pytorch:2.1.0
              command:
                - torchrun
                - --nnodes=3
                - --nproc_per_node=4
                - --master_addr=$(MASTER_SVC_HOST)
                - train.py
              resources:
                limits:
                  nvidia.com/gpu: 4

2.3 GPU Operator 部署详解

# 1. 添加 Helm 仓库
helm repo add nvidia https://helm.ngc.nvidia.com/nvidia
helm repo update

# 2. 安装 GPU Operator（完整功能）
helm install gpu-operator nvidia/gpu-operator \
  --namespace gpu-operator \
  --create-namespace \
  --set driver.enabled=true \
  --set migManager.enabled=true \
  --set mig.strategy=mixed \
  --set toolkit.enabled=true \
  --set dcgmExporter.enabled=true \
  --set devicePlugin.enabled=true \
  --set gfd.enabled=true

# 3. 验证安装
kubectl get pods -n gpu-operator
kubectl describe node <gpu-node> | grep nvidia.com/gpu

MIG（Multi-Instance GPU）配置实战

# MIG 配置策略 ConfigMap
apiVersion: v1
kind: ConfigMap
metadata:
  name: mig-config
  namespace: gpu-operator
data:
  # A100-80GB 切成 7 个 MIG 实例（1g.10gb × 7）
  config.yaml: |
    version: v1
    mig-configs:
      all-1g.10gb:
        - devices: all
          mig-enabled: true
          mig-devices:
            "1g.10gb": 7
      all-2g.20gb:
        - devices: all
          mig-enabled: true
          mig-devices:
            "2g.20gb": 3
      all-3g.40gb:
        - devices: all
          mig-enabled: true
          mig-devices:
            "3g.40gb": 2

模块三：GPU 基础设施与算力管理

3.1 NVIDIA GPU 架构与 CUDA 工具链

GPU 架构演进

架构	代表 GPU	核心特性	适用场景
Volta	V100	第一代 Tensor Core, NVLink 2.0	遗留训练
Turing	T4	INT8/INT4 推理加速	推理服务
Ampere	A100/A30	MIG, TF32, NVLink 3.0	训练+推理
Hopper	H100/H800	FP8, Transformer Engine	大模型训练
Blackwell	B200	FP4, NVLink 5.0	下一代

CUDA 工具链

# === nvidia-smi 高级用法 ===
# 实时监控（每秒刷新）
nvidia-smi dmon -s pucvmet -d 1

# 查看 GPU 拓扑
nvidia-smi topo -m

# 查看 GPU 进程详情
nvidia-smi pmon -c 1 -s um

# 查看 GPU 计算能力
nvidia-smi --query-gpu=compute_cap --format=csv

# === NVML (NVIDIA Management Library) ===
# Python 示例：监控 GPU
python3 -c "
import pynvml
pynvml.nvmlInit()
device_count = pynvml.nvmlDeviceGetCount()
for i in range(device_count):
    handle = pynvml.nvmlDeviceGetHandleByIndex(i)
    name = pynvml.nvmlDeviceGetName(handle)
    temp = pynvml.nvmlDeviceGetTemperature(handle, pynvml.NVML_TEMPERATURE_GPU)
    power = pynvml.nvmlDeviceGetPowerUsage(handle) / 1000
    util = pynvml.nvmlDeviceGetUtilizationRates(handle)
    mem = pynvml.nvmlDeviceGetMemoryInfo(handle)
    print(f'GPU {i} ({name}): {util.gpu}% util, {temp}°C, {power:.1f}W, {mem.used/1024**3:.1f}/{mem.total/1024**3:.1f} GB')
"

# === 查看 CUDA 环境 ===
cat /usr/local/cuda/version.json    # CUDA 版本
nvcc --version                      # CUDA 编译器版本
cat /proc/driver/nvidia/version     # 驱动版本

3.2 GPU 常见故障诊断

# === Xid 错误排查 ===
# Xid 是 NVIDIA GPU 的错误代码，记录在内核日志中
dmesg | grep -i "NVRM.*Xid"
# 常见 Xid 错误：
# Xid 31: GPU 内存页面故障（Page Fault），可能是显存硬件问题
# Xid 48: 双位 ECC 错误（Double Bit ECC），显存硬件故障
# Xid 79: GPU 已从总线断开（GPU has fallen off the bus），PCIe 连接问题

# Xid 错误决策树：
# ECC 错误 → 检查 dmesg + nvidia-smi -q → 隔离 GPU → 联系 NVIDIA 支持
# 超时错误 → 检查系统日志 /var/log/messages → 降低 GPU 频率 → 检查散热

# === GPU 内存问题排查 ===
# 查看 ECC 错误
nvidia-smi -q -d ECC
# 查看显存温度
nvidia-smi -q -d TEMPERATURE
# 查看功耗限制是否触发
nvidia-smi -q -d POWER

# === GPU 性能退化诊断 ===
# 1. 运行 GPU Burn 压力测试
docker run --gpus all --rm nvidia/cuda:12.1.0-devel-ubuntu22.04 \
  bash -c "git clone https://github.com/wilicc/gpu-burn && cd gpu-burn && make && ./gpu_burn 120"

# 2. 运行 DCGM 诊断（需要 dcgmi）
dcgmi diag -r 3   # Level 3 诊断（含内存带宽测试）

# 3. 运行 NCCL 带宽测试
# 编译 nccl-tests
git clone https://github.com/NVIDIA/nccl-tests
cd nccl-tests && make CUDA_HOME=/usr/local/cuda
./build/all_reduce_perf -b 8 -e 2G -f 2 -g 4   # 4卡带宽测试

3.3 GPU 资源分配策略

# K8s GPU 共享方案对比

# 方案 1: Time-Slicing（时间分片）
# GPU Operator 配置
apiVersion: v1
kind: ConfigMap
metadata:
  name: time-slicing-config
data:
  any: |-
    version: v1
    flags:
      migStrategy: none
    sharing:
      timeSlicing:
        resources:
          - name: nvidia.com/gpu
            replicas: 4    # 每个物理 GPU 切分为 4 份
# Pod 使用：
#   resources:
#     limits:
#       nvidia.com/gpu: 1  # 获取 1/4 GPU

# 方案 2: MIG（物理分片，仅 A100/A30/H100）
# GPU Operator 配置
mig:
  strategy: mixed  # single | mixed
# Pod 使用：
#   resources:
#     limits:
#       nvidia.com/mig-1g.10gb: 1

# 方案 3: vGPU（虚拟 GPU，需 NVIDIA vGPU 许可）
# 适用于虚拟化场景（VMware/KVM）

模块四：AI 框架运行环境管理

4.1 CUDA 版本兼容性矩阵

最常遇到的坑：CUDA 版本不匹配导致的 "CUDA error: no kernel image available"

兼容性规则：
  驱动版本 ≥ CUDA Toolkit 所需的最低驱动版本
  CUDA Toolkit ≤ 驱动版本支持的最高 CUDA

PyTorch 版本 → CUDA 版本 对应关系：
  PyTorch 2.1.x → CUDA 11.8 / 12.1
  PyTorch 2.2.x → CUDA 11.8 / 12.1
  PyTorch 2.3.x → CUDA 12.1
  PyTorch 2.4.x → CUDA 12.4

cuDNN 版本：
  CUDA 12.1 → cuDNN 8.9.x
  CUDA 12.4 → cuDNN 9.x

PyTorch 多版本环境管理

# 使用 venv + pip（最简单）
python3 -m venv /opt/pytorch-2.1-cu121
source /opt/pytorch-2.1-cu121/bin/activate
pip install torch==2.1.0 torchvision==0.16.0 --index-url https://download.pytorch.org/whl/cu121

# 使用 conda（推荐用于多 CUDA 环境共存）
conda create -n pytorch-2.3-cu121 python=3.10
conda activate pytorch-2.3-cu121
conda install pytorch==2.3.0 torchvision pytorch-cuda=12.1 -c pytorch -c nvidia

# 在 Docker 中固化环境（最佳实践: 生产环境）
FROM nvidia/cuda:12.1.0-cudnn8-devel-ubuntu22.04
RUN pip install torch==2.1.0 torchvision==0.16.0 --index-url https://download.pytorch.org/whl/cu121

4.2 vLLM 推理引擎部署

# vLLM 生产部署最佳实践

# 1. 安装
pip install vllm

# 2. 启动 API 服务
python -m vllm.entrypoints.openai.api_server \
  --model /data/models/Qwen2-72B-Instruct \
  --tensor-parallel-size 4 \
  --gpu-memory-utilization 0.90 \
  --max-model-len 8192 \
  --enable-prefix-caching \
  --host 0.0.0.0 \
  --port 8000

# 参数说明：
# --tensor-parallel-size: 张量并行度（= GPU 数量）
# --gpu-memory-utilization: 显存使用率上限（防止 OOM）
# --max-model-len: 最大上下文长度（影响 KV Cache 显存占用）
# --enable-prefix-caching: 启用 prefix 缓存（大幅降低首个 token 延迟）

# 3. 测试
curl http://localhost:8000/v1/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "/data/models/Qwen2-72B-Instruct", "prompt": "你好", "max_tokens": 100}'

vLLM 显存估算公式

KV Cache 显存 = 2 × num_layers × num_kv_heads × head_dim × max_model_len × bytes_per_element

示例：Qwen2-72B (num_layers=80, num_kv_heads=8, head_dim=128, max_len=8192, FP16)
KV Cache = 2 × 80 × 8 × 128 × 8192 × 2 = 2.68 GB（单卡）
模型权重 = 72B × 2 bytes = 144 GB（FP16，需 TP=4，每卡 36GB）

总计单卡显存 = 36GB (权重) + 2.68GB (KV Cache) + 约 5GB (框架开销) ≈ 44GB
→ 至少需要 A100-80GB × 4 卡

4.3 分布式训练环境配置

# NCCL 环境变量最佳配置

# === 基础配置 ===
export NCCL_DEBUG=INFO            # 调试日志
export NCCL_IB_DISABLE=0         # 启用 InfiniBand（有 IB 网卡时）
export NCCL_SOCKET_IFNAME=eth0   # 指定通信网卡（避免走管理网络）
export NCCL_IB_GID_INDEX=3       # RoCE v2 模式
export NCCL_IB_HCA=mlx5_0,mlx5_1 # 指定 RDMA 网卡

# === 性能优化 ===
export NCCL_NET_GDR_LEVEL=5      # GPU Direct RDMA（最高等级）
export NCCL_IB_QPS_PER_CONNECTION=4  # 增加 Queue Pairs 提升带宽
export NCCL_IB_TIMEOUT=23        # IB 超时时间
export NCCL_NSOCKS_PERTHREAD=4   # 每线程 Socket 数
export NCCL_SOCKET_NTHREADS=4    # Socket 线程数

# === PyTorch DDP 启动命令 ===
torchrun \
  --nnodes=4 \
  --nproc_per_node=8 \
  --master_addr=${MASTER_ADDR} \
  --master_port=29500 \
  --node_rank=${RANK} \
  train.py \
  --batch-size 128 \
  --gradient-accumulation-steps 4 \
  --fp16

模块五：MLOps 与 LLMOps 平台

5.1 MLflow 实验管理平台搭建

# 生产级 MLflow 部署
# 架构：MLflow Tracking Server + PostgreSQL + S3/MinIO

# 1. 创建 PostgreSQL 数据库
kubectl create ns mlflow
kubectl apply -f - <<EOF
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: postgres
  namespace: mlflow
spec:
  serviceName: postgres
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
        - name: postgres
          image: postgres:15
          env:
            - name: POSTGRES_DB
              value: mlflow
            - name: POSTGRES_USER
              value: mlflow
            - name: POSTGRES_PASSWORD
              value: mlflow123
          volumeMounts:
            - name: data
              mountPath: /var/lib/postgresql/data
  volumeClaimTemplates:
    - metadata:
        name: data
      spec:
        accessModes: ["ReadWriteOnce"]
        resources:
          requests:
            storage: 50Gi
EOF

# 2. 部署 MLflow Server
kubectl apply -f - <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mlflow-server
  namespace: mlflow
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mlflow
  template:
    metadata:
      labels:
        app: mlflow
    spec:
      containers:
        - name: mlflow
          image: ghcr.io/mlflow/mlflow:v2.10.0
          ports:
            - containerPort: 5000
          command:
            - mlflow
            - server
            - --backend-store-uri
            - postgresql://mlflow:mlflow123@postgres.mlflow.svc:5432/mlflow
            - --default-artifact-root
            - s3://mlflow-artifacts
            - --host
            - 0.0.0.0
          env:
            - name: AWS_ACCESS_KEY_ID
              value: minioadmin
            - name: AWS_SECRET_ACCESS_KEY
              value: minioadmin
            - name: MLFLOW_S3_ENDPOINT_URL
              value: http://minio.default.svc:9000
EOF

5.2 Kubeflow Pipelines 核心流程

Kubeflow Pipeline 组件架构：

┌──────────────────────────────────────────────────────┐
│                   Kubeflow Pipeline                  │
├──────────────────────────────────────────────────────┤
│                                                      │
│  ┌─────────┐   ┌─────────┐   ┌─────────┐   ┌──────┐  │
│  │数据预处理│──▶│模型训练  │──▶│模型评估  │──▶│注册│  │
│  │ (CPU)   │   │ (GPU)   │   │ (CPU)   │   │      │  │
│  └─────────┘   └─────────┘   └─────────┘   └──────┘  │
│       │            │             │                   │
│  ┌────┴─────┐ ┌────┴─────┐ ┌─────┴─────┐             │
│  │ S3/MinIO │ │ PVC (SSD)│ │ MLflow    │             │
│  │ 原始数据  │ │ 训练日志  │ │ 指标对比   │            │
│  └──────────┘ └──────────┘ └───────────┘             │
│                                                      │
└──────────────────────────────────────────────────────┘

# Kubeflow Pipeline Python SDK 示例
import kfp
from kfp import dsl

@dsl.component(
    base_image="python:3.10",
    packages_to_install=["pandas", "pyarrow"]
)
def preprocess(data_path: str, output_path: str):
    import pandas as pd
    df = pd.read_parquet(data_path)
    # 清洗、采样处理
    df.sample(frac=0.1).to_parquet(output_path)

@dsl.component(
    base_image="nvidia/cuda:12.1.0-runtime-ubuntu22.04",
    packages_to_install=["torch==2.1.0", "transformers"]
)
def train(input_path: str, model_output: str):
    import torch
    from transformers import AutoModelForCausalLM
    model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-7B")
    # 训练逻辑...
    model.save_pretrained(model_output)

@dsl.pipeline(
    name="LLM Fine-tuning Pipeline",
    description="大模型微调流水线"
)
def llm_finetune_pipeline(data_path: str = "s3://data/raw"):
    preprocess_task = preprocess(data_path=data_path, output_path="s3://data/processed")
    
    train_task = train(input_path=preprocess_task.outputs["output_path"], model_output="s3://models/finetuned")
    train_task.set_gpu_limit(8)
    train_task.set_memory_limit("256Gi")
    
    # 条件执行：如果评估指标达标，注册模型
    with dsl.Condition(train_task.outputs["accuracy"] > 0.85):
        register_model(model_path=train_task.outputs["model_output"])

if __name__ == "__main__":
    kfp.compiler.Compiler().compile(llm_finetune_pipeline, "llm_finetune_pipeline.yaml")

5.3 KServe 模型服务

# KServe InferenceService：生产级模型服务
apiVersion: serving.kserve.io/v1beta1
kind: InferenceService
metadata:
  name: qwen2-7b-instruct
spec:
  predictor:
    # 自动扩缩容配置
    minReplicas: 1
    maxReplicas: 10
    scaleTarget: 5              # 目标并发数
    
    pytorch:
      storageUri: s3://models/qwen2-7b-instruct
      resources:
        limits:
          nvidia.com/gpu: 1
          memory: 32Gi
        requests:
          nvidia.com/gpu: 1
          memory: 16Gi
      env:
        - name: MAX_BATCH_SIZE
          value: "32"
        - name: MAX_SEQUENCE_LENGTH
          value: "4096"

  # 金丝雀部署（零停机更新）
  canaryTrafficPercent: 10      # 10% 流量到新版本

模块六：分布式存储与高速网络

6.1 AI 训练存储选型

存储方案	带宽	IOPS	适用场景	部署复杂度
本地 NVMe SSD	7 GB/s	1M+	小规模训练(1-4卡)	低
JuiceFS + S3	10+ GB/s	取决于缓存	云上训练、弹性训练	中
CephFS	5+ GB/s	100K+	私有化部署	高
Lustre/GPFS	100+ GB/s	1M+	大规模训练(100+卡)	极高
WekaFS	100+ GB/s	1M+	企业级 AI 存储	中（商业）

JuiceFS 部署（推荐中小企业方案）

# JuiceFS: 开源分布式文件系统，元数据引擎 + S3 对象存储

# 1. 安装
curl -sSL https://d.juicefs.com/install | sh -

# 2. 创建文件系统（元数据: Redis, 数据: MinIO/S3）
juicefs format \
  --storage minio \
  --bucket http://minio:9000/training-data \
  --access-key minioadmin \
  --secret-key minioadmin \
  redis://redis:6379/1 \
  training-fs

# 3. 挂载（含本地 SSD 缓存）
juicefs mount -d \
  --cache-dir /nvme0/juicefs-cache \
  --cache-size 500000 \      # 500GB 本地缓存
  --writeback \              # 回写缓存加速
  redis://redis:6379/1 \
  /mnt/training-data

# 4. K8s CSI Driver 部署
kubectl apply -f https://raw.githubusercontent.com/juicedata/juicefs-csi-driver/master/deploy/k8s.yaml

6.2 RDMA/RoCE 网络配置

RDMA 原理：
  ┌─────────┐                              ┌─────────┐
  │  GPU 0  │                              │  GPU 1  │
  │  显存    │                              │  显存    │
  └────┬────┘                              └────┬────┘
       │ GPU Direct RDMA                       │
       │ (绕过 CPU，直接显存到网卡)              │
  ┌────┴────┐                              ┌────┴────┐
  │ ConnectX│ ←──────── RDMA ────────────→ │ ConnectX│
  │ 网卡     │    RoCE v2 / InfiniBand     │ 网卡     │
  └─────────┘                              └─────────┘
       总带宽：400 Gbps (H100 + CX-7)
       延迟：~1-2 μs（vs TCP 50-100 μs）

# RoCE 网络配置检查清单

# 1. 检查 RDMA 设备
ibstat                              # InfiniBand 状态
ibv_devinfo                         # 详细设备信息

# 2. 检查 RDMA 连通性
# ib_write_bw 带宽测试
ib_write_bw -d mlx5_0 -F --report_gbits

# 3. NCCL 启用 RDMA
export NCCL_IB_DISABLE=0
export NCCL_IB_GID_INDEX=3          # RoCE v2 下通常是 3
export NCCL_NET_GDR_LEVEL=5         # GPU Direct RDMA

# 4. Docker 中使用 RDMA
docker run --gpus all \
  --device=/dev/infiniband/ \
  --ulimit memlock=-1 \
  pytorch:latest

# 5. K8s 中使用 RDMA
# 使用 Multus CNI + SR-IOV / Macvlan
# 或使用 NVIDIA Network Operator

模块七：监控可观测性与告警

图 3：AI 平台运维监控金字塔 — 六层全维度可观测体系

7.1 GPU 全维度监控体系

GPU 监控金字塔：

    ┌─────────────────────────────┐
    │    业务层 (SLA, 训练吞吐)     │ ← 自研/MLflow
    ├─────────────────────────────┤
    │    应用层 (Python 指标)       │ ← PyTorch Profiler
    ├─────────────────────────────┤
    │    容器层 (资源使用)          │ ← cAdvisor + KSM
    ├─────────────────────────────┤
    │    GPU 层 (SM/显存/温度/功耗)  │ ← DCGM Exporter
    ├─────────────────────────────┤
    │    节点层 (CPU/内存/IO/网络)   │ ← Node Exporter
    └─────────────────────────────┘

DCGM Exporter 核心指标

# Prometheus 关键 GPU 指标
- DCGM_FI_DEV_GPU_UTIL              # GPU 利用率 (%)
- DCGM_FI_DEV_MEM_COPY_UTIL         # 显存带宽利用率 (%)
- DCGM_FI_DEV_FB_USED               # 显存已用 (MB)
- DCGM_FI_DEV_FB_FREE               # 显存空闲 (MB)
- DCGM_FI_DEV_GPU_TEMP              # GPU 温度 (°C)
- DCGM_FI_DEV_POWER_USAGE           # 功耗 (W)
- DCGM_FI_DEV_SM_CLOCK              # SM 时钟频率 (MHz)
- DCGM_FI_DEV_PCIE_TX_THROUGHPUT    # PCIe 发送带宽
- DCGM_FI_DEV_PCIE_RX_THROUGHPUT    # PCIe 接收带宽
- DCGM_FI_DEV_NVLINK_BANDWIDTH_TOTAL # NVLink 带宽
- DCGM_FI_DEV_XID_ERRORS            # Xid 错误数
- DCGM_FI_DEV_ECC_SBE_VOL_TOTAL     # ECC 单比特错误
- DCGM_FI_DEV_ECC_DBE_VOL_TOTAL     # ECC 双比特错误（严重）

核心告警规则

# PrometheusRule: GPU 告警规则
groups:
  - name: gpu-alerts
    rules:
      # GPU 掉卡（最高优先级）
      - alert: GPUDeviceLost
        expr: DCGM_FI_DEV_XID_ERRORS > 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "GPU {{ $labels.gpu }} Xid 错误"
          description: "Xid 错误数: {{ $value }}"
      
      # GPU 温度过高
      - alert: GPUHighTemperature
        expr: DCGM_FI_DEV_GPU_TEMP > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "GPU {{ $labels.gpu }} 温度 {{ $value }}°C > 85°C"
      
      # 显存使用过高（训练 OOM 风险）
      - alert: GPUMemoryHigh
        expr: DCGM_FI_DEV_FB_USED / DCGM_FI_DEV_FB_TOTAL > 0.95
        for: 5m
        labels:
          severity: warning
      
      # 训练卡 GPU 低利用率（资源浪费）
      - alert: GPULowUtilization
        expr: DCGM_FI_DEV_GPU_UTIL < 60
        for: 30m
        labels:
          severity: info
        annotations:
          summary: "GPU {{ $labels.gpu }} 利用率持续低于 60%"

7.2 PyTorch Profiler 集成

# 训练性能分析
from torch.profiler import profile, schedule, ProfilerActivity, tensorboard_trace_handler

with profile(
    activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
    schedule=schedule(wait=2, warmup=2, active=6, repeat=1),
    on_trace_ready=tensorboard_trace_handler('./logs/profile'),
    record_shapes=True,
    profile_memory=True,
    with_stack=True
) as prof:
    for step, batch in enumerate(dataloader):
        loss = model(batch).loss
        loss.backward()
        optimizer.step()
        prof.step()
        if step >= 12:
            break

# 在 TensorBoard 中查看：
# tensorboard --logdir=./logs/profile
# 重点关注：GPU 空闲时间、CPU/GPU 数据传输时间、Kernel 启动开销

7.3 eBPF 深度可观测性

# 使用 bcc-tools 监控 GPU 工作负载
# 示例：追踪 CUDA Kernel 启动延迟
bpftrace -e '
tracepoint:nvidia:nvidia_gpu_kernel_launch {
    @start[tid] = nsecs;
}
tracepoint:nvidia:nvidia_gpu_kernel_complete /@start[tid]/ {
    @latency_us = hist((nsecs - @start[tid]) / 1000);
    delete(@start[tid]);
}'

# 追踪显存分配
bpftrace -e '
uprobe:/usr/lib/x86_64-linux-gnu/libcuda.so:cudaMalloc {
    printf("cudaMalloc size=%d\n", arg1);
}'

模块八：基础设施即代码与自动化

8.1 Terraform 管理 GPU 集群

# Terraform: 混合云 GPU 资源管理

# 阿里云 GPU ECS
resource "alicloud_instance" "gpu_node" {
  count = var.gpu_node_count
  
  instance_name = "gpu-worker-${count.index}"
  instance_type = "ecs.gn7i-c32g1.8xlarge"  # A10 GPU × 1
  image_id      = "ubuntu_22_04_x64_20G_alibase_20231221.vhd"
  
  system_disk {
    category = "cloud_essd"
    size     = 100
  }
  
  data_disks {
    category = "cloud_essd"
    size     = 2000  # 2TB 训练数据盘
  }
  
  vswitch_id = alicloud_vswitch.gpu_vswitch.id
  security_groups = [alicloud_security_group.gpu_sg.id]
  
  user_data = templatefile("${path.module}/gpu_init.sh", {
    k8s_join_command = module.eks.join_command
  })
  
  tags = {
    Environment = var.environment
    NodeGroup   = "gpu-training"
    GPUModel    = "A10"
  }
}

# Spot 实例管理（节约成本）
resource "alicloud_instance" "gpu_spot_node" {
  count                = var.gpu_spot_count
  instance_type        = "ecs.gn7i-c16g1.4xlarge"
  spot_strategy        = "SpotWithPriceLimit"
  spot_price_limit     = 5.0   # 最高出价 ¥5/小时
}

8.2 Ansible GPU 节点初始化

# Ansible Playbook: GPU 节点初始化
- name: GPU Node Bootstrap
  hosts: gpu_nodes
  become: yes
  tasks:
    - name: Install NVIDIA Driver
      shell: |
        wget -q https://cn.download.nvidia.com/tesla/535.129.03/NVIDIA-Linux-x86_64-535.129.03.run
        chmod +x NVIDIA-Linux-x86_64-535.129.03.run
        ./NVIDIA-Linux-x86_64-535.129.03.run --silent --no-questions
      args:
        creates: /usr/bin/nvidia-smi

    - name: Install CUDA Toolkit
      apt:
        deb: https://developer.download.nvidia.com/compute/cuda/12.1.1/local_installers/cuda-repo-ubuntu2204-12-1-local_12.1.1-530.30.02-1_amd64.deb

    - name: Install NVIDIA Container Toolkit
      shell: |
        distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
        curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
        curl -s -L https://nvidia.github.io/libnvidia-container/$distribution/libnvidia-container.list | \
          sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
          tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
        apt-get update && apt-get install -y nvidia-container-toolkit
        nvidia-ctk runtime configure --runtime=docker
        systemctl restart docker

    - name: Configure HugePages
      sysctl:
        name: vm.nr_hugepages
        value: "65536"
        state: present

    - name: Mount NVMe Training Data Disk
      filesystem:
        fstype: ext4
        dev: /dev/nvme0n1
      mount:
        path: /data
        src: /dev/nvme0n1
        fstype: ext4
        state: mounted

模块九：安全与合规

图 4：AI 平台安全架构 — 四层纵深防御体系

9.1 AI 平台安全架构

AI 平台安全层级：

┌──────────────────────────────────────────────────────┐
│                    安全边界                          │
├──────────────────────────────────────────────────────┤
│  数据安全层                                          │
│  ├── 训练数据加密（at rest / in transit）            │
│  ├── 模型权重访问控制                                │
│  ├── 数据脱敏/匿名化                                 │
│  └── 数据血缘追踪                                    │
├──────────────────────────────────────────────────────┤
│  网络安全层                                          │
│  ├── K8s NetworkPolicy（Pod 间隔离）                 │
│  ├── API Gateway 认证/限流                           │
│  ├── 推理服务 mTLS                                   │
│  └── 外网访问白名单                                  │
├──────────────────────────────────────────────────────┤
│  身份与访问控制层                                    │
│  ├── K8s RBAC                                        │
│  ├── GPU 资源配额管理                                │
│  ├── 模型仓库权限分级                                │
│  └── 审计日志                                        │
├──────────────────────────────────────────────────────┤
│  容器与供应链安全                                    │
│  ├── 镜像漏洞扫描（Trivy/Grype）                     │
│  ├── 镜像签名（Cosign）                              │
│  ├── 非 root 运行                                    │
│  └── 只读文件系统                                    │
└──────────────────────────────────────────────────────┘

关键安全实践

# 1. K8s NetworkPolicy: 限制 GPU Pod 网络
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: gpu-pod-isolation
spec:
  podSelector:
    matchLabels:
      type: gpu-workload
  policyTypes:
    - Ingress
    - Egress
  ingress:
    - from:
        - namespaceSelector:
            matchLabels:
              name: ml-platform
      ports:
        - port: 8000
  egress:
    - to:
        - podSelector:
            matchLabels:
              app: postgres
      ports:
        - port: 5432

# 2. RBAC: GPU 资源使用权限
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: gpu-user
rules:
  - apiGroups: [""]
    resources: ["pods", "pods/log"]
    verbs: ["get", "list", "create", "delete"]
  - apiGroups: [""]
    resources: ["resourcequotas"]
    verbs: ["get", "list"]

# 3. 镜像安全扫描（CI 流水线集成）
# 在 CI 中添加：
# trivy image --severity HIGH,CRITICAL --exit-code 1 pytorch:2.1.0-cuda12.1

9.2 模型安全

# 模型文件完整性校验
sha256sum /data/models/qwen2-7b/pytorch_model.bin > /data/models/qwen2-7b/checksums.sha256

# 推理输入安全（SQL 注入、Prompt Injection 防护）
# 在推理网关层面过滤
python3 -c "
import re

def sanitize_input(prompt: str) -> str:
    # 长度限制
    if len(prompt) > 32768:
        raise ValueError('Prompt too long')
    # SQL 注入关键字过滤
    forbidden = ['DROP TABLE', 'DELETE FROM', 'UNION SELECT']
    for kw in forbidden:
        if kw.lower() in prompt.lower():
            raise ValueError(f'Forbidden keyword: {kw}')
    return prompt
"

模块十：成本优化 (FinOps)

GPU 成本优化 (FinOps) — 四维降本策略全景

图 5：GPU 成本优化 (FinOps) — 四维降本策略全景

10.1 GPU 成本分析框架

GPU 成本 = 硬件成本 + 电力成本 + 运维人力成本

典型月度成本（A100-80GB × 8 节点）：
  ├── 云上按需：¥12万/月（¥25/小时/卡）
  ├── 云上包年：¥6万/月 (¥12.5/小时/卡)
  ├── 云上 Spot：¥3万/月 (¥6/小时/卡, 波动)
  └── 自建机房：¥2万/月 (折旧分摊 + 电力 + 带宽)

成本优化策略

# GPU 资源利用率报告生成
import pandas as pd
from prometheus_api_client import PrometheusConnect

prom = PrometheusConnect(url="http://prometheus:9090")

# 查询过去 30 天 GPU 利用率
query = '''
avg_over_time(
    DCGM_FI_DEV_GPU_UTIL{pod=~".*training.*"}[30d]
)
'''

metrics = prom.custom_query(query)
df = pd.DataFrame(metrics)

# 分析闲置 GPU
df['cost_per_hour'] = df['gpu_model'].map({'A100-80GB': 25, 'A10': 8})
df['wasted_per_hour'] = df['cost_per_hour'] * (1 - df['utilization'] / 100)
df['monthly_waste'] = df['wasted_per_hour'] * 24 * 30

print(f"月度 GPU 浪费金额: ¥{df['monthly_waste'].sum():,.0f}")
print(f"总 GPU 成本: ¥{df['cost_per_hour'].sum() * 24 * 30:,.0f}")
print(f"整体利用率: {df['utilization'].mean():.1f}%")

KubeCost 部署

# GPU 成本可视化
helm repo add kubecost https://kubecost.github.io/cost-analyzer
helm install kubecost kubecost/cost-analyzer \
  --namespace kubecost \
  --create-namespace \
  --set kubecostProductConfigs.gpuCostGPUModelMap="NVIDIA A100-SXM4-80GB=A100-80GB,NVIDIA A10=A10" \
  --set kubecostProductConfigs.gpuCostEnabled=true \
  --set kubecostProductConfigs.customPricesEnabled=true \
  --set prometheus.server.persistentVolume.enabled=true

10.2 GPU 调度优化节省成本

# 1. K8s Bin Packing（紧凑调度，减少碎片节点）
# KubeSchedulerConfiguration
apiVersion: kubescheduler.config.k8s.io/v1beta3
kind: KubeSchedulerConfiguration
profiles:
  - schedulerName: default-scheduler
    pluginConfig:
      - name: NodeResourcesFit
        args:
          scoringStrategy:
            type: MostAllocated   # 优先填满已有节点
            resources:
              - name: nvidia.com/gpu
                weight: 10

# 2. 自动缩容空闲 GPU 节点
# Cluster Autoscaler 配置
# --scale-down-utilization-threshold=0.3   # 利用率 < 30% 时缩容
# --scale-down-unneeded-time=10m           # 空闲 10 分钟后缩容

附：快速参考卡片

常用命令速查

# === GPU ===
nvidia-smi dmon -s pucvmet -d 1          # GPU 实时监控
nvidia-smi topo -m                        # GPU 拓扑
dcgmi diag -r 3                           # GPU 诊断

# === K8s ===
kubectl describe node <node> | grep gpu   # GPU 节点信息
kubectl top pods -A                       # 资源使用 TOP
kubectl logs -f <pod> --previous          # 查看上一个容器的日志（OOM 后）

# === 网络 ===
tcpdump -i eth0 -nn port 29500            # 抓 NCCL 通信包
ss -s                                      # Socket 统计

# === 存储 ===
iostat -x 1                               # IO 性能
df -h /data                               # 训练数据盘空间

故障排查速查表

症状	可能原因	排查命令
训练挂起	NCCL 死锁/IB 故障	`dmesg
OOM	显存不足/batch 过大	`nvidia-smi` + `dmesg`
GPU 掉卡	Xid 错误/PCIe 问题	`dmesg
慢训练	数据加载瓶颈	`iostat -x 1` + PyTorch Profiler
推理延迟高	模型未优化/显存不足	`nvidia-smi dmon` + vLLM 日志
Pod Pending	GPU 资源不足/亲和性	`kubectl describe pod`

本文档持续更新。建议每季度回顾并补充最新的工具和实践。AI 基础设施领域变化极快，保持学习习惯比掌握具体工具更重要。

posted @ 2026-08-11 10:45 冷水泡茶阅读(15) 评论(0) 收藏举报

刷新页面返回顶部

冷水泡茶

茶无上品, 适口为珍, 学习最重要的是找到适合自己的方法, 然后坚持下去, and so on ... (运维技术交流: 618354452)