docker容器入门最佳教程

为何要写这个

简单回答是：容器技术很是热门，但门槛高。

容器技术是继大数据和云计算以后又一煊赫一时的技术，并且将来至关一段时间内都会很是流行。

对 IT 行业来讲，这是一项很是有价值的技术。而对 IT 从业者来讲，掌握容器技术是市场的须要，也是提高自我价值的重要途径。

拿我本身的工做经从来说，毕业后的头几年是作 J2EE 应用开发。后来到一家大型IT公司，公司的产品从中间件到操做系统、从服务器到存储、从虚拟化到云计算都有涉及。

我所在的部门是专门作 IT 基础设施实施服务的，最开始是作传统的 IT 项目，包括服务器配置，双机 HA 等。随着虚拟化技术成熟，工做上也开始涉及各类虚拟化技术的规划和实施，包括 VMWare、KVM、PowerVM等。后来云计算兴起，在公司业务和我的兴趣的驱动下，开始学习和实践 OpenStack，在这个过程当中写了《天天5分钟玩转OpenStack》教程并获得你们的承认。

如今以 Docker 为表明的容器技术来了，并且关注度愈来愈高，这一点能够从 Google Trend 中 Docker 的搜索上升趋势（蓝色曲线）中清楚看到。

每一轮新技术的兴起，不管对公司仍是我的既是机会也是挑战。

我我的的见解是：若是某项新技术将来将成为主流，就应该及早尽快掌握。
由于：

1. 新技术意味着新的市场和新的需求 
   初期掌握这种技术的人不会不少，而市场需求会愈来愈大，于是会造成供不该求的卖方市场，物以稀为贵，这对技术人员将是一个可贵的价值提高机会。
2. 学习新技术须要时间和精力，早起步早成材

机会讲过了，我们再来看看挑战。

新技术每每意味着技术上的突破和创新，会有很多新的概念和方法。 
并且从大数据，云计算和容器技术来看，这些新技术都是平台级别，覆盖的技术范围很是广，包括了计算、网络、存储、高可用、监控、安全等多个方面，要掌握这些新技术对 IT 老兵尚有不小难度，更别说新人了。

因为对技术一直保持着很高的热诚和执着，在掌握了 OpenStack 相关 IaaS 技术后，我便开始调研 PaaS 技术栈。正好这时 Docker 也愈来愈流行，天然而然便开始了容器相关技术的学习研究和实践。

学习容器技术的过程能够说是惊喜不断，常常惊叹于容器理念的先进和容器生态环境的完整和强大。不少传统软件开发和运维中的难题在容器世界里都能轻松解决，也渐渐理解了容器为什么如此受到青睐。

不夸张地说，容器为我打开了一扇通往另外一个软件世界的大门，让我沉浸其中，激动不已。高兴之余，我也火烧眉毛地想把我所看到所学到和所想到的有关容器的知识介绍给更多的人，让更多的IT工程师可以从容器技术中受益。

我但愿这个教程也能为你们打开这扇门，下降学习的曲线，系统地学习和掌握容器技术。

写给谁看？

这套教程的目标读者包括：

软件开发人员

相信微服务架构（Microservice Architectur）会逐渐成为开发应用系统的主流。而容器则是这种架构的基石。市场将须要更多可以开发出基于容器的应用程序的软件开发人员。

IT 实施和运维工程师

容器为应用提供了更好的打包和部署方式。愈来愈多的应用将以容器的方式在开发、测试和生产环境中运行。掌握容器相关技术将成为实施和运维工程师的核心竞争力。

我本身

我坚信最好的学习方法是分享。编写这个教程同时也是对本身学习和实践容器技术的总结。对于知识，只有把它写出来并可以让其余人理解，才能说明真正掌握了这项知识。

包含哪些内容？

本系列教程包括如下三大块内容：

下面分别介绍各部分包含的内容。

启程

 

“启程”会介绍容器的生态系统，让你们先从总体上了解容器都包含哪些技术，各类技术之间的相互关系是什么，而后再来看咱们的教程都会涉及生态中的哪些部分。

为了让你们尽快对容器有个感性认识，咱们会搭建实验环境并运行第一个容器，为以后的学习热身。

容器技术

这是教程的主要内容，包含“容器核心知识”和“容器进阶知识”两部分。

核心知识主要回答有关容器 what, why 和 how 三方面的问题。 其中以 how 为重，将展开讨论架构、镜像、容器、网络和存储。

进阶知识包括将容器真正用于生产所必需的技术，包括多主机管理、跨主机网络、监控、数据管理、日志管理和安全管理。

 

容器平台技术

以下图所示，“容器平台技术”包括容器编排引擎、容器管理平台和基于容器的 PaaS。容器平台技术在生态环境中占据着举足轻重的位置，对于容器是否可以落地，是否能应用于生产相当重要。

 

怎样的编写方式？

我会继续采用《天天5分钟玩转OpenStack》的方式，经过大量的实验由浅入深地探讨和实践容器技术，力求达到以下目标：

1. 快速上手：以最直接、最有效的方式让你们把容器用起来。
2. 按部就班：由易到难，从浅入深，详细分析容器的各类功能和配置使用方法。
3. 理解架构：从设计原理和架构分析入手，深刻探讨容器的架构和运行机理。
4. 注重实践：以大量实际操做案例为基础，让你们可以掌握真正的实施技能。

