Aller au contenu
English

Livraison et nouvelles tentatives

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

Où nous en sommes

Dans la leçon précédente, l'API a enregistré le travail d'IA de chaque billet comme une tâche, et un processus l'a exécutée plus tard. Mais une file d'attente qui ne perd jamais de tâche peut en livrer certaines deux fois, et certaines tâches échouent et doivent être réessayées. Dans cette leçon, nous rendons le travail répété sans danger, nous réessayons un nombre limité de fois, et nous mettons de côté ce qui échoue encore. Pensons d'abord à une commande de pizza par téléphone, quand la ligne coupe.

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

Ce que vous saurez faire

Rendez le travail d’IA d’un billet de soutien sûr à recevoir deux fois. Répétez ce qui pourrait fonctionner la prochaine fois, un nombre limité de fois. Mettez de côté ce qui échoue encore pour qu’une personne puisse l’examiner.

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

  • Le projet à end-of-m04, de la leçon précédente : python -m pytest affiche 163 passed, 1 deselected.
  • PostgreSQL et Valkey en marche; le fournisseur simulé (python -m simulator) et l’API (fastapi dev) dans deux terminaux.

Cette leçon n’ajoute aucun code. Le plantage et le « processus naïf » sont des cas construits. Le cours les crée volontairement pour montrer ce qui peut mal tourner. Le fournisseur est simulé. Les tests ont été faits sur macOS (Apple silicon); les commandes Windows n’ont pas été testées.

Vous commandez une pizza par téléphone. La pizzeria prend votre commande, puis la ligne coupe avant que vous entendiez « OK ». L’ont-ils reçue? Vous ne savez pas, alors vous rappelez.

Une pizzeria négligente prépare une deuxième pizza, et vous en payez deux. Une pizzeria attentive demande votre numéro de téléphone, trouve votre commande dans la liste et dit : « Nous l’avons déjà; elle est au four. » Vous pouvez appeler dix fois et recevoir une seule pizza.

La pizzeria attentive ne vous empêche pas de rappeler. Elle rend votre deuxième appel sans danger.

L’API de billets rencontre cette situation à deux endroits.

L’appelant répète une requête. L’application d’un client envoie un nouveau billet, et le réseau perd la réponse. L’application ne sait pas si le billet est arrivé, alors elle l’envoie de nouveau. Sans protection, le service de soutien reçoit deux billets et le fournisseur fait le travail d’IA deux fois.

La file d’attente livre une tâche deux fois. Un processus prend la tâche 1, fait le travail et s’arrête avant de la marquer succeeded (réussie). Le processus a planté, ou l’ordinateur a redémarré. La tâche est encore running (en cours), mais aucun processus ne la détient. Son bail de 30 secondes se termine, et un autre processus la prend : la même tâche, une deuxième fois. C’est une livraison en double.

Le deuxième cas n’est pas un bogue de la file d’attente. C’est le prix à payer pour ne jamais perdre une tâche. Une file qui remet une tâche en attente quand son processus disparaît ne peut pas savoir jusqu’où il s’est rendu. Elle doit donc parfois livrer une tâche deux fois. Cette promesse s’appelle la livraison au moins une fois : chaque tâche s’exécute au moins une fois, parfois davantage.

La suite dépend du processus. Le cours a volontairement construit un processus naïf. Il appelle le fournisseur pour chaque étape et enregistre les résultats sans le numéro de la tâche. Après un plantage, la tâche livrée deux fois a laissé 6 résultats d’IA pour un billet et produit 6 appels au fournisseur. Cela donne deux équipes, deux brouillons de réponse, deux plongements (embeddings) et une facture doublée.

Une opération est idempotente si l’exécuter deux fois produit le même effet que l’exécuter une fois. Un bouton d’ascenseur est idempotent : appuyer cinq fois appelle un seul ascenseur. « Ajouter 10 euros au compte » ne l’est pas; « fixer le solde à 110 euros » l’est. Le mot signifie « la même puissance » en latin.

