多实例 API 限流:谁有权花掉同一份额度

从租户额度出发,比较单机桶、集中裁决与批量配额,用可执行模型拆解时间、原子性、策略迁移和故障误差,说明保护性限流为何不能替代结算约束。

一个租户被承诺每秒最多调用一百次导出接口。服务有十个副本,每个副本都配置“一百次每秒”,压测时却能放进接近十倍的流量。把单机数字除以十,扩容后又会变错;请求分布不均时,一部分副本已经拒绝,另一部分还闲着。

问题不在令牌桶公式,而在谁有权花掉同一份预算。本文讨论一个具体场景:多租户 API 的保护性限流,目标是控制下游负载,并给租户相对稳定的调用机会。它不是账单结算,不是库存扣减,也不是“绝不能多发一次”的付款额度。这个区别决定了我们可以接受哪些故障,以及是否值得把每次请求都送到一个中心裁决点。

我的选择是:中等规模、单地域服务先采用按租户集中裁决,入口另加粗粒度保护;只有实际测得中心往返或热点成本成为问题后,才引入批量配额。把精确性、延迟和故障时可用性同时写成保证,通常只是把矛盾藏进了实现。

先把“每秒一百次”说清楚

固定窗口的含义可能是每个整秒计数不超过一百。它允许上一秒末尾的一百次和下一秒开头的一百次挤在极短时间内。滑动窗口可以限制任意一秒的总量,但需要保存或近似维护更多历史。令牌桶则表达另一种契约:持续补充速度为 R,最多积累 B 个令牌,因此在正常的连续时间模型中,任意长度为 T 的区间,获准成本不超过初始可用额度加 R×T,初始额度最多为 B。

这不是同一件事。假设 R 为一百次每秒、B 为二十次,刚开始就能通过二十次,随后平均每十毫秒补一个。它适合允许小突发、限制持续压力的接口,却不直接满足“任意一秒最多一百次”的字面要求。产品页面、调用方文档和监控图如果分别采用不同口径,限流器即使没有程序错误,也会不断产生争议。

请求成本也不应天然等于一。查一条记录与导出十万条记录消耗不同,但不能把用户提供的 cost 原样送入限流器。成本应由服务端根据认证后的路由、套餐和已验证参数确定,并有上限。超过桶容量的请求不能靠等待变成可执行,应拆分任务、切换异步流程,或者明确拒绝。

还要把准入次数与在途数量分开。每秒只允许十次、每次执行一分钟,系统仍可能积累数百个在途任务。速率限制控制进入速度,并发隔离控制同时占用的资源,两者缺一不可。下面的桶不会替代数据库连接池,也不会替代导出工作器的并发上限。

三种部署方式,真正交换的是什么

单机桶最简单,没有网络往返,进程内锁就能保护状态。它适合保护该实例的 CPU、连接数或内存,不适合直接兑现租户全局额度。十个实例各自保存完整桶,相当于发出了十份消费权;这不是“最终会一致”的误差,而是契约已经改变。

集中裁决把同一租户的状态放到同一个权威位置。每次请求经过认证、取得策略版本、调用限流器,再进入业务处理。拒绝发生在昂贵操作之前,外部攻击流量则应先经过更粗的入口防护,避免所有垃圾请求都变成中心存储操作。中心可以按租户分片,不必让所有租户共享一把全局锁;但单个超级租户仍然是热点,分片无法拆掉它自身的一致性需求。

批量配额把一部分消费权提前发给实例。中心先扣掉一批,实例本地逐个消耗,减少远程调用。好处是延迟低、短暂断网仍能使用已获配额;代价是某个实例崩溃时,未用额度可能被浪费。如果中心在不知道旧实例是否仍能使用的情况下重新发放,就会产生重复消费权。节省网络调用并不免费,它要求额外设计配额身份、有效期、失效规则和恢复协议。

例如中心一次发给每个实例二十个配额,十个实例就可能持有两百个未花额度。它们在同一时刻消费,造成的实际入口突发可以大于中心桶的单次突发参数。中心限制的是发放时间,不再等同于真实执行时间。若业务在意实际请求的短窗口上限,批量配额必须另外约束使用节奏,或者承认这是近似限流。

因此我不会仅凭“Redis 每秒能处理很多命令”决定方案。先测当前峰值请求量、单次裁决的尾延迟、热点租户占比和失效预算,再判断是否需要把复杂性推到每个应用实例。

用整数表达令牌,避免把时间损失藏进取整

下面给出可执行的单进程参考模型,使用 Python 3.12,无第三方依赖。它不是分布式服务,而是把状态转移精确写出来,供不同存储实现做一致性对照。令牌以千分之一为内部单位,时间以毫秒为单位;每秒 R 个令牌,对应每毫秒增加 R 个内部单位。

