一、问题背景

事情是这样的。我们有个商品详情接口 GET /api/v1/products/{id},平时流量不大,一直没人管。直到上周做活动预告,运营说要推首页,我随手用wrk压了一下,结果有点难看:

wrk -t8 -c200 -d30s http://127.0.0.1:8000/api/v1/products/12345
Running 30s test @ http://127.0.0.1:8000/api/v1/products/12345
  8 threads and 200 connections
  Latency  Distribution
     50%    1.21s
     75%    1.55s
     90%    1.72s
     99%    1.80s
  Requests/sec:    118.63

QPS 118,P99 1.8秒。这个接口逻辑上就是"查商品 + 查SKU + 查库存 + 查促销",听起来不该这么慢。更离谱的是压测期间PostgreSQL的CPU直接干到95%,而应用服务器CPU才20%——说明瓶颈在数据库侧,而且大概率是查询写得有问题。

目标很明确:QPS至少上到1500,P99压到200ms以内,同时数据库CPU不能继续当瓶颈。

二、环境与版本

先把环境交代清楚,不然数据没法复现:

  • Python 3.11.7
  • FastAPI 0.110.0 + Uvicorn 0.29.0(4 worker,--workers 4)
  • SQLAlchemy 2.0.29(同步Session,没用async,这是历史包袱)
  • psycopg2-binary 2.9.9
  • PostgreSQL 15.6,4C8G,shared_buffers=2GB,max_connections=200
  • Redis 7.2.4,单机
  • 压测机:8C16G,wrk 4.2.0,和被测服务同内网
  • 数据量:products 表 80万行,skus 表 320万行,inventory 表 320万行,promotions 表 5千行

应用连接池配置是默认的:pool_size=5, max_overflow=10。这个后面也是个坑。

三、方案设计:先定位,再动手

我的原则是:没profiling数据之前不改一行代码。凭感觉优化,十有八九优化错地方。

定位分三步走:

  1. 应用层:用 py-spy 采样火焰图,看Python代码时间花在哪
  2. 数据库层:开 pg_stat_statements,看哪条SQL耗时最多、调用次数最多
  3. 压测验证:每改一项,单独压一次,记录数据,避免"多因素混合"说不清谁起作用

优化方向按预期收益排序:

  • N+1查询合并(最可能的大头)
  • 缺失索引补齐
  • 热点数据上Redis缓存
  • 连接池参数调整

下面逐个说。

四、核心实现

4.1 profiling:py-spy揪出N+1

py-spy 装起来很简单:

pip install py-spy==0.3.14
# 找到uvicorn worker的pid
py-spy record -o profile.svg --pid 12345 --duration 30 --rate 200

压测的同时采样30秒,火焰图出来我一眼就看到问题:get_product_detail 里有个 for sku in product.skus 的循环,循环体里每次都在调 session.execute(select(Inventory)...)。320万行的inventory表,一个商品平均12个SKU,就是12次独立查询。这就是典型的N+1。

再看 pg_stat_statements(需要先在 postgresql.conf 里加 shared_preload_libraries = 'pg_stat_statements'):

SELECT calls, mean_exec_time, total_exec_time, query
FROM pg_stat_statements
ORDER BY total_exec_time DESC
LIMIT 5;

结果前两名:

calls mean_exec_time(ms) total_exec_time(s) query
142560 8.7 1240.3 SELECT * FROM inventory WHERE sku_id = $1
11880 42.1 500.2 SELECT * FROM promotions WHERE product_id = $1

inventory那条被调了14万次,单次8.7ms看着不多,但乘以调用量就是1240秒。而且 sku_id 上居然没有索引——320万行的表全表扫,难怪数据库CPU爆了。

4.2 查询优化:合并N+1 + 补索引

改造前的代码大概长这样(简化版):

