🏠 总目录📚 本教程 推理服务化 ← →

AI基础设施 · 20

实例出现在注册表里,为什么还不能接新请求?

路由要面对真实可服务的模型实例。SLO、就绪检查、租约发现与排空各有责任,注册存在不能代替就绪证据。

读完能判断:用 SLO、就绪和排空状态判断真实可服务容量。

📑 本页目录(点开跳转)

20 · 推理服务化

⏱ 42 分钟 | ⭐ 从"能跑"到"能上线"


🎯 一句话

前面五章讲的是怎么让单机跑得快。 这一章讲怎么把它变成一个能承诺 SLO、能扛住流量、能算清账的服务。


🧭 一、先选引擎:按模型、硬件与服务负载比较

第 15 章把推理优化的第一步写成了"用专门的推理引擎,别拿 generate() 上生产,光这一步常常 5-10 倍", 但没说换成哪个。这一节补上。

⚠️ 先说时效:推理框架半年一变,功能互相抄,性能榜半年就翻篇。 所以下面只写定位和取舍判据,不写版本号、不写 API、不写 benchmark 数字。 记结构,别记名字。

七个常见选项,各自的位置

引擎 一句话定位 最擅长 部署代价
vLLM ⭐ 通用的默认选项,覆盖多种模型与量化格式,具体支持应核对版本 通用在线服务 低:装上给一条命令,直接是 OpenAI 兼容接口
SGLang ⭐ 面向复杂调用结构的引擎,核心是 RadixAttention 前缀高度重复的负载:Agent、多轮、多候选、约束解码 低,和 vLLM 同量级
TensorRT-LLM NVIDIA 官方的极致性能路线,可使用不同执行路线,预构建 engine 不是所有后端的共同前提 单一模型、形状稳定、把最后一滴性能榨出来 ⚠️ 需核对版本、执行后端、模型兼容性与准备成本;不能把所有路线都概括成换配置必重建 engine
TGI HuggingFace 的服务化方案,和 HF 生态贴得最紧 模型来源、权限、工具链都已经在 HF 那一套里的团队 低
LMDeploy 国内团队做的引擎,提供模型部署与量化路径,具体兼容性按版本核对 主力模型是国内开源系列时 低
llama.cpp ⭐ C++ 路线,没有 NVIDIA 卡也能跑(CPU / Apple Silicon / 各种边缘设备),GGUF 格式的发源地 本地、离线、消费级硬件 低,提供 server,仍需补齐部署侧鉴权、配额与运维
Ollama llama.cpp 之上的一层"能用就行"的包装,一条命令拉模型就跑 ⭐ 本地开发、demo、个人使用 极低

其实只有四个问题要问

流程图

① 你要的是"跑起来",还是"扛住流量"?
跑起来→Ollama(或 LM Studio)→⭐ 到此为止,别往下看了
② 有 NVIDIA 卡吗?
没有(CPU / Mac / 边缘)→llama.cpp + GGUF 路线
③ 模型和硬件会变吗?
不变,而且延迟/成本已经是核心 KPI→TensorRT-LLM
(⚠️ 需核对具体版本/后端的准备、加载与预热代价)
会变(还在选模型、还在调)→别碰编译型的
④ 你的请求之间前缀重合度高吗?
高(Agent、多轮、大量共享 few-shot)→SGLang
一般→vLLM ⭐ 默认答案

⭐ TGI 和 LMDeploy 属于"生态贴合"型的选择: 不是因为它们更快,而是因为你已经在那套生态里了,接起来省事。 选型的时候,"团队已经会什么"是一个合法的、而且经常被低估的判据。

⚠️ 一个反直觉但很重要的建议:先别去挑性能最高的那个。 主流引擎之间的差距通常在 20-50% 这个量级; 而你有没有开对连续批处理、前缀缓存、量化(第 17、16、18 章),差的是几倍。 💥 大部分"框架 A 比 B 快 3 倍"的评测,拆开看都是配置没对齐 —— 一边开了连续批处理一边没开,那测的不是引擎。

顺序:先把配置调对,再考虑换引擎。

再分清谁负责哪一层:调用外部 API、自行部署已有引擎、扩展已有引擎、自研核心运行时,是四种不同投入;自己部署 vLLM 不等于自研引擎。先列必须的模型、硬件、调度与服务能力,核对具体版本并测出差距,再评估现有方案及扩展是否可行;例如自定义模型注册可能只需扩展,不能预设某项能力今天仍不受支持。只有确认关键缺口后,才给自研原型预算,同时核算正确性、版本兼容、升级维护与运维成本。比较时固定模型、精度与质量要求、输入/输出长度分布、硬件、并发及到达模式、SLO;没有统一的 QPS 或收入门槛,也不能先许诺提速倍数。

🌳 RadixAttention:把前缀共享从"一条"推进到"一棵树"

这个机制值得单独讲,因为它和你已经学过的东西是同一条线上的下一步。

