Migrer des clés par machine vers des licences flottantes
Faire passer un produit .NET déjà déployé d'activations liées à la machine à un pool de sièges concurrents flottants est un changement de protocole, pas un simple réglage de configuration : mal effectué, chaque installation existante perd son siège ou est comptée deux fois. Ce guide montre le SDK bimode, le claim du modèle de siège et la réconciliation atomique côté serveur qui permettent la bascule sans casser un seul client.
Un pool de licences flottantes ressemble à un réglage serveur : « autoriser 25 utilisateurs simultanés au lieu de 25 machines nommées ». Ce n’en est pas un. Le modèle par nombre de machines et le modèle de sièges concurrents sont deux conversations distinctes entre le client et le service, et les clients déjà installés ne savent en tenir qu’une. Basculez le serveur avant que le terrain soit prêt et vous obtiendrez la pire erreur de licence qui soit : celle où les clients payants sont bloqués alors que le tableau de bord affiche que tout va bien.
À retenir : traitez le passage de lié à flottant comme une migration de protocole progressive. Placez un claim seat.model par clé dans la licence, diffusez un SDK bimode qui le lit, laissez ce SDK atteindre le terrain d’abord, et commencez seulement ensuite à frapper des clés flottantes. Le serveur réconcilie l’ancienne activation de chaque machine dans le nouveau pool de façon atomique, de sorte que le plafond partagé tient à tout moment.
La vraie question : qui décide du modèle, et quand ?
Avec le verrouillage à la machine, un client rattache une licence à une empreinte de machine stable et la valide localement ; le service suit une activation par machine et plafonne le compte. Avec le flottant, le client ne possède rien de permanent : il appelle ClaimSeatAsync au démarrage, renouvelle une licence courte sur un heartbeat, et le siège retourne au pool quand le client se ferme ou cesse de renouveler.
Ce sont des comportements par défaut incompatibles. Un client lié ne demande jamais de siège ; un client flottant n’attend jamais de lien permanent. La décision ne peut donc pas être un drapeau serveur global lu au moment de la validation : elle doit voyager à l’intérieur de chaque licence, où le serveur comme le client peuvent la lire avant de choisir un chemin.
{
"lic": "KR-7F3A-...",
"product": "acme-suite",
"seat": { "model": "floating", "max": 25, "leaseTtl": "00:05:00" },
"exp": "2027-03-01T00:00:00Z"
}
Le claim seat est signé dans la charge utile de la licence, un client ne peut donc pas forger son passage de lié à flottant, et le modèle est un fait concernant la clé plutôt que l’humeur actuelle du serveur. Les anciennes clés conservent "model": "node-locked" ; les clés renouvelées et nouvelles reçoivent "model": "floating".
Étape 1 : diffuser un SDK qui parle les deux
Le premier livrable est un client qui lit le claim et aiguille. C’est la pièce qui doit atteindre le terrain avant tout changement de clé, car c’est la seule version qui ne cassera pas lorsqu’elle rencontrera une clé flottante.
public async Task<SeatResult> AcquireAsync(CancellationToken ct = default)
{
LicenseClaims claims = _verifier.Verify(_storedKey); // Ed25519 check, fully local
if (!claims.IsValid)
return SeatResult.Invalid;
return claims.Seat.Model switch
{
SeatModel.NodeLocked => BindToMachine(claims), // legacy path, untouched
SeatModel.Floating => await ClaimFloatingSeatAsync(claims, ct),
_ => SeatResult.Invalid, // unknown model: fail closed
};
}
La branche liée est le code que vous diffusez déjà, inchangé. La branche flottante réclame un siège puis le conserve en renouvelant à la moitié du TTL de la licence, de sorte qu’un heartbeat manqué dispose encore d’une tentative avant que le siège soit récupéré.
async Task<SeatResult> ClaimFloatingSeatAsync(LicenseClaims claims, CancellationToken ct)
{
SeatGrant seat = await _service.ClaimSeatAsync(claims.LicenseId, _fingerprint, ct);
if (seat.Status == SeatStatus.PoolExhausted)
return SeatResult.Denied("all seats in use");
var half = claims.Seat.LeaseTtl / 2;
_heartbeat = new Timer(_ => _ = _service.RenewSeatAsync(seat.Token, ct), null, half, half);
return SeatResult.Granted(seat.Token, seat.ExpiresAtUtc);
}
Surtout, ce SDK est correct face aux deux types de clé. Un client qui met à jour aujourd’hui continue de fonctionner sur sa clé liée sans aucun changement de comportement. C’est ce qui rend la bascule sûre : la migration du SDK et la migration des clés sont découplées.
Étape 2 : réconcilier chaque machine au passage
C’est ici qu’une bascule naïve compte deux fois. Une machine qui détient déjà une activation liée puis réclame son premier siège flottant occuperait deux unités de capacité : une ancienne activation que le pool ne voit pas, plus un siège actif. Sur une flotte entière, cela survend silencieusement le plafond et commence à refuser des sièges légitimes.
Le correctif vit sur le serveur et doit être atomique. Lors de la première réclamation flottante depuis une empreinte qui détient encore une activation liée sur la même licence, Keyright retire l’activation et émet le siège en une seule transaction.
L’opération côté administrateur est un unique appel idempotent, de sorte qu’une réclamation retentée après une coupure réseau ne convertit pas deux fois :
# Server reconciles on first floating claim; the SDK triggers it transparently.
# To audit a license mid-migration, read its occupancy:
keyright seats show --license KR-7F3A-... --breakdown-by-model
# model=node-locked held=10
# model=floating active=15
# ceiling=25 overcommit=0
Tant que overcommit reste à zéro, le plafond est intact et vous pouvez continuer à convertir au rythme des mises à jour du terrain.
Étape 3 : basculer les clés au renouvellement, pas toutes d’un coup
Vous n’avez pas à migrer tout le monde à une date. Comme le modèle est par clé, la bascule la plus propre suit le cycle de renouvellement : quand une clé liée se renouvelle, frappez le remplacement en flottant. Les flottes ayant pleinement adopté le SDK bimode peuvent être basculées en bloc ; le reste se convertit naturellement à l’échéance de son terme.
keyright license reissue --license KR-7F3A-... \
--seat-model floating --seat-max 25 --lease-ttl 00:05:00
Le client récupère le nouveau modèle à sa prochaine actualisation de licence et appelle AcquireAsync par la branche flottante : sans réinstallation, sans ressaisie de clé, sans ticket de support.
Mises en garde : là où ça fait mal
L’ordre n’est pas négociable. Si une clé flottante atteint une machine qui exécute encore l’ancien SDK à modèle unique, ce client rencontre un modèle inconnu et — s’il n’a pas été écrit pour échouer fermé sur la branche liée — peut mal se comporter. Diffusez et confirmez la télémétrie d’adoption du SDK avant de réémettre une seule clé. Le claim du siège permet aux deux modèles de coexister précisément pour que vous puissiez attendre.
Un plantage conserve un siège jusqu’à l’expiration de la licence. La capacité flottante n’est récupérée que lorsque le TTL de la licence expire sans heartbeat ; voyez heartbeat de licence et récupération des baux pour dimensionner le TTL face à votre comportement de fermeture réel. Trop long, et un portable qui se met en veille en pleine session retient un siège ; trop court, et un réseau lent exclut un utilisateur actif.
Les installations hors ligne n’ont pas leur place dans un pool. Le flottant a besoin de l’aller-retour du heartbeat. Gardez les machines réellement isolées du réseau liées avec une fenêtre de grâce hors ligne bornée, et laissez le claim seat.model porter cette distinction par client plutôt que d’imposer un modèle à toute la base.
La réconciliation doit être atomique ou vous survendez. Le retirer-et-accorder doit être une seule transaction munie d’une clé d’idempotence. Faites-le en deux étapes et une réclamation retentée convertit la même machine deux fois, mangeant silencieusement un siège du plafond.
Conclusion
Passer de lié à flottant est une migration, pas un drapeau. Placez le modèle dans un claim seat signé par clé, diffusez un SDK bimode qui aiguille dessus et atteint le terrain en premier, réconciliez l’ancienne activation de chaque machine dans le pool de façon atomique, et basculez les clés au renouvellement. Fait dans cet ordre, le plafond partagé tient à chaque étape et aucun client ne remarque jamais que le modèle a changé sous lui. La Community Edition de Keyright exécute le chemin lié gratuitement ; les pools flottants et la réconciliation des modèles font partie des niveaux payants. La recette complète de migration vit dans la documentation Keyright.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.