Migrar claves por máquina a licencias flotantes
Cambiar un producto .NET ya distribuido de activaciones ancladas a máquina a un grupo de asientos concurrentes flotantes es un cambio de protocolo, no un simple ajuste de configuración: hazlo mal y cada instalación existente pierde su asiento o se cuenta dos veces. Esta guía muestra el SDK de doble modo, el claim del modelo de asiento y la reconciliación atómica en el servidor que permiten la transición sin romper a ningún cliente.
Un grupo de licencias flotantes parece un ajuste del servidor: “permitir 25 usuarios concurrentes en lugar de 25 máquinas con nombre”. No lo es. El modelo por recuento de máquinas y el modelo de asientos concurrentes son dos conversaciones distintas entre el cliente y el servicio, y los clientes ya instalados solo saben mantener una de ellas. Cambia el servidor antes de que el campo esté listo y tendrás el peor error de licencias que existe: uno en el que los clientes que pagan quedan bloqueados y el panel sigue diciendo que todo va bien.
Conclusión clave: trata el paso de anclado a flotante como una migración de protocolo progresiva. Pon un claim seat.model por clave en la licencia, distribuye un SDK de doble modo que lo lea, deja que ese SDK llegue al campo primero, y solo entonces empieza a acuñar claves flotantes. El servidor reconcilia la activación antigua de cada máquina en el nuevo grupo de forma atómica, de modo que el techo compartido se mantiene en todo momento.
La pregunta real: ¿quién decide el modelo y cuándo?
Con el anclaje a máquina, un cliente liga una licencia a una huella de máquina estable y la valida localmente; el servicio registra una activación por máquina y limita el recuento. Con el modelo flotante, el cliente no posee nada permanente: llama a ClaimSeatAsync al iniciar, renueva una licencia corta con un heartbeat, y el asiento vuelve al grupo cuando el cliente sale o deja de renovar.
Esos son valores por defecto incompatibles. Un cliente anclado nunca pide un asiento; un cliente flotante nunca espera un vínculo permanente. Así que la decisión no puede ser una bandera global del servidor leída en el momento de la validación: tiene que viajar dentro de cada licencia, donde tanto el servidor como el cliente pueden leerla antes de elegir un camino.
{
"lic": "KR-7F3A-...",
"product": "acme-suite",
"seat": { "model": "floating", "max": 25, "leaseTtl": "00:05:00" },
"exp": "2027-03-01T00:00:00Z"
}
El claim seat se firma como parte de la carga útil de la licencia, así que un cliente no puede falsificar su paso de anclado a flotante, y el modelo es un hecho sobre la clave en lugar del humor actual del servidor. Las claves antiguas conservan "model": "node-locked"; las claves renovadas y nuevas reciben "model": "floating".
Paso 1: distribuir un SDK que hable ambos
El primer entregable es un cliente que lea el claim y despache. Esta es la pieza que debe llegar al campo antes de que cambie cualquier clave, porque es la única versión que no se romperá cuando se encuentre con una clave flotante.
public async Task<SeatResult> AcquireAsync(CancellationToken ct = default)
{
LicenseClaims claims = _verifier.Verify(_storedKey); // Ed25519 check, fully local
if (!claims.IsValid)
return SeatResult.Invalid;
return claims.Seat.Model switch
{
SeatModel.NodeLocked => BindToMachine(claims), // legacy path, untouched
SeatModel.Floating => await ClaimFloatingSeatAsync(claims, ct),
_ => SeatResult.Invalid, // unknown model: fail closed
};
}
La rama anclada es el código que ya distribuyes, sin cambios. La rama flotante reclama un asiento y luego lo mantiene renovando a la mitad del TTL de la licencia, de modo que un heartbeat perdido todavía tiene un intento más antes de que el asiento sea recuperado.
async Task<SeatResult> ClaimFloatingSeatAsync(LicenseClaims claims, CancellationToken ct)
{
SeatGrant seat = await _service.ClaimSeatAsync(claims.LicenseId, _fingerprint, ct);
if (seat.Status == SeatStatus.PoolExhausted)
return SeatResult.Denied("all seats in use");
var half = claims.Seat.LeaseTtl / 2;
_heartbeat = new Timer(_ => _ = _service.RenewSeatAsync(seat.Token, ct), null, half, half);
return SeatResult.Granted(seat.Token, seat.ExpiresAtUtc);
}
Fundamentalmente, este SDK es correcto frente a ambos tipos de clave. Un cliente que actualice hoy sigue funcionando con su clave anclada sin ningún cambio de comportamiento. Eso es lo que hace segura la transición: la migración del SDK y la migración de las claves están desacopladas.
Paso 2: reconciliar cada máquina al cruzar
Aquí es donde una transición ingenua cuenta dos veces. Una máquina que ya tiene una activación anclada y luego reclama su primer asiento flotante ocuparía dos unidades de capacidad: una activación antigua que el grupo no puede ver, más un asiento activo. En toda una flota, eso sobrevende el techo en silencio y empieza a denegar asientos legítimos.
La solución vive en el servidor y debe ser atómica. En el primer reclamo flotante desde una huella que todavía tiene una activación anclada en la misma licencia, Keyright retira la activación y emite el asiento en una sola transacción.
La operación del lado del administrador es una sola llamada idempotente, de modo que un reclamo reintentado tras un corte de red no convierte dos veces:
# Server reconciles on first floating claim; the SDK triggers it transparently.
# To audit a license mid-migration, read its occupancy:
keyright seats show --license KR-7F3A-... --breakdown-by-model
# model=node-locked held=10
# model=floating active=15
# ceiling=25 overcommit=0
Mientras overcommit se mantenga en cero, el techo está intacto y puedes seguir convirtiendo al ritmo al que actualice el campo.
Paso 3: cambiar las claves en la renovación, no todas a la vez
No tienes que migrar a todos en una fecha. Como el modelo es por clave, la transición más limpia acompaña el ciclo de renovación: cuando una clave anclada se renueva, acuña el reemplazo como flotante. Las flotas que hayan adoptado por completo el SDK de doble modo pueden cambiarse en bloque; el resto se convierte de forma natural a medida que vence su término.
keyright license reissue --license KR-7F3A-... \
--seat-model floating --seat-max 25 --lease-ttl 00:05:00
El cliente recoge el nuevo modelo en su siguiente actualización de licencia y llama a AcquireAsync por la rama flotante: sin reinstalación, sin reintroducir una clave, sin ticket de soporte.
Advertencias: dónde duele
El orden no es negociable. Si una clave flotante llega a una máquina que todavía ejecuta el SDK antiguo de un solo modelo, ese cliente se topa con un modelo desconocido y —si no se escribió para fallar cerrado en la rama anclada— puede comportarse mal. Distribuye y confirma la telemetría de adopción del SDK antes de reemitir una sola clave. El claim del asiento permite que ambos modelos coexistan precisamente para que puedas esperar.
Un fallo mantiene un asiento hasta que la licencia caduca. La capacidad flotante solo se recupera cuando el TTL de la licencia expira sin un heartbeat; consulta heartbeat de licencias y recuperación de arrendamientos para dimensionar el TTL frente a tu comportamiento real de salida. Ponlo demasiado largo y un portátil que se suspende a mitad de sesión retiene un asiento; demasiado corto y una red lenta deja fuera a un usuario activo.
Las instalaciones sin conexión no pertenecen a un grupo. El modelo flotante necesita el ciclo de heartbeat. Mantén las máquinas realmente aisladas de la red ancladas con una ventana de gracia offline acotada, y deja que el claim seat.model lleve esa distinción por cliente en lugar de forzar un modelo sobre toda la base.
La reconciliación debe ser atómica o sobrevendes. El retirar-y-conceder tiene que ser una sola transacción con clave de idempotencia. Hazlo en dos pasos y un reclamo reintentado convierte la misma máquina dos veces, comiéndose en silencio un asiento del techo.
Conclusión
Pasar de anclado a flotante es una migración, no una bandera. Pon el modelo en un claim seat firmado por clave, distribuye un SDK de doble modo que despache según él y llegue al campo primero, reconcilia la activación antigua de cada máquina en el grupo de forma atómica, y cambia las claves en la renovación. Hecho en ese orden, el techo compartido se mantiene en cada paso y ningún cliente nota nunca que el modelo cambió por debajo. La Community Edition de Keyright ejecuta la ruta anclada de forma gratuita; los grupos flotantes y la reconciliación de modelos forman parte de los niveles de pago. La receta completa de migración vive en la documentación de Keyright.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.