Docker 零基础快速入门教程

👋 关于作者

你好，这里是一条泥憨鱼　|　专注于 后端开发、AI 前沿技术与计算机基础 。 🏠 个人主页：一条泥憨鱼

通过技术博客记录技术成长，分享学习心得与经验。期待与您共同交流！

第一部分：认识 Docker

1.1 Docker 是什么

Docker 是一个把「应用 + 运行环境」打包成标准单元，并在任何机器上以同样方式运行的容器工具。

你写了一个 Spring Boot 项目，本机能跑；发给同学，他启动报错——他装的是 JDK 8，你用的是 JDK 17；他 MySQL 是 5.7，你建表用了 8.0 的语法；他的 Redis 没设密码，你的配置文件里写了密码。于是你们花了一下午排查「环境问题」，而不是写代码。

Docker 的解决思路很直接：不要再让对方去装环境，而是把环境本身一起打包给你。

它把「JDK 17 + 你的 jar 包 + 启动命令 + 时区配置」打包成一个叫镜像的东西。同学只要装好 Docker，一条命令就能得到一个和你完全一致的环境。这就是常说的「一次构建，到处运行」。

1.2 为什么开发者需要 Docker

1.3 镜像、容器、仓库

这三个词是 Docker 的全部基础，用「类与对象」来类比最好记：

串起来：从仓库拉取镜像 → 用镜像创建容器 → 容器里跑着你的程序。

补充两个后面会反复出现的概念：

• Dockerfile：一份文本说明书，描述「如何构建一个镜像」。
• 数据卷（Volume）：宿主机上的一块持久化存储，挂给容器用。容器删了，卷里的数据还在。

1.4 Docker 与虚拟机的区别

容器比虚拟机轻得多、快得多，所以适合开发环境和服务部署。

Windows 上的 Docker Desktop 实际是通过 WSL2 跑一个轻量 Linux 环境，所以你拉取的镜像绝大多数是 Linux 镜像。这属于正常现象，不用关心细节。

1.5 Docker 在 Java 后端开发中的常见用途

• 本地依赖服务：MySQL、Redis、RabbitMQ、Kafka、Nacos、MinIO 全部用容器起，一条命令切换版本。
• 打包部署自己的服务：把 Spring Boot 的 jar 打成镜像，推送到镜像仓库，服务器拉取即运行。
• 一键起整套环境：用 Docker Compose 把「应用 + 数据库 + 缓存」一次拉起，新同事入职十分钟就能跑通项目。
• CI/CD：流水线里自动构建镜像并发布。

第二部分：安装与第一次使用

2.1 安装 Docker

安装方式请以官方文档为准，下面只给结论和入口。

Windows

macOS

• 从 https://docs.docker.com/desktop/setup/install/mac-install/ 下载对应芯片版本（Apple Silicon 选 Apple chip，Intel 选 Intel chip），拖入「应用程序」后启动即可。

Linux（Ubuntu 为例）

按官方文档用 apt 源安装：https://docs.docker.com/engine/install/ubuntu/。安装后把当前用户加入 docker 组，避免每条命令都要 sudo：

sudo usermod -aG docker $USER
# 重新登录终端后生效

2.2 检查是否安装成功

docker version
docker info

docker version 能看到 Client 和 Server 两段信息，说明客户端和引擎都正常。如果只有 Client 没有 Server，通常是 Docker Desktop 没启动，或当前用户没有权限。

再跑一个官方示例验证整条链路：

docker run hello-world

出现 Hello from Docker! 说明拉取镜像、创建容器、运行容器全部正常。这个容器运行完就自动退出了，属于正常现象。

2.3 第一次完整操作：用 Nginx 走一遍流程

下面用 Nginx 演示「拉取 → 运行 → 查看 → 停止 → 启动 → 删除」的完整闭环。

# 1. 拉取镜像（不拉也行，docker run 会自动拉，但显式拉取更清楚）
docker pull nginx:1.27

# 2. 后台运行一个容器，名字叫 web-demo，把宿主机 8080 端口映射到容器 80 端口
docker run -d –name web-demo -p 8080:80 nginx:1.27

# 3. 查看运行中的容器
docker ps

# 4. 浏览器访问 http://localhost:8080 ，能看到 Welcome to nginx! 即成功

接着练习生命周期操作：

docker stop web-demo # 停止容器
docker ps # 此时列表里看不到它了
docker ps -a # 加 -a 才能看到已停止的容器
docker start web-demo # 重新启动
docker rm -f web-demo # 强制删除（会先停止再删除）
docker ps -a # 确认已删除

