Skip to content
← Todas las publicaciones
· Delta1 Labs LicensingKeyright

Evitar una estampida de revalidación de licencias con jitter

Cuando miles de clientes comparten un TTL de validación en caché o se reconectan todos tras una caída, sus llamadas de refresco se sincronizan en una avalancha. Así se aplica jitter a la revalidación en segundo plano del SDK para no hacer DDoS a tu propio servicio emisor.

Una comprobación de licencia en línea es barata hasta que todos la hacen a la vez. Un solo cliente de Keyright refrescando su lease en caché contra tu servicio emisor autoalojado es una petición de menos de un segundo que ocurre cada pocos minutos y no cuesta nada. Diez mil clientes refrescando en el mismo segundo es un evento completamente distinto — y las dos situaciones que lo producen son ambas corrientes, no exóticas.

La primera es un intervalo de refresco fijo. Si tu aplicación refresca cada quince minutos y unos miles de copias se desplegaron en la misma ventana de despliegue, sus temporizadores arrancan sincronizados en fase y siguen así. No se separan por sí solos; un PeriodicTimer sin más es determinista. Así que cada quince minutos, al minuto, toda la flota llama al servicio junta. La segunda es un borde de recuperación: tu servicio emisor tiene un parpadeo breve — una actualización progresiva, una rotación de certificado — y todos los clientes tiran de su lease en caché. En el momento en que el servicio vuelve a ser alcanzable, todos reintentan a la vez, y el servicio que apenas se estaba recuperando recibe una avalancha de regalo de bienvenida.

Ambas son el mismo fallo: revalidación sincronizada, una estampida que te infligiste a ti mismo. La solución no es más capacidad. Es impedir que los clientes se pongan de acuerdo sobre cuándo llamar.

Idea clave: Añade jitter aleatorio a la revalidación en segundo plano del SDK para que la flota reparta sus refrescos a lo largo del intervalo en vez de concentrarlos en los bordes. Usa full jitter para el refresco periódico en régimen estacionario y decorrelated jitter más Retry-After para los reintentos tras una caída. Apóyate en la ventana de gracia para que Validate() nunca espere a un refresco — que es lo que hace que el jitter sea gratis de añadir.

Por qué un intervalo fijo nunca se desincroniza

La intuición de que «al final se repartirán» es falsa para un temporizador fijo. Considera el refresco en segundo plano que casi todo el mundo escribe primero:

// ANTIPATRÓN: un intervalo fijo mantiene la flota sincronizada en fase para siempre.
using var timer = new PeriodicTimer(TimeSpan.FromMinutes(15));
while (await timer.WaitForNextTickAsync(ct))
    await License.RefreshAsync(ct);

PeriodicTimer dispara a una cadencia constante relativa a cuándo arrancó. Si dos procesos arrancaron con un segundo de diferencia — que es lo que hizo cada proceso de un mismo despliegue — se mantienen con un segundo de diferencia indefinidamente. No hay mecanismo que los separe. Lo único que perturba la fase alguna vez es un refresco que tarda más de lo normal, y bajo una estampida todos los refrescos tardan más, lo que tiende a re-sincronizarlos en lugar de dispersarlos.

Así que la tasa de peticiones de la flota contra el servicio emisor no es un goteo suave de una petición por cliente cada quince minutos. Es un pico de diez mil peticiones cada quince minutos y un silencio casi total en medio. Has construido un DDoS de frecuencia fija contra tu propio servicio.

Picos de refresco sincronizados frente a refresco con jitter repartido a lo largo del intervaloSincronizado: un intervalo fijo dispara toda la flota a la veztiempo10k pet10k pet10k pett=0+15m+30mCon jitter: el full jitter reparte la misma carga a lo largo de cada intervalotiempo~mismo total, sin pico

Full jitter en el refresco periódico

El remedio para el caso estacionario es programar cada siguiente refresco en un punto aleatorio uniforme dentro del intervalo en lugar de exactamente un intervalo después. Esto es full jitter: el retardo hasta el próximo refresco es un sorteo uniforme sobre [0, intervalo] (o, si quieres un suelo para que un cliente nunca golpee, sobre [intervalo/2, intervalo]). En uno o dos ciclos, una flota que arrancó perfectamente sincronizada en fase queda repartida de forma uniforme a lo largo de la ventana.

