WEBVTT

00:00:00.120 --> 00:00:08.800
大家好，欢迎到另一个
容器频道节目。

00:00:08.800 --> 00:00:12.580
我是 Matt McSpirit，技术
我们的数据的所有宣传员

00:00:12.580 --> 00:00:15.640
中心技术，这是
第二，在一个小的 miniseries 部分

00:00:15.640 --> 00:00:18.450
我们已经在做的事情上，
在容器的基础知识。

00:00:18.450 --> 00:00:21.200
在这第一段内
我们讨论了一些 miniseries

00:00:21.200 --> 00:00:24.770
关于一些关键位
在图像周围的概念在周围

00:00:24.770 --> 00:00:28.490
网络、 周围建筑物
一个容器，我们运行一个容器。

00:00:28.490 --> 00:00:29.830
我们期待的一些
体系结构

00:00:29.830 --> 00:00:32.380
之间的区别
容器和虚拟机的。

00:00:32.380 --> 00:00:35.130
在这个片段中我高兴
要通过李瑞是浪费金钱和加入

00:00:35.130 --> 00:00:38.940
再次，以帮助我们理解
有点更有深度，或

00:00:38.940 --> 00:00:42.930
我说，他相当多的更多
深度图像上此时间

00:00:42.930 --> 00:00:45.410
网络和可移植性。

00:00:45.410 --> 00:00:48.740
因此李瑞让我们了解一些
我们需要了解的重要事项

00:00:48.740 --> 00:00:51.390
同时编写专业人员并
开发人员需要知道周围

00:00:51.390 --> 00:00:53.890
某些图像，
网络和可移植性。

00:00:53.890 --> 00:00:56.780
>> 确实使我要在中执行操作
实际上，我们是此会话

00:00:56.780 --> 00:01:00.890
要生成的应用程序
在我的便携式计算机。

00:01:00.890 --> 00:01:03.690
然后，我们将到
采用 th 容器

00:01:03.690 --> 00:01:07.720
从该应用程序的图像
将其 Docker 中心和

00:01:07.720 --> 00:01:10.960
然后将入容器
在 Azure 上运行的主机。

00:01:10.960 --> 00:01:15.360
通过此过程，我们
要深入研究图像分层。

00:01:15.360 --> 00:01:16.770
我们要谈
有关网络，和

00:01:16.770 --> 00:01:18.680
然后我们好了
可移植性段。

00:01:18.680 --> 00:01:20.970
我们要来看看
在 Docker 帮助和

00:01:20.970 --> 00:01:22.790
我们如何使用给
移动图像。

00:01:22.790 --> 00:01:25.350
>>，是因为它是不非常
复制和粘贴键入操作。

00:01:25.350 --> 00:01:26.570
没有一点儿给它更多。

00:01:26.570 --> 00:01:29.840
好了，因此，这是有一点
上一次会话中重复介绍。

00:01:29.840 --> 00:01:31.970
但愿您监视
以前的节目。

00:01:31.970 --> 00:01:33.270
我们未涵盖的一些
此内容，但

00:01:33.270 --> 00:01:34.660
只让人
为加快

00:01:34.660 --> 00:01:37.570
那些还没有
一般情况下的图像。

00:01:37.570 --> 00:01:40.310
>> 是，那么，第一件事
我们来看一看是图像

00:01:40.310 --> 00:01:43.860
和图像分层和
只是回顾一下，容器图像

00:01:45.290 --> 00:01:47.700
包含的应用程序，
它包含依赖项。

00:01:47.700 --> 00:01:50.500
因此，基本上，
我们使用的单位

00:01:50.500 --> 00:01:52.060
派生的容器。

00:01:52.060 --> 00:01:55.150
因此，我想要生成时
一个容器我基本上是

00:01:55.150 --> 00:01:59.020
嘿生成，其中一个容器
图像，你，离开它的时代。

00:01:59.020 --> 00:01:59.530
>> 好。

00:01:59.530 --> 00:02:03.180
>> 一个中的概念，
图像处理它是很棒，

00:02:03.180 --> 00:02:08.140
它，与不少，
我们如何使用图像

00:02:08.140 --> 00:02:11.970
这是虚拟机
图像分层的概念。

00:02:11.970 --> 00:02:16.520
我们开始明白我的意思是
具有基本的操作系统映像，以便

00:02:16.520 --> 00:02:19.280
那可能是
Windows 服务器核心。

00:02:19.280 --> 00:02:21.450
我们必须将图像窗口
服务器核心然后我们可能做

00:02:21.450 --> 00:02:24.630
与一些修改
图像，安装一些软件和

00:02:24.630 --> 00:02:27.550
然后捕获的
到新图像中。

00:02:27.550 --> 00:02:31.400
我们实际上并没有很好地创建
一个新的完整图像，

00:02:31.400 --> 00:02:34.610
包括 Windows 服务器核心
在新应用程序。

00:02:34.610 --> 00:02:37.270
我们实际上就创建
增量图像。

00:02:37.270 --> 00:02:38.270
>> 是。
因此它会更改。

00:02:38.270 --> 00:02:39.880
>> 刚刚所做的更改，并

00:02:39.880 --> 00:02:44.670
如果我们真要去修补程序部署
应用程序中，什么，该怎么办

00:02:44.670 --> 00:02:48.210
发生时使用的容器
>> 这两个图层。

00:02:48.210 --> 00:02:51.220
它使用基本的操作系统映像和
所做的更改。

00:02:51.220 --> 00:02:51.730
>> 的权限。
>> 和

00:02:51.730 --> 00:02:55.330
然后所有其他容器我们
此外提出在该主机上

00:02:55.330 --> 00:02:59.990
使用任何公共的层中，
我们不需要启动一个新

00:02:59.990 --> 00:03:01.710
实例
容器的图像。

00:03:01.710 --> 00:03:03.810
他们只是共享的
已经到位。

00:03:03.810 --> 00:03:06.240
因此，我们可以看一下
这在文档中或

00:03:06.240 --> 00:03:09.000
在这里，PowerPoint
和这里的图形。

00:03:09.000 --> 00:03:12.450
因此这里的图片描绘了
容器主机和

00:03:12.450 --> 00:03:14.480
容器主机无法
是物理计算机，

00:03:14.480 --> 00:03:15.480
它可能是一个虚拟机？

00:03:15.480 --> 00:03:15.980
>> 绝对，
>> 对吧？

00:03:15.980 --> 00:03:16.840
>> 的虚拟机，因此

00:03:16.840 --> 00:03:19.260
大多数的演示
我们将在这里看到。

00:03:19.260 --> 00:03:19.880
我使用了 Linux

00:03:19.880 --> 00:03:21.930
运行系统
Hyper-V 我的便携式计算机上。

00:03:21.930 --> 00:03:23.500
>> Mmhm
>> 我们还将看到一个虚拟

00:03:23.500 --> 00:03:25.840
在 Azure 上运行的计算机
在以后的时间点没关系。

00:03:25.840 --> 00:03:28.930
因此种遍历
这种情况下，通过

00:03:28.930 --> 00:03:31.180
我可能会部署
基本的操作系统映像。

00:03:31.180 --> 00:03:32.460
>> 和
人并不熟悉，

00:03:32.460 --> 00:03:34.150
从哪里获得
基本 OS 映像？

00:03:34.150 --> 00:03:36.040
我的意思是，
不要随之启动。

00:03:36.040 --> 00:03:37.310
它是在计算机上，

00:03:37.310 --> 00:03:39.300
它可能包含 [INAUDIBLE]
[INAUDIBLE] 计算机吗？

00:03:39.300 --> 00:03:40.830
它有基础操作系统
那里图像？

00:03:40.830 --> 00:03:43.430
我必须抓住它，
Windows 会怎么样？

00:03:43.430 --> 00:03:47.170
因此，如果我们正在使用我们
我们可以抓住这些 Linux 主机

00:03:47.170 --> 00:03:50.920
图像从 Docker 集线器或
其他注册表。

00:03:50.920 --> 00:03:53.460
和现在的技术
windows 服务器的预览

00:03:53.460 --> 00:03:54.130
容器。

00:03:55.680 --> 00:03:58.700
我们将以此为基础
操作系统为您，因此图像

00:03:58.700 --> 00:04:01.330
我们将 Windows 服务器
基本 OS 映像的核心。

00:04:01.330 --> 00:04:02.770
因此，如果通过这些文档，请转

00:04:02.770 --> 00:04:05.420
它将遍历的过程
Windows 服务器的设置。

00:04:05.420 --> 00:04:07.117
您可以下载 [串扰]
>> 是的和

00:04:07.117 --> 00:04:08.170
它将为您。

