1
00:00:00,000 --> 00:00:05,042
>> [音乐播放]

2
00:00:05,042 --> 00:00:06,000
DAVID马兰：好的。

3
00:00:06,000 --> 00:00:07,630
非常感谢你的光临。

4
00:00:07,630 --> 00:00:11,850
这是码头工人，一个CS50研讨会
技术，我们自己和CS50

5
00:00:11,850 --> 00:00:13,392
已经开始使用现在的一段时间。

6
00:00:13,392 --> 00:00:15,766
所以，我的名字是大卫·马兰，我
哈佛教授的介绍

7
00:00:15,766 --> 00:00:16,671
计算机科学。

8
00:00:16,671 --> 00:00:18,670
在相当一些年来，
我们一直在给学生

9
00:00:18,670 --> 00:00:20,435
下载的客户端侧
虚拟机

10
00:00:20,435 --> 00:00:22,134
上，他们做他们的问题集。

11
00:00:22,134 --> 00:00:24,300
我们现在已经转变
到云环境

12
00:00:24,300 --> 00:00:27,396
实际使用这项技术
叫多克尔，使得所有CS50

13
00:00:27,396 --> 00:00:29,270
学生现在有自己的
自己的码头工人集装箱

14
00:00:29,270 --> 00:00:31,180
那你很快就会听到一切。

15
00:00:31,180 --> 00:00:33,740
>> 此外，CS50的服务器上
方群，多年

16
00:00:33,740 --> 00:00:35,290
我们使用亚马逊的云服务器。

17
00:00:35,290 --> 00:00:37,164
我们运行的各个
虚拟机。

18
00:00:37,164 --> 00:00:40,330
也就是说，我们也已经开始过渡到
这些东西叫做泊坞容器

19
00:00:40,330 --> 00:00:43,762
让我们所有的应用程序都是现在
完全相互分离。

20
00:00:43,762 --> 00:00:46,720
在这样的情况多了，让我
介绍我们的朋友，尼科和马诺，

21
00:00:46,720 --> 00:00:48,574
从码头工人本身。

22
00:00:48,574 --> 00:00:49,740
NICOLA KABAR：谢谢你，大卫。

23
00:00:49,740 --> 00:00:51,410
大家好。

24
00:00:51,410 --> 00:00:54,230
我的名字是尼克，这是马诺。

25
00:00:54,230 --> 00:00:58,260
我们从泊坞窗。

26
00:00:58,260 --> 00:01:02,240
我们将要谈论about--
让你们的介绍，以泊坞窗，

27
00:01:02,240 --> 00:01:08,100
并希望，接近尾声
这次谈话中可以实现

28
00:01:08,100 --> 00:01:12,890
你可以用多少医生
草酸盐应用程序开发

29
00:01:12,890 --> 00:01:14,200
和部署。

30
00:01:14,200 --> 00:01:21,250
>> 所以，我们要开始真正的
快与一些背景资料。

31
00:01:21,250 --> 00:01:22,750
描述一下码头工人的全部。

32
00:01:22,750 --> 00:01:25,490
它是如何工作的？

33
00:01:25,490 --> 00:01:27,400
它是如何架构？

34
00:01:27,400 --> 00:01:29,360
我会做一些演示。

35
00:01:29,360 --> 00:01:35,070
而马诺将是
描述你如何使用泊坞窗

36
00:01:35,070 --> 00:01:37,720
并为您的具体步骤
如何上手。

37
00:01:37,720 --> 00:01:41,490
>> 我将不胜感激，如果你们能装
关闭您的问题接近尾声。

38
00:01:41,490 --> 00:01:46,800
这样的话，我可能会解决这些
问题在整个演示文稿。

39
00:01:46,800 --> 00:01:52,150
因此，我们将留一些时间
接近尾声的问题。

40
00:01:52,150 --> 00:01:55,170
>> 因此，只要真正的快，谁拥有
实际工作过码头工人，

41
00:01:55,170 --> 00:01:56,850
喜欢玩吗？

42
00:01:56,850 --> 00:01:58,000
真棒。

43
00:01:58,000 --> 00:01:58,520
凉。

44
00:01:58,520 --> 00:01:59,817
大。

45
00:01:59,817 --> 00:02:01,525
所以，我要开始
一些历史。

46
00:02:01,525 --> 00:02:04,350

47
00:02:04,350 --> 00:02:09,820
因此，早在20世纪90年代和
21世纪初，基本

48
00:02:09,820 --> 00:02:16,940
作为Web开发人员，应用程序开发人员，
当他们去部署应用程序

49
00:02:16,940 --> 00:02:19,350
它被拴裸机。

50
00:02:19,350 --> 00:02:20,860
这是一台服务器。

51
00:02:20,860 --> 00:02:22,870
这是一个应用程序。

52
00:02:22,870 --> 00:02:25,260
>> 传统上，一个例子
会像一个LAMP堆栈，

53
00:02:25,260 --> 00:02:30,630
在这里你实际上必须
调出的资源池。

54
00:02:30,630 --> 00:02:37,110
CPU，内存，磁盘，网络，安装
操作系统在其顶部。

55
00:02:37,110 --> 00:02:40,060
如果如果你提供的东西，
你实际上有Web服务器，

56
00:02:40,060 --> 00:02:42,470
你需要像
Apache来为它服务。

57
00:02:42,470 --> 00:02:47,540
>> 如果您的应用程序
需要数据库，反手，

58
00:02:47,540 --> 00:02:50,840
你安装的东西
如MySQL，等等。

59
00:02:50,840 --> 00:02:55,910
如果你需要在运行时，PHP的
和PHP Python的工作都在那里。

60
00:02:55,910 --> 00:02:59,480
因此，我们实际上不得不
采取以那些步骤

61
00:02:59,480 --> 00:03:02,060
让您的应用程序启动和运行。

62
00:03:02,060 --> 00:03:08,440
>> 如果你需要更多的计算能力，你
基本上有打电话给你的行动的人

63
00:03:08,440 --> 00:03:16,260
或加仑去和机架新
硬件设备，它连接，

64
00:03:16,260 --> 00:03:19,850
你必须重复这些
流程连连。

65
00:03:19,850 --> 00:03:23,680
所以这个过程是
相对昂贵。

66
00:03:23,680 --> 00:03:26,080
肯定是非常缓慢的。

67
00:03:26,080 --> 00:03:27,550
>> 这是低效的。

68
00:03:27,550 --> 00:03:33,890
而且在很多情况下，你的
硬件是没有得到充分利用。

69
00:03:33,890 --> 00:03:38,830
所以，在90年代末和21世纪初，
硬件虚拟化碰到。

70
00:03:38,830 --> 00:03:42,475
正如你可以看到在这里
图片，基本上他们做了什么

71
00:03:42,475 --> 00:03:46,390
抽象的池
免费硬件资源

72
00:03:46,390 --> 00:03:49,680
与那种服务的
给上层，

73
00:03:49,680 --> 00:03:52,360
在这种情况下，客户操作系统。

74
00:03:52,360 --> 00:03:54,940
>> 与整体思路
虚拟机碰到

75
00:03:54,940 --> 00:03:59,110
而真正帮助云
计算作为我们今天所知道的。

76
00:03:59,110 --> 00:04:02,730
所以，这是什么意思是你
可以同时运行多个虚拟机，这

77
00:04:02,730 --> 00:04:06,720
意味着多堆，多
应用程序在同一台物理机器上。

78
00:04:06,720 --> 00:04:10,570

79
00:04:10,570 --> 00:04:16,440
>> 这无疑有助于用
速度的应用程序部署。

80
00:04:16,440 --> 00:04:17,629
肯定有费用。

81
00:04:17,629 --> 00:04:22,810
你不必去花
能量，时间和资源，以架

82
00:04:22,810 --> 00:04:26,210
更多的服务器来得到更多的计算。

83
00:04:26,210 --> 00:04:30,950
和的速度实际上使
这些资源了要快得多。

84
00:04:30,950 --> 00:04:31,450
大。

85
00:04:31,450 --> 00:04:34,320
>> 因此，我们解决世界饥饿问题，对不对？

86
00:04:34,320 --> 00:04:36,390
不，不是真的。

87
00:04:36,390 --> 00:04:42,410
因此，虚拟化技术，它更是
实际的帮助下，解决这个问题，

88
00:04:42,410 --> 00:04:45,460
它实际上介绍
很多挑战。

89
00:04:45,460 --> 00:04:49,210
管理程序肯定
推出了很多的复杂性，

90
00:04:49,210 --> 00:04:53,820
处理这些底层
池资源。

91
00:04:53,820 --> 00:04:57,910
>> 这在某种意义上更重的前
你有一个单一的操作系统，它

92
00:04:57,910 --> 00:05:01,830
就像在磁盘上三，四演出。

93
00:05:01,830 --> 00:05:04,230
现在，如果你有10台机器
在单个硬件

94
00:05:04,230 --> 00:05:09,060
你必须乘以
通过机器的数量。

