一、问题背景

上个月接手了一个内部服务,叫商品聚合查询API。业务很简单:前端传一个商品ID,后端要同时从库存服务、价格服务、促销服务三个下游HTTP接口拿数据,拼装后返回。

原来的实现是Flask + requests,代码大概是这样的:

# before: app_sync.py
import requests
from flask import Flask, jsonify

app = Flask(__name__)

STOCK_URL = "http://stock-svc:8001/stock/{pid}"
PRICE_URL = "http://price-svc:8002/price/{pid}"
PROMO_URL = "http://promo-svc:8003/promo/{pid}"

@app.route("/product/")
def get_product(pid):
    stock = requests.get(STOCK_URL.format(pid=pid), timeout=2).json()
    price = requests.get(PRICE_URL.format(pid=pid), timeout=2).json()
    promo = requests.get(PROMO_URL.format(pid=pid), timeout=2).json()
    return jsonify({"stock": stock, "price": price, "promo": promo})

逻辑上没问题,但性能很差。原因很直接:三个下游调用是串行的,每个平均100ms左右,加起来就是300ms。Flask默认单进程单线程处理请求,虽然可以开多worker,但每个worker内部还是串行阻塞。

压测数据(locust 2.29.0,100并发,持续5分钟):

  • QPS:约120
  • P50延迟:310ms
  • P99延迟:820ms
  • 4核8G机器,gunicorn 4 worker + 4 thread

P99到820ms说明排队严重,请求在worker里堵着等IO。这是一个典型的IO密集型场景被同步模型拖垮的案例。

二、环境与版本

动手前先把环境钉死,避免后面数据不可比:

  • Python 3.11.9(3.11的asyncio有TaskGroup和更快的异常处理,值得升)
  • aiohttp 3.9.5
  • uvicorn 0.30.1(标准版,含uvloop)
  • uvloop 0.19.0(uvicorn[standard]自带)
  • locust 2.29.0
  • 下游三个服务保持不变,用mock服务模拟,固定延迟100ms

机器配置:4 vCPU / 8GB,容器内跑,网络延迟忽略不计。

三、方案设计

目标很明确:把三个串行IO变成并发IO,单请求的理论耗时从300ms降到100ms左右。方案选型上考虑过几个:

  1. 继续用Flask + 线程池跑requests——改动小,但线程上下文切换和GIL下收益有限,而且线程池大小难调,容易打满下游。
  2. 换FastAPI + async——框架层原生支持async,生态成熟。
  3. 纯asyncio + aiohttp自建HTTP服务——太底层,不划算。

最终选FastAPI(0.111.0),因为团队后续要加接口文档和参数校验,FastAPI的pydantic集成省事。但核心不是框架,是asyncio的并发模型。

关键设计点:

  • 用asyncio.gather并发三个下游请求
  • aiohttp用全局ClientSession,配TCPConnector连接池,limit=100,limit_per_host=50
  • 每个请求加asyncio.timeout(1.5),避免单个下游拖死整体
  • uvicorn开--workers 4,配合uvloop
  • 下游失败时降级返回默认值,不让整个请求500

四、核心实现

先看改造后的代码:

# after: app_async.py
import asyncio
import aiohttp
from fastapi import FastAPI
from contextlib import asynccontextmanager

STOCK_URL = "http://stock-svc:8001/stock/{pid}"
PRICE_URL = "http://price-svc:8002/price/{pid}"
PROMO_URL = "http://promo-svc:8003/promo/{pid}"

session: aiohttp.ClientSession | None = None

@asynccontextmanager
async def lifespan(app: FastAPI):
    global session
    connector = aiohttp.TCPConnector(
        limit=100,
        limit_per_host=50,
        ttl_dns_cache=300,
        enable_cleanup_closed=True,
    )
    timeout = aiohttp.ClientTimeout(total=1.5, connect=0.5)
    session = aiohttp.ClientSession(connector=connector, timeout=timeout)
    yield
    await session.close()

app = FastAPI(lifespan=lifespan)

