## 21 个基本 Docker 命令 \[通过示例进行解释\]

* * *

**21 个可执行且信息丰富的 Docker 命令的汇编，供您快速参考。**

Docker 有一组广泛的命令（更准确地说是子命令）。你不可能使用所有这些，也没有必要去追求那个成就。

大多数时候，您将使用特定的命令子集来管理容器和映像。

我将列出这些常见但必不可少的 Docker 命令，这些命令对于 Docker 用户和管理员的日常使用非常有用。

我将这些 Docker 命令分为两类：

1.  可执行文件：用于运行和管理容器的命令
    
2.  信息性：用于提取有关容器、图像和图层信息的命令。
    

听起来不错？让我们看看这些必须知道的 Docker 命令以及实际示例。

## Docker执行命令\[用于运行和管理容器\]

这些 Docker 命令用于管理容器和构建镜像。它们执行特定的任务，因此我将它们称为“Docker 执行命令”。

此时，我建议您使用此映像刷新 Docker 容器生命周期的基础知识：

[![](https://cn.linux-console.net/common-images/essential-docker-commands/docker-container-lifecycle-diagram-2.png)](https://cn.linux-console.net/common-images/essential-docker-commands/docker-container-lifecycle-diagram-2.png)

除此之外，让我们看看命令及其示例。

如果您的系统上安装了 Docker，您可以运行示例和教程来练习。

### 1.Docker运行

Docker run 用于创建容器并立即启动它。

该命令首先查找要运行的容器的现有映像，如果找不到，则从存储库中提取它，从该映像创建一个容器，然后立即开始运行它。

让我们从官方存储库运行 Nginx 容器。

```
avimanyu@localhost:~$ docker run --name nginx-root -p 80:80 -d nginx

8411c3df0fd7f57395b0732b1b1963c215040eed669dc8327200db197ff6099b
avimanyu@localhost:~$
```

使用 `--name` 标志，您可以自定义其本地名称，并将主机端口映射到容器端口。 `-d` 或 `--detach` 有助于以分离模式在后台运行容器。

“docker run”是“docker 容器运行”的缩写版本。 Docker 官方建议使用较长的形式，但较旧且较短的形式仍然很流行，因为输入命令所需的时间较短。

### 2.Docker停止

该命令用于停止已经运行的容器。语法很简单：

```
docker stop container-name-or-id
```

让我们停止在第一个命令中启动的容器。

```
avimanyu@localhost:~$ docker stop nginx-root
nginx-root
avimanyu@localhost:~$
```

如果您在运行时没有自定义名称，可以使用 docker ps 命令检查随机生成的名称（稍后讨论）。

当您使用 docker stop 命令时，它会发送 SIGTERM 信号请求终止，然后根据终止情况管理 SIGKILL 信号。

### 3.Docker启动

这用于启动已停止的容器。语法很简单：

```
docker start container-name-or-id
```

让我们启动您在上一个示例中刚刚停止的 Nginx 容器。

```
avimanyu@localhost:~$ docker start nginx-root
nginx-root
avimanyu@localhost:~$
```

请注意，与 docker run 不同，docker start 无法从镜像创建新容器。它只能“运行”处于停止状态的容器。

### 4\. Docker 执行

docker exec，顾名思义，用于在已经运行的容器中执行新命令。

```
avimanyu@localhost:~$ docker exec -ti nginx-root /bin/bash
root@72acb924f667:/#
```

现在您正在容器内运行 bash shell。

在 `-ti` 中，**t** 表示“终端”，**i** 表示“交互式”，以保持 STDIN（标准输入）打开（即使未连接）。

要退出容器 shell，只需使用 exit 命令返回到主机控制台。

```
root@72acb924f667:/# exit
exit
avimanyu@localhost:~$
```

### 5.Docker重命名

要重命名容器，请使用以下语法：

```
docker rename old_container_name new_container_name
```

让我们将 nginx-root 容器重命名为 nginx-toor。 **请注意，即使容器已启动并运行，您也可以执行此操作！**

```
avimanyu@localhost:~$ docker rename nginx-root nginx-toor
```

### 6.Docker暂停/取消暂停

使用`docker暂停`，您可以暂停指定容器中的所有进程。使用 SIGSTOP 信号，暂停状态下的进程会注意到该信号。

```
avimanyu@localhost:~$ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
72acb924f667 nginx "nginx -g 'daemon of…" 4 hours ago Up 4 hours 0.0.0.0:80->80/tcp nginx-toor
e2dd68fdd220 wordpress:5.3.0-php7.1-apache "docker-entrypoint.s…" 3 days ago Up 3 days 0.0.0.0:8088->80/tcp wp2_wordpress_1
016709c05add wordpress:5.3.0-php7.1-apache "docker-entrypoint.s…" 3 days ago Up 3 days 0.0.0.0:8080->80/tcp wp1_wordpress_1
656f6761ce0d mariadb:10.4.10-bionic "docker-entrypoint.s…" 8 days ago Up 3 days 3306/tcp wp2_mysql_1
ee953bb14483 mariadb:10.4.10-bionic "docker-entrypoint.s…" 8 days ago Up 3 days 3306/tcp wp1_mysql_1
```

让我们暂停 nginx-toor 容器：

```
avimanyu@localhost:~$ docker pause nginx-toor
nginx-toor
```

现在您可以再次使用 docker ps 命令检查它是否真的暂停了：

```
avimanyu@localhost:~$ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
72acb924f667 nginx "nginx -g 'daemon of…" 4 hours ago Up 4 hours (Paused) 0.0.0.0:80->80/tcp nginx-toor
e2dd68fdd220 wordpress:5.3.0-php7.1-apache "docker-entrypoint.s…" 3 days ago Up 3 days 0.0.0.0:8088->80/tcp wp2_wordpress_1
016709c05add wordpress:5.3.0-php7.1-apache "docker-entrypoint.s…" 3 days ago Up 3 days 0.0.0.0:8080->80/tcp wp1_wordpress_1
656f6761ce0d mariadb:10.4.10-bionic "docker-entrypoint.s…" 8 days ago Up 3 days 3306/tcp wp2_mysql_1
ee953bb14483 mariadb:10.4.10-bionic "docker-entrypoint.s…" 8 days ago Up 3 days 3306/tcp wp1_mysql_1
```

要恢复，只需使用取消暂停：

```
avimanyu@localhost:~$ docker unpause nginx-toor
nginx-toor
```

### 7\. Docker 杀死

`docker Kill` 用于向容器发送默认的 KILL 信号。与 docker stop 不同的是，它直接发送 SIGKILL 信号，而不用 SIGTERM 信号请求终止。

这是一种基于典型紧急情况强制终止的突然方法，因此始终建议首先使用 docker stop 。

```
avimanyu@localhost:~$ docker kill nginx-root
nginx-root
avimanyu@localhost:~$
```

### 8\. Docker 构建

如果您要修改 Docker 映像，则需要先构建自定义映像，然后才能使用它来部署新容器。

docker build 是构建此类修改后的映像的命令。

我建议阅读有关使用 Dockerfile 创建自定义 Docker 映像的详细指南。在这里，我仅举一个简单的例子。

这是一个示例 Dockerfile：

```
FROM alpine:latest
RUN apk update
RUN apk add vim
```

首先，它从官方存储库下载 Alpine Linux 映像。然后它会更新包缓存，然后另外将 Vim 编辑器安装到其中。

这意味着从此映像运行的容器将预安装 Vim 编辑器。

按以下方式构建图像：

```
avimanyu@localhost:~/docker-build-test$ docker image build -t docker-build-test-image .

Sending build context to Docker daemon 2.048kB
Step 1/3 : FROM alpine:latest
---> 965ea09ff2eb
Step 2/3 : RUN apk update
---> Using cache
---> b16ea26b03aa
Step 3/3 : RUN apk add vim
---> Using cache
---> b283eaf606c1
Successfully built b283eaf606c1
Successfully tagged docker-build-test-image:latest
```

修改后的镜像名为***docker-build-test-image***，该命令在当前目录中查找 Dockerfile。

### 9\. Docker cp

cp 命令对于有经验的 Linux 用户来说已经很熟悉了，它可以在不同位置之间复制文件和目录。

类似地，docker cp 或简称 docker cp 用于在容器和主机之间复制文件和目录。

```
avimanyu@localhost:~/nginx-root$ docker cp nginx-root:/etc/nginx/nginx.conf ./config
```

上面的命令会将 nginx.conf 文件从容器 nginx-root 复制到名为 config 的目录，该目录必须已位于当前工作目录（也名为 nginx-root）中。请注意，容器的文件系统结构（/etc/nginx）与常规 Linux 系统类似。

### 10\. Docker rm

与通过 Linux 终端删除文件和目录类似，Docker 也使用类似的语法来删除映像和容器。

```
docker rm container_or_image_name_or_id
```

尝试删除您之前在本教程中创建的 nginx-root 容器：

```
avimanyu@localhost:~$ docker rm nginx-root
nginx-root
```

输出不会说容器已删除或类似的内容，但它仍然被删除。

您无法删除正在运行的容器。您无法删除与容器关联的映像，即使是已停止的映像。

让我们总结一下上面的所有命令：

[![](https://cn.linux-console.net/common-images/essential-docker-commands/docker-cheatsheet-executables.png)](https://cn.linux-console.net/common-images/essential-docker-commands/docker-cheatsheet-executables.png)

我将再次创建 nginx-root 容器以在其他一些命令示例中使用它。

## Docker 信息命令 \[用于获取有关容器和映像的信息\]

为您提供与特定任务和现有可读参数相关的信息的 Docker 命令可以称为信息性 docker 命令。

为此，我列出了 11 个 Docker 命令：

### 11\. Docker ps/container ls

docker ps 是 docker container ls 的缩写，可用于列出系统上当前运行的所有容器，并通过其他统计信息检查其状态。

```
avimanyu@localhost:~$ docker ps

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
e2dd68fdd220 wordpress:5.3.0-php7.1-apache "docker-entrypoint.s…" 3 days ago Up 3 days 0.0.0.0:8088->80/tcp wp2_wordpress_1

016709c05add wordpress:5.3.0-php7.1-apache "docker-entrypoint.s…" 3 days ago Up 3 days 0.0.0.0:8080->80/tcp wp1_wordpress_1

80e12e4a431c nginx "nginx -g 'daemon of…" 3 days ago Up 3 days 0.0.0.0:80->80/tcp nginx-root

656f6761ce0d mariadb:10.4.10-bionic "docker-entrypoint.s…" 7 days ago Up 3 days 3306/tcp wp2_mysql_1

ee953bb14483 mariadb:10.4.10-bionic "docker-entrypoint.s…" 7 days ago Up 3 days 3306/tcp wp1_mysql_1

avimanyu@localhost:~$
```

### 12\. Docker 镜像/镜像 ls

如果您是经验丰富的 Linux 用户，您可能已经熟悉用于使用 Linux 终端检查目录内容的 ls 命令。

类似地，在 Docker 中，`docker image ls` 或简称 `docker images` 用于检查系统中存在的所有 Docker 镜像的列表。这些图像可能是官方的或自定义的，具体取决于它们的构建方式。

```
avimanyu@localhost:~$ docker images

REPOSITORY TAG IMAGE ID CREATED SIZE
nginx latest 4152a9608752 10 days ago 126MB
avimanyu786/flask-test latest f8e2d6f524ef 2 weeks ago 122MB
avimanyu786/nginx-test latest 5fe5e88b9eaa 2 weeks ago 23MB
wordpress 5.3.0-php7.1-apache f0985bcc2ffb 2 weeks ago 530MB
mariadb 10.4.10-bionic c1c9e6fba07a 2 weeks ago 355MB
avimanyu786/alpine-with-vim latest b283eaf606c1 2 weeks ago 34.7MB
jwilder/nginx-proxy latest d1c0beda6804 3 weeks ago 161MB
nginx alpine b6753551581f 5 weeks ago 21.4MB
python alpine 204216b3821e 5 weeks ago 111MB
alpine latest 965ea09ff2eb 5 weeks ago 5.55MB
mysql latest c8ee894bd2bd 6 weeks ago 456MB
hello-world latest fce289e99eb9 11 months ago 1.84kB
avimanyu@localhost:~$
```

除了容器和镜像之外，`ls` 还在 Docker 上用于类似的目的，以管理网络、卷、节点和集群服务。

### 13.Docker日志

此命令对于生产服务器调查和解决问题非常有帮助。您可以借助 docker log 命令获取任何容器的日志。

```
docker logs container_name_or_id
```

例如：

```
avimanyu@localhost:~$ docker logs nginx-toor
178.130.157.61 - - [30/Nov/2019:07:56:14 +0000] "GET / HTTP/1.1" 200 612 "-" "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.103 Safari/537.36" "-"
178.130.157.61 - - [30/Nov/2019:07:56:14 +0000] "GET / HTTP/1.1" 200 612 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36" "-"
.
.
.
.
x64|'|'|No|'|'|0.7d|'|'|..|'|'|AA==|'|'|112.inf|'|'|SGFjS2VkDQoxOTIuMTY4LjkyLjIyMjo1NTUyDQpEZXNrdG9wDQpjbGllbnRhLmV4ZQ0KRmFsc2UNCkZhbHNlDQpUcnVlDQpGYWxzZQ==12.act|'|'|AA==" 400 157 "-" "-" "-"
8.36.123.216 - - [30/Nov/2019:10:32:20 +0000] "GET / HTTP/1.1" 200 612 "-" "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)" "-"
202.142.105.74 - - [30/Nov/2019:12:03:39 +0000] "GET /favicon.ico HTTP/1.1" 404 153 "-" "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:70.0) Gecko/20100101 Firefox/70.0" "-"
```

### 14.Docker版本

要获取系统上安装的 Docker 版本的详细信息，只需使用：

```
docker version
```

这些信息如下所示：

```
avimanyu@localhost:~$ docker version
Client: Docker Engine - Community
Version: 19.03.4
API version: 1.40
Go version: go1.12.10
Git commit: 9013bf583a
Built: Fri Oct 18 15:54:09 2019
OS/Arch: linux/amd64
Experimental: false
Server: Docker Engine - Community
Engine:
Version: 19.03.4
API version: 1.40 (minimum version 1.12)
Go version: go1.12.10
Git commit: 9013bf583a
Built: Fri Oct 18 15:52:40 2019
OS/Arch: linux/amd64
Experimental: false
containerd:
Version: 1.2.10
GitCommit: b34a5c8af56e510852c35414db4c1f4fa6172339
runc:
Version: 1.0.0-rc8+dev
GitCommit: 3e425f80a8c931f88e6d94a8c831b9d5aa481657
docker-init:
Version: 0.18.0
GitCommit: fec3683
avimanyu@localhost:~$
```

### 15\. Docker 信息

以下命令将显示安装 Docker 的主机系统的系统范围信息：

```
avimanyu@localhost:~$ docker info
Client:
Debug Mode: false
Server:
Containers: 9
Running: 5
Paused: 0
Stopped: 4
Images: 17
Server Version: 19.03.4
Storage Driver: overlay2
Backing Filesystem: extfs
Supports d_type: true
Native Overlay Diff: true
Logging Driver: json-file
Cgroup Driver: cgroupfs
Plugins:
Volume: local
Network: bridge host ipvlan macvlan null overlay
Log: awslogs fluentd gcplogs gelf journald json-file local logentries splunk syslog
Swarm: inactive
Runtimes: runc
Default Runtime: runc
Init Binary: docker-init
containerd version: b34a5c8af56e510852c35414db4c1f4fa6172339
runc version: 3e425f80a8c931f88e6d94a8c831b9d5aa481657
init version: fec3683
Security Options:
apparmor
seccomp
Profile: default
Kernel Version: 4.15.0-50-generic
Operating System: Ubuntu 18.04.2 LTS
OSType: linux
Architecture: x86_64
CPUs: 1
Total Memory: 985.4MiB
Name: localhost
ID: MZTJ:L5UF:WMQ3:VOIO:NR3N:336Q:YX2T:MSOU:5Y2N:MA7V:F6BQ:6UDY
Docker Root Dir: /var/lib/docker
Debug Mode: false
Registry: https://index.docker.io/v1/
Labels:
Experimental: false
Insecure Registries:
127.0.0.0/8
Live Restore Enabled: false
WARNING: No swap limit support
avimanyu@localhost:~$
```

### 16\. Docker 检查

docker检查命令用于显示有关容器和映像的低级信息。

您可以获得图像的校验和、层、容器 IP 地址和其他网络信息以及许多其他信息。

明智的做法是使用 grep 命令来过滤输出并仅获取所需的信息。

在以下示例中，我检查名为 **avimanyu786/alpine-with-vim:latest** 的现有 Docker 映像。

```
avimanyu@localhost:~$ docker inspect avimanyu786/alpine-with-vim:latest
[
{
"Id": "sha256:b283eaf606c18a4d0cc461ffdf86d53ecb173db5271129090a7421a64b1c514e",
"RepoTags": [
"avimanyu786/alpine-with-vim:latest"
],
"RepoDigests": [],
"Parent": "sha256:b16ea26b03aaf5d9bd84157fbef61670d2f318c1af854ae04f0dbc290afd4b04",
"Comment": "",
"Created": "2019-11-12T11:51:24.458552779Z",
"Container": "5b759e6f98e354a78dfca588eb65316b35f0cfb88c9119844471c8fcba362898",
"ContainerConfig": {
"Hostname": "",
"Domainname": "",
"User": "",
"AttachStdin": false,
"AttachStdout": false,
"AttachStderr": false,
"Tty": false,
"OpenStdin": false,
"StdinOnce": false,
"Env": [
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
],
"Cmd": [
"/bin/sh",
"-c",
"apk add vim"
],
"Image": "sha256:b16ea26b03aaf5d9bd84157fbef61670d2f318c1af854ae04f0dbc290afd4b04",
.
.
.
.
"Metadata": {
"LastTagTime": "2019-11-12T11:51:24.563369343Z"
}
}
avimanyu@localhost:~$
```

### 17\. Docker 历史

使用 docker History image-name 找出 Docker 系统上存在的任何镜像的历史记录。

图像的历史记录将以相反的时间顺序告诉您所做的更改和提交。

```
avimanyu@localhost:~$ docker history avimanyu786/alpine-with-vim:latest
IMAGE CREATED CREATED BY SIZE COMMENT
b283eaf606c1 2 weeks ago /bin/sh -c apk add vim 27.7MB
b16ea26b03aa 2 weeks ago /bin/sh -c apk update 1.42MB
965ea09ff2eb 5 weeks ago /bin/sh -c #(nop) CMD ["/bin/sh"] 0B
<missing> 5 weeks ago /bin/sh -c #(nop) ADD file:fe1f09249227e2da2… 5.55MB
avimanyu@localhost:~$
```

### 18\. Docker 端口

该命令在管理多个容器时非常有用，因为它非常容易地显示主机到容器的端口映射：

```
avimanyu@localhost:~$ docker port nginx-root
80/tcp -> 0.0.0.0:80
```

在这里您可以看到主机端口 80 映射到名为 nginx-root 的容器的容器端口 80。

### 19\. Docker 差异

使用 docker diff，您可以检查容器文件系统上文件或目录的更改。它列出了容器文件系统自创建以来更改的文件和目录。

跟踪三种不同类型的更改 (A/D/C)：

+   A：添加文件或目录
    
+   D：删除文件或目录
    
+   C：文件或目录的更改
    

让我们检查一下 nginx-root 容器的情况：

```
avimanyu@localhost:~$ docker diff nginx-root
C /run
A /run/nginx.pid
C /var
C /var/cache
C /var/cache/nginx
A /var/cache/nginx/client_temp
A /var/cache/nginx/fastcgi_temp
A /var/cache/nginx/proxy_temp
A /var/cache/nginx/scgi_temp
A /var/cache/nginx/uwsgi_temp
avimanyu@localhost:~$
```

### 20\. Docker 顶部

再次强调，top 是您可能已经熟悉的 Linux 命令。它用于列出系统上正在运行的进程。

使用 docker top，您可以列出容器内运行的进程。

```
docker top container_ID_or_name
```

如果我在我们的示例中使用 nginx-root 执行此操作，它会显示以下值。

```
avimanyu@localhost:~$ docker top nginx-root
UID PID PPID C STIME TTY TIME CMD
root 10355 10330 0 07:54 ? 00:00:00 nginx: master process nginx -g daemon off;
systemd+ 10401 10355 0 07:54 ? 00:00:00 nginx: worker process
root 12054 10330 0 10:22 pts/0 00:00:00 /bin/bash
avimanyu@localhost:~$
```

### 21\. Docker 统计数据

docker stats 命令可以按原样使用，也可以用于特定容器。它向您显示容器详细信息以及系统资源使用情况。

首先我们看一下它的通用形式：

```
avimanyu@localhost:~$ docker stats
CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O PIDS
72acb924f667 nginx-root 0.00% 2.621MiB / 985.4MiB 0.27% 8.02kB / 8.92kB 6.8MB / 0B 3
e2dd68fdd220 wp2_wordpress_1 0.00% 44.24MiB / 985.4MiB 4.49% 1.9MB / 1.62MB 53.3MB / 61.4kB 11
016709c05add wp1_wordpress_1 0.00% 68.52MiB / 985.4MiB 6.95% 12MB / 4.77MB 136MB / 61.4kB 11
656f6761ce0d wp2_mysql_1 0.05% 70.12MiB / 985.4MiB 7.12% 1.05MB / 1MB 16MB / 2.15MB 30
ee953bb14483 wp1_mysql_1 0.04% 31.73MiB / 985.4MiB 3.22% 1.16MB / 4.76MB 50.6MB / 91.8MB 31
```

上述输出将持续实时生成，直到您使用 Ctrl+C 退出。

现在，如果您尝试针对特定容器，您将看到相同的输出，但仅针对该容器：

```
avimanyu@localhost:~$ docker stats nginx-root
CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O PIDS
72acb924f667 nginx-root 0.00% 2.621MiB / 985.4MiB 0.27% 8.02kB / 8.92kB 6.8MB / 0B 3
```

我也总结一下 Docker 命令的信息：

[![](https://cn.linux-console.net/common-images/essential-docker-commands/docker-cheatsheet-informatives-1.png)](https://cn.linux-console.net/common-images/essential-docker-commands/docker-cheatsheet-informatives-1.png)

要获得所有 Docker 命令的详尽且全面的资源，您可以始终参考 Docker 的官方文档。

您会注意到常用的 Linux 命令和一些 Docker 命令之间有相似之处。我认为这是故意让 Docker 命令更容易记住。

希望您发现本文对您的日常 Docker 使用很有用。如果您有更多此类有用的命令可以分享，请随时在下面分享。反馈和建议，随时欢迎。

docker常用命令1

## Swarm 集群管理

### 简介

Docker Swarm 是 Docker 的集群管理工具。它将 Docker 主机池转变为单个虚拟 Docker 主机。 Docker Swarm 提供了标准的 Docker API，所有任何已经与 Docker 守护程序通信的工具都可以使用 Swarm 轻松地扩展到多个主机。

支持的工具包括但不限于以下各项：

+   Dokku
+   Docker Compose
+   Docker Machine
+   Jenkins

### 原理

如下图所示，swarm 集群由管理节点（manager）和工作节点（work node）构成。

+   **swarm mananger**：负责整个集群的管理工作包括集群配置、服务管理等所有跟集群有关的工作。
+   **work node**：即图中的 available node，主要负责运行相应的服务来执行任务（task）。

[![](https://www.runoob.com/wp-content/uploads/2019/11/services-diagram.png)](https://www.runoob.com/wp-content/uploads/2019/11/services-diagram.png)

* * *

## 使用

以下示例，均以 Docker Machine 和 virtualbox 进行介绍，确保你的主机已安装 virtualbox。

### 1、创建 swarm 集群管理节点（manager）

创建 docker 机器：

```
$ docker-machine create -d virtualbox swarm-manager
```

[![](https://www.runoob.com/wp-content/uploads/2019/11/swarm1.png)](https://www.runoob.com/wp-content/uploads/2019/11/swarm1.png)

初始化 swarm 集群，进行初始化的这台机器，就是集群的管理节点。

```
$ docker-machine ssh swarm-manager
$ docker swarm init --advertise-addr 192.168.99.107 #这里的 IP 为创建机器时分配的 ip。
```

[![](https://www.runoob.com/wp-content/uploads/2019/11/swarm2.png)](https://www.runoob.com/wp-content/uploads/2019/11/swarm2.png)

以上输出，证明已经初始化成功。需要把以下这行复制出来，在增加工作节点时会用到：

```
docker swarm join --token SWMTKN-1-4oogo9qziq768dma0uh3j0z0m5twlm10iynvz7ixza96k6jh9p-ajkb6w7qd06y1e33yrgko64sk 192.168.99.107:2377
```

### 2、创建 swarm 集群工作节点（worker）

这里直接创建好俩台机器，swarm-worker1 和 swarm-worker2 。

[![](https://www.runoob.com/wp-content/uploads/2019/11/swarm3.png)](https://www.runoob.com/wp-content/uploads/2019/11/swarm3.png)

分别进入两个机器里，指定添加至上一步中创建的集群，这里会用到上一步复制的内容。

[![](https://www.runoob.com/wp-content/uploads/2019/11/swarm4.png)](https://www.runoob.com/wp-content/uploads/2019/11/swarm4.png)

以上数据输出说明已经添加成功。

上图中，由于上一步复制的内容比较长，会被自动截断，实际上在图运行的命令如下：

```
docker@swarm-worker1:~$ docker swarm join --token SWMTKN-1-4oogo9qziq768dma0uh3j0z0m5twlm10iynvz7ixza96k6jh9p-ajkb6w7qd06y1e33yrgko64sk 192.168.99.107:2377
```

### 3、查看集群信息

进入管理节点，执行：docker info 可以查看当前集群的信息。

```
$ docker info
```

[![](https://www.runoob.com/wp-content/uploads/2019/11/swarm5.png)](https://www.runoob.com/wp-content/uploads/2019/11/swarm5.png)

通过画红圈的地方，可以知道当前运行的集群中，有三个节点，其中有一个是管理节点。

### 4、部署服务到集群中

**注意**：跟集群管理有关的任何操作，都是在管理节点上操作的。

以下例子，在一个工作节点上创建一个名为 helloworld 的服务，这里是随机指派给一个工作节点：

```
docker@swarm-manager:~$ docker service create --replicas 1 --name helloworld alpine ping docker.com
```

[![](https://www.runoob.com/wp-content/uploads/2019/11/swarm6.png)](https://www.runoob.com/wp-content/uploads/2019/11/swarm6.png)

### 5、查看服务部署情况

查看 helloworld 服务运行在哪个节点上，可以看到目前是在 swarm-worker1 节点：

```
docker@swarm-manager:~$ docker service ps helloworld
```

[![](https://www.runoob.com/wp-content/uploads/2019/11/swarm7.png)](https://www.runoob.com/wp-content/uploads/2019/11/swarm7.png)

查看 helloworld 部署的具体信息：

```
docker@swarm-manager:~$ docker service inspect --pretty helloworld
```

[![](https://www.runoob.com/wp-content/uploads/2019/11/swarm8.png)](https://www.runoob.com/wp-content/uploads/2019/11/swarm8.png)

### 6、扩展集群服务

我们将上述的 helloworld 服务扩展到俩个节点。

```
docker@swarm-manager:~$ docker service scale helloworld=2
```

[![](https://www.runoob.com/wp-content/uploads/2019/11/swarm9.png)](https://www.runoob.com/wp-content/uploads/2019/11/swarm9.png)

可以看到已经从一个节点，扩展到两个节点。

[![](https://www.runoob.com/wp-content/uploads/2019/11/swarm10.png)](https://www.runoob.com/wp-content/uploads/2019/11/swarm10.png)

### 7、删除服务

```
docker@swarm-manager:~$ docker service rm helloworld
```

[![](https://www.runoob.com/wp-content/uploads/2019/11/swarm11.png)](https://www.runoob.com/wp-content/uploads/2019/11/swarm11.png)

查看是否已删除：

[![](https://www.runoob.com/wp-content/uploads/2019/11/swarm12.png)](https://www.runoob.com/wp-content/uploads/2019/11/swarm12.png)

### 8、滚动升级服务

以下实例，我们将介绍 redis 版本如何滚动升级至更高版本。

创建一个 3.0.6 版本的 redis。

```
docker@swarm-manager:~$ docker service create --replicas 1 --name redis --update-delay 10s redis:3.0.6
```

[![](https://www.runoob.com/wp-content/uploads/2019/11/swarm13.png)](https://www.runoob.com/wp-content/uploads/2019/11/swarm13.png)

滚动升级 redis 。

```
docker@swarm-manager:~$ docker service update --image redis:3.0.7 redis
```

[![](https://www.runoob.com/wp-content/uploads/2019/11/swarm14.png)](https://www.runoob.com/wp-content/uploads/2019/11/swarm14.png)

看图可以知道 redis 的版本已经从 3.0.6 升级到了 3.0.7，说明服务已经升级成功。

### 9、停止某个节点接收新的任务

查看所有的节点：

```
docker@swarm-manager:~$ docker node ls
```

[![](https://www.runoob.com/wp-content/uploads/2019/11/swarm16.png)](https://www.runoob.com/wp-content/uploads/2019/11/swarm16.png)

可以看到目前所有的节点都是 Active, 可以接收新的任务分配。

停止节点 swarm-worker1：

[![](https://www.runoob.com/wp-content/uploads/2019/11/swarm17.png)](https://www.runoob.com/wp-content/uploads/2019/11/swarm17.png)

**注意**：swarm-worker1 状态变为 Drain。不会影响到集群的服务，只是 swarm-worker1 节点不再接收新的任务，集群的负载能力有所下降。

可以通过以下命令重新激活节点：

```
docker@swarm-manager:~$  docker node update --availability active swarm-worker1
```

[![](https://www.runoob.com/wp-content/uploads/2019/11/swarm19.png)](https://www.runoob.com/wp-content/uploads/2019/11/swarm19.png)

Swarm 集群管理

## Docker Machine

### 简介

Docker Machine 是一种可以让您在虚拟主机上安装 Docker 的工具，并可以使用 docker-machine 命令来管理主机。

Docker Machine 也可以集中管理所有的 docker 主机，比如快速的给 100 台服务器安装上 docker。

![](https://www.runoob.com/wp-content/uploads/2019/11/68747470733a2f2f646f63732e646f636b65722e636f6d2f6d616368696e652f696d672f6c6f676f2e706e67.png)

Docker Machine 管理的虚拟主机可以是机上的，也可以是云供应商，如阿里云，腾讯云，AWS，或 DigitalOcean。

使用 docker-machine 命令，您可以启动，检查，停止和重新启动托管主机，也可以升级 Docker 客户端和守护程序，以及配置 Docker 客户端与您的主机进行通信。

![](https://www.runoob.com/wp-content/uploads/2019/11/machine.png)

* * *

## 安装

安装 Docker Machine 之前你需要先安装 Docker。

Docker Machine 可以在多种平台上安装使用，包括 Linux 、MacOS 以及 windows。

### Linux 安装命令

```
$ base=https://github.com/docker/machine/releases/download/v0.16.0 &&
  curl -L $base/docker-machine-$(uname -s)-$(uname -m) >/tmp/docker-machine &&
  sudo mv /tmp/docker-machine /usr/local/bin/docker-machine &&
  chmod +x /usr/local/bin/docker-machine
```

### macOS 安装命令

```
$ base=https://github.com/docker/machine/releases/download/v0.16.0 &&
  curl -L $base/docker-machine-$(uname -s)-$(uname -m) >/usr/local/bin/docker-machine &&
  chmod +x /usr/local/bin/docker-machine
```

### Windows 安装命令

如果你是 Windows 平台，可以使用 [Git BASH](https://git-for-windows.github.io/)，并输入以下命令：

```
$ base=https://github.com/docker/machine/releases/download/v0.16.0 &&
  mkdir -p "$HOME/bin" &&
  curl -L $base/docker-machine-Windows-x86_64.exe > "$HOME/bin/docker-machine.exe" &&
  chmod +x "$HOME/bin/docker-machine.exe"
```

查看是否安装成功：

```
$ docker-machine version
docker-machine version 0.16.0, build 9371605
```

> **注意：**各版本更新日志里面也有安装说明：[https://github.com/docker/machine/releases](https://github.com/docker/machine/releases)

* * *

## 使用

本章通过 virtualbox 来介绍 docker-machine 的使用方法。其他云服务商操作与此基本一致。具体可以参考每家服务商的指导文档。

### 1、列出可用的机器

可以看到目前只有这里默认的 default 虚拟机。

```
$ docker-machine ls
```

[![](https://www.runoob.com/wp-content/uploads/2019/11/docker-machine1.png)](https://www.runoob.com/wp-content/uploads/2019/11/docker-machine1.png)

### 2、创建机器

创建一台名为 test 的机器。

```
$ docker-machine create --driver virtualbox test
```

+   **\--driver**：指定用来创建机器的驱动类型，这里是 virtualbox。

[![](https://www.runoob.com/wp-content/uploads/2019/11/docker-machine2.png)](https://www.runoob.com/wp-content/uploads/2019/11/docker-machine2.png)

### 3、查看机器的 ip

```
$ docker-machine ip test
```

[![](https://www.runoob.com/wp-content/uploads/2019/11/docker-machine3.png)](https://www.runoob.com/wp-content/uploads/2019/11/docker-machine3.png)

### 4、停止机器

```
$ docker-machine stop test
```

[![](https://www.runoob.com/wp-content/uploads/2019/11/docker-machine4.png)](https://www.runoob.com/wp-content/uploads/2019/11/docker-machine4.png)

### 5、启动机器

```
$ docker-machine start test
```

[![](https://www.runoob.com/wp-content/uploads/2019/11/docker-machine5.png)](https://www.runoob.com/wp-content/uploads/2019/11/docker-machine5.png)

### 6、进入机器

```
$ docker-machine ssh test
```

[![](https://www.runoob.com/wp-content/uploads/2019/11/docker-machine6.png)](https://www.runoob.com/wp-content/uploads/2019/11/docker-machine6.png)

### docker-machine 命令参数说明

+   **docker-machine active**：查看当前激活状态的 Docker 主机。
    
    ```
    $ docker-machine ls
    
    NAME      ACTIVE   DRIVER         STATE     URL
    dev       -        virtualbox     Running   tcp://192.168.99.103:2376
    staging   *        digitalocean   Running   tcp://203.0.113.81:2376
    
    $ echo $DOCKER_HOST
    tcp://203.0.113.81:2376
    
    $ docker-machine active
    staging
    ```
    
+   **config**：查看当前激活状态 Docker 主机的连接信息。
+   **create**：创建 Docker 主机
+   **env**：显示连接到某个主机需要的环境变量
+   **inspect**： 以 json 格式输出指定Docker的详细信息
+   **ip**： 获取指定 Docker 主机的地址
+   **kill**： 直接杀死指定的 Docker 主机
+   **ls**： 列出所有的管理主机
+   **provision**： 重新配置指定主机
+   **regenerate-certs**： 为某个主机重新生成 TLS 信息
+   **restart**： 重启指定的主机
+   **rm**： 删除某台 Docker 主机，对应的虚拟机也会被删除
+   **ssh**： 通过 SSH 连接到主机上，执行命令
+   **scp**： 在 Docker 主机之间以及 Docker 主机和本地主机之间通过 scp 远程复制数据
+   **mount**： 使用 SSHFS 从计算机装载或卸载目录
+   **start**： 启动一个指定的 Docker 主机，如果对象是个虚拟机，该虚拟机将被启动
+   **status**： 获取指定 Docker 主机的状态(包括：Running、Paused、Saved、Stopped、Stopping、Starting、Error)等
+   **stop**： 停止一个指定的 Docker 主机
+   **upgrade**： 将一个指定主机的 Docker 版本更新为最新
+   **url**： 获取指定 Docker 主机的监听 URL
+   **version**： 显示 Docker Machine 的版本或者主机 Docker 版本
+   **help**： 显示帮助信息

Docker Machine

## Docker Compose

### Compose 简介

Compose 是用于定义和运行多容器 Docker 应用程序的工具。通过 Compose，您可以使用 YML 文件来配置应用程序需要的所有服务。然后，使用一个命令，就可以从 YML 文件配置中创建并启动所有服务。

如果你还不了解 YML 文件配置，可以先阅读 [YAML 入门教程](https://www.runoob.com/w3cnote/yaml-intro.html)。

Compose 使用的三个步骤：

+   使用 Dockerfile 定义应用程序的环境。
    
+   使用 docker-compose.yml 定义构成应用程序的服务，这样它们可以在隔离环境中一起运行。
    
+   最后，执行 docker-compose up 命令来启动并运行整个应用程序。
    

docker-compose.yml 的配置案例如下（配置参数参考下文）：

## 实例

\# yaml 配置实例  
version: '3'  
services:  web:    build: .    ports:  
   - "5000:5000"    volumes:  
   - .:/code  
    - logvolume01:/var/log    links:  
   - redis  redis:    image: redis  
volumes:  logvolume01: {}  

* * *

## Compose 安装

Linux 上我们可以从 Github 上下载它的二进制包来使用，最新发行的版本地址：[https://github.com/docker/compose/releases](https://github.com/docker/compose/releases)。

运行以下命令以下载 Docker Compose 的当前稳定版本：

```
$ sudo curl -L "https://github.com/docker/compose/releases/download/v2.2.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
```

要安装其他版本的 Compose，请替换 v2.2.2。

> Docker Compose 存放在 GitHub，不太稳定。
> 
> 你可以也通过执行下面的命令，高速安装 Docker Compose。
> 
> ```
> curl -L https://get.daocloud.io/docker/compose/releases/download/v2.4.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
> ```

将可执行权限应用于二进制文件：

```
$ sudo chmod +x /usr/local/bin/docker-compose
```

创建软链：

```
$ sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
```

测试是否安装成功：

```
$ docker-compose version
cker-compose version 1.24.1, build 4667896b
```

**注意**： 对于 alpine，需要以下依赖包： py-pip，python-dev，libffi-dev，openssl-dev，gcc，libc-dev，和 make。

### macOS

Mac 的 Docker 桌面版和 Docker Toolbox 已经包括 Compose 和其他 Docker 应用程序，因此 Mac 用户不需要单独安装 Compose。Docker 安装说明可以参阅 [MacOS Docker 安装](https://www.runoob.com/docker/macos-docker-install.html)。

### windows PC

Windows 的 Docker 桌面版和 Docker Toolbox 已经包括 Compose 和其他 Docker 应用程序，因此 Windows 用户不需要单独安装 Compose。Docker 安装说明可以参阅 [Windows Docker 安装](https://www.runoob.com/docker/windows-docker-install.html)。

* * *

## 使用

### 1、准备

创建一个测试目录：

```
$ mkdir composetest
$ cd composetest
```

在测试目录中创建一个名为 app.py 的文件，并复制粘贴以下内容：

## composetest/app.py 文件代码

import time

import redis  
from flask import Flask

app \= Flask(\_\_name\_\_)  
cache \= redis.Redis(host\='redis', port\=6379)

def get\_hit\_count():  
    retries \= 5  
    while True:  
        try:  
            return cache.incr('hits')  
        except redis.exceptions.ConnectionError as exc:  
            if retries \== 0:  
                raise exc  
            retries -\= 1  
            time.sleep(0.5)

@app.route('/')  
def hello():  
    count \= get\_hit\_count()  
    return 'Hello World! I have been seen {} times.\\n'.format(count)

在此示例中，redis 是应用程序网络上的 redis 容器的主机名，该主机使用的端口为 6379。

在 composetest 目录中创建另一个名为 requirements.txt 的文件，内容如下：

```
flask
redis
```

### 2、创建 Dockerfile 文件

在 composetest 目录中，创建一个名为 Dockerfile 的文件，内容如下：

```
FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP app.py
ENV FLASK_RUN_HOST 0.0.0.0
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
CMD ["flask", "run"]
```

**Dockerfile 内容解释：**

+   **FROM python:3.7-alpine**: 从 Python 3.7 映像开始构建镜像。
+   **WORKDIR /code**: 将工作目录设置为 /code。
+   ```
    ENV FLASK_APP app.py
    ENV FLASK_RUN_HOST 0.0.0.0
    ```
    
    设置 flask 命令使用的环境变量。
    
+   **RUN apk add --no-cache gcc musl-dev linux-headers**: 安装 gcc，以便诸如 MarkupSafe 和 SQLAlchemy 之类的 Python 包可以编译加速。
+   ```
    COPY requirements.txt requirements.txt
    RUN pip install -r requirements.txt
    ```
    
    复制 requirements.txt 并安装 Python 依赖项。
    
+   **COPY . .**: 将 . 项目中的当前目录复制到 . 镜像中的工作目录。
+   **CMD \["flask", "run"\]**: 容器提供默认的执行命令为：flask run。

### 3、创建 docker-compose.yml

在测试目录中创建一个名为 docker-compose.yml 的文件，然后粘贴以下内容：

## docker-compose.yml 配置文件

\# yaml 配置  
version: '3'  
services:  web:    build: .    ports:  
     - "5000:5000"  redis:    image: "redis:alpine"  

该 Compose 文件定义了两个服务：web 和 redis。

+   **web**：该 web 服务使用从 Dockerfile 当前目录中构建的镜像。然后，它将容器和主机绑定到暴露的端口 5000。此示例服务使用 Flask Web 服务器的默认端口 5000 。
+   **redis**：该 redis 服务使用 Docker Hub 的公共 Redis 映像。

### 4、使用 Compose 命令构建和运行您的应用

在测试目录中，执行以下命令来启动应用程序：

```
docker-compose up
```

如果你想在后台执行该服务可以加上 \-d 参数：

```
docker-compose up -d
```

* * *

## yml 配置指令参考

### version

指定本 yml 依从的 compose 哪个版本制定的。

### build

指定为构建镜像上下文路径：

例如 webapp 服务，指定为从上下文路径 ./dir/Dockerfile 所构建的镜像：

```
version: "3.7"
services:
  webapp:
    build: ./dir
```

或者，作为具有在上下文指定的路径的对象，以及可选的 Dockerfile 和 args：

```
version: "3.7"
services:
  webapp:
    build:
      context: ./dir
      dockerfile: Dockerfile-alternate
      args:
        buildno: 1
      labels:
        - "com.example.description=Accounting webapp"
        - "com.example.department=Finance"
        - "com.example.label-with-empty-value"
      target: prod
```

+   context：上下文路径。
+   dockerfile：指定构建镜像的 Dockerfile 文件名。
+   args：添加构建参数，这是只能在构建过程中访问的环境变量。
+   labels：设置构建镜像的标签。
+   target：多层构建，可以指定构建哪一层。

### cap\_add，cap\_drop

添加或删除容器拥有的宿主机的内核功能。

```
cap_add:
  - ALL # 开启全部权限

cap_drop:
  - SYS_PTRACE # 关闭 ptrace权限
```

### cgroup\_parent

为容器指定父 cgroup 组，意味着将继承该组的资源限制。

```
cgroup_parent: m-executor-abcd
```

### command

覆盖容器启动的默认命令。

```
command: ["bundle", "exec", "thin", "-p", "3000"]
```

### container\_name

指定自定义容器名称，而不是生成的默认名称。

```
container_name: my-web-container
```

### depends\_on

设置依赖关系。

+   docker-compose up ：以依赖性顺序启动服务。在以下示例中，先启动 db 和 redis ，才会启动 web。
+   docker-compose up SERVICE ：自动包含 SERVICE 的依赖项。在以下示例中，docker-compose up web 还将创建并启动 db 和 redis。
+   docker-compose stop ：按依赖关系顺序停止服务。在以下示例中，web 在 db 和 redis 之前停止。

```
version: "3.7"
services:
  web:
    build: .
    depends_on:
      - db
      - redis
  redis:
    image: redis
  db:
    image: postgres
```

注意：web 服务不会等待 redis db 完全启动 之后才启动。

### deploy

指定与服务的部署和运行有关的配置。只在 swarm 模式下才会有用。

```
version: "3.7"
services:
  redis:
    image: redis:alpine
    deploy:
      mode：replicated
      replicas: 6
      endpoint_mode: dnsrr
      labels: 
        description: "This redis service label"
      resources:
        limits:
          cpus: '0.50'
          memory: 50M
        reservations:
          cpus: '0.25'
          memory: 20M
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
        window: 120s
```

可以选参数：

**endpoint\_mode**：访问集群服务的方式。

```
endpoint_mode: vip 
# Docker 集群服务一个对外的虚拟 ip。所有的请求都会通过这个虚拟 ip 到达集群服务内部的机器。
endpoint_mode: dnsrr
# DNS 轮询（DNSRR）。所有的请求会自动轮询获取到集群 ip 列表中的一个 ip 地址。
```

**labels**：在服务上设置标签。可以用容器上的 labels（跟 deploy 同级的配置） 覆盖 deploy 下的 labels。

**mode**：指定服务提供的模式。

+   **replicated**：复制服务，复制指定服务到集群的机器上。
    
+   **global**：全局服务，服务将部署至集群的每个节点。
    
+   图解：下图中黄色的方块是 replicated 模式的运行情况，灰色方块是 global 模式的运行情况。
    
    ![](https://www.runoob.com/wp-content/uploads/2019/11/docker-composex.png)
    

**replicas：mode** 为 replicated 时，需要使用此参数配置具体运行的节点数量。

**resources**：配置服务器资源使用的限制，例如上例子，配置 redis 集群运行需要的 cpu 的百分比 和 内存的占用。避免占用资源过高出现异常。

**restart\_policy**：配置如何在退出容器时重新启动容器。

+   condition：可选 none，on-failure 或者 any（默认值：any）。
+   delay：设置多久之后重启（默认值：0）。
+   max\_attempts：尝试重新启动容器的次数，超出次数，则不再尝试（默认值：一直重试）。
+   window：设置容器重启超时时间（默认值：0）。

**rollback\_config**：配置在更新失败的情况下应如何回滚服务。

+   parallelism：一次要回滚的容器数。如果设置为0，则所有容器将同时回滚。
+   delay：每个容器组回滚之间等待的时间（默认为0s）。
+   failure\_action：如果回滚失败，该怎么办。其中一个 continue 或者 pause（默认pause）。
+   monitor：每个容器更新后，持续观察是否失败了的时间 (ns|us|ms|s|m|h)（默认为0s）。
+   max\_failure\_ratio：在回滚期间可以容忍的故障率（默认为0）。
+   order：回滚期间的操作顺序。其中一个 stop-first（串行回滚），或者 start-first（并行回滚）（默认 stop-first ）。

**update\_config**：配置应如何更新服务，对于配置滚动更新很有用。

+   parallelism：一次更新的容器数。
+   delay：在更新一组容器之间等待的时间。
+   failure\_action：如果更新失败，该怎么办。其中一个 continue，rollback 或者pause （默认：pause）。
+   monitor：每个容器更新后，持续观察是否失败了的时间 (ns|us|ms|s|m|h)（默认为0s）。
+   max\_failure\_ratio：在更新过程中可以容忍的故障率。
+   order：回滚期间的操作顺序。其中一个 stop-first（串行回滚），或者 start-first（并行回滚）（默认stop-first）。

**注**：仅支持 V3.4 及更高版本。

### devices

指定设备映射列表。

```
devices:
  - "/dev/ttyUSB0:/dev/ttyUSB0"
```

### dns

自定义 DNS 服务器，可以是单个值或列表的多个值。

```
dns: 8.8.8.8

dns:
  - 8.8.8.8
  - 9.9.9.9
```

### dns\_search

自定义 DNS 搜索域。可以是单个值或列表。

```
dns_search: example.com

dns_search:
  - dc1.example.com
  - dc2.example.com
```

### entrypoint

覆盖容器默认的 entrypoint。

```
entrypoint: /code/entrypoint.sh
```

也可以是以下格式：

```
entrypoint:
    - php
    - -d
    - zend_extension=/usr/local/lib/php/extensions/no-debug-non-zts-20100525/xdebug.so
    - -d
    - memory_limit=-1
    - vendor/bin/phpunit
```

### env\_file

从文件添加环境变量。可以是单个值或列表的多个值。

```
env_file: .env
```

也可以是列表格式：

```
env_file:
  - ./common.env
  - ./apps/web.env
  - /opt/secrets.env
```

### environment

添加环境变量。您可以使用数组或字典、任何布尔值，布尔值需要用引号引起来，以确保 YML 解析器不会将其转换为 True 或 False。

```
environment:
  RACK_ENV: development
  SHOW: 'true'
```

### expose

暴露端口，但不映射到宿主机，只被连接的服务访问。

仅可以指定内部端口为参数：

```
expose:
 - "3000"
 - "8000"
```

### extra\_hosts

添加主机名映射。类似 docker client --add-host。

```
extra_hosts:
 - "somehost:162.242.195.82"
 - "otherhost:50.31.209.229"
```

以上会在此服务的内部容器中 /etc/hosts 创建一个具有 ip 地址和主机名的映射关系：

```
162.242.195.82  somehost
50.31.209.229   otherhost
```

### healthcheck

用于检测 docker 服务是否健康运行。

```
healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost"] # 设置检测程序
  interval: 1m30s # 设置检测间隔
  timeout: 10s # 设置检测超时时间
  retries: 3 # 设置重试次数
  start_period: 40s # 启动后，多少秒开始启动检测程序
```

### image

指定容器运行的镜像。以下格式都可以：

```
image: redis
image: ubuntu:14.04
image: tutum/influxdb
image: example-registry.com:4000/postgresql
image: a4bc65fd # 镜像id
```

### logging

服务的日志记录配置。

driver：指定服务容器的日志记录驱动程序，默认值为json-file。有以下三个选项

```
driver: "json-file"
driver: "syslog"
driver: "none"
```

仅在 json-file 驱动程序下，可以使用以下参数，限制日志得数量和大小。

```
logging:
  driver: json-file
  options:
    max-size: "200k" # 单个文件大小为200k
    max-file: "10" # 最多10个文件
```

当达到文件限制上限，会自动删除旧的文件。

syslog 驱动程序下，可以使用 syslog-address 指定日志接收地址。

```
logging:
  driver: syslog
  options:
    syslog-address: "tcp://192.168.0.42:123"
```

### network\_mode

设置网络模式。

```
network_mode: "bridge"
network_mode: "host"
network_mode: "none"
network_mode: "service:[service name]"
network_mode: "container:[container name/id]"
```

networks

配置容器连接的网络，引用顶级 networks 下的条目 。

```
services:
  some-service:
    networks:
      some-network:
        aliases:
         - alias1
      other-network:
        aliases:
         - alias2
networks:
  some-network:
    # Use a custom driver
    driver: custom-driver-1
  other-network:
    # Use a custom driver which takes special options
    driver: custom-driver-2
```

**aliases** ：同一网络上的其他容器可以使用服务名称或此别名来连接到对应容器的服务。

### restart

+   no：是默认的重启策略，在任何情况下都不会重启容器。
+   always：容器总是重新启动。
+   on-failure：在容器非正常退出时（退出状态非0），才会重启容器。
+   unless-stopped：在容器退出时总是重启容器，但是不考虑在Docker守护进程启动时就已经停止了的容器

```
restart: "no"
restart: always
restart: on-failure
restart: unless-stopped
```

注：swarm 集群模式，请改用 restart\_policy。

### secrets

存储敏感数据，例如密码：

```
version: "3.1"
services:

mysql:
  image: mysql
  environment:
    MYSQL_ROOT_PASSWORD_FILE: /run/secrets/my_secret
  secrets:
    - my_secret

secrets:
  my_secret:
    file: ./my_secret.txt
```

### security\_opt

修改容器默认的 schema 标签。

```
security-opt：
  - label:user:USER   # 设置容器的用户标签
  - label:role:ROLE   # 设置容器的角色标签
  - label:type:TYPE   # 设置容器的安全策略标签
  - label:level:LEVEL  # 设置容器的安全等级标签
```

### stop\_grace\_period

指定在容器无法处理 SIGTERM (或者任何 stop\_signal 的信号)，等待多久后发送 SIGKILL 信号关闭容器。

```
stop_grace_period: 1s # 等待 1 秒
stop_grace_period: 1m30s # 等待 1 分 30 秒 
```

默认的等待时间是 10 秒。

### stop\_signal

设置停止容器的替代信号。默认情况下使用 SIGTERM 。

以下示例，使用 SIGUSR1 替代信号 SIGTERM 来停止容器。

```
stop_signal: SIGUSR1
```

### sysctls

设置容器中的内核参数，可以使用数组或字典格式。

```
sysctls:
  net.core.somaxconn: 1024
  net.ipv4.tcp_syncookies: 0

sysctls:
  - net.core.somaxconn=1024
  - net.ipv4.tcp_syncookies=0
```

### tmpfs

在容器内安装一个临时文件系统。可以是单个值或列表的多个值。

```
tmpfs: /run

tmpfs:
  - /run
  - /tmp
```

### ulimits

覆盖容器默认的 ulimit。

```
ulimits:
  nproc: 65535
  nofile:
    soft: 20000
    hard: 40000
```

### volumes

将主机的数据卷或者文件挂载到容器里。

```
version: "3.7"
services:
  db:
    image: postgres:latest
    volumes:
      - "/localhost/postgres.sock:/var/run/postgres/postgres.sock"
      - "/localhost/data:/var/lib/postgresql/data"
```

Docker Compose

## Docker Dockerfile

### 什么是 Dockerfile？

Dockerfile 是一个文本文件，包含了构建 Docker 镜像的所有指令。

Dockerfile 是一个用来构建镜像的文本文件，文本内容包含了一条条构建镜像所需的指令和说明。

通过定义一系列命令和参数，Dockerfile 指导 Docker 构建一个自定义的镜像。

### 使用 Dockerfile 定制镜像

这里仅讲解如何运行 Dockerfile 文件来定制一个镜像，具体 Dockerfile 文件内指令详解，将在下一节中介绍，这里你只要知道构建的流程即可。

**1、下面以定制一个 nginx 镜像（构建好的镜像内会有一个 /usr/share/nginx/html/index.html 文件）**

在一个空目录下，新建一个名为 Dockerfile 文件，并在文件内添加以下内容：

```
FROM nginx
RUN echo '这是一个本地构建的nginx镜像' > /usr/share/nginx/html/index.html
```

![](https://www.runoob.com/wp-content/uploads/2019/11/dockerfile1.png)

**2、FROM 和 RUN 指令的作用**

**FROM**：定制的镜像都是基于 FROM 的镜像，这里的 nginx 就是定制需要的基础镜像。后续的操作都是基于 nginx。

**RUN**：用于执行后面跟着的命令行命令。有以下俩种格式：

shell 格式：

```
RUN <命令行命令>
# <命令行命令> 等同于，在终端操作的 shell 命令。
```

exec 格式：

```
RUN ["可执行文件", "参数1", "参数2"]
# 例如：
# RUN ["./test.php", "dev", "offline"] 等价于 RUN ./test.php dev offline
```

**注意**：Dockerfile 的指令每执行一次都会在 docker 上新建一层。所以过多无意义的层，会造成镜像膨胀过大。例如：

FROM centos  
RUN yum \-y install wget  
RUN wget \-O redis.tar.gz "http://download.redis.io/releases/redis-5.0.3.tar.gz"  
RUN tar \-xvf redis.tar.gz  

以上执行会创建 3 层镜像。可简化为以下格式：

FROM centos  
RUN yum \-y install wget \\  
    && wget \-O redis.tar.gz "http://download.redis.io/releases/redis-5.0.3.tar.gz" \\  
    && tar \-xvf redis.tar.gz  

如上，以 && 符号连接命令，这样执行后，只会创建 1 层镜像。

### 开始构建镜像

在 Dockerfile 文件的存放目录下，执行构建动作。

以下示例，通过目录下的 Dockerfile 构建一个 nginx:v3（镜像名称:镜像标签）。

**注**：最后的 . 代表本次执行的上下文路径，下一节会介绍。

$ docker build \-t nginx:v3 .  

![](https://www.runoob.com/wp-content/uploads/2019/11/dockerfile2.png)

以上显示，说明已经构建成功。

### 上下文路径

上一节中，有提到指令最后一个 . 是上下文路径，那么什么是上下文路径呢？

$ docker build \-t nginx:v3 .  

上下文路径，是指 docker 在构建镜像，有时候想要使用到本机的文件（比如复制），docker build 命令得知这个路径后，会将路径下的所有内容打包。

**解析**：由于 docker 的运行模式是 C/S。我们本机是 C，docker 引擎是 S。实际的构建过程是在 docker 引擎下完成的，所以这个时候无法用到我们本机的文件。这就需要把我们本机的指定目录下的文件一起打包提供给 docker 引擎使用。

如果未说明最后一个参数，那么默认上下文路径就是 Dockerfile 所在的位置。

**注意**：上下文路径下不要放无用的文件，因为会一起打包发送给 docker 引擎，如果文件过多会造成过程缓慢。

* * *

## 指令详解

| Dockerfile 指令 | 说明 |
| --- | --- |
| FROM | 指定基础镜像，用于后续的指令构建。 |
| MAINTAINER | 指定Dockerfile的作者/维护者。（已弃用，推荐使用LABEL指令） |
| LABEL | 添加镜像的元数据，使用键值对的形式。 |
| RUN | 在构建过程中在镜像中执行命令。 |
| CMD | 指定容器创建时的默认命令。（可以被覆盖） |
| ENTRYPOINT | 设置容器创建时的主要命令。（不可被覆盖） |
| EXPOSE | 声明容器运行时监听的特定网络端口。 |
| ENV | 在容器内部设置环境变量。 |
| ADD | 将文件、目录或远程URL复制到镜像中。 |
| COPY | 将文件或目录复制到镜像中。 |
| VOLUME | 为容器创建挂载点或声明卷。 |
| WORKDIR | 设置后续指令的工作目录。 |
| USER | 指定后续指令的用户上下文。 |
| ARG | 定义在构建过程中传递给构建器的变量，可使用 "docker build" 命令设置。 |
| ONBUILD | 当该镜像被用作另一个构建过程的基础时，添加触发器。 |
| STOPSIGNAL | 设置发送给容器以退出的系统调用信号。 |
| HEALTHCHECK | 定义周期性检查容器健康状态的命令。 |
| SHELL | 覆盖Docker中默认的shell，用于RUN、CMD和ENTRYPOINT指令。 |

### COPY

复制指令，从上下文目录中复制文件或者目录到容器里指定路径。

格式：

```
COPY [--chown=<user>:<group>] <源路径1>...  <目标路径>
COPY [--chown=<user>:<group>] ["<源路径1>",...  "<目标路径>"]
```

**\[--chown=<user>:<group>\]**：可选参数，用户改变复制到容器内文件的拥有者和属组。

**<源路径>**：源文件或者源目录，这里可以是通配符表达式，其通配符规则要满足 Go 的 filepath.Match 规则。例如：

```
COPY hom* /mydir/
COPY hom?.txt /mydir/
```

**<目标路径>**：容器内的指定路径，该路径不用事先建好，路径不存在的话，会自动创建。

### ADD

ADD 指令和 COPY 的使用格类似（同样需求下，官方推荐使用 COPY）。功能也类似，不同之处如下：

+   ADD 的优点：在执行 <源文件> 为 tar 压缩文件的话，压缩格式为 gzip, bzip2 以及 xz 的情况下，会自动复制并解压到 <目标路径>。
+   ADD 的缺点：在不解压的前提下，无法复制 tar 压缩文件。会令镜像构建缓存失效，从而可能会令镜像构建变得比较缓慢。具体是否使用，可以根据是否需要自动解压来决定。

### CMD

类似于 RUN 指令，用于运行程序，但二者运行的时间点不同:

+   CMD 在docker run 时运行。
+   RUN 是在 docker build。

**作用**：为启动的容器指定默认要运行的程序，程序运行结束，容器也就结束。CMD 指令指定的程序可被 docker run 命令行参数中指定要运行的程序所覆盖。

**注意**：如果 Dockerfile 中如果存在多个 CMD 指令，仅最后一个生效。

格式：

```
CMD <shell 命令> 
CMD ["<可执行文件或命令>","<param1>","<param2>",...] 
CMD ["<param1>","<param2>",...]  # 该写法是为 ENTRYPOINT 指令指定的程序提供默认参数
```

推荐使用第二种格式，执行过程比较明确。第一种格式实际上在运行的过程中也会自动转换成第二种格式运行，并且默认可执行文件是 sh。

### ENTRYPOINT

类似于 CMD 指令，但其不会被 docker run 的命令行参数指定的指令所覆盖，而且这些命令行参数会被当作参数送给 ENTRYPOINT 指令指定的程序。

但是, 如果运行 docker run 时使用了 --entrypoint 选项，将覆盖 ENTRYPOINT 指令指定的程序。

**优点**：在执行 docker run 的时候可以指定 ENTRYPOINT 运行所需的参数。

**注意**：如果 Dockerfile 中如果存在多个 ENTRYPOINT 指令，仅最后一个生效。

格式：

```
ENTRYPOINT ["<executeable>","<param1>","<param2>",...]
```

可以搭配 CMD 命令使用：一般是变参才会使用 CMD ，这里的 CMD 等于是在给 ENTRYPOINT 传参，以下示例会提到。

示例：

假设已通过 Dockerfile 构建了 nginx:test 镜像：

```
FROM nginx

ENTRYPOINT ["nginx", "-c"] # 定参
CMD ["/etc/nginx/nginx.conf"] # 变参 
```

1、不传参运行

```
$ docker run  nginx:test
```

容器内会默认运行以下命令，启动主进程。

```
nginx -c /etc/nginx/nginx.conf
```

2、传参运行

```
$ docker run  nginx:test -c /etc/nginx/new.conf
```

容器内会默认运行以下命令，启动主进程(/etc/nginx/new.conf:假设容器内已有此文件)

```
nginx -c /etc/nginx/new.conf
```

### ENV

设置环境变量，定义了环境变量，那么在后续的指令中，就可以使用这个环境变量。

格式：

```
ENV <key> <value>
ENV <key1>=<value1> <key2>=<value2>...
```

以下示例设置 NODE\_VERSION = 7.2.0 ， 在后续的指令中可以通过 $NODE\_VERSION 引用：

```
ENV NODE_VERSION 7.2.0

RUN curl -SLO "https://nodejs.org/dist/v$NODE_VERSION/node-v$NODE_VERSION-linux-x64.tar.xz" \
  && curl -SLO "https://nodejs.org/dist/v$NODE_VERSION/SHASUMS256.txt.asc"
```

### ARG

构建参数，与 ENV 作用一致。不过作用域不一样。ARG 设置的环境变量仅对 Dockerfile 内有效，也就是说只有 docker build 的过程中有效，构建好的镜像内不存在此环境变量。

构建命令 docker build 中可以用 --build-arg <参数名>=<值> 来覆盖。

格式：

```
ARG <参数名>[=<默认值>]
```

### VOLUME

定义匿名数据卷。在启动容器时忘记挂载数据卷，会自动挂载到匿名卷。

作用：

+   避免重要的数据，因容器重启而丢失，这是非常致命的。
+   避免容器不断变大。

格式：

```
VOLUME ["<路径1>", "<路径2>"...]
VOLUME <路径>
```

在启动容器 docker run 的时候，我们可以通过 -v 参数修改挂载点。

### EXPOSE

仅仅只是声明端口。

作用：

+   帮助镜像使用者理解这个镜像服务的守护端口，以方便配置映射。
+   在运行时使用随机端口映射时，也就是 docker run -P 时，会自动随机映射 EXPOSE 的端口。

格式：

```
EXPOSE <端口1> [<端口2>...]
```

### WORKDIR

指定工作目录。用 WORKDIR 指定的工作目录，会在构建镜像的每一层中都存在。以后各层的当前目录就被改为指定的目录，如该目录不存在，WORKDIR 会帮你建立目录。

docker build 构建镜像过程中的，每一个 RUN 命令都是新建的一层。只有通过 WORKDIR 创建的目录才会一直存在。

格式：

```
WORKDIR <工作目录路径>
```

### USER

用于指定执行后续命令的用户和用户组，这边只是切换后续命令执行的用户（用户和用户组必须提前已经存在）。

格式：

```
USER <用户名>[:<用户组>]
```

### HEALTHCHECK

用于指定某个程序或者指令来监控 docker 容器服务的运行状态。

格式：

```
HEALTHCHECK [选项] CMD <命令>：设置检查容器健康状况的命令
HEALTHCHECK NONE：如果基础镜像有健康检查指令，使用这行可以屏蔽掉其健康检查指令

HEALTHCHECK [选项] CMD <命令> : 这边 CMD 后面跟随的命令使用，可以参考 CMD 的用法。
```

### ONBUILD

用于延迟构建命令的执行。简单的说，就是 Dockerfile 里用 ONBUILD 指定的命令，在本次构建镜像的过程中不会执行（假设镜像为 test-build）。当有新的 Dockerfile 使用了之前构建的镜像 FROM test-build ，这时执行新镜像的 Dockerfile 构建时候，会执行 test-build 的 Dockerfile 里的 ONBUILD 指定的命令。

格式：

```
ONBUILD <其它指令>
```

### LABEL

LABEL 指令用来给镜像添加一些元数据（metadata），以键值对的形式，语法格式如下：

```
LABEL <key>=<value> <key>=<value> <key>=<value> ...
```

比如我们可以添加镜像的作者：

```
LABEL org.opencontainers.image.authors="runoob"
```

21 个基本 Docker 命令 [通过示例进行解释]

Swarm 集群管理

简介

Docker Machine

简介

Docker Compose

Compose 简介

Docker Dockerfile

什么是 Dockerfile？