Docker 容器化技术完全指南：从入门到实战

Docker 通过容器化技术重新定义了应用部署的方式。从开发环境到生产环境，容器确保了一致性和可移植性，成为现代 DevOps 的核心基础设施。

一、核心概念

Docker 是一个开源的容器化平台，它允许开发者将应用及其依赖打包到一个轻量级、可移植的容器中。理解以下核心概念是掌握 Docker 的基础：

1. 镜像（Image）

镜像是容器的蓝图，是一个只读的模板，包含了运行应用所需的所有内容：代码、运行时、库、环境变量和配置文件。镜像通过 Dockerfile 构建，可以分层存储，每一层都是只读的。

2. 容器（Container）

容器是镜像的运行实例。它是一个轻量级、独立的可执行软件包，包含运行应用所需的一切。容器之间相互隔离，共享宿主机的操作系统内核，因此比虚拟机更加轻量和高效。

3. 仓库（Registry）

仓库是存储和分发镜像的地方。Docker Hub 是最大的公共仓库，提供了大量的官方镜像。企业也可以搭建私有仓库来存储自己的镜像。

4. Dockerfile

Dockerfile 是一个文本文件，包含了构建镜像所需的所有指令。通过 Dockerfile，可以将应用的构建过程标准化和自动化。

二、核心内容

2.1 Docker 安装与配置

Docker 支持主流操作系统，以下是在 Ubuntu 上安装 Docker 的步骤：

# 更新软件包索引
sudo apt-get update

# 安装依赖包
sudo apt-get install apt-transport-https ca-certificates curl software-properties-common

# 添加 Docker 官方 GPG 密钥
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

# 添加 Docker APT 仓库
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

# 安装 Docker CE
sudo apt-get update
sudo apt-get install docker-ce

# 启动 Docker 服务
sudo systemctl start docker
sudo systemctl enable docker

# 验证安装
docker --version

2.2 镜像管理

镜像是 Docker 的核心资源，掌握镜像管理是使用 Docker 的第一步：

# 搜索镜像
docker search nginx

# 拉取镜像
docker pull nginx:latest
docker pull python:3.11-slim

# 查看本地镜像
docker images

# 删除镜像
docker rmi nginx:latest

# 导出镜像
docker save -o nginx.tar nginx:latest

# 导入镜像
docker load -i nginx.tar

# 为镜像打标签
docker tag nginx:latest myregistry.com/nginx:v1.0

# 推送镜像到仓库
docker push myregistry.com/nginx:v1.0

2.3 容器生命周期管理

容器的生命周期包括创建、启动、停止、删除等状态：

# 创建并启动容器（最常用）
docker run -d --name mynginx -p 80:80 nginx:latest

# 参数说明：
# -d: 后台运行
# --name: 指定容器名称
# -p: 端口映射，格式为 宿主机端口:容器端口

# 查看运行中的容器
docker ps

# 查看所有容器（包括已停止的）
docker ps -a

# 停止容器
docker stop mynginx

# 启动已停止的容器
docker start mynginx

# 重启容器
docker restart mynginx

# 删除容器
docker rm mynginx

# 强制删除运行中的容器
docker rm -f mynginx

# 查看容器日志
docker logs mynginx
docker logs -f mynginx  # 实时查看

# 进入容器内部
docker exec -it mynginx /bin/bash

# 查看容器详细信息
docker inspect mynginx

# 查看容器资源使用情况
docker stats mynginx

2.4 Dockerfile 编写最佳实践

Dockerfile 是构建镜像的核心，以下是编写高质量 Dockerfile 的实践：

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

# 设置工作目录
WORKDIR /app

# 设置环境变量
# PYTHONDONTWRITEBYTECODE: 防止 Python 生成 .pyc 文件
# PYTHONUNBUFFERED: 确保 Python 输出直接显示在终端
ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1

