分类: 系统运维

  • 深入 nf_conntrack 满载丢包排查:SNAT 端口耗尽引发的 SYN 阻断与 nftables Flowtable 旁路加速实战

    高并发网关常遇 nf_conntrack: table full 导致 SYN 丢包。盲目调大 nf_conntrack_max 只会加剧内核自旋锁争用与内存开销。根本解法是排查 SNAT 端口耗尽,并从 iptables 彻底迁移至 nftables,利用 Flowtable 机制开启流量卸载(Offload),让 ESTABLISHED 状态报文旁路跳过 Netfilter 核心链,实测可降低 40% 的 sys CPU 并彻底消除连接跟踪瓶颈。

    案发现场:诡异的 99 线毛刺与超时

    排查过程中,某承载了上万并发连接的 K8s Egress NAT 网关节点(Kernel 5.15.0)频繁出现请求超时,监控大盘显示 TCP 99线延迟出现规律性毛刺,Load Average 中的 sys CPU 间歇性飙升到 80% 以上。

    直接上机器看内核日志:

    $ dmesg -T | tail -n 20 | grep conntrack
    [Thu Oct 26 14:12:33 2023] nf_conntrack: nf_conntrack: table full, dropping packet
    [Thu Oct 26 14:12:33 2023] nf_conntrack: nf_conntrack: table full, dropping packet
    

    经典的连接跟踪表爆满导致丢包。看一下当前连接数与上限:

    $ sysctl net.netfilter.nf_conntrack_count net.netfilter.nf_conntrack_max
    net.netfilter.nf_conntrack_count = 262144
    net.netfilter.nf_conntrack_max = 262144
    

    为什么盲目调大 nf_conntrack_max 是一剂毒药?

    遇到 table full,很多人的第一反应是无脑加大 nf_conntrack_max。在低并发场景下这确实管用,但在高吞吐 NAT 网关上,这是一剂毒药。

    nf_conntrack 是基于哈希表实现的。它的核心数据结构由 Hash buckets(桶)和链表组成。当你只调大 nf_conntrack_max 而不调整 nf_conntrack_buckets 时,每个 Hash bucket 下挂载的链表会变得极长。 内核在进行包过滤或 NAT 时,需要遍历链表来匹配五元组。链表越长,查询的开销越大;加上 Hash bucket 的自旋锁(spinlock)争用,在多核高 PPS(Packet Per Second)场景下,CPU 会被 __nf_conntrack_find_get 等函数吃干抹净(表现为软中断 si 和内核态 sy CPU 极高)。

    正确的临时缓解姿势必须是联动调整(保持桶大小为最大连接数的 1/4):

    # 1. 调大 Hash 桶大小(立即生效,不可通过 sysctl 修改)
    $ echo 262144 > /sys/module/nf_conntrack/parameters/hashsize
    # 2. 调大最大连接数
    $ sysctl -w net.netfilter.nf_conntrack_max=1048576
    # 3. 缩短 TIME_WAIT 和 ESTABLISHED 状态的超时时间,加速条目回收
    $ sysctl -w net.netfilter.nf_conntrack_tcp_timeout_established=300
    $ sysctl -w net.netfilter.nf_conntrack_tcp_timeout_time_wait=30
    

    但这只是治标。抓包发现,该节点作为 SNAT 网关,真实存在的活跃连接并没有达到 26 万,导致表满的真凶是 SNAT 端口耗尽引发的僵尸连接积压。由于 iptables 的 MASQUERADE 规则,多个内网 Pod 访问外部同一个目标 IP:Port 时,由于源端口池(默认 1024-65535)被快速消耗殆尽,新的 SYN 包在进行 NAT 转换时无法分配到 free tuple,导致连接状态卡死并在 conntrack 表中滞留。

    iptables 时代的穷途末路与 nftables 破局

    只要你还在用 iptables,每一个数据包都要不可避免地穿透 PREROUTING -> FORWARD -> POSTROUTING 整条链。即使是已经建立连接(ESTABLISHED)的报文,也要每次去走一遍 Rule 解析和 Conntrack 状态机。

    Kernel 4.16+ 引入了 nftables 的杀手锏功能:Flowtable (Fast-path Offload)。 它的底层原理极其优雅:对于已经建立连接的 TCP/UDP 流量,Flowtable 会在网卡的 ingress hook 点(非常靠前的位置)直接进行路由转发和 NAT 替换,完全绕过传统的 Netfilter 过滤链和 Conntrack 查询

    实战:将 iptables NAT 迁移至 nftables Flowtable

    不要再用 iptables-nft 这种套壳工具了,直接写原生的 nftables 配置。以下是我们在网关节点上的落地配置,实现内网到外网的 SNAT 并开启 Flowtable 硬件/软件卸载。

    清除老旧规则:

    $ iptables -F && iptables -t nat -F
    $ systemctl stop iptables
    

    编写 /etc/nftables.conf

    flush ruleset
    
    table inet filter {
        # 定义 Flowtable 开启卸载
        flowtable f {
            # 挂载在非常靠前的 ingress 钩子,优先级 0
            hook ingress priority 0;
            # 绑定内外网网卡(根据实际情况修改)
            devices = { eth0, eth1 };
        }
    
        chain forward {
            type filter hook forward priority 0; policy drop;
    
            # 核心逻辑:允许 ESTABLISHED 流量,并将新流量加入 flowtable 'f'
            ip protocol { tcp, udp } flow add @f
    
            # 允许内网 (10.0.0.0/8) 到外网的初始包通过
            iifname "eth0" oifname "eth1" ip saddr 10.0.0.0/8 accept
    
            # 允许已建立连接的回包
            ct state established,related accept
        }
    }
    
    table ip nat {
        chain postrouting {
            type nat hook postrouting priority 100; policy accept;
            # 传统 SNAT/Masquerade,只对首包生效
            oifname "eth1" ip saddr 10.0.0.0/8 masquerade random
        }
    }
    

    应用配置并验证:

    $ nft -f /etc/nftables.conf
    $ nft list ruleset
    

    注意:masquerade random 的加入是为了缓解 SNAT 端口分配的哈希碰撞冲突,配合 Flowtable 能最大程度压榨网关性能。

    性能表现对比

    迁移至 nftables Flowtable 后,使用 perf top 观察内核函数调用:

    • 迁移前ipt_do_tablenf_conntrack_in 长年霸占 Top 3,软中断消耗极大。

    • 迁移后:由于首包建立连接后,后续几十个甚至成百上千个数据包直接从网卡 ingress 进入 nft_flow_offload_eval 后被路由发出,ipt_do_table 直接消失,sys CPU 占用率暴降 40% 以上,dmesg 中再无 table full 报错。

    常见问题 (FAQ)

    Q1:为什么我明明清空了 iptables,用 iptables -L 还能看到一些莫名其妙的规则? 因为较新的 OS(如 Debian 11+, RHEL 8+)默认将 iptables 软链接到了 iptables-nft。这是兼容层,你在 iptables 敲的命令,其实被转换成了 nftables 的内置表。要查看纯正的 iptables 规则,请使用 iptables-legacy -L。在系统层面彻底向 nftables 演进时,强烈建议干掉所有 legacy 和兼容层,统一用 nft 命令行管理。

    Q2:开启 nftables Flowtable 之后,为什么 tcpdump 抓不到部分数据包了? 这是预期行为。Flowtable 提供了 Software Offload 和 Hardware Offload (NIC HW offload)。如果是 Hardware offload(需要网卡驱动支持 tc 卸载),数据包在物理网卡层面就被转发了,根本不会进入内核网络栈,挂在 AF_PACKET 上的 tcpdump 自然抓不到。即使是 Software offload,由于绕过了常规的 Netfilter RX 路径,抓包结果也会呈现“只看到 SYN 包,看不到后续数据流”的现象。排查网络问题时,需要临时禁用 flowtable 规则。

    Q3:在 K8s 中使用 IPVS 模式的 kube-proxy,也会受 nf_conntrack 限制吗? 会。虽然 IPVS 维护了自己的连接管理哈希表,但它仍然深度依赖 Netfilter 框架做底层的包拦截和 NAT 协调(尤其是 nf_conntrack)。K8s 场景下大量短连接(如探针、微服务间 RPC)极易打满 conntrack。除文中提到的调优手段外,建议通过 kube-proxy 启动参数 --conntrack-max-per-core 来合理规划容量,而非手动修改 sysctl,防止被 Kubelet 重置。

  • 深入 Zabbix 监控雪崩排查:LLD 发现风暴引发的 Proxy 缓存积压与 History Syncer 夯死实战

    近期处理了一起 Zabbix 6.0 LTS 集群雪崩事故。根因是某业务线引入劣质自定义 LLD 模板,单机生成逾万监控项,引发 Proxy 缓存打满与 History Syncer 进程 100% 繁忙,最终压垮后端 DB IO 导致全局断连。核心解法:阻断异常 LLD 发现、调优 Zabbix 核心缓存参数,并将底层存储彻底迁移至 PostgreSQL + TimescaleDB 解决写入墙问题。

    故障现场:Queue 积压与 Poller 满载

    排查过程中,监控大屏首先报警的是 Zabbix Queue 严重积压,延迟超过 10 分钟的 item 数量直线飙升破 5 万。登录 Zabbix Server 核心节点,top 命令显示 Load Average 飙升至 80+,系统 iowait 长期盘踞在 40% 以上。

    查看 Zabbix Server 日志 /var/log/zabbix/zabbix_server.log,满屏都是极其致命的告警:

    Zabbix server history syncer processes more than 75% busy
    Zabbix server history syncer processes more than 100% busy
    server is out of memory: Out of memory (data: 256M, index: 64M)
    cannot accept connection from proxy "cn-sh-proxy-01": max number of Trapper processes reached
    

    切到前端分布式 Proxy 节点 /var/log/zabbix/zabbix_proxy.log,同样处于崩溃边缘:

    cannot send proxy data to server at "10.0.0.10": Zabbix server connection failed
    history cache is full, sleeping for 1 second
    

    表象很清晰:数据写不进数据库,导致 Zabbix Server 的 History Syncer(负责将内存数据刷入 DB 的核心进程)全部夯死。Server 端 Trapper 进程耗尽,导致 Proxy 无法上报数据,Proxy 本地的 HistoryCache 被打爆,最终整个监控链路瘫痪。

    为什么一个简单的自定义模板能搞垮整个监控集群?

    很多开发在写 Zabbix 监控脚本时,缺乏“防御性编程”思维。抓取故障现场的 Proxy sqlite3 库(或本地临时文件),发现罪魁祸首是一个名为 Custom_K8s_Pod_Discovery 的 LLD (Low-Level Discovery) 脚本。

    该脚本通过 Python 遍历全量 Pod 状态,但没有做任何 Limit 限制和状态机过滤。单台 Kubernetes Node 上的脚本直接返回了近 5MB 的 JSON Array:

    {
      "data": [
        {"{#PODNAME}": "web-api-7b89f...", "{#NAMESPACE}": "prod", "{#CONTAINER}": "nginx"},
        // ... 往下还有 15000+ 个对象
      ]
    }
    

    Zabbix LLD 引擎在处理这个宏大 JSON 时,会为每一个 {#PODNAME} 动态生成 5 个 Item(CPU、内存、网络 IO 等)。 算一笔账:1 台机器抛出 15000 个实体 $\times$ 5 个 Item = 75000 个监控项。 如果是 100 台节点的集群,瞬间生成 750 万个新监控项

    这些海量监控项每 30 秒采集一次数据,疯狂涌入 Zabbix Proxy。 Proxy 的默认 HistoryCacheSize 仅有区区 16M,瞬间被打满。随后 Proxy 将庞大的 Payload 塞给 Zabbix Server,Server 端的 History Syncer 试图将这几百万条并发写入后端的 MySQL history_uint 表。MySQL InnoDB 面对这种毫无规律的极高频并发 Insert,B+ 树页分裂严重,NVMe 磁盘的 IOPS 直接打满,写延迟达到 500ms 以上,彻底堵死。

    架构级改造:从 MySQL 到 PG+TimescaleDB

    在千万级 Item 的企业监控场景下,MySQL 表分区脚本(如常用的 partitioning.sql 存储过程)不仅维护极其痛苦,且对历史数据的清理依然会产生锁争用。

    解决写入瓶颈的最终态方案,是利用原生时序数据库。Zabbix 从 5.0 开始深度支持 PostgreSQL + TimescaleDB 扩展,将 history 相关的表转化为 hypertable,实现按时间维度的透明 Chunk 分片。

    迁移与落地步骤:

    1. 部署 PostgreSQL 14 与 TimescaleDB 插件。

    2. 导入 Zabbix 基础 Schema 后,务必执行 TimescaleDB 转换脚本:

    # Zabbix 6.0 环境下开启 TimescaleDB 支持
    zcat /usr/share/doc/zabbix-sql-scripts/postgresql/timescaledb.sql | sudo -u zabbix psql zabbix
    
    1. 在 Zabbix Server 开启内部历史数据压缩(极大降低磁盘 IO 并节省 70% 空间):
    -- 连接到 zabbix 库
    UPDATE config SET db_extension='timescaledb', history_compression_status=1, history_compress_older='7d';
    

    切换到 TimescaleDB 后,Zabbix History Syncer 的写操作变成了针对内存中最新 Chunk 的顺序追加写(Append-only),避开了全表扫描和巨型 B-Tree 维护,单机轻松抗住 10万+ QPS 的监控项写入。

    调优与防御性配置落地

    底层存储问题解决后,必须对 Zabbix 核心配置进行防御性加固,防止类似 LLD 风暴再次冲垮服务。

    1. Zabbix Server 核心参数重调

    编辑 /etc/zabbix/zabbix_server.conf

    # 根据物理内存,大幅提高历史缓存,作为 DB 抖动时的缓冲池
    HistoryCacheSize=2G
    HistoryIndexCacheSize=256M
    ValueCacheSize=1G
    
    # 增加数据刷盘进程数(需结合 DB 最大连接数考量)
    StartHistorySyncers=30
    
    # 增加处理 Proxy 和 Agent 主动上报的 Trapper 进程
    StartTrappers=100
    
    # 禁用 Server 端轮询,强制全部走 Proxy 分布式采集
    StartPollers=0
    

    2. Zabbix Proxy 缓冲防御

    编辑 /etc/zabbix/zabbix_proxy.conf

    # 提高 Proxy 侧的缓存,容忍更长时间的 Server 端断连
    HistoryCacheSize=1G
    HistoryIndexCacheSize=128M
    
    # 严格控制外部脚本超时时间,防止进程卡死(默认3秒,最大不超过10秒)
    Timeout=10
    

    3. 数据预处理(Pre-processing)截流

    针对自定义监控项,强制要求在 Zabbix Web UI 的 Item Preprocessing 中配置以下规则:

    • Discard unchanged with heartbeat (心跳抑制): 如果监控值没有变化,直接在 Proxy/Server 端丢弃,只在达到 heartbeat(如 1 小时)时强制写入一次。这能削减 60% 以上的无用状态写入。

    • 正则表达式过滤: 对 LLD 发现的文本进行白名单截断,丢弃非核心进程的数据。

    常见问题

    Q1: Proxy 报错 “Zabbix server connection failed”,但网络 Ping 和 Telnet 都通,如何排查? 通常不是网络问题,而是 Zabbix Server 端的 Trapper 进程全忙。检查 Zabbix Server 监控大屏上的 Zabbix server trapper processes busy 指标是否达到 100%。若是,需调大 StartTrappers,或检查是否有超大 Payload 正在阻塞网络层解析。

    Q2: 监控项经常出现断点,日志提示 “first network error, wait for 15 seconds”,如何优化? 这是 Poller 进程在执行某些慢请求(如大文本抓取、远端 API 调用)时超时了。Zabbix 默认超时 Timeout=3 秒。建议将耗时任务改成 Agent 端的异步 Crontab 写入本地文件,Zabbix 只做简单的 vfs.file.contents 读取;或者将 Timeout 谨慎上调至 10。

    Q3: 迁移到 TimescaleDB 后,Zabbix 的 Housekeeper 还需要开启吗? 绝对不需要对历史表开启。开启 TimescaleDB 后,应在 Zabbix UI 的 “Administration -> General -> Housekeeping” 中,勾选 Override item history period 并启用内部机制。旧数据的清理会由 DB 原生的 drop_chunks() 函数瞬间完成,而不是 Housekeeper 一行行执行极度耗 IO 的 DELETE 语句。

    Q4: 怎样防止自定义 LLD 脚本再次引发灾难? 运维必须剥夺业务组直接创建 LLD Template 的权限。通过 CI/CD 管道扫描业务侧提交的脚本,限制 LLD 返回的 JSON 最大数组长度(如不超过 200)。此外,在 Zabbix 中利用 “LLD overrides” 功能,强制要求匹配特定正则的对象才能触发 Item 发现。

  • 深入 OpenLDAP 生产雪崩排查:SSSD 全表扫描引发的 syncrepl 同步阻塞与 PAM 认证超时

    SSSD 客户端缺乏精准过滤且 OpenLDAP 缺少核心字段索引,会导致 LMDB 后端触发全表扫描。这不仅会让 slapd 进程 CPU 长期打满,还会饿死 syncrepl 复制线程,最终引发多主集群 contextCSN 断层与全局 SSH/PAM 认证雪崩。破局点在于重建 olcDbIndex、收敛 SSSD 搜寻范围并启用 delta-syncrepl

    某次排查过程中,某环境数千台 Linux 服务器突然出现 SSH 无法登陆、sudo 命令卡死的问题。查看 K8S Worker 节点的 /var/log/secure,满屏的 pam_sss(sshd:auth): System error 与超时报错。

    登录核心认证集群,发现所有 OpenLDAP (版本 2.4.59) 节点的 slapd 进程 CPU 利用率飙升至 400%(4核跑满),Load Average 突破 80。

    通过 ldapsearch 提取各节点的 contextCSN,发现 Provider 与 Consumer 之间的数据已经严重割裂:

    # Provider 节点
    $ ldapsearch -x -LLL -H ldap://10.0.0.10 -s base -b "dc=corp,dc=com" contextCSN
    contextCSN: 20231018120001.123456Z#000000#000#000000
    
    # Consumer 节点 (同步延迟超过半小时)
    $ ldapsearch -x -LLL -H ldap://10.0.0.11 -s base -b "dc=corp,dc=com" contextCSN
    contextCSN: 20231018112500.654321Z#000000#000#000000
    

    syncrepl 同步几乎处于停滞状态。开启 slapdstats 日志级别后,我们抓到了导致血案的直接原因:大量无索引的 Group 遍历查询。

    为什么百万级 DIT 下,SSSD 组查询会演变成全表扫描?

    在标准的 PAM/SSSD 集成架构中(SSSD 2.2.3),当用户尝试 SSH 登录时,SSSD 会通过 LDAP 校验用户身份并拉取该用户所属的所有组(Group)信息。

    如果我们看当时的 slapd 日志,会频繁出现以下警告:

    slapd[1234]: <= mdb_equality_candidates: (memberUid) not indexed
    slapd[1234]: <= mdb_equality_candidates: (member) not indexed
    

    在默认的 SSSD 配置下,如果你开启了 enumerate = true,或者使用了极其宽泛的 LDAP Search Base(例如直接挂在 dc=corp,dc=com 而非 ou=Groups,dc=corp,dc=com),SSSD 客户端会定期向 LDAP 发起类似 (&(objectClass=posixGroup)(memberUid=username)) 的查询。

    OpenLDAP 的 LMDB (Lightning Memory-Mapped Database) 底层是基于 B+ 树的键值对存储。当查询条件中的属性(如 memberUid)在 olcDbIndex 中没有定义 eq (精确匹配) 索引时,slapd 只能回退到最原始的处理方式:全表遍历 (Full Table Scan)

    在拥有数十万 Entry 的 DIT (Directory Information Tree) 中,单次全表扫描就会产生巨量的内存分页换入换出(Page Fault)。当几千台机器的 SSSD 并发发起查询时,LMDB 的 PageCache 被迅速击穿,磁盘 IO Wait 暴增,slapd 的查询线程池被彻底耗尽。

    syncrepl 复制堆积与写饿死机制

    理解了读性能衰减,还需要解释为什么主从同步会断层。

    OpenLDAP 的 syncrepl (基于 refreshAndPersist 模式) 是单线程拉取机制。Consumer 节点通过一个持续的 LDAP Search 连接监听 Provider 的变动。

    当 Provider 的查询线程被全表扫描的 SSSD 客户端占满时:

    1. 底层 LMDB 引擎面临极高的读锁竞争。

    2. Provider 端尝试将新的写入(比如密码错误次数更新 pwdFailureTime)提交到磁盘,但写事务在等待读事务释放锁,或者 CPU 时间片被读事务耗尽。

    3. 即使写入成功,负责向 Consumer 推送更新的 Sync Provider 线程也拿不到资源去构建同步 Payload。

    4. Consumer 端的 syncrepl 线程长轮询超时,触发重连,重连后发送自己旧的 contextCSN 要求全量对比增量数据,进一步加重了 Provider 的负担。

    这就是经典的读风暴导致写饿死,进而引发复制雪崩

    防御性调优与落地实战

    面对这种架构脆弱性,仅仅重启是没用的,必须从索引层、服务端防刷层以及客户端检索边界三个维度进行彻底改造。

    1. 补齐核心字段索引 (olcDbIndex)

    生产环境的 OpenLDAP,绝不允许出现 not indexed 警告。必须通过 ldapmodify 动态注入索引配置,然后离线重建。

    构建 index.ldif

    dn: olcDatabase={2}mdb,cn=config
    changetype: modify
    add: olcDbIndex
    olcDbIndex: memberUid eq,pres,sub
    olcDbIndex: member eq,pres
    olcDbIndex: uidNumber eq,pres
    olcDbIndex: gidNumber eq,pres
    olcDbIndex: entryCSN eq
    olcDbIndex: entryUUID eq
    

    应用配置并重建索引(针对 2.4.x 大库,最安全的方式是停机重建):

    ldapmodify -Y EXTERNAL -H ldapi:/// -f index.ldif
    systemctl stop slapd
    # 使用 slapindex 重建底层 LMDB B+ 树,切换为 ldap 用户执行
    su - ldap -s /bin/bash -c "slapindex -b 'dc=corp,dc=com'"
    systemctl start slapd
    

    2. OpenLDAP 防刷限流 (Limits & Timeouts)

    为了防止单个烂 SQL (LDAP Query) 拖垮整库,必须在服务端设置防御性阈值。在 cn=config 中限制单次查询扫描的最大条目数和时间:

    dn: olcDatabase={2}mdb,cn=config
    changetype: modify
    replace: olcSizeLimit
    olcSizeLimit: size.soft=1000 size.hard=5000
    -
    replace: olcTimeLimit
    olcTimeLimit: time.soft=10 time.hard=30
    

    超过该限制的恶意查询将直接被掐断,返回 Size limit exceeded 异常,保证核心进程存活。

    3. SSSD 客户端瘦身配置 (sssd.conf)

    绝大部分运维配置 SSSD 时喜欢照抄网上的模板。正确的 sssd.conf 应当极度收敛搜索边界:

    [domain/corp.com]
    id_provider = ldap
    auth_provider = ldap
    # 严禁在几千台机器上开启 enumerate (这会拉取全量用户列表)
    enumerate = false
    
    # 强制限定 Search Base,不要在根路径捞针
    ldap_user_search_base = ou=People,dc=corp,dc=com
    ldap_group_search_base = ou=Groups,dc=corp,dc=com
    
    # 忽略不必要的组成员查询(如果不需要依赖组成员做 sudoers 细粒度控制)
    ignore_group_members = true
    
    # 开启离线凭证缓存,在 LDAP 抖动时保证老用户依然能登录
    cache_credentials = true
    entry_cache_timeout = 14400
    

    4. 优化复制模式 (delta-syncrepl)

    当涉及到超大 Group(例如拥有上万个 memberUid 的组)时,任何一人的增删都会导致整个 Group 的全量条目被 syncrepl 传输。 在架构改造层面,必须启用 accesslog Overlay,并切换到 delta-syncrepl。该模式下,Provider 将变更操作(Modify/Add/Delete)记录到独立的 LMDB 库中,Consumer 只拉取具体的变更动作(如 add: memberUid: newuser),而不是拉取包含1万个用户的整个 Group 对象,使得网络传输和 CPU 解析开销呈指数级下降。

    常见问题 (FAQ)

    Q1:如何准确监控 OpenLDAP 的 syncrepl 复制延迟? 不要依靠 ping 端口,必须采集 contextCSN。可通过编写 Exporter 或 Shell 脚本,分别从 Provider 和 Consumer 取出 contextCSN 的时间戳部分进行差值计算。如果有多个 Provider 写入,contextCSN 会包含多个 Server ID(如 #000001, #000002),必须分别对比每个 ID 的时间戳。

    Q2:slapd 日志大量报错 mdb_db_open: database "dc=xxx" cannot be opened, err 12. Cannot allocate memory,如何处理? 这是 LMDB 的 maxsize 达到了限制。LMDB 使用内存映射文件(mmap),其 maxsize 并不代表真实占用的磁盘空间,而是虚拟内存映射的上限。默认值通常太小(如 1GB),对于生产环境,应该在 cn=configolcDbMaxSize 修改为更大的值(例如 8589934592 即 8GB),并确保操作系统层面没有限制进程的 VIRT 内存。

    Q3:SSSD 缓存导致用户刚改了组权限却不生效,怎么清理最快? 执行 sss_cache -E 清理全量缓存,或者针对特定用户执行 sss_cache -u username,然后重启 sssd 服务(systemctl restart sssd)。在生产环境批量排查时,切忌盲目清空缓存,否则瞬间穿透到 OpenLDAP 的并发查询会引发洪峰。

  • 深入 eBPF/XDP 实战:从 Netfilter 软中断打满看 XDP 快速拦截与 kfree_skb 丢包追踪

    传统 iptables/Netfilter 在千万级 PPS 场景下必然成为软中断杀手,协议栈过深的遍历路径是高并发网关的性能毒药。本文直接给出基于 eBPF/XDP 的网络防刷与加速方案,在网卡驱动层(甚至硬件卸载)直接丢弃恶意包,将 CPU si 开销降低 80%,并结合 tracepoint:skb:kfree_skb 彻底终结内核丢包“黑盒”排查。

    案发现场:Netfilter 成为性能瓶颈

    某次生产环境流量突增,某业务 Ingress 网关(Ubuntu 22.04, Kernel 5.15.0-88-generic)QPS 并没有成倍放大,但 P99 延迟直接从 20ms 飙升到了 500ms,部分节点甚至出现 SSH 登录卡顿。

    第一反应看负载,直接上 mpstat -P ALL 1,发现网卡队列绑定的几个 CPU 核心 si(SoftIRQ)直接被打满到了 100%。

    抓取热点函数 perf top -a,霸榜的调用链异常清晰:

      18.52%  [kernel]  [k] nf_hook_slow
      15.21%  [kernel]  [k] ip_rcv
      12.33%  [kernel]  [k] kmem_cache_alloc
      10.14%  [kernel]  [k] __netif_receive_skb_core
    

    典型的 CC 攻击/恶意扫段特征。大量无效的小包涌入,虽然在 iptables/Netfilter 层面配置了 DROP 规则,但由于 iptables 挂载在 PREROUTING 等 Hook 点,数据包走到这里时,内核已经为每一个包分配了 sk_buff 结构体,并走完了复杂的 L2 和 L3 早期协议栈处理

    在动辄几百万 PPS 的冲击下,频繁的 kmem_cache_alloc 和 Netfilter 规则链遍历直接榨干了 CPU。我们需要在更底层“掐断”这些流量。

    为什么 XDP 能在千万级 PPS 下实现防刷降级?

    常规的数据包接收路径是:网卡 -> DMA 拷贝到 Ring Buffer -> 触发硬中断 -> NAPI 轮询拉取 -> 分配 sk_buff -> __netif_receive_skb_core -> 网络协议栈 (Netfilter/IP/TCP 等)。

    XDP(eXpress Data Path)之所以快,根本原因在于它的 Hook 点位于 网络驱动层分配 sk_buff 之前。 当网卡通过 DMA 将数据放入内存后,XDP BPF 程序直接读取这段连续的原始内存(xdp_md),如果是恶意包,直接返回 XDP_DROP,网卡驱动会原地回收页面。没有 skb 内存分配,没有协议栈解析,没有上下文切换。

    XDP 黑名单拦截实战代码

    我们使用 BPF Map 来维护一个高频攻击 IP 黑名单,在 XDP 层直接匹配并丢弃。 以下是精简后的核心 C 代码(xdp_drop.c):

    #include <linux/bpf.h>
    #include <linux/in.h>
    #include <linux/if_ether.h>
    #include <linux/if_packet.h>
    #include <linux/if_vlan.h>
    #include <linux/ip.h>
    #include <bpf/bpf_helpers.h>
    
    // 定义一个 BPF Hash Map 存储黑名单 IP
    struct {
        __uint(type, BPF_MAP_TYPE_HASH);
        __uint(max_entries, 10000);
        __type(key, __u32);   // IPv4 Address
        __type(value, __u32); // Drop counter
    } blacklist SEC(".maps");
    
    SEC("xdp")
    int xdp_drop_prog(struct xdp_md *ctx) {
        void *data_end = (void *)(long)ctx->data_end;
        void *data = (void *)(long)ctx->data;
    
        // 边界检查(必须,否则 eBPF 验证器会拒绝加载)
        struct ethhdr *eth = data;
        if ((void *)(eth + 1) > data_end)
            return XDP_PASS;
    
        if (eth->h_proto != __constant_htons(ETH_P_IP))
            return XDP_PASS;
    
        struct iphdr *iph = data + sizeof(struct ethhdr);
        if ((void *)(iph + 1) > data_end)
            return XDP_PASS;
    
        __u32 src_ip = iph->saddr;
    
        // 查询黑名单 Map
        __u32 *value = bpf_map_lookup_elem(&blacklist, &src_ip);
        if (value) {
            __sync_fetch_and_add(value, 1); // 原子递增拦截计数
            return XDP_DROP; // 核心:在驱动层直接丢弃
        }
    
        return XDP_PASS;
    }
    
    char _license[] SEC("license") = "GPL";
    

    编译与挂载:

    # 使用 clang 编译成 BPF 字节码
    clang -O2 -target bpf -c xdp_drop.c -o xdp_drop.o
    
    # 将 XDP 程序挂载到网卡 eth0 (推荐 Native 模式,如果网卡驱动支持)
    ip link set dev eth0 xdp obj xdp_drop.o sec xdp
    
    # 查看挂载状态
    ip link show eth0
    # 输出会包含: prog/xdp id 123 tag xxxxxxx
    

    此时再用 bpftool map 动态向 blacklist 中写入恶意 IP,被拦截的流量完全不会在 CPU si 中泛起波澜,系统 Load 瞬间恢复。

    丢包排查:用 bpftrace 追踪 kfree_skb 黑盒

    在上述流量清洗的过程中,常会遇到业务方反馈:“我的包明明发过去了,为什么网关没收到?”。此时,如果是协议栈内部某处静默丢包(如 MTU 不匹配、TCP 状态机异常、连接跟踪满),用 tcpdump 是看不出所以然的。

    内核丢弃数据包最终都会调用 kfree_skbconsume_skb(正常释放)。利用 eBPF 追踪 kfree_skb 是降维打击。

    在 Kernel 5.15 下,可以直接使用 bpftrace 一行命令定位丢包的确切内核调用栈:

    # 捕获 10 秒内所有因非正常原因丢包的内核栈并统计次数
    bpftrace -e '
    tracepoint:skb:kfree_skb {
        // args->reason 在 5.1x 较新内核引入,可直接区分丢包原因
        @[kstack] = count();
    }
    '
    

    如果你的内核支持 skb_drop_reason(Kernel 5.17+ 完善),甚至可以直接打印出人类可读的丢包枚举值。 在我们的排查过程中,通过上述命令输出了如下聚合栈:

    @[
        kfree_skb+1
        tcp_v4_rcv+1452
        ip_protocol_deliver_rcu+54
        ip_local_deliver_finish+108
        __netif_receive_skb_one_core+138
        process_backlog+164
        __napi_poll+42
        net_rx_action+582
    ]: 2450
    

    一针见血,包是在 tcp_v4_rcv 中被丢弃的。结合代码和偏移量,立刻定位到是处于 TIME_WAIT 状态的 socket 堆积,导致 PAWS(Protect Against Wrapped Sequence numbers)校验失败,触发了静默丢包。调整 net.ipv4.tcp_tw_reuse 和时间戳设置后,问题迎刃而解。没有 eBPF,这个问题在海量流量下排查至少需要拔几根头发。

    常见问题 (FAQ)

    Q1:XDP 有 Native 和 Generic 两种模式,性能差异多大? Native 模式下,XDP BPF 代码直接嵌入在网卡驱动的 NAPI poll 循环中执行,性能极高(线速丢包可达 10M~20M PPS)。而 Generic 模式(xdpgeneric)是作为回退方案,挂载在 sk_buff 分配之后、协议栈处理之前,性能大打折扣,失去了 XDP “零分配”的核心优势。实战中,如果网卡驱动(如 ixgbe, i40e, mlx5)支持,务必使用 Native 模式(xdpdrv)。

    Q2:加载 XDP 字节码时报错 bpf verifier errors,提示越界访问,怎么解决? eBPF 内核验证器(Verifier)极其严格,采用“防御性加载”策略。如果你在 C 代码中解析 IP 头部,但没有在使用指针前做边界检查(例如 if ((void *)(iph + 1) > data_end) return XDP_PASS;),验证器会认为该程序可能引发 Kernel Panic 并拒绝加载。必须为每一次网络包头部偏移读取增加严格的 data_end 边界校验。

    Q3:网关已经部署了 Cilium (基于 eBPF/XDP),我自己挂载的 XDP 会冲突吗? 会冲突。一个网卡的 RX 队列在同一时间点通常只能挂载一个 XDP 程序。如果强制挂载,后者的会覆盖前者,导致 Cilium 的网络路由与策略失效。在较新的内核中可以使用 libxdp 提供的多程序链(Multi-prog dispatcher)机制,将多个 XDP 程序按优先级串联(如将你的防刷 XDP 作为优先级最高的程序执行,如果 XDP_PASS,再交由 Cilium 的 XDP 程序处理)。

    Q4:为什么不用 TC (Traffic Control) BPF 做拦截? TC BPF 也是极好的网络控制点(支持 Ingress 和 Egress 双向),且能获取完整的 skb 上下文,功能比 XDP 更丰富(比如修改包长、克隆重定向)。但 TC Hook 点位于 skb 分配之后。如果你的首要目标是应对 L3/L4 层的洪水攻击或极限压榨 CPU 性能,选 XDP;如果是做复杂的流量整形、七层之前的深度负载均衡,选 TC。