在内容的发布上仍是经过微信公众号（cloudman6）每周 一、三、5 按期分享。欢迎你们经过公众号提出问题和建议，进行技术交流。

为何叫《天天5分钟玩转Docker容器技术》？

为了下降学习的难度而且考虑到移动端碎片化阅读的特色，每次推送的内容你们只须要花5分钟就能看完（注意这里说的是看完，有时候要彻底理解可能须要更多时间哈），每篇内容包含1-3个知识点，这就是我把教程命名为《天天5分钟玩转Docker容器技术》的缘由。虽然是碎片化推送，但整个教程是系统、连贯和完整的，只是化整为零了。

好了，今天这5分钟算是开了个头，下次咱们正式开始玩转容器技术。

容器生态系统

对于像容器这类平台级别的技术，一般涉及的知识范围会很广，相关的软件，解决方案也会不少，初学者每每容易迷失。

那怎么办呢？

咱们能够从生活经验中寻找答案。 
当咱们去陌生城市旅游想了解一下这个城市通常咱们会怎么作？

我想大部分人应该会打开手机看一下这个城市的地图：

1. 城市大概的位置和地理形状是什么？
2. 都由哪几个区或县组成？
3. 主要的交通干道是哪几条？

一样的道理，学习容器技术咱们能够先从天上鸟瞰一下：

1. 容器生态系统包含哪些不一样层次的技术？
2. 不一样技术之间是什么关系？
3. 哪些是核心技术哪些是辅助技术？

首先得对容器技术有个总体认识，以后咱们的学习才可以有的放矢，才可以分清轻重缓急，作到心中有数，这样就不容易迷失了。

接下来我会根据本身的经验帮你们规划一条学习路线，一块儿探索容器生态系统。

学习新技术获得及时反馈是很是重要的，因此咱们立刻会搭建实验环境，并运行第一个容器，感觉什么是容器。

千里之行始于足下，让咱们从了解生态系统开始吧。

鸟瞰容器生态系统

容器生态系统

一谈到容器，你们都会想到 Docker。

Docker 如今几乎是容器的代名词。确实，是 Docker 将容器技术发扬光大。同时，你们也须要知道围绕 Docker 还有一个生态系统。Docker 是这个生态系统的基石，但完善的生态系统才是保障 Docker 以及容器技术可以真正健康发展的决定因素。

大体来看，容器生态系统包含核心技术、平台技术和支持技术。

下面分别介绍。

容器核心技术

容器核心技术是指可以让 container 在 host 上运行起来的那些技术。

 

这些技术包括容器规范、容器 runtime、容器管理工具、容器定义工具、Registry 以及 容器 OS，下面分别介绍。

容器规范

容器不光是 Docker，还有其余容器，好比 CoreOS 的 rkt。为了保证容器生态的健康发展，保证不一样容器之间可以兼容，包含 Docker、CoreOS、Google在内的若干公司共同成立了一个叫 Open Container Initiative（OCI） 的组织，其目是制定开放的容器规范。

目前 OCI 发布了两个规范：runtime spec 和 image format spec。 
有了这两个规范，不一样组织和厂商开发的容器可以在不一样的 runtime 上运行。这样就保证了容器的可移植性和互操做性。

容器 runtime

runtime 是容器真正运行的地方。runtime 须要跟操做系统 kernel 紧密协做，为容器提供运行环境。

若是你们用过 Java，能够这样来理解 runtime 与容器的关系：

Java 程序就比如是容器，JVM 则比如是 runtime。JVM 为 Java 程序提供运行环境。一样的道理，容器只有在 runtime 中才能运行。

lxc、runc 和 rkt 是目前主流的三种容器 runtime。

lxc 是 Linux 上老牌的容器 runtime。Docker 最初也是用 lxc 做为 runtime。

runc 是 Docker 本身开发的容器 runtime，符合 oci 规范，也是如今 Docker 的默认 runtime。

rkt 是 CoreOS 开发的容器 runtime，符合 oci 规范，于是可以运行 Docker 的容器。

容器管理工具

光有 runtime 还不够，用户得有工具来管理容器啊。容器管理工具对内与 runtime 交互，对外为用户提供 interface，好比 CLI。这就比如除了 JVM，还得提供 java 命令让用户可以启停应用不是。

lxd 是 lxc 对应的管理工具。

runc 的管理工具是 docker engine。docker engine 包含后台 deamon 和 cli 两个部分。咱们一般提到 Docker，通常就是指的 docker engine。

rkt 的管理工具是 rkt cli。

容器定义工具

容器定义工具容许用户定义容器的内容和属性，这样容器就可以被保存，共享和重建。

docker image 是 docker 容器的模板，runtime 依据 docker image 建立容器。

dockerfile 是包含若干命令的文本文件，能够经过这些命令建立出 docker image。

ACI (App Container Image) 与 docker image 相似，只不过它是由 CoreOS 开发的 rkt 容器的 image 格式。

Registry

容器是经过 image 建立的，须要有一个仓库来统一存放 image，这个仓库就叫作 Registry。

 

