Docker & Compose
实战指南

1容器到底是什么入门

容器 = 把"应用 + 它依赖的所有东西"打成一个包，在任何能跑 Docker 的机器上一致运行。它不是虚拟机，没装一个完整的操作系统，更轻、更快。

1.1 三个必须区分的概念

1.2 为什么团队都在用

2安装与验证入门

curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER     # 免 sudo
newgrp docker

验证

docker --version            # Docker version 27.x.x
docker compose version      # Docker Compose version v2.x.x
docker run hello-world      # 拉镜像 → 跑容器 → 打印消息

3跑第一个容器入门

跑一个 nginx：

docker run -d -p 8080:80 --name my-nginx nginx:alpine

拆解这一行：

浏览器打开 http://localhost:8080 → 看到 Nginx 欢迎页 ✅

容器的生命周期

4核心命令速查入门

4.1 容器管理

4.2 镜像管理

4.3 一键清理

docker system df              # 看占用
docker system prune -a        # 清除未使用的镜像/容器/网络
docker volume prune           # 清除未使用的卷（小心数据）

5镜像与 Dockerfile进阶

Dockerfile 是一份"如何把代码做成镜像"的说明书。每一条指令产生一个层(layer)，层会被缓存，改一行只重做那一层之后的内容。

5.1 最常用指令

5.2 第一个真实例子：Python Flask 应用

# app.py
from flask import Flask
app = Flask(__name__)

@app.get("/")
def hello():
    return {"msg": "Hello from Docker!"}

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000)

# Dockerfile
FROM python:3.12-slim

WORKDIR /app

# 关键：先 COPY requirements，单独一层 → 改代码不会重装依赖
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8000
CMD ["python", "app.py"]

docker build -t flask-demo:1.0 .
docker run -d -p 8000:8000 --name web flask-demo:1.0
curl http://localhost:8000

5.3 .dockerignore（很多人忘）

类似 .gitignore，避免把无用文件打进镜像，加快构建：

.git
.env
node_modules
__pycache__
*.log
dist
.DS_Store

6数据卷与持久化进阶

容器删除后所有写入容器内的数据都会消失。要持久化必须用 volume。

6.1 三种挂载方式

6.2 实战：MySQL 数据持久化

# 不持久化（数据随容器消失）
docker run -d --name db -e MYSQL_ROOT_PASSWORD=secret mysql:8

# 持久化到 named volume（推荐）
docker run -d --name db \
  -e MYSQL_ROOT_PASSWORD=secret \
  -v mysql_data:/var/lib/mysql \
  -p 3306:3306 \
  mysql:8

# 查看 volume
docker volume ls
docker volume inspect mysql_data

6.3 现代写法：--mount

语义更明确，强烈推荐用于脚本和生产：

docker run -d \
  --mount type=volume,source=mysql_data,target=/var/lib/mysql \
  --mount type=bind,source=$(pwd)/conf,target=/etc/mysql/conf.d,readonly \
  mysql:8

7网络模式进阶

7.1 四种模式

7.2 实战：web 和 db 互通

# 1. 创建自定义网络
docker network create app-net

# 2. 容器挂到同一网络
docker run -d --name db --network app-net \
  -e POSTGRES_PASSWORD=pw postgres:16

docker run -d --name web --network app-net -p 8000:8000 \
  -e DATABASE_URL=postgres://postgres:pw@db:5432/postgres \
  myapp:1.0

# 在 web 容器里直接用 "db" 作为主机名连接 ✅

8镜像仓库进阶

# 登录
docker login                          # Docker Hub
docker login ghcr.io                  # GitHub Container Registry
docker login registry.gitlab.com      # GitLab Registry

# 推送（镜像名前缀 = 仓库地址）
docker tag myapp:1.0 ghcr.io/myorg/myapp:1.0
docker push ghcr.io/myorg/myapp:1.0

# 拉取私有镜像
docker pull ghcr.io/myorg/myapp:1.0

镜像命名规范

