基于 Docker + Docker Compose 实现一键部署（单节点部署场景下轻量、易维护、可一键启停)

一、环境准备（服务器端）

首先确保部署服务器已安装Docker和Docker Compose，以下是CentOS/Ubuntu通用安装命令：

# 1. 安装Docker（适配CentOS/Ubuntu）
curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun

# 2. 启动Docker并设置开机自启
systemctl start docker
systemctl enable docker

# 3. 安装Docker Compose（v2版本）
curl -L "https://github.com/docker/compose/releases/download/v2.24.6/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

# 4. 验证安装
docker --version
docker-compose --version

二、目录结构规划

先在服务器上创建统一的部署目录，方便管理配置、数据和日志：

java-project-deploy/  # 根目录
├── deploy.sh         # 一键部署启动脚本
├── stop.sh           # 一键停止脚本
├── docker-compose.yml # 核心编排文件（所有服务配置）
├── postgres/         # PostgreSQL自定义镜像（含PostGIS/ParadeDB）
│   ├── Dockerfile    # 构建带插件的PG镜像
│   └── init.sql      # 初始化插件/数据库
├── nginx/            # Nginx配置&前端文件（外挂）
│   ├── conf/
│   │   └── nginx.conf # Nginx配置
│   └── html/         # 前端应用文件（放你的前端包）
├── data/             # 所有服务的数据持久化目录（防止容器删除丢失数据）
│   ├── postgres/
│   ├── mysql/
│   ├── redis/
│   ├── minio/
│   ├── nacos/
│   ├── kafka/
│   ├── flink/
│   └── dolphinscheduler/
├── conf/             # 各服务自定义配置文件
│   ├── nacos/
│   ├── redis/
│   ├── flink/
│   └── kafka/
└── logs/             # 各服务日志目录
    ├── postgres/
    ├── mysql/
    └── ...

创建目录的命令：

mkdir -p java-project-deploy/{postgres,nginx/{conf,html},data/{postgres,mysql,redis,minio,nacos,kafka,flink,dolphinscheduler},conf/{nacos,redis,flink,kafka},logs}
cd java-project-deploy

三、核心配置编写

1. 自定义PostgreSQL镜像（含PostGIS+ParadeDB）

官方PG镜像不含PostGIS和ParadeDB，需自定义构建，编写postgres/Dockerfile：

# 基于PostgreSQL 17基础镜像（适配你的版本170007）
FROM postgres:17