95
00:05:09,060 --> 00:05:11,440
这肯定是更
贵在某种意义上你还是

96
00:05:11,440 --> 00:05:14,430
必须获得许可
虚拟化技术

97
00:05:14,430 --> 00:05:18,210
如果它不是开源的。

98
00:05:18,210 --> 00:05:21,120
>> 但是，我们不要把所有的
信贷从虚拟化。

99
00:05:21,120 --> 00:05:27,530
因为发生的事情是有一个
很多栈和大量的软件

100
00:05:27,530 --> 00:05:33,900
启用的技术
你被多快能够得到

101
00:05:33,900 --> 00:05:38,040
与云计算热潮资源。

102
00:05:38,040 --> 00:05:46,675
>> 所以，今天一个单一的应用程序或服务能
可以用以下任何运行时的

103
00:05:46,675 --> 00:05:47,216
或数据库。

104
00:05:47,216 --> 00:05:50,250

105
00:05:50,250 --> 00:05:56,070
PHP，Python的，MySQL和Redis的，诸如此类的东西。

106
00:05:56,070 --> 00:05:59,740
因此，有很多复杂的这个
堆栈数实际调出

107
00:05:59,740 --> 00:06:02,210
单一的服务。

108
00:06:02,210 --> 00:06:07,300
而伴随着的是，你有很多的
潜在的资源或基础设施

109
00:06:07,300 --> 00:06:15,210
类型测试部署和基本
采取生产这些应用程序

110
00:06:15,210 --> 00:06:16,900
你正在开发。

111
00:06:16,900 --> 00:06:21,950
>> 特别是作为你的球队有
快把工作的这些应用程序，

112
00:06:21,950 --> 00:06:25,310
有很多的
复杂性和挑战

113
00:06:25,310 --> 00:06:31,660
这被带到保证
在cycle--基本应用

114
00:06:31,660 --> 00:06:34,040
开发周期，是
居然成功了。

115
00:06:34,040 --> 00:06:40,440
因此，事实上，你的应​​用程序
是在本地工作在本地虚拟机

116
00:06:40,440 --> 00:06:47,480
并不能保证你的同事
将会期望相同的结果。

117
00:06:47,480 --> 00:06:51,330
>> 而当运营团队
参与拍摄你有什么

118
00:06:51,330 --> 00:06:54,480
并部署它在生产中
规模，也不能保证

119
00:06:54,480 --> 00:06:56,730
那这实际上会发生。

120
00:06:56,730 --> 00:07:00,900
因此，这给我们留下了一个非常
big--了很多问号，

121
00:07:00,900 --> 00:07:07,700
其实很多的挑战
面对同样在天回。

122
00:07:07,700 --> 00:07:12,280
这提醒我们，
航运业。

123
00:07:12,280 --> 00:07:14,280
>> 因此，航运业
有很多的商品，

124
00:07:14,280 --> 00:07:16,190
你可以在左侧看到。

125
00:07:16,190 --> 00:07:19,840
和在右手侧，
有很多的，基本上，

126
00:07:19,840 --> 00:07:22,160
如何运送这些货物。

127
00:07:22,160 --> 00:07:26,040
而会发生什么一对夫妇
人走到了一起，说：

128
00:07:26,040 --> 00:07:29,600
我们需要规范如何
我们实际上把那些货。

129
00:07:29,600 --> 00:07:33,280
只听轰的一声，你有
联运运输集装箱。

130
00:07:33,280 --> 00:07:38,970
>> 因此，他们同意对最
常见的尺寸为容器。

131
00:07:38,970 --> 00:07:40,160
如何处理它们。

132
00:07:40,160 --> 00:07:44,560
你需要什么确切的方法
加载它们和它们卸载。

133
00:07:44,560 --> 00:07:49,590
因此，真正
帮助航运业。

134
00:07:49,590 --> 00:07:55,250
现在，90％以上的重点运输
全球正在使用的容器。

135
00:07:55,250 --> 00:08:01,010
这绝对下降
费用以及

136
00:08:01,010 --> 00:08:03,400
损害赔偿因运费。

137
00:08:03,400 --> 00:08:09,660
>> 因此，我们采取了同样的模式，我们
使用两个应用程序开发软件

138
00:08:09,660 --> 00:08:13,080
架构，在这个意义上
该集装箱

139
00:08:13,080 --> 00:08:15,842
把虚拟化上一级。

140
00:08:15,842 --> 00:08:17,800
因此，与其这样做，
在硬件一级，

141
00:08:17,800 --> 00:08:22,060
它变得更加的操作的
系统级的虚拟化。

142
00:08:22,060 --> 00:08:26,450
>> 同时，我们也通过提供每一
在自己的轻量级应用，

143
00:08:26,450 --> 00:08:31,180
孤立的，可运行，并
便携，最重要的是，

144
00:08:31,180 --> 00:08:35,049
一种方法来实际打包
它需要执行所有功能。

145
00:08:35,049 --> 00:08:36,100
的任何地方，可以运行。

146
00:08:36,100 --> 00:08:42,039
所以，不管你运行它
本地开发环境，生产

147
00:08:42,039 --> 00:08:44,490
环境，暂存或测试。

148
00:08:44,490 --> 00:08:47,700
不管是什么根本
基础设施是存在的，

149
00:08:47,700 --> 00:08:51,410
你有一个职能工作的应用程序。

150
00:08:51,410 --> 00:08:54,100

151
00:08:54,100 --> 00:09:01,800
>> 所以，这也正是基本上是什么
集装箱做了这个问题。

152
00:09:01,800 --> 00:09:04,070
他们通过解决这一问题
包装它以这样的方式

153
00:09:04,070 --> 00:09:09,490
它可以保证它的部署
成功，无论它生活的地方。

154
00:09:09,490 --> 00:09:12,120
所以，如果你打算
像鲍勃它仍然确定。

155
00:09:12,120 --> 00:09:17,860
如果你困惑与我在说什么，
我将要阐述的。

156
00:09:17,860 --> 00:09:20,900
>> 那么，如何泊坞窗本身
适合在这幅画？

157
00:09:20,900 --> 00:09:26,335
所以多克是一个开放的平台，
轻松，强调轻松，

158
00:09:26,335 --> 00:09:30,500
建船，运行，
轻巧便携的自我

159
00:09:30,500 --> 00:09:33,440
足够的应用程序容器的任何地方。

160
00:09:33,440 --> 00:09:37,660
如果你从这个拿东西所以，
通话，请按以下。

161
00:09:37,660 --> 00:09:40,980
>> 如果你有你的应用程序运行
在当地，你开发它

162
00:09:40,980 --> 00:09:45,930
在使用泊坞平台，预计
它被成功部署。

163
00:09:45,930 --> 00:09:49,380
不管是什么
底层基础设施。

164
00:09:49,380 --> 00:09:53,830
所以，如果你有一个泊坞窗
容器和它的工作，然后

165
00:09:53,830 --> 00:09:58,130
只要有一个泊坞窗
发动机上的其它side--

166
00:09:58,130 --> 00:10:02,190
如果你的操作基础设施
可使用任何云，无论

167
00:10:02,190 --> 00:10:06,680
是AWS，或谷歌的，还是微软，
或任何公共云，

168
00:10:06,680 --> 00:10:10,010
或者你自己的云，或者打开的堆栈
云或本地环境。

169
00:10:10,010 --> 00:10:11,970
>> 如果你有一个引擎
运行时，该装置

170
00:10:11,970 --> 00:10:14,537
这将是
成功部署在那里。

171
00:10:14,537 --> 00:10:16,620
这将运行
完全一样的行为

172
00:10:16,620 --> 00:10:21,480
因为你的架构它是。

173
00:10:21,480 --> 00:10:26,080
因此，如果我们看看at--我要去
经过实际是什么

174
00:10:26,080 --> 00:10:29,160
在多克尔的主要组成部分。

175
00:10:29,160 --> 00:10:31,060
>> 因此，发动机是泊坞窗的核心。

176
00:10:31,060 --> 00:10:32,770
它是大脑的。

177
00:10:32,770 --> 00:10:39,360
它编排建筑，航运，
部署和管理

178
00:10:39,360 --> 00:10:41,570
容器自身。

179
00:10:41,570 --> 00:10:45,160
我会来挖成什么引擎做
在一第二的更多细节。

180
00:10:45,160 --> 00:10:47,740

181
00:10:47,740 --> 00:10:51,720
基本上，因为医生建
围绕着客户端服务器架构，

182
00:10:51,720 --> 00:10:56,630
因此为了与互动
引擎，你需要某种形式的一个客户。

183
00:10:56,630 --> 00:11:01,200
>> 图像是在模板中
其中集装箱从构建。

184
00:11:01,200 --> 00:11:06,800
所以图像基本上都是
只是静态文件。

185
00:11:06,800 --> 00:11:08,740
模板和集装箱
其实是什么

186
00:11:08,740 --> 00:11:12,280
在运行时运行
是服务应用程序

187
00:11:12,280 --> 00:11:15,150
或做一些与数据。

