Aller au contenu
English

Cycle de vie d'une tâche

  • Leçon 11
  • 55 min
  • Module 4 : Files d'attente et travailleurs en arrière-plan

Où nous en sommes

Dans le module 3, le cache a évité des appels au fournisseur pour les questions répétées. Mais chaque nouveau billet attend encore plusieurs secondes son travail d'IA, et quand le fournisseur est occupé, le billet est perdu. Dans cette leçon, nous acceptons un billet en quelques millisecondes, nous enregistrons son travail d'IA comme une tâche dans une file d'attente, et un processus distinct l'exécute. Un nettoyeur travaille de la même façon.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité

Ce que vous saurez faire

Acceptez un nouveau billet de soutien en quelques millisecondes, même quand le fournisseur d’IA est occupé. Enregistrez le travail d’IA comme une tâche dans une file d’attente. Laissez un processus distinct l’exécuter, et laissez l’appelant demander le résultat plus tard.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 55 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

Après cette leçon, votre projet correspond à l’instantané end-of-m04. Les deux prochaines leçons utilisent les mêmes fichiers et n’ajoutent aucun code. Le fournisseur d’IA est le fournisseur simulé du cours : ses durées et son quota proviennent d’appels réels enregistrés. Chaque nombre indiqué comme « mesuré » provient d’un ordinateur Apple M4 (10 cœurs, 16 Go) sans autre activité. Vos nombres seront différents, mais les courbes garderont la même forme. Les tests ont été faits sur macOS (Apple silicon). Les commandes Windows sont fournies, mais n’ont pas été testées.

Vous apportez une chemise chez un nettoyeur. La personne au comptoir ne la nettoie pas pendant que vous attendez. Elle écrit un reçu numéroté, vous en donne la moitié et place la chemise sur un rail. Vous repartez après une minute. Derrière le comptoir, les nettoyeurs prennent les chemises sur le rail, dans l’ordre, aussi vite que possible. Demain, vous revenez avec votre numéro et récupérez la chemise.

Trois choses rendent cela possible. Le comptoir ne fait qu’accepter le travail, donc il est toujours rapide. Le rail conserve le travail, donc rien ne se perd quand les nettoyeurs sont occupés. Et votre numéro vous permet de demander des nouvelles de votre chemise plus tard.

Jusqu’ici, POST /v1/tickets effectuait le travail d’IA pendant la requête. L’API demandait trois choses au fournisseur, l’une après l’autre : l’équipe et la priorité, une ébauche de réponse et un plongement (embedding). Cela prend environ 2,2 secondes par billet. L’application du client attendait tout ce temps.

L’attente n’est pas le pire problème. Le fournisseur permet 100 requêtes de clavardage par minute, et chaque billet en demande deux. Il peut donc traiter environ 50 billets par minute. Selon les chiffres d’Omar pour le Vendredi fou, la minute la plus chargée peut apporter 90 billets. Pendant cette minute, le fournisseur doit refuser certains appels.

L’équipe du cours a mesuré ce que voient les clients. Les billets arrivaient à raison de 10 par seconde pendant 30 secondes, avec le quota enregistré. Avec la conception asynchrone du module 2, seulement 55 sur 300 billets environ ont été enregistrés. Environ 245 clients ont reçu 503 ai_busy (IA occupée), et leurs billets n’ont pas été enregistrés. Un client a écrit un message, et le service de soutien ne l’a jamais vu, parce qu’une ébauche de réponse n’était pas prête.

Sam pose la question évidente : « Enregistrer un billet, c’est une ligne dans la base de données. Pourquoi cela dépend-il de l’IA? » Cette dépendance n’est pas nécessaire.

