
Hello,我是小兔大白糖。 读完能复述分区并行、ISR 与 ACK 的可靠/性能权衡,以及 Consumer Group 再均衡敏感点。
Kafka是分区追加日志:并行靠分区,可靠靠 ISR/ACK,消费靠 Consumer Group 再均衡合同。
估计阅读时间:61 分钟
目标:深入掌握 Kafka 原理,成为 Kafka 专家
目录
- 1. 核心概念与架构
- 2. 分区与消费者组
- 3. 消息可靠性机制
- 4. 顺序性保障
- 5. Rebalance 机制
- 6. 分区策略与 Key 设计
- 7. 幂等性与 Exactly-Once
- 8. 集群优化方案
- 9. 业务场景设计优化
- 10. 监控与运维
- 附录:配置速查表
- 下一步:业务场景实战
- 一句话结论是什么?
- 1. 这是什么?概念怎么定义
- 2. 核心原理是什么?
- 3. 怎么用?关键代码与配置
- 4. 业界怎么做?
1. 核心概念与架构
1.1 Kafka 架构概览
1.2 核心组件
| 组件 | 职责 | 说明 |
|---|---|---|
| Broker | 存储消息 | 每个 Broker 是一个 Kafka 实例 |
| Topic | 消息分类 | 逻辑容器,包含多个 Partition |
| Partition | 分区存储 | 每个 Partition 是有序的、不可变的消息序列 |
| Replica | 数据备份 | Partition 的副本,分为 Leader 和 Follower |
| Producer | 消息生产者 | 将消息发送到 Topic |
| Consumer | 消息消费者 | 从 Topic 消费消息 |
| Consumer Group | 消费者组 | 一组 Consumer,共同消费一个 Topic |
| Coordinator | 协调者 | 管理 Consumer Group 的 Rebalance |
1.3 消息存储结构
Topic: order-events (3 partitions)
────────────────────────────────────────────────────────────
Partition 0 Partition 1 Partition 2
┌─────────────────────┐ ┌─────────────────────┐ ┌─────────────────────┐
│ offset: 0 │ │ offset: 0 │ │ offset: 0 │
│ timestamp: t1 │ │ timestamp: t1 │ │ timestamp: t1 │
│ key: "order-1001" │ │ key: "order-1002" │ │ key: "order-1003" │
│ value: {...} │ │ value: {...} │ │ value: {...} │
├─────────────────────┤ ├─────────────────────┤ ├─────────────────────┤
│ offset: 1 │ │ offset: 1 │ │ offset: 1 │
│ timestamp: t2 │ │ timestamp: t2 │ │ timestamp: t2 │
│ key: "order-1001" │ │ key: "order-1004" │ │ key: "order-1005" │
│ value: {...} │ │ value: {...} │ │ value: {...} │
├─────────────────────┤ ├─────────────────────┤ ├─────────────────────┤
│ offset: 2 │ │ offset: 2 │ │ offset: 2 │
│ ... │ │ ... │ │ ... │
└─────────────────────┘ └─────────────────────┘ └─────────────────────┘
▲ ▲ ▲
│ │ │
└──▶ 追加写入(顺序)◀──────┴──────────────────────────┘
1.4 关键特性
| 特性 | 说明 |
|---|---|
| 持久化 | 消息写入磁盘,可配置保留时间 |
| 高吞吐 | 顺序写入 + 零拷贝 + 批量处理 |
| 水平扩展 | 通过增加分区和 Broker 实现扩展 |
| 分区复制 | Partition 可配置副本数,保证高可用 |
| Exactly-once | 幂等生产者 + 事务 API 实现精确一次 |
2. 分区与消费者组
2.1 分区分配原则
核心规则:
1. 一个分区只能被同一个 Consumer Group 的一个 Consumer 消费
2. 不同 Consumer Group 可以消费同一个分区(广播模式)
3. Consumer 数量 > 分区数量时,多余的 Consumer 空闲
2.2 分区数 vs Consumer 数关系
| 场景 | 分区数 | Consumer 数 | 结果 |
|---|---|---|---|
| 正常 | 6 | 3 | 每个 Consumer 消费 2 个分区 |
| Consumer 不足 | 6 | 2 | 每个 Consumer 消费 3 个分区 |
| Consumer 过多 | 6 | 9 | 6 个 Consumer 消费分区,3 个空闲 |
| 1:1 映射 | 3 | 3 | 每个 Consumer 消费 1 个分区 |
2.3 分区数计算公式
分区数 = 期望峰值 QPS × 业务平均耗时 / 1000ms
举例:
- 期望峰值 QPS = 10000
- 业务平均耗时 = 50ms
- 保守冗余系数 = 3~5 倍
基础分区数 = 10000 × 50 / 1000 = 500
最终分区数 = 500 × 4 = 2000(取 4 倍冗余)
2.4 分区数设计考虑因素
| 因素 | 说明 |
|---|---|
| 消费者数量 | 分区数 >= 预期最大 Consumer 实例数 |
| 吞吐量需求 | 分区数越多,并行消费能力越强 |
| 顺序性要求 | 强顺序要求时,同 key 消息必须在同一分区 |
| 副本数量 | 每个分区有 replication-factor 个副本 |
| Broker 数量 | 分区数建议是 Broker 数量的倍数 |
3. 消息可靠性机制
3.1 Producer ACK 策略
3.2 ACK 级别对比
| 级别 | 可靠性 | 性能 | 丢消息风险 |
|---|---|---|---|
acks=0 | 最低 | 最高 | 高(Leader 宕机) |
acks=1 | 中等 | 高 | 中(Leader 宕机但 Follower 未同步) |
acks=all (-1) | 最高 | 低 | 低(需所有 ISR 确认) |
3.3 ISR (In-Sync Replicas)
ISR = Leader + 保持同步的 Follower 集合
配置:min.insync.replicas = 2
含义:
- 必须至少有 2 个副本确认才算成功
- 如果只有 1 个副本(Leader),写入会失败
3.4 消费者提交策略
| 模式 | 配置 | 风险 |
|---|---|---|
| 自动提交 | enable.auto.commit=true | 处理失败但已提交,会丢消息 |
| 同步提交 | 手动调用 commitSync() | 阻塞,但可靠 |
3.5 消息丢失场景与防护
┌─────────────────────────────────────────────────────────────────┐
│ 消息丢失场景与防护 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 【场景1:Producer 发送失败】 │
│ ┌────────┐ ┌────────┐ ┌────────┐ │
│ │ 发送消息│ ──× ─│ Kafka │ │ 消息丢失│ ← 无重试 │
│ └────────┘ └────────┘ └────────┘ │
│ │
│ 防护:启用 retries +delivery.timeout │
│ │
│ 【场景2:Leader 宕机但未同步】 │
│ ┌────────┐ ┌────────┐ ┌────────┐ │
│ │写入Leader│ ──✓ ─│ Leader │ ──× ─│ Follower│ ← 数据不一致 │
│ └────────┘ └────────┘ └────────┘ │
│ │
│ 防护:acks=all + min.insync.replicas=2 │
│ │
│ 【场景3:消费者自动提交后处理失败】 │
│ ┌────────┐ ┌────────┐ ┌────────┐ │
│ │ 消费消息│ ──✓ ─│ 自动提交│ ──× ─│ 处理失败│ ← 消息已丢失 │
│ └────────┘ └────────┘ └────────┘ │
│ │
│ 防护:手动同步提交,处理成功后再提交 │
│ │
└─────────────────────────────────────────────────────────────────┘
4. 顺序性保障
4.1 Kafka 顺序性保证
1. 分区内有序:同一 Partition 内的消息按 offset 顺序消费
2. 分区间无序:不同 Partition 之间消息无顺序保证
3. 跨 Consumer 无序:不同 Consumer 消费不同分区无顺序保证
4.2 按 Key 分区保证顺序
4.3 单分区单线程保证强顺序
4.4 顺序性保障方案对比
| 方案 | 实现 | 适用场景 | 吞吐 |
|---|---|---|---|
| 单分区单线程 | 1 分区 + 1 Consumer | 金融交易等强顺序 | 低 |
| 按 Key 分区 + 同 Key 串行 | 多分区 + key 分组 | 订单等业务 | 中 |
| 最终一致 + 版本校对 | 多分区 + 版本号 | 高并发场景 | 高 |
5. Rebalance 机制
5.1 Rebalance 触发条件
5.2 Rebalance 分区分配策略
| 策略 | 说明 | 特点 |
|---|---|---|
| Range | 按 Topic 分组分配 | 可能不均匀 |
| RoundRobin | 轮询分配 | 更均匀 |
| StickyAssignor | 保持已有分配,尽量少变动 | 减少 Rebalance 影响 |
5.3 Rebalance 影响与优化
影响:
- 分区重新分配期间停止消费
- 可能造成消息积压
- 频繁 Rebalance 影响系统稳定性
优化配置:
# 合理的心跳配置
session.timeout.ms = 30000
heartbeat.interval.ms = 10000
max.poll.interval.ms = 300000
# 避免频繁 Rebalance
session.timeout.ms = 45000
heartbeat.interval.ms = 150006. 分区策略与 Key 设计
6.1 分区选择算法
6.2 Key 设计原则
| 场景 | Key 设计 | 效果 |
|---|---|---|
| 订单消息 | order_id | 同订单消息在同一分区,保证顺序 |
| 用户消息 | user_id | 同用户消息顺序 |
| 业务隔离 | tenant_id | 不同租户消息隔离 |
| 时间序列 | device_id + 时间 | 同设备消息有序 |
6.3 自定义分区器
type CustomPartitioner struct{}
func (p *CustomPartitioner) Partition(
topic string,
key, value []byte,
numPartitions int,
) int {
// 按业务规则自定义分区逻辑
if bytes.HasPrefix(key, []byte("vip-")) {
// VIP 用户消息打到高优先级分区
return 0
}
return int(crc32.ChecksumIEEE(key)) % numPartitions
}6.4 分区数规划流程
┌─────────────────────────────────────────────────────────────────┐
│ 分区数规划流程 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 1. 估算峰值 QPS │
│ ↓ │
│ 2. 估算单条消息处理耗时 │
│ ↓ │
│ 3. 计算基础分区数 = QPS × 耗时 / 1000 │
│ ↓ │
│ 4. 考虑冗余系数(3-5 倍) │
│ ↓ │
│ 5. 考虑 Consumer 数量(分区数 >= 最大实例数) │
│ ↓ │
│ 6. 考虑副本数(影响 Leader 分布) │
│ ↓ │
│ 7. 最终分区数 = max(所有因素) │
│ │
└─────────────────────────────────────────────────────────────────┘
7. 幂等性与 Exactly-Once
7.1 Kafka 幂等性
7.2 幂等 Producer 配置
# 启用幂等性
enable.idempotence=true
# 防止因重试导致的消息乱序
max.in.flight.requests.per.connection=5
# 合理设置重试次数
retries=2147483647
# Delivery Timeout
delivery.timeout.ms=1200007.3 Exactly-Once 语义
| 语义 | 说明 | 实现方式 |
|---|---|---|
| At-least-once | 至少一次,可能重复 | 自动重试 + 幂等消费 |
| At-most-once | 至多一次,可能丢消息 | 不重试 + 自动提交 |
| Exactly-once | 恰好一次,不丢不重复 | 事务 API + 幂等生产 |
7.4 幂等消费实现:Redis + DB 双写
// 幂等检查伪代码
func ProcessMessage(ctx context.Context, msg Message) error {
idempotentKey := fmt.Sprintf("%s-%d-%d",
msg.Topic, msg.Partition, msg.Offset)
// 1. Redis SETNX 检查
ok, err := redis.SetNX(ctx, idempotentKey, "processing", 24*time.Hour)
if err != nil {
return err
}
if !ok {
log.Infof("消息已处理,跳过: %s", idempotentKey)
return nil // 幂等,直接返回
}
// 2. 处理业务
err = businessProcess(ctx, msg)
if err != nil {
return err
}
// 3. DB 落库(乐观锁)
err = db.UpdateWithVersion(ctx, msg)
if err != nil {
return err
}
// 4. 删除 Redis Key(或设置过期)
redis.Del(ctx, idempotentKey)
return nil
}7.5 幂等 Key 设计
幂等Key = topic + partition + offset
例如:
"data-service-0-12345678"
格式:{topic}-{partition}-{offset}
8. 集群优化方案
8.1 Broker 配置优化
# 网络和 IO 优化
num.network.threads=8
num.io.threads=16
socket.send.buffer.bytes=102400
socket.receive.buffer.bytes=102400
socket.request.max.bytes=104857600
# 存储优化
log.dir=/data/kafka
log.dirs=/data/kafka
num.partitions=6
log.retention.hours=168
log.segment.bytes=1073741824 # 1GB
log.index.interval.bytes=4096
# 副本优化
default.replication.factor=3
min.insync.replicas=2
# 连接优化
max.connections.per.ip=2147483647
max.poll.records=500
fetch.max.bytes=52428800 # 50MB8.2 Producer 优化
# 批量发送
batch.size=16384
linger.ms=10
buffer.memory=33554432
# 压缩
compression.type=snappy
# ACK 策略
acks=all
retries=2147483647
# 幂等性
enable.idempotence=true8.3 Consumer 优化
# 消费批量
fetch.min.bytes=1
fetch.max.wait.ms=500
max.poll.records=500
# 提交策略(同步提交)
enable.auto.commit=false
auto.offset.reset=latest
# 心跳和超时
session.timeout.ms=45000
heartbeat.interval.ms=150008.4 集群拓扑设计
8.5 分区副本分配策略
// 副本分配原则
1. 分区副本分散在不同 Broker
2. 考虑机架/数据中心
3. Leader 均匀分布
// 示例:9 分区,3 副本
Partition 0: [Broker1, Broker4, Broker7]
Partition 1: [Broker2, Broker5, Broker8]
Partition 2: [Broker3, Broker6, Broker9]
// ...9. 业务场景设计优化
9.1 高吞吐场景
9.2 低延迟场景
# Producer 优化
linger.ms=0
batch.size=0
compression.type=none
# Consumer 优化
fetch.min.bytes=1
fetch.max.wait.ms=09.3 消息优先级
9.4 消息回溯消费
// 从头消费
consumer := kafka.NewReader(kafka.ReaderConfig{
Topic: "my-topic",
GroupID: "my-group",
StartOffset: kafka.FirstOffset,
})
// 从最新消费
consumer := kafka.NewReader(kafka.ReaderConfig{
Topic: "my-topic",
GroupID: "my-group",
StartOffset: kafka.LastOffset,
})
// 按时间消费
consumer := kafka.NewReader(kafka.ReaderConfig{
Topic: "my-topic",
GroupID: "my-group",
StartOffset: kafka.FirstOffset,
})9.5 消息积压处理
┌─────────────────────────────────────────────────────────────────┐
│ 消息积压处理流程 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 1. 监控告警 │
│ - consumer.lag > 阈值 │
│ - 消费延迟 > 5 分钟 │
│ │
│ 2. 快速扩容 │
│ - 增加 Consumer 实例 │
│ - 触发 Rebalance │
│ │
│ 3. 消费者优化 │
│ - 增加 fetch.max.bytes │
│ - 减少 max.poll.records │
│ - 开启批量处理 │
│ │
│ 4. 生产者限流(极端情况) │
│ - 控制消息发送速率 │
│ │
└─────────────────────────────────────────────────────────────────┘
10. 监控与运维
10.1 关键指标
| 指标 | 说明 | 告警阈值 |
|---|---|---|
consumer_lag | 消费延迟 | > 10000 |
produce_rate | 生产速率 | - |
consume_rate | 消费速率 | - |
under_replicated_partitions | 副本不足 | > 0 |
offline_partitions | 离线分区 | > 0 |
messages_in_per_sec | 每秒消息数 | - |
10.2 监控命令
# 查看消费延迟
kafka-consumer-groups.sh --bootstrap-server localhost:9092 \
--group my-group --describe
# 查看 Topic 列表
kafka-topics.sh --bootstrap-server localhost:9092 --list
# 查看 Topic 分区详情
kafka-topics.sh --bootstrap-server localhost:9092 \
--topic my-topic --describe
# 查看消费者组
kafka-consumer-groups.sh --bootstrap-server localhost:9092 \
--list10.3 常见问题排查
| 问题 | 原因 | 解决方案 |
|---|---|---|
| 消息丢失 | ACK 配置不当 | 改为 acks=all |
| 消息重复 | 网络重试 | 启用幂等消费 |
| 消费延迟 | Consumer 不足 | 增加 Consumer 实例 |
| Rebalance 频繁 | 心跳超时 | 调整 session.timeout |
| 分区不均衡 | 分区分配策略 | 使用 StickyAssignor |
附录:配置速查表
Producer 配置
| 配置项 | 推荐值 | 说明 |
|---|---|---|
acks | all | 强可靠性 |
retries | 2147483647 | 充分重试 |
enable.idempotence | true | 幂等生产 |
batch.size | 16384 (16KB) | 批量发送 |
linger.ms | 10 | 等待批量 |
compression.type | snappy | 压缩 |
Consumer 配置
| 配置项 | 推荐值 | 说明 |
|---|---|---|
enable.auto.commit | false | 手动同步提交 |
auto.offset.reset | latest | 从最新消费 |
session.timeout.ms | 45000 | 较长超时 |
heartbeat.interval.ms | 15000 | 频繁心跳 |
max.poll.records | 500 | 批量拉取 |
下一步:业务场景实战
建议阅读配套文档 Kafka 生产级架构设计(IM + 交易场景),了解:
- IM 聊天消息场景的 Kafka 架构设计
- 交易系统消息的顺序性保证方案
- 工业级消息可靠性保障体系
一句话结论是什么?
Kafka 通过 顺序写磁盘 + 零拷贝 + 分段日志 实现了近似内存读写的吞吐量;通过 分区(Partition)并行 + 副本(Replica)冗余 实现水平扩展与高可用;通过 ISR(In-Sync Replicas)+ ACK 机制 在可靠性与性能之间做精确权衡;Consumer Group 借助 Coordinator 管理成员与分区分配,Rebalance 是消费端的性能敏感点;Offset 从 ZooKeeper 迁移到 Kafka 内部 Topic(__consumer_offsets),使架构更简洁且扩展性更强。
1. 这是什么?概念怎么定义
1.1 Kafka 核心术语
| 术语 | 定义 | 一句话理解 |
|---|---|---|
| Topic | 逻辑消息队列,生产者发送消息到 Topic,消费者从 Topic 订阅 | 消息的"主题分类",类似数据库的表名 |
| Partition | Topic 的物理分片,每个 Partition 是一个有序的、不可变的消息序列 | 实现并行处理的单元,Partition 数决定消费者并行度上限 |
| Offset | 消息在 Partition 内的唯一递增序号(逻辑位置) | 消费者的"书签",记录读到了哪里 |
| Replica | Partition 的副本,同一 Partition 的多个 Replica 分布在不同 Broker | 保证高可用,Leader 负责读写,Follower 同步数据 |
| ISR | In-Sync Replicas,与 Leader 保持同步的副本集合 | "靠谱副本名单",只有 ISR 中的成员才有资格竞选 Leader |
| LEO | Log End Offset,副本最后一条消息的 Offset | 副本的"写入进度" |
| HW | High Watermark,所有 ISR 副本都已同步的最大 Offset | 消费者可见的安全边界,HW 之前的消息才算"已提交" |
| ACK | 生产者收到 Broker 的确认级别(0/1/all) | 可靠性配置:不等确认 / 等 Leader 确认 / 等所有 ISR 确认 |
1.2 为什么需要 Kafka
在传统的企业级系统中,系统间的通信往往采用 点对点直连 或 集中式 ESB(企业服务总线):
- 直连:A 系统直接调 B 系统的 HTTP/RPC 接口。问题是耦合严重、流量突发时下游被压垮、故障扩散
- ESB:集中式消息总线。问题是中心节点成为性能瓶颈,扩展困难
Kafka 的诞生解决了三个核心痛点:
- 解耦:生产者和消费者互不知道对方存在,通过 Topic 间接通信
- 削峰填谷:消息先写入 Kafka,消费者按自己的速率消费,流量高峰被平滑
- 高吞吐持久化:顺序写磁盘 + 批量处理,单节点可达数十万 QPS,数据持久化后仍可被多个消费者组独立消费
类比理解:Kafka 就像城市的高速公路系统。Topic 是不同方向的高速公路(如"京藏高速"),Partition 是公路的车道(多条车道并行),Offset 是你在公路上的里程牌,Consumer Group 是不同目的地的车队(去北京的车队、去内蒙古的车队各自独立行驶)。
2. 核心原理是什么?
2.1 生产者端架构:分区、序列化与发送流程
消息路由到 Partition 的策略
生产者发送消息时,必须确定消息进入哪个 Partition:
| 策略 | 行为 | 适用场景 |
|---|---|---|
| 指定 Partition | 直接写入指定 Partition | 需要严格顺序保证的业务(如订单状态变更) |
| 指定 Key | hash(key) % partitionNum | 相同 Key 的消息进入同一 Partition,保证该 Key 的消息顺序 |
| 轮询(RoundRobin) | 无 Key 时,依次发往各 Partition | 负载均衡,最大化吞吐量 |
| 自定义 Partitioner | 实现 Partitioner 接口 | 复杂路由逻辑(如按地域分片) |
生产者发送流程
Producer.send(record)
├── 1. 拦截器(Interceptor)处理
├── 2. 序列化(Serializer)
├── 3. 分区器(Partitioner)选择 Partition
├── 4. 消息进入 RecordAccumulator(内存缓冲区,默认 32MB)
│ └── 按 Topic-Partition 分队列(Deque)
├── 5. Sender 线程批量拉取(batch.size 默认 16KB,linger.ms 默认 0)
├── 6. 构建请求,发送到目标 Broker(Leader)
├── 7. 等待 Broker ACK(acks 配置决定)
└── 8. 回调通知(成功 / 失败重试)
关键理解:生产者发送是异步批量的。消息先进入内存缓冲区(RecordAccumulator),Sender 线程按
batch.size或linger.ms触发实际网络发送。这种设计将大量小 IO 合并为大 IO,是 Kafka 高吞吐的核心之一。
ACK 机制与可靠性权衡
| acks 配置 | 行为 | 延迟 | 可靠性 | 适用场景 |
|---|---|---|---|---|
acks=0 | 发送后不等待任何 ACK | 最低 | 可能丢失(Broker 宕机即丢) | 日志采集、监控指标,可容忍丢失 |
acks=1 | 等待 Leader 写入成功后 ACK | 中等 | Leader 宕机但 Follower 未同步时可能丢失 | 大多数普通业务场景 |
acks=all | 等待 ISR 中所有副本确认 | 最高 | 最高(只要 ISR 中有一个存活就不会丢) | 金融交易、订单状态,不可丢消息 |
注意:
acks=all配合min.insync.replicas=2(默认 1)才能真正发挥可靠性。如果 ISR 中只有 Leader 一个副本,acks=all退化为acks=1。
2.2 Broker 存储机制:分段日志与索引
日志段(Log Segment)
Kafka 的 Partition 在磁盘上以 Log Segment 为单位存储:
Partition 目录结构:
/test-topic-0/
├── 00000000000000000000.log # 消息数据文件(从 offset 0 开始)
├── 00000000000000000000.index # 稀疏索引(offset → 物理位置)
├── 00000000000000000000.timeindex # 时间索引(timestamp → offset)
├── 00000000000000356892.log # 下一个 segment(从 offset 356892 开始)
├── 00000000000000356892.index
└── 00000000000000356892.timeindex
- 每个 Segment 默认 1GB(
log.segment.bytes) - 当 Segment 满或超过 7 天(
log.retention.hours)时,创建新 Segment - 旧的 Segment 可被删除或压缩(Compaction)
稀疏索引(Sparse Index)
Kafka 的 .index 文件采用 稀疏索引,并非每条消息都建立索引:
索引条目间隔 = log.index.interval.bytes (默认 4KB)
即:每写入 4KB 消息数据,才在索引文件中写入一条 offset → 物理位置 的映射
查找消息流程:
- 根据目标 offset,通过二分查找定位到对应的 Segment 文件
- 在
.index文件中找到不大于目标 offset 的最大索引条目 - 从该索引条目对应的物理位置开始顺序扫描
.log文件,找到精确的消息
为什么用稀疏索引而非稠密索引?> - 空间换时间的权衡:索引文件小,可常驻内存
- 顺序扫描磁盘极快(机械硬盘顺序读约 100MB/s,SSD 更快)
- 4KB 间隔意味着最多扫描 4KB 数据,开销极小
零拷贝(Zero-Copy)技术
传统文件发送流程:
磁盘 → 内核页缓存 → 用户态 Buffer → Socket Buffer → 网卡
(4次数据拷贝,4次上下文切换)
Kafka 使用 Linux 的 sendfile() 系统调用:
磁盘 → 内核页缓存 → 网卡(DMA 直接拷贝)
(2次数据拷贝,2次上下文切换)
如果网卡支持 Gather Operation,可进一步优化到 1 次拷贝(内核页缓存的内存地址和长度直接传给网卡,无需额外拷贝)。
类比:传统方式像快递员把包裹从仓库搬到前台,再搬到车上;零拷贝像仓库直接开门让车进来装货,省了两道搬运。
2.3 副本机制:Leader、Follower 与 ISR
副本角色
| 角色 | 职责 |
|---|---|
| Leader | 处理所有读写请求,维护 LEO |
| Follower | 从 Leader 拉取(Pull)消息,同步到自己的日志中 |
| AR(Assigned Replicas) | 该 Partition 的所有副本集合 |
| ISR | AR 中与 Leader 保持同步的子集 |
| OSR(Out-of-Sync Replicas) | 同步滞后的副本(落后超过 replica.lag.time.max.ms,默认 30 秒) |
ISR 收缩与扩容
- 收缩:Follower 同步滞后(如网络延迟、GC 停顿)超过阈值,从 ISR 中移除。此时若 Leader 宕机,该 Follower 不能竞选 Leader(避免数据丢失)
- 扩容:Follower 追赶上 Leader 的 LEO,重新加入 ISR
- unclean.leader.election.enable:是否允许 OSR 中的副本竞选 Leader。默认
false(Kafka 0.11+),保证数据不丢但可能降低可用性;设为true则可用性更高但可能丢消息
2.4 Consumer Group 与 Rebalance
消费者组的核心概念
- Consumer Group:一组共同消费一个 Topic 的消费者实例,组内每个 Partition 只能被一个消费者消费
- Partition 分配策略:
- Range(默认):按 Topic 范围分配,可能导致分配不均
- RoundRobin:轮询分配,更均匀
- Sticky:尽量保持上一次分配结果,减少 Rebalance 时的变动(Kafka 0.11+ 推荐)
- Cooperative Sticky:增量式 Rebalance,先撤销部分分区再重新分配(Kafka 2.4+),进一步减少停顿
Rebalance 触发条件
- 组成员变化:消费者加入或离开组
- 订阅主题变化:消费者订阅了新的 Topic
- Partition 数变化:Topic 扩容分区
Rebalance 流程(Kafka 0.10.1+ 使用 Coordinator)
1. 消费者加入组:向 __consumer_offsets 的 Coordinator 发送 JoinGroup 请求
2. 选 Leader Consumer:Coordinator 选择第一个加入的消费者作为 Leader
3. 同步元数据:Coordinator 将组成员信息和 Topic/Partition 元数据发送给 Leader
4. 制定分配方案:Leader 根据分配策略计算每个消费者该消费哪些 Partition
5. 同步方案:Leader 将分配方案发给 Coordinator,Coordinator 再下发给所有成员
6. 开始消费:各消费者按分配方案开始消费
Rebalance 的代价:Rebalance 期间整个 Consumer Group 停止消费。如果消费逻辑复杂、成员众多,Rebalance 可能持续数秒甚至数十秒,导致消息堆积。
Offset 管理演进
| 版本 | Offset 存储位置 | 说明 |
|---|---|---|
| Kafka 0.8 之前 | ZooKeeper (/consumers/{group}/offsets) | ZK 写性能瓶颈,不适合高频提交 |
| Kafka 0.8+ | Kafka 内部 Topic __consumer_offsets | 高吞吐、可压缩、与 Kafka 自身水平扩展 |
| Kafka 0.9+ | Consumer 自主管理(可存外部系统) | 如存入 MySQL/Redis,实现"精确一次"语义 |
__consumer_offsets Topic:
- 默认 50 个 Partition(
offsets.topic.num.partitions) - 消息格式:
(group, topic, partition) → (offset, metadata, commit_timestamp) - 压缩策略:Log Compaction(只保留每个 Key 的最新值)
2.5 图解:消息生产与消费完整流程
2.6 图解:Broker 分段日志与索引结构
3. 怎么用?关键代码与配置
3.1 生产级 Kafka Producer 配置
@Configuration
public class KafkaProducerConfig {
@Value("${kafka.bootstrap-servers}")
private String bootstrapServers;
@Bean
public ProducerFactory<String, String> riskEventProducerFactory() {
Map<String, Object> props = new HashMap<>();
// 基础配置
props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, JsonSerializer.class);
// 可靠性配置:金融风控场景,消息不可丢失
props.put(ProducerConfig.ACKS_CONFIG, "all"); // 等待所有 ISR 确认
props.put(ProducerConfig.RETRIES_CONFIG, 3); // 发送失败重试 3 次
props.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG, true); // 开启幂等生产者
props.put(ProducerConfig.MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION, 5); // 允许 5 个未确认请求在途
props.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "risk-producer-1"); // 事务 ID
// 吞吐优化
props.put(ProducerConfig.BATCH_SIZE_CONFIG, 32 * 1024); // 批次大小 32KB
props.put(ProducerConfig.LINGER_MS_CONFIG, 10); // 最多等待 10ms 攒批
props.put(ProducerConfig.COMPRESSION_TYPE_CONFIG, "lz4"); // LZ4 压缩
props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 64 * 1024 * 1024L); // 缓冲区 64MB
// 超时配置
props.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG, 30000); // 请求超时 30s
props.put(ProducerConfig.DELIVERY_TIMEOUT_MS_CONFIG, 120000); // delivery.timeout.ms
return new DefaultKafkaProducerFactory<>(props);
}
@Bean
public KafkaTemplate<String, String> riskKafkaTemplate(
ProducerFactory<String, String> riskEventProducerFactory) {
return new KafkaTemplate<>(riskEventProducerFactory);
}
}3.2 风控事件生产:带事务的消息发送
@Service
@RequiredArgsConstructor
@Slf4j
public class RiskEventProducer {
private final KafkaTemplate<String, RiskEvent> kafkaTemplate;
// 风控事件 Topic,按 userId 分区保证用户事件的顺序性
private static final String RISK_EVENT_TOPIC = "risk.events";
/**
* 发送实时风控事件(带事务,保证 Exactly-Once 语义)
* 场景:用户下单后,风控系统需要记录一笔风险事件,且这笔记录必须与订单状态一致
*/
@Transactional("kafkaTransactionManager")
public void sendRiskEvent(RiskEvent event) {
try {
// 使用 userId 作为 Key,保证同一用户的事件进入同一 Partition
// 这对风控场景至关重要:同一用户的交易序列需要按顺序分析
String key = String.valueOf(event.getUserId());
// 构建消息,携带业务上下文 Header
ProducerRecord<String, RiskEvent> record = new ProducerRecord<>(
RISK_EVENT_TOPIC,
key,
event
);
record.headers()
.add("traceId", MDC.get("traceId").getBytes(StandardCharsets.UTF_8))
.add("eventType", event.getEventType().getBytes(StandardCharsets.UTF_8))
.add("timestamp", String.valueOf(System.currentTimeMillis()).getBytes());
// 同步发送 + 事务:保证消息发送与本地事务的原子性
SendResult<String, RiskEvent> result = kafkaTemplate.send(record).get(5, TimeUnit.SECONDS);
log.info("风控事件发送成功, topic={}, partition={}, offset={}, userId={}",
result.getRecordMetadata().topic(),
result.getRecordMetadata().partition(),
result.getRecordMetadata().offset(),
event.getUserId()
);
} catch (Exception e) {
log.error("风控事件发送失败, userId={}, event={}", event.getUserId(), event, e);
// 抛出异常触发 Kafka 事务回滚,消息不会被真正写入
throw new RiskEventPublishException("风控事件发送失败", e);
}
}
/**
* 批量发送风控事件(异步 + 回调)
* 场景:离线特征计算完成后,批量回写风控评分事件
*/
public void batchSendRiskEvents(List<RiskEvent> events) {
List<ListenableFuture<SendResult<String, RiskEvent>>>> futures = new ArrayList<>();
for (RiskEvent event : events) {
ListenableFuture<SendResult<String, RiskEvent>> future = kafkaTemplate.send(
RISK_EVENT_TOPIC,
String.valueOf(event.getUserId()),
event
);
// 添加回调处理成功/失败
future.addCallback(
result -> {
if (log.isDebugEnabled()) {
log.debug("批量事件发送成功, userId={}, offset={}",
event.getUserId(), result.getRecordMetadata().offset());
}
},
ex -> log.error("批量事件发送失败, userId={}", event.getUserId(), ex)
);
futures.add(future);
}
// 等待所有发送完成(可选,取决于业务是否需要确认)
// 如果不需要等待,可立即返回,由回调处理结果
}
}
// 风控事件定义
@Data
@Builder
public class RiskEvent {
private Long userId;
private String eventType; // LOGIN, TRADE, WITHDRAW, etc.
private BigDecimal amount; // 交易金额
private String currency; // 币种
private String ipAddress;
private String deviceId;
private Long timestamp;
private Map<String, Object> features; // 扩展特征
}3.3 消费者组:手动提交 Offset + 重试策略
@Configuration
public class KafkaConsumerConfig {
@Value("${kafka.bootstrap-servers}")
private String bootstrapServers;
@Bean
public ConsumerFactory<String, RiskEvent> riskEventConsumerFactory() {
Map<String, Object> props = new HashMap<>();
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
props.put(ConsumerConfig.GROUP_ID_CONFIG, "risk-processor-group-v1");
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, JsonDeserializer.class);
// 手动提交 Offset(金融场景必须手动提交,保证业务处理成功后才确认消费)
props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
// 消费者从最早的消息开始消费(新组首次启动时)
props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
// 单次拉取最大消息数,控制消费速率
props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 100);
// 两次 poll 之间的最大间隔,超过则 Consumer 被踢出组,触发 Rebalance
props.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, 300_000); // 5分钟
// 心跳间隔,必须远小于 session.timeout.ms
props.put(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, 3_000);
props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, 10_000);
// 分配策略:Cooperative Sticky(Kafka 2.4+),减少 Rebalance 影响
props.put(ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG,
CooperativeStickyAssignor.class.getName());
return new DefaultKafkaConsumerFactory<>(props,
new StringDeserializer(),
new JsonDeserializer<>(RiskEvent.class));
}
@Bean
public ConcurrentKafkaListenerContainerFactory<String, RiskEvent> riskKafkaListenerContainerFactory(
ConsumerFactory<String, RiskEvent> riskEventConsumerFactory) {
ConcurrentKafkaListenerContainerFactory<String, RiskEvent> factory =
new ConcurrentKafkaListenerContainerFactory<>();
factory.setConsumerFactory(riskEventConsumerFactory);
// 并发消费者数 = Partition 数时达到最大并行度
factory.setConcurrency(8);
// 手动 ACK 模式:Record / Batch / Count / Time
factory.getContainerProperties().setAckMode(ContainerProperties.AckMode.MANUAL_IMMEDIATE);
return factory;
}
}@Component
@RequiredArgsConstructor
@Slf4j
public class RiskEventConsumer {
private final RiskRuleEngine ruleEngine;
private final RiskEventRepository eventRepository;
/**
* 消费风控事件,执行规则判定
* 关键:手动提交 Offset,且处理逻辑必须是幂等的
*/
@KafkaListener(
topics = "risk.events",
groupId = "risk-processor-group-v1",
containerFactory = "riskKafkaListenerContainerFactory"
)
public void onRiskEvent(ConsumerRecord<String, RiskEvent> record,
Acknowledgment acknowledgment) {
RiskEvent event = record.value();
String traceId = new String(record.headers().lastHeader("traceId").value(), StandardCharsets.UTF_8);
MDC.put("traceId", traceId);
try {
log.info("消费风控事件, partition={}, offset={}, userId={}",
record.partition(), record.offset(), event.getUserId());
// 1. 幂等校验:防止重复消费(基于 Kafka 的 unique idempotency key)
if (eventRepository.existsByEventId(event.getEventId())) {
log.warn("事件已处理,跳过, eventId={}", event.getEventId());
acknowledgment.acknowledge(); // 已处理过,直接确认
return;
}
// 2. 执行业务逻辑:规则引擎判定
RiskDecision decision = ruleEngine.evaluate(event);
// 3. 持久化决策结果(与 Offset 提交在同一业务语义中)
eventRepository.save(EventRecord.builder()
.eventId(event.getEventId())
.userId(event.getUserId())
.decision(decision.getAction()) // PASS, REVIEW, BLOCK
.score(decision.getRiskScore())
.processedAt(Instant.now())
.build());
// 4. 业务处理成功后,手动提交 Offset
// 如果此处崩溃,Offset 未提交,消息会被重新消费(依赖幂等保证不重复处理)
acknowledgment.acknowledge();
log.info("风控事件处理完成, eventId={}, decision={}",
event.getEventId(), decision.getAction());
} catch (Exception e) {
log.error("风控事件处理失败, partition={}, offset={}, userId={}",
record.partition(), record.offset(), event.getUserId(), e);
// 不提交 Offset,让消息进入重试或死信队列
// 注意:不调用 acknowledgment.acknowledge(),消息会在 session timeout 后重新投递
// 或者根据异常类型决定是否 ack(如业务校验异常可 ack,系统异常不 ack)
throw e;
} finally {
MDC.clear();
}
}
}4. 业界怎么做?
4.1 LinkedIn:Kafka 的诞生地与万亿级消息实践
背景:Kafka 最初由 LinkedIn 的 Jay Kreps、Neha Narkhede 和 Jun Rao 于 2011 年开发,用于解决 LinkedIn 内部海量日志和事件数据的传输问题。
规模:
- 每天处理 7 万亿条消息(截至 2020 年公开数据)
- 超过 10 万个 Topic,数百万个 Partition
- 峰值吞吐量达到 每秒千万级消息
关键实践:
-
Exactly-Once 语义落地:LinkedIn 在 Kafka 0.11 引入幂等生产者和事务 API 后,立即在生产环境启用。其核心场景是 "用户行为事件" 与 "数据库变更" 的一致性 —— 确保用户资料更新和对应的事件通知要么都成功,要么都失败。
-
MirrorMaker 跨机房复制:LinkedIn 使用 Kafka MirrorMaker 将数据从美国东海岸复制到西海岸,实现灾备。风控相关实践:只复制关键 Topic(而非全部),并设置
acks=1降低跨地域延迟。 -
Consumer Rebalance 优化:LinkedIn 在大规模 Consumer Group(数千个消费者)中发现,Rebalance 导致的消费停顿是严重问题。他们推动了 Incremental Cooperative Rebalancing(Kafka 2.4+ 的 Cooperative Sticky Assignor)的社区实现,将 Rebalance 时间从分钟级降到秒级。
LinkedIn 的经验:"Kafka 的性能上限不在磁盘,而在网络。网络带宽是大型集群的首要瓶颈,压缩(LZ4/Snappy)和批量发送是必须开启的。"
4.2 阿里巴巴:双十一万亿级交易消息的 Kafka 改造
背景:阿里的电商核心系统早期使用自研消息队列 Notify 和 MetaQ(RocketMQ 的前身)。随着业务规模增长,阿里对 Kafka 进行了深度定制,形成了 RocketMQ(开源)和内部版本的 Kafka 分支。
阿里 Kafka 实践的核心改造:
-
多副本同步策略优化:阿里发现原生 Kafka 的 ISR 机制在跨机房场景下性能不佳(等待远距离 Follower 确认导致延迟飙升)。他们引入了 "异步复制 + 主从自动切换" 的策略:同城机房内
acks=all,跨机房使用异步复制,牺牲部分一致性换取可用性。 -
Broker 无状态化改造:阿里将 Kafka Broker 的元数据管理从 ZooKeeper 迁移到自研的 ConfigServer,解决了 ZK 在百万级 Partition 下的性能瓶颈。这与 Kafka 3.0 后的 KRaft 模式(去除 ZooKeeper)思路一致。
-
Consumer Group 水平扩展限制:双十一期间,某风控 Consumer Group 需要扩容到 100+ 消费者,但 Topic 只有 64 个 Partition,导致部分消费者空闲。阿里的解决方案是:
- 增加 Partition 数(提前扩容到 256 个)
- 引入二级消费者:一级消费者只做简单过滤和路由,将消息分发到多个二级 Topic,二级 Consumer Group 消费处理
-
消息积压快速恢复:某年双十一凌晨,由于下游风控系统故障,Kafka 消息积压达到 数十亿条。阿里的应急方案:
- 立即扩容 Consumer 实例(EC2 弹性扩容)
- 将非核心 Topic 的消费暂停,释放计算资源给核心风控 Topic
- 启动 "跳过积压" 机制:对于超过 1 小时的旧消息,直接标记为已消费(风控场景下旧事件价值极低)
4.3 Shopify:电商订单系统的 Kafka 流处理
背景:Shopify 是全球最大的 SaaS 电商平台之一,支撑数百万商家的订单处理。
实践:
- 所有订单状态变更(创建、支付、发货、退款)都以事件形式写入 Kafka Topic
orders - 使用 Key = order_id 保证同一订单的事件顺序性
- 多个 Consumer Group 独立消费:
- 库存组:扣减/释放库存
- 物流组:通知仓库发货
- 风控组:实时检测欺诈交易
- 分析组:离线数据仓库同步
Shopify 的核心经验:"Kafka 不是数据库,不应该长期存储数据。设置合理的 retention(7天),让 Consumer 及时处理,否则就是技术债。"
5. 业务场景怎么对照?
5.1 风控/Risk 场景的 Kafka 策略矩阵
| 风控场景 | Topic 设计 | Partition 策略 | ACK 配置 | Consumer 策略 |
|---|---|---|---|---|
| 实时交易风控事件 | risk.events.trade | Key = user_id(保证用户顺序) | acks=all + 幂等 | 低延迟优先,自动提交改为手动,批量 10 条 |
| 用户登录/行为日志 | risk.events.login | Key = user_id | acks=1 | 高吞吐,批量 500 条,允许秒级延迟 |
| 风控规则变更通知 | risk.config.changes | 单 Partition(全局有序) | acks=all | 单消费者或广播模式,必须全部接收 |
| 离线特征计算结果 | risk.features.batch | RoundRobin | acks=1 | 批量消费,高吞吐,容忍分钟级延迟 |
| 风控告警/阻断指令 | risk.alerts | Key = alert_id | acks=all | 低延迟,并行消费,立即处理 |
5.2 常见误区 vs 正确做法
| 误区 | 正确做法 |
|---|---|
| ❌ "Partition 越多越好" | ✅ Partition 过多会导致:文件句柄耗尽、Rebalance 变慢、Broker 元数据膨胀。建议单 Topic < 200 个 Partition,总数根据 Broker 数和磁盘能力评估 |
| ❌ "acks=all 就绝对不会丢消息" | ✅ acks=all 必须配合 min.insync.replicas >= 2 且 ISR 大小 >= min.insync.replicas。如果 ISR 只剩 Leader,仍可能丢消息 |
| ❌ "Consumer 自动提交 Offset 很方便" | ✅ 风控场景必须 手动提交 Offset,且在业务处理成功后才 ack。自动提交可能导致消息丢失(业务处理失败但 Offset 已提交) |
| ❌ "同一个 Consumer Group 可以无限扩容" | ✅ Consumer 并行度上限 = Topic Partition 数。Consumer 数 > Partition 数时,多余的 Consumer 空闲 |
| ❌ "Rebalance 是无害的" | ✅ Rebalance 期间整个 Consumer Group 停止消费。应避免频繁加入/退出 Consumer,使用 Sticky 策略减少影响 |
| ❌ "Kafka 消息永远不会丢" | ✅ 生产者端可能丢(acks=0/1、异步发送无回调)、Broker 端可能丢(acks=all 但 ISR=1)、Consumer 端可能丢(先 ack 后处理) |
| ❌ "Consumer 处理慢就增加 max.poll.records" | ✅ 处理慢应优化业务逻辑或增加 Consumer 实例。max.poll.records 过大导致单次处理时间超过 max.poll.interval.ms,Consumer 被踢出组 |
5.3 选型建议
When to use Kafka:
- 高吞吐日志/事件流(> 10万 QPS)
- 需要消息持久化和回溯消费
- 多消费者组独立消费同一份数据
- 流处理场景(与 Flink/Spark Streaming 集成)
When NOT to use Kafka(考虑 RabbitMQ / Pulsar):
- 需要复杂路由(Topic/Queue 动态绑定)
- 需要优先级队列
- 需要延迟消息(Kafka 原生不支持,需额外实现)
- 消息体极小且延迟要求极低(< 1ms)
6. 高频问题怎么答?
Q1: Kafka 为什么比 RabbitMQ 吞吐量高?顺序写磁盘为什么比随机写内存还快?
简要答案:
Kafka 高吞吐的核心原因:
- 顺序写磁盘:机械硬盘顺序写约 100MB/s,接近内存随机写;Kafka 将消息追加到文件末尾,纯顺序写
- 零拷贝(Zero-Copy):使用
sendfile()减少数据拷贝次数 - 批量处理:生产者批量发送、消费者批量拉取,减少网络 RTT
- 页缓存(Page Cache):数据先写入 OS 页缓存,由操作系统异步刷盘,生产者不等待磁盘 IO
- 无消费确认回写:消费者只是移动 Offset,不像 RabbitMQ 需要逐条 ACK 修改队列状态
类比:顺序写磁盘就像在高速公路上直线行驶,速度可以很快;随机写内存就像在城市里频繁转弯停车,反而更慢。
Q2: ISR 收缩后,如果 Leader 宕机,没有 ISR 成员怎么办?unclean.leader.election 该开还是关?
简要答案:
如果 ISR 为空(Leader 宕机,且所有 Follower 都因滞后被踢出 ISR),此时:
unclean.leader.election.enable=false(默认):不选举新 Leader,该 Partition 不可用,直到旧 Leader 恢复或有 Follower 追上重新进入 ISR。保证数据不丢,牺牲可用性。unclean.leader.election.enable=true:允许 OSR 中的 Follower 竞选 Leader。恢复可用性,但可能丢失数据(该 Follower 可能缺少部分消息)。
大型加密货币交易所 等金融场景的推荐配置:
- 核心资金/风控 Topic:
unclean.leader.election.enable=false,宁可不可用也不能丢消息 - 监控/日志 Topic:
unclean.leader.election.enable=true,可用性优先
Q3: Consumer Group Rebalance 的详细流程是什么?如何减少 Rebalance 的影响?
简要答案:
Rebalance 流程(Coordinator 协调):
- Consumer 发送
JoinGroup请求给 Coordinator - Coordinator 等待
session.timeout.ms,收集所有成员的加入请求 - 选出一个 Consumer 作为 Leader,发送成员列表给 Leader
- Leader 根据分配策略计算 Partition 分配方案
- Leader 发送
SyncGroup携带分配方案给 Coordinator - Coordinator 将方案广播给所有成员
- 各 Consumer 按方案开始消费
减少 Rebalance 影响的策略:
- 避免频繁扩缩容:Consumer 实例稳定运行,不要频繁启停
- 增加
session.timeout.ms:给 Consumer 更多心跳容错时间(但会增加故障检测延迟) - 使用 Sticky / Cooperative Sticky Assignor:尽量保持原有分配,减少 Partition 迁移
- 处理逻辑轻量:
poll()后尽快处理完毕,避免因处理慢导致心跳超时 - 独立线程处理:在
poll()后将消息交给线程池异步处理,主线程继续poll()维持心跳
Q4: Kafka 的 Exactly-Once 语义怎么实现?为什么说 Exactly-Once 其实是有条件的?
简要答案:
Kafka 的 Exactly-Once(EOS)需要三个条件共同配合:
-
幂等生产者(Idempotent Producer):
enable.idempotence=true。Broker 端去重,保证单分区、单会话内消息不重复。- 原理:Producer 为每条消息分配
PID(Producer ID)+Sequence Number,Broker 记录每个 PID-Partition 的最大 SeqNum,重复的消息被丢弃。
- 原理:Producer 为每条消息分配
-
事务(Transaction):跨 Partition 的原子写入。
initTransactions()→beginTransaction()→send()→commitTransaction()- 配合 Consumer 的
isolation.level=read_committed,只读取已提交的事务消息
-
消费者端幂等:即使生产者 EOS,Consumer 处理消息后如果崩溃且 Offset 未提交,重启后仍会重新消费(At-Least-Once)。因此 Consumer 的业务逻辑本身必须是幂等的。
为什么说 "有条件":
- 幂等生产者只在 单会话内 有效(Producer 重启后 PID 会变)
- Exactly-Once 是 "端到端" 的,如果 Consumer 处理消息后写入外部系统(如 MySQL),且 MySQL 写入与 Kafka Offset 提交不是原子的,仍可能重复或丢失
- Kafka Streams 通过 事务性 Offset 提交 实现了端到端 Exactly-Once,但普通 Consumer 需要自己保证幂等
Q5: Kafka 的日志保留策略有哪些?Compaction 适用于什么场景?
简要答案:
Kafka 提供两种日志保留策略:
| 策略 | 配置项 | 行为 | 适用场景 |
|---|---|---|---|
| 时间保留 | log.retention.hours (默认 168 = 7天) / log.retention.minutes | 超过时间的 Segment 被删除 | 普通日志、事件流 |
| 大小保留 | log.retention.bytes | 超过大小的旧 Segment 被删除 | 磁盘容量受限的场景 |
| 日志压缩 | cleanup.policy=compact | 保留每个 Key 的最新值,删除旧值 | Key-Value 更新流(如配置变更、用户资料) |
Compaction 详解:
- Compaction 不是删除整个 Topic,而是对相同 Key 的消息只保留最新版本
- 有一个 "压缩点"(Log Head / Log Tail 分界),Head 是活跃的写入区域,Tail 是已压缩区域
- 适合场景:用户资料变更、风控规则配置、汇率更新等 "状态快照" 类 Topic
- 不适合:纯追加的日志、事件流(因为没有 Key 或不需要更新旧值)
Q6: 为什么 Kafka Consumer 是 Pull 模式而不是 Push 模式?有什么好处?
简要答案:
Kafka Consumer 采用 Pull(拉取) 模式,而 RabbitMQ 等采用 Push(推送) 模式。
Pull 模式的优势:
- 消费速率自控:Consumer 根据自己的处理能力决定拉取多少消息,不会被 Broker 的推送速率压垮
- 批量拉取优化:Consumer 可以一次拉取一批消息(
fetch.min.bytes/fetch.max.wait.ms),减少网络请求次数 - 简化 Broker 设计:Broker 不需要维护每个 Consumer 的消费状态,只负责存储和响应拉取请求
- 便于回溯消费:Consumer 可以自主决定从哪个 Offset 开始消费(earliest / latest / specific offset)
缺点:
- 如果队列中无消息,Consumer 会空轮询(Kafka 通过
fetch.max.wait.ms让 Consumer 阻塞等待,减少空轮询)
Q7: 在 大型加密货币交易所 全球化部署中,Kafka 集群应该如何规划?跨地域复制怎么做?
简要答案:
集群规划:
- 地域隔离:每个主要地域(如新加坡、东京、法兰克福)部署独立的 Kafka Cluster,服务本地业务
- 就近生产:Producer 将消息发送到本地域的 Kafka,避免跨地域网络延迟(> 100ms)
- 跨地域复制:对于需要全局一致的数据(如用户黑名单、全局风控规则),使用 MirrorMaker 2.0 或 Confluent Replicator 进行单向/双向复制
跨地域复制策略:
- 风控规则 Topic:从中心集群(如新加坡)向边缘集群单向复制,
acks=1降低延迟 - 交易事件 Topic:各本地域独立写入,不跨地域复制(数据量太大,且各地域只需处理本地交易)
- 全局告警 Topic:边缘集群向中心集群汇总,中心集群做全局关联分析
容灾考虑:
- 单地域内 Kafka Cluster 部署在多个可用区(AZ),Broker 分布在不同 AZ
- 使用
min.insync.replicas=2+replication.factor=3,保证单 AZ 故障不丢消息 - 跨地域层面,关键数据在异地有异步备份,RPO(恢复点目标)在秒级到分钟级
7. 还要关联学什么?
- D2 - Kafka 高级特性:幂等生产者、事务消息、顺序消息、积压处理
- D3 - Kafka vs RabbitMQ:架构差异、选型决策树
- D6 - 消息可靠性:Exactly-Once 全链路保障、消息不丢失、不重复
- E2 - 实时风控系统:风控事件接入 Kafka 的链路设计
- B4 - CAP/BASE:Kafka 在一致性和可用性上的权衡(默认可用性优先,可配置为一致性优先)