# Temporisation exponentielle

## Ce que c'est

La temporisation exponentielle, ou exponential backoff, définit le temps d'attente avant de réessayer. Après chaque échec, l'attente est multipliée par un facteur fixe, le plus souvent deux, jusqu'à un plafond : une seconde, puis deux, quatre, huit, etc. La règle se trouve dans le client, mais elle est faite pour le système qu'il appelle. Un serveur, un chemin réseau ou une base qui cède sous la charge ne se rétablit pas plus vite parce qu'on l'interroge immédiatement de nouveau. Il se rétablit lorsque ses appelants ralentissent. Une attente croissante les fait ralentir davantage à mesure que le problème dure.

L'exemple le plus ancien et le plus répandu se trouve dans TCP. La RFC 6298, document du parcours de normalisation de juin 2011 qui définit le calcul du délai de retransmission TCP, fixe ce délai à une seconde avant la première mesure du temps aller-retour. Elle indique qu'une valeur calculée inférieure à une seconde devrait être arrondie à une seconde. Chaque fois que le temporisateur expire et qu'un segment doit être renvoyé, l'hôte doit doubler ce délai. Un plafond est permis s'il est d'au moins 60 secondes. À réception d'une nouvelle mesure aller-retour, le délai est recalculé depuis les mesures, ce qui peut le faire redescendre directement après plusieurs doublements. L'algorithme remonte à l'article Congestion Avoidance and Control de Van Jacobson, en 1988. La section sécurité de la RFC en expose l'enjeu : Internet dépend d'un temporisateur de retransmission correct pour garder le réseau stable et éviter son effondrement par congestion.

Dans le code applicatif, la même idée comporte quelques réglages : attente initiale, multiplicateur, attente maximale arrêtant la croissance et limite du nombre de tentatives ou du temps total consacré à réessayer. Après le n-ième échec, en comptant depuis zéro, l'attente est la plus petite valeur entre le plafond et base × multiplicateur à la puissance n. L'analyse AWS présentée plus bas appelle cela la temporisation exponentielle plafonnée. Le plafond compte plus qu'il n'y paraît. Doubler dix fois une attente d'une seconde donne 1 024 secondes, plus de 17 minutes, au-delà de ce que la plupart des appelants attendront, quelle que soit l'opération.

Le dernier réglage est le jitter, un aléa dans chaque attente. Le protocole de temporisation des connexions gRPC décrit comment ses clients se reconnectent après un échec. Il part d'une seconde, multiplie par 1,6, plafonne à 120 secondes et applique un jitter de 0,2 : chaque attente est donc augmentée ou réduite aléatoirement, dans une limite de 20 %. Il laisse aussi au moins 20 secondes à chaque tentative de connexion pour aboutir. Il réinitialise la temporisation dès que le serveur a accepté la connexion, ce qu'il situe à la réception de la trame SETTINGS. Le protocole autorise d'autres implémentations, par exemple sur un téléphone devant se réveiller le moins souvent possible. Il exige toutefois de répartir les tentatives simultanées et d'éviter une fréquence sensiblement plus élevée.

## Pourquoi c'est important

Une nouvelle tentative ajoute de la charge au pire moment : précisément lorsque le système appelé échoue. Si un service ralentit par surcharge et que chaque appelant réessaie immédiatement, la charge augmente pendant que la capacité baisse. La documentation de Google Cloud Storage classe pour cette raison les tentatives sans temporisation parmi les mauvaises pratiques : des reprises immédiates ou très rapprochées peuvent provoquer des défaillances en cascade, l'une en entraînant d'autres. La temporisation fait de la nouvelle tentative un frein plutôt qu'un amplificateur. Plus le problème dure, moins chaque client y ajoute de charge.

La temporisation seule ne suffit pas : les clients qui échouent ensemble attendent aussi ensemble. Dans Exponential Backoff And Jitter, publié par AWS en mars 2015, Marc Brooker a simulé de nombreux clients mettant à jour la même ligne d'une base distante avec un contrôle de concurrence optimiste. Quand chaque client participe à chaque tour, le travail total croît avec le carré du nombre de clients. La temporisation exponentielle plafonnée aide peu. Les appels restent groupés, séparés par des intervalles calmes ; la contention diminue à peine. Tirer chaque attente au hasard entre zéro et la valeur exponentielle plafonnée supprime ces intervalles, laisse un débit d'appels approximativement constant et, pour 100 clients concurrents, réduit le nombre d'appels de plus de moitié. Parmi les variantes comparées, Brooker qualifie celle sans jitter de « grande perdante ». Il en précise aussi la limite : aucune méthode ne change le fait que le travail croît avec le carré de la contention. L'aléa réduit le gaspillage, sans supprimer le conflit. Une mise à jour de mai 2023 indique que la plupart des SDK AWS incluent désormais temporisation exponentielle et jitter dans leurs modes de reprise standard et adaptatif.

