最新资讯

使用 Docker 搭建本地开发环境

Docker 容器化技术让开发环境的搭建变得快速、一致且可移植。以下是使用 Docker 快速搭建各类开发环境的详细指南。

1. Docker 基础准备

安装 Docker

1. Windows: 安装 Docker Desktop for Windows
2. macOS: 安装 Docker Desktop for Mac
3. Linux:

   curl -fsSL https://get.docker.com -o get-docker.sh
   sudo sh get-docker.sh
   

Docker Compose 安装

最新版 Docker Desktop 已包含 Docker Compose。如需单独安装：

sudo curl -L "https://github.com/docker/compose/releases/download/v2.23.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

2. 通用开发环境模板

创建基础 docker-compose.yml

在项目根目录创建 docker-compose.yml：

version: '3.8'

services:
  # 这里会添加各种服务
  
volumes:
  # 持久化数据卷
  
networks:
  # 自定义网络
  app-network:
    driver: bridge

3. Web 开发环境

Node.js 环境

services:
  node-app:
    image: node:18
    container_name: node-dev
    working_dir: /app
    volumes:
      - ./:/app
      - node_modules:/app/node_modules
    ports:
      - "3000:3000"
    command: sh -c "npm install && npm start"
    environment:
      - NODE_ENV=development

volumes:
  node_modules:

LAMP 环境 (Linux + Apache + MySQL + PHP)

services:
  webserver:
    image: php:8.2-apache
    container_name: php-apache
    volumes:
      - ./src:/var/www/html
    ports:
      - "80:80"
    depends_on:
      - db
      
  db:
    image: mysql:8.0
    container_name: mysql
    volumes:
      - mysql_data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: myapp
      MYSQL_USER: user
      MYSQL_PASSWORD: password
    ports:
      - "3306:3306"
      
  phpmyadmin:
    image: phpmyadmin/phpmyadmin
    container_name: phpmyadmin
    ports:
      - "8080:80"
    environment:
      PMA_HOST: db
    depends_on:
      - db

volumes:
  mysql_data:

MERN 环境 (MongoDB + Express + React + Node.js)

services:
  backend:
    image: node:18
    container_name: express-backend
    working_dir: /app/backend
    volumes:
      - ./backend:/app/backend
    ports:
      - "5000:5000"
    command: sh -c "npm install && npm start"
    depends_on:
      - mongo
      
  frontend:
    image: node:18
    container_name: react-frontend
    working_dir: /app/frontend
    volumes:
      - ./frontend:/app/frontend
    ports:
      - "3000:3000"
    command: sh -c "npm install && npm start"
    stdin_open: true
    
  mongo:
    image: mongo:6
    container_name: mongodb
    volumes:
      - mongo_data:/data/db
    ports:
      - "27017:27017"
    environment:
      MONGO_INITDB_ROOT_USERNAME: root
      MONGO_INITDB_ROOT_PASSWORD: rootpassword

volumes:
  mongo_data:

4. Python 开发环境

Django 开发环境

services:
  web:
    build:
      context: .
      dockerfile: Dockerfile.dev
    container_name: django-app
    volumes:
      - ./:/app
    ports:
      - "8000:8000"
    depends_on:
      - db
    command: python manage.py runserver 0.0.0.0:8000
    
  db:
    image: postgres:15
    container_name: postgres-db
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_USER=postgres
      - POSTGRES_DB=postgres

volumes:
  postgres_data:

Dockerfile.dev:

FROM python:3.11

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

Flask + Redis 环境

services:
  web:
    build:
      context: .
      dockerfile: Dockerfile.dev
    container_name: flask-app
    volumes:
      - ./:/app
    ports:
      - "5000:5000"
    depends_on:
      - redis
    environment:
      - FLASK_APP=app.py
      - FLASK_ENV=development
    command: flask run --host=0.0.0.0
    
  redis:
    image: redis:alpine
    container_name: redis
    ports:
      - "6379:6379"

