Merge branch 'master' of github.com:yeasy/docker_practice

2024-11-15 19:13:39 +00:00 · 2019-05-05 19:31:08 +08:00 · 2019-05-05 19:31:08 +08:00 · f7dcffc7be
commit f7dcffc7be
parent a17f3f6b2f 8576e16b61
75 changed files with 1121 additions and 369 deletions
--- a/.editorconfig
+++ b/.editorconfig
@ -1,4 +1,4 @@
-# EditorConfig is awesome: http://EditorConfig.org
+# EditorConfig is awesome: https://EditorConfig.org

 root = true

--- a/.gitattributes
+++ b/.gitattributes
@ -2,4 +2,4 @@

 *.sh        text eol=lf

-*.py        linguist-language=go
+*           linguist-language=go
--- a/.github/ISSUE_TEMPLATE/Bug_report.md
+++ b/.github/ISSUE_TEMPLATE/Bug_report.md
@ -12,11 +12,9 @@ about: Create a report to help us improve

 * [x] Linux
   * [x] CentOS 7
-   * [x] Ubuntu 14.04
+   * [x] Fedora
   * [x] Ubuntu 16.04 +
-   * [x] Debian 7
-   * [x] Debian 8 +
-   * [x] CoreOS
+   * [x] Debian 9 +
 * [x] macOS
 * [x] Windows 10
 * [x] Raspberry Pi (ARM)
--- a/.github/ISSUE_TEMPLATE/Custom.md
+++ b/.github/ISSUE_TEMPLATE/Custom.md
@ -12,11 +12,9 @@ about: Create a issue about Docker

 * [x] Linux
   * [x] CentOS 7
-   * [x] Ubuntu 14.04
+   * [x] Fedora
   * [x] Ubuntu 16.04 +
-   * [x] Debian 7
-   * [x] Debian 8 +
-   * [x] CoreOS
+   * [x] Debian 9 +
 * [x] macOS
 * [x] Windows 10
 * [x] Raspberry Pi (ARM)
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@ -1,20 +1,20 @@
 <!--
-    Thanks for your contribution. 
+    Thanks for your contribution.
    See [CONTRIBUTING](CONTRIBUTING.md) for contribution guidelines.
 -->

 ### Proposed changes (Mandatory)

 <!--
-    Tell us what you did and why: 
+    Tell us what you did and why:

    One line short description
-    
+
    And details in other paragraphs.
 -->

 ### Fix issues (Optional)

 <!--
-    Tell us what issues you fixed, e.g., fix #123 
+    Tell us what issues you fixed, e.g., fix #123
 -->
--- a/.travis.yml
+++ b/.travis.yml
@ -1,7 +1,8 @@
 language: bash
-sudo: required
+
 services:
 - docker
+
 before_install:
 - openssl aes-256-cbc -K $encrypted_6cc8cff04075_key -iv $encrypted_6cc8cff04075_iv
  -in .travis/id_rsa.enc -out ~/.ssh/id_rsa -d
@ -10,8 +11,10 @@ before_install:
 - date
 - git config --global user.name "khs1994"
 - git config --global user.email "khs1994@khs1994.com"
+
 script:
 - docker run -it --rm -v $PWD:/srv/gitbook-src yeasy/docker_practice build
+
 after_success:
 - sudo chmod -R 777 _book
 - echo "FROM nginx:1.13.8-alpine" >> Dockerfile
@ -29,14 +32,17 @@ after_success:
 - COMMIT=`date "+%F %T"`
 - git commit -m "Travis CI Site updated $COMMIT"
 - git push -f origin master:"$DEPLOY_BRANCH"
+
 env:
  global:
  - DEPLOY_BRANCH: pages
  # - DEPLOY_BRANCH: legacy-pages
  - REPO: git@github.com:yeasy/docker_practice.git
+
 addons:
  ssh_known_hosts:
  - github.com
+
 branches:
  only:
  - master
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,8 +1,13 @@
 ## 主要修订记录

+* 1.1.0 2019-06-30
+  * 增加 `BuildKit`
+  * 增加 `docker manifest` 命令使用说明
+  * 移除 `Ubuntu 14.04` `Debian 8` `Debian 7`
+  
 * 1.0.0: 2018-12-31
  * 全面支持 v18.x 新版本
-  * 添加如何调试 Docker 附录
+  * 添加如何调试 Docker
  * 错误修正

 * 0.9.0: 2017-12-31
--- a/README.md
+++ b/README.md
@ -1,12 +1,10 @@
 # Docker — 从入门到实践

