微服务混沌工程：使用 Chaos Toolkit、Chaos Monkey、Kubernetes 和 Istio 进行弹性测试

介绍

随着现代应用采用微服务、Kubernetes 和 Istio 等服务网格，确保系统弹性已成为当今云原生环境中的一项关键挑战。分布式架构引入了新的故障模式，因此需要主动进行弹性测试才能实现高可用性。混沌工程通过引入可控故障来分析系统行为并提高可靠性，使组织能够在漏洞影响生产环境之前识别并缓解这些漏洞。

对于 Java (Spring Boot) 和 Node.js 应用，Chaos Toolkit、Chaos Monkey 和基于 Istio 的故障注入提供了实现混沌工程的强大方法。此外，Kubernetes 原生的混沌实验，例如 Pod 故障、网络延迟注入和基于区域的中断，使团队能够大规模地评估系统稳定性。

本文档探讨如何在 Java、Node.js、Kubernetes 和 Istio 中实现混沌工程，重点介绍 Chaos Toolkit 和 Chaos Monkey 的安装、配置和实验执行。我们还将介绍基于 Kubernetes 和 Istio 的故障注入方法，以提高分布式应用程序和多云环境的弹性。

什么是混沌工程？

混沌工程是一门旨在通过模拟真实世界故障来主动识别分布式系统弱点的学科。其目标是通过运行受控实验来增强应用程序的弹性，从而帮助团队：

• 模拟整个区域或数据中心的故障。
• 在服务之间注入延迟。
• 将CPU 核心数用尽，以评估性能影响。
• 模拟文件系统 I/O 故障。
• 测试当依赖项不可用时应用程序的行为。
• 观察故障对微服务的连锁影响。

通过引入混沌工程实践，组织可以在弱点影响生产之前检测到它们，从而减少停机时间并提高系统恢复速度。

混沌工程生命周期

混沌工程实验的开展过程遵循一个结构化的生命周期：

图 1：混沌工程生命周期：通过持续实验来提高系统弹性的系统方法。

这种生命周期确保故障有条不紊地引入，并不断进行改进。

Chaos Toolkit 与 Chaos Monkey：主要区别

Chaos Toolkit和Chaos Monkey是混沌工程中功能强大的工具，但它们的用途各不相同。

何时使用 Chaos Toolkit？

• 在使用基于 Kubernetes 的部署时。
• 当需要进行多云或多语言混沌测试时。
• 在为分布式环境定义自定义故障场景时。

何时使用混沌猴？

• 测试Spring Boot 应用程序时。
• 当需要处理应用层故障时，例如方法级延迟和异常。
• 当需要轻量级、内置的基于 Java 的微服务解决方案时。

Chaos Toolkit：一个多功能的混沌测试框架

安装

对于 Java 和 Node.js 应用程序，请安装Chaos Toolkit CLI：

pip install chaostoolkit

集成基于 Kubernetes 的混沌测试：

pip install chaostoolkit-kubernetes

对于基于 Istio 的延迟注入：

pip install -U chaostoolkit-istio

使用Prometheus 验证应用程序健康状况：

pip install -U chaostoolkit-prometheus


Chaos Monkey for Spring Boot

下图展示了Chaos Monkey for Spring Boot如何与 Spring Boot 应用的不同组件集成，以注入故障并评估其弹性。左侧展示了典型 Spring Boot 应用的关键层，包括 @Controller、@Repository、@Service 和 @RestController，分别代表 Web 层、业务逻辑层和数据访问层。这些组件由Chaos Monkey 的监视器持续监控，包括 Controller Watcher、Repository Watcher、Service Watcher 和 RestController Watcher。这些监视器跟踪各自层内的活动，使 Chaos Monkey 能够动态地引入故障。右侧展示了可以触发的不同类型的Chaos 攻击，例如Latency Assault（在请求处理中引入人为延迟）、Exception Assault（向方法中注入随机异常）和KillApp Assault（模拟应用程序完全崩溃）。通过利用这些 Chaos 实验，团队可以验证其 Spring Boot 应用处理意外故障的能力，并提高系统弹性。该可视化有助于理解 Spring Boot 应用程序中的故障注入点，并突出 Chaos Monkey 如何在真实场景中实现容错测试。

图 2：Spring Boot 应用程序中的 Chaos Monkey：在不同层（控制器、服务、存储库）注入故障以测试弹性。

安装

将以下依赖项添加到您的 Spring Boot 项目中：