5. Java/Kotlin 开发环境

Spring Boot 环境

services:
  app:
    image: gradle:8.5-jdk17
    container_name: spring-app
    working_dir: /app
    volumes:
      - ./:/app
      - gradle-cache:/home/gradle/.gradle
    ports:
      - "8080:8080"
    command: gradle bootRun
    depends_on:
      - db
      
  db:
    image: mysql:8.0
    container_name: mysql
    volumes:
      - mysql_data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: springapp
    ports:
      - "3306:3306"

volumes:
  gradle-cache:
  mysql_data:

Android 开发环境

services:
  android:
    image: thyrlian/android-sdk:latest
    container_name: android-sdk
    working_dir: /app
    volumes:
      - ./:/app
      - gradle-cache:/root/.gradle
      - android-sdk:/opt/android-sdk
    environment:
      - JAVA_OPTS=-Xmx2048m
    
volumes:
  gradle-cache:
  android-sdk:

6. 数据科学环境

Jupyter Notebook 环境

services:
  jupyter:
    image: jupyter/datascience-notebook:latest
    container_name: jupyter-notebook
    volumes:
      - ./notebooks:/home/jovyan/work
    ports:
      - "8888:8888"
    environment:
      - JUPYTER_ENABLE_LAB=yes
    command: start-notebook.sh --NotebookApp.token='' --NotebookApp.password=''

TensorFlow 环境

services:
  tensorflow:
    image: tensorflow/tensorflow:latest-gpu-jupyter
    container_name: tensorflow-gpu
    volumes:
      - ./notebooks:/tf/notebooks
    ports:
      - "8888:8888"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

7. 数据库环境组合

多数据库开发环境

services:
  postgres:
    image: postgres:15
    container_name: postgres
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: postgres
      POSTGRES_USER: postgres
      POSTGRES_DB: testdb
    ports:
      - "5432:5432"
      
  mysql:
    image: mysql:8.0
    container_name: mysql
    volumes:
      - mysql_data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: testdb
    ports:
      - "3306:3306"
      
  redis:
    image: redis:alpine
    container_name: redis
    ports:
      - "6379:6379"
      
  mongo:
    image: mongo:6
    container_name: mongodb
    volumes:
      - mongo_data:/data/db
    ports:
      - "27017:27017"

volumes:
  postgres_data:
  mysql_data:
  mongo_data:

8. 开发工具集成

Git + VS Code Server

services:
  code-server:
    image: codercom/code-server:latest
    container_name: vscode-server
    volumes:
      - ./:/home/coder/project
      - ~/.ssh:/home/coder/.ssh
    ports:
      - "8080:8080"
    environment:
      - PASSWORD=yourpassword
    command: --auth password --host 0.0.0.0

代码质量工具

services:
  sonarqube:
    image: sonarqube:latest
    container_name: sonarqube
    volumes:
      - sonarqube_data:/opt/sonarqube/data
      - sonarqube_extensions:/opt/sonarqube/extensions
    ports:
      - "9000:9000"

volumes:
  sonarqube_data:
  sonarqube_extensions:

9. 完整全栈开发环境示例

企业级全栈开发环境

version: '3.8'