第 16 章的前缀缓存解决的是"所有请求共享同一个系统提示词", 第 17 章的块共享让这件事在实现上几乎免费。 但它们的匹配方式是线性的:从头比对,命中一条前缀。

而真实的 Agent 负载长这样:

真实 Agent 负载不是一条链,是一棵树 系统提示词 2000 token 所有请求共用 用户问题 A 用户问题 B 第一次分叉 工具调用 → 结果 1 工具调用 → 结果 2 继续追问 第二次分叉 ⭐ 沿树往下走,能匹配多远就复用多远 —— 只有分叉之后的部分才要重新算 ⚠️ 缓存满了只能淘汰叶子:父节点还被别的分支用着
线性的前缀缓存只认得"从头开始一模一样的那一段";RadixAttention 把 KV Cache 的索引直接组织成一棵基数树,分叉点是自动被发现的,不需要你告诉它哪些请求该配对。

RadixAttention 做的就是:把 KV Cache 的索引组织成一棵基数树(radix tree,也就是压缩过的前缀树)。

算一算

· 树上每条边 = 一段 token 序列,对应一批 KV 块

· 新请求来了,沿树往下走,能匹配多远就复用多远

→ 只有【分叉之后】的那部分才需要重新 Prefill

· 缓存满了按 LRU 淘汰【叶子】

⭐ 只淘汰叶子,因为父节点还被别的分支用着

线性前缀缓存(第 16、17 章) RadixAttention
匹配结构 线性:从头比对,命中一条前缀 树:分叉点自动被发现
淘汰 按块 LRU 按叶子 LRU,感知父子依赖
收益最大的场景 固定的系统提示词 多轮 + 分叉:Agent、多候选生成、树搜索、共享 few-shot ⭐

⭐ 两者不是互斥的,思路完全一样("算过的 KV 别重算"), RadixAttention 是它在数据结构上的推进,而且各家引擎都在往这个方向收敛。

⚠️ 所以真正的判断依据不是"哪个框架有这个功能", 而是【你的请求之间到底有多少共享前缀】 —— 一点都不共享,两者都白搭。 这件事你可以在换引擎之前就自己统计出来。

💡 顺带一条容易漏掉的能力:如果你要在一个基座上热挂多个 LoRA 适配器 (多租户各自微调一份),主流引擎大多支持这类"多 LoRA 服务" —— 它省的是"每个租户开一份完整实例"的显存。有这个需求的话,选型时要单独确认。


📏 二、先定 SLO,再谈优化

先拿一次请求对表

同样是「回复慢」,有时屏幕一开始就是空的,有时第一段很快、后面却卡住。沿用第 15 章的两阶段模型:Prefill 读完提示、建立 KV Cache 并产出首个 token 所需的分数,后续 Decode 沿着已有序列继续生成。服务还要接收、排队和发送结果。先对齐客户端与服务端观测的事件,才知道该调哪一段。

0 → 10 ms客户端发出请求,网关在 10 ms 入队
10 → 40 ms等待执行槽位
40 → 90 msPrefill 与首 token 采样
100 → 190 ms客户端在 100、120、180、190 ms 收到 4 个输出 token

这是教学用的对齐时间线,假设每个内容事件只交付一个 token。线上没有统一时钟时,各侧用自己的单调时钟算区间,再用请求 ID 关联;实际流可能把多个 token 合并在一个块里,空块、角色字段或流结束标记也不能当成输出 token。

请求 A:把三个计时起止点写清楚
想知道什么取哪些时刻,怎么算
首 token 时间(Time To First Token,TTFT)从发出请求到收到首个输出 token:100 − 0 = 100 ms。本例分成 10 ms 接收、30 ms 排队、50 ms Prefill 与采样、10 ms 首 token 发送。
输出 token 间隔(Inter-Token Latency,ITL)相邻到达时刻之差:120 − 100 = 20 ms,180 − 120 = 60 ms,190 − 180 = 10 ms。中间卡了 60 ms。
平均每输出 token 时间(Time Per Output Token,TPOT)按本章每请求口径,把首个 token 之后的时长摊给剩余输出。输出数 N = 4,一共有 N − 1 = 3 个间隔:(190 − 100) ÷ 3 = (20 + 60 + 10) ÷ 3 = 30 ms/token。

从发送到末 token 用了 100 + 3 × 30 = 190 ms。如果流结束标记在 200 ms 到达,则完整流耗时是 200 ms。只有一个输出 token 时可以算 TTFT,却没有可平均的间隔;没有输出就超时的请求要记失败。压测工具可能把 ITL 定义成每块归一化的间隔,比较前先确认输出口径和聚合方法。

再给达标率一个分母

只看 A 会以为用户都等得起。假设统计窗口从 0 到 1,000 ms,同一个流式问答入口的四个合规请求全部在窗内得到终态。先设演示判定:成功完成、TTFT ≤ 150 ms,且对至少输出两个 token 的响应要求 TPOT ≤ 40 ms/token。

