Skip to main content

新页面

好的，这是一个非常经典的高性能计算（HPC）和AI集群的搭建需求。你拥有非常棒的硬件基础（8台8卡服务器 + IB网络），搭建一个高效、易用的系统是完全可行的。

下面我将为你提供一套完整的、分阶段的部署方案，从系统架构设计到具体的软件选型和配置，最终实现你想要的效果。

第一部分：整体架构设计 (Architecture)

首先，我们需要一个清晰的架构。你的8台服务器不能都是对等的，需要有角色划分。

  1. 管理/登录节点 (Head/Login Node):

    • 角色: 集群的“大脑”和“大门”。
    • 功能:
      • 用户通过SSH登录这台服务器。
      • 运行作业调度系统的控制器（如Slurm Controller）。
      • 编译代码、准备数据集、提交作业。
      • 运行监控服务。
    • 建议: 从你的8台服务器中指定1台作为管理节点。这台节点本身也包含8张GPU，可以配置成既是管理节点，又是计算节点。对于8台的小规模集群，这是最经济的做法。

  2. 计算节点 (Compute Nodes):

    • 角色: 执行计算任务的“工人”。
    • 功能:
      • 只负责运行由调度系统分配过来的作业。
      • 用户通常不直接登录计算节点。
    • 建议: 剩下的7台服务器（以及管理节点自身）都作为计算节点。

  3. 存储节点/服务 (Storage Node/Service):

    • 角色: 提供共享文件中心的“仓库”。
    • 功能: 所有节点（管理节点和计算节点）都可以像访问本地目录一样访问这个共享存储。
    • 建议: 你可以：
      • 方案A (简单快速): 在管理节点上同时运行NFS（Network File System）服务，将一块大容量硬盘（或RAID阵列）共享出来。
      • 方案B (性能更佳): 如果有额外的一台服务器，可以将其专门用作NFS存储服务器，性能和稳定性更好。

  4. 网络规划 (Networking):

    • 管理网络 (Ethernet): 使用服务器自带的千兆或万兆以太网口。用于SSH登录、系统管理、软件安装、访问外部互联网等。所有节点都需要连接到这个网络。
    • 计算网络 (InfiniBand): 使用IB卡和IB交换机。专门用于高性能计算，特别是多机多卡的分布式训练（如MPI、NCCL通信）。这是保证GPU之间通信速度的关键。

架构图示意:

      +------------------+      +-------------------+
      |   用户 (SSH)      |----->|  管理/登录节点     |
      |                  |      | (Head Node)       |
      +------------------+      | - 作业调度器 Master |
                              | - NFS Server      |
                              | - 监控服务        |
                              +--------+----------+
                                       |
           +---------------------------+---------------------------+ (管理网络 - Ethernet)
           |                           |                           |
+----------+---------+     +-----------+--------+     +------------+-------+
| 计算节点 1 (Compute)|     | 计算节点 2 (Compute)| ... | 计算节点 8 (Compute)|
| (Head Node 自身)    |     |                    |     |                    |
+--------------------+     +--------------------+     +--------------------+
           |                           |                           |
           +---------------------------+---------------------------+ (计算网络 - InfiniBand)
                                       |
                              +--------+----------+
                              |   IB 交换机        |
                              +-------------------+

第二部分：分步实施指南 (Step-by-Step Guide)

