开始使用

1. 使用 AI Inference Server 提供和推断
2. 使用关键指标验证 Red Hat AI Inference 服务器的好处

流程

1. 使用 pip list package 命令运行 Red Hat AI Inference Server 容器镜像，以查看所有已安装的 Python 软件包。例如：

   $ podman run --rm --entrypoint=/bin/bash \
     registry.redhat.io/rhaiis/vllm-cuda-rhel9:3.2.5 \
     -c "pip list"

2. 要查看有关特定软件包的详细信息，请运行带有 pip show <package_name> 的 Podman 命令。例如：

   $ podman run --rm --entrypoint=/bin/bash \
     registry.redhat.io/rhaiis/vllm-cuda-rhel9:3.2.5 \
     -c "pip show vllm"

   输出示例

   Name: vllm
   Version: v0.11.2

流程

1. 在服务器主机上打开一个终端，并登录到 registry.redhat.io ：

   $ podman login registry.redhat.io

2. 运行以下命令拉取相关的 NVIDIA CUDA 镜像：

   $ podman pull registry.redhat.io/rhaiis/vllm-cuda-rhel9:3.2.5

3. 如果您的系统启用了 SELinux，请将 SELinux 配置为允许设备访问：

   $ sudo setsebool -P container_use_devices 1

4. 创建卷并将其挂载到容器中。调整容器权限，以便容器可以使用它。

   $ mkdir -p rhaiis-cache

   $ chmod g+rwX rhaiis-cache

5. 创建或附加 HF_TOKEN Hugging Face 令牌到 private.env 文件。提供 private.env 文件。

   $ echo "export HF_TOKEN=<your_HF_token>" > private.env

   $ source private.env

6. 启动 AI Inference Server 容器镜像。

   1. 对于 NVIDIA CUDA 加速器，如果主机系统有多个 GPU 并使用 NVSwitch，则启动 NVIDIA Fabric Manager。要检测您的系统是否使用 NVSwitch，请首先检查 /proc/driver/nvidia-nvswitch/devices/ 中是否存在文件，然后启动 NVIDIA Fabric Manager。启动 NVIDIA Fabric Manager 需要 root 特权。

      $ ls /proc/driver/nvidia-nvswitch/devices/

      输出示例

      0000:0c:09.0  0000:0c:0a.0  0000:0c:0b.0  0000:0c:0c.0  0000:0c:0d.0  0000:0c:0e.0

      $ systemctl start nvidia-fabricmanager

      重要

      只有在具有多个 GPU 的系统上需要使用 NVSwitch 的系统才需要 NVIDIA Fabric Manager。如需更多信息，请参阅 NVIDIA 服务器架构。

      1. 运行以下命令，检查 Red Hat AI Inference Server 容器是否可以访问主机上的 NVIDIA GPU：

         $ podman run --rm -it \
         --security-opt=label=disable \
         --device nvidia.com/gpu=all \
         nvcr.io/nvidia/cuda:12.4.1-base-ubi9 \
         nvidia-smi

         输出示例

         +-----------------------------------------------------------------------------------------+
         | NVIDIA-SMI 570.124.06             Driver Version: 570.124.06     CUDA Version: 12.8     |
         |-----------------------------------------+------------------------+----------------------+
         | GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
         | Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
         |                                         |                        |               MIG M. |
         |=========================================+========================+======================|
         |   0  NVIDIA A100-SXM4-80GB          Off |   00000000:08:01.0 Off |                    0 |
         | N/A   32C    P0             64W /  400W |       1MiB /  81920MiB |      0%      Default |
         |                                         |                        |             Disabled |
         +-----------------------------------------+------------------------+----------------------+
         |   1  NVIDIA A100-SXM4-80GB          Off |   00000000:08:02.0 Off |                    0 |
         | N/A   29C    P0             63W /  400W |       1MiB /  81920MiB |      0%      Default |
         |                                         |                        |             Disabled |
         +-----------------------------------------+------------------------+----------------------+
         
         +-----------------------------------------------------------------------------------------+
         | Processes:                                                                              |
         |  GPU   GI   CI              PID   Type   Process name                        GPU Memory |
         |        ID   ID                                                               Usage      |
         |=========================================================================================|
         |  No running processes found                                                             |
         +-----------------------------------------------------------------------------------------+

      2. 启动容器。

         $ podman run --rm -it \
         --device nvidia.com/gpu=all \
         --security-opt=label=disable \ 

         1

         
         --shm-size=4g -p 8000:8000 \ 

         2

         
         --userns=keep-id:uid=1001 \ 

         3

         
         --env "HUGGING_FACE_HUB_TOKEN=$HF_TOKEN" \ 

         4

         
         --env "HF_HUB_OFFLINE=0" \
         -v ./rhaiis-cache:/opt/app-root/src/.cache:Z \ 

         5

         
         registry.redhat.io/rhaiis/vllm-cuda-rhel9:3.2.5 \
         --model RedHatAI/Llama-3.2-1B-Instruct-FP8 \
         --tensor-parallel-size 2 

         6

         1

         启用 SELinux 的系统需要。--security-opt=label=disable 防止 SELinux 重新标记卷挂载中的文件。如果您选择不使用此参数，您的容器可能无法成功运行。

         2

         如果您在共享内存时遇到问题，请将 -shm-size 增加到 8GB。

         3

         将主机 UID 映射到容器中 vLLM 进程的有效 UID。您也可以 pass-- user=0，但这比 the- userns 选项不太安全。set-- user=0 在容器内以 root 身份运行 vLLM。

         4

         使用 Hugging Face API 访问令牌设置和导出 HF_TOKEN

         5

         启用 SELinux 的系统需要。在 Debian 或 Ubuntu 操作系统上，或者在不使用 SELinux 的情况下使用 Docker 时，:Z 后缀不可用。

         6

         在多个 GPU 上运行 AI Inference Server 容器时，set -tensor-parallel-size 与 GPU 的数量匹配。

