Skip to content
← Tous les articles
· Delta1 Labs LicensingKeyright

Sièges par utilisateur nommé contre par appareil dans Keyright

Un siège peut désigner une machine ou une personne, et les deux ne se comptent pas pareil. Voici comment lier, appliquer et réconcilier les sièges par appareil et par utilisateur nommé dans Keyright sans survendre ni bloquer des clients qui paient.

La plupart des bugs de licence ne sont pas cryptographiques. Ce sont des erreurs de comptage : vous avez vendu « cinq sièges » en pensant cinq personnes, et votre application compte cinq machines, si bien que l’ingénieur avant-vente qui fait aussi tourner l’appli sur un portable et une VM consomme à lui seul trois des cinq sièges. Personne n’a rien attaqué. La licence compte simplement un substantif différent de celui du bon de commande.

Keyright permet à un siège de désigner l’un ou l’autre substantif. Cet article explique comment choisir délibérément entre les deux, lier une activation à la bonne dimension, appliquer le plafond contre elle et — la partie qui fait trébucher les équipes — réconcilier les deux modèles quand il faut passer de l’un à l’autre sans bloquer des clients qui n’ont rien fait de mal.

Deux choses qu’un siège peut désigner

Un siège est une unité de droit concurrent. La seule vraie question est ce qui en consomme un.

Sièges par appareil

Un siège par appareil est lié à une machine. Le SDK calcule une empreinte de la machine stable à l’activation, le service émetteur l’enregistre, et le plafond de sièges de la licence est appliqué contre le nombre d’empreintes distinctes. Cinq sièges par appareil, c’est au plus cinq machines détenant une activation vivante en même temps. C’est le bon modèle pour les postes partagés, les bornes, les agents de build et tout cas où « qui est assis là » n’a pas d’importance : vous licenciez l’installation, pas l’humain.

Le mode de défaillance, c’est l’utilisateur avancé avec trois appareils. En sièges par appareil, il compte pour trois sièges, et si votre grille tarifaire disait « par utilisateur », il vous manque désormais deux sièges pour le même prix.

Sièges par utilisateur nommé

Un siège par utilisateur nommé est lié à une identité — un e-mail, un sujet SSO, un identifiant d’employé — portée dans l’activation sous forme de référence utilisateur stable. Le plafond de sièges est appliqué contre le nombre d’identités distinctes, et chaque identité peut activer sur autant de ses propres appareils que la licence l’autorise. Cinq sièges par utilisateur nommé, c’est cinq personnes, chacune sur son portable, son poste fixe et sa VM, sans surcoût. Cela correspond à la manière dont la plupart des logiciels B2B sont réellement vendus.

Son mode de défaillance, c’est l’identifiant partagé : si dix personnes activent sous un même ops@acme.example, vous comptez un siège et en perdez neuf. Les sièges par utilisateur nommé ne sont honnêtes que lorsque l’identité est une que le client ne peut pas partager facilement : un sujet SSO, pas une boîte mail partagée.

Sièges par appareilSièges par utilisateur nomméportableposte fixeVM1 siège1 siège1 siège3 sièges utiliséscompte les machines : un utilisateur,trois empreintes, trois siègesportableposte fixeVMalice@acme1 siège utilisécompte les personnes : une identité,trois appareils, un siège

Lier une activation à la bonne dimension

Le SDK s’initialise de la même façon pour les deux modèles ; la différence est ce que vous attachez à l’activation. Pour un déploiement auto-hébergé, vous pointez le client vers votre service émetteur et épinglez la clé publique avec laquelle les licences sont signées :

var keyright = new KeyrightClient(new KeyrightOptions
{
    Product         = "acme-suite",
    PublicKeyBase64 = EmbeddedPublicKey,                 // épingle à qui vous faites confiance pour signer
    ServiceUrl      = "https://license.acme.example"     // votre instance auto-hébergée
});

Pour un produit à sièges par appareil, vous activez avec la seule empreinte de la machine. Le SDK la dérive de signaux stables du matériel et du système ; vous ne la calculez pas à la main.

// Ancré à l'appareil : le siège est la machine. Aucune identité n'est envoyée.
var result = await keyright.ActivateAsync(licenseKey);
if (result.Status == ActivationStatus.SeatsExhausted)
    ShowUpgradePrompt(result.SeatsUsed, result.SeatCeiling);

Pour un produit à utilisateur nommé, vous passez en plus une référence utilisateur stable. Faites-en l’identité la plus résistante à la falsification dont vous disposez : un sujet SSO (claim sub) est idéal, car l’IdP du client lui-même la garantit et un utilisateur ne peut pas en fabriquer une seconde pour contourner le comptage.

// Utilisateur nommé : le siège est la personne. L'empreinte voyage toujours pour les limites d'appareils.
var result = await keyright.ActivateAsync(licenseKey, new ActivationContext
{
    UserRef = currentUser.Subject                        // p. ex. le claim « sub » d'OIDC
});

L’empreinte accompagne toujours une activation par utilisateur nommé, et c’est ce qui vous permet de plafonner les appareils par utilisateur (par exemple « utilisateur nommé, jusqu’à 5 appareils chacun ») : un second plafond que le service émetteur applique indépendamment du comptage des utilisateurs. Envoyer les deux liaisons à chaque activation est aussi ce qui rend indolore la migration ci-dessous : une activation qui porte les deux peut être comptée dans un sens comme dans l’autre.

Appliquer le plafond au bon endroit

Le comptage des sièges est une décision côté serveur — on ne peut pas faire confiance à un client pour compter sa propre population — mais l’application sous licence doit tout de même restreindre les fonctionnalités localement et échouer en mode fermé. Les deux tâches se séparent nettement.