阶段一：硬件和基础系统安装

  1. 硬件上架与连接:

    • 将8台服务器和IB交换机上架。
    • 以太网: 将所有服务器的以太网口连接到同一个以太网交换机。
    • InfiniBand: 将所有服务器的IB卡连接到IB交换机。

  2. 操作系统安装:

    • 在所有8台服务器上安装完全相同版本的Linux操作系统。
    • 推荐: Ubuntu Server 22.04 LTS，因为它对AI/ML社区支持最好。CentOS/Rocky Linux也是不错的选择。
    • 关键: 保持内核版本、系统库一致，避免未来出现奇怪的依赖问题。
    • 自动化工具: 为了保证一致性，强烈建议使用自动化工具如 Ansible。你只需要写好一个部署脚本（Playbook），就可以一键在所有机器上完成配置。

  3. 网络配置:

    • 为所有节点的以太网口和IB网口配置静态IP地址。
    • 示例:
      • 管理网络 (eth0): 192.168.1.10 (管理节点), 192.168.1.11 - 192.168.1.17 (计算节点)
      • IB网络 (ib0): 10.10.1.10 (管理节点), 10.10.1.11 - 10.10.1.17 (计算节点)
    • 配置 /etc/hosts 文件，让所有节点可以通过主机名互相访问（如 head-node, compute-01）。
    • 测试: 在所有节点间 ping 主机名，确保网络通畅。使用 ib_pingpong 等工具测试IB网络的连通性和延迟。

  4. 基础软件和驱动安装:

    • 在所有节点上安装:
      • NVIDIA Driver: 版本要一致！
      • CUDA Toolkit: 版本要一致！
      • cuDNN
      • NCCL: NVIDIA的集合通信库，对分布式训练至关重要，需要确保它能利用IB网络。
    • 再次强调: 使用Ansible来自动化这个过程，确保所有节点配置完全一样。

阶段二：搭建共享文件中心 (NFS)

  1. 在管理节点上 (作为NFS Server):

    • 安装NFS服务: sudo apt update && sudo apt install nfs-kernel-server
    • 创建共享目录: sudo mkdir -p /export/share
    • 设置权限: sudo chown -R nobody:nogroup /export/share && sudo chmod 777 /export/share
    • 配置NFS导出: 编辑 /etc/exports 文件，添加一行： 
      /export/share  192.168.1.0/24(rw,sync,no_subtree_check)
      这允许192.168.1.x网段的机器读写这个目录。
    • 启动并生效: sudo exportfs -a && sudo systemctl restart nfs-kernel-server

  2. 在所有计算节点上 (以及管理节点自身，作为NFS Client):

    • 安装NFS客户端: sudo apt update && sudo apt install nfs-common
    • 创建挂载点: sudo mkdir -p /share
    • 设置开机自动挂载: 编辑 /etc/fstab 文件，添加一行： 
      192.168.1.10:/export/share  /share  nfs  defaults  0  0
      (假设 192.168.1.10 是你管理节点的IP)
    • 手动挂载测试: sudo mount -a
    • 验证: 在任意节点 cd /share，创建一个文件，然后去另一个节点查看该文件是否存在。

现在，你就有了一个所有节点都能访问的 /share 目录，可以存放代码、数据集和模型。

阶段三：用户管理

为了让Slurm正确地将作业分配给用户，所有节点上的用户和用户组必须有相同的UID和GID。

  • 简单方案 (适合小集群): 在所有8台服务器上手动创建相同的用户账号，并确保 useradd 命令生成的UID/GID一致。
  • 标准方案 (推荐): 使用 LDAP 或 SSSD 搭建统一认证中心。这样你只需要在一个地方创建用户，所有机器都能识别。这个稍微复杂些，但一劳永逸。对于8台机器，可以先从手动创建开始。

阶段四：作业调度和GPU管理 (核心)

这是实现“选择几张卡跑实验”功能的核心。我们将使用 Slurm，它是开源HPC领域的事实标准。

  1. 安装Slurm:

    • 在所有节点上安装Slurm。在Ubuntu上通常是 slurm-wlm。 
      sudo apt update
sudo apt install slurm-wlm # 这会安装所有组件
    • 你还需要一个Munge服务来做Slurm各组件间的认证。 
      sudo apt install munge
# 需要生成一个 munge.key，并分发到所有节点
# 在管理节点生成: sudo /usr/sbin/create-munge-key
# 拷贝到其他节点: scp /etc/munge/munge.key compute-01:/etc/munge/
# 在所有节点上设置权限并启动服务

  2. 配置Slurm: 这是最关键的一步。配置文件是 /etc/slurm/slurm.conf，你需要在管理节点上精心编辑一份，然后分发到所有节点。

    slurm.conf 核心配置示例:

    # 集群名称
