Kafka 的设计起点不是"队列",而是"日志"。这一取向决定了它的存储模型、消费模型与可靠性的实现方式,也决定了它在整套消息中间件里承担的分工。

一、起源:日志型消息系统的设计出发点

1.1 从队列到日志

传统队列的模型是"投递即出队":消息被消费者确认后从队列中删除,队列的长度反映的是待处理工作量。Kafka 的模型是"顺序追加的日志":消息写入分区末尾,读取方按偏移量自行推进,消息不因被读取而删除,只由保留策略按时间或大小清理。

两种模型带来两类能力差异:

  1. 队列模型面向"任务分发",核心指标是待处理消息数与投递可靠性
  2. 日志模型面向"数据流",核心能力是可重复读取、可多个独立读取方各自推进、可按时间回放

日志模型把"消费进度"从服务端状态(队列中消息是否还在)转化为客户端状态(读取到哪个偏移量),服务端因此不必为每个消费者维护投递状态,这是 Kafka 支持大量消费者组同时读取同一份数据的结构性原因。

1.2 顺序追加写

分区日志在磁盘上是一个只允许追加的文件。写入操作固定发生在文件末尾,配合以下两点获得吞吐:

  1. 段文件滚动:日志按大小或时间切分为段,写入始终落在最后一个段,段写满后新建段继续追加,历史段只读
  2. 顺序写的物理优势:顺序写只需定位一次磁头轨道后持续写入,随机写需要反复寻道;在机械盘上两者的吞吐差异可达两个数量级

顺序写解决的是"写入放大",批量解决的是"单条消息的固定开销"。

1.3 批量传输与页缓存

单条消息的网络往返、协议头解析、磁盘寻道开销都无法通过顺序写摊薄,因此 Kafka 在生产者、Broker、消费者三段都采用批量:

  1. 生产端按 batch.size 与 linger.ms 聚合成批后再发送
  2. Broker 按批落盘,一批消息在一次追加中写入
  3. 消费者按批拉取,批量返回

Broker 自身不在 JVM 堆中缓存消息数据,而是依赖操作系统的页缓存:

  1. 写入时数据先进入页缓存,由内核按脏页回写策略刷盘,进程无需等待
  2. 读取时若命中页缓存则不经磁盘,近期写入的数据通常仍驻留内存,因此"刚写入就被消费"的场景几乎不产生读磁盘开销
  3. 数据不受 JVM 垃圾回收管理,避免了堆内大对象带来的停顿

页缓存的读写路径、脏页回写与 fsync 语义参见 ../../../../linux/base/page_cache_and_io_performance.html。

1.4 与传统队列的分工

按语义划分,两类系统的适用场景如下:

需求特征 日志型(Kafka) 队列型(RabbitMQ)
吞吐量 十万级至百万级消息每秒(批量、顺序写、零拷贝) 万级至十万级消息每秒
单条延迟 毫秒级,受批量与刷盘策略影响 微秒级至毫秒级
重复读取 原生支持,位点可重置、可回放 不支持,消息确认后删除
路由能力 仅主题与分区,无交换机模型 多种交换机类型,路由灵活
延迟消息 需外部方案或自行实现 TTL 加死信或延迟插件
典型场景 日志采集、埋点、CDC、事件溯源、流处理 业务解耦、任务分发、RPC 回调、复杂路由

两类系统并非替代关系:同一系统内常见 Kafka 承载数据流与事件总线,RabbitMQ 承载业务动作与任务分发。AMQP 侧的模型定义与协议细节参见 ../../theoreticalbasis/amqp.html,RabbitMQ 侧的机制与实践参见 ../rabbitmq/rabbitmq.html,差异对照见本文 3.7。

二、原理

2.1 架构与组件

Broker

Broker 是 Kafka 的服务进程,负责存储分区副本、响应生产与消费请求。集群由多个 Broker 组成,每个 Broker 以唯一的 broker.id(KRaft 模式下为 node.id)标识。客户端只需在 bootstrap.servers 中配置若干节点地址,连接后由 Broker 返回集群完整元数据,不要求列全所有节点。

Controller

集群中有一个 Broker 承担 Controller 角色,负责分区 Leader 选举、分区分配、副本重分配、主题创建与分区扩容等元数据变更。Controller 是管理平面的唯一决策者,因此"ActiveControllerCount 应恒等于 1"是集群健康的基本判据。

Topic 与 Partition

Topic 是逻辑分类,Partition 是物理分片,也是 Kafka 的基本存储与并行单位:

  1. 一个分区是一份独立的有序日志,分区内消息严格有序
  2. 主题内不保证全局有序,跨分区的顺序需要业务自行约束
  3. 分区数决定同组消费者的并行度上限:同组内一个分区只会被一个消费者消费
  4. 一个分区的副本只落在集群中的一台 Broker 上,分区是副本分配与迁移的粒度

Replica

每个分区拥有 replication.factor 个副本,其中一个是 Leader,其余为 Follower。同一分区的不同副本分布在不同的 Broker 上,同一 Broker 上同一分区不会承载两个副本。

ZooKeeper 模式与 KRaft 模式的差别

维度 ZooKeeper 模式 KRaft 模式
元数据存储 目录树节点(/brokers、/controller、/config 等) 内部元数据日志 __cluster_metadata 与快照
Controller 选举 通过 ZooKeeper 临时节点抢占 Controller 节点间通过 Raft 仲裁选举
部署组件 Kafka 集群加 ZooKeeper 集群(或外部 ZK) 仅 Kafka 进程,Controller 角色可与 Broker 合并或独立
Controller 故障切换 依赖 ZK 会话超时,通常需数秒至数十秒 Raft 仲裁选举,切换时间在秒级
分区规模上限 受元数据写入与 ZK 节点规模限制,数万分区级 元数据按日志追加与快照压缩,可支撑数十万分区
版本演进 2.8 之前唯一方式,4.0 起移除 2.8 引入,3.3 起具备生产可用性

KRaft 的部署形态有三种:仅 Broker 节点、仅 Controller 节点、以及两者合并的 combined 节点。生产环境推荐 3 个独立 Controller 节点(Raft 多数派要求奇数)加若干 Broker 节点;小规模场景可用 3 个 combined 节点。ZooKeeper 到 KRaft 的迁移由 ZooKeeperMigrationTool 完成,属不可逆的元数据迁移操作。

元数据管理

元数据包括主题定义与配置、分区与副本分配、Leader 与 ISR 状态、动态配置、ACL、消费者组与事务状态等:

  1. 主题、分区、副本分配、配置变更属于集群元数据,由 Controller 决策后广播到所有 Broker,并持久化在元数据存储中
  2. 消费者组位点与组成员存放在内部主题 __consumer_offsets(默认 50 个分区)
  3. 事务状态存放在内部主题 __transaction_state
  4. __consumer_offsets 与 __transaction_state 是普通主题,它们的 Leader 所在 Broker 分别充当对应组、事务的协调者(Coordinator)

2.2 存储与日志结构

分区目录与分段文件

每个分区副本对应 log.dirs 下名为 <topic>-<partition> 的一个目录(主题名中的特殊字符会被转义),目录内是若干段文件:

  1. <baseOffset>.log:消息数据文件,命名为该段第一条消息的偏移量
  2. <baseOffset>.index:偏移量索引,映射"相对偏移量 → 物理文件位置"
  3. <baseOffset>.timeindex:时间戳索引,映射"时间戳 → 相对偏移量"
  4. leader-epoch-checkpoint:Leader 纪元与起始偏移的记录,用于副本截断时判断数据分叉点
  5. partition.metadata:KRaft 模式下记录分区使用的元数据版本