[registry/][namespace/]name[:tag]

例：
  nginx                           # Docker Hub library/nginx:latest
  python:3.12-slim                # 指定 tag
  ghcr.io/myorg/myapp:v1.2.3      # GHCR + 版本
  registry.cn-hangzhou.aliyuncs.com/myns/myapp:latest

9镜像优化与多阶段构建高级

一个能跑的镜像 vs. 一个好的镜像，差别在 3 个维度：体积、构建速度、安全表面。

9.1 优化前后对比（真实案例：Node.js 应用）

FROM node:20
WORKDIR /app
COPY . .
RUN npm install
RUN npm run build
EXPOSE 3000
CMD ["npm", "start"]

# 阶段 1: builder
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# 阶段 2: runner（只要产物）
FROM node:20-alpine AS runner
WORKDIR /app
ENV NODE_ENV=production
COPY package*.json ./
RUN npm ci --omit=dev && npm cache clean --force
COPY --from=builder /app/dist ./dist
EXPOSE 3000
USER node
CMD ["node", "dist/server.js"]

9.2 多阶段构建原理

9.3 通用瘦身技巧

RUN apt-get update \
 && apt-get install -y curl \
 && rm -rf /var/lib/apt/lists/*

9.4 BuildKit 加速

现代 Docker 默认开启。可用 缓存挂载、secret 挂载：

# 缓存挂载：npm/pip cache 跨构建复用
RUN --mount=type=cache,target=/root/.npm \
    npm ci

# secret 挂载：构建期需要 token 但不留进镜像
RUN --mount=type=secret,id=npmrc,target=/root/.npmrc \
    npm install

10安全加固高级

# 生产启动模板
docker run -d \
  --name web \
  --read-only \
  --tmpfs /tmp \
  --memory=512m --cpus=1 \
  --security-opt no-new-privileges \
  --cap-drop ALL \
  --user 1000:1000 \
  -p 8000:8000 \
  myapp@sha256:abc123...   # 用 digest 锁死版本

11调试与排障高级

11.1 容器起不来 / 一启动就退出

# 1. 看日志
docker logs my-container
docker logs --tail 100 -f my-container

# 2. 查退出原因
docker inspect my-container --format='{{.State.ExitCode}} {{.State.Error}}'

# 3. 改启动命令进去看
docker run -it --entrypoint sh myapp:1.0

11.2 进容器排查

# 进运行中的容器
docker exec -it web sh        # alpine
docker exec -it web bash      # debian/ubuntu

# 容器没装调试工具？用临时 sidecar
docker run -it --rm --pid=container:web \
  --net=container:web nicolaka/netshoot

11.3 资源/网络问题

12Compose 起步 🐳Compose

单条 docker run 适合一个容器。但真实应用是 web + db + redis + worker + …，手敲命令既慢又错。Compose 用一个 YAML 文件描述整个应用栈，一条命令起停所有服务。

12.1 最小例子

# compose.yaml
services:
  web:
    image: nginx:alpine
    ports:
      - "8080:80"

docker compose up -d              # 后台启动
docker compose ps                 # 查看
docker compose logs -f            # 看日志
docker compose down               # 停止 + 删容器（保留 volume）
docker compose down -v            # 连 volume 一起删

13多服务实战：Web + API + DB + Redis 🐳Compose

下面是一份能直接跑的完整栈，覆盖几乎所有常用字段。

# compose.yaml
services:
  # --- 反向代理 ---
  nginx:
    image: nginx:1.27-alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      api:
        condition: service_healthy
    restart: unless-stopped

  # --- 应用 API（用 Dockerfile 构建）---
  api:
    build:
      context: ./api
      dockerfile: Dockerfile
      args:
        NODE_ENV: production
    environment:
      DATABASE_URL: postgres://app:${DB_PASSWORD}@db:5432/app
      REDIS_URL: redis://redis:6379
      NODE_ENV: production
    env_file: .env
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:8000/health"]
      interval: 10s
      timeout: 3s
      retries: 5
      start_period: 20s
    deploy:
      resources:
        limits: { cpus: '1.0', memory: 512M }
    restart: unless-stopped

  # --- 数据库 ---
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: app
      POSTGRES_USER: app
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - db_data:/var/lib/postgresql/data
      - ./db/init.sql:/docker-entrypoint-initdb.d/init.sql:ro
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U app -d app"]
      interval: 5s
      retries: 10
    restart: unless-stopped

  # --- 缓存 ---
  redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes
    volumes:
      - redis_data:/data
    restart: unless-stopped

volumes:
  db_data:
  redis_data:

13.1 配套 .env 文件

# .env （加进 .gitignore）
DB_PASSWORD=super-secret-pw-please-rotate
NODE_ENV=production

13.2 关键字段拆解

13.3 常用命令

14Compose 高级技巧高级

14.1 多环境：override + profile

Compose 默认会合并两个文件：compose.yaml + compose.override.yaml。后者覆盖前者。这是区分开发/生产的官方方式：

# compose.yaml（生产基准）
services:
  api:
    image: ghcr.io/myorg/api:1.2.0
    restart: unless-stopped

# compose.override.yaml（开发本地，自动加载）
services:
  api:
    build: ./api
    volumes:
      - ./api:/app     # 代码热更新
    environment:
      DEBUG: "true"
    ports:
      - "8000:8000"

docker compose up -d                                            # 开发
docker compose -f compose.yaml up -d                            # 只用 base（生产）
docker compose -f compose.yaml -f compose.prod.yaml up -d       # 显式合并

14.2 Profile：可选服务

services:
  api: { image: myapi }
  db:  { image: postgres }

  # 调试工具，平时不起
  adminer:
    image: adminer
    profiles: ["debug"]

  # 性能测试
  k6:
    image: grafana/k6
    profiles: ["perf"]

docker compose up -d                          # 只起 api + db
docker compose --profile debug up -d          # 加 adminer
docker compose --profile perf up -d k6        # 临时跑压测

14.3 复用配置：YAML anchor & extends

x-common-env: &common-env
  TZ: Asia/Shanghai
  LOG_LEVEL: info

services:
  api:
    image: myapi
    environment:
      <<: *common-env
      ROLE: api

  worker:
    image: myapi
    environment:
      <<: *common-env
      ROLE: worker
    command: ["python", "worker.py"]

14.4 自定义网络分层

services:
  nginx:
    image: nginx
    networks: [frontend]
  api:
    image: myapi
    networks: [frontend, backend]    # 双网卡
  db:
    image: postgres
    networks: [backend]               # 数据库只在内网

networks:
  frontend:
  backend:
    internal: true                    # 完全无外网

14.5 Secret 管理（生产）

services:
  db:
    image: postgres:16
    environment:
      POSTGRES_PASSWORD_FILE: /run/secrets/db_pw
    secrets:
      - db_pw

secrets:
  db_pw:
    file: ./secrets/db_password.txt

14.6 监听 + 热更新（Compose Watch）

Compose 2.22+ 支持 watch，本地代码变化自动同步/重建：

services:
  api:
    build: ./api
    develop:
      watch:
        - action: sync           # 同步文件，无需重启
          path: ./api/src
          target: /app/src
        - action: rebuild        # package.json 变了 → 重建镜像
          path: ./api/package.json

docker compose up --watch

15走向生产高级

Compose 在单机生产是完全够用的（不少团队用它跑业务好几年）。要做好这几件事：

15.1 生产部署最小脚本

#!/usr/bin/env bash
set -euo pipefail
cd /opt/myapp

# 拉最新代码
git pull

# 用 .env.prod 启动
docker compose --env-file .env.prod \
  -f compose.yaml -f compose.prod.yaml \
  pull

docker compose --env-file .env.prod \
  -f compose.yaml -f compose.prod.yaml \
  up -d --remove-orphans

# 清理旧镜像
docker image prune -f

15.2 与 CI/CD 集成

✓学习路径总结