第 2 步：准备应用镜像、部署容器、跑起来测试（“先验证环境”）#

这一步在 PPT 里排在”改配置、打 jar”前面，读起来有点绕。把它当成”先把环境验证一遍”就顺了：课程资料里另外给了一份很小的样例应用（资料/03. jdk & jar包/：一个 app.jar、一个 Dockerfile、一份 测试url.txt），先用它走一遍”镜像 → 容器 → 浏览器能访问”这条路，确认 Docker 这边没问题；确认完，第 3～6 步再把主角换成 tlias 项目本体（资料/04. 项目部署/服务端项目/：tlias.jar + Dockerfile + 那条容器命令）。

那份 测试url.txt 里就两行，正是”跑起来测试”的落点：

1
http://192.168.100.128:8080/emps
2
http://192.168.100.128:8080/depts

容器把 8080 映射到宿主机 8080（110 篇的端口映射），所以在宿主机（或者局域网里任何一台机器）上访问 http://192.168.100.128:8080/depts 能拿到数据，就说明”应用在容器里活得好好的”。

第 3 步：改两个地址，再打 jar#

这一步是六步里最容易被跳过、又最容易出事的一步：改配置文件，然后打包。PPT 点名要改两处——数据库服务地址和 logback 日志文件存放地址。

为什么必须改？109 篇讲过同一条道理：jar 里打进去的是”打包那一刻”的配置。上个项目是在 Windows 上开发的，配置里写的是本机的数据库地址和 Windows 的日志路径；现在程序要跑在 Linux 容器里，这两样都不成立了。

那到底改成了什么？课程资料里那份成品 tlias.jar 里有答案（把它解开就能看到 BOOT-INF/classes/ 下的两个文件）：

1
# tlias.jar 里的 BOOT-INF/classes/application.yml（节选）
2
spring:
3
  datasource:
4
    url: jdbc:mysql://mysql:3306/tlias      # ← 数据库服务地址：主机名是"容器名"，端口是"容器内的端口"
5
    username: root
6
    password: 123

1
<!-- tlias.jar 里的 BOOT-INF/classes/logback.xml（节选） -->
2
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
3
    <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
4
        <!-- 日志文件输出的文件名 -->
5
        <FileNamePattern>/tlias/tlias-%d{yyyy-MM-dd}-%i.log</FileNamePattern>   <!-- ← 日志存放地址 -->
6
        <MaxHistory>30</MaxHistory>
7
        <maxFileSize>10MB</maxFileSize>
8
    </rollingPolicy>
9
</appender>

两个地址都很有意思，值得逐字读：

改完配置，在 maven 父工程上执行 package 生命周期打出 jar（和 109 篇第 68 页那一步一样，只是这次数据源指向的是容器而不是服务器上的 MySQL）。

第 4 步：写 Dockerfile（就是课程资料里那一份）#

这一步在 112 篇已经把每一行都拆过了，这里贴的是课程资料里服务端项目那份（资料/04. 项目部署/服务端项目/Dockerfile），它比 PPT 第 39 页的通用示例多了三小块东西：

1
# 使用 CentOS 7 作为基础镜像
2
FROM centos:7
3

4
# 添加 JDK 到镜像中
5
COPY jdk17.tar.gz /usr/local/
6
RUN tar -xzf /usr/local/jdk17.tar.gz -C /usr/local/ &&  rm /usr/local/jdk17.tar.gz
7

8
# 设置环境变量
9
ENV JAVA_HOME=/usr/local/jdk-17.0.10
10
ENV PATH=$JAVA_HOME/bin:$PATH
11

12
# 阿里云 OSS 的访问凭证（值换成你自己的）
13
ENV OSS_ACCESS_KEY_ID=你的AccessKeyId
14
ENV OSS_ACCESS_KEY_SECRET=你的AccessKeySecret
15

16
# 统一编码（避免容器里中文乱码）
17
ENV LANG=en_US.UTF-8
18
ENV LANGUAGE=en_US:en
19
ENV LC_ALL=en_US.UTF-8
20

21
# 创建应用目录
22
RUN mkdir -p /tlias
23
WORKDIR /tlias
24

25
# 复制应用 JAR 文件到容器
26
COPY  tlias.jar  tlias.jar
27

28
# 暴露端口
29
EXPOSE 8080
30

31
# 运行命令
32
ENTRYPOINT ["java","-jar","/tlias/tlias.jar"]

多出来的三块，以及和 PPT 第 39 页那份的区别：

（课程另外还给了一份 JDK 21 版的 Dockerfile（资料/06. JDK21版本的Dockerfile/Dockerfile）：FROM centos:7 一样，只是把 jdk 包换成 jdk21.tar.gz、JAVA_HOME 指向 jdk-21.0.1，并且多了一行 LABEL maintainer="..." 标记维护者。换 JDK 版本就是换这两处，其余结构一字不变。）

第 5 步：构建镜像#

1
docker build -t tlias:1.0 .

和 112 篇讲的一模一样：-t tlias:1.0 给镜像起名（repository，不写 tag 默认 latest），末尾的 . 是 Dockerfile 所在目录、同时是构建上下文——所以 Dockerfile、jdk17.tar.gz、tlias.jar 必须放在同一个目录里（课程资料就是这么放的）。构建完 docker images 里就能看到 tlias 这个镜像。

第 6 步：部署容器（注意 --network）#

课程资料里给的那条命令（资料/04. 项目部署/服务端项目/tlias-server容器命令.txt）是：

1
docker run -d --name tlias-server --network itheima -p 8080:8080 tlias:1.0

