一、问题背景

事情是这样的。我们组维护的一个商品查询服务,之前一直跑得好好的,QPS 大概二三十,P99 在 300ms 上下,没人管它。结果上个月运营搞了个活动,流量一下涨到 80 QPS 左右,接口开始大面积超时,监控上 P99 直接飙到 1.8s,前端页面转圈转到用户骂人。

这个服务本身不复杂,就是 FastAPI 写的一个查询接口,接收商品 ID 列表,返回商品详情、库存、价格这些信息。代码量不大,但问题就出在"不大"上——因为简单,当初写得比较随意,同步 SQLAlchemy 直接查,没有任何缓存,也没做查询优化。

这篇文章就是把这个接口从 1.8s 优化到 120ms 的完整过程。不是教科书式的"最佳实践",是我真实踩过的坑和最后跑出来的数据。

二、环境与版本

先把环境交代清楚,避免版本差异导致复现不了:

  • Python 3.10.12
  • FastAPI 0.104.1
  • Uvicorn 0.24.0(4 worker,--workers 4)
  • SQLAlchemy 2.0.23(同步 ORM,create_engine 默认连接池)
  • PostgreSQL 14.9
  • Redis 7.0.11(redis-py 5.0.1)
  • py-spy 0.3.14
  • locust 2.17.0(压测工具)
  • 部署:单机 4C8G,接口和数据库不在同一台机器

压测基线:locust 模拟 100 并发用户,持续 5 分钟,接口 P99 = 1820ms,QPS 峰值 52,错误率 3.1%(超时)。

三、方案设计

优化思路分三步走,顺序很重要,不能一上来就加缓存:

第一步:定位瓶颈。 在不知道慢在哪的情况下加缓存是耍流氓。我用 py-spy 做火焰图采样,同时加了一个轻量中间件记录每个请求的耗时分解。

第二步:解决根因。 火焰图出来后发现 70% 的时间耗在数据库查询上,而且是 N+1 查询——接口收到 20 个商品 ID,代码里 for 循环一个个查,20 次往返。这里要做的是批量查询 + 索引优化。

第三步:加缓存兜底。 根因解决后再上 Redis 缓存,把热点商品的查询挡在数据库前面。缓存策略用 cache-aside,TTL 60s,因为库存数据允许短暂不一致。

另外把同步 ORM 换成异步(asyncpg + SQLAlchemy async),这个放在最后做,因为改动面大,前面几步已经能解决大部分问题。

四、核心实现

4.1 Profiling:先看清楚慢在哪

中间件记录耗时分解,这段代码直接可以抄:

import time
import logging
from fastapi import FastAPI, Request

app = FastAPI()
logger = logging.getLogger("perf")

@app.middleware("http")
async def timing_middleware(request: Request, call_next):
    start = time.perf_counter()
    response = await call_next(request)
    cost = (time.perf_counter() - start) * 1000
    # 只记录慢请求,避免日志刷屏
    if cost > 200:
        logger.warning(
            "slow request path=%s cost=%.1fms", request.url.path, cost
        )
    response.headers["X-Cost-Ms"] = f"{cost:.1f}"
    return response

但中间件只能告诉你"整个请求慢",不能告诉你慢在函数级别。这时候上 py-spy:

# 找到 uvicorn worker 的 pid
ps aux | grep uvicorn

# 采样 30 秒,生成火焰图
py-spy record -o profile.svg --pid  --duration 30 --rate 100

火焰图一出来,问题一目了然:get_product_detail 这个函数占了 68% 的采样,再往下展开就是 SQLAlchemy 的 Session.execute,再往下是 psycopg2 的网络等待。典型的"在循环里查数据库"。

原始代码长这样(反面教材):

# 优化前:N+1 查询
@app.get("/products")
def get_products(ids: str):
    id_list = [int(i) for i in ids.split(",")]
    result = []
    for pid in id_list:          # 20 个 ID 就是 20 次 DB 往返
        row = db.execute(
            text("SELECT * FROM products WHERE id = :id"), {"id": pid}
        ).fetchone()
        if row:
            result.append(dict(row._mapping))
    return result

4.2 数据库查询优化

批量查询改造:

# 优化后:一次 IN 查询
@app.get("/products")
def get_products(ids: str):
    id_list = [int(i) for i in ids.split(",")]
    rows = db.execute(
        text("""
            SELECT p.id, p.name, p.price, p.category_id,
                   s.stock, s.updated_at
            FROM products p
            LEFT JOIN stock s ON s.product_id = p.id
            WHERE p.id = ANY(:ids)
        """),
        {"ids": id_list},
    ).fetchall()
    return [dict(r._mapping) for r in rows]

注意这里用了 PostgreSQL 的 = ANY(:ids) 而不是 IN :ids,因为 SQLAlchemy 2.0 对 IN 的绑定参数处理比较啰嗦,ANY 配合数组绑定更干净,而且 PG 对 ANY 的索引利用和 IN 是一样的。

索引分析。 改完批量查询后 P99 从 1820ms 降到 640ms,但还是慢。跑 EXPLAIN ANALYZE:

EXPLAIN ANALYZE
SELECT p.id, p.name, p.price, p.category_id, s.stock, s.updated_at
FROM products p
LEFT JOIN stock s ON s.product_id = p.id
WHERE p.id = ANY(ARRAY[1,2,3,...]);