注意：本节用完请执行 docker rm -f web-demo，释放 8080 端口，后面运行 Spring Boot 还要用它。

第三部分：必须掌握的常用命令

3.1 先搞懂 docker run 的五个核心参数

docker run 是使用频率最高的命令，格式为 docker run [参数] 镜像名 [容器内执行的命令]。

再加两个常用参数：

• –rm：容器停止后自动删除，适合临时跑一次的命令。
• –restart unless-stopped：异常退出或开机后自动重启，适合常驻服务。

3.2 命令详解

docker pull —— 拉取镜像

docker pull mysql:8.0

作用：从镜像仓库下载镜像到本地。注意：不写 tag 默认拉 latest，生产环境务必写明版本号，否则哪天 latest 变了行为会变。

docker images —— 查看本地镜像

docker images

作用：列出本地所有镜像，包含仓库名、标签、镜像 ID、大小、创建时间。注意：镜像 ID 是唯一的，删除时可以用 ID 的前几位。

docker run —— 创建并运行容器

docker run -d –name redis-demo -p 6379:6379 redis:7

作用：以镜像为模板创建一个新容器并启动。注意：每次执行都会创建一个新容器，不会复用同名容器；同名会报 Conflict，需要先删除旧容器或换个名字。

docker ps —— 查看运行中的容器

docker ps

作用：只显示正在运行的容器，包含容器 ID、镜像、状态、端口映射、名字。注意：这是排错第一步，先确认容器到底有没有在跑。

docker ps -a —— 查看所有容器

docker ps -a

作用：包括已停止、已退出的容器。注意：Exited (1) 表示异常退出，需要去看日志。

docker start —— 启动已存在的容器

docker start mysql-demo

作用：重新启动一个已停止的容器，保留原来的配置和数据。注意：start 只接受容器名或 ID，不能用来创建新容器。

docker stop —— 停止容器

docker stop mysql-demo

作用：向容器发送停止信号，容器内进程正常退出。注意：默认等待 10 秒，超时会强杀；想立刻停止可以用 docker kill。

docker rm —— 删除容器

docker rm mysql-demo

作用：删除已停止的容器。注意：运行中的容器删不掉，需要加 -f 强制删除。删除容器本身不会删除数据卷里的数据，但如果启动时没挂载卷，数据会一起消失。

docker rmi —— 删除镜像

docker rmi mysql:8.0

作用：删除本地镜像。注意：有容器（包括已停止的）正在使用该镜像时删不掉，需要先删除容器。加 -f 可以强制删除，但可能留下悬空镜像。

docker logs —— 查看容器日志

docker logs -f –tail 100 mysql-demo

作用：查看容器内程序的标准输出和错误输出，-f 持续跟踪，–tail 100 只看最后 100 行。注意：容器启动失败时，这是排查原因的第一现场。

docker exec -it —— 进入容器执行命令

docker exec -it mysql-demo bash

作用：在运行中的容器里开一个交互式终端，方便查看文件、连数据库。注意：-it 中 -i 保持输入、-t 分配终端，缺一不可；有些精简镜像没有 bash，可换成 sh。用 exit 退出，退出不会停止容器。

docker build —— 构建镜像

docker build -t demo-app:1.0 .

作用：根据当前目录下的 Dockerfile 构建镜像，-t 指定「仓库名:标签」。注意：最后那个 . 是构建上下文目录，不能省略，它决定 Docker 能读取哪些文件。

docker inspect —— 查看容器或镜像详情

docker inspect mysql-demo

作用：输出完整的 JSON 配置，包括 IP 地址、挂载信息、环境变量、启动命令。注意：常用 docker inspect -f '{{.NetworkSettings.IPAddress}}' mysql-demo 只取某个字段。

3.3 命令速查表

第四部分：使用 Docker 运行 MySQL 和 Redis

这是日常开发中使用频率最高的场景。下面命令可以直接复制执行，前后连贯。

4.1 运行 MySQL

# 1. 拉取镜像（使用 8.0 版本，兼容性最好）
docker pull mysql:8.0

# 2. 创建并运行容器
docker run -d \\
–name mysql-demo \\
-p 3306:3306 \\
-e MYSQL_ROOT_PASSWORD=123456 \\
-e MYSQL_DATABASE=demo_db \\
-e TZ=Asia/Shanghai \\
-v mysql-data:/var/lib/mysql \\
–restart unless-stopped \\
mysql:8.0

