ai部署3

可以。针对你的场景，我建议把目标明确成：

2 台 CentOS 9 NVIDIA GPU 服务器，每台 8×A100 80GB PCIe，共 16×A100，裸机部署，不使用 Docker、不使用 Kubernetes，实现：GPU 基础环境 → 分布式训练 → LoRA/Full Fine-tuning → 监控 → 日志 → Checkpoint → 故障恢复 → 日常维护。

下面先给你工具总表，再给完整实施文档。

一、整体软件栈

层级	软件	作用	两台都安装	训练	监控	维护
OS	CentOS Stream 9 / CentOS 9	操作系统	✓			✓
GPU	NVIDIA Driver	驱动 A100	✓	✓	✓	✓
GPU Runtime	CUDA	GPU 计算平台	✓	✓		✓
AI Library	cuDNN	深度学习算子加速	✓	✓
GPU 通信	NCCL	GPU/GPU、节点间通信	✓	✓		✓
网络	RDMA/IB	两节点高速通信	✓	✓		✓
Python	Python 3.x	AI 软件运行环境	✓	✓		✓
Framework	PyTorch	神经网络训练	✓	✓		✓
Model	Transformers	Qwen/DeepSeek 等模型	✓	✓		✓
Distributed	FSDP	PyTorch 分布式训练	✓	✓		✓
Distributed	DeepSpeed	ZeRO/显存优化/分布式训练	✓	✓		✓
Fine-tune	PEFT	LoRA/Adapter 微调	✓	✓
Dataset	Datasets	数据集加载/处理	✓	✓
Tokenizer	Transformers Tokenizer	文本→Token	✓	✓
Training	TRL	SFT/DPO/偏好训练	✓	✓
Inference	vLLM	模型推理/API	✓		✓	✓
Monitoring	NVIDIA DCGM	GPU 指标	✓		✓	✓
Monitoring	Prometheus	指标采集	建议独立		✓	✓
Monitoring	Grafana	指标可视化	建议独立		✓	✓
System	node_exporter	CPU/内存/磁盘/网络	✓		✓	✓
Process	systemd	管理训练/服务	✓			✓
Log	journald	系统日志	✓			✓
Storage	NFS/并行存储	模型/数据/Checkpoint	视架构	✓		✓
Backup	rsync	Checkpoint/配置同步	✓			✓
API	OpenAI-compatible API	模型服务接口			✓	✓

二、最终架构

建议不要把所有东西都堆在 GPU 节点上。

                         ┌─────────────────────┐
                         │      管理网络        │
                         │ SSH / Ansible / NTP │
                         └──────────┬──────────┘
                                    │
                    ┌───────────────┴───────────────┐
                    │                               │
           ┌────────▼────────┐             ┌────────▼────────┐
           │   GPU-01        │             │   GPU-02        │
           │                 │             │                 │
           │ 8×A100 80GB     │             │ 8×A100 80GB     │
           │                 │             │                 │
           │ NVIDIA Driver   │             │ NVIDIA Driver   │
           │ CUDA            │             │ CUDA            │
           │ NCCL            │◄───────────►│ NCCL            │
           │ PyTorch         │   RDMA/IB    │ PyTorch         │
           │ DeepSpeed       │             │ DeepSpeed       │
           │ Transformers    │             │ Transformers    │
           └────────┬────────┘             └────────┬────────┘
                    │                               │
                    └──────────────┬────────────────┘
                                   │
                         ┌─────────▼─────────┐
                         │    Shared Storage │
                         │                   │
                         │ Dataset           │
                         │ Model             │
                         │ Checkpoint        │
                         └───────────────────┘


              ┌───────────────────────────────────┐
              │          Monitoring Server        │
              │                                   │
              │ Prometheus                        │
              │ Grafana                           │
              │ Alertmanager                      │
              └───────────────────────────────────┘

三、服务器规划

假设：