Aquí tienes un BackgroundService que calienta la licencia al arrancar y luego revalida con una planificación con full jitter. Se apoya en el SDK de la forma correcta: Validate() es la comprobación pura, offline y que nunca lanza, que sirve las decisiones de control desde el lease en caché; RefreshAsync es la única llamada que toca la red, y es la que sometemos a jitter.

public sealed class LicenseRefreshService(
    IKeyrightClient license, ILogger<LicenseRefreshService> log) : BackgroundService
{
    static readonly TimeSpan Interval = TimeSpan.FromMinutes(15);

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        // Calienta la caché una vez al arrancar para que la primera decisión de control sea fresca.
        await SafeRefreshAsync(ct);

        while (!ct.IsCancellationRequested)
        {
            TimeSpan delay = NextDelay();
            log.LogDebug("Next license refresh in {Delay}.", delay);
            try { await Task.Delay(delay, ct); }
            catch (OperationCanceledException) { break; }

            await SafeRefreshAsync(ct);
        }
    }

    // Full jitter sobre la segunda mitad del intervalo: nunca antes de interval/2,
    // nunca después de interval, uniformemente aleatorio en medio.
    static TimeSpan NextDelay()
    {
        double half   = Interval.TotalMilliseconds / 2;
        double jitter = Random.Shared.NextDouble() * half;   // [0, interval/2)
        return TimeSpan.FromMilliseconds(half + jitter);     // [interval/2, interval)
    }
}

Dos cosas hacen esto seguro. Random.Shared es una fuente por proceso, sembrada de forma independiente, así que diez mil procesos sortean diez mil retardos no correlacionados — no hay semilla compartida que los vuelva a sincronizar. Y el jitter se recalcula en cada ciclo, no una vez al arrancar, así que, aunque dos procesos sorteen el mismo primer retardo, divergen en el siguiente tick. La flota se mantiene repartida.

Refrescar sin dejar que un fallo lance nunca

El refresco en sí nunca debe tumbar la aplicación, y debe distinguir una respuesta definitiva de un servicio inalcanzable, porque solo esta última debe disparar un reintento. Es la misma separación transitorio-contra-definitivo que el SDK ya traza para las ventanas de gracia.

    async Task SafeRefreshAsync(CancellationToken ct)
    {
        try
        {
            RefreshResult r = await license.RefreshAsync(ct);
            switch (r.Status)
            {
                case RefreshStatus.Confirmed:
                    // Lease renovado; la ventana de gracia se reinicia. Nada que hacer.
                    break;

                case RefreshStatus.Revoked:
                case RefreshStatus.Expired:
                case RefreshStatus.SeatWithdrawn:
                    // Definitivo. Validate() informará ahora de Community Edition;
                    // nuestro control existente desactiva las funciones de pago. Sin reintento.
                    log.LogWarning("License no longer valid: {Reason}.", r.Reason);
                    break;

                case RefreshStatus.ServiceUnreachable:
                    // Transitorio. El lease en caché sigue en pie dentro de su ventana de gracia.
                    // NO reintentar en un bucle apretado — honra Retry-After y retrocede.
                    await BackoffRetryAsync(r.RetryAfter, ct);
                    break;
            }
        }
        catch (Exception ex) when (ex is not OperationCanceledException)
        {
            // Un refresco en segundo plano nunca debe tumbar el host.
            log.LogWarning(ex, "License refresh failed; continuing on cached lease.");
        }
    }

Fíjate en lo que no ocurre aquí: un resultado ServiceUnreachable no bloquea la aplicación. Validate() sigue respondiendo desde el lease firmado en caché durante toda la ventana de gracia, que es mucho más larga que el intervalo de refresco, así que un refresco perdido — o varios — no le cuesta nada al cliente. Precisamente por eso el jitter es gratis de añadir: mover el refresco unos minutos en cualquier dirección dentro de una ventana de gracia medida en días nunca puede caducar una licencia.

Decorrelated jitter y Retry-After para el borde de recuperación

El jitter periódico resuelve el régimen estacionario. El borde de recuperación necesita más, porque cuando el servicio vuelve todos los clientes quieren reintentar en el mismo instante. Reintentar en absoluto con un retardo corto fijo solo reconstruye la estampida. Dos herramientas la derrotan.

Honra Retry-After. Cuando el servicio emisor está descargando tráfico o volviendo a la vida, puede decir a los clientes cuánto esperar. Si el SDK expone un RetryAfter en el resultado inalcanzable, respétalo como un suelo — nunca reintentes antes.

