Zakaj je FastAPI hiter in kako ga ohraniš takšnega?

Question

Accepted Answer

FastAPI je med najhitrejšimi Python okvirji, ker je zgrajen na **Starlette** (lahkem ASGI ogrodju) in je **async-nativa**, kar omogoča učinkovito upravljanje številnih sočasnih zahtevkov s posebnostjo I/O. Vendar pa njegovo hitrost zahteva pravilno uporabo async — pogosta napaka je blokiranje zanke dogodkov.

## Zakaj je hiter

```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 ključen: medtem ko ena zahtevka čaka na poizvedbo baze podatkov ali klic API-ja, strežnik upravlja druge — kar daje visoko prepustnost za I/O-omejene delovne obremenitve.

## Najpomembnejši način, da ga ohraniš hitrega: ne blokiraj zanke dogodkov

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

To je edino najpomembnejše pravilo zmogljivosti: klic, ki blokira znotraj `async def`, blokira celotno zanko dogodkov, kar prisili zahtevke k zaporednemu izvajanju. Uporabi async knjižnice z `await` ali navadni `def` (se zažene v niti bazena).

## Ohranjanje hitrega — kontrolni 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
```

## Zakaj je to pomembno

Hitrost FastAPI-ja je glavni razlog, da si ekipe izberejo ta okvir, vendar pa doseganje te hitrosti v praksi zavisi od **pravilne uporabe async** — in najpomembnejše, pogosto kršeno pravilo je **nikoli ne blokiraj zanke dogodkov**.

Razumevanje *zakaj* je FastAPI hiter (async-nativna ASGI osnova, učinkovita I/O sočasnost, hiter Pydantic v2 jedro) pojasni, da se njegova prednost zmogljivosti uporablja za I/O-omejene delovne obremenitve, ki se izvajajo sočasno.

Znanje kako ga *ohraniš* hitrega je kritična praktična spretnost: izogibanje katastrofalnih napakam postavljanja blokirajočih klicev v `async def` (kar serijalizira vse zahtevke za zmrznjeno zanko dogodkov), uporaba async knjižnic v async končnih točkah (ali navadni `def` za blokirajočo kodo), izločanje CPU dela, cache-iranje, optimizacija baze podatkov (pogosto pravi ozko grlo) in zagon več delavcev za več jeder.

Ta kombinacija — pravilna izkoriščanja async in merjenja za iskanje resničnih ozkih grl — je tisto, kar te pusti realizirati potencial zmogljivosti FastAPI-ja, kar ga naredi pomembno znanje na ravni starejšega inženirja za gradnjo resnično hitrih, razširljivih API-jev namesto tistih, ki izgledajo async, vendar se izvajajo kot blokirajoca koda.