拆开看，多出来的那一个参数正是 112 篇网络那一节的落点：

起来之后验证三处：docker ps --filter name=tlias-server 看状态与端口映射；docker logs tlias-server 看应用启动日志（连上数据库没有、有没有报 UnknownHostException: mysql）；在浏览器/接口工具里访问 http://192.168.100.128:8080/depts 看数据出不出来。服务端的 8080 只是”调试用”地开着——真正对外的入口是下面那个 80（和 109 篇的分工一致）。

那份 nginx.conf 长什么样#

要映射进去的配置文件就是课程资料里那份（资料/04. 项目部署/前端项目/conf/nginx.conf）：

1
server {
2
    listen       80;
3
    server_name  localhost;
4
    client_max_body_size 10m;
5

6
    location / {
7
        root   /usr/share/nginx/html;         # ← 容器里的路径（不是 109 篇那种相对路径）
8
        index  index.html index.htm;
9
        try_files $uri $uri/ /index.html;
10
    }
11

12
    location ^~ /api/ {
13
        rewrite ^/api/(.*)$ /$1 break;
14
        proxy_pass http://tlias-server:8080;  # ← 容器名:容器内端口
15
    }
16
}

和 109 篇那份逐项对照，只有两处变了，而且原因都很明确：

到这儿，一次访问的路线就完整了（和 109 篇那张链路图是同一个结构，只是三种东西都变成了容器）：

浏览器 → 宿主机 80 → nginx-tlias 容器的 80 → location / 发出静态页面 → 页面请求 /api/xxx 再到 80 → location ^~ /api/ 摘掉 /api 后 proxy_pass → tlias-server 容器的 8080 → 应用连 mysql 容器的 3306 → JSON 原路返回。

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

1. 项目部署分三块（PPT 第 46 页）：服务端部署（Java 应用打成镜像）／前端部署（nginx 容器 + 静态资源）／DockerCompose（一个 yml 管住一组容器）
2. 服务端部署六步（PPT 第 47 页）：① 准备 MySQL 容器并创建 tlias 库表（已完成）② 准备 java 应用镜像、部署容器、运行测试 ③ 改配置文件（数据库服务地址、logback 日志文件存放地址）后打 jar ④ 编写 Dockerfile ⑤ 构建 Docker 镜像 ⑥ 部署 Docker 容器
3. 第 3 步改了什么：数据库地址改成 jdbc:mysql://mysql:3306/tlias（主机名写容器名、端口写容器内端口）；logback 的日志路径改成 /tlias/tlias-%d{yyyy-MM-dd}-%i.log（容器里的 /tlias，和 Dockerfile 的 WORKDIR /tlias 配套）。依据——课程那份成品 tlias.jar 里的 BOOT-INF/classes/application.yml 与 logback.xml 就是这么写的
4. 为什么非改这两处：容器里的 localhost 是容器自己（那儿没有数据库）、容器里也没有 Windows 盘符路径；不改应用根本起不来。同时记住 109 篇那条老规矩——jar 里带的是”打包那一刻”的配置
5. 服务端 Dockerfile 的关键行：FROM centos:7 → COPY jdk17.tar.gz + RUN tar ... && rm ... → ENV JAVA_HOME / ENV PATH → ENV 传 OSS 的 AK/SK → ENV LANG/LANGUAGE/LC_ALL 统一 UTF-8 编码 → RUN mkdir -p /tlias + WORKDIR /tlias → COPY tlias.jar tlias.jar → EXPOSE 8080 → ENTRYPOINT ["java","-jar","/tlias/tlias.jar"]
6. 构建与部署容器的命令：构建 docker build -t tlias:1.0 .；部署 docker run -d --name tlias-server --network itheima -p 8080:8080 tlias:1.0——--network itheima 是必须的（应用要用容器名找 mysql，nginx 要用容器名找它）
7. 前端部署（PPT 第 49 页）：新建一个 nginx 容器，设两条目录映射——-v /root/tlias-nginx/html:/usr/share/nginx/html（静态资源）与 -v /root/tlias-nginx/conf/nginx.conf:/etc/nginx/nginx.conf（配置文件，左边是文件不是目录）；资源与配置传到宿主机侧目录后再起容器；另外要 --network itheima -p 80:80
8. nginx 容器里那份 nginx.conf 与 109 篇的差别：只有两处——root 改成容器里的绝对路径 /usr/share/nginx/html；proxy_pass 改成 http://tlias-server:8080（用容器名，因为后端也是个容器）。listen 80、location /、try_files、rewrite 都没变
9. 一次访问的完整链路：浏览器 → 宿主机 80 → nginx-tlias 容器的 80 →（location / 发静态页面）→ 页面请求 /api/xxx 回到 80 → location ^~ /api/ 摘掉前缀后 proxy_pass → tlias-server 容器的 8080 → 应用连 mysql 容器的 3306 → JSON 返回
10. 手动部署的痛点（PPT 第 50 页）：手动部署繁琐（命令长、有先后顺序、容器一多就是一堆 docker run，图上列了 mysql/nginx/tlias-server/redis/mq/order-server/admin-server 七个）、不便于统一管理（日志/启停/配置都得一个个来）
11. Docker Compose 是什么（PPT 第 52 页）：通过一个单独的 docker-compose.yml 模板文件（YAML 格式）来定义一组相关联的应用容器，实现多个相互关联的 Docker 容器的快速部署
12. 项目（Project）与服务（Service）：项目＝这一个 compose 文件定义的一整套服务（管理的最小整体，默认以目录名当项目名）；服务＝项目里的一个容器（services: 下面的一项：用哪个 image、container_name 叫什么、ports/volumes/networks 怎么配）
13. docker run 参数在 yml 里的对应（PPT 第 53 页）：镜像 → image；--name → container_name；-v → volumes（写法完全一样）；--network itheima → 服务里 networks: - itheima + 顶层 networks: itheima: name: itheima；-p → ports；-d → 由 docker compose up -d 提供
14. compose 里两个特殊写法：build: { context: ., dockerfile: Dockerfile }（镜像现场构建——所以 Dockerfile 与构建原料要和 yml 同一目录）；depends_on（控制启动顺序，但不保证依赖服务”已就绪”）
15. Compose 的命令（PPT 第 55 页）：格式 docker compose [OPTIONS] [COMMAND]；Options -f（指定 compose 文件路径与名称）、-p（指定 project 名称）；Commands up（创建并启动所有 service 容器）、down（停止并移除所有容器、网络）、ps、logs、stop、start、restart、top
16. 本机实测（Compose）：docker compose up -d → 两个容器 Creating → Created → Starting → Started；docker compose ps → 都 Up；docker compose logs → 每行带 ch20-svc-a | 前缀；docker compose down → Stopped → Removing → Removed，连网络 compose-demo_default 一起删（网络名里的项目名前缀来自 compose 文件所在目录名）
17. 本轮实测边界：Compose 实测过；“真实 tlias 打包成镜像部署”没做（要 JDK17 的 Linux 安装包、mysql:8 大镜像、真实 MySQL 容器），按 PPT 写——但课程资料里的 Dockerfile、容器命令、nginx.conf、compose 文件读了原文，tlias.jar 里的两个配置文件也解出来看过