Vous ne pouvez pas empêcher les répétitions. Vous rendez plutôt chaque répétition sans danger, avec deux outils :

  1. Une clé d’idempotence pour une requête répétée. L’appelant donne un nom à sa requête dans l’en-tête Idempotency-Key (clé d’idempotence). L’API conserve ce nom avec la tâche. Quand le même nom revient, elle renvoie la première réponse sans rien enregistrer de nouveau.
  2. Le numéro de la tâche sur chaque résultat, pour une livraison répétée. Le processus enregistre le résultat de chaque étape avec l’identifiant de la tâche. La base de données autorise un seul résultat par tâche et par étape. Avant une étape, le processus vérifie les résultats de la tâche. Il saute les étapes terminées.

Le cours sur les agents utilise la même idée pour les actions dans le monde extérieur. Ses identifiants d’opération donnent un nom à chaque changement prévu, pour qu’un remboursement répété ne paie qu’une fois.

Voici un petit exemple avec la démonstration du cours. Worker-1 fait les trois étapes de la tâche 1 et plante avant de la marquer succeeded. Le bail se termine, et worker-2 prend la tâche :

Appels au fournisseur Résultats enregistrés État de la tâche
Worker-1, tentative 1 classify, draft_reply, embed (3) 3, chacun avec la tâche 1 running (plantage)
Worker-2, tentative 2 : le processus du projet aucun : les 3 étapes sont terminées 0 nouveau succeeded
Worker-2, tentative 2 : le processus naïf (construit) encore 3 3 de plus, sans l’identifiant de la tâche —
Total projet : 3; naïf : 6 projet : 3; naïf : 6
Une séquence avec worker-1, PostgreSQL, le fournisseur d'IA simulé et worker-2. Worker-1 prend la tâche 1, tentative 1, avec un bail qui se termine dans 1 seconde. Il appelle classify, draft_reply et embed, puis enregistre 3 résultats, chacun avec la tâche 1. Ensuite, il plante avant de marquer la tâche comme réussie (cas construit). Le bail se termine : la tâche 1 est encore en cours, mais aucun processus ne la détient. Worker-2 reprend la tâche 1, tentative 2. Deux possibilités suivent. Le processus du projet demande les résultats de la tâche 1 : classify, draft_reply et embed. Il ne fait aucun appel, car chaque étape est terminée, et marque la tâche comme réussie : 3 résultats, 3 appels au fournisseur au total. Un processus naïf (construit) appelle de nouveau classify, draft_reply et embed. Il enregistre 3 résultats de plus sans l'identifiant de la tâche : 6 résultats, 6 appels au fournisseur.
Une livraison en double : la même tâche arrive à un deuxième processus après un plantage. Le processus du projet trouve les étapes terminées; un processus naïf les répète.
Description textuelle du diagramme

La moitié supérieure se produit dans les deux cas : un plantage après le travail, avant la dernière mise à jour. Le bail transforme ce plantage en deuxième livraison. L’encadré du bas compare deux processus. Le processus du projet lit d’abord les résultats de la tâche. La deuxième livraison ne fait donc que marquer la tâche comme terminée. Le processus naïf ne se fie à rien de ce qu’il peut lire. Il répète donc chaque appel et double chaque résultat.

Décrivez précisément la promesse, car Kwame vous le demandera. Après un nombre quelconque de livraisons, un billet a une tâche, une équipe et une priorité, un brouillon de réponse et un plongement : un résultat par étape. C’est l’effet prévu.

Le nombre d’appels au fournisseur n’est pas toujours de 3. La démonstration a planté après le dernier enregistrement, donc la deuxième livraison n’a fait aucun appel. Si un processus plante entre un appel au fournisseur et son enregistrement, la livraison suivante répète cet appel. Le résultat est toujours enregistré une seule fois, mais le fournisseur facture cet appel deux fois. Aux prix du cours, une étape de conversation coûte environ 0,00003 $ US. Pour un brouillon de réponse, c’est acceptable. Pour une étape ayant un effet extérieur, comme un courriel au client, ce ne l’est pas. Cette étape a besoin de sa propre clé, vérifiée par l’autre service, comme les identifiants d’opération ci-dessus.