ClusterName=ai-cluster

# 管理节点信息
SlurmctldHost=head-node  # 管理节点的主机名
SlurmctldPort=6817

# GPU作为通用资源(Generic Resource)进行管理
GresTypes=gpu

# Slurm状态保存位置
StateSaveLocation=/var/spool/slurmctld
# ...其他全局配置...

# --- 节点定义 ---
# 定义每个计算节点，并告诉Slurm每个节点有多少CPU、内存和GPU
# 注意: NodeName必须和`hostname`命令输出一致
NodeName=head-node CPUs=64 RealMemory=256000 Gres=gpu:8 State=UNKNOWN
NodeName=compute-01 CPUs=64 RealMemory=256000 Gres=gpu:8 State=UNKNOWN
NodeName=compute-02 CPUs=64 RealMemory=256000 Gres=gpu:8 State=UNKNOWN
# ...为所有8台机器添加类似的行...

# --- 分区定义 ---
# 分区是节点的集合，用户向分区提交作业
PartitionName=gpu_partition Nodes=head-node,compute-[01-07] Default=YES MaxTime=INFINITE State=UP

    gres.conf 配置GPU设备文件: 为了让Slurm知道 Gres=gpu:8 对应 /dev/nvidia0 到 /dev/nvidia7，创建 /etc/slurm/gres.conf：

    # 在所有计算节点上创建此文件
NodeName=head-node Name=gpu File=/dev/nvidia[0-7]
NodeName=compute-01 Name=gpu File=/dev/nvidia[0-7]
# ...为所有8台机器添加类似的行...

# 更简单的方法是使用 AutoDetect=nvml，Slurm会自动检测NVIDIA GPU
# AutoDetect=nvml

  3. 启动服务:

    • 管理节点: sudo systemctl start slurmctld
    • 所有计算节点: sudo systemctl start slurmd
    • 检查状态: 在管理节点运行 sinfo，你应该能看到所有节点和它们的状态。

阶段五：运维和用户工作流

  1. 用户如何使用:

    • 用户SSH到 head-node。
    • 在 /share 目录准备好代码和数据。
    • 创建一个作业脚本，例如 run_pytorch.sh:
    #!/bin/bash

#SBATCH --job-name=my_deep_learning_job  # 作业名
#SBATCH --partition=gpu_partition        # 提交到gpu_partition分区
#SBATCH --nodes=1                        # 需要1个节点
#SBATCH --ntasks=1                       # 在节点上运行1个任务
#SBATCH --cpus-per-task=8                # 为这个任务分配8个CPU核心
#SBATCH --mem=64G                        # 为这个任务分配64GB内存

# !!! 这是关键：请求4张GPU !!!
#SBATCH --gres=gpu:4

# 加载环境（如果使用conda或module）
# source activate my_env

# 打印分配到的GPU信息，Slurm会自动设置CUDA_VISIBLE_DEVICES
echo "CUDA_VISIBLE_DEVICES: $CUDA_VISIBLE_DEVICES"
nvidia-smi

# 运行你的Python训练脚本
python train.py --batch-size 256

    • 提交作业: sbatch run_pytorch.sh

    • 工作流:

      1. Slurm收到请求，寻找一个有至少4张空闲GPU的节点。
      2. 找到后，它在该节点上锁定这4张GPU，并设置环境变量 CUDA_VISIBLE_DEVICES (例如 0,1,2,3)。
      3. 你的 train.py 脚本（使用PyTorch或TensorFlow）将只会看到这4张被分配的卡，从而实现了资源隔离和按需使用。

  2. 常用监控命令:

    • sinfo: 查看集群节点状态。
    • squeue: 查看正在排队和运行的作业。
    • scontrol show node <nodename>: 查看节点详细信息，包括GPU分配情况。
    • scancel <jobid>: 取消作业。
    • watch nvidia-smi: 在节点上实时查看GPU使用情况。

  3. 高级监控系统 (运维):

    • Prometheus + Grafana: 这是现代运维的标配。
    • Node Exporter: 采集节点的CPU、内存、磁盘等系统指标。
    • DCGM Exporter: NVIDIA官方的工具，用于采集非常详细的GPU指标（利用率、显存、温度、功耗、NVLink流量等）。
    • 在Grafana中创建一个仪表盘，你可以一目了然地看到整个集群所有64张GPU的实时状态，非常酷炫且实用。