二、裸写题#

• 2-1 把后端 jar 做成镜像并跑起来，一共几步？（把整条链写出来） 需求：tlias 后端要部署到这台服务器上（Docker 已装好，MySQL 容器已经在跑）。请照着 PPT 第 47 页的六步，把从”手上只有源码工程”到”容器里跑着这个应用”这条链完整写出来： ① 起手先做什么检查？（MySQL 容器这边要准备好什么） ② 应用里有两个配置必须改，是哪两个、改成什么（写出改后的值）、为什么必须改； ③ jar 怎么来（在哪儿执行什么）； ④ Dockerfile 里要照顾到的几个特殊点（密钥、编码、目录）； ⑤ 构建镜像、部署容器的命令各是什么（部署那条要带网络参数，并说明为什么）； ⑥ 怎么验证”它真的活起来了”。 （练习文件 test_113_Compose与部署.md 的题目2-1 里给了写作区。）

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

  一级 · 思路：按”环境 → 配置 → 打包 → 镜像 → 容器 → 验证”六站走；每一站的产物是下一站的输入（配置改不完，打出来的 jar 就是废的；镜像没构建出来，容器起不来） 二级 · 方法：MySQL 容器由 docker run 起、tlias.sql 挂在初始化目录上自动建库表；两处配置是 spring.datasource.url（用容器名写地址）和 logback 的日志路径（写成容器里的目录）；打包在 maven 父工程执行 package；Dockerfile 里用 ENV 传 OSS 密钥、用三条 ENV 统一 UTF-8 编码、目录用 /tlias；构建 docker build -t tlias:1.0 .；部署 docker run -d --name tlias-server --network itheima -p 8080:8080 tlias:1.0；验证 docker ps / docker logs / 访问 http://IP:8080/depts 三级 · 骨架：① MySQL 容器 + ____ 脚本建库表；② url 改成 jdbc:mysql://____:____/tlias、logback 的 FileNamePattern 改成 ____/tlias-....log；③ 父工程 ____ → tlias.jar；④ Dockerfile：ENV OSS_ACCESS_KEY____、ENV LANG=____、WORKDIR ____；⑤ docker build -t ____ . + docker run -d --name ____ --____ itheima -p 8080:8080 ____；⑥ docker ____ / docker ____ / 浏览器 http://____:8080/depts

  参考答案（做完再点开）

  1
  【0】先确认第 1 步"已完成"的部分
  2
    · MySQL 容器在跑：docker ps 能看到 mysql 容器
  3
      （起法：docker run -d --name mysql -p 3307:3306 -e TZ=Asia/Shanghai
  4
             -e MYSQL_ROOT_PASSWORD=123 mysql:8）
  5
    · 库表由 tlias.sql 建好：把 sql 挂在 /docker-entrypoint-initdb.d 目录上，
  6
      容器第一次启动时自动执行（也可以是手动执行一遍）
  7
  
  8
  【1】改配置（第 3 步，但要在打包前完成）
  9
    ① 数据库服务地址（application.yml）：
  10
         jdbc:mysql://mysql:3306/tlias
  11
       · 主机名 mysql 是"数据库容器的容器名"（不是 IP、不是 localhost）
  12
       · 3306 是"容器内的端口"（宿主机上映射出去的是 3307）
  13
       · 账号密码与起容器时一致（root / 123）
  14
       为什么必须改：程序跑在容器里，容器里的 localhost 是它自己，连不上数据库；
  15
       而用容器名互访的前提是两个容器在同一个自定义网络里。
  16
    ② logback 日志文件存放地址（logback.xml）：
  17
         <FileNamePattern>/tlias/tlias-%d{yyyy-MM-dd}-%i.log</FileNamePattern>
  18
       · /tlias 是"容器里的应用目录"（下面 Dockerfile 里 mkdir + WORKDIR 的就是它）
  19
       为什么必须改：原来写的是 Windows 上的路径，容器（Linux）里没有那个盘
  20
  
  21
  【2】打 jar
  22
    在 maven 父工程上执行 package 生命周期 → 得到 tlias.jar
  23
    （打包前先把上面两处配置改好——jar 里带的是打包那一刻的配置）
  24
  
  25
  【3】写 Dockerfile（放到与 jdk17.tar.gz、tlias.jar 同一个目录）
  26
    FROM centos:7
  27
    COPY jdk17.tar.gz /usr/local/
  28
    RUN tar -xzf /usr/local/jdk17.tar.gz -C /usr/local/ && rm /usr/local/jdk17.tar.gz
  29
    ENV JAVA_HOME=/usr/local/jdk-17.0.10
  30
    ENV PATH=$JAVA_HOME/bin:$PATH
  31
    ENV OSS_ACCESS_KEY_ID=你的AccessKeyId          # 密钥不能打进 jar
  32
    ENV OSS_ACCESS_KEY_SECRET=你的AccessKeySecret
  33
    ENV LANG=en_US.UTF-8                            # 统一编码，防中文乱码
  34
    ENV LANGUAGE=en_US:en
  35
    ENV LC_ALL=en_US.UTF-8
  36
    RUN mkdir -p /tlias
  37
    WORKDIR /tlias
  38
    COPY tlias.jar tlias.jar
  39
    EXPOSE 8080
  40
    ENTRYPOINT ["java","-jar","/tlias/tlias.jar"]
  41
  
  42
  【4】构建镜像
  43
    docker build -t tlias:1.0 .
  44
    确认：docker images tlias 能看到 tlias:1.0
  45
  
  46
  【5】部署容器（注意 --network）
  47
    docker run -d --name tlias-server --network itheima -p 8080:8080 tlias:1.0
  48
    为什么要 --network itheima：
  49
      · 应用配置里用容器名 mysql 找数据库 → 必须在同一个自定义网络里才解析得了
  50
      · 后面 nginx 要用容器名 tlias-server 找它 → 也得在同一个网络里
  51
  
  52
  【6】验证
  53
    docker ps --filter name=tlias-server        看状态与端口映射
  54
    docker logs tlias-server                    看启动日志（连库成功没有）
  55
    http://192.168.100.128:8080/depts           宿主机上直接访问，能拿到数据
  56
    失败时先看：日志里是不是 UnknownHostException: mysql（网络没接上）

  显示更多显示更少

  检查点：① 两处配置改成了”容器名 + 容器内端口”和”容器内目录”；② 说清”为什么必须改”；③ Dockerfile 有密钥与编码那两组 ENV、目录用 /tlias；④ 构建命令的 -t 与 . 都对；⑤ 部署命令带 --network itheima 并且能解释原因；⑥ 验证用了 docker ps + docker logs + 实际访问。

