最新动态
功能总览
服务公告
- 下线公告
- 产品发布说明
- 产品变更公告
  - 网络调整公告
  - 预测API的域名停用公告
产品介绍
- 图解ModelArts
  - 初识ModelArts
  - 初识Workflow
- 什么是ModelArts
- 产品优势
- 应用场景
- 功能介绍
- AI开发基础知识
- 安全
- 约束与限制
- 权限管理
- 计费说明
- 配额与限制
- 与其他云服务的关系
计费说明
- 计费概述
- 计费模式
- 计费项
- 计费样例
- 变更计费模式
- 续费
- 费用账单
- 欠费说明
- 停止计费
- 成本管理
- 计费FAQ
快速入门
- ModelArts入门指引
- 使用ModelArts Standard一键完成商超商品识别模型部署
- 使用ModelArts Standard自动学习实现垃圾分类
- 使用ModelArts Standard自定义算法实现手写数字识别
- 使用ModelArts Studio的Qwen2-7B模型框架实现对话问答
- 使用ModelArts Studio的DeepSeek-R1模型框架实现对话问答
- ModelArts入门实践
ModelArts用户指南（Standard）
- ModelArts Standard使用流程
- ModelArts Standard准备工作
- ModelArts Standard资源管理
- 使用自动学习实现零代码AI开发
- 使用Workflow实现低代码AI开发
- 使用Notebook进行AI开发调试
- 数据准备与处理
- 使用ModelArts Standard训练模型
- 使用ModelArts Standard部署模型并推理预测
- 制作自定义镜像用于ModelArts Standard
- ModelArts Standard资源监控
- 使用CTS审计ModelArts服务
  - ModelArts支持云审计的关键操作
  - 查看ModelArts相关审计日志
ModelArts用户指南（Studio）
- MaaS使用场景和使用流程
- 配置MaaS访问授权
- 准备MaaS资源
- 在模型广场查看模型
- 在MaaS中创建模型
- 使用MaaS调优模型
- 使用MaaS压缩模型
- 使用MaaS部署模型服务
- 免费体验MaaS预置服务
- 在MaaS体验模型服务
- 调用MaaS部署的模型服务
- 通过Function Calling扩展大语言模型交互能力
- 管理我的服务
- 在MaaS应用实践中心查看应用解决方案
ModelArts用户指南（Lite Server）
- Lite Server使用前必读
- Lite Server资源开通
- Lite Server资源配置
- Lite Server资源使用
  - LLM/AIGC/数字人基于Server适配NPU的训练推理指导
  - GPT-2基于Server适配PyTorch GPU的训练推理指导
- Lite Server资源管理
ModelArts用户指南（Lite Cluster）
- Lite Cluster使用前必读
- Lite Cluster资源开通
- Lite Cluster资源配置
- Lite Cluster资源使用
- Lite Cluster资源管理
ModelArts用户指南（AI Gallery）
- AI Gallery（新版）
- AI Gallery（旧版）
最佳实践
- ModelArts最佳实践案例列表
- 昇腾能力应用地图
- DeepSeek系列模型推理
- LLM大语言模型训练推理
- MLLM多模态模型训练推理
- 文生图模型训练推理
- 文生视频模型训练推理
- 数字人模型训练推理
  - Wav2Lip推理基于Lite Server适配PyTorch NPU推理指导（6.3.907）
  - Wav2Lip训练基于Lite Server适配PyTorch NPU训练指导（6.3.907）
- 内容审核模型训练推理
- GPU业务迁移至昇腾训练推理
- Standard权限管理
- Standard自动学习
  - 使用ModelArts Standard自动学习实现口罩检测
  - 使用ModelArts Standard自动学习实现垃圾分类
- Standard开发环境
  - 将Notebook的Conda环境迁移到SFS磁盘
  - 使用ModelArts VSCode插件调试训练ResNet50图像分类模型
- Standard模型训练
  - 使用ModelArts Standard自定义算法实现手写数字识别
  - 基于ModelArts Standard运行GPU训练作业
- Standard推理部署
- 历史待下线案例
API参考
- 使用前必读
- API概览
- 如何调用API
  - 构造请求
  - 认证鉴权
  - 返回结果
- Workflow工作流管理
  - 获取Workflow工作流列表
  - 新建Workflow工作流
  - 删除Workflow工作流
  - 查询Workflow工作流
  - 修改Workflow工作流
  - 总览Workflow工作流
  - 查询Workflow待办事项
  - 在线服务鉴权
  - 创建在线服务包
  - 获取Execution列表
  - 新建Workflow Execution
  - 删除Workflow Execution
  - 查询Workflow Execution
  - 更新Workflow Execution
  - 管理Workflow Execution
  - 管理Workflow StepExecution
  - 获取Workflow工作流节点度量信息
  - 新建消息订阅Subscription
  - 删除消息订阅Subscription
  - 查询消息订阅Subscription详情
  - 更新消息订阅Subscription
  - 创建工作流定时调度
  - 查询工作流定时调度详情
  - 删除工作流定时调度信息
  - 更新工作流定时调度信息
