标签：load 混沌 -- ChaosBlade create blade experiment 测试 chaosblade

700914220

ChaosBlade: 一个简单易用且功能强大的混沌实验实施工具

官方仓库：https://github.com/chaosblade-io/chaosblade

1. 项目介绍

ChaosBlade 是阿里巴巴开源的一款遵循混沌工程原理和混沌实验模型的实验注入工具，帮助企业提升分布式系统的容错能力，并且在企业上云或往云原生系统迁移过程中业务连续性保障。

Chaosblade 是内部 MonkeyKing 对外开源的项目，其建立在阿里巴巴近十年故障测试和演练实践基础上，结合了集团各业务的最佳创意和实践。

ChaosBlade 不仅使用简单，而且支持丰富的实验场景，场景包括：

基础资源：比如 CPU、内存、网络、磁盘、进程等实验场景；
Java 应用：比如数据库、缓存、消息、JVM 本身、微服务等，还可以指定任意类方法注入各种复杂的实验场景；
C++ 应用：比如指定任意方法或某行代码注入延迟、变量和返回值篡改等实验场景；
Docker 容器：比如杀容器、容器内 CPU、内存、网络、磁盘、进程等实验场景；
云原生平台：比如 Kubernetes 平台节点上 CPU、内存、网络、磁盘、进程实验场景，Pod 网络和 Pod 本身实验场景如杀 Pod，容器的实验场景如上述的 Docker 容器实验场景；

将场景按领域实现封装成一个个单独的项目，不仅可以使领域内场景标准化实现，而且非常方便场景水平和垂直扩展，通过遵循混沌实验模型，实现 chaosblade cli 统一调用。目前包含的项目如下：

chaosblade：混沌实验管理工具，包含创建实验、销毁实验、查询实验、实验环境准备、实验环境撤销等命令，是混沌实验的执行工具，执行方式包含 CLI 和 HTTP 两种。提供完善的命令、实验场景、场景参数说明，操作简洁清晰。
chaosblade-spec-go: 混沌实验模型 Golang 语言定义，便于使用 Golang 语言实现的场景都基于此规范便捷实现。
chaosblade-exec-os: 基础资源实验场景实现。
chaosblade-exec-docker: Docker 容器实验场景实现，通过调用 Docker API 标准化实现。
chaosblade-exec-cri: 容器实验场景实现，通过调用 CRI 标准化实现。
chaosblade-operator: Kubernetes 平台实验场景实现，将混沌实验通过 Kubernetes 标准的 CRD 方式定义，很方便的使用 Kubernetes 资源操作的方式来创建、更新、删除实验场景，包括使用 kubectl、client-go 等方式执行，而且还可以使用上述的 chaosblade cli 工具执行。
chaosblade-exec-jvm: Java 应用实验场景实现，使用 Java Agent 技术动态挂载，无需任何接入，零成本使用，而且支持卸载，完全回收 Agent 创建的各种资源。
chaosblade-exec-cplus: C++ 应用实验场景实现，使用 GDB 技术实现方法、代码行级别的实验场景注入。

2. 使用文档

你可以从 Releases 地址下载最新的 chaosblade 工具包，解压即用。如果想注入 Kubernetes 相关故障场景，需要安装 chaosblade-operator，详细的中文使用文档请查看 chaosblade-help-zh-cn。

chaosblade 支持 CLI 和 HTTP 两种调用方式，支持的命令如下：

prepare：简写 p，混沌实验前的准备，比如演练 Java 应用，则需要挂载 java agent。例如要演练的应用名是 business，则在目标主机上执行 blade p jvm --process business。如果挂载成功，返回挂载的 uid，用于状态查询或者撤销挂载。
revoke：简写 r，撤销之前混沌实验准备，比如卸载 java agent。命令是 blade revoke UID
create: 简写是 c，创建一个混沌演练实验，指执行故障注入。命令是 blade create [TARGET] [ACTION] [FLAGS]，比如实施一次 Dubbo consumer 调用 xxx.xxx.Service 接口延迟 3s，则执行的命令为 blade create dubbo delay --consumer --time 3000 --service xxx.xxx.Service，如果注入成功，则返回实验的 uid，用于状态查询和销毁此实验使用。
destroy：简写是 d，销毁之前的混沌实验，比如销毁上面提到的 Dubbo 延迟实验，命令是 blade destroy UID
status：简写 s，查询准备阶段或者实验的状态，命令是 blade status UID 或者 blade status --type create
server：启动 web server，暴露 HTTP 服务，可以通过 HTTP 请求来调用 chaosblade。例如在目标机器xxxx上执行：blade server start -p 9526，执行 CPU 满载实验：curl "http:/xxxx:9526/chaosblade?cmd=create%20cpu%20fullload"