00:04:08.170 --> 00:04:11.280
因此可能会部署这
基本操作系统映像和

00:04:11.280 --> 00:04:12.950
然后安装部分
到它的软件。

00:04:12.950 --> 00:04:16.680
因此，让我们，只是为
例如，一个 web 应用程序。

00:04:18.070 --> 00:04:21.340
然后捕获出去的
给自己容器的映像。

00:04:21.340 --> 00:04:26.020
我然后可能重新部署，
web 服务器映像和

00:04:26.020 --> 00:04:29.200
部署应用程序，
然后再重新部署它，

00:04:29.200 --> 00:04:30.410
将另一个应用程序的部署。

00:04:30.410 --> 00:04:34.480
因此，我有两个容器
图像，每个都包含其

00:04:34.480 --> 00:04:38.550
自己的应用程序，但它们
常见的 web 服务器映像和

00:04:38.550 --> 00:04:40.740
常见的基本操作系统映像。

00:04:40.740 --> 00:04:43.520
>> 这些应用程序 1 图像和
在此处的图形应用程序 2 图像

00:04:43.520 --> 00:04:45.360
依赖
Web 服务器映像，

00:04:45.360 --> 00:04:47.340
其本身采用
对基本的依赖性。

00:04:47.340 --> 00:04:48.830
>> 是。
>>，如果您还没有，

00:04:48.830 --> 00:04:51.430
告诉我什么图像位于
系统视图，请在此容器中，

00:04:51.430 --> 00:04:52.990
您会看到四个
这一时刻。

00:04:52.990 --> 00:04:54.930
>> 是，绝对，
您会看到四个。

00:04:54.930 --> 00:04:56.180
>> 好。
>> 我们来看一看的。

00:04:56.180 --> 00:04:58.740
实际上，我们来看一看
它们之间的依赖关系。

00:04:58.740 --> 00:04:59.460
>> 好，很好。

00:04:59.460 --> 00:05:02.680
>> 然后在我容器的宿主，
如果我是将我的应用程序

00:05:02.680 --> 00:05:04.770
一幅图像，
>> 和部署它，

00:05:05.930 --> 00:05:07.360
我将有一个正在运行的容器，
>> 是。

00:05:07.360 --> 00:05:08.380
>> 与应用程序 1。

00:05:08.380 --> 00:05:12.495
并将该容器
组成这些三幅图像。

00:05:12.495 --> 00:05:13.000
>> 毫米 hm。

00:05:13.000 --> 00:05:16.380
>> 如果我再到部署
从应用程序映像 2，容器

00:05:16.380 --> 00:05:19.730
我现在已经运行容器

00:05:19.730 --> 00:05:21.780
>> 两个应用程序，您可以看到它

00:05:21.780 --> 00:05:26.195
共享公共的 web 服务器
图像，并基本操作系统映像。

00:05:26.195 --> 00:05:27.020
>> 的权限。

00:05:27.020 --> 00:05:27.990
>> 容器图像

00:05:27.990 --> 00:05:32.540
因此它实际上可能会共享
这些图像的实例。

00:05:32.540 --> 00:05:36.960
占地面积保持向下容器
增加正常运行时间的旋转。

00:05:36.960 --> 00:05:39.160
>> 和资源的使用
是非常有效的。

00:05:39.160 --> 00:05:40.070
>> 是的绝对。

00:05:40.070 --> 00:05:40.950
>> 好。

00:05:40.950 --> 00:05:42.140
>> 让我们包含我们
图像分层和

00:05:42.140 --> 00:05:43.980
我们来看一看
在演示中的。

00:05:43.980 --> 00:05:49.050
再次，我这样做的目标之一
已点出的一些类型

00:05:49.050 --> 00:05:52.310
工作之间的区别
与虚拟机上

00:05:52.310 --> 00:05:58.010
长时间的系统中心种类
数据中心管理类型

00:05:58.010 --> 00:06:01.630
因此部署虚拟机
从图像是-

00:06:01.630 --> 00:06:02.180
>> 和模板。

00:06:02.180 --> 00:06:03.780
>> 是的它是
我做了很多。

00:06:03.780 --> 00:06:05.410
它很有点此处更改。

00:06:05.410 --> 00:06:09.110
第二件事的
不同的使用

00:06:09.110 --> 00:06:12.790
从 Vm 的容器可能
是我们的网络连接方式

00:06:13.850 --> 00:06:15.250
与我们的容器。

00:06:15.250 --> 00:06:17.240
因此，您的看法时
虚拟机或

00:06:17.240 --> 00:06:19.070
虚拟机的主机。

00:06:19.070 --> 00:06:21.340
我要放大量的
在此主机上的不同虚拟机，但

00:06:21.340 --> 00:06:24.080
这些虚拟机的每个
要有一个 IP 地址。

00:06:24.080 --> 00:06:27.240
我真的不管理
它们任何以不同的方式。

00:06:27.240 --> 00:06:30.290
>> 好了，这样的 Nick 和
该 Nick 对其 mac。

00:06:30.290 --> 00:06:31.900
>> 完全正确，
>> 就像一个物理系统。

00:06:31.900 --> 00:06:32.420
>> 完全一样。

00:06:32.420 --> 00:06:34.790
如果需要访问的资源。

00:06:34.790 --> 00:06:39.400
为正在承载在该虚拟机，
我只是转到虚拟机，

00:06:40.490 --> 00:06:42.740
如下面的图像所示。

00:06:42.740 --> 00:06:46.300
因此这与的不同在于，
我们必须将此大密度

00:06:47.840 --> 00:06:50.900
功能，本大密度
与容器的功能。

00:06:50.900 --> 00:06:55.070
我可以确切地说有可能
成千上万的这些事情

00:06:55.070 --> 00:06:59.190
在一台主机，而不是
它们中的每个

00:06:59.190 --> 00:07:03.540
公共可访问
IP 地址。

00:07:03.540 --> 00:07:07.450
这是共用的
执行而不是放它们背后

00:07:09.150 --> 00:07:12.120
网络地址转换。

00:07:12.120 --> 00:07:16.030
因此，我的主机可能有 IP
被公开的地址

00:07:16.030 --> 00:07:21.400
可以但是我容器
有不可路由的 IP 地址。

00:07:21.400 --> 00:07:25.370
当我想要访问
在我的容器中，该应用程序

00:07:25.370 --> 00:07:27.930
而不是引用
该 IP 地址，或

00:07:27.930 --> 00:07:31.950
该网络的偏向名称
相关联的 IP 地址。

00:07:31.950 --> 00:07:36.430
相反，我将
访问主机和

00:07:36.430 --> 00:07:38.400
我们将构建的某些端口映射，
>> 是。

00:07:38.400 --> 00:07:40.910
>> 之间外部
在主机上的端口，

00:07:40.910 --> 00:07:42.910
内部端口
容器应用程序。

00:07:42.910 --> 00:07:43.690
>> 我看到。
>> 和什么

00:07:43.690 --> 00:07:46.270
这使我做是如果您
想象一下，我可能有

00:07:46.270 --> 00:07:49.140
容器主机正在运行
>> 三个百

00:07:49.140 --> 00:07:53.270
web 应用程序所有服务
在洗衣房端口上的内容。

00:07:53.270 --> 00:07:56.410
当然，如果我按容器
在洗衣房，端口上的主机

00:07:56.410 --> 00:07:59.410
您知道它需要知道
如何路由该请求。

00:07:59.410 --> 00:08:01.230
>> 是。
>> 因此，我们将执行这些映射。

00:08:01.230 --> 00:08:05.170
我可能做喜欢端口到端口 80
80 和 82 端口到端口 60 和

00:08:05.170 --> 00:08:06.580
83 端口到端口 80。

00:08:06.580 --> 00:08:07.120
>> 是。

00:08:07.120 --> 00:08:09.060
>> 和我们将要看到的在
同时演示。

00:08:09.060 --> 00:08:10.380
>> 很好，因此很重要
同样，调用的

00:08:10.380 --> 00:08:13.550
介绍网络
这都是通用

00:08:13.550 --> 00:08:18.340
对于很多人但 DHCP
也可以使用 [INAUDIBLE]

00:08:18.340 --> 00:08:20.470
它不只是网络
唯一的解决方案。

00:08:20.470 --> 00:08:21.720
>> Yup、 绝对，
因此，如果您是。

00:08:21.720 --> 00:08:22.670
>> 你的企业。

00:08:22.670 --> 00:08:24.960
>> 可以使用 DHCP
在容器中。

00:08:26.480 --> 00:08:29.400
什么我发现 NAT
更为常见的情况也是如此。

00:08:29.400 --> 00:08:30.820
>> 右，
好有趣，很好。