<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>chaos-monkey-spring-boot</artifactId>
    <version>2.5.4</version>
</dependency>

在 application.yml 中启用 Chaos Monkey：

spring:
  profiles:
    active: chaos-monkey
chaos:
  monkey:
    enabled: true
    assaults:
      level: 3
      latency-active: true
      latency-range-start: 2000
      latency-range-end: 5000
      exceptions-active: true
    watcher:
      controller: true
      service: true
      repository: true

在 Spring Boot 中运行 Chaos Monkey

启动应用程序时，请执行以下操作：

mvn spring-boot:run -Dspring.profiles.active=chaos-monkey

要通过Spring Boot Actuator 端点 手动启用 Chaos Monkey 攻击：

curl -X POST <http://localhost:8080/actuator/chaosmonkey/enable>

要引入延迟或例外情况，请动态配置攻击：

curl -X POST http://localhost:8080/actuator/chaosmonkey/assaults \   -H "Content-Type: application/json" \   -d '{ "latencyActive": true, "exceptionsActive": true, "level": 5 }'

Node.js 中的混沌工程：实现 Chaos Monkey 和 Chaos Toolkit

虽然Chaos Monkey for Spring Boot广泛用于 Java 应用程序，但Node.js 应用程序也可以使用Chaos Toolkit和Node 特有的库来集成混沌工程原理。

Chaos Monkey for Node.js

对于 Node.js 应用程序，可以使用第三方库来实现混沌猴子功能。最常用的库是：

Chaos Monkey for Node.js（npm 包）

Node.js 安装

要安装适用于 Node.js 的 Chaos Monkey 库：

npm install chaos-monkey --save


Node.js 应用中的基本用法

const express = require("express");
const chaosMonkey = require("chaos-monkey");
const app = express();
app.use(chaosMonkey()); // Injects random failures
app.get("/", (req, res) => {
  res.send("Hello, Chaos Monkey!");
});
app.listen(3000, () => {
  console.log("App running on port 3000");
});

这是做什么用的？

• 注入随机延迟。
• 在端点中抛出随机异常。
• 模拟网络故障。

在 Node.js 中配置 Chaos Monkey 以进行受控实验

为了更好地控制混沌注入，您可以定义特定的故障类型。

配置故障注入

修改 chaosMonkey.config.js：

module.exports = {
  latency: {
    enabled: true,
    minMs: 500,
    maxMs: 3000,
  },
  exceptions: {
    enabled: true,
    probability: 0.2, // 20% chance of exception
  },
  killProcess: {
    enabled: false, // Prevents killing the process
  },
};

现在，修改server.js文件以加载配置：

const express = require("express");
const chaosMonkey = require("chaos-monkey");
const config = require("./chaosMonkey.config");
const app = express();
app.use(chaosMonkey(config)); // Inject failures based on configuration
app.get("/", (req, res) => {
  res.send("Chaos Engineering in Node.js is running!");
});

app.listen(3000, () => {
  console.log("App running on port 3000 with Chaos Monkey");
});

适用于 Node.js 应用程序的 Chaos Toolkit

与 Kubernetes 和 Java 应用程序类似，Chaos Toolkit 可用于向 Node.js 服务注入故障。

示例：使用 Chaos Toolkit 为 Node.js 进行延迟注入

这个Chaos Toolkit 实验将为Node.js 服务引入延迟。

{
  "title": "Introduce artificial latency in Node.js service",
  "description": "Test how the Node.js API handles slow responses.",
  "method": [
    {
      "type": "action",
      "name": "introduce-latency",
      "provider": {
        "type": "process",
        "path": "curl",
        "arguments": [
          "-X",
          "POST",
          "http://localhost:3000/chaosmonkey/enable-latency"
        ]
      }
    }
  ],
  "rollbacks": [
    {
      "type": "action",
      "name": "remove-latency",
      "provider": {
        "type": "process",
        "path": "curl",
        "arguments": [
          "-X",
          "POST",
          "http://localhost:3000/chaosmonkey/disable-latency"
        ]
      }
    }
  ]
}

执行并报告实验结果：

chaos run node-latency-experiment.json --journal-path=node-latency-journal.json 

chaos report --export-format=json node-latency-journal.json > node-latency-report.json

在多云和 Kubernetes 环境中进行混沌实验

对于部署在 Kubernetes 或多云平台上的微服务，Chaos Toolkit 提供了一种更强大的方法来执行故障转移测试。

图 3：Chaos Toolkit 实验执行流程：注入故障和观察系统行为的结构化方法。