企业能够用 Docker Registry 构建私有的 Registry。

Docker Hub（https://hub.docker.com） 是 Docker 为公众提供的托管 Registry，上面有不少现成的 image，为 Docker 用户提供了极大的便利。

http://Quay.io（https://quay.io/）是另外一个公共托管 Registry，提供与 Docker Hub 相似的服务。

容器 OS

因为有容器 runtime，几乎全部的 Linux、MAC OS 和 Windows 均可以运行容器。但这不并无妨碍容器 OS 的问世。

容器 OS 是专门运行容器的操做系统。与常规 OS 相比，容器 OS 一般体积更小，启动更快。由于是为容器定制的 OS，一般它们运行容器的效率会更高。

目前已经存在很多容器 OS，CoreOS、atomic 和 ubuntu core 是其中的杰出表明。

容器平台技术

容器核心技术使得容器可以在单个 host 上运行。而容器平台技术可以让容器做为集群在分布式环境中运行。

容器平台技术包括容器编排引擎、容器管理平台和基于容器的 PaaS。

容器编排引擎

基于容器的应用通常会采用微服务架构。在这种架构下，应用被划分为不一样的组件，并以服务的形式运行在各自的容器中，经过 API 对外提供服务。为了保证应用的高可用，每一个组件均可能会运行多个相同的容器。这些容器会组成集群，集群中的容器会根据业务须要被动态地建立、迁移和销毁。

你们能够看到，这样一个基于微服务架构的应用系统其实是一个动态的可伸缩的系统。这对咱们的部署环境提出了新的要求，咱们须要有一种高效的方法来管理容器集群。而这，就是容器编排引擎要干的工做。

所谓编排（orchestration），一般包括容器管理、调度、集群定义和服务发现等。经过容器编排引擎，容器被有机的组合成微服务应用，实现业务需求。

docker swarm 是 Docker 开发的容器编排引擎。

kubernetes 是 Google 领导开发的开源容器编排引擎，同时支持 Docker 和 CoreOS 容器。

mesos 是一个通用的集群资源调度平台，mesos 与 marathon 一块儿提供容器编排引擎功能。

以上三者是当前主流的容器编排引擎。

容器管理平台

容器管理平台是架构在容器编排引擎之上的一个更为通用的平台。一般容器管理平台可以支持多种编排引擎，抽象了编排引擎的底层实现细节，为用户提供更方便的功能，好比 application catalog 和一键应用部署等。

Rancher 和 ContainerShip 是容器管理平台的典型表明。

基于容器的 PaaS

基于容器的 PaaS 为微服务应用开发人员和公司提供了开发、部署和管理应用的平台，使用户没必要关心底层基础设施而专一于应用的开发。

Deis、Flynn 和 Dokku 都是开源容器 PaaS 的表明。

容器支持技术

下面这些技术被用于支持基于容器的基础设施。

容器网络

容器的出现使网络拓扑变得更加动态和复杂。用户须要专门的解决方案来管理容器与容器，容器与其余实体之间的连通性和隔离性。

 

docker network 是 Docker 原生的网络解决方案。除此以外，咱们还能够采用第三方开源解决方案，例如 flannel、weave 和 calico。不一样方案的设计和实现方式不一样，各有优点和特色，须要根据实际须要来选型。

服务发现

动态变化是微服务应用的一大特色。当负载增长时，集群会自动建立新的容器；负载减少，多余的容器会被销毁。容器也会根据 host 的资源使用状况在不一样 host 中迁移，容器的 IP 和端口也会随之发生变化。

在这种动态的环境下，必需要有一种机制让 client 可以知道如何访问容器提供的服务。这就是服务发现技术要完成的工做。

服务发现会保存容器集群中全部微服务最新的信息，好比 IP 和端口，并对外提供 API，提供服务查询功能。

etcd、consul 和 zookeeper 是服务发现的典型解决方案。

监控

监控对于基础架构很是重要，而容器的动态特征对监控提出更多挑战。针对容器环境，已经涌现出不少监控工具和方案。

docker ps/top/stats 是 Docker 原生的命令行监控工具。除了命令行，Docker 也提供了 stats API，用户能够经过 HTTP 请求获取容器的状态信息。

sysdig、cAdvisor/Heapster 和 Weave Scope 是其余开源的容器监控方案。

数据管理

容器常常会在不一样的 host 之间迁移，如何保证持久化数据也可以动态迁移，是 Rex-Ray 这类数据管理工具提供的能力。

日志管理

日志为问题排查和事件管理提供了重要依据。

docker logs 是 Docker 原生的日志工具。而 logspout 对日志提供了路由功能，它能够收集不一样容器的日志并转发给其余工具进行后处理。

安全性

对于年轻的容器，安全性一直是业界争论的焦点。

OpenSCAP 可以对容器镜像进行扫描，发现潜在的漏洞。

本教程覆盖的知识范围

前面咱们已经鸟瞰了整个容器生态系统，对容器所涉及的技术体系有了全面的认识。那咱们的系列教程会讨论其中的哪些内容呢？

会覆盖容器生态系统 91.6% 的技术！

运行第一个容器

为了让你们对容器有个感性认识，咱们将尽快让一个容器运行起来。首先咱们须要搭建实验环境。

环境选择

