Kodėl FastAPI yra greitasis ir kaip jį išlaikyti greitą?

Question

Accepted Answer

FastAPI yra vienas iš greitausių Python framework'ų, nes yra pastatytas ant **Starlette** (lengvo ASGI framework'o) ir yra **async-native**, efektyviai tvarkydamas daug vienu metu atliekamų I/O-bound užklausų. Tačiau jo išlaikymui greitam reikalingas teisingas async naudojimas — dažniausia klaida yra event loop blokavimas.

## Kodėl jis yra greitasis

```text
✓ ASGI + Starlette — a modern async foundation (vs older WSGI sync frameworks)
✓ Async-native — one process handles thousands of concurrent I/O-bound requests
  by overlapping wait times, instead of one-at-a-time
✓ Pydantic v2 — validation/serialization core is now in Rust (very fast)
✓ Minimal overhead per request
```

Asinchroninis modelis yra raktas: kai viena užklausa laukia duomenų bazės užklausos arba API skambučio, serveris apdoroja kitas — suteikdamas aukštą našumą I/O-bound darbo apkrovoms.

## #1 būdas jį išlaikyti greitą: neblokuoti event loop

```python
# ❌ blocking call inside async def → freezes the event loop, serializing ALL requests
@app.get("/bad")
async def bad():
    return requests.get(url).json()       # SYNC/blocking → kills concurrency

# ✅ use an async client and await it
@app.get("/good")
async def good():
    async with httpx.AsyncClient() as c:
        return (await c.get(url)).json()  # non-blocking

# ✅ OR use a plain def — FastAPI runs it in a thread pool (safe for blocking code)
@app.get("/also-good")
def also_good():
    return requests.get(url).json()
```

Tai yra viena svarbiausių našumo taisyklė: blokuojantis skambucis `async def` viduje blokuoja visą event loop, priversdamas užklausas vykti vieną po kitos. Naudokite asinchronines bibliotecas su `await` arba paprastą `def` (vykdomą siūlų telkinyje).

## Jo išlaikymas greitam — kontrolinis sąrašas

```text
✓ Use async DB drivers / async libraries (httpx, asyncpg) in async endpoints
✓ Run blocking code in plain def (thread pool) or via run_in_executor
✓ Avoid heavy CPU work on the event loop → offload to workers/processes
✓ Add caching (Redis) for expensive repeated work
✓ Optimize the database (fix N+1, add indexes) — often the real bottleneck
✓ Run multiple worker processes (uvicorn/gunicorn workers) to use all CPU cores
✓ Use connection pooling; paginate large results
✓ MEASURE first (profiling, load testing) — fix the actual bottleneck
```

## Kodėl tai svarbu

FastAPI greitis yra pagrindinė priežastis, kodėl komandos ją pasirenka, tačiau realiai pasiekti tą greitį priklauso nuo **teisingai naudojant async** — ir svarbiausias, dažnai sulaužomas taisyklė yra **niekada neblokuoti event loop**.

Supratime, *kodėl* FastAPI yra greitasis (async-native ASGI pagrindas, efektyvus I/O lygiagretumas, greitas Pydantic v2 branduolys) paaiškina, kad jo našumo pranašumas taikomas I/O-bound darbo apkrovoms, apdorojamiems lygiagretei.

Žinoti, kaip jo *išlaikyti* greitą, yra kritinis praktinis įgūdis: vengti žalingos klaidos, kai blokuojantys skambučiai `async def` viduje (kurie serijinė visos užklausas šaldytojo event loop'o atžvilgiu), naudoti asinchronines bibliotecas async pabaigose (arba paprastą `def` blokuojančiam kodui), CPU darbą nukelti, talpinti, duomenų bazę optimizuoti (dažnai tikroji kliūtis) ir kelis darbininkus paleisti keliems branduoliams.

Šis derinys — tinkamai naudoti async ir matuoti tikroms kliūtims rasti — yra kas leidžia jums suprasti FastAPI našumo potencialą, todėl jis yra svarbus aukšto lygio žinios kurti tikrai greitai, išplečiamoms API, o ne tiems, kurie atrodo async, bet veikia kaip blokuojantis kodas.