主机	管理 IP	GPU	GPU 数量	hostname
GPU-01	10.0.0.11	A100 80GB PCIe	8	gpu01
GPU-02	10.0.0.12	A100 80GB PCIe	8	gpu02
Monitor	10.0.0.20	无	0	monitor01

实际 IP 替换成你的环境。

如果暂时没有独立 Monitor Server，也可以先把 Prometheus/Grafana 放到 GPU-01，但生产环境不推荐。

四、安装前检查

4.1 检查 GPU

两台：

lspci | grep -i nvidia

应该看到 8 张 NVIDIA GPU。

然后：

nvidia-smi

最终应该看到：

GPU 0  NVIDIA A100 80GB PCIe
GPU 1  NVIDIA A100 80GB PCIe
...
GPU 7  NVIDIA A100 80GB PCIe

检查 GPU：

nvidia-smi -L

应该：

GPU 0: NVIDIA A100-SXM...
GPU 1: NVIDIA A100...
...
GPU 7: NVIDIA A100...

五、操作系统统一

两台必须尽量一致：

cat /etc/redhat-release

uname -r

hostnamectl

建议：

gpu01
gpu02

修改：

hostnamectl set-hostname gpu01

第二台：

hostnamectl set-hostname gpu02

六、配置 /etc/hosts

两台：

cat >> /etc/hosts <<EOF
10.0.0.11 gpu01
10.0.0.12 gpu02
10.0.0.20 monitor01
EOF

检查：

ping gpu01
ping gpu02

七、时间同步

分布式训练对时间同步没有 Kubernetes 那么严格，但生产环境必须统一。

安装：

dnf install -y chrony

启动：

systemctl enable --now chronyd

检查：

chronyc sources -v
chronyc tracking

两台时间差尽量控制在毫秒级。

八、安装 NVIDIA Driver

这里不要直接照抄一个固定版本。

Driver、CUDA、PyTorch、NCCL 必须选择兼容组合。

安装之前先确定：

GPU
↓
Driver
↓
CUDA
↓
PyTorch
↓
NCCL

检查：

lspci | grep -i nvidia

安装完成：

nvidia-smi

重点检查：

Driver Version
CUDA Version
GPU Temperature
Power
Memory
ECC

九、GPU 基础验证

执行：

nvidia-smi

然后：

nvidia-smi topo -m

这个非常重要。

它告诉你：

GPU0 ↔ GPU1
GPU0 ↔ GPU2
...
GPU ↔ NIC

PCIe A100 服务器尤其需要关注 GPU 和 NIC 的拓扑。

再看：

nvidia-smi -q

重点关注：

ECC
PCI
Power
Temperature
Memory
Clocks
Persistence Mode

十、开启 Persistence Mode

nvidia-smi -pm 1

检查：

nvidia-smi

可以做成 systemd 服务，避免重启后配置丢失。

十一、安装 CUDA

确认：

nvcc --version

如果没有：

which nvcc

CUDA 主要提供：

CUDA Runtime
CUDA Compiler
CUDA Libraries
CUDA Toolkit

例如：

export CUDA_HOME=/usr/local/cuda
export PATH=$CUDA_HOME/bin:$PATH
export LD_LIBRARY_PATH=$CUDA_HOME/lib64:$LD_LIBRARY_PATH

永久配置：

cat >/etc/profile.d/cuda.sh <<'EOF'
export CUDA_HOME=/usr/local/cuda
export PATH=$CUDA_HOME/bin:$PATH
export LD_LIBRARY_PATH=$CUDA_HOME/lib64:$LD_LIBRARY_PATH
EOF

十二、安装 Python

建议不要污染系统 Python。

例如：

dnf install -y python3 python3-devel

然后：

python3 --version

建立独立环境：

python3 -m venv /opt/ai-venv

激活：

source /opt/ai-venv/bin/activate

升级：

pip install -U pip setuptools wheel

十三、安装 PyTorch

PyTorch 是整个训练系统的核心。

安装后：

python - <<'PY'
import torch