容器须要管理工具、runtime 和操做系统，咱们的选择以下：

1. 管理工具 - Docker Engine 
   由于 Docker 最流行使用最普遍。
2. runtime - runc 
   Docker 的默认 runtime
3. 操做系统 - Ubuntu 
   虽然存在诸如 CoreOS 的容器 OS，因考虑到咱们目前处于初学阶段，选择你们熟悉的操做系统更为合适。等具有了扎实的容器基础知识后再使用容器 OS 会更有利。

安装 Docker

本节咱们将在 ubuntu 16.04 虚拟机中安装 Docker。由于安装过程须要访问 internet， 因此虚拟机必须可以上网。

Docker 支持几乎全部的 Linux 发行版，也支持 Mac 和 Windows。各操做系统的安装方法能够访问：https://docs.docker.com/engine/installation/

Docker 分为开源免费的 CE（Community Edition）版本和收费的 EE（Enterprise Edition）版本。下面咱们将按照文档，经过如下步骤在 Ubuntu 16.04 上安装 Docker CE 版本。

配置 Docker 的 apt 源

1.安装包，容许 apt 命令 HTTPS 访问 Docker 源。

2.添加 Docker 官方的 GPG key

3.将 Docker 的源添加到 /etc/apt/sources.list

安装 Docker

运行第一个容器

环境就绪，立刻运行第一个容器，执行命令：

其过程能够简单的描述为：

1. 从 Docker Hub 下载 httpd 镜像。镜像中已经安装好了 Apache HTTP Server。
2. 启动 httpd 容器，并将容器的 80 端口映射到 host 的 80 端口。

下面咱们能够经过浏览器验证容器是否正常工做。在浏览器中输入 http://[your ubuntu host IP]

能够访问容器的 http 服务了，第一个容器运行成功！咱们轻轻松松就拥有了一个 WEB 服务器。随着学习的深刻，会看到容器技术带给咱们更多的价值。

小结

咱们已经完成了教程的第一部分。

咱们认识了容器生态系统，后面会陆续学习生态系统中的大部分技术。咱们在 Ubuntu 16.04 上配置好了实验环境，并成功运行了第一个容器 httpd。

容器大门已经打开，让咱们去探秘吧。

 

 

What - 什么是容器？

容器是一种轻量级、可移植、自包含的软件打包技术，使应用程序能够在几乎任何地方以相同的方式运行。开发人员在本身笔记本上建立并测试好的容器，无需任何修改就可以在生产系统的虚拟机、物理服务器或公有云主机上运行。

容器与虚拟机

谈到容器，就不得不将它与虚拟机进行对比，由于二者都是为应用提供封装和隔离。

容器由两部分组成：

1. 应用程序自己
2. 依赖：好比应用程序须要的库或其余软件

容器在 Host 操做系统的用户空间中运行，与操做系统的其余进程隔离。这一点显著区别于的虚拟机。

传统的虚拟化技术，好比 VMWare, KVM, Xen，目标是建立完整的虚拟机。为了运行应用，除了部署应用自己及其依赖（一般几十 MB），还得安装整个操做系统（几十 GB）。

下图展现了两者的区别。

如图所示，因为全部的容器共享同一个 Host OS，这使得容器在体积上要比虚拟机小不少。另外，启动容器不须要启动整个操做系统，因此容器部署和启动速度更快，开销更小，也更容易迁移。

Why - 为何须要容器？

为何须要容器？容器到底解决的是什么问题？ 
简要的答案是：容器使软件具有了超强的可移植能力。

容器解决的问题

咱们来看看今天的软件开发面临着怎样的挑战？

现在的系统在架构上较十年前已经变得很是复杂了。之前几乎全部的应用都采用三层架构（Presentation/Application/Data），系统部署到有限的几台物理服务器上（Web Server/Application Server/Database Server）。

而今天，开发人员一般使用多种服务（好比 MQ，Cache，DB）构建和组装应用，并且应用极可能会部署到不一样的环境，好比虚拟服务器，私有云和公有云。

一方面应用包含多种服务，这些服务有本身所依赖的库和软件包；另外一方面存在多种部署环境，服务在运行时可能须要动态迁移到不一样的环境中。这就产生了一个问题：

如何让每种服务可以在全部的部署环境中顺利运行？

因而咱们获得了下面这个矩阵：

各类服务和环境经过排列组合产生了一个大矩阵。开发人员在编写代码时须要考虑不一样的运行环境，运维人员则须要为不一样的服务和平台配置环境。对他们双方来讲，这都是一项困难而艰巨的任务。

如何解决这个问题呢？

聪明的技术人员从传统的运输行业找到了答案。

几十年前，运输业面临着相似的问题。

每一次运输，货主与承运方都会担忧因货物类型的不一样而致使损失，好比几个铁桶错误地压在了一堆香蕉上。另外一方面，运输过程当中须要使用不一样的交通工具也让整个过程痛苦不堪：货物先装上车运到码头，卸货，而后装上船，到岸后又卸下船，再装上火车，到达目的地，最后卸货。一半以上的时间花费在装、卸货上，并且搬上搬下还容易损坏货物。

这一样也是一个 NxM 的矩阵。

幸运的是，集装箱的发明解决这个难题。

