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:用键值对匹配,性能低于键匹配,场景有限。
原理流程
- 生产者发布消息到指定 exchange,携带 routing key。
- exchange 按类型计算匹配的 binding。
- 命中的队列收到消息副本,等待消费者 ack。
- 无队列绑定时消息按配置丢弃或返回生产者。
代码或图示
# 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。
原理流程
- 声明队列与绑定关系(队列 + exchange + 绑定键)。
- 消息携带 routing key 进入 exchange。
- exchange 逐条比对绑定规则。
- 所有命中队列获得消息副本。
代码或图示
# 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:空闲后自动清理,避免遗留无用队列。
原理流程
- 声明队列时设置三个标志位。
- durable 队列元数据写入持久层;exclusive 绑定连接生命周期。
- 消费者断开,auto-delete 计数归零后删除队列。
- 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 状态,计入消费者投递数量。
原理流程
- broker 投递消息给消费者,状态为 unacked。
- 消费者执行业务:成功
basic_ack(delivery_tag)。 - 失败
basic_nack(requeue=True)重回队列,或requeue=False进死信。 - 连接断开,所有 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思路一致。
原理流程
- 消费者声明 channel 时设置 prefetch_count。
- broker 投递消息直到未 ack 数达到上限。
- 消费者 ack 一条,broker 再补投一条。
- 长任务占住在途额度,其他任务排队等待。
代码或图示
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,死信队列是普通队列,只是用途隔离。
- 死信消息可携带原始信息头(交换器、路由键、原因)。
原理流程
- 队列声明时配置
x-dead-letter-exchange与死信 routing key。 - 消息被拒绝/过期/溢出,broker 将其发往 DLX。
- DLX 按绑定路由到死信队列。
- 消费者从死信队列重试、补偿或人工介入。
代码或图示
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 按消息头延迟投递,能力受插件版本支持。
原理流程
- 业务处理失败,消息投递到 TTL 重试队列。
- 到期后消息死信路由回业务队列重新消费。
- 重试次数写入消息头,递增判断。
- 超过最大次数转死信队列,不再回到业务队列。
代码或图示
orders --nack--> retry.1m (TTL 60s) --dead-letter--> orders
超限 --> dead
常见误区
- 重试队列不记次数:失败消息永远循环重试。
- TTL 队列头部阻塞:RabbitMQ 队列 TTL 按队头检查,前一条不过期后面不解除(待确认:当前版本行为)。
- 依赖插件做长延迟:插件未安装/集群版本不一致导致延迟失效。
追问
- 阶梯退避怎么配?答:多个不同 TTL 的重试队列,按重试次数路由到对应层级。
- 延迟消息插件生产注意什么?答:集群所有节点安装同版本,重启后延迟消息持久化情况需验证。
- 重试间隔为什么要加随机抖动?答:避免大量失败消息同一时刻重投,形成重试冲击。
04.7.21.3-008 镜像队列和仲裁队列有什么区别?
一句话结论
镜像队列是 RabbitMQ 早期高可用方案:主节点队列同步副本到镜像节点,已被官方标记废弃;仲裁队列(Quorum Queue)基于 Raft 复制,数据一致由多数派保证,是当前推荐的生产高可用方案。新集群应使用仲裁队列,存量镜像队列规划迁移。
概念解释
- 镜像队列:主从复制,脑裂/一致性问题历史较多,维护成本高。
- 仲裁队列:Raft 多数派提交,节点故障自动选主,数据不依赖单副本。
- 两者配置与监控指标不同,迁移需双队列过渡。
原理流程
- 仲裁队列在多节点建立 Raft 副本集。
- 写入经多数派确认后提交。
- 主节点故障,多数派选举新主继续服务。
- 客户端连接配合集群拓扑自动重连到新主。
代码或图示
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:业务完成后才确认,崩溃可重投。
原理流程
- 生产者声明 durable 队列,发布持久化消息。
- broker confirm 通知消息已安全落盘。
- 消费者手动处理,成功后 ack;未 ack 重投。
- 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:消息无法到达队列时退回,携带交换器、路由键与错误码。
- 生产者需记录未确认消息,超时重试或告警。
原理流程
- 开启 confirm 模式,注册 confirm 回调。
- 发布消息,
mandatory=True注册 return 回调。 - 可路由:broker 处理后 confirm 成功。
- 不可路由: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 保持同步的副本集合。
原理流程
- 主题创建时指定分区数与副本因子。
- 生产者按 key 选分区,写入 leader 日志。
- follower 拉取 leader 消息同步到本地。
- 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处理无位点/位点越界。
原理流程
- 消费者拉取消息批次,记录当前偏移。
- 业务处理完成。
- 手动提交 offset 到 broker(__consumer_offsets)。
- 崩溃重启:从已提交位点继续;未提交部分重新消费。
代码或图示
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 期间分区无主,消息暂停消费。
原理流程
- 消费者加入组,加入协议协调分配。
- 协调者按策略(range/roundrobin/sticky)分配分区。
- 成员异常退出或心跳缺失,标记离组。
- 触发 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()间隔过长被踢出,对应长任务。 - 静态成员:实例固定身份,重启不改变成员身份,减少分区迁移。
原理流程
- 监控成员心跳与 poll 间隔。
- 超时判定离组,协调者触发 rebalance。
- 重新分配分区,暂停消费直到分配完成。
- 优化配置与处理时长,降低触发频率与暂停窗口。
代码或图示
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 拒绝序列号重复或乱序的重复写入。
- 局限:单会话内单分区幂等,事务性写一致性另由事务消息保证。
原理流程
- 生产者启动获得 PID。
- 每条消息携带单调递增序列号。
- broker 检查序列号:重复/回退拒绝,正常追加。
- 生产者重试的重复消息被识别去重。
代码或图示
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只读已提交事务消息。 - 事务隔离未提交数据,与数据库事务概念对应但作用于日志写入。
原理流程
- 生产者初始化事务 ID,开启事务。
- 向多个分区写入消息。
- 提交:事务标记写入,消息对 committed 消费者可见。
- 中止:事务标记 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 概念一致,迁移主要改调用层。
原理流程
- 同步栈:
Consumer.poll()轮询批次,处理后commit()。 - 异步栈:
await consumer.getone()/getmany(),协程内处理与提交。 - 生产者对应
produce/send与await send。 - 配置项按客户端文档映射,超时与重试参数语义对齐。
代码或图示
# 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 排队。
原理流程
- 生产者以业务 key(订单号)发送,哈希到固定分区。
- 消息按追加顺序写入分区日志。
- 消费者按 offset 顺序拉取。
- 单分区内串行处理;需要并行时按 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 可能不同)。
- 状态机:已处理状态拦截重复副作用。
原理流程
- 消息进入,提取业务唯一键。
- 查去重记录:已处理直接确认跳过。
- 未处理:执行业务,成功后写去重记录并提交 offset。
- 重复投递命中记录,不再产生副作用。
代码或图示
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 分区水平扩展吞吐。
原理流程
- 评估需求:路由复杂度、消息留存、吞吐、回溯、延迟。
- 业务通知/任务/死信重试 → RabbitMQ。
- 事件流/日志/数据集成/多订阅回放 → Kafka。
- 混合场景按链路拆分,不强行统一中间件。
代码或图示
任务队列、复杂路由、死信、低延迟 -> 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 持久化/主从能力约束。
原理流程
- 评估消息量级、留存时长、消费组数量、可靠性要求。
- 轻量异步/已有 Redis → Stream。
- 大规模流/回溯/多订阅 → Kafka。
- 积压与故障恢复能力按组件能力分别验证。
代码或图示
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 慢查询、外部接口超时会拖住消费者。
原理流程
- 监控队列深度/分区 lag 曲线,定位积压起点。
- 核对消费者实例、并发线程、心跳与状态。
- 聚合消息处理耗时与失败率,找长尾。
- 检查下游依赖指标与日志。
- 扩容/隔离/限流,观察消费速率追上生产速率。
代码或图示
lag ↑ -> 消费者是否在线/打满 -> 单条耗时 -> 下游依赖
-> 扩容消费者 / 拆分队列 / 限流生产者
常见误区
- 盲目加消费者:受分区数/下游连接上限约束,扩容无效。
- 不区分慢消息类型统一处理:快任务被慢任务拖累。
- 积压消化不限速:恢复后批量重投压垮下游。
追问
- Kafka 消费者数能超过分区数吗?答:能,但多余实例空闲;并行上限是分区数。
- RabbitMQ 积压能在 broker 侧扩容吗?答:增加消费者实例分摊队列消息,队列本身可镜像/仲裁高可用。
- 积压期间怎么保护在线接口?答:生产者侧限流,低优事件延后投递。
04.7.21.3-023 消息丢失可能发生在哪些环节?
一句话结论
丢失链路三环节:生产者发送失败未确认/重试丢失;broker 未持久化或节点故障;消费者未处理完就 ack/崩溃。逐环节防护:生产者 confirm 重试、队列与消息持久化、消费者手动 ack 与幂等。排查丢消息要按环节核对确认记录、持久化配置与 ack 时机。
概念解释
- 生产环节:网络超时、broker 拒绝、未等待确认。
- broker 环节:内存消息未刷盘、节点宕机、副本不足。
- 消费环节:自动 ack、异常跳过、进程被杀。
原理流程
- 生产者发布并等待 confirm/ack,失败重发。
- broker 持久化队列与消息,副本同步多数派。
- 消费者处理成功后手动 ack;未 ack 重投。
- 对账:生产记录、broker 留存、消费记录三段比对定位缺口。
代码或图示
生产者 -> broker -> 消费者
confirm 持久化 手动 ack
重试 副本 幂等兜底
常见误区
- 只防 broker 不防生产/消费:两端窗口照样丢消息。
- 消息不持久化依赖内存:broker 重启即丢。
- 以为中间件保证恰好一次:中间件防丢,重复与跳过需业务处理。
追问
- 怎么对账消息是否丢失?答:业务单号串联生产日志、broker 位点/队列、消费记录,抽样比对。
- broker 宕机消息还在吗?答:持久化 + 副本多数派可恢复;内存/单副本场景丢失。
- 消费者重启已 ack 的消息能找回吗?答:已 ack 从队列移除,不可找回,需业务补偿。
04.7.21.3-024 顺序消费和并发消费怎么取舍?
一句话结论
顺序消费:同一业务实体消息串行处理,保证状态流转正确,但吞吐受限;并发消费:多分区/多队列并行,吞吐高但同实体消息可能乱序。取舍按业务:状态机、资金、库存变更要求顺序,按 key 分组串行;只读通知、聚合统计可并发。设计上按 key 分流,组内串行、组间并行。
概念解释
- 顺序代价:单线程处理,吞吐随分区/key 数扩展。
- 并发风险:后到消息先处理,状态回退或覆盖。
- 折中:按业务 key 分区,消费者按 key 哈希分配到独立串行单元。
原理流程
- 识别消息是否依赖先后状态。
- 依赖顺序:key 路由单分区,消费者串行处理。
- 无顺序要求:多分区并行消费。
- 混合场景: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)是倒排构建前提,分析器决定词项切分。
原理流程
- 文档写入,经分析器分词为词项。
- 每个词项映射到 posting list,记录文档 ID 与统计信息。
- 查询词项查 posting list,得到候选文档。
- 评分、过滤、排序后返回结果。
代码或图示
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会扁平化。
原理流程
- 建索引时显式定义 mapping 或首次写入自动推断。
- 新字段按 dynamic 策略处理:入 mapping/仅存源/报错。
- 字段类型一旦确定不可直接改,需新建索引重建。
- 类型不匹配查询会报错或命中失败。
代码或图示
{
"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:小写化、停用词、同义词、词干提取。
- 索引分析与查询分析要匹配,否则检索不到。
原理流程
- 原始文本进入 char filter 清洗。
- tokenizer 切分为词项流。
- token filter 规范化每个词项。
- 生成索引词项;查询时同样分析查询串再匹配倒排。
代码或图示
"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 时可选加分。
原理流程
- 构造 bool 子句树,各子句对应查询类型。
- ES 分别执行 must/should/filter/must_not 子查询。
- filter/must_not 过滤候选集,must/should 计算评分。
- 合并结果按 _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 缓存:节点级缓存常用过滤结果,重复查询加速。
- 评分受字段长度、词项稀有度影响,不是简单命中即最高分。
原理流程
- 查询词项匹配候选文档。
- 评分模型计算每个候选 _score。
- filter 子句先缩小候选集,不参与打分。
- 结果按 _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:早期快照遍历,适合批量导出,不适合实时用户翻页。
原理流程
- 首页查询带排序字段与 size。
- 记录最后一条的排序值(含唯一字段防并列)。
- 下一页
search_after=[上页末尾值]取后续批次。 - 无 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 上下文有存活期,需及时清理。
原理流程
- scroll:首次查询带
scroll=1m,返回首批与 scroll_id;后续用 scroll_id 取批次。 - PIT:先创建 PIT 拿到 id,查询带 PIT id 与 search_after。
- 遍历完成释放上下文/PIT。
- 快照保证遍历期间结果一致,不受新写入影响。
代码或图示
// 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:段刷新后新文档才可被搜索;频率越高写入越慢。
- 副本数在建索引阶段可临时调小,完成后恢复。
原理流程
- 客户端按批次组装 bulk 请求,批次大小按文档量压测。
- 写入前评估 mapping,避免动态推断与冗余字段。
- 调整
refresh_interval,批量导入期可设-1关闭刷新。 - 导入完成恢复刷新与副本,监控写入延迟与拒绝率。
代码或图示
// 建索引阶段临时配置
{
"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。
- 监控分片大小、磁盘水位与分片分布,超限拆分新索引。
代码或图示
{
"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 开销。
- 副本写入:主分片写成功后同步副本,查询可能命中副本。
原理流程
- 文档写入主分片内存 buffer 与 translog。
- 到达 refresh 间隔,buffer 生成新段,可被搜索。
- 后台段合并持续进行。
- 数据复制到副本,副本刷新后可被查询。
代码或图示
写入 -> 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,不提供本地文件系统挂载(部分网关除外)。
原理流程
- 管理员创建 bucket,配置权限/区域/生命周期。
- 上传对象指定 key,写入 bucket。
- 通过 endpoint + bucket + key 访问。
- 按前缀列举对象,模拟目录结构。
代码或图示
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 角色/元数据。
- 超时、重试、签名版本可在客户端/会话级配置。
原理流程
- 读取配置:endpoint、区域、凭证(注入或环境变量)。
- 创建 S3 client 或 resource 接口。
- 复用客户端单例,业务调用 upload/download。
- 凭证轮换/权限最小化,定期审计访问密钥。
代码或图示
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 泄露风险与过期时长正相关。
原理流程
- 后端校验用户权限。
- 生成预签名 URL:方法、key、
ExpiresIn秒数。 - 客户端用 URL 直传/直下载对象。
- 过期后 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 清理,避免存储残留。
原理流程
- 创建 multipart upload,拿到 upload_id。
- 本地切片,并发上传各分片,记录 part number 与 ETag。
- 全部成功,complete 提交合并清单。
- 失败/取消: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 去重。
原理流程
- 平台配置回调地址与签名密钥。
- 对象事件触发,回调带签名头与事件体。
- 业务按算法重算签名比对,检查时间戳防重放。
- 校验通过按事件处理;失败返回错误,平台按策略重试。
代码或图示
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)按查询与更新频率权衡。
原理流程
- 按查询模式设计文档结构:高频一起读的数据嵌入。
- 频繁独立更新/多对多关系用引用。
- 控制单文档大小与数组长度,避免大数组无限增长。
- 复杂跨实体一致性评估事务能力与替代方案。
代码或图示
{
"_id": "u1",
"name": "ann",
"tags": ["vip"],
"addresses": [{ "city": "昆明" }]
}
常见误区
- 把关系库范式照搬 MongoDB:大量引用文档,查询需多次关联。
- 文档无限嵌套/大数组:查询与更新成本高,单文档超限。
- 强事务需求硬上 MongoDB:多文档事务能力有限,复杂一致性场景选关系库。
追问
- 单文档大小限制多少?答:BSON 文档上限 16MB(待确认:版本是否调整),大内容拆分引用。
- 数组里的子文档怎么查?答:数组字段可索引与查询,嵌套字段用点路径。
- MongoDB 支持 JOIN 吗?答:
$lookup聚合阶段可左连接,性能与灵活性不及关系库。
04.7.21.3-041 MongoDB 有哪些索引类型?复合索引怎么建?
一句话结论
索引类型:单字段、复合(多字段)、多键(数组)、文本、地理空间、唯一、稀疏/TTL。复合索引字段顺序遵循最左前缀:等值在前、排序/范围在后;唯一索引保证键不重复;TTL 索引自动过期删除文档。索引提升查询但增加写入与存储开销。
概念解释
- 复合索引顺序:查询条件与排序决定字段顺序,最左前缀匹配。
- 多键索引:数组字段自动展开建索引。
- TTL:按日期字段到期删除,适合会话/日志数据。
原理流程
- 分析查询条件、排序、聚合路径。
- 设计复合索引:等值字段在前,范围/排序在后。
- 创建唯一/多键/TTL 等专用索引。
- 用
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:扫描索引键后回取文档。
- 扫描行数远超返回行数说明索引选择性差或未命中。
原理流程
- 开启 profiling 或慢查询日志收集慢语句。
explain("executionStats")查看执行阶段。- 识别 COLLSCAN 与扫描行数,定位缺失/失效索引。
- 补复合索引或改写查询,复查计划。
代码或图示
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 窗口限制长事务。
原理流程
- 会话开启事务,执行多文档读写。
- 提交或中止;副本集多数派保证提交。
- 超出时限/约束,事务中止报错。
- 跨实体一致性需求评估事务覆盖范围,不足部分应用补偿。
代码或图示
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:查询路由层,对应用透明。
原理流程
- 按数据增长与访问模式选分片键。
- 数据按分片键哈希/范围分布到分片。
- mongos 按元数据路由查询到目标分片。
- 数据倾斜时 chunk 迁移再平衡。
代码或图示
app -> mongos -> shard A (user_id 1..k)
-> shard B (user_id k+1..n)
config servers: 分片元数据
常见误区
- 过早分片:副本集够用时增加运维复杂度。
- 分片键选低基数/热点值:数据集中到单分片,扩展失效。
- 跨分片查询无分片键:广播到全分片,开销大。
追问
- 分片键能改吗?答:集合分片后分片键不可直接改,需导出重建集合。
- 范围分片和哈希分片区别?答:范围分片利于范围查询但可能热点;哈希分片分布均匀,范围查询需跨分片。
- 分片副本还需要吗?答:每个分片内部仍是副本集,保证高可用。
04.7.21.3-045 最终一致性怎么实现?补偿手段有哪些?
一句话结论
最终一致性:分布式操作不要求实时一致,通过异步重试、补偿事务、对账修复在短时间内收敛一致。手段:可靠消息投递(outbox)、幂等消费、失败重试与死信、定时对账扫描差异、人工兜底处理异常单据。设计时明确一致性窗口与不一致可容忍度。
概念解释
- 强一致:同步等待所有节点确认;最终一致:异步收敛。
- 补偿:正向操作失败后执行逆向操作(退款、撤销、回滚记录)。
- 对账:周期比对各系统状态,差异自动修复或人工介入。
原理流程
- 本地事务写业务数据与待发消息(outbox)。
- 消息投递下游,消费者幂等处理。
- 失败重试/死信,异常单据进补偿流程。
- 定时对账扫描差异,自动补偿或告警人工处理。
代码或图示
本地事务: 业务表 + outbox 记录
→ 投递消息 → 幂等消费
→ 失败重试/死信 → 对账扫描 → 自动补偿/人工
常见误区
- 承诺实时一致却用异步链路:一致性预期错位。
- 只有重试无对账:长期隐藏的不一致无人发现。
- 补偿操作不幂等:重复补偿造成二次损害。
追问
- 一致性窗口怎么定?答:按业务容忍度,秒级/分钟级/日级,配合监控告警。
- 跨服务事务用什么模式?答:Saga(编排/协同)、TCC、outbox + 异步补偿,按场景选。
- 对账发现差异怎么修?答:先冻结异常单据,按权威数据源修复,记录处理轨迹。
04.7.21.3-046 outbox 本地消息表怎么设计?
一句话结论
outbox 模式:本地事务内同时写业务表与消息记录(outbox 表),事务提交后由后台任务/CDC 读取未发消息投递到 broker,投递成功标记状态。保证「业务落库」与「消息发出」一致,避免事务内直接发 MQ 导致的回滚脏消息。表字段含消息 ID、topic/队列、载荷、状态、重试次数、创建时间。
概念解释
- 本地事务原子性:业务数据与消息记录同一事务提交。
- 投递解耦:后台扫描 outbox 投递,失败重试,幂等更新状态。
- 可结合 CDC(binlog 订阅)替代轮询扫描。
原理流程
- 业务事务:写业务记录 + 插入 outbox 待发消息。
- 事务提交,消息状态为 pending。
- 投递任务扫描 pending 记录,发往 broker。
- 投递成功标记 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:消息记录随事务持久化,异步补偿投递。
原理流程
- 评估消息可靠性要求与崩溃恢复场景。
- 高可靠:业务表 + outbox 同事务,后台投递。
- 一般场景:提交后钩子直接
delay(),监控投递失败。 - 低风险采样/通知:可简化处理。
代码或图示
事务内发布: 回滚 -> 脏消息(不推荐)
提交后发布: 崩溃 -> 可能丢消息
outbox: 事务落记录 -> 异步投递 -> 可恢复
常见误区
- 把 outbox 当万能:增加表与投递任务,简单场景过度设计。
- 提交后投递不做失败重试:消息丢失无补偿。
- 事件载荷含未提交对象:应传 ID,提交后再加载。
追问
- outbox 和本地消息表是一回事吗?答:是同一模式的不同叫法,记录待投递事件。
- 事件顺序怎么保证?答:outbox 按创建顺序投递,同业务 key 串行下游消费。
- 多服务事件怎么广播?答:outbox 投递到 topic/交换器,各消费组订阅。
04.7.21.3-048 幂等消费去重表怎么落地?
一句话结论
去重表记录已处理业务事件:事件唯一键、处理状态、结果、时间;消费时先查记录,已处理直接确认跳过;处理成功后写入记录。表上加唯一索引防并发重复,状态区分处理中/成功/失败。关键业务落库去重,缓存只作加速层;去重记录按周期清理。
概念解释
- 唯一键:业务单号/事件 ID,不用消息 offset。
- 并发防护:处理中状态 + 唯一索引,双写冲突拦截。
- 与 outbox 配合:生产去重与消费去重两侧都可设。
原理流程
- 消费消息提取事件键。
- 查去重表:成功 → ack 跳过;处理中 → 等待/退出。
- 执行业务,成功后插入去重记录。
- 唯一索引拦截并发重复写入;失败记录状态便于重试。
代码或图示
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 重试、补偿和人工兜底怎么分层?
一句话结论
分层策略:瞬时故障自动重试(退避 + 次数上限);业务可逆错误走补偿事务(逆向操作);多次失败/不可逆异常进死信/异常表,告警人工介入。每层记录原因与轨迹,自动修复优先,人工兜底覆盖边缘场景;补偿操作本身必须幂等可重放。
概念解释
- 重试:同一正向操作重复执行,限瞬时故障。
- 补偿:执行逆向动作撤销前序影响(退款、解冻、撤销记录)。
- 人工:系统无法自动收敛的单据,人工核对后处理。
原理流程
- 失败分类:可重试/可补偿/需人工。
- 可重试:退避重投,超限转下一层。
- 可补偿:执行逆向操作,记录补偿轨迹。
- 无法自动处理:异常队列/表 + 告警,人工核对修复。
代码或图示
失败 -> 重试(退避, N次) -> 补偿事务(逆向) -> 死信/异常表 -> 人工
常见误区
- 所有失败都自动重试:fatal 错误反复执行,污染队列。
- 补偿操作不幂等:重复补偿造成二次损害。
- 人工兜底无流程:异常单据积压无人跟进。
追问
- 补偿和回滚一样吗?答:补偿是业务层逆向动作,不一定撤销数据库;回滚是事务层撤销。
- 人工处理后怎么闭环?答:记录处理人与结果,关闭异常单,回归对账。
- 重试次数怎么定?答:按下游 SLA 与故障类型,指数退避加抖动,总时长可控。
04.7.21.3-050 选型消息中间件看哪些指标?
一句话结论
选型维度:吞吐量与延迟、消息留存/回溯能力、路由模型、顺序性保证、重复与幂等支持、持久化与容错、运维复杂度与团队熟悉度、生态客户端、监控与社区活跃度。按主诉求排序:任务队列 vs 事件流 vs 轻量通知,不追求功能最全而求匹配场景。
概念解释
- 吞吐:分区/队列水平扩展能力。
- 留存:消息确认后删除还是按周期保留。
- 可靠:确认、持久化、副本、死信能力。
- 运维:部署、监控、升级、故障恢复成本。
原理流程
- 列出业务场景与非功能需求。
- 按维度对比 RabbitMQ/Kafka/Redis Stream 等。
- 预发压测关键指标:吞吐、延迟、积压恢复。
- 结合团队栈与运维能力定型。
代码或图示
任务/路由/死信 -> 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 间隔。
原理流程
- 配置拉取批次大小与等待时间。
- 拉取批次后逐条/分组处理。
- 按下游容量限流,超速等待或回压。
- 处理完提交 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 速率差决定积压方向。
- 队列健康:消费者在线、持久化配置、死信路由正常。
原理流程
- 通过管理 API/指标采集队列深度与消费者数。
- 计算生产-消费速率差,判断趋势。
- 阈值告警:深度超线、消费者离线、Unacked 堆积。
- 联动排查消费者与下游依赖。
代码或图示
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 冲突:字符串写入数值字段、数组类型不一致、对象结构冲突。
- 批量响应:逐条报告成功/失败,失败项可单独重试。
- 索引版本冲突:并发更新同一文档版本冲突。
原理流程
- 写入响应检查错误清单与失败原因。
- 类型不匹配:清洗数据或调整 mapping;不可改则新建索引迁移。
- 版本冲突:重读后重试更新。
- 失败消息入重试队列,超限落异常表告警。
代码或图示
{
"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、凭证按环境区分。
原理流程
- 开发环境启动 MinIO 容器,创建测试桶。
- 客户端配置指向本地 endpoint 与测试凭证。
- 业务上传/下载走同一套 S3 接口。
- 测试结束清理桶与数据;生产切换 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 流程。
原理流程
- 梳理表关系与查询/更新模式。
- 设计文档模型:嵌入/引用划分,控制文档大小。
- 双写迁移 + 对账校验数据一致。
- 评估不适合的数据保留关系库,混合存储。
代码或图示
关系表: users 1—N addresses
MongoDB: addresses 嵌入 users.addresses(读多写少)
或 addresses 引用 user_id(独立更新频繁)
常见误区
- 照搬三范式建集合:多次引用查询,性能差。
- 大表拆文档不评估大小:单文档超限,数组膨胀。
- 忽略事务差异:原关系流程在 MongoDB 无法等价保证。
追问
- 迁移后怎么对账?答:按主键比对数量、抽样字段值与聚合统计,差异修复。
- 双写期怎么切读?答:先双写,读流量灰度切到 MongoDB,稳定后停旧库写。
- 聚合报表适合 MongoDB 吗?答:复杂多表关联分析一般更适合关系库/数仓。
04.7.21.3-056 跨组件一致性链路怎么设计?
一句话结论
端到端一致性链路:入口写本地事务(业务 + outbox)→ 可靠消息投递 → 下游幂等消费 → 失败重试/死信 → 对账补偿。每段明确状态与责任人,关键单据可追溯;监控不一致迹象(重复、缺失、状态卡住),强一致核心链路评估是否应缩短为本地事务。
概念解释
- 状态贯通:业务状态、消息状态、消费状态可串联查询。
- 边界:跨服务只能最终一致,本地内强一致。
- 补偿闭环:自动修复 + 人工兜底。
原理流程
- 划定链路涉及的服务、存储、消息中间件。
- 每段定义成功/失败/重试/死信状态。
- outbox 保证投递,消费幂等防重复。
- 周期对账比对各段状态,差异触发补偿。
代码或图示
DB 事务 -> outbox -> MQ -> 服务B 幂等 -> 服务C
对账贯通: 业务单号串联各段记录
常见误区
- 链路无状态追踪:出问题无法定位卡在哪一段。
- 只设计正常路径:失败/重试/补偿分支缺失。
- 跨服务追求实时强一致:链路长、可用性差,应明确最终一致窗口。
追问
- 怎么串起全链路记录?答:业务单号/事件 ID 贯穿日志、outbox、消费记录与消息头。
- 不一致告警看什么?答:消息积压、死信增长、对账差异、状态长时间不流转。
- 核心资金链路怎么设计?答:缩短分布式跨度,关键扣减在本地事务,跨系统用对账 + 冻结/解冻补偿。
04.7.21.3-057 消息 schema 怎么演进保持兼容?
一句话结论
消息 schema 演进规则:新增字段给默认值、不删除已有字段、不改字段类型与语义;消费者兼容旧版本消息(缺字段用默认),生产者兼容新结构。版本号/字段说明纳入约定,废弃字段先标记再在下一版本移除;跨语言契约可用 schema 注册表或文档约束。
概念解释
- 向后兼容:新消费者能读旧消息。
- 向前兼容:旧消费者能读新消息(忽略未知字段)。
- 破坏性变更:改类型、删字段、改语义,需新 topic/版本迁移。
原理流程
- 定义消息字段约定与版本策略。
- 新增字段:可选 + 默认值,消费者缺失时兜底。
- 废弃字段:先保留只读,观察期后移除。
- 破坏性变更:新版本消息/主题,双版本过渡。
代码或图示
{
"event_id": "e1",
"order_id": "o1",
"channel": "web",
"schema_version": 2
}
常见误区
- 直接改字段类型:旧消费者反序列化失败。
- 消费者不忽略未知字段:新字段导致解析报错。
- 无版本约定:线上新旧消息混跑难以排查。
追问
- 消息体用什么序列化?答:JSON 通用;跨语言高性能可用 Protobuf/Avro,配合 schema 管理。
- 字段废弃流程?答:标记 deprecated → 停止生产写入 → 消费侧确认无依赖 → 移除。
- 破坏性变更怎么过渡?答:新 topic/事件名并行,旧消费者迁移后再下线旧版本。
04.7.21.3-058 积压期间怎么降级?哪些消息可以丢弃?
一句话结论
积压降级:低优事件限流/延后投递,消费者优先处理高优队列;可丢弃消息仅限可重新生成、无业务后果的采样/监控/埋点类;业务订单、通知、资金类不可丢弃,需扩容与补偿。降级决策记录依据,恢复后评估补跑范围,避免静默丢业务事件。
概念解释
- 降级层级:限流生产者、暂停低优消费、扩容消费者、临时扩容中间件。
- 丢弃前提:数据可由后续周期重新采集,丢失无业务影响。
- 不可丢弃:状态流转、对外通知、账务、库存变更。
原理流程
- 识别积压类型与消息优先级。
- 高优队列优先消费,低优事件延后/限流。
- 采样类消息按策略降级丢弃并记录。
- 恢复后检查业务消息是否补齐,必要时补偿重放。
代码或图示
高优: 订单/支付/通知 -> 保消费
低优: 报表/埋点/统计 -> 延后或限流
采样: 监控指标 -> 可丢弃, 记录降级
常见误区
- 积压时一刀切丢弃:业务事件丢失造成客诉与账务问题。
- 降级无记录:事后无法判断丢了哪些消息。
- 恢复后不补跑低优任务:周期数据缺口长期存在。
追问
- 怎么判断消息可否丢弃?答:是否影响业务状态、对外承诺、资金;可重新采集且无后果才降级。
- 限流在生产侧还是消费侧?答:两侧配合,生产侧控制投递速率,消费侧保护下游。
- 降级开关怎么管理?答:配置化开关,可一键恢复,记录触发与解除时间。
04.7.21.3-059 存储组件监控哪些要点?
一句话结论
消息中间件监控:深度/lag、消费者在线与并发、重试/死信率、投递与消费速率、broker 资源(CPU/内存/磁盘/网络)、积压恢复时间。搜索/对象/文档库监控:写入/查询延迟与拒绝率、索引大小与分片健康、对象存储请求量/错误率/容量、索引命中与扫描量。指标要关联业务 SLA,不只看组件存活。
概念解释
- 消息:可靠性与吞吐指标并重。
- 搜索:检索延迟、写入吞吐、集群健康(分片/副本/磁盘水位)。
- 对象存储:请求错误、容量、带宽、预签名签发量。
原理流程
- 梳理各组件关键指标与采集方式。
- 配置阈值告警:积压、错误率、资源水位。
- 关联业务指标:接口耗时、订单成功率。
- 定期复盘容量与趋势,提前扩容。
代码或图示
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 存灵活内容(按需)。
原理流程
- 梳理订单状态流转与下游依赖。
- 本地事务 + outbox 保证事件可靠发出。
- 按场景选 broker:任务通知 RabbitMQ,事件流 Kafka。
- 下游幂等消费,失败重试/死信,定时对账补偿。
- 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)