Skip to content
← Tous les articles
· Delta1 Labs LicensingKeyright

Calculer le pic de licences pour la régularisation

Au renouvellement, vous devez savoir combien de licences flottantes un client a réellement utilisées en même temps — ni le compte du jour, ni la somme de toutes les activations. Cette analyse approfondie dérive le nombre exact du journal d'événements de lease avec une ligne de balayage, traite les leases qui chevauchent la fenêtre de facturation et ceux que le reaper a fermés implicitement, et montre pourquoi un p95 pondéré par le temps facture plus honnêtement que le pic brut.

Un éditeur vend un pool flottant : cinquante licences concurrentes, facturées annuellement, régularisation au renouvellement. Douze mois plus tard, la question sur la facture est trompeusement simple : combien de licences ont-ils réellement utilisées ? Les réponses naïves sont toutes deux fausses. Comptez les licences actives à l’instant même et vous obtenez ce que l’horloge a capté, en général un nombre calme. Additionnez toutes les activations de l’année et vous facturez mille, parce qu’une licence qui tourne entre deux cents utilisateurs ressemble à deux cents licences. Aucune n’est la quantité que le contrat rationne.

Idée clé : Le nombre contre lequel un contrat flottant est écrit est la concurrence maximale — le plus grand ensemble de leases qui ont été ouverts en même temps à un instant quelconque de la fenêtre de facturation. Vous le calculez de façon exacte, non par échantillonnage, avec une ligne de balayage sur le journal d’événements de lease : triez les événements d’acquisition et de libération par temps, parcourez-les en tenant un compteur, et mémorisez le maximum atteint. Les subtilités sont toutes aux bords — les leases qui chevauchent la limite de la fenêtre et ceux que le reaper a fermés implicitement — et un percentile pondéré par le temps facture en général plus honnêtement que le maximum brut.

La vraie question : combien de leases se sont chevauchés ?

Keyright enregistre l’activité des licences flottantes comme un journal de leases. Chaque check-out est une acquisition ; chaque check-in, expiration ou balayage du reaper est une libération. Pour la régularisation, la matière première est une liste d’intervalles — un par lease — chacun avec un début et une fin :

public readonly record struct LeaseInterval(DateTimeOffset Start, DateTimeOffset End);

La concurrence maximale est le nombre maximal de ces intervalles qui se chevauchent en un seul point du temps. Vous pourriez y répondre par échantillonnage — compter les leases actifs chaque minute et prendre le maximum — mais l’échantillonnage rate un pic qui vit entre deux tics, et un client qui conteste une régularisation est exactement le public qui remarquera que vous avez deviné. La réponse exacte est bon marché, alors calculez la réponse exacte.

Le mécanisme : une ligne de balayage sur les événements de lease

L’astuce consiste à cesser de penser en intervalles et à penser en événements. Chaque lease en apporte deux : un +1 à son début et un -1 à sa fin. Triez chaque événement par horodatage, parcourez la liste de gauche à droite en tenant une somme cumulée, et la somme à tout moment est le nombre de leases ouverts à ce moment. La plus grande valeur que la somme atteint est le pic.

Cinq leases sur la fenêtre de facturation → pic de concurrence = 4lease Alease Blease Clease Dlease E01234pic = 4JanDécUne libération au même instant qu'une acquisition est triée avant, donc une licence passée directement d'un utilisateur à un autre compte pour une, pas deux.
La ligne de balayage. La courbe en escalier est le compte cumulé de leases ; son maximum — quatre, là où les leases A, B, C et D se chevauchent — est la concurrence maximale contre laquelle facture la régularisation.

Deux détails rendent le parcours correct. D’abord, écrêtez chaque lease à la fenêtre de facturation avant d’émettre ses événements : un lease qui a commencé à la période précédente occupe encore une licence le 1er janvier, et un lease toujours ouvert en fin d’année en occupe une jusqu’au 31 décembre. Ensuite, quand une libération et une acquisition tombent au même instant, traitez d’abord la libération ; sinon, une licence passée directement d’un utilisateur à un autre se lit comme deux leases qui se chevauchent pendant un tic.

