核心概念

概念关系流程

镜像与仓库交互

docker pull 从仓库拉取镜像 → docker run 从镜像启动容器 → docker push 推送镜像到仓库

概念详解

docker pull nginx:alpine

docker run -d -p 80:80 nginx

docker push user/image:tag

镜像分层结构

每层只读，容器运行时添加可写层（Copy-on-Write）

Dockerfile

Dockerfile 是定义镜像构建过程的文本文件，包含一系列指令用于构建 Docker 镜像。

基础示例

# Node.js 应用
FROM node:20-alpine

WORKDIR /app

COPY package*.json ./
RUN npm ci --only=production

COPY . .

EXPOSE 3000

CMD ["node", "server.js"]

多阶段构建

多阶段构建可以显著减小最终镜像大小，分离构建环境和运行环境。

# 构建阶段
FROM node:20-alpine AS builder
WORKDIR /app
COPY . .
RUN npm ci && npm run build

# 生产阶段
FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
EXPOSE 3000
CMD ["node", "dist/server.js"]

完整指令列表

CMD vs ENTRYPOINT

# 组合使用示例
ENTRYPOINT ["node"]
CMD ["app.js"]

# docker run myapp        → node app.js
# docker run myapp server.js → node server.js

常犯错误

FROM node:latest  # 不推荐

FROM node:20-alpine  # 推荐

COPY . .
RUN npm install  # 任何文件变化都会重新执行

COPY package*.json ./
RUN npm install
COPY . .  # 只在代码变化时才重新复制

FROM node:20-alpine
# 默认 root 用户
CMD ["node", "app.js"]

FROM node:20-alpine
RUN addgroup -g 1001 app && \
    adduser -u 1001 -G app user
USER user
CMD ["node", "app.js"]

FROM node:20  # Debian 基础镜像 ~900MB
RUN npm install

FROM node:20-alpine  # Alpine ~170MB
RUN npm install

RUN apk add --no-cache git
RUN apk add --no-cache curl
RUN apk add --no-cache vim

RUN apk add --no-cache \
    git curl vim

COPY . .  # 复制所有文件

# .dockerignore
node_modules
.git
*.md
.env

最佳实践清单

# 1. 使用特定版本的基础镜像
FROM node:20-alpine3.19

# 2. 设置工作目录
WORKDIR /app

# 3. 先复制依赖文件，利用缓存
COPY package*.json ./
RUN npm ci --only=production

# 4. 再复制源代码
COPY . .

# 5. 创建非 root 用户
RUN addgroup -g 1001 -S appgroup && \
    adduser -S appuser -u 1001 -G appgroup

# 6. 设置环境变量
ENV NODE_ENV=production

# 7. 声明端口
EXPOSE 3000

# 8. 切换用户
USER appuser

# 9. 健康检查
HEALTHCHECK --interval=30s --timeout=3s \
  CMD wget -q --spider http://localhost:3000/health || exit 1

# 10. 设置启动命令
CMD ["node", "server.js"]

Docker Compose

Docker Compose 是定义和运行多容器应用的工具，使用 YAML 文件配置服务、网络和数据卷。

服务架构示意

服务启动顺序

配置文件结构

基本结构

# docker-compose.yml 基本结构
version: "3.8"  # 可选，新版本已不需要

services:       # 定义服务
  webapp:
    # 服务配置...

networks:       # 定义网络（可选）
  frontend:

volumes:        # 定义数据卷（可选）
  db-data:

configs:        # 定义配置（可选）
  my-config:

secrets:        # 定义机密（可选）
  db-password:

完整示例

services:
  web:
    build:
      context: .
      dockerfile: Dockerfile
      args:
        - NODE_ENV=production
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/myapp
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - frontend
      - backend
    volumes:
      - ./logs:/app/logs
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "wget", "-q", "--spider", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
    deploy:
      resources:
        limits:
          cpus: '1'
          memory: 512M

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - db-data:/var/lib/postgresql/data
    networks:
      - backend
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U user -d myapp"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes
    volumes:
      - redis-data:/data
    networks:
      - backend
    restart: unless-stopped

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    internal: true  # 内部网络，外部无法访问

volumes:
  db-data:
  redis-data:

常用命令

# 服务管理
docker compose up -d              # 后台启动所有服务
docker compose up -d --build      # 重建镜像后启动
docker compose up -d web db       # 只启动指定服务
docker compose down               # 停止并删除容器、网络
docker compose down -v            # 同时删除数据卷
docker compose down --rmi all     # 同时删除镜像

# 查看状态
docker compose ps                 # 查看服务状态
docker compose logs               # 查看所有日志
docker compose logs -f web        # 实时查看 web 服务日志
docker compose top                # 查看进程

# 服务操作
docker compose start web          # 启动服务
docker compose stop web           # 停止服务
docker compose restart web        # 重启服务
docker compose pause web          # 暂停服务
docker compose unpause web        # 恢复服务

# 执行命令
docker compose exec web sh        # 进入容器
docker compose exec db psql -U user myapp  # 在 db 容器执行命令
docker compose run --rm web npm test       # 一次性运行命令

# 其他
docker compose config             # 验证配置文件
docker compose config --services  # 列出所有服务
docker compose pull               # 拉取所有镜像
docker compose push               # 推送所有镜像

常用场景

场景 1：开发环境

services:
  app:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - .:/app           # 挂载代码目录，支持热重载
      - /app/node_modules  # 防止本地 node_modules 覆盖
    environment:
      - NODE_ENV=development
      - CHOKIDAR_USEPOLLING=true  # 支持文件监听
    command: npm run dev

  db:
    image: postgres:16-alpine
    ports:
      - "5432:5432"     # 暴露端口便于本地连接
    environment:
      POSTGRES_DB: dev
      POSTGRES_USER: dev
      POSTGRES_PASSWORD: dev
    volumes:
      - dev-data:/var/lib/postgresql/data