• 2-2 用 compose 一次拉起 mysql + 应用（写 yml） 需求：请写一份 docker-compose.yml，把下面两个服务一次拉起：

  • mysql：用 mysql:8 镜像，容器名 mysql，宿主机 3307 映射到容器 3306，环境变量 TZ=Asia/Shanghai、MYSQL_ROOT_PASSWORD=123，把宿主机的 /usr/local/app/mysql/data、/usr/local/app/mysql/init、/usr/local/app/mysql/conf 分别挂到容器里的数据目录、初始化目录、配置目录；
  • 应用：镜像要现场构建（构建上下文是当前目录、用当前目录下的 Dockerfile），容器名 tlias-server，8080 映射 8080，启动顺序要在 mysql 之后；
  • 两个服务放进同一个自定义网络，网络真实名字就叫 itheima。 写完后再回答两个小问题：build 那段为什么要求 Dockerfile 和 yml 在同一目录？depends_on 能保证”mysql 已经能连了”吗？ （练习文件 test_113_docker-compose.yml 里给了完整的写作区。）
  提示（先自己想，实在想不出再点开）

  一级 · 思路：把”两条 docker run”翻译成 yml——最外层 services:，每个服务一项；-e → environment、-v → volumes、-p → ports、--name → container_name、--network → networks（网络还要在文件顶层声明一次） 二级 · 方法：镜像用 image:；自己构建用 build: 下的 context 与 dockerfile；启动顺序用 depends_on；网络在顶层写 networks: 网络key: name: itheima；列表项用 - 开头 三级 · 骨架：services: → mysql:（image: ____ / container_name: ____ / ports: - "____:____" / environment: / volumes: - "____:/var/lib/mysql" / networks: - ____）→ tlias:（build: context: ____ / dockerfile: ____ / container_name: ____ / ports: / networks: / depends_on: - ____）→ 顶层 networks: ____: name: ____

  参考答案（做完再点开）

  1
  services:
  2
    mysql:
  3
      image: mysql:8
  4
      container_name: mysql
  5
      ports:
  6
        - "3307:3306"
  7
      environment:
  8
        TZ: Asia/Shanghai
  9
        MYSQL_ROOT_PASSWORD: 123
  10
      volumes:
  11
        - "/usr/local/app/mysql/data:/var/lib/mysql"
  12
        - "/usr/local/app/mysql/init:/docker-entrypoint-initdb.d"
  13
        - "/usr/local/app/mysql/conf:/etc/mysql/conf.d"
  14
      networks:
  15
        - tlias-net
  16
    tlias:
  17
      build:
  18
        context: .
  19
        dockerfile: Dockerfile
  20
      container_name: tlias-server
  21
      ports:
  22
        - "8080:8080"
  23
      depends_on:
  24
        - mysql
  25
      networks:
  26
        - tlias-net
  27
  networks:
  28
    tlias-net:
  29
      name: itheima

  显示更多显示更少

  两个小问题： ① build 里的 context: . 指的是 compose 文件所在的那个目录，Docker 会在这个目录里执行构建；而 Dockerfile 里的 COPY jdk17.tar.gz / COPY tlias.jar 只能拷到这个目录里的文件——所以三样东西必须放一起。 ② 不能。depends_on 只控制启动顺序（先起 mysql，再起 tlias），它不知道 mysql 里面”初始化完了没有、能不能接受连接”；应用启动太快时仍可能连不上（要可靠就配 healthcheck 之类的健康检查）。 检查点：① 两个服务都在 services: 下、缩进正确；② -v 的三条左右两边都写全（左宿主机绝对路径）；③ build 用 context + dockerfile；④ depends_on 写在应用服务里；⑤ 网络在服务里引用 + 顶层声明 name: itheima；⑥ 两个小问题答对。