async def fetch(url: str) -> dict:
    try:
        async with session.get(url) as resp:
            resp.raise_for_status()
            return await resp.json()
    except (aiohttp.ClientError, asyncio.TimeoutError):
        return {"error": True}

@app.get("/product/{pid}")
async def get_product(pid: str):
    stock, price, promo = await asyncio.gather(
        fetch(STOCK_URL.format(pid=pid)),
        fetch(PRICE_URL.format(pid=pid)),
        fetch(PROMO_URL.format(pid=pid)),
    )
    return {"stock": stock, "price": price, "promo": promo}

启动命令:

uvicorn app_async:app --host 0.0.0.0 --port 8080 --workers 4 --loop uvloop

几个细节说明:

  • ClientSession必须在lifespan里创建和关闭,不能每个请求新建。每次新建session等于每次新建连接池,TCP握手和TLS开销全回来了,这是最常见的错误。
  • limit_per_host=50是拍脑袋定的,后来根据下游承载能力调过,见下一节。
  • ClientTimeout(total=1.5, connect=0.5)分开设连接超时和总超时,连接超时短一点能快速失败。
  • asyncio.gather默认return_exceptions=False,但我在fetch内部已经捕获了异常,所以gather不会因为单个失败而整体抛错。

五、踩坑与优化

改造过程不是一次成功的,记录几个真实坑:

坑1:连接池打满下游。 第一版limit=1000,压测时下游mock服务直接被打挂,因为4个worker各开1000连接,总共4000并发连接。后来把limit_per_host降到50,总连接控制在200,下游稳了,QPS反而没降——说明瓶颈不在连接数。最终配置:limit=200, limit_per_host=50。

坑2:DNS缓存。 aiohttp默认每次请求可能走DNS解析,虽然系统有缓存,但容器环境DNS查询偶发慢。加上ttl_dns_cache=300后,P99抖动明显减少。

坑3:gather没有超时保护。 虽然有ClientTimeout,但如果下游返回慢速流式响应,await resp.json()可能卡住。后来在外层再加一层asyncio.timeout兜底。

坑4:uvicorn worker数和连接池的乘法关系。 一开始没意识到每个worker是独立进程、独立连接池。4 worker × limit_per_host 50 = 200个到单一下游的连接。调参时要按总量算,不是按单worker算。

坑5:JSON序列化开销。 压测到QPS 900左右时CPU起来了,profile发现resp.json()和FastAPI的响应序列化各占一部分。后来把下游返回改成orjson解析(aiohttp支持自定义json loads),QPS多了约8%。

六、效果数据

同样的locust脚本、100并发、5分钟,对比:

指标 before (Flask) after (asyncio)
QPS 120 1100
P50 310ms 88ms
P95 620ms 92ms
P99 820ms 95ms
CPU使用率 65% 78%
内存 420MB 380MB

QPS提升约9倍,P99从820ms降到95ms。CPU使用率上升是因为并发度高了、真正在干活,不是坏事。内存略降是因为没有线程栈开销。

再补一个并发梯度测试(after方案):

并发数 QPS P99
50 620 82ms
100 1100 95ms
200 1350 180ms
400 1400 420ms

200并发之后QPS基本到顶,P99开始涨,说明瓶颈转移到了下游或CPU。这个拐点数据对容量规划很有用。

七、总结

这次改造的核心结论就一条:IO密集型的聚合接口,串行改并发是性价比最高的优化,代码改动量不到100行,QPS提升一个数量级。

几个可以复用的经验:

  1. ClientSession必须全局复用,连接池参数按"worker数 × 单worker连接数"算总量。
  2. 超时要分层设:连接超时、请求总超时、外层兜底超时。
  3. 用asyncio.gather时,异常在子协程内部消化,别让一个下游失败拖垮整个响应。
  4. 压测要看拐点,QPS到顶后的并发数没有意义,只会推高P99。
  5. 别忘了ttl_dns_cache,容器环境里这个参数很值。

如果下游有强依赖顺序(比如要先拿价格才能算促销),那就只能部分并发,这时候要考虑用asyncio.Queue做流水线,或者干脆做结果缓存。但那是另一个话题了。