188
00:11:15,150 --> 00:11:19,020
>> 注册人称为的问题
如何实际分发映像。

189
00:11:19,020 --> 00:11:23,230
所以，如果你需要共享图像
你的工作到您的同事

190
00:11:23,230 --> 00:11:27,220
或老年退休金计划的团队，你
使用注册表使用它。

191
00:11:27,220 --> 00:11:31,720
你可以下载一个开源
版本的它的泊坞制作

192
00:11:31,720 --> 00:11:33,150
和开源。

193
00:11:33,150 --> 00:11:38,040
>> 或者你可以使用泊坞帮助，
这是云版本

194
00:11:38,040 --> 00:11:40,130
推拉图像在那里。

195
00:11:40,130 --> 00:11:41,160
这是一个巨大的东西。

196
00:11:41,160 --> 00:11:44,520
因为有一个庞大的
各地泊坞窗的生态系统，它的

197
00:11:44,520 --> 00:11:48,960
真正大量使用的枢纽。

198
00:11:48,960 --> 00:11:59,780
>> 所以，在这里总结一下，这是怎样的
简约的码头工人的工作流客户端。

199
00:11:59,780 --> 00:12:04,040
你与主持人进行互动，在
这种情况下，它的码头工人守护进程。

200
00:12:04,040 --> 00:12:06,490
这是同样的事情引擎。

201
00:12:06,490 --> 00:12:09,690
你不喜欢命令
泊坞建设，拉，跑。

202
00:12:09,690 --> 00:12:14,280
和发动机本身的推移
而做这些事情。

203
00:12:14,280 --> 00:12:18,010
>> 因此，无论是与之交互
注册地拉这些图片

204
00:12:18,010 --> 00:12:19,670
和图像的层。

205
00:12:19,670 --> 00:12:25,030
无论您是否要部署，运行
集装箱，杀了他们，把他们下来，

206
00:12:25,030 --> 00:12:25,730
诸如此类的东西。

207
00:12:25,730 --> 00:12:32,190
因此，这总结了工作流程
所有这些组件。

208
00:12:32,190 --> 00:12:34,710
>> 所以，如果你把每
组件本身。

209
00:12:34,710 --> 00:12:37,690
因此发动机，它只是一个守护进程。

210
00:12:37,690 --> 00:12:40,800
那种它会发挥它支持
它在Linux因为它

211
00:12:40,800 --> 00:12:44,380
需要一定的Linux内核的功能。

212
00:12:44,380 --> 00:12:48,820
但是，Windows正在工作
在做同样的事情。

213
00:12:48,820 --> 00:12:53,720
它应该得到支持
由Windows服务器2016年。

214
00:12:53,720 --> 00:13:01,500
>> 如此，同样，与责任
发动机，或者是，建立图像。

215
00:13:01,500 --> 00:13:05,340
从泊坞窗拉图像
集线器或您自己的注册表。

216
00:13:05,340 --> 00:13:07,840
如果你用这些图片做
或者你创建一个新的形象，

217
00:13:07,840 --> 00:13:14,770
你可以把这些回注册表
将它们分发到其他球队。

218
00:13:14,770 --> 00:13:18,300
>> 并试图遏制在本地
和管理容器生命周期

219
00:13:18,300 --> 00:13:19,260
本地。

220
00:13:19,260 --> 00:13:22,010
它是围绕HTTP REST API。

221
00:13:22,010 --> 00:13:24,480
因此从技术上讲，你可以
编写自己的客户端

222
00:13:24,480 --> 00:13:31,650
只要使用HTTP，这是一个很
标准的机制来谈谈发动机

223
00:13:31,650 --> 00:13:33,110
和许多其他服务。

224
00:13:33,110 --> 00:13:35,780
你可以从看
在这里，无论

225
00:13:35,780 --> 00:13:39,010
什么样的基础设施
是的，只要你can--所有

226
00:13:39,010 --> 00:13:42,170
你需要的是一个操作
系统，Linux的具体。

227
00:13:42,170 --> 00:13:45,460
>> 你可以安装泊坞引擎
在此基础之上，并运行它

228
00:13:45,460 --> 00:13:48,970
和它编排，基本上
所有这些应用程序的一个，两个，

229
00:13:48,970 --> 00:13:51,530
三是实际的容器。

230
00:13:51,530 --> 00:13:53,990
所以这是引擎。

231
00:13:53,990 --> 00:13:58,040
正如我前面提到的，因为
你需要与引擎交互，

232
00:13:58,040 --> 00:13:59,200
还有的客户端。

233
00:13:59,200 --> 00:14:03,180
>> 但实际上当你安装
泊坞窗，它附带了它。

234
00:14:03,180 --> 00:14:06,110
因此，它被安装，
所以这是一个单一的二进制。

235
00:14:06,110 --> 00:14:11,830
你可以做本地电话
您多克尔引擎。

236
00:14:11,830 --> 00:14:14,040
或远程调用的远程发动机。

237
00:14:14,040 --> 00:14:16,600

238
00:14:16,600 --> 00:14:19,590
它不使用HTTP，作为
我前面提到的。

239
00:14:19,590 --> 00:14:24,200
有被称为GUI客户端
Kitematic从泊坞窗。

240
00:14:24,200 --> 00:14:26,390
而且肯定有
其他很多乡亲

241
00:14:26,390 --> 00:14:29,740
谁正在建设大量的
图形用户界面，基本上实现

242
00:14:29,740 --> 00:14:32,980
某些HTTP调用来谈谈发动机。

243
00:14:32,980 --> 00:14:35,920

244
00:14:35,920 --> 00:14:39,280
>> 只是一些示例命令。

245
00:14:39,280 --> 00:14:44,620
如果你这样做码头工人的版本，它会
显示您的客户端版本，以及

246
00:14:44,620 --> 00:14:47,030
服务器版本。

247
00:14:47,030 --> 00:14:49,500
如果你这样做码头工人的信息它会
告诉你所有的信息

248
00:14:49,500 --> 00:14:54,300
有多少集装箱正在运行
或创建的，你有多少图像有，

249
00:14:54,300 --> 00:14:56,530
等等等等。

250
00:14:56,530 --> 00:15:01,850
>> 在这里，我有，在旁边
去年中，我有医生跑。

251
00:15:01,850 --> 00:15:04,970
所以这就是我是如何实际
创建容器。

252
00:15:04,970 --> 00:15:08,960
而我给它呼应的Hello World
睡一秒钟，诸如此类的东西。

253
00:15:08,960 --> 00:15:12,830
你可以看到
结果。因此，它是持续的。

254
00:15:12,830 --> 00:15:16,930
而类似Linux的ps的，你可以看到
所有的过程，并且在此情况下，

255
00:15:16,930 --> 00:15:18,540
所有正在运行的容器。

256
00:15:18,540 --> 00:15:23,430
这一个指回
容器我刚刚创建。

257
00:15:23,430 --> 00:15:27,560
>> 所以，这是因为真正重要的，
喜欢，它可以是一个有点混乱。

258
00:15:27,560 --> 00:15:33,050
所以图像是只读
采集的文件，对不对？

259
00:15:33,050 --> 00:15:37,000
他们就是我们的容器是基于。

260
00:15:37,000 --> 00:15:40,340
但他们只是只读的。

261
00:15:40,340 --> 00:15:44,330
所以，你与基础映像开始。

262
00:15:44,330 --> 00:15:50,180
它往往模仿操作系统状，所以
Ubuntu的，CentOS的，诸如此类的基本图像。

263
00:15:50,180 --> 00:15:53,990
然后你就开始建设之上
如此，某些层，这将弥补

264
00:15:53,990 --> 00:16:00,010
您的高端形象，这里到底的结果。

265
00:16:00,010 --> 00:16:03,220
>> 并且其中的每个层
应该有一个父图像

266
00:16:03,220 --> 00:16:06,690
它引用时，
其实想创建。

267
00:16:06,690 --> 00:16:09,922
他们是不可改变的，在这个意义上
因为他们是只读的，

268
00:16:09,922 --> 00:16:11,630
你不能真正
对其进行更改。

269
00:16:11,630 --> 00:16:17,540
您可以使用它们来创建一个
从图像中，容器

270
00:16:17,540 --> 00:16:23,530
会调用所有后续
所需的图像下面。

271
00:16:23,530 --> 00:16:26,400
>> 您可以更改
到一个不同的层，

272
00:16:26,400 --> 00:16:28,810
这是一个重写层，我会
在第二个谈。

273
00:16:28,810 --> 00:16:31,350
但每个这些层的
永远不会改变。

274
00:16:31,350 --> 00:16:34,300

275
00:16:34,300 --> 00:16:38,670
基本的图像使用的东西
所谓的联盟文件系统，UFS。

276
00:16:38,670 --> 00:16:42,280
而有不同的存储
后端利用该技术。

277
00:16:42,280 --> 00:16:49,430
而这是什么意思是，它
汇集了不同的文件系统