• 2-3 部署前端：新建一个 nginx 容器把页面发出去 需求：前端打包好的静态资源（index.html、assets/、favicon.ico）和一份改好的 nginx.conf 都在你本机，要部署到服务器上，让浏览器访问服务器 IP（80）能看到页面、并且页面里的 /api/xxx 请求能打到后端容器 tlias-server（8080）。请写出： ① 容器怎么起（完整命令：容器名、两条映射分别是什么、网络、端口、镜像）； ② 两条映射分别解决什么问题（一条是目录、一条是文件，说清各自的作用与必要性）； ③ 资源与配置什么时候传、传到哪； ④ nginx.conf 里 location / 和 location ^~ /api/ 两段该怎么写（重点是那两个”和 109 篇不一样的地方”）；⑤ 怎么验证”页面出来了”和”接口也通了”。 （练习文件 test_113_Compose与部署.md 的题目2-3 里给了写作区。）

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

  一级 · 思路：nginx 容器要”看到”两样东西才能干活——发给用户的页面（静态资源目录）和它自己的配置（nginx.conf）；所以要用两条挂在容器上的映射，把它们都指向宿主机上你实际放文件的目录 二级 · 方法：起容器 docker run -d --name nginx-tlias -v 宿主机html目录:/usr/share/nginx/html -v 宿主机nginx.conf:/etc/nginx/nginx.conf --network itheima -p 80:80 nginx:1.20.2；资源传到宿主机侧 html 目录、配置文件放到宿主机侧那一条路径；nginx.conf 里 root 写容器里的绝对路径、proxy_pass 写 http://tlias-server:8080；验证：访问 80 看页面、点开有数据的列表看接口 三级 · 骨架：① docker run -d --name ____ -v ____:/usr/share/nginx/html -v ____:/etc/nginx/nginx.conf --____ itheima -p ____:____ nginx:____；② 第一条映射解决 ____，第二条解决 ____（文件映射，左边是文件不是目录）；③ 先传 ____，再起容器；④ root /usr/share/nginx/html; + proxy_pass http://____:____;；⑤ 访问 http://____ 看页面，打开一个要查数据的页面看数据出不出来

  参考答案（做完再点开）

  ① 起容器的命令：

  1
  docker run -d \
  2
   --name nginx-tlias \
  3
   -v /root/tlias-nginx/html:/usr/share/nginx/html \
  4
   -v /root/tlias-nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
  5
   --network itheima \
  6
   -p 80:80 \
  7
  nginx:1.20.2

  ② 两条映射各干什么：

  • -v /root/tlias-nginx/html:/usr/share/nginx/html——目录映射：把宿主机的 html 目录接到容器里 nginx 放网页的目录上，静态资源放宿主机这边，容器里的 nginx 直接对外发（改文件不用进容器）；
  • -v /root/tlias-nginx/conf/nginx.conf:/etc/nginx/nginx.conf——文件映射（左边是文件，不是目录）：用自己写好的配置替换容器里那份默认配置，让 nginx 按我们要的规则发页面、转 /api；映射出来的好处是容器删了重建配置还在（容器自己的文件系统是即用即弃的）。 ③ 什么时候传、传到哪：起容器之后往宿主机的对应目录里传（也可以先传好再起容器，效果一样）——资源传进 /root/tlias-nginx/html（注意传的是资源”里面的文件”，别多套一层文件夹），nginx.conf 放到 /root/tlias-nginx/conf/nginx.conf。传完不用重启容器，nginx 直接读；改了配置则要让它重新加载（进容器执行 nginx -s reload，或者 docker restart nginx-tlias）。 ④ 两段 location：

  1
  location / {
  2
      root   /usr/share/nginx/html;        # 容器里的绝对路径（109 篇是相对 nginx 安装目录的 html）
  3
      index  index.html index.htm;
  4
      try_files $uri $uri/ /index.html;
  5
  }
  6
  location ^~ /api/ {
  7
      rewrite ^/api/(.*)$ /$1 break;
  8
      proxy_pass http://tlias-server:8080; # 用容器名（两个容器在同一个自定义网络里）
  9
  }

  ⑤ 怎么验证：浏览器访问 http://192.168.100.128（80 可省）——看到 tlias 的页面说明 location / 那一路通了；打开一个要查数据的页面（部门管理/员工管理），表格里有数据说明 /api 那一路（rewrite + proxy_pass 到 tlias-server:8080）也通了。页面打不开先查 80 映射与容器状态（docker ps）；页面能开但没数据，先查 nginx 容器和 tlias-server 在不在同一个网络里、proxy_pass 里的容器名对不对。