volumes:
  dev-data:

场景 2：微服务架构

services:
  gateway:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - api
      - web
    networks:
      - frontend

  api:
    build: ./api
    environment:
      - DATABASE_URL=postgres://db:5432/myapp
    depends_on:
      - db
      - redis
    networks:
      - frontend
      - backend

  web:
    build: ./web
    networks:
      - frontend

  db:
    image: postgres:16-alpine
    volumes:
      - db-data:/var/lib/postgresql/data
    networks:
      - backend

  redis:
    image: redis:7-alpine
    networks:
      - backend

networks:
  frontend:
  backend:
    internal: true  # 只有内部服务可访问

场景 3：CI/CD 测试

services:
  app:
    build: .
    depends_on:
      db:
        condition: service_healthy
    environment:
      - DATABASE_URL=postgres://test:test@db:5432/test
    command: npm test

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: test
      POSTGRES_USER: test
      POSTGRES_PASSWORD: test
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U test"]
      interval: 5s
      timeout: 5s
      retries: 10
    tmpfs:
      - /var/lib/postgresql/data  # 使用内存存储，测试更快

场景 4：多环境配置

# docker-compose.yml（基础配置）
services:
  web:
    image: myapp
    ports:
      - "3000:3000"

# docker-compose.override.yml（开发环境，自动加载）
services:
  web:
    build: .
    volumes:
      - .:/app
    environment:
      - DEBUG=true

# docker-compose.prod.yml（生产环境）
services:
  web:
    image: myapp:latest
    restart: always
    deploy:
      replicas: 3

# 使用方式：
# 开发环境: docker compose up
# 生产环境: docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d

常见错误

ports:
  - "80:80"  # 本地 80 端口已被占用

ports:
  - "8080:80"  # 使用其他本地端口

depends_on:
  - db  # 只等待容器启动，不等待服务就绪

depends_on:
  db:
    condition: service_healthy  # 等待健康检查通过

docker compose down  # 默认不删除卷

# 删除所有数据（危险操作）
docker compose down -v

# 生产环境建议定期备份
docker compose exec db pg_dump ...

environment:
  - DB_PASS=$DB_PASSWORD  # 变量未定义时为空

# 使用 .env 文件
# .env
DB_PASSWORD=secret

# 或设置默认值
environment:
  - DB_PASS=${DB_PASSWORD:-default}

version: "2"  # 旧版格式

version: "3.8"  # 使用最新格式
# 或直接省略 version（新版本推荐）

# 服务 A 无法访问服务 B

# 确保服务在同一网络
services:
  a:
    networks:
      - mynet
  b:
    networks:
      - mynet
networks:
  mynet:

配置文件最佳实践

# 1. 使用 .env 文件管理环境变量
# .env
COMPOSE_PROJECT_NAME=myapp
POSTGRES_PASSWORD=secret
API_KEY=xxx

# 2. 使用命名卷而非绑定挂载（生产环境）
volumes:
  db-data:  # 命名卷

# 3. 限制资源
deploy:
  resources:
    limits:
      cpus: '0.5'
      memory: 256M

# 4. 设置重启策略
restart: unless-stopped

# 5. 使用健康检查
healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost/health"]
  interval: 30s
  timeout: 10s
  retries: 3

# 6. 使用网络隔离
networks:
  frontend:
  backend:
    internal: true

# 7. 使用 secrets 管理敏感数据
secrets:
  db_password:
    file: ./secrets/db_password.txt

服务配置指令详解

变量替换

# .env 文件
DB_HOST=db
DB_PORT=5432
DB_NAME=myapp
DB_USER=${DB_USER:-admin}      # 默认值
DB_PASS=${DB_PASS:?密码未设置}  # 必须设置，否则报错

# docker-compose.yml
services:
  app:
    environment:
      - DATABASE_URL=postgres://${DB_USER}:${DB_PASS}@${DB_HOST}:${DB_PORT}/${DB_NAME}
    ports:
      - "${APP_PORT:-3000}:3000"  # 使用默认值

# 使用方式
DB_PASS=secret docker compose up -d
# 或
cp .env.example .env && docker compose up -d

Profiles 功能

Profiles 允许按需启动不同服务组合：

services:
  web:
    image: nginx
    ports:
      - "80:80"

  # 只在 debug profile 启用
  debug:
    image: busybox
    command: tail -f /dev/null
    profiles:
      - debug

  # 只在 test profile 启用
  selenium:
    image: selenium/standalone-chrome
    profiles:
      - test

  # 多个 profile
  adminer:
    image: adminer
    profiles:
      - debug
      - admin

# 使用方式
docker compose up -d                    # 只启动 web
docker compose --profile debug up -d    # 启动 web + debug + adminer
docker compose --profile test up -d     # 启动 web + selenium
docker compose --profile debug --profile test up -d  # 启动全部

更多应用场景

场景 5：负载均衡

services:
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - web

  web:
    image: myapp:latest
    deploy:
      replicas: 3  # 运行 3 个副本
    environment:
      - NODE_ENV=production
    networks:
      - app-network

networks:
  app-network:

场景 6：日志收集

services:
  app:
    image: myapp
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"
    depends_on:
      - elasticsearch
      - logstash

  elasticsearch:
    image: elasticsearch:8-alpine
    environment:
      - discovery.type=single-node
    volumes:
      - es-data:/usr/share/elasticsearch/data

  logstash:
    image: logstash:8-alpine
    volumes:
      - ./logstash.conf:/usr/share/logstash/pipeline/logstash.conf

  kibana:
    image: kibana:8-alpine
    ports:
      - "5601:5601"
    depends_on:
      - elasticsearch

volumes:
  es-data:

场景 7：消息队列