- 开发环境管理
  - 创建Notebook实例
  - 查询Notebook实例列表
  - 查询所有Notebook实例列表
  - 查询Notebook实例详情
  - 更新Notebook实例
  - 删除Notebook实例
  - 通过运行的实例保存成容器镜像
  - 查询Notebook支持的有效规格列表
  - 查询Notebook支持的可切换规格列表
  - 查询运行中的Notebook可用时长
  - Notebook时长续约
  - 启动Notebook实例
  - 停止Notebook实例
  - 获取动态挂载OBS实例信息列表
  - 动态挂载OBS
  - 获取动态挂载OBS实例详情
  - 动态卸载OBS
  - 添加资源标签
  - 删除资源标签
  - 查询Notebook资源类型下的标签
  - 查询支持的镜像列表
  - 注册自定义镜像
  - 查询用户镜像组列表
  - 查询镜像详情
  - 删除镜像
- 训练管理
  - 创建算法
  - 查询算法列表
  - 查询算法详情
  - 更新算法
  - 删除算法
  - 获取支持的超参搜索算法
  - 创建训练实验
  - 创建训练作业
  - 查询训练作业详情
  - 更新训练作业描述
  - 删除训练作业
  - 终止训练作业
  - 查询训练作业指定任务的日志（预览）
  - 查询训练作业指定任务的日志（OBS链接）
  - 查询训练作业指定任务的运行指标
  - 查询训练作业列表
  - 查询超参搜索所有trial的结果
  - 查询超参搜索某个trial的结果
  - 获取超参敏感度分析结果
  - 获取某个超参敏感度分析图像的路径
  - 提前终止自动化搜索作业的某个trial
  - 获取自动化搜索作业yaml模板的信息
  - 获取自动化搜索作业yaml模板的内容
  - 创建训练作业标签
  - 删除训练作业标签
  - 查询训练作业标签
  - 获取训练作业事件列表
  - 创建训练作业镜像保存任务
  - 查询训练作业镜像保存任务
  - 获取训练作业支持的公共规格
  - 获取训练作业支持的AI预置框架
- AI应用管理
  - 查询模型runtime
  - 查询AI应用列表
  - 创建AI应用
  - 查询AI应用详情
  - 删除AI应用
- APP认证管理
  - 获取APP列表
  - 创建APP
  - 查询APP详情
  - 删除APP
  - 增加AppCode
  - 重置AppCode
  - 删除AppCode
  - 重置AppSecret
  - 获取用户绑定APP的api列表
  - 注册API并授权给APP
  - 删除API
  - 授权API至APP
  - 更新API授权
  - 解除API对APP的授权
  - 获取API授权关系列表
  - 创建API
  - 查询API
  - 查询API和APP
  - 查询APP的API认证信息
  - 查询APP是否存在
- 服务管理
  - 通过patch操作对服务进行更新
  - 查询服务监控信息
  - 查询服务列表
  - 部署服务
  - 查询支持的服务部署规格
  - 查询服务详情
  - 更新服务配置
  - 删除服务
  - 更新模型服务的单个属性
  - 查询专属资源池列表
  - 查询服务事件日志
  - 启动停止边缘节点服务实例
  - 查询服务更新日志
  - 添加资源标签
  - 删除资源标签
  - 查询推理服务标签
  - 查询推理VPC访问通道信息的API
- 资源管理
  - 查询OS的配置参数
  - 查询插件模板
  - 查询节点列表
  - 批量删除节点
  - 批量重启节点
  - 查询事件列表
  - 创建网络资源
  - 查询网络资源列表
  - 查询网络资源
  - 删除网络资源
  - 更新网络资源
  - 查询资源实时利用率
  - 创建资源池
  - 查询资源池列表
  - 查询资源池
  - 删除资源池
  - 更新资源池
  - 资源池监控
  - 资源池统计
  - 查询资源规格列表
  - 查询专属资源池作业列表
  - 查询专属资源池作业统计信息
- DevServer管理
  - 查询用户所有DevServer实例列表
  - 创建DevServer
  - 查询DevServer实例详情
  - 删除DevServer实例
  - 实时同步用户所有DevServer实例状态
  - 启动DevServer实例
  - 停止DevServer实例
- 授权管理
  - 查看授权列表
  - 配置授权
  - 删除授权
  - 创建ModelArts委托
- 工作空间管理
  - 查询工作空间详情
  - 修改工作空间
  - 删除工作空间
  - 查询工作空间配额
  - 修改工作空间配额
  - 查询工作空间列表
  - 创建工作空间
- 配额管理
  - 查询OS的配额
- 资源标签管理
  - 查询资源池的所有标签
  - 查询资源池上的标签
- 节点池管理
  - 查询节点池列表
  - 创建节点池
  - 查询指定节点池详情
  - 更新节点池
  - 删除节点池
  - 查询节点池的节点列表
- 应用示例
  - 创建图像分类数据集并进行标注任务
  - 创建并完成图像分类的智能标注任务
  - 开发环境的应用示例
  - 以PyTorch框架创建训练作业（新版训练）
  - 创建和修改工作空间
  - 管理ModelArts服务的委托授权