L’API cherche la clé avant d’enregistrer quoi que ce soit. La clé appartient à l’appelant (l’acteur de la tâche). Deux clients peuvent donc utiliser la même clé sans conflit :

ticket_api/intake.py (accept, part)
if key:
earlier = jobs.find_by_key(conn, actor, key)
if earlier is not None:
if earlier["request_sha256"] != digest:
raise jobs.IdempotencyConflict(key) # 422 idempotency_key_reused
...
return earlier["ticket_id"], earlier, ahead, jobs.stats(conn), True # replayed

digest est une empreinte SHA-256 du corps de la requête. La même clé avec le même corps est une répétition. L’API répond 202 avec le premier billet et la première tâche, ainsi que l’en-tête Idempotent-Replayed: true (réponse d’idempotence rejouée). La même clé avec un corps différent est une erreur du client : 422 idempotency_key_reused (clé d’idempotence réutilisée).

Deux copies d’une requête peuvent aussi arriver au même moment, avant que l’une soit enregistrée. Un index unique jobs_idempotency_key sur (actor, idempotency_key) permet à une seule copie d’être insérée. L’autre échoue à cause d’une violation d’unicité, et accept_once cherche la clé de nouveau. Il renvoie ensuite le billet de la première requête.

La migration 014_jobs.sql ajoute l’identifiant de la tâche à ai_runs, ainsi qu’une règle :

migrations/014_jobs.sql (part)
ALTER TABLE ai_runs ADD COLUMN job_id bigint REFERENCES jobs (job_id) ON DELETE SET NULL;
CREATE UNIQUE INDEX ai_runs_one_per_job_task ON ai_runs (job_id, task) WHERE job_id IS NOT NULL;

Le processus utilise la règle deux fois. D’abord, avant les étapes, il lit les résultats de la tâche (repository.job_runs) et saute chaque étape qui en possède un. Ensuite, il enregistre chaque résultat avec ON CONFLICT (job_id, task) … DO NOTHING (ne rien faire en cas de conflit). Si un autre processus a enregistré la même étape juste avant, l’insertion n’ajoute rien. Le processus ne met donc pas le billet à jour de nouveau. L’auteur a tenté d’ajouter manuellement une deuxième ligne classify (classification) pour la tâche 1 :

ERROR: duplicate key value violates unique constraint "ai_runs_one_per_job_task"
DETAIL: Key (job_id, task)=(1, classify) already exists.

Avec le ON CONFLICT … DO NOTHING du processus, la même insertion a affiché INSERT 0 0 : aucune erreur, aucune deuxième ligne.

Une dernière protection se trouve dans jobs.finish. Elle marque une tâche succeeded seulement si ce processus la détient encore (locked_by). Un processus lent dont le bail est terminé ne peut pas écraser l’état écrit par le nouveau processus.

Nouvelles tentatives : quelques-unes, une attente croissante, puis l’arrêt

Section intitulée « Nouvelles tentatives : quelques-unes, une attente croissante, puis l’arrêt »

Toutes les défaillances ne sont pas des plantages. Parfois, le fournisseur répond 503 ou ne répond pas à temps. Une nouvelle tentative consiste à réessayer la même tâche plus tard. Les nouvelles tentatives sont maintenant sûres, car le travail est idempotent. Mais elles ne sont pas gratuites.

