一、问题背景:一个"简单"的聚合接口
事情是这样的。我们有个商品详情页,后端有个聚合接口 /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
三、方案设计:并发 + 限流 + 超时
改造思路其实就三句话:
- 三个下游调用改为并发,总耗时从"三者之和"变成"三者最大值",理论上从300ms降到120ms左右。
- 用
asyncio.gather聚合结果,return_exceptions=True让单个下游失败不拖垮整体,降级返回空数据。 - 用
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。
七、总结
这次改造的核心结论就几条:
- IO密集型接口,异步的收益是数量级的,但前提是真的跑在ASGI服务器上,Flask的伪async不算。
- 异步不等于无限并发,
Semaphore背压和连接池上限必须配,否则流量尖峰时你是把下游打挂的第一责任人。 - 客户端要全局复用,
AsyncClient单例 + keep-alive是QPS翻倍的关键,比调参管用。 - 别在async函数里混同步阻塞调用,一个
time.sleep就能让整个事件循环停摆,这类问题压测时才暴露,平时看不出来。 - 降级要用
safe_fetch这种按依赖定制的包装,比return_exceptions更好维护。
当然异步不是银弹。如果下游是CPU密集任务,或者团队对协程调试不熟,同步+多进程可能更稳。但对我们这种"一个请求扇出多个下游IO"的场景,asyncio是当前Python生态里性价比最高的解法。代码还短了30行,可读性反而更好——毕竟gather三个任务,比三行串行requests.get更能表达"这三个是并行的"这个意图。