PowerShell 用户注意：PowerShell 的续行符是反引号 `，不是反斜杠 \\。上面这段在 PowerShell 里要么写成一行，要么把每行末尾的 \\ 换成反引号。 下面的命令同理，为通用性统一用 \\，实际执行时按你的终端替换。

逐段解释：

验证服务是否正常

# 查看容器状态，STATUS 应为 Up
docker ps

# 查看启动日志，看到 "ready for connections" 即初始化完成
docker logs mysql-demo

# 在容器内执行 SQL 验证
docker exec -it mysql-demo mysql -uroot -p123456 -e "SELECT VERSION();"

也可以用本机客户端连接：主机 127.0.0.1，端口 3306，用户 root，密码 123456。

4.2 运行 Redis

docker pull redis:7

docker run -d \\
–name redis-demo \\
-p 6379:6379 \\
-v redis-data:/data \\
–restart unless-stopped \\
redis:7 redis-server –appendonly yes

解释：

• -p 6379:6379：本机客户端连 localhost:6379。
• -v redis-data:/data：Redis 的数据目录是 /data，挂卷后 RDB/AOF 文件持久化。
• redis-server –appendonly yes：镜像名后面的内容会作为容器内启动命令，这里开启 AOF 持久化，避免重启丢数据。

验证

docker ps
docker logs redis-demo
docker exec -it redis-demo redis-cli ping
# 返回 PONG 即正常

4.3 为什么数据库容器必须考虑持久化

容器的设计哲学是「用完即弃」：容器删除后，容器内写入的文件全部消失。MySQL 的数据默认写在容器内的 /var/lib/mysql，如果不挂卷，执行 docker rm mysql-demo 后，你建的库、表、数据会一起没掉。

数据卷就是解决这个问题的：数据实际落在宿主机上，容器只是「借用」这个目录。删容器、重建容器、换镜像版本，数据都还在。

4.4 停止、重启、删除

docker stop mysql-demo # 停止
docker start mysql-demo # 再次启动，数据仍在
docker restart mysql-demo # 重启

docker rm -f mysql-demo # 删除容器（数据卷仍在）
docker volume ls # 查看数据卷
docker volume rm mysql-data # 删除数据卷 —— 数据会真正丢失

数据卷对比：

• docker rm 容器：只删容器，卷保留。
• docker volume rm 卷名：删除卷，数据不可恢复。
• 如果你想彻底重来（比如密码忘了、初始化失败），执行 docker rm -f mysql-demo && docker volume rm mysql-data，再重新 docker run，就会得到一个全新的库。

安全提醒：本文所有密码 123456 仅用于本地学习。真实项目不要把密码硬编码进命令、配置文件或提交到 Git，应使用环境变量、密钥管理服务等方式管理。

说明：以上参数是为了「本地开发快速跑通」而给出的最小配置，不涉及主从、备份、资源限制、权限收敛等生产环境要考虑的内容。

第五部分：Dockerfile 与 Docker Compose 入门

5.1 Dockerfile 是什么

Dockerfile 是一份文本文件，逐行描述「如何从基础镜像一步步做出你的镜像」。三者关系是：

Dockerfile –(docker build)–> 镜像 –(docker run)–> 容器

常用指令

两个容易混的点：

• RUN 在构建时执行，CMD 在容器启动时执行。
• EXPOSE 只是声明，真正的端口映射要靠 docker run -p 或 compose 的 ports。

5.2 把 Spring Boot 项目打成镜像

前置条件：项目已用 Maven 打成可执行 jar。

mvn clean package -DskipTests
# 产物在 target/ 目录下，例如 target/demo-0.0.1-SNAPSHOT.jar

在项目根目录（与 pom.xml 同级）新建 Dockerfile：

# 1. 基础镜像：JDK 17 运行时（只含 JRE，体积比 JDK 小）
FROM eclipse-temurin:17-jre

# 2. 工作目录
WORKDIR /app

# 3. 复制构建产物（target 下只有一个可执行 jar，用通配符避免写死版本号）
COPY target/*.jar app.jar

# 4. 创建一个日志目录（演示 RUN 指令）
RUN mkdir -p /app/logs

# 5. 声明服务端口（仅声明，映射仍需 -p）
EXPOSE 8080

# 6. 容器启动命令
CMD ["java", "-jar", "app.jar"]

再新建 .dockerignore，避免把无用文件打进构建上下文（构建更快，也不会误把本地配置带进镜像）：

target/*.original
.idea
.git
*.log

注意：target 目录不能被完全忽略，因为我们要复制里面的 jar。这里的写法只排除了 .original 文件。

构建并运行

docker build -t demo-app:1.0 .
docker run -d –name demo-app -p 8080:8080 demo-app:1.0
docker ps
docker logs -f demo-app

浏览器访问 http://localhost:8080 验证。

关键点：如果这个服务要连 MySQL，不能再用 localhost

容器里的 localhost 指的是容器自己，不是你的电脑。正确做法有两种：

• 连接宿主机上跑着的 MySQL：把配置里的地址改成 host.docker.internal（Docker Desktop 提供的宿主机别名）。
• 连接另一个 MySQL 容器：让两个容器在同一个网络里，用容器名当主机名（见 6.3 的 FAQ 和 Compose 部分）。

例如用环境变量覆盖 Spring Boot 配置：

docker run -d –name demo-app -p 8080:8080 \\
-e SPRING_DATASOURCE_URL="jdbc:mysql://host.docker.internal:3306/demo_db?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true" \\
-e SPRING_DATASOURCE_USERNAME=root \\
-e SPRING_DATASOURCE_PASSWORD=123456 \\
demo-app:1.0

5.3 为什么需要 Docker Compose

上面每个服务都要写一长串 docker run，而且 MySQL 和 Redis 起来的顺序、网络、依赖关系都要手动维护。服务一多就管不过来。

Docker Compose 用一个 YAML 文件描述「一整套服务」，然后一条命令全部拉起。

和 Dockerfile 的区别：

两者是配合关系，不是替代关系：Compose 可以引用现成镜像（MySQL、Redis），也可以用 Dockerfile 构建自己的服务。

5.4 compose.yaml 示例：同时启动 MySQL 和 Redis

在项目根目录新建 compose.yaml：

services:
mysql:
image: mysql:8.0
container_name: mysql–demo
environment:
MYSQL_ROOT_PASSWORD: "123456"
MYSQL_DATABASE: demo_db
TZ: Asia/Shanghai
ports:
– "3306:3306"
volumes:
– mysql–data:/var/lib/mysql
restart: unless–stopped

redis:
image: redis:7
container_name: redis–demo
ports:
– "6379:6379"
volumes:
– redis–data:/data
command: redis–server ––appendonly yes
restart: unless–stopped

volumes:
mysql-data:
redis-data:

对照前面的 docker run 命令看，字段是一一对应的：image 对应镜像名，ports 对应 -p，environment 对应 -e，volumes 对应 -v，command 对应镜像名后面那串启动命令。末尾的 volumes: 是在声明具名数据卷。

注意：如果之前已经用 docker run 起过同名的 mysql-demo、redis-demo，再执行 docker compose up -d 会报容器名冲突。先执行 docker rm -f mysql-demo redis-demo 即可（数据卷保留，数据不会丢）。

常用命令

docker compose up -d # 后台启动所有服务
docker compose ps # 查看本 compose 项目下的容器
docker compose logs -f # 查看所有服务日志（-f 持续跟踪）
docker compose logs mysql # 只看某个服务的日志
docker compose down # 停止并删除容器和网络（数据卷默认保留）

对比一下：docker compose down 默认不删数据卷，下次 up -d 数据还在。如果想连数据一起清掉，用 docker compose down -v，这会删除 compose 中声明的具名卷，数据不可恢复。

Compose 文件在较新版本中推荐命名为 compose.yaml，且不再需要写 version: 字段。

5.5 用它搭本地开发环境

日常流程就三步：

# 1. 进入项目根目录
# 2. 一键拉起依赖服务
docker compose up -d
# 3. 在 IDEA 里直接启动 Spring Boot，连 localhost:3306 / localhost:6379

下班或换项目时：

docker compose down # 停服务，数据保留

这样本机不需要装 MySQL、Redis，每个项目各有一套独立的依赖环境。

第六部分：常见问题与快速复习

6.1 常见问题

Q1：容器启动失败，怎么查原因？

按顺序三步：

docker ps -a # 1. 看状态，Exited 后面的数字就是退出码
docker logs mysql-demo # 2. 看日志，异常信息通常在最后几行
docker inspect mysql-demo # 3. 看配置，确认环境变量、端口、挂载是否写对

最常见的原因：必填环境变量没写（如 MYSQL_ROOT_PASSWORD）、端口被占用、挂载路径写错、启动命令写错。

Q2：宿主机访问不了容器里的服务，检查什么？

依次检查：

Q3：为什么容器之间不能随意用 localhost 通信？

每个容器有自己独立的网络命名空间，容器里的 localhost 指向容器自己。所以 Spring Boot 容器里写 localhost:3306，它找的是自己内部的 3306，而不是 MySQL 容器。

正确做法：

• 同一 Compose 网络内，用服务名作主机名，例如 jdbc:mysql://mysql:3306/demo_db。
• 访问宿主机上的服务，用 host.docker.internal（Docker Desktop）。
• 实在要用容器 IP，可以用 docker inspect 查，但 IP 会变，不推荐。

Q4：删除容器后数据为什么可能丢失？

容器的可写层随容器一起删除。启动时没有用 -v 把数据目录挂出来，数据就写在容器自己的文件系统里，删容器即删数据。

所以数据库类容器必须挂卷：

• MySQL：-v mysql-data:/var/lib/mysql
• Redis：-v redis-data:/data
• 通用做法：查镜像文档，确认它的数据目录在哪里。

Q5：改了 Java 代码，为什么必须重新构建？

镜像里的 jar 是构建那一刻拷进去的静态文件，代码改了不会自动同步。容器每次启动执行的是镜像里那份旧 jar。

正确流程：

mvn clean package -DskipTests
docker build -t demo-app:1.0 .
docker rm -f demo-app
docker run -d –name demo-app -p 8080:8080 demo-app:1.0

如果是用 Compose 且写了 build: .，可以简化为：

docker compose up -d –build

本地开发时，更推荐在 IDEA 里直接运行 Spring Boot（热部署、调试方便），只在需要验证镜像时才构建；容器主要用来跑 MySQL、Redis 这类依赖服务。

Q6：如何安全地清理不用的容器和镜像？

先看占用：

docker ps -a # 看有哪些已停止的容器
docker images # 看本地镜像
docker volume ls # 看数据卷
docker system df # 看磁盘占用汇总

逐个精确清理（推荐先做这一步）：

docker stop 容器名
docker rm 容器名 # 只删已停止的容器
docker rmi 镜像:标签

高风险命令，务必看清楚再执行：

• docker system prune：删除所有已停止的容器、未使用的网络、悬空镜像。数据卷默认会被保留，相对安全。
• docker system prune -a：额外删除所有未被容器使用的镜像。
• docker system prune -a –volumes：连数据卷一起删，运行中的容器数据也可能受影响，确认没有要保留的数据库再执行。

拿不准的时候，先 docker system df -v 看清楚是什么再删。

6.2 核心概念总结

6.3 常用命令速查

6.4 最小化实战任务

按顺序完成，全部跑通说明你已经能上手用了。

任务 1：用 Docker 启动 MySQL 和 Redis（不用 Compose）

docker pull mysql:8.0
docker pull redis:7

docker run -d –name mysql-demo -p 3306:3306 \\
-e MYSQL_ROOT_PASSWORD=123456 -e MYSQL_DATABASE=demo_db \\
-e TZ=Asia/Shanghai -v mysql-data:/var/lib/mysql mysql:8.0

docker run -d –name redis-demo -p 6379:6379 \\
-v redis-data:/data redis:7 redis-server –appendonly yes

docker ps
docker exec -it mysql-demo mysql -uroot -p123456 -e "SHOW DATABASES;"
docker exec -it redis-demo redis-cli ping

验收标准：两个容器都是 Up，MySQL 能看到 demo_db，Redis 返回 PONG。

任务 2：用 Dockerfile 运行 Spring Boot 项目

docker build -t demo-app:1.0 .
docker run -d –name demo-app -p 8080:8080 demo-app:1.0
docker logs -f demo-app

任务 3（选做）：把任务 1 改写成 compose.yaml

参照 5.4 节示例，把 MySQL、Redis 写进 compose.yaml，练习 up -d、ps、logs、down 四个命令。注意先删掉任务 1 手动创建的同名容器，再用 Compose 启动。之后每次开发只需要一条 docker compose up -d。

收尾

docker rm -f demo-app mysql-demo redis-demo
# 如果确认不需要数据了，再删卷
docker volume rm mysql-data redis-data

最后提醒：Docker 的命令不需要背，用三次就熟了。真正要建立的是两个习惯——容器出问题先看 docker ps -a 和 docker logs；涉及删除的命令，先确认数据卷里有没有你要的东西。