【Docker 从零到精通】：一份能真正上手的教程

Docker 从零到精通：一份能真正上手的教程

本文基于 Windows 环境撰写（Docker Desktop），所有命令和现象我都实际验证过。文末会用真实的spring-RAG项目做完整演练。

目录

1. Docker 到底是什么，解决什么问题
2. Windows 安装 Docker Desktop
3. 五个核心概念：搞懂这些后面都顺了
4. 第一批命令：跑起来你的第一个容器
5. 镜像：从哪来、怎么拉、怎么看
6. 容器：运行、停止、删除、进容器里看看
7. 端口映射：为什么 localhost:3306 能连进容器
8. 数据卷：容器删了数据还在不在
9. Dockerfile：自己打包一个镜像
10. Docker Compose：一条命令起整套环境
11. 实战：用 Docker 跑 spring-RAG 的 MySQL + Redis
12. 排错手册：90% 的问题出在这
13. 进阶：网络、资源限制、多阶段构建
14. 学习路线：从会用到精通还要学什么

1. Docker 到底是什么，解决什么问题

1.1 先讲一个真实场景

假设你要跑一个 Java 项目，需要：

• JDK 17
• MySQL 8.0
• Redis Stack（带向量搜索模块）
• Node.js 18（跑前端）

传统做法：在本机一个个装。装完能跑，过两个月：

• MySQL 密码忘了
• Redis 装的是普通版，没有 RediSearch，RAG 项目报错
• 同学电脑是 Mac，你的安装步骤对他没用
• 换电脑，从头再来

Docker 的思路是：别在操作系统上直接装软件，把软件和它需要的环境一起打包，放到一个隔离的「盒子」里跑。

这个「盒子」就是容器（Container）。

1.2 和虚拟机有什么区别

很多人第一次听 Docker 会想到虚拟机。区别大概是这样：

在 Windows 上，Docker Desktop 底层其实用了 WSL2 或 Hyper-V，但对你来说不用管这些——你只管「我要 MySQL 8.0，给我起一个」。

1.3 Docker 三个你每天都会碰的东西

记住这三个词，后面所有操作都围绕它们：

1. 镜像（Image）— 只读模板，类似「安装包」或「类」
2. 容器（Container）— 镜像跑起来后的实例，类似「进程」或「对象」
3. 仓库（Registry）— 存镜像的地方，默认是 Docker Hub

关系：docker pull mysql:8.0下载镜像 →docker run mysql:8.0从镜像创建并启动容器。

2. Windows 安装 Docker Desktop

2.1 系统要求（2024/2025 年常见配置）

• Windows 10 64位 专业版/企业版/教育版，或 Windows 11
• 建议开启WSL2（Windows Subsystem for Linux 2）
• BIOS 里开启虚拟化（Intel VT-x / AMD-V）

家庭版 Windows 也能装，但偶尔会遇到 WSL2 相关的问题，专业版省心一些。

2.2 安装步骤

1. 打开 https://www.docker.com/products/docker-desktop/
2. 下载Docker Desktop for Windows
3. 安装时如果问你是否使用 WSL2，选是（推荐）
4. 装完重启电脑（安装程序通常会提示）
5. 打开 Docker Desktop，等左下角/状态栏显示Docker Desktop is running

2.3 验证安装

打开 PowerShell 或 CMD，执行：

docker--version

正常会看到类似：

Docker version 27.x.x, build xxxxx

再执行：

docker compose version

注意：新版本是docker compose（中间有空格），老教程写的docker-compose（带横杠）是独立工具，Docker Desktop 已内置 compose 插件，用docker compose就行。

2.4 跑一个 hello-world 检验

docker run hello-world

第一次会自动从 Docker Hub 拉镜像。如果最后看到Hello from Docker!，说明安装成功。

如果这一步失败，常见原因：

• Docker Desktop 没启动（托盘图标不是 running 状态）
• 网络问题，拉不到镜像（国内可能需要配置镜像加速，后面排错章节会讲）
• 公司网络代理拦截

2.5 Docker Desktop 界面简单认识

装完不必深究，但知道这几个地方有用：

• Containers：当前运行/停止的容器列表
• Images：本地已有的镜像
• Volumes：数据卷
• Settings → Resources：可以调 Docker 占用的 CPU、内存（默认有时偏小，跑 MySQL 建议至少给 4GB 内存）

3. 五个核心概念：搞懂这些后面都顺了