7. 在终端中的单独标签页中，使用 API 向模型发出请求。

   curl -X POST -H "Content-Type: application/json" -d '{
       "prompt": "What is the capital of France?",
       "max_tokens": 50
   }' http://<your_server_ip>:8000/v1/completions | jq

   输出示例

   {
       "id": "cmpl-b84aeda1d5a4485c9cb9ed4a13072fca",
       "object": "text_completion",
       "created": 1746555421,
       "model": "RedHatAI/Llama-3.2-1B-Instruct-FP8",
       "choices": [
           {
               "index": 0,
               "text": " Paris.\nThe capital of France is Paris.",
               "logprobs": null,
               "finish_reason": "stop",
               "stop_reason": null,
               "prompt_logprobs": null
           }
       ],
       "usage": {
           "prompt_tokens": 8,
           "total_tokens": 18,
           "completion_tokens": 10,
           "prompt_tokens_details": null
       }
   }

流程

1. 在服务器主机上打开一个终端，并登录到 registry.redhat.io ：

   $ podman login registry.redhat.io

2. 运行以下命令拉取 AMD ROCm 镜像：

   $ podman pull registry.redhat.io/rhaiis/vllm-rocm-rhel9:3.2.5

3. 如果您的系统启用了 SELinux，请将 SELinux 配置为允许设备访问：

   $ sudo setsebool -P container_use_devices 1

4. 创建卷并将其挂载到容器中。调整容器权限，以便容器可以使用它。

   $ mkdir -p rhaiis-cache

   $ chmod g+rwX rhaiis-cache

5. 创建或附加 HF_TOKEN Hugging Face 令牌到 private.env 文件。提供 private.env 文件。

   $ echo "export HF_TOKEN=<your_HF_token>" > private.env

   $ source private.env