Séparez la requête en deux parties, comme chez le nettoyeur. L’API enregistre le billet et une note qui dit « ce billet a besoin de son travail d’IA ». Elle répond immédiatement. Un programme distinct lit les notes, l’une après l’autre, et effectue le travail d’IA.

  • Une tâche est la note : un travail à faire plus tard, avec son propre numéro. Ici, une tâche correspond au travail d’IA d’un billet.
  • Une file d’attente est le rail : les tâches qui attendent, dans l’ordre. La première tâche entrée est la première sortie.
  • Un processus est le nettoyeur : un programme qui prend une tâche dans la file, l’exécute et enregistre le résultat. Il s’exécute dans son propre processus, à côté de l’API. Ce n’est pas la même chose que les processus de Mise à l’échelle horizontale. Ceux-là sont des copies de l’API qui répondent aux requêtes (fastapi run --workers 4). Un processus de file d’attente ne répond à aucune requête; il prend seulement des tâches.

L’API répond maintenant 202 Accepted (acceptée). En HTTP, 202 signifie « j’ai reçu votre requête, et le travail n’est pas encore terminé ». La réponse contient le numéro de la tâche et un en-tête Location (emplacement) : l’adresse où l’appelant peut demander son état.

Voici un petit exemple où tous les nombres sont visibles. Six billets arrivent dans la même seconde. Un processus exécute 4 tâches en même temps, et chaque tâche prend 2,2 secondes. Chaque client reçoit une réponse en environ 15 millisecondes :

Billet Réponse au client Début de la tâche Fin de la tâche
1 à 4 202, à 0,015 s 0 s 2,2 s
5 et 6 202, à 0,015 s 2,2 s (une place se libère) 4,4 s

Les tâches 5 et 6 attendent 2,2 secondes dans la file. Personne ne les regarde attendre : les clients ont reçu la réponse « acceptée » immédiatement. Quand un afflux dépasse ce que les processus peuvent traiter, la file s’allonge et les tâches attendent plus longtemps. Le travail est en retard, mais il n’est pas perdu.

Une séquence avec cinq participants : l'application du client, l'API, PostgreSQL, le processus et le fournisseur d'IA simulé. L'application envoie POST /v1/tickets. L'API enregistre le billet et une tâche en attente dans une seule transaction. Elle répond 202 Accepted (acceptée) avec Location : /v1/jobs/1 en environ 15 ms. Plus tard, le processus prend la tâche avec UPDATE jobs … FOR UPDATE SKIP LOCKED. La tâche est maintenant en cours d'exécution, à la tentative 1, avec un bail de 30 secondes. Le processus appelle classify (environ 0,9 s) et enregistre son résultat avec le numéro de la tâche. Il appelle ensuite draft_reply (environ 1,1 s) et embed (environ 0,2 s), en enregistrant chaque résultat immédiatement. Il marque la tâche comme réussie. Quand l'application envoie GET /v1/jobs/1, l'API lit la tâche et ses résultats. Elle répond 200 avec l'état succeeded (réussie), l'équipe, la priorité et l'ébauche de réponse.
Un billet avec une file d'attente : l'API ne fait qu'enregistrer; le processus effectue les trois appels d'IA plus tard; l'appelant lit le résultat à l'adresse de la tâche.
Description textuelle du diagramme

Le diagramme comporte trois parties. La partie du haut est la requête : l’application du client parle seulement à l’API, et l’API parle seulement à la base de données. La réponse revient en environ 15 millisecondes, avant tout appel d’IA. La partie du milieu est le processus. Il parle à la base de données et au fournisseur, et aucun client ne l’attend. Chacun des trois résultats va dans la base de données dès qu’il est prêt, avec le numéro de la tâche. La prochaine leçon explique pourquoi. La dernière partie montre l’application du client qui demande le résultat avec GET /v1/jobs/1.

Une file d’attente a besoin d’un emplacement accessible à tous les processus de l’API et à tous les processus de tâches. Cet emplacement doit conserver les tâches quand un programme s’arrête. L’équipe du cours a mesuré deux options avec les mêmes tâches synthétiques qui ne font rien. Quatre processus ont pris 2 000 tâches vides aussi vite que possible.

Tâches vides par seconde dans chaque file d'attente (4 processus, médiane de 3 passages), et rythme permis par le quota du fournisseur.
Description textuelle du graphique

Un graphique à trois colonnes. Une liste Valkey a transféré 7,171.6 tâches vides par seconde. Une table PostgreSQL a transféré 2,585.9 tâches par seconde. Le quota du fournisseur permet 0.83 billets par seconde. Cette colonne est trop petite pour être visible : elle est environ 3 000 fois plus basse que celle de PostgreSQL.

