一、问题背景

事情是这样的。我们有个商品聚合查询接口 /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 个商品 × 每页,累积起来就吓人了

问题清楚了,三座大山:

  1. LIKE '%phone%' 前置通配符导致索引失效,全表扫
  2. N+1 查询,一页20个商品就是 1 + 20×2 = 41 次往返
  3. 没有任何缓存,同样的热门关键词每次都要重查

四、方案设计与核心实现

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 条

七、总结

这次调优下来,几点体会:

  1. 别猜,先测。 py-spy + cProfile + 慢查询日志三件套,半小时就能把瓶颈定位得七七八八,比拍脑袋改代码强太多。
  2. N+1 是 API 性能的头号杀手,尤其是 ORM 用得顺手的项目,一个 lazy 关系就能让你多出几十次往返。
  3. 索引要跟着查询走,LIKE '%x%' 这种写法在现代 MySQL 里就该用全文索引替掉,别硬扛。
  4. 缓存是放大器不是遮羞布,数据库没优化好就上缓存,雪崩的时候哭都来不及。先让单次查询够快,再用缓存扛量。
  5. 压测数据要留档,每改一版压一次,用数字说话,也方便回滚时对比。

代码都跑在 Python 3.10 + FastAPI 0.104 + SQLAlchemy 2.0 上,直接抄能跑。有问题评论区聊。