在當今快節奏的Web應用開發中，API性能直接影響用戶體驗和系統穩定性。FastAPI作爲一個高性能的Python Web框架，憑藉異步支持和自動生成文檔等特性，已成爲衆多項目的首選。但即使使用FastAPI，若代碼和部署環節缺乏優化，性能瓶頸仍可能出現。本文將從代碼、數據庫、緩存到部署，一步步拆解FastAPI性能優化的核心思路和實用技巧，幫助初學者快速提升應用效率。
一、代碼層面的基礎優化¶
FastAPI本身已基於異步和高效解析器（如Uvicorn）實現了基礎性能優勢，但代碼寫法仍可能成爲瓶頸。以下是初學者最容易優化的方向：
1. 優先使用異步函數處理IO密集型任務¶
FastAPI支持async def定義異步路徑操作函數，適合處理IO密集型任務（如數據庫查詢、API調用、文件讀寫）。但需注意：不要在異步函數中執行CPU密集型操作（如複雜循環、數學計算），這類任務會阻塞事件循環，反而降低性能。
# 反例：同步數據庫查詢（會阻塞事件循環）
def get_user_sync(user_id: int):
db = create_db_connection() # 同步連接
result = db.query("SELECT * FROM users WHERE id = ?", user_id)
db.close()
return result
# 正例：異步數據庫查詢（非阻塞）
from fastapi import FastAPI
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine # 異步ORM
app = FastAPI()
engine = create_async_engine("postgresql+asyncpg://user:pass@localhost/db") # 異步連接
@app.get("/users/{user_id}")
async def get_user(user_id: int, db: AsyncSession = Depends(get_db)):
result = await db.execute(User.__table__.select().where(User.id == user_id)) # 用await等待異步查詢
return result.scalars().first()
2. 避免“過度計算”和數據冗餘¶
在路徑函數中，若需返回大量數據（如列表），直接構造完整列表可能導致內存佔用過高。此時可用生成器（Generator） 或分頁替代，減少內存消耗。
# 反例：返回完整大列表（內存佔用高）
@app.get("/products")
async def get_all_products():
return [{"id": i, "name": f"商品{i}"} for i in range(10000)] # 生成10000條數據
# 正例：使用生成器+分頁（按需返回）
from fastapi import Query
@app.get("/products")
async def get_products(page: int = Query(1, ge=1), page_size: int = Query(20, ge=1, le=100)):
offset = (page - 1) * page_size
# 生成器示例：通過SQL的limit/offset分頁，只返回當前頁數據
async with engine.connect() as conn:
result = await conn.execute(
User.__table__.select().offset(offset).limit(page_size)
)
return [dict(row) for row in result.all()]
3. 用參數驗證減少後續處理¶
FastAPI的參數驗證（如類型註解、Query/Path參數）不僅能自動生成API文檔，還能提前過濾無效請求，避免後續邏輯浪費資源。
# 正例：參數類型註解+範圍驗證
@app.get("/items/{item_id}")
async def get_item(item_id: int = Path(..., ge=1), limit: int = Query(10, le=100)): # 限制item_id≥1，limit≤100
return {"item_id": item_id, "limit": limit}
二、異步編程的正確姿勢¶
異步是FastAPI的核心優勢，但誤用異步反而會導致性能下降。以下是關鍵原則：
1. 區分“IO密集型”和“CPU密集型”任務¶
- IO密集型（如網絡請求、數據庫查詢）：適合異步，因爲等待IO時可切換其他任務。
- CPU密集型（如大數據計算、AI推理）：異步不適用，需用
asyncio.run_in_executor提交到線程池，或改用多進程。
# 反例：異步函數中執行CPU密集任務（阻塞事件循環）
import time
async def process_data(data: list):
result = []
for item in data:
time.sleep(0.1) # 模擬CPU密集計算（實際中可能是for循環處理大數據）
result.append(item * 2)
return result
# 正例：將CPU密集任務丟到線程池（非阻塞）
from concurrent.futures import ThreadPoolExecutor
@app.get("/process")
async def process_data():
data = [1, 2, 3, ..., 1000] # 大數據列表
loop = asyncio.get_event_loop()
result = await loop.run_in_executor(
ThreadPoolExecutor(), # 線程池處理CPU密集任務
process_data_sync, # 同步函數（內部是CPU密集邏輯）
data
)
return result
2. 異步框架的正確搭配¶
使用異步ORM（如SQLAlchemy 1.4+的異步版本、Tortoise-ORM）或異步HTTP客戶端（如aiohttp），避免在異步函數中調用同步庫（如requests）。
# 錯誤：異步函數中調用同步HTTP庫（會阻塞事件循環）
import requests
async def get_remote_data():
response = requests.get("https://api.example.com/data") # 同步請求，會阻塞！
return response.json()
# 正確：用異步HTTP客戶端
import aiohttp
async def get_remote_data():
async with aiohttp.ClientSession() as session:
async with session.get("https://api.example.com/data") as response:
return await response.json() # 等待異步響應
三、數據庫查詢優化¶
數據庫是最常見的性能瓶頸，優化方向如下：
1. 連接池與連接複用¶
頻繁創建/關閉數據庫連接會消耗大量時間。使用連接池複用連接，設置合理的連接數（通常爲CPU核心數×2）。
# SQLAlchemy異步連接池配置
from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
from sqlalchemy.orm import sessionmaker
engine = AsyncEngine(
"postgresql+asyncpg://user:pass@localhost/db",
pool_size=10, # 連接池大小（根據併發量調整）
max_overflow=20, # 超過pool_size後最多創建的連接數
pool_recycle=300 # 連接超時自動回收（避免數據庫斷連）
)
SessionLocal = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
2. 索引與查詢語句優化¶
- 加索引：確保查詢字段（如
WHERE、JOIN條件）有索引，避免全表掃描。 - 優化SQL：避免
SELECT *（只查必要字段），用LIMIT/OFFSET分頁（大數據量用遊標分頁）。
-- 優化前：無索引的全表掃描
SELECT * FROM users WHERE name LIKE '%test%'; # 慢！全表掃描
-- 優化後：加索引
CREATE INDEX idx_users_name ON users(name); # 對name字段加索引
SELECT id, email FROM users WHERE name LIKE '%test%' LIMIT 100; # 只查必要字段+分頁
3. 延遲加載與批量操作¶
- 延遲加載：用
selectinload（批量加載關聯數據）替代joinedload（立即加載），減少數據庫往返。 - 批量插入/更新：用
bulk_insert_mappings替代逐條插入，減少SQL執行次數。
四、緩存策略：減少重複計算¶
緩存可顯著降低數據庫負載和重複計算，適合不常變化、高頻訪問的數據（如熱門商品列表、配置信息）。
1. 內存緩存（簡單場景）¶
用cachetools實現內存緩存，適合單實例部署：
from cachetools import LRUCache
# 定義緩存（最多存100條記錄，自動淘汰舊數據）
cache = LRUCache(maxsize=100)
@app.get("/hot-products")
async def get_hot_products():
# 嘗試從緩存獲取
cached_result = cache.get("hot_products")
if cached_result:
return cached_result # 直接返回緩存數據
# 緩存未命中，查詢數據庫
async with SessionLocal() as session:
result = await session.execute("SELECT * FROM products ORDER BY sales DESC LIMIT 20")
hot_products = [dict(row) for row in result.all()]
# 存入緩存（設置10分鐘過期）
cache["hot_products"] = hot_products
return hot_products
2. Redis分佈式緩存（多實例場景）¶
多服務器部署時，用Redis作爲共享緩存，支持跨實例緩存。需安裝redis庫：
import redis
r = redis.Redis(host="localhost", port=6379, db=0) # 連接Redis
@app.get("/product/{product_id}")
async def get_product(product_id: int):
cache_key = f"product:{product_id}"
cached_data = r.get(cache_key)
if cached_data:
return json.loads(cached_data) # 返回緩存數據
# 數據庫查詢
product = await get_product_from_db(product_id)
# 存入Redis（設置30分鐘過期）
r.setex(cache_key, 60*30, json.dumps(product))
return product
五、部署與擴展：提升併發能力¶
代碼和數據庫優化後，需通過部署配置提升服務器併發處理能力。
1. 多進程/多線程部署¶
FastAPI需配合異步服務器（如Uvicorn）和進程管理工具（如Gunicorn）：
# 啓動命令：Uvicorn + Gunicorn（2個worker，每個worker4個線程）
gunicorn main:app -w 2 -k uvicorn.workers.UvicornWorker -t 120 --threads 4
- worker數量：通常爲
CPU核心數×2 + 1（充分利用多核）。 - 線程數：IO密集型任務設爲
worker數×CPU核心數，減少等待時間。
2. 反向代理與負載均衡¶
用Nginx作爲反向代理，處理靜態資源、SSL終結，並轉發請求到多個FastAPI實例：
# Nginx配置示例
server {
listen 80;
location / {
proxy_pass http://127.0.0.1:8000; # 轉發到FastAPI
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
}
location /static/ {
alias /path/to/static/files/; # 直接返回靜態資源，不經過FastAPI
}
}
3. 容器化與自動擴縮容¶
用Docker容器化部署，配合Kubernetes實現自動擴縮容（根據CPU/內存使用率動態增加實例）：
# Dockerfile
FROM python:3.10-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["gunicorn", "main:app", "-w", "4", "-k", "uvicorn.workers.UvicornWorker", "--bind", "0.0.0.0:8000"]
總結：性能優化的核心思路¶
- 定位瓶頸：用工具（如
cProfile、asyncio調試）先找出慢的代碼段。 - 從代碼到部署逐步優化：先優化異步代碼→數據庫→緩存→部署。
- 優先解決高性價比問題：比如加索引、緩存，往往比複雜架構更簡單有效。
- 監控與迭代：用Prometheus、APM工具監控性能指標，持續優化。
通過以上步驟，即使是初學者也能系統提升FastAPI的性能，打造高效、穩定的API服務。