Skip to content
← Tous les articles
· Delta1 Labs PerformanceKeyright

Tests de charge de la vérification de licence avec k6

Vous testez en charge votre tunnel de paiement et votre connexion, mais l'appel qui décide si le logiciel a le droit de s'exécuter — l'activation de licence — rencontre généralement la charge de production pour la première fois lors d'un redémarrage de tout le parc. Ce guide utilise k6 pour mettre la chaîne de vérification sous charge : il sépare la vérification de signature locale et peu coûteuse (qui ne touche jamais le réseau) des appels d'activation et de rafraîchissement (qui, eux, le font), modélise la tempête d'activations qu'un déploiement provoque réellement, définit des seuils de latence p95 et de taux d'échec, et exerce le rafraîchissement conditionnel pour vérifier que la voie rapide 304 tient.

Vous testez en charge les chemins que vous respectez déjà comme critiques : le paiement, la connexion, la barre de recherche. Et puis il y a le seul appel qui décide si le logiciel a le droit de s’exécuter — la vérification de licence — et il ne voit presque jamais de test de charge. Il fonctionne très bien en développement, où exactement une instance s’active exactement une fois. La première fois qu’il rencontre une vraie concurrence, c’est en production, au pire moment possible : un déploiement ou un redémarrage ramène tout le parc en même temps, chaque instance avec un cache froid, toutes à chercher une licence dans les mêmes deux secondes.

Une vérification de licence est un appel de dépendance comme un autre, et la chaîne d’activation a une capacité. Cet article la met sous charge avec k6, et la première tâche est d’être précis sur quelle partie vous testez réellement.

Ce qui est local, et ce qui passe sur le fil

L’erreur courante est d’imaginer chaque vérification de licence comme un aller-retour vers un serveur. Avec Keyright, ce n’en est pas un. La vérification en régime permanent est une opération locale : le SDK conserve une licence signée, et Validate() vérifie sa signature contre la clé publique embarquée et lit ses claims. Pas de socket, pas de DNS, des microsecondes.

// Steady state: no network at all. Validate() checks the signature on the
// cached, signed license with the embedded public key, then reads claims.
LicenseInfo info = _client.Validate(licenseKey);
if (info.Status != LicenseStatus.Valid)
    throw new LicenseException(info.Status);   // fail closed

Tester cet appel en charge n’a aucun intérêt : c’est de l’arithmétique de signature limitée par le CPU, sans aucune ressource partagée à se disputer. Ce qui touche le réseau, et a donc une capacité que vous pouvez épuiser, ce sont deux choses :

  • L’activation. La première fois qu’une instance démarre, ou la première fois après la perte de son cache, elle appelle le service d’émission pour obtenir une licence signée pour son identité machine. C’est l’appel coûteux, et celui qui survient en ruée après un déploiement.
  • Le rafraîchissement. À intervalle régulier, le SDK revalide, pour qu’une révocation ou un changement de droits se propage. C’est une requête conditionnelle : elle envoie l’étiquette de version qu’elle a déjà et reçoit généralement un 304 Not Modified peu coûteux.

Le vrai test de charge n’est donc pas « vérifier une licence un million de fois ». C’est « qu’arrive-t-il à l’endpoint d’activation quand 300 instances reviennent d’un déploiement au même instant, puis se calment en un bourdonnement régulier de rafraîchissements conditionnels ».

Où se trouve vraiment la charge réseauInstance clientedémarrage à froid / après déploiementValidate() → localvérification de signature, sans réseaumicrosecondesPOST /v1/activateréseau · coûteux · ruéeGET refresh + ETagsouvent 304 · peu coûteux · périodiqueService d'émissionsigne une licencevotre déploiementa une capaciték6ramping-VUs → tempête d'activations+ scénario de rafraîchissement régulierSeuls l'activation et le rafraîchissement traversent le réseau ; Validate en régime permanent est local, rien à tester en charge là.

Les appels HTTP sous test

L’activation est un simple POST. Le client envoie le produit qu’il active, la clé de licence et une identité machine stable ; il reçoit un document de licence signé.

POST /v1/activate HTTP/1.1
Host: license.example.com
Content-Type: application/json

{ "productKey": "prod_designer", "licenseKey": "KR-7Q2F-...", "machineId": "a1b2c3d4" }

Un rafraîchissement est un GET conditionnel. Le client envoie l’étiquette de version qu’il possède déjà ; quand rien n’a changé, il reçoit un 304 au corps vide, ce qui est tout l’intérêt : un parc sain génère majoritairement des 304, pas des documents de licence complets.

GET /v1/license/lic_8f3a HTTP/1.1
Host: license.example.com
If-None-Match: "v7-2026-11-01"

→ HTTP/1.1 304 Not Modified

Ce sont les deux requêtes que k6 va générer.

Modéliser la tempête d’activations

L’exécuteur par défaut de k6 maintient un nombre fixe d’utilisateurs virtuels, mais ce n’est pas la forme du risque ici. Le risque est une rampe : de zéro à quelques centaines d’instances en secondes, quand un déploiement redémarre le parc. Utilisez ramping-vus et faites de chaque utilisateur virtuel une machine distincte qui se met en ligne.

import http from 'k6/http';
import { check, sleep } from 'k6';
import { Trend, Rate } from 'k6/metrics';

const activateLatency = new Trend('activate_latency', true);
const activateFailed = new Rate('activate_failed');

