FDE Times 数据在招 FDE 职位 924▲33 近 7 天在招职位数的变化(同口径比较):不计入本周新开始追踪的公司的职位近 7 天新增 80在招公司 196支持远程 25%美国薪资中位数 $200k招聘最多 Databricks 107
ENVI

前线部署工程师(FDE)的专业媒体

技能指南 · 指南

客户十分钟发来 5 万个订单,系统怎么扛

队列不会让处理变快,但有了竞争消费者和背压,处理节奏由你自己决定。

分享微博

要点速览

  • 在客户系统和 worker 之间放一个队列吸收突发流量,再让多个 worker 竞争处理消息。
  • 背压在消费端:限制未确认消息数,超时时间按真实处理时长设置,按队列深度扩缩容。
  • 顺序没有保证,消息也可能到达两次,所以消费者必须幂等,并配好 DLQ 兜底。
点图展示每个订单的处理时间,刻度从 0 到 50 秒。平均订单耗时 2 秒,最慢的订单耗时 45 秒,落在超过 SQS 默认 30 秒超时的阴影区域内;在该区域,订单会重新出现在队列中并被处理两次。
在 5 万订单的示例中,最慢的订单耗时 45 秒,超过 SQS 默认 30 秒的可见性超时,因此会重新出现在队列中,被另一个 worker 取走。来源:Amazon SQS 文档(默认超时);文中假设示例(2 秒和 45 秒)。

设想这样一个场景:客户的 ERP 系统跑日终同步任务,十分钟内向你的 webhook 推送了 50,000 个订单。每个订单都要调用一次模型、写一次数据库,再把结果推送到 CRM。你的 API 开始超时,客户那边自动重试,第二天早上你只能去清理被写了两遍的订单。

凡是对接客户系统的人,都应该提前为这种情况做准备。客户的系统不归你管,你也没法让对方“发慢一点”。你能控制的是自己的系统如何接收工作,而这项能力建立在三个概念之上:pub/sub、竞争消费者和背压。

队列不会让你更快,而是让你自己选择速度

上面例子的问题在于,webhook 既负责接收,又负责处理。解决办法是把两者拆开:webhook 只把消息写入队列,立即返回 200;一组 worker 从队列中取消息,按自己的节奏处理。

Microsoft 的架构文档描述的正是这个角色:队列是发送方与处理实例之间的缓冲区,在流量涨落时把它削平。

多个 worker 从同一个队列读取消息,就是竞争消费者模式:worker 之间相互竞争,每条消息只交给其中一个。pub/sub 正好相反:每个订阅者都会收到每条消息。两者的核心区别在于每条消息由谁接收,这决定了你如何设计拓扑。

实际项目中通常两者都要用。一个“新订单”事件只发布一次,“风险评分”订阅者和“CRM 同步”订阅者各自拿到一份副本,每个订阅者内部再挂一组竞争 worker。还有一个附带好处:某个订阅者出故障,不会拖垮发布方或其他订阅者,broker 会替它保存消息,直到它恢复。

背压放在哪里?

队列能吸收突发流量,但如果 worker 一次贪心地拉取太多消息,压力只是从 webhook 转移到了 worker 的内存。

Microsoft 的 pub/sub 指南给出了明确的优先顺序:先用 broker 的流量控制限制每个订阅者的未确认消息数,流量控制不够时,再用竞争消费者横向扩展。

每种 broker 把这个控制放在不同的位置,名字也不一样:

Broker 在哪里调背压 需要记住的点
RabbitMQ prefetch(basic.qos) 值为 0 表示不限制未确认消息数
Celery worker_prefetch_multiplier 长任务应设为 1,避免 worker 囤积任务
Amazon SQS 可见性超时(visibility timeout) 默认 30 秒;标准队列的在途消息上限约为 120,000 条
Kafka 拉取模型 + 消费者组 提前规划分区数:一个分区在组内只属于一个消费者,所以分区数就是并行度的上限

