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érification if product.stock < quantity passe (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 = 1 car 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 ?

  1. @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.
  2. select_for_update() : Empêche Bob de lire le stock tant qu'Alice n'a pas fini.
  3. models.F('stock') - quantity : Plutôt que de faire stock = 1 - 1 en 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 :

  1. Un décorateur de transaction.
  2. 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 du COMMIT.

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 :

  1. @transaction.atomic sur la méthode qui persiste les données.
  2. select_for_update() pour verrouiller la ressource critique.
  3. 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

me contacter

* champ obligatoire