6. 启动 AI Inference Server 容器镜像。

   1. 对于 AMD ROCm 加速器：

      1. 使用 amd-smi static -a 验证容器是否可以访问主机系统 GPU：

         $ podman run -ti --rm --pull=newer \
         --security-opt=label=disable \
         --device=/dev/kfd --device=/dev/dri \
         --group-add keep-groups \ 

         1

         
         --entrypoint="" \
         registry.redhat.io/rhaiis/vllm-rocm-rhel9:3.2.5 \
         amd-smi static -a

         1

         您必须属于 AMD 系统上的视频和呈现组才能使用 GPU。要访问 GPU，您必须将 --group-add=keep-groups 补充组选项传给容器。

      2. 启动容器：

         podman run --rm -it \
         --device /dev/kfd --device /dev/dri \
         --security-opt=label=disable \ 

         1

         
         --group-add keep-groups \
         --shm-size=4GB -p 8000:8000 \ 

         2

         
         --env "HUGGING_FACE_HUB_TOKEN=$HF_TOKEN" \
         --env "HF_HUB_OFFLINE=0" \
         -v ./rhaiis-cache:/opt/app-root/src/.cache \
         registry.redhat.io/rhaiis/vllm-rocm-rhel9:3.2.5 \
         --model RedHatAI/Llama-3.2-1B-Instruct-FP8 \
         --tensor-parallel-size 2 

         3

         1

         --security-opt=label=disable 防止 SELinux 重新标记卷挂载中的文件。如果您选择不使用此参数，您的容器可能无法成功运行。

         2

         如果您在共享内存时遇到问题，请将 -shm-size 增加到 8GB。

         3

         在多个 GPU 上运行 AI Inference Server 容器时，set -tensor-parallel-size 与 GPU 的数量匹配。

7. 在终端中的单独标签页中，使用 API 向模型发出请求。

   curl -X POST -H "Content-Type: application/json" -d '{
       "prompt": "What is the capital of France?",
       "max_tokens": 50
   }' http://<your_server_ip>:8000/v1/completions | jq

   输出示例

   {
       "id": "cmpl-b84aeda1d5a4485c9cb9ed4a13072fca",
       "object": "text_completion",
       "created": 1746555421,
       "model": "RedHatAI/Llama-3.2-1B-Instruct-FP8",
       "choices": [
           {
               "index": 0,
               "text": " Paris.\nThe capital of France is Paris.",
               "logprobs": null,
               "finish_reason": "stop",
               "stop_reason": null,
               "prompt_logprobs": null
           }
       ],
       "usage": {
           "prompt_tokens": 8,
           "total_tokens": 18,
           "completion_tokens": 10,
           "prompt_tokens_details": null
       }
   }

流程

1. 在 TPU 服务器主机上打开一个终端，并登录到 registry.redhat.io ：

   $ podman login registry.redhat.io

2. 运行以下命令拉取 Red Hat AI Inference Server 镜像：

   $ podman pull registry.redhat.io/rhaiis/vllm-tpu-rhel9:3.2.5

3. 可选：验证主机中是否有 TPU。

   1. 在 Red Hat AI Inference Server 容器中打开 shell 提示符。运行以下命令:

      $ podman run -it --net=host --privileged -e PJRT_DEVICE=TPU --rm --entrypoint /bin/bash registry.redhat.io/rhaiis/vllm-tpu-rhel9:3.2.5

   2. 通过在容器 shell 提示符中运行以下 Python 代码来验证系统 TPU 访问和基本操作：

      $ python3 -c "
      import torch
      import torch_xla
      try:
          device = torch_xla.device()
          print(f'')
          print(f'XLA device available: {device}')
          x = torch.randn(3, 3).to(device)
          y = torch.randn(3, 3).to(device)
          z = torch.matmul(x, y)
          import torch_xla.core.xla_model as xm
          torch_xla.sync()
          print(f'Matrix multiplication successful')
          print(f'Result tensor shape: {z.shape}')
          print(f'Result tensor device: {z.device}')
          print(f'Result tensor: {z.data}')
          print('TPU is operational.')
      except Exception as e:
          print(f'TPU test failed: {e}')
          print('Try restarting the container to clear TPU locks')
      "

      输出示例

      XLA device available: xla:0
      Matrix multiplication successful
      Result tensor shape: torch.Size([3, 3])
      Result tensor device: xla:0
      Result tensor: tensor([[-1.8161,  1.6359, -3.1301],
              [-1.2205,  0.8985, -1.4422],
              [ 0.0588,  0.7693, -1.5683]], device='xla:0')
      TPU is operational.

   3. 退出 shell 提示符。

      $ exit

