Docker容器化实战：从入门到精通

Docker容器化实战：从入门到精通

引言

Docker已经成为现代应用部署的标准工具，它通过容器化技术实现了应用的快速部署、可移植性和隔离性。本文将从基础概念到高级技巧，全面讲解Docker容器化的实战经验。

一、Docker基础

1.1 什么是Docker

Docker是一个开源的容器化平台，允许开发者将应用及其依赖打包成一个轻量级、可移植的容器。

1.2 Docker核心概念

• 镜像（Image）：只读的模板，包含运行应用所需的所有文件和配置
• 容器（Container）：镜像的运行实例，可以被创建、启动、停止、删除
• 仓库（Registry）：存储和分发镜像的地方，如Docker Hub
• Dockerfile：定义如何构建镜像的文本文件

1.3 Docker架构

┌─────────────────────────────────────────────────────────────┐
│                    Docker架构                              │
├─────────────────────────────────────────────────────────────┤
│                    Docker Client                           │
│                      (docker命令)                          │
├─────────────────────────────────────────────────────────────┤
│                    Docker Daemon                           │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐     │
│  │   Images     │  │  Containers  │  │   Networks   │     │
│  └──────────────┘  └──────────────┘  └──────────────┘     │
│  ┌──────────────┐  ┌──────────────┐                       │
│  │    Volumes   │  │   Registry   │                       │
│  └──────────────┘  └──────────────┘                       │
└─────────────────────────────────────────────────────────────┘

二、Dockerfile编写技巧

2.1 基础Dockerfile结构

FROM golang:1.21-alpine AS builder

WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download

COPY . .
RUN go build -o myapp .

FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/myapp .

RUN apk --no-cache add ca-certificates

EXPOSE 8080

USER 1000

CMD ["./myapp"]

2.2 多阶段构建

多阶段构建可以显著减小镜像大小。

# 阶段1：构建
FROM node:18-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

COPY . .
RUN npm run build

# 阶段2：运行
FROM nginx:alpine
COPY --from=build /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/nginx.conf

EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

2.3 最佳实践

# 使用官方基础镜像
FROM python:3.11-slim

# 设置工作目录
WORKDIR /app

# 安装依赖
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 暴露端口
EXPOSE 5000

# 设置健康检查
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:5000/health || exit 1

# 运行命令
CMD ["python", "app.py"]

三、Docker Compose实战

3.1 Docker Compose配置

version: '3.8'

services:
  web:
    build: .
    ports:
      - "8080:8080"
    environment:
      - DATABASE_URL=postgres://user:password@db:5432/mydb
    depends_on:
      - db
      - redis
    networks:
      - backend

  db:
    image: postgres:15-alpine
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=mydb
    networks:
      - backend

  redis:
    image: redis:7-alpine
    volumes:
      - redis_data:/data
    networks:
      - backend

volumes:
  postgres_data:
  redis_data:

networks:
  backend:
    driver: bridge

3.2 多环境配置

# docker-compose.prod.yml
version: '3.8'

services:
  web:
    build:
      context: .
      dockerfile: Dockerfile.prod
    environment:
      - NODE_ENV=production
      - LOG_LEVEL=info
    deploy:
      replicas: 3
      restart_policy:
        condition: on-failure

四、Docker网络

4.1 网络类型

# 创建自定义网络
docker network create --driver bridge my-network

# 查看网络
docker network ls

# 连接容器到网络
docker network connect my-network my-container

# 断开连接
docker network disconnect my-network my-container

4.2 网络隔离

version: '3.8'

services:
  frontend:
    image: nginx:alpine
    networks:
      - frontend-network

  backend:
    image: node:18-alpine
    networks:
      - frontend-network
      - backend-network

  database:
    image: postgres:15-alpine
    networks:
      - backend-network

networks:
  frontend-network:
    driver: bridge
  backend-network:
    driver: bridge
    internal: true

五、Docker存储

