# 8. 「集装箱化」与运维管理

内核恐慌 · 2015-01-11

<https://lib.pan.icu/1d12e9a3-67fa-4b21-8ede-0a0bca0d412d>

本期《内核恐慌》主要探讨DevOps实践与容器化技术，Rio和吴涛认为软件部署应像实体集装箱一样标准化和隔离化。他们对比了Fabric、Capistrano等自动化工具与Puppet、Chef配置管理工具，重点介绍Python社区的Salt和Ansible。随后深入Docker，基于Linux cgroups实现轻量级容器，能毫秒级启动、减少资源损耗，并统一开发与运维环境。节目还提及CoreOS、Ubuntu Core等更激进的尝试，以及NixOS追求完全无状态系统的理念。

## Questions this episode answers

### 软件部署中的集装箱化（containerization）是什么意思？

Rio 和吴涛用现实中的集装箱作比喻：集装箱通过标准化尺寸（如20英尺）和隔离，让货物搬运方便、互不干扰，并彻底淘汰了码头工人（docker）。在软件世界，Docker 等工具利用 Linux 的 cgroups 实现类似的隔离和标准化，启动一个容器只需几十毫秒，远快于虚拟机的二三十秒，且资源损耗极低，让应用像装进标准箱子一样快速部署和伸缩。

