原文:
annas-archive.org/md5/504ac02bda9c6c4c7655551815fb7bc6相关服务:美国GPU服务器
译者:飞龙
序言
DevOps 是快速高效地部署软件的最新革命。通过一套自动化工具、编排平台和一些流程,公司可以加速其 IT 系统的发布周期,使工程师能够在业务流程中更有效地工作。
本书内容涵盖
第一章,实际世界中的 DevOps,展示了 DevOps 在当前 IT 公司工程部门中的位置,以及如何调整资源以最大化交付潜力。
第二章,云数据中心,比较了不同的云解决方案,用于管理云上的资源(虚拟机、网络、磁盘等)。
第三章,Docker,教授关于 Docker 及其内部工作原理的知识,以便更好地理解容器化技术的运作方式。
第四章,持续集成,讨论了可以用来执行测试以及其他许多操作的持续集成技术,正如我们将在第八章,发布管理 - 持续交付中看到的。
第五章,基础设施即代码,展示了如何以可编程的方式描述我们的基础设施,并应用软件开发生命周期的最佳实践来确保其完整性。
第六章,服务器配置,展示了如何使用 Ansible 来管理远程服务器的配置,以便简化大量服务器的维护工作,即使我们将重点放在 Kubernetes 上,这也是值得了解的。
第七章,Docker Swarm 和 Kubernetes - 集群基础设施,简要介绍了 Docker Swarm,然后引导您关注 Kubernetes,这是最先进的容器编排技术,被世界上最大的公司如 Google 广泛使用。
第八章,发布管理 - 持续交付,展示如何在 Google Cloud Platform 上使用 Kubernetes 和 Jenkins 设置持续交付管道。
第九章,监控,展示了如何监控我们的软件和服务器,以便能够在潜在故障发生前非常快速地发现并修复(可能)而不会影响我们的客户。
您需要准备什么
为了能够跟随本书及其内容,你需要在 Google Cloud Platform 上注册一个试用账户,并安装一个编辑器(我使用的是 Atom,但任何其他编辑器也可以),以及在本地机器上安装 Node.js。你还需要在本地安装 Docker,以便测试不同的示例。我们将在 Kubernetes 示例中使用Google 容器引擎(GKE),但如果你想在本地玩 Kubernetes,也可以使用 Minikube,尽管你需要一台相当强大的计算机。
本书适用对象
本书适合那些希望在 DevOps 领域提升技能的工程师,特别是那些想要精通 Kubernetes 和容器的读者。中级技能的读者最为理想。
约定
本书中,你会看到多种文本样式,用于区分不同类型的信息。以下是这些样式的一些示例及其含义的解释。文本中的代码词汇、数据库表名、文件夹名称、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 句柄以如下方式显示:“下一行代码会读取链接并将其分配给BeautifulSoup函数。” 一段代码块如下所示:
resource "google_compute_address" "my-first-ip" {
name = "static-ip-address"
}
当我们希望引起你对代码块中特定部分的注意时,相关的行或项目会用粗体显示:
resource "google_compute_address" "my-first-ip" {
name = "static-ip-address"
}
任何命令行输入或输出都写作如下:
docker commit 329b2f9332d5 my-ubuntu
新术语和重要词汇以粗体显示。你在屏幕上看到的词语,例如在菜单或对话框中,文本中会像这样显示:“为了下载新模块,我们将进入 Files | Settings | Project Name | Project Interpreter。”
警告或重要提示以这种方式显示。
提示和技巧以这种方式出现。
读者反馈
我们始终欢迎读者的反馈。告诉我们你对本书的看法——你喜欢或不喜欢的部分。读者的反馈对我们很重要,因为它帮助我们开发出你真正能从中受益的书籍。如果你有专业知识并且有兴趣编写或参与编写一本书,请查阅我们的作者指南:www.packtpub.com/authors。
客户支持
现在你是 Packt 书籍的骄傲拥有者,我们提供了许多帮助你最大限度利用这本书的资源。
下载示例代码
你可以从你的帐户中下载本书的示例代码文件,网址为:www.packtpub.com。如果你在其他地方购买了本书,可以访问www.packtpub.com/support并注册,文件会直接通过电子邮件发送给你。你可以按照以下步骤下载代码文件:
-
使用你的电子邮件地址和密码登录或注册我们的官网。
-
将鼠标指针悬停在顶部的 SUPPORT 标签上。
-
点击代码下载与勘误表。
-
在搜索框中输入书籍名称。
-
选择您想要下载代码文件的书籍。
-
从下拉菜单中选择您购买本书的渠道。
-
点击“代码下载”。
文件下载完成后,请确保使用最新版本的以下工具解压或解压文件夹:
-
Windows 版的 WinRAR / 7-Zip
-
Mac 版的 Zipeg / iZip / UnRarX
-
Linux 版的 7-Zip / PeaZip
该书的代码包也托管在 GitHub 上,网址为github.com/PacktPublishing/Implementing-Modern-DevOps。我们还提供了其他书籍和视频的代码包,您可以在github.com/PacktPublishing/找到它们。快来看看吧!
下载本书的彩色图片。
我们还为您提供了包含本书中使用的截图/图表的彩色图片的 PDF 文件。这些彩色图片将帮助您更好地理解输出中的变化。您可以从www.packtpub.com/sites/default/files/downloads/ImplementingModernDevOps_ColorImages.pdf下载该文件。
勘误表
尽管我们已尽最大努力确保内容的准确性,但错误仍然会发生。如果您在我们的书籍中发现错误——可能是文本或代码中的错误——我们将非常感激您向我们报告。通过这样做,您可以帮助其他读者避免挫折,并帮助我们改进后续版本。如果您发现任何勘误,请访问www.packtpub.com/submit-errata报告,选择您的书籍,点击勘误提交表格链接,填写勘误的详细信息。一旦您的勘误被验证,您的提交将被接受,勘误内容将被上传到我们的网站或添加到该书籍的勘误列表中。
要查看之前提交的勘误,请访问www.packtpub.com/books/content/support,并在搜索框中输入书籍名称。所需的信息将在勘误部分显示。
盗版
网络盗版问题在所有媒体上都是一个持续的难题。在 Packt,我们非常重视对版权和许可证的保护。如果您在互联网上发现任何非法的我们作品的副本,请立即提供其位置地址或网站名称,以便我们采取措施。请通过[email protected]与我们联系,并提供可疑盗版材料的链接。
我们感谢您帮助我们保护作者权益,并确保我们能够为您提供有价值的内容。
问题
如果您在本书的任何方面遇到问题,欢迎通过[email protected]联系我们,我们会尽力解决问题。
第一章:现实世界中的 DevOps
在过去的几年里,软件行业发展迅速。我最喜欢的演变例子之一是金融科技(FinTech),这是一个新的领域,其名称源于金融和技术的融合。在这个领域,企业往往以颠覆性的方式构建金融产品,直到威胁到大型传统银行,甚至将它们置于危险之中。
这种情况主要是由于大公司失去了在 IT 系统中保持成本效益的能力,而银行恰恰是这些大公司之一。银行仍然使用 IBM 大型机运行系统,并且不愿意迁移到云端,这一点并不奇怪;同样,银行的核心组件依然是自 90 年代以来没有更新过的 COBOL 应用程序,这也并不奇怪。如果不是因为只有少数具备 AWS 或 Google Cloud Platform 账户的才华横溢的工程师,实际上可以构建出能够替代某些银行产品的服务,比如货币兑换甚至是经纪服务,那这一切或许还不会那么糟糕。
这在过去几年中已成为一种常态,FinTech 中小公司成功的部分原因归功于 DevOps,另一个部分则是其规模。通常,大公司会随着时间推移将 IT 系统商品化,外包给第三方,这些第三方专注于价格,忽视了质量。这是一个非常有效的削减成本的措施,但也有一个副作用:你失去了快速交付价值的能力。
在这一章中,我们将把 DevOps 放到一个更广泛的视角来看,并探索它如何帮助我们创造成本效益高的工作单元,从而在极短的时间内提供大量价值。
什么是 DevOps?
亨利·福特(Ford 公司创始人)有一句著名的名言:
“如果我问人们他们想要什么,他们会说更快的马。”
这就是传统系统管理员角色的变化:人们在尝试解决错误的问题。
所谓“错误的问题”,是指缺乏合适的工具来自动化生产系统中的干预,避免人为错误(这种错误比你想象的还要常见),并导致公司流程中的沟通不连续。
最初,DevOps 是开发、运维和 QA 的交集。DevOps 工程师应该做所有事情,完全参与软件开发生命周期(SDLC),解决传统发布管理中的沟通问题。这是理想的状态,在我看来,这正是全栈工程师应当做的:端到端的软件开发,从需求捕获到部署和维护。
如今,这一定义已经被扭曲到了一个地步,DevOps 工程师基本上是一个使用一套工具来自动化任何公司基础设施的系统工程师。这种 DevOps 的定义并没有错,但请记住,我们正在失去一个非常有竞争力的优势:对系统的端到端视角。一般来说,我不会称这个角色为 DevOps 工程师,而是站点可靠性工程师(SRE)。这是谷歌几年前提出的一个术语,因为有时候(尤其是在大公司中),无法为一个工程师提供执行 DevOps 所需的访问权限。我们将在下一节中讨论这个角色,即 SRE 模型。
在我看来,DevOps 更像是一种理念,而不是一套工具或流程:让工程师接触到产品的完整生命周期需要很大的纪律性,但也能让你对所构建的内容拥有巨大的控制力。如果工程师理解问题,他们就能解决它;这正是他们擅长的。
DevOps 的起源
在过去的几年里,我们经历了 IT 行业的革命:它从纯粹的 IT 公司蔓延到各行各业:零售、银行、金融等等。这催生了一批小公司,称为初创企业,基本上是一些有创意的个人,他们付诸实践,并走向市场,通常是为了将产品或服务销售给全球市场。像亚马逊、阿里巴巴,更不用说谷歌、苹果、Stripe 甚至 Spotify,已经从创始人车库中的小公司发展为雇佣数千人的大公司。
这些公司最初的共同点一直是企业效率低下:公司越大,完成简单任务所需的时间就越长**。**

企业效率低下图表示例
这种现象创造了一个独立的市场,需求无法通过传统产品满足。为了提供更敏捷的服务,这些初创公司需要具备成本效益。大银行可以在其货币兑换平台上花费数百万,但如果你是一家正在奋斗的小公司,你与大银行竞争的唯一方式就是通过自动化和更好的流程来降低成本。对于小公司来说,这促使它们采用更好的做事方式,因为每一天的过去都意味着离现金耗尽更近,但更大的驱动力是采用 DevOps 工具:失败。
失败是任何系统发展的自然因素。无论我们投入多少努力,失败总是存在,在某个时刻,它总会发生。
通常,公司非常关注消除失败,但有一条不成文的规则却阻碍了它们的成功:80/20 法则:
- 你只需要 20%的时间就能实现 80%的目标。剩下的 20%将占用你 80%的时间。
在避免失败上花费大量时间注定会失败,但幸运的是,另一个解决方案是:快速恢复。
到目前为止,在我的工作经验中,我只见过一家公司问“如果凌晨 4 点发生故障,我们该怎么办?”而不是“我们还能做些什么来防止系统崩溃?”,相信我,创建一个恢复系统要比确保我们的系统不会宕机容易得多(特别是有了现代工具)。
所有这些事件(自动化和故障管理)推动了现代自动化工具的发展,使我们的工程师能够:
-
自动化基础设施和软件
-
快速从错误中恢复
DevOps 和企业
DevOps 完美契合了小型公司(初创公司)的世界:一些可以访问一切并执行所需命令的个人,能够快速进行系统更改。在这些生态系统中,DevOps 闪耀着光芒。
在大型公司的传统开发模型中,这种访问级别是不可行的。如果您的系统处理的是高度机密的数据,这甚至可能成为法律上的障碍,因为您需要从政府那里为员工获取安全许可才能授予他们对数据的访问权限。
对公司来说,保持一个传统的开发团队将产品交付给运行该产品的工程师,并与开发人员密切合作,以确保沟通不成问题,也会是一个方便的选择。
SRE 也使用 DevOps 工具,但通常他们更多地关注构建和运行一个中间件集群(如 Kubernetes、Docker Swarm 等),为开发人员提供一致性和共同语言,使他们能够抽象化基础设施:他们甚至不需要知道集群部署在哪些硬件上;他们只需要为将要在集群中部署的应用程序创建描述符,并以访问控制和自动化的方式进行,以确保遵循安全政策。
SRE 是一个独立的学科,Google 已经发布了一本免费的电子书,您可以在landing.google.com/sre/book.html找到它。
我建议您阅读这本书,它提供了一个相当有趣的观点。
传统发布管理
多年来,企业将 IT 系统的发展从其核心业务流程中剥离出来:零售商店的业务是零售而非软件,但现实很快就敲响了警钟,像亚马逊或阿里巴巴这样的公司,部分可以归功于将其 IT 系统置于业务核心位置。
几年前,许多公司习惯于将整个 IT 系统外包,试图像外包办公室维护一样将复杂性从主营业务中剥离出去。这种做法在很长一段时间里是成功的,因为相同应用程序或系统的发布周期足够长(每年发布几次),可以将复杂的变更管理链条组织起来,发布就像一次大爆炸事件,所有的内容都要精确到毫米,几乎没有容忍失败的空间。
通常,这类项目的生命周期非常类似于下图所示:

这种模型传统上被称为瀑布模型(你可以看到它的形状),它借鉴了传统工业管道的做法,在这些管道中,事情按非常明确的顺序和阶段发生。在软件行业的最初阶段,工程师们尝试将传统行业的做法应用于软件,尽管这是一个不错的想法,但它也存在一些缺点:
-
旧问题被带到了一个新领域
-
软件的无形性优势被削弱
使用瀑布模型时,我们面临一个大问题:没有什么进展是快速的。无论在流程中投入多少努力,它都是为巨大的软件组件设计的,这些组件每年发布的次数很少,甚至只有一年一次。如果你尝试将这种模型应用于较小的软件组件,它会因涉及的参与者数量而失败。很可能,捕获需求的人不会参与应用程序的开发,而且肯定对部署一无所知。
沟通链条
我记得小时候,我们曾经玩一个叫做“疯狂电话”的游戏。有人会编一个充满细节的故事并写在纸上,这个人把故事读给另一个人听,后者需要尽可能多地捕捉信息,并把故事传递给下一个人,直到达到游戏人数的上限。四个人之后,几乎可以肯定,故事不会和最初的版本相似,但还有一个更让人担忧的细节:在第一个人之后,故事就再也不会一样了。细节会被删减或创造出来,但故事肯定会发生变化。
这个游戏正是我们在瀑布模型中试图复制的:那些在需求上工作的人员正在编写一个故事,这个故事将被开发人员转述,而开发人员又会编写另一个故事,交给 QA,以便他们可以测试交付的产品是否符合一个已经经过至少两个人手的故事。
正如你所看到的,这注定会是一场灾难,但等等,我们能做些什么来解决它?如果我们看看传统行业,我们会发现他们从来不会犯错,至少错误率非常低。我认为其中的原因是,他们正在构建的是有形的东西,比如汽车或核反应堆,这些东西可以轻易地进行检查,相信与否,它们通常比软件项目简单。如果你开车,几分钟后你就能发现发动机的问题,但如果你开始使用一个新版本的软件,可能要过几年才能发现安全问题,甚至功能性问题。
在软件中,我们通过创建非常简洁且复杂的图表来缓解这个问题,使用统一建模语言(UML),这样我们就可以捕捉唯一的事实来源,始终可以回到它来解决问题或验证我们的工件。尽管这是更好的方法,但它也不是没有问题:
-
一些细节很难在图表中捕捉
-
业务相关人员不理解 UML
-
创建图表需要时间
特别是,业务相关人员不理解 UML 是这里的最大问题。在需求收集后,修改它们或在较低级别(如开发、运维等)提出问题时,通常需要涉及一些人,至少有一个人(即业务相关人员)不理解需求捕捉的语言。如果项目的需求从第一次迭代开始就是完全正确的,这不会成为问题,但你参与过的有多少个项目的需求是静态的?答案是没有。
修复 bug 的成本
一旦我们明确了存在沟通问题,bug 通常会在我们的过程中出现。无论是与需求的不一致,还是需求本身有误,通常都会导致缺陷,这可能会阻止我们将应用程序部署到生产环境并延迟所有进度。
在瀑布模型中,修复 bug 在每一步都变得越来越可能。例如,在需求阶段修复 bug 非常简单:只需更新图表/文档,就完成了。如果同样的 bug 在验证阶段被 QA 工程师捕获,我们需要:
-
更新文档/图表
-
创建应用程序的新版本
-
部署新版本到 QA 环境