La temporisation décide quand réessayer, pas si cela est sûr. La documentation Cloud Storage pose d'abord deux questions. La réponse indique-t-elle un problème transitoire : codes HTTP 408, 429 et 5xx, dépassement du délai d'attente d'un socket ou déconnexion TCP ? La requête est-elle idempotente ? Une opération de liste peut être répétée librement. La création d'une notification Pub/Sub ne le peut pas : chaque appel réussi crée une nouvelle notification. Entre les deux, les opérations conditionnellement idempotentes deviennent sûres à relancer si elles portent une précondition. Un téléversement peut ainsi ne réussir que si le numéro de génération de l'objet correspond encore à celui attendu par le client.

Le serveur en sait parfois plus que la formule du client. L'en-tête Retry-After, défini par la RFC 9110, indique combien de temps le client devrait attendre avant une requête suivante, sous forme de date ou de nombre de secondes. Avec une réponse 503 Service Unavailable, il précise la durée d'indisponibilité prévue. Le statut 429 Too Many Requests de la RFC 6585, qui signale une limitation de débit, peut porter le même champ. Une boucle de reprise peut employer cette valeur à la place de son calcul, puisqu'elle provient du côté qui connaît sa propre charge.

## À quoi cela ressemble en pratique

Une boucle de reprise avec temporisation exponentielle plafonnée et jitter complet tient en quelques lignes de Python :

```python
import random
import time

class TransientError(Exception):
    """A timeout, a 408, 429 or 5xx response, or a dropped connection."""

def call_with_backoff(op, attempts=5, base=1.0, cap=30.0):
    for attempt in range(attempts):
        try:
            return op()
        except TransientError:
            if attempt == attempts - 1:
                raise
            ceiling = min(cap, base * 2**attempt)
            time.sleep(random.uniform(0, ceiling))
```

Avec ces valeurs, cinq tentatives sont séparées par quatre attentes plafonnées à 1, 2, 4 et 8 secondes. La boucle passe donc au plus 15 secondes à dormir avant d'abandonner, environ 7,5 secondes en moyenne, chaque attente étant tirée uniformément entre zéro et son plafond. Seule `TransientError` entraîne une nouvelle tentative ; un échec d'autorisation ou une requête mal formée lève immédiatement une exception. La boucle répète tout ce que fait `op`. `op` doit donc pouvoir être répété sans risque : une lecture ou une écriture que le serveur peut reconnaître comme répétée.

Les bibliothèques clientes fournissent leurs propres variantes, avec des réglages prédéfinis différents, même pour un service identique. Pour Cloud Storage, le client Python part d'une seconde, double chaque attente jusqu'à 60 secondes et abandonne après un délai prédéfini de 120 secondes. Le client C++ part aussi d'une seconde et double, mais peut attendre jusqu'à cinq minutes entre deux tentatives et réessayer pendant au plus 15 minutes, plus de sept fois plus longtemps. Il relance aussi des opérations jamais idempotentes, sauf si le programme choisit explicitement une politique stricte d'idempotence. La ligne de commande gcloud emploie ce que Google appelle une temporisation exponentielle binaire tronquée, avec au plus 32 nouvelles tentatives sans autre réglage. Deux programmes appelant la même API face au même échec peuvent donc le signaler après deux minutes ou un quart d'heure, selon leur langage.

L'attente n'a pas à bloquer un thread. En arrière-plan, une tâche échouée peut retourner dans une file avec une date d'exécution ultérieure. La temporisation devient alors une propriété de la tâche plutôt que d'un processus endormi. C'est sa place naturelle lorsque personne n'attend la réponse.

Dans le projet courriel avec basculement et journalisation de la livraison, réalisé dans le cadre d’un poste occupé depuis 2025, la temporisation se trouve du côté asynchrone. Les messages passent par trois fournisseurs : SendGrid en premier, puis SMTP2GO et Azure Communication Services, avec basculement automatique. L'envoi lui-même utilise un client au délai d'expiration de 30 secondes. La livraison asynchrone dispose de nouvelles tentatives et d'une temporisation, afin qu'un bref incident ne coûte pas un message. La page résume le résultat : si un fournisseur traverse un mauvais après-midi, le courrier suit un chemin dégradé plutôt que de subir une panne. Elle nomme aussi le prix : trois intégrations à maintenir au lieu d'une.

## Où les problèmes surviennent

