知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# Agent 压测与容量规划 > 导读:本文从"给 Agent 做压测时,照着普通接口的 QPS 思路压,压测报告一片绿,上线后却依然大面积超时和限流"这个具体痛点出发,把 Agent 特有的容量指标、单任务耗时与成本的拆解、流量建模、mock 与阶梯加压、瓶颈定位、容量反推估算、成本与容量联合优化、观测告警,以及一份压测脚本骨架逐项讲透,最后给出工程实践与踩坑清单。适合正在把 Agent 从 Demo 推向线上、需要回答"这份配额/这些实例到底能扛多少"的后端与平台同学。 ## 一、先建立全局认知 ### Q:Agent 的容量指标和普通服务有什么不同? A:结论先行——**普通服务的容量可以用"QPS + P99 延迟"基本描述,因为一次请求对应一次近似确定的工作量;而 Agent 一次请求内部是"多步推理 + 多次模型调用 + 多次工具调用"的复合体,工作量本身是变量,所以容量必须用"会话维度 + 步数维度 + Token 维度"三组指标联合描述,QPS 只是最外层的一个入口计数。** 普通服务和 Agent 服务在容量建模上的根本差异,在于"一次请求的工作量是否是常量": | 维度 | 普通微服务 | Agent 服务 | | --- | --- | --- | | 一次请求的工作量 | 近似常量(1 次 DB 查询 + 若干次 RPC) | 变量(步数从 1 到步数上限不等) | | 核心入口指标 | QPS / TPS | 会话到达率(session arrival rate)、并发会话数(concurrent sessions) | | 内部放大指标 | 下游 RPC 次数 ≈ QPS × 固定系数 | 模型调用次数 ≈ 并发会话 × 平均步数 | | 资源瓶颈 | CPU / 内存 / 连接池 | 模型侧配额与推理并发、工具侧下游、线程池/连接池、向量库 | | 延迟形态 | 单峰、相对稳定 | 多峰叠加 + 长尾极长(某一步卡住整任务卡住) | | 成本 | 固定机器成本 | 与 Token 用量线性相关,随步数放大 | | 容量规划输出 | 实例数 | 实例数 + 模型配额 + 成本预算三者联合 | 因此描述一个 Agent 服务的能力,至少要报出下面这组指标: - **并发会话数**(concurrent sessions):同一时刻处于"正在被处理、尚未结束"的会话/任务数量。它是决定模型并发压力的核心量。 - **平均步数 / P95 步数**(average steps / P95 steps):一次任务平均调用模型多少次(也近似等于"Reasoning-Act"循环轮数)。它是把"并发会话"放大成"模型请求量"的乘数。 - **每步 Token**(tokens per step):单次模型调用的输入与输出 Token。输入通常随会话轮次累积而增长。 - **每任务工具调用次数**(tool calls per task):一次任务触发多少次工具/检索/外部 API,它决定下游系统压力。 - **会话到达率**(session arrival rate):每秒新建多少个会话,单位为 sessions/s。 - **任务端到端 P95/P99 延迟**(task latency):从用户提交到最终答复的墙钟时间,而不是单步延迟。 - **任务成功率 / 步数超限率**:既看效果,也看"因步数上限被迫中断"的比例。 一句话记忆:**普通服务看 QPS,Agent 服务看"并发会话 × 平均步数"这条乘出来的内部请求量。** 一个把上述指标串起来的结构示意:  *图:容量放大——内部请求量 ≈ 并发会话数 × 平均步数* ```text 用户请求流(sessions/s) │ ▼ ┌───────────────────────┐ │ 会话接入层 / 排队 │ ← 并发会话数在这里被限制 └───────────┬───────────┘ ▼ ┌───────────────────────────────────────────┐ │ Agent 编排循环 │ │ for step in 1..maxSteps: │ │ 模型调用 (1 次) ──▶ Token 计费 │ │ 若有 tool_call: 工具调用 (0..N 次) ──▶ 下游 │ │ 若可结束: break │ └───────────┬───────────────────────────────┘ ▼ 内部请求量 ≈ 并发会话数 × 平均步数 ``` ### Q:一次 Agent 任务的耗时和成本怎么拆解? A:结论先行——**一次任务的端到端耗时 ≈ Σ(每步模型调用耗时) + Σ(每步工具调用耗时) + 编排与调度开销;成本 ≈ Σ(每步输入 Token × 输入单价 + 输出 Token × 输出单价) + Σ(工具/检索/外部服务费用)。两者的共同特征是:都由"步数"成倍放大,并且都呈现明显长尾——平均值好看不代表 P99 好看。** **耗时拆解。** 把一次任务按步骤拉平: ```text 任务 = step1 + step2 + ... + stepK step_i = 模型调用耗时_i + (工具调用耗时_i) + 编排开销_i 模型调用耗时 = 排队等待 + 首 Token 延迟(TTFT) + 输出 Token 数 / 输出速率 任务总耗时 T = Σ_{i=1..K} step_i ``` 几个必须记住的定性结论(**具体数值需按自身实测**): 1. **步数是最强的耗时放大器。** 如果单步平均耗时是 t,平均步数是 K,则平均任务耗时近似 K·t。步数从 3 涨到 6,任务耗时大概翻倍,而 QPS 完全没变——这正是"QPS 没涨但延迟爆了"的原因。 2. **每步内部还有排队等待。** 高并发下模型侧有排队,单步模型的"排队 + TTFT"往往是主要成分,且随并发上升而变差,不是常数。 3. **长尾来自"最慢的那一步"。** 一次任务的 P99 近似等于"K 步里最慢一步的 P99 累积"。即使每步 P99 只有一个固定概率出现慢,K 步累积后任务级超时的概率会显著上升。所以**任务级 P99 不能由单步 P99 简单推算,必须实测**。 **成本拆解。** 用计算模型表达(系数按自身实际单价与流量结构核算,不要背数字): ```text 单任务成本 C ≈ Σ_{i=1..K} ( inTokens_i × priceIn + outTokens_i × priceOut ) + Σ tool 调用费用 + 检索/向量化费用 其中 inTokens_i ≈ SystemPrompt + 会话历史(随 i 增长) + 工具返回内容 K = 平均步数(也等于平均模型调用次数) 月成本 ≈ 月任务数 × 平均单任务成本 + 重试放大(重试率 × 单任务成本) - 缓存/前缀缓存节省 ``` 关键点: - **输入 Token 随步数累积。** 第 i 步通常要把前面所有工具结果和历史重新放进上下文,所以 `inTokens_i` 随 i 增长,总的输入 Token 近似 O(K²) 量级增长,而不是 O(K)。这解释了为什么"步数多"既贵又慢。 - **一次任务被计费多次。** 用户视角是"一个问题",账单视角是 K 次模型调用。**容量预算必须按"模型调用次数"而不是"任务数"来算。** - **重试与降级要单独建模。** 超时重试、工具失败重试、模型 429 重试都会乘在成本上。 **长尾问题单独强调。** 容量规划里最容易被忽略的就是长尾:平均耗时 8 秒、P99 40 秒的服务,如果按平均值算并发和超时阈值,线上会持续有 1% 的用户体验灾难。做法是**同时看 P50/P95/P99,并以 P95 作为容量与超时阈值的设计基准**(具体分位点按业务 SLA 定)。 ## 二、压测方法 ### Q:如何做流量建模:会话到达率与并发会话? A:结论先行——**压测的输入不是"QPS",而是"会话到达率 + 会话时长分布 + 每会话步数分布"这三个量;并发会话数由它们通过 Little's Law 推导出来,而并发会话数才是真正决定模型压力的量。** 先用排队论里最基础的一条关系式把三者串起来: ```text Little's Law: L = λ × W L = 平均并发会话数(in-flight) λ = 会话到达率(sessions/s) W = 平均会话/任务时长(s) 反推:需要的并发会话容量 L ≈ λ × W_p95(按 P95 时长留裕量) ``` 举例说明建模步骤(**示例数字仅用于演示算法,不代表任何真实系统**): 1. **确定业务目标**:日活用户 5 万,每人日均发起 2 个任务,则日任务量 ≈ 10 万。 2. **确定时间分布**:假设 80% 集中在 8 小时峰值时段,则峰值 λ ≈ 80% × 10 万 / (8 × 3600) ≈ 2.8 sessions/s。 3. **确定单任务时长**:实测平均 10 s、P95 30 s。 4. **推并发会话数**:L ≈ λ × W ≈ 2.8 × 30 ≈ 84 个并发会话(用 P95 时长留裕量)。 5. **推模型请求量**:若平均步数 4,则模型请求速率 ≈ 84 × (1/平均单步耗时) ... 更直接地,模型总调用速率 ≈ λ × 平均步数 ≈ 2.8 × 4 ≈ 11.2 次/s。 所以**流量模型必须显式包含"步数分布"和"时长分布"**,否则压测出来的并发对不上真实负载。 压测流量参数建议用一个结构化配置表达: ```yaml # 压测流量模型(示例,值为占位,需按实测替换) traffic_model: arrival_mode: poisson # 泊松到达更接近真实用户;固定速率只用于定压 arrival_rate: 3 # sessions/s total_sessions: 3000 session: steps_distribution: # 步数分布:不要只用平均值 type: empirical values: [1, 2, 3, 4, 5, 8] weights: [0.10, 0.20, 0.30, 0.25, 0.10, 0.05] think_time_s: 0 # 多轮对话型 Agent 才有用户思考间隔 sla: task_p95_ms: 30000 task_p99_ms: 60000 success_rate: 0.995 ``` **适用边界**:Little's Law 假设系统处于稳态、任务不会无限堆积。若到达率超过系统处理能力,队列会持续增长,`L = λW` 不再成立,此时压测会表现为"延迟单调上升直至超时"——这恰恰是容量饱和信号。 ### Q:为什么要 mock 模型与工具,才能避免压测费钱? A:结论先行——**因为 Agent 压测会成倍放大调用次数(并发会话 × 步数),如果打真实模型和真实下游,一次全量压测既烧钱又可能打爆生产下游;所以压测主力必须用 mock,真实调用只留小比例做"真实性校准"。** mock 的两类对象和注意事项: | 对象 | mock 什么 | 关键要求 | | --- | --- | --- | | 模型 | 返回内容、Token 用量、延迟分布 | **延迟必须能配置**(含 TTFT 与输出速率),否则压不出排队效应;Token 用量要接近真实 | | 工具 | 下游响应内容、延迟、错误率 | 支持注入慢响应、超时、5xx、限流,用于测错误路径 | | 向量库 | 检索结果、延迟 | 保持返回条数分布接近真实,否则上下文长度失真 | **mock 模型最容易被做错的地方**:把 mock 写成"立即返回固定文本",于是压测完全没有模型延迟,压出来的吞吐毫无意义。正确做法是 mock 也要"消耗时间",且时间要与真实分布一致: ```text mock 模型延迟 ≈ 排队延迟(并发函数) + TTFT + 输出Token数 / 输出速率 + 随机抖动 并且要能配置"并发超过 N 时排队延迟非线性上升",才能模拟模型侧限流/排队。 ``` **mock 与真实的比例策略**:全量压测走 mock;另外保留一个小比例(如 1%)的真实调用做"校准",用来验证 mock 的 Token 估算与延迟分布是否偏离真实。**比例按预算定,不能用真实调用做主力压测。** ### Q:阶梯加压与瓶颈定位怎么做? A:结论先行——**用"阶梯加压 + 每阶段稳态观测"找出系统的拐点(throughput 不再增长、延迟开始非线性上升的那个并发值),拐点之前的并发就是可用容量,拐点之后进入饱和区。瓶颈则靠"对照每层的资源与排队指标"定位到具体某一层。** 阶梯加压的执行方式:  *图:压测加压曲线:并发会话数阶梯上升到饱和* ```text 并发会话数 120 │ ╭──── 饱和(延迟飙升,吞吐不涨) 100 │ ╭────╯ 80 │ ╭──────╯ 60 │ ╭─────╯ 40 │ ╭────╯ 20 │───╯ └────┬────┬────┬────┬────┬────▶ 时间 阶段1 阶段2 阶段3 阶段4 阶段5 每阶段:加压 → 稳态运行 → 采集指标 → 再升一档 ``` 每个阶段必须满足两个条件才有意义:**(1)到达稳态**(延迟与吞吐在观测窗口内不再单调漂移);(2)**窗口足够长**,覆盖至少若干个最慢任务的完整生命周期。否则会采到过渡态数据,误判拐点。 瓶颈定位用"分层对照"的思路,逐层看"资源利用率 + 排队长度 + 错误类型":  *图:各层级要看的指标与典型饱和信号* ```text 层级 看什么指标 典型饱和信号 ───────────────────────────────────────────────────────────── 接入/排队 队列长度、排队等待时长 队列持续增长不收敛 Agent 线程池 活跃线程、任务队列、拒绝数 RejectedExecution 模型侧 并发请求数、429/超时率、排队延迟 429 上升、单步延迟抬升 工具下游 下游 P99、错误率、连接池等待 下游超时、连接池打满 向量库 查询延迟、并发上限 检索延迟抬升 连接池(N个) 活跃连接、等待获取连接时长 获取连接等待上升 ``` 定位口诀:**先看"最上游的队列是否堆积",再沿调用链往下找"第一个资源利用率打满且排队上升的层",那一层就是当前瓶颈。** 注意瓶颈是会转移的:解决掉模型侧限流后,瓶颈常常迁移到工具下游或线程池。 ## 三、瓶颈定位 ### Q:Agent 系统的瓶颈通常在哪些位置? A:结论先行——**按出现频率,依次是:模型侧(限流/推理并发)、工具侧下游系统、Agent 自身线程池与连接池、向量库/检索层。它们共同的特点是"排队",而不是"算得慢",所以定位要看排队指标而非只看 CPU。** **瓶颈一:模型侧限流与推理并发。** 表现是 429、超时率上升、单步延迟随并发非线性抬升。根因是该模型账号/部署有并发或速率配额(**配额口径与单位需结合供应商与版本确认**,例如按 RPM/TPM 还是按并发数限制,不同供应商不同)。这类瓶颈**不能靠"加应用实例"解决**,应用实例加得越多,超限越严重。对策是控制应用侧并发上限 + 配额扩容 + 模型分级。 **瓶颈二:工具侧下游系统。** Agent 会在短时间内对同一个下游发出大量调用(并发会话 × 工具调用次数),而且是"突发的"。表现是下游 P99 抬升、错误率上升、连接池等待。**这是压测最容易"打爆"的东西**,所以压测必须带限流保护,或使用下游的隔离/影子环境。 **瓶颈三:Agent 自身线程池与连接池。** 如果引擎用线程池处理会话、或按步提交异步任务,线程池大小、队列容量、模型/工具 HTTP 连接池大小都会成为瓶颈。表现是 `RejectedExecution`、请求在"获取连接"处等待。**这类瓶颈的坑是"池子大小与并发会话数不匹配"**:并发会话 100,但模型连接池只有 20,实际并发被人为压到 20。 **瓶颈四:向量库/检索层。** 每次工具调用可能触发一次检索,检索延迟和并发上限会叠加进每步耗时。  *图:任务链路上的三类排队点:模型、工具、向量库* ```text 一次任务里的排队点分布(示意): 编排队列 → [线程池] → 模型连接池 → 模型服务排队 ──▶ 模型 → 工具连接池 → 下游服务排队 ──▶ 工具 → 向量库连接池 → 向量库排队 ──▶ 检索 ▲ 任一处打满,整条链路吞吐就被它按住(木桶效应) ``` ### Q:只压单轮为什么发现不了问题? A:结论先行——**因为 Agent 的容量问题大多由"多步叠加"产生:Token 随步数累积、成本随步数放大、任务级 P99 由多步长尾累积。只压单轮(一步)等于把出问题的那个乘数设为 1,等于没压。** 必须覆盖的多步特性: - **上下文增长**:第 N 步输入远大于第 1 步,Token 与延迟都随之上涨。 - **任务级长尾**:多步叠加后 P99 显著高于单步 P99。 - **中断/恢复路径**:步数超限、工具失败重试、人工介入挂起,这些路径的并发占用不容忽视。 - **成本**:单轮压测完全看不出成本结构。 ## 四、容量估算 ### Q:给定目标并发与 SLA,怎么反推模型配额、实例数与成本预算? A:结论先行——**反推的顺序是:目标并发会话 → 平均步数 → 模型请求速率与 Token 速率 → 模型配额需求 → 应用实例数(按每实例可承载并发会话)→ 成本预算。每一步都是"乘/除一个系数",系数必须来自自身实测。** 完整计算模型(**所有系数均为占位,须以实测替换;不要照抄任何数字**): ```text Step 1 目标并发会话 L (由业务量 × Little's Law 得出) Step 2 模型调用速率 R_model ≈ λ × 平均步数 (等价写法:并发会话数 L ÷ 平均单步耗时;稳态下两式一致) Token 速率 R_token = R_model × 每步平均 Token(输入+输出) Step 3 模型配额需求: 需要的最小配额 = R_model 峰值 × 安全系数(如 1.3) —— 与供应商配额口径对齐(RPM/TPM/并发数,需按版本确认) Step 4 应用实例数: 每实例可承载并发会话 = min(每实例线程/协程数, 模型连接池并发, 下游连接池并发) 实例数 = ceil( L × 安全系数 / 每实例可承载并发会话 ) —— 注意木桶效应:取各项最小值,别只按线程数算 Step 5 成本预算: 月成本 ≈ 月模型调用次数 × 单次平均 Token 成本 + 下游调用费用 + 基础设施费用 × 重试放大系数 Step 6 校验:在压测拐点并发处,验证延迟 ≤ SLA 且成本 ≤ 预算 ``` 几个反推时的关键提醒: 1. **配额是硬约束,先算配额再算实例。** 如果模型配额只够支持 L=60 的并发,那么即使你部署 10 个实例也没用,第 61 个并发就会开始限流。 2. **实例数要按"木桶最短板"算。** 每实例的并发承载能力由线程池、模型连接池、下游连接池中最小的那个决定。 3. **安全系数不可省。** 真实流量有突发性,压测的稳态拐点要打折扣使用。 4. **成本要按"模型调用次数"而非"任务数"。** 一步一次调用,多步任务要乘步数。 ### Q:成本和容量如何联合优化? A:结论先行——**成本与容量不是两件事,而是同一个杠杆的两端:降低"内部模型请求量"和"单次 Token 成本",同时就是在释放容量。优化的优先级从高到低是:模型分级路由 → 缓存 → 步数上限 → 并发上限与排队 → 降级。** 优化手段与"同时改善什么"的对照: | 手段 | 降成本原理 | 增容量/降延迟原理 | 风险 | | --- | --- | --- | --- | | 模型分级路由 | 简单步骤走小模型,单价更低 | 小模型通常更快、配额更宽松 | 小模型质量不足,需评测兜底 | | 精确/前缀缓存 | 命中即不重复计费 | 命中即不占用模型并发 | 命中率与正确性风险 | | 步数上限 | 截断 O(K²) 的 Token 累积 | 限制单任务最长耗时,保护并发 | 设太短会降低任务成功率 | | 并发上限 + 排队 | 避免重试放大 | 防止把模型侧打到限流 | 队列过长导致延迟上升 | | 降级(简化推理/直接答复) | 少调用模型 | 高负载下保住核心请求 | 效果下降,需可观测 | 一个把"容量约束"显式纳入的排队与降级策略(文字描述):**在编排入口维护一个信号量(Semaphore)限制并发会话数;超出时进入有界队列等待;队列也满时按优先级降级(低优先级任务直接返回"繁忙稍后重试"或走简化路径)。** 这样做的目的不是提升峰值吞吐,而是**把过载从"全链路雪崩"变成"可控排队 + 部分降级"**。 **步数上限的双重意义**:它既是成本闸门(截断 O(K²) 的输入累积),也是容量闸门(限制单任务最长生命周期,避免个别任务长期占用并发会话)。所以**步数上限不能只当成效果参数,它同时是容量参数**。 ## 五、观测与告警指标 ### Q:Agent 上线后应该盯哪些指标? A:结论先行——**至少分四层盯:入口层(会话/任务)、编排层(步数/循环)、模型层(调用/Token/限流)、工具层(下游调用/错误);每层都用"速率 + 延迟分位 + 错误 + 饱和度"四类信号表达。** | 层 | 指标 | 类型 | 告警意义 | | --- | --- | --- | --- | | 入口 | 会话到达率、并发会话数 | 速率 | 判断负载是否逼近拐点 | | 入口 | 任务 P95/P99 延迟、成功率 | 分位/比率 | SLA 是否失守 | | 编排 | 平均步数、P95 步数 | 分布 | 步数异常抬升=成本/延迟预警 | | 编排 | 步数超限率、平均循环轮数 | 比率 | 任务质量与容量双重信号 | | 模型 | 模型调用速率、429/超时率 | 速率/比率 | 是否触及配额 | | 模型 | 每步 Token 分位、Token 速率 | 分布/速率 | 成本与配额消耗 | | 模型 | 单步延迟(含排队)分位 | 分位 | 模型侧饱和 | | 工具 | 每任务工具调用次数、下游 P99 | 分布/分位 | 下游压力 | | 工具 | 下游错误率、重试次数 | 比率 | 下游与网络问题 | | 资源 | 线程池活动/队列/拒绝数 | 饱和度 | 应用侧瓶颈 | | 资源 | 连接池活跃/等待获取时长 | 饱和度 | 连接池瓶颈 | 告警设计要点: - **用"并发会话数"和"模型调用速率"做容量预警**,而不是等到超时率上升才报警——超时是结果,饱和是原因。 - **区分"排队型"和"故障型"信号**:排队是延迟抬升但成功率尚可;故障是错误率跳升。两者处置不同。 - **Token/成本做趋势告警**,防止"平均步数悄悄上涨"带来的成本漂移。 ## 六、压测脚本骨架与结果分析 ### Q:压测脚本骨架长什么样? A:结论先行——**一个可用的 Agent 压测脚本要包含四块:流量发生器(按到达率产生会话)、mock 模型/工具(可配置延迟与错误)、多步执行循环(走真实编排逻辑)、指标采集与分位统计。下面给一个最小骨架,解决"如何按流量模型驱动并发会话并采集分位"。** ```python """Agent 压测脚本最小骨架(示意,非可直接运行的生产代码)。 目标:按会话到达率产生会话,跑多步代理循环,采集任务级延迟与步数分位。 """ import asyncio import random import time from dataclasses import dataclass, field @dataclass class Metrics: task_latencies: list = field(default_factory=list) # 任务级墙钟耗时(ms) steps_per_task: list = field(default_factory=list) # 每任务步数 model_calls: int = 0 in_flight: int = 0 # 当前并发会话数 peak_in_flight: int = 0 errors: int = 0 # ---------- mock 层:必须"消耗时间",并支持错误注入 ---------- async def mock_model_call(step: int, sem: asyncio.Semaphore, metric: Metrics): async with sem: # 模拟模型侧并发上限/排队 ttft = random.uniform(0.2, 0.6) # 首 token 延迟(占位值,按实测替换) out_tokens = random.randint(100, 500) gen_s = out_tokens / 30.0 # 输出速率(占位值) await asyncio.sleep(ttft + gen_s) metric.model_calls += 1 return {"tokens_in": 500 + step * 300, "tokens_out": out_tokens} async def mock_tool_call(metric: Metrics): lat = random.uniform(0.05, 0.8) # 工具延迟分布(占位值) await asyncio.sleep(lat) if random.random() < 0.01: # 1% 错误注入 raise RuntimeError("tool failed") # ---------- 单次任务:走真实的多步编排逻辑 ---------- async def run_one_session(step_dist, model_sem, metric: Metrics): t0 = time.perf_counter() steps = random.choices(step_dist[0], weights=step_dist[1])[0] metric.in_flight += 1 metric.peak_in_flight = max(metric.peak_in_flight, metric.in_flight) try: for step in range(1, steps + 1): await mock_model_call(step, model_sem, metric) if random.random() < 0.5: # 有概率触发工具调用 await mock_tool_call(metric) except Exception: metric.errors += 1 finally: metric.in_flight -= 1 metric.task_latencies.append((time.perf_counter() - t0) * 1000) metric.steps_per_task.append(steps) def percentile(xs, p): if not xs: return 0.0 xs = sorted(xs) return xs[min(int(len(xs) * p), len(xs) - 1)] # ---------- 流量发生器:按泊松到达率产生会话,阶梯加压 ---------- async def stage(arrival_rate: float, duration_s: float, model_concurrency: int): metric = Metrics() model_sem = asyncio.Semaphore(model_concurrency) # 模型侧并发上限 tasks = [] end = time.perf_counter() + duration_s while time.perf_counter() < end: tasks.append(asyncio.create_task( run_one_session(([1, 2, 3, 4, 5, 8], [0.1, 0.2, 0.3, 0.25, 0.1, 0.05]), model_sem, metric))) # 泊松到达:间隔 ~ Exp(1/λ) await asyncio.sleep(random.expovariate(arrival_rate)) await asyncio.gather(*tasks, return_exceptions=True) return metric async def main(): for rate in [1, 2, 4, 8, 16]: # 阶梯加压 m = await stage(rate, duration_s=60, model_concurrency=20) print(f"λ={rate}/s peak_in_flight={m.peak_in_flight} " f"P50={percentile(m.task_latencies,0.5):.0f}ms " f"P95={percentile(m.task_latencies,0.95):.0f}ms " f"P99={percentile(m.task_latencies,0.99):.0f}ms " f"steps_avg={sum(m.steps_per_task)/max(len(m.steps_per_task),1):.2f} " f"err={m.errors}") if __name__ == "__main__": asyncio.run(main()) ``` 代码要点与边界: - **为什么 mock 也要 sleep**:模型调用和工具调用的"延迟"是压测要压的核心对象;直接返回等于把系统延迟置零,压不出瓶颈。 - **为什么用 Semaphore 模拟模型并发**:真实模型侧有并发/速率上限,用信号量可以让"排队延迟随并发上升"这一现象自然出现,从而找到拐点。 - **为什么按泊松到达**:真实用户到达更接近泊松过程,固定速率只适合"定压"验证稳态吞吐。 - **适用边界**:这是骨架,省略了真实引擎接入、错误分类、分位滑窗、资源采集。生产压测应接入真实编排逻辑(只替换模型/工具为 mock),并把指标打到监控系统。 - **注意**:其中的延迟、Token、并发数等数字都是占位值,**必须用自身实测替换**。 ### Q:阶梯压测结果应该怎么分析? A:结论先行——**看三件事:吞吐随并发是否还有增量、延迟是否在某点开始非线性上升、错误率/429 是否在该点抬升。那个"吞吐停止增长而延迟开始飙升"的点就是可用并发,再往前打个安全折扣作为线上并发上限。** 分析思路(配合前面脚本的阶梯输出):  *图:五阶段压测:阶段 4 现拐点,阶段 5 已饱和* ```text 把每个阶段的 (peak_in_flight, 完成吞吐, P95, P99, 错误数) 列成表: 阶段 λ(sessions/s) peak并发 完成吞吐(任务/s) P95(ms) P99(ms) 429/错误 1 1 ~12 ~1 800 1500 0 2 2 ~24 ~2 1200 2600 0 3 4 ~45 ~3.8 2500 7000 0 4 8 ~70 ~4.2 9000 30000 12 ← 拐点 5 16 ~72 ~4.2 20000 90000 85 ← 饱和 判读: - 阶段 3→4:吞吐从 3.8 涨到 4.2(增量变小),P95 从 2500 跳到 9000 → 逼近拐点 - 阶段 4→5:吞吐不再增长(4.2→4.2),延迟翻倍,错误出现 → 已饱和 - 可用并发取值:阶段 3 的 peak 并发(45) × 安全系数(如 0.7) ≈ 30~35 作为线上并发上限 - 瓶颈判定:结合模型侧 429 → 瓶颈在模型配额;若 429=0 而下游 P99 飙 → 瓶颈在下游 ``` 再配合"瓶颈分层指标"进一步定位到具体层,然后针对性扩容或限流,**扩容后要重跑同一组阶梯,验证拐点是否右移**——迁移后的新瓶颈往往出现在下一层。 ## 七、工程实践与踩坑清单 ### Q:Agent 压测与容量规划最常踩的坑有哪些? A:结论先行——**按"压测方法、指标口径、成本、容量落地"四类记。** **压测方法类:** 1. **压测打爆下游。** Agent 会把下游调用量放大数倍且突发,直接对生产下游压测可能造成事故。**对策**:压测走影子/隔离环境,或对下游加限流与熔断;真实调用只留小比例。 2. **只测单轮不测多步。** 见上文。**对策**:压测必须走真实的多步编排循环,覆盖上下文增长与任务级长尾。 3. **mock 不消耗时间。** mock 立即返回,压出来的吞吐虚高。**对策**:mock 必须可配置延迟分布(含排队),且与真实分布校准。 4. **忽略长尾,只看平均。** 按平均延迟设超时阈值和并发。**对策**:以 P95/P99 作为设计和告警基准。 5. **用固定速率代替泊松到达。** 忽略突发性,压不出拐点。**对策**:定压与泊松到达结合使用。 6. **观测窗口太短。** 采到过渡态数据,误判拐点。**对策**:每阶段等稳态、窗口覆盖最慢任务完整生命周期。 7. **mock 与真实差异未校准。** mock 的 Token 估算与实际偏差大,成本与配额估算全错。**对策**:保留小比例真实调用做校准。 **指标口径类:** 8. **把"QPS"当容量。** 一次任务多步多次调用,QPS 无法反映内部压力。**对策**:用并发会话 + 步数 + 模型调用速率描述容量。 9. **步数上限率不监控。** 不知道有多少任务因超步数被截断,效果与容量双失真。 10. **只统计成功请求的延迟。** 超时/失败请求的耗时被丢弃,P99 失真。**对策**:失败请求也计入延迟统计。 **成本类:** 11. **成本未计入容量规划。** 只规划实例数,不管模型配额与 Token 成本。**对策**:实例数、配额、预算三者联合规划。 12. **按任务数算成本,不按模型调用次数算。** 严重低估。**对策**:成本 = 模型调用次数 × 单次 Token 成本。 13. **重试与降级未建模。** 一次问题付费多次。**对策**:把重试率作为成本放大系数显式纳入。 14. **忽略输入 Token 的 O(K²) 累积。** 步数一多成本非线性上涨。**对策**:对齐步数上限与上下文裁剪策略。 **容量落地类:** 15. **并发上限与连接池/线程池不匹配。** 配额给到 100 并发,连接池只有 20,容量被人为掐死。**对策**:全链路并发容量按木桶最短板对齐。 16. **只加应用实例,不解决模型配额。** 配额不够时加实例反而加剧 429。**对策**:先确认配额是否够,再加实例。 17. **没有排队与降级。** 过载时全链路雪崩。**对策**:入口信号量 + 有界队列 + 优先级降级。 18. **容量结论不留安全裕量。** 按压测拐点满负荷上线。**对策**:拐点打安全折扣,留突发裕量。 19. **不做回归。** 模型/工具/业务逻辑一改,旧的容量结论失效。**对策**:把阶梯压测纳入定期回归。 ## 小结 - Agent 容量的核心不是 QPS,而是 **并发会话数 × 平均步数** 推出来的内部模型请求量;必须用"会话 / 步数 / Token / 工具调用"四类指标联合描述。 - 单任务耗时 = Σ(模型调用) + Σ(工具调用) + 编排开销;成本 = Σ(每步 Token 成本) + 外部费用;两者都被步数放大,且输入 Token 近似 **O(K²)** 累积,且都存在长尾。 - 压测的输入是 **会话到达率 + 时长分布 + 步数分布**,并发会话由 **Little's Law(L = λW)** 推得;主力必须 **mock 模型与工具**,mock 要能消耗时间和注入错误,并保留小比例真实调用做校准。 - 用 **阶梯加压 + 稳态观测** 找拐点:吞吐停止增长、延迟非线性上升、错误/429 出现的那一点就是可用上限;瓶颈靠分层排队指标定位,通常落在 **模型配额 → 下游 → 线程池/连接池 → 向量库**。 - 容量反推顺序:**目标并发 → 步数 → 模型调用/Token 速率 → 模型配额 → 实例数(按木桶最短板)→ 成本预算**;配额是硬约束,先算配额再算实例。 - 成本与容量是一个杠杆的两端:**模型分级路由 → 缓存 → 步数上限 → 并发上限与排队 → 降级**,步数上限同时是成本闸门与容量闸门。 - 观测与告警分四层(入口 / 编排 / 模型 / 工具),每层用 **速率 + 延迟分位 + 错误 + 饱和度**;容量预警看并发会话与模型调用速率,而不是等超时。 - 本文所有延迟、Token、并发、成本数字均为**占位示例**,必须用自身实测替换;供应商配额口径(RPM/TPM/并发数)与限流行为**需结合版本确认**。 ## 思考题 1. 如果你只能用一个指标来近似描述 Agent 服务当前的容量水位,你会选"并发会话数"还是"模型调用速率"?为什么,什么情况下这个选择会失效? 2. 设计一个 mock 模型,使其在低并发下延迟接近真实、在高并发下能自然产生排队效应。你会用什么函数形态描述"排队延迟随并发上升"?如何用少量真实调用校准它? 3. 给定"目标峰值 100 并发会话、平均 4 步、SLA P95 ≤ 30s"这三个前提,写出你反推模型配额和应用实例数的完整步骤,并指出每一步的系数从哪里来。 4. 压测发现吞吐在 60 并发处不再增长,但模型 429 为 0、下游 P99 也正常。你的怀疑清单有哪些?如何用最小代价逐一排除? 5. 一个 Agent 把下游打爆了,但线上没有明显异常,只是下游 DBA 报警。你会怎么改压测方案和 Agent 侧的调用方式,避免"压测就是 DDOS"? 6. 步数上限设得越小越省成本、越省容量,但任务成功率可能下降。你会如何用数据决定这个上限?需要采集哪些指标? 7. 模型供应商把配额口径从"并发数"改成"TPM(每分钟 Token)",你的容量模型需要改哪些部分?为什么?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入