任何货物，不管钢琴仍是保时捷，都被放到各自的集装箱中。集装箱在整个运输过程当中都是密封的，只有到达最终目的地才被打开。标准集装箱能够被高效地装卸、重叠和长途运输。现代化的起重机能够自动在卡车、轮船和火车之间移动集装箱。集装箱被誉为运输业与世界贸易最重要的发明。

Docker 将集装箱思想运用到软件打包上，为代码提供了一个基于容器的标准化运输系统。Docker 能够将任何应用及其依赖打包成一个轻量级、可移植、自包含的容器。容器能够运行在几乎全部的操做系统上。

其实，“集装箱” 和 “容器” 对应的英文单词都是 “Container”。 
“容器” 是国内约定俗成的叫法，多是由于容器比集装箱更抽象，更适合软件领域的原故吧。

我我的认为：在老外的思惟中，“Container” 只用到了集装箱这一个意思，Docker 的 Logo 不就是一堆集装箱吗？

 

Docker 的特性

咱们能够看看集装箱思想是如何与 Docker 各类特性相对应的。

容器的优点

对于开发人员 - Build Once, Run Anywhere

容器意味着环境隔离和可重复性。开发人员只需为应用建立一次运行环境，而后打包成容器即可在其余机器上运行。另外，容器环境与所在的 Host 环境是隔离的，就像虚拟机同样，但更快更简单。

对于运维人员 - Configure Once, Run Anything

只须要配置好标准的 runtime 环境，服务器就能够运行任何容器。这使得运维人员的工做变得更高效，一致和可重复。容器消除了开发、测试、生产环境的不一致性。

How - 容器是如何工做的？

接下来学习容器核心知识的最主要部分。

咱们首先会介绍 Docker 的架构，而后分章节详细讨论 Docker 的镜像、容器、网络和存储。

Docker 架构详解

Docker 的核心组件包括：

1. Docker 客户端 - Client
2. Docker 服务器 - Docker daemon
3. Docker 镜像 - Image
4. Registry
5. Docker 容器 - Container

Docker 架构以下图所示：

Docker 采用的是 Client/Server 架构。客户端向服务器发送请求，服务器负责构建、运行和分发容器。客户端和服务器能够运行在同一个 Host 上，客户端也能够经过 socket 或 REST API 与远程的服务器通讯。

Docker 客户端

最经常使用的 Docker 客户端是 docker 命令。经过 docker 咱们能够方便地在 Host 上构建和运行容器。

docker 支持不少操做（子命令），后面会逐步用到。

除了 docker 命令行工具，用户也能够经过 REST API 与服务器通讯。

Docker 服务器

Docker daemon 是服务器组件，以 Linux 后台服务的方式运行。

Docker daemon 运行在 Docker host 上，负责建立、运行、监控容器，构建、存储镜像。

默认配置下，Docker daemon 只能响应来自本地 Host 的客户端请求。若是要容许远程客户端请求，须要在配置文件中打开 TCP 监听，步骤以下：

1.编辑配置文件 /etc/systemd/system/multi-user.target.wants/docker.service，在环境变量 ExecStart 后面添加 -H tcp://0.0.0.0，容许来自任意 IP 的客户端链接。

若是使用的是其余操做系统，配置文件的位置可能会不同。

2.重启 Docker daemon。

3.服务器 IP 为 192.168.56.102，客户端在命令行里加上 -H 参数，便可与远程服务器通讯。

info 子命令用于查看 Docker 服务器的信息。

Docker 镜像

可将 Docker 镜像当作只读模板，经过它能够建立 Docker 容器。

例如某个镜像可能包含一个 Ubuntu 操做系统、一个 Apache HTTP Server 以及用户开发的 Web 应用。

镜像有多种生成方法：

1. 能够从无到有开始建立镜像
2. 也能够下载并使用别人建立好的现成的镜像
3. 还能够在现有镜像上建立新的镜像

咱们能够将镜像的内容和建立步骤描述在一个文本文件中，这个文件被称做 Dockerfile，经过执行 docker build <docker-file> 命令能够构建出 Docker 镜像，后面咱们会讨论。

Docker 容器

Docker 容器就是 Docker 镜像的运行实例。

用户能够经过 CLI（docker）或是 API 启动、中止、移动或删除容器。能够这么认为，对于应用软件，镜像是软件生命周期的构建和打包阶段，而容器则是启动和运行阶段。

Registry

Registry 是存放 Docker 镜像的仓库，Registry 分私有和公有两种。

Docker Hub（https://hub.docker.com/） 是默认的 Registry，由 Docker 公司维护，上面有数以万计的镜像，用户能够自由下载和使用。

出于对速度或安全的考虑，用户也能够建立本身的私有 Registry。后面咱们会学习如何搭建私有 Registry。

docker pull 命令能够从 Registry 下载镜像。 docker run 命令则是先下载镜像（若是本地没有），而后再启动容器。

Docker 组件如何协做？

一个完整的例子

还记得咱们运行的第一个容器吗？如今经过它来体会一下 Docker 各个组件是如何协做的。

容器启动过程以下：

