vLLM实现本地部署大模型

vLLM（virtual LLM）是由 UC Berkeley 和一些工业界开发者提出的一个 高性能、大模型推理引擎，旨在提高大语言模型（LLM）在推理服务部署过程中的吞吐、延迟和内存效率。

使用 vLLM 进行本地大模型部署是目前性价比最高、效率最优秀的方案之一。

1. 极致性能：凭借 PagedAttention，吞吐量远超其他方案，能同时服务更多用户。
2. 降低成本：更高的吞吐量意味着用更少的 GPU 服务器实现相同的并发能力。
3. 简单易用：API 设计简洁，与 OpenAI API 兼容，生态友好。
4. 功能强大：开箱即用地支持连续批处理、并行采样、张量并行等高级功能。

一、环境准备

1. 硬件要求：

   • GPU：推荐 NVIDIA GPU（如 A100, A10, V100, 3090/4090, 等）。显存越大，能运行的模型就越大。
   • 显存：模型所需显存 ≈ 模型参数量 × 2（对于 FP16/BF16）。例如：
     • 7B 模型：约 14 GB
     • 13B 模型：约 26 GB
     • 70B 模型（需张量并行）：约 140 GB（分布在多卡上）
   • CPU 和 RAM：足够的系统内存来加载模型权重（通常 16GB+）和快速的 CPU。

2. 软件要求：

   • 操作系统：Linux (Ubuntu/CentOS) 或 WSL2 (Windows)。
   • 驱动程序：安装最新的 NVIDIA GPU 驱动。
   • CUDA/cuDNN：vLLM 会通常通过 PyPI 自动安装合适的 CUDA 版本。但为了确保兼容性，建议预先安装与你的驱动匹配的 CUDA 工具包（如 CUDA 12.1）。
   • Python：推荐 Python 3.12

如果你的设备是 Linux 系统（如 Ubuntu、CentOS），可以直接安装 vLLM 并运行；但如果你的设备是 Windows 系统，由于 Windows 原生环境对 vLLM 的支持存在诸多限制，WSL 成为了在 Windows 上高效运行 vLLM 的主流解决方案。

好的，完全没问题。使用 WSL (Windows Subsystem for Linux) 是在 Windows 系统上体验 Linux 环境并运行 vLLM 的完美方案。

下面我将详细解释如何通过 WSL 在 Windows 上部署本地大模型。

二、安装WSL

WSL 允许你在 Windows 内部运行一个完整的 Linux 发行版（如 Ubuntu），无需双系统或虚拟机。在这个 Linux 环境中，你可以直接访问 Windows 上的 GPU 资源（需要 NVIDIA 驱动支持），从而安装 CUDA、Python 和 vLLM。

简单流程： Windows → 安装 WSL 和 Ubuntu → 在 Ubuntu 中安装 NVIDIA CUDA 驱动 → 安装 Python 和 vLLM → 模型文件放在 Windows 硬盘上，在 Linux 中直接调用。

安装并配置WSL2：https://learn.microsoft.com/zh-cn/windows/wsl/install

第 1 步：安装和设置 WSL 2

1. 启用 WSL 功能：

   • 以管理员身份打开 PowerShell 或 命令提示符。

   

   • 运行以下命令：

     wsl --update
     

     wsl --install  #这步如果慢就用这个: wsl --update --web-download
     

     这个命令会自动启用所需的“Windows Subsystem for Linux”和“虚拟机平台”功能，并默认安装 Ubuntu 发行版。完成后需要重启电脑。

     

     如果你之前已安装过wsl1，可以直接卸载掉：

     wsl --uninstall
     

2. （如果上述无效）手动安装：

   • 如果上面的命令不工作，可以手动启用：

     dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
     dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
     

   • 重启后，前往 Microsoft Store 搜索 “Ubuntu” 并安装一个版本（如 Ubuntu 22.04 LTS）。

