知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 模型部署与本地推理(vLLM / Ollama / 量化) > 导读:本文从"公司要求数据不出内网,可公有云大模型 API 又便宜又好用,到底要不要自己部署一套大模型"这个实际决策疑问出发,把自部署与 API 的取舍、推理引擎选型、量化、显存估算、性能指标与优化、部署运维、模型网关混合路由逐项讲透,最后给出工程实践与踩坑清单。适合正在做 LLM 应用架构选型、需要把模型落到自己机房或自己显卡上的同学,也适合面试前想快速建立"部署这一块"知识骨架的同学。  *图:模型部署的三件套——模型权重、推理引擎与服务化外壳* ## 一、先建立全局认知 ### Q:什么情况下必须自部署,什么情况下直接用 API 更划算? A:结论先行——**自部署买的是"数据主权 + 成本可控 + 深度可控",代价是"你把自己变成了模型服务的运维方";API 买的是"零运维 + 最新模型 + 弹性",代价是单次调用贵、数据要出域、能力受厂商节奏控制。** 决策的本质不是技术对比,而是问自己三个问题:数据能不能出去、调用量够不够大、有没有 GPU 运维能力。 先看一张决策对比表: | 维度 | 直接用 API | 自部署(本地 / 私有化) | |---|---|---| | 数据合规 | 数据出域,需过安全评估、签数据处理协议(DPA),敏感行业往往不可行 | 数据在自有网络内闭环,最容易过合规 | | 起步成本 | 几乎为零,充值即可 | 高:GPU 采购或租用 + 环境搭建 + 人力 | | 边际成本 | 按 token 计费,量大时线性增长 | 固定成本为主,跑满后边际成本极低 | | 弹性 | 秒级弹性,天然抗突发 | 受显卡数量限制,扩容周期以天/周计 | | 模型新鲜度 | 厂商上新的旗舰模型,随时可用 | 自己拉权重,滞后于发布节奏 | | 可控性 | 除采样参数外几乎不可改(自定义 logits 处理、约束解码受限) | 可改采样、可加约束解码、可做 LoRA 热插拔、可定制 tokenizer | | 可观测性 | 只有厂商给的用量与延迟指标 | 全链路自建:GPU 利用率、队列深度、KV Cache 命中率全都有 | | 稳定性 | 受厂商限流、故障、区域影响 | 自己负责;但也意味着故障可自愈、版本可回滚 | | 典型适用 | 探索期、中小流量、非敏感数据、需要最强模型能力 | 合规敏感、稳定大流量、需要私有微调、离线或边缘场景 | 判断口诀可以记成三条: 1. **合规一票否决**:金融、医疗、政企、法务、人力等场景,只要数据不能出域,就只剩自部署(或私有云托管)这一条路,没有讨价还价空间。 2. **用量算拐点**:`月 API 费用 ≈ 自部署月均摊成本` 是临界点。自部署的月均摊成本要把 GPU 折旧或租金、电费、运维人力、冗余(至少留 20%~30% 余量)全部算进去。注意:**自部署的成本优势只在"利用率足够高"时成立**——如果一天只跑几百次请求,GPU 大部分时间在空转,自部署反而更贵。 3. **能力算天花板**:如果业务强依赖某个闭源旗舰模型的推理能力(复杂 Agent、长链推理、多步规划),自部署的中小开源模型可能达不到效果,此时"自部署省钱"是伪命题——效果不达标,省下的都是白省。 ### Q:自部署时,"部署"的到底是什么东西? A:结论先行——**你部署的不是"一个模型文件",而是"模型权重 + 推理引擎 + 服务化外壳"三件套,外加一套围绕它的运维体系。** 拆开看:  *图:本地推理部署栈:外壳、推理引擎、权重与硬件驱动* ```text ┌────────────────────────────────────┐ 业务 / 网关 ────▶│ 服务化外壳(HTTP Server) │ │ - OpenAI 兼容 /v1/chat/completions │ │ - 鉴权、限流、排队、指标暴露 │ ├────────────────────────────────────┤ │ 推理引擎(Runtime) │ │ - 调度:批处理、KV Cache 管理 │ │ - Kernel:Attention / GEMM 加速 │ │ - 并行:TP / PP / EP │ ├────────────────────────────────────┤ │ 模型权重(Weights) │ │ - 原始精度 / 量化后权重 │ │ - tokenizer / config 等元文件 │ ├────────────────────────────────────┤ │ 硬件与驱动:GPU / 驱动 / CUDA │ └────────────────────────────────────┘ ``` - **权重(Weights)**:模型的参数矩阵,是真正的"知识"载体;量化就是在这里做文章。 - **推理引擎(Inference Engine)**:把一次请求翻译成 GPU 上的一串算子调用。KV Cache 管理、批处理调度、算子融合都在这一层。**同一个模型换引擎,吞吐可能差出数倍**,所以引擎选型比模型选型更影响成本。 - **服务化外壳(Serving Layer)**:把引擎包成 HTTP 服务,负责协议、鉴权、并发控制、可观测性。vLLM 自带的 OpenAI 兼容 server 就属于这一层。 ### Q:一张 GPU 上能跑多大的模型?先看哪几个数? A:结论先行——**决定"能不能跑"的不是参数量本身,而是"权重占用 + KV Cache + 激活 + 框架开销"是否小于可用显存;决定"跑得快不快"的则是显存带宽(memory bandwidth),而不是算力(TFLOPS)。** 大模型推理的 decode 阶段(逐 token 生成)几乎全是访存密集型(memory-bound):每生成一个 token,都要把整个模型的权重从显存里读一遍。因此: - **显存容量**决定"能不能装下"; - **显存带宽**决定"每秒能吐多少 token"; - **算力**主要在 prefill 阶段(处理输入、以矩阵乘法为主)起作用。 一个定性的判断:模型权重占用的显存大致等于"参数量 × 每参数占用字节数"。FP16/BF16 是 2 字节/参数,FP8/INT8 是 1 字节/参数,INT4 约为 0.5 字节/参数。再加上 KV Cache、激活、框架预留,实际可用显存必须留出余量。**具体数字必须实测**,因为不同引擎、不同 batch、不同上下文长度差异很大。 > 提示:所有"某某模型需要多少 GB 显存"的说法都必须附带前提(精度、上下文长度、并发数、引擎版本),否则没有参考意义。 ## 二、推理引擎选型 ### Q:vLLM 为什么快?PagedAttention 和连续批处理到底是什么? A:结论先行——**vLLM 快在两件事:用 PagedAttention 把 KV Cache 像操作系统的虚拟内存分页一样管理,消掉了显存碎片与预留浪费;用连续批处理(Continuous Batching)把批的粒度从"整个请求"降到"每个 decode step",让 GPU 几乎没有空闲等待。** 先解释两个术语: - **KV Cache(键值缓存)**:自回归生成时,把已经算过的 Key/Value 张量缓存下来,避免每一步重算。代价是显存占用随"上下文长度 × 并发序列数"增长。 - **PagedAttention**:把 KV Cache 切成固定大小的块(block),用类似虚拟内存页表的映射来管理,逻辑上连续的序列在物理显存里可以不连续,从而支持按需分配、跨请求共享前缀、显著减少内部碎片。 传统静态批处理(static batching)的问题: ```text 静态批处理:一个 batch 里所有请求一起开始、一起结束 请求 A(短) ██░░░░░░░░░░░░ 必须等 B、C 结束才能释放槽位 请求 B(长) ████████████████ 请求 C(中) ██████░░░░░░░░ ↑ 空转的槽位被浪费,GPU 利用率低 连续批处理:每一步结束后,完成的序列立即退出,新请求立即补位 step: 1 2 3 4 5 6 7 8 A ██ ← 短请求很快返回 B ████████████████ C ██████ D ██████████ ← 新请求随时插入 ↑ 槽位几乎不空转 ``` 关键点与适用边界: - 连续批处理提升的是**吞吐**(tokens/s),对单条请求的**延迟**帮助有限,高负载下甚至会推高单条延迟(因为要和别人抢算力)。 - PagedAttention 的显存节省在**变长请求、大量共享 System Prompt** 的场景收益最大;如果所有请求长度都一样,收益会明显变小。 - vLLM 以**吞吐优先**为设计目标,适合"高并发 + 可接受秒级延迟"的在线服务。 ### Q:TGI、Ollama、llama.cpp、TensorRT-LLM 各自的定位是什么? A:结论先行——**按部署形态分:Ollama 是"个人与边缘的一键本地方案",llama.cpp 是"没有 GPU 也要跑"的底层引擎,vLLM / TGI 是"服务器上多并发跑"的生产引擎,TensorRT-LLM 是"在 NVIDIA 上把吞吐榨干"的性能上限方案。** | 引擎 | 底层 / 血统 | 强项 | 弱项 | 典型场景 | |---|---|---|---|---| | **vLLM** | Python + 自研 kernel,PyTorch 生态 | PagedAttention、连续批处理、前缀缓存、OpenAI 兼容 API、量化支持广、社区迭代快 | 长尾算子与新模型支持偶有滞后;高并发下需调优调度参数 | 服务端主力引擎、企业私有化平台 | | **TGI** | Hugging Face 官方 | 与 HF 生态贴合、连续批处理、张量并行、指标完善 | 模型覆盖面与量化选项不如 vLLM 丰富 | 已用 HF 全家桶、求稳的场景 | | **Ollama** | 基于 llama.cpp 封装 | 安装即用、模型拉取像 `docker pull`、Modelfile 定制、CPU/GPU 混合 | 高并发能力弱,主要用于单机;不适合做核心在线服务 | 开发者本机、边缘设备、Demo、内网小工具 | | **llama.cpp** | C/C++,GGUF 格式 | 纯 CPU 可跑、低比特量化最成熟、跨平台(macOS / ARM / 嵌入式) | 服务化能力需自己封装;多卡扩展弱 | 无 GPU 环境、Apple Silicon、端侧 | | **TensorRT-LLM** | NVIDIA 编译式 | 编译出针对目标卡的 engine,吞吐与延迟上限高,支持 in-flight batching | 编译结果绑定卡型号与软件版本、迁移成本高、调试门槛高 | 追求极致性能的大规模 NVIDIA 部署 | | **SGLang**(补充) | RadixAttention 前缀复用 | 多轮对话、前缀高度重复场景吞吐表现好 | 生态相对较新 | 结构化输出、多轮对话密集场景 | 选型建议(按场景查,不必背): - 只有一张消费级卡或笔记本 → **Ollama**;Apple Silicon 或纯 CPU → **llama.cpp / Ollama**。 - 服务器多卡、要稳定的在线服务 → **vLLM**(首选)或 **TGI**。 - 已大规模使用 NVIDIA、有专门性能团队 → 评估 **TensorRT-LLM**。 - 只做原型验证 → 哪个装得快用哪个,别过度设计。 ### Q:Ollama 和 vLLM 是二选一吗? A:结论先行——**不是。它们面向不同环节,可以共存:Ollama 负责开发机上的快速验证,vLLM 负责线上集群的正式服务。** 但要注意**模型格式不同**:Ollama 走 GGUF,vLLM 主要吃 Hugging Face 的 safetensors 权重(对部分量化格式也有支持,具体需结合版本确认)。这意味着"本地用 Ollama 调好的模型"不能直接搬上 vLLM,需要重新准备权重与量化产物。工程上通常约定:开发环境与生产环境使用**同一份 HF 权重 + 同一份量化产物**,只在引擎上区分,避免"本地好用、线上不一样"。 ## 三、量化:用精度换显存和带宽 ### Q:GPTQ / AWQ / GGUF / FP8 到底差在哪? A:结论先行——**它们不在同一个维度上:GPTQ 和 AWQ 是"权重量化算法",GGUF 是"文件格式与配套量化方案家族",FP8 是"一种低精度数值类型"。理解它们的关键是把"量化什么、多少比特、跑在什么硬件上"这三个问题拆开。** | 方案 | 本质 | 量化对象 | 常见位宽 | 硬件倾向 | 主要特点 | |---|---|---|---|---|---| | **GPTQ** | 训练后量化(PTQ)算法 | 权重,逐层、分组量化 | 4bit(也有 3bit / 8bit) | GPU | 需要校准数据集,用近似二阶信息最小化量化误差;出现早、生态广 | | **AWQ** | PTQ 算法,激活感知 | 权重 | 4bit | GPU | 依据激活幅值给"重要通道"加缩放保护,通常比朴素量化更抗精度损失 | | **GGUF** | 文件格式 + 量化档位家族 | 权重,不同张量可用不同位宽 | 2~8bit(Q4_K_M 等档位) | CPU / Apple Silicon / 低显存 GPU | llama.cpp 生态;采用混合量化,关键张量保留更高精度 | | **FP8** | 数值类型(E4M3 / E5M2) | 权重与激活(W8A8) | 8bit | 新一代 NVIDIA GPU | 精度明显优于 4bit,显存与速度收益可观,强依赖硬件与框架支持 | | **INT8(如 SmoothQuant 类)** | PTQ | 权重 + 激活 | 8bit | GPU | 精度损失小,但压缩比不如 4bit | | **BitsAndBytes(NF4 / INT8)** | 运行时量化 | 权重 | 4bit / 8bit | GPU | 上手最简单(改加载参数即可),但推理速度通常不如专用 kernel | 关键区分点: 1. **"只量化权重" vs "权重 + 激活都量化"**:GPTQ / AWQ 主要量化权重,激活仍是 FP16;FP8 / INT8 常同时量化激活(W8A8),对 kernel 实现要求更高。 2. **"算法" vs "格式"**:GGUF 是格式,内部可以用不同量化方法;`Q4_K_M` 是一个档位名,本质是对不同张量采用混合位宽。 3. **"通用" vs "专用"**:FP8 的收益高度依赖硬件架构与框架版本(**需结合版本确认**);GPTQ / AWQ 在多数消费级卡上都能跑。 ### Q:量化档位怎么选? A:结论先行——**优先选 8bit(FP8 / INT8),其次选 AWQ 或 GPTQ 的 4bit;只有在显存或硬件极度受限时才降到更低比特(GGUF 的 Q4 及以下),并且必须做效果回归,不能只看"服务跑起来了"。** 选择路径:  *图:显存不够时依次考虑 FP8、INT8、AWQ、GGUF* ```text 显存够装 FP16 / BF16 吗? ├── 够 → 先用 FP16 / BF16,别急着量化(精度最稳) └── 不够 ├── 硬件支持 FP8(新一代 GPU)且框架支持 → 先试 FP8 ├── 显存差得不多 → 试 INT8 / W8A8 ├── 显存差得多(约一半) → 试 AWQ 4bit 或 GPTQ 4bit └── 只有 CPU / 显存极小 / 要跑在 Mac 上 → GGUF Q4_K_M 起步, 仍不够再往 Q3 / Q2 降,同时接受明显的能力下降 ``` 几条经验(都要用你自己的评测集验证,不能直接当结论): - **4bit 通常处在"甜点区"**:显存省得多,精度损失在多数任务上可接受,但对**数学推理、代码生成、长链逻辑**这类任务更敏感。 - **位宽越低,损失越"非均匀"**:可能出现"平时看不出来,一遇到需要严谨推理就塌"的现象,所以只跑几个闲聊用例是测不出问题的。 - **不同算法不能只比位宽**:同为 4bit,AWQ / GPTQ 与"朴素 round-to-nearest"的差距可能很大,应优先选择有成熟 kernel 支持的方案。 - **量化后必须重新压测**:吞吐、延迟、显存占用都要重新测量,不能沿用 FP16 时代的压测结论。 ### Q:量化会让模型"变傻"吗? A:结论先行——**会,但"变傻"通常表现为"分布偏移"而不是"能力整体等比下降":通用对话几乎无感,特定任务(数学、代码、结构化输出、长上下文)会明显退化。** 因此量化必须配套**回归评测集**:把业务关键用例固化成"量化验收集",每次换档位都跑一遍对比。不要用"看着还行"来验收量化,那是事故发生的前奏。 ## 四、显存估算:把账算清楚 ### Q:显存被谁吃掉了? A:结论先行——**显存 = 权重 + KV Cache + 激活与临时缓冲 + 框架与 CUDA 上下文开销。权重可以算,KV Cache 必须按"上下文长度 × 并发"算,激活与框架开销只能靠实测留余量。**  *图:显存占用构成:固定开销、激活缓冲、KV Cache 与权重* ```text 显存占用构成(定性) ┌────────────────────────────────────────────────┐ │ 框架 / CUDA 上下文 / 通信缓冲 ← 固定开销,最易被忽略 │ ├────────────────────────────────────────────────┤ │ 激活与临时缓冲(prefill 阶段峰值最高) │ ├────────────────────────────────────────────────┤ │ KV Cache ← 随 上下文长度 × 并发序列数 线性增长 │ ├────────────────────────────────────────────────┤ │ 模型权重 ← 参数量 × 每参数占用字节数 │ └────────────────────────────────────────────────┘ ``` 权重部分的计算思路(**只给方法,不给具体数字**): ```text 权重显存 ≈ 参数量 × 每参数占用字节 FP16 / BF16 → 2 字节 FP8 / INT8 → 1 字节 INT4 / AWQ / GPTQ 4bit → 约 0.5 字节 (实际略高:量化 scale / zero 等元数据有额外开销) 再叠加 tokenizer、embedding 与输出层、临时缓冲等,实际必须留余量。 ``` KV Cache 的计算思路(**这是最容易算错的一环**): ```text 单个 token 的 KV Cache ≈ 2 × 层数 × KV 头数 × 头维度 × 每元素字节数 (乘 2 是因为 Key 和 Value 各存一份) 总 KV Cache ≈ 单 token KV Cache × 序列长度 × 并发序列数 注意:这里要用 KV 头数,而不是注意力头数。 使用 GQA / MQA 的模型,KV 头数远小于注意力头数, 使 KV Cache 显著变小 —— 这是决定长上下文能力的关键设计之一。 ``` ### Q:上下文长度和并发怎么影响显存? A:结论先行——**在不启用任何缓存复用的前提下,KV Cache 与"上下文长度 × 并发数"近似成正比,因此"支持超长上下文"和"支持高并发"这两件事往往不能同时满足。** 一个**计算思路**的示意(数字为占位,请代入自己模型的真实参数): ```text 设:单 token KV Cache = S,目标上下文长度 = L,最大并发数 = C 则 KV Cache 需求 ≈ S × L × C 场景 A:L 大、C 小 → 长文档问答、单用户长会话 场景 B:L 小、C 大 → 高并发短问答(客服机器人) 场景 C:L 大、C 大 → 最易爆显存,必须靠量化 + 前缀缓存 + 排队限流组合治理 ``` 工程含义: - 部署时不要只看"模型能不能加载进显存",要按**目标并发 × 目标上下文**反推显存,再决定是否量化、量化到什么档位。 - 引擎通常提供"最大并发序列数"和"最大模型长度"两个参数,**这两个必须一起调**,只调一个很可能直接显存不足(OOM)。 - **不要在业务高峰开放最高上下文**:更稳妥的做法是动态控制上下文上限,让超长请求单独排队,避免少数超长请求把整个 KV Cache 池占满(本质是资源隔离思路)。 - 显存不够时的处理顺序建议为:量化 → 降上下文上限 → 降并发上限 → 减小预分配 → 升配或加卡。 ## 五、关键性能指标与优化手段 ### Q:衡量推理服务要看哪几个指标? A:结论先行——**至少看四个:首 Token 延迟(TTFT)、单 token 输出延迟(TPOT / ITL)、吞吐(tokens/s)、并发上限;它们互相牵制,必须一起看,只看一个必然误判。** | 指标 | 全称 | 含义 | 用户体验关联 | |---|---|---|---| | **TTFT** | Time To First Token | 从发请求到第一个 token 返回的耗时 | 用户"点下去之后多久有反应" | | **TPOT / ITL** | Time Per Output Token / Inter-Token Latency | 生成阶段相邻 token 的间隔 | 用户感觉"吐字快不快" | | **吞吐** | Throughput | 单位时间生成的总 token 数 | 决定单位成本与能承载的流量 | | **并发** | Concurrency | 同时在处理的请求数 | 决定能否抗住高峰 | | **排队时间** | Queue Time | 请求在队列中等待的时间 | 高负载下真正的体验杀手 | 一个非常重要的认知:**TTFT 主要受 prefill(处理输入)影响,而 prefill 与 decode 在同一个 GPU 上抢资源。** 因此: - 输入很长(例如 RAG 塞了大段上下文)→ TTFT 高; - 输出很长 → 总时长高,但 TPOT 可能依然稳定; - 两者都要快 → GPU 必须在"处理新请求的输入"和"继续生成老请求的输出"之间切分算力,这正是 **chunked prefill(分块预填充)** 要解决的问题。 ### Q:有哪些手段能把吞吐拉起来? A:结论先行——**按投入产出比排序:连续批处理(引擎自带)> 前缀缓存 > 合适的量化 > 分块预填充 > 张量并行加卡 > 投机解码。每一条都有适用边界,不能无脑堆。**  *图:推理优化手段速查:手段、解决的问题与代价边界* ```text 优化手段速查 ┌──────────────────┬────────────────────────────────┬──────────────────────────┐ │ 手段 │ 解决什么 │ 代价 / 边界 │ ├──────────────────┼────────────────────────────────┼──────────────────────────┤ │ 连续批处理 │ GPU 空转 │ 高负载下单请求延迟上升 │ │ 前缀缓存 │ 重复 System Prompt 反复 prefill │ 占用显存换时间 │ │ 分块预填充 │ 长输入阻塞其他请求 │ 调度复杂,参数需调 │ │ 量化 │ 显存不足 / 带宽瓶颈 │ 精度损失,需回归验证 │ │ 张量并行 TP │ 单卡装不下 / 想加速 │ 卡间通信开销,收益递减 │ │ 投机解码 │ 低并发场景降低延迟 │ 高并发下收益被摊薄 │ │ 请求排队与限流 │ 防止雪崩 │ 用户体验与稳定性的取舍 │ └──────────────────┴────────────────────────────────┴──────────────────────────┘ ``` 关键概念解释: - **前缀缓存(Prefix Caching)**:如果多个请求共享同一段前缀(同一套 System Prompt、同一段 RAG 上下文、多轮对话的前几轮),引擎可以复用这段前缀的 KV Cache,跳过重复的 prefill。**Chat 类应用几乎必然命中**,性价比很高。代价是它占显存,且需要引擎支持(vLLM 通过启动参数开启,**具体参数名需结合版本确认**)。 - **分块预填充(Chunked Prefill)**:把超长的 prefill 拆成多个小块,与 decode 交错执行,避免"一个超长输入把所有人卡住",改善长输入场景下 TTFT 的抖动。 - **投机解码(Speculative Decoding)**:用一个小模型(draft model)先猜几个 token,大模型一次并行校验,猜对的部分就"白赚"。**低并发、延迟敏感场景收益明显;高并发的吞吐优先场景收益有限。** - **张量并行(Tensor Parallelism, TP)**:把一层拆到多卡上协同计算。收益不是线性的(有卡间通信开销),一般先把单卡吃满,再考虑上多卡。 ### Q:第一版容量怎么估? A:结论先行——**不要用"单请求延迟 × 并发数"拍脑袋,要先用压测拿到"单卡在不同并发下的吞吐曲线",再用业务目标反推卡数。** 估算思路: ```text 1. 定义业务目标 - 峰值 QPS(每秒请求数) - 平均输入 token 数(含 RAG 检索上下文) - 平均输出 token 数 2. 压测取数(必须实测) - 单卡在并发 1 / 4 / 8 / 16 / 32 ... 下的吞吐与 TTFT / TPOT 曲线 - 找到"吞吐拐点":再加并发吞吐不再涨、延迟却快速上升的那个点 3. 反推卡数 峰值 token 吞吐需求 = 峰值 QPS × (平均输入 + 平均输出) 卡数 ≈ 峰值 token 吞吐需求 ÷ 单卡在目标延迟下的安全吞吐 再留 ≥ 30% 余量,用于突发流量、长尾请求、模型切换与故障冗余 4. 注意事项 - 长上下文请求会显著拉低平均吞吐,请按分位数(P95 / P99)输入长度计算,不要用均值 - 为超长请求预留单独的通道与限流策略 ``` > 提醒:**所有吞吐数字都必须来自你自己环境的实测**,因为模型、量化档位、引擎版本、GPU 型号、batch 配置都会显著改变结果。网上任何"某卡能跑多少 tokens/s"的数字,只能当作量级参考。 ## 六、部署与运维 ### Q:容器化部署要注意什么? A:结论先行——**推理服务的容器化不是"把 Python 环境塞进镜像",核心是三件事:镜像与宿主驱动版本的绑定、模型权重的挂载与缓存、健康检查语义的设计。**  *图:推理容器——镜像、权重挂载与宿主机依赖* ```text ┌────────────────────────────────────────────────────────────┐ │ 宿主机:GPU 驱动 + NVIDIA Container Toolkit(必需) │ │ ┌──────────────────────────────────────────────────────┐ │ │ │ 推理容器 │ │ │ │ - 镜像(引擎 + 依赖,版本锁定) │ │ │ │ - 挂载点 1:/models ← 权重目录(宿主机 / 共享存储) │ │ │ │ - 挂载点 2:模型缓存目录 ← 避免每次启动重新拉权重 │ │ │ │ - 环境变量:并行度、显存比例、上下文长度上限 │ │ │ │ - 端口:HTTP 服务端口 + 指标端口 │ │ │ └──────────────────────────────────────────────────────┘ │ │ 共享存储:NFS / 对象存储 / PVC(多副本共享同一份权重) │ └────────────────────────────────────────────────────────────┘ ``` 要点: - **驱动与 CUDA 版本要锁定**:容器内 CUDA 与宿主驱动存在兼容矩阵,**升级镜像前必须先在预发环境验证**(典型的"需结合版本确认"场景)。 - **权重不要打进镜像**:动辄几十 GB,镜像会变得不可分发。用挂载或启动时下载,并做好本地缓存。 - **启动时间要单独设计**:权重加载、CUDA 图捕获、kernel 编译都可能耗时。健康检查要区分"进程活着"与"能真正服务"两种状态。 - **镜像用固定 tag 或 digest**:生产不要用 `latest`,否则回滚不可复现。 ### Q:健康检查怎么设计才不坑? A:结论先行——**要分三层检查:进程存活(liveness)、可接受请求(readiness)、依赖健康(GPU / 权重 / 上游)。只检查端口是最常见的坑——进程活着但模型还没加载完,流量打进来只会 500。** ```text Liveness :进程是否卡死 / 死锁 → 失败则重启容器 Readiness :模型是否加载完成、能否处理请求 → 失败则摘除流量 Startup :启动是否超时(给足冷启动时间) → 避免被 liveness 误杀 依赖检查 :GPU 是否可访问、是否处于显存耗尽的边缘状态 ``` 最佳实践: - **readiness 要真的打一次轻量推理,或调用引擎自身的健康接口**,而不是只判断端口通不通。 - **启动探针的超时时间要给够**:大模型冷启动可能持续很久,容易触发 liveness 误重启,进而形成崩溃循环。 - **不要把"高负载导致的排队"当成不健康**:队列长不等于服务死了,此时摘流量会让其他副本被打垮(雪崩)。要区分"慢"和"坏"。 ### Q:多模型共存、GPU 调度怎么做? A:结论先行——**GPU 是容错性最差的资源:显存被占满就是硬 OOM,没有"换页"这种优雅退路。所以 GPU 调度要"按显存配额 + 独占优先",多模型共存要么分卡独占,要么用引擎自身的多模型加载能力,别指望资源超卖。** 常见模式: | 模式 | 做法 | 优点 | 缺点 | |---|---|---|---| | 一卡一模型(独占) | 每张卡跑一个模型实例 | 隔离性最好、性能可预期 | 利用率可能低,小模型占用大卡浪费 | | 模型分组共享 | 多个小模型共享一张卡 | 提升利用率 | 显存竞争、相互影响 | | 引擎内多模型 | 引擎按请求切换或同时加载多个模型 / LoRA | 省显存、切换快 | 依赖引擎能力,**需结合版本确认** | | 平台统一调度 | K8s + GPU 设备插件按显存与算力申请 | 统一治理、配额可控 | 需要平台能力,调度粒度通常仍是整卡 | 实践建议: - **按"显存需求 + 峰值并发"给模型分配配额**,不要按"平均利用率"分配。 - **给每个实例留安全余量**:显存打满的实例遇到长请求就会 OOM 重启,反而更浪费。 - **LoRA 多租户**是"多模型共存"的廉价方案:共享一个基座模型,为不同业务挂不同 LoRA,切换开销远小于加载整模型(支持度**需结合引擎版本确认**)。 ### Q:灰度与回滚怎么做? A:结论先行——**模型上线必须和代码上线一样走灰度,但额外多了"版本对比"这件事:新旧模型要能同时在线、按流量比例分流,并能一键切回。**  *图:90% 走 A、10% 走 B,按指标决定放量或回滚* ```text 流量 100% │ ├── 90% ──▶ 模型 A(当前稳定版) └── 10% ──▶ 模型 B(新版本 / 新量化档位,影子或小流量) │ ├── 技术指标:TTFT / TPOT / 错误率 / OOM 次数 ├── 业务指标:小流量用户反馈、离线评测集通过率 └── 达标则逐步放大比例;不达标立即回滚到 A ``` - **保留上一版权重与容器镜像**:回滚速度取决于"权重是否还在本地或共享存储",别让回滚变成"重新下载几十 GB"。 - **配置与权重解耦**:并行度、上下文上限、采样默认值等放在配置里,回滚只需改配置或切换逻辑模型名。 - **灰度要覆盖长尾**:小流量阶段别只挑短请求,要主动灌入长上下文与高并发,否则问题会在全量时才暴露。 ### Q:自部署怎么和模型网关配合? A:结论先行——**网关是"混合路由"的关键:对上层屏蔽"这个请求到底走自部署还是走 API",对下层做路由、降级、限流、计费与观测。**  *图:模型网关路由:自部署 vLLM 与两类云端 API 的分工* ```text ┌──────────────────────────────────┐ │ 模型网关 Model Gateway │ │ - 统一协议(OpenAI 兼容) │ │ - 鉴权 / 配额 / 限流 │ │ - 路由策略(见下) │ │ - 重试 / 降级 / 熔断 │ │ - 计费 / 日志 / 链路追踪 │ └───────────────┬──────────────────┘ │ ┌──────────────────────┼───────────────────────┐ ▼ ▼ ▼ 自部署 vLLM 集群 云端 API(旗舰模型) 云端 API(兜底 / 廉价) 主力、敏感数据、大流量 复杂推理、能力天花板 降级、突发溢出 ``` 常见路由策略: 1. **按数据敏感度路由**:带敏感字段或内网内容的请求强制走自部署;公开知识类走 API。 2. **按任务难度路由**:简单分类、抽取用自部署小模型,复杂推理路由到强模型(即"模型级联"),在成本与效果之间折中。 3. **按负载路由**:自部署集群队列积压超过阈值 → 溢出到云端 API,把 API 当作"弹性峰值容量"。这是"自部署 + API 混合"最实用的价值。 4. **按可用性降级**:自部署故障 → 自动降级到 API,保住可用性,同时告警。 5. **统一逻辑模型名**:上层永远请求 `chat-default` 这类逻辑名,路由细节藏在网关里,避免业务代码硬编码模型名。 注意:**网关自身是有状态的(配额、路由表、缓存),必须做成无状态多副本 + 配置中心下发**,否则它会成为新的单点。同时要防止"降级风暴"——API 侧的限流与成本也要在网关里兜住。 ## 七、动手:vLLM 的 Docker 启动与 OpenAI 兼容调用 先说明要解决的问题:**我们要在一台有 GPU 的机器上,用容器启动一个 vLLM 服务,暴露 OpenAI 兼容接口,再用标准 OpenAI 客户端调用它**。这样业务代码基本不用改,只换 `base_url` 与模型名。 ### 步骤 1:启动容器 ```bash # 说明:把宿主机模型目录挂载进容器,并暴露 8000 端口 # --gpus all 依赖宿主机已安装 NVIDIA Container Toolkit docker run --rm --gpus all \ -p 8000:8000 \ -v /data/models:/models \ vllm/vllm-openai:latest \ --model /models/Qwen2.5-7B-Instruct \ --served-model-name chat-default \ --dtype auto \ --tensor-parallel-size 1 \ --max-model-len 8192 \ --gpu-memory-utilization 0.90 \ --enable-prefix-caching ``` 说明与边界: - `--model` 既可以是本地路径,也可以是 Hugging Face 仓库名(后者需要能访问外网或配好镜像源)。 - `--tensor-parallel-size` 要与实际 GPU 数量匹配。 - `--max-model-len` 直接决定 KV Cache 上限,**开太大可能启动即失败(显存不足)**,要按前面的显存估算来定。 - `--gpu-memory-utilization` 控制引擎可占用的显存比例,**调太高容易 OOM,调太低浪费卡**。 - `--enable-prefix-caching` 打开前缀缓存,Chat 场景建议开启。 - 以上参数名与可用取值**需结合所用 vLLM 版本确认**,不同版本会有增删。 ### 步骤 2:确认服务可用 ```bash # 查看当前可用的模型(OpenAI 兼容接口) curl -s http://localhost:8000/v1/models # 发一次最小请求,验证 chat 接口 curl -s http://localhost:8000/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "chat-default", "messages": [{"role": "user", "content": "用一句话解释什么是 KV Cache"}], "temperature": 0.2, "max_tokens": 128 }' ``` ### 步骤 3:用 Python 调用(复用 OpenAI SDK) 解决的问题:**让业务代码在"自部署"和"云端 API"之间无缝切换。** ```python from openai import OpenAI # 只改 base_url 与 api_key,业务调用方式完全不变 client = OpenAI( base_url="http://vllm-gateway:8000/v1", api_key="your-api-key", # 自部署可填占位值;生产建议在网关侧统一鉴权 ) def ask(question: str) -> str: resp = client.chat.completions.create( model="chat-default", messages=[ {"role": "system", "content": "你是一个严谨的技术助手,不知道就说不确定。"}, {"role": "user", "content": question}, ], temperature=0.2, max_tokens=512, stream=True, timeout=60, # 长上下文请求耗时可能较长,显式设置超时 ) chunks = [] for event in resp: delta = event.choices[0].delta.content if delta: chunks.append(delta) return "".join(chunks) ``` 关键点: - **流式(`stream=True`)在自部署上尤其重要**:它不减少服务端计算量,但能显著改善"首字延迟"的主观体验,也让客户端能在首个 chunk 上做超时判断。 - **超时与重试要显式设置**:长上下文请求可能耗时几十秒,默认超时容易误杀;同时要避免对生成类请求做无脑重试(可能产生重复计费或重复副作用)。 - **不要把 `max_tokens` 设得过大**:它直接影响单请求占用的 KV Cache 与总时长。 ### 步骤 4(可选):Kubernetes 部署片段 ```yaml apiVersion: apps/v1 kind: Deployment metadata: name: vllm-chat spec: replicas: 2 selector: matchLabels: { app: vllm-chat } template: metadata: labels: { app: vllm-chat } spec: containers: - name: vllm image: vllm/vllm-openai:latest # 生产请使用固定 tag 或 digest args: - "--model=/models/Qwen2.5-7B-Instruct" - "--served-model-name=chat-default" - "--max-model-len=8192" - "--enable-prefix-caching" ports: - containerPort: 8000 resources: limits: nvidia.com/gpu: "1" # 依赖集群 GPU 设备插件 readinessProbe: httpGet: { path: /v1/models, port: 8000 } initialDelaySeconds: 60 # 冷启动必须给足时间 periodSeconds: 10 volumeMounts: - { name: models, mountPath: /models } volumes: - name: models persistentVolumeClaim: { claimName: models-pvc } ``` 要点:**`initialDelaySeconds` 必须覆盖模型冷启动时间;`nvidia.com/gpu` 的申请粒度通常是整卡,"显存切分"要靠引擎参数或 MIG 等硬件特性(可用性需结合硬件与集群版本确认)。** ## 八、工程实践与踩坑清单 | 症状 | 可能原因 | 排查思路 | 处理 | |---|---|---|---| | 启动即 OOM / 加载到一半崩 | `--max-model-len` 或显存比例设得过大;权重精度过高 | 看启动日志中的显存分配;先降上下文再降利用率 | 量化、降上下文、降并发上限、加卡 | | 跑一段时间后 OOM | KV Cache 池被长请求吃满;并发上限过高 | 观察并发数、平均上下文长度、队列深度 | 限制单请求最大长度、限制最大并发、开前缀缓存、超长请求单独排队 | | 首 Token 特别慢 | 输入极长(RAG 塞太多)、prefill 抢占、未开分块预填充 | 区分 TTFT 与 TPOT,统计输入 token 分布 | 精简 RAG 上下文、开分块预填充、开前缀缓存、超长输入单独限流 | | 吞吐上不去、GPU 利用率低 | 批处理未生效、并发太低、请求过短 | 看 GPU 利用率与 batch size,逐步加压 | 提高并发、确认连续批处理生效、避免频繁冷启动 | | 并发一压就雪崩 | 无排队、无超时、无限流,任务无限堆积 | 观察队列长度与超时比例 | 网关限流 + 队列上限 + 快速失败 + 溢出到 API | | 量化后效果明显变差 | 位宽过低 / 不适合该任务 / 校准数据不匹配 | 用固定评测集对比 FP16 与量化版本 | 改 AWQ / GPTQ、升到 8bit、关键业务不量化 | | 上下文超限报错 | 输入 + 输出超过了 `max-model-len` | 打印实际 token 数 | 客户端截断或摘要;服务端明确报错,不要静默截断 | | 多租户互相影响 | 共享实例且无隔离 | 看不同租户的延迟分布 | 关键租户独占实例,或按租户做配额与限流 | | 升级后行为变了 | 引擎 / 驱动 / 量化 kernel 版本变化 | 保留旧镜像与配置做 A/B | 锁版本 + 灰度 + 可回滚 | | 服务"活着但不能用" | 健康检查只看端口 | 手工打一次推理请求 | readiness 做真实推理探针;区分"慢"与"坏" | 几条容易被忽略但很疼的经验: 1. **显存是硬约束,宁可多留余量也不要卡满**:卡满的实例遇到长尾请求就会崩,重启又要几十秒到几分钟,反而拉低整体可用性。 2. **长上下文是"资源放大器"**:一个超长上下文请求的占用可能是普通请求的几十倍,**必须单独限流或单独路由**,否则正常用户会被拖死。 3. **压测要按真实流量分布**:用固定短 prompt 压出来的漂亮数字,在生产的"长上下文混合流量"下会大幅缩水。压测数据必须包含 P95 / P99 输入长度。 4. **一切参数都要留档**:镜像版本、引擎版本、模型权重版本、量化档位、启动参数、GPU 型号,缺一样后续就复现不了线上问题。 5. **先解决"能不能用",再解决"快不快"**:不少团队在精度尚未验收时就开始疯狂优化吞吐,最后效果不达标,前面的折腾全部作废。 ## 小结 - **决策**:合规敏感、大流量、需要深度可控 → 自部署;探索期、非敏感数据、需要最强能力 → API;大流量且峰值突发 → 混合(自部署为主 + API 溢出)。 - **选型**:服务端优先 vLLM / TGI;端侧与无 GPU 场景用 Ollama / llama.cpp;追求极致性能再评估 TensorRT-LLM。 - **量化**:默认不量化,不够再降;4bit 是甜点区、8bit 更稳;量化必须配套回归评测集。 - **容量**:显存 = 权重 + KV Cache(按上下文 × 并发算)+ 激活与框架开销;吞吐必须实测,并按分位数输入长度估算。 - **指标**:TTFT / TPOT / 吞吐 / 并发 / 排队时间要一起看;优化优先级 = 连续批处理 > 前缀缓存 > 量化 > 分块预填充 > 张量并行。 - **运维**:锁版本、权重外置、真实探针、灰度可回滚、网关统一路由与降级。 ## 思考题 1. 在你的业务里,如果只能保留一个指标来决定是否扩容,你选 TTFT 还是吞吐?为什么? 2. 一个 Chat 应用的 System Prompt 有 2000 token、并发 50。开启前缀缓存前后,KV Cache 占用与 prefill 计算量的变化分别落在什么量级?请给出估算思路而不是具体数字。 3. 为什么"显存带宽"比"算力"更决定 decode 阶段的速度?如果换成超长输入的 prefill 阶段,这个结论还成立吗? 4. 请设计一个"自部署 + 云端 API"的混合路由:当自部署集群排队时间超过 3 秒时溢出到云端。需要哪些指标、哪些配置?如何防止"降级风暴"? 5. 量化到 4bit 后,数学题准确率明显下降但闲聊无感。你会如何定位这是"位宽问题"还是"算法问题"?又该如何向业务方解释并设定验收标准?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入