Tomás propose une règle simple : « On réessaie jusqu’à ce que le fournisseur réponde. » Pendant une panne du fournisseur, cette règle envoie des centaines d’appels à un service qui ne peut pas répondre. Quand le fournisseur revient, chaque tâche réessaie dans la même seconde, et le fournisseur tombe encore en panne sous la charge. Les nouvelles tentatives ont besoin de trois limites :

  1. Attendre plus longtemps après chaque échec. C’est le délai d’attente croissant exponentiel : l’attente maximale double après chaque tentative. Le projet commence à 2 secondes (RETRY_BASE_SECONDS) et n’attend jamais plus de 60 secondes (RETRY_CAP_SECONDS).
  2. Choisir une attente aléatoire sous cette limite. C’est la gigue. Les tâches qui ont échoué dans la même seconde réessaient alors à différents moments, plutôt que toutes ensemble.
  3. Arrêter après quelques tentatives. Après 5 tentatives (JOB_MAX_ATTEMPTS), la tâche devient une lettre morte. Elle quitte la file et attend qu’une personne l’examine. Le nom vient de la poste : une lettre impossible à livrer ou à retourner va dans un bureau spécial.

Les attentes d’une tâche, avec les paramètres du projet (jobs.backoff_seconds) :

Après la tentative Attente maximale Attente réelle
1 2 s aléatoire, de 0 à 2 s
2 4 s aléatoire, de 0 à 4 s
3 8 s aléatoire, de 0 à 8 s
4 16 s aléatoire, de 0 à 16 s
5 — aucune nouvelle tentative : dead_letter (lettre morte)

L’auteur a réglé le fournisseur simulé sur outage (panne) et envoyé un billet. Le journal du processus :

09:25:55,599 INFO ticket_api.worker: job 2: retried (attempt 1)
09:25:56,147 INFO ticket_api.worker: job 2: retried (attempt 2)
09:25:58,716 INFO ticket_api.worker: job 2: retried (attempt 3)
09:25:59,768 INFO ticket_api.worker: job 2: retried (attempt 4)
09:26:01,827 INFO ticket_api.worker: job 2: dead_letter (attempt 5)

Les attentes aléatoires étaient courtes cette fois : 6,2 secondes entre la première tentative et l’état de lettre morte. GET /v1/jobs/2 a ensuite montré "state":"dead_letter" et "last_error":"ProviderUnavailable: the provider answered 503" (fournisseur indisponible : il a répondu 503). Après la panne, POST /v1/jobs/2/retry l’a remise en attente avec 0 tentative, et le processus l’a terminée en 2,0 secondes.

Deux fins se ressemblent, mais elles sont différentes. Une tâche échouée a rencontré une erreur qu’une nouvelle tentative ne peut pas corriger, comme une réponse non valide. Le processus s’arrête immédiatement. Une lettre morte a rencontré des erreurs qui pourraient disparaître, mais qui n’ont pas disparu en 5 tentatives. Les deux conservent last_error, pour qu’une personne puisse décider.

Une règle de nouvelle tentative qui transformait l’attente en échec

Section intitulée « Une règle de nouvelle tentative qui transformait l’attente en échec »

Erreur courante

Compter un 429 comme une tentative échouée (trouvé dans le processus du cours)

Symptôme (mesuré) : la première version du processus du cours a reçu une rafale de 180 billets, 6 par seconde, avec le quota enregistré activé. En 50 secondes, 99 des 180 tâches étaient des lettres mortes. Le fournisseur n’était pas du tout en panne. Il demandait seulement au processus de ralentir.

Cause : ce processus traitait 429 comme 503 : réessayer plus tard et consommer une tentative. Ses attentes duraient quelques secondes (0 à 2, 0 à 4, 0 à 8…). Mais le quota compte les appels sur une minute entière. Une tâche utilisait donc ses 5 tentatives en environ une demi-minute, alors que le quota était encore plein. Elle devenait alors une lettre morte.

Diagnostic : comparez le moment où les lettres mortes apparaissent à la fenêtre du quota. Dans cette exécution, les premières lettres mortes sont apparues 16 secondes après le début de la rafale. Toutes les 99 sont apparues en 50 secondes : moins que la minute nécessaire pour reconstituer le quota. Pour voir pourquoi chaque tâche s’est terminée, regroupez les lettres mortes par leur dernière erreur : SELECT last_error, count(*) FROM jobs WHERE state = 'dead_letter' GROUP BY 1;.

