Docker 概述

之前的虚拟机技术

以往虚拟机结构

虚拟机技术缺点

  1. 资源占用十分多

  2. 冗余步骤多

  3. 启动很慢！

容器化技术

容器化技术不是模拟的一个完整的操作系统

容器化技术

比较 Docker 和 虚拟机技术的不同：

  • 传统虚拟机，虚拟出一些硬件，运行一个完整的操作系统，然后在这个系统上安装和运行软件
  • 容器内的应用直接运行在 宿主机的内核，容器是没有自己的内核的，也没有虚拟我们的硬件，所以就轻便了
  • 每个容器间是互相隔离的，每个容器内都有一个属于自己的文件系统，互不影响

DevOps(开发、运维)

应用更快速的交付和部署

传统：一堆帮助文档，安装程序

Docker：打包镜像发布测试，一键运行

更快捷的升级和扩缩容

使用了 Docker 之后，我们部署应用就像搭积木一样！

项目打包为一个镜像，扩展 服务器 A ！ 服务器 B…

更简单的系统运维

在容器化之后，我们的开发，测试环境都是高度一致的。

更高效的计算资源利用

Docker 是内核级别的虚拟化，可以在一个物理机上运行很多的容器实例！服务器的性能可以被压榨到极致。

安装 Docker

Docker 的基本组成

Docker基本组成

镜像（images）：

docker 镜像就好比是一个模版，可以通过这个模版来创建容器服务，tomcat 镜像 --> run --> tomcat01 容器（提供服务器）， 通过这个镜像可以创建多个容器（最终服务运行或者项目运行就是在容器中的）。

容器（container）：

Docker 利用容器技术，独立运行一个或者一组应用，它们是通过镜像来创建的。

启动、停止、删除…基本命令！

目前可以把容器理解为就是一个简易的 linux 系统

仓库（repository）：

仓库就是存放镜像的地方！

仓库分为公有仓库和私有仓库！

Docker Hub（默认是国外的）

阿里云…都有容器服务器（配置镜像加速！）

安装 Docker

环境准备

  1. 需要会一点点的 Linux 基础
  2. Ubuntu 20.04
  3. Windows 可以使用 Xshell 7 或者下载 Terminal 终端连接远程服务器进行操作！这里我是使用 Mac 自有 Terminal 进行操作

环境查看

1
2
3
# 系统内核
# uname -r
5.4.0-150-generic
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 系统版本
# cat /etc/os-release
NAME="Ubuntu"
VERSION="20.04.6 LTS (Focal Fossa)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 20.04.6 LTS"
VERSION_ID="20.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=focal
UBUNTU_CODENAME=focal

安装

帮助文档：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 1. 卸载旧的版本
for pkg in docker.io docker-doc docker-compose podman-docker containerd runc; do sudo apt-get remove $pkg; done

# 2. 需要的安装包
# 添加Docker的官方GPG密钥
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# 将docker-ubuntu仓库添加到Apt源
echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 更新apt-get软件包索引
sudo apt-get update

# 安装docker docker-ce 社区 ee 企业版
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# 3. 设置镜像的仓库
TODO

# 4. 启动docker
systemctl start docker
sudo service docker start

# 5. 使用docker version 查看是否安装成功
docker version

docker version

1
2
3
4
5
# 6. hello-world
docker run hello-world # 启动之后会有Hello from Docker!

# 7. 查看一下下载的这个 hello-world 镜像
docker images

了解：卸载 docker

1
2
3
4
5
6
# 1. 卸载依赖
sudo apt-get purge docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras

# 2. 删除资源
sudo rm -rf /var/lib/docker # docker的默认工作路径!
sudo rm -rf /var/lib/containerd

配置阿里云镜像加速

  1. 登录阿里云找到容器镜像服务

    阿里云容器镜像服务位置

  2. 找到镜像加速地址。

阿里云镜像加速地址

  1. 配置使用
1
2
3
4
5
6
7
8
9
10
11
sudo mkdir -p /etc/docker

sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://xxxxxx.mirror.aliyuncs.com"]
}
EOF

sudo systemctl daemon-reload

sudo systemctl restart docker

回顾 HelloWorld 流程

docker run 的运行流程

底层原理

Docker 是怎么工作的？

Docker 是一个 Client - Server 结构的系统，Docker 的守护进程运行在主机上。通过 Socket 从客户端访问 Docker！