以上命令帮助均可使用 blade help [COMMAND] 或者 blade [COMMAND] -h 查看，也可查看新手指南，或者上述中文使用文档，快速上手使用。

3. 安装

可以选择编译安装或者使用容器镜像

3.1 主机安装

访问chaosblade下载最新版本的安装包并解压到系统path路径，目前仅支持X86架构。

3.2 容器安装运行

docker pull chaosbladeio/chaosblade-demodocker pull chaosbladeio/chaosblade-demo
docker run -it --privileged chaosbladeio/chaosblade-demo
# 进入镜像之后，可阅读 README.txt 文件实施混沌实验
bash-4.4# ls
README.txt  bin         blade       lib

3.3 k8s安装

helm repo add chaosblade-io https://chaosblade-io.github.io/charts
helm install chaosblade chaosblade-io/chaosblade-operator --namespace chaosblade
# 默认的镜像仓库是`ghcr.io/chaosblade-io/chaosblade-tool` and `ghcr.io/chaosblade-io/chaosblade-operator`, 增加参数`--set blade.repository` 或者 `--set operator.repository` 修改镜像仓库，例如下:
helm install chaosblade-operator chaosblade-io/chaosblade-operator --namespace chaosblade --set blade.repository=chaosbladeio/chaosblade-tool,operator.repository=chaosbladeio/chaosblade-operator 

# 卸载
helm uninstall chaosblade-operator --namespace chaosblade

3.4 编译安装

此项目采用 golang 语言编写，所以需要先安装最新的 golang 版本，最低支持的版本是 1.11。Clone 工程后进入项目目录执行以下命令进行编译：

# 下载项目
https://github.com/chaosblade-io/chaosblade.git
# 编译安装，默认会安装全部测试场景
cd chaosblade
make build

如果在 mac 系统上，编译当前系统的版本，请执行：

make build_darwin

如果想在 mac 系统上，编译 linux 系统版本，请执行：

make build_linux

也可以选择性编译，比如只需要编译 cli、os 场景，则执行：

make build_with cli os
# 如果是 mac 系统，执行
make build_with cli os_darwin
# 如果是 mac 系统，想选择性的编译 linux 版本的 cli，os，则执行：
ARGS="cli os" make build_with_linux

Arch Linux 安装 chaosblade-bin

yay -S chaosblade-bin

4. 实践测试

4.1 帮助文档

 ./blade --help
An easy to use and powerful chaos engineering experiment toolkit

Usage:
  blade [command]

Available Commands:
  check       Check the environment for chaosblade
  create      Create a chaos engineering experiment
  destroy     Destroy a chaos experiment
  help        Help about any command
  prepare     Prepare to experiment
  query       Query the parameter values required for chaos experiments
  revoke      Undo chaos engineering experiment preparation
  status      Query preparation stage or experiment status
  version     Print version info

Flags:
  -d, --debug   Set client to DEBUG mode
  -h, --help    help for blade

支持构造的试验场景，从下面的命令输出可以看到支持C++、CPU、磁盘、容器、dubbo、http、jvm、k8s、mysql、网络、进程、mq、脚本、java servlet等场景或组件的测试试验。

# ./blade create --help
Create a chaos engineering experiment

Usage:
  blade create [command]

Aliases:
  create, c

Examples:
blade create cpu load --cpu-percent 60

Available Commands:
  aliyun      Aliyun experiment
  aws         Aws experiment
  ck          Clickhouse experiment
  cpu         Cpu experiment
  cri         CRI experiment
  disk        Disk experiment
  druid       Experiment with the Druid
  dubbo       Experiment with the Dubbo
  es          ElasticSearch experiment!
  feign       feign experiment
  file        File experiment
  gateway     gateway experiment!
  hbase       hbase experiment!
  http        http experiment
  jedis       jedis experiment
  jvm         Experiment with the JVM
  k8s         Kubernetes experiment
  kafka       kafka experiment
  lettuce     redis client lettuce experiment
  log         log experiment
  mem         Mem experiment
  mongodb     MongoDB experiment
  mysql       mysql experiment
  network     Network experiment
  nginx       Nginx experiment
  process     Process experiment
  psql        Postgrelsql experiment
  rabbitmq    rabbitmq experiment
  redis       Redis experiment
  redisson    redisson experiment
  rocketmq    Rocketmq experiment,can make message send or pull delay and exception
  script      Script chaos experiment
  security    SpringSecurity login experiment
  servlet     java servlet experiment
  strace      strace experiment
  systemd     Systemd experiment
  tars        tars experiment
  time        Time experiment
  zk          zk experiment

Flags:
  -a, --async             whether to create asynchronously, default is false
  -e, --endpoint string   the create result reporting address. It takes effect only when the async value is true and the value is not empty
  -h, --help              help for create
  -n, --nohup             used to internal async create, no need to config
      --uid string        Set Uid for the experiment, adapt to docker and cri

