别在事故复盘会上才想起混沌工程:从 Kubernetes 源码看故障注入如何真正验证韧性

引言

我见过太多团队的系统"韧性"只存在于 PPT 里。

去年帮一家公司做架构评审,他们的高可用方案写得漂亮:三副本部署、PodDisruptionBudget、HPA 自动扩缩、跨可用区容灾。我问了一句:"你们做过故障注入验证吗?"对方说做过——"演练时手动删了一个 Pod,服务没挂,很稳。"

这就是典型的假韧性。删一个 Pod 是最温柔的故障,Kubernetes 的 ReplicaSet Controller 会在几百毫秒内补上一个新 Pod,你验证的其实不是系统韧性,而是 K8s 控制器的自愈能力。真实的生产事故从来不这么温柔:节点级网络分区、etcd 慢查询导致的 Apiserver 假死、DNS 解析超时、依赖服务返回 200 但 body 是脏数据、磁盘 IO 打满导致探针误判……这些才是杀死系统的元凶。

混沌工程的核心不是"制造故障",而是用受控的实验去证伪你对系统的假设。这篇文章我会从 Kubernetes 的探针实现源码讲起,说明为什么很多"故障注入"根本没注入到关键路径上,然后给出三套可直接落地的代码:基于 eBPF 的故障注入、基于 Chaos Mesh 的声明式实验、以及嵌入 CI 流水线的韧性门禁。最后对比主流方案,聊聊我踩过的坑。


核心概念:混沌工程到底在验证什么

生活类比:消防演习 vs 真火训练

传统监控告警像消防演习——烟感报警器响了,你按流程疏散,一切井然有序。但演习里没人真的放火,你不知道防火门会不会卡死、消防通道会不会被杂物堵住。

混沌工程像受控的真火训练:在消防员待命的条件下,真的点一把小火,看整条逃生链路是否真的通畅。关键在于"受控"——火候、范围、逃生窗口都要精确设计,否则就从训练变成了纵火。

技术定义

混沌工程是在生产或准生产环境中,主动注入受控故障,以验证系统在异常条件下仍能维持可接受服务水平的工程实践。它有三个不可妥协的要素:

  1. 稳态假设(Steady State Hypothesis):用可量化的业务指标定义"正常",比如 P99 延迟 < 200ms、订单成功率 > 99.5%。
  2. 受控实验(Controlled Experiment):故障有精确的爆炸半径(Blast Radius),可随时中止。
  3. 自动化闭环(Automated Loop):实验可重复、可编排、可进 CI,而不是一次性手工操作。

区别一下三个容易混淆的概念:

概念 目的 时机 典型手段
故障演练 验证应急预案是否可执行 定期 人工按 runbook 操作
混沌工程 证伪系统韧性假设 持续/自动化 受控注入 + 稳态断言
故障测试(Fault Testing) 验证特定故障下的行为 开发阶段 单元/集成测试打桩

源码深度分析:为什么你的故障注入没打到关键路径

要注入有效的故障,必须理解 K8s 判定"Pod 是否健康"的真实机制。很多人注入网络延迟后,服务明明已经不可用,但 K8s 就是不重启 Pod——因为探针的失败阈值和超时设置有坑。

kubelet 探针执行源码剖析

kubelet 的探针逻辑在 pkg/kubelet/prober/worker.go 里。每个容器每种探针(liveness/readiness/startup)都有一个独立的 worker,核心循环是 doProbe:

// 摘自 kubernetes/pkg/kubelet/prober/worker.go(简化并加注释)
func (w *worker) doProbe() (keepGoing bool) {
    // 1. 取容器状态,容器没起来直接跳过
    status, ok := w.probeManager.statusManager.GetPodStatus(w.pod.UID)
    if !ok || status == nil {
        return true
    }

    // 2. 执行真正的探针,注意这里返回 (result, output, err)
    result, output, err := w.probeManager.prober.probe(
        w.probeType, w.pod, status, w.container, w.containerID)
    if err != nil {
        // 探针执行框架本身出错(如 exec 无法进入容器),不计入失败次数
        return true
    }

    switch result {
    case results.Success:
        // 成功:清零失败计数
        w.onProbeResult(true)
    case results.Failure:
        // 失败:累加失败计数,达到 FailureThreshold 才真正动作
        w.onProbeResult(false)
    case results.Warning:
        // 警告:不改变计数,仅记录事件
    }
    return true
}

