
# 从vLLM-Ascend开源社区获取模型部署在ModelArts推理平台
通过vllm-ascend推理框架结合ModelArts推理平台的在线服务部署能力，实现开源大模型在昇腾NPU环境下的快速部署与推理，适用于GLM、Qwen、DeepSeek等开源大语言模型的推理部署场景。
![](https://support.huaweicloud.com/bestpractice-modelarts/public_sys-resources/note_3.0-zh-cn.png)
本部署指导方案基于vLLM-Ascend开源社区提供的模型，仅适用于功能验证、原型测试等场景，鉴于生产环境对高可用、安全合规、可观测性及运维管控的严苛要求，请勿直接将本方案用于业务生产环境。本案例中提到的模型能力和性能等取决于开源社区提供的能力。
#### 应用场景
当您需要将HuggingFace、ModelScope等开源社区的大语言模型部署到ModelArts推理平台的昇腾NPU环境时，面临以下挑战：模型权重体积大，推理框架需适配昇腾CANN算子，多机多卡部署需配置张量并行和数据并行参数，健康检查配置不当导致服务状态与实际不一致。通过vllm-ascend推理框架结合ModelArts在线服务部署能力，可一站式完成模型获取、镜像准备、脚本配置和服务部署，降低开源大模型在昇腾环境的部署门槛。
典型应用场景：
- 昇腾NPU大模型推理：将GLM、Qwen、DeepSeek等开源大语言模型部署在昇腾设备上，提供文本生成、对话问答能力。
- 多机多卡并行推理：通过张量并行（TP）和数据并行（DP）策略，将大模型拆分到多台NPU设备上部署，突破单卡显存限制。
- 量化模型推理：部署W8A8等量化模型，降低显存占用和推理延迟，提升吞吐量。
- 通用模型推理服务化：将任意vllm-ascend支持的开源模型封装为OpenAI兼容API接口，供业务系统调用。
 
#### 方案流程
从开源社区获取模型部署到ModelArts推理平台的整体流程如下：
1. 模型权重准备：从ModelScope或HuggingFace下载模型权重，上传至OBS桶。
2. 部署镜像准备：从Quay.io下载vllm-ascend镜像，推送至SWR镜像仓库。
3. 启动脚本准备：根据模型适配文档编写启动脚本和健康检查脚本，上传至OBS桶。
4. 推理服务部署：在ModelArts平台配置在线服务，挂载模型权重和启动脚本，启动推理服务。
5. 验证服务：通过API接口调用推理服务，验证可用性。
 
#### 约束限制
- 模型必须在vllm-ascend官方支持列表（[模型列表](https://docs.vllm.ai/projects/ascend/zh-cn/latest/tutorials/models/index.html)）中，否则需自行验证适配。
- 多机部署时需确保网络互通，HCCL通信依赖节点间网络。
 
#### 资源和成本规划
[表1]列举了本文案例使用的资源及成本规划。
 表1资源和成本规划 
| 资源             | 资源说明                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 数量 | 费用说明                  |
|:---|:---|:---|:---|
| ModelArts专属资源池 | 部署在线服务，需配备NPU资源。 本案例以GLM-5.2-W8A8双机部署为例，使用如下计算资源： - 资源池类型：物理资源池  - 实例规格类型：NPU  - 实例规格：8 \* ascend-snt9b（A2）  - 实例数量：2   | 1  | 按需计费，费用取决于NPU规格和使用时长。 |
| 对象存储服务OBS      | 存储模型权重、启动脚本和健康检查脚本。"存储类别"为"标准存储"。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 1  | 按存储量和请求次数计费。          |
| 容器镜像服务SWR      | 托管vllm-ascend推理镜像。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 1  | 按镜像存储量和流量计费。          |
| 弹性云服务器ECS      | 用于镜像加载和推送至SWR。 - 如果镜像制作过程中涉及与Github、HuggingFace等网站交互，建议购买中国-香港站的ECS，避免因网络代理问题导致镜像制作失败。  - "CPU架构"选择"鲲鹏计算"，"镜像"选择"EulerOS"，并绑定弹性公网IP。  - 要求可用空间≥50GB。                                                                                                                                                                                                           | 1  | 节点规格和使用时长计费。          |
   
#### 准备工作
在开始部署前，需完成以下准备工作：
- 已开通ModelArts、OBS、SWR服务。
- 已创建ModelArts专属资源池，配备Snt9b规格的NPU资源。
- 已创建可用的OBS桶和SWR组织，且和ModelArts在同一区域。
- 已创建ECS服务器，请参见[快速购买和使用Linux ECS](https://support.huaweicloud.com/qs-ecs/ecs_01_0103.html)。
 
 #### 步骤一：下载模型权重并上传至OBS
1. 访问vllm-ascend模型适配说明列表，确认目标模型在支持列表中，并查看模型权重要求。 GLM-5.2-W8A8的适配说明文档：<https://docs.vllm.ai/projects/ascend/zh-cn/latest/tutorials/models/GLM5.2.html>
   
2. 从ModelScope或HuggingFace下载模型权重。 GLM-5.2-W8A8的模型权重从ModelScope下载：<https://www.modelscope.cn/models/Eco-Tech/GLM-5.2-w8a8/files>
   ![](https://support.huaweicloud.com/bestpractice-modelarts/public_sys-resources/caution_3.0-zh-cn.png)
   务必确认下载的模型权重文件内容完整，包含权重文件（.safetensors）、配置文件（config.json）和tokenizer文件。
   
3. 将下载的模型权重上传至OBS桶的models目录中。 模型权重文件的OBS路径规划：
   ```
   ├── <OBS桶>
   │   └── models
   │       └── <模型名>                    # 模型权重所在目录，部署时挂载到容器内
   ```
   ![](https://support.huaweicloud.com/bestpractice-modelarts/public_sys-resources/note_3.0-zh-cn.png)
   大模型权重文件上传至OBS耗时较长，百亿参数模型约20GB、千亿参数模型约200GB，上传时间取决于网络带宽。
   
 
 #### 步骤二：下载推理镜像并推送至SWR
从官方镜像仓库下载vllm-ascend镜像，通过ECS节点推送至SWR。
1. 根据vllm-ascend模型适配说明，确认目标模型所需的推理镜像。
   以GLM-5.2为例，A2系列使用的推理镜像名称是"quay.io/ascend/vllm-ascend:glm5.2"。
   
2. 远程登录ECS，检查ECS是否已经安装Docker。
   ```
   # 检查Docker是否安装
   docker -v
   ```
   如尚未安装，运行以下命令安装Docker。
   ```
   yum install -y docker-engine.aarch64 docker-engine-selinux.noarch docker-runc.aarch64
   ```
   
3. 在ECS使用Docker下载镜像。
   ```
   docker pull --platform linux/arm64 <推理镜像名称>
   ```
   推理镜像名称和[1]保持一致。
   示例：
   ```
   docker pull --platform linux/arm64 quay.io/ascend/vllm-ascend:glm5.2
   ```
   ![](https://support.huaweicloud.com/bestpractice-modelarts/public_sys-resources/caution_3.0-zh-cn.png)
   昇腾设备使用ARM架构镜像，下载时必须指定--platform linux/arm64，否则镜像架构不匹配将导致推理失败。
   下载成功会显示下载状态，如：
   ```
   Status: Downloaded newer image for quay.io/ascend/vllm-ascend:glm5.2
   ```
   故障处理：
   - 执行pull命令提示不支持--platform参数不可用，可以参考[FAQ：执行pull命令提示不支持--platform怎么办]解决。
   
   - 执行pull命令提示ECS无法连接quay.io，可以参考[FAQ：ECS网络无法访问镜像仓库导致pull超时怎么办]解决。
     
4. 登录SWR服务，选择"我的镜像"，单击右上角的"客户端上传"，在"客户端上传"对话框中单击"生成登录指令"，获取Docker的登录指令。
   登录指令示例：
   ```
   docker login -u <区域>@<账号AK> -p <临时Token> <镜像地址>
   ```
   详细操作指导请参考[容器引擎客户端推送镜像（推荐）](https://support.huaweicloud.com/usermanual-swr/swr_01_0011.html#section3)章节。
   
5. 在ECS输入获取的登录指令，登录Docker。 返回"Login Succeeded"表示登录成功。
   
6. 为推理镜像打标签。
   ```
   docker tag <推理镜像名称> <镜像地址>/<组织名称>/<镜像名称>:<版本名称>
   ```
   表2打标签的参数说明 
   | 参数     | 说明                                                   |
   |:---|:---|
   | 推理镜像名称 | 要推送到SWR的实际镜像版本，如"quay.io/ascend/vllm-ascend:glm5.2"。 |
   | 镜像地址   | SWR镜像地址，即登录指令末尾的域名。                                  |
   | 组织名称   | 准备工作中创建的SWR组织名称，如"modelarts"。                        |
   | 镜像名称   | 自定义镜像名称，可以和实际镜像名称一致，如"vllm-ascend"。                  |
   | 版本名称   | 自定义版本名称，可以和实际镜像的版本名称一致，如"glm5.2"。                    |
      
   示例：
   ```
   docker tag quay.io/ascend/vllm-ascend:glm5.2 swr.xxx.example.com/modelarts/vllm-ascend:glm5.2
   ```
   
7. 将打好标签的推理镜像推送至SWR。
   ```
   docker push <镜像地址>/<组织名称>/<镜像名称>:<版本名称>
   ```
   示例：
   ```
   docker push swr.xxx.example.com/modelarts/vllm-ascend:glm5.2
   ```
   push成功时会显示每层的推送进度和最终的digest摘要，如：
   ```
   glm5.2: digest: xxx:xxxxx size: xxxx
   ```
   
8. 在SWR控制台确认镜像是否上传成功。在"我的镜像 \> 自有镜像"，查看是否已有推送的镜像。
   图1查看镜像   
   ![](https://support.huaweicloud.com/bestpractice-modelarts/figure/zh-cn_image_0000002643161690.png) 
 
#### 步骤三：编写脚本并上传至OBS
1. 根据vllm-ascend模型适配说明，确认目标模型的启动命令要求。 GLM-5.2-W8A8的适配说明文档：<https://docs.vllm.ai/projects/ascend/zh-cn/latest/tutorials/models/GLM5.2.html>
   
2. 编写从全局rank表获取master IP的工具"get_master_ip.py"，用于多机PD部署时自动检测master/slave角色。单机部署时（即总共只有一个推理单元，DP=1）无需区分master/slave角色，不用提供该脚本。
   ```
   import json
   import os
   import time
   import sys
   GLOBAL_RANK_TABLE_ENV = 'GLOBAL_RANK_TABLE_FILE_PATH'
   def wait_and_get_completed_global_rank_table():
       global_rank_table_path = os.getenv(GLOBAL_RANK_TABLE_ENV)
       if not global_rank_table_path:
           print('read env "{}" failed'.format(GLOBAL_RANK_TABLE_ENV))
           return
       while True:
           try:
               rank_table = get_rank_table(global_rank_table_path)
               if rank_table is not None:
                   return rank_table
           except Exception as e:
               print(e)
           time.sleep(1)
   def get_rank_table(global_rank_table_path=None):
       if global_rank_table_path is None:
           global_rank_table_path = os.getenv(GLOBAL_RANK_TABLE_ENV)
       with open(global_rank_table_path, 'r') as file:
           buf = file.read()
       rank_table = json.loads(buf)
       if rank_table["status"] == "completed":
           return rank_table
       else:
           return None
   def get_master_ip():
       try:
           wait_and_get_completed_global_rank_table()
           global_rank_table_path = os.getenv(GLOBAL_RANK_TABLE_ENV)
           with open(global_rank_table_path, 'r') as file:
               buf = file.read()
           rank_table = json.loads(buf)
           master = rank_table['server_group_list'][0]['server_list'][0]
           return master['server_ip']
       except Exception as e:
           print(e)
   def get_dp_start_rank():
       try:
           wait_and_get_completed_global_rank_table()
           global_rank_table_path = os.getenv(GLOBAL_RANK_TABLE_ENV)
           pod_ip = os.getenv("POD_IP")
           if not pod_ip:
               print("read env POD_IP failed")
               return 0
           with open(global_rank_table_path, 'r') as file:
               buf = file.read()
           rank_table = json.loads(buf)
           rank = 0
           for group in rank_table.get('server_group_list', []):
               for server in group.get('server_list', []):
                   if server.get('server_ip') == pod_ip or server.get('server_id') == pod_ip or server.get('container_ip') == pod_ip:
                       return rank
                   rank += 1
           print(f"Warning: POD_IP {pod_ip} not found in rank table, fallback to rank 0")
           return 0
       except Exception as e:
           print(f"get_dp_start_rank error: {e}")
           return 0
   if __name__ == "__main__":
       if len(sys.argv) > 1 and sys.argv[1] == "--dp-rank":
           print(get_dp_start_rank())
       else:
           print(get_master_ip())
   ```
   
3. 编写模型启动脚本，脚本内容参考vllm-ascend模型适配说明文档的"部署"部分，下面提供了不同部署模式的脚本示例。
   - 多机PD部署：需要检测master/slave角色以"glm_5_2.sh"举例（本案例使用的模型启动脚本）。
     ```
     #!/bin/sh
     CUR_DIR=$(cd "$(dirname "$0")" && pwd)
     # ============ 模型特定参数 ============
     MODEL_PATH="/weight/"
     SERVED_MODEL_NAME="glm-52"
     PORT="7000"
     TENSOR_PARALLEL_SIZE=8
     DATA_PARALLEL_SIZE=2
     DATA_PARALLEL_SIZE_LOCAL=1
     MAX_MODEL_LEN=40000
     MAX_NUM_BATCHED_TOKENS=4096
     GPU_MEMORY_UTILIZATION=0.95
     MAX_NUM_SEQS=16
     QUANTIZATION="ascend"
     EXTRA_ARGS="--enable-expert-parallel \
       --safetensors-load-strategy 'prefetch' \
       --block-size 128 \
       --async-scheduling \
       --additional-config '{\"fuse_muls_add\": true, \"multistream_overlap_shared_expert\": true, \"ascend_compilation_config\": {\"enable_npugraph_ex\": true}}' \
       --compilation-config '{\"cudagraph_mode\": \"FULL_DECODE_ONLY\"}' \
       --speculative-config '{\"num_speculative_tokens\": 5, \"method\": \"deepseek_mtp\"}'"
     # 网络配置
     nic_name=$(ifconfig | grep -B1 "$POD_IP" | grep -o "^\w*")
     master_ip=$(PYTHONUNBUFFERED=1 python3 "$CUR_DIR"/get_master_ip.py)
     dp_start_rank=$(PYTHONUNBUFFERED=1 python3 "$CUR_DIR"/get_master_ip.py --dp-rank)
     echo "master ip:${master_ip}, local ip: ${POD_IP}, nic:${nic_name}, dp_rank:${dp_start_rank}"
     # 确定节点角色
     if [ "$POD_IP" = "$master_ip" ]; then
         echo "Current node is MASTER"
         slave_opts="--api-server-count 1"
     else
         echo "Current node is SLAVE"
         nohup python -m http.server 8080 > http_server.log 2>&1 &
         slave_opts="--headless"
     fi
     # 环境变量配置
     export HCCL_OP_EXPANSION_MODE="AIV"
     export HCCL_IF_IP=$POD_IP
     export GLOO_SOCKET_IFNAME=$nic_name
     export TP_SOCKET_IFNAME=$nic_name
     export HCCL_SOCKET_IFNAME=$nic_name
     export VLLM_RPC_TIMEOUT=360000
     export VLLM_EXECUTE_MODEL_TIMEOUT_SECONDS=3000
     export HCCL_EXEC_TIMEOUT=200
     export HCCL_CONNECT_TIMEOUT=120
     export OMP_PROC_BIND=false
     export OMP_NUM_THREADS=10
     export PYTORCH_NPU_ALLOC_CONF=expandable_segments:True
     export ACL_OP_INIT_MODE=1
     export TASK_QUEUE_ENABLE=1
     export CPU_AFFINITY_CONF=1
     export VLLM_ENGINE_READY_TIMEOUT_S=1200
     # 构建量化参数（可选，仅量化模型涉及）
     quant_opts=""
     if [ -n "$QUANTIZATION" ]; then
         quant_opts="--quantization ${QUANTIZATION}"
     fi
     # 启动服务
     vllm serve ${MODEL_PATH} \
       --host 0.0.0.0 \
       --port ${PORT} \
       --max_model_len ${MAX_MODEL_LEN} \
       --max-num-batched-tokens ${MAX_NUM_BATCHED_TOKENS} \
       --served-model-name ${SERVED_MODEL_NAME} \
       --seed 1024 \
       --gpu-memory-utilization ${GPU_MEMORY_UTILIZATION} \
       --max-num-seqs ${MAX_NUM_SEQS} \
       --data-parallel-size ${DATA_PARALLEL_SIZE} \
       --data-parallel-size-local ${DATA_PARALLEL_SIZE_LOCAL} \
       --data-parallel-start-rank ${dp_start_rank} \
       --data-parallel-address ${master_ip} \
       --data-parallel-rpc-port 13389 \
       --tensor-parallel-size ${TENSOR_PARALLEL_SIZE} \
       ${quant_opts} ${EXTRA_ARGS} \
       $slave_opts
     ```
     
   
   - 单机部署：无需区分master/slave角色，模型启动脚本更简洁。以为"minitron-8b-base.sh"举例。
     ```
     #!/bin/sh
     # ============ 模型特定参数 ============
     MODEL_PATH="/weight/"
     SERVED_MODEL_NAME="minitron-8b-base"
     PORT="8000"
     TENSOR_PARALLEL_SIZE=1
     MAX_MODEL_LEN=4096
     GPU_MEMORY_UTILIZATION=0.9
     EXTRA_ARGS="--enforce-eager"
     # 启动服务
     vllm serve ${MODEL_PATH} \
       --host 0.0.0.0 \
       --port ${PORT} \
       --max_model_len ${MAX_MODEL_LEN} \
       --served-model-name ${SERVED_MODEL_NAME} \
       --gpu-memory-utilization ${GPU_MEMORY_UTILIZATION} \
       --tensor-parallel-size ${TENSOR_PARALLEL_SIZE} \
       ${EXTRA_ARGS}
     ```
     
   
   
   表3启动脚本参数说明 
   | 变量名                      | 说明                                              | 取值示例                         |
   |:---|:---|:---|
   | MODEL_PATH               | 模型权重挂载路径，需与ModelArts平台的模型挂载路径一致。                | /weight/                     |
   | SERVED_MODEL_NAME        | 推理服务对外展示名，API调用时使用。建议和模型名称一致。                   | glm-52                       |
   | TENSOR_PARALLEL_SIZE     | 张量并行数，需与部署时每台推理单元使用的NPU卡数一致。                    | 8                            |
   | DATA_PARALLEL_SIZE       | 数据并行数，需与部署时使用的总实例数一致（总实例数=推理单元个数 × 每台推理单元的实例数）。 | 2                            |
   | DATA_PARALLEL_SIZE_LOCAL | 单节点数据并行数，需与部署时每台推理单元的实例数一致。                     | 1                            |
   | MAX_MODEL_LEN            | 最大上下文长度，根据vllm-ascend模型适配说明文档配置。                | 40000                        |
   | MAX_NUM_BATCHED_TOKENS   | 每批次最大token数，按需配置。                               | 4096                         |
   | GPU_MEMORY_UTILIZATION   | 显存使用占比，根据vllm-ascend模型适配说明文档配置。                 | 0.95                         |
   | MAX_NUM_SEQS             | 最大并发序列数，根据业务并发需求调整。                             | 16                           |
   | QUANTIZATION             | 量化方式，W8A8模型使用ascend；非量化模型可删除此变量。                | ascend                       |
   | EXTRA_ARGS               | 模型特定优化参数，含专家并行、投机解码、算子融合等，根据模型适配文档整块替换或删除。      | --enable-expert-parallel ... |
   | PORT                     | vllm推理服务监听端口，需与部署时容器端口一致。需确保端口不冲突。              | 7000                         |
      
   
4. 编写"check.sh"健康检查脚本。下面提供了不同部署模式的脚本示例，其中PORT要和模型启动脚本里的PORT保持一致。
   - 多机PD部署：需要调用get_master_ip.py获取master IP（本案例使用的健康检查脚本）。
     ```
     #!/bin/bash
     PROBE_TYPE=$1
     # 端口号必须和模型启动脚本一致
     PORT="7000"
     if [[ $PROBE_TYPE == "startup" ]]; then
         if pgrep -f "vllm serve" > /dev/null; then
         exit 0
         fi
         exit 1
     fi
     master_ip=$(PYTHONUNBUFFERED=1 python3 /code/get_master_ip.py)
     if [[ $PROBE_TYPE == "readiness" ]]; then
         HEALTH_URL="http://${master_ip}:{PORT}/health"
         status_code=$(curl -s -o /dev/null -w "%{http_code}" $HEALTH_URL)
         if [ "$status_code" -eq 200 ]; then
           exit 0
         else
           echo "readiness check failed" >&2
           exit 1
         fi
     fi
     if [[ $PROBE_TYPE == "liveness" ]]; then
         if pgrep -f "vllm serve" > /dev/null; then
         exit 0
         fi
         exit 1
     fi
     ```
     
   
   - 单机部署：无需区分master/slave角色，健康检查脚本更简洁。
     ```
     #!/bin/bash
     PROBE_TYPE=$1
     # 端口号必须和模型启动脚本一致
     PORT="8000"
     if [[ $PROBE_TYPE == "startup" ]]; then
         if pgrep -f "vllm serve" > /dev/null; then
         exit 0
         fi
         exit 1
     fi
     if [[ $PROBE_TYPE == "readiness" ]]; then
         HEALTH_URL="http://${POD_IP}:${PORT}/health"
         status_code=$(curl -s -o /dev/null -w "%{http_code}" $HEALTH_URL)
         if [ "$status_code" -eq 200 ]; then
           exit 0
         else
           echo "readiness check failed" >&2
           exit 1
         fi
     fi
     if [[ $PROBE_TYPE == "liveness" ]]; then
         if pgrep -f "vllm serve" > /dev/null; then
         exit 0
         fi
         exit 1
     fi
     ```
     
    
5. 将启动脚本和健康检查脚本上传至OBS桶的code目录中。 脚本文件的OBS路径规划：
   ```
   ├── <OBS桶>
   │   └── models
   │       └── <模型名>                    # 模型权重所在目录，部署时挂载到容器内
   │   └── code
   │       ├── get_master_ip.py            # 从全局rank表获取master IP的工具（仅多机PD部署时涉及）
   │       ├── glm_5_2.sh                  # 模型启动脚本
   │       └── check.sh                    # 健康检查脚本
   ```
   
 
#### 步骤四：部署推理服务
在ModelArts平台配置并启动在线服务。
1. 登录[ModelArts管理控制台](https://console.huaweicloud.com/modelarts/)。
2. 为加速部署，建议提前在专属资源池中预热模型权重。
   ![](https://support.huaweicloud.com/bestpractice-modelarts/public_sys-resources/note_3.0-zh-cn.png)
   首次部署推理服务时需从OBS下载模型权重到节点，大模型加载耗时较长，使用资源池预热能力可以提前加载模型，缩短部署时长。
   1. 在左侧菜单栏中选择"资源管理 \> 专属算力资源 \> 资源池"。
   
   2. 在资源池列表，选择目标专属资源池，单击名称，进入详情页。
   
   3. 选择"预热任务"，单击"添加预热任务"，在对话框中完成任务配置。此处仅列出关键参数配置说明，详细操作请参见[在专属资源池添加模型预热](https://support.huaweicloud.com/resmgmt-modelarts/resmgmt-modelarts_0081.html)。
      表4添加模型预热任务的关键参数说明 
      | 参数名称   | 参数说明                                                                                                                                                        | 取值示例              |
      |:---|:---|:---|
      | 权重路径地址 | 选择待预热的模型权重文件的OBS路径。即[步骤一：下载模型权重并上传至OBS]的路径。                                | obs://xxx/models/ |
      | 文件占用空间 | 根据需要预热的模型权重文件大小输入数值。 选择完"权重路径地址"后，单击"获取权重文件占用空间"获取到推荐值，一般情况下，该预测值略大于模型实际目录大小。 | 780               |
         
      
   
   4. 配置完成后，单击"确定"提交模型预热任务。 当"预热状态"变成"保温中"则表示模型预热已完成。
      
    
3. 返回ModelArts主菜单栏，选择"模型推理 \> 在线推理"，进入在线服务管理页面。
4. 单击右上角的"部署"，进入"部署在线服务"页面。
5. 在部署在线服务页面，配置服务信息。此处仅列出关键参数配置说明，详细操作请参见[配置服务信息](https://support.huaweicloud.com/inference-modelarts/inference2.0-modelarts-0016.html)。
   表5服务信息的关键参数说明 
   | 参数类别 | 参数名称   | 参数说明                                | 取值示例        |
   |:---|:---|:---|:---|
   | 基础信息 | 服务名称   | 自定义服务名称，建议加上模型名称。                   | glm_52_w8a8 |
   | 网络配置 | 服务接入方式 | 选择"默认"，使用ModelArts平台能力。             | 默认          |
   | 网络配置 | 服务协议   | 选择"HTTP"，请求超时按需修改。                  | HTTP        |
   | 网络配置 | 认证方式   | 按需选择服务认证方式，测试环境可以选择"无认证"，便于直接调用API。 | 无认证         |
      
   
6. 单击"下一步"，进行部署配置。此处仅列出关键参数配置说明，详细操作请参见[推理在线服务多机PD混部](https://support.huaweicloud.com/inference-modelarts/inference2.0-modelarts-0038.html)。
   表6部署配置的关键参数说明 
   | 参数类别   | 参数名称     | 参数说明                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | 取值示例                  |
   |:---|:---|:---|:---|
   | 资源配置   | 资源池类型    | 选择"专属资源池"，获得独占资源保障。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 专属资源池                 |
   | 模型配置   | 模型来源     | 选择"自定义模型"。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 自定义模型                 |
   | 模型配置   | 存储类型     | 选择"资源池已预热模型"。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 资源池已预热模型              |
   | 模型配置   | 已预热模型    | 选择已预热完成的模型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | glm52w8a8             |
   | 模型配置   | 挂载路径     | 模型权重在容器内的挂载路径，需与启动脚本"glm_5_2.sh"中模型权重挂载路径一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | /weight/              |
   | 单元配置   | 部署方式     | 选择模型部署方式。 - 基础模式：单机部署，配置1个推理单元，不需要角色检测和PD通信。  - 多角色分离：多机PD部署，配置多个推理单元，需要"get_master_ip.py"脚本检测master/slave角色。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 多角色分离                 |
   | 单元配置   | 单元名称     | 自定义推理单元名称。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | role-0                |
   | 单元配置   | 规格类型     | 选择"自定义规格"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 自定义规格                 |
   | 单元配置   | NPU      | 每台推理单元使用的NPU卡数。需与模型启动脚本（如"glm_5_2.sh"）中"TENSOR_PARALLEL_SIZE"参数值一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 8                     |
   | 单元配置   | CPU      | 根据资源池规格配置。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 144                   |
   | 单元配置   | 内存       | 根据资源池规格配置。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 512000MB              |
   | 单元配置   | 单副本资源实例数 | 每台推理单元的实例数。需与模型启动脚本（如"glm_5_2.sh"）中的"DATA_PARALLEL_SIZE_LOCAL"参数值一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | 1                     |
   | 单元配置   | 镜像类型     | 选择"自定义镜像"。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 自定义镜像                 |
   | 单元配置   | 选择镜像     | 选择容器镜像服务SWR的自有镜像。即[步骤二：下载推理镜像并推送至SWR]的镜像。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | vllm-ascend:glm52     |
   | 单元配置   | 文件存储挂载   | 将OBS中的code文件夹挂载到容器内。 "文件存储"的存储类型选择"对象存储OBS-对象桶"，存储地址选到code，挂载路径是"/code/"。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 参见参数说明列               |
   | 单元配置   | 健康检查     | 配置健康检查。 - 启动探针：检查vllm进程是否已启动。 检查方式选择"执行命令检查"，健康检查命令为bash /code/check.sh startup。   - 就绪探针：检查推理服务是否可接收请求（仅master节点检查/health接口）。 检查方式选择"执行命令检查"，健康检查命令为bash /code/check.sh readiness。   - 存活探针：检查vllm进程是否仍在运行。 检查方式选择"执行命令检查"，健康检查命令为bash /code/check.sh liveness。    | 参见参数说明列               |
   | 单元配置   | 启动命令     | 输入启动命令，挂载/code/，容器启动后，会将obs中的代码路径挂载到该路径下，在启动命令中，使用该路径下的启动脚本启动vllm服务。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | bash /code/glm_5_2.sh |
   | 单元配置   | 添加推理单元   | 多机PD部署时，需要参考第一个推理单元按需添加多个推理单元。单元名称自定义，如"role-1"，其他参数保持一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | -                     |
   | 部署管理配置 | 容器协议     | 容器的网络传输协议。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | HTTP                  |
   | 部署管理配置 | 容器端口     | 镜像监听的端口号，需与模型启动脚本（如"glm_5_2.sh"）中的"port"参数值一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | 7000                  |
      
   
7. 配置完成后，单击"下一步"，确认配置详情。
8. 单击"确认部署"，启动在线服务。
9. 当在线推理服务的"状态"变为"运行中"时，单击服务名称，进入详情页，选择"日志"页签。
10. 在日志页签，观察部署日志，当出现如下信息则表示推理服务部署成功。
    ```
    INFO: Application startup complete.
    ```
    
 
#### 步骤五：接口可用性验证
通过API接口验证推理服务可用性。
1. 在服务列表，选择部署成功的在线推理服务，单击服务名称，进入详情页。
2. 选择"预测"页签。
3. 设置请求参数。 示例：
   - 请求方法：POST
   
   - 请求URL：/v1/completions
   
   - 数据格式：stream
   
   - 请求Body：
     ```
     {
         "model": "glm-52",
         "prompt": "The future of AI is",
         "max_completion_tokens": 50,
         "temperature": 0
     }
     ```
     
    
4. 单击"预测"，在预测结果处查看返回结果，服务正常时返回模型名称、模型信息和回答内容。 首次请求时模型需完成编译和缓存预热，响应较慢为正常现象。后续请求响应恢复正常。
   
 
 #### FAQ：执行pull命令提示不支持--platform怎么办
执行pull命令返回如下报错时，需要先开启Docker的实验特性才能用--platform。
```
"--platform" is only supported on a Docker daemon with experimental features enabled
```
开启实验模式的步骤：
1. 编辑"/etc/docker/daemon.json"：
   ```
   {
     "experimental": true
   }
   ```
   
2. 重启Docker：
   ```
   systemctl restart docker
   ```
   
3. 重新执行pull命令。
 
 #### FAQ：ECS网络无法访问镜像仓库导致pull超时怎么办
执行pull命令返回如下信息，则表示ECS无法连接quay.io，需要在能连接quay.io的机器上下载镜像，导出后传到当前ECS。
```
Error response from daemon: Get "https://quay.io/v2/": net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers)
```
解决方案：
1. 确认ECS与quay.io之间的网络，显示超时，则表示ECS在隔离网络，无法直接访问镜像仓库。
   ```
   curl -I https://quay.io
   ```
   
2. 确认模型部署环境。
   - 如果模型部署计划在局域网，则执行下一步，使用另一台支持公网访问的ECS下载镜像，再导出上传到局域网内的ECS。
   
   - 如果模型部署计划在公网，则给当前ECS绑定弹性公网IP，再重新执行[步骤二：下载推理镜像并推送至SWR]，继续部署。
    
3. 使用另一台支持公网访问的ECS下载镜像。
   1. 远程登录ECS，检查ECS是否已经安装Docker。
      ```
      # 检查Docker是否安装
      docker -v
      ```
      如尚未安装，运行以下命令安装Docker。
      ```
      yum install -y docker-engine.aarch64 docker-engine-selinux.noarch docker-runc.aarch64
      ```
      
   
   2. 在ECS使用Docker下载镜像。
      ```
      docker pull --platform linux/arm64 <推理镜像名称>
      ```
      推理镜像名称和[1]保持一致。
      示例：
      ```
      docker pull --platform linux/arm64 quay.io/ascend/vllm-ascend:glm5.2
      ```
      
    
4. 镜像下载完成后，导出为tar文件"vllm-ascend.tar"。
   ```
   docker save <推理镜像名称> > vllm-ascend.tar
   ```
   示例：
   ```
   docker save quay.io/ascend/vllm-ascend:v0.22.1rc1 > vllm-ascend.tar
   ```
   
5. 将tar文件"vllm-ascend.tar"传到局域网内的ECS，可以采用scp/FTP/移动硬盘/U盘等物理传输方式，也可以使用OBS的obsutil上传下载数据。
   
6. 在局域网内的ECS上加载镜像到本地Docker。
   ```
   docker load < vllm-ascend.tar
   ```
   执行成功会显示加载的镜像名称，如：
   ```
   Loaded image: quay.io/ascend/vllm-ascend:v0.22.1rc1
   ```
   
7. 将加载成功的镜像推送至内网SWR。操作步骤请参见[4]\~[8]。
8. 继续进行模型部署。
 
