Skip to content
← Tous les articles
· Delta1 Labs ReliabilityKeyright

Verrouillage optimiste pour l'activation concurrente de licences

Deux machines réclament le siège final à la même milliseconde. Un naïf lire-compter-écrire les laisse entrer toutes les deux et survend la licence. Voici comment la concurrence optimiste transforme la réclamation de siège en un compare-and-swap, et comment le SDK gère le 409.

La plupart du temps, réclamer un siège est ennuyeux. Un client demande un siège au service émetteur, le service vérifie que le pool n”est pas plein, enregistre la réclamation et répond oui. Le cas intéressant est celui qui survient exactement à 9 h 00 au début d”une équipe : deux cents machines se réveillent et demandent un siège dans les mêmes quelques millisecondes, et il reste un siège au pool. Qui l”obtient ?

Si vous construisez la réclamation de siège de la manière évidente — lire le compteur actuel, vérifier qu”il est sous la limite, écrire le compteur incrémenté — alors, sous cette rafale, les deux machines qui courent pour le dernier siège lisent « 24 sur 25 utilisés », toutes deux décident qu”il y a de la place, et toutes deux écrivent « 25 ». Vous avez vendu 26 sièges sur une licence de 25. Le client est désormais hors conformité sans aucune faute de sa part, et vous ne l”apprenez que lorsque le 26e utilisateur appelle le support. C”est le problème du dernier siège, et ce n”est pas un bug spécifique à Keyright : c”est la classique course à la mise à jour perdue, appliquée à un pool de licences.

Cet article porte sur le mécanisme qui le rend impossible : la concurrence optimiste. La réclamation de siège n”est pas une lecture suivie d”une écriture. C”est une unique écriture conditionnelle — un compare-and-swap sur un jeton de version — qui soit gagne proprement, soit est rejetée proprement, sans état intermédiaire où deux clients croiraient tous deux avoir gagné.

La course, dessinée

Imaginez deux clients, A et B, tous deux détenteurs d”une clé de licence valide, atteignant tous deux le service émetteur au même instant avec un siège libre.

Client A Service émetteur Client B used=24 v=57 lire : 24/25, v=57 lire : 24/25, v=57 calculer 25 calculer 25 écrire 25 si v==57 accepté → v=58 200 OK, siège accordé écrire 25 si v==57 v vaut 58 → rejeter 409 conflit → réessayer

Les deux clients lisent le même état : 24 sièges utilisés sur 25, transporté avec un jeton de version — ici, v=57. Ce jeton est toute l”astuce. C”est une valeur opaque que le service émetteur attache à l”état actuel du pool de sièges, et elle change chaque fois que le pool change. Lorsqu”un client renvoie sa réclamation, il inclut la version qu”il a lue, et le service accepte l”écriture seulement si la version est toujours 57. L”écriture du Client A arrive en premier, le compteur passe à 25, et la version avance à 58. La réclamation du Client B arrive un instant plus tard en portant v=57 — mais le pool est déjà à v=58, donc la condition échoue et l”écriture est rejetée avant de pouvoir toucher le compteur. B n”a jamais obtenu de siège ; le compteur n”a jamais dépassé 25.

Ce que voit le client

La décision de conception importante est que le rejet de B n”est pas la même chose que le pool étant plein. C”est un conflit de concurrence — un signal que B a perdu une course et devrait regarder à nouveau, parce que l”état sur lequel il a décidé est périmé. Keyright l”expose comme une ConcurrencyConflictException distincte (HTTP 409 avec un problem-type de conflit), séparée de SeatsExhaustedException, et le SDK la réessaie pour vous.

var client = KeyrightClient.Initialize(new KeyrightOptions
{
    Product         = "acme-studio",
    PublicKeyBase64 = config["Keyright:PublicKey"],   // verify-only, not a secret
    ServiceUrl      = config["Keyright:ServiceUrl"],   // your self-hosted instance
});

try
{
    // AcquireSeatAsync retries a concurrency conflict internally,
    // re-reading the version each time, with bounded jittered backoff.
    SeatLease lease = await client.AcquireSeatAsync(userKey);
    EnableLicensedFeatures(lease);
}
catch (SeatsExhaustedException)
{
    // Definitive: the pool really is full after the race settled.
    ShowAllSeatsInUse();
}

