┌─────────────────────────────────────────────────────────────┐
│                    🌐 负载均衡层                            │
│              Nginx / ALB / CloudFlare                      │
├─────────────────────────────────────────────────────────────┤
│                    🐳 容器编排层                            │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │
│  │  Web应用    │  │  API服务    │  │  Worker节点 │        │
│  │  (React)    │  │  (Flask)    │  │  (Celery)   │        │
│  └─────────────┘  └─────────────┘  └─────────────┘        │
├─────────────────────────────────────────────────────────────┤
│                    💾 数据存储层                            │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │
│  │    MySQL    │  │    Redis    │  │  文件存储   │        │
│  │   (主从)    │  │   (集群)    │  │   (MinIO)   │        │
│  └─────────────┘  └─────────────┘  └─────────────┘        │
├─────────────────────────────────────────────────────────────┤
│                    📊 监控告警层                            │
│        Prometheus + Grafana + AlertManager                 │
└─────────────────────────────────────────────────────────────┘

技术选型：稳定可靠的工具链

容器化技术：

Docker：应用容器化，环境一致性保障
Docker Compose：本地开发和小规模部署
Kubernetes：大规模生产环境编排（可选）

CI/CD工具：

GitHub Actions：代码托管在GitHub时的首选
GitLab CI：私有化部署的好选择
Jenkins：传统企业的经典选择

监控告警：

Prometheus：指标收集和存储
Grafana：可视化监控面板
AlertManager：告警规则和通知

🐳 Docker容器化

Dockerfile编写：打包应用的艺术

后端Dockerfile：

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

# 设置工作目录
WORKDIR /app

# 设置环境变量
ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
    PIP_NO_CACHE_DIR=1 \
    PIP_DISABLE_PIP_VERSION_CHECK=1