同一秒内的到达、完成和达标
请求客户端观察完成/达标
A0 ms 发出;100、120、180、190 ms 收到 4 token;成功结束。是/是
B0 ms 发出;210、240、270、300 ms 收到 4 token;成功结束。TTFT = 210 − 0 = 210 ms,TPOT = (300 − 210) ÷ 3 = 30 ms/token。是/否
C25 ms 发出,排队至 150 ms 时超时,未收到 token。否/否
D50 ms 发出,入口过载,当即拒绝,未进入队列。否/否

服务水平指标(Service Level Indicator,SLI)是带口径和窗口的观测量,例如上面的达标率。服务水平目标(Service Level Objective,SLO)给指标定目标,例如「过去 30 天至少 95% 的合规请求达标」。服务水平协议(Service Level Agreement,SLA)是服务承诺,说明未达到约定时如何处理。此处一秒只是算例,实际要先写清按到达还是终态归窗、仍在途的请求怎么处理,以及取消和各类拒绝的计数规则。

也可以为各指标分别设目标,例如 TTFT 的 P95 小于 500 ms、TPOT 的 P95 小于 50 ms/token、可用性 99.9%。吞吐目标还要写清在什么负载下测。分开的两个延迟目标各自达标,不能直接推出同一批请求同时满足两个条件的比例。

下面用同一批演示记录复算。每行存「发出毫秒时刻、终态、收到的 token 时刻」。循环先数可见 token,再对成功响应计算延迟;一 token 的成功响应只查首 token 时间。代码只需 Python 3,不启动推理引擎。

requests = [
    (0, "completed", [100, 120, 180, 190]),
    (0, "completed", [210, 240, 270, 300]),
    (25, "timeout", []),
    (50, "rejected", []),
]
window_seconds = 1
completed = met = visible_tokens = 0
for sent, status, arrivals in requests:
    visible_tokens += len(arrivals)
    if status != "completed":
        continue
    completed += 1
    ttft = arrivals[0] - sent
    intervals = len(arrivals) - 1
    tpot = (arrivals[-1] - arrivals[0]) / intervals if intervals else None
    met += ttft <= 150 and (tpot is None or tpot <= 40)

print(f"完成 {completed / window_seconds:.0f} 请求/s,输出 {visible_tokens / window_seconds:.0f} token/s")
print(f"达标 {met / window_seconds:.0f} 请求/s,达标率 {met / len(requests):.0%}")

输出为「完成 2 请求/s,输出 8 token/s」和「达标 1 请求/s,达标率 25%」。把 B 的发出时刻改成 70 ms、保持收包时刻不变,再预测达标率;B 的 TTFT 会变成 140 ms,达标率会变成 2 ÷ 4 = 50%。真实日志还需检查成功响应是否具有内容和合法时序,缺测单独记账。

术语与计时口径可参照 NVIDIA 推理基准说明、DistServe 的 SLO 与容量分析和 Google SRE 的服务水平目标。本章把窗口内达标的请求数除以窗口长度,比较研究结果时需重新对齐定义。

不同场景的教学目标示例(须按实际需求验证):

场景 TTFT TPOT 吞吐
代码补全 < 200ms ⭐ < 30ms 中
聊天机器人 < 1s < 50ms 中
Agent / 长推理 宽松 < 30ms ⭐(输出很长) 中
批量处理 无所谓 无所谓 最大化 ⭐
语音对话 < 300ms < 40ms 低

🔑 定 SLO 的意义:它把"越快越好"变成一个可以做取舍的工程问题。 如果提高 batch 后 TPOT 仍在目标内,继续对照 TTFT、达标率和显存余量,再决定能不能用延迟换吞吐。目标来自用户等得起多久,选哪组参数还要看同负载下的结果。


📊 三、压测:画出你的延迟-吞吐曲线

结果对照

教学示意:用同一请求分布与配置下的延迟/吞吐曲线作为容量依据之一:
并发数→吞吐(tok/s) TPOT P95 是否满足 SLO
1 140 7ms ✅
8 1000 12ms ✅
32 3500 28ms ✅
64 5200 45ms ✅ 仅在本示例所设 TPOT 目标内
128 6800 95ms ❌ 超了
256 7500 210ms ❌
本示例候选并发上限为 64;还需检查 TTFT、错误与资源余量
ceil(峰值并发 / 本示例容量) 仅作静态起点;弹性还要看就绪、排队与启动时间

实际压测还应记录固定的模型、精度与质量要求、输入/输出长度、到达模式和测试时长。固定并发测的是同时挂着多少请求;按到达率发请求才看得出指定流量下如何积压。两种测试都要报成功、超时、拒绝和取消;吞吐上涨但达标吞吐下降时,不能把吞吐峰值当可用容量。

