WEBVTT

00:00:00.000 --> 00:00:08.198
[音乐]

00:00:08.198 --> 00:00:09.947
你好，
欢迎使用我们为另一节目上

00:00:09.947 --> 00:00:11.430
容器的通道。

00:00:11.430 --> 00:00:13.160
我是 Matt McSpirit
技术推广人员的

00:00:13.160 --> 00:00:14.590
所有的数据
中心的技术。

00:00:14.590 --> 00:00:17.120
并在此段内有
真正的开始

00:00:17.120 --> 00:00:20.130
其中我们迷你系列
要探讨容器

00:00:20.130 --> 00:00:21.450
基础知识。

00:00:21.450 --> 00:00:23.490
那些已经监视
一些已经上的视频

00:00:23.490 --> 00:00:24.380
容器的通道，

00:00:24.380 --> 00:00:27.000
您就会知道我们已经有了很多
很酷的东西的演示。

00:00:27.000 --> 00:00:29.960
我们引入并有面试
Docker 人。

00:00:29.960 --> 00:00:33.180
我们会见约翰霍华德和
探讨了他的贡献

00:00:33.180 --> 00:00:35.860
Docker 也，因此
我们已经介绍的负载

00:00:35.860 --> 00:00:38.700
东西，但我们想要确保
我们给予您深度

00:00:38.700 --> 00:00:41.030
了解我们
同样的容器。

00:00:41.030 --> 00:00:44.350
并帮助我今天做的
我由李瑞是浪费金钱和在一起。

00:00:44.350 --> 00:00:45.770
李瑞，做一下自我介绍，

00:00:45.770 --> 00:00:48.850
请告诉我们一点关于您
与容器连接。

00:00:48.850 --> 00:00:50.210
>> 好用，谢谢 Matt。

00:00:50.210 --> 00:00:51.400
因此，我的名字的李瑞是浪费金钱和，

00:00:51.400 --> 00:00:54.600
我的内容开发
Microsoft 在这里。

00:00:54.600 --> 00:00:57.280
这样，实际上我所做
与容器是书写

00:00:57.280 --> 00:01:00.160
继续文档
我们的实现与

00:01:00.160 --> 00:01:02.340
将窗口的容器
服务器容器和

00:01:02.340 --> 00:01:04.270
即将到来的超 B 容器。

00:01:04.270 --> 00:01:07.100
因此，我正在与我们
可视化项团队，和

00:01:07.100 --> 00:01:08.600
乔和泰勒。

00:01:08.600 --> 00:01:11.900
记录的容器的类型
并作为它的一部分播放

00:01:11.900 --> 00:01:15.020
周围和进行信息检索
在技术上我自己。

00:01:15.020 --> 00:01:16.870
>> 它是所有非常
对于我们中的很多新。

00:01:16.870 --> 00:01:18.410
很多我们的 IT
作为专业人员也这样

00:01:18.410 --> 00:01:20.080
文档
是至关重要的

00:01:20.080 --> 00:01:23.050
本文档处理程序
我们此次采取

00:01:23.050 --> 00:01:26.390
将它放在 MSDM 上的容器
但人们也发现了访问

00:01:26.390 --> 00:01:28.560
它通过 [INAUDIBLE]
这就是大。

00:01:28.560 --> 00:01:30.950
更改
我们 << 是绝对我的意思是，

00:01:30.950 --> 00:01:34.970
我们将我们的文档
在 GitHub，

00:01:34.970 --> 00:01:38.600
社区可以参与到它，
请给它和真正的更新

00:01:38.600 --> 00:01:43.180
窗口的容器就 nad
我们在技术预览，但

00:01:43.180 --> 00:01:46.350
我们正在记录
它们很大，因此

00:01:46.350 --> 00:01:48.870
我们将大量的东西
很快缩小。

00:01:48.870 --> 00:01:51.000
>>，如果您未选中
出的文档，

00:01:51.000 --> 00:01:54.140
它是 MSDN 点 Microsoft.com，
如果您想要向 MSDN 下走

00:01:54.140 --> 00:01:56.330
根，正斜杠
虚拟化和

00:01:56.330 --> 00:01:58.570
这样，就会到
登录页的容器。

00:01:58.570 --> 00:02:00.840
并没有大量的
不同的方案，我们

00:02:00.840 --> 00:02:04.820
技术预览记录
三，各地获取您

00:02:04.820 --> 00:02:08.320
部署的容器主机已准备好，
容器与 PowerShare，或

00:02:08.320 --> 00:02:10.920
使用 Docker 管理它们，
因此，和 Azure 也上。

00:02:10.920 --> 00:02:13.210
因此，如果您还没有，
签出文档，

00:02:13.210 --> 00:02:15.920
跟着，并同时查看
视频因为它们将引导

00:02:15.920 --> 00:02:18.220
您通过为好，
您可以直观地看到它。

00:02:18.220 --> 00:02:21.380
但如今，正如我所说的
是的迷你系列开始。

00:02:21.380 --> 00:02:22.730
我们不知道多少
我们要不要，剧集

00:02:22.730 --> 00:02:24.460
我们只需转到
让他们在 ya。

00:02:24.460 --> 00:02:25.980
为了帮助您理解和

00:02:25.980 --> 00:02:28.950
抓住一个位在基础知识
更多技术层面。

00:02:28.950 --> 00:02:31.400
但经历了许多帮助您
同时演示。

00:02:31.400 --> 00:02:34.710
因此，李瑞的被繁忙的建筑物
若要启用，以显示这些系统

00:02:34.710 --> 00:02:37.610
您一些实质上是如何的
资料工作有点更有深度。

00:02:37.610 --> 00:02:39.930
我们只是第一个
转会先了解一下

00:02:39.930 --> 00:02:42.800
其实关于简介
只是什么容器是，

00:02:42.800 --> 00:02:45.840
接下来从某些级别下移
我们在过去所做的视频。

00:02:45.840 --> 00:02:47.560
帮助您了解一些
构建基块和

00:02:47.560 --> 00:02:50.270
一些关键的功能，
组件和概念。

00:02:50.270 --> 00:02:53.170
之前我们在将来移动
为更多的深度的剧集

00:02:53.170 --> 00:02:56.000
周围的图像
网络等等。

00:02:56.000 --> 00:02:58.320
所以为什么不您拿走它
指导我们完成我们是什么

00:02:58.320 --> 00:03:00.311
要了解今天
在这个特定的片段。

00:03:00.311 --> 00:03:03.813
<< 我们将做的这个片段
只是谈一谈哪些容器

00:03:03.813 --> 00:03:06.127
是的我们将创建
一些容器的外观

00:03:06.127 --> 00:03:09.168
在容器中的某些图像和
像您这样的实际上只是开始

00:03:09.168 --> 00:03:12.341
说奠定
深入了解诸如

00:03:12.341 --> 00:03:15.518
网络的容器图像
容器的可移植性

00:03:15.518 --> 00:03:16.046
>> 可以酷

00:03:16.046 --> 00:03:16.706
>> 确定现在，让我们

00:03:16.706 --> 00:03:17.630
>> 目前仅有少数几个

00:03:17.630 --> 00:03:21.065
"不，我们不认为的幻灯片
做幻灯片"我们有几个，

00:03:21.065 --> 00:03:23.642
然后我们会停靠
直入一些演示，

