Structure avec Django

Django REST Framework (DRF) est une extension puissante de Django qui permet de créer des APIs web robustes et maintenables.
Contrairement à Flask ou FastAPI, Django propose une architecture plus imposante, avec un système intégré de modèles, vues, serializers et routes.

DRF est idéal lorsque l’on souhaite construire une API complexe, avec :

• Gestion automatique des utilisateurs et permissions

• Relations entre modèles

• Pagination, filtres et authentification avancée

• Documentation semi-automatique des endpoints

Projet et applications Django

Django repose sur une organisation en projets et applications :

• Projet Django : conteneur global, gère la configuration globale (settings, URLs, WSGI/ASGI)

• Applications Django : modules fonctionnels indépendants qui contiennent la logique métier (ex. users, products, predictions)

Chaque application contient :

• models.py : définition des structures de données (tables)

• views.py : logique métier exposée via endpoints

• serializers.py : conversion entre objets Python et JSON pour l’API

• urls.py : routes spécifiques à l’application

Pourquoi cette structure est utile :

• Modularité et isolation des fonctionnalités

• Possibilité de réutiliser des applications dans d’autres projets

• Facilite le développement en équipe et la maintenabilité

Point d’entrée : urls.py et settings.py

Le point d’entrée d’une API Django est le fichier urls.py du projet :

• Il redirige les requêtes vers les URLs des applications

• Permet de centraliser la gestion des routes

• Intégré au serveur Django (via WSGI ou ASGI)

Le fichier settings.py contient :

• Configuration des bases de données

• Paramètres de sécurité (SECRET_KEY, CORS, DEBUG)

• Applications installées (INSTALLED_APPS)

• Paramètres liés à DRF (pagination, authentification, permissions)

Pourquoi c’est important : centraliser la configuration permet d’éviter la duplication et d’adapter facilement l’API à différents environnements (dev, test, prod).

Modèles (models.py)

Dans Django, les models représentent les tables de la base de données :

• Chaque classe hérite de models.Model

• Les attributs de la classe correspondent aux colonnes de la table

• Relations possibles : ForeignKey, ManyToManyField, OneToOneField

Pourquoi c’est crucial :

• DRF se base sur les modèles pour générer automatiquement les serializers et vues

• La structure des données est centralisée et validée dès la base

• Les migrations gèrent l’évolution de la base sans perte de données

Serializers

Les serializers convertissent les objets Python (instances de modèles) en JSON et inversement :

• Définissent les champs visibles ou modifiables

• Gèrent la validation des données entrantes

• Permettent la sérialisation imbriquée pour les relations complexes

Pourquoi :

• Sécurise l’API contre les données invalides

• Facilite la communication entre backend et frontend

• Simplifie la transformation des données complexes pour les modèles ML ou applications web

Vues et ViewSets

Les vues (views) sont responsables de la logique métier exposée à l’API.

DRF propose deux approches :

1. APIView : équivalent à Flask/FastAPI, permet de gérer manuellement chaque méthode HTTP

2. ViewSet : simplifie la création d’API CRUD en générant automatiquement les méthodes GET, POST, PUT, DELETE

Pourquoi :

• Les ViewSets réduisent le code répétitif

• Ils fonctionnent avec les routers pour générer automatiquement les URLs

• Permettent une maintenance facile et une extension rapide de l’API

Routers et urls.py

DRF utilise les routers pour connecter les ViewSets aux URLs :

• Un router prend un ViewSet et génère les endpoints REST standard

• Permet de garder urls.py minimal et lisible

Exemple de logique :

• /api/users/ → ViewSet gérant les utilisateurs

• /api/products/ → ViewSet gérant les produits

Pourquoi :

• Centralise la gestion des routes

• Réduit le risque d’erreurs manuelles dans les URLs

• Rend l’API cohérente et prévisible pour les développeurs frontend ou les clients externes

Permissions, authentification et middleware

DRF permet de gérer la sécurité et les accès de manière fine :

• Permissions globales ou par endpoint (ex. IsAuthenticated, IsAdminUser)

• Authentification via token, JWT ou OAuth2

• Middlewares pour le logging, le CORS, la compression ou le suivi des erreurs

Pourquoi :

• Assure que seules les personnes autorisées accèdent aux endpoints

• Sépare la logique métier de la sécurité

• Facilite la mise en production sur des environnements sensibles

Tests et validation

DRF est conçu pour être testable facilement :

• APITestCase et APIClient permettent de tester les endpoints

• Tests unitaires pour la logique métier et les serializers

• Tests fonctionnels pour vérifier l’ensemble des flux API

Pourquoi :

• Garantit la robustesse de l’API

• Détecte les erreurs avant le déploiement

• Permet d’intégrer facilement le CI/CD dans le cycle de développement

Documentation automatique

Django REST Framework propose la documentation intégrée :

• Swagger ou Redoc peuvent être activés automatiquement

• Les serializers et ViewSets renseignent les types de champs, la validation et les endpoints disponibles

Pourquoi c’est crucial :

• Facilite la collaboration avec les clients ou développeurs frontend

• Réduit le risque d’erreurs dans l’utilisation de l’API

• Permet une intégration rapide dans des applications externes

Conclusion

Structurer une API Django avec DRF implique :

• Organiser le projet en applications modulaires

• Centraliser la configuration dans settings.py

• Définir clairement les models, serializers et views

• Utiliser les ViewSets et routers pour une API cohérente et maintenable

• Séparer la logique métier, les permissions et la validation des données

• Mettre en place des tests automatisés et une documentation complète

En respectant cette structure, vous obtenez une API robuste, évolutive et prête pour la production, parfaitement adaptée aux projets complexes et aux intégrations front/back modernes.