278
00:16:49,430 --> 00:16:51,190
使它们看起来像一个。

279
00:16:51,190 --> 00:16:54,460
>> 所以，你实际上可以从
应用的角度，

280
00:16:54,460 --> 00:16:59,570
你有一个观点，即节目的顶
所有的不同的文件系统所需

281
00:16:59,570 --> 00:17:01,120
该应用程序来运行。

282
00:17:01,120 --> 00:17:04,400
但它们实际上，在此，
他们实际上是在不同的地方

283
00:17:04,400 --> 00:17:06,410
和正在使用的
其他容器为好。

284
00:17:06,410 --> 00:17:09,569

285
00:17:09,569 --> 00:17:14,410
>> 因此，大家可以看到在这里
如果我们开始与守护形象

286
00:17:14,410 --> 00:17:18,619
为基地的形象，然后
我们进去，并添加[？ emacs的？]

287
00:17:18,619 --> 00:17:20,720
然后是另一层。

288
00:17:20,720 --> 00:17:21,916
然后放入阿帕奇。

289
00:17:21,916 --> 00:17:22,790
这是另一层。

290
00:17:22,790 --> 00:17:25,470
然后我们花费
容器从。

291
00:17:25,470 --> 00:17:29,760
每个这些图像，
每个这些层，

292
00:17:29,760 --> 00:17:35,530
是不同的，并且可以是
其他容器重复使用。

293
00:17:35,530 --> 00:17:40,070
>> 如果你看一下容器本身，
他们在某种程度上像虚拟机一样，

294
00:17:40,070 --> 00:17:41,930
但不处理的相同时间。

295
00:17:41,930 --> 00:17:49,180
所以，他们没有，在技术上，
它们下面的完整的操作系统。

296
00:17:49,180 --> 00:17:52,630
他们使用单内核
主机操作系统。

297
00:17:52,630 --> 00:17:54,440
他们建立在此之上。

298
00:17:54,440 --> 00:17:56,250
他们模仿他们如何看。

299
00:17:56,250 --> 00:18:00,710
他们模仿他们的根文件
操作系统的系统。

300
00:18:00,710 --> 00:18:04,930
但他们实际上没有复制。

301
00:18:04,930 --> 00:18:12,080
>> 代替具有不可改变的层，从而，
最后层，其是容器

302
00:18:12,080 --> 00:18:14,690
本身，它是一个读写层。

303
00:18:14,690 --> 00:18:17,350
这也运行过程
您的应用程序。

304
00:18:17,350 --> 00:18:23,530
它依赖于基础层上。

305
00:18:23,530 --> 00:18:26,730
每个容器
从图像创建。

306
00:18:26,730 --> 00:18:32,450
这图像可以是单一的
层或多层图像。

307
00:18:32,450 --> 00:18:37,200
>> 我想，这里要注意
该码头工人大量使用，

308
00:18:37,200 --> 00:18:40,370
或者是基于复制的写机制。

309
00:18:40,370 --> 00:18:44,350
所以说，实际上，如果你不
进行更改到容器上，

310
00:18:44,350 --> 00:18:45,930
它不会采取额外的空间。

311
00:18:45,930 --> 00:18:49,600
所以这基本上是你如何
总结副本上写。

312
00:18:49,600 --> 00:18:53,820
这将明确加快
开机时间容器。

313
00:18:53,820 --> 00:18:56,300
因为如果你没有将
变化到容器上，

314
00:18:56,300 --> 00:18:57,800
它是利用了什么已经存在。

315
00:18:57,800 --> 00:19:01,130

316
00:19:01,130 --> 00:19:02,955
>> 那么，它是如何实际工作。

317
00:19:02,955 --> 00:19:06,920

318
00:19:06,920 --> 00:19:14,240
它的一部分的样子，现在，它
使用至少两个关键的内核

319
00:19:14,240 --> 00:19:14,820
特征。

320
00:19:14,820 --> 00:19:17,660
这基本上是什么
创建隔离的那个水平

321
00:19:17,660 --> 00:19:19,550
对于容器本身。

322
00:19:19,550 --> 00:19:22,290
这些特征是
命名空间和cgroup的。

323
00:19:22,290 --> 00:19:29,870
因此，命名空间是一种方法，
创建隔离的资源，

324
00:19:29,870 --> 00:19:36,290
使容器本身内，
只有你能看到一定的资源。

325
00:19:36,290 --> 00:19:40,030
比如网络接口
或者某些用户或诸如此类的东西。

326
00:19:40,030 --> 00:19:44,160
>> 而这些仅仅是可见的，只有
在容器内进行访问。

327
00:19:44,160 --> 00:19:48,290
cgroup中在另一侧限
你如何使用这些资源。

328
00:19:48,290 --> 00:19:50,950
的CPU，存储器和磁盘。

329
00:19:50,950 --> 00:19:53,900
当你能进去，我
是指那些实际上是

330
00:19:53,900 --> 00:19:57,410
被开发by--的功能
他们是Linux内核的一部分。

331
00:19:57,410 --> 00:20:01,800
因此，他们并没有彻底改造
或由码头工人重新创建。

332
00:20:01,800 --> 00:20:03,770
泊坞窗使用它们。

333
00:20:03,770 --> 00:20:05,560
>> 什么医生真的
这里实际上是它

334
00:20:05,560 --> 00:20:08,680
精心策划创作
名称空间每个容器

335
00:20:08,680 --> 00:20:13,320
和创建的cgroup以便它
可笑容易创建容器

336
00:20:13,320 --> 00:20:14,870
使用这些功能。

337
00:20:14,870 --> 00:20:22,910
当然，前面我所描述，联盟
文件系统和副本上写真正

338
00:20:22,910 --> 00:20:26,810
帮助的速度和盘
利用容器。

339
00:20:26,810 --> 00:20:28,917
>> 一旦你得到你的
各地码头工人手中，

340
00:20:28,917 --> 00:20:32,000
你会看到它的速度有多快
实际上旋转起来的容器和撕裂

341
00:20:32,000 --> 00:20:32,500
下来。

342
00:20:32,500 --> 00:20:36,060

343
00:20:36,060 --> 00:20:40,230
所以，如果你可能会问，怎么能
你居然构建映像？

344
00:20:40,230 --> 00:20:45,940
我们创造的过程构建映像
容器和更改，变更

345
00:20:45,940 --> 00:20:50,220
他们，并承诺他们
入成为一个图像。

346
00:20:50,220 --> 00:20:54,330
>> 所以这是一个鸡和
鸡蛋参考这里，

347
00:20:54,330 --> 00:20:57,350
因为所有容器都
从图片和图像来

348
00:20:57,350 --> 00:21:00,270
从承诺容器，
在大多数情况下。

349
00:21:00,270 --> 00:21:03,830
有三个选项
创建图像。

350
00:21:03,830 --> 00:21:06,580
我要说明
第一个和最后一个。

351
00:21:06,580 --> 00:21:10,060
您可以手动或者
去运行容器

352
00:21:10,060 --> 00:21:14,280
做出这些变化，
就像你会做任何VM

353
00:21:14,280 --> 00:21:17,060
或任何操作系统，如
安装新的二进制文件，

354
00:21:17,060 --> 00:21:19,370
添加文件系统，以及诸如此类的东西。

355
00:21:19,370 --> 00:21:22,620
>> 然后你退出，因为
你可以看到在那里。

356
00:21:22,620 --> 00:21:24,330
我离开我的容器。

357
00:21:24,330 --> 00:21:26,050
然后我做泊坞提交。

358
00:21:26,050 --> 00:21:28,390
而我犯了。

359
00:21:28,390 --> 00:21:31,560
你可以在这里看到，数
只是一个UUID，或前12

360
00:21:31,560 --> 00:21:32,810
的UUID的比特。

361
00:21:32,810 --> 00:21:34,320
或字节的UUID的。

362
00:21:34,320 --> 00:21:35,770
然后，我打电话是我的形象。

363
00:21:35,770 --> 00:21:39,510
所以，现在泊坞窗照顾
记录一切，我做到了

364
00:21:39,510 --> 00:21:42,830
并创造了新的
基于该图像。

365
00:21:42,830 --> 00:21:47,080

366
00:21:47,080 --> 00:21:52,560
>> 我不打算谈压缩包，
但有一种方法可以得到一个单一的，

367
00:21:52,560 --> 00:21:58,200
创建一个单一的，或者使一个单一
使用tar包层图像。

368
00:21:58,200 --> 00:22:02,650
什么我要说说这
什么今天的主要使用，

369
00:22:02,650 --> 00:22:03,270
是Dockerfile。

370
00:22:03,270 --> 00:22:07,260
这在技术上是第一
一步一个码头工人本身的自动化。

371
00:22:07,260 --> 00:22:11,920
所以Dockerfiles事情，你是
会看到很多GitHub的回购

372
00:22:11,920 --> 00:22:13,150
今天。

373
00:22:13,150 --> 00:22:16,420
它基本上只是一个
描述文本文件