4. 创建卷并将其挂载到容器中。调整容器权限，以便容器可以使用它。

   $ mkdir ./.cache/rhaiis

   $ chmod g+rwX ./.cache/rhaiis

5. 将 HF_TOKEN Hugging Face 令牌添加到 private.env 文件中。

   $ echo "export HF_TOKEN=<huggingface_token>" > private.env

6. 将 HF_HOME 变量附加到 private.env 文件。

   $ echo "export HF_HOME=./.cache/rhaiis" >> private.env

   提供 private.env 文件。

   $ source private.env

7. 启动 AI Inference Server 容器镜像：

   podman run --rm -it \
     --name vllm-tpu \
     --network=host \
     --privileged \
     --shm-size=4g \
     --device=/dev/vfio/vfio \
     --device=/dev/vfio/0 \
     -e PJRT_DEVICE=TPU \
     -e HF_HUB_OFFLINE=0 \
     -v ./.cache/rhaiis:/opt/app-root/src/.cache \
     registry.redhat.io/rhaiis/vllm-tpu-rhel9:3.2.5 \
     --model Qwen/Qwen2.5-1.5B-Instruct \
     --tensor-parallel-size 1 \ 

   1

   
     --max-model-len=256 \ 

   2

   
     --host=0.0.0.0 \
     --port=8000

   1

   set- tensor-parallel-size，以匹配 TPU 的数量。

   2

   为了获得最佳性能，请将 max-model-len 参数设置为 low，因为您的工作负载允许。

流程

1. 在服务器主机上打开一个终端，并登录到 registry.redhat.io ：

   $ podman login registry.redhat.io

2. 运行 servicereport 命令来验证 IBM Spyre 硬件：

   $ servicereport -r -p spyre

   输出示例

   servicereport 2.2.5
   
   Spyre configuration checks                          PASS
   
     VFIO Driver configuration                         PASS
     User memlock configuration                        PASS
     sos config                                        PASS
     sos package                                       PASS
     VFIO udev rules configuration                     PASS
     User group configuration                          PASS
     VFIO device permission                            PASS
     VFIO kernel module loaded                         PASS
     VFIO module dep configuration                     PASS
   
   Memlock limit is set for the sentient group.
   Spyre user must be in the sentient group.
   To add run below command:
           sudo usermod -aG sentient <user>
           Example:
           sudo usermod -aG sentient abc
           Re-login as <user>.

3. 运行以下命令拉取 Red Hat AI Inference Server 镜像：

   $ podman pull registry.redhat.io/rhaiis/vllm-spyre:3.2.5

4. 如果您的系统启用了 SELinux，请将 SELinux 配置为允许设备访问：

   $ sudo setsebool -P container_use_devices 1

5. 使用 lspci -v 验证容器是否可以访问主机系统 IBM Spyre AI Accelerators：

   $ podman run -it --rm --pull=newer \
       --security-opt=label=disable \
       --device=/dev/vfio \
       --group-add keep-groups \
       --entrypoint="lspci" \
       registry.redhat.io/rhaiis/vllm-spyre:3.2.5

   输出示例

   0381:50:00.0 Processing accelerators: IBM Spyre Accelerator (rev 02)
   0382:60:00.0 Processing accelerators: IBM Spyre Accelerator (rev 02)
   0383:70:00.0 Processing accelerators: IBM Spyre Accelerator (rev 02)
   0384:80:00.0 Processing accelerators: IBM Spyre Accelerator (rev 02)