services:
  frontend:
    image: node:18
    container_name: frontend
    working_dir: /app/frontend
    volumes:
      - ./frontend:/app/frontend
      - frontend_node_modules:/app/frontend/node_modules
    ports:
      - "3000:3000"
    command: sh -c "npm install && npm start"
    
  backend:
    build:
      context: ./backend
      dockerfile: Dockerfile.dev
    container_name: backend
    volumes:
      - ./backend:/app
      - backend_node_modules:/app/node_modules
    ports:
      - "5000:5000"
    depends_on:
      - postgres
      - redis
      - mongo
    environment:
      - DB_HOST=postgres
      - DB_NAME=appdb
      - DB_USER=postgres
      - DB_PASSWORD=postgres
      - REDIS_HOST=redis
      - MONGO_URI=mongodb://mongo:27017/appdb
      
  postgres:
    image: postgres:15
    container_name: postgres
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: postgres
      POSTGRES_USER: postgres
      POSTGRES_DB: appdb
    ports:
      - "5432:5432"
      
  redis:
    image: redis:alpine
    container_name: redis
    ports:
      - "6379:6379"
      
  mongo:
    image: mongo:6
    container_name: mongodb
    volumes:
      - mongo_data:/data/db
    ports:
      - "27017:27017"
      
  mailhog:
    image: mailhog/mailhog
    container_name: mailhog
    ports:
      - "1025:1025"
      - "8025:8025"
      
  nginx:
    image: nginx:alpine
    container_name: nginx
    volumes:
      - ./nginx/default.conf:/etc/nginx/conf.d/default.conf
    ports:
      - "80:80"
    depends_on:
      - frontend
      - backend

volumes:
  frontend_node_modules:
  backend_node_modules:
  postgres_data:
  mongo_data:

10. 快速启动与使用技巧

启动环境

# 启动所有服务
docker-compose up

# 后台启动
docker-compose up -d

# 启动特定服务
docker-compose up backend db

# 重建镜像并启动
docker-compose up --build

管理技巧

# 查看容器日志
docker-compose logs -f backend

# 进入容器
docker-compose exec backend bash

# 停止环境
docker-compose down

# 停止并删除卷
docker-compose down -v

环境配置文件化

创建多环境配置：

1. docker-compose.yml - 基本配置
2. docker-compose.override.yml - 开发环境默认覆盖
3. docker-compose.prod.yml - 生产环境配置

启动生产环境：

docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d

总结

使用 Docker 搭建本地开发环境的优势：

1. 一致性 - 确保所有团队成员使用相同环境
2. 隔离性 - 不同项目的依赖不会相互干扰
3. 可移植性 - 环境可以在任何支持 Docker 的系统上运行
4. 可版本控制 - 环境配置可以通过 Git 管理
5. 快速启动 - 新成员加入只需几分钟即可完成环境搭建

关键最佳实践：

• 使用命名卷而非匿名卷保存数据
• 配置环境变量以适应不同场景
• 为容器命名以便于管理
• 将常用命令添加到 Makefile 或 npm scripts 中以简化操作

通过本指南的配置模板，您可以根据项目需求快速组合和定制适合的开发环境，大大提高开发效率。

使用 Docker 瞬间搭建本地开发环境（续）

11. 多架构开发环境

微服务架构开发环境

针对微服务开发，可以使用更复杂的 Docker Compose 配置：

version: '3.8'

services:
  # API Gateway
  gateway:
    image: nginx:alpine
    container_name: api-gateway
    volumes:
      - ./gateway/nginx.conf:/etc/nginx/conf.d/default.conf
    ports:
      - "80:80"
    depends_on:
      - auth-service
      - user-service
      - product-service
    networks:
      - microservice-network
      
  # 认证服务
  auth-service:
    build: 
      context: ./auth-service
      dockerfile: Dockerfile.dev
    container_name: auth-service
    volumes:
      - ./auth-service:/app
    ports:
      - "8001:8000"
    environment:
      - DB_HOST=auth-db
    depends_on:
      - auth-db
    networks:
      - microservice-network
      - auth-network
      
  auth-db:
    image: postgres:15
    container_name: auth-db
    volumes:
      - auth_db_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_DB=auth
    networks:
      - auth-network
      
  # 用户服务  
  user-service:
    build:
      context: ./user-service
      dockerfile: Dockerfile.dev
    container_name: user-service
    volumes:
      - ./user-service:/app
    ports:
      - "8002:8000"
    environment:
      - MONGO_URI=mongodb://user-db:27017/users
    depends_on:
      - user-db
    networks:
      - microservice-network
      - user-network
      
  user-db:
    image: mongo:6
    container_name: user-db
    volumes:
      - user_db_data:/data/db
    networks:
      - user-network
      
  # 产品服务
  product-service:
    build:
      context: ./product-service
      dockerfile: Dockerfile.dev
    container_name: product-service
    volumes:
      - ./product-service:/app
    ports:
      - "8003:8000"
    environment:
      - MYSQL_HOST=product-db
    depends_on:
      - product-db
    networks:
      - microservice-network
      - product-network
      
  product-db:
    image: mysql:8.0
    container_name: product-db
    volumes:
      - product_db_data:/var/lib/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=root
      - MYSQL_DATABASE=products
    networks:
      - product-network
      
  # 监控与日志
  prometheus:
    image: prom/prometheus
    container_name: prometheus
    volumes:
      - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"
    networks:
      - monitoring-network
      - microservice-network
      
  grafana:
    image: grafana/grafana
    container_name: grafana
    volumes:
      - grafana_data:/var/lib/grafana
    ports:
      - "3000:3000"
    depends_on:
      - prometheus
    networks:
      - monitoring-network

networks:
  microservice-network:
  auth-network:
  user-network:
  product-network:
  monitoring-network:

volumes:
  auth_db_data:
  user_db_data:
  product_db_data:
  grafana_data:

12. 云原生开发环境

Kubernetes 本地开发

使用 Kind（Kubernetes in Docker）或 Minikube 创建本地 K8s 集群：

services:
  kind:
    image: docker:dind
    container_name: kind-cluster
    privileged: true
    volumes:
      - ./k8s-config:/config
      - kind-data:/var/lib/docker
    ports:
      - "8443:8443" # Kubernetes API
    environment:
      - DOCKER_TLS_CERTDIR=""
    command: sh -c "dockerd-entrypoint.sh & sleep 5 && kind create cluster --config=/config/kind-config.yaml && tail -f /dev/null"

  kubectl:
    image: bitnami/kubectl:latest
    container_name: kubectl
    volumes:
      - ~/.kube:/root/.kube
    depends_on:
      - kind
    command: sh -c "sleep 10 && kubectl get nodes && tail -f /dev/null"

volumes:
  kind-data:

kind-config.yaml:

kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
  extraPortMappings:
  - containerPort: 30000
    hostPort: 30000
- role: worker
- role: worker

13. DevOps 工具链环境

CI/CD 本地开发环境

version: '3.8'

services:
  # Git服务器
  gitlab:
    image: gitlab/gitlab-ce:latest
    container_name: gitlab
    restart: always
    hostname: gitlab.local
    ports:
      - "80:80"
      - "443:443"
      - "22:22"
    volumes:
      - gitlab_config:/etc/gitlab
      - gitlab_logs:/var/log/gitlab
      - gitlab_data:/var/opt/gitlab
    shm_size: '256m'
    
  # CI/CD服务
  jenkins:
    image: jenkins/jenkins:lts
    container_name: jenkins
    restart: always
    privileged: true
    ports:
      - "8080:8080"
      - "50000:50000"
    volumes:
      - jenkins_home:/var/jenkins_home
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - JAVA_OPTS=-Djenkins.install.runSetupWizard=false
    
  # 制品库
  nexus:
    image: sonatype/nexus3
    container_name: nexus
    restart: always
    ports:
      - "8081:8081"
    volumes:
      - nexus_data:/nexus-data
      
  # 代码质量
  sonarqube:
    image: sonarqube:latest
    container_name: sonarqube
    restart: always
    ports:
      - "9000:9000"
    volumes:
      - sonarqube_data:/opt/sonarqube/data
      - sonarqube_extensions:/opt/sonarqube/extensions
      - sonarqube_logs:/opt/sonarqube/logs
    environment:
      - SONARQUBE_JDBC_URL=jdbc:postgresql://sonarqube-db:5432/sonar
      - SONARQUBE_JDBC_USERNAME=sonar
      - SONARQUBE_JDBC_PASSWORD=sonar
    depends_on:
      - sonarqube-db
      
  sonarqube-db:
    image: postgres:15
    container_name: sonarqube-db
    restart: always
    volumes:
      - sonarqube_db:/var/lib/postgresql/data
    environment:
      - POSTGRES_USER=sonar
      - POSTGRES_PASSWORD=sonar
      - POSTGRES_DB=sonar

volumes:
  gitlab_config:
  gitlab_logs:
  gitlab_data:
  jenkins_home:
  nexus_data:
  sonarqube_data:
  sonarqube_extensions:
  sonarqube_logs:
  sonarqube_db:

14. 前端开发专用环境

现代前端工具链

version: '3.8'

services:
  # 主应用开发环境
  app:
    image: node:18
    container_name: frontend-app
    working_dir: /app
    volumes:
      - ./:/app
      - node_modules:/app/node_modules
    ports:
      - "3000:3000" # React/Vue/Angular
      - "5173:5173" # Vite
    command: sh -c "npm install && npm run dev"
    stdin_open: true
    tty: true
    
  # 静态分析
  eslint:
    image: node:18
    container_name: eslint
    working_dir: /app
    volumes:
      - ./:/app
    command: sh -c "npm install && npm run lint"
    profiles: ["tools"]
    
  # 测试环境
  test:
    image: node:18
    container_name: test
    working_dir: /app
    volumes:
      - ./:/app
    command: sh -c "npm install && npm test"
    environment:
      - CI=true
    profiles: ["tools"]
    
  # 组件文档
  storybook:
    image: node:18
    container_name: storybook
    working_dir: /app
    volumes:
      - ./:/app
    ports:
      - "6006:6006"
    command: sh -c "npm install && npm run storybook"
    profiles: ["tools"]
    
  # API Mock服务
  mock-api:
    image: node:18
    container_name: mock-api
    working_dir: /app/mock-server
    volumes:
      - ./mock-server:/app/mock-server
    ports:
      - "3001:3001"
    command: sh -c "npm install && node server.js"

volumes:
  node_modules:

15. 嵌入式系统开发环境

IoT和嵌入式开发容器

version: '3.8'

services:
  # 嵌入式开发环境
  embedded-dev:
    image: gcc:latest
    container_name: embedded-dev
    working_dir: /workspace
    volumes:
      - ./:/workspace
    command: tail -f /dev/null
    
  # 交叉编译
  arm-toolchain:
    build:
      context: .
      dockerfile: ARM.Dockerfile
    container_name: arm-compiler
    working_dir: /workspace
    volumes:
      - ./:/workspace
    command: tail -f /dev/null
    
  # IoT模拟器
  mosquitto:
    image: eclipse-mosquitto:latest
    container_name: mqtt-broker
    ports:
      - "1883:1883"
      - "9001:9001"
    volumes:
      - ./mosquitto/config:/mosquitto/config
      - mosquitto_data:/mosquitto/data
      - mosquitto_log:/mosquitto/log
      
  # 数据采集与存储
  influxdb:
    image: influxdb:latest
    container_name: influxdb
    ports:
      - "8086:8086"
    volumes:
      - influxdb_data:/var/lib/influxdb2
    environment:
      - DOCKER_INFLUXDB_INIT_MODE=setup
      - DOCKER_INFLUXDB_INIT_USERNAME=admin
      - DOCKER_INFLUXDB_INIT_PASSWORD=password123
      - DOCKER_INFLUXDB_INIT_ORG=my-org
      - DOCKER_INFLUXDB_INIT_BUCKET=iot-data
      
  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana
    depends_on:
      - influxdb

volumes:
  mosquitto_data:
  mosquitto_log:
  influxdb_data:
  grafana_data:

ARM.Dockerfile:

FROM ubuntu:22.04

RUN apt-get update && apt-get install -y 
    build-essential 
    gcc-arm-linux-gnueabihf 
    g++-arm-linux-gnueabihf 
    cmake 
    make 
    git 
    && rm -rf /var/lib/apt/lists/*

ENV PATH="/usr/arm-linux-gnueabihf/bin:${PATH}"
WORKDIR /workspace

16. 多容器管理与优化

使用 Docker Compose 配置文件实现环境分离

基础配置 docker-compose.yml:

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    volumes:
      - ./:/app
    ports:
      - "3000:3000"

开发环境配置 docker-compose.dev.yml:

version: '3.8'

services:
  app:
    build:
      dockerfile: Dockerfile.dev
    command: npm run dev
    environment:
      - NODE_ENV=development
    volumes:
      - ./:/app
      - /app/node_modules

测试环境配置 docker-compose.test.yml:

version: '3.8'

services:
  app:
    command: npm test
    environment:
      - NODE_ENV=test

启动开发环境:

docker-compose -f docker-compose.yml -f docker-compose.dev.yml up

Makefile 简化操作

创建 Makefile:

.PHONY: dev test prod down

dev:
	docker-compose -f docker-compose.yml -f docker-compose.dev.yml up -d

test:
	docker-compose -f docker-compose.yml -f docker-compose.test.yml up --abort-on-container-exit

prod:
	docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d

down:
	docker-compose down

logs:
	docker-compose logs -f

使用: make dev 快速启动开发环境。

17. 容器资源管理

设置资源限制

services:
  app:
    image: node:18
    container_name: web-app
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 256M

使用Docker Compose轻松实现应用伸缩

# 启动3个应用实例
docker-compose up -d --scale app=3

18. 高级网络配置

创建自定义网络拓扑

version: '3.8'

services:
  frontend:
    image: nginx:alpine
    networks:
      - frontend-network
      - app-network
      
  backend:
    image: node:18
    networks:
      - app-network
      - database-network
      
  database:
    image: postgres:15
    networks:
      - database-network

networks:
  frontend-network:
    driver: bridge
    ipam:
      driver: default
      config:
        - subnet: 172.28.0.0/16
          
  app-network:
    driver: bridge
    
  database-network:
    driver: bridge
    internal: true  # 内部网络，不能访问外网

19. 安全强化

安全开发环境

version: '3.8'

services:
  secure-app:
    image: node:18
    container_name: secure-app
    user: node  # 非root用户
    read_only: true  # 只读文件系统
    cap_drop:  # 删除所有权能
      - ALL
    security_opt:
      - no-new-privileges:true
    volumes:
      - ./app:/home/node/app:ro  # 只读挂载
      - node_modules:/home/node/app/node_modules
      - tmp_data:/tmp  # 可写临时目录
    working_dir: /home/node/app
    command: node server.js
    
  # 安全扫描
  security-scan:
    image: aquasec/trivy
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: image secure-app
    profiles: ["scan"]

volumes:
  node_modules:
  tmp_data:

20. 一体化开发环境终极示例

以下是一个完整的全栈应用开发环境，包含前端、后端、数据库、缓存、监控等所有组件：

version: '3.8'

services:
  # 前端服务
  frontend:
    build:
      context: ./frontend
      dockerfile: Dockerfile.dev
    container_name: frontend
    volumes:
      - ./frontend:/app
      - /app/node_modules
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=development
      - REACT_APP_API_URL=http://localhost/api
    depends_on:
      - backend
    networks:
      - frontend-network
      - backend-network
      
  # 后端API服务
  backend:
    build:
      context: ./backend
      dockerfile: Dockerfile.dev
    container_name: backend
    volumes:
      - ./backend:/app
      - /app/node_modules
    environment:
      - NODE_ENV=development
      - DATABASE_URL=postgres://postgres:postgres@postgres:5432/app
      - REDIS_URL=redis://redis:6379
      - PORT=4000
      - JWT_SECRET=development_secret
    depends_on:
      - postgres
      - redis
    networks:
      - backend-network
      - db-network
      
  # 网关
  nginx:
    image: nginx:alpine
    container_name: nginx
    volumes:
      - ./nginx/default.dev.conf:/etc/nginx/conf.d/default.conf
    ports:
      - "80:80"
    depends_on:
      - frontend
      - backend
    networks:
      - frontend-network
      - backend-network
      
  # 数据库
  postgres:
    image: postgres:15
    container_name: postgres
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./init-scripts:/docker-entrypoint-initdb.d
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_DB=app
    ports:
      - "5432:5432"
    networks:
      - db-network
      
  # 缓存
  redis:
    image: redis:alpine
    container_name: redis
    volumes:
      - redis_data:/data
    ports:
      - "6379:6379"
    networks:
      - db-network
      
  # 数据库管理工具
  pgadmin:
    image: dpage/pgadmin4
    container_name: pgadmin
    environment:
      - PGADMIN_DEFAULT_EMAIL=admin@example.com
      - PGADMIN_DEFAULT_PASSWORD=admin
    ports:
      - "5050:80"
    depends_on:
      - postgres
    networks:
      - db-network
      
  # 消息队列
  rabbitmq:
    image: rabbitmq:3-management
    container_name: rabbitmq
    volumes:
      - rabbitmq_data:/var/lib/rabbitmq
    ports:
      - "5672:5672"
      - "15672:15672"
    networks:
      - backend-network
      
  # 搜索引擎
  elasticsearch:
    image: elasticsearch:8.6.2
    container_name: elasticsearch
    volumes:
      - elasticsearch_data:/usr/share/elasticsearch/data
    ports:
      - "9200:9200"
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
    networks:
      - db-network
      
  # 监控
  prometheus:
    image: prom/prometheus
    container_name: prometheus
    volumes:
      - ./prometheus:/etc/prometheus
      - prometheus_data:/prometheus
    ports:
      - "9090:9090"
    networks:
      - monitoring-network
      - backend-network
      
  grafana:
    image: grafana/grafana
    container_name: grafana
    volumes:
      - grafana_data:/var/lib/grafana
    ports:
      - "3030:3000"
    depends_on:
      - prometheus
    networks:
      - monitoring-network
      
  # 日志聚合
  loki:
    image: grafana/loki
    container_name: loki
    ports:
      - "3100:3100"
    networks:
      - monitoring-network
      
  promtail:
    image: grafana/promtail
    container_name: promtail
    volumes:
      - ./logs:/var/log
      - ./promtail:/etc/promtail
    command: -config.file=/etc/promtail/config.yml
    networks:
      - monitoring-network
      
  # 邮件测试
  mailhog:
    image: mailhog/mailhog
    container_name: mailhog
    ports:
      - "1025:1025"
      - "8025:8025"
    networks:
      - backend-network

networks:
  frontend-network:
  backend-network:
  db-network:
  monitoring-network:

volumes:
  postgres_data:
  redis_data:
  rabbitmq_data:
  elasticsearch_data:
  prometheus_data:
  grafana_data:

使用小贴士

1. 启动项目：新克隆项目后立即能启动开发环境

   git clone your-project-url
   cd your-project
   docker-compose up -d
   

2. 保持环境一致：将 Docker 配置文件纳入版本控制，确保团队所有成员使用相同环境

3. 优化构建速度：

   • 利用多阶段构建
   • 使用 .dockerignore 排除不需要的文件
   • 优化层缓存

4. 环境变量管理：

   • 使用 .env 文件管理环境变量
   • 在代码存储库中保留 .env.example 作为模板

5. 持久化管理：

   • 为持久化数据创建命名卷
   • 定期备份重要卷
   • 考虑将数据卷挂载到主机目录以便于备份

通过 Docker 构建的开发环境为开发者提供了极大的便利，不仅确保了环境的一致性与可重现性，还大幅降低了配置时间，让团队成员可以专注于代码开发而非环境配置。不论是简单的单一技术栈应用还是复杂的微服务架构，Docker 都能提供快速、可靠的开发环境搭建方案。