public static int PeakConcurrency(
    IEnumerable<LeaseInterval> leases,
    DateTimeOffset windowStart,
    DateTimeOffset windowEnd)
{
    var events = new List<(DateTimeOffset At, int Delta)>();
    foreach (var l in leases)
    {
        // Clamp to the billing window: a lease open across a boundary
        // still holds a seat for the part that falls inside the period.
        var start = l.Start < windowStart ? windowStart : l.Start;
        var end   = l.End   > windowEnd   ? windowEnd   : l.End;
        if (end <= start) continue;            // no overlap with this window
        events.Add((start, +1));
        events.Add((end,   -1));
    }
    // Ties: -1 (release) before +1 (acquire), so a back-to-back
    // handoff of one seat never reads as two.
    events.Sort((a, b) =>
        a.At != b.At ? a.At.CompareTo(b.At) : a.Delta.CompareTo(b.Delta));

    int current = 0, peak = 0;
    foreach (var e in events)
    {
        current += e.Delta;
        if (current > peak) peak = current;
    }
    return peak;
}

Voilà tout l’algorithme : O(n log n) pour le tri, un passage linéaire, pas d’échantillonnage, et la réponse est exacte. Une année d’un pool de cinquante licences représente au plus quelques centaines de milliers d’événements : des millisecondes.

Le bord qui fait vraiment mal : les leases que le reaper a fermés

Le code ci-dessus suppose que chaque lease a une End propre. Dans un vrai système flottant, beaucoup n’en ont pas. Un portable qui se met en veille, un processus tué, un conteneur évincé : aucun n’envoie de check-in. Le lease cesse simplement d’émettre des heartbeats, et le reaper du serveur récupère la licence une fois que le TTL du lease s’écoule sans heartbeat. (Ce mécanisme de reaping est un sujet à part entière ; voir l’article sur le reaping de leases par heartbeat.)

Pour la facturation, un lease récupéré par le reaper n’a pas occupé une licence jusqu’à ce que le reaper s’en aperçoive. Il en a occupé une jusqu’au dernier heartbeat, plus la marge que vous êtes prêt à accorder. Facturer à un client le TTL complet après un processus qui a planté gonflerait chaque pic. Donc la fin effective d’un lease est sa libération explicite s’il en a une et, sinon, son dernier heartbeat plus le TTL :

public static LeaseInterval ToInterval(LeaseRow row, TimeSpan leaseTtl)
{
    DateTimeOffset end = row.ReleasedAt             // clean check-in
        ?? row.LastHeartbeatAt + leaseTtl;          // reaped: held until TTL lapsed
    return new LeaseInterval(row.AcquiredAt, end);
}

Trompez-vous dans le sens généreux et chaque client instable gonfle le pic ; trompez-vous dans le sens avare et vous sous-facturez l’usage réel. Le TTL que vous avez déjà choisi pour le reaping est la réponse défendable : c’est la fenêtre pendant laquelle le serveur a véritablement considéré la licence comme prise.

Facturer sur le p95, pas sur le pic brut

Le pic absolu est honnête mais fragile. Une réunion générale où trois prestataires se sont connectés pendant cinq minutes peut pousser un client de cinquante licences à cinquante-trois, et facturer une augmentation permanente de trois licences sur une pointe de cinq minutes est une discussion de renouvellement que vous perdrez. Un percentile pondéré par le temps facture sur la demande soutenue plutôt que sur le pire instant.

Calculez-le à partir du même flux d’événements. Parcourez les événements triés et, pour chaque écart entre événements consécutifs, accumulez la durée de l’écart dans un bucket indexé par le niveau de concurrence pendant cet écart. Vous obtenez « secondes passées à chaque niveau », et le p95 est le niveau le plus bas sous lequel 95 % du temps de la fenêtre s’accumule :

public static int PercentileConcurrency(
    IReadOnlyList<(DateTimeOffset At, int Delta)> sortedEvents,
    double percentile)
{
    var secondsAtLevel = new SortedDictionary<int, double>();
    int current = 0;
    for (int i = 0; i + 1 < sortedEvents.Count; i++)
    {
        current += sortedEvents[i].Delta;
        double seconds = (sortedEvents[i + 1].At - sortedEvents[i].At).TotalSeconds;
        if (seconds > 0)
        {
            secondsAtLevel.TryGetValue(current, out var acc);
            secondsAtLevel[current] = acc + seconds;
        }
    }
    double total  = secondsAtLevel.Values.Sum();
    double cutoff  = total * percentile;
    double running = 0;
    foreach (var (level, seconds) in secondsAtLevel)   // ascending
    {
        running += seconds;
        if (running >= cutoff) return level;
    }
    return secondsAtLevel.Count == 0 ? 0 : secondsAtLevel.Keys.Max();
}