- 权限策略和授权项
  - 策略及授权项说明
  - 数据管理权限
  - 开发环境权限
  - 训练作业权限
  - 模型管理权限
  - 服务管理权限
  - 工作空间管理权限
  - DevServer权限
- 公共参数
  - 状态码
  - 错误码
  - 获取项目ID和名称
  - 获取账号名和账号ID
  - 获取用户名和用户ID
- 历史API
  - 数据管理（旧版）
  - 开发环境（旧版）
  - 训练管理（旧版）
SDK参考
- 文档导读
- SDK简介
- 快速开始
- （可选）本地服务器安装ModelArts SDK
- Session鉴权
- OBS管理
- 数据管理
- 训练管理
  - 训练作业
  - 资源和引擎规格接口
    - 查询资源规格列表
    - 查询引擎规格列表
- 模型管理
- 服务管理
场景代码示例
故障排除
- 通用问题
  - ModelArts中提示OBS相关错误
- 自动学习
- 开发环境
- 训练作业
- 推理部署
- MoXing
- API/SDK
- 资源池
- Lite Server
- Lite Cluster
常见问题
- 权限相关
- 存储相关
  1. 在ModelArts中如何查看OBS目录下的所有文件？
- Standard自动学习
- Standard Workflow
  1. 如何定位Workflow运行报错
- Standard数据准备
- Standard Notebook
- Standard模型训练
- Standard推理部署
- Standard镜像相关
- Standard专属资源池
- Studio
- Edge
  1. 在ModelArts中使用边缘节点部署边缘服务时能否使用http接口协议？
- API/SDK
- Lite Server
- Lite Cluster
  1. Cluster资源池如何进行NCCl Test？
- 历史文档待下线
  1. ModelArts与其他服务的关系
  2. 如何上传数据至OBS？
视频帮助
文档下载
通用参考
- 产品术语
- 云服务等级协议（SLA）
- 白皮书资源
- 支持区域
- 系统权限

本文导读

展开导读

文档首页/ AI开发平台ModelArts/ 最佳实践/ DeepSeek系列模型推理/ DeepSeek模型基于ModelArts Lite Server适配MindIE推理部署指导/ 部署推理服务/ 自动化脚本快速部署推理服务（推荐）

自动化脚本快速部署推理服务（推荐）

更新时间：2025-02-25 GMT+08:00

查看PDF

场景描述

本方案提供了一键式安装脚本start.sh，用于快速部署推理服务。脚本中实现了以下步骤的自动化操作：

环境检查
拉取镜像
根据实际值更新rank_table_file.json
启动容器
进入容器启动服务

前提条件

已经完成资源购买。
请确保多机之间能够正常通信。
请确保每台机器都能访问到西南-贵阳一SWR镜像仓库。

约束限制

脚本中的镜像是在西南-贵阳一区域，建议在西南-贵阳一区域上部署推理服务。

脚本默认只支持在标准的欧拉或HCE 2.0操作系统上执行。

步骤一：检查环境

SSH登录机器后，检查NPU设备检查。如果驱动版本不是24.1.0，请先升级驱动和对应固件。
```
npu-smi info -t board -i 1 | egrep -i "software|firmware"   #查看驱动和固件版本
```
24.1.0版本驱动文件为Ascend-hdk-910b-npu-driver_24.1.0_linux-aarch64.run，对应固件文件为Ascend-hdk-910b-npu-firmware_7.5.0.3.220.run，请申请下载。

安装固件命令如下，安装完后需要reboot重启机器。
```
chmod 700 *.run
./Ascend-hdk-910b-npu-firmware_7.5.0.3.220.run --full
reboot
```
安装24.1.0驱动命令如下：
```
./Ascend-hdk-910b-npu-driver_24.1.0_linux-aarch64.run --full --install-for-all
```
安装完成后再使用如下命令查看是否安装正确。
```
npu-smi info -t board -i 1 | egrep -i "software|firmware"
```

检查docker是否安装。

docker -v   #检查docker是否安装

如尚未安装，运行以下命令安装docker。

yum install -y docker-engine.aarch64 docker-engine-selinux.noarch docker-runc.aarch64

配置IP转发，用于容器内的网络访问。执行以下命令查看net.ipv4.ip_forward配置项的值，如果为1，可跳过此步骤。
```
sysctl -p | grep net.ipv4.ip_forward
```
如果net.ipv4.ip_forward配置项的值不为1，执行以下命令配置IP转发。
```
sed -i 's/net\.ipv4\.ip_forward=0/net\.ipv4\.ip_forward=1/g' /etc/sysctl.conf
sysctl -p | grep net.ipv4.ip_forward
```

步骤二：自动化部署

需要先安装yum和expect。

sudo apt-get install yum
yum install expect

把rank_table_file.json、start.sh和权重文件放在同一目录下。其中rank_table_file.json和start.sh只需要在主节点即可。rank_table_file.json仅作为模板使用，会在start.sh脚本里自动更新，文件内容详见附录：rank_table_file.json文件和一键部署脚本start.sh。参考目录结构如下：
```
${mountPath}
|---rank_table_file.json
|---start.sh
|---DeepSeekR1-w8a8  # 权重文件所在目录，每个节点都要有，且目录结构保持一致
```

