Skip to content
← Tous les articles
· Delta1 Labs LicensingKeyright

Des sièges flottants qui se libèrent quand un client plante

Comment un déploiement Keyright auto-hébergé distribue un nombre borné de sièges concurrents, maintient chacun en vie par des battements de cœur périodiques et récupère le siège d'un client mort sans l'avoir rendu — y compris les vraies courses à la limite du plafond, le décalage d'horloge sur l'expiration du bail et l'ordre entre battement et libération, avec le C# qu'exécutent le SDK et le service d'émission.

Une licence flottante est une promesse avec un trou. Vous vendez dix sièges concurrents, le SDK fait consciencieusement un checkout d”un siège au démarrage de l”application, et tout marche jusqu”au jour où un processus client est tué — coupure de courant, forçage de fermeture, conteneur évincé en pleine tâche — sans jamais dire au serveur qu”il avait terminé. Le siège qu”il détenait est désormais un fantôme : comptabilisé contre votre plafond, revendiqué par personne, et impossible à distinguer d”un vrai utilisateur qui s”est simplement absenté. Ne faites rien et votre licence de dix sièges s”affame peu à peu à mesure que les fantômes s”accumulent. Récupérez trop avidement et vous arrachez un siège à quelqu”un dont le portable a seulement dormi quatre-vingt-dix secondes.

La vraie question est de savoir comment un service d”émission distribue un nombre borné de sièges et récupère sans danger les morts, sans connexion persistante à chaque client et sans jamais laisser le compte vivant dépasser le plafond. Keyright le fait avec un bail : un siège n”est pas un drapeau que l”on lève et abaisse, c”est une concession de courte vie dotée d”une échéance, maintenue en vie par des battements et récupérée par expiration. Ce seul choix de conception transforme une question sans réponse — ce client est-il encore vivant ? — en une question qui en a une — ce bail a-t-il été renouvelé assez récemment ? Cet article explique comment fonctionne le cycle de vie du bail, et où se cachent les courses.

Un siège est un bail, pas un drapeau

Le modèle naïf stocke un booléen par siège et un compte. Le checkout bascule un bit et incrémente ; la libération le rebascule. Il échoue dès qu”un client meurt sans libérer, parce que le bit reste levé pour toujours. Il n”y a aucun moyen borné de récupérer, seulement des heuristiques fausses dans les deux sens.

Le modèle de bail stocke, pour chaque siège actif, un petit enregistrement doté d”une échéance :

{
  "leaseId": "lease_7e2a9c",
  "licenseId": "KR-9QX2-7F3M",
  "seatHolder": "host-7e2a9c:pid-4821",
  "issuedAt": "2026-11-21T09:12:04.118Z",
  "expiresAt": "2026-11-21T09:14:04.118Z",
  "renewals": 0
}

Un siège est vivant si et seulement s”il existe un bail pour lui et que now() précède son expiresAt, tel qu”en juge l”horloge du service. Voilà toute la définition. Un client planté cesse de renouveler ; son expiresAt glisse dans le passé ; le siège devient récupérable sans aucune détection spéciale de plantage nulle part. L”échéance fait le travail qu”une vérification de présence par battement ne pourrait jamais faire, parce qu”elle n”a besoin d”aucun second message pour confirmer la mort — l”absence de renouvellement est le signal.

DISPONIBLE count < cap DÉTENU now < expiresAt RENOUVELLEMENT le battement étend RÉCUPÉRÉ siège libéré checkout renouveler ⟳ libérer expiration (sans battement) un siège récupéré revient au pool disponible — un client mort prend l''arête d''expiration pointillée, pas celle de libérer
La machine à états du bail. Une sortie propre prend l''arête pleine libérer ; un client planté prend l''arête pointillée expiration — même destination, sans détection de plantage.

Le checkout, et la course à la limite du plafond

Le checkout est l”endroit où la justesse se gagne ou se perd. La tentation est de l”écrire en deux étapes : compter les baux vivants, et s”il est sous le plafond, en insérer un nouveau. C”est un bug de type temps-de-vérification-à-temps-d”usage, cas d”école. Deux clients lisent tous deux « neuf vivants » et insèrent tous deux le dixième — il y a maintenant onze sièges détenus contre un plafond de dix.

L”appel du SDK est délibérément simple ; toute la logique dure vit sur le service :

using Keyright.Client;

var seats = new SeatClient(new SeatClientOptions
{
    ServiceUri = new Uri("https://licensing.internal.acme.example"),
    LicenseKey = licenseKey,
    SeatHolder = SeatHolder.ForThisProcess(), // host + pid + boot id
});

// Blocks only on the round-trip; throws SeatCapReachedException on 409.
await using SeatLease lease = await seats.CheckoutAsync(cancellationToken);

// The lease keeps itself alive in the background until disposed.
RunApplication();

