AI开发者的Docker指南

Docker让AI应用的部署变得简单可靠。本指南将教你如何在AI项目中高效使用Docker。

为什么AI开发需要Docker？

核心优势

环境一致性: 开发、测试、生产环境完全相同
依赖隔离: 避免版本冲突
快速部署: 一键部署到任何平台
资源管理: 精确控制CPU、内存、GPU

AI项目的痛点

# 传统部署的问题
"在我机器上能运行" ❌
CUDA版本不匹配 ❌
Python依赖冲突 ❌
模型文件丢失 ❌

# Docker解决方案
容器化部署 ✅
环境完全一致 ✅
依赖全部打包 ✅

Docker基础

安装Docker

# Windows/Mac: 下载Docker Desktop
# https://www.docker.com/products/docker-desktop

# Linux
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# 验证安装
docker --version
docker run hello-world

核心概念

镜像 (Image)

只读模板
包含应用和依赖
可以共享和版本控制

容器 (Container)

镜像的运行实例
隔离的运行环境
可以启动、停止、删除

Dockerfile

构建镜像的脚本
定义环境和依赖
可重复构建

第一个AI容器

简单的Python应用

# Dockerfile
FROM python:3.11-slim

WORKDIR /app

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

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

# 复制应用代码
COPY . .

# 暴露端口
EXPOSE 8000

# 启动命令
CMD ["python", "app.py"]

# app.py
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello from Docker!"

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

# 构建镜像
docker build -t my-ai-app .

# 运行容器
docker run -p 8000:8000 my-ai-app

# 访问: http://localhost:8000

机器学习模型容器化

FastAPI + 模型服务

FROM python:3.11-slim

WORKDIR /app