00:03:23.642 --> 00:03:24.970
因此是一直使用它。

00:03:24.970 --> 00:03:27.140
>> 只是有助于我们的位置
有些东西也。

00:03:27.140 --> 00:03:28.500
>> 的确，绝对。

00:03:28.500 --> 00:03:32.560
因此容器
热到极点，不一定是

00:03:32.560 --> 00:03:34.820
很多人
都在谈论它们。

00:03:34.820 --> 00:03:39.780
它是在非常早期的
技术生命周期容器

00:03:39.780 --> 00:03:41.870
有已有一段时间
>> 在 Linux 上

00:03:41.870 --> 00:03:43.680
>> 在 Linux 上，但

00:03:43.680 --> 00:03:47.040
他们真的正在采取关闭右
现在，我只是来介绍

00:03:47.040 --> 00:03:50.140
容器和内容
容器是因为它是

00:03:50.140 --> 00:03:53.210
我们已经是奇怪的抽象，
在为虚拟化工作

00:03:53.210 --> 00:03:57.460
一些时间，而且它的很容易
比较到一个虚拟容器

00:03:57.460 --> 00:04:00.340
机器，但
>> 什么是容器

00:04:00.340 --> 00:04:02.800
和我们做什么与这些
和我们如何使用它们？

00:04:02.800 --> 00:04:04.280
所以我的意思的核心

00:04:04.280 --> 00:04:08.660
容器，真正是什么样的
虚拟化的组件。

00:04:08.660 --> 00:04:11.170
它是几乎类似
操作系统或

00:04:11.170 --> 00:04:12.890
应用程序虚拟化。

00:04:12.890 --> 00:04:16.460
我们使用所以实质
容器类似于如何我们

00:04:16.460 --> 00:04:18.040
可以使用虚拟机。

00:04:18.040 --> 00:04:20.920
我们实现此操作系统虚拟化和

00:04:20.920 --> 00:04:24.020
我们运行的应用程序从
在容器内，并

00:04:24.020 --> 00:04:27.410
我们可以访问这些应用程序
来自于容器之外。

00:04:27.410 --> 00:04:29.470
您可以在此处看到我
第一个项目符号点，

00:04:29.470 --> 00:04:33.030
我动员它们为操作系统
应用程序虚拟化和

00:04:33.030 --> 00:04:35.720
图像处理或
图像分层技术，

00:04:35.720 --> 00:04:38.300
这一点真的很重要
>> 很多的好处，我们

00:04:38.300 --> 00:04:40.400
会在容器中查找。

00:04:40.400 --> 00:04:43.550
福利的事情
快速启动时间，或

00:04:43.550 --> 00:04:46.300
在主机操作系统，占地面积小

00:04:46.300 --> 00:04:49.680
不得不与方式
我们可以管理和

00:04:49.680 --> 00:04:52.990
创建这些图像，或
容器使用这些图像的方式。

00:04:52.990 --> 00:04:54.830
因此，我将它放在第一
项目符号点，

00:04:54.830 --> 00:04:58.420
由于图像是非常
如何对重要

00:04:58.420 --> 00:04:59.470
容器的工作。

00:04:59.470 --> 00:05:00.270
并且，正如我们所说的

00:05:00.270 --> 00:05:03.566
我们要深入研究相当
深入探讨容器的图像。

00:05:03.566 --> 00:05:07.520
这样，容器，
操作系统虚拟化。

00:05:07.520 --> 00:05:11.900
容器承载的应用程序和
应用程序依存关系，

00:05:11.900 --> 00:05:13.350
它也是至关重要的。

00:05:13.350 --> 00:05:16.340
什么我们将看到的是，我们
塞得满满的应用程序和

00:05:16.340 --> 00:05:18.780
所有依赖项
在这个容器中。

00:05:18.780 --> 00:05:22.220
并比较成为此容器
此自包含单元，

00:05:22.220 --> 00:05:25.020
然后可以来回移动，
之间的环境，但

00:05:25.020 --> 00:05:27.270
其中有所有那些
内置于其依赖项。

00:05:27.270 --> 00:05:29.630
所以我们不做这样的事情
无需重新配置我们

00:05:29.630 --> 00:05:31.830
容器与我们移动。

00:05:31.830 --> 00:05:34.340
>> 依赖项没有到
居住在同一个容器？

00:05:34.340 --> 00:05:36.080
是因为无法布置这些
外侧不能您吗？

00:05:36.080 --> 00:05:36.920
>> 是的绝对。

00:05:36.920 --> 00:05:40.010
我们可以有多
容器应用程序。

00:05:40.010 --> 00:05:42.701
我们可能有的前端
具有所有依赖项

00:05:42.701 --> 00:05:44.021
对于前端
一个容器，

00:05:44.021 --> 00:05:46.050
具有所有后端
依赖项

00:05:46.050 --> 00:05:52.680
后端，
但是这些两个容器

00:05:52.680 --> 00:05:53.910
依赖于彼此
>> 是。

00:05:53.910 --> 00:05:55.560
>> 因此，它们构成一个应用程序。

00:05:55.560 --> 00:05:57.710
>> 和他们自己
取决于基本映像。

00:05:57.710 --> 00:05:59.710
确实，是的绝对。

00:05:59.710 --> 00:06:01.300
>> 好。
>> 我们已经 kinda

00:06:01.300 --> 00:06:04.880
讨论了它的容器
从容器图像生成。

00:06:04.880 --> 00:06:06.440
容器的图像是可移植的
和

00:06:06.440 --> 00:06:07.390
这是很酷。

00:06:07.390 --> 00:06:10.090
在将来我们会看到
节目中，我们将实际构建

00:06:10.090 --> 00:06:14.260
在我的便携式计算机上的应用程序
将该容器的图像

00:06:14.260 --> 00:06:18.070
上的移到什么称为
容器图像注册表和

00:06:18.070 --> 00:06:22.090
然后拉，到虚拟机中
Azure，因此其此可移植性

00:06:22.090 --> 00:06:27.690
这使我们的图像中
好方法移动的我们

00:06:27.690 --> 00:06:30.030
从环境到另一个工作
>> 毫米 hm 和

00:06:30.030 --> 00:06:30.960
这是同样的灵活性。

00:06:30.960 --> 00:06:32.340
所有我们的开发人员
也看到。

00:06:32.340 --> 00:06:35.200
您知道，生成应用程序
在工作站上本地

00:06:35.200 --> 00:06:37.100
从知道
一致性的角度来看，

00:06:37.100 --> 00:06:39.690
假如我可以将其部署到
便携式计算机中，到服务器

00:06:39.690 --> 00:06:42.850
在数据中心或设置为
公共云，它将起作用。

00:06:42.850 --> 00:06:44.050
>> 绝对。
>> 因为他们那里看到了它。

00:06:44.050 --> 00:06:46.260
它将具有依赖项
或它会用它，拉出

00:06:46.260 --> 00:06:47.790
然后便得到了
这一灵活性。

00:06:47.790 --> 00:06:51.410
>> 是的绝对的因此一些
容器中的优点，它是

00:06:51.410 --> 00:06:53.880
像好，我们可以看到我们
将应用程序放在这里，

00:06:53.880 --> 00:06:55.360
但是，好处在哪里呢？