保存为 bucket.py。生产调用方不能提供时间,测试中显式传入时间只是为了构造可重复边界。

from dataclasses import dataclass
from threading import Lock

@dataclass
class State:
    credit: int
    last_ms: int

class Bucket:
    def __init__(self, capacity, rate, start_ms=0):
        if capacity <= 0 or rate <= 0:
            raise ValueError('positive capacity and rate required')
        self.cap = capacity * 1000
        self.rate = rate
        self.s = State(self.cap, start_ms)
        self.lock = Lock()

    def take(self, now_ms, cost=1):
        if cost <= 0 or cost * 1000 > self.cap:
            raise ValueError('cost outside bucket range')
        with self.lock:
            now = max(now_ms, self.s.last_ms)
            credit = min(
                self.cap,
                self.s.credit + (now-self.s.last_ms)*self.rate
            )
            need = cost * 1000
            allowed = credit >= need
            if allowed:
                credit -= need
            wait_ms = (
                0 if allowed
                else (need-credit+self.rate-1)//self.rate
            )
            self.s = State(credit, now)
            return allowed, wait_ms

这里的锁覆盖读取、补充、判断和扣除。若先读取再在锁外判断,两条请求就可能同时看到最后一个令牌,并且都通过。内部余额保留小数部分,因此频繁查询不会把每次不足一个令牌的补充丢掉。拒绝请求也更新时间和余额,但不扣消费额。

max 防止时间倒退使余额减少,也防止把较早时间重新写回后,在下一次调用时重复计算同一段补充。它不能解决时钟突然向前跳的问题:向前跳会提前补满。单进程可用单调时钟;跨机器持久化时不能随意把各进程的单调时间混在一起。需要选择同一个裁决端的时间源,监控时钟变化,并把故障切换后的时间解释列入测试。

补充下面代码后运行 python3 bucket.py,可以检查容量耗尽、毫秒边界、回拨与并发:

if __name__ == '__main__':
    b = Bucket(2, 1)
    assert b.take(0) == (True, 0)
    assert b.take(0) == (True, 0)
    assert b.take(0) == (False, 1000)
    assert b.take(999) == (False, 1)
    assert b.take(1000) == (True, 0)
    assert b.take(500) == (False, 1000)
    assert b.take(2000) == (True, 0)
    assert b.take(10000, 2) == (True, 0)
    assert b.take(10000) == (False, 1000)
    try:
        b.take(10000, 3)
        raise AssertionError('oversize accepted')
    except ValueError:
        pass
    from concurrent.futures import ThreadPoolExecutor
    c = Bucket(10, 1)
    with ThreadPoolExecutor(max_workers=20) as pool:
        results = list(pool.map(lambda _: c.take(0)[0], range(100)))
    assert sum(results) == 10
    print('11 checks passed')

本文在 Python 3.12.14 实际执行以上模型,输出 11 checks passed。最后一个检查用一百次并发调用争抢十个额度,验证的是进程内锁保护,不是多节点或网络故障下的正确性。没有运行 Redis 服务,没有进行吞吐压测,也没有验证主从切换。把模型测试通过写成“分布式限流已验证”会越过证据边界。

放进 Redis 时,原子性只解决其中一层

集中方案可以把每个租户的 credit、last_ms 和策略版本保存在一个键中,在一次 Lua 脚本内完成上述状态转移。不能用独立的 GET 和 SET 拼出同样流程。Redis 文档明确说明脚本执行具有原子性,同时执行期间会阻塞其他服务端活动,因此脚本应保持短小且有界,不在里面扫描租户、等待或执行大循环。Redis Lua 执行语义

接口可以定义为 admit(tenant_id, policy_version, cost),返回 allowed、retry_after_ms 和当前策略版本。租户 ID 必须来自认证结果,而非任意请求头;键名可用固定前缀加内部租户编号,不应把无限长度的用户输入直接变成存储键。Lua 的数值表示与 Python 整数不同,移植时还要限制容量、速率、时间差及乘积,不能假设大整数运算行为完全一致。

Redis 的 TIME 返回服务器时间,可减少不同应用机器各自带入时间产生的偏差,但它不是对单调时间或跨节点一致时钟的承诺。TIME 命令 使用前仍要按照部署版本核实脚本调用方式,并专门测时钟回拨、向前跳和切换后的状态。

状态过期也不是随手设个五分钟。一个空桶若要十分钟才能补满,却在五分钟后被删除,下一次请求初始化为满桶,就凭空多出额度。只有达到“即使保留状态也必定已满”的时刻,删除才等价于正常补充;策略改变、时钟回拨又会影响这个判断。最保守的早期实现可以先不自动过期,控制租户集合和内存,再加入经过验证的清理规则。不能为了节省一点内存,在不可观察的角落重置消费权。