# 改造前:N+1 重灾区
@app.get("/api/v1/products/{product_id}")
def get_product_detail(product_id: int, db: Session = Depends(get_db)):
    product = db.execute(
        select(Product).where(Product.id == product_id)
    ).scalar_one_or_none()
    if not product:
        raise HTTPException(404)

    skus = db.execute(
        select(Sku).where(Sku.product_id == product_id)
    ).scalars().all()

    result_skus = []
    for sku in skus:  # 每个sku一次查询
        inv = db.execute(
            select(Inventory).where(Inventory.sku_id == sku.id)
        ).scalar_one_or_none()
        result_skus.append({
            "id": sku.id,
            "name": sku.name,
            "price": str(sku.price),
            "stock": inv.stock if inv else 0,
        })

    promo = db.execute(
        select(Promotion).where(Promotion.product_id == product_id)
    ).scalars().all()

    return {"id": product.id, "title": product.title,
            "skus": result_skus, "promotions": [p.name for p in promo]}

改成一次性 JOIN 拉全,用 selectinload 也行,但这里字段少,直接显式JOIN更可控:

# 改造后:单次JOIN + 索引
@app.get("/api/v1/products/{product_id}")
def get_product_detail(product_id: int, db: Session = Depends(get_db)):
    stmt = (
        select(
            Product.id, Product.title,
            Sku.id.label("sku_id"), Sku.name.label("sku_name"),
            Sku.price, func.coalesce(Inventory.stock, 0).label("stock"),
        )
        .join(Sku, Sku.product_id == Product.id)
        .outerjoin(Inventory, Inventory.sku_id == Sku.id)
        .where(Product.id == product_id)
    )
    rows = db.execute(stmt).all()
    if not rows:
        raise HTTPException(404)

    skus = [
        {"id": r.sku_id, "name": r.sku_name,
         "price": str(r.price), "stock": r.stock}
        for r in rows
    ]
    # 促销单独查,量小且可缓存
    promo = db.execute(
        select(Promotion.name).where(Promotion.product_id == product_id)
    ).scalars().all()

    return {"id": rows[0].id, "title": rows[0].title,
            "skus": skus, "promotions": list(promo)}

索引补两条,注意 CONCURRENTLY 避免锁表:

CREATE INDEX CONCURRENTLY idx_inventory_sku_id ON inventory (sku_id);
CREATE INDEX CONCURRENTLY idx_sku_product_id ON skus (product_id);
CREATE INDEX CONCURRENTLY idx_promotion_product_id ON promotions (product_id);
ANALYZE inventory;
ANALYZE skus;

这一步做完,先压了一轮:QPS 从118涨到 640,P99 从1.8s降到 320ms,数据库CPU从95%降到55%。有效,但离目标还差得远。P99 320ms说明还有别的东西。

再采样火焰图,这次热点变成了 psycopg2 的连接获取等待——连接池不够。200并发打4个worker,每个worker pool_size=5 + max_overflow=10,总共60个连接上限,但数据库 max_connections=200 根本没用满,请求全堵在池子外面等连接。

4.3 连接池与缓存策略

连接池调整:

# db.py
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

engine = create_engine(
    "postgresql+psycopg2://app:***@10.0.1.12:5432/shop",
    pool_size=20,          # 5 -> 20
    max_overflow=30,       # 10 -> 30,单worker上限50
    pool_timeout=5,
    pool_recycle=1800,
    pool_pre_ping=True,
    echo=False,
)
SessionLocal = sessionmaker(bind=engine, autoflush=False, expire_on_commit=False)

4 worker × 50 = 200,正好贴着 max_connections=200。这里有个细节:pool_pre_ping=True 会多一次round trip,但能避免拿到死连接,生产上值得。另外把 expire_on_commit=False 加上,减少一次无谓的重新加载。

Redis缓存:商品详情是典型读多写少,缓存收益大。策略是 cache-aside + 随机TTL防雪崩,key 按商品ID,value 存JSON:

import json, random
import redis
from fastapi import FastAPI, HTTPException, Depends