当然！搭建 Prometheus + Grafana 监控系统是你运维体系中至关重要的一环，它能让你从“黑盒”运维变成“白盒”运维，对整个集群的健康状况和资源使用情况了如指掌。

下面是一套专门为你这个AI集群量身定制的 Prometheus + Grafana 搭建建议。

第一部分：架构和理念

这个监控系统的核心理念是 "Pull" (拉取) 模型。

  1. Exporters (数据探针): 在你所有的8台服务器上，我们会安装一些小程序，叫做 "Exporter"。它们的作用就像是暴露在外的传感器，负责采集本机的各种指标（CPU、内存、磁盘、网络，以及最重要的GPU指标），并以特定的格式（HTTP端点）暴露出来。
  2. Prometheus Server (数据中心): 在你的**管理节点 (Head Node)**上，我们会安装 Prometheus 主服务。它会周期性地（例如每15秒）去“拉取”所有8台服务器上 Exporter 暴露的数据，并存储在自己的时序数据库(TSDB)中。
  3. Grafana (可视化仪表盘): 同样在你的管理节点上，我们安装 Grafana。它本身不存储数据，而是作为一个漂亮的前端。它会向 Prometheus 查询数据，然后通过丰富的图表、仪表盘等形式展示出来。
  4. Alertmanager (报警系统，可选): Prometheus 可以根据预设的规则（例如：GPU温度超过90度）产生告警，并将其发送给 Alertmanager。Alertmanager 负责对告警进行去重、分组，并通过Email、Slack、钉钉等方式通知你。

架构图示意:

+-------------------------------------------------+
|                   管理节点 (Head Node)           |
|                                                 |
| +----------------+   PULL   +-----------------+ |
| | Grafana        |<---------| Prometheus      | |
| | (Port 3000)    |  Query   | (Port 9090)     | |
| +----------------+          +--------+--------+ |
|                                      |          |
+--------------------------------------|----------+
                                       | PULL (Scrape)
                                       |
+--------------------------------------|-----------------------------------------+
|                                      |                                         |
|         on all 8 nodes               |          on all 8 nodes                 |
|                                      |                                         |
| +----------------------------------+ | +-------------------------------------+ |
| |  Node Exporter (系统指标)         | | |  DCGM Exporter (GPU核心指标)         | |
| |  (e.g., Port 9100)               | | |  (e.g., Port 9400)                  | |
| +----------------------------------+ | +-------------------------------------+ |
|                                      |                                         |
|            计算节点 1-8               |            计算节点 1-8                  |
+---------------------------------------------------------------------------------+

第二部分：分步实施指南

先决条件: 假设你的8台服务器（包括管理节点）都已经装好了操作系统，并且网络互通。

阶段一：在所有8台服务器上部署 Exporters

这一步强烈建议使用 Ansible 自动化完成，否则你需要在8台机器上重复操作。

1. 安装 Node Exporter (采集系统基础指标)

Node Exporter 负责采集CPU、内存、磁盘I/O、网络流量等基础指标。

  • 在所有8台服务器上执行:
    1. 下载: 去 Prometheus官网下载页面 找到最新的 node_exporter for linux-amd64 的下载链接。 
      wget https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz
    2. 解压安装: 
      tar xvfz node_exporter-1.7.0.linux-amd64.tar.gz
sudo mv node_exporter-1.7.0.linux-amd64/node_exporter /usr/local/bin/
    3. 创建 systemd 服务 (使其开机自启): 创建文件 sudo nano /etc/systemd/system/node_exporter.service 并写入以下内容： 
      [Unit]