1. Docker 客户端执行 docker run 命令。
2. Docker daemon 发现本地没有 httpd 镜像。
3. daemon 从 Docker Hub 下载镜像。
4. 下载完成，镜像 httpd 被保存到本地。
5. Docker daemon 启动容器。

docker images 能够查看到 httpd 已经下载到本地。

docker ps 或者 docker container ls 显示容器正在运行。

小结

Docker 借鉴了集装箱的概念。标准集装箱将货物运往世界各地，Docker 将这个模型运用到本身的设计哲学中，惟一不一样的是：集装箱运输货物，而 Docker 运输软件。

每一个容器都有一个软件镜像，至关于集装箱中的货物。容器能够被建立、启动、关闭和销毁。和集装箱同样，Docker 在执行这些操做时，并不关心容器里到底装的什么，它无论里面是 Web Server，仍是 Database。

用户不须要关心容器最终会在哪里运行，由于哪里均可以运行。

开发人员能够在笔记本上构建镜像并上传到 Registry，而后 QA 人员将镜像下载到物理或虚拟机作测试，最终容器会部署到生产环境。

使用 Docker 以及容器技术，咱们能够快速构建一个应用服务器、一个消息中间件、一个数据库、一个持续集成环境。由于 Docker Hub 上有咱们能想到的几乎全部的镜像。

不知你们是否意识到，潘多拉盒子已经被打开。容器不但下降了咱们学习新技术的门槛，更提升了效率。

若是你是一个运维人员，想研究负载均衡软件 HAProxy，只须要执行 docker run haproxy，无需繁琐的手工安装和配置既能够直接进入实战。

若是你是一个开发人员，想学习怎么用 django 开发 Python Web 应用，执行 docker run django，在容器里随便折腾吧，不用担忧会搞乱 Host 的环境。

不夸张的说：容器大大提高了 IT 人员的幸福指数。

最小的镜像

镜像是 Docker 容器的基石，容器是镜像的运行实例，有了镜像才能启动容器。

本章内容安排以下：

1. 首先经过研究几个典型的镜像，分析镜像的内部结构。
2. 而后学习如何构建本身的镜像。
3. 最后介绍怎样管理和分发镜像。

镜像的内部结构

为何咱们要讨论镜像的内部结构？

若是只是使用镜像，固然不须要了解，直接经过 docker 命令下载和运行就能够了。

但若是咱们想建立本身的镜像，或者想理解 Docker 为何是轻量级的，就很是有必要学习这部分知识了。

咱们从一个最小的镜像开始吧。

hello-world - 最小的镜像

hello-world 是 Docker 官方提供的一个镜像，一般用来验证 Docker 是否安装成功。

咱们先经过 docker pull 从 Docker Hub 下载它。

用 docker images 命令查看镜像的信息。

hello-world 镜像居然还不到 2KB!

经过 docker run 运行。

其实咱们更关心 hello-world 镜像包含哪些内容。

Dockerfile 是镜像的描述文件，定义了如何构建 Docker 镜像。Dockerfile 的语法简洁且可读性强，后面咱们会专门讨论如何编写 Dockerfile。

hello-world 的 Dockerfile 内容以下：

只有短短三条指令。

1. FROM scratch 
   此镜像是从白手起家，从 0 开始构建。
2. COPY hello / 
   将文件“hello”复制到镜像的根目录。
3. CMD ["/hello"] 
   容器启动时，执行 /hello

镜像 hello-world 中就只有一个可执行文件 “hello”，其功能就是打印出 “Hello from Docker ......” 等信息。

/hello 就是文件系统的所有内容，连最基本的 /bin，/usr, /lib, /dev 都没有。

hello-world 虽然是一个完整的镜像，但它并无什么实际用途。一般来讲，咱们但愿镜像能提供一个基本的操做系统环境，用户能够根据须要安装和配置软件。

这样的镜像咱们称做 base 镜像。

 

base 镜像

上一节咱们介绍了最小的 Docker 镜像，本节讨论 base 镜像。

base 镜像有两层含义：

1. 不依赖其余镜像，从 scratch 构建。
2. 其余镜像能够之为基础进行扩展。

因此，能称做 base 镜像的一般都是各类 Linux 发行版的 Docker 镜像，好比 Ubuntu, Debian, CentOS 等。

咱们以 CentOS 为例考察 base 镜像包含哪些内容。
下载镜像：

docker pull centos

查看镜像信息：

镜像大小不到 200MB。

等一下！
一个 CentOS 才 200MB ？
平时咱们安装一个 CentOS 至少都有几个 GB，怎么可能才 200MB !

相信这是几乎全部 Docker 初学者都会有的疑问，包括我本身。下面咱们来解释这个问题。

Linux 操做系统由内核空间和用户空间组成。以下图所示：

rootfs

内核空间是 kernel，Linux 刚启动时会加载 bootfs 文件系统，以后 bootfs 会被卸载掉。

用户空间的文件系统是 rootfs，包含咱们熟悉的 /dev, /proc, /bin 等目录。

对于 base 镜像来讲，底层直接用 Host 的 kernel，本身只须要提供 rootfs 就好了。

而对于一个精简的 OS，rootfs 能够很小，只须要包括最基本的命令、工具和程序库就能够了。相比其余 Linux 发行版，CentOS 的 rootfs 已经算臃肿的了，alpine 还不到 10MB。

