一、问题背景:一个"简单"的聚合接口

事情是这样的。我们有个商品详情页,后端有个聚合接口 /api/item/{id}/detail,需要同时从三个下游服务拿数据:商品基础信息(item-service)、库存(stock-service)、评价摘要(review-service)。三个服务都是独立的HTTP接口,互相没有依赖。

最初的实现非常"朴素"——Flask + requests,顺序调用:

@app.route("/api/item//detail")
def item_detail(item_id):
    item = requests.get(f"{ITEM_SVC}/item/{item_id}", timeout=1).json()
    stock = requests.get(f"{STOCK_SVC}/stock/{item_id}", timeout=1).json()
    review = requests.get(f"{REVIEW_SVC}/review/{item_id}/summary", timeout=1).json()
    return {"item": item, "stock": stock, "review": review}

平时流量低的时候没啥感觉,直到有一次做活动,监控告警:这个接口P99飙到1.2秒,QPS卡在87上不去,CPU却只用了15%。一看就明白了——CPU闲着,线程全在等IO。每个请求串行等三次下游,单次请求耗时就是三个下游延迟之和,约300ms,加上Gunicorn只开了4个sync worker,吞吐自然上不去。

这就是典型的IO密集型场景被同步模型拖死。改异步是顺理成章的事。

二、环境与版本

先交代下环境,避免版本差异导致的行为不一致:

  • Python 3.11.6(3.11的asyncio有TaskGroup,但本文为了兼容性还是用gather)
  • 改造前:Flask 2.3.3 + requests 2.31.0 + Gunicorn 21.2.0(4 sync workers)
  • 改造后:FastAPI 0.104.1 + uvicorn 0.24.0 + httpx 0.25.1(1 worker,uvloop可选)
  • 压测工具:wrk 4.2.0,wrk -t4 -c200 -d30s
  • 机器:2核4G,下游三个服务部署在同内网,单次调用延迟稳定在80~120ms

三、方案设计:并发 + 限流 + 超时

改造思路其实就三句话:

  1. 三个下游调用改为并发,总耗时从"三者之和"变成"三者最大值",理论上从300ms降到120ms左右。
  2. 用asyncio.gather聚合结果,return_exceptions=True让单个下游失败不拖垮整体,降级返回空数据。
  3. 用asyncio.Semaphore限制单进程并发下游请求数,防止流量突增时把下游打挂——这点很重要,异步不是无限并发,没有背压的异步系统在流量尖峰时反而更危险。

超时控制上,httpx的timeout参数要显式设置,我给了connect=0.5s, read=1.0s,比原来requests的1s总超时更精细。另外整个handler外层再套一个asyncio.wait_for(..., timeout=1.5)做兜底。

为什么选FastAPI而不是"Flask + async"?Flask本身是WSGI,虽然2.x可以用async def视图,但底层还是跑在线程池里,等于没真正吃到异步的红利。要真异步就得上ASGI服务器,FastAPI + uvicorn是现成组合,顺便白嫖了Pydantic的响应校验。

四、核心实现

先看改造后的完整代码:

# app.py
import asyncio
import httpx
from fastapi import FastAPI

app = FastAPI()

ITEM_SVC = "http://item-service:8001"
STOCK_SVC = "http://stock-service:8002"
REVIEW_SVC = "http://review-service:8003"

# 全局复用一个 AsyncClient,内部维护连接池
client = httpx.AsyncClient(
    timeout=httpx.Timeout(connect=0.5, read=1.0, write=1.0, pool=1.0),
    limits=httpx.Limits(max_connections=200, max_keepalive_connections=50),
)

# 限制单进程同时进行的下游请求数,形成背压
sem = asyncio.Semaphore(100)


async def fetch(url: str):
    async with sem:
        resp = await client.get(url)
        resp.raise_for_status()
        return resp.json()


async def safe_fetch(url: str, default):
    try:
        return await fetch(url)
    except Exception as e:
        # 记录日志后降级,不阻断整体
        print(f"fetch {url} failed: {e!r}")
        return default


@app.get("/api/item/{item_id}/detail")
async def item_detail(item_id: int):
    item_task = safe_fetch(f"{ITEM_SVC}/item/{item_id}", {})
    stock_task = safe_fetch(f"{STOCK_SVC}/stock/{item_id}", {"stock": -1})
    review_task = safe_fetch(f"{REVIEW_SVC}/review/{item_id}/summary", {"score": None})

    item, stock, review = await asyncio.wait_for(
        asyncio.gather(item_task, stock_task, review_task),
        timeout=1.5,
    )
    return {"item": item, "stock": stock, "review": review}

几个关键点解释一下:

