标签: 混沌工程

  • 深入混沌工程陷阱排查:无差别 tc 丢包注入引发的 Kubelet 脑裂驱逐风暴与爆炸半径管控实战

    排查过程中,我们遭遇了一次由于混沌工程(Chaos Engineering)实施不当引发的生产级雪崩。原本只是一次常规的 GameDay 演练,目的是向支付网关注入 100% 网络丢包以验证断路器(Circuit Breaker)的降级 SLO,最终却导致该节点被标记为 NotReady,数百个核心 Pod 被强行驱逐,跨可用区的网络流量剧烈抖动。最终结论很明确:在对配置了 hostNetwork: true 的目标 Pod 注入网络故障时,未做端口或目标 IP 级别的精细过滤,直接在物理网卡上挂载了全局的 tc netem 丢包规则,阻断了 Kubelet 与 API Server 的心跳,导致控制平面触发了无差别的脑裂驱逐(Eviction)。

    混沌工程的核心原则是“控制爆炸半径”,而不是在没有消防措施的情况下往机房里扔燃烧弹。这种因为对底层网络命名空间(Network Namespace)和 K8S 节点状态机理解不透彻造成的事故,属于典型的低级失误。

    案发现场:从演练降级到节点失联

    某次核心链路故障演练期间,监控大盘显示支付网关的 99 线延迟如预期般飙升,断路器指标(hystrix_circuit_breaker_open)也正常触发。但演练进行到第 60 秒时,事态失去控制:

    1. Prometheus 疯狂涌出 KubeNodeNotReady 告警。

    2. 该节点上的数十个与演练完全无关的微服务(包括本地缓存 Redis 和日志采集 DaemonSet)连接数全部归零。

    3. K8S 控制平面开始调度新 Pod 到其他节点,引发瞬间的镜像拉取风暴和 CPU 满载(Load Average 瞬间飙升到 80+)。

    登录目标节点,系统自身其实毫无压力,CPU、内存、磁盘 IO 全在低位。但查看 Kubelet 日志,满屏都是触目惊心的超时报错:

    E0914 10:23:45.123456    1234 kubelet_node_status.go:456] Error updating node status, will retry: error getting node "node-pay-01": Get "https://10.0.0.1:6443/api/v1/nodes/node-pay-01": dial tcp 10.0.0.1:6443: i/o timeout
    E0914 10:23:55.124567    1234 kubelet_node_status.go:456] Error updating node status, will retry: error getting node "node-pay-01": Get "https://10.0.0.1:6443/api/v1/nodes/node-pay-01": dial tcp 10.0.0.1:6443: i/o timeout
    

    Kubelet 彻底哑火了。

    底层机制:tc netem 与 hostNetwork 的致命交叉

    为什么对一个“支付网关 Pod”注入网络故障,会干掉整个宿主机的网络?

    排查混沌注入工具(此处使用的是基于 eBPF/tc 封装的底层执行器)的注入记录,并直接在问题节点执行 tc qdisc show 查看流量控制规则:

    $ tc qdisc show dev eth0
    qdisc netem 8001: root refcnt 9 loss 100%
    

    破案了。工具在物理网卡 eth0 的 root 队列规则(qdisc)上,直接挂载了 netem loss 100%。

    在 Kubernetes 环境中,绝大多数 Pod 运行在独立的 Network Namespace 中(由 CNI 分配独立 IP 和 veth pair),对这些 Pod 注入网络故障,tc 规则只会作用于 Pod 对应的 veth 接口或内部的 eth0 上。 然而,由于支付网关需要极高的网络吞吐,运维团队为该 Deployment 配置了 hostNetwork: true。这意味着该 Pod 共享宿主机的 Root Network Namespace。

    当混沌引擎按照常规逻辑查找该 Pod 的网络接口并实施注入时,它拿到的是宿主机的 eth0。更要命的是,注入配置里没有指定任何 Filter(过滤器),直接进行了全局 100% 丢包。

    来看看 K8S 节点状态机的默认时间线:

    1. Kubelet 每 10 秒向 API Server 发送一次心跳(node-status-update-frequency)。

    2. 当 API Server 连续 40 秒(node-monitor-grace-period)收不到心跳,kube-controller-manager 就会将 Node 标记为 NotReady。

    3. 如果节点持续 NotReady 达到 300 秒(Pod 默认的 tolerationSeconds),控制平面将触发驱逐逻辑。由于演练中某些关键有状态 Pod 的容忍度被调整为了 60 秒,驱逐几乎在节点失联后立刻发生。

    拨乱反正:爆炸半径的精细管控

    混沌工程不是盲目的破坏。既然我们要对 hostNetwork 下的特定进程注入故障,就必须在内核网络栈层面实现精确制导。

    1. 废弃无差别的 root qdisc

    切忌直接在 root 节点挂载 netem,必须结合 htb (Hierarchical Token Bucket) 或 prio 建立层级队列,并使用 u32 或 cgroup 过滤器匹配特定流量。

    如果要针对支付网关(监听在 8080 端口,目标下行调用 3306 数据库)进行丢包注入,正确的底层 tc 规则构建路径应该是:

    # 1. 在 eth0 根节点创建 prio 队列(分为 3 个频段,默认走 band 2)
    tc qdisc add dev eth0 root handle 1: prio
    
    # 2. 在 band 1 (handle 1:1) 上挂载 netem 丢包规则
    tc qdisc add dev eth0 parent 1:1 handle 10: netem loss 100%
    
    # 3. 使用 u32 过滤器,仅将发往 3306 端口的流量导向丢包队列 (classid 1:1)
    tc filter add dev eth0 protocol ip parent 1:0 prio 1 u32 \
        match ip dport 3306 0xffff flowid 1:1
    
    # 4. (关键) 显式放行 Kubelet 与 API Server 的通信端口 6443,导向正常队列 (classid 1:2)
    tc filter add dev eth0 protocol ip parent 1:0 prio 0 u32 \
        match ip dport 6443 0xffff flowid 1:2
    

    2. 使用支持白名单的现代混沌工具

    如果在 Kubernetes 中使用 Chaos Mesh 或 Litmus,必须在 YAML 中显式配置目标及绕过规则。现代混沌工具提供了网络级别的高级选择器。例如 Chaos Mesh 的 NetworkChaos:

    apiVersion: chaos-mesh.org/v1alpha1
    kind: NetworkChaos
    metadata:
      name: payment-loss-injection
    spec:
      action: loss
      mode: one
      selector:
        labelSelectors:
          app: payment-gateway
      loss:
        loss: '100'
      # 必须限制方向,并在外部控制器中规避控制面端口
      direction: to
      target:
        selector:
          labelSelectors:
            app: mysql-cluster
    

    如果是针对 hostNetwork,必须开启特定的 BPF 注入模式或在系统级预设 K8S 控制平面的网段白名单(CIDR exclude)。

    避坑总结

    高可用系统的韧性验证,基础是敬畏系统。在生产环境进行故障注入,必须具备“一键终止(Abort Button)”的能力,但如果网络故障直接干掉了节点级别的通信,你的“一键终止”指令连下发到 Chaos Daemon 的通道都会被切断,这就演变成了不可控的灾难。做混沌实验前,先问自己三个问题:目标域到底在哪个 Namespace?底层注入手段会不会产生越权逃逸?如果控制通道断了,实验能不能自动回滚?

    同类问题速查排查清单

    1. 宿主机网络逃逸排查:检查目标业务 Pod 是否配置了 hostNetwork: true。如果是,常规的网络故障注入(如直接作用于网卡的 tc 规则)将污染整个宿主机网络环境。

    2. Kubelet 心跳阻断确认:当节点突然 NotReady,优先检查 API Server 审计日志与问题节点本地 Kubelet 日志,确认 i/o timeout 端口是否为 6443,判断是否为网络层拦截导致。

    3. 残留 tc 规则清理:如果注入工具异常退出导致规则未清理,手动执行 tc qdisc del dev root 恢复网络通信,切忌盲目重启节点。

    4. 混沌控制通道隔离:混沌代理(Chaos Daemon)所在的端口和控制平面(API Server 6443, etcd 2379, kubelet 10250)必须在注入系统的全局白名单(Whitelist/Bypass)中,确保任何情况下的实验可中止性。

  • 深入 ChaosBlade 陷阱排查:cgroup 状态逃逸引发的永久性 CPU Throttling 与 GameDay 瘫痪实战

    近期在主导一次核心交易链路的 GameDay 时,遇到一起极具讽刺意味的故障:我们在对结算微服务注入 CPU 满载故障以验证 HPA(水平Pod扩容)和限流降级策略后,通过控制台停止了混沌实验。然而,目标微服务并未如期恢复,P99 延迟死死钉在 3000ms 以上,QPS 从日常的 5000 跌至不到 100,业务处于静默熔断状态。最终排查确认:这是由于 ChaosBlade Agent 在实验期间因资源竞争被 Kubelet Evict,导致 cgroup 恢复逻辑被跳过,目标 Pod 的 cpu.cfs_quota_us 被永久锁定在极低值,引发了灾难性的全局 CPU Throttling。

    混沌工程的核心原则是“控制爆炸半径”和“可恢复性”,但如果故障注入工具本身的鲁棒性一塌糊涂,GameDay 就会演变成一场真正的灾难。今天把现场排查逻辑复盘出来,希望能让大家对底层资源隔离和混沌工具的原子性有更深的敬畏。

    现场还原与排查逻辑

    实验结束指令下发后,监控大盘并未如期恢复“全绿”。 第一反应是业务代码里有自旋锁没释放,或者 Go Runtime GC 挂起了。但登录到目标 Node 上查看,系统 Load Average 只有不到 2.0,极其空闲。

    执行 top 并按 P 排序,发现目标 Go 进程的 CPU 占用率不到 1%,但处于 R (Running) 状态的时间极短。 拉取 Prometheus 监控,发现 go_goroutines 数量堆积到了 8 万多,说明请求进来了,但处理极慢。

    排除了应用层死锁后,直奔底层资源隔离指标。执行以下 PromQL 检查容器 CPU 限流情况:

    rate(container_cpu_cfs_throttled_periods_total{pod=~"settlement-svc-.*"}[1m]) 
    / 
    rate(container_cpu_cfs_periods_total{pod=~"settlement-svc-.*"}[1m])
    

    图表极其触目惊心:Throttling 比例高达 99.9%!这意味着容器几乎每个 CPU 调度周期都被内核硬生生掐断。

    立刻切入宿主机,根据 Pod UID 定位到对应的 cgroup 目录,查看当前的 CFS 配额:

    # 获取容器的 cgroup 路径
    CGROUP_PATH=$(find /sys/fs/cgroup/cpu/kubepods.slice/ -name "*$(docker inspect -f '{{.Id}}' <container_id>)*")
    
    # 查看当前配额
    cat $CGROUP_PATH/cpu.cfs_quota_us
    1000
    
    cat $CGROUP_PATH/cpu.cfs_period_us
    100000
    

    结论非常荒谬:这个 Pod 原本是 Guaranteed QoS,配置了 requests.cpu=4, limits.cpu=4,其 cpu.cfs_quota_us 应该是 400000。现在居然变成了 1000(即 0.01 核)!难怪业务进程形同植物人。

    底层原理解析:ChaosBlade 的致命缺陷

    为什么停止了 ChaosBlade 实验,配额却没有恢复?

    追踪 kubelet 和 chaosblade-tool 的日志,还原了事发现场:

    1. 注入阶段:ChaosBlade 为了模拟 CPU 饥饿/满载,并不是单纯地在容器内拉起一个 stress-ng 跑满 CPU(这无法限制宿主机上其他进程抢占)。它的部分高阶实现会直接入侵目标容器的 cgroup namespace,动态修改 cpu.cfs_quota_us 来限制应用的实际可用 CPU,或者在拉起满载进程的同时调整配额。

    2. 状态保存:在修改 cfs_quota_us 之前,ChaosBlade Agent 会将原始值(400000)保存在本地内存或一个临时状态文件中。

    3. 意外崩溃:在故障注入期间,由于整体 Node CPU 压力剧增,Kubelet 触发了资源保护机制。ChaosBlade 的 DaemonSet Pod 因为没有配置足够高的 PriorityClass(优先级过低),直接被 Kubelet 判定为牺牲品,执行了 Eviction(驱逐)。

    4. 逃逸与死锁:当操作人员在控制台点击“停止实验”时,控制端向集群下发恢复指令,但旧的 Agent 已经死了,新拉起的 Agent 内存中根本没有那个 Pod 的原始 cgroup 状态记录!恢复操作直接被跳过(或静默失败)。目标 Pod 的 cgroup 彻底成了无主孤魂,被永久锁定在 1000。

    这种非原子性的状态管理,是防御性编程的绝对反面教材。

    修复与避坑指南

    现场的临时止血很简单,手动把正确的配额写回 cgroup,或者直接删掉业务 Pod 让 K8S 重新调度重建:

    echo 400000 > /sys/fs/cgroup/cpu/kubepods.slice/kubepod-pod<UID>.slice/docker-<ContainerID>.scope/cpu.cfs_quota_us
    

    但从架构和 SRE 规范的角度,必须要建立以下护城河:

    1. 混沌组件必须配置最高优先级: Chaos Agent 等同于节点上的 Rootkit,其生命周期必须得到绝对保障。必须为其分配 system-node-critical 级别的 PriorityClass,并配置严苛的 Guaranteed 资源 QoS。绝不允许在实验中途被 Kubelet 驱逐。

    2. 无状态恢复与 eBPF 化: 抛弃那些通过直接篡改不可变基础设施状态(如原地修改 cgroup、原地修改 iptables 规则且不依赖 owner)来注入故障的低级工具。优秀的混沌工具应采用 eBPF(挂载点随进程生命周期绑定,进程死则注入自动失效)或 TC+cgroup-bpf 技术。如果一定要改文件,必须有基于独立 Watchdog 的兜底恢复机制(例如通过 Label 记录原始状态)。

    3. GameDay 旁路熔断监控: 实验脚本不能只看“业务指标是否下降”,必须引入“基础设施一致性校验”。在实验停止的自动化流水线中,增加一步对注入点(cgroup、网络 tc 队列)的物理清理确认。

    同类问题排查清单

    1. CPU Throttling 突增排查:不要只看 Node CPU 使用率。应用变慢但 Load 正常时,第一步永远是 cat /sys/fs/cgroup/cpu/.../cpu.stat,重点关注 nr_throttled 和 throttled_time。

    2. 混沌注入残留排查:网络类实验结束后延迟依然很高,检查 tc qdisc show dev eth0 是否残留 netem 规则;CPU 类检查 cfs_quota_us;IO 类检查 eBPF probe 或 FUSE 挂载点残留。

    3. Agent 生命保障检查:检查所有 DaemonSet 类型的运维组件(Chaos, Fluentd, node-exporter)的 PriorityClass,如果没有配置,在节点资源紧张时它们必然成为导致系统雪崩的定时炸弹。

    4. Cgroup 泄漏检测:定期运行脚本遍历 kubepods.slice 下的僵尸 cgroup 目录,K8S 曾有多个版本存在 Pod 销毁后 cgroup 目录不清理的 Bug,会导致内核内存碎片化及性能剧降。

  • 深入 Chaos Mesh 陷阱排查:TimeChaos vDSO 劫持失效引发的 Go Runtime 挂起与 GameDay 熔断实战

    结论先行:在 Chaos Mesh (v2.6.2) 中对 Go (v1.20) 服务执行 TimeChaos 时间回拨注入时,若错误配置 clockIds 包含 CLOCK_MONOTONIC,将通过 vDSO 劫持强制回拨单调钟。这会破坏 Go Runtime runtime.nanotime() 的严格递增语义,导致 Timer Heap 计算下溢,触发 100% CPU 空转与全局 Goroutine 饥饿。修复方案是仅劫持 CLOCK_REALTIME,并配置严密的 GameDay 自动化熔断策略。

    现场:GameDay 变故与 Go 服务静默挂起

    在某次旨在验证分布式锁续期容灾能力的 GameDay 演练中,我们通过 Chaos Mesh 向一个基于 etcd 的核心调度服务注入时间回退故障(Time Offset: -10m)。预期的 SLO 行为是:目标 Pod 因为时间回退导致 Lease 判定过期,主动释放 Leader 身份,备用节点在 3 秒内完成接管。

    然而,混沌实验触发的瞬间,监控大盘上的 P99 延迟并未如期出现短暂毛刺,而是该节点的 QPS 直接跌零。告警风暴接踵而至:

    1. 目标 Pod 所在的 Node Load Average 瞬间从 2 飙升到 80+。

    2. 目标服务的 Liveness Probe 连续失败,处于假死状态。

    3. Kubelet 尝试 SIGTERM 回收 Pod 超时,最终触发 SIGKILL,但在 Pod 重建期间,由于 Chaos 的 Label Selector 持续命中,新 Pod 启动即再次假死,形成“启动-挂起-强杀”的死亡循环。GameDay 爆炸半径彻底失控。

    排查过程中,我登录该 Node,迅速拉起 top 发现目标进程 CPU 使用率打满(400%,占用 4 个 Core),但没有任何日志输出。

    直接用 perf top -p 抓取 CPU 现场:

      12.34%  my-service       [.] runtime.siftdownTimer
      11.89%  my-service       [.] runtime.runOneTimer
       9.50%  my-service       [.] runtime.nanotime
       8.21%  my-service       [.] runtime.checkTimers
    

    调用栈清晰表明,Go Runtime 的调度器死在了 Timer Heap 的维护操作上。一个单纯的 OS 层面的时间注入,为什么会击穿 Go 的 Runtime?

    为什么 TimeChaos 的 vDSO 劫持会引发 Runtime 假死?

    要理清这个问题,必须拆解 Chaos Mesh TimeChaos 的底层实现与 Go 获取时间的机制。

    在 Linux 环境下,高频调用的 clock_gettime 如果走标准系统调用(Syscall),会带来昂贵的用户态/内核态上下文切换开销。因此,内核提供了 vDSO(Virtual Dynamically Shared Object),将包含时间获取指令的内存页直接映射到用户进程的地址空间。Go 的 runtime.walltime 和 runtime.nanotime 都是直接读取 vDSO 来获取时间的。

    Chaos Mesh 为了实现对单个进程的时间欺骗(而不影响整个 Node),采用了极其硬核的 vDSO 劫持方案:

    1. chaos-daemon 利用 ptrace 附着到目标进程。

    2. 读取 /proc//maps 找到 [vdso] 内存段的基址。

    3. 在目标进程的内存中 mmap 一块新区域,写入伪造的 clock_gettime 汇编指令。

    4. 修改原 vDSO 页(需要修改页保护属性为可写),将原 __vdso_clock_gettime 的入口指令替换为 jmp,无条件跳转到伪造的函数。

    伪造的函数会根据注入的 offset 返回修改后的时间。

    我们的 TimeChaos 配置如下:

    apiVersion: chaos-mesh.org/v1alpha1
    kind: TimeChaos
    metadata:
      name: scheduler-time-chaos
      namespace: my-app
    spec:
      mode: one
      selector:
        labelSelectors:
          app: scheduler
      timeOffset: '-10m'
      clockIds:
        - 'CLOCK_REALTIME'
        - 'CLOCK_MONOTONIC' # 致命错误点
      duration: '5m'
    

    致命点在于 clockIds 包含了 CLOCK_MONOTONIC。CLOCK_REALTIME 是墙上时钟(受 NTP 影响,可跳变),而 CLOCK_MONOTONIC 是单调钟,保证自系统启动后绝对单调递增,Go 的定时器(Timer)和超时控制(Context Timeout)强依赖它。

    当 vDSO 劫持生效,CLOCK_MONOTONIC 瞬间回退 10 分钟。Go Runtime 的 runtime.nanotime() 读到了一个比之前还要小的值。在 Go 内部的 timer 调度中:

    // Go runtime timer 执行逻辑简写
    now := nanotime()
    if t.when > now {
        // 还没到时间
        break
    }
    // 执行回调
    

    当 now 被暴力回退后,整个 Timer Heap 的状态机发生紊乱。某些已经触发或正在触发过程中的 timer,在状态跃迁计算时发生了下溢(Underflow),导致 siftdownTimer 无法正确维护四叉堆的堆序特性,调度器陷入死循环,疯狂占用 CPU,直接导致同 P(Processor)上的其他 Goroutine 饥饿,整个服务彻底挂起。

    修复路径:防御性配置与 SLO 验证闭环

    明确了根因,修复操作分为两步:配置修正与 GameDay 架构升级。

    1. 修正 TimeChaos 配置

    在任何针对现代编程语言(Go, Rust, Java)的时间混沌实验中,绝不允许回拨单调钟。必须将 clockIds 严格限制为 CLOCK_REALTIME。

      timeOffset: '-10m'
      clockIds:
        - 'CLOCK_REALTIME' # 仅修改墙上时钟
    

    如果业务代码中存在直接使用 time.Now().Unix() 来计算超时(而不是使用 time.Since 这种基于单调钟的方法),仅回拨 CLOCK_REALTIME 足以暴露业务逻辑的缺陷,同时能保全 Runtime 的稳定性。

    2. 建立 GameDay 自动化熔断机制

    这次演练失控暴露出另一个严重问题:爆炸半径未能被有效收敛。一次成熟的混沌实验,注入不是关键,可控的观测与自动熔断才是核心。

    我们在现有的 Chaos Mesh 体系外,补充了基于 Prometheus + Alertmanager + Webhook 的防御性熔断链路:

    1. 设定 SLI/SLO 警戒线:针对目标节点的 Load Average、Pod 的 CPU Throttling 以及业务请求的 5xx 错误率设定阈值。

    2. Webhook 熔断器:编写了一个极简的 Webhook 服务。当 Alertmanager 触发 ChaosBlastRadiusExceeded 告警时,Webhook 会携带告警上下文,调用 K8s API 强制删除当前 Namespace 下所有的 Chaos 资源。

    # 熔断器核心逻辑片段 (Bash 伪码展示原理)
    ALERT_NAME=$(jq -r '.alerts[0].labels.alertname' $WEBHOOK_PAYLOAD)
    if [ "$ALERT_NAME" == "ChaosBlastRadiusExceeded" ]; then
        echo "[WARN] 爆炸半径超限,触发自动熔断!"
        kubectl delete networkchaos,timechaos,stresschaos --all -n $TARGET_NAMESPACE
        # 强制清理 chaos-daemon 残留的 BPF 或 ptrace 挂载
        kubectl exec -n chaos-mesh -l app.kubernetes.io/component=chaos-daemon -- chaos-daemon ptrace --cleanup
    fi
    

    这种“防御性编程”思想同样适用于运维架构:永远假设你的破坏工具会失控,并为其配备物理级的刹车。

    常见问题

    Q: 除了 Go Runtime,Java/JVM 服务对 TimeChaos 敏感吗? A: 同样敏感。JVM 内部依赖 System.nanoTime() 获取高精度单调钟,如果通过 vDSO 劫持回拨了 CLOCK_MONOTONIC,会导致 Thread.sleep(), Object.wait(), LockSupport.parkNanos() 的挂起时间计算出错,轻则线程提前唤醒或永久睡眠,重则引发 GC 线程 CPU 飙升。规则同样是:只劫持 CLOCK_REALTIME。

    Q: 为什么在某些 ARM64 节点上,TimeChaos 会注入失败并报错 ptrace attach: operation not permitted? A: 这通常是因为内核配置或安全策略(如 Yama LSM)限制了非父进程的 ptrace 调用。可以通过确认 sysctl kernel.yama.ptrace_scope 的值(需为 0),或者检查目标 Pod 是否开启了严格的 Seccomp Profile 拦截了 ptrace 系统调用。

    Q: 停止 TimeChaos 后,目标 Pod 的时间没有恢复正常,只能重启 Pod 解决,是什么原因? A: 这是典型的 vDSO 劫持后遗症。由于 Chaos Mesh 是通过内存注入修改指令,当实验结束时,chaos-daemon 需要将原有的 jmp 指令恢复成原生的 clock_gettime 指令。如果恢复阶段因为网络抖动、chaos-daemon OOM 或内核限制导致操作未完成,目标进程的内存数据将永久处于被劫持状态。这也是为什么在生产环境实施混沌工程时,必须具备自动化强杀受污染 Pod 的兜底预案。

  • 深入 Chaos Mesh 陷阱排查:StressChaos 击穿 cgroup 触发全局 OOM 与 GameDay 节点雪崩实战

    本文直接给出结论:在进行混沌工程内存注入演练时,如果目标 Pod 未配置硬性 Memory Limit(处于 Burstable/BestEffort 状态),且注入工具(如 Chaos Mesh 的 stress-ng)以极快速度(如 >100MB/s)分配内存,将直接绕过 Kubelet 周期为 10s 的 cAdvisor 驱逐检测,触发宿主机内核全局 OOM(Global Out of Memory)。最终导致核心组件(如 containerd/calico)被 OOM Killer 绞杀,引发 Node NotReady 和不可控的 Pod 驱逐雪崩。解决方案是:强制落地 LimitRange,配置 Kubelet 严格的 enforce-node-allocatable 屏障,并控制注入速率。

    排查过程中,我们正在对核心交易链路进行一次常态化的 GameDay 演练。演练 SLO 是:单节点内某个无状态服务突发内存泄漏(OOMKilled)时,K8S ReplicaSet 能够在一分钟内完成自愈调度,且上游关流平滑,P99 延迟波动不超过 50ms。

    然而,演练按钮按下的第 15 秒,监控大盘直接被红色淹没。目标 Pod 并没有按照预期发生局部重启,而是其所在的整个宿主机节点直接陷入 NotReady 状态,该节点上的 40 多个无关业务 Pod 全部触发 Eviction 驱逐,大面积重调度瞬间击穿了我们的依赖服务,爆炸半径完全失控。

    我不喜欢在 PPT 里讲容灾,GameDay 就是最好的照妖镜。下面还原当时的排查现场与底层根因。

    故障现场:一个 StressChaos 干挂了整片 Node

    我们使用的混沌工程平台是 Chaos Mesh (v2.6.2),目标环境为 Kubernetes v1.24,宿主机内核为 CentOS 7 的 5.4.x。当时下发的 StressChaos 配置如下:

    apiVersion: chaos-mesh.org/v1alpha1
    kind: StressChaos
    metadata:
      name: memory-leak-injection
      namespace: chaos-testing
    spec:
      mode: one
      selector:
        labelSelectors:
          app: payment-gateway
      stressors:
        memory:
          workers: 4
          size: '8GB'
          oomScoreAdj: -500 # 企图保护注入进程自身
      duration: '5m'
    

    直观上看,这个注入的逻辑很简单:通过 chaos-daemon 侵入目标 Pod 的 cgroup namespace,启动 4 个 stress-ng worker,吃掉 8GB 内存。

    但在目标节点的 /var/log/messages 中,我们看到了极其惨烈的内核日志:

    kernel: [123456.789] stress-ng-vm invoked oom-killer: gfp_mask=0x100cca(GFP_HIGHUSER_MOVABLE), order=0, oom_score_adj=-500
    kernel: [123456.790] CPU: 12 PID: 45678 Comm: stress-ng-vm Tainted: G        W         5.4.203-1.el7.elrepo.x86_64
    ...
    kernel: [123456.812] Out of memory: Killed process 3845 (containerd) total-vm:4589312kB, anon-vm:894320kB, file-vm:0kB, shmem-vm:0kB, UID:0 pgtables:2312kB oom_score_adj:-999
    kernel: [123456.815] oom_reaper: reaped process 3845 (containerd), now anon-vm:0kB, file-vm:0kB, shmem-vm:0kB
    

    内核的 OOM Killer 被唤醒,它没有干掉我们的目标业务进程,也没有干掉 stress-ng,而是把节点上的 containerd 给绞杀了。CRI 运行时一挂,Kubelet 随之陷入 PLEG (Pod Lifecycle Event Generator) timeout 死循环,节点状态直接变为 NotReady。

    为什么 100MB/s 的内存注入会击穿 cgroup 防线?

    这里有两个核心悖论:

    1. Kubernetes 的 Kubelet 有 evictionHard 机制(默认 memory.available<100Mi),为什么没提前驱逐 Pod?

    2. 为什么 cgroup 机制没有把目标 Pod 限制住(Cgroup OOM),而是触发了全局内存耗尽(Global OOM)?

    Kubelet 驱逐的"盲区时间"

    Kubelet 的驱逐机制属于用户态行为。它依赖内置的 cAdvisor 组件来周期性地抓取容器资源的利用率,这个指标采集的默认周期(Housekeeping Interval)大约是 10 到 15 秒。 在我们的演练中,stress-ng 通过 mmap() 配合多线程快速触发 Page Fault 分配物理内存,分配速率轻松超过 1GB/s。 当系统剩余可用内存从 2GB 掉到 100MB 以下时,只需不到 2 秒。在这 2 秒内,cAdvisor 根本还没来得及完成下一次指标轮询,Kubelet 完全不知道节点内存已经枯竭,自然无法发起 Eviction 驱逐。

    Cgroup OOM 与 Global OOM 的区别

    如果 Pod 配置了完整的 resources.limits.memory(属于 Guaranteed QoS),cgroup 目录底下的 memory.limit_in_bytes 会有一个明确的上限值。当 stress-ng 吃满这个值时,内核会触发基于该 cgroup 的 OOM(Cgroup OOM),这只会杀死该 Pod 内的进程,对宿主机无害。

    但排查发现,目标 Pod 恰好是一个历史遗留服务,开发只配了 requests,没有配 limits(QoS 为 Burstable)。 这意味着该容器对应的 cgroup 没有任何硬性内存上限(memory.limit_in_bytes = 9223372036854771712,即无限大)。 因此,注入进程直接把整台物理机的物理内存 + Swap 吃光了,最终导致内核触发全局级别的 OOM(Global OOM)。

    内核 OOM Killer 的无差别绞杀逻辑

    触发 Global OOM 后,Linux 内核必须牺牲某个进程来拯救系统。这个死刑判决基于 oom_score(范围 0 ~ 1000),分数越高的进程越先被杀。其计算公式大致为: oom_score = (进程消耗的物理内存百分比 * 10) + oom_score_adj

    我们看看当时的算分情况:

    1. 目标 Java 进程:消耗内存不大,默认 oom_score_adj。

    2. stress-ng 注入进程:消耗了绝大部分内存,本应分数最高。但我们在 YAML 里手贱配置了 oomScoreAdj: -500(为了防止混沌测试进程刚启动就被杀)。这导致它的最终得分大幅降低。

    3. kubelet:官方默认配置了 oom_score_adj = -999,可以说是拿到了"免死金牌"。

    4. containerd / calico-node:在这个版本的集群环境中,部署脚本遗漏了对这些关键系统守护进程配置 oom_score_adj 的下调操作(默认是 0)。

    于是荒诞的一幕出现了:stress-ng 吃光了内存但因为有护身符逃过一劫;containerd 虽然占用不多,但相比有着 -999 护身符的 kubelet 来说,成了分最高的"软柿子",直接被 OOM Killer 刀了。

    防御性 GameDay 的架构加固方案

    不要把演练变成灾难,我们需要在底座和混沌工程平台两端加上硬性约束(Guardrails)。

    1. 补齐 Kubelet 节点级别的资源硬防线 (Cgroup 层)

    仅仅靠用户态的 Kubelet 驱逐是不够的,必须利用 Kubelet 的 Node Allocatable 特性,在内核 cgroup 层面画好红线。

    在 Kubelet 参数中增加以下配置:

    --enforce-node-allocatable=pods
    --system-reserved=cpu=2,memory=4Gi,ephemeral-storage=10Gi
    --kube-reserved=cpu=1,memory=2Gi,ephemeral-storage=5Gi
    

    原理解析:开启 enforce-node-allocatable=pods 后,Kubelet 会在宿主机上创建一个顶级的 kubepods cgroup,并将所有的 Pod 都挂载在这个 cgroup 之下。该 cgroup 的最大内存限制被硬编码为 Node Capacity - kube-reserved - system-reserved。 这样,哪怕所有 Pod 都没有配 Limit,它们联合起来能消耗的最大内存也会被死死按在 kubepods 的 cgroup 隔离带里。一旦越界,内核只会触发 kubepods 这个 cgroup 层级的 OOM,绝对不会影响到处于 system.slice 下的 containerd 和 sshd。

    2. 收拢 Chaos Mesh 爆炸半径:限制注入速率与打分

    在执行 Memory StressChaos 时,严禁使用过低的 oomScoreAdj,同时必须限制 worker 的内存分配速率。可以利用 stress-ng 的底层参数,不要让其"毕其功于一役"地申请内存。

    修改后的安全演练 YAML:

    apiVersion: chaos-mesh.org/v1alpha1
    kind: StressChaos
    metadata:
      name: safe-memory-leak
    spec:
      mode: one
      selector:
        labelSelectors:
          app: payment-gateway
      stressors:
        memory:
          workers: 1
          size: '2GB'
          # 移除 oomScoreAdj,让 stress-ng 接受正常的 OOM 制裁
          options:
            - '--vm-keep'    # 持续保持内存占用而不是反复分配/释放
            - '--vm-bytes' 
            - '2G'
    

    3. 拦截违规负载:强制引入 LimitRange 与 Mutating Webhook

    运维必须兜底。为了防止开发再次上线只有 requests 没有 limits 的“定时炸弹”,在所有 namespace 强制下发 LimitRange,对没有配置 limits 的 Pod 进行自动补全:

    apiVersion: v1
    kind: LimitRange
    metadata:
      name: enforce-limits
    spec:
      limits:
      - default:
          memory: "2Gi" # 强制加上 Limit,将容器锁定在 Cgroup OOM 范畴
        defaultRequest:
          memory: "512Mi"
        type: Container
    

    常见问题 (FAQ)

    Q1:进行 CPU 混沌注入(CPU Stress)时,是否也会遇到这种节点雪崩的风险? 相对可控。CPU 是可压缩资源(Compressible Resource),而内存是不可压缩资源。即使 CPU 被 stress-ng 打满,内核通过 CFS (Completely Fair Scheduler) 仍能保证关键进程(如 kubelet,通常在启动时会拉高 nice 优先级或单独的 cpuset)获得时间片。但如果大量生成陷入内核态(D状态)的压测进程,耗尽了 PID 或者导致 Syscall 卡死,依然可能拖垮节点。

    Q2:如何确认节点是因为 Global OOM 崩溃,而不是因为 Kubelet 驱逐引起的重启? 直接登录现场宿主机(如果还能登入),或者查看采集的系统日志:执行 dmesg -T | grep -i oom-killer 或 cat /var/log/messages | grep "Out of memory"。如果有大量针对非目标进程的 Killed process 日志,且没有 Kubelet Evicting Pod 的审计事件,那大概率就是发生了击穿 cgroup 的 Global OOM。

    Q3:在 Cgroup v2 环境下,内存混沌注入的行为会有变化吗? Cgroup v2 引入了更平滑的内存控制机制,比如 memory.high(软限流,触达后会大力压制进程运行并强制内存回收)和 memory.max(硬限流,等同于 v1 的 limit_in_bytes)。如果在 v2 集群下配合 Kubelet 的 MemoryQoS 特性,未配 Limit 的 Pod 在吃光内存前,会先触发 memory.high 的限流惩罚,这在一定程度上延缓了内存飙升速度,能给 cAdvisor 和 Kubelet 留出更多时间执行优雅驱逐(Eviction)。

  • 深入 Chaos Mesh 陷阱排查:IOChaos FUSE 阻塞引发的 Kubelet D状态死锁与 GameDay 爆炸半径失控实战

    结论先行:在某次验证 I/O 降级 SLO 的 GameDay 实战中,使用 Chaos Mesh IOChaos (v2.5.1) 注入磁盘延迟。由于注入器 FUSE 进程 (toda) OOM,遗留死挂载点,导致 Kubelet 采集 Volume 指标时触发 stat 系统调用陷入 D 状态(Uninterruptible Sleep)。最终 PLEG 超时,节点 NotReady。破局方案:执行 umount -l 强卸载死挂载点;长期规范需在 GameDay 平台接入 Prometheus 异常熔断机制,并优先采用基于 eBPF 的 I/O 注入方案。

    GameDay 现场:被击穿的爆炸半径

    近期在落地高可用容灾演练时,SRE 团队设计了一个针对有状态服务(MySQL 集群)的 GameDay。核心 SLO 是:当单节点磁盘 I/O 出现严重毛刺(P99 延迟突破 500ms)时,上层业务的熔断降级机制应在 30 秒内生效,保障整体 API 成功率不低于 99.9%。

    我们通过 Chaos Mesh 下发了 IOChaos,期望在目标 Pod 的数据目录注入 300ms 的延迟:

    apiVersion: chaos-mesh.org/v1alpha1
    kind: IoChaos
    metadata:
      name: mysql-io-delay
      namespace: db-cluster
    spec:
      action: latency
      mode: one
      selector:
        labelSelectors:
          app: mysql
      volumePath: /var/lib/mysql
      delay: '300ms'
      duration: '5m'
    

    注入下发后前 2 分钟,业务指标按预期平滑降级。但到了第 3 分钟,监控大盘突然雪崩:

    1. 宿主机 Load Average 从日常的 4 飙升至 200+。

    2. 该 Node 上所有微服务的 QPS 跌零,网关大量 504 报错。

    3. K8s 控制面告警:该节点进入 NotReady 状态,触发大面积 Pod Eviction(驱逐)。

    一场本该局限在单个 MySQL Pod 内的故障注入,失控变成了整个 Node 的雪崩。

    现场排查:揪出 D 状态的幕后黑手

    登录宿主机(K8s v1.24.10, Kernel 5.4.x),系统响应极度卡顿,top 命令显示 CPU Sys 态占用并不高,但 iowait 异常。

    查看 Kubelet 日志,发现经典的 PLEG 死亡报错:

    E0915 14:22:31.451921   14212 kubelet.go:1982] "PLEG is not healthy:" ...
    W0915 14:23:01.452132   14212 node_status.go:421] "Error updating node status, will retry" err="timeout waiting for PLEG"
    

    PLEG (Pod Lifecycle Event Generator) 不健康,通常意味着 Kubelet 的某个关键 Sync 循环被彻底阻塞。由于 Load Average 极高,立刻怀疑存在大量 D 状态进程:

    # 抓取所有 D 状态进程
    ps -eo state,pid,cmd | awk '$1=="D"'
    

    输出令人头皮发麻,不仅几十个日常运维 Agent(如 Fluent-bit, Node-Exporter)处于 D 状态,连 kubelet 主进程赫然在列!

    查看 Kubelet 的内核调用栈,寻找阻塞点:

    cat /proc/$(pidof kubelet)/stack
    

    内核栈输出:

    [<0>] request_wait_answer+0x12e/0x210 [fuse]
    [<0>] fuse_simple_request+0x1a9/0x2e0 [fuse]
    [<0>] fuse_getattr+0x2cc/0x350 [fuse]
    [<0>] vfs_getattr_nosec+0x2a/0x40
    [<0>] vfs_getattr+0x26/0x30
    [<0>] vfs_statx+0x79/0xe0
    [<0>] __do_sys_newstat+0x3d/0x70
    [<0>] do_syscall_64+0x5c/0x1a0
    [<0>] entry_SYSCALL_64_after_hwframe+0x44/0xa9
    

    真相大白:Kubelet 死锁在了 fuse_getattr 上,也就是尝试去获取某个 FUSE(用户态文件系统)挂载点的信息时,被底层 FUSE 守护进程彻底 Block 了。

    紧急止血:通过 mount | grep fuse 找到对应挂载点,强制卸载。

    umount -f -l /var/lib/kubelet/pods/xxx/volumes/kubernetes.io~empty-dir/data
    systemctl restart kubelet
    

    节点随即恢复 Ready,Load Average 在 1 分钟内回落。

    为什么一个 Pod 的 IOChaos 会导致宿主机 Kubelet 死锁?

    这涉及 Chaos Mesh IOChaos 的底层实现原理机制与 Kubelet 监控机制的致命冲突。

    1. toda FUSE 劫持机制: 在 Chaos Mesh (v2.5.x 默认机制) 中,IOChaos 的底层是通过注入一个名为 toda 的组件来实现的。toda 基于 FUSE。当你指定 volumePath 时,Chaos-daemon 会将原始目录 move 走,然后用 toda 起一个 FUSE 挂载点在原位置。Pod 内所有的 I/O 请求都会穿透 VFS 发给 FUSE,再由 toda 进程在用户态增加延迟后,转发给底层真实文件系统。

    2. toda 进程的静默死亡: 排查系统日志发现 dmesg -T | grep toda: text Out of memory: Killed process 31415 (toda) total-vm:451232kB, anon-rss:102400kB... 在注入 300ms 延迟后,MySQL 大量 I/O 请求堆积,导致处理这些请求的 toda 进程内存暴涨,触及了宿主机 cgroup 限制,被内核 OOM Killer 强杀。

    3. Kubelet 踩雷: toda 进程死后,FUSE 挂载点 /var/lib/kubelet/pods/.../volumes/... 变成了一个死挂载点 (Orphaned Mount)。没有任何用户态进程来响应这个挂载点上的 VFS 请求。 而 Kubelet 内部集成的 cAdvisor 模块,会定期扫描宿主机上所有 Pod 的 Volume 目录(计算 ephemeral-storage 占用量)。当 Kubelet 发起 stat() 系统调用遍历到这个死挂载点时,由于 FUSE 的特性,内核会一直等待用户态的回复。结果就是:Kubelet 陷入无法被信号中断的 D 状态。 PLEG 线程因 Kubelet 整体卡死而超时,最终判定 Node NotReady。

    GameDay 防御性架构与改造实践

    为了避免演练变成灾难,我们在底层架构与演练平台上做了三项核心改造:

    1. 禁用 FUSE 注入,切换为 eBPF 模式

    FUSE 代理模式在生产环境的脆弱性太高。Chaos Mesh 实际上从较新版本开始提供了实验性的基于 eBPF 的 I/O 注入,或者可以直接使用 ChaosBlade 的基于内核态(SystemTap/eBPF)的 disk delay。 如果必须使用 FUSE,则必须对注入侧进程(toda)的资源进行独立调优,并且绝对禁止作用于 Kubelet 关键路径扫描的目录。

    2. Kubelet 免疫配置优化

    为了防御类似 NFS 夯死、FUSE 异常导致的 Kubelet 雪崩,可以通过配置 Kubelet 参数,降低统计频率或关闭部分非核心目录的扫描,避免单点阻塞拖垮主循环(尽管根本上还是内核层面的限制,但在 Kubernetes 1.25+ 中对 PLEG 的底层逻辑做了部分解耦)。

    3. 建设自动熔断的 GameDay 引擎

    真正的混沌工程绝不是“在生产环境乱搞”,而是高度受控的科学实验。我们在自研的 GameDay 平台中,强制要求配置停止条件 (Halt Conditions)。 通过 webhook 联动 Prometheus,如果在演练期间满足以下 PromQL 任意一条,演练引擎将立即调用 Chaos Mesh API 执行 Delete 操作并触发报警:

    # 熔断策略片段
    haltConditions:
      - name: "Node Load 异常熔断"
        query: "node_load1{instance='$NODE_IP'} > 50"
        duration: "30s"
      - name: "全局 5xx 错误率飙升"
        query: "sum(rate(istio_requests_total{response_code=~\"5.*\"}[1m])) / sum(rate(istio_requests_total[1m])) > 0.05"
        duration: "10s"
    

    常见问题

    Q: 如何快速定位宿主机上哪些进程卡在了哪个死挂载点? A: 首先通过 dmesg | grep "blocked for more than" 查看内核警告。然后执行 mount | grep fuse 列出嫌疑挂载点。如果直接使用 df -h 卡住,可以使用 cat /proc/mounts(读取内存,不会触发 stat)来排查死挂载的具体路径。

    Q: Chaos Mesh 的 NetworkChaos 会有类似的爆炸半径扩散问题吗? A: NetworkChaos 底层原理是操作网络命名空间中的 TC (Traffic Control) 和 iptables。只要 Pod 是独立的 Network Namespace(没有使用 hostNetwork: true),网络注入通常被严格限制在 Pod 级别,极少出现穿透到宿主机导致 Node NotReady 的情况,其安全性远高于基于挂载的 IOChaos。

    Q: 遇到 D 状态进程,除了重启物理机,还有没有优雅的恢复办法? A: D 状态是内核层面的等待,常规的 kill -9 无效。如果是 NFS/Ceph/FUSE 这类网络或代理文件系统导致的 D 状态,强行卸载挂载点(umount -f -l <路径>)通常是唯一解。如果是本地物理磁盘硬件损坏导致的 D 状态,基本只能等待 I/O 超时或硬件复位。

  • 深入 ChaosBlade 陷阱排查:DNS 延迟注入引发的 UDP conntrack 溢出与节点雪崩实战

    在一次验证系统对 DNS 解析抖动容忍度的 GameDay 实战中,仅向 CoreDNS 注入 200ms 延迟,竟导致数十个业务节点接连失联。核心结论:高并发下微服务的无脑重试,配合 Linux UDP 默认 30 秒的 nf_conntrack_udp_timeout 状态保留,会瞬间撑爆 nf_conntrack 表。在进行网络层混沌工程时,必须提前调优内核连接跟踪参数或使用 raw 表豁免 DNS 流量,并设置基于系统底层指标的爆炸半径熔断器。

    1. 故障现场:一场失控的 GameDay

    近期的 SLO 验证计划中,我们需要验证核心交易链路在 DNS 存在长尾延迟(P99 200ms)时的系统表现,以确认超时控制和降级策略是否按预期生效。

    使用的故障注入工具是 ChaosBlade (v1.7.0),目标集群为 Kubernetes 1.22,宿主机内核为 5.4.x。通过以下命令对 CoreDNS Pod 所在节点注入网络延迟:

    blade create k8s network delay \
      --time 200 --offset 50 \
      --interface eth0 \
      --namespace kube-system \
      --names coredns-xxxx,coredns-yyyy
    

    预期现象:业务监控面板中,外部接口调用的 P99 延迟略微上升,部分请求触发 500ms 的断路器,系统平稳降级。 实际现象:注入 1 分钟后,监控大盘不仅没有展现预期的降级曲线,反而出现了严重的“断崖”。更致命的是,API Server 报错频繁,多个承载高并发业务的 Worker 节点状态变为 NotReady,节点上的所有 Pod 被判定为不可用,开始触发大规模漂移重调度的雪崩。

    2. 现场排查:谁拔了宿主机的网线?

    由于故障节点 SSH 已经无法连入(连接直接超时),通过带外管理(IPMI)登录物理机终端。

    执行 top 查看,CPU 使用率不到 30%,Load Average 在 4.0 左右(对于 64 核机器极低),内存也很充足。但网络就是不通,ping 网关全丢包。

    习惯性拉出内核环形缓冲区日志排查:

    dmesg -T | tail -n 20
    

    满屏的红色报错直击痛点:

    [Tue Oct 24 14:12:33 2023] nf_conntrack: nf_conntrack: table full, dropping packet
    [Tue Oct 24 14:12:33 2023] nf_conntrack: nf_conntrack: table full, dropping packet
    

    查看当前的连接跟踪数和系统上限:

    cat /proc/sys/net/netfilter/nf_conntrack_count
    # 输出: 262144
    cat /proc/sys/net/netfilter/nf_conntrack_max
    # 输出: 262144
    

    毫无疑问,宿主机的 nf_conntrack 表被打满了,导致 Netfilter 丢弃了所有新建连接的包(包括 Kubelet 与 API Server 的心跳,以及新的 SSH 握手请求)。

    到底是什么流量塞满了 conntrack 表?通过 conntrack 工具统计状态:

    conntrack -L | awk '{print $1}' | sort | uniq -c
    

    输出结果令人诧异:

          4 ICMP
       1024 tcp
     261116 udp
    

    超过 99% 的表项全被 UDP 占满。

    3. 为什么 200ms 的 DNS 延迟会击穿几十万的 conntrack 表?

    这涉及到 Linux 内核对 UDP 连接跟踪的处理机制,以及业务代码在面对网络抖动时的“疯狂”行为。

    底层原理:UDP 的伪状态机与超时机制

    UDP 本身是无连接的,但为了让 iptables/Netfilter 能够实现状态防火墙(例如允许外部响应包返回内部),内核强行给 UDP 设计了连接跟踪机制。

    当一个 UDP 包发出时,内核在 nf_conntrack 中建立一条状态,标记为 UNREPLIED。如果在默认时间内收到了对端的回包,状态变更为 ASSURED。 在 CentOS/Ubuntu 等主流发行版中,相关的内核参数默认值如下:

    • net.netfilter.nf_conntrack_udp_timeout = 30 (未收到回包时的保留时间,30秒)

    • net.netfilter.nf_conntrack_udp_timeout_stream = 120 (收到回包,被认定为流时的保留时间,120秒)

    业务雪崩推演

    1. 注入延迟:ChaosBlade 通过底层的 tc netem 让 CoreDNS 的响应延迟了 200ms。

    2. 业务超时:业务代码(Go net/http 或某些缺乏连接池管理的短连接客户端)设置的 DNS 查询超时可能极短(例如 100ms)。

    3. 疯狂重试:因为请求 DNS 超时,业务线程/协程被唤醒,立即发起下一次 DNS 解析。关键点来了:每次重试,客户端都会申请一个新的临时端口(Ephemeral Port)作为 UDP 源端口。

    4. 表项爆炸:由于源端口改变,Netfilter 将其视为一条全新的“连接”。旧的 DNS 请求由于没收到回包(还在 tc 的队列里排队),其在 conntrack 表中的 UNREPLIED 记录将死死挂住 30秒 才会过期回收。

    算一笔账:假设单节点有 5000 QPS 的请求,由于 DNS 延迟,导致业务每秒产生 3 次重试。 每秒新增 UDP conntrack 数 = 5000 * 3 = 15000。 经过 30 秒的积累,15000 * 30 = 450,000 条记录。 这就轻而易举地击穿了默认的 nf_conntrack_max (262144),最终导致宿主机网络瘫痪。

    4. 混沌工程防御性设计与底层加固

    发现原因后,解决问题并不难。但在混沌工程实践中,如何防止测试把系统“真搞挂”,才是考验架构师功底的地方。

    1. 系统底层加固:收紧 UDP conntrack 超时

    对于承载高并发微服务的宿主机,默认的 30s 容忍度过于宽泛。建议在 sysctl.conf 中激进地调低这个值,并适当抬高 max 上限。

    # 修改 /etc/sysctl.d/99-kubernetes-cri.conf
    net.netfilter.nf_conntrack_max = 1048576
    net.netfilter.nf_conntrack_udp_timeout = 10
    net.netfilter.nf_conntrack_udp_timeout_stream = 60
    

    执行 sysctl -p /etc/sysctl.d/99-kubernetes-cri.conf 立即生效。

    2. 根治方案:在 Netfilter 层面豁免 DNS 流量

    既然 DNS 是典型的极短生命周期 RPC,且集群内部互信,完全可以直接跳过 conntrack 跟踪。利用 iptables 的 raw 表(优先级高于 conntrack)注入 NOTRACK 规则。

    # 对发往 53 端口的 UDP 流量不进行状态跟踪
    iptables -t raw -I PREROUTING -p udp --dport 53 -j NOTRACK
    iptables -t raw -I OUTPUT -p udp --dport 53 -j NOTRACK
    # 相应的回包也不跟踪
    iptables -t raw -I PREROUTING -p udp --sport 53 -j NOTRACK
    iptables -t raw -I OUTPUT -p udp --sport 53 -j NOTRACK
    

    注:如果集群内使用了依赖于状态跟踪的复杂 NetworkPolicy,此操作可能引发冲突,需配合实际 CNI 插件(如 Calico/Cilium)的具体实现来权衡。

    3. GameDay 的熔断设计:爆炸半径控制

    混沌工程的第一原则是控制爆炸半径。我们在后续的演练体系中,强制引入了基于 Prometheus+Alertmanager+Webhook 的“自动停止机制”。

    编写一个看门狗脚本或部署专门的 DaemonSet,高频采集节点的 /proc/sys/net/netfilter/nf_conntrack_count。 当 (count / max) > 80% 时,触发最高级别告警,Webhook 直接调用 ChaosBlade API 强制销毁当前所有的混沌实验:

    # Webhook 触发的急救脚本片段
    blade status --type create | grep Success | awk '{print $4}' | xargs -I {} blade destroy {}
    

    常见问题

    Q1:为什么不直接使用 NodeLocal DNSCache 来解决这个问题? NodeLocal DNSCache 确实能极大缓解跨节点的 DNS 压力和 conntrack 表争抢(它将 DNS 请求拦截在本地并复用 TCP)。但如果针对 NodeLocal DNSCache 自身所在节点进行注入,或者上游 CoreDNS 完全不可用导致本地缓存穿透,业务依旧会疯狂重试击穿本地的 UDP conntrack 表。底层参数调优依然是最后一道防线。

    Q2:当节点已经 NotReady 且 SSH 无法连接时,如何快速恢复? 如果物理机有 OOB(如 IPMI、iLO),登录后直接调高上限:echo 1048576 > /proc/sys/net/netfilter/nf_conntrack_max 即可瞬间恢复网络通信。若无 OOB 且节点已“僵死”,只能通过 IaaS 控制台硬重启实例,此时务必确认 StatefulSet 挂载的存储卷是否正常卸载,以防脑裂。

    Q3:使用基于 eBPF 的故障注入(如 Chaos Mesh 的 BPF 模式)是否能避免此问题? 不能完全避免。虽然 eBPF 可以在 Socket 层或 TC 层更高效地丢包/延迟,避开部分 Netfilter 链的处理开销。但应用层(如 Go 的 HTTP Client)感知不到底层是被 eBPF 拦截还是真实网络延迟,它依然会发起重试。只要这些重试的 UDP 数据包依然经过宿主机的 Netfilter 协议栈,nf_conntrack 就会尽职尽责地去记录它们,最终依然会导致表满。

  • 深入 Chaos Mesh 陷阱排查:TC netem 队列溢出引发的静默丢包与 GameDay 失控实战

    在进行高并发场景的混沌工程(Chaos Engineering)演练时,网络延迟注入常因 Linux 内核 tc netem 默认队列长度(1000)的硬限制,在超过 QPS * 延迟时间 的吞吐下演变为静默丢包风暴。这会导致预期内的延迟降级被放大为级联雪崩。破局点在于遵循排队论(Little’s Law)调整 qdisc 队列上限,或在高并发链路转向 L7 层故障注入,并建立基于底层的爆炸半径监控。

    故障现场:失控的 GameDay

    在某次支付核心链路的 GameDay 演练中,SRE 团队计划验证断路器(Circuit Breaker)在弱网环境下的 SLO 表现。 演练目标:向支付网关(Payment Gateway)所在的 Pod 注入固定 100ms 的网络延迟。 预期指标:接口 P99 延迟升高至 120ms 左右,部分请求触发熔断,降级链路生效,整体成功率保持在 99.9% 以上。 环境配置:Kubernetes v1.24.10, 操作系统 Alinux 3 (Kernel 5.10), Chaos Mesh v2.6.2。

    通过 Chaos Mesh 下发 NetworkChaos 资源后,监控面板瞬间亮起红灯:

    1. 支付网关的上游 Nginx 出现海量 504 Gateway Timeout 和 502 Bad Gateway。

    2. 支付网关自身的 P99 延迟飙升至 3~5 秒,远超预期的 120ms。

    3. 容器 CPU 出现毛刺,节点 Load Average 飙升。

    4. 业务成功率暴跌至 70%,被迫紧急触发 Chaos Mesh 的 Pause 机制,演练以严重事故(SEV)收场。

    抽丝剥茧:消失的报文与 TCP RTO 退避

    排查过程中,我们首先怀疑是底层网络插件(Cilium/Calico)与 Chaos Mesh 的 eBPF 探针产生了冲突。但在复现环境中,资源水位一切正常。

    为了拿到第一手现场,我们在复现期间通过 nsenter 进入了目标 Pod 的网络命名空间:

    # 获取目标 Pod 的 PID
    PID=$(crictl inspectp $(crictl pods --name payment-gateway-0 -q) | jq .info.pid)
    
    # 进入 Pod 的网络命名空间
    nsenter -t $PID -n
    
    # 检查网卡设备的 qdisc 规则与统计
    tc -s qdisc show dev eth0
    

    终端输出了令人头皮发麻的指标:

    qdisc netem 1: root refcnt 2 limit 1000 delay 100ms
     Sent 1450230 bytes 1230 pkt (dropped 84503, overlimits 0 requeues 0) 
     backlog 14000b 1000p requeues 0
    

    注意看 dropped 84503 和 backlog 14000b 1000p。 这意味着 tc netem 模块正在疯狂丢包。这不仅是“延迟”,这是毁灭性的“断网”。

    伴随着底层丢包,应用层的 TCP 连接开始进入漫长的超时重传(RTO 退避)机制。通过抓包(tcpdump)分析,发现大量的 TCP 报文触发了 200ms、400ms、800ms 的指数级重传退避,直接导致应用层的 P99 延迟被放大到秒级。大量积压的半连接和重传报文耗尽了应用的 worker 线程池,最终导致网关假死。

    为什么单纯的网络延迟注入会演变成毁灭性的丢包风暴?

    要理解这个陷阱,必须深入 Linux 内核的流量控制子系统(Traffic Control)和排队论。

    Chaos Mesh 的 NetworkChaos 底层依赖于 Linux Kernel 的 netem (Network Emulator) 调度器。当你执行延迟注入时,Chaos Mesh 的 chaos-daemon 实际上是在 Pod 的 veth 设备上执行了类似如下的命令:

    tc qdisc add dev eth0 root netem delay 100ms
    

    陷阱在于 netem 的默认队列长度限制(limit)。 在内核源码 net/sched/sch_netem.c 中,当一个数据包进入 netem 队列(netem_enqueue)时,内核会计算当前队列长度:

    static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch,
                 struct sk_buff **to_free)
    {
        struct netem_sched_data *q = qdisc_priv(sch);
        /* ... 延迟计算逻辑 ... */
    
        if (likely(sch->q.qlen < sch->limit)) {
            return qdisc_enqueue_tail(skb, sch);
        }
        // 队列满了,直接丢弃!
        return qdisc_drop(skb, sch, to_free);
    }
    

    默认情况下,netem 的 limit 被硬编码或初始化为 1000 个数据包。

    引入排队论中的利特尔法则(Little’s Law):L = λW

    • L:系统中的平均请求数(在这里是队列中积压的数据包数量)

    • λ:请求到达率(在此场景下为网卡的 PPS,即每秒数据包吞吐量)

    • W:请求在系统中停留的时间(在这里是我们注入的 100ms 延迟,即 0.1s)

    在我们的高并发支付网关场景中,日常吞吐量约为 15,000 QPS,算上 TCP ACK 和分片,实际 PPS 超过 20,000。 将这些数据代入公式: L = 20,000 pkt/s * 0.1 s = 2,000 pkt

    这意味着,为了仅仅维持住 100ms 的延迟而不丢包,netem 队列中时刻需要容纳至少 2000 个数据包。而默认的 limit 只有 1000。 结果显而易见:多出来的包,全部触发了 qdisc_drop。 一个本意是验证延迟 SLO 的 GameDay,因为底层的物理限制,演变成了一场规模庞大的丢包雪崩。

    架构级防御与 GameDay 设计最佳实践

    发现问题后,我们必须在 Chaos 工程体系中实施防御性设计,防止类似的基础设施参数截断导致测试失真。

    1. 显式调整 tc netem limit 参数

    对于确需在网络层(L3/L4)进行大流量延迟注入的场景,必须重写或调整 qdisc 限制。部分混沌工程工具可能未直接暴露 limit 参数,可以通过以下方式介入: 如果使用原生 tc,务必带上计算后的 limit:

    # 假设预估最大 PPS 为 50000,延迟 200ms (0.2s)
    # 理论队列深度 L = 50000 * 0.2 = 10000
    # 留出 20% 冗余,设定 limit 为 12000
    tc qdisc add dev eth0 root netem limit 12000 delay 200ms
    

    在 Chaos Mesh 中,若 CRD 不支持动态扩展限额,可利用 Direction: to 与 Target 选择器,将注入目标限制在特定的下游弱依赖 IP 或端口上,从而大幅度降低匹配该 qdisc 规则的真实 PPS(λ),规避队列溢出。

    2. 高并发链路转向 L7 故障注入

    对于 QPS 动辄破万的 RPC/HTTP 微服务网关,在 L3/L4 模拟延迟极易触碰内核栈瓶颈。最佳实践是利用 Service Mesh(如 Istio / Envoy)的 L7 Fault Injection。 L7 注入发生在用户态,通过挂起协程/线程来模拟延迟,不消耗内核 qdisc 队列,彻底消除了底层丢包的副作用。

    apiVersion: networking.istio.io/v1alpha3
    kind: VirtualService
    metadata:
      name: payment-route
    spec:
      hosts:
      - payment-service
      http:
      - fault:
          delay:
            percentage:
              value: 100.0
            fixedDelay: 0.1s
        route:
        - destination:
            host: payment-service
    

    3. 构建基于旁路指标的“硬刹车”机制

    在 GameDay 中,必须建设基于基础设施指标的自动化 Abort 机制。不能仅盯业务大盘。应将 Node Exporter 的 node_network_transmit_drop_total 或底层 tc 的 drop 速率接入 Prometheus 告警。一旦发现注入期间网卡 drop 速率陡增,混沌平台应通过 Webhook 自动中止演练。

    常见问题

    Q1:进行网络故障注入时,为什么有时会导致 Kubernetes Node 直接变成 NotReady 状态? 这是典型的“爆炸半径穿透”。如果在注入时没有严格指定网卡(如误将规则挂载到了宿主机的 eth0 或 cni0 桥接网上),或者未配置白名单,故障规则会拦截 Kubelet 与 API Server 的心跳通信(默认 10250 端口及 6443 端口)。Kubelet 无法上报状态,Node 就会被标记为 NotReady,随后触发惨烈的 Pod 全局大驱逐(Eviction Storm)。

    Q2:当混沌工程控制面(如 Chaos Controller)宕机,导致注入的故障无法恢复,应如何自救? 这是防御性演练必须考虑的极端场景。底座必须备有“一键逃生”脚本,通过 Ansible 或 K8s DaemonSet 绕过控制面,直接到底层 Node 节点清理网络命名空间内的规则。逃生核心命令为: for pid in $(crictl ps -q | xargs crictl inspectp | grep pid | awk '{print $2}'); do nsenter -t $pid -n tc qdisc del dev eth0 root; done

    Q3:网络丢包注入(Loss)和网络延迟注入(Delay)在内核层的消耗有什么区别? 延迟注入(Delay)需要内核将报文暂存在内存队列中直到时间到期,极度消耗队列长度(limit)和内存资源(backlog),受排队论直接影响;而丢包注入(Loss)是通过内部的随机数生成器(如 prandom_u32())判断命中后直接 kfree_skb 释放内存,对队列深度的压力极小。因此,高并发下注入 Delay 远比注入 Loss 容易引发次生灾害。

  • 深入混沌工程内核:从 TC/eBPF 故障注入到 SLO 自动化验证实战

    混沌工程绝不是毫无章法的“拔网线”。本文直接拆解基于 Chaos Mesh (v2.6.2) 的底层故障注入原理(Linux tc 与 eBPF 机制),并给出一套将故障注入与 Prometheus SLO 报警集成的自动化 GameDay 验证闭环方案。记住:没有可观测性度量和自动恢复兜底的故障注入,纯粹是在搞破坏。

    为什么你的故障注入总是不及预期?深入 TC 与 eBPF 机制

    很多研发拿着现成的 YAML 一把梭,看到 Pod 报错就以为混沌实验成功了。但在真实的排查场景中,如果不清楚底层到底“烂”在哪个系统调用或网络栈层级,你根本无法验证微服务的超时重试和熔断机制是否真正生效。

    1. 网络延迟注入:Netem 与 Namespace 的戏法

    当你下发一个针对某个 Pod 的网络延迟(NetworkChaos)时,控制面并不会去修改交换机配置。底层的 chaos-daemon 会通过 Kubelet 拿到目标容器的 PID,然后利用 nsenter 钻进该容器的网络命名空间(Network Namespace),利用 Linux 内核自带的 Traffic Control (tc) 和 netem 模块进行流量整形。

    某次验证超时熔断时,发现注入 200ms 延迟后应用依然秒回。直接登录 Node,钻入目标 Pod 命名空间查看真实流控规则:

    # 获取目标 Pod 容器的主进程 PID
    PID=$(crictl inspect <container_id> | jq .info.pid)
    
    # 进入容器的网络命名空间查看 tc 规则
    nsenter -t $PID -n tc -s qdisc show dev eth0
    

    正常被注入延迟的网卡,你能看到类似如下的输出:

    qdisc netem 1: root refcnt 2 limit 1000 delay 200.0ms  10.0ms 25%
     Sent 10234 bytes 81 pkt (dropped 0, overlimits 0 requeues 0)
     backlog 0b 0p requeues 0
    

    如果输出是 qdisc pfifo_fast 0:,说明 tc 规则根本没打上。通常是因为 CNI 插件(如 Cilium 的某些 BPF 模式)绕过了宿主机的 veth pair,或者内核没有加载 sch_netem 模块(modprobe sch_netem 可解)。

    2. 磁盘 IO 故障:eBPF 对 VFS 的精准拦截

    早期的 IO 故障注入靠在容器里跑 dd 把磁盘带宽打满,这种做法极度粗暴,且容易引发宿主机的 IO 风暴,波及同节点其他核心 Pod(典型的爆炸半径失控)。

    现代混沌工程(如 Chaos Mesh 的 IOChaos)在内核态使用 eBPF 实现精准注入。要求宿主机内核至少在 4.17+(推荐 5.4+ 以获得稳定的 BPF 特性)。其原理是将一段 BPF 字节码挂载到内核的 VFS(虚拟文件系统)层面上,例如通过 kprobe 拦截 vfs_read 和 vfs_write 函数。

    当目标进程发起读写请求时,BPF 程序会被触发,强制在内核态 bpf_ktime_get_ns() 循环等待(制造延迟),或者直接修改系统调用返回值,返回 -EIO (Input/output error)(制造读写失败)。这种方式只针对特定 PID 和特定目录生效,彻底切断了对宿主机全局的干扰。

    SLO 验证闭环:用数据说话,拒绝肉眼盯盘

    GameDay(故障演练日)的核心不是制造恐慌,而是验证系统的容错边界是否符合 SLO(服务级别目标)。我们通常以 Error Budget(错误预算)消耗率为核心判定标准。

    在演练前,必须确保 Prometheus 中有定义严谨的 SLO 监控指标。例如,核心交易链路的 P99 延迟 SLO 定义为 200ms。

    # 记录规则:计算订单服务 P99 延迟
    record: job:request_latency:p99
    expr: histogram_quantile(0.99, sum(rate(http_request_duration_seconds_bucket{service="order-svc"}[1m])) by (le))
    

    在 GameDay 流程中,自动化脚本的逻辑应该是:

    1. 持续轮询拉取当前 P99 延迟,确认 Baseline 正常(如 50ms)。

    2. 下发 NetworkChaos,注入 150ms 延迟。

    3. 观测 P99 延迟指标是否在 1 分钟内攀升至 200ms 左右。

    4. 核心断言:断言上游 API Gateway 的 5xx 错误率是否上升。如果上游配置了合理的 100ms 超时和重试熔断,上游应用应触发熔断策略,而不会被下游彻底拖死导致线程池耗尽(防止级联雪崩)。

    GameDay 实战剧本:千万别忘了防御性恢复

    这里给出一个验证数据库主备切换的真实网络隔离注入配置片段。注意其中的 duration 和 mode 参数,这是防御性编程在混沌工程中的体现。

    apiVersion: chaos-mesh.org/v1alpha1
    kind: NetworkChaos
    metadata:
      name: db-partition-gameday
      namespace: sre-chaos
    spec:
      action: partition
      mode: fixed
      value: "1" # 仅影响 1 个目标 Pod(爆炸半径控制)
      selector:
        namespaces:
          - production
        labelSelectors:
          "app": "mysql-cluster"
          "role": "master"
      direction: both
      target:
        selector:
          namespaces:
            - production
          labelSelectors:
            "app": "order-service"
      # 极其重要:强制 60 秒后自动恢复。严禁在没有自动恢复时间的配置下执行演练!
      duration: "60s" 
    

    排查心法:演练过程中如果发现系统挂了且无法自愈,第一反应是直接删除 Chaos 资源(kubectl delete networkchaos db-partition-gameday -n sre-chaos)。如果 chaos-controller-manager 组件本身在这个时候假死卡住了,立刻在宿主机执行兜底恢复脚本: find /proc -maxdepth 1 -regex '/proc/[0-9]+' -exec nsenter -t {} -n tc qdisc del dev eth0 root 2>/dev/null \; (强制清理节点上所有的 tc 限制,简单粗暴但救命)。

    常见问题

    Q1: 生产环境做混沌实验,如果控制面(Controller)挂了,故障一直存在怎么兜底? 控制面宕机会导致 duration 到期后无法自动清理。成熟的落地方案必须在 Node 层面部署一层“看门狗(Watchdog)”。可以写一个 DaemonSet,每 10 秒去 APIServer 检查特定 Chaos 对象是否存在,如果 APIServer 超时无响应,或者 Chaos 对象已被标记删除但底层规则还在,DaemonSet 直接在本地执行 tc qdisc del 或 bpf-loader unload 强制清理底层规则,确保业务绝对存活。

    Q2: 使用 PodChaos 注入了 CPU 满载(Stress)故障,为什么进容器敲 top 命令看到的 CPU 使用率并没有飙升? 这是容器隔离性带来的经典视图问题。top 命令读取的是 /proc/stat,默认情况下容器内挂载的是宿主机的 /proc 系统(除非你使用了 lxcfs 这类用户态文件系统)。因此 top 看到的是整个宿主机的 CPU 状态。要确认容器是否被压满,应该在宿主机查看目标容器对应的 cgroup 统计指标:cat /sys/fs/cgroup/cpu/kubepods.slice/kubepods-pod.slice/cpuacct.usage_percpu。

    Q3: 注入 IO 故障后,为什么 Node 节点内核直接发生 Panic 重启了? eBPF 的能力虽然强大,但拦截诸如 vfs_read/write 属于非常底层的内核操作。在特定的 Linux 内核版本(尤其是一些云厂商魔改的 4.19.x 分支)中,bpf 钩子与系统现有的某些内核模块(如特定的存储驱动)会产生竞态条件。遇到内核 Panic,首先通过 kdump 捕获 vmcore,用 crash 工具查看堆栈调用树(Backtrace),通常能看到 bpf_prog_XXX 导致了空指针解引用。解决办法是:升级内核至稳定版(如 5.4.x),或改用相对高层的应用级注入方案。