services:
  producer:
    build: ./producer
    environment:
      - RABBITMQ_HOST=rabbitmq
    depends_on:
      rabbitmq:
        condition: service_healthy

  consumer:
    build: ./consumer
    environment:
      - RABBITMQ_HOST=rabbitmq
    depends_on:
      rabbitmq:
        condition: service_healthy
    deploy:
      replicas: 3  # 多个消费者

  rabbitmq:
    image: rabbitmq:3-management-alpine
    ports:
      - "5672:5672"   # AMQP
      - "15672:15672" # 管理界面
    healthcheck:
      test: ["CMD", "rabbitmqctl", "status"]
      interval: 10s
      timeout: 10s
      retries: 5
    volumes:
      - rabbit-data:/var/lib/rabbitmq

volumes:
  rabbit-data:

场景 8：数据库主从复制

services:
  pg-master:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_REPLICATION_USER: replicator
      POSTGRES_REPLICATION_PASSWORD: repl_pass
    volumes:
      - master-data:/var/lib/postgresql/data
    command: >
      postgres
      -c wal_level=replica
      -c max_wal_senders=3
      -c max_replication_slots=3

  pg-replica:
    image: postgres:16-alpine
    environment:
      PGUSER: replicator
      PGPASSWORD: repl_pass
      PGHOST: pg-master
    depends_on:
      - pg-master
    volumes:
      - replica-data:/var/lib/postgresql/data

volumes:
  master-data:
  replica-data:

扩展和继承

# 使用 extends 继承配置（已弃用，推荐使用 YAML 锚点）
# docker-compose.yml
x-common-config: &common-config
  restart: unless-stopped
  networks:
    - app-network
  logging:
    driver: json-file
    options:
      max-size: "10m"

services:
  api:
    <<: *common-config
    image: myapp:api
    ports:
      - "3000:3000"

  worker:
    <<: *common-config
    image: myapp:worker
    command: node worker.js

networks:
  app-network:

网络

Docker 提供多种网络模式，满足不同应用场景：

网络类型

网络架构示意图

常用命令

# 查看网络列表
docker network ls

# 创建自定义网络
docker network create mynet

# 创建指定类型的网络
docker network create -d bridge mynet
docker network create -d host myhost

# 查看网络详情
docker network inspect mynet

# 连接容器到网络
docker network connect mynet container_name

# 断开容器网络
docker network disconnect mynet container_name

# 删除网络
docker network rm mynet

应用场景示例

场景 1：微服务通信

# 创建应用网络
docker network create app-network

# 启动服务，同一网络内可通过服务名访问
docker run -d --name api --network app-network myapi
docker run -d --name web --network app-network nginx
# web 容器可通过 http://api:8080 访问 API

场景 2：隔离不同环境

# 开发环境网络
docker network create dev-network

# 测试环境网络
docker network create test-network

# 开发和测试环境完全隔离
docker run -d --name dev-db --network dev-network postgres
docker run -d --name test-db --network test-network postgres

场景 3：DNS 解析

# 同一网络内的容器自动获得 DNS 解析
docker run -d --name redis --network mynet redis
docker run -d --name app --network mynet myapp

# app 容器内可直接使用主机名连接
# redis://redis:6379

容器与外界通讯过程

理解容器如何与外界通讯是掌握 Docker 网络的关键。

通讯架构图

┌─────────────────────────────────────────────────────────────────┐
│                         外部网络（互联网）                         │
└─────────────────────────────────────────────────────────────────┘
                              ↑↓
┌─────────────────────────────────────────────────────────────────┐
│                        宿主机 (Host)                              │
│  ┌──────────────────────────────────────────────────────────┐   │
│  │                    Docker 网桥 (docker0)                   │   │
│  │                    172.17.0.1 (网关)                       │   │
│  └──────────────────────────────────────────────────────────┘   │
│         ↑                    ↑                    ↑              │
│    ┌────────┐           ┌────────┐           ┌────────┐         │
│    │ 容器 A  │           │ 容器 B  │           │ 容器 C  │         │
│    │172.17.0.2│          │172.17.0.3│          │172.17.0.4│        │
│    │ 端口 80 │           │ 端口 3000│          │ 端口 5432│        │
│    └────────┘           └────────┘           └────────┘         │
│         ↑                    ↑                    ↑              │
│    主机端口                主机端口              主机端口         │
│    8080→80               3000→3000            5432→5432         │
└─────────────────────────────────────────────────────────────────┘

1. 容器访问外部网络

# 容器访问互联网的过程：
# 1. 容器发送请求（源 IP: 172.17.0.2）
# 2. 请求经过 docker0 网桥
# 3. 通过 NAT（网络地址转换）转换为宿主机 IP
# 4. 请求发送到外部网络
# 5. 响应按原路返回

# 示例：容器内访问外部 API
docker run --rm alpine wget -qO- https://api.github.com

# 查看容器的网络配置
docker run --rm alpine ip addr show
# eth0: 172.17.0.x → docker0 网桥

# 查看宿主机的 iptables NAT 规则
sudo iptables -t nat -L -n

2. 外部访问容器（端口映射）

# 端口映射原理：
# 外部请求 → 宿主机端口 → iptables 转发 → 容器端口

# 映射单个端口
docker run -d -p 8080:80 nginx
# 宿主机 8080 → 容器 80

# 映射多个端口
docker run -d -p 8080:80 -p 8443:443 nginx

# 指定 IP 绑定
docker run -d -p 127.0.0.1:8080:80 nginx
# 只允许本地访问

# 映射 UDP 端口
docker run -d -p 53:53/udp dns-server

# 查看端口映射
docker port container_name
docker ps --format "table {{.Names}}\t{{.Ports}}"

# 验证端口监听
netstat -tlnp | grep 8080
# 或
lsof -i :8080

3. 容器间通讯

# 同一 bridge 网络内的容器通讯：

# 方式 1：通过 IP 地址
# 容器 A (172.17.0.2) → 容器 B (172.17.0.3)
curl http://172.17.0.3:3000

