Skip to content
← Todas las publicaciones
· Delta1 Labs PerformanceKeyright

Pruebas de carga de la verificación de licencias con k6

Haces pruebas de carga del checkout y del login, pero la llamada que decide si el software puede ejecutarse — la activación de la licencia — suele enfrentarse a la carga de producción por primera vez durante un reinicio de toda la flota. Esta guía usa k6 para someter a carga la ruta de verificación: separa la comprobación de firma local y barata (que nunca toca la red) de las llamadas de activación y refresco (que sí), modela la tormenta de activaciones que provoca un despliegue, define umbrales de latencia p95 y de tasa de errores, y ejercita el refresco condicional para comprobar que la vía rápida 304 aguanta.

Haces pruebas de carga de las rutas que ya respetas como críticas: el checkout, el login, la caja de búsqueda. Y luego está la única llamada que decide si el software puede ejecutarse siquiera — la verificación de licencia — y casi nunca pasa por una prueba de carga. Funciona bien en desarrollo, donde exactamente una instancia se activa exactamente una vez. La primera vez que se enfrenta a concurrencia real es en producción, en el peor momento posible: un despliegue o un reinicio devuelve toda la flota a la vez, cada instancia con la caché fría, todas buscando una licencia en los mismos dos segundos.

Una comprobación de licencia es una llamada a una dependencia como cualquier otra, y la ruta de activación tiene una capacidad. Este artículo la somete a carga con k6, y lo primero es ser preciso sobre qué parte estás probando en realidad.

Qué es local y qué va por el cable

El error habitual es imaginar cada comprobación de licencia como una ida y vuelta a un servidor. Con Keyright no lo es. La verificación en régimen estacionario es una operación local: el SDK guarda una licencia firmada, y Validate() comprueba su firma contra la clave pública incrustada y lee sus claims. Sin socket, sin DNS, microsegundos.

// 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

Probar con carga esa llamada no tiene sentido: es aritmética de firma limitada por CPU, sin ningún recurso compartido por el que competir. Lo que toca la red, y por tanto tiene una capacidad que puedes agotar, son dos cosas:

  • Activación. La primera vez que una instancia arranca, o la primera vez tras perder su caché, llama al servicio de emisión para obtener una licencia firmada para su identidad de máquina. Es la llamada cara, y la que ocurre en estampida tras un despliegue.
  • Refresco. Cada cierto intervalo el SDK revalida, para que una revocación o un cambio de derechos se propague. Es una petición condicional: envía la etiqueta de versión que ya tiene y normalmente recibe un 304 Not Modified barato.

Así que la verdadera prueba de carga no es “verificar una licencia un millón de veces”. Es “qué le pasa al endpoint de activación cuando 300 instancias vuelven de un despliegue en el mismo instante, y luego se asientan en un zumbido constante de refrescos condicionales”.

Dónde está de verdad la carga de redInstancia clientearranque en frío / tras despliegueValidate() → localcomprobación de firma, sin redmicrosegundosPOST /v1/activatered · cara · estampidaGET refresh + ETagnormalmente 304 · barato · periódicoServicio de emisiónfirma una licenciatu desplieguetiene una capacidadk6ramping-VUs → tormenta de activaciones+ escenario de refresco estableSolo la activación y el refresco cruzan la red; Validate en régimen estacionario es local, así que ahí no hay nada que probar con carga.

Las llamadas HTTP bajo prueba

La activación es un POST normal. El cliente envía el producto que activa, la clave de licencia y una identidad de máquina estable; recibe un documento de licencia firmado.

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

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

Un refresco es un GET condicional. El cliente envía la etiqueta de versión que ya tiene; cuando nada ha cambiado recibe un 304 con cuerpo vacío, que es justamente la gracia: una flota sana genera mayoritariamente 304s, no documentos de licencia completos.

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

Esas son las dos peticiones que k6 generará.

Modelar la tormenta de activaciones

El ejecutor por defecto de k6 mantiene un número fijo de usuarios virtuales, pero esa no es la forma del riesgo aquí. El riesgo es una rampa: de cero a unos cientos de instancias en segundos, cuando un despliegue reinicia la flota. Usa ramping-vus y haz que cada usuario virtual sea una máquina distinta que entra en línea.

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);
}

Dos detalles cargan con todo el peso. El check sobre el cuerpo importa porque un endpoint de activación bajo estrés puede devolver 200 con una carga útil truncada o errónea; contar solo los códigos de estado daría por bueno un error. Y los umbrales son la prueba: una ejecución de k6 sin umbrales solo imprime números, pero los umbrales la hacen pasar o fallar, que es lo que te permite integrarla en CI y cazar una regresión antes de que se envíe.

Ejecútala con el objetivo y las credenciales en el entorno, nunca incrustados en el 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

Ejercitar también la vía barata

Un segundo escenario demuestra que el refresco en régimen estacionario sigue siendo barato. Aquí la afirmación interesante es que la mayoría de las respuestas son 304: si tu flota paga un documento de licencia completo en cada refresco, algo aguas arriba no está respetando la etiqueta de versión, y eso multiplica en silencio tu coste estacionario.

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,
  });
}

Añádelo junto a la tormenta como un segundo escenario con un ejecutor constant-arrival-rate, para que modele una tasa fija de peticiones independiente de lo lentas que se vuelvan las respuestas, que es exactamente como se comporta una flota de temporizadores.

Leer el resultado, y lo que no te dice

Una ejecución en verde significa que tu despliegue absorbe la estampida dentro de tu presupuesto de latencia y sirve de forma abrumadora los refrescos por la vía rápida 304. Ese es el número que quieres antes del próximo gran despliegue.

Sé honesto con los límites.

  • Pruebas tu despliegue, no la aritmética de verificación. La comprobación de firma es local y de tiempo casi constante; nada de lo que hagas en k6 la estresa. La capacidad que mides pertenece al servicio de emisión que levantas.
  • La protección contra abusos peleará con tu generador de carga, y con razón. Un endpoint de activación que merezca desplegarse tiene limitación de tasa y reglas antiabuso. Una prueba de carga puede dispararlas, y un 429 no es un fallo de capacidad: es el servicio haciendo su trabajo. Prueba contra un despliegue de staging y un producto configurado con límites que dejen pasar la ejecución, o estarás midiendo el limitador de tasa, no el servicio.
  • La reactivación debería ser idempotente, así que modela máquinas nuevas. Activar el mismo machineId dos veces debería ser barato y no debe consumir un segundo asiento. Por eso el script deriva una identidad distinta por iteración: una prueba de carga que reactiva una sola máquina mide la vía rápida idempotente, no la tormenta.
  • Nunca lo apuntes a un servicio compartido o en vivo. Apúntalo solo a un despliegue que poseas y puedas reiniciar, con una licencia de prueba dedicada. La Community Edition autoalojada de Keyright basta para levantar un objetivo realista.

Conclusión

La comprobación de licencia es una dependencia crítica, y la mitad que toca la red tiene una capacidad como cualquier otro endpoint. k6 te deja encontrar esa capacidad en tus términos: modelando la ráfaga sincronizada de arranque en frío que provoca de verdad un despliegue, afirmando sobre p95 y tasa de errores en vez de mirar una gráfica a ojo, y confirmando que la ruta de refresco se mantiene en su barato carril 304. Hazlo una vez en staging y el próximo reinicio de toda la flota dejará de ser el momento en que descubres el límite.

Prueba Nebula.NET

Endurece tu código .NET en minutos — empieza con la edición gratuita.