Un projet Django avec Celery qui fonctionne en développement avec task_always_eager=True et un seul worker ne révèle presque aucun des problèmes qui apparaissent en production : tâches perdues au redémarrage du broker, tâches exécutées deux fois sans qu'aucune erreur ne soit visible dans les logs, workers tués par l'OOM-killer en plein traitement. La configuration par défaut de Celery est pensée pour le confort de développement, pas pour la fiabilité en production - et le passage de l'une à l'autre demande des choix explicites, pas juste CELERY_BROKER_URL pointé vers Redis.

Pourquoi la configuration par défaut échoue en prod

Le comportement par défaut de Celery acquitte une tâche (ack) avant de l'exécuter, dès qu'elle est reçue par le worker (task_acks_late = False). Si le worker crashe pendant l'exécution - OOM, kill -9, coupure réseau vers le broker - la tâche est perdue définitivement, puisque le broker la considère déjà comme traitée. C'est un choix raisonnable pour des tâches non critiques et rapides, mais inacceptable pour l'envoi d'un email de confirmation de paiement ou la génération d'une facture.

# settings.py - configuration orientée fiabilité plutôt que débit brut
CELERY_TASK_ACKS_LATE = True
CELERY_WORKER_PREFETCH_MULTIPLIER = 1
CELERY_TASK_REJECT_ON_WORKER_LOST = True

CELERY_BROKER_TRANSPORT_OPTIONS = {
    # Doit être supérieur à la durée maximale attendue d'une tâche,
    # sinon Redis redistribue la tâche à un autre worker alors
    # qu'elle est encore en cours d'exécution ailleurs
    'visibility_timeout': 3600,
}

task_acks_late = True inverse la logique : l'acquittement n'a lieu qu'après succès, donc une tâche interrompue par un crash de worker est automatiquement redistribuée. Le corollaire obligatoire est que worker_prefetch_multiplier doit être abaissé à 1 - sinon un worker peut avoir réservé plusieurs tâches en mémoire sans les avoir acquittées, et toutes repartent en cas de crash, pas seulement celle en cours.

Idempotence et retries : la contrepartie obligatoire

acks_late élimine la perte de tâches mais introduit la possibilité qu'une tâche s'exécute deux fois - un worker qui termine le traitement juste au moment où le broker le considère comme perdu (timeout réseau transitoire, par exemple) peut voir la même tâche redistribuée et exécutée par un second worker. Sans idempotence, c'est le même risque de double effet de bord que pour n'importe quel système de retry.

from celery import shared_task
from django.db import transaction

@shared_task(
    bind=True,
    autoretry_for=(ConnectionError, TimeoutError),
    retry_backoff=10,
    retry_backoff_max=300,
    retry_jitter=True,
    max_retries=5,
)
def send_invoice_notification(self, invoice_id, idempotency_key):
    with transaction.atomic():
        invoice = Invoice.objects.select_for_update().get(id=invoice_id)

        if invoice.notification_sent_at is not None:
            # Déjà traité par une exécution précédente, même en cas de double livraison
            return

        notification_service.send(invoice, idempotency_key=idempotency_key)
        invoice.notification_sent_at = timezone.now()
        invoice.save(update_fields=['notification_sent_at'])

Le select_for_update() associé à la vérification de l'état déjà persisté est ce qui rend la tâche réellement sûre à rejouer, indépendamment du mécanisme de retry de Celery lui-même.

Diagnostiquer en production

Trois outils complémentaires, à utiliser avant de supposer qu'un comportement anormal est un bug de code :

# Surveiller la profondeur de la file en temps réel (broker Redis)
redis-cli -h redis-host llen celery

# Flower donne une vue temps réel des tâches en cours, retries et échecs
celery -A myproject flower --port=5555

Les logs de worker révélant des WorkerLostError indiquent presque toujours un worker tué brutalement (OOM-killer du système, le plus souvent) plutôt qu'une exception applicative - un signal qu'il faut corréler avec les métriques mémoire du système, pas uniquement avec les logs Celery. Une file qui grossit en continu sans jamais se vider indique généralement que le débit de production de tâches dépasse la capacité de traitement des workers actuellement déployés, pas une tâche bloquée isolée.

Le pattern dead letter : Celery ne le fournit pas nativement

Contrairement à des systèmes comme SQS ou RabbitMQ configuré nativement avec une dead letter exchange, Celery n'a pas de file d'échec intégrée par défaut. Une tâche qui épuise ses tentatives de retry est simplement marquée FAILURE et disparaît du radar si personne ne l'observe explicitement.

from celery.signals import task_failure