Añade decorrelated jitter encima. El decorrelated jitter retrocede y aleatoriza a la vez: cada espera se sortea de un rango cuyo límite superior crece con la espera anterior, así que los fallos repetidos se separan cada vez más en vez de agruparse. La formulación clásica es sleep = min(cap, random_between(base, previous * 3)).

    async Task BackoffRetryAsync(TimeSpan? retryAfter, CancellationToken ct)
    {
        TimeSpan baseDelay = TimeSpan.FromSeconds(2);
        TimeSpan cap       = TimeSpan.FromMinutes(5);
        TimeSpan sleep     = baseDelay;

        for (int attempt = 0; attempt < 6 && !ct.IsCancellationRequested; attempt++)
        {
            // Decorrelated jitter: la siguiente espera es aleatoria en [base, previous * 3], acotada.
            double next = Random.Shared.NextDouble()
                        * (sleep.TotalMilliseconds * 3 - baseDelay.TotalMilliseconds)
                        + baseDelay.TotalMilliseconds;
            sleep = TimeSpan.FromMilliseconds(Math.Min(cap.TotalMilliseconds, next));

            // El Retry-After del servidor es un suelo; nunca reintentes antes de lo que pide.
            if (retryAfter is { } ra && ra > sleep) sleep = ra;

            try { await Task.Delay(sleep, ct); }
            catch (OperationCanceledException) { return; }

            RefreshResult r = await license.RefreshAsync(ct);
            if (r.Status != RefreshStatus.ServiceUnreachable) return;   // recuperado o definitivo
            retryAfter = r.RetryAfter;                                  // puede cambiar entre intentos
        }
        // Sigue inalcanzable: vuelve al bucle periódico. La ventana de gracia nos mantiene con licencia.
    }

Como cada cliente sortea su propia secuencia decorrelacionada, una flota de diez mil que perdió el contacto en el mismo segundo no reintentará toda en el mismo segundo. Se abren en abanico — unos pocos sondean temprano, la mayoría llega repartida por el rango de retroceso — y el servicio en recuperación ve una rampa, no un muro. Los que sondean temprano y lo logran dejan de reintentar; el resto encuentra el servicio sano en un intento posterior, escalonado de forma natural.

Por qué fallar-abierto-dentro-de-gracia es lo que hace esto seguro

Todo el diseño solo funciona porque un refresco tardío es inofensivo. Si tu decisión de control llamara a la red de forma síncrona — si Validate() se bloqueara esperando al servicio emisor — entonces el jitter sería un lujo que no te podrías permitir, porque un refresco retrasado sería un usuario retrasado. Al mantener Validate() como una comprobación offline pura sobre el lease firmado en caché, y honrar ese lease a través de una ventana de gracia mucho más larga que el intervalo de refresco, desacoplas cuándo revalidas de si el usuario puede trabajar ahora mismo. La revalidación se convierte en una tarea de mantenimiento en segundo plano cuyo momento exacto es tuyo para dispersar como quieras.

Ese desacoplamiento es también lo que impide que una estampida se convierta en una caída. Si una manada sincronizada abruma brevemente al servicio, los clientes que agotan su tiempo simplemente siguen funcionando con su lease en caché y reintentan más tarde con retroceso. El modo de fallo de «demasiados refrescos a la vez» es unos pocos refrescos que llegan un poco tarde — no una flota de clientes bloqueados. Puedes ajustar para la carga sin ceder jamás la disponibilidad.

Elegir tus números

Unas pocas reglas prácticas cierran esto. Fija el intervalo de refresco bastante por debajo de la ventana de gracia — un refresco de 15 minutos bajo una gracia de 72 horas te da cientos de oportunidades de reconectar antes de que nada falle cerrado, así que ningún refresco perdido suelto importa. Usa full jitter sobre la segunda mitad del intervalo para el bucle periódico, de modo que los refrescos se repartan pero ningún cliente pase mucho más de un intervalo entre comprobaciones. Acota el decorrelated backoff en unos pocos minutos para que una caída larga se asiente en un re-sondeo estable y escalonado en vez de derivar a horas. Y trata siempre Retry-After como un suelo, porque el único componente que sabe cuánta carga aguanta el servicio emisor ahora mismo es el servicio emisor.

Haz esas cuatro cosas y las dos estampidas — el pico de intervalo fijo y la manada del borde de recuperación — se aplanan ambas en una carga que tu instancia autoalojada apenas nota. La comprobación de licencia permanece invisible para tus clientes, que es exactamente donde debe estar una comprobación de licencia.

Prueba Nebula.NET

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