Description=Node Exporter
Wants=network-online.target
After=network-online.target

[Service]
User=node_exporter
Group=node_exporter
Type=simple
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target
    4. 创建专用用户并启动服务: 
      sudo useradd --no-create-home --shell /bin/false node_exporter
sudo systemctl daemon-reload
sudo systemctl enable node_exporter
sudo systemctl start node_exporter
    5. 验证: 在浏览器或使用 curl 访问 http://<任意一台服务器IP>:9100/metrics，如果看到一大堆文本指标输出，说明成功。
2. 安装 DCGM Exporter (采集NVIDIA GPU核心指标)

这是监控GPU的最佳实践。DCGM (Data Center GPU Manager)是NVIDIA官方套件，dcgm-exporter 可以从中提取非常详细的GPU指标，远比nvidia-smi强大。

  • 在所有8台服务器上执行:
    1. 安装DCGM: 按照 NVIDIA官方文档 的指导，添加NVIDIA的仓库并安装DCGM。对于Ubuntu，通常是： 
      # 参照官方文档添加仓库...
sudo apt-get update
sudo apt-get install -y datacenter-gpu-manager
    2. 启动DCGM服务: 
      sudo systemctl enable nvidia-dcgm
sudo systemctl start nvidia-dcgm
    3. 下载并运行 dcgm-exporter: 推荐使用Docker来运行，最简单干净。 
      docker run -d --restart always --gpus all \
  --net host \
  -p 9400:9400 \
  --name dcgm-exporter \
  nvidia/dcgm-exporter:3.3.0-1-ubuntu22.04
      • --gpus all: 允许容器访问所有GPU。
      • --net host: 让容器直接使用主机的网络，性能最好，也方便Prometheus发现。
      • -p 9400:9400: 默认暴露在9400端口。
    4. 验证: 访问 http://<任意一台服务器IP>:9400/metrics，应该能看到大量以 DCGM_ 开头的GPU指标。

阶段二：在管理节点上安装和配置 Prometheus

  • 只在管理节点 (Head Node) 上执行:

    1. 下载并安装 Prometheus:

      wget https://github.com/prometheus/prometheus/releases/download/v2.51.0/prometheus-2.51.0.linux-amd64.tar.gz
tar xvfz prometheus-2.51.0.linux-amd64.tar.gz
cd prometheus-2.51.0.linux-amd64
sudo mv prometheus promtool /usr/local/bin/
sudo mkdir /etc/prometheus
sudo mv prometheus.yml /etc/prometheus/

    2. 配置 prometheus.yml: 这是最关键的配置！编辑 sudo nano /etc/prometheus/prometheus.yml，内容如下：

      global:
  scrape_interval: 15s # 每15秒抓取一次

scrape_configs:
  # 抓取 Prometheus 自身
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  # 抓取所有节点的系统指标
  - job_name: 'node_exporter'
    static_configs:
      - targets:
        - 'head-node:9100'      # 你的管理节点主机名或IP
        - 'compute-01:9100'     # 你的计算节点1
        - 'compute-02:9100'
        - 'compute-03:9100'
        - 'compute-04:9100'
        - 'compute-05:9100'
        - 'compute-06:9100'
        - 'compute-07:9100'
        # 把你所有8台机器的地址和端口都加上

  # 抓取所有节点的GPU指标
  - job_name: 'dcgm_exporter'
    static_configs:
      - targets:
        - 'head-node:9400'
        - 'compute-01:9400'
        - 'compute-02:9400'
        - 'compute-03:9400'
        - 'compute-04:9400'
        - 'compute-05:9400'
        - 'compute-06:9400'
        - 'compute-07:9400'
        # 同样，所有8台机器的地址和端口

    3. 创建 systemd 服务: 创建 sudo nano /etc/systemd/system/prometheus.service：

      [Unit]
Description=Prometheus
Wants=network-online.target
After=network-online.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus \
    --config.file /etc/prometheus/prometheus.yml \
    --storage.tsdb.path /var/lib/prometheus/ \
    --web.console.templates=/etc/prometheus/consoles \
    --web.console.libraries=/etc/prometheus/console_libraries