Global Flags:
  -d, --debug   Set client to DEBUG mode

Use "blade create [command] --help" for more information about a command.

备注

二进制主机版本的功能较容器形态的功能较丰富，建议使用二进制版本。

4.2 测试案例

部分测试案例总结如下。

jvm异常测试

# 运行容器
docker run -it --privileged chaosbladeio/chaosblade-demo
# 容器中运行了一个dubbo示例程序，执行如下命令可以看到程序的功能
bash-4.4# curl http://localhost:8080/dubbo/hello?name=dubbo
Hello dubbo, response from provider: 172.17.0.2:20880
bash-4.4# netstat -tulnp
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 :::20880                :::*                    LISTEN      16/java
tcp        0      0 :::8080                 :::*                    LISTEN      16/java
tcp        0      0 ::ffff:127.0.0.1:8005   :::*                    LISTEN      16/java
tcp        0      0 :::8009                 :::*                    LISTEN      16/java

# 进行混沌测试，准备一个java程序试验环境
bash-4.4# blade prepare jvm --process business
{"code":200,"success":true,"result":"400019538151a8cf"}
bash-4.4#  blade status --type prepare
{
        "code": 200,
        "success": true,
        "result": [
                {
                        "Uid": "400019538151a8cf",
                        "ProgramType": "jvm",
                        "Process": "business",
                        "Port": "44587",
                        "Status": "Running",
                        "Error": "",
                        "CreateTime": "2024-05-31T12:45:46.620634205Z",
                        "UpdateTime": "2024-05-31T12:45:56.864110741Z"
                }
        ]
}

# 构造一个延迟场景。当调用com.example.service.DemoService的sayHello方法时，延迟3s。
bash-4.4# blade create dubbo delay --time 3000 --service com.example.service.DemoService --methodname sayHello --consumer
{"code":200,"success":true,"result":"e3861cc4b4bca049"}
# 再次执行curl调用接口，查看效果
bash-4.4# curl http://localhost:8080/dubbo/hello?name=dubbo
chaosblade-mock-TimeoutException,timeout=1000
# 删除构造的延迟3秒的故障
bash-4.4# blade destroy e3861cc4b4bca049
{"code":200,"success":true,"result":"command: dubbo delay --consumer true --help false --service com.example.service.DemoService --provider false --debug false --methodname sayHello --time 3000"}
bash-4.4# curl http://localhost:8080/dubbo/hello?name=dubbo
Hello dubbo, response from provider: 172.17.0.2:20880
# 使用status命令查询试验的状态
bash-4.4# blade status --type create
{
        "code": 200,
        "success": true,
        "result": [
                {
                        "Uid": "e3861cc4b4bca049",
                        "Command": "dubbo",
                        "SubCommand": "delay",
                        "Flag": "--consumer true --help false --service com.example.service.DemoService --provider false --debug false --methodname sayHello --time 3000",
                        "Status": "Destroyed",
                        "Error": "",
                        "CreateTime": "2024-05-31T12:28:48.91064256Z",
                        "UpdateTime": "2024-05-31T12:31:01.99721936Z"
                }
        ]
}

# 或者使用blade s <UID>查看

# 构造一个当调用服务时，异常抛出的场景
bash-4.4# blade create jvm throwCustomException --exception java.lang.Exception \
>     --classname com.example.controller.DubboController --methodname hello
{"code":200,"success":true,"result":"44fead600e3c2579"}
bash-4.4# blade status 44fead600e3c2579
{
        "code": 200,
        "success": true,
        "result": {
                "Uid": "44fead600e3c2579",
                "Command": "jvm",
                "SubCommand": "throwCustomException",
                "Flag": "--exception java.lang.Exception --help false --methodname hello --classname com.example.controller.DubboController --debug false",
                "Status": "Success",
                "Error": "",
                "CreateTime": "2024-05-31T12:35:22.602827497Z",
                "UpdateTime": "2024-05-31T12:35:23.010550446Z"
        }
}
bash-4.4# curl http://localhost:8080/dubbo/hello?name=dubbo
...
Request processing failed; nested exception is java.lang.Exception: chaosblade-mock-exception
...
# 删除构造的异常后，调用恢复正常。

cpu加压测试

使用指导：

# ./blade create cpu load --help
Create chaos engineering experiments with CPU load

Usage:
  blade create cpu fullload

Aliases:
  fullload, fl, load

Examples:

# Create a CPU full load experiment
blade create cpu load

#Specifies two random core's full load
blade create cpu load --cpu-percent 60 --cpu-count 2

# Specifies that the core is full load with index 0, 3, and that the core's index starts at 0
blade create cpu load --cpu-list 0,3

# Specify the core full load of indexes 1-3
blade create cpu load --cpu-list 1-3