对于部署在 Kubernetes 或多云平台上的微服务，Chaos Toolkit 提供了一种更强大的方法来执行故障转移测试。

通过pod终止实验测试 Kubernetes 中的应用程序弹性：

{
  "version": "1.0.0",
  "title": "System Resilience to Pod Failures",
  "description": "Can the system survive a pod failure?",
  "configuration": {
    "app_name": { "type": "env", "key": "APP_NAME" },
    "namespace": { "type": "env", "key": "NAMESPACE" }
  },
  "steady-state-hypothesis": {
    "title": "Application must be up and healthy",
    "probes": [{
      "name": "check-application-health",
      "type": "probe",
      "provider": {
        "type": "http",
        "url": "http://myapp.com/health",
        "method": "GET"
      }
    }]
  },
  "method": [{
    "type": "action",
    "name": "terminate-pod",
    "provider": {
      "type": "python",
      "module": "chaosk8s.pod.actions",
      "func": "terminate_pods",
      "arguments": {
        "label_selector": "app=${app_name}",
        "ns": "${namespace}",
        "rand": true,
        "mode": "fixed",
        "qty": 1
      }
    }
  }]
}

运行混沌实验

要执行实验，请运行：
chaos run pod-kill-experiment.json --journal-path=pod-kill-experiment-journal.json

执行后生成报告：

chaos report --export-format=html pod-kill-experiment-journal.json > pod-kill-experiment-report.html

（如有必要）撤销实验：

chaos rollback pod-kill-experiment.json


示例：区域延迟实验（Kubernetes 和 Istio）

该实验通过修改 Istio 的虚拟服务，向请求中注入网络延迟。

version: "1.0.0"
title: "Region Delay Experiment"
description: "Simulating high latency in a specific region"
method:
  - type: action
    name: "inject-fault"
    provider:
      type: python
      module: chaosistio.fault.actions
      func: add_delay_fault
      arguments:
        virtual_service_name: "my-service-vs"
        fixed_delay: "5s"
        percentage: 100
        ns: "default"
  pauses:
    before: 5
    after: 20
rollbacks:
  - type: action
    name: "remove-fault"
    provider:
      type: python
      module: chaosistio.fault.actions
      func: remove_delay_fault
      arguments:
        virtual_service_name: "my-service-vs"
        ns: "default"

执行： 生成详细报告：图 4：多云混沌工程：使用全局负载均衡器模拟 AWS、Azure 和 GCP 上的云区域故障。
chaos run region-delay-experiment.yaml --journal-path=region-delay-journal.json


chaos report --export-format=html region-delay-journal.json > region-delay-report.html


更多混沌工具包场景

除了基本的 pod 故障和延迟注入之外，Chaos Toolkit 还可以模拟更复杂的故障场景：

• 在 Kubernetes Pod 中注入内存/CPU 压力 - 测试应用程序在高 CPU 或内存消耗下的运行情况。
• 关闭数据库实例 - 模拟数据库故障，以验证系统是否能够优雅地处理数据库中断。
• 服务间的网络分区 - 引入网络分区来分析对微服务通信的影响。
• 缩减整个服务 - 减少服务的可用副本数量，以测试自动扩展机制。
• 基于时间的故障——仅在高峰流量时段模拟故障，以观察负载下的恢复能力。

这些真实世界的场景有助于发现分布式架构中的薄弱环节，并改进恢复策略。

将混沌工程集成到 CI/CD 流水线中

为了确保弹性测试成为软件开发生命周期不可或缺的一部分，企业应在 CI/CD 流水线中自动化混沌实验。这样可以在生产部署之前以可控的方式引入故障，从而降低意外中断的风险。

为什么要将混沌测试集成到 CI/CD 中？

• 在部署过程中自动进行弹性验证。
• 在变更实施到生产环境之前，识别出性能瓶颈。
• 确保服务能够在故障后无需人工干预即可恢复。
• 通过模拟真实世界的问题来提高平均恢复时间 (MTTR) 。

CI/CD 工作流程中的混沌工程

典型的集成 CI/CD 的混沌测试工作流程遵循以下步骤：

• 开发者提交代码→ 代码更改被推送到代码仓库。
• CI/CD 流水线触发构建和部署→ 应用程序被构建并部署到 Kubernetes。
• 运行混沌实验→ 部署后执行自动化混沌测试。
• 可观测性和监控→ Prometheus、Datadog 和日志收集系统行为指标。
• 验证系统弹性→ 如果服务健康检查通过，则部署继续进行。
• 必要时回滚→ 如果系统未能达到弹性阈值，则会触发自动回滚。

