Django moderno (3.1+) supporta viste asincrone usando async/await di Python, permettendo la gestione efficiente di operazioni I/O-bound concorrenti (chiamate API esterne, accesso async al database) senza blocchi. Ciò completa il modello sincronizzato tradizionale di Django per casi d'uso specifici.
# 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())
Una vista async def può await operazioni I/O, consentendo al server di gestire altre richieste mentre aspetta — efficiente per viste che effettuano chiamate esterne lente.
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})
Il vantaggio principale: attendere più operazioni I/O indipendenti concorrentemente (con asyncio.gather) — sovrapponendo i loro tempi di attesa per un grande miglioramento di velocità quando una vista aggrega dati da diverse fonti lente.
# 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 offre ora metodi ORM async (aget, acreate, async for) in modo da poter accedere al database all'interno di viste async senza blocchi.
✓ 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
from asgiref.sync import sync_to_async, async_to_sync
result = await sync_to_async(blocking_function)() # run sync code from async safely
Il supporto async è una capacità significativa di Django moderno che vale la pena comprendere, anche se la sua applicabilità è specifica — fornisce benefici reali per carichi di lavoro I/O-bound ad alta concorrenza pur non essendo una soluzione universale.
Il valore chiave è l'abilitazione dell'I/O concorrente efficiente: le viste async possono await operazioni lente (chiamate API esterne, query async al database) senza bloccare il worker, e crucialmente possono eseguire più operazioni I/O indipendenti concorrentemente (tramite asyncio.gather), sovrapponendo i loro tempi di attesa — un grande miglioramento di velocità per viste che aggregano dati da diverse fonti esterne lente, o per scenari I/O ad alta concorrenza come websocket e streaming.
Comprendere quando async aiuta (concorrenza I/O-bound) rispetto a quando non aiuta (non fornisce vantaggi per il lavoro CPU-bound) è essenziale per usarlo appropriatamente piuttosto che cargo-cult ovunque.
Equalmente importante sono le avvertenze che rendono async complicato in Django: devi usare librerie compatibili con async (httpx invece di requests, i metodi ORM async come aget/acreate) ed evitare di chiamare direttamente codice sincronizzato bloccante in viste async (che blocca l'event loop, vanificando lo scopo) — richiedendo bridging sync_to_async/async_to_sync, gestione attenta dato che gran parte dell'ecosistema Django rimane sincrono, e un server ASGI per il deployment.
Sapere che le viste async esistono, i loro casi d'uso genuini (I/O concorrente, funzionalità real-time), l'ORM async, e le importanti insidie riflette consapevolezza dell'evoluzione di Django moderno e il giudizio di applicare async dove aiuta veramente.
Sebbene non necessario per ogni applicazione (il modello sincrono di Django rimane perfettamente adatto per la maggior parte), async è sempre più rilevante per applicazioni I/O-heavy, ad alta concorrenza e real-time, rendendolo preziosa conoscenza a livello senior per comprendere le capacità attuali di Django e scegliere l'approccio di concorrenza giusto per un dato carico di lavoro.
Una raccolta di domande di colloquio IT con risposte dettagliate — da Junior a Senior.
Dona