00:08:32.560 --> 00:08:34.270
>>，然后最后的最后
我们将查看此处的事情是

00:08:34.270 --> 00:08:35.270
容器注册表和

00:08:35.270 --> 00:08:37.010
我们已经讨论过这
有些已经相当。

00:08:37.010 --> 00:08:39.530
我们来看看 Docker 集线器
公开的注册表中，

00:08:39.530 --> 00:08:41.660
我们可以采取这些
容器的图像，

00:08:41.660 --> 00:08:45.000
拍卖在注册表中，
将它们拉向别处下或

00:08:45.000 --> 00:08:46.160
主机上的另一个容器。

00:08:46.160 --> 00:08:46.950
>> 很好。
好。

00:08:46.950 --> 00:08:49.950
因此，我想现在是时间
看一看该技术。

00:08:49.950 --> 00:08:50.650
>> 是。
因此，让我们跳到

00:08:50.650 --> 00:08:51.620
在演示中。

00:08:52.620 --> 00:08:53.280
>> 我说让我们做到这一点，

00:08:53.280 --> 00:08:57.470
就是你这样做，但
我声称一些，我还在这里。

00:08:57.470 --> 00:08:58.710
>> 确定。
因此第一件工作我将做

00:08:58.710 --> 00:09:02.680
只是现在，是我们要花
看图像分层此处。

00:09:02.680 --> 00:09:06.110
因此，我要首先创建
Ubuntu 用容器

00:09:06.110 --> 00:09:07.472
基本操作系统映像。

00:09:07.472 --> 00:09:11.659
因此，同一命令
我们在中使用的命令

00:09:11.659 --> 00:09:16.937
上一个视频中，
运行-docker 它 ubuntu。

00:09:16.937 --> 00:09:20.373
>>-该交互式元素，其中
意味着它立刻开始和

00:09:20.373 --> 00:09:22.380
到你，
在此案例的大扫除。

00:09:22.380 --> 00:09:24.500
>> 我的容器中
在 Bash 稍后再试。

00:09:24.500 --> 00:09:27.290
>> 因此，如果类似的您
在 Windows 计算机上一样，

00:09:27.290 --> 00:09:29.870
您必须设置为内容
自动启动。

00:09:29.870 --> 00:09:32.058
只要计算机
开始，

00:09:32.058 --> 00:09:32.936
[串扰]
>> 您是

00:09:32.936 --> 00:09:33.540
选择您要使用。

00:09:33.540 --> 00:09:36.000
>> 的我们会告诉它什么
若要运行一次，我们跳的过程

00:09:36.000 --> 00:09:36.620
到容器中。

00:09:36.620 --> 00:09:38.560
>>，如果这是
非交互式会话，

00:09:38.560 --> 00:09:39.580
它将一个 web 服务器，

00:09:39.580 --> 00:09:42.510
您将只需要 web 服务器
立刻开始的服务。

00:09:42.510 --> 00:09:43.790
>> 是的和
我们将看到这样的示例。

00:09:43.790 --> 00:09:44.680
>> 好，很好。

00:09:44.680 --> 00:09:47.088
>> 所有权利，因此在这
我打算继续操作的容器并且

00:09:47.088 --> 00:09:48.073
安装一些软件。

00:09:50.678 --> 00:09:53.610
实际上，我将到
更新应用程序 git 就到

00:09:53.610 --> 00:09:57.739
为其指定新列表的引用
和要安装的软件。

00:09:57.739 --> 00:10:00.441
>> 因此，让我们希望它不是一个完整的
在 Linux 上更新生成和

00:10:00.441 --> 00:10:02.633
一切的
完整的操作系统和所有内容。

00:10:02.633 --> 00:10:03.492
>> 它应该是非常快速。

00:10:03.492 --> 00:10:05.512
>> 就了。

00:10:05.512 --> 00:10:06.026
同样，

00:10:06.026 --> 00:10:09.702
完成此操作后，我将
安装的软件。

00:10:09.702 --> 00:10:13.558
到新捕获的关闭
容器的图像，然后什么

00:10:13.558 --> 00:10:17.412
我们将尽时，我们实际上将
在 Ubuntu 图像和

00:10:17.412 --> 00:10:20.890
看看我新的图像，和
什么样的看到它们合并的方式。

00:10:20.890 --> 00:10:22.565
我们会看到
在分层中的重叠。

00:10:22.565 --> 00:10:24.560
然后我们将继续
除此之外，生成和

00:10:24.560 --> 00:10:26.400
我们可能会生成
到该应用程序。

00:10:26.400 --> 00:10:29.060
>> 这些更新您刚完成，
它们还没有更新基。

00:10:29.060 --> 00:10:30.525
>> 号
>> 在更新之后您运行

00:10:30.525 --> 00:10:32.090
以此为基础的实例。

00:10:32.090 --> 00:10:34.120
>> 是，因此这些更新
已写入该从头开始

00:10:34.120 --> 00:10:35.970
空间，这将
然后成为的一部分

00:10:35.970 --> 00:10:37.310
新图像
我们将创建。

00:10:37.310 --> 00:10:39.729
>>，但是，任何人都部署一个新
从基本的容器不会

00:10:39.729 --> 00:10:41.138
获取更新
您所做。

00:10:41.138 --> 00:10:43.030
>> 完全一样。

00:10:43.030 --> 00:10:47.040
因此，apt 获取安装 nano。

00:10:47.040 --> 00:10:49.750
再次，这是刚
另一个文本编辑器。

00:10:49.750 --> 00:10:52.860
没事，这样做的。

00:10:52.860 --> 00:10:56.650
因此，容器内部的
我可以运行 nano。

00:10:56.650 --> 00:10:59.676
因此，我将退出，并且现在我
退出该容器。

00:11:04.571 --> 00:11:08.830
这就是容器的
我们刚刚创建，优雅.柯里。

00:11:08.830 --> 00:11:10.300
>> 很好。

00:11:10.300 --> 00:11:11.360
>> 因此，我将做博士提交。

00:11:11.360 --> 00:11:14.520
>> 应该使用这类型的
方法算出我

00:11:14.520 --> 00:11:17.270
游戏者标记功能
Xbox，我真的竭尽全力。

00:11:17.270 --> 00:11:20.633
>> 所有右博士提交演示。

00:11:23.370 --> 00:11:24.680
同样，
如果我们看一下 Docker 图像

00:11:24.680 --> 00:11:27.480
我们可以看到，我有
一个新的图像演示。

00:11:28.650 --> 00:11:33.200
因此，让我们实际看看
那里在重叠的类型

00:11:33.200 --> 00:11:35.970
之间的基本操作系统映像和
我们刚刚创建的内容。

00:11:35.970 --> 00:11:37.680
因此，我将运行
命令 Docker 历史记录。

00:11:40.230 --> 00:11:47.903
并为其提供的名称
我们刚刚，容器

00:11:47.903 --> 00:11:50.300
或容器图像
我们只被创建。

00:11:50.300 --> 00:11:54.500
和也做相同的事，
运行 Ubuntu。

00:11:54.500 --> 00:11:57.660
因此，可以在此处看到的
Ubuntu 图像组成的

00:11:57.660 --> 00:11:59.360
四层。

00:11:59.360 --> 00:12:03.410
因此，每个它更新的时间，
创建一个新图层和

00:12:03.410 --> 00:12:07.150
是该正式映像
docker 集线器上可用

00:12:07.150 --> 00:12:09.670
组成的注册表
这些四个图像。

00:12:09.670 --> 00:12:10.980
>> 的不
所做的事情。

00:12:10.980 --> 00:12:11.970
>> 的不
我所做的事物。

00:12:11.970 --> 00:12:15.850
所有来自我拉，
从 docker 集线器下图像。

00:12:15.850 --> 00:12:16.640
>> 好了右侧。

00:12:16.640 --> 00:12:19.070
但请注意，

00:12:20.650 --> 00:12:24.690
我刚刚创建演示图像
由五层。

00:12:24.690 --> 00:12:26.980
>> 的权限。
>> 和我们实际上看这里，

00:12:26.980 --> 00:12:30.510
在上面的图层
Ooboontoo 以 498 结束。

00:12:30.510 --> 00:12:34.100
好在第四层
我的映像上。

00:12:34.100 --> 00:12:38.190
因此以 498，
我所做的更改

00:12:38.190 --> 00:12:42.740
表示由
这一层就在这里。

00:12:42.740 --> 00:12:45.300
>> 尽管您是，即使
尽管本质上了

00:12:45.300 --> 00:12:47.900
两个单独的图像，你们
有了您，您已经不仅仅是

00:12:47.900 --> 00:12:49.260
在本质上是
创建的过程。

