Elastic High Performance Computing：使用標準slurm叢集調度容器作業

步驟一：建立叢集

1. 建立一個標準版SLURM叢集。

   本文使用的叢集配置樣本如下，未提及的參數請根據需要填寫。

   	配置項	配置
   叢集配置	系列	標準版
   	部署模式	公用雲叢集
   	叢集類型	SLURM
   	管理節點	執行個體規格：採用ecs.r7.xlarge執行個體規格，該規格配置為4 vCPU，32 GiB記憶體。 鏡像：centos_7_6_x64_20G_alibase_20211130.vhd
   計算節點與隊列	隊列節點數	初始節點1。
   	節點間互聯	VPC網路
   	執行個體規格組	執行個體規格：採用ecs.gn7i-c56g1.14xlarge執行個體規格，該規格配置為56 vCPU、346 GiB記憶體。 重要 需使用支援GPU的執行個體規格。更多內容，請參見執行個體規格類型系列。 鏡像：centos_7_6_x64_20G_alibase_20211130.vhd
   共用檔案儲存體	/home 叢集掛載目錄	預設情況下，管理節點的/home和/opt將掛載檔案系統，作為共用儲存目錄。
   	/opt 叢集掛載目錄
   軟體與服務元件	待安裝軟體	選擇docker。
   	可安裝服務元件	登入節點： 執行個體規格：採用ecs.r7.xlarge執行個體規格，該規格配置為4 vCPU，32 GiB記憶體。 鏡像：centos_7_6_x64_20G_alibase_20211130.vhd。

2. 建立一個叢集使用者。

   本文中以usertest使用者為例。

步驟二：搭建基礎軟體環境

1. 為計算節點綁定Elastic IP Address。具體操作，請參見Elastic IP Address。

2. 遠端連線計算節點。

3. 下載並安裝CUDA。

   1. 下載CUDA安裝包。

      cd /opt
      wget https://developer.download.nvidia.com/compute/cuda/12.4.1/local_installers/cuda_12.4.1_550.54.15_linux.run

   2. 安裝CUDA。

      yum install -y git
      sh /opt/cuda_12.4.1_550.54.15_linux.run

      顯示如下圖所示時，說明CUDA已安裝。

      

   3. 配置環境變數。

      echo 'export PATH=/usr/local/cuda-12.4/bin:$PATH' >> ~/.bashrc
      echo 'export LD_LIBRARY_PATH=/usr/local/cuda-12.4/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
      
      source ~/.bashrc

   4. 查看NVIDIA CUDA工具包和GPU驅動的安裝狀態及版本資訊。

      # NVIDIA CUDA編譯驅動程式的版本資訊
      nvcc --version
      
      # GPU的詳細狀態資訊
      nvidia-smi

      顯示如下圖所示時，說明CUDA和GPU驅動正常。

      

4. 安裝並配置 NVIDIA Container Toolkit。

   distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
   curl -s -L https://nvidia.github.io/libnvidia-container/stable/rpm/nvidia-container-toolkit.repo | sudo tee /etc/yum.repos.d/nvidia-container-toolkit.repo
   sudo yum install -y nvidia-container-toolkit
   sudo systemctl restart docker

5. 下載並安裝Singularity。

   Singularity是一個容器化工具，它允許在不改變使用者環境的情況下運行容器，常用於HPC環境。

   cd /opt
   wget https://public-ehs.oss-cn-hangzhou.aliyuncs.com/softwares/packages/CentOS_7.2_64/singularity-3.8.3-1.el7.x86_64.rpm
   yum install -y /opt/singularity-3.8.3-1.el7.x86_64.rpm

