🏠 总目录📚 本教程 12 · 限流与成本护栏 ← →

AI全栈 / 12

限制请求次数,就能把模型账单守住吗?

速率、配额与全局预算分别控制不同风险,还要定义超限后的响应和归因。

能为教学场景选择对应护栏并说明核算条件。

核对配额与预算

📑 本页目录(点开跳转)

12 · 限流、配额与成本护栏

⏱ 64 分钟 | ⭐ AI 应用和普通 Web 应用最大的差别:每个请求真的花钱


🎯 一句话

普通接口被刷爆,代价是服务器变慢;AI 接口被刷爆,代价是账单。 所以护栏必须有三层 —— 限流管「多快」、配额管「多少」、全局预算拉闸管「今天最多亏多少」。只做第一层的人非常多,而能一夜烧掉几万块的,恰恰是第三层要防的那种事故。


🧩 一、三层护栏,缺一不可

层 管什么 单位 不做的后果
① 限流 每个用户多快 次 / 分钟 一个脚本把你的并发和上游速率打满,其他人全排队
② ⭐ 配额 每个用户多少 token / 钱 / 月 单个用户一个月慢慢悠悠花掉几千块,限流永远不会触发
③ ⭐ 全局预算拉闸 整个应用今天最多花多少 钱 / 天 一个 bug 循环调 API,一夜烧穿全年预算

⭐ 为什么限流挡不住配额要挡的事:限流是「每分钟 10 次」,一天 1440 分钟 = 14400 次上限。 一个用户老老实实地每分钟 9 次跑一整天,从头到尾没触发过任何限流 —— 但账单是真的。

慢慢进来的请求,也可能把位置占满

长文档总结要运行一阵子。假设服务只允许同时处理 2 个总结,每个要占用 20 秒。前两个在第 0 秒和第 5 秒开始,第 10 秒来了第三个。这一分钟才到 3 次,远低于每分钟 10 次的入口限速,但前两个要到第 20 秒和第 25 秒才完成,第 10 秒时没有空位。

第 0 秒第 1 个总结开始,占 1 个位置。
第 5 秒第 2 个总结开始,2 个位置都占了。
第 10 秒第 3 个总结通过入口限速,等待空位或被拒绝。

并发(Concurrency)数这一刻仍在处理的任务,单位是「个」;请求速率数一段时间内来的请求,单位是「次 / 分钟」等。给在途调用单设上限,可限制同时占用的资源。个人月配额和全局日预算继续管这批请求总共能用掉多少,哪怕它们彼此间隔很久。


🧩 二、限流:令牌桶

令牌桶的形状是:一个桶按固定速率往里滴令牌,桶有容量上限;来一个请求就拿走一个,没得拿就拒绝。 两个参数分别对应两件事:滴速 = 长期允许的速率,桶容量 = 允许多大的突发。

下面的独立TokenBucket实验保留了两位小数的舍入返回。代码注释和print把它称作Retry-After,仅可按内部/展示等待值理解,不能直接用作合规HTTP响应头,也不代表未舍入精确等待;后面的中间件例会保留原始wait再转换。

import time


class TokenBucket:
    def __init__(self, rate, burst, clock=time.monotonic):
        self.rate, self.burst = rate, burst   # 每秒补几个 / 桶最多装几个
        self.tokens, self.clock = float(burst), clock
        self.ts = clock()

    def take(self, n=1):
        now = self.clock()
        # ⭐ 不开线程定时补令牌:用「距上次过了多久」现算,少一个线程也不会漂
        self.tokens = min(self.burst, self.tokens + (now - self.ts) * self.rate)
        self.ts = now
        if self.tokens >= n:
            self.tokens -= n
            return True, 0.0
        # ⭐ 拒绝时顺手算出「等多久才够」——这个数直接写进 Retry-After 响应头
        return False, round((n - self.tokens) / self.rate, 2)


now = [0.0]                                   # 假时钟,让结果可复现
b = TokenBucket(rate=2, burst=5, clock=lambda: now[0])
print("桶满时连发 7 次:", [b.take()[0] for _ in range(7)])
print("被拒时 Retry-After:", b.take()[1], "秒")
now[0] += 3.0                                 # 等 3 秒补 6 个,但桶只装得下 5 个
print("等 3 秒后再连发 7 次:", [b.take()[0] for _ in range(7)])