3.1 镜像 Image

镜像是分层的只读文件系统。

比如mysql:8.0这个镜像里已经配好了：

• Linux 基础层
• MySQL 8.0 二进制
• 默认配置文件
• 入口脚本（container 启动时执行的逻辑）

你不需要在 Windows 上「安装 MySQL」，只需要docker run用这个镜像。

标签 tag 的含义：mysql:8.0中，mysql是仓库名，8.0是标签。latest表示该仓库默认最新版，但生产环境不建议盲目用latest，版本会变，今天能跑明天可能不行。

3.2 容器 Container

容器 = 镜像的运行实例。

特点：

• 容器之间相互隔离（有自己的文件系统、网络命名空间）
• 容器是可写的（在镜像只读层之上加一层可写层）
• 容器停止后，可写层默认还在；删除容器后，没有挂载卷的数据会丢

一个镜像可以起多个容器。比如你可以起两个 MySQL 容器，端口分别映射到 3306 和 3307。

3.3 数据卷 Volume

容器删了，里面的数据默认跟着没——这是新手踩坑第一名。

Volume（卷）是 Docker 管理的持久化存储，存在宿主机上（Windows 上实际在 WSL2 虚拟磁盘里），和容器生命周期解耦。

volumes:mysql_data:/var/lib/mysql

意思是：把容器里的/var/lib/mysql（MySQL 存数据的地方）映射到名为mysql_data的 Docker 卷。容器删了，卷还在，下次docker compose up数据还在。

3.4 端口映射 Port Mapping

容器内部有自己的网络。MySQL 在容器里监听 3306，你的 Windows 主机默认访问不到。

端口映射把「宿主机的端口」转发到「容器的端口」：

"3306:3306" ↑ ↑ 宿主机 容器内

你在本机连localhost:3306，Docker 帮你转发到 MySQL 容器里的 3306。

3.5 网络 Network

Compose 启动多个容器时，它们可以在同一个 Docker 网络里用服务名互相访问。

比如 compose 文件里服务名叫mysql，同一网络里的另一个容器可以用 hostnamemysql连接，而不需要知道 IP。

你的 spring-RAG 项目里，后端跑在 Windows 本机（不在 Docker 里），所以连localhost:3306就行，不需要服务名。

4. 第一批命令：跑起来你的第一个容器

4.1 docker run 完整结构

docker run[选项]镜像名[命令]

常用选项：

4.2 例子：临时跑一个 Redis 玩玩

docker run-d--name my-redis-p 6379:6379 redis:7

解释：

• -d：后台跑，不占用当前终端
• --name my-redis：容器名叫 my-redis，方便后面操作
• -p 6379:6379：本机 6379 → 容器 6379
• redis:7：用 Redis 7 官方镜像

测试连接（如果你有 redis-cli）：

docker exec-it my-redis redis-cliping

应返回PONG。

用完删掉：

docker stop my-redis dockerrmmy-redis

4.3 docker ps：看谁在用

# 只看运行中的dockerps# 包括已停止的dockerps-a

输出里关注：CONTAINER ID、NAMES、PORTS、STATUS。

5. 镜像：从哪来、怎么拉、怎么看

5.1 docker pull 拉镜像

docker pull mysql:8.0

会从 Docker Hub 下载到本地。下载过程按层显示，已存在的层会Already exists。

5.2 docker images 看本地镜像

docker images

REPOSITORY TAG IMAGE ID CREATED SIZE mysql 8.0 xxxxxxxxxxxx 2 weeks ago 500MB

IMAGE ID是镜像唯一标识。TAG 是给人看的版本号。

5.3 镜像命名规则

完整格式：[registry/][namespace/]repository[:tag]

• mysql:8.0→ Docker Hub 官方 mysql 仓库的 8.0 标签
• redis/redis-stack:latest→ Docker Hub 上 redis 组织下的 redis-stack 镜像

5.4 删除镜像

docker rmi mysql:8.0

如果有容器还在用这个镜像，会删失败，需要先删容器。

清理不用的镜像（慎用，会删 dangling 镜像）：

docker image prune

6. 容器：运行、停止、删除、进容器里看看

6.1 生命周期

create → start → running → stop → (remove) ↓ pause / restart

对应命令：

dockerstart容器名 docker stop 容器名# 优雅停止，发 SIGTERMdockerkill容器名# 强制杀docker restart 容器名 dockerrm容器名# 删除已停止的容器dockerrm-f 容器名# 强制删除运行中的

