一、问题背景
事情是这样的。我们有个商品详情接口 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数据之前不改一行代码。凭感觉优化,十有八九优化错地方。
定位分三步走:
- 应用层:用
py-spy采样火焰图,看Python代码时间花在哪 - 数据库层:开
pg_stat_statements,看哪条SQL耗时最多、调用次数最多 - 压测验证:每改一项,单独压一次,记录数据,避免"多因素混合"说不清谁起作用
优化方向按预期收益排序:
- 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和缺索引这两个根因还在,缓存一失效照样打穿数据库,问题只是被藏起来了。
几个可复用的结论:
py-spy+pg_stat_statements是Python+PG组合的最低成本定位手段,先看数据再改代码;- 索引优先于ORM优化,
selectinload救不了没索引的表; - 连接池上限要和
max_connections、worker数一起算,别只调一个; - 缓存必须带降级和超时,
RedisError要吞掉,TTL加抖动; - 每改一项单独压测,混着改永远说不清是谁的功劳。
遗留问题:同步SQLAlchemy在超高并发下还是不如async,下一步考虑把这条链路迁到 asyncpg + AsyncSession,预计还能再压一截。不过那是另一个故事了。