Utilizzo di Django con API REST

LT
Luca Terribili
Autore

Partiremo dalla configurazione iniziale dell’ambiente, passando per la creazione di un’applicazione dedicata alle API, fino all’implementazione di serializer e router. Successivamente mostreremo come strutturare le view con i classici endpoint CRUD, come proteggere le risorse con permessi e meccanismi di autenticazione, e come verificare il corretto funzionamento usando strumenti come Postman o curl. Concluderemo con un esempio pratico di gestione di una libreria di libri, fornendo risorse per approfondire l’argomento.

L’obiettivo è fornire una panoramica completa ma concisa, in modo che chiunque abbia già dimestichezza con Django possa rapidamente aggiungere al proprio progetto funzionalità RESTful, mantenendo un codice pulito e facilmente estendibile.

Cos’è Django e perché utilizzarlo con API REST

Django è un framework open‑source scritto in Python, noto per la rapidità di sviluppo e per il suo ORM che semplifica l’interazione con il database. Integrarlo con le API REST permette di esporre i dati dell’applicazione attraverso richieste HTTP, rendendo le funzionalità disponibili a client esterni, come app mobile o altri servizi web.

Il pacchetto Django REST Framework (DRF) aggiunge un set di strumenti specifici per costruire API: view, serializer e router pronti all’uso, riducendo drasticamente la quantità di codice necessario. Grazie a DRF, è possibile creare endpoint conformi alle migliori pratiche REST senza dover riscrivere logica di serializzazione o gestione delle risposte.

Questa combinazione consente di realizzare applicazioni complete, modulabili e pronte per l’integrazione, mantenendo al contempo la leggibilità e la manutenzione del codice.

Configurazione di un progetto Django per l’utilizzo con API REST

  1. Installazione dei pacchetti

pip install Django djangorestframework

  • Creazione del progetto e dell’applicazione

    • django-admin startproject myproject
cd myproject
python manage.py startapp myapp

  • Registrazione di DRF Aggiungi 'rest_framework' e la tua app alla lista INSTALLED_APPS in settings.py.

  • Definizione del modello (esempio di libro)

    • # myapp/models.py
from django.db import models

class Book(models.Model):
   title = models.CharField(max_length=200)
   author = models.CharField(max_length=100)
   publication_date = models.DateField()

  • Creazione del serializer

    • # myapp/serializers.py
from rest_framework import serializers
from .models import Book

class BookSerializer(serializers.ModelSerializer):
   class Meta:
       model = Book
       fields = ['id', 'title', 'author', 'publication_date']

  • Implementazione della viewset

    • # myapp/views.py
from rest_framework import viewsets
from .models import Book
from .serializers import BookSerializer

class BookViewSet(viewsets.ModelViewSet):
   queryset = Book.objects.all()
   serializer_class = BookSerializer

  • Configurazione delle rotte

    • # myapp/urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import BookViewSet

router = DefaultRouter()
router.register(r'books', BookViewSet)

urlpatterns = [
   path('', include(router.urls)),
]

    Con questi passaggi il progetto è pronto a gestire le operazioni CRUD sui libri tramite endpoint http://localhost:8000/books/.

    Creazione di modelli e view per le API REST

    Creazione dei modelli

    Il modello rappresenta la struttura dei dati. Dopo aver definito la classe Book (come mostrato sopra) è necessario creare le migrazioni e applicarle:

    python manage.py makemigrations
python manage.py migrate

    Creazione delle view

    Le view di DRF, in particolare i ViewSet, automatizzano le operazioni CRUD. Se si preferisce una view basata su funzioni, è possibile usare i decoratori @api_view e @permission_classes:

    ## myapp/views.py (funzione alternativa)
from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from .models import Book
from .serializers import BookSerializer

@api_view(['GET', 'POST'])
@permission_classes([IsAuthenticated])
def book_list(request):
    if request.method == 'GET':
        books = Book.objects.all()
        serializer = BookSerializer(books, many=True)
        return Response(serializer.data)

    serializer = BookSerializer(data=request.data)
    if serializer.is_valid():
        serializer.save()
        return Response(serializer.data, status=201)
    return Response(serializer.errors, status=400)

    Entrambe le soluzioni possono coesistere; il router registrerà i ViewSet mentre le view basate su funzioni possono essere collegate manualmente alle URL.

    Implementazione di metodi HTTP e autenticazione

    DRF gestisce automaticamente i metodi HTTP fondamentali (GET, POST, PUT, PATCH, DELETE) quando si utilizza un ModelViewSet. Per personalizzare il comportamento è sufficiente sovrascrivere i metodi corrispondenti nella viewset.

    L’autenticazione può essere impostata globalmente in settings.py oppure a livello di vista mediante i decoratori. Esempio di configurazione globale:

    ## settings.py
REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.BasicAuthentication',
        'rest_framework.authentication.SessionAuthentication',
    ],
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticated',
    ],
}

    Se si desidera applicare l’autenticazione solo a una vista specifica:

    from rest_framework.authentication import BasicAuthentication
from rest_framework.permissions import IsAuthenticated
from rest_framework.decorators import authentication_classes

@api_view(['GET'])
@authentication_classes([BasicAuthentication])
@permission_classes([IsAuthenticated])
def user_detail(request, pk):
    # logica della vista
    ...

    In questo modo le API rimangono sicure, consentendo l’accesso solo a utenti autenticati.

    Test delle API REST e risoluzione dei problemi

    Per verificare il corretto funzionamento delle API è consigliato utilizzare Postman, Insomnia o curl. Un tipico test di endpoint books con curl:

    curl -u username:password http://localhost:8000/books/

    Se si riscontrano errori, i primi step sono:

    1. Controllare i log di Django (python manage.py runserver) per messaggi di eccezione.
    2. Verificare le impostazioni di autenticazione e permessi.
    3. Utilizzare il pannello di amministrazione (/admin/) per ispezionare i dati nel database.

    Quando si modificano query o logica di serializzazione, è buona pratica eseguire nuovamente i test per assicurarsi che il problema sia stato risolto.

    Esempi pratici di utilizzo di Django con API REST

    Immaginiamo di gestire una libreria digitale. Dopo aver creato il modello Book, il serializer BookSerializer e il BookViewSet, le rotte sono disponibili all’indirizzo /books/.

    Per aggiungere funzionalità di ricerca per titolo, è sufficiente estendere il queryset nella viewset:

    class BookViewSet(viewsets.ModelViewSet):
    serializer_class = BookSerializer

    def get_queryset(self):
        qs = Book.objects.all()
        title = self.request.query_params.get('title')
        if title:
            qs = qs.filter(title__icontains=title)
        return qs

    Ora, una chiamata GET /books/?title=django restituisce solo i libri il cui titolo contiene la parola “django”.

    Questo esempio mostra come, con poche righe di codice, DRF permette di arricchire le API con filtri, paginazione e altre funzionalità avanzate, mantenendo al contempo una struttura leggibile.

    Approfondire l’utilizzo di Django con API REST

    Per approfondire, visita la documentazione ufficiale di Django (https://www.djangoproject.com/) e quella di Django REST Framework (https://www.django-rest-framework.org/). Entrambe le risorse offrono guide, tutorial e best practice per sfruttare al meglio le potenzialità del framework.

    Ricorda che la pratica è fondamentale: crea piccoli progetti, sperimenta nuove configurazioni, e partecipa alle community (Stack Overflow, forum Django) per confrontarti con altri sviluppatori. Con Django e le API REST a disposizione, avrai a disposizione una base solida per costruire applicazioni web moderne, scalabili e integrate. Buon lavoro!

    ← Precedente
    Successivo →