Skip to content

5.4-2 Kafka 存储:segment、稀疏索引、零拷贝 ​

所属:05 消息中间件 / 5.4 Kafka 分级:A 状态:◐ 初稿 关联:5.1-1、5.1-4、5.3-2、5.4-1、5.4-3、5.4-6、5.4-7

  • 题型:原理 / 源码 / 调优

  • 一句话结论:Kafka 的存储是**“每个分区一个目录、目录里切 segment、segment 里顺序追加”:消息只追加到 .log 文件,.index 是每 4KB 一条的稀疏偏移索引**,.timeindex 是时间索引;消费时用二分找 segment、查稀疏索引、再顺序扫一小段。它不靠 fsync 保证持久性,而靠副本;高吞吐靠顺序写 + PageCache + 零拷贝(sendfile)+ 批量压缩。理解和 RocketMQ 的差异(单 CommitLog vs 分区目录、稠密 20B 索引 vs 稀疏索引)是这道题的核心。

  • 分层要点:

    1. 目录结构:log.dirs 下每个分区一个目录 topic-partition,里面是多个 segment:<baseOffset>.log(消息)、<baseOffset>.index(偏移索引)、<baseOffset>.timeindex(时间索引)。同一分区的 segment 按 baseOffset 递增,只有最后一个(active segment)可写,其余只读。
    2. segment 滚动:当 active segment 达到 segment.bytes(默认 1GB)或超过 segment.ms(默认 7 天)时滚动出新文件;索引文件大小由 segment.index.bytes(默认 10MB)约束。滚动是删除与保留的最小单位——Kafka 删的是整个 segment,不是单条消息。
    3. 只追加的日志:消息以 record batch 为单位追加,batch 带 baseOffset、lastOffsetDelta、CRC、压缩编码;offset 是逻辑位置,物理位置是文件内字节偏移。追加只写文件尾,顺序 IO,这是吞吐的基础;batch 越大、压缩越好,吞吐越高、单条延迟越高。
    4. 稀疏索引:.index 不是每条消息都记,而是每写入约 index.interval.bytes(默认 4096 字节)记一条,每条 8 字节(4 字节相对 offset + 4 字节物理位置);.timeindex 每 12 字节(8 字节时间戳 + 4 字节相对 offset)。查询时先二分索引找到“不大于目标 offset 的最近一条”,再从该物理位置顺序扫描到目标。稀疏换空间,扫描换精度。
    5. 读取路径:根据目标 offset 在所有 segment 里二分找到所属文件 → 在 .index 里二分 → 得到物理位置 → 从该位置顺序读 .log → 解压 batch → 返回。消费滞后不多时,数据大概率在 PageCache 里;滞后很多才会真正读盘。索引文件也是 mmap 的,查找不经过堆内存。
    6. 零拷贝:Consumer fetch 时,Broker 用 FileChannel.transferTo(底层 sendfile)把 PageCache 里的数据直接送到 socket,不经过用户态缓冲区,省掉两次拷贝与上下文切换。前提是数据在 PageCache;开启 TLS 后零拷贝基本失效(要加密就得进用户态),这也是“内网明文 + 外网 TLS”取舍的原因之一。
    7. 持久性靠副本,不靠 fsync:Kafka 默认不每条 fsync(flush.messages / flush.ms 默认极大),写入落在 PageCache 就返回;可靠性由 acks=all + min.insync.replicas + 多副本保证(5.1-1、5.4-3)。这和 RocketMQ 的 SYNC_FLUSH 是两条路线:Kafka 用复制换持久性,RocketMQ 提供刷盘选项。
    8. 保留与清理:cleanup.policy=delete 按 retention.ms(默认 7 天)/retention.bytes 删除整段;cleanup.policy=compact 按 key 保留每个 key 的最新值(墓碑记录在 delete.retention.ms 后清除),用于 changelog/状态恢复。active segment 不会被删;删除有 log.segment.delete.delay.ms 延迟,避免正在读的文件被立刻删掉。
  • 图/流程:

text
目录布局:
  log.dirs/order-0/
    00000000000000000000.log
    00000000000000000000.index
    00000000000000000000.timeindex
    00000000000001073741824.log      ← 1GB 后滚动
    00000000000001073741824.index
    00000000000001073741824.timeindex
    00000000000002147483648.log      ← active(可写)
    ...
  log.dirs/pay-3/
    ...
text
写入:
  Producer batch
    → Leader 的 active segment .log 末尾追加
      → 更新 LEO
        → follower fetch 复制
          → 更新 HW
  达到 segment.bytes / segment.ms
    → roll:新建 segment,旧文件只读