下列是历史命令结构示例,需按已安装 vLLM 版本查对应压测入口与数据集参数。

# vLLM 自带的压测工具
python -m vllm.entrypoints.openai.api_server --model <model> &

python benchmarks/benchmark_serving.py \
  --model <model> \
  --dataset-name sharegpt \
  --request-rate 10 \
  --num-prompts 1000

⚠️ 压测最常见的错误:用固定长度的输入输出。 真实流量的长度分布方差极大(第 17 章), 固定长度适合做对照,却可能错估连续批处理的收益和尾延迟。 容量测试要重放接近目标业务的长度、到达间隔和突发比例;可用经过脱敏的线上记录,或用公开数据验证分布是否相近。


🏗️ 四、部署架构

部署架构:一层负载均衡 + 多个模型实例 请求 负载均衡 ⭐ 路由策略很重要 实例 1 TP=2 实例 2 TP=2 实例 3 TP=2 每个实例内部自己做张量并行,实例之间彼此独立
请求先进负载均衡,再被分发到若干个各自 TP=2 的推理实例上 —— 分发怎么分,比实例本身跑多快还要影响吞吐。
可选:Redis 租约怎样给路由器提供成员?

限定 Redis 7.2 单实例:每服务/稳定实例号一个 key,值含 endpoint、模型版本、phase、每次启动唯一且不复用的 incarnation/token,key 自身带 TTL。用 SET key value NX PX ttl_ms 原子注册,已有 key 不覆盖;租约内身份绑定不变,同 token 不能改 endpoint/版本。注册存在、TCP 可达、模型 ready 是三件事,新流量还须通过本页已有就绪检查。

同一稳定实例号的协议状态例,A/B 是不同启动 token
情形条件与结果
① A 注册先以 loading 建租约;未变为 ready 或模型版本不匹配,不进入新流量集合。
② A 续约/更新阶段在一个 Lua 脚本内读取并比较 token 和绑定身份,匹配才 PEXPIRE;续约只延 TTL。phase 更新也须同一原子条件检查,仅改阶段并保留到期时间,不能借机换身份。
③ 后台发现取值并核有效租约、ready 与目标模型版本;loading/draining 排除。注册记录只是发现候选,不能代替模型就绪证据。
④ A 过期后 B 接替B 用新 token 注册同 key。主动摘除也须同一 Lua 脚本原子比较 token/身份后才 DEL;旧 A 的续约和摘除均不能改动 B。不能先 GET 检查、再裸 DEL/PEXPIRE。

发现端在后台限量、限时续扫;SCAN 返回 cursor=0 才结束一轮,空批次不代表结束,结果须去重,并发变化仍非快照。原子读取值与剩余 TTL,缓存上限与剩余 TTL 取短、从刷新发起时刻计时;刷新失败或到期后,停止给未重新确认的成员新流量,不延长旧缓存。不能每请求 KEYS 全库,也不能只靠过期通知维护集合;排空沿用下方流程。

TTL 过期只表示租约失效,不证明旧进程已停。暂停、网络分区和缓存延迟仍可能留下陈旧判断;Redis 故障、异步复制切换也不能保证强一致成员视图或外部工作独占。原子比较只约束本 Redis 实例的记录操作,不能升级为全局共识。此表是协议例,未运行 Redis 服务、故障切换或压测。

路由策略的选择(比想象中重要):

策略 说明
轮询 实现简单,可作基线;请求成本相近、到达较均匀时较合适,但不看实例当前积压
最少请求数 按未完成请求数分配,适合请求成本相近的情况;A 只有 1 个长请求、B 有 2 个短请求时,A 未必更空闲
最少待处理 token ⭐ 用排队及执行中请求的剩余 token 估计工作量,能反映长度差异;输出长度未知,Prefill/Decode 每 token 成本也不同,估计仍需校准
前缀感知路由 ⭐ 尽量把可复用前缀送到同一实例,增加缓存复用机会;还要看缓存容量与实例负载,热门前缀的黏性可能造成倾斜

⭐ 多租户各有长系统提示词时,黏性路由可能提高复用,也可能把热点挤到少数实例。不能只看命中率:在相同模型、提示分布、到达负载与副本资源下,对照待处理工作量、排队延迟和 SLO,再权衡复用与负载均衡;不能因命中更多就断言整体更快。这里没有执行路由压测,不给通用收益率。

实例数够不够,先数就绪的:扩容目标不等于已经可服务;新副本完成准备/加载、预热和就绪检查后才放流量。缩容先停止接新请求、排空再回收。把这些状态与排队、尾延迟和错误一起看,就能衔接上面的部署图;完整闭环可选读。

深入:把监控、扩缩与就绪串起来(可跳过)

先划清责任:模型选型、开放权重与自建责任见 导论 07b;托管 API 的超时、重试与配额见 AI 全栈 04。只有在自己负责模型服务实例时,才直接管理下面的模型副本;不能把供应商的约定当作本地服务已验收。