3. 设置 WSL 版本：

   • 确保 WSL 2 是默认版本。在 PowerShell 中运行：

     wsl --set-default-version 2
     

【错误原因】

可能是BIOS里面虚拟化未启动，可以检查一下

第 2 步：启动Ubuntu

• 从开始菜单启动你安装的 “Ubuntu” 应用。第一次启动会要求你设置一个用户名和密码（注意，输入密码时屏幕不会显示，这是正常的）。

• 确认WSL版本：https://learn.microsoft.com/zh-cn/windows/wsl/install#check-which-version-of-wsl-you-are-running

wsl -l -v

确保是版本2：

  NAME              STATE           VERSION
* Ubuntu-22.04      Running         2
  docker-desktop    Stopped         2

官方文档说：然后重新启动计算机

执行：

wsl

WSL2 将 Windows 上的固定驱动器（如 C:, D:）自动挂载到 Linux 环境中的 /mnt/ 目录下。

• C: 盘 → /mnt/c/

• D: 盘 → /mnt/d/

• E: 盘 → /mnt/e/

• …以此类推。

• WSL2 的 Linux 发行版默认安装在一个虚拟硬盘（.vhdx 文件）中，这个文件的大小会随着使用而自动增长，但管理起来不如直接使用 Windows 的 NTFS 驱动器直观。

• 大模型动辄占用 10GB+ 的存储空间。将它们放在 /mnt/d/Models/ 下，意味着它们存储在您的 Windows D 盘上，您可以清楚地知道它们占了多少空间，并可以利用 Windows 的文件管理器进行轻松的复制、移动或备份。

三、在 WSL 中安装 vLLM

现在你的 WSL 环境已经是一个标准的、带有 GPU 的 Ubuntu 系统了。

第 1 步：更新系统并安装 Python：

sudo apt update && sudo apt upgrade -y
sudo apt install python3-pip python3-venv -y

第 2步：显卡驱动

检查GPU支持：

注：下面是在powershell里面执行的检查方式

docker pull nvidia/cuda:12.2.0-base-ubuntu20.04
docker run --gpus all nvidia/cuda:12.2.0-base-ubuntu20.04 nvidia-smi

#如果商店装的wsl就直接用这个指令就好了
docker pull ubuntu:22.04
docker run --gpus all=Ubuntu-22.04 
docker run --gpus all ubuntu:22.04 nvidia-smi #查看cuda

第 3 步：虚拟环境

和宿主机里面安装虚拟环境一样，这里我们也安装anaconda。

你完全可以安装完整的Anaconda，但是我们这里的目标只是部署大模型，所以安装Miniconda是最经济实惠的：

下载(选一个)：

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh #Miniconda
wget https://repo.anaconda.com/archive/Anaconda3-2025.06-0-Linux-x86_64.sh #anaconda

**运行安装脚本：**回车-----yes-----回车-----yes

bash Miniconda3-latest-Linux-x86_64.sh  #Miniconda
bash Anaconda3-2025.06-0-Linux-x86_64.sh #anaconda

让修改生效：

source ~/.bashrc

【报错】

错误的核心是 下载的安装包文件不完整或已损坏，需要删除之前尝试安装时产生的所有文件

删除c盘下的这个文件，然后再重新运行下载命令

# 创建一个虚拟环境
python3 -m venv vllm-env

# 激活虚拟环境
source vllm-env/bin/activate

# 安装 vLLM 和所需的包
pip install vllm

四、大模型部署

第 1步：安装 vLLM

安装非常简单，使用 pip 即可。建议在一个新的虚拟环境中进行。

• 创建新的虚拟环境

conda create -n vllm python==3.12

conda activate vllm

• 查看你的cuda版本

nvidia-smi

• 找你的显卡驱动对应的最新的pytorch框架，下载torch：https://pytorch.org/ （防止报错）
• 下载 vllm (需要关闭梯子 使用国内镜像下载 这步需要下载很久)