Correction : un 429 n’est pas la faute de la tâche. Le processus remet maintenant la tâche en attente sans consommer de tentative. Il attend selon l’indication du fournisseur ou un délai d’attente croissant, selon la durée la plus longue :

ticket_api/worker.py (process, part)
except ProviderRateLimited as error:
# Over the quota is not the job's fault: the job waits and keeps its attempts.
state = "waiting"
self.rate_limited += 1
delay = max(error.retry_after or 0,
jobs.backoff_seconds(min(self.rate_limited, 6), ...))
await asyncio.to_thread(self._release, job, delay)

Les pannes (5xx, dépassements de délai) consomment encore des tentatives et finissent encore en lettres mortes. La même rafale après la correction :

  • Avant la correction : lettres mortes
  • Après la correction : lettres mortes (pointillés, 0)
  • Après la correction : tâches en attente
La même rafale (180 billets, 6 par seconde, quota activé), avant et après la correction. Une ligne toutes les 2 secondes.
Description textuelle du graphique

Un graphique linéaire sur 140 secondes. Avant la correction, les lettres mortes apparaissent vers 16 secondes et montent à 99 à 50 secondes, puis restent stables. Après la correction, les lettres mortes restent à 0 pendant toute l’exécution. Les tâches refusées par le quota attendent plutôt dans la file : jusqu’à 116 vers 30 secondes. Ensuite, la file raccourcit, car le quota laisse passer environ 50 tâches par minute. À 138 secondes, 25 tâches attendaient encore, et la plus ancienne attendait depuis environ deux minutes. La rafale provenait de l’exécution locale de mise à l’échelle automatique du module 5, une simulation sur cet ordinateur.

Ce que cela nous apprend. Après la correction, aucune tâche n’a été perdue, mais des tâches ont attendu plusieurs minutes. C’est le résultat réel d’un quota : le travail est en retard, pas perdu. La prochaine leçon détermine quelle quantité de travail en attente la file devrait accepter.

Exercice du module : un message volontairement répété

Section intitulée « Exercice du module : un message volontairement répété »

Cet exercice sert aussi de vérification de fin du module. scripts/duplicate_demo.py répète un message des deux façons. Il envoie la même requête deux fois avec une seule clé d’idempotence. Puis il livre la même tâche deux fois après un plantage simulé. Il exécute l’API et deux processus de traitement dans un seul processus, sur votre base de données .env, avec le fournisseur simulé.

  1. Rechargez les données pour que le billet de la démonstration soit T-500001 : python -m scripts.load --reset.

  2. Assurez-vous que le fournisseur simulé fonctionne (python -m simulator). L’API n’a pas besoin de fonctionner.

  3. Lancez la démonstration : python -m scripts.duplicate_demo. Elle prend environ 8 secondes, car elle attend la fin du bail du processus qui a planté.

  4. Examinez les résultats d’IA de la tâche dans la base de données :

    Fenêtre de terminal
    docker compose exec db psql -U tickets -d tickets -c "SELECT run_id, job_id, task, left(output, 40) AS output FROM ai_runs WHERE ticket_id = 'T-500001' ORDER BY run_id;"
  5. Lancez les tests qui vérifient les mêmes règles : python -m pytest tests/test_jobs.py -k "twice or idempotency" -v.

Afficher le résultat attendu

L’étape 3 affiche d’abord deux lignes WARNING ticket_api: API_KEY is not set (avertissement : API_KEY n’est pas définie). Elle affiche aussi quelques lignes INFO (information) et HTTP Request (requête HTTP). Ensuite :

