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