混沌工程：通过可控故障实验提升软件系统可靠性

图书标准信息

• 作者 [波兰]米科拉吉·帕利科夫斯基 著
• 出版社 机械工业出版社
• 出版时间 2023-02
• 版次 1
• ISBN 9787111716624
• 定价 129.00元
• 装帧 其他
• 开本 16开
• 纸张 胶版纸
• 页数 364页
• 字数 490千字

【内容简介】

混沌工程是一种有意的实验实践，旨在发现系统性问题。在本书中，我们将探讨为什么、何时以及如何应用混沌工程来改善你的计算机系统。你将学习通过一系列模拟真实故障的测试来运行应用程序和基础设施。通过学习像混沌工程师一样思考，以及学习设计适当的实验来确保软件的可靠性，你将掌握混沌工程的理论与技术，并将其应用于实际的系统中。

【作者简介】

章进入混沌工程的世界1

1.1什么是混沌工程2

1.2混沌工程的动机3

1.2.1评估风险和成本，并设定sli、slo和sla3

1.2.2在整体上测试系统4

1.2.3找到“涌现”特5

1.3混沌工程的四个步骤5

1.3.1确保可观测7

1.3.2定义稳态8

1.3.3形成设9

1.3.4运行实验并证明（或反驳）你的设9

1.4什么不是混沌工程10

1.5初识混沌工程11

1.5.1fizzbuzz即服务11

1.5.2漫漫长夜11

1.5.3后续12

1.5.4混沌工程简述13

结13

部分混沌工程基础

第2章来碗混沌与爆炸半径17

2.1设置使用本书中的代码17

2.2场景18

2.3linux10120

2.3.1退出码20

2.3.2终止进程21

2.3.3内存溢出杀手23

2.4个混沌实验25

2.4.1确保可观测29

2.4.2定义稳态29

2.4.3形成设30

2.4.4运行实验30

2.5爆炸半径31

2.6深入挖掘33

2.6.1拯救世界35

结36

第3章可观测38

3.1应用程序运行缓慢39

3.2use方法39

3.3资源41

3.3.1系统概述43

3.3.2blocki/o44

3.3.3网络48

3.3.4ram52

3.3.5cpu59

3.3.6作系统65

3.4应用程序67

3.4.1cprofile68

3.4.2bcc和python69

3.5自动化：使用时序数据库71

3.5.1prometheus和grafana71

3.6延伸阅读74

结75

第4章数据库故障和生产环境中的测试76

4.1我们在做wordpress76

4.2弱点78

4.2.1实验1：磁盘慢了79

4.2.2实验2：网络慢了83

4.3在生产环境中测试88

结90

第二部分混沌工程实战

第5章剖析docker93

5.1我的（docker化的）应用程序运行缓慢94

5.1.1架构94

5.2docker简史95

5.2.1、模拟和虚拟化95

5.2.2vm和容器97

5.3linux容器和docker99

5.4docker102

5.4.1使用chroot变更进程的路径102

5.4.2实现一个简单的容器（-ish）

部分：使用chroot105

5.4.3实验1：一个容器可以阻止另一个容器写磁盘吗107

5.4.4使用linux命名空间隔离进程111

5.4.5docker和命名空间114

5.5实验2：终止其他pid命名空间中的进程116

5.5.1实现一个简单的容器（-ish）

第2部分：命名空间118

5.5.2使用cgrou进程的资源使用120

5.6实验3：使用你能找到的所有cpu126

5.7实验4：使用过多内存128

5.7.1实现一个简单的容器（-ish）

第3部分：cgrou130

5.8docker和网络133

5.8.1capabilities和secp137

5.9docker揭秘140

5.10修复我的（docker化的）应用程序运行缓慢的问题141

5.10.1启动meower141

5.10.2为什么应用程序运行缓慢143

5.11实验5：使用pumba让容器的网络变慢143

5.11.1pumba：docker混沌工程工具143

5.11.2运行混沌实验144

5.12其他主题147

5.12.1dockerdaemon重启148

5.12.2镜像layer的存储148

5.12.3网络148

5.12.4安全149

结149

第6章你要调用谁？系统调用破坏者150

6.1场景：恭喜你升职了150

6.1.1systemx：如果大家都在用，但没人维护，是不是废弃软件151

6.2简单回顾系统调用153

6.2.1了解系统调用154

6.2.2使用标准c库和glibc156

6.3如何观测进程的系统调用158

6.3.1strace和sleep158

6.3.2strace和systemx161

6.3.3strace的问题：开销162

6.3.4bpf163

6.3.5其他选择166

6.4为乐趣和收益阻塞系统调用

部分：strace167

6.4.1实验1：破坏close系统调用167

6.4.2实验2：破坏write系统调用171

6.5为乐趣和收益阻塞系统调用

第2部分：secp173

6.5.1secp的简单方法：使用docker173

6.5.2secp的困难方法：使用libsecp175

结177

第7章jvm故障注入178

7.1场景178

7.1.1fizzbuzzenterpriseedition介绍179

7.1.2环顾fizzbuzzenterprise-edition179

7.2混沌工程和java180

7.2.1实验的思路181

7.2.2实验的计划182

7.2.3jvm字节码简介183

7.2.4实验的实现190

7.3已有的工具196

7.3.1byteman196

7.3.2byte-monkey198

7.3.3springboot的chaosmonkey200

7.4延伸阅读200

结201

第8章应用级故障注入202

8.1场景202

8.1.1实现细节：混沌之前204

8.2实验1：redis延迟208

8.2.1实验1的计划209

8.2.2实验1的稳态209

8.2.3实验1的实现210

8.2.4实验1的执行212

8.2.5实验1的讨论213

8.3实验2：失败的请求213

8.3.1实验2的计划214

8.3.2实验2的实现214

8.3.3实验2的执行215

8.4应用程序与基础设施216

结217

第9章我的浏览器中有一只“猴子”218

9.1场景218

9.1.1pgweb219

9.1.2pgweb实现细节220

9.2实验1：增加延迟222

9.2.1实验1的计划223

9.2.2实验1的稳态223

9.2.3实验1的实现224

9.2.4实验1的执行226

9.3实验2：添加故障227

9.3.1实验2的实现227

9.3.2实验2的执行229

9.4其他好知道的话题229

9.4.1fetchapi229

9.4.2throttling230

9.4.3工具：greasemonkey和tampermonkey232

结232

第三部分kuberes中的混沌工程

0章kuberes中的混沌235

10.1将东西移植到kuberes236

10.1.1high-profile项目文档237

10.1.2goldpinger是什么237

10.2kuberes是什么238

10.2.1kuberes简史238

10.2.2kuberes能为你做什么239

10.3搭建kuberes集群241

10.3.1使用minikube241

10.3.2启动一个集群241

10.4测试运行在kuberes上的软件243

10.4.1运行icant项目243

10.4.2实验1：终止50%的pod251

10.4.3派对：时尚地终止pod256

10.4.4实验2：引入网络缓慢257

结267

1章自动化kuberes实验268

11.1使用powerfulseal自动化混沌268

11.1.1powerfulseal是什么269

11.1.2安装powerfulseal270

11.1.3实验1b：终止50%的pod271

11.1.4实验2b：引入网络缓慢273

11.2持续测试和服务水准目标276

11.2.1实验3：验证pod在创建后几秒内是否准备绪277

11.3云层282

11.3.1云提供商api、可用区282

11.3.2实验4：关闭vm284

结286

2章kuberes底层工作287

12.1kuberes集群剖析以及如何破坏它287

12.1.1控制面288

12.1.2kubelet和pause容器295

12.1.3kuberes、docker以及容器运行时297

12.1.4kuberes网络300

12.2关键组件结304

结304

3章混沌工程与人305

13.1混沌工程思维305

13.1.1故障不是一种可能：它会发生306

13.1.2早失败与晚失败307

13.2获得支持308

13.2.1经理308

13.2.2团队成员309

13.2.3游戏309

13.3将团队当成分布式系统310

13.3.1查找知识单点故障：宅度312

13.3.2团队的错误信息和信任313

13.3.3团队中的瓶颈：慢车道上的生活313

13.3.4测试你的流程：工作314

结315

附录

附录a安装混沌工程工具318

附录b突击测验325

附录c导演剪辑333

附录d混沌工程食谱337

后记343

【目录】

推荐序一

推荐序二

译者序

序言一

序言二

前言

致谢

作者简介

第1章　进入混沌工程的世界　1

1.1　什么是混沌工程　2

1.2　混沌工程的动机　3

1.2.1　评估风险和成本，并设定SLI、SLO和SLA　3

1.2.2　在整体上测试系统　4

1.2.3　找到“涌现性”特性　5

1.3　混沌工程的四个步骤　5

1.3.1　确保可观测性　7

1.3.2　定义稳态　8

1.3.3　形成假设　9

1.3.4　运行实验并证明（或反驳）

你的假设　9

1.4　什么不是混沌工程　10

1.5　初识混沌工程　11

1.5.1　FizzBuzz即服务　11

1.5.2　漫漫长夜　11

1.5.3　后续　12

1.5.4　混沌工程简述　13

总结　13

第一部分　混沌工程基础

第2章　来碗混沌与爆炸半径　17

2.1　设置使用本书中的代码　17

2.2　场景　18

2.3　Linux取证101　20

2.3.1　退出码　20

2.3.2　终止进程　21

2.3.3　内存溢出杀手　23

2.4　第一个混沌实验　25

2.4.1　确保可观测性　29

2.4.2　定义稳态　29

2.4.3　形成假设　30

2.4.4　运行实验　30

2.5　爆炸半径　31

2.6　深入挖掘　33

2.6.1　拯救世界　35

总结　36

第3章　可观测性　38

3.1　应用程序运行缓慢　39

3.2　USE方法　39

3.3　资源　41

3.3.1　系统概述　43

3.3.2　block I/O　44

3.3.3　网络　48

3.3.4　RAM　52

3.3.5　CPU　59

3.3.6　操作系统　65

3.4　应用程序　67

3.4.1　cProfile　68

3.4.2　BCC和Python　69

3.5　自动化：使用时序数据库　71

3.5.1　Prometheus和Grafana　71

3.6　延伸阅读　74

总结　75

第4章　数据库故障和生产环境中的

测试　76

4.1　我们在做WordPress　76

4.2　弱点　78

4.2.1　实验1：磁盘慢了　79

4.2.2　实验2：网络慢了　83

4.3　在生产环境中测试　88

总结　90

第二部分　混沌工程实战

第5章　剖析Docker　93

5.1　我的（Docker化的）应用程序

运行缓慢　94

5.1.1　架构　94

5.2　Docker简史　95

5.2.1　仿真、模拟和虚拟化　95

5.2.2　VM和容器　97

5.3　Linux容器和Docker　99

5.4　Docker原理　102

5.4.1　使用chroot变更进程的

路径　102

5.4.2　实现一个简单的容器（-ish）

第1部分：使用chroot　105

5.4.3　实验 1：一个容器可以阻止

另一个容器写磁盘吗　107

5.4.4　使用Linux命名空间隔离

进程　111

5.4.5　Docker和命名空间　114

5.5　实验2：终止其他PID命名空间

中的进程　116

5.5.1　实现一个简单的容器（-ish）

第2部分：命名空间　118

5.5.2　使用cgroups限制进程的资源

使用　120

5.6　实验3：使用你能找到的所有

CPU　126

5.7　实验4：使用过多内存　128

5.7.1　实现一个简单的容器（-ish）

第 3 部分：cgroups　130

5.8　Docker和网络　133

5.8.1　capabilities和seccomp　137

5.9　Docker揭秘　140

5.10　修复我的（Docker化的）应用

程序运行缓慢的问题　141

5.10.1　启动Meower　141

5.10.2　为什么应用程序运行缓慢　143

5.11　实验5：使用Pumba让容器的

网络变慢　143

5.11.1　Pumba：Docker混沌工程

工具　143

5.11.2　运行混沌实验　144

5.12　其他主题　147

5.12.1　Docker daemon重启　148

5.12.2　镜像layer的存储　148

5.12.3　高级网络　148

5.12.4　安全　149

总结　149

第6章　你要调用谁？系统调用

破坏者　150

6.1　场景：恭喜你升职了　150

6.1.1　System X：如果大家都在

用，但没人维护，是不是

废弃软件　151

6.2　简单回顾系统调用　153

6.2.1　了解系统调用　154

6.2.2　使用标准C库和glibc　156

6.3　如何观测进程的系统调用　158

6.3.1　strace和sleep　158

6.3.2　strace和System X　161

6.3.3　strace的问题：开销　162

6.3.4　BPF　163

6.3.5　其他选择　166

6.4　为乐趣和收益阻塞系统调用

第1部分：strace　167

6.4.1　实验1：破坏close系统

调用　167

6.4.2　实验2：破坏write系统

调用　171

6.5　为乐趣和收益阻塞系统调用

第2部分：seccomp　173

6.5.1　seccomp 的简单方法：使用Docker　173

6.5.2　seccomp 的困难方法：使用libseccomp　175

总结　177

第7章　JVM故障注入　178

7.1　场景　178

7.1.1　FizzBuzzEnterpriseEdition 

介绍　179

7.1.2　环顾FizzBuzzEnterprise-

Edition　179

7.2　混沌工程和Java　180

7.2.1　实验的思路　181

7.2.2　实验的计划　182

7.2.3　JVM字节码简介　183

7.2.4　实验的实现　190

7.3　已有的工具　196

7.3.1　Byteman　196

7.3.2　Byte-Monkey　198

7.3.3　Spring Boot的Chaos 

Monkey　200

7.4　延伸阅读　200

总结　201

第8章　应用级故障注入　202

8.1　场景　202

8.1.1　实现细节：混沌之前　204

8.2　实验1：Redis延迟　208

8.2.1　实验1的计划　209

8.2.2　实验1的稳态　209

8.2.3　实验1的实现　210

8.2.4　实验1的执行　212

8.2.5　实验1的讨论　213

8.3　实验2：失败的请求　213

8.3.1　实验2的计划　214

8.3.2　实验2的实现　214

8.3.3　实验2的执行　215

8.4　应用程序与基础设施　216

总结　217

第9章　我的浏览器中有一只“猴子”　218

9.1　场景　218

9.1.1　Pgweb　219

9.1.2　Pgweb实现细节　220

9.2　实验1：增加延迟　222

9.2.1　实验1的计划　223

9.2.2　实验1的稳态　223

9.2.3　实验1的实现　224

9.2.4　实验1的执行　226

9.3　实验2：添加故障　227

9.3.1　实验2的实现　227

9.3.2　实验2的执行　229

9.4　其他好知道的话题　229

9.4.1　Fetch API　229

9.4.2　Throttling　230

9.4.3　工具：Greasemonkey和Tampermonkey　232

总结　232

第三部分　Kubernetes中的混沌工程

第10章　Kubernetes中的混沌　235

10.1　将东西移植到Kubernetes　236

10.1.1　High-Profile 项目文档　237

10.1.2　Goldpinger是什么　237

10.2　Kubernetes是什么　238

10.2.1　Kubernetes简史　238

10.2.2　Kubernetes能为你做

什么　239

10.3　搭建Kubernetes集群　241

10.3.1　使用Minikube　241

10.3.2　启动一个集群　241

10.4　测试运行在Kubernetes上的

软件　243

10.4.1　运行ICANT项目　243

10.4.2　实验1：终止50%的

Pod　251

10.4.3　派对技巧：时尚地终止

Pod　256

10.4.4　实验2：引入网络缓慢　257

总结　267

第11章　自动化Kubernetes实验　268

11.1　使用PowerfulSeal自动化

混沌　268

11.1.1　PowerfulSeal是什么　269

11.1.2　安装PowerfulSeal　270

11.1.3　实验1b：终止50%的

Pod　271

11.1.4　实验2b：引入网络缓慢　273

11.2　持续测试和服务水准目标　276

11.2.1　实验3：验证Pod在创建后

几秒内是否准备就绪　277

11.3　云层　282

11.3.1　云提供商API、可用区　282

11.3.2　实验4：关闭VM　284

总结　286

第12章　Kubernetes底层工作原理　287

12.1　Kubernetes集群剖析以及如何

破坏它　287

12.1.1　控制平面　288

12.1.2　Kubelet和pause容器　295

12.1.3　Kubernetes、Docker以及

容器运行时　297

12.1.4　Kubernetes网络　300

12.2　关键组件总结　304

总结　304

第13章　混沌工程与人　305

13.1　混沌工程思维　305

13.1.1　故障不是一种可能：它会

发生　306

13.1.2　早失败与晚失败　307

13.2　获得支持　308

13.2.1　经理　308

13.2.2　团队成员　309

13.2.3　游戏日　309

13.3　将团队当成分布式系统　310

13.3.1　查找知识单点故障：

宅度假　312

13.3.2　团队内部的错误信息和

信任　313

13.3.3　团队中的瓶颈：慢车道上的

生活　313

13.3.4　测试你的流程：内部

工作　314

总结　315

附录

附录A　安装混沌工程工具　318

附录B　突击测验答案　325

附录C　导演剪辑　333

附录D　混沌工程食谱　337

后记　343