如果 bug 在生产环境中被发现,您可以想象修复它涉及多少步骤,更不用说压力,特别是当 bug 影响到公司收入时。
发布新版本
几年前,我曾在一家公司的生产发布步骤中工作,步骤是逐条写在 Microsoft Word 文档中的,并附带解释:
-
将这个文件复制过去:
cp a.tar b.tar -
使用以下命令重启服务器
xyz:sudo service my-server restart
这还加上了一长串发布新版本所需执行的操作。这种情况发生是因为那家公司相当大,IT 部门已经商品化,尽管他们的业务是基于 IT 产品的,但他们并没有将 IT 嵌入到业务的核心。
如你所见,这是一个非常危险的情况。即便是创建版本和部署文档的开发人员在场,仍然有人在生产机器上盲目地按照指示部署新的 WAR 文件(一个打包在文件中的 Java Web 应用)。我记得有一天我问过:如果这个人在没有质疑的情况下执行命令,为什么我们不直接写一个在生产环境中运行的脚本呢?他们说那样太危险了。
他们说得对:风险是我们在部署新版本软件时想要减少的因素,而这些软件一天内会被几十万用户使用。公平地说,正是风险促使我们选择在凌晨 4 点而不是在工作时间进行部署。
我看到的问题是,缓解风险的方法(在早上 4 点当没有人购买我们产品时进行部署)创造了我们在 IT 中所说的单点故障:部署是一种“全有或全无”的事件,受时间的巨大限制,因为在早上 8 点,应用的流量通常会从每小时两次访问增长到每分钟成千上万次,早上 9 点通常是一天中最繁忙的时段。
话虽如此,部署结果有两种可能的结果:新软件要么成功部署,要么没有成功。这给相关人员带来了压力,而你最不希望看到的就是压力重重的人在操作一个数百万美元的商业系统。
让我们看看手动部署背后的数学原理,比如之前提到的:
| 描述 | 成功率 |
|---|---|
从集群中卸载server 1 | 99.5% |
停止server 1上的Tomcat | 99.5% |
| 移除旧版本的应用(WAR 文件) | 98% |
| 复制新版本的应用(WAR 文件) | 98% |
| 更新配置文件中的属性 | 95% |
启动Tomcat | 95% |
将server 1附加到集群 | 99.5% |
这描述了在单台机器上发布新版本的软件所涉及的步骤。整个公司系统有几台机器,因此该过程需要重复进行几次,但为了简化起见,我们假设只在一台服务器上进行部署。
现在有一个简单的问题:整个过程中的失败率是多少?
我们自然倾向于认为,像前面这种链式过程中的失败概率,在每个步骤中是链条上最大的一步:5%。但事实并非如此。公平地说,这是一种非常危险的认知偏差。我们通常会因为对低风险的错误认知而做出非常危险的决定。
让我们用数学来计算失败的概率:
上述列表是依赖事件的列表。如果步骤 4 失败,我们就不能执行第 6 步,因此我们要应用的公式如下:
P(T) = P(A1)*P(A2)…*P(An)
这导致了以下计算:
P(T) = (99.5/100) * (99.5/100) * (98/100) * (98/100) * (95/100) * (95/100) * (99.5/100) = 0.8538
我们只有 85.38%的时间会成功。这转化为部署,这意味着我们在凌晨 4 点唤醒来发布新版本的时候,每 6 次中就会出现 1 次问题,但更大的问题是:如果在刚发布后的生产测试中没有人注意到的错误呢?对这个问题的答案既简单又痛苦:公司需要关闭整个系统以回滚到先前的版本,这可能导致收入和客户流失。
现代发布管理
几年前,当我在凌晨 4 点进行手动部署时,我记得自问:“一定有更好的办法。”工具还不够成熟,而且大多数公司并不认为 IT 是他们业务的核心。然后,一场变革发生了:DevOps 工具开始在开源社区中表现出色,公司开始创建持续交付管道。其中一些取得了成功,但绝大多数失败了,原因有两个:
-
发布管理流程
-
组织对齐的失败
我们将在本章后面讨论组织对齐问题。现在,我们将专注于发布管理流程,因为它需要与传统的发布管理完全不同,以促进软件生命周期。
在前面的章节中,我们谈到了不同的阶段:
-
需求
-
设计
-
实施
-
验证
-
维护
我们还解释了它在庞大软件中如何运作,我们将功能分组到大版本中,以大爆炸式的方式执行,要么全面部署,要么不部署。
第一次尝试将此流程适应更小的软件组件就是每个人称为敏捷的东西,但没有人真正知道它是什么。
敏捷开发和沟通
在传统的发布管理中,一个大问题是沟通:人们传递信息和消息的链条,正如我们所见,往往收效甚微。
敏捷鼓励更短的沟通链:利益相关者应参与软件开发管理,从需求定义到同一软件的验证(测试)。这有一个巨大的优势:团队永远不会构建不需要的功能。如果需要满足截止日期,工程团队会减少最终产品的规模,牺牲功能而不是质量。
"提前交付并频繁交付"是敏捷的座右铭,基本含义是定义一个最小可行产品(MVP),并在它准备好时尽早交付,以便为应用程序的客户提供价值,然后根据需求交付新功能。通过这种方式,我们从第一次发布开始就提供价值,并在产品生命周期的早期就获得反馈。
为了表达这种工作方式,提出了一个新概念:sprint(冲刺)。冲刺是一个时间段(通常为 2 周),在这段时间内会完成一组功能,并在结束时将其交付到生产环境,以实现不同的效果:
-
客户能够频繁获得价值
-
反馈每 2 周就会到达开发团队,以便采取纠正措施
-
团队变得更加可预测,并且能够准确估算
最后这一点非常重要:如果我们在一个季度发布中的估算偏差为 10%,那么意味着我们误差了两周,而在两周的冲刺中,误差只有一天,随着时间推移,随着每次冲刺积累的知识,团队能够根据已有的功能和所花费的时间建立一个数据库,从而进行比较,调整新的功能。
这些功能不叫功能,它们叫做故事。故事的定义是:在冲刺开始之前,为开发团队准备好所有必要信息的、功能清晰的模块,因此当我们开始开发冲刺时,开发者可以专注于技术活动,而不是集中精力解决这些功能中的未知问题。
并非所有的故事大小相同,因此我们需要一个衡量单位:故事点。通常,故事点与时间框架无关,而是与复杂性相关。这让团队能够计算出每个冲刺结束时能交付多少故事点,因此,随着时间的推移,他们能更好地进行估算,每个人的期望都能得到满足。
每个冲刺结束时,团队应该发布已开发、测试并集成到生产环境中的功能,以便进入下一个冲刺。
冲刺的内容从团队正在维护和准备的待办事项列表中选择。
主要目标是通过保持沟通畅通,满足每个人的期望,能够预测交付内容及其交付时间,并明确交付所需的条件。
有多种方法可以在我们的软件产品中实现敏捷方法。前面讲解的叫做Scrum,但如果你研究其他开发方法论,你会发现它们都专注于相同的概念:改善同一团队中不同角色之间的沟通。
如果你对Scrum感兴趣,可以查看更多信息:en.wikipedia.org/wiki/Scrum_(software_development)。
发布新版本
如前所述,如果我们遵循 Scrum 方法论,我们应该每 2 周交付一个新版本(在大多数情况下,一个 sprint 的周期),这对消耗的资源有显著影响。让我们来做个数学比较:季度发布与双周发布:
-
在季度发布中,除了紧急发布以外,我们一年只发布四次,用来修复生产中发现的问题。
-
在双周发布中,我们每两周发布一次,除此之外还有紧急发布。这意味着每年会发布 26 次(大约 52 周),加上紧急发布。
为了简单起见,我们忽略紧急发布,专注于我们应用程序的日常业务。假设我们需要 10 小时来准备和发布我们的软件:
-
季度发布:10 x 4 = 40 每年小时
-
双周发布:10 x 26 = 260 每年小时
到目前为止,发布软件始终是相同的活动,无论我们是每季度发布一次还是每天发布一次。其含义是相同的(大致上),所以我们面临一个大问题:我们的双周发布消耗了大量时间,如果我们需要发布修复 QA 中被忽略的问题,情况会更糟。
解决这个问题只有一个办法:自动化。正如前面提到的,直到 2 年前(大约 2015 年),用于协调自动化部署的工具还不够成熟。Bash 脚本曾经很常见,但并不理想,因为 bash 并不是为了改变生产服务器的状态而设计的。
最早的自动化部署工具是用来管理服务器状态的框架:Capistrano 或 Fabric 包装了 ssh 访问和状态管理,利用 Ruby 和 Python 上的一组命令,允许开发者创建脚本,根据服务器的状态执行不同的步骤来实现一个目标:发布新版本。
这些框架是一个很好的进步,但它们存在更大的问题:跨公司解决方案通常以不同的方式解决相同的问题,这意味着 DevOps(开发*+* 运维)工程师需要学会如何在每一个公司中处理这些问题。
真正的变化来自 Docker 和编排平台,如 Kubernetes 或 Docker Swarm。在本书中,我们将探讨如何使用它们,特别是 Kubernetes,将部署时间从 10 小时(或者一般的小时)减少到一次简单的点击,这样我们的每年 260 小时变成了每次发布几分钟。
这也有一个副作用,和我们在本章前面解释的内容有关:从一个非常高风险的发布(记住,85.38%的成功率)伴随大量压力开始,我们正在朝着一个可以在几分钟内修补的发布方式发展,因此发布一个 bug,尽管这不好,但由于我们能够在几分钟内修复或甚至在几秒钟内回滚,它的影响大大降低。我们将在第八章中讨论如何做到这一点,发布管理 – 持续交付。
一旦我们与这些实践达成一致,我们甚至可以将单个项目发布到生产环境:一旦某个功能完成,如果部署是自动化的,且只需点击一下,为什么不在功能完成时直接推出这些功能呢?
DevOps 和微服务
微服务是如今的大趋势:小型软件组件,它允许公司在功能的垂直切片上管理他们的系统,单独部署功能,而不是将它们捆绑在一个大应用程序中,这在大团队中可能会导致问题,因为功能之间的交互常常会导致冲突和错误被发布到生产环境,而没人注意到。
一个使用微服务且相当成功的公司例子是 Spotify。不仅在技术层面,甚至在业务层面,他们已经组织好了相关工作,能够协调大量的服务,提供几乎不会失败的顶级音乐流媒体服务,如果失败了,也只是部分失败:
-
播放列表由一个微服务管理;因此,如果它宕机,只有播放列表会不可用。
-
如果推荐功能没有生效,用户通常甚至不会注意到。
这带来了巨大的成本:运营开销。将一个应用拆分成多个微服务需要相应的运营量来维持其运行,如果处理不当,这个开销会呈指数增长。我们来看一个例子:
-
我们的系统由五个应用程序组成:A、B、C、D 和 E。
-
它们每个都是一个单独部署的微服务,每个月需要大约 5 小时的运维时间(部署、容量规划、维护等)。
如果我们将所有五个应用程序合并成一个大应用程序,我们的维护成本将大幅下降,几乎和之前提到的任何微服务的成本一样。数字非常清晰:
-
基于微服务架构的系统每月需要 25 小时的维护时间
-
单体应用每月需要 5 小时的维护时间
这带来了一个问题:如果我们的系统增长到数百个(是的,数百个)微服务,情况就变得难以管理,因为这会消耗我们所有的时间。
唯一的解决方案是自动化。虽然始终会有运营开销,但通过自动化,我们不仅可以节省每个服务每月增加的 5 小时时间,随着时间的推移,这个时间会减少,因为一旦我们自动化了干预,新的服务几乎不会消耗任何时间,一切都会像事件链一样自动发生。
在第八章中,发布管理 - 持续交付,我们将设置一个持续交付流水线,演示这一点是如何实现的,尽管我们会有一些手动步骤以保证稳定性,但完全可以自动化在 Kubernetes 等集群上运行的微服务环境中的所有操作。
一般来说,我不建议任何公司在没有适当自动化的情况下启动基于微服务的项目,特别是如果你确信系统会随着时间的推移增长,那么 Kubernetes 将是一个非常有趣的选择:它提供了其他平台所缺乏的功能,比如负载均衡、路由、入口等。我们将在接下来的章节中深入探讨 Kubernetes。
所有这些活动应该是 DevOps 工程师日常工作的组成部分(其中还有很多其他任务),但首先,我们需要解决一个问题:如何调整我们公司的资源,以便最大限度地发挥 DevOps 工程师的作用。
DevOps:组织对齐
到目前为止,我们已经了解了现代和传统发布生命周期的运作方式。我们还定义了 DevOps 工程师的角色,并说明了他们如何帮助微服务,如前所述,如果没有适当的自动化,它们是不可行的。
除了技术细节,还有一个对 DevOps 文化成功至关重要的因素:组织对齐。
传统的软件开发通常将团队划分为不同的角色:
-
商业分析师
-
开发人员
-
系统管理员
-
QA 工程师
这就是我们所说的横向切片:一个系统管理员团队与开发人员有少数接触点,以便他们获得足够的信息来部署和维护软件。
在现代发布生命周期中,这种方式显然行不通。我们需要的是纵向切片:一个团队应该由每个横向团队的至少一名成员组成。这意味着开发人员、商业分析师、系统管理员和 QA 工程师应该在一起……当然,百分之百的融合并非必需。
在 DevOps 哲学下,这些角色中的一些变得不再重要或需要发展。其理念是一个团队能够独立地构建、部署和运行应用程序,而不依赖外部支持:这被称为跨职能自主管理团队。
在我的职业经验中,跨职能团队是交付高质量可靠产品的最佳组织方式。产品由构建人员管理;因此,他们对产品了如指掌。分析师(取决于业务性质)、开发人员和 DevOps 工程师的组合是将高质量软件交付到生产环境所需的全部人员。有些团队可能还会包括 QA 工程师,但一般来说,由 DevOps 和开发人员创建的自动化测试应该是至高无上的:如果没有良好的代码覆盖率,就不可能以持续交付的方式发布软件。我非常支持分析师亲自进行软件测试,因为他/她是最了解需求的人,因此最适合进行验证。
DevOps 工程师扮演着跨领域的角色:他们需要了解应用是如何构建的(并可能参与开发),但他们的重点与应用的运营相关:安全性、操作准备、基础设施和测试应是他们的日常工作。
我也看到过完全由 DevOps 工程师和分析师组成的团队,没有纯粹的开发人员或 QA。在这种情况下,DevOps 工程师不仅负责基础设施部分,还负责应用开发,这可能会非常具有挑战性,具体取决于系统的复杂性。一般来说,每个案例都需要单独研究,因为 DevOps 并不是一个“通用”的产品。
你可以从本书中期待什么
现在我们已经介绍了 DevOps,接下来是具体说明我们将在本书中学习什么内容。主要将集中在 Google Cloud Platform 及其相关的 DevOps 工具上,原因有多方面:
-
GCP 的试用期足够让你完成整本书的学习。
-
这是一个非常成熟的产品。
-
Kubernetes 是 GCP 的重要组成部分。
你将学习 DevOps 工具和实践的基础知识,这些内容提供了足够的细节,让你在需要时能够进一步查找额外的信息,同时也能立即在公司中应用所学。
本书将重点关注 DevOps 的运维部分,因为应用开发方面的知识已经足够,且在 DevOps 世界中并未发生变化。不言而喻,我们不会展示如何为你的应用编写测试,这对于确保系统的稳定性是至关重要的活动:没有良好的代码覆盖和自动化测试,DevOps 是无法奏效的。
一般来说,这些示例足够简单,入门级的 DevOps 人员也能轻松跟上,但如果你想深入了解 GCP 的某些方面,可以参考 cloud.google.com/docs/tutorials 上的丰富教程集合。
这本书的结构是渐进式的:首先,在讲解不同云提供商的内容之后,展示 Docker 的基础知识,但在深入讲解配置管理工具(具体是 Ansible)和容器编排平台(主要是 Kubernetes)之前。
最终,我们将设置一个名为 Chronos 的时区时间戳管理系统的持续交付管道,我出于多种原因在讲座中使用它:
-
它几乎没有业务逻辑。
-
它基于微服务架构。
-
它涵盖了几乎所有所需的基础设施。
你可以在以下 GitHub 仓库找到 Chronos 的代码:github.com/dgonzalez/chronos。
大多数示例可以通过在本地计算机上使用虚拟化提供商(例如 VirtualBox 和 Kubernetes 示例中的 MiniKube)进行重复,但我鼓励你注册 Google Cloud Platform 的试用版,因为它在写这篇文章时,提供给你 $300 或 1 年的资源供自由使用。
概述
在这一章中,我们已经看到了如何调整资源(工程师)以交付低成本、高影响力的 IT 系统。我们还看到了,沟通不畅如何导致缺陷的发布过程,从而使我们的部署陷入僵局,并且从业务角度来看,系统变得相当低效。在本书的其余部分,我们将探讨能够帮助我们不仅改善这种沟通,还能使我们的工程师以更低的成本交付更高质量功能的工具。
这些工具的第一个系列将在下一章中介绍:云数据中心。这些数据中心使我们能够从其资源池中创建资源(虚拟机、网络、负载均衡器等),以满足我们对特定硬件的需求,且价格合理,灵活性高。现代(以及一些非现代)IT 公司越来越多地采用这种云数据中心,这也促使了一系列自动化基础设施的工具的诞生。
第二章:云数据中心——新现实
在过去几年,云系统逐渐成为主流,它们使得企业能够根据需求以一种简便且低成本的方式扩展。它们还使公司能够利用一种叫做基础设施即代码(IAC)的技术,这基本上允许你将之前需要根据需求购买的物理资源(服务器和路由器)视为代码,你可以查看、运行并重新运行这些代码,以使基础设施适应你的需求。
在本章中,我们将介绍主要的云服务提供商,重点分析它们的主要优点和缺点,以便形成清晰的认识,了解它们提供了什么以及我们作为工程师如何利用这些服务。
在市场上的所有提供商中,我们将重点关注这两家:
-
Amazon Web Services(AWS)
-
Google Cloud Platform
我们还将简要讨论以下内容:
-
Heroku
-
Azure
-
DigitalOcean
我们应该保持开放的心态,因为它们每个都可以提供不同且有价值的功能集,这是不容忽视的。
我们将介绍Kubernetes,在我个人看来,它是现代 DevOps 世界中许多问题的答案。
亚马逊网络服务
亚马逊无疑是全球最大的在线零售商,几乎在全球都有业务。每个人都听说过亚马逊,以及这种商店为 21 世纪繁忙社会带来的各种可能性:它们提供几乎任何可以在传统商店购买的商品的送货上门服务。
亚马逊由 Jeff Bezos 于 1994 年创立,从那时起,它每年都在持续增长,提供越来越多的产品和服务,但有一天,它们进入了云计算业务。对于像亚马逊这样的大公司来说,拥有大量的处理能力是有意义的,同时它还具有可靠性,并能够迅速适应业务需求。
起初,云服务是为了满足业务的高可用性需求,并且能够以统一的方式扩展。这使得公司在构建一流的基础设施即服务(IaaS)方面积累了大量经验,最终他们意识到这些技术可以出售给客户。
到了 2006 年,市场上没有任何竞争对手,所以它们处于成功起步的有利位置。
我记得当时我还在大学,EC2 和 EC3 两项服务首次在一个会议上推出。
EC2 让你能够在云上创建虚拟机,提供一个通过命令行接口和 Web 界面进行操作的 API,后者可以作为你资源的监控工具。
S3 是一种关键价值存储(某种意义上),允许你以非常低的价格存储大量数据,并且同样可以通过命令行界面进行操作。
这真的是一次革命。它是一个完全的范式转变:现在你可以根据需要请求更多资源。这就像是一个 API 调用,几分钟内就可以得到三台新机器。下面的截图展示了 AWS 上的服务列表:

2017 年 1 月 AWS 服务目录
在过去几年中,亚马逊频繁地添加服务,直到有时很难跟上这种速度。在本章中,我们将介绍一些主要的服务(或我认为最有用的服务),展示它们的功能和应用领域。
EC2 - 计算服务
云系统必须为用户提供的第一个元素是计算能力。EC2代表弹性计算云,它允许你通过几次点击在云端创建机器。
这是 EC2 界面的样子:

EC2 界面
EC2 于 2006 年 8 月 25 日推出(beta 版本),自那时以来已经经历了很多发展。它为用户提供不同大小的机器,并且在全球范围内可用(截至今天,覆盖 11 个不同的区域)。这意味着用户可以在全球不同地区启动机器,以实现高可用性和低延迟,使得你公司工程师能够在不需要跨国协调团队的情况下构建多区域应用。
它们还提供不同类型的实例,针对不同任务进行了优化,使得用户可以根据自己的需求定制基础设施。总共有 24 种不同类型的实例,但它们也按类型进行了分组,我们将在本章后面详细介绍。
让我们看一个如何启动实例的示例。
启动实例
首先,你需要进入 AWS EC2 界面。
- 现在点击启动实例按钮,这将带你进入以下界面:

-
这是你可以选择运行镜像的地方。如你所见,镜像是将运行在 EC2 实例上的操作系统。在亚马逊的术语中,这个镜像被称为Amazon Machine Image(AMI),你可以创建自己的镜像并保存以便后续使用,这样可以便捷地发布预先构建的软件。现在,选择 Ubuntu Server 16.04 并点击选择。
-
下一屏显示的是镜像的大小。AWS 提供了多种大小和类型的镜像。这一参数会显著影响应用程序的性能,包括网络、内存、CPU 性能以及机器的 I/O。
-
让我们看一下不同类型的实例:
| 类型 | 描述 |
|---|---|
| 突发型实例 | T2 是用于突发处理的通用型实例。它们提供了一个 CPU 基线水平,以应对处理能力的高峰,但这些高峰是按累积方式提供的:在空闲时,CPU 会累积积分,这些积分可以在需求高峰期使用,一旦这些积分用尽,性能就会恢复到基线水平。 |
| 通用型 | M3 是一个通用型实例,具有专用资源(没有突发积分)。它在 CPU、内存和网络资源之间提供了良好的平衡,是需要稳定性能的生产应用程序的最小实例。M4 遵循与 M3 相同的理念,但硬件有所更新:亚马逊弹性块存储(Amazon EBS)优化、更好的 CPU 以及增强的网络系统是该实例类型的亮点。 |
| 计算优化型 | AWS 的计算优化型实例包括 C3 和 C4。与 M 系列实例相同,C4 是 C3 的硬件升级版。这些类型的实例适用于需要强大 CPU 性能的工作,如数据处理和分析或高要求的服务器。C4 还配备了增强型网络系统,这对于高网络流量应用程序非常有帮助。 |
| 内存优化型 | 如你所料,AWS 还提供了内存优化型实例,适用于需要高内存使用的应用程序。基于 Apache Spark(或大数据应用)的应用程序、内存数据库等,最能受益于这类实例。在这种情况下,内存优化型实例被划分为两个子系列:X1:这些是大规模企业级实例。X1 可用于企业生态系统中最苛刻的应用程序,它是内存密集型实例的旗舰,仅用于非常大的应用程序。R3/R4:尽管比 X1 更为简朴,但 R 实例完全能够处理大多数日常内存密集型应用程序。缓存系统、内存数据库等是 X 和 R 实例的最佳应用场景。 |
| 加速计算实例 | 一些应用程序,如人工智能(AI),具有特定的计算要求,如图形处理单元(GPU)处理或可重配置硬件。这些实例被分为三种系列:P2:GPU 计算实例。这些实例经过优化,可执行特定的处理任务,如通过暴力破解密码以及机器学习应用(通常依赖 GPU 算力)。G2:图形处理实例。视频渲染、光线追踪或视频流媒体是这些实例的最佳应用场景。 |
- 如你所见,每种用户需求都有一个相应的实例可用。目前,我们首先选择一个小型实例,因为我们只是测试 AWS,其次是因为 AWS 提供免费套餐,允许你在 1 年内免费使用
t2.micro实例,具体如以下截图所示:

-
现在我们有两个选项。点击“审核实例启动”或“配置实例详情”。在本例中,我们将点击“审核实例启动”,但通过点击“配置实例详情”,我们可以配置实例的多个元素,例如网络、存储等。
-
当你点击“审核实例启动”后,审查页面将出现。点击“启动”,你应该看到类似于下图所示的界面:

-
只需为密钥对命名并点击“下载密钥对”按钮,这将下载一个
.pem文件,稍后我们将使用该文件通过ssh访问实例。 -
一旦你指定了密钥对,点击“启动实例”,如前面的截图所示,就是这么简单。经过几次检查后,你的镜像将准备好安装所需软件(这通常需要几分钟)。
这是在 AWS 中创建运行实例所需的最低配置。正如你所看到的,整个过程在屏幕上有非常详细的解释,一般来说,如果你了解 DevOps 的基础(ssh、网络配置和设备管理),你在创建实例时不需要太多帮助。
关系型数据库服务
在前一部分中,我们展示了可以用来安装所需软件的 EC2 实例。还有一个服务可以让你管理跨区域的高可用数据库(MySQL、PostgreSQL、Maria DB、Aurora,以及 Oracle 和 SQL Server)。这个服务叫做 RDS,代表关系型数据库服务。
关系型数据库的一大难题是高可用性配置:主主配置通常费用较高,小公司往往无法承担。AWS 通过 RDS 提升了标准,提供了可以通过几次点击就能设置的多区域高可用数据库。
AWS 与 EC2 的网络配置
AWS 提供了细粒度的网络控制。与任何物理数据中心一样,你可以定义自己的网络,但 AWS 有一个更高级的抽象概念:虚拟私有云(VPC)。
亚马逊虚拟私有云(Amazon VPC)是 AWS 云的一部分,允许您将资源在子网中分组和隔离,以便按照您的需求组织和规划基础设施。它还允许您在 AWS 和物理数据中心之间创建 VPN,从而扩展后者,增加更多来自 AWS 的资源。同时,当您在 EC2 中创建资源时,您可以选择将资源创建在您自定义的子网中。
在了解 VPC 的结构之前,让我们先解释一下 AWS 如何处理资源的地理分布。AWS 为您提供不同地区的数据中心,例如欧洲、亚洲和美国。以欧盟西部(EU West)为例,它有三个不同的可用区:

在 AWS 中,“区域”概念基本上指的是 AWS 数据中心所在的地理区域。了解这些信息使我们能够构建全球规模的应用程序,通过将流量从最近的数据中心提供服务来提高延迟表现。地理分布的另一个重要原因是许多国家的 数据保护法律。通过选择数据存储的位置,我们可以确保遵守这些法律。
在这些地理区域内,我们有时可以找到可用区。一个可用区基本上是一个物理上分离的数据中心,确保系统的高可用性。例如,在其中一个数据中心发生灾难时,我们可以始终依靠其他可用区进行恢复。
让我们来看一下区域和可用区的分布:

现在我们已经理解了 AWS 从地理角度的运作方式,让我们更深入地了解在区域和可用区层面上 VPC 的概念。
VPC 是 AWS 云中逻辑上隔离的部分,对于用户而言是私有的,可以承载资源,并且跨越 AWS 区域的所有可用区。在这个 VPC 内,我们可以定义不同的子网(不同可用区中的公共和私有子网),并指定哪些机器可以从互联网访问:AWS 允许您创建路由表、Internet 网关、NAT 网关以及其他常见的网络资源,使用户能够构建与物理数据中心中相同的基础设施。
要讨论 AWS 中的网络,仅这一部分就足以写一本完整的书。我们将在本书的后续章节深入探讨一些概念,但如果你真的想深入了解 AWS 的网络部分,你可以访问 docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Introduction.html 查找更多的数据和示例。
AWS 还提供了一个非常强大的元素:**Elastic Load Balancing **(ELB)。ELB 是经典硬件负载均衡器的现代版本。它使我们能够对资源进行健康检查,只将健康的资源加入池中。此外,AWS 提供两种类型的负载均衡器:经典负载均衡器和应用负载均衡器。第一种版本,顾名思义,是应用负载均衡器,它根据健康检查分配流量,并不理解传输的数据,而应用负载均衡器可以根据请求的信息,基于高级策略来路由流量。ELB 还能够处理完整的 HTTPS 流量,这样我们就可以在负载均衡器中进行 SSL 终止操作,并允许我们的应用将加密/解密任务卸载给负载均衡器。
AWS 和 EC2 中的存储
到目前为止,我们已经展示了如何在 AWS 中创建机器和网络基础设施。在构建应用程序时,一个重要的方面就是数据存储。默认情况下,当我们在 EC2 中启动机器时,根卷中可以关联两种存储类型来运行操作系统:
-
实例存储支持的镜像
-
**Amazon Elastic Block Store **(Amazon EBS)存储支持的镜像
第一种类型,即实例存储支持的镜像,依赖于与镜像相关联的存储来挂载并运行根卷。这意味着一旦机器终止,存储在镜像中的数据将丢失(这种类型的镜像不支持停止操作,只支持终止操作)。
第二种类型的实例是由 EBS 支持的。Elastic Block Store 是 AWS 提供的存储服务名称。使用 EBS,用户可以根据需要创建和销毁卷(块设备)以及快照:我们可以在进行风险操作之前创建一个正在运行的镜像副本,以便如果发生错误时可以恢复。
存储类型可以根据我们的需求有所不同:你可以从磁性块设备到 SSD 硬盘,也可以使用通用设备来覆盖所有应用中的大多数使用场景。
通常情况下,所有实例都由 EBS 支持,因为存储在逻辑上与计算分离,这使得我们能够进行一些操作,例如调整实例大小(例如,创建更强大的实例),而不会丢失数据。
可以将多个卷挂载到同一个 EC2 实例中,这些卷会像物理设备一样暴露给它,因此如果我们使用的是基于 Linux 的镜像(如 Ubuntu),我们可以使用 mount 命令将设备挂载到文件夹中。
Amazon S3
亚马逊简单存储服务(Amazon S3)正如其名,是一种以非常低的成本,在云端存储大量数据的简单方式,并提供了一套不错的功能。与基于预定义大小的设备存储的 EC2 不同,Amazon S3 实际上是一种键值存储,使我们能够通过键来识别数据。与其他键值存储技术不同,S3 准备好存储从小到非常大的对象(最大可达 5 TB),且响应时间极低,且可以在任何地方访问。
与 EC2 一样,Amazon S3 是一个具有区域概念的功能,但 S3 不理解可用区:S3 服务本身能够将对象存储在不同的设备上,因此您不需要担心这一点。数据存储在一种叫做桶(buckets)的抽象结构中,如果我们尝试将 S3 与文件系统进行比较,它就像一个文件夹,但有一个限制:桶的名称必须在 AWS 账户的所有区域中唯一,因此我们不能在两个不同的区域创建一个名为 Documents 的桶。
S3 的另一个优势是 AWS 提供了一个 REST API,可以非常简单地访问对象,这使得它成为现代 Web 存储的理想选择。
在我的职业生涯中,我遇到的 S3 的最佳使用案例之一是在金融机构中管理大量文档。通常,当公司涉及到资金时,他们必须将客户纳入一个叫做 客户尽职调查(CDD)的过程。这个过程确保客户确实是他们声称的人,且资金来源是合法的。根据金融规定,公司还需要保存这些文件至少 6 年。
为了进行这项调查,用户需要将文件发送给公司,而 Amazon S3 正好适合这个需求:客户将文件上传到公司的官网,实际上是将文件推送到 S3 桶(每个客户一个桶),并通过 Amazon S3 的复制功能将文件跨区域复制。此外,S3 为这一模式提供了另一个有趣的功能:有效期内的对象链接。基本上,这使得您可以创建一个仅在特定时间内有效的链接,因此,如果审查文档的人将链接暴露给第三方,S3 会返回错误,确保文件不容易被意外泄露(用户仍然可以下载它)。
S3 另一个有趣的特点是可以与 Amazon 密钥管理系统(Amazon KMS)集成(KMS 是 AWS 提供的另一项功能),因此我们在 S3 中的所有对象都会由保存在 KMS 中的密钥加密,并且该密钥可以定期透明地轮换。
亚马逊 ECR 和 ECS
容器已成为新常态。在过去几年中,我遇到的每个公司都在使用或考虑使用容器来构建软件。这使我们能够在构建软件时考虑微服务的原则(小型独立运行的单个软件组件),因为它提供了从不同应用程序的配置和部署中抽象出一个合理的层次:基本上,所有配置都存储在容器中,我们只需要关心如何运行它。
作为微服务架构的先驱之一,Amazon 创建了自己的镜像注册表和集群(服务)。
正如我们在第三章中将深入讨论的那样,Docker 是围绕两个概念构建的:镜像和容器。镜像是应用程序的定义(配置 + 软件),而容器是运行镜像的实例。镜像通过 Dockerfile(一个带有非常基础脚本语言的镜像描述)构建并存储在注册表中,在这种情况下是 Amazon EC2 容器注册表(ECR),我们在 AWS 基础设施中的私有注册表。我们不需要担心可用性或管理资源;我们只需选择容器运行的区域,并将镜像推送到该存储库。
然后,从我们运行 Docker 的主机中,拉取镜像并实例化容器。这既简单又有效,但有一些需要考虑的因素:
-
当我们的主机没有足够的资源来运行我们想要的容器数量时,会发生什么情况?
-
如果我们想确保容器的高可用性会发生什么情况?
-
我们如何确保容器在故障(出于某种原因)时重新启动?
-
我们如何在不中断服务的情况下为系统添加更多的硬件资源?
这些问题在几年前更加棘手,但现在变得简单了:Amazon EC2 容器服务(Amazon ECS)会为我们处理这些问题。ECS 基本上是一个由资源(EC2 机器)组成的集群,这些资源协同工作,为我们的容器提供运行环境。
在 ECS 中,当创建一个新服务时,我们会指定一些参数,比如应该同时运行多少个容器副本,以及容器应使用什么配置(镜像)。让我们看看它是如何工作的。
创建集群
首先,我们将在 AWS 控制台中创建一个集群,并查看它是如何工作的。
- 转到 Amazon ECS 页面并点击“开始使用”按钮(屏幕上唯一的按钮,因为你还没有创建任何资源):

-
在继续之前,确保两个复选框都已勾选。我们想将一个示例应用部署到 ECS,并且还希望将镜像存储在 ECR 中。
-
下一屏幕至关重要:这里是我们定义镜像存储库的地方,它将决定用于从本地机器通过 Docker 推送镜像的存储库 URI。

-
只需使用
devops-test作为仓库名称,我们的仓库 URI 看起来将与前面截图中的非常相似。 -
步骤 2(共 6 步)是 AWS 提供的一系列命令,用于登录 ECR 并推送我们项目的镜像。在本例中,我们将使用一个非常简单的
Node.js应用:
var express = require('express');
var app = express();
app.get('/', function (req, res) {
res.send('Hello World!');
});
app.listen(3000, function () {
console.log('Example app listening on port 3000!');
});
- 将之前的代码保存在名为
index.js的文件中,放在本地机器上名为devops-test的文件夹内。由于我们正在使用 express,所以我们需要安装所需的依赖项。只需执行以下命令:
npm init
- 经过几个问题(只需按几次 Enter 就可以了),应该会创建一个名为
package.json的文件。现在我们需要为程序安装 express:
npm install --save express
- 就这样!我们的
package.json文件应该包含一行描述所需依赖项的内容:
{
"name": "code",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "echo "Error: no test specified"
&& exit 1",
"start": "node index.js"
},
"author": "",
"license": "ISC",
"dependencies": {
"express": "⁴.14.1"
}
}
-
这个文件允许我们在需要时重新安装依赖项,而无需手动操作;它还允许我们指定一个命令,当我们执行
npm start时会运行该命令(这是一种使用 npm 运行 Node 应用的标准方式)。按前面的代码中所示添加并突出显示该行,因为我们稍后会需要它(不要忘记上一行的分号)。 -
现在我们需要编写我们的 Dockerfile。正如我们将在第三章中看到的,Docker是一个描述我们的 Docker 镜像外观的文件。在这个案例中,我们将重建在 Docker 容器中运行节点应用程序所需的步骤:
FROM node:latest
RUN mkdir -p /usr/src/app
WORKDIR /usr/src/app
COPY package.json /usr/src/app/
RUN npm install
COPY . /usr/src/app
EXPOSE 3000
CMD [ "npm", "start" ]
- 不要试图理解这个文件;我们将在本书后面深入讲解。只需将其保存为
Dockerfile,并放在之前提到的文件夹devops-test中。到目前为止,你的devops-test文件夹应该如下所示:

- 现在我们准备好按照 ECS 设置中的步骤 2 进行操作。请注意,以下图像与我在 AWS 中的用户相关;你的用户将有不同的参数,因此请使用你自己的参数,而不是复制前面截图中的内容:

完成后,包含你应用程序镜像的新版本应该会安装在你的私有 ECR 中。
-
下一步(步骤 3)是创建 AWS 所谓的任务定义,它基本上是我们的容器实例的配置:我们将使用多少内存、运行哪个镜像以及在容器中暴露哪些端口。只需保留默认内存,但将端口更改为
3000,因为这是我们在前面的示例中使用的端口(节点应用程序)。这是典型的 Docker 参数,我们将在下一章中详细了解 Docker。 -
一旦准备好,点击下一步,我们将进入第 4 步。此步骤是我们将配置服务的地方。这里的服务指的是我们要保持活跃的容器实例数量,以及如何暴露它们:通过负载均衡器,还是仅通过集群中的 EC2 实例。我们还可以指定用于注册和注销正在运行实例的 IAM(AWS 凭证系统):

-
我们只需要保留默认设置,除了两个参数:
-
所需任务数量:设置为
2 -
在 ELB 部分,我们只需选择 sample-app:
80(或选择不是“No ELB”的选项,这样 AWS 会为我们提供一个 ELB)
-
-
点击下一步,在这里我们将定义我们的集群将如何配置:
-
节点的数量
-
节点的大小
-
-
一旦准备好,只需检查并启动实例。几分钟后,我们的集群应该启动并运行,准备好与我们部署的任务一起工作。
你可以通过集群本身提供的负载均衡器,在端口3000上访问我们创建的任务实例。如你所见,ECS 简化了设置容器集群的任务。
在本书中,我们将特别关注 Kubernetes 和 Docker Swarm,主要是因为它们是平台无关的技术,但我相信 Amazon ECS 是构建新容器化系统时值得考虑的一个非常有效的技术。
其他服务
如你所见,AWS 中的服务列表几乎是无止境的。我们已经访问了我认为最重要的服务,接下来的章节中,我们将探讨一些其他也很有趣的服务,但遗憾的是,我们无法深入探讨所有服务。然而,AWS 的文档相当完善,每项服务总是附带了详细的使用说明。
在本节中,我们将简要介绍一些服务,尽管它们非常重要,但并不是本书开发的核心内容。
Route 53
Route 53 是 AWS 中的 DNS 服务。它是一个全球性的可扩展 DNS 服务,允许你执行一些高级操作:
-
注册域名
-
从其他注册商转移域名
-
创建流量路由策略(例如跨区域的故障转移)
-
监控你应用程序的可用性(并将流量重定向到健康的实例)。
使用 Route 53,我们可以将域名链接到 AWS 资源,如负载均衡器、S3 存储桶和其他资源,使我们能够为在 AWS 实例中创建的资源(主要是虚拟机)公开一个人类可读的名称。
CloudFront
CloudFront 解决了低流量网站在访问量激增时面临的最大问题之一:它提供了缓存,使我们不禁想是否是 AWS 在提供数据,而不是我们的服务器。基本上,CloudFront 拦截对我们主机的请求,渲染页面,并将其缓存长达 24 小时,这样我们的网站就可以将流量卸载到 AWS。它是为提供静态内容而设计的,因为当用户第二次访问相同的 URL 时,将会提供缓存版本,而不是再次访问您的服务器。
强烈建议您使用 CloudFront 为公司的网站提供服务,这样您就可以使用一台非常小的机器处理所有流量,既节省了资源,也能在流量激增时提高站点的正常运行时间。
Amazon ElasticCache
Amazon ElasticCache,顾名思义,是一个分布式和可扩展的内存缓存系统,可以用于在应用程序中存储缓存数据。
它解决了我们在构建依赖缓存存储和检索数据的应用程序时可能面临的最大问题之一:高可用性和一致的临时数据存储。
Amazon RDS
RDS 代表 关系型数据库服务。通过 RDS,您可以通过几次点击配置 DB 实例,用于存储数据:Oracle、MySQL 和 MariaDB 是我们在 RDS 中的几个选择。它利用底层数据库系统的高可用性,这可能是我们依赖 AWS 时面临的一个问题,但通常是可以接受的,因为 SQL 数据库中的高可用性是一个复杂的课题。
DynamoDB
DynamoDB 是一款出色的工程产品。它是一个 NoSQL 数据库,在任何规模下都能将延迟微调到毫秒级。它存储对象而不是行(无法使用 SQL),是存储大量数据的无模式方式的良好选择。从本质上讲,DynamoDB 非常类似于 MongoDB,但有一个基本区别:DynamoDB 是 AWS 提供的服务,只能在 AWS 内运行,而 MongoDB 是一款可以安装在任何地方的软件,包括 AWS。从功能角度来看,MongoDB 的大部分用例同样适用于建模 DynamoDB 数据库。
Google Cloud Platform
Google 一直在技术领域处于领先地位。令人惊讶的是,Google 过去没有提供一个联合的服务层;相反,它提供了各个服务,这在为开发人员提供一个稳固的平台构建应用程序时远非理想。为了解决这个问题,它推出了 Google Cloud Platform,这是一个服务集合(基础设施即服务、平台即服务、容器和大数据,以及许多其他功能),使开发人员和公司能够构建具有高度可靠性和可扩展性的系统,提供一些最先进的功能,如 Kubernetes 和一套独特的机器学习 API。
界面也是 Google Cloud 的主要亮点之一:它为你提供了一个 web 控制台,基本上你可以在这里使用一个与所有服务连接的 ssh 终端,直接操作,而无需在本地机器上做任何配置。界面中的另一个优点是它使用了传统系统管理员领域的术语,使得大多数服务的学习曲线变得容易。

与 AWS 类似,Google Cloud Platform 允许工程师在全球各地的区域和可用区创建资源,以确保我们系统的高可用性,并遵守当地的法律法规。
但真正的皇冠上的明珠是他们的容器引擎。我是容器编排的忠实粉丝。如今,每个人都在朝着基于微服务的系统发展,看到公司遇到微服务系统操作现实的瓶颈并不奇怪:没有编排工具,这几乎是无法管理的。在市场上所有潜在的选择中(Amazon ECS、Docker Swarm 和 DCOS),有一个特别的工具改变了我的生活:Kubernetes。
Kubernetes 是我在撰写第一本书(使用 Node.js 开发微服务)时提出的一个问题的答案:如何通过为开发和运维提供一个共同的基础,有效地自动化微服务环境中的操作?Kubernetes 融合了 Google 多年来在使用容器方面积累的所有专业经验,创造了一个产品,提供了有效管理部署管道所需的所有组件。
在本书中,我们将特别强调 Kubernetes,因为在我看来,它是今天许多团队在成员和资源扩展过程中遇到问题的解决方案。
为了开始使用 GCP,Google 提供了 300 美元的试用信用或 60 天的免费试用,这足以让你了解大部分服务,当然,也足够跟随本书中的示例,玩转我们将要介绍的大多数概念。我建议你激活试用期并开始尝试:一旦信用用完或 60 天试用结束,Google 会要求明确确认启动计费,因此你的账户不会产生额外费用(在撰写本书时是这样的情况)。
Google 计算引擎
Google Compute Engine 相当于 Amazon Web Services 中的 EC2。它允许您以一种我前所未见的简便方式管理机器实例、网络和存储。在与 AWS 上手时,我发现的一个缺点是,他们创建了一些命名抽象,名称并不直观:虚拟私有云、弹性块存储等。虽然这并不是什么大问题,因为 AWS 在市场中非常知名,但 Google 领会了这一点,并且以非常直观的方式命名其资源,使得新用户几乎无需任何努力即可快速上手该平台。
关于机器类型,与 AWS 相比,Google Cloud Platform 提供了一组简化且有限的机器类型,但足够多样化以满足我们的需求。需要注意的 Google Cloud Platform 特性之一是,硬件随着实例大小的增加而提升,这意味着 64 核心的机器比 2 核心的机器拥有更强的 CPU。
Google Cloud Platform 还提供了一个 CLI 工具,可以通过终端与 GCP 资源进行交互。要安装它,只需访问此网址:cloud.google.com/sdk/。
然后,根据您的操作系统,按照说明进行操作。
标准机器类型
标准机器是任何应用程序中最常用的类型。它们在 CPU 和内存之间提供平衡,适合所有项目中的大多数任务。这些类型的机器为每个虚拟 CPU 提供 3.75 GB 的内存。让我们看几个示例:
| 名称 | CPU | 内存 |
|---|---|---|
n1-standard-1 | 1 | 3.75 GB |
n1-standard-2 | 2 | 7.50 GB |
n1-standard-64 | 64 | 240 GB |
如您所见,命名约定非常简单,容易根据规范名称推测机器的内存和 CPU 数量。
高内存机器类型
这些机器经过优化,适用于内存密集型应用程序。每个虚拟 CPU 配备了额外的内存,使您可以在内存方面做到更加出色。
每台高内存类型的机器都配备每个虚拟 CPU 6.5 GB 的内存,以下是一些示例:
| 名称 | CPU | 内存 |
|---|---|---|
n1-highmem-2 | 2 | 13 |
n1-highmem-8 | 8 | 52 |
n1-highmem-64 | 64 | 416 |
这些机器配备大量内存,非常适合分布式缓存、数据库以及许多其他需要相对较高内存消耗的应用程序。
高 CPU 机器类型
如其名称所示,高 CPU 型机器是具有高 CPU/内存比率的实例,每个虚拟 CPU 配备 0.9 GB 的内存,这意味着它们非常适合在高强度 CPU 任务中节省一些开销(因为我们减少了大量内存)。以下是这些机器的一些示例:
| 名称 | CPU | 内存 |
|---|---|---|
n1-highcpu-2 | 2 | 1.8 GB |
n1-highcpu-8 | 8 | 7.2 GB |
n1-highcpu-64 | 64 | 57.6 GB |
正如你所看到的,标准机器和高内存机器之间的唯一区别在于,这些机器配置了较少的 RAM,这使得我们在一些应用中可以节省不需要的资源,尤其是当这些应用能够在相同价格下创建更多 CPU 的机器时。高 CPU 机器非常适合需要高 CPU 和低内存消耗的应用,比如数学处理或其他类型的计算。
共享核心机器类型
有时,我们真的不需要为我们的流程提供专用的机器,因此 Google Cloud 提供了可以用作共享机器的选项。在我看来,分享核心的机器不适合生产使用,但它们非常适合用作原型或实验不同资源。以下是两种类型的机器:
| 名称 | CPU | 内存 |
|---|---|---|
f1-micro | 0.2 | 0.6 |
g1-small | 0.5 | 1.7 |
正如你所看到的,这里只有两种选项,它们在 RAM 和 CPU 功率上有所不同。我个人在想要尝试新的软件或 Google Cloud Platform 的新产品时,通常会使用这些机器。
别忘了,这些是突发型机器,只适合短时间内的高强度处理,不适合持续消耗资源,因为 CPU 是在不同应用之间共享的。
自定义机器和 GPU 处理
有时,我们的机器需要额外的资源,这些资源通常不在其他提供商预定义的机器实例中,但在这种情况下,Google Cloud Platform 通过一个令人惊叹的功能来解救我们:自定义机器类型。
在 Google Cloud Platform 上,使用自定义机器类型,我们可以在资源较少的机器上获得大型机器的硬件升级优势,或者创建适合我们需求的特定配置。
我们可以找到自定义机器的一个最佳例子是,当我们希望在我们的配置中加入 GPU 处理时。在 Google Cloud 中,GPU 可以按需附加到任何非共享(f1 或 g1)的机器上。借助创建自定义机器类型的能力,我们可以定义希望在其中提升处理能力的 GPU 数量。
总的来说,当我设计系统时,我尽量坚持使用标准类型,以简化我的设置,但创建自定义机器类型并没有错,唯一的问题是,我们可能会轻易陷入过早优化系统的问题,这也是 IT 工作中最常见的难题之一。
启动实例
在 Google Cloud Platform 中,一切都被组织在项目中。为了创建资源,你需要将它们与项目关联,因此启动实例的第一步是创建一个项目。为此,只需在第一次进入 Google Cloud Platform 界面时选择“新建项目”按钮,或者在已经创建了一个项目后,点击顶部栏的下拉菜单:
- 对于本书的示例,我将创建一个名为
Implementing Modern DevOps的项目,并用它来运行所有示例:

- 一旦我们创建了项目,就可以继续创建新的虚拟机实例。虽然可以创建超过 64 个核心的实例(通过自定义机器类型),但为了节省成本,我们将使用标准机器类型。继续使用默认值创建实例(只需更改名称):

-
我非常喜欢 Google Cloud Platform 的两个特点:
-
他们如何轻松地命名资源,并使一切都变得清晰易懂
-
他们在定价方面的透明度
-
-
在 Google Cloud Platform 上创建虚拟机时,存在这两个特点:创建机器的表单只有少数几个字段,并且会显示机器每月的费用(所以不会有意外费用)。
-
和 AWS 一样,Google Cloud Platform 允许你选择实例将要部署的区域和可用区(记住,这是一个物理隔离的数据中心),以确保系统的高可用性。
-
此外(不在前面的图中),它允许你通过勾选两个复选框,只需几个点击即可允许
http和https流量进入实例。这既简单又有效。 -
你还可以配置其他内容,如网络、SSH 密钥以及其他我们暂时跳过的参数。只需点击创建按钮(表单底部),然后等待机器完全配置(可能需要几分钟),你应该会看到类似于以下截图的内容:

-
Google Cloud Platform 最吸引人的特点之一是其用户界面的精心设计。在这种情况下,你可以看到机器描述中有一个名为“连接”的列,允许你通过几种不同的方式连接到机器:
-
SSH
-
gcloud命令(GCP 的命令行工具) -
使用另一个 SSH 客户端
-
-
我们将选择 SSH(默认选项),并点击 SSH 按钮。屏幕上应该会弹出一个窗口,几秒钟后,我们应该能看到类似于
ssh终端的界面,它是我们机器上的终端:

这是一个非常简洁且实用的功能,它基本上使工程师避免携带一组加密密钥,因为加密密钥总是存在泄露的风险,一旦泄露,你的机器就会暴露。
网络设置
我不能强调 Google Cloud Platform 如何简化概念并使其看起来类似于现实世界的物理数据中心概念这一点。这在网络设置中同样适用:所有的概念和名称都可以一一映射到现实世界的物理网络概念上。
在 Google Cloud 中,我们可以通过几次点击实现任何符合 IP 网络设计原则的需求(与 AWS 相同)。Google Cloud 还提供了一个有趣的功能(与 AWS 等其他提供商一样),即可以通过 VPN 网络将数据中心扩展到云中,既能享受云产品的好处,又能达到最敏感数据所需的安全性。
Google 容器引擎
Google 容器引擎 (GKE) 是 Google 提出的一个容器编排方案,利用市场上最强大的容器集群之一:Kubernetes。
如我们在第七章中将进一步讨论的那样,Docker Swarm 和 Kubernetes——集群基础设施,Kubernetes 是一个功能丰富的集群,专门用于以受控方式部署和扩展基于容器的应用程序,特别强调定义开发和运维之间的共同语言:一个将开发和运维概念融合为共同基础的框架:资源的 YAML(或 JSON)描述。
Kubernetes 的一个大问题是确保高可用性。当你在本地或云提供商上部署集群时,利用计算资源(AWS 中的 EC2 或 GCP 中的 Compute Engine),你需要负责升级集群版本,并随着 Kubernetes 的新版本发布而不断演进。在这种情况下,Google Cloud Platform 通过容器引擎解决了操作问题:GCP 负责保持主节点的更新,而用户在 Kubernetes 发布新版本时升级节点,这使得我们能够制定不同的集群升级程序。
设置集群
在第七章中,Docker Swarm 和 Kubernetes——集群基础设施,你将学习如何操作 Kubernetes,但值得在本章中教你如何在 GKE 中设置集群,以便在深入了解 Kubernetes 的核心概念之前,先展示设置集群的简便性:
- 首先,进入 Google Cloud Platform 中的容器引擎:

-
如你所见,目前没有设置任何集群,所以我们有两个选择:
-
创建一个新的容器集群
-
快速开始
-
-
我们只需点击“创建一个容器集群”,然后按照屏幕上的指示(表单)设置我们的集群:

-
确保区域(Zone)靠近你的地理位置(尽管现在这并不重要),并且大小设置为
3。这个参数——大小——将要求 GCP 在计算引擎中创建3个实例来设置集群,并由 GCP 自行管理一个主节点。关于镜像,我们在这里有两个选项,gci或container-vm。在这种情况下,实际上并不重要,因为这是一个测试集群,但请注意,如果你想使用 NFS 或其他高级文件系统,你将需要使用container-vm。 -
点击创建,几分钟后,你应该会看到两样东西:
-
集群是在 Google 容器引擎部分创建的
-
三个新的虚拟机在计算引擎部分配置
-
-
这是一个非常智能的设置,因为通过一些使用 Google Cloud Platform 命令工具(
gcloud)的命令,我们可以对集群进行扩展或缩减,还可以调整实例的大小以满足我们的需求。如果你探索集群(点击它的名称),你会发现一个“连接到集群”的链接,它会引导你到一个包含连接 Kubernetes 仪表板的说明的页面。