段的大小由 segment.bytes(默认 1GB)控制,滚动的最大时间间隔由 segment.ms 控制。索引采用稀疏方式:每写入 log.index.interval.bytes(默认 4096 字节)数据才追加一条索引项,因此索引文件远小于数据文件。索引通过 mmap 映射到内存,因此需要保证 vm.max_map_count 足够大。

偏移量的含义

偏移量(offset)是消息在分区内的单调递增位置编号:

  1. 逻辑定位:偏移量只表示"第几条",不携带时间、业务主键等含义,也不要求连续(日志压实后会出现空洞)
  2. LEO(Log End Offset):分区日志末尾的下一个可用偏移量,即写入位置
  3. logStartOffset:日志起始偏移量,随保留策略删除或按偏移量删除而前移
  4. 已提交位点:消费者组提交的消费进度,语义是"下一条待消费消息的偏移量"

消费者位点小于 logStartOffset 时,请求的偏移量已不存在,auto.offset.reset 决定是跳到最早(earliest)还是最新(latest)可用位置。按偏移量读取的定位流程为:按 baseOffset 定位段、二分偏移索引得到最近的物理位置、从该位置顺序扫描解压直到目标偏移量。

顺序写与页缓存

Kafka 的写入路径为:网络线程接收请求放入队列、IO 线程批量追加到当前活动段的页缓存、按 log.flush.interval.messages 与 log.flush.interval.ms(默认不强制刷盘,交由内核回写)决定是否 fsync。可靠性由多副本而非单机刷盘保证:acks=all 的确认意味着数据已写入多个副本的页缓存,而非已落盘,因此整机掉电(所有副本同时失效)仍可能丢失最近数据,这属于机房级故障的范畴。

零拷贝与批量发送

读取路径的优化集中在减少数据在内核缓冲区与用户态之间的搬运次数:

  1. 消费者请求的数据位于页缓存时,Broker 使用 sendfile 系统调用把页缓存中的字节直接送入套接字缓冲区,省去内核态到用户态的两次拷贝与用户态缓冲区开销,即零拷贝
  2. 零拷贝对已按批次压缩存储的数据最为有效,整批字节原样传输;若 Broker 需要修改数据(例如 compression.type 配置为转换压缩格式、或为兼容旧版本客户端做消息格式降级转换),则必须解压重写,退化为普通读写路径
  3. 消费者拉取受 fetch.min.bytes 与 fetch.max.wait.ms 制约:Broker 攒够一定字节数或等待时间到达才响应,用少量延迟换取更大的传输批次

2.3 副本机制

Leader 与 Follower

  1. 生产者写入与消费者读取都只面向 Leader,Follower 不对外提供服务
  2. Follower 以消费者身份向 Leader 发起 fetch 请求主动拉取数据,持续追赶 Leader 的 LEO
  3. 只有写入 Leader 并经副本同步确认的消息,才推进高水位(HW,High Watermark);消费者只能读到 HW 之前的消息,从而不会读到可能在 Leader 切换中丢失的数据
  4. Leader Epoch 为每个 Leader 任期编号,副本截断时依据纪元判断分叉位置,避免旧版本依靠 HW 截断造成的数据不一致

ISR 的含义与收缩

ISR(In-Sync Replica)是与 Leader 保持同步的副本集合,始终包含 Leader。判定标准是时间而非条数:Follower 的 LEO 落后 Leader 超过 replica.lag.time.max.ms(默认 30000 毫秒)未追上,即被移出 ISR;追赶上来后重新加入。

ISR 收缩是可靠性的预警信号,常见成因:

  1. Follower 磁盘 I/O 饱和,写入速度低于 Leader 的写入速度
  2. 跨机架、跨机房复制带宽不足
  3. Follower 所在 Broker 出现长时间 GC 停顿或负载过高
  4. 数据分布倾斜,个别分区写入量远高于其他分区

acks 与 min.insync.replicas 的组合

生产者确认级别与最小同步副本数的组合决定可靠性与可用性的边界:

acks min.insync.replicas 行为 风险
0 不参与 发送即认为成功,不等待任何确认 网络异常时静默丢失
1 不参与 Leader 写入即确认 Leader 故障且数据未复制时丢失
all(-1) 1 至少 Leader 确认 等价于副本因子层面的弱保证,允许 ISR 仅剩 Leader 时仍可写
all(-1) 2(副本因子 3) ISR 中至少 2 个副本写入成功才确认 剩余副本不足 2 时拒绝写入,抛出 NotEnoughReplicasException

min.insync.replicas 仅在 acks=all 时生效。设置为 2 意味着容忍 1 个副本故障且不丢已确认消息,同时以"ISR 不足时拒绝写入"换取一致性,这是可用性向一致性的让渡点。副本因子为 3、min.insync.replicas 为 2 是生产环境的常见组合。Kafka 3.0 起生产端默认 acks=all 且默认开启幂等。

Leader 选举与可用性

分区 Leader 失效时,由 Controller 从 ISR 中挑选新 Leader(通常取 ISR 列表中的第一个副本),由于候选者已同步全部已提交数据,切换不丢消息。

ISR 为空(所有 Follower 都落后)时的处理方式由 unclean.leader.election.enable 决定:

  1. 默认 false:分区保持不可用,等待原 Leader 恢复或 ISR 中的副本追平,可用性让位于一致性
  2. 设置为 true:允许非同步副本成为 Leader,分区恢复可用,但未同步的数据被永久丢弃,且新 Leader 的日志与旧 Leader 产生分叉

可用性量化:副本因子为 3、min.insync.replicas 为 2 时,集群可容忍 1 台 Broker 故障且保持读写;若 min.insync.replicas 为 1,则可容忍 2 台故障但已确认消息可能在切换中丢失。

2.4 生产者

分区策略

消息写入哪个分区由分区器决定,优先级顺序为:

  1. 指定分区:显式传入分区号,用于业务自行控制落点(需自行承担分区不存在与分布不均的后果)
  2. 按键哈希:指定 key 时,使用 murmur2 哈希对分区数取模,相同 key 恒定落到同一分区,从而保证同一业务主键的消息分区内有序;分区数变化会改变映射关系,破坏这一保证
  3. 无 key:早期版本使用轮询,逐个分区轮转;Kafka 2.4 起改为粘性分区策略,尽量把消息填满同一个批次后再切换分区,减少小批次的产生

批量与压缩

参数 默认值 作用与取舍
batch.size 16384 字节 单分区的批次大小上限,调大可提升吞吐,过大则占用更多内存与增加延迟
linger.ms 0 批次发送前的等待时间,调大提升压缩率与吞吐,代价是端到端延迟增加
compression.type none 可选 gzip、snappy、lz4、zstd,压缩在客户端完成,Broker 按压缩批次原样存储
buffer.memory 33554432 字节 生产者可用于缓冲待发送数据的总内存,写满后阻塞或抛异常
max.request.size 1048576 字节 单个请求大小上限,需与 Broker 端的 message.max.bytes、socket.request.max.bytes 匹配

压缩在批次级别生效,压缩率与批次大小正相关,因此压缩配置通常与 linger.ms 一起调整。压缩后的批次在 Broker 端无需解压即可落盘与零拷贝传输,是吞吐提升的主要来源之一。

重试与幂等生产者

网络抖动、Leader 切换、超时都会触发生产者重试,重试带来两个后果:重复消息与乱序。

  1. retries 控制重试次数,retry.backoff.ms 控制重试间隔,delivery.timeout.ms 限定包含重试与等待的总时长上限,超时后向上层抛出异常
  2. 幂等生产者(enable.idempotence=true,3.0 起默认开启)为每个生产者会话分配唯一 Producer ID,并为每个分区维护单调递增的序列号;Broker 按 (PID, 分区) 记录已接收的序列号,丢弃重复批次
  3. 幂等的前提是 acks=all、retries 大于 0、max.in.flight.requests.per.connection 不大于 5,且不主动开启事务冲突配置
  4. 幂等只覆盖"同一生产者会话内、单个分区"的去重;生产者重启后 PID 变化,跨会话的重复仍可能发生