[Install]
WantedBy=multi-user.target

    4. 创建用户、目录并启动:

      sudo useradd --no-create-home --shell /bin/false prometheus
sudo mkdir /var/lib/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus
sudo systemctl daemon-reload
sudo systemctl enable prometheus
sudo systemctl start prometheus

    5. 验证: 访问 http://<管理节点IP>:9090。点击菜单栏的 "Status" -> "Targets"。你应该能看到 node_exporter 和 dcgm_exporter 两个 job，并且下面所有节点的 "State" 都应该是 "UP" (绿色)。

阶段三：在管理节点上安装和配置 Grafana

  • 只在管理节点 (Head Node) 上执行:
    1. 安装 Grafana: 推荐使用官方源安装，方便升级。 
      sudo apt-get install -y apt-transport-https software-properties-common
wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -
echo "deb https://packages.grafana.com/oss/deb stable main" | sudo tee -a /etc/apt/sources.list.d/grafana.list
sudo apt-get update
sudo apt-get install grafana
    2. 启动 Grafana: 
      sudo systemctl daemon-reload
sudo systemctl enable grafana-server
sudo systemctl start grafana-server
    3. 配置 Grafana:
      • 访问 http://<管理节点IP>:3000。
      • 默认用户名/密码是 admin/admin，首次登录会要求你修改密码。
      • 添加数据源 (Data Source):
        • 点击左侧齿轮图标 -> "Data Sources" -> "Add data source"。
        • 选择 "Prometheus"。
        • 在 "HTTP" -> "URL" 字段中，输入 http://localhost:9090。
        • 其他保持默认，点击 "Save & Test"。如果显示绿色√，说明连接成功。
      • 导入仪表盘 (Import Dashboards): 这是最激动人心的部分！你不需要自己画图，社区有大量现成的优秀模板。
        • 导入GPU仪表盘:
          • 点击左侧加号图标 -> "Import"。
          • 在 "Import via grafana.com" 输入框中，输入 12239，然后点击 "Load"。这是NVIDIA官方推荐的DCGM仪表盘。
          • 在下一个页面，选择你刚刚创建的 Prometheus 数据源，然后点击 "Import"。
          • 大功告成！ 你现在应该能看到一个极其详细的仪表盘，显示了你集群里所有64张卡的利用率、显存、温度、功耗、NVLink流量等信息。你可以通过下拉菜单选择查看哪个节点。
        • 导入Node Exporter仪表盘:
          • 重复导入步骤，这次输入 1860。这是一个非常流行的Node Exporter总览仪表盘。
          • 导入后，你就可以看到所有节点的CPU、内存、磁盘和网络状况。

非常好！这个问题直击要害，是从“系统管理员”视角转换到“最终用户”视角的关键。一个集群搭得再好，如果用户不知道如何高效、规范地使用，那它的价值也无法完全发挥。

下面我将为你详细描绘一个多人共享此集群的完整工作流程，包括管理员的准备工作和用户的具体操作步骤。

