Asientos por usuario nombrado frente a por dispositivo en Keyright
Un asiento puede significar una máquina o una persona, y cada uno se cuenta distinto. Así se enlazan, se aplican y se reconcilian los asientos por dispositivo y por usuario nombrado en Keyright sin sobrevender ni bloquear a usuarios que pagan.
La mayoría de los errores de licenciamiento no son criptográficos. Son un desajuste de conteo: vendiste “cinco asientos” entendiendo cinco personas, y tu aplicación cuenta cinco máquinas, de modo que el ingeniero de ventas que además ejecuta la app en un portátil y en una VM consume tres de los cinco asientos él solo. Nadie atacó nada. La licencia simplemente cuenta un sustantivo distinto al que figura en la orden de compra.
Keyright permite que un asiento signifique cualquiera de los dos sustantivos. Este artículo trata de elegir deliberadamente entre ambos, enlazar una activación a la dimensión correcta, aplicar el tope contra ella y —la parte que hace tropezar a los equipos— reconciliar los dos modelos cuando necesitas pasar de uno al otro sin bloquear a clientes que no hicieron nada malo.
Dos cosas que puede significar un asiento
Un asiento es una unidad de derecho concurrente. La única pregunta real es qué consume uno.
Asientos por dispositivo
Un asiento por dispositivo está enlazado a una máquina. El SDK calcula una huella de la máquina estable en la activación, el servicio emisor la registra, y el tope de asientos de la licencia se aplica contra el número de huellas distintas. Cinco asientos por dispositivo significa como máximo cinco máquinas con una activación viva a la vez. Es el modelo correcto para estaciones de trabajo compartidas, kioscos, agentes de compilación y cualquier caso en el que “quién está sentado ahí” sea irrelevante: licencias la instalación, no a la persona.
El modo de fallo es el usuario avanzado con tres dispositivos. Bajo asientos por dispositivo son tres asientos, y si tu lista de precios decía “por usuario”, ahora te faltan dos asientos por el mismo dinero.
Asientos por usuario nombrado
Un asiento por usuario nombrado está enlazado a una identidad —un correo, un sujeto de SSO, un id de empleado— que se lleva a la activación como una referencia de usuario estable. El tope de asientos se aplica contra el número de identidades distintas, y cada identidad puede activar en tantos de sus propios dispositivos como permita la licencia. Cinco asientos por usuario nombrado significa cinco personas, cada una en su portátil, su equipo de escritorio y su VM, sin cargo extra. Esto coincide con cómo se vende realmente la mayoría del software B2B.
Su modo de fallo es el inicio de sesión compartido: si diez personas activan bajo un mismo ops@acme.example, cuentas un asiento y pierdes nueve. Los asientos por usuario nombrado solo son honestos cuando la identidad es una que el cliente no puede compartir con facilidad: un sujeto de SSO, no un buzón compartido.
Enlazar una activación a la dimensión correcta
El SDK se inicializa igual para ambos modelos; la diferencia es lo que adjuntas a la activación. Para una instalación autoalojada apuntas el cliente a tu servicio emisor y fijas la clave pública con la que se firman las licencias:
var keyright = new KeyrightClient(new KeyrightOptions
{
Product = "acme-suite",
PublicKeyBase64 = EmbeddedPublicKey, // fija en quién confías para firmar
ServiceUrl = "https://license.acme.example" // tu instancia autoalojada
});
Para un producto de asientos por dispositivo activas solo con la huella de la máquina. El SDK la deriva de señales estables del hardware y del sistema operativo; no la calculas a mano.
// Anclado al dispositivo: el asiento es la máquina. No se envía identidad.
var result = await keyright.ActivateAsync(licenseKey);
if (result.Status == ActivationStatus.SeatsExhausted)
ShowUpgradePrompt(result.SeatsUsed, result.SeatCeiling);
Para un producto de usuario nombrado pasas además una referencia de usuario estable. Haz que sea la identidad más resistente a manipulación que tengas: un sujeto de SSO (claim sub) es ideal, porque el propio IdP del cliente la avala y un usuario no puede acuñar una segunda para esquivar el conteo.
// Usuario nombrado: el asiento es la persona. La huella sigue viajando para límites de dispositivo.
var result = await keyright.ActivateAsync(licenseKey, new ActivationContext
{
UserRef = currentUser.Subject // p. ej. el claim "sub" de OIDC
});
La huella sigue acompañando una activación por usuario nombrado, y eso es lo que te permite limitar dispositivos por usuario (por ejemplo, “usuario nombrado, hasta 5 dispositivos cada uno”): un segundo tope que el servicio emisor aplica de forma independiente al conteo de usuarios. Enviar ambos enlaces en cada activación es también lo que hace indolora la migración de más abajo: una activación que lleva los dos se puede contar de cualquier manera.
Aplicar el tope en el lugar correcto
El conteo de asientos es una decisión del lado del servidor —no se puede confiar en que un cliente cuente su propia población—, pero la app licenciada aún debe restringir funciones localmente y fallar cerrada. Los dos trabajos se separan con nitidez.
El servicio emisor es dueño del conteo. Cuando llega una activación, proyecta la solicitud sobre la dimensión configurada de la licencia y la compara con el tope. En pseudocódigo la regla es la misma para ambos modelos; solo cambia la clave:
// Dentro del servicio emisor, simplificado.
string seatKey = license.SeatModel switch
{
SeatModel.Device => request.Fingerprint, // un asiento por máquina
SeatModel.NamedUser => request.UserRef // un asiento por identidad
?? throw new MissingUserRefException(), // usuario nombrado necesita identidad
_ => throw new UnreachableException()
};
var distinct = await _seats.CountDistinctAsync(license.Id, license.SeatModel);
bool alreadyHeld = await _seats.HoldsAsync(license.Id, seatKey);
if (!alreadyHeld && distinct >= license.SeatCeiling)
return ActivationResult.SeatsExhausted(distinct, license.SeatCeiling);
await _seats.UpsertAsync(license.Id, seatKey, request.Fingerprint);
Fíjate en que reactivar una identidad (o una máquina) que ya posee un asiento es idempotente: alreadyHeld cortocircuita la comprobación del tope, de modo que Alice añadiendo su tercer portátil bajo asientos por usuario nombrado nunca dispara “asientos agotados”, mientras que una sexta persona distinta sí lo hace.
La app, por su parte, nunca cuenta nada. Valida la licencia firmada que posee y restringe según los derechos, fallando cerrada, para que una caída de red nunca desbloquee silenciosamente una función:
var info = await keyright.ValidateAsync();
if (!info.IsValid || !info.Entitlements.Has("reporting"))
throw new FeatureLockedException("reporting"); // local, seguro sin conexión, siempre
Reconciliar asientos por dispositivo en asientos por usuario nombrado
La migración difícil es de dispositivo a usuario nombrado, porque los conteos no son intercambiables y un cambio descuidado o sobrevende (otorgas un asiento por dispositivo, ahora gratis) o bloquea (otorgas un asiento por usuario pero algunos usuarios superan de pronto su antiguo conteo de dispositivos). El camino seguro son tres pasos ordenados, y el primero te da tiempo.
1. Empieza a llevar la identidad antes de cambiar el modelo. Publica una versión que envíe UserRef en la activación mientras la licencia sigue contando dispositivos. Nada cambia para el cliente, pero cada nueva activación registra ahora qué persona posee cada máquina. Deja que esto repose hasta que la mayoría de las activaciones vivas lleven una identidad.
2. Reconcilia y luego dimensiona la nueva licencia. Agrupa las activaciones de dispositivo registradas por su UserRef. Cada grupo es un futuro asiento por usuario nombrado; el tamaño del grupo te dice cuántos dispositivos ejecuta ese usuario. El número de grupos es la cantidad de asientos por usuario nombrado que el cliente realmente necesita, que casi siempre es menor que su conteo de dispositivos, y ese es el argumento de venta del cambio.
// Colapsa las activaciones de dispositivo en asientos por usuario nombrado.
var seatsNeeded = activations
.Where(a => a.UserRef is not null)
.GroupBy(a => a.UserRef)
.Select(g => new NamedUserSeat(g.Key!, devices: g.Count()))
.ToList();
int newCeiling = seatsNeeded.Count; // personas, no máquinas
int maxDevices = seatsNeeded.Max(s => s.Devices); // dimensiona el tope de dispositivos por usuario
3. Emite una nueva licencia que cuente usuarios, dimensionada según la reconciliación. Fija el tope en newCeiling (más el margen que vendas) y el tope de dispositivos por usuario en al menos maxDevices, para que ningún usuario existente quede retroactivamente por encima del límite. Como las apps en campo validan contra la licencia firmada que recibirán, el cambio es invisible para ellas: siguen funcionando, el servicio emisor simplemente empieza a contar un sustantivo distinto. Las activaciones que nunca reportaron un UserRef son tu lista de limpieza: máquinas obsoletas que dejar expirar, o usuarios a los que perseguir por una identidad.
La migración inversa, de usuario nombrado a dispositivo, es más sencilla y rara vez deseada: cada huella distinta ya presente se convierte en un asiento por dispositivo, así que solo necesitas un tope al menos tan grande como el conteo actual de dispositivos distintos.
Elige el sustantivo y luego cuéntalo
Todo esto se reduce a una disciplina: decide si un asiento es una máquina o una persona antes de fijar el precio de la licencia, enlaza la activación exactamente a ese sustantivo y deja que el servicio emisor cuente esa única dimensión. Asientos por dispositivo para instalaciones, asientos por usuario nombrado para personas, y una identidad que no se pueda compartir cuando se trata de personas. Lleva ambos enlaces en cada activación y el modelo se convierte en un ajuste del lado del servidor que puedes cambiar —con una pasada de reconciliación— en lugar de una decisión congelada en tu población de campo.
Ambos modelos de asiento funcionan en Keyright autoalojado, incluida la Community Edition gratuita para un solo producto y un número modesto de licencias; las flotas multiproducto y los grupos de asientos más grandes son una actualización a una self-license de pago. En cualquier caso la regla de conteo es la misma, y lo único que llega a bloquear a un usuario que paga es enlazar un asiento al sustantivo equivocado.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.