乱序与最大在途请求

max.in.flight.requests.per.connection 表示每个连接上未收到响应的请求数上限,默认 5。在途请求数大于 1 时,若前一批次失败重试而后续批次已成功写入,分区内顺序被打乱;顺序与并发的取舍如下:

  1. 严格单分区有序:设置该值为 1,吞吐显著下降
  2. 兼顾顺序与吞吐:保持默认 5 并开启幂等,幂等机制会按序列号拒绝乱序写入(此时生产者收到 OutOfOrderSequenceException 并重建连接),因此"幂等加在途数不超过 5"被视为不牺牲顺序的推荐配置

事务生产者与跨分区原子写

事务用于实现"一批消息要么全部对消费者可见,要么全部不可见":

  1. 指定 transactional.id 后调用 initTransactions() 初始化,Broker 侧的 Transaction Coordinator 负责事务状态管理,状态写入 __transaction_state
  2. beginTransaction() 到 commitTransaction() 之间的多个分区、多个主题写入构成一个原子单元;abortTransaction() 使这些消息被标记为中止
  3. 消费者需设置 isolation.level=read_committed 才能过滤未提交与已中止事务的消息,默认 read_uncommitted 会读取全部消息
  4. 事务可同时提交消费位点(sendOffsetsToTransaction),使"消费—处理—生产"闭环具备精确一次语义

事务的边界必须明确:原子性只覆盖 Kafka 内部(消息写入与位点提交),写入外部数据库或调用外部接口不在事务范围内,跨系统的原子性需要靠事务性发件箱、CDC 或对端幂等来实现。

2.5 消费者与消费者组

消费者组与协调者

消费者组是消费并行的单位:同组内一个分区只被一个消费者消费,不同组的消费者互不影响且各自维护位点。组协调者(Group Coordinator)是 __consumer_offsets 中该组对应分区(hash(group.id) % 分区数)的 Leader 所在 Broker,负责组成员管理、心跳检测与位点提交。

组内通信由四个请求构成:JoinGroup(加入组)、SyncGroup(同步分配结果)、Heartbeat(心跳保活)、LeaveGroup(主动离开)。分区分配由组 Leader(第一个加入组的消费者)在客户端计算后经 SyncGroup 下发。

分区分配策略

策略 分配方式 特点
range 按主题逐个分区排序后按区间切分 订阅多个主题时,前面消费者分到的分区数偏多,易不均衡
round-robin 所有订阅分区整体轮转分配 分区分布较均匀,但重平衡时分区几乎全部重新移动
sticky 在均衡前提下尽量保留上次分配 减少重平衡时的分区迁移量
cooperative-sticky 在 sticky 基础上采用增量协作重平衡 重平衡期间只迁移需变更的分区,其余分区持续消费

Kafka 3.0 起客户端默认分配策略为 cooperative-sticky。

位点提交

位点提交是把消费进度写入 __consumer_offsets 的动作,提交的是下一条待消费消息的偏移量:

  1. 自动提交:enable.auto.commit=true(默认),由客户端按 auto.commit.interval.ms(默认 5000 毫秒)周期性提交 poll 返回的最大偏移量。风险在于提交时机与业务处理完成时机无关:处理未完成而位点已提交会造成消息丢失,处理已完成而尚未提交会造成重复消费
  2. 手动同步提交:commitSync() 阻塞等待 Broker 响应,失败可重试,适合处理完成后的关键提交;批量提交(传入分区位点映射)可减少提交次数
  3. 手动异步提交:commitAsync() 不阻塞、失败不重试,适合周期性提交;通常做法是循环内异步提交、关闭前用同步提交兜底,避免异步提交失败造成位点回退
  4. 位点提交的失败处理需要区分可重试异常(如可重试的协调者迁移)与不可重试异常(如位点越界),后者应重置位点或走异常流程

重平衡的触发条件与代价

触发条件包括:

  1. 组成员数量变化:新消费者加入、消费者主动离开、实例崩溃或心跳超时
  2. 订阅的主题集合变化:例如正则订阅匹配到了新建主题
  3. 订阅主题的分区数变化
  4. 消费者被判定失效:session.timeout.ms 内无心跳,或两次 poll 间隔超过 max.poll.interval.ms(默认 300000 毫秒)

重平衡的代价体现在三点:分配计算期间相关分区停止消费形成进度停顿;分区归属变更需要重新建立获取位置(可能触发位点重置逻辑);提交与再分配存在竞态,未提交的处理结果会以重复消息的形式重新出现。控制手段包括:调大 max.poll.interval.ms 或调小 max.poll.records 以避免处理超时被踢出;使用静态成员 group.instance.id,使实例重启在 session.timeout.ms 内不触发重平衡;采用增量协作协议减少分区迁移面。

再平衡协议演进

  1. eager(KIP-429 之前的默认行为):所有消费者先放弃全部分区,再重新分配,形成全局停顿(Stop-The-World)
  2. cooperative(KIP-429,2.4 起):分区分两阶段迁移,仅撤销需要改属的分区,未被调整的分区持续消费
  3. broker 侧协议(KIP-848):把分配计算从客户端组 Leader 移到 Broker,减少 JoinGroup 往返与客户端侧停顿,进一步缩短重平衡窗口

消费滞后(lag)

lag 是分区日志末端与消费者已提交位点之间的距离(LEO 减 已提交位点),是消费进度的核心度量:

  1. lag 稳定在较小值表示消费能力与生产速率匹配
  2. lag 持续增长表示消费速率低于生产速率,需扩容消费者或优化处理逻辑
  3. lag 突增后回落可能是生产尖峰或消费端短暂停顿
  4. lag 为负值或异常跳变通常意味着保留策略删除了未消费数据,或位点被重置

需要注意:lag 单调增加并不必然代表故障,若业务本身允许积压,应以"预计追平时间"而非绝对 lag 值作为判据。

2.6 投递语义

at-least-once 的实现方式

至少一次是 Kafka 的默认语义,产生路径有两条:

  1. 生产端:写入成功但确认丢失时重试,Broker 会再次写入同一条消息
  2. 消费端:业务处理完成但位点提交失败(或提交前进程退出),重平衡后该消息被重新投递

对应的实现要点是"处理完成后再提交位点",同时保证生产端重试不会静默失败。

at-most-once

先提交位点再处理业务,进程崩溃时未处理的消息不会重新投递,因此最多一次。适用场景极少,通常仅在允许丢弃的数据上使用。

exactly-once 的边界

Kafka 内部的精确一次由三部分组成:

  1. 幂等生产者消除生产端重试造成的重复
  2. 事务把跨分区的写入与消费位点提交绑定为一个原子单元
  3. 消费者使用 read_committed 隔离级别过滤未提交与已中止的消息

该组合覆盖"Kafka 到 Kafka"的流转链路(消费—转换—生产)。超出这一范围即失效:写入外部数据库、调用外部接口、跨集群复制、人工重放历史数据等场景,原子性无法由 Kafka 事务保证,此时仍需要在业务侧实现幂等。因此消费幂等不是与 exactly-once 互斥的选项,而是任何投递语义下都需要保留的兜底手段。

通用幂等手段(唯一约束、去重表、状态机判重、缓存标记)在此不重复展开,参见 ../../theoreticalbasis/message_reliability_and_idempotency.html,RabbitMQ 侧重复消费的处理方案参见 ../rabbitmq/rabbitmq.html;Kafka 侧的特殊之处在于重平衡与位点重置会主动制造重复,幂等键的选择应覆盖位点回退这一场景。

2.7 保留与压缩

时间与大小保留

保留策略决定消息在分区中存留多久,默认按时间清理:

配置 默认值 说明
log.retention.hours(retention.ms) 168 小时 消息保留时长
log.retention.bytes(retention.bytes) -1 分区可占用的最大字节数,-1 表示不限
log.segment.bytes(segment.bytes) 1073741824 段文件大小,删除以段为单位
log.retention.check.interval.ms 300000 清理线程的检查周期

删除的粒度是段文件,因此实际保留时间不短于配置值:一个未写满也未滚动的段不会因超过保留时间而被删除(除非同时配置了 segment.ms)。

日志压实

cleanup.policy=compact 时,后台清理线程按键合并段,只保留每个 key 的最新值:

  1. 触发条件由脏比率控制,min.cleanable.dirty.ratio(默认 0.5)表示段内可清理数据占比超过阈值后参与合并
  2. 合并保持偏移量的单调性,被合并掉的旧记录留下偏移量空洞,读取时跳过
  3. 压实与删除可组合为 delete,compact,先按时间保留再按 key 去重

tombstone

值为 null 的消息称为墓碑记录,语义为"删除该 key":

  1. 压实处理时,墓碑记录本身会在 delete.retention.ms(默认 86400000 毫秒)之后被清理
  2. 该保留窗口的作用是给下游消费者留出读到删除事件的时间,窗口过短会导致下游看不到删除而残留旧值
  3. 需要保留删除语义的场景(如状态恢复、外部同步)不能把该值设为 0 或极小值

按 key 保留最新值的场景

压实主题适合"只关心每个主键当前状态"的场景:变更数据捕获(CDC)输出、缓存预热数据、流处理的状态存储 changelog、配置分发。这类主题的容量与主键数量相关而非与写入总量相关,因此可以在固定磁盘占用下长期保留全量最新状态。

三、实现

3.1 部署要点

单机与集群

  1. 单机部署仅用于开发与功能验证,一个 Broker 无法提供副本冗余,且 min.insync.replicas 大于 1 时无法满足条件
  2. 生产集群的最小可用配置是 3 个 Broker(或 3 个 combined 节点),满足副本因子 3 与 Raft 多数派的要求
  3. Broker 数量增加后需关注分区与 Leader 在节点间是否均衡,分区数宜为 Broker 数的整数倍,避免个别节点承载过多 Leader

KRaft 与 ZooKeeper 的选择

新集群一律使用 KRaft:无需维护 ZooKeeper 集群、Controller 切换更快、元数据可支撑更大分区规模,且 4.0 起 ZooKeeper 模式已移除。已有 ZooKeeper 集群可继续运行,迁移需使用官方迁移工具并不可回退,迁移前必须完成元数据与数据快照备份。

磁盘与文件系统

  1. log.dirs 配置多个独立物理磁盘的挂载点,一个分区副本整体落在其中一个目录,多目录并行可提升总吞吐
  2. 优先使用 JBOD 而非 RAID:Kafka 自身通过副本保证冗余,RAID 的写惩罚会降低吞吐,且单盘故障时整组降级
  3. 避免使用网络存储(NFS 等)承载分区数据,网络抖动会直接造成 Follower 落后与 ISR 收缩
  4. 文件系统以 XFS 或 ext4 为主,挂载时关闭 atime 更新(noatime),减少无意义的元数据写入

JVM 与内存

  1. 堆内存按经验控制在 6 至 8GB 以内,堆越大单次 GC 停顿越长,停顿会直接造成请求超时与副本同步滞后
  2. 使用 G1 垃圾回收器,并预留时间与空间相关的参数余量;堆内存之外的物理内存留给页缓存,页缓存是读性能的主要来源
  3. 堆内存主要承载请求对象、索引与元数据,不应按"总内存减去其他进程占用"的方式分配

操作系统参数与文件句柄

# 进程文件句柄上限,需覆盖所有分区段文件、索引文件与网络连接
# /etc/security/limits.conf
kafka  soft  nofile  100000
kafka  hard  nofile  100000

# 减少换页,避免页缓存被换出后读性能下降
vm.swappiness = 1
# 降低脏页集中回写造成的写入停顿
vm.dirty_background_ratio = 5
vm.dirty_ratio = 60
# 索引文件使用 mmap,分区规模大时需要提高映射数量上限
vm.max_map_count = 262144

# 提高网络连接队列与本地端口范围
net.core.somaxconn = 1024
net.ipv4.tcp_max_syn_backlog = 1024
net.ipv4.ip_local_port_range = 10240 65535

vm.max_map_count 与方法数量成正比于分区副本总数,分区规模扩大时该值需同步调整,否则新分区创建会因 mmap 失败而报错。

线程配置

# 接收请求与发送响应的网络线程
num.network.threads=8
# 处理请求(含磁盘写入)的 IO 线程
num.io.threads=16
# 副本同步的抓取线程数,分区多时需提高
num.replica.fetchers=4
# 单个连接上响应请求的并发上限与网络缓冲区
queued.max.requests=500
socket.send.buffer.bytes=1048576
socket.receive.buffer.bytes=1048576
socket.request.max.bytes=104857600

副本分布与机架感知

  1. 为每个 Broker 配置 broker.rack,创建主题时 Kafka 会尽量把同一分区的副本分散到不同机架,避免单机架掉电造成多副本同时失效
  2. 跨机架同步产生流量成本,副本因子与机架布局需一并考虑
  3. 分区分配不均衡时使用副本重分配迁移分区,迁移过程需设置带宽限流,避免抢占业务流量

3.2 主题与分区规划

分区数估算依据

分区数决定并行度上限,估算顺序为:

  1. 确定峰值写入吞吐(字节每秒与消息条数每秒)
  2. 测量单分区可持续写入能力(受副本数、压缩、磁盘与网络影响,需以压测数据为准)
  3. 分区数取"峰值吞吐 ÷ 单分区能力"并留出余量,同时满足消费端并行度需求(分区数不小于消费者实例数上限)
  4. 分区数宜为 Broker 数的整数倍,便于均衡分布
  5. 同时评估元数据与文件句柄开销:分区副本总数受 Controller 元数据规模、vm.max_map_count、句柄上限与 Leader 选举恢复时间共同约束

副本数

生产主题的副本因子取 3,配合 min.insync.replicas=2,可容忍单节点故障且不丢已确认消息。副本数为 2 时任何单节点故障都会使 ISR 不足而拒写,不构成有效冗余;副本数大于 3 会增加同步流量与写入延迟,仅在跨机房容灾场景下考虑。

分区扩容的代价

分区数只能增加不能减少,且增加会带来两类影响:

  1. 键到分区的映射改变:默认分区器按 hash(key) % 分区数 计算落点,分区数变化后同一 key 会映射到不同分区,原有的同键有序性被打断
  2. 下游状态重分布:依赖"同键同分区"的流处理状态、按 key 压实的语义与消费端本地缓存都会失效

因此主题创建时应按未来一段时间的容量预留分区数。若必须扩容,可行路径是新建主题并迁移(保持旧主题只读直到位点对齐)、或使用自定义分区器固定映射关系;Kafka 2.4 起虽支持自定义分区器,但默认行为无法兼容扩容。

命名规范

建议按固定层级命名,便于权限与保留策略的批量管理:

<环境>.<业务域>.<数据类型>.<版本>
prod.order.order-events.v1
prod.order.order-events.v1.dlq        业务死信主题
prod.order.order-events.v1.changelog  压实后的状态主题

命名中应避免嵌入分区数与临时标记,主题名变更等同于新主题,会丢失原有位点。

