分类: 系统运维与架构

  • 深入 Netfilter 排查:海量 iptables 规则引发的 CPU SoftIRQ 暴涨与 nftables 匿名集合 O(1) 重构实战

    结论先行:将 5 万条 iptables 顺序拦截规则重构为原生 nftables 的匿名集合(Set/Map)后,宿主机网卡软中断(SoftIRQ)CPU 开销从 100% 暴降至 2%,网络 P99 延迟从 200ms 恢复至 2ms。在海量 IP 拦截与路由过滤场景下,彻底抛弃 iptables 的 O(N) 线性遍历,改用 nftables 基于红黑树与哈希表的 O(1) 匹配,才是现代网关防御的唯一出路。

    近期在排查某边缘网关集群性能问题时,发现部分节点在 PPS(每秒包数)仅 10 万左右时,Load Average 飙升至 40+,网络出现严重丢包。该节点主要承担流量清洗清洗和恶意 IP 封禁任务,安全组件会通过脚本动态下发拦截规则。

    案发现场:ksoftirqd 满载与 perf 剖析

    登录问题机器(Ubuntu 22.04, Kernel 5.15.0, iptables v1.8.7),通过 mpstat -P ALL 1 观察,发现多个 CPU 核心的 %soft 指标长期顶在 100%,而 %usr 和 %sys 极低。这说明 CPU 周期全部消耗在了内核态网络软中断处理上。

    直接挂载 perf 抓取热点函数:

    perf record -a -g -F 99 -- sleep 10
    perf report
    

    调用栈结果异常刺眼:

    -   78.42%     ksoftirqd/2  [kernel.kallsyms]   [k] nft_do_chain
       - 77.10% nft_do_chain
          - 68.32% nft_cmp_eval
          - 4.21% nft_counter_eval
    

    排查防火墙规则,发现安全组件通过 iptables -A INPUT -s -j DROP 累积下发了高达 5.2 万条黑名单规则。

    为什么 iptables-nft 包装层依然无法拯救 SoftIRQ 雪崩?

    很多人有个误区,认为在较新的 Linux 发行版中,iptables 已经默认切换到了 iptables-nft(即底层调用 nftables API),性能应该自动得到了优化。这是极其致命的错觉。

    iptables-nft 仅仅是一个语法翻译层。当你执行 5 万次 iptables -A INPUT -s IP -j DROP 时,翻译层会在 nftables 中原样生成 5 万条独立的规则。

    在内核 net/netfilter/nf_tables_core.c 的 nft_do_chain() 函数执行时,Netfilter 依然会像老版本一样,对数据包进行 O(N) 的线性遍历匹配。这意味着:

    1. 合法流量的深渊:正常用户的包如果不匹配任何黑名单,必须遍历完这 5.2 万条规则,直到命中链底部的默认 ACCEPT。

    2. SYN 洪水的放大器:虽然通常会在链表顶部配置 iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT,但对于新建连接(SYN)或恶意扫描包,Conntrack 无法命中,依然会陷入 5.2 万次 nft_cmp_eval 的循环对比中。

    单包处理时间的微秒级膨胀,在 10 万 PPS 的乘数效应下,瞬间抽干了 ksoftirqd 的处理能力,导致网卡 Ring Buffer 溢出,触发连环丢包。

    nftables 重构实战:利用 Set/Map 实现 O(1) 降维打击

    要解决这个问题,必须抛弃 iptables 的扁平化规则思维,改用 nftables(推荐版本 >= 1.0.2)原生的集合(Set)数据结构。内核会自动为集合选择合适的数据结构(针对离散 IP 默认使用 rhashtable,针对网段使用 pipapo)。

    1. 编写原生 nftables 配置

    清空旧的 iptables 规则,并加载优化的 nftables 配置:

    # file: /etc/nftables.conf
    flush ruleset
    
    table inet filter {
        # 预先定义一个巨大的哈希集合用于存放黑名单 IP
        set blacklist_ipv4 {
            type ipv4_addr
            flags interval
            auto-merge
            size 100000 # 预分配空间,避免频繁扩容引起的自旋锁竞争
        }
    
        chain input {
            type filter hook input priority filter; policy accept;
    
            # 1. 优先放行已建立的连接,跳过后续检查 (Conntrack 加速)
            ct state established,related accept
    
            # 2. 无效包直接丢弃
            ct state invalid drop
    
            # 3. O(1) 极速匹配黑名单,命中即丢弃
            ip saddr @blacklist_ipv4 drop
    
            # 4. 本地回环与 SSH 放行等常规规则...
            iifname "lo" accept
            tcp dport 22 accept
        }
    }
    

    2. 动态管理海量 IP 且不重载规则

    传统 iptables 增删规则时会对整个链表加锁(xtables_lock),并发极差。而在 nftables 中,向 set 添加元素是轻量级的原子操作,完全不会影响其他规则的执行:

    # 批量导入 5 万个黑名单 IP(执行耗时仅需几十毫秒)
    nft add element inet filter blacklist_ipv4 { 1.1.1.1, 2.2.2.0/24, 3.3.3.3 }
    
    # 删除特定 IP
    nft delete element inet filter blacklist_ipv4 { 1.1.1.1 }
    

    3. 性能验证

    重构上线后,再次压测 30 万 PPS 的新建连接风暴:

    • CPU %soft 消耗直接降至 2% ~ 3%。

    • perf top 中 nft_do_chain 的开销跌出前十。

    • 通过 nft list set inet filter blacklist_ipv4 查看,五万个 IP 被压缩在一次底层的哈希查找中,耗时几近于零。

    底层原理:Pipapo 与 rhashtable 的威力

    在 nftables 的源码实现中(net/netfilter/nft_set_hash.c),当你定义了一个不带 interval(网段)标志的独立 IP set 时,内核默认初始化 rhashtable(可动态扩容的哈希表)。查找复杂度为绝对的 O(1)。

    如果带有 interval 标志(例如混合了 CIDR 网段拦截),内核会使用 pipapo (PIle PAcket POlicies) 算法(net/netfilter/nft_set_pipapo.c)。这是一种针对多维范围匹配高度优化的算法,通过预构建位图(Bitmaps),将多级网段的匹配转换为内存连续的位运算操作,且对 CPU Cache 极其友好。这解释了为何无论黑名单是 5 千还是 5 万,单包处理时延的抖动曲线始终保持平滑。

    常见问题 (FAQ)

    Q1: 在向 nftables 的 Set 中大批量添加 IP 时,会阻塞现有的网络连接吗? 不会。nftables 底层通过 RCU (Read-Copy Update) 机制保障数据的并发读写。对于数据包匹配链路(读侧),RCU 提供了无锁访问能力;而在控制平面批量更新 Set 元素时(写侧),只会发生极短的锁竞争。这与传统 iptables 重载整个规则链引发的剧烈抖动有本质区别。

    Q2: 既然设置了 ct state established accept,为什么之前用 iptables 时,正常流量还是会感觉到高延迟? 因为网络环境并非绝对纯净。即使正常长连接被 Conntrack 放行,但在公网环境中,机器每秒都会遭受大量的垃圾扫描包、伪造包或恶意 SYN 包。这些无状态包无法命中 established,必定会落入后续的 5 万条 iptables 规则中进行线性遍历,进而抢占大量 CPU 资源,导致正常连接的软中断处理被系统调度延后,最终体现为 P99 延迟飙升。

    Q3: 如何将现有的业务脚本从 iptables 平滑迁移到 nftables? 千万不要依赖 iptables-nft 来容忍旧脚本。正确的做法是:

    1. 重写网关的基线规则,用 nft -f 加载带有 Set 的配置结构。

    2. 将现有的封禁/解封脚本,从 iptables -I INPUT -s $IP -j DROP 替换为 nft add element inet filter blacklist_ipv4 { $IP }。

    3. 如果依赖 fail2ban 等第三方工具,需将 action 配置修改为 nftables-multiport 或直接修改其默认的 backend 为 nftables。

  • 深入 Apache Pulsar 延迟雪崩排查:Bookie Journal 刷盘阻塞引发的 P99 飙升与 IO 瓶颈实战

    近期排查了一起 Pulsar 集群(v2.10.4)P99 写入延迟从 5ms 突增至 2s 的雪崩故障。核心根因是 BookKeeper 的 Journal 与 Ledger 未做物理盘隔离,且 RocksDB Compaction 引发大量写放大,导致 fsync 阻塞 IO 线程组。通过硬隔离 NVMe 盘、开启 Direct IO 并优化 Group Commit 参数,最终将 P99 压回 2ms 以内。

    故障现场:P99 延迟雪崩与 Broker 背压

    排查过程中,监控告警显示某核心业务 Topic 的写入耗时剧增。查看 Prometheus 监控,Broker 侧的 pulsar_broker_publish_latency P99 指标平时稳定在 5ms,突发流量下直接飙升到 2000ms 以上,甚至触发了 Client 端的 TimeoutException。

    登录其中一台 Bookie 节点(BookKeeper 4.14.5),直接用 dmesg 和 iostat 摸底硬件状态:

    # 每秒打印一次 IO 状态
    iostat -x -d 1
    Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
    nvme0n1           0.00     0.00    0.00 4521.00     0.00 74523.00    32.96    12.45   15.20    0.00   15.20   0.22 100.00
    

    可以看到 nvme0n1 的 %util 已经被打到 100%,且 w_await 高达 15ms(对于 NVMe 来说,超过 2ms 就已经说明底层队列严重排队了)。

    翻看 Bookie 的 bookkeeper.log,果不其然,满屏的 Journal Sync 超时告警:

    22:14:05.123 [bookie-journal-DIR-sync] WARN  org.apache.bookkeeper.bookie.Journal - Sync object took 1250 ms
    22:14:05.345 [bookie-journal-DIR-sync] WARN  org.apache.bookkeeper.bookie.Journal - Sync object took 1420 ms
    22:14:06.001 [bookie-journal-DIR-sync] ERROR org.apache.bookkeeper.bookie.Journal - Journal Sync queue is full, dropping requests!
    

    为什么明明是存算分离架构,Bookie 的 Journal 刷盘依然会被阻塞?

    Pulsar 吹嘘最多的就是“存算分离”和“读写分离”。但在 BookKeeper 底层,读写分离是有前提的。

    BookKeeper 的一次写入流程(Add Entry)包含两步核心操作:

    1. Append to Journal:将数据追加到 Journal 盘(WAL),并在内存中将数据加入 MemTable。只要 Journal 刷盘(fsync)成功,Bookie 就向 Broker 返回 ACK。

    2. Flush to Ledger:后台线程定期将 MemTable 刷入 Entry Logger(数据文件)和 RocksDB(索引文件),这两个文件通常存放在 Ledger 盘。

    理论上,Journal 负责顺序写,Ledger 负责随机读和后台批量写,互不干扰。但现实很骨感:如果你的 Journal 和 Ledger 共享同一块物理盘,或者共享同一个 PCIe 通道/阵列卡带宽,灾难就会发生。

    在我们的现场,之前的运维人员为了图省事,将 /bookkeeper/data/journal 和 /bookkeeper/data/ledger 挂载到了同一块 2TB 的 NVMe 盘上。当业务触发海量小消息写入时,Ledger 目录下的 RocksDB 疯狂进行 Compaction(文件合并),产生极其严重的写放大。底层文件系统的 Page Cache 被瞬间打满,导致 Journal 线程调用 fsync() 时,被 OS 的脏页回写机制死死卡住。

    Journal 线程一卡,Broker 发来的新请求全部堆积在 Bookie 的 Netty 队列里,进而引发 OOM 风险,最终触发 Broker 侧的背压(Backpressure),全局写入延迟雪崩。

    解决与加固:防御性 IO 隔离与参数调优

    知道了痛点,解决思路就很清晰:物理隔离与绕过 Page Cache 污染。

    1. 物理盘绝对隔离

    永远不要让 Journal 和 Ledger 抢 IO。Journal 盘需要极低的 fsync 延迟,容量不需要太大(只保存 WAL,写满后会滚动删除);Ledger 盘需要大容量,对 IOPS 也有一定要求(特别是有 Catch-up 追赶读的场景)。

    实战配置:

    • Journal:挂载独立的 100G NVMe SSD。

    • Ledger:挂载大容量的 SATA SSD 或阵列。

    在 bookkeeper.conf 中明确拆分:

    journalDirectories=/data/journal/bk
    ledgerDirectories=/data/ledger/bk
    

    2. 启用 Ledger Direct IO,避免 Page Cache 污染

    Ledger 的后台 Flush 和 Catch-up 读非常容易污染操作系统的 Page Cache,导致真正需要 Page Cache 加速的读请求被驱逐,甚至影响其他进程的 IO 性能。 在 BookKeeper 4.14+ 中,建议开启 DbLedgerStorage 的 Direct IO,直接让读写绕过 OS 缓存。

    # 使用 DbLedgerStorage
    storage_facility=org.apache.bookkeeper.bookie.DbLedgerStorage
    
    # 针对 Entry Logger 开启 Direct IO (绕过 Page Cache)
    dbStorage_directIOEntryLogger=true
    
    # 分配给 RocksDB Block Cache 的内存(建议占节点物理内存的 10%-20%)
    dbStorage_rocksdbBlockCacheSize=4294967296
    # 增加 Write Cache 以减少高并发下的 RocksDB 刷盘频次
    dbStorage_writeCacheMaxSizeMb=1024
    

    3. Journal Group Commit (组提交) 调优

    Journal 是靠 fsync 保证数据不丢的(journalSyncData=true 绝对不能关,关了就是拿命在跑)。但高并发下,每一条消息都 fsync 会让 NVMe 直接瘫痪。 我们需要调整 Group Commit 参数,让 Bookie 在延迟和吞吐之间找到一个平衡。

    # 最大等待时间,默认 1ms。如果你的网络/磁盘稍有抖动,1ms 太激进。建议改为 2-5ms,牺牲微小延迟换取巨大吞吐。
    journalMaxGroupWaitMSec=2
    
    # 队列中积压多少字节触发一次强制刷盘,默认 512KB,可适当调大到 1MB 或 2MB
    journalBufferedWritesThreshold=1048576
    
    # 如果 Journal 盘写入排队依然严重,可以增加 Journal 目录的数量(多盘配置)
    journalDirectories=/data/journal1/bk,/data/journal2/bk
    

    重启 Bookie 节点后,再次观察 iostat,nvme0n1(Journal盘)的 w_await 稳定在 0.5ms 以内,Pulsar 生产端的 P99 写入延迟死死压在 2ms,故障彻底解除。

    常见问题 (FAQ)

    Q:为什么开启了存算分离,消费端(Consumer)追赶历史数据(Catch-up Read)时,还是会导致生产端(Producer)延迟抖动? A:如果没有开启 Ledger 的 Direct IO,追赶读会把大量历史冷数据加载到 OS Page Cache,把操作系统的空闲内存耗光,触发 OS 的全局脏页回写(Global Flush)。此时哪怕 Journal 在另一块盘上,CPU 和总线也会受到系统态 IO 阻塞的影响。解决方案就是强制配置 dbStorage_directIOEntryLogger=true。

    Q:journalSyncData=false 能不能用来解决 P99 高的问题? A:可以解决监控上的数字问题,但会解决掉你的饭碗。设置为 false 意味着数据写到 OS Page Cache 就直接向 Broker 返回成功,一旦 Bookie 所在机器断电或 Kernel Panic,尚未刷盘的数据将永久丢失。对于金融级或核心交易场景,必须保持为 true,靠优化硬件和 Group Commit 来提速。

    Q:如何预估和监控 RocksDB 引发的写放大? A:重点监控 Bookie 的 bookkeeper_server_DbLedgerStorage_compaction_time 和 IO 设备的写入量。如果发现 Ledger 盘的实际写入速率是业务写入速率的 3 倍以上,说明遇到了 RocksDB 的写放大瓶颈。可以通过调大 dbStorage_writeCacheMaxSizeMb 和限制后台 Compaction 线程的速率来缓解。

    Q:多租户场景下,个别异常租户的高频写入会不会打满 Bookie 导致全局故障? A:会。Bookie 底层是对所有 Topic 的 Entry 进行混合追加写的,一个 Topic 的流量突增会吃光 Journal 的 fsync 能力。必须在 Broker 端开启严格的资源配额(Quota)和按租户/Namespace 的流量限流(Rate Limiting),这叫“防御性运维”。不要指望底层存储能无限制抗住上层的不合理调用。

  • 深入 NVMe 队列阻塞排查:blk-mq 调度器误用引发的 XFS 元数据锁雪崩与 sys CPU 饱和实战

    高并发写入场景下,NVMe 盘配合 XFS 极易触发 sys CPU 满载与 IO 夯死。核心原因是 NVMe 误用了 mq-deadline 调度器,导致 blk-mq 软件队列自旋锁争用,进而引发 XFS 分配元数据时在 xfs_log_commit_cil 处发生锁雪崩。直接结论:NVMe 设备的 IO 调度器必须设为 none,同时对于高并发盘,需在格式化时调大 XFS 的 agcount 以打散锁粒度。

    故障现场:数据库写入 p99 突增与 sys CPU 飙升

    某次排查过程中,一套承载核心业务的 PostgreSQL 集群(内核版本 5.10.134-el8,底层存储为裸金属物理机的 PCIe Gen4 NVMe SSD)在高并发 COPY 导入数据时,QPS 出现周期性断崖式下跌。

    通过 top 观察,CPU sys 态长期飙升至 70% 以上,iowait 反而在 10% 左右波动。这极不寻常——对于一块标称 100万 IOPS 的 NVMe 盘,IO 没有跑满,CPU 却在内核态被榨干。

    抓取当时的 iostat -x 1 核心指标:

    Device:         r/s     w/s     rkB/s     wkB/s   rrqm/s   wrqm/s  %rrqm  %wrqm r_await w_await aqu-sz rareq-sz wareq-sz  svctm  %util
    nvme0n1        12.0 42351.0     192.0  680512.0     0.0     0.0    0.0    0.0    0.15   18.42   12.5   16.00    16.06   0.02  85.40
    

    注意 w_await 达到了惊人的 18.42ms,对于 NVMe 来说,这个延迟意味着底层已经严重阻塞。但 %util 只有 85%,设备并未完全饱和。

    使用 perf top -U 直接看内核态热点,现场如下:

      18.45%  [kernel]  [k] queued_spin_lock_slowpath
      12.31%  [kernel]  [k] dd_insert_requests
       8.52%  [kernel]  [k] xfs_log_commit_cil
       6.14%  [kernel]  [k] blk_mq_submit_bio
       5.33%  [kernel]  [k] _raw_spin_lock_irqsave
    

    热点非常集中:dd_insert_requests 和 xfs_log_commit_cil。这表明系统同时在块设备调度层和文件系统日志提交层发生了严重的锁争用。

    为什么 NVMe 设备使用 mq-deadline 会导致 IO 栈雪崩?

    问题出在 Linux blk-mq(Block Multi-Queue)架构的调度器选择上。

    在传统的单队列(Single Queue)时代,所有 IO 请求进入一个全局队列,需要 CFQ 或 Deadline 这种电梯算法(Elevator)进行合并和排序,以减少机械硬盘的磁头寻道。

    到了 NVMe 时代,硬件支持多达 64K 个提交/完成队列。Linux 为此重构了 blk-mq 架构,分为软件队列(Software Staging Queues,通常每个 CPU 核心一个)和硬件分发队列(Hardware Dispatch Queues)。

    排查发现,该服务器的 NVMe 被默认配置了 mq-deadline 调度器:

    $ cat /sys/block/nvme0n1/queue/scheduler
    [mq-deadline] kyber bfq none
    

    底层阻塞原理: 当调度器设置为 mq-deadline(甚至 bfq)时,IO 请求在进入硬件队列前,必须先挂载到电梯算法的软件队列中。dd_insert_requests 就是 mq-deadline 插入请求的内核函数。由于高并发下成千上万个线程试图向这个软件队列提交 BIO(Block I/O),这就不可避免地触发了自旋锁(queued_spin_lock_slowpath)。 NVMe 的纳秒级响应速度完全被软件队列的自旋锁开销抹平,导致 CPU 在 sys 态空转,IO 提交路径被硬生生卡住。

    剥茧抽丝:XFS 延迟分配与 AIL/CIL 阻塞

    块设备的延迟飙升,迅速引发了文件系统层的连锁反应,这也是为什么 perf 中出现了大量 xfs_log_commit_cil。

    XFS 是一种强依赖 Allocation Group(AG)并发设计的日志文件系统(当前版本 V5)。当数据库执行大量写入时,XFS 会利用延迟分配(Delayed Allocation)机制,在内存中缓存数据,直到刷盘时才真正分配物理 Block 并更新元数据。

    1. CIL(Committed Item List)雪崩:元数据变更首先写入内存中的 CIL。当底层 NVMe 因为 mq-deadline 阻塞时,后台刷脏线程(xfsaild)将 AIL(Active Item List)刷入磁盘的速度骤降。

    2. AG 锁争用:CIL 空间被占满,前端业务线程在调用 xfs_alloc_vextent 申请新的空间块时,必须等待日志空间释放。大量 PostgreSQL 线程被迫在同一个 AG 的元数据锁上排队。

    3. 全局夯死:IO 栈的阻塞放大了 XFS 的锁临界区时间,最终导致原本并行的 IO 瀑布般退化为串行等待,形成死锁态势的雪崩。

    解决方案与防御性配置

    解决该问题不需要修改业务代码,纯属系统级架构调优,分为治标和治本两步。

    1. 立即剥离软件调度器(实时恢复)

    将 NVMe 设备的调度器强行切换为 none,绕过所有电梯算法,让 BIO 请求直接从软件多队列打入硬件队列。

    echo none > /sys/block/nvme0n1/queue/scheduler
    

    执行瞬间,sys CPU 从 70% 骤降至 8%,PostgreSQL QPS 恢复正常,w_await 回落至 0.05ms。

    为了防止重启失效,通过 udev 固化防御策略:

    # vim /etc/udev/rules.d/60-io-scheduler.rules
    ACTION=="add|change", KERNEL=="nvme[0-9]*", ATTR{queue/scheduler}="none"
    

    2. XFS AG 并发度调优(底层重构)

    默认情况下,mkfs.xfs 根据磁盘大小自动计算 agcount(通常是 4 或 8)。对于大容量、极高吞吐的 NVMe 盘和数据库场景,默认 AG 数量太少,容易发生并发分配碰撞。 在节点下线重装阶段,调整格式化参数,人为扩大 AG 数量打散锁粒度:

    # 格式化 XFS:强制启用 32 个 AG,对齐 512M 日志大小
    mkfs.xfs -f -K -d agcount=32 -l size=512m,version=2,su=256k /dev/nvme0n1
    

    注:agcount 并非越大越好,过大会增加 mount 时间和内存开销,通常 16-32 针对高端 NVMe 是甜点区间。

    常见问题

    Q1: io_uring 在遇到这种 XFS 锁争用时,会退化成同步阻塞吗? 会。这是很多人使用 io_uring 踩坑的地方。虽然 io_uring 是异步 IO,但如果在文件系统层发生 metadata 锁争用(比如 XFS 分配 block),底层的 IORING_OP_WRITE 且带有 RWF_NOWAIT 标志位时,内核会直接返回 -EAGAIN。随后 io_uring 只能将这个 IO 任务推入后台的 io_worker 线程池进行同步阻塞处理,纯异步链路被击穿,高并发下依然会导致线程池耗尽。

    Q2: 调度器设置为 none 后,系统还有 IO 合并能力吗? 有,但发生在不同层级。none 确实禁用了电梯算法层的合并,但 blk-mq 在软件队列层(Software Staging Queue)和块设备硬件驱动层依然会利用 scatter-gather list 进行有限的相邻物理段合并。对于 NVMe 而言,本身 4K 随机 IO 的性能极高,强行进行复杂的 IO 合并排序带来的 CPU 锁开销远大于其收益。

    Q3: 如何在生产环境无损监控 XFS 的 AG 锁争用情况? 极力推荐使用 eBPF/bpftrace 而不是 SystemTap。可以通过挂载 tracepoint 实时监控 CIL 提交延迟:

    bpftrace -e 'tracepoint:xfs:xfs_log_commit_cil { @start[tid] = nsecs; } tracepoint:xfs:xfs_log_commit_cil_wait { if(@start[tid]) { @usecs = hist((nsecs - @start[tid]) / 1000); delete(@start[tid]); } }'
    

    如果输出的直方图显示大量调用耗时超过 1000 微秒(1ms),说明文件系统日志提交已出现严重积压,需立即排查底层块设备延迟。

  • Kafka 集群 P99 飙升至 3000ms:强制开启 SSL 击穿零拷贝引发的 ISR 频繁收缩与雪崩

    近期处理了一起非常典型的 Kafka 核心集群生产事故:业务反馈生产耗时 P99 从平时的 10ms 突增至 3000ms 以上,消费端出现大面积堆积。排查发现,集群的 Under Replicated Partitions (URP) 指标狂飙,Controller 频繁进行 Leader 选举。

    最终结论直接抛出:这是一起因“安全合规”要求,盲目在 Broker 间以及所有 Client 强制开启 SSL/TLS 加密,导致 Linux底层的 sendfile(零拷贝)机制彻底失效,叠加某下游业务重放海量历史数据引发 PageCache 穿透,最终打满 CPU 且耗尽内存带宽的惨案。Follower 无法在 replica.lag.time.max.ms 内完成数据同步,导致 ISR 疯狂收缩与扩散,进而引发集群级雪崩。

    安全合规当然要做,但在没有经过基准压测的情况下,用一纸行政命令违背底层的 I/O 物理规律,除了给系统带来毁灭性打击外毫无意义。今天把底层的调用链剖开,看看零拷贝是怎么被干碎的。

    现场还原:被击穿的 I/O 与失控的 ISR

    接到告警时,监控面板上的数据已经可以用“惨烈”来形容:

    1. CPU 指标异常:平时 usr 利用率不到 15% 的 Broker 节点,usr 飙升至 85%,sys 飙到 15%,Context Switches(上下文切换)激增。

    2. URP 指标报警:kafka.server:type=ReplicaManager,name=UnderReplicatedPartitions 从 0 飙升到数百。

    3. Broker 日志刷屏:大量的 ISR 踢出与拉入日志,Zookeeper 会话出现超时。

    [202X-XX-XX 14:12:05,123] INFO [Partition topic-user-event-4 broker=1] Shrinking ISR from 1,2,3 to 1. (kafka.cluster.Partition)
    [202X-XX-XX 14:12:18,456] INFO [Partition topic-user-event-4 broker=1] Expanding ISR from 1 to 1,2. (kafka.cluster.Partition)
    

    更致命的是,为了保证数据不丢失,该集群配置了强一致性参数 acks=all 以及 min.insync.replicas=2。当 ISR 缩减到只剩 Leader(1 个副本)时,Producer 瞬间收到了海量的 NotEnoughReplicasException 报错,整个业务写入链路直接被掐断。

    底层原理解析:当 SSL 遇到 Kafka

    为什么开个 SSL 能把集群干趴下?这要从 Kafka 引以为傲的高吞吐内核设计——零拷贝(Zero-Copy) 说起。

    1. 正常状态下的数据流转(sendfile)

    在未开启 SSL(PLAINTEXT)时,Consumer(包括作为特殊 Consumer 的 Follower 副本)向 Broker 发起 Fetch 请求,Broker 直接利用 Linux 操作系统的 sendfile 系统调用。

    数据流转路径:磁盘 -> DMA Copy -> OS PageCache -> DMA Copy -> 网卡 Buffer。 整个过程没有任何数据被拷贝到用户态空间(User Space),CPU 的参与度极低,只负责下发指令和管理文件描述符。

    可以通过 strace 命令清晰地看到高频的 sendfile 调用:

    # 跟踪 kafka 进程的系统调用统计
    strace -f -p $(pgrep -f kafka) -e trace=sendfile,read,write -c
    
    % time     seconds  usecs/call     calls    errors syscall
    ------ ----------- ----------- --------- --------- ----------------
     98.15    4.521012          52     86942           sendfile
      1.02    0.047101          10      4710           write
      0.83    0.038102           9      4233           read
    

    2. 开启 SSL 后的数据流转(零拷贝失效)

    SSL/TLS 属于应用层的加密协议。要对数据进行加密,内核态的 PageCache 就无能为力了,数据必须被读取到用户态的 JVM 内存中进行加密运算。

    此时 sendfile 退化为 read + write 的组合。 数据流转路径变成了:磁盘 -> DMA Copy -> OS PageCache -> CPU Copy -> User Space (JVM 堆外/堆内) -> CPU 执行加密算法 -> CPU Copy -> Socket Buffer -> DMA Copy -> 网卡 Buffer。

    上下文切换从 2 次增加到 4 次,数据拷贝次数增加,最要命的是 CPU 变成了密集型加密工人。结合当时的 strace 抓包,sendfile 的调用次数直接归零,取而代之的是暴涨的 read 和 write。

    3. 压死骆驼的最后一根稻草:历史数据回溯

    如果仅仅是开启 SSL,在常态流量下 CPU 也许还能扛住。但恰巧排查过程中发现,某大数据团队上线了一个新任务,从头消费(auto.offset.reset=earliest)一个高达数 TB 的核心 Topic。

    这种冷读行为导致了严重的 PageCache 污染与穿透。 Broker 不得不从物理磁盘读取冷数据,拉入 PageCache,再 Copy 到用户态进行 SSL 加密。磁盘 I/O 等待(iowait)、CPU 资源耗尽、内存带宽打满三管齐下。Broker 的网络线程池(num.network.threads)被这些沉重的处理逻辑长时间阻塞。

    故障传播链:ISR 机制引发的血案

    底层 I/O 阻塞后,Kafka 内核的分布式状态机开始崩溃,形成经典的雪崩链:

    1. Follower 同步延迟:Follower 向 Leader 发送的 FetchRequest 被积压在 Leader 的网络请求队列中。

    2. 触发 ISR 剔除:Leader 发现 Follower 超过 replica.lag.time.max.ms(默认 30000ms)没有成功拉取数据,认为 Follower 挂了,将其移出 ISR 列表。

    3. Zookeeper 冲击:Leader 将新的 ISR 状态写入 Zookeeper,频繁的元数据更新让 Zookeeper 的负载飙升。

    4. 业务断流:由于 min.insync.replicas=2,ISR 只剩 1 时,Leader 拒绝接收新的 Produce 请求。

    5. Leader 选举风暴:极端情况下,Broker 自身的 GC 停顿或 CPU 饥饿导致与 ZK 的 Session Timeout,Controller 认为 Broker 宕机,开始进行大规模的 Leader 切换,整个集群进入瘫痪状态。

    破局与防御性架构落地

    解决这个问题,不能头痛医头去改大 replica.lag.time.max.ms(这只会掩盖问题),必须从架构和配置层面进行隔离。

    1. 剥离内部 SSL,回归零拷贝 坚决摒弃“一刀切”的加密策略。将 Kafka 部署在安全的 VPC 内,配置多 Listener。Broker 间复制(内部流量)绝对禁止使用 SSL,保障 Follower 同步时的零拷贝效率。外部不可信网络接入时才走 SSL Listener。

    # 监听器隔离:内网明文,外网加密
    listeners=INTERNAL://0.0.0.0:9092,EXTERNAL_SSL://0.0.0.0:9093
    # 强制规定内部 Broker 通信必须走明文
    security.inter.broker.protocol=PLAINTEXT
    listener.security.protocol.map=INTERNAL:PLAINTEXT,EXTERNAL_SSL:SSL
    

    2. 物理资源隔离与 Quota 限流 针对重放历史数据的“野蛮”消费者,必须在 Kafka 层面实施配额(Quota)限制,防止单个 Consumer 耗尽 Broker 的网络带宽和 CPU。

    # 限制特定 Client-ID 的拉取速率 (例如限制为 50MB/s)
    bin/kafka-configs.sh --bootstrap-server localhost:9092 \
      --alter --add-config 'consumer_byte_rate=52428800' \
      --entity-type clients --entity-name bad_consumer_client
    

    3. 内核参数调优防御 为了缓解偶尔的网络抖动导致的 ISR 频繁变动,适当微调相关参数,但不要偏离合理区间:

    • replica.lag.time.max.ms:结合网络 P99 延迟,可适当从 30s 调至 45s-60s。

    • num.network.threads 和 num.io.threads:在开启不可避免的 SSL 节点上,根据 CPU 核数增加处理线程,避免请求队列阻塞。

    排查清单:Kafka 性能骤降同类问题速查

    如果遇到类似 P99 飙升、URP 报警的问题,直接按以下清单排查:

    1. 查零拷贝状态:执行 strace -p -e trace=sendfile,read,write -c,如果 sendfile 占比极低且 read/write 极高,立刻检查是否有 SSL 开启或某些拦截器组件强制将数据读入了 User Space。

    2. 查 PageCache 命中率:通过 iostat -xdm 1 观察磁盘的 rMB/s。如果读磁盘的吞吐量极高,说明发生了冷读穿透,立刻通过 kafka-consumer-groups.sh 定位是哪个 Group 在重放历史数据。

    3. 查网络/IO线程阻塞:查看 JMX 指标 kafka.network:type=RequestMetrics,name=RequestQueueTimeMs。如果队列等待时间过长,说明 Broker 处理线程池已经打满。

    4. 查 ISR 震荡日志:在 server.log 中 grep "Shrinking ISR"。如果伴随频繁变动,且写入端出现 NotEnoughReplicasException,先检查集群级别的网络连通性及 Broker 负载,切勿盲目通过脚本强行 Reassign Partitions,那只会加重 IO 负担。