关键在 onProbeResult 和它背后的 resultsManager。我把它最核心的判定逻辑抽出来:

// 摘自 kubernetes/pkg/kubelet/prober/results/results_manager.go(简化)
func (m *manager) Set(id kubecontainer.ContainerID, result Result, pod *v1.Pod) {
    if m.update(id, result) {
        // 结果变化时,通知订阅者(worker 通过 channel 收到)
        m.notify(id)
    }
}

// worker 侧根据连续失败次数决定是否触发动作
func (w *worker) onProbeResult(success bool) {
    if success {
        w.resultRun = 0
        return
    }
    w.resultRun++
    // 只有连续失败次数 >= FailureThreshold 才视为真正失败
    if w.resultRun < int(w.probe.FailureThreshold) {
        return
    }
    // 触发动作:liveness 失败 -> 重启容器;readiness 失败 -> 摘流量
    w.handleProbeFailure()
}

这里藏着第一个大坑:假设你的 liveness 探针配置是 timeoutSeconds: 1, failureThreshold: 3, periodSeconds: 10。当注入 500ms 网络延迟时,探针可能只是偶尔超时,连续 3 次失败需要 30 秒,而在这 30 秒里,你的服务可能已经把错误请求打爆了下游。更糟的是,如果你的探针走的是 localhost 直连进程,网络延迟注入根本没影响到探针——探针永远成功,K8s 永远不会重启你那个已经响应缓慢的 Pod。

这就是"假韧性"的源码级原因:故障注入的路径和健康判定的路径不一致。

探针链路示意图

graph TD A[kubelet prober worker] -->|HTTP GET /healthz| B[Pod IP:8080] B --> C{是否经过 Service/Ingress?} C -->|否,直连 Pod| D[业务进程] C -->|是| E[Envoy/Sidecar] E --> D F[Chaos Injection] -->|注入延迟| G{注入位置} G -->|注入在 Pod 网络栈| B G -->|注入在 Service 层| E G -->|注入在 localhost| D style F fill:#f96 style D fill:#9cf

如果故障注入点(橙色)和探针实际访问路径(蓝色)不重合,注入就白费了。正确做法是让探针也走真实的网络路径,或者直接注入到进程内部(如 eBPF 的 tcp_sendmsg 钩子)。


实战代码:三套可落地的故障注入方案

示例一:基于 eBPF 的透明网络故障注入

传统 tc netem 只能注入到网卡层,对 localhost 和进程内部调用无效。eBPF 可以挂到 connect/sendmsg 等系统调用上,实现进程级的精确故障注入。下面是一个用 cilium/ebpf 库写的注入器,对目标进程的所有出站连接注入 30% 概率的 500ms 延迟:

// fault_injector.go
// 编译: go build -o injector fault_injector.go
// 运行: sudo ./injector -pid 12345 -delay 500 -prob 30
package main

import (
	"flag"
	"fmt"
	"log"
	"os"
	"time"

	"github.com/cilium/ebpf"
	"github.com/cilium/ebpf/link"
)

//go:generate bpf2go -cc clang Injector injector.bpf.c -- -I./headers

// bpfProgram 是编译后的 eBPF 字节码(通过 bpf2go 生成)
// 这里展示核心加载与挂载逻辑

func main() {
	targetPID := flag.Int("pid", 0, "目标进程 PID")
	delayMs := flag.Int("delay", 500, "注入延迟(毫秒)")
	probPct := flag.Int("prob", 30, "触发概率(%)")
	flag.Parse()

	if *targetPID == 0 {
		log.Fatal("必须指定 -pid")
	}

	// 1. 加载 eBPF 程序(由 bpf2go 从 injector.bpf.c 生成)
	spec, err := LoadInjector()
	if err != nil {
		log.Fatalf("加载 eBPF spec 失败: %v", err)
	}

	// 2. 写入配置到 eBPF map,供内核态程序读取
	//    key=0 存储 delay_ns,key=1 存储概率
	if err := spec.RewriteConstants(map[string]interface{}{
		"target_pid": uint32(*targetPID),
		"delay_ns":   uint64(*delayMs) * 1e6,
		"prob":       uint32(*probPct),
	}); err != nil {
		log.Fatalf("重写常量失败: %v", err)
	}

	var objs InjectorObjects
	if err := spec.LoadAndAssign(&objs, nil); err != nil {
		log.Fatalf("加载 eBPF 对象失败: %v", err)
	}
	defer objs.Close()

	// 3. 挂载到 sys_enter_connect 追踪点,拦截所有 connect 调用
	tp, err := link.Tracepoint("syscalls", "sys_enter_connect", objs.HandleConnect, nil)
	if err != nil {
		log.Fatalf("挂载 tracepoint 失败: %v", err)
	}
	defer tp.Close()

	fmt.Printf("已对 PID %d 注入延迟: %dms, 概率: %d%%\n", *targetPID, *delayMs, *probPct)
	fmt.Println("按 Ctrl+C 停止注入")
	// 保持运行,直到收到信号
	<-make(chan struct{})
}

