13 · Estaciones · OrquestaciónLección 2 de 2
Rollout seguro
Safe rollout
El décimo paso del sistema de Alba de principio a fin: llevar el modelo nuevo de la sombra al 100 % del tráfico por peldaños, con criterios escritos antes, comparando siempre contra el estable y con la versión anterior viva para volver sin levantar nada.
Secciones14
- 01Lo que entra, lo que sale y lo que se decide
- 02Shadow: contestar en la sombra
- 03La release y el canary con Argo Rollouts
- 04Comparar contra el estable, con n mínimo
- 05El PSI del canary y su piso de ruido extra
- 06Promover, el A/B y el bake
- 07Volver: el rollback según la fase y el runbook
- 08Dos versiones vivas a la vez extra
- 09Errores comunes
- 10En la vida real extra
- 11Ejercicios
- 12Lo que sigue
- 13Palabras que vas a oír
- 14Chequeo
El modelo de noviembre ya pasó el gate, la paridad y el pipeline, y su imagen está en el registro. ¿Cómo se pone frente a millones de fotos reales sin que un error llegue a todos, y cómo se decide, sin que nadie lo vigile, si se queda o se va?
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. Con las fotos que piden otros equipos, son ≈ 10 millones de requests (pedidos de un programa a otro) al día, una foto por request: ≈ 116 por segundo en promedio y ≈ 350 en el pico del mediodía. La sugerencia la hace una ResNet-50 (una red neuronal para fotos) convertida en un engine de TensorRT (el modelo compilado para la GPU) y servida por Triton (el programa que carga el modelo y contesta). Corre en GPUs T4 de NVIDIA, cada una en una máquina g4dn.xlarge de AWS (Amazon Web Services, la nube de Amazon) que cuesta US$0.526 por hora. Delante de Triton está el gateway, el programa en Python que recibe la foto, la valida, la prepara y le pide la respuesta a Triton.
Las nueve estaciones anteriores dejaron todo listo. El modelo de noviembre, resnet50-2026-11-01, es la versión 15 del registro de modelos, el catálogo de las versiones entrenadas. Lleva el alias challenger (el candidato) porque pasó dos exámenes: el gate, que lo comparó con el modelo actual en el golden set, un examen fijo de fotos con su categoría correcta; y la paridad del engine, que comprobó que el engine contesta lo mismo que el modelo evaluado. El que atiende hoy, en noviembre de 2026, es la versión 14, resnet50-2026-10-01, con el alias champion, la etiqueta del modelo en producción.
La imagen de Triton de la versión 15 (el paquete con el programa y el modelo, listo para correr) está en el registro de imágenes, nombrada por su digest, su huella única. El pipeline la entregó a Argo CD, el programa que copia al clúster lo que dice un repositorio de Git, cuando una persona aprobó el job produccion, el único paso que espera a un humano («CI/CD y registro de imágenes»). Y «Kubernetes» dejó corriendo los pods, las copias del programa en el clúster (el grupo de máquinas que Kubernetes administra), con sus probes (preguntas periódicas de «¿estás vivo?» y «¿estás listo?»), su autoscaling (más pods cuando sube el tráfico) y su rolling update.
Esta estación convierte un challenger probado en el examen en un champion probado con tráfico real.
Lo que entra, lo que sale y lo que se decide
EsencialIn, out and what gets decided
Lo que entra
- La versión 15,
resnet50-2026-11-01, con aliaschallenger, y su imagenclassifier-triton:resnet50-2026-11-01en ECR (Elastic Container Registry, el registro de imágenes de AWS), por digest. - La versión 14,
resnet50-2026-10-01, con aliaschampion, sirviendo el 100 % del tráfico con sus dos pods de Triton, uno por zona (un centro de datos aparte, con su propia luz y su propia red). - El repositorio de despliegue
alba/despliegue, que Argo CD aplica al clúster: ahí vive cada manifiesto (el archivo que describe qué debe correr) y cada cambio es un commit.
Lo que sale
- La versión 15 al 100 % del tráfico, con el alias
championmovido a ella en el registro. - La versión 14 todavía viva 24 a 48 horas más, lista para volver en minutos sin levantar nada; después, un PR (pull request, una propuesta de cambio que otra persona revisa y aprueba) la quita.
- El registro de lo que pasó: el reporte del shadow, cada medición del canary y quién aprobó qué.
Lo que se decide
El gate de la estación 4 respondió una pregunta: ¿el modelo nuevo es al menos igual de bueno en un examen fijo? Eso no basta, porque el examen no es el mundo. Faltan cuatro preguntas, y cada una tiene su peldaño:
- 1
¿Funciona con tráfico real?
Que no truene, que no tarde de más y que conteste parecido al actual con fotos de verdad. Lo responde el shadow: el modelo nuevo recibe copias y nadie ve lo que contesta.
- 2
¿Es seguro con usuarios reales?
Que sus errores y su latencia (cuánto tarda en contestar) no empeoren cuando de verdad contesta. Lo responde el canary: una parte chica del tráfico, comparada con la versión estable, la que ya atiende.
- 3
¿Mejora el producto?
Que la gente acepte más sugerencias. Lo responde una prueba A/B por vendedor: dos grupos al azar, cada uno con una versión, y se mide cuál acepta más. Alba solo la corre para cambios grandes.
- 4
¿Podemos volver?
Que la versión anterior siga lista mientras se confirma. Lo da el bake: la anterior viva 24 a 48 h.
Juntos forman un despliegue progresivo (progressive delivery): la versión nueva gana tráfico en peldaños, y en cada uno se mide algo distinto antes de subir al siguiente.
Por qué no basta un rolling update
«Kubernetes» presentó el rolling update: el Deployment (el objeto que mantiene corriendo N copias iguales de un pod) reemplaza los pods viejos por nuevos de a poco, y solo sigue si cada pod nuevo pasa su probe de probe de readiness, la pregunta periódica «¿ya puedes recibir tráfico?». Suena a despliegue seguro. Para un modelo no lo es, por tres razones.
La primera: la readiness mide salud, no calidad. Pregunta «¿el proceso contesta?», y un modelo que confunde tenis con botas contesta perfecto, en 30 ms, con 94 % de confianza. El rolling update lo daría por bueno y seguiría.
La segunda: no controla el porcentaje. Con 2 pods de Triton y maxSurge: 1 (Kubernetes puede prender 1 pod de más mientras dura el cambio), hay 3 pods y el primero nuevo ya recibe un tercio del tráfico; en cuanto sale uno viejo, la mitad.
La tercera: no compara nada. No sabe cómo le iba a la versión anterior, así que no puede notar que la nueva va peor.
Por eso el rolling update se queda para cambios que no tocan lo que contesta el modelo, como la memoria de un pod o los plazos de una probe.
Qué cambio sube qué peldaños
No todo cambio sube todos los peldaños. En Alba:
| Cambio | Peldaños | Cada cuánto |
|---|---|---|
| Reentrenamiento mensual (la versión 15) | gate → shadow 1–2 días → canary 5 % → 25 % → 100 % → bake | 1 al mes |
| Código del gateway (sin cambiar el modelo) | CI (las pruebas automáticas) → canary 5 % por 1 h → 25 % por 1 h → 100 %, sin shadow | varias veces por semana |
| Arquitectura nueva o categorías nuevas | gate → shadow → canary → A/B de 1–2 semanas → 100 % | pocas veces al año |
La regla de fondo: cada peldaño cuesta tiempo, y se paga solo donde el riesgo lo pide. Un cambio de código del gateway no cambia lo que contesta el modelo, así que no necesita sombra. Un modelo con otra arquitectura puede cambiar de formas que solo mide la gente: necesita el A/B.
Shadow: contestar en la sombra
EsencialShadow: answering in the dark
Qué es
Un shadow (despliegue en sombra) (despliegue en sombra; también dark launch) es correr la versión nueva con copias de requests reales, guardar lo que contesta y tirarlo: el usuario solo ve la respuesta de la versión actual. El mecanismo que hace las copias es la copia de tráfico (traffic mirroring).
Mide al modelo nuevo con las fotos de hoy, con su mezcla real de celulares, luz y categorías, sin arriesgar a nadie. Lo que no mide es a la gente: nadie vio esas sugerencias, así que nadie las aceptó ni las rechazó. El shadow responde «¿funciona?», nunca «¿ayuda?».
Quién copia y adónde va la copia
En Alba copia el gateway de la versión vigente, la 14. Por cada request decide si es de la muestra, contesta como siempre con su Triton y, aparte, manda la misma foto ya preparada (convertida en el tensor que espera el modelo) al Triton de la versión 15, que corre en su propia T4. Tres reglas cuidan que la copia nunca afecte al usuario:
- Va en una tarea aparte, con su propio plazo (el tiempo máximo que se le espera). La respuesta al usuario no espera a la copia.
- La cola de copias es acotada: una fila de espera con lugares fijos: si se llena, la copia se tira. Una sombra lenta nunca frena al camino de verdad.
- La respuesta del challenger solo va al log, el archivo donde el gateway anota cada request: una línea con el mismo
request_id(el identificador único de la request),model_version: resnet50-2026-11-01yshadow=true. Nunca al usuario, nunca a la base de datos.
Qué requests se copian lo decide el hash del request_id: una cuenta que convierte el texto del id en un número que parece al azar, pero que sale siempre igual para el mismo id. El gateway copia si ese número cae en el 10 % de los valores posibles. Es la asignación por hash de «Tiempo, hashes e identificadores»: la misma request siempre cae del mismo lado, y cualquiera puede repetir la decisión después.
- Ana · sube unos tenis
La vendedora de ejemplo. Su foto entra como una request más, con su request_id; ella nunca sabe que hubo una copia. - ALB · 100 % a la 14
El balanceador de Alba. Durante el shadow manda todo al gateway de la release 14: la copia no la hace él, la hace el gateway. - gateway v14 · release vigente
Contesta como siempre y, aparte, decide por el hash delrequest_idsi la request es del 10 % que se copia. La copia corre en una tarea aparte, con su propio plazo. - triton-v14 · contesta
El champion,resnet50-2026-10-01. Su respuesta es la que ve Ana: «Calzado › Tenis», 94 %. - cola de copias · acotada
Si se llena, la copia se tira. Así, una sombra lenta nunca frena la respuesta de verdad. - triton-v15 · su propia T4
El challenger,resnet50-2026-11-01, en su propia T4 (US$0.526/h). Calcula y devuelve números: no escribe en ningún lado. - revisión · 300–500 a mano
Una muestra al azar de los desacuerdos va a una persona, que dice cuál de los dos acertó. Es lo que dice en qué cambió el modelo. - job diario · une por request_id
Une las dos líneas de cadarequest_idy mide acuerdo top-1 (≥ 90 %), p99 (≤ 1.1 × el del champion), crashes (cero) y las 20 categorías más grandes (ninguna < 85 %). - log · shadow=true
Una línea por respuesta del challenger, con el mismorequest_id,model_version: resnet50-2026-11-01yshadow=true. La del champion ya estaba ahí, como siempre.
Cuánto junta
- donde
- Rd
- las requests de un día, en requests
- m
- la fracción que se copia, sin unidad (0.10 = 10 %)
- Np
- los pares de un día, en pares; un par es una respuesta del champion y una del challenger para la misma foto
- a
- el acuerdo top-1, la fracción de pares en que los dos modelos ponen la misma categoría en primer lugar, sin unidad
- Nd
- los desacuerdos de un día, en pares
Un millón de pares sobra para medir el acuerdo. Su error estándar (cuánto se movería si repitieras la medición con otra muestra) es √a×
Qué se compara, con umbrales escritos antes
El job diario (un programa que corre una vez al día y termina) une las dos líneas de cada request_id y mide cuatro cosas. Los umbrales viven en el repositorio desde antes de mirar, igual que los del gate, para que nadie los acomode después de ver los números:
| Medida | Umbral de Alba |
|---|---|
| Acuerdo top-1 con el champion | ≥ 90 % |
| p99 del challenger (la latencia que solo el 1 % de las requests supera) | ≤ 1.1 × el del champion |
| Caídas (crashes) del Triton nuevo: veces que el proceso se muere | cero |
| Acuerdo en las 20 categorías más grandes | ninguna < 85 % |
El acuerdo no es exactitud (la fracción de aciertos): dos modelos pueden coincidir en lo mismo y los dos estar mal. Mide cuánto cambió el comportamiento. Un acuerdo de 99.9 % en un reentrenamiento diría que el modelo nuevo casi no aprendió nada; uno de 70 % diría que algo se rompió (unas categorías desordenadas, un preproceso distinto). Los 300 a 500 desacuerdos revisados dicen en qué cambió: si el nuevo acierta donde el viejo fallaba, el cambio es bueno.
Para ir más hondoEl código: la muestra por hash y los pares+
Decide la muestra por hash y une los pares, en chico.
import hashlib
def a_la_sombra(request_id, m=0.10): # m: la fracción que se copia
h = int(hashlib.sha256(request_id.encode()).hexdigest()[:8], 16) # la huella, como número
return h % 10_000 < m * 10_000 # el mismo id, siempre la misma decisión
ids = [f"r-{i:06d}" for i in range(100_000)]
print("copiadas:", sum(a_la_sombra(r) for r in ids), "de", len(ids))
print("r-000042:", a_la_sombra("r-000042"), "· otra vez:", a_la_sombra("r-000042"))
# El job diario une las dos líneas que comparten request_id
champion = {"r-001": "Calzado › Tenis", "r-004": "Deportes › Bicis",
"r-005": "Hogar › Lámparas", "r-006": "Hogar › Lámparas"}
challenger = {"r-001": "Calzado › Tenis", "r-004": "Deportes › Bicis",
"r-005": "Hogar › Iluminación", "r-006": "Hogar › Lámparas"}
pares = [(champion[r], challenger[r]) for r in champion if r in challenger]
acuerdo = sum(a == b for a, b in pares) / len(pares)
print(f"pares: {len(pares)} · acuerdo top-1: {acuerdo:.0%}")
print("a revisión:", [r for r in champion if champion[r] != challenger.get(r)])copiadas: 9955 de 100000
r-000042: False · otra vez: False
pares: 4 · acuerdo top-1: 75%
a revisión: ['r-005']De 100,000 ids se copian 9,955, casi exactamente el 10 %, y la misma request da la misma respuesta las dos veces. La foto de la lámpara de Caro, otra vendedora (r-005), es el único desacuerdo: el champion dice «Lámparas» y el challenger «Iluminación». Es el tipo de caso que revisa una persona: las dos podrían estar bien.
Lo que el shadow no debe hacer
El peligro del shadow son los efectos secundarios: lo que la copia hace en el mundo además de contestar. Si el challenger guardara su respuesta en la base de datos de publicaciones, la sugerencia de Ana cambiaría sin que nadie lo decidiera. Si mandara un correo, Ana recibiría dos. Si gastara una cuota de un proveedor externo, la pagaría el doble. En Alba es fácil cumplirlo, porque Triton solo calcula: recibe un tensor y devuelve números. Pero la regla vale para cualquier sistema: la copia lee y calcula; nunca escribe fuera de su log.
Cuesta poco: una T4 más mientras dura, a US$0.526 por hora, ≈ US$13 por día. Lo que de verdad cuesta es el tiempo: 1 o 2 días antes de que la versión 15 atienda a nadie.
La release y el canary con Argo Rollouts
EsencialThe release and the canary with Argo Rollouts
Una release es un par
Antes de repartir tráfico hay que saber qué se reparte. Una release es una versión publicada del sistema. En Alba, una release es un par: el gateway de esa versión más el Triton de esa versión. Cada versión del modelo corre en su propio Deployment, triton-v15, con su propio Service triton-v15: un nombre fijo dentro del clúster que reparte las requests entre los pods de ese Deployment. El gateway de la release 15 trae tres cosas que apuntan a su modelo y solo a él:
TRITON_URL=triton-v15.classifier.svc.cluster.local:8000: el nombre de su Triton dentro del clúster, en una variable de entorno (un valor que el programa lee al arrancar).MODEL_VERSION=resnet50-2026-11-01, otra variable de entorno.- Su
labels.json: las 500 categorías en el orden de las salidas del modelo. Viene de un ConfigMap (un archivo de configuración guardado en el clúster) por versión,classifier-labels-15, y su huella SHA-256 va en otra variable de entorno. El gateway la verifica al arrancar: si la huella no coincide o no hay 500 nombres, el proceso termina y el pod nunca llega a estar listo.
¿Por qué tanto cuidado? Porque nunca debe haber dos modelos detrás del mismo nombre. Si los pods del gateway de la 15 pudieran caer en el Triton de la 14, la sugerencia de una foto dependería de a qué pod le tocó, y ninguna métrica sabría a qué versión culpar. Con el par, cada request tiene una sola versión, y esa versión va escrita en su log y en sus métricas.
Quién reparte el tráfico
El gateway de Alba no es un Deployment: es un Rollout de Argo Rollouts. Un Rollout es un objeto que trae el mismo template de pod que un Deployment (la plantilla que dice cómo es cada pod: su imagen, sus variables, sus recursos), más una lista de pasos del canary. Su controlador, un programa que corre dentro del clúster en el namespace argo (un apartado del clúster con nombre propio), ejecuta esos pasos. Argo CD lo aplica como cualquier otro manifiesto: lo que cambia en Git es el template del gateway (su TRITON_URL, su MODEL_VERSION, su ConfigMap de labels), y ese cambio dispara el canary.
Un canary es mandar una parte chica del tráfico real a la versión nueva, por etapas, y avanzar solo si en cada etapa se ve tan bien como la estable. El nombre viene de los canarios que los mineros bajaban a la mina: si el aire se envenenaba, el canario lo notaba primero.
El porcentaje lo pone el ALB (Application Load Balancer), el balanceador de AWS que recibe el tráfico de Alba: el programa que reparte las requests entre varios destinos. Reparte con pesos, como cuenta «Balanceadores, proxies y gateways»: sus dos destinos son los Services gateway-stable y gateway-canary, y con pesos 95 y 5, 1 de cada 20 requests va al canary.
¿Quién mueve esos pesos? Argo Rollouts los escribe, cada uno de 0 a 999, en una anotación (una nota de configuración pegada al objeto) del Ingress gateway, la regla que dice cómo entra el tráfico de afuera al clúster. El AWS Load Balancer Controller, el programa que traduce el Ingress a la configuración del ALB, los aplica. Al 5 % en el pico el canary recibe 350 × 5 ÷ 100 = 17.5 requests por segundo.
El Triton de la 15 se despliega antes, sin tráfico: es un Deployment nuevo, con un solo pod (la T4 de más), y solo lo llaman los pods canary del gateway. Es el mismo pod que sirvió al shadow, así que el canary no espera los ≈ 5–13 minutos que tarda un pod nuevo de Triton. Un pod basta: al 25 % en el pico recibe 350 × 25 ÷ 100 = 87.5 fotos por segundo, y una T4 contesta ≈ 1,200 por segundo.
Los pasos
Así se ve la parte del canary en el Rollout del gateway. Es una ilustración, recortada: las reglas del análisis se cuentan en la sección siguiente. Cada línea que empieza con - en steps es un paso: setWeight pone el peso del canary en % y pause espera ese tiempo antes del paso siguiente.
apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata: {name: gateway, namespace: classifier}
spec:
rollbackWindow: {revisions: 3} # volver a una de las 2 anteriores se salta los pasos
strategy:
canary:
stableService: gateway-stable # Service que ve solo los pods estables
canaryService: gateway-canary # Service que ve solo los pods nuevos
scaleDownDelaySeconds: 172800 # el gateway anterior sigue prendido 48 h (el bake)
trafficRouting:
alb: {ingress: gateway, servicePort: 8080} # los pesos los aplica el ALB
analysis: # corre de fondo durante todo el canary
templates: [{templateName: canary-vs-estable}]
steps:
- setWeight: 5
- pause: {duration: 4h} # cubre el pico del mediodía
- setWeight: 25
- pause: {duration: 4h}
- setWeight: 100Las dos líneas de arriba, rollbackWindow y scaleDownDelaySeconds, son las del bake, el tiempo en que la versión anterior sigue prendida al final: las explica «Promover, el A/B y el bake». Tres decisiones están en los pasos.
Por qué 5 %. Es el tamaño de la apuesta: si la versión 15 está mal, afecta a 1 de cada 20 requests mientras la detectan, no a todas. Y es suficiente para juntar evidencia: 17.5 requests por segundo en el pico.
Por qué horas, no minutos. En 10 minutos de pico ya se juntan ≈ 10,500 requests, que bastan para ver un salto de errores. Pero el tráfico cambia con la hora: las fotos de la mañana no son las de la noche, y el pico estresa la latencia como no la estresa la madrugada. Cada paso de 4 horas incluye el pico del mediodía. Un cambio solo de código del gateway usa pasos de 1 hora, porque no cambia lo que contesta el modelo.
Por qué sin pausa manual. Los dos pause tienen duración: nadie aprieta un botón para pasar de 5 a 25 ni de 25 a 100. La única aprobación humana fue la del job produccion, antes de que Argo CD aplicara el cambio. Después, lo automático decide: si el análisis falla, revierte; si no, avanza cuando se cumple el tiempo.
Para ir más hondoCuando sí espera a una persona+
Si una medición sale inconclusa (no cumple ni la condición de verde ni la de falla), Argo Rollouts pausa el Rollout hasta que alguien lo reanude o lo aborte.
Cuánto tarda en juntar la evidencia
Cada decisión del criterio de errores 5xx necesita un mínimo de requests para que su medición diga algo: en Alba, 10,000 requests del canary (el PSI pide 5,000 predicciones). La sección siguiente explica por qué hace falta. Lo que importa aquí es cuánto se tarda en juntarlas, que depende del tráfico de esa hora.
- donde
- nmin
- las requests del canary que pide el criterio antes de decidir, en requests
- Q
- el tráfico total en ese momento, en requests por segundo
- w
- el peso del canary, en % (por eso se divide entre 100)
- tn
- el tiempo que tarda en juntar nmin, en minutos (el × 60 pasa de requests por segundo a requests por minuto)
- alba/despliegue · template v15
El repositorio de despliegue. El cambio del template del gateway (TRITON_URL=triton-v15…,MODEL_VERSION, los labels 15) llegó en un PR que juntó la GitHub App tras la aprobación del jobproduccion. - Argo CD · aplica
Argo CD aplica el Rollout como cualquier manifiesto. No sabe de canarios: solo hace que el clúster se parezca a Git. - Argo Rollouts · 5 → 25 → 100
El controlador de Argo Rollouts ve un template nuevo y ejecuta los pasos: 5 % por 4 h, 25 % por 4 h, 100 %. Sin pausa manual. - job promover · mueve champion
Del pipeline. Espera a que el Rollout esté al 100 % y sano, y entonces mueve el alias. - ALB · pesos 95 / 5
Dos destinos, uno por Service, con pesos de 0 a 999. Argo Rollouts los escribe en una anotación del Ingress, y el AWS Load Balancer Controller los aplica. Cada request cae en uno al azar, en proporción: ruteo por peso. - gateway-stable · release 14
Los pods del gateway de la 14. Hablan solo contriton-v14y traen los labels de su modelo. - gateway-canary · release 15
Los pods del gateway de la 15. Hablan solo contriton-v15: nunca dos modelos detrás del mismo nombre. - triton-v14 · 2 pods, 2 zonas
El champion, con sus dos T4, una por zona, durante todo el canary. Al llegar al 100 %, un PR lo baja a un solo pod para el bake. - triton-v15 · 1 pod, desde el shadow
Se desplegó antes, sin tráfico, con un solo pod (la T4 de más): el mismo que sirvió al shadow. El canary no espera los ≈ 5–13 min de un pod nuevo de Triton, y al 25 % en el pico ese pod recibe 87.5 fotos por segundo, lejos de las ≈ 1,200 de una T4. - Prometheus · por model_version
El sistema que junta y guarda, cada pocos segundos, las métricas de los dos gateways (la flecha dibuja solo la del canary). Cada una llevamodel_versioncomo etiqueta: así se separa canary de estable en la misma consulta. - Análisis · canary vs estable
El análisis consulta Prometheus: 5xx, p99, baja confianza y PSI contra el estable, en la misma ventana y con su n mínimo (el PSI lo publica cada hora un job que lee el log). Una medición mala basta para abortar. - registro · champion → 15
El registro de modelos. El aliaschampionpasa a la versión 15 solo al final.
Comparar contra el estable, con n mínimo
EsencialCompare against the stable version, with a minimum n
Los criterios
Un criterio de promoción es la regla, escrita antes de empezar, que dice qué tiene que cumplir el canary para subir al siguiente peldaño. Su espejo es el rollback automático: la regla que, si se rompe, regresa el tráfico al estable sin esperar a nadie.
Alba tiene dos clases de reglas. Las primeras son topes absolutos, los mismos de su promesa de servicio: si el canary pasa de 0.5 % de errores 5xx o su p99 pasa de 200 ms, se revierte. Un error 5xx es una respuesta con código de estado del 500 al 599: el servidor falló. Las segundas reglas comparan contra el estable, y cada una tiene su ventana, el pedazo de tiempo en que se mide:
| Señal | Revierte si | Ventana |
|---|---|---|
| Errores 5xx | ≥ 2 × el estable, con ≥ 10,000 requests del canary | 10 min, o hasta juntar el n mínimo |
| Latencia p99 | > 1.2 × el estable | 10 min |
| Baja confianza (top-1 < 0.3) | > 1.5 × el estable | 30 min |
| PSI de las categorías que predice | > 0.1, con ≥ 5,000 predicciones, sobre ≈ 30 categorías padre | 1 h |
La baja confianza es la parte de fotos en que el modelo duda: la probabilidad de su primera categoría es menor que 0.3. El PSI (population stability index, de «Comparar distribuciones: cómo se mide el drift») es un número que mide cuánto cambió una mezcla: aquí, qué fracción de las fotos cae en cada categoría. Vale 0 si las dos mezclas son iguales y crece mientras más se separan. Las categorías padre son los ≈ 30 grupos que juntan a las 500, como «Calzado», que junta «Tenis» y «Botas».
Estas dos son las únicas señales que miran qué contesta el modelo, no solo si contesta, y ningún probe las ve. El PSI, además, atrapa al modelo que se equivoca con confianza, que la baja confianza no nota.
Para ir más hondoDe dónde salen los números+
El análisis los lee de Prometheus, el sistema que junta y guarda cada pocos segundos las métricas de todos los programas. La baja confianza sale del histograma de la confianza top-1 que el gateway ya publica (cuántas fotos cayeron en cada rango de confianza), separado por model_version. El PSI lo calcula cada hora un job que lee el log de cada versión y publica el resultado como métrica.
Por qué contra el estable, en la misma ventana
El análisis del canary compara al canary contra el estable en la misma ventana de tiempo, no contra un número fijo ni contra ayer. La razón es el ruido del día.
Imagina que a las 13:00 una campaña llena el marketplace de fotos de bicis. La baja confianza sube en las dos versiones, porque las bicis con accesorios son difíciles. Un umbral fijo («baja confianza > 8 %») dispararía por la campaña, no por el modelo. Comparar contra ayer, igual. Comparar canary contra estable, en los mismos 30 minutos, cancela la campaña: las dos versiones ven la misma mezcla de fotos, porque los pesos reparten al azar por request. Si la razón entre las dos se mueve, es el modelo.
Los topes absolutos se quedan como red: si todo el sistema está mal (las dos versiones con 1 % de errores), la comparación diría «iguales» y el tope frena igual.
El ruido de una regla sin n mínimo
Una regla relativa con pocas requests es peligrosa al revés: revierte versiones buenas. El n mínimo de un criterio es cuántas requests (o predicciones) tiene que juntar el canary antes de que esa regla pueda decidir. Para ver por qué hace falta, cuenta cuántos errores 5xx ve un canary idéntico al estable.
Supón que el estable falla en el 0.1 % de las requests. No es su tasa normal: es el peor caso que permite la promesa de Alba (99.9 % de requests buenas, así que hasta 0.1 % malas), y con ese supuesto diseña Alba su regla. Si la tasa real es menor, se esperan menos errores y el azar pesa más: lo ves en la calculadora de abajo.
Los errores que caen en n requests del canary siguen, aproximadamente, una distribución de Poisson, como las llegadas de «Probabilidad». Es la que describe cuántas veces pasa algo raro cuando hay muchas oportunidades: la probabilidad de que caigan exactamente i errores cuando se esperan λ es λi×
- donde
- v
- la ventana de una decisión, en minutos
- n
- las requests del canary en esa ventana, en requests (Q en requests por segundo y w en %, como en los minutos del n mínimo; el × 60 pasa de segundos a minutos)
- p0
- la tasa de 5xx del estable, como fracción (0.001 = 0.1 %)
- λ
- los errores que se esperan en el canary si es igual al estable, en errores
- k
- los errores que hacen disparar la regla «≥ 2 × el estable», en errores; ⌈ ⌉ redondea hacia arriba
- X
- los errores que de verdad caen en la ventana, un número al azar
- i
- un número de errores posible (0, 1, 2…), el que recorre la suma; i! = 1 × 2 × … × i, y 0! = 1
- f
- la probabilidad de una falsa alarma en una decisión, sin unidad
- tp
- la duración del paso del canary, en horas (el × 60 la pasa a minutos)
- J
- las decisiones que se toman en un paso del canary, sin unidad
- F
- la probabilidad de al menos un rollback falso en todo el paso, sin unidad
Para ir más hondoEl código de las tres cuentas+
Las tres cuentas a la vez: de madrugada en un paso de 1 hora (como el de un cambio del gateway), en promedio y con el n mínimo.
import math
def p_al_menos(k, lam): # P(X ≥ k) si X sigue una Poisson(λ)
return 1 - sum(math.exp(-lam) * lam**i / math.factorial(i) for i in range(k))
p0 = 0.001 # 5xx del estable: 0.1 % (supuesto)
for caso, n, J in [("madrugada, 10 min", 600, 6),
("promedio, 10 min", 3_480, 24),
("con n mínimo", 10_000, 8)]:
lam = n * p0 # errores esperados si el canary es igual
k = math.ceil(2 * lam) # la regla: canary ≥ 2 × el estable
f = p_al_menos(k, lam) # falsa alarma en una decisión
F = 1 - (1 - f) ** J # al menos una en J decisiones
print(f"{caso:17} n={n:>6} λ={lam:5.2f} k={k:>2} f={f:6.2%} F={F:5.1%}")madrugada, 10 min n= 600 λ= 0.60 k= 2 f=12.19% F=54.2%
promedio, 10 min n= 3480 λ= 3.48 k= 7 f= 6.38% F=79.4%
con n mínimo n= 10000 λ=10.00 k=20 f= 0.35% F= 2.7%De madrugada (Q ≈ 20), una ventana de 10 minutos junta solo n = 600 requests: λ = 0.6, y bastan k = 2 errores para disparar. En un paso de 1 hora, con 6 decisiones, la versión buena se revierte más de la mitad de las veces (F ≈ 54 %). Por eso la ventana de Alba no es «10 minutos» a secas: es «10 minutos, o lo que tarde en juntar 10,000». De madrugada, una decisión tarda horas; en el pico, menos de 10 minutos.
Una versión idéntica al estable, juzgada con la regla «5xx del canary ≥ 2 × el estable». La calculadora aplica n=
Con n = 10,000 exactos y p0 = 0.1 %, λ = 10 y f baja a ≈ 0.35 %; con una ventana entera de 29 min, n = 10,092, k salta a 21 y f queda en ≈ 0.18 %: el redondeo hacia arriba de k también cuenta. Las colas de la Poisson se calculan con la aproximación de Stirling para i!: el error es de milésimas.
Arranca con el paso de 4 horas al 5 % en tráfico promedio, sin n mínimo: F ≈ 79 %. Sube la ventana v a 29 min, la primera en que n pasa de 10,000 (da 10,092): f cae a ≈ 0.18 % y F a ≈ 1.4 %, con solo 8 decisiones J. Luego baja p0 a 0.05 %. Con menos errores de base, la misma ventana de 29 min vuelve a dar falsas alarmas (f ≈ 1.5 % y F ≈ 11 %): hace falta todavía más n.
Para ir más hondoDe dónde sale el 10,000+
Con el estable 19 veces más grande que el canary, la cuenta de «Diseñar el A/B» en «Ruido, muestras y pruebas A/B» se adapta a dos grupos de distinto tamaño. Dos palabras de esa lección: la significancia α es la probabilidad que aceptas de ver un salto que no existe, y la potencia 1−
- donde
- p0,p1
- la tasa del estable y la del canary que se quiere detectar, como fracciones (aquí p0 es la del estable, no la tasa combinada que esa lección llama así)
- r
- cuántas veces más tráfico tiene el estable (19 al 5 %)
- pcomb
- la tasa combinada de los dos grupos, (p1+
r× p0)/(1+ r) - zα
- 1.96, para una significancia de 0.05 en dos colas
- zβ
- 0.84, para una potencia de 0.8
- gα,gβ
- las dos partes del numerador, sin unidad
- nmin
- las requests del canary que hacen falta para ver el salto, en requests
Con p0 = 0.1 %: para ver un salto a 0.5 %, el tope absoluto, bastan nmin ≈ 1,040, un minuto de pico al 5 % (17.5 × 60 = 1,050). Para ver que se duplica, a 0.2 %, hacen falta nmin ≈ 10,650: de ahí el n mínimo de 10,000. Y si el estable anda en 0.05 %, duplicarse a 0.1 % pide nmin ≈ 21,300: el n mínimo de un criterio se diseña con la tasa real, y se revisa cuando esa tasa cambia.
El PSI del canary y su piso de ruido
ExtraThe canary's PSI and its noise floor
Una señal que mira las respuestas
El PSI del canary compara la mezcla de categorías que predice el canary contra la del estable, en la misma hora. Si la versión 15 empieza a mandar a «Calzado» fotos que la 14 mandaba a «Deportes», la mezcla cambia y el PSI sube. Es la señal que atrapa un labels.json desordenado: las respuestas siguen saliendo con buena confianza, pero en las categorías equivocadas.
El problema es que el PSI nunca vale 0 con muestras finitas, aunque las dos versiones sean idénticas. Cada categoría tiene su ruido, y el PSI suma lo que aporta cada una. Con muchas categorías y pocas predicciones, la suma del puro ruido pasa el umbral.
- donde
- K
- el número de categorías del PSI (sus bins), sin unidad; es una K mayúscula, distinta de la k de los errores
- n
- las predicciones del canary en la ventana, en predicciones (una por request: es la misma n de la falsa alarma, ahora en una ventana de 1 h)
- ne
- las predicciones del estable en la misma ventana, en predicciones
- ψ0
- el PSI que se espera por puro azar entre dos versiones idénticas, sin unidad
La fórmula sale de que cada categoría aporta, en promedio, su varianza de muestreo (cuánto se mueve su proporción por puro azar), y las K categorías suman K−
Con las 500 categorías y una hora de madrugada al 5 % (Q ≈ 20, así que n = 20 × 5 ÷ 100 × 3,600 s = 3,600 y ne = 19 × 3,600 = 68,400): ψ0 ≈ 499 × (1/3,600 + 1/68,400) ≈ 0.146. Más que el umbral de 0.1: el canary se revertiría de noche, por azar. Por eso Alba agrupa las 500 en ≈ 30 categorías padre (K = 30) y exige ≥ 5,000 predicciones del canary (ne = 19 × 5,000 = 95,000): ψ0 ≈ 29 × (1/5,000 + 1/95,000) ≈ 0.006, dieciséis veces abajo del umbral.
El código lo comprueba con 20 horas simuladas de un canary y un estable idénticos, sacados de la misma mezcla.
import math, random
from collections import Counter
def psi(a, e, K, na, ne): # PSI entre dos conteos, con medio conteo de colchón
s = 0.0
for i in range(K):
pa, pe = (a[i] + 0.5) / (na + 0.5 * K), (e[i] + 0.5) / (ne + 0.5 * K)
s += (pa - pe) * math.log(pa / pe)
return s
random.seed(7)
for K in (500, 30): # 500 categorías o ≈ 30 padres
pesos = [1 / (i + 1) for i in range(K)] # unas pocas grandes y una cola larga
n, ne = 3_600, 19 * 3_600 # 1 h de canary de madrugada y su estable
vals = [psi(Counter(random.choices(range(K), pesos, k=n)),
Counter(random.choices(range(K), pesos, k=ne)), K, n, ne)
for _ in range(20)]
piso = (K - 1) * (1 / n + 1 / ne)
print(f"K={K:3}: PSI medio {sum(vals)/20:.3f} · máx {max(vals):.3f} · fórmula {piso:.3f}")K=500: PSI medio 0.123 · máx 0.140 · fórmula 0.146
K= 30: PSI medio 0.009 · máx 0.016 · fórmula 0.008Con 500 categorías, las 20 horas de dos versiones idénticas dan un PSI de 0.11 a 0.14 (el mínimo, 0.108, no sale impreso): todas pasan el umbral de 0.1. La fórmula da un poco más que la simulación porque muchas categorías tienen conteos de 0 o 1, donde la aproximación falla, y el medio conteo de colchón (que evita dividir entre 0) achica el PSI. Con 30, ninguna hora se acerca. La mezcla de juguete, con pesos 1, 1/2, 1/3…, imita la forma de la de Alba: pocas categorías grandes y una cola larga.
El PSI entre dos versiones idénticas no da 0: da su piso de ruido. La calculadora aplica n=
Es una aproximación: con muchas categorías de conteo 0 o 1, el PSI real (con su colchón) sale algo menor. Alba usa K ≈ 30 categorías padre y exige ≥ 5,000 predicciones.
Empieza con las 500 categorías de madrugada: ψ0 ≈ 0.146, arriba del umbral. Baja K a 30 y mira cómo cae. Luego sube Q a 350, el pico: con más predicciones, hasta 500 categorías quedan debajo de 0.1.
Promover, el A/B y el bake
EsencialPromote, the A/B test and the bake
Quién mueve champion
Al 100 %, con el análisis siempre verde, la versión 15 atiende a todos. Falta que el registro lo diga. Lo hace el job promover del pipeline: espera a que el Rollout esté sano al 100 % y mueve el alias champion a la versión 15 en el registro de modelos. Le pone dos etiquetas: el run (el registro del entrenamiento que produjo el modelo) y el digest de la imagen. No hay una segunda aprobación: vale la de la persona que aprobó el job produccion antes de que todo empezara.
«Gate de evaluación y registry» explicó por qué ningún servidor lee el alias: el pipeline lo leyó una vez y metió esa versión en la imagen. Aquí se cierra el ciclo: el alias se mueve al final, cuando ya es verdad. Si el canary se revierte, champion nunca se movió y sigue en la 14.
La regla de fondo: lo automático revierte, una persona autoriza. Revertir tiene que ser instantáneo y no puede esperar a que alguien despierte. Avanzar puede esperar, y por eso la persona aprueba una vez, antes de que Argo CD aplique el cambio.
Cuando el cambio es grande: el canary por request y el A/B por vendedor
El canary reparte por request: cada foto tira su propio dado. Eso basta para medir salud (errores, latencia, confianza), porque cada request es independiente. No basta para medir si la gente acepta más las sugerencias: Ana vería la versión 15 en una foto y la 14 en la siguiente, y no hay forma de saber cuál la convenció.
Para eso está la prueba A/B de «Ruido, muestras y pruebas A/B», con el vendedor como unidad de aleatorización: lo que se sortea entre los dos grupos (llamados brazos) es cada vendedor, no cada foto. Ana queda del mismo lado siempre, y se puede medir si acepta más sugerencias con una versión que con la otra. Dura de 1 a 2 semanas completas.
Alba solo lo corre para cambios grandes (arquitectura nueva o categorías nuevas). En esos, el canary sube a 5 % y a 25 % para confirmar la salud, y ahí se detiene: el A/B toma el reparto. El reentrenamiento de cada mes no lleva A/B; lleva gate, shadow y canary.
Para ir más hondoEl A/B de Alba por dentro+
Con una aceptación base de ≈ 70 % y un efecto mínimo de 1 punto, hacen falta ≈ 33,000 publicaciones por brazo: por eso dura semanas completas.
El sorteo por vendedor, hash(sal + seller_id) mod 100, lo cuenta «Ruido, muestras y pruebas A/B». El backend de publicación (el programa que guarda las publicaciones) manda el brazo en un header (una línea de datos que viaja con la request), X-Model-Arm. Una regla del ALB que mira ese header lleva la request a la release de su brazo, y el gateway escribe el brazo en el log junto al request_id.
El bake: la anterior, viva
Llegar al 100 % no es el final. Algunos problemas solo aparecen con todo el tráfico o con el tiempo: una categoría chica que la versión 15 confunde y que en un canary del 5 % juntó pocos casos, o una fuga de memoria (un programa que pide memoria y nunca la suelta) que tarda un día en llenar el pod. Por eso existe el bake (bake time, el tiempo de horneado): la release anterior, su gateway y su triton-v14, sigue prendida 24 a 48 horas después de llegar al 100 %.
El bake convierte el rollback en un cambio de ruteo: volver es mandar el tráfico a algo que ya está prendido, caliente y con su engine cargado. Sin bake, volver es levantar pods nuevos de Triton, que tardan minutos.
Eso es, en el fondo, un blue/green: dos entornos completos, uno viejo (blue) y uno nuevo (green), y un switch que manda todo el tráfico a uno o al otro. Alba no hace un blue/green puro, con el salto de 0 a 100 % de golpe; hace el canary para subir, y deja el blue vivo después, como red.
Con Argo Rollouts, el bake hay que pedirlo, porque por omisión hace dos cosas que lo rompen. Apaga el gateway viejo 30 segundos después de llegar al 100 %. Y volver a él corre otra vez todos los pasos, con su 5 % por 4 horas. Dos líneas del Rollout de Alba cambian eso: scaleDownDelaySeconds: 172800 deja el gateway viejo prendido 48 h, y rollbackWindow: {revisions: 3} hace que volver a una versión reciente se salte los pasos. triton-v14 no depende de esas líneas: es un Deployment aparte, y sigue prendido hasta que un PR lo quita.
Para ir más hondoLo que Argo Rollouts hace por omisión+
Argo Rollouts también tiene una estrategia blue/green, y ahí scaleDownDelaySeconds (lo que espera para apagar la versión vieja después del switch) vale 30 segundos por omisión: si tu plan de rollback cuenta con el blue un día, a los 30 s ya no existe. Hay que ponerla a mano, en segundos que sumen horas, y pagar esas horas. En el canary con pesos en el balanceador pasa lo mismo: el ReplicaSet viejo del gateway (el grupo de pods de la versión anterior) se apaga 30 s después de llegar al 100 %.
Abortar a medio canary, cuando el estable todavía es la 14, regresa el tráfico de inmediato. Pasado el canary, la 15 ya es el estable y volver a la 14 es otro cambio del template. rollbackWindow: {revisions: 3} cubre la actual y las 2 anteriores: volver a una de las 2 anteriores va directo al 100 %.
Cuánto cuesta la escalera
La sombra, el canary y el bake comparten un costo: una T4 de más mientras duran. En la sombra es la T4 del Triton de la 15, que todavía no atiende. En el canary, la misma. En el bake, la que se queda con la 14: la 15 pasa a sus 2 T4 de siempre, una por zona, y triton-v14 se queda con un solo pod. Mientras un Triton tiene un solo pod (la 15 en la sombra y el canary, la 14 en el bake), su PDB va en minAvailable: 0: con 1 de 1, ningún drain (vaciar un nodo para darle mantenimiento) podría sacarlo. Al terminar el bake, un PR quita la 14. Una T4 sola carga el pico de 350 requests por segundo, porque contesta ≈ 1,200 fotos por segundo; lo que pierde la 14 en el bake es la segunda zona, no la capacidad.
Para ir más hondoQuién cambia los pods al llegar al 100 %+
Cuando el Rollout llega al 100 % sano, el job promover mueve champion, y la GitHub App (la cuenta automática del repositorio de despliegue) abre y junta un PR con dos cambios. Pone a triton-v15 en su ScaledObject de KEDA (el autoscaling de Triton) con 2 a 4 pods, uno por zona como mínimo, y deja a triton-v14 con un solo pod para el bake. El mismo PR pone el PDB de triton-v14 en 0 y regresa el de triton-v15 a 1.
- donde
- u
- el precio por hora de una T4 (una g4dn.xlarge), en US$/h
- tsh
- el tiempo de shadow, en horas
- tcan
- el tiempo de canary, en horas
- tbk
- el tiempo de bake, en horas
- C
- el costo de la T4 extra en toda la escalera, en US$
Volver: el rollback según la fase y el runbook
EsencialGoing back: rollback by phase and the runbook
Cuánto tarda volver depende de cuándo
«Pruebas y CI/CD» dejó la regla: primero revertir, después investigar. Esta estación agrega el cómo, que cambia con la fase:
| Fase | Qué pasa al revertir | Cuánto tarda |
|---|---|---|
| Shadow | se apaga la copia; el usuario nunca vio nada | nada que revertir |
| Canary (5 % o 25 %) | Argo Rollouts aborta y devuelve el 100 % del peso al estable | segundos |
| Bake (24–48 h) | un git revert del cambio del template, en un PR que aprueba una persona; Argo CD lo aplica y, con rollbackWindow, el Rollout se salta los pasos y manda el tráfico a la release 14, que sigue prendida | minutos: lo que tarde la aprobación del PR, hasta 3 min de Argo CD y segundos de switch |
| Pasado el bake | el mismo git revert, más el del PR que quitó triton-v14, que hay que levantar otra vez: nodo con GPU, imagen de ≈ 9.2 GB, engine | ≈ 5–20 min |
Para ir más hondoLo que pasa en Git después de revertir+
En el canary, el controlador aborta solo, sin Git. Pero Git sigue pidiendo la versión 15, así que el Rollout queda abortado y Argo CD lo marca como degradado hasta que alguien revierte el commit en alba/despliegue («CI/CD y registro de imágenes», «El rollback, con este diseño»). Ese revert es un PR que aprueba una persona: no hay prisa, porque el tráfico ya volvió.
No se usa kubectl argo rollouts undo, el comando que regresa un Rollout a su revisión anterior (el kubectl rollout undo de «Kubernetes» es para Deployments). Con GitOps (Git manda sobre el clúster), un cambio a mano en el clúster no queda en Git: si Argo CD tiene prendida la corrección automática (self-heal), lo regresa a lo que dice Git en cuanto lo compara; si no, lo marca fuera de sincronía y el siguiente sync (cuando Argo CD vuelve a copiar Git al clúster) lo borra. El rollback de verdad es el revert.
Cuánto daño hace un modelo malo según la fase
Un modelo malo que contesta 200 OK (el código de «todo salió bien») no se ve en los errores. Se ve en la baja confianza o en el PSI, con su ventana de 30 minutos a 1 hora. Lo que cambia entre fases es a cuántos les toca mientras tanto.
- donde
- Q
- el tráfico total, en requests por segundo
- w
- el peso de la versión mala, en %
- tdet
- el tiempo hasta detectar, en minutos
- tr
- el tiempo hasta revertir, en minutos
- Nm
- las requests que contestó la versión mala, en requests
En el pico, con Q = 350 y tdet = 30 minutos (la ventana de la baja confianza):
- En el canary al 5 %, tr ≈ 0.1 min (segundos): Nm = 350 × 5 ÷ 100 × 60 × (30 + 0.1) ≈ 31,600 requests.
- En el bake, al 100 %, con la meta de tr ≤ 5 min: Nm = 350 × 100 ÷ 100 × 60 × (30 + 5) = 735,000.
- Pasado el bake, tr ≈ 20 min: Nm = 350 × 100 ÷ 100 × 60 × (30 + 20) = 1,050,000.
El canary al 5 % expone a 23 veces menos fotos que el mismo error en el bake (735,000 ÷ 31,600 ≈ 23). Y no son errores 5xx: son sugerencias peores que Ana puede corregir a mano. El daño es real pero acotado, y por eso existe el peldaño chico.
El kill switch
Hay un rollback todavía más rápido: no volver a la versión anterior, sino apagar la función. Un kill switch es un feature flag (un interruptor en la configuración, de «Configuración: YAML, variables de entorno y secretos») que apaga una función completa mientras el programa corre, sin desplegar nada. En Alba, apagar las sugerencias hace que Ana vea el selector de categorías normal, como si el modelo no existiera.
Es la palanca para cuando el problema no es la versión: si las dos sugieren tonterías porque cambió algo de afuera (como el preproceso de las fotos en la app), volver a la 14 no arregla nada. Apagar sí.
El runbook
Un runbook de rollback es la receta escrita, paso a paso, de qué hace la persona de guardia (la que atiende las alertas en su turno) cuando algo sale mal en un despliegue. Se escribe en calma para usarse con prisa, a las 3 de la mañana, por alguien que no hizo el cambio. En Alba, la de guardia es Marta, y el runbook dice:
- 1
Detectar
Lo hace la máquina: el análisis del canary o una alerta. Marta recibe el aviso con la versión, la señal que falló y el enlace a la gráfica.
- 2
Revertir sin diagnosticar
Meta: ≤ 5 minutos. Si fue en el canary, ya se revirtió solo. Si fue en el bake, revierte el commit en
alba/despliegue, pide la aprobación del PR y regresa el aliaschampiona la versión 14, porque el jobpromoverya lo había movido. No se busca la causa antes. - 3
Confirmar
En 15 a 30 minutos, las métricas de la 14 tienen que volver a su nivel. Si no vuelven, el problema no era la versión, y toca el kill switch o buscar otra causa.
- 4
Congelar
Nadie despliega otra versión del modelo hasta entender qué pasó.
- 5
Comunicar
Un mensaje corto a los equipos que usan las sugerencias: qué se vio, qué se hizo, qué sigue.
- 6
Investigar
Con calma, con el log de cada request (que dice su
model_version) y un análisis escrito de qué falló y qué se cambia.
Un runbook que nunca se ensayó no es un plan. Alba lo practica en staging, una copia del sistema sin usuarios reales (el namespace classifier-staging): un canary con un modelo roto a propósito, para ver que el análisis lo atrapa y que el aborto funciona.
Dos versiones vivas a la vez
ExtraTwo versions alive at once
Lo que se rompe cuando conviven
Durante el canary y el bake, la 14 y la 15 contestan a la vez, y eso rompe lo que suponga una sola:
- Los logs y las métricas. Si una línea de log no dice qué versión contestó, el análisis no puede comparar. En Alba, cada línea lleva
model_version, y la métrica de requests (classifier_requests_total) la lleva como etiqueta. - El caché. Su llave lleva la huella de la foto más la versión del modelo; sin la versión, el canary serviría respuestas del estable y viceversa.
- Los labels. El
labels.jsonviaja con su modelo, nunca con la imagen del gateway: con los de otra versión, el gateway contestaría con buena confianza en las categorías equivocadas.
Los tres contratos
| Contrato | Qué es | Cómo se cuida |
|---|---|---|
| La API pública | POST /v1/classify (la ruta que recibe la foto) y su respuesta | La respuesta trae el nombre de la categoría, nunca su posición en la salida del modelo |
| La entrada del modelo | un tensor de 3 × 224 × 224 en FP32 (números de 32 bits), con su preproceso | Versión del preproceso registrada con el modelo |
| La salida del modelo | 500 logits (un puntaje por categoría), en el orden de labels.json | La huella de labels.json en el registro, verificada al arrancar |
La primera regla es la que más protege: si la respuesta trajera «categoría 213», un cambio de orden en el modelo cambiaría lo que ven todos los clientes sin que nada fallara.
Expand and contract: de 500 a 501
Cuando el negocio agrega una categoría, por ejemplo «bolsas», el modelo pasa de 500 a 501 salidas. Si todo cambiara de golpe, durante el canary convivirían clientes que conocen 500 nombres y un modelo que contesta con 501. La técnica para cambiar un contrato sin romper a nadie es expand and contract (expandir y contraer), en tres pasos:
- 1
Expandir los consumidores
Primero, quien usa la respuesta aprende el nombre nuevo: el backend de publicación y la app aceptan «Bolsas» aunque todavía nadie lo mande.
- 2
Cambiar el productor
Después, la release con el modelo de 501 sale por su escalera (con A/B, porque cambian las categorías). Los dos modelos conviven sin problema: los clientes ya entienden los dos.
- 3
Contraer
Al final, cuando la versión vieja ya no existe, se borra lo que solo servía para ella.
El orden es lo importante: nadie produce algo que su consumidor todavía no entiende.
Errores comunes
EsencialCommon mistakes
En la vida real
ExtraIn real life
En Alba
Una vez al mes, el día 1, el pipeline entrena el modelo nuevo, y en los días siguientes sube la escalera: hasta dos días de sombra, 8 horas de canary y hasta dos días de bake. Nadie del equipo de 5 personas mira un tablero para promoverlo: la máquina avanza y revierte. Las personas aprueban el job produccion y revisan a mano los 300 a 500 desacuerdos del shadow. Los cambios del gateway, varias veces por semana, solo hacen el canary corto, de 1 hora por paso.
En el Hot Sale, la campaña donde el tráfico de Alba se multiplica, el equipo congela los despliegues: ningún canary corre esa semana. Antes suben los mínimos de pods, como cuenta «Kubernetes».
Otros casos
- Video en tiempo real. Un detector nuevo para cámaras de seguridad corre en sombra en 10 cámaras de 2 sitios (supuesto del ejemplo): procesa el mismo video y guarda sus alertas sin mandarlas a nadie. La sombra dura semanas, porque los eventos raros (un intruso) llegan pocas veces. Y el rollback es local: cada sitio guarda las dos versiones, y volver es cambiar a cuál apunta un enlace.
- Inspección en una fábrica. Una cámara con GPU revisa piezas en la línea. El modelo nuevo corre en sombra un turno completo, después de que el actual decidió: ≈ 57,600 piezas con ≈ 99.8 % de acuerdo dan ≈ 115 desacuerdos para revisar (supuesto del ejemplo). Cada aparato guarda dos engines: volver tarda minutos, sin la nube.
- Predicciones en lote. Un modelo que calcula cada noche una tabla de predicciones no tiene canary: escribe la tabla nueva al lado (
predicciones_v2), se compara contra la vieja, y el cambio es mover el puntero que leen los demás. Es un blue/green sobre datos. - Búsqueda y recomendación. La pregunta casi siempre es «¿mejora?», y manda el A/B, que dura semanas. El canary solo confirma que el sistema nuevo no truena.
- Servicios gestionados. SageMaker, el servicio de modelos de AWS, ofrece «guardrails» de despliegue: un blue/green que mueve el tráfico de golpe, en dos pasos (canary) o en varios iguales (linear), con un tiempo de espera (baking period) y rollback automático por alarmas de CloudWatch, su sistema de métricas. KServe, sobre Kubernetes, pone un porcentaje de canary en su manifiesto. Otros nombres, la misma escalera.
Fuera de ML
Un restaurante que cambia su receta de mole no la sirve a todos el lunes. Primero la prueba la cocina (el gate), luego una mesa de confianza la come junto al mole de siempre (la sombra), luego la ofrece en una de cada veinte mesas (el canary), y una semana guarda la receta vieja en el refrigerador (el bake). Si alguien se queja, el mesero no investiga: saca el mole de siempre.
Ejercicios
EsencialExercises
Resuélvelos con lápiz antes de abrir la solución. Usa las letras de la lección: Rd, m, Np, a, Nd (shadow); nmin, Q, w, tn (n mínimo); v, n, p0, λ, k, i, f, tp, J, F (falsa alarma); K, ne, ψ0 (PSI); u, tsh, tcan, tbk, C (costo); Nm, tdet, tr (daño).
- 1Fácil
El shadow de la versión 15 copia el 5 % en vez del 10 % durante 2 días, con un acuerdo a de 0.94. ¿Cuántos pares y desacuerdos junta en total? ¿Alcanza para revisar 400 a mano?
Ver la solución paso a paso
- Np=
Rd× = 10,000,000 × 0.05 = 500,000 pares al día; en 2 días, 1,000,000.m - Nd=
Np× = 1,000,000 × 0.06 = 60,000 desacuerdos.(1− a) - Sobra: 400 es menos del 1 % de 60,000. Lo que se pierde son casos de las categorías chicas.
- Np=
- 2Fácil
Di qué peldaños sube cada cambio en Alba: (a) el reentrenamiento de diciembre; (b) un arreglo en el código que decodifica las fotos en el gateway; (c) un modelo con otra arquitectura y 501 categorías.
Ver la solución paso a paso
- (a) Gate, shadow de 1–2 días, canary de 5 % → 25 % → 100 % con pasos de 4 h y bake de 24–48 h. Sin A/B.
- (b) CI y canary con pasos de 1 h, sin shadow. Ojo: decodificar distinto sí puede cambiar lo que contesta el modelo; la baja confianza y el PSI del canary lo tienen que ver.
- (c) Todos: gate, shadow, canary hasta 25 % y A/B de 1 a 2 semanas por vendedor, con expand and contract para la categoría nueva.
- 3Fácil
Con nmin = 10,000, ¿cuánto tarda en juntarse el n mínimo al 25 % en tráfico promedio (Q = 116)? ¿Y al 1 % en el pico?
Ver la solución paso a paso
- tn=
nmin÷ .(Q× w÷ 100× 60) - Al 25 % en promedio: 116 × 25 ÷ 100 = 29 por segundo; 10,000 ÷ (29 × 60) ≈ 5.7 min.
- Al 1 % en el pico: 350 × 1 ÷ 100 = 3.5 por segundo; 10,000 ÷ (3.5 × 60) ≈ 48 min. Arriesga menos, pero tarda más en saber.
- tn=
- 4Medio
Un cambio del gateway hace su paso al 5 % por 1 h a las 3 de la mañana, con Q ≈ 20 y la regla de 5xx «≥ 2 × el estable» cada 10 minutos y sin n mínimo. Con p0 = 0.001, calcula n, λ, k, f y F.
Ver la solución paso a paso
- n=
Q× = 20 × 5 ÷ 100 × 60 × 10 = 600 requests en 10 min.w÷ 100× 60× v - λ=
n× = 600 × 0.001 = 0.6; k=p0 ⌈2× = ⌈1.2⌉ = 2: bastan 2 errores.0.6⌉ - f=
P(X≥ = 1−2) e−0.6× ≈ 1 − 0.549 × 1.6 ≈ 0.122.(1+ 0.6) - J=
60× = 60 × 1 ÷ 10 = 6; F=tp÷ v 1− ≈ 1 − 0.458 ≈ 54 %: más de la mitad de los cambios buenos se revertiría.(1− 0.122)6
- n=
- 5Medio
El análisis del canary de la versión 15 mide, en 30 minutos de pico: estable con 6.0 % de baja confianza y canary con 8.4 %. A la misma hora, una campaña de bicicletas subió la baja confianza de las dos. ¿Qué decide la regla relativa? ¿Y un umbral fijo de «> 8 %»?
Ver la solución paso a paso
- Razón = baja confianza del canary ÷ la del estable = 8.4 ÷ 6.0 = 1.4, menos que 1.5: la regla relativa sigue.
- El umbral fijo de 8 % revertiría: lo empujó la campaña, no el modelo.
- Un 1.4 está cerca del límite: vale la pena que una persona mire las categorías de esa media hora, sin detener nada.
- 6Medio
La versión 15 sugiere mal en el bake, al 100 %, y la baja confianza tarda tdet = 30 min en verlo. Compara Nm en el pico si el runbook revierte en tr = 5 min (con la 14 viva) contra 20 min (pasado el bake). ¿Cuánto ahorra el bake?
Ver la solución paso a paso
- Nm=
Q× .w/100× 60× (tdet+ tr) - Con bake: 350 × 1 × 60 × (30 + 5) = 735,000.
- Sin bake: 350 × 60 × (30 + 20) = 1,050,000.
- El bake ahorra 315,000 fotos con sugerencias malas en un incidente, por ≈ US$13–25 de una T4. Aun así, lo que más pesa son los 30 minutos de detección.
- Nm=
- 7Reto
Alguien propone quitar el n mínimo y bajar la ventana de 5xx a 1 minuto «para detectar más rápido». En el pico al 5 %, con p0 = 0.001, calcula n, λ y k por minuto. ¿Por qué esto es peor, aunque en el pico f sea parecido al de la madrugada con 10 minutos?
Ver la solución paso a paso
- n=
Q× = 350 × 5 ÷ 100 × 60 × 1 = 1,050 en un minuto; λ=w÷ 100× 60× v n× = 1.05; k=p0 ⌈2× = ⌈2.1⌉ = 3 errores.λ⌉ - f=
P(X≥ con λ = 1.05: 1−3) e−1.05× ≈ 1 − 0.350 × 2.601 ≈ 0.09.(1+ 1.05+ 0.551) - Lo grave es J: en un paso de 4 horas, J=
60× = 60 × 4 ÷ 1 = 240 decisiones. F=tp÷ v 1− = 1 − 0.91^240 ≈ 100 %: el canary nunca termina un paso.(1− f)J - Para saltos grandes ya está el tope absoluto (0.5 %), que con n ≈ 1,050 los ve en un minuto. La regla relativa existe para saltos chicos, y esos necesitan n.
- n=
- 8Reto
Diseña el canary de un cambio de código del gateway que se despliega a cualquier hora. Pasos de 1 h al 5 % y 25 %, y quieres F ≤ 5 % para la regla de 5xx en cada paso. ¿Qué n mínimo pides? ¿Y de madrugada?
Ver la solución paso a paso
- F=
1− , con J = las decisiones que caben en el paso de 1 h = 60 ÷ tn.(1− f)J - Con nmin = 10,000: f ≈ 0.35 %. En el pico al 5 %, tn ≈ 9.5 min, así que caben ≈ 6 decisiones por hora: F ≈ 1 − 0.9965^6 ≈ 2.1 %, debajo de 5 %.
- Al 25 % en el pico, tn ≈ 1.9 min y caben ≈ 31 decisiones: F ≈ 1 − 0.9965^31 ≈ 10 %. Para bajarlo, sube nmin al 25 % (con 50,000, λ = 50, k = 100 y f es casi 0) o decide una sola vez al final del paso.
- De madrugada al 5 % (Q ≈ 20), una decisión pide 2.8 h: el paso de 1 h termina sin decidir. O el paso no avanza hasta juntar el n mínimo («inconcluso no es verde»), o no se despliega de madrugada. Alba hace las dos.
- F=
Para ir más hondoCuatro ejercicios más, para la segunda pasada+
- 1Fácil
¿Cuánto cuesta la T4 extra de una release con shadow de 2 días, canary de 8 h y bake de 24 h, con u = US$0.526/h?
Ver la solución paso a paso
- C=
u× = 0.526 × (48 + 8 + 24) = 0.526 × 80 ≈ US$42.(tsh+ tcan+ tbk) - Contra US$3,000 al mes: ≈ 1.4 %.
- C=
- 2Medio
Con las 500 categorías, ¿cuántas predicciones del canary harían falta en una hora para que el piso de ruido ψ0 quede en 0.05, la mitad del umbral? Toma ne=
19× . ¿Cuántas con 30 categorías?n Ver la solución paso a paso
- ψ0≈
(K− .1)× (1/n+ 1/ne)= (K− 1)× (1/n)× (1+ 1/19) - Despeja: n=
(K− .1)× (1+ 1/19)÷ ψ0 - Con K = 500: 499 × 1.0526 ÷ 0.05 ≈ 10,500 predicciones en la hora: 2.9 por segundo al canary, Q ≈ 58 al 5 %. De madrugada no llega.
- Con K = 30: 29 × 1.0526 ÷ 0.05 ≈ 610. Agrupar en padres baja el n necesario ≈ 17 veces.
- ψ0≈
- 3Medio
El gateway de la 15 arranca con el
labels.jsonde la 14 por un error en el repositorio de despliegue. ¿Qué lo detiene primero: el arranque del gateway, el shadow o el canary? ¿Y si el error fuera solo el orden de dos categorías, con el mismo número de nombres?Ver la solución paso a paso
- Primero el arranque del gateway: verifica la huella de
labels.jsoncontra la esperada pararesnet50-2026-11-01. No coincide, el proceso termina, el pod nunca llega a estar listo ni entra al Servicegateway-canary, y el Rollout no avanza. - Si se desordenaran dos categorías y la huella esperada tuviera el mismo error, el arranque pasaría. Lo atrapa el PSI del canary: las fotos de esas dos categorías cambian de lugar y la mezcla de padres se mueve. Si las dos son del mismo padre, el PSI no lo ve; queda el shadow, donde el acuerdo en esas dos categorías se desploma.
- Primero el arranque del gateway: verifica la huella de
- 4Reto
El canary al 25 % se aborta por la baja confianza, a las 15:00. Escribe, en orden, lo que pasa en el clúster, en Git y en el registro, y quién hace cada cosa.
Ver la solución paso a paso
- Clúster: el análisis mide 1.6 × el estable (el límite es 1.5 ×) y Argo Rollouts aborta: el peso del ALB vuelve a 100 % en
gateway-stableen segundos. Los pods canary del gateway bajan;triton-v15sigue prendido. - Guardia: Marta recibe el aviso. Ya se revirtió solo: confirma en 15–30 minutos que la baja confianza de la 14 sigue en su nivel.
- Git: Argo CD ve el Rollout degradado, porque el repositorio todavía pide la 15. Marta abre el revert del commit en
alba/despliegue, otra persona lo aprueba y Argo CD lo aplica. Otro PR quitatriton-v15. - Registro: nada.
championsigue en la 14, y la 15 queda comochallengerhasta entender qué pasó.
- Clúster: el análisis mide 1.6 × el estable (el límite es 1.5 ×) y Argo Rollouts aborta: el peso del ALB vuelve a 100 % en
Lo que sigue
EsencialWhat comes next
- «La request en vivo» sigue una request por todo el camino, con su línea de log y sus métricas: las mismas
model_versionyclassifier_requests_totalque consulta el análisis del canary. - «Monitoreo, drift y reentrenamiento» vigila al
championcuando ya no hay canary que lo compare: la baja confianza contra su promedio de 7 días, el PSI contra las 4 semanas previas, las alertas de la guardia y el disparador que manda a entrenar el modelo siguiente, que volverá a subir esta escalera.
Palabras que vas a oír
EsencialWords you will hear
Estos son los conceptos que presentó esta lección. Cada uno tiene su tarjeta con la definición completa.
Despliegue progresivoprogressive deliveryPoner una versión nueva frente al tráfico en peldaños (sombra, una parte chica, todo), midiendo algo distinto en cada uno y regresando al anterior si un criterio falla.Más +
Desplegar un modelo tiene tres riesgos distintos: que no funcione con datos reales, que empeore la experiencia de quien lo usa y que no mejore el producto. El despliegue progresivo separa esas preguntas y le da a cada una su peldaño: el shadow (despliegue en sombra) responde «¿funciona?», el canary «¿es seguro?», una prueba A/B «¿mejora?» y el bake time «¿podemos volver?». No todo cambio sube todos los peldaños: cada uno cuesta tiempo y se paga donde el riesgo lo pide. Un rolling update no es un despliegue progresivo de un modelo: mide salud, no calidad, y no controla el porcentaje.
Analogía. Como una receta nueva en un restaurante: la prueba la cocina, luego una mesa de confianza, luego una de cada veinte mesas, y la receta vieja se queda en el refrigerador una semana. Se rompe en que los comensales eligen platillo; las requests no eligen versión.
Ejemplo. El reentrenamiento mensual de Alba sube gate → shadow de 1–2 días → canary 5 % → 25 % → 100 % → bake de 24–48 h; un cambio de código del gateway solo hace el canary, con pasos de 1 h.
Shadow (despliegue en sombra)shadow deploymentCorrer la versión nueva con copias de requests reales, guardar lo que contesta y tirarlo: el usuario solo ve la respuesta de la versión actual.Más +
También se llama dark launch. Mide al modelo nuevo con el tráfico de hoy (errores, latencia y cuánto cambia lo que contesta) sin arriesgar a nadie. Lo que no mide es a la gente: nadie vio sus sugerencias. La copia se hace con copia de tráfico; corre en una tarea aparte, con su plazo y una cola acotada, y su respuesta solo va al log. Su peligro son los efectos secundarios: una copia que escribe en una base de datos, manda un correo o comparte un caché le sirve su respuesta a alguien.
Analogía. Un alumno de manejo con el volante desconectado: gira como si manejara, una cámara graba los dos volantes, y al final se compara. Se rompe en que el alumno ve el camino que eligió el instructor; en el shadow, cada foto es independiente.
Ejemplo. En Alba, el gateway de la release 14 copia el 10 % de las requests (por el hash del request_id) al Triton de la versión 15 durante 1–2 días: ≈ 1 M pares al día; pasa con acuerdo top-1 ≥ 90 %, p99 ≤ 1.1 × el del champion y cero crashes.
Copia de tráficotraffic mirroringEl mecanismo que manda una copia de cada request (o de una muestra) a un segundo destino, cuya respuesta se descarta. Es lo que hace posible un shadow (despliegue en sombra).Más +
La copia se puede hacer en tres lugares: en el propio programa (el gateway decide y copia), en una malla de servicios (una capa de red que pone un programita, el sidecar, junto a cada servicio) o en la plataforma (un balanceador que la soporte). Donde sea, la regla es la misma: la copia no debe frenar ni cambiar la respuesta original. Por eso va en una tarea aparte, con su propio plazo y una cola acotada que tira copias si se llena. La muestra se elige con una asignación por hash para que sea repetible.
Ejemplo. El gateway de Alba calcula el SHA-256 del request_id, lee los primeros 8 caracteres de esa huella como un número y copia si ese número, módulo 10,000 (el residuo de dividir entre 10,000), da menos de 1,000: de 100,000 ids copia 9,955, casi el 10 %.
Release (el par gateway + Triton)release pairEn Alba, una release es un par: el gateway (el servicio que recibe las fotos) de una versión más el Triton (el servidor del modelo) de esa versión, cada uno con su nombre. Así nunca hay dos modelos detrás del mismo nombre.Más +
Cada versión del modelo corre en su propio Deployment triton-vN con su Service triton-vN. El gateway de esa release trae TRITON_URL apuntando a ese Service, su MODEL_VERSION y su labels.json (de un ConfigMap por versión, con su huella verificada al arrancar). Durante un canary conviven dos releases completas, y cada request pasa por una sola: su versión queda escrita en el log y en las métricas, y el análisis puede compararlas.
Ejemplo. La release 15 es el gateway con TRITON_URL=triton-v15.classifier.svc.cluster.local:8000, MODEL_VERSION=resnet50-2026-11-01 y el ConfigMap classifier-labels-15, más el Deployment triton-v15.
Canarycanary releaseMandar una parte chica del tráfico real a la versión nueva, por etapas, y avanzar solo si en cada etapa se ve tan bien como la estable, comparando las dos en el mismo periodo de tiempo.Más +
El porcentaje lo pone un proxy con pesos (en Alba, el ALB), no el número de pods: con 2 pods estables y 1 nuevo, el reparto por pods da ≈ 33 %. El canary reparte por request, así que mide salud (errores, latencia, confianza) pero no el comportamiento de cada usuario, que pide una prueba A/B por usuario. Cada etapa dura lo suficiente para juntar su n mínimo y cubrir el pico del día, y sus criterios se escriben antes. El nombre viene de los canarios que los mineros bajaban para detectar gas.
Ejemplo. El de Alba para un modelo: 5 % por 4 h (17.5 requests por segundo en el pico), 25 % por 4 h (87.5), 100 %, sin pausa manual; lo ejecuta Argo Rollouts.
Argo RolloutsArgo RolloutsUn programa que corre dentro de Kubernetes (un controlador) y agrega el objeto Rollout: la misma plantilla de pod que un Deployment, más los pasos de un canary o un blue/green, con análisis automático y aborto.Más +
Los pasos son una lista (setWeight: 5, pause: {duration: 4h}…). Con trafficRouting escribe los pesos (qué parte del tráfico va a cada versión) en el balanceador (en AWS, en una anotación del Ingress que el AWS Load Balancer Controller aplica al ALB); sin él, reparte por número de pods. Su análisis consulta métricas (Prometheus, entre otros) y, si una medición falla, aborta y regresa el tráfico al estable. Con GitOps, Argo CD aplica el Rollout como cualquier manifiesto; tras un aborto, el Rollout queda abortado hasta que Git vuelva a pedir la versión estable. Apaga la versión vieja 30 s después del switch (en blue/green) o de llegar al 100 % (en canary con trafficRouting) si no se cambia scaleDownDelaySeconds. Y volver a una versión anterior ya promovida es, para él, un cambio más: corre otra vez todos los pasos, salvo que rollbackWindow diga cuántas revisiones recientes se saltan los pasos.
Ejemplo. El gateway de Alba es el Rollout gateway, en el namespace classifier, con los Services gateway-stable y gateway-canary, el Ingress gateway y el análisis canary-vs-estable.
Criterio de promociónpromotion criteriaLa regla, escrita antes de empezar, que dice qué tiene que cumplir una versión en un peldaño para subir al siguiente.Más +
Se escribe antes por la misma razón que los umbrales de un gate: si se elige después de ver los números, siempre se puede justificar lo que uno quería. Un buen criterio compara contra el estable en la misma ventana, dice su ventana y su n mínimo, y exige que las señales estén verdes durante todo el paso, no solo al final. Su espejo es el rollback automático.
Ejemplo. En el shadow de Alba: acuerdo top-1 ≥ 90 %, p99 ≤ 1.1 × el del champion, cero crashes y ninguna de las 20 categorías más grandes con acuerdo < 85 %. En el canary: los cuatro criterios relativos verdes durante las 4 h de cada paso.
Rollback automáticoautomated rollbackRegresar el tráfico a la versión estable sin esperar a una persona, cuando una métrica rompe un umbral escrito antes.Más +
Existe porque revertir no puede esperar a que alguien despierte, y porque decidir con calma a las 3 de la mañana es difícil. Usa dos clases de umbrales: topes absolutos (la promesa del servicio) y comparaciones contra el estable en la misma ventana, cada una con su n mínimo para no revertir por azar. La regla de fondo: lo automático revierte; una persona autoriza el avance.
Ejemplo. Alba revierte si el canary pasa de 0.5 % de 5xx (errores del servidor) o de 200 ms de p99. También si, contra el estable, tiene más de 2 × sus 5xx (con ≥ 10,000 requests), 1.2 × su p99 o 1.5 × su baja confianza, o si el PSI pasa de 0.1 (con ≥ 5,000 predicciones).
Análisis del canarycanary analysisLa comparación automática de las métricas del canary contra las del estable en la misma ventana de tiempo, que decide si el canary sigue o se aborta.Más +
Comparar en la misma ventana cancela el ruido del día: una campaña o la madrugada afectan a las dos versiones igual, porque los pesos reparten al azar por request. Lo que queda es la diferencia del modelo. Para eso cada métrica lleva la versión como etiqueta (model_version). Los topes absolutos se quedan como red, por si todo el sistema está mal. Las señales que miran qué contesta el modelo (la confianza, la mezcla de categorías con el PSI) son las que atrapan a un modelo que se equivoca con confianza.
Ejemplo. A las 13:00, una campaña de bicicletas sube la baja confianza (la parte de fotos en que el modelo duda) de las dos versiones: estable 6.0 %, canary 8.4 %. La razón, 1.4, queda bajo el límite de 1.5: el canary sigue.
n mínimo de un criteriominimum sample sizeCuántas requests (o predicciones) tiene que juntar el canary antes de que un criterio pueda decidir. Sin él, el azar revierte versiones buenas.Más +
Con pocas requests, una regla relativa dispara por ruido: si el estable falla en el 0.1 % y el canary junta 600 requests, se esperan 0.6 errores, y 2 ya son «el doble». La ventana se alarga hasta juntar el n mínimo, así que de madrugada una decisión tarda horas. El n se diseña con la potencia que se quiere y con la tasa real del estable: si la tasa baja, el n tiene que subir. En un PSI, el piso de ruido es ≈ (K − 1)(1/n + 1/n_e), con K categorías, n predicciones del canary y n_e del estable, así que con muchas categorías también hace falta agrupar.
Ejemplo. Alba pide ≥ 10,000 requests por decisión para los 5xx (los errores del servidor): con p0 = 0.1 %, la falsa alarma por decisión baja de ≈ 6.4 % (3,480 requests) a ≈ 0.35 %. Para el PSI, ≥ 5,000 predicciones sobre ≈ 30 categorías padre.
Bake timebake timeEl tiempo que la versión anterior sigue prendida después de que la nueva llega al 100 %. Convierte el rollback en un cambio de ruteo.Más +
Algunos problemas solo aparecen con todo el tráfico o con el tiempo: una categoría chica que el canary vio poco, una fuga de memoria que tarda un día. Mientras dura el bake, volver es mandar el tráfico a algo prendido y caliente: el switch tarda segundos, y en Alba el camino completo (el PR del revert y Argo CD) unos minutos; después, hay que levantarlo otra vez (en Alba, ≈ 5–20 min para Triton). Con Argo Rollouts hay que pedirlo: el ReplicaSet viejo se apaga 30 s después de llegar al 100 % si no se cambia scaleDownDelaySeconds, y volver a él corre otra vez todos los pasos si no se configura rollbackWindow. Cuesta lo que cuesten las máquinas de la versión anterior durante esas horas. Es, en el fondo, un blue/green que se deja vivo después del canary.
Analogía. Como guardar la receta vieja en el refrigerador una semana después de cambiar el menú. Se rompe en que una receta guardada no cuesta nada; una T4 prendida cuesta cada hora.
Ejemplo. En Alba, la release 14 (su gateway y triton-v14) sigue viva 24–48 h: una T4 de más, ≈ US$13 por 24 h y ≈ US$25 por 48 h. Al terminar, un PR la quita.
Blue/greenblue/green deploymentTener dos entornos completos, el viejo (blue) y el nuevo (green), y un switch que manda todo el tráfico a uno o al otro de golpe.Más +
Volver es mover el switch: tan rápido como cambiar un ruteo. El costo es tener dos entornos prendidos mientras se decide. No da un porcentaje intermedio: el salto es de 0 a 100 %, así que no limita a cuántos les toca un error como lo hace un canary. Muchos sistemas combinan los dos: suben con canary y dejan el viejo vivo como blue durante el bake time. En Argo Rollouts, la estrategia blue/green apaga el viejo 30 s después del switch si no se cambia scaleDownDelaySeconds.
Ejemplo. Unas predicciones en lote que se recalculan cada noche: se escribe predicciones_v2 al lado de la tabla vieja, se comparan, y el cambio es mover el puntero que leen los demás.
Kill switchkill switchUn interruptor de la configuración (un feature flag) que apaga una función completa mientras el programa corre, sin desplegar nada. Es el rollback más rápido: apaga la función, no la versión.Más +
Sirve cuando el problema no es la versión nueva: si las dos versiones fallan porque algo de afuera cambió, volver a la anterior no arregla nada y apagar sí. Se prepara antes: el código tiene que saber qué hacer con la función apagada. Es un caso particular de feature flag.
Ejemplo. En Alba, apagar las sugerencias hace que Ana vea el selector de categorías normal, como si el modelo no existiera.
Runbook de rollbackrollback runbookLa receta escrita, paso a paso, de qué hace la persona de guardia cuando un despliegue sale mal: detectar, revertir sin diagnosticar, confirmar, congelar, comunicar e investigar.Más +
Se escribe con calma para usarse con prisa, por alguien que no hizo el cambio. Su regla central es «primero revertir, después investigar»: cada minuto buscando la causa es un minuto de tráfico con la versión mala. Dice cómo se revierte en cada fase y qué pasa si revertir no arregla nada (entonces el problema no era la versión). Un runbook que nunca se ensayó no es un plan: se practica en staging.
Ejemplo. El de Alba: la máquina detecta; Marta, de guardia, revierte en ≤ 5 min (en el canary ya se revirtió solo; en el bake, un revert en alba/despliegue); confirma en 15–30 min; congela los despliegues del modelo; avisa; investiga con el model_version de cada línea de log.
Expand and contractexpand and contractCambiar un contrato entre sistemas en tres pasos para no romper a nadie: primero los consumidores aprenden lo nuevo, después el productor lo produce, al final se borra lo viejo.Más +
Hace falta cuando dos versiones conviven (en un canary, en un bake) y sus consumidores no se actualizan al mismo tiempo. El orden es lo importante: nadie produce algo que su consumidor todavía no entiende. Se usa igual en bases de datos (agregar una columna, escribirla, dejar de leer la vieja) y en APIs. En modelos, ayuda que la API devuelva el nombre de la categoría y nunca su posición en la salida.
Ejemplo. Para pasar de 500 a 501 categorías con «bolsas»: el backend y la app aceptan el nombre nuevo; luego la release con el modelo de 501 sube sus peldaños de despliegue (shadow, canary), con una prueba A/B; al final se borra lo que solo servía para el de 500.
Chequeo
EsencialCheck
Intenta responder en tu cabeza antes de abrir cada respuesta.
1¿Qué pregunta responde el shadow, y cuál no puede responder?Ver respuesta
«¿Funciona con tráfico real?»: errores, latencia y cuánto cambió lo que contesta. No responde «¿ayuda?», porque nadie vio sus sugerencias.
2¿Por qué un rolling update no es un despliegue seguro de un modelo?Ver respuesta
Porque la readiness mide salud, no calidad, y porque no controla el porcentaje ni compara contra el estable.
3¿Por qué el canary se compara contra el estable en la misma ventana y no contra un umbral fijo?Ver respuesta
Porque las dos ven la misma mezcla de fotos al mismo tiempo: el ruido del día (una campaña, la madrugada) se cancela y queda la diferencia del modelo.
4¿Para qué sirve el n mínimo de un criterio?Ver respuesta
Para que el azar no dispare una regla con pocas requests. Sin él, de madrugada, 2 errores en 600 requests revierten una versión buena.
5¿Qué convierte el rollback en un cambio de ruteo?Ver respuesta
El bake: la release anterior sigue prendida 24 a 48 horas, con su Triton caliente. Volver es mandar el tráfico ahí: unos minutos (el PR del revert y Argo CD), en vez de ≈ 5–20 min levantando Triton.
6¿Quién mueve
championen Alba, y cuándo?Ver respuestaEl job
promoverdel pipeline, cuando el Rollout llega al 100 % sano. Si el canary se aborta, nunca se mueve.7¿Por qué la respuesta de la API trae el nombre de la categoría y no su posición?Ver respuesta
Porque la posición depende del orden de
labels.jsonde cada modelo. Con el nombre, un cambio de orden entre versiones no cambia lo que ven los clientes.