6. 建立作業依賴資料。

   1. 拉取PyTorch容器鏡像。

      docker pull ac2-registry.cn-hangzhou.cr.aliyuncs.com/ac2/pytorch:2.4.0-cuda12.1.1-py310-alinux3.2104

   2. 使用usertest 使用者，建立main.py檔案 。

      vim /home/usertest/main.py

   3. main.py檔案指令碼內容如下。

      # -*- coding: utf-8 -*-
      
      import torch
      import torchvision
      import torchvision.transforms as transforms
      from torch import nn
      from torch.utils.data import DataLoader
      from torch.optim import SGD
      
      class SimpleNet(nn.Module):
          def __init__(self):
              super(SimpleNet, self).__init__()
              self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
              self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
              self.fc1 = nn.Linear(64 * 8 * 8, 128)
              self.fc2 = nn.Linear(128, 10)
              self.pool = nn.MaxPool2d(2, 2)
              self.relu = nn.ReLU()
              self.dropout = nn.Dropout(0.5)
      
          def forward(self, x):
              x = self.pool(self.relu(self.conv1(x)))
              x = self.pool(self.relu(self.conv2(x)))
              x = x.view(-1, 64 * 8 * 8)
              x = self.relu(self.fc1(x))
              x = self.dropout(x)
              x = self.fc2(x)
              return x
      
      device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
      print(f"Using device: {device}")
      
      transform = transforms.Compose([
          transforms.ToTensor(),
          transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
      ])
      
      train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
      test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
      
      train_loader = DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
      test_loader = DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)
      
      model = SimpleNet().to(device)
      criterion = nn.CrossEntropyLoss()
      optimizer = SGD(model.parameters(), lr=0.001, momentum=0.9)
      
      num_epochs = 10
      for epoch in range(num_epochs):
          model.train()
          running_loss = 0.0
          for i, data in enumerate(train_loader, 0):
              inputs, labels = data
              inputs, labels = inputs.to(device), labels.to(device)
      
              optimizer.zero_grad()
              outputs = model(inputs)
              loss = criterion(outputs, labels)
              loss.backward()
              optimizer.step()
      
              running_loss += loss.item()
              if i % 100 == 99: 
                  print(f"[{epoch + 1}, {i + 1}] loss: {running_loss / 100:.3f}")
                  running_loss = 0.0
      
          model.eval()
          correct = 0
          total = 0
          with torch.no_grad():
              for data in test_loader:
                  images, labels = data
                  images, labels = images.to(device), labels.to(device)
                  outputs = model(images)
                  _, predicted = torch.max(outputs.data, 1)
                  total += labels.size(0)
                  correct += (predicted == labels).sum().item()
      
          print(f"Accuracy on test set: {100 * correct / total:.2f}%")
      
      print("Training finished.")

步驟三：調度作業

#!/bin/bash
#SBATCH --job-name=your_job_name
#SBATCH --output=your_output
#SBATCH --nodes=1
#SBATCH --gres=gpu:1
#SBATCH --ntasks=2

# args
iamges="your_image"
run_cmd="your_command"
work_dir="your_workdir"
share_dir="/ehpcdata/:/mnt"
devices="device=$CUDA_VISIBLE_DEVICES"

# cleanup docker handle
function cleanup {
    echo "Caught signal, stopping Docker container: " $SLURM_JOB_NAME
    docker ps -q --filter label=$SLURM_JOB_NAME | xargs -r docker stop
    docker ps -qa --filter label=$SLURM_JOB_NAME | xargs -r docker rm
}
trap cleanup SIGINT SIGTERM

# start docker
docker pull $iamges
srun docker run \
  --label $SLURM_JOB_NAME \
  --rm --net=host \
  --gpus '"'$devices'"' \
  -v $share_dir \
  $iamges \
  /bin/bash -c "$run_cmd" &

# wait to complete
wait
cleanup

#!/bin/bash
#SBATCH --job-name=my_job_name
#SBATCH --output=output.log
#SBATCH --nodes=1
#SBATCH --gres=gpu:1
#SBATCH --ntasks=2

# args
image=your_image.sif
run_cmd="your cmd"
share_dir="/ehpcdata/:/mnt"

singularity exec --nv --bind $share_dir $image $run_cmd