5.1 卷挂载

version: '3.8'

services:
  app:
    image: myapp:latest
    volumes:
      # 命名卷
      - app_data:/app/data
      # 绑定挂载
      - ./config:/app/config
      # tmpfs挂载
      - type: tmpfs
        target: /app/tmp

volumes:
  app_data:
    driver: local

5.2 存储驱动选择

六、Docker安全

6.1 安全最佳实践

# 以非root用户运行
RUN adduser -D appuser
USER appuser

# 最小化镜像
FROM alpine:latest

# 清理不需要的文件
RUN rm -rf /var/cache/apk/*

# 设置只读文件系统
VOLUME ["/app/data"]

6.2 扫描镜像漏洞

# 使用trivy扫描
trivy image myapp:latest

# 使用snyk扫描
snyk container test myapp:latest

# 使用docker scout
docker scout quickview myapp:latest

七、Docker镜像优化

7.1 减小镜像大小

# 使用更小的基础镜像
FROM alpine:latest

# 合并RUN命令
RUN apk add --no-cache curl \
    && curl -sSL https://example.com/install.sh | sh \
    && apk del curl

# 删除不需要的依赖
RUN npm ci --only=production

7.2 镜像分层优化

# 先复制依赖文件
COPY go.mod go.sum ./
RUN go mod download

# 再复制代码
COPY . .
RUN go build -o myapp .

八、Docker Swarm入门

8.1 初始化Swarm集群

# 初始化Swarm
docker swarm init --advertise-addr 192.168.1.100

# 添加工作节点
docker swarm join --token SWMTKN-1-xxx 192.168.1.100:2377

# 查看节点
docker node ls

8.2 部署服务

version: '3.8'

services:
  web:
    image: myapp:latest
    deploy:
      replicas: 5
      update_config:
        parallelism: 2
        delay: 10s
      restart_policy:
        condition: on-failure
        max_attempts: 3
    ports:
      - "80:8080"

# 部署服务
docker stack deploy -c docker-compose.yml myapp

# 查看服务
docker stack services myapp

# 查看日志
docker service logs myapp_web

九、实战案例：微服务架构

9.1 架构设计

version: '3.8'

services:
  api-gateway:
    build: ./api-gateway
    ports:
      - "80:8080"
    depends_on:
      - user-service
      - order-service
    networks:
      - microservices

  user-service:
    build: ./user-service
    environment:
      - DB_HOST=user-db
      - REDIS_HOST=redis
    networks:
      - microservices

  order-service:
    build: ./order-service
    environment:
      - DB_HOST=order-db
      - RABBITMQ_HOST=rabbitmq
    networks:
      - microservices

  user-db:
    image: postgres:15-alpine
    volumes:
      - user-db-data:/var/lib/postgresql/data
    networks:
      - microservices

  order-db:
    image: postgres:15-alpine
    volumes:
      - order-db-data:/var/lib/postgresql/data
    networks:
      - microservices

  redis:
    image: redis:7-alpine
    networks:
      - microservices

  rabbitmq:
    image: rabbitmq:3-management-alpine
    ports:
      - "15672:15672"
    networks:
      - microservices

volumes:
  user-db-data:
  order-db-data:

networks:
  microservices:
    driver: bridge

9.2 健康检查与自动恢复

services:
  api-gateway:
    build: ./api-gateway
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    deploy:
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
        window: 120s

十、总结

Docker容器化技术已经改变了现代应用的部署方式。通过掌握Dockerfile编写、Docker Compose配置、网络管理、存储优化和安全实践，你可以构建出高效、安全、可扩展的容器化应用。

在实际项目中，需要根据应用特点选择合适的镜像策略和部署方式。Docker Swarm适合简单的容器编排场景，而对于更复杂的需求，可以考虑使用Kubernetes。

持续学习和实践是掌握Docker的关键。不断尝试新的功能和最佳实践，才能在实际工作中游刃有余。