# 方式 2：通过容器名称（需要自定义网络）
docker network create mynet
docker run -d --name db --network mynet postgres
docker run -d --name app --network mynet myapp

# app 容器可以通过名称访问 db
# postgresql://db:5432/mydb

# 查看网络内容器的 IP
docker network inspect mynet

# 进入容器测试连通性
docker exec -it app ping db
docker exec -it app curl http://db:5432

4. 不同网络模式对比

5. 网络通讯完整示例

# 场景：Web 应用 + 数据库 + Redis

# 1. 创建网络
docker network create app-network

# 2. 启动数据库（内部端口，不映射到外部）
docker run -d \
  --name db \
  --network app-network \
  -e POSTGRES_PASSWORD=secret \
  postgres:16-alpine
# 数据库只能在网络内部访问，外部无法直接连接

# 3. 启动 Redis（内部端口）
docker run -d \
  --name redis \
  --network app-network \
  redis:7-alpine

# 4. 启动 Web 应用（映射端口到外部）
docker run -d \
  --name web \
  --network app-network \
  -p 3000:3000 \
  -e DATABASE_URL=postgres://postgres:secret@db:5432 \
  -e REDIS_URL=redis://redis:6379 \
  myapp

# 通讯路径：
# 外部用户 → 宿主机:3000 → web 容器:3000
# web 容器 → db:5432（内部 DNS 解析）
# web 容器 → redis:6379（内部 DNS 解析）

# 验证通讯
docker exec -it web ping db      # Web → DB
docker exec -it web ping redis    # Web → Redis
curl http://localhost:3000        # 外部 → Web

6. 常见网络问题排查

# 问题 1：容器无法访问外部网络
# 检查 DNS
docker run --rm alpine nslookup google.com
docker run --rm alpine ping -c 3 8.8.8.8

# 问题 2：外部无法访问容器端口
# 检查端口映射
docker port container_name
# 检查防火墙
sudo ufw status
sudo iptables -L -n | grep 8080

# 问题 3：容器间无法通讯
# 确认在同一网络
docker network inspect mynet
# 检查容器网络配置
docker exec container_name ip addr show

# 问题 4：DNS 解析失败
# 使用自定义 DNS
docker run --dns 8.8.8.8 myapp

# 问题 5：端口冲突
# 查看端口占用
lsof -i :8080
netstat -tlnp | grep 8080

企业内部 Registry

Docker Registry 是存储和分发 Docker 镜像的服务，企业可自建私有 Registry 来管理内部镜像。

为什么需要私有 Registry？

• 安全合规：敏感镜像不上传公网，数据完全自主可控
• 访问速度：内网拉取镜像更快，不占用公网带宽
• 成本控制：避免 Docker Hub 拉取次数限制和付费
• 版本管理：统一管理内部应用的镜像版本

快速搭建 Registry

# 1. 最简单的启动方式
docker run -d \
  --name registry \
  -p 5000:5000 \
  -v registry-data:/var/lib/registry \
  --restart always \
  registry:2

# 2. 使用 Docker Compose（推荐）
# docker-compose.yml
services:
  registry:
    image: registry:2
    ports:
      - "5000:5000"
    environment:
      REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY: /var/lib/registry
    volumes:
      - registry-data:/var/lib/registry
    restart: always

volumes:
  registry-data:

推送和拉取镜像

# 1. 标记镜像指向私有仓库
docker tag myapp:v1 localhost:5000/myapp:v1

# 2. 推送镜像
docker push localhost:5000/myapp:v1

# 3. 拉取镜像
docker pull localhost:5000/myapp:v1

# 4. 查看仓库中的镜像
curl http://localhost:5000/v2/_catalog
curl http://localhost:5000/v2/myapp/tags/list

配置 HTTPS（生产必需）

# 方案 1：使用 Nginx 反向代理 + Let's Encrypt

# docker-compose.yml
services:
  registry:
    image: registry:2
    volumes:
      - registry-data:/var/lib/registry
    restart: always

  nginx:
    image: nginx:alpine
    ports:
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./certs:/etc/nginx/certs:ro
    depends_on:
      - registry

volumes:
  registry-data:

# nginx.conf 示例
# server {
#     listen 443 ssl;
#     server_name registry.example.com;
#     ssl_certificate /etc/nginx/certs/fullchain.pem;
#     ssl_certificate_key /etc/nginx/certs/privkey.pem;
#     client_max_body_size 0;  # 不限制上传大小
#     location / {
#         proxy_pass http://registry:5000;
#     }
# }

配置认证

# 1. 创建用户密码文件
docker run --rm \
  --entrypoint htpasswd \
  httpd:2 -Bbn admin password123 > htpasswd

# 2. 启动带认证的 Registry
docker run -d \
  --name registry \
  -p 5000:5000 \
  -v registry-data:/var/lib/registry \
  -v $(pwd)/htpasswd:/etc/docker/registry/htpasswd \
  -e REGISTRY_AUTH=htpasswd \
  -e REGISTRY_AUTH_HTPASSWD_REALM="Registry Realm" \
  -e REGISTRY_AUTH_HTPASSWD_PATH=/etc/docker/registry/htpasswd \
  registry:2

# 3. 登录私有仓库
docker login localhost:5000
# 输入用户名和密码

# 4. 推送镜像（需要先登录）
docker push localhost:5000/myapp:v1

# 5. 退出登录
docker logout localhost:5000

完整生产配置

