Mengapa FastAPI cepat, dan bagaimana cara menjaganya tetap cepat?

Question

Accepted Answer

FastAPI adalah salah satu framework Python tercepat karena dibangun di atas **Starlette** (framework ASGI yang ringan) dan **async-native**, menangani banyak request I/O-bound bersamaan dengan efisien. Tetapi menjaganya tetap cepat memerlukan penggunaan async dengan benar — kesalahan paling umum adalah memblokir event loop.

## Mengapa cepat

```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 adalah kuncinya: saat satu request menunggu query database atau panggilan API, server menangani yang lain — memberikan throughput tinggi untuk workload I/O-bound.

## Cara #1 menjaganya cepat: jangan 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()
```

Ini adalah aturan performa paling penting: panggilan blocking di dalam `async def` memblokir seluruh event loop, memaksa request berjalan satu per satu. Gunakan library async dengan `await`, atau `def` biasa (dijalankan di thread pool).

## Menjaga kecepatan — 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
```

## Mengapa ini penting

Kecepatan FastAPI adalah alasan utama tim memilihnya, tetapi mencapai kecepatan itu dalam praktik tergantung pada **menggunakan async dengan benar** — dan aturan paling penting yang sering dilanggar adalah **jangan pernah blokir event loop**.

Memahami *mengapa* FastAPI cepat (fondasi ASGI async-native, konkurensi I/O efisien, core Pydantic v2 cepat) menjelaskan bahwa keunggulan performanya berlaku untuk workload I/O-bound yang ditangani secara bersamaan.

Mengetahui cara *menjaganya* cepat adalah keterampilan praktis yang kritis: menghindari kesalahan fatal menempatkan panggilan blocking di `async def` (yang menserialisasi semua request di balik event loop yang membeku), menggunakan library async di endpoint async (atau `def` biasa untuk kode blocking), memindahkan pekerjaan CPU, caching, mengoptimalkan database (sering kali bottleneck nyata), dan menjalankan multiple worker untuk multiple core.

Kombinasi ini — memanfaatkan async dengan benar dan mengukur untuk menemukan bottleneck nyata — adalah apa yang memungkinkan Anda mewujudkan potensi performa FastAPI, menjadikannya pengetahuan level senior yang penting untuk membangun API yang benar-benar cepat dan scalable daripada yang terlihat async tetapi berperforma seperti kode blocking.