00:06:55.360 --> 00:06:58.450
快速启动容器
他们快速扩展。

00:06:58.450 --> 00:07:00.270
它们可以快速破坏。

00:07:00.270 --> 00:07:03.700
在主机上，占地面积
相比，要小得多

00:07:03.700 --> 00:07:04.550
虚拟机。

00:07:04.550 --> 00:07:07.430
因此，我们可以获得此密度

00:07:07.430 --> 00:07:10.340
我们的物理计算机上，
承载这些容器。

00:07:10.340 --> 00:07:14.190
我们可以获得更高的密度
与容器不是我们可以使用

00:07:14.190 --> 00:07:15.900
一个虚拟机本身。

00:07:15.900 --> 00:07:17.060
>>，和与此相反

00:07:17.060 --> 00:07:19.500
我认为，我们将查看 VM
体系结构在每分钟但

00:07:19.500 --> 00:07:21.870
如果您要创建的 VM 的那些
有一些使用 Hyper-V 的历史记录。

00:07:21.870 --> 00:07:25.130
您知道您将会说 ︰ 如何
许多虚拟流程操作

00:07:25.130 --> 00:07:28.540
需要多少内存，我需要
虚拟 DVD 驱动器多少

00:07:28.540 --> 00:07:31.720
哪种网络它们的网络
需要 VLAN 的上等。

00:07:31.720 --> 00:07:34.550
没有更多的思考
关于，从虚拟机

00:07:34.550 --> 00:07:38.830
该硬件的角度看，
一定，是的图层

00:07:38.830 --> 00:07:41.690
它存在于在某种程度上
在某些方面的容器。

00:07:41.690 --> 00:07:46.590
但在该方面非常
严格，此虚拟机将具有这些

00:07:46.590 --> 00:07:48.600
虚拟进程，
这就是很大的不同。

00:07:48.600 --> 00:07:51.470
>> 是的我的意思是，实质上是我们
生成虚拟机非常类似于如何

00:07:51.470 --> 00:07:52.940
我们将构建
物理计算机。

00:07:52.940 --> 00:07:54.230
我们需要所有这些定义。

00:07:54.230 --> 00:07:58.410
组件和大量的
does 消失与容器。

00:07:58.410 --> 00:08:02.660
话虽如此，我的意思是，将潜在顾客到
这最后一次点此处，

00:08:02.660 --> 00:08:06.770
我们可以做的事情之一
容器是种类的限制

00:08:06.770 --> 00:08:09.350
该主机的资源使用情况。

00:08:09.350 --> 00:08:11.810
因此，我的意思是我们可以生成
一个容器，说嗨

00:08:11.810 --> 00:08:15.880
使用这么多内存也不
使用多个这么多内存。

00:08:15.880 --> 00:08:18.700
使用此数量的 CPU
而不需要。

00:08:18.700 --> 00:08:21.540
>> 是。
>> 使我们可以约束

00:08:21.540 --> 00:08:24.330
容器可以
从该主机的占用。

00:08:24.330 --> 00:08:25.740
>> 像您知道
万像素容器。

00:08:25.740 --> 00:08:26.870
>> 确定。
确实。

00:08:26.870 --> 00:08:27.430
完全正确。

00:08:27.430 --> 00:08:30.200
>> 只是在同一个方式。

00:08:30.200 --> 00:08:32.620
还应考虑的内容。

00:08:32.620 --> 00:08:34.030
确定操作。

00:08:34.030 --> 00:08:37.070
比较和对比，
VM，如果我们打开图形

00:08:37.070 --> 00:08:39.260
我们已经有了下一步
幻灯片以帮助我们阐明，

00:08:39.260 --> 00:08:41.950
从几个关键点是什么
此特定的图形

00:08:41.950 --> 00:08:44.679
人们应该知道的吗？

00:08:44.679 --> 00:08:46.770
>> 如果您已完成
研究容器后

00:08:46.770 --> 00:08:48.790
可能看到非常
相似的图形。

00:08:48.790 --> 00:08:52.360
和最大的一个
一个容器之间的差异

00:08:52.360 --> 00:08:56.130
和虚拟机
如何比较容器

00:08:56.130 --> 00:08:59.700
内核的工作原理
主机上。

00:08:59.700 --> 00:09:01.610
所以请看左边
在这里，手端

00:09:01.610 --> 00:09:03.630
我们提供了一个虚拟机。

00:09:03.630 --> 00:09:07.300
我们已经有了一个硬件层，
我们必须将操作系统和

00:09:07.300 --> 00:09:12.260
主机内核
随着虚拟机管理程序技术。

00:09:12.260 --> 00:09:14.740
然后我们在分层和
虚拟机

00:09:14.740 --> 00:09:16.880
在该虚拟机监控程序。

00:09:16.880 --> 00:09:19.210
因此每个这些虚拟
计算机的操作系统

00:09:19.210 --> 00:09:20.510
并在它的内核也。

00:09:20.510 --> 00:09:24.370
所以每当我们启动虚拟机
我们正在引导出一个完整的操作系统，

00:09:24.370 --> 00:09:25.620
内核和所有内容。

00:09:25.620 --> 00:09:28.610
>> 和一般来讲，每个
另一个将具有虚拟硬盘-

00:09:28.610 --> 00:09:29.020
>> 是。

00:09:29.020 --> 00:09:31.190
>>，将
>> 可能很大

00:09:31.190 --> 00:09:33.320
从空间您
任何后端存储

00:09:33.320 --> 00:09:34.650
这可能是。

00:09:34.650 --> 00:09:37.570
是，您可以使用诸如
差异磁盘中读取

00:09:37.570 --> 00:09:40.820
但仍只有父映像，但
存储消耗量

00:09:40.820 --> 00:09:43.920
通常与虚拟机相关联
可以是很大。

00:09:43.920 --> 00:09:44.700
>> 是的绝对。

00:09:44.700 --> 00:09:48.156
然后您得到了这些
虚拟机 kinda 进行

00:09:48.156 --> 00:09:51.324
硬件请求和
获取此虚拟机管理程序层

00:09:51.324 --> 00:09:54.852
截获这些请求和
管理这些请求

00:09:54.852 --> 00:09:58.816
根据主机的硬件
该虚拟机保存。

00:09:58.816 --> 00:10:02.183
这就是图像
虚拟机。

00:10:02.183 --> 00:10:06.581
若要对比容器主机
我们的硬件

00:10:06.581 --> 00:10:08.650
容器的主机。

00:10:08.650 --> 00:10:12.100
我们在内核中有操作系统
除此之外，坐

00:10:12.100 --> 00:10:15.380
以及该容器
软件 Docker 引擎。

00:10:15.380 --> 00:10:20.950
Windows 服务器容器引擎，
但您会注意到这里的

00:10:20.950 --> 00:10:25.170
容器本身不
具有该操作系统。

00:10:25.170 --> 00:10:26.760
它不具有该内核。

00:10:26.760 --> 00:10:28.500
因此，没有真正共享

00:10:28.500 --> 00:10:31.525
这些容器被共享
与主机操作系统内核。

00:10:31.525 --> 00:10:37.095
启动时间是快得多
还有很少进展

00:10:37.095 --> 00:10:39.665
当我们开始这些容器
与虚拟机。