# docker-compose.yml - 生产环境完整配置
services:
  registry:
    image: registry:2
    volumes:
      - registry-data:/var/lib/registry
      - ./config.yml:/etc/docker/registry/config.yml:ro
    environment:
      - REGISTRY_HTTP_ADDR=0.0.0.0:5000
      - REGISTRY_LOG_LEVEL=info
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.registry.rule=Host(`registry.example.com`)"
      - "traefik.http.routers.registry.tls.certresolver=letsencrypt"
    restart: always
    healthcheck:
      test: ["CMD", "wget", "-q", "--spider", "http://localhost:5000/v2/"]
      interval: 30s
      timeout: 10s
      retries: 3

  # 可选：Web 管理界面
  registry-ui:
    image: joxit/docker-registry-ui:latest
    ports:
      - "8080:80"
    environment:
      - REGISTRY_TITLE=My Private Registry
      - REGISTRY_URL=http://registry:5000
      - DELETE_IMAGES=true
      - SHOW_CONTENT_DIGEST=true
    depends_on:
      - registry

  # 可选：镜像清理服务
  registry-gc:
    image: registry:2
    entrypoint: ["bin/registry", "garbage-collect", "/etc/docker/registry/config.yml"]
    volumes:
      - registry-data:/var/lib/registry
      - ./config.yml:/etc/docker/registry/config.yml:ro

volumes:
  registry-data:

客户端配置

# 配置 Docker 客户端信任私有仓库

# 1. 配置 insecure-registry（仅用于 HTTP，不推荐生产）
# /etc/docker/daemon.json
{
  "insecure-registries": ["registry.example.com:5000"]
}

# 重启 Docker
sudo systemctl restart docker

# 2. 对于自签名证书，需要信任证书
sudo mkdir -p /etc/docker/certs.d/registry.example.com
sudo cp ca.crt /etc/docker/certs.d/registry.example.com/

# 3. 企业环境建议使用企业 CA 证书
# 或使用 Let's Encrypt 等受信任的证书

镜像管理操作

# 查看所有仓库
curl -u admin:password123 http://localhost:5000/v2/_catalog

# 查看某镜像的所有标签
curl -u admin:password123 http://localhost:5000/v2/myapp/tags/list

# 删除镜像（需要配置 DELETE_IMAGES=true）
curl -X DELETE -u admin:password123 \
  http://localhost:5000/v2/myapp/manifests/sha256:xxx

# 获取镜像 digest
curl -I -u admin:password123 \
  -H "Accept: application/vnd.docker.distribution.manifest.v2+json" \
  http://localhost:5000/v2/myapp/manifests/v1

# 清理未引用的层（垃圾回收）
docker exec registry bin/registry garbage-collect /etc/docker/registry/config.yml

备份与迁移

# 备份 Registry 数据
docker run --rm \
  -v registry-data:/data \
  -v $(pwd)/backup:/backup \
  alpine tar czf /backup/registry-backup.tar.gz -C /data .

# 恢复数据
docker run --rm \
  -v registry-data:/data \
  -v $(pwd)/backup:/backup \
  alpine sh -c "cd /data && tar xzf /backup/registry-backup.tar.gz"

# 迁移到新服务器
# 1. 停止原 Registry
docker stop registry

# 2. 打包数据卷
docker run --rm \
  -v registry-data:/data \
  -v $(pwd):/backup \
  alpine tar czf /backup/registry-data.tar.gz -C /data .

# 3. 复制到新服务器并解压
scp registry-data.tar.gz user@new-server:/tmp/
ssh user@new-server
docker volume create registry-data
docker run --rm \
  -v registry-data:/data \
  -v /tmp:/backup \
  alpine sh -c "cd /data && tar xzf /backup/registry-data.tar.gz"

Harbor - 企业级 Registry

对于大型企业，推荐使用 Harbor，它提供了更丰富的功能：

# Harbor 功能特点：
# - Web 管理界面
# - 基于角色的访问控制（RBAC）
# - 漏洞扫描（Trivy 集成）
# - 镜像签名（Notary）
# - 镜像复制（跨区域同步）
# - 垃圾回收自动化
# - 审计日志

# 快速安装 Harbor
wget https://github.com/goharbor/harbor/releases/download/v2.10.0/harbor-offline-installer-v2.10.0.tgz
tar xzf harbor-offline-installer-v2.10.0.tgz
cd harbor

# 配置 harbor.yml
cp harbor.yml.tmpl harbor.yml
# 编辑 harbor.yml，设置 hostname、密码等

# 安装
./install.sh

# 或使用 Docker Compose
docker compose -f docker-compose.yml up -d

# 访问：https://your-harbor-domain
# 默认用户名：admin
# 默认密码：Harbor12345

Registry 方案对比

安全最佳实践

RUN addgroup -g 1001 appgroup && \
    adduser -u 1001 -G appgroup appuser
USER appuser

FROM alpine:3.19
# 或使用 distroless
FROM gcr.io/distroless/static

HEALTHCHECK --interval=30s \
  CMD wget -q --spider \
  http://localhost:3000/health

Docker 周边工具

Docker 生态系统拥有丰富的周边工具，覆盖管理、监控、安全、开发等多个领域，帮助提升工作效率。

🔍 Docker Scout - 安全扫描工具

# 1. 快速查看镜像安全概况
docker scout quickview nginx:latest

# 2. 详细漏洞扫描
docker scout cves myapp:latest

# 3. 只显示高危漏洞
docker scout cves --severity HIGH,CRITICAL myapp:latest

# 4. 生成软件物料清单（SBOM）
docker scout sbom --format spdx-json --output sbom.json myapp:latest

# 5. 比较两个镜像的安全差异
docker scout compare --from myapp:v1 --to myapp:v2

# 6. 在 CI/CD 中自动阻断不安全镜像
docker scout cves --exit-code 1 --severity HIGH,CRITICAL myapp:latest

Q: 扫描结果显示很多漏洞，我该怎么办？
A: 优先修复 CRITICAL 和 HIGH 级别的漏洞，Docker Scout 会给出具体的修复建议。

Q: 每次构建都需要扫描吗？
A: 建议在 CI/CD 流程中加入自动扫描，确保不安全的镜像不会部署到生产环境。

🤖 Ask Gordon - Docker AI 助手

# 启动 Ask Gordon（需要 Docker Desktop）
docker ai