策略更新同样需要状态迁移。升级套餐时是否立即给满新桶,是业务选择;降低容量时,已有余额至少要截断到新容量。直接把版本号放进键名并创建一个满桶,可能让每次配置发布都赠送一次突发。更可控的方式是在原子操作里识别策略变化,按明确规则转换旧余额,记录生效版本,旧实例传入过期版本时拒绝或重新取配置,而不是各自解释额度。

超时不能等同于“没有扣过”

应用调用限流器超时,可能是命令没送到,也可能是扣除已经完成但响应丢了。保护性限流最简单的处理是拒绝本次请求,不自动退款。这样可能少放一次,却不会因为猜测而多发额度。若选择重试,同一次请求可能被扣两次;如果业务无法接受,就必须增加请求 ID 去重,保存裁决结果,并为去重记录定义期限和容量。

这里不要把准入幂等与业务幂等混为一谈。相同请求 ID 第二次拿到“允许”,不意味着可以再执行一次业务副作用。业务层仍需独立防重。反过来,业务执行失败也不一定应该退回限流额度,因为失败请求已经消耗了鉴权、查询或下游连接。若只按成功结果计数,攻击者可以利用昂贵失败不断消耗资源而不花额度。

主从切换则是另一类不确定性。Redis 默认异步复制,确认过的状态变更在特定故障下仍可能丢失;同步等待复制也不能被简单等同于强一致系统。Redis 复制说明 对限流而言,余额回退可能再次放出已消费令牌。若一次额外突发的后果是短暂负载抬高,可以用下游并发上限兜底;若后果是超额支付或重复发放不可撤回权益,这套保护性桶就选错了工具,应把权利消耗放进可审计的强约束事务。

故障模式需要预算,不能只有开关

限流器不可用时全部放行,保护目标恰好在依赖故障时消失;全部拒绝又把一个辅助组件变成业务单点。所谓“失败时开放”或“失败时关闭”只是标签,真正需要约定的是哪些请求、持续多久、最多放多少。

例如可以给低成本读取设置应急本地额度,高成本导出在中心不可达时直接拒绝。应急额度必须按最大存活实例数估计总量,而不是按平时副本数计算;否则自动扩容会不断放大降级流量。实例重启若重新获得满额,也会使预算无限再生,因此需要限制降级持续时间,并明确该方案只是负载保护,不是精确租户配额。

容量规划也要包含拒绝路径。假设正常峰值为每秒五万次请求,九成请求被拒绝,如果每个请求仍然访问中心,中心看到的仍是五万次,而不是五千次。可以在入口用本地粗限流削掉明显超量流量,但它不能替代租户集中裁决。黑名单缓存和短暂拒绝缓存还会影响恢复速度,需要把允许重新尝试的时刻和配置失效方式定义清楚。

监控应至少区分四种结果:额度不足、中心超时、策略版本不匹配、应急路径放行。把它们全记成一个 429,会让运营误判为客户调用过量。RFC 6585 定义了 429,并允许携带 Retry-After,但没有替服务端规定用户身份和计数算法。HTTP 429 规范 返回的等待时间只是当前状态下的估计,竞争者也在消费,不能承诺等到那一刻一定成功。客户端还需要退避和抖动,避免整群请求按同一秒重新冲进来。

验收应从“多放了多少”开始

上线前先验证正常状态下的总额度边界,再故意制造不确定性:在扣除后丢弃响应、终止应用进程、切换中心节点、调整套餐、让一个实例停留在旧策略。记录每一种情况下允许数、拒绝数、重复扣除数、误放量以及恢复时间。只测试平均每秒请求数,很容易掩盖短突发和配置切换造成的额外额度。

批量配额方案还要单独验证崩溃后剩余额度如何处理,以及旧实例重新联网时是否仍有消费权。若不能证明回收安全,宁愿让未用额度过期浪费,也不要为了提高利用率重复分配。这里的浪费是可计算的成本;重复消费权则会破坏承诺。

对本文场景,集中桶是合理起点,因为它把同一租户的消费顺序放在一个地方,便于观测和测试;本地桶负责保护实例,不能伪装成全局保证;批量配额只有在中心成本真实存在且允许近似时才值得引入。限流设计成熟的标志,不是用了多少算法,而是能够清楚回答:一次裁决结果丢失、一次实例扩容、一次中心故障之后,我们最多会少放或多放多少请求,谁来承担这段误差。

相关文章

评论

登录后即可参与讨论

暂无评论。