罗罗编程学习记录
本页内容 展开查看

04.7.21.3 消息队列、搜索与存储组件

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python / 04.7.21 Python 后端常见搭配技术

覆盖范围

  • RabbitMQ:exchange 类型、routing key、queue 属性、ack、prefetch、死信与重试队列、仲裁队列、生产者确认
  • Kafka:分区与副本、offset、消费者组与 rebalance、幂等生产者、事务消息、客户端差异、顺序性与重复消费
  • RabbitMQ / Kafka / Redis Stream 选型、积压排查、消息丢失链路、顺序与并发
  • Elasticsearch:倒排索引、mapping、分析器、bool 查询、深分页、写入优化、分片副本与近实时
  • 对象存储:bucket/object、boto3、预签名 URL、分片上传、回调签名校验
  • MongoDB:文档模型、索引、查询计划、事务限制、分片
  • 最终一致、outbox 模式、幂等消费、补偿与消息 schema 演进

04.7.21.3-001 RabbitMQ 的 exchange 有哪几种类型?

一句话结论

RabbitMQ 交换器四种类型:direct(按 routing key 精确匹配绑定键)、topic(按通配符模式匹配,* 匹配一个词、# 匹配多个词)、fanout(广播到所有绑定队列,忽略 routing key)、headers(按消息头属性匹配,少用)。生产者把消息发到 exchange,由 exchange 按类型和绑定规则路由到队列。

概念解释

  • direct:点对点按键匹配,如订单状态路由。
  • topic:主题订阅,按层级词匹配,适合事件分类。
  • fanout:广播,所有消费者队列都收到副本。
  • headers:用键值对匹配,性能低于键匹配,场景有限。

原理流程

  1. 生产者发布消息到指定 exchange,携带 routing key。
  2. exchange 按类型计算匹配的 binding。
  3. 命中的队列收到消息副本,等待消费者 ack。
  4. 无队列绑定时消息按配置丢弃或返回生产者。

代码或图示

# direct:routing_key="order.created" 精确匹配绑定
channel.basic_publish(
    exchange="orders",
    routing_key="order.created",
    body=msg,
)
# topic:"order.*" 匹配 order.created/order.paid
# fanout:忽略 routing_key,全部绑定队列

常见误区

  • 把 exchange 当队列:exchange 只路由不存储消息,队列才保存消息。
  • topic 通配符写错:* 单段、# 多段,混用导致匹配不到。
  • fanout 也期待按 key 过滤:广播模式忽略 routing key,过滤要在消费者或多 exchange 上做。

追问

  • headers 交换器为什么少用?答:匹配计算成本高,键模式表达力不如 topic,仅特殊头匹配场景使用。
  • 一个队列能绑多个 exchange 吗?答:能,队列可与多个绑定关系关联。
  • 消息路由不到队列会怎样?答:默认丢弃;配置 mandatory/return 回调可通知生产者。

04.7.21.3-002 routing key 和 binding 怎么匹配?

一句话结论

binding 把队列与 exchange 绑定并指定绑定键;消息 routing key 与绑定键按交换类型匹配:direct 全等比较,topic 按点分层级与通配符匹配,fanout 直接命中。匹配规则在 RabbitMQ 服务端完成,生产者只需发布消息。

概念解释

  • routing key:点分单词串,如 order.created.vip。
  • 绑定键:direct 下与 routing key 全等;topic 下可含 */#。
  • 同一队列可绑定多个规则,覆盖不同 routing key。

原理流程

  1. 声明队列与绑定关系(队列 + exchange + 绑定键)。
  2. 消息携带 routing key 进入 exchange。
  3. exchange 逐条比对绑定规则。
  4. 所有命中队列获得消息副本。

代码或图示

# topic 绑定:order.# 匹配 order.created、order.paid.vip
channel.queue_bind(
    queue="audit",
    exchange="events",
    routing_key="order.#",
)

常见误区

  • 绑定键含空格/大写不一致:匹配按字符串精确比较,大小写敏感。
  • 用 direct 表达订阅模式:direct 不支持通配,需换 topic。
  • 一个消息匹配多个队列时以为只发一份:每个命中队列各得副本。

追问

  • * 和 # 各匹配什么?答:* 匹配恰好一个单词;# 匹配零或多个单词。
  • routing key 长度有限制吗?答:有长度与字符约束,超长/非法字符需查 RabbitMQ 规范(待确认:当前版本上限)。
  • 匹配失败消息去哪了?答:无绑定队列时按 mandatory 配置丢弃或 return 给生产者。

04.7.21.3-003 队列 durable/exclusive/auto-delete 区别?

一句话结论

durable=True 队列元数据持久化,broker 重启后队列仍存在;exclusive=True 队列只绑定当前连接,连接断开即删除;auto-delete=True 队列在最后一个消费者断开后自动删除。持久化队列还要配合消息持久化才不会丢消息,三者控制不同生命周期维度。

概念解释

  • durable:队列定义存活过重启;消息是否存活看 delivery_mode。
  • exclusive:连接级私有,适合临时回调队列。
  • auto-delete:空闲后自动清理,避免遗留无用队列。

原理流程

  1. 声明队列时设置三个标志位。
  2. durable 队列元数据写入持久层;exclusive 绑定连接生命周期。
  3. 消费者断开,auto-delete 计数归零后删除队列。
  4. broker 重启,durable 队列重建,非 durable 队列丢失。

代码或图示

channel.queue_declare(
    queue="orders",
    durable=True,          # 重启保留队列
    exclusive=False,
    auto_delete=False,
)

常见误区

  • durable 队列就以为消息不丢:队列持久化不等于消息持久化,消息需 delivery_mode=2。
  • exclusive 队列被多个消费者使用:连接断开即删,不适合共享队列。
  • auto-delete 用于常驻业务队列:消费者短暂断开后队列被删,消息与绑定丢失。

追问

  • 队列参数变更要注意什么?答:已有队列参数不可直接改,需删除重建或换队列名,避免参数冲突报错。
  • 临时回调队列怎么声明?答:exclusive=True 且不指定名字,broker 生成临时队列名。
  • durable 队列里的非持久化消息会怎样?答:broker 重启后消息丢失,队列本身保留。

04.7.21.3-004 消息 ack 机制怎么工作?手动和自动确认怎么选?

一句话结论

消费者处理完消息后向 broker 发送 ack,broker 才删除消息;未 ack 的消息在消费者断开/超时后重新入队。自动确认(auto_ack=True)消息一投递就视为确认,简单但可能丢消息;手动确认在业务处理成功后 basic_ack,失败 basic_nack/basic_reject 重投或进死信。可靠业务用手动确认。

概念解释

  • ack:正向确认,消息移除。
  • nack:否定确认,可重新入队或丢弃。
  • reject:单条拒绝,行为类似 nack 但不支持批量。
  • 未 ack 消息保持 unacked 状态,计入消费者投递数量。

原理流程

  1. broker 投递消息给消费者,状态为 unacked。
  2. 消费者执行业务:成功 basic_ack(delivery_tag)。
  3. 失败 basic_nack(requeue=True) 重回队列,或 requeue=False 进死信。
  4. 连接断开,所有 unacked 消息重新入队。

代码或图示

def callback(ch, method, properties, body):
    try:
        handle(body)
        ch.basic_ack(delivery_tag=method.delivery_tag)
    except Exception:
        ch.basic_nack(delivery_tag=method.delivery_tag, requeue=False)

常见误区

  • 业务未完成就 ack:进程崩溃后消息已移除,无法重投。
  • 重复 ack 同一标签:broker 报错,需跟踪 ack 状态。
  • nack 无限 requeue:失败消息反复重投形成循环,应进死信或重试队列。

追问

  • 一条消息能被多个消费者同时处理吗?答:同一时刻只投递给一个消费者;ack 后才可能再分发。
  • 手动 ack 在哪个通道发?答:必须用接收消息的同一 channel 确认。
  • 自动确认适用什么场景?答:可丢失的监控/采样数据,可靠性要求低的通知。

04.7.21.3-005 prefetch 数量怎么影响消费公平性?

一句话结论

basic_qos(prefetch_count=N) 限制消费者未 ack 的最大消息数;N=1 最公平,消息处理完才取下一条,避免快消费者囤积慢任务;N 大吞吐高但可能造成任务在消费者本地排队。混合任务时长场景调低 prefetch,同构短任务可适当提高。

概念解释

  • prefetch 是未确认消息上限,不是一次性拉取总量。
  • 公平分发:RabbitMQ 默认按轮询投递,不看消费者忙碌程度;prefetch 控制在途数量。
  • 与 Celery prefetch_multiplier 思路一致。

原理流程

  1. 消费者声明 channel 时设置 prefetch_count。
  2. broker 投递消息直到未 ack 数达到上限。
  3. 消费者 ack 一条,broker 再补投一条。
  4. 长任务占住在途额度,其他任务排队等待。

代码或图示

channel.basic_qos(prefetch_count=1)
channel.basic_consume(queue="orders", on_message_callback=callback)

常见误区

  • prefetch 设很大:快消费者囤走大量消息,慢任务堵在本地队列。
  • 忽略多 channel:每个 channel 独立 prefetch 额度。
  • 混合任务不调 prefetch:慢任务拖累整体消费延迟。

追问

  • prefetch=1 吞吐会低吗?答:每条消息等 ack 再取下一条,往返增加;短任务可放宽。
  • 怎么判断 prefetch 过大?答:队列有积压但部分消费者空闲,本地未 ack 队列变长。
  • 全局 prefetch 还是 per-consumer?答:RabbitMQ QoS 作用于 channel/消费者,按连接与消费者配置。

04.7.21.3-006 死信队列(DLX)是什么?怎么路由失败消息?

一句话结论

死信交换器(Dead Letter Exchange)接收被拒绝、过期或被队列长度/TTL 淘汰的消息;队列绑定 DLX 并指定死信 routing key,nack(requeue=False)、消息过期、队列溢出时消息转入 DLX 再路由到死信队列。死信队列用于隔离失败消息,供重试/排查/人工处理。

概念解释

  • 死信来源:reject/nack 不重投、消息 TTL 过期、队列最大长度溢出。
  • DLX 是普通 exchange,死信队列是普通队列,只是用途隔离。
  • 死信消息可携带原始信息头(交换器、路由键、原因)。

原理流程

  1. 队列声明时配置 x-dead-letter-exchange 与死信 routing key。
  2. 消息被拒绝/过期/溢出,broker 将其发往 DLX。
  3. DLX 按绑定路由到死信队列。
  4. 消费者从死信队列重试、补偿或人工介入。

代码或图示

channel.queue_declare(
    queue="orders",
    arguments={
        "x-dead-letter-exchange": "dlx",
        "x-dead-letter-routing-key": "order.dead",
    },
)

常见误区

  • 死信队列不消费:失败消息堆积无人处理,问题被掩盖。
  • 死信消息直接无限重投:应经重试队列延迟重试,超限再进死信。
  • 所有失败都进同一死信:无法按业务/原因分类,排查困难。

追问

  • 消息过期为什么会死信?答:队列/消息设置 TTL,过期后若配了 DLX 则转死信,否则丢弃。
  • 死信消息还能回到原队列吗?答:可以,由重试消费者转发到原队列或重试队列。
  • DLX 需要单独部署吗?答:不需要,逻辑交换器与队列在同一 broker 内配置。

04.7.21.3-007 重试队列和延迟消息怎么实现?

一句话结论

RabbitMQ 可靠重试通常用「重试队列 + TTL + 死信交换」:消息进入带 TTL 的重试队列,过期后经 DLX 回到业务队列;延迟任务同理。也可用延迟消息插件(rabbitmq_delayed_message_exchange)实现固定延迟。重试要记录次数,超限进死信,避免循环。

概念解释

  • TTL 重试:消息在重试队列等待一段时间,过期转 DLX 回业务队列。
  • 多层重试队列:1 分钟、5 分钟、30 分钟阶梯退避。
  • 延迟插件:exchange 按消息头延迟投递,能力受插件版本支持。

原理流程

  1. 业务处理失败,消息投递到 TTL 重试队列。
  2. 到期后消息死信路由回业务队列重新消费。
  3. 重试次数写入消息头,递增判断。
  4. 超过最大次数转死信队列,不再回到业务队列。

代码或图示

orders --nack--> retry.1m (TTL 60s) --dead-letter--> orders
                              超限 --> dead

常见误区

  • 重试队列不记次数:失败消息永远循环重试。
  • TTL 队列头部阻塞:RabbitMQ 队列 TTL 按队头检查,前一条不过期后面不解除(待确认:当前版本行为)。
  • 依赖插件做长延迟:插件未安装/集群版本不一致导致延迟失效。

追问

  • 阶梯退避怎么配?答:多个不同 TTL 的重试队列,按重试次数路由到对应层级。
  • 延迟消息插件生产注意什么?答:集群所有节点安装同版本,重启后延迟消息持久化情况需验证。
  • 重试间隔为什么要加随机抖动?答:避免大量失败消息同一时刻重投,形成重试冲击。

04.7.21.3-008 镜像队列和仲裁队列有什么区别?

一句话结论

镜像队列是 RabbitMQ 早期高可用方案:主节点队列同步副本到镜像节点,已被官方标记废弃;仲裁队列(Quorum Queue)基于 Raft 复制,数据一致由多数派保证,是当前推荐的生产高可用方案。新集群应使用仲裁队列,存量镜像队列规划迁移。

概念解释

  • 镜像队列:主从复制,脑裂/一致性问题历史较多,维护成本高。
  • 仲裁队列:Raft 多数派提交,节点故障自动选主,数据不依赖单副本。
  • 两者配置与监控指标不同,迁移需双队列过渡。

原理流程

  1. 仲裁队列在多节点建立 Raft 副本集。
  2. 写入经多数派确认后提交。
  3. 主节点故障,多数派选举新主继续服务。
  4. 客户端连接配合集群拓扑自动重连到新主。

代码或图示

channel.queue_declare(
    queue="orders",
    durable=True,
    arguments={"x-queue-type": "quorum"},
)

常见误区

  • 新集群还用镜像队列:沿用废弃方案,后续版本支持风险。
  • 仲裁队列副本数设 1:无冗余,故障即丢消息。
  • 迁移期双写不一致:需对账校验后再切消费。

追问

  • 仲裁队列推荐几个副本?答:奇数节点(3/5),多数派容错,权衡一致性与可用性。
  • 仲裁队列性能代价?答:Raft 复制与多数派确认有额外开销,吞吐低于单机队列。
  • 镜像队列怎么迁到仲裁队列?答:新建 quorum 队列,双写过渡,消费切流,校验后下线旧队列。

04.7.21.3-009 消息持久化怎么保证不丢?

一句话结论

可靠消息链路三环节:生产者确认发布成功 → 队列与消息持久化 → 消费者成功处理后 ack。broker 侧:durable 队列 + 消息 delivery_mode=2;生产者用 publisher confirm 确认落盘;消费者手动 ack。任一环节缺位都有丢失窗口,需按可靠性等级组合配置。

概念解释

  • 队列持久化:定义重启保留;消息持久化:消息体写入磁盘。
  • 生产者 confirm:broker 收到并持久化后回调确认。
  • 消费者 ack:业务完成后才确认,崩溃可重投。

原理流程

  1. 生产者声明 durable 队列,发布持久化消息。
  2. broker confirm 通知消息已安全落盘。
  3. 消费者手动处理,成功后 ack;未 ack 重投。
  4. broker 重启:durable 队列与持久化消息恢复。

代码或图示

channel.confirm_delivery()
channel.basic_publish(
    exchange="orders",
    routing_key="order.created",
    body=msg,
    properties=pika.BasicProperties(delivery_mode=2),
)

常见误区

  • 只持久化队列不持久化消息:重启后消息丢失。
  • 生产者不等 confirm 就认为发送成功:broker 故障窗口消息未落盘。
  • 消费者自动 ack:处理崩溃消息已移除,不可恢复。

追问

  • 持久化消息写磁盘有性能代价吗?答:有 fsync/IO 开销,吞吐低于内存消息,按可靠性取舍。
  • broker 多节点怎么保消息?答:仲裁队列 Raft 复制多数派,或镜像队列同步(旧方案)。
  • 消息重复怎么防?答:消费端幂等去重,持久化只防丢失不防重复。

04.7.21.3-010 生产者 confirm 和 return 回调分别处理什么?

一句话结论

publisher confirm(confirm_delivery)通知生产者消息已被 broker 接收/持久化,用于确认发布成功;return 回调处理消息无法路由(无绑定队列)的场景,配合 mandatory=True 把不可路由消息退回生产者。两者互补:confirm 管落盘确认,return 管路由失败。

概念解释

  • confirm:异步回调,含 delivery tag 与是否成功标志。
  • return:消息无法到达队列时退回,携带交换器、路由键与错误码。
  • 生产者需记录未确认消息,超时重试或告警。

原理流程

  1. 开启 confirm 模式,注册 confirm 回调。
  2. 发布消息,mandatory=True 注册 return 回调。
  3. 可路由:broker 处理后 confirm 成功。
  4. 不可路由:return 退回消息;confirm 仍按 broker 处理结果回调。

代码或图示

channel.confirm_delivery()

def on_return(channel, method, properties, body):
    log.warning("unroutable: %s", method.routing_key)

channel.add_on_return_callback(on_return)

常见误区

  • 只发消息不监听 confirm:不知道 broker 是否真的收到。
  • mandatory 不开:不可路由消息直接丢弃,return 不会触发。
  • confirm 成功就忽略业务校验:确认只代表 broker 收到,不代表消费者处理成功。

追问

  • confirm 是逐条还是批量?答:支持单条与批量确认,回调按 delivery tag 标识。
  • 长时间无 confirm 怎么处理?答:记录消息与超时,重发或告警,避免消息悬置。
  • return 退回后消息还在 broker 吗?答:不可路由时未入队,退回生产者侧处理。

04.7.21.3-011 Kafka 分区和副本机制是怎样的?

一句话结论

Kafka 主题分为多个分区(partition),分区是顺序追加日志的并行单元;每个分区有一个 leader 副本负责读写,其他 follower 副本同步数据。分区数决定并行度与顺序边界,副本数保证故障容错;leader 选举由控制器(controller)完成。

概念解释

  • 分区:消息按 key 哈希或轮询写入,分区内消息有序。
  • 副本:leader 处理读写,follower 拉取同步;replica.lag 落后过多会被剔除 ISR。
  • ISR(in-sync replicas):与 leader 保持同步的副本集合。

原理流程

  1. 主题创建时指定分区数与副本因子。
  2. 生产者按 key 选分区,写入 leader 日志。
  3. follower 拉取 leader 消息同步到本地。
  4. leader 故障,控制器从 ISR 中选举新 leader。

代码或图示

topic orders
├── partition 0: leader A, followers B,C (ISR)
├── partition 1: leader B, followers A,C
└── partition 2: leader C, followers A,B

常见误区

  • 分区越多越好:分区占用文件/内存开销, broker 分区数有上限建议。
  • 副本因子为 1:leader 故障即丢数据,生产至少 2–3 副本。
  • 以为跨分区全局有序:只有单分区内有序,不同分区并行。

追问

  • 消息按什么选分区?答:指定 key 按哈希;无 key 轮询(粘性分区优化批量)。
  • follower 能读消息吗?答:默认消费者只读 leader,follower 负责同步(待确认:follower 读特性版本支持)。
  • 分区数能改吗?答:可以增加,已存在 key 的分区归属会变化,减少分区不支持。

04.7.21.3-012 offset 提交语义有哪些?

一句话结论

offset 是消费者在分区中的消费位置;提交方式分自动提交(周期提交)与手动提交(处理后 commit)。提交位点只记录「已处理到哪」,不防重复:提交前崩溃会重投,提交后崩溃跳过未处理消息。可靠业务手动提交,先处理完业务再提交。

概念解释

  • 自动提交:enable.auto.commit=True 按间隔提交,简单但可能重复/跳过。
  • 手动提交:同步/异步 commit(),业务成功后提交。
  • 位点重置策略:auto.offset.reset 处理无位点/位点越界。

原理流程

  1. 消费者拉取消息批次,记录当前偏移。
  2. 业务处理完成。
  3. 手动提交 offset 到 broker(__consumer_offsets)。
  4. 崩溃重启:从已提交位点继续;未提交部分重新消费。

代码或图示

consumer = KafkaConsumer(
    "orders",
    bootstrap_servers=...,
    enable_auto_commit=False,
    group_id="order-processor",
)
for msg in consumer:
    handle(msg)
    consumer.commit()

常见误区

  • 先提交 offset 再处理业务:崩溃后消息被跳过,数据丢失。
  • 批量处理中途失败提交整批:已提交部分跳过,未处理消息丢失。
  • 自动提交间隔过长:重复消费窗口大;过短:提交开销高。

追问

  • offset 存哪里?答:broker 内部 __consumer_offsets 主题,按消费组存储。
  • 位点越界怎么处理?答:auto.offset.reset 选 earliest/latest/none,按业务语义配置。
  • 手动提交异步失败怎么办?答:捕获提交异常,必要时同步重试,避免位点丢失导致重复。

04.7.21.3-013 消费者组和 rebalance 是怎么回事?

一句话结论

同一消费组内分区被组内成员分摊消费,一个分区同一时刻只被一个成员消费;组成员变化(加入/离开/心跳超时)或订阅分区变化时触发 rebalance:重新分配分区归属,期间消费暂停。消费者组是 Kafka 水平扩展与容错的核心模型。

概念解释

  • 组内并行:分区数 ≥ 消费者实例数才有并行收益。
  • rebalance 触发:成员加入/离开、心跳超时、订阅变更、分区数变更。
  • rebalance 期间分区无主,消息暂停消费。

原理流程

  1. 消费者加入组,加入协议协调分配。
  2. 协调者按策略(range/roundrobin/sticky)分配分区。
  3. 成员异常退出或心跳缺失,标记离组。
  4. 触发 rebalance,重新分配分区,恢复消费。

代码或图示

group order-processor
├── consumer-1: partition 0, 1
└── consumer-2: partition 2, 3
成员变化 -> rebalance -> 重新分配

常见误区

  • 消费者数超过分区数:多余实例空闲,不增加并行度。
  • 长阻塞任务不发心跳:被判定离组触发 rebalance,任务被重复分配。
  • 频繁 rebalance:消费暂停累积,需排查心跳/处理时长/会话超时配置。

追问

  • 分区分配策略有哪些?答:range、roundrobin、sticky(尽量保持原有分配减少变动)。
  • 怎么减少 rebalance 影响?答:调大会话/心跳超时、缩短单批处理、用静态成员组。
  • rebalance 时已拉取未提交消息怎么办?答:未提交位点保留,新主人从位点继续,可能重复消费。

04.7.21.3-014 rebalance 什么时候触发?怎么减少抖动?

一句话结论

触发条件:消费者加入/退出组、心跳会话超时、订阅主题/分区变更、消费者处理过久被踢出。减少抖动:合理配置 session.timeout.ms 与 max.poll.interval.ms、缩短单批处理时长、使用静态成员组(group.instance.id)避免重启反复重平衡、分批消费避免长阻塞。

概念解释

  • 心跳超时:后台心跳线程判定成员存活。
  • 轮询间隔超时:两次 poll() 间隔过长被踢出,对应长任务。
  • 静态成员:实例固定身份,重启不改变成员身份,减少分区迁移。

原理流程

  1. 监控成员心跳与 poll 间隔。
  2. 超时判定离组,协调者触发 rebalance。
  3. 重新分配分区,暂停消费直到分配完成。
  4. 优化配置与处理时长,降低触发频率与暂停窗口。

代码或图示

consumer = KafkaConsumer(
    group_id="order-processor",
    session_timeout_ms=10000,
    max_poll_interval_ms=300000,
    group_instance_id="consumer-1",  # 静态成员
)

常见误区

  • 任务处理很久不 poll:超过 max.poll.interval 被踢,反复 rebalance。
  • 心跳超时设太小:网络抖动误判离组。
  • 批量拉取过大:单批处理超时,触发踢出。

追问

  • 静态成员组解决什么?答:消费者重启保持成员身份,避免短暂下线引发全量 rebalance。
  • rebalance 暂停期间消息积压吗?答:是,分区无消费,队列延迟上升。
  • 怎么监控 rebalance?答:消费组重平衡次数、暂停时长、成员变化事件。

04.7.21.3-015 Kafka 幂等生产者解决什么问题?

一句话结论

幂等生产者(enable.idempotence=true)让 broker 对同一生产者重复发送的消息去重:基于 PID 与序列号识别重试重复,避免生产者重试导致的重复写入。它解决单分区内生产者重试重复问题,不解决跨生产者/跨会话的业务重复,业务幂等仍需去重键。

概念解释

  • 重试重复:网络超时生产者重发,broker 收到两份相同消息。
  • 幂等机制:PID + 序列号,broker 拒绝序列号重复或乱序的重复写入。
  • 局限:单会话内单分区幂等,事务性写一致性另由事务消息保证。

原理流程

  1. 生产者启动获得 PID。
  2. 每条消息携带单调递增序列号。
  3. broker 检查序列号:重复/回退拒绝,正常追加。
  4. 生产者重试的重复消息被识别去重。

代码或图示

producer = KafkaProducer(
    bootstrap_servers=...,
    enable_idempotence=True,
)

常见误区

  • 开幂等就以为业务不会重复:跨生产者、重启后 PID 变化仍可能重复,消费端需幂等。
  • 幂等保证全局有序?答:单分区内结合序列号保证顺序,跨分区不保证。
  • 误以为幂等替代事务:幂等只去重,不提供多分区原子写。

追问

  • 幂等生产者有什么前提?答:开启后要求 acks=all 等配置约束(待确认:当前版本强制配置组合)。
  • PID 什么时候分配?答:生产者与 broker 建立会话时获取,会话结束失效。
  • 重复消息在消费端还要去重吗?答:要,生产者幂等覆盖范围有限,业务键去重表兜底。

04.7.21.3-016 Kafka 事务消息解决什么?适用边界在哪?

一句话结论

Kafka 事务(transactional API)保证一组跨分区消息要么全部写入成功、要么全部不可见,配合 read_committed 隔离未提交消息;用于多分区原子写、消费-生产-消费(consume-transform-produce)链路。代价是吞吐与复杂度上升,单分区去重用幂等生产者即可,不必上事务。

概念解释

  • 事务:beginTransaction → 多分区 send → commitTransaction/abortTransaction。
  • 消费者 isolation.level=read_committed 只读已提交事务消息。
  • 事务隔离未提交数据,与数据库事务概念对应但作用于日志写入。

原理流程

  1. 生产者初始化事务 ID,开启事务。
  2. 向多个分区写入消息。
  3. 提交:事务标记写入,消息对 committed 消费者可见。
  4. 中止:事务标记 abort,消费者忽略该批消息。

代码或图示

producer.init_transactions()
producer.begin_transaction()
try:
    producer.send(topic_a, ...)
    producer.send(topic_b, ...)
    producer.commit_transaction()
except Exception:
    producer.abort_transaction()

常见误区

  • 单分区简单发送也开事务:吞吐下降,无必要。
  • 事务替代业务幂等:事务保证写原子性,不保证消费端不重复处理。
  • 消费者用 read_uncommitted 读事务主题:未提交消息可能被读到。

追问

  • 事务会阻塞分区吗?答:未提交事务的消息在 committed 视图不可见,长期悬挂影响读取。
  • 事务 ID 怎么管理?答:应用配置或自动生成,多实例避免事务 ID 冲突(待确认:当前版本事务恢复机制)。
  • 什么场景必须用事务?答:一次业务动作需写多个分区且要求原子可见,或 consume-transform-produce 链路精确一次语义。

04.7.21.3-017 confluent-kafka 和 aiokafka 用法有什么差异?

一句话结论

confluent-kafka 是 librdkafka 的 Python 封装,同步 API、性能成熟、功能全;aiokafka 基于 asyncio 原生异步客户端,适合 FastAPI/异步栈。二者配置项(group id、offset、超时)概念对应,但 API 风格不同:同步阻塞 poll/consume vs await 协程方法;生产选型按应用同步/异步模型决定。

概念解释

  • confluent-kafka:C 扩展封装,高吞吐,语言绑定薄。
  • aiokafka:纯 Python 异步实现,与事件循环集成,无阻塞调用。
  • 消息模型、分区/组/offset 概念一致,迁移主要改调用层。

原理流程

  1. 同步栈:Consumer.poll() 轮询批次,处理后 commit()。
  2. 异步栈:await consumer.getone()/getmany(),协程内处理与提交。
  3. 生产者对应 produce/send 与 await send。
  4. 配置项按客户端文档映射,超时与重试参数语义对齐。

代码或图示

# aiokafka 异步
async for msg in consumer:
    handle(msg)
    await consumer.commit()

# confluent-kafka 同步
while True:
    msg = consumer.poll(1.0)
    if msg:
        handle(msg)
        consumer.commit(msg)

常见误区

  • 异步栈用同步客户端:poll 阻塞事件循环,并发退化。
  • 两个客户端配置照搬:参数名/默认值有差异,需对照各自文档。
  • 忽略 librdkafka 部署依赖:confluent-kafka 需对应 C 库环境。

追问

  • 性能哪个更好?答:confluent-kafka 基于 C 库通常吞吐更高;aiokafka 优势在异步集成,基准按场景压测。
  • 事务消息两个库都支持吗?答:能力支持程度随版本不同,需查客户端文档确认(待确认:aiokafka 事务 API 成熟度)。
  • 消费者组配置一致吗?答:group.id、offset 策略、心跳超时等概念一致,参数名可能不同。

04.7.21.3-018 Kafka 怎么保证消息顺序性?

一句话结论

Kafka 只保证单分区内消息顺序;要保证一类业务消息有序,必须用同一业务 key 路由到同一分区(如订单 ID),消费者单线程/单协程顺序处理该分区。跨分区不保证全局顺序;并发消费会破坏分区内顺序,需按 key 分区后再控制消费并发。

概念解释

  • 顺序边界:分区日志追加顺序。
  • key 哈希:相同 key 落到固定分区。
  • 消费侧:多线程并发处理同一分区会打乱顺序,需串行或按 key 排队。

原理流程

  1. 生产者以业务 key(订单号)发送,哈希到固定分区。
  2. 消息按追加顺序写入分区日志。
  3. 消费者按 offset 顺序拉取。
  4. 单分区内串行处理;需要并行时按 key 分流到独立处理单元。

代码或图示

producer.send("orders", key=order_id.encode(), value=payload)
# 同一 order_id 始终进入同一分区

常见误区

  • 以为 Kafka 全局有序:不同分区并行,无全局顺序。
  • 同一分区多线程消费:处理完成顺序与写入顺序不一致。
  • key 选择可变字段:字段变化导致消息跳分区,顺序断裂。

追问

  • 顺序消费怎么并行?答:按 key 分组,每组单线程处理,组间并行。
  • 分区数变化影响顺序吗?答:增加分区后 key 哈希重映射,历史顺序边界变化,需评估。
  • 失败重试会打乱顺序吗?答:阻塞重试会卡住后续消息;异步重试可能乱序,顺序敏感场景需特殊设计。

04.7.21.3-019 重复消费怎么识别和处理?

一句话结论

重复消费来源:提交前崩溃重投、rebalance 后位点未提交、生产者重试、超时重投。处理:消费端按业务唯一键去重(去重表/缓存记录已处理),处理逻辑幂等;记录消息 key/offset 便于追溯。中间件只防丢失,不保证恰好一次,业务层必须兜底。

概念解释

  • 重复不等于错误:幂等设计下重复执行结果一致。
  • 去重粒度:业务单号/事件 ID,不用消息 offset(重投后 offset 可能不同)。
  • 状态机:已处理状态拦截重复副作用。

原理流程

  1. 消息进入,提取业务唯一键。
  2. 查去重记录:已处理直接确认跳过。
  3. 未处理:执行业务,成功后写去重记录并提交 offset。
  4. 重复投递命中记录,不再产生副作用。

代码或图示

def consume(msg):
    event = parse(msg.value())
    if Dedup.exists(event.event_id):
        return
    apply(event)
    Dedup.save(event.event_id)

常见误区

  • 用消息 offset 去重:重投/重平衡后 offset 变化,挡不住重复。
  • 去重记录只放缓存:缓存丢失后重复执行,关键路径落库。
  • 非幂等外部调用无防护:重复通知/扣款,重复消费直接造成业务损失。

追问

  • 去重记录保留多久?答:按业务回溯周期,资金类长期保留,普通事件可定期清理。
  • 批量消息部分失败怎么去重?答:逐条记录处理状态,失败重试不影响已成功条目。
  • 怎么统计重复消费率?答:日志记录重复命中次数,监控重复比例异常。

04.7.21.3-020 RabbitMQ 和 Kafka 怎么选型?

一句话结论

RabbitMQ:路由灵活(exchange/topic)、确认与死信成熟、低延迟、消息可丢弃,适合业务异步解耦、任务队列、复杂路由;Kafka:高吞吐、消息持久化留存、可重放、分区并行,适合日志流、事件溯源、大数据管道、长期消费。任务队列选 RabbitMQ,数据流平台选 Kafka。

概念解释

  • RabbitMQ 消息确认后删除,侧重投递可靠性与路由。
  • Kafka 消息按保留期留存,可多消费者组重复消费、回溯。
  • 吞吐模型:RabbitMQ 单队列路由精细;Kafka 分区水平扩展吞吐。

原理流程

  1. 评估需求:路由复杂度、消息留存、吞吐、回溯、延迟。
  2. 业务通知/任务/死信重试 → RabbitMQ。
  3. 事件流/日志/数据集成/多订阅回放 → Kafka。
  4. 混合场景按链路拆分,不强行统一中间件。

代码或图示

任务队列、复杂路由、死信、低延迟  -> RabbitMQ
高吞吐、消息留存、重放、多消费组  -> Kafka

常见误区

  • 用 Kafka 做短任务队列:消费位点与重试模型不如 RabbitMQ 任务语义直接。
  • 用 RabbitMQ 堆积海量日志:队列与镜像/仲裁扩展性有限。
  • 只看吞吐不看运维栈:团队熟悉度与监控体系也是选型因素。

追问

  • 两者都能持久化吗?答:都支持;Kafka 以日志留存为核心,RabbitMQ 持久化消息确认后删除。
  • 消息顺序性谁更强?答:都需按 key/队列分区保证;Kafka 单分区有序,RabbitMQ 单队列单消费者有序。
  • 跨系统事件同步选哪个?答:事件溯源/多订阅回放选 Kafka;命令式通知/任务选 RabbitMQ。

04.7.21.3-021 Kafka 和 Redis Stream 怎么选?

一句话结论

Kafka 面向大规模持久化流:分区副本、长期留存、多消费组、回溯能力强;Redis Stream 轻量、与 Redis 栈复用、延迟低,适合中小规模异步消息、轻量消费组。海量事件流与数据管道选 Kafka;已有 Redis 基础设施、简单任务通知选 Redis Stream。

概念解释

  • Redis Stream:条目 ID 追加,消费组与 pending 条目机制,存于 Redis 内存。
  • Kafka:分布式日志,磁盘持久化,副本容错,吞吐水平扩展。
  • 可靠性:Redis Stream 受 Redis 持久化/主从能力约束。

原理流程

  1. 评估消息量级、留存时长、消费组数量、可靠性要求。
  2. 轻量异步/已有 Redis → Stream。
  3. 大规模流/回溯/多订阅 → Kafka。
  4. 积压与故障恢复能力按组件能力分别验证。

代码或图示

Redis Stream: 轻量、低延迟、复用 Redis、内存受限
Kafka:       高吞吐、持久化留存、副本容错、可重放

常见误区

  • Redis Stream 存海量历史消息:内存成本高,过期淘汰影响消费回溯。
  • 用 Stream 做复杂死信/延迟路由:能力薄,需应用层补。
  • 忽略 Redis 单线程瓶颈:大消息/高并发下 Stream 命令排队。

追问

  • Redis Stream 有消费组吗?答:有,消费组 + pending 条目跟踪,ack 后移除。
  • Stream 消息能重复读吗?答:未 ack 条目可 reclaim,已读条目按 ID 范围读取。
  • 两者顺序性?答:单 Stream/单分区内追加有序,多消费者并行不保证。

04.7.21.3-022 消息积压怎么排查和扩容?

一句话结论

积压排查:看队列/分区深度趋势与消费速率 → 检查消费者在线数、并发、是否阻塞/崩溃 → 分析单条消息处理耗时与下游依赖 → 判断容量不足还是故障。扩容:增加消费者实例(不超分区/队列并行上限)、拆分慢消息队列、限流生产者;故障恢复后控制消化速率,避免二次冲击。

概念解释

  • 积压 = 生产速率 > 消费速率,持续累积。
  • 并行上限:Kafka 分区数、RabbitMQ 队列分发能力。
  • 下游瓶颈:DB 慢查询、外部接口超时会拖住消费者。

原理流程

  1. 监控队列深度/分区 lag 曲线,定位积压起点。
  2. 核对消费者实例、并发线程、心跳与状态。
  3. 聚合消息处理耗时与失败率,找长尾。
  4. 检查下游依赖指标与日志。
  5. 扩容/隔离/限流,观察消费速率追上生产速率。

代码或图示

lag ↑ -> 消费者是否在线/打满 -> 单条耗时 -> 下游依赖
-> 扩容消费者 / 拆分队列 / 限流生产者

常见误区

  • 盲目加消费者:受分区数/下游连接上限约束,扩容无效。
  • 不区分慢消息类型统一处理:快任务被慢任务拖累。
  • 积压消化不限速:恢复后批量重投压垮下游。

追问

  • Kafka 消费者数能超过分区数吗?答:能,但多余实例空闲;并行上限是分区数。
  • RabbitMQ 积压能在 broker 侧扩容吗?答:增加消费者实例分摊队列消息,队列本身可镜像/仲裁高可用。
  • 积压期间怎么保护在线接口?答:生产者侧限流,低优事件延后投递。

04.7.21.3-023 消息丢失可能发生在哪些环节?

一句话结论

丢失链路三环节:生产者发送失败未确认/重试丢失;broker 未持久化或节点故障;消费者未处理完就 ack/崩溃。逐环节防护:生产者 confirm 重试、队列与消息持久化、消费者手动 ack 与幂等。排查丢消息要按环节核对确认记录、持久化配置与 ack 时机。

概念解释

  • 生产环节:网络超时、broker 拒绝、未等待确认。
  • broker 环节:内存消息未刷盘、节点宕机、副本不足。
  • 消费环节:自动 ack、异常跳过、进程被杀。

原理流程

  1. 生产者发布并等待 confirm/ack,失败重发。
  2. broker 持久化队列与消息,副本同步多数派。
  3. 消费者处理成功后手动 ack;未 ack 重投。
  4. 对账:生产记录、broker 留存、消费记录三段比对定位缺口。

代码或图示

生产者 -> broker -> 消费者
  confirm   持久化   手动 ack
  重试      副本     幂等兜底

常见误区

  • 只防 broker 不防生产/消费:两端窗口照样丢消息。
  • 消息不持久化依赖内存:broker 重启即丢。
  • 以为中间件保证恰好一次:中间件防丢,重复与跳过需业务处理。

追问

  • 怎么对账消息是否丢失?答:业务单号串联生产日志、broker 位点/队列、消费记录,抽样比对。
  • broker 宕机消息还在吗?答:持久化 + 副本多数派可恢复;内存/单副本场景丢失。
  • 消费者重启已 ack 的消息能找回吗?答:已 ack 从队列移除,不可找回,需业务补偿。

04.7.21.3-024 顺序消费和并发消费怎么取舍?

一句话结论

顺序消费:同一业务实体消息串行处理,保证状态流转正确,但吞吐受限;并发消费:多分区/多队列并行,吞吐高但同实体消息可能乱序。取舍按业务:状态机、资金、库存变更要求顺序,按 key 分组串行;只读通知、聚合统计可并发。设计上按 key 分流,组内串行、组间并行。

概念解释

  • 顺序代价:单线程处理,吞吐随分区/key 数扩展。
  • 并发风险:后到消息先处理,状态回退或覆盖。
  • 折中:按业务 key 分区,消费者按 key 哈希分配到独立串行单元。

原理流程

  1. 识别消息是否依赖先后状态。
  2. 依赖顺序:key 路由单分区,消费者串行处理。
  3. 无顺序要求:多分区并行消费。
  4. 混合场景:key 分组并行,组内保序。

代码或图示

group 0: key=A 串行 -> msg A1, A2, A3
group 1: key=B 串行 -> msg B1, B2
组间并行,组内有序

常见误区

  • 全部并发处理顺序敏感事件:状态流转错乱。
  • 全部分组串行:吞吐不足,积压严重。
  • 失败重试阻塞后续消息:顺序队列里慢重试卡住同 key 后续事件。

追问

  • 顺序队列里消息失败怎么办?答:阻塞重试或转延迟重试队列,避免乱序;同 key 后续消息等待。
  • 怎么验证消费顺序?答:日志记录 key、时间戳与处理序号,核对单调递增。
  • 跨实体消息有先后要求吗?答:一般按业务实体隔离,跨实体依赖通过事件版本/状态校验处理。

04.7.21.3-025 Elasticsearch 倒排索引是什么原理?

一句话结论

倒排索引从词项(term)映射到包含该词项的文档列表,区别于正排从文档找词。写入时分词生成词项,建立 term → posting list 映射;查询时按词项查 posting list,再合并打分排序。ES 基于 Lucene 倒排结构,支持全文检索与聚合。

概念解释

  • 正向索引:文档 → 词项;倒排:词项 → 文档。
  • posting list:文档 ID 列表,含位置/频率/权重信息。
  • 分词(analysis)是倒排构建前提,分析器决定词项切分。

原理流程

  1. 文档写入,经分析器分词为词项。
  2. 每个词项映射到 posting list,记录文档 ID 与统计信息。
  3. 查询词项查 posting list,得到候选文档。
  4. 评分、过滤、排序后返回结果。

代码或图示

term "elastic" -> [doc 1, doc 5, doc 9]
term "search"   -> [doc 2, doc 5]
交集/并集 -> 候选文档 -> 评分排序

常见误区

  • 把 ES 当关系表精确查询库:强项是全文检索与聚合,复杂事务不是其定位。
  • 忽略分词质量:分析器不当导致搜不到/误匹配。
  • 大文档无字段拆分:索引体积膨胀,检索变慢。

追问

  • 倒排索引为什么快?答:直接按词项定位文档列表,避免全文档扫描文本。
  • posting list 有哪些压缩?答:Lucene 对文档列表等结构编码压缩,降低磁盘占用(待确认:当前版本编码细节)。
  • ES 集群还存正排数据吗?答:存储 stored/source 字段用于取回原文,检索主要走倒排。

04.7.21.3-026 mapping 字段类型和 dynamic mapping 怎么理解?

一句话结论

mapping 定义字段名、类型(text/keyword/数值/日期/布尔/嵌套等)与索引参数;dynamic=true 新字段自动按类型推断加入 mapping,dynamic=false 新字段只存 _source 不建索引,strict 遇新字段报错。生产建议显式管理 mapping,避免自动推断产生错误类型与索引膨胀。

概念解释

  • text:分词全文检索;keyword:精确匹配/聚合/排序。
  • 数值/日期类型决定存储与查询语义。
  • 嵌套对象 nested 保持对象内关联,object 会扁平化。

原理流程

  1. 建索引时显式定义 mapping 或首次写入自动推断。
  2. 新字段按 dynamic 策略处理:入 mapping/仅存源/报错。
  3. 字段类型一旦确定不可直接改,需新建索引重建。
  4. 类型不匹配查询会报错或命中失败。

代码或图示

{
  "mappings": {
    "properties": {
      "title": { "type": "text" },
      "sku": { "type": "keyword" },
      "price": { "type": "scaled_float" },
      "created_at": { "type": "date" }
    }
  }
}

常见误区

  • 字符串字段全用 text:无法精确聚合/排序,需 keyword 子字段。
  • dynamic=true 放任新字段:类型推断错误,索引字段无序膨胀。
  • 想改已有字段类型:ES 不支持直接改类型,需 reindex 到新索引。

追问

  • text 和 keyword 怎么配合?答:字段可同时配 text 主字段与 keyword 子字段,检索用 text,聚合排序用 keyword。
  • 数组字段要单独声明吗?答:ES 数组复用元素类型,无需专门 array 类型。
  • nested 和 object 区别?答:object 扁平化对象字段,nested 保留数组对象间独立关联查询。

04.7.21.3-027 分析器(analyzer)由哪些部分组成?

一句话结论

分析器由字符过滤器(char filter)、分词器(tokenizer)、词项过滤器(token filter)组成:先清洗文本,再切分词项,最后规范化(小写、停用词、词干)。索引与查询各用一套分析器,中文需专门分词器(如 IK/pinyin 插件,待确认:生产插件选型)。

概念解释

  • char filter:去标签、替换字符。
  • tokenizer:按规则切分单词。
  • token filter:小写化、停用词、同义词、词干提取。
  • 索引分析与查询分析要匹配,否则检索不到。

原理流程

  1. 原始文本进入 char filter 清洗。
  2. tokenizer 切分为词项流。
  3. token filter 规范化每个词项。
  4. 生成索引词项;查询时同样分析查询串再匹配倒排。

代码或图示

"Hello, World!"
 -> char filter: 去标点
 -> tokenizer: [hello, world]
 -> token filter: 小写 [hello, world]

常见误区

  • 索引和查询分析器不一致:查询词项匹配不到索引词项。
  • 中文不装分词插件:按单字切分,检索质量差。
  • 停用词/同义词配置不当:召回过多或关键词被过滤。

追问

  • 怎么测试分析器效果?答:_analyze 接口传入文本,查看分词结果词项。
  • 同义词怎么生效?答:索引期或查询期配置同义词 filter,两种时机召回不同。
  • 数字/型号怎么检索?答:keyword 精确匹配,避免 text 分词拆散。

04.7.21.3-028 bool 查询 must/should/filter 怎么用?

一句话结论

bool 组合子句:must 必须匹配且参与评分;should 可选匹配,命中加分;filter 必须匹配但不评分(可缓存);must_not 必须不匹配。组合表达复杂条件:相关度排序用 must/should,纯条件过滤用 filter,排除项用 must_not。

概念解释

  • filter 上下文:不计算相关性得分,结果可被节点缓存,性能更好。
  • must 上下文:参与评分,影响 _score。
  • should 在没有 must/filter 时至少命中一个;有 must 时可选加分。

原理流程

  1. 构造 bool 子句树,各子句对应查询类型。
  2. ES 分别执行 must/should/filter/must_not 子查询。
  3. filter/must_not 过滤候选集,must/should 计算评分。
  4. 合并结果按 _score 排序返回。

代码或图示

{
  "query": {
    "bool": {
      "must": [{ "match": { "title": "手机" } }],
      "filter": [{ "term": { "status": "on" } }],
      "must_not": [{ "term": { "deleted": true } }],
      "should": [{ "term": { "brand": "xm" } }]
    }
  }
}

常见误区

  • 精确条件塞进 must:参与评分且无法缓存,性能与排序都受影响。
  • should 无 must 时误解为可选:此场景至少命中一个 should。
  • 嵌套 bool 层级过深:调试困难,条件拆分需清晰。

追问

  • filter 缓存什么?答:常用 filter 子句结果可被缓存,重复查询直接命中。
  • match 和 term 区别?答:match 先分析查询串再匹配;term 精确匹配词项,不分词。
  • 怎么组合范围查询?答:range 子句放 filter 上下文,按数值/日期区间过滤。

04.7.21.3-029 相关度评分和 filter 缓存怎么理解?

一句话结论

ES 按 TF-IDF/BM25 等模型计算 _score,词频、字段长度、逆文档频率影响权重;filter 上下文只做布尔过滤不评分,结果可缓存。不需要排序相关性的条件(状态、类目、时间范围)放 filter,提升性能并利用缓存;需要匹配度排序的放 must/match。

概念解释

  • BM25:Lucene 默认评分模型,考虑词频饱和与字段长度归一。
  • filter 缓存:节点级缓存常用过滤结果,重复查询加速。
  • 评分受字段长度、词项稀有度影响,不是简单命中即最高分。

原理流程

  1. 查询词项匹配候选文档。
  2. 评分模型计算每个候选 _score。
  3. filter 子句先缩小候选集,不参与打分。
  4. 结果按 _score 排序,可按字段二次排序。

代码或图示

{
  "query": {
    "bool": {
      "must": [{ "match": { "desc": "笔记本" } }],
      "filter": [{ "range": { "price": { "lte": 5000 } } }]
    }
  }
}

常见误区

  • 所有条件都用 match:精确条件被评分污染,排序失真且无缓存。
  • 依赖默认评分做业务排序:业务排序应显式按字段 sort,不靠 _score。
  • 忽略索引词频分布:稀有词权重高,通用词重复出现收益递减。

追问

  • BM25 可调参数吗?答:可在索引/字段配置调 k1、b 等参数(待确认:当前版本参数名与默认值)。
  • filter 缓存命中率怎么看?答:ES 节点统计与慢查询日志观察 filter 命中情况。
  • 怎么提升弱相关召回?答:同义词、分词优化、multi_match 多字段匹配,而非调评分权重。

04.7.21.3-030 深分页为什么受限?search_after 怎么用?

一句话结论

from + size 深分页要协调节点收集各分片前 from+size 条结果再排序截取,越深成本越高,ES 有 index.max_result_window(默认 10000)限制。search_after 用上一页最后一条的排序值作为游标,只取后续批次,避免深翻页成本;需要跳页/随机跳转时不适用。

概念解释

  • from/size:偏移分页,深翻页各分片都要取到偏移位置。
  • search_after:游标分页,依赖唯一排序字段(如 id + 时间)。
  • scroll:早期快照遍历,适合批量导出,不适合实时用户翻页。

原理流程

  1. 首页查询带排序字段与 size。
  2. 记录最后一条的排序值(含唯一字段防并列)。
  3. 下一页 search_after=[上页末尾值] 取后续批次。
  4. 无 offset 成本,随翻页深度保持稳定。

代码或图示

{
  "size": 20,
  "sort": [{ "created_at": "desc" }, { "id": "desc" }],
  "search_after": [1732000000000, 9988]
}

常见误区

  • 大 from 翻页:触发窗口限制或性能骤降。
  • search_after 排序字段有并列值:游标定位不准,需加唯一字段兜底。
  • 用 search_after 做随机跳页:它只能顺序向后翻,不支持跳转到指定页。

追问

  • max_result_window 默认多少?答:默认 10000(待确认:当前版本默认值),可调整但深翻页成本仍高。
  • scroll 和 PIT 区别?答:scroll 快照遍历;PIT(point in time)配合 search_after 保持一致视图,适合持续翻页(待确认:版本支持)。
  • 批量导出用什么?答:scroll/PIT + search_after 或 bulk 导出,避免 from/size 深分页。

04.7.21.3-031 scroll 和 PIT 分别适合什么场景?

一句话结论

scroll 维护快照遍历上下文,适合一次性批量导出/全量同步;PIT(point in time)生成时间点视图,配合 search_after 做持续翻页且期间新写入不干扰结果。实时用户翻页用 search_after + PIT;离线大批量遍历用 scroll;两者都解决深分页问题,模型不同。

概念解释

  • scroll:首次查询生成滚动上下文,后续按游标取批次,快照期间数据变更不反映。
  • PIT:锁定某时间点视图,search_after 在该视图内翻页。
  • scroll 上下文有存活期,需及时清理。

原理流程

  1. scroll:首次查询带 scroll=1m,返回首批与 scroll_id;后续用 scroll_id 取批次。
  2. PIT:先创建 PIT 拿到 id,查询带 PIT id 与 search_after。
  3. 遍历完成释放上下文/PIT。
  4. 快照保证遍历期间结果一致,不受新写入影响。

代码或图示

// scroll 首批
{ "size": 100, "scroll": "1m", "query": { "match_all": {} } }
// 后续:{ "scroll_id": "...", "scroll": "1m" }

常见误区

  • scroll 上下文不清理:占用节点资源,长期累积。
  • 用 scroll 做用户实时翻页:上下文重、延迟高,体验差。
  • PIT 存活期过短:长翻页中途视图过期,需重建。

追问

  • scroll 能看到遍历期间的更新吗?答:快照视图内不可见,保证遍历一致性。
  • PIT 适合多轮查询吗?答:适合持续翻页,期间新写入不进入当前视图。
  • 大数据量导出怎么控制速率?答:分批拉取,控制批次大小与并发,避免压垮 ES。

04.7.21.3-032 ES 写入怎么优化?bulk 和 refresh_interval 怎么配?

一句话结论

批量写入用 bulk 聚合多条请求减少往返;refresh_interval 控制索引刷新为可见的频率,调大(如 30s)提升写入吞吐,牺牲近实时可见性;索引建立阶段可临时关闭刷新与副本。写入优化还包括:避免动态 mapping、字段精简、批量大小适中、监控写入拒绝与线程池排队。

概念解释

  • bulk:一次请求携带多条 index/update,减少网络与协调开销。
  • refresh:段刷新后新文档才可被搜索;频率越高写入越慢。
  • 副本数在建索引阶段可临时调小,完成后恢复。

原理流程

  1. 客户端按批次组装 bulk 请求,批次大小按文档量压测。
  2. 写入前评估 mapping,避免动态推断与冗余字段。
  3. 调整 refresh_interval,批量导入期可设 -1 关闭刷新。
  4. 导入完成恢复刷新与副本,监控写入延迟与拒绝率。

代码或图示

// 建索引阶段临时配置
{
  "settings": {
    "refresh_interval": "30s",
    "number_of_replicas": 0
  }
}

常见误区

  • bulk 批次过大:请求体超阈值、内存压力大、失败重试成本高。
  • 实时搜索场景调大 refresh:新数据延迟可见,业务不可接受。
  • 写入慢只加节点:先查 mapping 膨胀、字段过多、磁盘 IO 与线程池排队。

追问

  • bulk 部分失败怎么处理?答:响应逐条报告错误,按错误项重试/修正 mapping。
  • refresh_interval 默认多少?答:默认 1s(待确认:当前版本默认值),实时检索场景保持默认。
  • 索引生命周期怎么管理?答:热温冷分层,老索引收缩/冻结/归档,控制集群规模。

04.7.21.3-033 分片数和副本数怎么规划?

一句话结论

分片数决定水平拆分与并行度,按数据量与单分片大小规划(常见单分片 GB 级到数十 GB),不宜过多;副本数保证容错与读扩展,生产至少 1–2 副本。分片数建索引后只能增不能减,需预留增长;副本随集群节点分布,避免同节点放全副本。

概念解释

  • 分片过多:元数据/内存开销上升,查询协调成本增加。
  • 副本:主分片数据复制,故障切换与读负载分摊。
  • 单分片过大:迁移、恢复、查询性能受影响。

原理流程

  1. 预估总数据量、增长速率与单分片目标大小。
  2. 分片数 ≈ 总量 / 单分片目标,考虑未来增长。
  3. 副本因子按容错与读扩展需求设 1–2。
  4. 监控分片大小、磁盘水位与分片分布,超限拆分新索引。

代码或图示

{
  "settings": {
    "number_of_shards": 5,
    "number_of_replicas": 1
  }
}

常见误区

  • 一开始分片开很多:小数据量分片分散,资源浪费。
  • 副本数为 0 上生产:节点故障丢数据。
  • 按节点数凑分片:分片规划看数据量,不看节点数量。

追问

  • 分片数能减少吗?答:ES 不支持直接减少分片,需新建索引 reindex 迁移。
  • 副本会占用多少磁盘?答:磁盘 ≈ 主分片数据 ×(1 + 副本数)。
  • 读多写少怎么扩?答:增加副本分摊读请求,副本分布到不同节点。

04.7.21.3-034 ES 的近实时(NRT)是什么意思?

一句话结论

ES 写入后不是立即可搜:文档先写内存 buffer,refresh 后生成可搜索段(segment)才进入搜索视图,默认刷新间隔 1s,因此是近实时而非强实时。刷新频率、段合并、副本同步影响可见延迟;对强实时可见性要求高的场景需评估 ES 边界。

概念解释

  • segment:Lucene 不可变倒排段,refresh 后可见。
  • 段合并:小段合并为大段,优化检索但有 IO 开销。
  • 副本写入:主分片写成功后同步副本,查询可能命中副本。

原理流程

  1. 文档写入主分片内存 buffer 与 translog。
  2. 到达 refresh 间隔,buffer 生成新段,可被搜索。
  3. 后台段合并持续进行。
  4. 数据复制到副本,副本刷新后可被查询。

代码或图示

写入 -> buffer/translog -> refresh -> segment 可见 -> 副本同步

常见误区

  • 以为写入即可查:存在 refresh 延迟窗口。
  • 频繁手动 refresh:段数量暴涨,合并压力大。
  • 把 ES 当业务主库:NRT 与检索定位决定它不承担强一致事务。

追问

  • 怎么强制刷新?答:_refresh 接口,但生产不可频繁调用。
  • translog 作用是什么?答:记录未刷盘操作,节点崩溃后恢复内存段之前的数据。
  • 搜索能读到未刷新数据吗?答:不能,需等 refresh 生成段。

04.7.21.3-035 对象存储的 bucket、object、endpoint 是什么?

一句话结论

bucket(桶)是存储容器,全局/账号内命名;object(对象)是桶内文件及其元数据;endpoint 是服务访问域名/地址。对象存储按「桶名 + 对象键(key)」定位文件,扁平结构无真实目录层级,目录靠 key 前缀模拟。常见兼容 S3 协议:AWS S3、MinIO、阿里云 OSS、腾讯 COS。

概念解释

  • 对象:数据 + 元数据(大小、类型、时间、ETag)。
  • 前缀:key 中 / 分隔路径,模拟文件夹视图。
  • 访问协议:RESTful API / S3 SDK,不提供本地文件系统挂载(部分网关除外)。

原理流程

  1. 管理员创建 bucket,配置权限/区域/生命周期。
  2. 上传对象指定 key,写入 bucket。
  3. 通过 endpoint + bucket + key 访问。
  4. 按前缀列举对象,模拟目录结构。

代码或图示

bucket: user-avatars
key:    2026/11/19/ann.png
endpoint: https://oss.example.com

常见误区

  • 把对象存储当本地磁盘随机改写:对象整体覆盖写入,不支持局部修改。
  • bucket 名含大写/特殊字符:S3 规范要求小写与合法字符。
  • 目录层级真实存在:列举靠前缀匹配,无目录对象。

追问

  • 对象存储适合存什么?答:图片、视频、附件、导出文件、静态资源;不适合频繁随机更新的小数据。
  • 权限怎么控制?答:桶策略、访问 ACL、预签名 URL、临时凭证,最小权限。
  • 跨区域复制有吗?答:多数服务支持跨区域复制与版本控制,按服务能力配置。

04.7.21.3-036 boto3 客户端怎么初始化和配置凭证?

一句话结论

boto3 通过 boto3.client("s3", endpoint_url=..., aws_access_key_id=..., aws_secret_access_key=..., region_name=...) 创建 S3 兼容客户端;凭证优先从环境变量、配置文件或实例角色读取,不在代码硬编码。自建 MinIO/私有 OSS 通过 endpoint_url 指向;客户端线程安全,可复用单例。

概念解释

  • S3 兼容:boto3 可对接 MinIO、OSS 等实现 S3 协议的服务。
  • 凭证来源链:环境变量 → 共享凭证文件 → IAM 角色/元数据。
  • 超时、重试、签名版本可在客户端/会话级配置。

原理流程

  1. 读取配置:endpoint、区域、凭证(注入或环境变量)。
  2. 创建 S3 client 或 resource 接口。
  3. 复用客户端单例,业务调用 upload/download。
  4. 凭证轮换/权限最小化,定期审计访问密钥。

代码或图示

import boto3

s3 = boto3.client(
    "s3",
    endpoint_url="https://oss.example.com",
    aws_access_key_id=access_key,
    aws_secret_access_key=secret_key,
    region_name="cn-north-1",
)
s3.upload_file("local.png", "bucket", "2026/ann.png")

常见误区

  • 代码/配置仓库提交明文密钥:泄露后可直接访问存储,必须用环境变量/密钥管理。
  • 每次请求新建客户端:连接无法复用,初始化开销叠加。
  • endpoint_url 漏配:默认连 AWS 公网,私有服务不可达。

追问

  • boto3 resource 和 client 区别?答:client 是低层 API;resource 是面向对象封装,底层仍走 client。
  • 凭证怎么轮换?答:定期更换访问密钥,旧密钥禁用,接入密钥管理服务。
  • 私有 MinIO 用什么签名?答:S3 v4 签名,客户端默认处理;兼容问题按服务文档调整。

04.7.21.3-037 预签名 URL 是什么原理?怎么控制过期?

一句话结论

预签名 URL 由持有凭证的服务端用签名算法生成,携带权限、对象、过期时间与签名;客户端凭 URL 直接上传/下载,无需暴露长期密钥。presigned_get_url 用于下载,presigned_post_url/分片上传用于上传;过期时间按业务场景设置,路径/对象绑定签名防篡改。

概念解释

  • 签名包含 HTTP 方法、bucket、key、过期时间、凭证范围。
  • 服务端鉴权后签发,客户端直连对象存储,减轻应用带宽。
  • 签名 URL 泄露风险与过期时长正相关。

原理流程

  1. 后端校验用户权限。
  2. 生成预签名 URL:方法、key、ExpiresIn 秒数。
  3. 客户端用 URL 直传/直下载对象。
  4. 过期后 URL 失效,签名被篡改则拒绝访问。

代码或图示

url = s3.generate_presigned_url(
    ClientMethod="get_object",
    Params={"Bucket": "bucket", "Key": "2026/ann.png"},
    ExpiresIn=600,
)

常见误区

  • 预签名 URL 长期有效:泄露后长期可访问,按场景设短过期。
  • 服务端不鉴权直接签发:任意用户可拿到他人对象 URL。
  • 签名绑定对象被替换:key 对应内容变更,URL 仍指向原 key 权限范围。

追问

  • 上传预签名怎么限制文件大小/类型?答:POST 策略表单可限制 content-length、字段,按 S3 兼容服务能力配置。
  • 预签名 URL 能跨域吗?答:对象存储需配 CORS 规则,浏览器直传才允许。
  • 下载私有文件怎么做?答:后端鉴权后签短期 GET URL,前端跳转/下载。

04.7.21.3-038 大文件分片上传流程是什么?

一句话结论

大文件分片上传:服务端/客户端初始化分片上传任务 → 文件切分为分片并行上传 → 全部完成后合并;失败分片可单独重传,无需整文件重传。S3 兼容协议分 create_multipart_upload、upload_part、complete_multipart_upload,中止用 abort。适合视频、安装包、导出文件。

概念解释

  • 分片大小与数量权衡:分片过小请求多,过大失败重传成本高。
  • 并行上传提升吞吐,合并在服务端完成。
  • 未完成的分片上传需定期 abort 清理,避免存储残留。

原理流程

  1. 创建 multipart upload,拿到 upload_id。
  2. 本地切片,并发上传各分片,记录 part number 与 ETag。
  3. 全部成功,complete 提交合并清单。
  4. 失败/取消:abort 清理已上传分片。

代码或图示

create = s3.create_multipart_upload(Bucket=bucket, Key=key)
upload_id = create["UploadId"]
parts = []
for i, chunk in enumerate(split(file), start=1):
    resp = s3.upload_part(Bucket=bucket, Key=key, UploadId=upload_id,
                          PartNumber=i, Body=chunk)
    parts.append({"PartNumber": i, "ETag": resp["ETag"]})
s3.complete_multipart_upload(Bucket=bucket, Key=key, UploadId=upload_id,
                             MultipartUpload={"Parts": parts})

常见误区

  • 分片上传不清理未完成任务:残留分片占用空间,需定时 abort 过期任务。
  • 合并清单 ETag/分片号错配:合并失败或文件损坏。
  • 分片过大并行度低:小文件直传即可,不必分片。

追问

  • 分片大小怎么定?答:常见 5–20MB,按文件大小与网络环境压测;分片数有协议上限。
  • 断点续传怎么实现?答:已上传分片记录 part 号/ETag,续传跳过已完成分片。
  • 合并后能直接访问吗?答:complete 成功后对象可见,ETag 与分片清单相关。

04.7.21.3-039 对象存储回调通知怎么校验签名?

一句话结论

存储事件回调(上传完成/删除通知)推送到业务回调地址,业务必须校验请求签名与来源,防止伪造事件触发业务逻辑;回调体含对象 bucket/key/事件类型/时间,签名用平台密钥按约定算法计算。校验通过后再处理,失败记录并拒绝;回调需幂等,重复推送重复处理无副作用。

概念解释

  • 签名校验:时间戳、随机串/body、密钥参与签名,防篡改与重放。
  • 来源确认:平台域名/IP 白名单辅助识别。
  • 回调重试:平台可能多次推送,业务按事件 ID 去重。

原理流程

  1. 平台配置回调地址与签名密钥。
  2. 对象事件触发,回调带签名头与事件体。
  3. 业务按算法重算签名比对,检查时间戳防重放。
  4. 校验通过按事件处理;失败返回错误,平台按策略重试。

代码或图示

def verify_callback(headers, body):
    expected = sign(secret, headers["timestamp"], body)
    if not constant_time_equal(expected, headers["signature"]):
        raise PermissionError

常见误区

  • 不校验签名直接处理:伪造上传完成事件可触发下游业务。
  • 回调不幂等:重复推送重复通知/重复生成记录。
  • 时间戳不校验:签名被截获后可长期重放。

追问

  • 回调签名算法看什么?答:对应存储平台文档的签名规则(HMAC-SHA256 等),密钥与业务密钥隔离。
  • 回调失败平台会重试吗?答:多数平台按指数退避重试,超时后进死信/通知队列,需查询服务文档。
  • 大文件完成通知延迟怎么办?答:业务以通知为准,必要时主动 head 对象校验存在性。

04.7.21.3-040 MongoDB 文档模型适合什么场景?边界在哪?

一句话结论

MongoDB 以 BSON 文档存储,模式灵活、嵌套结构自然、横向扩展方便,适合内容、目录、日志、半结构化数据;边界:多表强事务、复杂跨实体 JOIN、严格关系范式不是强项。文档内冗余与嵌套要按查询模式设计,避免过度嵌套与大数组。

概念解释

  • 文档:类 JSON 结构,可嵌套对象/数组,单文档有大小限制(16MB,待确认:当前版本上限)。
  • 集合:无固定 schema,字段可动态演进。
  • 关系建模:嵌入(embedding)与引用(reference)按查询与更新频率权衡。

原理流程

  1. 按查询模式设计文档结构:高频一起读的数据嵌入。
  2. 频繁独立更新/多对多关系用引用。
  3. 控制单文档大小与数组长度,避免大数组无限增长。
  4. 复杂跨实体一致性评估事务能力与替代方案。

代码或图示

{
  "_id": "u1",
  "name": "ann",
  "tags": ["vip"],
  "addresses": [{ "city": "昆明" }]
}

常见误区

  • 把关系库范式照搬 MongoDB:大量引用文档,查询需多次关联。
  • 文档无限嵌套/大数组:查询与更新成本高,单文档超限。
  • 强事务需求硬上 MongoDB:多文档事务能力有限,复杂一致性场景选关系库。

追问

  • 单文档大小限制多少?答:BSON 文档上限 16MB(待确认:版本是否调整),大内容拆分引用。
  • 数组里的子文档怎么查?答:数组字段可索引与查询,嵌套字段用点路径。
  • MongoDB 支持 JOIN 吗?答:$lookup 聚合阶段可左连接,性能与灵活性不及关系库。

04.7.21.3-041 MongoDB 有哪些索引类型?复合索引怎么建?

一句话结论

索引类型:单字段、复合(多字段)、多键(数组)、文本、地理空间、唯一、稀疏/TTL。复合索引字段顺序遵循最左前缀:等值在前、排序/范围在后;唯一索引保证键不重复;TTL 索引自动过期删除文档。索引提升查询但增加写入与存储开销。

概念解释

  • 复合索引顺序:查询条件与排序决定字段顺序,最左前缀匹配。
  • 多键索引:数组字段自动展开建索引。
  • TTL:按日期字段到期删除,适合会话/日志数据。

原理流程

  1. 分析查询条件、排序、聚合路径。
  2. 设计复合索引:等值字段在前,范围/排序在后。
  3. 创建唯一/多键/TTL 等专用索引。
  4. 用 explain 验证命中,删除冗余索引。

代码或图示

db.orders.create_index([("user_id", 1), ("created_at", -1)])
db.users.create_index("email", unique=True)
db.sessions.create_index("expires_at", expireAfterSeconds=0)

常见误区

  • 复合索引顺序与查询不匹配:最左前缀未命中,索引失效。
  • 每个查询字段单独建索引:冗余且写入开销大。
  • 数组无限制建多键索引:大数组索引体积膨胀。

追问

  • 索引怎么查是否命中?答:explain("executionStats") 看 stage、indexName、扫描行数。
  • 唯一索引允许 null 吗?答:唯一索引下 null 值按规则处理,多文档同 null 行为需验证(待确认:版本语义)。
  • TTL 索引能更新过期时间吗?答:文档到期自动删除,不适合需要保留历史的数据。

04.7.21.3-042 怎么判断 MongoDB 查询在全集合扫描?

一句话结论

explain 输出中 stage 为 COLLSCAN 即全集合扫描;命中索引为 IXSCAN。关注 totalDocsExamined(扫描行数)与返回行数差距、indexName 是否为空。全扫描常见于无索引条件、索引未命中、前缀不匹配、类型不一致;慢查询结合 profiling 日志定位。

概念解释

  • COLLSCAN:遍历集合所有文档。
  • IXSCAN:扫描索引键后回取文档。
  • 扫描行数远超返回行数说明索引选择性差或未命中。

原理流程

  1. 开启 profiling 或慢查询日志收集慢语句。
  2. explain("executionStats") 查看执行阶段。
  3. 识别 COLLSCAN 与扫描行数,定位缺失/失效索引。
  4. 补复合索引或改写查询,复查计划。

代码或图示

db.orders.explain("executionStats").find({ user_id: 1001 })
// stage: COLLSCAN -> 缺索引;IXSCAN + indexName -> 命中

常见误区

  • 查询条件用函数/表达式包裹索引列:索引无法使用。
  • 类型不一致(字符串 vs 数字):匹配失败走全扫描。
  • 只看返回快不看扫描量:小集合全扫快,数据增长后恶化。

追问

  • 怎么看索引使用率?答:$indexStats 聚合查看各索引命中次数与大小。
  • 大集合全扫描有什么影响?答:CPU/IO 占用高,阻塞其他查询,内存缓存被污染。
  • 复合索引失效常见原因?答:违反最左前缀、范围列后再排序列、类型不匹配。

04.7.21.3-043 MongoDB 事务有哪些限制?

一句话结论

MongoDB 多文档事务副本集支持,分片集群事务能力受版本与配置约束;事务内操作文档跨集合/跨分片有限制,事务有时限与运行时限制。关系库成熟的复杂 JOIN、隔离级别、长事务语义不是其强项;强一致多实体场景应评估关系库或应用层补偿。

概念解释

  • 单文档操作天然原子;多文档事务需显式 session 事务。
  • 事务限制:跨分片写入、索引/集合创建等操作不可在事务内执行(待确认:版本具体约束清单)。
  • 事务超时与 oplog 窗口限制长事务。

原理流程

  1. 会话开启事务,执行多文档读写。
  2. 提交或中止;副本集多数派保证提交。
  3. 超出时限/约束,事务中止报错。
  4. 跨实体一致性需求评估事务覆盖范围,不足部分应用补偿。

代码或图示

with client.start_session() as session:
    with session.start_transaction():
        db.accounts.update_one(..., session=session)
        db.orders.insert_one(..., session=session)

常见误区

  • 把 MongoDB 事务当关系库事务用:跨分片/长事务支持有限。
  • 事务内做 schema 变更:多数不允许,需事务外执行。
  • 长事务阻塞复制与缓存:事务时长需控制在平台限制内。

追问

  • 分片集群支持事务吗?答:新版本支持跨分片事务,但有约束与性能代价(待确认:当前版本支持范围)。
  • 事务隔离级别可配置吗?答:MongoDB 事务提供快照隔离级别语义(待确认:可配置级别)。
  • 不支持事务的场景怎么保证一致?答:状态机 + 幂等 + 对账补偿,必要时引入关系库。

04.7.21.3-044 MongoDB 分片是什么概念?

一句话结论

分片(sharding)把数据按分片键拆分到多个分片节点,水平扩展存储与吞吐;mongos 路由请求到对应分片,配置存储分片元数据。分片键选择决定数据分布与查询路由,热点分片会抵消扩展效果。中小规模先用副本集,数据量/容量到瓶颈再分片。

概念解释

  • 分片键:决定文档落到哪个分片。
  • chunk:分片内连续数据块,达到大小拆分迁移。
  • mongos:查询路由层,对应用透明。

原理流程

  1. 按数据增长与访问模式选分片键。
  2. 数据按分片键哈希/范围分布到分片。
  3. mongos 按元数据路由查询到目标分片。
  4. 数据倾斜时 chunk 迁移再平衡。

代码或图示

app -> mongos -> shard A (user_id 1..k)
             -> shard B (user_id k+1..n)
config servers: 分片元数据

常见误区

  • 过早分片:副本集够用时增加运维复杂度。
  • 分片键选低基数/热点值:数据集中到单分片,扩展失效。
  • 跨分片查询无分片键:广播到全分片,开销大。

追问

  • 分片键能改吗?答:集合分片后分片键不可直接改,需导出重建集合。
  • 范围分片和哈希分片区别?答:范围分片利于范围查询但可能热点;哈希分片分布均匀,范围查询需跨分片。
  • 分片副本还需要吗?答:每个分片内部仍是副本集,保证高可用。

04.7.21.3-045 最终一致性怎么实现?补偿手段有哪些?

一句话结论

最终一致性:分布式操作不要求实时一致,通过异步重试、补偿事务、对账修复在短时间内收敛一致。手段:可靠消息投递(outbox)、幂等消费、失败重试与死信、定时对账扫描差异、人工兜底处理异常单据。设计时明确一致性窗口与不一致可容忍度。

概念解释

  • 强一致:同步等待所有节点确认;最终一致:异步收敛。
  • 补偿:正向操作失败后执行逆向操作(退款、撤销、回滚记录)。
  • 对账:周期比对各系统状态,差异自动修复或人工介入。

原理流程

  1. 本地事务写业务数据与待发消息(outbox)。
  2. 消息投递下游,消费者幂等处理。
  3. 失败重试/死信,异常单据进补偿流程。
  4. 定时对账扫描差异,自动补偿或告警人工处理。

代码或图示

本地事务: 业务表 + outbox 记录
→ 投递消息 → 幂等消费
→ 失败重试/死信 → 对账扫描 → 自动补偿/人工

常见误区

  • 承诺实时一致却用异步链路:一致性预期错位。
  • 只有重试无对账:长期隐藏的不一致无人发现。
  • 补偿操作不幂等:重复补偿造成二次损害。

追问

  • 一致性窗口怎么定?答:按业务容忍度,秒级/分钟级/日级,配合监控告警。
  • 跨服务事务用什么模式?答:Saga(编排/协同)、TCC、outbox + 异步补偿,按场景选。
  • 对账发现差异怎么修?答:先冻结异常单据,按权威数据源修复,记录处理轨迹。

04.7.21.3-046 outbox 本地消息表怎么设计?

一句话结论

outbox 模式:本地事务内同时写业务表与消息记录(outbox 表),事务提交后由后台任务/CDC 读取未发消息投递到 broker,投递成功标记状态。保证「业务落库」与「消息发出」一致,避免事务内直接发 MQ 导致的回滚脏消息。表字段含消息 ID、topic/队列、载荷、状态、重试次数、创建时间。

概念解释

  • 本地事务原子性:业务数据与消息记录同一事务提交。
  • 投递解耦:后台扫描 outbox 投递,失败重试,幂等更新状态。
  • 可结合 CDC(binlog 订阅)替代轮询扫描。

原理流程

  1. 业务事务:写业务记录 + 插入 outbox 待发消息。
  2. 事务提交,消息状态为 pending。
  3. 投递任务扫描 pending 记录,发往 broker。
  4. 投递成功标记 sent;失败递增重试次数,超限告警转人工。

代码或图示

CREATE TABLE outbox (
  id BIGINT PRIMARY KEY,
  event_id VARCHAR(64) UNIQUE,
  target VARCHAR(128),
  payload TEXT,
  status VARCHAR(16),
  retries INT,
  created_at TIMESTAMP
);

常见误区

  • outbox 与业务不在同一事务:仍存在不一致窗口。
  • 投递成功不更新状态:重复投递,消费端需幂等兜底。
  • 扫描无索引:按 status/created_at 扫描大表,性能恶化。

追问

  • outbox 消息保留多久?答:sent 记录定期清理,保留周期按审计需求。
  • CDC 方案怎么工作?答:订阅业务库 binlog,捕获 outbox 变更投递,降低轮询开销。
  • 消息载荷存大对象合适吗?答:大载荷落对象存储,outbox 存引用。

04.7.21.3-047 事件发布时机:事务内、提交后还是 outbox?

一句话结论

三种时机:事务内发 MQ(回滚脏消息风险)、提交后发 MQ(进程崩溃可能丢消息)、outbox/CDC(本地事务落消息记录,异步投递,一致性最好)。可靠业务优先 outbox;低风险通知可提交后直接投递;事务内发布只在确认无回滚场景使用。

概念解释

  • 事务内:消息先于提交发出,事务回滚后消费者已收到脏消息。
  • 提交后:on_commit 钩子投递,钩子前崩溃消息丢失。
  • outbox:消息记录随事务持久化,异步补偿投递。

原理流程

  1. 评估消息可靠性要求与崩溃恢复场景。
  2. 高可靠:业务表 + outbox 同事务,后台投递。
  3. 一般场景:提交后钩子直接 delay(),监控投递失败。
  4. 低风险采样/通知:可简化处理。

代码或图示

事务内发布: 回滚 -> 脏消息(不推荐)
提交后发布: 崩溃 -> 可能丢消息
outbox:    事务落记录 -> 异步投递 -> 可恢复

常见误区

  • 把 outbox 当万能:增加表与投递任务,简单场景过度设计。
  • 提交后投递不做失败重试:消息丢失无补偿。
  • 事件载荷含未提交对象:应传 ID,提交后再加载。

追问

  • outbox 和本地消息表是一回事吗?答:是同一模式的不同叫法,记录待投递事件。
  • 事件顺序怎么保证?答:outbox 按创建顺序投递,同业务 key 串行下游消费。
  • 多服务事件怎么广播?答:outbox 投递到 topic/交换器,各消费组订阅。

04.7.21.3-048 幂等消费去重表怎么落地?

一句话结论

去重表记录已处理业务事件:事件唯一键、处理状态、结果、时间;消费时先查记录,已处理直接确认跳过;处理成功后写入记录。表上加唯一索引防并发重复,状态区分处理中/成功/失败。关键业务落库去重,缓存只作加速层;去重记录按周期清理。

概念解释

  • 唯一键:业务单号/事件 ID,不用消息 offset。
  • 并发防护:处理中状态 + 唯一索引,双写冲突拦截。
  • 与 outbox 配合:生产去重与消费去重两侧都可设。

原理流程

  1. 消费消息提取事件键。
  2. 查去重表:成功 → ack 跳过;处理中 → 等待/退出。
  3. 执行业务,成功后插入去重记录。
  4. 唯一索引拦截并发重复写入;失败记录状态便于重试。

代码或图示

CREATE TABLE consumed_events (
  event_id VARCHAR(64) PRIMARY KEY,
  status VARCHAR(16),
  result TEXT,
  created_at TIMESTAMP
);

常见误区

  • 去重只放 Redis:缓存丢失后重复执行,关键路径必须落库。
  • 先执行业务后写记录:崩溃窗口重复执行。
  • 去重键含可变字段:身份不稳定,挡不住重复。

追问

  • 去重表和业务表能合并吗?答:状态字段并入业务表可减少一张表,但通用事件去重独立表更清晰。
  • 记录保留策略?答:按业务回溯期清理,资金/审计类长期保留。
  • 并发重复插入冲突怎么处理?答:捕获唯一索引冲突,视为已处理,直接 ack。

04.7.21.3-049 重试、补偿和人工兜底怎么分层?

一句话结论

分层策略:瞬时故障自动重试(退避 + 次数上限);业务可逆错误走补偿事务(逆向操作);多次失败/不可逆异常进死信/异常表,告警人工介入。每层记录原因与轨迹,自动修复优先,人工兜底覆盖边缘场景;补偿操作本身必须幂等可重放。

概念解释

  • 重试:同一正向操作重复执行,限瞬时故障。
  • 补偿:执行逆向动作撤销前序影响(退款、解冻、撤销记录)。
  • 人工:系统无法自动收敛的单据,人工核对后处理。

原理流程

  1. 失败分类:可重试/可补偿/需人工。
  2. 可重试:退避重投,超限转下一层。
  3. 可补偿:执行逆向操作,记录补偿轨迹。
  4. 无法自动处理:异常队列/表 + 告警,人工核对修复。

代码或图示

失败 -> 重试(退避, N次) -> 补偿事务(逆向) -> 死信/异常表 -> 人工

常见误区

  • 所有失败都自动重试:fatal 错误反复执行,污染队列。
  • 补偿操作不幂等:重复补偿造成二次损害。
  • 人工兜底无流程:异常单据积压无人跟进。

追问

  • 补偿和回滚一样吗?答:补偿是业务层逆向动作,不一定撤销数据库;回滚是事务层撤销。
  • 人工处理后怎么闭环?答:记录处理人与结果,关闭异常单,回归对账。
  • 重试次数怎么定?答:按下游 SLA 与故障类型,指数退避加抖动,总时长可控。

04.7.21.3-050 选型消息中间件看哪些指标?

一句话结论

选型维度:吞吐量与延迟、消息留存/回溯能力、路由模型、顺序性保证、重复与幂等支持、持久化与容错、运维复杂度与团队熟悉度、生态客户端、监控与社区活跃度。按主诉求排序:任务队列 vs 事件流 vs 轻量通知,不追求功能最全而求匹配场景。

概念解释

  • 吞吐:分区/队列水平扩展能力。
  • 留存:消息确认后删除还是按周期保留。
  • 可靠:确认、持久化、副本、死信能力。
  • 运维:部署、监控、升级、故障恢复成本。

原理流程

  1. 列出业务场景与非功能需求。
  2. 按维度对比 RabbitMQ/Kafka/Redis Stream 等。
  3. 预发压测关键指标:吞吐、延迟、积压恢复。
  4. 结合团队栈与运维能力定型。

代码或图示

任务/路由/死信  -> RabbitMQ
事件流/留存/回放 -> Kafka
轻量异步/复用 Redis -> Redis Stream

常见误区

  • 选型只看峰值吞吐:可靠性、运维成本被忽略。
  • 跟风选流行组件:团队不熟悉,故障排查慢。
  • 一个中间件覆盖所有场景:不同链路拆分更合理。

追问

  • 怎么压测消息中间件?答:固定生产速率,观察消费延迟、积压、broker CPU/内存/磁盘与重试率。
  • 客户端生态重要吗?答:Python 客户端成熟度、异步支持、维护状态直接影响开发效率。
  • 未来扩展怎么预留?答:接口抽象消息层,业务代码不绑定具体中间件实现。

04.7.21.3-051 Kafka 消费者怎么限流和控制批次?

一句话结论

批次参数:max.poll.records 控制单次拉取条数,fetch.min.bytes/fetch.max.wait.ms 控制攒批大小与等待;限流在消费处理侧按下游容量控制速率。批量处理失败要逐条记录状态,避免整批跳过;poll 间隔不能超过 max.poll.interval.ms,否则被踢出组。

概念解释

  • 攒批:多消息合并处理提升吞吐,增加延迟。
  • 限流:消费速率匹配下游 DB/接口容量,保护依赖。
  • 批次大小与单条处理时长共同决定 poll 间隔。

原理流程

  1. 配置拉取批次大小与等待时间。
  2. 拉取批次后逐条/分组处理。
  3. 按下游容量限流,超速等待或回压。
  4. 处理完提交 offset,控制 poll 节奏。

代码或图示

consumer = KafkaConsumer(
    "orders",
    max_poll_records=500,
    fetch_min_bytes=1024,
    fetch_max_wait_ms=500,
)

常见误区

  • 批次过大:单批处理超时触发 rebalance。
  • 批量失败整批提交:部分消息被跳过丢失。
  • 不限流消费:下游被打垮,积压反弹。

追问

  • 批量处理怎么提交 offset?答:逐条成功后可逐条提交;整批成功提交整批,失败条目单独记录重试。
  • 拉取线程和处理线程分开吗?答:可解耦拉取与处理,注意 offset 提交与背压。
  • 怎么观察批次效率?答:记录批次大小、处理时长、提交间隔与下游耗时。

04.7.21.3-052 RabbitMQ 队列长度怎么监控和告警?

一句话结论

监控队列深度(Ready 消息数)、Unacked 数、消费者数量、消息进入/离开速率、队列磁盘/内存占用。告警分级:深度持续增长、消费者为 0、Unacked 长期不下降、磁盘内存水位高。结合消费速率判断是正常波动还是积压,避免瞬时峰值误告警。

概念解释

  • Ready:待投递消息;Unacked:已投递未确认。
  • 速率:publish/ack 速率差决定积压方向。
  • 队列健康:消费者在线、持久化配置、死信路由正常。

原理流程

  1. 通过管理 API/指标采集队列深度与消费者数。
  2. 计算生产-消费速率差,判断趋势。
  3. 阈值告警:深度超线、消费者离线、Unacked 堆积。
  4. 联动排查消费者与下游依赖。

代码或图示

queue depth, ready, unacked, consumers,
publish rate, ack rate, memory/disk

常见误区

  • 只看深度绝对值:小队列深但消费快是正常;趋势与速率更关键。
  • 不监控消费者数:消费者全部离线,深度暴涨才发现。
  • 告警无分级:瞬时峰值频繁打扰值班。

追问

  • RabbitMQ 指标怎么采集?答:管理插件 HTTP API 或 Prometheus exporter 导出队列/连接/通道指标。
  • Unacked 高说明什么?答:消费慢或任务卡住,检查处理时长与下游。
  • 死信队列也要监控吗?答:要,死信深度代表失败消息积压,需跟进处理。

04.7.21.3-053 ES 写入失败和 mapping 冲突怎么处理?

一句话结论

写入失败常见原因:字段类型与 mapping 不匹配、文档超大小/字段上限、动态 mapping 策略限制、批量部分拒绝。处理:响应逐条解析错误项,修正数据或 mapping;类型冲突需新建索引 reindex;写入失败进重试/死信并告警,不静默丢弃。

概念解释

  • mapping 冲突:字符串写入数值字段、数组类型不一致、对象结构冲突。
  • 批量响应:逐条报告成功/失败,失败项可单独重试。
  • 索引版本冲突:并发更新同一文档版本冲突。

原理流程

  1. 写入响应检查错误清单与失败原因。
  2. 类型不匹配:清洗数据或调整 mapping;不可改则新建索引迁移。
  3. 版本冲突:重读后重试更新。
  4. 失败消息入重试队列,超限落异常表告警。

代码或图示

{
  "errors": true,
  "items": [
    { "index": { "status": 400, "error": { "type": "mapper_parsing_exception" } } }
  ]
}

常见误区

  • 批量写入忽略逐项错误:部分文档未入库无人发现。
  • 直接改已有字段类型:ES 不支持,必须 reindex。
  • 失败无限重试:mapping 错误重试无效,应转人工修正。

追问

  • 字段类型错了怎么迁移?答:建新索引定义正确 mapping,reindex 迁移,别名切换后删旧索引。
  • 文档大小超限怎么处理?答:拆分字段/引用外部存储,减小单文档。
  • 怎么预防 mapping 冲突?答:写入前校验数据类型,显式管理 mapping,关闭不当动态推断。

04.7.21.3-054 本地开发怎么 mock 对象存储?

一句话结论

本地/测试环境用 MinIO 等 S3 兼容服务起容器,或用 S3 mock 库模拟客户端;代码通过 endpoint_url 切换,业务接口面向 S3 协议抽象。避免把本地文件路径硬编码进业务代码;测试用临时桶隔离,用完清理,保证生产切换凭证与区域配置即可。

概念解释

  • S3 兼容:MinIO、本地 OSS 网关都实现 S3 API,boto3 客户端可直连。
  • mock 层级:本地容器服务最接近真实协议;内存 mock 适合单元测试。
  • 配置注入:endpoint、bucket、凭证按环境区分。

原理流程

  1. 开发环境启动 MinIO 容器,创建测试桶。
  2. 客户端配置指向本地 endpoint 与测试凭证。
  3. 业务上传/下载走同一套 S3 接口。
  4. 测试结束清理桶与数据;生产切换 endpoint 与凭证。

代码或图示

s3 = boto3.client(
    "s3",
    endpoint_url=settings.s3_endpoint,  # 本地 MinIO / 生产 OSS
    aws_access_key_id=settings.s3_key,
    aws_secret_access_key=settings.s3_secret,
)

常见误区

  • 业务代码直接读写本地文件目录:上生产路径不通,无法走对象存储 API。
  • mock 不校验签名/权限:真实环境权限问题本地暴露不出。
  • 测试桶数据不清理:本地与 CI 环境残留堆积。

追问

  • 单元测试用什么 mock?答:boto3 stub/自定义 fake client,模拟 put/get 响应与异常。
  • 多环境桶名怎么规划?答:环境前缀隔离(dev/staging/prod),避免串数据。
  • S3 协议差异要注意什么?答:各兼容服务分片上传、签名、策略支持程度不同,关键功能预发验证。

04.7.21.3-055 MongoDB 与关系库表结构迁移边界在哪?

一句话结论

从关系库迁 MongoDB:范式表拆分为嵌入/引用文档,按查询模式重构;强关联、多表 JOIN、复杂事务、统计报表类数据不一定适合迁移。迁移前评估读写模式、事务需求、索引与聚合能力;灰度双写对账,不强行把关系模型搬进文档库。

概念解释

  • 嵌入:高频一起读写的子对象并入文档。
  • 引用:独立更新、多对多关系保留引用。
  • 不适合迁移:复杂跨表事务、强 JOIN 分析、严格 ACID 流程。

原理流程

  1. 梳理表关系与查询/更新模式。
  2. 设计文档模型:嵌入/引用划分,控制文档大小。
  3. 双写迁移 + 对账校验数据一致。
  4. 评估不适合的数据保留关系库,混合存储。

代码或图示

关系表: users 1—N addresses
MongoDB: addresses 嵌入 users.addresses(读多写少)
       或 addresses 引用 user_id(独立更新频繁)

常见误区

  • 照搬三范式建集合:多次引用查询,性能差。
  • 大表拆文档不评估大小:单文档超限,数组膨胀。
  • 忽略事务差异:原关系流程在 MongoDB 无法等价保证。

追问

  • 迁移后怎么对账?答:按主键比对数量、抽样字段值与聚合统计,差异修复。
  • 双写期怎么切读?答:先双写,读流量灰度切到 MongoDB,稳定后停旧库写。
  • 聚合报表适合 MongoDB 吗?答:复杂多表关联分析一般更适合关系库/数仓。

04.7.21.3-056 跨组件一致性链路怎么设计?

一句话结论

端到端一致性链路:入口写本地事务(业务 + outbox)→ 可靠消息投递 → 下游幂等消费 → 失败重试/死信 → 对账补偿。每段明确状态与责任人,关键单据可追溯;监控不一致迹象(重复、缺失、状态卡住),强一致核心链路评估是否应缩短为本地事务。

概念解释

  • 状态贯通:业务状态、消息状态、消费状态可串联查询。
  • 边界:跨服务只能最终一致,本地内强一致。
  • 补偿闭环:自动修复 + 人工兜底。

原理流程

  1. 划定链路涉及的服务、存储、消息中间件。
  2. 每段定义成功/失败/重试/死信状态。
  3. outbox 保证投递,消费幂等防重复。
  4. 周期对账比对各段状态,差异触发补偿。

代码或图示

DB 事务 -> outbox -> MQ -> 服务B 幂等 -> 服务C
         对账贯通: 业务单号串联各段记录

常见误区

  • 链路无状态追踪:出问题无法定位卡在哪一段。
  • 只设计正常路径:失败/重试/补偿分支缺失。
  • 跨服务追求实时强一致:链路长、可用性差,应明确最终一致窗口。

追问

  • 怎么串起全链路记录?答:业务单号/事件 ID 贯穿日志、outbox、消费记录与消息头。
  • 不一致告警看什么?答:消息积压、死信增长、对账差异、状态长时间不流转。
  • 核心资金链路怎么设计?答:缩短分布式跨度,关键扣减在本地事务,跨系统用对账 + 冻结/解冻补偿。

04.7.21.3-057 消息 schema 怎么演进保持兼容?

一句话结论

消息 schema 演进规则:新增字段给默认值、不删除已有字段、不改字段类型与语义;消费者兼容旧版本消息(缺字段用默认),生产者兼容新结构。版本号/字段说明纳入约定,废弃字段先标记再在下一版本移除;跨语言契约可用 schema 注册表或文档约束。

概念解释

  • 向后兼容:新消费者能读旧消息。
  • 向前兼容:旧消费者能读新消息(忽略未知字段)。
  • 破坏性变更:改类型、删字段、改语义,需新 topic/版本迁移。

原理流程

  1. 定义消息字段约定与版本策略。
  2. 新增字段:可选 + 默认值,消费者缺失时兜底。
  3. 废弃字段:先保留只读,观察期后移除。
  4. 破坏性变更:新版本消息/主题,双版本过渡。

代码或图示

{
  "event_id": "e1",
  "order_id": "o1",
  "channel": "web",
  "schema_version": 2
}

常见误区

  • 直接改字段类型:旧消费者反序列化失败。
  • 消费者不忽略未知字段:新字段导致解析报错。
  • 无版本约定:线上新旧消息混跑难以排查。

追问

  • 消息体用什么序列化?答:JSON 通用;跨语言高性能可用 Protobuf/Avro,配合 schema 管理。
  • 字段废弃流程?答:标记 deprecated → 停止生产写入 → 消费侧确认无依赖 → 移除。
  • 破坏性变更怎么过渡?答:新 topic/事件名并行,旧消费者迁移后再下线旧版本。

04.7.21.3-058 积压期间怎么降级?哪些消息可以丢弃?

一句话结论

积压降级:低优事件限流/延后投递,消费者优先处理高优队列;可丢弃消息仅限可重新生成、无业务后果的采样/监控/埋点类;业务订单、通知、资金类不可丢弃,需扩容与补偿。降级决策记录依据,恢复后评估补跑范围,避免静默丢业务事件。

概念解释

  • 降级层级:限流生产者、暂停低优消费、扩容消费者、临时扩容中间件。
  • 丢弃前提:数据可由后续周期重新采集,丢失无业务影响。
  • 不可丢弃:状态流转、对外通知、账务、库存变更。

原理流程

  1. 识别积压类型与消息优先级。
  2. 高优队列优先消费,低优事件延后/限流。
  3. 采样类消息按策略降级丢弃并记录。
  4. 恢复后检查业务消息是否补齐,必要时补偿重放。

代码或图示

高优: 订单/支付/通知 -> 保消费
低优: 报表/埋点/统计 -> 延后或限流
采样: 监控指标 -> 可丢弃, 记录降级

常见误区

  • 积压时一刀切丢弃:业务事件丢失造成客诉与账务问题。
  • 降级无记录:事后无法判断丢了哪些消息。
  • 恢复后不补跑低优任务:周期数据缺口长期存在。

追问

  • 怎么判断消息可否丢弃?答:是否影响业务状态、对外承诺、资金;可重新采集且无后果才降级。
  • 限流在生产侧还是消费侧?答:两侧配合,生产侧控制投递速率,消费侧保护下游。
  • 降级开关怎么管理?答:配置化开关,可一键恢复,记录触发与解除时间。

04.7.21.3-059 存储组件监控哪些要点?

一句话结论

消息中间件监控:深度/lag、消费者在线与并发、重试/死信率、投递与消费速率、broker 资源(CPU/内存/磁盘/网络)、积压恢复时间。搜索/对象/文档库监控:写入/查询延迟与拒绝率、索引大小与分片健康、对象存储请求量/错误率/容量、索引命中与扫描量。指标要关联业务 SLA,不只看组件存活。

概念解释

  • 消息:可靠性与吞吐指标并重。
  • 搜索:检索延迟、写入吞吐、集群健康(分片/副本/磁盘水位)。
  • 对象存储:请求错误、容量、带宽、预签名签发量。

原理流程

  1. 梳理各组件关键指标与采集方式。
  2. 配置阈值告警:积压、错误率、资源水位。
  3. 关联业务指标:接口耗时、订单成功率。
  4. 定期复盘容量与趋势,提前扩容。

代码或图示

MQ: lag, consumers, retry/dead-letter, rates, broker resources
ES: query/write latency, rejects, shard health, disk
S3: request errors, capacity, bandwidth
Mongo: scan ratio, index usage, locks, connections

常见误区

  • 只监控进程存活:进程在但队列积压/慢查询严重。
  • 指标无基线:无法判断异常波动。
  • 不监控资源水位:磁盘打满才发现,影响写入。

追问

  • 监控数据采到哪?答:Prometheus + exporter/自定义埋点,Grafana 看板,告警分级通知。
  • 怎么看组件是否成为瓶颈?答:关联业务耗时与组件指标,瓶颈段指标随请求量恶化。
  • 容量趋势怎么复盘?答:周期增长外推,提前规划扩容与归档策略。

04.7.21.3-060 综合场景:订单事件链路怎么选组件设计?

一句话结论

以订单链路为例:下单本地事务写库与 outbox → broker 投递订单事件 → 库存/通知/积分各消费组幂等处理;业务命令与可靠通知选 RabbitMQ(死信/重试成熟),事件流水与多订阅回放选 Kafka;搜索走 ES 补全文检索,附件走对象存储,对账补偿保证最终一致。设计先定一致性等级与 SLA,再选组件。

概念解释

  • 链路分层:写入本地事务、异步解耦、检索与附件外挂。
  • 一致性:核心扣减本地事务,跨服务最终一致 + 对账。
  • 组件职责:MQ 解耦、ES 检索、对象存储附件、Mongo 存灵活内容(按需)。

原理流程

  1. 梳理订单状态流转与下游依赖。
  2. 本地事务 + outbox 保证事件可靠发出。
  3. 按场景选 broker:任务通知 RabbitMQ,事件流 Kafka。
  4. 下游幂等消费,失败重试/死信,定时对账补偿。
  5. ES 承担检索,对象存储存附件,监控全链路指标。

代码或图示

下单 -> DB + outbox -> MQ -> 库存/通知/积分(幂等)
                     -> 事件流回放
检索: ES  附件: 对象存储  对账: 定时扫描补偿

常见误区

  • 链路一开始就引入所有组件:过度设计,按真实需求落地。
  • 跨服务环节忽略幂等与对账:重复/缺失无人兜底。
  • 检索直接查业务库:大表全文查询拖垮在线交易。

追问

  • 订单超时取消怎么实现?答:延迟队列/定时扫描到期订单,状态校验后取消,幂等处理重复触发。
  • 多下游消费失败怎么隔离?答:独立队列与消费组,单下游故障不影响其他消费。
  • 怎么验证链路可靠?答:故障演练:broker 重启、消费者崩溃、消息重复,验证重投、幂等与对账修复。

本节高频题

  • RabbitMQ 交换/绑定/队列属性(001、002、003)
  • ack、prefetch、死信与重试队列(004、005、006、007)
  • 仲裁队列与消息可靠性(008、009、010)
  • Kafka 分区副本、offset 与消费组(011、012、013、014)
  • 幂等生产者、事务消息与客户端差异(015、016、017)
  • 顺序性、重复消费与选型对比(018、019、020、021)
  • 积压排查与消息丢失链路(022、023、024)
  • ES 倒排、mapping、分析器与 bool 查询(025、026、027、028、029)
  • 深分页、写入优化与分片规划(030、031、032、033、034)
  • 对象存储客户端、预签名与分片上传(035、036、037、038、039)
  • MongoDB 索引、查询计划与事务限制(040、041、042、043、044)
  • 最终一致、outbox、幂等与补偿(045、046、047、048、049)
  • 选型指标、监控与综合链路(050、052、059、060)