00:10:39.665 --> 00:10:42.635
>> 和显然是此图形
我们来描述，只是说硬件

00:10:42.635 --> 00:10:45.835
在底部，但这
可能是物理硬件，或

00:10:45.835 --> 00:10:47.595
它可能是内部的
虚拟机中。

00:10:47.595 --> 00:10:48.665
>> 是的绝对。

00:10:48.665 --> 00:10:51.295
>> 因此，没有什么
停止这两个

00:10:51.295 --> 00:10:53.970
不同的技术
高兴地共存。

00:10:53.970 --> 00:10:57.150
您可能需要为实例的方式
你的 Hyper-V 主机，

00:10:57.150 --> 00:10:59.880
你两个 VM，
一个是 Linux，一个是 Windows 和

00:10:59.880 --> 00:11:02.500
运行 Linux 容器
在一个 VM 内部和

00:11:02.500 --> 00:11:04.050
在另一台 Windows 容器。

00:11:04.050 --> 00:11:06.780
但在该整个物理上
正在运行的混合系统

00:11:06.780 --> 00:11:07.700
容器。

00:11:07.700 --> 00:11:09.840
所以您有最好的
实际上那里的是，这两个世界

00:11:09.840 --> 00:11:12.350
使用
补充的技术。

00:11:12.350 --> 00:11:14.630
所以他们肯定是不一个或
其他，

00:11:14.630 --> 00:11:17.270
可以在中使用它们
结合这一点尤为重要。

00:11:17.270 --> 00:11:18.490
>> 是的绝对。

00:11:18.490 --> 00:11:25.150
因此在表面层中，它具有
真正简单到说虚拟

00:11:25.150 --> 00:11:28.970
机器，我们已经有了独立
在 VM 容器中，内核

00:11:28.970 --> 00:11:33.110
我们共享的
与主机操作系统的内核。

00:11:33.110 --> 00:11:34.700
现在这张照片
有点改变

00:11:34.700 --> 00:11:37.460
当我们将引进
超 V 容器

00:11:37.460 --> 00:11:41.120
它提供了更多
通过隔离层比较

00:11:41.120 --> 00:11:43.330
环绕该容器
在 VM 本身。

00:11:43.330 --> 00:11:44.450
>> 是的和
在几个星期的时间，

00:11:44.450 --> 00:11:46.960
我们会遇到剧集
HyperV 容器的右侧

00:11:46.960 --> 00:11:50.260
时间点当它们
可供测试。

00:11:50.260 --> 00:11:52.860
因此，您将看到更多集数
容器的通道，

00:11:52.860 --> 00:11:56.520
帮助人们剖析是什么
Hyper-V 容器是因为

00:11:56.520 --> 00:11:59.690
它肯定会添加一个额外
图层的功能，但

00:11:59.690 --> 00:12:02.390
它也是非常复杂，要抓住
也知道怎么回事

00:12:02.390 --> 00:12:05.550
这混合类型的设置
技术的 ' s 下面这样。

00:12:05.550 --> 00:12:07.070
>> 绝对。
>> 所以请继续关注那个。

00:12:07.070 --> 00:12:12.410
>> 这是什么样的主机
>> 虚拟机主机容器差异。

00:12:12.410 --> 00:12:14.890
另外，还有一些区别
我们的方式匹配的容器

00:12:14.890 --> 00:12:15.880
而不是给 VM。

00:12:15.880 --> 00:12:16.740
有一个比较班次

00:12:16.740 --> 00:12:19.940
尤其是如果您已经在
您所管理的 VM 回滚

00:12:19.940 --> 00:12:20.970
很长时间。

00:12:20.970 --> 00:12:23.560
这实际上是如何我们
使用容器的图像。

00:12:23.560 --> 00:12:27.150
因此，如果您已完成的质量
部署的虚拟机，您可能

00:12:27.150 --> 00:12:29.840
熟悉这一概念
像虚拟机映像，就像是

00:12:29.840 --> 00:12:33.900
sys prept 版本的操作系统
我们可以部署到一组

00:12:33.900 --> 00:12:37.660
虚拟机和一组数值调节钮
虚拟机快速率。

00:12:37.660 --> 00:12:39.970
容器的图像是非常
不同的虚拟机映像，并

00:12:39.970 --> 00:12:41.810
我们会发现，
我们将深入该深度。

00:12:41.810 --> 00:12:44.890
以及我们管理的方式
我们的容器，使用网络

00:12:44.890 --> 00:12:46.370
是不是有点不同。

00:12:48.060 --> 00:12:50.780
它是如何与不同我们
可能需要管理

00:12:50.780 --> 00:12:52.880
与虚拟机，网络和
看一看，也。

00:12:52.880 --> 00:12:53.430
>> 好了，冷却。

00:12:53.430 --> 00:12:56.290
因此请告诉我们一些更有
最少为这些简介

00:12:56.290 --> 00:12:57.650
您已经被提及的图像。

00:12:57.650 --> 00:13:00.930
我知道在下一次的节目
我们要深入地，

00:13:00.930 --> 00:13:02.880
得更深，
为容器的图像，但

00:13:02.880 --> 00:13:06.340
只是让人 10000
英尺的图像的视图。

00:13:06.340 --> 00:13:07.340
>> 是的绝对。

00:13:07.340 --> 00:13:10.220
和我做动员这因为
这是非常重要的一部分

00:13:10.220 --> 00:13:11.840
使用容器。

00:13:11.840 --> 00:13:15.530
因此，容器的图像是什么是
他们正在读的唯一的模板

00:13:15.530 --> 00:13:18.720
它用来启动
向上的容器。

00:13:18.720 --> 00:13:22.280
这些模板
包含应用程序。

00:13:22.280 --> 00:13:24.940
它们包含依赖关系
对于应用程序中。

00:13:24.940 --> 00:13:27.700
它们还可以包含
像的说明

00:13:27.700 --> 00:13:28.790
引导映像。

00:13:28.790 --> 00:13:32.198
因此喜欢每次启动时
具有此图像的容器

00:13:32.198 --> 00:13:33.590
开始此过程。

00:13:33.590 --> 00:13:35.680
然后，我们将看到的。

00:13:35.680 --> 00:13:38.950
这些图像可以组成
多个图层。

00:13:38.950 --> 00:13:42.790
所以我可能有基本的操作系统映像，
正如 Ubuntu，并且我可能

00:13:42.790 --> 00:13:48.580
有另一层的顶部
这就是我的 web 应用程序。

00:13:48.580 --> 00:13:51.540
然后对每个容器
我在我的主机上启动的那

00:13:51.540 --> 00:13:56.530
使用该基本操作系统映像，
它们都共享相同的实例

00:13:56.530 --> 00:13:59.810
该图像，这是在哪里
我们得到的小的占地面积-

00:13:59.810 --> 00:14:01.930
>> 优化资源使用情况。

00:14:01.930 --> 00:14:06.060
>> 优化资源使用情况和
我们可以实现通过该密度

00:14:06.060 --> 00:14:08.510
共享这些映像，我们将
看到这样的示例也。

00:14:09.640 --> 00:14:14.300
已经讨论过
包含图像

00:14:14.300 --> 00:14:18.030
执行的说明，
然后最后，这些图像

00:14:18.030 --> 00:14:21.500
可以存储和检索
从容器的注册表。