咱们平时安装的 CentOS 除了 rootfs 还会选装不少软件、服务、图形桌面等，须要好几个 GB 就不足为奇了。

base 镜像提供的是最小安装的 Linux 发行版。

下面是 CentOS 镜像的 Dockerfile 的内容：

第二行 ADD 指令添加到镜像的 tar 包就是 CentOS 7 的 rootfs。在制做镜像时，这个 tar 包会自动解压到 / 目录下，生成 /dev, /proc, /bin 等目录。

注：可在 Docker Hub 的镜像描述页面中查看 Dockerfile 。

支持运行多种 Linux OS

不一样 Linux 发行版的区别主要就是 rootfs。

好比 Ubuntu 14.04 使用 upstart 管理服务，apt 管理软件包；而 CentOS 7 使用 systemd 和 yum。这些都是用户空间上的区别，Linux kernel 差异不大。

因此 Docker 能够同时支持多种 Linux 镜像，模拟出多种操做系统环境。

上图 Debian 和 BusyBox（一种嵌入式 Linux）上层提供各自的 rootfs，底层共用 Docker Host 的 kernel。

这里须要说明的是：

1. base 镜像只是在用户空间与发行版一致，kernel 版本与发行版是不一样的。
例如 CentOS 7 使用 3.x.x 的 kernel，若是 Docker Host 是 Ubuntu 16.04（好比咱们的实验环境），那么在 CentOS 容器中使用的实际是是 Host 4.x.x 的 kernel。

① Host kernel 为 4.4.0-31

② 启动并进入 CentOS 容器

③ 验证容器是 CentOS 7

④ 容器的 kernel 版本与 Host 一致

2. 容器只能使用 Host 的 kernel，而且不能修改。
全部容器都共用 host 的 kernel，在容器中没办法对 kernel 升级。若是容器对 kernel 版本有要求（好比应用只能在某个 kernel 版本下运行），则不建议用容器，这种场景虚拟机可能更合适。

镜像的分层结构

Docker 支持经过扩展示有镜像，建立新的镜像。

实际上，Docker Hub 中 99% 的镜像都是经过在 base 镜像中安装和配置须要的软件构建出来的。好比咱们如今构建一个新的镜像，Dockerfile 以下：

① 新镜像再也不是从 scratch 开始，而是直接在 Debian base 镜像上构建。

② 安装 emacs 编辑器。

③ 安装 apache2。

④ 容器启动时运行 bash。

构建过程以下图所示：

能够看到，新镜像是从 base 镜像一层一层叠加生成的。每安装一个软件，就在现有镜像的基础上增长一层。

问什么 Docker 镜像要采用这种分层结构呢？

最大的一个好处就是 - 共享资源。

好比：有多个镜像都从相同的 base 镜像构建而来，那么 Docker Host 只需在磁盘上保存一份 base 镜像；同时内存中也只需加载一份 base 镜像，就能够为全部容器服务了。并且镜像的每一层均可以被共享，咱们将在后面更深刻地讨论这个特性。

这时可能就有人会问了：若是多个容器共享一份基础镜像，当某个容器修改了基础镜像的内容，好比 /etc 下的文件，这时其余容器的 /etc 是否也会被修改？

答案是不会！

修改会被限制在单个容器内。

这就是咱们接下来要学习的容器 Copy-on-Write 特性。

可写的容器层

当容器启动时，一个新的可写层被加载到镜像的顶部。
这一层一般被称做“容器层”，“容器层”之下的都叫“镜像层”。

全部对容器的改动 - 不管添加、删除、仍是修改文件都只会发生在容器层中。

只有容器层是可写的，容器层下面的全部镜像层都是只读的。

下面咱们深刻讨论容器层的细节。

镜像层数量可能会不少，全部镜像层会联合在一块儿组成一个统一的文件系统。若是不一样层中有一个相同路径的文件，好比 /a，上层的 /a 会覆盖下层的 /a，也就是说用户只能访问到上层中的文件 /a。在容器层中，用户看到的是一个叠加以后的文件系统。

1. 添加文件 在容器中建立文件时，新文件被添加到容器层中。
2. 读取文件 在容器中读取某个文件时，Docker 会从上往下依次在各镜像层中查找此文件。一旦找到，当即将其复制到容器层，而后打开并读入内存。
3. 修改文件 在容器中修改已存在的文件时，Docker 会从上往下依次在各镜像层中查找此文件。一旦找到，当即将其复制到容器层，而后修改之。
4. 删除文件 在容器中删除文件时，Docker 也是从上往下依次在镜像层中查找此文件。找到后，会在容器层中记录下此删除操做。

只有当须要修改时才复制一份数据，这种特性被称做 Copy-on-Write。可见，容器层保存的是镜像变化的部分，不会对镜像自己进行任何修改。

这样就解释了咱们前面提出的问题：容器层记录对镜像的修改，全部镜像层都是只读的，不会被容器修改，因此镜像能够被多个容器共享。

构建镜像

对于 Docker 用户来讲，最好的状况是不须要本身建立镜像。几乎全部经常使用的数据库、中间件、应用软件等都有现成的 Docker 官方镜像或其余人和组织建立的镜像，咱们只须要稍做配置就能够直接使用。

