Proč je FastAPI rychlý a jak jej udržovat rychlý?

Question

Accepted Answer

FastAPI je jedním z nejrychlejších Python frameworků, protože je postaven na **Starlette** (lehký ASGI framework) a je **async-native**, efektivně zpracovávající mnoho souběžných I/O-bound požadavků. Ale aby zůstal rychlý, je potřeba používat async správně — nejčastější chyba je blokování event loop.

## Proč je rychlý

```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
```

Async model je klíčový: zatímco jeden požadavek čeká na databázový dotaz nebo volání API, server zpracovává ostatní — poskytuje vysokou propustnost pro I/O-bound workloady.

## #1 způsob, jak jej udržovat rychlý: neblokuj 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()
```

Toto je jediné nejdůležitější pravidlo výkonu: blokující volání uvnitř `async def` blokuje celý event loop, což nutí požadavky běžet postupně. Použijte async knihovny s `await`, nebo běžný `def` (spustit ve thread pool).

## Udržování rychlosti — kontrolní seznam

```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
```

## Proč je to důležité

Rychlost FastAPI je hlavním důvodem, proč si týmy vybírají, ale dosažení takové rychlosti v praxi závisí na **správném používání async** — a nejdůležitější, často porušovaným pravidlem je **nikdy neblokuj event loop**.

Pochopení *proč* je FastAPI rychlý (async-native ASGI základ, efektivní I/O souběžnost, rychlé Pydantic v2 jádro) objasňuje, že jeho výkon platí pro I/O-bound workloady zpracovávané souběžně.

Vnímání jak jej *udržovat* rychlý je kritická praktická dovednost: vyhýbání se katastrofální chybě vkládání blokujících volání do `async def` (což serializuje všechny požadavky za zmrazením event loop), používání async knihoven v async endpointech (nebo běžný `def` pro blokující kód), offloading CPU práce, caching, optimalizace databází (často skutečné úzké místo), a spuštění více workerů pro více jader.

Tato kombinace — správné využívání async a měření k nalezení skutečných bottlenecků — vám umožní realizovat výkonnostní potenciál FastAPI, čímž se stane důležitým vědomím na úrovni seniora pro vytváření skutečně rychlých, škálovatelných API namísto těch, která vypadají async, ale funcionují jako blokující kód.