• 2-4 同一个 nginx 容器：“docker run 写法”和”compose 写法”互译 需求：下面这条命令起的是一个 nginx 容器。请： ① 把它改写成 compose 的写法（服务名叫 nginx-tlias；网络真实名字要叫 itheima）； ② 逐项说明”run 的参数”分别落到了 yml 的哪一行； ③ 回答：为什么网络要在文件顶层再声明一次？不写 name: 会怎样？ ④ 反过来：如果 yml 里加一个环境变量、又多加一个目录映射，对应的 docker run 命令会变成什么样？ （练习文件 test_113_docker-compose.yml 里给了写作区。）

  1
  docker run -d \
  2
  --name nginx-tlias \
  3
  -v /usr/local/app/html:/usr/share/nginx/html \
  4
  -v /usr/local/app/conf/nginx.conf:/etc/nginx/nginx.conf \
  5
  --network itheima \
  6
  -p 80:80 \
  7
  nginx:1.20.2

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

  一级 · 思路：把 run 的每个”开关”当成一把钥匙，去 yml 里找对应的抽屉——镜像、名字、卷、网络、端口五样，一把一把对 二级 · 方法：image: / container_name: / volumes:（列表） / networks:（列表，值写网络的 key） / ports:（列表）；顶层 networks: 声明 key 对应的真实网络名（name:）；-d 在 yml 里不需要（由 docker compose up -d 提供） 三级 · 骨架：services: → nginx-tlias: → image: "____" / container_name: ____ / volumes: - "____:____" / networks: - ____ / ports: - "____:____" → 顶层 networks: ____: name: ____

  参考答案（做完再点开）

  ① compose 写法：

  1
  services:
  2
    nginx-tlias:
  3
      image: "nginx:1.20.2"
  4
      container_name: nginx-tlias
  5
      volumes:
  6
        - "/usr/local/app/html:/usr/share/nginx/html"
  7
        - "/usr/local/app/conf/nginx.conf:/etc/nginx/nginx.conf"
  8
      networks:
  9
        - itheima
  10
      ports:
  11
        - "80:80"
  12
  networks:
  13
    itheima:
  14
      name: itheima

  ② 逐项对应：

  docker run 里	yml 里
  nginx:1.20.2	image: "nginx:1.20.2"
  --name nginx-tlias	container_name: nginx-tlias（另外服务名本身也叫 nginx-tlias）
  -v ...（两条）	volumes: 下的两条（写法完全一样，左宿主机、右容器）
  --network itheima	服务里的 networks: - itheima + 顶层 networks: itheima: name: itheima
  -p 80:80	ports: - "80:80"
  -d	不用写，由 docker compose up -d 的 -d 提供

  ③ 为什么顶层还要声明一次：服务里写的 itheima 是网络的 key（在这个文件里引用用的名字），它到底对应 Docker 里哪个网络，要在顶层说清楚。不写 name: 的话，Compose 会自动给网络加上项目名前缀（项目名默认取 compose 文件所在目录名），实测里那个自动网络就叫 compose-demo_default；课程想要的就是干干净净的 itheima（112 篇里那些容器也都在这个网络里），所以用 name: 钉死。 ④ 反过来（yml 加环境变量 + 加一条映射）：

  1
  docker run -d \
  2
   --name nginx-tlias \
  3
   -e TZ=Asia/Shanghai \
  4
   -v /usr/local/app/html:/usr/share/nginx/html \
  5
   -v /usr/local/app/conf/nginx.conf:/etc/nginx/nginx.conf \
  6
   -v /usr/local/app/logs:/var/log/nginx \
  7
   --network itheima \
  8
   -p 80:80 \
  9
  nginx:1.20.2

  （yml 那边就是多加 environment: 一项、volumes: 下多一行——两边是一一对应的，没有魔法。） 检查点：① yml 的缩进/列表写法正确；② 五样对应关系一个不漏（含 -d 由 up -d 承担）；③ 能解释”key 与真实网络名”和”项目名前缀”；④ 反写命令时 -e、-v 的位置与写法正确。