// injector.bpf.c 核心片段(供理解,实际需用 clang -target bpf 编译):
/*
#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_tracing.h>

const volatile __u32 target_pid = 0;
const volatile __u64 delay_ns = 0;
const volatile __u32 prob = 0;

SEC("tracepoint/syscalls/sys_enter_connect")
int handle_connect(struct trace_event_raw_sys_enter *ctx) {
    __u32 pid = bpf_get_current_pid_tgid() >> 32;
    if (pid != target_pid) return 0;
    // 用 bpf_get_prandom_u32 做概率判定
    if ((bpf_get_prandom_u32() % 100) >= prob) return 0;
    // 注意:tracepoint 上下文不能直接睡眠,
    // 实际延迟需配合 bpf_override_return 或 kprobe + bpf_send_signal 实现
    // 这里演示概率判定逻辑,真正的延迟在用户态通过信号+定时器协同完成
    return 0;
}
char LICENSE[] SEC("license") = "GPL";
*/

说明:eBPF 在 tracepoint 上下文里不能直接睡眠,实际生产级延迟注入需要用 bpf_override_return 让 connect 立即返回 -EINPROGRESS,再由用户态代理延迟后再真正建连;或者用 fentry + bpf_loop 配合 bpf_ktime_get_ns 忙等(有风险)。这是 eBPF 故障注入的第一个坑:内核态无睡眠上下文。很多开源工具(如 ChaosBlade)在用户态用 LD_PRELOAD 打桩来绕过这个限制,牺牲了透明性换取实现简单。

示例二:Chaos Mesh 声明式实验——验证 PDB 与探针协同

Chaos Mesh 是 K8s 原生的混沌平台,用 CRD 声明实验。下面这个实验同时注入"Pod 网络分区"和"高负载",用来验证你的 PDB 是否真的能防止服务雪崩:

# chaos-experiment.yaml
# 场景:模拟一个可用区网络分区,同时给剩余 Pod 施压
# 验证目标:PDB 生效、剩余副本不被驱逐、SLO 不跌破阈值
apiVersion: chaos-mesh.org/v1alpha1
kind: NetworkChaos
metadata:
  name: zone-partition
  namespace: chaos-testing
spec:
  action: partition          # 分区,而非简单延迟
  mode: one                  # 每次只影响一个 Pod,控制爆炸半径
  selector:
    namespaces: ["order-service"]
    labelSelectors:
      app: order-service
  direction: both
  target:
    selector:
      namespaces: ["payment-service"]   # 切断 order -> payment 的调用
      labelSelectors:
        app: payment-service
    mode: all
  duration: "5m"
  scheduler:
    cron: "@every 2h"        # 定期执行,纳入日常
---
apiVersion: chaos-mesh.org/v1alpha1
kind: StressChaos
metadata:
  name: cpu-stress
  namespace: chaos-testing
spec:
  mode: fixed-percent
  value: "30"                # 30% 的 Pod 施压
  selector:
    namespaces: ["order-service"]
    labelSelectors:
      app: order-service
  stressors:
    cpu:
      workers: 2
      load: 80               # 80% CPU 负载
  duration: "5m"
---
# PDB:验证驱逐保护是否生效
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: order-service-pdb
spec:
  minAvailable: 2            # 至少保留 2 个可用副本
  selector:
    matchLabels:
      app: order-service

配合下面的稳态断言脚本,实验才算完整——没有断言的故障注入只是制造混乱,不是混沌工程:

# steady_state_check.py
# 稳态断言:实验前后对比业务指标,任何一项跌破阈值则判定"韧性不足"
import time
import requests

PROMETHEUS = "http://prometheus:9090/api/v1/query"

# 稳态假设:这三个指标定义了"系统正常"
STEADY_STATE = {
    "order_success_rate": ("sum(rate(order_success_total[2m])) / sum(rate(order_total[2m]))", 0.995),
    "p99_latency_ms":     ("histogram_quantile(0.99, sum(rate(order_latency_bucket[2m])) by (le))", 200),
    "error_budget_burn":  ("sum(rate(http_errors_total[2m])) / sum(rate(http_requests_total[2m]))", 0.01),
}

def query(expr):
    resp = requests.get(PROMETHEUS, params={"query": expr}).json()
    return float(resp["data"]["result"][0]["value"][1])

def assert_steady_state(phase):
    """phase: 'before' 或 'during',用于对比"""
    failures = []
    for name, (expr, threshold) in STEADY_STATE.items():
        val = query(expr)
        # 延迟和错误率是"越小越好",成功率是"越大越好"
        if name == "order_success_rate":
            ok = val >= threshold
        else:
            ok = val <= threshold
        status = "PASS" if ok else "FAIL"
        print(f"[{phase}] {name}: {val:.4f} (阈值 {threshold}) -> {status}")
        if not ok:
            failures.append(name)
    return failures

if __name__ == "__main__":
    print("=== 实验前基线采集 ===")
    before = assert_steady_state("before")
    if before:
        print(f"基线本身就不达标: {before},实验无意义,中止")
        exit(1)

    print("=== 故障注入中,持续观测 5 分钟 ===")
    violations = []
    for _ in range(30):  # 每 10 秒采样一次
        violations += assert_steady_state("during")
        time.sleep(10)

    if violations:
        print(f"韧性不足!以下指标在故障期间被击穿: {set(violations)}")
        exit(2)   # 非零退出码,供 CI 阻断
    print("韧性验证通过:故障期间稳态假设始终成立")

示例三:把韧性门禁嵌入 GitOps + CI 流水线

混沌实验最大的价值是左移——在代码合并前就验证韧性,而不是等生产事故。下面是一个 Argo Workflows 定义,在每次 GitOps 同步前跑一轮"冒烟级混沌测试",失败则阻断发布:

# resilience-gate.yaml
# 嵌入 GitOps 发布流水线的韧性门禁
apiVersion: argoproj.io/v1alpha1
kind: WorkflowTemplate
metadata:
  name: resilience-gate
  namespace: ci
spec:
  entrypoint: resilience-pipeline
  templates:
  - name: resilience-pipeline
    steps:
    - - name: deploy-canary
        template: deploy-canary
    - - name: inject-fault
        template: inject-fault
    - - name: verify-steady-state
        template: verify-steady-state
      # 关键:断言失败则整个发布中止
      when: "{{steps.inject-fault.outputs.result}} == succeeded"

  - name: deploy-canary
    container:
      image: bitnami/kubectl:latest
      command: [sh, -c]
      args:
        - |
          kubectl set image deploy/order-service order-service=registry/order:v-{{workflow.parameters.version}} -n order
          kubectl rollout status deploy/order-service -n order --timeout=120s

  - name: inject-fault
    container:
      image: chaos-mesh/chaos-mesh:latest
      command: [sh, -c]
      args:
        - |
          # 用短时、小爆炸半径的故障,只影响 canary 副本
          cat <<EOF | kubectl apply -f -
          apiVersion: chaos-mesh.org/v1alpha1
          kind: PodChaos
          metadata: {name: gate-pod-kill, namespace: chaos-testing}
          spec:
            action: pod-kill
            mode: one
            selector:
              namespaces: [order]
              labelSelectors: {app: order-service, track: canary}
            duration: "60s"
          EOF
          sleep 60
          # 清理实验资源,避免影响后续
          kubectl delete podchaos gate-pod-kill -n chaos-testing --ignore-not-found

  - name: verify-steady-state
    container:
      image: python:3.11-slim
      command: [python, /scripts/steady_state_check.py]
      # 挂载上面写的断言脚本
      volumeMounts:
        - name: scripts
          mountPath: /scripts
    # 若脚本 exit(2),此 step 失败,流水线中止,canary 不晋级

