docker 就是经常听到听到的 容器。github 项目已经改名为 Moby 。star :5w+
关于 docker 和k8s 的联系参考（k8s:生产级别的容器编排系统）：
知乎：10分钟看懂Docker和K8S
知乎：Kubernetes，2020 快速入门

docker 用 google 的 go 语言开发
docker 和 虚拟机 都是基于沙箱原理，实现一套环境的隔离作用。
由于隔离进程独立于宿主，也被称为容器
docker 比虚拟机更轻便，没有自己的内核，也没有硬件虚拟
docker 就好像使用云的概念，使用共同资源——镜像
docker 是一个镜像的软连接，差不多可以这样理解，在目标主机上搭建环境
这里还要提一下，另外一个远程操控主机的 工具，就是ansible 可以和docker 配合使用，ansible 通过 ansible-playbook xx.yml 可向目标主机派发任务，远程配置环境以及执行命令

Docker宣称，开发人员可以在笔记本上编译，测试，打包其应用及依赖到可移植容器中，然后批量发布到任意服务器，并在生产环境中部署，包括VMs, OpenStack集群等其他基础应用平台。

而容器是完全的沙箱机制，相互之间不会有任何接口，有点类似iOS中的独立Apps。
参考文章：（主要还是参考文档）
阮一峰 docker 入门教程
docker 中文文档

Docker 属于 Linux 容器的一种封装，提供简单易用的容器使用接口。它是目前最流行的 Linux 容器解决方案
Docker 将应用程序与该程序的依赖，打包在一个文件里面。运行这个文件，就会生成一个虚拟容器。程序在这个虚拟容器里运行，就好像在真实的物理机上运行一样。有了 Docker，就不用担心环境问题。

• Docker 的用途

（1）提供一次性的环境。比如，本地测试他人的软件、持续集成的时候提供单元测试和构建的环境。

（2）提供弹性的云服务。因为 Docker 容器可以随开随关，很适合动态扩容和缩容。

（3）组建微服务架构。通过多个容器，一台机器可以跑多个服务，因此在本机就可以模拟出微服务架构。
（4）持续迁移和部署：Docker 确保了执行环境的一致性，Docker 可以在很多平台上运行，无论是物理机、虚拟机、公有云、私有云，甚至是笔记本，其运行结果是一致的。因此用户可以很轻易的将在一个平台上运行的应用，迁移到另一个平台上。
（5）更轻松的维护和扩展：Docker 团队同各个开源项目团队一起维护了一大批高质量的 官方镜像，既可以直接在生产环境使用
（6）系统支持量：单机支持上千个容器

• Docker的基本概念

1.Docker 镜像

Docker 镜像（Image），就相当于是一个 root 文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数

2.Docker 容器

镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的 类 和 实例 一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。
容器的实质是进程，但与直接在宿主执行的进程不同，容器进程运行于属于自己的独立的 命名空间。因此容器可以拥有自己的 root 文件系统、自己的网络配置、自己的进程空间，甚至自己的用户 ID 空间。

3.Docker 仓库

为了方便公用镜像，就有了公共仓库注册处的概念。注册处 register 包含多个仓库。每个仓库可以包含多个 标签（Tag）；每个标签对应一个镜像的版本。我们可以通过 <仓库名>:<标签> 的格式来指定具体是这个软件哪个版本的镜像。如果不给出标签，将以 latest 作为默认标签。
仓库名经常以 两段式路径 形式出现，比如jwilder/nginx-proxy，前者往往意味着 Docker 仓库 多用户环境下的用户名，后者则往往是对应的软件名
注册处 docker register 分为公有和私有
公有仓库
用户免费上传、下载公开的镜像，并可能提供收费服务供用户管理私有镜像
私有仓库
用户还可以在本地搭建私有 Docker Registry。Docker 官方提供了 Docker Registry 镜像，可以直接使用做为私有 Registry 服务

• Docker 安装

Docker 分为 CE 和 EE 两大版本。CE 即社区版（免费，支持周期 7 个月），EE 即企业版，强调安全，付费使用，支持周期 24 个月。

免费版CE

Ubuntu 安装 Docker CE
Windows 10 PC 安装 Docker Desktop CE
macOS 安装 Docker Desktop CE

镜像加速器

国内从 Docker Hub 拉取镜像有时会遇到困难，此时可以配置镜像加速器。国内很多云服务商都提供了国内加速器服务，例如：

