Bagaimana dukungan async bekerja di Django modern?

Question

Accepted Answer

Django modern (3.1+) mendukung **async views** menggunakan `async`/`await` Python, memungkinkan penanganan efisien operasi konkuren **I/O-bound** (panggilan API eksternal, akses database async) tanpa pemblokiran. Ini melengkapi model sinkron tradisional Django untuk kasus penggunaan tertentu.

## Async views

```python
# a synchronous view (the traditional default)
def sync_view(request):
    data = requests.get("https://api.example.com").json()   # BLOCKS the worker
    return JsonResponse(data)

# an async view — can await I/O without blocking
import httpx
async def async_view(request):
    async with httpx.AsyncClient() as client:
        response = await client.get("https://api.example.com")   # non-blocking await
    return JsonResponse(response.json())
```

Sebuah view `async def` dapat `await` operasi I/O, membiarkan server menangani permintaan lain saat menunggu — efisien untuk views yang melakukan panggilan eksternal yang lambat.

## Concurrent I/O — manfaat utamanya

```python
import asyncio

async def dashboard(request):
    # run multiple slow API calls CONCURRENTLY instead of sequentially
    users, orders, stats = await asyncio.gather(
        fetch_users(),
        fetch_orders(),
        fetch_stats(),
    )
    # 3 calls taking 1s each → ~1s total (concurrent), not 3s (sequential)
    return JsonResponse({"users": users, "orders": orders, "stats": stats})
```

Keuntungan utama: menunggu beberapa operasi I/O independen **secara konkuren** (dengan `asyncio.gather`) — tumpang tindih waktu tunggu mereka untuk peningkatan besar ketika view mengagregasi data dari beberapa sumber yang lambat.

## Async ORM (Django modern)

```python
# async query methods (Django 4.1+)
async def get_articles(request):
    articles = [a async for a in Article.objects.all()]    # async iteration
    article = await Article.objects.aget(pk=1)              # async get
    await Article.objects.acreate(title="New")             # async create
    return JsonResponse({...})
```

Django sekarang menawarkan metode async ORM (`aget`, `acreate`, `async for`) sehingga Anda dapat melakukan akses database dalam async views tanpa pemblokiran.

## Peringatan penting dan kapan menggunakan async

```text
✓ USE async for: I/O-bound views with concurrent external calls, slow APIs,
  websockets/streaming, high-concurrency I/O workloads
✗ DON'T expect async to speed up CPU-bound work (it doesn't — that's not the point)
✗ Don't call SYNCHRONOUS blocking code directly in async views (blocks the event loop)
  → wrap it with sync_to_async; use async-compatible libraries (httpx, async ORM)
✗ Much of the Django ecosystem is still sync — mixing requires care (async_to_sync / sync_to_async)
Deployment: needs an ASGI server (uvicorn, daphne), not just WSGI
```

## Sync vs async bridging

```python
from asgiref.sync import sync_to_async, async_to_sync
result = await sync_to_async(blocking_function)()   # run sync code from async safely
```

## Mengapa ini penting

Dukungan async adalah kemampuan Django modern yang signifikan dan patut dipahami, meskipun aplikabilitasnya spesifik — memberikan manfaat nyata untuk **workload I/O-bound dengan concurrency tinggi** sambil bukan merupakan solusi universal.

Nilai kunci adalah pengaktifan I/O konkuren yang efisien: async views dapat `await` operasi lambat (panggilan API eksternal, query database async) tanpa memblokir worker, dan secara krusial dapat menjalankan beberapa operasi I/O independen **secara konkuren** (via `asyncio.gather`), tumpang tindih waktu tunggu mereka — peningkatan besar untuk views yang mengagregasi data dari beberapa sumber eksternal yang lambat, atau untuk skenario I/O concurrency tinggi seperti websockets dan streaming.

Memahami kapan async membantu (concurrency I/O-bound) versus kapan tidak (memberikan manfaat untuk pekerjaan CPU-bound) adalah penting untuk menggunakannya secara tepat daripada cargo-culting di mana-mana.

Sama pentingnya adalah **peringatan** yang membuat async rumit di Django: Anda harus menggunakan library yang kompatibel dengan async (httpx bukan requests, metode async ORM seperti `aget`/`acreate`) dan menghindari memanggil kode sinkron yang memblokir secara langsung dalam async views (yang memblokir event loop, mengalahkan tujuannya) — memerlukan bridging `sync_to_async`/`async_to_sync`, penanganan hati-hati mengingat sebagian besar ekosistem Django tetap sinkron, dan server ASGI untuk deployment.

Mengetahui async views ada, kasus penggunaan mereka yang genuine (concurrent I/O, fitur real-time), async ORM, dan pitfall penting mencerminkan kesadaran tentang evolusi Django modern dan penilaian untuk menerapkan async di mana benar-benar membantu.

Meskipun tidak diperlukan untuk setiap aplikasi (model sinkron Django tetap sepenuhnya cocok untuk sebagian besar), async semakin relevan untuk aplikasi yang berat I/O, high-concurrency, dan real-time, menjadikannya pengetahuan level senior yang berharga untuk memahami kemampuan Django saat ini dan memilih pendekatan concurrency yang tepat untuk workload tertentu.