执行部署脚本start.sh。
```
sh start.sh --model_name ${modelName} --mount_path ${mountPath} --maxSeqLen ${maxSeqLen} --node_ips ${nodeIps} --passwords ${nodePwds}
```
- modelName：模型权重所在文件夹名称。注意：文件夹名称需要包含R1或V3。例如：DeepSeekR1-w8a8。
- mountPath：容器挂载的路径，且不能为/home，该路径下包含权重文件所在目录。即为权重文件所在目录的父目录。
- maxSeqLen：输入长度+输出长度的最大值。推荐默认16384。
- nodeIps：节点IP列表，使用“,“分隔。填2个节点IP地址。
- nodePwds：各节点的root用户登录密码，使用“,“分隔，和上述节点要一一对应。

步骤三：调用

执行请求调用模型

curl -ik -H 'Content-Type: application/json' -d '{"messages":[{"role":"user","content":"请讲一个笑话"}],"model":"${model_name}","temperature":0.6,"max_tokens":1024}' -X POST http://${ip}:${port}/v1/chat/completions

model_name：为要调用的模型名称，即DeepSeek-V3或DeepSeek-R1
ip：为步骤二：自动化部署中nodeIps中第一个IP
port：为要访问的端口，默认1025

一键部署脚本start.sh

#!/bin/bash

# 定义默认值
# 参数变量
model_name=""
mount_path=""
maxSeqLen=
image_name="swr.cn-southwest-2.myhuaweicloud.com/ei_ascendcloud_devops/mindie:2.0.T3.1-800I-A2-py311-openeuler24.03-lts-0220"
CONTAINER_NAME="mindie"
# 根据变量修改的值
MODEL_NAME=""
model_path=""
mount_path="${mount_path%/}"
RANK_TABLE_FILE="$mount_path/rank_table_file.json"

port=22
# 默认maxSeqLen为16K时的参数配置，如果maxSeqLen修改为32K时，需要修改maxInputTokenLen、maxPrefillTokens和maxIterTimes的值，具体修改方法参见附录：config.json文件介绍。
maxPrefillBatchSize=100
maxInputTokenLen=8192
maxPrefillTokens=8192
maxIterTimes=8192
httpsEnabled=false
multiNodesInferEnabled=true
interCommTLSEnabled=false
interNodeTLSEnabled=false


# 定义期望的软件和固件版本
expected_software_version="24.1.0"
expected_firmware_version="7.5.0.3.220"


# 定义节点IP列表（第一个IP为主节点）
node_ips=("")
NODE_IPS=""
echo "node_ips:   ${node_ips[*]}"

# 定义密码列表（如果只有一个密码，则所有节点使用该密码）
# node_passwords=("xxx" "xxx")  # 替换为实际密码
node_passwords=("")


# 检查expect是否安装
if ! command -v expect &> /dev/null; then
    echo "错误: expect未安装，请先执行yum install expect"
    exit 1
fi

# 解析命令行参数
ARGS=$(getopt -o n:p:l:i:k: -l model_name:,mount_path:,maxSeqLen:,node_ips:,passwords: -- "$@")
if [ $? -ne 0 ]; then
    echo "参数解析失败"
    exit 1
fi

eval set -- "$ARGS"

while true; do
    case "$1" in
        -n|--model_name)
            model_name=$2  # 忽略大小写
            MODEL_NAME=$model_name
            shift 2
            ;;
        -p|--mount_path)
            mount_path="$2"
            # 去除 mount_path 最后的 '/'
            mount_path="${mount_path%/}"
            shift 2
            ;;
        -l|--maxSeqLen)
            maxSeqLen="$2"
            shift 2
            ;;
        -i|--node_ips)
            IFS=',' read -r -a node_ips <<< "$2"
            shift 2
            ;;
        -k|--passwords)
            IFS=',' read -r -a node_passwords <<< "$2"
            shift 2
            ;;
        --)
            shift
            break
            ;;
        *)
            echo "用法：$0 -n <model_name> -p <mount_path> -l <maxSeqLen> -i <node_ips> -k <passwords>"
            echo "  -n, --model-name: 模型名称，可选值为 r1 或 v3"
            echo "  -p, --mount-path: 挂载路径，必须提供，且不能为 /home"
            echo "  -l, --max-seq-len: 输入长度+输出长度的最大值，需要在8192上加2^的若干次方数"
            echo "  -i, --node-ips: 逗号分隔的节点IP地址"
            echo "  -k, --passwords: 密码字符串列表"
            exit 1
            ;;
    esac
done

# 检查 mount_path 是否为空或为 /home
if [ -z "$mount_path" ]; then
    echo "必须提供 mount_path 参数"
    exit 1
fi

if [ "$mount_path" = "/home" ]; then
    echo "mount_path 不能为 /home"
    exit 1
fi

if [ -z "$maxSeqLen" ]; then
    echo "必须提供 maxSeqLen 参数"
    exit 1