• Azure 中国镜像 https://dockerhub.azk8s.cn
• 阿里云加速器(需登录账号获取)
• 七牛云加速器 https://reg-mirror.qiniu.com

由于镜像服务可能出现宕机，建议同时配置多个镜像。

linux
对于使用 systemd 的系统，请在 /etc/docker/daemon.json 中写入如下内容（如果文件不存在请新建该文件）

{
  "registry-mirrors": [
    "https://dockerhub.azk8s.cn",
    "https://reg-mirror.qiniu.com"
  ]
}

注意，一定要保证该文件符合 json 规范，否则 Docker 将不能启动。

之后重新启动服务。

$ sudo systemctl daemon-reload
$ sudo systemctl restart docker

windows
对于使用 Windows 10 的系统，在系统右下角托盘 Docker 图标内右键菜单选择 Settings，打开配置窗口后左侧导航菜单选择 Daemon。在 Registry mirrors 一栏中填写加速器地址 https://dockerhub.azk8s.cn(这里用Azure 镜像为例)，之后点击 Apply 保存后 Docker 就会重启并应用配置的镜像地址了。
macOS
对于使用 macOS 的用户，在任务栏点击 Docker Desktop 应用图标 -> Perferences... -> Daemon -> Registry mirrors。在列表中填写加速器地址 https://dockerhub.azk8s.cn。修改完成之后，点击 Apply & Restart 按钮，Docker 就会重启并应用配置的镜像地址了。
检查加速器是否生效
执行 $ docker info，如果从结果中看到了如下内容，说明配置成功。
Registry Mirrors:
https://dockerhub.azk8s.cn/

• 下面介镜像的使用

1.获取镜像

之前提到过，Docker Hub 上有大量的高质量的镜像可以用，这里我们就说一下怎么获取这些镜像。

从 Docker 镜像仓库获取镜像的命令是 docker pull。其命令格式为：

docker pull [选项] [Docker Registry 地址[:端口号]/]仓库名[:标签]

具体的选项可以通过 docker pull --help 命令看到，这里我们说一下镜像名称的格式。

• Docker 镜像仓库地址：地址的格式一般是 <域名/IP>[:端口号]。默认地址是 Docker Hub。
• 仓库名：如之前所说，这里的仓库名是两段式名称，即 <用户名>/<软件名>。对于 Docker Hub，如果不给出用户名，则默认为 library，也就是官方镜像

$ docker pull ubuntu:18.04

上面的命令中没有给出 Docker 镜像仓库地址，因此将会从 Docker Hub 获取镜像。而镜像名称是 ubuntu:18.04，因此将会获取官方镜像 library/ubuntu 仓库中标签为 18.04 的镜像

2.运行容器

以上面的 ubuntu:18.04 为例，如果我们打算启动里面的 bash 并且进行交互式操作的话，可以执行下面的命令。

docker run -it --rm \
    ubuntu:18.04 \
    bash

简要说明一下参数：

-it：这是两个参数，一个是 -i：交互式操作，一个是 -t 终端。我们这里打算进入 bash 执行一些命令并查看返回结果，因此我们需要交互式终端。
--rm：这个参数是说容器退出后随之将其删除。默认情况下，为了排障需求，退出的容器并不会立即删除，除非手动 docker rm。我们这里只是随便执行个命令，看看结果，不需要排障和保留结果，因此使用 --rm 可以避免浪费空间。
ubuntu:18.04：这是指用 ubuntu:18.04 镜像为基础来启动容器。
bash：放在镜像名后的是 命令，这里我们希望有个交互式 Shell，因此用的是 bash。

进入容器后，我们可以在 Shell 下操作，就好像是打开了一个虚拟机的shell 一样，就可以猥琐欲为了。（这里是练习是用来一个linux 系统的镜像）

3.列出镜像

要想列出已经下载下来的镜像，可以使用 docker image ls 命令。

$ docker image（s） ls
REPOSITORY           TAG                 IMAGE ID            CREATED             SIZE
redis                latest              5f515359c7f8        5 days ago          183 MB

列表包含了 仓库名、标签、镜像 ID、创建时间 以及 所占用的空间。
注意如果存在不同版本的同一镜像，他们可能公用一个基础镜像
因此实际镜像硬盘占用空间很可能要比这个列表镜像大小的总和要小的多。

4.查看镜像、容器、数据卷所占用的空间。