# 安装系统依赖
# 使用 && 连接命令，减少镜像层数
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc \
    && rm -rf /var/lib/apt/lists/*

# 复制依赖文件
COPY requirements.txt .

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

# 复制项目文件
COPY . .

# 创建非 root 用户运行应用（安全最佳实践）
RUN useradd -m appuser && chown -R appuser:appuser /app
USER appuser

# 暴露端口
EXPOSE 8000

# 健康检查
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:8000/health || exit 1

# 启动命令
# 使用 CMD 而非 ENTRYPOINT，便于调试时覆盖
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

Dockerfile 最佳实践要点：

• 使用官方基础镜像，优先选择 Alpine 或 slim 版本
• 合并 RUN 指令减少镜像层数
• 利用构建缓存，把变化最少的指令放在前面
• 使用 .dockerignore 排除不必要的文件
• 不要在镜像中存储敏感信息
• 使用非 root 用户运行容器

2.5 Docker Compose 多容器编排

实际项目中往往需要多个容器协同工作，Docker Compose 是解决这个问题的利器：

# docker-compose.yml
version: '3.8'

services:
  # Web 应用服务
  web:
    build: .
    container_name: django_app
    command: python manage.py runserver 0.0.0.0:8000
    volumes:
      - .:/app  # 代码热更新
      - static_volume:/app/staticfiles
    ports:
      - "8000:8000"
    environment:
      - DEBUG=1
      - DATABASE_URL=postgres://postgres:password@db:5432/mydb
      - REDIS_URL=redis://redis:6379/0
    depends_on:
      - db
      - redis
    networks:
      - app_network
    restart: unless-stopped

  # PostgreSQL 数据库
  db:
    image: postgres:15-alpine
    container_name: postgres_db
    environment:
      - POSTGRES_DB=mydb
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - app_network
    restart: unless-stopped

  # Redis 缓存
  redis:
    image: redis:7-alpine
    container_name: redis_cache
    volumes:
      - redis_data:/data
    networks:
      - app_network
    restart: unless-stopped

  # Nginx 反向代理
  nginx:
    image: nginx:alpine
    container_name: nginx_proxy
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - static_volume:/app/staticfiles:ro
    depends_on:
      - web
    networks:
      - app_network
    restart: unless-stopped

# 数据卷定义
volumes:
  postgres_data:
  redis_data:
  static_volume:

# 网络定义
networks:
  app_network:
    driver: bridge

# Docker Compose 常用命令
# 启动所有服务
docker-compose up -d

# 查看服务状态
docker-compose ps

# 查看日志
docker-compose logs -f

# 停止所有服务
docker-compose down

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

# 重新构建并启动
docker-compose up -d --build

# 只启动特定服务
docker-compose up -d web

# 进入容器
docker-compose exec web /bin/bash

# 扩展服务实例数量
docker-compose up -d --scale web=3

三、实战案例

案例一：部署一个完整的 Python Web 应用

以下是一个完整的 Django + PostgreSQL + Redis + Nginx 项目结构：

project/
├── app/
│   ├── manage.py
│   ├── requirements.txt
│   ├── Dockerfile
│   └── config/
├── nginx/
│   └── nginx.conf
└── docker-compose.yml

# app/Dockerfile
FROM python:3.11-slim

WORKDIR /app

ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1

RUN apt-get update && apt-get install -y --no-install-recommends \
    libpq-dev \
    && rm -rf /var/lib/apt/lists/*

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

RUN useradd -m appuser && chown -R appuser:appuser /app
USER appuser

EXPOSE 8000

CMD ["gunicorn", "--bind", "0.0.0.0:8000", "config.wsgi:application"]

案例二：多阶段构建优化镜像大小

多阶段构建可以显著减小最终镜像的大小，只保留运行时必需的文件：

# 构建阶段
FROM node:18-alpine AS builder

WORKDIR /app

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

COPY . .
RUN npm run build

# 生产阶段 - 使用更小的基础镜像
FROM nginx:alpine

# 只复制构建产物
COPY --from=builder /app/build /usr/share/nginx/html
COPY nginx.conf /etc/nginx/nginx.conf

EXPOSE 80

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

优化效果：

• 构建阶段镜像：约 1GB
• 最终生产镜像：约 25MB
• 镜像大小减少 97%

案例三：Docker 网络配置与容器互联

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

# 启动数据库容器
docker run -d --name db \
  --network myapp_network \
  -e POSTGRES_PASSWORD=secret \
  postgres:15-alpine

# 启动应用容器，通过容器名连接数据库
docker run -d --name web \
  --network myapp_network \
  -e DATABASE_URL=postgres://postgres:secret@db:5432/mydb \
  -p 8000:8000 \
  myapp:latest

# 在应用容器中可以通过容器名 "db" 访问数据库
# 这就是 Docker 内置的 DNS 解析功能

案例四：数据持久化与数据卷管理

# 创建命名卷
docker volume create mydata

# 查看所有卷
docker volume ls

# 查看卷详情
docker volume inspect mydata

# 使用卷启动容器
docker run -d --name app \
  -v mydata:/app/data \
  myapp:latest

# 挂载宿主机目录（bind mount）
docker run -d --name app \
  -v /host/path:/container/path \
  myapp:latest

# 使用 tmpfs（临时文件系统，存储在内存中）
docker run -d --name app \
  --tmpfs /tmp \
  myapp:latest

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

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

四、进阶技巧

4.1 镜像优化策略

# 使用 dive 工具分析镜像层
dive myapp:latest

# 查看镜像历史
docker history myapp:latest

# 多阶段构建 + Alpine 基础镜像
# 最终镜像可以控制在 10MB 以内

4.2 容器资源限制

# 限制 CPU 和内存使用
docker run -d --name app \
  --cpus="1.5" \
  --memory="512m" \
  --memory-swap="1g" \
  myapp:latest

# 使用 docker-compose 限制资源
# 在 docker-compose.yml 中：
services:
  app:
    deploy:
      resources:
        limits:
          cpus: '1.5'
          memory: 512M
        reservations:
          cpus: '0.5'
          memory: 256M

4.3 安全最佳实践

# 1. 使用只读文件系统
docker run --read-only --tmpfs /tmp myapp:latest

# 2. 限制容器能力
docker run --cap-drop ALL --cap-add NET_BIND_SERVICE myapp:latest

# 3. 禁止特权模式
docker run --security-opt no-new-privileges myapp:latest

# 4. 使用安全扫描工具
docker scan myapp:latest
trivy image myapp:latest

五、常见问题与解决方案

5.1 容器无法启动

问题：容器启动后立即退出

排查步骤：

# 查看容器退出码
docker ps -a

# 查看详细日志
docker logs container_name

# 使用交互模式调试
docker run -it --entrypoint /bin/sh myapp:latest

5.2 磁盘空间不足

# 查看磁盘使用情况
docker system df

# 清理未使用的资源
docker system prune -a

# 只清理悬空镜像
docker image prune

# 清理停止的容器
docker container prune

5.3 网络连接问题

# 检查容器网络
docker network inspect bridge

# 进入容器测试网络
docker exec -it container_name ping google.com

# 查看容器 DNS 配置
docker exec -it container_name cat /etc/resolv.conf

总结

Docker 容器化技术已成为现代应用开发和部署的核心基础设施。通过本文的学习，你应该掌握了：

1. 核心概念：理解镜像、容器、仓库等基本概念
2. 镜像管理：拉取、构建、推送和管理镜像
3. 容器操作：创建、启动、停止和管理容器生命周期
4. Dockerfile 编写：编写高质量的镜像构建脚本
5. Docker Compose：编排多容器应用
6. 实战应用：部署真实的 Web 应用项目
7. 进阶技巧：镜像优化、资源限制、安全加固

容器化不仅仅是技术升级，更是一种思维方式的转变。它让应用的构建、分发和运行变得标准化和自动化，极大地提高了开发效率和部署可靠性。随着 Kubernetes 等容器编排技术的发展，容器化已成为云原生应用的基石。

建议在实际项目中多加练习，从简单的单容器应用开始，逐步过渡到复杂的多服务架构。掌握 Docker，你就掌握了现代应用部署的核心技能。

本文链接：https://www.kkkliao.cn/?id=908 转载需授权！