Skip to content
← Todas las publicaciones
· Delta1 Labs Blazor ServerKeyright

Licenciar una app Blazor Server por circuito

En Blazor Server un ámbito de DI vive durante todo el circuito SignalR, no por solicitud, así que una licencia que validas cuando una pestaña se conecta sigue siendo la respuesta tres días después, mucho después de que la lease caducara. Aquí verás cómo acotar las entitlements de Keyright al circuito, mantenerlas al día durante toda su vida y mostrar una interfaz en modo degradado cuando cambian.

Una pestaña de Blazor Server puede permanecer abierta durante días. Detrás de ella, un circuito SignalR mantiene vivo un ámbito de inyección de dependencias durante toda la conexión, así que una licencia que validaste en el momento en que el circuito se abrió sigue siendo la respuesta que da la app al tercer día, mucho después de que la lease caducara y la prueba expirara. En ASP.NET Core con ámbito por solicitud ese fallo no puede ocurrir: el ámbito muere con la solicitud. En Blazor Server es el comportamiento por defecto, y es lo que la mayoría de equipos hacen mal al añadir licenciamiento a una app renderizada en servidor.

La pregunta real: ¿dónde vive una licencia en un circuito?

El instinto es registrar un LicenseService con ámbito, leerlo en tus componentes y seguir adelante. En MVC es correcto. En Blazor Server se rompe en silencio, porque un servicio con ámbito no está acotado a la solicitud, sino al circuito. Blazor crea exactamente un ámbito cuando el navegador establece su circuito y lo mantiene hasta que el circuito se desmonta. Navegar entre páginas no crea un ámbito nuevo. Pulsar botones no crea un ámbito nuevo. El ámbito es la conexión.

Así que una licencia leída una sola vez en el constructor de un servicio con ámbito queda congelada durante toda la sesión. Un cliente cuya evaluación de 30 días caduca a medianoche conserva todas las funciones de pago hasta que cierra la pestaña. No es un caso límite teórico; los paneles de larga duración son precisamente el punto fuerte de Blazor Server.

La solución tiene tres piezas en movimiento: un contexto con ámbito que guarda la instantánea actual de entitlements y anuncia los cambios, un CircuitHandler que lo rellena al conectar y lo mantiene al día durante la vida del circuito, y componentes que reaccionan a los cambios pasando a un modo degradado de solo lectura en lugar de mentir sobre lo que está licenciado.

Pestañacircuito SignalRCircuitLicenseContextuno por circuito (scoped)LicenseCircuitHandlerValidate() + bucle 5 minSDK de Keyright — Validate() offline, sin redFunción activaEntitlements onModo solo lecturaedición cambióválidacaducadaChanged → StateHasChanged
Un ámbito por circuito: el manejador toma la instantánea de la licencia al conectar, revalida con un temporizador y un evento de cambio re-renderiza los componentes en modo de solo lectura, todo offline.

Paso 1: un contexto con ámbito que falla cerrado y anuncia los cambios

El contexto guarda el último LicenseInfo y emite un evento cuando se reemplaza. Arranca en un estado de fallo cerrado para que, si algo va mal antes de que corra el manejador —prerenderizado, una condición de carrera, un manejador que lanza excepción—, la app se comporte como sin licencia en lugar de desbloqueada.

using Keyright;

public sealed class CircuitLicenseContext
{
    private LicenseInfo _info = LicenseInfo.None;   // fail closed until the handler fills it

    public LicenseInfo Current => _info;
    public event Action? Changed;

    public bool IsEnabled(string key)
        => _info.IsValid && _info.Entitlements.IsEnabled(key);

    public void Update(LicenseInfo next)
    {
        _info = next;
        Changed?.Invoke();
    }
}

IsEnabled falla cerrado por partida doble: una licencia inválida cortocircuita, y el propio IsEnabled del SDK de Keyright devuelve false para cualquier entitlement que no esté presente. No hay ningún camino en el que una entitlement ausente se lea como activa.

Paso 2: un CircuitHandler que mantiene fresca la instantánea

CircuitHandler es el gancho de ciclo de vida de Blazor Server. Registra uno con ámbito y Blazor lo instancia por circuito, llamando a OnCircuitOpenedAsync cuando la conexión se establece y a OnCircuitClosedAsync cuando se desmonta. Tomamos la instantánea de la licencia al abrir y luego ejecutamos un PeriodicTimer durante la vida del circuito para que una caducidad a mitad de sesión se detecte en lugar de quedar en caché para siempre.

using Keyright;
using Microsoft.AspNetCore.Components.Server.Circuits;

public sealed class LicenseCircuitHandler : CircuitHandler, IDisposable
{
    private readonly KeyrightClient _client;
    private readonly CircuitLicenseContext _context;
    private readonly CancellationTokenSource _cts = new();

    public LicenseCircuitHandler(KeyrightClient client, CircuitLicenseContext context)
        => (_client, _context) = (client, context);

    public override Task OnCircuitOpenedAsync(Circuit circuit, CancellationToken ct)
    {
        _context.Update(_client.Validate());          // snapshot at connect time
        _ = RevalidateLoop(_cts.Token);               // keep it fresh; don't await
        return Task.CompletedTask;
    }