fi
model_path=$mount_path/$model_name
# 转换 model_name 为小写，以便忽略大小写
lower_model_name=$(echo "$model_name" | tr '[:upper:]' '[:lower:]')

# 检查 model_name 是否包含 r1 或 v3
if [[ "$lower_model_name" == *"r1"* ]]; then
    model_name="DeepSeek-R1"
    # model_path=$mount_path/deepseekR1-w8a8
    # echo "模型路径为：$model_path"

elif [[ "$lower_model_name" == *"v3"* ]]; then
    model_name="DeepSeek-V3"
    # model_path=$mount_path/deepseekV3-w8a8
    # echo "模型路径为：$model_path"
else
    echo "错误: model_name 参数中必须包含 r1 或 v3"
    exit 1
fi


RANK_TABLE_FILE="$mount_path/rank_table_file.json"
# 打印参数值
echo "maxSeqLen的值为：$maxSeqLen"
echo "模型名:$model_name"
echo "模型路径:$model_path"
echo "挂载路径:$mount_path"
echo "node_ips:   ${node_ips[*]}"
# 将数组元素以空格连接成字符串，再使用tr将空格替换为逗号
NODE_IPS=$(printf "%s " "${node_ips[@]}" | tr ' ' ',')
# 去除末尾多余的逗号
NODE_IPS=${NODE_IPS%,}
echo "NODE_IPS: ${NODE_IPS}"
echo "node_passwords:   ${node_passwords[*]}"
echo "rank_table_file文件路径:$RANK_TABLE_FILE"
# exit 0


echo "步骤1: 检查NPU的软件和固件信息..."
npu_smi_output=$(npu-smi info -t board -i 1 | egrep -i "software|firmware")

if [ $? -ne 0 ]; then
    echo "检查NPU软件和固件信息失败，退出脚本。"
    exit 1
fi


# 提取实际的软件和固件版本
actual_software_version=$(echo "$npu_smi_output" | grep -i "Software Version" | awk -F': ' '{print $2}' | tr -d ' ')
actual_firmware_version=$(echo "$npu_smi_output" | grep -i "Firmware Version" | awk -F': ' '{print $2}' | tr -d ' ')

# 比较软件版本
if echo -e "$actual_software_version\n$expected_software_version" | sort -V | head -n1 | grep -q "$actual_software_version"; then
    if [ "$actual_software_version" != "$expected_software_version" ]; then
        echo "软件版本不对，期望版本至少为 $expected_software_version，实际版本为 $actual_software_version"
        exit 1
    fi
fi

# 比较固件版本
if echo -e "$actual_firmware_version\n$expected_firmware_version" | sort -V | head -n1 | grep -q "$actual_firmware_version"; then
    if [ "$actual_firmware_version" != "$expected_firmware_version" ]; then
        echo "固件版本不对，期望版本至少为 $expected_firmware_version，实际版本为 $actual_firmware_version"
        exit 1
    fi
fi

echo "NPU软件和固件版本检查通过。"

# 步骤2: 执行一系列检查命令，如果有报错则退出
echo "步骤2: 执行检查命令..."
commands=(
    "for i in {0..7}; do hccn_tool -i \$i -lldp -g | grep Ifname; done"
    "for i in {0..7}; do hccn_tool -i \$i -link -g ; done"
    "for i in {0..7}; do hccn_tool -i \$i -net_health -g ; done"
    "for i in {0..7}; do hccn_tool -i \$i -netdetect -g ; done"
    "for i in {0..7}; do hccn_tool -i \$i -gateway -g ; done"
    "for i in {0..7}; do hccn_tool -i \$i -tls -g ; done | grep switch"
    "for i in {0..7}; do hccn_tool -i \$i -tls -s enable 0; done"
)

echo "拉取镜像"
docker pull $image_name

# 步骤4: 获取enp67s0f5网卡下的IP地址
echo "步骤4: 获取本机IP地址..."
ip_addr_now=$(hostname -I | awk '{print $1}')
if [ -z "$ip_addr_now" ]; then
    echo "获取当前物理机IP地址失败。"
    exit 1
fi
echo "获取当前物理机IP地址成功，IP地址为: $ip_addr_now"


# 初始化标记位
is_first_node=false
echo "主节点ip地址为：${node_ips[0]}"
# exit 0
# 判断 ip_addr_now 是否是第一个节点
if [ "$ip_addr_now" = "${node_ips[0]}" ]; then
    is_first_node=true
fi