[1:38:48](https://lib.pan.icu/1d12e9a3-67fa-4b21-8ede-0a0bca0d412d?t=5928000)

### DevOps 是如何解决开发者和运维人员之间的矛盾的？

节目中提到，传统上开发（dev）追求变化，运维（ops）追求稳定，两者常互相指责。DevOps 运动提倡合二为一，让开发者自己部署和运维（end-to-end ownership），既激励他们写出更可靠的代码，也减少了小团队中的沟通成本和人员闲置，使整个软件生命周期从头到尾由同一人负责，从而化解了屁股决定脑袋的冲突。

[48:02](https://lib.pan.icu/1d12e9a3-67fa-4b21-8ede-0a0bca0d412d?t=2882000)

### 配置管理工具 Ansible 和 Salt 相比 Puppet 和 Chef 有哪些优势？

Rio 和吴涛指出，Puppet 和 Chef 使用 Ruby 编写 DSL，在执行大批量主机时可能慢到需要半小时，且每次都要完整运行脚本。Ansible 和 Salt 则使用声明式的 YAML 语法，工具可以直接判断状态并跳过已满足的步骤，从而大幅提速；Salt 还基于 ZeroMQ 实现高效通信，Ansible 甚至无需在客户端安装额外代理。

[1:22:19](https://lib.pan.icu/1d12e9a3-67fa-4b21-8ede-0a0bca0d412d?t=4939000)

## Key moments

- **[0:00] 反馈**
  - [0:14] Rio：“我又念错了，应该是‘瞠目结舌’。”
  - [0:37] 吴涛：“我做内核恐慌以来最大的收获之一就是语文变得好一点了。”
  - [1:52] 吴涛承认错误：听众log.e指出Swift没有垃圾回收，只是自动引用计数。
  - [3:30] 吴涛和Rio一致认为Ubuntu Mono字体设计丑陋，大写的I比小写的l还短。
  - [6:07] 吴涛批评Ubuntu Mono字体对编程阅读的干扰，认为使用者“真是没有什么品味”。
  - [8:50] 吴涛与Rio争论：苹果对开发者好的是工程师工具，但审核部门破坏体验。
- **[35:32] 新闻**
  - [36:40] Rio认为专业网站如Dr. Dobb's在广告模式下难生存，因好内容难以量化赚钱。
  - [40:00] 吴涛和Rio争论收藏旧杂志：吴涛想保留童年记忆，Rio认为没用的就该扔掉。
  - [43:20] Rio解释Dev与Ops的传统冲突：开发者要变化，运维要稳定。
- **[44:28] DevOps**
  - [45:00] Rio解释DevOps运动：开发者要自己部署和维护软件，实现端到端所有权。
  - [47:30] 吴涛：“成为一个DevOps，你需要懂网络、系统管理、脚本语言，就像学计算机的得会修电脑。”
  - [50:00] Rio介绍Fabric：用Python脚本通过SSH批量操作远程服务器的工具。
  - [53:20] 吴涛介绍Capistrano：Ruby社区的远程自动部署工具，与Fabric类似。
  - [56:40] Rio推荐使用VPS（如Digital Ocean或Linode）来练习远程服务器管理。
  - [1:00:00] 吴涛解释从命令式到声明式的转变：Puppet和Chef让你描述目标状态，而不是执行步骤。
- **[1:03:49] 工具**
  - [1:06:40] 吴涛认为Ruby on Rails的崛起带动了Ruby在服务器运维工具的流行。
  - [1:10:00] Rio介绍Salt和Ansible：Python社区的新一代配置管理工具，使用YAML。
  - [1:13:20] 吴涛兴奋发现Ansible的名字源自科幻小说《安德的游戏》中的超光速通信工具安赛波。
  - [1:16:40] Rio解释Salt基于ZeroMQ实现快速通信，通过master和多minion架构管理批处理。
  - [1:20:00] 吴涛对比声明式配置：Puppet/Chef每次运行整个脚本，而Salt/Ansible可以跳过已满足的状态，更快。
  - [1:23:20] Rio吐槽Ansible的YAML有时代替编程很痛苦，担心重蹈Java用XML编程的覆辙。
- **[1:38:48] 集装箱化**
  - [1:40:00] 吴涛将软件部署比作散货运输：不同应用依赖冲突、安装方式不统一。
  - [1:41:40] 吴涛解释虚拟机作为最早的软件容器，但资源开销大，启动慢。
  - [1:45:00] 吴涛介绍Linux cgroups（control groups）是实现轻量级隔离的内核特性。
  - [1:48:20] Rio指出Docker基于cgroups，提供比虚拟机更轻量、启动更快的容器。
  - [1:51:40] 吴涛说明Docker利用写时复制文件系统，多个容器可共享基础镜像，节省磁盘空间。
  - [1:55:00] Rio强调Docker的一个最佳实践是每个容器只运行一个主要应用，便于管理。
- **[2:01:02] Docker**
  - [2:01:40] 吴涛提到Docker的镜像像Git一样管理版本，可以保存某个运行状态的快照。
  - [2:05:00] 吴涛介绍CoreOS：一个极简Linux系统，只用来跑Docker容器，将宿主机精简到极致。
  - [2:06:40] 吴涛提及Ubuntu Core将宿主机系统本身也用Docker化方式管理升级和回滚。
  - [2:10:00] Rio和吴涛讨论容器化的终极哲学：让服务器像函数式编程一样无状态。
  - [2:13:20] 吴涛认为NixOS试图将操作系统变成完全无状态，但过于激进难以普及。
- **[2:15:16] 玄学**
  - [2:16:40] Rio指出服务端技术选择更理性，没有消费电子的宗教式偏好，因此更易接受变革。
  - [2:20:00] 吴涛宣布《内核恐慌》被苹果Hour of Code 2014活动推荐，感到自豪。
  - [2:23:20] Rio推荐IPN旗下节目《流行通信》，认为它能唤起程序员的艺术细胞。

## Speakers

- **Rio** (host)
- **吴涛** (host)

## Mentioned

Apple (company), Digital Ocean (company), Linode (company), 阿里云 (company), 青云 (company), Ansible (product), Boot to Docker Client (product), Capistrano (product), Chef (product), CoreOS (product), Docker (product), Fabric (product), LXC (product), NixOS (product), Pallet (product), Puppet (product), Rex (product), Salt (product), Ubuntu Core (product), VirtualBox (product)

## Transcript

### 反馈

**Rio** [0:00]
大家好 ， 欢迎收听第 8 期的 《 内核恐慌 》， 我是 Rio。

**吴涛** [0:05]
我是吴涛 。 呃 ， 新年快乐 。

**Rio** [0:08]
呃 ， 所以今天我们节目开始之前 ， 还是先做一个 follow-up 吧 。

**吴涛** [0:13]
对 。

**Rio** [0:14]
呃 ， 先是我自我检讨 ： 我又念错了 ， 应该是 " 瞠目结舌 "。

**吴涛** [0:19]
你念了 " 瞠目结舌 "， 我听的时候就觉得好像不太对 ， 然后就查了一下， 果然不是 " 瞠目结舌 "。

但 too late， 就对 。 然后我也念错了字 ， 呃 ，而且这个错我觉得有点 ， 呃 。

**Rio** [0:35]
不可原谅 ，是不是 ？

**吴涛** [0:37]
也不 ， 原谅总是可以原谅的 。 我总是原谅自己 。 哈哈哈 。 就是这个 " 粘贴 " 我总是念成 " 粘贴 "，但我觉得首先 " 粘 " 这个字是个多音字吧 ， 然后我个人在听到 " 粘贴 " 的时候会觉得有点不舒服 ，somehow。

所以我可能在很小的时候就知道我读错了 ，但是我一直都没有改过 。

**Rio** [1:00]
其实这个事情我也一直挺模糊的 ， 后来我还专门去查了一下， 就是有听众指出这个错误之后哈 ， 我还专门去查了一下词典 ， 我说哎呀 ， 原来是这样的 。

就是说 。

**吴涛** [1:10]
对 。

**Rio** [1:10]
做动词的 ， 做动词的时候一定是念 " 粘贴 " 的 。 然后名词的话 ， 这个就是 " 米 " 字旁这个字 。

**吴涛** [1:17]
姓 。 对 。

**Rio** [1:17]
" 米 " 字旁这个字做 " 粘 "， 念 " 粘 " 的时候只是做一个人的姓而已 ， 就姓氏 。 然后 " 粘 "， 姓的 " 粘 " 是另外一个 ，是这个叫 " 鼠 " 字旁 ，不是 " 米 " 字旁 。

**吴涛** [1:28]
对 。 而 " 米 " 字旁的 " 粘 "，在某些词典里面说它是 " 鼠 " 字旁的那个 " 粘 " 的异体字 。

**Rio** [1:33]
哇 ， 怎么这么乱 。

**吴涛** [1:34]
Yeah, whatever. 对 。 所以所以所以 ， 我做内核恐慌以来最大的收获之一就是语文变得好一点了 。

**Rio** [1:42]
哈哈哈 。 怎么 ， 话也讲得溜了是吧 ？

**吴涛** [1:46]
对 。 这是一个出乎意料的收获吧 ， 加引号的收获 。

**Rio** [1:52]
这也是个进步 。其实我也是 。 哈哈哈 。

**吴涛** [1:55]
对 。其实就 ， 呃 ， 我们两个在上一期录音的时候说 ， 如果我们下一期做 feedback 的话 ， 会把前两期的 feedback， 呃 ， 综合在一起 ， 呃 ， 反馈给大家 。

但是目前看来 ，不知道是因为过节的缘故还是怎么样 ， 就过去两期好像没有什么反响 。 不管是在社交网络上还是在邮件里面 ， 当然就还是有一些反响 ，但没有我们想象的那么多 。

因为我一开始预想的是 ， 我们至少我们在做那个 ， 嗯 ，memory management 那一期 ， 可能犯了很多很低级的错误 。

**Rio** [2:37]
嗯哼 。

**吴涛** [2:37]
但目前看来没有什么人指出 。 反而是比如说 " 粘贴 " 念成 " 粘贴 "，" 粘贴 " 念成 " 粘贴 "， 这样低级的语文错误总是有听众指出来 。

**Rio** [2:46]
嗯 。 不过可能也是因为这个播客这个媒介的限制哈 ， 就是有时候你要挑错嘛 ， 你总得知道你要错在哪里 ， 对吧 ？

但是有时候你听过之后不一定能记得下来 ， 或者说你当时想听到了 ，但是可能你一下没联系到之前他说了什么东西 ， 所以 。

**吴涛** [3:04]
对 。

**Rio** [3:05]
You know。

**吴涛** [3:05]
对 。 就好像我们在开车的时候 ， 一起听那个 ， 呃 ， 出站分配 ， 或者是流行通信的时候 。

**Rio** [3:13]
对啊 。

**吴涛** [3:13]
会说 ， 哎 ， 这地方这地方说的好像不太对啊 ， 然后讨论一阵 ，但是也不会想起来要给那个 ， 嗯 ， 主持人一些反馈什么的 。

**Rio** [3:22]
对啊 。 所以所以这里就是有这个问题嘛 ， 就是 。

**吴涛** [3:25]
对 。 大概咱们两个已经在 ， 已经被很多人在驾驶舱里面骂了很多次了 ，但 。

**Rio** [3:31]
你这俩傻逼 。

**吴涛** [3:32]
对 ， 又说错了 。 这种低级错误都犯 ， 哈哈哈 。 但咱们两个也都听不到 ， 所以 。

**Rio** [3:37]
嗯 。 所以还是应该求反馈 ， 就是别不要在底下默默的骂完就就爽了 ， 我们还是要多听一下， 然后 。

**吴涛** [3:46]
对 。 不仅要当时骂 ， 还要这个 。

**Rio** [3:49]
事后还得接着来信骂 。

**吴涛** [3:51]
对 。curse 记录下来发给我们 ，但我们改不改是另一回事 。

**Rio** [3:58]
但起码有可以 ，有机会可以共同提高嘛 。 就是如果听众朋友里面也有类 ， 类 ， 犯我们类似错误的 ， 就起码我们在检讨自己错误的时候 ， 你们也能够啊 ， 知道自己过往的哪里错了嘛 。

**吴涛** [4:12]
对 。 而且我觉得一个 podcast 可能最恐怖的事情 ，不是被很多很多人骂 ，而是根本没有人去理睬 。 所以 ， 呃 ， 如果一个 podcast 总是得不到回应的话 ，也许就让制作人觉得做下去有什么意义呢 ？

但如果很多人骂的话 ， 反而有可能我就说 ， 哎 ， 这个还是有点人听的 ， 那我就继续做 。 哈哈哈 。

你说是不是 ？

**Rio** [4:34]
你说不是贱吗 ？

**吴涛** [4:36]
嗯 ， 对 。 轮船不叫轮船 。Anyway。 嗯 ， 接下来的一条反馈是听众 log 点 e， 呃 ， 发给我的 ， 发给我们的邮箱里面的一条 。

说他说 ， 嗯 ，Swift 是没有 garbage collection 的 ， 这个是正确的 。 因为我又回去看了一遍那个 ，因为我之所以会有 Swift 有 GC 的印象 ，是在最开始的那个 Swift 的 announcement 的视频里面 。

**Rio** [5:04]
嗯哼 。

**吴涛** [5:04]
呃 ， 当时有一幅图嘛 ， 就标写出那个 Swift 的各项新特性 。

**Rio** [5:10]
嗯哼 。

**吴涛** [5:10]
然后我记得里面有 garbage collection， 可是我回去翻了一遍发现其实是没有的 。 对 。 然后

其实还是 reference counting， 只不过 automated， 然后也一直没有注意到这件事情 。 对 。 所以这件事情是我们错了 。 然后这个 ， 呃 ， 我不知道为什么 log 一这位听众用 QQ 邮箱发给我们的 ，但是我回复的时候说投递失败 ， 难道 QQ 不能收 Gmail？

**Rio** [5:40]
呃 ， 你知道最近出了一点点问题吗 ？

**吴涛** [5:43]
听说 。

**Rio** [5:44]
但是印象中还是 。

**吴涛** [5:47]
QQ 和 Gmail 好像没有什么仇吧 ？

**Rio** [5:49]
对 。 因为不是那个 ，因为 QQ 他邮箱他在海外， 或者至少在香港吧 ， 应该是做过什么 ， 呃 ， 就是 ， 呃 ， 就是墙外服务器的 ， 应该是没有问题的 。

不知道你这个情况怎么一回事 。 不过 anyway， 就这里反馈了 ， 这里讲完也可以了嘛 。

**吴涛** [6:05]
对 。

**Rio** [6:05]
嗯哼 。

**吴涛** [6:07]
然后有一位听众 ， 呃 ， 来信说 Ubuntu Mono 也是 ，也是一个不错的编程字体 ，而这一点我觉得我是不能接受的 。

**Rio** [6:16]
我也不能接受 。Ubuntu 那一套字体真是太丑了 。

**吴涛** [6:20]
对 。

**Rio** [6:21]
不光是 Mono 那一个 ， 它还有一个那个界面的 UI 的字体叫什么来着 ？ 就是 14 点几里面 ， 就是那个整个它的桌面环境里面默认的 。

**吴涛** [6:31]
Ubuntu display 吗 ？ 还是叫什么我忘了 。

**Rio** [6:33]
反正它自己处理成这里 ， 就是那种感觉是很 ， 就是所有的所有转角都是圆形的那个 。

**吴涛** [6:38]
对 。 这它就是为了突出这个人文主义 ， 就是以人为本的这个这个这个哲学嘛 。 就 。

**Rio** [6:45]
实在是太丑了 。 实在是太丑了 。

**吴涛** [6:47]
把一套把一套科技字体 ，也不是科技字体 ， 反正就把它的在试图通过字体来反射出它那种圆滑的 ， 呃 ， 具有人情味的这么一套系统 。

但我觉得是失败了 。 但不是针对这位听众啊 ，但我是觉得使用 Ubuntu Mono 并是作为编程字体的人， 真是没有什么品味 。sorry， 非常对不起 。

但比如说就是我专门又去看了一下， 就这个字体甚至大写的 I 比小写的 l 要短一点 ， 然后你在 ， 你就是它会让你的阅读 ， 让你的视线变得比较受到干扰 ， 就是你会情不自禁的去 ，不 ， 你会情不自禁的去注意到这款字体的 ， 呃 ， 加括弧的设计上面 。

就是 。

**Rio** [7:39]
嗯 。 对 。 这个我有这感觉 。 就是每次看见啊 ， 这好像有点太 。

**吴涛** [7:44]
对 。 它会它会非常跳脱出来 ， 会会像会呐喊着让你注意到它的存在 。

**Rio** [7:49]
不够 subtle 对吧 ？

**吴涛** [7:51]
对 。 这是这是非常非常影响字体质量的一个一个一个特性 。

**Rio** [7:57]
就其实还是因为丑 ，而且丑的没那么那么喧嚣 。

**吴涛** [8:03]
Anyway。 丑话说够了 。

**Rio** [8:05]
还好还好 。 我们这个审美取向比较一致 ，不然这里得打起来 。

**吴涛** [8:10]
对 。 呃 ， 对 。 我觉得这可能是 IT 公论比较具有可行性的一个特点 ， 就是 ， 呃 ， 你跟 Lawrence 的的观点总是趋向于不同的 。

**Rio** [8:23]
嗯哼 。

**吴涛** [8:23]
而咱们这边总是说你说什么什么 ， 我说对对对 ， 然后我说什么你说对对对 。

**Rio** [8:30]
实际上咱们都是这个什么同行啊 。

**吴涛** [8:33]
对 。 实际上咱俩是一个阵营的 ， 下次应该请另一个阵营了 ，但我也不知道 。 但 。

**Rio** [8:39]
嗯 。 好吧 。

**吴涛** [8:40]
Anyway。 嗯 ， 然后 IT 公论上一期 ， 就我们上一期录音的时候 ， 你告诉我说要听下一期 IT 公论关于苹果开发者的部分 。

**Rio** [8:50]
嗯哼 。

**吴涛** [8:50]
你们吐槽了苹果开对于开发者是多么的不友好 。 但 ， 嗯

， 怎么说呢 ， 我觉得这里面有一点 ， 就是我强调的是苹果对于开发者好的那部分 ，是他们的工程师所呈现出来的对于开发者的那一面 。

而你们所强调的则是其审核部门 ， 或者说他们 ， 呃 ， 管控的这一部分 ， 对于开发者不友好的部分 。

**Rio** [9:21]
嗯哼 。 对 。

**吴涛** [9:21]
我觉得两者其实是当然是冲突的 ，但是在我看来 ， 就是我比较看重的是工程师的那部分 。 因为我自己反正不是一个要给什么第三方开发者 ， 呃 ， 要给最终用户做 APP 的人。

**Rio** [9:35]
嗯哼 。

**吴涛** [9:35]
那我所关注的只是 。

**Rio** [9:36]
就只管写得爽啊 。

**吴涛** [9:38]
对 。 我所关注的只是它提供了什么样的工具 ，以及它的生态系统看起来是怎么样的 。 但至于这套生态系统能不能被管理层 ， 呃 ，以一种什么样的形式转化为对于最终用户友好的一部分 ， 我觉得这个对我们来说没有什么 concern。

就 。

**Rio** [9:58]
对 。

**吴涛** [9:58]
而而且而且说实话 ， 当我第一次听说 ， 呃 ，Peacock 要在那个 ， 呃 ，Today Widget 里面做一个计算器的时候 ， 我的第一反应其实是为什么要做计算器呢 ？

就我觉得这个东西不属于 Today。 你明白我意思吗 ？

**Rio** [10:17]
嗯哼 。 就是 。

**吴涛** [10:18]
Today。

**Rio** [10:19]
你觉得它那个语境不对 ，不符合那个东西 。

**吴涛** [10:21]
对啊 。 这个东西不应该出现在那 。 就我是 somehow 支持审核者的决定的 。

**Rio** [10:27]
嗯哼 。 嗯 。 怎么说呢 ， 就是就是你你是就是你是严格按照那个 Today View 的那个名字 ， 或者是这个含义来确定它应该包含什么东西 ，不应该包含什么东西嘛 。

**吴涛** [10:41]
对 。 当然你也可以说 Today 里面出现了很多东西 ，其实都不一定跟 Today 完全相关 。 就是这条线是很难划定的 ， 这个我承认 。

比如说 Evernote 或者是或者是 ， 呃 ，Instapaper，在里面出现一个 widget， 显示你可以读的东西 ， 或者是你可以直接在 Evernote 里面做的一些事情 。

**Rio** [10:59]
嗯哼 。

**吴涛** [11:00]
可能也跟 Today 没有什么直接的关系 。 但是 Peacock 这个东西在我看来 ， 你在一个本来是应该提供 ， 呃 ， 通知和总结的地方做了一个计算器 ，在我看来这是 misuse。

**Rio** [11:15]
哈哈哈 。 对 。 这个这个怎么讲呢 ， 就是说 ， 呃 ， 肯定从刚才讲的你是一个非常合理的一个说法 ， 就是说你这个不应该出现在那个地方是吧 ？

你就为什么要出现在那个地方 ？ 但是我觉得这个这个选择的自由是不是 ， 难道不是应该用户来决定的吗 ？

**吴涛** [11:34]
呃 ， 用户是不知道自己要什么 。

**Rio** [11:37]
那但问题是说如果他不知道 。

**吴涛** [11:39]
这么说 。

**Rio** [11:39]
如果 。

**吴涛** [11:40]
好 。 那我也是个用户 。 那我觉得这个地方不应该出现 Peacock。 你怎么说 ？

**Rio** [11:44]
那你就不要 ， 那你就不要装呗 。 就是那个不是默认启动的吗 ？ 你要填 ， 都填下档里面才可以 。

**吴涛** [11:50]
审核者那边不应该替用户做出决定 ， 这个东西不可以在那出现 。

**Rio** [11:55]
对 。 对 。 就是说除非它除非它违违反了某一条这个 ， 就是说对你这个东西有明显的损害 ， 对吧 ？

像这种不痛不痒的事情 ， 那我的就是默认的一个选择就是不要限制选择的自由嘛 。

**吴涛** [12:10]
OK。 所以 。

**Rio** [12:11]
就没没有人阻止 ， 没有人阻止你去往这个 Today 那个 view 里面加一个计算器 ，但是也没有人强迫你往里面加 ， 对吧 ？

这这完全是一个用户可以选择的东西 ，而且它默认是默认是没有的 。

**吴涛** [12:25]
OK。 所以 ， 呃 ， 实际上这是一种管理哲学的分歧 ， 就是你觉得你你不应该替用户做出太多的决定 ，而我觉得你应该 ， 我至少或者我应该替用户做出一些看起来让我觉得不爽的决定 。

**Rio** [12:39]
不 。 我觉得你可以做替用户做决定 ， 比如说你默认 ， 比如你你给那个你给一个在比如说这个开发者 ， 呃 ， 责任里面说明说 Today Today View 应该是主要用来干什么的 ， 啊 ， 然后你不鼓励什么东西 ，但是你不能说因为我不鼓励这个 ， 所以我完全禁止你做这个 ， 对吧 ？

因为这个并不是一个 ， 就是有些人就是愿意这样使用的 ，因为那个方便嘛 ， 拉下来之后它就它并不是把这个 Today View 当成一个跟按字面意义上讲的是今日相关的事情 ，而是说作为一个能够比较快捷的 ， 呃 ， 启动一个 ， 或者更甚至不用启动程序的一个完成一个功能的方式嘛 ， 对吧 ？

这个也很难很难说啊 。

**吴涛** [13:20]
好吧 。 但在我看来 ， 这就好像 ， 呃 ，在 Bookmark 上面用一个 JavaScript， 呃 ， 的小程序来来完成一件事情 ， 叫什么 Bookmarklet 一样 ， 是一种 ， 呃 ， 是一种误用吧 。

**Rio** [13:34]
但是这个你那你不不可不可否认 ， 就说这种情况有些 。

**吴涛** [13:39]
对 。 它是方便 ，但是它错了 。

**Rio** [13:41]
所谓 power power user 它就是要这样用嘛 。 就是我我我不反对说你你你指指出一种它应该做什么 ，但是你不能说我禁止完全禁止你做什么 。

你你是一个 ， 就你并不是用户自己 ， 对吧 ？ 有用户他可能他就是需要这样的需求 ， 对吧 ？ 他发现哎 ， 可以这么用 ， 我觉得还觉得还挺方便的 ， 那你为什么要干涉用户的用户的自由 ？

如果照这种逻辑发展下去 ， 那这不就成了独裁专制吗 ？ 那 OS 上面我们那些什么定制化的什么什么 per user 的工具就不要搞了 。

**吴涛** [14:11]
不 。 但我觉得这个不算独裁专制吧 ？ 这个算比如说 ， 呃 ， 你这这实际上是把是虽然但是这个这用这个词造句 ， 你是 ， 呃 ， 你是愿意说虽然这样做是错的 ，但是用户有这样的需求 ， 还是说 。

**Rio** [14:28]
嗯哼 。

**吴涛** [14:28]
虽然用户有这个需求 ，但是这样做是错的呢 ？ 那那我可以说就其实这就好像 ， 呃 ， 怎么说花园里面的草坪 。

**Rio** [14:35]
嗯哼 。

**吴涛** [14:36]
呃 ， 你说虽然用户从 A 点走到 B 点直接穿过草坪是最方便的 ，但是我就不要我不要这样修路 ，因为那样会破坏草坪的整个设计或者是美观 。

你也可以说虽然这样设计看起来是横平竖直的 ，但是会使得用户从 A 点到 B 点不得不绕一段弯路 ，他有可能会去踩草坪 。

这个跟专制没什么关系吧 ？ 这只是一种就是我愿意把我的这一套设计哲学放在我的 ， 呃 ， 软件仓库里面 ， 呃 ， 或者说施加在我的餐厅软件仓库上面 。

那你不爱用可以别用啊 ， 你不想进这个花园可以别进啊 ， 这跟独裁也没什么关系吧 ？

**Rio** [15:17]
但但问题是说你你这样你这样限制了之后， 你得到了什么呢 ？

**吴涛** [15:22]
我得到了我的 。

**Rio** [15:23]
你认为的美观 ， 对吧 ？

**吴涛** [15:25]
对啊 。 就如果我是一个园林设计者的话 ， 我希望我的游园客人来欣赏园林 ， 或者说使用我园林 ，在我园林里面玩 ， 那我不希望他们踩草坪 ， 这难道不是对的吗 ？

**Rio** [15:37]
所以所以我觉得这里要讲 ， 我就是这个以前也很多人引用的那个故事啊 ， 说这个迪士尼的公园里面怎么修草坪 ， 就先把草坪铺上， 然后让游客游客随便进去踩 ， 然后踩过一段时间之后看哪个地方的脚印多 ， 就在那边挖一条路 。

**吴涛** [15:53]
修一条路 。 对 。 这个这个我也听过 ，但这是一种这是一种怎么说呢 ， 这是一种没有设计的设计啊 ， 就是无为而治嘛 ， 就随机应变设计嘛 。

但我就想要修一条像那个修一个像那个 ， 嗯 ， 凡尔赛宫一样的横平竖直的草坪 ， 那这套方法就行不通了呀 。

**Rio** [16:11]
嗯 。 所以所以我说我就是要这么任性 。 哈哈哈 。

**吴涛** [16:14]
对啊 。 但我也不知道 。 我觉得苹果是一个比较 control freak 的公司啊 。

**Rio** [16:19]
嗯 。 但是但是起码它现在 back off， 就是它已经取消了两个决定 。 因为这个因为其实你从这个取舍利益的角度来讲 ， 确实是真的很不值得 。

因为首先这个 Today View 这个东西本来就是一个生造出来的一个功能 ， 然后真正有没有多少用户需求其实很难讲 。

而且其实按按照我自己的观察来看 ， 我完全意义意义的验证 ， 按照你刚才讲的那种字面上的这个 Today View 的东西 ， 我其实我是很少去用它的 。

但是如果有一个什么小工具 ， 那里我我现在有装一个小工具在里面哈 ，但是我还还有经常去看它 。

就所以这里面就是说你可以去生造出来一个东西 ，但是它是不是真的符合用户的需求 ， 这个是很难说的 。

所以我觉得在面对这种情况的话 ， 还是就是给开发者和用户一个选择的自由 。 我觉得这里这种这种方式是更好的 。

**吴涛** [17:08]
对 。 我觉得其实更加 ， 呃 ， 合理的一个选择是开放那个 ， 呃 ， 下从下面往上拉的那个叫什么 control center 的 。

**Rio** [17:19]
对对对 。

**吴涛** [17:20]
的的的 widget 开发 。 因为计算器如果你可以替换那个默认计算器的话 ， 那我觉得我没有任何话说了 。

因为那个地方本来就是让你干那个事情用的 ， 对吧 ？

**Rio** [17:31]
就它那个其实它有点性质不一样啊 。 就 control center 里面就你拉下来 ， 它比如四个这个快捷启动嘛 ， 它默认的是是这个 ， 呃 。

**吴涛** [17:41]
手电筒 。

**Rio** [17:42]
电灯筒 。 然后这个什么呀 ？

**吴涛** [17:43]
呃 。

**Rio** [17:44]
是这个闹钟 。

**吴涛** [17:46]
手边没有 。 对 。 秒表 。

**Rio** [17:47]
然后是计算器 ， 然后照相机嘛 。

**吴涛** [17:50]
对 。

**Rio** [17:50]
但其实这里就有些奇怪的 ， 就是说为什么会把计算器放在那里 ？

**吴涛** [17:58]
因为计算的确是一个需要便捷使用的功能呀 。 就美国人总是要算小费 ， 算账单什么的 。

**Rio** [18:05]
那这其实这里就出现了一个问题了 。 这四个四个钮是说它按照某一个方式 ， 要么是数据统计 ， 要么是拍脑袋拍出来 ， 就这个四个是应该会比较常用的功能 ， 对吧 ？

但是这真的这四个功能是所有人都最常用的四个功能吗 ？ 这个也很难讲 ， 对不对 ？

**吴涛** [18:21]
对 。 这就是我说为什么要应该开放这个东西的是那个开发 API 啊 。 就如果我可以自由定义这四个快捷方式的话 ， 那 Today View 不就可以去服务其本该服务的东西了吗 ？

**Rio** [18:35]
呃 ， 所以这里要讲嘛 ， 就是它有点不一样啊 。 就是那个像 Peacock 那个那件事情里面 ， 它是等于是在那个 Today View 里面直接做了一个计算器 ， 你甚至都不需要单独启动它 。

但是如果你用这个 control center 下面那四个钮 ， 你其实还是要启动那个程序 ， 还是要跳一下的嘛 。 就你用完之后还得再跳回来 ， 对吧 ？

所以其实你说那下面 control center 那四个快捷方菜单对应的那个 APP 其实应该是那个叫什么 Launch Launch Pro 还是 Launch Center 吧 ？

对 。 然后它它也在那个 Today View 里面做了这种快速启动的一个钮 ， 就是它在里面放了几个那种那种你自定义的这个 icon， 然后你拉下来之后就把它这个点进去嘛 。

但是从这种角度来讲 ， 你说其实其实你它苹果应该开发那四个其实是去满足刚才你讲那个 Launch Pro 还是 Launch Center 那个软软件对 Today View 的滥用的问题嘛 。

**吴涛** [19:26]
嗯 。

**Rio** [19:27]
对 。 但是你就是像 Peacock 这种 ， 它甚至都不需要启动别的地方去 ，其实还是很难讲的 。 或者说 ， 呃 ， 就是人们就是需要因为这个 iOS 这个是一个单一 APP， 就是在 foreground 的这种情况的这种前提下， 你怎么去减少这个 APP 间切换的成本 。

就 Today View 可能给出了一个可以可以用的地方 ，但是它对现在这个地方的限制还比较死 ， 那你不如再加一个什么 ， 它现在打开 Today View 不是下面有三个 tab 嘛 ，Today and notification， 那你再加旁边给一个什么什么 dashboard，因为这个在 OS 上也有这个概念嘛 。

你在里面搞了的话 ， 那可以自己加一些随意 ， 就是要求没有那么限制严格的东西啊 ，也也其实也是一个不错的思路 ， 我觉得 。

**吴涛** [20:14]
嗯 。 所以我觉得归根结底还是一个 ， 呃 ， 敲竹死枣 ， 就是苹果这一套死板管制的哲学没有贯彻下来 。

就是我觉得你是其实你是希望苹果变得更像 Android，不是吗 ？ 就是就更松散一些 ， 朝就是按照让软件按照用户的需求去生长出来 ，而不是一上来做一个 grand design 啊 ， 然后， 呃 。

**Rio** [20:40]
但但实际上 iOS 这么多年这么几年的演化并确实是照在这条路上走下去的呀 。 很多东西它都不是说苹果自己拍脑袋想出来的一个方案 ，而是说看到别的平台用户用得很好 ， 然后把这个东西透就是借鉴过来吧 ， 我都不说 。

**吴涛** [20:56]
对 。 甚至是什么官方压死同仁就 。

**Rio** [20:58]
对对对 。

**吴涛** [20:59]
就这种情况做出来 ， 然后它自己盗用 。

**Rio** [21:01]
就是我我相信绝大多数软件都不是这么一个 ， 就起码就针对最终用户的这种软件哈 ， 它都不是一个最终设计出来一个东西 ，而可能更真的是要用户体验出来的 。

**吴涛** [21:13]
对 。 但这里面有一个度的问题 ， 就是你在多大程度上让用户来使用导向 ， 你在多大程度上要让别人去踩草坪 ， 还是你你完全不去预设 ， 就是你从完全不去预设用户怎么从 A 点走到 B 点和精确的设计出从 A 点走到 B 点的每一步是中间是有很大的回旋空间的 ， 就是一个灰色地带嘛 。

你你对 。Anyway， 这个问题太 IT 公论了 ， 太 soft call 了 ， 我们不要再讨论 。

**Rio** [21:42]
对 。 不不过其实回到你刚才你讲那一点哈 ， 就是你刚才你也提到说你你觉得最爽的就是苹果的工程团队带给你那些东西 ， 比如说像在去年 WWDC 上它展示的那些 API 啊 ， 那些底层技术让你很兴奋 ， 对吧 ？

但是你对这个审核这块其实完全不感冒 。 因为首先第一个你并不是一个独立开发者 。

**吴涛** [22:01]
我不是一个开发者 。 对 。

**Rio** [22:02]
对 。 你不需要去面对这个的审核不过的后果 。 但我觉得这里我觉得这正是刚才我们讨论的那那堆事情反映出来的一个一个结果哈 ， 就是说 ， 呃 ，其实也大家都在这这持这么一个观点嘛 。

就很多人， 嗯 ， 就工程团队给了开发者这么一个很爽的一个选择 ， 很爽的这么技术可以去去玩 ， 或者说你叫炫技吧 。

但是开发者花时间做出来之后， 然后审核团队啪给人家拒了 ， 这个就是一个很恶劣的结果嘛 ， 就是怎么左手打右手啊 。

**吴涛** [22:33]
对 。 而且会有寒蝉效应嘛 。 就 。

**Rio** [22:36]
对啊 。 就会有 。

**吴涛** [22:37]
很多人都懒得做了 。

**Rio** [22:38]
就不光这个是会有这个很负面的影响嘛 ， 包括舆论上也好 ， 包括对开发者心态上的影响也好 。 啊 ， 然后现在就说很多这个批评苹果这个审核 ， 呃 ， 这这这一套东西的人就这么就就有持这么一种观点 ， 就是在上一期我们大家听过也提到了哈 ， 就说安卓现在已经越来越好用了 ， 对吧 ？

**吴涛** [23:00]
嗯哼 。

**Rio** [23:01]
特别是在 5.0 之后， 就是我看到身边哪怕是很多这个之前的 iOS 死忠的用户都就都觉得哎 ， 这个确实真的啊做得不错 。

呃 ， 然后我们就众众所周知的安卓是一个相对开放的系统嘛 ， 就没有那么多条条框框的限制 。 那这样的话 ， 苹果在这种情况下这样给自己给自己打脸 ，其实会造成这这某种某种程度上是有一个对开发者的驱动力 ， 让他去说哎 ， 那我不要在苹果上面开发好了 ， 我去给开给安卓开发 ，不用受这么多气 ， 对吧 ？

**吴涛** [23:35]
对 。

**Rio** [23:36]
对 。 所以其实这个对他的生态来讲其实叫什么 ？ 自自毁基石 。 自毁有个什么成语来着 ？ 啊 ，anyway， 还是不要讲了 ， 免得又被挑错 。

**吴涛** [23:47]
对 。 嗯 。

**Rio** [23:48]
嗯 。

**吴涛** [23:49]
What？ 好吧 。 有这么一个成语吗 ？

**Rio** [23:51]
有一个什么 ？

**吴涛** [23:54]
自废无功 。

**Rio** [23:56]
之类的 。 肯定是有一个什么的 ，但我现在想不起来了 。Anyway， 下一个 。

**吴涛** [23:59]
不重要 。 但我觉得至少从我的角度来讲 ， 就是呃 ， 如果我真的不要去做 iOS 的话 ， 我宁可试一试 Windows phone，因为 。

**Rio** [24:09]
哈哈哈 。 为什么 ？

**吴涛** [24:09]
Java 太恶心 。 在 GoLang 可以完全写安卓之前 ， 我应该是绝对不会去碰安卓的 。

**Rio** [24:17]
你也可以试试用 Scala 写安卓其实 。

**吴涛** [24:20]
嗯 。Closure。

**Rio** [24:21]
这个过程应该是蛮酸爽的 。

**吴涛** [24:23]
啊 。 算了吧 。

**Rio** [24:26]
好吧 。

**吴涛** [24:26]
还是算了吧 。 嗯 。

**Rio** [24:28]
哦 ，Windows phone 你可以用 C# 写 ， 对吧 ？

**吴涛** [24:31]
对啊 。 很爽 。

**Rio** [24:32]
嗯 。 哎 ， 对啊 。 那如果这样的话 ，其实还可以建议你试一下 。 因为据说啊 ， 微软也在推这个 Windows phone 的应用嘛 ，他们最缺的就是应用嘛 。

然后说如果你这个应用做得好 ， 它还有钱奖励哦 。

**吴涛** [24:47]
但 again， 我还是不会去做一些最终用户用的东西啊 ， 就基本上还是会会不爽 。 我究竟做过什么 ，其实也没有做过什么 ， 就只是因为公司的原因 ，而且我已经换了公司了 ， 可能也不需要再趟这趟浑水了 。

**Rio** [25:02]
嗯 。 所以所以你还是打算安安静静的做一个高冷的企业开发者 ？

**吴涛** [25:08]
很难说 。 就 anyway， 反正我正式工作是应该在这一期播出的时候 ， 我已经上了三天班了 ， 所以嗯哼 ， 呃 ，在下一期节目的时候 ， 我们应该可以对我至少我会对自己会做什么有一个清晰的了解 ，以及呃 ， 那个时候就可以知道自己是不是还继续要在移动开发这一块有什么建建树或者发展 。

**Rio** [25:37]
好吧 。

**吴涛** [25:37]
嗯 。 下次再说吧 。

**Rio** [25:39]
嗯哼 。

**吴涛** [25:41]
嗯 。

然后还有一位听众提到我们作为两个 Pythonista， 等等 ，Pythonista 的复数应该是 Pythonisti。 哈哈哈 。 对 。 因为我我我刚刚从意大利回来 ， 然后呃 ， 非常非常冷 ， 然后在在呃 ，在和朋友们聊天的时候说什么 ， 呃 ， 我们非常注重这个意大利 ， 就是德国人非常注重在说外来语的时候一定要按照外来语的正确的语法去去变格呀什么的 。

比如说 espresso 的复数不是 espressos，而是 espressi。 所以你你不能说我要两杯 espresso，而要说我要两杯 espressi。 然后意大利人你摇着头说 no no no，在意大利 ， 如果如果你在意大利之外的地方这么说 ， 可能是非常正确高逼格的 ，但在意大利你说两杯咖啡就行了 ，因为意大利人咖啡默认就是 espresso。

**Rio** [26:44]
哈哈哈 。

**吴涛** [26:44]
对 。 然后 Pythonista 因为它是意大利语吧 ， 所以它的复数应该是 Pythonisti。

**Rio** [26:51]
嗯哼 。 啊 ， 这个 。

**吴涛** [26:53]
工作 。 对 。

**Rio** [26:53]
又给科普了 。 这个这个其实我在知乎上经常有有有土过几次茶的哈 ， 就是经常会有人， 呃 ， 应该是前去年还是前年的时候吧 ，有人在知乎上去哪里去招这个 Python 程序员 ，他说他自己是他们要招 Pythoner。

**吴涛** [27:10]
Pythoner。 对啊 。 我们之前找过 。 但这没办法 ， 中国的英语教育就这这可能跟中国的英语教育也扯不上什么关系 ， 就你没有在那个文化圈子里面 。

呃 。

**Rio** [27:20]
不 。 我觉得这个就是很奇怪的地方 。 如果你真的是要招这个死 ， 就是什么所谓 hardcore Python 的这个 。

**吴涛** [27:28]
对 。 你至少应该有点文化是吧 ？

**Rio** [27:29]
对 。 你至少要要知道这个这个 jargon 是什么 ， 对吧 ？

**吴涛** [27:32]
对 。

**Rio** [27:33]
然后如果你招 Pythoner， 哈哈 ， 默认已经 fail。

**吴涛** [27:36]
对 。 就好像 Ruby 也 fail。Ruby Ruby 是什么 ？Rubyist。

**Rio** [27:42]
对 。 呃 。 那个比较好 ， 那个比较比较常见嘛 ，因为 y 结尾的有完全会怎么变 ，但是像 Python 这种情况很多人。

**吴涛** [27:50]
Python 也是 y 结尾 。 哦 ，不不 ，sorry， 我二了 。 没什么 。 我刚才想到别的地方去了 。

**Rio** [27:57]
就就很容易忘文生意 ， 就跟我们看中文一样嘛 ， 很容易唐木结绳 ， 明明就是 n 结尾嘛 ， 加 e， 多简单 。

哈哈哈 。

**吴涛** [28:07]
OK。

**Rio** [28:08]
还是没文化关键是 。

**吴涛** [28:09]
对 。 然后刚才说什么来着 ？ 呃 ，Pythonista， 我们作为两个 Pythonisti 居然不知道 ， 居然没有提到 Python 的 packaging， 呃 ， 就是 Conda 这套东西 。

**Rio** [28:18]
嗯哼 。

**吴涛** [28:19]
呃 ， 你有什么说的吗 ？

**Rio** [28:20]
我是真的不知道 。

**吴涛** [28:22]
What？ 我没听过 。

**Rio** [28:24]
你不知道 Anaconda 吗 ？

**吴涛** [28:26]
哦 ， 它是它是之前很早就有的吗 ？ 还是后来才 。

**Rio** [28:30]
Anaconda 有一阵了吧 。 就是就是我之前不是提起来我在折腾 PyQt 嘛 。

**吴涛** [28:34]
嗯哼 。

**Rio** [28:35]
呃 ， 什么 PyQt？ 就是这这 iPython Qt console 嘛 。

**吴涛** [28:39]
嗯哼 。

**Rio** [28:40]
呃 ，其实部分原因就是因为我想要在电脑上不装 Anaconda， 搞出一个 iPython 的 Qt console。 呃 ，因为 Anaconda，Anaconda 实际上是一个 ， 嗯 ， 怎么说呢 ， 小白给小白用户们使用的 Python distribution， 就是比如说数据分析师啊 ， 或者是尤其是在 ， 嗯 。

**吴涛** [29:03]
就是非非 CS 人士用 Python 的程序 。

**Rio** [29:06]
就是一些不得不写程序 ，但是没有系统的学过怎么写程序的人， 比如说什么 ， 呃 ， 搞生物的呀 ， 要处理那个细胞图像啊 ， 或者是 ， 呃 ， 搞化学的呀 ， 要做一些化学计算 。

因为 Python 毕竟是一个在科学计算领域非常非常 ， 呃 ， 受欢迎的主流语言 。

**吴涛** [29:26]
教学语言吗 ？

**Rio** [29:27]
对 。 不不只是教学 ， 就是在科研领域 。

**吴涛** [29:30]
教教水 ，glue language。

**Rio** [29:32]
呃 ， 这个也不能算教水语言了 ， 就是它是它是正儿八经的很多科研人员的第一生产力语言啊 。

**吴涛** [29:38]
这个我知道 ， 就是像那个 Numeric Pi， 它也是这种场景下应用的出来的结果嘛 。 就是 。

**Rio** [29:44]
啊 ， 你的意思是它使用 Python 作为 ， 呃 ， 操作界面而而使用 ，而而让这个开发者可以用用到数学库 ， 就是 。

**吴涛** [29:53]
对啊对啊 。

**Rio** [29:54]
在这个意义上教水是吧 ？

**吴涛** [29:56]
呃 ，其实这么说也不对哈 ， 应该教水应该是粘合各不同组件 。 不 anyway， 就是说他们用它 ，因为它这个比较简 ， 这个语法比较简单嘛 ， 然后相相对直观一点 ， 然后去用到一些什么第三方的库去做一些科学计算 ， 这些我是有有有所耳闻的 。

不过我这现在反应过来 ， 我为什么我没有听说过这个东西了 。

**Rio** [30:18]
因为你不是搞这个 。

**吴涛** [30:19]
不是你看起来像小白用户吗 ？

**Rio** [30:21]
哈哈哈 。

**吴涛** [30:22]
不是你刚才说他小白用户用的 ， 那我不是啊 。

**Rio** [30:25]
对 。

**吴涛** [30:26]
Anaconda。 对 。Anaconda 就是大蟒或者什么比较大的蟒蛇 ， 就 Anaconda 应该没错吧 ？Anaconda 这个词应该是蟒蛇意思吧 ？ 别别又给人吐槽 。

对 。 我不知道啊 ，但我觉得 Anaconda 应该是 。

**Rio** [30:38]
应该没错 。

**吴涛** [30:39]
某种蟒蛇 。 然后对 。 然后它就是一个 Python 的 distribution， 它它把它等于把 Python 包装在了一个安装包里面 。 然后如果你是做 ， 你是呃 ， 要学比如说数据呃 ， 图像处理啊 ， 或者是你要搞什么化学生物学方面的计算啊 ， 甚至物理学有应用吧 ， 我不知道 。

然后你可以安装 Anaconda， 然后啪一下你什么都有了 。

**Rio** [31:01]
嗯哼 。

**吴涛** [31:02]
什么 Qt iPython 的笔记本啊 ，console 啊 ， 呃 ，Numpy 啊 ， 全都有了 。 然后呃 ， 安装和呃 ， 删除这些 Python 的包也通过 ，也都是通过一个图形界面 ， 就有点像 Sigwin。

**Rio** [31:19]
嗯 。

**吴涛** [31:19]
大概那那那种感觉吧 。 然后然后所谓 Conda 就是一个 ， 就是你怎么把自己的 package 呃 ， 打包给 Anaconda 用 ，是这么一套东西 。

**Rio** [31:32]
OK。

**吴涛** [31:33]
对 。 它几乎是一个 Python 的平行宇宙吧 。

**Rio** [31:36]
那所以其实就是说这种专业开发者肯定是不会接触到的喽 。

**吴涛** [31:42]
也不一定吧 。 因为 Anaconda 里面的包其实也都是几乎所有的常见的 Python 包 Anaconda 里面都有吧 。 我甚至怀疑 Anaconda 其实就是把定期会把 PyPi 上面的那个包全都包一遍 ， 然后装一个就是包装成 Anaconda 的格式嘛 ， 然后给那个呃 ， 科学计算领域的用户用 。

因为他们根本不关心我们这些工程师在干嘛 ，他只关心造出来的东西它能用就行了 。 然后你只要提供一个傻瓜化的安装界面就就蛮好的 。

**Rio** [32:15]
哦 。Speaking of there's only one way to do things.

**吴涛** [32:19]
Yes. Exactly.

**Rio** [32:20]
There's another way.

**吴涛** [32:22]
对 。

**Rio** [32:22]
啊 ， 来 ， 再接着科 ， 呃 ， 接接着有文化一点 。Anaconda 这个中文叫做森林的森 ， 然后这个字 。

**吴涛** [32:31]
森蟒 。

**Rio** [32:32]
不 ， 森蚺 。

**吴涛** [32:34]
森蚺 。

**Rio** [32:34]
虫子旁一个再不要上面那一横 ， 就是再见的再不要上面那一横 。

**吴涛** [32:39]
嗯 。

**Rio** [32:40]
然后这个叫做产于热带南美洲的大蟒蛇 ， 可用身身体嚼死猎物 ， 亦称大水蟒 。

**吴涛** [32:50]
OK。

**Rio** [32:51]
啊 ， 知道了 。 又又学了一个词儿 。

**吴涛** [32:53]
我觉得好像之前看过一部恐怖片或者是不是恐怖片 ， 惊悚片 ，thriller 吧 ， 就是讲有一道非常非常大的蟒蛇 ， 然后怎么搞人的 ，是 90 年代的片子吧 。

**Rio** [33:10]
嗯哼 。

**吴涛** [33:11]
就因为那个时候有时候有一部有一部什么那个 ， 嗯 ， 讲鳄鱼的恐怖片 ， 很很很卖座 ， 然后他们就拍了一个什么搞不好叫什么狂蟒之灾的这么一部电影 ， 然后 。

**Rio** [33:23]
我想起名字 。

**吴涛** [33:25]
对 。

**Rio** [33:26]
这一定是台湾或者香港人翻译的 。

**吴涛** [33:29]
对 。 然后片名应该就叫 Anaconda。

**Rio** [33:31]
OK。

**吴涛** [33:32]
Anyway，不重要 。

**Rio** [33:34]
啊 ， 还有一个叫做 Nix 的东西 ，其实我也没有用过 ，也没有听说过 ， 准确来说 。

**吴涛** [33:40]
Nix 不就是 NixOS 的那个吗 ？

**Rio** [33:42]
不不 ， 这个是 Python 的 Nix， 这个刚刚我们提到另另外一个 Nix 是另外一个东西 。

**吴涛** [33:47]
啊 ， 这个那这个我也不知道 。 我一开始以为它就是那个 ， 嗯 ，NixOS 的 Nix。

**Rio** [33:53]
啊 ， 所以 ， 哎 ， 怎么说呢 ？

**吴涛** [33:57]
茫然无知啊 。 我们 。

**Rio** [33:59]
这这这不怪咱们吧 。 我觉得这个他都这个已经什么四分五裂成这样了 ， 我也没什么好说的了 。

**吴涛** [34:08]
对 。

**Rio** [34:08]
啊 。

**吴涛** [34:08]
我们 。

**Rio** [34:09]
反正我反正我是不怎么用了 ， 随便了 。

**吴涛** [34:12]
嗯 。 对 。Anaconda 我其实我装过一次 ，但是我不记得为什么了 。 我用了大概两三天就把它删了 。 好像是有一个我我不能理不能理解还是不能接受的 ， 呃 ，show stop，但我不确定了 ，是因为它装了之后 system Python 就就就坏了 ， 还是还是 somehow someway 有一个东西不能用 。

因为我大概三年前用过一次 ，但对 ， 具体也不记得了 。

**Rio** [34:41]
嗯 。Anyway， 过吧 。

**吴涛** [34:44]
哈哈 ， 过 。 嗯 ， 还有什么 ？ 没有什么了 。 对 。 那另外一个 feedback 就是我给 ， 呃 ，Love 写了邮件 ， 说我们能不能用 Still Alive 作为我们的 Simson 啊 ， 然后对 ， 一直到现在都没有人理我 。

**Rio** [35:01]
没有 。

**吴涛** [35:01]
我不知道我们会不会有听众在 Valve 工作呢 ？Valve 应该有很多华人华人程序员的 。

**Rio** [35:07]
这个应该是他们的法务部门吧 ， 我觉得 。

**吴涛** [35:10]
对 。 但如果你能够 somehow someway 接触到 。

**Rio** [35:14]
有内部人最好是吧 ？

**吴涛** [35:16]
对 。 有有知道我们这个问题能够由谁来解决 ， 能不能帮帮我们的忙 。

**Rio** [35:22]
贵谢了 ， 贵谢了 。

**吴涛** [35:24]
对 ， 贵谢了 ， 贵谢了 。 如果帮不了的话 ，I don't blame you。

对 。 好吧 。

**Rio** [35:32]
OK。

### 新闻

**吴涛** [35:32]
呃 ，feedback 结束了 。 那接下来进入我们的当当当新闻环节 。

**Rio** [35:37]
哈哈哈 。 来吧 。

**吴涛** [35:40]
啊 ， 对 ，其实上一期 ， 呃 ，IT 公论也提到了 ， 就是 Dr. Dobbs 这个这个在线杂志停刊 。

**Rio** [35:48]
嗯哼 。

**吴涛** [35:49]
嗯 ， 当然它不是停刊啊 ， 它只是把它只是不再更新了 ， 整个网站还是还是在那儿 。 我当时 。

**Rio** [35:55]
停停刊不就是这个意思吗 ？

**吴涛** [35:57]
停刊也有可能是整个网站要撤下来 ，因为它后来 。

**Rio** [36:01]
不不不 ， 你知道这个停刊这个字肯定是从传统杂志的这个来的一个概念嘛 ， 就停止发行嘛 ， 对吧 ？

但是你之前买过的旧的还在你家里啊 。

**吴涛** [36:11]
好吧 ， 说点事 。

**Rio** [36:12]
所以所以其实还是有点那个这这个语境下面其实还蛮好的 。

**吴涛** [36:19]
对 。 所以如果它真的整个站挂掉了 ， 或者是整个站停掉了 ， 应该叫关站是吧 ？

**Rio** [36:26]
对 。 就停刊其实还蛮好的 ， 就是 stop publishing，但是你还可以看之前发过发表过的嘛 。

**吴涛** [36:33]
嗯 。 对 。 这个我当时在推特上读到还是挺伤感的 ，因为我不显然不是读着 Dr. Dobbs 长大的 ，但至少 Dr.

Dobbs， 呃 ， 是一个我觉得非常靠谱的 ， 呃 ，而且而且不管是深度还是

及时度都让人相当满意的一个在线杂志 。

**Rio** [36:54]
嗯哼 。

**吴涛** [36:55]
所以而且而且就是我不知道你有你有没有印象 ， 就是有一本书叫 ， 嗯 ， 哎 ，Graphic Programming Black Book。

**Rio** [37:06]
没什么印象 。

**吴涛** [37:07]
就是 ， 呃 ， 讲图像处理的黑书 。

**Rio** [37:13]
OK。

**吴涛** [37:14]
对 。 里面讲了非常多的图像处理相关的 ， 呃 ， 的问题 ， 或者说教你怎么去写图像处理方面的 ， 嗯 ，也不是图像处理 ， 就是就是 Graphic Programming。

嗯 ， 怎么说呢 ？ 对 ， 就这一方面主题的一系列文章 。 它最开始其实就是在 Dr. Dobbs 上面连载啊 ， 然后整个连载最后集结成书放在网上， 直到现在都是非常非常经典的一本书 。

**Rio** [37:43]
OK。

**吴涛** [37:43]
对 。

**Rio** [37:44]
所以你对这个还是很有深有感情的 。

**吴涛** [37:46]
对啊 。 而且我也不知道 ， 就 Dr. Dobbs 就有点像一个每次上他的网站就看到那种那种 90 年代的气息扑面而来 ， 就让人觉得这是我的青少年， 这是我的童年 。

**Rio** [38:02]
嗯 。 不过怎么说呢 ， 就是这一类的专业网站其实在广告模式情况下还是挺难生存的吧 ， 特别现在就有很多这种所谓新媒体站 ， 呃 ， 一直在抢眼球的情况下 。

**吴涛** [38:18]
就我虽然它这件事情虽然让我伤感 ，但我从来不觉得它是意外的事情 ， 或者说它是不可理解的事情 。

因为我们每个人都知道这样的内这样就是内容 heavy 的网站是很难在我们现在这样一种经济环境下生存下去的 。

因为没有人知道怎样用好的内容赚钱 。

**Rio** [38:42]
就没法量化嘛 ， 这个东西 。

**吴涛** [38:43]
对 。 而不像杂志 ， 你可以说这本杂志就卖这么多 ， 然后每一版广告都有定价 ， 然后现在是一个非常混乱的时代 ， 没有人知道应该怎么怎么用好的内容 。

**Rio** [38:55]
所以所以其实还是应该就是说 ， 比如说像那个 Dr. Dobbs， 它可以说恢复我们会员制啊 ， 就说需要需要订阅才能看啊之类的 ， 这样起码它的这个会稳定一点嘛 。

**吴涛** [39:08]
哎 ，也许吧 。 我也不知道 ，但 。

**Rio** [39:11]
哎 ，不过 。

**吴涛** [39:12]
嗯 ， 完了就完了吧 。 还是会还还会有后继者的 。

**Rio** [39:17]
嗯 。

**吴涛** [39:17]
而且凭良心说话 ， 就是我其实也不会去专门关注 Dr. Dobbs 最近有什么更新 ， 甚至我不知道你你买杂志吗 ？

**Rio** [39:25]
偶尔看一天呢 。

**吴涛** [39:26]
你买杂志吗 ？ 传统传统的传统意义上的电脑杂志你还买吗 ？

**Rio** [39:30]
哇 ， 我很久以前还很久很久以前买 ，但是 。

**吴涛** [39:33]
大家都是这样嘛 。

**Rio** [39:34]
对 ， 自从有了互联网之后就再也不花钱买杂志了 。

**吴涛** [39:37]
对啊 。 就我小时候还会觉得 ， 我小时候有一个朋友会把一整年的大众软件 ， 呃 ， 排在书架里面 ， 然后那一整年的那个书籍 。

**Rio** [39:46]
嗯哼 。

**吴涛** [39:47]
就书的那个侧面会会连成一个图案 。 我当时觉得哇 ， 将来长大了我也要干这个 。

**Rio** [39:53]
说来上次我回家的时候清理家里的那个什么 ， 就我的自己的书架 ， 把那些都当废废纸卖掉了 。

**吴涛** [40:01]
真的 ？

**Rio** [40:02]
嗯哼 。

**吴涛** [40:03]
这件事情我应该还是不会干的 。 就我小时候存攒的那些杂志 ， 我觉得还是就就让就让他们压在那好了 。

**Rio** [40:10]
没有什么用啊 。

**吴涛** [40:11]
就你为什么一定所有事情都要有用 ？

**Rio** [40:15]
不 ， 我就呃 ， 我就要先解释一下这个情况 ， 就是说因为那个要放其他东西嘛 ， 然后堆不下了 ， 然后 。

**吴涛** [40:22]
OK。 所以你是有空间需求 。

**Rio** [40:24]
哦 ，不 ，而且我有这个什么洁癖 。

**吴涛** [40:27]
哦 ， 你有你有你有整理癖 。OK。

**Rio** [40:29]
就是反正你也没什么用嘛 ， 过期的信息 ， 然后你也不好看 。

**吴涛** [40:33]
你知道古玩商最爱你们这种人了 ， 就是你们这种人的存在使得古玩可使得是一些文物可以在可以可以不定时的重见天日 。

如果每个人都没有整理癖的话 ， 每个人的阁楼里面都堆满了各种各样的各种各样的 ， 这在那个时代毫不稀奇 ，但是过上二三十年就非常非常让人让人让人， 呃 ， 爱不释手的东西 。

如果没有整理癖的人群存在的话 ， 这些东西永远不会重见天日 。

**Rio** [41:01]
不过我很难想象什么这个过过期杂志能成为什么一个玩物嘛 。

**吴涛** [41:08]
过期杂志的确很难成为玩物 ，但 。

**Rio** [41:10]
对啊 。

**吴涛** [41:10]
嗯 ， 我 。

**Rio** [41:13]
所以起码就在可以预见的将来 ， 这个东西都只会成为一个负担 ，而不会成为一个有价值的东西嘛 。 就可能唯一的价值就是缅怀一下什么逝去的青春 。

**吴涛** [41:25]
它有展示的价值和收藏的 。 嗯 ， 我也不知道 。

**Rio** [41:28]
它又不是四大名著 ， 它我给展示给谁看 ？

**吴涛** [41:32]
不 ， 这就好像一台古旧的计算机一样 ， 它没有什么使用价值 ， 可是它摆在那儿就是可以让人觉得你很有文化 ，不是吗 ？

**Rio** [41:43]
哈哈哈 。 那你真的觉得大众大众软件会让你显得很有文化 ？ 我这个 。

**吴涛** [41:47]
我又在鬼扯了 。 我也不知道 。

**Rio** [41:48]
I don't know。 不 ， 你有一个什么 PGP10 或者 11， 你摆在家里可能还行 ，但是像这种东西 。

**吴涛** [41:55]
Imagine that。 十年之后你有了一个大宅子 ， 然后大宅子里面有一个书房 ， 书房里面摆了一大堆过的大众软件 ，90 年代的期刊 ， 然后每一本都压得像钻石 ， 呃 ， 压得像压得像大理石一样平 ， 然后摆在书架上， 然后这个时候你的童年朋友们来玩的时候就说哇 ， 你还收着 90 年代的大众软件 ， 这难道不是一个谈资吗 ？

**Rio** [42:19]
难道他不会认为你是一个 weirdo 啊 ？

**吴涛** [42:23]
哈哈哈 。

**Rio** [42:26]
对吧 ？

**吴涛** [42:26]
Next。

**Rio** [42:27]
哈哈哈

。

**吴涛** [42:32]
对 。 所以所以我们两个其实还是有分歧的 ， 我们两个在在在价值观上还是有分歧的 。 耶 。

**Rio** [42:37]
对的对的 。

**吴涛** [42:38]
哈哈 ， 太好了 。

**Rio** [42:40]
节目可以做下去 。 有有有的聊了 。

**吴涛** [42:42]
耶 。

**Rio** [42:42]
嗯 。

**吴涛** [42:43]
嗯 ， 然后另外一个就是我前两期也提到那个 Anaconda。

**Rio** [42:48]
嗯哼 。

**吴涛** [42:49]
也是它没有停刊了 ，但是它被卖给了 Purch， 这个你们也在 IT 公论里面聊过 ， 这个我没有什么太多可说的 ，但我也觉得挺可惜的 。

**Rio** [42:58]
其实事情这个它没什么 ， 就这个还好啊 ， 它卖给那个只是换了这个东西而已 ，但是编辑团队啊还是没变 ， 然后它还是独立运作的嘛 ， 这个其实倒没什么 ，但是其实也反映出一个现象吧 ， 就是但是他们说的理由之一就是这样可以增强他们在这个广告买主那里的一个什么就竞争力嘛 ， 就是因为你大平台这个买主更多嘛 ， 就是这个其实潜台

词就是说它作为一个独立的这么一个网站运营的广告收入其实要要么就是没有 。

**吴涛** [43:30]
难以为继 。

**Rio** [43:30]
对 。

**吴涛** [43:30]
要么没有增长 。

**Rio** [43:31]
终究还是要去终究还是需要更多的钱 。 对 。 所以其实跟那个 Dr. Dobbs 面临的是同样的问题 ， 只是说它的那个程度没有那么严重 ，而且它现在就是说找到了一个还不错的买家 ， 然后能够就起码我们希望它能够解决问题吧 ，但是可能再过个两三年发现卖过去还是不行 ， 那再再怎么样呢 ， 我们也不知道 。

但是像这种所谓的这种 hardcore 媒体 ， 包括 B 节目在内 ， 都有这种 ， 呃 ， 用户群体 ， 呃 ， 就读者群体或者听众群体比较小众 ， 然后没有办法 ， 呃 ， 可以持续盈利化做下去的情况嘛 ， 对吧 ？

起码我们现在还是在免费做这件事情 ， 对吧 ？ 就没有任何收费的这个 ， 呃 ， 尝试嘛 ， 目前还 。

**吴涛** [44:12]
征兆啊 。 而且我们收的话大概也是就 donate， 就只是捐捐赠而已 。

**Rio** [44:18]
对对 。 但是就像它并不可能 ， 就我们不可能说哎 ， 我们来全职做这个东西 ， 对吧 ？ 你肯定养活不了我们两个人。

**吴涛** [44:25]
嗯 。

**Rio** [44:26]
嗯 。

**吴涛** [44:27]
好吧 。 嗯 。

### DevOps

**Rio** [44:28]
OK， 现在开始今天的正题哈 。其实今天我们准备刚才扯了差不多 45 分钟的读似了 。

**吴涛** [44:36]
对 。

**Rio** [44:36]
我们其实今天准备准备延续着之前的那个话题 ，不 ，也不叫话题吧 ， 那个方向走下去 。 今天我们讲了一些这个运维的一些东西 。

**吴涛** [44:45]
对 。 上一期我们说的东西其实有一点像从 ， 嗯 ， 从小处 ， 就是从非常小的一个单独的程序运行 ， 或者说一群程序在一个计算在一个操作系统上运行的时候 。

**Rio** [45:02]
嗯哼 。

**吴涛** [45:02]
呃 ， 它们的周期生存周期管理 。 然后我们上一期又提到了这些东西 ， 当你把它从你开发那台计算机上拿出来放到其他计算机 ， 或者反过来 ， 你怎么把别人开发好的程序放到你的计算机上用的时候 。

**Rio** [45:16]
嗯哼 。

**吴涛** [45:17]
呃 ， 去管理它的它的生存周期 。

**Rio** [45:20]
嗯 。

**吴涛** [45:20]
嗯 ，而这一期我们想要说的其实就是 。

**Rio** [45:24]
你怎么用它 。

**吴涛** [45:25]
你怎样才能在就是整你一个人作为一个开发者管理一堆程序和你一个公司去管理一堆你开发出来的程序跑在一堆服务器上 ，其实又是一个更大的层级 。

然后我们今天想要讨论的其实就是这件事 。

**Rio** [45:46]
对 。在这个之前可能先要引入一个概念啊 ， 就是说本身有两个概念 ， 就是一个叫 dev， 一个叫 op， 就是开发者和运维者这两种身份 。

我们传统上应该是分离的吧 ， 就大部分那种传统企业里面都是这样子 。

**吴涛** [46:02]
对 。 所谓 dev 就是 developer， 呃 ， 开发者 。 然后开发者的传统意义上的 ， 嗯 ， 那应该包括哪些呢 ？ 我觉得可以包括比如说 programmers 肯定吧 ，他们是 developer， 然后 testers。

**Rio** [46:15]
对 。

**吴涛** [46:16]
Testers 应该其实也是开发团队的一部分 。

**Rio** [46:18]
对 。 它是最保证这个产品质量的最后一个环节嘛 。

**吴涛** [46:22]
对 。 然后， 嗯 ，wait a second。QA 是最后一个环 ， 我还是 QA 和 tester 一般是混在一起的 。

**Rio** [46:29]
呃 ， 就它开发者自己有一套标准化的测试 ， 一般是 ， 然后 QA 是在就是这么白盒和黑盒嘛 ， 对吧 ？

**吴涛** [46:37]
对 。

**Rio** [46:37]
就是要一个 ， 呃 ， 黑盒测试嘛 ， 就 QA 那个环节要保证最后那最终的那个结果 。 然后就是这个产品出来 ， 然后运维的人把它 。

**吴涛** [46:47]
对 。

**Rio** [46:48]
负责就是 operator 把它弄到机器上去跑 ， 然后保证它能够连续稳定的工作下去 ， 然后 。

**吴涛** [46:56]
对 。 对 。 然后这一部分就是 operate， 就是就 ops 应该是 operations 还是 operators？

**Rio** [47:02]
如果 developer， 然后 。

**吴涛** [47:04]
Developer operator。OK。operator 包括哪些人 ？ 包括 ， 呃 。

**Rio** [47:08]
呃 。

**吴涛** [47:09]
首先那些管网络的肯定是 operator。

**Rio** [47:11]
网管 ， 网络管理员有算是 。

**吴涛** [47:13]
然后 system admin 其实是更更更 ， 呃 ，proper 的一个一个头衔吧 。

**Rio** [47:20]
对对 。

**吴涛** [47:21]
System administrator。

**Rio** [47:22]
系统管理 。

**吴涛** [47:22]
然后还有 ， 呃 ，database administrator 应该也算是 ops 的一部分吧 。

**Rio** [47:27]
DBA。

**吴涛** [47:28]
DBA 其实介于两者之间 。

**Rio** [47:30]
就只要是在一个是在开发时的工种 ， 一个是在运行时的工种嘛 。

**吴涛** [47:36]
呃 。

**Rio** [47:37]
可以这么理解吧 。

**吴涛** [47:38]
但至少在我接触的几个公司里面 ，DBA 其实多半还要参与到 architecture 的的决策里面 。

**Rio** [47:45]
就是开发之前的工作 ， 对吧 ？

**吴涛** [47:48]
对 。 对 。 所以当然这两者之间的分野也不是非常明确 ，但我们在这里就把 DBA 划划到 ops 里面吧 。

**Rio** [47:56]
嗯哼 。

**吴涛** [47:57]
对 。 然后它们两者之间的这个这个这个兴趣其实是有冲突的 。

**Rio** [48:02]
嗯哼 。

**吴涛** [48:03]
对 。 就 ， 呃 ， 像我们上次提到那个知乎帖子里面说 ， 就屁股决定脑袋 。

**Rio** [48:08]
哈哈哈 。

**吴涛** [48:09]
对 。 开发者的屁股坐在他们要做新的东西 ，他们要他们要改变世界这一部分 。

**Rio** [48:17]
可能最新最 ， 呃 ， 什么 ， 最新的 ， 然后最炫的技术呢 。

**吴涛** [48:22]
对 。 所以他们他们是奥巴马派的 ，we want change。

**Rio** [48:25]
对 。

**吴涛** [48:25]
但是 ops 这一派就比较比较比较保守 ，他们说 ， 呃 ， 我们要叫什么 ？

**Rio** [48:31]
稳定 。

**吴涛** [48:32]
Stability。 对 。Reliability。

**Rio** [48:33]
嗯哼 。

**吴涛** [48:34]
就是你跑你跑什么东西千万不要坏 ， 坏了我们就有了麻烦 。

**Rio** [48:39]
麻烦 。 就要被什么半夜 3 点被一个 call 起来 ， 然后去去看 ， 哎 ， 服务器宕机了怎么办啊 。

**吴涛** [48:46]
对 。 没错 。 而而 ， 呃 ，developer 担心的则是 ， 哎呀 ，不开发新的东西我就没饭吃了 。

**Rio** [48:52]
哈哈哈 。 嗯 。 所以所以传统上在这些企业里面 ， 现在这两个工种是工种是完全分离的 ，他们有不同的这个职责 ， 然后他们有不同的这个侧重点 。

然后刚才讲的也是因为屁股决定脑袋嘛 ， 所以他们对这个工具的选择也好啊 ， 对这个这个这个包括操作系统的选择也好啊 ，他们都是有不同的取这个取向的哈 。

**吴涛** [49:15]
对 。 而且他们会不停的互相 blame。

**Rio** [49:18]
哈哈哈 。 出了问题 ， 啊 ， 开发那个傻逼写的什么破玩意儿 ， 一开就死机 。

**吴涛** [49:23]
运维那帮傻逼我写的这个东西好好的 ， 就就是跑不起来 。 蠢不蠢 ？

**Rio** [49:29]
就是 。 啊 ， 所以就其实这两个割裂还是有点问题的哈 ， 大家刚才也看到了 。 所以最最就是最近的一个趋 ，也不叫最近 ， 应该有好几年了 ， 这种流行的一个趋势就是说 ， 那我们不要分这么细好了 ， 我们就是二合 ， 就什么合体吧 。

**吴涛** [49:47]
对 。

**Rio** [49:47]
什么我们就叫做什么 devop， 就是它既是开发者 ， 它又是运维的人员 。 就是说就是简单来讲 ， 就是开发者说 deploy your own shit。

就你自己的狗屎你自己去部署 ， 然后你自己去运维 。

**吴涛** [50:02]
吃你自己的狗屎 ， 然后部署你自己写出来的屎 。

**Rio** [50:05]
对 。 然后其实从大的一个角度来讲哈 ， 就是这个可能就刚才我们讲的是一个比较比较比较直白的描述 ，但是有一些比如说很 enterprise 的说法 ， 就是说什么这个什么 end to end ownership， 就是说你这个这个软件的工程的 ， 呃 ， 这个 ownership 就是这个这个全责在哪里 ？

你是从头到尾从它的这个制作到它的这个最终使用 ， 你都是要负全责的 。

**吴涛** [50:33]
对 。

**Rio** [50:33]
这样的话就可以 。

**吴涛** [50:34]
从收集用户的需求开始 ， 然后到把最终产品呈现给用户使用为止 ， 整个过程你都要自己去去完成 。

**Rio** [50:45]
对 。 就这样的话其实 ， 呃 ， 就是理论上说是可以对这个用 ， 呃 ， 这个开发者也好还是运维者也好 ， 它有更大的一个激励机制嘛 。

因为传统上这个开发和运维分开的话 ，有一个这么一个不太好的地方 ， 就是开发者开发完毕之后觉得啊 ， 这个事情就跟我没关系了 ， 然后这个这个东西到底跑起来怎么样啊 ， 性能怎么样啊 ，其实他们就比较不太关心了吧 。

然后这样的话从而得到的成就感可能就哎 ， 那个东西是我从头到脚负责负责到底的 ， 然后你最终用上看牛逼吧 ， 你就说你这种成就感可能就没有那么强烈了 。

**吴涛** [51:21]
对 。

**Rio** [51:21]
所以从某种意义上来讲呢 ， 这种所谓 devop 运动或者说这个 end to end ownership， 它其实有一种也是激励激励开发者有更多的这个动力去去做事的一个方法吧 ， 我觉得 。

**吴涛** [51:34]
没错 。

**Rio** [51:34]
嗯 。 当然同时它这个 devop 运动呢 ， 就它对这个这个软件从业者的技能的要求就有有了更进一步的要求了 。

或者说我们之前有一个另外一个概念叫做 full stack developer 嘛 ， 就是所谓全栈工程师 ， 就是你要从这个硬件底层到最终用户界面 ， 每一个细每一个步骤你都你不说要精通吧 ， 那起码你有了解 ， 你至少要知道出了问题去在哪一层去解决 。

那就是说这个是一个所谓的如果把这个定为一个终极目标的话 ，devop 其实就是在往这个目标上又又又更近了一步嘛 。

**吴涛** [52:08]
对 。 而且其实我觉得 devop 有点多少有点 ， 呃 ，back to the roots 的感觉 ， 就是在很古早的时代每一个程序员都是 devop。

**Rio** [52:20]
哈哈 。 对 。 没有没有还没有那个出现这个 ， 呃 ， 这个 。

**吴涛** [52:23]
它还没有出现分野 ， 对吧 ？

**Rio** [52:25]
对对 。

**吴涛** [52:25]
但是分工就是软件工程变得越来越大的时候 ， 呃 ， 一个人的 scope 可能没办法 cover 到那么那么那么大的范围 。

但是 ， 呃 ， 那个时候的思潮就是要让这一群 devs 做 devs 的事情 ， 然后一群 ops 做 ops 的事情 。 但是现在潮流又反过来了 ， 反过来了 ， 就是要要要要希望一个人能够完成所有的事情 ，因为这样才可以得到怎么说呢 ， 比较比较高质量的 ， 呃 ， 软件 ，并且也会让整个开发过程变得更加敏捷一点 。

**Rio** [53:00]
嗯 。其实刚才讲了那么多哈 ， 就是我们还是要探究一下那个 devop 这个背景啊 ， 刚才讲那个一个激励因素是一个方面 。其实我觉得可能从一个务实的角度来讲 ， 就特别是现在我们不是流行这个创业小团队嘛 ， 小团队的话 ， 那么就隐含的一个条一个一个前提就是人少 。

**吴涛** [53:19]
每个人都要会什么 。

**Rio** [53:20]
对 。 就是说我可能这个团队我就三个人， 如果说你这个三个人， 然后你说你其中一个人只写代码 ， 另外一个只运维 ， 这显然那可能平时那个写代码的人就一直在写代码 ， 然后运维的人部署完了也没什么事干了 ， 对吧 ？

就其实对这个资源的利用也是不太合理的 。 然后另外一方面就是说小公司可能也没有那么那么划分明确的东西 ，因为如果你一旦划分明确的话 ， 你就要在不同的这个人员之间沟通嘛 。

然后沟通的成沟通的话 ，其实对这个效率是有很大很大的这个这个折损的 。

**吴涛** [53:56]
对 。

**Rio** [53:56]
就是如果你说你是一个小小团队的话 ， 你肯定是要减尽量是减少这种折损 ，因为你没有那么多人去 ， 你没有那么多总的那个那个什么脑力去去去消耗 ， 你要把这些东西全部用在实际的价值上面去 ， 你得让他们都他他就是在做真正实在在做事 。

所以其实从这个角度来讲 ，其实 devop 这个运动还是从很多务实的考虑出来的结果吧 ， 我觉得 。

**吴涛** [54:21]
没错 。

**Rio** [54:22]
嗯 。

**吴涛** [54:22]
那要成为一个 devops 其实说难也不难 ，但是说简单也不是很简单吧 。 就如果你只是一个 ， 或者说我是一个很普通的学了一点编程的人， 呃 ， 我怎样才能知道自己要成为一个 devops 需要哪些 ， 呃 ， 额外的知识呢 ？

就是其实这个这个问题有点让我想起就是之前 ， 呃 ，不只是在知乎上， 就是很多地方都会出现的一个问题 ， 就是我是学计算机的 。

**Rio** [54:55]
嗯哼 。

**吴涛** [54:56]
但是我的亲戚朋友让我修电脑 ， 我不会修 。

**Rio** [54:59]
哈哈哈 。

**吴涛** [55:00]
我应该怎么让他们理解我是学计算机的 ，但是我不一定会修电脑呢 ？ 我觉得我对这个问题的回答就是 ， 你一个学计算机的怎么可以不会修电脑 ？

**Rio** [55:12]
哈哈哈 。

**吴涛** [55:14]
当然现在想想这种这种这种反应可能是 。

**Rio** [55:19]
错的呢 。

**吴涛** [55:20]
是是不那么至少是政治不正确的 。 就是你不能要求每一个人， 呃 ， 所选择的专业都是他真正 ， 这么说好像太黑了 ， 都是他真正所喜欢的所 。

**Rio** [55:33]
这个这个没这个没什么好黑的 ， 这个现实就是啊 ， 我相信很多人就是学的那个专业都不是他自己所真真正喜欢的东西 。

**吴涛** [55:40]
对 。在跑在跑计算机科学专业之前 ， 可能完全不知道计算机科学到底是干嘛 。

**Rio** [55:46]
对啊 。 就可能哎 ， 这个这个这个是我没有经历过的一个一个一个一个至少不能理解的一种现象 ，但我也我觉得也可能具体去想也没什么可以后非的 。

就可能有些人就是这样的 ，但在我看来 ， 一个学计算机的不会修电脑是挺让人费解的一件事情 ， 甚至会在主观上去寻找一个怎么才能让别人明白我学计算机的就不会修电脑是一件正常的事情 。

anyway， 就回到 devops 这个话题 ， 就是我觉得这就有点像你要成为一个 devops，但是你只会 dev， 可能就有点像你是一个学计算机的人， 然后你要学会怎么修计算机一样 ， 是一个从从 ， 呃 ， 偏向理论部分转向于理论和实践相结合的一个一个状态的过程 。

**吴涛** [56:40]
嗯哼 。

**Rio** [56:41]
嗯 。 然后还有一部分人是从 op 然后转向 devop，他们又需要学习什么东西 ？

**吴涛** [56:48]
对 。 这个其实也挺有意思的 ， 就是 ， 呃 ， 想象你是一个在中国村电脑城存机长大的孩子 ， 然后在生命的某一时刻 ， 你突然决定说我对硬件搞得这么熟 ， 那我想要研究一下软件怎么弄 。

这个好像也 。

**Rio** [57:12]
我觉得我觉得你这个 crowd 有点大 ， 我们还是说回一个正常一点的 ， 就说你是一个系统管理员 ， 或者你是个网络管理员 ， 然后你怎么想 ， 我也来写几个程序部署来玩玩 。

**吴涛** [57:24]
有这样的人存在吗 ？

**Rio** [57:25]
有啊 ，有啊 ， 肯定是有的 。

**吴涛** [57:27]
可是为什么会有人先成为一个系统管理员而不会编程呢 ？

**Rio** [57:31]
哎 ， 这个就是要要讲的一件事情呢 ， 就是以前什么思科中还还很牛逼的时候 ，不是有什么各种认证嘛 。

**吴涛** [57:41]
嗯哼 。

**Rio** [57:42]
就是什么还有还有好几个什么 CCEP 什么什么 ， 哎呀 ， 明明一下缩写我也想不起来哈 ， 就是专门教你怎么去管理一个组件计算机网络 ， 管理计算机网络 ， 然后包括很多人也就是从这个地方入手吧 ， 然后开始去接触这个服务器的运 ， 就起码就中国互联网早期创业那帮人很多是从这种渠道出来的嘛 。

**吴涛** [58:04]
哦 ， 我明白了 ， 就是就等于把计算机网络管理作为一种技能来教授 。

**Rio** [58:11]
对对 ， 这就是一个还有还可以颁证书的技能呢 ， 当然是很多人有这种方式 。

**吴涛** [58:15]
OK， 我知道这个东西 ， 就那个时候虽然我还小 ，但我总觉得这些东西应该是至少是就是你得先会写程序才会去考的一个东西吧 。

**Rio** [58:25]
不需要 ，不需要 ， 完全不需要 。

**吴涛** [58:27]
啊 ， 原来如此 。

**Rio** [58:28]
我昨天我昨天还有什么北大青鸟 ， 你还有啊 ， 这种各种培训班也是在做这种事情 。

**吴涛** [58:34]
记得记得 。

**Rio** [58:35]
来 ， 现在什么蓝翔绩效估计也在做这个事吧 。

**吴涛** [58:37]
OK。

**Rio** [58:38]
对 ， 就是这这这方面是属于一个比较成熟的 ，因为因为网络其实它是一个演进相对于相对来说比较慢 ， 就是它的这个技术是比较稳定的一个东西嘛 。

然后就会有一些这种成熟的培训体系来做这个教大家怎么去使用组件网络 ， 怎么去就是调试啊之类的东西 。

然后很多这个公司招人的时候也会会去选择嘛 ， 就说那我来招一个网络管理员把这个东西弄好就好了 。

**吴涛** [59:08]
好吧 ， 现在我大概明白了 。 对了 ，OK。 对 ， 那好吧 ， 那我们来说说做一个 devops 到底需要哪些知识 。

**Rio** [59:18]
呃 ， 首先你得知道软件工程 ， 对吧 ？ 那 。

**吴涛** [59:22]
对 ， 你得会写程序 。

**Rio** [59:23]
包括软件工程的所有的那些东西 ， 什么什么算法呀 ， 什么东西之类的 ， 你得全会 ， 就你得先把那个东西做出来 ， 对吧 ？

你得是一个是一个厨师 ， 你得把 。

**吴涛** [59:35]
对 ， 就是或者说我们前两期提及的这些内容你得会 。

**Rio** [59:38]
你得会 。 然后在那基础上你还得知道就是现代的一个服务器 ， 呃 ，是怎么样子的 ， 现在一个它需要一个什么样操作系统啊 ， 它需要什么工具 ， 刚才有讲我们待会会提到一些部署的一些工具 ， 然后你还得知道网络的基础的一些东西是怎么样子的 ， 什么 TCP IP 几层几层 ， 然后每个包干嘛的 ， 然后每一层能做什么 。

因为这样的话你出了问题你才好找 ， 才好调 ， 呃 ， 除错嘛 。 然后你还得会在比如说 Linux 的系统上面配置这些东西 ， 使得它能达到你的那些一些效果 。

你还得知道操作系统的底层啊 ， 什么那些调度怎么样子 ， 然后如此种种吧 。

**吴涛** [1:00:21]
嗯 ， 对 。 所以总结出来就是要有计算机网络方面的知识 ，有 ， 呃 ， 计算机架构方面的知识 。

**Rio** [1:00:27]
对 。

**吴涛** [1:00:28]
并且还要有实践技能 。其实我觉得最重要的一点就是你得明白怎么样才能隔着网络去操纵一台远程的计算机 。

就是当你当你看不到那台计算机的时候 ， 怎么才能操作它 ， 去去探测远程计算机的状态啊 ， 去配置远程计算机的功能 ， 然后把你的软件通过一个 ， 呃 ， 非图形化的方式去部署到那台计算机上， 然后才能去考虑怎么样把它运行起来之类的 。

而这些东西其实都是跟编程没有什么直接关系的 。

**Rio** [1:01:07]
嗯 ， 对 ， 可以这么说吧 。

**吴涛** [1:01:10]
对 ， 就是如果你习惯了在一个 IDE 里面写出一个程序 ， 然后点一下 IDE 的那个 play button， 然后这个程序就跑起来的话 ， 那么可能到这个点上你对于怎样才能让这个程序在一个远程的计算机上跑起来是惘然无知的 。

这一块其实是非常需要需要 devops 掌握的 。

**Rio** [1:01:33]
对 。 呃 ， 换句话说 ， 就是 devops 其实是需要一个软件工程师成为一个计算机行业的文艺复兴人， 就他得什么都会 ， 然后包括你得什么 ， 如果拿什么拿餐厅的来做比较好了 ， 你得是成为一个小餐馆的老板 ， 你得从采购原材料开始 ， 到制作原材料 ， 到上菜 ， 到包括回收盘子洗碗 ， 你都是全套都得都得搞定 ，而不是说像一个五星级酒店大厨 ， 你只用掌勺就可以了

。

**吴涛** [1:02:03]
对 。

**Rio** [1:02:04]
对 ， 所以这种要求还是蛮高的 。

**吴涛** [1:02:07]
可能说到这儿就有些人已经望而却步了 ， 就我不要当 devops， 我好好写我的程序 。

**Rio** [1:02:12]
好累 。

**吴涛** [1:02:13]
对 ， 就是好像好像好像有些后端程序员会说 ， 哎呀 ， 前面那套我不要搞 ， 或者是 ， 嗯 ， 对 ， 回到那个 computer science 的专业生的比喻 ， 就是哎呀 ， 我干嘛要学电脑啊 。其实可能有时候我也会有这样的想法 ， 就是 ， 嗯 ， 这个东西坏了你要我修 ，但其实我是没有那么多时间精力或者是 know how 去去去搞定这件事情的 。

**Rio** [1:02:41]
嗯哼 。 嗯 。

对 ， 这个可能对这个广度的需求会比较高 ，但对深度的需求其实也没有那么多 。 比如说你可能并不真正的需要完全理解这个 Linux 的什么内核才能做 devops， 对吧 ？

其实也没有那个必要 。 就是说并不是说我们刚才提到那些东西你都要每个都要完全精通而已 。

啊 ， 你就有时候可能只是作为一个工具的需求 ， 你知道出了问题怎么去解决它 ， 你并不 ，但如果你有兴趣或者有这个学有余力哈 ， 你愿意去去去再钻研某一个自己的短板 ，其实当然也是很好的 ，但是我觉得也不要想的那么太可怕吧 ， 我觉得 。

**吴涛** [1:03:23]
嗯 ，而且还有很重要的一点就是要掌握一门 script language， 或者是几门 script language， 除了除了 Shell script 之外， 还要掌握什么 Ruby 或 Python 之类的 。

因为我们接下来要提到很多 op tool 其实都是 。

**Rio** [1:03:39]
跑不了的 。

**吴涛** [1:03:40]
对 ， 跑不掉的 。

**Rio** [1:03:42]
嗯 。 好 ， 那么开始介绍这些运维的一些常见的工具吧 ， 好了 。

**吴涛** [1:03:48]
好呀 。

**Rio** [1:03:49]
啊 ， 最简单的一个也是可能比较稍微古老 ， 或者是这个没有那么吓人的一个工具叫做 Fabric。

### 工具

**吴涛** [1:03:56]
嗯哼 ， 这又是我们 Pythonista 喜欢的东西了 。

**Rio** [1:04:01]
对 ， 这是一个什么呢 ？ 这是一个可以用 Python 脚本语言来编程控制 ， 或者说你就写几个 Python 脚本来 ， 然后来控制这个远向某几台远程服务器发送指令的一个工具 。

可以这么说吧 。

**吴涛** [1:04:18]
对 ， 就是其实它是非常简单的一个让你可以 ， 呃 ， 批量处理一堆远程计算机上， 比如说在在在一堆远程计算机上同时运行一个程序 ， 然后看他们的看他们输出结果啊之类的 ， 这样一个一个很简单的工具 。

**Rio** [1:04:39]
就是简单的 ， 就是它可以让你通过 SSH 协议 ， 就其实它就是一个可编程的 SSH 客户端吧 ， 可以这么讲 。

**吴涛** [1:04:47]
然后 Ruby 那边有一个叫做 Capistrano， 这可能这又是一个意大利词 ， 应该看起来像 ， 嗯 ， 的这么一个工具 Capistrano， 然后它也是利用了 Ruby 的这张比较 ， 呃 ， 强力的写 DSL 的功能 ， 呃 ， 搞出这么一套东西 ， 就是它也是一个 Ruby gem， 然后也是可以定义一大堆在远程机器上跑起来的东西 ， 嗯 ， 诸如此类的 ， 只不过是 Ruby 这一边的 。

而且可能应该是要比 Fabric 更强大一点 ， 我觉得 。

**Rio** [1:05:26]
嗯 ，但是不管是这个叫什么 Capistrano 和这个 Fabric 也好啊 ， 它都有一个这个很就它很很很简单的一个工具 ， 就是你只要理解 SSH 怎么回事 ， 就基本上能够写能够用它来做一些自动化的工作 。

但是它的问题在哪里呢 ？ 就是如果它要批量处理多台机器的话 ， 就同时处理多台机器的话 ， 它它要求那些机器的状态是一致的 。

**吴涛** [1:05:52]
对 。

**Rio** [1:05:53]
哎 ，不然会出现什么问题呢 ？ 就是说你写一个脚本 ， 它可能 ， 呃 ， 当然你可以说从用 If 语句去判断它当前的状态是怎么样子 ，但是总总体来讲 ， 呃 ， 如果你的这个操作多台机器的状态不一致 ， 那么你可能执行的每一条指令的成功与失败就不确定 ， 对吧 ？

这样的话你对接下来的要做的操作就会变得分支很多 ， 就管理起来并不方便嘛 。

**吴涛** [1:06:20]
就这一批工具 ， 这两个就是这两个工具的代表 ， 这一这一个操这个抽抽象层级的工具所能帮你做的事情只是把你的一些 ， 呃 ， 日常或者经常需要用到的命令自动化而已 。

它并不能替你解决如果远程机器对于某一个指令的回响和你期望的不一样该怎么办这个问题 。

**Rio** [1:06:47]
嗯 ， 对 。 啊 ， 对 ，其实在说这个之前 ， 我们应该先说如果是手工做应该是怎么样子啊 ， 才有才有个比较明显的对比啊 。

**吴涛** [1:06:55]
嗯 ，OK。

**Rio** [1:06:56]
对 ， 手手工管理一个服务器怎么样 ， 一般就是说你通过什么 SSH 登录上去 ， 然后运行一堆指令 ， 把你的软件部署上去跑起来 ， 然后查看一下状态看是否正常 ， 对吧 ？

**吴涛** [1:07:08]
对 ， 哎 ， 这其实是牵扯到一个问题 ， 就是你要想要成为 devops 的话 ， 或者说你想要了解如何远程操作一台计算机的话 ， 最好的方法是什么呢 ？

是不是拥有一台真正意义上的远程计算机呢 ？ 就买一个 VPS。

**Rio** [1:07:23]
嗯 ， 对啊 ， 这个就能练手嘛 ， 现在有有很方便的那种什么第三方的云的工具 ， 国内有很多 ， 国外也有什么最近比较火的 。

啊 ， 你说 Digital Ocean， 对 ， 它也很便宜 ， 一个月好像 。

**吴涛** [1:07:36]
你转了吗 ？

**Rio** [1:07:37]
五块钱 。 我有它的号 ，但我还没我自己用 。

**吴涛** [1:07:41]
OK， 我现在 metafox.com 的域名是在 Digital Ocean 上面 。

**Rio** [1:07:45]
那你已经不在 Linode 上面了 。

**吴涛** [1:07:47]
对 ， 嗯 ， 对 ， 后来 Linode 也是升级了吧 。

**Rio** [1:07:51]
啊 ， 你是在它升级之前转的是吧 ？

**吴涛** [1:07:53]
我是在它升级之前转的 。

**Rio** [1:07:54]
OK， 就就它升级之后其实两家的那个竞争力也是差不多的 ， 就所以我们我就没有切了 。

**吴涛** [1:08:00]
对 。

**Rio** [1:08:01]
呃 ， 然后传统的有那个

Linode，Linode，Linode。

**吴涛** [1:08:07]
对 。

**Rio** [1:08:08]
啊 ， 还有一些像国内的什么各种云啊 ， 青云啊 ， 什么还有什么阿里云啊之类的 。

**吴涛** [1:08:15]
对 ， 这里有一个这里有个问题 ， 就是我们所在这里推荐的是一个真正一是一台真正意义上的计算机 ，而不是像 Google App Engine 或者是我不知道阿里云是干嘛的 ，但 。

**Rio** [1:08:28]
阿里云跟亚马逊那种差不多 ， 对 。 不 ， 就是也也不对吧 ， 就是它有很庞大的产品的子类 ，但是它的虚拟机那块 。

**吴涛** [1:08:35]
EC2 还是 S2？

**Rio** [1:08:36]
是是是跟 EC2 差不多 。

**吴涛** [1:08:38]
OK。

**Rio** [1:08:39]
啊 。

**吴涛** [1:08:39]
OK。 对 ， 所以比较 。

**Rio** [1:08:42]
打开来玩一下 。

**吴涛** [1:08:43]
拥有一台真正意义上的被虚拟出来的计算机 ，而不是仅仅是一个能够跑你的程序的容器 ， 两者还是还是有蛮大的区别的 。

**Rio** [1:08:53]
对 。

**吴涛** [1:08:54]
后者对于 devops 功力的培养可能没有什么助益吧 。

**Rio** [1:08:58]
对 。

**吴涛** [1:08:58]
也是有啦 ，但没有那么多 。

**Rio** [1:09:00]
哈哈哈 。 啊 ， 就所以最原始的方法就是你直接登录到某一台远程的计算机或者是 VPS 上面去 ， 呃 ， 去做一些操作 ， 然后查看运行状态嘛 ， 刚才也讲了 。

然后， 呃 ，但如果你有不止一台的话 ， 你有四五台的时候 ， 这个整个你每台都重复这个操作就比较繁琐嘛 。

然后像 Fabric 这种工具就是说能够帮你去 ， 呃 ， 自动化掉重复的那一部分 ，但是 ， 呃 ， 如果你的机器机器多了多了之后， 这样呢 ， 就不可避免的有些机器的状态可能并不是非常一致 ， 这个时候你就要一些更加高级的 ， 或者说这个 ， 啊 ， 功能更强大 ， 然后抽象层级更高的一些工具来帮助你解决这个 ， 呃 ， 数量庞大的这个服务器的管理吧 。

啊 ， 一般怎么一般怎么说 ， 就说如果你假设你有超过 ， 啊 ， 十台吧 ， 比如说这个这个数目之后， 你再用像用 Fabric 这种工具来管理就可能不是那么有效了 。

**吴涛** [1:09:57]
对 ， 那个有一个数字是人类同一时间可以关注到的物体的最高数量是多少 ？ 七 ， 五到七 。

**Rio** [1:10:06]
嗯哼 。

**吴涛** [1:10:06]
对 ， 我觉得其实超过五台基本上就有点让人力不从心 。

**Rio** [1:10:10]
力不从心 ， 嗯 ， 对 ， 确实是这样 。 那么然后就会引入像这个叫 Puppet 和 Chef 这种叫做 Configuration Management Tool， 叫配置管理工具 。

**吴涛** [1:10:22]
对 ，Puppet 就是 ， 嗯 ， 小小木偶 ， 嗯哼 ， 对吧 ？ 然后 Chef 就是厨师 。 对 ， 这其实也是两个 Chef 这个这个这个 metaphor 可能还更更更圈一点 ， 就是更绕人一点 ， 就是 Chef 其实它的 metaphor 是你给它准备了一个菜单 ， 然后 Chef 可以按单做菜 ， 就 Chef 这个工具可以给你按单做菜 。

而 Puppet 这个名字的 metaphor 则是你管理那些 ， 呃 ， 计算机就好像去去去操纵一些木偶一样 。

**Rio** [1:10:56]
提线木偶的 。

**吴涛** [1:10:57]
对 ， 提线木偶 。

**Rio** [1:10:58]
嗯 。

**吴涛** [1:10:59]
那么它们两个其实都是目前是竞争关系吧 ， 应该说 。

**Rio** [1:11:03]
呃 ， 一直都是吧 。

**吴涛** [1:11:05]
对 ， 就是 ， 呃 ， 经常会有 ， 呃 ，Python 还是 Ruby，Puppet 还是 Chef 之类 ， 这样也是一个 flame war 的一个起点 。

**Rio** [1:11:13]
又一个圣战 。

**吴涛** [1:11:14]
对 ， 又一个圣战 ，但我觉得 Puppet 和 Chef 好像是没有那么没有那么吵得起来的吧 ，因为两者还是太相像了 。

**Rio** [1:11:22]
它们是就是都是 Ruby 社区里面的东西嘛 ， 然后它们只是说在设计哲学上有所不同 ，但是因为我们 ， 等会儿反正处于处于敌对阵营也无所谓了 。

但是 ， 啊 ， 就它们在干什么呢 ？ 我觉得这个是更加重要的一个问题 。

**吴涛** [1:11:37]
没错 。

**Rio** [1:11:38]
嗯 。

**吴涛** [1:11:39]
呃 ， 你解释一下还是 。

**Rio** [1:11:42]
你来吧 。

**吴涛** [1:11:43]
呃 ， 它们的干

， 好吧 ， 就是你有一个我们可以把一台远程的计算机想象一想象成一个原始材料 ， 然后如果我们沿用 Chef 的 ， 呃 ，metaphor 的话 ， 那么就是我要提供一个菜单 ， 呃 ，在这个菜单上面我详细的不是菜单 ， 应该叫 ， 嗯 ， 做菜的那个东西叫什么 ？

做菜的指令 。

**Rio** [1:12:14]
菜谱 。

**吴涛** [1:12:14]
对 ， 菜谱 ，sorry， 就是我要准备一个菜谱 。 对 ， 告诉你在 ， 嗯 ， 为了要把这个原材料做成一个最终能用的菜 ，也就是一个最终能够跑应用程序的环境 ， 我需要在整个过程中做什么 ， 比如说我需要安装哪一些必要的组件 ， 呃 ， 需要在需要这些组件的什么版本 ， 然后， 啊 ， 每一个组件安装之后， 呃 ， 需要做哪些配置 ，以及把所有的组件的配置做好了之后， 怎样从什

么地方把我的写好的一个程序上传上去 ， 然后把上传上去的程序又要开启什么样的服务 ， 做哪些配置 ，blah blah， 所有这些都一步一步写下来 ， 然后交给 Chef 说 Chef， 这里是我的菜谱 ， 你把我的服务器弄好吧 ， 然后， 嗯 ，Chef 就会或者 Puppet 就会替你完成这些事情 。

大概是这么一个意思 。

**Rio** [1:13:18]
对 ， 所以它们比之于像之前提到的那个 Fabric 工具的进步之处在哪里 ？

**吴涛** [1:13:24]
就是它提供了一种 ， 嗯 ， 它比如说你用 Fabric 就有点像 ， 呃 ， 就有点像写一个程序说 ， 嗯 ， 我要在比如说你在 Chef 里面 ， 嗯 ， 反过来吧 ， 比如说在 Fabric 里面你要写说 ， 啊 ， 首先远程用 SSH 远程连接到这一台计算机上， 然后在那边执行一个指令 ， 看看这个计算机的目前的内核版本是什么 ， 然后比较这个内核版本和我期望的内核版本是不是一致 ，不

一致的话 ， 那我要执行另外一条指令 ， 把这个内核版本升级到什么地方 ， 然后再看看这台计算机上有哪些安装好的 ， 嗯 ， 包 ， 然后比较这些包和我期待的是否一致 ， 如果不一致的话再执行另外一条指令 ， 把这些包安装好 。

所有这些繁琐的操作其实都是为了解 ， 都是为了完成一件事情 ， 就是 ， 呃 ， 安装某一个特定版本的软件包在某一个特定版本的内核上， 对吧 ？

那么在 Chef 这边你所做所有这一切都简化为了一句 ， 你告诉 Chef 说这台计算机上应该有这个内核 ， 然后应该有那个软件包 ， 然后 Chef 就会自动帮你完成这一切 。

所以它其实有一个从所谓 ， 呃 ，imperative 到 declarative 的 ， 就是从命令式向向 declarative 的中文是什么 ？ 说明式的 。

**Rio** [1:14:46]
描述式 。

**吴涛** [1:14:47]
描述式的 ， 呃 ， 语言的这么一个进步 ， 这么一个转向吧 。

**Rio** [1:14:51]
嗯哼 。

**吴涛** [1:14:52]
我觉得这是最重要的进步 。

**Rio** [1:14:54]
对 。 嗯 ，而这里可能有一个小区别要要说明一下， 就是说像 Fabric 这种的 ， 它的核心逻辑还是在这个就是所谓的控制那台电脑 ， 比如说你用你的笔记本上操作这个 Fabric， 然后去向那个远程计算机发送指令 ， 然后那个再执行 ， 就是你的控制逻辑还是在这个叫什么 ， 嗯 ， 你的控制 。

**吴涛** [1:15:17]
在本机上 。

**Rio** [1:15:17]
本机上面 ， 对 ，不是在服务器上面的 。 然后像 Puppet 和 Chef 这两种 ， 我觉得大部分情况下它的那个控制逻辑其实是已经移交到了这个服务器上去再来运行 ， 对吧 ？

**吴涛** [1:15:28]
对 ，因为你在本机上你所做的只是下命令 ，而不是 ， 对 ， 或者说你做的只是描述你要达到什么样的效果 ，而不是你怎么样完成我想要达到的效果 。

**Rio** [1:15:42]
嗯哼 ， 没错 。

**吴涛** [1:15:43]
对 。

**Rio** [1:15:44]
然后这两个工具都是 ， 啊 ，Ruby 写的 ，其实在相当长一段时间内 ， 这两个已经是在市在那个 DevOps 这个这个市场上占着主导地位的一个工具哈 。

**吴涛** [1:15:56]
对 ，de facto stand out。

**Rio** [1:15:57]
对 ， 然后后来 ， 嗯 ， 我们这个阵营 ， 哎 ，不对 ， 就 Python 这个阵营的这这这些哥们们终于站不住 ， 就是什么 ， 就是忍不住了哈 ，因为因为其实在这之前 ，Ruby 在这个服务器运维这一块其实并没有多少人在用吧 ， 照我的理解 。

**吴涛** [1:16:19]
对 ，Ruby 其实这个语言是非常有意思的一个 ， 就是在 Ruby and Rails 出现之前 ，Ruby 是一个没人理睬的语言吧 ， 我觉得 。

**Rio** [1:16:26]
对对对 。

**吴涛** [1:16:27]
就那个时候什么 Zoop 呀 ， 什么那个 。

**Rio** [1:16:30]
就 Python 是一个主导地位的语言 。

**吴涛** [1:16:32]
对啊 ， 当前当年 Zoop 可是跟什么 J2E， 呃 ，JavaE 评分纠错的一个东西吧 。

**Rio** [1:16:40]
对 。

**吴涛** [1:16:41]
就你你要在服务器端完成一个大型的 ， 呃 ， 应用软件 ， 好像在 Ruby and Rails 出现之前 ， 要么 Java， 要么就 Python， 要么就就其他的什么更更偏门的东西 。

但是 Ruby and Rails 出现之后就几乎一夜之间扳倒了整个开发社区的气氛 。

**Rio** [1:17:03]
对 ， 然后我们就看到很多这种 ， 呃 ， 开发运维工具都是基于 Ruby 来写的 ，而且就是就那个在我还是 Python 那个阵营的时候 ， 我曾经一度怀疑说 ， 哎呀 ，是不是应该转向 Ruby 那个阵营啊 ，因为那么多新的有意思的工具都是从那个 Ruby 阵营过来的 。

**吴涛** [1:17:22]
对 ，因为那个时候 Ruby 正在 hype 嘛 ，而且 Ruby 一直都在 hype。

**Rio** [1:17:26]
哈哈哈 。 呃 ，不过现在可能要要要弱一点了 ，因为有像什么 Node 这种工具又起来了 ， 所以 。

**吴涛** [1:17:33]
对 ， 还有 Go 啊之类的 。

**Rio** [1:17:34]
对对 ，不过 ， 嗯

， 就反正我这个这个我觉得这么说还是很安全的 ， 就是说正是因为像 Ruby and Rails 这种框架的崛起 ， 使得 Ruby 在这个服务圈 ， 呃 ， 这个 DevOps 这个圈子流行起来 ， 然后才出现了像 Puppet 啊 ，Chef 这种一系列的基于 Ruby 这个这个这个工具吧 ， 就如果没有这个东西 ， 可能这一切都不会存在 。

**吴涛** [1:18:00]
没错 ， 所以 Ruby and Rails 其实是一个功不可没的起点 ，killer app。

**Rio** [1:18:06]
然后当然 Python 是其实也没闲着啊 ， 后来就出了两套 ， 呃 ， 叫什么新一代的这个就是 Configuration Management Tool 吧 。

**吴涛** [1:18:15]
对 。

**Rio** [1:18:15]
其中一个叫做 Salt， 盐 ， 然后另外一个叫做 Ansible。

**吴涛** [1:18:20]
Ansible，Ansible 是一个缩写吧 ，是是 ，而且不是什么 。

**Rio** [1:18:26]
你这么一问我还真不知道 ， 可以查一下 Ansible 到底什么意思 。

**吴涛** [1:18:32]
Ansible is simple IT automation。 呃 ，wait a second，LE 是哪来的 ？

**Rio** [1:18:44]
哈哈哈 。 嗯 。

**吴涛** [1:18:45]
对 ， 计算机界有两件最难的事情 ， 一件是 cache invalidation， 另一件就是 naming things。

**Rio** [1:18:51]
哈哈哈 。

**吴涛** [1:18:53]
而而比这所有更难的一件事情就是 figure out 这个东西是怎么被命名的 。

**Rio** [1:19:01]
对 ， 啊 ， 这个就不知这叫什么意思啊 ， 我也没我也没没没有查到 。 但是这两个都有一个共同点哈 ， 就说 ， 啊 ， 应该是说 ，不 ， 先说这个 Puppet 和 Chef 它们的这个这个编写那个脚本的东西都是使用了 Ruby 的脚本 ， 然后用那个 DSL 的方法来写 。

**吴涛** [1:19:20]
我靠 ， 我查到了 。

**Rio** [1:19:22]
啊 ，是什么 ？

**吴涛** [1:19:23]
它居然是 《 恩德 》 游戏里面的安赛波 。

**Rio** [1:19:26]
什么玩意儿 ？

**吴涛** [1:19:27]
就是 ， 呃 ，有一个有一个有个非常非常非常非常 awesome 史诗级别的科幻小说 ， 如果你没看过的话一定要去给我看 ， 叫做 《 安德的游戏 》。

**Rio** [1:19:37]
OK。

**吴涛** [1:19:38]
呃 ， 前阵子去年被拍成 ， 前年被拍 ， 去年前年被拍成了电影 。

**Rio** [1:19:41]
谁写的 ？

**吴涛** [1:19:42]
呃 ，Scott Cart， 呃 ， 叫 ， 嗯 ， 卡德吧 ， 应该我记得中文好像我看短 ，《 安德的游戏 》，sorry， 原谅我的语无伦次 ，因为这部 ， 呃 ， 科幻小说实在是太史诗级别了 。

就是 ， 呃 ， 作者应该叫 Scott Cart， 斯科特 · 卡德 ， 然后他写了一系列 ， 呃 ，由一个 ， 嗯 ，也不是小男孩 ，但是在 《 安德的游戏 》 这部书里面 ，他还是一个小男孩的为主角的科幻小说 ， 然后这部科幻小说第一卷就叫做 ， 呃 ，《Enders Game》， 就是 《 终结者的游戏 》，但是中文一般翻译成 《 安德的游戏 》，因为这个主角就叫 Ender， 我们俗话说叫 Ender， 然后它是非常非常好看的一部一部一部科幻

片 ， 呃 ， 科幻电影 。 呃 ，2003 年的时候这部片 ， 这部这个这个 ，sorry， 它是非常好看好好看的一部科幻小说 ， 然后 2003 年的时候它被翻拍成了电影 ，但是电影没有原著的十分之一吧 ， 我觉得视觉效果是很炫了 ，但是原著里面的很多非常让人激动或者乃乃至难过的片段其实都没有呈现得很好 ， 然后这一部 。

**Rio** [1:20:59]
这不是所有小说改编成电影的 ， 然后小说读过小说的人都有这种感觉吗 ？

**吴涛** [1:21:04]
也不尽然吧 ， 就是有些电影让我觉得比小说要好 。

**Rio** [1:21:08]
OK。

**吴涛** [1:21:09]
但一时也想不出来名字 ，但总之这部电影里面有就是讲述的是人类和 ， 呃 ， 一个虫族 ， 就是这对 ， 就有点像那个 《 星之梦 》 里面的 Zerg 的感觉 ，但是这部小说出来的时候 ， 呃 ，1985 年的小说 ， 这是那个时候还远远没有 Zerg， 什么星舰 Star Trooper， 呃 ， 那个星舰散兵那部科幻电影可能也可能都没有出来 。

然后在里面它描写了一个人类和遥远的虫族之间的战争 ， 然后其中里面有一种超光速通信工具 ， 就叫做 Ansible， 安赛波 ， 所以这个名字是这么来的 。

**Rio** [1:21:49]
OK。

**吴涛** [1:21:50]
啊 ， 我立刻我立刻爱上了这个软件 。

**Rio** [1:21:53]
哈哈哈 。 不过其实这里也说到了一个问题啊 ， 就是说 ， 啊 ， 为什么 ， 呃 ，他们要做这个东西 ，其实也是因为就他们很多人抱怨这个 Puppet 和 Chef 太慢了嘛 ， 就是你如果你管理什么几百几百什么上千台机器的时候 ， 那个什么归宿啊 ， 就是你运行完一个脚本肯定要半个小时这样 ， 然后他说要从根本上解决这个问题 ， 那个什么就不能那些是救不

回来了 ， 你要重新要什么 start over， 你才可以解决这个问题 。 然后就有这么两个 Python 社区来的工具啊 ， 一个叫做 Salt， 一个叫 Ansible， 刚才你也提了 ， 然后它们的一个特点呢 ， 就是用户看到的一个特点 ， 就是它们的这个配置语言是 YAML， 就是哇 ， 这要解释一下 。

**吴涛** [1:22:39]
Yet another mockup, yet another mockup language.

**Rio** [1:22:42]
就是一个比 XML 简单 ， 然后比 JSON 强大 ， 然后跟 JSON 是一个 JSON 的超级的这么一个配置语言 。

**吴涛** [1:22:49]
嗯 ，而且它最大优点是人类读的时候也非常舒畅 。

**Rio** [1:22:53]
就可以手写 ， 然后可以可以可以裸眼读 ，不需要借助任何工具 ， 比较爽 。

**吴涛** [1:22:59]
读 XML 让人想死 ， 对吧 ？ 读 JSON 略好 ，但是读 YAML 就非常像读一个正常的人类文档 。

**Rio** [1:23:07]
JSON 读起来还行 ， 就是写起来太费劲了 ， 各种限制比较多 ， 比如说不能加注释啊 ， 然后 key 必须要括起来啊 ，blah blah， 然后之类的 。

啊 ， 这个跟 Puppet 和 Chef 它们在就起码在用的时候你有个很鲜明的对比 ， 就是 Puppet 和 Chef 它们都是用那个 Ruby 的 ， 直接就又是一个什么 class 文件嘛 。

**吴涛** [1:23:26]
对 。

**Rio** [1:23:27]
啊 ， 然后这里就有一个取舍的好 ， 或者说你你想为什么 Python 社区的人不用 Python 写呢 ？ 当然其中一个主要的原因是因为 Python 写 DSL 并不方便 ， 然后语法限制比较多 ， 然后 。

**吴涛** [1:23:39]
对 ，Python 其实本身就有点像 DSL，但 ， 嗯 ， 呃 ， 或者我我觉得我知道我这个描述可能非常怪异 ，但 Python 给人的感觉就是它明明是一种泛用的编程语言 ，但是你在写它的时候就好像觉得自己在写某一种 。

**Rio** [1:23:58]
英文吗 ？

**吴涛** [1:23:59]
某一种 ， 对 ， 某一种不那么像像写程序的程序 。

**Rio** [1:24:03]
嗯哼 。

**吴涛** [1:24:04]
而 DSL 给人的感觉其实也是这样 。

**Rio** [1:24:06]
嗯哼 。 呃 ，但问题是说 Python 呢 ， 它的那个语法限制比较多嘛 ， 比如说它对这个对对缩进有要求 ， 然后对这个啊 ， 这个 block 也有要求 ， 就不像 Ruby 的语法那么灵活 ， 这样的话作为一个配置工具 ， 你要求这个用户学的东西就比较多了 。

但是说我也一直没搞明白这个的这个的点在哪里 ，因为你始终还是要学 Python 这个这个语言才能用的嘛 。

啊 ，不过呢 ， 它用那个 YAML 这种也有也是有一个明比较明显的好处的 ， 就是说它可以啊 ， 比较方便的用机器去读这些配置文件 ， 然后去用机器去处理它 ，因为这和 Ruby 的那种方式那种就不太一样 ，因为 Ruby 那种的话你必须解运行过才可以 ， 对吧 ？

它并不是一个 ， 就怎么讲呢 ， 它并不是一个就是 code is code， 然后这个 data is data， 对 ， 它这两个是分离的 ， 然后在 Python 的这个这个 YAML 这种方式的话 ， 就说 code is data，data is code， 就有点这个意思在里面 。

**吴涛** [1:25:08]
没错 。

**Rio** [1:25:08]
啊 ， 虽然 YAML 并虽然 YAML 本身并不能直接执行 ， 还是要依靠这个 Python 去解析它 。

**吴涛** [1:25:13]
对 ，而且我觉得另外一个优点就是 ， 呃 ，在 Puppet 和 Chef 里面你可以 ，因为它是 DSL， 它毕竟还是它还是 Ruby， 你还是可以编程的 。

**Rio** [1:25:22]
嗯哼 。

**吴涛** [1:25:23]
而写 YAML 的时候它会强迫你 ， 或者说它会提示 。

**Rio** [1:25:26]
你不能不编程了 。

**吴涛** [1:25:27]
对 ， 你不能再编程了 ， 这个地方你该 declarative 给我好好 declarative， 你不要再那像写 Chef 或 Puppet 脚本的时候 ， 你可以加入一些私货 ， 你可以说这个地方 ， 哎 ， 我要做一些东西 ，而因为我可以 ， 所以我要做 。

**Rio** [1:25:43]
对 ，但这个就是有时候是一个怎么讲呢 ， 一个可维护性和易用性之间的这个权衡嘛 ， 就是说因为其实如果你真的去用那个 Ansible 这种一些啊 ，因为我用 Salt 没有用过哈 ， 就是我用过 Ansible， 就是去做一些部署 ， 然后其实你真的用的话会发现 ，其实你有时候还是逃不掉要做一些 ， 比如说简单的什么循环啊 ， 那种这种批量的操作的时候 ， 你还是用很坑爹的

用那个 YAML 的语法去写一些东西 ，但这个好处就是说你知道那里是在干嘛 ， 然后你能能比较好的判断这个用程序去判断它的那个状态 ，但是 ， 呃 ，但是写起来就比较比较费劲了 ， 然后那个语法因为它并不是一个完整的编程语言嘛 ， 就很怪异的一个状态 ，但是这个时候你就用如果用 Ruby 这种方式去写的话 ， 就会会爽很多 ， 只要你只要你会 Ruby 嘛 ， 你

写个循环多简单 ， 对吧 ？ 那个所有的语法你都知道 ， 然后你该操作怎么就很都很都很正常 ， 所以这里也是一个不同的这个什么就设计哲学的这个区别吧 ， 我觉得 。

**吴涛** [1:26:44]
而且我觉得这个问题可能也不仅仅是在 Ansible 这边会有 ， 那你刚才说描述的这个情况让我想起了就是 AngularJS。

**Rio** [1:26:53]
嗯哼 。

**吴涛** [1:26:54]
呃 ，AngularJS 在很大一部分程度上是试图去把 HTML 的语义扩展出来 ， 就是 AngularJS 可以自定义一个 HTML tag。

**Rio** [1:27:04]
嗯哼 。

**吴涛** [1:27:05]
然后这个 HTML tag 所呈现出来的东西 ， 它的外观以及它的行为可以通过 HTML 和 CSS 和 JavaScript 去去去去定义 。

**Rio** [1:27:15]
嗯哼 。

**吴涛** [1:27:16]
但是你在定义的过程中会发现 ，有时候你几乎是在用 HTML 来编程 ， 就你会试图用 HTML 写一些和逻辑相关的东西 ， 这个让我觉得挺不爽的 ，但很显然这也是这也不是 HTML 的错 ， 然后在 Ansible 这边这也不是 YAML 的错 ， 就是有时候有些场景逼迫你不得不这样做 。

**Rio** [1:27:37]
对 。

**吴涛** [1:27:37]
而工具的切分则是相对来说比较分明的 ， 你不可能在这里面 ， 呃 ，有那么多的灵活性 ， 如果你要如果你要尊重 ， 呃 ， 工具之间的区别的话 。

**Rio** [1:27:51]
对 ， 这也是我比较担心的一个问题啊 ， 就是特别是看到 Ansible 那个那个模板 ， 就是那个 YAML 语法之后的一个问题 ， 就是说很有可能你知道你很我们之前也吐槽过 Java 程序员因为这个 Java 的灵活性太差 ，也被迫被逼不得已使用什么 XML 来编程了吗 ？

**吴涛** [1:28:10]
对 ， 没错 。

**Rio** [1:28:11]
对 ， 我觉得可能 YAML 如果它之后搞不好会陷入同样的这个困境 ， 就是要用被迫要用 YAML 来编程 。 啊 ， 所以其实这里要吐槽一下， 就是其实为什么没有人用 Ellipse 写一个写一个这个这个配置工具 ， 就没有这个问题了呀 ， 这个真的是 data is code，code is data。

**吴涛** [1:28:33]
这个还真有 ， 就是 ， 呃 ，也我当然我不确定你这个是不是你真的要了 ，但是你知道基于 Ellipse 的那个 Java dialect 不反了 ， 基于 JVM 的 Ellipse dialect。

**Rio** [1:28:48]
嗯 ， 那 closure。

**吴涛** [1:28:50]
嗯 ， 对 ，有一个 ， 呃 ， 运维工具叫做应该是叫做 Pallet。

**Rio** [1:28:55]
嗯哼 。

**吴涛** [1:28:56]
就是用 closure 写的 。

**Rio** [1:28:59]
所以它的配置文本是 。

**吴涛** [1:29:00]
它的配置文本其实就是它的运行脚本 。

**Rio** [1:29:03]
OK。

**吴涛** [1:29:03]
脚本级配置配置级脚本 。

**Rio** [1:29:05]
然后它的那个什么脚本也是可以当做 data 来处理的 ， 所以 。

**吴涛** [1:29:10]
没错 。

**Rio** [1:29:11]
存在这个问题啊 。

**吴涛** [1:29:12]
对 ， 这个东西叫做 Pallet，但是因为它是需要 Java dependency， 就是你本来搞东西可能已经非常臃肿了 ， 然后还要加一个 Java dependency。

**Rio** [1:29:22]
对 ， 这个可能就是一个比较麻烦的问题啊 ，因为像你如果你凡是一个东西是基于 JVM 的话 ， 那你首先你那个目标机器上你至少要要得有一个才可以运行了 ， 对吧 ？

然后 JVM 的启动啊那些也并不算得迅速吧 。

**吴涛** [1:29:37]
没错 。

**Rio** [1:29:37]
对 ， 一个那种如果你需要轻量级的做一些配置 ，其实我觉得可能不是特别好的一个选择 。

**吴涛** [1:29:43]
对 ， 所以 Pallet 不是非常适合你一些比较 ， 嗯 ， 啊 ， 中等量级的 ， 尤其是如果你的你要部署的东西本身跟 Java 没什么关系呢 ， 徒增一个 Java dependency 简直是 。

**Rio** [1:29:56]
对 ， 何必呢 ， 真的 。 OK， 啊 ， 那说回这个 Salt 和 Ansible 这两个东西啊 ， 就它们的还有在设计哲学上跟那个 Puppet 和 Chef 还有点不一样哈 。

**吴涛** [1:30:09]
没错 。

**Rio** [1:30:10]
嗯 ， 就 。

**吴涛** [1:30:11]
你来说吧 。

**Rio** [1:30:12]
至少 Salt 这个东西是比较 Salt 其实有点像 ， 呃 ，Fabric。

**吴涛** [1:30:18]
嗯哼 。

**Rio** [1:30:19]
在某种程度上， 只不过 Salt 会比较 ， 哎呀 ， 怎么说呢 ， 就更加是 Fabric 的升级版本吧 ， 就是首先 Salt 是基于 ZeroMQ 的 ， 就其他的 Puppet 和 Chef 也好 ， 全都是基于 SSH， 就是它的底层传输协议都是 SSH，而 Salt 则是基于 ZeroMQ 的 ， 就 MQ ZeroMQ， 这什么是 ZeroMQ 你来解释一下 。

**吴涛** [1:30:43]
啊 ，ZeroMQ 你可以认为它是一个增强版的套接字 Socket。

**Rio** [1:30:49]
对 。

**吴涛** [1:30:49]
然后它可以让你做 ，因为你知道我们通常用的那个 TCP Socket， 它是一个基于流的嘛 ， 基于 stream 的 ， 你你不知道这个这个流的开头结尾怎么样 ， 你得去读那个内容 ， 然后自己定义协议去判断嘛 。

然后 ZeroMQ 的话 ， 它是基于 message， 就是基于消息的 ， 消息的话就是一个有定有一个固定的 ，也不叫固定长度 ， 就是它是你可以每有这个每一个消息之间它是有一个固定边界的 ， 就是你知道消息之间消息怎么样 ， 然后它可以让你做一些比较 ， 呃 ， 普通的这种 Socket 做不到的事情 ， 比如说它可以让你做一个什么 pub sub 啊 ， 可以做一个 queue 啊 ， 这种更加丰富多样的一些拓

扑结构吧 ， 然后它的性能就就是性能是非常不错的一个一个通讯工具 。

**Rio** [1:31:33]
对 ，broadcast actually。

**吴涛** [1:31:35]
对对对 。

**Rio** [1:31:36]
当然它最大的败笔可能是用 C++ 写 。

**吴涛** [1:31:38]
呃 ， 就它的就安装和依赖会比较比较麻烦 。

**Rio** [1:31:42]
我记得 ZeroM 我在什么地方读过 ZeroMQ 的作者说 ， 如果给他上天给他再来一次机会 ，他会选择用 C 来重写 ZeroMQ。

**吴涛** [1:31:50]
ZeroMQ 那个那个原作者就自制意吧 ，他已经分就跟原那个分裂了嘛 ，他就自己真的用那个那个 C 在写 。

**Rio** [1:31:59]
C 去重写了吗 ？

**吴涛** [1:32:00]
叫做 。

**Rio** [1:32:00]
啊 ， 真的吗 ？

**吴涛** [1:32:01]
叫 NanoMessage。

**Rio** [1:32:02]
啊 。

**吴涛** [1:32:03]
NanoMSG 就也是那个人， 呃 ， 就作者之一吧 ， 干的 ， 然后 ZeroMQ 它现在是一个有一个公司来推动的一事情 ， 就是那个那个作者之一 ，他出去搞了这个东西 ， 然后他就改用 C 写了 。

**Rio** [1:32:16]
对 。

**吴涛** [1:32:18]
呃 ， 对 。

**Rio** [1:32:18]
嗯哼 。 总之 Salt 就是一个基于 ZeroMQ 的这样一个 ， 呃 ， 呃 ，message bus， 呃 ， 来写的这么一套配置工具 ， 然后它其实也是要有一台 master， 然后， 呃 ，clients 在那边叫做 minions。

**吴涛** [1:32:34]
嗯哼 。

**Rio** [1:32:34]
就那个 dispersible mean 里面的那个 minions。

**吴涛** [1:32:39]
像 。

**Rio** [1:32:40]
像小黄人， 对 ， 香蕉人。 对 ， 然后它的功能 。

**吴涛** [1:32:43]
就是小兵的意思吧 ， 对吧 ？

**Rio** [1:32:45]
Minion 我怎么记得 minion 其实是仆从嘛 ， 就是随呃 ， 我的控我手下的小喽啰 。

**吴涛** [1:32:52]
被我控制的 ， 哎 ， 小喽啰 ， 对 ， 这个词 。

**Rio** [1:32:54]
对 ， 我记我记得这个词我是从那个 Dungeon Keeper 里面学的 。

**吴涛** [1:32:59]
哈哈哈 。

**Rio** [1:33:01]
又暴露年龄了 ， 对 。 嗯 ， 对 ， 然后 Salt 是一个相对来说要比 Puppet 和 Chef 简单多的工具 ， 它安整个安装过程就是在 master 上安一个包 ， 然后在 client 上安一个包 ， 然后就完了 。

嗯 。

**吴涛** [1:33:18]
而这一点可能跟那个 Ansible 就是还区别蛮大的 ， 就是 Ansible 其实不需要在客户端上安装任何东西的 。

**Rio** [1:33:25]
但是 Ansible 在 。

**吴涛** [1:33:26]
你可以 。

**Rio** [1:33:27]
服务端上安装的东西是专门专门要写本书的 ， 就那个也不是专门写本书 ， 反正专门有个教程来教你怎么在服务端上安安装一个 Ansible。

**吴涛** [1:33:39]
对 。

**Rio** [1:33:39]
但是 。

**吴涛** [1:33:40]
你可以不用装 ，但是就是如果你是就数量不多的情况下 。

**Rio** [1:33:44]
对 。Ansible 也是由企业级解决方案的 ， 对吧 ？ 就是要装装一个 Console 什么的 。

**吴涛** [1:33:50]
其实这几个都是嘛 ， 就是像 Puppet 也好 ，Chef 也好 ，Salt 也好 ， 它们都是一个共同的一个方式 ， 就是说它们有一个这个商业公司来提供这种商业级别的就付费的啊 ， 商业支持 ，但同时又有一个免就是开放的就是社区版本嘛 ， 就是所有的都是基于一个开源软件 ， 然后开源社区的 ， 然后做一些商业化的这个支持的这么一个盈利模式 。

**Rio** [1:34:12]
嗯哼 。

**吴涛** [1:34:13]
应该这么说是安全的 ， 对 。

**Rio** [1:34:15]
对 。

**吴涛** [1:34:16]
嗯 。

**Rio** [1:34:17]
呃 ，但是我记得 Salt 其实也是有所谓 ， 呃 ，masterless minion 的一个一个模式的 ， 我们就是我们这一期最大的问题就是我们两个其实都没有什么实际的使用经验 ，而且 。

**吴涛** [1:34:29]
因为我只用过这个 Ansible，Salt 其实我是没没怎么用 。

**Rio** [1:34:33]
OK。

**吴涛** [1:34:33]
应该是它比 Ansible 后出现吧 ， 应该是 ， 对 。

**Rio** [1:34:36]
对 ，其实 Salt 最简单的用法 ， 我不知道 Ansible 能不能做这件事情 ， 就是 Salt 最简单的用法就是比如说 Salt 专门有个命令行工具叫 Salt。

**吴涛** [1:34:44]
嗯 。

**Rio** [1:34:44]
Salt， 呃 ， 然后那个 ， 嗯 ，hostname，hostname 可以用比如说 ， 呃 ， 那个 asterisk，asterisk 就是 。

**吴涛** [1:34:55]
嗯 ， 星号 。

**Rio** [1:34:55]
呃 ， 星号来来来指代所有可以被 ， 呃 ， 抵达的这个 ， 呃 ，minion， 然后 Salt， 呃 ， 星号 ， 然后 ping， 然后所有的那个 ， 嗯 ，manual 都会执行 ping 命令 ， 诸如此类的 ， 就是它有最简单的一个用法 ， 就是直接用命令行下面的 Salt。

**吴涛** [1:35:18]
嗯哼 。

**Rio** [1:35:18]
然后你也可以在 master 上面说所有的 minion，Salt 所有的 minion 一起来 ， 比如说 ， 呃 ，install package vim。

**吴涛** [1:35:27]
嗯哼 。

**Rio** [1:35:27]
然后所有的 ， 呃 ，minion 也就会去安装 minion， 呃 ， 安装 vim。

**吴涛** [1:35:32]
对 。

**Rio** [1:35:33]
然后接下来就是你可以写一个脚本来来来批量完成一些 ， 嗯 ， 呃 ， 叫做 formula， 对 ， 这个应该是跟 brew 一样 ， 叫做 formula。

**吴涛** [1:35:44]
嗯哼 。

**Rio** [1:35:44]
就是你可以执行一系列脚本 ， 然后这些脚本叫做 formula， 可以就有点像 ， 呃 ，Puppet 或者是 Chef 那样 ， 可以自动化完成一系列一系列作用 ， 呃 ， 一系列行动这样 。

**吴涛** [1:35:58]
对 ， 所以所以为什么说就实际用的时候 ， 为什么 ， 呃 ， 这个 Ansible 还还好也好 ， 还是这个 Salt 也好 ， 它会比 Puppet 和 Chef 这种跑起来更快呢 ？

这里可能要解稍微解释一下哈 。

**Rio** [1:36:11]
嗯哼 。

**吴涛** [1:36:12]
就是说 ， 呃 ，因为也是刚才提到那个脚那个配置语言的一个关系吧 ， 就是说 Puppet 和 Chef 它它配它每个机器上它要跑一遍那个脚本 ， 它跑完之后才能知道这个状态是否达到你所要的需求 ， 对吧 ？

就每次你不管做什么改动 ， 它都要把那个脚本完完整整从头到尾跑一遍 。 但是像 Salt 和 Ansible 这两个东西 ， 它是因为它的配置文件是一个描述性的语言嘛 ， 呃 ，不是语言 ， 就是描述性的数数据结构 ， 这样的话它可以直接跳过中间已经满足的那些东西 ， 它不需要每次都执行完那个脚本 。

对 ， 我我觉得 。

**Rio** [1:36:49]
对 。

**吴涛** [1:36:49]
这么描述应该是正确的吧 ？

**Rio** [1:36:51]
应该是正确的吧 。

**吴涛** [1:36:52]
对 ， 啊 ， 就所以可以有 ， 呃 ， 很大程度上可以减减少这个每一台机每一台服务器上需要等待的时间 ， 这样的话就可以大幅度提高这个部署的速度嘛 。

**Rio** [1:37:03]
没错 。

**吴涛** [1:37:03]
嗯 。 呃 ， 然后这几个常见的 up tool 我们就讲到这里 ， 下面还有一些不常见的就带过吧 ，有个什么 Perl 的 Rex 你也你也写到有 。

**Rio** [1:37:15]
对 ，Rex 是一个反正也是有集中的那一个 。

**吴涛** [1:37:20]
Perl 现在还有人在用吗 ？ 我现在就是 。

**Rio** [1:37:23]
不要这样 。

**吴涛** [1:37:24]
这么这么说真的不太好哈 。 对 ，但是确实是不太不太流行的一个语言 。

**Rio** [1:37:30]
我的前前公司安装了一个一套机房组件 ， 我忘了是什么 ， 好像是某一套电源电源管理系统 。

**吴涛** [1:37:38]
电电 。

**Rio** [1:37:39]
OK， 电源管理系统 ， 对 ， 给了一批配置工具 。

**吴涛** [1:37:42]
嗯哼 。

**Rio** [1:37:42]
啊 ， 就是用 Perl 写的 。

**吴涛** [1:37:43]
就感觉就是新的那些工具基本上都没有用 Perl 写的了 。

**Rio** [1:37:47]
对 ，Perl 是一个 Perl 就是 80 年的 80 年的 Ruby 嘛 。

**吴涛** [1:37:52]
对 。

**Rio** [1:37:52]
那个 Hype 的劲儿 。

**吴涛** [1:37:54]
它现在好像已经过期了 。

**Rio** [1:37:56]
对 。

**吴涛** [1:37:57]
这么说应该是安全的 ，不会被人喷吧 ？

**Rio** [1:37:59]
那很难说啊 ，Perl 也是有 。

**吴涛** [1:38:02]
我想最最最近我用的一个 Perl 写的工具还蛮令我意外的 ， 那个 Linode 它不是开发了一个命令行工具 ， 让它可以不用网页版 ，不用登录网页 ， 可以直接操纵那个虚拟机吗 ？

**Rio** [1:38:13]
嗯 。

**吴涛** [1:38:14]
那东西是 Perl 写的 ？

**Rio** [1:38:15]
用 Perl 写的 。

**吴涛** [1:38:16]
啊 ， 安装过程 。

**Rio** [1:38:17]
我们 fucking god。

**吴涛** [1:38:18]
你你试一下在 brew 里面安装的话 ， 你会发现那个安装过程超级超级长 ， 它下载可能好几百个 Perl 的包 。

**Rio** [1:38:26]
OK。

**吴涛** [1:38:27]
天哪 ， 我真是 anyway。

**Rio** [1:38:30]
啊 。

**吴涛** [1:38:30]
就是唯一一个现代一点的 Perl 的用户 ， 然后给我感觉就这么糟糕 ， 所以你可以想而知这个后面是多么惨烈的一个状况 。anyway， 下面我们过渡到今天最最核心的内容 ， 就是 containerization。

**Rio** [1:38:48]
当当当当当当当 。

### 集装箱化

**吴涛** [1:38:50]
这个先要解释一下这个 containerization 是什么玩意儿 ， 就就简单说就是集装箱嘛 。

**Rio** [1:38:55]
对 ， 集装箱化 。

**吴涛** [1:38:56]
对 ， 集装箱化 ， 对 ，但是要解释集装箱可能要牵涉到那我们这讲集装箱化是是在软件世界里面这样讲 。

**Rio** [1:39:04]
对 ， 我们在讲一个 metaphor，但是其实在现实世界里面这个 metaphor 也是同样同等重要的 ， 对 ， 就 ， 呃 ，containerization 可能是人类最重要的发明之一 。

**吴涛** [1:39:15]
不可能 ， 没有之一 ， 可能最重要的发明 。

**Rio** [1:39:18]
不可能啊 ， 人类最重要的发明是火 。

**吴涛** [1:39:20]
好吧 。

**Rio** [1:39:22]
不 ， 就是现代社会 ， 现代社会可能集装箱是一个就如果有排前十的话 ， 它可能至少能列到前五 。

**吴涛** [1:39:30]
呃 ， 好吧 ， 我们来排一排好了 。

**Rio** [1:39:34]
算了算了 。

**吴涛** [1:39:35]
还是吧 。

**Rio** [1:39:36]
对 ， 总之总之抽水马桶和集装箱可能是彻底让我们变得文明起来的必要条件 ， 两个必要条件 。

**吴涛** [1:39:44]
嗯 ， 就是如果没有集装箱 ， 就肯定没有什么现代什么全球化 ， 没有什么现代经济 ， 我们也没有办法在这里扯什么犊子 。

**Rio** [1:39:51]
没错 。

**吴涛** [1:39:52]
嗯 。

**Rio** [1:39:52]
呃 ， 为什么呢 ？ 因为 ， 呃 ， 曾经有这么一个时代 ， 甚至离我们不是特别遥远 ， 就是在二战 ， 应该是在二战之前 ， 就是大概六 ， 划一分水岭的话就是 191960 年之前 。

**吴涛** [1:40:07]
嗯 。

**Rio** [1:40:08]
整个世界的航运系统是怎么说呢 ， 分散的 ，是没有一个统一的 ， 没有就是这么说吧 ， 就 60 年代之前在集装箱发展出来之前 。

**吴涛** [1:40:22]
嗯哼 。

**Rio** [1:40:23]
整个人类的物流系统是非常臃肿和零散的 。

**吴涛** [1:40:27]
对 ， 这里要可能要一个比较形象的描述哈 ， 就是说假设 ， 嗯 ， 我当你在德国 ， 对吧 ？

**Rio** [1:40:34]
对 。

**吴涛** [1:40:35]
我在加拿大 ， 然后你准备给我运 10 吨大米过来 ， 举个例子 ， 就我们虽然不明白为什么要这么干 ，但是可以可以讲一下这个过程就是要会有多繁琐 ，因为你你你首先你是在一个内陆的城市 ， 对吧 ？

**Rio** [1:40:48]
对 。

**吴涛** [1:40:48]
你不是在海港 ， 你得先把那 10 吨大米想办法装到一个车上面或者火车上面 ， 然后这个火车或者是卡车拖到那个德国的一个海港上， 然后再装船 ， 那再运到我这里来 ， 我这里边是我这里是个港口 ， 可能还好 ，但是就就说说你那段吧 ， 应该主要的运输的难度都已经能够覆盖的到了 ，因为这个米是一个小颗粒嘛 ， 散装的东西 。

**Rio** [1:41:09]
对 ， 它是散的东西 。

**吴涛** [1:41:10]
啊 。

**Rio** [1:41:10]
首先你第一步就是你要解决一个容器的问题 ， 你是装在袋子里还是装在桶里呢 ？ 袋子和桶都有各有各的各有各的优点 ， 比如说袋子比较比较灵活 ， 你可以把几袋米叠在一起 ，但是袋子容易破 。

**吴涛** [1:41:23]
不 ，不光是有这个问题 ， 就是说 ， 呃 ，不是所有的地方 ，因为你你装袋是要有成本的嘛 ， 袋子首先本身是要成 10 吨大米 ， 你要装多大 ， 你要如装那种我们常见的那种什么几十公斤的一个小袋 ， 你得装好几多少 ， 几百包吧 ， 几几千包这样的 。

**Rio** [1:41:37]
对 。

**吴涛** [1:41:37]
然后这其实这个是一个你装填的时候就是一个成本 ， 然后如果像像这种成这种规模的运输的话 ， 很多人他们都是所有都用这个散货 ， 就是你直接装到一个大的容器里面 ， 然后整就不用再分袋小装了 ， 然后再装再再运输这样 。

**Rio** [1:41:53]
对 ，但是散货的盒子又有一个又不能太大又不能太小 。

**吴涛** [1:41:58]
呃 ， 散货的话你要比如说你先有个卡车 ， 对吧 ？ 你先散货装在一个卡车上面 ， 你也得把想办法把那个东西那些米装到那个卡车里面去 ， 对吧 ？

然后卡车有不同的尺寸 ， 对吧 ？ 你可能你可能一个车装不了 ， 你还得搞几个车 ， 能 10 吨可能体现不出来 ，有些卡车 10 吨就能装上了 ， 那 100 吨吧 ， 我们可能要运好几卡车 ， 然后可能卡车的这个形状还不一样 ， 那你怎么办 ？

然后你到了卡车到了海港边 ， 如果你是散货的话 ， 你得想办法怎么去装到这个一个船上 ，因为船不止装 100 吨或者 10 吨嘛 ， 你还想怎么去和其他的东西 ， 呃 ， 共共就是什么 ， 就是怎么摆和其他的那些船上其他物品一些怎么摆 ， 如果你是散货的话 ， 你还得考虑在海上的时候下防潮怎么办 ， 路上有下雨怎么办 ， 对吧 ？

**Rio** [1:42:45]
对 。

**吴涛** [1:42:46]
各种各样的 。

**Rio** [1:42:46]
住船怎么办 ？ 有人偷盗窃怎么办 ？

**吴涛** [1:42:48]
然后装货的时候还有一个很大的 ， 你散货的话你可能怎么装 ， 你拿个最传统的时候是一些人拿个那个什么铲子 ， 一一铲一铲的往上铲 ， 对吧 ？

**Rio** [1:42:58]
对 。

**吴涛** [1:42:59]
你就这个这过程 。

**Rio** [1:43:00]
就是每天养嘛 ， 现在即即便现在没船还是这样运 。

**吴涛** [1:43:04]
没船还是这样的吗 ？

**Rio** [1:43:05]
对 ， 航就是在莱茵河里面经常还是可以看到一些运那个 。

**吴涛** [1:43:10]
在铲的 。

**Rio** [1:43:10]
散货的 ， 对 ，他们不是海海仍旧不是用集装箱了 ，因为仍旧不是用集装集装箱了 ，但他们也不是用铲 ，他们是用什么卷扬机之类的 ， 就是 。

**吴涛** [1:43:18]
啊 ， 还是自动化了 ， 对吧 ？

**Rio** [1:43:19]
对 。

**吴涛** [1:43:19]
但是你需要有一个那你不可能说你用用运煤的东西再去运这个运大米嘛 ， 就是说你你用你卷煤那个东西肯定不能不能用来卷大米嘛 ，因为它会互相污染 ， 对吧 ？

**Rio** [1:43:31]
对 。

**吴涛** [1:43:31]
所以看我们就互相污染也是一个很重要的问题 。

**Rio** [1:43:34]
没错 。

**吴涛** [1:43:35]
啊 ， 然后就是这个运就每在每切换一次模式的时候 ， 切换一次运输模式 ， 比如说你从卡车转到船或者是卡车转到火车这种模式的时候 ， 你就要有一个转换的过程 ， 这个费就费时费力 ， 然后又可能 。

**Rio** [1:43:49]
而且会有损耗 。

**吴涛** [1:43:49]
会有损耗 ， 对 ， 你可能每次会铲掉一些到到地上的 ， 或者说 ， 啊 ， 就铲坏了一些 ，因为那个就就像那种米是长条的嘛 ， 可能你铲下去可能就断成两截了 ， 对吧 ？

**Rio** [1:44:01]
没错 。

**吴涛** [1:44:01]
对 ， 就就每一个环节都会出现这么一个问题 。

**Rio** [1:44:04]
对 。

**吴涛** [1:44:04]
啊 ， 所以后来就有一个这个什么跨时代的发明 ， 就集装箱就横空出世了 。

**Rio** [1:44:11]
对 ， 集装箱其实我们现在司空见惯 ，但是 ， 呃 ， 细细想来其实是一个挺了不起的东西 。

**吴涛** [1:44:18]
对 ， 就它解决了刚才我们讲的一系列的问题哈 。

**Rio** [1:44:21]
嗯 ， 没错 ， 就是你想象一个钢做的盒子 ， 一个是钢做的 ， 应该是钢还是铝啊 ？

**吴涛** [1:44:26]
钢 。

**Rio** [1:44:27]
钢做的盒子 ， 钢做的盒子 ， 哎 ， 你往里面放什么东西 ， 然后整个盒子作为一个整体可以被搬到船上， 被放在火车上， 被放在汽车上， 然后， 呃 ， 甚至有我记得我们家 ，因为我们家曾经从 ， 嗯 ， 兰州搬到天津 ， 那整个搬家的过程其实就是 。

**吴涛** [1:44:46]
买个集装箱的 。

**Rio** [1:44:47]
公司运来了一个集装箱 ， 然后我们家占其中一半 ， 然后另外一个邻居占其中另一半 ， 然后整个集装箱被运到天津 ， 然后我们再把集装箱从我们新家的门口拆下来 。

**吴涛** [1:44:59]
对 。

**Rio** [1:45:00]
把里面的家具一个搬出来 。

**吴涛** [1:45:01]
就是我们可以看到在用集装箱之后， 首先解决了这个模式切换中间的一个损耗的问题 ， 就是说 。

**Rio** [1:45:08]
对 。

**吴涛** [1:45:08]
因为集装箱你作为整体处理嘛 ， 你再从这个卡你集装箱装到一个卡车上面去 ， 然后再从卡车装到火车上面去 ， 中间只需要一个吊一下 ，不需要再每把里面东西每一个一个就像你们搬家一样哈 ，不需要把里面每个家具家具再搬出来 ， 然后再放到火车上再摆一遍 ， 然后再从火车上放挪下来 ， 再放到船上再摆一遍 ， 这样每每一次切换就只是一个简单

的挪一下， 呃 ， 吊车吊一下就好了 ，不需要不需要这个也没有损耗 。

**Rio** [1:45:35]
对 。

**吴涛** [1:45:35]
然后因为它是这个整个它是封起来的嘛 ， 就是说它可以做到什么所所谓的这个 weatherproof， 就是不怕就风雨无阻啊 。

**Rio** [1:45:44]
对 。

**吴涛** [1:45:44]
就是你因为你可以铁盒里面你可以做一些包括加固啊 ， 密封啊 ， 这些东西的 。

**Rio** [1:45:50]
保温啊 ， 对 。

**吴涛** [1:45:51]
而且更重要一点就是你可以让卖让这个收货人和送货人都放心的一个一个一个 。

**Rio** [1:45:57]
可以锁起来 。

**吴涛** [1:45:58]
就是它会对每集装箱在上船的时候会锁起来 ， 然后下船的时候收货人可以验证这个封条会拆过 ， 对 ， 如果被拆过了可以拒收 。

**Rio** [1:46:07]
对 ， 就跟那个快递一样 。

**吴涛** [1:46:10]
没错 ，而且它可以就是可以说 ， 啊 ， 这个因为集装箱它是密封 ， 就是每个东西可以密封起来 ， 如果你对这个串味的要求更严重 ， 你还可以再做一些特在集装箱内部再做一些特别的处理 ， 对吧 ？

**Rio** [1:46:21]
没错 。

**吴涛** [1:46:22]
比如说你这就可以保证让你说同一车你可以一车运大米 ， 一车运大粪 。

**Rio** [1:46:27]
哈哈哈 。

**吴涛** [1:46:28]
就如果如果你真的愿意这么干的话 ， 真的是可以这么做的 。

**Rio** [1:46:31]
Because we can。

**吴涛** [1:46:32]
Yeah， 就是完全不会互相影响 ，而且就你内部做的任何的防护处理也好 ， 包括那个制冷的那些什么方法也好 ， 对于这个运输这个船或者是卡车一样 ， 它都可以做到 ， 它可以不不不用知道你内部做了什么处理 ， 它不用知道这些细节 。

**Rio** [1:46:49]
对 ， 它有一个非常好的封装在那边 。

**吴涛** [1:46:52]
对 ， 所以我们看它有什么 ， 就是就是一个最一个一大特性就是 isolation。

**Rio** [1:46:57]
对 。

**吴涛** [1:46:57]
就是就是隔离 ， 这是很重要的一个东西 ， 然后第二个就是标准化 ， 就 standardization，因为所有的集装箱都是 ， 呃 ，也不叫所有集装箱吧 ， 就就是它有规定的尺寸 ， 就只有那么几种尺寸 。

**Rio** [1:47:08]
对 ， 应该我没记错的话应该是短集装箱 20 英寸 。

**吴涛** [1:47:12]
嗯 。

**Rio** [1:47:13]
啊 ， 啊不不 ，sorry，20 英尺 。

**吴涛** [1:47:14]
嗯 。

**Rio** [1:47:15]
然后 20 英尺的柜子是短柜 ， 然后 40 英尺的是长柜 ，40 英尺 。

**吴涛** [1:47:19]
就它只有它只有长短的区别嘛 ， 然后它的那个截面都是一样大的 。

**Rio** [1:47:23]
呃 ，wait a second， 我没记错的话是宽度 ，因为我要说到一本书 ， 就 anyway， 就是它的宽度是固定的 ，但是高度其实还是有几种标准的 ，但只不过目前所见的最常见的一种就是长宽 ， 应该是高度和宽度几乎一致的一个版本 。

**吴涛** [1:47:40]
嗯哼 。

**Rio** [1:47:41]
其他的就比较小众了 。

**吴涛** [1:47:42]
就方盒子嘛 。

**Rio** [1:47:44]
对 。

**吴涛** [1:47:44]
啊 ， 长条盒 ， 长条的方盒子 。

**Rio** [1:47:46]
对 ， 长条的盒子 ， 然后你在你现在的码头和 60 年代之前的码头是完全不一样的场景 ， 就现在的码头区码头区就是啊 ， 一大堆集装箱 。

**吴涛** [1:47:56]
嗯 ， 那个 。

**Rio** [1:47:57]
但是 60 年代以前的码头 。

**吴涛** [1:47:59]
全是散货堆地上 。

**Rio** [1:48:01]
全都是从轮船通向岸边的桥啊 ， 然后有吊车呀 ， 然后更重要的是那个时候的码头上有非常非常非常多的码头工人。

**吴涛** [1:48:13]
啊 ， 叫 。

**Rio** [1:48:14]
他们就是 。

**吴涛** [1:48:15]
码头工人叫 docker。

**Rio** [1:48:17]
对 ，docker， 然后这些 docker 他们的最大的 ， 呃 ， 任务之一就是把散货从船上搬到岸上， 或者从岸上搬到船上 。

**吴涛** [1:48:27]
对 。

**Rio** [1:48:27]
然后这群码头工人是因为他们是纯粹卖苦力的这么一群人嘛 ， 就薪水又低 ， 然后然后， 呃 ， 为什么 。

**吴涛** [1:48:34]
经常偷货 。

**Rio** [1:48:35]
非常差 ， 对 ， 然后然后然后又没有什么教养 ， 就经常偷货 ， 然后更更恐怖 ， 对 ，他们还会结成帮派帮派之类的 ，因为天津以前就是一个码头嘛 ， 天津有一群非常有名的 ，有一个 ， 呃 ， 混应该不是帮派 ， 是一类人就叫混混 。

**吴涛** [1:48:52]
嗯 。

**Rio** [1:48:53]
然后混混他们的发家地之一就是码头 ， 码头工人。

**吴涛** [1:48:57]
对 。

**Rio** [1:48:59]
但是所以在那个集装箱出现之后， 这群码头工人就已经消失了 。

**吴涛** [1:49:05]
对 。

**Rio** [1:49:05]
就他们不会需要 。

**吴涛** [1:49:08]
十十几年的时间吧 ， 就完全淘汰了 ， 改变 。

**Rio** [1:49:10]
对 ， 现在已经很难找到一个人说哦 ， 我我是在码头扛麻包 ， 这不这不可能已经 。

**吴涛** [1:49:16]
对 。

**Rio** [1:49:16]
可能只有在一些非常遥远的 。

**吴涛** [1:49:19]
小小港口 ， 小非常非常小的 。

**Rio** [1:49:21]
小小国家或者是非常就甚至我们这种第三世界国家都就中国这种第三世界国家都已经可能不再存在了 。

**吴涛** [1:49:28]
哈哈哈 ， 对 。

**Rio** [1:49:29]
呃 ， 对 ，而那个时候商船水手们可以在港口上岸玩好几天 ，因为装货实在是太满了 。

**吴涛** [1:49:36]
对 。

**Rio** [1:49:36]
现在基本上是你只能你到一个港口抽两根烟 ， 哎 ， 又得上船走 ，因为货已经卸完了 。

**吴涛** [1:49:43]
换个补给 。

**Rio** [1:49:43]
对 ， 没错 。

**吴涛** [1:49:44]
啊 ， 啊 ， 来说回集装箱的这个东西本身 ， 就我们看到它的一些属性 ， 什么样的是好的 ， 刚才讲的一个是就是 ， 呃 ， 隔离 isolation， 标准化 ， 让它的尺寸是标准化的 ， 这样的话标准化有什么隔离有什么好处 ， 就是隔离的话可以保证集装箱之间互不影响嘛 ， 这样我可以把不同不同 ， 呃 ， 内含不同物品的集装箱混合摆放 ，不是之间不会影响 ， 然后标准化

， 呃 ，有一个好处就是说其除了我们可以能比较简单的摆 ， 就是因为大家尺寸都一样 ， 就是直接是摆 ， 看他能摆多少摆多少呗 ， 然后另外还可以共用这个这个搬运的机械 ， 比如刚才讲我们讲所以装散货的话 ， 你运煤的那个散货你不能用来运大米嘛 ，但是如果你用集装箱化的话 ， 你运煤的那个的机器也可以运来运大米 ，因为它都是处理

集装箱而已 ， 对吧 ？ 那个那叫什么鹤 ， 叫什么龙龙门吊 ， 对不对 ？

**Rio** [1:50:34]
对 ， 龙门吊 。

**吴涛** [1:50:35]
叫 crane 嘛 。

**Rio** [1:50:36]
Crane，crane 是鹤 。

**吴涛** [1:50:38]
鹤 ， 中文翻译叫龙门吊 ， 就那种码码头机械机械 。

**Rio** [1:50:42]
Crane 和龙门吊可能还不是完全一样 ，crane 还是要 。

**吴涛** [1:50:47]
Crane 是一个泛的东西嘛 ， 对吧 ？

**Rio** [1:50:48]
对 ，crane 还是包括那种包括那种有一个摇臂出去的东西 ，但是龙门吊是专门指那个像龙门一样的东西 。

**吴涛** [1:50:56]
嗯哼 ，anyway， 啊 ， 所以这个就是这就就集装箱之后就改变了这个人类的运输 ， 然后才使得这个全那个什么中国的产品能够很快速的运到美国去销售 ， 这样才了才了全球化嘛 。

**Rio** [1:51:11]
对 。

**吴涛** [1:51:12]
当然那些 。

**Rio** [1:51:12]
这就是为什么我们说集装箱是对中国非常重要的一个东西 ，因为如果没有集装箱的话 ， 可能现在不可能有什么 。

**吴涛** [1:51:20]
我们还在被朝的时代 。

**Rio** [1:51:22]
中对 ， 我们还不是什么中国是世界工厂 ， 这是根本不可能的 。

**吴涛** [1:51:26]
对 。

**Rio** [1:51:26]
就那个时候在如果没有集装箱的话 ， 可能别说从中国运到美国了 ， 从可能从江苏运到山东都是非常非常不划算的事情 。

**吴涛** [1:51:37]
困难的事情 。

**Rio** [1:51:37]
对 。

**吴涛** [1:51:38]
啊 ， 说了这么久集装箱了 ， 我们其实我们还是要说一个就是在软件世界里面 ， 集装箱是一个什么样的概念啊 。

**Rio** [1:51:45]
呃 ， 稍微等一下， 我最后提一件事情 ， 就是如果刚才我们说这件事 ， 我们说的这段话对你没有产生太多的困扰 ， 反而让你觉得挺有意思的话 ， 你可以去看一本书叫做集装箱改变世界 。

**吴涛** [1:51:58]
嗯 ， 一听标题就这么 。

**Rio** [1:52:00]
没错 ， 它是应该也是译注吧 ，但是我读的是中文版 ， 我相信这本书还是能买得到 ， 然后我回头会把这本书的 ， 呃 ， 链接加到我们的 shownotes 里面 。

**吴涛** [1:52:10]
OK。

**Rio** [1:52:11]
对 。

**吴涛** [1:52:12]
OK， 那我们现在来说这个软件世界里面集装箱 。 啊 ， 传统上我们部署的一个一个软件的时候 ，其实你那个服务器上面是一个开放的东西 ， 它是一个它是一个装载机嘛 ， 然后你把那个东西上进去 ， 这个过程就有点像装散货 ， 就是他们互相之间是有点影响的 ，而且他们 ， 呃 ， 怎么说呢 ， 比如说你在服务器上要装一个数据库 ， 然后再装一个什么你自己的

软件 ， 那搞不指不定数据库依赖的什么东西和你那个东西和你的软件就冲突了 ， 你还得想办法去解决它 ， 对吧 ？

**Rio** [1:52:43]
对 。

**吴涛** [1:52:44]
就它并不是一个完全隔离的一个东西啊 ， 包括不同的应用之间可能互相会对 ， 可能会共享某一个文件 ， 或者说这个数据库觉得 ， 呃 ， 这个这个程序会觉得 ， 哎 ， 我要改那个文件 ， 那个数据那个程序会觉得 ， 哎 ， 你怎么改了我那个文件 ， 对吧 ？

这个东西是可能会出现的一个问题 ， 然后他们对这个资源的这个 ， 呃 ，不叫他们的这个安装方式也是一个非标准化的 ， 就说你安装数据库的方法和你安装一个什么 Tomcat 的方法可能并不一样 。

**Rio** [1:53:13]
对 ， 这又回到了我们上一期讲的内容 ， 就是可能两个软件所需要的包管理系统是完全不一样的 。

**吴涛** [1:53:21]
就会出现这种不一致的一个状况 。 啊 ， 所以如果我们能够把刚才讲的集装箱那几个概念拿起来拿过来用到这个软件部署里面 ，是不是就会情况好很多呢 ？

我们能不能说 ， 哎 ， 装个软件就好像 ， 呃 ， 怎么讲呢 ， 就你直接就把它那个文件传上去就好了 ， 或者执行同一个命令就好了 ， 它互相之间绝对不会干扰 。

**Rio** [1:53:44]
对 ， 就之前的思潮可能是说这一船货 ， 就是如果说一台计算机是一艘船的话 ， 那我们可能说这艘船上装了一群猪 ， 然后又装了一坨米 ， 然后之前的思潮可能是把仓室里面的这一块划给猪 ， 然后另一部分划给米 。

**吴涛** [1:54:02]
对 。

**Rio** [1:54:02]
但是此时就有一个问题 ， 就是它们两个有可能是互相影响的 ， 就万一猪圈翻了 ， 然后猪跑出来把米拱了 ， 那你说你是救猪呢还是救米呢 ？

**吴涛** [1:54:12]
哈哈哈 。

**Rio** [1:54:14]
但是 ， 呃 ，containerization 就有点 ， 呃 ， 就有点的 ， 呃 ，其实这个类比不是特别的合适 ，因为真正的 containerization 其实是把猪和米分别装到两条船上 。

**吴涛** [1:54:27]
不对 ，是装到两个盒子里面 。

**Rio** [1:54:30]
但这两个盒子在 containerization 的世界 ， 就是如果是 proper 像 Docker 这样的 containerization 的话 ， 它们两个它们两个其实是跑在两个不同的虚拟机上， 它们是它们之间不存在 。

**吴涛** [1:54:42]
不不不 ， 它们是在它们是在同一个虚拟机 ， 同一个机器里面 ，但是只是在不同的子子区域里面 。

**Rio** [1:54:48]
啊 ，OK。

**吴涛** [1:54:49]
对 。

**Rio** [1:54:49]
对 ， 我好吧 。

**吴涛** [1:54:51]
嗯 ， 啊 ，anyway， 就是说 ， 呃 ， 然后我们还想如果能够所有软件都不要去说我你那个那个数据库要用什么 APT 来装 ， 然后你自己的应用程序要用一个自己的方法来装 ，不要搞这些麻烦的方法 ，不要搞 32 种不同的安装方式 ， 对吧 ？

那我们所有的方案都用同一个方式安装过去 ， 这样不就更好嘛 ， 对吧 ？

**Rio** [1:55:12]
对 。

**吴涛** [1:55:12]
其实最先实践这种想法的其实有也有叫做虚拟机这个概念 ， 对吧 ？

**Rio** [1:55:18]
对 。

**吴涛** [1:55:19]
虚拟机能够虚拟机里面 ， 然后有一个叫做 virtual appliance 这么一个概念啊 ， 我不知道你们大家用 virtual box 应该可能看到有这么一个 import appliance 这么一个东西 ， 什么意思呢 ？

就是说我们部署软件的单位不再是某一个软件哦 ， 某一个应用 ， 某一个应用 ， 呃 ， 为单位了 ，而是说我们以整个把这个应用所需要的所有环境 ， 包括它的操作系统啊 ， 包括它所依赖的文件啊 ， 包括它的依赖的数据啊 ， 还有它的什么 ， 啊 ， 这个就各种这样它它需要依赖的环境嘛 ， 打包成一个虚拟机 ， 然后再部署到某一个实体的这个物理的服务器上去

运行 ， 这个在很长的时间里面大家啊都是这么就什么像那个亚马逊的那个 EC2 嘛 ， 就这种方式来做的 ， 就是说 ， 呃 ， 我把我的应用都打包成一个完整的虚拟机 ， 然后我所我需要用呃用的时候我就开一个虚拟机 ， 它让它跑起来就好了 ， 然后我也不去改虚拟机里面的内容 ， 就是让它运行就好了 ， 然后如果我不需要我就把这个虚拟机关上，

对吧 ？

**Rio** [1:56:21]
对 。

**吴涛** [1:56:22]
这就实现了我们刚才讲的那个什么标准化 ，因为所有的都是不管你里面装什么 ， 对 ， 就是你这开发者只要负责建好这个虚拟机 ， 我运维的时候我就只负责开关这个虚拟机就好了 ， 然后如果某一个虚拟机坏了 ， 我就把它 ， 呃 ， 关掉 ， 然后在另外开个新的 ， 就实现了这个标准化和这个隔离 ， 这个确实是好的啊 ，也在相当长一段时间

内我们都知道很多这个厂商都是 。

**Rio** [1:56:44]
甚至到现在都是主流吧 ， 可以说 。

**吴涛** [1:56:46]
啊 ， 对 ， 就是到目前为止它还是一个起码有半壁江山这么一个状态 。

**Rio** [1:56:51]
对 。

**吴涛** [1:56:51]
但是虚拟机有一个什么问题呢 ？ 就是它的那个资源损耗是比较高的 ，因为你想象一下虚拟机的话 ， 你其实要首先你要虚拟一个操作系统 ， 对吧 ？

**Rio** [1:57:00]
对 。

**吴涛** [1:57:00]
那我们这看虚拟一个操作系统 ， 你要至少哪怕你最精简的一个 Linux 的 ，也不叫最精简吧 ， 就是一个正常的一个 Linux 的发行版 ， 你运行起来可能都需要占掉个几百两三百兆的内存 ， 就是这个内存的 overhead。

**Rio** [1:57:15]
可以再小一点 ，但对差不多 。

**吴涛** [1:57:17]
就至少是在一两百这个两三百这个范围内嘛 ， 然后硬盘磁盘空间你可能每个虚拟机至少装完那个系统都是至少是一两个 G 的 ， 然后再装你的应用又是一堆空间在那里 。

**Rio** [1:57:28]
对 。

**吴涛** [1:57:28]
然后这个虚拟虚拟机运行的时候 ，因为它是在之前没有这个硬件虚拟的 ， 就是没有那个这个这个硬件支持的情况下， 虚拟机的运行效率还会打折 ， 对吧 ？

因为你虚拟机要代码是在一个虚拟的环境里面运行的 ， 还要再转化成那个真实的在硬件上运行的代码 ， 还要经过一层转化 ，但后来有这个芯片 ， 这个呃 ，CPU 级别的虚拟化支持的这个情况会好很多 ，但是并不是完全是一个无碍的 ， 特别是在面对 IO 啊 ， 内存读写这一块的时候 ， 还是有一个比较大的瓶颈 ， 就是 。

**Rio** [1:58:02]
对 ， 它只是解决了计算计算能力的方面的问题 ，但没有解决 IO 方面的 。

**吴涛** [1:58:07]
对 ， 损耗还是很很大的 ， 就是应该目前有一个比较怎么说 ， 一个默认的数字吧 ， 就是可能是 1% 到 20% 这么一个损耗 ， 就是性能上的损耗 。

就啊 ， 然后这个虚拟机的在启动的时候也比较慢 ， 比如说你开一个虚拟机 ， 你只需要等它里面操作系统完全 boot 一遍嘛 ， 至少你最快也得个二三十秒吧 ， 我会呃 ， 我们看到一一般的一个发行版 。

**Rio** [1:58:32]
对 。

**吴涛** [1:58:32]
嗯 ， 所以就有人在想说 ， 那我们能不能够再保留虚拟机那些好处 ， 比如说隔离 ， 然后标准化这些好处 ， 同时解决它的问题呢 ？

就是说它的就是能够让它更加快速的启动 ， 然后啊 ， 就不再是说几十秒 ， 我们能不能做到说几十毫秒或者几百毫秒的级别的启动 ， 或者是杀掉它 ， 然后我们同时能够不不去浪费那么多的资源在虚拟机本身上面 ，而是把资资源集中到这个应用上面去跑呢 ？

于是就有这个 container 这个概念 ， 就是就横空出世了 。

**Rio** [1:59:06]
终于说到它了 。

**吴涛** [1:59:08]
对 ， 终于说到 container， 就是集装箱啊 ， 这个概念 。

**Rio** [1:59:11]
对 ， 然后这个运这个趋势也被一些人称为所谓呃 Docker Apocalypse， 就是嗯 ， 它是一种灾难性的 ， 就是在在某些传统主义者的人看来 ， 这是某种灾难性的变革 ， 就是程序和呃机和跑它和它所运行的环境之间的隔离变得越来越越来越 ， 就是有些人是不喜欢这样多出来的这一层的隔离和抽象的 。

**吴涛** [1:59:45]
嗯哼 。

**Rio** [1:59:46]
但是目前看来 ， 呃 ， 这个趋势的确是呃带来的优势要远远大于它所损失的那一点 ， 就是你们不能再和一个比较 native 的呃环境所互通而带来的便利 。

**吴涛** [2:00:02]
对 。 啊 ， 那接着说这个 Docker 哈 ， 就最开始的时候是 Linux 有一个内核的一些功能叫做 cgroups， 嗯 ， 叫 control groups 吧 。

**Rio** [2:00:13]
Control groups 没错 。

**吴涛** [2:00:14]
对 ， 它能做些什么事呢 ？ 就它可以让啊 ， 你在在一个 Linux 的系统上面去划分出一群这个进程 ， 然后让它们共让让让让它们不叫不叫划分出去 ， 应该是做一个这么一个容器 ， 就刚才讲的 container 吧 ， 然后它你可以限制这个容器它能够使用的这个资源的比率 ， 然后你可以限制就你可以让容器之间互相隔离 。

**Rio** [2:00:40]
Cgroups 好像一开始就叫什么 process container 之类的一个名字 ，但后后来才改成 control groups。

**吴涛** [2:00:46]
对 ，因为有一个有一个什么命名上的冲突啊 ， 我后来忘了 。

**Rio** [2:00:51]
呃 ，OK，有可能我觉得有可能是那个时候觉得 container 这个词指的太就职位太不明了 。

**吴涛** [2:00:59]
嗯哼 。

**Rio** [2:00:59]
太太不明确了 ， 所以才改成 control group。

### Docker

**吴涛** [2:01:02]
Control group。

**Rio** [2:01:02]
因为对 ，在 Linux 世界里面好像 group 这个这个这个概念更容易理解一些 。

**吴涛** [2:01:07]
哈哈哈 ，anyway， 就是前面就说有有这么一个内核的一个支持吧 ， 让你可以划分出这个资源的这个限制 ， 互相之间它们是不可以 ， 比如说不不可以访问的 ， 然后可以限制它能只能使用多少多少比例的这个 CPU 啊 ， 多少比例的内存这样啊 ， 这样就可以在呃很大程度上实现说我们运行的时候互相不干扰 。

**Rio** [2:01:32]
对 ， 甚至都不知道别人的存在 。

**吴涛** [2:01:34]
对 ， 甚至不知道对方的存在 ， 就是说对于我来说 ， 我以为我我这个机器这个程序认为我是这个在这台机上运行的唯一的程序 ，但其实不是 ，但你也用的不是虚拟机的方法 ， 这样的话就有个好处 ， 就是说它没有虚拟机那些那些损耗嘛 ， 比如没有这个这个转化那一层 ，因为所有东西都是还是在直接在这个硬件上运行的嘛 。

**Rio** [2:01:55]
对 。

**吴涛** [2:01:57]
啊 ，但是还有一个要解决的问题就是说那磁盘怎么办 ， 就是还有一个文件系统嘛 ， 对吧 ？ 啊 ， 然后 cgroup control group 它还有一个功能 ， 就是还能够划分不同的文件 ， 就是说让不同的进程看到的自己的那个那个文件的目录树是唯一是独立的分分隔的 。

**Rio** [2:02:14]
嗯哼 。

**吴涛** [2:02:15]
这样的话就可以让啊 ， 互相之间 ， 比如说我同样要读取什么 ETC 下面的一个配置文件的时候 ， 大家可以读到不同的版本 ， 或者说改修改的时候互相不冲突 。

**Rio** [2:02:26]
对 ，其实就是一个对操作系统级别的虚拟机 ，但它又不是 。

**吴涛** [2:02:33]
它不是虚拟机 。

**Rio** [2:02:33]
重量级的虚拟机 。

**吴涛** [2:02:34]
对 ， 它提供了虚拟机的功能 ，但是它并不是一个虚拟机 。 对 ， 就是一个超轻量级的一个虚拟机吧 。

**Rio** [2:02:42]
一个虚拟技术吧 ， 可以这么说 。

**吴涛** [2:02:44]
然后 control group 它能够启动那些呃启动这个这个隔离也非常快 ， 它就是什么都有几十毫秒几百毫秒级别就可以建立出建建新建一个 control group， 然后可以在几十毫秒几百毫秒这个量级上把它把它杀掉嘛 ， 就基本上认为可以它是一个就是即时的一个过程 ，而不是像像那个虚拟机你还要等取等它启动 ， 然后等它这个退出 ， 要要等那个几十秒的 ， 就是一个数量级

的提升 ， 两三个数量级的提升了 。

**Rio** [2:03:11]
没错 。

**吴涛** [2:03:12]
嗯 ， 啊 ， 然后有了这么一个基础技术之后呢 ， 就后来有一个公司叫做 Docker 出了一个啊 ， 基于这个 。

**Rio** [2:03:22]
基于 cgroups 的一个技术 ， 就叫做对 ， 就像 Docker。

**吴涛** [2:03:26]
对 ，Docker 就是刚才我们讲的码头工人嘛 ， 就是负责建这个负责搬运货物的一个东西 ，但是虽然 Docker 已经绝种了 ， 现在这个工种已经绝种了 ，但是它把这个名字借过来了 ， 它说我们是 。

**Rio** [2:03:41]
啊 ， 当然它的它的 logo 不是一个正在扛完包的码头工人 ，而是一个 。

**吴涛** [2:03:45]
运着集装箱的鲸鱼 。

**Rio** [2:03:46]
对 ， 承载着一群一堆集装箱的一个鲸鱼 ， 这还蛮可爱的 。

**吴涛** [2:03:51]
对 ， 呃 ， 就它是把因为 control group 它是一个内核集内核的一些 API 嘛 ， 所以它你要有一个什么呃叫什么用户可以直接要操作它的一个界面 ， 最开始的时候 Linux 是支持一个叫做 LXC 的一个东西吧 ，但是那个也不是非常友好 ，也不是非常好用 ， 然后 Docker 就说那我们提供一个 。

**Rio** [2:04:12]
更加好用完善的工具 。

**吴涛** [2:04:15]
命令行界面 ， 就是 Docker 目前有图形应该也是用命令行界面的 。

**Rio** [2:04:20]
对 ， 命令行界面的东西 。

**吴涛** [2:04:21]
对 ， 它用起来有点像 Git。

**Rio** [2:04:24]
嗯 ， 对 ，有点有点类似感觉吧 。

**吴涛** [2:04:26]
对 ， 嗯 ， 啊 ， 然后它是一个什么东西呢 ？ 就是它就是利用这个 control group 这些内核的一些特性 ， 然后让你能够快速的新建出一个一个的所谓的 container， 一个一个集装箱 ， 然后每个集装箱可以做些什么事儿 ， 就是说你集装箱里面包含呃它们推荐的方式 ， 一个集装箱里面只包含一个主要的软件哈 。

**Rio** [2:04:49]
对 。

**吴涛** [2:04:50]
比如说你就运行一个数据库 ， 就运行一个数据库 ，不要搞一些别的东西 ， 然后运行一个程序 ， 一个应用 ， 就是单独的一个应用 ，不要塞五个应用在一个 container 里面 ， 这样这样不方便管理嘛 。

啊 ，有了这些集装箱之后， 它它 Docker 提供了这么一套工具 ， 能够标准化的去去安装它 ， 然后可以标准化的去部署它 ， 这样就可以实现 container 那些所有的好处 ， 然后也可以避免那个虚拟机的那些资源损耗高的问题 。

**Rio** [2:05:15]
没错 ，而且它还大幅度的简化了一个嗯软件部署者 ，也就是或者说我们刚才说的这个 DevOps 的工作量 ， 就是呃之前我们会觉得用 Chef 好像已经相当简便了 ， 用 Chef 或者 Puppet 来来来描述整个的部署过程已经相当简便了 。

**吴涛** [2:05:38]
嗯哼 。

**Rio** [2:05:38]
但是使用 Docker 的时候 ， 你会觉得原来整个过程还可以更加抽象 ， 更加简便一点 。

**吴涛** [2:05:44]
嗯哼 。

**Rio** [2:05:44]
就是之前你还需要去操心你从哪里获得一个一个一个一个操作系统 ， 你还要去操心 ，因为 Puppet 毕竟还是要运行在一个特定的操作系统之上的 。

**吴涛** [2:05:57]
对 。

**Rio** [2:05:58]
啊 ，但是 Docker 也需要 ，但呃 Puppet 所关心的抽象是在操作系统级别以下的 ， 可是从 Docker 开始 ， 这个抽象就已经包含操作系统本身在内了 。

这是一个非常了不起的一个一个一个一个封装层级 。

**吴涛** [2:06:16]
对 ，而且就怎么说呢 ， 就是说如果用 Docker 这种方式来部署的话 ， 就开发者和运运维者做的事情其实是非常呃叫什么用的工具是类似同样的工具了 ，因为在过去的话 ， 开发者其实并不你开发的过程中至少是并不需要用到 Puppet 也好 ， 还有刚才讲 Chef 那套那些东西 ， 对吧 ？

因为那个只是部署时候才用到的 。 但是如果你用 Docker 来做这个开发的话 ，其实你发现你在开发的时候就已经是在 Docker 里面去 。

**Rio** [2:06:43]
对 ， 你可以一上来就说我要一个什么样的 Docker， 然后呃 。

**吴涛** [2:06:47]
里面在配置那个 Docker 那个 container。

**Rio** [2:06:49]
一上来我就说我就知道了 ， 这个东西最终会跑在一个什么样的环境里面 。

**吴涛** [2:06:53]
嗯哼 ， 然后你怎么你在开发的时候去怎么去构建那个 container 的环境 ， 或者你怎么去构建你的那个呃软件最终运行的环境 ，也就正是你在最后部署的时候 ， 运维的时候要用的同样的环境 ， 就是你用的是同样一套工具 ， 同样一套命令去执行这个东西 。

这样的话就有什么好处呢 ？ 运运维的时候你只需要只需要拿到开发好的这个 Docker 的 container， 然后直接把它部署到这个物理的机器上去就好了 ，并不需要做任何特别多的额外的操作 ，但额外的操作就可能在这个那个目标的机器上装上这个 Docker 本身哈 。

**Rio** [2:07:29]
对 ， 换言之 ， 呃 ， 从如从 Docker 之后， 整个软件的开发过程就变成了 Dev 在 container 里面开发一个东西 ， 然后 Ops 接过 container， 然后把它放在一个呃实呃真正的运行环境上 。

然后整个过程中你会发现 DevOps 好像因此而变得非常简单了 。

**吴涛** [2:07:51]
对 ， 啊 ，Docker 另外一个重要的贡献就是说它把这个文件系统虚拟化做得比较好 ， 就是说我们过去比如说刚才讲那个虚拟机需要如果你开五个虚拟机 ， 那你还要建五个虚拟机镜像 ， 那么它们那个呃每个镜像都要占用那个系统要占用一定的空间 ， 然后应用还占用一定的空间 ， 对吧 ？

**Rio** [2:08:11]
对 。

**吴涛** [2:08:11]
啊 ，Docker 说那首先我们不需要这个虚拟每一个操作系统了 ， 我们不需要我们这一条就省掉了 。 然后第二个就是我们这个文件系统是一个很叫什么 copy and write 的系统 。

**Rio** [2:08:20]
嗯哼 。

**吴涛** [2:08:21]
就是说我如果我在文件系统上做一个改进的话 ， 我只需要记录它修改那一部分 ， 然后如果其他的共享的部分就可以可以共享到这个磁盘空间嘛 ， 这样的话我哪怕我开一十个一百个这个 Docker 的 container 的同时运行的时候 ， 我并不需要真的浪费一百份的磁盘空间 。

**Rio** [2:08:41]
对 。

**吴涛** [2:08:42]
这个是非常了不得的一个一个贡献吧 。

**Rio** [2:08:45]
没错 。

**吴涛** [2:08:46]
嗯 ， 可以看到哈 ，Docker 这个工具是非常强大的一个东西 ，但是 Docker 本身还是要跑在一个系统上面的嘛 。在 Ubuntu 这个 14.04 开始 ， 它就官方已经有支持了 ， 然后那个你只要在那个 APT 里面安装一下那个我发的那个主机 ， 就可以变成一个 Docker 主机 ， 然后你再可以在里面运行这些 Docker 的 container 就好了 。

**Rio** [2:09:06]
对 ， 或者说就你就可以在这台机器上将你自己的 application 呃 dockerize。

**吴涛** [2:09:12]
嗯哼 。

**Rio** [2:09:13]
对 ， 让它跑在一个容器里面 ， 这套界面还是挺容易用的吧 。 而且我忽然想起来有一个优点 ， 就是你可以保留一个嗯保留某一个开发版本的一个 image。

**吴涛** [2:09:25]
啊 ？

**Rio** [2:09:26]
就是对 ， 好像是这样的吧 。

**吴涛** [2:09:28]
对对对 。

**Rio** [2:09:28]
就是你可以在里面运行一个程序 ， 然后把它存成一个 image， 然后你每次打开这个 image 的时候 ， 你会得到这个程序在那个时候的运行时刻 。

**吴涛** [2:09:37]
嗯哼 。

**Rio** [2:09:38]
啊 ， 就在那个时候的部署部署部署状态 。 对 ， 它等于又成了某一种很特别的版本控制系统啊 ， 它所控制的是一个软件的运行状态的版本 。

**吴涛** [2:09:50]
呃 ， 或者说是把整个操作系统的状态进行了一个版本控制吧 。

**Rio** [2:09:55]
对 ，有一点像那个 VMware 里面的呃 VirtualBox 里面的 snapshot。

**吴涛** [2:10:00]
Snapshot， 对对 ，但是它比那个 snapshot 要轻量级更多 ，而且快嘛 。

**Rio** [2:10:05]
没错 。

**吴涛** [2:10:05]
啊 ，但是还有人觉得这样还是太麻烦了 。 那个就是所谓 Docker 的这个什么宿主机啊 ， 就是太复杂了 。

就有很多人在做一些新的尝试 ， 比如说最可能大家听得比较多的是一个叫做 CoreOS 的这么一个尝试 ， 就是它是一个精简版的 Linux 系统 ， 然后它的 。

**Rio** [2:10:26]
然后它也是基于 cgroups 的 。

**吴涛** [2:10:28]
啊 ， 对 ， 它最开始是是它现在还是就目前为止还还是基于 Docker 的 ， 就是说它就是给你提供一个精简版的 Docker 的运行环境 ， 然后你直接在里面去 ， 就是它的这个 CoreOS 本身是非常精简的东西 ，并里面并没有很多东西 ， 然后你所有的应用的部署都是在 CoreOS 里面跑一个 Docker， 然后在 Docker 里面再建不同的这个虚拟机去跑 ， 那个 container 去跑 。

当然他们最近也在搞一个 ，因为他们跟 Docker，因为 Docker 背后还有一个公司叫 Docker Incorporated 嘛 ， 然后他们之间有一些利益的冲突 ， 然后他们 。

**Rio** [2:11:01]
他们不是一家的 ， 这是对 ， 或者说他们的设计哲学有点不一样 。

**吴涛** [2:11:05]
对 ，他们这个设计理念有点不一样 ， 然后商业的这个利益也有点有点冲突嘛 ， 所以他们就在最近在搞一个所谓的 Docker 的一个分支嘛 ， 一个 fork 啊 ， 去把一些标准化东西定下来 ，但是这个我们就不去纠结那些细节了哈 。

**Rio** [2:11:20]
其实说穿了就是原教旨主义和嘿嘿嘿和这个什么商业利益之间的冲突啊 。

**吴涛** [2:11:27]
对对 ， 然后 Ubuntu 他们也没有闲着哈 ，他们前一段时间也发布了一个叫做 Ubuntu Core 这么一个新的 Ubuntu 的发行版 。

嗯 ， 这个也比较好玩的一点 ， 就是说它连这个这个母系统本身都变成一个 Docker 的 Docker 化的一个东西了吧 ， 你可以这么想 。

**Rio** [2:11:49]
What？

**吴涛** [2:11:49]
就是因为因为母宿宿主机的系统里面它还是可以有一些状态要改的嘛 ， 然后它的升级啊这些还是不是非常啊稳健的 ，但是刚才我们讲利用这种 image 的这种版本控制的一种方式 ， 它可以做到连这个宿主机的升级和这个维护都变成一个非常确定化的东西 ， 就是如果中途失败可以是可以回滚的 ， 然后 。

**Rio** [2:12:10]
啊 。

**吴涛** [2:12:11]
就变成就变成这个就是用 Docker 来控制 Docker 宿主机了 ， 你可以大概是这个意思 。

**Rio** [2:12:17]
OK，有意思 。

**吴涛** [2:12:19]
啊 ， 对 ， 就比较好 。 但是整个来说呢 ， 对 Docker 现在还是比较一个新兴的技术吧 ， 就是说呃你如果要用到生产中可能还是要先实践一下， 那也有也有不少的坑 。

嗯 ，因为 Docker 本身是一个还在不断完善中的系统 。

**Rio** [2:12:35]
对 ， 可能就是因为这些坑 ， 就是刚才说到的这个所谓 DockerApocalypse， 所以也指的就是这些 ， 就是有些人对于对此持怀疑态度的会觉得因为这个东西还还不成熟 ， 就是哪怕我们两个 ， 我们两个觉得这是一个划时代的伟大发明 ，也不可能拍着胸脯说这个东西肯定会在十年之后成为绝对的主流 。

**吴涛** [2:12:57]
对 ，但是我觉得趋势还是要往那个再往那个方向走 。

**Rio** [2:13:01]
对 ，因为就像集装箱一样 ， 很难想象将来没有这种便利的话 ， 啊 ， 还能有什么更好的方式来管理 ， 来来让来让来来让每个人都可以更加低门槛的成为 DevOps。

**吴涛** [2:13:16]
对 。

**Rio** [2:13:17]
可能这是最好的一种方法 。

**吴涛** [2:13:18]
对 ， 啊 ， 所以如果你作为一个开发者 ， 然后你想成为一个 DevOps， 你想去接触一下 Docker 这东西呢 ， 就也有很多的方法可以尝试 ， 比如说你自己在电脑上装一个免费的这个啊 VirtualBox， 然后你再装一个这个 Docker， 或者装一个 Ubuntu 也好 ， 啊 ， 然后在这里面装 Docker 或者装个 CoreOS 也可以 。

当然也有个如果你是在 Mac 上面的话 ，有个我们我们有一个更简单的方式哈 ， 就是 Docker 这个社区提供了一个叫做 Boot to Docker 的这么一个极极度精简版的 Linux 系统 ， 然后你可以里面它做的唯一件事情就是让你跑 Docker， 然后我给这个系统这个这个 Boot to Docker 这个工具做了一个命令行的小工具 。

**Rio** [2:13:59]
噔噔噔噔 ， 对 ， 各位现在正在听这个我们的 Rio 同学在 Brag 他写的一个自我推广 。

**吴涛** [2:14:07]
哈哈哈 。

**Rio** [2:14:08]
一个用用 Docker 的小命令行工具叫做叫什么 ？

**吴涛** [2:14:13]
Boot to Docker Client。

**Rio** [2:14:14]
对对对 ，Boot to Docker Client。

**吴涛** [2:14:18]
对 ， 然后你可以在那个呃 HomeBrew 里面装 Mac 上面 ，因为这个主要是给 Mac 用户开发的 ，因为那个 Docker 不能原生运行 ， 只能原生运行在 Linux 上面嘛 。

**Rio** [2:14:28]
对 。

**吴涛** [2:14:28]
所以你肯定是需要一个虚拟机的才能在 Mac 上面跑的 。 然后这个工具你可以干嘛呢 ？ 可以帮你啊一件事的去完成 ， 只要你装装上那个 VirtualBox 之后， 它可以一件事的帮你建装好这个 Boot to Docker 东西 ， 然后可以让你很方便的去操纵这个虚拟机的里面的一些概念吧 ， 然后之后你就可以直接用 Docker 去跟这个用 Boot to Docker 装好的一个好说用 Boot to Docker 装好的一个 Docker 宿主机的去去去去

可以去玩嘛 ， 就可以去学习里面的东西 。

**Rio** [2:15:03]
哇 ， 好累 。

**吴涛** [2:15:05]
嗯 ， 对 ， 大概就这个 ， 大概就是这个意思 ， 可以去学习 。 然后现在我们要在节目的最后要扯一点啊玄学 。

**Rio** [2:15:16]
对 ， 就是扯一些有的没的 ， 可能不不干不湿 ， 可能还是偏湿的一些东西吧 。

### 玄学

**吴涛** [2:15:22]
对 ， 就是其实我们刚才讲那么多东西啊 ， 就是我们为什么要这么多工具去做这东西 ，其实要解决什么问题 。

就是如果我们把那个一个一台服务器作为一个状态机的话哈 ，其实我们就是可以看到那些工具的一个一个发展方向 ， 就是把这个状态机尽量变得无状态 。

**Rio** [2:15:43]
嗯 ， 状态机不可能无状态 ，而我觉得可能正确的说法应该是让状态机的状态变化 。

**吴涛** [2:15:51]
是可预测的吗 ？

**Rio** [2:15:52]
是可 ， 嗯 ， 这么说可能也不是特别精确 。 我们到底想表达什么意思 ？ 就是呃服务器是一大堆状态机 。

**吴涛** [2:16:01]
嗯哼 。

**Rio** [2:16:02]
就是呃状状态机是一个我算了 ， 我不解释什么状态机了 。 就是如果把服务器视为一个状态机的话 ， 那么我们的终极理想就是我不用去操心状态机从状态 A 变到状态 B 的过程究竟需要做哪些事情 ， 我只操心让它从状态 A 变到状态 B 可控 ， 呃有反应 ，并且可以同时在很多很多机器上运行 。

**吴涛** [2:16:31]
对 ， 就是说我们希望能够有成百上千的 ， 我们不用只不用一个通过很 imperative 很命令式的方式去指定它怎么切换状态的状态机 ， 我只用告诉它说进入 A 状态 ， 然后它们就全部进入了 A 状态了 。

**Rio** [2:16:48]
对 ， 这就有点像那个呃 Disposable Me 里面的命令一样 ， 我们理想状态是不是告诉每一个单独的命令 ，Kevin 你去拿那个 ， 然后呃 Mike 你去拿那个 ， 然后把它们拿两个不同的工具把把缩小摄像枪偷出来 。

我只需要下一个命令 ， 你们去把缩小摄像枪给我偷出来 ， 至于怎么完成的我不管 。

**吴涛** [2:17:11]
对 。

**Rio** [2:17:12]
这是我们想要达到的终极终极终极目标 。

**吴涛** [2:17:15]
对 。

**Rio** [2:17:15]
说穿了其实还是懒嘛 。 我觉得我们这我们这一期讲的这个 Docker 呃其实也是第三层的所谓的 Lifecycle Management， 就是 Server as a State Machine as a as a as a Service， 我们要管理它们的 Lifecycle， 然后嗯所有这一切都希望能够尽可能的自动化 ， 尽可能的无痛的实现 。

所以最归根结底其实还是因为懒 。

**吴涛** [2:17:44]
或者说啊叫做呃削减复杂度嘛 ， 就是说如果你要你要关注每一台机器它具体的状态怎么样 ， 然后每台机器状态还不一样 ， 你再去手工一个一个解决的话 ， 这个就太复杂了嘛 。

那我们想的方法就是说能够通过这种啊把它啊就首先是一个就是描述性的语言去去指定它的状态 ， 然后用工具去实现说我不管啊你是什么状态 ， 你就变成这样的状态就好了啊 。

**Rio** [2:18:10]
对 。

**吴涛** [2:18:11]
来来做到把这个事情尽量变得简化一点 ， 然后最简化的目的目标呢是什么呢 ？ 就是说我们还是说能够希望很快速方便的能够去伸缩我们这个计算资源 ， 然后去应对啊这个随时变化的这个工作负担工作负荷嘛 。

**Rio** [2:18:28]
没错 ， 所以这然后我们让状态机变得所谓嗯不是 stateless，但是是某种意义上的类呃在我们的最终用户的视角看来是处于 stateless 的状态的 。

**吴涛** [2:18:45]
嗯哼 。

**Rio** [2:18:45]
呃这样一种这样一种思潮或者说这样一种哲学 。

**吴涛** [2:18:51]
嗯 。

**Rio** [2:18:51]
其理念和 functional programming 其实是相通的 。

**吴涛** [2:18:55]
对 ， 就说我们如如果我们把每一个 ，因为我们为什么要弄那么多服务器跑起来 ， 就是因为它要完成一个功能嘛 。

那所谓完成功能就是说它服务器接受一个输入用户的请求 ， 对吧 ？ 然后它要完成一个输出 ， 就是产生用户的这个反反馈给用户的结果 。

就我们是希望每一个这个这个这个我们叫做服务器也好 ， 还是叫做这个 container 也好 ， 我们希望它的这个输入输出是能够呃呃就是无状态的 ， 就是说我们只要有同样的另外一个 container 或者同样的另外一个服务器 ， 我给它同样的输出 ， 它能够产生同样的输出嘛 。

**Rio** [2:19:29]
对 ， 没有副作用 。

**吴涛** [2:19:31]
对 ， 就是然后这样没有副作用的话 ， 就可以让我们很方便的去管理它们嘛 ，也可以调配资源啊 ， 调度资源啊 。

**Rio** [2:19:38]
对 ， 我们就可以像把整个服务器像一个函数一样组建起来 ， 然后每次扔进去 ， 我们想我们知道会得到什么样输出的输入就可以了 ，而不是像在命令式编程那样还要去操心此时的整个程序处于什么状态 。

**吴涛** [2:19:57]
对 。

**Rio** [2:19:57]
对 ， 哎 ， 这个我们是不是忘了提 NixOS？NixOS 不对 ， 它的最终目标不就是要达到这个效果 。

**吴涛** [2:20:04]
哎 ， 对 ， 这个其实应该要讲的 ，不过因为我自己也没有用过 ， 就是在关注这个东西哈 ， 就是没有太多的实际的这个应用应用的啊场景 ，而且它那个本身也不太成熟嘛 ， 还是在一个开发 。

**Rio** [2:20:18]
对 ， 它还是一个比较相比较先锋式的 ， 比较比较比较更加纯粹的这么一个朝着 stateless 的的管理工具的一个一个尝试 。

**吴涛** [2:20:32]
对 ， 对 ， 就是 Docker 这种思路 ， 就是说我们不改变目前的操作系统 ， 就是你现在 Docker 里面跑的东西还是一个就是我们所谓的这个常规的一个操作系统嘛 ， 就它里面还是有那些状态的 。

但就是说我们只是说因为我们用一个归一化的方式去生成它 ， 然后我们就是 hopefully 哈 ， 就是我们希望我们通过归一化的方式去生成它 ， 得到的结果是一个大家都一样的结果 ，但是并不能保证它运行一段时间之后， 它每个个呃同样就同样方式生成的那个这个 container， 它不会出现所谓 diverge， 就是呃所谓出现分野嘛 ， 就是说这个运行了一段时间变成这个状态

， 然后那个运行的时间变成另一个状态 。

**Rio** [2:21:12]
没错 。

**吴涛** [2:21:13]
啊 ，但是像那个 Nix 这种东西的话 ，其实它又想做又更进一步了 。 它我我们只要把这个操作系统变成本身变成是一个 stateless 的东西 ， 就是它的其实是更加一个更激进的一个方法吧 ， 我觉得 。

**Rio** [2:21:29]
对 。

**吴涛** [2:21:30]
但是通常来说呢 ， 这种更加激进的方法一般都是不会不会成功的 。

**Rio** [2:21:37]
哈哈哈 。

**吴涛** [2:21:38]
就是对软件工程来讲 ， 我觉得这个向后兼容 ， 还有这个所谓的这个啊规模优势还是有点有有点用处吧 。

就是说 Nix 那个它其实更加类似于 Ubuntu Core 那种比较极极极端的一种方式去改变我们的这个部署的环境 。

**Rio** [2:21:56]
嗯 ， 但愿是吧 ，但 。

**吴涛** [2:22:00]
但我还是希望它能够做做得起来 。

**Rio** [2:22:03]
我应该但愿我应该说但愿不是吧 。

**吴涛** [2:22:05]
哈哈哈 。

**Rio** [2:22:05]
我觉得在服务端 ，其实人们接受变革的呃的的阻力还是要比在其他领域少一些 ，因为在服务端其实首先人们对产品没有太多感情 。

**吴涛** [2:22:19]
嗯哼 。

**Rio** [2:22:20]
不像不像呃 。

**吴涛** [2:22:22]
就没有用户习惯在里面 。

**Rio** [2:22:23]
对 ， 我们不会说我是果粉 ， 或者说我有苹果的使用习惯 。

**吴涛** [2:22:26]
嗯哼 。

**Rio** [2:22:27]
啊在 。

**吴涛** [2:22:28]
我们都是一堆见风使舵的人。

**Rio** [2:22:30]
对 ， 我们在呃看得见摸得着的这种消费品消费电子产品领域会有这样的教派的存在 ， 就是你我都是啊 ， 我不知道你是不是 ，但我是一个呃苹果教徒 ，但在服务端可能不会有 。

**吴涛** [2:22:47]
会更加理性一些 。

**Rio** [2:22:48]
对 ， 会更加利益驱使 ， 或者说 lazy driven 一点 。

**吴涛** [2:22:51]
对对 。

**Rio** [2:22:52]
就是什么好我用什么 ， 我不会去 ，而而且好在服务端的优好处就是好是有一个明确的标准的 。 如果我用这个比你一快二简单 ， 那它就是好 ， 对吧 ？

**吴涛** [2:23:04]
对 。

**Rio** [2:23:04]
但是在我们可能 。

**吴涛** [2:23:07]
消费级别的东西有一些看不着 。

**Rio** [2:23:08]
中端电子用户会有一些非常难以理解的非理性的因素在里面 。

**吴涛** [2:23:12]
对 ，有有感性的因素在里面 。

**Rio** [2:23:14]
对 ， 比如说我就是习惯关闭按钮在左上角 。

**吴涛** [2:23:17]
哈哈哈 。

**Rio** [2:23:18]
没有理由的 。

**吴涛** [2:23:19]
你能把对 ， 没有什么理由啊 ， 你你能告诉我说在右上角就是要比左上角好吗 ？

**Rio** [2:23:24]
啊 ， 所以我就是喜欢 。

**吴涛** [2:23:25]
就说不好你咬我呀 ， 对吧 ？ 我就觉得那个 OST 的字体渲染比 Windows 的好 ， 你能把我咋地 ？

**Rio** [2:23:30]
对 ， 你咬我呀 。 但是在服务端就不会有这种 ，不会有这样的问题 。 真的是真刀真枪 ， 嗯 ， 没有什么 ， 就一切都是可以量化的 。

这可能是你为什么喜欢后端的一个原因吧 。

**吴涛** [2:23:41]
对啊 ， 就是一切都是可控的 。

**Rio** [2:23:43]
倾向于对 ， 你倾向于一切都是可控可以量化 ， 可以可以抉择 。

**吴涛** [2:23:47]
嗯 。

**Rio** [2:23:49]
所以对 ， 从这个角度讲 ， 可能呃 NixOS 还是会有 ， 还是会呃后来居上的 ， 如果它真的有它宣称的那么好的话 。

当然其作者也说了 ，NixOS is not for the faint of heart for now.

**吴涛** [2:24:05]
就是说小白悟尽 。

**Rio** [2:24:07]
对 ， 如果如果你没有一些功力 ， 没有想要折腾的心念的话 ， 最好还是不要碰它 。

**吴涛** [2:24:14]
嗯 ，不过那个 Ubuntu Core 那个还比较用户友好 ， 可以去玩一下 。 如果如果你觉得 NixOS 太太 hardcore 的话 。

**Rio** [2:24:22]
Hardcore 啊 。

**吴涛** [2:24:23]
对 ， 这个 Ubuntu Core 这个还比较比较好玩 。 就我我自己试试了一下， 还挺还我觉得还不错吧 ， 就那个理念也挺简单的 。

**Rio** [2:24:32]
嗯 。

**吴涛** [2:24:32]
嗯 。

**Rio** [2:24:34]
好吧 ， 那我们呃大概聊完了这个最后一期的 ，sorry，2015 年第一期的呃内核恐慌 。 我们今天的主题是其实也是延伸了前两期的 Lifecycle Management， 我们今天讲的是 Containerization， 呃就是 Containerization 集装箱化 ， 可以这么说吗 ？

**吴涛** [2:24:57]
嗯 ， 对 。

**Rio** [2:24:57]
软件部署的集装箱化以及 DevOps。

**吴涛** [2:25:00]
嗯哼 。

**Rio** [2:25:01]
啊 ， 我觉得我从今天开始一定要每一期都说那个罐口 ，因为好像其他节目都说我不说不太好 。 嗯 ， 北美山地时间 2006 年 1 月 2 日下午 3 点 04 分 05 秒 ， 您正在收听的您正在收听的是 IPN Podcast 网络旗下的 IT 技术主题节目 《 内核恐慌 》。

我们号称 hardcore 啊 ，但是也没有干货 ， 想听的人听 ，不想听的人就不要听 。 嗯 ， 同时 IPN 旗下的其他五档 Podcast， 包括 SoftCore 技术主题节目 《IT 公论 》， 呃同样也是由 Rio 和呃另外一位我们的制作人 Lawrence 一起主持的 ， 还有医疗主题节目 《 他一来了 》， 嗯 ， 美食节目 《 未知道 》， 嗯哼 ，以及不只谈艺术的艺术类节目 《 流行通信 》。

它的英文名字叫做 Pop Dispatch， 千万不要记错成 《 出战分派 》。

**吴涛** [2:25:54]
哈哈哈 。

**Rio** [2:25:56]
最后还有其实我是非常推荐呃 《 流行通信 》 这堂节目的 ， 就是我觉得尤其是死城们应该听一听 ，因为我 。

**吴涛** [2:26:05]
唤醒一下脑中已经快要死去的艺术系不感性那一部分是不是 ？

**Rio** [2:26:09]
对 ， 就是我和我女朋友在听这个节目的时候就说 ， 如果我们啊 《 内核恐慌 》 有我们自己的一个一个一个 pattern 的话 ， 或者一个一个怎么说 ， 一个家或一个族徽的话 ， 那肯定到处都是直线 。

**吴涛** [2:26:22]
哈哈哈 。

**Rio** [2:26:24]
所有地方都是 90 度角 。 但如果你在听呃 《 出战分派 》Pop Dispatch 啊 《 流行通信 》 的时候 ， 你会觉得就有时候你会觉得这个从从一个呃死理型派的角度会觉得主持人好像有点脱线 ， 就是 。

**吴涛** [2:26:39]
很乱糟糟的 。

**Rio** [2:26:41]
不知道在讲什么 ，但是可能这才是就是我们所缺失的那一部分 ， 让我们成为让我们去更具有人情味的一部分 。

就是如果他们有他们的主题图案的话 。

**吴涛** [2:26:52]
嗯哼 。

**Rio** [2:26:53]
可能是都是非常柔美的曲线 ， 像云一样 。

**吴涛** [2:26:56]
对 。

**Rio** [2:26:56]
嗯 ， 水云纹 。

**吴涛** [2:26:58]
哈哈哈 。

**Rio** [2:26:58]
对 ， 所以我还是非常推荐各位呃喜欢收听我们节目的听众的话 ， 一定一定也要去听一下 《 流行通信 》。

但如果你不喜欢听我们节目的话 ，也非常欢迎您去听 《 流行通信 》。

**吴涛** [2:27:13]
嗯 。

**Rio** [2:27:13]
对 ， 然后 IPN 还有一款节目就是我也不知道在播什么的 ， 无主题节目 ， 无次元 。 对 ， 没有固定时长 ， 没有禁忌 ， 没有主播 ， 呃没有主题 ， 无次元 。

好 ， 欢迎收听本期 《 内核恐慌 》。

**吴涛** [2:27:29]
对了 ， 还有个事情我忘了说 。

**Rio** [2:27:31]
啊 ？

**吴涛** [2:27:32]
啊啊 ， 非常高兴哈 ， 这个 2014 年就你们听到这期节目的时候 ，2014 年已经结束了 ，但是有一个 。

**Rio** [2:27:39]
我们录这期节的时候 2014 年也结束了 。

**吴涛** [2:27:41]
啊 ，是吗 ？ 啊 ， 对啊 ，2014 年已经结束了 。OK。

**Rio** [2:27:44]
Holy。

**吴涛** [2:27:45]
啊 ，不过我们在这个我们节目也第八期了哈 ，在就 2014 年做了七期 ， 然后非常高兴上呃荣登苹果的这个 Hour of Code 2014 这个活动的推荐搒里面 。

**Rio** [2:27:59]
啊 ， 对 ， 没错 。

**吴涛** [2:28:00]
嗯 。

**Rio** [2:28:01]
其实 Hour of Code 是干嘛的 ？

**吴涛** [2:28:03]
就它大概是一个全球性的活动嘛 ， 就是让 。

**Rio** [2:28:06]
就是大家来学编程吧 。

**吴涛** [2:28:08]
对对对 ， 推进这个就是这个 ， 就把编程作为通识教育的一部分 ， 让更多人来能够接触它 ，而不是说哎呀我是小白 ， 我什么都不懂 ，不要告诉我那些什么东西 。

你们连奥巴马都去写 JavaScript 了是吧 ？

**Rio** [2:28:22]
对 。

**吴涛** [2:28:22]
所以这个事情还是蛮值得高兴的 。 但是啊 ，有人说 。

**Rio** [2:28:26]
咱们两个可以互相互相

恭维一番 。 Unbelievable, you, subject name here, must be the pride of subject hometown here.

**吴涛** [2:28:37]
Yay.

**Rio** [2:28:37]
Yay.

**吴涛** [2:28:38]
啊 ，不过也有人说哈 ， 这个我们这个字幕讲那么多 ，是不是对对初学编程者太难了 ？ 哎呀 ， 我是这么想的 ，其实我们讲的很多概念应该是主要的目的还是唤起大家对对这个的兴趣嘛哈 。

**Rio** [2:28:54]
我们有吗 ？

**吴涛** [2:28:55]
有这个我不知道 ， 我我希望是这样子 。 就是 。

**Rio** [2:28:59]
哎呀 ， 我也不知道 ， 我觉得还是那句话吧 ， 就是这款节目我们想做就做 ， 想听的人听 ，不想听的人就不想听 。

**吴涛** [2:29:06]
对 ， 然后 。

**Rio** [2:29:07]
Anyway。

**吴涛** [2:29:08]
嗯 ， 啊 ，不过这个还是蛮这个可喜可贺的事情 ， 这做了做了几期还是有有有什么有所嗯被人认识吧 ， 然后能够 。

**Rio** [2:29:19]
对 。

**吴涛** [2:29:19]
被更多的人知道 ， 然后能拿到这个 。

**Rio** [2:29:21]
对 ， 回想 2014 年， 觉得这件事情还是挺值得叫 。

**吴涛** [2:29:24]
对 ， 那也可以贴个章 。 Our code recommended.

**Rio** [2:29:29]
Yeah.

**吴涛** [2:29:30]
好了 ， 就这样吧 。

**Rio** [2:29:32]
好吧 ， 今天节目到此为止了 。

**吴涛** [2:29:33]
下期再见 ， 拜拜 。

**Rio** [2:29:34]
再见 ， 拜拜 。

---

本节目库由 PodHood（https://podhood.com）提供支持——播客网站平台。