DockerServer 接收到 Docker-Client 的指令，就会去执行命令！

docker 底层原理

Docker 为什么比 VM 快？

  1. Docker 有着比虚拟机更少的抽象层。

  2. docker 利用的是宿主机的内核，VM 需要是 Guest OS。

    Docker与虚拟机架构对比

    所以说， 新建一个容器的时候，docker 不需要像虚拟机一样重新加载一个操作系统内核，避免引导。虚拟机是加载 Guest OS，是分钟级别的，而 docker 是利用宿主机的操作系统，省略了这个复杂的过程，是秒级的！

    Docker容器、LXC、VM对比

Docker 常用命令

帮助命令

1
2
3
docker version      # 显示docker的版本信息
docker info         # 显示docker的系统信息，包括镜像和容器的数量
docker 命令 --help   # 帮助命令

帮助文档的地址：https://docs.docker.com/engine/reference/commandline/

镜像的基本命令

docker images 查看所有本地的主机上的镜像

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# docker images
REPOSITORY                 TAG       IMAGE ID       CREATED        SIZE
jc22/nginx-proxy-manager   latest    9c3f57xxxxxx   5 weeks ago    843MB
go                         1.20      b2941exxxxxx   6 weeks ago    1.51GB

# 解释
REPOSITORY  镜像的仓库源
TAG         镜像的标签
IMAGE ID    镜像的id
CREATED     镜像的创建时间
SIZE        镜像的大小

# 可选项
  -a, --all             # 列出所有的镜像
      --digests         # 展示签名
  -q, --quiet           # 只显示镜像的id

docker search 搜索镜像

1
2
3
4
5
6
7
8
9
10
11
# docker search
NAME                            DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql                           MySQL is a widely used, open-source relation…   14474     [OK]
mariadb                         MariaDB Server is a high performing open sou…   5527      [OK]

# 可选项, 通过收藏来过滤
--filter=STARS=3000      # 搜索出来的镜像就是STARS大于3000的
# docker search mysql --filter=STARS=3000
NAME      DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql     MySQL is a widely used, open-source relation…   14474     [OK]
mariadb   MariaDB Server is a high performing open sou…   5527      [OK]

docker pull 下载镜像

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# docker pull 镜像名[:tag]
Using default tag: latest # 如果不写 tag，默认是 latest

# 按照指定版本举例
# docker pull mysql：5.7
5.7: Pulling from library/mysql # 分层下载，docker images的核心 联合文件系统
72a69066d2fe: Pull complete
93619dbc5b36: Pull complete
99da31dd6142: Pull complete
626033c43d70: Pull complete
37d5d7efb64e: Pull complete
ac563158d721: Pull complete
d2ba16033dad: Pull complete
0ceb82207cd7: Pull complete
37f2405cae96: Pull complete
e2482e017e53: Pull complete
70deed891d42: Pull complete
Digest: sha256:f2ad209efe9c67104167fc609cca6973c8422939491c9345270175a300419f94 # 签名
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7 # 真实地址

# 等价于它
docker pull docker:5.7
docker pull docker.io/library/mysql:5.7

docker rmi 删除镜像

1
2
3
4
5
# docker rmi -f 镜像id # 删除指定的镜像
docker rmi c20987f18b13

# docker rmi -f 镜像id 镜像id 镜像id 镜像id # 删除多个镜像
docker rmi -f $(docker images -aq) # 删除所有镜像

容器的基本命令

说明：我们有了镜像才可以创建容器，linux 为例，下载一个 centos 镜像来测试学习

1
docker pull centos

新建容器并启动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
docker run [可选参数] image

# 参数说明
--name="Name"      容器名字 tomcat01 tomcat02，用来区分容器
-d                 后台方式运行
-it                使用交互方式运行，进入容器查看内容
-p                 指定容器的端口 -p 8080:8080
      -p ip:主机端口:容器端口
      -p 主机端口:容器端口  (常用)
      -p 容器端口  # 不映射
      直接写容器端口
-P                 随机指定端口

# 测试，启动并进入容器
# docker run -it centos /bin/bash
[root@e0256025f29c /]# ls      # 查看容器内的centos，基础版本，很多命令都是不完善的！
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

# 从容器中退回到主机
[root@e0256025f29c /]# exit
exit

列出所有运行中的容器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# docker ps 命令
      # 列出当前正在运行的容器
