Django : Pourquoi votre CreateView « simple » peut vendre du stock fantôme
Le piège du code qui marche... jusqu'au jour de l'affluence
Quand on débute avec les vues génériques de Django, on est émerveillé par leur simplicité. Une CreateView pour gérer une commande, quelques lignes de validation, et le tour est joué.
Regardons ce code qui semble parfaitement logique :
# forms.py
from django import forms
from .models import Order, Product
class OrderForm(forms.ModelForm):
class Meta:
model = Order
fields = ['product', 'quantity']
def clean(self):
cleaned_data = super().clean()
product = cleaned_data.get('product')
quantity = cleaned_data.get('quantity')
if product and quantity:
if product.stock < quantity:
raise forms.ValidationError(
f"Stock insuffisant. Disponible : {product.stock}"
)
return cleaned_data
# views.py
from django.views.generic.edit import CreateView
from .models import Order
from .forms import OrderForm
class OrderCreateView(CreateView):
model = Order
form_class = OrderForm
def form_valid(self, form):
# Le formulaire est déjà valide (stock vérifié)
product = form.cleaned_data['product']
quantity = form.cleaned_data['quantity']
# Calcul du total
form.instance.total = product.price * quantity
# Sauvegarde de la commande
response = super().form_valid(form)
# Mise à jour du stock
product.stock -= quantity
product.save()
return response
Ce code est clair, concis, et utilise proprement l'API de Django. Il fonctionne parfaitement en local.
Mais il est faillible. Gravement faillible.
Pourquoi ce code est dangereux en production ?
Le scénario catastrophe : La Race Condition
Imaginez un produit ultra-demandé (le dernier iPhone, une place de concert). Il ne reste qu'un seul exemplaire en stock.
- Alice (10h00m00.001s) : Son navigateur envoie la requête POST. Django lit
product.stock = 1. La vérificationif product.stock < quantitypasse (1 < 1 est faux, donc OK). - Bob (10h00m00.050s) : Son navigateur envoie la requête POST 50 millisecondes plus tard. Django lit aussi
product.stock = 1car Alice n'a pas encore fini de sauvegarder sa commande.
Résultat : - Alice obtient sa commande. Le stock passe à 0. - Bob obtient aussi sa commande. Le stock passe à -1.
Félicitations, vous venez de vendre deux fois le même produit unique.
Le problème technique : L'absence d'atomicité
Le code ci-dessus n'est pas atomique. Entre le moment où on lit le stock (if product.stock) et le moment où on le décrémente (product.save()), une autre requête peut s'intercaler.
C'est le problème classique du "Check-then-Act" en environnement concurrentiel.
La solution Django : Verrouillage et Transaction
Pour résoudre cela, Django met à notre disposition deux outils puissants qui doivent toujours être utilisés ensemble dans ce cas de figure.
Outil n°1 : Le décorateur @transaction.atomic
Il garantit que toutes les opérations de base de données à l'intérieur de la fonction réussissent ensemble ou échouent ensemble (principe du « Tout ou Rien »).
from django.db import transaction
@transaction.atomic
def form_valid(self, form):
# ...
# Si une exception est levée ici, RIEN n'est enregistré en base.
if product.stock < quantity:
raise ValidationError("Stock insuffisant (vérification finale)")
# ...
Outil n°2 : La méthode select_for_update()
C'est l'arme fatale contre les race conditions. Elle pose un verrou sur la ligne de la base de données SELECT ... FOR UPDATE.
Tant qu'Alice n'a pas fini sa transaction COMMIT, Bob attend à la porte.
Le code robuste : La CreateView « Alerte Rouge »
Voici comment transformer votre vue pour qu'elle soit digne d'un environnement à fort trafic.
from django.views.generic.edit import CreateView
from django.db import transaction, models
from django.core.exceptions import ValidationError
from django.http import JsonResponse
from .models import Order, Product
class OrderCreateView(CreateView):
model = Order
fields = ['product', 'quantity']
@transaction.atomic
def form_valid(self, form):
product_id = form.cleaned_data['product'].id
quantity = form.cleaned_data['quantity']
# 1. VERROUILLAGE : On recharge le produit en posant un verrou SQL
try:
product = Product.objects.select_for_update().get(pk=product_id)
except Product.DoesNotExist:
# Normalement géré par la validation du form, mais sécurité
raise ValidationError("Produit introuvable")
# 2. VALIDATION MÉTIER (sous verrou)
if product.stock < quantity:
# Le fait de lever une exception ici déclenche un ROLLBACK automatique
# grâce à @transaction.atomic
raise ValidationError("Stock insuffisant")
# 3. CALCUL
form.instance.total = product.price * quantity
# 4. SAUVEGARDE DE L'ORDER (Django gère le INSERT)
response = super().form_valid(form)
# 5. DÉCRÉMENTATION ATOMIQUE DU STOCK
# Utiliser F() évite de re-lire la valeur en mémoire Python.
# Le calcul se fait directement dans la base de données.
product.stock = models.F('stock') - quantity
product.save(update_fields=['stock'])
return response
Pourquoi ce code est-il meilleur ?
@transaction.atomic: Si la mise à jour du stock échoue pour X raison, la commande n'est pas créée. Impossible de se retrouver avec une commande orpheline.select_for_update(): Empêche Bob de lire le stock tant qu'Alice n'a pas fini.models.F('stock') - quantity: Plutôt que de fairestock = 1 - 1en Python (risque faible mais réel de recalcul erroné), on envoie à PostgreSQL :UPDATE product SET stock = stock - 1. C'est le SGBD qui fait le calcul, de manière totalement isolée.
L'alternative update_field
Si vous n'avez pas besoin de l'objet product après, vous pouvez même écrire :
Product.objects.filter(pk=product_id).update(stock=models.F('stock') - quantity)
Cela évite un SELECT supplémentaire pour le save().
La simplicité n'exclut pas la rigueur
Les vues génériques de Django sont un gain de temps phénoménal. Mais un CreateView qui touche à des ressources partagées (comme un stock) nécessite toujours ces deux garde-fous :
- Un décorateur de transaction.
- Un verrou
select_for_update().
En ajoutant ces deux éléments, vous passez d'un code « Démo » à un code « Production Ready ». Votre client ne vous appellera jamais pour vous dire "Pourquoi j'ai -1 en stock ?".
Le cas de Django REST Framework
Quand on utilise Django REST Framework, la tentation est grande de tout mettre dans le create() du Serializer et de faire confiance au framework. Mais les mêmes pièges de concurrence existent.
Voici comment blinder une API de commande avec DRF.
Le code naïf (et dangereux)
# serializers.py
from rest_framework import serializers
from .models import Order, Product
class OrderSerializer(serializers.ModelSerializer):
class Meta:
model = Order
fields = ['id', 'product', 'quantity', 'total']
read_only_fields = ['total']
def validate(self, data):
product = data['product']
quantity = data['quantity']
if product.stock < quantity:
raise serializers.ValidationError({
'quantity': 'Stock insuffisant'
})
return data
def create(self, validated_data):
product = validated_data['product']
quantity = validated_data['quantity']
validated_data['total'] = product.price * quantity
order = super().create(validated_data)
product.stock -= quantity
product.save()
return order
# views.py
from rest_framework.generics import CreateAPIView
from .serializers import OrderSerializer
class OrderCreateView(CreateAPIView):
serializer_class = OrderSerializer
Problème : Comme avec la CreateView standard, rien n'empêche deux requêtes simultanées de lire le même stock et de créer deux commandes pour un seul produit.
La solution DRF robuste
# serializers.py
from rest_framework import serializers
from django.db import transaction, models
from django.core.exceptions import ValidationError
from .models import Order, Product
class OrderSerializer(serializers.ModelSerializer):
class Meta:
model = Order
fields = ['id', 'product', 'quantity', 'total', 'created_at']
read_only_fields = ['id', 'total', 'created_at']
def validate(self, data):
"""
Validation préliminaire (sans verrou).
Permet de rejeter rapidement les requêtes manifestement invalides.
"""
product = data['product']
quantity = data['quantity']
# Vérification rapide (sera revérifiée sous verrou dans create())
if product.stock < quantity:
raise serializers.ValidationError({
'quantity': f'Stock insuffisant. Disponible : {product.stock}'
})
return data
@transaction.atomic
def create(self, validated_data):
"""
Création atomique de la commande avec verrouillage pessimiste.
"""
product = validated_data['product']
quantity = validated_data['quantity']
# 1. VERROUILLAGE : On recharge l'objet avec un verrou SQL
# Même si on l'a déjà dans validated_data, on le recharge
# pour poser le SELECT ... FOR UPDATE
try:
product_locked = Product.objects.select_for_update().get(pk=product.pk)
except Product.DoesNotExist:
raise serializers.ValidationError({
'product': 'Produit introuvable ou supprimé'
})
# 2. RE-VALIDATION sous verrou (car le stock a pu changer)
if product_locked.stock < quantity:
# L'exception déclenche un ROLLBACK automatique grâce à @transaction.atomic
raise serializers.ValidationError({
'quantity': f'Stock insuffisant (vérification finale). Disponible : {product_locked.stock}'
})
# 3. Calcul du total
validated_data['total'] = product_locked.price * quantity
# 4. Création de la commande (INSERT)
order = super().create(validated_data)
# 5. Décrémentation atomique du stock (UPDATE)
# Utilisation de F() pour que le calcul se fasse côté SGBD
product_locked.stock = models.F('stock') - quantity
product_locked.save(update_fields=['stock'])
return order
Et côté View, rien ne change (ou presque)
# views.py
from rest_framework.generics import CreateAPIView
from rest_framework.permissions import IsAuthenticated
from .serializers import OrderSerializer
from .models import Order
class OrderCreateAPIView(CreateAPIView):
"""
Crée une commande avec vérification de stock concurrentielle.
"""
queryset = Order.objects.all()
serializer_class = OrderSerializer
permission_classes = [IsAuthenticated]
# Optionnel : enrichir la réponse
def create(self, request, *args, **kwargs):
response = super().create(request, *args, **kwargs)
response.data['message'] = 'Commande créée avec succès'
return response
Pourquoi cette version DRF est-elle supérieure ?
Séparation des responsabilités :
validate(): Vérifications rapides, sans impact base de données.create(): Logique métier transactionnelle avec verrouillage.
Le décorateur @transaction.atomic sur create() :
Toute exception levée dans create() annule automatiquement :
- L'INSERT de la commande
- L'UPDATE du stock
Impossible d'avoir une commande sans déduction de stock, ou l'inverse.
Double validation :
# Dans validate() : vérification rapide (peut être dépassée)
if product.stock < quantity: ...
# Dans create() : re-vérification sous verrou
product_locked = Product.objects.select_for_update().get(pk=product.pk)
if product_locked.stock < quantity: ...
Pourquoi cette redondance ?
validate()évite de poser un verrou coûteux pour les requêtes manifestement invalides.create()garantit la cohérence finale au moment duCOMMIT.
models.F('stock') - quantity : l'update atomique :
# Mauvais (race condition potentielle entre le get et le save)
product.stock -= quantity
product.save()
# Bon (le SGBD fait le calcul en isolation totale)
product.stock = models.F('stock') - quantity
product.save()
La version avec F() génère exactement ce SQL :
UPDATE product SET stock = stock - 1 WHERE id = 42;
Même si 100 requêtes arrivent exactement en même temps, le stock final sera correct.
Bonus : Gestion fine des erreurs
Avec cette structure, DRF renverra automatiquement :
// Cas 1 : Stock insuffisant détecté dans validate()
{
"quantity": ["Stock insuffisant. Disponible : 0"]
}
// Cas 2 : Stock insuffisant détecté sous verrou (le dernier produit vient de partir)
{
"quantity": ["Stock insuffisant (vérification finale). Disponible : 0"]
}
// Cas 3 : Succès
{
"id": 123,
"product": 42,
"quantity": 1,
"total": "99.99",
"created_at": "2026-04-19T14:30:00Z",
"message": "Commande créée avec succès"
}
Avec Django REST Framework, la logique métier trouve naturellement sa place dans le Serializer, et plus précisément dans la méthode create() décorée de @transaction.atomic.
Les trois points forts d'une API de commande fiable :
@transaction.atomicsur la méthode qui persiste les données.select_for_update()pour verrouiller la ressource critique.models.F()pour les mises à jour atomiques.
Ces trois éléments ajoutent environ 6 lignes de code à votre projet, mais vous épargnent des nuits de debugging et des appels clients furieux. Un excellent retour sur investissement.
Publié le