Zašto je FastAPI brz i kako ga održavati takvim?

Question

Accepted Answer

FastAPI je među najbržim Python okvirima jer je izgrađen na **Starlette** (laganom ASGI okviru) i **async-native**, što učinkovito rukuje mnogim istovremenim I/O-bound zahtjevima. Ali da bi ga zadržao brzim, potrebno je ispravno koristiti async — najčešća greška je blokiranje event loop-a.

## Zašto je brz

```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čan: dok jedan zahtjev čeka query baze podataka ili API poziv, server rukuje ostalima — što daje visok propusnost za I/O-bound workloads.

## #1 način da ga zadržiš brzim: ne blokira 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()
```

Ovo je najvažnije pravilo performansi: blokiranje poziva unutar `async def` blokira cijeli event loop, forsira zahtjeve da se izvršavaju jedan po jedan. Koristi async biblioteke s `await`, ili običan `def` (pokreće se u thread pool-u).

## Održavanje brzine — checklist

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

## Zašto je to važno

Brzina FastAPI-ja je primarni razlog što timovi ga biraju, ali postizanje te brzine u praksi ovisi o **ispravnoj upotrebi async-a** — i najvažnije, često kršeno pravilo je **nikada ne blokira event loop**.

Razumijevanje *zašto* je FastAPI brz (async-native ASGI temelj, učinkovita I/O konkurentnost, brz Pydantic v2 core) pojašnjava da se njegov prednost u performansama odnosi na I/O-bound workloads obrađene istovremeno.

Znanje kako ga *održati* brzim je kritična praktična vještina: izbjegavanje katastrofalne greške stavljanja blocking poziva u `async def` (što serializira sve zahtjeve iza zamrznutog event loop-a), korištenja async biblioteka u async endpointima (ili običan `def` za blocking kod), rasterećenja CPU posla, cachiranja, optimizacije baze podataka (često pravi usko grlo), i pokretanja više workera za više jezgri.

Ova kombinacija — ispravna upoteba async-a i mjerenja za pronalaženje stvarnih uskih grla — je ono što te omogućava da realiziraš performance potencijal FastAPI-ja, čineći to važnim znanjem razine seniora za izgradnju doista brzih, skalabilnih API-ja umjesto onih koji izgledaju async ali se ponašaju kao blocking kod.