00:14:21.500 --> 00:14:23.600
这是我们可以怎样
实现可移植性。

00:14:23.600 --> 00:14:26.850
因此开发本地，
存储在注册表中，

00:14:26.850 --> 00:14:28.930
将其拉我
生产环境。

00:14:28.930 --> 00:14:29.430
>> 注册表、 存储库。
>> [串扰]

00:14:29.430 --> 00:14:31.784
>> 注册表、 存储库，

00:14:31.784 --> 00:14:36.150
只是一个地方。
我们可以有专用的注册表

00:14:36.150 --> 00:14:38.830
我们在看一个
未来集是

00:14:38.830 --> 00:14:40.420
公共注册表医生中心。

00:14:40.420 --> 00:14:41.590
>> 的权限。
好了，冷却。

00:14:41.590 --> 00:14:44.590
所以，我猜那
少量的背景。

00:14:44.590 --> 00:14:46.710
您想要进入一个演示吗
并显示 [串扰]。

00:14:46.710 --> 00:14:48.040
>> 是的绝对。

00:14:48.040 --> 00:14:50.350
让我们看看
在该演示版。

00:14:50.350 --> 00:14:53.587
因此，让我只大小上我
环境这里，因此我将

00:14:53.587 --> 00:14:57.120
请不要大量这些初始的演示
使用 Linux 的容器。

00:14:57.120 --> 00:15:02.790
尽管如此，我已经有了
在超 V 运行的 Linux 主机

00:15:02.790 --> 00:15:03.900
我的计算机上就在这里。

00:15:03.900 --> 00:15:05.750
所以，尽管我的工作在 Linux 中，

00:15:05.750 --> 00:15:09.150
我实际上正在对照
超 V 版本机器。

00:15:09.150 --> 00:15:12.240
现在我要运行
大量的 Docker 命令。

00:15:12.240 --> 00:15:15.350
Docker 是，
正如我们看到在其他视频中，

00:15:15.350 --> 00:15:17.950
是一种容器
管理系统。

00:15:17.950 --> 00:15:21.250
我们将使用它这里
针对 Linux 的容器

00:15:21.250 --> 00:15:23.900
我还将介绍一个示例
使用针对 Docker

00:15:23.900 --> 00:15:25.570
Windows 服务器
同样的容器。

00:15:25.570 --> 00:15:26.670
>> 很好，同样，和

00:15:26.670 --> 00:15:29.990
目前已经有一些
在 MSDN 上的文档

00:15:29.990 --> 00:15:31.540
网站和在 GitHub 上。

00:15:31.540 --> 00:15:34.420
您可以在其中如果要
开始使用 Docker 和

00:15:34.420 --> 00:15:36.730
Windows 服务器容器
没有为您的资料存在。

00:15:36.730 --> 00:15:38.050
>> 是。
>> 因此剥夺它。

00:15:38.050 --> 00:15:39.620
>> 因此，我们将只需了解
在一些基本的命令。

00:15:39.620 --> 00:15:41.470
因此，我在我
这里容器主机。

00:15:41.470 --> 00:15:46.120
我要不要 Docker 图像

00:15:46.120 --> 00:15:49.320
若要查看的图像列表，我
我们对该容器主机

00:15:49.320 --> 00:15:52.470
可以看到我有三双引导
然后几个其他人。

00:15:52.470 --> 00:15:54.140
>> 它们是如何存在？

00:15:54.140 --> 00:15:58.260
>> 因此，我有这些
将其从 Docker 集线器

00:15:58.260 --> 00:15:58.850
注册表。

00:15:58.850 --> 00:15:59.417
>> 好。
>> 因此

00:15:59.417 --> 00:16:01.934
比如，如果我愿意
拉下一个新的映像

00:16:01.934 --> 00:16:02.587
让我们假设。

00:16:08.012 --> 00:16:10.450
也许 MySQL。

00:16:10.450 --> 00:16:16.010
我要运行的命令
Docker 搜索，MySQL。

00:16:16.010 --> 00:16:18.670
它要做是去往
进入到 Docker 集线器，因此出

00:16:18.670 --> 00:16:19.820
注册表中，并且

00:16:19.820 --> 00:16:23.840
返回列表中的图像，
在其名称中包含 MySQL。

00:16:23.840 --> 00:16:27.560
您可以在这里看到我们
此列在这里，官员，和

00:16:27.560 --> 00:16:32.070
种一些指示，
这是官方的图像。

00:16:32.070 --> 00:16:35.290
这样我就可以看到 MySQL，
它是一个正式的镜像。

00:16:35.290 --> 00:16:37.210
然后我也可以看到星星。

00:16:37.210 --> 00:16:39.750
这些图像可以是这样
分级 Docker 集线器上。

00:16:39.750 --> 00:16:43.730
比较得到一些指示
通过类似，此视图

00:16:43.730 --> 00:16:46.290
嘿，可能是图像我
想要转后，因为我不能

00:16:46.290 --> 00:16:51.190
想要非常一般化
MySQL 图像上的定位。

00:16:51.190 --> 00:16:52.660
但还有很多
在那里的其他事项。

00:16:52.660 --> 00:16:55.918
>> 它有趣的这么多
人们已上载内容看起来

00:16:55.918 --> 00:16:58.028
想要对等
相同的图像，

00:16:58.028 --> 00:17:00.925
即使没有一个有
那太好了，您可以

00:17:00.925 --> 00:17:03.230
使用的标准额定的全部准备就绪。

00:17:03.230 --> 00:17:04.690
>> 但
所以有很多意义，因此

00:17:04.690 --> 00:17:08.880
我可能想要摧毁这
MySQL 图像，官方的图像。

00:17:08.880 --> 00:17:12.630
这样做几个更改
与我的应用程序。

00:17:12.630 --> 00:17:14.830
>> 好。
>> 和可能发回达

00:17:14.830 --> 00:17:17.870
公共注册表，以便我
可以将将其拉出其他地方。

00:17:17.870 --> 00:17:18.540
>> 好了，我看到。

00:17:18.540 --> 00:17:22.035
因此，我想如果他们文档
描述中的一部分

00:17:22.035 --> 00:17:23.800
希望其中一些只是
还说我 sequels。

00:17:23.800 --> 00:17:24.480
>> 的确，确保。

00:17:24.480 --> 00:17:25.580
>> 绝对。

00:17:25.580 --> 00:17:28.230
我们需要一些良好
文档的提示。

00:17:28.230 --> 00:17:30.200
>> 确定。
[笑声]当然，因此

00:17:30.200 --> 00:17:30.990
让我们来执行此操作。

00:17:30.990 --> 00:17:31.913
让我们实际，因此我们。

00:17:35.743 --> 00:17:37.460
看到图像的列表
在我的计算机。

00:17:37.460 --> 00:17:41.860
让我们继续操作并在旋转
一个容器，和真实看到，

00:17:41.860 --> 00:17:44.480
生成容器，并查看
我们可以做一些。

00:17:44.480 --> 00:17:48.870
因此，如果我真正运行一个命令，
我们可以看到 docker ps

00:17:48.870 --> 00:17:51.470
该 docker ps 基本上
返回列表的容器，

00:17:51.470 --> 00:17:52.725
我们可以看到这里有无。