# 安装系统依赖
RUN apt-get update && apt-get install -y \
    gcc \
    default-libmysqlclient-dev \
    pkg-config \
    && rm -rf /var/lib/apt/lists/*

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

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

# 复制应用代码
COPY . .

# 创建非root用户
RUN adduser --disabled-password --gecos '' appuser && \
    chown -R appuser:appuser /app
USER appuser

# 暴露端口
EXPOSE 5000

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

# 启动命令
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "--workers", "4", "--timeout", "120", "app:create_app()"]

前端Dockerfile：

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

WORKDIR /app

# 复制package文件
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

# 复制nginx配置
COPY nginx.conf /etc/nginx/nginx.conf

# 暴露端口
EXPOSE 80

# 启动nginx
CMD ["nginx", "-g", "daemon off;"]

Docker Compose：一键启动的魔法

docker-compose.yml：

version: '3.8'

services:
  # 前端服务
  frontend:
    build:
      context: ./frontend
      dockerfile: Dockerfile
    ports:
      - "80:80"
    depends_on:
      - backend
    networks:
      - test-platform
    restart: unless-stopped

  # 后端API服务
  backend:
    build:
      context: ./backend
      dockerfile: Dockerfile
    ports:
      - "5000:5000"
    environment:
      - DATABASE_URL=mysql://root:password@mysql:3306/test_platform
      - REDIS_URL=redis://redis:6379/0
      - CELERY_BROKER_URL=redis://redis:6379/1
    depends_on:
      - mysql
      - redis
    networks:
      - test-platform
    restart: unless-stopped
    volumes:
      - ./logs:/app/logs
      - ./uploads:/app/uploads

  # Celery Worker
  celery-worker:
    build:
      context: ./backend
      dockerfile: Dockerfile
    command: celery -A app.celery_app worker --loglevel=info --concurrency=4
    environment:
      - DATABASE_URL=mysql://root:password@mysql:3306/test_platform
      - REDIS_URL=redis://redis:6379/0
      - CELERY_BROKER_URL=redis://redis:6379/1
    depends_on:
      - mysql
      - redis
    networks:
      - test-platform
    restart: unless-stopped
    volumes:
      - ./logs:/app/logs

  # Celery Beat (定时任务调度器)
  celery-beat:
    build:
      context: ./backend
      dockerfile: Dockerfile
    command: celery -A app.celery_app beat --loglevel=info
    environment:
      - DATABASE_URL=mysql://root:password@mysql:3306/test_platform
      - REDIS_URL=redis://redis:6379/0
      - CELERY_BROKER_URL=redis://redis:6379/1
    depends_on:
      - mysql
      - redis
    networks:
      - test-platform
    restart: unless-stopped
    volumes:
      - ./logs:/app/logs

  # MySQL数据库
  mysql:
    image: mysql:8.0
    environment:
      - MYSQL_ROOT_PASSWORD=password
      - MYSQL_DATABASE=test_platform
      - MYSQL_USER=testuser
      - MYSQL_PASSWORD=testpass
    ports:
      - "3306:3306"
    networks:
      - test-platform
    restart: unless-stopped
    volumes:
      - mysql_data:/var/lib/mysql
      - ./mysql/init.sql:/docker-entrypoint-initdb.d/init.sql

  # Redis缓存
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    networks:
      - test-platform
    restart: unless-stopped
    volumes:
      - redis_data:/data
    command: redis-server --appendonly yes

  # Flower (Celery监控)
  flower:
    build:
      context: ./backend
      dockerfile: Dockerfile
    command: celery -A app.celery_app flower --port=5555
    ports:
      - "5555:5555"
    environment:
      - CELERY_BROKER_URL=redis://redis:6379/1
    depends_on:
      - redis
    networks:
      - test-platform
    restart: unless-stopped

  # Nginx负载均衡
  nginx:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
      - ./nginx/ssl:/etc/nginx/ssl
    depends_on:
      - frontend
      - backend
    networks:
      - test-platform
    restart: unless-stopped

networks:
  test-platform:
    driver: bridge

volumes:
  mysql_data:
  redis_data:

🚀 CI/CD流水线

GitHub Actions：自动化部署的利器

.github/workflows/deploy.yml：

name: Deploy Test Platform

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: test-platform

jobs:
  test:
    runs-on: ubuntu-latest
    
    services:
      mysql:
        image: mysql:8.0
        env:
          MYSQL_ROOT_PASSWORD: password
          MYSQL_DATABASE: test_platform_test
        ports:
          - 3306:3306
        options: --health-cmd="mysqladmin ping" --health-interval=10s --health-timeout=5s --health-retries=3
      
      redis:
        image: redis:7-alpine
        ports:
          - 6379:6379
        options: --health-cmd="redis-cli ping" --health-interval=10s --health-timeout=5s --health-retries=3

    steps:
    - uses: actions/checkout@v3

    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.9'

    - name: Install dependencies
      run: |
        cd backend
        pip install -r requirements.txt
        pip install pytest pytest-cov

    - name: Run backend tests
      env:
        DATABASE_URL: mysql://root:password@localhost:3306/test_platform_test
        REDIS_URL: redis://localhost:6379/0
      run: |
        cd backend
        pytest tests/ --cov=app --cov-report=xml

    - name: Set up Node.js
      uses: actions/setup-node@v3
      with:
        node-version: '16'

    - name: Install frontend dependencies
      run: |
        cd frontend
        npm ci

    - name: Run frontend tests
      run: |
        cd frontend
        npm test -- --coverage --watchAll=false

    - name: Upload coverage reports
      uses: codecov/codecov-action@v3

  build-and-push:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    
    permissions:
      contents: read
      packages: write

    steps:
    - name: Checkout repository
      uses: actions/checkout@v3

    - name: Log in to Container Registry
      uses: docker/login-action@v2
      with:
        registry: ${{ env.REGISTRY }}
        username: ${{ github.actor }}
        password: ${{ secrets.GITHUB_TOKEN }}

    - name: Extract metadata
      id: meta
      uses: docker/metadata-action@v4
      with:
        images: ${{ env.REGISTRY }}/${{ github.repository }}/${{ env.IMAGE_NAME }}

    - name: Build and push backend image
      uses: docker/build-push-action@v4
      with:
        context: ./backend
        push: true
        tags: ${{ env.REGISTRY }}/${{ github.repository }}/backend:latest
        labels: ${{ steps.meta.outputs.labels }}

    - name: Build and push frontend image
      uses: docker/build-push-action@v4
      with:
        context: ./frontend
        push: true
        tags: ${{ env.REGISTRY }}/${{ github.repository }}/frontend:latest
        labels: ${{ steps.meta.outputs.labels }}

  deploy:
    needs: build-and-push
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    
    steps:
    - name: Deploy to production
      uses: appleboy/ssh-action@v0.1.5
      with:
        host: ${{ secrets.HOST }}
        username: ${{ secrets.USERNAME }}
        key: ${{ secrets.SSH_KEY }}
        script: |
          cd /opt/test-platform
          docker-compose pull
          docker-compose up -d --remove-orphans
          docker system prune -f

部署脚本：一键部署的便利

deploy.sh：

#!/bin/bash

# 测试平台部署脚本
set -e

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# 日志函数
log_info() {
    echo -e "${GREEN}[INFO]${NC} $1"
}

log_warn() {
    echo -e "${YELLOW}[WARN]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# 检查Docker是否安装
check_docker() {
    if ! command -v docker &> /dev/null; then
        log_error "Docker未安装，请先安装Docker"
        exit 1
    fi
    
    if ! command -v docker-compose &> /dev/null; then
        log_error "Docker Compose未安装，请先安装Docker Compose"
        exit 1
    fi
    
    log_info "Docker环境检查通过"
}

# 创建必要的目录
create_directories() {
    log_info "创建必要的目录..."
    
    mkdir -p logs
    mkdir -p uploads
    mkdir -p data/mysql
    mkdir -p data/redis
    mkdir -p nginx/ssl
    
    log_info "目录创建完成"
}

# 生成配置文件
generate_config() {
    log_info "生成配置文件..."
    
    # 生成随机密码
    DB_PASSWORD=$(openssl rand -base64 32)
    SECRET_KEY=$(openssl rand -base64 32)
    
    # 创建环境变量文件
    cat > .env << EOF
# 数据库配置
DB_PASSWORD=${DB_PASSWORD}
DB_HOST=mysql
DB_PORT=3306
DB_NAME=test_platform

# Redis配置
REDIS_HOST=redis
REDIS_PORT=6379

# 应用配置
SECRET_KEY=${SECRET_KEY}
DEBUG=false
ENVIRONMENT=production

# Celery配置
CELERY_BROKER_URL=redis://redis:6379/1
CELERY_RESULT_BACKEND=redis://redis:6379/2
EOF
    
    log_info "配置文件生成完成"
}

# 启动服务
start_services() {
    log_info "启动测试平台服务..."
    
    # 拉取最新镜像
    docker-compose pull
    
    # 启动服务
    docker-compose up -d
    
    # 等待服务启动
    log_info "等待服务启动..."
    sleep 30
    
    # 检查服务状态
    if docker-compose ps | grep -q "Up"; then
        log_info "服务启动成功！"
        
        echo ""
        echo "==================================="
        echo "🎉 测试平台部署完成！"
        echo "==================================="
        echo "前端访问地址: http://localhost:8080"
        echo "后端API地址: http://localhost:5000"
        echo "Flower监控: http://localhost:5555"
        echo "==================================="
        echo ""
        
        # 显示服务状态
        docker-compose ps
    else
        log_error "服务启动失败，请检查日志"
        docker-compose logs
        exit 1
    fi
}

# 健康检查
health_check() {
    log_info "执行健康检查..."
    
    # 检查后端API
    if curl -f http://localhost:5000/health > /dev/null 2>&1; then
        log_info "后端API健康检查通过"
    else
        log_warn "后端API健康检查失败"
    fi
    
    # 检查前端
    if curl -f http://localhost:8080 > /dev/null 2>&1; then
        log_info "前端健康检查通过"
    else
        log_warn "前端健康检查失败"
    fi
}

# 主函数
main() {
    log_info "开始部署测试平台..."
    
    check_docker
    create_directories
    generate_config
    start_services
    health_check
    
    log_info "部署完成！"
}

# 执行主函数
main "$@"