6. 创建卷以挂载到容器并调整容器权限，以便容器可以使用它。

   $ mkdir -p ~/models && chmod g+rwX ~/models

7. 将 granite-3.3-8b-instruct 模型下载到 models/ 文件夹中。如需更多信息，请参阅 下载模型。

8. 为 VLLM_AIU_PCIE_IDS 变量收集 Spyre ID：

   $ lspci

   输出示例

   0381:50:00.0 Processing accelerators: IBM Spyre Accelerator (rev 02)
   0382:60:00.0 Processing accelerators: IBM Spyre Accelerator (rev 02)
   0383:70:00.0 Processing accelerators: IBM Spyre Accelerator (rev 02)
   0384:80:00.0 Processing accelerators: IBM Spyre Accelerator (rev 02)

9. 设置 SPYRE_IDS 变量：

   $ SPYRE_IDS="0381:50:00.0 0382:60:00.0 0383:70:00.0 0384:80:00.0"

10. 启动 AI Inference Server 容器。例如，部署为实体提取服务配置的 granite-3.3-8b-instruct 模型：

    podman run \
        --device=/dev/vfio \
        -v $HOME/models:/models \
        -e AIU_PCIE_IDS="${SPYRE_IDS}" \
        -e VLLM_SPYRE_USE_CB=1 \
        --pids-limit 0 \
        --userns=keep-id \
        --group-add=keep-groups \
        --memory 200G \
        --shm-size 64G \
        -p 8000:8000 \
        registry.redhat.io/rhaiis/vllm-spyre:3.2.5 \
            --model /models/granite-3.3-8b-instruct \
            -tp 4 \
            --max-model-len 32768 \
            --max-num-seqs 32

流程

1. 在服务器主机上打开一个终端，并登录到 registry.redhat.io ：

   $ podman login registry.redhat.io

2. 运行以下命令拉取 Red Hat AI Inference Server 镜像：

   $ podman pull registry.redhat.io/rhaiis/vllm-spyre:3.2.5

3. 如果您的系统启用了 SELinux，请将 SELinux 配置为允许设备访问：

   $ sudo setsebool -P container_use_devices 1

4. 使用 lspci -v 验证容器是否可以访问主机系统 IBM Spyre AI Accelerators：

   $ podman run -it --rm --pull=newer \
       --security-opt=label=disable \
       --device=/dev/vfio \
       --group-add keep-groups \
       --entrypoint="lspci" \
       registry.redhat.io/rhaiis/vllm-spyre:3.2.5

   输出示例

   0381:50:00.0 Processing accelerators: IBM Spyre Accelerator (rev 02)
   0382:60:00.0 Processing accelerators: IBM Spyre Accelerator (rev 02)
   0383:70:00.0 Processing accelerators: IBM Spyre Accelerator (rev 02)
   0384:80:00.0 Processing accelerators: IBM Spyre Accelerator (rev 02)

5. 创建卷以挂载到容器并调整容器权限，以便容器可以使用它。

   $ mkdir -p ~/models && chmod g+rwX ~/models

6. 将 granite-3.3-8b-instruct 模型下载到 models/ 文件夹中。如需更多信息，请参阅 下载模型。

7. 为可用的 Spyre 设备收集 IOMMU 组 ID：

   $ lspci

   输出示例

   0000:00:00.0 Processing accelerators: IBM Spyre Accelerator Virtual Function (rev 02)
   0001:00:00.0 Processing accelerators: IBM Spyre Accelerator Virtual Function (rev 02)
   0002:00:00.0 Processing accelerators: IBM Spyre Accelerator Virtual Function (rev ff)
   0003:00:00.0 Processing accelerators: IBM Spyre Accelerator Virtual Function (rev 02)

   每行都以 PCI 设备地址开头，例如 0000:00:00.0。