- 有时,这些指令会失败,因为
gcloud配置不当。如果你在配置集群访问时遇到错误,运行以下命令:
gcloud auth login <your email>
-
然后,按照说明操作。假设你已经配置好了 Google Cloud SDK,一切应该正常工作,运行
kubectl proxy命令后,你应该能够通过http://localhost:8001/ui访问 Kubernetes 仪表板。 -
为了测试是否一切按预期工作,只需在 Kubernetes 中运行一个简单的镜像(在此案例中是
busybox镜像):
kubectl run -i busybox --image=busybox
- 如果我们在运行 Kubernetes 代理时(如前所述)刷新仪表板 (
http://localhost:8001/ui),我们应该看到与以下图像相似的内容,位于“部署”部分:

这表明部署(一个 Kubernetes 概念,我们将在第七章,Docker Swarm 和 Kubernetes - 集群基础设施中探讨)成功。
其他 Google Cloud Platform 产品
Google Cloud 平台不仅有计算引擎和容器引擎,它还是一系列非常有趣的服务集合,适用于不同的用途。由于涉及的范围有限,我们不会看到大多数服务,只会集中于与 DevOps 相关的服务。
Google App Engine
直到现在,我们一直在使用 DevOps 领域的一个方面,即IaaS。Google Cloud 平台还提供了一种名为平台即服务(PaaS)的服务。在 IaaS 模型中,我们不需要担心底层基础设施:配置机器、安装软件、修补软件。使用Google App Engine(或任何其他主要的 PaaS),我们可以忘记基础设施的操作,专注于应用程序的开发,将底层基础设施交给 Google 处理。我们不需要启动机器并安装 Java 来运行基于 Spring Boot 的应用程序,而是只需指定我们希望运行一个 Java 应用程序,GCP 会处理其他一切。
这款产品——Google App Engine,满足了大多数小型到中型项目的需求,但在本书中,我们将重点讨论维护 IaaS 所涉及的 DevOps。
Google App Engine 还为我们提供了诸如用户管理等功能,这是所有应用程序中经常遇到的问题。
机器学习 API
Google 一直以其在技术产品上的创新而闻名。它改变了人们使用电子邮件的方式(通过 Gmail),也改变了人们使用手机的方式(通过 Android)。
关于机器学习,它们也通过一套创新的 API 震撼了世界,用户可以使用这些 API 来处理图像(使用视觉 API)、翻译文档(使用翻译 API),并通过自然语言 API 分析大量文本数据。
我看到的一个关于视觉 API 的最惊人的用法是,一家公司需要为其客户做一定程度的照片 ID 验证。问题是,很多人上传无效图像(随机图像,甚至是部分面部被遮挡或类似的图像),于是我们使用了视觉 API 来识别那些包含面部且没有胡须、帽子或任何配饰(除了眼镜)的图像。
结果是,做身份验证的人只专注于有效的图像,而不必在继续验证之前对其进行有效或无效的分类。
大数据
大数据现在是一个重要的领域。每个人都在努力利用大数据探索新商业领域,或在传统业务中释放其潜力。
Google Cloud Platform 提供了一套大数据 API,使用户能够处理几乎任何大数据任务。通过像 BigQuery 这样的工具,数据分析师可以在几秒钟内对 TB 级别的信息进行查询,而无需设置大规模的基础设施。
一般来说,来自 Google 的大数据 API 被称为 DevOps 世界中的“无操作工具”(no-ops tools):它们不需要用户进行维护,因为这些工具已经被集成到 Google 中。这意味着,如果一个大查询需要大量的处理能力,Google 会负责透明地将这些计算能力提供给用户。
其他云服务提供商
不幸的是,我们在一本书中能讲解的概念有限,因此这次我们将重点介绍 AWS 和 GCP,因为它们是市场上功能最全的云服务提供商。
我总是尝试以开放的心态看待技术,以下是我认为你应该了解的三个云服务提供商:
-
DigitalOcean
-
Heroku
-
Azure
他们提供的服务非常丰富,且都紧跟 DevOps 和安全的新趋势。
Heroku
Heroku 的核心理念就是这句话:构建应用,而非基础设施。这是一个非常有力的信息。基本上,Heroku 全力推动PaaS(平台即服务)概念,让你避免维护底层基础设施:只需指定你想要运行的内容(例如,一个 Node.js 应用程序)以及规模。
通过这一强大的理念,Heroku 让你轻松地通过几个点击部署应用程序实例、数据库或通信总线(例如 Kafka),而无需像使用 DevOps 工具(如 Ansible、Chef 或类似工具)那样进行繁琐的配置。
Heroku 是初创公司首选的云服务提供商之一,因为相比使用 AWS 或 Google Cloud Platform,你可以节省大量时间,因为你只需专注于应用程序,而非基础设施。
DigitalOcean
DigitalOcean 是一个即使不如 AWS 或 GCP 知名,但为中小型组织提供了一个非常有趣的替代方案的云服务提供商。他们开发了一个非常强大的概念:droplet。
基本上,droplet 是一个可以运行你的软件并通过某些配置连接到不同网络(私有或公共)的组件。
为了创建一个 droplet,我们只需要定义几个内容:
-
镜像(操作系统或一键镜像)
-
尺寸
-
区域
一旦你选择了配置,droplet 便开始运行。这非常简单有效,这也是公司通常所追求的。
Azure
Azure 是微软推出的云系统平台,也是过去几年增长最快的云服务提供商之一。正如预期的那样,Azure 是运行基于 Windows 的应用程序的特别优秀平台,但这并不意味着我们可以忽视它运行 Linux 应用程序的能力。
他们的产品目录和 AWS 或 Google Cloud Platform 一样全面,完全没有理由不选择 Azure 作为你的系统云服务提供商。
Azure 也是市场上最年轻的云服务提供商之一(自 2013 年广泛推出),因此它有一个优势,就是能够解决其他提供商所面临的问题。
摘要
到目前为止,我们展示了 AWS 和 GCP 的特点,并介绍了一些在构建系统时非常有趣的其他提供商。市场上有众多竞争者的一个优点是,每个提供商都有自己的强项,我们可以通过使用 VPN 将它们组合起来,在不同的提供商之间创建一个庞大且扩展的虚拟数据中心。
在本书的其余部分,我们将特别关注 AWS 和 GCP,因为它们对于一本 DevOps 书籍来说具有最有趣的特点(当然不能忽视其他云服务提供商,但请记住,篇幅有限)。
我们还将特别关注容器集群,例如 Kubernetes 或 Docker Swarm,因为它们无疑是未来的趋势。
第三章:Docker
多年来,开发和运维之间的接触点一直是将新版本应用程序部署到生产环境时的一个问题源。不同的编程语言生成不同类型的制品(Java 的 war 或 JAR,Node.js 的源代码),这导致了在推出新版本时程序的异构性。
这种异构性导致了定制化的版本发布解决方案,这些解决方案往往像是巫术,带有奇怪的习惯,例如凌晨 4 点发布以避免系统中断,或创建容易出错的 bash 脚本,这些脚本比软件本身更难维护。问题除了复杂性外,还在于新员工需要适应你的系统,这总是引入我们大多数时候未意识到的风险,直到某些事情出错。
Docker 来拯救我们。有了 Docker,我们可以生成一个可部署的制品,这不仅仅是你构建的软件,还有它的运行时。如果你要部署一个 Java 应用程序,通过 Docker,你将打包应用程序和将要运行你的应用程序的 Java 版本。
听起来像是一个梦想:一个受控环境,从开发到 QA,再到生产(有时会在预生产环境进行检查)作为一个制品被推广,这个过程是可重复的,唯一在不同环境间变化的是配置,通常是通过环境变量注入的。这不是梦想;这是 2017 年的现实,在本章中,我们将快速学习如何在 Docker 中运行容器并构建镜像,速度快得如同光速。
在本章中,我们将覆盖以下主题:
-
Docker 架构
-
Docker 客户端
-
构建
docker images -
Docker 注册中心
-
卷(Volumes)
-
Docker 网络
-
Docker Compose
我们还将介绍docker-compose,这是一个用于组合多个容器的工具,这样我们就可以在开发机器上组成我们的系统,模拟生产配置,或者至少接近组件间的连接,但在此之前,我们还将深入探讨 Docker 网络:我们如何选择最合适的网络来支持我们的系统,以及 Docker 提供的不同网络之间的主要区别是什么?
Docker 的另一个有趣特点是镜像的构建方式:基本上,我们选择一个基础镜像(我们将了解如何构建一个),然后通过一组精简的命令,我们可以构建一个 Docker 文件,这基本上是一个脚本,用于指导 Docker 根据我们需要的配置来构建我们的镜像。
Docker 架构
我学习的一种偏好方式是通过实验。为了说明 Docker 架构,我们将展示一个示例,但首先,我们需要安装 Docker 本身。在这个案例中,我正在使用 Mac,但在docs.docker.com/engine/installation/上,你可以找到适合你需求的发行版,并且有一套非常清晰的安装说明(通常是需要安装的包)。
安装 Docker 后,运行以下命令:
docker run hello-world
一旦完成,输出应该和以下内容非常相似:
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
78445dd45222: Pull complete
Digest: sha256:c5515758d4c5e1e838e9cd307f6c6a0d620b5e07e6f927b07d05f6d12a1ac8d7
Status: Downloaded newer image for hello-world:latest
Hello from Docker!
这条消息显示你的安装似乎工作正常。
为了生成这条消息,Docker 执行了以下步骤:
-
Docker 客户端联系了 Docker 守护进程。
-
Docker 守护进程从 Docker Hub 拉取了
hello-world镜像。 -
Docker 守护进程从该镜像创建了一个新容器,运行生成当前输出的可执行文件。
-
Docker 守护进程将输出流传输到 Docker 客户端,然后客户端将其发送到你的终端。
如果你想尝试更具挑战性的操作,可以运行一个 Ubuntu 容器,命令如下:
$ docker run -it ubuntu bash
使用免费的 Docker ID,在cloud.docker.com/上分享镜像,自动化工作流,等等。
获取更多示例和想法,访问:docs.docker.com/engine/userguide/。
如你所见,hello-world 镜像向你展示了运行前面命令时发生的情况。
这里引入了一些新概念:
-
Docker Hub:这是一个中央仓库,既有公共也有私有部分,用户可以将本地构建的镜像推送到这里。Docker 镜像库用于在不同的部署阶段(甚至在不同系统之间)传输镜像。
-
层:Docker 镜像由层组成。层基本上是有序的文件系统差异。Docker 镜像是这些层的堆叠,最终形成镜像。当你更改一个已有镜像中的文件时,会创建一个新层,但镜像的其余层会被复用,因此我们可以节省大量(相信我,真的是很多)空间。
-
Docker 守护进程:Docker 遵循客户端-服务器架构。在这种情况下,Docker 守护进程是服务器端,可以通过表现状态转移(REST)API 进行操作。
-
Docker 客户端:Docker 客户端是一个命令行接口(CLI),用于操作 Docker 守护进程。它可以是本地的,也可以是远程的。
最后三个概念是草拟 Docker 架构的关键。请查看以下图示:

客户端/服务器架构在软件中占主导地位。你可能认为这种架构对于像 Docker 这样的系统来说是过度设计,但它实际上为你提供了很多灵活性。例如,在前面的图示中,我们可以看到 Docker CLI(客户端)如何管理本地的 Docker 守护进程实例,同时也能通过设置一个名为 DOCKER_HOST 的环境变量与远程守护进程通信,在此案例中,DOCKER_HOST 的值为 62.112.42.57。
Docker 的一个关键点是它完全利用了 Linux 内核的虚拟化,使得目前无法在 Windows 或 Mac 上运行 Docker(因为它使用了 Linux 内核的能力)。解决方案是创建一个运行 Linux 的虚拟机来运行 Docker 守护进程,CLI 会与虚拟机通信来执行 Docker 命令。
例如,在 Mac 上,Docker 的旧版本使用名为 Boot2Docker 的分发版来运行 Docker 守护进程,而 Docker 的新版本则使用名为 HyperKit 的轻量级虚拟化解决方案。
Docker for Windows 使用一种与 Mac 上相同的虚拟化技术,因此对于 Mac 所做的所有假设也适用于 Windows。
Docker 内部结构
到目前为止,我们已经了解了 Docker 在整体架构方面的工作原理,但 Docker 守护进程在操作系统层面上发生了什么呢?
粗略地说,Docker 为你的应用程序提供了一个运行时环境:你可以限制容器使用的核心数量和内存量,但归根结底,运行容器的内核和运行宿主机的内核是一样的。
证明这一点的是 Docker 组织镜像的方式:它计算文件系统的差异,并将其打包成可以重用的层。我们来拉取一个相当大的镜像(不是前面示例中的 hello-world):
docker pull ubuntu
这将产生以下输出:
Using default tag: latest
latest: Pulling from library/ubuntu
d54efb8db41d: Pull complete
f8b845f45a87: Pull complete
e8db7bf7c39f: Pull complete
9654c40e9079: Pull complete
6d9ef359eaaa: Pull complete
Digest: sha256:dd7808d8792c9841d0b460122f1acf0a2dd1f56404f8d1e56298048885e45535
Status: Downloaded newer image for ubuntu:latest
如你所见,Docker 已经拉取了五个层次,这基本上告诉我们 Ubuntu 镜像是通过五个步骤构建的(虽然不完全正确,但这是一个很好的方式)。现在,我们将运行一个 Ubuntu 实例。在 Docker 中,镜像的一个实例就是我们所说的容器,镜像和容器之间的主要区别是顶部的可写层(在 Docker 中,层是以只读模式堆叠起来组成镜像的,就像几个补丁文件中的差异)。让我们来演示一下:
docker run -it ubuntu /bin/bash
前面的命令在 Ubuntu 镜像的实例中运行 /bin/bash。i 和 t 标志让你像使用虚拟机一样使用容器,分配一个虚拟终端(t 标志)并创建交互式会话(i 标志)。现在,你可以看到你的提示符已经变成了如下所示:
root@329b2f9332d5:/#
它不一定完全相同,但应该相似。请注意,你的提示符现在是一个 root 提示符,但不要太兴奋;它仅仅是在容器内。
创建一个文件来更改文件系统:
touch test.txt
现在可以使用exit命令断开与容器的连接。
正如您所看到的,提示符已返回到您的系统提示符,如果您运行docker ps,您会看到没有正在运行的容器,但是如果您运行docker ps -a(显示所有容器,而不仅仅是正在运行的容器),您应该看到类似以下内容:

这是一个已从镜像创建但不再运行的容器。正如我们之前所说,此容器与镜像之间唯一的区别是顶层可写层。为了证明这一点,我们将从几分钟前运行的容器中创建一个新的镜像:
docker commit 329b2f9332d5 my-ubuntu
在这种情况下,我正在使用引用329b。因为它是前面图片(docker ps -a的输出)中显示的,但您需要将哈希更改为您的输出中显示的哈希。公平地说,您不需要全部输入,只需几个字符即可完成任务。如果一切顺利,该命令应输出一个SHA256校验和,并将控制权返回给您。现在运行docker images(列出 Docker 中的镜像),输出应类似于以下内容:

正如您所看到的,这里有一个名为my-ubuntu的新镜像,我们刚刚创建。
现在我们想要检查ubuntu镜像和my-ubuntu镜像之间的差异。为了做到这一点,我们需要检查每个镜像的层并查看差异。我们要使用的命令是docker history,并将镜像名称作为第三个参数。
首先,对于ubuntu镜像:

然后对于my-ubuntu:镜像(刚从ubuntu创建):

非常有启发性。镜像my-ubuntu与ubuntu完全相同,只是顶层可写层我们刚刚通过登录到机器并创建文件创建的。这非常聪明,因为尽管这两个镜像都使用大约 130 MB 的空间,但第二个镜像额外使用的空间只是在本例中使用的顶层,仅为 5 字节,导致这两个镜像使用的是 130 MB 和 5 字节的空间。这也产生了我们之前讨论过的副作用:容器与镜像完全相同,只是顶层可写层不同,因此运行容器的实例只使用 5 字节的空间。正如您所看到的,创建 Docker 的工程师考虑到了一切!
Docker 如何将镜像存储在硬盘上的方式是存储驱动程序的责任:Docker 可以使用不同的驱动程序以不同的方式(以及位置,例如 AWS 中的 S3)存储镜像,但是最常见的用例,即默认驱动程序,将镜像存储在硬盘上,并为每个层创建一个文件,文件名为层的校验和。
Docker 客户端
我们在前一节中已经使用了 Docker 客户端,但我们需要深入了解 Docker CLI 可以提供的选项。我最喜欢的学习方式是通过实验,而我们将在这一节中从上到下建立概念(更多是拆解,而非构建),所以我建议你按顺序完整阅读这一节,不要跳过任何部分,因为后面的示例将会基于前面的内容。
如果你之前稍微了解过 Docker,你会发现这些命令非常冗长,并不像你想象的那么直观。最常见的用例是以下组合:
docker run -i -t <docker-image>
这个命令基本上做了一件简单的事:它以交互模式运行一个容器并分配伪终端。这使得我们能够与容器交互并执行命令(并非每个镜像都适用,但对于所有 Linux 发行版的基础镜像来说是成立的)。让我们看看这意味着什么:
docker run -i -t ubuntu
这应该会返回一个类似于以下的提示:
root@248ff3bcedc3:/#
刚刚发生了什么?提示符变成了 root,并且主机部分有一个奇怪的数字。我们现在在容器内。基本上,现在我们可以运行将在容器内执行的命令。要退出容器,只需键入exit,控制权将返回到主机的终端,容器会继续在后台运行。
大多数时候,前面的命令就能满足我们的需求,但有时我们希望将容器运行在后台:假设你启动了一个 Jenkins 服务器,并且不想让终端一直挂在它上面。为了做到这一点,我们只需要添加-d选项(守护进程模式),并去掉-i和-t选项:
docker run -d jenkins
一旦镜像被拉取并开始运行,控制权就会返回到你的终端。输出的最后一行应该是类似下面的一串长字符:
9f6a33eb6bda4c4e050f3a5dd113b717f07cc97e2fdc5e2c73a2d16613bd540b
这是正在运行的容器的哈希值。如果你执行docker ps,将会产生类似的输出:

注意,截图中CONTAINER ID下的值与前一个命令的哈希值的前几位数字相匹配。
从理论上讲,我们已经运行了一个 Jenkins 实例,如前面的图片所示,它正在监听端口8080和端口50000。让我们尝试用浏览器访问http://localhost:8080。没有反应。基本上,我们的浏览器无法打开该 URL。
这是因为我们没有告诉 Docker 将容器端口绑定到主机机器的本地端口。为了做到这一点,我们需要先停止容器,然后带上一个特殊的参数重新启动它。
现在是时候学习如何停止容器了。我们这里有两个选项:
-
停止容器:通过停止选项,我们向容器中的主进程发送
SIGTERM信号,并等待它完成(有一个宽限期)。然后,我们发送SIGKILL信号。 -
杀死容器:使用 kill 选项时,我们向容器中的主进程发送
SIGKILL信号,这会强制容器立即退出,而无法保存状态。
在这种情况下,选择哪个并不重要,但请小心。当你在生产环境中运行时,确保在执行此操作前可以安全地停止容器,因为使用停止选项时,我们允许正在运行的软件保存当前的事务并优雅地退出。在这种情况下,我将要杀死容器:
docker kill 9f6a
Docker 很聪明。我不需要指定完整的容器标识符,仅用几个字符,Docker 就能识别容器(或在其他命令中识别镜像)并将其杀死。
如果你记得之前的例子,当我们杀死一个容器时,会留下一个层,进入一个 dead 状态的容器,我们可以通过添加 -a 选项来探索它,使用 docker ps 命令。对于这个例子,我们也将使用以下命令删除这个层:
docker rm 9f6a
就这样。容器在我们的主机中从未存在过。
现在,回到 Jenkins 的例子,我们希望以一种能够从浏览器访问正在运行实例的方式来运行 Jenkins。让我们修改一下前面的命令并解释原因:
docker run -p 8080:8080 -p 50000 -d jenkins
几秒钟后,如果我们在浏览器中访问 http://localhost:8080,我们应该能看到 Jenkins 的初始配置页面,它会要求输入初始密码才能继续。
让我们先解释一下前面的命令。我们可以看到一个新选项:-p。如你所料,-p 是来自端口。实际上,你可以将 -p 改为 --port,一切照常运行。使用 -p 选项,我们将主机(你的机器)上的端口映射到容器中。在这个例子中,我们将主机的端口 8080 映射到容器的端口 8080,将主机的端口 50000 映射到容器的端口 50000,但如果我们想映射不同的主机端口,该怎么做呢?嗯,这其实非常简单:
docker run -p 8081:8080 -p 50001:50000 -d jenkins
运行上述命令后,我们有两个 Jenkins 实例在运行:
-
第一个实例暴露在你机器的端口
8080上。 -
第二个实例暴露在你机器的端口
80801上。
请注意,尽管我们没有使用端口 50000,我将其更改为 50001,因为你的机器上的端口 50000 已经被我们之前运行的第一个 Jenkins 实例占用。
如你所见,Jenkins 要求输入密码,而 http://localhost:8080 的初始网页上写明密码可以在日志或文件系统中找到。重点是日志,使用 Docker,我们可以随时提取由守护进程注册的任何容器的日志。让我们尝试一下:
docker logs 11872
在我的情况下,运行在端口 80801 上的 Jenkins 实例的 ID 以 11872 开头。执行上述命令应该能提取 Jenkins 的启动日志,我们可以用来进行故障排除,或者在此情况下,恢复用于初始化 Jenkins 的密码。
Docker 中另一个有趣且常见的选项是将环境变量传递给容器内运行的应用程序。如果你仔细想想,配置 Docker 容器内的应用程序只有三种方式:
-
环境变量
-
一个包含数据的卷
-
从网络获取配置
让我们看一下来自 Docker Hub 的官方 MySQL 镜像:
MySQL 是一个流行的数据库服务器,它也已经被 dockerized(容器化)。如果你稍微浏览一下文档,你会发现其中的一个配置选项是 MySQL 数据库的 root 密码。公平地说,快速入门示例指向了正确的方向:
docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql
这里的新选项是 -e。这个选项允许你将环境变量传递给容器,并指定你希望设置的值,格式为 = 后跟值。运行完前面的命令后,我们将执行另一个命令:
docker inspect caa40cc7d45f
在这个例子中,caa40cc7d45f 是在我的机器上运行 MySQL 时得到的 ID(你可能会得到不同的 ID)。终端中应该会输出一个巨大的 JSON,但其中有一个特别的部分,Config,里面有一个子部分叫做 Env,它应该与以下内容非常相似:
...
"Env": [
"MYSQL_ROOT_PASSWORD=my-secret-pw",
"no_proxy=*.local, 169.254/16",
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
"GOSU_VERSION=1.7",
"MYSQL_MAJOR=5.7",
"MYSQL_VERSION=5.7.17-1debian8"
],
...
就是这样。我们之前传递的环境变量 MYSQL_ROOT_PASSWORD 现在可以作为环境变量在容器内访问。
在 docker inspect 命令中,有很多非常有价值的信息。只要浏览一下,你可能会对其中的大部分信息感到熟悉:它主要是 Linux 术语。
到目前为止,我们已经浏览了截至 2017 年 1 月最常见的命令。如你所知,软件的发展非常迅速,到你阅读这本书时,Docker 已经加入了新的版本(比如 secrets)。检查当前情况的最佳方式是通过 www.docker.com 上的文档,在我看来,它相当全面。你当前 Docker 安装的命令参考也可以通过 docker help 命令获得。
构建 Docker 镜像
在前面的章节中,我们使用 Docker 的 commit 命令构建了一个镜像。虽然这方法可行,但我看到一个大问题:它不可重复。当镜像中的软件由于新漏洞或版本更新被修补时,没有一种简单的方法可以反复重建镜像。
为了解决这个问题,Docker 提供了一种更好的构建镜像的方式:Dockerfile。
Dockerfile 是一个包含一组有序命令的文件,这些命令可以将镜像准备好以供使用。诸如安装软件、升级内核版本以及添加用户等常见操作都可以在 Dockerfile 中进行。让我们来看一个例子:
FROM node:latest
RUN mkdir -p /app/
WORKDIR /app/
COPY package.json /app/
RUN npm install
COPY . /app
EXPOSE 8080
CMD [ "npm", "start" ]
如果你在 IT 领域工作了几年,实际上你不需要解释发生了什么,但我们还是确保大家都在同一页面:
-
我们是基于最新的 Node.js 镜像创建镜像。
-
在
/app中创建了一个新文件夹。我们的应用将安装在那里。 -
工作目录被设置为这个新文件夹。
-
复制
package.json并安装 Node.js 依赖项。记住,我们已经将工作目录设置为/app,所以RUN命令将在/app文件夹中执行。 -
复制剩余的源代码。
-
将端口
8080暴露给外部世界。 -
运行
npm start。
一旦做几次就会变得非常简单。需要记住的一点,可能会让初学者抓狂的是:CMD 和 RUN 的区别。
在前面的 Dockerfile 中,我们有时使用 RUN,有时使用 CMD,但它们似乎执行相同的操作:运行一个命令。其实有一个区别:
-
RUN:在构建镜像时运行此命令。 -
CMD:这将在基于生成的镜像启动的容器中运行该命令。
此外,RUN(通常)会创建一个新的层,而 CMD 使用容器的可写层。
现在,是时候测试之前的 Dockerfile 了。在构建镜像之前,我们需要构建一个小的 Node.js 应用程序,这个程序将作为镜像中运行的软件。创建一个新文件夹并添加以下三个文件:
-
package.json -
index.js -
Dockerfile(之前的那个)
package.json的内容如下:
{
"name": "test",
"version": "1.0.0",
"description": "Test",
"main": "index.js",
"scripts": {
"start": "node index.js"
},
"author": "Test",
"license": "MIT"
}
index.js 的内容如下:
console.log('Hello world!')
现在,将之前的文件和之前描述的 Dockerfile 放在同一个文件夹中,运行以下命令:
docker build . -t my-node-app
几秒钟后,您的镜像将准备好使用。让我们检查一下。如果您使用docker images命令列出您的镜像,应该可以看到一个名为my-node-app的镜像。现在基于这个镜像创建一个容器:
docker run my-node-app
你应该会看到类似以下的内容:
npm info it worked if it ends with ok
npm info using [email protected]
npm info using [email protected]
npm info lifecycle [email protected]~prestart: [email protected]
npm info lifecycle [email protected]~start: [email protected]
> [email protected] start /app
> node index.js
hello world!
npm info lifecycle [email protected]~poststart: [email protected]
npm info ok
如你所见,在高亮部分,我们的应用程序输出显示在这里。
Dockerfile 参考
如前所述,Dockerfile 非常简单,如果有任何疑问,Dockerfile 语言的官方文档非常详尽。
一般来说,创建 Dockerfile 使用的语言非常类似于几年前 Windows 的批处理语言(.bat 文件)。
让我们看一下最常用的命令:
FROM | 该指令用于指定基础镜像。每个 Docker 镜像都是从基础镜像开始创建的(您可以从正在运行的 Linux 发行版创建基础镜像)。 |
|---|---|
COPY | 如你所料,COPY 允许你将文件和文件夹复制到镜像中。例如,我们可以将我们的应用程序、war 文件或任何其他将在镜像分发时一起打包的工件复制进去。 |
| ADD | 这个指令与 COPY 完全相同,但有三个不同之处:
-
文件的来源可以是一个在复制之前下载的 URL。
-
文件的来源可以是一个打包文件(例如 TAR 文件),该文件将在镜像文件系统中解压。
|
RUN | 该命令在镜像中运行一个命令。例如,它可以用来在镜像中安装软件。它每次都会在 Docker 镜像中创建一个新的层,因此要小心,并尽量将RUN命令保持在最低限度。 |
|---|---|
CMD | 这是当镜像实例化为容器时运行的默认命令。正如在前面的例子中所看到的,我们使用CMD来执行npm start,该命令会运行node index.js(参考package.json)。它不会创建新层,因为它使用顶部的可写层来存储更改。 |
ENTRYPOINT | ENTRYPOINT类似于CMD,但它会覆盖 docker 镜像中的默认命令/bin/sh -c。为了覆盖指定的入口点,你需要在运行镜像实例时传递--entrypoint标志。ENTRYPOINT非常适合将容器配置为命令行工具,因为你可以将一个相当复杂的命令和复杂的设置打包在一个容器中。 |
MAINTAINER | 使用MAINTAINER,你可以指定镜像的维护者(还可以指定电子邮件)。 |
EXPOSE | 该命令暴露了第一个参数指定的端口,以便容器可以监听该端口。实际上,它并不会在docker客户端主机上暴露该端口,因此用户必须传递-p标志才能访问指定的端口。 |
使用这些命令,你几乎可以构建任何你想要的内容,尤其是RUN命令,它允许用户在容器内运行任何命令,使我们能够运行脚本(如python、bash和ruby)或使用包管理器安装软件。
除了前述指令外,Dockerfile 语言还支持添加环境变量、卷以及其他一些功能,使其功能非常强大。
Docker 仓库
在上一节中,我们创建了一个安装并准备好使用的全新镜像(在这个例子中,是一个非常简单的Hello world Node.js 应用程序)。
现在,我们需要分发这个镜像,以便它可以在我们部署管道的所有阶段安装,或者甚至供其他开发者使用。Docker 不仅适用于运行应用程序,它也是一个非常有趣的选择,用来创建其他开发者也能受益的命令行工具。
为了分发镜像,我们必须依赖导出/导入镜像或使用仓库。仓库基本上是一种软件,允许我们存储和分发 Docker 镜像。仓库有两种类型:
-
公共仓库
-
私有仓库
让我们来看看不同的仓库类型。
公共仓库
最著名的公共仓库是 Docker Hub。它是每个 Docker 安装都默认知道的官方仓库。此外,它还提供私有仓库,但最有趣的功能是所有官方镜像都可以在 Docker Hub 上获取。
让我们看看如何使用它。首先,您需要创建一个账户。注册后,创建一个新的仓库:

这个仓库托管了一个名为modern-devops的镜像,我们将向其中推送一个镜像。一旦创建完成,您可以看到 Docker Hub 建议您使用以下命令来拉取镜像:
docker pull dagonzadub/modern-devops
在您的情况下,dagonzadub需要替换成您的用户名。显然,我们不会拉取一个还不存在的镜像,所以我们先推送一个镜像。在前面的部分,我们创建了一个名为my-node-app的镜像。我们将使用这个镜像来测试 Docker Hub。Docker 依赖标签系统来知道将镜像推送到哪里或从哪里拉取。由于我们正在使用default注册表,因此无需指定 URL,但需要指定用户和仓库名称。如果您没有删除之前创建的镜像,请运行以下命令:
docker tag my-node-app dagonzadub/modern-devops
然后,运行这个命令:
docker push dagonzadub/modern-devops
几秒钟后(根据您的上传速度,可能几分钟),您的镜像就会出现在 Docker Hub 上。由于我们将其标记为public,任何人都可以拉取并使用您的镜像。
私有注册表
那么,如果我们想将镜像存储在我们基础设施中的私有注册表里会发生什么呢?
好的,我们有一些选择。如果我们使用云服务提供商,例如 Google Cloud Platform 或 Amazon Web Services,它们提供的 Docker 注册表仅在您的账户内可以访问,您还可以指定镜像所在的区域(记住,我们处理的数据类型可能需要遵守严格的合规规则,规定我们应该存储数据的位置)。
在 AWS 中,容器注册表被称为EC2 容器注册表(ECR),在 GCP 中,它被称为容器注册表。如果您的基础设施在这些私有云平台之一,我鼓励您使用它,因为您可以利用平台提供的访问控制。
有时,我们可能会发现自己处于无法使用云服务提供商的情况,因为我们的系统必须部署在本地。这时,我们就需要使用一个私有的本地 Docker 注册表。
现在,市场上有很多选项,但很可能随着越来越多的公司使用 Docker,未来几个月或几年市场会进一步扩大。
在所有的注册表选项中,有三个我特别感兴趣:
Quay:这是目前市场上的一个完整注册表(截至本文写作时)。它有一些有趣的功能,其中可能最有趣的是能够扫描镜像,寻找已安装软件的安全漏洞。它还可以根据您的 git 仓库中的变化构建镜像,因此如果您的 Dockerfile 在 GitHub 中被修改,Quay 会自动触发构建并部署新的镜像版本。Quay 并非免费,使用它需要购买许可证。
注册表:这是一个普通概念的简单名称。它是注册表 API 的官方实现,并以容器的形式打包。它默认没有界面或访问控制,但它完成了工作。它还提供存储管理驱动程序,因此我们可以将镜像部署到 S3 或 Google Cloud Storage 的存储桶中,以及许多其他选项。Registry 是免费的,可以从 Docker Hub 拉取。
Docker Trusted Registry:这是 Docker 企业版的一部分。像几乎所有其他商业注册表一样,它提供静态容器分析以及存储管理驱动程序。Docker Trusted Registry(DTR)不是免费的,因此需要支付许可证费用才能使用。
Docker 数据卷
到目前为止,我们已经看到如何创建镜像,如何将镜像存储到注册表中,以及 Docker 镜像的工作原理(层和容器与镜像的区别)。
任何应用程序的一个重要部分就是存储。通常情况下,Docker 应用程序应该是无状态的,但随着新的编排软件的出现,例如 Kubernetes、Docker Swarm 等,越来越多的工程师正在朝着容器化数据库的方向发展。
Docker 以一种非常优雅的方式解决了这个问题:你可以像使用普通文件夹一样,将本地机器中的文件夹挂载到容器中。
这是一个非常强大的抽象,因为它利用了将数据从容器中推送出来并保存到网络附加存储(NAS)或任何其他存储技术的能力(可以使用 Google Cloud Storage 或 S3 中的存储桶作为容器中挂载的数据卷)。
让我们从基础开始。先运行一个 MySQL 数据库:
docker run --name my-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:latest
这有效。它实际上做到了预期的功能:它启动了一个包含 mysql 实例的容器。问题是,所有数据都将写入**/var/lib/mysql**,而这个文件夹被映射到容器的顶部可写层(记住,在前一节中,我们解释了容器和镜像的区别)。保存数据的唯一方法实际上是提交更改并创建一个新的镜像,但这并不可管理,当然,这不是你想要的做法。想一想:如果你在 Docker 中删除了一个文件,实际上是在顶部层进行的操作,而这个层是唯一可写的,因此实际上你并没有删除文件;你只是把它隐藏了。文件依然存在于某一层中,占用了空间,但不可见。Docker 记录的是差异,每一层本身就是上一层的差异集(想一想 Git 是如何工作的;原理是一样的)。
我们不打算将更改提交到新的镜像中,而是将 docker 主机中的一个文件夹挂载到容器中。让我们稍微修改一下之前的命令:
docker run --name my-mysql-2 -v /home/david/docker/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:latest
现在我们有了一个新的标志-v,后面跟着data:/var/lib/mysql的值。命令的含义非常简单:将/home/david/data文件夹挂载到我的容器的/var/lib/mysql路径下。
如你所料,数据文件夹,在我的例子中是/home/david/data,应该存在于你当前的目录中,因此如果它不存在,请创建它或修改路径以适应你的设置,然后启动容器。这个用例只能通过-v标志实现:将主机中的选定文件夹挂载到容器中。
现在,在数据文件夹中执行ls命令(在 Docker 主机中):
ls /home/david/data
你可以看到mysql实际上已经写入了与启动时创建的数据库对应的数据文件。
Docker 卷不限于每个容器一个,因此你可以根据需要多次使用**-v**标志,以满足你的需求。
另一种挂载容器与主机之间共享文件夹的方式是直接指定容器内的路径:
docker run --name my-mysql-3 -v /var/lib/myysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:latest
这个命令将会从我们的 Docker 主机挂载一个文件夹到容器中,但在 Docker 主机中的文件夹将由存储驱动程序和docker本身管理:
docker inspect my-mysql-3
输出是熟悉的。我们之前在前面的章节中见过它,但现在我们要寻找不同的信息。我们实际上在寻找一个名为Mounts的部分,类似下面这样(至少类似):
"Mounts": [
{
"Type": "volume",
"Name": "572c2303b8417557072d5dc351f25d152e6947c1129f596f08e7e8d15ea2b220",
"Source": "/var/lib/docker/volumes/572c2303b8417557072d5dc351f25d152e6947c1129f596f08e7e8d15ea2b220/_data",
"Destination": "/var/lib/mysql",
"Driver": "local",
"Mode": "",
"RW": true,
"Propagation": ""
}
]
这也可以通过 Dockerfile 中的VOLUME指令实现。
上面的 JSON 告诉我们哪个本地文件夹将被挂载到容器中(JSON 的Source值),并提供了一个有趣的洞察:卷已经被docker命名(JSON 的Name值)。
这意味着 Docker 跟踪所有(或曾经)挂载在任何容器中的卷,并且可以通过 API 调用列出它们:
docker volume ls
这应该产生类似以下的输出:
DRIVER VOLUME NAME
local 13b66aa9f9c20c5a82c38563a585c041ea4a832e0b98195c610b4209ebeed444
local 572c2303b8417557072d5dc351f25d152e6947c1129f596f08e7e8d15ea2b220
local 695d7cbc47881078f435e466b1dd060be703eda394ccb95bfa7a18f64dc13d41
local b0f4553586b17b4bd2f888a17ba2334ea0e6cf0776415e20598594feb3e05952
如你所料,我们也可以通过api调用创建卷:
docker volume create modern-devops
这个卷的创建方式与前一个例子相同:由 Docker 来决定将本地机器上的哪个文件夹挂载到容器中的指定路径,但在这种情况下,我们首先创建卷,然后将其挂载到容器。你甚至可以检查这个卷:
docker volume inspect modern-devops
这应该返回类似下面的内容:
[
{
"Driver": "local",
"Labels": {},
"Mountpoint": "/var/lib/docker/volumes/modern-devops/_data",
"Name": "modern-devops",
"Options": {},
"Scope": "local"
}
]
现在我们可以使用这个命名资源并将其挂载到我们的容器中,只需引用名称即可:
docker run --name my-mysql-4 -v modern-devops:/var/lib/myysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:latest
最后一个(但同样重要的)有趣用例是在卷中帮助我们在不同的容器间共享配置。想象一下,你有一个相当复杂的设置,导致 Docker 命令非常庞大,带有多个-v。Docker 为我们提供了一个更简单的方式来跨容器共享卷配置:
docker run --name my-mysql-5 --volumes-from my-mysql-4 -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:latest
这非常简单直观:my-mysql-5将以my-mysql-4的卷配置启动。
Docker 网络
网络是 Docker 的一个重要部分。默认情况下,Docker 提供了三个网络,我们可以通过执行以下命令来查看它们:
docker network ls
这应该产生类似以下的输出:

让我们解释一下不同的网络:
-
bridge: 这是默认网络。它与主机机器完全不同,具有不同的 IP 范围,在桥接模式下(主机机器作为容器的“路由器”)。创建时未指定网络的容器会附加到默认的桥接网络。 -
host: 在这个网络中,容器与 Docker 主机共享网络堆栈。如果您检查容器中的配置,您会发现它与 Docker 主机中的配置完全相同。 -
none: 这很容易猜到;容器未连接到任何网络,只连接到容器中的回环接口。
现在是看一些示例的时候了。我们将使用 busybox,它是 Docker 映像的“瑞士军刀”。它有几个 Unix 工具,我们可以从中受益,但在这种情况下,我们将从中受益的特性是它是一个功能齐全的 Linux,并且占用空间较小。
让我们运行以下命令:
docker run -it busybox /bin/sh
如果您已经按照前面的部分操作,现在您应该能够理解结果:我们获得了正在运行的容器的 root 访问权限。
接下来的步骤是在容器内部执行 ifconfig 命令。它应该会给我们两个接口:
- eth0 - 172.17.0.2
- lo - 127.0.0.1
IP 可能会改变,但您应该看到这两个接口。将 IP 与 Docker 主机上的 IP 进行比较,我们可以验证容器正在桥接网络中运行,因为 IP 和网络完全不同;在我的情况下,我的 Docker 主机上的 IP 是 10.0.0.12。
现在,让我们在另一个终端中使用 busybox 来生成另一个容器:
docker run -it busybox /bin/sh
到目前为止,我们应该有两个正在运行的 busybox 实例,并且它们应该具有连续的 IP 地址,在我的情况下是 172.17.0.2 和 172.17.0.3。如果您回到第一个 busybox 实例的终端,您可以通过 IP 地址对第二个容器进行 ping 测试。这是因为它们都属于(或连接到)相同的网络,即默认的桥接网络。
要在主机网络中运行容器,我们只需将 --network=host 标志传递给 docker run 命令,就可以了;这样我们的容器将与 Docker 主机共享网络堆栈,但是要注意,如果您使用的是 Mac 或 Windows,则 Docker 主机是一个虚拟机,所以不要尝试通过 localhost 访问它;您需要找到运行 docker 的虚拟机的 IP 地址。
用户定义的网络
在 Docker 中也可以创建自定义的隔离网络。从安全角度来看,这是很有意思的,因为它使我们能够在网络层面上隔离不同的容器,从而可以强制执行更高级别的访问控制。
要创建网络,我们只需执行以下命令:
docker network create my-network
就是这样。这是一个简单的方法,但效果如预期。正如您所知,网络是一个复杂的主题,因此 Docker 提供了自定义范围、掩码和其他参数的选项。用户定义的网络类型为桥接。
一旦网络创建完成,你可以在该网络中运行新的容器,如下所示(在一个新终端中):
docker run -it --network=my-network busybox /bin/sh
如预期,这些容器将与其他网络隔离。在这种情况下,这两个容器是启动在 bridge 网络中的。以我的情况为例,第三个容器(刚刚启动的那个)IP 地址是 172.19.0.2,而启动在桥接网络中的两个容器分别是 172.17.0.2 和 172.17.0.3。在不同网络的容器之间执行 ping 命令会导致 100% 丢包。
Docker Compose
大多数时候,Docker 就是微服务的代名词。在 Docker 中运行一个大型单体应用没有太大意义,因为整个 Docker 引擎是为了运行拆分成不同小服务的大型应用程序而设计的。虽然在 Docker 上运行单体应用没有技术限制,但当容器编排软件介入时(在后续章节中介绍),这就真的违背了容器化的目的。
在处理微服务时,开发过程中通常会同时运行多个服务,因为新服务需要依赖现有服务来执行操作。
为了实现这一设置,Docker 提供了一个名为 docker-compose 的工具,通过创建一个定义容器的 YAML 文件,它可以启动一个完整的容器生态系统。
Docker Compose 曾在 Docker 初期非常流行。如今,它仍然被广泛使用,但随着 Kubernetes 容器编排工具接管了生产环境的工作,它的使用范围逐渐缩小至开发阶段。
让我们来看一下 Docker Compose 是如何工作的:
version: '2'
services:
my_app:
build: .
depends_on:
- db
db:
image: postgres
前面的 YAML 文件是一个 docker-compose 定义。如你所见,它包含了两个组件:
-
一个 web 应用程序(当前文件夹)
-
一个数据库(postgres)
将文件保存到名为 docker-compose.yaml 的文件夹中。
这是一个应用程序连接数据库的典型案例。为了简化起见,我们的应用程序将只是一个虚拟应用(没有数据库连接),代码如下:
let dns = require('dns')
dns.lookup('db', (err, result) => {
console.log('The IP of the db is: ', result)
})
{
"name": "modern-devops",
"version": "1.0.0",
"description": "Test",
"main": "index.js",
"scripts": {
"start": "node index.js"
},
"author": "",
"license": "ISC"
}
package.json
而我们的 Dockerfile 非常简单:
FROM node:onbuild
这个 Dockerfile 会安装所需的依赖并在我们的应用文件夹根目录下运行 npm start。
如你所见,应用程序非常简单,它仅仅尝试解析名称 db,而不是连接到数据库(公平地说,我们甚至没有指定连接数据库的端口)。我们将演示 docker-compose 如何连接容器。到目前为止,工作文件夹中应该有四个文件:
-
index.js -
package.json -
Dockerfile
-
docker-compose.yaml
回到我们的 docker-compose 文件,我们可以看到在 my_app 的定义中,我们要求构建当前文件夹(构建 Dockerfile 描述的镜像),并且我们指定容器本身依赖另一个名为 db 的容器。这使得 Docker 执行操作并连接这两个容器,从而能够通过名称从 my-app 访问 db。为了实现这一点,/etc/hosts 中创建了一个条目,记录了 db 的 IP 地址,这样 my-app 就能解析它。Docker Compose 非常容易理解:它几乎是自解释的,并且使用 YAML 格式使得一切变得更加可读。现在我们需要运行它:
docker-compose up
一旦完成,它应该会输出很长的一段内容,但有些行会显示我们的成功:
my_app_1 | > [email protected] start /usr/src/app
my_app_1 | > node index.js
my_app_1 |
my_app_1 | The IP of the db is 172.20.0.2
my_app_1 | npm info lifecycle [email protected]~poststart:[email protected]
web_1 | npm info ok
高亮部分告诉我们,my_app 能通过 IP 访问 db,因为它们位于同一个桥接网络上。我们来看看这里发生了什么:
-
Docker 从 Dockerfile 构建了当前文件夹(如
my_app中指定的)的镜像 -
Docker 从 Docker Hub 拉取了
postgres镜像 -
Docker 按顺序启动了镜像:首先是
db,其次是my_app,如依赖关系中所指定的
在本书中,我们将特别强调编排技术,接着我们将在第五章《基础设施即代码》中回到 Docker Compose,届时我们将深入探讨 Docker Swarm,这时 Compose 变得非常有用。
总结
在本章中,我们从内部结构到命令行界面走访了 Docker,学习了如何操作 Docker 主机。现在,我们有足够的知识来理解在生产环境中运行 Docker 的后果和好处。我们没有讨论如何开发 Docker 插件以及不同的存储驱动,因为不幸的是,本书的篇幅有限,无法介绍所有有趣的概念,但我们已经深入探讨了 Docker,足以通过网络上可用的资源(官方文档、视频等)进一步学习。
在下一章中,我们将研究如何围绕我们的软件自动化任务:运行测试、构建镜像以及其他许多不应手动完成的任务。这种自动化被称为 持续集成,因为它允许我们的团队以无缝的方式集成新特性。
第四章:持续集成
在软件构建过程中,质量评估通常会被推到生命周期的末尾,发布之前。当团队在一个六个月的发布周期内工作时,这些缺点不如在发布周期只有几天(甚至几小时!)时那么明显,但根据我的经验,我可以告诉你,在软件开发早期就获取反馈对于将质量提高到我们可以接受的水平至关重要。
软件中存在一种误解,致使许多软件项目面临危险:软件必须是完美的*.* 这是完全错误的。想想这些真实世界中的系统:你汽车的引擎、核电站、大城市的水净化系统等等;这些系统关乎人命,并且它们也会失败。在这些系统上花费了大量资金,但无法确保完全安全,那你怎么认为你公司编写的软件就能做到完美呢?
与其将资源投入到使软件完美,不如我通过艰难的经验得出结论:更好的做法是将资源投入到构建软件的方式,使工程师能够尽可能快速地修复问题,并能够在有足够信心的情况下缩短发布周期。在本章中,我们将探讨持续集成的关键组成部分:
-
软件开发生命周期
-
传统持续集成服务器:
-
Bamboo
-
Jenkins
-
-
现代持续集成服务器:
- Drone
其目标是建立一个有效的持续集成流水线,以确保可靠性,并使我们能够更快地交付产品。
软件开发生命周期
软件开发生命周期是我们作为软件工程师的日常活动图表,等等,这本书是关于 DevOps 的;那我们为什么要谈论软件工程呢?理论上讲,DevOps 是 IT 活动的一部分,涵盖了软件组件的完整生命周期,从初期到发布再到后续的维护。如今,许多公司正在招聘 DevOps 工程师,基于招聘强化版的系统管理员,尽管这种做法有效,但它完全忽视了 DevOps 角色的最大优势:让团队中有人接触软件的所有方面,这样问题就可以快速解决,而无需涉及来自不同团队的人。
在进一步讨论之前,让我们看看软件开发生命周期是如何运作的:

这是 IT 素养中最经典且最研究透彻的软件开发生命周期,几乎每个人在大学里都经历过这一过程,并且即使我们之前没见过,它也作为一种心理模型存在于每个人的脑海中。如今,随着敏捷方法的出现,人们倾向于认为这个模型已经过时。但我认为它仍然是一个非常有效的模型,唯一变化的是规模以及不同利益相关者在之前图示中的参与度。让我们从上到下简要地了解每个步骤的目标:
-
需求分析:这是我们将遇到大部分问题的地方。我们需要在 IT 外部人员(如会计、市场营销人员、农民等)与 IT 人员之间找到共同的语言,这通常会导致术语不同,甚至商业流程被错误捕捉的问题。
-
设计:在这一阶段,我们将使用 IT 人员可以立即理解的语言设计流程,这样他们就能够高效地编码。通常,这一阶段会与需求分析重叠(如果利益相关者本身就懂 IT),这也是理想的情况,因为图表是我们正在寻找的完美中介语言。
-
开发:顾名思义,这就是软件被构建的地方。这是开发人员擅长的事情:构建符合(可能有缺陷的)规范并且能够正常工作的技术制品。这里我们需要聪明:不管我们做什么,我们的软件都不可能完美无缺,我们需要相应地进行规划。当我们在敏捷环境中工作时,“尽早交付,频繁交付”是减少错误规范影响的座右铭,这样利益相关者就能在问题变得过大之前对产品进行测试。我还认为,尽早让利益相关者参与进来是一个不错的策略,但这不是万灵药,所以无论我们做什么,我们的软件必须是模块化的,以便我们可以插拔模块以适应新的需求。为了确保我们模块的功能正常,我们编写可以快速运行的单元测试,以确保代码按照预期的方式执行。
-
测试:这是持续集成存在的地方。我们的持续集成服务器将在适当时运行测试,并尽快通知我们应用程序可能存在的问题。根据软件的复杂性,在这一阶段我们的测试可能非常广泛,但一般来说,持续集成服务器专注于运行集成测试和验收测试(也就是说,集成服务器通常会运行所有测试,因为单元测试应该是低成本的)。
-
发布:在这个阶段,我们将软件交付到所谓的生产环境中;人们开始使用软件,无论我们在前期阶段投入多少精力,都难免会出现 Bug,这也是我们设计软件时希望能快速修复问题的原因。在发布阶段,我们可以创建一些稍后将在本书中看到的东西,称为持续交付(CD)流水线,它使开发人员能够非常快速地执行构建-测试-部署周期(甚至每天几次)。
-
维护:维护有两种类型:演化性和修正性。演化性维护是通过添加新功能或改进业务流程来推动软件的发展,以适应业务需求。修正性维护是修复错误和误解的过程。我们希望将后者最小化,但不能完全避免。
测试类型
在上一节中,我们讨论了不同类型的测试:
-
单元测试:我们所说的白盒测试是模拟依赖项并测试特定代码片段的业务流程。
-
集成测试:这些测试旨在验证应用程序不同组件之间的集成,而不是广泛地测试业务逻辑。有时,当软件不太复杂时,集成测试被用作单元测试(尤其是在动态语言中),但这并不是最常见的使用场景。
-
验收测试:这些测试旨在验证业务假设,通常基于我们所称的用户故事原理,描述具有“给定假设”风格的情境。
每个测试有不同的目标,它们协同工作,但请记住以下图示:

这就是我所说的测试金字塔,背后有多年的经验(不仅仅是我的):你的软件应该有大量的单元测试,较少的集成测试,以及一些验收测试。这可以确保大部分业务逻辑被单元测试覆盖,集成测试和验收测试用于更特定的功能。此外,集成测试和验收测试通常更昂贵,因此通常建议最小化它们的使用(但前提是不降低测试覆盖率)。
当与 CI 服务器协作时,通常开发人员会在自己的计算机上运行单元测试,因为它们快速且能够发现大量潜在问题,将集成测试和验收测试留给 CI 服务器,在开发人员进行其他任务时运行这些测试。
传统 CI 服务器
在本节中,我们将介绍最传统的 CI 服务器:
-
Bamboo
-
Jenkins
它们已经存在一段时间了,尽管它们在企业界得到了广泛使用,但在与新的、更现代的 CI 服务器(如 Drone 或 Travis)相比,它们的优势正在逐渐减弱(尽管 Travis 已经存在一段时间,但它已被重新设计以支持云端工作)。
Bamboo
Bamboo是由 Atlassian 开发的专有 CI 服务器。Atlassian 是一家专注于为开发者提供工具的软件公司。像 JIRA 和 Bitbucket 这样的产品由 Atlassian 开发,并在 IT 界广为人知。Bamboo 是他们为 CI 活动提供的解决方案,并且因与其他产品的良好集成而非常受欢迎。
让我们安装它。为此,请访问 Bamboo 的主页:confluence.atlassian.com/bamboo/并按照快速入门指南中的说明操作。如你所见,安装过程非常简单,生成评估许可证并经过一些步骤(快速安装)后,你应该能在本地计算机上运行 Bamboo:

如果你点击标有“创建你的第一个构建计划”的按钮,你会发现设置 Bamboo 中的作业非常简单。在这个例子中,我们可以使用我之前创建的一个开源项目——Visigoth,它是一个带有断路器功能的负载均衡器,用于微服务之间的互联。GitHub 仓库位于github.com/dgonzalez/visigoth。
如果你想修改它,可以将其分叉到你的 GitHub 仓库中。Visigoth 是一个单一组件,彼此之间不互相作用,因此只为其创建了单元测试。在相应的字段中输入仓库的克隆 URL,在此情况下为 Git 仓库,然后提交表单。
如果你的 GitHub 账户启用了基于时间的一次性密码(TOTP)保护,你可能需要在表单的源部分选择“无认证的 Git 仓库”,而不是选择“GitHub 仓库”来创建测试计划。
一旦你完成了创建计划的步骤,它将要求你为测试计划添加任务,目前,这些任务仅包括从 Git 检出源代码。在这种情况下,Visigoth 是一个 Node.js 应用程序,因此,测试是通过执行npm test命令来运行的。为了执行此命令,我们需要添加两个type命令任务。第一个任务将用于安装应用程序的依赖项,第二个任务将用于运行测试。让我们先添加第一个任务:

如你所见,我通过点击“添加新可执行文件”并指定NPM所在路径来添加了一个可执行文件。你可以通过在安装 Bamboo 的机器的终端执行which npm来找到该路径。
你需要在安装了 Bamboo 的同一台机器上安装 Node.js 才能运行测试。当前的 LTS 版本与之兼容良好,但 Visigoth 是在 Node 6.x 上进行测试的。
现在我们将添加第二个命令,它将执行npm test来运行测试。该命令只会在前两个步骤(检出代码[Checkout Default Repository]和安装依赖[NPM install])成功后执行:

一旦保存了任务,我们就完成了执行 Visigoth 测试所需的所有操作。现在,剩下的唯一任务就是运行该作业:

如果一切正常,你应该会看到一个绿色的徽章和成功的消息。正如你看到的,我的构建在之前的运行中失败了,因为我正在调整 CI 服务器以运行 Visigoth。
你可以查看作业的日志,看看有多少测试成功通过以及其他有用的信息。如果你进一步探索,你还会看到 Bamboo 提供了不同类型的任务,比如 mocha 测试运行器,这使得 Bamboo 能够理解测试结果。目前,在当前配置下,如果任何测试失败,Bamboo 将无法识别失败的是哪个测试。我建议你尝试不同的配置,甚至不同的应用程序,以便熟悉它。正如你自己所看到的,界面非常友好,通常通过创建新任务,达到你期望的配置也相当简单。
默认情况下,Bamboo 会创建一个名为触发器的东西。触发器是一种导致测试计划执行的操作。在这种情况下,如果我们更改了作业创建时使用的 GitHub 仓库,测试计划将被触发以验证更改,确保新代码的持续集成。
另一种有趣的触发器类型是基于时间的触发器。这种类型的触发器允许我们在夜间运行构建,因此如果我们的测试需要几分钟甚至几个小时才能完成,我们可以在没人使用服务器时执行它。此类触发器帮助我避免了由于夏令时调整导致的一些错误,这些错误会导致某些测试失败,因为代码片段无法很好地处理跨时区的时间变化。
总的来说,Bamboo 能够应对各种情况,并且已经适应了现代的需求:我们甚至可以在测试通过后构建 Docker 镜像,并将其推送到远程注册表,以便后续部署。Bamboo 还能够在构建后的阶段采取行动,例如,如果构建在夜间失败,它会通过电子邮件或其他通信渠道通知我们。
Jenkins
我已经使用 Jenkins 一段时间了,我必须说,使用它让我感到非常舒适,因为我知道它是免费的、开源的,并且高度可定制。它有一个强大且文档完善的 API,使用户能够自动化几乎与持续集成相关的所有事务。在第八章,发布管理 – 持续交付,我们将设置一个持续交付管道,使用 Jenkins 以便在测试结果满意时能够透明地发布应用程序的新版本,使我们的团队能够专注于开发,并自动化所有与部署相关的活动。
Jenkins 也是模块化的,这使得开发人员可以编写插件来扩展功能,例如,在构建失败时向 Slack 渠道发送消息,或将 Node.js 脚本作为作业的一部分执行。
在可扩展性方面,Jenkins 像 Bamboo 一样,可以通过主从配置扩展到数百个节点,从而为我们的 CI 服务器增加更多的计算能力,以便并行执行一些任务。
就其本身而言,Jenkins 足以提供几本书的内容,但我们将探讨设置自动化作业以测试应用程序所需的内容。也可以为 Jenkins 编写插件,因此,实际上它的功能没有限制。
现在让我们先关注 Jenkins 的操作方面。为了运行 Jenkins,我们有两个选择:
-
以 Docker 容器的方式运行
-
将其作为程序安装在您的 CI 服务器上
现在,我们将使用 Jenkins 的 Docker 镜像进行安装,因为这是运行它的最简单方式,并且适合我们的目的。让我们开始吧。首先要做的是通过命令行运行一个简单的 Jenkins 实例:
docker run -p 8080:8080 -p 50000:50000 jenkins
这将运行 Jenkins,但要注意,所有关于配置和执行的构建信息都将存储在容器中,因此如果丢失容器,所有数据也会丢失。如果您想使用一个卷来存储数据,需要执行的命令如下:
docker run --name myjenkins -p 8080:8080 -p 50000:50000 -v /var/jenkins_home jenkins
这将创建一个可以在升级到新版本的 Jenkins 或甚至重新启动相同容器时重用的卷。运行该命令后,日志将显示类似于以下图示的内容:

这是 Jenkins 的初始密码,设置实例时需要用到它。几秒钟后,容器的日志将停止,这意味着您的 Jenkins 服务器已准备好使用。只需打开浏览器,访问http://localhost:8080/,您将看到类似于以下内容的界面:

这里是您可以输入先前保存的管理员密码,并单击“继续”按钮的位置。接下来的屏幕将询问您是否应安装建议的插件,或者您是否想选择要安装的插件。请选择建议的插件。几分钟后,它将允许您创建用户,就这样。Jenkins 正在一个容器中运行:

现在我们将创建一个新的作业。我们将使用与 Bamboo 相同的代码库,以便我们可以比较这两个集成服务器。让我们点击“创建新项目”。您将看到以下表单:

只需为项目输入名称,并选择第一个选项:自由样式项目。Jenkins 有不同类型的项目。自由样式项目是一种我们可以定义步骤的项目类型,就像我们在 Bamboo 中所做的那样。另一个有趣的选项是流水线类型,我们可以通过一个称为 DSL(即 领域特定语言)的语言定义一组步骤和阶段,创建可以保存为代码的流水线。
接下来的屏幕是我们配置项目的地方。我们将使用 Git,其存储库托管在 github.com/dgonzalez/visigoth.git 上。
如果您之前在 Bamboo 中创建了分支,则可以使用您的分支。您的配置应与以下屏幕截图所示类似:

现在我们需要使用 npm install --development 命令安装 Visigoth 的依赖项,并使用 npm test 命令执行测试,但我们是从容器中运行 Jenkins,而这个容器并未安装 Node.js。我们将利用我们的 Docker 知识来安装它。检查 Docker Hub 中 Jenkins 镜像的 Dockerfile,我们可以验证它基于 Debian Jessie(它基于 OpenJDK,但是它基于 Debian Jessie),因此我们可以在其中安装所需的软件。要安装软件的第一步是获得容器的 root 访问权限。正如您在 第二章 中所学到的,“云数据中心 - 新的现实”,我们可以在正在运行的容器上执行命令。让我们执行以下命令:
docker exec -u 0 -it eaaef41f221b /bin/bash
此命令在 ID 为 eaaef41f221b 的容器中以 UID 和 GID 为 0 的用户(在您的系统中将会有所不同,因为每个容器的 ID 都是唯一的)执行 /bin/bash。我们需要这样做是因为 Jenkins 镜像定义并使用一个名为 jenkins 的新用户,其具有已知的 UID 和 GID,因此如果未传递 -u 0 标志,则 /bin/bash 命令将由用户 jenkins 执行。
一旦我们在容器中获得了 root 权限,继续安装 Node.js:
curl -sL https://deb.nodesource.com/setup_7.x | bash -
一旦上一个命令的执行完成,运行以下命令:
apt-get install -y nodejs build-essentials
就这样。从现在开始,我们的 Jenkins 容器有了 Node.js 的安装,可以运行 Node.js 脚本。也就是说,我们应该避免在生产容器中安装软件。我们的容器应该是不可变的工件,在生命周期内不做更改,因此我们应该将这个镜像的更改提交并标记为新版本,以便将其发布到生产容器中。由于我们没有生产容器,所以我们边做边修改。
我们生产环境中的容器应该是不可变的工件:如果我们需要更改它们的状态,我们会创建新版本的镜像并重新部署,而不是修改正在运行的容器。
一旦安装了 Node.js,我们可以退出容器中的 root shell,然后回到 Jenkins 完成我们的任务。就像我们在 Bamboo 中做的一样,以下是我们运行测试所需要的步骤:

在作业配置的最底部,有一个叫做 post-build 的操作部分。这个部分允许你在作业完成后执行一些操作。这些操作包括发送电子邮件、将提交信息添加到 Git 仓库等。如我们之前提到的,Jenkins 是可扩展的,通过安装新插件,可以添加新的操作。
Jenkins 还可以通过用户输入对构建进行参数化。
一旦你添加了这两个步骤到构建中,点击保存,我们就完成了:现在你已经拥有一个完全功能的 Jenkins 作业。如果我们运行它,它应该能够成功运行 Visigoth 上的测试。
密钥管理
CI 服务器的一个功能是能够与通常依赖某种凭证(如访问令牌或类似物品)来验证用户身份的第三方服务进行通信。暴露这些密钥是不被鼓励的,因为它们可能会对我们的公司造成重大损害。
Jenkins 以非常简单的方式处理此问题:它提供了一种安全存储凭证的方法,可以将这些凭证作为环境变量注入到构建中,以便我们可以使用它们。
我们来看一些示例。首先,我们需要在 Jenkins 中创建密钥。为此,我们需要从首页进入管理 Jenkins 页面。
一旦我们到达那里,你应该看到一个非常相似的界面:

我们使用的是全局凭证存储,因为我们只是想展示其工作原理,但 Jenkins 允许你将凭证封装起来,以便你可以在不同的使用场景下限制访问权限。在 Jenkins 中,凭证除了可以注入到构建上下文外,还可以连接到插件和扩展,以便它们可以对第三方系统进行身份验证。
现在,点击左侧的“添加凭证”按钮:

在继续之前,有些字段需要我们填写,但它们非常基础:
-
类型:这是我们想要创建的秘密类型。如果打开下拉菜单,会有几种类型,从文件到证书,涵盖用户名和密码等。
-
范围:这是我们秘密的作用范围。文档不是 100%清晰(至少第一次阅读时不清晰),但它允许我们在某些情况下隐藏秘密。这里有两个选项:全局(Global)和系统(System)。选择全局时,凭据可以暴露给 Jenkins 及其子对象中的任何对象,而选择系统时,凭据只能暴露给 Jenkins 及其节点。
其余字段取决于秘密的类型。接下来,我们将创建一个用户名与密码类型的秘密。只需在下拉菜单中选择它并填写其余细节。创建完成后,它应该会出现在凭据列表中。
下一步是创建一个绑定到这些凭据的任务,以便我们可以使用它们。只需像本节开始时看到的那样创建一个新的自由风格项目,但我们将在配置任务的屏幕上停下来,特别是在构建环境部分:

现在选择用户名和密码(联合)。联合用户名和密码意味着我们在一个变量中获得完整的秘密(用户名和密码),而分开则会将秘密分成两个变量:一个用于用户名,另一个用于密码。
一旦我们选择了它,创建绑定的表单就非常简单:

我们可以选择存储秘密的变量,并且还可以选择具体的秘密。有一个单选按钮可以让你选择“参数表达式”或“特定凭据”,因为我们可以将任务参数化,让用户在触发屏幕中输入内容。为了展示 Jenkins 设计的周全,我们将添加一个构建步骤,通过将秘密回显到日志中来使用它:

点击保存按钮以保存任务并运行它。一旦任务执行完成,转到结果并点击控制台输出。如果你原本期待在这里看到秘密,Jenkins 将给你一个惊喜:

为了防止未授权用户暴露秘密,该秘密已被掩码处理。虽然这种方法并非万无一失,因为有人可能会轻易地从通过 Jenkins 检查出的应用程序中的测试中提取该秘密,但它确实为安全性提供了一定的保障,剩下的则依赖于代码审查和流程。
现代 CI 服务器
在 IT 领域,有一件事是明确的,那就是市场发展非常迅速,每隔几年,就会有一个新的趋势打破曾经被认为是完美解决方案的问题。CI 软件也不例外。在过去的几年中(考虑到本书是 2017 年写的),基础设施即代码(Infrastructure as Code)吸引了大量的关注,而在 CI 中,其对应的概念是流水线即代码(Pipelines as Code)。
Jenkins 和 Bamboo 最近已经添加了对声明式流水线的支持,但它们并不是围绕这个概念构建的。
Drone CI
Drone 可能是市场上最新的 CI 服务器。我决定在本章介绍它,因为当我在 nearForm Ltd. 了解到它时,它对我来说是一个巨大的启示。那时,我已经习惯了 Jenkins,它适用于我在职业生涯中遇到的每一个用例,从 CI 到持续交付,有时甚至作为堡垒主机,使用一种叫做回调 URL 的功能,在这个功能下,工作可以通过向特定 URL 发送 HTTP 请求来触发。
Drone 是基于容器概念构建的。Drone 中的所有内容都是容器,从服务器到测试运行的地方,最有趣的部分是,甚至插件也是容器。这使得编写新的插件以执行自定义操作变得非常容易,唯一的要求是,如果容器成功完成,必须返回 0 作为退出代码,如果不成功,则返回非零退出代码。
对于 Jenkins 或 Bamboo,编写插件需要几个小时的测试和阅读文档。而对于 Drone,我们只需要知道如何构建 Docker 镜像以及我们想要完成的任务。
请注意,Drone 仍然处于 0.5 版本,并且发展非常快速,因此在你阅读本书时,Drone 可能已经发生了显著变化,但我还是决定包括它,因为我认为它是一个非常有前途的软件。
安装 Drone
为了安装 Drone,我们将使用 docker-compose,并将其配置为与 GitHub 一起使用。
Drone 和 Docker 一样,遵循客户端-服务器架构,因此我们可以找到两个不同的组件:服务器和 CLI。我们将首先继续进行服务器部分的配置。请查看以下 docker-compose 文件:
version: '2'
services:
drone-server:
image: drone/drone:0.5
ports:
- 80:8000
volumes:
- ./drone:/var/lib/drone/
restart: always
environment:
- DRONE_OPEN=true
- DRONE_GITHUB=true
- DRONE_GITHUB_CLIENT=${DRONE_GITHUB_CLIENT}
- DRONE_GITHUB_SECRET=${DRONE_GITHUB_SECRET}
- DRONE_SECRET=${DRONE_SECRET}
drone-agent:
image: drone/drone:0.5
command: agent
restart: always
depends_on: [ drone-server ]
volumes:
- /var/run/docker.sock:/var/run/docker.sock
environment:
- DRONE_SERVER=ws://drone-server:8000/ws/broker
- DRONE_SECRET=${DRONE_SECRET}
在前面的 Docker Compose 文件中,运行了两个容器:一个是服务器,另一个是代理。在 0.4 版本之前,Drone 的主节点可以执行构建,但在此之后,需要一个代理来运行构建。在继续之前,我们需要配置一些秘密信息,这些信息通过环境变量传递给 Compose(使用${VAR_NAME}符号):
-
DRONE_GITHUB_CLIENT:如前所述,我们将使用 GitHub 作为源代码的来源,以便进行测试。在 GitHub 上注册一个新的 OAuth 应用时,这个值会提供给你。你可以在 GitHub 的设置部分创建 OAuth 应用。小心,创建 GitHub OAuth 应用时需要的参数之一是回调 URL。在这种情况下,我们将使用http://localhost/authorize,因为我们在本地计算机上工作。 -
DRONE_GITHUB_SECRET:与DRONE_GITHUB_CLIENT相同,这是在 GitHub 上创建新 OAuth 应用时提供的。 -
DRONE_SECRET:这是一个与代理和主服务器共享的任意字符串。你只需创建一个简单的字符串,但在生产环境中运行 Drone 时,确保字符串足够长,以免被猜到。
为了让 Drone 与 GitHub 集成工作,我们需要从 GitHub 接收回调。一旦我们获取到所有的值,我们只需要运行以下命令:
DRONE_GITHUB_CLIENT=your-client DRONE_GITHUB_SECRET=your-secret DRONE_SECRET=my-secret docker-compose up
在一行命令中,我们设置了所需的三个变量,并运行了docker-compose up。如果一切顺利,当你访问http://localhost时,应该能看到类似下面的窗口:

如果点击登录,Drone 应该会将你重定向到 GitHub 进行授权,然后 GitHub 会将你重定向到创建 OAuth 应用时指定的回调 URL,即你的本地 Drone 安装地址http://localhost/authorize。有时可能需要一些调整,但一般来说,非常容易让它工作。如你所见,Drone 利用 GitHub 的身份验证,因此需要一个 GitHub 账号来登录。
现在我们将继续进行 CLI 配置。只需访问readme.drone.io/0.5/install/cli/并选择适合你平台的版本,在我的案例中是 macOS。只需将二进制文件放在路径中,你就可以开始使用了。为了配置 Drone 服务器的位置,你需要指定两个环境变量:
-
DRONE_SERVER:这是你的 Drone 服务器的 URL,在这种情况下是http://localhost -
DRONE_TOKEN:登录 Drone 后,进入帐户页面并点击显示令牌。这就是你需要的值
设置好这两个变量后,执行以下命令:
drone info
这应该会显示你的 GitHub 用户名和你用来注册的电子邮件。
运行构建
Drone 在运行构建时有不同的理念:它通过触发管道来响应远程仓库中代码的变化。我们来创建一个超级简单的仓库,里面有一个非常简单的 Node.js 应用。我已经在我的 GitHub 账户上创建了这个仓库,为了让一切更加简单:github.com/dgonzalez/node-example-drone/。只需将其 fork 到你自己的账户,就可以开始了。
我们需要做的第一件事是激活你本地 Drone 安装中的项目。只需进入账户,在仓库列表中激活node-example-drone。现在,它应该像下面的截图一样出现在主屏幕上:

现在我们面临一个小问题:Drone 是为了触发通过 GitHub 发送到我们的 Drone 服务器的 webhook 而创建的。由于我们在一个私有网络中工作,我们需要以某种方式将我们的服务器暴露到互联网。在这种情况下,我们将使用一个叫做Ngrok的服务(www.ngrock.com),以便将 Drone 暴露到互联网,而在生产环境中工作时这并不是必要的,因为它应该可以通过互联网访问(或者至少通过代理访问)。只需按照说明操作,一旦在终端运行它,它应该和下面的截图非常相似:

这指定了哪个主机被转发到你的本地地址,在我的例子中是http://852cc48a.ngrok.io。只需在浏览器中打开它,检查是否可以从那里访问 Drone。
还剩下一件事,就是编辑 Drone 在我们激活时安装在 GitHub 仓库中的 webhook。你可以在 GitHub 的仓库设置中找到它。只需编辑 webhook,将 URL 从http://localhost更改为你的 Ngrok URL,在我的例子中是http://852cc48a.ngrok.io。
执行管道
现在设置完成,在做任何事情之前,先看一下 forked 仓库中的.drone.yaml文件:
debug: true
pipeline:
build:
image: node
commands:
- npm install --development
- npm test
这是我们的管道,正如你所猜测的,它会和我们的代码一起提交到仓库中。当 GitHub 将 webhook 传送到我们的 Drone 安装时,Drone 会执行此管道中的指令。由于 Drone 与容器一起工作,Drone 首先会基于我们指定的 node 创建一个镜像,并执行以下操作:
-
它会安装依赖
-
它会运行测试
如果执行这些命令的容器的退出代码是0,那么我们的构建就成功了,你可以通过推送一些更改到你的 GitHub 仓库,并观察 Drone 如何响应来进行测试。
还有一种通过 CLI 接口重新触发构建的方法(不是第一次)。打开终端,在配置好之前提到的环境变量后(如果你还没有做),执行以下命令:
drone build list dgonzalez/node-example-drone
这将返回一个已执行构建的列表。只需将dgonzalez更改为你的用户名,正如你在网页界面中看到的那样。为了重新运行之前的构建,我们可以执行以下命令:
drone build run dgonzalez/node-example-drone 1
这个命令触发了一个已构建的 Drone 构建。这在你怀疑构建因外部因素而失败时特别有用。
有时,webhook 会失败(尤其是我们与 Ngrok 的设置),但 GitHub 允许你在仓库的 webhook 部分调试这个问题。
这是管道的最简单案例。如前所述,Drone 基于插件,这些插件也是 Docker 镜像。插件列表非常全面,可以在github.com/drone-plugins找到。
假设我们想将镜像推送到 Google Cloud 中的 Google Container Registry。我们将使用来自github.com/drone-plugins/drone-gcr的插件 drone-gcr。这是我们的管道:
debug: true
pipeline:
build:
image: node
commands:
- npm install --development
- npm test
publish:
gcr:
repo: myrepo/node-example-drone
token: >
{
...
}
这里有一个两阶段的管道:它首先执行测试,一旦测试成功,就将镜像部署到 Google Cloud Registry。我们在管道中有不同的阶段可以使用:
-
构建: 用于构建测试和相关命令
-
发布: 用于将工件发布到远程仓库
-
部署: 对于持续集成非常有用,因为它允许我们以持续交付的方式部署软件
-
通知: 用于通过电子邮件、Slack 或其他任何渠道发送通知
例如,如果我们想发送一个 Slack 通知,我们只需要将以下几行添加到管道中:
notify:
image: plugins/slack
channel: developers
username: drone
记住,YAML 对制表符和空格非常敏感,因此 notify 需要与 publish 或 build 在同一级别。
其他功能
在撰写本文时,Drone 正在积极开发中,不断添加新功能,并进行一些重大重构。它还提供了其他功能,如秘密管理和支持服务。
通过秘密管理,我们可以注入加密后的秘密,这些秘密存储在数据库中,只有在我们的 Drone CLI 使用来自 Drone 服务器的有效令牌进行加密签名后,才会注入到构建中。
Drone 还提供支持服务,这些服务在测试期间与测试一起运行。当我们的集成测试依赖数据库,或需要启动像 Hashicorp Vault 这样的第三方软件,或者像 Consul 或 Eureka 这样的服务发现基础设施时,这非常有用。
预计未来 Drone 将会有更多功能,但目前它正在经历重大变化,因为它正在积极开发(与像 Jenkins 这样的成熟服务器不同,后者已经存在了一段时间)。
总结
在本章中,我们介绍了三种不同的 CI 工具:
-
Bamboo,一种商业工具
-
Jenkins,一种行业标准的开源工具
-
Drone,一款尖端技术的 CI 服务器
我们在本书中讨论了将来要使用的 Jenkins 的关键特性,但我们也展示了 Drone 如何将容器的概念融入一个非常强大的 CI 系统,尽管它还不够成熟,但我预计在未来几年将成为行业标准。
我们需要注意的重要概念已经解释过了,但总结来说,我们使用集成服务器来为我们运行测试,这样可以让开发人员不需要做这些工作,同时也能在夜间运行测试,以确保每日构建的稳定性。
在下一章,我们将探讨社区所称的 Infrastructure as Code: 基本上是一种将我们的基础设施视为代码来处理的方式,优雅地管理资源。
第五章:基础设施即代码
在前几章中,我们展示了新一代云数据中心如何帮助我们非常轻松地创建在线资源(虚拟机、Docker 仓库、加密密钥),将硬件配置周期从几周(购买、运输和安装新计算机)缩短到几秒钟。我们还看到了市场上有不同的供应商可以提供类似的功能,并且具有各自不同的优势,我们可以在构建系统时加以利用。
你已经学会了如何通过他们提供的网页界面创建资源,但这种方式的可扩展性如何呢?手动创建资源阻止了我们保持自动化的资源清单,这对于安全目的以及像管理软件组件一样管理我们的基础设施是必要的。
在本章中,你将首先学习如何通过云数据中心供应商提供的 SDK 来构建云中的资源,然后通过一个叫做Terraform的软件组件来构建,Terraform是一个管理在线资源的行业标准。我们将专注于Google Cloud Platform,原因有几个:
我个人认为,命令行界面更易于使用。
Google Cloud Platform 的试用版涵盖了大量资源,你可以在本书中使用这些资源进行实验,因为你几乎可以在全套产品中创建任何资源。
在写这篇文章时(2017 年 4 月),在云数据中心方面,Google Cloud Platform 提供了最具性价比的服务。
也就是说,AWS、Azure 或任何其他供应商也提供了非常有趣的试用账户,但遗憾的是,我们不能在一本书中涵盖所有内容。
Google Cloud Platform SDK - gcloud
Google 为我们提供了一个非常全面的 SDK,它可以用于操作 Google Cloud Platform 以及安装与云操作相关的软件组件。
我们需要做的第一件事是安装gcloud。
虽然有 Windows 版安装程序,但通常来说,对于基于 Unix 的系统(主要是 Linux 和 Mac),我们有一个可以从命令行执行的交互式安装程序,并且有一个无人值守模式(用于自动配置)。
不同的选项可以在cloud.google.com/sdk/downloads找到。
为了安装它(在我的例子中是在 Mac 上),我们需要做的第一件事是运行以下命令:
curl https://sdk.cloud.google.com | bash
这将启动在线模式下的交互式安装程序:在安装过程中,我们会被问到一系列问题。
第一个是安装目录。默认情况下,这是用户的主目录,但你可以将其更改为你选择的文件夹。选择文件夹后,它将开始下载并安装所需的基础组件。
问题是,你是否愿意通过收集匿名数据来帮助改进 Google Cloud SDK。请根据你的偏好作答。
现在,Google Cloud SDK 将开始安装核心组件。

如前图所示,Google SDK 安装了一些用于操作 Google Cloud Platform 上基本服务的软件包。安装完成后(无需执行任何操作),它会询问你是否要修改系统的 PATH 变量。只需回复 Y 并按 Enter 键,这样 gcloud 命令就可以在控制台中使用了。它会询问你要在哪个文件中修改 PATH 变量。通常,安装程序提供的默认选项已经足够好。在修改文件之前,Google Cloud SDK 安装程序会创建一个备份文件,文件名与原文件相同,扩展名为 .backup,这样你可以还原更改。
现在完成了。它会提示你启动一个新的 shell 来使更改生效。关闭终端并重新打开,检查 gcloud 命令是否可用。
现在我们已经安装了 Google Cloud SDK,是时候配置认证了。执行以下命令:
gcloud init
它会要求你登录,因此请选择“是”,这将打开一个浏览器窗口,要求你输入 Google 凭证。输入与你的试用账户相关联的凭证(如果你没有注册试用版,请在配置凭证之前进行注册)。如果你在 Google Cloud Platform 上已经创建了项目,它会要求你在控制台中选择要使用的项目。在我的例子中,我已经在第二章中配置了一个项目,云数据中心——新现实,所以我选择了名为 implementing-modern-devops 的项目。
接下来的主题是配置 Google Compute Engine。请选择“是”并选择你的可用性区域。在我的情况下,欧洲的任何地方都适合我。
完成此步骤后,我们就完成了。提示符会告诉我们已经创建了一个名为“default”的配置。这意味着 Google Cloud SDK 可以使用多个凭证,但在本例中,我们将只使用一组凭证和一个项目。
使用 Google Cloud SDK 创建资源
一旦我们设置好,就该开始创建资源了。正如你所猜测的,创建资源的命令可能会非常复杂,也可能非常简单,取决于你的需求。幸运的是,Google 工程师在创建 Google Cloud Platform 的界面时已经考虑到了这一点。
首先,你需要登录到你的 Google Cloud Platform 账户。登录后,进入 Compute Engine 并填写表单以创建新的资源。输入实例名称,选择离你最近的区域(在我这里是欧洲),选择机器类型(默认即可),API 访问(我们不需要这个,但默认设置可以),并勾选允许 HTTP 流量和允许 HTTPS 流量。在点击创建之前,请查看以下截图:

如果你查看最底部,在“创建”按钮下面,有两个链接:
-
REST 等效
-
命令行
现在,我们将重点关注命令行链接。点击它,你应该会看到一个带有一些命令的窗口。让我们解释一下它们:
gcloud compute --project "implementing-modern-devops" instances create "test-instance" \
--zone "europe-west1-c" --machine-type "n1-standard-1" --subnet "default" \
--maintenance-policy "MIGRATE" \
--service-account "[email protected]"
--scopes \
"https://www.googleapis.com/auth/devstorage.read_only", \
"https://www.googleapis.com/auth/logging.write", \
"https://www.googleapis.com/auth/monitoring.write", \
"https://www.googleapis.com/auth/servicecontrol", \
"https://www.googleapis.com/auth/service.management.readonly", \
"https://www.googleapis.com/auth/trace.append" \
--tags "http-server","https-server" --image "debian-8-jessie-v20170327" \
--image-project "debian-cloud" --boot-disk-size "10" --boot-disk-type "pd-standard" \
--boot-disk-device-name "test-instance"
第一个命令创建了虚拟机。如你所见,没有人能够轻松学会如何创建这个命令,但幸运的是,Google Cloud Platform 为你提供了每个将要创建的资源的命令,因此你可以使用 UI 来生成这些命令。也就是说,前面的命令设置了Google Cloud提供的每一个潜在设置,换句话说,我们能够运行前面的命令,得到相同的结果,无论我们在云账户中更改了什么设置。
还有一个更简短的版本:
gcloud compute --project "implementing-modern-devops" instances create "test-instance"
这个命令与之前那个非常长的命令完全相同,但假设设置是默认的(记住,你已经选择了一些参数,比如默认区域)。
另外两个命令更简单:
gcloud compute --project "implementing-modern-devops" firewall-rules create "default-allow-http" --allow tcp:80 --network "default" --source-ranges "0.0.0.0/0" --target-tags "http-server"
也看看这个:
gcloud compute --project "implementing-modern-devops" firewall-rules create "default-allow-https" --allow tcp:443 --network "default" --source-ranges "0.0.0.0/0" --target-tags "https-server"
正如你所猜测的,这些命令允许 HTTP 和 HTTPS 流量进入我们的主机,正如 UI 表单中所描述的那样。
这些是基础的基础设施即代码。我们可以将这些命令写入 bash 脚本中,然后就可以开始了;我们的基础设施将会自动为我们创建。以同样的方式,如果我们不想依赖 Google Cloud SDK,我们可以选择 REST 选项,它将向我们展示需要向 Google Cloud 发出的 HTTP 请求列表,以便创建相同的资源。如果你熟悉像 Python、JavaScript(Node.js)等编程语言,你就会知道发出 HTTP 请求以创建资源是多么简单,这样你就能像管理代码一样管理基础设施,遵循相同的生命周期。
这是管理云端资源的一大步,但它仍然不完整。想象一下这个情况:你在一家拥有相当复杂设置的公司工作,比如在不同的时区有几台机器,并且网络配置相当复杂。你怎么能一眼看出哪些机器在运行,防火墙规则是什么呢?
答案很简单:根据我们今天所知道的,这种方式不可行。在下一部分,你将学习如何使用来自 HashiCorp 的Terraform来管理不仅是资源的创建,还有不同云提供商上在线资源的完整生命周期。
Terraform
Terraform是HashiCorp开发的一款产品。HashiCorp 是一家专注于 DevOps 工具的公司,例如 Consul,一个高度可用的分布式键值存储,或 Vagrant,一个使用与生产环境相同的提供程序来重现开发环境的工具。
Terraform,顾名思义,允许你以声明式的方式在云数据中心创建基础设施,跟踪哪些内容在何处被创建,并允许你从代码角度应用更改:你的基础设施作为代码进行描述,因此,它可以遵循其生命周期。
我们需要做的第一件事是下载并安装 Terraform。只需在浏览器中打开www.terraform.io/downloads.html网址并选择你的平台,在我这里是 Mac。Terraform 是一个压缩成 ZIP 文件的单一二进制文件(据我所知,所有平台都是如此),我解压并将其放在我的路径中,在我的情况下,是/usr/local/bin/terraform。
请小心,某些 OSX 配置并不包含/usr/local/bin/在PATH环境变量中,因此你可能需要在能够从任何路径执行 Terraform 之前,手动添加它。
一旦安装完成,并且PATH变量中包含/usr/local/bin/作为以分号分隔的值之一,我们可以检查一切是否按预期工作:
terraform version
这应该返回以下输出:
Terraform v0.9.4
这确认了一切都正确无误。另请注意,现如今 DevOps 工具更新非常迅速,它们需要一天比一天做更多的事情。我们将使用最新的版本 0.9.4,但当你读到这本书时,可能会有一个更新的版本,带有新特性甚至可能有一些不兼容的更改。幸运的是,Terraform 附带了一个非常强大的文档。让我们查看所有可用的命令。只需执行这个:
terraform
这应该输出类似以下的内容:

现在,为了显示任何命令的帮助对话框,我们只需要在命令后加上标志-h。例如,我们来查看apply命令的帮助:
terraform apply -h
它将输出该命令在命令提示符下的所有可用选项列表。
创建资源
现在我们已经安装了所有要求的软件包,我们将创建我们的第一个资源,帮助我们理解 Terraform 是如何工作的以及它的强大功能。请在你的计算机上创建一个名为implementing-modern-devops的文件夹,并添加一个名为resources.tf的文件,文件内容如下:
provider "google" {
credentials = "${file("xxx.json")}"
project = "implementing-modern-devops"
region = "europe-west1-b"
}
resource "google_compute_instance" "my-first-instance" {
}
如你所见,前面的片段与 JSON 非常相似,但它实际上被称为 HCL:HashiCorp 配置语言。我们来解释一下这段代码的作用。
第一部分是我们配置凭据的地方。如你所见,Terraform 期望有一个名为xxx.json的文件,而我们现在没有该文件。如果我们查看 Google Cloud Platform 的 Terraform 官方文档,它指出我们需要从 Google Cloud Platform 的 API 管理器部分创建一个服务帐户,如下图所示:

一旦我们选择 JSON 格式创建它,文件将自动保存在我们的计算机上,包含我们操作 Google Cloud Platform 所需的凭证。
请小心。如果泄露了这些凭证,别人可能会代表你创建或销毁资源,这可能会导致重大费用或数据丢失。
将文件复制到之前创建的文件夹 (implementing-modern-devops),并将其重命名为 xxx.json,使其与我们的配置匹配。
第二部分是我们虚拟机的描述,即将在 Google Cloud 中创建的实例。在这种情况下,我们创建了一个名为 my-first-instance 的资源,类型为 google_compute_instance。我们故意没有指定任何配置,因为我想展示如何使用 Terraform 排查问题,鉴于其高质量的错误日志,排查过程非常简单。
让我们看看发生了什么。从我们项目的根目录,即 implementing-modern-devops 文件夹中,运行以下命令:
terraform plan
这个命令将描述在 Google Cloud 中创建基础设施所需的步骤。在这种情况下,它相当简单,因为我们只有一台机器,但这对于学习 Terraform 会非常有帮助。
让我们来看一下发生了什么,以及在输出中是如何解释的:
Errors:
* google_compute_instance.my-first-instance: "disk": required field is not set
* google_compute_instance.my-first-instance: "name": required field is not set
* google_compute_instance.my-first-instance: "machine_type": required field is not set
* google_compute_instance.my-first-instance: "zone": required field is not set
上述命令失败了。基本上,我们的计算实例需要四个字段,而我们没有指定:machine_type、name、zone 和 disk。在这种情况下,我们可以指定这些字段,但如果你需要检查额外的参数,关于资源 google_compute_instance 的所有文档可以在 www.terraform.io/docs/providers/google/r/compute_instance.html 查阅。
访问它并阅读内容,以便熟悉它。
我们还将指定网络接口(基本上是我们想要连接到机器的网络),因为如果现在不这样做,稍后的 apply 命令将会失败。
现在,我们将解决第一次运行时发现的问题。用以下内容替换 google_compute_instance 块:
resource "google_compute_instance" "my-first-instance" {
name = "my-first-instance"
machine_type = "n1-standard-1"
zone = "europe-west1-b"
disk {
image = "ubuntu-os-cloud/ubuntu-1704-zesty-v20170413"
}
network_interface {
network = "default"
access_config {
// Ephemeral IP
}
}
}
返回终端并再次执行 terraform plan。输出将类似于以下内容:
+ google_compute_instance.my-first-instance
can_ip_forward: "false"
disk.#: "1"
disk.0.auto_delete: "true"
disk.0.image: "ubuntu-os-cloud/ubuntu-1704-zesty-v20170413"
machine_type: "n1-standard-1"
metadata_fingerprint: "<computed>"
name: "my-first-instance"
network_interface.#: "1"
network_interface.0.access_config.#: "1"
network_interface.0.access_config.0.assigned_nat_ip: "<computed>"
network_interface.0.address: "<computed>"
network_interface.0.name: "<computed>"
network_interface.0.network: "default"
self_link: "<computed>"
tags_fingerprint: "<computed>"
zone: "europe-west1-b"
Plan: 1 to add, 0 to change, 0 to destroy.
出于空间考虑,我省略了资源说明之前的解释性文本,但基本上它告诉我们可以将此计划保存在文件中,以便将其作为参数传递给接下来我们将要运行的 apply 命令。
这使我们能够确保执行的内容与我们在计划中看到的相符,以防别人已经在计算需要更改的内容之前修改了在线基础设施,Terraform 会将资源文件中的配置与 Google Cloud 中现有的基础设施进行同步。因此,可能会发生这种情况:我们执行 terraform plan 时,别人通过另一个 Terraform 脚本或手动修改了我们的云基础设施,然后我们的 terraform apply 命令与计算出的计划不同。
一旦确认我们的 Terraform 计划是创建一台虚拟机,执行以下命令:
terraform apply
几秒钟后,脚本应该会完成并展示出已创建、已更改或已销毁的内容:
google_compute_instance.my-first-instance: Creating...
can_ip_forward: "" => "false"
... (lines omitted: they should match the ones in the plan) ...
zone: "" => "europe-west1-b"
google_compute_instance.my-first-instance: Still creating... (10s elapsed)
google_compute_instance.my-first-instance: Still creating... (20s elapsed)
google_compute_instance.my-first-instance: Still creating... (30s elapsed)
google_compute_instance.my-first-instance: Creation complete
Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
The state of your infrastructure has been saved to the path
below. This state is required to modify and destroy your
infrastructure, so keep it safe. To inspect the complete state
use the `terraform show` command.
State path: terraform.tfstate
如果一切按计划进行,我们的文件夹中应该会有一个名为 terraform.tfstate 的文件,它是我们在云端创建的虚拟基础设施的状态。我们还会有一个扩展名为 backup 的相同文件,它是我们在执行最后一次 apply 命令之前基础设施的状态。
这个文件非常重要。Terraform 可以根据云端的变更来刷新它,但无法重新构建它。有些人将此文件与 Terraform 脚本一起保存,而其他人则更倾向于使用后端存储此文件并管理 Terraform 状态。
远程状态管理
后端是一种存储我们状态的系统,它将状态存储在一个共享环境中,所有使用相同配置的人都可以快速访问。让我们看看如何使用 Google Cloud Storage 来实现这一点。只需执行以下命令:
terraform remote config -backend=gcs -backend-config="bucket=my-terraform" -backend-config="path=terraform/infrastructure"
以下是一些注意事项:我们需要在 Google Cloud Storage 界面中创建一个名为 my-terraform 的存储桶,并且需要为 Google Cloud 配置应用程序默认凭证。最简单的方法是通过设置名为 GOOGLE_APPLICATION_CREDENTIALS 的环境变量,将其路径指向我们用来在运行基础设施时进行 GCP 认证的 xxx.json 文件。如果你在同一文件夹下,只需运行以下命令:
export GOOGLE_APPLICATION_CREDENTIALS=./xxx.json
一旦完成并且 Terraform 命令执行成功,如果我们检查 Google Cloud Storage 中的存储桶,我们会发现一个新项,它包含我们在本地文件系统中使用的 terraform.tfstate 文件的内容。
现在我们可以通过改变基础设施并查看如何在 Google Cloud Storage 中的存储桶中反映这些变化来测试它是否正常工作。你可以通过运行 terraform destroy 并检查远程状态在 Google Cloud 中的变化来轻松做到这一点。
小心处理状态文件。它们包含关于你公司基础设施的非常重要的信息,可能会被用作攻击的切入点。
这个功能用于在工程团队中共享配置,它由 Terraform 完全管理:你无需手动拉取或推送状态文件,因为 Terraform 会为你处理这些操作。
修改你的基础设施
到目前为止,我们只创建了资源并将云数据中心的状态存储在在线存储桶中。接下来你将学习如何修改已有的基础设施,就像我们之前创建的项目一样。
如你所见,我们从一个非常简单的示例开始:创建一台带有临时 IP 地址的虚拟机(由 Google 分配的默认 IP 地址,非固定)。
现在,我们将创建一个静态 IP 并将其分配给我们的虚拟机,以确保它始终使用相同的 IP 地址。通过 Terraform 来实现这一点的方法是创建一个类型为 google_compute_address 的资源,如下所示:
resource "google_compute_address" "my-first-ip" {
name = "static-ip-address"
}
现在,我们可以执行 terraform plan 来查看如果应用基础设施更改,哪些内容会发生变化。正如你在新的执行计划中看到的那样,Terraform 识别出我们需要创建一个新的 google_compute_address 类型的资源,但是……我们如何将这个 IP 地址附加到我们的虚拟机呢?让我们重新检查虚拟机的配置:
resource "google_compute_instance" "my-first-instance" {
name = "my-first-instance"
machine_type = "n1-standard-1"
zone = "europe-west1-b"
disk {
image = "ubuntu-os-cloud/ubuntu-1704-zesty-v20170413"
}
network_interface {
network = "default"
access_config {
nat_ip = "${google_compute_address.my-first-ip.address}"
}
}
在代码的高亮行中,你可以看到将我们的虚拟机与我们将要创建的新地址关联是多么简单:我们创建的资源,即地址,将具有计算属性(在运行时计算的属性),这些属性可以在其他资源中使用。在 Terraform 中,插值值的语法是 ${},其中括号中的值为要插值的属性值,在本例中是名为 my-first-ip 的资源的 IP 地址。
如果你前往 Google Cloud 控制台并打开外部 IP 部分,你会看到类似于以下屏幕截图的内容:

IP 地址已按预期与我们的虚拟机关联。
Terraform 变量
我们之前没有提到的一点是 Terraform 可以与变量一起使用。请看以下定义:
provider "google" {
credentials = "${file("xxx.json")}"
project = "implementing-modern-devops"
region = "europe-west1"
}
这是我们提供程序的配置。有些字符串很可能会在其他地方使用,比如区域或项目名称。Terraform 有变量的概念,变量是一个可能会变化的值,因此我们可以将其提取到一个单独的文件中。到目前为止,我们已经创建了一个名为 resources.tf 的文件。现在,让我们创建一个名为 vars.tf 的文件,内容如下:
variable "project_name" {
type = "string"
default = "implementing-modern-devops"
}
variable "default_region" {
type = "string"
default = "europe-west1"
}
现在,我们将把这些变量应用到我们的文件中。默认情况下,Terraform 会查看当前文件夹中所有扩展名为 .tf 的文件,构建所有已描述事实的知识库,并开始根据需要创建我们的基础设施(内部构建一个依赖关系图,可以使用 terraform graph 命令进行检查)。这意味着我们不需要做任何特别的操作,Terraform 就能识别我们的变量文件:
provider "google" {
credentials = "${file("xxx.json")}"
project = "${var.project_name}"
region = "${var.default_region}"
}
我们可以在几乎任何地方使用变量,以便更轻松地创建我们的基础设施。如你所见,语法与插值时使用的语法相同;实际上,这就是插值。
在变量文件中,我们已经为这些变量指定了默认值,但我们也可能根据环境或调整配置时需要更改这些值。Terraform 还允许你通过三种方式来覆盖变量:
-
在命令行中
-
使用名为
terraform.tfvars的文件 -
使用环境变量
第一种方式就是简单地在 terraform 命令中添加额外的标志。例如,如果我们想在应用基础设施更改时修改 project_name,只需传递一个额外的标志,并指定变量的值:
terraform apply -var 'project_name=my-new-name'
就是这样。你可以通过更改项目名称或区域来进行实验,看看terraform plan如何创建新的资源(因为它们在不同的项目中不存在)。
第二种方法是使用包含变量定义的文件。为了测试它,在你的项目根目录下创建一个名为terraform.tfvars的文件,并填入以下内容:
project_name = "my-new-project-name"
现在,如果你运行terraform plan,你将看到 Terraform 计划创建新资源,因为它们在名为my-new-project-name的项目中不存在。文件名不一定是terrafrom.tfvars,但如果你使用不同的名称创建它,Terraform 默认不会加载它,你需要传递-var-file标志来加载它。
在继续之前,别忘了移除terraform.tfvars文件。
覆盖变量的第三种方法是通过环境变量。这种方法特别有趣,因为它可以轻松地通过外部因素来管理不同环境的配置。约定是定义一个与 Terraform 中的变量同名的环境变量,但前缀加上TF_VAR_。例如,对于变量project_name,我们可以执行以下命令:
export TF_VAR_project_name=my-new-project-name
Terraform outputs
到目前为止,我们已经使用 Terraform 来创建我们的基础设施,但我们对我们的云环境(在本例中是 Google Cloud Platform)几乎没有任何了解。HashiCorp 的工程师们也考虑到了这一点,并创建了一个名为输出(output)的元素,允许我们打印脚本创建的资源的值。
到目前为止,我们有两个文件:
-
resources.tf -
variables.tf
在继续之前,请确保你已经通过运行terraform apply创建了在线基础设施,就像我们之前所做的那样。
现在,我们将创建另一个文件,名为outputs.tf。这并非偶然。在 Terraform 中,这是推荐的项目布局方式,它有助于代码的可读性,并且能够分隔职责。
将以下内容添加到outputs.tf文件中:
output "instance_ip" {
value = "${google_compute_instance.my-first-instance.network_interface.0.access_config.0.nat_ip}"
}
我们稍后会回到这个命令,但现在我们需要重新运行 apply 命令,以便让 Terraform 为我们创建输出。某些内容已经发生了变化:
google_compute_address.my-first-ip: Refreshing state... (ID: static-ip-address)
google_compute_instance.my-first-instance: Refreshing state... (ID: my-first-instance)
Apply complete! Resources: 0 added, 0 changed, 0 destroyed.
Outputs:
instance_ip = 23.251.138.171
即使你没有更改基础设施,Terraform apply也需要运行,才能使你的输出可用。
现在我们可以看到一个新的部分,叫做 outputs,它包含了我们在 outputs 文件中定义的值。如果你想随时查看它,只需运行以下命令:
terraform output instance_ip
或者,直接运行以下命令:
terraform output
第一个将只显示实例的 IP(这对于作为其他命令的输入特别有用)。第二个则显示你在 Terraform 脚本中定义的所有输出。
现在,让我们解释一下输出是如何工作的。在这个例子中,我们使用了以下字符串来识别我们想要输出的内容:
google_compute_instance.my-first-instance.network_interface.0.access_config.0.nat_ip
前两个键(由点分隔)很明确:我们的资源类型和名称。然后,IP 属于network_interface中的acccess_config部分,值存储在nat_ip中,但那里的 0 是怎么回事呢?
很简单;我们可以通过重复network_interface块多次来定义多个网络接口:代码中的第一个接口是0,第二个是1,依此类推…
这个属性路径有时可能很难计算,尽管大多数情况下从配置文件中是相当明显的。如果你在寻找想要输出的内容时遇到问题,下面有一个快捷方式:当你运行terraform apply时,在输出中你会看到类似这样的内容:

这是你可以在输出中显示的所有属性的列表;键是左侧的列。例如,如果我们想显示创建 VM 的区域,就像这样简单:
output "instance_zone" {
value = "The zone is ${google_compute_instance.my-first-instance.zone}"
}
如你所见,这里的插值也起作用,允许你将字符串与 Terraform 资源的值混合在一起。
摘要
Terraform 是每个 DevOps 工程师必须掌握的基本工具,它允许你像管理代码一样管理基础设施,可以与 Google Cloud Platform 或 AWS 等云服务提供商高效工作,具有生命周期管理和部署基础设施的能力。
在本章中,我们看到了 Terraform 在创建虚拟基础设施方面的最重要内容。你已经学到了足够的知识,可以借助在线文档,创建资源并将它们连接起来,从而创建更大的项目。
即使我们在本章中遵循的示例相当基础,在下一章中,我们将创建更复杂的基础设施并安装所需的软件,以便以自动化方式运行它。
我们还将使用更高级的 Terraform 功能,例如模块,以创建高度可重用的组件,这些组件可以与不同的团队共享,甚至作为开源组件。






