14 · Estaciones · MonitoreoLección 2 de 2
Monitoreo, drift y reentrenamiento
Monitoring, drift and retraining
El último paso del sistema de Alba: vigilar el servicio y el modelo en cinco capas, alertar solo cuando alguien puede y debe actuar, notar cuándo el mundo se movió y convertir esa señal en una decisión, con diagnóstico, antes de reentrenar.
Secciones16
- 01Lo que entra, lo que sale y lo que se decide
- 02Las fallas silenciosas y las cinco capas
- 03Las señales de servicio de Alba
- 04Una alerta bien hecha
- 05Burn rate: alertar con el presupuesto
- 06El modelo sin labels: baja confianza, score y PSI
- 07Los labels que llegan tarde
- 08Del aviso a la decisión: diagnosticar antes de reentrenar
- 09Vigilar al que vigila: el job diario y su frescura extra
- 10La guardia: dashboards, runbooks, fatiga y postmortems extra
- 11Errores comunes
- 12En la vida real extra
- 13Ejercicios
- 14Lo que sigue
- 15Palabras que vas a oír
- 16Chequeo
Todo contesta 200 OK, en 20 milisegundos, y el modelo empeora sin que nadie lo note. ¿Cómo se entera Alba, quién se despierta y quién no, y cuándo se manda a entrenar el modelo siguiente?
Imagina un martes cualquiera. El servicio contesta todo con 200 OK, el código de «todo bien». El p99 (el tiempo que deja abajo al 99 % de las requests) de cada pod del gateway (cada copia del programa que recibe las fotos) no pasa de ≈ 69 ms ni con el tráfico más alto para el que se diseñó. Los errores están en su nivel de siempre. Pero desde el viernes una versión nueva de la app del celular manda las fotos más comprimidas, y el modelo acierta un poco menos en esas fotos. Nadie lo ve en el dashboard (la página de gráficas) del servicio, porque para el servicio no pasó nada. Esta lección trata de cómo se nota eso, quién se entera, cuándo, y qué se hace con la señal.
Lo que entra, lo que sale y lo que se decide
EsencialIn, out and what gets decided
Alba es la empresa del curso: un marketplace en línea que recibe ≈ 2.5 millones de publicaciones nuevas al día y sugiere la categoría de cada foto entre 500 (el árbol tiene 501 desde que el 1 de octubre se agregó «bolsas», que el modelo en producción todavía no conoce). Con las fotos que piden otros equipos de Alba (moderación y búsqueda) son ≈ 10 millones de requests al día, una foto por request: ≈ 116 por segundo en promedio, ≈ 350 en el pico del día y 500 en su pico de diseño, el tráfico para el que se compraron las máquinas. La sugerencia la hace una ResNet-50 compilada como engine de TensorRT y servida por Triton, el servidor de modelos de NVIDIA, en Kubernetes, en AWS (us-east-1). Delante de Triton está el gateway, el programa en Python que recibe la foto, la prepara y le pide la respuesta a Triton; corre en varios pods, copias iguales del mismo programa. En noviembre de 2026 atiende la release 14 (en Alba, una release es un par: un gateway y un Triton de la misma versión): el modelo resnet50-2026-10-01, con el alias champion (el champion es el modelo que atiende a la gente), en triton-v14, dos pods con una GPU T4 cada uno. El modelo se reentrena cada mes. Lo opera un equipo de 5 personas.
Alba promete dos cosas, sus SLO (service level objectives, las metas medibles del servicio): p99 ≤ 200 ms del lado del servidor (lo que tarda dentro de Alba, sin la red del usuario), y 99.9 % de las requests sin error del servidor en cada ventana de 30 días. Ese 0.1 % que sobra es su presupuesto de error: el 0.1 % de los ≈ 300 millones de requests de 30 días (10 millones × 30), ≈ 300,000 requests al mes; o, contado en tiempo, el 0.1 % de los 43,200 minutos del mes, 43.2 minutos.
Lo que entra
Lo que dejó «La request en vivo» y lo que llega después:
- El log de cada request: una línea de ≈ 300 bytes por foto, con su
request_id, elmodel_version, elsource(de dónde viene la foto:mobile, la app del celular;web;internal, otro sistema de Alba; la métrica sumaother), el top-5 (las 5 categorías más probables) con sus scores (la probabilidad que el modelo le da a cada una), los milisegundos de cada tramo, los bytes de la foto y el código de respuesta. Son ≈ 3 GB al día (300 bytes × 10 millones) que llegan a S3 por el camino del log y quedan en Parquet (tablas guardadas por columnas), partidos por día (dt) y pormodel_version: ≈ 0.5 GB al día, guardados 90 días. - Las métricas: los números con nombre que lleva cada pod, como
classifier_requests_total, y que Prometheus lee cada 15 segundos. - Las trazas del ≈ 1 % de las requests (el recorrido de una request por cada programa, con lo que tardó en cada uno), y lo que mide el ALB (el balanceador de la entrada) en CloudWatch, el servicio de métricas de AWS.
- Los eventos del backend de publicaciones, el programa que llama al clasificador:
suggestion_shown(la pantalla pintó las 5 sugerencias) ycategory_selected(qué categoría quedó y por qué vía). - Las correcciones de moderación, cuando una persona de Alba cambia la categoría de una publicación ya hecha.
- El holdout: el ≈ 1 % de las cuentas de vendedor que nunca ve sugerencias y elige la categoría a mano.
Lo que sale
- Alertas con dueño y runbook: cada una dice quién la recibe y qué hacer.
- Tickets cuando una señal del modelo se mueve: trabajo de la semana, no de las 3 de la mañana.
- Un disparador de reentrenamiento: una corrida adelantada del pipeline mensual, que solo lanza una persona después de un diagnóstico.
- Muestras para etiquetar: la cola del mes, ≈ 5,000 fotos que etiquetan personas pagadas, y, si un ticket lo pide, una tanda extra de un slice (un pedazo del tráfico que se mide por separado, como las fotos de un solo
source). Con eso el ciclo vuelve a la estación 1.
Lo que se decide
- 1
Qué se vigila y con qué retraso
Unas señales llegan en segundos y otras en semanas.
- 2
Qué despierta a alguien
Un page despierta a la guardia, la persona de turno; un warning espera al horario; un ticket es trabajo de la semana.
- 3
Cómo se alerta con el presupuesto
Con qué tan rápido se gasta el presupuesto del mes, no con «más de 1 % de errores».
- 4
Contra qué se compara el modelo
Qué referencia, qué ventana y cuánto tiempo sostenido.
- 5
Qué se descarta antes de reentrenar, y quién decide
Un error propio no se arregla reentrenando, y nada se despliega solo.
Las fallas silenciosas y las cinco capas
EsencialSilent failures and the five layers
Un servidor web roto se nota: deja de contestar, o contesta 500. Un modelo roto sigue contestando con la misma latencia y la misma confianza aparente. Eso es una falla silenciosa (silent failure): todo responde 200 OK mientras las predicciones empeoran.
Y casi nunca cambió el modelo. El engine de la release 14 es el mismo archivo que pasó el gate (el examen automático que decide si un modelo entra) en octubre; sus pesos no se mueven. Lo que cambió es el mundo que lo alimenta: las fotos, la gente, lo que se vende. Eso es el drift. A veces cambia lo que entra (una cámara nueva, la luz de noviembre); a veces cambia la relación entre lo que entra y la respuesta correcta, el concept drift (una categoría nueva que parte a otra en dos). Las dos cosas las ves a fondo en «Comparar distribuciones: cómo se mide el drift».
Cinco capas, de la más rápida a la más lenta
Para notar lo que no truena, Alba vigila cinco capas, cada una con sus señales y su retraso:
| Capa | Qué mira en Alba | Cuánto tarda en avisar |
|---|---|---|
| Infraestructura | nodos, GPU, pods listos | segundos |
| Servicio | p99, errores 5xx, fila de Triton | segundos a minutos |
| Datos | bytes de las fotos por source, tasas de 400, 413 y 415 | minutos |
| Modelo | score top-1, tasa de baja confianza, PSI de las categorías | minutos a 1 día |
| Negocio | aceptación, recategorización de moderación, holdout | horas a semanas |
Los 400, 413 y 415 son los códigos con que el gateway rechaza una foto: mal formada, demasiado grande o que no es imagen. El score top-1, la baja confianza y el PSI se explican en «El modelo sin labels».
Las dos capas de arriba existen en cualquier servicio. Las tres de abajo son de ML. Y la regla que las ordena es incómoda: cuanto más abajo, más lenta la señal y más cerca de lo que importa. Lo que de verdad importa es si la sugerencia fue correcta, y eso solo lo dice un label (la categoría correcta), que llega tarde.
La app nueva: una falla silenciosa con números
El caso del martes, con números de ejemplo. El viernes sale una versión nueva de la app del celular que procesa distinto las fotos: más compresión y un filtro de contraste. El backend la sigue mandando con source=mobile. Así se ve en cada capa:
| Capa | Lo que se ve | ¿Suena algo? |
|---|---|---|
| Infraestructura | nada | no |
| Servicio | el p99 de un pod del gateway, ≈ 69 ms en el pico de diseño, y 5xx en el 0.1 % del SLO | no |
| Datos | las fotos de mobile bajan de ≈ 210 KB a ≈ 140 KB de mediana, en minutos | no hay alerta: se ve en el dashboard, si alguien mira |
| Modelo | la tasa de baja confianza (las fotos en que el modelo duda: su probabilidad más alta queda abajo de 0.3) sube de 4 % a 5.5 % del total | no: la alerta pide el doble, ≈ 8 % |
| Negocio | 6 días después, la aceptación de mobile (cuántas veces quien vende elige una de las sugerencias) cae de 70.1 % a 66.2 % semana contra semana | sí: un ticket |
La señal rápida (los bytes) estaba ahí desde el primer minuto, pero no prueba nada: una foto más chica no tiene por qué ser peor. La señal lenta (la aceptación) sí prueba que algo empeoró, pero tardó casi una semana. Monitorear un modelo es vivir entre esas dos: usar las rápidas para sospechar y las lentas para confirmar.
Y fíjate qué no se debe hacer con ese ticket: reentrenar. El modelo no tiene la culpa; la tiene un cambio en quien llama. Reentrenar le enseñaría a convivir con un bug que se arregla en la app. Lo verás en «Del aviso a la decisión».
Las señales de servicio de Alba
EsencialAlba's service signals
Las dos capas de arriba se vigilan como cualquier servicio web, con recetas conocidas.
Señales doradas, RED y USE
Las señales doradas (golden signals), del libro de SRE de Google (Site Reliability Engineering, la disciplina de mantener servicios en pie), son cuatro preguntas para cualquier servicio:
- Latencia: cuánto tarda. En Alba, el p99 del histograma
classifier_request_latency_seconds(«latencia de cada request del clasificador, en segundos»), contra los 200 ms del SLO. - Tráfico: cuánto le piden. Las requests por segundo, ≈ 116 en promedio y ≈ 350 en el pico.
- Errores: cuántas fallan. La fracción de 5xx (los códigos de error del servidor) sobre las requests que no son 4xx (los 4xx son culpa de quien llama: no cuentan).
- Saturación: qué tan lleno está: qué tan cerca del punto en que empieza a hacer esperar.
Dos recetas más cortas dicen lo mismo desde dos ángulos. RED (rate, errors, duration: tasa, errores, duración) es para cada servicio: el gateway y Triton tienen cada uno su tasa, sus errores y su latencia. USE (utilization, saturation, errors: utilización, saturación, errores) es para cada recurso: cada GPU, cada nodo, cada disco.
Saturación: la fila, no el porcentaje
La tentación es medir la saturación con la utilización de la GPU: «está al 100 %, está llena». No es así. La utilización dice qué fracción del tiempo la GPU tuvo algo que hacer, no si alguien esperaba. Lo viste en «Qué tan rápido y cuánto: latencia y throughput»: la saturación se nota en el tiempo de espera en la fila.
Por eso la señal de saturación de Alba es la espera media en la fila de Triton. Triton lleva dos contadores (números que solo suben): los microsegundos que todas sus requests pasaron en la fila, acumulados, y cuántas requests terminó bien. La espera media en una ventana es el cociente de lo que creció cada uno:
- donde
- Dq
- los microsegundos que las requests pasaron en la fila durante la ventana: lo que creció el contador
nv_inference_queue_duration_us, en µs - Nok
- las requests que Triton terminó bien en la misma ventana: lo que creció
nv_inference_request_success, en requests - ÷
1,000 - pasa de µs a ms
- W
- la espera media en la fila, en ms
Un minuto del pico, con números de ejemplo: el contador de la fila crece Dq = 42,000,000 µs y el de éxitos Nok = 21,000 (350 por segundo × 60). La espera media es 42,000,000 ÷ 21,000 = 2,000 µs = 2 ms. Tranquilo.
Con esa misma espera trabaja KEDA, el programa que escala Triton: busca que la espera media de los últimos 2 minutos quede en 10 ms, con 2 réplicas (copias de Triton) como mínimo y 4 como máximo. Si la espera pasa de 20 ms durante 10 minutos, el doble de su objetivo, salta el warning TritonQueueTimeHigh («la espera en la fila de Triton está alta»): KEDA no está alcanzando. La utilización tiene su propio warning, GPUSaturated («GPU saturada»), si una GPU pasa de 85 % durante 15 minutos. Se mide por GPU, sin sumar: el promedio de una al 100 % y otra al 40 % da un 70 % tranquilo que esconde a la que se ahoga.
Una alerta bien hecha
EsencialA well-made alert
Una regla de alerta es una regla que Prometheus evalúa cada cierto tiempo: si una expresión da verdadero el tiempo suficiente, avisa a alguien. Escribirla es fácil. Escribirla bien es lo que separa a una guardia que duerme de una que deja de creer en sus alertas.
La anatomía
Cada alerta de Alba lleva seis cosas:
- Un nombre que es el síntoma:
ClassifierHighP99Latency(«el p99 de la latencia del clasificador está alto») dice qué siente el usuario, no qué pieza falló. Se alerta por síntomas; las causas se buscan después. - Una condición y una ventana, que salen del SLO: «p99 > 200 ms».
- Un
for: cuánto tiempo debe sostenerse la condición antes de disparar. - Una severidad: page, warning o ticket.
- Un dueño: una rotación de personas, nunca «el equipo».
- Un runbook: el documento que dice qué revisar y qué hacer, enlazado en la alerta misma.
Y una prueba: si no hay acción posible, no es un page.
Las tres severidades
| Severidad | Qué significa en Alba | A quién le llega |
|---|---|---|
| page | el usuario está afectado ahora y alguien puede arreglarlo ahora | a la persona de guardia, que la reconoce en ≤ 5 minutos, de día o de noche |
| warning | una causa que anticipa un page | al canal del equipo, en horario de trabajo |
| ticket | la calidad del modelo y las tendencias | a la cola del equipo de ML; se revisa en la semana |
La guardia es una rotación semanal entre las 5 personas del equipo; en los ejemplos, la que está de guardia es Marta. Fíjate en lo que la tabla deja fuera de su teléfono: la calidad del modelo. Nadie debería despertarse a las 3 de la mañana porque subió el PSI. Un cambio en el modelo se entiende mirando muestras y datos, con calma, y en Alba el usuario tiene un respaldo: si no hay sugerencia, Ana, la vendedora de los ejemplos, elige la categoría en el selector manual.
Las alertas de Alba
| Severidad | Alerta | Condición |
|---|---|---|
| page | ClassifierHighP99Latency(p99 alto) | p99 > 200 ms durante 10 min |
| page | ClassifierErrorBudgetFastBurn(el presupuesto se quema rápido) | el presupuesto se gasta 14.4× más rápido de lo permitido, en 1 h y en 5 min |
| page | TritonNotReady(Triton no está listo) | menos de 2 pods listos del Triton de la release vigente (triton-v14 hoy) durante 5 min |
| page | ALB5xx(5xx del ALB) | los 5xx que pone el propio ALB pasan de 0.5 % del total en 5 min (RequestCount más esos 5xx; en CloudWatch) |
| warning | TritonQueueTimeHigh(fila de Triton alta) | espera en la fila > 20 ms durante 10 min |
| warning | GPUSaturated(GPU saturada) | una GPU > 85 % durante 15 min |
| warning | LogsStale(logs atrasados) | no llega un archivo de log nuevo a S3 en 30 min |
| ticket | ClassifierErrorBudgetSlowBurn(el presupuesto se quema lento) | 6× en 6 h y en 30 min |
| ticket | ClassifierLowConfidenceSpike(pico de baja confianza) | la baja confianza pasa del doble de su promedio de 7 días durante 30 min |
| ticket | drift de categorías | PSI > 0.2 tres días seguidos |
| ticket | caída de aceptación | > 3 puntos semana contra semana |
| ticket | MonitoringJobStale(job de monitoreo atrasado) | el job diario no publica en 26 h |
La alerta del p99 y sus 10 minutos ya los viste en «Promedios, medianas y percentiles». Las de errores van por burn rate, lo que sigue.
for: que dure antes de sonar
Sin for, una regla dispara en la primera evaluación que da verdadero. Un deploy reinicia un pod, un minuto sale lento, y suena. Con for: 10m (10m es «10 minutos» en la notación de Prometheus), la alerta queda pendiente mientras la condición se cumple y solo dispara si sigue cumpliéndose 10 minutos después. Si en medio una evaluación da falso, el reloj vuelve a cero. El costo: 10 minutos más tarde en avisar. Por eso el for se elige con el SLO: el p99 de Alba se vigila en ventanas de 5 minutos, y dos ventanas seguidas malas ya no son un pico.
Tráfico bajo: un error no es una tasa
A las 4 de la mañana, en un minuto pueden llegar unas pocas decenas de requests. Si en una ventana hay 20 requests y una falla, la tasa es 5 %, cincuenta veces el 0.1 % permitido. Una regla que solo mira la fracción despertaría a Marta por una sola request. La defensa es pedir volumen además de fracción: la alerta de baja confianza de Alba exige más de 1 request por segundo en su ventana. Es la misma idea del canary de «Rollout seguro» (la versión nueva recibe primero una parte chica del tráfico): no se juzga hasta que junta un mínimo de requests.
La serie que no está
Si un pod del gateway muere, sus métricas desaparecen: no valen cero, simplemente no hay serie. Y una regla que divide errores entre requests no da «verdadero» ni «falso» sobre una serie que no existe: no da nada, y no dispara. El servicio caído tiene el dashboard más tranquilo del mundo.
Tres defensas:
- Mirar si se pudo leer: Prometheus guarda para cada pod que lee la serie
up, que vale 1 si la lectura funcionó y 0 si no.up == 0sí da resultado cuando el pod no contesta, mientras Prometheus lo siga teniendo en su lista. Si el pod desaparece del todo (Kubernetes lo borra y ya no aparece en el Service, el objeto que lista los pods que reciben tráfico), suuptambién desaparece: por eso hacen falta las otras dos defensas. - Preguntar por la ausencia:
absent(serie)da 1 justo cuando la serie no existe. - Alertar desde quien espera:
TritonNotReadyno le pregunta a Triton si está bien. Cuenta, desde Kubernetes (con kube-state-metrics, el programa que publica el estado de los objetos del clúster como métricas), cuántos pods detriton-v14están listos. YALB5xxmira desde el ALB: si todos los gateways salen del balanceador, el ALB contesta 503 él mismo y el gateway no cuenta nada, porque nadie le llegó. Lo viste en «La request en vivo».
Reglas de grabación: precalcular lo caro
Algunas expresiones son caras: la tasa de errores de las últimas 6 horas suma millones de muestras. Si cada alerta la recalcula en cada evaluación, Prometheus trabaja de más. Una regla de grabación (recording rule) la calcula cada cierto tiempo (en Alba, cada minuto) y guarda el resultado como una serie nueva, con un nombre propio. Alba graba la tasa de errores en cuatro ventanas (classifier:error_ratio:rate5m, …rate30m, …rate1h y …rate6h) y la tasa de baja confianza en 30 minutos. El nombre sigue una costumbre de tres partes: nivel (classifier), métrica (error_ratio) y operación (rate1h).
Alertmanager: de la alerta a la persona
Prometheus decide que una alerta suena. Quién se entera y cómo lo decide el Alertmanager, un programa aparte que en Alba vive en el namespace monitoring (el espacio con nombre del clúster donde corre todo el monitoreo). Hace cuatro cosas:
- Agrupa: las alertas de un mismo incidente llegan en una sola notificación. Alba agrupa por nombre de alerta y por namespace.
- Deduplica: si hay dos Prometheus iguales por seguridad, la misma alerta llega dos veces; Alertmanager manda una.
- Inhibe: calla las alertas que son consecuencia de otra. Si
TritonNotReadyestá sonando, los warning de la fila de Triton se callan: claro que la fila está mal, si no hay Triton. - Silencia: durante un mantenimiento anunciado, alguien pone un silencio con hora de fin.
- monitoreo-diario · 01:00 UTC
El job diario: pasa el log a Parquet, calcula el PSI de las ≈ 30 categorías padre y la aceptación por slice, y publica cada resultado como gauge (una métrica que sube y baja). Tarda ≈ 20 min. - gateway y Triton · /metrics
Cada pod lleva sus métricas en memoria y las expone en/metrics(el gateway en el puerto 8080, Triton en el 8002). Si el pod muere, sus series desaparecen. - ALB · la entrada
El balanceador. Ve lo que el gateway no: si todos los gateways salen de su lista, contesta 503 él mismo. - Pushgateway · último valor
Guarda lo que el job le empuja hasta que alguien lo borre, máspush_time_seconds, la hora del último envío. Por eso existeMonitoringJobStale(26 h). - Prometheus · cada 15 segundos
Lee/metricsde cada pod cada 15 segundos (lo declaran un ServiceMonitor para Triton y un PodMonitor para el gateway) y guarda 15 días. Para cada pod que lee, guarda tambiénup: 1 si pudo leer, 0 si no. - Grafana · 4 dashboards
Los dashboards: servicio, Triton y GPU, modelo y negocio. Consulta a Prometheus; no decide nada. - CloudWatch · alarma ALB5xx
El servicio de métricas de AWS. La alarmaALB5xxes un page si los 5xx del propio ALB pasan de 0.5 % del total en 5 min. El total sumaRequestCounty esos 5xx, porqueRequestCountno cuenta las requests que no llegaron a un destino. - reglas · grabación y alerta
Las reglas de grabación precalculan las tasas de error (5 min, 30 min, 1 h, 6 h) y la baja confianza; las reglas de alerta las comparan con su umbral, sufory su severidad. - Alertmanager · agrupa e inhibe
Alertmanager vive en el namespacemonitoring, con Prometheus y Grafana. Agrupa por alerta y namespace, deduplica, calla los warning de Triton mientrasTritonNotReadysuena y respeta los silencios de mantenimiento. - cola de ML · ticket
Los tickets: calidad del modelo y tendencias. Se revisan en la semana, en horario. - canal del equipo · warning
Los warning: causas que anticipan un page, como la fila de Triton arriba de 20 ms. Se miran en horario de trabajo. - Marta · page · ≤ 5 min
La persona de guardia de la semana. Recibe solo los page y los reconoce en ≤ 5 minutos, de día o de noche.
Para ir más hondoLa regla, como la escribe Alba+
Las reglas viven en el repositorio de despliegue, como objetos PrometheusRule que carga el operador de Prometheus (el programa que instala y configura Prometheus en Kubernetes): cambiar una alerta es un PR que otra persona revisa. Por eso TritonNotReady cambia en el mismo PR que la release: cuando entre la 15, mirará triton-v15.
Una parte de la PrometheusRule de Alba, como ilustración (necesita Prometheus): la regla de grabación de 1 hora y la alerta rápida de errores.
groups:
- name: classifier-slo
rules:
- record: classifier:error_ratio:rate1h # 5xx ÷ requests sin 4xx, en 1 h
expr: |
sum(rate(classifier_requests_total{status=~"5.."}[1h]))
/ sum(rate(classifier_requests_total{status!~"4.."}[1h]))
- alert: ClassifierErrorBudgetFastBurn
expr: |
classifier:error_ratio:rate1h > (14.4 * 0.001)
and classifier:error_ratio:rate5m > (14.4 * 0.001)
labels: # etiquetas de la alerta, no labels de entrenamiento
severity: page
annotations:
summary: "El presupuesto de errores se gasta 14.4× más rápido de lo permitido"
runbook_url: "https://runbooks.alba.example/classifier/error-budget-burn"Burn rate: alertar con el presupuesto
EsencialBurn rate: alerting with the budget
¿Cuántos errores son demasiados? La respuesta ingenua es un umbral fijo: «más de 1 % de 5xx en 5 minutos». Tiene dos problemas. Cinco minutos al 1.1 % se comen una parte diminuta del mes (≈ 0.13 % del presupuesto, con la fórmula de abajo) y despiertan a alguien igual. Y un 0.5 % sostenido toda una semana nunca dispara, aunque se coma todo el presupuesto del mes y un poco más: 0.5 % es 5 veces el 0.1 % permitido, y una semana es 168 de las 720 horas del mes, así que gasta 5 × 168 ÷ 720 ≈ 117 % del presupuesto. El umbral fijo no sabe cuánto daño hace un error; el presupuesto sí.
La fórmula
El burn rate (velocidad de gasto) es qué tan rápido se gasta el presupuesto comparado con el ritmo que lo agotaría justo al final de los 30 días. En «Probabilidad para sistemas que fallan» lo calculaste para un deploy malo: con 5 % de errores contra un presupuesto de 0.1 %, se gasta 50 veces más rápido. Aquí van las mismas letras de esa lección (S, p, R, B, F, f), con un cambio: las horas de la ventana son t, y no h, para no confundirlas con la unidad.
- donde
- S
- el SLO de disponibilidad, como fracción: 0.999 en Alba
- 1−
S - el presupuesto como fracción de las requests: 0.001
- p
- la fracción de requests con error del servidor en la ventana (5xx ÷ requests sin 4xx), como fracción
- β
- el burn rate, en veces: 1× gasta el presupuesto justo en los 30 días
- t
- la duración de la ventana de la alerta, en horas
- V
- la ventana del SLO, en horas: 30 días = 720 h
- f
- la fracción del presupuesto del mes que se gasta en esas t horas
- ta
- las horas que tardaría en agotarse el presupuesto completo a ese ritmo
- R
- las requests al día: ≈ 10,000,000 en Alba
- B
- el presupuesto del mes, en requests: B=
(1− = 300,000 (es una letra de la cuenta, no la B de bytes)S)× R× 30 - F
- las requests con error en la ventana, F=
R÷ . No la confundas con f: F cuenta requests y f es la fracción del presupuesto, f=24× t× p F÷ B
Las tres líneas dicen lo mismo de tres formas. Si β = 1, la fracción p es justo el 0.1 % y el presupuesto dura las 720 horas. Si β = 2, dura la mitad. Y en una ventana de t horas se gasta la parte t÷
De dónde salen 14.4× y 6×
Los números de Alba vienen del libro de trabajo de SRE de Google (The Site Reliability Workbook), y salen al revés: primero se decide cuánto presupuesto se tolera perder antes de avisar, y de ahí se despeja β. Despejando la segunda línea, β=
- Page: perder 2 % del presupuesto en 1 hora. β = 0.02 × 720 ÷ 1 = 14.4.
- Ticket: perder 5 % en 6 horas. β = 0.05 × 720 ÷ 6 = 6.
El libro de SRE pone el de 6× como page. Alba lo manda a ticket porque tiene un respaldo: si el clasificador falla, Ana elige la categoría en el selector manual. Un 0.6 % de errores durante 6 horas se arregla en horario; un servicio sin respaldo, como un pago, lo dejaría en page. El libro tiene además un tercer nivel, 1× en 3 días (ticket), que Alba no usa. Sin él, el goteo de 0.5 % de toda una semana (5×) no llega al 6× y ninguna alerta de Alba lo ve. El último ejercicio lo calcula.
Dos ventanas: la larga confirma, la corta apaga
Cada alerta de burn rate mira dos ventanas a la vez, y dispara solo si las dos pasan el umbral: 1 hora y 5 minutos para el page, 6 horas y 30 minutos para el ticket. La corta mide 1/12 de la larga, la proporción que recomienda el libro, para bajar en minutos. Es una alerta multiventana (multiwindow, multi-burn-rate alert).
¿Para qué dos? La ventana larga es la que confirma: un pico de 2 minutos no mueve el promedio de una hora, así que no despierta a nadie. Pero tiene memoria: después del arreglo, la hora siguiente sigue cargando los errores de antes, y la alerta seguiría sonando media hora con el servicio ya sano. La ventana corta es la que apaga: 5 minutos después del arreglo vuelve a la normalidad, y como la regla pide las dos, la alerta se calla.
Para ir más hondoEl mismo incidente, minuto a minuto+
Supone el mismo número de requests cada minuto, así que la fracción de una ventana es el promedio de sus minutos:
S = 0.999 # el SLO: 99.9 % sin error del servidor
p = [0.001] * 150 # fracción con error, minuto a minuto
for minuto in range(60, 100): # un incidente: 3 % de errores por 40 min
p[minuto] = 0.03
def burn(fin, largo): # β de la ventana de `largo` minutos que acaba en `fin`
ventana = p[fin - largo + 1 : fin + 1]
return sum(ventana) / largo / (1 - S)
sonando = False
for minuto in range(60, 150):
larga, corta = burn(minuto, 60), burn(minuto, 5)
ahora = larga > 14.4 and corta > 14.4
if ahora != sonando:
estado = "SUENA" if ahora else "se apaga"
print(f"min {minuto - 60:>2}: {estado:8} 1 h = {larga:4.1f}× 5 min = {corta:4.1f}×")
sonando = ahora
print(f"solo con la de 1 h se apagaría en el min {next(m - 60 for m in range(100, 150) if burn(m, 60) <= 14.4)}")min 27: SUENA 1 h = 14.5× 5 min = 30.0×
min 42: se apaga 1 h = 20.3× 5 min = 12.6×
solo con la de 1 h se apagaría en el min 72Suena en el minuto 27 y se apaga en el 42, 2 minutos después del arreglo (el incidente ocupa los minutos 0 a 39), con la ventana de 1 hora todavía en 20×. Son los mismos minutos de la figura. Sin la ventana corta, Marta vería la alerta sonar media hora más con todo ya bien.
¿Y si el incidente es peor? Con p = 100 % (todo falla), β = 1 ÷ 0.001 = 1,000, y la ventana de 1 hora cruza 14.4× en 14.4 ÷ 1,000 = 0.0144 horas: ≈ 0.9 minutos de errores. En la práctica suena en uno o dos minutos, porque Prometheus lee cada 15 segundos y las reglas se evalúan cada minuto. La alerta se adapta sola: cuanto más grave, más rápido suena.
Elige el SLO, la fracción de errores y la ventana. La calculadora aplica β=
Supone el mismo tráfico todas las horas. Con p = 0.1 % y S = 99.9 %, β = 1: el presupuesto dura justo los 30 días.
Arranca con el page de Alba: 1.44 % de errores en 1 hora. Sube p a 5 % (el deploy malo de «Probabilidad para sistemas que fallan») y mira cómo el mes se agota en 14.4 horas. Luego pon p = 0.6 % y t = 6 h: es el ticket.
El modelo sin labels: baja confianza, score y PSI
EsencialThe model without labels: low confidence, score and PSI
En el momento de la request nadie sabe si la sugerencia fue correcta. Lo que sí se sabe es lo que el modelo contestó y cómo venía la foto. Con eso se arman los proxies de calidad (proxy metrics): señales sin labels que avisan «algo cambió» en minutos. Ninguna prueba que el modelo empeoró. Sirven para sospechar, abrir un ticket, mirar muestras y mandar a etiquetar.
Alba tiene tres:
- El score top-1: la probabilidad de la categoría que quedó en primer lugar. El histograma
classifier_top1_score(«score top-1 del clasificador») lo cuenta pormodel_version, con 10 bordes (0.1, 0.2, …, 1.0): para cada borde, cuántas fotos tuvieron un top-1 menor o igual. - La tasa de baja confianza: qué fracción de las fotos tiene top-1 menor que 0.3.
- El PSI de las categorías: qué tanto cambió la mezcla de categorías predichas.
La tasa de baja confianza
Alba llama «foto dudosa» a la que tiene top-1 < 0.3, el umbral que viste en «Qué es un modelo». En un día normal son ≈ 4 % de las fotos: ≈ 400 mil de los ≈ 10 millones. La tasa sale de dos contadores del histograma del score, en una ventana de 30 minutos:
- donde
- Nbaja
- las requests de la ventana con top-1 menor que 0.3: lo que creció el bucket
le="0.3"del histograma del score (lees less or equal, «menor o igual»: cuenta también las de 0.3 exacto, una diferencia que no se nota) - Ntotal
- todas las requests de la ventana: lo que creció el total del histograma (
_count) - c
- la tasa de baja confianza, como fracción
- c7
- el promedio de c en los últimos 7 días, como fracción
La alerta ClassifierLowConfidenceSpike abre un ticket si c > 2 × c7 durante 30 minutos y además llega más de 1 request por segundo. Se compara contra su propio promedio, no contra un número fijo, porque la tasa normal se mueve con las temporadas: una campaña de bicicletas la sube un poco y eso no es una falla.
La tasa se calcula con una regla de grabación, classifier:low_confidence_share:rate30m («la fracción de baja confianza en 30 minutos»), cada minuto.
Para ir más hondoPor qué se graba, y la expresión+
¿Por qué grabarla? Porque la alerta la compara con su promedio de 7 días. Promediar 7 días de la expresión cruda en cada evaluación obligaría a Prometheus a releer una semana de buckets cada vez; promediar la serie grabada, una muestra por minuto, es barato. Por eso Prometheus guarda 15 días en Alba: la alerta necesita al menos 7.
Así se ve, como ilustración, la expresión que graba esa regla (es PromQL, el lenguaje de consultas de Prometheus que presenta «La request en vivo»):
sum(rate(classifier_top1_score_bucket{le="0.3"}[30m]))
/ sum(rate(classifier_top1_score_count[30m]))El PSI del día, contra qué y cuánto tiempo
El PSI (Population Stability Index, índice de estabilidad de la población) mide qué tanto se movió una distribución. Parte los datos en bins (las casillas de un histograma; aquí, cada bin es una categoría padre) y suma, bin por bin, la diferencia entre la proporción de hoy y la de la referencia, multiplicada por el logaritmo de su cociente. La cuenta completa y cómo se lee están en «Comparar distribuciones: cómo se mide el drift»; aquí importa lo operativo.
Alba lo calcula una vez al día sobre la mezcla de categorías predichas, agrupadas en sus ≈ 30 categorías padre (las ramas de arriba del árbol, como «Calzado», que contiene a «Calzado › Tenis»). Así lo hace también el canary de «Rollout seguro», que mide el PSI de cada hora mientras entra una versión nueva: allí, con 500 bins y una hora de datos, el puro azar daba un PSI alto. Con un día entero de fotos ese ruido es chico, pero agrupar igual hace que las dos cuentas se lean igual y que un slice chico no se infle de azar.
En una semana normal, el PSI de cada día sale ≈ 0.002. La lectura de costumbre: menos de 0.1 es estable; de 0.1 a 0.25, un cambio moderado; más de 0.25, uno grande. Alba pone su umbral en 0.2.
La pregunta difícil es contra qué se compara. Es la referencia del drift, y cada opción ve una cosa y se pierde otra («Comparar distribuciones: cómo se mide el drift» las compara todas):
| Referencia | Qué pregunta responde | Qué se pierde |
|---|---|---|
El mes con que se entrenó el champion (su snapshot, la copia congelada de los datos: ds-2026-09-01 para la 14) | ¿ve algo que no aprendió? | si el mundo se movió para siempre, suena sin parar |
| Las 4 semanas previas | ¿cambió de golpe? | un cambio lento nunca se ve: cada semana se parece a la anterior |
Alba usa las dos: las 4 semanas previas para la alerta, y el mes del snapshot del champion para el reporte mensual, que ve los cambios lentos.
Y el cuánto tiempo: el ticket se abre si el PSI pasa de 0.2 tres días seguidos. Un solo día raro (un festivo, una campaña) no basta. En «Comparar distribuciones: cómo se mide el drift», en «Chi-cuadrado y las falsas alarmas», viste cuánto rinde pedir que dure: si una prueba da falsa alarma el 5 % de los días y los días fueran independientes, tres seguidos pasan 1 vez de cada 8,000 (0.05 × 0.05 × 0.05 = 1 ÷ 8,000). Allí también está por qué Alba usa el PSI y no un p-value (la probabilidad de ver un cambio así por puro azar): con millones de fotos, la prueba KS da p ≈ 0 por cualquier cambio diminuto.
Para ir más hondoLa regla de los tres días, en Python+
La regla, día por día:
psi = { # PSI diario de las 30 categorías padre
"11-03": 0.002, "11-04": 0.24, "11-05": 0.003, "11-06": 0.21,
"11-07": 0.23, "11-08": 0.004, "11-09": 0.22, "11-10": 0.26,
"11-11": 0.29, "11-12": 0.31,
}
UMBRAL, DIAS = 0.2, 3 # la regla de Alba: > 0.2 tres días seguidos
racha = 0
for dia, valor in psi.items():
racha = racha + 1 if valor > UMBRAL else 0
marca = " <- ticket" if racha == DIAS else ""
print(f"{dia} PSI {valor:.3f} racha {racha}{marca}")11-03 PSI 0.002 racha 0
11-04 PSI 0.240 racha 1
11-05 PSI 0.003 racha 0
11-06 PSI 0.210 racha 1
11-07 PSI 0.230 racha 2
11-08 PSI 0.004 racha 0
11-09 PSI 0.220 racha 1
11-10 PSI 0.260 racha 2
11-11 PSI 0.290 racha 3 <- ticket
11-12 PSI 0.310 racha 4Dos días sueltos arriba de 0.2 no abren nada; tres seguidos, sí, y abren un solo ticket aunque la racha siga.
Los labels que llegan tarde
EsencialLabels that arrive late
La pregunta que de verdad importa, «¿acertó?», solo la contesta un label. En Alba los labels llegan de tres fuentes, cada una con su retraso y su trampa. Son labels demorados, como viste en «Datos y etiquetas».
Tres fuentes, tres retrasos
| Fuente | Qué es | Retraso | Su trampa |
|---|---|---|---|
| Aceptación | si quien vende eligió una de las 5 sugerencias | minutos a horas | está sesgada por lo que el modelo mostró |
| Moderación | cuando un moderador recategoriza una publicación ya hecha | días | solo mira lo que alguien reportó o revisó |
| Holdout | la categoría que eligió a mano el ≈ 1 % que nunca ve sugerencias | 1 a 2 meses (madura a los 30 días) | la sugerencia no la sesga, pero tarda |
La aceptación, y por qué no basta
La tasa de aceptación es, de las publicaciones donde la pantalla pintó las sugerencias, la fracción cuya categoría se eligió por la vía «sugerencia». Su base es ≈ 70 %, y la mide el backend con suggestion_shown y category_selected (la vía puede ser sugerencia, búsqueda o el árbol de categorías).
La aceptación es la señal más rápida de negocio, pero miente un poco. Quien vende tiende a aceptar lo que le pusieron enfrente: si el modelo sugiere «Calzado › Tenis» para unos zapatos de vestir, mucha gente lo deja. Es el feedback loop de «Datos y etiquetas»: contra lo que elige quien vende, el modelo parece acertar ≈ 95 %, cuando de verdad acierta ≈ 85 %. Diez puntos de optimismo.
El holdout: la medida limpia
La defensa es una muestra que no depende del modelo: el holdout, ≈ 1 % de las cuentas de vendedor (elegidas por el hash de su seller_id, como viste en «Datos y etiquetas») que nunca ve sugerencias: ≈ 25 mil publicaciones al día, ≈ 750 mil al mes. Ahí la persona elige sola, así que comparar contra su elección el top-1 del champion da la exactitud sin la huella de la sugerencia (quien vende también se equivoca: eso lo mide la muestra al azar): ≈ 85 %, con ± 0.1 punto de ruido. La que dice el examen fijo del gate, el golden set, también es ≈ 85 %: la brecha offline–online de Alba hoy es casi cero. Si un mes el holdout cae a 82 % y el golden set sigue en 85 %, el mundo ya no se parece al examen.
El precio del holdout es el tiempo: un label se cree hasta que pasan 30 días sin corrección de moderación (la regla de maduración), así que la medida limpia de este mes llega en uno o dos meses.
Cuánto ruido tiene una tasa
Una caída de 3 puntos en la aceptación, ¿es real o es azar? Depende de cuántas publicaciones la midieron. Es el intervalo de confianza de «Ruido, muestras y pruebas A/B», aplicado a una tasa:
- donde
- a
- la tasa medida, como fracción: 0.70 para la aceptación de Alba
- n
- cuántas publicaciones entraron en la medida (el slice en la ventana)
- z
- cuántos errores estándar abarca el intervalo, sin unidad: 1.96 para uno de 95 %
- m
- el margen: la tasa verdadera está en a±
m con 95 % de confianza; como fracción (× 100 para puntos) - nmin
- cuántas publicaciones hacen falta para que el margen quede en m
De ahí sale la regla de Alba para los slices (los pedazos del tráfico que se miden por separado: por source, por las ≈ 30 categorías padre y por model_version): un slice solo alerta si tiene al menos 5,000 publicaciones en su ventana. Abajo de eso, se mira en el reporte, pero no se abre ticket.
Para ir más hondoComparar dos semanas tiene más ruido+
El disparador compara esta semana contra la anterior, y las dos tienen ruido. El margen de una diferencia de dos tasas independientes con el mismo n es z×
Para ir más hondoTres slices de una semana, en Python+
Tres slices de una semana, con números de ejemplo: los dos source más grandes y una categoría padre chica.
import math
Z, N_MIN, CAIDA = 1.96, 5_000, 0.03 # 95 %, n mínimo y el disparador (3 puntos)
slices = { # slice: (n esta semana, a esta semana, a la anterior)
"source=mobile": (10_400_000, 0.662, 0.701),
"source=web": ( 6_100_000, 0.703, 0.699),
"padre=Instrumentos": ( 3_100, 0.640, 0.690),
}
for nombre, (n, a, a_antes) in slices.items():
m = Z * math.sqrt(a * (1 - a) / n) # margen al 95 %
if n < N_MIN:
veredicto = "n chico: no alerta"
elif a_antes - a > CAIDA:
veredicto = "ticket"
else:
veredicto = "estable"
print(f"{nombre:19} a = {a:.1%} ± {m * 100:.2f} pts "
f"cambio {(a - a_antes) * 100:+.1f} pts {veredicto}")source=mobile a = 66.2% ± 0.03 pts cambio -3.9 pts ticket
source=web a = 70.3% ± 0.04 pts cambio +0.4 pts estable
padre=Instrumentos a = 64.0% ± 1.69 pts cambio -5.0 pts n chico: no alertamobile es el caso de la app nueva: cayó 3.9 puntos con un ruido de centésimas, y abre ticket. La categoría chica cayó más, 5 puntos, y quizá sea real, pero con 3,100 publicaciones no llega al n mínimo: queda en el reporte, donde alguien la mira con calma. Con ≈ 30 categorías padre y varios source, docenas de slices chicos se moverían cada semana por azar; el n mínimo evita que cada uno abra un ticket.
Cuánto se mueve por azar una tasa medida con n publicaciones. La calculadora aplica m=
El margen solo cubre el azar de qué publicaciones entraron. Si la tasa está sesgada (la aceptación lo está por la sugerencia), el intervalo sale igual de angosto y no lo avisa.
Arranca con un slice de 5,000 y la aceptación de 70 %. Baja n a 500 y mira cómo el margen pasa los 3 puntos del disparador. Luego mueve el margen que quieres: con ± 1 punto, el n mínimo ya es ≈ 8 mil.
Del aviso a la decisión: diagnosticar antes de reentrenar
EsencialFrom the alert to the decision: diagnose before retraining
Ya hay un ticket. La tentación es reentrenar: «el modelo empeoró, que aprenda lo nuevo». A veces es lo correcto. Muchas veces no: reentrenar sobre un bug propio le enseña el bug al modelo.
Tres cosas que se descartan primero
Antes de tocar el modelo, quien recibe el ticket descarta, en este orden:
- 1
Un deploy propio
¿El cambio empezó justo cuando entró una release, del modelo o del gateway? Si coincide, es nuestro: se hace rollback con el runbook de rollback de «Rollout seguro», no se reentrena.
- 2
Datos rotos del lado de quien llama
¿El cambio está en un solo
source, o empezó con una versión nueva de la app? Se avisa al dueño de ese cambio. Es el caso de la app nueva. - 3
Training-serving skew
¿Prepara el gateway la foto igual que el entrenamiento? El training-serving skew de «Una foto, vista por un modelo» se ve como drift, pero es un bug: si empeoró desde el día de un deploy, es tu código. Se corre la prueba de paridad de punta a punta: las mismas fotos por el camino del entrenamiento y por el del gateway, y se compara lo que sale.
Solo si cambió el mundo, y los labels lo confirman, se adelanta el reentrenamiento.
De la señal a la acción
| Lo que se ve | Lo que se hace |
|---|---|
| Cambió justo tras un deploy propio | rollback; no reentrenar |
Un input raro en un solo source | avisar al dueño; no reentrenar |
| PSI alto, labels estables | etiquetar una muestra; por ahora, nada más |
| PSI alto y labels peores en el mismo slice | tanda extra de ese slice y reentrenar |
| Labels peores en todos lados, inputs estables | concept drift o cambio de criterio: revisar la guía de etiquetado y reetiquetar |
| Un cambio anunciado (una categoría nueva) | no esperar a la alerta: planearlo |
| Nada raro | el calendario mensual |
Los disparadores, y quién aprieta el botón
En Alba, un reentrenamiento se dispara por cuatro caminos:
- El calendario: la corrida
reentreno-mensual, el día 1 de cada mes a las 03:00 UTC, que viste en «Versionado y linaje». Tarda ≈ 4–5 horas y cuesta ≈ US$3–4 de GPU. - El PSI > 0.2 tres días seguidos.
- La aceptación, si cae más de 3 puntos semana contra semana.
- Una categoría nueva en el árbol, como «bolsas» el 1 de octubre (el árbol pasó de 500 a 501 categorías). Esta es planeada: se sabe antes y no espera a ninguna alerta.
Ninguno de los cuatro reentrena solo. Un disparador abre un ticket, y después del diagnóstico una persona del equipo decide. Si decide adelantar, lanza la corrida a partir del mismo CronWorkflow, la tarea programada de Argo Workflows (el programa que corre los pipelines de Alba dentro de Kubernetes) que lanza reentreno-mensual cada mes:
argo submit --from cronwf/reentreno-mensualEs un comando de ilustración: necesita el clúster de Alba. La corrida adelantada arma un snapshot extra con la fecha del día de corte, por ejemplo ds-2026-11-18 si se lanza el 18 de noviembre, con los labels vigentes ese día. La corrida del día 1 sigue igual.
Y si el ticket lo pide, la persona también encarga una tanda extra de etiquetado: ≈ 500 fotos del slice afectado, elegidas al azar dentro del slice del log, encima de la cola normal de ≈ 5,000. A 5–10 centavos de dólar por foto son ≈ US$25–50, y tardan ≈ 5 días hábiles. Sin labels nuevos del slice que falla, el modelo nuevo no tiene de dónde aprender lo que cambió.
El modelo nuevo sube la misma escalera
Que el disparo sea urgente no salta ningún paso: el mismo gate contra el champion, la paridad del engine, el shadow (despliegue en sombra) de 1–2 días (contesta copias de requests reales sin que nadie vea su respuesta) y el canary de 5 % y 25 % del tráfico, 4 horas cada uno, y luego 100 %, con 24–48 horas de bake time (la versión anterior sigue prendida, para volver a ella con solo cambiar el ruteo). La política en una frase: un reentrenamiento que arranca solo está bien; uno que llega a producción sin gate ni canary, no.
El ciclo se cierra
Con esto la estación 12 entrega lo que la estación 1 necesita: qué fotos etiquetar (la cola del mes, y la tanda extra si hubo ticket) y cuándo armar el snapshot siguiente. Las fotos dudosas que mide la baja confianza son las mismas que la cola elige por incertidumbre. El sistema es un círculo: los datos entrenan un modelo, el modelo atiende, el monitoreo mira cómo atiende, y lo que ve decide qué datos siguen.
- señal · PSI · aceptación
Un disparador: PSI > 0.2 tres días seguidos, o la aceptación cae más de 3 puntos semana contra semana en un slice con ≥ 5,000 publicaciones. - ticket · cola de ML
Un disparador abre un ticket, no un deploy. Nada se reentrena ni se despliega solo. - persona del equipo · descarta 3 cosas
Descarta en orden: (1) un deploy propio, (2) datos rotos de quien llama, (3) training-serving skew. Solo si cambió el mundo y los labels lo confirman, adelanta la corrida. - rollback · si fue un deploy
Si el cambio empezó con una release propia, se vuelve a la anterior con el runbook de rollback. Reentrenar le enseñaría el bug al modelo. - aviso al dueño · si fue quien llama
Si el cambio vive en un solosource(la app nueva), se avisa al equipo dueño de ese cambio. El modelo no tiene la culpa. - tanda extra · ≈ 500 fotos
≈ 500 fotos del slice afectado, al azar dentro del slice, encima de la cola de ≈ 5,000: ≈ US$25–50 y ≈ 5 días hábiles. - corrida adelantada · argo submit
Una persona la lanza desde el CronWorkflowreentreno-mensual. Tarda ≈ 4–5 h y cuesta ≈ US$3–4 de GPU. La del día 1 sigue igual. - snapshot · ds-2026-11-18
El snapshot extra lleva la fecha del día de corte y los labels vigentes ese día (aquí, si se lanzara el 18 de noviembre). - cola del mes · estación 1
El ciclo vuelve a empezar: la cola de ≈ 5,000 fotos de cada mes, con las dudosas que eligió la baja confianza. - la misma escalera · gate → canary
El candidato pasa el gate, la paridad, el shadow de 1–2 días, el canary de 5 % y 25 % y el bake. Urgente no quiere decir sin pasos.
Vigilar al que vigila: el job diario y su frescura
ExtraWatching the watcher: the daily job and its freshness
El PSI del día, la aceptación por slice y los bytes por source no salen de ningún pod con métricas: los calcula un job que corre y termina. En Alba es el CronWorkflow monitoreo-diario de Argo Workflows, a las 01:00 UTC, sobre el día UTC anterior. Tarda ≈ 20 minutos y hace cinco cosas:
- Pasa el log crudo de S3 a Parquet, partido por
dtymodel_version. - Calcula el PSI de las ≈ 30 categorías padre contra las 4 semanas previas.
- Calcula la aceptación por día y por slice (une el log con los eventos del backend por
request_id). - Cuenta bytes y tasas de 4xx por
source. - Publica cada resultado como gauge (una métrica que sube y baja) en el Pushgateway.
Por qué un Pushgateway
Prometheus lee métricas de quien está vivo: cada 15 segundos hace un scrape, va y pregunta. Un job de 20 minutos tiene sus resultados hasta el final, justo antes de terminar a las 01:20: ningún scrape los alcanza con seguridad, y después ya no hay a quién preguntar. El Pushgateway es un programa que se queda prendido: el job le empuja sus resultados al terminar, y Prometheus los lee de ahí como de cualquier pod.
La trampa: el Pushgateway nunca olvida
El Pushgateway guarda el último valor de cada serie hasta que alguien lo borre: no tiene caducidad. (Solo lo pierde si se reinicia sin guardar a disco.) Si el job deja de correr (un cambio de permisos en S3, una imagen que ya no existe), el último PSI se queda publicado para siempre: 0.002, estable, día tras día. El dashboard se ve perfecto, y nada se está midiendo.
La defensa es medir la frescura del job: cuánto hace que publicó por última vez. El Pushgateway guarda, para cada grupo de métricas, la serie push_time_seconds: la hora del último envío, en segundos desde 1970. La alerta MonitoringJobStale abre un ticket si time() - push_time_seconds pasa de 26 horas. ¿Por qué 26 y no 24? El job corre cada 24 horas y tarda ≈ 20 minutos; con 2 horas de margen, un día en que tarde un poco más no abre un ticket, y uno en que no corre sí.
Es la misma idea de LogsStale: si no llega un archivo nuevo de log a S3 en 30 minutos, algo se rompió en el camino aunque nadie se queje. Un monitor que puede morir en silencio necesita su propio monitor.
La guardia: dashboards, runbooks, fatiga y postmortems
ExtraOn-call: dashboards, runbooks, fatigue and postmortems
Un dashboard por audiencia
Un dashboard es una página de gráficas en vivo; Alba los arma en Grafana, que consulta a Prometheus. Tiene cuatro, porque cada audiencia hace otra pregunta:
| Dashboard | Para quién | Qué tiene |
|---|---|---|
| Servicio | la guardia | arriba, el SLO y el presupuesto que queda; abajo, tasa, errores y latencia por tramo, con marcas de cada deploy |
| Triton y GPU | la guardia y el equipo | fila contra cómputo, batch promedio, réplicas contra el tope de KEDA |
| Modelo | el equipo de ML | score top-1, baja confianza, las 20 categorías más grandes contra su línea base; todo por model_version |
| Negocio | producto | diario: aceptación, recategorización, publicaciones completadas |
Un dashboard que sirve a los tres no le sirve a ninguno: la guardia a las 3 de la mañana necesita ver en 10 segundos si el SLO está en peligro, no buscarlo entre 40 gráficas de categorías.
El runbook del p99
Un runbook es la receta de qué hacer cuando suena una alerta, escrita en calma para usarse con prisa. El de ClassifierHighP99Latency, en el orden en que Marta lo sigue:
- 1
¿Qué tramo subió?
El preproceso, la fila de Triton o el cómputo. El dashboard de servicio los muestra por separado.
- 2
¿Hubo deploy?
Si el salto coincide con una release, rollback con el runbook de «Rollout seguro».
- 3
¿KEDA está en su tope de 4 réplicas?
Si la fila crece y ya no hay más réplicas, falta GPU: se sube el tope o se agrega capacidad.
- 4
¿Un cliente manda de más?
Si un solo cliente duplicó su tráfico, se aplica su cuota.
- 5
Escalar
Si en 30 minutos no mejora, Marta llama a otra persona del equipo.
La regla de fondo: mitigar primero, entender después. A las 3 de la mañana, volver a la versión anterior y entender mañana es mejor que entender ahora con el SLO ardiendo.
Fatiga de alertas
Si una alerta suena seguido y nunca pasa nada, la gente deja de mirarla, y la vez que importa también la ignora. Eso es la fatiga de alertas. Se mide así: qué fracción de los pages terminó en una acción. Con números de ejemplo: si en un mes hubo 12 pages y en 9 alguien hizo algo, 75 %; los 3 restantes son candidatos a borrar o a bajar a warning. Una alerta que nadie atendió en un mes no protege nada: estorba.
Postmortem sin culpables
Después de todo page con impacto en los usuarios, Alba escribe un postmortem sin culpables en ≤ 5 días hábiles. Es sin culpables (blameless): no busca quién se equivocó, sino qué dejó que el error llegara a producción. Lleva línea de tiempo, impacto, con qué señal se detectó y acciones con dueño y fecha.
En ML la pregunta clave es otra: ¿qué señal lo habría detectado antes? Si a la app nueva la descubrió la aceptación 6 días después, la acción puede ser una alerta de datos: un aviso si la mediana de bytes de un source cae más de un cuarto en un día. Si lo encontró un usuario, falta una métrica. Si lo encontró una alerta tres semanas tarde, falta una señal más rápida.
Errores comunes
EsencialCommon mistakes
En la vida real
ExtraIn real life
Alba. Todo lo de esta lección corre todos los días: 12 alertas con su severidad, un job diario que publica el PSI y la aceptación por slice, una guardia de 5 personas y una política que no deja que nada se despliegue solo.
Inspección industrial. Un modelo que rechaza piezas defectuosas solo recibe labels de las que rechazó, porque esas las revisa una persona. Se ve cuántos rechazos eran falsos (la precisión), pero no cuántas piezas malas pasaron (el recall). La defensa es la idea del holdout: piezas patrón con defectos conocidos y una muestra de aprobadas que se revisa a mano.
Un sistema con cola de mensajes. Si un sistema procesa trabajos de una cola, su saturación no es cuántos mensajes hay, sino la edad del más viejo: mil mensajes que salen en un segundo no preocupan; uno que lleva una hora, sí. Y los mensajes que siempre fallan terminan en la DLQ, que tiene su propia alerta.
Fraude y recomendación. En fraude, solo se sabe que una transacción lo era cuando alguien reclama, semanas después, y solo de las que el modelo dejó pasar. En recomendación, solo se sabe si gustó lo que se mostró. En los dos, como en la aceptación de Alba, el label está filtrado por el modelo, y hace falta una muestra chica al azar que no lo esté.
Un LLM o el asistente con RAG. Un LLM genera texto token por token (pedazos de palabra); con RAG (retrieval-augmented generation), antes de contestar busca y lee los documentos que sirven. El asistente interno de Alba responde así ≈ 25 mil preguntas al día con los documentos de la empresa. Su latencia se vigila por token (el tiempo hasta el primer token y entre tokens), y su calidad, con muestras de respuestas que califica una persona u otro modelo: ahí no hay «aceptación» automática.
Ejercicios
EsencialExercises
Resuélvelos con lápiz antes de abrir la solución. Usa las letras de la lección: S, p, β, t, V, f, ta, R, B, F (burn rate); c, c7, Nbaja, Ntotal (baja confianza); a, n, z, m, nmin (el ruido de una tasa); W, Dq, Nok (la fila de Triton).
- 1Fácil
Un deploy malo hace fallar 2 % de las requests de Alba. ¿Cuál es su burn rate? ¿Suena el page si dura una hora? ¿En cuántas horas se acabaría el presupuesto del mes?
Ver la solución paso a paso
- β=
p÷ = 0.02 ÷ 0.001 = 20×.(1− S) - La ventana de 5 minutos pasa 14.4× casi enseguida. La de 1 hora promedia 20× por la fracción de la hora que lleva el deploy, así que llega a 14.4× cuando esa fracción es 14.4 ÷ 20: a los 14.4 ÷ 20 × 60 ≈ 43 minutos. Si dura una hora, sí suena.
- ta=
V÷ = 720 ÷ 20 = 36 horas.β
- β=
- 2Fácil
Clasifica cada alerta en page, warning o ticket, como Alba: (a) la fila de Triton en 25 ms durante 15 minutos; (b) la baja confianza en 9 % durante una hora; (c) el ALB contesta 503 a todo; (d) el PSI en 0.23 un solo día.
Ver la solución paso a paso
- (a) Warning (
TritonQueueTimeHigh): anticipa un page, pero el usuario todavía no está afectado. - (b) Ticket (
ClassifierLowConfidenceSpike): es calidad del modelo; si la base es ≈ 4 %, 9 % pasa el doble. - (c) Page (
ALB5xx): todos los usuarios están afectados ahora. - (d) Nada todavía: la regla pide más de 0.2 tres días seguidos.
- (a) Warning (
- 3Fácil
En un minuto del pico, el contador de la fila de Triton crece Dq = 1,470,000,000 µs y el de éxitos Nok = 21,000. ¿Cuánto es W? ¿Suena algo si dura así 10 minutos?
Ver la solución paso a paso
- W=
Dq÷ = 1,470,000,000 ÷ 21,000 ÷ 1,000 = 70,000 ÷ 1,000 = 70 ms.Nok÷ 1,000 - Pasa los 20 ms: tras 10 minutos, warning
TritonQueueTimeHigh. Con 70 ms de fila, la request típica de 20 ms ya va en ≈ 90, y el p99 se acerca a los 200: es probable que pronto también suene el page del p99.
- W=
- 4Fácil
La aceptación de un slice es 70 % con n = 2,000 publicaciones. ¿Cuánto es su margen? ¿Puede alertar en Alba?
Ver la solución paso a paso
- m=
z× = 1.96 × √(0.21 ÷ 2,000) = 1.96 × 0.0102 ≈ ± 2.0 puntos.√(a× (1− a)÷ n) - No alerta: tiene menos de 5,000. Se ve en el reporte.
- m=
- 5Medio
El PSI del día sale 0.25 el martes, el miércoles y el jueves. Ese martes entró la release del gateway que cambió cómo se decodifica WebP. La aceptación no se movió. ¿Qué se hace?
Ver la solución paso a paso
- Se abre el ticket (tres días seguidos arriba de 0.2), pero el diagnóstico va primero.
- Deploy propio: el cambio empezó el día de la release. Es lo primero que se descarta, y aquí coincide. Se compara el PSI por formato de foto; si el salto está en las WebP, es el código.
- Acción: rollback del gateway o un arreglo, y una prueba de paridad que incluya WebP. No se reentrena: el modelo aprendería a convivir con una decodificación rota.
Para ir más hondoCinco ejercicios más, para la segunda pasada+
- 1Medio
Durante 6 horas, Alba falla 0.8 % de las requests y en la última media hora sigue igual. ¿Qué alerta suena? ¿Cuántas requests fallaron y qué parte del presupuesto se fue?
Ver la solución paso a paso
- β=
p÷ = 0.008 ÷ 0.001 = 8×: pasa 6× en 6 h y en 30 min, pero no 14.4×. Suena el ticket(1− S) ClassifierErrorBudgetSlowBurn, no el page. - F=
R÷ = 416,667 × 6 × 0.008 ≈ 20,000 requests.24× t× p - f=
β× = 8 × 6 ÷ 720 ≈ 6.7 % del mes (= 20,000 ÷ 300,000).t÷ V
- β=
- 2Medio
A las 4 de la mañana llegan 25 requests por segundo. En media hora, ¿cuántas fotos dudosas dispararían
ClassifierLowConfidenceSpikesi c7 = 4 %? ¿Y si el tráfico fuera de 0.5 requests por segundo?Ver la solución paso a paso
- Ntotal = requests por segundo × 1,800 s = 25 × 1,800 = 45,000. El ticket pide Nbaja>
2× = 0.08 × 45,000 = 3,600 fotos dudosas, sostenido 30 minutos.c7× Ntotal - Con 0.5 por segundo no llega al volumen mínimo (más de 1 por segundo): no dispara, por más alta que sea la tasa. Con 900 requests en la media hora, 18 fotos dudosas de más moverían la tasa 2 puntos.
- Ntotal = requests por segundo × 1,800 s = 25 × 1,800 = 45,000. El ticket pide Nbaja>
- 3Medio
Una persona propone cambiar
MonitoringJobStalede 26 a 48 horas «para que haga menos ruido». ¿Qué se pierde? Supón que el job deja de correr el lunes a las 01:00 UTC, justo después de su última corrida buena del domingo.Ver la solución paso a paso
- Con 26 h: la última publicación fue el domingo ≈ 01:20; el ticket se abre el lunes ≈ 03:20, ≈ 2 horas después de la corrida que faltó.
- Con 48 h: se abre el martes ≈ 01:20. Un día entero más con el PSI y la aceptación congelados en el valor del domingo.
- Si en esos días empieza un drift real, la regla de «3 días seguidos» tarda un día más en contar. El ruido que se ahorra es casi cero: el job corre una vez al día.
- 4Reto
Diseña la señal que habría detectado la app nueva antes que la aceptación. Tienes el histograma
classifier_image_bytes(los bytes de cada foto) porsource. La mediana demobilebajó de ≈ 210 KB a ≈ 140 KB. Propón una regla con su severidad, su ventana y su defensa contra falsas alarmas, y di por qué no debe ser un page.Ver la solución paso a paso
- Una regla que compara la mediana (el p50 estimado desde los buckets) de bytes de cada
sourcecontra su promedio de 7 días: aviso si cae más de 25 % durante 2 horas. 140 ÷ 210 ≈ 0.67: una caída de ≈ 33 %, que la pasa. - Defensas: volumen mínimo por
source(queinternal, con poco tráfico, no dispare solo),forde 2 horas y comparar cadasourcecontra sí mismo, no contra el total. - Severidad: ticket. Una foto más chica no prueba que el modelo falle; abre una investigación (¿hubo una versión nueva de la app?) y le gana 6 días a la aceptación. No es page porque el usuario no está afectado de forma medible ahora y la guardia no puede arreglar la app de madrugada.
- Una regla que compara la mediana (el p50 estimado desde los buckets) de bytes de cada
- 5Reto
Alba quiere un tercer nivel de burn rate, como el del libro de SRE: perder 10 % del presupuesto en 3 días. ¿Qué β le toca, qué ventana corta y qué fracción de errores? ¿Qué severidad le pondrías?
Ver la solución paso a paso
- β=
f× = 0.10 × 720 ÷ 72 = 1×: gastar el presupuesto justo al ritmo que lo acaba en el mes.V÷ t - Ventana corta: 1/12 de 72 h = 6 horas.
- p=
β× = 0.1 %: el ritmo normal permitido, sostenido 3 días.(1− S) - Severidad: ticket. A ese ritmo el mes alcanza justo; no hay emergencia, pero conviene saberlo antes de gastar el resto en deploys.
- β=
Lo que sigue
EsencialWhat comes next
Esta es la última estación, y no termina: devuelve el sistema a donde empezó.
- «Datos y etiquetas» recibe la cola del mes, las tandas extra y las fotos dudosas; relee «El feedback loop y el holdout» con lo que ahora sabes de la aceptación.
- «Versionado y linaje» arma el snapshot siguiente, del calendario o de una corrida adelantada, y el pipeline mensual lo entrena («El pipeline mensual como DAG»).
- Y el modelo nuevo vuelve a subir «Gate de evaluación y registry» y «Rollout seguro».
Para repasar las bases: «Probabilidad para sistemas que fallan» (el presupuesto de error), «Ruido, muestras y pruebas A/B» (el intervalo), «Comparar distribuciones: cómo se mide el drift» (el PSI y la trampa del n enorme), «Promedios, medianas y percentiles» (el p99) y «La request en vivo» (las métricas).
Palabras que vas a oír
EsencialWords you will hear
Los conceptos que presentó esta lección, cada uno con su tarjeta:
Falla silenciosasilent failureCuando un modelo empeora sin que nada truene: el servicio sigue contestando 200 OK (el código de «todo bien»), igual de rápido y con la misma seguridad aparente, pero sus respuestas son peores.Más +
Un servidor web roto se nota porque deja de contestar. Un modelo roto sigue contestando. Casi nunca cambió el modelo: cambió el mundo que lo alimenta (las fotos, la gente, lo que se vende), y eso es drift. Por eso no bastan las señales de servicio: hacen falta señales del modelo y del negocio, en las cinco capas del monitoreo.
Analogía. Como un termómetro que se descalibra: sigue marcando un número cada vez que lo miras, solo que ya no es la temperatura. Se rompe en que el termómetro sí cambió; en un modelo, casi siempre cambió lo que mide.
Ejemplo. Una versión nueva de la app manda las fotos más comprimidas. El p99 de un pod del gateway sigue en ≈ 69 ms o menos (el de su pico de diseño) y no hay errores de más; seis días después, la aceptación de source=mobile cae de 70.1 % a 66.2 %.
Las cinco capas del monitoreomonitoring layersInfraestructura, servicio, datos, modelo y negocio: lo que se vigila de un sistema de ML, de la señal más rápida (segundos) a la más lenta y más cercana a lo que importa (semanas).Más +
Las dos primeras capas existen en cualquier servicio (nodos, pods, latencia, errores). Las tres siguientes son propias de ML: los datos que entran (tamaño, formatos), lo que contesta el modelo (score, baja confianza, PSI) y lo que pasa después (aceptación, correcciones, labels: las respuestas correctas). La regla incómoda: cuanto más abajo, más lenta la señal, porque el label que dice si se acertó llega tarde.
Ejemplo. En Alba: infraestructura (pods listos, segundos) · servicio (p99, 5xx, fila de Triton) · datos (bytes por source, minutos) · modelo (baja confianza, PSI, hasta 1 día) · negocio (aceptación, holdout, horas a semanas).
Señales doradasgolden signalsCuatro preguntas para vigilar cualquier servicio: cuánto tarda (latencia), cuánto le piden (tráfico), cuánto falla (errores) y qué tan lleno está (saturación).Más +
Vienen del libro de SRE (Site Reliability Engineering) de Google. Dos recetas hermanas dicen lo mismo desde otro ángulo: RED (rate, errors, duration: tasa, errores, duración) para cada servicio, y USE (utilization, saturation, errors: utilización, saturación, errores) para cada recurso, como una GPU o un disco. La saturación se mide mejor con la fila (cuánto se espera) que con la utilización: una GPU al 100 % puede no tener a nadie esperando.
Ejemplo. En Alba: latencia = el p99 contra 200 ms; tráfico ≈ 116 requests por segundo en promedio; errores = 5xx ÷ requests sin 4xx; saturación = la espera media en la fila de Triton, con warning arriba de 20 ms durante 10 minutos.
Señal sin labels (proxy de calidad)proxy metricUna señal que se mide sin saber la respuesta correcta y avisa «algo cambió» en minutos: la mezcla de categorías predichas, el score top-1 (la probabilidad de la primera opción del modelo), la tasa de baja confianza o el tamaño de las fotos.Más +
Los labels llegan tarde, así que mientras tanto se vigila lo que sí se sabe en el momento: qué contestó el modelo y cómo venía la entrada. Ningún proxy prueba que el modelo empeoró: un cambio en la mezcla puede ser la temporada. Sirven para sospechar, abrir un ticket, mirar muestras y mandar a etiquetar; los labels demorados confirman.
Ejemplo. La tasa de baja confianza de Alba sube de 4 % a 5.5 % el día que sale una versión nueva de la app: no prueba nada, pero apunta a dónde mirar.
Tasa de baja confianzalow-confidence rateLa fracción de las predicciones cuya probabilidad más alta (el score top-1) queda debajo de un umbral. En Alba, la de las fotos con top-1 menor que 0.3: ≈ 4 % en un día normal.Más +
Se calcula con dos contadores del histograma del score: el bucket del umbral entre el total, en una ventana de 30 minutos, con una regla de grabación. Se compara contra su propio promedio de 7 días, porque la tasa normal se mueve con las temporadas. Ve las dudas del modelo, no sus errores seguros: un modelo mal calibrado puede equivocarse con 0.9.
Ejemplo. En media hora de tráfico promedio de Alba hay 208,800 requests y ≈ 8,352 fotos dudosas (4 %). El ticket ClassifierLowConfidenceSpike pide más del doble de su promedio de 7 días (≈ 8 %) durante 30 minutos, con más de 1 request por segundo.
Tasa de aceptaciónacceptance rateDe las publicaciones donde la pantalla mostró las sugerencias, la fracción cuya categoría se eligió entre ellas. En Alba, ≈ 70 %.Más +
Es la señal de negocio más rápida: llega en minutos u horas. Se mide con los eventos de quien llama (en Alba, suggestion_shown y category_selected del backend), no con el log del servidor, que no sabe si la sugerencia se llegó a pintar. Está sesgada: la gente tiende a aceptar lo que le mostraron (bucle de retroalimentación), así que no sirve para medir la exactitud real; para eso está el holdout.
Ejemplo. Con ≈ 17.3 M publicaciones a la semana, el azar mueve la aceptación de Alba ± 0.02 puntos; el disparador pide una caída de más de 3 puntos semana contra semana.
Referencia y ventana del driftreference windowContra qué se compara la distribución de hoy para decir si hubo drift, y sobre cuánto tiempo. Cada referencia ve una cosa y se pierde otra.Más +
Contra los datos de entrenamiento, la pregunta es «¿ve algo que no aprendió?», pero si el mundo se movió para siempre, la alerta suena sin parar. Contra una ventana reciente, la pregunta es «¿cambió de golpe?», pero un cambio lento nunca se ve, porque cada semana se parece a la anterior. Por eso se usan dos. Además se pide que el cambio se sostenga, para que un día raro no dispare nada.
Ejemplo. Alba compara el PSI diario contra las 4 semanas previas (la alerta, si pasa de 0.2 tres días seguidos) y contra el mes del snapshot del champion, ds-2026-09-01 para la release 14 (el reporte mensual).
Regla de alertaalerting ruleUna condición que el sistema de monitoreo evalúa cada cierto tiempo y que, si se cumple el tiempo suficiente, avisa a alguien. Lleva nombre, condición, cuánto tiene que durar (for), severidad, dueño y runbook (la receta de qué hacer).Más +
Se alerta por síntomas (lo que siente el usuario), no por causas. El for pide que la condición dure antes de disparar, para que un pico de un deploy no despierte a nadie. Hay que protegerla del tráfico bajo (un error en 20 requests es 5 %) y de las series ausentes: si el servicio muere, sus métricas desaparecen y la regla no da nada, así que se alerta también con up == 0, absent() o desde quien espera la señal. Si no hay acción posible, no es un page (una alerta que despierta a alguien).
Ejemplo. ClassifierHighP99Latency de Alba: p99 > 200 ms durante 10 minutos, severidad page, para la guardia, con el runbook del p99 enlazado.
Severidad de una alertaalert severityQué tan urgente es una alerta y a quién le llega: page (despierta a la guardia), warning (canal del equipo, en horario) o ticket (trabajo de la semana).Más +
Page solo para lo que afecta a los usuarios ahora y alguien puede arreglar ahora. Warning para una causa que anticipa un page. Ticket para la calidad del modelo y las tendencias, que se entienden mirando datos con calma. Poner todo en page lleva a la fatiga de alertas.
Ejemplo. En Alba, el p99 arriba de 200 ms es page; la fila de Triton arriba de 20 ms, warning; el PSI arriba de 0.2 tres días seguidos, ticket. Nadie se despierta a las 3 de la mañana porque subió el PSI.
AlertmanagerAlertmanagerEl programa que recibe las alertas que dispara Prometheus y decide a quién y cómo avisar: agrupa, deduplica, inhibe y silencia.Más +
Prometheus solo decide que una alerta suena. Alertmanager agrupa las de un mismo incidente en una notificación, deduplica las que llegan repetidas de dos Prometheus iguales, inhibe las que son consecuencia de otra y silencia durante un mantenimiento. También enruta cada severidad a su canal (el teléfono de la guardia, el chat del equipo, la cola de tickets).
Ejemplo. En Alba vive en el namespace monitoring, agrupa por alerta y namespace y calla los warning de la fila de Triton mientras TritonNotReady está sonando.
Regla de grabaciónrecording ruleUna expresión cara que el sistema de métricas calcula cada cierto tiempo y guarda como una serie nueva, para que las alertas y los dashboards la lean ya hecha.Más +
Calcular una tasa de 6 horas o promediar 7 días suma millones de muestras; si cada alerta la recalcula en cada evaluación, el sistema trabaja de más. La regla de grabación la calcula cada cierto tiempo (en Alba, una vez por minuto) y le da un nombre propio, por costumbre de tres partes: nivel, métrica y operación (classifier:error_ratio:rate1h).
Ejemplo. Alba graba la fracción de errores en 5 min, 30 min, 1 h y 6 h para sus alertas de burn rate, y classifier:low_confidence_share:rate30m para comparar la baja confianza contra su promedio de 7 días.
Burn rateburn rateQué tan rápido se gasta el presupuesto de error (lo que el SLO, la meta del servicio, deja fallar), comparado con el ritmo que lo agotaría justo al final de la ventana del SLO. 1× lo gasta exacto en el mes; 14.4×, en 50 horas.Más +
Se calcula como β=
Ejemplo. Con el SLO de 99.9 % de Alba, un 1.44 % de errores es 14.4×: en una hora se van ≈ 6,000 requests, 2 % de las 300,000 del mes. Un deploy malo con 5 % de errores es 50×: el mes duraría 14.4 horas.
Alerta multiventanamultiwindow, multi-burn-rate alertUna alerta de burn rate que mira dos ventanas a la vez, una larga y una corta (1/12 de la larga), y suena solo si las dos pasan el umbral.Más +
La ventana larga confirma que el problema es real: un pico de dos minutos no mueve el promedio de una hora. Pero tiene memoria y seguiría arriba mucho después del arreglo. La corta casi no tiene memoria: cuando el incidente termina, baja en minutos y la alerta se apaga. Se combinan varios niveles (rápido y lento) para cubrir incidentes graves y goteos.
Ejemplo. Alba: page a 14.4× en 1 h y en 5 min; ticket a 6× en 6 h y en 30 min. Un incidente al 3 % durante 40 min, con 0.1 % de fondo (el tope que deja el SLO; supuesto del ejemplo), hace sonar el page del minuto 27 al 42; con la ventana larga sola, sonaría hasta el 72.
DashboarddashboardUna página de gráficas en vivo que muestra las métricas de un sistema. En Alba se arman en Grafana, un programa de gráficas que consulta a Prometheus.Más +
Un dashboard sirve si contesta rápido la pregunta de quien lo mira, así que se hace uno por audiencia: la guardia necesita ver en segundos si el SLO está en peligro; el equipo de ML, cómo se comporta el modelo por versión; producto, el negocio día a día. Uno que sirve a los tres no le sirve a ninguno. Un dashboard no avisa: para eso están las alertas.
Ejemplo. Los cuatro de Alba: servicio (el SLO y el presupuesto arriba, con marcas de deploy), Triton y GPU, modelo (todo por model_version) y negocio (diario).
Guardiaon-callLa persona del equipo que, por turno, recibe las alertas urgentes (los page) y responde a cualquier hora.Más +
La guardia rota entre las personas del equipo para que nadie la cargue siempre. Recibe solo lo que no puede esperar; lo demás llega como warning o ticket en horario. Sigue los runbooks y, si el incidente afectó a los usuarios, al final se escribe un postmortem sin culpables.
Ejemplo. En Alba es una rotación semanal entre las 5 personas del equipo; en los ejemplos, Marta. Reconoce cada page en ≤ 5 minutos.
RunbookrunbookLa receta escrita de qué revisar y qué hacer cuando suena una alerta, enlazada desde la alerta misma. Se escribe en calma para usarse con prisa.Más +
Un buen runbook va en orden de lo más probable y lo más rápido de mitigar, y dice cuándo escalar. La regla de fondo: mitigar primero, entender después. El runbook de rollback es un caso particular.
Ejemplo. El runbook del p99 de Alba: (1) qué tramo subió, (2) ¿hubo deploy? → rollback, (3) ¿KEDA en su tope de 4? → falta GPU, (4) ¿un cliente manda de más? → su cuota, (5) escalar si en 30 minutos no mejora.
Fatiga de alertasalert fatigueCuando suenan tantas alertas que no llevan a nada que la gente deja de hacerles caso, y la que importa también se ignora.Más +
Nace de alertas sin for, sin volumen mínimo, por causas en vez de síntomas, o de pages que deberían ser tickets; y de muchas pruebas a la vez (comparaciones múltiples). Se mide con la fracción de pages que terminaron en una acción, y se cura borrando o bajando de severidad lo que nadie atendió.
Ejemplo. Con números de ejemplo: 12 pages en un mes y solo 9 con acción es 75 %; los otros 3 son candidatos a borrar o a pasar a warning.
Postmortem sin culpablesblameless postmortemEl documento que se escribe después de un incidente: qué pasó, cuánto afectó, cómo se detectó y qué se hará para que no se repita, sin buscar a quién culpar.Más +
Lleva línea de tiempo, impacto, con qué señal se detectó y acciones con dueño y fecha. Es sin culpables porque busca qué dejó pasar el error, no quién lo cometió: así la gente cuenta lo que de verdad pasó. En ML la pregunta clave es qué señal lo habría detectado antes.
Ejemplo. Alba escribe uno después de cada page con impacto en usuarios, en ≤ 5 días hábiles. Si una versión nueva de la app que comprimía más las fotos solo se detectó seis días después, por la caída de la aceptación, una acción puede ser una alerta por bytes de cada source.
Frescura de un job (y Pushgateway)job freshness · PushgatewayCuánto tiempo hace que un job (un programa que corre y termina) publicó su último resultado. Se vigila porque un job muerto deja su último valor publicado y todo parece estable.Más +
Prometheus lee métricas de quien está vivo; un job que corre y termina las empuja al Pushgateway, un programa que se queda prendido y que las guarda hasta que alguien las borre, junto con push_time_seconds, la hora del último envío. Si el job deja de correr, el último valor se queda para siempre. La defensa es una alerta sobre time() - push_time_seconds.
Ejemplo. El job monitoreo-diario de Alba corre a las 01:00 UTC y tarda ≈ 20 minutos; MonitoringJobStale abre un ticket si pasan más de 26 horas sin un envío nuevo.
Disparador de reentrenamientoretraining triggerUna condición que propone reentrenar el modelo antes del calendario. Abre un ticket para que una persona diagnostique y decida; no despliega nada solo.Más +
Antes de adelantar se descarta lo que no es del mundo: un deploy propio, datos rotos de quien llama y el training-serving skew. Solo si cambió el mundo y los labels lo confirman, se adelanta la corrida, con una tanda extra de etiquetado del slice si hace falta, y el modelo nuevo sube los mismos peldaños: gate, shadow (despliegue en sombra) y canary.
Ejemplo. En Alba: el calendario (día 1, 03:00 UTC), el PSI > 0.2 tres días seguidos, la aceptación −3 puntos semana contra semana y una categoría nueva planeada. Una persona lanza argo submit --from cronwf/reentreno-mensual.
Brecha offline–onlineoffline–online gapLa diferencia entre lo bien que le va a un modelo en el examen fijo (offline) y lo bien que le va con el tráfico real (online).Más +
El examen fijo, como un golden set, no cambia; el mundo sí. Si la medida online cae y la offline no, el mundo ya no se parece al examen: hace falta actualizar el examen o reentrenar. La medida online tiene que estar libre del sesgo de la sugerencia, como el holdout.
Ejemplo. En Alba, el golden set da ≈ 85 % de top-1 y el holdout ≈ 85 % ± 0.1 punto: la brecha hoy es casi cero. Si un mes el holdout cae a 82 %, se abre la investigación.
Chequeo
EsencialCheck
Intenta responder en tu cabeza antes de abrir cada respuesta.
1¿Por qué un modelo puede fallar sin que el dashboard del servicio lo note?Ver respuesta
Porque sigue contestando 200 OK con la misma latencia y la misma confianza aparente. Cambió el mundo que lo alimenta, no el servicio.
2¿Qué decide si una alerta es page, warning o ticket?Ver respuesta
Si el usuario está afectado ahora y alguien puede arreglarlo ahora (page), si es una causa que anticipa un page (warning) o si es calidad del modelo y tendencias (ticket).
3¿Qué es un burn rate de 14.4× y por qué Alba lo usa en vez de «más de 1 % de errores»?Ver respuesta
Gastar el presupuesto 14.4 veces más rápido de lo que lo agota en 30 días: 2 % del mes en una hora. Mide el daño contra el presupuesto; un umbral fijo no sabe cuánto daño hace un error.
4¿Para qué sirve la ventana corta de una alerta multiventana?Ver respuesta
Para que la alerta se apague pronto cuando el incidente se arregla. La larga confirma que es real; la corta tiene poca memoria.
5¿Por qué la aceptación no basta para medir la exactitud real?Ver respuesta
Porque quien vende tiende a aceptar lo que le mostraron: está sesgada por el modelo. La medida limpia es el holdout, que no ve sugerencias.
6¿Qué hace en Alba un disparador de reentrenamiento?Ver respuesta
Abre un ticket. Después del diagnóstico, una persona decide si adelanta la corrida; el modelo nuevo sube igual el gate, el shadow y el canary.