这个假时钟实验中,桶满时前 5 次通过、后 2 次被拒,已舍入的内部/展示等待值为0.5秒;等3秒后又是5通过2拒(补了6个但桶只装5个)。缺的令牌数÷滴速给出内部等待秒数;这里保留的 round(..., 2) 结果不是未舍入精确值,也不能直接作为HTTP字段。该例0.5秒若以合法数字头表示,应为 Retry-After: 1。

⚠️ 固定窗口的边界漏洞

另一种常见实现是固定窗口计数:按整分钟分桶,每桶限 N 次。省内存,但跨桶那一瞬间能放进两倍流量。

实测(把 59.0–59.9 秒的 10 次和 60.0–60.9 秒的 10 次喂进去,限额是「每 60 秒 10 次」):固定窗口放过 20 次,滑动窗口只放过 10 次。这 20 次落在 2 秒之内。

固定窗口 滑动窗口(记录每次时刻) 令牌桶
内存 一个计数器 ⚠️ 跟着 QPS 走 两个数
边界 ⚠️ 能放进两倍 精确 精确
突发 说不清 不允许 ⭐ 参数可调

⚠️ 多实例部署时,桶必须是共享的。每个进程各持一个桶 = 实际限额乘以进程数。放 Redis 里,并且用一个 Lua 脚本把「读 + 算 + 写」做成一次原子操作 —— 分成三次命令,中间那道缝就是超发的来源。

可跳过:共享限流里的原子性,不等于SQL式回滚

Pipeline把命令批量发送,主要减少往返和协议开销;它自身不承诺一组命令隔离执行。若第二条依赖第一条读回的结果,客户端仍要等待/计算,不能把“批量GET/SET”当作原子限流。

MULTI/EXEC把命令排队,在EXEC时按序执行、不与其他客户端命令交错;DISCARD丢弃尚未执行的队列,不是EXEC后的撤销。排队期的语法/参数等错误可能使EXEC整体拒绝;执行期类型错误则在对应回复中报错,其他已排队命令仍会执行,不能假定都自动回滚。

一个教学预期轨迹(未跑Redis):初始quota=0,MULTI中排入INCR quota、对字符串key错误使用LPUSH、INCR quota;执行期中间那条类型错误不自动撤销两次合法INCR,quota可到2。客户必须检查EXEC中每条结果,不能只看“发过EXEC”。

WATCH用于乐观比较更新:先监视key、读取并计算,再MULTI提交;被监视值在EXEC前变化会使提交中止,客户端重新读取并有界重试。它不是长期持有的互斥锁,连接状态/连接池使用要正确。Redis7.2中相关过期变化也在监视语义内;不要套用旧版本的例外。

Lua适合把当前限流的读、条件判断和写放到服务器一次执行,执行期间不与其他客户端操作交错;长脚本也会阻塞服务。这里的原子执行不应被理解成遇任何运行错误都自动恢复SQL事务前的状态:先验证类型、参数和上限,再写,并设计失败/重试结果检查。跨数据库/对象服务的副作用更不在脚本原子性里。依据 Redis事务、Pipeline、Lua执行说明;本节不做服务器线程或全局分布式事务教程。


🧩 三、配额与全局预算拉闸

这两件事的形状是一样的:一个账本 + 一条带条件的扣减语句。关键是判断和扣减必须在同一条语句里 —— 「先 SELECT 看看够不够、再 UPDATE 扣掉」中间那道缝,会让两个并发请求都看到「还够」。

import sqlite3

db = sqlite3.connect(":memory:")
db.execute("CREATE TABLE quota(user TEXT PRIMARY KEY, used INTEGER, cap INTEGER)")
db.execute("CREATE TABLE budget(day TEXT PRIMARY KEY, spent INTEGER, cap INTEGER)")
db.executemany("INSERT INTO quota VALUES(?,0,100)", [("u1",), ("u2",)])  # 单位:分
db.execute("INSERT INTO budget VALUES('2026-08-07',0,150)")
db.commit()


class Blocked(Exception):
    pass