text
读取(offset = 12345678):
  1. 在 segment 列表中二分 → 找到 baseOffset ≤ 12345678 的文件
  2. 在 .index 中二分 → 找到 ≤ 目标的最近索引项
       (相对 offset, 物理位置)
  3. 从物理位置顺序扫描 .log
  4. 解压 batch → 定位到目标 offset → 返回
text
零拷贝:
  Disk / PageCache ──sendfile──▶ Socket Buffer ──▶ 网卡
        (数据不经过 JVM 用户态)
  对比普通读:
  Disk → PageCache → 用户缓冲区 → Socket Buffer → 网卡
  • 版本/源码锚点:

    • 存储核心:Log、LogSegment、LogManager、OffsetIndex、TimeIndex、FileRecords、MemoryRecords、LogCleaner(compact)。
    • 零拷贝:FileRecords.writeTo → FileChannel.transferTo → sendfile。
    • 参数:log.dirs、log.segment.bytes(1GB)、log.roll.ms/log.roll.hours(168h)、log.index.size.max.bytes(10MB)、log.index.interval.bytes(4096)、log.retention.ms(168h)、log.retention.bytes(-1)、log.retention.check.interval.ms(5min)、cleanup.policy、min.cleanable.dirty.ratio(0.5)、delete.retention.ms(24h)。
    • 刷盘:log.flush.interval.messages、log.flush.interval.ms(默认不强制);可靠性由 acks/min.insync.replicas 决定(5.4-3)。
    • 消息格式:0.11+ record batch v2(varint、CRC32C、压缩);3.0 移除 v0/v1。
    • 3.6+:分层存储(KIP-405),旧 segment 可卸载到对象存储(视发行版支持情况)。
  • 三类文件对比:

文件内容条目大小写入频率查找方式
.log消息 batch变长每条消息顺序扫描
.indexoffset → 物理位置8B每 ~4KB 一条二分
.timeindextimestamp → offset12B每 ~4KB 一条二分
  • 关键参数:
参数默认作用调优建议
log.segment.bytes1GBsegment 大小太小→文件多、索引频繁;太大→删除粒度粗
log.roll.hours168h按时间滚动配合保留时间
log.index.interval.bytes4096索引密度越小索引越大、扫描越少
log.index.size.max.bytes10MB索引文件上限一般不动
log.retention.hours168h保留时间按业务回溯需求
log.retention.bytes-1按容量保留磁盘敏感时设置
cleanup.policydelete删除/压缩changelog 用 compact
log.flush.interval.messages极大强制 fsync 条数一般不设,靠副本
compression.typeproducer 决定压缩算法lz4/zstd 常用
  • 删除 vs 压缩:
维度deletecompact
触发retention.ms/bytescleanup.policy=compact
单位整个 segment按 key 重写 segment
保留时间/容量窗口内全部每个 key 最新值
墓碑无delete.retention.ms 后清除
场景日志、事件流changelog、状态快照、CDC
  • RocketMQ vs Kafka 存储:
维度RocketMQKafka
写入组织所有 Topic 一个 CommitLog每分区独立目录/segment
索引每队列每条 20B(稠密)每 ~4KB 一条(稀疏)
索引内容offset/size/tag hash相对 offset/物理位置
写 IO全顺序分区内顺序
读 IO索引 + CommitLog 随机读索引 + 小段顺序扫描
持久性可配同步/异步刷盘默认不 fsync,靠副本
删除按文件、按时间按 segment、按时间/容量
零拷贝mmap + FileRegionsendfile(无 TLS 时)
  • 失效场景与定位:
