Kafka 架构通识:分区日志、副本 ISR 与消费者组

Kafka 架构通识:分区日志、副本 ISR 与消费者组

Hello,我是小兔大白糖。 读完能复述分区并行、ISR 与 ACK 的可靠/性能权衡,以及 Consumer Group 再均衡敏感点。

Kafka是分区追加日志:并行靠分区,可靠靠 ISR/ACK,消费靠 Consumer Group 再均衡合同。

估计阅读时间:61 分钟

生产、分区日志与消费者组
生产、分区日志与消费者组 · 点击查看 SVG 原图

目标:深入掌握 Kafka 原理,成为 Kafka 专家


目录


1. 核心概念与架构

1.1 Kafka 架构概览

kafka architecture basics · 图 2
kafka architecture basics · 图 2 · 点击查看 SVG 原图

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 分区分配原则

kafka architecture basics · 图 3
kafka architecture basics · 图 3 · 点击查看 SVG 原图

核心规则:

1. 一个分区只能被同一个 Consumer Group 的一个 Consumer 消费
2. 不同 Consumer Group 可以消费同一个分区(广播模式)
3. Consumer 数量 > 分区数量时,多余的 Consumer 空闲

2.2 分区数 vs Consumer 数关系

场景分区数Consumer 数结果
正常63每个 Consumer 消费 2 个分区
Consumer 不足62每个 Consumer 消费 3 个分区
Consumer 过多696 个 Consumer 消费分区,3 个空闲
1:1 映射33每个 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 策略

kafka architecture basics · 图 4
kafka architecture basics · 图 4 · 点击查看 SVG 原图

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 消费者提交策略

kafka architecture basics · 图 5
kafka architecture basics · 图 5 · 点击查看 SVG 原图
模式配置风险
自动提交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 分区保证顺序

kafka architecture basics · 图 6
kafka architecture basics · 图 6 · 点击查看 SVG 原图

4.3 单分区单线程保证强顺序

kafka architecture basics · 图 7
kafka architecture basics · 图 7 · 点击查看 SVG 原图

4.4 顺序性保障方案对比

方案实现适用场景吞吐
单分区单线程1 分区 + 1 Consumer金融交易等强顺序低
按 Key 分区 + 同 Key 串行多分区 + key 分组订单等业务中
最终一致 + 版本校对多分区 + 版本号高并发场景高

5. Rebalance 机制

5.1 Rebalance 触发条件

kafka architecture basics · 图 8
kafka architecture basics · 图 8 · 点击查看 SVG 原图

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 = 15000

6. 分区策略与 Key 设计

6.1 分区选择算法

kafka architecture basics · 图 9
kafka architecture basics · 图 9 · 点击查看 SVG 原图

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 幂等性

kafka architecture basics · 图 10
kafka architecture basics · 图 10 · 点击查看 SVG 原图

7.2 幂等 Producer 配置

# 启用幂等性
enable.idempotence=true

# 防止因重试导致的消息乱序
max.in.flight.requests.per.connection=5

# 合理设置重试次数
retries=2147483647

# Delivery Timeout
delivery.timeout.ms=120000

7.3 Exactly-Once 语义

语义说明实现方式
At-least-once至少一次,可能重复自动重试 + 幂等消费
At-most-once至多一次,可能丢消息不重试 + 自动提交
Exactly-once恰好一次,不丢不重复事务 API + 幂等生产

7.4 幂等消费实现:Redis + DB 双写

kafka architecture basics · 图 11
kafka architecture basics · 图 11 · 点击查看 SVG 原图
// 幂等检查伪代码
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  # 50MB

8.2 Producer 优化

# 批量发送
batch.size=16384
linger.ms=10
buffer.memory=33554432

# 压缩
compression.type=snappy

# ACK 策略
acks=all
retries=2147483647

# 幂等性
enable.idempotence=true

8.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=15000

8.4 集群拓扑设计

kafka architecture basics · 图 12
kafka architecture basics · 图 12 · 点击查看 SVG 原图

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 高吞吐场景

kafka architecture basics · 图 13
kafka architecture basics · 图 13 · 点击查看 SVG 原图

9.2 低延迟场景

# Producer 优化
linger.ms=0
batch.size=0
compression.type=none

# Consumer 优化
fetch.min.bytes=1
fetch.max.wait.ms=0

9.3 消息优先级

kafka architecture basics · 图 14
kafka architecture basics · 图 14 · 点击查看 SVG 原图

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 \
  --list

10.3 常见问题排查

问题原因解决方案
消息丢失ACK 配置不当改为 acks=all
消息重复网络重试启用幂等消费
消费延迟Consumer 不足增加 Consumer 实例
Rebalance 频繁心跳超时调整 session.timeout
分区不均衡分区分配策略使用 StickyAssignor

