首页 > 网站技巧 > 服务器 > 云和虚拟化 > docker > Docker搭建本地开发环境

使用Docker搭建本地开发环境的详细指南

2025-04-30 10:37:48 作者：小宝哥Code

这篇文章主要介绍了使用Docker搭建本地开发环境的详细指南,涵盖了从基础Docker准备到多容器管理、安全强化等各个方面,通过使用Docker,可以确保开发环境的一致性、可移植性和可版本控制,文中通过代码介绍的非常详细,需要的朋友可以参考下

使用 Docker 搭建本地开发环境

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

1. Docker 基础准备

安装 Docker

Windows: 安装 Docker Desktop for Windows
macOS: 安装 Docker Desktop for Mac

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

环境配置文件化

创建多环境配置：

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

启动生产环境：

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

总结

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

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

关键最佳实践：

使用命名卷而非匿名卷保存数据
配置环境变量以适应不同场景
为容器命名以便于管理
将常用命令添加到 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:

使用小贴士

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

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

保持环境一致：将 Docker 配置文件纳入版本控制，确保团队所有成员使用相同环境
优化构建速度：
- 利用多阶段构建
- 使用 .dockerignore 排除不需要的文件
- 优化层缓存
环境变量管理：
- 使用 .env 文件管理环境变量
- 在代码存储库中保留 .env.example 作为模板
持久化管理：
- 为持久化数据创建命名卷
- 定期备份重要卷
- 考虑将数据卷挂载到主机目录以便于备份

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

总结

到此这篇关于使用Docker搭建本地开发环境的文章就介绍到这了,更多相关Docker搭建本地开发环境内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

使用Docker搭建本地开发环境的详细指南