别在事故复盘会上才想起混沌工程:从 Kubernetes 源码看故障注入如何真正验证韧性
引言
我见过太多团队的系统"韧性"只存在于 PPT 里。
去年帮一家公司做架构评审,他们的高可用方案写得漂亮:三副本部署、PodDisruptionBudget、HPA 自动扩缩、跨可用区容灾。我问了一句:"你们做过故障注入验证吗?"对方说做过——"演练时手动删了一个 Pod,服务没挂,很稳。"
这就是典型的假韧性。删一个 Pod 是最温柔的故障,Kubernetes 的 ReplicaSet Controller 会在几百毫秒内补上一个新 Pod,你验证的其实不是系统韧性,而是 K8s 控制器的自愈能力。真实的生产事故从来不这么温柔:节点级网络分区、etcd 慢查询导致的 Apiserver 假死、DNS 解析超时、依赖服务返回 200 但 body 是脏数据、磁盘 IO 打满导致探针误判……这些才是杀死系统的元凶。
混沌工程的核心不是"制造故障",而是用受控的实验去证伪你对系统的假设。这篇文章我会从 Kubernetes 的探针实现源码讲起,说明为什么很多"故障注入"根本没注入到关键路径上,然后给出三套可直接落地的代码:基于 eBPF 的故障注入、基于 Chaos Mesh 的声明式实验、以及嵌入 CI 流水线的韧性门禁。最后对比主流方案,聊聊我踩过的坑。
核心概念:混沌工程到底在验证什么
生活类比:消防演习 vs 真火训练
传统监控告警像消防演习——烟感报警器响了,你按流程疏散,一切井然有序。但演习里没人真的放火,你不知道防火门会不会卡死、消防通道会不会被杂物堵住。
混沌工程像受控的真火训练:在消防员待命的条件下,真的点一把小火,看整条逃生链路是否真的通畅。关键在于"受控"——火候、范围、逃生窗口都要精确设计,否则就从训练变成了纵火。
技术定义
混沌工程是在生产或准生产环境中,主动注入受控故障,以验证系统在异常条件下仍能维持可接受服务水平的工程实践。它有三个不可妥协的要素:
- 稳态假设(Steady State Hypothesis):用可量化的业务指标定义"正常",比如 P99 延迟 < 200ms、订单成功率 > 99.5%。
- 受控实验(Controlled Experiment):故障有精确的爆炸半径(Blast Radius),可随时中止。
- 自动化闭环(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。
这就是"假韧性"的源码级原因:故障注入的路径和健康判定的路径不一致。
探针链路示意图
如果故障注入点(橙色)和探针实际访问路径(蓝色)不重合,注入就白费了。正确做法是让探针也走真实的网络路径,或者直接注入到进程内部(如 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,形成闭环:
方案对比:主流混沌工具怎么选
| 维度 | 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 只在你有非常明确的定制需求(比如注入到某个特定系统调用、需要纳秒级精度)时才值得投入。
最佳实践与避坑指南
- 稳态假设必须用业务指标,不能用基础设施指标。CPU 80% 不代表系统有问题,订单成功率跌到 99% 才是。我见过太多团队拿 "Pod Ready 数量" 当稳态,结果 Pod 全 Ready 但业务全错。
- 探针路径 = 故障注入路径。这是本文源码分析的核心结论。如果你的 liveness 探针走 localhost,就一定要用进程级注入(eBPF/LD_PRELOAD),否则你验证的是幻觉。
- 爆炸半径必须可计算、可中止。每个实验都要能回答:"最坏情况下会影响多少用户?" 生产环境实验要配
duration硬超时和自动回滚,别指望值班同学手速。
- 从"只读实验"开始。先注入对只读接口的故障(查询超时),验证降级逻辑;再逐步扩展到写路径。上来就注入支付链路,你是想上新闻吗。
- 常见坑:
FailureThreshold和periodSeconds的乘积就是你的故障检测延迟。注入 30 秒的故障,但探针 30 秒后才判定失败,等于故障窗口和检测窗口完美错开,什么都没测到。实验前先把这两个参数算清楚。
- 把混沌实验纳入 SLO 体系。每次实验记录"故障期间 SLO 消耗了多少 error budget",这才是韧性可量化的证据,而不是"演练成功"四个字。
- 别在复盘会上才做混沌。混沌工程的价值在于提前证伪假设,事故后补做只是验证根因。真正成熟的团队,混沌实验是 CI 流水线的常驻门禁,每个大版本发布前必跑。
总结
回到开头那个"删一个 Pod 就很稳"的团队。问题不在于他们做错了,而在于他们验证的对象错了:他们验证的是 K8s 控制器的自愈能力,而不是自己系统的韧性。
真正的混沌工程有三个硬核要求:
- 看源码:理解探针、控制器、网络栈的真实行为,才能设计出"打得中"的故障。K8s 的
onProbeResult里那个resultRun < FailureThreshold的判定,决定了你的故障窗口设计是否有效。
- 用业务稳态:用订单成功率、P99 延迟这些业务指标做断言,而不是 Pod 数量。没有断言的注入是纵火,不是工程。
- 左移进流水线:把混沌实验做成 GitOps 发布门禁,让韧性验证成为每次发布的默认动作,而不是季度演练的表演。
延伸思考:混沌工程的下一站是自适应混沌——系统根据当前 error budget 消耗速率,自动调整实验的爆炸半径和频率。当 error budget 充裕时多注入、快迭代;预算告急时自动收缩。这需要把混沌平台、SLO 系统、发布流水线三者打通,也是我目前正在探索的方向。韧性不是测出来的,是设计出来、验证出来的、持续演进出来的。