# 安装依赖&PostGIS+ParadeDB插件
RUN apt-get update && apt-get install -y \
    wget \
    gnupg \
    lsb-release \
    && rm -rf /var/lib/apt/lists/*

# 添加PostGIS源
RUN echo "deb http://apt.postgresql.org/pub/repos/apt/ $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list \
    && wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | apt-key add -

# 安装PostGIS（适配PG17）
RUN apt-get update && apt-get install -y \
    postgresql-17-postgis-3 \
    postgresql-17-postgis-3-scripts \
    && rm -rf /var/lib/apt/lists/*

# 安装ParadeDB（官方推荐方式）
RUN wget -qO- https://paradedb.com/install.sh | bash -s -- -p 17

# 复制初始化脚本（启动时自动执行）
COPY init.sql /docker-entrypoint-initdb.d/

# 暴露端口
EXPOSE 5432

编写postgres/init.sql（初始化插件、创建数据库）：

-- 启用PostGIS和ParadeDB插件
CREATE EXTENSION IF NOT EXISTS postgis;
CREATE EXTENSION IF NOT EXISTS postgis_topology;
CREATE EXTENSION IF NOT EXISTS paradedb;

-- 可选：创建业务数据库
CREATE DATABASE tong_project;
GRANT ALL PRIVILEGES ON DATABASE tong_project TO postgres;

2. 编写docker-compose.yml（核心编排文件）

这个文件整合所有服务，实现一键启动，注意替换<>中的自定义配置（如密码、镜像地址）：

version: '3.8'

# 所有服务的通用配置
x-common:
  &common
  restart: always  # 容器异常退出自动重启
  logging:
    driver: "json-file"
    options:
      max-size: "100m"  # 日志文件最大100M
      max-file: "3"     # 最多保留3个日志文件

services:
  # ========== 公共基础服务 ==========
  # 1. PostgreSQL（带PostGIS+ParadeDB）
  postgres:
    <<: *common
    build: ./postgres  # 构建自定义PG镜像
    container_name: tong-postgres
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_PASSWORD=123456  # 自定义密码
      - POSTGRES_USER=postgres
      - PGDATA=/var/lib/postgresql/data/pgdata
    volumes:
      - ./data/postgres:/var/lib/postgresql/data  # 数据持久化
      - ./logs/postgres:/var/log/postgresql       # 日志挂载
    networks:
      - tong-network

  # 2. MySQL
  mysql:
    <<: *common
    image: mysql:8.0
    container_name: tong-mysql
    ports:
      - "3306:3306"
    environment:
      - MYSQL_ROOT_PASSWORD=123456
      - MYSQL_DATABASE=nacos_config  # nacos依赖的数据库
    volumes:
      - ./data/mysql:/var/lib/mysql
      - ./logs/mysql:/var/log/mysql
      - ./conf/mysql/my.cnf:/etc/mysql/my.cnf  # 自定义配置（可选）
    networks:
      - tong-network
    healthcheck:  # 健康检查，确保启动完成
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-p123456"]
      interval: 10s
      timeout: 5s
      retries: 3

  # 3. Nacos（依赖MySQL）
  nacos:
    <<: *common
    image: nacos/nacos-server:v2.3.2
    container_name: tong-nacos
    ports:
      - "8848:8848"
    environment:
      - SPRING_DATASOURCE_PLATFORM=mysql
      - MYSQL_SERVICE_HOST=mysql
      - MYSQL_SERVICE_PORT=3306
      - MYSQL_SERVICE_USER=root
      - MYSQL_SERVICE_PASSWORD=123456
      - MYSQL_SERVICE_DB_NAME=nacos_config
      - NACOS_AUTH_ENABLE=false  # 关闭认证（测试环境）
    volumes:
      - ./data/nacos:/home/nacos/data
      - ./logs/nacos:/home/nacos/logs
      - ./conf/nacos/application.properties:/home/nacos/conf/application.properties
    depends_on:
      mysql:
        condition: service_healthy  # 等待MySQL启动完成
    networks:
      - tong-network

  # 4. Redis（单节点）
  redis:
    <<: *common
    image: redis:7.0
    container_name: tong-redis
    ports:
      - "6379:6379"
    command: redis-server --requirepass 123456  # 单节点+密码
    volumes:
      - ./data/redis:/data
      - ./logs/redis:/var/log/redis
    networks:
      - tong-network

  # 5. MQTT（EMQ X）
  mqtt:
    <<: *common
    image: emqx/emqx:5.10.0
    container_name: tong-mqtt
    ports:
      - "1883:1883"  # MQTT端口
      - "8083:8083"  # WebSocket端口
    volumes:
      - ./data/mqtt:/opt/emqx/data
      - ./logs/mqtt:/opt/emqx/log
    networks:
      - tong-network

  # 6. Nginx（外挂前端）
  nginx:
    <<: *common
    image: nginx:1.25
    container_name: tong-nginx
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/conf/nginx.conf:/etc/nginx/nginx.conf  # 自定义配置
      - ./nginx/html:/usr/share/nginx/html             # 外挂前端文件
      - ./logs/nginx:/var/log/nginx
    networks:
      - tong-network

  # 7. MinIO（指定版本）
  minio:
    <<: *common
    image: minio/minio:RELEASE.2020-09-23T19-18-30Z
    container_name: tong-minio
    ports:
      - "9000:9000"
      - "9001:9001"
    command: server /data --console-address ":9001"
    environment:
      - MINIO_ROOT_USER=minioadmin
      - MINIO_ROOT_PASSWORD=minioadmin123
    volumes:
      - ./data/minio:/data
    networks:
      - tong-network

  # ========== 轻量化湖仓底座（单节点） ==========
  # 8. Kafka（单节点）
  kafka:
    <<: *common
    image: apache/kafka:3.6.1
    container_name: tong-kafka
    ports:
      - "9092:9092"
    environment:
      - KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092
      - KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://kafka:9092
      - KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR=1  # 单节点
      - KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181
    volumes:
      - ./data/kafka:/tmp/kafka-logs
    depends_on:
      - zookeeper
    networks:
      - tong-network

  # Kafka依赖的Zookeeper
  zookeeper:
    <<: *common
    image: zookeeper:3.8
    container_name: tong-zookeeper
    ports:
      - "2181:2181"
    volumes:
      - ./data/zookeeper:/data
    networks:
      - tong-network

  # 9. Flink（单节点）
  flink:
    <<: *common
    image: flink:1.20.0-scala_2.12
    container_name: tong-flink
    ports:
      - "8081:8081"  # WebUI
      - "6123:6123"
    command: jobmanager
    environment:
      - FLINK_PROPERTIES=jobmanager.rpc.address:flink
    volumes:
      - ./data/flink:/tmp/flink
      - ./conf/flink/flink-conf.yaml:/opt/flink/conf/flink-conf.yaml
    networks:
      - tong-network

  # 10. Dinky 1.2.5（单节点）
  dinky:
    <<: *common
    image: dinky/dinky:1.2.5
    container_name: tong-dinky
    ports:
      - "8888:8888"
    environment:
      - SPRING_PROFILES_ACTIVE=prod
      - FLINK_REST_ADDRESS=flink:8081
    volumes:
      - ./data/dinky:/opt/dinky/data
    depends_on:
      - flink
    networks:
      - tong-network

  # 11. DolphinScheduler 3.3.2（单节点）
  dolphinscheduler:
    <<: *common
    image: apache/dolphinscheduler:3.3.2-allinone
    container_name: tong-dolphinscheduler
    ports:
      - "12345:12345"
      - "25333:25333"
    environment:
      - DATABASE_TYPE=mysql
      - DATABASE_HOST=mysql
      - DATABASE_PORT=3306
      - DATABASE_USER=root
      - DATABASE_PASSWORD=123456
      - DATABASE_DATABASE=dolphinscheduler
    volumes:
      - ./data/dolphinscheduler:/dolphinscheduler/data
    depends_on:
      mysql:
        condition: service_healthy
    networks:
      - tong-network

  # ========== Java应用服务 ==========
  # 12. 示例：tong-admin（替换为你的实际镜像）
  tong-admin:
    <<: *common
    image: <你的私有镜像仓库>/tong-admin:latest  # 替换为实际镜像
    container_name: tong-admin
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=prod
      - SPRING_REDIS_HOST=redis
      - SPRING_NACOS_SERVER-ADDR=nacos:8848
    volumes:
      - ./logs/tong-admin:/app/logs
    depends_on:
      - nacos
      - redis
      - mysql
    networks:
      - tong-network

  # 其他Java应用（tong-gateway/tong-system等）按上述格式添加

# 自定义网络（所有服务在同一网络，可通过容器名访问）
networks:
  tong-network:
    driver: bridge

3. 编写一键部署脚本（deploy.sh）

#!/bin/bash
set -e  # 遇到错误立即退出

# 脚本所在目录
BASE_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
cd $BASE_DIR

echo "===== 1. 构建PostgreSQL自定义镜像（含PostGIS+ParadeDB） ====="
docker build -t tong-postgres:17 ./postgres

echo "===== 2. 启动所有服务 ====="
docker-compose up -d

echo "===== 3. 检查服务状态 ====="
docker-compose ps

echo "===== 部署完成！====="
echo "各服务访问地址参考："
echo "- Nacos: http://服务器IP:8848/nacos (账号密码默认nacos/nacos)"
echo "- Nginx前端: http://服务器IP"
echo "- Dinky: http://服务器IP:8888"
echo "- DolphinScheduler: http://服务器IP:12345 (账号密码admin/dolphinscheduler123)"

4. 编写一键停止脚本（stop.sh）

#!/bin/bash
set -e

BASE_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
cd $BASE_DIR

echo "===== 停止所有服务 ====="
docker-compose down

echo "===== 停止完成！====="

5. 给脚本添加执行权限

chmod +x deploy.sh stop.sh

四、部署操作

1. 准备前端文件

将你的前端应用包（如tong-jqfx-ui、tong-empower-dash-ui等）解压到nginx/html目录下，Nginx会自动挂载并访问。

2. 替换Java应用镜像

将docker-compose.yml中<你的私有镜像仓库>/tong-admin:latest等替换为你实际的Java应用镜像地址（可从Jenkins/CI构建后推送到私有仓库）。

3. 执行一键部署

./deploy.sh

4. 验证部署

# 查看所有服务状态
docker-compose ps

# 查看某个服务日志（如nacos）
docker-compose logs -f nacos

# 进入容器调试（如postgres）
docker exec -it tong-postgres psql -U postgres

---

总结

1. 基于Docker Compose 实现单节点一键部署，适配你所有组件的单节点要求，通过docker-compose up/down实现一键启停；
2. 自定义PostgreSQL镜像解决PostGIS、ParadeDB插件集成问题，其他组件直接使用官方/社区镜像降低维护成本；
3. 通过数据卷挂载 实现所有服务的数据持久化，Nginx通过挂载html目录实现前端应用外挂；
4. 一键脚本封装了镜像构建、服务启动、状态检查流程，只需执行./deploy.sh即可完成全量部署。

扩展建议

• 生产环境可添加docker-compose.yml的restart: always确保服务异常重启；
• 敏感配置（如密码）可通过Docker Secret或环境变量文件（.env）管理，避免硬编码；
• 若后续需要多节点部署，可平滑迁移到Kubernetes（K8s），只需将Compose配置转为K8s的Deployment/Service配置。