pip install vllm -i https://mirrors.aliyun.com/pypi/simple/

第 2 步：下载模型

vLLM 完美支持 Hugging Face Hub 上的模型。你需要一个你喜欢的模型。

• 从 Hugging Face Hub 下载：vLLM 可以在运行时自动下载。但为了稳定和速度，建议先使用 git-lfs 下载到本地。
• 推荐一些热门模型：
  • Meta-Llama-3-8B-Instruct：Meta 最新推出的模型，能力强劲。
  • Qwen2-7B-Instruct：阿里通义千问的模型，中英文能力均衡。
  • Mistral-7B-Instruct-v0.3：一个非常强大的 7B 指令模型。
  • Gemma-7B-it：Google 推出的轻量级模型。

示例：下载模型Qwen(–local-dir路径改成自己电脑的路径)

export HF_ENDPOINT=https://hf-mirror.com
huggingface-cli download --resume-download Qwen/Qwen3-0.6B --local-dir /mnt/e/huggingface/Qwen3-0.6B --local-dir-use-symlinks False 

启动运行

python3 -m vllm.entrypoints.openai.api_server --model /mnt/c/huggingface/Qwen3-0.6B --host 0.0.0.0 --port 8000 --gpu-memory-utilization 0.8 --max-model-len 4086 

启动效果：

说明：

• --gpu-memory-utilization 0.6

  限制 vLLM 使用 60% GPU 显存

• --max-model-len 32000

  表示把最大序列长度从 40960 降到 32000，KV cache 占用显存会减少，不然显存不够用

• --quantization int8

  对模型进行 8-bit 量化，大幅减少显存占用,如果不支持可以不要这个参数

• --host 0.0.0.0

  允许 Windows 或局域网其他机器访问 API

• --port 8000

  自定义 API 端口，可根据需要修改

• /mnt/c/huggingface/Qwen3-0.6B

  映射 Windows c 盘下载好的模型，无需重复下载

• –max-gpu-memory：最大GPU使用

【运行报错】

1.RuntimeError: Failed to find C compiler. Please specify via CC environment variable.缺少 C 编译器

解决方法是安装 C 编译器并指定环境变量,在 Ubuntu/Debian 系统中：

sudo apt update
sudo apt install build-essential

2.可适当减少–max-model-len模型单次能处理的最大 Token 长度

3.若提示 GPU 内存不足，降低 --gpu-memory-utilization 至 0.5 或更低

第 3 步： API 端口

首先查看WSL真实IP地址：

wsl hostname -I

客户端可以访问的地址：

http://172.19.246.30:8000/
http://localhost:8000/
http://127.0.0.1:8000/

默认情况下，vLLM 的 API 服务器运行在：
http://localhost:8000 或 http://0.0.0.0:8000

所有的 API 请求都需要在这个基础 URL 后加上特定的端点路径。

分类	API 端点 (Endpoint)	HTTP 方法	主要用途	示例 URL
核心功能	/v1/chat/completions	POST	对话补全 (首选)，用于多轮聊天交互	http://localhost:8000/v1/chat/completions
	/v1/completions	POST	文本补全，给定提示词让模型继续写作	http://localhost:8000/v1/completions
查询与监控	/v1/models	GET	获取服务器当前加载的模型列表	http://localhost:8000/v1/models
	/health	GET	健康检查，确认服务器是否正常运行	http://localhost:8000/health
	/metrics	GET	获取 Prometheus 格式的性能指标 (用于监控)	http://localhost:8000/metrics
开发与调试	/docs	GET	交互式 API 文档 (Swagger UI)，用于查看和测试所有端点	http://localhost:8000/docs
基础地址	/	GET	根目录，通常返回 404 或简单欢迎信息，用于测试连通性	http://localhost:8000/

现在，你的本地大模型已经变成了一个类似 OpenAI 的服务。你可以用任何 HTTP 客户端调用它。