Tous les clients attendent la même durée. Sans jitter, ceux qui ont échoué ensemble réessaient ensemble. Le serveur retrouve le même pic après une, deux, quatre et huit secondes. La simulation de Brooker montre que la temporisation exponentielle seule réduit à peine la contention pour cette raison. Ajoutez un aléa : dans sa comparaison, Full Jitter et Decorrelated Jitter réduisent tous deux nettement le travail client et la charge serveur. Les deux sont de bons choix initiaux.

L'attente n'a pas de plafond, ou les tentatives n'ont pas de fin. Un doublement non plafonné dépasse 17 minutes après dix échecs. Une boucle sans limite garde la requête active alors que plus personne n'attend sa réponse depuis longtemps. Google classe le non-respect des limites de reprise parmi les mauvaises pratiques : réessayer indéfiniment peut épuiser les ressources applicatives ou continuer à solliciter un service qui ne se rétablira pas sans intervention. Fixez une attente maximale et un délai total adaptés à l'appelant : courts si la latence compte, plus longs pour le traitement par lots.

On réessaie malgré des erreurs permanentes. Une erreur d'autorisation ou une requête invalide produit le même échec à chaque tentative. Réessayer ne fait que retarder l'erreur. Sans limite, le client peut finir dans une boucle infinie, avertit Cloud Storage. Distinguez les erreurs transitoires des permanentes avant la boucle. Ne réessayez que les premières, comme 408, 429, 5xx et les connexions interrompues. Journalisez les autres avec leur cause.

Une opération non idempotente est répétée aveuglément. Si la requête expire après que le serveur a agi, la relance répète l'action. Google cite parmi ses mauvaises pratiques les écrasements ou suppressions involontaires de données qui en résultent. Ne relancez que les opérations idempotentes, rendez les écritures conditionnelles quand l'API le permet et, sinon, assurez-vous que le destinataire détecte les doublons.

Plusieurs couches empilent leurs tentatives. Si l'application effectue trois tentatives et que sa bibliothèque cliente en effectue trois pour chacune, un échec aboutit à neuf tentatives. C'est l'exemple de Google. Chaque couche supplémentaire qui réessaie seule multiplie encore ce nombre. La documentation ajoute que ces reprises peuvent entraîner une limitation des requêtes et une latence accrue sans améliorer le taux de succès. Réessayez dans une seule couche, généralement la bibliothèque, et désactivez ou réduisez les reprises ailleurs.

La temporisation n'est jamais réinitialisée, ou personne ne la voit. Un client qui conserve sa dernière longue attente après le rétablissement attendra le maximum au petit échec suivant. gRPC revient à l'attente initiale dès qu'une connexion est acceptée, et TCP recalcule son temporisateur depuis de nouvelles mesures. Réinitialisez après un succès. Comme les reprises cachent les problèmes aux utilisateurs, elles les cachent aussi à l'équipe. Comptez-les dans la supervision et déclenchez une alerte si leur fréquence grimpe : une dépendance exigeant trois tentatives par appel présente déjà des défaillances.

## Pour aller plus loin
* RFC 6298 : calcul du temporisateur de retransmission TCP — les règles du parcours de normalisation pour le délai de retransmission TCP, dont son doublement à chaque expiration.
* Protocole de temporisation des connexions gRPC — l'algorithme de reconnexion, ses cinq paramètres et leurs valeurs, et le moment de la réinitialisation.
* Temporisation exponentielle et jitter — la simulation de clients concurrents par Marc Brooker en 2015, comparant l'absence de jitter aux variantes Full, Equal et Decorrelated Jitter.
* Stratégie de nouvelle tentative — les opérations que Cloud Storage juge sûres à relancer, les réglages prédéfinis de chaque bibliothèque et cinq mauvaises pratiques de reprise.
* RFC 9110 : sémantique HTTP — le champ Retry-After, par lequel le serveur indique l'attente avant la prochaine requête.

=> /fr/glossary/#queue file
=> /fr/portfolio/built-email-with-failover-and-delivery-logging/ courriel avec basculement et journalisation de la livraison
=> /fr/glossary/#monitoring supervision
=> /fr/glossary/#alert alerte
=> https://www.rfc-editor.org/rfc/rfc6298.html RFC 6298 : calcul du temporisateur de retransmission TCP
=> https://github.com/grpc/grpc/blob/master/doc/connection-backoff.md Protocole de temporisation des connexions gRPC
=> https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/ Temporisation exponentielle et jitter
=> https://docs.cloud.google.com/storage/docs/retry-strategy Stratégie de nouvelle tentative
=> https://www.rfc-editor.org/rfc/rfc9110.html#section-10.2.3 RFC 9110 : sémantique HTTP

=> https://engineer.company/fr/glossary/exponential-backoff/ Cette page sur le Web