def reserve(user, day, cents):
    """调模型【之前】先预扣。返回 ok / quota / budget_stop。"""
    try:
        with db:   # ⭐ 抛异常自动回滚:不会留下「全局扣了、个人没过」的脏账
            # ⭐ 条件写在 WHERE 里,不是先 SELECT 再 if —— 那道缝就是超发的来源
            if db.execute("UPDATE quota SET used=used+? WHERE user=? AND used+?<=cap",
                          (cents, user, cents)).rowcount == 0:
                raise Blocked("quota")
            if db.execute("UPDATE budget SET spent=spent+? WHERE day=? AND spent+?<=cap",
                          (cents, day, cents)).rowcount == 0:
                raise Blocked("budget_stop")
    except Blocked as e:
        return str(e)
    return "ok"


for u in ["u1", "u1", "u1", "u2", "u2"]:
    print(u, reserve(u, "2026-08-07", 40))
print(db.execute("SELECT user, used FROM quota").fetchall(),
      db.execute("SELECT spent FROM budget").fetchone())

输出是 ok / ok / quota / ok / budget_stop,最后 [('u1', 80), ('u2', 40)] (120,)。 ⭐ 注意最后一次:u2 的个人配额还够(40 + 40 ≤ 100),是全局日预算拦下的(120 + 40 > 150);而且因为异常触发了回滚,u2 的 used 停在 40 而不是脏成 80。这就是第三层护栏存在的意义。

⚠️ 预扣要在调用之前,结算要在调用之后。调用前你只有一个估的 token 数(输出多少还不知道),所以流程是:按可计费上限预留预算 → 调用 → 拿到真实用量后结算,释放多预留的部分。只在调用后记账,等于在超支之后才知道超支了。

⭐ 预算拉闸要告警到人,但恢复不能只靠等几秒。 它看账本是否还有余额;依赖故障熔断看上游是否恢复,是两道不同的门:

门 / 状态现在怎么处理何时恢复 / 转移
预算拉闸预扣后会超支就拒绝新调用真实结算释放预留、预算窗口重置或经授权调额后,重新检查余额;不靠探测请求恢复
故障熔断 · closed正常调用,统计约定窗口内的依赖失败达到配置的失败阈值与最小样本量 → open
故障熔断 · open快速拒绝或降级,暂停向坏依赖发请求冷却到期 → half-open,只放限量探测
故障熔断 · half-open限制探测并发,其余流量仍拒绝或降级,避免刚恢复就被压垮探测达到成功条件 → closed;探测失败 → open 并重新冷却

⚠️ 失败分类、阈值、最小样本量、冷却时间和探测并发要按依赖与流量配置,没有通用固定值;故障恢复也不会补回预算,两道门都允许才发起调用。

可跳过:把配额扣减迁到有限库存

同一活动内,以可信用户+稳定请求号建立唯一记录,绑定商品与正整数数量的参数指纹:同号同参重放结果,同号异参拒绝。首次有效请求在同一数据库事务中认领请求、在库存足够时条件扣减,并保存订单预占与可靠处理意图;失败整体回滚。请求号规则复用 03c 的幂等合同。

手算最后 1 件:A 预占后余 0,B 的条件扣减失败;A 的响应丢失时先按原号查结果,不能再扣一次。完成与取消/到期只能从预占状态原子迁移到一个终态:完成先成功,取消不释放;取消先成功,在同一事务归还一次,重复取消不再归还,迟到完成不得继续。外部结果未知时先查单核对,不能凭超时释放后又盲目完成。

教学假设 1 万人在 1 秒内各请求 1 次,入口平均约 1 万请求/秒,重试另计;这不是已测容量。准入速率、队列容量和等待上限须按下游能力验证,满载明确拒绝;可靠投递复用 11 章。本框只迁移账本不变量,万人容量、外部支付和真实并发均待验收。


🧩 四、在哪一层拦

⭐ 三处都要拦,各拦不同的东西。 只在一处拦,另外两类攻击面全裸着。

位置 拦什么 为什么必须在这一层
网关 / 反向代理 按 IP 的粗粒度洪水、超大请求体 ⭐ 这一层的请求还没进你的进程,最便宜。但它不知道「谁是谁」
应用中间件 按用户/租户限流、检查配额 认证之后才知道用户是谁。⚠️ 要放在认证之后、业务逻辑之前
⭐ 调用层 每次调模型前预扣、之后记账 这里能在发出前确定模型和用量上限,返回后再拿实际用量和缓存命中。一次请求可能调 5 次模型,中间件那层看不见

⚠️ 只在中间件拦的典型漏洞:一个 Agent 请求内部循环调了 40 次模型。 中间件看到的是「1 次请求」,全都放行 —— 钱是在调用层花的,护栏也得在调用层。