if $is_first_node; then
    echo "${ip_addr_now}作为主节点"

    # 步骤3: 获取每张卡的IP地址并打印（修正版）
    echo "步骤3: 获取每张卡的IP地址..."

    # 获取主节点的显卡IP
    echo "步骤3: 获取主节点的显卡IP..."
    declare -a main_npu_ips
    for i in {0..7}; do
        ip_info=$(hccn_tool -i $i -ip -g 2>&1)
        if [ $? -ne 0 ]; then
            echo "获取卡号 $i 的IP地址失败，退出脚本。"
            exit 1
        fi

        ip_addr=$(echo "$ip_info" | awk -F':' '/ipaddr/ {print $2}' | tr -d ' ')
        if [ -z "$ip_addr" ]; then
            echo "卡号 $i 未找到有效IP地址，退出脚本。"
            exit 1
        fi
        main_npu_ips[$i]=$ip_addr
        echo "主节点NPU卡$i IP地址: ${main_npu_ips[$i]}"
    done
    echo "主节点IP地址获取完成。"

    # 备份原始文件
    cp "$RANK_TABLE_FILE" "${RANK_TABLE_FILE}.bak"

    # 设置环境变量传递显卡IP
    export ips_0="${main_npu_ips[@]}"

    # 更新主节点的server_id和container_ip (使用Python)
    python3 <<EOF
import json
import os

def update_json(filename, server_id, container_ip):
    device_ips = os.getenv("ips_0").split()
    with open(filename, 'r') as f:
        data = json.load(f)
    # 更新主节点的server_id和container_ip
    data['server_list'][0]['server_id'] = server_id
    data['server_list'][0]['container_ip'] = container_ip
    # 更新主节点的device_ip
    for i in range(8):
        if i < len(device_ips):
            data['server_list'][0]['device'][i]['device_ip'] = device_ips[i]
        else:
            data['server_list'][0]['device'][i]['device_ip'] = ""
    # 删除多余的设备条目（如果有的话）
    for server in data['server_list']:
        if len(server['device']) > 8:
            server['device'] = server['device'][:8]
    with open(filename, 'w') as f:
        json.dump(data, f, indent=4)

