Apa sing nggawe FastAPI cepet, lan carane njaga tetep cepet?

Question

Accepted Answer

FastAPI minangka salah sawijining framework Python sing paling cepet amarga dibangun ing **Starlette** (framework ASGI sing ringan) lan **async-native**, nangani kanthi efisien akeh permintaan I/O-bound sing serentak. Nanging njaga tetep cepet mbutuhake nggunakake async kanthi bener — kesalahan paling umum yaiku blokir event loop.

## Apa sing nggawe cepet

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

Model async minangka kunci: nalika siji permintaan ngenteni query database utawa panggilan API, server nangani sing liyane — menehi throughput dhuwur kanggo beban kerja I/O-bound.

## Cara #1 kanggo njaga tetep cepet: aja blokir 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()
```

Iki minangka aturan performa paling penting: panggilan blokir ing jero `async def` blokir kabeh event loop, meksa permintaan mlayu siji demi siji. Gunakake pustaka async karo `await`, utawa `def` biasa (mlayu ing thread pool).

## Njaga tetep cepet — cek dhaftar

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

## Apa sing penting

Kecepatan FastAPI minangka alasan utama tim milih, nanging nggayuh kecepatan kasebut kanthi praktik gantung ing **nggunakake async kanthi bener** — lan aturan paling penting sing asring dilanggar yaiku **aja blokir event loop**.

Ngerti *apa* sing nggawe FastAPI cepet (fondasi ASGI async-native, concurrency I/O efisien, Pydantic v2 core cepet) jelas karo yen keunggulan performa kasebut ditrapake ing beban kerja I/O-bound sing ditangani kanthi serentak.

Mengerti carane *njaga* tetep cepet yaiku katrampilan praktis kritikal: nyegah kesalahan mengancam yaiku nulis panggilan blokir ing `async def` (sing nggawe kabeh permintaan serial ing mburi event loop tus), nggunakake pustaka async ing endpoint async (utawa `def` biasa kanggo kode blokir), ngilangi kerja CPU, caching, optimisasi database (asring langsing sing nyambut gawe), lan mlayu akeh worker kanggo akeh core.

Gabungan iki — ngangkut async kanthi bener lan ngukur kanggo nemokake langsing asli — minangka sing nglarangake sira kenal potensi performa FastAPI, nggawe penting pengetahuan level senior kanggo mbangun API cepat lan skalabel sing bener-beneren tinimbang sing katon async nanging performa kaya kode blokir.