8. 使用 PCI 地址确定所需的 Spyre 卡的 IOMMU 组 ID，例如：

   $ readlink /sys/bus/pci/devices/<PCI_ADDRESS>/iommu_group

   输出示例

   ../../../kernel/iommu_groups/0

   IOMMU 组 ID (0)是 readlink 输出中末尾的数字。

   对每个必需的 Spyre 卡重复此操作。

9. 使用 readlink 输出为所需的 Spyre 卡设置 IOMMU_GROUP_ID 变量。例如：

   IOMMU_GROUP_ID0=0
   IOMMU_GROUP_ID1=1
   IOMMU_GROUP_ID2=2
   IOMMU_GROUP_ID3=3

10. 启动 AI Inference Server 容器，传递所需的 Spyre 设备的 IOMMU 组 ID 变量。例如，部署为实体提取在 4 个 Spyre 设备中提取的 granite-3.3-8b-instruct 模型：

    podman run \
      --device /dev/vfio/vfio \
      --device /dev/vfio/${IOMMU_GROUP_ID0}:/dev/vfio/${IOMMU_GROUP_ID0}  \
      --device /dev/vfio/${IOMMU_GROUP_ID1}:/dev/vfio/${IOMMU_GROUP_ID1}  \
      --device /dev/vfio/${IOMMU_GROUP_ID2}:/dev/vfio/${IOMMU_GROUP_ID2}  \
      --device /dev/vfio/${IOMMU_GROUP_ID3}:/dev/vfio/${IOMMU_GROUP_ID3}  \
      -v $HOME/models:/models:Z \
      --pids-limit 0 \
      --userns=keep-id \
      --group-add=keep-groups \
      --memory 200G \
      --shm-size 64G \
      -p 8000:8000 \
      registry.redhat.io/rhaiis/vllm-spyre:3.2.5 \
        --model /models/granite-3.3-8b-instruct \
        -tp 4 \
        --max-model-len 32768 \
        --max-num-seqs 32

流程

1. 在您的主机系统上，启动一个 AI Inference Server 容器并提供模型。

   $ podman run --rm -it --device nvidia.com/gpu=all \
   --shm-size=4GB -p 8000:8000 \
   --env "HUGGING_FACE_HUB_TOKEN=$HF_TOKEN" \
   --env "HF_HUB_OFFLINE=0" \
   -v ./rhaiis-cache:/opt/app-root/src/.cache \
   --security-opt=label=disable \
   registry.redhat.io/rhaiis/vllm-cuda-rhel9:3.2.5 \
   --model RedHatAI/Llama-3.2-1B-Instruct-FP8

2. 在一个单独的终端选项卡中，安装基准工具依赖项。

   $ pip install vllm pandas datasets

3. 克隆 vLLM Git 存储库 ：

   $ git clone https://github.com/vllm-project/vllm.git

4. 运行 ./vllm/benchmarks/benchmark_serving.py 脚本。

   $ python vllm/benchmarks/benchmark_serving.py --backend vllm --model RedHatAI/Llama-3.2-1B-Instruct-FP8 --num-prompts 100 --dataset-name random  --random-input 1024 --random-output 512 --port 8000

流程

1. 打开终端并登录到 registry.redhat.io ：

   $ podman login registry.redhat.io

2. 为已安装的 AI 加速器拉取特定的 Red Hat AI Inference Server 容器镜像。例如，要拉取 Google Cloud TPU 的 Red Hat AI Inference Server 容器，请运行以下命令：

   $ podman pull registry.redhat.io/rhaiis/vllm-tpu-rhel9:3.2.5

3. 在容器中运行 collect 环境脚本：

   $ podman run --rm -it \
     --name vllm-tpu \
     --network=host \
     --privileged \
     --device=/dev/vfio/vfio \
     --device=/dev/vfio/0 \
     -e PJRT_DEVICE=TPU \
     -e HF_HUB_OFFLINE=0 \
     -v ./.cache/rhaiis:/opt/app-root/src/.cache:Z \
     --entrypoint vllm collect-env \
     registry.redhat.io/rhaiis/vllm-tpu-rhel9:3.2.5