环节证据与动作容易误判的边界
① 观测按固定窗口汇总待处理 token/请求、排队时间、TTFT/TPOT 分位数、错误/取消和 KV/资源占用;保留输入/输出长度分布。不只盯 GPU 或一个 KV 百分比。先区分负载增长、长请求与引擎故障,再选限流、降级、扩容或修故障。
② 提出扩缩目标根据相同模型与负载下的容量证据、成本预算、最小/最大副本数和资源可用性提出 desired;设置观察/稳定窗口及变化速率。阈值、迟滞和冷却依控制器/业务设计;不能把教程值直接上线,也不能瞬间按 desired 记可用容量。
③ 加载与就绪新副本准备运行环境与必要算子/后端,加载正确版本,预热并通过约定的功能/就绪检查后才进入路由。进程启动或健康端点返回不一定证明模型已满足服务目标;具体加载/编译步骤按版本和执行后端核对。
④ 排空与回收缩容先摘除新流量,处理在途请求;按已定超时/取消策略结束,再清理请求/KV与回收资源。直接杀掉活跃副本会影响长请求。取消信号到达不等于清理已经完成,需按实现确认生命周期。
⑤ 回看用户目标新副本 ready 或缩容后,继续按同一窗口比较尾延迟、排队、错误、质量约束和成本;异常时按预案限流、降级或回退。扩容不保证消除故障或提高质量。故障重启、过载降级和按负载扩缩是不同动作,不能互相代替验收。

未执行的教学状态记录:假设每个模型副本内部 TP=2,以下只演示状态,不是流量或吞吐实测。

  1. t0:ready=2,排队在观察窗口内持续上升;策略提出 desired=3。
  2. t1:第 3 个副本仍 loading/warming,ready 仍为 2;此时不能宣称容量已经增长 50%。
  3. t2:第 3 个副本通过 ready 检查后才接新流量,继续看同口径尾延迟/错误。新增这个 TP=2 副本还需要相应资源,不是把原副本 TP 改成 3。
  4. t3:缩容时选中一个副本进入 draining,不再给它新请求;在途请求按约定完成或超时/取消,确认清理后才回收。desired、ready、draining 要分别记录。

系统/数据/模型三层监控已有 监控章,不在这里重讲。若使用 Kubernetes,HPA 的自定义指标、readiness 与稳定窗口可作为一种实现;也可以采用其他控制器,不要求安装集群。用 vLLM 等引擎时核对实际版本暴露的指标和含义,不能只复制名字。

依据:Google SRE · SLI/SLO/SLA、HPA 控制与就绪条件、vLLM 指标说明、TensorRT-LLM 执行后端说明。这里没有部署服务、运行压测或证明任何 SLA 已达成。


💰 五、算清成本

算一算

每百万 token 成本 = GPU 小时单价 ÷ (吞吐 tok/s × 3600) × 1e6

例:A100 按 $2/小时,实测吞吐 5000 tok/s

→ 2 / (5000 × 3600) × 1e6 = $0.11 / 百万 token

def cost_per_million(gpu_hourly, tokens_per_sec, n_gpus=1, utilization=0.6):
    """utilization: 平均负载率——⭐ 这个数字最容易被忽略"""
    effective = tokens_per_sec * utilization
    return gpu_hourly * n_gpus / (effective * 3600) * 1e6

print(f"${cost_per_million(2.0, 5000):.3f} / 百万 token")   # $0.185

⭐ 注意 utilization 那一项: 大部分服务的平均负载只有峰值的 30-60%(夜间几乎没流量)。 按峰值算容量、按平均算成本 —— 这两个数不能混。

💡 降成本的三个方向: ① 提高吞吐(前面五章) ② 提高利用率(把离线批量任务填到低峰期)⭐ ③ 用更便宜的卡(量化后可能装得下)


🛡️ 六、生产必备的五件事

事项 做法
限流 按租户/API key 限 QPS 和 token 速率 ⭐
超时与取消 客户端断开时向调度器传递取消,确认后续不再为它派发工作、正在执行的轮次按实现结束、请求持有的 KV 资源随后释放。⭐
优雅关闭 停止接新请求,等在跑的完成再退出
健康检查 不只是 ping,要真跑一次推理
降级 过载时切到小模型 / 降低 max_tokens / 排队

💥 "客户端断开不取消"是一个真实且昂贵的 bug: 用户关掉页面后,服务器还在为他生成 2000 个 token, 占着 KV Cache 槽位不放 —— 高并发下这会显著吃掉容量。 确认你的框架真的处理了 disconnect。

队列优先级让谁更快,又让谁等得更久?

同一个问答服务也接后台评测。后台任务正在跑,前台用户突然发来一条短请求。优先级决定谁先拿到可用的执行机会;抢占(preemption)是在调度边界暂停在跑的请求,把机会让给别人。两者是不同的策略选择。