export const options = {
  scenarios: {
    // A deploy brings the fleet back with a cold cache: everyone activates at once.
    activation_storm: {
      executor: 'ramping-vus',
      startVUs: 0,
      stages: [
        { duration: '30s', target: 300 }, // ramp to 300 concurrent clients
        { duration: '1m',  target: 300 }, // hold the herd
        { duration: '30s', target: 0 },   // drain
      ],
    },
  },
  thresholds: {
    // Activation is on the critical path of a cold start. If p95 crosses
    // 800ms, a fleet restart visibly stalls; fail the run if it does.
    activate_latency: ['p(95)<800'],
    activate_failed:  ['rate<0.01'],  // under 1% may fail under the storm
    checks:           ['rate>0.99'],
  },
};

const BASE = __ENV.KEYRIGHT_URL;    // e.g. https://license.staging.example.com

export default function () {
  // Each VU/iteration is a distinct machine identity.
  const machineId = `load-${__VU}-${__ITER}`;
  const res = http.post(`${BASE}/v1/activate`, JSON.stringify({
    productKey: __ENV.PRODUCT_KEY,
    licenseKey: __ENV.LICENSE_KEY,
    machineId,
  }), { headers: { 'Content-Type': 'application/json' } });

  activateLatency.add(res.timings.duration);
  activateFailed.add(res.status !== 200);

  check(res, {
    'status is 200': (r) => r.status === 200,
    'body is a signed license': (r) => {
      try { return (JSON.parse(r.body).signature || '').length > 0; }
      catch { return false; }
    },
  });
  sleep(1);
}

Deux détails portent tout le poids. Le check sur le corps compte parce qu’un endpoint d’activation sous stress peut renvoyer 200 avec une charge utile tronquée ou erronée ; ne compter que les codes de statut ferait passer une réponse cassée pour un succès. Et les seuils sont le test : une exécution de k6 sans seuils ne fait qu’afficher des chiffres, mais les seuils la font réussir ou échouer, ce qui permet de l’intégrer dans la CI et d’attraper une régression avant qu’elle ne parte.

Lancez-la avec la cible et les identifiants dans l’environnement, jamais codés en dur dans le script :

k6 run \
  -e KEYRIGHT_URL=https://license.staging.example.com \
  -e PRODUCT_KEY=prod_designer \
  -e LICENSE_KEY=KR-7Q2F-TEST \
  activation-storm.js

Exercer aussi la voie peu coûteuse

Un second scénario prouve que le rafraîchissement en régime permanent reste peu coûteux. Ici, l’assertion intéressante est que la plupart des réponses sont des 304 : si votre parc paie un document de licence complet à chaque rafraîchissement, quelque chose en amont ne respecte pas l’étiquette de version, et cela multiplie en silence votre coût permanent.

export function refresh() {
  const res = http.get(`${BASE}/v1/license/${__ENV.LICENSE_ID}`, {
    headers: { 'If-None-Match': __ENV.ETAG },
  });
  check(res, {
    'not-modified fast path': (r) => r.status === 304,
  });
}

Ajoutez-le à côté de la tempête comme second scénario avec un exécuteur constant-arrival-rate, afin qu’il modélise un débit de requêtes fixe indépendant de la lenteur des réponses — ce qui est exactement le comportement d’un parc de minuteries.

Lire le résultat, et ce qu’il ne vous dit pas

Une exécution au vert signifie que votre déploiement absorbe la ruée dans votre budget de latence et sert massivement les rafraîchissements par la voie rapide 304. C’est le chiffre que vous voulez avant le prochain gros déploiement.

Soyez honnête sur les limites.

  • Vous testez votre déploiement, pas l’arithmétique de vérification. La vérification de signature est locale et à temps quasi constant ; rien de ce que vous faites dans k6 ne la stresse. La capacité que vous mesurez appartient au service d’émission que vous montez.
  • La protection anti-abus combattra votre générateur de charge, à juste titre. Un endpoint d’activation digne d’être déployé a une limitation de débit et des règles anti-abus. Un test de charge peut les déclencher, et un 429 n’est pas un échec de capacité : c’est le service qui fait son travail. Testez contre un déploiement de staging et un produit configuré avec des limites qui laissent passer l’exécution, sinon vous mesurez le limiteur de débit, pas le service.
  • La réactivation devrait être idempotente, modélisez donc des machines neuves. Activer deux fois le même machineId devrait être peu coûteux et ne doit pas consommer un second siège. C’est pourquoi le script dérive une identité distincte par itération : un test de charge qui réactive une seule machine mesure la voie rapide idempotente, pas la tempête.
  • Ne le pointez jamais vers un service partagé ou en production. Pointez-le uniquement vers un déploiement que vous possédez et pouvez réinitialiser, avec une licence de test dédiée. La Community Edition auto-hébergée de Keyright suffit à monter une cible réaliste.

À retenir

La vérification de licence est une dépendance critique, et la moitié qui touche le réseau a une capacité comme tout autre endpoint. k6 vous laisse trouver cette capacité à vos conditions : en modélisant la rafale synchronisée de démarrage à froid qu’un déploiement provoque vraiment, en affirmant sur le p95 et le taux d’échec plutôt qu’en jugeant un graphe à l’œil, et en confirmant que la chaîne de rafraîchissement reste sur sa voie 304 peu coûteuse. Faites-le une fois en staging et le prochain redémarrage de tout le parc cessera d’être le moment où vous découvrez la limite.

Essayez Nebula.NET

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