# Specified percentage load
blade create cpu load --cpu-percent 60

Flags:
      --blade-release string     Blade release package，use this flag when the channel is ssh
      --cgroup-root string       cgroup root path, default value /sys/fs/cgroup
      --channel string           Select the channel for execution, and you can now select SSH
      --climb-time string        durations(s) to climb
      --cpu-count string         Cpu count
      --cpu-index string         cpu index, user unavailable!
      --cpu-list string          CPUs in which to allow burning (0-3 or 1,3)
      --cpu-percent string       percent of burn CPU (0-100)
  -h, --help                     help for fullload
      --install-path string      install path default /opt/chaosblade，use this flag when the channel is ssh
      --override-blade-release   Override blade release，use this flag when the channel is ssh
      --ssh-host string          Use this flag when the channel is ssh
      --ssh-key string           Use this flag when the channel is ssh
      --ssh-key-passphrase       Use this flag when the channel is ssh
      --ssh-port string          Use this flag when the channel is ssh
      --ssh-user string          Use this flag when the channel is ssh
      --timeout string           set timeout for experiment

Global Flags:
  -a, --async             whether to create asynchronously, default is false
  -d, --debug             Set client to DEBUG mode
  -e, --endpoint string   the create result reporting address. It takes effect only when the async value is true and the value is not empty
  -n, --nohup             used to internal async create, no need to config
      --uid string        Set Uid for the experiment, adapt to docker and cri

cpu加压测试，使cpu满负荷运行60秒：

./blade create cpu load --cpu-percent 100 --timeout 60

内存加压测试

使用指导：

./blade create mem load --help
Create chaos engineering experiments with memory load

Usage:
  blade create mem load

Examples:

# The execution memory footprint is 50%
blade create mem load --mode ram --mem-percent 50

# The execution memory footprint is 50%, cache model
blade create mem load --mode cache --mem-percent 50

# The execution memory footprint is 50%, usage contains buffer/cache
blade create mem load --mode ram --mem-percent 50 --include-buffer-cache

# The execution memory footprint is 50%, avoid mem-burn process being killed
blade create mem load --mode ram --mem-percent 50 --avoid-being-killed

# The execution memory footprint is 50% for 200 seconds
blade create mem load --mode ram --mem-percent 50 --timeout 200

# 200M memory is reserved
blade create mem load --mode ram --reserve 200 --rate 100

构造内存100%测试，持续60s，执行如下命令后，使用free -m查看系统内存：

blade create mem load --mode ram --mem-percent 100 --timeout 60

磁盘加压测试

支持磁盘负载加压，及空间填充测试。可以使用下面命令查看具体参数：

# IO负载加压
./blade create disk burn  --help
Increase disk read and write io load

Usage:
  blade create disk burn

Examples:

# The data of rkB/s, wkB/s and % Util were mainly observed. Perform disk read IO high-load scenarios
blade create disk burn --read --path /home

# Perform disk write IO high-load scenarios
blade create disk burn --write --path /home

# Read and write IO load scenarios are performed at the same time. Path is not specified. The default is /
blade create disk burn --read --write
...

# 空间填充测试
./blade create disk  fill --help
Fill the specified directory path. If the path is not directory or does not exist, an error message will be returned.

Usage:
  blade create disk fill

Examples:

# Perform a disk fill of 40G to achieve a full disk (34G available)
blade create disk fill --path /home --size 40000

# Performs populating the disk by percentage, and retains the file handle that populates the disk
Command: "blade c disk fill --path /home --percent 80 --retain-handle

# Perform a fixed-size experimental scenario
blade c disk fill --path /home --reserve 1024
...

5. 面向云原生

chaosblade-operator 项目是针对云原生平台所实现的混沌实验注入工具，遵循混沌实验模型规范化实验场景，把实验定义为 Kubernetes CRD 资源，将实验模型映射为 Kubernetes 资源属性，很友好地将混沌实验模型与 Kubernetes 声明式设计结合在一起，在依靠混沌实验模型便捷开发场景的同时，又可以很好的结合 Kubernetes 设计理念，通过 kubectl 或者编写代码直接调用 Kubernetes API 来创建、更新、删除混沌实验，而且资源状态可以非常清晰地表示实验的执行状态，标准化实现 Kubernetes 故障注入。除了使用上述方式执行实验外，还可以使用 chaosblade cli 方式非常方便的执行 kubernetes 实验场景，查询实验状态等。具体请阅读：云原生下的混沌工程实践

6. 场景大图

experiments landscape

7. 项目生态

ecosystem

更详细的功能及最新信息请访问官方仓库查看。

标签：load,混沌,--,ChaosBlade,create,blade,experiment,测试,chaosblade
From： https://www.cnblogs.com/lldhsds/p/18224532

ChaosBlade混沌测试实践