Part 1: the same request twice, with the same Idempotency-Key
first: 202 ticket T-500001 job 1
second: 202 ticket T-500001 job 1 (Idempotent-Replayed: true)
in the database: tickets 1, jobs 1, AI results 0
Part 2: the same job delivered twice (a simulated crash)
after worker-1 (crashed before finishing): job running, attempt 1; tickets 1, jobs 1, AI results 3
after worker-2: job succeeded, attempt 2; tickets 1, jobs 1, AI results 3
provider calls for this job: 3 (3 steps: classify, draft_reply, embed)

Étape 4, exécution de l’auteur (vos numéros run_id peuvent différer) :

run_id | job_id | task | output
--------+--------+-------------+------------------------------------------
295 | 1 | classify | {"team": "billing", "priority": 1}
296 | 1 | draft_reply | Thank you for your message about "Charge
297 | 1 | embed | vector embed-small-384-v1
(3 rows)

L’étape 5 sélectionne 2 tests, test_the_same_idempotency_key_gives_the_same_ticket et test_a_job_delivered_twice_has_one_effect. Elle se termine par 2 passed, 13 deselected.

Vérification de fin. Montrez trois choses pour un billet. La requête répétée a renvoyé le même billet et la même tâche. La deuxième livraison s’est terminée avec la tâche succeeded à la tentative 2. Et la base de données contient exactement un résultat par étape, avec l’identifiant de la tâche. Expliquez ensuite en deux phrases quelle ligne du projet empêche chaque doublon.

Faites d’abord une prédiction. C-0022 envoie un billet avec Idempotency-Key: my-first-key-0001. Puis C-0003 envoie un billet différent avec la même clé. La deuxième réponse est-elle une réponse rejouée, un 422 ou un nouveau billet?

Avec l’API en marche, envoyez les deux :

Fenêtre de terminal
for c in C-0022 C-0003; do
curl -s -i -X POST http://127.0.0.1:8000/v1/tickets -H "Content-Type: application/json" \
-H "Idempotency-Key: my-first-key-0001" \
-d "{\"customer_id\": \"$c\", \"subject\": \"Late parcel\", \"body\": \"My parcel is late.\"}"
done

Dans PowerShell, envoyez les deux requêtes une à une avec curl.exe.

Afficher la réponse

Un nouveau billet. Dans l’exécution de l’auteur :

HTTP/1.1 202 Accepted
{"ticket_id":"T-500082","job_id":82,"state":"queued",…}
HTTP/1.1 202 Accepted
{"ticket_id":"T-500083","job_id":83,"state":"queued",…}

La clé appartient à son appelant : l’index unique porte sur (actor, idempotency_key). Les deux acteurs sont customer:C-0022 et customer:C-0003. Les clients choisissent leurs clés indépendamment, donc deux clients peuvent choisir la même. Si les clés étaient globales, la clé d’un client bloquerait le billet d’un autre client. Pire encore, elle pourrait renvoyer le billet d’un autre client. Vos numéros de billet dépendent de ce que vous avez envoyé auparavant.

Utilisez une clé d’idempotence pour chaque requête qui crée quelque chose et qu’un client pourrait répéter : nouveaux billets, paiements, messages. Conservez les clés aussi longtemps qu’un client pourrait répéter une requête; ce projet les conserve avec la tâche. Rendez toujours chaque tâche en file d’attente idempotente : avec une livraison au moins une fois, une deuxième livraison finira par arriver.

Les nouvelles tentatives avec délai d’attente croissant conviennent aux erreurs temporaires : délais dépassés, 503, dépendance qui redémarre. Ne réessayez pas après une erreur qui se répète de la même façon, comme une requête rejetée par le fournisseur. Marquez-la immédiatement comme failed (en échec). Ne comptez pas un signal « ralentissez » (429) comme un échec.

Ces outils coûtent un index unique, une lecture supplémentaire avant chaque étape et quelques appels répétés après un plantage. Les tâches en échec définitif demandent aussi une personne, un écran ou une requête, et une décision. Avec ces délais, les cinq tentatives se terminent en moins d’une minute. Cela convient à un bref problème. Pour une panne prolongée, le module 5 ajoute un disjoncteur. Les tâches attendent alors au lieu d’épuiser leurs tentatives.

