Asientos flotantes que se liberan solos cuando un cliente falla
Cómo un despliegue autohospedado de Keyright reparte un número acotado de asientos concurrentes, mantiene cada uno vivo con latidos periódicos y recupera el asiento de un cliente que murió sin devolverlo — incluyendo las carreras reales en el límite del tope, el desfase de reloj en la expiración de la concesión y el orden entre latido y liberación, con el C# que ejecutan el SDK y el servicio de emisión.
Una licencia flotante es una promesa con un agujero. Vendes diez asientos concurrentes, el SDK diligentemente hace checkout de uno cuando arranca la aplicación, y todo funciona hasta el día en que un proceso cliente se mata — un corte de luz, un forzado de cierre, un contenedor desalojado a mitad de tarea — sin decirle jamás al servidor que había terminado. El asiento que retenía es ahora un fantasma: contabilizado contra tu techo, reclamado por nadie, e imposible de distinguir de un usuario real que simplemente se ausentó. No hagas nada y tu licencia de diez asientos se va muriendo de hambre a medida que los fantasmas se acumulan. Recupera con demasiada avidez y le arrancas el asiento a alguien cuyo portátil solo se durmió noventa segundos.
La pregunta real es cómo un servicio de emisión reparte un número acotado de asientos y recupera con seguridad los muertos, sin una conexión persistente a cada cliente y sin dejar nunca que el conteo vivo supere el tope. Keyright lo hace con una concesión: un asiento no es una bandera que pones y quitas, es una concesión de corta vida con un plazo, mantenida viva por latidos y recuperada por expiración. Esa única decisión de diseño convierte una pregunta sin respuesta — ¿sigue vivo este cliente? — en una con respuesta — ¿se ha renovado esta concesión lo bastante recientemente? Este artículo trata de cómo funciona el ciclo de vida de la concesión, y dónde se esconden las carreras.
Un asiento es una concesión, no una bandera
El modelo ingenuo almacena un booleano por asiento y un conteo. El checkout pone un bit y lo incrementa; la liberación lo vuelve a quitar. Falla en el momento en que un cliente muere sin liberar, porque el bit queda puesto para siempre. No hay forma acotada de recuperar, solo heurísticas que se equivocan en ambas direcciones.
El modelo de concesión almacena, por cada asiento activo, un pequeño registro con un plazo:
{
"leaseId": "lease_7e2a9c",
"licenseId": "KR-9QX2-7F3M",
"seatHolder": "host-7e2a9c:pid-4821",
"issuedAt": "2026-11-21T09:12:04.118Z",
"expiresAt": "2026-11-21T09:14:04.118Z",
"renewals": 0
}
Un asiento está vivo si y solo si existe una concesión para él y now() es anterior a su expiresAt, según juzga el reloj del servicio. Esa es toda la definición. Un cliente que ha fallado deja de renovar; su expiresAt se desliza al pasado; el asiento se vuelve recuperable sin ninguna detección especial de fallos en ningún sitio. El plazo hace el trabajo que una comprobación de presencia por latido nunca podría, porque no necesita un segundo mensaje para confirmar la muerte — la ausencia de renovación es la señal.
El checkout, y la carrera en el límite del tope
El checkout es donde la corrección se gana o se pierde. La tentación es escribirlo en dos pasos: contar las concesiones vivas y, si está bajo el tope, insertar una nueva. Ese es un bug de tiempo-de-comprobación-a-tiempo-de-uso de libro de texto. Dos clientes leen ambos “nueve vivas” y ambos insertan la décima — ahora hay once asientos retenidos contra un tope de diez.
La llamada del SDK es deliberadamente simple; toda la lógica dura vive en el servicio:
using Keyright.Client;
var seats = new SeatClient(new SeatClientOptions
{
ServiceUri = new Uri("https://licensing.internal.acme.example"),
LicenseKey = licenseKey,
SeatHolder = SeatHolder.ForThisProcess(), // host + pid + boot id
});
// Blocks only on the round-trip; throws SeatCapReachedException on 409.
await using SeatLease lease = await seats.CheckoutAsync(cancellationToken);
// The lease keeps itself alive in the background until disposed.
RunApplication();
En el servicio, el checkout es una única escritura condicional atómica. Inserta la concesión solo si el número de concesiones vivas para esta licencia sigue por debajo del tope en el instante de la escritura — el conteo y la inserción son una operación indivisible, no dos. Expresado como el predicado que impone la capa de almacenamiento:
// Service-side. Runs as ONE atomic operation, serialised per licenseId.
public CheckoutResult Checkout(string licenseId, SeatHolder holder, int cap, TimeSpan ttl)
{
var now = _clock.UtcNow;
// Count only leases that are still live by the SERVICE clock.
// Expired leases do not count — they are reclaimed implicitly here.
int liveCount = _leases.CountWhere(licenseId, l => l.ExpiresAt > now);
if (liveCount >= cap)
return CheckoutResult.CapReached(liveCount, cap);
var lease = new Lease
{
LeaseId = LeaseId.New(),
LicenseId = licenseId,
Holder = holder,
IssuedAt = now,
ExpiresAt = now + ttl,
};
// Commit succeeds ONLY IF liveCount is still < cap at write time.
// If a racing writer committed first, this returns Conflict and we retry.
return _leases.InsertIfLiveCountBelow(lease, cap, now)
? CheckoutResult.Granted(lease)
: CheckoutResult.CapReached(cap, cap);
}
La línea que carga el peso es InsertIfLiveCountBelow. Es un compare-and-set: la escritura se acepta solo si el predicado de conteo vivo al que estaba condicionada sigue cumpliéndose en el momento del commit. Cuando dos peticiones compiten por el último asiento, la capa de almacenamiento las ordena. La primera ve nueve vivas y confirma la décima. La segunda se evalúa contra el estado ya confirmado, ve diez, y es rechazada. El perdedor obtiene un resultado CapReached y nunca recibe un token de concesión — así que nunca cree tener un asiento. Observa que las concesiones expiradas se excluyen de liveCount, lo que significa que cada checkout realiza también una recuperación implícita: el fantasma de un cliente que falló no cuenta contra el tope en el momento en que ha pasado su plazo.
Los latidos, y por qué son condicionales
Una vez concedida, la concesión debe mantenerse viva. El SeatLease que devuelve CheckoutAsync posee un bucle en segundo plano que renueva la concesión a una fracción del TTL — por defecto cada tercio del camino, así que una concesión de dos minutos se renueva más o menos cada cuarenta segundos. Renovar temprano no es un desperdicio; es el margen que absorbe un temporizador lento, una petición retrasada o una renovación perdida sin que la concesión llegue nunca a caducar de verdad.
La propiedad crítica es que un latido es condicional. No es “pon expiresAt a now + TTL para este asiento”; es “extiende esta concesión exacta si sigue viva”. La renovación lleva el leaseId, y el servicio la rechaza si esa concesión ha desaparecido:
// Service-side renewal. Conditional on the lease still existing AND being live.
public RenewResult Renew(string leaseId, TimeSpan ttl)
{
var now = _clock.UtcNow;
// Atomic: extend only if the lease is present and not yet expired.
bool extended = _leases.ExtendIfLive(leaseId, newExpiry: now + ttl, now: now);
return extended
? RenewResult.Renewed(now + ttl)
: RenewResult.Lost; // released, revoked, or already swept
}
// SDK-side loop. A lost renewal is surfaced, never swallowed.
private async Task HeartbeatLoop(CancellationToken ct)
{
var interval = _ttl / 3;
while (!ct.IsCancellationRequested)
{
await Task.Delay(interval, ct);
var result = await _transport.RenewAsync(_leaseId, ct);
if (result.Kind == RenewKind.Lost)
{
_lostSeat.TrySetResult(); // application observes SeatLost
return; // stop renewing a seat we no longer hold
}
_expiresAt = result.NewExpiry;
}
}
ExtendIfLive es la contraparte de InsertIfLiveCountBelow: otro compare-and-set, esta vez condicionado a que la concesión esté presente y no expirada. Cierra la carrera de resurrección. Imagina una renovación ya en tránsito cuando la aplicación llama a release, o un administrador revoca el asiento. La liberación borra la concesión; un milisegundo después llega el latido en tránsito. Un “toque” incondicional recrearía alegremente la fila y empujaría el conteo vivo por encima del tope con un asiento que nadie usa. Como la renovación es condicional, no encuentra ninguna concesión viva que extender, devuelve Lost, y el SDK detiene el bucle en lugar de resucitar un asiento muerto.
Liberación, expiración y el orden que importa
Hay dos maneras de que un asiento vuelva. La limpia es la liberación: await using desecha el SeatLease, que envía una última llamada borrando la concesión y liberando el asiento de inmediato — sin esperar a un plazo. La costosa-pero-segura es la expiración: un cliente que nunca llega a liberar (porque falló) simplemente deja de renovar, y su concesión caduca.
La expiración se evalúa de forma perezosa. El servicio no corre un temporizador por concesión esperando dispararse; compara now() con expiresAt cada vez que se inspecciona un asiento — en el siguiente checkout para esa licencia (donde las concesiones expiradas se excluyen del conteo, como arriba) y en un barrido periódico de baja frecuencia que ordena las filas abandonadas para que el almacén no crezca sin límite. La evaluación perezosa es lo que mantiene a cero el coste de diez mil concesiones inactivas: nada se despierta por una concesión que nadie disputa.
El orden que importa es latido-contra-liberación, y la regla es simple: la liberación es un borrado, la renovación es una extensión condicional, y el que el almacén confirme primero gana de forma determinista. Si la liberación confirma primero, el latido posterior no encuentra concesión y devuelve Lost. Si un latido confirma primero, meramente empuja el plazo un TTL hacia adelante — y la liberación que sigue aún borra la concesión por completo, liberando el asiento sin importar cuánto se hubiera extendido el plazo. No hay entrelazado en el que un asiento acabe a la vez liberado y vivo, porque release no se preocupa del plazo y la renovación no puede recrear una concesión borrada.
Cuándo se rompe esto, honestamente
Los asientos flotantes te compran equidad acotada, no perfección, y vale la pena enunciar tres límites con claridad.
Primero, la ventana de recuperación es el TTL, y nada la acorta. Un cliente que falla retiene su asiento hasta que pasa el plazo. Elegir el TTL es un compromiso real: los TTL cortos recuperan fantasmas rápido pero multiplican el tráfico de latidos y castigan los cortes breves de red; los TTL largos son amables con los enlaces inestables pero dejan a un cliente muerto ocupando más tiempo. No hay ajuste que recupere al instante y tolere un portátil dormido, porque son la misma incertidumbre vista desde dos lados.
Segundo, la tolerancia sin conexión está acotada por exactamente esa ventana. Un cliente que pierde la red sigue trabajando hasta que su concesión habría expirado; reconecta a tiempo y el siguiente latido lo cura, pierde la ventana y el asiento se ha ido y hay que volver a hacer checkout, lo cual puede fallar si el tope se llenó entretanto. El licenciamiento flotante no es uso sin conexión ilimitado — es uso sin conexión acotado por el TTL, y esa es su forma honesta.
Tercero, todo esto descansa en el reloj del servicio, y solo en el reloj del servicio. El expiresAt del cliente es orientativo; cada decisión de autorización es el servicio comparando su propio now() con un plazo que almacenó. Eso es lo que hace del desfase de reloj del cliente un no-evento — pero también significa que un servicio cuyo propio reloj da un salto es lo único que puede corromper el tiempo de la concesión, razón por la cual el plazo, la renovación y el barrido leen todos un único reloj de servicio monótono en lugar de cualquier valor que suministre un cliente.
Conclusión
El truco de los asientos flotantes es negarse a responder la pregunta sin respuesta. No puedes detectar de forma fiable que un cliente ha fallado, así que nunca lo intentas. Repartes una concesión con un plazo, la mantienes viva con latidos condicionales, y dejas que la ausencia recupere lo que la muerte dejó atrás. El tope se sostiene porque el checkout es una única escritura condicional atómica, nunca un leer-luego-escribir; los asientos nunca resucitan porque la renovación está condicionada a una concesión viva; y la expiración no necesita detección de fallos porque el latido que falta es la detección. Configura el TTL según tu tolerancia a los fantasmas frente a tu tolerancia a las recuperaciones falsas, cablea el await using del SDK para que las salidas limpias liberen al instante, y los diez asientos que vendiste siguen siendo diez — ni más, ni menos de los que están genuinamente vivos. Consulta las opciones de asientos concurrentes en la documentación de Keyright y el modelo de licenciamiento en la página de producto de Keyright.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.