1. 使用 curl 命令测试：

curl http://localhost:8000/v1/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "my-llama", # 与 --served-model-name 参数一致
    "prompt": "San Francisco is a",
    "max_tokens": 100,
    "temperature": 0
  }'

2. 使用 Chat API（更推荐，用于对话模型）：

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "my-llama",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "请写一首关于春天的短诗。"}
    ],
    "max_tokens": 200,
    "temperature": 0.7
  }'

3. 使用 Python 代码调用：

你可以使用 OpenAI 的官方库，只需将 base_url 指向你的本地服务器。

from openai import OpenAI

# 初始化客户端，指向你的本地 vLLM 服务器
client = OpenAI(
    api_key="EMPTY", # vLLM 服务器默认不需要 API key
    base_url="http://localhost:8000/v1" # 你的服务器地址
)

# 调用聊天接口
response = client.chat.completions.create(
    model="my-llama", # 与 --served-model-name 参数一致
    messages=[
        {"role": "user", "content": "请解释一下人工智能的未来。"}
    ],
    max_tokens=512,
    temperature=0.8,
    stream=True # 支持流式输出
)

# 处理流式响应
for chunk in response:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)

五、Docker部署

Docker 是一个开源的容器化平台，核心作用是将应用程序及其依赖（如库、配置、运行环境等）打包成一个标准化的 “容器”，确保应用在任何支持 Docker 的环境中（Windows、Linux、macOS 甚至云服务器）都能一致、稳定地运行，解决了 “在我这能跑，在你那跑不起来” 的经典环境兼容问题。

核心概念

1. 镜像（Image）
   • 可以理解为一个 “只读的模板”，包含了运行应用所需的所有文件（代码、依赖、环境变量、配置等）。
   • 比如 “Python 3.10 镜像” 就是包含了 Python 3.10 解释器、基础 Linux 系统库的模板；“vLLM 镜像” 则是在 Python 基础上，预先装好了 vLLM、PyTorch、CUDA 等依赖的模板。
   • 镜像不能直接运行，是创建容器的 “原材料”。
2. 容器（Container）
   • 镜像的 “运行实例”，是一个独立的、可执行的软件包（包含应用和其运行环境）。
   • 容器之间相互隔离（有自己的文件系统、网络、进程空间），但共享宿主机（你的 WSL Linux）的内核，性能接近原生。
   • 比如你用 “vLLM 镜像” 创建一个容器，这个容器就是一个独立的 vLLM 运行环境，启停、删除都不会影响宿主机或其他容器。
3. 仓库（Repository）
   • 存放镜像的 “仓库”，类似代码仓库（如 GitHub）。
   • 官方仓库是 Docker Hub，里面有大量现成的镜像（如 Python、Ubuntu、vLLM 等），你可以直接下载使用，无需自己从零构建。

使用官方 vllm/vllm-openai 镜像的优势包括：

• 环境隔离：Docker 容器提供了独立的运行环境，能有效避免系统库版本冲突和依赖错误问题。
• 便捷迁移：容器可以轻松地在不同的服务器、数据中心或云平台之间迁移，降低了环境搭建和维护的成本。
• 资源高效：vLLM 采用了 PagedAttention 等核心技术，能显著提升吞吐量和内存使用效率。
• 开箱即用：镜像预装了运行环境，你无需在本地手动安装 CUDA、Python 包等复杂的依赖。
• 兼容性：部署后的服务提供与 OpenAI API 兼容 的接口，这意味着你可以使用熟悉的 openai Python 库或其他兼容工具来调用你的模型。

准备工作

在运行容器之前，请确保你的主机环境满足以下要求：