分区键设计

  1. key 决定同键有序与分布均衡,二者常相互冲突:需要严格有序时以业务主键为 key,接受可能的倾斜;无需有序时可不设 key,由粘性分区策略保证均匀
  2. 低基数 key(如状态、固定枚举、少量城市)会造成热点分区,此时可加"盐"(key 加随机后缀)打散,代价是牺牲同键有序
  3. 热点隔离可用独立主题与独立分区数承载,避免单一分区拖慢整个主题的消费进度
  4. 消息体不宜携带超大 payload,大对象应先落对象存储再传递地址,避免超出 max.request.size 与 message.max.bytes 的限制并放大网络与复制开销

3.3 客户端使用

生产端关键参数与取舍

spring:
  kafka:
    bootstrap-servers: 10.0.0.21:9092,10.0.0.22:9092,10.0.0.23:9092
    producer:
      properties:
        # 可靠性与顺序的基础:全副本确认加幂等
        acks: all
        enable.idempotence: true
        # 在途请求上限,与幂等配合可在保证顺序的前提下保留并发
        max.in.flight.requests.per.connection: 5
        # 重试与总超时,delivery.timeout.ms 是包含重试的上限
        retries: 2147483647
        delivery.timeout.ms: 120000
        # 批量与压缩:吞吐与时延的取舍点
        batch.size: 65536
        linger.ms: 20
        compression.type: lz4
        # 缓冲与被阻塞时的行为
        buffer.memory: 67108864
        max.request.size: 1048576

spring.kafka.producer.properties 下的键会原样传递给生产者客户端配置,因此使用 Kafka 原生配置名,避免与 Spring 自身属性名混用造成歧义。

参数取舍原则:

  1. acks 与 min.insync.replicas 必须作为一组决策,只调整一端无法得到预期的可靠性
  2. linger.ms 与 batch.size 共同决定批次大小,压缩率随之提高;对延迟敏感的场景应把两者调小,改以增加分区数与生产者实例提升吞吐
  3. delivery.timeout.ms 应大于 linger.ms 加一次请求的最坏往返时间,过小会使正常重试被提前判定失败
  4. buffer.memory 写满后 send() 会阻塞至 max.block.ms,这是生产者侧的背压机制,需要与上游限流配合而非简单调大

消费端关键参数与取舍

spring:
  kafka:
    consumer:
      properties:
        group.id: order-events-consumer
        # 位点提交交给容器按处理结果控制
        enable.auto.commit: false
        auto.offset.reset: earliest
        # 单次 poll 的记录数与处理时限需匹配业务耗时
        max.poll.records: 200
        max.poll.interval.ms: 600000
        session.timeout.ms: 45000
        heartbeat.interval.ms: 3000
        # 拉取批次与等待,控制空轮询与网络往返
        fetch.min.bytes: 1
        fetch.max.wait.ms: 500
        # 需要读取事务消息时开启
        isolation.level: read_committed
        # 静态成员,实例重启在会话超时内不触发重平衡
        group.instance.id: order-consumer-1
        partition.assignment.strategy: org.apache.kafka.clients.consumer.CooperativeStickyAssignor

消费端同样通过 spring.kafka.consumer.properties 使用 Kafka 原生配置名;容器侧的提交时机由 spring.kafka.listener.ack-mode 控制,取值含义见本节后续说明。

参数取舍原则:

  1. max.poll.interval.ms 必须大于单批最坏处理耗时(含下游超时与重试),否则消费者被判定失联并触发重平衡
  2. session.timeout.ms 需要覆盖一次 GC 停顿上限,同时不应大于 Broker 的 group.min.session.timeout.ms 与 group.max.session.timeout.ms 允许范围
  3. fetch.min.bytes 调大可减少空拉取,但会增加单条消息的等待延迟,低流量主题上该影响明显
  4. auto.offset.reset 仅在无位点或位点越界时生效,不能用于控制常规起点,常规起始位点由消费组已提交位点决定

Spring 生态的接入结构

Spring for Apache Kafka 的接入由四部分组成:KafkaTemplate 负责发送,@KafkaListener 与 ConcurrentKafkaListenerContainerFactory 负责消费与并发度,AckMode 决定位点提交时机,CommonErrorHandler(含 DefaultErrorHandler 与 DeadLetterPublishingRecoverer)负责重试与死信投递。

import org.apache.kafka.clients.producer.ProducerRecord;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;

@Component
public class OrderEventPublisher {

    private final KafkaTemplate<String, String> kafkaTemplate;

    public OrderEventPublisher(KafkaTemplate<String, String> kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }

    /**
     * 以订单号作为 key,保证同一订单的事件落同一分区并按序消费
     */
    public void publish(String orderId, String payload) {
        ProducerRecord<String, String> record =
                new ProducerRecord<>("prod.order.order-events.v1", orderId, payload);
        kafkaTemplate.send(record).whenComplete((result, ex) -> {
            if (ex != null) {
                // 发送失败交由上层重试或落库补偿,不可静默丢弃
                throw new IllegalStateException("发送订单事件失败,orderId=" + orderId, ex);
            }
        });
    }
}

手动提交与异常处理的配合

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.support.Acknowledgment;
import org.springframework.stereotype.Component;

@Component
public class OrderEventListener {

    private final OrderEventHandler handler;

    public OrderEventListener(OrderEventHandler handler) {
        this.handler = handler;
    }

    /**
     * 容器配置 AckMode.MANUAL_IMMEDIATE 时,acknowledge() 触发同步提交
     * 处理成功后再提交,异常交给容器错误处理器决定重试或投递死信
     */
    @KafkaListener(topics = "prod.order.order-events.v1", groupId = "order-events-consumer")
    public void onMessage(ConsumerRecord<String, String> record, Acknowledgment ack) {
        handler.handle(record.key(), record.value());
        ack.acknowledge();
    }
}

配合要点:

  1. 处理成功后再提交是 at-least-once 的实现方式;提交前抛出异常,容器按错误处理器策略重试,超出次数后投递死信主题
  2. AckMode.RECORD 由容器在单条记录处理成功后提交,BATCH 按批提交,MANUAL 在批次处理完成后统一提交,MANUAL_IMMEDIATE 立即提交;按业务耗时可接受的最坏重复量选择
  3. 死信主题应与业务主题分区数一致并按原分区写入,便于按分区排查
  4. 处理逻辑仍需幂等:位点重置、重平衡与人为重放都会产生重复消息,提交时机的调整无法消除全部重复

3.4 常用运维命令

以下命令以 Kafka 自带的 shell 工具为例,--bootstrap-server 指向任意可用 Broker 即可。

主题管理

# 创建主题,指定分区数、副本因子与主题级配置
kafka-topics.sh --bootstrap-server 10.0.0.21:9092 \
  --create --topic prod.order.order-events.v1 \
  --partitions 12 --replication-factor 3 \
  --config retention.ms=604800000 \
  --config min.insync.replicas=2 \
  --config segment.bytes=536870912

# 查看主题列表与详情(含分区、Leader、ISR、副本分配)
kafka-topics.sh --bootstrap-server 10.0.0.21:9092 --list
kafka-topics.sh --bootstrap-server 10.0.0.21:9092 --describe --topic prod.order.order-events.v1

# 查看主题级与 Broker 级动态配置
kafka-configs.sh --bootstrap-server 10.0.0.21:9092 --describe \
  --entity-type topics --entity-name prod.order.order-events.v1

# 动态修改保留时长(无需重启,不影响现有数据)
kafka-configs.sh --bootstrap-server 10.0.0.21:9092 --alter \
  --entity-type topics --entity-name prod.order.order-events.v1 \
  --add-config retention.ms=259200000

# 分区扩容:只能增加,不能减少
kafka-topics.sh --bootstrap-server 10.0.0.21:9092 --alter \
  --topic prod.order.order-events.v1 --partitions 24

# 删除主题:kafka-topics.sh --bootstrap-server 10.0.0.21:9092 --delete --topic <主题名>