6.2 docker exec：进容器里执行命令

这是排错必备：

docker exec-it spring-rag-mysql bash

• exec：在运行中的容器里执行命令
• -i：交互
• -t：分配伪终端
• bash：要执行的命令（MySQL 镜像一般有 bash；Alpine 系镜像用 sh）

进去后可以：

mysql-uroot-proot123

输入exit退出容器 shell。exit 只退出 shell，不会停容器。

6.3 docker logs：看日志

docker logs spring-rag-mysql docker logs-f spring-rag-mysql# 持续跟踪，类似 tail -fdocker logs--tail 100 spring-rag-mysql

MySQL 启动失败、Redis 起不来，第一时间看 logs。

6.4 docker inspect：看详细配置

docker inspect spring-rag-mysql

输出是 JSON，信息很全。常用技巧——只看 IP：

docker inspect-f"{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}"spring-rag-mysql

日常排错 compose 网络问题时有用。

7. 端口映射：为什么 localhost:3306 能连进容器

7.1 映射格式

ports:-"3306:3306"

左边是宿主机（你的 Windows），右边是容器内。

也可以写成"3307:3306"，表示本机连 3307 端口，转发到容器 3306。适合本机已经占用了 3306 的情况。

7.2 端口冲突

如果docker compose up报：

Bind for 0.0.0.0:3306 failed: port is already allocated

说明本机 3306 已被占用。常见占用者：

• 你自己装的 MySQL 服务
• 之前没关干净的 Docker 容器

排查：

netstat-ano|findstr :3306

解决思路：

1. 停掉本机 MySQL 服务
2. 或改 compose 端口映射为3307:3306，同时改 Spring Boot 的 jdbc url

7.3 只绑定 localhost

默认0.0.0.0:3306表示所有网卡都能访问。如果只想本机访问：

ports:-"127.0.0.1:3306:3306"

教学环境一般不用特意设，但生产部署时要考虑安全。

8. 数据卷：容器删了数据还在不在

8.1 两种挂载方式

1）命名卷（Named Volume）— 推荐存数据库

volumes:-mysql_data:/var/lib/mysqlvolumes:mysql_data:

Docker 管理存储位置，跨平台省心。

2）绑定挂载（Bind Mount）— 适合配置文件、脚本

volumes:-./sql/init.sql:/docker-entrypoint-initdb.d/init.sql

把宿主机的./sql/init.sql文件挂进容器里的指定路径。

8.2 关键区别

8.3 MySQL 官方镜像的初始化机制

MySQL 官方镜像有个约定：

• 容器第一次启动时，会执行/docker-entrypoint-initdb.d/目录下的.sql、.sh文件
• 只在数据目录为空时执行一次
• 如果mysql_data卷里已经有数据，再改 init.sql 不会重新执行

这就是为什么有时候你改了init.sql，删容器再起，表没变——因为卷还在。

要重新初始化：

docker compose down-v# -v 会删卷，数据全没，慎用！docker compose up-d

8.4 查看和管理卷

docker volumelsdocker volume inspect spring-rag_mysql_data

卷名默认是{项目目录名}_{卷名}，比如目录叫spring-RAG，卷名mysql_data，实际名可能是spring-rag_mysql_data（Docker 会把名字规范化）。

9. Dockerfile：自己打包一个镜像

到目前为止我们用的都是别人做好的镜像。实际工作中你要把自己的 Java 项目也打进镜像。

9.1 Dockerfile 是什么

一个文本文件，描述「怎么组装镜像」。每一行指令产生一层。

9.2 一个最小 Java 例子

# 基础镜像：带 JDK 17 的 Linux FROM eclipse-temurin:17-jre-alpine # 工作目录 WORKDIR /app # 把打好的 jar 复制进去 COPY target/spring-rag-1.0.0.jar app.jar # 容器启动时执行的命令 ENTRYPOINT ["java", "-jar", "app.jar"] # 声明容器监听端口（文档作用，不会自动映射） EXPOSE 8080

构建：

docker build-t my-spring-rag:1.0.

运行：

docker run-d--name rag-backend-p 8080:8080 my-spring-rag:1.0

9.3 常用指令说明

9.4 多阶段构建（进阶但实用）

Java 项目不想在最终镜像里带 Maven 和源码，可以用多阶段：