print("PyTorch:", torch.__version__)
print("CUDA:", torch.version.cuda)
print("CUDA available:", torch.cuda.is_available())
print("GPU count:", torch.cuda.device_count())

for i in range(torch.cuda.device_count()):
    print(i, torch.cuda.get_device_name(i))
PY

必须看到：

CUDA available: True
GPU count: 8

十四、安装 Transformers

pip install transformers

测试：

python - <<'PY'
import transformers
print(transformers.__version__)
PY

十五、安装分布式训练组件

pip install \
    accelerate \
    datasets \
    peft \
    trl \
    sentencepiece

DeepSpeed：

pip install deepspeed

验证：

ds_report

重点检查：

CUDA
Torch
NCCL
aio
CPU

十六、验证单机 8 GPU

先不要急着做两机。

先验证：

GPU-01
8 GPU

运行：

torchrun \
  --nproc_per_node=8 \
  test.py

测试程序核心：

import torch
import torch.distributed as dist

dist.init_process_group("nccl")

local_rank = int(torch.cuda.current_device())

print(
    "rank=",
    dist.get_rank(),
    "world=",
    dist.get_world_size(),
    "gpu=",
    local_rank
)

dist.destroy_process_group()

应该看到：

rank=0 world=8 gpu=0
rank=1 world=8 gpu=1
...
rank=7 world=8 gpu=7

十七、再测试两台 16 GPU

GPU-01：

torchrun \
  --nnodes=2 \
  --nproc_per_node=8 \
  --node_rank=0 \
  --master_addr=gpu01 \
  --master_port=29500 \
  test.py

GPU-02：

torchrun \
  --nnodes=2 \
  --nproc_per_node=8 \
  --node_rank=1 \
  --master_addr=gpu01 \
  --master_port=29500 \
  test.py

最终：

world_size = 16

十八、NCCL 两机测试

正式训练前，必须验证 NCCL。

重点检查：

echo $NCCL_DEBUG
echo $NCCL_SOCKET_IFNAME
echo $NCCL_IB_HCA

测试：

NCCL_DEBUG=INFO

然后运行 NCCL Tests。

例如：

./build/all_reduce_perf \
    -b 8 \
    -e 4G \
    -f 2 \
    -g 8

两机测试重点看：

NCCL
NET/IB
NET/Socket
Bandwidth
AllReduce

如果 NCCL 两机通信不正常，不要开始正式训练。

十九、为什么 RDMA 很重要

两台机器之间：

GPU
 ↓
PCIe
 ↓
NIC
 ↓
Network
 ↓
NIC
 ↓
PCIe
 ↓
GPU

如果走普通 TCP：

GPU
 ↓
CPU
 ↓
TCP/IP
 ↓
CPU
 ↓
GPU

通信开销会明显增加。

如果使用 RDMA：

GPU
 ↓
RDMA
 ↓
NIC
 ↓
RDMA
 ↓
GPU

对于 16 GPU 分布式训练，网络通信可能成为主要瓶颈。

二十、训练数据目录规划

不要把数据随便放 /root。

建议：

/data/
├── datasets/
│   ├── raw/
│   ├── cleaned/
│   └── tokenized/
│
├── models/
│   ├── base/
│   ├── lora/
│   └── merged/
│
├── checkpoints/
│   ├── job-001/
│   ├── job-002/
│   └── latest/
│
├── logs/
│   ├── training/
│   └── inference/
│
└── cache/

二十一、训练数据

例如 SFT 数据：

{
  "instruction": "解释 Kubernetes Pod 为什么会 OOMKilled",
  "input": "",
  "output": "Pod 被 OOMKilled 通常表示..."
}

或者对话：

{
  "messages": [
    {
      "role": "user",
      "content": "什么是 TCP TIME_WAIT？"
    },
    {
      "role": "assistant",
      "content": "TIME_WAIT 是 TCP..."
    }
  ]
}

数据质量通常比“堆很多数据”更重要。

二十二、训练之前必须做数据检查

至少统计：

