Kapan Anda harus menggunakan `async def` dibanding `def` untuk endpoint?

Question

Accepted Answer

FastAPI mendukung baik `async def` maupun `def` biasa untuk operasi path. Pilihan ini penting untuk performa: gunakan **`async def`** ketika Anda bisa `await` operasi I/O non-blokir, dan **`def`** biasa ketika kode Anda memanggil operasi blokir (synchronous).

## Dua bentuk

```python
@app.get("/async")
async def async_endpoint():
    data = await fetch_from_api()        # await non-blocking I/O — efficient
    return data

@app.get("/sync")
def sync_endpoint():
    data = blocking_db_call()             # ordinary blocking code
    return data
```

## Cara FastAPI menangani masing-masing

```text
async def → runs on the main event loop. Efficient ONLY if you await non-blocking calls.
            ⚠️ A BLOCKING call inside async def blocks the WHOLE event loop → kills concurrency!
def       → FastAPI runs it in a THREAD POOL, so blocking code doesn't block the event loop.
            Safe for synchronous/blocking libraries.
```

## Aturan pengambilan keputusan

```python
# ✅ async def — when you can await async libraries (httpx, async DB drivers)
async def get_user():
    async with httpx.AsyncClient() as c:
        return await c.get(url)

# ✅ plain def — when using SYNCHRONOUS/blocking libraries (requests, sync ORM)
def get_user():
    return requests.get(url).json()       # blocking → FastAPI runs it in a thread

# ❌ THE DANGEROUS MISTAKE — blocking call inside async def
async def bad():
    return requests.get(url).json()       # blocks the event loop! Use `def` or an async client
```

Aturan kritis: **jangan pernah letakkan panggilan blokir di `async def`** — itu memblokir event loop dan menghancurkan concurrency. Gunakan library async dengan `await`, atau gunakan `def` biasa (yang FastAPI jalankan dengan aman di thread pool).

## Mengapa ini penting

Memilih dengan benar antara `async def` dan `def` secara langsung memengaruhi performa dan concurrency API Anda, dan melakukannya dengan salah adalah kesalahan yang umum dan serius.

Wawasan kunci adalah bahwa **`async def` hanya menguntungkan ketika Anda `await` operasi non-blokir** — menempatkan panggilan blokir (seperti library `requests` yang synchronous atau driver database yang blokir) di dalam `async def` memblokir seluruh event loop, membekukan semua request concurrent, dan menghancurkan tujuan dari async.

Sebaliknya, FastAPI dengan cerdas menjalankan endpoint `def` biasa di thread pool, jadi kode synchronous/blokir aman di sana.

Memahami aturan ini — gunakan `async def` dengan library async yang sebenarnya, gunakan `def` biasa untuk kode blokir, dan jangan pernah campur panggilan blokir ke dalam `async def` — sangat penting untuk menulis endpoint FastAPI yang performan dan menghindari kesalahan halus namun menghancurkan dari secara tidak sengaja membuat serial semua request di belakang event loop yang terblokir.