-a    # 列出当前正在运行的容器+带出历史运行过的容器
-n=?  # 显示最近创建的容器 n=1表示最近1个
-q    # 只显示容器的编号

# docker ps -n=1
CONTAINER ID   IMAGE     COMMAND       CREATED         STATUS                     PORTS     NAMES
e0256025f29c   centos    "/bin/bash"   5 minutes ago   Exited (0) 4 minutes ago             cool_perlman

# docker ps -aq
e0256025f29q
8f531646b70k
6d53ff9106bs
b32e55a5cd7e

退出容器

1
2
exit          # 容器停止并退出
Ctrl + P + Q  # 容器不停止退出

删除容器

1
2
3
4
# docker rm 命令
docker rm 容器id                   # 删除指定的容器，不能删除正在运行的容器，如果要强制删除 rm -f
docker rm -f $(docker ps -aq)      # 删除所有的容器
docker ps -a -q | xargs docker rm  # 删除所有的容器

启动和停止容器的操作

1
2
3
4
docker start 容器id      # 启动容器
docker restart 容器id    # 重启容器
docker stop 容器id       # 停止当前正在运行的容器
docker kill 容器id       # 强制停止当前容器

其他常用命令

后台启动容器

1
2
3
4
5
6
7
8
# 命令 docker run -d 镜像名！
# docker run -d centos

# 问题docker ps，发现 centos 停止了

# 常见的坑：docker 容器使用后台运行，就必须要有一个前台进程，docker发现没有应用，就会自动停止
# 比如 nginx，容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了
# 我的理解是进入容器之后什么进程都没有开，就会默认关闭，如果是tomcat(举例), 就不会

查看日志

1
2
3
4
5
6
7
8
9
docker logs -tf --tail 10 容器， 没有日志

# 自己编写一段shell脚本
# docker run -d centos /bin/bash -c "while true;do echo axin-star;sleep 1;done"

# 显示日志
-tf            # 显示日志 t是时间戳 f是标准日志输出格式
--tail number  # 要显示的日志数量(末尾)
docker logs -tf --tail 10 centos(或者容器id，我这里docker rename过容器名了)

查看容器中进程信息

1
2
3
4
5
# 命令 docker top 容器id
# docker top centos
UID                 PID                 PPID                C                   STIME               TTY
root                867783              867760              0                   22:59               ?
root                868502              867783              0                   23:08               ?

查看容器的元数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
# 命令
docker inspect centos(容器id)