00:12:49.260 --> 00:12:52.290
>> 使为两个管理它们
单独的图像，完全是。

00:12:52.290 --> 00:12:55.810
和 Docker 引擎
接受治疗的类型的

00:12:55.810 --> 00:12:56.810
>> 缝合所有在一起。

00:12:56.810 --> 00:12:58.190
>> 是，
所有在一起缝合。

00:12:58.190 --> 00:13:00.830
是的我可能只是部署演示，
但

00:13:00.830 --> 00:13:03.650
它将继续和
请确保所有这些

00:13:03.650 --> 00:13:07.110
定位层
其中，他们需要进行。

00:13:07.110 --> 00:13:10.290
这里，实际上您可以看到，
我们实际安装软件

00:13:10.290 --> 00:13:13.670
和我们的图层，也可以查看
该图像的大小

00:13:13.670 --> 00:13:16.070
更改，以及我们将
该软件在那里。

00:13:16.070 --> 00:13:18.490
因此，这是只是什么样的
有关如何演示，

00:13:18.490 --> 00:13:20.810
分层的工作方式，和
您可以使用此窗体

00:13:20.810 --> 00:13:22.728
故障排除和
whatnot 为您。

00:13:22.728 --> 00:13:23.335
>> 看到什么 [串扰]
>> 的更改

00:13:23.335 --> 00:13:24.842
>> 做了过去。

00:13:24.842 --> 00:13:26.500
>> 是，并且您可以
实际上转，我也许想

00:13:26.500 --> 00:13:27.660
>> 容器的启动

00:13:27.660 --> 00:13:30.330
使用中间的一个
只会看到什么样的图像

00:13:30.330 --> 00:13:33.040
该图层看起来像
当运行在容器中。

00:13:33.040 --> 00:13:34.840
>> 它是几乎类似
版本控制。

00:13:34.840 --> 00:13:37.030
>> 绝对。
>> 中的方式是因为您看到它。

00:13:37.030 --> 00:13:39.240
我想念我是否在上
SharePoint 端和

00:13:39.240 --> 00:13:41.330
我所做的更改到一个文档中，
我始终可以返回并

00:13:41.330 --> 00:13:42.830
查找以前。

00:13:42.830 --> 00:13:45.390
只是为了进行更改和操作
我们可以在它更改页面。

00:13:45.390 --> 00:13:46.700
>> 或者破坏我的应用程序，

00:13:46.700 --> 00:13:48.400
也许我想要回到
上一个图像和

00:13:48.400 --> 00:13:49.710
只是种看到什么的
发生在这里。

00:13:49.710 --> 00:13:51.210
>> Yup。
>>，并不仅仅是我的双手在

00:13:51.210 --> 00:13:51.940
因此明确。

00:13:51.940 --> 00:13:53.070
>> 确定，所有权限。

00:13:53.070 --> 00:13:56.085
>> 所有权利，因此，让我们
在展开小技巧。

00:13:56.085 --> 00:13:57.780
> 我们知道多长时间
此列表可能吗？

00:13:58.830 --> 00:13:59.680
有什么。

00:13:59.680 --> 00:14:01.710
>> 我不知道，
我不知道多长时间可以

00:14:01.710 --> 00:14:06.680
但肯定当您进入
此过程生成的图像的

00:14:06.680 --> 00:14:09.380
可以肯定，
没有策略。

00:14:09.380 --> 00:14:12.598
为确保您的图像
是简明，并且没有战略

00:14:12.598 --> 00:14:15.116
用于管理 [串扰]
>> 您不必穿过

00:14:15.116 --> 00:14:16.309
成千上万的历史记录

00:14:16.309 --> 00:14:18.230
每个更改，但-
>> 是，和

00:14:18.230 --> 00:14:20.050
我们将谈一谈一些
这下面一点的位

00:14:20.050 --> 00:14:22.700
有绝对是，我的意思是
没有现成的文章

00:14:22.700 --> 00:14:26.920
关于正确的映像创建和
正确的映像管理。

00:14:26.920 --> 00:14:28.450
的确值得一读。

00:14:28.450 --> 00:14:29.910
>> 好，很好。

00:14:29.910 --> 00:14:34.420
不错，所以我们采取了一个基
我们创建一个新图像，图像，

00:14:34.420 --> 00:14:35.740
安装一些看待它的软件。

00:14:35.740 --> 00:14:38.080
我们详细的
一点儿，

00:14:38.080 --> 00:14:40.350
启动生成
从它的应用程序。

00:14:40.350 --> 00:14:44.932
因此，我将到，
我这里有些文件夹切换

00:15:00.597 --> 00:15:05.564
所以我们接下来要做
将创建一个新映像。

00:15:05.564 --> 00:15:07.906
我们要推动它，
我们刚刚创建的映像和

00:15:07.906 --> 00:15:10.170
我们实际上要放一些
到该 web 服务器软件。

00:15:10.170 --> 00:15:10.740
>> 的权限。

00:15:10.740 --> 00:15:14.800
>> 现在到目前为止我们已经
已手动创建的图像。

00:15:14.800 --> 00:15:17.850
因此，部署该容器，
我跳到它，

00:15:17.850 --> 00:15:19.990
我做了修改，
我离开，

00:15:19.990 --> 00:15:23.130
然后我捕获
它的图像。

00:15:23.130 --> 00:15:24.370
>> 是。

00:15:24.370 --> 00:15:26.990
>> Docker 有一个过程
我们可以使用到

00:15:26.990 --> 00:15:29.150
通过简单的自动化这
称为 docker 文件。

00:15:29.150 --> 00:15:29.710
>> 的权限。

00:15:29.710 --> 00:15:32.200
>> 和 docker
文件实际上我们 jus

00:15:32.200 --> 00:15:33.550
编写这些指令。

00:15:33.550 --> 00:15:34.920
和我们说嗨。

00:15:34.920 --> 00:15:39.560
创建一个容器，这些运行
命令完成后

00:15:39.560 --> 00:15:41.520
捕获的出
到它是自己的图像。

00:15:41.520 --> 00:15:43.150
因此，自动化
方法创建的图像。

00:15:43.150 --> 00:15:45.580
>> 这就像小的背景文件
实际上去做某事。

00:15:45.580 --> 00:15:46.260
>> 差不多。

00:15:46.260 --> 00:15:47.920
>> 好了右侧。
>> 这是一个示例之一，

00:15:47.920 --> 00:15:50.140
您可以看到这
演示中的第一行。

00:15:50.140 --> 00:15:54.480
我要说的是转会我
演示图像，该图像我们

00:15:54.480 --> 00:15:58.960
只需创建并运行所有的
针对这些命令。

00:15:58.960 --> 00:16:02.030
>> 为阐明执行前
您已完成此操作，

00:16:02.030 --> 00:16:02.740
这不是。

00:16:02.740 --> 00:16:03.360
>> 是。

00:16:03.360 --> 00:16:05.470
>> 这不是事情的
已生成基于

00:16:05.470 --> 00:16:07.080
您的环境
到目前为止。

00:16:07.080 --> 00:16:09.840
>> 是，良好称之为刚
我刚出去，生成的文本文件

00:16:09.840 --> 00:16:11.645
在 [INAUDIBLE]
>> 因此，您已经编写了这。

00:16:11.645 --> 00:16:12.400
>> 是。
>> 好，很好。

00:16:12.400 --> 00:16:16.130
是的所以只是一些
元数据维护和

00:16:16.130 --> 00:16:19.050
然后，运行的应用程序获取安装 nginx。

00:16:19.050 --> 00:16:21.900
所以基本上我
说是向上数值调节钮

00:16:21.900 --> 00:16:23.858
从图像演示一个容器。

00:16:23.858 --> 00:16:24.752
>> 毫米 hm。

00:16:24.752 --> 00:16:26.540
>> 安装 nginx。

00:16:26.540 --> 00:16:27.370
>> 检查有任何更新。

00:16:27.370 --> 00:16:29.810
>> 是，实际上我实际上
注释掉出去的。

00:16:29.810 --> 00:16:31.530
>> 是因为回忆的
>> 我们已经做了它。

00:16:31.530 --> 00:16:35.370
>> 我们这样做已经当
我们创建的图像。

00:16:35.370 --> 00:16:38.700
公开端口 80，
设置工作目录，和

00:16:38.700 --> 00:16:43.270
然后设置要运行的命令每个
一个容器，我们开始的时间

00:16:43.270 --> 00:16:44.230
通过该映像。

00:16:44.230 --> 00:16:45.340
所以我并基本上说，嘿，

00:16:45.340 --> 00:16:48.180
当这激发了，
启动引擎 x。

