Fix words

Update figure's path

README.md

@@ -1,12 +1,12 @@
 # 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/github/release/yeasy/docker_practice/all.svg)](https://github.com/yeasy/docker_practice/releases) [![](https://img.shields.io/badge/Based-Docker%20CE%20v20.10-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)][1]
+[![](https://img.shields.io/github/stars/yeasy/docker_practice.svg?style=social&label=Stars)](https://github.com/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%20v27.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)][1]
 
-**v1.3.0**
+**v1.4.0**
 
-| 语言           | - |
-| :------------- | :--- |
-| [简体中文](https://github.com/yeasy/docker_practice)              | [阅读](https://vuepress.mirror.docker-practice.com/) |
+| 语言                                               | -                                                  |
+| :----------------------------------------------- | :------------------------------------------------- |
+| [简体中文](https://github.com/yeasy/docker_practice) | [阅读](https://vuepress.mirror.docker-practice.com/) |
 
 [Docker](https://www.docker.com) 是个划时代的开源项目，它彻底释放了计算虚拟化的威力，极大提高了应用的维护效率，降低了云计算应用开发的成本！使用 Docker，可以让应用的部署、测试和分发都变得前所未有的高效和轻松！
 
@@ -22,6 +22,7 @@ Docker 自身仍在快速发展中，生态环境也在蓬勃成长。建议初
 * [修订记录](CHANGELOG.md)
 * [贡献者名单](https://github.com/yeasy/docker_practice/graphs/contributors)
 
+<!--
 ## 微信小程序
 
 <p align="center">
@@ -29,14 +30,16 @@ Docker 自身仍在快速发展中，生态环境也在蓬勃成长。建议初
 </p>
 
 <p align="center"><strong>微信扫码 随时随地阅读~</strong></p>
+-->
 
 ## 技术交流
-
+<!--
 <p align="center">
 <img width="200" src="https://docker_practice.gitee.io/pic/dpsig-wechat.jpg">
 </p>
 
 <p align="center"><strong>微信扫码 加入群聊~ 或者微信添加 <code>dpsigs</code> 邀请入群</strong></p>
+-->
 
 欢迎加入 Docker 技术交流 QQ 群，分享 Docker 资源，交流 Docker 技术。
 
@@ -49,18 +52,20 @@ Docker 自身仍在快速发展中，生态环境也在蓬勃成长。建议初
 * QQ 群 VII （已满）：252403484
 * QQ 群 VIII（已满）：544818750
 * QQ 群 IX  （已满）：571502246
-* QQ 群 X   （可加）：145983035
+* QQ 群 X   （已满）：145983035
+
+建议前往 [Github Discussions](https://github.com/yeasy/docker_practice/discussions) 进行技术交流。
 
 >如果有容器技术相关的疑问，请通过 [Issues](https://github.com/yeasy/docker_practice/issues/new/choose) 来提出。
 
 ## 进阶学习
 
-[![](https://github.com/yeasy/docker_practice/raw/master/_images/docker_primer3.png)][1]
+[![](https://github.com/yeasy/docker_practice/raw/master/_images/docker_primer4.jpg)][1]
 
-《[Docker 技术入门与实战][1]》第三版已经面世，介绍最新的容器技术栈，欢迎大家阅读使用并反馈建议。
+《[Docker 技术入门与实战][1]》已更新到第 4 版，讲解最新容器技术栈知识，欢迎大家阅读并反馈建议。
 
 * [京东图书][1]
-* [China-Pub](http://product.china-pub.com/8052127)
+* [天猫图书](https://detail.tmall.com/item.htm?id=997383773726&skuId=6143496614475)
 
 ## 鼓励项目
 
@@ -70,4 +75,4 @@ Docker 自身仍在快速发展中，生态环境也在蓬勃成长。建议初
 
 <p align="center"><strong>欢迎鼓励项目一杯 coffee~</strong></p>
 
-[1]: https://union-click.jd.com/jdc?e=&p=JF8AANADIgZlGF0VAxUDVBJdHDISBFAfWRcCGzcRRANLXSJeEF4aVwkMGQ1eD0kdSVJKSQVJHBIEUB9ZFwIbGAxeB0gyS34PbFlHVHNkI0MQEAoIcSxyBWFLRAtZK1olABYHXR9eHAoQN2UbXCVQfN_jrYOwsw7T_5SOnZUiBmUbXBYBFwBVG14UBBAAZRxbHDJJUjscCEEHEQ4FSA4VBhBQZStrFjIiN1UrWCVAfARQT1gQA0cFAEwOEAcRDlMTDEALQAFTEwwRUhMAUR1cJQATBlES
+[1]: https://item.jd.com/10200902362001.html

SUMMARY.md

@@ -6,6 +6,7 @@
 * [Docker 简介](introduction/README.md)
   * [什么是 Docker](introduction/what.md)
   * [为什么要用 Docker](introduction/why.md)
+
 * [基本概念](basic_concept/README.md)
   * [镜像](basic_concept/image.md)
   * [容器](basic_concept/container.md)
@@ -18,7 +19,7 @@
   * [Raspberry Pi](install/raspberry-pi.md)
   * [Linux 离线安装](install/offline.md)
   * [macOS](install/mac.md)
-  * [Windows 10](install/windows.md)
+  * [Windows 10/11](install/windows.md)
   * [镜像加速器](install/mirror.md)
   * [开启实验特性](install/experimental.md)
 * [使用镜像](image/README.md)
@@ -45,7 +46,6 @@
     * [参考文档](image/dockerfile/references.md)
   * [Dockerfile 多阶段构建](image/multistage-builds/README.md)
     * [实战多阶段构建 Laravel 镜像](image/multistage-builds/laravel.md)
-  * [构建多种系统架构支持的 Docker 镜像](image/manifest.md)
   * [其它制作镜像的方式](image/other.md)
   * [实现原理](image/internal.md)
 * [操作容器](container/README.md)
@@ -63,27 +63,15 @@
 * [数据管理](data_management/README.md)
   * [数据卷](data_management/volume.md)
   * [挂载主机目录](data_management/bind-mounts.md)
-* [使用网络](network/README.md)
-  * [外部访问容器](network/port_mapping.md)
-  * [容器互联](network/linking.md)
+* [网络配置](network/README.md)
   * [配置 DNS](network/dns.md)
-* [高级网络配置](advanced_network/README.md)
-  * [快速配置指南](advanced_network/quick_guide.md)
-  * [容器访问控制](advanced_network/access_control.md)
-  * [端口映射实现](advanced_network/port_mapping.md)
-  * [配置 docker0 网桥](advanced_network/docker0.md)
-  * [自定义网桥](advanced_network/bridge.md)
-  * [工具和示例](advanced_network/example.md)
-  * [编辑网络配置文件](advanced_network/config_file.md)
-  * [配置 HTTP/HTTPS 网络代理](advanced_network/http_https_proxy.md)
-  * [实例：创建一个点到点连接](advanced_network/ptp.md)
+  * [外部访问容器](network/port_mapping.md)
 * [Docker Buildx](buildx/README.md)
   * [BuildKit](buildx/buildkit.md)
   * [使用 buildx 构建镜像](buildx/buildx.md)
   * [使用 buildx 构建多种系统架构支持的 Docker 镜像](buildx/multi-arch-images.md)
 * [Docker Compose](compose/README.md)
   * [简介](compose/introduction.md)
-  * [Compose v2](compose/v2.md)
   * [安装与卸载](compose/install.md)
   * [使用](compose/usage.md)
   * [命令说明](compose/commands.md)

advanced_network/README.md

@@ -1,15 +0,0 @@
-# 高级网络配置
-
->注意：本章属于 `Docker` 高级配置，如果您是初学者，您可以暂时跳过本章节，直接学习 [Docker Compose](../compose) 一节。
-
-本章将介绍 Docker 的一些高级网络配置和选项。
-
-当 Docker 启动时，会自动在主机上创建一个 `docker0` 虚拟网桥，实际上是 Linux 的一个 bridge，可以理解为一个软件交换机。它会在挂载到它的网口之间进行转发。
-
-同时，Docker 随机分配一个本地未占用的私有网段（在 [RFC1918](https://datatracker.ietf.org/doc/html/rfc1918) 中定义）中的一个地址给 `docker0` 接口。比如典型的 `172.17.42.1`，掩码为 `255.255.0.0`。此后启动的容器内的网口也会自动分配一个同一网段（`172.17.0.0/16`）的地址。
-
-当创建一个 Docker 容器的时候，同时会创建了一对 `veth pair` 接口（当数据包发送到一个接口时，另外一个接口也可以收到相同的数据包）。这对接口一端在容器内，即 `eth0`；另一端在本地并被挂载到 `docker0` 网桥，名称以 `veth` 开头（例如 `vethAQI2QT`）。通过这种方式，主机可以跟容器通信，容器之间也可以相互通信。Docker 就创建了在主机和所有容器之间一个虚拟共享网络。
-
-![Docker 网络](./_images/network.png)
-
-接下来的部分将介绍在一些场景中，Docker 所有的网络定制配置。以及通过 Linux 命令来调整、补充、甚至替换 Docker 默认的网络配置。

advanced_network/access_control.md

@@ -1,56 +0,0 @@
-# 容器访问控制
-
-容器的访问控制，主要通过 Linux 上的 `iptables` 防火墙来进行管理和实现。`iptables` 是 Linux 上默认的防火墙软件，在大部分发行版中都自带。
-
-## 容器访问外部网络
-容器要想访问外部网络，需要本地系统的转发支持。在Linux 系统中，检查转发是否打开。
-
-```bash
-$sysctl net.ipv4.ip_forward
-net.ipv4.ip_forward = 1
-```
-如果为 0，说明没有开启转发，则需要手动打开。
-```bash
-$sysctl -w net.ipv4.ip_forward=1
-```
-如果在启动 Docker 服务的时候设定 `--ip-forward=true`, Docker 就会自动设定系统的 `ip_forward` 参数为 1。
-
-## 容器之间访问
-容器之间相互访问，需要两方面的支持。
-* 容器的网络拓扑是否已经互联。默认情况下，所有容器都会被连接到 `docker0` 网桥上。
-* 本地系统的防火墙软件 -- `iptables` 是否允许通过。
-
-### 访问所有端口
-当启动 Docker 服务（即 dockerd）的时候，默认会添加一条转发策略到本地主机 iptables 的 FORWARD 链上。策略为通过（`ACCEPT`）还是禁止（`DROP`）取决于配置`--icc=true`（缺省值）还是 `--icc=false`。当然，如果手动指定 `--iptables=false` 则不会添加 `iptables` 规则。
-
-可见，默认情况下，不同容器之间是允许网络互通的。如果为了安全考虑，可以在 `/etc/docker/daemon.json` 文件中配置 `{"icc": false}` 来禁止它。
-
-### 访问指定端口
-在通过 `-icc=false` 关闭网络访问后，还可以通过 `--link=CONTAINER_NAME:ALIAS` 选项来访问容器的开放端口。
-
-例如，在启动 Docker 服务时，可以同时使用 `icc=false --iptables=true` 参数来关闭允许相互的网络访问，并让 Docker 可以修改系统中的 `iptables` 规则。
-
-此时，系统中的 `iptables` 规则可能是类似
-```bash
-$ sudo iptables -nL
-...
-Chain FORWARD (policy ACCEPT)
-target     prot opt source               destination
-DROP       all  --  0.0.0.0/0            0.0.0.0/0
-...
-```
-
-之后，启动容器（`docker run`）时使用 `--link=CONTAINER_NAME:ALIAS` 选项。Docker 会在 `iptable` 中为 两个容器分别添加一条 `ACCEPT` 规则，允许相互访问开放的端口（取决于 `Dockerfile` 中的 `EXPOSE` 指令）。
-
-当添加了 `--link=CONTAINER_NAME:ALIAS` 选项后，添加了 `iptables` 规则。
-```bash
-$ sudo iptables -nL
-...
-Chain FORWARD (policy ACCEPT)
-target     prot opt source               destination
-ACCEPT     tcp  --  172.17.0.2           172.17.0.3           tcp spt:80
-ACCEPT     tcp  --  172.17.0.3           172.17.0.2           tcp dpt:80
-DROP       all  --  0.0.0.0/0            0.0.0.0/0
-```
-
-注意：`--link=CONTAINER_NAME:ALIAS` 中的 `CONTAINER_NAME` 目前必须是 Docker 分配的名字，或使用 `--name` 参数指定的名字。主机名则不会被识别。

advanced_network/bridge.md

@@ -1,45 +0,0 @@
-# 自定义网桥
-
-除了默认的 `docker0` 网桥，用户也可以指定网桥来连接各个容器。
-
-在启动 Docker 服务的时候，使用 `-b BRIDGE`或`--bridge=BRIDGE` 来指定使用的网桥。
-
-如果服务已经运行，那需要先停止服务，并删除旧的网桥。
-
-```bash
-$ sudo systemctl stop docker
-$ sudo ip link set dev docker0 down
-$ sudo brctl delbr docker0
-```
-
-然后创建一个网桥 `bridge0`。
-
-```bash
-$ sudo brctl addbr bridge0
-$ sudo ip addr add 192.168.5.1/24 dev bridge0
-$ sudo ip link set dev bridge0 up
-```
-
-查看确认网桥创建并启动。
-
-```bash
-$ ip addr show bridge0
-4: bridge0: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state UP group default
-    link/ether 66:38:d0:0d:76:18 brd ff:ff:ff:ff:ff:ff
-    inet 192.168.5.1/24 scope global bridge0
-       valid_lft forever preferred_lft forever
-```
-
-在 Docker 配置文件 `/etc/docker/daemon.json` 中添加如下内容，即可将 Docker 默认桥接到创建的网桥上。
-
-```json
-{
-  "bridge": "bridge0",
-}
-```
-
-启动 Docker 服务。
-
-新建一个容器，可以看到它已经桥接到了 `bridge0` 上。
-
-可以继续用 `brctl show` 命令查看桥接的信息。另外，在容器中可以使用 `ip addr` 和 `ip route` 命令来查看 IP 地址配置和路由信息。

advanced_network/config_file.md

@@ -1,5 +0,0 @@
-# 编辑网络配置文件
-
-Docker 1.2.0 开始支持在运行中的容器里编辑 `/etc/hosts`, `/etc/hostname` 和 `/etc/resolv.conf` 文件。
-
-但是这些修改是临时的，只在运行的容器中保留，容器终止或重启后并不会被保存下来，也不会被 `docker commit` 提交。

advanced_network/docker0.md

@@ -1,37 +0,0 @@
-# 配置 docker0 网桥
-
-Docker 服务默认会创建一个 `docker0` 网桥（其上有一个 `docker0` 内部接口），它在内核层连通了其他的物理或虚拟网卡，这就将所有容器和本地主机都放到同一个物理网络。
-
-Docker 默认指定了 `docker0` 接口 的 IP 地址和子网掩码，让主机和容器之间可以通过网桥相互通信，它还给出了 MTU（接口允许接收的最大传输单元），通常是 1500 Bytes，或宿主主机网络路由上支持的默认值。这些值都可以在服务启动的时候进行配置。
-
-* `--bip=CIDR` IP 地址加掩码格式，例如 192.168.1.5/24
-* `--mtu=BYTES` 覆盖默认的 Docker mtu 配置
-
-也可以在配置文件中配置 DOCKER_OPTS，然后重启服务。
-
-由于目前 Docker 网桥是 Linux 网桥，用户可以使用 `brctl show` 来查看网桥和端口连接信息。
-
-```bash
-$ sudo brctl show
-bridge name     bridge id               STP enabled     interfaces
-docker0         8000.3a1d7362b4ee       no              veth65f9
-                                             vethdda6
-```
-*注：`brctl` 命令在 Debian、Ubuntu 中可以使用 `sudo apt-get install bridge-utils` 来安装。
-
-
-每次创建一个新容器的时候，Docker 从可用的地址段中选择一个空闲的 IP 地址分配给容器的 eth0 端口。使用本地主机上 `docker0` 接口的 IP 作为所有容器的默认网关。
-
-```bash
-$ sudo docker run -i -t --rm base /bin/bash
-$ ip addr show eth0
-24: eth0: <BROADCAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
-    link/ether 32:6f:e0:35:57:91 brd ff:ff:ff:ff:ff:ff
-    inet 172.17.0.3/16 scope global eth0
-       valid_lft forever preferred_lft forever
-    inet6 fe80::306f:e0ff:fe35:5791/64 scope link
-       valid_lft forever preferred_lft forever
-$ ip route
-default via 172.17.42.1 dev eth0
-172.17.0.0/16 dev eth0  proto kernel  scope link  src 172.17.0.3
-```

advanced_network/example.md

@@ -1,9 +0,0 @@
-# 工具和示例
-
-在介绍自定义网络拓扑之前，你可能会对一些外部工具和例子感兴趣：
-
-## pipework
-Jérôme Petazzoni 编写了一个叫 [pipework](https://github.com/jpetazzo/pipework) 的 shell 脚本，可以帮助用户在比较复杂的场景中完成容器的连接。
-
-## playground
-Brandon Rhodes 创建了一个提供完整的 Docker 容器网络拓扑管理的 [Python库](https://github.com/brandon-rhodes/fopnp/tree/m/playground)，包括路由、NAT 防火墙；以及一些提供 `HTTP` `SMTP` `POP` `IMAP` `Telnet` `SSH` `FTP` 的服务器。

advanced_network/how_connect.md

@@ -1 +0,0 @@
-

advanced_network/http_https_proxy.md

@@ -1,74 +0,0 @@
-# 配置 HTTP/HTTPS 网络代理
-
-使用Docker的过程中，因为网络原因，通常需要使用 HTTP/HTTPS 代理来加速镜像拉取、构建和使用。下面是常见的三种场景。
-
-## 为 dockerd 设置网络代理
-
-"docker pull" 命令是由 dockerd 守护进程执行。而 dockerd 守护进程是由 systemd 管理。因此，如果需要在执行 "docker pull" 命令时使用 HTTP/HTTPS 代理，需要通过 systemd 配置。
-
-- 为 dockerd 创建配置文件夹。
-```
-sudo mkdir -p /etc/systemd/system/docker.service.d
-```
-
-- 为 dockerd 创建 HTTP/HTTPS 网络代理的配置文件，文件路径是 /etc/systemd/system/docker.service.d/http-proxy.conf 。并在该文件中添加相关环境变量。
-```
-[Service]
-Environment="HTTP_PROXY=http://proxy.example.com:8080/"
-Environment="HTTPS_PROXY=http://proxy.example.com:8080/"
-Environment="NO_PROXY=localhost,127.0.0.1,.example.com"
-```
-
-- 刷新配置并重启 docker 服务。
-```
-sudo systemctl daemon-reload
-sudo systemctl restart docker
-```
-
-## 为 docker 容器设置网络代理
-
-在容器运行阶段，如果需要使用 HTTP/HTTPS 代理，可以通过更改 docker 客户端配置，或者指定环境变量的方式。
-
-- 更改 docker 客户端配置：创建或更改 ~/.docker/config.json，并在该文件中添加相关配置。
-```
-{
- "proxies":
- {
-   "default":
-   {
-     "httpProxy": "http://proxy.example.com:8080/",
-     "httpsProxy": "http://proxy.example.com:8080/",
-     "noProxy": "localhost,127.0.0.1,.example.com"
-   }
- }
-}
-```
-
-- 指定环境变量：运行 "docker run" 命令时，指定相关环境变量。
-
-| 环境变量 |  docker run 示例 |
-| -------- | ---------------- |
-| HTTP_PROXY | --env HTTP_PROXY="http://proxy.example.com:8080/" |
-| HTTPS_PROXY | --env HTTPS_PROXY="http://proxy.example.com:8080/" |
-| NO_PROXY | --env NO_PROXY="localhost,127.0.0.1,.example.com" |
-
-## 为 docker build 过程设置网络代理
-
-在容器构建阶段，如果需要使用 HTTP/HTTPS 代理，可以通过指定 "docker build" 的环境变量，或者在 Dockerfile 中指定环境变量的方式。
-
-- 使用 "--build-arg" 指定 "docker build" 的相关环境变量
-```
-docker build \
-    --build-arg "HTTP_PROXY=http://proxy.example.com:8080/" \
-    --build-arg "HTTPS_PROXY=http://proxy.example.com:8080/" \
-    --build-arg "NO_PROXY=localhost,127.0.0.1,.example.com" .
-```
-
-- 在 Dockerfile 中指定相关环境变量
-
-| 环境变量 | Dockerfile 示例 |
-| -------- | ---------------- |
-| HTTP_PROXY | ENV HTTP_PROXY="http://proxy.example.com:8080/" |
-| HTTPS_PROXY | ENV HTTPS_PROXY="http://proxy.example.com:8080/" |
-| NO_PROXY | ENV NO_PROXY="localhost,127.0.0.1,.example.com" |
-

advanced_network/port_mapping.md

@@ -1,57 +0,0 @@
-# 映射容器端口到宿主主机的实现
-
-默认情况下，容器可以主动访问到外部网络的连接，但是外部网络无法访问到容器。
-
-## 容器访问外部实现
-
-容器所有到外部网络的连接，源地址都会被 NAT 成本地系统的 IP 地址。这是使用 `iptables` 的源地址伪装操作实现的。
-
-查看主机的 NAT 规则。
-
-```bash
-$ sudo iptables -t nat -nL
-...
-Chain POSTROUTING (policy ACCEPT)
-target     prot opt source               destination
-MASQUERADE  all  --  172.17.0.0/16       !172.17.0.0/16
-...
-```
-
-其中，上述规则将所有源地址在 `172.17.0.0/16` 网段，目标地址为其他网段（外部网络）的流量动态伪装为从系统网卡发出。MASQUERADE 跟传统 SNAT 的好处是它能动态从网卡获取地址。
-
-## 外部访问容器实现
-
-容器允许外部访问，可以在 `docker run` 时候通过 `-p` 或 `-P` 参数来启用。
-
-不管用那种办法，其实也是在本地的 `iptable` 的 nat 表中添加相应的规则。
-
-使用 `-P` 时：
-
-```bash
-$ iptables -t nat -nL
-...
-Chain DOCKER (2 references)
-target     prot opt source               destination
-DNAT       tcp  --  0.0.0.0/0            0.0.0.0/0            tcp dpt:49153 to:172.17.0.2:80
-```
-
-使用 `-p 80:80` 时：
-
-```bash
-$ iptables -t nat -nL
-Chain DOCKER (2 references)
-target     prot opt source               destination
-DNAT       tcp  --  0.0.0.0/0            0.0.0.0/0            tcp dpt:80 to:172.17.0.2:80
-```
-
-注意：
-
-* 这里的规则映射了 `0.0.0.0`，意味着将接受主机来自所有接口的流量。用户可以通过 `-p IP:host_port:container_port` 或 `-p IP::port` 来指定允许访问容器的主机上的 IP、接口等，以制定更严格的规则。
-
-* 如果希望永久绑定到某个固定的 IP 地址，可以在 Docker 配置文件 `/etc/docker/daemon.json` 中添加如下内容。
-
-```json
-{
-  "ip": "0.0.0.0"
-}
-```

advanced_network/ptp.md

@@ -1,45 +0,0 @@
-# 示例：创建一个点到点连接
-默认情况下，Docker 会将所有容器连接到由 `docker0` 提供的虚拟子网中。
-
-用户有时候需要两个容器之间可以直连通信，而不用通过主机网桥进行桥接。
-
-解决办法很简单：创建一对 `peer` 接口，分别放到两个容器中，配置成点到点链路类型即可。
-
-首先启动 2 个容器：
-```bash
-$ docker run -i -t --rm --net=none base /bin/bash
-root@1f1f4c1f931a:/#
-$ docker run -i -t --rm --net=none base /bin/bash
-root@12e343489d2f:/#
-```
-
-找到进程号，然后创建网络命名空间的跟踪文件。
-```bash
-$ docker inspect -f '{{.State.Pid}}' 1f1f4c1f931a
-2989
-$ docker inspect -f '{{.State.Pid}}' 12e343489d2f
-3004
-$ sudo mkdir -p /var/run/netns
-$ sudo ln -s /proc/2989/ns/net /var/run/netns/2989
-$ sudo ln -s /proc/3004/ns/net /var/run/netns/3004
-```
-
-创建一对 `peer` 接口，然后配置路由
-```bash
-$ sudo ip link add A type veth peer name B
-
-$ sudo ip link set A netns 2989
-$ sudo ip netns exec 2989 ip addr add 10.1.1.1/32 dev A
-$ sudo ip netns exec 2989 ip link set A up
-$ sudo ip netns exec 2989 ip route add 10.1.1.2/32 dev A
-
-$ sudo ip link set B netns 3004
-$ sudo ip netns exec 3004 ip addr add 10.1.1.2/32 dev B
-$ sudo ip netns exec 3004 ip link set B up
-$ sudo ip netns exec 3004 ip route add 10.1.1.1/32 dev B
-```
-现在这 2 个容器就可以相互 ping 通，并成功建立连接。点到点链路不需要子网和子网掩码。
-
-此外，也可以不指定 `--net=none` 来创建点到点链路。这样容器还可以通过原先的网络来通信。
-
-利用类似的办法，可以创建一个只跟主机通信的容器。但是一般情况下，更推荐使用 `--icc=false` 来关闭容器之间的通信。

advanced_network/quick_guide.md

@@ -1,26 +0,0 @@
-# 快速配置指南
-
-下面是一个跟 Docker 网络相关的命令列表。
-
-其中有些命令选项只有在 Docker 服务启动的时候才能配置，而且不能马上生效。
-
-* `-b BRIDGE` 或 `--bridge=BRIDGE` 指定容器挂载的网桥
-* `--bip=CIDR` 定制 docker0 的掩码
-* `-H SOCKET...` 或 `--host=SOCKET...` Docker 服务端接收命令的通道
-* `--icc=true|false` 是否支持容器之间进行通信
-* `--ip-forward=true|false` 请看下文容器之间的通信
-* `--iptables=true|false` 是否允许 Docker 添加 iptables 规则
-* `--mtu=BYTES` 容器网络中的 MTU
-
-下面2个命令选项既可以在启动服务时指定，也可以在启动容器时指定。在 Docker 服务启动的时候指定则会成为默认值，后面执行 `docker run` 时可以覆盖设置的默认值。
-
-* `--dns=IP_ADDRESS...` 使用指定的DNS服务器
-* `--dns-search=DOMAIN...` 指定DNS搜索域
-
-最后这些选项只有在 `docker run` 执行时使用，因为它是针对容器的特性内容。
-
-* `-h HOSTNAME` 或 `--hostname=HOSTNAME` 配置容器主机名
-* `--link=CONTAINER_NAME:ALIAS` 添加到另一个容器的连接
-* `--net=bridge|none|container:NAME_or_ID|host` 配置容器的桥接模式
-* `-p SPEC` 或 `--publish=SPEC` 映射容器端口到宿主主机
-* `-P or --publish-all=true|false` 映射容器所有端口到宿主主机

appendix/best_practices.md

@@ -118,7 +118,7 @@ RUN apt-get update && apt-get install -y \
 将 `apt-get update` 放在一条单独的 `RUN` 声明中会导致缓存问题以及后续的 `apt-get install` 失败。比如，假设你有一个 `Dockerfile` 文件：
 
 ```docker
-FROM ubuntu:18.04
+FROM ubuntu:24.04
 
 RUN apt-get update
 
@@ -128,7 +128,7 @@ RUN apt-get install -y curl
 构建镜像后，所有的层都在 Docker 的缓存中。假设你后来又修改了其中的 `apt-get install` 添加了一个包：
 
 ```docker
-FROM ubuntu:18.04
+FROM ubuntu:24.04
 
 RUN apt-get update
 

appendix/command/docker.md

@@ -1,4 +1,4 @@
-# 客户端命令(docker)
+# 客户端命令 - docker
 
 ## 客户端命令选项
 
@@ -63,7 +63,8 @@
 * `wait`：阻塞直到一个容器终止，然后输出它的退出符。
 
 ## 一张图总结 Docker 的命令
-![Docker 命令总结](../_images/cmd_logic.png)
+
+![Docker 命令总结](../../.gitbook/assets/cmd_logic.png)
 
 ## 参考
 

appendix/faq/README.md

@@ -1,4 +1,4 @@
-# 常见问题总结
+# 附录一：常见问题总结
 
 ## 镜像相关
 
@@ -19,20 +19,15 @@
 答：整体原则上，尽量保持镜像功能的明确和内容的精简，要点包括
 
 * 尽量选取满足需求但较小的基础系统镜像，例如大部分时候可以选择 `alpine` 镜像，仅有不足六兆大小；
-
 * 清理编译生成文件、安装包的缓存等临时文件；
-
 * 安装各个软件时候要指定准确的版本号，并避免引入不需要的依赖；
-
 * 从安全角度考虑，应用要尽量使用系统的库和依赖；
-
 * 如果安装应用时候需要配置一些特殊的环境变量，在安装后要还原不需要保持的变量值；
-
 * 使用 Dockerfile 创建镜像时候要添加 .dockerignore 文件或使用干净的工作目录。
 
 更多内容请查看 [Dockerfile 最佳实践](../best_practices.md)
 
-### 碰到网络问题，无法 pull 镜像，命令行指定 http_proxy 无效？
+### 碰到网络问题，无法 pull 镜像，命令行指定 http\_proxy 无效？
 
 答：在 Docker 配置文件中添加 `export http_proxy="http://<PROXY_HOST>:<PROXY_PORT>"`，之后重启 Docker 服务即可。
 
@@ -61,6 +56,7 @@ docker inspect --format '{{ .State.Pid }}' <CONTAINER ID or NAME>
 ### 如何获取某个容器的 IP 地址？
 
 答：可以使用
+
 ```bash
 docker inspect --format '{{ .NetworkSettings.IPAddress }}' <CONTAINER ID or NAME>
 ```
@@ -84,16 +80,15 @@ $ docker run --network=my-net --ip=172.25.3.3 -itd --name=my-container busybox
 答：
 
 * 创建镜像时 `Dockerfile` 要通过 `EXPOSE` 指定正确的开放端口；
-
 * 容器启动时指定 `PublishAllPort = true`。
 
 ### 可以在一个容器中同时运行多个应用进程么？
 
-答：一般并不推荐在同一个容器内运行多个应用进程。如果有类似需求，可以通过一些额外的进程管理机制，比如 `supervisord` 来管理所运行的进程。可以参考 https://docs.docker.com/config/containers/multi-service_container/ 。
+答：一般并不推荐在同一个容器内运行多个应用进程。如果有类似需求，可以通过一些额外的进程管理机制，比如 `supervisord` 来管理所运行的进程。可以参考 https://docs.docker.com/config/containers/multi-service\_container/ 。
 
 ### 如何控制容器占用系统资源（CPU、内存）的份额？
 
-答：在使用 `docker create` 命令创建容器或使用 `docker run` 创建并启动容器的时候，可以使用 -c|--cpu-shares[=0] 参数来调整容器使用 CPU 的权重；使用 -m|--memory[=MEMORY] 参数来调整容器使用内存的大小。
+答：在使用 `docker create` 命令创建容器或使用 `docker run` 创建并启动容器的时候，可以使用 -c|--cpu-shares\[=0] 参数来调整容器使用 CPU 的权重；使用 -m|--memory\[=MEMORY] 参数来调整容器使用内存的大小。
 
 ## 仓库相关
 
@@ -109,14 +104,13 @@ $ docker run --network=my-net --ip=172.25.3.3 -itd --name=my-container busybox
 
 答：使用 `systemd` 的系统（如 Ubuntu 16.04、Centos 等）的配置文件在 `/etc/docker/daemon.json`。
 
-
 ### 如何更改 Docker 的默认存储位置？
 
 答：Docker 的默认存储位置是 `/var/lib/docker`，如果希望将 Docker 的本地文件存储到其他分区，可以使用 Linux 软连接的方式来完成，或者在启动 daemon 时通过 `-g` 参数指定，或者修改配置文件 `/etc/docker/daemon.json` 的 "data-root" 项 。可以使用 `docker system info | grep "Root Dir"` 查看当前使用的存储位置。
 
 例如，如下操作将默认存储位置迁移到 /storage/docker。
 
-```sh
+```
 [root@s26 ~]# df -h
 Filesystem                    Size  Used Avail Use% Mounted on
 /dev/mapper/VolGroup-lv_root   50G  5.3G   42G  12% /
@@ -138,9 +132,7 @@ lrwxrwxrwx. 1 root root 15 11月 17 13:43 docker -> /storage/docker
 答：这是因为系统默认没有开启对内存和 swap 使用的统计功能，引入该功能会带来性能的下降。要开启该功能，可以采取如下操作：
 
 * 编辑 `/etc/default/grub` 文件（Ubuntu 系统为例），配置 `GRUB_CMDLINE_LINUX="cgroup_enable=memory swapaccount=1"`
-
 * 更新 grub：`$ sudo update-grub`
-
 * 重启系统，即可。
 
 ## Docker 与虚拟化
@@ -148,6 +140,7 @@ lrwxrwxrwx. 1 root root 15 11月 17 13:43 docker -> /storage/docker
 ### Docker 与 LXC（Linux Container）有何不同？
 
 答：LXC 利用 Linux 上相关技术实现了容器。Docker 则在如下的几个方面进行了改进：
+
 * 移植性：通过抽象容器配置，容器可以实现从一个平台移植到另一个平台；
 * 镜像系统：基于 OverlayFS 的镜像系统为容器的分发带来了很多的便利，同时共同的镜像层只需要存储一份，实现高效率的存储；
 * 版本管理：类似于Git的版本管理理念，用户可以更方便的创建、管理镜像文件；
@@ -159,7 +152,6 @@ lrwxrwxrwx. 1 root root 15 11月 17 13:43 docker -> /storage/docker
 答：两者的定位完全不同。
 
 * Vagrant 类似 Boot2Docker（一款运行 Docker 的最小内核），是一套虚拟机的管理环境。Vagrant 可以在多种系统上和虚拟机软件中运行，可以在 Windows，Mac 等非 Linux 平台上为 Docker 提供支持，自身具有较好的包装性和移植性。
-
 * 原生的 Docker 自身只能运行在 Linux 平台上，但启动和运行的性能都比虚拟机要快，往往更适合快速开发和部署应用的场景。
 
 简单说：Vagrant 适合用来管理虚拟机，而 Docker 适合用来管理应用环境。

appendix/repo/mongodb.md

@@ -14,19 +14,29 @@
 $ docker run --name mongo -d mongo
 ```
 
-使用其他应用连接到容器，可以用
-
+使用其他应用连接到容器，首先创建网络
 ```bash
-$ docker run --name some-app --link some-mongo:mongo -d application-that-uses-mongo
+$ docker network create my-mongo-net
+```
+
+然后启动 MongoDB 容器
+```bash
+$ docker run --name some-mongo -d --network my-mongo-net mongo
+```
+
+最后启动应用容器
+```bash
+$ docker run --name some-app -d --network my-mongo-net application-that-uses-mongo
 ```
 
 或者通过 `mongo`
 
 ```bash
 $ docker run -it --rm \
-    --link some-mongo:mongo \
+    --network my-mongo-net \
     mongo \
-    sh -c 'exec mongo "$MONGO_PORT_27017_TCP_ADDR:$MONGO_PORT_27017_TCP_PORT/test"'
+    sh -c 'exec mongo "some-mongo:27017/test"'
+```
 ```
 
 ## Dockerfile

appendix/repo/mysql.md

@@ -16,19 +16,31 @@ $ docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=mysecretpassword -d mysql
 
 之后就可以使用其它应用来连接到该容器。
 
+首先创建网络
 ```bash
-$ docker run --name some-app --link some-mysql:mysql -d application-that-uses-mysql
+$ docker network create my-mysql-net
+```
+
+然后启动 MySQL 容器
+```bash
+$ docker run --name some-mysql -d --network my-mysql-net -e MYSQL_ROOT_PASSWORD=mysecretpassword mysql
+```
+
+最后启动应用容器
+```bash
+$ docker run --name some-app -d --network my-mysql-net application-that-uses-mysql
 ```
 
 或者通过 `mysql` 命令行连接。
 
 ```bash
 $ docker run -it --rm \
-    --link some-mysql:mysql \
+    --network my-mysql-net \
     mysql \
-    sh -c 'exec mysql -h"$MYSQL_PORT_3306_TCP_ADDR" -P"$MYSQL_PORT_3306_TCP_PORT" -uroot -p"$MYSQL_ENV_MYSQL_ROOT_PASSWORD"'
+    sh -c 'exec mysql -hsome-mysql -P3306 -uroot -pmysecretpassword'
 ```
 
+
 ## Dockerfile
 
 请到 https://github.com/docker-library/docs/tree/master/mysql 查看

appendix/repo/redis.md

@@ -22,19 +22,28 @@ $ docker run --name some-redis -d -p 6379:6379 redis redis-server --appendonly y
 
 默认数据存储位置在 `VOLUME/data`。可以使用 `--volumes-from some-volume-container` 或 `-v /docker/host/dir:/data` 将数据存放到本地。
 
-使用其他应用连接到容器，可以用
-
+使用其他应用连接到容器，首先创建网络
 ```bash
-$ docker run --name some-app --link some-redis:redis -d application-that-uses-redis
+$ docker network create my-redis-net
+```
+
+然后启动 redis 容器
+```bash
+$ docker run --name some-redis -d --network my-redis-net redis
+```
+
+最后启动应用容器
+```bash
+$ docker run --name some-app -d --network my-redis-net application-that-uses-redis
 ```
 
 或者通过 `redis-cli`
 
 ```bash
 $ docker run -it --rm \
-    --link some-redis:redis \
+    --network my-redis-net \
     redis \
-    sh -c 'exec redis-cli -h "$REDIS_PORT_6379_TCP_ADDR" -p "$REDIS_PORT_6379_TCP_PORT"'
+    sh -c 'exec redis-cli -h some-redis'
 ```
 
 ## Dockerfile

appendix/repo/wordpress.md

@@ -10,15 +10,28 @@
 
 启动容器需要 MySQL 的支持，默认端口为 `80`。
 
+首先创建网络
 ```bash
-$ docker run --name some-wordpress --link some-mysql:mysql -d wordpress
+$ docker network create my-wordpress-net
+```
+
+启动 MySQL 容器
+```bash
+$ docker run --name some-mysql -d --network my-wordpress-net -e MYSQL_ROOT_PASSWORD=mysecretpassword mysql
+```
+
+启动 WordPress 容器
+```bash
+$ docker run --name some-wordpress -d --network my-wordpress-net -e WORDPRESS_DB_HOST=some-mysql -e WORDPRESS_DB_PASSWORD=mysecretpassword wordpress
 ```
 
 启动 WordPress 容器时可以指定的一些环境变量包括：
 
-* `WORDPRESS_DB_USER` 缺省为 `root`
-* `WORDPRESS_DB_PASSWORD` 缺省为连接 mysql 容器的环境变量 `MYSQL_ROOT_PASSWORD` 的值
-* `WORDPRESS_DB_NAME` 缺省为 `wordpress`
+* `WORDPRESS_DB_HOST`: MySQL 服务的主机名
+* `WORDPRESS_DB_USER`: MySQL 数据库的用户名
+* `WORDPRESS_DB_PASSWORD`: MySQL 数据库的密码
+* `WORDPRESS_DB_NAME`: WordPress 要使用的数据库名
+
 
 ## Dockerfile
 

appendix/resources.md

@@ -20,7 +20,8 @@
 ## 技术交流
 
 * Docker 邮件列表： https://groups.google.com/forum/#!forum/docker-user
-* Docker 的 IRC 频道：https://chat.freenode.net#docker
+* Docker 社区 Slack：https://dockercommunity.slack.com/
+* Docker Community Discord: https://discord.gg/docker
 * Docker 的 Twitter 主页：https://twitter.com/docker
 
 ## 其它

basic_concept/README.md

@@ -1,8 +1,9 @@
 # 基本概念
 
-**Docker** 包括三个基本概念
-* **镜像**（`Image`）
-* **容器**（`Container`）
-* **仓库**（`Repository`）
+**Docker** 包括三个基本概念：
+
+* **镜像**（`Image`）：Docker 镜像是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）。镜像不包含任何动态数据，其内容在构建之后也不会被改变。
+* **容器**（`Container`）：镜像（`Image`）和容器（`Container`）的关系，就像是面向对象程序设计中的 `类` 和 `实例` 一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。
+* **仓库**（`Repository`）：镜像构建完成后，可以很容易的在当前宿主机上运行，但是，如果需要在其它服务器上使用这个镜像，我们就需要一个集中的存储、分发镜像的服务，Docker Registry 就是这样的服务。
 
 理解了这三个概念，就理解了 **Docker** 的整个生命周期。

basic_concept/image.md

@@ -1,6 +1,6 @@
 # Docker 镜像
 
-我们都知道，操作系统分为 **内核** 和 **用户空间**。对于 `Linux` 而言，内核启动后，会挂载 `root` 文件系统为其提供用户空间支持。而 **Docker 镜像**（`Image`），就相当于是一个 `root` 文件系统。比如官方镜像 `ubuntu:18.04` 就包含了完整的一套 Ubuntu 18.04 最小系统的 `root` 文件系统。
+我们都知道，操作系统分为 **内核** 和 **用户空间**。对于 `Linux` 而言，内核启动后，会挂载 `root` 文件系统为其提供用户空间支持。而 **Docker 镜像**（`Image`），就相当于是一个 `root` 文件系统。比如官方镜像 `ubuntu:24.04` 就包含了完整的一套 Ubuntu 24.04 最小系统的 `root` 文件系统。
 
 **Docker 镜像** 是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）。镜像 **不包含** 任何动态数据，其内容在构建之后也不会被改变。
 

basic_concept/repository.md

@@ -6,7 +6,7 @@
 
 通常，一个仓库会包含同一个软件不同版本的镜像，而标签就常用于对应该软件的各个版本。我们可以通过 `<仓库名>:<标签>` 的格式来指定具体是这个软件哪个版本的镜像。如果不给出标签，将以 `latest` 作为默认标签。
 
-以 [Ubuntu 镜像](https://hub.docker.com/_/ubuntu) 为例，`ubuntu` 是仓库的名字，其内包含有不同的版本标签，如，`16.04`, `18.04`。我们可以通过 `ubuntu:16.04`，或者 `ubuntu:18.04` 来具体指定所需哪个版本的镜像。如果忽略了标签，比如 `ubuntu`，那将视为 `ubuntu:latest`。
+以 [Ubuntu 镜像](https://hub.docker.com/_/ubuntu) 为例，`ubuntu` 是仓库的名字，其内包含有不同的版本标签，如，`22.04`, `24.04`。我们可以通过 `ubuntu:22.04`，或者 `ubuntu:24.04` 来具体指定所需哪个版本的镜像。如果忽略了标签，比如 `ubuntu`，那将视为 `ubuntu:latest`。
 
 仓库名经常以 *两段式路径* 形式出现，比如 `jwilder/nginx-proxy`，前者往往意味着 Docker Registry 多用户环境下的用户名，后者则往往是对应的软件名。但这并非绝对，取决于所使用的具体 Docker Registry 的软件或服务。
 

buildx/buildkit.md

@@ -145,9 +145,9 @@ $ ssh-add ~/.ssh/id_rsa
 $ docker build -t test --ssh default=$SSH_AUTH_SOCK .
 ```
 
-## docker-compose build 使用 Buildkit
+## docker compose build 使用 Buildkit
 
-设置 `COMPOSE_DOCKER_CLI_BUILD=1` 环境变量即可使用。
+设置 `COMPOSE_DOCKER_CLI_BUILD=1` 和 `DOCKER_BUILDKIT=1` 环境变量即可使用。
 
 ## 官方文档
 

buildx/multi-arch-images.md

@@ -1,38 +1,62 @@
-# 使用 buildx 构建多种系统架构支持的 Docker 镜像
+# 构建多种系统架构支持的 Docker 镜像
 
-在之前的版本中构建多种系统架构支持的 Docker 镜像，要想使用统一的名字必须使用 [`$ docker manifest`](../image/manifest.md) 命令。
+Docker 镜像可以支持多种系统架构，这意味着你可以在 `x86_64`、`arm64` 等不同架构的机器上运行同一个镜像。这是通过一个名为 "manifest list"（或称为 "fat manifest"）的文件来实现的。
 
-在 Docker 19.03+ 版本中可以使用 `$ docker buildx build` 命令使用 `BuildKit` 构建镜像。该命令支持 `--platform` 参数可以同时构建支持多种系统架构的 Docker 镜像，大大简化了构建步骤。
+## Manifest List 是什么？
 
-## 新建 `builder` 实例
+Manifest list 是一个包含了多个指向不同架构镜像的 manifest 的文件。当你拉取一个支持多架构的镜像时，Docker 会自动根据你当前的系统架构选择并拉取对应的镜像。
 
-Docker for Linux 不支持构建 `arm` 架构镜像，我们可以运行一个新的容器让其支持该特性，Docker 桌面版无需进行此项设置。
+例如，官方的 `hello-world` 镜像就支持多种架构。你可以使用 `docker manifest inspect` 命令来查看它的 manifest list：
 
 ```bash
-$ docker run --rm --privileged tonistiigi/binfmt:latest --install all
+$ docker manifest inspect hello-world
+{
+   "schemaVersion": 2,
+   "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json",
+   "manifests": [
+      {
+         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
+         "size": 525,
+         "digest": "sha256:80852a401a974d9e923719a948cc5335a0a4435be8778b475844a7153a2382e5",
+         "platform": {
+            "architecture": "amd64",
+            "os": "linux"
+         }
+      },
+      {
+         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
+         "size": 525,
+         "digest": "sha256:3adea81344be1724b383d501736c3852939b33b3903d02474373700b25e5d6e3",
+         "platform": {
+            "architecture": "arm",
+            "os": "linux",
+            "variant": "v5"
+         }
+      },
+      // ... more architectures
+   ]
+}
 ```
 
-由于 Docker 默认的 `builder` 实例不支持同时指定多个 `--platform`，我们必须首先创建一个新的 `builder` 实例。同时由于国内拉取镜像较缓慢，我们可以使用配置了 [镜像加速地址](https://github.com/moby/buildkit/blob/master/docs/buildkitd.toml.md)  的 [`dockerpracticesig/buildkit:master`](https://github.com/docker-practice/buildx) 镜像替换官方镜像。
+## 使用 `docker buildx` 构建多架构镜像
 
-> 如果你有私有的镜像加速器，可以基于 https://github.com/docker-practice/buildx 构建自己的 buildkit 镜像并使用它。
+在 Docker 19.03+ 版本中，`docker buildx` 是推荐的用于构建多架构镜像的工具。它使用 `BuildKit` 作为后端，可以大大简化构建过程。
+
+### 新建 `builder` 实例
+
+首先，你需要创建一个新的 `builder` 实例，因为它支持同时为多个平台构建。
 
 ```bash
-# 适用于国内环境
-$ docker buildx create --use --name=mybuilder-cn --driver docker-container --driver-opt image=dockerpracticesig/buildkit:master
-
-# 适用于腾讯云环境(腾讯云主机、coding.net 持续集成)
-$ docker buildx create --use --name=mybuilder-cn --driver docker-container --driver-opt image=dockerpracticesig/buildkit:master-tencent
-
-# $ docker buildx create --name mybuilder --driver docker-container
-
-$ docker buildx use mybuilder
+$ docker buildx create --name mybuilder --use
+$ docker buildx inspect --bootstrap
 ```
 
-## 构建镜像
+### 构建和推送
 
-新建 Dockerfile 文件。
+使用 `docker buildx build` 命令并指定 `--platform` 参数，可以同时构建支持多种架构的镜像。`--push` 参数会将构建好的镜像和 manifest list 推送到 Docker 仓库。
 
-```docker
+```dockerfile
+# Dockerfile
 FROM --platform=$TARGETPLATFORM alpine
 
 RUN uname -a > /os.txt
@@ -40,87 +64,58 @@ RUN uname -a > /os.txt
 CMD cat /os.txt
 ```
 
-使用 `$ docker buildx build` 命令构建镜像，注意将 `myusername` 替换为自己的 Docker Hub 用户名。
-
-`--push` 参数表示将构建好的镜像推送到 Docker 仓库。
-
 ```bash
-$ docker buildx build --platform linux/arm,linux/arm64,linux/amd64 -t myusername/hello . --push
-
-# 查看镜像信息
-$ docker buildx imagetools inspect myusername/hello
+$ docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 -t your-username/multi-arch-image . --push
 ```
 
-在不同架构运行该镜像，可以得到该架构的信息。
+构建完成后，你就可以在不同架构的机器上拉取并运行 `your-username/multi-arch-image` 这个镜像了。
 
-```bash
-# arm
-$ docker run -it --rm myusername/hello
-Linux buildkitsandbox 4.9.125-linuxkit #1 SMP Fri Sep 7 08:20:28 UTC 2018 armv7l Linux
+### 架构相关的构建参数
 
-# arm64
-$ docker run -it --rm myusername/hello
-Linux buildkitsandbox 4.9.125-linuxkit #1 SMP Fri Sep 7 08:20:28 UTC 2018 aarch64 Linux
+在 `Dockerfile` 中，你可以使用一些预定义的构建参数来根据目标平台定制构建过程：
 
-# amd64
-$ docker run -it --rm myusername/hello
-Linux buildkitsandbox 4.9.125-linuxkit #1 SMP Fri Sep 7 08:20:28 UTC 2018 x86_64 Linux
-```
+*   `TARGETPLATFORM`: 构建镜像的目标平台，例如 `linux/amd64`。
+*   `TARGETOS`: 目标平台的操作系统，例如 `linux`。
+*   `TARGETARCH`: 目标平台的架构，例如 `amd64`。
+*   `TARGETVARIANT`: 目标平台的变种，例如 `v7`。
+*   `BUILDPLATFORM`: 构建环境的平台。
+*   `BUILDOS`: 构建环境的操作系统。
+*   `BUILDARCH`: 构建环境的架构。
+*   `BUILDVARIANT`: 构建环境的变种。
 
-## 架构相关变量
+例如，你可以这样编写 `Dockerfile` 来拷贝特定架构的二进制文件：
 
-`Dockerfile` 支持如下架构相关的变量
-
-**TARGETPLATFORM** 
-
-构建镜像的目标平台，例如 `linux/amd64`, `linux/arm/v7`, `windows/amd64`。
-
-**TARGETOS** 
-
-`TARGETPLATFORM` 的 OS 类型，例如 `linux`, `windows`
-
-**TARGETARCH** 
-
-`TARGETPLATFORM` 的架构类型，例如 `amd64`, `arm`
-
-**TARGETVARIANT**
-
-`TARGETPLATFORM` 的变种，该变量可能为空，例如 `v7`
-
-**BUILDPLATFORM**
-
-构建镜像主机平台，例如 `linux/amd64`
-
-**BUILDOS** 
-
-`BUILDPLATFORM` 的 OS 类型，例如 `linux`
-
-**BUILDARCH** 
-
-`BUILDPLATFORM` 的架构类型，例如 `amd64`
-
-**BUILDVARIANT** 
-
-`BUILDPLATFORM` 的变种，该变量可能为空，例如 `v7`
-
-### 使用举例
-
-例如我们要构建支持 `linux/arm/v7` 和 `linux/amd64` 两种架构的镜像。假设已经生成了两个平台对应的二进制文件：
-
-* `bin/dist-linux-arm`
-* `bin/dist-linux-amd64`
-
-那么 `Dockerfile` 可以这样书写：
-
-```docker
+```dockerfile
 FROM scratch
 
-# 使用变量必须申明
 ARG TARGETOS
-
 ARG TARGETARCH
 
 COPY bin/dist-${TARGETOS}-${TARGETARCH} /dist
 
-ENTRYPOINT ["dist"]
+ENTRYPOINT ["/dist"]
 ```
+
+## 使用 `docker manifest` (底层工具)
+
+`docker manifest` 是一个更底层的命令，可以用来创建、检查和推送 manifest list。虽然 `docker buildx` 在大多数情况下更方便，但了解 `docker manifest` 仍然有助于理解其工作原理。
+
+### 创建 manifest list
+
+```bash
+# 首先，为每个架构构建并推送镜像
+$ docker buildx build --platform linux/amd64 -t your-username/my-app:amd64 . --push
+$ docker buildx build --platform linux/arm64 -t your-username/my-app:arm64 . --push
+
+# 然后，创建一个 manifest list，将它们组合在一起
+$ docker manifest create your-username/my-app:latest \
+    --amend your-username/my-app:amd64 \
+    --amend your-username/my-app:arm64
+
+# 最后，推送 manifest list
+$ docker manifest push your-username/my-app:latest
+```
+
+### 检查 manifest list
+
+你可以使用 `docker manifest inspect` 来查看一个 manifest list 的详细信息，如上文所示。

cases/ci/drone/README.md

@@ -86,11 +86,11 @@ $ git push origin master
 
 打开我们部署好的 `Drone` 网站或者 Drone Cloud，即可看到构建结果。
 
-![](./_images/drone-build.png)
+![](../../../.gitbook/assets/drone-build.png)
 
 当然我们也可以把构建结果上传到 GitHub，Docker Registry，云服务商提供的对象存储，或者生产环境中。
 
-本书 GitBook 也使用 Drone 进行 CI/CD，具体配置信息请查看本书根目录 [`.drone.yml`](https://github.com/yeasy/docker_practice/blob/master/.drone.yml) 文件。
+本书 GitBook 也使用 Drone 进行 CI/CD，具体配置信息请查看本书根目录 [`.drone.yml`](../../../.drone.yml) 文件。
 
 ## 参考链接
 

cases/os/alpine.md

@@ -2,7 +2,7 @@
 
 ## 简介
 
-![Alpine Linux 操作系统](./_images/alpinelinux-logo.png)
+![Alpine Linux 操作系统](../../.gitbook/assets/alpinelinux-logo.png)
 
 `Alpine` 操作系统是一个面向安全的轻型 `Linux` 发行版。它不同于通常 `Linux` 发行版，`Alpine` 采用了 `musl libc` 和 `busybox` 以减小系统的体积和运行时资源消耗，但功能上比 `busybox` 又完善的多，因此得到开源社区越来越多的青睐。在保持瘦身的同时，`Alpine` 还提供了自己的包管理工具 `apk`，可以通过 `https://pkgs.alpinelinux.org/packages` 网站上查询包信息，也可以直接通过 `apk` 命令直接查询和安装各种软件。
 
@@ -65,5 +65,5 @@ RUN sed -i "s/dl-cdn.alpinelinux.org/mirrors.aliyun.com/g" /etc/apk/repositories
 
 * `Alpine` 官网：https://www.alpinelinux.org/
 * `Alpine` 官方仓库：https://github.com/alpinelinux
-* `Alpine` 官方镜像：https://hub.docker.com/_/alpine/
+* `Alpine` 官方镜像：https://hub.docker.com/\_/alpine/
 * `Alpine` 官方镜像仓库：https://github.com/gliderlabs/docker-alpine

cases/os/busybox.md

@@ -2,7 +2,7 @@
 
 ## 简介
 
-![Busybox - Linux 瑞士军刀](./_images/busybox-logo.png)
+![Busybox - Linux 瑞士军刀](../../.gitbook/assets/busybox-logo.png)
 
 `BusyBox` 是一个集成了一百多个最常用 Linux 命令和工具（如 `cat`、`echo`、`grep`、`mount`、`telnet` 等）的精简工具箱，它只需要几 MB 的大小，很方便进行各种快速验证，被誉为“Linux 系统的瑞士军刀”。
 
@@ -111,5 +111,5 @@ tmpfs on /sys/firmware type tmpfs (ro,relatime)
 
 * `Busybox` 官网：https://busybox.net/
 * `Busybox` 官方仓库：https://git.busybox.net/busybox/
-* `Busybox` 官方镜像：https://hub.docker.com/_/busybox/
+* `Busybox` 官方镜像：https://hub.docker.com/\_/busybox/
 * `Busybox` 官方仓库：https://github.com/docker-library/busybox

cases/os/centos.md

@@ -1,15 +1,17 @@
-# CentOS/Fedora
+# CentOS Fedora
 
 ## CentOS 系统简介
 
 `CentOS` 和 `Fedora` 都是基于 `Redhat` 的常见 Linux 分支。`CentOS` 是目前企业级服务器的常用操作系统；`Fedora` 则主要面向个人桌面用户。
 
-![CentOS 操作系统](./_images/centos-logo.png)
+![CentOS 操作系统](../../.gitbook/assets/centos-logo.png)
 
 CentOS（Community Enterprise Operating System，中文意思是：社区企业操作系统），它是基于 `Red Hat Enterprise Linux` 源代码编译而成。由于 `CentOS` 与 `Redhat Linux` 源于相同的代码基础，所以很多成本敏感且需要高稳定性的公司就使用 `CentOS` 来替代商业版 `Red Hat Enterprise Linux`。`CentOS` 自身不包含闭源软件。
 
 ### 使用 CentOS 官方镜像
 
+**注意：CentOS 8 已于 2021 年 12 月 31 日停止维护（EOL）。对于新部署，推荐使用 CentOS Stream，或 Rocky Linux、AlmaLinux 等替代发行版。**
+
 使用 `docker run` 直接运行 `CentOS 7` 镜像，并登录 `bash`。
 
 ```bash
@@ -25,7 +27,7 @@ CentOS Linux release 7.9.2009 (Core)
 
 ## Fedora 系统简介
 
-![Fedora 操作系统](./_images/fedora-logo.png)
+![Fedora 操作系统](../../.gitbook/assets/fedora-logo.png)
 
 `Fedora` 由 `Fedora Project` 社区开发，红帽公司赞助的 `Linux` 发行版。它的目标是创建一套新颖、多功能并且自由和开源的操作系统。`Fedora` 的功能对于用户而言，它是一套功能完备的，可以更新的免费操作系统，而对赞助商 `Red Hat` 而言，它是许多新技术的测试平台。被认为可用的技术最终会加入到 `Red Hat Enterprise Linux` 中。
 
@@ -33,7 +35,6 @@ CentOS Linux release 7.9.2009 (Core)
 
 使用 `docker run` 命令直接运行 `Fedora` 官方镜像，并登录 `bash`。
 
-```bash
 $ docker run -it fedora bash
 Unable to find image 'fedora:latest' locally
 latest: Pulling from library/fedora
@@ -41,16 +42,16 @@ latest: Pulling from library/fedora
 Digest: sha256:64a02df6aac27d1200c2572fe4b9949f1970d05f74d367ce4af994ba5dc3669e
 Status: Downloaded newer image for fedora:latest
 [root@196ca341419b /]# cat /etc/redhat-release
-Fedora release 24 (Twenty Four)
-```
+Fedora release 39 (Thirty Nine)
+
 
 ## 相关资源
 
 * `Fedora` 官网：https://getfedora.org/
 * `Fedora` 官方仓库：https://github.com/fedora-infra
-* `Fedora` 官方镜像：https://hub.docker.com/_/fedora/
+* `Fedora` 官方镜像：https://hub.docker.com/\_/fedora/
 * `Fedora` 官方镜像仓库：https://github.com/fedora-cloud/docker-brew-fedora
 * `CentOS` 官网：https://www.centos.org
 * `CentOS` 官方仓库：https://github.com/CentOS
-* `CentOS` 官方镜像：https://hub.docker.com/_/centos/
+* `CentOS` 官方镜像：https://hub.docker.com/\_/centos/
 * `CentOS` 官方镜像仓库：https://github.com/CentOS/CentOS-Dockerfiles

cases/os/debian.md

@@ -1,10 +1,10 @@
-# Debian/Ubuntu
+# Debian Ubuntu
 
 `Debian` 和 `Ubuntu` 都是目前较为流行的 **Debian 系** 的服务器操作系统，十分适合研发场景。`Docker Hub` 上提供了官方镜像，国内各大容器云服务也基本都提供了相应的支持。
 
 ## Debian 系统简介
 
-![Debian 操作系统](./_images/debian-logo.png)
+![Debian 操作系统](../../.gitbook/assets/debian-logo.png)
 
 `Debian` 是由 `GPL` 和其他自由软件许可协议授权的自由软件组成的操作系统，由 **Debian 计划（Debian Project）** 组织维护。**Debian 计划** 是一个独立的、分散的组织，由 `3000` 人志愿者组成，接受世界多个非盈利组织的资金支持，`Software in the Public Interest` 提供支持并持有商标作为保护机构。`Debian` 以其坚守 `Unix` 和自由软件的精神，以及其给予用户的众多选择而闻名。现时 `Debian` 包括了超过 `25,000` 个软件包并支持 `12` 个计算机系统结构。
 
@@ -26,7 +26,7 @@ Debian GNU/Linux 8
 
 ## Ubuntu 系统简介
 
-![Ubuntu 操作系统](./_images/ubuntu-logo.jpg)
+![Ubuntu 操作系统](../../.gitbook/assets/ubuntu-logo.jpg)
 
 `Ubuntu` 是一个以桌面应用为主的 `GNU/Linux` 操作系统，其名称来自非洲南部祖鲁语或豪萨语的“ubuntu”一词（官方译名“友帮拓”，另有“吾帮托”、“乌班图”、“有奔头”或“乌斑兔”等译名）。`Ubuntu` 意思是“人性”以及“我的存在是因为大家的存在”，是非洲传统的一种价值观，类似华人社会的“仁爱”思想。 `Ubuntu` 基于 `Debian` 发行版和 `GNOME/Unity` 桌面环境，与 `Debian` 的不同在于它每 6 个月会发布一个新版本，每 2 年推出一个长期支持 **（Long Term Support，LTS）** 版本，一般支持 3 年时间。
 
@@ -145,9 +145,9 @@ root@7d93de07bf76:/# curl 127.0.0.1
 * `Debian` 官网：https://www.debian.org/
 * `Neuro Debian` 官网：http://neuro.debian.net/
 * `Debian` 官方仓库：https://github.com/Debian
-* `Debian` 官方镜像：https://hub.docker.com/_/debian/
+* `Debian` 官方镜像：https://hub.docker.com/\_/debian/
 * `Debian` 官方镜像仓库：https://github.com/tianon/docker-brew-debian/
 * `Ubuntu` 官网：https://ubuntu.com
 * `Ubuntu` 官方仓库：https://github.com/ubuntu
-* `Ubuntu` 官方镜像：https://hub.docker.com/_/ubuntu/
+* `Ubuntu` 官方镜像：https://hub.docker.com/\_/ubuntu/
 * `Ubuntu` 官方镜像仓库：https://github.com/tianon/docker-brew-ubuntu-core

cloud/alicloud.md

@@ -1,11 +1,11 @@
 # 阿里云
 
-![阿里云](./_images/aliyun-logo.png)
+![阿里云](../.gitbook/assets/aliyun-logo.png)
 
-[阿里云](https://www.aliyun.com?source=5176.11533457&userCode=8lx5zmtu&type=copy) 创立于 2009 年，是中国较早的云计算平台。阿里云致力于提供安全、可靠的计算和数据处理能力。
+[阿里云](https://www.aliyun.com/?source=5176.11533457\&userCode=8lx5zmtu\&type=copy) 创立于 2009 年，是中国较早的云计算平台。阿里云致力于提供安全、可靠的计算和数据处理能力。
 
-[阿里云](https://www.aliyun.com?source=5176.11533457&userCode=8lx5zmtu&type=copy) 的客户群体中，活跃着微博、虎牙、魅族、优酷等一大批明星互联网公司。在天猫双 11 全球狂欢节等极富挑战的应用场景中，阿里云保持着良好的运行纪录。
+[阿里云](https://www.aliyun.com/?source=5176.11533457\&userCode=8lx5zmtu\&type=copy) 的客户群体中，活跃着微博、虎牙、魅族、优酷等一大批明星互联网公司。在天猫双 11 全球狂欢节等极富挑战的应用场景中，阿里云保持着良好的运行纪录。
 
-[阿里云容器服务 Kubernetes 版 ACK](https://www.aliyun.com/product/kubernetes?source=5176.11533457&userCode=8lx5zmtu&type=copy) 提供了高性能、可伸缩的容器应用管理服务，支持在一组云服务器上通过 Docker 容器来进行应用生命周期管理。容器服务极大简化了用户对容器管理集群的搭建工作，无缝整合了阿里云虚拟化、存储、网络和安全能力。容器服务提供了多种应用发布方式和流水线般的持续交付能力，原生支持微服务架构，助力用户无缝上云和跨云管理。
+[阿里云容器服务 Kubernetes 版 ACK](https://www.aliyun.com/product/kubernetes?source=5176.11533457\&userCode=8lx5zmtu\&type=copy) 提供了高性能、可伸缩的容器应用管理服务，支持在一组云服务器上通过 Docker 容器来进行应用生命周期管理。容器服务极大简化了用户对容器管理集群的搭建工作，无缝整合了阿里云虚拟化、存储、网络和安全能力。容器服务提供了多种应用发布方式和流水线般的持续交付能力，原生支持微服务架构，助力用户无缝上云和跨云管理。
 
 ![](https://img.alicdn.com/tps/TB10yjtPpXXXXacXXXXXXXXXXXX-1531-1140.png)

cloud/aws.md

@@ -1,6 +1,6 @@
 # 亚马逊云
 
-![AWS](./_images/aws-logo.jpg)
+![AWS](../.gitbook/assets/aws-logo.jpg)
 
 [AWS](https://www.amazonaws.cn)，即 Amazon Web Services，是亚马逊（Amazon）公司的 IaaS 和 PaaS 平台服务。AWS 提供了一整套基础设施和应用程序服务，使用户几乎能够在云中运行一切应用程序：从企业应用程序和大数据项目，到社交游戏和移动应用程序。AWS 面向用户提供包括弹性计算、存储、数据库、应用程序在内的一整套云计算服务，能够帮助企业降低 IT 投入成本和维护成本。
 
@@ -8,4 +8,4 @@
 
 2015 年 AWS 正式发布了 EC2 容器服务(ECS)。ECS 的目的是让 Docker 容器变的更加简单，它提供了一个集群和编排的层，用来控制主机上的容器部署，以及部署之后的集群内的容器的生命周期管理。ECS 是诸如 Docker Swarm、Kubernetes、Mesos 等工具的替代，它们工作在同一个层，除了作为一个服务来提供。这些工具和 ECS 不同的地方在于，前者需要用户自己来部署和管理，而 ECS 是“作为服务”来提供的。
 
-![AWS 容器服务](./_images/ECS.jpg)
+![AWS 容器服务](../.gitbook/assets/ECS.jpg)

cloud/intro.md

@@ -1,7 +1,22 @@
 # 简介
 
-目前与容器相关的云计算主要分为两种类型。
+随着容器技术的普及，目前主流的云计算服务商都提供了成熟的容器服务。与容器相关的云计算服务主要分为以下几种类型：
 
-一种是传统的 IaaS 服务商提供对容器相关的服务，包括镜像下载、容器托管等。
+## 1. 容器编排托管服务 (Managed K8s)
 
-另一种是直接基于容器技术对外提供容器云服务，所谓 Container as a Service（CaaS）。
+这是目前最主流的形式。云厂商托管 Kubernetes 的控制平面（Master节点），用户只需管理工作节点（Worker Node）。
+* **优势**：降低了 Kubernetes 集群的维护成本，高可用性由厂商保证。
+* **典型服务**：AWS EKS, Azure AKS, Google GKE, 阿里云 ACK, 腾讯云 TKE。
+
+## 2. 容器实例服务 (Serverless Containers)
+
+这一类服务通常被称为 CaaS (Container as a Service)。用户无需管理底层服务器（EC2/CVM），只需提供镜像和配置即可运行容器。
+* **优势**：极致的弹性，按秒计费，零运维。
+* **典型服务**：AWS Fargate, Azure Container Instances, Google Cloud Run, 阿里云 ECI。
+
+## 3. 镜像仓库服务 (Container Registry)
+
+提供安全、可靠的私有 Docker 镜像存储服务，通常与云厂商的 CI/CD 流水线深度集成。
+* **典型服务**：AWS ECR, Azure ACR, Google GCR/GAR, 阿里云 ACR。
+
+本章将介绍如何在几个主流云平台上使用 Docker 和 Kubernetes 服务。

cloud/tencentCloud.md

@@ -1,11 +1,11 @@
 # 腾讯云
 
-![腾讯云](./_images/qcloud-logo.jpg)
+![腾讯云](../.gitbook/assets/qcloud-logo.jpg)
 
-[腾讯云](https://cloud.tencent.com/act/cps/redirect?redirect=1040&cps_key=3a5255852d5db99dcd5da4c72f05df61&from=console) 在架构方面经过多年积累，并且有着多年对海量互联网服务的经验。不管是社交、游戏还是其他领域，都有多年的成熟产品来提供产品服务。腾讯在云端完成重要部署，为开发者及企业提供云服务、云数据、云运营等整体一站式服务方案。
+[腾讯云](https://cloud.tencent.com/act/cps/redirect?redirect=1040\&cps_key=3a5255852d5db99dcd5da4c72f05df61\&from=console) 在架构方面经过多年积累，并且有着多年对海量互联网服务的经验。不管是社交、游戏还是其他领域，都有多年的成熟产品来提供产品服务。腾讯在云端完成重要部署，为开发者及企业提供云服务、云数据、云运营等整体一站式服务方案。
 
-具体包括 [云服务器](https://cloud.tencent.com/act/cps/redirect?redirect=1001&cps_key=3a5255852d5db99dcd5da4c72f05df61&from=console)、[云存储](https://cloud.tencent.com/act/cps/redirect?redirect=1020&cps_key=3a5255852d5db99dcd5da4c72f05df61&from=console)、[云数据库](https://cloud.tencent.com/act/cps/redirect?redirect=1003&cps_key=3a5255852d5db99dcd5da4c72f05df61&from=console)、[视频与CDN](https://cloud.tencent.com/act/cps/redirect?redirect=1019&cps_key=3a5255852d5db99dcd5da4c72f05df61&from=console) 和 [域名注册](https://dnspod.cloud.tencent.com) 等基础云服务；腾讯云分析（MTA）、腾讯云推送（信鸽）等腾讯整体大数据能力；以及 QQ互联、QQ 空间、微云、微社区等云端链接社交体系。这些正是腾讯云可以提供给这个行业的差异化优势，造就了可支持各种互联网使用场景的高品质的腾讯云技术平台。
+具体包括 [云服务器](https://cloud.tencent.com/act/cps/redirect?redirect=1001\&cps_key=3a5255852d5db99dcd5da4c72f05df61\&from=console)、[云存储](https://cloud.tencent.com/act/cps/redirect?redirect=1020\&cps_key=3a5255852d5db99dcd5da4c72f05df61\&from=console)、[云数据库](https://cloud.tencent.com/act/cps/redirect?redirect=1003\&cps_key=3a5255852d5db99dcd5da4c72f05df61\&from=console)、[视频与CDN](https://cloud.tencent.com/act/cps/redirect?redirect=1019\&cps_key=3a5255852d5db99dcd5da4c72f05df61\&from=console) 和 [域名注册](https://dnspod.cloud.tencent.com) 等基础云服务；腾讯云分析（MTA）、腾讯云推送（信鸽）等腾讯整体大数据能力；以及 QQ互联、QQ 空间、微云、微社区等云端链接社交体系。这些正是腾讯云可以提供给这个行业的差异化优势，造就了可支持各种互联网使用场景的高品质的腾讯云技术平台。
 
-[腾讯云容器服务 TKE](https://cloud.tencent.com/act/cps/redirect?redirect=10058&cps_key=3a5255852d5db99dcd5da4c72f05df61) 是高度可扩展的高性能容器管理服务，用户可以在托管的云服务器实例集群上轻松运行应用程序。使用该服务，将无需安装、运维、扩展用户的集群管理基础设施，只需进行简单的 API 调用，便可启动和停止 Docker 应用程序，查询集群的完整状态，以及使用各种云服务。用户可以根据用户的资源需求和可用性要求在用户的集群中安排容器的置放，满足业务或应用程序的特定要求。
+[腾讯云容器服务 TKE](https://cloud.tencent.com/act/cps/redirect?redirect=10058\&cps_key=3a5255852d5db99dcd5da4c72f05df61) 是高度可扩展的高性能容器管理服务，用户可以在托管的云服务器实例集群上轻松运行应用程序。使用该服务，将无需安装、运维、扩展用户的集群管理基础设施，只需进行简单的 API 调用，便可启动和停止 Docker 应用程序，查询集群的完整状态，以及使用各种云服务。用户可以根据用户的资源需求和可用性要求在用户的集群中安排容器的置放，满足业务或应用程序的特定要求。
 
 ![](https://mc.qcloudimg.com/static/img/0581dbeb97c869bbe6e62025dbc592d7/image.png)

compose/commands.md

@@ -4,12 +4,12 @@
 
 对于 Compose 来说，大部分命令的对象既可以是项目本身，也可以指定为项目中的服务或者容器。如果没有特别的说明，命令对象将是项目，这意味着项目中所有的服务都会受到命令影响。
 
-执行 `docker-compose [COMMAND] --help` 或者 `docker-compose help [COMMAND]` 可以查看具体某个命令的使用格式。
+执行 `docker compose [COMMAND] --help` 或者 `docker compose help [COMMAND]` 可以查看具体某个命令的使用格式。
 
-`docker-compose` 命令的基本的使用格式是
+`docker compose` 命令的基本的使用格式是
 
 ```bash
-docker-compose [-f=<arg>...] [options] [COMMAND] [ARGS...]
+docker compose [-f=<arg>...] [options] [COMMAND] [ARGS...]
 ```
 
 ## 命令选项
@@ -26,13 +26,13 @@ docker-compose [-f=<arg>...] [options] [COMMAND] [ARGS...]
 
 ### `build`
 
-格式为 `docker-compose build [options] [SERVICE...]`。
+格式为 `docker compose build [options] [SERVICE...]`。
 
 构建（重新构建）项目中的服务容器。
 
 服务容器一旦构建后，将会带上一个标记名，例如对于 web 项目中的一个 db 容器，可能是 web_db。
 
-可以随时在项目目录下运行 `docker-compose build` 来重新构建服务。
+可以随时在项目目录下运行 `docker compose build` 来重新构建服务。
 
 选项包括：
 
@@ -64,19 +64,19 @@ docker-compose [-f=<arg>...] [options] [COMMAND] [ARGS...]
 
 ### `kill`
 
-格式为 `docker-compose kill [options] [SERVICE...]`。
+格式为 `docker compose kill [options] [SERVICE...]`。
 
 通过发送 `SIGKILL` 信号来强制停止服务容器。
 
 支持通过 `-s` 参数来指定发送的信号，例如通过如下指令发送 `SIGINT` 信号。
 
 ```bash
-$ docker-compose kill -s SIGINT
+$ docker compose kill -s SIGINT
 ```
 
 ### `logs`
 
-格式为 `docker-compose logs [options] [SERVICE...]`。
+格式为 `docker compose logs [options] [SERVICE...]`。
 
 查看服务容器的输出。默认情况下，docker-compose 将对不同的服务输出使用不同的颜色来区分。可以通过 `--no-color` 来关闭颜色。
 
@@ -84,13 +84,13 @@ $ docker-compose kill -s SIGINT
 
 ### `pause`
 
-格式为 `docker-compose pause [SERVICE...]`。
+格式为 `docker compose pause [SERVICE...]`。
 
 暂停一个服务容器。
 
 ### `port`
 
-格式为 `docker-compose port [options] SERVICE PRIVATE_PORT`。
+格式为 `docker compose port [options] SERVICE PRIVATE_PORT`。
 
 打印某个容器端口所映射的公共端口。
 
@@ -102,7 +102,7 @@ $ docker-compose kill -s SIGINT
 
 ### `ps`
 
-格式为 `docker-compose ps [options] [SERVICE...]`。
+格式为 `docker compose ps [options] [SERVICE...]`。
 
 列出项目中目前的所有容器。
 
@@ -112,7 +112,7 @@ $ docker-compose kill -s SIGINT
 
 ### `pull`
 
-格式为 `docker-compose pull [options] [SERVICE...]`。
+格式为 `docker compose pull [options] [SERVICE...]`。
 
 拉取服务依赖的镜像。
 
@@ -126,7 +126,7 @@ $ docker-compose kill -s SIGINT
 
 ### `restart`
 
-格式为 `docker-compose restart [options] [SERVICE...]`。
+格式为 `docker compose restart [options] [SERVICE...]`。
 
 重启项目中的服务。
 
@@ -136,9 +136,9 @@ $ docker-compose kill -s SIGINT
 
 ### `rm`
 
-格式为 `docker-compose rm [options] [SERVICE...]`。
+格式为 `docker compose rm [options] [SERVICE...]`。
 
-删除所有（停止状态的）服务容器。推荐先执行 `docker-compose stop` 命令来停止容器。
+删除所有（停止状态的）服务容器。推荐先执行 `docker compose stop` 命令来停止容器。
 
 选项：
 
@@ -147,14 +147,14 @@ $ docker-compose kill -s SIGINT
 * `-v` 删除容器所挂载的数据卷。
 
 ### `run`
-格式为 `docker-compose run [options] [-p PORT...] [-e KEY=VAL...] SERVICE [COMMAND] [ARGS...]`。
+格式为 `docker compose run [options] [-p PORT...] [-e KEY=VAL...] SERVICE [COMMAND] [ARGS...]`。
 
 在指定服务上执行一个命令。
 
 例如：
 
 ```bash
-$ docker-compose run ubuntu ping docker.com
+$ docker compose run ubuntu ping docker.com
 ```
 
 将会启动一个 ubuntu 服务容器，并执行 `ping docker.com` 命令。
@@ -172,7 +172,7 @@ $ docker-compose run ubuntu ping docker.com
 如果不希望自动启动关联的容器，可以使用 `--no-deps` 选项，例如
 
 ```bash
-$ docker-compose run --no-deps web python manage.py shell
+$ docker compose run --no-deps web python manage.py shell
 ```
 
 将不会启动 web 容器所关联的其它容器。
@@ -201,14 +201,14 @@ $ docker-compose run --no-deps web python manage.py shell
 
 ### `scale`
 
-格式为 `docker-compose scale [options] [SERVICE=NUM...]`。
+格式为 `docker compose scale [options] [SERVICE=NUM...]`。
 
 设置指定服务运行的容器个数。
 
 通过 `service=num` 的参数来设置数量。例如：
 
 ```bash
-$ docker-compose scale web=3 db=2
+$ docker compose scale web=3 db=2
 ```
 
 将启动 3 个容器运行 web 服务，2 个容器运行 db 服务。
@@ -221,15 +221,15 @@ $ docker-compose scale web=3 db=2
 
 ### `start`
 
-格式为 `docker-compose start [SERVICE...]`。
+格式为 `docker compose start [SERVICE...]`。
 
 启动已经存在的服务容器。
 
 ### `stop`
 
-格式为 `docker-compose stop [options] [SERVICE...]`。
+格式为 `docker compose stop [options] [SERVICE...]`。
 
-停止已经处于运行状态的容器，但不删除它。通过 `docker-compose start` 可以再次启动这些容器。
+停止已经处于运行状态的容器，但不删除它。通过 `docker compose start` 可以再次启动这些容器。
 
 选项：
 
@@ -241,13 +241,13 @@ $ docker-compose scale web=3 db=2
 
 ### `unpause`
 
-格式为 `docker-compose unpause [SERVICE...]`。
+格式为 `docker compose unpause [SERVICE...]`。
 
 恢复处于暂停状态中的服务。
 
 ### `up`
 
-格式为 `docker-compose up [options] [SERVICE...]`。
+格式为 `docker compose up [options] [SERVICE...]`。
 
 该命令十分强大，它将尝试自动完成包括构建镜像，（重新）创建服务，启动服务，并关联服务相关容器的一系列操作。
 
@@ -255,13 +255,13 @@ $ docker-compose scale web=3 db=2
 
 可以说，大部分时候都可以直接通过该命令来启动一个项目。
 
-默认情况，`docker-compose up` 启动的容器都在前台，控制台将会同时打印所有容器的输出信息，可以很方便进行调试。
+默认情况，`docker compose up` 启动的容器都在前台，控制台将会同时打印所有容器的输出信息，可以很方便进行调试。
 
 当通过 `Ctrl-C` 停止命令时，所有容器将会停止。
 
-如果使用 `docker-compose up -d`，将会在后台启动并运行所有的容器。一般推荐生产环境下使用该选项。
+如果使用 `docker compose up -d`，将会在后台启动并运行所有的容器。一般推荐生产环境下使用该选项。
 
-默认情况，如果服务容器已经存在，`docker-compose up` 将会尝试停止容器，然后重新创建（保持使用 `volumes-from` 挂载的卷），以保证新启动的服务匹配 `docker-compose.yml` 文件的最新内容。如果用户不希望容器被停止并重新创建，可以使用 `docker-compose up --no-recreate`。这样将只会启动处于停止状态的容器，而忽略已经运行的服务。如果用户只想重新部署某个服务，可以使用 `docker-compose up --no-deps -d <SERVICE_NAME>` 来重新创建服务并后台停止旧服务，启动新服务，并不会影响到其所依赖的服务。
+默认情况，如果服务容器已经存在，`docker compose up` 将会尝试停止容器，然后重新创建（保持使用 `volumes-from` 挂载的卷），以保证新启动的服务匹配 `docker-compose.yml` 文件的最新内容。如果用户不希望容器被停止并重新创建，可以使用 `docker compose up --no-recreate`。这样将只会启动处于停止状态的容器，而忽略已经运行的服务。如果用户只想重新部署某个服务，可以使用 `docker compose up --no-deps -d <SERVICE_NAME>` 来重新创建服务并后台停止旧服务，启动新服务，并不会影响到其所依赖的服务。
 
 选项：
 
@@ -281,7 +281,7 @@ $ docker-compose scale web=3 db=2
 
 ### `version`
 
-格式为 `docker-compose version`。
+格式为 `docker compose version`。
 
 打印版本信息。
 

compose/compose_file.md

@@ -5,7 +5,7 @@
 默认的模板文件名称为 `docker-compose.yml`，格式为 YAML 格式。
 
 ```yaml
-version: "3"
+version: "3" # 在 Compose V2 中，version 字段已成为可选，且推荐不再使用。
 
 services:
   webapp:
@@ -306,7 +306,7 @@ labels:
 
 ## `links`
 
->注意：不推荐使用该指令。
+>注意：不推荐使用该指令。容器之间应通过 Docker 网络（networks）进行互联。
 
 ## `logging`
 

compose/demo/django/requirements.txt

@@ -1,2 +1,2 @@
-Django>=2.0,<3.0
+Django>=5.0.6,<6.0
 psycopg2>=2.7,<3.0

compose/django.md

@@ -49,10 +49,10 @@ services:
 
 查看 [`docker-compose.yml` 章节](compose_file.md) 了解更多详细的工作机制。
 
-现在我们就可以使用 `docker-compose run` 命令启动一个 `Django` 应用了。
+现在我们就可以使用 `docker compose run` 命令启动一个 `Django` 应用了。
 
 ```bash
-$ docker-compose run web django-admin startproject django_example .
+$ docker compose run web django-admin startproject django_example .
 ```
 
 由于 web 服务所使用的镜像并不存在，所以 Compose 会首先使用 `Dockerfile` 为 web 服务构建一个镜像，接着使用这个镜像在容器里运行 `django-admin startproject django_example` 指令。
@@ -85,10 +85,10 @@ DATABASES = {
 }
 ```
 
-这些信息是在 [postgres](https://hub.docker.com/_/postgres/) 镜像固定设置好的。然后，运行 `docker-compose up` ：
+这些信息是在 [postgres](https://hub.docker.com/_/postgres/) 镜像固定设置好的。然后，运行 `docker compose up` ：
 
 ```bash
-$ docker-compose up
+$ docker compose up
 
 django_db_1 is up-to-date
 Creating django_web_1 ...
@@ -113,8 +113,8 @@ web_1  | Quit the server with CONTROL-C.
 
 这个 `Django` 应用已经开始在你的 Docker 守护进程里监听着 `8000` 端口了。打开 `127.0.0.1:8000` 即可看到 `Django` 欢迎页面。
 
-你还可以在 Docker 上运行其它的管理命令，例如对于同步数据库结构这种事，在运行完 `docker-compose up` 后，在另外一个终端进入文件夹运行以下命令即可：
+你还可以在 Docker 上运行其它的管理命令，例如对于同步数据库结构这种事，在运行完 `docker compose up` 后，在另外一个终端进入文件夹运行以下命令即可：
 
 ```bash
-$ docker-compose run web python manage.py syncdb
+$ docker compose run web python manage.py syncdb
 ```

compose/install.md

@@ -1,59 +1,46 @@
 # 安装与卸载
 
+`Compose` 是 Docker 官方的开源项目，负责实现对 Docker 容器集群的快速编排。
+
+从 `v2` 版本开始，`Compose` 作为 `docker` 的子命令存在，例如 `docker compose up`。
+
 `Compose` 支持 Linux、macOS、Windows 10 三大平台。
 
-`Compose` 可以通过 Python 的包管理工具 `pip` 进行安装，也可以直接下载编译好的二进制文件使用，甚至能够直接在 Docker 容器中运行。
-
-`Docker Desktop for Mac/Windows` 自带 `docker-compose` 二进制文件，安装 Docker 之后可以直接使用。
-
-```bash
-$ docker-compose --version
-
-docker-compose version 1.27.4, build 40524192
-```
+`Docker Desktop for Mac/Windows` 自带 `docker compose` 命令。
 
 Linux 系统请使用以下介绍的方法安装。
 
-## 二进制包
+## Linux
 
-在 Linux 上的也安装十分简单，从 [官方 GitHub Release](https://github.com/docker/compose/releases) 处直接下载编译好的二进制文件即可。
+在 Linux 上，你可以通过下载 `docker-compose` 二进制包来安装。
+
+从 [官方 GitHub Release](https://github.com/docker/compose/releases) 处直接下载编译好的二进制文件即可。
 
 例如，在 Linux 64 位系统上直接下载对应的二进制包。
 
 ```bash
-$ sudo curl -L https://github.com/docker/compose/releases/download/1.27.4/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
-
-# 国内用户可以使用以下方式加快下载
-$ sudo curl -L https://download.fastgit.org/docker/compose/releases/download/1.27.4/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
-
-$ sudo chmod +x /usr/local/bin/docker-compose
+$ DOCKER_CONFIG=${DOCKER_CONFIG:-$HOME/.docker}
+$ mkdir -p $DOCKER_CONFIG/cli-plugins
+$ curl -SL https://github.com/docker/compose/releases/download/v2.29.1/docker-compose-linux-x86_64 -o $DOCKER_CONFIG/cli-plugins/docker-compose
 ```
 
-## PIP 安装
-
-*注：* `x86_64` 架构的 Linux 建议按照上边的方法下载二进制包进行安装，如果您计算机的架构是 `ARM` (例如，树莓派)，再使用 `pip` 安装。
-
-这种方式是将 Compose 当作一个 Python 应用来从 pip 源中安装。
-
-执行安装命令：
+之后，执行
 
 ```bash
-$ sudo pip install -U docker-compose
+$ chmod +x $DOCKER_CONFIG/cli-plugins/docker-compose
 ```
 
-可以看到类似如下输出，说明安装成功。
+## 测试安装
 
 ```bash
-Collecting docker-compose
-  Downloading docker-compose-1.27.4.tar.gz (149kB): 149kB downloaded
-...
-Successfully installed docker-compose cached-property requests texttable websocket-client docker-py dockerpty six enum34 backports.ssl-match-hostname ipaddress
+$ docker compose version
+Docker Compose version v2.29.1
 ```
 
 ## bash 补全命令
 
 ```bash
-$ curl -L https://raw.githubusercontent.com/docker/compose/1.27.4/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose
+$ curl -L https://raw.githubusercontent.com/docker/compose/v2.29.1/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose
 ```
 
 ## 卸载
@@ -61,11 +48,5 @@ $ curl -L https://raw.githubusercontent.com/docker/compose/1.27.4/contrib/comple
 如果是二进制包方式安装的，删除二进制文件即可。
 
 ```bash
-$ sudo rm /usr/local/bin/docker-compose
-```
-
-如果是通过 `pip` 安装的，则执行如下命令即可删除。
-
-```bash
-$ sudo pip uninstall docker-compose
-```
+$ rm $DOCKER_CONFIG/cli-plugins/docker-compose
+```

compose/rails.md

@@ -47,10 +47,10 @@ services:
       - "3000:3000"
 ```
 
-所有文件就绪后，我们就可以通过使用 `docker-compose run` 命令生成应用的骨架了。
+所有文件就绪后，我们就可以通过使用 `docker compose run` 命令生成应用的骨架了。
 
 ```bash
-$ docker-compose run web rails new . --force --database=postgresql --skip-bundle
+$ docker compose run web rails new . --force --database=postgresql --skip-bundle
 ```
 
 `Compose` 会先使用 `Dockerfile` 为 web 服务创建一个镜像，接着使用这个镜像在容器里运行 `rails new ` 和它之后的命令。一旦这个命令运行完后，应该就可以看一个崭新的应用已经生成了。
@@ -73,7 +73,7 @@ gem 'therubyracer', platforms: :ruby
 现在我们已经有一个新的 `Gemfile` 文件，需要再重新创建镜像。（这个会步骤会改变 Dockerfile 文件本身，所以需要重建一次）。
 
 ```bash
-$ docker-compose build
+$ docker compose build
 ```
 
 应用现在就可以启动了，但配置还未完成。Rails 默认读取的数据库目标是 `localhost` ，我们需要手动指定容器的 `db` 。同样的，还需要把用户名修改成和 postgres 镜像预定的一致。
@@ -97,7 +97,7 @@ test:
 现在就可以启动应用了。
 
 ```bash
-$ docker-compose up
+$ docker compose up
 ```
 
 如果一切正常，你应该可以看到 PostgreSQL 的输出，几秒后可以看到这样的重复信息：
@@ -111,7 +111,7 @@ myapp_web_1 | [2014-01-17 17:16:29] INFO  WEBrick::HTTPServer#start: pid=1 port=
 最后， 我们需要做的是创建数据库，打开另一个终端，运行：
 
 ```bash
-$ docker-compose run web rake db:create
+$ docker compose run web rake db:create
 ```
 
 这个 web 应用已经开始在你的 docker 守护进程里面监听着 3000 端口了。

compose/usage.md

@@ -68,7 +68,67 @@ services:
 ### 运行 compose 项目
 
 ```bash
-$ docker-compose up
+$ docker compose up
 ```
 
 此时访问本地 `5000` 端口，每次刷新页面，计数就会加 1。
+
+
+按下 `Ctrl-C` 停止项目。
+
+### 后台运行
+
+```bash
+$ docker compose up -d
+```
+
+### 停止
+
+```bash
+$ docker compose stop
+```
+
+### 进入服务
+
+```bash
+$ docker compose exec redis sh
+/data # redis-cli
+127.0.0.1:6379> get hits
+"9"
+```
+
+### 查看日志
+
+```bash
+$ docker compose logs -f
+```
+
+### 构建镜像
+
+```bash
+$ docker compose build
+```
+
+### 启动服务
+
+```bash
+$ docker compose start
+```
+
+### 运行一次性命令
+
+```bash
+$ docker compose run web python app.py
+```
+
+### 验证 `docker-compose.yml`
+
+```bash
+$ docker compose config
+```
+
+### 删除项目
+
+```bash
+$ docker compose down
+```

compose/v2.md

@@ -1,7 +0,0 @@
-# Compose V2
-
-目前 Docker 官方用 GO 语言 [重写](https://github.com/docker/compose-cli) 了 Docker Compose，并将其作为了 docker cli 的子命令，称为 `Compose V2`。你可以参照官方文档安装，然后将熟悉的 `docker-compose` 命令替换为 `docker compose`，即可使用 Docker Compose。
-
-## 官方文档
-
-* [Compose V2 beta](https://docs.docker.com/compose/cli-command/)

compose/wordpress.md

@@ -48,4 +48,4 @@ volumes:
 
 ## 构建并运行项目
 
-运行 `docker-compose up -d` Compose 就会拉取镜像再创建我们所需要的镜像，然后启动 `wordpress` 和数据库容器。 接着浏览器访问 `127.0.0.1:8000` 端口就能看到 `WordPress` 安装界面了。
+运行 `docker compose up -d` Compose 就会拉取镜像再创建我们所需要的镜像，然后启动 `wordpress` 和数据库容器。 接着浏览器访问 `127.0.0.1:8000` 端口就能看到 `WordPress` 安装界面了。

data_management/README.md

@@ -1,9 +1,8 @@
-# Docker 数据管理
+# 数据管理
 
-![](./_images/types-of-mounts.png)
+![](../.gitbook/assets/types-of-mounts.png)
 
 这一章介绍如何在 Docker 内部以及容器之间管理数据，在容器中管理数据主要有两种方式：
 
 * 数据卷（Volumes）
-
 * 挂载主机目录 (Bind mounts)

etcd/cluster.md

@@ -119,7 +119,7 @@ networks:
         subnet: 172.16.238.0/24
 ```
 
-使用 `docker-compose up` 启动集群之后使用 `docker exec` 命令登录到任一节点测试 `etcd` 集群。
+使用 `docker compose up` 启动集群之后使用 `docker exec` 命令登录到任一节点测试 `etcd` 集群。
 
 ```bash
 / # etcdctl member list

etcd/etcdctl-v2.md

@@ -1,281 +0,0 @@
-# 使用 etcdctl v2
-
-`etcdctl` 是一个命令行客户端，它能提供一些简洁的命令，供用户直接跟 `etcd` 服务打交道，而无需基于 `HTTP API` 方式。这在某些情况下将很方便，例如用户对服务进行测试或者手动修改数据库内容。我们也推荐在刚接触 `etcd` 时通过 `etcdctl` 命令来熟悉相关的操作，这些操作跟 `HTTP API` 实际上是对应的。
-
-`etcd` 项目二进制发行包中已经包含了 `etcdctl` 工具，没有的话，可以从 [github.com/etcd-io/etcd/releases](https://github.com/etcd-io/etcd/releases) 下载。
-
-`etcdctl` 支持如下的命令，大体上分为数据库操作和非数据库操作两类，后面将分别进行解释。
-
-```
-$ etcdctl -h
-NAME:
-   etcdctl - A simple command line client for etcd.
-
-USAGE:
-   etcdctl [global options] command [command options] [arguments...]
-
-VERSION:
-   2.0.0-rc.1
-
-COMMANDS:
-   backup	backup an etcd directory
-   mk		make a new key with a given value
-   mkdir	make a new directory
-   rm		remove a key
-   rmdir	removes the key if it is an empty directory or a key-value pair
-   get		retrieve the value of a key
-   ls		retrieve a directory
-   set		set the value of a key
-   setdir	create a new or existing directory
-   update	update an existing key with a given value
-   updatedir	update an existing directory
-   watch	watch a key for changes
-   exec-watch	watch a key for changes and exec an executable
-   member	member add, remove and list subcommands
-   help, h	Shows a list of commands or help for one command
-
-GLOBAL OPTIONS:
-   --debug			output cURL commands which can be used to reproduce the request
-   --no-sync			don't synchronize cluster information before sending request
-   --output, -o 'simple'	output response in the given format (`simple` or `json`)
-   --peers, -C 			a comma-delimited list of machine addresses in the cluster (default: "127.0.0.1:4001")
-   --cert-file 			identify HTTPS client using this SSL certificate file
-   --key-file 			identify HTTPS client using this SSL key file
-   --ca-file 			verify certificates of HTTPS-enabled servers using this CA bundle
-   --help, -h			show help
-   --version, -v		print the version
-```
-
-## 数据库操作
-数据库操作围绕对键值和目录的 CRUD （符合 REST 风格的一套操作：Create）完整生命周期的管理。
-
-etcd 在键的组织上采用了层次化的空间结构（类似于文件系统中目录的概念），用户指定的键可以为单独的名字，如 `testkey`，此时实际上放在根目录 `/` 下面，也可以为指定目录结构，如 `cluster1/node2/testkey`，则将创建相应的目录结构。
-
-*注：CRUD 即 Create, Read, Update, Delete，是符合 REST 风格的一套 API 操作。*
-
-### set
-指定某个键的值。例如
-```bash
-$ etcdctl set /testdir/testkey "Hello world"
-Hello world
-```
-支持的选项包括：
-```bash
---ttl '0'			该键值的超时时间（单位为秒），不配置（默认为 0）则永不超时
---swap-with-value value 若该键现在的值是 value，则进行设置操作
---swap-with-index '0'	若该键现在的索引值是指定索引，则进行设置操作
-```
-
-### get
-获取指定键的值。例如
-```bash
-$ etcdctl set testkey hello
-hello
-$ etcdctl update testkey world
-world
-```
-
-当键不存在时，则会报错。例如
-```bash
-$ etcdctl get testkey2
-Error:  100: Key not found (/testkey2) [1]
-```
-
-支持的选项为
-```bash
---sort	对结果进行排序
---consistent 将请求发给主节点，保证获取内容的一致性
-```
-
-### update
-当键存在时，更新值内容。例如
-```bash
-$ etcdctl set testkey hello
-hello
-$ etcdctl update testkey world
-world
-```
-
-当键不存在时，则会报错。例如
-```bash
-$ etcdctl update testkey2 world
-Error:  100: Key not found (/testkey2) [1]
-```
-
-支持的选项为
-```bash
---ttl '0'	超时时间（单位为秒），不配置（默认为 0）则永不超时
-```
-
-### rm
-删除某个键值。例如
-```bash
-$ etcdctl rm testkey
-```
-
-当键不存在时，则会报错。例如
-```bash
-$ etcdctl rm testkey2
-Error:  100: Key not found (/testkey2) [8]
-```
-
-支持的选项为
-```bash
---dir		如果键是个空目录或者键值对则删除
---recursive		删除目录和所有子键
---with-value 	检查现有的值是否匹配
---with-index '0'	检查现有的 index 是否匹配
-```
-
-### mk
-如果给定的键不存在，则创建一个新的键值。例如
-```bash
-$ etcdctl mk /testdir/testkey "Hello world"
-Hello world
-```
-当键存在的时候，执行该命令会报错，例如
-```bash
-$ etcdctl set testkey "Hello world"
-Hello world
-$ ./etcdctl mk testkey "Hello world"
-Error:  105: Key already exists (/testkey) [2]
-```
-
-支持的选项为
-```bash
---ttl '0'	超时时间（单位为秒），不配置（默认为 0）则永不超时
-```
-
-### mkdir
-如果给定的键目录不存在，则创建一个新的键目录。例如
-```bash
-$ etcdctl mkdir testdir
-```
-当键目录存在的时候，执行该命令会报错，例如
-```bash
-$ etcdctl mkdir testdir
-$ etcdctl mkdir testdir
-Error:  105: Key already exists (/testdir) [7]
-```
-支持的选项为
-```bash
---ttl '0'	超时时间（单位为秒），不配置（默认为 0）则永不超时
-```
-
-### setdir
-
-创建一个键目录，无论存在与否。
-
-支持的选项为
-```bash
---ttl '0'	超时时间（单位为秒），不配置（默认为 0）则永不超时
-```
-
-### updatedir
-更新一个已经存在的目录。
-支持的选项为
-```bash
---ttl '0'	超时时间（单位为秒），不配置（默认为 0）则永不超时
-```
-
-### rmdir
-删除一个空目录，或者键值对。
-
-若目录不空，会报错
-```bash
-$ etcdctl set /dir/testkey hi
-hi
-$ etcdctl rmdir /dir
-Error:  108: Directory not empty (/dir) [13]
-```
-
-### ls
-列出目录（默认为根目录）下的键或者子目录，默认不显示子目录中内容。
-
-例如
-```bash
-$ ./etcdctl set testkey 'hi'
-hi
-$ ./etcdctl set dir/test 'hello'
-hello
-$ ./etcdctl ls
-/testkey
-/dir
-$ ./etcdctl ls dir
-/dir/test
-```
-
-支持的选项包括
-```bash
---sort	将输出结果排序
---recursive	如果目录下有子目录，则递归输出其中的内容
--p		对于输出为目录，在最后添加 `/` 进行区分
-```
-
-## 非数据库操作
-
-### backup
-备份 etcd 的数据。
-
-支持的选项包括
-```bash
---data-dir 		etcd 的数据目录
---backup-dir 	备份到指定路径
-```
-### watch
-监测一个键值的变化，一旦键值发生更新，就会输出最新的值并退出。
-
-例如，用户更新 testkey 键值为 Hello world。
-```bash
-$ etcdctl watch testkey
-Hello world
-```
-
-支持的选项包括
-```bash
---forever		一直监测，直到用户按 `CTRL+C` 退出
---after-index '0'	在指定 index 之前一直监测
---recursive		返回所有的键值和子键值
-```
-### exec-watch
-监测一个键值的变化，一旦键值发生更新，就执行给定命令。
-
-例如，用户更新 testkey 键值。
-```bash
-$ etcdctl exec-watch testkey -- sh -c 'ls'
-default.etcd
-Documentation
-etcd
-etcdctl
-etcd-migrate
-README-etcdctl.md
-README.md
-```
-
-支持的选项包括
-```bash
---after-index '0'	在指定 index 之前一直监测
---recursive		返回所有的键值和子键值
-```
-
-### member
-
-通过 list、add、remove 命令列出、添加、删除 etcd 实例到 etcd 集群中。
-
-例如本地启动一个 etcd 服务实例后，可以用如下命令进行查看。
-
-```bash
-$ etcdctl member list
-ce2a822cea30bfca: name=default peerURLs=http://localhost:2380,http://localhost:7001 clientURLs=http://localhost:2379,http://localhost:4001
-```
-
-## 命令选项
-* `--debug`			输出 cURL 命令，显示执行命令的时候发起的请求
-* `--no-sync`			发出请求之前不同步集群信息
-* `--output, -o 'simple'`	输出内容的格式 (`simple` 为原始信息，`json` 为进行json格式解码，易读性好一些)
-* `--peers, -C`			指定集群中的同伴信息，用逗号隔开 (默认为: "127.0.0.1:4001")
-* `--cert-file` 			HTTPS 下客户端使用的 SSL 证书文件
-* `--key-file`			HTTPS 下客户端使用的 SSL 密钥文件
-* `--ca-file` 			服务端使用 HTTPS 时，使用 CA 文件进行验证
-* `--help, -h`			显示帮助命令信息
-* `--version, -v`		打印版本信息

etcd/intro.md

@@ -1,6 +1,6 @@
-# 什么是 etcd
+# 简介
 
-![](./_images/etcd_logo.png)
+![](../.gitbook/assets/etcd_logo.png)
 
 `etcd` 是 `CoreOS` 团队于 2013 年 6 月发起的开源项目，它的目标是构建一个高可用的分布式键值（`key-value`）数据库，基于 `Go` 语言实现。我们知道，在分布式系统中，各种服务的配置信息的管理分享，服务的发现是一个很基本同时也是很重要的问题。`CoreOS` 项目就希望基于 `etcd` 来解决这一问题。
 
@@ -9,17 +9,14 @@
 受到 [Apache ZooKeeper](https://zookeeper.apache.org/) 项目和 [doozer](https://github.com/ha/doozerd) 项目的启发，`etcd` 在设计的时候重点考虑了下面四个要素：
 
 * 简单：具有定义良好、面向用户的 `API` ([gRPC](https://github.com/grpc/grpc))
-
 * 安全：支持 `HTTPS` 方式的访问
-
 * 快速：支持并发 `10 k/s` 的写操作
-
 * 可靠：支持分布式结构，基于 `Raft` 的一致性算法
 
-*Apache ZooKeeper 是一套知名的分布式系统中进行同步和一致性管理的工具。*
+_Apache ZooKeeper 是一套知名的分布式系统中进行同步和一致性管理的工具。_
 
-*doozer 是一个一致性分布式数据库。*
+_doozer 是一个一致性分布式数据库。_
 
-*[Raft](https://raft.github.io/) 是一套通过选举主节点来实现分布式系统一致性的算法，相比于大名鼎鼎的 Paxos 算法，它的过程更容易被人理解，由 Stanford 大学的 Diego Ongaro 和 John Ousterhout 提出。更多细节可以参考 [raftconsensus.github.io](http://raftconsensus.github.io)。*
+[_Raft_](https://raft.github.io/) _是一套通过选举主节点来实现分布式系统一致性的算法，相比于大名鼎鼎的 Paxos 算法，它的过程更容易被人理解，由 Stanford 大学的 Diego Ongaro 和 John Ousterhout 提出。更多细节可以参考_ [_raftconsensus.github.io_](http://raftconsensus.github.io)_。_
 
 一般情况下，用户使用 `etcd` 可以在多个节点上启动多个实例，并添加它们为一个集群。同一个集群中的 `etcd` 实例将会保持彼此信息的一致性。

image/build.md

@@ -57,7 +57,7 @@ RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html
 既然 `RUN` 就像 Shell 脚本一样可以执行命令，那么我们是否就可以像 Shell 脚本一样把每个命令对应一个 RUN 呢？比如这样：
 
 ```docker
-FROM debian:stretch
+FROM debian:bookworm
 
 RUN apt-get update
 RUN apt-get install -y gcc libc6-dev make wget
@@ -78,7 +78,7 @@ RUN make -C /usr/src/redis install
 上面的 `Dockerfile` 正确的写法应该是这样：
 
 ```docker
-FROM debian:stretch
+FROM debian:bookworm
 
 RUN set -x; buildDeps='gcc libc6-dev make wget' \
     && apt-get update \

image/commit.md

@@ -1,6 +1,6 @@
 # 利用 commit 理解镜像构成
 
->注意：如果您是初学者，您可以暂时跳过后面的内容，直接学习 [容器](../container) 一节。
+> 注意：如果您是初学者，您可以暂时跳过后面的内容，直接学习 [容器](../container/) 一节。
 
 注意： `docker commit` 命令除了学习之外，还有一些特殊的应用场合，比如被入侵后保存现场等。但是，不要使用 `docker commit` 定制镜像，定制镜像应该使用 `Dockerfile` 来完成。如果你想要定制镜像请查看下一小节。
 
@@ -16,11 +16,11 @@ $ docker run --name webserver -d -p 80:80 nginx
 
 这条命令会用 `nginx` 镜像启动一个容器，命名为 `webserver`，并且映射了 80 端口，这样我们可以用浏览器去访问这个 `nginx` 服务器。
 
-  如果是在本机运行的 Docker，那么可以直接访问：`http://localhost` ，如果是在虚拟机、云服务器上安装的 Docker，则需要将 `localhost` 换为虚拟机地址或者实际云服务器地址。
+如果是在本机运行的 Docker，那么可以直接访问：`http://localhost` ，如果是在虚拟机、云服务器上安装的 Docker，则需要将 `localhost` 换为虚拟机地址或者实际云服务器地址。
 
 直接用浏览器访问的话，我们会看到默认的 Nginx 欢迎页面。
 
-![](./_images/images-mac-example-nginx.png)
+![](../.gitbook/assets/images-mac-example-nginx.png)
 
 现在，假设我们非常不喜欢这个欢迎页面，我们希望改成欢迎 Docker 的文字，我们可以使用 `docker exec` 命令进入容器，修改其内容。
 
@@ -37,7 +37,7 @@ exit
 
 现在我们再刷新浏览器的话，会发现内容被改变了。
 
-![](./_images/images-create-nginx-docker.png)
+![](../.gitbook/assets/images-create-nginx-docker.png)
 
 我们修改了容器的文件，也就是改动了容器的存储层。我们可以通过 `docker diff` 命令看到具体的改动。
 

image/manifest.md

@@ -1,162 +0,0 @@
-# 构建多种系统架构支持的 Docker 镜像 -- docker manifest 命令详解
-
-我们知道使用镜像创建一个容器，该镜像必须与 Docker 宿主机系统架构一致，例如 `Linux x86_64` 架构的系统中只能使用 `Linux x86_64` 的镜像创建容器。
-
-> Windows、macOS 除外，其使用了 [binfmt_misc](https://docs.docker.com/docker-for-mac/multi-arch/) 提供了多种架构支持，在 Windows、macOS 系统上 (x86_64) 可以运行 arm 等其他架构的镜像。
-
-例如我们在 `Linux x86_64` 中构建一个 `username/test` 镜像。
-
-```docker
-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` 架构的计算机中分别使用 `golang:alpine` 镜像运行容器 `$ docker run golang:alpine go version` 时，容器能够正常的运行。
-
-这是什么原因呢？
-
-原因就是 `golang:alpine` 官方镜像有一个 [`manifest` 列表 (`manifest list`)](https://docs.docker.com/registry/spec/manifest-v2-2/)。
-
-当用户获取一个镜像时，Docker 引擎会首先查找该镜像是否有 `manifest` 列表，如果有的话 Docker 引擎会按照 Docker 运行环境（系统及架构）查找出对应镜像（例如 `golang:alpine`）。如果没有的话会直接获取镜像（例如上例中我们构建的 `username/test`）。
-
-我们可以使用 `$ docker manifest inspect golang:alpine` 查看这个 `manifest` 列表的结构。
-
-```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://www.docker.com/blog/multi-arch-all-the-things/

image/multistage-builds/README.md

@@ -35,7 +35,8 @@ WORKDIR /go/src/github.com/go/helloworld/
 
 COPY app.go .
 
-RUN go get -d -v github.com/go-sql-driver/mysql \
+RUN go mod init helloworld \
+  && go get -d -v github.com/go-sql-driver/mysql \
   && CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o app . \
   && cp /go/src/github.com/go/helloworld/app /root
 

image/pull.md

@@ -16,17 +16,17 @@ $ docker pull [选项] [Docker Registry 地址[:端口号]/]仓库名[:标签]
 比如：
 
 ```bash
-$ docker pull ubuntu:18.04
+$ docker pull ubuntu:24.04
 18.04: Pulling from library/ubuntu
 92dc2a97ff99: Pull complete
 be13a9d27eb8: Pull complete
 c8299583700a: Pull complete
 Digest: sha256:4bc3ae6596938cb0d9e5ac51a1152ec9dcac2a1c50829c74abd9c4361e321b26
-Status: Downloaded newer image for ubuntu:18.04
-docker.io/library/ubuntu:18.04
+Status: Downloaded newer image for ubuntu:24.04
+docker.io/library/ubuntu:24.04
 ```
 
-上面的命令中没有给出 Docker 镜像仓库地址，因此将会从 Docker Hub （`docker.io`）获取镜像。而镜像名称是 `ubuntu:18.04`，因此将会获取官方镜像 `library/ubuntu` 仓库中标签为 `18.04` 的镜像。`docker pull` 命令的输出结果最后一行给出了镜像的完整名称，即： `docker.io/library/ubuntu:18.04`。
+上面的命令中没有给出 Docker 镜像仓库地址，因此将会从 Docker Hub （`docker.io`）获取镜像。而镜像名称是 `ubuntu:24.04`，因此将会获取官方镜像 `library/ubuntu` 仓库中标签为 `24.04` 的镜像。`docker pull` 命令的输出结果最后一行给出了镜像的完整名称，即： `docker.io/library/ubuntu:24.04`。
 
 从下载过程中可以看到我们之前提及的分层存储的概念，镜像是由多层存储所构成。下载也是一层层的去下载，并非单一文件。下载过程中给出了每一层的 ID 的前 12 位。并且下载结束后，给出该镜像完整的 `sha256` 的摘要，以确保下载一致性。
 
@@ -36,33 +36,33 @@ docker.io/library/ubuntu:18.04
 
 ## 运行
 
-有了镜像后，我们就能够以这个镜像为基础启动并运行一个容器。以上面的 `ubuntu:18.04` 为例，如果我们打算启动里面的 `bash` 并且进行交互式操作的话，可以执行下面的命令。
+有了镜像后，我们就能够以这个镜像为基础启动并运行一个容器。以上面的 `ubuntu:24.04` 为例，如果我们打算启动里面的 `bash` 并且进行交互式操作的话，可以执行下面的命令。
 
 ```bash
-$ docker run -it --rm ubuntu:18.04 bash
+$ docker run -it --rm ubuntu:24.04 bash
 
 root@e7009c6ce357:/# cat /etc/os-release
 NAME="Ubuntu"
-VERSION="18.04.1 LTS (Bionic Beaver)"
+VERSION="24.04 LTS (Noble Numbat)"
 ID=ubuntu
 ID_LIKE=debian
-PRETTY_NAME="Ubuntu 18.04.1 LTS"
-VERSION_ID="18.04"
+PRETTY_NAME="Ubuntu 24.04 LTS"
+VERSION_ID="24.04"
 HOME_URL="https://www.ubuntu.com/"
 SUPPORT_URL="https://help.ubuntu.com/"
 BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
 PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
-VERSION_CODENAME=bionic
-UBUNTU_CODENAME=bionic
+VERSION_CODENAME=noble
+UBUNTU_CODENAME=noble
 ```
 
 `docker run` 就是运行容器的命令，具体格式我们会在 [容器](../container) 一节进行详细讲解，我们这里简要的说明一下上面用到的参数。
 
 * `-it`：这是两个参数，一个是 `-i`：交互式操作，一个是 `-t` 终端。我们这里打算进入 `bash` 执行一些命令并查看返回结果，因此我们需要交互式终端。
 * `--rm`：这个参数是说容器退出后随之将其删除。默认情况下，为了排障需求，退出的容器并不会立即删除，除非手动 `docker rm`。我们这里只是随便执行个命令，看看结果，不需要排障和保留结果，因此使用 `--rm` 可以避免浪费空间。
-* `ubuntu:18.04`：这是指用 `ubuntu:18.04` 镜像为基础来启动容器。
+* `ubuntu:24.04`：这是指用 `ubuntu:24.04` 镜像为基础来启动容器。
 * `bash`：放在镜像名后的是 **命令**，这里我们希望有个交互式 Shell，因此用的是 `bash`。
 
-进入容器后，我们可以在 Shell 下操作，执行任何所需的命令。这里，我们执行了 `cat /etc/os-release`，这是 Linux 常用的查看当前系统版本的命令，从返回的结果可以看到容器内是 `Ubuntu 18.04.1 LTS` 系统。
+进入容器后，我们可以在 Shell 下操作，执行任何所需的命令。这里，我们执行了 `cat /etc/os-release`，这是 Linux 常用的查看当前系统版本的命令，从返回的结果可以看到容器内是 `Ubuntu 24.04 LTS` 系统。
 
 最后我们通过 `exit` 退出了这个容器。

install/centos.md

@@ -6,7 +6,7 @@
 
 ### 系统要求
 
-Docker 支持 64 位版本 CentOS 7/8，并且要求内核版本不低于 3.10。 CentOS 7 满足最低内核的要求，但由于内核版本比较低，部分功能（如 `overlay2` 存储层驱动）无法使用，并且部分功能可能不太稳定。
+Docker 支持 64 位版本 CentOS 7/8/9，以及 Rocky Linux/AlmaLinux 8/9，并且要求内核版本不低于 3.10。 CentOS 7 满足最低内核的要求，但由于内核版本比较低，部分功能（如 `overlay2` 存储层驱动）无法使用，并且部分功能可能不太稳定。对于 CentOS 8 及更高版本，以及 Rocky Linux/AlmaLinux，推荐使用 `dnf` 包管理器。
 
 ### 卸载旧版本
 
@@ -22,7 +22,9 @@ $ sudo yum remove docker \
                   docker-logrotate \
                   docker-selinux \
                   docker-engine-selinux \
-                  docker-engine
+                  docker-engine \
+                  docker-ce-cli \
+                  containerd.io
 ```
 
 ## 使用 yum 安装
@@ -30,7 +32,7 @@ $ sudo yum remove docker \
 执行以下命令安装依赖包：
 
 ```bash
-$ sudo yum install -y yum-utils
+$ sudo dnf install -y dnf-utils
 ```
 
 鉴于国内网络问题，强烈建议使用国内源，官方源请在注释中查看。
@@ -38,14 +40,14 @@ $ sudo yum install -y yum-utils
 执行下面的命令添加 `yum` 软件源：
 
 ```bash
-$ sudo yum-config-manager \
+$ sudo dnf config-manager \
     --add-repo \
     https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
 
-$ sudo sed -i 's/download.docker.com/mirrors.aliyun.com\/docker-ce/g' /etc/yum.repos.d/docker-ce.repo
+$ sudo sed -i 's/download.docker.com/mirrors.aliyun.com\/docker-ce/g' /etc/dnf.repos.d/docker-ce.repo
 
 # 官方源
-# $ sudo yum-config-manager \
+# $ sudo dnf config-manager \
 #     --add-repo \
 #     https://download.docker.com/linux/centos/docker-ce.repo
 ```
@@ -53,15 +55,15 @@ $ sudo sed -i 's/download.docker.com/mirrors.aliyun.com\/docker-ce/g' /etc/yum.r
 如果需要测试版本的 Docker 请执行以下命令：
 
 ```bash
-$ sudo yum-config-manager --enable docker-ce-test
+$ sudo dnf config-manager --enable docker-ce-test
 ```
 
 ### 安装 Docker
 
-更新 `yum` 软件源缓存，并安装 `docker-ce`。
+更新 `dnf` 软件源缓存，并安装 `docker-ce`。
 
 ```bash
-$ sudo yum install docker-ce docker-ce-cli containerd.io
+$ sudo dnf install docker-ce docker-ce-cli containerd.io
 ```
 
 ## CentOS8 额外设置

install/debian.md

@@ -65,7 +65,7 @@ $ echo \
 
 ```
 
->以上命令会添加稳定版本的 Docker APT 源，如果需要测试版本的 Docker 请将 stable 改为 test。
+>以上命令会添加稳定版本的 Docker APT 源，如果需要测试版本的 Docker 请将 stable 改为 test。 Debian11可能不使用`/etc/apt/keyrings/`， 如gpg错误可以考虑更换为`/etc/apt/trusted.gpg.d`， 见[issue 15727](https://github.com/docker/docs/issues/15727)。
 
 ### 安装 Docker
 

install/mac.md

@@ -1,8 +1,8 @@
-# macOS 安装 Docker
+# macOS
 
 ## 系统要求
 
-[Docker Desktop for Mac](https://docs.docker.com/docker-for-mac/) 要求系统最低为 macOS 必须是 10.15 或更高版本， Catalina、Big Sur 或者 Monterey，建议升级到最新版本的 macOS。
+[Docker Desktop for Mac](https://docs.docker.com/docker-for-mac/) 要求系统最低为 macOS Monterey 12.0 或更高版本，建议升级到最新版本的 macOS（如 Sonoma 或 Ventura）。
 
 ## 安装
 
@@ -22,27 +22,27 @@ $ brew install --cask docker
 
 如同 macOS 其它软件一样，安装也非常简单，双击下载的 `.dmg` 文件，然后将那只叫 [Moby](https://www.docker.com/blog/call-me-moby-dock/) 的鲸鱼图标拖拽到 `Application` 文件夹即可（其间需要输入用户密码）。
 
-![](./_images/install-mac-dmg.png)
+![](../.gitbook/assets/install-mac-dmg.png)
 
 ## 运行
 
 从应用中找到 Docker 图标并点击运行。
 
-![](./_images/install-mac-apps.png)
+![](../.gitbook/assets/install-mac-apps.png)
 
 运行之后，会在右上角菜单栏看到多了一个鲸鱼图标，这个图标表明了 Docker 的运行状态。
 
-![](./_images/install-mac-menubar.png)
+![](../.gitbook/assets/install-mac-menubar.png)
 
 每次点击鲸鱼图标会弹出操作菜单。
 
-![](./_images/install-mac-menu.png)
+![](../.gitbook/assets/install-mac-menu.png)
 
 之后，你可以在终端通过命令检查安装后的 Docker 版本。
 
 ```bash
 $ docker --version
-Docker version 20.10.0, build 7287ab3
+Docker version 27.2.1, build 9e34c9b
 ```
 
 如果 `docker version`、`docker info` 都正常的话，可以尝试运行一个 [Nginx 服务器](https://hub.docker.com/_/nginx/)：
@@ -51,9 +51,9 @@ Docker version 20.10.0, build 7287ab3
 $ docker run -d -p 80:80 --name webserver nginx
 ```
 
-服务运行后，可以访问 <http://localhost>，如果看到了 "Welcome to nginx!"，就说明 Docker Desktop for Mac 安装成功了。
+服务运行后，可以访问 [http://localhost](http://localhost)，如果看到了 "Welcome to nginx!"，就说明 Docker Desktop for Mac 安装成功了。
 
-![](./_images/install-mac-example-nginx.png)
+![](../.gitbook/assets/install-mac-example-nginx.png)
 
 要停止 Nginx 服务器并删除执行下面的命令：
 

install/mirror.md

@@ -1,16 +1,16 @@
 # 镜像加速器
 
-国内从 Docker Hub 拉取镜像有时会遇到困难，此时可以配置镜像加速器。国内很多云服务商都提供了国内加速器服务，例如：
+国内从 Docker Hub 拉取镜像有时会遇到困难，此时可以配置镜像加速器。~~国内很多云服务商都提供了国内加速器服务，例如：~~
 
 * [阿里云加速器(点击管理控制台 -> 登录账号(淘宝账号) -> 左侧镜像工具 -> 镜像加速器 -> 复制加速器地址)](https://cr.console.aliyun.com/cn-hangzhou/instances)
-* [网易云加速器 `https://hub-mirror.c.163.com`](https://www.163yun.com/help/documents/56918246390157312)
-* [百度云加速器 `https://mirror.baidubce.com`](https://cloud.baidu.com/doc/CCE/s/Yjxppt74z#%E4%BD%BF%E7%94%A8dockerhub%E5%8A%A0%E9%80%9F%E5%99%A8)
 
 **由于镜像服务可能出现宕机，建议同时配置多个镜像。各个镜像站测试结果请到 [docker-practice/docker-registry-cn-mirror-test](https://github.com/docker-practice/docker-registry-cn-mirror-test/actions) 查看。**
 
 > 国内各大云服务商（腾讯云、阿里云、百度云）均提供了 Docker 镜像加速服务，建议根据运行 Docker 的云平台选择对应的镜像加速服务，具体请参考本页最后一小节。
 
-本节我们以 [网易云](https://www.163yun.com/) 镜像服务 `https://hub-mirror.c.163.com` 为例进行介绍。
+本节我们以 [AtomHub 可信镜像中心](https://hub.atomgit.com/) 镜像服务 `https://hub.atomgit.com` 为例进行介绍。
+
+> `hub.atomgit.com` 仅包含部分官方镜像，可以满足初学者的使用。
 
 ## Ubuntu 16.04+、Debian 8+、CentOS 7+
 
@@ -29,8 +29,7 @@ $ systemctl cat docker | grep '\-\-registry\-mirror'
 ```json
 {
   "registry-mirrors": [
-    "https://hub-mirror.c.163.com",
-    "https://mirror.baidubce.com"
+    "https://hub.atomgit.com"
   ]
 }
 ```
@@ -46,13 +45,12 @@ $ sudo systemctl restart docker
 
 ## Windows 10
 
-对于使用 `Windows 10` 的用户，在任务栏托盘 Docker 图标内右键菜单选择 `Settings`，打开配置窗口后在左侧导航菜单选择 `Docker Engine`，在右侧像下边一样编辑 json 文件，之后点击 `Apply & Restart` 保存后 Docker 就会重启并应用配置的镜像地址了。
+对于使用 `Windows 10` 的用户，在任务栏托盘 Docker 图标内右键菜单选择 `Change settings`，打开配置窗口后在左侧导航菜单选择 `Docker Engine`，在右侧像下边一样编辑 json 文件，之后点击 `Apply & Restart` 保存后 Docker 就会重启并应用配置的镜像地址了。
 
 ```json
 {
   "registry-mirrors": [
-    "https://hub-mirror.c.163.com",
-    "https://mirror.baidubce.com"
+    "https://hub.atomgit.com"
   ]
 }
 ```
@@ -64,8 +62,7 @@ $ sudo systemctl restart docker
 ```json
 {
   "registry-mirrors": [
-    "https://hub-mirror.c.163.com",
-    "https://mirror.baidubce.com"
+    "https://hub.atomgit.com"
   ]
 }
 ```
@@ -76,7 +73,7 @@ $ sudo systemctl restart docker
 
 ```bash
 Registry Mirrors:
- https://hub-mirror.c.163.com/
+ https://hub.atomgit.com/
 ```
 
 ## `k8s.gcr.io` 镜像
@@ -100,6 +97,8 @@ $ docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/xxx
 * https://dockerhub.azk8s.cn **已转为私有**
 * https://reg-mirror.qiniu.com
 * https://registry.docker-cn.com
+* https://hub-mirror.c.163.com
+* https://mirror.baidubce.com
 
 建议 **watch（页面右上角）** [镜像测试](https://github.com/docker-practice/docker-registry-cn-mirror-test) 这个 GitHub 仓库，我们会在此更新各个镜像地址的状态。
 

install/offline.md

@@ -1,14 +1,12 @@
-# 离线部署Docker
+# Linux 离线安装
 
-[TOC]
+\[TOC]
 
 生产环境中一般都是没有公网资源的，本文介绍如何在生产服务器上离线部署`Docker`
 
-
-
 括号内的字母表示该操作需要在哪些服务器上执行
 
-<img src="_images/image-20200412202617411.png" alt="Docker-offile-install-top" style="zoom:30%;" />
+![Docker-offile-install-top](../.gitbook/assets/image-20200412202617411.png)
 
 ## Centos7 离线安装Docker
 
@@ -16,7 +14,7 @@
 
 推荐这种方式，是因为在生产环境种一般会选定某个指定的文档软件版本使用。
 
-####  查询可用的软件版本(A)
+#### 查询可用的软件版本(A)
 
 ```bash
 #下载清华的镜像源文件
@@ -77,28 +75,32 @@ Background downloading packages, then exiting:
 Total                                                                                                                                               118 MB/s |  87 MB  00:00:00
 exiting because "Download Only" specified
 ```
+
 #### 复制到目标服务器之后进入文件夹安装(C-N)
 
 * 离线安装时，必须使用rpm命令不检查依赖的方式安装
+
 ```bash
 rpm -Uvh *.rpm --nodeps --force
 ```
 
 #### 锁定软件版本(C-N)
 
-##### 下载锁定版本软件
+**下载锁定版本软件**
+
 可参考下文的网络源搭建
+
 ```bash
 sudo yum install yum-plugin-versionlock
 ```
 
-##### 锁定软件版本
+**锁定软件版本**
 
 ```bash
 sudo yum versionlock add docker
 ```
 
-##### 查看锁定列表
+**查看锁定列表**
 
 ```bash
 sudo yum versionlock list
@@ -110,7 +112,7 @@ Loaded plugins: fastestmirror, versionlock
 versionlock list done
 ```
 
-##### 锁定后无法再更新
+**锁定后无法再更新**
 
 ```bash
 sudo yum install docker-ce
@@ -121,7 +123,7 @@ Package 3:docker-ce-24.0.4-1.el7.x86_64 already installed and latest version
 Nothing to do
 ```
 
-##### 解锁指定软件
+**解锁指定软件**
 
 ```bash
 sudo yum versionlock delete docker-ce
@@ -133,14 +135,12 @@ Deleting versionlock for: 3:docker-ce-24.0.4-1.el7.*
 versionlock deleted: 1
 ```
 
-##### 解锁所有软件
+**解锁所有软件**
 
 ```bash
 sudo yum versionlock delete all
 ```
 
-
-
 ### YUM 本地源服务器搭建安装Docker
 
 #### 挂载 ISO 镜像搭建本地 File 源（AB）
@@ -170,8 +170,6 @@ yum clean all
 yum install createrepo -y
 ```
 
-
-
 #### 根据本地文件搭建BASE网络源（B）
 
 ```bash
@@ -245,5 +243,3 @@ sudo yum makecache fast
 sudo yum install docker-ce docker-ce-cli containerd.io
 sudo systemctl enable docker
 ```
-
-

install/ubuntu.md

@@ -6,23 +6,30 @@
 
 ### 系统要求
 
-Docker 支持以下版本的 [Ubuntu](https://ubuntu.com/server) 操作系统：
+Docker 支持诸多版本的 [Ubuntu](https://ubuntu.com/server) 操作系统。但是较旧的版本上将不会有Docker新版本的持续更新，以截至2024年中的几个 Ubuntu LTS（Long Term Support，长期支持）版本为例：
 
-* Ubuntu Hirsute 21.04
-* Ubuntu Groovy 20.10
-* Ubuntu Focal 20.04 (LTS)
-* Ubuntu Bionic 18.04 (LTS)
+* Ubuntu Noble 24.04 (LTS)，Docker v27.2.1
+* Ubuntu Jammy 22.04 (LTS), Docker v27.2.1
+* Ubuntu Focal 20.04 (LTS), Docker v27.2.1
+* Ubuntu Bionic 18.04 (LTS)，Docker v24.0.2
 
-Docker 可以安装在 64 位的 x86 平台或 ARM 平台上。Ubuntu 发行版中，LTS（Long-Term-Support）长期支持版本，会获得 5 年的升级维护支持，这样的版本会更稳定，因此在生产环境中推荐使用 LTS 版本。
+在 Ubuntu LTS 版本上，目前 Docker 支持 amd64、arm64、armhf、ppc64el、s390x 等 5 个平台；而非 LTS 版本支持的平台通常较少。同时，LTS 版本会获得 5 年的升级维护支持，这样的系统会获得更长期的安全保障，因此在生产环境中推荐使用 LTS 版本。
 
 ### 卸载旧版本
 
 旧版本的 Docker 称为 `docker` 或者 `docker-engine`，使用以下命令卸载旧版本：
 
 ```bash
-$ sudo apt-get remove docker \
-               docker-engine \
-               docker.io
+$ for pkg in docker \
+           docker-engine \
+           docker.io \
+           docker-doc \
+           podman-docker \
+           containerd \
+           runc;
+do
+    sudo apt remove $pkg;
+done
 ```
 
 ## 使用 APT 安装
@@ -30,9 +37,9 @@ $ sudo apt-get remove docker \
 由于 `apt` 源使用 HTTPS 以确保软件下载过程中不被篡改。因此，我们首先需要添加使用 HTTPS 传输的软件包以及 CA 证书。
 
 ```bash
-$ sudo apt-get update
+$ sudo apt update
 
-$ sudo apt-get install \
+$ sudo apt install \
     apt-transport-https \
     ca-certificates \
     curl \
@@ -73,9 +80,9 @@ $ echo \
 更新 apt 软件包缓存，并安装 `docker-ce`：
 
 ```bash
-$ sudo apt-get update
+$ sudo apt update
 
-$ sudo apt-get install docker-ce docker-ce-cli containerd.io
+$ sudo apt install docker-ce docker-ce-cli containerd.io
 ```
 
 ## 使用脚本自动安装

install/windows.md

@@ -1,4 +1,4 @@
-# Windows 10 安装 Docker
+# Windows 10/11
 
 ## 系统要求
 
@@ -12,13 +12,13 @@
 
 下载好之后双击 `Docker Desktop Installer.exe` 开始安装。
 
-**使用 [winget](https://docs.microsoft.com/zh-cn/windows/package-manager/) 安装**
+**使用** [**winget**](https://docs.microsoft.com/zh-cn/windows/package-manager/) **安装**
 
 ```powershell
 $ winget install Docker.DockerDesktop
 ```
 
-## 在 WSL2 运行 Docker 
+## 在 WSL2 运行 Docker
 
 若你的 Windows 版本为 Windows 10 专业版或家庭版 v1903 及以上版本可以使用 WSL2 运行 Docker，具体请查看 [Docker Desktop WSL 2 backend](https://docs.docker.com/docker-for-windows/wsl/)。
 
@@ -26,11 +26,11 @@ $ winget install Docker.DockerDesktop
 
 在 Windows 搜索栏输入 **Docker** 点击 **Docker Desktop** 开始运行。
 
-![](./_images/install-win-docker-app-search.png)
+![](../.gitbook/assets/install-win-docker-app-search.png)
 
 Docker 启动之后会在 Windows 任务栏出现鲸鱼图标。
 
-![](./_images/install-win-taskbar-circle.png)
+![](../.gitbook/assets/install-win-taskbar-circle.png)
 
 等待片刻，当鲸鱼图标静止时，说明 Docker 启动成功，之后你可以打开 PowerShell 使用 Docker。
 

introduction/README.md

@@ -2,8 +2,22 @@
 
 本章将带领你进入 **Docker** 的世界。
 
-什么是 **Docker**？
+## 本章内容
 
-用它会带来什么样的好处？
+* [什么是 Docker](what.md)
+  * 介绍 Docker 的起源、发展历程以及其背后的核心技术（Cgroups, Namespaces, UnionFS）。
+  * 了解 Docker 是如何改变软件交付方式的。
+
+* [为什么要用 Docker](why.md)
+  * 对比传统虚拟机技术，阐述 Docker 在启动速度、资源利用率、交付效率等方面的巨大优势。
+  * 探讨 Docker 在 DevOps、微服务架构中的关键作用。
+
+## 学习目标
+
+通过本章的学习，你将能够：
+
+1. 理解 Docker 的核心概念与架构。
+2. 明白 Docker 解决了现代软件开发与运维中的哪些痛点。
+3. 建立起对容器技术的初步认知，为后续的实战操作打下基础。
 
 好吧，让我们带着问题开始这神奇之旅。

introduction/what.md

@@ -1,6 +1,6 @@
 # 什么是 Docker
 
-**Docker** 最初是 `dotCloud` 公司创始人 [Solomon Hykes](https://github.com/shykes) 在法国期间发起的一个公司内部项目，它是基于 `dotCloud` 公司多年云服务技术的一次革新，并于 [2013 年 3 月以 Apache 2.0 授权协议开源][docker-soft]，主要项目代码在 [GitHub](https://github.com/moby/moby) 上进行维护。`Docker` 项目后来还加入了 Linux 基金会，并成立推动 [开放容器联盟（OCI）](https://opencontainers.org/)。
+**Docker** 最初是 `dotCloud` 公司创始人 [Solomon Hykes](https://github.com/shykes) 在法国期间发起的一个公司内部项目，它是基于 `dotCloud` 公司多年云服务技术的一次革新，并于 [2013 年 3 月以 Apache 2.0 授权协议开源](https://en.wikipedia.org/wiki/Docker_\(software\))，主要项目代码在 [GitHub](https://github.com/moby/moby) 上进行维护。`Docker` 项目后来还加入了 Linux 基金会，并成立推动 [开放容器联盟（OCI）](https://opencontainers.org/)。
 
 **Docker** 自开源后受到广泛的关注和讨论，至今其 [GitHub 项目](https://github.com/moby/moby) 已经超过 5 万 7 千个星标和一万多个 `fork`。甚至由于 `Docker` 项目的火爆，在 `2013` 年底，[dotCloud 公司决定改名为 Docker](https://www.docker.com/blog/dotcloud-is-becoming-docker-inc/)。`Docker` 最初是在 `Ubuntu 12.04` 上开发实现的；`Red Hat` 则从 `RHEL 6.5` 开始对 `Docker` 进行支持；`Google` 也在其 `PaaS` 产品中广泛应用 `Docker`。
 
@@ -16,8 +16,6 @@
 
 下面的图片比较了 **Docker** 和传统虚拟化方式的不同之处。传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程；而容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。
 
-![传统虚拟化](./_images/virtualization.png)
+![传统虚拟化](../.gitbook/assets/virtualization.png)
 
-![Docker](./_images/docker.png)
-
-[docker-soft]:https://en.wikipedia.org/wiki/Docker_(software)
+![Docker](../.gitbook/assets/docker.png)

kubernetes/concepts.md

@@ -1,6 +1,6 @@
 # 基本概念
 
-![](./_images/kubernetes_design.jpg)
+![](../.gitbook/assets/kubernetes_design.jpg)
 
 * 节点（`Node`）：一个节点是一个运行 Kubernetes 中的主机。
 * 容器组（`Pod`）：一个 Pod 对应于由若干容器组成的一个容器组，同个组内的容器共享一个存储卷(volume)。
@@ -59,15 +59,15 @@ Kubernetes 校验节点可用依赖于 ID。在当前的版本中，有两个接
 ### 节点控制
 
 在 Kubernetes 主节点中，节点控制器是用来管理节点的组件。主要包含：
+
 * 集群范围内节点同步
 * 单节点生命周期管理
 
-节点控制有一个同步轮询，主要监听所有云平台的虚拟实例，会根据节点状态创建和删除。可以通过 `--node_sync_period`标志来控制该轮询。如果一个实例已经创建，节点控制将会为其创建一个结构。同样的，如果一个节点被删除，节点控制也会删除该结构。在 Kubernetes 启动时可用通过 `--machines`标记来显示指定节点。同样可以使用 `kubectl` 来一条一条的添加节点，两者是相同的。通过设置 `--sync_nodes=false`标记来禁止集群之间的节点同步，你也可以使用  api/kubectl 命令行来增删节点。
+节点控制有一个同步轮询，主要监听所有云平台的虚拟实例，会根据节点状态创建和删除。可以通过 `--node_sync_period`标志来控制该轮询。如果一个实例已经创建，节点控制将会为其创建一个结构。同样的，如果一个节点被删除，节点控制也会删除该结构。在 Kubernetes 启动时可用通过 `--machines`标记来显示指定节点。同样可以使用 `kubectl` 来一条一条的添加节点，两者是相同的。通过设置 `--sync_nodes=false`标记来禁止集群之间的节点同步，你也可以使用 api/kubectl 命令行来增删节点。
 
 ## 容器组
 
-在 Kubernetes 中，使用的最小单位是容器组，容器组是创建，调度，管理的最小单位。
-一个容器组使用相同的 Docker 容器并共享卷（挂载点）。一个容器组是一个特定应用的打包集合，包含一个或多个容器。
+在 Kubernetes 中，使用的最小单位是容器组，容器组是创建，调度，管理的最小单位。 一个容器组使用相同的 Docker 容器并共享卷（挂载点）。一个容器组是一个特定应用的打包集合，包含一个或多个容器。
 
 和运行的容器类似，一个容器组被认为只有很短的运行周期。容器组被调度到一组节点运行，直到容器的生命周期结束或者其被删除。如果节点死掉，运行在其上的容器组将会被删除而不是重新调度。（也许在将来的版本中会添加容器组的移动）。
 
@@ -133,50 +133,56 @@ Kubernetes 校验节点可用依赖于 ID。在当前的版本中，有两个接
 举例如下。
 
 * 容器组状态 `running`，有 1 容器，容器正常退出
-     * 记录完成事件
-     * 如果重启策略为：
-        * 始终：重启容器，容器组保持 `running`
-        * 失败时：容器组变为 `succeeded`
-        * 从不：容器组变为 `succeeded`
+  * 记录完成事件
+  * 如果重启策略为：
+    * 始终：重启容器，容器组保持 `running`
+    * 失败时：容器组变为 `succeeded`
+    * 从不：容器组变为 `succeeded`
 * 容器组状态 `running`，有1容器，容器异常退出
-     * 记录失败事件
-     * 如果重启策略为：
-        * 始终：重启容器，容器组保持 `running`
-        * 失败时：重启容器，容器组保持 `running`
-        * 从不：容器组变为 `failed`
+  * 记录失败事件
+  * 如果重启策略为：
+    * 始终：重启容器，容器组保持 `running`
+    * 失败时：重启容器，容器组保持 `running`
+    * 从不：容器组变为 `failed`
 * 容器组状态 `running`，有2容器，有1容器异常退出
-     * 记录失败事件
-     * 如果重启策略为：
-        * 始终：重启容器，容器组保持 `running`
-        * 失败时：重启容器，容器组保持 `running`
-        * 从不：容器组保持 `running`
-    * 当有2容器退出
-        * 记录失败事件
-        * 如果重启策略为：
-            * 始终：重启容器，容器组保持 `running`
-            * 失败时：重启容器，容器组保持 `running`
-            * 从不：容器组变为 `failed`
-* 容器组状态 `running`，容器内存不足
-    * 标记容器错误中断
-    * 记录内存不足事件
+  * 记录失败事件
+  * 如果重启策略为：
+    * 始终：重启容器，容器组保持 `running`
+    * 失败时：重启容器，容器组保持 `running`
+    * 从不：容器组保持 `running`
+  * 当有2容器退出
+    * 记录失败事件
     * 如果重启策略为：
-        * 始终：重启容器，容器组保持 `running`
-        * 失败时：重启容器，容器组保持 `running`
-        * 从不：记录错误事件，容器组变为 `failed`
+      * 始终：重启容器，容器组保持 `running`
+      * 失败时：重启容器，容器组保持 `running`
+      * 从不：容器组变为 `failed`
+* 容器组状态 `running`，容器内存不足
+  * 标记容器错误中断
+  * 记录内存不足事件
+  * 如果重启策略为：
+    * 始终：重启容器，容器组保持 `running`
+    * 失败时：重启容器，容器组保持 `running`
+    * 从不：记录错误事件，容器组变为 `failed`
 * 容器组状态 `running`，一块磁盘死掉
-    * 杀死所有容器
-    * 记录事件
-    * 容器组变为 `failed`
-    * 如果容器组运行在一个控制器下，容器组将会在其他地方重新创建
+  * 杀死所有容器
+  * 记录事件
+  * 容器组变为 `failed`
+  * 如果容器组运行在一个控制器下，容器组将会在其他地方重新创建
 * 容器组状态 `running`，对应的节点段溢出
-    * 节点控制器等到超时
-    * 节点控制器标记容器组 `failed`
-    * 如果容器组运行在一个控制器下，容器组将会在其他地方重新创建
+  * 节点控制器等到超时
+  * 节点控制器标记容器组 `failed`
+  * 如果容器组运行在一个控制器下，容器组将会在其他地方重新创建
 
 ## Replication Controllers
+
 ## 服务
+
 ## 卷
+
 ## 标签
+
 ## 接口权限
+
 ## web界面
+
 ## 命令行操作

kubernetes/design.md

@@ -1,9 +1,11 @@
-# 基本架构
+# 架构设计
 
 任何优秀的项目都离不开优秀的架构设计。本小节将介绍 Kubernetes 在架构方面的设计考虑。
 
 ## 基本考虑
+
 如果让我们自己从头设计一套容器管理平台，有如下几个方面是很容易想到的：
+
 * 分布式架构，保证扩展性；
 * 逻辑集中式的控制平面 + 物理分布式的运行平面；
 * 一套资源调度系统，管理哪个容器该分配到哪个节点上；
@@ -13,7 +15,7 @@
 
 下面这张图完整展示了 Kubernetes 的运行原理。
 
-![Kubernetes 架构](./_images/k8s_architecture.png)
+![Kubernetes 架构](../.gitbook/assets/k8s_architecture.png)
 
 可见，Kubernetes 首先是一套分布式系统，由多个节点组成，节点分为两类：一类是属于管理平面的主节点/控制节点（Master Node）；一类是属于运行平面的工作节点（Worker Node）。
 
@@ -22,6 +24,7 @@
 从这张图上，我们没有能发现 Kubernetes 中对于控制平面的分布式实现，但是由于数据后端自身就是一套分布式的数据库 Etcd，因此可以很容易扩展到分布式实现。
 
 ## 控制平面
+
 ### 主节点服务
 
 主节点上需要提供如下的管理服务：
@@ -31,6 +34,7 @@
 * `controller-manager` 负责管理控制器，包括 endpoint-controller（刷新服务和 pod 的关联信息）和 replication-controller（维护某个 pod 的复制为配置的数值）。
 
 ### Etcd
+
 这里 Etcd 即作为数据后端，又作为消息中间件。
 
 通过 Etcd 来存储所有的主节点上的状态信息，很容易实现主节点的分布式扩展。
@@ -38,7 +42,8 @@
 组件可以自动的去侦测 Etcd 中的数值变化来获得通知，并且获得更新后的数据来执行相应的操作。
 
 ## 工作节点
+
 * kubelet 是工作节点执行操作的 agent，负责具体的容器生命周期管理，根据从数据库中获取的信息来管理容器，并上报 pod 运行状态等；
 * kube-proxy 是一个简单的网络访问代理，同时也是一个 Load Balancer。它负责将访问到某个服务的请求具体分配给工作节点上的 Pod（同一类标签）。
 
-![Proxy 代理对服务的请求](./_images/kube-proxy.png)
+![Proxy 代理对服务的请求](../.gitbook/assets/kube-proxy.png)

kubernetes/intro.md

@@ -1,6 +1,6 @@
-# 项目简介
+# 简介
 
-![](./_images/kubernetes_logo.png)
+![](../.gitbook/assets/kubernetes_logo.png)
 
 Kubernetes 是 Google 团队发起的开源项目，它的目标是管理跨多个主机的容器，提供基本的部署，维护以及应用伸缩，主要实现语言为 Go 语言。Kubernetes 是：