Vérifiez votre compréhension

Pourquoi une file d'attente qui ne perd jamais de tâche ne peut-elle pas garantir une livraison exactement une fois?

Afficher la réponse

Quand un processus disparaît, la file d’attente ne peut pas savoir où il en était. Il n’a peut-être rien fait. Il a peut-être tout fait, puis planté avant la dernière mise à jour. Pour ne jamais perdre de tâche, la file d’attente la confie à un autre processus quand le bail expire. Dans le deuxième cas, c’est une deuxième livraison. La file d’attente garantit donc une livraison « au moins une fois », et le processus rend la répétition sans danger. Il enregistre une seule fois le résultat de chaque étape avec l’identifiant de la tâche et saute les étapes terminées.

Vérifiez votre compréhension

La deuxième livraison de la démonstration n'a fait aucun appel au fournisseur. Décrivez un plantage après lequel la livraison suivante refait un appel. Expliquez pourquoi le billet conserve un seul brouillon de réponse.

Afficher la réponse

Worker-1 appelle le fournisseur pour draft_reply (brouillon de réponse), reçoit la réponse et plante avant de l’enregistrer. La tâche contient un résultat pour classify (classer), mais aucun pour draft_reply. La livraison suivante saute classify, rappelle le fournisseur pour draft_reply et enregistre le résultat : le fournisseur a facturé cette étape deux fois. Le billet contient un seul brouillon de réponse, car une seule ligne peut exister pour (job_id, 'draft_reply'). L’effet se produit une seule fois; un appel a été répété.

Vérifiez votre compréhension

Avant la correction, 99 des 180 tâches sont passées en échec définitif pendant une pointe, sans panne du fournisseur. Expliquez pourquoi et ce que le processus fait maintenant avec un code 429.

Afficher la réponse

Le processus comptait chaque code 429 comme une tentative échouée et attendait seulement quelques secondes avant la suivante. Le quota compte les appels sur une minute entière. Une tâche épuisait donc ses 5 tentatives alors que le quota était encore atteint. Un code 429 signifie « ralentissez », pas « cette tâche est défectueuse ». Maintenant, le processus remet la tâche en file d’attente sans utiliser de tentative. Il attend le plus long des deux délais : celui indiqué par le fournisseur ou le délai d’attente croissant. Pendant la même pointe, aucune tâche n’est passée en échec définitif; les tâches ont plutôt attendu dans la file.

Récapitulatif

  • Une file d’attente qui ne perd jamais de tâche livre certaines tâches deux fois : livraison au moins une fois. Le travail doit être idempotent : deux exécutions ont l’effet d’une seule.
  • Une clé Idempotency-Key par appelant fait renvoyer le même billet et la même tâche lors d’une requête répétée (Idempotent-Replayed: true). Un autre corps avec la même clé donne 422 idempotency_key_reused (clé d’idempotence réutilisée).
  • Le résultat de chaque étape est enregistré avec l’identifiant de la tâche, et UNIQUE (job_id, task) n’en autorise qu’un. Une tâche ayant planté, livrée deux fois : 3 résultats et 3 appels au fournisseur; un processus naïf (construit) : 6 et 6.
  • L’effet voulu est un résultat par étape. Un plantage entre un appel et son enregistrement répète cet appel, pas le résultat.
  • Les nouvelles tentatives attendent plus longtemps après chaque échec, avec une variation aléatoire : délai d’attente croissant exponentiel avec gigue. Après 5 tentatives, la tâche passe en échec définitif et demande une intervention humaine. failed désigne les erreurs qu’une nouvelle tentative ne peut pas corriger.
  • Un code 429 ne doit pas coûter une tentative. Le compter a fait passer 99 des 180 tâches en échec définitif; après la correction, 0.

Leçon suivante : Contre-pression