# 示例对话：
You: 帮我为 Node.js 应用写一个 Dockerfile
Gordon: 好的，这是为你生成的 Dockerfile...
[生成优化的 Dockerfile]

You: 我的容器启动后立即退出了，怎么回事？
Gordon: 让我帮你分析可能的原因...
[给出诊断建议]

You: 如何减小镜像大小？
Gordon: 这里有一些优化建议...
[列出具体的优化方法]

# 场景 1：生成 Dockerfile
"帮我为一个 Python Flask 应用创建 Dockerfile"

# 场景 2：诊断问题
"容器报错 'connection refused'，如何排查？"

# 场景 3：优化建议
"这个 Dockerfile 有什么可以优化的地方？"

# 场景 4：学习概念
"什么是多阶段构建？为什么要用它？"

📦 Dockerizer - 自动容器化工具

# 1. 安装 Dockerizer
npm install -g dockerizer

# 2. 在项目目录中初始化
cd my-project
npx dockerizer init

# Dockerizer 会：
# - 分析 package.json / requirements.txt 等依赖文件
# - 检测项目类型（Node.js / Python / Java 等）
# - 生成优化的 Dockerfile
# - 生成 docker-compose.yml（可选）

# 3. 分析现有项目
npx dockerizer analyze

# 4. 生成多阶段构建的 Dockerfile
npx dockerizer init --multi-stage

# 5. 为特定框架生成
npx dockerizer init --framework nextjs
npx dockerizer init --framework django

# Dockerizer 自动生成的 Dockerfile 示例
# 项目类型：Node.js Express

# --- 基础阶段 ---
FROM node:20-alpine AS base
WORKDIR /app

# --- 依赖阶段 ---
FROM base AS deps
COPY package*.json ./
RUN npm ci --only=production

# --- 运行阶段 ---
FROM base
COPY --from=deps /app/node_modules ./node_modules
COPY . .
EXPOSE 3000
USER node
CMD ["node", "server.js"]

🖥️ Dockge - 可视化管理界面

# 方法 1：Docker 命令（推荐）
docker run -d \
  --name dockge \
  -p 5001:5001 \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v ~/dockge/data:/app/data \
  louislam/dockge:latest

# 方法 2：Docker Compose
services:
  dockge:
    image: louislam/dockge:latest
    ports:
      - "5001:5001"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./data:/app/data
    restart: unless-stopped

# 访问界面
# 打开浏览器：http://localhost:5001

# 1. 管理 Compose 项目
# - 查看所有服务状态
# - 启动/停止/重启服务
# - 查看实时日志

# 2. 编辑 compose 文件
# - 内置 YAML 编辑器
# - 语法高亮
# - 自动补全

# 3. 容器终端
# - 直接在网页中进入容器
# - 执行命令

# 4. 资源监控
# - CPU/内存使用情况
# - 网络流量

🧠 Docker GenAI Stack - AI 应用开发栈

# 1. 克隆项目
git clone https://github.com/docker/genai-stack
cd genai-stack

# 2. 启动服务
docker compose up -d

# 3. 访问应用
# 打开浏览器：http://localhost:8501

# 包含的组件：
# - Ollama：本地运行大语言模型
# - LangChain：AI 应用开发框架
# - Neo4j：图数据库（可选）
# - Streamlit：Web 界面

# 在容器中运行 Ollama
docker exec -it ollama ollama pull llama2
docker exec -it ollama ollama run llama2

# 或者使用 Docker 直接运行 Ollama
docker run -d \
  --name ollama \
  -p 11434:11434 \
  -v ollama-data:/root/.ollama \
  ollama/ollama

# 拉取并运行模型
docker exec -it ollama ollama pull llama2
docker exec -it ollama ollama pull codellama
docker exec -it ollama ollama pull mistral

🔒 Trivy AI 增强版 - 漏洞扫描工具

# 安装 Trivy
# macOS
brew install trivy

# Windows (使用 Scoop)
scoop install trivy

# Linux
curl -sfL https://raw.githubusercontent.com/aquasecurity/trivy/main/contrib/install.sh | sh

# 基本使用
# 1. 扫描镜像
trivy image nginx:latest

# 2. 扫描本地文件系统
trivy fs .

# 3. 扫描配置文件
trivy config .

# 4. 扫描多种类型
trivy image --scanners vuln,secret,misconfig myapp:latest

# 5. 输出 JSON 格式
trivy image --format json --output report.json myapp:latest

# 6. 只显示高危漏洞
trivy image --severity HIGH,CRITICAL myapp:latest

# GitHub Actions
name: Security Scan
on: [push]
jobs:
  scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run Trivy
        uses: aquasecurity/trivy-action@master
        with:
          scan-type: 'fs'
          severity: 'HIGH,CRITICAL'
          exit-code: '1'  # 发现漏洞时失败

trivy image myapp:latest

# 输出示例：
# ┌──────────────┬───────────────┬──────────────┬─────────────┐
# │   Library    │ Vulnerability │  Severity    │   Version   │
# ├──────────────┼───────────────┼──────────────┼─────────────┤
# │ openssl      │ CVE-2024-1234 │ CRITICAL     │ 1.1.1k      │
# │ node         │ CVE-2024-5678 │ HIGH         │ 18.0.0      │
# └──────────────┴───────────────┴──────────────┴─────────────┘

# 解读：
# - CRITICAL: 必须立即修复
# - HIGH: 应尽快修复
# - MEDIUM: 计划修复
# - LOW: 可忽略

工具对比与选择指南

🖥️ 可视化管理工具

Portainer - 最流行的管理界面

# 快速启动
docker run -d \
  --name portainer \
  -p 9443:9443 \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v portainer-data:/data \
  --restart always \
  portainer/portainer-ce:latest

# 访问：https://localhost:9443
# 首次访问需要设置管理员密码