00:16:48.180 --> 00:16:50.494
如果您具有足够的
现在中的注释

00:16:50.494 --> 00:16:53.940
在将降低
向下的速度

00:16:53.940 --> 00:16:56.630
整个图像创建
因为很明显，它已经走了

00:16:56.630 --> 00:16:58.950
通过该大过程
它占不长，但

00:16:58.950 --> 00:17:03.210
它是 30 秒的下载
可能会有更大在将来。

00:17:03.210 --> 00:17:05.840
>> 是，在这种情况下，
它具有实际运行，

00:17:05.840 --> 00:17:08.650
同样，过程和它将有
采取更多一点儿的时间。

00:17:08.650 --> 00:17:10.910
实际上，它不
两个更多的事情也。

00:17:10.910 --> 00:17:14.800
如我们所见，所以为
在 docker 文件中，每一行

00:17:14.800 --> 00:17:17.350
创建链接
为新图像

00:17:17.350 --> 00:17:19.950
每个发生的事物
在医生的文件中。

00:17:19.950 --> 00:17:21.360
>> 好。

00:17:21.360 --> 00:17:23.640
>> 因此，我们将看到一个例子
这里中的第二个。

00:17:23.640 --> 00:17:24.190
>> 很好。好。很好。

00:17:24.190 --> 00:17:26.640
>> 因此，让我退出这。

00:17:26.640 --> 00:17:29.560
同样的而不是
若要创建一个容器，

00:17:29.560 --> 00:17:31.090
手动进行此更改，

00:17:31.090 --> 00:17:35.298
与 docker 文件捕获出
我只是做 docker，

00:17:35.298 --> 00:17:40.290
生成短划线 T，
>> T 是什么意思？

00:17:40.290 --> 00:17:43.080
>> 只允许我
为图像指定名称。

00:17:43.080 --> 00:17:44.400
>> 的权限。
>> 如果我没有给 T，一条短划线

00:17:44.400 --> 00:17:46.520
只是，它将自动
生成的名称或

00:17:46.520 --> 00:17:48.090
我实际上认为它
给它没有名称。

00:17:48.090 --> 00:17:48.590
>> 的权限。

00:17:50.540 --> 00:17:52.870
因此，这将是您的映像名称
您将指定在那里？

00:17:52.870 --> 00:17:54.200
>> 是。

00:17:54.200 --> 00:17:58.320
Demonginx，和
仅有时间段说嗨，

00:17:58.320 --> 00:18:01.060
抓取 docker 文件从
我们正在使用的文件夹。

00:18:01.060 --> 00:18:01.560
>> 是。

00:18:03.637 --> 00:18:05.290
>> 和因此，移交。

00:18:05.290 --> 00:18:06.030
它将继续和

00:18:06.030 --> 00:18:07.980
完成所有工作，我
已手动完成。

00:18:07.980 --> 00:18:10.890
>> 很好。
>>，这一点很重要。

00:18:10.890 --> 00:18:13.490
这使得我们，
当我们想到的事情

00:18:13.490 --> 00:18:15.630
语句如下所示
基础结构即代码中，

00:18:15.630 --> 00:18:17.900
我的意思是这就是我们
有呢。

00:18:17.900 --> 00:18:21.960
因此，如果我想要像重建
此特定的图像

00:18:21.960 --> 00:18:26.350
节奏，您知道，而不是
手动执行所有这些工作，

00:18:26.350 --> 00:18:31.160
我把这段代码定义
我的映像中的内容，

00:18:31.160 --> 00:18:32.700
我可以只重新运行此。

00:18:32.700 --> 00:18:34.320
>>，它是一致的。

00:18:34.320 --> 00:18:35.847
>> 它是一致的
[串扰] 是的好。

00:18:35.847 --> 00:18:38.631
因此它是完成的。

00:18:38.631 --> 00:18:43.210
现在，如果我做 docker 图像

00:18:43.210 --> 00:18:47.290
我可以在这里看到的我现在
具有此图像 demonginx。

00:18:47.290 --> 00:18:48.330
因此让我们来看看的
>> 因此

00:18:48.330 --> 00:18:50.000
它的大小增加的什么？

00:18:50.000 --> 00:18:51.550
我们采取 18 兆。

00:18:51.550 --> 00:18:52.637
>> 是。
>>，这将是

00:18:52.637 --> 00:18:55.812
实质上的大小
在多数情况下的最终遗传科。

00:19:03.654 --> 00:19:04.490
是的就可以了。

00:19:04.490 --> 00:19:05.830
因此，最终遗传 18 兆。

00:19:05.830 --> 00:19:07.180
>> 是。

00:19:07.180 --> 00:19:10.290
>> 其余的更改
这是您。

00:19:10.290 --> 00:19:11.030
防火墙和

00:19:11.030 --> 00:19:14.390
您将工作，直到其读
在命令提示符下，则为零。

00:19:14.390 --> 00:19:19.040
您可以在这里看到，这样，我们
这源于具有演示

00:19:19.040 --> 00:19:22.820
五层，而不是添加
另一层则添加

00:19:22.820 --> 00:19:25.850
安静的几个图层，您可以
实际上看其中的每一个

00:19:25.850 --> 00:19:31.750
图层包含的步骤，
我们在 dockerfile 中运行。

00:19:31.750 --> 00:19:36.590
因此，我们讨论了战略
围绕创建映像。

00:19:36.590 --> 00:19:38.210
还有两件事
请转到此，

00:19:38.210 --> 00:19:40.410
想要观看您
投入您的 dockerfile。

00:19:40.410 --> 00:19:41.540
>> 是。
>> 还有一些

00:19:41.540 --> 00:19:45.110
我们还可以做为什么样的技巧
>> 使

00:19:45.110 --> 00:19:46.450
较小的层数。

00:19:46.450 --> 00:19:49.220
>> 是，如果您有
一个非常复杂的容器，或

00:19:49.220 --> 00:19:52.160
非常复杂
要求您

00:19:52.160 --> 00:19:54.040
将通道
docker 文件中。

00:19:54.040 --> 00:19:57.770
这可能是很大的列表，
当您运行该命令。

00:19:57.770 --> 00:19:59.403
>> 是，看看这。

00:19:59.403 --> 00:20:01.214
因此，我要做。

00:20:09.324 --> 00:20:11.531
因此我想到了另一个
这里 docker 文件。

00:20:11.531 --> 00:20:13.730
所以我们创建一个容器，
我们将 EngineX 放在它。

00:20:13.730 --> 00:20:19.060
让我们再进一步
并且除了，嗯，

00:20:19.060 --> 00:20:21.750
我们将使用该容器的
包含 web 软件，但

00:20:21.750 --> 00:20:24.000
让我们继续操作并
放置到该应用程序。

00:20:24.000 --> 00:20:27.230
然后我们将运行
应用程序和移动它。

00:20:27.230 --> 00:20:27.930
一件事，

00:20:27.930 --> 00:20:31.030
看一看此 Docker
文件，我已经如此，

00:20:31.030 --> 00:20:35.480
我实际上安装几个
与此 Docker 文件的事情。

00:20:35.480 --> 00:20:38.500
因此我正在运行的应用程序获取更新。

00:20:38.500 --> 00:20:43.430
然后安装 git
在曲线中称为纳米，程序。

00:20:44.870 --> 00:20:49.930
基本上就是此处本斜杠
回车符。

00:20:49.930 --> 00:20:50.470
>> 是。
>> 但

00:20:50.470 --> 00:20:53.490
实质上这一条命令。

00:20:53.490 --> 00:20:55.330
>> 的权限。
>>，在一个命令中，

00:20:55.330 --> 00:20:57.580
我正在安装所有
此软件。

00:20:57.580 --> 00:21:00.260
而不是
单个的命令

00:21:00.260 --> 00:21:01.120
分别安装。

00:21:01.120 --> 00:21:04.303
因此，您可以在这里看到是
例如，我最小化

00:21:04.303 --> 00:21:06.436
图层的数量
该 [串扰]

00:21:06.436 --> 00:21:07.477
>> 不是会有四个

00:21:07.477 --> 00:21:08.470
在该列表中的条目。

00:21:08.470 --> 00:21:09.680
它只会是一个条目。

00:21:09.680 --> 00:21:10.310
>> 完全一样。
>> 好。

00:21:10.310 --> 00:21:11.580
我看到。
>> 因此，小技巧如下所示

00:21:11.580 --> 00:21:14.210
这种保持到
关闭图层。

00:21:14.210 --> 00:21:15.040
>> 的权限。

00:21:15.040 --> 00:21:16.650
因此，让我继续，
请将此项。

00:21:16.650 --> 00:21:20.570
实际上，让我们看看
在这再次真正快速，

