Einen Lizenz-Revalidierungs-Ansturm mit Jitter vermeiden
Wenn Tausende Clients einen gemeinsamen Cache-Validierungs-TTL teilen oder nach einem Ausfall alle zugleich neu verbinden, synchronisieren sich ihre Refresh-Aufrufe zu einer Lawine. So setzen Sie Jitter auf die Hintergrund-Revalidierung des SDK, um nicht Ihren eigenen Ausstellungsdienst zu DDoS-en.
Eine Online-Lizenzprüfung ist billig, bis alle sie zugleich ausführen. Ein einzelner Keyright-Client, der sein zwischengespeichertes Lease gegen Ihren selbst gehosteten Ausstellungsdienst erneuert, ist eine Anfrage von unter einer Sekunde, die alle paar Minuten geschieht und nichts kostet. Zehntausend Clients, die in derselben Sekunde erneuern, sind ein völlig anderes Ereignis — und die beiden Situationen, die es erzeugen, sind beide gewöhnlich, nicht exotisch.
Die erste ist ein festes Refresh-Intervall. Wenn Ihre Anwendung alle fünfzehn Minuten erneuert und ein paar tausend Kopien im selben Deploy-Fenster ausgerollt wurden, starten ihre Timer phasenstarr und bleiben es. Sie driften nicht von selbst auseinander; ein schlichter PeriodicTimer ist deterministisch. Also ruft alle fünfzehn Minuten, auf die Minute genau, die ganze Flotte den Dienst gemeinsam auf. Die zweite ist eine Wiederanlauf-Kante: Ihr Ausstellungsdienst hat einen kurzen Schluckauf — ein fortlaufendes Upgrade, eine Zertifikatsrotation — und alle Clients weichen auf ihr zwischengespeichertes Lease aus. In dem Moment, in dem der Dienst wieder erreichbar ist, wiederholen alle gleichzeitig, und der Dienst, der sich gerade erst erholte, bekommt als Willkommensgeschenk eine Lawine.
Beide sind derselbe Fehler: synchronisierte Revalidierung, ein Ansturm, den Sie sich selbst zugefügt haben. Die Lösung ist nicht mehr Kapazität. Sie besteht darin, die Clients davon abzuhalten, sich darauf zu einigen, wann sie aufrufen.
Kernaussage: Fügen Sie der Hintergrund-Revalidierung des SDK zufälligen Jitter hinzu, damit eine Flotte ihre Refreshes über das Intervall verteilt, statt an den Rändern zu spitzen. Verwenden Sie Full Jitter für das periodische Refresh im eingeschwungenen Zustand und Decorrelated Jitter plus Retry-After für Wiederholungen nach einem Ausfall. Stützen Sie sich auf das Kulanzfenster, damit Validate() nie auf ein Refresh wartet — das ist es, was Jitter kostenlos hinzuzufügen macht.
Warum ein festes Intervall sich nie desynchronisiert
Die Intuition, „sie werden sich schon irgendwann verteilen“, ist für einen festen Timer falsch. Betrachten Sie das naive Hintergrund-Refresh, das fast jeder zuerst schreibt:
// ANTIMUSTER: ein festes Intervall hält die Flotte für immer phasenstarr.
using var timer = new PeriodicTimer(TimeSpan.FromMinutes(15));
while (await timer.WaitForNextTickAsync(ct))
await License.RefreshAsync(ct);
PeriodicTimer feuert in einer gleichmäßigen Taktung relativ zu seinem Start. Wenn zwei Prozesse mit einer Sekunde Abstand gestartet sind — was jeder Prozess eines einzigen Deploys tat — bleiben sie unbegrenzt mit einer Sekunde Abstand. Es gibt keinen Mechanismus, der sie auseinanderzieht. Das Einzige, was die Phase je stört, ist ein Refresh, das länger dauert als üblich, und unter einem Ansturm dauern alle Refreshes länger, was sie eher re-synchronisiert als sie zerstreut.
Also ist die Anfragerate der Flotte gegen den Ausstellungsdienst kein gleichmäßiges Rinnsal von einer Anfrage pro Client alle fünfzehn Minuten. Es ist eine Spitze von zehntausend Anfragen alle fünfzehn Minuten und beinahe Stille dazwischen. Sie haben einen festfrequenten DDoS gegen Ihren eigenen Dienst gebaut.
Full Jitter auf dem periodischen Refresh
Das Mittel für den eingeschwungenen Fall ist, jedes nächste Refresh an einem gleichverteilt zufälligen Punkt innerhalb des Intervalls zu planen statt genau ein Intervall später. Das ist Full Jitter: die Verzögerung bis zum nächsten Refresh ist eine Gleichverteilung über [0, Intervall] (oder, wenn Sie einen Boden wollen, damit ein Client nie hämmert, über [Intervall/2, Intervall]). In ein, zwei Zyklen ist eine Flotte, die perfekt phasenstarr startete, gleichmäßig über das Fenster verschmiert.
Hier ist ein BackgroundService, der die Lizenz beim Start vorwärmt und dann nach einem Full-Jitter-Zeitplan revalidiert. Er stützt sich auf die richtige Weise auf das SDK: Validate() ist die reine, Offline-, nie werfende Prüfung, die Kontrollentscheidungen aus dem zwischengespeicherten Lease bedient; RefreshAsync ist der einzige Aufruf, der das Netz berührt, und ihn versehen wir mit 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)
{
// Wärmt den Cache einmal beim Start vor, damit die erste Kontrollentscheidung frisch ist.
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 über die zweite Hälfte des Intervalls: nie vor interval/2,
// nie nach interval, gleichverteilt zufällig dazwischen.
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)
}
}
Zwei Dinge machen dies sicher. Random.Shared ist eine prozessweite, unabhängig geseedete Quelle, also ziehen zehntausend Prozesse zehntausend unkorrelierte Verzögerungen — es gibt keinen gemeinsamen Seed, der sie re-synchronisiert. Und der Jitter wird in jedem Zyklus neu berechnet, nicht einmal beim Start, sodass zwei Prozesse, selbst wenn sie dieselbe erste Verzögerung ziehen, beim nächsten Tick divergieren. Die Flotte bleibt verteilt.
Refreshen, ohne einen Fehler je werfen zu lassen
Das Refresh selbst darf die Anwendung nie umwerfen, und es muss eine endgültige Antwort von einem nicht erreichbaren Dienst unterscheiden, denn nur Letzterer soll eine Wiederholung auslösen. Das ist dieselbe vorübergehend-gegen-endgültig-Trennung, die das SDK bereits für Kulanzfenster zieht.
async Task SafeRefreshAsync(CancellationToken ct)
{
try
{
RefreshResult r = await license.RefreshAsync(ct);
switch (r.Status)
{
case RefreshStatus.Confirmed:
// Lease erneuert; das Kulanzfenster wird zurückgesetzt. Nichts zu tun.
break;
case RefreshStatus.Revoked:
case RefreshStatus.Expired:
case RefreshStatus.SeatWithdrawn:
// Endgültig. Validate() meldet nun Community Edition;
// unser bestehendes Gating deaktiviert die kostenpflichtigen Funktionen. Keine Wiederholung.
log.LogWarning("License no longer valid: {Reason}.", r.Reason);
break;
case RefreshStatus.ServiceUnreachable:
// Vorübergehend. Das zwischengespeicherte Lease besteht innerhalb seines Kulanzfensters weiter.
// NICHT in einer engen Schleife wiederholen — Retry-After honorieren und zurückweichen.
await BackoffRetryAsync(r.RetryAfter, ct);
break;
}
}
catch (Exception ex) when (ex is not OperationCanceledException)
{
// Ein Hintergrund-Refresh darf den Host nie zum Absturz bringen.
log.LogWarning(ex, "License refresh failed; continuing on cached lease.");
}
}
Beachten Sie, was hier nicht geschieht: Ein ServiceUnreachable-Ergebnis sperrt die Anwendung nicht. Validate() antwortet während des gesamten Kulanzfensters weiter aus dem signierten zwischengespeicherten Lease, das weit länger ist als das Refresh-Intervall, sodass ein verpasstes Refresh — oder mehrere — den Kunden nichts kostet. Genau deshalb ist Jitter kostenlos hinzuzufügen: das Refresh um ein paar Minuten in die eine oder andere Richtung innerhalb eines in Tagen gemessenen Kulanzfensters zu verschieben, kann niemals eine Lizenz zum Ablaufen bringen.
Decorrelated Jitter und Retry-After für die Wiederanlauf-Kante
Der periodische Jitter löst den eingeschwungenen Zustand. Die Wiederanlauf-Kante braucht mehr, denn wenn der Dienst zurückkommt, will jeder Client im selben Augenblick wiederholen. Überhaupt mit einer festen kurzen Verzögerung zu wiederholen, baut den Ansturm nur neu auf. Zwei Werkzeuge besiegen ihn.
Honorieren Sie Retry-After. Wenn der Ausstellungsdienst Last abwirft oder zum Leben zurückkehrt, kann er den Clients sagen, wie lange sie warten sollen. Wenn das SDK ein RetryAfter auf dem Nicht-erreichbar-Ergebnis freilegt, respektieren Sie es als Boden — wiederholen Sie nie früher.
Legen Sie Decorrelated Jitter obendrauf. Decorrelated Jitter weicht zurück und randomisiert zugleich: jede Wartezeit wird aus einem Bereich gezogen, dessen Obergrenze mit der vorherigen Wartezeit wächst, sodass wiederholte Fehler sich immer weiter spreizen, statt sich zu bündeln. Die klassische Formel ist 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: die nächste Wartezeit ist zufällig in [base, previous * 3], gedeckelt.
double next = Random.Shared.NextDouble()
* (sleep.TotalMilliseconds * 3 - baseDelay.TotalMilliseconds)
+ baseDelay.TotalMilliseconds;
sleep = TimeSpan.FromMilliseconds(Math.Min(cap.TotalMilliseconds, next));
// Das Retry-After des Servers ist ein Boden; wiederholen Sie nie früher, als es verlangt.
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; // erholt oder endgültig
retryAfter = r.RetryAfter; // kann sich zwischen Versuchen ändern
}
// Weiterhin nicht erreichbar: zurück zur periodischen Schleife. Das Kulanzfenster hält uns lizenziert.
}
Da jeder Client seine eigene dekorrelierte Folge zieht, wird eine Flotte von zehntausend, die in derselben Sekunde den Kontakt verlor, nicht geschlossen in derselben Sekunde wiederholen. Sie fächern sich auf — ein paar sondieren früh, die meisten treffen über den Rückweich-Bereich verteilt ein — und der sich erholende Dienst sieht eine Rampe, keine Wand. Die früh sondieren und Erfolg haben, hören auf zu wiederholen; der Rest findet den Dienst bei einem späteren, natürlich gestaffelten Versuch gesund.
Warum offen-innerhalb-der-Kulanz-scheitern dies sicher macht
Der ganze Entwurf funktioniert nur, weil ein spätes Refresh harmlos ist. Riefe Ihre Kontrollentscheidung das Netz synchron auf — blockierte Validate() auf dem Ausstellungsdienst — dann wäre Jitter ein Luxus, den Sie sich nicht leisten könnten, denn ein verzögertes Refresh wäre ein verzögerter Nutzer. Indem Sie Validate() als reine Offline-Prüfung über das signierte zwischengespeicherte Lease halten und dieses Lease durch ein Kulanzfenster honorieren, das weit länger ist als das Refresh-Intervall, entkoppeln Sie, wann Sie revalidieren, von ob der Nutzer gerade jetzt arbeiten kann. Die Revalidierung wird eine Hintergrund-Hauswirtschaftsaufgabe, deren genauer Zeitpunkt Ihnen gehört, zu zerstreuen, wie es Ihnen beliebt.
Diese Entkopplung ist auch das, was verhindert, dass ein Ansturm zu einem Ausfall wird. Überwältigt eine synchronisierte Horde den Dienst kurz, laufen die Clients, deren Zeit abläuft, einfach auf ihrem zwischengespeicherten Lease weiter und wiederholen später mit Rückweichen. Der Fehlermodus von „zu viele Refreshes zugleich“ sind ein paar Refreshes, die ein wenig spät eintreffen — keine Flotte ausgesperrter Kunden. Sie dürfen auf Last justieren, ohne je die Verfügbarkeit zu verspielen.
Ihre Zahlen wählen
Ein paar Faustregeln zum Abschluss. Setzen Sie das Refresh-Intervall deutlich unter das Kulanzfenster — ein 15-Minuten-Refresh unter einer 72-Stunden-Kulanz gibt Ihnen Hunderte Gelegenheiten, wieder zu verbinden, bevor irgendetwas geschlossen scheitert, sodass kein einzelnes verpasstes Refresh zählt. Verwenden Sie Full Jitter über die zweite Hälfte des Intervalls für die periodische Schleife, damit Refreshes verteilt sind, aber kein Client viel länger als ein Intervall zwischen den Prüfungen verstreichen lässt. Deckeln Sie den Decorrelated Backoff bei ein paar Minuten, damit ein langer Ausfall sich in ein stetiges, gestaffeltes Neu-Sondieren einpendelt, statt in Stunden abzudriften. Und behandeln Sie Retry-After stets als Boden, denn die einzige Komponente, die weiß, wie viel Last der Ausstellungsdienst gerade jetzt verträgt, ist der Ausstellungsdienst.
Tun Sie diese vier Dinge, und die beiden Anstürme — die Festintervall-Spitze und die Horde an der Wiederanlauf-Kante — flachen beide zu einer Last ab, die Ihre selbst gehostete Instanz kaum bemerkt. Die Lizenzprüfung bleibt für Ihre Kunden unsichtbar, was genau dort ist, wo eine Lizenzprüfung hingehört.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.