• 2-5 手动部署 vs Docker Compose：说清”痛点”和”解法” 需求：一个项目要起七个容器（mysql、nginx、tlias-server、redis、mq、order-server、admin-server）。请回答： ① 用手动方式部署，麻烦在哪儿（至少写出三条具体表现，要能对上前面的命令）； ② PPT 第 50 页给那两条结论是什么； ③ 换成 Compose 之后，上面这些麻烦分别被什么解决（对着”项目/服务”这两个概念说）； ④ 写出从”第一次部署”到”全部停掉”你会用到的 Compose 命令（含格式与常用选项），并说清 up 和 down 各自把什么建起来、删掉了什么（用本机实测的输出作证）。 （练习文件 test_113_Compose与部署.md 的题目2-5 里给了写作区。）

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

  一级 · 思路：从”命令长、顺序要记、数量多、管理散、换机器要重来”这几个角度说痛点；对应地，Compose 用一个文件把这些”命令、顺序、数量”都收进 services 里，用一套命令统一管理 二级 · 方法：手动部署的账：一条 docker run 一长串参数、谁先谁后自己记、七个容器七条命令、日志/启停要一个个来、换机器要重抄；Compose：docker-compose.yml 定义一组服务（项目 = 一整套、服务 = 一个容器），docker compose up -d 一键起、down 一键停并删容器与网络、ps/logs 统一看 三级 · 骨架：① 至少三条具体麻烦；② 两句 PPT 结论（____ / ____）；③ 对应到 ____（Project）与 ____（Service）；④ docker compose [____] [____]；up = 创建并启动所有 ____；down = 停止并移除所有 ____ 和 ____

  参考答案（做完再点开）

  ① 手动部署的麻烦（具体表现）：

  • 命令又长又多：docker run -d --name nginx-tlias -v ... -v ... --network itheima -p 80:80 nginx:1.20.2——一条命令一长串参数，七个容器就是七条，抄错一个字母就是一个坑；
  • 先后顺序要自己记：数据库要先起、应用再起、nginx 最后起（起反了就是启动报错）；
  • 想留痕还得自己加参数：日志路径、目录挂载、环境变量（比如 OSS 密钥、MYSQL_ROOT_PASSWORD）都得在命令里带对；
  • 管理是散的：看日志要一个个 docker logs、停要一个个 docker stop、删还得自己记着删网络；
  • 换台机器等于重来：这一串命令要再抄一遍。 ② PPT 第 50 页的两条结论：“手动部署 - 繁琐”、“不便于统一管理”。 ③ Compose 怎么解决：
  • “繁琐” → 那七条 docker run 变成 docker-compose.yml 里的七个服务（Service），参数各归各的字段（image/container_name/ports/volumes/networks/environment/depends_on），文件能存 Git、能改一处生效一处；
  • “不便于统一管理” → 它们同属一个项目（Project），用一套命令统一操作：docker compose up -d 一起起（顺序按 depends_on）、docker compose ps 一起看、docker compose logs 一起看日志、docker compose down 一起停并删（连网络一起）；
  • “换机器” → 把 yml 和资源拷过去，一条 up -d 重来一遍。 ④ 从部署到收工的 Compose 命令（格式 docker compose [OPTIONS] [COMMAND]）：

  1
  # 第一次部署（-f 指定文件、-p 指定项目名，默认可省）
  2
  docker compose up -d
  3
  # 看状态 / 看日志
  4
  docker compose ps
  5
  docker compose logs
  6
  # 停 / 起 / 重启（不动容器与网络）
  7
  docker compose stop
  8
  docker compose start
  9
  docker compose restart
  10
  # 全部收工：停止并移除所有容器、网络
  11
  docker compose down

  up 干的事（本机实测）：Creating → Created → Starting → Started——把服务逐个创建并启动（镜像要构建的顺手构建、网络不存在就建）； down 干的事（本机实测）：Stopped → Removing → Removed，最后还有 Network compose-demo_default Removing / Removed——容器和网络一起清掉（这也是那句”删要自己记着删网络”的对比：down 一步全包）。 检查点：① 至少三条具体麻烦且对得上命令；② 两条结论写对；③ 能落到 Project / Service 两个概念上；④ 命令格式与常用子命令齐全，up/down 各自”建什么/删什么”说得清（能引用实测输出更好）。

三、综合题#

