Mengapa FastAPI cepat, dan bagaimana Anda mempertahankannya 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 secara efisien banyak permintaan I/O-bound bersamaan. Tetapi mempertahankannya tetap cepat memerlukan penggunaan async dengan benar — kesalahan paling umum adalah memblokir event loop.

## Mengapa itu 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: sementara satu permintaan menunggu kueri database atau panggilan API, server menangani yang lain — memberikan throughput tinggi untuk beban kerja I/O-bound.

## Cara #1 untuk mempertahankannya tetap 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 tunggal yang paling penting: panggilan pemblokiran di dalam `async def` memblokir seluruh event loop, memaksa permintaan berjalan satu per satu. Gunakan perpustakaan async dengan `await`, atau `def` biasa (berjalan di thread pool).

## Mempertahankannya tetap cepat — daftar periksa

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

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

Memahami *mengapa* FastAPI cepat (fondasi ASGI async-native, konkurensi I/O yang efisien, Pydantic v2 core yang cepat) memperjelas bahwa keunggulan performa-nya berlaku untuk beban kerja I/O-bound yang ditangani secara bersamaan.

Mengetahui cara *mempertahankannya* tetap cepat adalah keterampilan praktis yang sangat penting: menghindari kesalahan menghancurkan dengan menempatkan panggilan pemblokiran di `async def` (yang menserialisasi semua permintaan di belakang event loop yang beku), menggunakan perpustakaan async di endpoint async (atau `def` biasa untuk kode pemblokiran), memindahkan pekerjaan CPU, caching, mengoptimalkan database (sering kali bottleneck sesungguhnya), dan menjalankan beberapa pekerja untuk beberapa inti.

Kombinasi ini — memanfaatkan async dengan benar dan mengukur untuk menemukan bottleneck sesungguhnya — adalah apa yang memungkinkan Anda menyadari potensi performa FastAPI, menjadikannya pengetahuan tingkat senior yang penting untuk membangun API yang benar-benar cepat dan dapat diskalakan daripada yang terlihat async tetapi berkinerja seperti kode pemblokiran.