docker system df
TYPE                TOTAL               ACTIVE              SIZE                RECLAIMABLE
Images              24                  0                   1.992GB             1.992GB (100%)
Containers          1                   0                   62.82MB             62.82MB (100%)
Local Volumes       9                   0                   652.2MB             652.2MB (100%)
Build Cache                                                 0B                  0B

5.虚悬镜像

镜像名被转移到了新下载的镜像身上，而旧的镜像上的这个名称则被取消，从而成为了 <none>可以删除

REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
<none>              <none>              00285df0df87        5 days ago          342 MB

删除玄虚镜像

$ docker image prune  

6.列出部分镜像

根据仓库名列出镜像

$ docker image ls ubuntu
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
ubuntu              18.04               f753707788c5        4 weeks ago         127 MB

列出特定的某个镜像，也就是说指定仓库名和标签

$ docker image ls ubuntu:18.04
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
ubuntu              18.04               f753707788c5        4 weeks ago         127 MB

查看某个镜像之后建立的镜像

$ docker image ls -f since=mongo:3.2
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
redis               latest              5f515359c7f8        5 days ago          183 MB

查看某个镜像之前建立的镜像
$ docker image ls -f before=mongo:3.2

7.格式化镜像的输出

只列出id

$ docker image ls -q
5f515359c7f8
05a60462f8ba
fe9198c04d62

只包含镜像ID和仓库名：

$ docker image ls --format "{{.ID}}: {{.Repository}}"
5f515359c7f8: redis
05a60462f8ba: nginx

以表格等距显示，并且有标题行，和默认一样，不过自己定义列：

$ docker image ls --format "table {{.ID}}\t{{.Repository}}\t{{.Tag}}"
IMAGE ID            REPOSITORY          TAG
5f515359c7f8        redis               latest
05a60462f8ba        nginx               latest

8.删除本地镜像

可以使用 docker image rm 命令，其格式为:

$ docker image rm [选项] <镜像1> [<镜像2> ...]

<镜像> 可以是 镜像短 ID、镜像长 ID、镜像名 或者 镜像摘要
例如 可以用前三位 ID 来删除 下面的redis

$ docker image rm 501

使用镜像名 删除

$ docker image rm centos

使用摘要删除镜像

$ docker image rm repository名@digest值

$ docker image ls
REPOSITORY                  TAG                 IMAGE ID            CREATED             SIZE
centos                      latest              0584b3d2cf6d        3 weeks ago         196.5 MB
redis                       alpine              501ad78535f0        3 weeks ago         21.03 MB

docker image ls 默认列出的就已经是短 ID 了

$ docker image ls --digests
这个可以列出长ID  
$ docker image ls --digests
REPOSITORY                  TAG                 DIGEST                                                                    IMAGE ID            CREATED             SIZE
node                        slim                sha256:b4f0e0bdeb578043c1ea6862f0d40cc4afe32a4a582f3be235a3b164422be228   6e0c4c8e3913        3 weeks ago         214 MB

长ID 就是 digest 对应的值

9.镜像的删除状态

未删除：（Untagged ）
一个镜像可能对应多个标签，有可能只是删除了一个标签
镜像依赖：另外镜像是多层结构，删除的时候，可能某个镜像和删除的镜像公用一层，那么，也不会删除该层。
容器依赖：如果这个镜像有对应的容器存在（不管有没有运行）要把容器先删除才可以，删除 镜像 （容器是以镜像为基础，再加一层容器存储层）
删除（Deleted）

关于镜像的更多内容，这里就先不扩展了
详见：后面同级菜单 内容

• 使用 Dockerfile 定制镜像 （文末已经添加这个内容）

内容参见

• 操作 Docker 容器

容器是 Docker 又一核心概念。可以看做是镜像的实例
查看容器 docker container ls

1.启动容器

一、基于镜像新建一个容器并启动
二、将在终止状态（stopped）的容器重新启动。

因为 Docker 的容器实在太轻量级了，很多时候用户都是随时删除和新创建容器。

新建并启动

例如，下面的命令输出一个 “Hello World”，之后终止容器。
$ docker run ubuntu:18.04 /bin/echo 'Hello world'
Hello world

这跟在本地直接执行 /bin/echo 'hello world' 几乎感觉不出任何区别

启动一个容器的bash 终端
$ docker run -t -i ubuntu:18.04 /bin/bash
root@af8bae53bdd3:/#

docker run 启动新容器的过程