374
00:22:16,420 --> 00:22:19,780
究竟该如何建立形象。

375
00:22:19,780 --> 00:22:25,540
>> 而对于每一行，它实际上创造
容器，执行该线，

376
00:22:25,540 --> 00:22:30,480
提交该容器成
新形象，而你，基本上，

377
00:22:30,480 --> 00:22:36,160
将其用于所有的后续操作
直到你到最后的图像。

378
00:22:36,160 --> 00:22:39,260
这基本上是
最终目标这里，结束。

379
00:22:39,260 --> 00:22:42,420
而当你后，你exec--
写你的Dockerfile，这

380
00:22:42,420 --> 00:22:46,750
是纯粹的文字，你做一个泊坞窗
构建和图像的名称。

381
00:22:46,750 --> 00:22:50,000
>> 而你指向的是
其中Dockerfile是。

382
00:22:50,000 --> 00:22:56,570
你可以期望看到我的形象
作为一个形象，你在本地。

383
00:22:56,570 --> 00:22:59,100
所以，这只是一个视觉
什么的例子不胜枚举。

384
00:22:59,100 --> 00:23:00,820
你开始与基础映像。

385
00:23:00,820 --> 00:23:05,150
您运行到一个容器
不改变基本图像本身。

386
00:23:05,150 --> 00:23:08,310
而是创建
在它的上面重写层

387
00:23:08,310 --> 00:23:10,340
在这里所做的更改，
在您提交

388
00:23:10,340 --> 00:23:15,050
你重复这个过程，直到
你会得到你的最终图像。

389
00:23:15,050 --> 00:23:20,980
>> 而通过这样做，每隔构建
进程可以使用相同的层

390
00:23:20,980 --> 00:23:23,870
和same--基本
泊坞窗缓存这些层。

391
00:23:23,870 --> 00:23:30,040
所以，如果我做的完全相同
过程中，而是安装PHP，

392
00:23:30,040 --> 00:23:31,540
我安装Python。

393
00:23:31,540 --> 00:23:34,210
这将使用Apache和Ubuntu。

394
00:23:34,210 --> 00:23:39,570
这样一来，你就可以利用你的磁盘。

395
00:23:39,570 --> 00:23:42,330
它利用高速缓存
和可用的图像那里。

396
00:23:42,330 --> 00:23:45,320

397
00:23:45,320 --> 00:23:48,840
>> 最后一块是书记官
是你如何分配你的图片。

398
00:23:48,840 --> 00:23:52,710
而且，正如我前面提到的，
有一个云版本的它，

399
00:23:52,710 --> 00:23:54,290
这是泊坞枢纽。

400
00:23:54,290 --> 00:23:57,550
你可以去探索
很多，基本上

401
00:23:57,550 --> 00:24:04,900
这是一个公开的SAS产品，
你仍然可以有私人的图像，

402
00:24:04,900 --> 00:24:06,590
但是有很多的公共图像。

403
00:24:06,590 --> 00:24:10,580
它实际上是无限的，你可以
推无限的公众形象出现。

404
00:24:10,580 --> 00:24:13,730
这是你怎么能
与您的团队协作。

405
00:24:13,730 --> 00:24:17,159
>> 你可以将它们指向你回购
他们可以下载它，或者你的形象

406
00:24:17,159 --> 00:24:18,200
他们可以下载它。

407
00:24:18,200 --> 00:24:21,140

408
00:24:21,140 --> 00:24:24,990
因此，足够的谈话。

409
00:24:24,990 --> 00:24:29,110
谁愿意看到一些演示真正的快？

410
00:24:29,110 --> 00:24:31,330
好吧。

411
00:24:31,330 --> 00:24:34,050
所以在这里我有。

412
00:24:34,050 --> 00:24:37,480
CA你们看到我的屏幕？

413
00:24:37,480 --> 00:24:38,390
好吧。

414
00:24:38,390 --> 00:24:45,810
>> 所以，我有泊坞运行在这里，所以我
可以检查it's--这是版本

415
00:24:45,810 --> 00:24:47,510
泊坞窗的的运行。

416
00:24:47,510 --> 00:24:49,320
可以做多克的信息。

417
00:24:49,320 --> 00:24:55,730
检查所有有多少信息
图像他们有，等等。

418
00:24:55,730 --> 00:24:58,890
泊坞PS，没有什么运行。

419
00:24:58,890 --> 00:25:00,570
这些连接在一起。

420
00:25:00,570 --> 00:25:06,370
>> 所以，我想要做的第一件事就是秀
你如何可以轻松地运行的容器。

421
00:25:06,370 --> 00:25:09,350
因此，关于美
医生来说，如果它实际上

422
00:25:09,350 --> 00:25:14,700
没有找到本地的图像，
默认情况下，会谈医生集线器

423
00:25:14,700 --> 00:25:17,240
并试图找到它
和下载它。

424
00:25:17,240 --> 00:25:22,820
因此它包括一个多克
拉命令，自然。

425
00:25:22,820 --> 00:25:26,130
>> 所以，如果我做的一个码头工人来说，你好世界。

426
00:25:26,130 --> 00:25:28,890

427
00:25:28,890 --> 00:25:31,200
因此，首先它是怎么回事
试图找到它。

428
00:25:31,200 --> 00:25:36,140
否则，你可以在这里看到，
它找不到本地。

429
00:25:36,140 --> 00:25:41,830
现在，它只是拉着两层
，使得该图像，我跑了。

430
00:25:41,830 --> 00:25:45,440
该HELLO-世界只是基本
输出，你做了什么。

431
00:25:45,440 --> 00:25:47,680
因此，这是最简单的，
一个最简单的例子。

432
00:25:47,680 --> 00:25:53,840
所以，其实我只是跑和
终止容器真正的快。

433
00:25:53,840 --> 00:25:59,500
>> 如果我想，以run--和的方式，如果
我想的是，只要你知道的时候，

434
00:25:59,500 --> 00:26:03,572
这是需要多长时间来
实际上旋转起来，并包含它。

435
00:26:03,572 --> 00:26:05,030
我们测量它以毫秒为单位。

436
00:26:05,030 --> 00:26:10,600
所以，你可以看到有多少这样能
真正帮助你不仅在测试中，

437
00:26:10,600 --> 00:26:13,200
而且，即使部署。

438
00:26:13,200 --> 00:26:17,221
所以这是一个简单的笔记上。

439
00:26:17,221 --> 00:26:18,970
接下来的事情我是
要做的实际上是

440
00:26:18,970 --> 00:26:21,930
跑我已经准备的图像。

441
00:26:21,930 --> 00:26:24,460
因此，泊坞窗运行。

442
00:26:24,460 --> 00:26:27,240
-d仅仅是一个标志，告诉
它在后台运行。

443
00:26:27,240 --> 00:26:30,290
和-P分配特定端口。

444
00:26:30,290 --> 00:26:32,670
因为默认情况下，
容器是孤立的，

445
00:26:32,670 --> 00:26:36,080
所以你必须明确指定
如何可以访问它们。

446
00:26:36,080 --> 00:26:41,150
在这种情况下，我告诉泊坞窗
映射一个随机端口的主机上

447
00:26:41,150 --> 00:26:44,560
内指定端口
容器本身。

448
00:26:44,560 --> 00:26:47,130

449
00:26:47,130 --> 00:26:56,460
而这基本上是哪里image--
希望这是正确的。

450
00:26:56,460 --> 00:27:01,780
>> 因此，它的并行下载每个
这些层中，你可以在这里看到。

451
00:27:01,780 --> 00:27:06,949
那些的各层使
我建的高端形象。

452
00:27:06,949 --> 00:27:08,115
这将需要一秒钟。

453
00:27:08,115 --> 00:27:11,290

454
00:27:11,290 --> 00:27:12,370
瞧。

455
00:27:12,370 --> 00:27:16,590
>> 所以，现在如果我做一个泊坞窗ps的，我应该
看到正在运行的东西。

456
00:27:16,590 --> 00:27:22,250
我应该看到的ID，图像
这是基于关闭，

457
00:27:22,250 --> 00:27:23,880
并且命令被执行。

458
00:27:23,880 --> 00:27:28,720
以及如何访问它
基本上你去到该端口。

459
00:27:28,720 --> 00:27:33,240
所以我要去用于：此
是我在AWS上运行它。

460
00:27:33,240 --> 00:27:37,150
我要去32769。

461
00:27:37,150 --> 00:27:37,650
哎呀。

462
00:27:37,650 --> 00:27:40,495

463
00:27:40,495 --> 00:27:41,120
现在我们开始。

464
00:27:41,120 --> 00:27:44,550
>> 因此，这其实只是
Web服务，显示

465
00:27:44,550 --> 00:27:46,240
该容器它正在从提供服务。

466
00:27:46,240 --> 00:27:50,450
所以，你可以看到它
从容器a9f。

467
00:27:50,450 --> 00:27:52,850
在这里，这是
容器的命名。

468
00:27:52,850 --> 00:27:56,550
所以你们可以看到如何迅速
是实际上不仅拉也