# Docker Compose 方式
services:
  portainer:
    image: portainer/portainer-ce:latest
    ports:
      - "9443:9443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - portainer-data:/data
    restart: always

volumes:
  portainer-data:

Lazydocker - 终端交互式管理

# 安装（macOS）
brew install jesseduffield/lazydocker/lazydocker

# 安装（Linux）
curl https://raw.githubusercontent.com/jesseduffield/lazydocker/master/scripts/install_update_linux.sh | bash

# 安装（Windows）
scoop install lazydocker

# 或使用 Docker 运行
docker run --rm -it \
  -v /var/run/docker.sock:/var/run/docker.sock \
  lazyteam/lazydocker

# 启动
lazydocker

# 快捷键：
# - 上/下：选择项目
# - Enter：查看详情
# - x：停止/删除
# - l：查看日志
# - s：进入容器 Shell
# - ?：帮助

ctop - 容器实时监控

# 安装（macOS）
brew install ctop

# 安装（Linux）
sudo wget https://github.com/bcicen/ctop/releases/download/v1.0.7/ctop-1.0.7-linux-amd64 -O /usr/local/bin/ctop
sudo chmod +x /usr/local/bin/ctop

# 使用 Docker 运行
docker run --rm -it \
  -v /var/run/docker.sock:/var/run/docker.sock \
  quay.io/vektorlab/ctop:latest

# 启动
ctop

# 快捷键：
# - a：切换显示所有/运行中容器
# - l：查看容器日志
# - s：进入容器 Shell
# - e：显示环境变量
# - h：帮助

🔧 开发辅助工具

Dive - 镜像分析工具

# 安装（macOS）
brew install dive

# 安装（Linux）
wget https://github.com/wagoodman/dive/releases/download/v0.12.0/dive_0.12.0_linux_amd64.deb
sudo apt install ./dive_0.12.0_linux_amd64.deb

# 分析镜像
dive nginx:alpine

# 分析本地构建的镜像
dive myapp:latest

# 在 CI 中使用
dive --ci myapp:latest

# 输出信息：
# - 每层的文件变更
# - 可能的优化建议
# - 镜像效率评分
# - 重复文件检测

Hadolint - Dockerfile 语法检查

# 安装（macOS）
brew install hadolint

# 安装（Linux）
wget -O hadolint https://github.com/hadolint/hadolint/releases/download/v2.12.0/hadolint-Linux-x86_64
chmod +x hadolint
sudo mv hadolint /usr/local/bin/

# 使用 Docker 运行
docker run --rm -i hadolint/hadolint < Dockerfile

# 检查 Dockerfile
hadolint Dockerfile

# 只显示错误（忽略警告）
hadolint --ignore DL3008 Dockerfile

# 输出 JSON 格式
hadolint -f json Dockerfile

# 常见规则：
# DL3000: 使用绝对 WORKDIR
# DL3001: 不要使用 MAINTAINER（已废弃）
# DL3003: 不要使用 WORKDIR 切换目录
# DL3004: 不要以 root 用户构建
# DL3008: 固定 apt 包版本
# DL3015: 避免使用 --no-install-recommends 以外的选项

# VS Code 集成
# 安装扩展：exiasr.hadolint

DevContainer - 开发容器化

# .devcontainer/devcontainer.json
{
  "name": "My Dev Container",
  "image": "mcr.microsoft.com/devcontainers/base:ubuntu",
  "features": {
    "ghcr.io/devcontainers/features/node:1": {
      "version": "20"
    },
    "ghcr.io/devcontainers/features/docker-in-docker:2": {}
  },
  "customizations": {
    "vscode": {
      "extensions": [
        "dbaeumer.vscode-sqlite",
        "esbenp.prettier-vscode"
      ]
    }
  },
  "forwardPorts": [3000],
  "postCreateCommand": "npm install",
  "remoteUser": "vscode"
}

# 或使用 Docker Compose
# .devcontainer/docker-compose.yml
services:
  app:
    build: 
      context: ..
      dockerfile: Dockerfile.dev
    volumes:
      - ../..:/workspaces:cached
    command: sleep infinity
    environment:
      - DATABASE_URL=postgres://db:5432/dev

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: dev
      POSTGRES_PASSWORD: dev

# VS Code 命令面板：
# Dev Containers: Reopen in Container
# Dev Containers: Rebuild Container

⚙️ 自动化工具

Watchtower - 自动更新容器

# 基本启动
docker run -d \
  --name watchtower \
  -v /var/run/docker.sock:/var/run/docker.sock \
  containrrr/watchtower

# 指定检查间隔（秒）
docker run -d \
  --name watchtower \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -e WATCHTOWER_POLL_INTERVAL=3600 \
  containrrr/watchtower

# 只监控特定容器
docker run -d \
  --name watchtower \
  -v /var/run/docker.sock:/var/run/docker.sock \
  containrrr/watchtower myapp nginx

# Docker Compose
services:
  watchtower:
    image: containrrr/watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - WATCHTOWER_POLL_INTERVAL=3600
      - WATCHTOWER_CLEANUP=true        # 删除旧镜像
      - WATCHTOWER_INCLUDE_STOPPED=true # 包括停止的容器
      - WATCHTOWER_NOTIFICATIONS=email  # 发送通知
    restart: always

# 通知配置（邮件示例）
environment:
  - WATCHTOWER_NOTIFICATIONS=email
  - WATCHTOWER_NOTIFICATION_EMAIL_FROM=sender@example.com
  - WATCHTOWER_NOTIFICATION_EMAIL_TO=admin@example.com
  - WATCHTOWER_NOTIFICATION_EMAIL_SERVER=smtp.example.com
  - WATCHTOWER_NOTIFICATION_EMAIL_SERVER_PORT=587
  - WATCHTOWER_NOTIFICATION_EMAIL_SERVER_USER=user
  - WATCHTOWER_NOTIFICATION_EMAIL_SERVER_PASSWORD=pass