当利用 docker run 来创建容器时，Docker 在后台运行的标准操作包括：

1.检查本地是否存在指定的镜像，不存在就从公有仓库下载
2.利用镜像创建并启动一个容器
3.分配一个文件系统，并在只读的镜像层外面挂载一层可读写层
4.从宿主主机配置的网桥接口中桥接一个虚拟接口到容器中去
5.从地址池配置一个 ip 地址给容器
6.执行用户指定的应用程序
7.执行完毕后容器被终止

启动已终止容器

可以利用 docker container start 命令，直接将一个已经终止的容器启动运行。
容器的核心为所执行的应用程序，所需要的资源都是应用程序运行所必需的。除此之外，并没有其它的资源。可以在伪终端中利用 ps 或 top 来查看进程信息。
这种特点使得 Docker 对资源的利用率极高，是货真价实的轻量级虚拟化。

2.进入容器

进入容器进行操作，包括使用 docker attach 命令或 docker exec 命令，推荐大家使用 docker exec 命令，原因会在下面说明。
只介绍exec 命令
docker exec 后边可以跟多个参数，这里主要说明 -i -t 参数
当 -i -t 参数一起使用时，则可以看到我们熟悉的 Linux 命令提示符。

$ docker exec -it 69d1 bash
root@69d137adef7a:/#

这个 从 stdin 中 exit，不会导致容器的停止。（这就是为什么推荐用exec ）

3.导出和导入容器

本地导出某个容器

docker export

$ docker container ls -a
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                    PORTS               NAMES
7691a814370e        ubuntu:18.04        "/bin/bash"         36 hours ago        Exited (0) 21 hours ago                       test
$ docker export 7691a814370e > ubuntu.tar

这样就可以导出容器快照到本地文件 ubuntu.tar

导入容器快照

可以使用 docker import 从容器快照文件中再导入为镜像，例如

$ cat ubuntu.tar | docker import - test/ubuntu:v1.0
$ docker image ls
REPOSITORY          TAG                 IMAGE ID            CREATED              VIRTUAL SIZE
test/ubuntu         v1.0                9d37a6082e97        About a minute ago   171.3 MB

也可以通过指定 URL 或者某个目录来导入，例如

$ docker import http://example.com/exampleimage.tgz example/imagerepo

docker load 来导入镜像存储文件到本地镜像库 但是 会保存完整的镜像完完整的记录，体积较大 。 docker import 导入容器快照后，可以重新定义标签的等原数据

4.删除容器

$ docker container rm  -f  name

-f 可以删除正在运行的容器
清理所有已经终止的容器

$ docker container prune

• 使用 Dockerfile 定制镜像 （这个很重要）

内容参见

1.利用commit理解镜像的构成

容器是在镜像作为基础层，在镜像上面增加一个容器运行时的存储层。

docker run --name webserver -d -p 80:80 nginx

这条命令会用 nginx 镜像启动一个容器，命名为 webserver，并且映射了 80 端口，这样我们可以用浏览器去访问这个 nginx 服务器

docker exec -it webserver bash

我们以交互式终端方式进入 webserver 容器，并执行了 bash 命令，也就是获得一个可操作的 Shell。
如果进入容器进行修改的文件，也就是改动了容器的存储层。我们可以通过 docker diff 命令看到具体的改动。

$ docker diff webserver

运行一个容器后，（如果不使用卷）进入容器做的任何修改和变化，都会记录在容器的存储层。docker commit 命令可以将现在容器的存储层形成一层新的镜像，并加在现在已经存在的镜像上，形成新的镜像。新镜像会拥有容器变化后的文件

docker commit [选项] <容器ID或容器名> [<仓库名>[:<标签>]]

例如：

$ docker commit \
    --author "Tao Wang <twang2218@gmail.com>" \
    --message "修改了默认网页" \
    webserver \
    nginx:v2

--author 是指定修改的作者，而 --message 则是记录本次修改的内容。（这些可以不填，和git 类似）

docker image ls 就可以看到已经多了一个新的镜像

nginx               v2                  07e334659748        9 seconds ago       181.5 MB

查看镜像的历史：
（会显示，在nginx:latest 上增加了刚commit 的记录）

docker history nginx:v2
IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT
07e334659748        54 seconds ago      nginx -g daemon off;                            95 B                修改了默认网页
e43d811ce2f4        4 weeks ago         /bin/sh -c #(nop)  CMD ["nginx" "-g" "daemon    0 B