Le service émetteur est propriétaire du comptage. Lorsqu’une activation arrive, il projette la requête sur la dimension configurée de la licence et la compare au plafond. En pseudo-code, la règle est la même pour les deux modèles ; seule la clé change :

// À l'intérieur du service émetteur, simplifié.
string seatKey = license.SeatModel switch
{
    SeatModel.Device    => request.Fingerprint,          // un siège par machine
    SeatModel.NamedUser => request.UserRef               // un siège par identité
        ?? throw new MissingUserRefException(),          // l'utilisateur nommé exige une identité
    _ => throw new UnreachableException()
};

var distinct = await _seats.CountDistinctAsync(license.Id, license.SeatModel);
bool alreadyHeld = await _seats.HoldsAsync(license.Id, seatKey);
if (!alreadyHeld && distinct >= license.SeatCeiling)
    return ActivationResult.SeatsExhausted(distinct, license.SeatCeiling);

await _seats.UpsertAsync(license.Id, seatKey, request.Fingerprint);

Remarquez que réactiver une identité (ou une machine) qui détient déjà un siège est idempotent : alreadyHeld court-circuite la vérification du plafond, de sorte qu’Alice ajoutant son troisième portable en sièges par utilisateur nommé ne déclenche jamais « sièges épuisés », tandis qu’une sixième personne distincte, si.

L’application, elle, ne compte jamais rien. Elle valide la licence signée qu’elle détient et restreint selon les droits, en échouant en mode fermé, afin qu’une coupure réseau ne débloque jamais silencieusement une fonctionnalité :

var info = await keyright.ValidateAsync();
if (!info.IsValid || !info.Entitlements.Has("reporting"))
    throw new FeatureLockedException("reporting");       // local, sûr hors ligne, à chaque fois

Réconcilier des sièges par appareil en sièges par utilisateur nommé

La migration difficile va de l’appareil vers l’utilisateur nommé, car les comptages ne sont pas interchangeables et un basculement négligent, soit survend (vous accordez un siège par appareil, désormais gratuit), soit bloque (vous accordez un siège par utilisateur mais certains utilisateurs dépassent soudain leur ancien nombre d’appareils). Le chemin sûr est en trois étapes ordonnées, et la première vous fait gagner du temps.

1. Commencez à porter l’identité avant de changer de modèle. Livrez une version qui envoie UserRef à l’activation pendant que la licence compte encore les appareils. Rien ne change pour le client, mais chaque nouvelle activation enregistre désormais quelle personne possède chaque machine. Laissez reposer jusqu’à ce que la plupart des activations vivantes portent une identité.

2. Réconciliez, puis dimensionnez la nouvelle licence. Regroupez les activations d’appareils enregistrées par leur UserRef. Chaque groupe est un futur siège par utilisateur nommé ; la taille du groupe vous indique combien d’appareils cet utilisateur fait tourner. Le nombre de groupes est le nombre de sièges par utilisateur nommé dont le client a réellement besoin — qui est presque toujours inférieur à son nombre d’appareils, et c’est l’argument de vente du changement.

// Fusionne les activations d'appareils en sièges par utilisateur nommé.
var seatsNeeded = activations
    .Where(a => a.UserRef is not null)
    .GroupBy(a => a.UserRef)
    .Select(g => new NamedUserSeat(g.Key!, devices: g.Count()))
    .ToList();

int newCeiling = seatsNeeded.Count;                      // des personnes, pas des machines
int maxDevices = seatsNeeded.Max(s => s.Devices);        // dimensionne le plafond d'appareils par utilisateur

3. Émettez une nouvelle licence qui compte les utilisateurs, dimensionnée selon la réconciliation. Fixez le plafond à newCeiling (plus la marge que vous vendez) et le plafond d’appareils par utilisateur à au moins maxDevices, pour qu’aucun utilisateur existant ne se retrouve rétroactivement au-dessus de la limite. Comme les applications sur le terrain valident contre la licence signée qu’elles recevront, le basculement leur est invisible : elles continuent de tourner, le service émetteur se met simplement à compter un substantif différent. Les activations qui n’ont jamais rapporté de UserRef sont votre liste de nettoyage : des machines obsolètes à laisser expirer, ou des utilisateurs à relancer pour une identité.

La migration inverse, d’utilisateur nommé vers appareil, est plus simple et rarement souhaitée : chaque empreinte distincte déjà présente devient un siège par appareil, vous n’avez donc besoin que d’un plafond au moins égal au nombre actuel d’appareils distincts.

Choisissez le substantif, puis comptez-le

Tout cela se résume à une discipline : décidez si un siège est une machine ou une personne avant de tarifer la licence, liez l’activation exactement à ce substantif, et laissez le service émetteur compter cette unique dimension. Sièges par appareil pour les installations, sièges par utilisateur nommé pour les personnes, et une identité impossible à partager lorsqu’il s’agit de personnes. Portez les deux liaisons à chaque activation et le modèle devient un réglage côté serveur que vous pouvez changer — avec une passe de réconciliation — au lieu d’une décision figée dans votre population de terrain.

Les deux modèles de siège fonctionnent sur Keyright auto-hébergé, y compris la Community Edition gratuite pour un seul produit et un nombre modeste de licences ; les flottes multiproduits et les pools de sièges plus grands sont une mise à niveau vers une self-license payante. Dans tous les cas, la règle de comptage est la même, et la seule chose qui finit par bloquer un client qui paie, c’est de lier un siège au mauvais substantif.

Essayez Nebula.NET

Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.