Sur le service, le checkout est une unique écriture conditionnelle atomique. Elle n”insère le bail que si le nombre de baux vivants pour cette licence est encore sous le plafond à l”instant de l”écriture — le compte et l”insertion sont une opération indivisible, pas deux. Exprimé comme le prédicat que la couche de stockage impose :

// Service-side. Runs as ONE atomic operation, serialised per licenseId.
public CheckoutResult Checkout(string licenseId, SeatHolder holder, int cap, TimeSpan ttl)
{
    var now = _clock.UtcNow;

    // Count only leases that are still live by the SERVICE clock.
    // Expired leases do not count — they are reclaimed implicitly here.
    int liveCount = _leases.CountWhere(licenseId, l => l.ExpiresAt > now);

    if (liveCount >= cap)
        return CheckoutResult.CapReached(liveCount, cap);

    var lease = new Lease
    {
        LeaseId   = LeaseId.New(),
        LicenseId = licenseId,
        Holder    = holder,
        IssuedAt  = now,
        ExpiresAt = now + ttl,
    };

    // Commit succeeds ONLY IF liveCount is still < cap at write time.
    // If a racing writer committed first, this returns Conflict and we retry.
    return _leases.InsertIfLiveCountBelow(lease, cap, now)
        ? CheckoutResult.Granted(lease)
        : CheckoutResult.CapReached(cap, cap);
}

La ligne qui porte le poids est InsertIfLiveCountBelow. C”est un compare-and-set : l”écriture n”est acceptée que si le prédicat de compte vivant auquel elle était conditionnée tient toujours au moment du commit. Quand deux requêtes font la course pour le dernier siège, la couche de stockage les ordonne. La première voit neuf vivants et valide le dixième. La seconde est évaluée contre l”état désormais validé, en voit dix, et est rejetée. Le perdant reçoit un résultat CapReached et ne reçoit jamais de jeton de bail — donc il ne croit jamais détenir un siège. Remarquez que les baux expirés sont exclus de liveCount, ce qui signifie que chaque checkout effectue aussi une récupération implicite : le fantôme d”un client planté ne compte pas contre le plafond dès l”instant où son échéance est passée.

client A client B cap = 10 · live = 9 avant la course checkout checkout écriture atomique sérialisée par licence accordé (siège 10) 409 plafond atteint
À la limite du plafond, les deux checkouts s''effondrent en une écriture sérialisée. L''un valide le dernier siège ; l''autre est évalué contre l''état validé et rejeté — il n''existe aucune fenêtre où les deux réussissent.

Les battements, et pourquoi ils sont conditionnels

Une fois accordé, le bail doit être maintenu en vie. Le SeatLease que renvoie CheckoutAsync possède une boucle d”arrière-plan qui renouvelle le bail à une fraction du TTL — par défaut tous les tiers du chemin, de sorte qu”un bail de deux minutes est renouvelé à peu près toutes les quarante secondes. Renouveler tôt n”est pas du gaspillage ; c”est la marge qui absorbe une minuterie lente, une requête retardée ou un renouvellement perdu sans que le bail ne lapse jamais vraiment.

La propriété critique est qu”un battement est conditionnel. Ce n”est pas « mets expiresAt à now + TTL pour ce siège » ; c”est « étends ce bail exact s”il est encore vivant ». Le renouvellement porte le leaseId, et le service le refuse si ce bail a disparu :

// Service-side renewal. Conditional on the lease still existing AND being live.
public RenewResult Renew(string leaseId, TimeSpan ttl)
{
    var now = _clock.UtcNow;

    // Atomic: extend only if the lease is present and not yet expired.
    bool extended = _leases.ExtendIfLive(leaseId, newExpiry: now + ttl, now: now);

    return extended
        ? RenewResult.Renewed(now + ttl)
        : RenewResult.Lost; // released, revoked, or already swept
}
// SDK-side loop. A lost renewal is surfaced, never swallowed.
private async Task HeartbeatLoop(CancellationToken ct)
{
    var interval = _ttl / 3;
    while (!ct.IsCancellationRequested)
    {
        await Task.Delay(interval, ct);
        var result = await _transport.RenewAsync(_leaseId, ct);
        if (result.Kind == RenewKind.Lost)
        {
            _lostSeat.TrySetResult(); // application observes SeatLost
            return;                   // stop renewing a seat we no longer hold
        }
        _expiresAt = result.NewExpiry;
    }
}

ExtendIfLive est le pendant de InsertIfLiveCountBelow : un autre compare-and-set, cette fois conditionné à ce que le bail soit présent et non expiré. Il ferme la course de résurrection. Imaginez un renouvellement déjà en vol quand l”application appelle release, ou qu”un administrateur révoque le siège. La libération supprime le bail ; une milliseconde plus tard, le battement en vol arrive. Une « touche » inconditionnelle recréerait allègrement la ligne et pousserait le compte vivant au-dessus du plafond avec un siège que personne n”utilise. Parce que le renouvellement est conditionnel, il ne trouve aucun bail vivant à étendre, renvoie Lost, et le SDK arrête la boucle au lieu de ressusciter un siège mort.