运行新commit 的镜像

docker run --name web2 -d -p 81:80 nginx:v2

因为容器一旦运行，就会产生很多文件垃圾等。所以一般不会用 docker commit 来制作新的镜像
而且用docker commit 制作的属于黑箱镜像，别人并不知道，你镜像里都是什么东西。这种镜像不纯洁的。
而且镜像是分层存储的，即新镜像依然保留上一层所有的东西，你一层层改东西，然后产生新镜像，这样一来，前一层即使不存在的文件，也会保留在新的镜像中，镜像体积越来越大了。爆了
（比如：v1:增加了 10m 的视频，提交新镜像v2,然后v2删除了，这个视频，然后加入20m 的视频，提交v3。现在v3 是3层结构，即基础镜像，和v1(含10m 视频) 和v2(含20m 视频) 和v3 本层。这样镜像的体积就是 30m+ 了。不能忍受的。好吗

2.利用Dockerfile 定制镜像

上面已经讲了一下 docker commit 来制作新镜像的过程。
基本命令式

docker  commit  容器   新镜像名 

commit 制作镜像的原理就是 一层层添加配置，这个过程其实可以用一个脚本来实现，这就是都dockerfile。 会解决镜像不透明，体积臃肿的问题。
docker file 包含了很多指令，一条指令构建一层
举例制作nginx 镜像：
进入一个新目录：
新建 名为 Dockerfile 的文本文件
里面写入：

FROM nginx
RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html

上面用了 FROM 和 RUN 两个命令

FROM

定制镜像必须制定一个基础镜像，就是在那个镜像之上进行配置新镜像。
因此dokcer file 第一指令必须是 FROM
1.预装软件镜像
在 Docker Hub 上有非常多的高质量的官方镜像
可以直接拿来作为基础镜像使用
如 nginx、redis、mongo、mysql、httpd、php、tomcat 等；
2.预装语言镜像
也有一些方便开发、构建、运行各种语言应用的镜像，如 node、openjdk、python、ruby、golang 等。可以在其中寻找一个最符合我们最终目标的镜像为基础镜像进行定制。

3.无预装 裸系统镜像
如果想使用只有操作系统的镜像。官方镜像中还提供了一些更为基础的操作系统镜像，如 ubuntu、debian、centos、fedora、alpine 等，这些操作系统的软件库为我们提供了更广阔的扩展空间。直接使用这些作为基础镜像，将更自由。任你发挥了

其实有一些软件并不需要任何镜像，直接是可运行的编译好的。比如那些二进制的。最好就是不用任何基础镜像（更轻便，灵活）
那就需要用一个空白镜像：

FROM scratch 
...

scratch 表示一个空白镜像

直接将可执行文件复制进镜像的做法并不罕见，比如 swarm、etcd。对于 Linux 下静态编译的程序来说，并不需要有操作系统提供运行时支持，所需的一切库都已经在可执行文件里了，因此直接 FROM scratch 会让镜像体积更加小巧。 Go 是特别适合容器微服务架构的语言，go 语言开发的应用很多用空白镜像制作。

RUN

RUN 就是执行命令的 可以理解为 $ 命令行
格式有两种：
shell 格式（像是直接运行命令行一样）

shell 格式：RUN <命令>

exec 格式：

RUN ["可执行文件", "参数1", "参数2"]  # 这更像是函数调用中的格式。

每一个 RUN 的行为都会新建立一层，然后commit ,所以，正确的做法是：

FROM debian:stretch

