本机实测：同一串命令跑起来是什么样#

本机实验为了零下载，用已有的 alpine 镜像走了同一套命令（把”nginx”换成”alpine + sleep 300”这个”会一直跑着”的命令，其余参数与流程完全一样），输出如下（本机实测，Docker Desktop 29.1.3）：

1
# ④ 创建并运行容器（-d 后台，--name 起名，最后是镜像名 + 容器里执行的命令）
2
$ docker run -d --name ch20-demo docker.m.daocloud.io/library/alpine sleep 300
3
a303f29946c2bc1f664a78b14912f4b75ab624d184e1c2d2e00bc4d98f0bc3f3
4

5
# ⑤ 查看容器
6
$ docker ps
7
NAMES       IMAGE                                 STATUS                  COMMAND
8
ch20-demo   docker.m.daocloud.io/library/alpine   Up Less than a second   "sleep 300"
9

10
# ⑧ 进容器执行命令（不用进交互界面，直接让它在容器里跑一条）
11
$ docker exec ch20-demo hostname
12
a303f29946c2                                   ← 容器里的"主机名"就是容器 ID 前 12 位
13
$ docker exec ch20-demo echo "hello from container"
14
hello from container
15

16
# 日志与详情
17
$ docker logs ch20-demo                        ← 空（sleep 不打印任何东西）
18
$ docker inspect ch20-demo（关键字段）
19
状态: running | 网络: bridge | 镜像: docker.m.daocloud.io/library/alpine
20

21
# ⑥⑦⑨ 停止 / 启动 / 删除
22
$ docker stop ch20-demo                        → ch20-demo
23
$ docker ps -a --filter name=ch20-             → ch20-demo | Exited (137) ...
24
$ docker start ch20-demo                       → ch20-demo
25
$ docker rm -f ch20-demo                       → ch20-demo（强制删除）
26
$ docker ps -a --filter name=ch20-             → （无输出，已经删干净）

这一串输出里有四个只有真敲过才知道的细节：

容器的两种状态与状态流转#

docker ps 那张表里最关键的一列是 STATUS——容器在”运行中（Up）“和”已停止（Exited）“之间来回切：

1
   docker run                  docker stop                docker start
2
   ──────────►  运行中 (Up)  ──────────►  已停止 (Exited)  ──────────►  运行中
3
                 │                                                   │
4
                 │ docker rm -f                                      │ docker rm
5
                 ▼                                                   ▼
6
              （删除，docker ps -a 也看不到了）

本机实测：五个命令各自输出什么#

1
$ docker volume create ch20-vol
2
ch20-vol                                   ← 创建成功，回显卷名
3

4
$ docker volume ls | grep ch20
5
local     ch20-vol                         ← DRIVER 是 local（本地卷）、名字 ch20-vol
6

7
$ docker volume inspect ch20-vol
8
名称: ch20-vol | 驱动: local
9
宿主机目录: /var/lib/docker/volumes/ch20-vol/_data      ← ★ 固定在这儿
10

11
$ docker volume rm ch20-vol
12
ch20-vol                                   ← 删除成功（用完就清）

docker volume inspect 这条最值得记：它把”虚拟目录”翻译成了宿主机上的真实目录 /var/lib/docker/volumes/ch20-vol/_data——这正是 PPT 第 33 页那句话”（宿主机目录固定 /var/lib/docker/volumes/xxx/_data）“的出处。也就是说：具名数据卷的宿主机目录你不用选、也选不了，Docker 统一放在这个位置；想自己指定宿主机目录，就得用后面的”本地目录挂载”。

本机实测：写文件 → 删容器 → 新容器还能读到#

这是数据卷这一节最硬的一条证据（本机实测，Docker Desktop 29.1.3）：

1
# ① 起一个容器，把数据卷 ch20-vol 挂到容器里的 /data
2
$ docker run -d --name ch20-vol-demo -v ch20-vol:/data docker.m.daocloud.io/library/alpine sleep 300
3
122ba6146c953a0b8bfdb5631dcece930cfc520276ff8e858dc096f275b2e590
4