469
00:27:56,550 --> 00:28:00,440
部署该容器。

470
00:28:00,440 --> 00:28:05,070
>> 现在，下一个步骤是
考虑Dockerfiles

471
00:28:05,070 --> 00:28:09,430
以及我们如何真正
建立新的图像。

472
00:28:09,430 --> 00:28:15,250
我只是去给克隆，一
样品根据先前Dockerfile

473
00:28:15,250 --> 00:28:17,755
图中，一个Apache和PHP。

474
00:28:17,755 --> 00:28:26,740

475
00:28:26,740 --> 00:28:28,140
希望我记得我的回购协议。

476
00:28:28,140 --> 00:28:36,410

477
00:28:36,410 --> 00:28:38,750
>> 所以，我有我的库现在。

478
00:28:38,750 --> 00:28:43,080
而且你会看到
这个有很多实际。

479
00:28:43,080 --> 00:28:45,110
我没有安装树。

480
00:28:45,110 --> 00:28:48,700
>> 所以基本上你会怎么看
你的源代码文档各地

481
00:28:48,700 --> 00:28:51,240
它，然后一个Dockerfile上
如何真正打包。

482
00:28:51,240 --> 00:28:57,970
所以，这只是一个示例PHP
呼应打招呼CS50。

483
00:28:57,970 --> 00:29:01,550
>> 所以，如果我要运行它，
我会做搬运工的构建。

484
00:29:01,550 --> 00:29:03,370
我必须先建立它。

485
00:29:03,370 --> 00:29:12,420
我将它命名为demo_cs50。

486
00:29:12,420 --> 00:29:16,470
而你需要一个标签，它也。

487
00:29:16,470 --> 00:29:19,802
因此，让我们把它叫做v1的点缀。

488
00:29:19,802 --> 00:29:21,760
因此，正如我前面所述，
我在做什么今天

489
00:29:21,760 --> 00:29:26,840
是我告诉泊坞去使用
实际上that--，对不起，是我不好。

490
00:29:26,840 --> 00:29:29,450

491
00:29:29,450 --> 00:29:32,500
我们没有一起来看看
在Dockerfile本身。

492
00:29:32,500 --> 00:29:39,020
因此，在这里唯一的东西
index.php文件以及自述文件

493
00:29:39,020 --> 00:29:39,810
和Dockerfile。

494
00:29:39,810 --> 00:29:44,600
>> 所以，如果你看看
在Dockerfile，所以它的

495
00:29:44,600 --> 00:29:47,150
非常类似于
我前面所述。

496
00:29:47,150 --> 00:29:51,220
它只是一堆
泊坞窗执行该步骤

497
00:29:51,220 --> 00:29:56,330
通过建立和拆除容器
和 [？计数？]成的图像。

498
00:29:56,330 --> 00:29:59,570
>> 基本上，你可以
see-- [听不清]它这里 - 

499
00:29:59,570 --> 00:30:04,340
但是这是从本地回购。

500
00:30:04,340 --> 00:30:06,410
这将去抓住index.php文件。

501
00:30:06,410 --> 00:30:10,970
所以，这是唯一的源代码，
实际上你的应用程序的一部分。

502
00:30:10,970 --> 00:30:16,800
所有这一切基本上都是
操作系统管道，

503
00:30:16,800 --> 00:30:21,460
获得正确的包和
Apache和PHP，以及诸如此类的东西。

504
00:30:21,460 --> 00:30:26,950
但其实这是采取的index.php
并承诺将它放入容器，

505
00:30:26,950 --> 00:30:28,210
到图像。

506
00:30:28,210 --> 00:30:33,120
>> 所以，如果你继续运行的
命令通过执行以下操作，

507
00:30:33,120 --> 00:30:36,155
它实际上going--，
这可能需要一点。

508
00:30:36,155 --> 00:30:40,870

509
00:30:40,870 --> 00:30:42,455
但愿它不会需要太长时间。

510
00:30:42,455 --> 00:30:45,129

511
00:30:45,129 --> 00:30:46,170
所以你可以看到的步骤。

512
00:30:46,170 --> 00:30:49,320
我鼓励你去
回到家里今天和尝试。

513
00:30:49,320 --> 00:30:51,280
而马诺将描述
究竟你做到这一点。

514
00:30:51,280 --> 00:30:57,810
但它真的很棒，看看到底
发生了什么幕后。

515
00:30:57,810 --> 00:31:02,420
但它的可笑容易建立
图像和使用泊坞部署它们。

516
00:31:02,420 --> 00:31:12,170

517
00:31:12,170 --> 00:31:14,050
>> 它采取了一下
比我预期的要长。

518
00:31:14,050 --> 00:31:29,085

519
00:31:29,085 --> 00:31:32,690
>> 让我们来看看，当你 - 冷却会发生什么。

520
00:31:32,690 --> 00:31:36,260
因此，大家可以看到，每一个这些步骤
表示在Dockerfile线。

521
00:31:36,260 --> 00:31:42,570
它表明在这里，它
成功建立了这个形象。

522
00:31:42,570 --> 00:31:46,480
>> 所以，如果我做搬运工的图像，我要去
看到我所有的局部图像。

523
00:31:46,480 --> 00:31:52,160
其中一人叫我
的用户名，和该图像的名称，

524
00:31:52,160 --> 00:31:56,050
并且标签representing--
主要是它的一个版本标记。

525
00:31:56,050 --> 00:31:58,040
>> 所以，现在如果我想运行
它，我做搬运工运行。

526
00:31:58,040 --> 00:32:06,040

527
00:32:06,040 --> 00:32:14,960
而我只想做一个-d -P。做V1。

528
00:32:14,960 --> 00:32:18,500
所以，我现在可以看到我有两个
容器运行，一个，我刚

529
00:32:18,500 --> 00:32:21,230
创建和Hello
多克一个，我最后得到了。

530
00:32:21,230 --> 00:32:24,320
>> 你可以在这里看到，它
其分配一个不同的端口。

531
00:32:24,320 --> 00:32:30,710
所以，如果我去同一个IP，但它分配
不同port--希望我没有。

532
00:32:30,710 --> 00:32:33,060
所以，现在这个应用程序
我刚刚部署。

533
00:32:33,060 --> 00:32:35,980

534
00:32:35,980 --> 00:32:43,900
>> 如果我想做出改变，我
可以快速编辑源代码

535
00:32:43,900 --> 00:32:49,050
并做到以下几点。

536
00:32:49,050 --> 00:32:55,170
让我们做你好哈佛。

537
00:32:55,170 --> 00:32:57,989
所以，现在这是怎么回事
发生的是，我

538
00:32:57,989 --> 00:32:59,905
要与标记它
不同version--哦，

539
00:32:59,905 --> 00:33:03,080
不是这个guy--将其标记
不同的版本。

540
00:33:03,080 --> 00:33:05,735
而你要
see--做你们的期望

541
00:33:05,735 --> 00:33:11,020
它采取相同的时间量
建立它第二次还是没有？

542
00:33:11,020 --> 00:33:14,470
所有的权利，任何人都知道这是为什么？

543
00:33:14,470 --> 00:33:15,020
说出来。

544
00:33:15,020 --> 00:33:16,350
>> 听众：[听不清]

545
00:33:16,350 --> 00:33:19,830
>> NICOLA KABAR：它基本上我们
仅改变的稍后的步骤之一。

546
00:33:19,830 --> 00:33:23,110
因此，它会使用
高速缓存和使用各个层。

547
00:33:23,110 --> 00:33:27,080
这就是真正的一些
泊坞窗的杀手锏

548
00:33:27,080 --> 00:33:32,930
它实际上是如何利用
并重接管

549
00:33:32,930 --> 00:33:36,950
您的磁盘相同
准确的信息片段。

550
00:33:36,950 --> 00:33:40,700
>> 因此，如果我们做同样的事情，
只花了几秒钟。

551
00:33:40,700 --> 00:33:48,860
如果我们想的那么现在redeploy--
我应该有三个容器。

552
00:33:48,860 --> 00:33:56,160
但是这一个是
担任the--七分之一。

553
00:33:56,160 --> 00:33:58,860
所以，现在是第三个容器中。

554
00:33:58,860 --> 00:34:02,580
每个人都明白
我只是在这里做？

555
00:34:02,580 --> 00:34:06,320
>> 所以，现在，如果你想分享这
容器真正的快与你的朋友，

556
00:34:06,320 --> 00:34:14,840
你可以做搬运工推
容器的命名，希望。

557
00:34:14,840 --> 00:34:20,130
所以，现在它要推
用于：我不是在这里签署。

558
00:34:20,130 --> 00:34:33,511

559
00:34:33,511 --> 00:34:34,219
对于那个很抱歉。

560
00:34:34,219 --> 00:34:39,219
但我不打算现在解决此。

561
00:34:39,219 --> 00:34:42,780
但基本上是一个命令
只是上升推。

562
00:34:42,780 --> 00:34:45,670
而你将能够
看到它，如果你去泊坞枢纽