单执行槽的教学示意。后台 B 在 0 ms 到达,需 80 ms 执行,截止于 110 ms;前台 F 在 20 ms 到达,需 40 ms,截止于 70 ms。截止时刻以同一时钟表示。
策略时间线谁能完成
运行中的任务继续B 从 0 跑到 80 ms。F 到 70 ms 仍在等,取消排队;如果继续等,最早 80 + 40 = 120 ms 才能完成。B 完成,F 排队超时。
20 ms 恰逢轮次边界,抢占B 先跑 20 ms,剩 80 − 20 = 60 ms。F 在 20 + 40 = 60 ms 完成。B 即使无恢复开销,也要到 60 + 60 = 120 ms 才能完成。F 完成,B 恢复后在 110 ms 超时。若能预测赶不上,可提前终止并记明原因。

这是单槽算例,实际引擎可连续批处理;抢占时 KV 可能被释放,恢复需要重算或搬运。前台流量持续到达时,严格优先可能让后台长期等不到。可为后台保留一部分执行预算,或随等待时间提高优先级,再分组看等待时间、超时和拒绝。已经赶不上截止时间的新请求应按入口策略及时返回,而非让无效工作一直占队列。具体调度能力要核对引擎版本。vLLM 调度配置

服务还可以在接纳时给请求设输出 token 预算,用来约束最多生成多少内容;截止时间另算。一个评测任务的总预算若为 120 token,可以给单个候选最多 120,也可以给两个候选各 50、留 20 给一次模型判定,合计 50 + 50 + 20 = 120。已通过预定质量检查时可以提前停止;预算用完应记录截断。调用工具的等待时间也占截止时间,不能用 token 上限替代超时。用同一批样例比较任务通过率、实际 token 数、耗时与超时比例,再判断哪种分配划算。


📈 七、该监控什么

对照

⭐ 必须有的指标:

【延迟】TTFT / TPOT 的 P50、P95、P99;同窗口看分布,不只看平均

【吞吐】tokens/秒(输入和输出分开统计)⭐

【容量】正在运行的请求数 / 排队长度

【显存】KV Cache 使用率;与排队、抢占/重算及资源余量一起看

【异常】抢占次数、OOM 次数、超时率

【业务】每租户的 token 消耗

⭐ KV Cache 使用率是容量相关信号之一: 持续高占用提示风险,但 90% 不是通用抢占阈值。是否抢占/重算及延迟变化还取决于引擎、缓存策略和请求分布;与排队、错误、实际抢占次数一起核对,不能只据一个百分比决定扩容。

同一个窗口,均值 41 ms,P95 却是 160 ms

假设采到 20 个有首 token 的 TTFT 样本,排序后第 1~18 个都是 20 ms,第 19 个为 160 ms,第 20 个为 300 ms。

平均值是 (18 × 20 + 160 + 300) ÷ 20 = 820 ÷ 20 = 41 ms。

按最近秩法,P95取排序后第 ⌈0.95 × 20⌉ = 19 个,为 160 ms。⌈ ⌉ 表示向上取整,排名从 1 开始。P99取第 ⌈0.99 × 20⌉ = 20 个,为 300 ms。

若目标是 P95 ≤ 150 ms,这批样本超了 10 ms。20 个样本只适合手算;线上要保留样本数和算法口径,分窗口、分请求类别观察,并单列未收到首 token 的失败。


🧭 八、上线检查清单

对照

□ 引擎选过了(不是"团队一直用的那个",是按第一节四个问题选的)

□ SLO 写清了测量起止点、达标分母、统计窗口与失败口径

□ 用【真实分布】的数据压测过,画出了延迟-吞吐曲线

□ 根据曲线设了 max_num_seqs 上限(第 17 章)

□ 开了:连续批处理、前缀缓存、chunked prefill

□ 量化方案经过【业务数据】质量评估(第 18 章)

□ 客户端断开会取消生成

□ 分请求类别测过限流、降级、抢占、排队超时和取消后的资源清理

□ 监控里有 KV Cache 使用率和 P99 延迟告警

□ 做过一次故障演练(杀掉一个实例,看会怎样)


🔗 和站内其他章的关系