5
# ② 在容器里往 /data 写一个文件，并当场读出来
6
$ docker exec ch20-vol-demo sh -c 'echo hello-volume > /data/test.txt; ls -l /data; cat /data/test.txt'
7
total 4
8
-rw-r--r--    1 root     root            13 Sep 29 18:09 test.txt
9
hello-volume
10

11
# ③ ★ 把容器删掉（连同它的文件系统一起没了）
12
$ docker rm -f ch20-vol-demo
13
ch20-vol-demo
14

15
# ④ 用一个全新的容器挂同一个卷，文件还在！
16
$ docker run --rm -v ch20-vol:/data docker.m.daocloud.io/library/alpine cat /data/test.txt
17
hello-volume                                ← 容器是新的，数据是旧的
18

19
$ docker volume rm ch20-vol                 ← 清理

第 ③④ 步就是”容器删了数据还在”的直接证明：docker rm -f 把容器连同它的可写层一起删了，但数据卷 ch20-vol 是独立存在的，新容器只要挂同一个卷，就能看到上次写进去的 test.txt。这也解释了为什么 MySQL 容器必须挂数据卷——不挂的话，哪天容器删了重建，数据库里的表和数据就全没了。

两种挂载的区别（PPT 第 33 页）#

第 33 页把两种挂法摆在一起对比，是这一节最该背下来的一张表：

一句话选择法：“这个目录我想自己看着、自己放文件” → 本地目录挂载；“只要留住就行、位置无所谓” → 数据卷。

一、知识回顾（读完直接做下面的实践题）#

1. “Docker 核心”的四块：常见命令 / 数据卷 / 自定义镜像 / 网络（PPT 第 22、25 页）——本篇是前两块
2. 常见命令的三块地图：镜像仓库 ↔ 本地镜像（docker pull / docker push）、本地镜像（docker images / rmi / build / save / load）、容器（run / ps / stop / start / rm / logs / exec）（PPT 第 23 页）
3. 几个命令的含义：docker ps 查看运行中的容器（-a 连已停止的一起看）、docker logs 看容器日志、docker exec 在容器里执行命令、docker rmi 删镜像（rm 删容器）、docker save/load 把镜像导出成文件/从文件导入
4. Nginx 练习的 9 条需求：搜镜像 → 拉取 → 看本地镜像列表 → 创建并运行 → 查看容器 → 停止 → 再次启动 → 进入容器 → 删除容器（PPT 第 24 页）；对应命令 docker pull nginx / docker images / docker run -d --name nginx -p 80:80 nginx / docker ps / docker stop nginx / docker start nginx / docker exec -it nginx bash / docker rm nginx
5. 容器两种状态：Up（运行中）与 Exited（已停止）；stop 停止不等于删除、start 只是把停了的再启动（不是 run），rm 才是真删（运行中的要 -f）
6. 数据卷是什么：一个虚拟目录，是容器内目录与宿主机目录之间映射的桥梁——方便操作容器内文件、方便迁移容器产生的数据（PPT 第 27、30 页）
7. 数据卷五个命令：docker volume create（创建）、ls（查看）、rm（删除指定）、inspect（看详情）、prune（清除所有未使用的）（PPT 第 28 页）
8. 挂载数据卷的语法：docker run 时用 -v 数据卷:容器内目录；数据卷不存在会自动创建，不用先 create（PPT 第 29、30 页）
9. 数据卷的宿主机位置：固定在 /var/lib/docker/volumes/<卷名>/_data（本机实测 docker volume inspect 的输出；PPT 第 33 页也写了这句）
10. 持久化的证据：容器里往挂载目录写文件 → docker rm -f 删掉容器 → 新容器挂同一个卷仍能读到文件（本机实测 hello-volume）——所以有状态的软件（MySQL）必须挂卷
11. 本地目录挂载：-v 宿主机目录或文件:容器内目录或文件，必须以 / 或 ./ 开头；-v mysql:/var/lib/mysql 会被当成”名叫 mysql 的数据卷”，-v ./mysql:/var/lib/mysql 才是”当前目录下的 mysql 目录”（PPT 第 31 页）
12. 两种挂载的区别：数据卷左边写卷名（不能以 /、./ 开头）、宿主机位置固定；本地目录左边写路径（必须 / 或 ./ 开头）、宿主机位置任意指定（PPT 第 33 页）
13. 课程 MySQL 案例的三个挂载：/root/mysql/data → /var/lib/mysql（数据目录）、/root/mysql/init → /docker-entrypoint-initdb.d（初始化脚本，容器首次启动自动执行）、/root/mysql/conf → /etc/mysql/conf.d（配置文件）（PPT 第 32 页）
14. 本机实测（Docker Desktop 29.1.3）：docker exec … hostname 得到容器 ID 前 12 位；docker stop 后状态 Exited (137)；nginx 容器 + 数据卷把默认首页换成自己的 <h1>，curl 拿到 43 字节的页面、docker logs 里有两条 200 访问记录