563
00:34:45,670 --> 00:34:48,587
而你的，你登录
要能够看到它。

564
00:34:48,587 --> 00:34:50,420
然后你可以只
指出谁是怎么回事

565
00:34:50,420 --> 00:34:52,750
使用该图像的去拉。

566
00:34:52,750 --> 00:34:55,460
他们可以使用它。

567
00:34:55,460 --> 00:34:57,760
>> 就这样，希望
我种证明

568
00:34:57,760 --> 00:35:01,230
它是多么容易与码头工人的工作。

569
00:35:01,230 --> 00:35:06,610
而我只是要
还给马诺。

570
00:35:06,610 --> 00:35:11,760
而且他会采取它从这里开始。

571
00:35:11,760 --> 00:35:13,990
>> MANO MARKS：好吧
谢谢，谢谢尼科。

572
00:35:13,990 --> 00:35:18,700

573
00:35:18,700 --> 00:35:20,614
所以呢？

574
00:35:20,614 --> 00:35:24,410
所以的事情之一我
想做的事放在一起

575
00:35:24,410 --> 00:35:28,820
为什么这是一个important--
为什么泊坞窗，为什么

576
00:35:28,820 --> 00:35:33,000
容器是这样的
重要的新进展，

577
00:35:33,000 --> 00:35:36,890
实际上做软件的新途径。

578
00:35:36,890 --> 00:35:41,300
>> 还没等我做什么，我要去
只是介绍一些统计数据。

579
00:35:41,300 --> 00:35:42,790
我不会阅读所有这些。

580
00:35:42,790 --> 00:35:52,540
但是，这显示了你很多有关如何
流行的是在社区。

581
00:35:52,540 --> 00:35:56,310
核心泊坞窗技术
都是开源的。

582
00:35:56,310 --> 00:36:03,560
所以这是泊坞引擎，撰写，
群，一堆其他的东西

583
00:36:03,560 --> 00:36:05,210
都是开源的。

584
00:36:05,210 --> 00:36:10,590
我们有，我干了什么
说，1300贡献者。

585
00:36:10,590 --> 00:36:15,630
您现在看到的，如果你看一下
职位空缺的数目，最后一次

586
00:36:15,630 --> 00:36:19,640
我们看到，这是集团的43,000名工作
开口特别提到

587
00:36:19,640 --> 00:36:22,230
熟悉泊坞窗。

588
00:36:22,230 --> 00:36:26,450
数以百万计的图像有
被下载的泊坞枢纽。

589
00:36:26,450 --> 00:36:31,870
而且，还有，更大量的统计。

590
00:36:31,870 --> 00:36:34,770
>> 对于那些谁是好奇，它
最初是用Python编写的

591
00:36:34,770 --> 00:36:37,730
然后改写成围棋。

592
00:36:37,730 --> 00:36:40,320
而且它只有
打开source--这只是

593
00:36:40,320 --> 00:36:44,950
被释放约2年半，
这意味着，在2和1/2年，

594
00:36:44,950 --> 00:36:48,020
我们已经看到了大量的
生长和重要性的

595
00:36:48,020 --> 00:36:50,190
这在社会上。

596
00:36:50,190 --> 00:36:52,400
所以，我想谈
为什么一点点。

597
00:36:52,400 --> 00:36:54,940

598
00:36:54,940 --> 00:36:59,880
>> 所以，只是重申了一些
尼科的关键点，泊坞快。

599
00:36:59,880 --> 00:37:00,630
它是便携式的。

600
00:37:00,630 --> 00:37:02,500
这是重复的。

601
00:37:02,500 --> 00:37:06,130
它建立了一个标准的环境。

602
00:37:06,130 --> 00:37:13,370
>> 而what--这是我的蹩脚
杜绝巨石slide--什么

603
00:37:13,370 --> 00:37:17,990
它帮助人们做的，这
很多软件产业

604
00:37:17,990 --> 00:37:21,400
开始做的
21世纪初，是移动

605
00:37:21,400 --> 00:37:24,200
从这些单片
单一的应用

606
00:37:24,200 --> 00:37:28,590
在每一个依赖必须是
测试的整个应用程序收到

607
00:37:28,590 --> 00:37:31,280
待部署，这
可能意味着一个网站

608
00:37:31,280 --> 00:37:36,240
只得到了部署一次
每三个月，或更多，

609
00:37:36,240 --> 00:37:42,650
到一个更服务
面向服务架构

610
00:37:42,650 --> 00:37:46,090
或组件化的不同类型的
应用架构。

611
00:37:46,090 --> 00:37:48,610
所以允许这些
样的架构

612
00:37:48,610 --> 00:37:52,250
即利用
多克尔到在这三个运行

613
00:37:52,250 --> 00:37:58,450
发展的主要领域，其中
正在开发编写实际的代码，

614
00:37:58,450 --> 00:38:00,140
测试你的代码，并部署它。

615
00:38:00,140 --> 00:38:03,000

616
00:38:03,000 --> 00:38:05,420
>> 那么，为什么这很重要？

617
00:38:05,420 --> 00:38:09,920
如果你A--让我举一个例子。

618
00:38:09,920 --> 00:38:13,600
如果你是一个网站
设备的开发，你

619
00:38:13,600 --> 00:38:19,020
开发这是基于该网站
大卫产生在这里的数据库。

620
00:38:19,020 --> 00:38:20,490
对不起大卫，我给你打电话了。

621
00:38:20,490 --> 00:38:22,984

622
00:38:22,984 --> 00:38:24,900
如果你想部署
整个事情，你

623
00:38:24,900 --> 00:38:28,870
有下一个传统的等待
整体软件开发

624
00:38:28,870 --> 00:38:32,710
环境中，你必须要等待
直到他被与数据库进行

625
00:38:32,710 --> 00:38:36,030
之前，你实际上可能使
任何更改到您的网站。

626
00:38:36,030 --> 00:38:40,900
你不得不重新部署
整个应用这样做。

627
00:38:40,900 --> 00:38:45,490
>> 什么泊坞窗可帮助你要做的就是每个
不同成分的人工作

628
00:38:45,490 --> 00:38:52,990
并更新他们，因为他们去，只是让
确保该接口保持不变。

629
00:38:52,990 --> 00:38:56,350
所以它做了什么
是它的转向人

630
00:38:56,350 --> 00:39:03,950
从做这些庞大的单片
架构软件

631
00:39:03,950 --> 00:39:07,610
每个月部署到连续
整合和持续发展

632
00:39:07,610 --> 00:39:08,490
环境。

633
00:39:08,490 --> 00:39:12,580
>> 现在，这是不是唯一的码头工人，
但泊坞窗使得它容易得多，

634
00:39:12,580 --> 00:39:16,620
这意味着你基本上
不断部署。

635
00:39:16,620 --> 00:39:20,690
我们谈论的企业是
部署面向公众的应用

636
00:39:20,690 --> 00:39:30,180
成千上万的一天，因为次
他们看到的只是让价值

637
00:39:30,180 --> 00:39:33,740
小的变化，而只要
因为它贯穿测试，

638
00:39:33,740 --> 00:39:35,900
让它走出去投入生产。

639
00:39:35,900 --> 00:39:41,890
尼科总是告诉我
早些时候，在许多环境中，

640
00:39:41,890 --> 00:39:46,580
一个标准的生命周期
容器的单位是秒，

641
00:39:46,580 --> 00:39:50,460
而在虚拟机
在几个月可能被测量。

642
00:39:50,460 --> 00:39:54,590

643
00:39:54,590 --> 00:39:58,690
>> 我想采取一个轻微
转在这里，因为我

644
00:39:58,690 --> 00:40:00,170
在一个教育机构。

645
00:40:00,170 --> 00:40:06,670
我想给怎样的一个例子
这部作品在一个教育研究

646
00:40:06,670 --> 00:40:07,670
情况。

647
00:40:07,670 --> 00:40:10,930
因此，有一个组织
所谓的生物箱。

648
00:40:10,930 --> 00:40:15,450
生物箱做DNA
分析研究。

649
00:40:15,450 --> 00:40:22,029
>> 现在，他们发现的是，当
一个researcher--而这是不

650
00:40:22,029 --> 00:40:24,070
任何特定的故障
researcher--但是当

651
00:40:24,070 --> 00:40:31,240
部署研究员
一种算法来分析，

652
00:40:31,240 --> 00:40:36,670
在一个具体的方式中，DNA样品，
他们会写软件，

653
00:40:36,670 --> 00:40:39,980
发布，也许到
GitHub上或其他地方，

654
00:40:39,980 --> 00:40:42,680
然后将其完成。

655
00:40:42,680 --> 00:40:47,440
>> 那么问题是，它
不一定再现的。

656
00:40:47,440 --> 00:40:51,610
因为为了
了解软件，

657
00:40:51,610 --> 00:40:54,830
他们将设置为
确切的开发环境

658
00:40:54,830 --> 00:41:00,460
这是研究人员使用，通常
他们的膝上型计算机或服务器，或数据