数据量
平均 token
最大 token
重复率
空数据
异常数据
语言比例
训练/验证集比例

建议：

Train: 95%
Validation: 5%

不要直接：

100% 数据 → training

否则你无法判断模型有没有过拟合。

二十三、第一次训练建议 LoRA

你的第一套实验不要直接 Full Fine-Tuning。

项目	Full FT	LoRA
显存	高	低
GPU需求	高	低
训练速度	慢	快
Checkpoint	大	小
风险	高	低
调参	难	相对简单
首次实验	不推荐	推荐

二十四、LoRA 训练流程

Base Model
     │
     ▼
Tokenizer
     │
     ▼
Dataset
     │
     ▼
DataLoader
     │
     ▼
Forward
     │
     ▼
Loss
     │
     ▼
Backward
     │
     ▼
LoRA Parameters Update
     │
     ▼
NCCL Sync
     │
     ▼
Checkpoint

二十五、16 GPU 训练时要关注哪些参数

最重要：

per_device_train_batch_size
gradient_accumulation_steps
learning_rate
num_train_epochs
max_seq_length
bf16
gradient_checkpointing

例如：

GPU batch = 2

16 GPU

gradient accumulation = 8

有效 batch size：

2 × 16 × 8
=
256

即：

Effective Batch Size = GPU Batch × GPU 数量 × Gradient Accumulation

二十六、A100 使用 BF16

A100 对 BF16 支持很好。

训练通常优先考虑：

bf16

而不是：

fp32

例如：

FP32
4 bytes

BF16
2 bytes

可以显著降低显存和计算压力。

二十七、Gradient Checkpointing

如果模型显存压力大：

gradient_checkpointing=true

它的思路是：

少保存 activation
       ↓
需要的时候重新计算
       ↓
降低显存
       ↓
增加一些计算

典型的：

用计算换显存。

二十八、Checkpoint 必须设计好

训练不能只保存：

model.bin

至少需要：

Model
Optimizer
Scheduler
Random State
Training Step
Epoch
Configuration
Tokenizer

否则训练跑了 3 天，机器重启后只能从头开始。

二十九、断点恢复

例如：

--resume_from_checkpoint \
/data/checkpoints/job-001/checkpoint-10000

训练过程：

Step 10000
   ↓
Checkpoint
   ↓
Step 11000
   ↓
Checkpoint
   ↓
机器故障
   ↓
重新启动
   ↓
Checkpoint 10000
   ↓
继续训练

三十、训练监控

三十一、GPU 监控必须监控什么

至少：

指标	作用
GPU Utilization	GPU 是否真正工作
GPU Memory Used	显存
GPU Temperature	温度
GPU Power	功耗
GPU Clock	GPU频率
SM Utilization	SM 使用率
PCIe Throughput	PCIe
NVLink	如果有
ECC	GPU错误
XID	NVIDIA硬件/驱动异常
MIG	如果启用
Fan	散热

三十二、训练监控还要看

仅看 GPU utilization 不够。

还需要：

loss
learning_rate
tokens/sec
samples/sec
step time
epoch
global step
gradient norm
GPU memory
checkpoint

例如：

loss
  │
  │\
  │ \
  │  \
  │   \____
  │
  └────────── step

如果：

GPU = 95%

不代表训练一定正常。

三十三、典型异常

GPU 利用率只有 20%

可能：

数据加载慢
CPU瓶颈
Storage慢
网络慢
batch太小
NCCL等待

GPU 100%，但训练速度低

可能：

模型计算量太大
通信占比高
batch/seq配置不合理
GPU频率下降

一部分 GPU 100%，一部分 GPU 0%

这是重点问题。

通常：

某个 rank 卡住
NCCL 通信问题
数据不均衡
某 GPU 出错

三十四、日志管理

每个训练任务单独目录：

/data/logs/training/job-001/

例如：

train.log
rank-0.log
rank-1.log
...
rank-15.log

不要只保留 rank 0。

因为：

rank 0 正常
rank 13 异常