Rapportez les deux. Le p95 ancre la régularisation ; le pic brut est le plafond honnête que vous gardez au dossier au cas où un client demanderait à quoi ressemblait l’instant de plus forte activité.

Tirer le rapport

Rien de tout cela n’est quelque chose que le client devrait assembler à la main. Keyright expose l’historique des leases via l’API d’administration, et la CLI enveloppe la ligne de balayage pour qu’un opérateur obtienne les chiffres finis :

keyright report seats \
  --product acme-suite \
  --from 2026-01-01 --to 2026-12-31 \
  --metric peak,p95 --tz America/New_York
{
  "product": "acme-suite",
  "window": { "from": "2026-01-01", "to": "2026-12-31" },
  "entitled": 50,
  "peak": 53,
  "p95": 47,
  "peakAt": "2026-09-18T14:32:07-04:00",
  "overageBasis": "p95"
}

Le flag --tz compte plus qu’il n’y paraît : « la concurrence maximale pendant l’année de facturation » est bornée par le minuit-à-minuit local du client, et la calculer en UTC étale son 31 décembre sur deux de vos jours. Résolvez la fenêtre dans le fuseau horaire du client, puis écrêtez.

Mises en garde

Flottant uniquement. Ceci mesure la concurrence, qui n’a de sens que pour un pool flottant. Un droit utilisateur nommé facture sur des identités distinctes au cours de la période — un COUNT(DISTINCT user), pas un balayage — et une licence verrouillée sur nœud facture sur des machines liées. Exécutez la bonne requête pour le modèle de licence ; la ligne de balayage répond spécifiquement à la question flottante.

Confiance dans l’horloge entre nœuds. Dans un déploiement multi-nœuds, les horodatages des leases viennent du nœud qui a servi le heartbeat. Quelques secondes de décalage entre nœuds ne déplaceront pas un pic soutenu pendant des minutes, mais peuvent créer ou effacer un chevauchement fantôme d’une seconde. Facturez sur le p95, qui est immunisé contre un artefact d’un seul tic, et traitez le pic brut comme indicatif plutôt que comme ligne de facture.

Le TTL du lease récupéré est une politique, pas un fait. La fin effective d’un lease planté est un choix : dernier heartbeat plus TTL. C’est défendable parce que le serveur a traité la licence comme prise pendant exactement ce laps, mais cela reste votre politique, alors documentez-la dans le contrat. Un client qui voit « pic 53 » devrait pouvoir apprendre qu’un lease récupéré compte jusqu’à ce que son TTL s’écoule.

Le rapport ne vaut que le journal. Si des heartbeats sont perdus ou des événements de lease supprimés, la ligne de balayage calcule le pic de ce qu’elle a, pas de ce qui s’est passé. Des événements de lease durables et ordonnés sont la fondation ; l’arithmétique par-dessus est la partie facile.

À retenir

La régularisation de licences flottantes n’est ni un instantané ni une somme — c’est le chevauchement maximal des intervalles de lease sur la fenêtre de facturation, et vous l’obtenez de façon exacte avec une ligne de balayage : émettez un +1 et un -1 par lease, écrêtez à la fenêtre, triez avec les libérations avant les acquisitions et suivez le maximum cumulé. Fermez les leases récupérés par le reaper à leur dernier heartbeat plus le TTL pour qu’un client planté ne gonfle pas la facture, ancrez la facture sur un p95 pondéré par le temps plutôt que sur un pic fragile d’un seul instant, et résolvez la fenêtre dans le fuseau horaire propre du client. Keyright conserve l’historique des leases et fournit la commande report seats pour que le nombre soit défendable avant même d’atteindre une facture ; la Community Edition est gratuite et auto-hébergée, vous pouvez donc modéliser un pool flottant et lire son rapport de régularisation de bout en bout avant de vous engager. Toute la surface de l’API d’administration est dans la documentation de Keyright.

Essayez Nebula.NET

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