结果发现 stock 表的 product_id 上没有索引,JOIN 走的是 Seq Scan,stock 表 200 多万行,全表扫一遍 300ms 就没了。加索引:

-- 复合索引,覆盖 join 条件和查询字段
CREATE INDEX CONCURRENTLY idx_stock_product_id
ON stock (product_id) INCLUDE (stock, updated_at);

-- products 表主键已有索引,但 category_id 的过滤也要用到
CREATE INDEX CONCURRENTLY idx_products_category
ON products (category_id) WHERE deleted_at IS NULL;

CONCURRENTLY 这个要强调一下,生产环境建索引不加它会把表锁住,我们测试环境就因为忘了加,把测试库锁了 40 秒,被同事追着问。

加完索引,P99 到 280ms 左右。

4.3 缓存策略

到 280ms 其实已经能用了,但活动流量还在涨,加一层 Redis 缓存兜底。cache-aside 模式,读的时候先查缓存,miss 再查库并回填:

import json
import redis
from sqlalchemy import text

r = redis.Redis(host="127.0.0.1", port=6379, db=0, decode_responses=True)
CACHE_TTL = 60  # 库存允许 60s 内不一致

def get_products_cached(id_list: list[int]) -> list[dict]:
    keys = [f"product:{pid}" for pid in id_list]
    cached = r.mget(keys)
    result, miss_ids = [], []
    for pid, val in zip(id_list, cached):
        if val:
            result.append(json.loads(val))
        else:
            miss_ids.append(pid)

    if miss_ids:
        rows = db.execute(
            text("""
                SELECT p.id, p.name, p.price, p.category_id,
                       s.stock, s.updated_at
                FROM products p
                LEFT JOIN stock s ON s.product_id = p.id
                WHERE p.id = ANY(:ids)
            """),
            {"ids": miss_ids},
        ).fetchall()
        pipe = r.pipeline()
        for row in rows:
            item = dict(row._mapping)
            # updated_at 是 datetime,json 序列化需要转字符串
            item["updated_at"] = item["updated_at"].isoformat() if item["updated_at"] else None
            result.append(item)
            pipe.setex(f"product:{item['id']}", CACHE_TTL, json.dumps(item))
        pipe.execute()

    return result

这里有几个细节:mget 批量读避免多次 RTT;回填用 pipeline 批量写;TTL 设 60s 是因为库存有实时性要求,不能太长。缓存命中率压测下来在 87% 左右(商品 ID 有长尾分布,热点集中)。

五、踩坑与优化

坑一:同步 ORM 阻塞事件循环。 一开始我没在意,FastAPI 用 def 定义的路由会跑在线程池里,不阻塞事件循环。但后面我把路由改成 async def 想提升并发,结果同步的 SQLAlchemy 调用直接把事件循环堵死,QPS 反而从 52 掉到 38。教训是:要么全同步用线程池,要么全异步(asyncpg + AsyncSession),别混着来。我最后选了保守方案,保持同步路由 + 4 worker,够用。

坑二:连接池配置。 SQLAlchemy 默认 pool_size=5,100 并发下连接根本不够用,大量请求在等连接。改成:

engine = create_engine(
    DATABASE_URL,
    pool_size=20,
    max_overflow=30,
    pool_pre_ping=True,   # 防止连接被 DB 端断开后报错
    pool_recycle=1800,
)

pool_pre_ping 这个一定要加,我们 PG 侧有 idle_in_transaction_session_timeout,不加的话隔夜连接失效,第二天第一批请求全报错。

坑三:缓存雪崩。 TTL 统一 60s 导致缓存集中失效,DB 瞬间被打满。加了随机抖动:CACHE_TTL + random.randint(-10, 10),问题解决。

六、效果数据

同样是 locust 100 并发、5 分钟压测,各阶段对比:

阶段 P50 P99 QPS 错误率
优化前 420ms 1820ms 52 3.1%
批量查询后 180ms 640ms 110 0.4%
加索引后 90ms 280ms 190 0%
加缓存后 35ms 120ms 420 0%

P99 从 1820ms 降到 120ms,QPS 从 52 提到 420,错误率归零。活动当天峰值 380 QPS,平稳扛过,CPU 使用率峰值 62%,还有余量。

七、总结

回头看这次优化,其实没有用什么高深技术,就是老老实实按"定位 → 治根 → 兜底"的顺序来。几点体会:

  1. 先 profiling 再动手。 我见过太多人上来就加缓存,结果瓶颈根本不在 DB,缓存加了个寂寞。py-spy 火焰图 + 请求耗时中间件,这两个工具组合基本能定位 90% 的接口性能问题。
  2. N+1 查询是接口性能的头号杀手。 循环里查 DB 这种代码,review 的时候一定要盯死。
  3. 索引要看执行计划,不要猜。 EXPLAIN ANALYZE 跑一遍,Seq Scan 还是 Index Scan 一目了然。生产建索引记得 CONCURRENTLY。
  4. 缓存是最后一步,不是第一步。 根因没解决就加缓存,只会把问题藏起来,流量一涨照样崩。
  5. 同步/异步别混用。 FastAPI 的 async def 里调用同步阻塞代码,比全同步还慢。

代码都不复杂,关键是排查思路和顺序。希望这篇记录能帮到正在被慢接口折磨的同学。