非常常见。

三十五、systemd 管理

例如：

ai-training-job.service

可以做到：

systemctl start ai-training-job
systemctl stop ai-training-job
systemctl status ai-training-job
journalctl -u ai-training-job

但是对于一次性训练任务，我更推荐：

SLURM

如果未来训练任务很多，应该进一步引入：

SLURM

而不是自己写大量 shell 调度。

三十六、两台机器的维护

每天：

nvidia-smi

检查：

GPU
Temperature
Power
Memory
ECC
XID

检查：

dmesg | grep -i -E 'nvrm|xid|pcie'

检查：

journalctl -k

检查磁盘：

df -h

检查 inode：

df -i

检查网络：

ip -s link

三十七、GPU 异常重点看 XID

dmesg | grep -i xid

或者：

journalctl -k | grep -i xid

如果出现：

NVRM: Xid

需要重点调查：

GPU
Driver
PCIe
Power
Temperature
Hardware

不能简单地认为：

“训练程序有问题。”

三十八、版本管理

这个非常重要。

建立：

/opt/ai/
├── env/
│   ├── pytorch/
│   └── inference/
│
├── config/
│   ├── gpu01.env
│   └── gpu02.env
│
└── scripts/

保存：

nvidia-smi
nvcc --version
python --version
pip freeze

例如：

pip freeze > /opt/ai/config/pip-freeze.txt

同时记录：

Driver
CUDA
PyTorch
NCCL
Transformers
DeepSpeed
Python
OS kernel

三十九、两台服务器必须保证版本一致

尤其是：

Driver
CUDA
NCCL
PyTorch
Python
Transformers
DeepSpeed

不能：

GPU01 PyTorch 2.x
GPU02 PyTorch 另一版本

否则分布式训练非常容易出现奇怪问题。

四十、维护策略

建议建立三套环境：

Production
Training
Test

至少不要直接在生产训练环境：

pip install -U xxx

因为可能导致：

PyTorch升级
CUDA兼容性变化
NCCL变化
训练无法恢复

四十一、推荐目录

最终：

/opt/ai/
├── env/
│   └── pytorch/
│
├── models/
│   ├── base/
│   └── production/
│
├── datasets/
│
├── checkpoints/
│
├── jobs/
│   ├── job-001/
│   └── job-002/
│
├── logs/
│
├── scripts/
│   ├── gpu-check.sh
│   ├── nccl-test.sh
│   ├── train.sh
│   ├── stop.sh
│   └── health-check.sh
│
└── config/
    ├── versions.txt
    └── training/

四十二、生产维护检查表

检查项	频率	命令/工具
GPU状态	每日	`nvidia-smi`
XID	每日	`dmesg`
GPU温度	实时	Grafana
GPU显存	实时	DCGM
GPU利用率	实时	DCGM
CPU	实时	node_exporter
内存	实时	node_exporter
磁盘	实时	node_exporter
网络	实时	node_exporter
NCCL	变更后	nccl-tests
CUDA	变更后	`nvcc`
PyTorch	变更后	Python
Checkpoint	每个任务	文件系统
模型	每次发布	Model Registry/Storage
训练日志	每个任务	journald/文件
配置	每次变更	Git
系统	每月	RPM/安全更新

四十三、推荐的实施顺序

不要一次性把所有软件全部装上。

按照下面顺序做，故障定位最容易：

第 1 阶段
CentOS 9
   ↓
hostname / hosts / NTP

↓

第 2 阶段
NVIDIA Driver
   ↓
nvidia-smi
   ↓
8 GPU 正常

↓

第 3 阶段
CUDA
   ↓
nvcc

↓

第 4 阶段
Python
   ↓
PyTorch
   ↓
单 GPU

↓

第 5 阶段
8 GPU
   ↓
PyTorch DDP

↓

第 6 阶段
NCCL
   ↓
单机 8 GPU

↓

第 7 阶段
RDMA/IB
   ↓
两机网络

↓