二、裸写题#

• 2-1 让容器里的数据在容器删掉之后还在 需求：写一组命令，证明”容器里的数据能活过容器的删除”：① 创建一个数据卷（名字自取）；② 起一个容器，把这个卷挂到容器里的某个目录；③ 往那个目录写一个文件并确认写进去了；④ 把容器删掉；⑤ 用新容器挂同一个卷，把文件内容读出来。每一步后面注明”能看到什么”。 素材：实验用最小的 alpine 镜像就够；容器要能”一直活着”才会停在那儿等你操作（可以让它跑一条 sleep 命令）。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：五步是”建卷 → 挂卷起容器 → 写文件 → 删容器 → 新容器读文件”；关键是第 ④ 步删的是容器、不是卷 二级 · 方法：docker volume create 卷名；docker run -d --name 容器名 -v 卷名:/data 镜像 sleep 300；docker exec 容器名 sh -c '…' 写文件；docker rm -f 容器名；docker run --rm -v 卷名:/data 镜像 cat /data/xxx.txt 三级 · 骨架：① docker volume ____ myvol；② docker run -d --name demo -v ____:____ 镜像 sleep 300；③ docker exec demo sh -c 'echo ____ > /data/test.txt; cat /data/test.txt'；④ docker rm -f ____；⑤ docker run --rm -v ____:/data 镜像 cat /data/____

  参考答案（做完再点开）

  1
  # ① 创建数据卷
  2
  docker volume create myvol
  3
  #    回显 myvol 就是建好了；docker volume ls 能看到它
  4
  
  5
  # ② 起容器，把卷挂到容器里的 /data（-v 数据卷:容器内目录）
  6
  docker run -d --name demo -v myvol:/data alpine sleep 300
  7
  #    sleep 300 让容器"一直活着"，方便后面进去操作
  8
  
  9
  # ③ 往挂载目录写文件并当场验证
  10
  docker exec demo sh -c 'echo hello-volume > /data/test.txt; ls -l /data; cat /data/test.txt'
  11
  #    输出里有 test.txt，cat 出来是 hello-volume
  12
  
  13
  # ④ 删掉容器（注意：删的是容器，卷 myvol 还在）
  14
  docker rm -f demo
  15
  
  16
  # ⑤ 用新容器挂同一个卷，把文件读出来
  17
  docker run --rm -v myvol:/data alpine cat /data/test.txt
  18
  #    输出 hello-volume —— 容器是新的，数据是上次写的
  19
  
  20
  # 收尾：不用了就删卷
  21
  docker volume rm myvol

  显示更多显示更少

  要点：① -v 左边是卷名（不能带 / 或 ./，带了就变成”本地目录挂载”了）；② docker rm 删容器不会删卷，卷要单独 docker volume rm；③ 这条证据的意义——MySQL 这类有状态的容器必须挂卷，否则容器重建数据就没了。

