← points de vue
25 janvier 2022

Celery et FastAPI : rendre la main avant d’avoir fait le travail

Un serveur qui traite une image pendant la requête finit par tomber en panne. Séparer l’accusé de réception du traitement change la nature de la panne, et fait apparaître trois questions que le mode synchrone masquait.

Le besoin était banal : recevoir des photos de tickets de caisse, en extraire les lignes, renvoyer un résultat exploitable. Le premier prototype faisait tout dans la requête. Il a fonctionné tant que les images étaient petites et le trafic faible, c’est-à-dire jusqu’à la mise en service. Une extraction prend plusieurs secondes, une requête HTTP de plusieurs secondes occupe un processus de travail, et une centaine d’envois simultanés suffisent pour que le serveur cesse de répondre, y compris aux requêtes légères.

FastAPI propose `BackgroundTasks`, et c’est le piège le plus tentant. La tâche démarre bien après la réponse, mais dans le même processus. Elle partage le processeur avec les requêtes en cours, et si le processus s’arrête (déploiement, redémarrage, manque de mémoire), le travail est perdu sans laisser de trace. C’est acceptable pour envoyer un courriel, pas pour un traitement promis à un utilisateur.

01Deux processus, une file

Le serveur accepte la demande, dépose un message et répond aussitôt. Un processus de travail séparé consomme la file. Une règle est presque toujours oubliée la première fois : **l’image ne passe pas par la file**. Un courtier de messages transporte des instructions, pas des mégaoctets. On écrit l’image dans un stockage objet et on ne transmet que sa clé.

python
from celery import Celery
from fastapi import FastAPI, UploadFile
from fastapi.responses import JSONResponse

celery = Celery("receipts", broker="redis://redis:6379/0", backend="redis://redis:6379/1")
api = FastAPI()

@api.post("/receipts", status_code=202)
async def submit(upload: UploadFile) -> JSONResponse:
    # The image goes to object storage; the queue only ever gets a key.
    key = await store(upload)
    task = extract.delay(key)
    # 202 and not 200: the request is accepted, it is not fulfilled.
    return JSONResponse({"id": task.id}, status_code=202)

@api.get("/receipts/{task_id}")
def status(task_id: str) -> dict:
    r = celery.AsyncResult(task_id)
    return {"state": r.state, "result": r.result if r.successful() else None}
02Les trois réglages qui décident de tout

Les valeurs par défaut de Celery sont prévues pour des tâches courtes et nombreuses. Un traitement d’image est long et coûteux. Trois de ces réglages posent alors problème, et il vaut mieux les changer avant un incident que pendant.

python
celery.conf.update(
    # Defaults to 4: a worker reserves four messages ahead and holds them while
    # processing one. On long tasks, three images wait behind the current one
    # while another worker sits idle.
    worker_prefetch_multiplier=1,
    # Defaults to False: the message is acknowledged on receipt, so it is lost
    # if the worker dies midway. At True it is only acknowledged at the end —
    # at the cost of a possibly repeated execution.
    task_acks_late=True,
    task_reject_on_worker_lost=True,
    # With no limit, one pathological image holds a worker indefinitely. The
    # soft limit raises a catchable exception; the hard one kills.
    task_soft_time_limit=110,
    task_time_limit=120,
)

Le troisième réglage a une conséquence à prévoir dès le départ. Si un message peut être rejoué, la tâche doit pouvoir l’être aussi. Écrire le résultat sous une clé dérivée de l’entrée plutôt qu’en ajout, et vérifier son existence avant de traiter, coûte trois lignes et évite un doublon dans un rapport client.

03Le choix du courtier, et l’avancement

Je ne traite pas le choix du courtier. Redis convient tant qu’on accepte sa garantie de livraison, plus faible que celle d’un courtier transactionnel ; au-delà d’un certain enjeu, la question se pose à nouveau, avec des arguments que je n’ai pas eu à trancher ici. Je laisse aussi de côté l’affichage de l’avancement, le pourcentage qui progresse pendant que l’utilisateur attend. C’est faisable, mais presque toujours inutile : la personne qui a envoyé une image veut savoir quand revenir chercher le résultat.