# 测试 docker inspect centos
[
    {
        "Id": "d4cb64d7b19ecf2b223201d5550b016dcd6dd7bec6bc07eb088a0cbb00b5b0ad", # 容器id
        "Created": "2023-09-25T14:59:05.664555367Z",
        "Path": "/bin/bash", # 命令行
        "Args": [
            "-c",
            "while true;do echo axin-star;sleep 1;done" # 创建容器时的入参
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 867783,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2023-09-25T14:59:05.891054131Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6", # 创建镜像
        "ResolvConfPath": "/var/lib/docker/containers/d4cb64d7b19ecf2b223201d5550b016dcd6dd7bec6bc07eb088a0cbb00b5b0ad/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/d4cb64d7b19ecf2b223201d5550b016dcd6dd7bec6bc07eb088a0cbb00b5b0ad/hostname",
        "HostsPath": "/var/lib/docker/containers/d4cb64d7b19ecf2b223201d5550b016dcd6dd7bec6bc07eb088a0cbb00b5b0ad/hosts",
        "LogPath": "/var/lib/docker/containers/d4cb64d7b19ecf2b223201d5550b016dcd6dd7bec6bc07eb088a0cbb00b5b0ad/d4cb64d7b19ecf2b223201d5550b016dcd6dd7bec6bc07eb088a0cbb00b5b0ad-json.log",
        "Name": "/centos",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "docker-default",
        "ExecIDs": null,
        "HostConfig": {
            "Binds": null,
            "ContainerIDFile": "",
            "LogConfig": {
                "Type": "json-file",
                "Config": {}
            },
            "NetworkMode": "default",
            "PortBindings": {},
            "RestartPolicy": {
                "Name": "no",
                "MaximumRetryCount": 0
            },
            "AutoRemove": false,
            "VolumeDriver": "",
            "VolumesFrom": null,
            "ConsoleSize": [
                69,
                211
            ],
            "CapAdd": null,
            "CapDrop": null,
            "CgroupnsMode": "host",
            "Dns": [],
            "DnsOptions": [],
            "DnsSearch": [],
            "ExtraHosts": null,
            "GroupAdd": null,
            "IpcMode": "private",
            "Cgroup": "",
            "Links": null,
            "OomScoreAdj": 0,
            "PidMode": "",
            "Privileged": false,
            "PublishAllPorts": false,
            "ReadonlyRootfs": false,
            "SecurityOpt": null,
            "UTSMode": "",
            "UsernsMode": "",
            "ShmSize": 67108864,
            "Runtime": "runc",
            "Isolation": "",
            "CpuShares": 0,
            "Memory": 0,
            "NanoCpus": 0,
            "CgroupParent": "",
            "BlkioWeight": 0,
            "BlkioWeightDevice": [],
            "BlkioDeviceReadBps": [],
            "BlkioDeviceWriteBps": [],
            "BlkioDeviceReadIOps": [],
            "BlkioDeviceWriteIOps": [],
            "CpuPeriod": 0,
            "CpuQuota": 0,
            "CpuRealtimePeriod": 0,
            "CpuRealtimeRuntime": 0,
            "CpusetCpus": "",
            "CpusetMems": "",
            "Devices": [],
            "DeviceCgroupRules": null,
            "DeviceRequests": null,
            "MemoryReservation": 0,
            "MemorySwap": 0,
            "MemorySwappiness": null,
            "OomKillDisable": false,
            "PidsLimit": null,
            "Ulimits": null,
            "CpuCount": 0,
            "CpuPercent": 0,
            "IOMaximumIOps": 0,
            "IOMaximumBandwidth": 0,
            "MaskedPaths": [
                "/proc/asound",
                "/proc/acpi",
                "/proc/kcore",
                "/proc/keys",
                "/proc/latency_stats",
                "/proc/timer_list",
                "/proc/timer_stats",
                "/proc/sched_debug",
                "/proc/scsi",
                "/sys/firmware"
            ],
            "ReadonlyPaths": [
                "/proc/bus",
                "/proc/fs",
                "/proc/irq",
                "/proc/sys",
                "/proc/sysrq-trigger"
            ]
        },
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/8a727b0a49f8ff10a6ae2b3daf86cd00ba54788266eef1d645278273a7caa4d3-init/diff:/var/lib/docker/overlay2/9f2816bc7dd86bbc648a278390f3b0675c09d34c85ea898d15bbf671e7d53e4c/diff",
                "MergedDir": "/var/lib/docker/overlay2/8a727b0a49f8ff10a6ae2b3daf86cd00ba54788266eef1d645278273a7caa4d3/merged",
                "UpperDir": "/var/lib/docker/overlay2/8a727b0a49f8ff10a6ae2b3daf86cd00ba54788266eef1d645278273a7caa4d3/diff",
                "WorkDir": "/var/lib/docker/overlay2/8a727b0a49f8ff10a6ae2b3daf86cd00ba54788266eef1d645278273a7caa4d3/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "d4cb64d7b19e",
            "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/bash",
                "-c",
                "while true;do echo axin-star;sleep 1;done"
            ],
            "Image": "centos",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "org.label-schema.build-date": "20210915",
                "org.label-schema.license": "GPLv2",
                "org.label-schema.name": "CentOS Base Image",
                "org.label-schema.schema-version": "1.0",
                "org.label-schema.vendor": "CentOS"
            }
        },
        "NetworkSettings": {
            "Bridge": "",
            "SandboxID": "f41be92b05d7303b0fe4d61630f644849cc128cd61b173898524da4f856bad35",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/f41be92b05d7",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "bf370a850eab20d07c9990291157c8b41dcaa39337ebd01d678edc6468cc5fce",
            "Gateway": "172.17.0.1",
            "GlobalIPv6Address": "",
            "GlobalIPv6PrefixLen": 0,
            "IPAddress": "172.17.0.3",
            "IPPrefixLen": 16,
            "IPv6Gateway": "",
            "MacAddress": "02:42:ac:11:00:03",
            "Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "96d624d53e6c11d7f2c2e4568a8a0c8dceb24b23e9e92e2397f9e0bb38a6c965",
                    "EndpointID": "bf370a850eab20d07c9990291157c8b41dcaa39337ebd01d678edc6468cc5fce",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.3",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:11:00:03",
                    "DriverOpts": null
                }
            }
        }
    }
]

