知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# Kafka 高频面试题集(55 题) > 导读:本题集用于把系列中的核心概念转化为可复述、可追问的回答。先掌握标记为 **必背** 的题,再沿关联阅读回到原理与代码;面试时应明确版本、业务语义和配置前提。 ## 结论先行 高质量 Kafka 回答应先给语义边界,再说明实现机制和生产取舍:顺序只在分区内、至少一次依赖幂等、Kafka 事务不覆盖外部副作用、调优必须以测量为准。 按主题分六章,共 55 道高频题,覆盖基础、生产者、消费者、存储、可靠性、运维高级话题。每题给完整答案 + 代码/配置示例 + 生产经验。 ## 目录 - [第 1 章 · 基础概念(8 题)](#第-1-章--基础概念) - [第 2 章 · 生产者(8 题)](#第-2-章--生产者) - [第 3 章 · 消费者(10 题)](#第-3-章--消费者) - [第 4 章 · 存储机制(10 题)](#第-4-章--存储机制) - [第 5 章 · 可靠性与顺序性(8 题)](#第-5-章--可靠性与顺序性) - [第 6 章 · 高级与运维(11 题)](#第-6-章--高级与运维) ## 面试高频 Top 10(优先刷) 1. Kafka 为什么这么快?(6) 2. 消费组、分区、消费者的关系?(5) 3. acks 三种取值的区别?(11) 4. 怎么保证消息不丢?(37) 5. 怎么保证消息不重复?(38) 6. 怎么保证消息顺序?(39) 7. Rebalance 是什么?怎么减少?(20) 8. 消息积压怎么处理?(23 + 41) 9. HW 和 LEO 是什么?(33) 10. ISR 机制?(32) --- # 第 1 章 · 基础概念 ## 1. Kafka 是什么?核心特点是啥? Kafka 是一个**分布式、高吞吐的发布订阅消息系统**,最早由 LinkedIn 开源,现在是 Apache 顶级项目。核心特点: - **高吞吐**:单机几十万 QPS,顺序写磁盘 + 零拷贝 - **持久化**:消息落盘,不丢不乱 - **水平扩展**:通过 Partition 分区实现横向扩展 - **高可用**:基于副本机制(Replica)做冗余 - **流式处理**:支持流批一体(Kafka Streams) 不是内存消息队列,消息会持久化,即便消费者掉线也能重放。 ## 2. Kafka 和 RabbitMQ、RocketMQ、Pulsar 有什么区别? | 对比维度 | Kafka | RabbitMQ | RocketMQ | Pulsar | |---------|-------|----------|----------|--------| | 定位 | 流式处理 / 日志收集 | 企业消息总线 | 业务消息 | 流+队列 | | 吞吐量 | 依赖分区、消息大小、确认策略、硬件和负载模型 | 依赖路由、持久化策略和硬件 | 依赖分区、存储与硬件 | 依赖存算组件与负载模型 | | 延迟 | 毫秒级 | 微秒级 | 毫秒级 | 毫秒级 | | 消息模型 | 分区 + 消费组 | Exchange + Queue | 分区 + 消费组 | 分区 + 订阅 | | 顺序性 | 分区内有序 | 队列内有序 | 分区内有序 | 分区内有序 | | 事务 | 支持(幂等+事务) | 支持 | 支持 | 支持 | | 存储模型 | 本地磁盘 + 副本 | 内存+磁盘 | 本地磁盘 | 存算分离(BookKeeper) | **选型口诀**:日志/大数据 → Kafka;业务解耦/消息优先 → RabbitMQ/RocketMQ;云原生 → Pulsar。 ## 3. Kafka 核心术语(Topic / Partition / Broker / Producer / Consumer / Group)  *图:三分区的副本分布与消费者分配* ``` Producer → [Topic] │ ├─ Partition 0 ─┬─ Leader(Broker A) │ └─ Follower(Broker B, C) ├─ Partition 1 ─┬─ Leader(Broker B) │ └─ Follower(Broker A, C) └─ Partition 2 ─┬─ Leader(Broker C) └─ Follower(Broker A, B) ↓ [Consumer Group G1] ├─ Consumer 1 (读 P0) ├─ Consumer 2 (读 P1) └─ Consumer 3 (读 P2) ``` - **Topic**:消息的逻辑分类,比如 `order`、`payment` - **Partition**:Topic 的物理分片,每个分区内部有序,分区间无序 - **Broker**:一个 Kafka 服务节点 - **Producer**:生产者,把消息发到 Topic - **Consumer**:消费者,从 Topic 读消息 - **Consumer Group**:消费组,**一个分区同一时刻只能被组内一个消费者消费** > 💬 **Q:Follower 只同步吗?读的能力也不提供吗?** > > **默认情况下 Follower 确实不提供读服务**,Producer 和 Consumer 都只和 Leader 交互。原因是保证强一致性——如果消费者读 Follower,可能读到还没同步完的旧数据。 > > **但 Kafka 2.4+ 支持 Follower 读(KIP-392)**: > > - Consumer 配置 `client.rack`,从**同机房/同可用区的 Follower** 读 > - Broker 配置 `replica.selector.class = org.apache.kafka.common.replica.RackAwareReplicaSelector` > - 好处:**减少跨机房网络流量**,降低延迟 > - 代价:可能读到**稍旧的数据**(Follower 还没同步到最新) > > **适用场景**:多机房部署、对实时性要求不极致的消费(日志分析、监控) > > **不适用**:对一致性要求高的场景(金融、支付)还是只读 Leader - **Offset**:消费位置,每个消费组独立维护 ## 4. 为什么要分区(Partition)? 三个核心理由: 1. **水平扩展**:数据量大了一台机器装不下,分到多台 Broker 2. **并行消费**:一个消费组内,多个消费者可以同时消费不同分区,提升吞吐 3. **提高可用**:每个分区都有多副本,坏一台不影响服务 **代价**:分区之间不保证顺序。如果业务需要严格顺序(比如同一个订单的所有事件),就让它们带同一个 key,Kafka 会用 `hash(key) % numPartitions` 保证它们落到同一分区。 ## 5. 消费组(Consumer Group)是什么?解决了什么问题? 消费组是 Kafka 实现**消息广播**和**负载均衡**的核心机制。 - 组内互斥,组间独立 - **同一消费组内**:一个分区只会被组内一个消费者消费(互斥) → 点对点模型(负载均衡) - **不同消费组之间**同一个分区可以同时被多个组的消费者消费(各自独立的 offset) → 发布订阅模型(广播) ``` Partition 0 的消息:[msg1, msg2, msg3, msg4, msg5] Group-A 的 Consumer-1 在读 P0(offset 到了 3) Group-B 的 Consumer-X 也在读 P0(offset 到了 5) Group-C 的 Consumer-Y 也在读 P0(offset 到了 1) 三个组互不影响,各自维护自己的消费进度。 ```  *图:Group-A 分摊分区,Group-B 独立消费* ``` Topic(3 个分区) ├─ Group-A(2 个消费者)→ 负载均衡:C1 读 P0,P1;C2 读 P2 └─ Group-B(1 个消费者)→ 独立读全部 P0,P1,P2(和 A 互不影响) ``` **关键点**: - 消费者数 > 分区数 时,多出的消费者空闲 - 消费者数 = 分区数 时,一对一最理想 - 消费者数 < 分区数 时,一个消费者读多个分区 ## 6. Kafka 为什么那么快? 四大法宝: 1. **顺序写磁盘**:比随机写快一个数量级,接近内存速度 2. **Page Cache**:读写都走操作系统页缓存,不进 JVM 堆,避免 GC 3. **零拷贝(sendfile)**:消费者读数据时,从 Page Cache 直接通过 DMA 发到网卡,**不经过用户态**,减少两次数据拷贝和两次上下文切换 4. **批量 + 压缩**:Producer 端批量发送(`batch.size`、`linger.ms`),服务端原样存储,消费者端原样读取,整个链路都是批量 ``` 传统读文件发网络: 磁盘 → 内核缓冲区 → 用户缓冲区 → Socket 缓冲区 → 网卡 (4 次拷贝,2 次上下文切换) Kafka 的 sendfile: 磁盘 → Page Cache → 网卡 (2 次拷贝,零次用户态参与) ``` ## 7. Kafka 消息模型是 Pull 还是 Push?为什么? **消费者主动 Pull**。不是 Broker 推送。 **为什么不用 Push**: - Push 由 Broker 决定推送速率,消费者慢的话会被压垮 - Pull 由消费者决定速率,可以按自己的处理能力拉取 - Pull 便于做批量拉取,吞吐更高 **Pull 的缺点**:没消息时会空轮询。Kafka 解决方式是 **long polling**(长轮询):拉取时如果没数据,Broker 会阻塞等待 `fetch.max.wait.ms`,直到有数据或超时。 ## 8. ZooKeeper 在 Kafka 里扮演什么角色?KRaft 又是啥? **ZooKeeper 时代(Kafka 2.x 及更早)**: - 存储 Broker 元数据(有哪些节点) - 存储 Topic/Partition 元数据 - Controller 选举 - 消费者 offset(早期版本,后来移到 `__consumer_offsets` topic) **KRaft(Kafka 3.0 开始,3.3+ 生产可用,4.0 完全移除 ZK)**: - Kafka 自己用 **Raft 协议**管理元数据 - 不再依赖 ZK,部署简化,元数据一致性更强 - 元数据操作更快(百万分区可控) 如果是新系统,直接用 KRaft 模式;老系统 Kafka 3.x 开始逐步迁移。 --- # 第 2 章 · 生产者 ## 9. Producer 发送消息的完整流程? ``` send(record) ↓ 1. 序列化(key/value serializer) ↓ 2. 分区器(Partitioner)决定发到哪个分区 ↓ 3. 进入 RecordAccumulator(内存缓冲区) ↓ 4. Sender 线程批量取出,封装成 ProducerRequest ↓ 5. 通过 NetworkClient 发到对应 Broker ↓ 6. Broker 写入 Leader Partition 的日志 ↓ 7. 根据 acks 策略等待 follower 同步 ↓ 8. 返回响应,回调 onCompletion ``` **关键参数**: - `batch.size`:单个分区的批次大小(默认 16KB) - `linger.ms`:批次等待时间(默认 0 即立即发送,生产建议 5-20ms) - `buffer.memory`:内存缓冲区总大小(默认 32MB) - `compression.type`:压缩算法(snappy / lz4 / zstd / gzip) ## 10. 消息怎么分配到分区?Partitioner 策略有哪些? 三种策略(按优先级): 1. **指定了 partition**:直接发到该分区 2. **没指定 partition,有 key**:`hash(key) % numPartitions`,同 key 同分区 3. **没指定 partition,没 key**: - Kafka 2.4 之前:Round Robin - Kafka 2.4 之后:**Sticky Partitioner**(粘性分区器),一段时间内只发同一个分区,填满一个 batch 再换分区,减少请求数,提升吞吐 **自定义 Partitioner**:实现 `Partitioner` 接口,配置 `partitioner.class`。 **业务要顺序**:让相关消息带同一个 key(比如 userId、orderId)。 ## 11. acks 参数是什么?三种取值的区别? `acks` 控制 Producer 等待 Broker 确认的严格程度: | acks | 语义 | 可靠性 | 性能 | 场景 | |------|------|--------|------|------| | `0` | 不等确认,发出去就算成功 | 最差,可能丢 | 最高 | 日志采集、指标 | | `1`(默认) | 等 Leader 写成功 | 一般,Leader 挂+未同步会丢 | 中等 | 一般业务 | | `-1`(或 `all`) | 等 ISR 所有副本写成功 | 最强 | 最低 | 金融、支付 | **注意**:`acks=all` 要配合 `min.insync.replicas >= 2` 才真正强一致。只有 1 个 ISR 时,`all` 等同于 `1`。 ## 12. 生产者怎么保证消息不丢? 三个层面一起做: **Producer 层**: - `acks = all` - `retries = Integer.MAX_VALUE`(或足够大) - `retry.backoff.ms`:重试间隔 - `max.in.flight.requests.per.connection <= 5`(配合幂等保证顺序) - `enable.idempotence = true`(幂等) **Broker 层**: - `replication.factor >= 3`(副本数) - `min.insync.replicas >= 2`(最少同步副本数) - `unclean.leader.election.enable = false`(禁止非 ISR 节点当 Leader) **Producer 代码层**: - 用 `send(record, callback)` 带回调,异常时记录/重发 - 或者用 `send().get()` 同步等待(吞吐低,可靠性高) ## 13. 幂等生产者(Idempotent Producer)是什么? `enable.idempotence = true` 开启。解决的是**单分区、单会话**内的重复发送问题。 **原理**:每个 Producer 实例被分配一个 PID,每条消息带一个单调递增的 Sequence Number,Broker 用 `(PID, Partition, SeqNum)` 去重。 ``` Producer 发送 seq=5 Broker 收到后写入成功,但返回 ack 时网络抖动 Producer 超时重发 seq=5 Broker 发现 seq=5 已写入,丢弃并返回成功 ``` **限制**: - **只保证单分区幂等**:跨分区要用事务 - **只保证单会话幂等**:Producer 重启后 PID 变了,之前的记录作废 - 跨会话跨分区的 exactly-once → 用事务(见下一题) ## 14. Kafka 事务是什么?怎么用? Kafka 事务(0.11 开始)实现**跨分区的原子写入**和**读写事务**。 **使用场景**: 1. 一次发送写多个分区,要么全成功要么全失败 2. **消费-处理-生产**的 exactly-once 模式(Kafka Streams 核心) **代码示例**: ```java producer.initTransactions(); // 初始化事务 try { producer.beginTransaction(); producer.send(new ProducerRecord<>("topic-a", "msg1")); producer.send(new ProducerRecord<>("topic-b", "msg2")); // 消费者位移也可以放进事务 producer.sendOffsetsToTransaction(offsets, "group-id"); producer.commitTransaction(); // 全部提交 } catch (Exception e) { producer.abortTransaction(); // 全部回滚 } ``` **关键配置**: - `transactional.id`:**必须设置**且全局唯一,重启后恢复事务状态 - `enable.idempotence = true`(事务依赖幂等) - 消费侧 `isolation.level = read_committed` 才能只读到已提交的消息 **代价**:事务会增加协调、标记与提交开销,具体影响必须用目标版本和负载压测验证。日志采集类场景通常不需要该原子性,应先评估是否值得。 ## 15. 发送超大消息怎么办? Kafka 默认单条消息上限 1MB。推荐做法: 1. **尽量不要发大消息**:消息只带引用(比如 S3/OSS 地址),大数据放对象存储 2. **非改不可时**,多处同步改配置: - Producer:`max.request.size` - Broker:`message.max.bytes`(每个 Topic 也可覆盖) - Consumer:`fetch.max.bytes`、`max.partition.fetch.bytes` 3. **开启压缩**(`compression.type=zstd`),大消息压缩收益大 4. **注意**:大消息会占 Page Cache,降低整体吞吐,评估好 ## 16. Producer 发送失败怎么处理? 分两种失败: **可重试异常**(NetworkException、NotLeaderForPartitionException 等): - 配置 `retries`,Kafka 会自动重试 - `retry.backoff.ms` 控制间隔 - 配合幂等避免重试导致重复 **不可重试异常**(RecordTooLargeException、SerializationException、InvalidTopicException): - 在 callback 里捕获,记录日志 + 发到死信 topic / 告警 - 这类异常重试也没用,靠代码修 **兜底**:业务侧加**本地消息表**,发送失败写表,异步重发。真正的可靠性保障在业务代码。 --- # 第 3 章 · 消费者 ## 17. 消费者怎么拉消息?poll 流程? ``` while (true) { ConsumerRecords<K, V> records = consumer.poll(Duration.ofMillis(100)); for (ConsumerRecord<K, V> r : records) { process(r); // 业务处理 } consumer.commitSync(); // 提交位移 } ``` 一次 `poll` 的内部流程: 1. 如果订阅关系/分配变化,触发 **Rebalance** 2. 从本地缓存拉消息,没有就向 Broker 发 FetchRequest 3. Broker 返回数据(可能从多个分区批量拿) 4. 反序列化 + 根据 `max.poll.records` 限流 5. 更新 offset 元数据(尚未提交) **关键参数**: - `max.poll.records`:单次 poll 最多条数(默认 500) - `max.poll.interval.ms`:两次 poll 最大间隔(默认 5 分钟),超时认为消费者挂了 - `fetch.min.bytes`:至少拉这么多才返回(默认 1 字节) - `fetch.max.wait.ms`:不够时最多等多久(默认 500ms) ## 18. 位移(Offset)提交方式有哪些?区别? 三种提交方式: | 方式 | API | 特点 | |------|-----|------| | **自动提交** | `enable.auto.commit=true` | 后台定时提交,简单但**可能重复消费或丢消息** | | **手动同步** | `commitSync()` | 阻塞等待提交成功,失败会重试,可靠 | | **手动异步** | `commitAsync()` | 不阻塞,失败不自动重试(可加 callback) | **最佳实践**:正常处理用 `commitAsync()` 提升吞吐,关闭消费者或异常退出时用 `commitSync()` 做兜底。 ```java try { while (true) { ConsumerRecords<K,V> records = consumer.poll(...); process(records); consumer.commitAsync(); // 正常路径异步 } } finally { consumer.commitSync(); // 兜底同步 consumer.close(); } ``` ## 19. 自动提交有什么坑? **坑 1:消息丢失** `auto.commit.interval.ms` 默认 5 秒自动提交一次。假设: ``` 拉到 100 条消息 处理到第 30 条时,5 秒触发自动提交(提交了 100 的位移) 第 31 条处理时崩溃 重启后从 101 开始,31-100 丢了 ``` **坑 2:重复消费** ``` 拉到 100 条消息,处理完 80 条 还没到自动提交时间,消费者崩溃 重启后还是从 0 开始,0-80 重复消费 ``` **结论**:对可靠性有要求的场景,关闭自动提交,手动提交。 ## 20. Rebalance 是什么?什么时候触发? Rebalance 是消费组内**重新分配分区**的过程。触发场景: 1. **组成员变化**:新消费者加入 / 老消费者离开(含宕机、kill) 2. **订阅主题变化**:`subscribe()` 变了 3. **主题分区数变化**:分区扩容 **Rebalance 的问题**: - **STW(Stop The World)**:整个消费组都停止消费 - **消费中断**:业务延迟毛刺 - **重复消费**:未提交的位移会导致部分消息被重新消费 **减少 Rebalance**: - `session.timeout.ms`:心跳超时(默认 10s) - `heartbeat.interval.ms`:心跳间隔(默认 3s,建议 = session/3) - `max.poll.interval.ms`:单次处理最大耗时,超过认为挂了 - **Static Membership**(2.3+):给 consumer 设 `group.instance.id`,短暂掉线不触发 rebalance - **Cooperative Rebalance**(2.4+):增量式,只影响变化的分区 ## 21. 分区分配策略有哪些? 三种内置策略(`partition.assignment.strategy`): **1. Range(默认)**:按主题范围分 ``` Topic A(7 个分区),Topic B(7 个分区),3 个消费者 Consumer 1: A0-A2, B0-B2 Consumer 2: A3-A4, B3-B4 Consumer 3: A5-A6, B5-B6 ``` 缺点:分区数不是消费者数的倍数时分配不均,靠前的消费者拿得多。 **2. RoundRobin**:轮询所有 Topic 的分区 ``` 所有分区按 hash 排序后轮流分 ``` 分配均匀,但要求所有消费者订阅相同主题。 **3. Sticky(黏性)**:尽量保留上次分配结果 Rebalance 时,尽量把原来的分区继续给原来的消费者,减少状态迁移开销。推荐使用。 **4. CooperativeSticky**:Sticky + 增量 rebalance,最推荐。 ## 22. 消费者怎么保证消息不丢?不重复? **不丢**: - 手动提交位移,**先处理消息再提交** - 业务处理要幂等或有重试补偿 - `auto.offset.reset` 慎用 `latest`,新消费者会跳过历史消息 **不重复(exactly-once)**: - 单纯消费场景:下游业务接口做**幂等**(最常见也最有效) - Kafka 内部场景:用 Kafka 事务(`isolation.level=read_committed`) **幂等实现**: - 数据库唯一索引 - Redis `SET NX` - 业务状态机判断 - 消息 ID + 处理记录表 ## 23. 消息堆积(Lag)怎么排查和解决? **排查命令**: ```bash kafka-consumer-groups.sh --bootstrap-server xxx --describe --group G1 # 输出 LAG 列就是堆积数量 ``` **常见原因**: 1. **消费者性能不够**:扩消费者(<= 分区数才有用) 2. **下游慢**(比如写 DB 慢):优化下游、加缓存、异步化 3. **消费者有 bug**:CPU 飙高、GC、死锁 4. **Rebalance 频繁**:消费都在 rebalance 而不是干活 5. **流量激增**:生产侧限流、临时扩容 **临时应急**: - 加消费者(前提是分区够) - 临时加分区(注意:分区数只能增不能减,且不影响已有 key 的分布) - 丢弃历史堆积(`kafka-consumer-groups --reset-offsets --to-latest`),业务能接受的话 - 多写一个临时 topic 分流 **预防**:监控 Lag,设置阈值告警。 ## 24. 消费者线程模型怎么设计? **方案 1:一个消费者一个线程(最简单)** ```java for (int i = 0; i < threadCount; i++) { new Thread(() -> { KafkaConsumer<> consumer = ...; consumer.subscribe(topics); while (true) { poll -> process -> commit } }).start(); } ``` 优点:简单、天然限流到分区级并行。 缺点:线程数 <= 分区数,单分区处理速度上限在单线程。 **方案 2:消费者拉取 + 业务线程池处理** ```java while (true) { records = consumer.poll(...); for (record : records) { executor.submit(() -> process(record)); } // 注意:这里直接 commit 会丢消息! } ``` 优点:单分区也能并发处理。 缺点:**位移提交难做**,业务处理未完成就 commit 会丢消息。需要用 `Map<TopicPartition, OffsetAndMetadata>` 跟踪,等全部处理完再按分区提交最大连续 offset。 **生产建议**:对顺序敏感的选方案 1;对吞吐敏感的选方案 2,但位移管理务必做对。 ## 25. 一个消费组里消费者数量比分区数多会怎样? **多出来的消费者会空闲**。 ``` Topic 有 3 个分区,消费组有 5 个消费者 → 3 个消费者各读 1 个分区,2 个消费者完全空闲 ``` 所以消费者数量**至少不要超过分区数**,浪费资源。 **正确姿势**: - 根据峰值 QPS 和单消费者处理能力,**先规划分区数**(通常几倍于消费者数,留扩容空间) - 分区数是一次性决策,只能增不能减 ## 26. 消费者重启后从哪里开始消费? 取决于**是否有历史位移**和 `auto.offset.reset` 配置: | 情况 | 行为 | |------|------| | 有已提交位移 | 从上次提交处继续 | | 没有位移 + `auto.offset.reset=earliest` | 从最早消息开始(可能几十亿条) | | 没有位移 + `auto.offset.reset=latest`(默认) | 从最新开始(历史消息跳过) | | 没有位移 + `auto.offset.reset=none` | 抛异常 | **常见坑**: - 新消费组首次启动时默认 `latest`,业务方经常误以为会读历史消息 - 生产上排查消息丢失时,先看消费组位移记录 --- # 第 4 章 · 存储机制 ## 27. Kafka 消息怎么存储在磁盘上? 每个分区对应一个独立的目录,目录里按 Segment 分段:  *图:分区目录 topic-order-0 的文件构成* ``` topic-order-0/ ← 分区目录 ├── 00000000000000000000.log ← 数据 ├── 00000000000000000000.index ← offset 索引 ├── 00000000000000000000.timeindex ← 时间戳索引 ├── 00000000000000100000.log ← 下一段 ├── 00000000000000100000.index └── ... ``` **分段(Segment)的原因**: - 单文件过大不好管理 - 清理(删除/压缩)以 Segment 为单位,方便 - 查找可以定位到 Segment 后再查索引 **切分时机**: - `log.segment.bytes`:段文件大小上限(默认 1GB) - `log.roll.ms/hours`:段文件最大存活时间(默认 7 天) ## 28. Kafka 的索引是怎么设计的? **两种索引**: **1. 偏移量索引(.index)**:稀疏索引 ``` 00000000000000000000.index: offset: 100, position: 4096 offset: 200, position: 8192 offset: 300, position: 12288 ... ``` - 不是每条消息都建索引,隔 `log.index.interval.bytes`(默认 4KB)记一条 - 查找 offset=250 时: 1. 二分找到 200 对应的 position=8192 2. 从 position=8192 开始顺序扫 .log 文件,直到找到 offset=250 **2. 时间戳索引(.timeindex)**:`(timestamp, offset)` - 支持按时间戳查找消息(比如从昨天 3 点的消息开始消费) - 也是稀疏索引 **为什么用稀疏索引**:节省空间。Kafka 假设顺序扫描很快,不需要精确定位到每条消息。 ## 29. Kafka 日志清理策略有哪些? 两种策略(`log.cleanup.policy`): **1. delete(默认)**:按时间/大小删除 - `log.retention.hours`:保留时长(默认 168 小时/7 天) - `log.retention.bytes`:保留总大小(默认 -1 不限制) - `log.retention.check.interval.ms`:检查间隔 **2. compact**:日志压缩,保留每个 key 的最新 value ``` 原始日志: k1=v1, k2=v2, k1=v3, k3=v4, k1=v5 压缩后: k2=v2, k3=v4, k1=v5 ``` 用于**存储状态而非事件**的场景,比如 `__consumer_offsets` topic、Kafka Streams 的 changelog。 **混合模式**:`log.cleanup.policy = compact,delete`,先压缩再按规则删。 ## 30. Kafka 是怎么实现零拷贝的? **传统方式读文件发网络**(4 次拷贝 + 2 次上下文切换): ``` read(fd, buf, len) → 磁盘 DMA 到内核 Page Cache → 再从 Page Cache 拷到用户态 buffer(拷贝 1) send(socket, buf) → 从用户 buffer 拷回内核 Socket buffer(拷贝 2) → Socket buffer DMA 到网卡 ``` **Kafka 用 sendfile**(底层 Linux `sendfile()` 系统调用): ``` 磁盘 DMA → Page Cache → 网卡 DMA ``` 只有 2 次 DMA 拷贝,**零次 CPU 拷贝**,不经过用户态。 **代码层面**:`FileChannel.transferTo()`。Consumer 读消息时 Broker 直接用这个 API 把 Page Cache 里的数据塞进 Socket。 **限制**: - SSL/TLS 加密时零拷贝失效(需要在用户态加密) - 压缩需要读到用户态处理时也会失效(Producer 端就压好的话,Broker 可以原样传) ## 31. 为什么 Kafka 要用 Page Cache 而不是堆内存? 四个理由: 1. **避免 GC**:大量数据放 JVM 堆会频繁 Full GC,Page Cache 由 OS 管理 2. **重启不丢**:JVM 重启缓存没了,Page Cache 由 OS 管理,进程重启不受影响 3. **零拷贝**:Page Cache 是内核空间,直接 sendfile 发出去 4. **复用读路径**:Producer 刚写入的数据还在 Page Cache 里,Consumer 读取时直接命中,基本不落盘 **调优建议**: - 不要给 Broker JVM 分配太多堆(6-8GB 通常够),剩下内存留给 Page Cache - Kafka Broker 一般不需要用 SSD,HDD 顺序写已经很快 ## 32. 副本机制 Replica 是怎么工作的? **基本概念**: - 每个分区有多个副本,一个 Leader + 若干 Follower - Producer 和 Consumer 只和 Leader 交互 - Follower 定期从 Leader 拉消息(pull 模式) **副本状态**: - **AR(Assigned Replicas)**:分区分配的所有副本 - **ISR(In-Sync Replicas)**:与 Leader 保持同步的副本(包含 Leader 自己) - **OSR(Out-of-Sync Replicas)**:落后太多被踢出 ISR 的副本 - `AR = ISR + OSR` **何时踢出 ISR**: - Follower 落后时间超过 `replica.lag.time.max.ms`(默认 30 秒) - 老版本还有 `replica.lag.max.messages`(条数差),新版移除避免误判 **何时加回 ISR**:Follower 追上 Leader 的 HW(High Watermark)。 ## 33. HW 和 LEO 是什么? - **LEO(Log End Offset)**:日志末尾的下一个位置,即"下一条消息要写入的位置" - **HW(High Watermark)**:**所有 ISR 副本都已同步的最高位置**,消费者**只能读到 HW 之前的消息** ``` Leader: [0][1][2][3][4][5] LEO = 6 Follower1: [0][1][2][3][4] LEO = 5 Follower2: [0][1][2][3] LEO = 4 HW = min(LEO) = 4 消费者最多读到 offset 3 ``` **HW 的作用**:保证消费者不会读到"还没被所有 ISR 同步"的消息,避免 Leader 切换后出现"消息丢失"的错觉。 **问题**:老版本 HW 机制有边界 bug,0.11 引入 **Leader Epoch** 解决(见下一题)。 ## 34. Leader Epoch 是什么?解决了什么问题? **问题背景**(老版 HW 的缺陷): ``` 场景:Leader A 刚写入 offset=10,HW=5,还没来得及把 HW 更新到 Follower B → B 此时宕机重启,会根据自己的 HW=5 截断到 offset=5 → 此时 A 也挂了,B 成为新 Leader → A 重启后作为 Follower,根据 B 的 HW 把自己的数据也截断到 5 → offset 6-10 的数据丢了! ``` **Leader Epoch 机制**(0.11+): - 每次 Leader 选举产生一个单调递增的 `epoch` - 存储 `(epoch, start_offset)` 映射 - Follower 截断日志时,不再看 HW,而是向 Leader 查询对应 epoch 的起始 offset 这样即使 HW 没及时同步,也能通过 epoch 精确对齐,避免数据丢失。 ## 35. unclean.leader.election 是什么?要开吗? **场景**:ISR 里所有副本都挂了,只剩 OSR(落后较多的副本)。要不要让 OSR 当 Leader? - `unclean.leader.election.enable = false`(默认,推荐):不让 OSR 当 Leader,等 ISR 恢复。**代价**:分区不可用 - `unclean.leader.election.enable = true`:让 OSR 当 Leader。**代价**:丢失部分未同步消息 **结论**:对一致性有要求就关;对可用性有要求就开。大部分业务选**关**,配合 `min.insync.replicas=2` 和 `replication.factor=3` 足以保证高可用。 ## 36. replication.factor 和 min.insync.replicas 怎么设? **经验值**: ``` replication.factor = 3 min.insync.replicas = 2 acks = all ``` **含义**: - 总共 3 副本 - Producer 写入时至少 2 个 ISR 写成功才返回 - 挂 1 台不影响,挂 2 台拒绝写入(但不丢数据) **不能设 `min.insync.replicas = replication.factor`**:否则挂 1 个副本就无法写入,失去副本的意义。 --- # 第 5 章 · 可靠性与顺序性 ## 37. 消息在 Kafka 全链路可能丢在哪?怎么避免? **三处可能丢**: **1. Producer 丢**: - 异步 send 没加 callback,发送失败无感知,应该加上callback,以便发送失败的时候进行重试,记录日志等操作 - acks=0时,Producer 不等任何确认,发出去就算成功。网络丢包、Broker 宕机都会丢。acks=1:只等 Leader 确认写入。Leader 写入后、Follower 同步前 Leader 挂了 → 数据丢失。acks=all(-1):等所有 ISR 副本确认。只要 ISR 中有一个副本活着,数据就不丢。 - - **解决**:`acks=all`、`retries` 充足、`enable.idempotence=true`、callback 处理失败 **2. Broker 丢**: > 场景 A: 副本不足:假设只有一个副本(replication.factor=1),机器磁盘坏了 → 数据永久丢失 > 场景 B:Unclean Leader Election > ``` > ISR = {Broker0(Leader), Broker1, Broker2} > Broker1 和 Broker2 落后 Leader 1000 条消息后被踢出 ISR > 此时 ISR = {Broker0} > Broker0 宕机 → 如果允许 unclean election,Broker1 当选新 Leader > → 那 1000 条消息永久丢失 > ``` > > 场景 C:Page Cache 未刷盘 > ``` > Kafka 写消息默认只写入 OS Page Cache(内存),由 OS 异步刷盘 > 如果机器突然断电,Page Cache 中未刷盘的数据丢失 > 但只要有其他副本已同步,数据不会真正丢失 > → 所以 Kafka 靠多副本保证持久性,而不是靠单机刷盘 > ``` **3. Consumer 丢**: > 场景 A:自动提交 + 处理失败 > 自动提交:poll 后 5 秒自动提交 offset。如果消息处理到一半程序崩溃,offset 已经提交了,消息不会被重新消费 > > 场景 B:先提交后处理 > 先提交再处理:提交成功后处理失败 → 消息丢失。正确做法时先处理后提交,处理成功后才提交。 > > **注意:先处理后提交会导致"至少一次"语义(可能重复消费)** > ``` > 处理成功 → 提交前程序崩溃 → 重启后从上次提交的 offset 重新消费 → 重复处理 > 解决重复:消费端做幂等(数据库唯一键、Redis 去重、业务状态机) > ``` ## 38. 怎么保证消息不重复消费? **两个层面**: **1. 生产端不重复**:开启幂等 `enable.idempotence=true`(单分区单会话)+ 事务(跨分区、跨会话) **2. 消费端幂等**(最实用,99% 场景用这个): - **业务层幂等**: - 数据库唯一索引(订单号、消息 ID) - Redis `SETNX` - 状态机判断(`if (status == 已处理) return;`) - 处理记录表(msg_id + 处理状态) - **通用模板**: ```java public void handle(Message msg) { if (!redis.setNX("msg:" + msg.getId(), "1", 24, HOURS)) { return; // 已处理过 } try { doBusiness(msg); } catch (Exception e) { redis.del("msg:" + msg.getId()); // 失败回滚,允许重试 throw e; } } ``` **记住**:MQ 层面的 exactly-once 实现复杂且有性能开销,**业务幂等是更普适的方案**。 ## 39. 怎么保证消息顺序消费? **全局顺序**(Topic 内所有消息严格有序): - 一个 Topic 只用 1 个分区 + 1 个消费者 - 吞吐极低,一般不用 **局部顺序**(相关消息有序,比如同一订单): - 让相关消息带**相同的 key**,hash 到同一分区 - 分区内天然有序 - 消费时**单线程**或用 key 做线程路由 **陷阱 1:Producer 重试乱序** ``` Producer 发送 msg1 → 失败重试 Producer 发送 msg2 → 成功 Producer 重试 msg1 → 成功 最终顺序:msg2, msg1 ❌ ``` 解决:开启幂等,并保证 `max.in.flight.requests.per.connection <= 5`。幂等会根据 seq 重排,保证单分区顺序。 **陷阱 2:消费者多线程乱序** ``` Consumer 拉到 [msg1, msg2, msg3] 扔线程池 → 三个线程并发处理,顺序乱 ``` 解决:按 key 路由到同一线程(`threadId = hash(key) % threadCount`)。 ## 40. Kafka 能实现 exactly-once 吗? **可以,但有前提**: **1. Producer 端**:`enable.idempotence=true` 保证单分区单会话不重复 **2. Producer 跨分区**:用 Kafka 事务,原子写多个分区 **3. Consumer-Producer 闭环**(Kafka Streams 场景): ```java producer.initTransactions(); while (true) { records = consumer.poll(...); producer.beginTransaction(); for (r : records) { producer.send(process(r)); // 处理后写回 Kafka } // 把消费位移也提交到事务里 producer.sendOffsetsToTransaction(offsets, groupId); producer.commitTransaction(); } ``` 加 `isolation.level=read_committed`,下游消费者只读到已提交事务。 **4. Consumer 写外部系统(最常见场景)**: Kafka 事务**管不到外部系统**(MySQL、Redis 等)。必须靠**业务幂等**兜底,否则做不到真正的 exactly-once。 **结论**:Kafka 内部可以做到 exactly-once;涉及外部系统时,**幂等是唯一可靠的方案**。 ## 41. 消息积压怎么快速消费? **前提**:分区数和消费者数的关系决定了上限。 **方案 1:扩消费者(前提分区够)** 加机器、加线程。如果分区不够,先扩分区。 **方案 2:临时双写分发** ``` 原 Topic(大量积压,处理慢) ↓ 临时消费者 A 只做转发 ↓ 分发到 N 个新 Topic(每个分区多) ↓ N 个消费组并发处理 ``` 老数据处理完后删除临时 topic。 **方案 3:直接跳过** `kafka-consumer-groups --reset-offsets --to-latest`,业务能接受丢弃历史消息时用。 **方案 4:降级处理** 消费逻辑里跳过耗时操作(比如暂时不调外部接口),先消化积压再补处理。 **预防**: - 监控 lag 阈值告警 - 预留容量(消费者 CPU/内存/分区数都留冗余) - 单条消息处理不要超过 100ms,长耗时任务异步化 ## 42. 单个分区写入速率瓶颈怎么办? **单分区瓶颈**应通过目标消息大小、压缩、确认策略、磁盘和网络压测确认;常见优化方向: **1. 生产侧**: - 增大 `batch.size`、`linger.ms` - 开启压缩(zstd / lz4) - Producer 实例增多(多个 Producer 并发写同一分区) **2. Broker 侧**: - 升级硬件(磁盘、网络、CPU) - 调大 `num.network.threads`、`num.io.threads` - 关闭无用的 compression 或 SSL **3. 架构侧(根本方案)**: - **增加分区数**:让写入分散到多分区、多 Broker - 注意分区数不能乱加:加分区后 `hash(key) % N` 的分布变了,老 key 的顺序性会打乱 **结论**:单分区能力没有可脱离环境复用的 TPS 数字。先用生产近似负载测量,再判断瓶颈在客户端批处理、Broker、网络、磁盘还是业务处理端。 ## 43. Kafka 如何实现延迟消息? **原生不支持**。几种实现方式: **方案 1:多级延迟 Topic** ``` delay-5s、delay-30s、delay-1m、delay-5m、delay-10m、delay-30m、delay-1h ... ``` 消息按延迟精度发到对应 topic,消费者拉到后判断是否到期,没到就 sleep。 **方案 2:时间轮 + 外部存储** 延迟消息先写 MySQL/Redis,定时扫描到期消息转发到 Kafka。 **方案 3:用 RocketMQ / RabbitMQ** 这两个天然支持延迟消息,如果强需求,换中间件。 **方案 4:Kafka Streams 窗口** 复杂但灵活。 **建议**:延迟消息是 Kafka 的短板,生产上如果强依赖延迟能力,考虑 RocketMQ。 ## 44. 如何设计一个高可用 Kafka 集群? **硬件层**: - Broker 至少 3 台,跨机房/可用区部署 - 磁盘用 SSD 或高性能 HDD,RAID 10 或多盘 JBOD(Kafka 自己会分摊) - 网络 10GbE **配置层**: - `replication.factor = 3` - `min.insync.replicas = 2` - `unclean.leader.election.enable = false` - `default.replication.factor = 3`、`offsets.topic.replication.factor = 3` **部署层**: - 用 **Rack Awareness**(机架感知),副本分布在不同机架 - 用 KRaft 模式(3.x+)避免 ZK 单点 **监控层**: - JMX 指标:`UnderReplicatedPartitions`、`OfflinePartitionsCount`、`RequestHandlerAvgIdlePercent` - Lag 监控 - Broker 机器 CPU/Disk I/O/Network **容灾**: - 跨机房复制用 **MirrorMaker 2.0** 或 **Confluent Replicator** - 做好恢复演练 **日常**: - 滚动重启验证 - 定期做故障演练(kill Broker、kill 网络) --- # 第 6 章 · 高级与运维 ## 45. Controller 是什么?怎么选举的? **Controller** 是 Kafka 集群的**大脑**,整个集群只有一个 Controller,负责: - 监听 Broker 上下线 - 分区 Leader 选举 - 分区副本重分配 - Topic 创建/删除 - ISR 变化通知其他 Broker **ZK 模式下选举**: - 所有 Broker 启动时去 ZK 的 `/controller` 路径创建临时节点 - 创建成功的那个就是 Controller - Controller 挂了,临时节点消失,其他 Broker 抢占 **KRaft 模式下**: - 用 Raft 协议选举 Controller,更快更稳 - Controller 可以是多个(Quorum),不再单点 ## 46. 分区 Leader 怎么选举? **前置条件**:只有 **ISR 里的副本**才有资格成为 Leader(除非开 unclean election)。 **选举过程**(ZK 模式): 1. Leader 挂了,Controller 检测到(通过 ZK Watcher) 2. Controller 从该分区的 ISR 列表里选第一个活着的副本作为新 Leader 3. 更新 ZK 和元数据缓存 4. 通知所有相关 Broker **优先副本(Preferred Replica)**: - 分区创建时指定的副本顺序中的第一个 - 正常情况下这个副本是 Leader - 故障切换后可能导致 Leader 分布不均,可以用 `kafka-preferred-replica-election.sh` 手动触发回切 - `auto.leader.rebalance.enable=true` 会定期自动平衡(默认开) ## 47. ISR 动态调整的逻辑? **加入 ISR**: - Follower 追上 Leader 的 LEO(或者说 Follower 的 LEO >= HW) - Controller 更新元数据 **踢出 ISR**: - Follower 超过 `replica.lag.time.max.ms`(默认 30s)没拉取消息 / 没追上 - 旧版本还看 `replica.lag.max.messages`(条数差),后来移除(避免突发流量时误判) **监控要点**: - `UnderReplicatedPartitions > 0`:有副本同步落后,要警觉 - `ISR shrinks/expands per sec`:频繁抖动说明 Broker 不稳定 ## 48. 生产环境怎么做 Kafka 监控? **核心指标**: | 类别 | 指标 | 说明 | |------|------|------| | **集群** | `UnderReplicatedPartitions` | > 0 说明有副本落后 | | | `OfflinePartitionsCount` | > 0 说明有分区不可用 | | | `ActiveControllerCount` | 必须 = 1 | | **Broker** | `RequestHandlerAvgIdlePercent` | < 30% 说明线程池紧张 | | | `NetworkProcessorAvgIdlePercent` | 同上 | | | `BytesInPerSec` / `BytesOutPerSec` | 吞吐量 | | **分区** | `LogEndOffset` / `LogStartOffset` | 消息范围 | | | `ISR` 大小 | 是否足够 | | **Producer** | `record-error-rate` | 发送失败率 | | | `record-send-rate` | 发送速率 | | **Consumer** | `records-lag-max` | 消费滞后数(关键)| | | `fetch-rate` | 拉取速率 | **工具**: - **Kafka 自带**:`kafka-consumer-groups.sh`、`kafka-topics.sh --describe` - **开源**:Kafka Manager(Yahoo)、Kafka Eagle、CMAK - **商业**:Confluent Control Center - **通用监控**:Prometheus + JMX Exporter + Grafana(最主流) ## 49. 分区扩容要注意什么? **能扩**:`kafka-topics.sh --alter --partitions N`,只能增加不能减少。 **坑点**: 1. **已有消息的 key 分布会变**: ``` hash(key) % 3 和 hash(key) % 4 结果完全不同 → 同一个 key 的新老消息可能落到不同分区 → 原本保证的分区内顺序被打破 ``` 2. **对顺序敏感的业务不能随便扩分区**,要提前规划好最终分区数 3. **扩容后不会自动迁移已有数据**,只有新消息按新规则分配 4. **消费者 Rebalance**:分区增加会触发消费组 rebalance **建议**: - Topic 创建时就规划好分区数,按未来 2-3 年峰值算 - 业务对 key 顺序敏感的话,**不要扩分区**,改用 `Partitioner` 自定义路由 ## 50. 跨机房/跨数据中心怎么同步 Kafka? **方案 1:MirrorMaker 2.0(推荐)** - Kafka 自带,基于 Kafka Connect - 支持双向复制、主题重命名、ACL 同步、Offset 同步 - 配置简单,生态好 **方案 2:Confluent Replicator** - 商业版功能更丰富 **方案 3:自己写消费+生产程序** - 不推荐,容易丢消息、漏细节 **跨机房核心难点**: - **网络延迟**:异地机房 ms 级延迟,影响 Producer 和同步 - **一致性**:同步复制延迟大,通常用**异步复制**(最终一致) - **双写冲突**:两边都写入时的冲突处理 - **Offset 映射**:同一消息在两个集群的 offset 不同,消费组切换要做映射 **典型架构**: - **Active-Passive**:主集群读写,备集群只同步,主挂了切到备 - **Active-Active**:双活,各写各的本地,互相同步,适合地域分布业务 ## 51. Kafka 能替代数据库吗? **不能**,但在某些场景可以做类似的事: **Kafka 能做的**: - **事件溯源(Event Sourcing)**:所有状态变更以事件形式存 Kafka,可回放 - **日志压缩(Compact)**:保留每个 key 的最新值,类似 KV 表 - **流处理 + 状态存储**:Kafka Streams 内部状态用 Kafka 存(RocksDB + changelog) **Kafka 做不到数据库的事**: - 复杂查询(只能按 offset/时间戳顺序读) - 事务跨多表 - 索引(只有 offset 和时间戳两个维度) - 更新/删除(只能通过 compact 间接实现) **结论**:Kafka 是**日志存储**,不是数据库。但和数据库搭配很常见:**Kafka 当 WAL + DB 当查询层**(CQRS 架构)。 ## 52. Kafka Streams 和 Flink 对比? | 对比 | Kafka Streams | Flink | |------|--------------|-------| | **定位** | 轻量级库,嵌入应用 | 独立计算引擎 | | **部署** | 和业务代码一起部署 | 独立集群 | | **状态存储** | RocksDB + Kafka changelog | 多种 backend | | **延迟** | 毫秒 | 毫秒 | | **吞吐** | 高(同 Kafka) | 高 | | **窗口** | 支持 | 支持更丰富(事件时间 + 处理时间 + watermark) | | **Exactly-once** | 支持(事务) | 支持 | | **生态** | 弱于 Flink | 强(SQL、CEP、ML 等) | | **学习成本** | 低 | 中高 | **选型**: - 逻辑简单、只处理 Kafka 数据、不想维护额外集群 → Kafka Streams - 复杂流处理、多数据源、大状态 → Flink ## 53. 为什么不建议 Topic 数量过多? Kafka 不擅长海量 Topic,原因: 1. **每个分区对应多个文件**(.log、.index、.timeindex),分区数太多时**文件句柄暴增**,消耗系统资源 2. **元数据膨胀**:Controller 管理压力大,元数据操作变慢 3. **内存占用**:每个分区在 Broker 上都有内存开销 4. **Leader 选举变慢**:Broker 宕机后恢复时间增加 **经验值**: - 分区密度应按 Broker 内存、文件句柄、恢复时间、控制器能力和运维 SLO 压测确定;不要套用脱离版本的固定上限 - KRaft 改善了元数据可扩展性,但仍需基于目标版本与故障恢复演练设定容量阈值 - 一个业务避免无治理地创建大量 Topic;是否合并到同一 Topic 需同时考虑保留策略、权限、隔离与 Schema 契约 ## 54. Kafka 怎么做权限控制(ACL)? **认证(Authentication)**: - SASL/PLAIN(用户名密码) - SASL/SCRAM(加盐密码,推荐) - SSL/TLS 双向认证 - SASL/Kerberos(企业环境) **授权(Authorization)**:基于 ACL ``` kafka-acls.sh --add --allow-principal User:alice \ --operation Read --topic orders ``` **资源类型**:Topic、Group、Cluster、TransactionalId **操作类型**:Read、Write、Create、Delete、Alter、Describe **加密**:SSL 加密传输,同时也提供认证能力。 **生产建议**:至少用 SASL/SCRAM + SSL。公网暴露的集群必须用。 ## 55. Kafka 在高并发场景下调优方向? **生产侧**: - `batch.size`:16KB → 64KB - `linger.ms`:0 → 10-20 - `compression.type`:开启 lz4/zstd - `buffer.memory`:32MB → 64-128MB - `max.in.flight.requests.per.connection`:1 → 5(配合幂等) **Broker 侧**: - `num.network.threads`:3 → 8 - `num.io.threads`:8 → 16(= 磁盘数 * 2) - `socket.send.buffer.bytes` / `socket.receive.buffer.bytes`:1MB - `num.replica.fetchers`:1 → 4 - JVM 堆:6-8GB,剩下给 Page Cache - GC:G1 或 ZGC **消费侧**: - `fetch.min.bytes`:1 → 64KB(批量拉取) - `fetch.max.wait.ms`:500ms(和 min.bytes 平衡延迟) - `max.poll.records`:500 → 根据处理速度调 - 多消费者(不超过分区数) **OS 层**: - 文件句柄:`ulimit -n 100000` - 虚拟内存:`vm.swappiness=1` - `vm.dirty_ratio`:刷盘策略 - 禁用 THP(Transparent Huge Pages) 调优前后都要**压测对比**,不要拍脑袋改参数。 ## 必背与关联阅读 **必背**:6(为什么快)、11(acks)、18/20(提交与再均衡)、22(至少一次与幂等)、32/33(ISR、HW/LEO)、37~40(端到端可靠性与事务)、48(监控)、49(扩分区风险)。回答时先交代“分区内顺序”“外部副作用无法由 Kafka 事务覆盖”“默认值依版本确认”三个边界。 关联阅读:[01 - 核心概念](./01-overview.md)|[03 - 生产者](./03-producer.md)|[04 - 消费者](./04-consumer.md)|[05 - 主题与分区](./05-topic-partition.md)|[06 - 存储](./06-storage.md)|[07 - 可靠性](./07-reliability.md)|[08 - 性能](./08-performance.md)|[10 - 生产实战](./10-production.md)。 ## 面试实践建议 避免报出脱离版本、硬件和消息大小的固定吞吐或延迟数字。将题目落到一个真实事件流:说明 Key 如何保证局部顺序、为何采用至少一次、如何通过唯一键或 Outbox 防重、用哪些指标确认副本和消费健康,即可体现工程判断。 ## 官方参考资料 - [Apache Kafka Documentation](https://kafka.apache.org/documentation/) - [Kafka Configuration](https://kafka.apache.org/documentation/#configuration) - [Kafka Design](https://kafka.apache.org/documentation/#design) --- 导航:[目录](./README.md) | 上一篇:[11 - 一条消息的完整生命周期](./11-message-lifecycle.md) | 下一篇:无
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入