• 2-2 用 nginx 容器把”自己的页面”发布出去 需求：写一组命令，把 nginx 跑在容器里，并让浏览器访问到自己写的一行内容：① 拉取 nginx 镜像；② 起容器（后台运行、命名 nginx、把宿主机的 80 映射到容器的 80、并挂一个数据卷到 nginx 的网页目录 /usr/share/nginx/html）；③ 先访问一次看看默认页；④ 把容器里网页目录下的 index.html 换成自己的内容；⑤ 再访问确认变了；⑥ 看访问日志；⑦ 收尾（删容器、删卷）。 素材：nginx 容器里网页文件放在 /usr/share/nginx/html；宿主机上可以直接用 curl 访问 http://localhost；日志用 docker logs 看。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：起容器（带端口映射 + 数据卷）→ 访问默认页 → 改容器里网页目录的文件 → 再访问 → 看日志 → 清理 二级 · 方法：docker pull nginx；docker run -d --name nginx -p 80:80 -v html:/usr/share/nginx/html nginx；curl http://localhost；docker exec nginx sh -c 'echo "<h1>…</h1>" > /usr/share/nginx/html/index.html'；docker logs nginx；docker rm -f nginx、docker volume rm html 三级 · 骨架：① docker ____ nginx；② docker run -d --name ____ -p ____:____ -v ____:/usr/share/nginx/html nginx；③ curl http://____；④ docker exec nginx sh -c 'echo "<h1>____</h1>" > /usr/share/nginx/____/index.html'；⑤ 再 curl；⑥ docker ____ nginx；⑦ docker rm -f nginx + docker volume rm ____

  参考答案（做完再点开）

  1
  # ① 拉取 nginx 镜像
  2
  docker pull nginx
  3
  
  4
  # ② 起容器：后台、命名、80→80、数据卷挂到网页目录
  5
  docker run -d --name nginx -p 80:80 -v html:/usr/share/nginx/html nginx
  6
  #    -p 80:80        宿主机 80 → 容器 80（左外右内）
  7
  #    -v html:/usr/share/nginx/html   数据卷 html 接到容器里的网页目录
  8
  
  9
  # ③ 访问默认页
  10
  curl http://localhost
  11
  #    能看到 <title>Welcome to nginx!</title>
  12
  
  13
  # ④ 换掉容器里网页目录下的首页文件
  14
  docker exec nginx sh -c 'echo "<h1>Hello Docker + Nginx 部署成功</h1>" > /usr/share/nginx/html/index.html'
  15
  
  16
  # ⑤ 再访问：页面变成自己的了
  17
  curl http://localhost
  18
  #    <h1>Hello Docker + Nginx 部署成功</h1>
  19
  
  20
  # ⑥ 看访问日志（两次请求都记着）
  21
  docker logs nginx
  22
  #    "GET / HTTP/1.1" 200 896 …（默认页）
  23
  #    "GET / HTTP/1.1" 200 43  …（自己的页）
  24
  
  25
  # ⑦ 收尾
  26
  docker rm -f nginx
  27
  docker volume rm html

  显示更多显示更少

  要点：① 挂数据卷的意义是”这个目录接到了宿主机上”——真实部署时从宿主机侧往卷的目录里放打包好的静态资源（105 篇的 dist）就行；② 换成 nginx:alpine 这类精简镜像时里面只有 sh，docker exec -it nginx bash 会失败，用 sh；③ 容器删了以后卷还在，要单独 docker volume rm 清掉。