现象根因处理
消费 RT 抖动、磁盘 IO 高消费滞后、PageCache 未命中扩内存、减少滞后、加 Broker
磁盘增长快保留时间过长/流量上涨调 retention、扩盘、压缩
删除后磁盘没降active segment 不删/延迟删除等滚动、查保留配置
索引文件损坏异常断电重启重建索引(扫描 log)
启动慢大量 segment 需恢复/建索引控制 segment 数、预留时间
零拷贝没生效开了 TLS/拦截层内网明文或接受拷贝
压缩比差消息小、key 随机批量、换 zstd/lz4
compact 后旧值还在未到清理周期/墓碑未过期调 min.cleanable.dirty.ratio、等待
单分区写入瓶颈分区少/热点 key扩分区、改 key(注意顺序)
磁盘满保留策略失效告警、限流、扩容
  • 深挖点(面试官常追的 6 个):

    1. Kafka 为什么快:① 分区内顺序追加,几乎只有顺序 IO;② 依赖 OS PageCache,读写都不走 JVM 堆;③ 消费用 零拷贝(sendfile),数据不进用户态;④ 批量 + 压缩,摊薄网络与磁盘开销;⑤ 稀疏索引,索引小、常驻内存。五点缺一不可,不要只说“零拷贝”。
    2. 为什么索引是稀疏的:如果每条消息都建索引,索引大小会和消息数成正比,内存与磁盘都吃不消;稀疏索引每 4KB 一条,把索引控制在很小,查询时二分定位到“最近的前一条”,再顺序扫描几 KB 就能找到目标。用少量顺序扫描换索引空间,这是典型的空间换时间反向操作。
    3. 零拷贝到底省了什么:普通读是“磁盘 → PageCache → 用户缓冲区 → socket buffer → 网卡”,有 4 次拷贝、2 次上下文切换;sendfile 让数据在内核态从 PageCache 直接进 socket buffer,省掉用户态那次拷贝与切换。但 SSL/TLS 必须在用户态加密,所以开了 TLS 零拷贝就失效;另外如果 Broker 做了消息格式转换(旧版本 down-conversion),也会退化为普通读。
    4. Kafka 不 fsync 为什么不怕丢:它把持久性交给副本:acks=all 要求 ISR 都写入,min.insync.replicas>=2 保证至少两个副本,Leader 挂了从 ISR 选新 Leader。只要副本机制正确,单机 PageCache 丢失不会导致数据丢失。代价是副本同步延迟与磁盘/网络成本;而 RocketMQ 提供同步刷盘,是另一种取舍(5.1-1、5.4-3)。
    5. segment 为什么要滚动:① 删除/保留以 segment 为单位,文件太大无法精细控制保留窗口;② 索引文件有大小上限,需要定期重建;③ 过期文件可以整文件删除,避免逐条清理;④ 便于并行恢复与迁移。滚动太频繁会产生大量小文件、增加 open 句柄与索引开销;太大则删除粒度粗、恢复慢。
    6. compact 和 delete 的区别:delete 按时间/容量删整个 segment,适合事件流;compact 按 key 保留最新值,适合 changelog、状态存储、CDC(同一 key 的旧值会被清理,墓碑在 delete.retention.ms 后删除)。compact 不是“删除重复消息”那么简单,它重写 segment、保留 offset 连续性,消费端仍按 offset 读,可能看到“空洞”(被压缩掉的位置)。
  • 追问链:

    1. Kafka 消息存哪? → 分区目录下的 segment。
    2. 目录名是什么? → topic-partition。
    3. segment 有哪些文件? → .log、.index、.timeindex。
    4. 哪个可写? → 只有 active segment。
    5. 什么时候滚动? → 大小/时间阈值。
    6. 默认大小? → 1GB。
    7. 默认时间? → 7 天。
    8. 消息怎么写入? → 追加到 .log 末尾。
    9. 是顺序写吗? → 分区内顺序。
    10. offset 是什么? → 分区内逻辑位置。
    11. 物理位置呢? → 文件内字节偏移。
    12. 索引存什么? → offset → 物理位置。
    13. 每条消息都索引吗? → 不是,稀疏索引。
    14. 多久一条? → 约每 4KB。
    15. 一条索引多大? → 8 字节。
    16. timeindex 呢? → 时间 → offset,12 字节。
    17. 为什么稀疏? → 省空间,扫描补精度。
    18. 怎么查 offset? → 二分 segment + 二分索引 + 扫描。
    19. 索引在内存吗? → mmap,走 PageCache。
    20. 零拷贝是什么? → sendfile,内核态直接送 socket。
    21. 省了什么? → 用户态拷贝与上下文切换。
    22. 开 TLS 还有吗? → 基本没有。
    23. Kafka 写入 fsync 吗? → 默认不。
    24. 不怕丢吗? → 靠副本。
    25. 怎么配可靠? → acks=all + minISR。
    26. 和 RocketMQ 刷盘区别? → 复制 vs 刷盘。
    27. PageCache 作用? → 读写加速、零拷贝前提。
    28. PageCache 丢了会怎样? → 未复制数据可能丢。
    29. 消费读盘还是读缓存? → 滞后小时读缓存。
    30. 滞后大呢? → 读盘、IO 升高。
    31. 消息怎么删? → 删整个 segment。
    32. active 会删吗? → 不会。
    33. 默认保留多久? → 7 天。
    34. 按容量呢? → retention.bytes。
    35. compact 是什么? → 按 key 保留最新。
    36. 墓碑是什么? → 标记删除的记录。
    37. compact 后 offset 连续吗? → 连续但有空洞。
    38. 索引损坏怎么办? → 重启扫描 log 重建。
    39. 启动为什么慢? → 恢复 segment/建索引。
    40. segment 越小越好吗? → 不是,文件多、开销大。
    41. segment 越大越好吗? → 删除粒度粗、恢复慢。
    42. 压缩在哪层? → batch 层。
    43. 常用压缩? → lz4/zstd。
    44. 批量大小影响? → 吞吐与延迟。
    45. 分区多磁盘压力? → 分散到多目录/多盘。
    46. 分层存储是什么? → 旧 segment 卸载到对象存储。
    47. KRaft 影响存储吗? → 元数据,不影响日志。
    48. 怎么监控存储? → 磁盘、segment 数、IO、滞后。
    49. 和 RocketMQ 最大区别? → 单日志 vs 分区目录;稠密 vs 稀疏索引。
    50. 面试怎么总结? → 分区目录 → segment → 顺序追加 → 稀疏索引 → 零拷贝 → 副本保可靠 → 删除/压缩。
  • 生产案例/取舍(示例,替换成你的项目):

    • 消费滞后 2 小时后磁盘 IO 打满,PageCache 全失效;扩消费者 + 加内存,恢复。
    • retention.ms 设 30 天,磁盘两周就满;改 7 天 + 冷数据下沉对象存储。
    • segment 设 128MB,集群产生几十万小文件、启动慢;调回 1GB。
    • 开了 TLS 后吞吐掉 30%,零拷贝失效;内网保持明文、边界做 TLS。
    • 以为 Kafka 不 fsync 会丢,实际是副本配置不足(RF=1);改 RF=3 + minISR=2。
    • 索引文件损坏导致启动失败,删除索引后重启自动重建;加异常断电演练。
    • compact topic 没配 delete.retention.ms,墓碑长期占用;按业务调整。
    • 热点 key 集中在一个分区,单盘 IO 打满;改 key 设计 + 扩分区。
    • 批量调大后吞吐上升但 P99 延迟变高;按业务分 topic 配置。
    • 磁盘满导致 Broker 挂起,生产全失败;加水位告警 + 自动清理。
    • 5.x 分层存储把 7 天以上数据放对象存储,本地磁盘降 60%。
    • 取舍:大 segment 换文件少,代价是删除粒度粗;稀疏索引换空间,代价是扫描;零拷贝换吞吐,代价是 TLS/转换失效;不 fsync 换吞吐,代价是依赖副本;compact 换状态存储,代价是重写与空洞。
  • 易错点:

    • 认为 Kafka 每个 Topic 一个文件。
    • 认为所有 segment 都可写。
    • 认为每条消息都有索引。
    • 认为索引存在 JVM 堆里。
    • 认为 offset 是物理位置。
    • 认为 Kafka 写入一定 fsync。
    • 认为不 fsync 就一定会丢。
    • 认为零拷贝在所有场景都生效。
    • 认为开 TLS 不影响零拷贝。
    • 认为消息可以逐条删除。
    • 认为 active segment 也会被保留策略删除。
    • 认为 compact 会删除所有旧消息。
    • 认为 compact 后 offset 不连续。
    • 认为 segment 越小越好。
    • 认为 segment 越大越好。
    • 认为 PageCache 只影响读。
    • 认为消费总是读磁盘。
    • 认为索引损坏无法恢复。
    • 认为启动慢只是数据多。
    • 认为压缩没有 CPU 代价。
    • 认为批量越大越好。
    • 认为分区越多单机越强。
    • 认为分层存储默认开启。
    • 认为 KRaft 改变了日志存储格式。
    • 认为 RocketMQ 和 Kafka 存储结构一样。
    • 认为稀疏索引会查不到消息。
    • 认为删除 segment 会立即释放空间。
    • 认为存储层与可靠性无关。
  • 30 秒口述稿:

Kafka 每个分区一个目录,目录里按 baseOffset 切成多个 segment,每个 segment 有 .log、.index、.timeindex 三个文件,只有最后一个 active segment 可写,消息只往 .log 末尾追加。索引是稀疏的,大约每 4KB 记一条,8 字节存相对 offset 和物理位置,所以查消息是先二分 segment、再二分索引、再顺序扫一小段。读取时 Broker 用 sendfile 做零拷贝,数据从 PageCache 直接到网卡;但开了 TLS 零拷贝基本失效。Kafka 默认不 fsync,可靠性靠副本:acks=all 加 minISR,Leader 挂了从 ISR 选。删除按 segment 整文件删,默认保留 7 天;compact 则是按 key 保留最新值,用于 changelog。和 RocketMQ 比,它是分区目录 + 稀疏索引,RocketMQ 是单 CommitLog + 每队列 20 字节稠密索引。

  • 3 分钟展开顺序:结论(分区目录 + segment + 稀疏索引 + 零拷贝 + 副本)→ 目录与文件 → segment 滚动与 active → 追加写与 offset/物理位置 → .index/.timeindex 结构 → 查询三步 → 零拷贝路径与 TLS 例外 → 不 fsync 与副本的关系 → 删除与 compact → 与 RocketMQ 存储对照 → 参数调优与故障定位。