生产化

第32课：部署方案

📚 部署方案概述

本课学习LLM应用的部署方案。从开发到生产，需要选择合适的架构（单体/微服务/Serverless）、编写生产级API、容器化部署。

🎯 核心要点

三种部署架构：单体/微服务/Serverless
FastAPI生产模板：异步/健康检查/错误处理
Docker容器化：镜像构建/编排/健康检查

第32课: 部署方案
├── 三种架构
│   ├── Monolith: 单体(简单/快速)
│   ├── Microservice: 微服务(灵活/复杂)
│   └── Serverless: 无服务器(按需/冷启动)
├── FastAPI模板
│   ├── 异步API
│   ├── 健康检查
│   └── 错误处理
└── Docker
    ├── Dockerfile
    ├── docker-compose
    └── 健康检查/重启策略

🔍 三种部署架构

# 三种部署架构
from dataclasses import dataclass
from typing import Dict, List

@dataclass
class DeploymentConfig:
    architecture: str    # monolith/microservice/serverless
    replicas: int = 1
    cpu_limit: str = "1"
    memory_limit: str = "2Gi"
    gpu_required: bool = False
    autoscaling: bool = False
    min_replicas: int = 1
    max_replicas: int = 10
    target_cpu_percent: int = 70

# 单体架构
@dataclass
class MonolithConfig(DeploymentConfig):
    architecture: str = "monolith"
    port: int = 8000
    workers: int = 4

# 微服务架构
@dataclass
class MicroserviceConfig(DeploymentConfig):
    architecture: str = "microservice"
    services: Dict[str, dict] = None  # name -> config
    api_gateway: str = "nginx"

# Serverless架构
@dataclass
class ServerlessConfig(DeploymentConfig):
    architecture: str = "serverless"
    provider: str = "aws_lambda"
    runtime: str = "python3.11"
    timeout_seconds: int = 30
    memory_mb: int = 512
    cold_start_concurrency: int = 5  # 预热实例

def compare_architectures() -> str:
    return """架构对比:
| 特性       | 单体     | 微服务     | Serverless |
|-----------|---------|-----------|-----------|
| 部署复杂度  | 低      | 高        | 低        |
| 扩展性     | 有限    | 好        | 自动      |
| 冷启动     | 无      | 无        | 有        |
| 成本模式   | 固定    | 固定+弹性 | 按调用     |
| 适用规模   | 小型    | 中大型    | 间歇/流量波动 |"""

✅ 验证通过：三种架构的配置类完整定义，包含资源限制和扩展策略

🛠 FastAPI生产模板

# FastAPI生产模板
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from typing import Optional, List
import time
import json

app = FastAPI(title="LLM App API", version="1.0.0")

# CORS
app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])

# 请求模型
class ChatRequest(BaseModel):
    message: str
    model: str = "gpt-4o-mini"
    temperature: float = 0.7
    max_tokens: int = 1000
    stream: bool = False

class ChatResponse(BaseModel):
    response: str
    model: str
    tokens_used: int
    latency_ms: float

# 健康检查
@app.get("/health")
def health_check():
    return {"status": "healthy", "timestamp": time.time()}

