Lizenz-Upgrades zur Laufzeit neu laden
Ein Kunde verlängert oder erweitert mitten im Betrieb und Ihr Dienst bedient weiter den alten Plan, bis jemand ihn neu startet. Dieser Beitrag verdrahtet den Keyright-Lizenzzustand mit der Change-Token- und IOptionsMonitor-Infrastruktur von .NET, sodass sich ein erweiterter Plan auf jedes Gate, jeden Worker und jede zwischengespeicherte Policy verteilt, sobald das SDK ihn sieht — ohne Neustart, ohne Polling in Ihrem Gate-Code — während der zeitbasierte Ablauf eine Entscheidung pro Aufruf bleibt und keine Konfigurationsänderung.
Ein Kunde wechselt um 14 Uhr von Standard auf Pro, oder verlängert ein abgelaufenes Abonnement, oder kauft das Add-on für den geplanten Export. Seine Lizenz ist jetzt breiter als heute Morgen. Ihr Dienst, seit dem letzten Deployment in Betrieb, weiß das nicht. Er gibt weiter 402 auf dem Export-Endpoint zurück, den der Kunde gerade bezahlt hat, hält den Hintergrund-Worker untätig, erzwingt weiter die alte Sitzplatzobergrenze — bis jemand den Prozess neu startet und die Lizenz beim Hochfahren frisch liest. „Kaufen Sie das Upgrade, dann starten Sie die Anwendung neu” ist ein schlechter Satz für eine Kaufbestätigungs-E-Mail.
Die übliche Lösung ist, die Lizenz bei jeder Anfrage neu zu lesen, und für eine Gate-Entscheidung ist das korrekt: Sie wollen den Ablauf im Moment seines Eintretens erfassen, also sollte die Autorisierungsprüfung die Lizenz pro Aufruf auswerten. Aber nicht jeder Verbraucher einer Lizenz ist anfragegebunden. Ein Hintergrund-Worker, der starten soll, wenn der Kunde ein Entitlement erhält, hat keine Anfrage, an die er eine Prüfung hängen könnte. Ein auf ein lizenziertes Sitzplatzlimit dimensionierter Verbindungspool wird einmal gebaut. Eine kompilierte Autorisierungs-Policy ist zwischengespeichert. Das sind Push-Verbraucher — sie müssen einmal benachrichtigt werden, wenn sich der Plan ändert — und die Lizenz von jedem von ihnen aus zu pollen ist die falsche Form.
Kernaussage: Modellieren Sie den Lizenz-Plan — was die Lizenz gewährt — als IOptionsMonitor<LicensePlan>, neu aufgebaut aus dem Offline-Validate() des SDK. Treiben Sie sein Change-Token aus einer Hintergrund-RefreshAsync-Schleife an, die nur signalisiert, wenn der Plan tatsächlich breiter oder schmaler wird. Dann abonniert jeder Push-Verbraucher mit OnChange und reagiert ohne Neustart auf eine Verlängerung oder ein Upgrade, während anfragegebundene Gates den Ablauf weiterhin pro Aufruf auswerten. Die Gewährung ist heiß neu geladene Konfiguration; ob die Gewährung jetzt aktiv ist, bleibt eine Entscheidung pro Aufruf.
Die zwei Uhren in einer Lizenz
Eine Lizenz trägt zwei Arten von Zustand, die auf völlig verschiedenen Uhren wechseln. Die Gewährung — Edition, die Menge der Entitlements, numerische Limits — ändert sich nur, wenn sich das Lease ändert: eine Verlängerung, ein Upgrade, ein Widerruf. Das ist ein diskretes, seltenes Ereignis. Die Aktivierung in einem Augenblick — hat dieses Entitlement gerade jetzt seinen Ablauf überschritten, liegt das Lease in seinem Kulanzfenster? — ändert sich kontinuierlich mit der Wanduhr und wird bei jedem Aufruf neu hergeleitet.
Beides zu vermengen ist der Fehler. Laden Sie die ganze Lizenz als Konfiguration auf einem Timer neu, erfassen Sie den Ablauf zu spät (beim nächsten Timer-Tick) und laden ständig umsonst neu. Lesen Sie nur pro Anfrage, erfahren Ihre nicht anfragegebundenen Verbraucher nie von einem Upgrade. Das saubere Design leitet jede Uhr an die für sie gebaute Infrastruktur: Die diskrete Gewährung läuft durch die Change-Token-Maschinerie von .NET, und die kontinuierliche Aktivierung bleibt ein Validate() pro Aufruf.
Die Gewährung als Options modellieren
LicensePlan ist eine schlichte Options-Klasse, die beschreibt, was die Lizenz gewährt. Sie hält bewusst keinen Zustand pro Augenblick — keine „jetzt aktiv”-Flags — denn die gehören zur anderen Uhr.
public sealed class LicensePlan
{
public string Edition { get; set; } = "Community";
public IReadOnlySet<string> Entitlements { get; set; } = ImmutableHashSet<string>.Empty;
public IReadOnlyDictionary<string, int> Limits { get; set; } = ImmutableDictionary<string, int>.Empty;
public bool Grants(string entitlement) => Entitlements.Contains(entitlement);
public int Limit(string name) => Limits.TryGetValue(name, out var v) ? v : 0;
}
Ein IConfigureOptions<LicensePlan> baut ihn aus dem Offline-Validate() des SDK auf. Das ist die Factory, die IOptionsMonitor beim ersten Zugriff ausführt und bei jedem Auslösen des Change-Tokens des Plans erneut ausführt.
public sealed class ConfigureLicensePlan(IKeyrightClient client) : IConfigureOptions<LicensePlan>
{
public void Configure(LicensePlan plan)
{
LicenseInfo info = client.Validate(); // local, offline, no network
plan.Edition = info.Edition;
plan.Entitlements = info.Entitlements.ToImmutableHashSet();
plan.Limits = info.Limits;
}
}
Beachten Sie, was Configure liest: die Menge der Entitlements, die die Lizenz trägt, und die numerischen Limits, nicht ob jedes in dieser Sekunde unabgelaufen ist. Die Gewährung ist die Obergrenze.
Das Change-Token, das bei einer Planänderung auslöst
Das Stück, das IOptionsMonitor reaktiv macht, ist ein IOptionsChangeTokenSource<LicensePlan>. Seine Aufgabe ist es, ein IChangeToken auszugeben, auf das sich der Monitor registriert; wenn wir dieses Token auslösen, verwirft der Monitor seinen zwischengespeicherten LicensePlan, baut ihn mit der Factory neu auf und ruft jeden OnChange-Listener auf. Wir hinterlegen das Token mit einer austauschbaren CancellationTokenSource.
public sealed class LicenseChangeSignal
{
private CancellationTokenSource _cts = new();
public IChangeToken Token => new CancellationChangeToken(_cts.Token);
public void Signal()
{
// Setze eine frische Quelle für das NÄCHSTE Token ein, brich dann die ab, die Verbraucher halten.
CancellationTokenSource stale = Interlocked.Exchange(ref _cts, new CancellationTokenSource());
stale.Cancel(); // löst jedes bereits ausgegebene Token aus
stale.Dispose();
}
}
public sealed class LicensePlanChangeTokenSource(LicenseChangeSignal signal)
: IOptionsChangeTokenSource<LicensePlan>
{
public string Name => Options.DefaultName;
public IChangeToken GetChangeToken() => signal.Token;
}
Die Reihenfolge in Signal() ist der feine Punkt. Der Monitor hält ein Token, das über der aktuellen _cts erzeugt wurde. Wir tauschen zuerst eine brandneue Quelle in _cts ein, brechen dann die alte ab — und lösen das Token aus, das der Monitor hält. Der Monitor reagiert, indem er GetChangeToken() erneut aufruft, das nun ein Token über der neuen Quelle zurückgibt, also ist es für die nächste Änderung scharf gestellt. Das ist dieselbe Form, die die ConfigurationChangeTokenSource des Frameworks für appsettings.json-Neuladungen verwendet.
Verdrahten Sie alles beim Start:
builder.Services.AddSingleton<LicenseChangeSignal>();
builder.Services.AddSingleton<IConfigureOptions<LicensePlan>, ConfigureLicensePlan>();
builder.Services.AddSingleton<IOptionsChangeTokenSource<LicensePlan>, LicensePlanChangeTokenSource>();
builder.Services.AddOptions<LicensePlan>(); // aktiviert IOptionsMonitor<LicensePlan>
Nur bei einer echten Änderung signalisieren
Die Hintergrundschleife ist der einzige Teil, der mit dem Netzwerk spricht. Sie aktualisiert das Lease in einem Intervall und signalisiert das Token nur, wenn sich der Plan-Fingerabdruck tatsächlich bewegt — sonst würde jeder Refresh die Options unnötig neu aufbauen und jeden Abonnenten wecken.
public sealed class LicenseRefreshLoop(
IKeyrightClient client, LicenseChangeSignal signal, ILogger<LicenseRefreshLoop> log)
: BackgroundService
{
protected override async Task ExecuteAsync(CancellationToken ct)
{
string current = Fingerprint(client.Validate());
using var timer = new PeriodicTimer(TimeSpan.FromMinutes(15));
while (await timer.WaitForNextTickAsync(ct))
{
await client.RefreshAsync(ct); // online wenn erreichbar, sonst Lease aus Cache
string next = Fingerprint(client.Validate());
if (next == current) continue; // gleiche Gewährung — niemanden stören
current = next;
signal.Signal(); // ← ein Aufruf verteilt sich an jeden Verbraucher
log.LogInformation("Lizenzplan geändert; an Ort und Stelle ohne Neustart neu geladen.");
}
}
static string Fingerprint(LicenseInfo i) =>
$"{i.Edition}|{string.Join(',', i.Entitlements.Order())}|{i.Limit("seats")}";
}
RefreshAsync degradiert elegant: Ist der ausstellende Dienst kurz nicht erreichbar, bedient es das zwischengespeicherte Lease, sodass ein Netzwerk-Flackern den Plan nie umschaltet. Der Fingerabdruck schließt Ablaufzeitstempel bewusst aus — ein Plan, dessen einzige Änderung „eine Minute näher am Ablauf” ist, ist keine Planänderung.
Den heiß neu geladenen Plan verbrauchen
Ein Push-Verbraucher abonniert einmal und konvergiert zu dem Plan, den er erhält. Hier startet oder stoppt ein Supervisor einen Hintergrund-Export-Worker, wie das Entitlement kommt und geht — das Verhalten, das ein Upgrade ohne Neustart wirksam macht.
public sealed class ExportWorkerSupervisor : IHostedService
{
private readonly IDisposable? _subscription;
private readonly ExportWorker _worker;
public ExportWorkerSupervisor(IOptionsMonitor<LicensePlan> plan, ExportWorker worker)
{
_worker = worker;
Apply(plan.CurrentValue); // Anfangszustand beim Start
_subscription = plan.OnChange(Apply); // jedes weitere Neuladen
}
private void Apply(LicensePlan plan) // idempotent: konvergieren, nicht umschalten
{
if (plan.Grants("acme.scheduled-export")) _worker.Enable();
else _worker.Disable();
}
public Task StartAsync(CancellationToken ct) => Task.CompletedTask;
public Task StopAsync(CancellationToken ct) { _subscription?.Dispose(); return Task.CompletedTask; }
}
Ein anfragegebundenes Gate liest CurrentValue für die Gewährung, wertet aber den Ablauf weiterhin pro Aufruf aus — hier treffen sich die zwei Uhren.
public sealed class ExportEndpoint(IOptionsMonitor<LicensePlan> plan, IKeyrightClient license)
{
public IResult Handle(ExportRequest req)
{
// Günstig: gewährt der Plan dies überhaupt? Beim Upgrade an Ort und Stelle neu geladen.
if (!plan.CurrentValue.Grants("acme.export"))
return Results.StatusCode(StatusCodes.Status402PaymentRequired);
// Pro Aufruf: gewährt, aber ist es jetzt gerade aktiv? Erfasst den Ablauf auf die Sekunde.
if (!license.Validate().IsEnabled("acme.export"))
return Results.StatusCode(StatusCodes.Status402PaymentRequired);
return Results.Ok(RunExport(req));
}
}
Lassen Sie die zweite Prüfung weg, würde ein Entitlement, das mittags ablief, weiter durchgehen, bis der nächste Refresh eine Änderung im Fingerabdruck feststellt — was bei einem reinen Ablauf nie geschähe, weil der Ablauf keine Gewährungsänderung ist. Die Gewährung nennt Ihnen die Obergrenze; das Validate() pro Aufruf sagt Ihnen, ob Sie in diesem Augenblick darunter liegen.
Vorbehalte und wann es bricht
Ablauf ist kein Konfigurationsereignis. Der häufigste Fehler ist der Versuch, den Plan genau in der Sekunde neu zu laden, in der ein Entitlement abläuft. Das geht nicht: Das Change-Token löst bei diskreten Lease-Änderungen aus, und eine stetig fortschreitende Uhr erzeugt keine. Halten Sie zeitbasierte Entscheidungen pro Aufruf.
OnChange kann mehr als einmal auslösen. IOptionsMonitor entprellt, verspricht aber keine Exactly-once-Zustellung, und zwei Token-Quellen können kurz hintereinander auslösen. Deshalb berechnet Apply den gewünschten Zustand aus dem Plan neu, statt umzuschalten — einen bereits aktivierten Worker zu aktivieren muss eine Nulloperation sein.
Geben Sie das Abonnement frei. OnChange gibt ein IDisposable zurück; ein gehaltenes Abonnement, das sein Ziel überlebt, leckt und löst weiter in ein totes Objekt hinein aus. Geben Sie es in StopAsync oder im umgebenden IDisposable frei.
Scoped Options sind Snapshots pro Anfrage. Injizieren Sie IOptionsMonitor<LicensePlan>, nicht IOptions<LicensePlan>. IOptions wird einmal aufgelöst und nie aktualisiert; IOptionsSnapshot ist scoped und berechnet pro Anfrage neu, hat aber kein OnChange. Nur der Monitor gibt Ihnen sowohl einen aktuellen Wert als auch die Push-Callback.
Ein Downgrade ist auch eine Planänderung. Die Signalisierung löst bei jeder Fingerabdruck-Bewegung aus, einschließlich eines Widerrufs, der die Lizenz auf Community Edition zusammenfallen lässt. Das ist korrekt und erwünscht — dieselbe Maschinerie, die beim Upgrade eine kostenpflichtige Funktion anschaltet, schaltet sie beim Widerruf aus, an Ort und Stelle, ohne auf einen Neustart zu warten. Stellen Sie sicher, dass Ihre Apply-Handler beim verengten Plan fail-closed arbeiten.
Den Lizenzzustand mit dem Options-System zu verdrahten ist eine kleine Menge Code, die eine echte Eigenschaft erkauft: Ein Kunde, der aufrüstet, sieht das Upgrade im laufenden Prozess wirksam werden, und ein Kunde, dessen Lizenz abläuft, verliert den Zugang über denselben Pfad, mit der diskreten Gewährung auf der Change-Token-Uhr und der kontinuierlichen Aktivierung auf der Uhr pro Aufruf. Zum Fähigkeitsmodell, das der Plan trägt, siehe Entitlements und Feature Flags; um die Signaturprüfung unter all dem vom heißen Pfad fernzuhalten, siehe Lizenzprüfung zwischenspeichern; und dazu, wie eine Verlängerung überhaupt das SDK erreicht, siehe eine Testversion in eine bezahlte Lizenz umwandeln.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.