目录

第 1 章 为什么选择微服务 1

1.1 本书的实用性 2

1.2 你将学到什么 4

1.3 你需要知道什么 5

1.4 管理复杂性 6

1.5 什么是微服务 7

1.6 什么是微服务应用程序 8

1.7 单体架构的问题是什么 9

1.8 为什么微服务如此受欢迎 12

1.9 微服务的优势 12

1.10 微服务的挑战 14

1.10.1 较高的技术技能需求 14

1.10.2 分布式应用程序构建的复杂性 14

1.10.3 微服务的扩展性挑战 15

1.10.4 对复杂性的普遍恐惧 15

1.10.5 提前应对挑战 15

1.11 现代微服务工具 16

1.12 不只是微服务 17

1.13 可能性范围 17

1.14 设计微服务应用程序 18

1.14.1 软件设计 19

1.14.2 设计原则 19

1.14.3 领域驱动设计 19

1.14.4 不要重复自己 20

1.14.5 服务的适当规模 21

1.14.6 深入了解设计知识 21

1.15 示例应用程序 22

1.16 总结 23

第 2 章 创建微服务 24

2.1 新工具介绍 25

2.2 获取代码 26

2.3 选择 Node.js 的理由 26

2.4 我们的开发哲学 28

2.5 构建单服务开发环境 30

2.5.1 安装 Git 31

2.5.2 克隆代码库 33

2.5.3 获取 VS Code 33

2.5.4 安装 Node.js 34

2.6 构建一个用于视频流的 HTTP 服务器 35

2.6.1 创建一个 Node.js 项目 36

2.6.2 安装 Express 39

2.6.3 创建 Express 框架 42

2.6.4 运行简单的 Web 服务器 43

2.6.5 运行基础 Web 服务器 44

2.6.6 添加视频流功能 44

2.6.7 配置我们的微服务 47

2.6.8 设置生产环境 49

2.6.9 实时重新加载以实现快速迭代 51

2.6.10 运行本章的完整代码 54

2.7 Node.js 回顾 55

2.8 继续学习 55

2.9 总结 56

第 3 章 发布微服务 57

3.1 Docker：一种新工具 58

3.2 获取代码 58

3.3 容器是什么 59

3.4 什么是镜像 60

3.5 为什么选择 Docker 61

3.6 为何选择使用 Docker 61

3.7 在开发环境中整合 Docker 62

3.7.1 安装 Docker 63

3.7.2 检查 Docker 安装情况 64

3.8 打包微服务 64

3.8.1 创建 Dockerfile 65

3.8.2 打包并检查 Docker 镜像 67

3.8.3 在容器中启动微服务 70

3.8.4 调试容器 73

3.8.5 停止容器 73

3.9 发布微服务 74

3.9.1 创建私有容器仓库 75

3.9.2 将微服务推送到仓库 80

3.9.3 从仓库启动微服务 83

3.9.4 删除你的容器仓库 86

3.10 Docker 回顾 87

3.11 继续学习 88

3.12 总结 89

第 4 章 微服务的数据管理 90

4.1 新工具 91

4.2 获取代码 91

4.3 使用 Docker Compose 开发微服务 92

4.3.1 为什么选择 Docker Compose 93

4.3.2 创建我们的 Docker Compose 文件 94

4.3.3 启动我们的微服务应用程序 96

4.3.5 关闭应用程序 97

4.3.6 为什么用 Docker Compose 进行开发，而不用于生产 99

4.4 为应用程序添加文件存储 99

4.4.1 使用 Azure Storage 100

4.4.2 更新视频流微服务 108

4.4.3 将新微服务添加到 Docker Compose 文件 110

4.4.4 测试更新后的应用程序 112

4.4.5 云存储与集群存储 114

4.4.6 我们实现了什么 114

4.5 向应用程序添加数据库 115

4.5.1 为什么选择 MongoDB 116

4.5.2 在开发中集成数据库服务器 116

4.5.3 在生产环境中部署数据库服务器 121

4.5.4 每个微服务用一个数据库还是整个应用用一个数据库 121

4.5.5 我们实现了什么 122

4.6 Docker Compose 回顾 122

4.7 深入拓展你的学习 123

4.8 总结 124

第 5 章 微服务间的通信 126

5.1 新工具与熟悉的工具 127

5.2 让我们的微服务开始对话 127

5.3 介绍历史微服务 129

5.4 快速迭代的实时重载 130

5.4.1 创建历史微服务的框架 131

5.4.2 增强微服务以支持实时重载 132

5.4.3 区分开发和生产的 Dockerfile 133

5.4.4 更新 Docker Compose 文件以支持实时重载 135

5.4.5 尝试实时重载 137

5.4.6 在开发环境中测试生产模式 138

5.4.7 我们已经实现了什么 139

5.5 微服务之间的通信方式 140

5.5.1 直接消息传递 140

5.5.2 间接消息传递 141

5.6 使用 HTTP 进行直接消息传递 142

5.6.1 为什么选择 HTTP 143

5.6.2 直接针对特定微服务发送消息 143

5.6.3 使用 HTTP POST 发送消息 144

5.6.4 使用 HTTP POST 接收消息 145

5.6.5 测试更新后的应用程序 146

5.6.6 通过直接消息协调行为 147

5.6.7 我们实现了什么 148

5.7 使用 RabbitMQ 进行间接消息传递 148

5.7.1 为什么选择 RabbitMQ 149

5.7.2 间接定位消息到微服务 149

5.7.3 创建一个 RabbitMQ 服务器 151

5.7.4 调查 RabbitMQ 仪表板 152

5.7.5 将我们的微服务连接到消息队列 153

5.7.6 多接收者消息 156

5.7.7 接收多接收者消息 157

5.7.8 发送多接收者消息 158

5.7.9 测试多接收者消息 159

5.7.10 通过间接消息实现复杂行为 159

5.7.11 我们实现了什么 161

5.8 微服务通信总结 161

5.9 继续学习 162

5.10 总结 162

第 6 章 走向生产 164

6.1 新工具介绍 165

6.2 代码获取 165

6.3 进入生产环境 166

6.4 在 Kubernetes 上托管微服务 166

6.4.1 为何选择 Kubernetes 168

6.4.2 Pod、节点和容器 169

6.4.3 Pod、部署和服务 170

6.5 启用你的本地 Kubernetes 实例 171

6.6 安装 Kubernetes 命令行工具 173

6.7 项目结构详解 174

6.8 部署到本地 Kubernetes 实例 175

6.8.1 构建微服务镜像 175

6.8.2 暂时无需容器仓库 176

6.8.3 创建部署到本地 Kubernetes 实例的配置 176

6.8.4 配置 kubectl 连接到本地 Kubernetes 179

6.8.5 部署微服务到本地 Kubernetes 180

6.8.6 测试已部署的微服务 182

6.8.7 删除部署 182

6.8.8 为什么在开发中不使用本地 Kubernetes 183

6.8.9 我们已经完成了什么 183

6.9 在 Azure 中创建托管 Kubernetes 集群 184

6.10 使用 Azure CLI 187

6.10.1 安装 Azure CLI 187

6.10.2 认证 Azure CLI 188

6.10.3 将 kubectl 连接至 Kubernetes 189

6.11 部署到生产集群 190

6.11.1 设置容器注册中心 190

6.11.2 发布镜像到容器注册中心 190

6.11.3 将容器注册中心与 Kubernetes 集群关联 191

6.11.4 创建部署到生产 Kubernetes 的配置 192

6.11.5 部署微服务到 Kubernetes 194

6.11.6 测试已部署的微服务 194

6.11.7 删除部署 196

6.11.8 销毁基础设施 196

6.11.9 我们取得的成就 196

6.12 Azure CLI 工具回顾 197

6.13 Kubectl 回顾 197

6.14 继续学习 198

6.15 总结 199

第 7 章 基础设施即代码 201

7.1 新工具介绍 202

7.2 获取代码 202

7.3 基础设施原型化 202

7.4 基础设施即代码 203

7.5 使用你的 Azure 账户认证 204

7.6 选择 Kubernetes 的合适版本 204

7.7 使用 Terraform 创建基础设施 205

7.7.1 为什么选择 Terraform 206

7.7.2 安装 Terraform 207

7.7.3 设置 Terraform 项目 207

7.8 创建 Azure 资源组 208

7.8.1 使用 Terraform 的演化架构 209

7.8.2 编写基础设施创建脚本 210

7.8.3 固定提供者版本号 210

7.8.4 初始化 Terraform 211

7.8.5 Terraform 初始化的副产品 212

7.8.6 构建你的基础设施 213

7.8.7 理解 Terraform 状态 214

7.8.8 销毁和重建我们的基础设施 217

7.8.9 我们达到了什么成就 219

7.9 创建我们的容器仓库 219

7.9.1 继续我们的基础设施演化 220

7.9.2 创建容器仓库 220

7.9.3 Terraform 输出 221

7.9.4 从 Terraform 输出敏感值 222

7.9.5 不要输出敏感值 223

7.9.6 获取容器仓库的详细信息 223

7.9.7 我们达成了什么目标 224

7.10 重构以共享配置数据 224

7.10.1 继续我们的基础设施演化 224

7.10.2 引入 Terraform 变量 224

7.11 创建我们的 Kubernetes 集群 226

7.11.1 编写创建集群的脚本 226

7.11.2 将仓库附加到集群 227

7.11.3 构建我们的集群 228

7.11.4 我们达到了什么成就 228

7.12 部署到我们的集群 229

7.13 销毁我们的基础设施 230

7.14 Terraform 回顾 231

7.15 继续学习 231

7.16 总结 232

第 8 章 持续部署 233

8.1 新工具 234

8.2 获取代码 234

8.3 在本章运行示例 234

8.4 什么是持续集成 236

8.5 持续部署简介 237

8.6 自动化部署的优势 239

8.7 初探 GitHub Actions 自动化 240

8.7.1 为何选用 GitHub Actions 240

8.7.2 工作流是什么 240

8.7.3 创建新的工作流 241

8.7.4 示例 1 概述 243

8.7.5 “Hello World”shell 脚本 243

8.7.6 “Hello World”工作流 244

8.7.7 内联调用命令 245

8.7.8 触发工作流的代码更改 246

8.7.9 查看工作流历史 246

8.7.10 通过 UI 触发工作流 248

8.7.11 我们实现了什么 248

8.8 实施持续集成 249

8.8.1 示例 2 概述 249

8.8.2 自动化测试的工作流 250

8.8.3 我们实现了什么 251

8.9 持续部署微服务 252

8.9.1 示例 3 概述 252

8.9.2 模板化部署配置 253

8.9.3 先于自动化部署的手动部署 255

8.9.4 自动化部署流程 258

8.9.5 验证部署结果 259

8.9.6 安装和配置 kubectl 260

8.9.7 从 GitHub Secrets 提取环境变量 260

8.9.8 使用 GitHub 上下文变量 261

8.9.9 设置 GitHub Secrets 261

8.9.10 调试你的部署流程 263

8.9.11 直接部署到生产环境的风险 264

8.9.12 我们实现了什么 265

8.10 继续学习 265

8.11 总结 266

第 9 章 微服务的自动化测试 267

9.1 新工具 268

9.2 获取代码 268

9.3 微服务的测试 269

9.4 自动化测试 269

9.5 使用 Jest 进行自动化测试 272

9.5.1 为什么选择 Jest 272

9.5.2 设置 Jest 273

9.5.3 要测试的数学库 275

9.5.4 我们的第一个 Jest 测试 275

9.5.5 运行我们的第一个测试 276

9.5.6 使用 Jest 的实时重新加载 277

9.5.7 解释测试失败 277

9.5.8 通过 npm 调用 Jest 279

9.5.9 充实我们的测试套件 280

9.5.10 使用 Jest 进行模拟 281

9.5.11 我们实现了什么 283

9.6 微服务的单元测试 283

9.6.1 元数据微服务 285

9.6.2 使用 Jest 创建单元测试 287

9.6.3 执行测试 290

9.6.4 我们实现了什么 291

9.7 集成测试 291

9.7.1 待测试的代码 292

9.7.2 启动 MongoDB 数据库 292

9.7.3 加载数据库固件 293

9.7.4 使用 Jest 创建集成测试 294

9.7.5 执行测试 297

9.7.6 我们实现了什么 298

9.8 端到端测试 298

9.8.1 为什么选择 Playwright 299

9.8.2 安装 Playwright 300

9.8.3 设置数据库固件 302

9.8.4 启动应用程序 305

9.8.5 使用 Playwright 编写端到端测试 305

9.8.6 使用 npm 运行 Playwright 308

9.8.7 我们达到了什么成就 309

9.9 自动化测试在 CI/CD 流程中的应用 310

9.10 测试概述 311

9.11 继续学习 311

9.12 总结 312

第 10 章 部署 FlixTube 314

10.1 熟悉的工具 315

10.2 获取代码 315

10.3 重温基本技能 316

10.4 FlixTube 概述 317

10.4.1 FlixTube 微服务概览 317

10.4.2 微服务项目结构 319

10.4.3 FlixTube 单一代码库 319

10.5 在开发环境中运行 FlixTube 321

10.5.1 启动单个微服务 321

10.5.2 启动整个 FlixTube 应用程序 323

10.6 在开发环境中测试 FlixTube 324

10.6.1 使用 Jest 对微服务进行测试 325

10.6.2 使用 Playwright 对应用程序进行测试 326

10.7 FlixTube 深入探讨 327

10.7.1 数据库夹具的应用 327

10.7.2 模拟存储微服务 329

10.7.3 网关 333

10.7.4 FlixTube 用户界面 334

10.7.5 视频流 337

10.7.6 视频上传 339

10.8 在本地 Kubernetes 部署 FlixTube 343

10.8.1 本地部署的前提条件 345

10.8.2 本地部署操作 345

10.8.3 测试本地部署 345

10.8.4 删除本地部署 346

10.9 手动将 FlixTube 部署到生产环境 346

10.9.1 生产部署的前提条件 347

10.9.2 生产部署 348

10.9.3 测试生产部署 349

10.9.4 清理生产环境部署 349

10.10 持续部署到生产环境 349

10.10.1 持续部署的前提条件 350

10.10.2 设置你自己的代码库 350

10.10.3 部署基础设施 351

10.10.4 每个微服务一个 CD 管道 351

10.10.5 测试 CD 管道 353

10.11 FlixTube 的未来 354

10.12 继续学习 355

10.13 总结 356

第 11 章 健康的微服务 358

11.1 维护微服务的健康 359

11.2 监控与管理微服务 360

11.2.1 日志记录的开发实践 360

11.2.2 错误处理 362

11.2.3 利用 Docker Compose 进行日志管理 365

11.2.4 在 Kubernetes 中进行基础日志记录 366

11.2.5 Kubernetes 日志聚合 369

11.2.6 企业级日志记录、监控和警报系统 370

11.2.7 微服务的可观测性 371

11.2.8 利用 Kubernetes 健康检查自动重启微服务 372

11.3 调试微服务 374

11.3.1 调试过程 374

11.3.2 在生产环境中调试微服务 379

11.4 可靠性与恢复 382

11.4.1 实施防御性编程 382

11.4.2 实施防御性测试 382

11.4.3 保护我们的数据 383

11.4.4 实现复制和冗余 383

11.4.5 故障隔离与优雅降级 385

11.4.6 实现容错的基本技巧 386

11.4.7 高级容错技术 389

11.5 深入学习 391

11.6 总结 392

第 12 章 可扩展性的途径 394

12.1 我们的未来是可扩展的 395

12.2 扩展开发过程 395

12.2.1 多个团队的扩展 396

12.2.2 独立的代码仓库 397

12.2.3 分离代码仓库 399

12.2.4 元仓库 400

12.2.5 创建多个环境 402

12.2.6 生产工作流 404

12.2.7 将应用配置与微服务配置分离 406

12.3 性能扩展 407

12.3.1 垂直扩展集群 408

12.3.2 水平扩展集群 410

12.3.3 水平扩展单个微服务 411

12.3.4 集群的弹性扩展 412

12.3.5 单个微服务的弹性扩展 412

12.3.6 扩展数据库 413

12.3.7 避免过早扩展 416

12.4 缓解变更引起的问题 416

12.4.1 自动化测试和部署 416

12.4.2 分支保护 417

12.4.3 部署到测试环境 417

12.4.4 滚动更新 417

12.4.5 蓝绿部署 418

12.5 基本安全概念 420

12.5.1 信任模型 420

12.5.2 敏感配置管理 422

12.6 微服务重构 423

12.6.1 转向微服务的必要性 423

12.6.2 规划转换并全员参与 424

12.6.3 深入了解你的单体应用 424

12.6.4 提升自动化水平 425

12.6.5 构建你的微服务平台 425

12.6.6 沿自然边界切割 426

12.6.7 优先级提取 426

12.6.8 迭代实施 427

12.7 可能性区间 427

12.7.1 追求实用而非完美 428

12.7.2 投资回报递减 429

12.7.3 混合架构策略 429

12.8 成本效益型微服务策略 430

12.9 开始简单地行动 431

12.10 持续学习 432

12.11 总结 433