# 安装系统依赖
RUN apt-get update && apt-get install -y \
    build-essential \
    && rm -rf /var/lib/apt/lists/*

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

# 复制模型和代码
COPY models/ ./models/
COPY app/ ./app/

# 暴露端口
EXPOSE 8000

# 启动FastAPI
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

# app/main.py
from fastapi import FastAPI
import joblib
import numpy as np

app = FastAPI()

# 加载模型
model = joblib.load('models/model.pkl')

@app.post("/predict")
async def predict(data: dict):
    features = np.array(data['features']).reshape(1, -1)
    prediction = model.predict(features)
    return {"prediction": prediction.tolist()}

@app.get("/health")
async def health():
    return {"status": "healthy"}

GPU支持

NVIDIA Docker

# 安装NVIDIA Container Toolkit
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | \
    sudo tee /etc/apt/sources.list.d/nvidia-docker.list

sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit
sudo systemctl restart docker

GPU Dockerfile

FROM nvidia/cuda:12.1.0-cudnn8-runtime-ubuntu22.04

# 安装Python
RUN apt-get update && apt-get install -y \
    python3.11 \
    python3-pip \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app

# 安装PyTorch with CUDA
RUN pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

# 复制应用
COPY requirements.txt .
RUN pip3 install --no-cache-dir -r requirements.txt

COPY . .

CMD ["python3", "train.py"]

# 运行GPU容器
docker run --gpus all -it my-gpu-app

# 指定GPU数量
docker run --gpus 2 my-gpu-app

# 指定特定GPU
docker run --gpus '"device=0,1"' my-gpu-app

验证GPU

# test_gpu.py
import torch

print(f"CUDA available: {torch.cuda.is_available()}")
print(f"CUDA version: {torch.version.cuda}")
print(f"GPU count: {torch.cuda.device_count()}")

if torch.cuda.is_available():
    print(f"GPU name: {torch.cuda.get_device_name(0)}")

多阶段构建优化

减小镜像体积

# 构建阶段
FROM python:3.11 as builder

WORKDIR /app

# 安装依赖到临时目录
COPY requirements.txt .
RUN pip install --user --no-cache-dir -r requirements.txt

# 运行阶段
FROM python:3.11-slim

WORKDIR /app

# 只复制必要的文件
COPY --from=builder /root/.local /root/.local
COPY app/ ./app/
COPY models/ ./models/

# 确保脚本在PATH中
ENV PATH=/root/.local/bin:$PATH

CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0"]

优化技巧

# 1. 使用.dockerignore
# .dockerignore
__pycache__
*.pyc
*.pyo
*.pyd
.git
.gitignore
.venv
venv/
*.md
tests/
.pytest_cache

# 2. 合并RUN命令
RUN apt-get update && \
    apt-get install -y package1 package2 && \
    rm -rf /var/lib/apt/lists/*

# 3. 利用缓存层
# 先复制requirements.txt，再复制代码
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .

# 4. 使用特定版本
FROM python:3.11.5-slim

Docker Compose

多容器应用

# docker-compose.yml
version: '3.8'

services:
  # FastAPI应用
  api:
    build: ./api
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/aidb
      - REDIS_URL=redis://redis:6379
    depends_on:
      - db
      - redis
    volumes:
      - ./models:/app/models
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

  # PostgreSQL数据库
  db:
    image: postgres:15
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=aidb
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

  # Redis缓存
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data

  # Nginx反向代理
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - api

volumes:
  postgres_data:
  redis_data:

# 启动所有服务
docker-compose up -d

# 查看日志
docker-compose logs -f api

# 停止服务
docker-compose down

# 重新构建
docker-compose up -d --build

数据持久化

挂载卷

# 命名卷
docker run -v model_data:/app/models my-ai-app

# 绑定挂载
docker run -v $(pwd)/models:/app/models my-ai-app

# 只读挂载
docker run -v $(pwd)/config:/app/config:ro my-ai-app

数据管理

# Dockerfile
FROM python:3.11-slim

WORKDIR /app

# 创建数据目录
RUN mkdir -p /app/data /app/models /app/logs

# 声明卷
VOLUME ["/app/data", "/app/models"]

COPY . .

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

环境变量管理

.env文件

# .env
OPENAI_API_KEY=sk-xxx
MODEL_PATH=/app/models/model.pkl
LOG_LEVEL=INFO
DATABASE_URL=postgresql://user:pass@localhost/db

# docker-compose.yml
services:
  api:
    build: .
    env_file:
      - .env
    environment:
      - ENVIRONMENT=production

安全实践

# 使用Docker secrets (Swarm模式)
echo "my_secret_key" | docker secret create api_key -

# 在服务中使用
docker service create \
  --name my-api \
  --secret api_key \
  my-ai-app

网络配置

自定义网络

# 创建网络
docker network create ai-network

# 运行容器并连接网络
docker run --network ai-network --name api my-api
docker run --network ai-network --name db postgres

# 容器间通信
# api容器可以通过 db:5432 访问数据库

Docker Compose网络

services:
  api:
    networks:
      - frontend
      - backend

  db:
    networks:
      - backend

  nginx:
    networks:
      - frontend

networks:
  frontend:
  backend:

健康检查

FROM python:3.11-slim

WORKDIR /app

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

COPY . .

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

CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0"]

# app/main.py
@app.get("/health")
async def health_check():
    # 检查模型是否加载
    if model is None:
        raise HTTPException(status_code=503, detail="Model not loaded")

    # 检查数据库连接
    try:
        db.execute("SELECT 1")
    except:
        raise HTTPException(status_code=503, detail="Database unavailable")

    return {"status": "healthy"}

CI/CD集成

GitHub Actions

# .github/workflows/docker.yml
name: Build and Push Docker Image

on:
  push:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v3

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

    - name: Login to Docker Hub
      uses: docker/login-action@v2
      with:
        username: ${{ secrets.DOCKER_USERNAME }}
        password: ${{ secrets.DOCKER_PASSWORD }}

    - name: Build and push
      uses: docker/build-push-action@v4
      with:
        context: .
        push: true
        tags: username/ai-app:latest
        cache-from: type=registry,ref=username/ai-app:buildcache
        cache-to: type=registry,ref=username/ai-app:buildcache,mode=max

生产环境部署

Docker Swarm

# 初始化Swarm
docker swarm init

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

# 扩展服务
docker service scale ai-stack_api=3

# 更新服务
docker service update --image username/ai-app:v2 ai-stack_api

Kubernetes部署

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ai-model-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ai-model
  template:
    metadata:
      labels:
        app: ai-model
    spec:
      containers:
      - name: ai-model
        image: username/ai-app:latest
        ports:
        - containerPort: 8000
        resources:
          requests:
            memory: "2Gi"
            cpu: "1000m"
            nvidia.com/gpu: 1
          limits:
            memory: "4Gi"
            cpu: "2000m"
            nvidia.com/gpu: 1
        env:
        - name: MODEL_PATH
          value: "/models/model.pkl"
        volumeMounts:
        - name: model-storage
          mountPath: /models
      volumes:
      - name: model-storage
        persistentVolumeClaim:
          claimName: model-pvc

监控和日志

日志管理

# 查看日志
docker logs container_name

# 实时日志
docker logs -f container_name

# 最近100行
docker logs --tail 100 container_name

# 带时间戳
docker logs -t container_name

集中式日志

# docker-compose.yml
services:
  api:
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

常用命令

# 镜像管理
docker images                    # 列出镜像
docker pull image:tag           # 拉取镜像
docker push image:tag           # 推送镜像
docker rmi image:tag            # 删除镜像
docker image prune              # 清理未使用镜像

# 容器管理
docker ps                       # 列出运行中容器
docker ps -a                    # 列出所有容器
docker start container          # 启动容器
docker stop container           # 停止容器
docker restart container        # 重启容器
docker rm container             # 删除容器
docker exec -it container bash  # 进入容器

# 系统清理
docker system prune             # 清理未使用资源
docker system prune -a          # 清理所有未使用资源
docker volume prune             # 清理未使用卷

# 调试
docker inspect container        # 查看容器详情
docker stats                    # 查看资源使用
docker top container            # 查看容器进程

最佳实践

1. 安全性

# 使用非root用户
FROM python:3.11-slim

RUN useradd -m -u 1000 appuser

WORKDIR /app
COPY --chown=appuser:appuser . .

USER appuser

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

2. 镜像标签

# 使用语义化版本
docker build -t myapp:1.0.0 .
docker build -t myapp:1.0 .
docker build -t myapp:latest .

# 使用Git commit
docker build -t myapp:$(git rev-parse --short HEAD) .

3. 资源限制

# 限制CPU和内存
docker run -m 2g --cpus 2 my-ai-app

# Docker Compose
services:
  api:
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 2G
        reservations:
          cpus: '1'
          memory: 1G

故障排查

# 检查容器日志
docker logs --tail 50 container_name

# 进入容器调试
docker exec -it container_name bash

# 检查网络
docker network inspect network_name

# 检查卷
docker volume inspect volume_name

# 查看容器进程
docker top container_name

# 实时资源监控
docker stats container_name

总结

Docker让AI应用部署变得简单可靠。关键要点:

容器化: 打包应用和依赖
GPU支持: 使用NVIDIA Docker
多阶段构建: 优化镜像大小
编排: 使用Docker Compose管理多容器
生产部署: CI/CD自动化

从简单容器开始，逐步掌握高级特性。Docker将成为你AI开发的得力助手！

AI开发者的Docker指南

分享这篇文章