相关的地方 这里的位置
第 15 章 TTFT/TPOT SLO 的两个核心指标 ⭐
第 15 章 "换引擎常常 5-10 倍" 换成哪个?本章第一节的横评和四问决策树就是答案 ⭐
第 16 章 前缀缓存 前缀感知路由让它命中率大涨;RadixAttention 是它在数据结构上的推进(本章第一节)⭐
第 17 章 max_num_seqs 守 SLO 的旋钮
第 17 章 块共享 线性前缀共享的实现基础,和 RadixAttention 的树共享是同一个思路的两级
第 18 章 量化 降成本的主要手段
第 23 章 更系统的成本优化
《大模型全景导论》06 推理优化 那边是产品视角的取舍清单(该不该压、压到什么程度),本章是工程视角的选型与守 SLO。从那边过来的人,缺的正是这一章第一节的横评
《模型上线之后》05 该监控什么 三层监控 本章第七节只有引擎指标;"它给的答案还合理吗"这一层在那边,两层都要有 ⭐
《模型上线之后》18 成本与容量 容量规划 本章的成本公式只算 GPU;峰值容量、排队雪崩、"不做也是一个选项"在那边 ⭐
⭐ 《AI 全栈》04 · 调用层 ⭐ 分界:本章是「推理引擎怎么选、怎么守 SLO」,那一章是「应用怎么调它」 —— 超时(连接 vs 读取是两个数)、重试白名单、成本记账、缓存与不确定性、假客户端。引擎调好了,应用侧不做这些照样会 500
《AI 全栈》12 · 限流配额与成本护栏 本章算的是你自己跑引擎的成本;那一章管的是每个用户能花多少(限流 / 配额 / 全局熔断三层)。⭐ 用托管 API 时,那三层就是你唯一的成本闸门
《推荐算法》15 工程落地 降级策略 本章表里一行的"降级",在那边是完整一节 —— 降级路径必须设计,不是可选项
《大模型全景导论》07 本地部署与开源生态 该不该自建 那边回答"要不要自己部署",本章第一节回答"决定自建之后,用哪个引擎" ⭐
《智能体工程教程》11 检索与 RAG 提示词怎么拼 决定了你的请求之间有多少共享前缀 —— 而那正是 RadixAttention / 前缀缓存能不能生效的前提 ⭐

✅ 检查点

  1. 选推理引擎的四个问题是什么?默认答案是哪个?
  2. TensorRT-LLM 的代价是什么?什么情况下才值得付?
  3. 为什么说"先别去挑性能最高的那个"?大部分"框架 A 快 3 倍"的评测问题出在哪?
  4. RadixAttention 和普通前缀缓存的区别是什么?为什么它只淘汰叶子?
  5. 判断该不该关心 RadixAttention,真正要看的是什么?
  6. 为什么要先定 SLO 再优化?不定会怎样?
  7. 代码补全和 Agent 场景的 SLO 侧重有什么不同?
  8. 压测最常见的错误是什么?为什么它会误导你?
  9. 延迟-吞吐曲线怎么用来做容量规划?
  10. 四种路由策略里,哪个最容易被忽略但收益大?为什么?
  11. 成本公式里 utilization 为什么重要?
  12. "客户端断开不取消"为什么是昂贵的 bug?
  13. 扩缩决策需要结合哪些监控信号?为什么不能只用 KV 使用率或 GPU 利用率?
  14. 为什么不能只看平均,还要看尾延迟、统计窗口和请求分布?
  15. SLI/SLO/SLA 怎样区分?desired=3、ready=2 时为何不能按 3 个副本承诺容量?缩容先做什么?
  16. 请求 A 四个 token 为什么只有三个间隔?如果首 token 仍在 100 ms 收到,末 token 改为 220 ms,TPOT 变成多少?
  17. 时间线里的抢占如果额外消耗 10 ms 才能恢复后台 B,B 最早何时能完成?F 的结果变不变?假设 10 ms 开销在 F 完成后才发生。