Libération, expiration et l”ordre qui compte

Il y a deux façons pour un siège de revenir. La propre est la libération : await using dispose le SeatLease, qui envoie un dernier appel supprimant le bail et libérant le siège immédiatement — sans attendre une échéance. La coûteuse-mais-sûre est l”expiration : un client qui n”arrive jamais à libérer (parce qu”il a planté) cesse simplement de renouveler, et son bail lapse.

L”expiration est évaluée paresseusement. Le service ne fait pas tourner une minuterie par bail en attente de déclenchement ; il compare now() à expiresAt chaque fois qu”un siège est inspecté — au prochain checkout pour cette licence (où les baux expirés sont exclus du compte, comme ci-dessus) et lors d”un balayage périodique à basse fréquence qui range les lignes abandonnées pour que le magasin ne croisse pas sans borne. L”évaluation paresseuse est ce qui maintient à zéro le coût de dix mille baux inactifs : rien ne se réveille pour un bail que personne ne dispute.

L”ordre qui compte est battement-contre-libération, et la règle est simple : la libération est une suppression, le renouvellement est une extension conditionnelle, et celui que le magasin valide en premier gagne de façon déterministe. Si la libération valide en premier, le battement ultérieur ne trouve aucun bail et renvoie Lost. Si un battement valide en premier, il ne fait que pousser l”échéance d”un TTL — et la libération qui suit supprime quand même le bail entièrement, libérant le siège peu importe de combien l”échéance avait été étendue. Il n”existe aucun entrelacement où un siège finit à la fois libéré et vivant, parce que release ne se soucie pas de l”échéance et le renouvellement ne peut recréer un bail supprimé.

Quand cela casse, honnêtement

Les sièges flottants vous achètent une équité bornée, pas la perfection, et trois limites méritent d”être énoncées clairement.

Premièrement, la fenêtre de récupération est le TTL, et rien ne la raccourcit. Un client planté retient son siège jusqu”à ce que l”échéance passe. Choisir le TTL est un vrai compromis : les TTL courts récupèrent vite les fantômes mais multiplient le trafic de battements et punissent les brèves coupures réseau ; les TTL longs sont doux avec les liens instables mais laissent un client mort squatter plus longtemps. Aucun réglage ne récupère instantanément et ne tolère un portable endormi, parce que ce sont la même incertitude vue de deux côtés.

Deuxièmement, la tolérance hors ligne est bornée par exactement cette fenêtre. Un client qui perd le réseau continue de travailler jusqu”à ce que son bail aurait expiré ; reconnectez à temps et le prochain battement le guérit, ratez la fenêtre et le siège est parti et doit être re-checkouté, ce qui peut échouer si le plafond s”est rempli entre-temps. La licence flottante n”est pas un usage hors ligne illimité — c”est un usage hors ligne borné par le TTL, et c”est sa forme honnête.

Troisièmement, tout cela repose sur l”horloge du service, et seulement l”horloge du service. Le expiresAt du client est indicatif ; chaque décision d”autorisation est le service comparant son propre now() à une échéance qu”il a stockée. C”est ce qui fait du décalage d”horloge client un non-événement — mais cela signifie aussi qu”un service dont la propre horloge saute est la seule chose qui puisse corrompre le minutage du bail, raison pour laquelle l”échéance, le renouvellement et le balayage lisent tous une unique horloge de service monotone plutôt qu”une valeur fournie par un client.

À retenir

L”astuce des sièges flottants est de refuser de répondre à la question sans réponse. Vous ne pouvez pas détecter de façon fiable qu”un client a planté, alors vous n”essayez jamais. Vous distribuez un bail doté d”une échéance, vous le maintenez en vie par des battements conditionnels, et vous laissez l”absence récupérer ce que la mort a laissé. Le plafond tient parce que le checkout est une unique écriture conditionnelle atomique, jamais un lire-puis-écrire ; les sièges ne ressuscitent jamais parce que le renouvellement est conditionné à un bail vivant ; et l”expiration n”a besoin d”aucune détection de plantage parce que le battement manquant est la détection. Configurez le TTL selon votre tolérance aux fantômes face à votre tolérance aux fausses récupérations, câblez le await using du SDK pour que les sorties propres libèrent à l”instant, et les dix sièges que vous avez vendus restent dix — ni plus, ni moins que ceux réellement vivants. Voyez les options de sièges concurrents dans la documentation Keyright et le modèle de licence sur la page produit Keyright.

Essayez Nebula.NET

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