Retry, Backoff e Circuit Breaker: Chiamare Servizi Esterni Senza Crollare
Ogni sistema reale prima o poi parla con qualcosa che non controlla: un'API di pagamento, un servizio di spedizioni, un provider di email, un gestionale di terze parti. Ogni chiamata esterna è una scommessa: la rete cade, il servizio risponde con un timeout, il provider restituisce 503 perché è sotto carico.
La reazione istintiva è aggiungere un retry. È anche il modo più rapido per trasformare un piccolo disservizio in un blackout. Questo articolo mette in fila i pezzi che servono per chiamare servizi esterni senza far crollare il proprio sistema: capire quali errori ritentare, aspettare il tempo giusto, mettere dei limiti e rendere sicuro il secondo tentativo.
Il retry ingenuo è un moltiplicatore di guai
Immagina, come esempio, un servizio che riceve 1.000 richieste al secondo e inizia a rispondere lentamente. Un client che ritenta subito, senza attesa, non fa altro che aggiungere richieste a un sistema già in difficoltà. Se tre client fanno la stessa cosa, il carico non cresce del 3%: cresce in modo moltiplicativo, perché ogni richiesta fallita genera nuovi tentativi che a loro volta falliscono.
Questo fenomeno ha due nomi che vale la pena conoscere:
- retry storm: i tentativi si accumulano più velocemente di quanto il servizio riesca a smaltirli;
- thundering herd: molti client, magari partiti nello stesso momento, ritentano tutti insieme e colpiscono il servizio nello stesso istante.
Il secondo problema è particolarmente insidioso perché nasce dalla sincronizzazione. Se tutti aspettano esattamente lo stesso intervallo prima di ritentare, si ritrovano a bussare alla stessa porta nello stesso millisecondo. La soluzione, come vedremo, è rompere la sincronia con un po' di casualità.
C'è anche una questione di livelli. Se il client ritenta, il gateway ritenta e il load balancer ritenta, i tentativi si moltiplicano tra loro. Vale la pena decidere un solo punto della catena in cui si ritenta, invece di lasciare che lo facciano tutti.
Prima di ritentare: classificare l'errore
Non tutti gli errori meritano un secondo tentativo. Ritentare un errore permanente è solo tempo sprecato e carico inutile.
| Situazione | Ritentare? | Note |
|---|---|---|
| 400, 422 | No | il payload è sbagliato, lo sarà anche la prossima volta |
| 401, 403 | No | problema di credenziali o permessi |
| 404 | No | la risorsa non c'è |
| 429 | Sì | ma rispettando l'header Retry-After |
| 500 | Dipende | spesso transitorio, non sempre |
| 502, 503, 504 | Sì | tipicamente problemi di infrastruttura |
| Timeout di rete | Solo se l'operazione è idempotente | l'esito è incerto |
| Connessione rifiutata | Sì | il servizio potrebbe non essere ancora pronto |
L'ultima riga è la più delicata. Un timeout non significa "non è successo niente": significa che non lo sappiamo. La richiesta potrebbe essere arrivata, essere stata eseguita e solo la risposta essersi persa per strada. Se l'operazione è "addebita 100 euro", ritentare alla cieca può addebitare due volte. Serve un modo per rendere l'operazione ripetibile senza effetti collaterali, e ci arriviamo tra poco.
Backoff: aspettare, e aspettare sempre di più
La regola di base è semplice: più tentativi falliscono, più si aspetta. Il backoff esponenziale fa crescere l'attesa in modo geometrico.
attesa = min(tetto_massimo, base * 2^tentativo)
Con una base, ad esempio, di 200 ms: 200 ms, 400 ms, 800 ms, 1,6 s, 3,2 s, e così via fino a un tetto che impedisca attese assurde. Il tetto è importante: senza di esso, dopo dieci tentativi si aspetterebbe più di tre minuti, e a quel punto tanto vale fallire e segnalare l'errore.
Il backoff da solo, però, non basta. Se tutti i client usano la stessa base e la stessa sequenza, continuano a restare sincronizzati: dopo il primo fallimento aspettano tutti 200 ms e ritentano tutti insieme. Serve il jitter, cioè una componente casuale.
Le varianti più usate:
- full jitter:
attesa = random(0, min(tetto, base * 2^n)); - equal jitter: metà dell'attesa è fissa, l'altra metà è casuale;
- decorrelated jitter: ogni attesa è casuale in un intervallo che cresce rispetto alla precedente.
Il full jitter è il più semplice e spesso sufficiente: distribuisce i tentativi su una finestra e rompe la sincronia.
Ecco un esempio di implementazione in Python:
import random
import time
def attesa_con_jitter(tentativo, base=0.2, tetto=10.0):
limite = min(tetto, base * (2 ** tentativo))
return random.uniform(0, limite)
def chiama_con_retry(funzione, max_tentativi=5):
for tentativo in range(max_tentativi):
try:
return funzione()
except ErroreTransitorio:
if tentativo == max_tentativi - 1:
raise
time.sleep(attesa_con_jitter(tentativo))
Nota che l'esempio non copre il caso dell'errore permanente: nella pratica distingueresti le eccezioni ritentabili da quelle che non lo sono, e usciresti subito dal ciclo per queste ultime.
Timeout e budget di tempo
Un retry senza timeout è un modo elegante per bloccare una risorsa per sempre. Ogni chiamata esterna deve avere un limite di tempo, e il limite deve essere più corto del tempo che si ha a disposizione per rispondere.
Qui entra in gioco il concetto di budget di tempo (o deadline). Se una richiesta utente deve essere servita in due secondi, non si può spendere cinque secondi in tentativi: quando il budget finisce, si smette di ritentare e si restituisce un errore o un fallback, anche se restavano tentativi disponibili. La deadline va propagata verso il basso, così i servizi interni sanno quanto tempo hanno ancora.
In pratica: fissa un timeout per singola chiamata, un budget complessivo per l'operazione, e fai in modo che il secondo vincoli il primo.
Il circuit breaker
Ritentare ha senso quando il problema è passeggero. Se il servizio a valle è completamente giù, continuare a chiamarlo è inutile e dannoso: si consumano risorse e si rallenta tutto il resto.
Il circuit breaker è un interruttore che si apre quando gli errori superano una soglia.
| Stato | Comportamento | Come cambia |
|---|---|---|
| Chiuso | le chiamate passano normalmente | apre se gli errori superano la soglia in una finestra |
| Aperto | le chiamate vengono rifiutate subito, senza provare | dopo un'attesa passa a semi-aperto |
| Semi-aperto | passano solo poche chiamate di prova | chiude se riescono, riapre se falliscono |
Il vantaggio principale è il fallimento rapido: invece di aspettare il timeout, il sistema risponde immediatamente con un errore controllato. Questo libera risorse e dà tempo al servizio a valle di riprendersi.
Un circuito aperto, però, richiede una strategia. Le opzioni tipiche:
- restituire un fallback: un valore di default, un dato in cache, una risposta parziale;
- accodare l'operazione per riprovare più tardi, se l'ordine non è critico;
- segnalare chiaramente che il servizio è temporaneamente non disponibile, invece di far aspettare l'utente.
Limitare il ritmo: rate limiting lato client
Anche con backoff e circuit breaker, un client aggressivo può fare danni. Due strumenti aiutano:
- limitare la concorrenza: un numero massimo di chiamate in volo contemporaneamente, gestito ad esempio con un semaforo. Se il servizio regge dieci richieste insieme, non ha senso mandarne cento.
- token bucket: una riserva di "gettoni" che si ricarica a una certa velocità; ogni chiamata consuma un gettone. Serve a imporre un tetto medio al ritmo delle richieste.
Quando il servizio risponde 429 con un Retry-After, la mossa giusta è rispettarlo: quel numero è il provider che ti sta dicendo quando tornare.
Idempotenza: il presupposto che rende tutto sicuro
Ritentare è sicuro solo se l'operazione può essere eseguita più volte con lo stesso effetto di una sola. Le operazioni si dividono in tre categorie:
- naturalmente idempotenti: leggere un dato, impostare un valore con un
PUT, fare unUPDATE ... WHERE id = .... Ritentarle non cambia il risultato. - non idempotenti: creare una risorsa con
POST, inviare un pagamento, inviare una email. - ambigue: timeout su operazioni non idempotenti, dove non sappiamo se è successo qualcosa.
Per il secondo e terzo caso si usano le chiavi di idempotenza: il client genera un identificatore univoco per l'operazione e lo invia con la richiesta. Il server lo memorizza e, se arriva la stessa chiave, restituisce il risultato già prodotto invece di eseguire di nuovo l'operazione. È il meccanismo che rende i retry davvero innocui.
Questo vale anche per le code e le pipeline: consegnare lo stesso messaggio due volte è normale, e chi lo consuma deve essere pronto. Ma questa è una storia che merita un articolo a parte.
Verificare che funzioni
Un meccanismo di retry che non viene mai testato è solo decorazione. Alcune pratiche utili:
- fault injection: un server di test che risponde con errori e timeout in modo controllato, per vedere come si comporta il client;
- testare il caso peggiore: il servizio resta giù a lungo. Il circuit breaker si apre? Il sistema degrada o si blocca del tutto?
- misurare: tasso di retry, latenza al 99° percentile, quante volte il circuito si apre, quanti errori arrivano all'utente. Con queste metriche si capisce se le soglie sono tarate bene.
Conclusione
Chiamare servizi esterni è una parte normale di qualsiasi sistema, ma va trattata con rispetto. I punti chiave:
- Classifica gli errori: ritenta solo ciò che è transitorio, e mai gli errori di validazione o di permessi.
- Backoff esponenziale con jitter: cresci nel tempo e rompi la sincronia tra i client.
- Timeout e budget: ogni chiamata ha un limite, e i tentativi totali devono stare dentro il tempo che hai davvero.
- Circuit breaker: quando il servizio a valle è giù, fallisci in fretta invece di insistere.
- Limita il ritmo: concorrenza massima e token bucket proteggono sia te sia il provider.
- Idempotenza prima di tutto: senza di essa, il retry è una scommessa, non una soluzione.
- Testa e misura: fault injection e metriche sono l'unico modo per sapere se il meccanismo regge.
Messi insieme, questi pezzi trasformano una serie di chiamate fragili in un sistema che assorbe i disservizi senza amplificarli.
Foto di copertina di Albert Stoynov su Unsplash.