一、问题背景
事情是这样的。我们有个商品聚合查询接口 /api/v1/products/search,早期用Flask写的,后来新功能都往FastAPI上迁,但这个接口因为调用方多,一直没动。日调用量大概200万,P95延迟常年在1200ms上下晃,高峰期(晚上8点到10点)偶尔飙到3秒以上,监控告警响过好几次。
业务方反馈"搜索页转圈太久",老板在群里@了我。没办法,只能硬着头皮上。
先说我一开始的判断——大概率是数据库慢查询。但经验告诉我别猜,先测。这篇文章就把整个过程记录下来:怎么定位、怎么优化、踩了哪些坑、最后数据怎么样。
二、环境与版本
先把环境交代清楚,不然数据没法复现:
- Python 3.10.12
- Flask 2.3.3(老接口),FastAPI 0.104.1 + Uvicorn 0.24.0(新接口)
- SQLAlchemy 2.0.23,MySQL 8.0.34(InnoDB)
- Redis 7.2.3,redis-py 5.0.1
- 部署:4核8G容器 × 3 实例,前面挂 Nginx
- 压测工具:wrk 4.2.0,本机与服务器同机房
数据库那张核心表 products 大概 380万行,关联表 product_skus 约1500万行,product_tags 约900万行。
三、定位:profiling 三板斧
3.1 先看火焰图,别急着改代码
第一步上 py-spy,这玩意儿对生产环境最友好,不用改代码、不用重启,直接 attach 到进程采样:
# 安装
pip install py-spy==0.3.14
# 找到 uvicorn worker 的 pid
ps -ef | grep uvicorn
# 采样 30 秒,生成火焰图
py-spy record -o profile.svg --pid 12345 --duration 30 --rate 100
同时用 wrk 打一轮流量,保证采样期间有真实请求:
wrk -t8 -c100 -d60s --latency "http://127.0.0.1:8000/api/v1/products/search?keyword=phone&page=1"
火焰图一出来,问题就很明显了:超过60%的采样时间卡在 pymysql 的 _read_bytes 上,也就是在等数据库返回。剩下的大头在 SQLAlchemy 的 ORM 对象构造上。
这说明什么?不是Python代码算得慢,是数据库往返次数太多、单次查询太慢。
3.2 cProfile 抓热点函数
火焰图看的是整体,具体到函数级别,用 cProfile 更细。写个脚本直接调接口的处理函数:
# profile_api.py
import cProfile
import pstats
from io import StringIO
from app.api.products import search_products # 你的处理函数
def run():
# 模拟真实请求参数
for _ in range(50):
search_products(keyword="phone", page=1, page_size=20)
if __name__ == "__main__":
pr = cProfile.Profile()
pr.enable()
run()
pr.disable()
s = StringIO()
ps = pstats.Stats(pr, stream=s).sort_stats("cumulative")
ps.print_stats(30)
print(s.getvalue())
输出里排名靠前的几条(简化后):
ncalls tottime cumtime function
50 0.002 58.320 search_products
1500 0.850 41.200 sqlalchemy.orm.query.Query.all
1500 0.120 39.800 pymysql.connections.Connection._read_bytes
950 0.030 22.100 app.models.Product.get_tags
看到没?50次请求触发了 1500 次 Query.all,平均每个请求 30 次查询。再看 get_tags 被调了 950 次——这就是典型的 N+1 查询。
3.3 定位到具体 SQL
把 ORM 的 echo 打开,或者直接看慢查询日志。我用了 MySQL 的 slow log,设置 long_query_time=0.1,抓到的典型 SQL 是这样的:
-- 主查询,走 keyword 模糊匹配
SELECT * FROM products WHERE name LIKE '%phone%' LIMIT 20 OFFSET 0;
-- 耗时 480ms,全表扫描 380万行
-- 然后对每个 product 单独查 SKU 和标签(N+1 的来源)
SELECT * FROM product_skus WHERE product_id = 10086;
SELECT * FROM product_tags WHERE product_id = 10086;
-- 各 1~3ms,但乘以 20 个商品 × 每页,累积起来就吓人了
问题清楚了,三座大山:
LIKE '%phone%'前置通配符导致索引失效,全表扫- N+1 查询,一页20个商品就是 1 + 20×2 = 41 次往返
- 没有任何缓存,同样的热门关键词每次都要重查
四、方案设计与核心实现
4.1 数据库查询优化
第一刀:干掉 N+1。 用 SQLAlchemy 的 selectinload(2.0 版本推荐,比 joinedload 在集合关系上更高效,避免笛卡尔积膨胀):
# app/api/products.py
from sqlalchemy import select
from sqlalchemy.orm import selectinload
from app.models import Product, ProductSku, ProductTag
async def fetch_products(session, keyword: str, offset: int, limit: int):
stmt = (
select(Product)
.where(Product.name.like(f"%{keyword}%"))
.options(
selectinload(Product.skus), # 批量 IN 查询,1 次搞定
selectinload(Product.tags),
)
.order_by(Product.sales.desc())
.offset(offset)
.limit(limit)
)
result = await session.execute(stmt)
return result.scalars().unique().all()
改完后查询次数从 41 次降到 3 次(主表1次 + skus 1次 + tags 1次)。这一刀下去,接口耗时直接砍掉一半多。
第二刀:解决模糊匹配。 前置 % 没法走 B+ 树索引,但 MySQL 8.0 支持全文索引。给 name 字段加:
ALTER TABLE products ADD FULLTEXT INDEX ft_name (name) WITH PARSER ngram;
ngram 解析器专门处理中文/短词,ngram_token_size 默认 2。查询改成:
SELECT * FROM products
WHERE MATCH(name) AGAINST ('phone' IN BOOLEAN MODE)
ORDER BY sales DESC LIMIT 20;
380万行的查询从 480ms 降到 35ms 左右。注意全文索引对超短关键词(1个字符)效果一般,业务上我们做了限制:关键词至少2个字符。
第三刀:补复合索引。 排序字段 sales 加上过滤条件,建了 (status, sales) 的复合索引,避免 filesort。
4.2 缓存策略
数据库优化完,P95 大概到 300ms 了,但热门关键词(比如 "phone"、"case")占了流量的40%,每次还查库太浪费。上 Redis。
缓存设计有几个点要想清楚:
- key 设计:
search:{keyword}:{page}:{size}:{filters_hash},filters 序列化后取 md5 前8位,避免 key 过长 - 过期时间:热门词 60s,冷门词 300s,加 ±10% 随机抖动防雪崩
- 空结果也缓存:防止缓存穿透,空值存 30s
- 序列化:用
orjson比标准 json 快 3~4 倍
封一个装饰器(FastAPI 场景下用依赖注入也行,但装饰器改动最小):
# app/cache.py
import hashlib
import random
import orjson
from functools import wraps
from redis.asyncio import Redis
redis_client = Redis(host="127.0.0.1", port=6379, db=0,
max_connections=50, decode_responses=False)
def cache_result(ttl: int = 60, prefix: str = "search"):
def decorator(func):
@wraps(func)
async def wrapper(*args, **kwargs):
raw = f"{kwargs.get('keyword')}:{kwargs.get('page')}:{kwargs.get('page_size')}"
fhash = hashlib.md5(str(sorted(kwargs.items())).encode()).hexdigest()[:8]
key = f"{prefix}:{raw}:{fhash}"
cached = await redis_client.get(key)
if cached is not None:
return orjson.loads(cached)
result = await func(*args, **kwargs)
# 随机抖动,防止同一批 key 同时过期
jitter = ttl * random.uniform(0.9, 1.1)
await redis_client.setex(key, int(jitter), orjson.dumps(result))
return result
return wrapper
return decorator
# 使用
@cache_result(ttl=60)
async def search_products(keyword: str, page: int = 1, page_size: int = 20):
async with async_session() as session:
return await fetch_products(session, keyword, (page - 1) * page_size, page_size)
4.3 连接池与运行时参数
几个容易忽略但影响不小的点:
- SQLAlchemy 连接池:
pool_size=20, max_overflow=10, pool_pre_ping=True, pool_recycle=1800 - Uvicorn worker 数:
--workers 4(4核机器,IO 密集型可以稍多,但别超过 2×核数) - MySQL 侧:
innodb_buffer_pool_size调到内存的 60%,我们的 8G 容器给了 4G
五、踩坑与优化
坑1:selectinload 不是万能的。 一开始我对 skus 用 joinedload,结果 20 个商品 × 平均8个SKU = 160 行,主表字段被重复返回,网络传输量暴涨,反而更慢。换成 selectinload(先查主表,再用 IN 批量查关联)才正常。
坑2:缓存雪崩差点翻车。 第一版没加随机抖动,ttl 统一 60s,结果整点缓存集体失效,数据库瞬间被打到 4000 QPS,慢查询告警直接刷屏。加了 ±10% 抖动后才稳住。另外给 Redis 加了本地二级缓存(cachetools.TTLCache,容量 1000,ttl 5s)兜底热点 key。
坑3:全文索引的分词坑。 ngram_token_size=2 时,搜 "iPhone 15" 会被切成 "iP"、"Ph"、"ho"、"on"、"ne"、"15" 等片段,召回结果里混进一堆不相关的。后来业务上加了 IN BOOLEAN MODE 并配合 + 强制包含,再在应用层做了二次过滤,才把准确率拉回来。
坑4:Flask 老接口的同步阻塞。 老接口是 Flask + 同步 pymysql,压测时 100 并发直接卡死。我们没重写,而是用 gunicorn --workers 8 --threads 4 的线程模型 + 连接池硬扛,新流量逐步切到 FastAPI 版本。
六、效果数据
优化前后用 wrk 各压 60 秒,参数一致(-t8 -c100):
| 阶段 | P50 | P95 | P99 | QPS | 错误率 |
|---|---|---|---|---|---|
| 优化前 | 680ms | 1210ms | 2350ms | 180 | 0.8% |
| 干掉 N+1 后 | 210ms | 420ms | 780ms | 520 | 0.1% |
| + 全文索引 | 95ms | 180ms | 320ms | 780 | 0% |
| + Redis 缓存 | 18ms | 85ms | 160ms | 1100 | 0% |
缓存命中率稳定在 78% 左右(热门词贡献大),数据库 QPS 从峰值 3200 降到 700 上下。
几个关键数字再强调一下:
- P95:1210ms → 85ms,降幅 93%
- QPS:180 → 1100,提升约 6 倍
- 数据库慢查询(>100ms)数量:日均 4.2 万条 → 不到 200 条
七、总结
这次调优下来,几点体会:
- 别猜,先测。 py-spy + cProfile + 慢查询日志三件套,半小时就能把瓶颈定位得七七八八,比拍脑袋改代码强太多。
- N+1 是 API 性能的头号杀手,尤其是 ORM 用得顺手的项目,一个
lazy关系就能让你多出几十次往返。 - 索引要跟着查询走,
LIKE '%x%'这种写法在现代 MySQL 里就该用全文索引替掉,别硬扛。 - 缓存是放大器不是遮羞布,数据库没优化好就上缓存,雪崩的时候哭都来不及。先让单次查询够快,再用缓存扛量。
- 压测数据要留档,每改一版压一次,用数字说话,也方便回滚时对比。
代码都跑在 Python 3.10 + FastAPI 0.104 + SQLAlchemy 2.0 上,直接抄能跑。有问题评论区聊。