进入当前正在运行的容器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 通常容器都是使用后台方式运行的，需要进入容器，修改一些配置

# 命令
docker exec -it 容器id bashShell(bash /bin/bash /bin/sh)

# 测试
# docker exec -it centos bash
[root@d4cb64d7b19e /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@d4cb64d7b19e /]# ps -ef
UID          PID    PPID  C STIME TTY          TIME CMD
root           1       0  0 14:59 ?        00:00:00 /bin/bash -c while true;do echo axin-star;sleep 1;done
root        1142       0  0 15:18 pts/0    00:00:00 bash
root        1163       1  0 15:18 ?        00:00:00 /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/sleep 1
root        1164    1142  0 15:18 pts/0    00:00:00 ps -ef

# 方式二
docker attach 容器id
# 测试
docker attach centos
正在执行当前进程...

# docker exec      # 进入容器后开启一个新的终端，可以在里边操作(常用)
# docker attach    # 进入容器正在执行的终端，不会启动新的进程！

从容器内拷贝文件到主机上

1
2
3
docker cp 容器id:容器内路径 目的主机的路径

# 拷贝是一个手动过程，未来我们使用 -v 卷的技术，可以实现自动同步

常用命令小结

docker 命令概览

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
attach    Attach to a running container                    #当前shell下attach连接指定运行镜像
build     Build an image from a Dockerfile                 #通过Dockerfile定制镜像
commit    Create a new image from a container's changes    #提交当前容器为新的镜像
cp        Copy files/folders from a container to a HOSTDIR or to STDOUT  #从容器中拷贝指定文件或者目录到宿主机中
create    Create a new container                           #创建一个新的容器，同run 但不启动容器
diff      Inspect changes on a container's filesystem      #查看docker容器变化
events    Get real time events from the server             #从docker服务获取容器实时事件
exec      Run a command in a running container             #在已存在的容器上运行命令
export    Export a container's filesystem as a tar archive #导出容器的内容流作为一个tar归档文件(对应import)
history   Show the history of an image                     #展示一个镜像形成历史
images    List images                                      #列出系统当前镜像
import    Import the contents from a tarball to create a filesystem image  #从tar包中的内容创建一个新的文件系统映像(对应export)
info      Display system-wide information                  #显示系统相关信息
inspect   Return low-level information on a container or image  #查看容器详细信息(元数据)
kill      Kill a running container                         #kill指定docker容器
load      Load an image from a tar archive or STDIN        #从一个tar包中加载一个镜像(对应save)
login     Register or log in to a Docker registry          #注册或者登陆一个docker源服务器
logout    Log out from a Docker registry                   #从当前Docker registry退出
logs      Fetch the logs of a container                    #输出当前容器日志信息
pause     Pause all processes within a container           #暂停容器
port      List port mappings or a specific mapping for the CONTAINER  #查看映射端口对应的容器内部源端口
ps        List containers                                  #列出容器列表
pull      Pull an image or a repository from a registry    #从docker镜像源服务器拉取指定镜像或者库镜像
push      Push an image or a repository to a registry      #推送指定镜像或者库镜像至docker源服务器
rename    Rename a container                               #重命名容器
restart   Restart a running container                      #重启运行的容器
rm        Remove one or more containers                    #移除一个或者多个容器
rmi       Remove one or more images                        #移除一个或多个镜像(无容器使用该镜像才可以删除，否则需要删除相关容器才可以继续或者-f强制删除)
run       Run a command in a new container                 #创建一个新的容器并运行一个命令
save      Save an image(s) to a tar archive                #保存一个镜像为一个tar包(对应load)
search    Search the Docker Hub for images                 #在docker hub中搜索镜像
start     Start one or more stopped containers             #启动容器
stats     Display a live stream of container(s) resource usage statistics  #统计容器使用资源
stop      Stop a running container                         #停止容器
tag       Tag an image into a repository                   #给源中镜像打标签
top       Display the running processes of a container     #查看容器中运行的进程信息
unpause   Unpause all processes within a container         #取消暂停容器
version   Show the Docker version information              #查看容器版本号
wait      Block until a container stops, then print its exit code  #截取容器停止时的退出状态值

docker 的命令是十分多的，上面我们学习的都是那些最常用的容器和镜像的命令，之后还会学习很多命令！