00:21:20.570 --> 00:21:22.090
找几
我正在做的事情。

00:21:22.090 --> 00:21:24.690
因此不仅我
在这里，安装软件

00:21:24.690 --> 00:21:28.010
我正在做一些，
少量的配置

00:21:28.010 --> 00:21:31.840
与 web 服务器软件
位于容器，

00:21:31.840 --> 00:21:34.250
但是也请注意
我运行 get 克隆。

00:21:35.260 --> 00:21:38.540
我实际上正在克隆
应用程序从 GitHub

00:21:38.540 --> 00:21:41.000
到容器
在生成时。

00:21:41.000 --> 00:21:43.820
因此要安装一些
软件，交往，

00:21:43.820 --> 00:21:48.350
获取一些静态文件的
基本上是一个网站我们

00:21:48.350 --> 00:21:51.622
将请参见-
>> [听不到]

00:21:51.622 --> 00:21:54.471
它为 web 服务器。

00:21:54.471 --> 00:21:57.228
>> 是的完全相同。

00:21:59.500 --> 00:22:02.300
和我实际上打算放
对此一些元数据。

00:22:06.103 --> 00:22:11.310
他是浪费金钱和，和
我将把此图像 c9app。

00:22:13.040 --> 00:22:13.580
并生成它。

00:22:15.040 --> 00:22:17.330
和什么此李瑞是浪费金钱和
does 还有，

00:22:17.330 --> 00:22:19.010
我已经有一个帐户
在 Docker 集线器。

00:22:19.010 --> 00:22:19.590
>> 的权限。
>> 和

00:22:19.590 --> 00:22:21.800
只是基本上是一个键值。

00:22:21.800 --> 00:22:25.030
当我去推这会

00:22:25.030 --> 00:22:26.800
推此图像的
>> 为您的

00:22:26.800 --> 00:22:28.220
>> 到我的帐户 Docker 集线器中。

00:22:28.220 --> 00:22:29.120
>> 这是可以理解。

00:22:29.120 --> 00:22:31.520
>> 如果能，那么它会通过，
编制所有，或

00:22:31.520 --> 00:22:33.160
它将安装软件。

00:22:33.160 --> 00:22:34.980
要走出去，到 Git0Hub。

00:22:34.980 --> 00:22:36.960
获取应用程序中，

00:22:36.960 --> 00:22:39.980
将它带到容器
图像，然后我们会有这

00:22:39.980 --> 00:22:42.010
容器的图像的
由多层组成。

00:22:42.010 --> 00:22:46.010
我们开始使用 boonton 基
os，然后我们安装 web

00:22:46.010 --> 00:22:49.540
现在，我们的服务器软件
安装应用程序。

00:22:49.540 --> 00:22:51.130
完成后，
我们将部署

00:22:51.130 --> 00:22:54.170
我们首先要看一看
现在网络段。

00:22:54.170 --> 00:22:57.920
因此，我们已经有点了解
这里在图像分层。

00:22:57.920 --> 00:23:00.030
我们首先要谈
这些网络的部分和

00:23:00.030 --> 00:23:03.220
如果我愿意，也许有
在这几个实例

00:23:03.220 --> 00:23:07.660
同一台主机，我该怎么办
外部、 内部端口映射。

00:23:07.660 --> 00:23:09.910
这样我可以访问它。

00:23:09.910 --> 00:23:13.490
因此，我们正在执行此操作，

00:23:13.490 --> 00:23:18.590
让我们多做医生的图像和
就是这样。

00:23:18.590 --> 00:23:21.812
所以是我的通道九个应用程序。

00:23:24.103 --> 00:23:27.010
这样，已准备好与
让我们继续操作并运行它。

00:23:27.010 --> 00:23:28.410
因此，我将做 Docker 运行

00:23:29.500 --> 00:23:33.400
到目前为止我们已经
已运行短线 t 和

00:23:33.400 --> 00:23:37.200
跳转右内我们种类
打开的内部会话

00:23:37.200 --> 00:23:39.290
我们可以在其中我们容器
与文件系统进行交互。

00:23:39.290 --> 00:23:41.860
我想要做不同的事情
这里和其中运行 d 一条短划线

00:23:41.860 --> 00:23:44.140
主要运行容器
在后台。

00:23:44.140 --> 00:23:48.190
>> 确定，与任何默认值
已配置设置。

00:23:48.190 --> 00:23:49.530
>> Yup，完全相同。

00:23:49.530 --> 00:23:54.740
所有权利因此
文档可以运行 d 划线和

00:23:54.740 --> 00:23:58.310
我会抓住我们容器的图像，
然后 bam。

00:24:00.520 --> 00:24:04.790
如果已安装文档或 ps，我们可以看到
这是我正在运行的容器

00:24:04.790 --> 00:24:07.720
doc 或 ps 将再次和
显示所有正在运行的容器

00:24:07.720 --> 00:24:11.210
Docker PS A 划线所示
所有运行的容器或

00:24:11.210 --> 00:24:13.290
它是最佳的名因此已停止
到目前为止也。

00:24:13.290 --> 00:24:15.730
我们得到什么这里。

00:24:15.730 --> 00:24:16.586
Kickass 的灰色。

00:24:16.586 --> 00:24:17.718
>> 很好。

00:24:24.811 --> 00:24:28.010
>> 人采取
IP 地址

00:24:28.010 --> 00:24:29.100
>> 容器的主机。

00:24:30.230 --> 00:24:31.770
将其放在此处。

00:24:31.770 --> 00:24:33.560
但是，请注意，
没有任何反应。

00:24:33.560 --> 00:24:34.460
它找不到任何东西。

00:24:34.460 --> 00:24:36.260
因此我特意留
东西有，

00:24:36.260 --> 00:24:37.690
这是该网络的一部分。

00:24:37.690 --> 00:24:38.270
>> 的权限。
>> 因此

00:24:38.270 --> 00:24:41.610
我所碰到的外部 IP
容器主机地址

00:24:41.610 --> 00:24:44.510
但我确实曾赋予
它没有说明

00:24:44.510 --> 00:24:47.640
如何将该请求传递
到该容器中。

00:24:49.970 --> 00:24:51.990
因此，为了做到这一点。

00:24:51.990 --> 00:24:54.420
我们可以添加一个附加
这里拼凑它是第一条短划线

00:24:54.420 --> 00:24:58.190
并比较定义
某些端口映射的集合。

00:24:58.190 --> 00:25:02.930
对于这第一次运行，我将到
在容器中的 80 端口映射

00:25:02.930 --> 00:25:05.840
主机端口 80 的
容器本身。

00:25:05.840 --> 00:25:12.620
所以 80、 80 基本上
相同的命令 docker 运行，

00:25:12.620 --> 00:25:17.910
空间划线 D 空间划线 P，80 80
然后图像和名称。

00:25:19.090 --> 00:25:24.710
所以这样做，
现在，我应该有我的应用程序。

00:25:24.710 --> 00:25:25.260
>> 就可以了。

00:25:25.260 --> 00:25:27.530
我将它拉
从 GitHub 也。

00:25:27.530 --> 00:25:29.380
>> 是，那么应用程序
同样来自 GitHub。

00:25:29.380 --> 00:25:30.560
>> 很好。

00:25:30.560 --> 00:25:35.140
没事，那么，现在，
我们可以看到此映射在此处。

00:25:35.140 --> 00:25:38.060
快速是显而易见的但

00:25:38.060 --> 00:25:40.810
我表示我已经有一个
在主机上的端口 80。

00:25:40.810 --> 00:25:41.370
>> 是。
>> 让我们

00:25:41.370 --> 00:25:45.580
说我想要运行 300 种
在我的容器内部的事情。

00:25:45.580 --> 00:25:47.190
也许这是一种服务。

00:25:47.190 --> 00:25:48.240
我要销售。

00:25:48.240 --> 00:25:50.600
登录时，
购买一种服务，并

00:25:50.600 --> 00:25:52.410
我所做的所有旋转
向上一个容器，但

00:25:52.410 --> 00:25:56.420
我有一堆的和
如何将更多的端口映射？

00:25:56.420 --> 00:25:57.300
>> 是。

00:25:57.300 --> 00:25:59.880
>> 因此，我只将运行
完全相同的命令，但

00:25:59.880 --> 00:26:01.920
这一次我将映射
81 到 80 端口

00:26:01.920 --> 00:26:05.060
也许我们只是运行此
两个不同的时间。

00:26:06.110 --> 00:26:07.900
这样，82。

00:26:07.900 --> 00:26:12.890
所以我要说的是，端口 83
在我的主机上映射到端口 80 上

