Docker 完整部署一个包含 Spring Boot（依赖 JDK）、MySQL、Redis、Nginx 的整套服务

前置准备

环境：一台安装了 Docker 和 Docker Compose 的服务器 / 虚拟机（CentOS、Ubuntu 均可）。

若未安装，可先执行以下一键安装命令（以 CentOS 为例，Ubuntu 命令类似，可自行查询）： bash

复制代码

# 安装Docker
curl -fsSL https://get.docker.com | sh
# 启动Docker并设置开机自启
systemctl start docker
systemctl enable docker
# 安装Docker Compose（v2，集成在Docker中，部分环境需单独安装）
yum install docker-compose-plugin -y
# 验证安装成功
docker --version
docker compose version

准备文件：
- 你的 Spring Boot 可执行 Jar 包（命名为 app.jar，方便后续配置）。
- （可选）Spring Boot 配置文件 application.yml（若需外部挂载配置，方便修改，推荐）。
- Nginx 配置文件 nginx.conf（用于反向代理 Spring Boot 服务）。

整体目录结构

先搭建统一的目录结构，方便管理所有配置和文件，后续操作均基于此目录：

已生成代码

执行命令创建目录：

bash

复制代码

mkdir -p springboot-docker/{app,nginx,mysql,redis}

然后将你的 app.jar、application.yml 放入 app/ 目录，后续创建 nginx.conf 和 docker-compose.yml。

步骤 1：配置 Spring Boot 项目

确保 application.yml 中的数据库、Redis 配置指向 Docker Compose 中的服务名 （Docker Compose 会自动创建内部网络，服务名可直接作为域名访问）：

yaml

复制代码

server:
  port: 8080 # Spring Boot 内部端口，后续被 Nginx 反向代理

spring:
  # 数据库配置
  datasource:
    url: jdbc:mysql://mysql:3306/your_db?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
    username: root # 与 docker-compose 中配置的 MYSQL_ROOT_USER 一致
    password: 123456 # 与 docker-compose 中配置的 MYSQL_ROOT_PASSWORD 一致
    driver-class-name: com.mysql.cj.jdbc.Driver
  # Redis 配置
  redis:
    host: redis # Docker Compose 中的 Redis 服务名
    port: 6379 # Redis 默认端口
    password: 123456 # 与 docker-compose 中配置的 REDIS_PASSWORD 一致
    database: 0 # 选择第 0 个数据库

# 其他你的业务配置...

确保 Spring Boot 项目已打包为可执行 Jar 包（mvn clean package -Dmaven.test.skip=true），并放入 springboot-docker/app/ 目录。

步骤 2：配置 Nginx

在 springboot-docker/nginx/ 目录下创建 nginx.conf 文件，核心功能是反向代理 Spring Boot 服务（将 80 端口的请求转发到 Spring Boot 的 8080 端口），同时支持静态资源转发（可选）：

nginx

复制代码

# 全局配置
worker_processes  1;

events {
    worker_connections  1024;
}

# HTTP 配置
http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;

    # 反向代理 Spring Boot 服务的配置
    upstream springboot_app {
        server app:8080; # app 是 Docker Compose 中的 Spring Boot 服务名，8080 是 Spring Boot 端口
    }

    # 虚拟主机配置
    server {
        listen       80; # 对外暴露 80 端口，可通过服务器 IP 直接访问
        server_name  localhost; # 可修改为你的域名，如 www.xxx.com

        # 所有请求转发到 Spring Boot 服务
        location / {
            proxy_pass   http://springboot_app;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }

        # （可选）静态资源配置，若 Spring Boot 有静态资源（如 img、js），可直接由 Nginx 提供
        location /static/ {
            root   /usr/share/nginx/html;
            expires  30d;
        }

        # 错误页面配置
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   /usr/share/nginx/html;
        }
    }
}

步骤 3：编写 Docker Compose 编排文件

这是核心文件，用于统一编排 JDK（内嵌在 Spring Boot 容器中）、Spring Boot、MySQL、Redis、Nginx 五个服务，在 springboot-docker/ 目录下创建 docker-compose.yml 文件：

yaml

复制代码

version: '3.8' # Docker Compose 版本，需与你的 Docker 版本兼容