update_json("$RANK_TABLE_FILE", "${node_ips[0]}", "${node_ips[0]}")
EOF

    # 远程登录其他节点，获取显卡IP并更新rank_table_file.json
    for (( node_index=1; node_index<${#node_ips[@]}; node_index++ )); do
        node_ip=${node_ips[$node_index]}
        node_password=${node_passwords[$node_index]} 

        echo "步骤3: 获取节点 $node_ip 的显卡IP..."

        # 使用expect远程执行命令获取显卡IP
        declare -a remote_npu_ips
        for i in {0..7}; do
            ip_info=$(expect -c "
                set timeout 10
                spawn ssh -p $port -o StrictHostKeyChecking=no root@$node_ip \"hccn_tool -i $i -ip -g\"
                expect {
                    \"password:\" {
                        send \"${node_password}\r\"
                        exp_continue
                    }
                    eof {
                        catch wait result
                        exit [lindex \$result 3]
                    }
                }
            ")
            if [ $? -ne 0 ]; then
                echo "获取节点 $node_ip 卡号 $i 的IP地址失败，退出脚本。"
                exit 1
            fi

            ip_addr=$(echo "$ip_info" | awk -F':' '/ipaddr/ {print $2}' | tr -d ' ')
            if [ -z "$ip_addr" ]; then
                echo "节点 $node_ip 卡号 $i 未找到有效IP地址，退出脚本。"
                exit 1
            fi
            remote_npu_ips[$i]=$ip_addr
            echo "节点 $node_ip NPU卡$i IP地址: ${remote_npu_ips[$i]}"
        done
        echo "节点 $node_ip IP地址获取完成。"

        # 设置环境变量传递显卡IP
        export ips_1="${remote_npu_ips[@]}"

        # 更新当前节点的server_id和container_ip 
        python3 <<EOF
import json
import os

def update_server_info(filename, server_index, server_id, container_ip):
    device_ips = os.getenv("ips_1").split()
    with open(filename, 'r') as f:
        data = json.load(f)

    # 确保 server_list 有足够的条目
    while server_index >= len(data['server_list']):
        new_server = {
            "device": [
                {"device_id": str(i), "device_ip": "", "rank_id": str(len(data['server_list']) * 8 + i)} for i in range(8)
            ],
            "server_id": "",
            "container_ip": ""
        }
        data['server_list'].append(new_server)

    # 更新指定服务器的信息
    data['server_list'][server_index]['server_id'] = server_id
    data['server_list'][server_index]['container_ip'] = container_ip

    # 更新设备 IP 和 rank_id
    for i in range(min(len(device_ips), 8)):
        data['server_list'][server_index]['device'][i]['device_ip'] = device_ips[i]
        data['server_list'][server_index]['device'][i]['rank_id'] = str(server_index * 8 + i)

    # 确保设备条目数量正确
    data['server_list'][server_index]['device'] = data['server_list'][server_index]['device'][:8]

    # 更新 server_count
    data['server_count'] = str(len(data['server_list']))

    with open(filename, 'w') as f:
        json.dump(data, f, indent=4)

update_server_info("$RANK_TABLE_FILE", $node_index, "$node_ip", "$node_ip")
EOF
    done


    # 传输给子节点
    # 传输 rank_table_file.json 到其他节点
    for (( node_index=1; node_index<${#node_ips[@]}; node_index++ )); do
        node_ip=${node_ips[$node_index]}
        node_password=${node_passwords[$node_index]} 

        echo "传输 rank_table_file.json 到节点 $node_ip..."

        # 使用 expect 自动输入密码并执行 scp
        expect -c "
            set timeout 10
            spawn scp -P $port -ro StrictHostKeyChecking=no $mount_path/rank_table_file.json $mount_path/start.sh root@$node_ip:$mount_path
            expect {
                \"password:\" {
                    send \"$node_password\r\"
                    exp_continue
                }
                eof {
                    catch wait result
                    exit [lindex \$result 3]
                }
            }
        "

        if [ $? -eq 0 ]; then
            echo "文件传输到节点 $node_ip 成功。"
        else
            echo "文件传输到节点 $node_ip 失败。"
            exit 1
        fi
    done

    echo "所有文件传输完成。"

    # 连接到远程节点并执行命令
    for (( node_index=1; node_index<${#node_ips[@]}; node_index++ )); do
        node_ip=${node_ips[$node_index]}
        node_password=${node_passwords[$node_index]}  

        echo "连接到节点 $node_ip 并执行命令..."

        expect -c "
            set timeout 10
            spawn ssh -p $port -o StrictHostKeyChecking=no root@$node_ip \"bash $mount_path/start.sh -n $MODEL_NAME -p $mount_path -l $maxSeqLen -i $NODE_IPS > $mount_path/log_$node_ip.txt 2>&1\"
            expect {
                \"password:\" {
                    send \"$node_password\r\"
                    exp_continue
                }
                eof {
                    catch wait result
                    exit [lindex \$result 3]
                }
            }
        "

        if [ $? -eq 0 ]; then
            echo "命令在节点 $node_ip 执行成功。"
        else
            echo "命令在节点 $node_ip 执行失败。"
            exit 1
        fi
    done

    echo "远程执行脚本成功"
sleep 32
fi

# 步骤5: 启动容器
echo "步骤5: 启动容器..."

# 启动容器
docker run -itd --privileged \
    -v /etc/localtime:/etc/localtime \
    -v /usr/local/Ascend/driver:/usr/local/Ascend/driver \
    -v /usr/local/Ascend/firmware:/usr/local/Ascend/firmware \
    --device=/dev/davinci_manager \
    --device=/dev/devmm_svm \
    --device=/dev/hisi_hdc \
    -v /var/log/npu/:/usr/slog \
    -v /usr/local/sbin/npu-smi:/usr/local/sbin/npu-smi \
    -v /sys/fs/cgroup:/sys/fs/cgroup:ro \
    -v $mount_path:$mount_path \
    --net=host \
    --ipc=host \
    --shm-size 2g \
    --name ${CONTAINER_NAME} \
    ${image_name} \
    /bin/bash

# 检查容器是否启动成功
if [ $? -eq 0 ]; then
    echo "容器启动成功，容器名：${CONTAINER_NAME}"
else
    echo "容器启动失败！"
    exit 1
fi
# exit 0
# 步骤6: 将命令写入 ~/.bashrc 文件并执行
echo "步骤6: 将命令写入 ~/.bashrc 文件并执行..."

# 定义需要写入的命令列表（直接使用宿主机变量）
commands_to_write=(
    "cd /usr/local/Ascend/mindie/latest"
    "chmod 750 mindie-service"
    "chmod -R 550 mindie-service/bin"
    "chmod -R 500 mindie-service/bin/mindie_llm_backend_connector"
    "chmod 550 mindie-service/lib"
    "chmod 440 mindie-service/lib/*"
    "chmod 550 mindie-service/lib/grpc"
    "chmod 440 mindie-service/lib/grpc/*"
    "chmod -R 550 mindie-service/include"
    "chmod -R 550 mindie-service/scripts"
    "chmod 750 mindie-service/logs"
    "chmod 750 mindie-service/conf"
    "chmod 640 mindie-service/conf/config.json"
    "chmod 700 mindie-service/security"
    "chmod -R 700 mindie-service/security/*"
    "source /usr/local/Ascend/ascend-toolkit/set_env.sh"
    "source /usr/local/Ascend/nnal/atb/set_env.sh"
    "source /usr/local/Ascend/atb-models/set_env.sh"
    "unset HCCL_OP_EXPANSION_MODE"
    "export ATB_LLM_HCCL_ENABLE=1"
    "export ATB_LLM_COMM_BACKEND=\"hccl\""
    "export PYTORCH_NPU_ALLOC_CONF=\"expandable_segments:True\""
    "export MIES_CONTAINER_IP=${ip_addr_now}"
    "export RANKTABLEFILE=$mount_path/rank_table_file.json"
    "export HCCL_DETERMINISTIC=false"
    "export PARALLEL_PARAMS=\"[1,16,1,16,-1,-1]\""
    "export ATB_WORKSPACE_MEM_ALLOC_ALG_TYPE=3"
    "export ATB_WORKSPACE_MEM_ALLOC_GLOBAL=1"
    "export NPU_MEMORY_FRACTION=0.96"
    "export HCCL_CONNECT_TIMEOUT=7200"
    "export HCCL_EXEC_TIMEOUT=0"
    # "export MINDIE_LOG_TO_STDOUT=1"
)

# 将命令列表转换为单行字符串（避免引号嵌套问题）
commands_str=$(printf "%s\n" "${commands_to_write[@]}")

# 在容器内执行命令（使用单引号包裹）
docker exec ${CONTAINER_NAME} bash -c '
    # 逐行处理命令
    while IFS= read -r cmd; do
        # 检查命令是否已存在
        if ! grep -Fxq "$cmd" ~/.bashrc; then
            echo "$cmd" >> ~/.bashrc
        fi
    done <<< "$1"

    # 使配置生效
    # source ~/.bashrc
' _ "${commands_str}"  # 通过参数传递命令列表

# 检查命令是否执行成功
if [ $? -eq 0 ]; then
    echo "命令已成功写入 ~/.bashrc 并执行。"
else
    echo "命令写入或执行失败！"
    echo "删除容器${CONTAINER_NAME}"
    docker stop ${CONTAINER_NAME} && docker rm ${CONTAINER_NAME}
    echo "删除成功"
    exit 1
fi


# 容器内执行命令
echo "环境变量设置的当前节点ip为:"
docker exec ${CONTAINER_NAME} bash -c 'source ~/.bashrc && echo $MIES_CONTAINER_IP'
docker exec ${CONTAINER_NAME} bash -c "cat $RANK_TABLE_FILE"


docker exec ${CONTAINER_NAME} bash -c "
    cd /usr/local/Ascend/mindie/latest/mindie-service/conf && \
    sed -i 's|\"ipAddress\" : \".*\"|\"ipAddress\" : \"${node_ips[0]}\"|g' config.json && \
    sed -i 's|\"managementIpAddress\" : \".*\"|\"managementIpAddress\" : \"${node_ips[0]}\"|g' config.json && \
    sed -i 's|\"modelName\" : \".*\"|\"modelName\" : \"${model_name}\"|g' config.json && \
    sed -i 's|\"modelWeightPath\" : \".*\"|\"modelWeightPath\" : \"${model_path}\"|g' config.json && \
    sed -i 's|\"maxPrefillBatchSize\" : .*|\"maxPrefillBatchSize\" : ${maxPrefillBatchSize},|g' config.json && \
    sed -i 's|\"maxSeqLen\" : .*|\"maxSeqLen\" : ${maxSeqLen},|g' config.json && \
    sed -i 's|\"maxInputTokenLen\" : .*|\"maxInputTokenLen\" : ${maxInputTokenLen},|g' config.json && \
    sed -i 's|\"maxPrefillTokens\" : .*|\"maxPrefillTokens\" : ${maxPrefillTokens},|g' config.json && \
    sed -i 's|\"httpsEnabled\" : .*|\"httpsEnabled\" : ${httpsEnabled},|g' config.json && \
    sed -i 's|\"multiNodesInferEnabled\" : .*|\"multiNodesInferEnabled\" : ${multiNodesInferEnabled},|g' config.json && \
    sed -i 's|\"interCommTLSEnabled\" : .*|\"interCommTLSEnabled\" : ${interCommTLSEnabled},|g' config.json && \
    sed -i 's|\"interNodeTLSEnabled\" : .*|\"interNodeTLSEnabled\" : ${interNodeTLSEnabled},|g' config.json && \
    sed -i 's|\"maxIterTimes\" : .*|\"maxIterTimes\" : ${maxIterTimes},|g' config.json
"

# 检查修改后的结果
echo "修改后的值如下所示："
docker exec ${CONTAINER_NAME} bash -c "cd /usr/local/Ascend/mindie/latest/mindie-service/conf && 
    cat config.json"



docker exec ${CONTAINER_NAME} bash -c "source ~/.bashrc && rm -rf /root/mindie/cache/* && cd /usr/local/Ascend/mindie/latest/mindie-service && 
    nohup ./bin/mindieservice_daemon &> $mount_path/start_log_$ip_addr_now.txt &"



# 查看容器日志
echo "查看容器日志："
docker logs -f ${CONTAINER_NAME}

echo "所有步骤执行完毕。"

父主题： 部署推理服务

上一篇：部署推理服务

下一篇：手动部署推理服务

意见反馈

文档内容是否对您有帮助？

有帮助没帮助

提供反馈

提交成功！非常感谢您的反馈，我们会继续努力做到更好！您可在我的云声建议查看反馈及问题处理状态。

系统繁忙，请稍后重试

在使用文档中是否遇到以下问题

内容与产品页面不一致

内容不易理解

缺失示例代码

步骤不可操作

搜不到想要的内容

缺少最佳实践

意见反馈（选填）

0/500

请至少选择一项反馈信息并填写问题反馈

字符长度不能超过500

直接提交取消

如您有其它疑问，您也可以通过华为云社区问答频道来与我们联系探讨

智能客服提问云社区提问

自动化脚本快速部署推理服务（推荐）

场景描述

前提条件

约束限制

步骤一：检查环境

步骤二：自动化部署

步骤三：调用

一键部署脚本start.sh

相关文档

意见反馈

文档内容是否对您有帮助？

7*24

备案

专业服务

退订

建议反馈

售前咨询热线

文档反馈