• 3-1 用 Docker Compose 把 tlias 整套（mysql + 服务端 + 前端 nginx）一次拉起 需求：服务器上 Docker 已经装好，你手上有这几样东西：tlias.sql、后端的 jdk17.tar.gz / tlias.jar / Dockerfile、前端打包好的静态资源、改好的 nginx.conf。请按 PPT 第 54 页的三步，把”整套系统用 Compose 一次拉起”做完，并写成一份可照着做的清单：

  1. 准备资源：把哪些文件放到同一个目录里（说清”为什么服务端那三样必须同目录”）；
  2. 写 docker-compose.yml：三个服务（mysql / 服务端 / 前端 nginx）各自怎么写——镜像或构建、容器名、端口映射、挂载、环境变量、启动顺序、网络；
  3. 说清名字的约束：应用配置里的数据库地址、nginx 配置里的转发地址，分别用的哪个容器名？改了会怎样？
  4. 一次构建：写命令，并说清它一次性做了哪几件事（构建镜像 / 建网络 / 起容器 / 顺序）；
  5. 验证三个阶段：后端自己能不能用（怎么直接访问）、前端页面能不能开（访问哪儿）、数据能不能出来（点开哪个页面、背后走的是哪条链路）；
  6. 收工与重来：全停掉用什么命令、它删掉了什么；如果只想停不想删，又该用什么。
  7. 收尾复盘：把”服务端六步”和”这份 yml”之间的对应说一遍（六步里的哪几步，被 yml 里的哪几行”一句话带过”了）。
  提示（先自己想，实在想不出再点开）

  一级 · 思路：这一题就是”把前三节做过的事，全部折叠进一个 yml 文件”——资源先归位（都在一个目录）、再用三个服务把 mysql / 应用 / nginx 描述出来、最后一条 up -d 收口；验证按”后端 → 前端 → 数据”三层往外走，哪层断了就查哪层 二级 · 方法：资源目录里放 docker-compose.yml、Dockerfile、jdk17.tar.gz、tlias.jar、tlias.sql、nginx.conf、静态资源目录；三个服务分别用 image（mysql、nginx）和 build（应用）；容器名 mysql / tlias-server / nginx-tlias；网络统一 tlias-net（顶层 name: itheima）；depends_on 串起”mysql → tlias → nginx”；docker compose up -d / down / stop 三级 · 骨架：① 目录清单（说明 build.context 的范围）；② yml 三段，照 2-2 与 2-3 拼起来；③ 数据库地址写容器名 ____、nginx 转发写容器名 ____；④ docker compose ____ -d；⑤ 后端 http://____:8080/depts、前端 http://____、数据看一个要查数据的页面；⑥ docker compose ____ / docker compose ____；⑦ 六步 ↔ yml 对应表

  参考答案（做完再点开）

  1
  【1】准备资源：全部放进同一个目录（比如 /usr/local/app）
  2
    docker-compose.yml      ← 这一份是"总指挥"
  3
    Dockerfile              ← 服务端构建用
  4
    jdk17.tar.gz            ← 服务端构建用
  5
    tlias.jar               ← 服务端构建用（已改好数据库地址与日志路径并打包）
  6
    tlias.sql               ← 数据库初始化用
  7
    nginx.conf              ← 前端配置
  8
    html/                   ← 前端静态资源（index.html、assets/、favicon.ico）
  9
    为什么服务端那三样必须同目录：yml 里 build.context 指的是 yml 所在目录，
  10
    Dockerfile 里的 COPY 只能拷这个目录里的文件。
  11
  
  12
  【2】docker-compose.yml（三个服务）
  13
    services:
  14
      mysql:
  15
        image: mysql:8
  16
        container_name: mysql
  17
        ports: ["3307:3306"]
  18
        environment:
  19
          TZ: Asia/Shanghai
  20
          MYSQL_ROOT_PASSWORD: 123
  21
        volumes:
  22
          - "/usr/local/app/mysql/data:/var/lib/mysql"
  23
          - "/usr/local/app/mysql/init:/docker-entrypoint-initdb.d"   # tlias.sql 放这儿
  24
          - "/usr/local/app/mysql/conf:/etc/mysql/conf.d"
  25
        networks: [tlias-net]
  26
      tlias:
  27
        build:
  28
          context: .
  29
          dockerfile: Dockerfile
  30
        container_name: tlias-server
  31
        ports: ["8080:8080"]
  32
        networks: [tlias-net]
  33
        depends_on: [mysql]
  34
      nginx:
  35
        image: nginx:1.20.2
  36
        container_name: nginx-tlias
  37
        ports: ["80:80"]
  38
        volumes:
  39
          - "/usr/local/app/nginx/conf/nginx.conf:/etc/nginx/nginx.conf"
  40
          - "/usr/local/app/nginx/html:/usr/share/nginx/html"
  41
        depends_on: [tlias]
  42
        networks: [tlias-net]
  43
    networks:
  44
      tlias-net:
  45
        name: itheima
  46
  
  47
  【3】名字的约束（不能随手改）
  48
    · 应用配置里：jdbc:mysql://mysql:3306/tlias → 用容器名 mysql
  49
    · nginx 配置里：proxy_pass http://tlias-server:8080 → 用容器名 tlias-server
  50
    改名的后果：容器名变了，这两处配置就找不到目标
  51
    （应用连不上库 / nginx 转发 502）；要改就两边一起改。
  52
    前提：三个容器都在同一个自定义网络（itheima）里 —— 只有这样才能用容器名互访。
  53
  
  54
  【4】一次构建
  55
    docker compose up -d
  56
    它一次做了：
  57
      · 给 tlias 服务构建镜像（build 那段，等于在 context 目录里 docker build）
  58
      · 创建网络 itheima（不存在才建）
  59
      · 按 depends_on 的顺序依次创建并启动三个容器：mysql → tlias → nginx
  60
  
  61
  【5】验证三个阶段
  62
    · 后端自己：宿主机访问 http://192.168.100.128:8080/depts 能拿到 JSON
  63
      （docker logs tlias-server 看启动日志有没有报错）
  64
    · 前端页面：浏览器访问 http://192.168.100.128（80）看到 tlias 页面
  65
    · 数据出来：打开部门管理/员工管理，表格有数据
  66
      背后的链路：浏览器 → nginx 容器 80 → location / 发页面
  67
      → 页面发 /api/depts → location ^~ /api/ rewrite 摘掉 /api
  68
      → proxy_pass http://tlias-server:8080 → 应用容器
  69
      → 连 mysql 容器的 3306 → 返回 JSON
  70
  
  71
  【6】收工与重来
  72
    docker compose down      → 停止并移除所有容器 + 网络（本机实测：Stopped/Removing/Removed，
  73
                               最后 Network ... Removing/Removed）
  74
    docker compose stop      → 只停止容器，不删（下次 docker compose start 接着用）
  75
    重来：docker compose up -d（镜像/网络已存在的会复用）
  76
  
  77
  【7】复盘：服务端六步 ↔ 这份 yml 的对应
  78
    PPT 第 1 步（准备 MySQL 容器与库表）  → mysql 服务那一段（image/ports/environment/volumes）
  79
    PPT 第 2 步（准备应用镜像、跑测试）    → tlias 服务的 build 段 + up 之后 up 起容器
  80
    PPT 第 3 步（改配置、打 jar）         → 不在 yml 里：这是"构建前"要做的准备工作
  81
    PPT 第 4 步（编写 Dockerfile）        → build.dockerfile 指向的那份文件
  82
    PPT 第 5 步（构建镜像）               → up -d 时自动完成（build 段）
  83
    PPT 第 6 步（部署容器）               → up -d 时自动完成（container_name/networks/ports/depends_on）
  84
    前端那两段（目录映射 + nginx.conf）    → nginx 服务那一段的 volumes

  显示更多显示更少

  检查点：① 资源清单完整、说得出”为什么服务端三样要同目录”；② yml 三个服务字段齐全、缩进正确、网络顶层声明了 name: itheima；③ 两个容器名（mysql、tlias-server）与两处配置对得上；④ up -d 做了哪几件事说得清；⑤ 验证分三层且链路说得对（尤其 /api 那一段）；⑥ down 与 stop 的区别清楚；⑦ 六步与 yml 的对应表能列出来。