00:17:52.725 --> 00:17:53.680
>> 毫米 hm。

00:17:53.680 --> 00:17:57.800
>> 如果办 docker ps 划线 it
返回容器的列表

00:17:57.800 --> 00:18:01.350
则在启动
状态或停止的状态。

00:18:01.350 --> 00:18:04.110
我因此再次有无容器
在这台机器无论如何。

00:18:05.120 --> 00:18:06.910
所以我要运行一个命令，
doc 或运行

00:18:09.730 --> 00:18:14.160
短划线 IT 和基本上划线 IT
将开始我的容器

00:18:14.160 --> 00:18:18.130
交互模式并返回
我到屏幕的键击。

00:18:18.130 --> 00:18:20.410
因此，基本上转到
启动容器和

00:18:20.410 --> 00:18:24.470
直接跳转到该容器，
然后我想要选择的图像

00:18:25.520 --> 00:18:27.180
我想要使用的
创建容器。

00:18:27.180 --> 00:18:30.800
我要选择我 Ubuntu 的映像
并将其命令。

00:18:31.990 --> 00:18:34.500
因此，我将运行
交互模式的命令

00:18:34.500 --> 00:18:35.610
我想要运行，在这种情况下，

00:18:35.610 --> 00:18:38.320
我只要打开
上背壳和

00:18:38.320 --> 00:18:41.310
快速，我容器
已创建和

00:18:41.310 --> 00:18:42.840
我在我的容器
这一时刻。

00:18:42.840 --> 00:18:43.900
>> 这是快速的。

00:18:43.900 --> 00:18:44.910
>> 是非常快速。

00:18:44.910 --> 00:18:47.630
>> 和容器名称，
很久？

00:18:47.630 --> 00:18:50.610
>> 所以这是的一部分
容器的盖子。

00:18:50.610 --> 00:18:54.260
容器还提供
名称，我们来看一看的。

00:18:54.260 --> 00:18:56.270
我们将从容器中溢出
这里一段时间中，

00:18:56.270 --> 00:18:56.930
看一看的。

00:18:56.930 --> 00:18:58.040
>> 没错，无妨棒极了。

00:18:58.040 --> 00:18:59.160
但这是快速。

00:18:59.160 --> 00:18:59.690
>> 是，因此

00:18:59.690 --> 00:19:03.020
如果我们采用容器内
看我的文件系统。

00:19:03.020 --> 00:19:07.460
这样有幕后
一堆的东西开始往上与

00:19:07.460 --> 00:19:12.070
该容器技术
若要简化该过程，因此

00:19:12.070 --> 00:19:15.390
我们必须将命名空间和
进程隔离。

00:19:15.390 --> 00:19:17.573
因此，而与
虚拟机，

00:19:17.573 --> 00:19:21.110
我们在转动
自包含的虚拟机。

00:19:21.110 --> 00:19:23.650
这个容器
在此主机上运行

00:19:23.650 --> 00:19:26.240
与任何其他容器。

00:19:26.240 --> 00:19:30.960
并使用命名空间和
处理隔离技术

00:19:30.960 --> 00:19:35.870
在此容器中，从
它看起来像一个完整、

00:19:35.870 --> 00:19:39.030
独立的实例
Ubuntu 操作系统。

00:19:39.030 --> 00:19:40.490
>> 是，它认为它有
唯一的事情那里的

00:19:40.490 --> 00:19:41.413
>> 系统认为它是唯一

00:19:41.413 --> 00:19:42.480
那里件事情本质上。

00:19:42.480 --> 00:19:43.420
>> 从资源的角度。

00:19:43.420 --> 00:19:44.480
>> 从资源的角度。

00:19:44.480 --> 00:19:46.250
这样就可以看到我们已经有了
文件系统，因此

00:19:46.250 --> 00:19:50.750
它可以是
如 Mkdir 测试。

00:19:50.750 --> 00:19:52.040
>> 创建文件夹
实质上。

00:19:52.040 --> 00:19:53.519
>> 是，因此
我已创建此文件夹测试。

00:19:55.951 --> 00:19:58.911
我将继续和
外出时的跳转

00:19:58.911 --> 00:20:03.662
键入 exit，我容器
因此，我们可以看到，我回来了。

00:20:03.662 --> 00:20:07.910
在容器的宿主，
如果已安装 ls，类似

00:20:07.910 --> 00:20:11.970
我们可以看到，我不这样认为
这里有一个测试文件夹。

00:20:11.970 --> 00:20:12.980
>> 是。

00:20:12.980 --> 00:20:15.430
>> 是一个很简单的东西，
但让我们看看，

00:20:15.430 --> 00:20:16.870
是的容器
实际创建。

00:20:16.870 --> 00:20:20.610
因此，我将运行
docker ps 划线，和

00:20:20.610 --> 00:20:23.535
在这里您可以看到我们已经有了
我们之前看到的容器 ID-

00:20:23.535 --> 00:20:24.110
>> 毫米 hm。

00:20:24.110 --> 00:20:27.050
>> 但还名称和
什么样的这里环绕。

00:20:27.050 --> 00:20:28.890
但我们已经可以看到
这古怪了。

00:20:28.890 --> 00:20:30.640
>> 的了
随机生成？

00:20:30.640 --> 00:20:31.220
>> 是。

00:20:31.220 --> 00:20:32.400
>> 确定 pearl 手册吗？

00:20:32.400 --> 00:20:33.670
>> 确定 pearl 手册。

00:20:33.670 --> 00:20:35.030
如果能，那么随机生成。

00:20:35.030 --> 00:20:35.860
>> 局限于任何。

00:20:35.860 --> 00:20:36.920
>> 是，是。

00:20:36.920 --> 00:20:42.500
因此非常简单，这是一个简单的
创建一个容器的示例

00:20:42.500 --> 00:20:43.750
修改容器。

00:20:43.750 --> 00:20:47.390
因此修改我们
未能创建文件夹。

00:20:47.390 --> 00:20:50.370
我们可以轻松地聊
安装一些软件。

00:20:50.370 --> 00:20:51.650
因此，让我们真正
看一看的。

00:20:54.920 --> 00:20:56.371
因此我要创建
一个新的容器。

00:21:01.323 --> 00:21:05.312
但我还会来运行
这在交互式模式中，

00:21:05.312 --> 00:21:06.710
使用 Ubuntu。

00:21:06.710 --> 00:21:07.840
>> 对同底，再次。

00:21:07.840 --> 00:21:09.404
>> 相同的基
[听不到] 的图像。

00:21:09.404 --> 00:21:10.900
>> 毫米 hm。
>> 和我将开始

00:21:10.900 --> 00:21:12.650
外壳程序。

00:21:12.650 --> 00:21:14.190
因此，已创建容器。

00:21:14.190 --> 00:21:15.460
我现在在容器内。

00:21:15.460 --> 00:21:16.330
>> 不同的结果。

00:21:16.330 --> 00:21:17.480
数字和字符存在，这样

00:21:17.480 --> 00:21:19.350
它是在不同的您
与上一个。

00:21:19.350 --> 00:21:20.110
>> 是的绝对。

00:21:20.110 --> 00:21:22.340
但现在我实际上会到
安装一些软件。

00:21:22.340 --> 00:21:23.820
我们会做的就是我们将和
安装一些软件