⭐ 中间件这一层怎么接线

第 3 章第四节埋了两个空壳依赖,其中 quota 就是留给这一章的挂载点(另一个 current_user 留给第 8 章)。现在把它填上:

本例的输入合同:rate为有限正数,桶配置有效,待序列化的原始wait为有限非负实数。负数、NaN、正负无穷和非数值明确排除,不应传入转换;本教学片段未实现这类配置校验,不能据此声称服务会拒绝非法配置。

内部小数不直接上HTTP头。Retry-After允许HTTP-date或非负十进制整数秒,本例选数字形式,语法为ASCII [0-9]+,对原始wait向上取整:0.004→1、0.5→1、1→1、1.004→2;精确零→0合法。不能先round再ceil,否则小正等待会变成0或偏小值。依据 RFC9110 §10.2.3。

import math
from typing import Annotated

from fastapi import Depends, FastAPI, Header, HTTPException
from fastapi.testclient import TestClient


class Bucket:
    """第二节那个令牌桶,缩到最短:⚠️ 省掉了按时间补令牌那半截(完整版在第二节)。
    本段的重点不是桶怎么写,是【它挂在哪】。"""

    def __init__(self, rate=2.0, burst=3):
        self.rate, self.tokens = rate, float(burst)

    def take(self):
        if self.tokens >= 1:
            self.tokens -= 1
            return True, 0.0
        return False, (1 - self.tokens) / self.rate   # 差多少 ÷ 滴速


app = FastAPI()
BUCKETS = {}          # ⚠️ 单进程演示用;多实例部署必须放 Redis(第二节)


def current_user(authorization: Annotated[str, Header()] = ""):
    if not authorization.startswith("Bearer "):
        raise HTTPException(401, "unauthorized")
    return {"uid": authorization[7:]}            # 第 8 章换成真的 token 校验


def guard(user: Annotated[dict, Depends(current_user)]):
    # ⭐ 依赖套依赖:顺序天然就是「认证之后、业务之前」,不用在每个路由开头手写
    ok, wait = BUCKETS.setdefault(user["uid"], Bucket()).take()
    if not ok:
        raise HTTPException(429, "rate limited", headers={"Retry-After": str(math.ceil(wait))})
    return user                                  # 配额扣减(第三节的 reserve)也挂在这里


@app.post("/chat")
def chat(user: Annotated[dict, Depends(guard)]):
    return {"uid": user["uid"]}                  # ⭐ 业务函数里一行限流代码都没有


c = TestClient(app)
h = {"Authorization": "Bearer u1"}
print("u1 连打 5 次:", [c.post("/chat", headers=h).status_code for _ in range(5)])
print("被拒时 Retry-After:", c.post("/chat", headers=h).headers["Retry-After"], "秒")
print("换成 u2:", c.post("/chat", headers={"Authorization": "Bearer u2"}).status_code)
print("不带 token:", c.post("/chat").status_code)

示例预期输出:[200, 200, 200, 429, 429],内部等待0.5秒在响应中表示为 Retry-After: 1;换成u2是 200(⭐ 桶是按用户分的,一个人打爆不该影响别人),不带token是401(还没进到限流就被上一层依赖拦了)。这里区分标准库可核对的字段转换与需另行运行的FastAPI/TestClient服务示例。

代码末尾的注释指的是示意挂点。真正接线时,用户级检查可以在认证后做;每次模型尝试的金额预留要在调用层再原子检查一次,一次网页请求里的多次模型调用也各自过账。

⭐ 三件事值得注意:① 业务函数 chat() 里一行限流代码都没有——这就是第 3 章说「依赖注入不是花架子」的兑现;② ⚠️ 顺序是靠依赖链保证的,不是靠你记得把中间件注册在正确的位置(第 16 章那条「限流中间件挂在认证之前所以永远拿不到用户」就是手写顺序才会犯的错);③ 换到 Node / Go 就是中间件,Depends 这个名字会过期,「每请求要做的事得有统一的地方挂」不会。


🧩 五、超限之后怎么办

策略 怎么做 什么时候用 ⚠️ 代价
拒绝 429 + Retry-After: 12 默认。本应用能算出等待时应主动提供合法字段;RFC6585对429是MAY,客户端宜按合法值退避 用户看到报错
降级 换成小模型 / 缩短上下文 / 关掉重排 功能允许质量打折时最好用 ⚠️ 必须告诉用户,否则就是偷偷变差
排队 转成异步 job,做完再通知 任务本来就不需要即时结果 队列会积压;⚠️ 排队本身要有上限,否则只是把爆炸推迟