删除主题属 高危 操作:删除是异步的,Controller 标记后由 Broker 清理分区目录,期间主题不可读写且数据无法恢复。执行前应确认无生产者与消费者引用,记录主题的分区数、副本因子与全部主题级配置(来自 --describe 与 kafka-configs.sh --describe)用于重建,并确认存在数据备份或下游已有副本(如 MirrorMaker 2 的远程集群)。删除后重建同名主题无法恢复位点,消费组需按 3.6 的取证流程重新确定起点。

副本重分配

# 生成重分配方案,输入为主题与目标 Broker 列表
cat > topics.json <<'EOF'
{"topics":[{"topic":"prod.order.order-events.v1"}],"version":1}
EOF

kafka-reassign-partitions.sh --bootstrap-server 10.0.0.21:9092 \
  --topics-to-move-json-file topics.json \
  --broker-list "1,2,3,4" --generate > reassign-plan.json

# 执行重分配并限流,避免抢占业务带宽
kafka-reassign-partitions.sh --bootstrap-server 10.0.0.21:9092 \
  --reassignment-json-file reassign-plan.json \
  --throttle 104857600 --execute

# 校验进度;完成后取消限流
kafka-reassign-partitions.sh --bootstrap-server 10.0.0.21:9092 \
  --reassignment-json-file reassign-plan.json --verify

副本重分配属 高危 操作:迁移期间数据在 Broker 间复制,未限流会挤占业务带宽并造成 ISR 收缩;迁移本身会重写副本数据,磁盘空间不足时可能写满目标节点。回滚方式是在执行前保存 --generate 输出中的原始分配方案(reassign-plan.json 中 original 字段),需要撤回时把该部分作为 --reassignment-json-file 再次 --execute,恢复到原分配。执行前应确认目标 Broker 剩余磁盘足以承载新增副本。

消费者组查看与位点重置

# 列出所有消费者组
kafka-consumer-groups.sh --bootstrap-server 10.0.0.21:9092 --list

# 查看组内分区分配、当前位点、日志末端与滞后量
kafka-consumer-groups.sh --bootstrap-server 10.0.0.21:9092 \
  --describe --group order-events-consumer

# 查看组成员、状态与成员级分区分配
kafka-consumer-groups.sh --bootstrap-server 10.0.0.21:9092 \
  --describe --group order-events-consumer --state --members --verbose

# 重置位点前先导出原始位点,用于回滚(--export 需与 --reset-offsets 同时使用)
kafka-consumer-groups.sh --bootstrap-server 10.0.0.21:9092 \
  --group order-events-consumer \
  --reset-offsets --to-current \
  --topic prod.order.order-events.v1 --export --dry-run > offsets-backup.csv

# 重置到指定时间点(重置需在组处于 inactive 状态时执行)
kafka-consumer-groups.sh --bootstrap-server 10.0.0.21:9092 \
  --group order-events-consumer \
  --reset-offsets --to-datetime 2026-09-21T00:00:00.000 \
  --topic prod.order.order-events.v1 --execute

# 从备份文件恢复位点
kafka-consumer-groups.sh --bootstrap-server 10.0.0.21:9092 \
  --group order-events-consumer \
  --reset-offsets --from-file offsets-backup.csv --execute

位点重置属 高危 操作:向前重置(如 --to-earliest、--shift-by 负值)会造成大面积重复消费并冲击下游,向后重置(如 --to-latest、--shift-by 正值)会直接跳过未消费消息造成数据丢失。执行前必须满足三个条件:组内无活跃消费者(否则命令报错或位点被后续提交覆盖)、已用 --export 保存原始位点、已确认下游具备幂等或可容忍重复。回滚方式是用导出的 CSV 执行 --reset-offsets --from-file;若未导出,只能依据 --describe 输出的滞后量与业务时间戳比对重新推算,存在偏差。

数据导入导出

# 导出:把主题数据写入本地文件(-p 打印 key 便于核对)
kafka-console-consumer.sh --bootstrap-server 10.0.0.21:9092 \
  --topic prod.order.order-events.v1 --from-beginning \
  --property print.key=true --property print.offset=true \
  --timeout-ms 30000 > topic-export.txt

# 导入:从文件按行写入主题(每行一条记录,key 与 value 以制表符分隔)
kafka-console-producer.sh --bootstrap-server 10.0.0.21:9092 \
  --topic prod.order.order-events.v1 \
  --property parse.key=true --property key.separator=$'\t' < topic-import.txt

# 查看分区两端的偏移量:-2 为起始偏移量,-1 为日志末端偏移量
kafka-get-offsets.sh --bootstrap-server 10.0.0.21:9092 \
  --topic prod.order.order-events.v1 --time -2
kafka-get-offsets.sh --bootstrap-server 10.0.0.21:9092 \
  --topic prod.order.order-events.v1 --time -1

# 查看段文件内容与索引,用于离线核对消息是否落盘
kafka-dump-log.sh --files /data/kafka/logs/prod.order.order-events.v1-0/00000000000000000000.log \
  --print-data-log --deep-iteration

正式数据集成建议使用 Kafka Connect(文件、数据库、对象存储等连接器)与 MirrorMaker 2(跨集群复制),脚本导入导出仅适合小批量校验与手工补偿。

3.5 监控与告警

Broker 关键指标

Kafka 通过 JMX 暴露指标,常用采集方式为 JMX Exporter 或 kafka_exporter,指标项与判读要点如下:

指标 含义 判读要点
UnderReplicatedPartitions 同步副本数不足的分区数 大于 0 持续存在即为异常,说明副本追赶不上
OfflinePartitionsCount 无 Leader 的分区数 大于 0 表示分区不可用,需立即处理
ActiveControllerCount 当前 Broker 是否为 Controller 集群总和应恒为 1,为 0 表示无 Controller,大于 1 表示脑裂
IsrShrinksPerSec、IsrExpandsPerSec ISR 收缩与扩张速率 频繁收缩说明副本同步不稳定,而非偶发波动
UncleanLeaderElectionsPerSec 非同步副本当选 Leader 的次数 大于 0 表示已发生数据丢失
RequestHandlerAvgIdlePercent IO 线程空闲率 持续低于 0.3 说明请求处理能力接近饱和
NetworkProcessorAvgIdlePercent 网络线程空闲率 持续偏低说明网络层成为瓶颈
MessagesInPerSec、BytesInPerSec、BytesOutPerSec 流入流出速率 用于流量基线与容量趋势
LogSize、DiskUsage、磁盘剩余 日志占用与磁盘水位 保留策略失效或流量突增时最先反映
PartitionCount、LeaderCount 分区与 Leader 分布 节点间差异过大说明分配不均衡
LogStartOffset 变化 日志起始偏移量前移 前移速度异常说明保留策略过短或删除操作

客户端关键指标

消费端:

  1. records-lag-max、各分区滞后量:消费进度与积压规模
  2. fetch-latency-avg、fetch-rate:拉取效率与空轮询
  3. commit-latency-avg、commit-rate:位点提交是否正常
  4. rebalance-rate-per-hour、rebalance-total、assigned-partitions:重平衡频率与分配情况
  5. poll-idle-ratio-avg:poll 中等待时间占比,偏高说明处理与拉取节奏不匹配

生产端:

  1. record-error-rate、record-retry-rate:失败与重试情况
  2. batch-size-avg、compression-rate-avg:批量与压缩是否达到预期
  3. request-latency-avg、request-timeout-rate:Broker 响应状况
  4. buffer-available-bytes、buffer-exhausted-rate:缓冲区是否成为背压瓶颈
  5. metadata-age:元数据刷新延迟,集群变更期间会升高

告警设计

告警规则由条件、持续时间、级别标签与注解四项构成,持续时间用于过滤瞬时抖动,抑制用于避免一个根因触发大量通知;这部分通用设计参见 ../../../../linux/monitoring/monitoring_and_alerting.html。Kafka 侧的规则示例:

groups:
  - name: kafka-cluster
    rules:
      - alert: KafkaOfflinePartitions
        expr: kafka_server_kafkacontroller_offlinepartitionscount > 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "{{ $labels.instance }} 存在离线分区"
          description: "离线分区数 {{ $value }},分区当前无 Leader,生产与消费均已失败"

      - alert: KafkaNoActiveController
        expr: sum(kafka_server_kafkacontroller_activecontrollercount) != 1
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "集群 Controller 数量异常"
          description: "活跃 Controller 总数不等于 1,元数据变更可能停滞或出现脑裂"

      - alert: KafkaUnderReplicatedPartitions
        expr: kafka_server_replicamanager_underreplicatedpartitions > 0
        for: 15m
        labels:
          severity: warning
        annotations:
          summary: "{{ $labels.instance }} 副本同步不足"
          description: "非同步副本分区数 {{ $value }},持续 15 分钟,读取磁盘与网络排查 Follower 落后原因"

      - alert: KafkaIsrShrinkFrequent
        expr: increase(kafka_server_replicamanager_isrshrinks_total[30m]) > 10
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "{{ $labels.instance }} ISR 收缩频繁"
          description: "30 分钟内 ISR 收缩超过 10 次,副本同步反复中断"

      - alert: KafkaUncleanLeaderElection
        expr: increase(kafka_controller_controllerstats_uncleanleaderelectionspersec_total[15m]) > 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "{{ $labels.instance }} 发生非同步副本选举"
          description: "已发生 unclean leader election,存在数据丢失"

      - alert: KafkaConsumerGroupLagHigh
        expr: sum by (consumergroup) (kafka_consumergroup_lag) > 100000
        for: 15m
        labels:
          severity: warning
        annotations:
          summary: "消费组 {{ $labels.consumergroup }} 积压偏高"
          description: "总滞后 {{ $value }} 条,持续 15 分钟,需核对生产速率与消费能力"

指标名随采集器不同而不同:以上表达式按 JMX Exporter 的命名转换(kafka_<域>_<类型>_<属性>)与 kafka_exporter 的消费组指标书写,实际部署时需以采集端暴露的指标名为准,并通过 curl 抓取 /metrics 核对后再落规则。

消费滞后告警

滞后告警的关键是把"绝对量"与"趋势"结合,避免两类误判:

  1. 以绝对阈值(如 10 万条)触发,适合有明确处理时限的业务;阈值应结合单条处理耗时换算为可接受的追平时间
  2. 以增长趋势触发,用 predict_linear 估算按当前斜率何时耗尽处理能力:predict_linear(kafka_consumergroup_lag[1h], 3600) > 阈值
  3. 滞后长期处于高位但稳定,属于容量不足而非突发故障,应走容量规划流程而非反复触发告警
  4. 突发滞后需先判断是生产尖峰还是消费停顿,两者的处置方向相反:前者扩容消费或安排削峰,后者排查消费端停顿原因

ISR 收缩告警

ISR 收缩的告警阈值应区分频率与持续性:偶发收缩后自行恢复属于网络抖动的正常范围,持续存在的 UnderReplicatedPartitions 才代表副本长期落后。告警注解中应给出节点、磁盘与网络三个排查方向,避免只报现象。

磁盘与水位告警

  1. 磁盘剩余低于 20% 触发 warning、低于 10% 触发 critical,预留余量用于日志轮转与副本追赶
  2. 主机侧磁盘指标与判读方法参见 ../../../../linux/monitoring/monitoring_and_alerting.html 中磁盘空间与 inode 部分
  3. 除磁盘空间外需同时监控 inode 占用:分区规模大、段文件小而多的场景下 inode 会先耗尽
  4. 磁盘写满会造成 Broker 停机而非降级服务,告警持续时间不宜过长

告警抑制

单台 Broker 故障会同时触发其承载全部分区的 ISR 收缩与下游所有消费组的滞后告警,应配置抑制规则:Broker 不可达的 critical 告警触发时,抑制同一实例与其承载分区上的滞后类 warning 告警;同时按消费组与主题维度设置静默窗口(如计划内重启、发布窗口),静默必须设置明确的结束时间。

3.6 故障排查

消费滞后增长

排查顺序:

  1. 确认生产侧是否出现流量突增(BytesInPerSec、MessagesInPerSec 曲线)
  2. 确认消费能力是否下降:查看 poll-idle-ratio-avg(等待占比高说明拉取不足,占比低说明处理耗时高)与消费端 GC、下游依赖响应时间
  3. 确认并行度是否充足:消费者实例数与分区数比较,是否存在分区分配集中在少数实例
  4. 确认是否存在热点分区:按分区查看滞后量,个别分区远超其他分区说明分区键倾斜
  5. 确认是否发生重平衡:rebalance-rate-per-hour 与组状态变化
  6. 确认是否被配额限流:Broker 侧客户端配额(--entity-type clients)或网络带宽限制

重平衡风暴

表现为消费组频繁进入 PreparingRebalance 状态、滞后在每次重平衡后阶跃上升。常见成因与处置:

  1. 单批处理耗时超过 max.poll.interval.ms:调大该值或调小 max.poll.records,同时优化处理逻辑(下游调用改为批量与异步)
  2. GC 停顿超过 session.timeout.ms:检查堆大小与 GC 日志,调整堆或回收器
  3. 实例被反复重启:容器探针超时、OOM Killer、发布过程滚动重启过密;使用静态成员 group.instance.id 并放宽部署节奏
  4. 心跳线程被阻塞:避免在 poll 线程外长时间持有消费者实例,或在消费线程中执行阻塞操作
  5. 分配策略为 eager 且成员频繁变动:改用 cooperative-sticky 降低迁移面

副本不同步

表现为 UnderReplicatedPartitions 大于 0、IsrShrinksPerSec 上升:

  1. 检查 Follower 节点的磁盘 I/O 饱和度与 await(读写等待时间),副本追赶是顺序读加顺序写,磁盘饱和会直接拖慢追赶
  2. 检查网络带宽与丢包:跨机架复制的流量与业务流量竞争时会互相影响
  3. 检查数据倾斜:个别分区写入量远高于均值,其副本必然长期落后
  4. 检查 Broker 负载:IO 线程空闲率过低时副本抓取请求会被压后处理
  5. 处置顺序为先恢复节点资源,再考虑增加 num.replica.fetchers 或迁移分区;不要在 ISR 未恢复时执行分区扩容或重分配

磁盘写满

  1. 直接处置:缩短保留时长(kafka-configs.sh --alter --add-config retention.ms=...),生效后由清理线程按段删除,不中断读写
  2. 按偏移量删除:kafka-delete-records.sh 可删除指定偏移量之前的数据,属 高危 操作,删除不可恢复且会使消费位点越过起始偏移量。执行前需记录各分区当前起始偏移量与消费者已提交位点,确认没有未消费数据落入被删除区间;若误删,只能从其他副本(未删除前)或备份集群恢复,因此执行前应确认备份可用
  3. 扩容与迁移:增加磁盘或新增 log.dirs 目录后通过副本重分配把分区迁移到新目录;新增 log.dirs 只影响后续创建的分区与再分配后的分区,已有分区不会自动迁移
  4. 兜底:为每个节点保留不低于 20% 磁盘余量,并对 log.retention.bytes 设置分区级上限,避免单一主题占满磁盘

生产者超时与批量重试