附录:配置速查表

Producer 配置

配置项推荐值说明
acksall强可靠性
retries2147483647充分重试
enable.idempotencetrue幂等生产
batch.size16384 (16KB)批量发送
linger.ms10等待批量
compression.typesnappy压缩

Consumer 配置

配置项推荐值说明
enable.auto.commitfalse手动同步提交
auto.offset.resetlatest从最新消费
session.timeout.ms45000较长超时
heartbeat.interval.ms15000频繁心跳
max.poll.records500批量拉取

下一步:业务场景实战

建议阅读配套文档 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 订阅消息的"主题分类",类似数据库的表名
PartitionTopic 的物理分片,每个 Partition 是一个有序的、不可变的消息序列实现并行处理的单元,Partition 数决定消费者并行度上限
Offset消息在 Partition 内的唯一递增序号(逻辑位置)消费者的"书签",记录读到了哪里
ReplicaPartition 的副本,同一 Partition 的多个 Replica 分布在不同 Broker保证高可用,Leader 负责读写,Follower 同步数据
ISRIn-Sync Replicas,与 Leader 保持同步的副本集合"靠谱副本名单",只有 ISR 中的成员才有资格竞选 Leader
LEOLog End Offset,副本最后一条消息的 Offset副本的"写入进度"
HWHigh Watermark,所有 ISR 副本都已同步的最大 Offset消费者可见的安全边界,HW 之前的消息才算"已提交"
ACK生产者收到 Broker 的确认级别(0/1/all)可靠性配置:不等确认 / 等 Leader 确认 / 等所有 ISR 确认

1.2 为什么需要 Kafka

在传统的企业级系统中,系统间的通信往往采用 点对点直连 或 集中式 ESB(企业服务总线):

  • 直连:A 系统直接调 B 系统的 HTTP/RPC 接口。问题是耦合严重、流量突发时下游被压垮、故障扩散
  • ESB:集中式消息总线。问题是中心节点成为性能瓶颈,扩展困难

Kafka 的诞生解决了三个核心痛点:

  1. 解耦:生产者和消费者互不知道对方存在,通过 Topic 间接通信
  2. 削峰填谷:消息先写入 Kafka,消费者按自己的速率消费,流量高峰被平滑
  3. 高吞吐持久化:顺序写磁盘 + 批量处理,单节点可达数十万 QPS,数据持久化后仍可被多个消费者组独立消费

类比理解:Kafka 就像城市的高速公路系统。Topic 是不同方向的高速公路(如"京藏高速"),Partition 是公路的车道(多条车道并行),Offset 是你在公路上的里程牌,Consumer Group 是不同目的地的车队(去北京的车队、去内蒙古的车队各自独立行驶)。


2. 核心原理是什么?

2.1 生产者端架构:分区、序列化与发送流程

消息路由到 Partition 的策略

生产者发送消息时,必须确定消息进入哪个 Partition:

策略行为适用场景
指定 Partition直接写入指定 Partition需要严格顺序保证的业务(如订单状态变更)
指定 Keyhash(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 → 物理位置 的映射

查找消息流程:

  1. 根据目标 offset,通过二分查找定位到对应的 Segment 文件
  2. 在 .index 文件中找到不大于目标 offset 的最大索引条目
  3. 从该索引条目对应的物理位置开始顺序扫描 .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 的所有副本集合
ISRAR 中与 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 触发条件

  1. 组成员变化:消费者加入或离开组
  2. 订阅主题变化:消费者订阅了新的 Topic
  3. 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 图解:消息生产与消费完整流程

kafka architecture basics · 图 15
kafka architecture basics · 图 15 · 点击查看 SVG 原图

2.6 图解:Broker 分段日志与索引结构

kafka architecture basics · 图 16
kafka architecture basics · 图 16 · 点击查看 SVG 原图

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
  • 峰值吞吐量达到 每秒千万级消息

关键实践:

  1. Exactly-Once 语义落地:LinkedIn 在 Kafka 0.11 引入幂等生产者和事务 API 后,立即在生产环境启用。其核心场景是 "用户行为事件" 与 "数据库变更" 的一致性 —— 确保用户资料更新和对应的事件通知要么都成功,要么都失败。

  2. MirrorMaker 跨机房复制:LinkedIn 使用 Kafka MirrorMaker 将数据从美国东海岸复制到西海岸,实现灾备。风控相关实践:只复制关键 Topic(而非全部),并设置 acks=1 降低跨地域延迟。

  3. 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 实践的核心改造:

  1. 多副本同步策略优化:阿里发现原生 Kafka 的 ISR 机制在跨机房场景下性能不佳(等待远距离 Follower 确认导致延迟飙升)。他们引入了 "异步复制 + 主从自动切换" 的策略:同城机房内 acks=all,跨机房使用异步复制,牺牲部分一致性换取可用性。

  2. Broker 无状态化改造:阿里将 Kafka Broker 的元数据管理从 ZooKeeper 迁移到自研的 ConfigServer,解决了 ZK 在百万级 Partition 下的性能瓶颈。这与 Kafka 3.0 后的 KRaft 模式(去除 ZooKeeper)思路一致。

  3. Consumer Group 水平扩展限制:双十一期间,某风控 Consumer Group 需要扩容到 100+ 消费者,但 Topic 只有 64 个 Partition,导致部分消费者空闲。阿里的解决方案是:

    • 增加 Partition 数(提前扩容到 256 个)
    • 引入二级消费者:一级消费者只做简单过滤和路由,将消息分发到多个二级 Topic,二级 Consumer Group 消费处理
  4. 消息积压快速恢复:某年双十一凌晨,由于下游风控系统故障,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.tradeKey = user_id(保证用户顺序)acks=all + 幂等低延迟优先,自动提交改为手动,批量 10 条
用户登录/行为日志risk.events.loginKey = user_idacks=1高吞吐,批量 500 条,允许秒级延迟
风控规则变更通知risk.config.changes单 Partition(全局有序)acks=all单消费者或广播模式,必须全部接收
离线特征计算结果risk.features.batchRoundRobinacks=1批量消费,高吞吐,容忍分钟级延迟
风控告警/阻断指令risk.alertsKey = alert_idacks=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 高吞吐的核心原因:

  1. 顺序写磁盘:机械硬盘顺序写约 100MB/s,接近内存随机写;Kafka 将消息追加到文件末尾,纯顺序写
  2. 零拷贝(Zero-Copy):使用 sendfile() 减少数据拷贝次数
  3. 批量处理:生产者批量发送、消费者批量拉取,减少网络 RTT
  4. 页缓存(Page Cache):数据先写入 OS 页缓存,由操作系统异步刷盘,生产者不等待磁盘 IO
  5. 无消费确认回写:消费者只是移动 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 协调):

  1. Consumer 发送 JoinGroup 请求给 Coordinator
  2. Coordinator 等待 session.timeout.ms,收集所有成员的加入请求
  3. 选出一个 Consumer 作为 Leader,发送成员列表给 Leader
  4. Leader 根据分配策略计算 Partition 分配方案
  5. Leader 发送 SyncGroup 携带分配方案给 Coordinator
  6. Coordinator 将方案广播给所有成员
  7. 各 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)需要三个条件共同配合:

  1. 幂等生产者(Idempotent Producer):enable.idempotence=true。Broker 端去重,保证单分区、单会话内消息不重复。

    • 原理:Producer 为每条消息分配 PID(Producer ID) + Sequence Number,Broker 记录每个 PID-Partition 的最大 SeqNum,重复的消息被丢弃。
  2. 事务(Transaction):跨 Partition 的原子写入。

    • initTransactions() → beginTransaction() → send() → commitTransaction()
    • 配合 Consumer 的 isolation.level=read_committed,只读取已提交的事务消息
  3. 消费者端幂等:即使生产者 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 模式的优势:

  1. 消费速率自控:Consumer 根据自己的处理能力决定拉取多少消息,不会被 Broker 的推送速率压垮
  2. 批量拉取优化:Consumer 可以一次拉取一批消息(fetch.min.bytes / fetch.max.wait.ms),减少网络请求次数
  3. 简化 Broker 设计:Broker 不需要维护每个 Consumer 的消费状态,只负责存储和响应拉取请求
  4. 便于回溯消费:Consumer 可以自主决定从哪个 Offset 开始消费(earliest / latest / specific offset)

缺点:

  • 如果队列中无消息,Consumer 会空轮询(Kafka 通过 fetch.max.wait.ms 让 Consumer 阻塞等待,减少空轮询)

Q7: 在 大型加密货币交易所 全球化部署中,Kafka 集群应该如何规划?跨地域复制怎么做?

简要答案:

集群规划:

  1. 地域隔离:每个主要地域(如新加坡、东京、法兰克福)部署独立的 Kafka Cluster,服务本地业务
  2. 就近生产:Producer 将消息发送到本地域的 Kafka,避免跨地域网络延迟(> 100ms)
  3. 跨地域复制:对于需要全局一致的数据(如用户黑名单、全局风控规则),使用 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 在一致性和可用性上的权衡(默认可用性优先,可配置为一致性优先)