Éviter une ruée de revalidation de licence avec du jitter
Quand des milliers de clients partagent un TTL de validation en cache ou se reconnectent tous après une panne, leurs appels de rafraîchissement se synchronisent en avalanche. Voici comment appliquer du jitter à la revalidation en arrière-plan du SDK pour ne pas DDoS votre propre service émetteur.
Une vérification de licence en ligne est bon marché jusqu’à ce que tout le monde la fasse en même temps. Un seul client Keyright rafraîchissant son lease en cache contre votre service émetteur auto-hébergé est une requête de moins d’une seconde qui se produit toutes les quelques minutes et ne coûte rien. Dix mille clients rafraîchissant à la même seconde, c’est un événement entièrement différent — et les deux situations qui le produisent sont toutes deux ordinaires, pas exotiques.
La première est un intervalle de rafraîchissement fixe. Si votre application rafraîchit toutes les quinze minutes et que quelques milliers de copies ont été déployées dans la même fenêtre de déploiement, leurs minuteurs démarrent calés en phase et le restent. Ils ne s’écartent pas d’eux-mêmes ; un PeriodicTimer tout simple est déterministe. Donc toutes les quinze minutes, à la minute, tout le parc appelle le service ensemble. La seconde est un bord de reprise : votre service émetteur a un hoquet bref — une mise à niveau progressive, une rotation de certificat — et tous les clients basculent sur leur lease en cache. À l’instant où le service redevient joignable, tous réessaient en même temps, et le service qui venait tout juste de se rétablir reçoit une avalanche en cadeau de bienvenue.
Les deux sont le même échec : revalidation synchronisée, une ruée que vous vous êtes infligée à vous-même. La solution n’est pas plus de capacité. C’est d’empêcher les clients de se mettre d’accord sur quand appeler.
À retenir : Ajoutez du jitter aléatoire à la revalidation en arrière-plan du SDK pour que le parc répartisse ses rafraîchissements sur l’intervalle au lieu de pics aux bords. Utilisez du full jitter pour le rafraîchissement périodique en régime permanent et du decorrelated jitter plus Retry-After pour les réessais après panne. Appuyez-vous sur la fenêtre de grâce pour que Validate() n’attende jamais un rafraîchissement — c’est ce qui rend le jitter gratuit à ajouter.
Pourquoi un intervalle fixe ne se désynchronise jamais
L’intuition qu’« ils finiront par s’étaler » est fausse pour un minuteur fixe. Considérez le rafraîchissement en arrière-plan que presque tout le monde écrit en premier :
// ANTI-MODÈLE : un intervalle fixe maintient le parc calé en phase pour toujours.
using var timer = new PeriodicTimer(TimeSpan.FromMinutes(15));
while (await timer.WaitForNextTickAsync(ct))
await License.RefreshAsync(ct);
PeriodicTimer se déclenche à une cadence constante relative à son démarrage. Si deux processus ont démarré à une seconde d’écart — ce que chaque processus d’un même déploiement a fait — ils restent à une seconde d’écart indéfiniment. Aucun mécanisme ne les écarte. La seule chose qui perturbe jamais la phase est un rafraîchissement qui prend plus longtemps que d’habitude, et sous une ruée tous les rafraîchissements prennent plus longtemps, ce qui tend à les re-synchroniser plutôt qu’à les disperser.
Donc le débit de requêtes du parc contre le service émetteur n’est pas un filet régulier d’une requête par client toutes les quinze minutes. C’est un pic de dix mille requêtes toutes les quinze minutes et un quasi-silence entre les deux. Vous avez construit un DDoS à fréquence fixe contre votre propre service.
Full jitter sur le rafraîchissement périodique
Le remède pour le cas en régime permanent est de planifier chaque prochain rafraîchissement à un point aléatoire uniforme à l’intérieur de l’intervalle plutôt qu’exactement un intervalle plus tard. C’est le full jitter : le délai jusqu’au prochain rafraîchissement est un tirage uniforme sur [0, intervalle] (ou, si vous voulez un plancher pour qu’un client ne martèle jamais, sur [intervalle/2, intervalle]). En un cycle ou deux, un parc qui a démarré parfaitement calé en phase est étalé uniformément sur la fenêtre.
Voici un BackgroundService qui préchauffe la licence au démarrage puis revalide selon une planification avec full jitter. Il s’appuie sur le SDK de la bonne manière : Validate() est la vérification pure, hors ligne, qui ne lève jamais, et qui sert les décisions de contrôle depuis le lease en cache ; RefreshAsync est le seul appel qui touche le réseau, et c’est celui que nous soumettons au jitter.
public sealed class LicenseRefreshService(
IKeyrightClient license, ILogger<LicenseRefreshService> log) : BackgroundService
{
static readonly TimeSpan Interval = TimeSpan.FromMinutes(15);
protected override async Task ExecuteAsync(CancellationToken ct)
{
// Préchauffe le cache une fois au démarrage pour que la première décision de contrôle soit fraîche.
await SafeRefreshAsync(ct);
while (!ct.IsCancellationRequested)
{
TimeSpan delay = NextDelay();
log.LogDebug("Next license refresh in {Delay}.", delay);
try { await Task.Delay(delay, ct); }
catch (OperationCanceledException) { break; }
await SafeRefreshAsync(ct);
}
}
// Full jitter sur la seconde moitié de l'intervalle : jamais avant interval/2,
// jamais après interval, uniformément aléatoire entre les deux.
static TimeSpan NextDelay()
{
double half = Interval.TotalMilliseconds / 2;
double jitter = Random.Shared.NextDouble() * half; // [0, interval/2)
return TimeSpan.FromMilliseconds(half + jitter); // [interval/2, interval)
}
}
Deux choses rendent cela sûr. Random.Shared est une source par processus, amorcée indépendamment, donc dix mille processus tirent dix mille délais non corrélés — il n’y a pas de graine partagée pour les re-synchroniser. Et le jitter est recalculé à chaque cycle, pas une seule fois au démarrage, donc même si deux processus tirent le même premier délai, ils divergent au tick suivant. Le parc reste étalé.
Rafraîchir sans jamais laisser un échec lever
Le rafraîchissement lui-même ne doit jamais faire tomber l’application, et il doit distinguer une réponse définitive d’un service injoignable, car seul ce dernier doit déclencher un réessai. C’est la même séparation passager-contre-définitif que le SDK trace déjà pour les fenêtres de grâce.
async Task SafeRefreshAsync(CancellationToken ct)
{
try
{
RefreshResult r = await license.RefreshAsync(ct);
switch (r.Status)
{
case RefreshStatus.Confirmed:
// Lease renouvelé ; la fenêtre de grâce se réinitialise. Rien à faire.
break;
case RefreshStatus.Revoked:
case RefreshStatus.Expired:
case RefreshStatus.SeatWithdrawn:
// Définitif. Validate() signalera désormais Community Edition ;
// notre contrôle existant désactive les fonctions payantes. Pas de réessai.
log.LogWarning("License no longer valid: {Reason}.", r.Reason);
break;
case RefreshStatus.ServiceUnreachable:
// Passager. Le lease en cache tient toujours dans sa fenêtre de grâce.
// Ne PAS réessayer dans une boucle serrée — honore Retry-After et recule.
await BackoffRetryAsync(r.RetryAfter, ct);
break;
}
}
catch (Exception ex) when (ex is not OperationCanceledException)
{
// Un rafraîchissement en arrière-plan ne doit jamais faire planter l'hôte.
log.LogWarning(ex, "License refresh failed; continuing on cached lease.");
}
}
Remarquez ce qui ne se produit pas ici : un résultat ServiceUnreachable ne verrouille pas l’application. Validate() continue de répondre depuis le lease signé en cache pendant toute la fenêtre de grâce, qui est bien plus longue que l’intervalle de rafraîchissement, donc un rafraîchissement manqué — ou plusieurs — ne coûte rien au client. C’est précisément pourquoi le jitter est gratuit à ajouter : déplacer le rafraîchissement de quelques minutes dans un sens ou l’autre à l’intérieur d’une fenêtre de grâce mesurée en jours ne peut jamais faire expirer une licence.
Decorrelated jitter et Retry-After pour le bord de reprise
Le jitter périodique résout le régime permanent. Le bord de reprise demande davantage, car quand le service revient, tous les clients veulent réessayer au même instant. Réessayer tout court sur un délai court fixe ne fait que reconstruire la ruée. Deux outils la vainquent.
Honorez Retry-After. Quand le service émetteur déleste du trafic ou revient à la vie, il peut dire aux clients combien de temps attendre. Si le SDK expose un RetryAfter sur le résultat injoignable, respectez-le comme un plancher — ne réessayez jamais plus tôt.
Ajoutez du decorrelated jitter par-dessus. Le decorrelated jitter recule et aléatoirise à la fois : chaque attente est tirée d’une plage dont la borne supérieure croît avec l’attente précédente, donc les échecs répétés s’écartent de plus en plus au lieu de se regrouper. La formulation classique est sleep = min(cap, random_between(base, previous * 3)).
async Task BackoffRetryAsync(TimeSpan? retryAfter, CancellationToken ct)
{
TimeSpan baseDelay = TimeSpan.FromSeconds(2);
TimeSpan cap = TimeSpan.FromMinutes(5);
TimeSpan sleep = baseDelay;
for (int attempt = 0; attempt < 6 && !ct.IsCancellationRequested; attempt++)
{
// Decorrelated jitter : la prochaine attente est aléatoire dans [base, previous * 3], plafonnée.
double next = Random.Shared.NextDouble()
* (sleep.TotalMilliseconds * 3 - baseDelay.TotalMilliseconds)
+ baseDelay.TotalMilliseconds;
sleep = TimeSpan.FromMilliseconds(Math.Min(cap.TotalMilliseconds, next));
// Le Retry-After du serveur est un plancher ; ne réessayez jamais plus tôt qu'il ne le demande.
if (retryAfter is { } ra && ra > sleep) sleep = ra;
try { await Task.Delay(sleep, ct); }
catch (OperationCanceledException) { return; }
RefreshResult r = await license.RefreshAsync(ct);
if (r.Status != RefreshStatus.ServiceUnreachable) return; // rétabli ou définitif
retryAfter = r.RetryAfter; // peut changer entre deux essais
}
// Toujours injoignable : revenir à la boucle périodique. La fenêtre de grâce nous garde sous licence.
}
Comme chaque client tire sa propre séquence décorrélée, un parc de dix mille qui a perdu le contact à la même seconde ne réessaiera pas tout entier à la même seconde. Ils s’ouvrent en éventail — quelques-uns sondent tôt, la plupart arrivent répartis sur la plage de recul — et le service en reprise voit une rampe, pas un mur. Ceux qui sondent tôt et réussissent cessent de réessayer ; les autres trouvent le service sain lors d’une tentative ultérieure, naturellement échelonnée.
Pourquoi échouer-ouvert-dans-la-grâce est ce qui rend cela sûr
Tout le design ne fonctionne que parce qu’un rafraîchissement tardif est inoffensif. Si votre décision de contrôle appelait le réseau de façon synchrone — si Validate() se bloquait sur le service émetteur — alors le jitter serait un luxe que vous ne pourriez pas vous permettre, car un rafraîchissement retardé serait un utilisateur retardé. En gardant Validate() comme une vérification hors ligne pure sur le lease signé en cache, et en honorant ce lease à travers une fenêtre de grâce bien plus longue que l’intervalle de rafraîchissement, vous découplez quand vous revalidez de si l’utilisateur peut travailler en ce moment même. La revalidation devient une tâche d’entretien en arrière-plan dont le moment exact vous appartient, à disperser comme bon vous semble.
Ce découplage est aussi ce qui empêche une ruée de devenir une panne. Si une horde synchronisée submerge brièvement le service, les clients qui expirent continuent simplement de tourner sur leur lease en cache et réessaient plus tard avec recul. Le mode d’échec de « trop de rafraîchissements en même temps » est quelques rafraîchissements qui arrivent un peu en retard — pas un parc de clients verrouillés. Vous pouvez ajuster pour la charge sans jamais sacrifier la disponibilité.
Choisir vos chiffres
Quelques règles empiriques pour conclure. Fixez l’intervalle de rafraîchissement bien en dessous de la fenêtre de grâce — un rafraîchissement de 15 minutes sous une grâce de 72 heures vous donne des centaines d’occasions de vous reconnecter avant que quoi que ce soit n’échoue fermé, donc aucun rafraîchissement manqué isolé n’a d’importance. Utilisez du full jitter sur la seconde moitié de l’intervalle pour la boucle périodique, afin que les rafraîchissements soient étalés mais qu’aucun client ne passe beaucoup plus d’un intervalle entre deux vérifications. Plafonnez le decorrelated backoff à quelques minutes pour qu’une panne longue se stabilise en un re-sondage régulier et échelonné au lieu de dériver vers des heures. Et traitez toujours Retry-After comme un plancher, car le seul composant qui sait combien de charge le service émetteur peut encaisser en ce moment, c’est le service émetteur.
Faites ces quatre choses et les deux ruées — le pic d’intervalle fixe et la horde du bord de reprise — s’aplatissent toutes deux en une charge que votre instance auto-hébergée remarque à peine. La vérification de licence reste invisible pour vos clients, ce qui est exactement là où une vérification de licence doit être.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.