TechPills per tutti: Inizia a creare API REST con Django REST Framework

Django REST Framework (DRF) è uno degli strumenti più potenti e flessibili per creare API RESTful in Python. Questo articolo ti guiderà passo dopo passo nella creazione del tuo primo endpoint API, illustrando l’uso di serializers, views e URL routing.

Abbiamo visto nel mio articolo precedente come strutturare il primo progetto Django, se non l’hai visto clicca qui, perchè si parte proprio da dove ci siamo lasciati.

Recommended article

Maggio 7, 2025

Evitare la duplicazione del codice sfruttando le high-order function in JavaScript

Fabrizio Tedeschi

Backend

Obiettivi

• Comprendere il ruolo di Django REST Framework e perché è utile.
• Creare un semplice endpoint API per la gestione di risorse.
• Eseguire richieste GET e POST per leggere e scrivere dati.

Quindi, se hai seguito il mio precedente articolo su Django, hai già un progetto Django configurato. Ora vediamo come esporre i dati attraverso un’API.

Django REST Framework (DRF) è un framework open source che estende Django per la costruzione di API web basate su architettura REST. Fornisce un set completo di strumenti per:

• Serializzazione avanzata: converte istanze di modelli Django in formati (JSON, XML) utilizzabili dalle applicazioni client e viceversa, garantendo validazione dei dati e gestione personalizzata dei campi.
• View classes e ViewSets: classi generiche (es. ListCreateAPIView, RetrieveUpdateDestroyAPIView) e ViewSets per gestire le operazioni CRUD minimizzando il codice boilerplate.
• Routing intelligente: Routers automatici che associano in modo dinamico ViewSets alle rotte URL, semplificando la definizione degli endpoint.
• Autenticazione e autorizzazione: supporto nativo per metodi di autenticazione (SessionAuth, TokenAuth, JWT) e classi di permission per controllare l’accesso alle risorse.
• Throttling, Filtering e Pagination: meccanismi integrati per limitare le richieste, filtrare i risultati e suddividere le risposte in pagine.
• Browsable API: interfaccia HTML interattiva per esplorare e testare gli endpoint durante lo sviluppo.

Ha un workflow abbastanza intuitivo diviso in serializers, views e routers:
I serializer gestiscono la conversione tra oggetti Python (tipicamente istanze dei modelli Django) e rappresentazioni serializzate (JSON, XML).

Le view di DRF processano le richieste HTTP e restituiscono le risposte serializzate. DRF offre classi generiche (GenericAPIView, ListAPIView, CreateAPIView, ecc.) per operazioni comuni. I ViewSet aggregano più azioni (list, create, retrieve, update, destroy) in un’unica classe, lavorando in sinergia con i Routers per ridurre ulteriormente il codice.

I Routers collegano automaticamente le azioni dei ViewSet a pattern URL. Ad esempio, utilizzando DefaultRouter si ottengono endpoint come /notes/ per list/create e /notes/{pk}/ per retrieve/update/delete, senza dover scrivere manualmente ogni URL.

Preparazione dell’ambiente

Installazione

Assicurati di avere Django installato e poi aggiungi Django REST Framework:

pip install djangorestframework

Aggiungilo alle app installate in settings.py:

INSTALLED_APPS = [

    ...

    'rest_framework',
]Code language: JavaScript (javascript)

Creazione del modello

Definiamo un modello semplice per una nota:

from django.db import models

class Note(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

Dopo aver definito il modello, applica le migrazioni:

python manage.py makemigrations

python manage.py migrateCode language: CSS (css)

Creazione del Serializer

Creiamo un file all’interno della directory della nostra app e lo chiamiamo serializers.py

I serializer convertono i dati del database in formato JSON:

from rest_framework import serializers
from .models import Note

class NoteSerializer(serializers.ModelSerializer):

    class Meta:
        model = Note
        fields = '__all__'

Creazione della View

Apriamo il file views.py, cancelliamo tutto il codice al suo interno.

Usiamo una ListCreateAPIView, che permette di ottenere la lista degli elementi (GET) e di crearne di nuovi (POST):

from rest_framework import generics
from .models import Note
from .serializers import NoteSerializer

class NoteListCreateView(generics.ListCreateAPIView):
    queryset = Note.objects.all()
    serializer_class = NoteSerializer

Configurazione degli URL

Aggiungiamo un URL per la nostra API, quindi apriamo il file urls.py all’interno della nostra app:

from django.urls import path
from .views import NoteListCreateView

urlpatterns = [
    path('notes/', NoteListCreateView.as_view(), name='note-list-create'),
]Code language: JavaScript (javascript)

Nel file urls.py principale del progetto:

from django.urls import path, include

urlpatterns = [
    path('api/', include('nome_app.urls')),
]Code language: JavaScript (javascript)

La Browsable API di Django REST Framework

Django REST Framework include una Browsable API integrata che permette di esplorare e interagire con i tuoi endpoint direttamente dal browser, senza dover ricorrere ad altri strumenti come Postman o curl. È una vera interfaccia utente HTML dinamica che:

• Visualizza le risorse: elenca i campi disponibili, i relativi tipi e i valori correnti, in modo chiaro e leggibile.
  
• Supporta le operazioni CRUD: fornisce automaticamente form per inviare richieste GET, POST, PUT e DELETE, compilando i campi in base al serializer.
  
• Gestisce l’autenticazione: permette di autenticarsi via sessione o token direttamente dall’interfaccia, nascondendo o mostrando i link a seconda dei permessi.
  
• Mostra gli errori: evidenzia gli errori di validazione con messaggi dettagliati accanto ai campi, facilitando il debug.
  

Per abilitarla non serve alcuna configurazione aggiuntiva: basta includere ‘rest_framework’ in INSTALLED_APPS e accedere all’URL nel browser (es. http://127.0.0.1:8000/api/notes/). La Browsable API è particolarmente utile in fase di sviluppo, perché consente di testare rapidamente gli endpoint, verificare il formato dei dati e comprendere la struttura delle risposte JSON in maniera visuale.

Testing dell’API

Possiamo testare il nostro endpoint con strumenti come curl o Postman, oppure utilizzando la browsable api inclusa in django rest framework.

Quindi apriamo il terminale e scriviamo:

python manage.py runserverCode language: CSS (css)

Esempio di richiesta GET:

curl http://127.0.0.1:8000/api/notes/Code language: JavaScript (javascript)

Esempio di richiesta POST:

curl -X POST -H "Content-Type: application/json" -d '{"title": "Test", "content": "Contenuto della nota"}' http://127.0.0.1:8000/api/notes/Code language: JavaScript (javascript)

oppure utilizzando la browsable api:

Se tutto funziona correttamente, dovresti vedere i dati restituiti in formato JSON.

Best Practices

Gestione degli errori

DRF gestisce automaticamente gli errori comuni, ma possiamo personalizzare i messaggi di errore se necessario.

Sicurezza

Per proteggere l’API, si possono implementare autenticazione e autorizzazione con i meccanismi offerti da DRF, come Token Authentication o JWT.

Modularità

Per progetti più complessi, DRF offre ViewSets e Routers che semplificano la gestione delle API.

Prossimi Passi

Abbiamo visto come creare un’API REST semplice con Django REST Framework, includendo:

• Definizione di un modello,
• Creazione di un serializer,
• Implementazione di una view,
• Configurazione degli URL,
• Test dell’API con GET e POST.

Prossimi approfondimenti

• Implementazione di autenticazione con DRF.
• Uso di ViewSets e Routers per API più strutturate.
• Deployment dell’API su un server di produzione.

Adesso sei pronto per sviluppare API più complesse.

Happy Coding!