图 5：将混沌工程集成到 CI/CD 中：使用 Kubernetes 和 Istio 实现弹性测试自动化。

示例：在 GitHub Actions 中自动化混沌测试

以下示例展示了如何在GitHub Actions CI/CD 流水线中自动化 Chaos Toolkit 实验：

name: Chaos Testing Pipeline
on:
  push:
    branches:
      - main
jobs:
  chaos-test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Code
        uses: actions/checkout@v2
      - name: Install Chaos Toolkit
        run: pip install chaostoolkit
      - name: Run Chaos Experiment
        run: chaos run pod-kill-experiment.json
      - name: Validate Recovery
        run: curl -f http://myapp.com/health || exit 1

关键步骤详解：

• 该流水线会在代码推送事件发生时触发。
• Chaos Toolkit是动态安装的。
• pod-kill 实验是在已部署的应用程序上执行的。
• 健康检查可确保应用程序从故障中恢复。
• 如果健康检查失败，管道将停止部署，以避免发布不稳定的代码。

混沌实验运行后的结果验证

执行混沌实验后，验证系统性能至关重要。混沌报告命令会生成详细的实验报告：如何分析结果？
chaos report --export-format=html /app/reports/chaos_experiment_journal.json /app/reports/chaos_experiment_summary.html


• 如果系统保持稳定状态→ 该服务具有弹性。
• 如果检测到异常情况→ 应使用日志、监控工具和警报机制进行调试。
• 如果发生故障级联→ 调整服务设计、引入断路器或优化自动扩展策略。

运行混沌实验的最佳实践

1. 从稳态假设开始 →在引入混沌之前，定义一个“健康”的系统是什么样子。
2. 从低级别故障开始 →先从 100 毫秒的延迟注入开始，然后再增加故障严重程度。
3. 监控系统指标 →使用 Grafana 和 Prometheus 仪表板跟踪故障影响。
4. 启用自动回滚 →确保实验结束后自动回滚失败结果。
5. 逐步提高混乱程度 →在引入大规模故障之前，先使用可控的混乱。

结论

混沌工程是当今云原生、Kubernetes 和服务网格环境中的一项关键实践。无论您使用的是Java（Spring Boot）、Node.js、Kubernetes 还是 Istio，您都可以利用以下优势：

• Chaos Monkey为 Spring Boot 应用程序提供轻量级故障注入。
• Chaos Toolkit适用于Kubernetes、Istio 和多​​云环境中的复杂故障场景。
• Kubernetes 和 Istio 混沌实验，用于验证故障转移策略、延迟处理和 pod 弹性。
• 基于服务网格的网络中断，用于模拟跨区域和集群内故障。

通过在应用层、网络层和基础设施层系统性地注入故障，团队可以主动提升系统弹性。Kubernetes 和 Istio 提供了强大的工具，用于注入延迟、网络中断和 Pod 故障，从而评估服务稳定性。将混沌工程集成到 CI/CD 流水线中，可确保跨多云部署的自动化弹性测试。

后续步骤

• 将Chaos Monkey 和 Chaos Toolkit集成到您的开发工作流程中。
• 使用CI/CD 流水线（GitHub Actions、Jenkins、Azure Devops）自动执行混沌实验。
• 探索 Kubernetes 原生故障注入技术。
• 使用Istio 流量管理来验证多区域和网络容错能力。

通过将混沌工程作为一门持续的学科来应用，组织可以构建容错性强、高可用性的系统，从而抵御生产中发生的意外故障。

快乐的混沌工程！

参考

要进一步了解混沌工程的原理、工具和最佳实践，请参考以下资源：

• 混沌工程原理——对混沌工程的核心原理和方法进行详细解释。
• Chaos Monkey for Spring Boot 文档– 为 Spring Boot 应用程序实现 Chaos Monkey 的指南。
• Spring Boot Actuator 参考文档– Spring Boot Actuator 的官方文档，用于 Chaos Monkey 实验。
• Chaos Monkey for Node.js (NPM 包) – 用于注入故障的 Node.js 库。
• Chaos Toolkit 官方文档– Chaos Toolkit 安装和使用官方指南。
• Chaos Toolkit GitHub 仓库– Chaos Toolkit 的源代码和贡献。
• Chaos Toolkit Kubernetes 集成 – Kubernetes 集群故障注入指南。

原文发表于https://dzone.com。