AsyncClient必须全局复用。 我一开始图省事在每个请求里async with httpx.AsyncClient() as c:,压测时QPS只有300多,netstat一看大量TIME_WAIT,每次请求都新建TCP连接,连接建立开销把并发收益吃掉了。改成模块级单例后,keep-alive连接池生效,QPS直接翻了三倍。这是最大的一个坑。

Semaphore(100)的位置。 放在fetch内部而不是handler外层,是为了让"获取信号量"这个等待也变成可调度的协程挂起,而不是阻塞。100这个值是根据下游承载能力定的——三个下游各自能扛约150并发,单进程100留了余量。如果部署多worker,记得总量要除以worker数。

return_exceptions vs safe_fetch。 两种降级方式都行。我这里用safe_fetch包了一层,好处是能给每个下游定制默认值(库存默认-1表示"未知",前端会隐藏库存模块;评价默认None表示"暂无")。如果用gather(return_exceptions=True),拿到的是异常对象,还得在结果里判断类型,反而啰嗦。

启动命令也从Gunicorn换成了uvicorn:

# before
gunicorn -w 4 -k sync app:app -b 0.0.0.0:8000

# after(单worker异步,若要利用多核就多开进程,用 --workers 2)
uvicorn app:app --host 0.0.0.0 --port 8000 --workers 1 --loop uvloop

这里有个取舍:2核机器上我试过--workers 2,QPS反而略降(约1050),因为两个进程各自维护连接池,下游连接数翻倍,加上GIL切换开销。最终选了单worker + uvloop。

五、踩坑与优化

说三个印象深刻的坑。

坑一:time.sleep阻塞事件循环。 改造初期我在某个错误处理分支里写了个time.sleep(0.1)做重试间隔,结果压测时QPS骤降到个位数,所有请求像排队一样。原因是time.sleep是同步阻塞,直接把整个事件循环卡死了。改成await asyncio.sleep(0.1)立刻恢复。同理,任何同步的requests.get、同步DB驱动(如pymysql)混进async函数里都是灾难,必须换成httpx/aiomysql这类异步库,或者用asyncio.to_thread包一层。

坑二:连接池耗尽导致的假死。 有一次把max_connections设成20,并发压到200时大量请求卡在pool超时上。httpx的Limits是客户端级别的,max_connections要大于你的并发峰值除以worker数再留余量。我最后设200,配合Semaphore(100),实际同时占用不会超过100,安全。

坑三:raise_for_status的时机。 最初fetch里忘了调raise_for_status,下游返回500时resp.json()直接抛JSONDecodeError,被safe_fetch吞掉降级了,但日志里全是解析错误,排查了半天才发现是下游挂了而不是数据格式问题。加上raise_for_status后错误信息清晰多了。

另外做了一处小优化:给下游请求加了X-Request-Id透传,方便链路追踪;print换成了logging(生产环境别用print,异步下stdout锁也会有影响)。

六、效果数据

同一台2核4G机器,下游延迟不变,wrk -t4 -c200 -d30s 结果:

指标 Before (Flask+requests) After (FastAPI+asyncio)
QPS 87 1100
P50 延迟 310ms 95ms
P99 延迟 1.2s 180ms
CPU 使用率 15% 62%
内存占用 180MB 210MB
单请求下游连接数 3(串行) 3(并发,连接复用)

QPS提升约12.6倍,P99降低85%。CPU从15%涨到62%是好事——说明机器终于干活了而不是在等IO。内存略涨是连接池和协程对象的开销,可以接受。

顺便做了个故障演练:手动把review-service停掉,接口仍能在约130ms内返回,review字段降级为{"score": null},前端正常展示"暂无评价",没有雪崩。这是同步版本做不到的——原来一个下游挂掉,整个接口直接500。

七、总结

这次改造的核心结论就几条:

  1. IO密集型接口,异步的收益是数量级的,但前提是真的跑在ASGI服务器上,Flask的伪async不算。
  2. 异步不等于无限并发,Semaphore背压和连接池上限必须配,否则流量尖峰时你是把下游打挂的第一责任人。
  3. 客户端要全局复用,AsyncClient单例 + keep-alive是QPS翻倍的关键,比调参管用。
  4. 别在async函数里混同步阻塞调用,一个time.sleep就能让整个事件循环停摆,这类问题压测时才暴露,平时看不出来。
  5. 降级要用safe_fetch这种按依赖定制的包装,比return_exceptions更好维护。

当然异步不是银弹。如果下游是CPU密集任务,或者团队对协程调试不熟,同步+多进程可能更稳。但对我们这种"一个请求扇出多个下游IO"的场景,asyncio是当前Python生态里性价比最高的解法。代码还短了30行,可读性反而更好——毕竟gather三个任务,比三行串行requests.get更能表达"这三个是并行的"这个意图。