⚠️ 协议允许429携带Retry-After,并非强制必选。本应用能计算等待时应主动提供合法字段;客户端宜识别其支持的格式,尊重等待并结合有上限的退避与非负抖动,不能假定所有客户端都会遵守。忽略等待、立即反复重试可能放大负载。依据 RFC6585 §4。

先看是谁拒绝的、拒绝时走到了哪一步。 本应用的入口限速拒绝发生在模型调用前;配额用完要等额度释放、窗口重置或授权调整,短时间重发解决不了。上游超时则可能已经开始处理。对于 POST,自动重试前要确认原请求未执行,或有服务端支持的幂等保证;同一业务意图继续使用原请求号,次数和等待时间都有上限。见 RFC 9110 §9.2.2 和 03c 的幂等合同。


🧩 六、成本归因:别只知道总账单涨了

⭐ 每次调用至少记三个维度:谁(user_id)、哪个功能(feature)、哪个模型(model)。少记一列,就有一个维度永远查不出来。月底账单涨了 40%,没有这三列你只能猜;有了,一条 GROUP BY 就知道是谁。

⭐ 这张表不是新的:它就是第 4 章第四节 record() 那个最小字段集落进库的样子。那一章的原话是「有了这张表,12 章的配额扣减、15 章的成本看板都只是拿它做聚合」—— 本节就是那个聚合的第一个用处,第 15 章的成本看板是第二个。所以下面这张表的列和那边一一对应,不要在项目里建第二张。

⚠️ 单价表也全项目只该有一份(第 4 章那个 cost_of 就是它)。这里为了让金额能当场心算,示例价换成了「分 / 千 token」,而第 4 章那张写的是「元 / 百万 token」—— ⭐ 两边单位不一样这件事本身就是个坑:真项目里挑一个单位钉死在一处,混用会让你的账和厂商账单差一个数量级,而且极难查。

import sqlite3

PRICE = {"big": (0.30, 1.50), "small": (0.02, 0.08)}  # 🗓️ 示例价:分/千token,会变
CACHE_RATE = 0.1        # 🗓️ 示例:命中缓存的输入按几折算,各家不同

db = sqlite3.connect(":memory:")
# ⭐ 就是第 4 章 record() 的字段集,一列不多一列不少
db.execute("""CREATE TABLE calls(trace_id TEXT, user_id TEXT, feature TEXT, model TEXT,
              tok_in INT, tok_out INT, ms INT, cached INT, retries INT, cents REAL)""")


def log(trace_id, user_id, feature, model, tok_in, tok_out, ms=0, cached=0, retries=0):
    pin, pout = PRICE[model]
    # ⭐ 缓存命中的输入必须单独算,否则你的账和厂商账单永远对不上
    c = round((tok_in - cached) / 1000 * pin + cached / 1000 * pin * CACHE_RATE
              + tok_out / 1000 * pout, 4)
    # ⭐ user_id / feature / model 少记一列,就有一个维度永远查不出来
    db.execute("INSERT INTO calls VALUES(?,?,?,?,?,?,?,?,?,?)",
               (trace_id, user_id, feature, model, tok_in, tok_out, ms, cached, retries, c))
    db.commit()
    return c


log("t-1", "u1", "chat", "small", 1200, 400, ms=900)
log("t-2", "u1", "summary", "big", 30000, 800, ms=9400, cached=28000)
log("t-3", "u2", "summary", "big", 30000, 800, ms=9600)   # 同样的活,没命中缓存
for r in db.execute("SELECT user_id, feature, model, cents FROM calls"):
    print(r)

⚠️ 别只看 token 数

上面跑出来的三行是 0.056 / 2.64 / 10.2 分(用示例价表算的)。两个对比:同样的 30000 + 800 token,命中缓存的那次 2.64 分、没命中的 10.2 分,差 3.9 倍;而一次大模型长上下文 10.2 分 vs 一次小模型短对话 0.056 分,差 182 倍。

⭐ 所以「本月 token 数涨了 20%」这句话没有信息量 —— 同样的 token 数,落在不同模型、不同缓存命中率上,账单可以差两个数量级。记账要记钱,不要记 token(token 数也留着,出问题时拿它对账)。