00:21:23.820 --> 00:21:26.350
到容器，
一旦有了软件

00:21:26.350 --> 00:21:29.985
已安装在该容器，
我们将跳醒目和

00:21:29.985 --> 00:21:33.195
然后捕获到的
其自己的容器图像。

00:21:33.195 --> 00:21:37.025
因此，我们将创建一个容器
派生自的图像

00:21:37.025 --> 00:21:39.095
基本操作系统映像。

00:21:39.095 --> 00:21:43.679
因此，我要运行的应用程序获取和
我只要安装的文本

00:21:43.679 --> 00:21:47.029
编辑器，和
然后实际操作，之前

00:21:47.029 --> 00:21:51.372
您可以看到是否我运行命令
这些命令找不到。

00:21:58.296 --> 00:22:01.367
我使用一个包
管理技术

00:22:01.367 --> 00:22:05.932
在 Linux 调用 apt 获取刚到
建立亲密关系，获取软件和

00:22:05.932 --> 00:22:08.240
将其安装在容器中。

00:22:08.240 --> 00:22:09.140
>> 好。
>> 同样，

00:22:09.140 --> 00:22:10.980
我说中进行安装
该容器，有一点。

00:22:10.980 --> 00:22:13.180
命名空间中，进程隔离。

00:22:13.180 --> 00:22:16.870
还有在一些诡计
在容器主机级别，

00:22:16.870 --> 00:22:17.540
但从根本上讲，

00:22:17.540 --> 00:22:19.840
这就是我们所要做是
下面是此软件的安装。

00:22:19.840 --> 00:22:22.600
>>，但在该容器中，
它有伤基

00:22:22.600 --> 00:22:25.170
实质上是在其中
捕获所做的更改。

00:22:25.170 --> 00:22:25.680
>> 完全一样。

00:22:25.680 --> 00:22:28.120
>> 因此，它将转到
这里，即使它所认为的

00:22:28.120 --> 00:22:32.470
如果在 Windows 环境下，它是
写入到 cdrive/窗口。

00:22:32.470 --> 00:22:35.615
它不是写入到主机
windows 中因为

00:22:35.615 --> 00:22:38.910
只读模式，从根本上讲，
因此，它将捕获到的基本映像

00:22:38.910 --> 00:22:43.500
临时空间可以让
您保存的关闭，该图像。

00:22:43.500 --> 00:22:47.790
>> 完全正确，因此，划伤
空间将成为下一个图层中

00:22:47.790 --> 00:22:50.190
该图像时我们
捕获此容器。

00:22:50.190 --> 00:22:52.820
>> 好了，所以
看起来像这样下载和。

00:22:52.820 --> 00:22:54.520
>> 安装已完成。

00:22:54.520 --> 00:22:55.780
>> Yup。
因此，我仍然在容器中，

00:22:55.780 --> 00:22:57.270
因此，我将运行这些测试。

00:22:57.270 --> 00:23:00.005
我们可以看到，我的软件
已安装。

00:23:00.005 --> 00:23:01.900
>> Uh-huh。

00:23:01.900 --> 00:23:03.290
>> 因此，我是存在。

00:23:03.290 --> 00:23:07.380
和我出容器的退出。

00:23:11.089 --> 00:23:12.366
再试一次。

00:23:15.697 --> 00:23:18.549
所以这是我两个
容器，这里是第一个

00:23:18.549 --> 00:23:21.800
我们创建，然后
我创建了最后一个。

00:23:21.800 --> 00:23:27.290
这有一个的名称-
>> 支付 Chandroseka。

00:23:27.290 --> 00:23:29.805
>> 是的非常感谢你们
我读出的。

00:23:29.805 --> 00:23:32.510
>> [发笑]
>> 它，我不知道在哪里

00:23:32.510 --> 00:23:35.860
他们将得到这非常非常
从各类名称与

00:23:35.860 --> 00:23:38.470
我们已经有了基于 2
我们到目前为止有 2。

00:23:38.470 --> 00:23:40.690
>> 因此，我将立即执行操作
是我要考虑这最后一次

00:23:40.690 --> 00:23:43.200
我们建立了，但我的容器
要从其创建的图像。

00:23:43.200 --> 00:23:49.820
不错，所以 Docker 提交
>> 我只在这里

00:23:49.820 --> 00:23:53.800
获取容器的主意
我只是将其命名它们

00:23:55.660 --> 00:23:59.230
并且，很快，我们可以看到
返回此大长网格

00:24:02.580 --> 00:24:06.230
现在，如果我做 Docker 图像
您会再次看到我有

00:24:07.290 --> 00:24:09.990
>> 另一个图像，然后再和

00:24:09.990 --> 00:24:15.665
因此，我再次强调，做 docker vim
我做交互模式。

00:24:15.665 --> 00:24:22.720
Vim 和短划线。

00:24:22.720 --> 00:24:23.720
>> 但
现在您可以从根本上讲，

00:24:23.720 --> 00:24:25.750
我知道我们要盖
这在将来的视频，

00:24:25.750 --> 00:24:27.600
还可以实质上是
为此 vim

00:24:27.600 --> 00:24:28.970
>> 任何人的图像。

00:24:28.970 --> 00:24:29.790
>> 绝对。
>> 和他们将

00:24:29.790 --> 00:24:34.110
能够在他们的计算机上运行
只要您有 Linux 基础。

00:24:34.110 --> 00:24:35.790
>> 是。
>>，它只需运行。

00:24:35.790 --> 00:24:39.530
>> 是，是的我们可以
我们刚刚创建的映像和

00:24:39.530 --> 00:24:41.170
将其推到 Docker 集线器。

00:24:41.170 --> 00:24:43.480
然后您可以将其拉和
在您的环境中，和

00:24:43.480 --> 00:24:44.440
只需运行它。

00:24:44.440 --> 00:24:45.400
>> 很酷、 很好。

00:24:45.400 --> 00:24:49.290
>> 因此，我只是构建一个新
该图像的容器。

00:24:49.290 --> 00:24:50.640
并将在 vim 中键入。

00:24:50.640 --> 00:24:52.170
您可以看到，
没有软件。

00:24:52.170 --> 00:24:53.960
>> 是，很好。

00:24:53.960 --> 00:24:56.730
>> 因此
这是相当简单。

00:24:56.730 --> 00:25:00.220
在下一段视频中我们将深入了解
为相当多的图像。

00:25:00.220 --> 00:25:04.630
我们实际上将
看看

00:25:04.630 --> 00:25:08.130
从基类派生的图像
将以此为基础进行比较。

00:25:08.130 --> 00:25:10.160
我们来了解一下分层，
实际上，我们来看

00:25:10.160 --> 00:25:12.870
更细小一下
>> 比较方式的分层

00:25:12.870 --> 00:25:13.620
工作正常。

00:25:13.620 --> 00:25:16.580
但要比较圆满地完成
有关演示

00:25:16.580 --> 00:25:19.070
此第一个介绍
这是相当简单。

00:25:19.070 --> 00:25:21.500
我们创建了一个文件夹，
我们安装的一些软件。

00:25:21.500 --> 00:25:24.630
但我还想让种类
一个完整的示例

00:25:24.630 --> 00:25:26.300
运行应用程序
在容器中，

00:25:26.300 --> 00:25:29.210
只是为了看清某种东西
更有实际意义。

