agent项目部署流程

1. 创建生产环境的 docker-compose.yml

version: '3.8'

services:
  # PostgreSQL 数据库
  postgres:
    image: postgres:16-alpine
    container_name: aligo-postgres
    environment:
      POSTGRES_DB: aligo
      POSTGRES_USER: ${DB_USER:-aligo}
      POSTGRES_PASSWORD: ${DB_PASSWORD:-aligo123}
    ports:
      - "5432:5432"
    volumes:
      - pgdata:/var/lib/postgresql/data
      - ./init-db:/docker-entrypoint-initdb.d
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U aligo"]
      interval: 10s
      timeout: 5s
      retries: 5
    deploy:
      resources:
        limits:
          memory: 1G
          cpus: '1.0'

  # Redis 缓存
  redis:
    image: redis:7-alpine
    container_name: aligo-redis
    command: redis-server --requirepass ${REDIS_PASSWORD:-wang123456} --maxmemory 512mb --maxmemory-policy allkeys-lru
    ports:
      - "6379:6379"
    volumes:
      - redisdata:/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD:-wang123456}", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '0.5'

  # 应用服务
  app:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: aligo-app
    environment:
      - PYTHONUNBUFFERED=1
      - DB_HOST=postgres
      - DB_PORT=5432
      - DB_USER=${DB_USER:-aligo}
      - DB_PASSWORD=${DB_PASSWORD:-aligo123}
      - REDIS_HOST=redis
      - REDIS_PORT=6379
      - REDIS_PASSWORD=${REDIS_PASSWORD:-wang123456}
      - LLM_API_KEY=${LLM_API_KEY}
      - LOG_LEVEL=${LOG_LEVEL:-INFO}
    ports:
      - "8080:8080"
    volumes:
      - ./data/models:/app/data/models
      - ./data/memory:/app/data/memory
      - ./.claude/skills/ask-question/data:/app/.claude/skills/ask-question/data
      - app_logs:/app/logs
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    deploy:
      resources:
        limits:
          memory: 4G
          cpus: '2.0'
        reservations:
          memory: 2G
          cpus: '1.0'

  # Nginx 反向代理（可选，用于 HTTPS 和负载均衡）
  nginx:
    image: nginx:alpine
    container_name: aligo-nginx
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./ssl:/etc/nginx/ssl:ro
      - ./static:/usr/share/nginx/html/static:ro
    depends_on:
      - app
    restart: unless-stopped
    deploy:
      resources:
        limits:
          memory: 256M
          cpus: '0.5'

volumes:
  pgdata:
    driver: local
  redisdata:
    driver: local
  app_logs:
    driver: local

networks:
  default:
    name: aligo-network
    driver: bridge

2. 创建 Dockerfile

FROM python:3.11-slim

# 设置工作目录
WORKDIR /app