走一遍长文档总结:从点击到结算

用户点一次「总结」,浏览器要知道有没有拿到结果,服务器还要知道这一次占了多少预算。下面是一套教学接口,沿用上面的 big 价表,金额统一用美分。doc_id 指向已上传的文档,服务器用认证信息识别用户,并核验他能否访问该文档。

POST /summaries
Authorization: Bearer <本应用凭证>
Content-Type: application/json
Idempotency-Key: summary-17

{"doc_id":"doc-17"}

服务器在用户和操作的范围内认领 summary-17,给这次物理调用另记尝试号。请求携带的业务号用于重查或复用原任务;若同一个业务号改传另一份文档,则按本接口的幂等合同拒绝。

① 准入认证 → 限速 → 并发有空位。
② 预留同一事务检查个人配额、全局日预算。
③ 发出调用带输出上限,并保留本地尝试号。
④ 核算用量确认后结算,未知则保留预留。

预留 11.25 分。 假设服务器已按模型口径数清完整输入为 30,000 token,并限制最多生成 1,500 个计费输出 token。这笔调用只有输入、输出两类费用。发送前还不知道会不会命中缓存,所以先按无缓存单价预留。千 token 数 = token 数 ÷ 1,000,乘上每千 token 单价才是美分。代入得到 (30,000 ÷ 1,000) × 0.30 + (1,500 ÷ 1,000) × 1.50 = 9.00 + 2.25 = 11.25 分。如果个人月余额 12 分、全局当日余额 16 分,两边都能锁住这同一笔 11.25 分。

完成后实扣 2.64 分。 上游返回了可用的摘要及用量:输入 30,000 个,其中 28,000 个命中缓存,输出 800 个。示例里缓存命中的输入按原单价的 0.1 倍收费。把输入分成两组,避免重复收费:(2,000 ÷ 1,000) × 0.30 + (28,000 ÷ 1,000) × 0.30 × 0.1 + (800 ÷ 1,000) × 1.50 = 0.60 + 0.84 + 1.20 = 2.64 分。把 11.25 分的预留换成 2.64 分的已花费,释放 11.25 − 2.64 = 8.61 分。个人和全局两个窗口都登记 2.64 分,是同一次消费在两个口径下的记录。

200 OK
Content-Type: application/json

{"request_id":"summary-17","summary":"会议决定先发布试用版。"}
失败 A · 模型还没被调用

如果在第 ① 步触发本应用的入口限速,返回 429、Retry-After: 1 和 JSON {"error":"rate_limited"}。这次没有预留,也没有上游模型费用。仍需总结时,客户端至少等 1 秒,在重试限额内用同一个业务号再次提交;入口还会重新检查,等 1 秒不保证放行。如果走到第 ② 步却发现全局只剩 10 分,连预留都不提交,也不调用模型。

失败 B · 模型可能已在生成

把同一功能切成流式模式后,如果第 ③ 步发出请求,流却在收到用量前中断,页面应将结果标为未完成或待查询。账本保留 11.25 分预留,并把用量标为待核算。第 5 章里的取消只能发出停止信号;是否已停、是否产生费用还要看上游。优先通过原业务号查状态,有上游请求号时按供应商支持的方式查用量或对账;确认零费用才全额释放。没有可按次查询的用量时,进入待核算流程,记录可用证据。

生产记账要区分业务号和尝试号,并记录预留金额、用量状态、价格版本、已知费用及关联的上游请求号。按尝试号原子地结算一次,重复收到同一结果也只实扣一次。若确实获准另发模型尝试,重新走准入和预留,把两次费用都归到原业务号。使用固定最小金额单位保存,精度要足以保留例中的小数分。这个 11.25 分上限依赖输入已核实、输出受限且没有额外收费项;工具调用等费用需要单独纳入预留。


💀 事故复盘:前端重试写错,一夜烧穿预算

⚠️ 这是一个构造的教学案例,不是真实统计。下面每个数字都是用本章那张示例价格表算出来的,你可以自己验算。

发生了什么。 一个「长文档总结」功能,每次调用约 30000 输入 + 800 输出 token,按示例价表是 10.2 分($0.102)。前端给流式接口设了 5 秒首字超时:超时便断开重发,既没有次数上限,也没有退避。