• 2-3 起一个 MySQL 容器，让数据、配置、初始化脚本都留在宿主机上 需求：一台 Linux 服务器（192.168.100.128，root 身份）。要求起一个 MySQL 容器，并做到三件事：① 数据库的数据文件落在宿主机 /root/mysql/data 目录里；② 放在 /root/mysql/init 里的 .sql 脚本能在容器第一次启动时自动执行；③ 自己写的配置文件放在 /root/mysql/conf 里、容器启动时能读到。请写出完整命令，并说明：这三条挂载分别对应容器里的哪个目录、为什么这里不能写成 -v mysql:/var/lib/mysql 这种形式。 素材：容器里 MySQL 的数据目录是 /var/lib/mysql、初始化脚本目录是 /docker-entrypoint-initdb.d、配置目录是 /etc/mysql/conf.d；MySQL 镜像要求的 root 密码用环境变量传；宿主机端口用 3307。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：一条 docker run，把 110 篇那四个参数和三条本地目录挂载拼起来；三条挂载的左边都是”宿主机上真实存在的目录路径” 二级 · 方法：-v /root/mysql/data:/var/lib/mysql、-v /root/mysql/init:/docker-entrypoint-initdb.d、-v /root/mysql/conf:/etc/mysql/conf.d；本地目录必须以 / 或 ./ 开头，否则会被当成数据卷名 三级 · 骨架：docker run -d --name mysql -p ____:____ -e TZ=Asia/Shanghai -e MYSQL_ROOT_PASSWORD=____ -v /root/mysql/data:____ -v /root/mysql/init:____ -v /root/mysql/conf:____ mysql:8

  参考答案（做完再点开）

  1
  # 先在宿主机上把三个目录建好，并把要用的 sql / 配置放进去
  2
  mkdir -p /root/mysql/data /root/mysql/init /root/mysql/conf
  3
  
  4
  # 起容器：四个基础参数 + 三条本地目录挂载
  5
  docker run -d \
  6
    --name mysql \
  7
    -p 3307:3306 \
  8
    -e TZ=Asia/Shanghai \
  9
    -e MYSQL_ROOT_PASSWORD=123 \
  10
    -v /root/mysql/data:/var/lib/mysql \
  11
    -v /root/mysql/init:/docker-entrypoint-initdb.d \
  12
    -v /root/mysql/conf:/etc/mysql/conf.d \
  13
    mysql:8

  三条挂载各管一件事： · /root/mysql/data → /var/lib/mysql：数据目录——建过的库表都在宿主机这个目录里，容器删了重建数据还在； · /root/mysql/init → /docker-entrypoint-initdb.d：初始化脚本——容器第一次启动时自动执行目录里的 .sql（建库建表、灌数据），之后重启不再执行； · /root/mysql/conf → /etc/mysql/conf.d：配置文件——宿主机上改 .cnf 就等于改容器里 MySQL 的配置。 为什么不能写成 -v mysql:/var/lib/mysql：-v 左边不带 / 或 ./ 开头的名字会被识别成”数据卷”，那样宿主机上的目录就变成 Docker 管的 /var/lib/docker/volumes/mysql/_data（位置固定、不归你指定）——而这里要的是”我自己指定 /root/mysql/data”。必须以 / 或 ./ 开头。 验证：docker ps 看容器在跑；用客户端连 192.168.100.128:3307（root / 123），能看到 init 里脚本建出来的库表；往 /root/mysql/conf 放一个 .cnf 再重启容器，配置生效。