00:25:29.210 --> 00:25:34.731
为此，我实际上对我进行让
退出此容器。

00:25:39.741 --> 00:25:41.877
我只是得到
到下面的文件夹中。

00:25:45.155 --> 00:25:48.130
我要使用的内容
被调用 Docker 撰写。

00:25:48.130 --> 00:25:50.670
我们可以谈论的内容
有关在以后的视频。

00:25:50.670 --> 00:25:55.440
但 Docker 撰写种类
业务流程工具的

00:25:55.440 --> 00:26:00.140
这使我们对
定义的说明

00:26:00.140 --> 00:26:03.740
部署多个容器
并将它们链接在一起。

00:26:03.740 --> 00:26:07.050
它是真的只是自动化
什么样的部署工具

00:26:07.050 --> 00:26:08.520
完整的应用程序
>> 的权限。

00:26:08.520 --> 00:26:10.640
>> 从几个基于
不同的容器。

00:26:10.640 --> 00:26:11.210
>> 好。
>> 因此，

00:26:11.210 --> 00:26:14.080
我只是比较
>> 获得此示例中，多和

00:26:14.080 --> 00:26:14.600
快速运行。

00:26:14.600 --> 00:26:16.790
我要使用的内容
被调用的医生撰写。

00:26:16.790 --> 00:26:20.810
所有权利因此

00:26:20.810 --> 00:26:26.140
医生撰写划线医生
构成了空间短划线 d。

00:26:26.140 --> 00:26:32.080
让我再试它一次。

00:26:34.220 --> 00:26:35.275
我不是在正确的文件夹中。

00:26:35.275 --> 00:26:40.272
docker-向上-d 撰写。

00:26:41.810 --> 00:26:45.490
它以快速旋转
两个计算机。

00:26:45.490 --> 00:26:47.540
因此，如果我做 docker ps

00:26:48.740 --> 00:26:52.320
您可以看到，我有
两个运行的容器。

00:26:53.580 --> 00:26:57.121
所使用的图像
neilpeterson/前和

00:26:57.121 --> 00:26:58.935
然后一个 MySQL 图像，和

00:26:58.935 --> 00:27:02.211
他们正在上运行
现在这个系统。

00:27:04.032 --> 00:27:07.213
所以，我只是抓住了 IP
此系统的地址。

00:27:21.557 --> 00:27:25.532
因此我们正在做，什么的
这里发生的情况是我在附加

00:27:25.532 --> 00:27:29.405
向正在运行的应用程序
在前方结束容器。

00:27:29.405 --> 00:27:30.170
>> 毫米 hm。

00:27:30.170 --> 00:27:32.490
它是只是一个简单的小窗体
这将插入一些

00:27:32.490 --> 00:27:34.650
到数据库的数据。

00:27:34.650 --> 00:27:35.640
因此，我只是做 C9 C9。

00:27:35.640 --> 00:27:39.150
实际上我不会这样填写。

00:27:41.560 --> 00:27:42.250
单击提交。

00:27:49.400 --> 00:27:52.100
然后我就到另一页
在该应用程序，您可以

00:27:52.100 --> 00:27:55.880
我们要检索的位置，请参阅
从实际 MySQL 数据

00:27:55.880 --> 00:27:58.980
正在运行的实例
那里第二个容器。

00:27:58.980 --> 00:28:01.400
>> 很好。
因此该 Docker 组成

00:28:01.400 --> 00:28:04.470
刚才的能力
使用实质上是

00:28:04.470 --> 00:28:06.210
使用某些类型的
配置文件。

00:28:06.210 --> 00:28:07.530
>> 是。
>> 为转，我需要这和

00:28:07.530 --> 00:28:08.920
此，繁荣。

00:28:08.920 --> 00:28:11.250
您必须配置和
那些单独过。

00:28:11.250 --> 00:28:13.100
它告诉他们怎么和
它开始运行时，

00:28:13.100 --> 00:28:17.525
您将看到有本地/bin/开始
对于我的 SQL，并

00:28:17.525 --> 00:28:20.170
前端的的 run.sh。

00:28:20.170 --> 00:28:22.110
它本质上是什么的
>> 是，

00:28:22.110 --> 00:28:23.890
让我们看看
看看该文件。

00:28:23.890 --> 00:28:25.140
因此，准确地
我们要做什么，

00:28:25.140 --> 00:28:27.750
我刚才已定义两个
在此处的容器。

00:28:27.750 --> 00:28:30.280
所以我第一个容器
我想要使用图像。

00:28:30.280 --> 00:28:32.210
我已经公开某些端口
我们将谈论它

00:28:32.210 --> 00:28:34.210
在下一步的视频。

00:28:34.210 --> 00:28:36.840
然后只需设置一些
环境变量和

00:28:36.840 --> 00:28:39.640
然后是相同的
我的第二个容器。

00:28:39.640 --> 00:28:44.160
所以只需一种自动的方法

00:28:44.160 --> 00:28:46.940
多个容器，向上旋转
将它们链接在一起。

00:28:46.940 --> 00:28:47.760
>> 很好。

00:28:47.760 --> 00:28:49.520
>> 是，并再次强调，我的目的所在
没有我只是真的想

00:28:49.520 --> 00:28:52.560
显示类型的更多实用
容器的示例

00:28:52.560 --> 00:28:56.220
除了只创建可以执行
文件夹和安装软件。

00:28:56.220 --> 00:28:59.560
但应用程序运行
从容器中。

00:28:59.560 --> 00:29:03.080
>> 很好，嗯，我想
我们演示到此结束。

00:29:03.080 --> 00:29:06.800
而这就使我们到结尾
对此这个第一个片段的

00:29:06.800 --> 00:29:09.250
迷你系列
容器的通道。

00:29:09.250 --> 00:29:10.940
还有一些建议
所需资源

00:29:10.940 --> 00:29:12.430
若要确保
你知道。

00:29:12.430 --> 00:29:14.510
首先，您可以下载
窗口的服务器技术

00:29:14.510 --> 00:29:17.430
预览当前技术
时间之前预览 3

00:29:17.430 --> 00:29:19.770
记录，如果您正在观看的
这地方下一行，

00:29:19.770 --> 00:29:22.430
它可能是 T P 4，
它可能甚至更高。

00:29:22.430 --> 00:29:24.050
它仍将相关。

00:29:24.050 --> 00:29:29.396
因此，评审出检查
在 MSDN.Microsoft.com/virtualiza-上的容器的文档

00:29:29.396 --> 00:29:31.415
在没有 Docker 资源服务和解决方案

00:29:31.415 --> 00:29:35.740
docker.com/microsoft，并获得
以 Docker 启动，没有

00:29:35.740 --> 00:29:39.518
为文档的链接
嗯，docs.docker.com/windows。

00:29:39.518 --> 00:29:43.100
大量的有用资源，
在下一次再次加入我们

00:29:43.100 --> 00:29:46.570
本微型系列视频位置
李瑞和我将探索

00:29:46.570 --> 00:29:49.293
中位更有深度，图像和
网络和可移植性。

00:29:49.293 --> 00:29:51.852
这样，很棒，谢谢。

00:29:51.852 --> 00:29:52.352
以后见。

00:29:52.352 --> 00:30:02.352
[音乐]