Kafka 值得单独说一句。由于消费者自己拉取数据,Kafka 的设计文档指出,慢消费者只是落后一些,有余力时再追上来,背压几乎是白送的。代价是:如果一个 topic 有 6 个分区,同一组里的第 7 个消费者只能闲着,所以设计 topic 时就要算好需要的并行度。

完整示例:从头算一遍

回到这 50,000 个订单。假设每个订单平均耗时 2 秒,模型响应慢时最长 45 秒。总工作量是 100,000 worker·秒;用 20 个 worker,队列大约 5,000 秒处理完,也就是 83 分钟多一点。先问客户第一个问题:结果是否必须在 83 分钟内完成?如果是,你马上就知道需要多少个 worker。

接下来是陷阱。如果用 SQS 且保留默认的 30 秒可见性超时,任何耗时 45 秒的订单都会在 worker 删除它之前重新出现在队列里,被另一个 worker 取走。

这个机制本意是从崩溃的 worker 手里抢救任务,在这里却制造了重复。超时时间要设得比你实际测得的最慢处理时间更长。

即便超时设对了,AWS 也明确说明 SQS 是至少一次投递,无法绝对保证消息不会到达两次。Microsoft 也指出,消费者收到消息的顺序并不反映消息的创建顺序。因此消费者必须幂等:

def handle(msg):
    key = f"{msg['order_id']}:{msg['version']}"
    with db.transaction():
        if db.exists("processed_keys", key):
            return  # 重复消息,跳过
        if db.current_version(msg["order_id"]) > msg["version"]:
            return  # 旧版本迟到,跳过
        upsert_order(msg)
        db.insert("processed_keys", key)

(两处注释分别表示“重复消息,跳过”和“旧副本迟到,跳过”。)

这两个条件解决的是两个不同的问题。幂等键挡住重复消息;version 比较挡住比新消息晚到的旧消息。如果客户系统不发送版本号,就在需求调研阶段问清楚哪个字段单调递增,比如 updated_at。

最后一步是毒消息:数据损坏的订单会永远处理失败。不要让它无限循环;投递达到一定次数后,把它移入死信队列(DLQ),留待人工排查。worker 池可以按队列深度自动扩缩容,队列为空时缩到零,同时设置并发上限,以免压垮后面的数据库。

按什么顺序做?

第一步是测量:客户的峰值流量、平均和最坏情况下的处理时间,以及业务截止时间。然后用队列把接收和处理分开,判断哪里需要 pub/sub(多个系统关心同一事件),哪里只用竞争消费者就够了。

接着调好控制参数:较小的 prefetch、高于 p99 的可见性超时,以及按目标并行度提前算好的分区数。最后编写幂等消费者,配置 DLQ,并为队列深度和在途消息数设置告警。

最常见的错误

最常见的错误是把 prefetch 留在 0,以为“拉得越多越快”,结果一个 worker 囤了几千条消息,其他 worker 却闲着。其次是长耗时的模型调用仍沿用默认的可见性超时。再就是 Kafka 消费者数超过分区数,然后奇怪吞吐量为什么没涨。

剩下两个更危险,因为它们不声不响:假设消息按顺序到达,以及没有 DLQ,导致一条坏记录堵住整个队列。

5 万订单示例里的这条决策链,正是前线部署工程师(FDE)面试时该拿出来讲的内容:峰值流量、worker 数的计算、超时为什么必须大于最慢处理时间、幂等键,以及 DLQ 放在哪里。用你自己的真实数字完整走一遍,比简历上一句“熟悉事件驱动系统”有说服力得多。

下次客户问“你们的系统每秒能处理多少请求?”,最好的回答不是一个数字,而是:对方发多少,系统都能接得住,并且严格按自己能承受的节奏处理。

这篇文章对你有帮助吗?

6 个信源
路线图上的下一篇 · 阶段 5: 部署上线客户负载均衡器之后,所有请求都是同一个 IP真实 IP 丢失、会话乱跳、健康检查失真,根源都在 L4、L7 和反向代理各自看到了什么。