常见异常与成因:

  1. TimeoutException(批次在 delivery.timeout.ms 内未完成):Broker 响应慢、linger.ms 过大挤占重试预算、网络拥塞;核对 delivery.timeout.ms 与 linger.ms、request.timeout.ms 的关系
  2. NotEnoughReplicasException:acks=all 且 ISR 数量低于 min.insync.replicas,属于副本层面故障,应按副本不同步排查而非调整生产端参数
  3. RecordTooLargeException:单条消息或批次超过 max.request.size、message.max.bytes 限制,需压缩或拆分 payload
  4. OutOfOrderSequenceException:开启幂等后在途请求过多或分区 Leader 切换,会触发生产者重建连接,需关注是否伴随重复写入
  5. 重试风暴:大量分区同时切换 Leader 时,所有生产者对齐重试;应关注 record-retry-rate 与 Broker 端 FailedProduceRequestsPerSec,必要时在上游限流而非放大重试

消息重复或丢失的取证顺序

取证原则是先确定语义边界,再逐段核对,避免在缺少结论依据时直接调整参数:

  1. 确认投递语义:核对生产端 acks、enable.idempotence、retries 与 Broker 端 min.insync.replicas、副本因子的组合,明确系统在理论上允许哪类异常(允许重复还是允许丢失)
  2. 确认生产端结果:查看生产者回调与 record-error-rate、record-retry-rate,确认是否存在"发送失败但业务以为成功"的路径;检查事务是否已提交
  3. 确认 Broker 端事件:检索 Broker 日志中的分区 Leader 切换、ISR 收缩与 unclean leader election 记录,确认是否发生过未同步副本当选或日志截断;UncleanLeaderElectionsPerSec 与 LogStartOffset 的变化是关键判据
  4. 确认消费端提交时机:核对 AckMode 或手动提交位置,判定是"提交早于处理"(可能丢失)还是"处理早于提交"(可能重复);检查是否存在重平衡导致的位点回退与提交失败
  5. 核对位点与数据:用 kafka-consumer-groups.sh --describe 对比位点与 LEO,用 kafka-get-offsets.sh 查看分区两端偏移量,确认目标消息是否仍在保留窗口内
  6. 落到数据本身:用 kafka-dump-log.sh --print-data-log 检查段文件中目标偏移量是否存在及其内容,区分"消息未写入"与"消息已写入但消费端未读到"
  7. 查询相关日志:Broker 与客户端日志的检索方法参见 ../../../../linux/log/log_query_and_audit.html,按时间窗口与主题、分区、偏移量关键字定位

常见结论对应关系:丢失多指向 acks 配置不足、ISR 不足时仍写入成功(min.insync.replicas=1)或位点提交超前;重复多指向生产者重试未开启幂等、位点提交滞后于处理、重平衡与位点重置造成的回放。

3.7 与 RabbitMQ 的差异对照

对比维度 Kafka RabbitMQ
系统定位 分布式流平台与日志型消息系统,面向数据流与事件溯源 传统消息代理,面向业务解耦与任务分发
消息模型 分区日志,消息由保留策略删除,与是否被消费无关 队列,消息确认后删除,队列长度即待处理量
路由能力 仅主题与分区,无交换机与绑定概念 交换机加绑定,支持 Direct、Topic、Fanout、Headers 多种路由
顺序性 分区内严格有序,主题内无序,跨分区顺序需业务保证 单队列有序,多消费者并发消费时顺序不保证;需顺序时用单消费者或 QoS 配合
消费模式 消费者主动拉取,按位点推进,支持位点重置与历史回放 服务端推送,确认即删除,不支持回放
消费并行单位 分区,同组内一个分区只被一个消费者消费 队列,多消费者竞争同一条消息
延迟消息 无原生支持,需延时主题、外部调度或时间轮实现 TTL 加死信队列,或延迟交换机插件
投递语义 默认至少一次,幂等加事务可实现 Kafka 内部精确一次 至少一次,靠手动确认与业务幂等保证
吞吐与延迟 高吞吐(批量、顺序写、零拷贝),延迟毫秒级且受批量影响 中等吞吐,延迟可达微秒至毫秒级
集群与高可用 分区副本加 ISR,Leader 选举由 Controller 与元数据仲裁驱动 镜像队列或仲裁队列,基于 Raft 或镜像同步
扩展方式 增加分区与 Broker,提升生产与消费并行度 增加消费者提升并发,节点加入集群分担队列
运维复杂度 涉及分区规划、副本重分配、位点管理、元数据仲裁模式选择 涉及插件、队列策略、镜像队列与集群节点管理
典型场景 日志采集、埋点、CDC、事件总线、流式计算 业务异步解耦、订单通知、任务分发、RPC 回调

选型判断的三个主要依据:

  1. 需要历史回放、多消费组独立推进同一份数据、或吞吐量在十万条每秒以上时,选择 Kafka
  2. 需要按路由键灵活分发、单条消息要求极低延迟、或需要原生延迟消息时,选择 RabbitMQ
  3. 两者可以在一套系统中共存:Kafka 承担数据管道与事件总线,RabbitMQ 承担业务动作分发

RabbitMQ 的模型、交换机类型、确认机制、集群模式与运维命令参见 ../rabbitmq/rabbitmq.html,部署与开发实践参见 ../rabbitmq/rabbitmq_theoretical_and_practice.html;消息模型的通用判据参见 ../../theoreticalbasis/message_queue_fundamentals.html,跨产品的选型维度对照参见 ../../theoreticalbasis/message_middleware_selection.html。

四、总结

  • Kafka 的设计起点是顺序追加的日志而非队列:消费进度成为客户端状态,服务端因此不必为每个消费者维护投递状态,并支持多组独立读取与历史回放
  • 吞吐来自顺序写、批量传输、页缓存与零拷贝的组合;页缓存由操作系统管理,Broker 不把消息数据放在堆内
  • 分区是存储、顺序与并行的最小单位:分区内有序、主题内无序,分区数决定同组消费并行度上限
  • 元数据管理有两种模式:ZooKeeper 模式在 4.0 起移除,KRaft 以 Raft 仲裁管理元数据日志与快照,切换更快且支持更大分区规模
  • 可靠性由副本机制承载:ISR 反映副本同步状态,acks=all 与 min.insync.replicas 必须成组配置,其组合决定"拒绝写入"与"允许丢数据"之间的边界
  • 生产端的关键取舍是批量、压缩与延迟之间的平衡,以及幂等与在途请求数的配合:幂等消除重试重复,在途数不超过 5 时不牺牲分区内顺序
  • 事务把多分区写入与位点提交绑为原子单元,但原子性只覆盖 Kafka 内部,跨系统场景仍需业务侧幂等
  • 消费端的行为由分配策略、位点提交时机与重平衡机制共同决定:重平衡期间分区停摆,位点提交超前造成丢失、滞后造成重复
  • 至少一次是默认语义,精确一次是"Kafka 内部"的有限保证,消费幂等在任何语义下都是必要兜底
  • 保留策略以段为单位删除,压实主题按键保留最新值,适合 CDC、状态存储与配置分发,tombstone 的保留窗口需大于下游读取延迟
  • 部署关注磁盘布局、JVM 堆与页缓存的分配、文件句柄与内核参数、机架感知的副本分布
  • 分区规划应预留分区数:扩容会改变键到分区的映射并打断同键有序,副本因子 3 配合 min.insync.replicas=2 是生产常用组合
  • 运维的四个主线是分区与副本的均衡、消费者组位点的正确性、保留策略与磁盘水位、监控告警中滞后与 ISR 的判读
  • 告警设计遵循条件、持续时间、级别与注解四要素,滞后告警需结合绝对值与增长趋势,单节点故障应通过抑制避免告警风暴
  • 故障排查遵循由语义到现象的顺序:先确认投递语义与配置边界,再核对生产端结果、Broker 端事件、消费端提交时机,最后落到日志与段文件内容
  • 与 RabbitMQ 的分工依据是数据流与业务动作的区别:需要回放与高吞吐选择 Kafka,需要灵活路由与低延迟选择 RabbitMQ,两者可在同一系统中共存