架构与系统设计 / 系统课时

用 Kafka 把下单移出请求链路

用 Kafka 把下单移出请求链路

秒杀请求已经通过资格与库存校验后,不必继续等待订单数据库写入完成。把“创建订单”变成 Kafka 事件,接口只等消息被 broker 确认就返回受理结果,再由消费者按自身吞吐落库,可以把数据库峰值从请求瞬时洪峰中隔离出来。

学习目标

  • 划清异步下单请求链路的结束位置,并理解为什么接口应返回受理而不是已下单。
  • 比较同步下单与 Kafka 异步下单在延迟、削峰和失败处理上的差异。
  • 跑通生产事件、消费落库和消费位点提交的最小链路。

缩短请求链路的真正边界

同步下单通常是“资格校验→扣库存→写订单库→返回成功”,请求线程会直接承受订单库延迟。异步化后,链路变成“资格校验→扣库存或占用资格→发送下单事件→返回 202 Accepted”,订单落库移到消费者中执行。

接口返回受理只表示事件已经可靠进入异步链路,不表示订单记录已经存在。客户端应使用 requestId 或 orderId 查询最终状态,而不是把 202 当成下单完成。若发送 Kafka 失败,接口也不能提前返回受理成功。

Kafka 异步下单的数据流与响应边界

看清同步与异步的差异

维度 同步写订单 Kafka 异步下单
请求返回点 订单库提交后 broker 确认事件后
峰值压力 请求洪峰直接打到订单库 Kafka 缓冲,消费者按能力落库
用户看到的状态 成功或失败较直接 先“已受理”,再查询最终结果
失败处理 当前请求内返回错误 重试、重放、幂等和状态查询必须完善

异步化并没有消灭失败,只是把失败从请求线程移到了消息处理链路。因此系统必须明确“消息是否已投递”“订单是否已创建”是两个不同状态,并让消费者能够安全重放。

跑通最小生产与消费链路

下面的 Python 程序同时包含生产者和消费者。运行前需要可访问的 Kafka broker,并安装 confluent-kafka;把 <HOST>:<PORT> 替换成实际地址。生产者等待 broker 确认后打印受理结果,消费者把订单写入本地 SQLite,再同步提交 Kafka 位点。

python
from confluent_kafka import Consumer, Producer
import json
import sqlite3
import sys
import time

BROKER = "<HOST>:<PORT>"
TOPIC = "order-create"

EVENT = {
    "eventId": "evt-10001",
    "orderId": "ord-10001",
    "userId": 42,
    "skuId": 1001,
    "qty": 1
}

def produce_order():
    result = {"error": None, "message": None}

    def on_delivery(error, message):
        result["error"] = error
        result["message"] = message

    producer = Producer({
        "bootstrap.servers": BROKER,
        "acks": "all"
    })
    producer.produce(
        TOPIC,
        key=str(EVENT["userId"]),
        value=json.dumps(EVENT),
        on_delivery=on_delivery
    )

    remaining = producer.flush(10)
    if remaining != 0 or result["error"] is not None:
        raise RuntimeError(f"broker ack failed: {result['error']}")

    message = result["message"]
    print(
        f"accepted topic={message.topic()} "
        f"partition={message.partition()} offset={message.offset()}"
    )

def consume_one():
    consumer = Consumer({
        "bootstrap.servers": BROKER,
        "group.id": "order-writer-demo",
        "auto.offset.reset": "earliest",
        "enable.auto.commit": False
    })
    consumer.subscribe([TOPIC])

    deadline = time.time() + 30
    while time.time() < deadline:
        message = consumer.poll(1.0)
        if message is None:
            continue
        if message.error():
            raise RuntimeError(message.error())

        event = json.loads(message.value().decode("utf-8"))
        with sqlite3.connect("orders.db") as db:
            db.execute(
                "CREATE TABLE IF NOT EXISTS orders ("
                "event_id TEXT PRIMARY KEY, "
                "order_id TEXT NOT NULL UNIQUE, "
                "user_id INTEGER NOT NULL, "
                "sku_id INTEGER NOT NULL, "
                "qty INTEGER NOT NULL)"
            )
            cursor = db.execute(
                "INSERT OR IGNORE INTO orders "
                "(event_id, order_id, user_id, sku_id, qty) "
                "VALUES (?, ?, ?, ?, ?)",
                (
                    event["eventId"],
                    event["orderId"],
                    event["userId"],
                    event["skuId"],
                    event["qty"]
                )
            )
            db.commit()

        consumer.commit(message=message, asynchronous=False)
        state = "created" if cursor.rowcount == 1 else "duplicate"
        print(f"{state} event={event['eventId']} order={event['orderId']}")
        consumer.close()
        return

    consumer.close()
    raise TimeoutError("no order event received within 30 seconds")

if __name__ == "__main__":
    if len(sys.argv) != 2 or sys.argv[1] not in {"producer", "consumer"}:
        raise SystemExit("usage: python async_order.py producer|consumer")

    if sys.argv[1] == "producer":
        produce_order()
    else:
        consume_one()

预期输出

text
# producer
accepted topic=order-create partition=<ID> offset=<ID>

# consumer
created event=evt-10001 order=ord-10001

先启动 consumer,再执行 producer。实际分区和 offset 会不同,因此示例用 <ID> 表示动态值。重复投递同一个 eventId 时,SQLite 主键会让订单写入保持幂等,消费者打印 duplicate 后仍可提交这条已确认无副作用的消息。

消费成功后再提交位点

消费者的关键顺序是“数据库事务提交→Kafka offset 提交”。如果先提交 offset 再写库,进程在两步之间崩溃时,这条事件可能被认为已经消费,却没有订单记录;反过来先写库再提交 offset,最坏情况是消息重放,因此只要订单写入具备幂等性就能安全恢复。

当订单库只能稳定处理每秒一部分写入时,Kafka 可以吸收短时洪峰,消费者按数据库可承受的速率持续落库。这样请求端延迟主要受资格判断和消息投递影响,而订单库的慢写不会直接拖住成千上万条抢购请求。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

用 Kafka 把下单移出请求链路

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通