    private async Task RevalidateLoop(CancellationToken ct)
    {
        using var timer = new PeriodicTimer(TimeSpan.FromMinutes(5));
        try
        {
            while (await timer.WaitForNextTickAsync(ct))
            {
                LicenseInfo next = _client.Validate();   // local, no network round-trip
                LicenseInfo now = _context.Current;
                if (next.Edition != now.Edition || next.IsValid != now.IsValid)
                    _context.Update(next);               // raises Changed → UI refresh
            }
        }
        catch (OperationCanceledException) { /* circuit closed */ }
    }

    public override Task OnCircuitClosedAsync(Circuit circuit, CancellationToken ct)
    {
        _cts.Cancel();
        return Task.CompletedTask;
    }

    public void Dispose() => _cts.Dispose();
}

Validate() es cálculo puramente local: verifica la firma contra la clave pública incrustada, comprueba la caducidad, el bloqueo por nodo y el estado del reloj, y lee el conjunto de entitlements de la lease que el SDK ya tenía en caché. Nunca toca la red ni lanza excepciones, así que ejecutarlo cada cinco minutos es barato y seguro. Solo emitimos Changed cuando la edición o la validez cambian de verdad, de modo que un circuito en estado estable no re-renderiza nada; el evento se dispara exactamente en la transición que importa: de pago a Community Edition, de válida a caducada.

Paso 3: componentes que degradan en lugar de mentir

Un componente se suscribe a Changed en OnInitialized, traslada el re-renderizado al contexto de sincronización del renderizador con InvokeAsync y cancela la suscripción al liberarse. Cuando la edición cambia, el control protegido se sustituye por un aviso de solo lectura en vez de desaparecer en silencio.

@implements IDisposable
@inject CircuitLicenseContext License

@if (License.IsEnabled("feature.export"))
{
    <button class="btn" @onclick="Export">Export report</button>
}
else
{
    <p class="notice">
        Export is read-only on @License.Current.Edition.
        Your license lapsed — renew to re-enable it without reloading.
    </p>
}

@code {
    protected override void OnInitialized() => License.Changed += OnLicenseChanged;

    private void OnLicenseChanged() => InvokeAsync(StateHasChanged);

    public void Dispose() => License.Changed -= OnLicenseChanged;
}

El evento Changed se emite desde el hilo del grupo del temporizador; InvokeAsync(StateHasChanged) salta de vuelta al despachador del circuito para que el re-renderizado sea seguro entre hilos. El usuario ve cómo el botón Export se convierte en un aviso de renovación en el instante en que la licencia caduca, en una pestaña que no tocó: sin recargar, sin bloqueo duro, sin fallos.

Cableado final

Tres registros. El cliente es singleton (carga la clave pública una vez y es inmutable); el contexto y el manejador tienen ámbito para que haya uno de cada por circuito.

builder.Services.AddSingleton(new KeyrightClient(o => o.PublicKey = PublicKeys.App));
builder.Services.AddScoped<CircuitLicenseContext>();
builder.Services.AddScoped<CircuitHandler, LicenseCircuitHandler>();

Registrar CircuitHandler como el tipo de servicio (no la clase concreta) es deliberado: Blazor descubre cada registro de CircuitHandler y los ejecuta todos, así que esto se compone con cualquier otro gancho de circuito que ya tengas.

Advertencias: dónde duele

El prerenderizado no tiene circuito. Durante el prerenderizado inicial en servidor no hay conexión SignalR, así que OnCircuitOpenedAsync aún no ha corrido y el contexto sigue en LicenseInfo.None. Por eso falla cerrado: el primer pintado renderizado en servidor muestra la interfaz sin licencia y luego el circuito se conecta y, si hay licencia, las funciones se activan. Si ese parpadeo es inaceptable, desactiva el prerenderizado para la página protegida o lee la licencia de forma síncrona durante el prerenderizado desde el cliente singleton.

Cada pestaña es un circuito. Dos pestañas significan dos ámbitos, dos contextos, dos bucles de revalidación y, si reclamas un asiento flotante por circuito, dos asientos. Cuando los asientos escasean, basa la reclamación del asiento en el usuario autenticado, lleva un recuento de referencias de sus circuitos abiertos entre OnCircuitOpenedAsync/OnCircuitClosedAsync y libera solo cuando el recuento llega a cero. Consulta asientos concurrentes flotantes para el lado del recuento de leases.

Cinco minutos es una ventana, no una garantía. Una licencia que caduca a las 12:00 se aplica a las 12:05 como muy tarde, nunca antes. Acorta el intervalo para una aplicación más estricta, pero recuerda que la verdadera línea de defensa está en el servidor: una verja de interfaz con ámbito de circuito es una cortesía hacia los usuarios honestos, no un sustituto de comprobar la entitlement allí donde se ejecuta el trabajo privilegiado. Combínalo con entitlements como políticas de autorización en tu superficie de API.

Conclusión

El modelo de Blazor Server en el que el ámbito es el circuito es el único hecho que convierte un patrón de licenciamiento correcto de ASP.NET Core en un fallo silencioso. Guarda la instantánea de entitlements en un contexto con ámbito, refréscala desde el temporizador de un CircuitHandler durante toda la vida del circuito y deja que los componentes se suscriban y degraden con elegancia: así una pestaña abierta durante una semana aplica su licencia con la misma fidelidad que una recién abierta. El Validate() offline y sin excepciones de Keyright es lo que hace el bucle de revalidación lo bastante barato como para correr para siempre.

Prueba Nebula.NET

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