对应 GitOps 侧,Argo CD 的 Sync 钩子可以关联这个 Workflow,形成闭环:

graph LR A[Git Push] --> B[Argo CD 检测变更] B --> C[部署 Canary] C --> D[触发 Resilience Gate] D --> E{稳态断言} E -->|通过| F[晋级全量发布] E -->|失败| G[自动回滚 + 告警] G --> H[记录实验报告] style E fill:#ff9 style G fill:#f99

方案对比:主流混沌工具怎么选

维度 Chaos Mesh ChaosBlade LitmusChaos 自研 eBPF
故障类型覆盖 网络/IO/Pod/JVM/DNS 全 最全(含中间件) K8s 原生 + 部分云 取决于实现深度
部署方式 K8s CRD 独立 Agent + CLI K8s Operator 需自建
爆炸半径控制 强(selector 精确) 中 强 最强(进程级)
学习曲线 中 低 中 高
适合场景 K8s 原生团队 混合技术栈、中间件多 云原生 SRE 极致定制、性能敏感
主要坑 CRD 版本耦合强 Agent 侵入性、端口占用 实验模板需自维护 内核版本、无睡眠上下文

我的建议:K8s 原生环境首选 Chaos Mesh,它的 NetworkChaos 分区能力比 tc netem 更贴近真实故障;如果团队有大量非 K8s 的中间件(Redis 集群、MQ),ChaosBlade 的覆盖面更广。自研 eBPF 只在你有非常明确的定制需求(比如注入到某个特定系统调用、需要纳秒级精度)时才值得投入。


最佳实践与避坑指南

  1. 稳态假设必须用业务指标,不能用基础设施指标。CPU 80% 不代表系统有问题,订单成功率跌到 99% 才是。我见过太多团队拿 "Pod Ready 数量" 当稳态,结果 Pod 全 Ready 但业务全错。
  1. 探针路径 = 故障注入路径。这是本文源码分析的核心结论。如果你的 liveness 探针走 localhost,就一定要用进程级注入(eBPF/LD_PRELOAD),否则你验证的是幻觉。
  1. 爆炸半径必须可计算、可中止。每个实验都要能回答:"最坏情况下会影响多少用户?" 生产环境实验要配 duration 硬超时和自动回滚,别指望值班同学手速。
  1. 从"只读实验"开始。先注入对只读接口的故障(查询超时),验证降级逻辑;再逐步扩展到写路径。上来就注入支付链路,你是想上新闻吗。
  1. 常见坑:FailureThreshold 和 periodSeconds 的乘积就是你的故障检测延迟。注入 30 秒的故障,但探针 30 秒后才判定失败,等于故障窗口和检测窗口完美错开,什么都没测到。实验前先把这两个参数算清楚。
  1. 把混沌实验纳入 SLO 体系。每次实验记录"故障期间 SLO 消耗了多少 error budget",这才是韧性可量化的证据,而不是"演练成功"四个字。
  1. 别在复盘会上才做混沌。混沌工程的价值在于提前证伪假设,事故后补做只是验证根因。真正成熟的团队,混沌实验是 CI 流水线的常驻门禁,每个大版本发布前必跑。

总结

回到开头那个"删一个 Pod 就很稳"的团队。问题不在于他们做错了,而在于他们验证的对象错了:他们验证的是 K8s 控制器的自愈能力,而不是自己系统的韧性。

真正的混沌工程有三个硬核要求:

  • 看源码:理解探针、控制器、网络栈的真实行为,才能设计出"打得中"的故障。K8s 的 onProbeResult 里那个 resultRun < FailureThreshold 的判定,决定了你的故障窗口设计是否有效。
  • 用业务稳态:用订单成功率、P99 延迟这些业务指标做断言,而不是 Pod 数量。没有断言的注入是纵火,不是工程。
  • 左移进流水线:把混沌实验做成 GitOps 发布门禁,让韧性验证成为每次发布的默认动作,而不是季度演练的表演。

延伸思考:混沌工程的下一站是自适应混沌——系统根据当前 error budget 消耗速率,自动调整实验的爆炸半径和频率。当 error budget 充裕时多注入、快迭代;预算告急时自动收缩。这需要把混沌平台、SLO 系统、发布流水线三者打通,也是我目前正在探索的方向。韧性不是测出来的,是设计出来、验证出来的、持续演进出来的。