r = redis.Redis(host="10.0.1.20", port=6379, db=0,
                socket_timeout=0.05, socket_connect_timeout=0.05,
                decode_responses=True)

CACHE_TTL = 300  # 5分钟基础TTL

def get_cached_detail(product_id: int, db):
    key = f"prod:detail:{product_id}"
    try:
        cached = r.get(key)
        if cached:
            return json.loads(cached)
    except redis.RedisError:
        pass  # 缓存挂了降级走DB,不能影响主流程

    data = query_from_db(product_id, db)  # 上面改造后的查询
    if data:
        try:
            # TTL加±10%随机抖动,避免同一批key同时过期
            ttl = int(CACHE_TTL * random.uniform(0.9, 1.1))
            r.setex(key, ttl, json.dumps(data, ensure_ascii=False))
        except redis.RedisError:
            pass
    return data

几个刻意的设计:socket_timeout=0.05(50ms),缓存超时立刻降级,绝不让Redis拖慢接口;try/except RedisError 包住所有缓存操作;TTL随机抖动。写路径上删除缓存(r.delete(key))在商品/SKU/库存更新的service里加,这里不展开。

缓存命中率压测时观察是 93.7%(redis-cli info stats 的 keyspace_hits / (hits+misses)),因为wrk一直打同一个ID,真实场景会低一些,但商品详情这种长尾分布,头部商品命中率不会差。

五、踩坑与优化

坑1:selectinload 反而更慢。 一开始我试了ORM的 selectinload(Product.skus).selectinload(Sku.inventory),它会把N+1变成3条IN查询,但 inventory 表没索引时那条 WHERE sku_id IN (...) 依然全表扫。所以索引必须先于ORM优化,顺序反了会得出错误结论。

坑2:连接池调大后出现偶发 too many connections。 因为压测时旧worker没退干净,加上pg的 max_connections 是硬上限。后来把 max_connections 提到250,并确认uvicorn --workers 数 × 单worker池上限 < 上限的90%。

坑3:JSON序列化 Decimal 报错。 Sku.price 是 Numeric,json.dumps 直接炸。改成 str(r.price) 输出字符串,前端本来也是按字符串处理的,反而避免了浮点精度问题。

坑4:缓存击穿。 压测时手工删了一个热点key,瞬间几百个请求同时打到DB,P99飙到1.2s。后来对热点key加了简单的互斥锁(SET key:lock NX EX 3),或者直接上 singleflight 思路,这里没上完整实现,先靠长TTL撑着。

六、效果数据

同样的wrk命令,最终对比:

指标 优化前 仅查询优化 最终(+池+缓存)
QPS 118 640 2130
P50 1.21s 210ms 31ms
P99 1.80s 320ms 86ms
DB CPU 95% 55% 18%
应用CPU 20% 35% 28%

QPS 提升约18倍,P99降了95%。另外用真实流量回放(缓存命中率降到71%的场景)压了一次,QPS 1480,P99 142ms,依然达标。

七、总结

这次调优最大的感受是:profiling 省下来的时间远比它花的时间多。如果一开始凭直觉去加缓存,N+1和缺索引这两个根因还在,缓存一失效照样打穿数据库,问题只是被藏起来了。

几个可复用的结论:

  1. py-spy + pg_stat_statements 是Python+PG组合的最低成本定位手段,先看数据再改代码;
  2. 索引优先于ORM优化,selectinload 救不了没索引的表;
  3. 连接池上限要和 max_connections、worker数一起算,别只调一个;
  4. 缓存必须带降级和超时,RedisError 要吞掉,TTL加抖动;
  5. 每改一项单独压测,混着改永远说不清是谁的功劳。

遗留问题:同步SQLAlchemy在超高并发下还是不如async,下一步考虑把这条链路迁到 asyncpg + AsyncSession,预计还能再压一截。不过那是另一个故事了。