# 第一阶段：编译 FROM maven:3.9-eclipse-temurin-17 AS builder WORKDIR /build COPY pom.xml . COPY src ./src RUN mvn package -DskipTests # 第二阶段：运行 FROM eclipse-temurin:17-jre-alpine WORKDIR /app COPY --from=builder /build/target/*.jar app.jar ENTRYPOINT ["java", "-jar", "app.jar"]

最终镜像只有 JRE + jar，体积可能从 800MB 降到 200MB 左右。

9.5 .dockerignore

类似.gitignore，排除不需要 COPY 的文件：

target/ .git/ .idea/ *.md uploads/

不然每次 build 把几 GB 垃圾 COPY 进去，又慢又臃肿。

10. Docker Compose：一条命令起整套环境

10.1 为什么需要 Compose

一个项目往往不止一个容器。spring-RAG 需要 MySQL + Redis Stack。

不用 Compose 的话：

docker run-d--name mysql...（一长串参数） docker run-d--name redis...（又一长串参数）

换电脑、换同学，参数容易错。

Compose 用 YAML 文件描述整套服务，docker compose up -d一键启动。

10.2 compose 文件结构

services:# 定义有哪些容器mysql:...redis:...volumes:# 定义命名卷mysql_data:redis_data:networks:# 可选，定义网络default:...

10.3 逐行解读 spring-RAG 的 docker-compose.yml

下面是你项目里真实的 compose 文件，我逐段讲：

services:mysql:image:mysql:8.0container_name:spring-rag-mysql

• image：用什么镜像
• container_name：固定容器名，不然 Docker 会随机起名

ports:-"3306:3306"

本机 3306 映射到容器 3306。Spring Boot 连jdbc:mysql://localhost:3306/spring_rag就是这样连上的。

environment:MYSQL_ROOT_PASSWORD:root123MYSQL_DATABASE:spring_ragTZ:Asia/Shanghai

MySQL 官方镜像认这些环境变量：

• MYSQL_ROOT_PASSWORD：root 密码（必填，不设起不来）
• MYSQL_DATABASE：自动创建的数据库名

volumes:-./sql/init.sql:/docker-entrypoint-initdb.d/init.sql-mysql_data:/var/lib/mysql

第一行：首次启动时自动执行 init.sql 建表。
第二行：数据持久化到命名卷。

command:--character-set-server=utf8mb4--collation-server=utf8mb4_unicode_ci

覆盖 MySQL 默认启动参数，支持中文和 emoji。

healthcheck:test:["CMD","mysqladmin","ping","-h","localhost"]interval:10stimeout:5sretries:5

健康检查：每 10 秒 ping 一次 MySQL，失败 5 次标记 unhealthy。docker compose ps能看到健康状态。

redis:image:redis/redis-stack:latestcontainer_name:spring-rag-redisports:-"6379:6379"-"8001:8001"volumes:-redis_data:/data

重点：这里必须是redis/redis-stack，不是普通redis。

普通 Redis 没有 RediSearch 模块，Spring AI 的向量存储会报FT.CREATE未知命令。8001 是 RedisInsight 可视化界面。

volumes:mysql_data:redis_data:

声明两个命名卷。Compose 会自动创建。

10.4 Compose 常用命令

在项目根目录（有 docker-compose.yml 的目录）执行：

# 启动（后台）docker compose up-d# 启动（前台，看日志）docker compose up# 停止docker compose stop# 停止并删除容器（卷保留）docker compose down# 停止并删除容器 + 卷（数据全删！）docker compose down-v# 查看状态docker composeps# 看某个服务日志docker compose logs mysql docker compose logs-f redis# 重启某个服务docker compose restart mysql# 拉最新镜像并重建docker compose pull docker compose up-d

10.5 docker compose up 背后发生了什么

1. 读docker-compose.yml
2. 检查网络，没有就创建默认网络
3. 检查卷，没有就创建
4. 本地没有镜像就 pull
5. 按依赖顺序创建并启动容器
6. 如果容器已在运行，对比配置决定是否重建

11. 实战：用 Docker 跑 spring-RAG 的 MySQL + Redis

这一节是完整操作流程，跟着做一遍，Docker 就算入门了。

11.1 前提

• Docker Desktop 已安装并 running
• 项目已下载到本地，比如C:\Users\xxx\Desktop\spring-RAG

11.2 启动基础设施

cd C:\Users\李旭东\Desktop\实训材料\青大备课\spring-RAG docker compose up-d

第一次会下载镜像，取决于网速，可能几分钟。

11.3 确认容器正常

docker composeps

期望输出类似：

NAME STATUS PORTS spring-rag-mysql Up (healthy) 0.0.0.0:3306->3306/tcp spring-rag-redis Up 0.0.0.0:6379->6379/tcp, 0.0.0.0:8001->8001/tcp

MySQL 显示(healthy)说明 healthcheck 通过了。

11.4 验证 MySQL

方式一：进容器

docker exec-it spring-rag-mysql mysql-uroot-proot123-e"SHOW DATABASES;"

应该能看到spring_rag数据库。

方式二：用 Navicat / DBeaver 连接

• 主机：localhost
• 端口：3306
• 用户：root
• 密码：root123

进去看有没有knowledge_base、document等表——这些是 init.sql 建的。

11.5 验证 Redis Stack

浏览器打开 http://localhost:8001 ，这是 RedisInsight。

或者用命令：

docker exec-it spring-rag-redis redis-cliping

返回PONG即可。

11.6 启动 Spring Boot 后端

后端跑在 Docker 外面（方便调试改代码），连 Docker 里的数据库：

cd backend# 配置 AI Key（示例：DeepSeek）$env:OPENAI_API_KEY="sk-你的密钥"$env:OPENAI_BASE_URL="https://api.deepseek.com"$env:OPENAI_CHAT_MODEL="deepseek-chat"mvn spring-boot:run

application.yml里已经配好了：

datasource:url:jdbc:mysql://localhost:3306/spring_rag?...username:rootpassword:root123data:redis:host:localhostport:6379

所以后端不需要改配置，Docker 起来就能连。

11.7 启动 Vue 前端

新开终端：

cd frontend npm install npm run dev

浏览器访问 http://localhost:5173

11.8 完整功能测试

1. 知识库管理→ 新建知识库
2. 上传sample-docs/spring-intro.txt
3. 看到「已索引、X 块」→ 说明 Redis 向量写入成功
4. 智能问答→ 新建对话 → 选知识库 → 朴素 RAG
5. 问「什么是 RAG？」→ 有回答、有引用来源

如果第 3 步失败，99% 是 Redis 问题（没用 Stack 镜像，或 Redis 没起来）。

11.9 每天开发怎么开/关

开工：

docker compose up-d# 然后照常启动 backend 和 frontend

收工：

docker compose stop

不要随便docker compose down -v，除非你想清空所有数据库和向量数据。

12. 排错手册：90% 的问题出在这

12.1 Docker Desktop 没启动

现象：任何 docker 命令报Cannot connect to the Docker daemon

解决：打开 Docker Desktop，等到 running。

12.2 镜像拉取慢或失败

现象：docker pull超时、Error response from daemon: Get https://registry-1.docker.io/...

国内常见。解决：Docker Desktop → Settings → Docker Engine，加镜像加速：

{"registry-mirrors":["https://docker.1ms.run","https://docker.xuanyuan.me"]}

镜像源可能变动，搜「Docker 镜像加速 2025」找当前可用的。

12.3 端口被占用

见第 7 节。改映射或停占用进程。

12.4 MySQL 起不来

docker compose logs mysql

常见原因：

• 密码不符合复杂度（MySQL 8 有时对空密码有限制，我们设了 root123 一般没问题）
• 之前坏的卷数据——尝试docker compose down -v后重来（会丢数据）
• 内存不够——Docker Desktop 调大 Memory 到 4GB+

12.5 init.sql 改了但没生效

因为卷里已有数据，init 脚本只执行一次。

解决：

docker compose down-v docker compose up-d

警告：这会删除 MySQL 和 Redis 所有数据。

12.6 RAG 报 FT.CREATE 未知命令

你用的是普通 Redis 镜像，不是 Redis Stack。

检查 compose 里是否是：

image:redis/redis-stack:latest

12.7 容器 healthy 但连不上

等 MySQL 完全启动需要几秒到几十秒。后端启动太快可能连不上。

解决：

• 后端加 spring 的spring.datasource.hikari.connection-retry或 simply 等 mysql healthy 后再启 backend
• 或 compose 里给 backend 也 docker 化并加depends_on: mysql: condition: service_healthy（进阶）

12.8 Windows 路径问题

绑定挂载./sql/init.sql在 Windows 上一般没问题。如果路径有空格或中文，偶尔出幺蛾子——尽量项目路径别用特殊字符。

12.9 磁盘空间不足

Docker 镜像和卷占空间。清理：

docker system df# 看占用docker system prune# 删停止的容器、无用网络、dangling 镜像docker system prune-a# 更激进，删所有未使用的镜像

prune 不会删正在使用的卷，但-a可能删你以为还会用的镜像，下次得重新 pull。

13. 进阶：网络、资源限制、多阶段构建

13.1 自定义网络

services:app:networks:-backendmysql:networks:-backendnetworks:backend:driver:bridge

同一网络的容器可以用服务名互访，比如 app 连mysql:3306。

13.2 depends_on 与启动顺序

services:backend:depends_on:mysql:condition:service_healthy

Compose 会等 MySQL healthy 后再起 backend。注意：depends_on只保证启动顺序，不保证 MySQL 里表已建好——官方镜像的 entrypoint 会处理。

13.3 资源限制

services:mysql:deploy:resources:limits:cpus:'1.0'memory:1G

防止某个容器吃光内存。Docker Desktop 单容器 deploy 在部分版本需 Swarm 模式，简单限制可用：

mem_limit:1gcpus:1.0

（非 Swarm 下部分字段行为因版本而异，生产环境查对应版本文档。）

13.4 环境变量文件 .env

Compose 自动读同目录.env：

MYSQL_ROOT_PASSWORD=root123 MYSQL_DATABASE=spring_rag

compose 里引用：

environment:MYSQL_ROOT_PASSWORD:${MYSQL_ROOT_PASSWORD}

密码不进 git，.env加入.gitignore。

13.5 把后端也 Docker 化（完整 compose 示例思路）

教学项目为了改代码方便，后端跑在宿主机。如果要「全 Docker 化」：

services:backend:build:./backendports:-"8080:8080"environment:SPRING_DATASOURCE_URL:jdbc:mysql://mysql:3306/spring_ragSPRING_DATA_REDIS_HOST:redisdepends_on:mysql:condition:service_healthyredis:condition:service_started

注意：此时 JDBC url 里 host 写mysql（服务名），不是localhost。

14. 学习路线：从会用到精通还要学什么

14.1 你现在处于哪一级

跟着本文做到第 11 节，你已经在入门偏熟练。

14.2 建议练习

1. 改端口：MySQL 改 3307，同步改 Spring Boot 配置，练端口映射
2. 写 Dockerfile：给 backend 写 Dockerfile，compose 里加 build
3. 故意搞坏再修：down -v清空数据，重新 up，体验 init.sql 和持久化
4. 看日志排错：停掉 Redis 再启 backend，看报什么错
5. 进容器：docker exec进 MySQL 手动查表

14.3 下一步学什么

• Docker Compose 进阶：profiles、override 文件（docker-compose.override.yml）
• Kubernetes：容器多了以后的管理标准（Minikube 本地练）
• CI/CD：GitHub Actions 里 build 镜像 push 到仓库
• 镜像安全：不要用 root 跑应用、扫描漏洞、最小基础镜像

14.4 推荐官方文档

• Docker 文档：https://docs.docker.com/
• Compose 文件参考：https://docs.docker.com/compose/compose-file/
• MySQL 镜像说明：https://hub.docker.com/_/mysql
• Redis Stack：https://hub.docker.com/r/redis/redis-stack

文档比营销号教程靠谱，遇到版本差异以官方为准。

附录 A：命令速查表

# 镜像docker pull <镜像> docker images docker rmi <镜像># 容器docker run-d--name <名>-p <宿端口>:<容器端口> <镜像> dockerps[-a]docker stop/start/restart <容器> dockerrm[-f]<容器> docker logs[-f]<容器> docker exec-it <容器> bash# Compose（在项目根目录）docker compose up[-d]docker compose down[-v]docker composepsdocker compose logs[-f][服务名]docker compose restart[服务名]# 卷docker volumelsdocker volume inspect <卷名> docker volumerm<卷名># 清理docker system df docker system prune[-a]

附录 B：spring-RAG 项目 Docker 相关文件说明

附录 C：名词对照

教程写于 2026 年，基于 Docker Desktop + Docker Compose V2。命令和镜像版本如有更新，以官方文档为准。

配合 spring-RAG 项目使用效果更佳——理论看完，第 11 节动手做一遍，比看十遍都有用。