# 聊天接口
@app.post("/v1/chat", response_model=ChatResponse)
async def chat(request: ChatRequest):
    start = time.time()
    try:
        from openai import OpenAI
        client = OpenAI()
        response = client.chat.completions.create(
            model=request.model,
            messages=[{"role": "user", "content": request.message}],
            temperature=request.temperature,
            max_tokens=request.max_tokens,
        )
        latency = (time.time() - start) * 1000
        return ChatResponse(
            response=response.choices[0].message.content or "",
            model=request.model,
            tokens_used=response.usage.total_tokens if response.usage else 0,
            latency_ms=latency,
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

# 运行: uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4

✅ 验证通过：FastAPI模板包含CORS、健康检查、聊天接口和错误处理

📦 Docker容器化

# Docker容器化
# Dockerfile
# FROM python:3.11-slim
# WORKDIR /app
# COPY requirements.txt .
# RUN pip install --no-cache-dir -r requirements.txt
# COPY . .
# EXPOSE 8000
# CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "4"]

# docker-compose.yml 示例
docker_compose = """
version: "3.8"
services:
  llm-api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
    deploy:
      resources:
        limits:
          cpus: "2"
          memory: 4G
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/conf.d/default.conf
    depends_on:
      - llm-api

volumes:
  redis-data:
"""

class DockerManager:
    """Docker管理工具"""
    def __init__(self, compose_path="docker-compose.yml"):
        self.compose_path = compose_path

    def build(self):
        return f"docker-compose -f {self.compose_path} build"

    def up(self, detach=True):
        cmd = f"docker-compose -f {self.compose_path} up"
        if detach: cmd += " -d"
        return cmd

    def down(self):
        return f"docker-compose -f {self.compose_path} down"

    def logs(self, service=None, tail=100):
        cmd = f"docker-compose -f {self.compose_path} logs --tail={tail}"
        if service: cmd += f" {service}"
        return cmd

    def scale(self, service, replicas):
        return f"docker-compose -f {self.compose_path} up -d --scale {service}={replicas}"

✅ 验证通过：Docker配置包含多服务编排、健康检查和资源限制

架构	部署复杂度	扩展性	冷启动	成本模式
单体	低	有限	无	固定
微服务	高	好	无	固定+弹性
Serverless	低	自动	有	按调用

💡 最佳实践

小型项目从单体开始
所有服务必须有健康检查
Docker镜像用slim基础镜像减小体积
环境变量管理密钥，不硬编码

⚠️ 常见陷阱

没有健康检查：无法自动恢复
过度微服务化：增加运维复杂度
忽略冷启动：Serverless首次延迟高

🔗 与其他课程的关系

前置知识：第31课「可观测性」
后续应用：第33课「灰度与A/B」
部署是生产化的基础设施

构建部署方案完整系统

# 挑战: 构建一键部署脚本
# - 自动构建Docker镜像
# - 健康检查等待就绪
# - 滚动更新零停机

进阶挑战

实现蓝绿部署——两套环境切换

🏅🏅 部署方案实践者

✅ 理解三种部署架构
✅ 编写FastAPI生产模板
✅ 实现Docker容器化部署

← 第31课 ≡ 目录第33课 →

🔄 生产部署架构详解

生产环境部署不只是"把代码放到服务器上"。需要考虑高可用、自动扩展、故障恢复、安全隔离等多个维度。

📐 高可用架构设计

多副本部署：至少2个实例，避免单点故障
健康检查：/health端点 + 自动重启策略
滚动更新：逐个替换实例，零停机部署
数据库备份：自动备份 + 跨区域复制
API限流：防止突发流量压垮服务

🧪 性能优化配置

组件	配置	作用	推荐值
Uvicorn	workers	并发工作进程	CPU核心数×2+1
Uvicorn	timeout-keep-alive	连接保活超时	5s
Nginx	proxy_read_timeout	后端读取超时	60s
Nginx	client_max_body_size	请求体大小限制	10M
Redis	maxmemory	缓存内存限制	512mb
Docker	memory limit	容器内存限制	2Gi
Docker	cpu limit	容器CPU限制	2 cores

📋 部署检查清单

✅ 上线前必查

环境变量已正确配置（API Key、数据库URL等）
健康检查端点正常工作
Docker镜像已推送到镜像仓库
数据库迁移已执行
日志级别设为INFO（不是DEBUG）
监控和告警已配置
灰度发布计划已准备
回滚方案已文档化
安全扫描通过（无已知漏洞）
压力测试已通过

📋 运维自动化

生产环境需要自动化运维来减少人工干预：

🔧 自动化脚本清单

自动备份：每日自动备份数据库和配置到S3
日志轮转：自动压缩和清理旧日志（保留30天）
证书续期：Let's Encrypt自动续期SSL证书
自动扩缩：基于CPU/内存指标自动调整副本数
故障自愈：健康检查失败自动重启容器
配置同步：GitOps自动同步配置变更

🌐 网络架构

┌──────────────────────────────────────┐
│           生产网络架构
├──────────────────────────────────────┤
│  CDN / CloudFlare (静态资源+DDoS防护)
├──────────────────────────────────────┤
│  Load Balancer (Nginx/ALB)
│  ├── /v1/chat → LLM API Service
│  ├── /v1/search → Search Service
│  └── /health → Health Check
├──────────────────────────────────────┤
│  API Service (FastAPI × N replicas)
│  ├── 认证中间件 (API Key / JWT)
│  ├── 速率限制 (Redis)
│  └── 语义缓存 (Redis + Embedding)
├──────────────────────────────────────┤
│  Data Layer
│  ├── PostgreSQL (用户/配置)
│  ├── Redis (缓存/会话)
│  └── Vector DB (知识库)
└──────────────────────────────────────┘

🔐 安全配置

生产部署的安全配置不容忽视：

🛡 安全检查清单

API Key管理：使用Secret Manager，不硬编码在代码中
网络安全：VPC隔离，内部服务不暴露公网
认证鉴权：所有API端点需要认证（API Key/JWT）
速率限制：每用户/IP每分钟请求次数限制
HTTPS强制：所有通信加密，禁用HTTP
日志脱敏：日志中不记录API Key和用户PII