Remarquez ce que vous n”écrivez pas : pas de verrou, pas de transaction, pas de boucle de nouvelle tentative pour le cas du conflit. Le compare-and-swap vit côté serveur et la nouvelle tentative est à l”intérieur de AcquireSeatAsync. Le seul échec que vous gérez vous-même est l”échec véritable — le pool étant plein — que vous présentez à l”utilisateur et sur lequel vous échouez en mode fermé.

Si vous pilotez l”API HTTP directement plutôt que via le SDK, le conflit est visible sur le fil, et le contrat est simple : réessayer sur 409 conflict, présenter 409 seats-exhausted à l”utilisateur.

POST /v1/seats/acquire HTTP/1.1
Host: license.internal.acme.example
Content-Type: application/json

{ "product": "acme-studio", "licenseKey": "ACME-...-9F2C", "machine": "b14c…" }

HTTP/1.1 409 Conflict
Content-Type: application/problem+json

{ "type": "https://keyright/problems/concurrency-conflict",
  "title": "Seat state changed during the claim",
  "status": 409, "retryable": true }

L”indice retryable est le seul champ sur lequel votre propre politique de nouvelle tentative devrait se brancher. Un concurrency-conflict est réessayable ; un seats-exhausted ne l”est pas. Les traiter de la même manière est l”erreur habituelle : soit vous réessayez un pool plein inutilement et martelez le service, soit vous abandonnez sur un conflit et dites à tort à un utilisateur légitime que la licence est pleine alors qu”un siège était libre depuis le début.

Pourquoi optimiste, pas pessimiste

L”alternative évidente est un verrou pessimiste : prendre un verrou exclusif sur le pool de sièges, faire le lire-vérifier-écrire à l”intérieur, relâcher. C”est correct, mais cela sérialise chaque activation d”un produit à travers une seule porte. La rafale de 9 h 00 qui a motivé toute cette conception mettrait alors deux cents activations en file l”une derrière l”autre, et le dernier artiste à démarrer attendrait tous les autres. Vous auriez échangé un bug de correction contre un bug de latence.

La concurrence optimiste inverse le pari. Elle suppose que les collisions sont rares — ce qu”elles sont, à l”échelle d”un pool de sièges — et laisse chaque réclamation avancer en parallèle sans aucun verrou. Le seul coût est payé par les réclamations qui entrent réellement en collision sur la même version, et ce coût est une relecture et une nouvelle tentative peu coûteuses. Sous la rafale, la grande majorité des réclamations touchent des compteurs de sièges différents (parce que les gagnants continuent de faire avancer la version) et passent du premier coup ; seule la poignée qui se dispute exactement le même siège final finit par réessayer. Vous obtenez un débit sans verrou pour le cas courant et une écriture sérialisée, à l”épreuve de la survente, pour le cas disputé.

La garantie mérite d”être énoncée clairement, car c”est la raison pour laquelle tout le schéma est sûr : aucune séquence de réclamations concurrentes ne peut pousser le compteur au-delà de la limite. Chaque incrément est conditionné à la version à partir de laquelle il a été calculé, de sorte que deux incréments ne peuvent jamais s”appliquer tous deux au même compteur de départ. L”un gagne et fait avancer la version ; l”autre est rejeté et doit repartir du nouveau compteur — moment où il verra correctement que le pool est plein et obtiendra une SeatsExhaustedException.

À retenir

  • La réclamation de siège est un compare-and-swap sur un jeton de version, pas un lire-puis-écrire — de sorte que deux clients courant pour le dernier siège ne peuvent jamais gagner tous les deux.
  • Une ConcurrencyConflictException (409 conflict, retryable: true) signifie « relis et réessaie », et le SDK la gère pour vous ; SeatsExhaustedException signifie « réellement plein », et vous échouez en mode fermé.
  • Branchez votre propre politique de nouvelle tentative sur l”indice retryable : ne réessayez jamais un pool plein, réessayez toujours un conflit.
  • La concurrence optimiste maintient les activations en parallèle et ne paie un coût que lorsque les réclamations entrent réellement en collision, de sorte qu”une rafale de changement d”équipe ne se sérialise pas derrière un seul verrou.

Un comptage de sièges correct ne consiste pas à compter avec soin. Il consiste à rendre l”incrément atomique, de sorte qu”il n”y ait aucune fenêtre dans laquelle deux clients pourraient croire tous deux que le dernier siège est le leur. Keyright le fait avec un jeton de version et une écriture conditionnelle, et laisse votre client sans rien d”autre à faire que distinguer un pool plein d”une course perdue.

Essayez Nebula.NET

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