00:26:12.890 --> 00:26:16.140
此新实例
我运行的容器。

00:26:16.140 --> 00:26:19.590
我只是将执行、 端口 81。

00:26:19.590 --> 00:26:24.070
最好能够有一个随机
和

00:26:24.070 --> 00:26:29.150
然后我做 85 因此现在，
如果我们运行 docker ps，我们可以看到

00:26:29.150 --> 00:26:32.940
我有一整套的这些
现在在我的主机上运行的东西。

00:26:32.940 --> 00:26:36.100
>>，很有创意的容器
也给他们自由。

00:26:36.100 --> 00:26:36.710
>> 是，因此

00:26:36.710 --> 00:26:40.020
我使用了单个容器，
因此我想到了多个实例

00:26:40.020 --> 00:26:42.710
运行该容器图像的
运行该应用程序。

00:26:42.710 --> 00:26:43.290
>> 是。
>> 和

00:26:43.290 --> 00:26:49.145
我把所有的端口映射
>>，现在，让我。

00:26:53.936 --> 00:26:55.895
再次抓住我的 IP 地址。

00:27:04.770 --> 00:27:09.616
因此，如果喜欢端口有的 81
应用程序端口 83，有

00:27:09.616 --> 00:27:14.209
只需要该应用程序，和我
抓住一个我们没有设置，

00:27:14.209 --> 00:27:18.580
87，而且它不仅仅旋转它，
找不到任何东西。

00:27:18.580 --> 00:27:19.510
>> 是，很好。

00:27:19.510 --> 00:27:28.510
>> 对，正是这样，因此
我们已经看过图像分层

00:27:28.510 --> 00:27:31.950
我们已经看过端口映射
现在让我们来此的整圆

00:27:31.950 --> 00:27:36.140
并采取此图像
>> 将其 docker 集线器中。

00:27:36.140 --> 00:27:36.710
>> 是。
>> 和

00:27:36.710 --> 00:27:40.250
然后我们会将其拉
运行 Linux 的 Azure 虚拟机，

00:27:40.250 --> 00:27:43.420
只是到 docker 引擎
看到一些可移植性。

00:27:44.550 --> 00:27:45.230
>> 很好。

00:27:45.230 --> 00:27:49.150
>> 所有权利、 docker 图像，因此

00:27:49.150 --> 00:27:52.140
这里是这样
我想要向上引发。

00:27:53.280 --> 00:27:59.350
所以我做 docker 推
>> 和我的映像名称。

00:28:02.610 --> 00:28:03.730
并且，被上传而

00:28:14.436 --> 00:28:15.910
看到这里我 Docker 集线器。

00:28:15.910 --> 00:28:19.190
我有几个我个人
这里已经定位的图像。

00:28:19.190 --> 00:28:20.380
>> 是。
>> 和中

00:28:20.380 --> 00:28:23.390
我们应该只是一点儿
请参阅此新的映像。

00:28:23.390 --> 00:28:26.470
>> 是其本质上，将
它知道，您的依赖性

00:28:26.470 --> 00:28:28.310
可能已经存在吗？

00:28:28.310 --> 00:28:29.130
您希望
>> 是是的没错。

00:28:29.130 --> 00:28:30.600
>>，因此它
不需要按下

00:28:30.600 --> 00:28:32.660
全部金额每次时，或
>> 是的完全相同。

00:28:32.660 --> 00:28:34.050
因此 Docker 比较负责，

00:28:34.050 --> 00:28:36.965
再次，管理那些图的层
我们。

00:28:36.965 --> 00:28:37.680
>> 毫米 hm。

00:28:37.680 --> 00:28:41.460
好了，原因是您使用了 286
兆，但我假设，但是

00:28:41.460 --> 00:28:43.290
根据的大小
当前的图像。

00:28:43.290 --> 00:28:46.160
但我假设，大部分
如果不是大多数

00:28:46.160 --> 00:28:47.480
将已存在。

00:28:47.480 --> 00:28:48.680
>> 是的完全相同。

00:28:48.680 --> 00:28:52.480
并按相反的顺序，如果我有
主机有没有图像

00:28:52.480 --> 00:28:54.430
然后我拉我们 C9 的应用程序。

00:28:54.430 --> 00:28:57.560
>> 知道，它将像说
嘿包括在这其中有

00:28:57.560 --> 00:28:59.560
在依赖项
Ubuntu 的图像。

00:28:59.560 --> 00:29:00.800
让我们向下拉，同样，
和

00:29:00.800 --> 00:29:04.480
它实际上将拉下所有
关联的图像或

00:29:04.480 --> 00:29:07.150
所有的参考图像
基于图像的

00:29:07.150 --> 00:29:08.160
您正在将关闭。

00:29:08.160 --> 00:29:11.865
>>，您需要有
要注册的特殊帐户

00:29:11.865 --> 00:29:13.130
任何人都可以注册医生集线器？

00:29:13.130 --> 00:29:15.530
>> 是，您可以转到灾难恢复。
中心和注册。

00:29:15.530 --> 00:29:17.790
>> 好了，并且还没有任何
>> 500 兆玩，

00:29:17.790 --> 00:29:19.680
有您有无限的量吗？

00:29:19.680 --> 00:29:21.630
>> 我不敢肯定
这些详细信息。

00:29:21.630 --> 00:29:23.640
>> 好了，我敢肯定您可以检查。

00:29:23.640 --> 00:29:25.850
>> 是，但
此外 docker 也，

00:29:25.850 --> 00:29:28.730
但它们也有软件
创建专用的集线器也。

00:29:28.730 --> 00:29:29.960
>> 企业权利。

00:29:29.960 --> 00:29:32.790
>> 我们正在处理与右什么
这里是比较公共面向

00:29:32.790 --> 00:29:35.230
但您可以创建自己的
以及专用存储库。

00:29:35.230 --> 00:29:36.390
>> 将任何人，因此，

00:29:36.390 --> 00:29:38.380
能够进入
在这里您的应用程序？

00:29:38.380 --> 00:29:39.780
>> 现在，是的绝对。

00:29:39.780 --> 00:29:40.620
>> 好，不够公平。

00:29:40.620 --> 00:29:43.290
因此，您可以创建
您自己专用的一个？

00:29:43.290 --> 00:29:44.120
>> 是。

00:29:44.120 --> 00:29:44.730
>> 好，很好。

00:29:46.020 --> 00:29:47.630
>> 所有正确，因此我们就大功告成。

00:29:47.630 --> 00:29:49.010
如果转到 Docker 中心和

00:29:49.010 --> 00:29:53.310
刷新，
它没有就在这里。

00:29:53.310 --> 00:29:55.546
>> 是，很好。

00:29:55.546 --> 00:30:01.011
所以我要做现在，
我使用了 Linux 虚拟机

00:30:01.011 --> 00:30:06.753
在 Azure 中运行，
Docker 配置它。

00:30:06.753 --> 00:30:09.548
因此我只是创建
在该 VM 会话。

00:30:16.868 --> 00:30:19.262
这运行在 Microsoft
这不是相同的在运行

00:30:19.262 --> 00:30:20.984
这不是在同一个 VM
运行您

00:30:20.984 --> 00:30:21.740
膝前。

00:30:21.740 --> 00:30:22.280
>> 完全一样。

00:30:22.280 --> 00:30:24.108
>> 没关系，让我们来吧，
看看它。

00:30:36.283 --> 00:30:41.410
堆的 Azure 中的功能
在医生和容器。

00:30:41.410 --> 00:30:43.980
肯定是我们可以更深入地介绍
为在未来视频是因为存在

00:30:43.980 --> 00:30:46.360
是只是大量的
在这里的功能的大量。

00:30:47.410 --> 00:30:51.230
因此，如果我们看一看资源和
组和 TWODocker，

00:30:53.480 --> 00:30:56.830
我基本上是在有资源
组，其中包含虚拟机，

00:30:56.830 --> 00:31:00.379
对开的公用 IP 地址
[听不到] whatnot，它是。

00:31:00.379 --> 00:31:02.785
>> 好。
>> 完全配置了 Docker

00:31:02.785 --> 00:31:04.060
然后，我们会回来的。

00:31:04.060 --> 00:31:07.340
因此，如果我 docker ps-a，

00:31:07.340 --> 00:31:10.390
您可以看到，这里有没有
在此主机上运行的容器。

00:31:10.390 --> 00:31:15.310
如果我这样做我们可以 docker 图像
看到，我有没有 docker

00:31:15.310 --> 00:31:16.380
图像，这里也。

00:31:18.540 --> 00:31:20.270
我做 docker 搜索应用程序。

00:31:20.270 --> 00:31:24.720
好吧，这样，您可以看到