Skaffold - Kubernetes 开发工具

# 安装（macOS）
brew install skaffold

# 安装（Linux）
curl -Lo skaffold https://storage.googleapis.com/skaffold/releases/latest/skaffold-linux-amd64
chmod +x skaffold
sudo mv skaffold /usr/local/bin

# 初始化项目
skaffold init

# 开发模式（文件变化自动重新部署）
skaffold dev

# 构建并部署
skaffold run

# 清理部署
skaffold delete

# skaffold.yaml 示例
apiVersion: skaffold/v4beta9
kind: Config
build:
  artifacts:
    - image: myapp
      docker:
        dockerfile: Dockerfile
manifests:
  rawYaml:
    - k8s/*.yaml
deploy:
  kubectl: {}

Tilt - 本地 Kubernetes 开发

# 安装（macOS/Linux）
curl -fsSL https://raw.githubusercontent.com/tilt-dev/tilt/master/scripts/install.sh | bash

# 安装（macOS with Homebrew）
brew install tilt-dev/tap/tilt

# 启动 Tilt
tilt up

# Tiltfile 示例
# Tiltfile
docker_build('myapp', '.')
k8s_yaml('k8s/')
k8s_resource('myapp', port_forwards=3000)

# 多服务示例
docker_build('api', './api')
docker_build('web', './web')
k8s_yaml('k8s/')
k8s_resource('api', port_forwards=8080)
k8s_resource('web', port_forwards=3000)

# 特点：
# - 实时日志查看
# - 资源监控面板
# - 文件变化自动构建
# - 支持 live_update（不重建镜像更新代码）

🌐 网络与代理

Traefik - 云原生边缘路由器

# docker-compose.yml
services:
  traefik:
    image: traefik:v3.0
    ports:
      - "80:80"
      - "443:443"
      - "8080:8080"  # Dashboard
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./traefik.yml:/etc/traefik/traefik.yml:ro
      - ./certs:/etc/certs:ro
    restart: always

  whoami:
    image: traefik/whoami
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.whoami.rule=Host(`whoami.example.com`)"
      - "traefik.http.routers.whoami.entrypoints=web"

# traefik.yml
api:
  dashboard: true
  insecure: true

entryPoints:
  web:
    address: ":80"
  websecure:
    address: ":443"

providers:
  docker:
    exposedByDefault: false

certificatesResolvers:
  letsencrypt:
    acme:
      email: admin@example.com
      storage: /etc/certs/acme.json
      httpChallenge:
        entryPoint: web

📊 监控与日志

Prometheus + Grafana - 监控方案

# docker-compose.yml
services:
  prometheus:
    image: prom/prometheus:latest
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'

  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
    volumes:
      - grafana-data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    ports:
      - "8081:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro

  node-exporter:
    image: prom/node-exporter:latest
    ports:
      - "9100:9100"
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro

volumes:
  grafana-data:

# prometheus.yml
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'cadvisor'
    static_configs:
      - targets: ['cadvisor:8080']
  - job_name: 'node-exporter'
    static_configs:
      - targets: ['node-exporter:9100']

# 导入 Grafana Dashboard
# 推荐 ID: 11600 (Docker and system monitoring)
# 或 893 (Node Exporter Full)

Dozzle - 轻量级日志查看

# 快速启动
docker run -d \
  --name dozzle \
  -p 9999:8080 \
  -v /var/run/docker.sock:/var/run/docker.sock \
  amir20/dozzle:latest

# Docker Compose
services:
  dozzle:
    image: amir20/dozzle:latest
    ports:
      - "9999:8080"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - DOZZLE_LEVEL=info
      - DOZZLE_TAILSIZE=300

# 访问：http://localhost:9999
# 特点：
# - 实时日志流
# - 多容器同时查看
# - 日志搜索过滤
# - 无需配置

🔐 安全加固工具

Docker Bench for Security

# 运行检查
docker run --rm \
  --net host \
  --pid host \
  --cap-add audit_control \
  -v /var/lib:/var/lib \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /usr/lib/systemd:/usr/lib/systemd \
  -v /etc:/etc \
  --label docker_bench_security \
  docker/docker-bench-security

# 输出分类：
# [INFO] 检查项
# [PASS] 通过
# [WARN] 警告（需要关注）
# [FAIL] 失败（需要修复）
# [NOTE] 说明

# 常见修复建议：
# 1. 设置日志驱动
#    --log-driver json-file --log-opts max-size=10m

# 2. 禁用 inter-container communication
#    --icc=false

# 3. 启用 user namespace
#    /etc/docker/daemon.json: {"userns-remap": "default"}

# 4. 限制容器 capabilities
#    --cap-drop ALL --cap-add CHOWN

# 5. 使用 seccomp profile
#    --security-opt seccomp=default.json

Clair - 镜像漏洞扫描

# 使用 Clair 的客户端工具 clair-scanner
docker run --rm \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v $(pwd)/reports:/reports \
  arminc/clair-local-scan:v2.0.8 \
  --clair http://clair:6060 \
  --report /reports/$(basename $IMAGE).json \
  myapp:latest

# 或使用 Clair V4
services:
  clair:
    image: quay.io/coreos/clair:v4.5.0
    ports:
      - "6060:6060"
      - "6061:6061"
    volumes:
      - ./config.yaml:/etc/clair/config.yaml

# 与 Harbor 集成
# Harbor 内置 Clair 扫描器
# 在 Harbor 配置中启用漏洞扫描即可

🛠️ 完整工具清单

实战案例

CI/CD 容器化流程

开发环境架构

案例 1：Web 应用

# Dockerfile
FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

案例 2：Python 应用

# Dockerfile
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["python", "app.py"]

案例 3：完整开发环境

# docker-compose.yml
services:
  app:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - .:/app
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/dev
    depends_on:
      - db

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: dev
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
    volumes:
      - db-data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

volumes:
  db-data: