学习 Docker 容器技术 2026

从零开始掌握容器化部署，利用 AI 辅助和现代化工具链轻松构建、运行和管理应用程序

开始学习 2026新特性 AI工具
🐳

什么是 Docker？

🤖

AI 智能构建

利用 AI 优化 Dockerfile，自动检测最佳实践，智能推荐基础镜像和依赖管理

⚡

极速部署

采用 BuildKit 2.0 和 Buildx，实现并行构建和缓存共享，部署速度提升 5-10 倍

🔄

环境一致性

开发、测试、生产环境完全一致，配合 Docker Scout 自动检测安全漏洞

📈

资源高效

采用 WASM 容器和 eBPF 监控，资源利用率提升 40%，内存占用降低 30%

🔒

零信任安全

内置签名验证、SBOM 生成和运行时保护，符合 2026 年安全合规标准

🌐

云原生集成

无缝对接 Kubernetes、AWS EKS、Azure AKS，支持多云部署和边缘计算

基础入门

1. Mac/Linux 安装

# 使用 Homebrew 安装 (Mac)
brew install --cask docker-desktop

# 或使用 Colima（轻量级替代方案）
brew install colima
colima start

# Ubuntu 安装（推荐使用官方脚本）
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# 添加当前用户到 docker 组
sudo usermod -aG docker $USER

2. Windows 安装

# 使用 WSL2 + Docker Desktop（推荐）
wsl --install

# 使用 Chocolatey
choco install docker-desktop

# 或使用 Rancher Desktop（开源替代）
choco install rancher-desktop

3. 验证安装

docker --version
docker run hello-world

# 检查 BuildKit（2026 默认启用）
docker buildx version

# 检查 Docker Scout（安全扫描工具）
docker scout version

Dockerfile 基础示例（2026 版本）

# 使用 BuildKit 优化的多阶段构建
# syntax=docker/dockerfile:1.4

# 构建阶段
FROM node:20-alpine AS builder
WORKDIR /app

# 启用 BuildKit 缓存挂载
RUN --mount=type=cache,target=/root/.npm \
    npm ci

COPY . .
RUN npm run build

# 运行阶段
FROM node:20-alpine
WORKDIR /app

# 复制构建产物
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY package*.json ./

# 创建非 root 用户
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001
USER nodejs

# 暴露端口
EXPOSE 3000

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD node -e "require('http').get('http://localhost:3000/health', (r) => {process.exit(r.statusCode === 200 ? 0 : 1)})"

# 启动应用
CMD ["node", "dist/index.js"]

2026 Dockerfile 新特性

  • # syntax: 声明 Dockerfile 语法版本，启用新特性
  • --mount=type=cache: BuildKit 缓存挂载，加速构建
  • --mount=type=secret: 安全挂载密钥（如 SSH 密钥）
  • --mount=type=ssh: 直接在构建中使用 SSH
  • COPY --link: 减少构建上下文和层大小
  • RUN --network: 控制构建时的网络访问
  • HEREDOC: 支持多行文本块

使用 Secrets 和 SSH

# syntax=docker/dockerfile:1.4

FROM node:20-alpine AS builder
WORKDIR /app

# 使用私有 npm 仓库的 token（作为 secret）
RUN --mount=type=secret,id=npm_token,required \
    NPM_TOKEN=$(cat /run/secrets/npm_token) \
    npm ci

# 克隆私有 Git 仓库
RUN --mount=type=ssh \
    git clone git@github.com:yourorg/private-repo.git

# 多行脚本（HEREDOC）
RUN <

什么是 Docker Compose？

Docker Compose 是一个用于定义和运行多容器 Docker 应用程序的工具。通过 Compose，您可以使用 YAML 文件来配置应用程序的服务，然后使用一个命令就可以创建并启动所有服务。

安装 Docker Compose

# Docker Desktop 已包含 Compose
# 验证安装
docker-compose --version

# 或使用新的 compose 插件
docker compose version

完整示例：Web 应用 + 数据库 + 缓存

version: '3.8'

services:
  # Web 应用
  web:
    build: .
    container_name: myapp-web
    ports:
      - "3000:3000"
    volumes:
      - .:/app
      - /app/node_modules
    environment:
      - NODE_ENV=development
      - DB_HOST=db
      - REDIS_HOST=redis
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - app-network
    restart: unless-stopped

  # PostgreSQL 数据库
  db:
    image: postgres:15-alpine
    container_name: myapp-db
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: appuser
      POSTGRES_PASSWORD: secretpassword
    volumes:
      - postgres-data:/var/lib/postgresql/data
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    ports:
      - "5432:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U appuser -d myapp"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - app-network
    restart: unless-stopped

  # Redis 缓存
  redis:
    image: redis:7-alpine
    container_name: myapp-redis
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    command: redis-server --appendonly yes
    networks:
      - app-network
    restart: unless-stopped

  # Nginx 反向代理
  nginx:
    image: nginx:alpine
    container_name: myapp-nginx
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./ssl:/etc/nginx/ssl
    depends_on:
      - web
    networks:
      - app-network
    restart: unless-stopped

# 数据卷定义
volumes:
  postgres-data:
    driver: local
  redis-data:
    driver: local

# 网络定义
networks:
  app-network:
    driver: bridge

核心概念

  • services: 定义要运行的容器服务
  • build: 从 Dockerfile 构建镜像
  • image: 使用现成的镜像
  • ports: 端口映射（主机:容器）
  • volumes: 数据卷挂载
  • environment: 环境变量
  • depends_on: 服务依赖关系
  • networks: 网络配置
  • healthcheck: 健康检查
  • restart: 重启策略

常用命令

# 启动所有服务（后台运行）
docker-compose up -d

# 启动所有服务（前台运行，查看日志）
docker-compose up

# 停止所有服务
docker-compose stop

# 停止并删除所有服务、网络
docker-compose down

# 停止并删除所有服务、网络、数据卷
docker-compose down -v

# 构建镜像
docker-compose build

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

# 查看服务状态
docker-compose ps

# 查看服务日志
docker-compose logs

# 查看特定服务日志
docker-compose logs -f web

# 重启服务
docker-compose restart

# 重启特定服务
docker-compose restart web

# 进入容器
docker-compose exec web sh

# 查看资源使用情况
docker-compose top

# 扩展服务（如扩展到3个副本）
docker-compose up -d --scale web=3

# 列出所有容器
docker-compose ps -a

重启策略

# 不自动重启（默认）
restart: "no"

# 总是重启
restart: always

# 失败时重启
restart: on-failure

# 失败时重启，最多5次
restart: on-failure:5

# 除非手动停止，否则总是重启
restart: unless-stopped

环境变量管理

# 方法1：在 docker-compose.yml 中定义
environment:
  - DB_HOST=localhost
  - DB_PORT=5432

# 方法2：使用 .env 文件
# 创建 .env 文件：
# DB_HOST=localhost
# DB_PORT=5432

# 在 docker-compose.yml 中引用：
environment:
  - DB_HOST=${DB_HOST}
  - DB_PORT=${DB_PORT}

# 方法3：使用 env_file
env_file:
  - .env
  - .env.production

多环境配置

# 基础配置：docker-compose.yml
version: '3.8'
services:
  web:
    build: .

# 开发环境：docker-compose.dev.yml
version: '3.8'
services:
  web:
    volumes:
      - .:/app
    environment:
      - NODE_ENV=development

# 生产环境：docker-compose.prod.yml
version: '3.8'
services:
  web:
    environment:
      - NODE_ENV=production
    restart: always

# 使用不同的配置文件
docker-compose -f docker-compose.yml -f docker-compose.dev.yml up -d

最佳实践

  • 使用命名卷：便于备份和迁移
  • 设置健康检查：确保服务真正可用
  • 配置重启策略：自动恢复失败的服务
  • 使用环境变量：避免敏感信息硬编码
  • 定义网络：隔离不同应用的服务
  • 限制资源：防止服务占用过多资源
  • 使用 .env 文件：管理环境变量
  • 版本控制：将配置文件纳入版本管理

什么是 WASM 容器？

WebAssembly (WASM) 容器是 2026 年 Docker 的革命性特性。它将 WASM 模块作为容器运行，提供接近原生的性能、极小的镜像大小（通常 <1MB）和更强的隔离性。

运行 WASM 容器

# 启用 WASM 支持（需要 Docker 27.0+）
export DOCKER_CLI_EXPERIMENTAL=enabled

# 运行 WASM 容器
docker run --runtime=wasm --rm -p 8080:8080 \
  wasmcloud/http-hello-world

# 查看 WASM 运行时
docker info | grep -i wasm

# 使用 Docker Compose 运行 WASM 服务
docker compose --compatibility up -d

WASM Dockerfile 示例

# syntax=docker/dockerfile:1.6
# 使用 WASM 基础镜像（基于 Spin 或 WasmEdge）

FROM ghcr.io/spinframework/spin:latest AS builder
WORKDIR /app

# 编译 WASM 应用
# 假设有一个简单的 HTTP 服务
COPY spin.toml .
COPY src/ ./src/

# 构建目标 WASM
RUN spin build

# 运行阶段
FROM scratch
COPY --from=builder /app/spin.toml .
COPY --from=builder /app/target/wasm32-wasi/release/app.wasm ./app.wasm

# 使用 WASM 运行时
CMD ["spin", "up"]

# WASM 应用通常很小（<1MB）
# 比传统容器小 100-1000 倍

WASM 容器优势

  • 极小体积：镜像通常 <1MB，比传统容器小 100-1000 倍
  • 快速启动：毫秒级启动，比传统容器快 10-100 倍
  • 高安全性：基于能力的安全模型，更强的隔离性
  • 跨平台：一次构建，随处运行（Linux、macOS、Windows）
  • 多语言支持：支持 Rust、Go、Python、JavaScript 等语言
  • 低资源占用：内存占用通常是传统容器的 10%
  • 无服务器友好：完美适配 FaaS 和边缘计算场景

WASM vs 传统容器对比

# 传统容器
镜像大小：~150MB (Node.js 应用)
启动时间：~1-2 秒
内存占用：~50-100MB
隔离性：Linux 命名空间 + cgroups

# WASM 容器
镜像大小：~500KB - 1MB
启动时间：~10-50ms
内存占用：~5-10MB
隔离性：WASM 能力模型 + 沙箱

# 性能提升：
- 镜像拉取速度：提升 100-200 倍
- 冷启动时间：提升 20-100 倍
- 资源利用率：提升 5-10 倍

Docker Compose WASM 示例

version: '3.8'

services:
  # WASM 微服务
  wasm-api:
    image: wasmcloud/http-hello-world
    runtime: wasm
    ports:
      - "8080:8080"
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 50M
    restart: unless-stopped

  # 传统容器（用于数据库）
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data

volumes:
  redis-data:

2026 Docker 新特性

🏗️

BuildKit 2.0

分布式构建、智能缓存、并行执行，构建速度提升 5-10 倍。支持远程构建和团队共享缓存。

🔍

Docker Scout

AI 驱动的漏洞扫描、SBOM 生成、合规检查。实时监控镜像安全状态，自动修复安全风险。

🔒

镜像签名

基于 Cosign 的原生签名验证，确保镜像完整性和来源可信。支持硬件密钥和云 KMS。

📊

eBPF 监控

基于 eBPF 的深度容器监控，零开销的性能追踪、网络分析和安全审计。

🤖

AI Dockerfile 生成

使用大语言模型自动生成优化 Dockerfile，智能选择基础镜像和依赖版本。

⚡

OCI v1.2 支持

完整的 OCI 规范支持，兼容所有符合标准的容器运行时和工具链。

使用 Docker Scout 进行安全扫描

# 扫描镜像漏洞
docker scout cves myapp:latest

# 快速漏洞扫描
docker scout quickview myapp:latest

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

# 查看镜像详情和依赖关系
docker scout repo myapp:latest

# 比较镜像差异
docker scout compare old:latest new:latest

# CI/CD 集成（失败如果发现高危漏洞）
docker scout cves --exit-code 1 --severity high,critical myapp:latest

使用 BuildKit 2.0 分布式构建

# 设置分布式构建缓存
export BUILDKIT_REMOTE_CACHE=type=registry,ref=myregistry.com/cache

# 使用远程构建器
docker buildx build \
  --builder=my-builder \
  --cache-from=type=registry,ref=myregistry.com/cache \
  --cache-to=type=registry,ref=myregistry.com/cache,mode=max \
  -t myapp:latest \
  .

# 创建远程构建器
docker buildx create --name remote-builder \
  --driver=docker-container \
  --driver-opt image=moby/buildkit:latest \
  --bootstrap

# 并行构建多架构镜像
docker buildx build \
  --platform linux/amd64,linux/arm64,linux/arm/v7 \
  -t myapp:multiarch \
  --push .

Docker 目录结构详解

📁 为什么了解 Docker 目录结构很重要？