# 定义所有服务
services:
  # 1. MySQL 服务
  mysql:
    image: mysql:8.0 # 选择 MySQL 8.0 镜像（稳定版，也可选择 5.7）
    container_name: springboot-mysql # 容器名称，方便后续管理
    restart: always # 开机自启，容器异常退出时自动重启
    environment:
      # MySQL 核心配置
      MYSQL_ROOT_PASSWORD: 123456 # 根密码，与 Spring Boot 配置一致
      MYSQL_ROOT_USER: root # 根用户名
      MYSQL_DATABASE: your_db # 自动创建的数据库，与 Spring Boot 配置一致
      TZ: Asia/Shanghai # 时区配置
    ports:
      - "3306:3306" # 主机端口:容器端口，外部可通过 3306 访问 MySQL
    volumes:
      - ./mysql:/var/lib/mysql # 数据持久化，将容器内 MySQL 数据目录挂载到主机 ./mysql 目录
    networks:
      - app-network # 加入自定义网络，方便服务间通信

  # 2. Redis 服务
  redis:
    image: redis:7.0 # Redis 7.0 镜像（稳定版）
    container_name: springboot-redis
    restart: always
    environment:
      TZ: Asia/Shanghai
    command: redis-server --requirepass 123456 --appendonly yes # 配置密码、开启持久化（AOF 模式）
    ports:
      - "6379:6379"
    volumes:
      - ./redis:/data # 数据持久化，挂载 Redis 数据目录
    networks:
      - app-network

  # 3. Spring Boot 服务（内嵌 JDK）
  app:
    image: openjdk:17-jdk-slim # 选择与你的 Spring Boot 兼容的 JDK 镜像（如 Spring Boot 3.x 推荐 JDK 17，2.x 推荐 JDK 8）
    container_name: springboot-app
    restart: always
    depends_on:
      - mysql # 依赖 MySQL 服务，启动顺序在 MySQL 之后
      - redis # 依赖 Redis 服务，启动顺序在 Redis 之后
    environment:
      TZ: Asia/Shanghai
    volumes:
      - ./app/app.jar:/app/app.jar # 挂载 Spring Boot Jar 包到容器内
      - ./app/application.yml:/app/application.yml # （可选）挂载外部配置文件，方便修改无需重启容器
    command: java -jar /app/app.jar # 启动 Spring Boot 命令
    networks:
      - app-network
    # 不暴露端口给外部，仅通过 Nginx 反向代理访问，更安全
    # ports:
    #   - "8080:8080"

  # 4. Nginx 服务
  nginx:
    image: nginx:1.25-alpine # Nginx 轻量镜像（alpine 版本体积小）
    container_name: springboot-nginx
    restart: always
    depends_on:
      - app # 依赖 Spring Boot 服务
    ports:
      - "80:80" # 对外暴露 80 端口，访问服务器 IP 即可进入应用
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf # 挂载 Nginx 配置文件
      - ./nginx/html:/usr/share/nginx/html # （可选）挂载静态资源目录
    networks:
      - app-network

# 自定义网络，所有服务加入此网络，可通过服务名互相访问
networks:
  app-network:
    driver: bridge

关键说明：

JDK 配置 ：直接使用 openjdk:17-jdk-slim 镜像，无需手动安装 JDK，Spring Boot 运行依赖的 JDK 环境由该镜像提供，这是 Docker 部署 Spring Boot 的最佳实践。
服务依赖 ：通过 depends_on 配置启动顺序，确保 MySQL、Redis 先启动，再启动 Spring Boot，最后启动 Nginx。
数据持久化 ：所有有状态服务（MySQL、Redis）都配置了 volumes 挂载，避免容器删除后数据丢失。
网络通信 ：自定义 app-network 网络，服务间可通过服务名（如 mysql、redis）直接通信，无需手动配置 IP。

步骤 4：启动整套服务

进入 springboot-docker/ 目录（确保当前目录下有 docker-compose.yml 文件）：

bash
复制代码
```
cd springboot-docker
```
启动所有服务（后台运行，加 -d 参数）：

bash
复制代码
```
docker compose up -d
```

查看服务启动状态： bash

复制代码

# 查看所有容器运行状态
docker compose ps
# 查看某个服务的日志（如 Spring Boot 服务，排查启动异常）
docker compose logs -f app
# 查看 Nginx 日志
docker compose logs -f nginx

验证访问：
- 直接在浏览器输入 http://你的服务器IP，即可通过 Nginx 反向代理访问到 Spring Boot 应用。
- 可通过 Navicat 等工具连接 MySQL（地址：服务器 IP，端口：3306，用户名：root，密码：123456），验证数据库是否自动创建。
- 可通过 Redis 客户端连接 Redis（地址：服务器 IP，端口：6379，密码：123456），验证 Redis 服务是否可用。

步骤 5：常用运维命令（后续管理）

停止所有服务： bash
复制代码
```
docker compose down
```
停止并删除数据卷（谨慎使用，会丢失 MySQL、Redis 数据）： bash
复制代码
```
docker compose down -v
```
重启某个服务（如修改 Spring Boot 配置后重启 app 服务）： bash
复制代码
```
docker compose restart app
```
更新服务（如替换新的 app.jar 后，重新构建并启动）：

bash
复制代码
```
docker compose up -d --build app
```

进入容器内部排查问题（如进入 MySQL 容器）： bash

复制代码

docker exec -it springboot-mysql bash
# 进入后可连接 MySQL
mysql -uroot -p123456

步骤 6：添加启动项

步骤 1：创建 systemd 服务文件

在 /etc/systemd/system/ 目录下创建一个服务文件，命名为 springboot-docker.service（名字可自定义，后缀必须为 .service）。

bash

复制代码

vim /etc/systemd/system/springboot-docker.service