1. NVIDIA 驱动与 CUDA：确保已安装最新的 NVIDIA 显卡驱动。vLLM 官方镜像通常需要 CUDA 12.1 或更高版本。使用 nvidia-smi 命令可以查看驱动版本和支持的 CUDA 版本。
2. Docker 与 NVIDIA Container Toolkit：正确安装 Docker 并配置 NVIDIA Container Toolkit（原 nvidia-docker2），以便 Docker 容器能够访问和使用宿主机的 GPU。
3. 模型文件：准备好你要部署的模型。你可以：
   • 从 Hugging Face Hub 或 Modelscope 等平台下载模型到本地目录。
   • 让容器在运行时自动下载（需设置 HUGGING_FACE_HUB_TOKEN 环境变量以访问受限模型）。

第 1 步：安装Docker

• 下载 Docker Desktop

  下载：https://docs.docker.com/desktop/setup/install/windows-install/

启动后:

• 配置

  • 磁盘镜像配置
    • Docker Desktop在 Windows 上跑的时候，其实是用 WSL2虚拟磁盘 存储容器、镜像、卷等数据。
    • 这个文件会越来越大，因为所有镜像/容器都放里面，会达到几十个G

  

  

  大模型路径建议不要填C盘：先点Browse选择路径后再点+号

  

• Docker Engine配置

  这里还是配置下镜像加速器：国内用户常用

  {
    "registry-mirrors": [
      "https://ustc-edu-cn.mirror.aliyuncs.com/",
      "https://ccr.ccs.tencentyun.com/",
      "https://docker.m.daocloud.io/",
      "https://hub-mirror.c.163.com",
      "https://mirror.ccs.tencentyun.com",
      "https://registry.docker-cn.com",
      "https://docker.mirrors.ustc.edu.cn"
    ],
    "builder": {
      "gc": {
        "defaultKeepStorage": "20GB",
        "enabled": true
      }
    },
    "experimental": false
  }
  

.wslconfig配置

(可选项)，配置文档：https://learn.microsoft.com/en-us/windows/wsl/wsl-config#configure-global-options-with-wslconfig

文件路径：C:\Users\<用户名>\.wslconfig

[wsl2]
memory=12GB             # 分配12GB给WSL2，留4GB给Windows系统和其他程序
processors=12           # 分配12核CPU给WSL2，避免系统卡顿
swap=8GB                # 开启8GB交换空间，防止内存不足导致崩溃
localhostForwarding=true

超级管理员，PowerShell，执行：

wsl --shutdown

重新打开你的 WSL 终端，配置生效。

第 2 步：拉取并运行

vllm/vllm-openai 镜像是docker官方的镜像,对cuda版本有要求,自行看下载哪个版本的:

https://hub.docker.com/r/vllm/vllm-openai/tags

接下来以vllm/vllm-openai:v0.8.4示例

• 建议先拉取镜像

docker pull vllm/vllm-openai:v0.8.4

• 运行

# vllm/vllm-openai:v0.9.2 不写版本默认是下载的最新的cuda12.8版本的 
docker run --gpus all -p 8000:8000 vllm/vllm-openai --model Qwen/Qwen3-0.6B
# 指定了镜像版本为 v0.8.4（较旧版本，适配的 CUDA 版本更低，如 CUDA 11.8/12.1）
docker run --gpus all -p 8000:8000 vllm/vllm-openai:v0.8.4 --model Qwen/Qwen3-0.6B
#运行:指定镜像版本为 v0.8.4，使用 gpu 80%（预留 20% 给系统或其他程序）
docker run --gpus all -p 8000:8000 vllm/vllm-openai:v0.8.4 --model Qwen/Qwen3-0.6B --gpu-memory-utilization 0.8

首次运行时，容器会从 Hugging Face Hub 下载 Qwen/Qwen3-0.6B 模型（约 1.2GiB），终端会显示下载进度（如 Downloading model files: 50%），此时需耐心等待，不要中断命令（中断后下次运行会重新下载未完成的文件）。

如果你提前下载好了模型，可以通过指定模型名字直接运行：

