AI编程实战手记：腾讯云SCF + PostgreSQL高并发摘要服务的性能调优与排障

# 错误示范：模块级全局引擎
engine = create_async_engine(DATABASE_URL, pool_size=10, max_overflow=20)
AsyncSessionLocal = sessionmaker(engine, class_=AsyncSession)

# app/database.py - 生产级修复
from contextlib import asynccontextmanager
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker
from app.config import DATABASE_URL, DB_POOL_SIZE, DB_MAX_OVERFLOW

# 强制限制：pool_size = max(2, cpu_count())，拒绝AI生成的10-20默认值
engine = create_async_engine(
    DATABASE_URL,
    pool_size=2,               # 每个容器仅保留2个长连接
    max_overflow=5,            # 峰值允许溢出5个，用完即弃
    pool_pre_ping=True,        # 关键：执行前探测连接存活，防止使用死连接
    pool_recycle=300,          # 5分钟强制回收，防止PG侧idle_timeout
    echo=False
)

AsyncSessionLocal = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)

# 关键修复：使用FastAPI的lifespan确保请求结束执行session.close()
@asynccontextmanager
async def get_db_session():
    async with AsyncSessionLocal() as session:
        try:
            yield session
            await session.commit()
        except Exception:
            await session.rollback()
            raise
        finally:
            await session.close()  # 显式归还连接，而非等待GC

# app/summarize.py - 修复版
import httpx
from app.config import HUNYUAN_INTERNAL_URL  # 内网VPC地址，如 http://hunyuan.internal.tencentcloudapi.com
import asyncio

# 全局单例Client（复用TCP连接）
_httpx_client: httpx.AsyncClient = None

async def get_http_client() -> httpx.AsyncClient:
    global _httpx_client
    if _httpx_client is None or _httpx_client.is_closed:
        # 关键参数：limits=100保持连接池，timeout分级控制
        _httpx_client = httpx.AsyncClient(
            base_url=HUNYUAN_INTERNAL_URL,
            timeout=httpx.Timeout(connect=5.0, read=28.0, write=10.0),
            limits=httpx.Limits(max_keepalive_connections=50, max_connections=100),
            http2=True,  # 混元支持HTTP/2，大幅降低头部延迟
            verify=False  # 内网VIP若证书校验失败可关闭（生产环境建议注入CA）
        )
    return _httpx_client

async def generate_summary(markdown: str) -> str:
    client = await get_http_client()
    payload = {
        "model": "hunyuan-pro",
        "messages": [{"role": "user", "content": f"摘要：{markdown[:6000]}"}],
        "temperature": 0.2
    }
    # 设置信号量控制并发，防止打爆下游（重要）
    semaphore = asyncio.Semaphore(20)
    async with semaphore:
        resp = await client.post("/v1/chat/completions", json=payload)
        resp.raise_for_status()
        return resp.json()["choices"][0]["message"]["content"]

#!/bin/bash
exec python3 -m uvicorn app.main:app --host 0.0.0.0 --port 9000 --workers 1 --loop asyncio

# app/main.py
from app.database import engine
from app.summarize import get_http_client

_is_initialized = False

@app.middleware("http")
async def lazy_init_middleware(request: Request, call_next):
    global _is_initialized
    if not _is_initialized:
        # 仅执行同步探测，异步连接池在首次get_db时自动初始化
        async with engine.connect() as conn:
            await conn.execute("SELECT 1")
        await get_http_client()  # 预热HTTP连接
        _is_initialized = True
        print("SCF Container Warmup Completed.")
    return await call_next(request)

# config.py 生产环境DSN
# 使用内网域名，而非IP
DATABASE_URL = f"postgresql+asyncpg://{USER}:{PASS}@{DB_HOST_INTERNAL}:5432/{DB_NAME}?ssl=require"

import os
# 容器内存限制读取
MEMORY_MB = int(os.environ.get('MEMORY_LIMIT', 512))
DB_POOL_SIZE = max(1, min(4, MEMORY_MB // 128))  # 128MB内存对应1个连接

from tencentcloud_cls_sdk import LogClient
import uuid

# 中间件注入Request ID
@app.middleware("http")
async def add_trace_id(request: Request, call_next):
    trace_id = request.headers.get("X-Trace-Id", str(uuid.uuid4()))
    request.state.trace_id = trace_id
    # 将trace_id注入日志
    with logger.contextualize(trace_id=trace_id):
        response = await call_next(request)
    return response