00:31:24.720 --> 00:31:29.540
从 docker 中心找到它
我们的应用程序创建的因此

00:31:29.540 --> 00:31:33.480
我做 docker 运行-d-p。

00:31:33.480 --> 00:31:36.160
同样，我想要映射端口。

00:31:36.160 --> 00:31:38.190
>> 因此，你不将做我
需要再拉这

00:31:38.190 --> 00:31:39.940
创建一个容器，你只是
要做一个快照中的全部吗？

00:31:39.940 --> 00:31:40.440
>> 是的完全相同。

00:31:40.440 --> 00:31:44.330
因此我无法运行 docker 池和
比较阶段，但如果我做

00:31:44.330 --> 00:31:48.300
运行 docker 和图像
尚未在主机上，分阶段

00:31:48.300 --> 00:31:49.470
它将建立亲密关系，
我拉。

00:31:49.470 --> 00:31:50.388
>> 很好，好，好。

00:31:52.524 --> 00:31:55.107
您需要为您自己
回顾在以后也，

00:31:55.107 --> 00:31:56.801
您需要在一个星
那里至少。

00:31:56.801 --> 00:31:58.577
>> [发笑]
>> 的 C9 app，如果能，

00:31:58.577 --> 00:31:59.317
绝对。

00:31:59.317 --> 00:32:00.723
>> 就在这里，您可以看到

00:32:00.723 --> 00:32:02.721
找不到
本地图像。

00:32:02.721 --> 00:32:03.350
>> 毫米 hm。
>> 因此

00:32:03.350 --> 00:32:04.160
要走出去，并将其拉出。

00:32:04.160 --> 00:32:07.431
您可以看到它拉
多个不同的层

00:32:07.431 --> 00:32:10.895
并且那将会不只
我们创建的容器图像

00:32:10.895 --> 00:32:13.862
该便携式计算机-[串扰]，但
所有依赖项。

00:32:13.862 --> 00:32:15.686
虽然这被拉下，

00:32:15.686 --> 00:32:19.334
两件事要动员
特定于 Azure 因为我

00:32:19.334 --> 00:32:22.526
映射端口 80 到 80
我将需要

00:32:22.526 --> 00:32:25.280
Azure 配置为
接受该通信流。

00:32:25.280 --> 00:32:27.420
>> 是的所以您需要结束
为虚拟机配置点。

00:32:27.420 --> 00:32:28.150
>> 是，是。
所以我

00:32:28.150 --> 00:32:31.340
有了网络安全
配置组。

00:32:31.340 --> 00:32:35.840
在与一些 Azure 中
入站规则因此

00:32:35.840 --> 00:32:37.650
我们已经有了 80 右
那里的将起作用。

00:32:37.650 --> 00:32:40.640
我们还没有了解的一件事
在就此运行时

00:32:40.640 --> 00:32:44.230
Windows 服务器容器
管理那些 Docker。

00:32:44.230 --> 00:32:48.490
我的意思是，我们已经看到大部分
这里正是如何像

00:32:48.490 --> 00:32:50.580
使用 Windows 服务器
同样的容器。

00:32:50.580 --> 00:32:53.210
>> 和几个其他
该频道的视频实际上

00:32:53.210 --> 00:32:54.070
不要显示的。

00:32:54.070 --> 00:32:55.480
>> 是。
>> 和任何人都是受监视的人

00:32:55.480 --> 00:32:57.750
那些和
这些命令，请看

00:32:57.750 --> 00:32:59.560
它们几乎完全相同，
如果不完全相同。

00:32:59.560 --> 00:33:00.160
>> 实际上是相同的

00:33:00.160 --> 00:33:03.290
是的一直下到
如何使用 docker 文件。

00:33:03.290 --> 00:33:04.580
>> 是。
>> 所有权利，因此

00:33:04.580 --> 00:33:05.570
程序已经完成这样

00:33:05.570 --> 00:33:07.810
如果我做 docker ps
>> 因此

00:33:07.810 --> 00:33:10.030
该图像是现在
在 Azure 的 VM。

00:33:10.030 --> 00:33:12.860
因此，它从拉
Docker 集线器到 Azure 内您

00:33:12.860 --> 00:33:15.880
虚拟机和容器都有
已创建的。

00:33:15.880 --> 00:33:17.700
>> 已创建的它，
它正在运行。

00:33:17.700 --> 00:33:19.270
>> 的权限。
>> 是现在，如果我需要的

00:33:19.270 --> 00:33:20.055
>> 真相大白的时刻。

00:33:20.055 --> 00:33:22.060
>> [笑声] 的 IP 地址

00:33:22.060 --> 00:33:25.520
公共 IP 地址
我 Azure 的 VM。

00:33:25.520 --> 00:33:26.570
将其放在那里。

00:33:26.570 --> 00:33:28.340
我必须映射到端口 80 的端口 80。

00:33:28.340 --> 00:33:29.030
>> 繁荣。

00:33:29.030 --> 00:33:31.490
>> 并没有我的应用程序
在 Azure 中运行这样。

00:33:31.490 --> 00:33:32.840
>> 很好。
那么它是现在超大规模呢？

00:33:32.840 --> 00:33:34.306
>> 是几乎是。

00:33:34.306 --> 00:33:37.716
[笑声]这样整圆的我们，
生成应用程序

00:33:37.716 --> 00:33:41.057
[串扰] 我的便携式计算机上
将其推到 Docker 集线器。

00:33:41.057 --> 00:33:43.590
抽取的到 Azure。

00:33:43.590 --> 00:33:47.760
在这样做时我们看一些
网络端口映射。

00:33:47.760 --> 00:33:49.460
>> 是。
>> 我们已经在时有的那些

00:33:49.460 --> 00:33:52.810
net 和我们已经种类的
看这些图像是如何工作的

00:33:52.810 --> 00:33:54.250
当上分层
彼此的顶部。

00:33:54.250 --> 00:33:54.750
>> 超。

00:33:58.760 --> 00:34:01.300
我想您会同意，
作为从端到端它演示

00:34:01.300 --> 00:34:03.300
没有得到很多
比这更好。

00:34:03.300 --> 00:34:04.630
您生成应用程序。

00:34:05.670 --> 00:34:08.850
将它移到它所在的位置
可访问的所有，

00:34:08.850 --> 00:34:11.710
让我们假设 Y 开发
团队，可以完成它

00:34:11.710 --> 00:34:14.470
对其计算机，是否他们
便携式计算机或工作站上或

00:34:14.470 --> 00:34:17.520
数据中心服务器，或
在公有云中最多。

00:34:17.520 --> 00:34:19.480
我的意思是，即，
很不错的东西。

00:34:19.480 --> 00:34:22.340
如果您想要了解更多
保持调到通道

00:34:22.340 --> 00:34:24.680
因为在将来我们将的视频
能进入相等程度

00:34:24.680 --> 00:34:28.270
在一些其他领域的深度
在 Windows 7 的容器上，

00:34:28.270 --> 00:34:31.290
在 Lenox 平台上，
作为容器服务，

00:34:31.290 --> 00:34:33.710
一整个主机的资料
我们将不同的方向

00:34:33.710 --> 00:34:35.320
将，所以请继续关注。

00:34:35.320 --> 00:34:36.800
但数
建议使用的资源，

00:34:36.800 --> 00:34:37.780
请确保您可以签出和

00:34:37.780 --> 00:34:40.140
下载最新的 Windows
7 技术预览。

00:34:40.140 --> 00:34:40.770
尝试此操作。

00:34:40.770 --> 00:34:43.520
显然，您可以使用 Linux
如果您想要按照 [音频]

00:34:43.520 --> 00:34:46.120
李瑞传递，演示
您可以遵循，

00:34:46.120 --> 00:34:48.770
类似对执行的操作
帮助您学习。

00:34:48.770 --> 00:34:52.790
签出 Docker 资源
在中的 Docker.com\Microsoft

00:34:52.790 --> 00:34:58.700
Docker 文档网站，
Docker.com\Windows\started。

00:34:58.700 --> 00:35:00.835
并签出容器
有关文档

00:35:00.835 --> 00:35:03.800
msdn.microsoft.com 和
在 Github。

00:35:03.800 --> 00:35:05.830
并且，却没有更多
可以说，感谢他如此

00:35:05.830 --> 00:35:07.780
到目前为止为该系列的帮助。

00:35:07.780 --> 00:35:08.340
>> 非常感谢。

00:35:08.340 --> 00:35:10.147
>>，我们会看到您再次上
另一种容器渠道

00:35:10.147 --> 00:35:10.897
节目，谢谢您。

00:35:10.897 --> 00:35:20.897
[音乐]