Ce que cela nous apprend. Valkey est presque trois fois plus rapide, et les deux options sont bien trop rapides pour que cela compte. Le travail d’IA, et non la file d’attente, impose le rythme. Le choix dépend donc d’autres facteurs, et PostgreSQL l’emporte sur deux d’entre eux :

  1. Le billet et sa tâche sont enregistrés dans une seule transaction. Soit les deux existent, soit aucun n’existe. Avec une file d’attente dans un autre système, l’API enregistre le billet, puis envoie la tâche. Si l’API s’arrête entre ces étapes, le billet ne reçoit jamais son travail d’IA, et personne ne le remarque. Conserver la tâche dans la même base de données que le billet s’appelle le modèle de boîte d’envoi transactionnelle (transactional outbox).
  2. Une tâche est une ligne que SQL peut lire. « Combien de tâches attendent, et quel est l’âge de la plus ancienne? » se résume à une requête. Mei peut y répondre avec les outils qu’elle utilise déjà.

D’autres bonnes files d’attente existent : les flux Redis ou Valkey, RabbitMQ et les files infonuagiques comme Azure Service Bus ou Amazon SQS. Choisissez-en une quand vous avez besoin de milliers de tâches par seconde, ou quand plusieurs services partagent la file. Prévoyez alors comment garder le billet et la tâche ensemble.

La migration 014_jobs.sql d’Amira ajoute la table. Voici les colonnes importantes pour cette leçon :