docker run -it --gpus all  -p 8000:8000 -v E:\huggingface:/data/huggingface   vllm/vllm-openai:v0.8.4  --model /data/huggingface/Qwen3-0.6B --max-model-len 8192 --gpu-memory-utilization 0.6 

成功运行后：

常用配置选项

在 docker run 命令中，vLLM 相关的参数允许你精细控制服务行为：

• --model：指定模型，可以是 Hugging Face 模型ID（如 meta-llama/Meta-Llama-3-8B-Instruct）或容器内的模型路径（如 /app/model）。
• --served-model-name：定义通过 API 访问时使用的模型名称。
• --tensor-parallel-size：张量并行度，通常等于使用的 GPU 数量，用于将大模型拆分到多卡。
• --dtype：指定模型加载的数据类型，如 auto, half (FP16), bfloat16。half 是内存和速度的常见平衡点。
• --gpu-memory-utilization：设定用于模型 KV 缓存的 GPU 内存比例，范围 0-1。根据你的模型大小和并发需求调整。
• --max-model-len：模型支持的最大上下文长度（Token 数）。
• --trust-remote-code：当加载的模型需要执行自定义代码时（如某些国产模型），必须添加此参数。
• --api-key：设置一个 API 密钥来保护你的服务端点（如 --api-key your-secret-key-here）。

【报错】

注意全程关闭管家和防火墙，若报错了先检查一下管家和防火墙再尝试

这里是没有提前拉取镜像，直接在运行时下载

打开docker会以一直转圈，并且弹窗（如上），警告

个人处理方法，非常粗暴，建议先试试其他方法：

此时关掉弹窗还会弹，所以打开任务管理器，把与docker相关的进程全部退出

然后把docker卸载重装，注意把镜像目录下的东西也要清空（如果在设置中修改里路径可以找到）

重装后重复上述步骤，但不同的是在运行下载模型前先拉取镜像docker pull vllm/vllm-openai:v0.8.4

镜像确定拉取完成后再进行下一步，若下载还是报错，把代理打开，我本人是有效的，可以运行成功后再关闭代理，不影响

第 3步：访问与测试 API

用Postman和Python分别测试下

Postman：

• 方法 (Method)：选择POST
• URL：输入http://localhost:8000/v1/chat/completions
• Headers： 添加一个 Key： Content-Type， Value： application/json
• Body：选择 raw， 然后从下拉菜单中选择 JSON

{
    "model": "Qwen/Qwen3-0.6B",
    "messages": [
        {
            "role": "user",
            "content": "你好，请用中文介绍一下你自己。"
        }
    ],
    "max_tokens": 150,
    "temperature": 0.7
}

预期成功的响应：
你会收到一个 200 OK 的状态码，响应体是一个 JSON 对象，其中包含模型的回答：

{
    "id": "chatcmpl-abc123",
    "object": "chat.completion",
    "created": 1708673200,
    "model": "Qwen/Qwen3-0.6B",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "你好！我是一个基于大型语言模型的人工智能助手，由vLLM引擎驱动。我可以回答你的问题、提供信息、进行翻译、总结内容，或者只是和你聊天。请问有什么可以帮你的吗？" // 模型的回答在这里
            },
            "finish_reason": "stop"
        }
    ],
    "usage": {
        "prompt_tokens": 20,
        "total_tokens": 80,
        "completion_tokens": 60
    }
}

Python集成：

from openai import OpenAI

client = OpenAI(
    base_url="http://127.0.0.1:8000/v1",
    api_key=""  # 默认不需要 key
)

response = client.chat.completions.create(
    model="/data/huggingface/Qwen3-0.6B",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
    	{"role": "user", "content": "你好，请简单介绍一下人工智能。"}
    ]
)
print(response.choices[0].message.content)

第 4步：打包和部署

快速开发 → 验证 OK → 打包 Docker 镜像 → 部署到服务器/云端

1 镜像打包