# 安装系统依赖
RUN apt-get update && apt-get install -y \
    gcc \
    g++ \
    curl \
    && rm -rf /var/lib/apt/lists/*

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

# 复制应用代码
COPY . .

# 创建必要的目录
RUN mkdir -p logs data/memory data/models

# 下载嵌入模型（如果不存在）
RUN python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('data/models/bge-small-zh-v1.5')" || true

# 初始化知识库
RUN python .claude/skills/ask-question/script/init_knowledge_base.py || true

# 暴露端口
EXPOSE 8080

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

# 启动命令
CMD ["uvicorn", "web:app", "--host", "0.0.0.0", "--port", "8080"]

3. 创建环境变量文件 .env

# 数据库配置
DB_USER=aligo
DB_PASSWORD=your_secure_password_here

# Redis 配置
REDIS_PASSWORD=your_secure_redis_password_here

# LLM API 配置
LLM_API_KEY=ark-8c48cdd6-2530-4ab3-87e6-ef313aafd3a1-6a698

# 日志级别
LOG_LEVEL=INFO

# 时区
TZ=Asia/Shanghai

4. 创建 Nginx 配置文件 nginx.conf

worker_processes auto;

events {
    worker_connections 1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    # 日志格式
    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
                    '$status $body_bytes_sent "$http_referer" '
                    '"$http_user_agent" "$http_x_forwarded_for"';

    access_log /var/log/nginx/access.log main;
    error_log /var/log/nginx/error.log warn;

    sendfile on;
    tcp_nopush on;
    keepalive_timeout 65;

    # Gzip 压缩
    gzip on;
    gzip_types text/plain text/css application/json application/javascript text/xml;

    upstream aligo_app {
        server app:8080;
    }

    server {
        listen 80;
        server_name your_domain.com;

        # 重定向到 HTTPS（如果有 SSL 证书）
        # return 301 https://$server_name$request_uri;

        location / {
            proxy_pass http://aligo_app;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_connect_timeout 60s;
            proxy_read_timeout 60s;
            proxy_send_timeout 60s;
        }

        location /health {
            proxy_pass http://aligo_app/health;
        }

        location /static/ {
            alias /usr/share/nginx/html/static/;
            expires 30d;
            add_header Cache-Control "public, immutable";
        }
    }

    # HTTPS 配置（可选）
    # server {
    #     listen 443 ssl http2;
    #     server_name your_domain.com;
    #
    #     ssl_certificate /etc/nginx/ssl/fullchain.pem;
    #     ssl_certificate_key /etc/nginx/ssl/privkey.pem;
    #     ssl_protocols TLSv1.2 TLSv1.3;
    #     ssl_ciphers HIGH:!aNULL:!MD5;
    #
    #     location / {
    #         proxy_pass http://aligo_app;
    #         proxy_set_header Host $host;
    #         proxy_set_header X-Real-IP $remote_addr;
    #         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    #         proxy_set_header X-Forwarded-Proto $scheme;
    #     }
    # }
}

5. 部署脚本 deploy.sh

#!/bin/bash

set -e

echo "🚀 开始部署 Aligo 差旅出行助手..."

# 检查 Docker 是否安装
if ! command -v docker &> /dev/null; then
    echo "❌ Docker 未安装，请先安装 Docker"
    exit 1
fi

if ! command -v docker-compose &> /dev/null; then
    echo "❌ Docker Compose 未安装，请先安装 Docker Compose"
    exit 1
fi

# 创建必要的目录
mkdir -p data/models data/memory logs ssl static

# 检查 .env 文件
if [ ! -f .env ]; then
    echo "⚠️  .env 文件不存在，从示例创建..."
    cp .env.example .env
    echo "请编辑 .env 文件配置环境变量"
    exit 1
fi

# 拉取最新代码（如果是 Git 部署）
# git pull origin main

# 构建并启动服务
echo "📦 构建 Docker 镜像..."
docker-compose build --no-cache

echo "🔧 启动服务..."
docker-compose up -d

# 等待服务启动
echo "⏳ 等待服务启动..."
sleep 30

# 检查服务状态
echo "✅ 检查服务状态..."
docker-compose ps

# 查看日志
echo "📋 查看应用日志..."
docker-compose logs -f app &

echo ""
echo "🎉 部署完成！"
echo "📍 Web 界面: http://localhost:8080"
echo "📊 健康检查: http://localhost:8080/health"
echo ""
echo "常用命令："
echo "  查看日志: docker-compose logs -f"
echo "  重启服务: docker-compose restart"
echo "  停止服务: docker-compose down"
echo "  更新部署: ./deploy.sh"

方案 B：Kubernetes 部署（大规模生产）

1. Kubernetes Deployment (k8s/deployment.yaml)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: aligo-app
  namespace: aligo
spec:
  replicas: 3
  selector:
    matchLabels:
      app: aligo
  template:
    metadata:
      labels:
        app: aligo
    spec:
      containers:
      - name: aligo
        image: your-registry/aligo:latest
        ports:
        - containerPort: 8080
        envFrom:
        - secretRef:
            name: aligo-secrets
        - configMapRef:
            name: aligo-config
        resources:
          requests:
            memory: "2Gi"
            cpu: "1000m"
          limits:
            memory: "4Gi"
            cpu: "2000m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 40
          periodSeconds: 30
        readinessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 20
          periodSeconds: 10
        volumeMounts:
        - name: model-data
          mountPath: /app/data/models
        - name: memory-data
          mountPath: /app/data/memory
      volumes:
      - name: model-data
        persistentVolumeClaim:
          claimName: aligo-model-pvc
      - name: memory-data
        persistentVolumeClaim:
          claimName: aligo-memory-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: aligo-service
  namespace: aligo
spec:
  selector:
    app: aligo
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080
  type: LoadBalancer
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: aligo-config
  namespace: aligo
data:
  DB_HOST: "postgres-service"
  REDIS_HOST: "redis-service"
  LOG_LEVEL: "INFO"
---
apiVersion: v1
kind: Secret
metadata:
  name: aligo-secrets
  namespace: aligo
type: Opaque
stringData:
  DB_PASSWORD: "your_secure_password"
  REDIS_PASSWORD: "your_secure_redis_password"
  LLM_API_KEY: "your_llm_api_key"

方案 C：传统服务器部

1. 服务器要求 最低配置： CPU: 2 核 内存: 4GB 磁盘: 50GB SSD 操作系统: Ubuntu 20.04+ / CentOS 7+ 推荐配置： CPU: 4 核 内存: 8GB 磁盘: 100GB SSD 操作系统: Ubuntu 22.04 LTS

2. 自动化部署脚本

#!/bin/bash

set -e

echo "🚀 开始部署 Aligo 差旅出行助手..."

# 1. 更新系统
sudo apt update && sudo apt upgrade -y

# 2. 安装必要软件
sudo apt install -y python3.11 python3.11-venv python3.11-dev \
    postgresql postgresql-contrib redis-server \
    nginx supervisor git curl

# 3. 创建应用用户
sudo useradd -m -s /bin/bash aligo || true

# 4. 克隆代码
cd /opt
sudo git clone https://your-repo/aligo.git || true
sudo chown -R aligo:aligo /opt/aligo

# 5. 创建虚拟环境
cd /opt/aligo
sudo -u aligo python3.11 -m venv venv
source venv/bin/activate

# 6. 安装依赖
pip install --upgrade pip
pip install -r requirements.txt

# 7. 配置 PostgreSQL
sudo -u postgres psql <<EOF
CREATE USER aligo WITH PASSWORD 'aligo123';
CREATE DATABASE aligo OWNER aligo;
GRANT ALL PRIVILEGES ON DATABASE aligo TO aligo;
EOF

# 8. 配置 Redis
sudo sed -i 's/# requirepass foobared/requirepass wang123456/' /etc/redis/redis.conf
sudo systemctl restart redis-server

# 9. 初始化应用
sudo -u aligo python migrate_memory.py
sudo -u aligo python .claude/skills/ask-question/script/init_knowledge_base.py

# 10. 配置 Supervisor
sudo tee /etc/supervisor/conf.d/aligo.conf > /dev/null <<EOF
[program:aligo]
command=/opt/aligo/venv/bin/uvicorn web:app --host 0.0.0.0 --port 8080
directory=/opt/aligo
user=aligo
autostart=true
autorestart=true
stderr_logfile=/var/log/aligo/err.log
stdout_logfile=/var/log/aligo/out.log
environment=PYTHONUNBUFFERED="1"
EOF

sudo mkdir -p /var/log/aligo
sudo supervisorctl reread
sudo supervisorctl update

# 11. 配置 Nginx
sudo tee /etc/nginx/sites-available/aligo > /dev/null <<EOF
server {
    listen 80;
    server_name your_domain.com;

    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto \$scheme;
    }
}
EOF

sudo ln -sf /etc/nginx/sites-available/aligo /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl restart nginx

# 12. 设置开机自启
sudo systemctl enable postgresql
sudo systemctl enable redis-server
sudo systemctl enable nginx
sudo systemctl enable supervisor

echo "✅ 部署完成！"
echo "访问地址: http://your_server_ip"

监控与运维

1. Prometheus + Grafana 监控配置 创建 prometheus.yml:

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'aligo'
    static_configs:
      - targets: ['localhost:8080']
    metrics_path: '/metrics'

2. 日志管理 使用 ELK Stack 或 Loki + Promtail:

# docker-compose.logging.yml
version: '3.8'
services:
  loki:
    image: grafana/loki:latest
    ports:
      - "3100:3100"
    volumes:
      - ./loki-config.yml:/etc/loki/local-config.yaml

  promtail:
    image: grafana/promtail:latest
    volumes:
      - /var/log:/var/log
      - ./promtail-config.yml:/etc/promtail/config.yml

3. 备份策略

#!/bin/bash
# backup.sh - 每日备份脚本

BACKUP_DIR="/backup/aligo/$(date +%Y%m%d)"
mkdir -p $BACKUP_DIR

# 备份 PostgreSQL
docker exec aligo-postgres pg_dump -U aligo aligo > $BACKUP_DIR/db_backup.sql

# 备份 Redis
docker exec aligo-redis redis-cli -a wang123456 BGSAVE
sleep 5
cp ~/.docker/volumes/aligo_redisdata/_data/dump.rdb $BACKUP_DIR/

# 备份本地文件
tar -czf $BACKUP_DIR/memory_backup.tar.gz data/memory/

# 保留最近 7 天的备份
find /backup/aligo -type d -mtime +7 -exec rm -rf {} \;

echo "✅ 备份完成: $BACKUP_DIR"

添加到 crontab:

0 2 * * * /opt/aligo/scripts/backup.sh >> /var/log/aligo_backup.log 2>&1

六、安全建议

防火墙配置

sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw deny 5432/tcp  # 禁止外部访问数据库
sudo ufw deny 6379/tcp  # 禁止外部访问 Redis
sudo ufw enable

SSL/TLS 证书

# 使用 Let's Encrypt
sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d your_domain.com

定期更新

# 每周自动更新
sudo apt update && sudo apt upgrade -y
docker-compose pull && docker-compose up -d

七、性能优化建议 1.数据库优化 添加索引：CREATE INDEX idx_user_preferences ON user_preferences(user_id); 连接池配置：调整 PostgreSQL max_connections 2.Redis 优化 设置最大内存：maxmemory 512mb 启用持久化：AOF + RDB 3.应用优化 启用 Gunicorn 多进程：gunicorn web:app -w 4 -k uvicorn.workers.UvicornWorker 添加 CDN 加速静态资源 4.缓存策略 LLM 响应缓存 RAG 检索结果缓存 用户偏好热点数据缓存