Docker 在主机上创建了多个目录用于存储镜像、容器、卷、网络等数据。了解这些目录的结构和用途可以帮助您：

  • 有效管理存储空间
  • 快速定位和备份重要数据
  • 解决存储相关问题
  • 优化 Docker 性能
  • 进行故障排查

查看 Docker 根目录

# 查看 Docker 根目录位置
docker info | grep "Docker Root Dir"

# 输出示例（Linux/Mac）：
# Docker Root Dir: /var/lib/docker

# Windows 输出示例：
# Docker Root Dir: C:\ProgramData\Docker

# 查看目录大小
du -sh /var/lib/docker/*

Docker 完整目录结构

/var/lib/docker/                      # Docker 根目录
├── aufs/                             # AUFS 存储驱动（如果使用 AUFS）
├── buildkit/                         # BuildKit 构建缓存
│   ├── cache/                        # 构建缓存
│   └── executor/                     # 构建执行器
├── containers/                       # 容器数据
│   └── [container-id]/               # 每个容器的目录
│       ├── config.json               # 容器配置
│       ├── hostname                  # 主机名
│       ├── hosts                     # /etc/hosts
│       ├── resolv.conf               # DNS 配置
│       └── checkpoint/               # 检查点数据
├── image/                            # 镜像元数据
│   └── overlay2/                     # Overlay2 驱动存储（最常用）
│       └── [image-id]/              # 镜像层数据
├── volumes/                          # 命名卷数据
│   └── [volume-name]/                # 每个卷的目录
│       └── _data/                    # 实际数据
├── networks/                         # 网络数据
│   └── files/                        # 网络配置文件
├── swarm/                            # Swarm 模式数据
├── plugins/                          # 插件数据
├── tmp/                              # 临时文件
├── trust/                            # 内容信任数据
│   └── tuf.db                        # 信任数据库
├── engine-id                         # 引擎唯一标识
└── cli-plugins/                      # CLI 插件（2026 新增）
    └── docker-scout/                 # Docker Scout 插件
    └── docker-ai/                    # Docker AI 插件
📦

containers/

存储所有容器的运行时数据、配置文件、日志等。每个容器有独立的目录。

🖼️

image/

存储镜像的元数据和层数据。使用分层存储，共享相同层以节省空间。

💾

volumes/

命名卷的存储位置，用于持久化数据。删除容器不会删除卷数据。

🌐

networks/

网络配置文件，包括桥接网络、覆盖网络等网络模式。

容器目录详解

/var/lib/docker/containers/
└── abc123def456/                     # 容器 ID（短 ID）
    ├── config.json                   # 容器配置（JSON 格式）
    ├── config.v2.json                # 配置版本 2
    ├── hostconfig.json               # 主机配置（端口映射等）
    ├── hostname                      # 容器主机名
    ├── hosts                         # /etc/hosts 文件
    ├── hostname                      # 主机名文件
    ├── resolv.conf                   # DNS 解析配置
    ├── resolv.conf.hash              # DNS 配置哈希
    ├── checkpoints/                  # 检查点数据（用于容器迁移）
    ├── mounts/                       # 挂载点信息
    ├── shm/                          # 共享内存（/dev/shm）
    └── [storage-driver]/             # 存储驱动数据
        └── merged/                   # 容器文件系统（联合挂载）

# 查看容器配置
cat /var/lib/docker/containers/[container-id]/config.json | jq

# 查看容器文件系统
ls -la /var/lib/docker/overlay2/[container-id]/merged/

# 查看容器日志
ls -la /var/lib/docker/containers/[container-id]/[container-id]-json.log

镜像目录详解

/var/lib/docker/image/
└── overlay2/                         # Overlay2 存储驱动
    ├── distribution/                 # 镜像分发信息
    │   └── v2metadata.db             # 镜像元数据数据库
    ├── imagedb/                      # 镜像数据库
    │   ├── content/                   # 镜像内容 SHA256
    │   ├── metadata/                 # 镜像元数据
    │   └── rootfs/                   # 根文件系统引用
    ├── layerdb/                      # 层数据库
    │   ├── sha256/                    # 层 SHA256 目录
    │   │   └── [layer-hash]/         # 每个层的目录
    │   │       ├── cache-id          # 缓存 ID
    │   │       ├── diff/             # 层差异
    │   │       ├── parent            # 父层引用
    │   │       └── size              # 层大小
    │   └── toml/                     # TOML 格式元数据
    └── repositories.json             # 仓库索引文件

# 查看镜像列表
docker images

# 查看镜像层信息
docker history [image-name]

# 查看镜像大小分布
du -sh /var/lib/docker/image/overlay2/*

卷目录详解

/var/lib/docker/volumes/
└── my-volume/                        # 卷名称
    └── _data/                        # 实际数据存储
        ├── app/                      # 应用数据
        └── logs/                     # 日志文件

# 查看所有卷
docker volume ls

# 查看卷详细信息
docker volume inspect my-volume

# 查看卷数据
ls -la /var/lib/docker/volumes/my-volume/_data/

# 创建卷
docker volume create my-volume

# 删除未使用的卷
docker volume prune

网络目录详解

/var/lib/docker/network/
└── files/
    └── local-kv.db                   # 网络键值数据库

# 网络配置存储在数据库中
# 包括桥接、覆盖、macvlan 等网络模式

# 查看所有网络
docker network ls

# 查看网络详细信息
docker network inspect bridge

# 查看网络中的容器
docker network inspect bridge | jq '[].[0].Containers'

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

# 删除未使用的网络
docker network prune

BuildKit 目录详解（2026 优化）

/var/lib/docker/buildkit/
├── cache/                            # 构建缓存
│   └── [cache-key]/                  # 按缓存键组织
│       └── [data]/                   # 缓存数据
├── executor/                         # 构建执行器
│   └── [build-id]/                   # 每个构建的目录
│       ├── snapshot.db              # 快照数据库
│       └── metadata.db              # 元数据数据库
└── state/                            # 构建状态
    └── [build-id]/                   # 构建状态

# 清理构建缓存
docker builder prune

# 查看构建缓存
docker builder ls

# 查看构建缓存详情
docker builder inspect [build-id]

# 使用缓存挂载（减少构建时间）
# 在 Dockerfile 中使用：
# RUN --mount=type=cache,target=/root/.npm npm ci

不同操作系统的 Docker 目录

  • Linux: /var/lib/docker
  • macOS (Docker Desktop): ~/Library/Containers/com.docker.docker/Data/vms/0/data/
  • macOS (Colima): ~/.colima/default/docker/
  • Windows: C:\ProgramData\Docker
  • Windows (WSL2): \\wsl$\docker-desktop-data\data\docker\

查看和管理 Docker 存储空间

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

# 详细磁盘使用
docker system df -v

# 查看特定目录大小
du -sh /var/lib/docker/*
du -sh /var/lib/docker/containers/*
du -sh /var/lib/docker/volumes/*

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

# 清理所有未使用的资源（包括卷）
docker system prune -a --volumes

# 清理构建缓存
docker builder prune

# 清理镜像
docker image prune

# 清理容器
docker container prune

# 清理卷
docker volume prune

# 清理网络
docker network prune

备份和恢复 Docker 数据

# 备份 Docker 目录（需要停止 Docker）
sudo systemctl stop docker
sudo tar -czf docker-backup-$(date +%Y%m%d).tar.gz /var/lib/docker
sudo systemctl start docker

# 恢复 Docker 目录
sudo systemctl stop docker
sudo tar -xzf docker-backup-20240127.tar.gz -C /
sudo systemctl start docker

# 备份特定卷
docker run --rm -v my-volume:/data -v $(pwd):/backup \
  alpine tar czf /backup/my-volume-backup.tar.gz /data

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

# 导出容器为镜像
docker commit [container-id] my-backup:latest

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

# 导入镜像
docker load -i my-image.tar

Docker 目录管理最佳实践

  • 定期清理：定期使用 docker system prune 清理未使用的资源
  • 监控空间：使用 docker system df 监控磁盘使用情况
  • 使用卷：持久化数据使用命名卷，不要存储在容器中
  • 备份数据：定期备份重要卷和配置
  • 限制大小：为容器设置资源限制，避免占用过多空间
  • 使用缓存：利用 BuildKit 缓存减少重复构建
  • 分层优化：优化 Dockerfile 减少层数和大小

Docker 网络详解

🌐 为什么需要理解 Docker 网络？

Docker 网络是容器间通信和容器与外部通信的基础。掌握 Docker 网络可以帮助您：

  • 实现容器间安全通信
  • 隔离不同应用的网络
  • 优化网络性能
  • 实现负载均衡
  • 部署微服务架构
  • 实现服务发现

网络类型

# 查看所有网络
docker network ls

# 查看网络详细信息
docker network inspect bridge

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

# 创建覆盖网络（用于 Swarm）
docker network create --driver overlay my-overlay

# 创建 Macvlan 网络（直接连接物理网络）
docker network create --driver macvlan \
  --subnet=192.168.1.0/24 \
  --gateway=192.168.1.1 \
  -o parent=eth0 my-macvlan

# 删除网络
docker network rm my-network
🌉

Bridge 网络模式

默认网络模式，容器通过 Docker 网桥通信，适合单主机场景。每个容器有独立的 IP 地址。

🔗

Host 网络模式

容器直接使用主机网络，没有网络隔离。性能最高但安全性较低，适合需要高性能的场景。

📦

Container 网络模式

容器共享另一个容器的网络命名空间，适合需要共享网络栈的场景。

🌍

None 网络模式

容器没有网络接口，完全隔离。适合需要高安全性的任务或批处理作业。

🔮

Overlay 网络模式

跨主机的容器网络，用于 Docker Swarm 集群。支持服务发现和负载均衡。

🎯

Macvlan 网络模式

容器直接连接物理网络，每个容器有独立的 MAC 地址。适合需要直接访问物理网络的场景。

Bridge 网络详解

# 查看默认桥接网络
docker network inspect bridge

# 创建自定义桥接网络
docker network create \
  --driver bridge \
  --subnet=172.20.0.0/16 \
  --gateway=172.20.0.1 \
  --ip-range=172.20.0.0/24 \
  --opt com.docker.network.bridge.name=br-custom \
  my-bridge-network

# 连接容器到网络
docker network connect my-bridge-network container1
docker network disconnect my-bridge-network container1

# 运行容器时指定网络
docker run -d --name web \
  --network my-bridge-network \
  -p 8080:80 \
  nginx:alpine

# 容器间通信（使用容器名作为主机名）
# 容器1: web
# 容器2: db
# 在 web 容器中可以访问 db: curl http://db:5432

# 查看容器的网络配置
docker inspect container1 | grep -A 20 "Networks"

Overlay 网络详解（用于 Swarm）

# 初始化 Swarm 集群
docker swarm init

# 创建覆盖网络
docker network create \
  --driver overlay \
  --opt encrypted \
  --subnet=10.0.0.0/24 \
  my-overlay-network

# 部署服务到覆盖网络
docker service create \
  --name web \
  --network my-overlay-network \
  --replicas 3 \
  nginx:alpine

# 查看服务网络
docker service ps web
docker network inspect my-overlay-network

# 服务发现：服务名可以解析为服务的所有 IP
# curl http://web

# 在服务中使用覆盖网络
docker service create \
  --name api \
  --network my-overlay-network \
  -e DB_HOST=db \
  my-api:latest

# 服务自动发现和负载均衡

Docker Compose 网络配置

version: '3.8'

services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
    networks:
      - frontend
      - backend

  app:
    image: myapp:latest
    networks:
      - backend
    depends_on:
      - db

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

networks:
  frontend:
    driver: bridge
    ipam:
      config:
        - subnet: 172.28.0.0/16
          gateway: 172.28.0.1

  backend:
    driver: bridge
    internal: true  # 隔离网络，不能访问外网
    ipam:
      config:
        - subnet: 172.29.0.0/16
          gateway: 172.29.0.1

volumes:
  db-data:

网络高级配置

# 创建带 DNS 的网络
docker network create \
  --driver bridge \
  --opt "com.docker.network.bridge.enable_ip_masquerade"="true" \
  --opt "com.docker.network.bridge.host_binding_ipv4"="0.0.0.0" \
  --opt "com.docker.network.mtu"="1500" \
  my-dns-network

# 为网络指定 DNS 服务器
docker run -d --name myapp \
  --network my-dns-network \
  --dns 8.8.8.8 \
  --dns 8.8.4.4 \
  myapp:latest

# 设置容器的 hostname
docker run -d --name myapp \
  --hostname myapp.example.com \
  --network my-bridge-network \
  myapp:latest

# 添加额外的 hosts
docker run -d --name myapp \
  --add-host host1:192.168.1.100 \
  --add-host host2:192.168.1.101 \
  myapp:latest

# 端口映射语法
docker run -d -p 8080:80 nginx              # 主机8080 -> 容器80
docker run -d -p 8080:80 -p 8443:443 nginx  # 多个端口
docker run -d -p 0.0.0.0:8080:80 nginx      # 绑定所有接口
docker run -d -p 127.0.0.1:8080:80 nginx    # 只绑定 localhost
docker run -d -p 8080:80/tcp nginx          # 指定协议
docker run -d -p 8080:80/udp nginx          # UDP 协议

网络故障排查

# 检查容器网络配置
docker inspect container1 | jq '.[0].NetworkSettings'

# 检查容器网络连接
docker network inspect bridge | jq '.[0].Containers'

# 测试容器网络连接
docker exec container1 ping -c 3 google.com
docker exec container1 curl http://example.com

# 检查容器端口监听
docker exec container1 netstat -tuln

# 查看 DNS 解析
docker exec container1 cat /etc/resolv.conf

# 测试容器间连接
docker exec container1 ping -c 3 container2

# 查看网络流量
docker stats --no-stream

# 查看网络统计
docker network inspect bridge | jq '.[0].IPAM.Config'

# 清理未使用的网络
docker network prune

Docker 网络最佳实践

  • 使用自定义网络：避免使用默认 bridge 网络
  • 网络隔离：不同应用使用不同网络
  • 使用服务名：容器间通过服务名通信，不要使用 IP
  • 内部网络：敏感服务使用 internal 网络
  • 端口限制：只暴露必要的端口
  • 监控网络：定期检查网络流量和连接
  • 使用 Compose：使用 Docker Compose 管理复杂网络
  • 网络加密：跨主机通信使用加密的 overlay 网络

Docker 数据卷详解

💾 为什么需要理解 Docker 数据卷？

Docker 容器是临时的，容器删除后数据会丢失。数据卷提供了持久化存储解决方案，帮助您：

  • 持久化容器数据
  • 在容器间共享数据
  • 实现数据备份和恢复
  • 分离应用和数据
  • 提高 I/O 性能
  • 实现数据迁移

数据卷类型

# 1. 命名卷（Named Volumes）
docker volume create my-volume
docker run -d --name myapp \
  -v my-volume:/data \
  nginx:alpine

# 2. 匿名卷（Anonymous Volumes）
docker run -d --name myapp \
  -v /data \
  nginx:alpine

# 3. 绑定挂载（Bind Mounts）
docker run -d --name myapp \
  -v /host/path:/container/path \
  nginx:alpine

# 4. tmpfs 挂载（临时文件系统）
docker run -d --name myapp \
  --tmpfs /tmp \
  nginx:alpine

# 5. 只读卷
docker run -d --name myapp \
  -v my-volume:/data:ro \
  nginx:alpine
🏷️

命名卷

由 Docker 管理，存储在 /var/lib/docker/volumes。适合持久化数据，独立于容器生命周期。

📂

绑定挂载

将主机目录挂载到容器，直接访问主机文件系统。适合开发和配置文件管理。

💨

匿名卷

自动创建的无名卷，通常在 Dockerfile 中使用。适合临时数据存储。

⚡

tmpfs 挂载

数据存储在内存中，容器重启后数据丢失。适合临时文件和缓存。

命名卷操作

# 创建命名卷
docker volume create my-volume

# 创建带标签的卷
docker volume create \
  --label project=myapp \
  --label environment=production \
  my-volume

# 查看所有卷
docker volume ls

# 查看卷详细信息
docker volume inspect my-volume

# 查看卷数据
ls -la /var/lib/docker/volumes/my-volume/_data/

# 使用命名卷运行容器
docker run -d --name myapp \
  -v my-volume:/data \
  nginx:alpine

# 连接卷到运行中的容器
docker volume create another-volume
docker run -d --name another-app \
  -v another-volume:/data \
  nginx:alpine

# 在容器间共享卷
docker run -d --name app1 -v shared-data:/app nginx
docker run -d --name app2 -v shared-data:/data nginx

# 删除卷（卷未被使用时）
docker volume rm my-volume

# 删除所有未使用的卷
docker volume prune

# 删除所有卷（包括正在使用的）
docker volume ls -q | xargs docker volume rm

绑定挂载详解

# 基本绑定挂载
docker run -d --name myapp \
  -v /host/path:/container/path \
  nginx:alpine

# 指定读写权限
docker run -d --name myapp \
  -v /host/path:/container/path:ro \
  nginx:alpine

# 只写权限
docker run -d --name myapp \
  -v /host/path:/container/path:rw \
  nginx:alpine

# 挂载多个目录
docker run -d --name myapp \
  -v /host/html:/usr/share/nginx/html \
  -v /host/logs:/var/log/nginx \
  -v /host/conf:/etc/nginx/conf.d \
  nginx:alpine

# 使用相对路径（相对于 Docker Compose 文件）
docker run -d --name myapp \
  -v ./html:/usr/share/nginx/html \
  nginx:alpine

# 挂载单个文件
docker run -d --name myapp \
  -v /host/nginx.conf:/etc/nginx/nginx.conf:ro \
  nginx:alpine

# 使用 SELinux 标签（Linux）
docker run -d --name myapp \
  -v /host/data:/container/data:z \
  nginx:alpine

# 使用 macOS 共享优化
docker run -d --name myapp \
  -v /host/data:/container/data:delegated \
  nginx:alpine

Docker Compose 卷配置

version: '3.8'

services:
  db:
    image: postgres:15
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - type: volume
        source: pgdata
        target: /var/lib/postgresql/data
      - type: bind
        source: ./init.sql
        target: /docker-entrypoint-initdb.d/init.sql
        read_only: true
    restart: unless-stopped

  web:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - type: volume
        source: nginx-cache
        target: /var/cache/nginx
      - type: bind
        source: ./html
        target: /usr/share/nginx/html
        read_only: true
      - type: bind
        source: ./logs
        target: /var/log/nginx
    restart: unless-stopped

  app:
    image: myapp:latest
    environment:
      - DATA_DIR=/data
    volumes:
      - type: volume
        source: app-data
        target: /data
      - type: tmpfs
        target: /tmp
        tmpfs:
          size: 100m
          mode: 1777
    restart: unless-stopped

volumes:
  pgdata:
    driver: local
    driver_opts:
      type: none
      o: bind
      device: /data/postgres

  nginx-cache:
    driver: local

  app-data:
    driver: local
    labels:
      project: myapp
      environment: production

卷备份和恢复

# 备份命名卷
docker run --rm \
  -v my-volume:/data \
  -v $(pwd):/backup \
  alpine tar czf /backup/my-volume-backup.tar.gz /data

# 恢复命名卷
docker run --rm \
  -v my-volume:/data \
  -v $(pwd):/backup \
  alpine sh -c "cd /data && tar xzf /backup/my-volume-backup.tar.gz --strip 1"

# 备份绑定挂载
tar czf host-data-backup.tar.gz /host/path

# 使用容器备份（适用于任何卷类型）
docker run --rm \
  --volumes-from myapp \
  -v $(pwd):/backup \
  alpine tar czf /backup/container-backup.tar.gz /data

# 恢复到新容器
docker run -d --name new-app \
  -v my-volume:/data \
  alpine sh -c "cd /data && tar xzf /backup/container-backup.tar.gz --strip 1"

# 使用 rsync 同步数据
docker run --rm \
  -v my-volume:/data \
  -v /backup:/backup \
  alpine sh -c "apk add rsync && rsync -av /backup/ /data/"

卷性能优化

# 使用 tmpfs 提升性能（临时数据）
docker run -d --name myapp \
  --tmpfs /tmp:size=1g \
  --tmpfs /cache:size=2g \
  nginx:alpine

# macOS 绑定挂载优化（使用 :delegated）
docker run -d --name myapp \
  -v /host/path:/container/path:delegated \
  nginx:alpine

# macOS 绑定挂载优化（使用 :cached）
docker run -d --name myapp \
  -v /host/path:/container/path:cached \
  nginx:alpine

# 使用本地卷驱动（自定义路径）
docker volume create \
  --driver local \
  --opt type=none \
  --opt device=/custom/path \
  --opt o=bind \
  my-custom-volume

# 使用 NFS 卷（生产环境）
docker volume create \
  --driver local \
  --opt type=nfs \
  --opt o=addr=nfs-server,rw \
  --opt device=:/path/to/nfs/share \
  nfs-volume

# 使用卷驱动插件（第三方）
docker volume create \
  --driver rexray/ebs \
  --name my-ebs-volume \
  --size 10

卷故障排查

# 查看卷使用情况
docker volume ls -f dangling=true

# 查看卷大小
du -sh /var/lib/docker/volumes/*

# 检查容器卷挂载
docker inspect myapp | jq '.[0].Mounts'

# 查看卷权限
docker exec myapp ls -la /data

# 修复卷权限问题
docker exec myapp chown -R 1000:1000 /data

# 测试卷读写
docker exec myapp touch /data/test
docker exec myapp echo "hello" > /data/test.txt
docker exec myapp cat /data/test.txt

# 查看卷使用情况
docker system df -v | grep VOLUME

# 清理未使用的卷
docker volume prune

Docker 卷最佳实践

  • 使用命名卷：生产环境优先使用命名卷而非绑定挂载
  • 定期备份：重要数据必须定期备份
  • 权限管理：正确设置卷的读写权限
  • 监控使用：定期检查卷的使用情况和大小
  • 文档化：记录每个卷的用途和依赖关系
  • 使用标签：为卷添加标签便于管理
  • 分离关注点：数据和应用分离，便于维护和迁移
  • 使用 tmpfs：临时文件使用 tmpfs 提升性能
  • 网络卷：生产环境使用 NFS 或云存储
  • 清理策略：定期清理未使用的卷释放空间

常用命令速查

镜像操作

docker pull image:tag 拉取镜像
docker build -t name . 构建镜像
docker images 列出镜像
docker rmi image 删除镜像
docker tag source target 标记镜像

容器操作

docker run image 运行容器
docker ps 列出运行中的容器
docker ps -a 列出所有容器
docker stop container 停止容器
docker rm container 删除容器
docker logs container 查看日志

容器管理

docker exec -it container sh 进入容器
docker cp local container:path 复制文件到容器
docker inspect container 查看容器详情
docker stats 查看资源使用
docker port container 查看端口映射

Docker Compose

docker-compose up -d 启动所有服务
docker-compose down 停止所有服务
docker-compose ps 查看服务状态
docker-compose logs 查看服务日志
docker-compose build 构建镜像
docker-compose restart 重启服务
docker-compose exec web sh 进入容器

清理命令

docker system prune 清理未使用资源
docker volume prune 清理未使用卷
docker network prune 清理未使用网络

实战示例

🌐 Web 应用部署

使用 Nginx 部署静态网站

FROM nginx:alpine
COPY . /usr/share/nginx/html

🗄️ 数据库部署

快速启动 MySQL 数据库

docker run -d \
  --name mysql \
  -e MYSQL_ROOT_PASSWORD=123456 \
  -p 3306:3306 \
  mysql:8.0

🐍 Python 应用

容器化 Python Flask 应用

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "app.py"]

🐳 WASM 应用

构建轻量级 WASM 容器应用

# 构建阶段
FROM ghcr.io/spinframework/spin:latest AS builder
COPY spin.toml .
RUN spin build

# 运行阶段
FROM scratch
COPY --from=builder /app/spin.toml .
COPY --from=builder /app/app.wasm ./app.wasm
CMD ["spin", "up"]

Docker 最佳实践（2026版）

📋 为什么需要遵循最佳实践？

遵循 Docker 最佳实践可以带来显著的好处：提高安全性、优化性能、降低成本、简化维护、提升团队协作效率。

✅

使用轻量级基础镜像

选择 Alpine 或 slim 版本的基础镜像，可以显著减少镜像大小。例如使用 node:20-alpine 而不是 node:20。Alpine 镜像通常只有 5MB，而标准镜像可能超过 100MB。

# 推荐
FROM node:20-alpine

# 不推荐
FROM node:20
✅

多阶段构建

将构建和运行环境分离，最终镜像只包含运行时所需的文件。这可以大幅减小镜像体积并提高安全性。

# 构建阶段
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN --mount=type=cache,target=/root/.npm npm ci
COPY . .
RUN npm run build

# 运行阶段
FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
CMD ["node", "dist/index.js"]
✅

最小化层数

合并相关的 RUN 命令，减少 Dockerfile 中的层数。过多的层会增加镜像大小和构建时间。每个 RUN 命令都会创建一个新层。

# 不推荐：多个 RUN 命令
RUN apk add --no-cache git
RUN apk add --no-cache curl
RUN apk add --no-cache wget

# 推荐：合并为一个命令
RUN apk add --no-cache git curl wget
✅

利用缓存

将不常变化的指令放在前面，充分利用 Docker 的层缓存机制。这样可以大幅加快构建速度。

# 推荐：先复制依赖文件
COPY package*.json ./
RUN npm ci

# 后再复制源代码（代码变化频繁）
COPY . .
✅

使用 .dockerignore

创建 .dockerignore 文件排除不需要的文件（如 node_modules、.git、.DS_Store），减少构建上下文大小和构建时间。

# .dockerignore 示例
node_modules
.git
.gitignore
.env
.env.local
*.log
coverage
.DS_Store
.vscode
.idea
✅

使用 BuildKit 2.0

启用 BuildKit 和缓存挂载，利用分布式构建和智能缓存，构建速度提升 5-10 倍。

# 启用 BuildKit
export DOCKER_BUILDKIT=1

# 使用缓存挂载
RUN --mount=type=cache,target=/root/.npm npm ci

# 使用 SSH
RUN --mount=type=ssh git clone git@github.com:org/repo.git
🔒

以非 root 用户运行

在 Dockerfile 中创建并切换到非 root 用户，提高容器安全性。以 root 用户运行容器会带来安全风险。

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

# 切换到非 root 用户
USER appuser
🔒

使用健康检查

定义 HEALTHCHECK 指令，确保容器真正可用，便于编排系统自动恢复不健康的容器。

HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:3000/health || exit 1
🔒

镜像签名和验证

使用 Docker Content Trust 或 Cosign 对镜像进行签名，确保镜像来源可信且未被篡改。

# 启用内容信任
export DOCKER_CONTENT_TRUST=1

# 拉取已签名的镜像
docker pull myrepo/myimage:signed

# 签名镜像
docker trust sign myrepo/myimage:latest

# 验证签名
docker trust inspect myrepo/myimage:latest
🔒

定期使用 Docker Scout 扫描

集成 Docker Scout 到 CI/CD 流程，自动扫描镜像漏洞，及时发现并修复安全问题。

# 扫描镜像
docker scout cves myapp:latest

# 快速扫描
docker scout quickview myapp:latest

# 生成 SBOM
docker scout sbom myapp:latest --output sbom.json
🔒

生成和维护 SBOM

使用 Docker Scout 生成软件物料清单（SBOM），满足合规要求并便于供应链安全审计。

# 生成 SBOM
docker scout sbom myapp:latest --output sbom.json

# 分析 SBOM
docker scout sbom myapp:latest --format spdx-json

# 导出为不同格式
docker scout sbom myapp:latest --output sbom.spdx.json
docker scout sbom myapp:latest --output sbom.cyclonedx.json
🔒

使用 Secrets 管理敏感信息

不要在 Dockerfile 或 docker-compose.yml 中硬编码密码、API 密钥等敏感信息。使用 Docker secrets 或环境变量。

# 使用环境变量
docker run -e DB_PASSWORD=secret myapp:latest

# 使用 Docker secrets（Swarm）
echo "my-secret-password" | docker secret create db_password -

# 使用 BuildKit secrets
docker build --secret id=db_password .
🔒

设置资源限制

为容器设置 CPU、内存限制，防止单个容器占用过多资源导致系统不稳定。

# 设置内存限制
docker run -m 512m myapp:latest

# 设置 CPU 限制
docker run --cpus="1.5" myapp:latest

# Docker Compose 中设置
services:
  web:
    deploy:
      resources:
        limits:
          cpus: '0.50'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 128M
🌐

使用自定义网络

避免使用默认的 bridge 网络，创建自定义网络以便更好地管理和隔离应用。

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

# 将容器连接到自定义网络
docker run --network my-network myapp:latest
🌐

使用服务名通信

容器间通过服务名通信，不要使用 IP 地址。这样更灵活且易于维护。

# 推荐：使用服务名
curl http://db:5432

# 不推荐：使用 IP
curl http://172.17.0.2:5432
🌐

网络隔离

不同应用使用不同网络，敏感服务使用内部网络（internal: true），不能访问外网。

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    internal: true  # 隔离网络
🌐

最小化端口暴露

只暴露必要的端口，不要将所有端口都暴露到主机。使用 -p 参数精确指定端口映射。

# 推荐：只暴露必要端口
docker run -p 8080:80 nginx:alpine

# 不推荐：暴露所有端口
docker run --net=host nginx:alpine
🌐

使用 HTTPS

生产环境必须使用 HTTPS，配置 SSL/TLS 证书保护数据传输安全。

services:
  web:
    image: nginx:alpine
    ports:
      - "443:443"
    volumes:
      - ./ssl:/etc/nginx/ssl
💾

使用命名卷

生产环境优先使用命名卷而非绑定挂载。命名卷由 Docker 管理，更易于备份和迁移。

# 创建命名卷
docker volume create my-data

# 使用命名卷
docker run -v my-data:/data myapp:latest
💾

定期备份数据

重要数据必须定期备份。使用 tar 或专用备份工具备份命名卷和绑定挂载。

# 备份命名卷
docker run --rm \
  -v my-volume:/data \
  -v $(pwd):/backup \
  alpine tar czf /backup/my-volume-backup.tar.gz /data
💾

不要在容器中存储重要数据

使用 Docker volumes 或 bind mounts 来持久化数据。容器删除后，容器内的数据会丢失。

💾

使用只读卷

对于不需要写入的数据，使用只读卷（:ro）提高安全性，防止意外修改。

# 只读挂载
docker run -v /host/config:/container/config:ro myapp:latest
💾

使用 tmpfs 提升性能

对于临时文件和缓存，使用 tmpfs 挂载存储在内存中，提升性能。

# 使用 tmpfs
docker run --tmpfs /tmp:size=1g myapp:latest
⭐

使用 WASM 容器

对于合适的场景（如微服务、边缘计算），优先使用 WASM 容器，获得更小的体积（<1MB）和更快的启动（10-50ms）。

# 运行 WASM 容器
docker run --runtime=wasm my-wasm-app:latest
⭐

集成 AI 工具

使用 AI 工具优化 Dockerfile、分析性能和检测安全问题，提升开发效率。

# AI 优化 Dockerfile
dockerfile-gpt --app-type nodejs --optimize-for production

# AI 安全扫描
docker scout cves --ai-suggest-fixes myapp:latest
⭐

使用 eBPF 监控

利用 eBPF 进行深度容器监控，零开销地收集性能指标和安全事件。

# 安装 eBPF 监控工具
kubectl apply -f https://raw.githubusercontent.com/kinvolk/inspektor-gadget/main/deploy/k8s/gadget.yaml

# 监控容器网络流量
sudo ig trace exec -n mynamespace
⭐

使用 BuildKit 2.0 分布式构建

利用 BuildKit 2.0 的分布式构建功能，共享构建缓存，加快团队构建速度。

# 创建远程构建器
docker buildx create --name remote-builder \
  --driver=docker-container \
  --driver-opt image=moby/buildkit:latest

# 使用远程构建器
docker buildx build --builder=remote-builder -t myapp:latest .
⭐

使用容器签名

采用 Cosign 或 Notary 等工具对镜像进行签名和验证，确保供应链安全。

# 使用 Cosign 签名
cosign sign myrepo/myimage:latest

# 使用 Cosign 验证
cosign verify myrepo/myimage:latest
⭐

使用 OCI v1.2 规范

确保镜像符合 OCI v1.2 规范，提高兼容性和互操作性。

⭐

采用零信任架构

实施零信任安全模型，对所有容器进行持续验证和监控。

🤖 AI 辅助 Docker 工具

2026 年的 AI Docker 生态

利用 AI 工具可以显著提升 Docker 开发效率，自动生成配置、优化镜像、检测漏洞，并提供智能建议。以下是 2026 年主流的 AI Docker 工具。

🤖

Docker AI Assistant

官方 AI 助手，集成在 Docker Desktop 中，提供智能 Dockerfile 生成、配置建议和问题诊断。

✨

Dockerfile-GPT

开源的 AI 工具，根据应用代码自动生成优化的 Dockerfile，支持多语言框架。

🔍

ContainerAI

AI 驱动的容器安全分析，自动检测配置错误、安全漏洞和性能瓶颈。

🚀

BuildOptimizer

使用机器学习优化构建过程，智能调整缓存策略、依赖顺序和并行构建。

使用 Docker AI Assistant 生成 Dockerfile

# 方法 1：使用 Docker Desktop AI 助手
docker assistant generate-dockerfile \
  --context ./my-app \
  --language typescript \
  --framework nextjs

# 方法 2：使用 CLI 工具
dockerfile-gpt --app-type nodejs \
  --optimize-for production \
  --target-size < 50MB

# 方法 3：使用 Docker Scout AI（集成在扫描中）
docker scout cves --ai-suggest-fixes myapp:latest

AI 优化 Dockerfile 示例

# 原始 Dockerfile（AI 生成前）
FROM node:18
WORKDIR /app
COPY . .
RUN npm install
RUN npm run build
CMD ["node", "server.js"]

# AI 优化后的 Dockerfile
# syntax=docker/dockerfile:1.4
FROM node:20-alpine AS builder
WORKDIR /app

# AI 建议的优化点：
# 1. 使用最新 LTS 版本
# 2. 使用 Alpine 减小镜像大小
# 3. 多阶段构建分离构建和运行
# 4. 利用 BuildKit 缓存挂载
# 5. 分层复制以优化缓存

COPY package*.json ./
RUN --mount=type=cache,target=/root/.npm \
    npm ci --only=production

COPY . .
RUN npm run build

FROM node:20-alpine
WORKDIR /app

RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001

COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY package*.json ./

USER nodejs
EXPOSE 3000
HEALTHCHECK --interval=30s --timeout=3s \
    CMD node -e "require('http').get('http://localhost:3000/health', (r) => {process.exit(r.statusCode === 200 ? 0 : 1)})"

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

# 结果：镜像大小从 500MB 减少到 80MB

AI 安全分析和修复

# 使用 AI 进行安全扫描和修复
docker scout cves --ai-fix myapp:latest

# 输出示例：
# 发现 3 个高危漏洞：
# 1. lodash < 4.17.21
#    AI 建议：升级到 4.17.21
#    自动修复：npm install lodash@4.17.21
#
# 2. node:18-alpine
#    AI 建议：升级到 node:20-alpine
#    理由：node:18 已停止维护，存在已知安全风险
#
# 3. 使用 root 用户运行
#    AI 建议：创建非 root 用户
#    安全提升：容器逃逸风险降低 80%

# 生成安全报告
docker scout cves --ai-report security-report.json myapp:latest

AI 驱动的性能优化

# 分析容器性能
docker ai analyze-performance myapp:latest

# 输出优化建议：
# 1. 内存使用：120MB
#    AI 建议：启用 --memory-limit=150MB
#    预期节省：30% 内存
#
# 2. 启动时间：2.5s
#    AI 建议：使用依赖预加载
#    预期提升：启动时间 < 1s
#
# 3. 镜像层数：12 层
#    AI 建议：合并 RUN 命令
#    预期优化：减少到 8 层
#
# 4. 并发处理能力：50 req/s
#    AI 建议：启用 HTTP/2 和 keep-alive
#    预期提升：150 req/s

# 自动应用优化
docker ai optimize --apply-all myapp:latest

AI 工具最佳实践

  • 不要完全依赖 AI：AI 建议需要人工审核，特别是生产环境
  • 逐步应用：先在测试环境验证 AI 建议，再应用到生产
  • 持续学习：AI 工具会不断学习新的最佳实践，保持更新
  • 团队协作：将 AI 工具集成到 CI/CD 流程，提升团队效率
  • 安全优先：AI 生成的配置必须经过安全审计
  • 文档化：记录 AI 建议和优化决策，便于团队知识共享

集成 AI 工具到 CI/CD

# .github/workflows/docker-ci.yml
name: Docker CI with AI

on: [push, pull_request]

jobs:
  build-and-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Generate Dockerfile with AI
        run: |
          dockerfile-gpt --app-type nodejs --output Dockerfile

      - name: Build image
        run: docker buildx build -t myapp:${{ github.sha }} .

      - name: AI Security Scan
        run: |
          docker scout cves --ai-fix \
            --output security-report.json \
            myapp:${{ github.sha }}

      - name: AI Performance Analysis
        run: |
          docker ai analyze-performance \
            --output performance-report.json \
            myapp:${{ github.sha }}

      - name: Upload Reports
        uses: actions/upload-artifact@v4
        with:
          name: reports
          path: |
            security-report.json
            performance-report.json

学习路径

1

Docker 基础

了解容器概念、Docker 架构、安装和基本命令

预计时间：2-3 天
2

Dockerfile 编写

学习编写 Dockerfile、构建和优化镜像，掌握 BuildKit 新特性

预计时间：3-5 天
3

Docker Compose

掌握多容器应用的编排和管理，包括健康检查、依赖配置

预计时间：2-3 天
4

WASM 容器

学习 WebAssembly 容器技术，构建轻量级高性能应用

预计时间：2-3 天
5

AI 辅助开发

使用 AI 工具优化 Dockerfile、安全扫描和性能分析

预计时间：2-3 天
6

实战项目

完成完整的容器化项目部署，包括 WASM 服务和 AI 工具集成

预计时间：5-7 天
7

Kubernetes 入门

学习容器编排和集群管理，包括 Docker 和 Kubernetes 的协同

预计时间：7-10 天