将以下内容复制到文件中，注意替换 [你的 docker-compose.yml 所在绝对路径] 为实际路径 （如上面 pwd 输出的 /home/ubuntu/springboot-docker）：

ini

复制代码

[Unit]
Description=Spring Boot Docker Compose Service
# 依赖 Docker 服务，确保 Docker 启动后再启动此服务
After=docker.service
Requires=docker.service

[Service]
# 服务运行用户（根据你的实际用户修改，如 root、ubuntu 等）
User=root
# 工作目录：docker-compose.yml 所在的绝对路径
WorkingDirectory=[你的 docker-compose.yml 所在绝对路径]
# 启动命令：后台启动 docker compose 服务
ExecStart=/usr/bin/docker compose up -d
# 停止命令：停止 docker compose 服务
ExecStop=/usr/bin/docker compose down
# 重启命令：重启 docker compose 服务
ExecReload=/usr/bin/docker compose restart
# 服务退出后的重启策略
Restart=always
# 重启间隔时间
RestartSec=5

[Install]
# 表示服务在系统多用户模式下启动
WantedBy=multi-user.target

关键参数说明

表格

参数	作用
`After=docker.service`	启动顺序：Docker 启动后，再启动本服务
`Requires=docker.service`	依赖关系：Docker 服务必须运行，否则本服务启动失败
`WorkingDirectory`	必须指定 `docker-compose.yml` 所在绝对路径，否则 `docker compose` 找不到配置文件
`ExecStart`	启动命令路径：`/usr/bin/docker` 是 Docker 安装路径，可通过 `which docker` 验证

步骤 2：重新加载 systemd 配置

创建完服务文件后，需要让 systemd 识别这个新服务：

bash

复制代码

systemctl daemon-reload

步骤 3：设置开机自启并启动服务

设置服务开机自启： bash
复制代码
```
systemctl enable springboot-docker.service
```
手动启动该服务（验证是否生效）： bash
复制代码
```
systemctl start springboot-docker.service
```
查看服务状态（确认是否正常运行）： bash
复制代码
```
systemctl status springboot-docker.service
```
- 输出中出现 active (running) 即为启动成功。

步骤 4：验证开机自启效果（可选）

为了确保配置生效，可以重启服务器进行测试：

bash

复制代码

reboot

服务器重启后，执行以下命令，查看容器是否自动启动：

bash

复制代码

# 进入工作目录
cd [你的 docker-compose.yml 所在绝对路径]
# 查看容器状态
docker compose ps

所有服务（app/mysql/redis/nginx）的状态应为 Up，说明开机自启配置成功。

常用运维命令（管理该服务）

表格

功能	命令
启动服务	`systemctl start springboot-docker.service`
停止服务	`systemctl stop springboot-docker.service`
重启服务	`systemctl restart springboot-docker.service`
查看服务状态	`systemctl status springboot-docker.service`
关闭开机自启	`systemctl disable springboot-docker.service`
查看服务日志（排查启动问题）	`journalctl -u springboot-docker.service -f`

问题

执行 systemctl start 后，服务状态显示 failed：
- 查看详细日志：journalctl -u springboot-docker.service -f，根据日志提示排查。
- 检查 WorkingDirectory 是否为绝对路径 ，且路径下存在 docker-compose.yml 文件。
- 检查 ExecStart 中的 docker 路径是否正确，可通过 which docker 验证（如路径为 /usr/local/bin/docker，需修改服务文件）。
服务器重启后，Docker 启动了，但容器未启动：
- 检查 Docker 服务是否真的开机自启：systemctl is-enabled docker，若未开启，执行 systemctl enable docker。
- 检查服务依赖配置是否正确（After=docker.service 和 Requires=docker.service）。

常见问题排查

Spring Boot 启动失败，提示无法连接 MySQL/Redis：
- 检查 application.yml 中的 host 是否为 Docker Compose 中的服务名（mysql/redis），而非 localhost 或 127.0.0.1。
- 检查密码、数据库名是否与 docker-compose.yml 中的配置一致。
- 查看 MySQL/Redis 日志，确认服务是否正常启动：docker compose logs mysql。
浏览器无法访问 http://服务器IP：
- 检查服务器防火墙是否开放 80 端口：firewall-cmd --query-port=80/tcp，未开放则执行 firewall-cmd --permanent --add-port=80/tcp && firewall-cmd --reload。
- 检查 Nginx 容器是否正常运行：docker compose ps nginx，查看 Nginx 日志是否有配置错误：docker compose logs nginx。
数据丢失：
- 确认 volumes 挂载目录是否正确，主机 ./mysql、./redis 目录是否有写入权限。

总结

核心采用 Docker Compose 编排服务，简化多容器部署和网络配置，是此类场景的最佳实践。
关键配置要点：服务间通过服务名通信 、有状态服务配置数据持久化挂载 、Spring Boot 依赖 JDK 由 openjdk 镜像提供、外部访问通过 Nginx 反向代理。
启动流程：准备目录和文件 → 配置各组件 → 编写 docker-compose.yml → docker compose up -d 启动 → 验证访问，全程可直接落地，无需复杂手动配置。