使用现成镜像的好处除了省去本身作镜像的工做量外，更重要的是能够利用前人的经验。特别是使用那些官方镜像，由于 Docker 的工程师知道如何更好的在容器中运行软件。

固然，某些状况下咱们也不得不本身构建镜像，好比：

1. 找不到现成的镜像，好比本身开发的应用程序。
2. 须要在镜像中加入特定的功能，好比官方镜像几乎都不提供 ssh。

因此本节咱们将介绍构建镜像的方法。同时分析构建的过程也可以加深咱们对前面镜像分层结构的理解。

Docker 提供了两种构建镜像的方法：

1. docker commit 命令
2. Dockerfile 构建文件

docker commit

docker commit 命令是建立新镜像最直观的方法，其过程包含三个步骤：

1. 运行容器
2. 修改容器
3. 将容器保存为新的镜像

举个例子：在 ubuntu base 镜像中安装 vi 并保存为新镜像。

1. 第一步， 运行容器

-it 参数的做用是以交互模式进入容器，并打开终端。412b30588f4a 是容器的内部 ID。

1. 安装 vi

确认 vi 没有安装。

安装 vi。

1. 保存为新镜像
   在新窗口中查看当前运行的容器。

silly_goldberg 是 Docker 为咱们的容器随机分配的名字。

执行 docker commit 命令将容器保存为镜像。

新镜像命名为 ubuntu-with-vi。

查看新镜像的属性。

从 size 上看到镜像由于安装了软件而变大了。

重新镜像启动容器，验证 vi 已经可使用。

以上演示了如何用 docker commit 建立新镜像。然而，Docker 并不建议用户经过这种方式构建镜像。缘由以下：

1. 这是一种手工建立镜像的方式，容易出错，效率低且可重复性弱。好比要在 debian base 镜像中也加入 vi，还得重复前面的全部步骤。
2. 更重要的：使用者并不知道镜像是如何建立出来的，里面是否有恶意程序。也就是说没法对镜像进行审计，存在安全隐患。

既然 docker commit 不是推荐的方法，咱们干吗还要花时间学习呢？

缘由是：即使是用 Dockerfile（推荐方法）构建镜像，底层也 docker commit 一层一层构建新镜像的。学习 docker commit 可以帮助咱们更加深刻地理解构建过程和镜像的分层结构。

Dockerfile 构建镜像

Dockerfile 是一个文本文件，记录了镜像构建的全部步骤。

第一个 Dockerfile

用 Dockerfile 建立上节的 ubuntu-with-vi，其内容则为：

 

 

下面咱们运行 docker build 命令构建镜像并详细分析每一个细节。

① 当前目录为 /root。

② Dockerfile 准备就绪。

③ 运行 docker build 命令，-t 将新镜像命名为 ubuntu-with-vi-dockerfile，命令末尾的 . 指明 build context 为当前目录。Docker 默认会从 build context 中查找 Dockerfile 文件，咱们也能够经过 -f 参数指定 Dockerfile 的位置。

④ 从这步开始就是镜像真正的构建过程。 首先 Docker 将 build context 中的全部文件发送给 Docker daemon。build context 为镜像构建提供所须要的文件或目录。
Dockerfile 中的 ADD、COPY 等命令能够将 build context 中的文件添加到镜像。此例中，build context 为当前目录 /root，该目录下的全部文件和子目录都会被发送给 Docker daemon。

因此，使用 build context 就得当心了，不要将多余文件放到 build context，特别不要把 /、/usr 做为 build context，不然构建过程会至关缓慢甚至失败。

⑤ Step 1：执行 FROM，将 ubuntu 做为 base 镜像。
ubuntu 镜像 ID 为 f753707788c5。

⑥ Step 2：执行 RUN，安装 vim，具体步骤为 ⑦、⑧、⑨。

⑦ 启动 ID 为 9f4d4166f7e3 的临时容器，在容器中经过 apt-get 安装 vim。

⑧ 安装成功后，将容器保存为镜像，其 ID 为 35ca89798937。

这一步底层使用的是相似 docker commit 的命令。

⑨ 删除临时容器 9f4d4166f7e3。

⑩ 镜像构建成功。

经过 docker images 查看镜像信息。

镜像 ID 为 35ca89798937，与构建时的输出一致。

在上面的构建过程当中，咱们要特别注意指令 RUN 的执行过程 ⑦、⑧、⑨。Docker 会在启动的临时容器中执行操做，并经过 commit 保存为新的镜像。

查看镜像分层结构

ubuntu-with-vi-dockerfile 是经过在 base 镜像的顶部添加一个新的镜像层而获得的。

这个新镜像层的内容由 RUN apt-get update && apt-get install -y vim 生成。这一点咱们能够经过 docker history 命令验证。

docker history 会显示镜像的构建历史，也就是 Dockerfile 的执行过程。

ubuntu-with-vi-dockerfile 与 ubuntu 镜像相比，确实只是多了顶部的一层 35ca89798937，由 apt-get 命令建立，大小为 97.07MB。docker history 也向咱们展现了镜像的分层结构，每一层由上至下排列。

注： 表示没法获取 IMAGE ID，一般从 Docker Hub 下载的镜像会有这个问题。