👀 答案
  1. ①要"跑起来"还是"扛住流量"(跑起来 → Ollama,到此为止)②有没有 NVIDIA 卡(没有 → llama.cpp + GGUF)③模型和硬件会不会变(不变且性能是 KPI → TensorRT-LLM)④请求之间前缀重合度高不高(高 → SGLang)。默认答案是 vLLM。TGI / LMDeploy 是"生态贴合"型的选择——"团队已经会什么"是一个合法且常被低估的判据。
  2. 需按具体版本、后端和模型核对支持、准备、加载及预热成本;预构建 engine 不是所有执行路线的共同前提。模型/硬件稳定且延迟或成本重要时值得与其他候选同口径比较,不能把更换配置一概写成必须重编。
  3. 因为主流引擎之间的差距通常只有 20-50%,而你有没有开对连续批处理、前缀缓存、量化,差的是几倍。💥 大部分"快 3 倍"的评测拆开看都是配置没对齐(一边开了连续批处理一边没开)。顺序:先把配置调对,再考虑换引擎。
  4. 普通前缀缓存的匹配是线性的(从头比对,命中一条前缀);RadixAttention 把 KV Cache 的索引组织成一棵基数树,分叉点是自动被发现的,沿树往下能匹配多远就复用多远,只有分叉之后的部分才重新 Prefill。只淘汰叶子是因为父节点还被别的分支用着。
  5. 看你的请求之间到底有多少共享前缀——不是"哪个框架有这个功能"。一点都不共享,两者都白搭;而这件事在换引擎之前就能自己统计出来。
  6. 因为不定目标就不知道调到什么程度算够、该牺牲什么。不定 SLO 会盲目优化延迟到远超需求的程度,白白损失吞吐。
  7. 代码补全 TTFT 极敏感(<200ms,用户等不了);Agent 输出很长,TPOT 是决定性的,TTFT 反而宽松。
  8. 把固定长度对照当成线上容量测试。真实流量的输入/输出长度和到达间隔会变化,容量测试要重现这些分布,才能比较排队、尾延迟和达标吞吐。
  9. 在固定模型/硬件/配置和请求长度分布下,延迟-吞吐曲线支持一个容量候选;64 只是示例,还需核对其他目标和余量。ceil(峰值并发/候选容量) 只是静态起点,扩缩要另看排队、就绪副本与冷启动时间。
  10. 前缀感知路由——把可复用前缀尽量送到同一实例,增加复用机会;也要防止黏性热点造成负载倾斜,按同负载的排队延迟与 SLO 验证,不预设命中率或提速幅度。
  11. 因为大部分服务的平均负载只有峰值的 30-60%(夜间几乎没流量)。按峰值算容量、按平均算成本,两个数不能混。
  12. 用户关掉页面后服务器还在生成 2000 个 token,占着 KV Cache 槽位不放——高并发下会显著吃掉容量。
  13. 结合待处理请求/token、排队时间、TTFT/TPOT 分位数、错误与实际抢占/重算、KV 和资源余量;要保持相同窗口和负载口径。90% 不是通用抢占阈值,一个百分比或 GPU 利用率都不能单独决定扩容。
  14. 均值 41 ms 的教学窗口仍有 160 ms 的 P95 和 300 ms 的 P99,个别长等待被大多数快请求摊薄了。要同时看样本数、统计窗口、分位数口径,以及没有延迟样本的失败请求。
  15. SLI 是带口径/窗口的观测,SLO 是目标,SLA 是服务约定及后果。desired 是目标而非已可服务的副本;新副本加载/预热/就绪后才放流量。缩容先摘除新请求并按超时/取消策略排空与清理,再回收。模型副本和副本内 TP 度数也不是同一个扩容维度。
  16. 首 token 是起点,后续三个 token 各贡献一个间隔。新的 TPOT = (220 − 100) ÷ (4 − 1) = 40 ms/token。
  17. F 仍在 60 ms 完成。B 到 60 + 10 = 70 ms 才能恢复,尚需 60 ms,最早 70 + 60 = 130 ms;110 ms 就会超时。恢复成本会影响容量,即便前台延迟没有变化。

本节回顾

⚡ 走神救援

扩缩闭环只记三步:观测负载与用户目标→新副本就绪后放流→旧副本排空后回收。desired 不等于 ready;SLI、SLO、SLA 不混用。2/3 副本与 64 并发都是示意,没有替代实际压测或服务验收。

⭐ 选引擎只要四个问题:跑起来还是扛流量 → 有没有 N 卡 → 模型和硬件会不会变 → 请求之间前缀重合度高不高。vLLM 是默认答案;SGLang 适合前缀重合度高的负载;TensorRT-LLM 的支持与准备成本需按具体版本/后端核对,不能一概写成更换配置必重编;llama.cpp 管没有 N 卡的场景。

⚠️⭐ 反直觉但最重要:先别挑性能最高的。 引擎之间通常只差两三成,而有没有开对连续批处理、前缀缓存、量化差的是几倍——💥 大部分「框架 A 快 3 倍」的评测拆开看都是配置没对齐。

⭐ RadixAttention 该不该在意,看的不是「哪个框架有这功能」,而是你的请求之间到底有多少共享前缀——不共享就都白搭。

⭐ 先定义谁算达标,再看能接多少流量。TTFT 看首 token,TPOT 看首 token 之后的平均间隔。分位数显示谁在等得更久,超时和过载拒绝按规则进入达标分母。压测要复现目标业务的请求分布与到达模式,再核对容量候选、资源与启动余量。

路由用前缀感知(同租户固定到同一实例,命中率能从三成提到九成)。⭐ 算成本别忘了利用率:按峰值算容量、按平均算成本。

生产五件事里最贵的一条:💥 客户端断开不取消是真实且昂贵的 bug——用户关了页面,你还在生成并占着 KV Cache 槽位。⭐ 监控把 KV、排队、实际抢占/重算、错误与尾延迟一起看;百分比和分位数要有负载口径/窗口,不能把 90% 或一个 P99 当通用通过标准。

下一节 👉 21-训练稳定性与故障恢复.md

条件与依据

引擎表描述路线而非排名;旧接口、性能倍数和示例压测命令不代表当前版本保证。批量上线前比较同请求分布、硬件、采样与质量,数字表是教学假设。前缀缓存可支持多分支复用,不能把其他引擎概括成只复用一条固定系统提示;多租户缓存还要遵守隔离与访问策略。

原论文;官方文档

打卡记录保存在你的浏览器里,首页能看到总进度