但 30000 token 的输入本来就要六到八秒才有首字,于是每次请求都在第一帧前被掐掉。后端又没有断连感知(第 5 章),仍把整段回答生成完、照常计费。11 个用户的标签从 22:00 挂到次日 07:00,共 9 小时。

⭐ 这个事故的形状要看清楚:后端每一次都成功了。 前端认定失败、后端认定成功,两边的判断从头到尾没对上过 —— 这正是下面三条监控全说「正常」的根源。

为什么没被发现。 三条监控全都显示「正常」:

  1. 成本告警是按账单发的,而账单数据 T+1 才到 —— 事故当晚根本没有数据
  2. 服务健康指标看 5xx 率和 p99 延迟。⚠️ 流式响应的 200 在第一个字之前就已经发出去了(第 5 章),这些请求在服务端的记录里全是 200,耗时也在这个功能平时的区间里 —— 曲线上完全正常
  3. QPS 确实涨了,但 71280 ÷ 32400 秒 = 2.2 QPS,绝对值太小,淹没在正常波动里

⭐ 最刺眼的一点:花掉 $7270 的过程中,没有任何一个系统认为出了问题。

该补什么(四条,都在本章里):

  1. ⭐ 全局日预算拉闸 —— 第三节那条 UPDATE ... WHERE spent+?<=cap。$5000 的月预算折成日上限 ≈ 167 美元;烧钱速度是 2.2 QPS × $0.102 ≈ 0.22 美元 / 秒,所以它在重试风暴开始后约 12 分钟(22:12 前后)就会把开关拉掉,当天损失止步在日上限那 167 美元。⚠️ 别忘了跨零点会重置:新的一天再烧十来分钟才第二次拉闸,两天合计约 334 美元 —— 是 7270 的 1/22
  2. 按用户限流 —— 令牌桶。一个标签打不出 6480 次
  3. ⭐ 成本告警看自己记的账,不看账单 —— 第六节那张 calls 表是秒级可查的,T+1 的账单只配用来对账。⚠️ 但要分清分工:拉闸靠预算检查,告警只负责让人看见;只有告警没有预算拉闸,你得到的是一条「你已经烧掉了很多钱」的通知
  4. 客户端重试必须有上限 + 退避 + 抖动 —— 见上一章的 backoff()。⭐ 这次还多一条根因:客户端的超时阈值不能比这个功能正常的首字延迟还短,否则重试逻辑写得再规矩也会一直被触发

🔁 换个栈怎么对应

概念 Python / FastAPI Node(Express / Hono) Go
令牌桶 自己写 / SlowAPI rate-limiter-flexible golang.org/x/time/rate
网关层限流 Nginx limit_req / 云 API 网关(三边一样) 同 同
分布式计数 Redis + Lua 原子脚本(三边一样) 同 同
依赖故障熔断(不负责预算账本) 自己写 / pybreaker opossum sony/gobreaker
配额账本 一条带条件的 UPDATE(三边一样) 同 同

⭐ 这一章里真正和语言有关的只有令牌桶那 20 行。账本、原子扣减、Retry-After、按三维度记账,换什么栈都一模一样。


🔗 这一章连到哪里

去哪 为什么
03 · 后端骨架 ⭐ 那一章第四节埋的 quota 空壳依赖就是本章第四节的挂载点:限流和配额接在哪、为什么「认证之后、业务之前」这个顺序不用你自己记
04 · 调用层 ⭐ 本章第六节那张 calls 表就是它 record() 的落库版本,单价表也在那边。先有记录才谈得上限制,顺序不能反
成本与容量 ⭐ 分界要记清:那边是模型推理的容量规划(要几张卡、QPS 撑不撑得住、怎么压单位成本),本章是应用层的护栏(谁能花、花多少、超了怎么办)。产能问题去那边,花钱问题在这里
可观测性与成本 自建推理时成本结构完全不同(按 GPU 小时算,核心指标是利用率),和调 API 按 token 付费是两种账。你要做自建 vs API 的成本对比,去那边拿另一半
KV-Cache 本章说「缓存命中便宜 3.9 倍」,为什么便宜在那边:命中的部分不用重算前向
接进真实产品 那边的「护栏」管模型说了什么(结构化输出、内容审核),本章的护栏管花了多少钱。两种护栏都要,别互相替代

