docker

Docker 学习笔记

本文档涵盖 Docker 的简介、架构、安装、常用命令、数据卷挂载、自定义镜像（Dockerfile）、容器互联、Docker Compose 编排以及私有仓库搭建等内容。

目录

• [一、Docker 简介](#一、Docker 简介)
• [二、Docker 架构](#二、Docker 架构)
• [三、Docker 安装](#三、Docker 安装)
• [四、Docker 常用命令](#四、Docker 常用命令)
• [五、Docker 数据卷挂载](#五、Docker 数据卷挂载)
• 六、自动创建镜像
• 七、容器互联
• [八、容器编排工具 - Docker Compose](#八、容器编排工具 - Docker Compose)
• [九、构建 Docker 的私有仓库](#九、构建 Docker 的私有仓库)
• [十、总结：Docker 常用命令速查](#十、总结：Docker 常用命令速查)

---

一、Docker 简介

1.1 虚拟化与 Docker

虚拟化技术主要分为两种类型：

1. 硬件级虚拟化（hardware-level-virtualization）：如 VMWare，模拟完整的硬件环境，每个虚拟机需要安装完整的操作系统，资源开销大。
2. 操作系统级虚拟化（os-level-virtualization）：如 Docker，多个容器共享宿主机的操作系统内核，轻量级、启动速度快。

对比：

项目	VMWare（虚拟机）	Docker（容器）
是否包含操作系统	每个虚拟机包含完整的操作系统	共享宿主机内核，只包含应用及其依赖
资源占用	大	小
启动速度	慢	快（秒级）

1.2 云服务的三种模式

• IaaS（Infrastructure-as-a-service，基础设施即服务）：提供虚拟机、存储、网络等基础设施资源。
• PaaS（Platform-as-a-service，平台即服务）：提供应用开发与部署的运行平台，用户无需关心底层环境。
• SaaS（Software-as-a-service，软件即服务）：直接提供软件服务，如 CRM、processon 等。

1.3 Docker 是什么

• Docker 是一个开源的应用容器引擎 ，基于 Go 语言 开发，遵循 Apache2.0 协议开源。
• 起源于 PaaS 公司 dotCloud，基于 LXC 技术，后托管到 GitHub 进行开源。
• 可以让开发者将应用及其依赖打包到一个可移植的容器中，发布到任何流行的 Linux / Windows 机器上。

---

二、Docker 架构

• Docker 采用客户端/服务器（C/S）架构。
• Docker 客户端通过 REST API 与 Docker 守护进程（daemon）进行通信。
• Docker 的三大核心组件：

组件	说明
镜像（Image）	只读的模板，用于创建容器
容器（Container）	镜像运行后的实例，等同于 Linux 中的一个进程
仓库（Repository）	集中存放镜像文件的地方（如 Docker Hub）

---

三、Docker 安装

3.1 环境要求

• 64 位操作系统
• 内存 4G 以上
• Linux 内核版本 3.10 及以上

查看当前操作系统版本：

cat /etc/redhat-release

查看系统内核版本：

uname -r

Docker 有两个版本：

1. Docker-ce：社区版（开源）
2. Docker-ee：企业版（收费）

3.2 Docker 下载安装地址

官网下载安装地址：https://docs.docker.com/engine/install/centos/

Docker 的安装方式有以下三种：

1. Docker's repositories：Docker 仓库安装（推荐使用）
2. RPM package：RPM 包安装
3. automated convenience scripts：脚本安装

3.3 卸载旧版本

如果之前已经安装过 Docker 则需要卸载，没有安装可略过：

yum remove docker \
                 docker-client \
                 docker-client-latest \
                 docker-common \
                 docker-latest \
                 docker-latest-logrotate \
                 docker-logrotate \
                 docker-engine

3.4 安装 Docker 的 yum 仓库

安装 yum-utils 工具包：

yum install -y yum-utils

使用 yum-config-manager 工具安装 yum 仓库：

# 官网（不推荐）
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

# 阿里云
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

更新 yum 缓存（重建 yum 本地的缓存文件），提高 yum 安装软件包的速度：

yum makecache fast

3.5 安装 Docker Engine（Docker 引擎）

安装 Docker 引擎、容器和相关组件：

# 默认安装最新版，想要安装其他版本可以查看版本列表，并安装指定的版本
yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# 查看版本列表
yum list docker-ce --showduplicates

# 安装指定的版本
yum install docker-ce-20.10.24 docker-ce-cli-20.10.24 containerd.io docker-buildx-plugin-20.10.24 docker-compose-plugin

3.6 启动 Docker

启动 Docker 服务：

systemctl start docker.service

启动 Docker 的同时设置开机自启动：

systemctl enable docker --now

3.7 查看 Docker 版本信息

查看 Docker 版本：

docker -v

输出示例：

Docker version 26.1.3, build b72abbb

查看 Docker 的详细版本信息：

docker version

查看 Docker 的镜像信息：

docker images

输出示例：

REPOSITORY   TAG       IMAGE ID   CREATED   SIZE

3.8 运行 hello-world 镜像，测试 Docker 是否安装成功

docker run hello-world

查看本地镜像库：

docker images

查看镜像运行后的容器：

docker ps -a

3.9 卸载 Docker

停止 Docker 服务：

systemctl stop docker

删除 Docker：

yum remove docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras

删除 Docker 相关文件：

rm -rf /var/lib/docker/
rm -rf /var/lib/containerd/

3.10 配置镜像加速器

使用阿里云进行镜像加速，需要到阿里云获取专属的镜像加速器地址 ，阿里云官网：https://www.aliyun.com/

1. 进入阿里云官网首页，选择 产品 --> 容器 --> 容器镜像服务

2. 进入镜像服务页面，登录后进入控制台（没有账户需注册，支付宝、钉钉、淘宝账户都可以）

3. 获取专属加速器地址，并在系统中进行配置

单独使用阿里云镜像加速器配置：

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://rk8pe7c8.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

使用阿里云镜像加速器后，有些镜像依然下载不下来，建议多使用几个镜像加速器：

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": [
    "https://hmhv5tp5.mirror.aliyuncs.com",
    "https://mirror.baidubce.com",
    "https://do.nark.eu.org",
    "https://dc.j8.work",
    "https://docker.m.daocloud.io",
    "https://dockerproxy.com",
    "https://docker.mirrors.ustc.edu.cn",
    "https://docker.nju.edu.cn",
    "https://dockerhub.icu",
    "https://docker.chenby.cn",
    "https://docker.1panel.live",
    "https://docker.awsl9527.cn",
    "https://docker.anyhub.us.kg",
    "https://dhub.kubesre.xyz",
    "https://docker.xuanyuan.me",
    "https://docker.1ms.run"
  ]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

---

四、Docker 常用命令

4.1 基础命令

1. 查看 Docker 的版本命令：docker -v 和 docker version

docker -v

docker version

2. 查看 Docker 的信息命令：docker info

docker info

3. 查看 Docker 命令帮助：docker --help

docker --help

4. 查看 Docker 中某个命令的帮助信息：docker 命令 --help

docker run --help

4.2 镜像命令（对镜像进行管理）

1. 查看本地镜像库 - docker images（重点）

docker images

镜像列表表头说明：

字段	说明
REPOSITORY	镜像的仓库源
TAG	镜像标签，latest 为最新版，7.0.4 为具体版本号
IMAGE ID	镜像 ID
CREATED	镜像创建时间
SIZE	镜像大小

docker images -a   # 查看本地镜像列表（含悬空镜像 <虚悬镜像>）
docker images -q   # 只显示镜像的 ID

2. 搜索镜像命令 - docker search 镜像名

docker search hello-world

docker search --limit 1 redis

3. 拉取镜像命令 - docker pull 镜像名[:TAG]（重点）

docker pull nginx

4. 查看 Docker 资源使用情况 - docker system df

docker system df

5. 删除镜像命令 - docker rmi 镜像名|镜像ID（重点）

docker rmi mysql:latest

-f：强制删除：

docker rmi -f redis:latest

同时删除多个镜像：

docker rmi redis:7.0.4 redis:6.0.8

删除全部镜像：

# 通过镜像 ID 批量删除
docker rmi -f $(docker images -qa)
docker rmi -f `docker images -qa`
docker images -q | xargs docker rmi

# 使用镜像名:版本号进行批量删除
docker images | awk 'NR>1{print "docker rmi "$1":"$2}' | bash

6. 清理临时镜像命令（虚悬镜像）

docker image prune

清理所有悬空镜像和未被使用的镜像：

docker image prune -a

7. 创建 TAG 镜像

一般在创建本地镜像库和自定义镜像时使用。新创建的镜像是一个引用镜像，引用源镜像：

docker images

docker tag centos:7.9.2009 centos:7.9.2009-mjkk

docker images

新创建的镜像除了 REPOSITORY 和 TAG 与以前的镜像不同，其他都一样，特别是 IMAGE ID。

新建的镜像引用源镜像，等同于对源镜像创建了一个软链接。

8. 镜像保存和导入（重点）

镜像保存：指将镜像打包压缩为 tar 或 tar.gz 文件：

docker save nginx:alpine -o nginx_alpine.tar.gz

注意：保存时如果使用镜像的 ID 保存，在导入后，镜像名和版本号为空。所以要使用 镜像名:版本号 保存。

镜像导入：指将保存好的镜像文件上传到其他主机节点并导入到本地镜像库中。上传到 192.168.234.11 主机：

scp nginx_alpine.tar.gz root@192.168.234.11:~/

docker load -i nginx_alpine.tar.gz

导入使用"镜像名:版本号"保存的镜像：

docker load -i redis_latest.tar.gz

docker images

导入使用"ID"保存的镜像：

docker load -i redis_latest1.tar.gz

docker images

批量保存镜像（保存本地所有镜像）：

docker images | awk 'NR>1{print "docker save",$1":"$2,"-o",$1"-"$2".tar.gz"}' | bash

批量导入镜像：

ll images | awk 'NR>1{print "docker load -i "$NF}' | bash

9. 查看镜像的详细信息 - docker image inspect 镜像名|镜像ID

docker image inspect centos:7.9.2009

docker image inspect eeb6ee3f44bd

输出示例：

[
   {
       "Id": "sha256:eeb6ee3f44bd0b5103bb561b4c16bcb82328cfe5809ab675bb17ab3a16c517c9",
       "RepoTags": [
           "centos:7.9.2009",
           "centos:7.9.2009-mjkk",
           "mjkk-centos:7.9.2009-mjkk"
       ],
       "RepoDigests": [],

10. 构建镜像命令 - docker build

该命令会根据 Dockerfile 中定义的内容构建一个镜像。

4.3 容器命令

一个 Docker 镜像运行起来后，就成了一个 Docker 容器，一个 Docker 容器等同于 Linux 中的一个进程。

1. 运行镜像命令（重点）

命令格式：

docker run [options] imageID|imageName [command] [args....]

常用选项：

选项	作用
--name	指定容器的命名，不指定会生成一个随机名字
-i	以交互模式运行容器，通常与 -t 一起使用
-t	为容器分配一个伪虚拟终端，交互使用
-d	后台运行，并返回容器 ID
-p	指定映射端口
--rm	容器退出自动删除（一般用于测试环境）
--restart	设置容器的重启策略：--restart=always（自动重启）、--restart=unless-stopped（只有容器关闭停止时才重启）、--restart=on-failure（只有失败时才重启）
-v	挂载数据卷

运行 centos 镜像：

[root@mjkk ~]# docker run -it --name centos7.9.2009 centos:7.9.2009 bash
[root@f26a9ba4f880 /]# exit
exit
[root@mjkk ~]# docker ps -a
CONTAINER ID   IMAGE             COMMAND   CREATED        STATUS                  NAMES
f26a9ba4f880   centos:7.9.2009   "bash"    7 seconds ago  Exited (0) 1 second ago centos7.9.2009

运行 nginx 镜像并指定映射端口：

[root@mjkk ~]# docker run -p 80:80 nginx

后台运行 redis 镜像并指定映射端口：

[root@mjkk ~]# docker run -d -p 80:80 redis

2. 查看容器命令 - docker ps（重点）

命令格式：docker ps [选项]

常用选项：

选项	作用
-a	显示所有容器，包含已退出的容器（默认只显示正在运行的容器）
-q	只显示容器的 ID
-l	显示最近运行的容器
-n N	显示最近运行的几个容器
-f	过滤显示字段

查看已启动的容器列表：

[root@mjkk ~]# docker ps
CONTAINER ID   IMAGE   COMMAND                  CREATED        STATUS         PORTS                    NAMES
d6e00eec0222   nginx   "/docker-entrypoint...."   11 minutes ago Up 10 minutes  0.0.0.0:80->80/tcp, :::80->80/tcp   reverent_volhard

查看所有容器列表：

[root@mjkk ~]# docker ps -a
CONTAINER ID   IMAGE             COMMAND                CREATED        STATUS                     PORTS                             NAMES
f26a9ba4f880   centos:7.9.2009   "bash"                 3 minutes ago  Exited (0) 3 minutes ago                                        centos7.9.2009
e220b4ee39bc   redis             "docker-entrypoint.s..." 8 minutes ago  Exited (0) About a minute ago                                   recursing_archimedes
d6e00eec0222   nginx             "/docker-entrypoint...." 12 minutes ago Up 11 minutes               0.0.0.0:80->80/tcp, :::80->80/tcp   reverent_volhard
826f68308d41   nginx             "/docker-entrypoint...." 21 minutes ago Exited (0) 12 minutes ago                                       peaceful_chebyshev

只查看容器 ID：

[root@mjkk ~]# docker ps -qa
f26a9ba4f880
e220b4ee39bc
d6e00eec0222
826f68308d41

显示状态为 Exited 的容器：

[root@mjkk ~]# docker ps -a -f "status=exited"
CONTAINER ID   IMAGE             COMMAND                CREATED        STATUS                   PORTS   NAMES
f26a9ba4f880   centos:7.9.2009   "bash"                 11 minutes ago Exited (0) 11 minutes ago         centos7.9.2009
e220b4ee39bc   redis             "docker-entrypoint.s..." 16 minutes ago Exited (0) 9 minutes ago           recursing_archimedes
826f68308d41   nginx             "/docker-entrypoint...." 29 minutes ago Exited (0) 20 minutes ago          peaceful_chebyshev

-f 根据指定的字段过滤容器数据：

• exited=<int>：显示已经退出的指定退出码的容器
• label=<key> 或 label=<key>=<value>：显示具有特定标签的容器
• name=<name>：显示具有特定名称的容器
• status=<status>：显示具有特定状态的容器（例如 created、running、paused、exited）
• ancestor=<image>：显示基于指定镜像的容器

3. Docker 的两种退出机制

• 使用 exit 或 Ctrl+d 退出容器后，容器会停止
• 使用 Ctrl+p+q 退出容器后，容器不会停止

4. 容器管理命令

1. 创建容器

   命令格式：docker create 镜像ID|镜像源:TAG

   使用镜像创建容器后，该容器处于 CREATE 状态，需要通过 start 命令启动容器。

2. 启动已经停止运行的容器

   使用 docker ps -a 查看容器列表时，在 STATUS 列显示为 Exited 表示容器已停止。

   命令格式：docker start 容器ID|容器名

3. 重启容器

   命令格式：docker restart 容器ID|容器名

4. 停止容器

   命令格式：docker stop 容器ID|容器名

5. 暂停容器

   命令格式：docker pause 容器ID|容器名

6. 暂停后继续运行容器

   命令格式：docker unpause 容器ID|容器名

7. 强制停止容器

   命令格式：docker kill [-s 9] 容器ID|容器名

   -s 9 强制停止容器。

8. 删除容器

   命令格式：docker rm 容器ID|容器名

   删除容器默认只能删除已停止的容器，如果要删除正在运行的容器使用 -f 选项。

   命令格式：docker rm -f 容器ID|容器名

   删除多个容器：

   docker rm -f $(docker ps -aq)
   docker ps -qa | xargs docker rm

5. 查看容器日志命令

命令格式：docker logs 容器ID|容器名

• -n number：指定要查看的行数，后 n 行数据

[root@mjkk ~]# docker logs a78ce816f3b6
1:C 29 May 2024 03:16:58.301 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
1:C 29 May 2024 03:16:58.301 # Redis version=6.2.6, bits=64, commit=00000000, modified=0, pid=1, just started
1:C 29 May 2024 03:16:58.301 # Warning: no config file specified, using the default config. In order to specify a config file use redis-server /path/to/redis.conf
1:M 29 May 2024 03:16:58.302 * monotonic clock: POSIX clock_gettime
1:M 29 May 2024 03:16:58.304 * Running mode=standalone, port=6379.
1:M 29 May 2024 03:16:58.304 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
1:M 29 May 2024 03:16:58.304 # Server initialized
1:M 29 May 2024 03:16:58.304 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.
1:M 29 May 2024 03:16:58.305 * Ready to accept connections

6. 查看容器的详细配置信息命令

命令格式：docker inspect 容器ID|容器名

[root@mjkk ~]# docker inspect a78ce816f3b6
[
   {
       "Id": "a78ce816f3b6df3dd4db7bf785b0d04783c54e853bfb0b63ba2a593b0eb6b417",
       "Created": "2024-05-29T03:16:58.003680063Z",
       "Path": "docker-entrypoint.sh",
       ..................................................

7. 查看容器状态

命令格式：docker stats [containerID] [-a]

8. 查看某个容器的进程信息

命令格式：docker top containerID

9. 进入容器命令（重点）

当从容器退出后如果想再次进入容器中，则可以使用以下命令实现：

# 命令1
docker exec -it 容器ID|容器名 bash|/bin/bash|/bin/sh

# 命令2
docker attach 容器ID|容器名

exec 和 attach 这两个命令都可以进入容器，它们的区别如下：

	exec	attach
连接	连接到容器	连接到容器
终端	连接的时候创建终端	只能连接到已有终端，容器中要存在终端
多连接	多个 exec 连接互不影响	多个连接共享
退出	退出后容器依然运行	退出后，容器也随之退出

10. 容器到主机的复制命令（重点）

命令格式：docker cp 容器ID:容器内文件路径 目的主机路径

用于主机与容器间的文件或目录的复制。

将容器内的文件 copy 到主机：

[root@7212672ed5be /]# echo abc > abc.txt
[root@7212672ed5be /]# ls
abc.txt  bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

[root@mjkk ~]# docker cp 7212672ed5be:/abc.txt ./
Successfully copied 2.05kB to /root/./
[root@mjkk ~]# ls
abc.txt  anaconda-ks.cfg  initial-setup-ks.cfg  mysqlpackage  公共  模板  视频  图片  文档  下载  音乐  桌面

将主机上的文件 copy 到容器中：

[root@mjkk ~]# echo xyz > xyz.txt
[root@mjkk ~]# docker cp ./xyz.txt 7212672ed5be:/
Successfully copied 2.05kB to 7212672ed5be:/

[root@mjkk ~]# docker exec -it 7212672ed5be bash
[root@7212672ed5be /]# ls
abc.txt  bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var  xyz.txt

11. 容器导入导出命令（了解）

导出容器（export）：将容器的内容导出为一个 tar 文件，为容器做一个备份，方便后期导入使用：

[root@mjkk ~]# docker export 7212672ed5be > centos.bak.tar
[root@mjkk ~]# docker export 7212672ed5be -o centos.bak.tar
[root@mjkk ~]# ls
anaconda-ks.cfg  centos.bak.tar  initial-setup-ks.cfg  mysqlpackage  公共  模板  视频  图片  文档  下载  音乐  桌面

导入容器（import）：将容器导出的 tar 文件导入成一个镜像（内容和原来导出的不变）：

[root@mjkk ~]# cat centos\:2.9.2009.tar.gz | docker import mjkk/centos:7.9.2009
[root@mjkk ~]# docker import centos.bak.tar mjkk/centos:7.9.2009
sha256:881096e7c53373c9c7fafc812771379918d7e567f16244ff131d0a17a8dc05b6

[root@mjkk ~]# docker images
REPOSITORY      TAG       IMAGE ID       CREATED        SIZE
mjkk/centos 7.9.2009  881096e7c533   5 seconds ago  204MB
nginx           latest    605c77e624dd   2 years ago    141MB
redis           latest    7614ae9453d1   2 years ago    113MB
centos          7.9.2009  eeb6ee3f44bd   2 years ago    204MB
centos          latest    5d0da3dc9764   2 years ago    231MB

[root@mjkk ~]# docker run -it mjkk/centos:7.9.2009 /bin/bash
[root@99a8ef45b297 /]# ls
abc.txt  anaconda-post.log  bin  dev  etc  home  lib  lib64  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

12. commit 自定义镜像命令

使用现有的容器生成一个新的镜像。

命令格式：docker commit 容器名|容器ID 新镜像名

使用流程（步骤）：

1. 获取基础镜像
2. 运行镜像，让其成为一个可以访问的容器
3. 根据需求对容器进行修改
4. 测试完成
5. 通过 commit 命令生成一个新的镜像
6. 使用新的镜像测试
7. 测试中发现问题，手动调整，再测试

实例：修改 nginx 的默认站点，并生成一个新的镜像：

# 启动一个容器
[root@mjkk ~]# docker run -d -p 80:80 --name nginx_mjkk_v1 nginx:alpine
d0c491f7eaaa1111f6ae0464cbaf4a0778ffdebc67abee83fb1befd2f67da32a

[root@mjkk ~]# docker ps -a
CONTAINER ID   IMAGE          COMMAND                CREATED        STATUS       PORTS                              NAMES
d0c491f7eaaa   nginx:alpine   "/docker-entrypoint...." 6 seconds ago  Up 5 seconds 0.0.0.0:80->80/tcp, :::80->80/tcp  nginx_mjkk_v1

# 进入容器修改内容
[root@mjkk ~]# docker exec -it nginx_mjkk_v1 /bin/sh
/ # vi /etc/nginx/conf.d/default.conf
   server {
       listen       80;
       server_name  eluosi.mjkk.com;
       access_log   /var/log/nginx/eluosi.mjkk-access.log  main;
       error_log    /var/log/nginx/eluosi.mjkk-error.log  error;

       location / {
           root   /apps/site/eluosi;
           index  index.html index.htm;
       }
   ~
/ # mkdir -p /apps/site/eluosi
/ # cd /apps/site/eluosi/
/apps/site/eluosi # ls
eluosifangkuai.zip
/apps/site/eluosi # unzip eluosifangkuai.zip
/apps/site/eluosi # ls
eluosi.js  image  index.html  music  piao.js
/apps/site/eluosi # nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
/apps/site/eluosi # nginx -s reload
2024/05/30 12:11:55 [notice] 60#60: signal process started

# 浏览器测试修改是否成功

# 使用修改后的容器创建一个新镜像
[root@mjkk ~]# docker commit nginx_mjkk_v1 nginx:mjkk_v1
sha256:a327ddfc2636feeb95167cecc56ab8ece8ef5dd232f1ced36cbbce2f80e4dbfe

[root@mjkk ~]# docker images
REPOSITORY   TAG          IMAGE ID       CREATED        SIZE
nginx        mjkk_v1  a327ddfc2636   7 seconds ago  27.9MB

# 测试新创建的镜像

---

五、Docker 数据卷挂载

一个 Docker 容器中运行的代码、数据、配置文件都保存在容器中，如果容器被删除了，则这些数据也就随之丢失了。

我们能不能使用一种方式，让操作容器中的文件自动保存到宿主机上，同样当操作宿主机中的文件时容器也随之改变？

实现以上方式就需要使用 Docker 数据卷挂载（类似磁盘挂载或 NFS）实现，让数据持久保存到宿主机中。

命令格式：

docker run -d -p [外漏端口]:[内部端口] -v 宿主机目录或文件:容器目录或文件 镜像ID|镜像名

5.1 文件挂载

# 挂载文件
[root@mjkk default]# docker run -d -p 80:80 -v /apps/site/default/index.html:/usr/share/nginx/html/index.html nginx:alpine

# 挂载目录
[root@mjkk default]# docker run -d -p 80:80 -v /apps/site/default/:/usr/share/nginx/html/ nginx:alpine

同时挂载多个目录：

[root@mjkk nginx]# docker run -d -p 80:80 \
-v /apps/nginx/conf.d/:/etc/nginx/conf.d/ \
-v /apps/nginx/site/:/apps/nginx/site/ nginx:alpine

同时挂载多个文件和目录：

[root@docker-server ~]# docker run -d -p 81:80 --name mjkk-nginx \
> -v /apps/nginx/nginx.conf:/etc/nginx/nginx.conf \
> -v /apps/nginx/conf.d:/etc/nginx/conf.d \
> -v /apps/nginx/site:/usr/share/nginx/html \
> nginx:alpine

5.2 目录挂载

案例：使用数据卷挂载，在宿主机上完全操作容器中的 Nginx。

5.3 数据卷空间

只关注容器中数据不丢失，不关注数据具体存放的位置。

创建数据卷空间：

[root@mjkk ~]# docker volume create mjkk_data_space

数据卷空间存放位置：/var/lib/docker/volumes/mjkk_space/ 目录下。

查看数据卷空间：

[root@mjkk ~]# docker volume ls
DRIVER    VOLUME NAME
local     3db18a78637f10f9548c3c2d5a97cb7cbc33c280348dec588c989126e51c6d62
local     51d14e9a43d985a0a5f6f3c4fdbd10386ed0553b26e0840e3aebcc6e5a6a99ec
local     3919dbb194371f3ebf339c3669de7b436202678d1d9eb10c55698858293f2398
local     5838c7642807ae32c966ef520e67369549e2d77410660d612df88808ac43fc30
local     77608fba9fa45614be7c791189654552ee0e6c9bb6747a3dd89ad6fe87c24f00
local     a8d84b5d7564144382c9fb2eb230717405490367fb4742c731161b0ff51454a0
local     a60b5e07e4de908a23e001bf00357fcbd7007b8fc2288550ea0d5a3e92036157
local     df58087947ade98043fc2592812afe8c5bab68deccd287511beaf3e569d40fc5
local     eebc647ebcfbe50e130289c7352bade029f30b702bd3babbc2d16baa9cb81c62
local     f8b963ce4238e5e8b4d5cfe3cc9ad104a8d79be9b477235bf2ca9ba2878317d9
local     mjkk_space

使用新建的数据卷空间：在 run 命令中使用 -v 指定数据卷空间，-v 空间名:挂载文件或目录：

[root@mjkk ~]# docker run -d -p 80:80 --name mjkk_data_space_test \
-v mjkk_data_space:/var/log/nginx/ nginx:alpine

---

六、自动创建镜像

当下载的镜像无法满足我们的需求时，我们就需要自定义镜像。

我们知道自定义镜像本质就是对已有的镜像进行修改，然后通过 commit 命令导出镜像即可。

但如果镜像需要经常修改，我们每次手动修改镜像、导出镜像，比较繁琐，所以就需要自动构建镜像。

自定义镜像的流程：

1. 获取基础镜像
2. 运行镜像，让其成为一个可以访问的容器
3. 根据需求对容器进行修改
4. 测试完成
5. 通过 commit 命令生成一个新的镜像
6. 使用新的镜像测试
7. 测试中发现问题，手动调整，再测试

6.1 手动创建镜像

手动创建一个基于 CentOS 的 Nginx 镜像：

1. 获取基础镜像
2. 运行镜像，让其成为一个可以访问的容器
3. 设置 yum 源（下载源）
4. 下载 nginx 软件包
5. 根据需求对容器进行修改
6. 测试完成
7. 通过 commit 命令生成一个新的镜像
8. 使用新的镜像测试
9. 测试中发现问题（没有启动项），手动调整，再测试

实现步骤：

（1）下载并运行 CentOS 镜像

（2）进入容器部署 Nginx

（3）修改 Nginx 相关配置

（4）测试

（5）将配置好的容器生成镜像

[root@mjkk ~]# docker run -d -p 80:80 --name "mjkk_nginx_centos_v1" mjkk/nginx:centOS_v1 nginx -g 'daemon off;'

6.2 使用 Dockerfile 自动创建镜像

• Dockerfile 类似脚本，它有自己的规则和语法要求。
• Dockerfile 主要用于自动创建镜像。
• 在 Dockerfile 中将创建自定义镜像的步骤按照一定的规则写入，然后通过 docker build 命令自动化生成自定义镜像。

实例：使用 Dockerfile 创建自定义镜像

镜像要求：基于 CentOS7.9.2009 系统，构建 Nginx 镜像。

手动创建实现步骤：

1. 获取并运行 CentOS7.9.2009 镜像
2. 配置 yum 源 CentOS-Base.repo、epel.repo、nginx.repo
3. 在容器中安装 Nginx：yum install -y nginx
4. 修改配置文件
5. 测试 Nginx
6. 将容器生成镜像

快速入门实例：使用 Dockerfile 实现镜像创建的自动化

前提：将 Dockerfile 中需要的相关文件准备好，并放在同一个目录中。

[root@mjkk nginx-dockerfile]# vim dockerfile

# 1.指定构建镜像的基础镜像
FROM centos:7.9.2009

# 2.添加镜像的说明信息
LABEL description="build images" author="mjkk" email="343454@qq.com"

# 3.更新yum源
# COPY复制命令
COPY CentOS-Base.repo epel.repo nginx.repo /etc/yum.repos.d/

# 4.yum安装Nginx
# RUN命令用于编写Linux命令
RUN yum install -y nginx \
        && rm -rf /tmp/* \
        && find /var/cache/ -maxdepth 1 -type d ! -name 'nginx' | awk 'NR>1{print}' | xargs rm -rf

# 5.修改nginx的默认首页文件
RUN echo "use dockerfile build image" >> /usr/share/nginx/html/index.html

# 6.用于设置镜像的启动命令
CMD ["nginx","-g","daemon off;"]

使用 Dockerfile 自动构建镜像：

[root@mjkk mjkk_centos_nginx]# docker build -t mjkk/centos:nginx_v1 .

查看并运行镜像：

[root@mjkk mjkk_centos_nginx]# docker images
REPOSITORY      TAG        IMAGE ID       CREATED        SIZE
mjkk/centos nginx_v1   9ebcd1e572c2   13 minutes ago 505MB
centos          7.9.2009   eeb6ee3f44bd   2 years ago    204MB

# 运行镜像
[root@mjkk mjkk_centos_nginx]# docker run -d -p 80:80 mjkk/centos:nginx_v1
51cbe48bae9be0e0af81bea4b798662a1cecc160beb2509c6d0f0b2a67707421

6.3 Dockerfile 中的常用指令

Dockerfile 文件中每行有两部分组成：指令 和 指令内容，在 Dockerfile 中指令使用大写表示。

指令	解释说明
FROM	指定基础镜像，Dockerfile 构建的镜像的基础镜像
LABEL	设置容器的说明信息，如描述、作者、邮箱等信息（和 MAINTAINER 相同，建议使用 LABEL）
RUN	指定镜像构建的时候需要运行的命令（多个连续的 RUN 尽量合并处理）
ENV	用于指定构建镜像要使用的变量，在创建镜像时设置的变量，该变量为镜像的环境变量
ADD	上传文件或目录，将指定的文件上传到容器中，tar 文件会自动解压
COPY	上传文件或目录，将指定的文件上传到容器中，和 ADD 不同的是 COPY 不会解压
WORKDIR	指定容器的默认工作目录
VOLUME	指定容器挂载的数据卷。1. 指定当前镜像可以将那个目录进行挂载（可以通过 -v 指定任意目录的挂载）2. 如果运行容器时，不指定挂载，则该数据卷会自动挂载到数据卷空间中（可以实现默认的持久化）。如果没有配置该选项，则默认不会进行任何挂载（不会持久化）
EXPOSE	指定镜像对外暴露的端口。1. 该端口为提醒功能，告诉使用者当前镜像中使用那个端口进行监听，但它不会自动映射 2. 在运行容器时，可以使用 -P（大 P）选项，自动映射到主机上的一个随机端口
CMD	指定这个容器启动的时候要运行的命令，指定容器的入口命令，运行镜像时默认执行该命令，命令在 run 时可以被代替
ENTRYPOINT	指定入口脚本

6.4 实例

（1）使用 Dockerfile 自动化构建基于 CentOS7.9.2009 系统的 Tomcat 镜像

[root@docker-server dockerfile-tomcat]# vim Dockerfile

# 指定基础镜像
FROM centos:7.9.2009

# 设置变量，该变量为系统的环境变量在容器中可以直接使用
ENV baseDir="/apps/tools"

# 设置JAVA_HOME的环境变量和PATH的环境变量
ENV JAVA_HOME="${baseDir}/jdk-21.0.9"
ENV PATH="${JAVA_HOME}/bin:${PATH}"

# 上传yum源文件
COPY CentOS-Base.repo epel.repo /etc/yum.repos.d/

# 创建存放jdk和tomcat的路径
RUN mkdir -p ${baseDir}

# 上传jdk和tomcat到指定路径
ADD jdk-21.0.9.tar.gz tomcat-10.1.23.tar.gz ${baseDir}

# 为catalina.sh创建一个软链接
RUN ln -s /apps/tools/tomcat-10.1.23/bin/catalina.sh /sbin/catalina

# 设置挂载数据卷
VOLUME ${baseDir}/tomcat-10.1.23/webapps
VOLUME ${baseDir}/tomcat-10.1.23/conf

# 指定对外暴露的端口信息
EXPOSE 8080

# 设置镜像的默认工作路径
WORKDIR ${baseDir}/tomcat-10.1.23/webapps

# 设置启动命令
CMD ["catalina","run"]

（2）使用 Dockerfile 自动化构建基于 ubuntu 系统的 Redis 镜像

修改 ubuntu 的安装源：将 ubuntu 系统 /etc/apt/sources.list.d/ubuntu.sources 文件中的 archive.ubuntu.com 和 security.ubuntu.com 修改为 mirrors.aliyun.com：

sed -i "s/archive.ubuntu.com/mirrors.aliyun.com/" /etc/apt/sources.list.d/ubuntu.sources
sed -i "s/security.ubuntu.com/mirrors.aliyun.com/" /etc/apt/sources.list.d/ubuntu.sources

更新软件包索引（更新后才能使用 apt 或 apt-get 安装软件包）：

apt update

完整 Dockerfile 文件：

# 将redis.tar.gz文件复制到dockerfile文件的目录中
[root@docker-server dockerfile-redis-ubuntu]# ls
dockerfile  redis-7.0.8.tar.gz

[root@docker-server dockerfile-redis-ubuntu]# vim dockerfile.back

# 指定基础镜像
FROM ubuntu:latest

# 设置变量
ENV baseDir="/apps/tools"

# 设置apt源，使用阿里提供镜像源
RUN sed -i "s/archive.ubuntu.com/mirrors.aliyun.com/" /etc/apt/sources.list.d/ubuntu.sources \
        && sed -i "s/security.ubuntu.com/mirrors.aliyun.com/" /etc/apt/sources.list.d/ubuntu.sources \
        && apt update

# 创建存储redis的路径
RUN mkdir -p ${baseDir}

# 上传redis
ADD redis-7.0.8.tar.gz ${baseDir}

# 安装redis的编译环境gcc
RUN apt install -y gcc

# 安装make软件包
RUN apt install -y make

# 进入redis的根目录，然后编译安装
RUN cd ${baseDir}/redis-7.0.8 \
        && make MALLOC=libc

# 修改redis的配置文件
RUN sed -i "s/bind 127.0.0.1/bind 0.0.0.0/" ${baseDir}/redis-7.0.8/redis.conf \
        && sed -i "s/protected-mode yes/protected-mode no/" ${baseDir}/redis-7.0.8/redis.conf

# 将redis的server启动命令和客户端启动命令创建软链接，连接文件放在/sbin/
RUN ln -s ${baseDir}/redis-7.0.8/src/redis-server /sbin/redis \
        && ln -s ${baseDir}/redis-7.0.8/src/redis-cli /sbin/redis-cli

# 指定暴露端口
EXPOSE 6379

# 设置启动命令
CMD ["redis","/apps/tools/redis-7.0.8/redis.conf"]

（3）使用 Dockerfile 自动化构建基于 CentOS7.9.2009 系统的 MySQL 镜像

（讲义原稿此处未提供具体内容）

6.5 Dockerfile 多阶段构建镜像

Docker 多阶段构建允许你在不同的阶段构建你的 Docker 镜像，每个阶段都可以使用不同的基础镜像，最终只保留你需要的构建产物。这样可以使你的最终镜像尽可能小，只包含运行你的应用程序所必需的文件。

我们在使用 Dockerfile 构建镜像时往往需要安装一些依赖软件，特别是在编译安装时需要下载安装各种依赖库，而这些软件包和依赖库只是在安装软件的过程中需要，而安装好之后并不需要。我们仅仅需要命令文件和一些相关的配置文件和目录即可。如果把这些文件都放在一个镜像中，往往让镜像变得比较大。

为了给镜像瘦身，我们可以使用多阶段构建镜像，只把最终需要的命令文件和一些相关的目录及配置文件做成一个最终的镜像即可。这样就大大减少了镜像的容量，提高资源的使用率。

在多阶段构建中 Dockerfile 文件包含多个 FROM，并为中间 FROM 定义别名，在后续的 FROM 中就可以使用这些别名来引用之前的 FROM。

实例：使用多阶段构建镜像编译安装 redis 镜像，基础镜像使用 centos7.9.2009 系统。

（1）基于 CentOS 进行分阶段构建

##########基于centos进行分阶段构建##############
[root@mjkk mjkk_centos_redis]# vim dockerfile

# 中间镜像
# AS temp为镜像起一个别名，方便后面的镜像引用
FROM centos:7.9.2009 AS temp

LABEL author="mjkk"

COPY CentOS-Base.repo epel.repo /etc/yum.repos.d/

RUN mkdir -p /apps/tools

ADD redis-7.0.4.tar /apps/tools

RUN yum install -y gcc

RUN yum install -y make

RUN cd /apps/tools/redis-7.0.4/ \
        && make MALLOC=libc

RUN cd /apps/tools/redis-7.0.4/ \
        && sed -i "s/bind 127.0.0.1 -::1/bind 0.0.0.0/" redis.conf \
        && sed -i "s/protected-mode yes/protected-mode no/" redis.conf

FROM centos:7.9.2009

RUN mkdir -p /apps/tools

# --from=temp：应用别名为temp的镜像
# 将temp镜像中/apps/tools/目录中的内容复制到当前镜像的/apps/tools/目录中
COPY --from=temp /apps/tools/ /apps/tools/

RUN ln -s /apps/tools/redis-7.0.4/ /sbin/redis-7.0.4

RUN ln -s /apps/tools/redis-7.0.4/src/redis-server /sbin/redis

EXPOSE 6379

CMD ["redis","/sbin/redis-7.0.4/redis.conf"]

（2）基于 ubuntu 分阶段构建

#####################基于ubuntu分阶段构建####################################

###################配置临时镜像#############################

# 指定基础镜像
# temp是一个别名,为临时镜像设置了一个别名,方便在其他镜像中使用
FROM ubuntu:latest as temp

# 设置变量
ENV baseDir="/apps/tools"

# 设置apt源，使用阿里提供镜像源
RUN sed -i "s/archive.ubuntu.com/mirrors.aliyun.com/" /etc/apt/sources.list.d/ubuntu.sources \
        && sed -i "s/security.ubuntu.com/mirrors.aliyun.com/" /etc/apt/sources.list.d/ubuntu.sources \
        && apt update

# 创建存储redis的路径
RUN mkdir -p ${baseDir}

# 上传redis
ADD redis-7.0.8.tar.gz ${baseDir}

# 安装redis的编译环境gcc
RUN apt install -y gcc

# 安装make软件包
RUN apt install -y make

# 进入redis的根目录，然后编译安装
RUN cd ${baseDir}/redis-7.0.8 \
        && make MALLOC=libc

# 修改redis的配置文件
RUN sed -i "s/bind 127.0.0.1/bind 0.0.0.0/" ${baseDir}/redis-7.0.8/redis.conf \
        && sed -i "s/protected-mode yes/protected-mode no/" ${baseDir}/redis-7.0.8/redis.conf

########################以上内容为临时镜像内容,目的在于安装redis#####################################
##########################以下内容为最终镜像#################################################

# 指定基础镜像
FROM ubuntu:latest

# 设置变量
ENV baseDir="/apps/tools"

# 创建存储redis的路径
RUN mkdir -p ${baseDir}

# 从临时镜像(中间)中将redis整个目录复制到当前镜像中
COPY --from=temp ${baseDir} ${baseDir}

# 将redis的server启动命令和客户端启动命令创建软链接，连接文件放在/sbin/
RUN ln -s ${baseDir}/redis-7.0.8/src/redis-server /sbin/redis \
        && ln -s ${baseDir}/redis-7.0.8/src/redis-cli /sbin/redis-cli

# 指定暴露端口
EXPOSE 6379

# 设置启动命令
CMD ["redis","/apps/tools/redis-7.0.8/redis.conf"]

（3）基于 ubuntu 和 debian 的分阶段构建

#####################基于ubuntu和debian的分阶段构建####################################

##########################配置临时镜像#######################################

# 指定基础镜像
# temp是一个别名,为临时镜像设置了一个别名,方便在其他镜像中使用
FROM ubuntu:latest as temp

# 设置变量
ENV baseDir="/apps/tools"

# 设置apt源，使用阿里提供镜像源
RUN sed -i "s/archive.ubuntu.com/mirrors.aliyun.com/" /etc/apt/sources.list.d/ubuntu.sources \
        && sed -i "s/security.ubuntu.com/mirrors.aliyun.com/" /etc/apt/sources.list.d/ubuntu.sources \
        && apt update

# 创建存储redis的路径
RUN mkdir -p ${baseDir}

# 上传redis
ADD redis-7.0.8.tar.gz ${baseDir}

# 安装redis的编译环境gcc
RUN apt install -y gcc

# 安装make软件包
RUN apt install -y make

# 进入redis的根目录，然后编译安装
RUN cd ${baseDir}/redis-7.0.8 \
        && make MALLOC=libc

# 修改redis的配置文件
RUN sed -i "s/bind 127.0.0.1/bind 0.0.0.0/" ${baseDir}/redis-7.0.8/redis.conf \
        && sed -i "s/protected-mode yes/protected-mode no/" ${baseDir}/redis-7.0.8/redis.conf

########################以上内容为临时镜像内容,目的在于安装redis#####################################
##########################以下内容为最终镜像#################################################

# 指定基础镜像
FROM debian:latest

# 设置变量
ENV baseDir="/apps/tools"

# 创建存储redis的路径
RUN mkdir -p ${baseDir}

# 从临时镜像(中间)中将redis整个目录复制到当前镜像中
COPY --from=temp ${baseDir} ${baseDir}

# 将redis的server启动命令和客户端启动命令创建软链接，连接文件放在/sbin/
RUN ln -s ${baseDir}/redis-7.0.8/src/redis-server /sbin/redis \
        && ln -s ${baseDir}/redis-7.0.8/src/redis-cli /sbin/redis-cli

# 指定暴露端口
EXPOSE 6379

# 设置启动命令
CMD ["redis","/apps/tools/redis-7.0.8/redis.conf"]

6.6 生产环境建议

建议	说明
尽量保证每个镜像功能单一	避免一个镜像中运行多个服务
选择合适的基礎镜像	不一定从头自定义镜像，可以在已有服务的镜像基础上修改（nginx、redis、tomcat......）
注释和说明	添加一定的注释和镜像属性信息（LABEL）
一定要指定版本号	定义和使用镜像时要指定版本号
尽量减少镜像层级和步骤	能合并的尽量合并，如：RUN、ADD
清理无用资源	清理临时文件、缓存、压缩包

---

七、容器互联

由于每个容器的功能要单一，也就是说一个容器只能提供一个服务，那么我们部署一个应用就需要多个服务，如 Nginx、tomcat、mysql、redis 等等。

按照容器功能单一的原则，就需要有多个容器分别运行不同的应用，要部署一个应用就需要将多个容器关联起来。这时就需要容器互联。

通过容器互联，将多个容器关联起来，如何实现互联呢？每个容器的 IP 地址是不固定的，我们没有办法使用 IP 地址将多个容器关联起来。

Docker 为我们提供了根据容器名进行地址映射的功能，也就是根据容器名可以自动将该容器名解析为容器的 IP 地址（等同于域名解析）。

我们可以使用 run --link 容器名:自由命名 的方式实现容器名自动解析。

实现步骤：

# 1.先启动tomcat容器
[root@docker-server nginx]# docker run -dit -p 8081:8080 --name mjkk-tomcat mjkk/tomcat:centos /bin/bash

# 2.启动nginx容器，在启动时设置--link tomcat容器的容器名:自定义别名
# 注意：别名不能使用"_"
[root@docker-server nginx]# docker run -d -p 81:80 \
--name mjkk-nginx \
-v /apps/nginx/nginx.conf:/etc/nginx/nginx.conf \
-v /apps/nginx/conf.d:/etc/nginx/conf.d \
-v /apps/nginx/site:/usr/share/nginx/html \
-v mjkk_data_space:/var/log/nginx \
--link mjkk-tomcat:tomcat-server nginx:alpine

案例：部署若依项目

Java 服务器需要安装 fontconfig（字体配置器）：

FROM harbor.mjkk.com/source/centos:7.9.2009

LABEL description="ruoyi-java-backed-server"

ENV JAVA_HOME=/apps/soft/jdk-23.0.2
ENV PATH=$JAVA_HOME/bin:$PATH

COPY CentOS-Base.repo epel.repo /etc/yum.repos.d/

RUN yum install -y fontconfig

RUN mkdir -p /apps/soft \
    && mkdir -p /apps/code/ruoyi

ADD jdk-23_linux-x64_bin.tar.gz /apps/soft

COPY ruoyi-admin.jar /apps/code/ruoyi

EXPOSE 8080

VOLUME /apps/code/ruoyi

CMD ["java","-jar","/apps/code/ruoyi/ruoyi-admin/target/ruoyi-admin.jar"]

---

八、容器编排工具 - Docker Compose

• Docker-compose 是 Docker 提供的容器编排工具，可以对大量的容器进行合理的编排处理。
• Docker-compose 是单机容器编排工具，如果要进行集群管理、集群容器编排则需要使用 K8S 或其他实现工具实现。
• 使用 Docker-compose 还可以解决 docker run 命令中大量繁琐的选项问题。

8.1 安装 Docker-Compose

Docker Compose 没有集成到 Docker 引擎中，需要单独安装（docker compose 在 epel 源中）：

[root@mjkk ~]# yum install -y docker-compose

查看 docker-compose 的版本信息：

[root@mjkk ~]# docker-compose -version
docker-compose version 1.18.0, build 8dd22a9

8.2 Docker-Compose 的基本使用

docker-compose 的文件格式为 yml 格式，语法要求比较严格，文件名建议使用以下几种：

• compose.yaml
• compose.yml
• docker-compose.yaml
• docker-compose.yml

实例：部署 nginx:alpine 镜像

[root@mjkk docker-compose]# vim docker-compose.yml

# 指定配置文件版本
version: "3.3"

# 配置服务实例(创建容器)
services:
  # 创建mjkk-nginx容器，该名字并不是容器名
  # 容器名由"文件所在目录_mjkk-nginx_1"
  mjkk-nginx:
    # 指定创建容器的镜像
    image: "nginx:alpine"
    # 指定映射端口，可以映射多个
    ports:
      - "81:80"

  mjkk-redis:
    image: "redis:alpine"
    ports:
      - 6379:6379

运行 docker-compose.yml 文件：

[root@mjkk docker-compose]# docker-compose up -d
Creating dockercompose_mjkk-nginx_1 ... done
Creating dockercompose_mjkk-redis_1 ... done

查看容器信息：

[root@mjkk docker-compose]# docker-compose ps
            Name                          Command               State     Ports
----------------------------------------------------------------------------------------
dockercompose_mjkk-nginx_1   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:81->80/tcp,:::81->80/tcp
dockercompose_mjkk-redis_1   docker-entrypoint.sh redis ...   Up      0.0.0.0:6379->6379/tcp,:::6379->6379/tcp

8.3 Docker-Compose 的常用指令

命令	说明
up -d	后台启动容器，等同于 docker run -d
down	关闭并删除容器
stop	关闭容器
start	启动容器
restart	重启容器
ps	查看容器
images	查看 docker-compose 管理的镜像
top	查看容器的进程信息
logs	查看容器的日志信息
rm	删除容器（容器需停止）
links	连接容器
volumes	挂载数据卷
depends_on	指定依赖容器，设置启动当前容器前需先启动那些容器

8.4 Docker 项目

项目描述：使用 Dockerfile 和 DockerCompose 实现前后端分离项目的自动化部署。

• 部署项目：RuoYi-Vue 前后端分离版
• 项目镜像：Nginx 镜像（部署前端项目）、Java 镜像（部署服务端项目）、MySQL 镜像、Redis 镜像

目录结构：

[root@docker-server ruoyi]# ls -l
drwxr-xr-x. 5 root root 231 2月  17 11:31 backend    # 服务端目录
-rw-r--r--. 1 root root 2228 2月  17 14:54 docker-compose.yml
drwxr-xr-x. 5 root root  93 2月  17 09:40 mysql      # MySQL数据库
drwxr-xr-x. 5 root root  84 2月  17 11:45 nginx      # Nginx-前端目录
drwxr-xr-x. 4 root root  54 2月  17 10:05 redis      # redis
drwxr-xr-x. 3 root root  30 2月  16 16:43 source     # 源码目录

（1）MySQL 镜像

目录结构：

[root@docker-server mysql]# ll
总用量 76
drwxrwxr-x. 2 root    root    41 2月  17 09:33 conf.d
drwxr-xr-t. 8 polkitd root  4096 2月  17 14:48 data
-rw-r--r--. 1 root    root   198 2月  16 14:50 Dockerfile
drwxr-xr-x. 2 root    root     6 2月  17 09:33 logs
-rw-r--r--. 1 root    root 68653 2月  16 14:41 ruoyi.sql

Dockerfile：

FROM harbor.mjkk.com/source/mysql:8.0.26

LABEL description="ruoyi-mysql-server"

COPY ruoyi.sql /docker-entrypoint-initdb.d/

EXPOSE 3306

VOLUME /var/lib/mysql/ /etc/mysql/conf.d/ /var/log/mysql/

注意：将多个 SQL 脚本合并到一个 SQL 脚本中，然后将这个 SQL 脚本添加到镜像的 /docker-entrypoint-initdb.d/ 目录中。

/docker-entrypoint-initdb.d/ 目录中可以存放 sql 脚本和 sh 脚本，在容器启动时会自动执行其中的脚本文件。

Dockerfile 构建镜像：

[root@mjkk ruoyi]# docker build -t mjkk/mysql:8.0.26 .

运行镜像：

[root@mjkk ruoyi]# docker run -d -p 3306:3306 --name "ruoyi_mysql_container" \
 -e MYSQL_ROOT_PASSWORD=root \
 -v /ruoyi/mysql/data:/var/lib/mysql \
 -v /ruoyi/mysql/conf:/etc/mysql/conf.d \
 -v /ruoyi/mysql/log:/var/log/mysql \
 mjkk/mysql:8.0.26

修改配置文件，解决中文乱码问题，在 /ruoyi/mysql/conf 目录下新建 mysql.cnf：

[client]
default_character_set=utf8

[mysqld]
collation_server=utf8_general_ci
character_set_server=utf8

（2）Redis 镜像

在构建之前将相关目录创建好，并从其他 redis 中将 redis.conf 文件复制到指定的目录中。

目录结构：

[root@docker-server redis]# ll
总用量 4
drwxr-xr-x. 2 polkitd root  22 2月  17 15:48 data
-rw-r--r--. 1 root    root 136 2月  16 15:02 Dockerfile
drwxr-xr-x. 2 root    root   6 2月  17 10:05 redis.conf

Dockerfile：

[root@docker-server redis]# vim Dockerfile

FROM harbor.mjkk.com/source/redis:latest

LABEL description="ruoyi-redis-server"

EXPOSE 6379

VOLUME /data /etc/redis/redis.conf

Dockerfile 构建镜像：

[root@mjkk redis]# docker build -t mjkk/redis:7.0.4 .

运行镜像：

[root@mjkk redis]# docker run -d -p 6379:6379 \
-v /ruoyi/redis/redis.conf:/etc/redis/redis.conf \
-v /ruoyi/redis/data:/data \
--name ruoyi_redis_container mjkk/redis:7.0.4 \
/etc/redis/redis.conf

（3）Java 镜像

目录结构：

[root@docker-server backend]# ll
总用量 429916
-rw-r--r--. 1 root root       19 2月  17 11:17 :
-rw-r--r--. 1 root root     2523 2月  16 19:22 CentOS-Base.repo
-rw-r--r--. 1 root root      432 2月  17 11:31 Dockerfile
-rw-r--r--. 1 root root      664 2月  16 19:22 epel.repo
-rw-r--r--. 1 root root 242739723 2月  16 19:35 jdk-23_linux-x64_bin.tar.gz
drwxr-xr-x. 2 root root       29 2月  17 14:29 ruoyi

Dockerfile：

[root@docker-server backend]# vim Dockerfile

FROM harbor.mjkk.com/source/centos:7.9.2009

LABEL description="ruoyi-java-backed-server"

ENV JAVA_HOME=/apps/soft/jdk-23.0.2
ENV PATH=$JAVA_HOME/bin:$PATH

COPY CentOS-Base.repo epel.repo /etc/yum.repos.d/

RUN yum install -y fontconfig

RUN mkdir -p /apps/soft \
    && mkdir -p /apps/code/ruoyi

ADD jdk-23_linux-x64_bin.tar.gz /apps/soft

EXPOSE 8080

VOLUME /apps/code/ruoyi

CMD ["java","-jar","/apps/code/ruoyi/ruoyi-admin.jar"]

Dockerfile 构建镜像：

[root@mjkk backend]# docker build --no-cache -t mjkk/jdk:21.0.3 .

运行镜像：

[root@mjkk backend]# docker run -d \
-v /apps/ruoyi/backend:/apps/code/ruoyi \
--link ruoyi_mysql_container:mysql_container \
--link ruoyi_redis_container:redis_container \
-p 8080:8080 \
--name ruoyi_jdk_container mjkk/jdk:21.0.3

（4）Nginx 镜像

目录结构：

[root@docker-server nginx]# ll
总用量 8
drwxr-xr-x. 2 root root  44 2月  17 14:52 conf.d
-rw-r--r--. 1 root root 166 2月  17 11:45 Dockerfile
drwxr-xr-x. 2 root root  88 2月  16 17:37 logs
-rw-r--r--. 1 root root 648 2月  16 17:16 nginx.conf
drwxr-xr-x. 4 root root 108 2月  16 17:09 ruoyi-ui

Dockerfile：

[root@docker-server nginx]# vim Dockerfile

FROM harbor.mjkk.com/source/nginx:alpine

LABEL description="ruoyi-nginx-server"

EXPOSE 80

RUN mkdir -p /data/

VOLUME /etc/nginx/conf.d/ /var/log/nginx/ /data/

Dockerfile 构建镜像：

[root@mjkk nginx]# docker build -t mjkk/nginx:1.21.5 .

运行镜像：

[root@mjkk nginx]# docker run -d -p 80:80 \
-v /apps/ruoyi/nginx/code:/apps/code/ruoyi \
-v /apps/ruoyi/nginx/conf.d:/etc/nginx/conf.d \
-v /apps/ruoyi/nginx/nginx.conf:/etc/nginx/nginx.conf \
-v /apps/ruoyi/nginx/logs:/var/log/nginx \
--link ruoyi_jdk_container:jdk_container \
--name ruoyi_nginx_container mjkk/nginx:1.21.5

（5）Docker-Compose

version: "3.3"

services:
  # MySQL容器
  ruoyi-mysql-server:
    # 使用Dockerfile文件构建镜像
    build:
      # 指定Dockerfile所在的目录
      context: mysql/
      # 指定Dockerfile文件的文件名
      dockerfile: Dockerfile
    # 配置Dockerfile生成镜像的镜像名称
    image: harbor.mjkk.com/mjkk/mysql:8.0.26
    # 设置端口映射
    ports:
      - 3306:3306
    container_name: ruoyi-mysql-container
    # 设置环境变量
    environment:
      # 设置mysql中root用户的密码
      MYSQL_ROOT_PASSWORD: root
      # 设置mysql所使用的时区
      TZ: "Asia/Shanghai"
    # 设置挂载卷
    volumes:
      - /apps/ruoyi/mysql/my.cnf:/etc/mysql/my.cnf
      - /apps/ruoyi/mysql/conf.d:/etc/mysql/conf.d
      - /apps/ruoyi/mysql/data:/var/lib/mysql
      - /apps/ruoyi/mysql/logs:/var/log/mysql
    networks:
      - ruoyi-network

  # Redis容器
  ruoyi-redis-server:
    build:
      context: redis/
      dockerfile: Dockerfile
    image: harbor.mjkk.com/mjkk/redis:7.4.2
    container_name: ruoyi-redis-container
    ports:
      - 6379:6379
    volumes:
      - /apps/ruoyi/redis/data:/data
      - /apps/ruoyi/redis/redis.conf:/etc/redis/redis.conf
    networks:
      - ruoyi-network

  ruoyi-backend-server:
    build:
      context: backend/
      dockerfile: Dockerfile
    image: harbor.mjkk.com/mjkk/backend:centos9
    container_name: ruoyi-backed-container
    ports:
      - 8080:8080
    volumes:
      - /apps/ruoyi/backend/ruoyi:/apps/code/ruoyi
    depends_on:
      - ruoyi-mysql-server
      - ruoyi-redis-server
    networks:
      - ruoyi-network

  ruoyi-nginx-server:
    build:
      context: nginx/
      dockerfile: Dockerfile
    image: harbor.mjkk.com/mjkk/nginx:alpine
    container_name: ruoyi-nginx-container
    ports:
      - 80:80
    volumes:
      - /apps/ruoyi/nginx/conf.d:/etc/nginx/conf.d
      - /apps/ruoyi/nginx/logs:/var/log/nginx
      - /apps/ruoyi/nginx/ruoyi-ui:/data
    depends_on:
      - ruoyi-backend-server
    networks:
      - ruoyi-network

# 自定义网络空间
networks:
  # 空间名称
  ruoyi-network:
    # 指定网络空间所使用的网络插件
    driver: bridge

8.5 Docker-compose 网络配置

docker-compose 网络配置允许你定义和管理多个容器之间的网络连接。

默认情况下（不指定网络空间），docker-compose 会为每个项目创建一个默认网络：

• 服务中的容器都属于该默认网络
• 服务中的容器通过容器名进行互联

[root@docker-server dockercompose]# vim docker-compose.yml

version: "3.3"

services:
  ruoyi-redis-server:
    build:
      context: /root/dockerfile/ruoyi/redis-server/
      dockerfile: dockerfile
    image: ruoyi/redis:7.0.8
    ports:
      - 6379:6379
    container_name: redis-server
    volumes:
      - /root/dockerfile/ruoyi/redis-server/data:/data

  ruoyi-mysql-server:
    build:
      context: /root/dockerfile/ruoyi/mysql-server/
      dockerfile: Dockerfile
    image: ruoyi/mysql:8.0.28
    ports:
      - 3306:3306
    container_name: mysql-server
    environment:
      MYSQL_ROOT_PASSWORD: Root@mjkk110.com
      TZ: "Asia/Shanghai"
    volumes:
      - /root/dockerfile/ruoyi/mysql-server/data:/var/lib/mysql
      - /root/dockerfile/ruoyi/mysql-server/logs:/var/log/mysql
      - /root/dockerfile/ruoyi/mysql-server/conf.d:/etc/mysql/conf.d

  ruoyi-backend-server:
    build:
      context: /root/dockerfile/ruoyi/java-server/
      dockerfile: Dockerfile
    image: ruoyi/backend:21
    ports:
      - 8080:8080
    container_name: backend-server
    depends_on:
      - ruoyi-redis-server
      - ruoyi-mysql-server

  ruoyi-nginx-server:
    build:
      context: /root/dockerfile/ruoyi/nginx-server/
      dockerfile: dockerfile
    image: ruoyi/nginx:1.28.1
    ports:
      - 80:80
    container_name: nginx-server
    volumes:
      - /root/dockerfile/ruoyi/nginx-server/ruoyi:/apps/site/ruoyi
      - /root/dockerfile/ruoyi/nginx-server/conf.d:/etc/nginx/conf.d
      - /root/dockerfile/ruoyi/nginx-server/logs:/var/log/nginx
    depends_on:
      - ruoyi-backend-server

自定义网络：

配置一个网络空间：

# 自定义网络
networks:
  # 网络名称
  ruoyi-network:
    # 驱动
    driver: bridge

容器中绑定网络：

  ruoyi-nginx-server:
    build:
      context: /root/dockerfile/ruoyi/nginx-server/
      dockerfile: dockerfile
    image: ruoyi/nginx:1.28.1
    ports:
      - 80:80
    container_name: nginx-container
    volumes:
      - /root/dockerfile/ruoyi/nginx-server/ruoyi:/apps/site/ruoyi
      - /root/dockerfile/ruoyi/nginx-server/conf.d:/etc/nginx/conf.d
      - /root/dockerfile/ruoyi/nginx-server/logs:/var/log/nginx
    depends_on:
      - ruoyi-backend-server
    # 使用容器名称关联
    networks:
      - ruoyi-network

    # 设置别名，通过别名关联
    networks:
      ruoyi-network:
        aliases:
          - nginx-server

---

九、构建 Docker 的私有仓库

应用场景：

• Docker 镜像仓库无法直接满足我们的需求
• 企业内部要定制大量镜像
• 针对不想公开的镜像
• 使用 Docker 镜像每次下载慢，想提高速度

构建私有仓库的方式：

1. 使用 registry 构建本地镜像仓库
   • 特点：使用方便，适用于小型企业网站集群，使用命令行操作
2. 使用 harbor 构建本地镜像仓库
   • 特点：企业级镜像仓库，图形化界面，使用方便，支持 Docker 和 k8s
3. 使用公有云构建私有镜像仓库
   • 特点：自主在公有云申请

9.1 使用 registry 构建本地镜像仓库

1. 环境准备

准备一台主机，做为本地仓库使用，并在主机上安装 Docker 环境。

• 主机域名：registry.mjkk.com
• 主机 IP：192.168.234.11

2. 配置 registry 本地镜像

（1）拉取 registry 镜像：

[root@mjkk ~]# docker pull registry

（2）启动 registry 镜像：

• 指定映射端口：5000:5000
• 指定挂载卷：/var/lib/registry:/var/lib/registry

[root@mjkk ~]# mkdir /var/lib/registry
[root@mjkk ~]# docker run -d --name mjkk_registry \
-p 5000:5000 \
-v /var/lib/registry:/var/lib/registry \
--restart=always registry:latest

3. 上传镜像到私有仓库

（1）在要上传的主机中配置域名解析，指定私有仓库的域名地址：

[root@mjkk ~]# vim /etc/hosts
192.168.234.11 registry.mjkk.com

（2）在要上传的主机中配置向镜像仓库上传时可以使用非安全的连接（基于 http）：

[root@mjkk ~]# vim /etc/docker/daemon.json
{
  "registry-mirrors": ["https://hmhv5tp5.mirror.aliyuncs.com"],
  "insecure-registries": ["registry.mjkk.com:5000"]
}

"insecure-registries": ["registry.mjkk.com:5000"]：设置访问指定域名和端口的连接允许使用 http 协议。

docker-registry 要求使用 https 连接。

（3）修改镜像 TAG（为镜像打上标签：镜像仓库地址/路径/名字/:版本）：

[root@mjkk ~]# docker tag mjkk/mysql:8.0.26 registry.mjkk.com:5000/mjkk/mysql:8.0.26

# registry.mjkk.com:5000：域名+端口
# mjkk/mysql：镜像名
# 8.0.26：版本号

在上传时 docker push 会根据 TAG 中的域名+端口访问镜像仓库。

（4）上传镜像到私有仓库：

[root@mjkk ~]# docker push registry.mjkk.com:5000/mjkk/mysql:8.0.26

（5）上传完成，查看仓库：

[root@mjkk ~]# curl registry.mjkk.com:5000/v2/_catalog
{"repositories":["mjkk/mysql"]}

4. 从私有仓库中下载镜像

[root@mjkk ~]# docker pull registry.mjkk.com:5000/mjkk/mysql:8.0.26

9.2 使用 harbor 构建基于 UI 界面的私有镜像仓库

下载 harbor：

• 官网：https://goharbor.io
• 进入官网可以下载最新版，也可以使用旧版本（建议），我们使用 harbor 2.3.1 版本

将下载的 harbor 解压到 /apps/tools/ 目录下，目录结构如下：

[root@mjkk harbor]# ll
总用量 618124
-rw-r--r--. 1 root root      3361 7月  19 2021 common.sh
-rw-r--r--. 1 root root 632922189 7月  19 2021 harbor.v2.3.1.tar.gz
-rw-r--r--. 1 root root      7840 7月  19 2021 harbor.yml.tmpl
-rwxr-xr-x. 1 root root      2500 7月  19 2021 install.sh
-rw-r--r--. 1 root root     11347 7月  19 2021 LICENSE
-rwxr-xr-x. 1 root root      1881 7月  19 2021 prepare

修改配置文件 harbor.yml：

[root@mjkk harbor]# vim harbor.yml

# hostname修改为自己的域名
hostname: harbor.mjkk.com

# https相关的注释掉
#https:
  # https port for harbor, default is 443
  # port: 443
  # The path of cert and key files for nginx
  # certificate: /your/certificate/path
  # private_key: /your/private/key/path

# 将harbor的登录密码设置为自己的，登录名为admin
harbor_admin_password: 123456

修改 /etc/docker/daemon.json 配置文件（使用 http 需要配置，使用 https 无需配置）：

• 设置 Docker 从指定的仓库上传或拉取镜像时不进行 TLS 验证
• 允许使用 http 方式访问指定的仓库

{
  "registry-mirrors": ["https://hmhv5tp5.mirror.aliyuncs.com"],
  "insecure-registries": ["harbor.mjkk.com"]
}

安装 harbor（安装前提：已安装 docker 和 docker-compose），执行 install.sh 进行安装：

[root@mjkk harbor]# ./install.sh

进入 harbor。

向 Harbor 私有仓库推送和拉取镜像

使用 docker push 命令推送镜像：

（1）在命令行登录到私有仓库：

[root@mjkk harbor]# docker login -u admin -p 123456 harbor.mjkk.com

WARNING! Using --password via the CLI is insecure. Use --password-stdin.
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded

（2）修改要上传的镜像的 TAG 为 域名/项目/repository[:tag]：

[root@mjkk harbor]# docker tag ubuntu:latest harbor.mjkk.com/mjkk/ubuntu:latest

（3）将本地镜像推送到镜像仓库：

[root@mjkk harbor]# docker push harbor.mjkk.com/mjkk/ubuntu:latest

从 Harbor 私有仓库中拉取镜像（docker pull）

在 UI 界面上复制拉取命令：

[root@mjkk harbor]# docker pull harbor.mjkk.com/mjkk/ubuntu:latest

---

十、总结：Docker 常用命令速查

本文档的实操命令比较多，这里将全文涉及的 Docker 常用命令整理成速查表，方便后续查阅。命令格式中 [] 表示可选参数，| 表示二选一。

10.1 安装与启动

操作	命令
安装 yum 工具包	yum install -y yum-utils
添加 Docker 官方仓库	yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
添加阿里云仓库	yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
更新 yum 缓存	yum makecache fast
安装 Docker 引擎	yum install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
启动 Docker	systemctl start docker
开机自启并启动	systemctl enable docker --now
查看版本	docker -v、docker version
查看系统信息	docker info
查看帮助	docker --help、docker 子命令 --help
卸载 Docker	yum remove docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
删除数据目录	rm -rf /var/lib/docker/

10.2 镜像操作

操作	命令
查看本地镜像	docker images
查看所有镜像（含悬空镜像）	docker images -a
只显示镜像 ID	docker images -q
搜索镜像	docker search 镜像名
拉取镜像	docker pull 镜像名[:TAG]
删除镜像	docker rmi 镜像名[:TAG]
强制删除镜像	docker rmi -f 镜像名[:TAG]
删除所有镜像	docker rmi -f $(docker images -qa)
清理悬空镜像	docker image prune
清理所有无用镜像	docker image prune -a
查看资源占用	docker system df
查看镜像详细信息	docker image inspect 镜像名
给镜像打标签	docker tag 镜像名:TAG 新镜像名:新TAG
保存镜像为文件	docker save 镜像名:TAG -o 文件.tar.gz
从文件导入镜像	docker load -i 文件.tar.gz
使用 Dockerfile 构建镜像	docker build -t 镜像名:TAG .
容器生成新镜像	`docker commit 容器名

10.3 容器操作

操作	命令
创建容器（不启动）	docker create 镜像名:TAG
运行容器（创建并启动）	docker run [选项] 镜像名[:TAG] [命令]
后台运行容器	docker run -d -p 宿主机端口:容器端口 镜像名
交互式运行容器	docker run -it 镜像名 bash
查看运行中的容器	docker ps
查看所有容器	docker ps -a
只显示容器 ID	docker ps -q
按状态过滤容器	docker ps -a -f "status=exited"
启动容器	`docker start 容器名
重启容器	`docker restart 容器名
停止容器	`docker stop 容器名
强制停止容器	`docker kill -s 9 容器名
暂停容器	`docker pause 容器名
恢复容器	`docker unpause 容器名
删除容器	`docker rm 容器名
强制删除运行中的容器	`docker rm -f 容器名
删除所有容器	docker rm -f $(docker ps -aq)
进入容器	`docker exec -it 容器名
附加到容器终端	`docker attach 容器名
查看容器日志	`docker logs -n 行数 容器名
查看容器进程	`docker top 容器名
查看容器资源占用	`docker stats [容器名
查看容器详细信息	`docker inspect 容器名
容器与主机互拷文件	docker cp 容器ID:容器内路径 主机路径 / docker cp 主机路径 容器ID:容器内路径
导出容器为文件	`docker export 容器名
导入容器文件为镜像	docker import 文件.tar 新镜像名:TAG

10.4 数据卷挂载

操作	命令
挂载目录或文件	docker run -v 宿主机目录:容器目录 镜像名
挂载多个目录	docker run -v 目录1:目录1 -v 目录2:目录2 镜像名
创建数据卷空间	docker volume create 卷名
查看数据卷空间	docker volume ls
挂载数据卷空间	docker run -v 卷名:容器目录 镜像名

10.5 Docker Compose

操作	命令
后台启动服务	docker-compose up -d
关闭并删除容器	docker-compose down
停止容器	docker-compose stop
启动容器	docker-compose start
重启容器	docker-compose restart
查看容器	docker-compose ps
查看容器日志	docker-compose logs
删除容器（需先停止）	docker-compose rm

10.6 私有仓库

操作	命令
拉取 registry 镜像	docker pull registry
启动私有仓库	docker run -d -p 5000:5000 -v /var/lib/registry:/var/lib/registry --restart=always registry
登录仓库	docker login -u 用户名 -p 密码 仓库地址
给镜像打仓库标签	docker tag 本地镜像 仓库地址:端口/项目/镜像:TAG
推送镜像	docker push 仓库地址:端口/项目/镜像:TAG
拉取仓库镜像	docker pull 仓库地址:端口/项目/镜像:TAG
查看仓库镜像列表	curl 仓库地址:5000/v2/_catalog

10.7 docker run 常用选项

选项	作用
--name 名称	指定容器名称
-i	以交互模式运行容器
-t	为容器分配伪终端
-d	后台运行容器
-p 宿主机端口:容器端口	端口映射
-v 宿主机目录:容器目录	挂载数据卷
--rm	容器退出时自动删除
--restart=always	容器退出后自动重启
--link 容器名:别名	连接其他容器（容器互联）

10.8 Dockerfile 常用指令

指令	作用
FROM	指定基础镜像
LABEL	设置镜像说明信息（作者、描述、邮箱等）
RUN	构建镜像时执行的命令
ENV	设置环境变量
ADD	上传文件/目录到容器，tar 包自动解压
COPY	上传文件/目录到容器，不自动解压
WORKDIR	设置容器默认工作目录
VOLUME	声明数据卷挂载点
EXPOSE	声明容器对外暴露的端口（提醒作用，不自动映射）
CMD	设置容器启动命令，运行时可被覆盖
ENTRYPOINT	设置容器入口脚本

10.9 常用组合命令

# 删除所有容器
docker rm -f $(docker ps -aq)

# 删除所有镜像
docker rmi -f $(docker images -qa)

# 批量保存本地所有镜像
docker images | awk 'NR>1{print "docker save",$1":"$2,"-o",$1"-"$2".tar.gz"}' | bash

# 批量导入镜像
ll images | awk 'NR>1{print "docker load -i "$NF}' | bash

# 配置镜像加速器后重启 Docker
sudo systemctl daemon-reload && sudo systemctl restart docker