RUN buildDeps='gcc libc6-dev make wget' \
    && apt-get update \
    && apt-get install -y $buildDeps \
    && wget -O redis.tar.gz "http://download.redis.io/releases/redis-5.0.3.tar.gz" \
    && mkdir -p /usr/src/redis \
    && tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1 \
    && make -C /usr/src/redis \
    && make -C /usr/src/redis install \
    && rm -rf /var/lib/apt/lists/* \
    && rm redis.tar.gz \
    && rm -r /usr/src/redis \
    && apt-get purge -y --auto-remove $buildDeps

上面折磨多吗，命令只有一个run ，使用 && 将各个所需命令串联起来。只会产生一个镜像层。
Dockerfile 支持 Shell 类的行尾添加 \ 的命令换行方式，以及行首 # 进行注释的格式。以及适当使用缩进。

这一组命令的最后添加了清理工作的命令，删除了为了编译构建所需要的软件，清理了所有下载、展开的文件，并且还清理了 apt 缓存文件。以防止下一层积累无用东西 ，导致镜像臃肿。

初学 Docker 制作出了很臃肿的镜像的原因之一，就是忘记了每一层构建的最后一定要清理掉无关文件。

3. 运行 Dockerfile 创建镜像

在 Dockerfile 文件所在目录执行：
还是以上面两行的nginx为例：

$ docker build -t nginx:v3 .   # 注意这里有个  .  表示上下文
Sending build context to Docker daemon 2.048 kB
Step 1 : FROM nginx
 ---> e43d811ce2f4
Step 2 : RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html
 ---> Running in 9cdc27646c7b
 ---> 44aa4490ce2c
Removing intermediate container 9cdc27646c7b
Successfully built 44aa4490ce2c

上面的过程是 拿到基础镜像，使用run 运行一个容器，并在里面运行run 后面的命令，创建 44aa4490ce2c 镜像，然后删除运行的容器 9cdc27646c7b

构建镜像使用 docker build：
格式

docker build [选项] <上下文路径/URL/->

补充说明 . 上下文
docker build 的工作原理 简要说明：就是 把

虽然表面上我们好像是在本机执行各种 docker 功能，但实际上，一切都是使用的远程调用形式在服务端（Docker 引擎）完成。镜像实际是在远程的docker 服务端进行的。
既然是在服务端，如何获取本地文件。那就是上下文代表的路径
运行 docker build 是会把上下文指定的目录打包，上传到dokcer 服务端引擎。 所以所有用到的文件只能放在上下文的目录里。（因为构建时，是使用上下文打包的文件，其他文件够不到的）

一般来说，就是吧docerfile放到一个空目录下，然后把所需文件复制到这个文件夹。如果该目录下，有文件不想上传给docker引擎，就要 .gitignore 一样的语法写一个 .dockerignore，该文件是用于剔除不需要作为上下文传递给 Docker 引擎的。

为什么默认名为 Dockerfile ?:

如果不额外指定 Dockerfile 的话，会将上下文目录下的名为 Dockerfile 的文件作为 Dockerfile
其实可以用 -f ../Dockerfile 参数指定某个文件作为 Dockerfile （dockerfile 并不需要放在 上下文目录）

其他docker build 方法
直接使用 url :

$ docker build https://github.com/twang2218/gitlab-ce-zh.git  #:11.1

这行命令指定了构建所需的 Git repo，并且指定默认的 master 分支，构建目录为 /11.1/，然后 Docker 就会自己去 git clone 这个项目、切换到指定分支、并进入到指定目录后开始构建
用给定的 tar 压缩包构建

$ docker build http://server/context.tar.gz

Docker 引擎会下载这个包，并自动解压缩，以其作为上下文，开始构建。
从标准输出构建（应该不怎么用，不说了）

Dockerfile 指令详解

上面讲过了，使用dockerfile 生成镜像的过程。使用到了两个命令 RUN 和FROM 。接下来讲跟多的命令

其实 Dockerfile 功能很强大，它提供了十多个指令。下面我们继续讲解其他的指令。

1、COPY 复制文件

COPY  <源路径>... <目标路径>

源路径 是上下文路径 目标路径 是镜像 路径
（其实是运行容器的目录，然后commit 到镜像的目录，然后在删除容器...）
举例：

COPY package.json /usr/src/app/

注意：使用 COPY 指令，源文件的各种元数据都会保留。比如读、写、执行权限、文件变更时间等。

额外操作：改变所属用户和组

--chown=<user>:<group>

2、ADD 更高级的复制文件
ADD 指令和 COPY 的格式和性质基本一致。但是在 COPY 基础上增加了一些功能。

自动解压到目标路径：
<源路径> 为一个 tar 压缩文件的话，压缩格式为 gzip, bzip2 以及 xz 的情况下，ADD 指令将会自动解压缩这个压缩文件到 <目标路径> 去。

根据官方推荐，一律用 copy ,除非需要自动解压才用add

3、CMD 容器启动命令
CMD 指令的格式和 RUN 相似，也是两种格
shell 格式：CMD <命令>

CMD service nginx start

exec 格式：CMD ["可执行文件", "参数1", "参数2"...]

CMD ["nginx", "-g", "daemon off;"]

CMD 指令就是用于指定默认的容器主进程的启动命令的。
比如：
ubuntu 镜像默认的 CMD 是 /bin/bash，如果我们直接 docker run -it ubuntu 的话，会直接进入 bash。我们也可以在运行时指定运行别的命令。
一般推荐使用 exec 格式

Docker 不是虚拟机，容器中的应用都应该以前台执行，而不是像虚拟机、物理机里面那样，用 systemd 去启动后台服务，容器内没有后台服务的概念。
对于容器而言，其启动程序就是容器应用进程，容器就是为了主进程而存在的，主进程退出，容器就失去了存在的意义，从而退出，其它辅助进程不是它需要关心的东西

更多命令 有时间在写吧

• ENTRYPOINT 入口点
• ENV 设置环境变量
• ARG 构建参数
• VOLUME 定义匿名卷
• EXPOSE 暴露端口
• WORKDIR 指定工作目录
• USER 指定当前用户
• HEALTHCHECK 健康检查
• ONBUILD 为他人作嫁衣裳
• 参考文档
  因为编写docker file 的时候。每一层操作目录都是不相关的，
  因此如果需要改变以后各层的工作目录的位置，那么应该使用 WORKDIR 指令。

更多内容：

• 访问仓库

访问仓库

暂时省略把，有时间在写 。。。 哈哈哈哈

• 数据管理

数据管理
暂时省略把，有时间在写 。。。 哈哈哈哈

• 使用网络

使用网络
暂时省略把，有时间在写 。。。 哈哈哈哈

• 高级网络陪配置

高级网络配置
暂时省略把，有时间在写 。。。 哈哈哈哈

• Docker Compose 项目

Docker Compose 项目

Docker Compose 是 Docker 官方编排（Orchestration）项目之一，负责快速的部署分布式应用。
本章将介绍 Compose 项目情况以及安装和使用。

1.Compose 的简介

只举例django 的应用

• Docker Machine 项目

Docker Machine 项目

以后有时间在写吧， 哈哈哈哈。。。

• Docker 三剑客之 Docker Swarm

Docker 三剑客之 Docker Swarm
以后有时间在写吧， 哈哈哈哈。。。

• 容器与云计算

容器与云计算
以后有时间在写吧， 哈哈哈哈。。。

• 操作系统

操作系统
以后有时间在写吧， 哈哈哈哈。。。

• 附录

https://yeasy.gitbooks.io/docker_practice/appendix/

• Docker 命令查询

Docker 命令查询

linux $ dokcer

Management Commands:
  builder     Manage builds
  config      Manage Docker configs
  container   Manage containers
  engine      Manage the docker engine
  image       Manage images
  network     Manage networks
  node        Manage Swarm nodes
  plugin      Manage plugins
  secret      Manage Docker secrets
  service     Manage services
  stack       Manage Docker stacks
  swarm       Manage Swarm
  system      Manage Docker
  trust       Manage trust on Docker images
  volume      Manage volumes

Commands:
  attach      Attach local standard input, output, and error streams to 
a running container
  build       Build an image from a Dockerfile
  commit      Create a new image from a container's changes
  cp          Copy files/folders between a container and the local filesystem
  create      Create a new container
  diff        Inspect changes to files or directories on a container's filesystem
  events      Get real time events from the server
  exec        Run a command in a running container
  export      Export a container's filesystem as a tar archive
  history     Show the history of an image
  images      List images
  import      Import the contents from a tarball to create a filesystem image
  info        Display system-wide information
  inspect     Return low-level information on Docker objects
  kill        Kill one or more running containers
  load        Load an image from a tar archive or STDIN
  login       Log in to a Docker registry
  logout      Log out from a Docker registry
  logs        Fetch the logs of a container
  pause       Pause all processes within one or more containers
  port        List port mappings or a specific mapping for the container
  ps          List containers
  pull        Pull an image or a repository from a registry
  push        Push an image or a repository to a registry
  rename      Rename a container
  restart     Restart one or more containers
  rm          Remove one or more containers
  rmi         Remove one or more images
  run         Run a command in a new container
  save        Save one or more images to a tar archive (streamed to STDOUT by default)
  search      Search the Docker Hub for images
  start       Start one or more stopped containers
  stats       Display a live stream of container(s) resource usage statistics
  stop        Stop one or more running containers
  tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE
  top         Display the running processes of a container
  unpause     Unpause all processes within one or more containers
  update      Update configuration of one or more containers
  version     Show the Docker version information
  wait        Block until one or more containers stop, then print their exit codes