✅ 检查点

  1. 三层护栏分别管什么?各自的单位是什么?
  2. 为什么「每分钟 10 次」的限流挡不住配额要挡的事?给出算式。
  3. 令牌桶的两个参数各对应什么?内部等待秒数怎样转换成合法的数字形式 Retry-After?
  4. 固定窗口的边界漏洞是什么?本章那个实测里两种实现分别放过了几次?
  5. 为什么配额扣减的条件必须写在 UPDATE 的 WHERE 里?
  6. 示例代码最后一次调用被谁拦下的?u2 的 used 为什么停在 40?
  7. 三处拦截各拦什么?只在中间件拦会漏掉什么?
  8. 为什么「本月 token 数涨了 20%」这句话没有信息量?给出本章的两个倍数。
  9. 事故里三条监控为什么都没报警?
  10. 第 10 秒到达的第三个总结,通过了入口限速却没开始执行。哪项资源用完了?
  11. 预留 11.25 分,最终确认花了 2.64 分,应释放多少?如果流断开且用量还未知,又该怎样处理?
👀 答案
  1. 限流管「多快」(次/分钟)、配额管「多少」(token 或钱 / 月)、全局预算拉闸管「今天最多亏多少」(钱/天)。
  2. 每分钟 10 次 × 1440 分钟 = 一天 14400 次上限。一个用户每分钟 9 次跑一整天,从没触发过限流,但账单是真的。
  3. 滴速 = 长期允许的速率,桶容量 = 允许多大的突发。缺的令牌数÷滴速是内部等待秒数;对有限非负原始wait,本例用 str(math.ceil(wait)) 生成ASCII非负整数字段。0.5秒对应头值1,0.004→1、1.004→2;精确零→0合法。不能先做展示舍入;负数和非有限值明确排除。429允许而非强制携带该头,本应用能算出时应主动提供。
  4. 按整分钟分桶,跨桶那一瞬间能放进两倍流量。实测(限「每 60 秒 10 次」):固定窗口放过 20 次,滑动窗口放过 10 次。
  5. 「先 SELECT 看够不够、再 UPDATE 扣」中间有一道缝,两个并发请求会都看到「还够」。写进 WHERE 才是一次原子的「判断 + 扣减」。
  6. 被全局日预算拉闸拦的 —— u2 个人配额还够(40+40 ≤ 100),但日预算 120+40 > 150。used 停在 40 是因为抛异常触发了回滚,没留下「全局扣了、个人没过」的脏账。
  7. 网关拦按 IP 的洪水和超大请求体(最便宜,但不知道谁是谁);中间件按用户限流、查配额(放在认证之后、业务逻辑之前);调用层预扣和记账(只有这里知道用了哪个模型、多少 token、有没有命中缓存)。只在中间件拦,一个内部循环调 40 次模型的 Agent 请求会被当成「1 次」放行。
  8. 同样的 token 数落在不同模型和缓存命中率上,账单差两个数量级:命中缓存 2.64 分 vs 没命中 10.2 分 = 3.9 倍;大模型长上下文 10.2 分 vs 小模型短对话 0.056 分 = 182 倍。所以记账要记钱。
  9. 根源是后端每一次都成功了(前端因为 5 秒首字超时判定失败,后端照样把整段生成完),所以:① 成本告警按账单发,账单 T+1 才到;② 服务健康看 5xx 和 p99,而流式的 200 在第一个字之前就发出去了,这些请求在服务端记录里全是 200、耗时也正常;③ QPS 只有 2.2(71280 ÷ 32400 秒),淹没在正常波动里。
  10. 用完的是并发位置。第 10 秒前两个任务都未完成,2 个位置已占满。这一分钟的 3 次到达还没碰到入口速率上限。
  11. 确认费用后释放 8.61 分,只实扣 2.64 分。用量未知时保留预留,先按原请求号查状态、核实用量或走待核算流程。前端断线和模型计费是两件事。

本节回顾

⚡ 走神救援

⭐ 限流管多快、配额管多少、全局预算拉闸管总花费;依赖故障熔断另管上游健康,按 closed → open → half-open 限量探测,成功恢复、失败再冷却。

护栏分别挂在网关、认证后的中间件和调用层;调用前原子预扣,调用后按真实用量结算并记钱,多实例共享限流与预算状态。

回想事故只抓一条主线:超时过短触发反复重试,后端却次次生成完;重试要有上限与退避,预算检查负责拉闸,告警负责让人看见。

下一节 👉 13-配置与密钥.md

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