@task_failure.connect
def handle_task_failure(sender=None, task_id=None, exception=None, **kwargs):
    FailedTask.objects.create(
        task_name=sender.name,
        task_id=task_id,
        exception=str(exception),
        payload=kwargs.get('kwargs', {}),
    )

Ce signal transforme les échecs définitifs en enregistrements persistés et interrogeables - l'équivalent fonctionnel d'une dead letter queue, construit manuellement parce que Celery ne l'offre pas de façon native. Sans ce genre de mécanisme explicite, une tâche métier critique qui échoue en boucle peut passer totalement inaperçue jusqu'à ce qu'un client s'en plaigne.

Le correctif, avec ses compromis

acks_late et prefetch_multiplier=1 améliorent la fiabilité au prix du débit : chaque worker ne traite plus qu'une tâche à la fois avant d'en réserver une nouvelle, ce qui réduit le parallélisme effectif sur des tâches très courtes. Séparer les tâches par file dédiée (celery -A myproject worker -Q payments pour les tâches critiques, une file distincte pour les tâches de reporting non urgentes) isole les tâches lentes des tâches rapides, évitant qu'un traitement de rapport volumineux ne bloque l'envoi d'emails transactionnels derrière lui dans la même file.

# Workers dédiés par file, pour isoler les tâches critiques des tâches de fond
celery -A myproject worker -Q payments --concurrency=4 -n payments@%h
celery -A myproject worker -Q reports --concurrency=2 -n reports@%h

Quand le correctif facile ne suffit pas

Pour une tâche réellement longue (export volumineux, traitement vidéo), acks_late seul ne suffit pas : si le worker est tué en plein traitement, la tâche entière redémarre de zéro plutôt que de reprendre où elle s'était arrêtée. La bonne réponse est de découper la tâche en étapes idempotentes avec un point de contrôle persisté (progression sauvegardée en base), plutôt que de compter sur Celery pour gérer une tâche monolithique de plusieurs dizaines de minutes.

Un autre piège spécifique à Django concerne celery beat : en cas de déploiement avec plusieurs instances de beat actives simultanément (souvent involontaire lors d'un déploiement rolling), les tâches planifiées s'exécutent en double à chaque intervalle. La solution n'est pas un simple retry ou une idempotence côté tâche, mais un verrou distribué explicite entre instances de beat (par exemple via redbeat, qui utilise Redis comme source unique de vérité pour le planning) garantissant qu'une seule instance déclenche réellement chaque tâche planifiée.

Enfin, le choix du broker a des implications de durabilité qui dépassent la configuration Celery elle-même : Redis sans persistance (appendonly no) peut perdre des tâches en file lors d'un redémarrage brutal du processus Redis, alors que RabbitMQ avec des files durables et des messages persistants survit à un redémarrage du broker. Ce choix se décide en amont, au niveau infrastructure, pas en ajustant les options Celery.

Limiter le temps d'exécution avec soft_time_limit

Une tâche qui boucle indéfiniment (dépendance externe qui ne répond jamais, boucle de pagination mal bornée) bloque un worker sans jamais déclencher de retry, puisqu'aucune exception n'est levée. acks_late ne protège pas contre ce cas : le worker reste simplement occupé indéfiniment, sans jamais acquitter ni échouer la tâche.

@shared_task(
    bind=True,
    soft_time_limit=300,  # lève SoftTimeLimitExceeded, récupérable dans le code
    time_limit=330,       # tue le worker si la tâche ignore le soft limit
)
def generate_monthly_report(self, account_id):
    try:
        return report_service.build(account_id)
    except SoftTimeLimitExceeded:
        # Point de sortie propre : logguer l'état partiel plutôt
        # que de laisser le worker se faire tuer sans contexte
        logger.warning('Report generation exceeded soft limit', extra={'account_id': account_id})
        raise

Le time_limit dur agit comme filet de sécurité final : si le code ignore ou intercepte mal le SoftTimeLimitExceeded, Celery force l'arrêt du worker après le délai supplémentaire configuré. Le compromis est qu'un time_limit trop bas sur une tâche légitimement longue (export volumineux un jour de forte charge) la tue à tort - la valeur doit être calibrée sur la durée réellement observée en production, pas sur une estimation optimiste mesurée en développement avec un jeu de données réduit.

À retenir

La fiabilité de Celery en production se construit à trois niveaux simultanés : un acquittement tardif combiné à de l'idempotence côté tâche pour survivre aux crashs de worker, une stratégie de dead letter explicite puisque Celery ne l'offre pas nativement, et un choix de broker et de topologie de files qui correspond réellement aux garanties de durabilité attendues par le métier.