Rechargement à chaud des mises à niveau de licence
Un client renouvelle ou met à niveau son offre en pleine journée et votre service continue de servir l'ancienne offre jusqu'à ce que quelqu'un le redémarre. Cet article relie l'état de licence de Keyright à l'infrastructure de jetons de changement et d'IOptionsMonitor de .NET pour qu'une offre élargie se propage à chaque barrière, worker et politique en cache dès que le SDK la détecte — sans redémarrage, sans sondage dans votre code de barrière — tout en gardant l'expiration temporelle comme une décision par appel, et non comme un changement de configuration.
Un client passe de Standard à Pro à 14 h, ou renouvelle un abonnement expiré, ou achète l”extension d”export planifié. Sa licence est désormais plus large que ce matin. Votre service, en marche depuis le dernier déploiement, l”ignore. Il continue de renvoyer 402 sur l”endpoint d”export que le client vient de payer, garde le worker d”arrière-plan inactif, applique encore l”ancien plafond de sièges — jusqu”à ce que quelqu”un redémarre le processus et relise la licence au démarrage. « Achetez la mise à niveau, puis redémarrez l”application » est une mauvaise phrase à mettre dans un e-mail de confirmation d”achat.
Le correctif habituel est de relire la licence à chaque requête, et pour une décision de barrière c”est correct : vous voulez détecter l”expiration à l”instant où elle survient, donc la vérification d”autorisation devrait évaluer la licence par appel. Mais tous les consommateurs d”une licence ne sont pas liés à une requête. Un worker d”arrière-plan qui doit démarrer quand le client gagne une entitlement n”a aucune requête sur laquelle accrocher une vérification. Un pool de connexions dimensionné à une limite de sièges sous licence est construit une seule fois. Une politique d”autorisation compilée est en cache. Ce sont des consommateurs push — ils doivent être prévenus, une fois, quand l”offre change — et sonder la licence depuis chacun d”eux est la mauvaise forme.
À retenir : Modélisez l”offre de licence — ce que la licence accorde — comme un IOptionsMonitor<LicensePlan>, reconstruit à partir du Validate() hors ligne du SDK. Pilotez son jeton de changement depuis une boucle RefreshAsync d”arrière-plan qui ne signale que lorsque l”offre s”élargit ou se réduit réellement. Chaque consommateur push s”abonne alors avec OnChange et réagit à un renouvellement ou une mise à niveau sans redémarrage, tandis que les barrières liées à une requête continuent d”évaluer l”expiration par appel. L”octroi est de la configuration rechargée à chaud ; savoir si l”octroi est actif maintenant reste une décision par appel.
Les deux horloges d”une licence
Une licence porte deux sortes d”état qui changent sur des horloges totalement différentes. L”octroi — édition, l”ensemble des entitlements, les limites numériques — ne change que lorsque le lease change : un renouvellement, une mise à niveau, une révocation. C”est un événement discret et rare. L”activation à un instant — cette entitlement a-t-elle dépassé son expiration à l”instant même, le lease est-il dans sa fenêtre de grâce ? — change continuellement avec l”horloge murale et est redérivée à chaque appel.
Les confondre est l”erreur. Si vous rechargez toute la licence comme configuration sur un minuteur, vous prenez l”expiration en compte en retard (au prochain tic du minuteur) et vous rechargez constamment pour rien. Si vous ne lisez que par requête, vos consommateurs non liés à une requête n”apprennent jamais une mise à niveau. La conception propre dirige chaque horloge vers l”infrastructure bâtie pour elle : l”octroi discret passe par la machinerie de jetons de changement de .NET, et l”activation continue reste un Validate() par appel.
Modéliser l”octroi comme des options
LicensePlan est une classe d”options ordinaire décrivant ce que la licence accorde. Elle ne détient volontairement aucun état par instant — aucun indicateur « active maintenant » — car ceux-ci appartiennent à l”autre horloge.
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;
}
Un IConfigureOptions<LicensePlan> le construit à partir du Validate() hors ligne du SDK. C”est la fabrique qu”IOptionsMonitor exécute au premier accès et réexécute chaque fois que le jeton de changement de l”offre se déclenche.
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;
}
}
Remarquez ce que lit Configure : l”ensemble d”entitlements que la licence porte et les limites numériques, pas si chacune est non expirée à cette seconde. L”octroi est le plafond.
Le jeton de changement qui se déclenche sur un changement d”offre
La pièce qui rend IOptionsMonitor réactif est un IOptionsChangeTokenSource<LicensePlan>. Son rôle est de fournir un IChangeToken sur lequel le moniteur s”enregistre ; quand nous déclenchons ce jeton, le moniteur jette son LicensePlan en cache, le reconstruit avec la fabrique et invoque chaque listener OnChange. Nous adossons le jeton à un CancellationTokenSource interchangeable.
public sealed class LicenseChangeSignal
{
private CancellationTokenSource _cts = new();
public IChangeToken Token => new CancellationChangeToken(_cts.Token);
public void Signal()
{
// Installe une source neuve pour le PROCHAIN jeton, puis annule celui que tiennent les consommateurs.
CancellationTokenSource stale = Interlocked.Exchange(ref _cts, new CancellationTokenSource());
stale.Cancel(); // déclenche tout jeton déjà remis
stale.Dispose();
}
}
public sealed class LicensePlanChangeTokenSource(LicenseChangeSignal signal)
: IOptionsChangeTokenSource<LicensePlan>
{
public string Name => Options.DefaultName;
public IChangeToken GetChangeToken() => signal.Token;
}
L”ordre dans Signal() est la partie subtile. Le moniteur tient un jeton créé sur le _cts actuel. Nous échangeons d”abord une source toute neuve dans _cts, puis annulons l”ancienne — déclenchant le jeton que le moniteur tient. Le moniteur réagit en rappelant GetChangeToken(), qui renvoie maintenant un jeton sur la nouvelle source, donc il est réarmé pour le prochain changement. C”est la même forme que le ConfigurationChangeTokenSource du framework utilise pour les rechargements d”appsettings.json.
Câblez le tout au démarrage :
builder.Services.AddSingleton<LicenseChangeSignal>();
builder.Services.AddSingleton<IConfigureOptions<LicensePlan>, ConfigureLicensePlan>();
builder.Services.AddSingleton<IOptionsChangeTokenSource<LicensePlan>, LicensePlanChangeTokenSource>();
builder.Services.AddOptions<LicensePlan>(); // active IOptionsMonitor<LicensePlan>
Ne signaler que sur un changement réel
La boucle d”arrière-plan est la seule partie qui parle au réseau. Elle rafraîchit le lease à un intervalle et ne signale le jeton que lorsque l”empreinte de l”offre bouge réellement — sinon chaque refresh reconstruirait inutilement les options et réveillerait chaque abonné.
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); // en ligne si joignable, sinon lease en cache
string next = Fingerprint(client.Validate());
if (next == current) continue; // même octroi — ne déranger personne
current = next;
signal.Signal(); // ← un appel se propage à chaque consommateur
log.LogInformation("Offre de licence changée ; rechargée sur place sans redémarrage.");
}
}
static string Fingerprint(LicenseInfo i) =>
$"{i.Edition}|{string.Join(',', i.Entitlements.Order())}|{i.Limit("seats")}";
}
RefreshAsync se dégrade avec élégance : quand le service émetteur est brièvement injoignable, il sert le lease en cache, donc un clignotement réseau ne change jamais l”offre. L”empreinte exclut volontairement les horodatages d”expiration — une offre dont le seul changement est « une minute plus proche de l”expiration » n”est pas un changement d”offre.
Consommer l”offre rechargée à chaud
Un consommateur push s”abonne une fois et converge vers l”offre qu”il reçoit. Ici un superviseur démarre ou arrête un worker d”export d”arrière-plan selon que l”entitlement va et vient — le comportement qui fait qu”une mise à niveau prend effet sans redémarrage.
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); // état initial au démarrage
_subscription = plan.OnChange(Apply); // chaque rechargement ultérieur
}
private void Apply(LicensePlan plan) // idempotent : converger, ne pas basculer
{
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; }
}
Une barrière liée à une requête lit CurrentValue pour l”octroi mais évalue encore l”expiration par appel — c”est là que les deux horloges se rencontrent.
public sealed class ExportEndpoint(IOptionsMonitor<LicensePlan> plan, IKeyrightClient license)
{
public IResult Handle(ExportRequest req)
{
// Bon marché : l''offre accorde-t-elle ceci tout court ? Rechargé sur place à la mise à niveau.
if (!plan.CurrentValue.Grants("acme.export"))
return Results.StatusCode(StatusCodes.Status402PaymentRequired);
// Par appel : accordé, mais est-ce actif à l''instant même ? Capte l''expiration à la seconde.
if (!license.Validate().IsEnabled("acme.export"))
return Results.StatusCode(StatusCodes.Status402PaymentRequired);
return Results.Ok(RunExport(req));
}
}
Si vous supprimez la seconde vérification, une entitlement expirée à midi passerait encore jusqu”à ce que le prochain refresh enregistre un changement d”empreinte — ce qui, pour une simple expiration, n”arriverait jamais, car l”expiration n”est pas un changement d”octroi. L”octroi vous donne le plafond ; le Validate() par appel vous dit si vous êtes en dessous à l”instant présent.
Mises en garde et quand cela casse
L”expiration n”est pas un événement de configuration. L”erreur la plus courante est de vouloir recharger l”offre à la seconde exacte où une entitlement expire. C”est impossible : le jeton de changement se déclenche sur des changements discrets du lease, et une horloge qui avance régulièrement n”en produit aucun. Gardez les décisions temporelles par appel.
OnChange peut se déclencher plus d”une fois. IOptionsMonitor applique un anti-rebond mais ne promet pas une livraison exactement-une-fois, et deux sources de jeton peuvent se déclencher coup sur coup. C”est pourquoi Apply recalcule l”état voulu à partir de l”offre plutôt que de basculer — activer un worker déjà activé doit être une opération nulle.
Libérez l”abonnement. OnChange renvoie un IDisposable ; un abonnement capturé qui survit à sa cible fuit et continue de se déclencher vers un objet mort. Libérez-le dans StopAsync ou dans l”IDisposable conteneur.
Les options scoped sont des instantanés par requête. Injectez IOptionsMonitor<LicensePlan>, pas IOptions<LicensePlan>. IOptions se résout une fois et ne se met jamais à jour ; IOptionsSnapshot est scoped et recalcule par requête mais n”a pas d”OnChange. Seul le moniteur vous donne à la fois une valeur actuelle et la callback push.
Une rétrogradation est aussi un changement d”offre. La signalisation se déclenche sur tout mouvement d”empreinte, y compris une révocation qui réduit la licence à Community Edition. C”est correct et souhaitable — la même machinerie qui allume une fonction payante à la mise à niveau l”éteint à la révocation, sur place, sans attendre un redémarrage. Assurez-vous que vos gestionnaires Apply échouent en mode fermé face à l”offre réduite.
Relier l”état de licence au système d”options est une petite quantité de code qui achète une vraie propriété : un client qui met à niveau voit la mise à niveau prendre effet dans le processus en marche, et un client dont la licence expire perd l”accès par le même chemin, avec l”octroi discret sur l”horloge des jetons de changement et l”activation continue sur l”horloge par appel. Pour le modèle de capacités que porte l”offre, voyez entitlements et feature flags ; pour garder la vérification de signature hors du chemin chaud sous tout cela, voyez mettre en cache la vérification de licence ; et pour comment un renouvellement atteint le SDK en premier lieu, voyez convertir un essai en licence payante.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.