第一部分：管理员的准备工作 (Admin's Checklist)

在你向用户开放集群之前，需要做好以下准备，为他们创造一个清晰、一致、隔离的环境。

1. 创建用户账户

这是第一步。你需要为每一位用户在所有节点上创建账户，并且必须保证同一个用户在所有节点上的用户名、UID (User ID) 和 GID (Group ID) 完全一致。这是Slurm和NFS能正确识别用户权限的基础。

操作示例（为用户 alice 创建账户）:

在管理节点上执行：

# 创建一个用户组，比如 researchers
sudo groupadd --gid 1001 researchers

# 创建用户 alice，指定UID和主组，并添加到 researchers 组
sudo useradd --uid 2001 --gid 1001 -g researchers -m -s /bin/bash alice
# -m: 创建家目录
# -s /bin/bash: 设置默认shell

记下 alice 的 UID (2001) 和 GID (1001)。然后，在所有其他7个计算节点上执行完全相同的命令，确保UID/GID不变。

强烈建议: 使用Ansible来自动化这个过程，确保一致性。

2. 配置家目录 (Home Directories)

用户的家目录必须位于共享存储上！这样，用户登录管理节点后，他们放在家目录里的代码、脚本等文件，在计算节点上也能被作业脚本访问到。

  • 推荐方案:

    1. 在你的NFS共享目录 /export/share 下创建一个 homes 目录: sudo mkdir /export/share/homes
    2. 修改 /etc/fstab，将NFS挂载点从 /share 改为 /home。或者创建一个新的挂载点。
    3. 当使用 useradd 创建用户时，使用 -d /home/alice 来指定家目录。

    这样，当alice登录后，她所在的 ~ (即 /home/alice) 目录就是网络共享的。

3. 建立数据存储规范 (Data Policy)

一个混乱的共享目录是灾难的开始。你需要建立并告知用户一套清晰的目录结构规范。

在你的NFS共享目录 /share (或你自定义的挂载点) 下创建如下结构:

  • /share/homes/: 存放所有用户的家目录。用于代码、配置文件、小型数据集。
  • /share/datasets/: 存放公共的大型数据集，如ImageNet, COCO等。这个目录最好由管理员统一管理，并设置为对普通用户只读，避免被误删或修改。
  • /share/scratch/<username>/: 提供给每个用户一个“草稿空间”。用于存放大型的实验输出、模型 checkpoints 等。可以告知用户这里的文件可能会被定期清理。

4. 提供环境管理工具

用户的代码依赖五花八门（不同版本的PyTorch、TensorFlow、CUDA），你不能在系统层面为他们一一安装。必须提供工具让他们自己管理自己的环境，互不干扰。

  • 首选方案：Conda/Mamba
    • 在系统层面安装Miniconda或Mambaforge。
    • 指导用户在自己的家目录中初始化并创建自己的Conda环境。这样所有环境配置都保存在用户的家目录里，天然隔离。
  • 高级方案：Singularity/Apptainer (取代Docker)
    • 在HPC集群中，直接使用Docker有安全风险（需要root权限）。Singularity/Apptainer是专为此类场景设计的容器技术，它允许普通用户运行容器而无需root权限。
    • 你可以预先构建一些包含常用AI框架的Singularity镜像，或者教会用户如何将自己的Docker镜像转换为Singularity镜像来运行。

5. 编写一份《用户入门指南》

准备一个简单的文档，包含以下信息，发给每一位新用户：

  • 集群登录地址 (ssh username@head-node.ip)。
  • 文件系统结构说明（/home, /datasets, /scratch 分别用来干什么）。
  • 如何使用Conda创建和管理环境。
  • Slurm作业提交的模板和常用命令 (sbatch, squeue, scancel)。
  • 集群使用规范（严禁在登录节点上直接跑计算任务！）。

第二部分：用户的工作流程 (User's Workflow)

假设新用户 alice 拿到了她的账户和《用户入门指南》，她想跑一个PyTorch训练任务，她的完整操作流程如下：

步骤1：登录和环境准备

  1. 登录管理节点:

    ssh alice@head-node.ip

    她现在位于自己的家目录 /home/alice。

  2. 准备代码:

    git clone https://github.com/some-repo/my-ai-project.git
cd my-ai-project

  3. 创建独立的Conda环境:

    # 创建一个名为 'pytorch_env' 的环境，指定python版本
conda create -n pytorch_env python=3.9 -y

# 激活环境
conda activate pytorch_env

# 在激活的环境中安装代码需要的库
# 假设你的集群CUDA版本是11.8
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
pip install -r requirements.txt

    现在，alice 有了一个完全属于她自己的、包含所有依赖的Python环境。

步骤2：编写Slurm作业脚本

alice 在她的项目目录 my-ai-project 下创建一个名为 run.slurm 的脚本文件。这是她与集群资源管理器Slurm对话的“申请表”。

run.slurm 文件内容:

#!/bin/bash

# --- Slurm 资源申请指令 ---
#SBATCH --job-name=alice-test-run          # 作业名称，方便自己识别
#SBATCH --partition=gpu_partition          # 提交到名为 gpu_partition 的分区
#SBATCH --nodes=1                          # 申请1个计算节点
#SBATCH --ntasks-per-node=1                # 每个节点上运行1个任务
#SBATCH --cpus-per-task=16                 # 为任务申请16个CPU核心
#SBATCH --mem=128G                         # 申请128GB内存

# !!! 核心：申请2张GPU !!!
#SBATCH --gres=gpu:2

# --- 作业执行的命令 ---

# 1. 打印作业信息，方便调试
echo "Job ID: $SLURM_JOB_ID"
echo "Job User: $SLURM_JOB_USER"
echo "Num Nodes: $SLURM_JOB_NUM_NODES"
echo "Node List: $SLURM_JOB_NODELIST"
echo "Submit Host: $SLURM_SUBMIT_HOST"
echo "GPU(s) allocated: $CUDA_VISIBLE_DEVICES"
echo "----------------------------------------------------"

# 2. 激活之前创建的Conda环境
# 找到你的conda.sh路径，通常在家目录的miniconda3/etc/profile.d/下
source /home/alice/miniconda3/etc/profile.d/conda.sh
conda activate pytorch_env

# 3. 切换到代码目录
cd /home/alice/my-ai-project

# 4. 运行你的Python训练脚本
# 你的python脚本会因为CUDA_VISIBLE_DEVICES环境变量，自动只使用被分配的2张GPU
python main_train.py --data_dir /share/datasets/some_data --batch_size 512

步骤3：提交并管理作业

  1. 提交作业:

    sbatch run.slurm

    终端会返回一个作业ID，例如 Submitted batch job 12345。

  2. 查看作业状态:

    # 查看自己所有作业的队列情况
squeue -u alice

# 输出可能像这样：
# JOBID PARTITION     NAME      USER ST       TIME  NODES NODELIST(REASON)
# 12345 gpu_parti alice-tes   alice PD       0:00      1 (Resources)  <-- PD表示排队中，等待资源
# 或者
# 12345 gpu_parti alice-tes   alice  R       5:30      1 compute-03   <-- R表示正在运行

  3. 查看实时输出: 作业的屏幕输出（print语句等）会被重定向到一个名为 slurm-12345.out 的文件里。alice 可以用 tail -f 来实时查看：

    tail -f slurm-12345.out

  4. 取消作业: 如果发现有问题，可以立即取消作业：

    scancel 12345

步骤4：获取结果

当作业运行结束后，alice 在 my-ai-project 目录下就能找到她的输出文件：

  • slurm-12345.out: 包含了所有的屏幕打印信息。
  • models/best_model.pth: 假如她的代码会保存模型。
  • logs/training_log.csv: 假如她的代码会记录日志。

因为这一切都发生在共享存储上，她可以在登录节点上直接访问这些文件，进行分析或下载到本地。

总结：给用户的黄金法则

这套流程的核心，是向用户灌输以下几条“黄金法则”：

  1. 只在登录节点做“轻”活：登录节点是公共客厅，只用来编辑代码、提交作业、管理文件。严禁直接在登录节点上运行 python train.py，这会占用所有人的共享资源，导致登录卡顿。
  2. 用 sbatch 提交一切“重”活：所有计算任务，无论大小，都必须通过 sbatch 脚本提交给Slurm。
  3. 资源按需申请：在 sbatch 脚本里，需要几张卡就申请几张（--gres=gpu:N），需要多少CPU就申请多少。精确申请可以减少排队时间，提高整个集群的利用率。
  4. 环境自我管理：使用Conda或Singularity管理自己的软件依赖，不要污染系统环境。

通过这套清晰的流程和规范，你的8台服务器就能高效、有序地被多位用户共享，每个人都能在自己的沙盒里工作，同时又能享受到整个集群强大的计算能力。

No comments to display

Back to top