659
00:41:00,460 --> 00:41:04,280
中心发现他们使用。

660
00:41:04,280 --> 00:41:11,530
因此，这是非常困难
重现的研究成果时，

661
00:41:11,530 --> 00:41:16,910
分析DNA样本，以寻找
在像incidence--

662
00:41:16,910 --> 00:41:23,830
比较心脏发作发病率
根据某些基因存在，

663
00:41:23,830 --> 00:41:28,900
例如，或癌症风险，或
任何其他种类的东西。

664
00:41:28,900 --> 00:41:33,900
>> 所以他们做了什么，而不是被
他们开始创建容器。

665
00:41:33,900 --> 00:41:39,380
你可以去bioboxes.org，
这是一个伟大的组织。

666
00:41:39,380 --> 00:41:43,900
而他们所做的是他们生产
基于研究的容器。

667
00:41:43,900 --> 00:41:46,840
然后，每当有人向
在他们的样本，他们可以运行它。

668
00:41:46,840 --> 00:41:52,770
它拥有所有的环境
运行该算法所需

669
00:41:52,770 --> 00:41:55,370
和产生的结果。

670
00:41:55,370 --> 00:41:58,250
而且他们发现，他们是
更可能与多

671
00:41:58,250 --> 00:42:01,300
更快速地能
返回结果的人。

672
00:42:01,300 --> 00:42:06,860
>> 而事实上，人们正在做什么
正在运行自己的分析对DNA，

673
00:42:06,860 --> 00:42:11,220
发送，在以生物箱，和
那么生物箱只是需要的数据，

674
00:42:11,220 --> 00:42:15,350
运行它针对各种
不同的容器

675
00:42:15,350 --> 00:42:19,030
看到不同的结果
根据不同的研究。

676
00:42:19,030 --> 00:42:21,860
所以这是一个非常强大的
方式，研究人员

677
00:42:21,860 --> 00:42:28,070
可以使一个实例，它允许
其他人试图重现

678
00:42:28,070 --> 00:42:28,650
结果。

679
00:42:28,650 --> 00:42:31,710

680
00:42:31,710 --> 00:42:34,360
>> 那么，你如何开始？

681
00:42:34,360 --> 00:42:37,950

682
00:42:37,950 --> 00:42:39,800
我们能很好地支持在Linux上。

683
00:42:39,800 --> 00:42:43,070
所以，如果你想安装
Linux上的任何东西，

684
00:42:43,070 --> 00:42:45,620
你用你的标准
包管理器安装。

685
00:42:45,620 --> 00:42:47,600
如果您使用的是Debian的，它容易搞定。

686
00:42:47,600 --> 00:42:50,500
CentOS是百胜。

687
00:42:50,500 --> 00:42:53,500
Fedora的Red Hat是
rpm--我不记得了。

688
00:42:53,500 --> 00:42:56,070
无论如何，它都在那里。

689
00:42:56,070 --> 00:42:59,610
我们支持大量不同
Linux发行版。

690
00:42:59,610 --> 00:43:01,150
您可以检查这些出。

691
00:43:01,150 --> 00:43:06,370
>> 我们也有其他选择，所以你
可以运行在Mac或Windows。

692
00:43:06,370 --> 00:43:10,670
现在尼科前面提到的那
它是只支持Linux操作系统。

693
00:43:10,670 --> 00:43:18,180
这是真的，因为它
需要一个Linux内核。

694
00:43:18,180 --> 00:43:20,540
但是，你可以在虚拟机上运行。

695
00:43:20,540 --> 00:43:25,290
什么泊坞窗工具箱
的确，你可以下载，

696
00:43:25,290 --> 00:43:27,610
它可以让你的虚拟机。

697
00:43:27,610 --> 00:43:37,260
>> 所以，只是一个快速48
第二，我认为，下载。

698
00:43:37,260 --> 00:43:40,670
你只要搜索泊坞窗
工具箱，将其下载到Mac，

699
00:43:40,670 --> 00:43:43,910
这部分是
当然加快了，因为谁

700
00:43:43,910 --> 00:43:47,620
想要观看一个下载信号？

701
00:43:47,620 --> 00:43:54,190
标准的Mac安装，
然后你

702
00:43:54,190 --> 00:43:59,795
去看看杰罗姆把他的密码。

703
00:43:59,795 --> 00:44:00,670
这是非常令人兴奋的。

704
00:44:00,670 --> 00:44:03,510

705
00:44:03,510 --> 00:44:06,230
然后它会安装一个
一大堆的工具。

706
00:44:06,230 --> 00:44:10,010
特别是它会
安装的命令行。

707
00:44:10,010 --> 00:44:14,220
然后，你可以看到
杰罗姆测试他的形象。

708
00:44:14,220 --> 00:44:19,050

709
00:44:19,050 --> 00:44:22,640
>> 然后在此基础上，
你可以看到YouTube的

710
00:44:22,640 --> 00:44:27,420
认为尼科有兴趣
星球大战的吉米金梅尔节目，

711
00:44:27,420 --> 00:44:29,020
我认为艾伦。

712
00:44:29,020 --> 00:44:34,130
我认为，最后一个是
从艾伦秀的剪辑。

713
00:44:34,130 --> 00:44:37,760
>> 因此，泊坞窗工具箱不过来
多只泊坞窗机。

714
00:44:37,760 --> 00:44:39,840
因此，泊坞窗机是
帮助的东西

715
00:44:39,840 --> 00:44:43,710
您设置一个虚拟
机上的Windows

716
00:44:43,710 --> 00:44:52,080
或Mac--您的Windows框或您的Mac
box--并帮助你做配置，

717
00:44:52,080 --> 00:44:54,040
>> 但它也带有
群和撰写，

718
00:44:54,040 --> 00:45:00,840
其目的是为了帮助你要做大
您的应用程序的规模部署。

719
00:45:00,840 --> 00:45:04,000
所以，如果你想管理
节点簇，

720
00:45:04,000 --> 00:45:08,450
集群容器，撰写并
群是要走的路有关。

721
00:45:08,450 --> 00:45:11,430
>> 当然，它带有
泊坞窗发动机和Kitematic，

722
00:45:11,430 --> 00:45:13,250
这是本桌面GUI。

723
00:45:13,250 --> 00:45:17,060
我还要提到泊坞注册，
其中不包括在工具箱，

724
00:45:17,060 --> 00:45:23,150
但它是一种让你运行你自己
像泊坞窗泊坞窗图像登记

725
00:45:23,150 --> 00:45:28,970
集线器，但你也可以只使用
码头工人枢纽，以此来做到这一点。

726
00:45:28,970 --> 00:45:32,955
>> 而且，剧情转折，你看到
它运行在容器中。

727
00:45:32,955 --> 00:45:34,830
这就是我们是
销售我们的幻灯片。

728
00:45:34,830 --> 00:45:38,610
这整个演示文稿
实际上是一个HTML幻灯片平台。

729
00:45:38,610 --> 00:45:43,170
并且它在运行中的
容器，你可以得到by--

730
00:45:43,170 --> 00:45:45,596
>> NICOLA KABAR：是的，所以它的
我的最大运行全职。

731
00:45:45,596 --> 00:45:47,540
而我从它呈现。

732
00:45:47,540 --> 00:45:50,910
你以后就去做泊坞窗
您安装工具箱。

733
00:45:50,910 --> 00:45:57,340
你可以做一个泊坞窗运行
并得到它，并使用滑动。

734
00:45:57,340 --> 00:45:58,830
>> MANO标志：就是这样。

735
00:45:58,830 --> 00:46:02,160
因此，我们感谢各位的光临。

736
00:46:02,160 --> 00:46:03,990
我们很高兴地回答问题。

737
00:46:03,990 --> 00:46:07,810
我要提到任何人之前，
叶有T恤在那边。

738
00:46:07,810 --> 00:46:10,940
对不起任何人谁在看着
本上Livestream或视频，

739
00:46:10,940 --> 00:46:12,820
但我们码头工人的T恤在那边。

740
00:46:12,820 --> 00:46:16,250
我们知道泊坞的学生，
在我的经验，

741
00:46:16,250 --> 00:46:18,940
教授也喜欢免费的衣服。

742
00:46:18,940 --> 00:46:22,490
>> 因此，感谢各位的光临了。

743
00:46:22,490 --> 00:46:27,050
而按照我们的Twitter
如果你想，还是没有。

744
00:46:27,050 --> 00:46:27,910
我不在乎。

745
00:46:27,910 --> 00:46:29,430
也跟着多克在Twitter上。

746
00:46:29,430 --> 00:46:31,890
这也很有趣。

747
00:46:31,890 --> 00:46:32,990
然后，就是这样。

748
00:46:32,990 --> 00:46:33,490
Docker.com。

749
00:46:33,490 --> 00:46:35,410
谢谢。

750
00:46:35,410 --> 00:46:39,360
>> [掌声]

751
00:46:39,360 --> 00:46:41,625