-[![](https://img.shields.io/github/stars/yeasy/docker_practice.svg?style=social&label=Stars)](https://github.com/yeasy/docker_practice) ![](https://img.shields.io/docker/pulls/yeasy/docker_practice.svg) [![](https://travis-ci.org/yeasy/docker_practice.svg?branch=master)](https://travis-ci.org/yeasy/docker_practice) [![](https://img.shields.io/github/release/yeasy/docker_practice/all.svg)](https://github.com/yeasy/docker_practice/releases) [![](https://badges.gitter.im/docker_practice/Lobby.svg)](https://gitter.im/docker_practice/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![](https://img.shields.io/github/stars/yeasy/docker_practice.svg?style=social&label=Stars)](https://github.com/yeasy/docker_practice) [![](https://travis-ci.org/yeasy/docker_practice.svg?branch=master)](https://travis-ci.org/yeasy/docker_practice) [![](https://img.shields.io/github/release/yeasy/docker_practice/all.svg)](https://github.com/yeasy/docker_practice/releases) [![](https://img.shields.io/badge/Based-Docker%20CE%20v18.x-blue.svg)](https://github.com/docker/docker-ce) [![](https://img.shields.io/badge/Docker%20%E6%8A%80%E6%9C%AF%E5%85%A5%E9%97%A8%E4%B8%8E%E5%AE%9E%E6%88%98-jd.com-red.svg)](https://u.jd.com/tKZmVG)

-v1.0.0
+**v1.1.0**

-*说明：本书自 0.9.0 版本起基于最新的 Docker CE v18.X 特性进行讲解。Docker 旧版本（1.13-）使用，请参考 [docker-legacy](https://github.com/yeasy/docker_practice/tree/docker-legacy) 分支。*
-
-[Docker](http://www.docker.com) 是个划时代的开源项目，它彻底释放了计算虚拟化的威力，极大提高了应用的维护效率，降低了云计算应用开发的成本！使用 Docker，可以让应用的部署、测试和分发都变得前所未有的高效和轻松！
+[Docker](https://www.docker.com) 是个划时代的开源项目，它彻底释放了计算虚拟化的威力，极大提高了应用的维护效率，降低了云计算应用开发的成本！使用 Docker，可以让应用的部署、测试和分发都变得前所未有的高效和轻松！

 无论是应用开发者、运维人员、还是其他信息技术从业人员，都有必要认识和掌握 Docker，节约有限的生命。

@ -30,6 +28,7 @@ Docker 自身仍在快速发展中，生态环境也在蓬勃成长。建议初
 <p align="center"><strong>微信扫码 随时随地阅读~</strong></p>

 ## 技术交流
+
 欢迎加入 Docker 技术交流 QQ 群，分享 Docker 资源，交流 Docker 技术。

 * QQ 群 I   （已满）：341410255
@ -41,16 +40,17 @@ Docker 自身仍在快速发展中，生态环境也在蓬勃成长。建议初
 * QQ 群 VII （已满）：252403484
 * QQ 群 VIII（已满）：544818750
 * QQ 群 IX  （已满）：571502246
-* QQ 群 X   （可加）：145983035
+* QQ 群 X   （可加）：145983035

 >如果有问题，请通过 [Issues](https://github.com/yeasy/docker_practice/issues/new/choose) 来提出。

 ## 进阶学习
-![](_images/docker_primer3.png)

-《[Docker 技术入门与实战](http://item.jd.com/12453318.html)》第三版已经面世，介绍最新的容器技术栈，欢迎大家阅读使用并反馈建议。
+[![](https://github.com/yeasy/docker_practice/raw/master/_images/docker_primer3.png)](https://u.jd.com/tKZmVG)

-* [京东图书](https://item.jd.com/12453318.html)
+《[Docker 技术入门与实战](https://u.jd.com/tKZmVG)》第三版已经面世，介绍最新的容器技术栈，欢迎大家阅读使用并反馈建议。
+
+* [京东图书](https://u.jd.com/tKZmVG)
 * [China-Pub](http://product.china-pub.com/8052127)

 ## 鼓励项目
--- a/SUMMARY.md
+++ b/SUMMARY.md
@ -39,7 +39,10 @@
        * [HEALTHCHECK 健康检查](image/dockerfile/healthcheck.md)
        * [ONBUILD 为他人作嫁衣裳](image/dockerfile/onbuild.md)
        * [参考文档](image/dockerfile/references.md)
-    * [Dockerfile 多阶段构建](image/multistage-builds.md)
+    * [Dockerfile 多阶段构建](image/multistage-builds/README.md)
+        * [实战多阶段构建 Laravel 镜像](image/multistage-builds/laravel.md)
+    * [构建多种系统架构支持的 Docker 镜像](image/manifest.md)
+    * [使用 BuildKit 构建镜像](image/buildkit.md)
    * [其它制作镜像的方式](image/other.md)
    * [实现原理](image/internal.md)
 * [操作容器](container/README.md)
@ -142,6 +145,7 @@
    * [本章小结](cases/os/summary.md)
 * [实战案例-CI/CD](cases/ci/README.md)
    * [Drone](cases/ci/drone.md)
+    * [Travis CI](cases/ci/travis.md)
 * [Docker 开源项目](opensource/README.md)
    * [LinuxKit](opensource/linuxkit.md)
 * [附录](appendix/README.md)
@ -149,11 +153,12 @@
    * [附录二：热门镜像介绍](appendix/repo/README.md)
        * [Ubuntu](appendix/repo/ubuntu.md)
        * [CentOS](appendix/repo/centos.md)
+        * [Nginx](appendix/repo/nginx.md)
+        * [PHP](appendix/repo/php.md)
        * [MySQL](appendix/repo/mysql.md)
+        * [WordPress](appendix/repo/wordpress.md)
        * [MongoDB](appendix/repo/mongodb.md)
        * [Redis](appendix/repo/redis.md)
-        * [Nginx](appendix/repo/nginx.md)
-        * [WordPress](appendix/repo/wordpress.md)
        * [Node.js](appendix/repo/nodejs.md)
    * [附录三：Docker 命令查询](appendix/command/README.md)
    * [附录四：Dockerfile 最佳实践](appendix/best_practices.md)
--- a/advanced_network/README.md
+++ b/advanced_network/README.md
@ -6,7 +6,7 @@

 当 Docker 启动时，会自动在主机上创建一个 `docker0` 虚拟网桥，实际上是 Linux 的一个 bridge，可以理解为一个软件交换机。它会在挂载到它的网口之间进行转发。

-同时，Docker 随机分配一个本地未占用的私有网段（在 [RFC1918](http://tools.ietf.org/html/rfc1918) 中定义）中的一个地址给 `docker0` 接口。比如典型的 `172.17.42.1`，掩码为 `255.255.0.0`。此后启动的容器内的网口也会自动分配一个同一网段（`172.17.0.0/16`）的地址。
+同时，Docker 随机分配一个本地未占用的私有网段（在 [RFC1918](https://tools.ietf.org/html/rfc1918) 中定义）中的一个地址给 `docker0` 接口。比如典型的 `172.17.42.1`，掩码为 `255.255.0.0`。此后启动的容器内的网口也会自动分配一个同一网段（`172.17.0.0/16`）的地址。

 当创建一个 Docker 容器的时候，同时会创建了一对 `veth pair` 接口（当数据包发送到一个接口时，另外一个接口也可以收到相同的数据包）。这对接口一端在容器内，即 `eth0`；另一端在本地并被挂载到 `docker0` 网桥，名称以 `veth` 开头（例如 `vethAQI2QT`）。通过这种方式，主机可以跟容器通信，容器之间也可以相互通信。Docker 就创建了在主机和所有容器之间一个虚拟共享网络。

--- a/advanced_network/access_control.md
+++ b/advanced_network/access_control.md
@ -22,7 +22,7 @@ $sysctl -w net.ipv4.ip_forward=1
 #### 访问所有端口
 当启动 Docker 服务（即 dockerd）的时候，默认会添加一条转发策略到本地主机 iptables 的 FORWARD 链上。策略为通过（`ACCEPT`）还是禁止（`DROP`）取决于配置`--icc=true`（缺省值）还是 `--icc=false`。当然，如果手动指定 `--iptables=false` 则不会添加 `iptables` 规则。

-可见，默认情况下，不同容器之间是允许网络互通的。如果为了安全考虑，可以在 `/etc/docker/daemon.json` 文件中配置 `{"icc": false}` 来禁止它（Ubuntu 14.04 等使用 upstart 的系统在文件 `/etc/default/docker` 中配置 `DOCKER_OPTS=--icc=false`）。
+可见，默认情况下，不同容器之间是允许网络互通的。如果为了安全考虑，可以在 `/etc/docker/daemon.json` 文件中配置 `{"icc": false}` 来禁止它。

 #### 访问指定端口
 在通过 `-icc=false` 关闭网络访问后，还可以通过 `--link=CONTAINER_NAME:ALIAS` 选项来访问容器的开放端口。
--- a/appendix/best_practices.md
+++ b/appendix/best_practices.md
@ -1,6 +1,6 @@
 # Dockerfile 最佳实践

-本附录是笔者对 Docker 官方文档中 [Best practices for writing Dockerfiles](https://docs.docker.com/engine/userguide/eng-image/dockerfile_best-practices/) 的理解与翻译。
+本附录是笔者对 Docker 官方文档中 [Best practices for writing Dockerfiles](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/) 的理解与翻译。

 ## 一般性的指南和建议

@ -36,7 +36,7 @@

 下面是来自 `buildpack-deps` 镜像的例子：

-```docker
+```dockerfile
 RUN apt-get update && apt-get install -y \
  bzr \
  cvs \
@ -72,7 +72,7 @@ RUN apt-get update && apt-get install -y \

 >注意：如果你的字符串中包含空格，必须将字符串放入引号中或者对空格使用转义。如果字符串内容本身就包含引号，必须对引号使用转义。

-```docker
+```dockerfile
 # Set one or more individual labels
 LABEL com.example.version="0.0.1-beta"

@ -85,7 +85,7 @@ LABEL com.example.version.is-production=""

 一个镜像可以包含多个标签，但建议将多个标签放入到一个 `LABEL` 指令中。

-```docker
+```dockerfile
 # Set multiple labels at once, using line-continuation characters to break long lines
 LABEL vendor=ACME\ Incorporated \
      com.example.is-beta= \
@ -94,7 +94,7 @@ LABEL vendor=ACME\ Incorporated \
      com.example.release-date="2015-02-12"
 ```

-关于标签可以接受的键值对，参考 [Understanding object labels](https://docs.docker.com/engine/userguide/labels-custom-metadata/)。关于查询标签信息，参考 [Managing labels on objects](https://docs.docker.com/engine/userguide/labels-custom-metadata/#managing-labels-on-objects)。
+关于标签可以接受的键值对，参考 [Understanding object labels](https://docs.docker.com/config/labels-custom-metadata/)。关于查询标签信息，参考 [Managing labels on objects](https://docs.docker.com/config/labels-custom-metadata/)。

 ### RUN

@ -108,7 +108,7 @@ LABEL vendor=ACME\ Incorporated \

 永远将 `RUN apt-get update` 和 `apt-get install` 组合成一条 `RUN` 声明，例如：

-```docker
+```dockerfile
 RUN apt-get update && apt-get install -y \
        package-bar \
        package-baz \
@ -117,7 +117,7 @@ RUN apt-get update && apt-get install -y \

 将 `apt-get update` 放在一条单独的 `RUN` 声明中会导致缓存问题以及后续的 `apt-get install` 失败。比如，假设你有一个 `Dockerfile` 文件：

-```docker
+```dockerfile
 FROM ubuntu:18.04

 RUN apt-get update
@ -127,7 +127,7 @@ RUN apt-get install -y curl

 构建镜像后，所有的层都在 Docker 的缓存中。假设你后来又修改了其中的 `apt-get install` 添加了一个包：

-```docker
+```dockerfile
 FROM ubuntu:18.04

 RUN apt-get update
@ -139,7 +139,7 @@ Docker 发现修改后的 `RUN apt-get update` 指令和之前的完全一样。

 使用 `RUN apt-get update && apt-get install -y` 可以确保你的 Dockerfiles 每次安装的都是包的最新的版本，而且这个过程不需要进一步的编码或额外干预。这项技术叫作 `cache busting`。你也可以显示指定一个包的版本号来达到 `cache-busting`，这就是所谓的固定版本，例如：

-```docker
+```dockerfile
 RUN apt-get update && apt-get install -y \
    package-bar \
    package-baz \
@ -150,7 +150,7 @@ RUN apt-get update && apt-get install -y \

 下面是一个 `RUN` 指令的示例模板，展示了所有关于 `apt-get` 的建议。

-```docker
+```dockerfile
 RUN apt-get update && apt-get install -y \
    aufs-tools \
    automake \
@ -193,7 +193,7 @@ RUN apt-get update && apt-get install -y \

 最后，`ENV` 也能用于设置常见的版本号，比如下面的示例：

-```docker
+```dockerfile
 ENV PG_MAJOR 9.3

 ENV PG_VERSION 9.3.4
@ -211,7 +211,7 @@ ENV PATH /usr/local/postgres-$PG_MAJOR/bin:$PATH

 如果你的 `Dockerfile` 有多个步骤需要使用上下文中不同的文件。单独 `COPY` 每个文件，而不是一次性的 `COPY` 所有文件，这将保证每个步骤的构建缓存只在特定的文件变化时失效。例如：

-```docker
+```dockerfile
 COPY requirements.txt /tmp/

 RUN pip install --requirement /tmp/requirements.txt
@ -223,7 +223,7 @@ COPY . /tmp/

 为了让镜像尽量小，最好不要使用 `ADD` 指令从远程 URL 获取包，而是使用 `curl` 和 `wget`。这样你可以在文件提取完之后删掉不再需要的文件来避免在镜像中额外添加一层。比如尽量避免下面的用法：

-```docker
+```dockerfile
 ADD http://example.com/big.tar.xz /usr/src/things/

 RUN tar -xJf /usr/src/things/big.tar.xz -C /usr/src/things
@ -233,7 +233,7 @@ RUN make -C /usr/src/things all

 而是应该使用下面这种方法：

-```docker
+```dockerfile
 RUN mkdir -p /usr/src/things \
    && curl -SL http://example.com/big.tar.xz \
    | tar -xJC /usr/src/things \
@ -250,7 +250,7 @@ RUN mkdir -p /usr/src/things \

 例如，下面的示例镜像提供了命令行工具 `s3cmd`:

-```docker
+```dockerfile
 ENTRYPOINT ["s3cmd"]

 CMD ["--help"]
@ -295,7 +295,7 @@ exec "$@"

 该辅助脚本被拷贝到容器，并在容器启动时通过 `ENTRYPOINT` 执行：

-```docker
+```dockerfile
 COPY ./docker-entrypoint.sh /

 ENTRYPOINT ["/docker-entrypoint.sh"]
@ -339,6 +339,6 @@ $ docker run --rm -it postgres bash

 为了清晰性和可靠性，你应该总是在 `WORKDIR` 中使用绝对路径。另外，你应该使用 `WORKDIR` 来替代类似于 `RUN cd ... && do-something` 的指令，后者难以阅读、排错和维护。

-## 官方仓库示例
+## 官方镜像示例

-这些官方仓库的 Dockerfile 都是参考典范：https://github.com/docker-library/docs
+这些官方镜像的 Dockerfile 都是参考典范：https://github.com/docker-library/docs
--- a/appendix/faq/README.md
+++ b/appendix/faq/README.md
@ -30,7 +30,7 @@

 * 使用 Dockerfile 创建镜像时候要添加 .dockerignore 文件或使用干净的工作目录。

-更多内容请查看 [Dockerfile 最佳实践](https://docs.docker.com/engine/userguide/eng-image/dockerfile_best-practices/)
+更多内容请查看 [Dockerfile 最佳实践](../best_practices.md)

 ### 碰到网络问题，无法 pull 镜像，命令行指定 http_proxy 无效？

@ -82,7 +82,7 @@ $ docker run --network=my-net --ip=172.25.3.3 -itd --name=my-container busybox

 ### 可以在一个容器中同时运行多个应用进程么？

-答：一般并不推荐在同一个容器内运行多个应用进程。如果有类似需求，可以通过一些额外的进程管理机制，比如 `supervisord` 来管理所运行的进程。可以参考 https://docs.docker.com/engine/admin/multi-service_container/ 。
+答：一般并不推荐在同一个容器内运行多个应用进程。如果有类似需求，可以通过一些额外的进程管理机制，比如 `supervisord` 来管理所运行的进程。可以参考 https://docs.docker.com/config/containers/multi-service_container/ 。

 ### 如何控制容器占用系统资源（CPU、内存）的份额？

@ -100,7 +100,7 @@ $ docker run --network=my-net --ip=172.25.3.3 -itd --name=my-container busybox

 ### Docker 的配置文件放在哪里，如何修改配置？

-答：使用 `upstart` 的系统（如 Ubuntu 14.04）的配置文件在 `/etc/default/docker`，使用 `systemd` 的系统（如 Ubuntu 16.04、Centos 等）的配置文件在 `/etc/docker/daemon.json`。
+答：使用 `systemd` 的系统（如 Ubuntu 16.04、Centos 等）的配置文件在 `/etc/docker/daemon.json`。


 ### 如何更改 Docker 的默认存储位置？
--- a/appendix/repo/php.md
+++ b/appendix/repo/php.md
@ -0,0 +1,19 @@
+## [PHP](https://hub.docker.com/_/php/)
+
+### 基本信息
+
+[PHP](https://en.wikipedia.org/wiki/php)（Hypertext Preprocessor 超文本预处理器的字母缩写）是一种被广泛应用的开放源代码的多用途脚本语言，它可嵌入到 HTML 中，尤其适合 web 开发。
+
+该仓库位于 `https://hub.docker.com/_/php/` ，提供了 PHP 5.x ~ 7.x 各个版本的镜像。
+
+### 使用方法
+
+下面的命令将运行一个已有的 PHP 脚本。
+
+```bash
+$ docker run -it --rm -v "$PWD":/app -w /app php:alpine php your-script.php
+```
+
+### Dockerfile
+
+请到 https://github.com/docker-library/docs/tree/master/php 查看。
--- a/appendix/repo/redis.md
+++ b/appendix/repo/redis.md
@ -11,13 +11,13 @@
 默认会在 `6379` 端口启动数据库。

 ```bash
-$ docker run --name some-redis -d redis
+$ docker run --name some-redis -d -p 6379:6379 redis
 ```

-另外还可以启用 [持久存储](http://redis.io/topics/persistence)。
+另外还可以启用 [持久存储](https://redis.io/topics/persistence)。

 ```bash
-$ docker run --name some-redis -d redis redis-server --appendonly yes
+$ docker run --name some-redis -d -p 6379:6379 redis redis-server --appendonly yes
 ```

 默认数据存储位置在 `VOLUME/data`。可以使用 `--volumes-from some-volume-container` 或 `-v /docker/host/dir:/data` 将数据存放到本地。
--- a/basic_concept/container.md
+++ b/basic_concept/container.md
@ -4,7 +4,7 @@

 容器的实质是进程，但与直接在宿主执行的进程不同，容器进程运行于属于自己的独立的 [命名空间](https://en.wikipedia.org/wiki/Linux_namespaces)。因此容器可以拥有自己的 `root` 文件系统、自己的网络配置、自己的进程空间，甚至自己的用户 ID 空间。容器内的进程是运行在一个隔离的环境里，使用起来，就好像是在一个独立于宿主的系统下操作一样。这种特性使得容器封装的应用比直接在宿主运行更加安全。也因为这种隔离的特性，很多人初学 Docker 时常常会混淆容器和虚拟机。

-前面讲过镜像使用的是分层存储，容器也是如此。每一个容器运行时，是以镜像为基础层，在其上创建一个当前容器的存储层，我们可以称这个为容器运行时读写而准备的存储层为**容器存储层**。
+前面讲过镜像使用的是分层存储，容器也是如此。每一个容器运行时，是以镜像为基础层，在其上创建一个当前容器的存储层，我们可以称这个为容器运行时读写而准备的存储层为 **容器存储层**。

 容器存储层的生存周期和容器一样，容器消亡时，容器存储层也随之消亡。因此，任何保存于容器存储层的信息都会随容器删除而丢失。

--- a/basic_concept/repository.md
+++ b/basic_concept/repository.md
@ -2,11 +2,11 @@

 镜像构建完成后，可以很容易的在当前宿主机上运行，但是，如果需要在其它服务器上使用这个镜像，我们就需要一个集中的存储、分发镜像的服务，[Docker Registry](../repository/registry.md) 就是这样的服务。

-一个 **Docker Registry** 中可以包含多个**仓库**（`Repository`）；每个仓库可以包含多个**标签**（`Tag`）；每个标签对应一个镜像。
+一个 **Docker Registry** 中可以包含多个 **仓库**（`Repository`）；每个仓库可以包含多个 **标签**（`Tag`）；每个标签对应一个镜像。

 通常，一个仓库会包含同一个软件不同版本的镜像，而标签就常用于对应该软件的各个版本。我们可以通过 `<仓库名>:<标签>` 的格式来指定具体是这个软件哪个版本的镜像。如果不给出标签，将以 `latest` 作为默认标签。

-以 [Ubuntu 镜像](https://hub.docker.com/_/ubuntu) 为例，`ubuntu` 是仓库的名字，其内包含有不同的版本标签，如，`16.04`, `18.04`。我们可以通过 `ubuntu:14.04`，或者 `ubuntu:18.04` 来具体指定所需哪个版本的镜像。如果忽略了标签，比如 `ubuntu`，那将视为 `ubuntu:latest`。
+以 [Ubuntu 镜像](https://hub.docker.com/_/ubuntu) 为例，`ubuntu` 是仓库的名字，其内包含有不同的版本标签，如，`16.04`, `18.04`。我们可以通过 `ubuntu:16.04`，或者 `ubuntu:18.04` 来具体指定所需哪个版本的镜像。如果忽略了标签，比如 `ubuntu`，那将视为 `ubuntu:latest`。

 仓库名经常以 *两段式路径* 形式出现，比如 `jwilder/nginx-proxy`，前者往往意味着 Docker Registry 多用户环境下的用户名，后者则往往是对应的软件名。但这并非绝对，取决于所使用的具体 Docker Registry 的软件或服务。

@ -14,7 +14,7 @@

 Docker Registry 公开服务是开放给用户使用、允许用户管理镜像的 Registry 服务。一般这类公开服务允许用户免费上传、下载公开的镜像，并可能提供收费服务供用户管理私有镜像。

-最常使用的 Registry 公开服务是官方的 [Docker Hub](https://hub.docker.com/)，这也是默认的 Registry，并拥有大量的高质量的官方镜像。除此以外，还有 [CoreOS](https://coreos.com/) 的 [Quay.io](https://quay.io/repository/)，CoreOS 相关的镜像存储在这里；Google 的 [Google Container Registry](https://cloud.google.com/container-registry/)，[Kubernetes](http://kubernetes.io/) 的镜像使用的就是这个服务。
+最常使用的 Registry 公开服务是官方的 [Docker Hub](https://hub.docker.com/)，这也是默认的 Registry，并拥有大量的高质量的官方镜像。除此以外，还有 [CoreOS](https://coreos.com/) 的 [Quay.io](https://quay.io/repository/)，CoreOS 相关的镜像存储在这里；Google 的 [Google Container Registry](https://cloud.google.com/container-registry/)，[Kubernetes](https://kubernetes.io/) 的镜像使用的就是这个服务。

 由于某些原因，在国内访问这些服务可能会比较慢。国内的一些云服务商提供了针对 Docker Hub 的镜像服务（`Registry Mirror`），这些镜像服务被称为**加速器**。常见的有 [阿里云加速器](https://cr.console.aliyun.com/#/accelerator)、[DaoCloud 加速器](https://www.daocloud.io/mirror#accelerator-doc) 等。使用加速器会直接从国内的地址下载 Docker Hub 的镜像，比直接从 Docker Hub 下载速度会提高很多。在 [安装 Docker](../install/mirror.md)  一节中有详细的配置方法。

@ -26,4 +26,4 @@ Docker Registry 公开服务是开放给用户使用、允许用户管理镜像

 开源的 Docker Registry 镜像只提供了 [Docker Registry API](https://docs.docker.com/registry/spec/api/) 的服务端实现，足以支持 `docker` 命令，不影响使用。但不包含图形界面，以及镜像维护、用户管理、访问控制等高级功能。在官方的商业化版本 [Docker Trusted Registry](https://docs.docker.com/datacenter/dtr/2.0/) 中，提供了这些高级功能。

-除了官方的 Docker Registry 外，还有第三方软件实现了 Docker Registry API，甚至提供了用户界面以及一些高级功能。比如，[VMWare Harbor](https://github.com/vmware/harbor) 和 [Sonatype Nexus](https://www.sonatype.com/docker)。
+除了官方的 Docker Registry 外，还有第三方软件实现了 Docker Registry API，甚至提供了用户界面以及一些高级功能。比如，[Harbor](https://github.com/goharbor/harbor) 和 [Sonatype Nexus](../repository/nexus3_registry.md)。
--- a/cases/ci/demo/travis/.travis.yml
+++ b/cases/ci/demo/travis/.travis.yml
@ -0,0 +1,16 @@
+language: bash
+
+dist: xenial
+
+services:
+  - docker
+
+before_script:
+  - echo "$DOCKER_PASSWORD" | docker login -u "$DOCKER_USERNAME" --password-stdin
+
+script:
+  - echo "test code"
+
+after_success:
+  - docker build -t username/alpine .
+  - docker push username/alpine
--- a/cases/ci/demo/travis/Dockerfile
+++ b/cases/ci/demo/travis/Dockerfile
@ -0,0 +1,3 @@
+FROM alpine
+
+RUN echo "Hello World"
--- a/cases/ci/drone.md
+++ b/cases/ci/drone.md
@ -67,7 +67,7 @@ services:
    dns: 114.114.114.114

 volumes:
-  drone-data:    
+  drone-data:
 ```

 替换 `${SSL_PATH}` 为你网站的 SSL 证书路径。
@ -117,7 +117,7 @@ package main

 import "fmt"

-func main(){  
+func main(){
    fmt.Printf("Hello World!");
 }
 ```
--- a/cases/ci/travis.md
+++ b/cases/ci/travis.md
@ -0,0 +1,47 @@
+## 在 Travis CI 中使用 Docker
+
+当代码提交到 GitHub 时，[Travis CI](https://travis-ci.com/) 会根据项目根目录 `.travis.yml` 文件设置的指令，执行一系列操作。
+
+本小节介绍如何在 Travis CI 中使用 Docker 进行持续集成/持续部署（CI/CD）。这里以当代码提交到 GitHub 时自动构建 Docker 镜像并推送到 Docker Hub 为例进行介绍。
+
+### 准备
+
+首先登录 https://travis-ci.com/account/repositories 选择 GitHub 仓库，按照指引安装 GitHub App 来启用 GitHub 仓库构建。
+
+在项目根目录新建一个 `Dockerfile` 文件。
+
+```dockerfile
+FROM alpine
+
+RUN echo "Hello World"
+```
+
+新建 Travis CI 配置文件 `.travis.yml` 文件。
+
+```yml
+language: bash
+
+dist: xenial
+
+services:
+  - docker
+
+before_script:
+  # 登录到 docker hub
+  - echo "$DOCKER_PASSWORD" | docker login -u "$DOCKER_USERNAME" --password-stdin
+
+script:
+  # 这里编写测试代码的命令
+  - echo "test code"
+
+after_success:
+  # 当代码测试通过后执行的命令
+  - docker build -t username/alpine .
+  - docker push username/alpine
+```
+
+> 请提前在 Travis CI 仓库设置页面配置 `DOCKER_PASSWORD` `DOCKER_USERNAME` 变量
+
+### 查看结果
+
+将项目推送到 GitHub, 登录 [Travis CI](https://travis-ci.com/) 查看构建详情。
--- a/cases/os/alpine.md
+++ b/cases/os/alpine.md
@ -56,7 +56,7 @@ $ apk --update add --no-cache <package>

 ### 相关资源

-* `Alpine` 官网：http://alpinelinux.org/
+* `Alpine` 官网：https://www.alpinelinux.org/
 * `Alpine` 官方仓库：https://github.com/alpinelinux
 * `Alpine` 官方镜像：https://hub.docker.com/_/alpine/
 * `Alpine` 官方镜像仓库：https://github.com/gliderlabs/docker-alpine
--- a/cases/os/debian.md
+++ b/cases/os/debian.md
@ -56,7 +56,6 @@ crashsystems/gitlab-docker           A trusted, regularly updated build of GitL.
 sylvainlasnier/memcached             This is a Memcached 1.4.14 docker images b...   16                   [OK]
 ubuntu-upstart                       Upstart is an event-based replacement for ...   16        [OK]
 mbentley/ubuntu-django-uwsgi-nginx                                                   16                   [OK]
-ansible/ubuntu14.04-ansible          Ubuntu 14.04 LTS with ansible                   15                   [OK]
 clue/ttrss                           The Tiny Tiny RSS feed reader allows you t...   14                   [OK]
 dockerfile/ubuntu-desktop            Trusted automated Ubuntu Desktop (LXDE) (h...   14                   [OK]
 tutum/ubuntu                         Ubuntu image with SSH access. For the root...   12                   [OK]
--- a/compose/compose_file.md
+++ b/compose/compose_file.md
@ -223,7 +223,7 @@ environment:
  - SESSION_SECRET
 ```

-如果变量名称或者值中用到 `true|false，yes|no` 等表达 [布尔](http://yaml.org/type/bool.html) 含义的词汇，最好放到引号里，避免 YAML 自动解析某些内容为对应的布尔语义。这些特定词汇，包括
+如果变量名称或者值中用到 `true|false，yes|no` 等表达 [布尔](https://yaml.org/type/bool.html) 含义的词汇，最好放到引号里，避免 YAML 自动解析某些内容为对应的布尔语义。这些特定词汇，包括

 ```bash
 y|Y|yes|Yes|YES|n|N|no|No|NO|true|True|TRUE|false|False|FALSE|on|On|ON|off|Off|OFF
--- a/compose/django.md
+++ b/compose/django.md
@ -1,6 +1,6 @@
 ## 使用 Django

-本小节内容适合 `Python` 开发人员阅读。
+> 本小节内容适合 `Python` 开发人员阅读。

 我们现在将使用 `Docker Compose` 配置并运行一个 `Django/PostgreSQL` 应用。

@ -8,7 +8,7 @@

 第一步，因为应用将要运行在一个满足所有环境依赖的 Docker 容器里面，那么我们可以通过编辑 `Dockerfile` 文件来指定 Docker 容器要安装内容。内容如下：

-```docker
+```dockerfile
 FROM python:3
 ENV PYTHONUNBUFFERED 1
 RUN mkdir /code
--- a/compose/rails.md
+++ b/compose/rails.md
@ -1,6 +1,6 @@
 ## 使用 Rails

-本小节内容适合 `Ruby` 开发人员阅读。
+> 本小节内容适合 `Ruby` 开发人员阅读。

 我们现在将使用 `Compose` 配置并运行一个 `Rails/PostgreSQL` 应用。

@ -8,7 +8,7 @@

 首先，因为应用将要运行在一个满足所有环境依赖的 Docker 容器里面，那么我们可以通过编辑 `Dockerfile` 文件来指定 Docker 容器要安装内容。内容如下：

-```docker
+```dockerfile
 FROM ruby
 RUN apt-get update -qq && apt-get install -y build-essential libpq-dev
 RUN mkdir /myapp
--- a/compose/usage.md
+++ b/compose/usage.md
@ -40,7 +40,7 @@ if __name__ == "__main__":

 编写 `Dockerfile` 文件，内容为

-```docker
+```dockerfile
 FROM python:3.6-alpine
 ADD . /code
 WORKDIR /code
@ -60,7 +60,7 @@ services:
    build: .
    ports:
     - "5000:5000"
-     
+
  redis:
    image: "redis:alpine"
 ```
--- a/compose/wordpress.md
+++ b/compose/wordpress.md
@ -1,6 +1,6 @@
 ## 使用 WordPress

-本小节内容适合 `PHP` 开发人员阅读。
+> 本小节内容适合 `PHP` 开发人员阅读。

 `Compose` 可以很便捷的让 `Wordpress` 运行在一个独立的环境中。

--- a/container/attach_exec.md
+++ b/container/attach_exec.md
@ -6,7 +6,7 @@

 ### `attach` 命令

-`docker attach` 是 Docker 自带的命令。下面示例如何使用该命令。
+下面示例如何使用 `docker attach` 命令。

 ```bash
 $ docker run -dit ubuntu
--- a/coreos/intro_tools.md
+++ b/coreos/intro_tools.md
@ -13,10 +13,8 @@ UUID		  APP	  IMAGE NAME			            STATE	  CREATED		    STARTED		   NETWORKS
 57581644	etcd	quay.io/coreos/etcd:v3.2.10	running	1 minute ago	1 minute ago
 ```

-`etcd` 使用方法请查看 [etcd 章节](../etcd/)。 
+`etcd` 使用方法请查看 [etcd 章节](../etcd/)。

 ## 容器管理

 第二个组件就是 `Docker`，它用来运行你的代码和应用。`CoreOS` 内置 `Docker`，具体使用请参考本书其他章节。
-
-`CoreOS` 也内置了由自己开发的容器 `Rkt`，`Rkt` 不属于本书的讨论范围，这里不再赘述。
--- a/data_management/bind-mounts.md
+++ b/data_management/bind-mounts.md
@ -69,7 +69,7 @@ $ docker run --rm -it \

 root@2affd44b4667:/# history
 1  ls
-2  diskutil list   
+2  diskutil list
 ```

 这样就可以记录在容器输入过的命令了。
--- a/etcd/cluster.md
+++ b/etcd/cluster.md
@ -14,7 +14,7 @@ services:
      - node1-data:/etcd-data
    expose:
      - 2379
-      - 2380      
+      - 2380
    networks:
      cluster_net:
        ipv4_address: 172.16.238.100
--- a/etcd/demo/cluster/docker-compose.yml
+++ b/etcd/demo/cluster/docker-compose.yml
@ -7,7 +7,7 @@ services:
      - node1-data:/etcd-data
    expose:
      - 2379
-      - 2380      
+      - 2380
    networks:
      cluster_net:
        ipv4_address: 172.16.238.100
--- a/etcd/intro.md
+++ b/etcd/intro.md
@ -6,7 +6,7 @@

 `etcd` 目前在 [github.com/coreos/etcd](https://github.com/coreos/etcd) 进行维护。

-受到 [Apache ZooKeeper](http://zookeeper.apache.org/) 项目和 [doozer](https://github.com/ha/doozerd) 项目的启发，`etcd` 在设计的时候重点考虑了下面四个要素：
+受到 [Apache ZooKeeper](https://zookeeper.apache.org/) 项目和 [doozer](https://github.com/ha/doozerd) 项目的启发，`etcd` 在设计的时候重点考虑了下面四个要素：

 * 简单：具有定义良好、面向用户的 `API` ([gRPC](https://github.com/grpc/grpc))

--- a/image/build.md
+++ b/image/build.md
@ -2,7 +2,7 @@

 从刚才的 `docker commit` 的学习中，我们可以了解到，镜像的定制实际上就是定制每一层所添加的配置、文件。如果我们可以把每一层修改、安装、构建、操作的命令都写入一个脚本，用这个脚本来构建、定制镜像，那么之前提及的无法重复的问题、镜像构建透明性的问题、体积的问题就都会解决。这个脚本就是 Dockerfile。

-Dockerfile 是一个文本文件，其内包含了一条条的**指令(Instruction)**，每一条指令构建一层，因此每一条指令的内容，就是描述该层应当如何构建。
+Dockerfile 是一个文本文件，其内包含了一条条的 **指令(Instruction)**，每一条指令构建一层，因此每一条指令的内容，就是描述该层应当如何构建。

 还以之前定制 `nginx` 镜像为例，这次我们使用 Dockerfile 来定制。

@ -25,7 +25,7 @@ RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html

 ### FROM 指定基础镜像

-所谓定制镜像，那一定是以一个镜像为基础，在其上进行定制。就像我们之前运行了一个 `nginx` 镜像的容器，再进行修改一样，基础镜像是必须指定的。而 `FROM` 就是指定**基础镜像**，因此一个 `Dockerfile` 中 `FROM` 是必备的指令，并且必须是第一条指令。
+所谓定制镜像，那一定是以一个镜像为基础，在其上进行定制。就像我们之前运行了一个 `nginx` 镜像的容器，再进行修改一样，基础镜像是必须指定的。而 `FROM` 就是指定 **基础镜像**，因此一个 `Dockerfile` 中 `FROM` 是必备的指令，并且必须是第一条指令。

 在 [Docker Hub](https://hub.docker.com/search?q=&type=image&image_filter=official) 上有非常多的高质量的官方镜像，有可以直接拿来使用的服务类的镜像，如 [`nginx`](https://hub.docker.com/_/nginx/)、[`redis`](https://hub.docker.com/_/redis/)、[`mongo`](https://hub.docker.com/_/mongo/)、[`mysql`](https://hub.docker.com/_/mysql/)、[`httpd`](https://hub.docker.com/_/httpd/)、[`php`](https://hub.docker.com/_/php/)、[`tomcat`](https://hub.docker.com/_/tomcat/) 等；也有一些方便开发、构建、运行各种语言应用的镜像，如 [`node`](https://hub.docker.com/_/node)、[`openjdk`](https://hub.docker.com/_/openjdk/)、[`python`](https://hub.docker.com/_/python/)、[`ruby`](https://hub.docker.com/_/ruby/)、[`golang`](https://hub.docker.com/_/golang/) 等。可以在其中寻找一个最符合我们最终目标的镜像为基础镜像进行定制。

@ -132,9 +132,9 @@ docker build [选项] <上下文路径/URL/->

 ### 镜像构建上下文（Context）

-如果注意，会看到 `docker build` 命令最后有一个 `.`。`.` 表示当前目录，而 `Dockerfile` 就在当前目录，因此不少初学者以为这个路径是在指定 `Dockerfile` 所在路径，这么理解其实是不准确的。如果对应上面的命令格式，你可能会发现，这是在指定**上下文路径**。那么什么是上下文呢？
+如果注意，会看到 `docker build` 命令最后有一个 `.`。`.` 表示当前目录，而 `Dockerfile` 就在当前目录，因此不少初学者以为这个路径是在指定 `Dockerfile` 所在路径，这么理解其实是不准确的。如果对应上面的命令格式，你可能会发现，这是在指定 **上下文路径**。那么什么是上下文呢？

-首先我们要理解 `docker build` 的工作原理。Docker 在运行时分为 Docker 引擎（也就是服务端守护进程）和客户端工具。Docker 的引擎提供了一组 REST API，被称为 [Docker Remote API](https://docs.docker.com/engine/reference/api/docker_remote_api/)，而如 `docker` 命令这样的客户端工具，则是通过这组 API 与 Docker 引擎交互，从而完成各种功能。因此，虽然表面上我们好像是在本机执行各种 `docker` 功能，但实际上，一切都是使用的远程调用形式在服务端（Docker 引擎）完成。也因为这种 C/S 设计，让我们操作远程服务器的 Docker 引擎变得轻而易举。
+首先我们要理解 `docker build` 的工作原理。Docker 在运行时分为 Docker 引擎（也就是服务端守护进程）和客户端工具。Docker 的引擎提供了一组 REST API，被称为 [Docker Remote API](https://docs.docker.com/develop/sdk/)，而如 `docker` 命令这样的客户端工具，则是通过这组 API 与 Docker 引擎交互，从而完成各种功能。因此，虽然表面上我们好像是在本机执行各种 `docker` 功能，但实际上，一切都是使用的远程调用形式在服务端（Docker 引擎）完成。也因为这种 C/S 设计，让我们操作远程服务器的 Docker 引擎变得轻而易举。

 当我们进行镜像构建的时候，并非所有定制都会通过 `RUN` 指令完成，经常会需要将一些本地文件复制进镜像，比如通过 `COPY` 指令、`ADD` 指令等。而 `docker build` 命令构建镜像，其实并非在本地构建，而是在服务端，也就是 Docker 引擎中构建的。那么在这种客户端/服务端的架构中，如何才能让服务端获得本地文件呢？

--- a/image/buildkit.md
+++ b/image/buildkit.md
@ -0,0 +1,178 @@
+## 使用 `BuildKit` 构建镜像
+
+**BuildKit** 是下一代的镜像构建组件，在 https://github.com/moby/buildkit 开源。
+
+**注意：如果您的镜像构建使用的是云服务商提供的镜像构建服务（Docker Hub 自动构建、腾讯云容器服务、阿里云容器服务等），由于上述服务提供商的 Docker 版本低于 18.09，BuildKit 无法使用，将造成镜像构建失败。建议使用 BuildKit 构建镜像时使用一个新的 Dockerfile 文件（例如 Dockerfile.buildkit）**
+
+**注意：docker-compose build 命令暂时不支持 BuildKit**
+
+下面介绍如何在 Docker CE 18.09+ 版本中使用 `BuildKit` 提供的 `Dockerfile` 新指令来更快、更安全的构建 Docker 镜像。
+
+### 启用 `BuildKit`
+
+启用 `BuildKit` 必须先设置 **环境变量**。
+
+Linux、macOS 执行如下命令：
+
+```bash
+$ export DOCKER_BUILDKIT=1
+```
+
+Windows 执行如下命令：
+
+```powershell
+$ set $env:DOCKER_BUILDKIT=1
+```
+
+> 以上是设置环境变量的临时方法，若使环境变量永久生效请读者自行设置。
+
+### `Dockerfile` 新增指令详解
+
+启用 `BuildKit` 之后，我们可以使用下面几个新的指令来加快镜像构建。
+
+#### `RUN --mount=type=cache`
+
+目前，几乎所有的程序都会使用依赖管理工具，例如 `Go` 中的 `go mod`、`Node.js` 中的 `npm` 等等，当我们构建一个镜像时，往往会重复的从互联网中获取依赖包，难以缓存，大大降低了镜像的构建效率。
+
+例如一个前端工程需要用到 `npm`：
+
+```docker
+FROM node:alpine as builder
+
+WORKDIR /app
+
+COPY package.json /app/
+
+RUN npm i --registry=https://registry.npm.taobao.org \
+        && rm -rf ~/.npm
+
+COPY src /app/src
+
+RUN npm run build
+
+FROM nginx:alpine
+
+COPY --from=builder /app/dist /app/dist
+```
+
+使用多阶段构建，构建的镜像中只包含了目标文件夹 `dist`，但仍然存在一些问题，当 `package.json` 文件变动时，`RUN npm i && rm -rf ~/.npm` 这一层会重新执行，变更多次后，生成了大量的中间层镜像。
+
+为解决这个问题，进一步的我们可以设想一个类似 **数据卷** 的功能，在镜像构建时把 `node_modules` 文件夹挂载上去，在构建完成后，这个 `node_modules` 文件夹会自动卸载，实际的镜像中并不包含 `node_modules` 这个文件夹，这样我们就省去了每次获取依赖的时间，大大增加了镜像构建效率，同时也避免了生成了大量的中间层镜像。
+
+`BuildKit` 提供了 `RUN --mount=type=cache` 指令，可以实现上边的设想。
+
+```docker
+# syntax = docker/dockerfile:experimental
+FROM node:alpine as builder
+
+WORKDIR /app
+
+COPY package.json /app/
+
+RUN --mount=type=cache,target=/app/node_modules,id=my_app_npm_module,sharing=locked \
+    --mount=type=cache,target=/root/.npm,id=npm_cache \
+        npm i --registry=https://registry.npm.taobao.org
+
+COPY src /app/src
+
+RUN --mount=type=cache,target=/app/node_modules,id=my_app_npm_module,sharing=locked \
+# --mount=type=cache,target=/app/dist,id=my_app_dist,sharing=locked \
+        npm run build
+
+FROM nginx:alpine
+
+# COPY --from=builder /app/dist /app/dist
+
+# 为了更直观的说明 from 和 source 指令，这里使用 RUN 指令
+RUN --mount=type=cache,target=/tmp/dist,from=builder,source=/app/dist \
+    # --mount=type=cache,target/tmp/dist,from=my_app_dist,sharing=locked \
+    mkdir -p /app/dist && cp -r /tmp/dist/* /app/dist
+```
+
+**由于 `BuildKit` 为实验特性，每个 `Dockerfile` 文件开头都必须加上如下指令**
+
+```docker
+# syntax = docker/dockerfile:experimental
+```
+
+第一个 `RUN` 指令执行后，`id` 为 `my_app_npm_module` 的缓存文件夹挂载到了 `/app/node_modules` 文件夹中。多次执行也不会产生多个中间层镜像。
+
+第二个 `RUN` 指令执行时需要用到 `node_modules` 文件夹，`node_modules` 已经挂载，命令也可以正确执行。
+
+第三个 `RUN` 指令将上一阶段产生的文件复制到指定位置，`from` 指明缓存的来源，这里 `builder` 表示缓存来源于构建的第一阶段，`source` 指明缓存来源的文件夹。
+
+上面的 `Dockerfile` 中 `--mount=type=cache,...` 中指令作用如下：
+
+|Option               |Description|
+|---------------------|-----------|
+|`id`                 | `id` 设置一个标志，以便区分缓存。|
+|`target` (必填项)     | 缓存的挂载目标文件夹。|
+|`ro`,`readonly`      | 只读，缓存文件夹不能被写入。 |
+|`sharing`            | 有 `shared` `private` `locked` 值可供选择。`sharing` 设置当一个缓存被多次使用时的表现，由于 `BuildKit` 支持并行构建，当多个步骤使用同一缓存时（同一 `id`）会发生冲突。`shared` 表示多个步骤可以同时读写，`private` 表示当多个步骤使用同一缓存时，每个步骤使用不同的缓存，`locked` 表示当一个步骤完成释放缓存后，后一个步骤才能继续使用该缓存。|
+|`from`               | 缓存来源（构建阶段），不填写时为空文件夹。|
+|`source`             | 来源的文件夹路径。|
+
+#### `RUN --mount=type=bind`
+
+该指令可以将一个镜像（或上一构建阶段）的文件挂载到指定位置。
+
+```docker
+# syntax = docker/dockerfile:experimental
+RUN --mount=type=bind,from=php:alpine,source=/usr/local/bin/docker-php-entrypoint,target=/docker-php-entrypoint \
+        cat /docker-php-entrypoint
+```
+
+#### `RUN --mount=type=tmpfs`
+
+该指令可以将一个 `tmpfs` 文件系统挂载到指定位置。
+
+```docker
+# syntax = docker/dockerfile:experimental
+RUN --mount=type=tmpfs,target=/temp \
+        mount | grep /temp
+```
+
+#### `RUN --mount=type=secret`
+
+该指令可以将一个文件挂载到指定位置。
+
+```docker
+# syntax = docker/dockerfile:experimental
+RUN --mount=type=secret,id=aws,target=/root/.aws/credentials \
+        cat /root/.aws/credentials
+```
+
+```bash
+$ docker build -t test --secret id=aws,src=$HOME/.aws/credentials .
+```
+
+#### `RUN --mount=type=ssh`
+
+该指令可以挂载 `ssh` 密钥。
+
+```docker
+# syntax = docker/dockerfile:experimental
+FROM alpine
+RUN apk add --no-cache openssh-client
+RUN mkdir -p -m 0700 ~/.ssh && ssh-keyscan gitlab.com >> ~/.ssh/known_hosts
+RUN --mount=type=ssh ssh git@gitlab.com | tee /hello
+```
+
+```bash
+$ eval $(ssh-agent)
+$ ssh-add ~/.ssh/id_rsa
+(Input your passphrase here)
+$ docker build -t test --ssh default=$SSH_AUTH_SOCK .
+```
+
+### 清理构建缓存
+
+执行以下命令清理构建缓存
+
+```bash
+$ docker builder prune
+```
+
+### 官方文档
+
+* https://github.com/moby/buildkit/blob/master/frontend/dockerfile/docs/experimental.md
--- a/image/commit.md
+++ b/image/commit.md
@ -126,6 +126,6 @@ docker run --name web2 -d -p 81:80 nginx:v2

 首先，如果仔细观察之前的 `docker diff webserver` 的结果，你会发现除了真正想要修改的 `/usr/share/nginx/html/index.html` 文件外，由于命令的执行，还有很多文件被改动或添加了。这还仅仅是最简单的操作，如果是安装软件包、编译构建，那会有大量的无关内容被添加进来，如果不小心清理，将会导致镜像极为臃肿。

-此外，使用 `docker commit` 意味着所有对镜像的操作都是黑箱操作，生成的镜像也被称为**黑箱镜像**，换句话说，就是除了制作镜像的人知道执行过什么命令、怎么生成的镜像，别人根本无从得知。而且，即使是这个制作镜像的人，过一段时间后也无法记清具体在操作的。虽然 `docker diff` 或许可以告诉得到一些线索，但是远远不到可以确保生成一致镜像的地步。这种黑箱镜像的维护工作是非常痛苦的。
+此外，使用 `docker commit` 意味着所有对镜像的操作都是黑箱操作，生成的镜像也被称为 **黑箱镜像**，换句话说，就是除了制作镜像的人知道执行过什么命令、怎么生成的镜像，别人根本无从得知。而且，即使是这个制作镜像的人，过一段时间后也无法记清具体在操作的。虽然 `docker diff` 或许可以告诉得到一些线索，但是远远不到可以确保生成一致镜像的地步。这种黑箱镜像的维护工作是非常痛苦的。

 而且，回顾之前提及的镜像所使用的分层存储的概念，除当前层外，之前的每一层都是不会发生改变的，换句话说，任何修改的结果仅仅是在当前层进行标记、添加、修改，而不会改动上一层。如果使用 `docker commit` 制作镜像，以及后期修改的话，每一次修改都会让镜像更加臃肿一次，所删除的上一层的东西并不会丢失，会一直如影随形的跟着这个镜像，即使根本无法访问到。这会让镜像更加臃肿。
--- a/image/demo/buildkit/Dockerfile
+++ b/image/demo/buildkit/Dockerfile
@ -0,0 +1,16 @@
+FROM node:alpine as builder
+
+WORKDIR /app
+
+COPY package.json /app/
+
+RUN npm i --registry=https://registry.npm.taobao.org \
+        && rm -rf ~/.npm
+
+COPY src /app/src
+
+RUN npm run build
+
+FROM nginx:alpine
+
+COPY --from=builder /app/dist /app/dist
--- a/image/demo/buildkit/Dockerfile.buildkit
+++ b/image/demo/buildkit/Dockerfile.buildkit
@ -0,0 +1,37 @@
+# syntax = docker/dockerfile:experimental
+
+FROM node:alpine as builder
+
+WORKDIR /app
+
+COPY package.json /app/
+
+RUN --mount=type=cache,target=/app/node_modules,id=my_app_npm_module,sharing=locked \
+    --mount=type=cache,target=/root/.npm,id=npm_cache \
+        npm i --registry=https://registry.npm.taobao.org
+
+COPY src /app/src
+
+RUN --mount=type=cache,target=/app/node_modules,id=my_app_npm_module,sharing=locked \
+# --mount=type=cache,target=/app/dist,id=my_app_dist,sharing=locked \
+        npm run build
+
+FROM nginx:alpine
+
+# COPY --from=builder /app/dist /app/dist
+
+# 为了更直观的说明 from 和 source 指令，这里使用 RUN 指令
+RUN --mount=type=cache,target=/tmp/dist,from=builder,source=/app/dist \
+    # --mount=type=cache,target/tmp/dist,from=my_app_dist,sharing=locked \
+    mkdir -p /app/dist && cp -r /tmp/dist/* /app/dist
+
+RUN --mount=type=bind,from=php:alpine,source=/usr/local/bin/docker-php-entrypoint,target=/docker-php-entrypoint \
+        cat /docker-php-entrypoint
+
+RUN --mount=type=tmpfs,target=/temp \
+        mount | grep /temp
+
+RUN --mount=type=secret,id=aws,target=/root/.aws/credentials \
+        cat /root/.aws/credentials
+
+# docker build -t test --secret id=aws,src=$PWD/aws.txt --progress=plain -f Dockerfile.buildkit .
--- a/image/demo/buildkit/aws.txt
+++ b/image/demo/buildkit/aws.txt
@ -0,0 +1 @@
+awskey
--- a/image/demo/buildkit/package.json
+++ b/image/demo/buildkit/package.json
@ -0,0 +1,11 @@
+{
+  "name": "my_app",
+  "version": "19.6.0",
+  "devDependencies": {
+    "webpack": "*",
+    "webpack-cli": "*"
+  },
+  "scripts": {
+    "build": "mkdir -p $PWD/dist && cp -r src/* dist/"
+  }
+}
--- a/image/demo/buildkit/src/index.js
+++ b/image/demo/buildkit/src/index.js
@ -0,0 +1 @@
+console.log(1);
--- a/image/dockerfile/cmd.md
+++ b/image/dockerfile/cmd.md
@ -28,7 +28,7 @@ CMD [ "sh", "-c", "echo $HOME" ]

 提到 `CMD` 就不得不提容器中应用在前台执行和后台执行的问题。这是初学者常出现的一个混淆。

-Docker 不是虚拟机，容器中的应用都应该以前台执行，而不是像虚拟机、物理机里面那样，用 upstart/systemd 去启动后台服务，容器内没有后台服务的概念。
+Docker 不是虚拟机，容器中的应用都应该以前台执行，而不是像虚拟机、物理机里面那样，用 `systemd` 去启动后台服务，容器内没有后台服务的概念。

 一些初学者将 `CMD` 写为：

--- a/image/dockerfile/references.md
+++ b/image/dockerfile/references.md
@ -2,6 +2,6 @@

 * `Dockerfie` 官方文档：https://docs.docker.com/engine/reference/builder/

-* `Dockerfile` 最佳实践文档：https://docs.docker.com/engine/userguide/eng-image/dockerfile_best-practices/
+* `Dockerfile` 最佳实践文档：https://docs.docker.com/develop/develop-images/dockerfile_best-practices/

 * `Docker` 官方镜像 `Dockerfile`：https://github.com/docker-library/docs
--- a/image/internal.md
+++ b/image/internal.md
@ -2,7 +2,7 @@

 Docker 镜像是怎么实现增量的修改和维护的？

-每个镜像都由很多层次构成，Docker 使用 [Union FS](http://en.wikipedia.org/wiki/UnionFS) 将这些不同的层结合到一个镜像中去。
+每个镜像都由很多层次构成，Docker 使用 [Union FS](https://en.wikipedia.org/wiki/UnionFS) 将这些不同的层结合到一个镜像中去。

 通常 Union FS 有两个用途, 一方面可以实现不借助 LVM、RAID 将多个 disk 挂到同一个目录下,另一个更常用的就是将一个只读的分支和一个可写的分支联合在一起，Live CD 正是基于此方法可以允许在镜像不变的基础上允许用户在其上进行一些写操作。

--- a/image/list.md
+++ b/image/list.md
@ -15,7 +15,7 @@ ubuntu               latest              f753707788c5        4 weeks ago

 列表包含了 `仓库名`、`标签`、`镜像 ID`、`创建时间` 以及 `所占用的空间`。

-其中仓库名、标签在之前的基础概念章节已经介绍过了。**镜像 ID** 则是镜像的唯一标识，一个镜像可以对应多个**标签**。因此，在上面的例子中，我们可以看到 `ubuntu:18.04` 和 `ubuntu:latest` 拥有相同的 ID，因为它们对应的是同一个镜像。
+其中仓库名、标签在之前的基础概念章节已经介绍过了。**镜像 ID** 则是镜像的唯一标识，一个镜像可以对应多个 **标签**。因此，在上面的例子中，我们可以看到 `ubuntu:18.04` 和 `ubuntu:latest` 拥有相同的 ID，因为它们对应的是同一个镜像。

 ### 镜像体积

--- a/image/manifest.md
+++ b/image/manifest.md
@ -0,0 +1,178 @@
+## 构建多种系统架构支持的 Docker 镜像 -- docker manifest 命令详解
+
+我们知道使用镜像创建一个容器，该镜像必须与 Docker 宿主机系统架构一致，例如 `Linux x86_64` 架构的系统中只能使用 `Linux x86_64` 的镜像创建容器。
+
+> macOS 除外，其使用了 [binfmt_misc](https://docs.docker.com/docker-for-mac/multi-arch/) 提供了多种架构支持，在 macOS 系统上 (x86_64) 可以运行 arm 等其他架构的镜像。
+
+例如我们在 `Linux x86_64` 中构建一个 `username/test` 镜像。
+
+```Dockerfile
+FROM alpine
+
+CMD echo 1
+```
+
+构建镜像后推送到 Docker Hub，之后我们尝试在树莓派 `Linux arm64v8` 中使用这个镜像。
+
+```bash
+$ docker run -it --rm username/test
+```
+
+可以发现这个镜像根本获取不到。
+
+要解决这个问题，通常采用的做法是通过镜像名区分不同系统架构的镜像，例如在 `Linux x86_64` 和 `Linux arm64v8` 分别构建 `username/test` 和 `username/arm64v8-test` 镜像。运行时使用对应架构的镜像即可。
+
+这样做显得很繁琐，那么有没有一种方法让 Docker 引擎根据系统架构自动拉取对应的镜像呢？
+
+我们发现在 `Linux x86_64` 和 `Linux arm64v8` 架构的计算机中执行 `$ docker run golang:alpine go version` 时我们发现可以正确的运行。
+
+这是什么原因呢？
+
+原因就是 `golang:alpine` 官方镜像有一个 [`manifest` 列表](https://docs.docker.com/registry/spec/manifest-v2-2/)。
+
+当用户获取一个镜像时，Docker 引擎会首先查找该镜像是否有 `manifest` 列表，如果有的话 Docker 引擎会按照 Docker 运行环境（系统及架构）查找出对应镜像（例如 `golang:alpine`）。如果没有的话会直接获取镜像（例如上例中我们构建的 `username/test`）。
+
+我们可以使用 `$ docker manifest inspect golang:alpine` 查看这个 `manifest` 列表的结构。
+
+由于该命令属于实验特性，必须设置如下 **环境变量** 之后才能使用：
+
+```bash
+# Linux、macOS
+
+$ export DOCKER_CLI_EXPERIMENTAL=enabled
+
+# Windows
+
+$ set $env:DOCKER_CLI_EXPERIMENTAL=enabled
+```
+
+> 以上是设置环境变量的临时方法，若使环境变量永久生效请读者自行设置。
+
+设置之后，执行结果如下
+
+```bash
+$ docker manifest inspect golang:alpine
+```
+
+```json
+{
+   "schemaVersion": 2,
+   "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json",
+   "manifests": [
+      {
+         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
+         "size": 1365,
+         "digest": "sha256:5e28ac423243b187f464d635bcfe1e909f4a31c6c8bce51d0db0a1062bec9e16",
+         "platform": {
+            "architecture": "amd64",
+            "os": "linux"
+         }
+      },
+      {
+         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
+         "size": 1365,
+         "digest": "sha256:2945c46e26c9787da884b4065d1de64cf93a3b81ead1b949843dda1fcd458bae",
+         "platform": {
+            "architecture": "arm",
+            "os": "linux",
+            "variant": "v7"
+         }
+      },
+      {
+         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
+         "size": 1365,
+         "digest": "sha256:87fff60114fd3402d0c1a7ddf1eea1ded658f171749b57dc782fd33ee2d47b2d",
+         "platform": {
+            "architecture": "arm64",
+            "os": "linux",
+            "variant": "v8"
+         }
+      },
+      {
+         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
+         "size": 1365,
+         "digest": "sha256:607b43f1d91144f82a9433764e85eb3ccf83f73569552a49bc9788c31b4338de",
+         "platform": {
+            "architecture": "386",
+            "os": "linux"
+         }
+      },
+      {
+         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
+         "size": 1365,
+         "digest": "sha256:25ead0e21ed5e246ce31e274b98c09aaf548606788ef28eaf375dc8525064314",
+         "platform": {
+            "architecture": "ppc64le",
+            "os": "linux"
+         }
+      },
+      {
+         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
+         "size": 1365,
+         "digest": "sha256:69f5907fa93ea591175b2c688673775378ed861eeb687776669a48692bb9754d",
+         "platform": {
+            "architecture": "s390x",
+            "os": "linux"
+         }
+      }
+   ]
+}
+```
+
+可以看出 `manifest` 列表中包含了不同系统架构所对应的镜像 `digest` 值，这样 Docker 就可以在不同的架构中使用相同的 `manifest` (例如 `golang:alpine`) 获取对应的镜像。
+
+下面介绍如何使用 `$ docker manifest` 命令创建并推送 `manifest` 列表到 Docker Hub。
+
+### 构建镜像
+
+首先在 `Linux x86_64` 构建 `username/x8664-test` 镜像。并在 `Linux arm64v8` 中构建 `username/arm64v8-test` 镜像，构建好之后推送到 Docker Hub。
+
+### 创建 `manifest` 列表
+
+```bash
+# $ docker manifest create MANIFEST_LIST MANIFEST [MANIFEST...]
+$ docker manifest create username/test \
+      username/x8664-test \
+      username/arm64v8-test
+```
+
+当要修改一个 `manifest` 列表时，可以加入 `-a,--amend` 参数。
+
+### 设置 `manifest` 列表
+
+```bash
+# $ docker manifest annotate [OPTIONS] MANIFEST_LIST MANIFEST
+$ docker manifest annotate username/test \
+      username/x8664-test \
+      --os linux --arch x86_64
+
+$ docker manifest annotate username/test \
+      username/arm64v8-test \
+      --os linux --arch arm64 --variant v8
+```
+
+这样就配置好了 `manifest` 列表。
+
+### 查看 `manifest` 列表
+
+```bash
+$ docker manifest inspect username/test
+```
+
+### 推送 `manifest` 列表
+
+最后我们可以将其推送到 Docker Hub。
+
+```bash
+$ docker manifest push username/test
+```
+
+### 测试
+
+我们在 `Linux x86_64` `Linux arm64v8` 中分别执行 `$ docker run -it --rm username/test` 命令，发现可以正确的执行。
+
+### 官方博客
+
+详细了解 `manifest` 可以阅读官方博客。
+
+* https://blog.docker.com/2017/11/multi-arch-all-the-things/
--- a/image/multistage-builds/README.md
+++ b/image/multistage-builds/README.md
@ -8,29 +8,25 @@

 一种方式是将所有的构建过程编包含在一个 `Dockerfile` 中，包括项目及其依赖库的编译、测试、打包等流程，这里可能会带来的一些问题：

-  * `Dockerfile` 特别长，可维护性降低
-
  * 镜像层次多，镜像体积较大，部署时间变长

  * 源代码存在泄露的风险

-例如
-
-编写 `app.go` 文件，该程序输出 `Hello World!`
+例如，编写 `app.go` 文件，该程序输出 `Hello World!`

 ```go
-package main  
+package main

-import "fmt"  
+import "fmt"

-func main(){  
+func main(){
    fmt.Printf("Hello World!");
 }
 ```

 编写 `Dockerfile.one` 文件

-```docker
+```dockerfile
 FROM golang:1.9-alpine

 RUN apk --no-cache add git ca-certificates
@ -58,11 +54,9 @@ $ docker build -t go/helloworld:1 -f Dockerfile.one .

 另一种方式，就是我们事先在一个 `Dockerfile` 将项目及其依赖库编译测试打包好后，再将其拷贝到运行环境中，这种方式需要我们编写两个 `Dockerfile` 和一些编译脚本才能将其两个阶段自动整合起来，这种方式虽然可以很好地规避第一种方式存在的风险，但明显部署过程较复杂。

-例如
+例如，编写 `Dockerfile.build` 文件

-编写 `Dockerfile.build` 文件
-
-```docker
+```dockerfile
 FROM golang:1.9-alpine

 RUN apk --no-cache add git
@ -77,7 +71,7 @@ RUN go get -d -v github.com/go-sql-driver/mysql \

 编写 `Dockerfile.copy` 文件

-```docker
+```dockerfile
 FROM alpine:latest

 RUN apk --no-cache add ca-certificates
@ -129,11 +123,9 @@ go/helloworld   1      f55d3e16affc    2 minutes ago   295MB

 为解决以上问题，Docker v17.05 开始支持多阶段构建 (`multistage builds`)。使用多阶段构建我们就可以很容易解决前面提到的问题，并且只需要编写一个 `Dockerfile`：

-例如
+例如，编写 `Dockerfile` 文件

-编写 `Dockerfile` 文件
-
-```docker
+```dockerfile
 FROM golang:1.9-alpine as builder

 RUN apk --no-cache add git
@ -154,7 +146,7 @@ WORKDIR /root/

 COPY --from=0 /go/src/github.com/go/helloworld/app .

-CMD ["./app"]  
+CMD ["./app"]
 ```

 构建镜像
@ -184,7 +176,7 @@ go/helloworld     1     f55d3e16affc     2 minutes ago      295MB
 FROM golang:1.9-alpine as builder
 ```

-例如当我们只想构建 `builder` 阶段的镜像时，我们可以在使用 `docker build` 命令时加上 `--target` 参数即可
+例如当我们只想构建 `builder` 阶段的镜像时，增加 `--target=builder` 参数即可

 ```bash
 $ docker build --target builder -t username/imagename:tag .
--- a/image/multistage-builds/example/laravel/.dockerignore
+++ b/image/multistage-builds/example/laravel/.dockerignore
@ -0,0 +1,12 @@
+.idea/
+.git/
+vendor/
+node_modules/
+public/js/
+public/css/
+yarn-error.log
+
+bootstrap/cache/*
+storage/
+
+# 自行添加其他需要排除的文件，例如 .env.* 文件
--- a/image/multistage-builds/example/laravel/Dockerfile
+++ b/image/multistage-builds/example/laravel/Dockerfile
@ -0,0 +1,53 @@
+FROM node:alpine as frontend
+
+COPY package.json /app/
+
+RUN cd /app \
+      && npm install --registry=https://registry.npm.taobao.org
+
+COPY webpack.mix.js /app/
+COPY resources/assets/ /app/resources/assets/
+
+RUN cd /app \
+      && npm run production
+
+FROM composer as composer
+
+COPY database/ /app/database/
+COPY composer.json /app/
+
+RUN cd /app \
+      && composer config -g repo.packagist composer https://packagist.laravel-china.org \
+      && composer install \
+           --ignore-platform-reqs \
+           --no-interaction \
+           --no-plugins \
+           --no-scripts \
+           --prefer-dist
+
+FROM php:7.2-fpm-alpine as laravel
+
+ARG LARAVEL_PATH=/app/laravel
+
+COPY --from=composer /app/vendor/ ${LARAVEL_PATH}/vendor/
+COPY . ${LARAVEL_PATH}
+COPY --from=frontend /app/public/js/ ${LARAVEL_PATH}/public/js/
+COPY --from=frontend /app/public/css/ ${LARAVEL_PATH}/public/css/
+COPY --from=frontend /app/mix-manifest.json ${LARAVEL_PATH}/mix-manifest.json
+
+RUN cd ${LARAVEL_PATH} \
+      && php artisan package:discover \
+      && mkdir -p storage \
+      && mkdir -p storage/framework/cache \
+      && mkdir -p storage/framework/sessions \
+      && mkdir -p storage/framework/testing \
+      && mkdir -p storage/framework/views \
+      && mkdir -p storage/logs \
+      && chmod -R 777 storage
+
+FROM nginx:alpine as nginx
+
+ARG LARAVEL_PATH=/app/laravel
+
+COPY laravel.conf /etc/nginx/conf.d/
+COPY --from=laravel ${LARAVEL_PATH}/public ${LARAVEL_PATH}/public
--- a/image/multistage-builds/example/laravel/laravel.conf
+++ b/image/multistage-builds/example/laravel/laravel.conf
@ -0,0 +1,18 @@
+server {
+  listen 80 default_server;
+  root /app/laravel/public;
+  index index.php index.html;
+
+  location / {
+      try_files $uri $uri/ /index.php?$query_string;
+  }
+
+  location ~ .*\.php(\/.*)*$ {
+    fastcgi_pass   laravel:9000;
+    include        fastcgi.conf;
+
+    # fastcgi_connect_timeout 300;
+    # fastcgi_send_timeout 300;
+    # fastcgi_read_timeout 300;
+  }
+}
--- a/image/multistage-builds/laravel.md
+++ b/image/multistage-builds/laravel.md
@ -0,0 +1,221 @@
+## 实战多阶段构建 Laravel 镜像
+
+> 本节适用于 PHP 开发者阅读。
+
+### 准备
+
+新建一个 `Laravel` 项目或在已有的 `Laravel` 项目根目录下新建 `Dockerfile` `.dockerignore` `laravel.conf` 文件。
+
+在 `.dockerignore` 文件中写入以下内容。
+
+```bash
+.idea/
+.git/
+vendor/
+node_modules/
+public/js/
+public/css/
+yarn-error.log
+
+bootstrap/cache/*
+storage/
+
+# 自行添加其他需要排除的文件，例如 .env.* 文件
+```
+
+在 `laravel.conf` 文件中写入 nginx 配置。
+
+```nginx
+server {
+  listen 80 default_server;
+  root /app/laravel/public;
+  index index.php index.html;
+
+  location / {
+      try_files $uri $uri/ /index.php?$query_string;
+  }
+
+  location ~ .*\.php(\/.*)*$ {
+    fastcgi_pass   laravel:9000;
+    include        fastcgi.conf;
+
+    # fastcgi_connect_timeout 300;
+    # fastcgi_send_timeout 300;
+    # fastcgi_read_timeout 300;
+  }
+}
+```
+
+### 前端构建
+
+第一阶段进行前端构建。
+
+```dockerfile
+FROM node:alpine as frontend
+
+COPY package.json /app/
+
+RUN cd /app \
+      && npm install --registry=https://registry.npm.taobao.org
+
+COPY webpack.mix.js /app/
+COPY resources/assets/ /app/resources/assets/
+
+RUN cd /app \
+      && npm run production
+```
+
+### 安装 Composer 依赖
+
+第二阶段安装 Composer 依赖。
+
+```dockerfile
+FROM composer as composer
+
+COPY database/ /app/database/
+COPY composer.json composer.lock /app/
+
+RUN cd /app \
+      && composer config -g repo.packagist composer https://packagist.laravel-china.org \
+      && composer install \
+           --ignore-platform-reqs \
+           --no-interaction \
+           --no-plugins \
+           --no-scripts \
+           --prefer-dist
+```
+
+### 整合以上阶段所生成的文件
+
+第三阶段对以上阶段生成的文件进行整合。
+
+```dockerfile
+FROM php:7.2-fpm-alpine as laravel
+
+ARG LARAVEL_PATH=/app/laravel
+
+COPY --from=composer /app/vendor/ ${LARAVEL_PATH}/vendor/
+COPY . ${LARAVEL_PATH}
+COPY --from=frontend /app/public/js/ ${LARAVEL_PATH}/public/js/
+COPY --from=frontend /app/public/css/ ${LARAVEL_PATH}/public/css/
+COPY --from=frontend /app/mix-manifest.json ${LARAVEL_PATH}/mix-manifest.json
+
+RUN cd ${LARAVEL_PATH} \
+      && php artisan package:discover \
+      && mkdir -p storage \
+      && mkdir -p storage/framework/cache \
+      && mkdir -p storage/framework/sessions \
+      && mkdir -p storage/framework/testing \
+      && mkdir -p storage/framework/views \
+      && mkdir -p storage/logs \
+      && chmod -R 777 storage
+```
+
+### 最后一个阶段构建 NGINX 镜像
+
+```dockerfile
+FROM nginx:alpine as nginx
+
+ARG LARAVEL_PATH=/app/laravel
+
+COPY laravel.conf /etc/nginx/conf.d/
+COPY --from=laravel ${LARAVEL_PATH}/public ${LARAVEL_PATH}/public
+```
+
+### 构建 Laravel 及 Nginx 镜像
+
+使用 `docker build` 命令构建镜像。
+
+```bash
+$ docker build -t my/laravel --target=laravel .
+
+$ docker build -t my/nginx --target=nginx .
+```
+
+### 启动容器并测试
+
+新建 Docker 网络
+
+```bash
+$ docker network create laravel
+```
+
+启动 laravel 容器， `--name=laravel` 参数设定的名字必须与 `nginx` 配置文件中的 `fastcgi_pass   laravel:9000;` 一致
+
+```bash
+$ docker run -it --rm --name=laravel --network=laravel my/laravel
+```
+
+启动 nginx 容器
+
+```bash
+$ docker run -it --rm --network=laravel -p 8080:80 my/nginx
+```
+
+浏览器访问 `127.0.0.1:8080` 可以看到 Laravel 项目首页。
+
+> 也许 Laravel 项目依赖其他外部服务，例如 redis、MySQL，请自行启动这些服务之后再进行测试，本小节不再赘述。
+
+### 生产环境优化
+
+本小节内容为了方便测试，将配置文件直接放到了镜像中，实际在使用时 **建议** 将配置文件作为 `config` 或 `secret` 挂载到容器中，请读者自行学习 `Swarm mode` 或 `Kubernetes` 的相关内容。
+
+### 附录
+
+完整的 `Dockerfile` 文件如下。
+
+```dockerfile
+FROM node:alpine as frontend
+
+COPY package.json /app/
+
+RUN cd /app \
+      && npm install --registry=https://registry.npm.taobao.org
+
+COPY webpack.mix.js /app/
+COPY resources/assets/ /app/resources/assets/
+
+RUN cd /app \
+      && npm run production
+
+FROM composer as composer
+
+COPY database/ /app/database/
+COPY composer.json /app/
+
+RUN cd /app \
+      && composer config -g repo.packagist composer https://packagist.laravel-china.org \
+      && composer install \
+           --ignore-platform-reqs \
+           --no-interaction \
+           --no-plugins \
+           --no-scripts \
+           --prefer-dist
+
+FROM php:7.2-fpm-alpine as laravel
+
+ARG LARAVEL_PATH=/app/laravel
+
+COPY --from=composer /app/vendor/ ${LARAVEL_PATH}/vendor/
+COPY . ${LARAVEL_PATH}
+COPY --from=frontend /app/public/js/ ${LARAVEL_PATH}/public/js/
+COPY --from=frontend /app/public/css/ ${LARAVEL_PATH}/public/css/
+COPY --from=frontend /app/mix-manifest.json ${LARAVEL_PATH}/mix-manifest.json
+
+RUN cd ${LARAVEL_PATH} \
+      && php artisan package:discover \
+      && mkdir -p storage \
+      && mkdir -p storage/framework/cache \
+      && mkdir -p storage/framework/sessions \
+      && mkdir -p storage/framework/testing \
+      && mkdir -p storage/framework/views \
+      && mkdir -p storage/logs \
+      && chmod -R 777 storage
+
+FROM nginx:alpine as nginx
+
+ARG LARAVEL_PATH=/app/laravel
+
+COPY laravel.conf /etc/nginx/conf.d/
+COPY --from=laravel ${LARAVEL_PATH}/public ${LARAVEL_PATH}/public
+```
--- a/image/other.md
+++ b/image/other.md
@ -8,32 +8,33 @@

 压缩包可以是本地文件、远程 Web 文件，甚至是从标准输入中得到。压缩包将会在镜像 `/` 目录展开，并直接作为镜像第一层提交。

-比如我们想要创建一个 [OpenVZ](https://openvz.org) 的 Ubuntu 14.04 [模板](https://openvz.org/Download/template/precreated)的镜像：
+比如我们想要创建一个 [OpenVZ](https://openvz.org) 的 Ubuntu 16.04 [模板](https://openvz.org/Download/template/precreated)的镜像：

 ```bash
 $ docker import \
-    http://download.openvz.org/template/precreated/ubuntu-14.04-x86_64-minimal.tar.gz \
-    openvz/ubuntu:14.04
-Downloading from http://download.openvz.org/template/precreated/ubuntu-14.04-x86_64-minimal.tar.gz
-sha256:f477a6e18e989839d25223f301ef738b69621c4877600ae6467c4e5289822a79B/78.42 MB
+    http://download.openvz.org/template/precreated/ubuntu-16.04-x86_64.tar.gz \
+    openvz/ubuntu:16.04
+
+Downloading from http://download.openvz.org/template/precreated/ubuntu-16.04-x86_64.tar.gz
+sha256:412b8fc3e3f786dca0197834a698932b9c51b69bd8cf49e100c35d38c9879213
 ```

-这条命令自动下载了 `ubuntu-14.04-x86_64-minimal.tar.gz` 文件，并且作为根文件系统展开导入，并保存为镜像 `openvz/ubuntu:14.04`。
+这条命令自动下载了 `ubuntu-16.04-x86_64.tar.gz` 文件，并且作为根文件系统展开导入，并保存为镜像 `openvz/ubuntu:16.04`。

 导入成功后，我们可以用 `docker image ls` 看到这个导入的镜像：

 ```bash
 $ docker image ls openvz/ubuntu
 REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
-openvz/ubuntu       14.04               f477a6e18e98        55 seconds ago      214.9 MB
+openvz/ubuntu       16.04               412b8fc3e3f7        55 seconds ago      505MB
 ```

 如果我们查看其历史的话，会看到描述中有导入的文件链接：

 ```bash
-$ docker history openvz/ubuntu:14.04
+$ docker history openvz/ubuntu:16.04
 IMAGE               CREATED              CREATED BY          SIZE                COMMENT
-f477a6e18e98        About a minute ago                       214.9 MB            Imported from http://download.openvz.org/template/precreated/ubuntu-14.04-x86_64-minimal.tar.gz
+f477a6e18e98        About a minute ago                       214.9 MB            Imported from http://download.openvz.org/template/precreated/ubuntu-16.04-x86_64.tar.gz
 ```

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

 进入容器后，我们可以在 Shell 下操作，执行任何所需的命令。这里，我们执行了 `cat /etc/os-release`，这是 Linux 常用的查看当前系统版本的命令，从返回的结果可以看到容器内是 `Ubuntu 18.04.1 LTS` 系统。

--- a/install/centos.md
+++ b/install/centos.md
@ -48,7 +48,7 @@ $ sudo yum-config-manager \
 # 官方源
 # $ sudo yum-config-manager \
 #     --add-repo \
-#     https://download.docker.com/linux/centos/docker-ce.repo    
+#     https://download.docker.com/linux/centos/docker-ce.repo
 ```

 如果需要测试版本的 Docker CE 请使用以下命令：
@ -145,11 +145,11 @@ For more examples and ideas, visit:

 ### 镜像加速

-鉴于国内网络问题，后续拉取 Docker 镜像十分缓慢，强烈建议安装 Docker 之后配置 [国内镜像加速](mirror.md)。
+如果在使用过程中发现拉取 Docker 镜像十分缓慢，可以配置 Docker [国内镜像加速](mirror.md)。

 ### 添加内核参数

-默认配置下，如果在 CentOS 使用 Docker CE 看到下面的这些警告信息：
+如果在 CentOS 使用 Docker CE 看到下面的这些警告信息：

 ```bash
 WARNING: bridge-nf-call-iptables is disabled
--- a/install/debian.md
+++ b/install/debian.md
@ -10,8 +10,6 @@ Docker CE 支持以下版本的 [Debian](https://www.debian.org/intro/about) 操

 * Buster 10
 * Stretch 9
-* Jessie 8 (LTS) (Docker CE v18.06 及以下版本)
-* Wheezy 7.7 (EOL) (Docker CE v18.03 及以下版本)

 #### 卸载旧版本

@ -23,16 +21,10 @@ $ sudo apt-get remove docker \
               docker.io
 ```

-#### Debian 7 Wheezy
-
-Debian 7 的内核默认为 3.2，为了满足 Docker CE 的需求，应该安装 [`backports`](https://backports.debian.org/Instructions/) 的内核。
-
 ### 使用 APT 安装

 由于 apt 源使用 HTTPS 以确保软件下载过程中不被篡改。因此，我们首先需要添加使用 HTTPS 传输的软件包以及 CA 证书。

-Debian 8 Jessie 或者 Debian 9 Stretch 使用以下命令:
-
 ```bash
 $ sudo apt-get update

@ -45,20 +37,6 @@ $ sudo apt-get install \
     software-properties-common
 ```

-Debian 7 Wheezy 使用以下命令：
-
-```bash
-$ sudo apt-get update
-
-$ sudo apt-get install \
-     apt-transport-https \
-     ca-certificates \
-     curl \
-     lsb-release \
-     python-software-properties
-
-```
-
 鉴于国内网络问题，强烈建议使用国内源，官方源请在注释中查看。

 为了确认所下载软件包的合法性，需要添加软件源的 GPG 密钥。
@ -83,19 +61,11 @@ $ sudo add-apt-repository \
 # $ sudo add-apt-repository \
 #    "deb [arch=amd64] https://download.docker.com/linux/debian \
 #    $(lsb_release -cs) \
-#    stable"  
+#    stable"
 ```

 >以上命令会添加稳定版本的 Docker CE APT 源，如果需要测试或每日构建版本的 Docker CE 请将 stable 改为 test 或者 nightly。

-Debian 7 需要进行额外的操作：
-
-编辑 `/etc/apt/sources.list` 将 deb-src 一行删除或者使用 # 注释。
-
-```bash
-deb-src [arch=amd64] https://download.docker.com/linux/debian wheezy stable
-```
-
 #### 安装 Docker CE

 更新 apt 软件包缓存，并安装 `docker-ce`。
@ -124,12 +94,6 @@ $ sudo systemctl enable docker
 $ sudo systemctl start docker
 ```

-Debian 7 Wheezy 请使用以下命令启动
-
-```bash
-$ sudo service docker start
-```
-
 ### 建立 docker 用户组

 默认情况下，`docker` 命令会使用 [Unix socket](https://en.wikipedia.org/wiki/Unix_domain_socket) 与 Docker 引擎通讯。而只有 `root` 用户和 `docker` 组的用户才可以访问 Docker 引擎的 Unix socket。出于安全考虑，一般 Linux 系统上不会直接使用 `root` 用户。因此，更好地做法是将需要使用 `docker` 的用户加入 `docker` 用户组。
@ -185,7 +149,7 @@ For more examples and ideas, visit:

 ### 镜像加速

-鉴于国内网络问题，后续拉取 Docker 镜像十分缓慢，强烈建议安装 Docker 之后配置 [国内镜像加速](mirror.md)。
+如果在使用过程中发现拉取 Docker 镜像十分缓慢，可以配置 Docker [国内镜像加速](mirror.md)。

 ### 参考文档

--- a/install/fedora.md
+++ b/install/fedora.md
@ -39,7 +39,7 @@ $ sudo dnf -y install dnf-plugins-core

 鉴于国内网络问题，强烈建议使用国内源，官方源请在注释中查看。

-执行下面的命令添加 `dnf 软件源：
+执行下面的命令添加 `dnf` 软件源：

 ```bash
 $ sudo dnf config-manager \
@ -163,7 +163,7 @@ For more examples and ideas, visit:

 ### 镜像加速

-鉴于国内网络问题，后续拉取 Docker 镜像十分缓慢，强烈建议安装 Docker 之后配置 [国内镜像加速](mirror.md)。
+如果在使用过程中发现拉取 Docker 镜像十分缓慢，可以配置 Docker [国内镜像加速](mirror.md)。

 ### 参考文档

--- a/install/mac.md
+++ b/install/mac.md
@ -2,13 +2,13 @@

 ### 系统要求

-[Docker for Mac](https://docs.docker.com/docker-for-mac/) 要求系统最低为 macOS 10.10.3 Yosemite。如果系统不满足需求，可以安装 [Docker Toolbox](https://docs.docker.com/toolbox/overview/)。
+[Docker for Mac](https://docs.docker.com/docker-for-mac/) 要求系统最低为 macOS El Capitan 10.11。

 ### 安装

 #### 使用 Homebrew 安装

-[Homebrew](http://brew.sh/) 的 [Cask](https://caskroom.github.io/) 已经支持 Docker for Mac，因此可以很方便的使用 Homebrew Cask 来进行安装：
+[Homebrew](https://brew.sh/) 的 [Cask](https://caskroom.github.io/) 已经支持 Docker for Mac，因此可以很方便的使用 Homebrew Cask 来进行安装：

 ```bash
 $ brew cask install docker
@ -44,11 +44,11 @@ $ brew cask install docker

 ```bash
 $ docker --version
-Docker version 17.10.0-ce, build f4ffd25
+Docker version 18.09.0, build 4d60db4
 $ docker-compose --version
-docker-compose version 1.17.0-rc1, build a0f95af
+docker-compose version 1.23.2, build 1110ad01
 $ docker-machine --version
-docker-machine version 0.13.0, build 9ba6da9
+docker-machine version 0.16.0, build 702c267f
 ```

 如果 `docker version`、`docker info` 都正常的话，可以尝试运行一个 [Nginx 服务器](https://hub.docker.com/_/nginx/)：
@ -70,4 +70,4 @@ $ docker rm webserver

 ### 镜像加速

-鉴于国内网络问题，后续拉取 Docker 镜像十分缓慢，强烈建议安装 Docker 之后配置 [国内镜像加速](mirror.md)。
+如果在使用过程中发现拉取 Docker 镜像十分缓慢，可以配置 Docker [国内镜像加速](mirror.md)。
--- a/install/mirror.md
+++ b/install/mirror.md
@ -3,6 +3,7 @@
 国内从 Docker Hub 拉取镜像有时会遇到困难，此时可以配置镜像加速器。Docker 官方和国内很多云服务商都提供了国内加速器服务，例如：

 * [Docker 官方提供的中国 registry mirror `https://registry.docker-cn.com`](https://docs.docker.com/registry/recipes/mirror/#use-case-the-china-registry-mirror)
+* [阿里云加速器(需登录账号获取)](https://cr.console.aliyun.com/cn-hangzhou/mirrors)
 * [七牛云加速器 `https://reg-mirror.qiniu.com/`](https://kirk-enterprise.github.io/hub-docs/#/user-guide/mirror)

 > 当配置某一个加速器地址之后，若发现拉取不到镜像，请切换到另一个加速器地址。
@ -11,20 +12,6 @@

 我们以 Docker 官方加速器 `https://registry.docker-cn.com` 为例进行介绍。

-### Ubuntu 14.04、Debian 7 Wheezy
-
-对于使用 [upstart](http://upstart.ubuntu.com/) 的系统而言，编辑 `/etc/default/docker` 文件，在其中的 `DOCKER_OPTS` 中配置加速器地址：
-
-```bash
-DOCKER_OPTS="--registry-mirror=https://registry.docker-cn.com"
-```
-
-重新启动服务。
-
-```bash
-$ sudo service docker restart
-```
-
 ### Ubuntu 16.04+、Debian 8+、CentOS 7

 对于使用 [systemd](https://www.freedesktop.org/wiki/Software/systemd/) 的系统，请在 `/etc/docker/daemon.json` 中写入如下内容（如果文件不存在请新建该文件）
@ -58,7 +45,7 @@ $ sudo systemctl restart docker

 ### 检查加速器是否生效

-配置加速器之后，如果拉取镜像仍然十分缓慢，请手动检查加速器配置是否生效，在命令行执行 `docker info`，如果从结果中看到了如下内容，说明配置成功。
+命令行执行 `docker info`，如果从结果中看到了如下内容，说明配置成功。

 ```bash
 Registry Mirrors:
--- a/install/raspberry-pi.md
+++ b/install/raspberry-pi.md
@ -55,7 +55,7 @@ $ sudo add-apt-repository \
 # $ sudo add-apt-repository \
 #    "deb [arch=armhf] https://download.docker.com/linux/raspbian \
 #    $(lsb_release -cs) \
-#    stable"    
+#    stable"
 ```

 >以上命令会添加稳定版本的 Docker CE APT 源，如果需要测试或每日构建版本的 Docker CE 请将 stable 改为 test 或者 nightly。
@ -145,4 +145,4 @@ For more examples and ideas, visit:

 ### 镜像加速

-鉴于国内网络问题，后续拉取 Docker 镜像十分缓慢，强烈建议安装 Docker 之后配置 [国内镜像加速](mirror.md)。
+如果在使用过程中发现拉取 Docker 镜像十分缓慢，可以配置 Docker [国内镜像加速](mirror.md)。
--- a/install/ubuntu.md
+++ b/install/ubuntu.md
@ -10,7 +10,6 @@ Docker CE 支持以下版本的 [Ubuntu](https://www.ubuntu.com/server) 操作

 * Bionic 18.04 (LTS)
 * Xenial 16.04 (LTS)
-* Trusty 14.04 (LTS) (Docker CE v18.06 及以下版本)

 Docker CE 可以安装在 64 位的 x86 平台或 ARM 平台上。Ubuntu 发行版中，LTS（Long-Term-Support）长期支持版本，会获得 5 年的升级维护支持，这样的版本会更稳定，因此在生产环境中推荐使用 LTS 版本。

@ -24,24 +23,6 @@ $ sudo apt-get remove docker \
               docker.io
 ```

-#### Ubuntu 14.04 可选内核模块
-
-从 Ubuntu 14.04 开始，一部分内核模块移到了可选内核模块包 (`linux-image-extra-*`) ，以减少内核软件包的体积。正常安装的系统应该会包含可选内核模块包，而一些裁剪后的系统可能会将其精简掉。`AUFS` 内核驱动属于可选内核模块的一部分，作为推荐的 Docker 存储层驱动，一般建议安装可选内核模块包以使用 `AUFS`。
-
-如果系统没有安装可选内核模块的话，可以执行下面的命令来安装可选内核模块包：
-
-```bash
-$ sudo apt-get update
-
-$ sudo apt-get install \
-    linux-image-extra-$(uname -r) \
-    linux-image-extra-virtual
-```
-
-#### Ubuntu 16.04 +
-
-Ubuntu 16.04 + 上的 Docker CE 默认使用 `overlay2` 存储层驱动,无需手动配置。
-
 ### 使用 APT 安装

 由于 `apt` 源使用 HTTPS 以确保软件下载过程中不被篡改。因此，我们首先需要添加使用 HTTPS 传输的软件包以及 CA 证书。
@ -81,7 +62,7 @@ $ sudo add-apt-repository \
 # $ sudo add-apt-repository \
 #    "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
 #    $(lsb_release -cs) \
-#    stable"    
+#    stable"
 ```

 >以上命令会添加稳定版本的 Docker CE APT 镜像源，如果需要测试或每日构建版本的 Docker CE 请将 stable 改为 test 或者 nightly。
@ -114,12 +95,6 @@ $ sudo systemctl enable docker
 $ sudo systemctl start docker
 ```

-Ubuntu 14.04 请使用以下命令启动：
-
-```bash
-$ sudo service docker start
-```
-
 ### 建立 docker 用户组

 默认情况下，`docker` 命令会使用 [Unix socket](https://en.wikipedia.org/wiki/Unix_domain_socket) 与 Docker 引擎通讯。而只有 `root` 用户和 `docker` 组的用户才可以访问 Docker 引擎的 Unix socket。出于安全考虑，一般 Linux 系统上不会直接使用 `root` 用户。因此，更好地做法是将需要使用 `docker` 的用户加入 `docker` 用户组。
@ -175,7 +150,7 @@ For more examples and ideas, visit:

 ### 镜像加速

-鉴于国内网络问题，后续拉取 Docker 镜像十分缓慢，强烈建议安装 Docker 之后配置 [国内镜像加速](mirror.md)。
+如果在使用过程中发现拉取 Docker 镜像十分缓慢，可以配置 Docker [国内镜像加速](mirror.md)。

 ### 参考文档

--- a/install/windows.md
+++ b/install/windows.md
@ -26,4 +26,4 @@ Docker CE 启动之后会在 Windows 任务栏出现鲸鱼图标。

 ### 镜像加速

-鉴于国内网络问题，后续拉取 Docker 镜像十分缓慢，强烈建议安装 Docker 之后配置 [国内镜像加速](mirror.md)。
+如果在使用过程中发现拉取 Docker 镜像十分缓慢，可以配置 Docker [国内镜像加速](mirror.md)。
--- a/introduction/what.md
+++ b/introduction/what.md
@ -2,7 +2,7 @@

 Docker 最初是 dotCloud 公司创始人 Solomon Hykes 在法国期间发起的一个公司内部项目，它是基于 dotCloud 公司多年云服务技术的一次革新，并于 [2013 年 3 月以 Apache 2.0 授权协议开源][docker-soft]，主要项目代码在 [GitHub](https://github.com/moby/moby) 上进行维护。Docker 项目后来还加入了 Linux 基金会，并成立推动 [开放容器联盟（OCI）](https://www.opencontainers.org/)。

-Docker 自开源后受到广泛的关注和讨论，至今其 GitHub 项目已经超过 4 万 6 千个星标和一万多个 fork。甚至由于 Docker 项目的火爆，在 2013 年底，[dotCloud 公司决定改名为 Docker](https://blog.docker.com/2013/10/dotcloud-is-becoming-docker-inc/)。Docker 最初是在 Ubuntu 12.04 上开发实现的；Red Hat 则从 RHEL 6.5 开始对 Docker 进行支持；Google 也在其 PaaS 产品中广泛应用 Docker。
+Docker 自开源后受到广泛的关注和讨论，至今其 [GitHub 项目](https://github.com/moby/moby) 已经超过 5 万 2 千个星标和一万多个 fork。甚至由于 Docker 项目的火爆，在 2013 年底，[dotCloud 公司决定改名为 Docker](https://blog.docker.com/2013/10/dotcloud-is-becoming-docker-inc/)。Docker 最初是在 Ubuntu 12.04 上开发实现的；Red Hat 则从 RHEL 6.5 开始对 Docker 进行支持；Google 也在其 PaaS 产品中广泛应用 Docker。

 Docker 使用 Google 公司推出的 [Go 语言](https://golang.org/) 进行开发实现，基于 Linux 内核的 [cgroup](https://zh.wikipedia.org/wiki/Cgroups)，[namespace](https://en.wikipedia.org/wiki/Linux_namespaces)，以及  [AUFS](https://en.wikipedia.org/wiki/Aufs) 类的 [Union FS](https://en.wikipedia.org/wiki/Union_mount) 等技术，对进程进行封装隔离，属于 [操作系统层面的虚拟化技术](https://en.wikipedia.org/wiki/Operating-system-level_virtualization)。由于隔离的进程独立于宿主和其它的隔离的进程，因此也称其为容器。最初实现是基于 [LXC](https://linuxcontainers.org/lxc/introduction/)，从 0.7 版本以后开始去除 LXC，转而使用自行开发的 [libcontainer](https://github.com/docker/libcontainer)，从 1.11 开始，则进一步演进为使用 [runC](https://github.com/opencontainers/runc) 和 [containerd](https://github.com/containerd/containerd)。

--- a/kubernetes/design.md
+++ b/kubernetes/design.md
@ -26,7 +26,7 @@

 主节点上需要提供如下的管理服务：

-* `apiserver` 是整个系统的对外接口，提供一套 RESTful 的 [Kubernetes API](https://github.com/GoogleCloudPlatform/kubernetes/blob/master/docs/api.md)，供客户端和其它组件调用；
+* `apiserver` 是整个系统的对外接口，提供一套 RESTful 的 [Kubernetes API](https://github.com/kubernetes/kubernetes/tree/master/docs/api-reference)，供客户端和其它组件调用；
 * `scheduler` 负责对资源进行调度，分配某个 pod 到某个节点上。是 pluggable 的，意味着很容易选择其它实现方式；
 * `controller-manager` 负责管理控制器，包括 endpoint-controller（刷新服务和 pod 的关联信息）和 replication-controller（维护某个 pod 的复制为配置的数值）。

--- a/kubernetes/kubectl.md
+++ b/kubernetes/kubectl.md
@ -1,5 +1,5 @@
 # kubectl 使用
-[kubectl](https://github.com/GoogleCloudPlatform/kubernetes) 是 Kubernetes 自带的客户端，可以用它来直接操作 Kubernetes。
+[kubectl](https://github.com/kubernetes/kubernetes) 是 Kubernetes 自带的客户端，可以用它来直接操作 Kubernetes。

 使用格式有两种：
 ```bash
@ -8,44 +8,73 @@ kubectl [command]
 ```

 ## get
-Display one or many resources
+
+显示一个或多个资源
+
 ## describe
-Show details of a specific resource
+
+显示资源详情
+
 ## create
-Create a resource by filename or stdin
+
+从文件或标准输入创建资源
+
 ## update
-Update a resource by filename or stdin.
+
+从文件或标准输入更新资源
+
 ## delete
-Delete a resource by filename, stdin, resource and ID, or by resources and label selector.
-## namespace
-SUPERCEDED: Set and view the current Kubernetes namespace
+
+通过文件名、标准输入、资源名或者 label selector 删除资源
+
 ## log
-Print the logs for a container in a pod.
+
+输出 pod 中一个容器的日志
+
 ## rolling-update
-Perform a rolling update of the given ReplicationController.
-## resize
-Set a new size for a Replication Controller.
+
+对指定的 replication controller 执行滚动升级
+
 ## exec
-Execute a command in a container.
+
+在容器内部执行命令
+
 ## port-forward
-Forward one or more local ports to a pod.
+
+将本地端口转发到Pod
+
 ## proxy
-Run a proxy to the Kubernetes API server
-## run-container
-Run a particular image on the cluster.
-## stop
-Gracefully shut down a resource by id or filename.
+
+为 Kubernetes API server 启动代理服务器
+
+## run
+
+在集群中使用指定镜像启动容器
+
 ## expose
-Take a replicated application and expose it as Kubernetes Service
+
+将 replication controller service 或 pod 暴露为新的 kubernetes service
+
 ## label
-Update the labels on a resource
+
+更新资源的 label
+
 ## config
-config modifies kubeconfig files
+
+修改 kubernetes 配置文件
+
 ## cluster-info
-Display cluster info
+
+显示集群信息
+
 ## api-versions
-Print available API versions.
+
+以 "组/版本" 的格式输出服务端支持的 API 版本
+
 ## version
-Print the client and server version information.
+
+输出服务端和客户端的版本信息
+
 ## help
-Help about any command
+
+显示各个命令的帮助信息
--- a/mesos/framework.md
+++ b/mesos/framework.md
@ -1,89 +1,89 @@
-## 常见应用框架
-
-应用框架是实际干活的，可以理解为 Mesos 之上跑的 `应用`。应用框架注册到 Mesos master 服务上即可使用。
-
-用户大部分时候，只需要跟应用框架打交道。因此，选择合适的应用框架十分关键。
-
-Mesos 目前支持的应用框架分为四大类：长期运行任务（以及 PaaS）、大数据处理、批量调度、数据存储。
-
-随着 Mesos 自身的发展，越来越多的框架开始支持 Mesos，下面总结了目前常用的一些框架。
-
-### 长期运行的服务
-
-#### [Aurora](http://aurora.incubator.apache.org)
-
-利用 Mesos 调度安排的任务，保证任务一直在运行。
-
-提供 REST 接口，客户端和 webUI（8081 端口）
-
-#### [Marathon](https://github.com/mesosphere/marathon)
-
-一个私有 PaaS 平台，保证运行的应用不被中断。
-
-如果任务停止了，会自动重启一个新的相同任务。
-
-支持任务为任意 bash 命令，以及容器。
-
-提供 REST 接口，客户端和 webUI（8080 端口）
-
-#### [Singularity](https://github.com/HubSpot/Singularity)
-
-一个私有 PaaS 平台。
-
-调度器，运行长期的任务和一次性任务。
-
-提供 REST 接口，客户端和 webUI（7099、8080 端口），支持容器。
-
-### 大数据处理
-#### [Cray Chapel](https://github.com/nqn/mesos-chapel)
-
-支持 Chapel 并行编程语言的运行框架。
-
-#### [Dpark](https://github.com/douban/dpark)
-
-Spark 的 Python 实现。
-
-#### [Hadoop](https://github.com/mesos/hadoop)
-
-经典的 map-reduce 模型的实现。
-
-#### [Spark](http://spark.apache.org)
-
-跟 Hadoop 类似，但处理迭代类型任务会更好的使用内存做中间状态缓存，速度要快一些。
-
-#### [Storm](https://github.com/mesos/storm)
-
-分布式流计算，可以实时处理数据流。
-
-### 批量调度
-#### [Chronos](https://github.com/airbnb/chronos)
-
-Cron 的分布式实现，负责任务调度，支持容错。
-
-#### [Jenkins](https://github.com/jenkinsci/mesos-plugin)
-
-大名鼎鼎的 CI 引擎。使用 mesos-jenkins 插件，可以将 jenkins 的任务被 Mesos 集群来动态调度执行。
-
-#### [JobServer](http://www.grandlogic.com/content/html_docs/jobserver.html)
-
-基于 Java 的调度任务和数据处理引擎。
-
-#### [GoDocker](https://bitbucket.org/osallou/go-docker)
-
-基于 Docker 容器的集群维护工具。提供用户接口，除了支持 Mesos，还支持 Kubernetes、Swarm 等。
-
-### 数据存储
-
-#### [ElasticSearch](https://github.com/mesos/elasticsearch)
-
-功能十分强大的分布式数据搜索引擎。
-
-一方面通过分布式集群实现可靠的数据库，一方面提供灵活的 API，对数据进行整合和分析。ElasticSearch + LogStash + Kibana 目前合成为 ELK 工具栈。
-
-#### [Hypertable](https://code.google.com/p/hypertable)
-
-高性能的分布式数据库，支持结构化或者非结构化的数据存储。
-
-#### [Tachyon](http://tachyon-project.org/)
-
-内存为中心的分布式存储系统，利用内存访问的高速提供高性能。
+## 常见应用框架
+
+应用框架是实际干活的，可以理解为 Mesos 之上跑的 `应用`。应用框架注册到 Mesos master 服务上即可使用。
+
+用户大部分时候，只需要跟应用框架打交道。因此，选择合适的应用框架十分关键。
+
+Mesos 目前支持的应用框架分为四大类：长期运行任务（以及 PaaS）、大数据处理、批量调度、数据存储。
+
+随着 Mesos 自身的发展，越来越多的框架开始支持 Mesos，下面总结了目前常用的一些框架。
+
+### 长期运行的服务
+
+#### [Aurora](http://aurora.incubator.apache.org)
+
+利用 Mesos 调度安排的任务，保证任务一直在运行。
+
+提供 REST 接口，客户端和 webUI（8081 端口）
+
+#### [Marathon](https://github.com/mesosphere/marathon)
+
+一个私有 PaaS 平台，保证运行的应用不被中断。
+
+如果任务停止了，会自动重启一个新的相同任务。
+
+支持任务为任意 bash 命令，以及容器。
+
+提供 REST 接口，客户端和 webUI（8080 端口）
+
+#### [Singularity](https://github.com/HubSpot/Singularity)
+
+一个私有 PaaS 平台。
+
+调度器，运行长期的任务和一次性任务。
+
+提供 REST 接口，客户端和 webUI（7099、8080 端口），支持容器。
+
+### 大数据处理
+#### [Cray Chapel](https://github.com/nqn/mesos-chapel)
+
+支持 Chapel 并行编程语言的运行框架。
+
+#### [Dpark](https://github.com/douban/dpark)
+
+Spark 的 Python 实现。
+
+#### [Hadoop](https://github.com/mesos/hadoop)
+
+经典的 map-reduce 模型的实现。
+
+#### [Spark](http://spark.apache.org)
+
+跟 Hadoop 类似，但处理迭代类型任务会更好的使用内存做中间状态缓存，速度要快一些。
+
+#### [Storm](https://github.com/mesos/storm)
+
+分布式流计算，可以实时处理数据流。
+
+### 批量调度
+#### [Chronos](https://github.com/airbnb/chronos)
+
+Cron 的分布式实现，负责任务调度，支持容错。
+
+#### [Jenkins](https://github.com/jenkinsci/mesos-plugin)
+
+大名鼎鼎的 CI 引擎。使用 mesos-jenkins 插件，可以将 jenkins 的任务被 Mesos 集群来动态调度执行。
+
+#### [JobServer](http://www.grandlogic.com/content/html_docs/jobserver.html)
+
+基于 Java 的调度任务和数据处理引擎。
+
+#### [GoDocker](https://bitbucket.org/osallou/go-docker)
+
+基于 Docker 容器的集群维护工具。提供用户接口，除了支持 Mesos，还支持 Kubernetes、Swarm 等。
+
+### 数据存储
+
+#### [ElasticSearch](https://github.com/mesos/elasticsearch)
+
+功能十分强大的分布式数据搜索引擎。
+
+一方面通过分布式集群实现可靠的数据库，一方面提供灵活的 API，对数据进行整合和分析。ElasticSearch + LogStash + Kibana 目前合成为 ELK 工具栈。
+
+#### [Hypertable](https://code.google.com/p/hypertable)
+
+高性能的分布式数据库，支持结构化或者非结构化的数据存储。
+
+#### [Tachyon](http://tachyon-project.org/)
+
+内存为中心的分布式存储系统，利用内存访问的高速提供高性能。
--- a/mesos/intro.md
+++ b/mesos/intro.md
@ -3,7 +3,7 @@ Mesos 最初由 UC Berkeley 的 AMP 实验室于 2009 年发起，遵循 Apache

 如果把数据中心中的集群资源看做一台服务器，那么 Mesos 要做的事情，其实就是今天操作系统内核的职责：抽象资源 + 调度任务。Mesos 项目是 Mesosphere 公司 Datacenter Operating System (DCOS) 产品的核心部件。

-Mesos 项目主要由 C++ 语言编写，项目官方地址为 [http://mesos.apache.org](http://mesos.apache.org)，代码仍在快速演化中，已经发布了正式版 1.0.0 版本。
+Mesos 项目主要由 C++ 语言编写，项目官方地址为 [https://mesos.apache.org](https://mesos.apache.org)，代码仍在快速演化中，已经发布了正式版 1.0.0 版本。

 Mesos 拥有许多引人注目的特性，包括：
 * 支持数万个节点的大规模场景（Apple、Twitter、eBay 等公司实践）；
--- a/repository/dockerhub.md
+++ b/repository/dockerhub.md
@ -28,15 +28,13 @@ saltstack/centos-6-minimal
 tutum/centos-6.4                                DEPRECATED. Use tutum/centos:6.4 instead. ...   5                    [OK]
 ```

-可以看到返回了很多包含关键字的镜像，其中包括镜像名字、描述、收藏数（表示该镜像的受关注程度）、是否官方创建、是否自动创建。
+可以看到返回了很多包含关键字的镜像，其中包括镜像名字、描述、收藏数（表示该镜像的受关注程度）、是否官方创建（OFFICIAL）、是否自动构建 （AUTOMATED）。

-官方的镜像说明是官方项目组创建和维护的，automated 资源允许用户验证镜像的来源和内容。
-
-根据是否是官方提供，可将镜像资源分为两类。
+根据是否是官方提供，可将镜像分为两类。

 一种是类似 `centos` 这样的镜像，被称为基础镜像或根镜像。这些基础镜像由 Docker 公司创建、验证、支持、提供。这样的镜像往往使用单个单词作为名字。

-还有一种类型，比如 `tianon/centos` 镜像，它是由 Docker 的用户创建并维护的，往往带有用户名称前缀。可以通过前缀 `username/` 来指定使用某个用户提供的镜像，比如 tianon 用户。
+还有一种类型，比如 `tianon/centos` 镜像，它是由 Docker Hub 的注册用户创建并维护的，往往带有用户名称前缀。可以通过前缀 `username/` 来指定使用某个用户提供的镜像，比如 tianon 用户。

 另外，在查找的时候通过 `--filter=stars=N` 参数可以指定仅显示收藏数量为 `N` 以上的镜像。

@ -74,24 +72,24 @@ NAME                      DESCRIPTION                                     STARS
 username/ubuntu
 ```

-### 自动创建
+### 自动构建

-自动创建（Automated Builds）功能对于需要经常升级镜像内程序来说，十分方便。
+自动构建（Automated Builds）功能对于需要经常升级镜像内程序来说，十分方便。

-有时候，用户创建了镜像，安装了某个软件，如果软件发布新版本则需要手动更新镜像。
+有时候，用户构建了镜像，安装了某个软件，当软件发布新版本则需要手动更新镜像。

-而自动创建允许用户通过 Docker Hub 指定跟踪一个目标网站（目前支持 [GitHub](https://github.com) 或 [BitBucket](https://bitbucket.org)）上的项目，一旦项目发生新的提交或者创建新的标签（tag），Docker Hub 会自动构建镜像并推送到 Docker Hub 中。
+而自动构建允许用户通过 Docker Hub 指定跟踪一个目标网站（支持 [GitHub](https://github.com) 或 [BitBucket](https://bitbucket.org)）上的项目，一旦项目发生新的提交 （commit）或者创建了新的标签（tag），Docker Hub 会自动构建镜像并推送到 Docker Hub 中。

-要配置自动创建，包括如下的步骤：
+要配置自动构建，包括如下的步骤：

-* 创建并登录 Docker Hub，以及目标网站；
+* 登录 Docker Hub；

-* 在目标网站中连接帐户到 Docker Hub；
+* 在 Docker Hub 点击右上角头像，在账号设置（Account Settings）中关联（Linked Accounts）目标网站；

-* 在 Docker Hub 中 [配置一个自动创建](https://registry.hub.docker.com/builds/add/)；
+* 在 Docker Hub 中新建或选择已有的仓库，在 `Builds` 选项卡中选择 `Configure Automated Builds`；

 * 选取一个目标网站中的项目（需要含 `Dockerfile`）和分支；

-* 指定 `Dockerfile` 的位置，并提交创建。
+* 指定 `Dockerfile` 的位置，并保存。

-之后，可以在 Docker Hub 的 [自动创建页面](https://registry.hub.docker.com/builds/) 中跟踪每次创建的状态。
+之后，可以在 Docker Hub 的仓库页面的 `Timeline` 选项卡中查看每次构建的状态。
--- a/repository/nexus3_registry.md
+++ b/repository/nexus3_registry.md
@ -2,7 +2,7 @@

 使用 Docker 官方的 Registry 创建的仓库面临一些维护问题。比如某些镜像删除以后空间默认是不会回收的，需要一些命令去回收空间然后重启 Registry 程序。在企业中把内部的一些工具包放入 Nexus 中是比较常见的做法，最新版本 `Nexus3.x` 全面支持 Docker 的私有镜像。所以使用 [`Nexus3.x`](https://www.sonatype.com/download-oss-sonatype/) 一个软件来管理 `Docker` , `Maven` , `Yum` , `PyPI` 等是一个明智的选择。

-### 启动 Nexus 容器 
+### 启动 Nexus 容器

 ```bash
 $ docker run -d --name nexus3 --restart=always \
@ -52,10 +52,10 @@ upstream register
 server {
    server_name YourDomainName;#如果没有 DNS 服务器做解析，请删除此选项使用本机 IP 地址访问
    listen       443 ssl;
-    
+
    ssl_certificate key/example.crt;
    ssl_certificate_key key/example.key;
-    
+
    ssl_session_timeout  5m;
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    ssl_ciphers  HIGH:!aNULL:!MD5;
--- a/repository/registry.md
+++ b/repository/registry.md
@ -97,20 +97,6 @@ REPOSITORY                         TAG                 IMAGE ID            CREAT

 这是因为 Docker 默认不允许非 `HTTPS` 方式推送镜像。我们可以通过 Docker 的配置选项来取消这个限制，或者查看下一节配置能够通过 `HTTPS` 访问的私有仓库。

-#### Ubuntu 14.04, Debian 7 Wheezy
-
-对于使用 `upstart` 的系统而言，编辑 `/etc/default/docker` 文件，在其中的 `DOCKER_OPTS` 中增加如下内容：
-
-```bash
-DOCKER_OPTS="--registry-mirror=https://registry.docker-cn.com --insecure-registries=192.168.199.100:5000"
-```
-
-重新启动服务。
-
-```bash
-$ sudo service docker restart
-```
-
 #### Ubuntu 16.04+, Debian 8+, centos 7

 对于使用 `systemd` 的系统，请在 `/etc/docker/daemon.json` 中写入如下内容（如果文件不存在请新建该文件）
--- a/security/kernel_ns.md
+++ b/security/kernel_ns.md
@ -11,5 +11,5 @@ Docker 容器和 LXC 容器很相似，所提供的安全特性也差不多。

 内核命名空间从 2.6.15 版本（2008 年 7 月发布）之后被引入，数年间，这些机制的可靠性在诸多大型生产系统中被实践验证。

-实际上，命名空间的想法和设计提出的时间要更早，最初是为了在内核中引入一种机制来实现 [OpenVZ](http://en.wikipedia.org/wiki/OpenVZ) 的特性。
+实际上，命名空间的想法和设计提出的时间要更早，最初是为了在内核中引入一种机制来实现 [OpenVZ](https://en.wikipedia.org/wiki/OpenVZ) 的特性。
 而 OpenVZ 项目早在 2005 年就发布了，其设计和实现都已经十分成熟。
--- a/swarm_mode/create.md
+++ b/swarm_mode/create.md
@ -46,7 +46,7 @@ docker@worker1:~$ docker swarm join \
    --token SWMTKN-1-49nj1cmql0jkz5s954yi3oex3nedyz0fb0xx14ie39trti4wxv-8vxv8rssmk743ojnwacrr2e7c \
    192.168.99.100:2377

-This node joined a swarm as a worker.    
+This node joined a swarm as a worker.
 ```

 ```bash
@ -58,7 +58,7 @@ docker@worker1:~$ docker swarm join \
    --token SWMTKN-1-49nj1cmql0jkz5s954yi3oex3nedyz0fb0xx14ie39trti4wxv-8vxv8rssmk743ojnwacrr2e7c \
    192.168.99.100:2377

-This node joined a swarm as a worker.    
+This node joined a swarm as a worker.
 ```

 >注意：一些细心的读者可能通过 `docker-machine create --help` 查看到 `--swarm*` 等一系列参数。该参数是用于旧的 `Docker Swarm`,与本章所讲的 `Swarm mode` 没有关系。
--- a/underly/cgroups.md
+++ b/underly/cgroups.md
@ -1,6 +1,6 @@
 ## 控制组

-控制组（[cgroups](http://en.wikipedia.org/wiki/Cgroups)）是 Linux 内核的一个特性，主要用来对共享资源进行隔离、限制、审计等。只有能控制分配到容器的资源，才能避免当多个容器同时运行时的对系统资源的竞争。
+控制组（[cgroups](https://en.wikipedia.org/wiki/Cgroups)）是 Linux 内核的一个特性，主要用来对共享资源进行隔离、限制、审计等。只有能控制分配到容器的资源，才能避免当多个容器同时运行时的对系统资源的竞争。

 控制组技术最早是由 Google 的程序员在 2006 年提出，Linux 内核自 2.6.24 开始支持。

--- a/underly/namespace.md
+++ b/underly/namespace.md
@ -19,4 +19,4 @@ UTS("UNIX Time-sharing System") 命名空间允许每个容器拥有独立的 ho
 ### user 命名空间
 每个容器可以有不同的用户和组 id, 也就是说可以在容器内用容器内部的用户执行程序而非主机上的用户。

-*注：更多关于 Linux 上命名空间的信息，请阅读 [这篇文章](http://blog.scottlowe.org/2013/09/04/introducing-linux-network-namespaces/)。
+*注：更多关于 Linux 上命名空间的信息，请阅读 [这篇文章](https://blog.scottlowe.org/2013/09/04/introducing-linux-network-namespaces/)。
--- a/underly/ufs.md
+++ b/underly/ufs.md
@ -1,6 +1,6 @@
 ## 联合文件系统

-联合文件系统（[UnionFS](http://en.wikipedia.org/wiki/UnionFS)）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。
+联合文件系统（[UnionFS](https://en.wikipedia.org/wiki/UnionFS)）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。

 联合文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。

@ -14,7 +14,7 @@ Docker 目前支持的联合文件系统包括 `OverlayFS`, `AUFS`, `Btrfs`, `VF

 |Linux 发行版 |	Docker 推荐使用的存储驱动 |
 | :--        | :--                     |
-|Docker CE on Ubuntu |	`overlay2` (Ubuntu 14.04.4 +, 16.04 +) |
+|Docker CE on Ubuntu |	`overlay2` (16.04 +) |
 |Docker CE on Debian |	`overlay2` (Debian Stretch), `aufs`, `devicemapper` |
 |Docker CE on CentOS |	`overlay2`  |
 |Docker CE on Fedora |	`overlay2`  |