migrations/014_jobs.sql (part)
CREATE TABLE jobs (
job_id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
ticket_id text NOT NULL REFERENCES tickets (ticket_id) ON DELETE CASCADE,
actor text NOT NULL,
state text NOT NULL DEFAULT 'queued',
attempts integer NOT NULL DEFAULT 0,
max_attempts integer NOT NULL DEFAULT 5,
run_after timestamptz NOT NULL DEFAULT now(),
locked_by text,
locked_until timestamptz,
...

L’API enregistre le billet et la tâche dans le même bloc with db.connection(). Ils font donc partie d’une seule transaction :

ticket_api/intake.py (accept, part)
ticket = repository.insert_ticket(conn, new.customer_id, new.subject, new.body, new.channel)
job = jobs.enqueue(conn, ticket["ticket_id"], actor, idempotency_key=key, ...)

La colonne actor (acteur) indique qui a demandé le travail : customer:C-0022. Le processus fait confiance à cette ligne, jamais à un message extérieur. Le cours sur l’authentification développe cette idée dans Contexte d’identité des tâches.

Mei pose la question sur la base de données : « Si deux processus regardent la file au même moment, prennent-ils tous les deux la tâche 1? » Pas avec SKIP LOCKED (ignorer les lignes verrouillées). Chaque processus prend des tâches avec une seule instruction :

ticket_api/jobs.py (claim, simplified)
UPDATE jobs SET state = 'running', attempts = attempts + 1, locked_by = 'worker-1',
locked_until = now() + interval '30 seconds'
WHERE job_id IN (
SELECT job_id FROM jobs
WHERE state = 'queued' AND run_after <= now()
ORDER BY run_after, job_id LIMIT 4
FOR UPDATE SKIP LOCKED)
RETURNING ...

FOR UPDATE verrouille les lignes choisies par le processus, comme dans le cours sur les bases de données. SKIP LOCKED indique à un deuxième processus d’ignorer ces lignes et de prendre les suivantes, plutôt que d’attendre. Chaque tâche va donc à un seul processus.

Le processus définit aussi un bail : locked_until (verrouillée jusqu’à), dans 30 secondes. Un bail est un prêt avec une heure de fin. Une tâche prend environ 2,2 secondes, donc le bail est assez long. Si le processus s’arrête au milieu, le bail se termine, et un autre processus peut reprendre la tâche. La prochaine leçon porte précisément sur ce cas.

Une tâche qui prend plusieurs minutes, comme un long rapport, demande plus. Son processus doit prolonger le bail pendant le travail. Il envoie régulièrement une mise à jour « toujours au travail », appelée signal de vie (heartbeat). Sans ce signal, une tâche lente et un processus arrêté se ressemblent.

Une tâche passe par six états. Chaque flèche correspond à une instruction SQL dans ticket_api/jobs.py. L’état dans la table représente donc toujours la réalité :

Une machine à états avec six états. POST /v1/tickets crée une tâche dans l'état queued (en attente), enregistrée avec le billet, et répond 202. Depuis queued, POST …/cancel mène à cancelled (annulée), mais seulement pendant que la tâche est en attente. Un processus prend une tâche en attente : elle devient running (en cours d'exécution), avec une tentative de plus et un bail de 30 secondes. Depuis running : l'enregistrement des trois résultats mène à succeeded (réussie); une mauvaise réponse qu'une nouvelle tentative ne peut pas corriger mène à failed (échouée). Un 5xx ou un dépassement de délai la renvoie à queued pour réessayer plus tard avec un délai d'attente croissant. Un 429 la renvoie à queued pour attendre, et la tentative n'est plus comptée. Si le bail se termine, un autre processus la reprend, et elle reste running. Si la cinquième tentative échoue aussi, elle devient dead_letter (tâche mise à l'écart). Depuis dead_letter, POST …/retry la renvoie à queued, sur décision d'une personne. Succeeded, failed et cancelled sont des états finaux.
Les états d'une tâche et l'événement qui la fait avancer le long de chaque flèche.
Description textuelle du diagramme

Lisez le diagramme à partir du haut. Chaque tâche commence à l’état queued (en attente). Seule la prise en charge par un processus mène à running (en cours d’exécution). Depuis running, il y a quatre sorties possibles. succeeded (réussie) est le but. failed (échouée) est une erreur qu’une nouvelle tentative ne peut pas corriger, comme une réponse non valide. Une tâche peut aussi revenir à queued pour une tentative ultérieure. Elle peut devenir une dead_letter (tâche mise à l’écart) après la dernière tentative. Une personne peut renvoyer une tâche mise à l’écart dans la file. cancelled (annulée) est possible seulement avant qu’un processus prenne la tâche, car une tâche en cours peut déjà avoir appelé le fournisseur. La prochaine leçon explique les nouvelles tentatives, la flèche 429 et les tâches mises à l’écart.

L’appelant suit la tâche avec trois adresses :

  • GET /v1/jobs/{id} : l’état, les tentatives, la dernière erreur et le résultat quand la tâche a réussi.
  • POST /v1/jobs/{id}/cancel : annuler une tâche en attente. Tout autre état renvoie 409 conflict (conflit).
  • GET /v1/queue : les nombres de la file : tâches en attente, prêtes, en cours, mises à l’écart, terminées dans la dernière minute, et âge de la plus ancienne.

Exercice guidé : déplacer le travail d’IA vers la file d’attente

Section intitulée « Exercice guidé : déplacer le travail d’IA vers la file d’attente »
  1. Dans ~/projects/ticket-api, avec l’environnement virtuel actif, copiez les fichiers du module 4 depuis l’instantané end-of-m04 :

    Fenêtre de terminal
    S=../nextia-learning-labs/C21/snapshots/end-of-m04
    for f in README.md compose.yaml contract/openapi.json migrations/014_jobs.sql \
    scripts/duplicate_demo.py scripts/load.py scripts/queue_watch.py scripts/send_tickets.py \
    tests/test_cache.py tests/test_intake.py tests/test_jobs.py \
    ticket_api/cache.py ticket_api/config.py ticket_api/errors.py ticket_api/intake.py \
    ticket_api/job_routes.py ticket_api/jobs.py ticket_api/main.py ticket_api/models.py \
    ticket_api/ratelimit.py ticket_api/repository.py ticket_api/worker.py; do cp "$S/$f" "$f"; done
  2. Si .env contient une ligne INTAKE_MODE=…, supprimez-la. La valeur par défaut est maintenant queue (file d’attente).

  3. Appliquez la nouvelle migration : python -m ticket_api.migrate. La commande affiche applied 014_jobs (migration 014_jobs appliquée).

  4. Exécutez les tests : python -m pytest. Le résultat attendu est 163 passed, 1 deselected (163 tests réussis, 1 non sélectionné).

  5. Rechargez les petites données pour que les nouveaux billets commencent à T-500001 : python -m scripts.load --reset.

  6. Démarrez le fournisseur simulé dans un terminal (python -m simulator) et l’API dans un deuxième (fastapi dev). Ne démarrez pas encore de processus de tâches.

  7. Dans un troisième terminal, envoyez un billet. Demandez ensuite sa tâche :

    Fenêtre de terminal
    curl -i -X POST http://127.0.0.1:8000/v1/tickets -H "Content-Type: application/json" \
    -d '{"customer_id": "C-0022", "subject": "Charged twice", "body": "Two payments for one order."}'
    curl http://127.0.0.1:8000/v1/jobs/1

    Dans PowerShell, écrivez curl.exe au lieu de curl, sur une seule ligne. Placez \" autour de chaque nom et valeur dans le JSON.

  8. Démarrez le processus dans le troisième terminal. Avec --once, il s’arrête quand la file est vide : python -m ticket_api.worker --once --name worker-1.

  9. Demandez de nouveau la tâche : curl http://127.0.0.1:8000/v1/jobs/1.

  10. Envoyez un deuxième billet et annulez immédiatement sa tâche : curl -X POST http://127.0.0.1:8000/v1/jobs/2/cancel. Annulez-la ensuite une deuxième fois.

Afficher le résultat attendu

Étape 7, lors de l’exécution de l’auteur (vos durées seront différentes) :

HTTP/1.1 202 Accepted
location: /v1/jobs/1
server-timing: rate_limit;dur=6.6, db;dur=17.4
{"ticket_id":"T-500001","job_id":1,"state":"queued","status_url":"/v1/jobs/1","queued_ahead":0,"estimated_wait_seconds":null}
{"job_id":1,"ticket_id":"T-500001","state":"queued","attempts":0,"max_attempts":5,"created_at":"…","started_at":null,"finished_at":null,"last_error":null,"result":null}

Le billet est enregistré, la réponse a pris quelques millisecondes, et aucun appel d’IA n’a encore eu lieu. L’étape 8 affiche trois lignes HTTP Request: POST http://127.0.0.1:8300/v1/… (requête HTTP), puis :

INFO ticket_api.worker: job 1: succeeded (attempt 1)
Worker worker-1: up to 4 jobs at a time. Takes what is queued, then stops.
Done in 2.3 s: 1 taken, 1 succeeded, 0 waiting for the quota, 0 to retry later, 0 failed, 0 dead letters.

L’étape 9 montre le résultat (abrégé) :

{"job_id":1,"ticket_id":"T-500001","state":"succeeded","attempts":1,…,"last_error":null,
"result":{"team":"billing","priority":1,"draft_reply":"Thank you for your message about \"Charged twice\". …","embedding_version":"embed-small-384-v1"}}

Étape 10 : la première annulation renvoie 200 avec "state":"cancelled" (état : annulée). La deuxième renvoie 409 avec {"error":{"code":"conflict","message":"Job 2 is cancelled: only a queued job can be cancelled.",…}} (conflit : la tâche 2 est annulée; seule une tâche en attente peut être annulée).

À vous de jouer : deux processus sur une file d’attente

Section intitulée « À vous de jouer : deux processus sur une file d’attente »

Faites d’abord une prédiction. Vingt tâches attendent. Vous démarrez deux processus au même moment, chacun avec --once. Combien de tâches chacun prend-il? Une tâche peut-elle apparaître dans les deux journaux (logs)?

  1. Envoyez 20 billets sans processus de tâches en cours d’exécution : python -m scripts.send_tickets --rate 5 --seconds 4.
  2. Dans deux terminaux, démarrez en même temps python -m ticket_api.worker --once --name worker-1 et python -m ticket_api.worker --once --name worker-2.
  3. Comparez les numéros de tâches dans les deux journaux.
Afficher la réponse

Lors de l’exécution de l’auteur, worker-1 a pris 9 tâches et worker-2 en a pris 11 :

worker-1: jobs 58, 59, 60, 61, 63, 64, 68, 69, 71 Done in 6.1 s: 9 taken, 9 succeeded …
worker-2: jobs 54, 55, 56, 57, 62, 65, 66, 67, 70, 72, 73 Done in 6.7 s: 11 taken, 11 succeeded …

Votre répartition sera différente, car le processus qui demande en premier obtient les tâches suivantes. Aucune tâche n’apparaît dans les deux journaux : SKIP LOCKED a donné chaque tâche à un seul processus. Deux processus ont terminé 20 tâches en moins de 7 secondes; un seul processus a besoin d’environ 11 secondes. Le quota les limite toujours tous les deux, comme le montre la leçon Contre-pression.

Erreur courante

L'API accepte les billets, mais aucun processus de tâches ne s'exécute

Symptôme : chaque POST /v1/tickets répond 202 en quelques millisecondes, donc tout semble normal. Mais aucun billet ne reçoit d’équipe, de priorité ou d’ébauche de réponse. GET /v1/jobs/{id} indique queued pour chaque tâche.

Cause : le processus de tâches ne s’exécute pas. Il n’a peut-être jamais démarré après un déploiement, ou il s’est arrêté à cause d’une erreur. L’API ne peut pas le voir : elle ne fait qu’enregistrer des tâches. Une file d’attente cache l’absence d’un processus, car les clients reçoivent toujours des réponses rapides.

Diagnostic : regardez les nombres de la file. python -m scripts.queue_watch --every 2 affiche une ligne toutes les 2 secondes. Sans processus de tâches, queued et oldest s (âge de la plus ancienne en secondes) augmentent. done/min (tâches terminées par minute) reste à 0. Lors de l’exécution de l’auteur, 31 tâches attendaient; un processus a ensuite démarré au temps 0 :

time queued ready running oldest s done/min dead
0 31 31 0 64.1 0 0
2 27 27 4 7.6 0 0
4 23 23 4 9.5 4 0
6 20 20 4 11.5 7 0
8 16 16 4 13.5 11 0
10 12 12 4 15.4 15 0
12 9 9 4 17.4 18 0
14 5 5 4 19.3 22 0
16 2 2 3 21.3 26 0
18 0 0 3 0.0 28 0
20 0 0 0 0.0 31 0

Au temps 0, la tâche la plus ancienne attendait depuis 64 secondes. Ensuite, queued a diminué d’environ 2 tâches par seconde, et la file était vide après environ 18 secondes.

Correction :

  1. Démarrez le processus : python -m ticket_api.worker. Dans Docker Compose, le service worker l’exécute.
  2. Surveillez l’âge de la tâche la plus ancienne, pas seulement les erreurs. Un âge qui augmente sans fin signifie « aucun processus » ou « processus trop lents ». Signaux de mise à l’échelle transforme ce nombre en signal pour ajouter des processus.

Quand utiliser une file d’attente, et ce qu’elle coûte

Section intitulée « Quand utiliser une file d’attente, et ce qu’elle coûte »

Utilisez une file d’attente quand le travail est lent ou peu fiable et que le résultat peut attendre. Le travail d’IA pour un nouveau billet convient bien. Le client doit savoir que le service de soutien a reçu le billet, pas la réponse préliminaire. De toute façon, une personne lit la réponse préliminaire plus tard.

N’utilisez pas de file d’attente quand l’appelant a besoin de la réponse immédiatement. POST /v1/answers, du module 3, répond à la question d’un client à l’écran. Une file d’attente obligerait simplement le client à redemander la réponse sans cesse. Pour ce point de terminaison, le cache et la conception asynchrone sont les bons outils.

Une file d’attente a des coûts, et Kwame veut les consigner :

  • Un programme de plus à exécuter et à surveiller. Le processus peut s’arrêter alors que l’API semble fonctionner, comme le montre l’erreur courante ci-dessus.
  • Le résultat arrive plus tard. L’appelant doit le demander avec GET /v1/jobs/{id}, ou recevoir un avis quand il est prêt.
  • Plus d’états à gérer. Une tâche peut attendre, échouer, être annulée ou nécessiter une intervention humaine. Chaque état exige une réponse pour le client et pour le service de soutien.
  • Une tâche peut s’exécuter deux fois. Un bail qui expire confie la même tâche à un deuxième processus. La prochaine leçon montre comment rendre cela sûr.

Vérifiez votre compréhension

Avec la conception asynchrone, environ 245 des 300 billets n'ont pas été enregistrés pendant la pointe de trafic. Pourquoi une file d'attente dans la même base de données les enregistre-t-elle tous, même quand le fournisseur refuse les appels?

Afficher la réponse

Avec une file d’attente, l’enregistrement du billet ne dépend plus du fournisseur. L’API enregistre le billet et sa tâche dans une seule transaction courte et répond 202 en environ 15 ms. Elle ne fait aucun appel d’IA. La limite du fournisseur détermine maintenant seulement la vitesse à laquelle le processus termine les tâches. Un refus fait attendre une tâche dans la file; il ne fait pas perdre le billet. Le coût est le temps : les résultats d’IA arrivent plus tard, et beaucoup plus tard lors d’une longue pointe de trafic.

Vérifiez votre compréhension

Une liste Valkey a transféré 7 172 tâches vides par seconde, et la table PostgreSQL, 2 586. Pourquoi Larkfield a-t-elle choisi la solution plus lente?

Afficher la réponse

Les deux sont des milliers de fois plus rapides que nécessaire. Le quota permet environ 0,83 billet par seconde, donc la vitesse de la file elle-même n’importe pas ici. PostgreSQL offre deux avantages qui comptent. Le billet et sa tâche sont enregistrés dans une seule transaction, donc aucun billet ne se retrouve sans sa tâche. De plus, les tâches sont des lignes que SQL peut compter et lire : combien attendent, l’âge de la plus ancienne, lesquelles ont échoué. Avec une autre file d’attente, l’API aurait besoin de travail supplémentaire pour garder le billet et la tâche ensemble.

Vérifiez votre compréhension

Prédisez : un client envoie POST /v1/jobs/7/cancel pendant que worker-1 exécute la tâche 7. Que se passe-t-il, et pourquoi l'API n'arrête-t-elle pas le travail?

Afficher la réponse

L’API répond 409 conflict (conflit) : seule une tâche en file d’attente peut être annulée. Une tâche en cours peut déjà avoir appelé le fournisseur et enregistré certains résultats. Le processus ne consulte pas l’API avant chaque étape. Pour arrêter une tâche en cours, le processus devrait vérifier entre les étapes si une annulation a été demandée. Il devrait aussi nettoyer ce qu’il a enregistré. Le projet reste simple : l’annulation est possible jusqu’à ce qu’un processus prenne la tâche.

Récapitulatif

  • Une file d’attente conserve les tâches jusqu’à ce qu’un processus les exécute. L’API enregistre le billet et sa tâche dans une seule transaction et répond 202 Accepted (accepté) avec l’adresse de la tâche.
  • Avec la conception asynchrone, environ 245 des 300 billets d’une pointe de trafic n’ont pas été enregistrés. Avec une file d’attente, l’enregistrement d’un billet ne dépend pas du fournisseur.
  • PostgreSQL (2 586 tâches/s) et une liste Valkey (7 172/s) dépassent largement les besoins du travail d’IA. PostgreSQL garde le billet et la tâche ensemble et permet à SQL de lire la file d’attente.
  • FOR UPDATE SKIP LOCKED confie chaque tâche à un seul processus. Un bail de 30 secondes remet une tâche à disposition si son processus s’arrête.
  • Une tâche est queued (en attente), running (en cours), succeeded (réussie), failed (échouée), cancelled (annulée) ou dead_letter (à traiter manuellement). GET /v1/jobs/{id} renvoie l’état et le résultat; l’annulation fonctionne seulement pendant l’attente.
  • Surveillez l’âge de la tâche la plus ancienne : une file d’attente masque l’arrêt d’un processus.

Leçon suivante : Livraison et nouvelles tentatives