现在已经用 Docker 启动了 vLLM 服务：

可以通过以下步骤打包镜像：

1.1 查找容器 ID

docker ps -a

1.2 提交容器为镜像

docker commit 018a0895fd12 my-lulaoshi-vllm:latest

镜像查看：

• my-lulaoshi-vllm:latest 是你打包后的镜像名称和 tag。
• 这会把容器内部修改（如安装的依赖）保存为镜像。
• 无法直接在文件夹里看到镜像文件。

1.3 保存为tar

docker save -o my-lulaoshi-vllm.tar my-lulaoshi-vllm:latest

• 生成 my-lulaoshi-vllm.tar 文件，可以拷贝到其他机器。

  

• 对方机器用：

  docker load -i my-lulaoshi-vllm
  

  就能直接使用镜像。

1.4 模型挂载处理

• 当前用 -v F:/huggingface:/models 映射模型。
• 镜像里面只有容器内已安装的软件和依赖，不会自动带走宿主机 F:/huggingface 的模型文件。
• 优点：镜像小、便于分发
• 缺点：目标机器需要重新挂载宿主机的模型路径，或者把模型拷贝到容器内

1.4.1 把模型打包到镜像

• 复制模型到容器内再打包

  • 先创建目录

    docker exec -it 018a0895fd12 mkdir -p /models
    

  • 再移植模型文件

    docker cp F:/huggingface/Qwen3-0.6B 018a0895fd12:/models/Qwen3-0.6B
    

  

• 打包后的镜像就包含模型

  docker commit 018a0895fd12 lulaoshi-vllm-with-model:latest
  

  

• 镜像会变大，再保存为tar文件

  docker save -o my-lulaoshi-vllm-with-model.tar lulaoshi-vllm-with-model:latest
  

  

1.4.2 不打包到镜像

也可以不用打包模型到镜像，后面通过挂载或者模型拷贝的方式指定模型即可，请参考后续镜像分发和部署。

2 镜像分发和部署

把打包好的镜像 .tar 拷贝到另一台机器，然后直接启动 vLLM 服务。

2.1 加载镜像

拷贝了 my-lulaoshi-vllm.tar 到新机器某个目录，例如 D:\docker_images\：

docker load -i D:\docker_images\my-lulaoshi-vllm.tar

这会把镜像导入 Docker，本地镜像列表里就会出现：

docker images

你应该能看到：

REPOSITORY             TAG       IMAGE ID
my-lulaoshi-vllm       latest    de5a3418de87

2.2 运行镜像

如果已经把模型打包在镜像里就不用挂载，否则仍然要指定模型：挂载模型 或者 拷贝模型到容器。

• 镜像里已经有模型

  docker run -it --gpus all -p 8000:8000 my-lulaoshi-vllm-with-model:latest
  

  • 容器启动后，vLLM API 就监听在宿主机的 8000 端口
  • 容器内模型路径 /models/Qwen3-0.6B 已经存在

• 镜像不带模型，依然挂载宿主机或者拷贝模型到容器

  假设新机器模型在 E:\huggingface：

  docker run -it --gpus all -p 8000:8000 -v E:/huggingface:/models my-lulaoshi-vllm:latest --model /models/Qwen3-0.6B
  

  • -v E:/huggingface:/models 把宿主机模型映射到容器
  • --model /models/Qwen3-0.6B 指定模型路径

2.3 访问 API

• 通过 Postman 或 Python 测试：

import requests

url = "http://<宿主机IP>:8000/v1/chat/completions"
data = {
    "model": "/models/Qwen3-0.6B",
    "messages": [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "你好，请简单介绍一下华清远见成都中心。"}
    ]
}

r = requests.post(url, json=data)
print(r.json())

• 如果容器内模型已经打包在镜像里，可以直接用 /models/Qwen3-0.6B
• 如果用挂载的方式，需要确保宿主机路径和容器内路径一致