• 2-4 容器的日常打理（看、停、启、进、删） 需求：服务器上有个叫 nginx 的容器，请写出下面每件事对应的命令，并说明会看到什么： ① 看它现在是不是在运行；② 它其实已经停了、想连停止状态的容器一起看；③ 把它停掉；④ 把它重新启动起来；⑤ 进到它里面去敲命令（退出来怎么办）；⑥ 看它最近打印的日志（想一直盯着新的日志输出）；⑦ 把它彻底删掉（运行中的状态直接删）。 素材：容器名是 nginx；容器里是精简镜像，只有 sh 没有 bash。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：这七件事就是”查看 → 停止 → 启动 → 进入 → 看日志 → 删除”这几条固定命令，注意 ps 加不加参数的区别、stop 与 rm 的区别 二级 · 方法：docker ps / docker ps -a；docker stop nginx；docker start nginx；docker exec -it nginx sh（exit 退出）；docker logs nginx（-f 实时跟随）；docker rm -f nginx 三级 · 骨架：① docker ____；② docker ps ____；③ docker ____ nginx；④ docker ____ nginx；⑤ docker exec -____ nginx ____；⑥ docker ____ nginx（加 ____ 实时看）；⑦ docker rm ____ nginx

  参考答案（做完再点开）

  1
  # ① 看运行中的容器（能看到 nginx 这一行、状态 Up、PORTS 列有映射）
  2
  docker ps
  3
  
  4
  # ② 连已停止的一起看（状态显示 Exited）
  5
  docker ps -a
  6
  
  7
  # ③ 停止（回显容器名；再 ps 就看不到了，但容器还在）
  8
  docker stop nginx
  9
  
  10
  # ④ 启动已停止的容器（注意不是 docker run —— run 会新建一个容器）
  11
  docker start nginx
  12
  
  13
  # ⑤ 进入容器（-i 保持输入、-t 分配终端；精简镜像用 sh，完整镜像可以 bash）
  14
  docker exec -it nginx sh
  15
  #    提示符变成容器里的样子，敲 ls、cat 都在容器里生效；exit 退出
  16
  
  17
  # ⑥ 看日志；-f 表示像 tail -f 一样持续输出新日志（Ctrl+C 退出）
  18
  docker logs nginx
  19
  docker logs -f nginx
  20
  
  21
  # ⑦ 强制删除运行中的容器（不加 -f 要先 stop）
  22
  docker rm -f nginx

  显示更多显示更少

  要点：① ps 与 ps -a 的区别（运行中 / 全部）；② stop 只是停、rm 才是删；③ start 是”把停了的再拉起来”，run 是”新建一个容器”——搞混会出现一堆重复容器；④ 删容器不会删镜像，也不会删数据卷。

三、综合题#

• 3-1 把这一节两个实验连起来做一遍，写成一份清单 需求：假设你在一台装好 Docker 的 Linux 服务器上（root 身份），要完成下面这串任务，请把它写成一份可以照着做的清单（每步：命令 + 目的 + 怎么确认成功）：

  1. 先熟悉命令：把 nginx 镜像从仓库拉到本地、看一眼本地镜像列表；
  2. 起一个 nginx 容器：后台运行、命名 nginx、宿主机的 80 映射到容器的 80，先访问一次确认默认页在；
  3. 给它挂数据卷：把这个容器的网页目录（/usr/share/nginx/html）接到一个数据卷上，把自己的页面放进去，再访问确认页面变了、日志里能看到这两次请求；
  4. 验证持久化：把 nginx 容器删掉，用新容器挂同一个数据卷，确认自己写的页面还在；
  5. 换到 MySQL：起一个 MySQL 容器，用本地目录挂载把数据目录、初始化脚本目录、配置文件目录都放到 /root/mysql/ 下面（说明为什么这三条必须用 / 开头的路径）；
  6. 收尾：说清”数据卷挂载”和”本地目录挂载”各自适合什么场景，以及 docker rm、docker volume rm、docker rmi 三条删除命令各删什么。
  提示（先自己想，实在想不出再点开）

  一级 · 思路：这份清单的骨架就是”命令练习 → nginx 起容器 → 挂卷改页面 → 删容器验证持久化 → MySQL 本地目录挂载 → 总结两种挂载”；每一步都要有一个”看得见的结果” 二级 · 方法：拉镜像 docker pull nginx；起容器 docker run -d --name nginx -p 80:80 -v html:/usr/share/nginx/html nginx；写页面 docker exec nginx sh -c 'echo … > /usr/share/nginx/html/index.html'；验证 curl http://localhost；持久化 docker rm -f nginx 后用新容器挂 -v html:/usr/share/nginx/html 再 curl；MySQL 用 -v /root/mysql/data:/var/lib/mysql 等三条 三级 · 骨架：① docker pull ____ + docker images；② docker run -d --name ____ -p ____:____ nginx + curl http://localhost；③ -v ____:/usr/share/nginx/html + docker exec … > index.html + curl + docker logs；④ docker rm -f ____ → 新容器挂同一个 ____ → curl；⑤ -v /root/mysql/____:____ ×3（必须 / 开头）；⑥ 两种挂载的区别 + 三条删除命令各删什么

  参考答案（做完再点开）

  1
  清单：从"练命令"到"两个实验"（PPT 第 22～33 页）
  2
  
  3
  【1】熟悉命令
  4
    docker pull nginx          → 逐层下载，最后 Downloaded newer image
  5
    docker images              → 列表里出现 nginx（REPOSITORY / TAG / SIZE）
  6
    顺带认识：docker push（推回仓库）、docker rmi（删镜像）、
  7
              docker save / docker load（导出成文件 / 从文件导入）
  8
  
  9
  【2】起 nginx 容器
  10
    docker run -d --name nginx -p 80:80 nginx
  11
    docker ps                  → Up、PORTS 显示 0.0.0.0:80->80/tcp
  12
    curl http://localhost      → <title>Welcome to nginx!</title>（默认页在）
  13
    说明：-d 后台、--name 命名、-p 宿主机 80 → 容器 80
  14
  
  15
  【3】挂数据卷 + 换成自己的页面
  16
    docker rm -f nginx         （先删掉上一个，或一开始起就带上 -v）
  17
    docker run -d --name nginx -p 80:80 -v html:/usr/share/nginx/html nginx
  18
    docker exec nginx sh -c 'echo "<h1>Hello Docker + Nginx 部署成功</h1>" > /usr/share/nginx/html/index.html'
  19
    curl http://localhost      → <h1>Hello Docker + Nginx 部署成功</h1>
  20
    docker logs nginx          → 两条 200：896（默认页）/ 43（自己的页）
  21
    说明：-v 数据卷:容器内目录，卷不存在会自动创建
  22
  
  23
  【4】验证"容器删了数据还在"
  24
    docker rm -f nginx
  25
    docker run --rm -v html:/usr/share/nginx/html nginx cat /usr/share/nginx/html/index.html
  26
      → 还是自己写的那行 <h1>…</h1>（新容器、旧数据）
  27
    说明：docker rm 删容器不删卷；要清掉得 docker volume rm html
  28
  
  29
  【5】MySQL：本地目录挂载
  30
    mkdir -p /root/mysql/data /root/mysql/init /root/mysql/conf
  31
    docker run -d \
  32
      --name mysql \
  33
      -p 3307:3306 \
  34
      -e TZ=Asia/Shanghai \
  35
      -e MYSQL_ROOT_PASSWORD=123 \
  36
      -v /root/mysql/data:/var/lib/mysql \
  37
      -v /root/mysql/init:/docker-entrypoint-initdb.d \
  38
      -v /root/mysql/conf:/etc/mysql/conf.d \
  39
      mysql:8
  40
    为什么必须带 / ：-v 左边**以 / 或 ./ 开头**才被当成本地目录；
  41
    写成 mysql:/var/lib/mysql 会被识别为"名叫 mysql 的数据卷"，
  42
    宿主机位置就固定成 /var/lib/docker/volumes/mysql/_data 了（不归你指定）
  43
    验证：客户端连 192.168.100.128:3307，能看到 init 脚本建出来的库表
  44
  
  45
  【6】两种挂载怎么选 + 三条删除命令
  46
    数据卷挂载   -v 卷名:容器内目录        位置固定 /var/lib/docker/volumes/xxx/_data
  47
                 → 数据要留住、不想操心路径（nginx 的 html）
  48
    本地目录挂载 -v 宿主机目录:容器内目录   位置任意指定（必须 / 或 ./ 开头）
  49
                 → 要自己指定位置、要把宿主机的文件/配置直接给容器用（MySQL 的 data/init/conf）
  50
  
  51
    docker rm 容器名        → 删容器（不删镜像、不删卷）
  52
    docker volume rm 卷名   → 删数据卷（里面的文件一起没）
  53
    docker rmi 镜像名:tag   → 删本地镜像

  显示更多显示更少

  检查点：① 每步都有”看得见的结果”（镜像列表、Up 状态、curl 的返回、日志里的两条 200）；② 第 4 步是新容器读旧数据；③ MySQL 三条挂载的左边都带 /，且能说清”不带 / 会变成卷名”；④ 收尾能分清 rm / volume rm / rmi 三条删除命令。