第 8 阶段
NCCL
   ↓
两机 16 GPU

↓

第 9 阶段
Transformers
DeepSpeed/FSDP
PEFT
TRL

↓

第 10 阶段
LoRA
   ↓
小数据集
   ↓
单机测试

↓

第 11 阶段
16 GPU
   ↓
正式训练

↓

第 12 阶段
DCGM
Prometheus
Grafana

↓

第 13 阶段
Checkpoint
日志
故障恢复

↓

第 14 阶段
vLLM
   ↓
AI Gateway

四十四、最终你得到的系统

                         AI Platform
                              │
             ┌────────────────┼────────────────┐
             │                │                │
          Training         Monitoring        Serving
             │                │                │
       PyTorch              DCGM             vLLM
       Transformers         node_exporter       │
       DeepSpeed            Prometheus          │
       FSDP                 Grafana             │
       PEFT                 Alertmanager        │
       TRL                                      │
             │                                  │
             └──────────────┬───────────────────┘
                            │
                     2 GPU Servers
                            │
                ┌───────────┴───────────┐
                │                       │
          GPU-01                  GPU-02
          8×A100                  8×A100
             │                       │
             └──────── NCCL ─────────┘
                       │
                  RDMA / IB
                       │
                Shared Storage

关键结论

对于你的 2 × 8 A100 80GB 环境，我建议技术路线定为：

基础层

CentOS 9 + NVIDIA Driver + CUDA + NCCL + RDMA

训练层

Python + PyTorch + Transformers + DeepSpeed/FSDP + PEFT + TRL

第一阶段训练

LoRA/SFT，而不是直接从零预训练

分布式

先单 GPU → 单机 8 GPU → 两机 16 GPU，逐级验证

监控

DCGM Exporter + node_exporter + Prometheus + Grafana

维护

systemd + journald + Checkpoint + 配置版本化 + 健康检查

推理

vLLM

后续集群调度

如果训练任务从 1 个增加到多个，再引入 SLURM；不需要为了两台机器一开始就上 Kubernetes。

这套架构的关键不是“把软件装齐”，而是先把 16 GPU 的 NCCL/RDMA 通信打通，再做训练。否则即使 PyTorch、DeepSpeed 都安装成功，两机训练仍然可能因为网络通信成为瓶颈。

posted on 2026-08-24 17:31 小镇-做题家阅读(3) 评论(0) 收藏举报

刷新页面返回顶部

ai部署3

一、整体软件栈

二、最终架构

三、服务器规划

四、安装前检查

4.1 检查 GPU

五、操作系统统一

六、配置 /etc/hosts

七、时间同步

八、安装 NVIDIA Driver

九、GPU 基础验证

十、开启 Persistence Mode

十一、安装 CUDA

十二、安装 Python

十三、安装 PyTorch

十四、安装 Transformers

十五、安装分布式训练组件

十六、验证单机 8 GPU

十七、再测试两台 16 GPU

十八、NCCL 两机测试

十九、为什么 RDMA 很重要

二十、训练数据目录规划

二十一、训练数据

二十二、训练之前必须做数据检查

二十三、第一次训练建议 LoRA

二十四、LoRA 训练流程

二十五、16 GPU 训练时要关注哪些参数

二十六、A100 使用 BF16

二十七、Gradient Checkpointing

二十八、Checkpoint 必须设计好

二十九、断点恢复

三十、训练监控

三十一、GPU 监控必须监控什么

三十二、训练监控还要看

三十三、典型异常

GPU 利用率只有 20%

GPU 100%，但训练速度低

一部分 GPU 100%，一部分 GPU 0%

三十四、日志管理

三十五、systemd 管理

三十六、两台机器的维护

三十七、GPU 异常重点看 XID

三十八、版本管理

三十九、两台服务器必须保证版本一致

四十、维护策略

四十一、推荐目录

四十二、生产维护检查表

四十三、推荐的实施顺序

四十四、最终你得到的系统

关键结论

导航

公告