7 · La nubeLección 5 de 5
Servicios gestionados, serverless y permisos
Managed services, serverless and permissions
Cuánto de tu sistema opera el proveedor y cuánto tú, cuánto cuesta esa diferencia, cuándo conviene que algo se apague solo y cómo decide la nube quién puede tocar qué.
Secciones14
- 01Quién opera qué: el servicio gestionado
- 02Gestionado contra propio: cuatro preguntas y una cuenta
- 03Plataformas de ML y endpoints gestionados
- 04Inferencia asíncrona: requests grandes y respuestas en minutos extra
- 05Serverless: pagar solo lo que corre
- 06Escalar a cero, arranque en frío y autoscaling
- 07IAM: quién puede hacer qué
- 08La identidad de un programa: sin llaves guardadas
- 09Errores comunes
- 10En la vida real extra
- 11Ejercicios
- 12Lo que sigue
- 13Palabras que vas a oír
- 14Chequeo
¿Por qué Alba corre su modelo en sus propias máquinas y no en un servicio que lo opere por él, cuándo sí conviene pagarle a la nube para que se encargue, y cómo sabe S3 que un programa tiene permiso de leer los pesos del modelo?
En la lección de la nube viste que puedes rentar una máquina virtual por hora y que la nube ordena sus servicios en una escalera: máquinas que rentas, plataformas y productos (IaaS, PaaS y SaaS). En la de máquinas viste cuánto cuesta una g4dn.xlarge con su GPU T4: ≈ US$0.526 por hora en us-east-1 (noviembre de 2026), ≈ US$384 al mes.
Alba, la empresa que seguimos en todo el curso, es un marketplace: recibe ≈ 2.5 millones de publicaciones al día y le sugiere a quien vende la categoría de cada foto, entre 500 posibles. Corre su modelo en dos de esas máquinas, una por zona, dentro de Kubernetes, el sistema que reparte los programas entre un grupo de máquinas. Alguien tiene que instalar los drivers de la GPU, actualizar el sistema operativo, decidir cuántas copias del modelo correr y despertarse a las 3 de la mañana si una de esas máquinas se cae. AWS podría hacer casi todo eso por ti, y te cobraría más. ¿Vale la pena?
Esta lección responde tres preguntas. Primero, qué cambia cuando el proveedor opera una pieza y cuándo conviene pagarlo, con la cuenta completa. Segundo, qué es serverless, por qué ahorra tanto en unos casos y por qué en otros es lo más caro, y qué es el arranque en frío. Tercero, cómo decide la nube quién puede hacer qué: IAM (su sistema de permisos), roles, políticas y la identidad de un programa sin contraseñas guardadas.
Quién opera qué: el servicio gestionado
EsencialWho runs what: managed services
Un servicio gestionado (managed service) es uno donde el proveedor de la nube opera una parte de la pila por ti. La pila (stack) son las capas que hacen funcionar un servicio, de abajo hacia arriba: la máquina, el sistema operativo, los drivers, el programa que sirve el modelo y el modelo mismo. El proveedor opera algunas de esas capas: las instala, las actualiza, las repara, las escala y las vigila. Tú usas el resultado por su API y pagas por usarlo.
«Operar» es todo lo que hay que hacer para que algo siga funcionando después de instalarlo. Para el servidor de modelos de Alba, eso incluye:
- Actualizar el sistema operativo y los drivers de la GPU cuando sale un parche de seguridad (una corrección para un hueco por donde podrían atacarte).
- Cambiar una máquina que se descompuso.
- Agregar copias cuando sube el tráfico y quitarlas cuando baja.
- Mirar las alertas y contestar el teléfono cuando algo falla, de día o de noche.
Ninguna de esas tareas hace que el modelo sea mejor. Pero si nadie las hace, el sistema se cae.
La escalera de Alba
Para clasificar la foto de Ana hay cuatro maneras, de más a menos trabajo tuyo:
- Máquinas solas (EC2, el servicio de máquinas virtuales de AWS). Rentas instancias con GPU y haces todo lo demás: el sistema operativo, los drivers, el programa que sirve el modelo, cuántas copias correr y cómo repartir el tráfico.
- Kubernetes gestionado (EKS). Al grupo de máquinas que maneja Kubernetes se le llama cluster. AWS opera el «cerebro» del cluster, y tú operas las máquinas que hacen el trabajo (en su modo normal; EKS también tiene un modo, Auto Mode, en el que AWS opera también esas máquinas). Es lo que usa Alba.
- Un endpoint de una plataforma de ML (SageMaker AI). Un endpoint es una dirección a la que le mandas datos y te contesta la predicción. Le das el modelo y un contenedor; AWS prende las máquinas, las cambia si se caen y agrega copias. Tú no ves ninguna máquina.
- Un producto listo (como Textract, el servicio de AWS que lee el texto de un documento escaneado). Ni siquiera traes el modelo: mandas un documento y te regresa el texto. Pagas por página.
Cada escalón te quita trabajo y te quita control. En el primero puedes ajustar cualquier cosa; en el cuarto, solo lo que la API deja. Y cada escalón cobra más por unidad de trabajo: el proveedor te cobra su gente, su software y su margen dentro del precio.
El escalón de en medio: Kubernetes gestionado
Kubernetes es el orquestador de Alba: el sistema que decide en qué máquina corre cada copia de cada programa y que levanta otra si una se cae. Tiene dos partes.
El plano de control (control plane) es el cerebro. Guarda el estado deseado del cluster («quiero 2 copias de Triton y 2 del gateway») y unos programas comparan, sin parar, lo que hay contra lo que se pidió. Si falta una copia, mandan crearla. Todo lo que le pides a Kubernetes pasa por su API.
Los nodos son las máquinas que hacen el trabajo: ahí corren los pods, los grupos de contenedores de tus programas.
Operar un plano de control a mano es delicado: su base de datos guarda todo el cluster, y si se corrompe, Kubernetes ya no sabe qué debería existir. Por eso las tres nubes venden Kubernetes gestionado: EKS en AWS, GKE en Google Cloud y AKS en Azure. El proveedor opera el plano de control (EKS lo corre en varias zonas; en GKE y AKS depende del tipo de cluster que elijas); tú operas los grupos de nodos.
El segundo renglón es un castigo por no actualizar. Kubernetes saca versiones nuevas varias veces al año, y AWS da soporte normal a cada una por un tiempo. Si tu cluster se queda en una versión que ya salió de ese soporte, AWS cobra seis veces más por hora (0.60 ÷ 0.10) mientras no la actualices.
Ese último renglón es una trampa común. El SLA de EKS dice que el endpoint de la API de Kubernetes contesta el 99.95 % del tiempo. No dice nada de tus pods: si tu nodo con la T4 se queda sin memoria, o tu imagen trae un error, AWS cumplió su promesa y tu servicio está caído. La disponibilidad de Alba la sigues construyendo tú, con dos réplicas en dos zonas (N+1).
Gestionado contra propio: cuatro preguntas y una cuenta
EsencialManaged vs self-hosted: four questions and one calculation
La decisión de gestionado contra propio (managed vs self-hosted) aparece en cada diseño. Se resume en cuatro preguntas, en orden:
- ¿Quién lo opera? Si no hay un equipo que sepa operar GPUs, drivers y el autoscaling (agregar y quitar copias solas según el tráfico; lo verás más abajo), la respuesta suele ser gestionado, sin más cuentas.
- ¿Cuánto volumen y qué tamaño tiene cada request? Muchos GB o millones de llamadas al mes hacen que los cobros por unidad crezcan.
- ¿Qué tan especial es lo que corre? Alba compila su modelo con TensorRT, la herramienta de NVIDIA que lo optimiza para un modelo de GPU concreto; el resultado se llama engine. Un engine armado para una T4, o un servidor que junta requests en lotes a su manera (batching), pueden no caber en el contenedor que acepta la plataforma.
- ¿Qué tan rápido hay que salir, y qué piden los datos? Un prototipo para la próxima semana pide gestionado. Datos que no pueden salir de cierto país o región (residencia de datos) pueden prohibirlo.
La primera casi siempre gana: gestionado cobra más por unidad y te ahorra gente. Una persona de ingeniería en Estados Unidos cuesta del orden de US$10,000 al mes o más, contando sueldo y prestaciones; un cuarto de su tiempo son ≈ US$10,000 × ¼ = US$2,500 al mes, el número que usan las cuentas de abajo: si un servicio gestionado te ahorra un cuarto de su tiempo, puede costar más en la factura y salir más barato en total.
La cuenta del OCR: Textract contra uno propio
Toma un ejemplo fuera de Alba: un servicio de procesamiento de documentos que lee facturas, identificaciones, comprobantes de domicilio y estados de cuenta, y extrae sus campos. El primer paso es un OCR (optical character recognition, reconocimiento óptico de caracteres), un modelo que convierte la imagen de una página en texto. Puede usar Textract, el OCR gestionado de AWS, o servir uno propio. Supón que procesa 186,000 páginas al mes (supuesto del ejemplo).
Textract cobra US$1.50 por cada 1,000 páginas en el primer millón del mes y US$0.60 por cada 1,000 arriba de eso (noviembre de 2026). El OCR propio cuesta lo mismo cada mes, proceses las páginas que proceses: sus máquinas más la gente que lo opera. El punto de equilibrio es el número de páginas donde los dos cuestan lo mismo:
- donde
- x
- páginas al mes
- a
- lo que cobra Textract por 1,000 páginas en el primer millón del mes: US$1.50
- b
- lo que cobra por 1,000 páginas arriba del primer millón: US$0.60
- G
- lo que pagas a Textract al mes, en US$
- H
- las máquinas (el hardware) del OCR propio al mes, en US$ (dos GPUs: ≈ US$768)
- E
- la gente que opera el OCR propio al mes, en US$ (un cuarto de persona: ≈ US$2,500)
- P
- el OCR propio al mes, en US$
- x∗
- el punto de equilibrio, en páginas al mes
Si P es menor que lo que cuesta el primer millón (1,000×
El OCR propio solo gana por factura arriba de ≈ 512,000 páginas al mes, ≈ 2.75 veces el volumen del ejemplo (512,000 ÷ 186,000). Y en cuanto cuentas a la persona que lo opera, el punto de equilibrio se va a ≈ 3.9 millones de páginas. Además, con supuestos típicos para un servicio así, el OCR es ≈ 3 % de lo que cuesta todo el servicio; el sueldo del equipo es ≈ 80–90 %. Ahorrar en el 3 % complicando la vida del 80 % es mal negocio.
Para ir más hondoLa misma cuenta en Python+
Así se ve la tabla con unos cuantos volúmenes. Cópialo y córrelo:
def textract(paginas): # US$1.50 por 1,000 hasta 1 M; US$0.60 después
return min(paginas, 1_000_000) * 1.50 / 1000 + max(paginas - 1_000_000, 0) * 0.60 / 1000
def propio(personas): # 2 × g4dn.xlarge ≈ US$768 + la gente que lo opera
return 768 + personas
print(f"{'páginas/mes':>12} {'Textract':>9} {'propio sin gente':>17} {'propio + ¼ persona':>19}")
for paginas in (186_000, 512_000, 1_000_000, 2_000_000, 4_000_000):
print(f"{paginas:>12,} {textract(paginas):>9,.0f} {propio(0):>17,.0f} {propio(2_500):>19,.0f}") páginas/mes Textract propio sin gente propio + ¼ persona
186,000 279 768 3,268
512,000 768 768 3,268
1,000,000 1,500 768 3,268
2,000,000 2,100 768 3,268
4,000,000 3,300 768 3,268La columna del medio miente: nadie opera dos GPUs gratis. La última es la que se compara.
Compara el OCR gestionado, que cobra por página, contra dos GPUs propias más la gente que las opera. Aplica las ecuaciones de la lección: G=
Con la gente E en 0 y las máquinas H en 768, el equilibrio baja a ≈ 512,000 páginas: la factura sola engaña. Con E ≈ US$2,500, se va a ≈ 3.9 M.
Empieza con los valores del servicio de documentos: x = 186,000 páginas, H = 768 y E = 2,500. Baja la gente E a cero y mira cómo el punto de equilibrio x∗ baja a ≈ 512,000 páginas; súbela a una persona completa (≈ US$10,000) y mira cómo se aleja.
Y luego, lo que no está en la factura
Gestionado también cuesta fuera de la factura:
- Dependencia del proveedor (lock-in): un sistema escrito contra la API de Textract no se mueve a Google Cloud cambiando una línea.
- Límites: cada servicio pone topes de tamaño, de tiempo y de requests por segundo. El servicio de documentos del ejemplo tuvo que pedir un aumento de cuota de requests por segundo del OCR y programar reintentos con backoff.
- Menos visibilidad: cuando algo falla, ves los logs que el proveedor publica, no la máquina.
Y «equivalente» no es «idéntico»: la tabla de equivalencias de la lección de la nube junta servicios que se parecen, pero cada uno tiene sus límites. Cloud Run (de Google) y Fargate (de AWS) corren contenedores los dos, con topes distintos; Pub/Sub y Kafka son colas de mensajes los dos y no garantizan lo mismo.
Plataformas de ML y endpoints gestionados
EsencialManaged ML platforms and endpoints
Las tres nubes venden una plataforma de ML gestionada: Amazon SageMaker AI, Gemini Enterprise Agent Platform de Google Cloud (Agent Platform, para abreviar; antes Vertex AI) y Azure Machine Learning. Las tres venden lo mismo: entrenar, servir y registrar modelos sin operar servidores.
No son un solo producto, sino una caja de piezas. Nadie usa todas:
| Pieza | Qué resuelve | En SageMaker AI |
|---|---|---|
| Entrenamiento | Correr el entrenamiento en máquinas que se prenden y se apagan solas | Training jobs |
| Serving en tiempo real | Un modelo que contesta cada request en milisegundos | Real-time endpoints |
| Asíncrono | Requests grandes o lentas que contestan en minutos | Asynchronous Inference |
| Serverless | Pagar solo por request, sin GPU | Serverless Inference |
| Batch | Pasar un archivo enorme por el modelo de una vez | Batch Transform |
| Pipelines | Encadenar pasos: preparar datos, entrenar, evaluar | Pipelines |
| Registro | Guardar cada versión del modelo y quién la aprobó | Model Registry |
| Feature store | Guardar las features para entrenar y para servir | Feature Store |
| Monitoreo | Vigilar si los datos que llegan cambian | Model Monitor |
Agent Platform y Azure ML tienen casi todas las mismas piezas con otros nombres. El registro de modelos, el pipeline y el feature store los verás a fondo más adelante, en las lecciones de las 12 estaciones del sistema de Alba.
Para entrenar casi siempre conviene
Entrenar es un trabajo (job) que arranca y termina. Un job gestionado prende las máquinas, corre tu código, guarda el modelo en S3 (el almacén de objetos de AWS) y apaga las máquinas solo. Cobra por segundo. Si usas máquinas instancia spot (las sobrantes, con descuento, que te pueden quitar), el job guarda checkpoints y retoma donde se quedó.
El fine-tune mensual de Alba (volver a entrenar el modelo un poco con datos nuevos) tarda ≈ 3–4 horas en una GPU y cuesta ≈ US$3–4 por corrida como job gestionado (≈ US$10–50 al mes, con las de prueba). Nadie tiene que acordarse de apagar una GPU un viernes en la noche. Por eso Alba lo corre así: es la parte de las plataformas que casi siempre conviene.
El endpoint gestionado
Un endpoint gestionado (managed endpoint) es la pieza de serving: una dirección a la que mandas una request con los datos y te contesta la predicción. Detrás hay máquinas, pero no las ves. La plataforma las prende, las reparte por zona, las cambia si se caen, agrega copias según el tráfico y hace canaries: manda una parte chica del tráfico a la versión nueva del modelo para probarla antes de pasarle todo.
A cambio, la plataforma te pide tres cosas:
- Un sobreprecio por hora. Una
ml.g4dn.xlarge(la misma T4 dentro de SageMaker AI) cuesta ≈ US$0.736 por hora contra ≈ US$0.526 lag4dn.xlargenormal, en us-east-1 (noviembre de 2026): ≈ 40 % más. En CPU, ≈ 20 % más. - Un cobro por cada GB. SageMaker AI cobra ≈ US$0.016 por GB que entra al endpoint y por GB que sale (datos procesados). Azure ML es la excepción: no cobra un extra propio por la plataforma; pagas las máquinas y los demás servicios que use, como el almacenamiento y el registro de imágenes.
- Un contrato. Tu contenedor escucha en el puerto 8080 y contesta
POST /invocations(la predicción) yGET /ping(si está vivo), acepta conexiones en 250 ms y responde en 60 s. El cuerpo de cada request, el payload (los datos que mandas), mide como máximo 6 MiB (6,291,456 bytes).
El gateway de Alba ya escucha en el 8080, pero sus rutas (las direcciones dentro del servidor) son /v1/classify, /healthz y /readyz. Habría que agregar dos rutas. Y algunas fotos de las publicaciones pesan hasta 10 MB: no caben en 6 MiB tal cual. Nada de esto es difícil. Es el tipo de detalle que convierte «lo subo a SageMaker AI» en una semana de trabajo que nadie estimó.
La cuenta de Alba en un endpoint gestionado
Alba recibe ≈ 10 millones de fotos al día, una por request. Para costos, un mes son 30.4 días (730 h ÷ 24): 10 M × 30.4 ≈ 304 millones de requests al mes. El gateway es el servicio de Alba que recibe la foto, la revisa y la prepara para el modelo. Para no castigar al lado gestionado, la cuenta supone que el gateway manda la imagen ya preparada: un tensor de 3 × 224 × 224 enteros de un byte (UINT8), 150,528 bytes por request. Alba hoy manda FP32 (602 KB); UINT8 es lo que haría al crecer.
Hay un cobro más. El gateway vive en tu red privada de la nube (VPC). Para llegar a SageMaker AI sin salir a internet, el tensor viaja por un camino privado, un endpoint de interfaz, que también cobra por GB.
Los cobros por GB se calculan igual: cuántos GB pasan al mes, por el precio de cada GB.
- donde
- R
- requests al mes: ≈ 304 M
- t
- el tamaño de cada request, en GB (150,528 bytes = 0.000150528 GB)
- V
- GB que pasan al mes por el servicio
- k
- lo que cobra el servicio por GB, en US$ (datos procesados: US$0.016; endpoint de interfaz: US$0.01)
- c
- el cobro al mes, en US$
Fíjate de dónde sale la diferencia: el sobreprecio de las máquinas son ≈ US$307 al mes (1,075 − 768). Los dos cobros por GB, ≈ US$1,212 (737 + 475). Con imágenes, lo que pesa es lo que se cobra por byte. En los ejercicios verás que con FP32 solo la entrada costaría ≈ US$2,929.
- Backend · de publicaciones
El servicio del marketplace que llama al clasificador de Alba con la foto de Ana. No cambia nada para él: sigue llamando a la misma dirección. - ALB · la puerta
El balanceador de carga de entrada. Verifica el token firmado que prueba que quien llama es el backend, y solo entonces deja pasar la request. - Gateway · foto → tensor
Lo sigues operando tú, en tus máquinas. Decodifica la foto y la convierte en un tensor de 3 × 224 × 224 enteros de un byte: 150,528 bytes por request. - Endpoint de interfaz · camino privado
Para llegar a SageMaker AI sin salir a internet, la VPC usa un endpoint de interfaz. Cobra ≈ US$0.01 por GB más su hora en cada zona: ≈ US$475 al mes para Alba. - Endpoint · POST /invocations
El endpoint gestionado: una dirección y nada más. Acepta cuerpos de hasta 6 MiB y espera la respuesta 60 s. Cobra ≈ US$0.016 por cada GB que entra y que sale. - 2 × ml.g4dn · una T4 por zona
Las mismas T4, ≈ 40 % más caras por hora: ≈ US$0.736 contra ≈ US$0.526. No puedes entrar a ellas ni corrernvidia-smi; AWS las cambia si se caen. - S3 · model.tar.gz
Los pesos y la configuración de Triton, empacados en un archivo comprimido que la plataforma baja cada vez que prende una máquina. - CloudWatch · logs y métricas
El servicio de AWS que guarda logs y métricas. Es lo único que ves de las máquinas: los logs y las métricas que publica la plataforma. Depurar un arranque lento desde aquí es más difícil que en tu cluster. - Cobro por GB · ≈ US$737 al mes
Datos procesados: (45,760 GB de entrada + ≈ 304 GB de respuestas) × US$0.016 ≈ US$737 al mes. Crece con cada request: con el tensor en FP32 serían ≈ US$2.9k.
¿Entonces SageMaker AI está mal para Alba? No por sí solo. La diferencia es de ≈ US$1.5k al mes (3.3k − 1.8k). Para un equipo chico, sin nadie que sepa Kubernetes, eso es una fracción de lo que costaría una persona operando EKS (del orden de US$10,000 al mes). Dicho directo: sin una plataforma de Kubernetes y con un equipo chico, SageMaker AI sería la respuesta práctica. Alba corre su propio Triton porque ya opera EKS (la primera pregunta) y porque su payload es grande (la segunda).
Para ir más hondoLos descuentos también son otros+
Los Savings Plans de EC2, los descuentos por comprometer un gasto por hora durante uno o tres años que viste en la lección de máquinas, no aplican a las máquinas ml.*. SageMaker AI tiene sus propios Savings Plans, que AWS anuncia con descuentos «de hasta 64 %». Si mueves un modelo de EKS a SageMaker AI, el compromiso que ya firmaste para EC2 no te sigue.
Inferencia asíncrona: requests grandes y respuestas en minutos
ExtraAsynchronous inference
Hay modelos que no caben en el contrato de un endpoint de tiempo real: el archivo pesa cientos de MB, o la predicción tarda 10 minutos. Un ejemplo fuera de Alba: un servicio de segmentación de imágenes médicas que analiza láminas de microscopio enteras. Cada archivo pesa ≈ 1 GB (algunos, 3 GB) y su promesa (SLO) es entregar el resultado en 60 minutos.
Para eso existe la inferencia asíncrona gestionada (asynchronous inference). En SageMaker AI funciona así:
- 1
Subes el archivo
Lo pones en un bucket de S3, no en el cuerpo de la request. Puede pesar hasta 1 GB.
- 2
Pides la predicción
Llamas al endpoint con la dirección del archivo. Te contesta de inmediato con un número de trabajo y la dirección donde quedará el resultado.
- 3
La plataforma lo pone en una fila
Si las máquinas están ocupadas, el trabajo espera en una cola interna. Cada uno puede tardar hasta 1 hora.
- 4
El resultado aparece en S3
Cuando termina, escribe la respuesta en S3 y, si lo pediste, te avisa con una notificación.
Lo mejor: cuando la cola está vacía, el endpoint puede bajar a 0 máquinas, y no pagas GPU. Cuando llega un trabajo, prende una. Esa primera tarda minutos, pero con un SLO de 60 minutos no importa. Para el servicio de láminas, un arranque en frío de 3 a 5 minutos no es problema con un SLO de 60 minutos; en un servicio síncrono, donde alguien espera la respuesta con la conexión abierta, sería inaceptable.
Agent Platform y Azure ML no tienen un modo asíncrono equivalente: ahí se arma con una cola y workers, o con su modo batch. Ese patrón, cola más workers que escalan a cero, es justo el que el servicio de láminas corre en su propio cluster. Y le conviene: sus láminas de ≈ 1 GB quedan en el límite de la asíncrona de SageMaker AI, y las de 3 GB no caben.
El primo: batch
Si no hay requests sueltas sino un archivo enorme, como «clasifica las 200 millones de fotos del catálogo», la pieza es batch (Batch Transform en SageMaker AI). Le das la carpeta de S3 con las entradas; la plataforma prende las máquinas, reparte los archivos, escribe los resultados en otra carpeta y apaga todo al terminar. Es un job, como el entrenamiento: no hay endpoint esperando.
La diferencia con la asíncrona es quién manda el trabajo. En la asíncrona llegan trabajos sueltos a lo largo del día, y el endpoint vive (a veces con cero máquinas) esperando el siguiente. En batch, tú decides cuándo empieza y todo el trabajo existe desde el principio. El backfill del catálogo de Alba (reclasificar sus ≈ 200 millones de fotos viejas con el modelo nuevo) es batch; los estudios que llegan de uno en uno a un hospital son asíncronos.
Serverless: pagar solo lo que corre
EsencialServerless: pay only for what runs
Serverless quiere decir «sin servidores»… que no es cierto: sí hay servidores, pero no los ves, no los eliges y no pagas cuando no hacen nada. Tiene dos rasgos:
- Pagas por uso: por segundo de ejecución o por request, no por hora de máquina prendida.
- El proveedor escala por ti, de cero a cientos de copias y de regreso, a veces hasta cero.
Es el extremo del pago por uso que viste en la lección de la nube. Hay dos formas.
Funciones: el código suelto
Una función serverless es un pedazo de código que el proveedor corre cada vez que llega un evento: una request, un archivo nuevo en S3, un mensaje en una cola. La más conocida es AWS Lambda. Escribes una función de Python, la subes y AWS la corre cuando hace falta.
Sus límites deciden para qué sirve:
| Límite de Lambda | Valor | Qué quiere decir para ML |
|---|---|---|
| GPU | No tiene | Solo modelos que corren bien en CPU |
| Memoria | Hasta 10,240 MB | Modelos chicos |
| Tiempo por llamada | 15 min | Nada de entrenamientos largos |
| Imagen de contenedor | Hasta 10 GB sin comprimir | Cabe un modelo mediano con sus bibliotecas |
| Payload de una llamada síncrona (la que espera su respuesta) | 6 MB | Las fotos de hasta 10 MB que acepta Alba no caben |
Lambda es buenísima para el pegamento: redimensionar una foto cuando llega a S3, mandar una notificación, validar un archivo. No es para servir una ResNet-50 en GPU.
Contenedores: la imagen completa, y ahora con GPU
Un contenedor serverless corre tu imagen de contenedor completa, con un servidor web adentro, y el proveedor la escala según las requests. Los principales son Cloud Run de Google Cloud y Azure Container Apps. Y estos sí tienen GPU:
| Servicio | GPU | Detalles | ¿Baja a cero? |
|---|---|---|---|
| Google Cloud Run | L4 (24 GB) y RTX PRO 6000 (96 GB), una por instancia | Regiones limitadas; con L4, mínimo 4 vCPU y 16 GiB | Sí |
| Azure Container Apps | T4 y A100, una por réplica | Cuota y regiones limitadas | Sí |
| SageMaker Serverless Inference | No | 1–6 GB de memoria, payload de 4 MB | Sí |
Tener GPU no basta. Son dos preguntas separadas: ¿tiene la GPU que necesito? ¿Y el modo de cobrar y de arrancar encaja con mi tráfico?
La cuenta: horas de GPU al día
Una L4 en Cloud Run cuesta ≈ US$1.05 por hora prendida: ≈ US$0.67 de la GPU más ≈ US$0.37 de los 4 vCPU y 16 GiB que pide como mínimo. Ese precio es de us-central1 y sin redundancia zonal. La redundancia zonal aparta capacidad en otra zona para que tu servicio se mueva ahí si la suya falla; viene prendida por omisión, y con ella la hora sube a ≈ US$1.42.
La misma L4 en una máquina dedicada (g6.xlarge) cuesta ≈ US$0.805 por hora en us-east-1 (noviembre de 2026), pero la pagas las 24 horas. Son regiones distintas, así que la comparación es aproximada: Cloud Run cobra ≈ 30 % más por hora, y solo las horas que la instancia está prendida.
Ojo con «prendida»: Cloud Run con GPU cobra toda la vida de la instancia, y después de la última request la deja esperando hasta ≈ 10 minutos por si llega otra. Si las 20,000 imágenes de abajo llegan regadas en el día, la GPU queda prendida muchas más horas que las 2 de trabajo (el juguete de Python de más abajo lo muestra). Por eso, de aquí en adelante, «horas activas» quiere decir horas con la instancia prendida, y la cuenta supone que el trabajo llega junto, en lotes.
- donde
- h
- horas activas al día (con la instancia prendida)
- s
- lo que cobra serverless por hora activa, en US$ (L4 en Cloud Run: ≈ 1.05)
- d
- lo que cobra la máquina dedicada por hora, en US$ (
g6.xlarge: ≈ 0.805) - Cs
- serverless al mes, en US$; un mes son 730 h ÷ 24 ≈ 30.4 días
- Cd
- la dedicada al mes, en US$: se pagan las 730 horas, la uses o no
- h∗
- el cruce, las horas activas al día en que Cs=
Cd . Sale de igualar las dos: s×h× , y 730 ÷ 30.4 = 2430.4= d× 730
Alba está en el otro extremo: su tráfico nunca baja de decenas de requests por segundo, ni de noche, así que su GPU trabaja las 24 horas. Una instancia de Cloud Run siempre prendida costaría Cs = 1.05 × 24 × 30.4 ≈ US$766 al mes, ≈ 30 % más que la misma L4 dedicada (≈ US$588). En una entrevista de diseño, esto distingue a alguien con experiencia (senior): saber que el perfil de carga (horas de GPU al día) decide el costo. Para Alba, serverless pierde esa cuenta.
Un contenedor serverless cobra solo las horas que está prendido (también los minutos que espera después de la última request), pero más caro por hora; la GPU dedicada cobra las 24 horas. Aplica las ecuaciones de la lección: Cs=
Pon una instancia mínima: el arranque en frío desaparece, pero pagas las 24 horas a precio de serverless, más que la dedicada.
Empieza con la herramienta de moderación: h = 2 horas al día. Sube h hasta que serverless cueste lo mismo que la dedicada: pasa en h∗ ≈ 18.4.
Escalar a cero, arranque en frío y autoscaling
EsencialScale to zero, cold starts and autoscaling
La otra pregunta de serverless es la de la primera request: ¿cuánto espera si no hay ninguna copia lista? Para entenderla hacen falta tres ideas.
Autoscaling: dos lazos de distinta velocidad
El autoscaling es ajustar solo cuánta capacidad corre según la carga. Funciona como un lazo de control, igual que un termostato: mide, compara con una meta y corrige, una y otra vez. En Kubernetes son dos lazos, uno dentro del otro:
- Réplicas, en segundos. Una regla mira una métrica (uso de GPU, requests por segundo, mensajes en una cola) y agrega o quita copias del programa. En Kubernetes lo hace el HPA (Horizontal Pod Autoscaler, el que ya trae Kubernetes) o KEDA (uno que escala con eventos, como los mensajes que esperan en una cola).
- Nodos, en minutos. Si una copia nueva no cabe en ninguna máquina, otro programa pide una máquina nueva a la nube. En AWS, ese programa suele ser Karpenter o el Cluster Autoscaler.
La regla corta: los pods no escalan más allá de los nodos que existen. Si hay una T4 libre, la copia nueva de Triton arranca en segundos. Si no, espera la máquina.
La mecánica fina (las métricas, cuánto esperar antes de quitar copias) la ves en la lección «Kubernetes». Aquí basta con la diferencia de velocidad.
El arranque en frío
El arranque en frío (cold start) es el tiempo desde que el sistema decide agregar una copia hasta que esa copia contesta su primera request. Ya lo viste con los pesos de un LLM en la lección de memoria. Para el Triton de Alba, cuando no hay nodo libre, el equipo de Alba lo estima así, etapa por etapa:
Un pico de tráfico dura segundos. El autoscaling tarda minutos. Por eso el autoscaling no absorbe picos de segundos: para eso está la capacidad de sobra que ya corre (el headroom). Alba diseña su sistema para un pico de 500 requests por segundo. Si en ese pico tarda 13 minutos en tener una copia más, pasan 500 req/s × 60 s por minuto × 13 min = 390,000 requests antes de que llegue la ayuda.
Escalar a cero
Escalar a cero (scale to zero) es dejar que el número de copias baje hasta 0 cuando no hay trabajo. Ahorra la GPU completa durante las horas sin tráfico. El precio: la siguiente request paga un arranque en frío entero.
¿Cuándo conviene? Cuando nadie espera la respuesta en segundos. Los workers del backfill de Alba, que reclasifican el catálogo viejo desde una cola, pueden bajar a cero. El servicio de láminas de microscopio baja a cero su capa de GPU (en inglés, tier): la capa de GPU es desechable y escala a cero; los resultados son durables. El Triton online de Alba nunca baja a cero: su promesa es un p99 de 200 ms o menos, y un arranque de segundos a minutos no cabe.
Para ir más hondoUn día con escala a cero, en Python+
El juguete de abajo simula un día de una herramienta interna con escala a cero. El servicio guarda la copia prendida unos minutos después de cada request, por si llega otra; si no llega, la apaga. Mira qué pasa con distintos tiempos de espera:
import random
random.seed(7)
# Una herramienta interna: 400 requests entre las 9:00 y las 18:00, y 6 de madrugada
llegadas = sorted([random.uniform(9*60, 18*60) for _ in range(400)] +
[random.uniform(0, 6*60) for _ in range(6)]) # en minutos del día
def un_dia(espera_min): # minutos que la instancia sigue prendida sin trabajo
frios, prendida, apagada_en = 0, 0.0, -1.0
for t in llegadas:
if t > apagada_en: # ya se había apagado: arranque en frío
frios += 1
prendida += espera_min # vive hasta 'espera_min' después de esta request
else:
prendida += t + espera_min - apagada_en # alarga su vida
apagada_en = t + espera_min
return frios, prendida / 60
for espera in (1, 5, 15, 60):
frios, horas = un_dia(espera)
print(f"espera {espera:>2} min: {frios:>3} arranques en frío, {horas:4.1f} h prendida, "
f"≈ US${horas * 1.05:5.2f} al día")
print(f"dedicada 24 h: ≈ US${24 * 0.8048:5.2f} al día")espera 1 min: 200 arranques en frío, 4.8 h prendida, ≈ US$ 5.07 al día
espera 5 min: 15 arranques en frío, 9.3 h prendida, ≈ US$ 9.79 al día
espera 15 min: 6 arranques en frío, 10.5 h prendida, ≈ US$11.04 al día
espera 60 min: 3 arranques en frío, 13.6 h prendida, ≈ US$14.33 al día
dedicada 24 h: ≈ US$19.32 al díaEsperar poco ahorra horas pero multiplica los arranques en frío: con 1 minuto, la mitad de las requests encuentra la máquina apagada. Esperar mucho casi los elimina, y se acerca al costo de la dedicada. Es el mismo trueque de siempre, en un número. El modelo es de juguete: los proveedores reales cobran el tiempo prendido de distintas maneras, y aquí no se cobra el arranque mismo.
Para ir más hondoKEDA y el número que no escribiste+
KEDA, el autoscaler de Kubernetes que escala con la longitud de una cola, tiene minReplicaCount en 0 por omisión. Si lo usas para un servicio online y no escribes ese número, tu servicio puede bajar a cero sin que nadie lo decida. En el servicio de láminas, los workers van de 0 a 4 con una meta de m = 15 mensajes por worker. KEDA calcula w=
IAM: quién puede hacer qué
EsencialIAM: who can do what
Hasta aquí, las piezas: máquinas, endpoints, funciones, buckets. Todas viven en tu cuenta de la nube, y cada vez que algo hace una llamada a la API (leer un archivo de S3, prender una máquina, invocar un endpoint) la nube tiene que decidir: ¿esto se permite?
En Linux, los permisos dicen qué usuario puede leer qué archivo. En la nube, eso lo hace IAM (Identity and Access Management, gestión de identidad y acceso): el sistema que decide quién puede hacer qué acción sobre qué recurso. Toda la nube pasa por él: también la consola donde das clic y los servicios gestionados que llaman a otros servicios.
Son dos preguntas distintas que se confunden siempre:
- Autenticación: ¿quién eres? Se demuestra con algo que tienes: una contraseña, una llave o un token firmado (un texto con una firma digital que prueba quién lo emitió y que nadie lo cambió).
- Autorización: ¿qué puedes hacer? Se decide con reglas escritas.
IAM hace las dos para todo lo que pasa dentro de la nube. Cómo se identifica un cliente de fuera ante tu API (JWT, API keys) es de la fase de seguridad.
La política: el documento que dice qué se puede
Una política de permisos (policy) es un documento con reglas. Cada regla tiene tres partes: un efecto (Allow o Deny), unas acciones (como s3:GetObject, «leer un objeto de S3») y unos recursos (qué bucket, qué prefijo). En AWS se escribe en JSON. Esta es una ilustración, la política del Triton de Alba (los nombres de bucket son inventados):
{
"Version": "2012-10-17",
"Statement": [
{ "Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::alba-artefactos/triton/*" },
{ "Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::alba-artefactos",
"Condition": { "StringLike": { "s3:prefix": "triton/*" } } }
]
}Se lee así: Triton puede leer objetos cuya llave (su nombre dentro del bucket) empieza con triton/ en el bucket alba-artefactos, y listar solo ese prefijo. Un prefijo es el principio del nombre: funciona como una carpeta. No puede escribir, ni borrar, ni ver otro bucket. El arn:aws:s3:::… es un ARN (Amazon Resource Name): el nombre completo y único de un recurso en AWS. Y la Version es la versión del lenguaje de políticas, no una fecha que tú elijas.
Para decidir, AWS sigue tres reglas, en este orden:
- Por omisión, todo se niega. Si ninguna regla lo permite, no se puede.
- Un
Allowlo permite, si la acción y el recurso coinciden. - Un
Denyexplícito gana siempre, aunque otra regla digaAllow.
(Hay más capas, como reglas de toda la organización y políticas del propio bucket, pero estas tres son el corazón.)
Para ir más hondoLas otras capas que también deciden+
Una request a S3 no la decide solo la política del rol. En AWS pueden opinar más documentos, y la regla del Deny vale en todos:
- La política del bucket (bucket policy), pegada al recurso y no a quien llama. Sirve, por ejemplo, para negar todo lo que no llegue por el camino privado de la VPC, o para dejar entrar a un rol de otra cuenta.
- Las reglas de la organización (SCP, service control policies). Una empresa con muchas cuentas pone topes que ningún rol de adentro puede pasar, como «nadie crea máquinas fuera de us-east-1».
- Los límites de permisos (permissions boundaries): un techo para los roles que crean otros equipos.
Para que algo se permita, ninguna capa puede negarlo y la que corresponde tiene que permitirlo. Por eso, cuando un permiso «está bien escrito y no funciona», el problema suele estar en otra capa. Las herramientas de la nube que simulan una política te dicen cuál negó.
El rol: un conjunto de permisos que se presta
Un rol de IAM (IAM role) es una identidad con políticas pegadas, que no pertenece a nadie en particular: se asume. Quien lo asume recibe sus permisos por un rato. Un usuario es una persona con su contraseña; un rol es un gafete que se presta y se devuelve.
El servicio de documentos del OCR tiene un rol por componente. La API de documentos (docs-api) escribe los originales y no lee los resultados. El worker (doc-worker) lee los originales, escribe los resultados y, por si alguien le agrega un permiso de más, tiene un Deny explícito para escribir en los originales. El peligro es lo contrario: un rol con s3:* («todas las acciones de S3») sobre * («todos los recursos») puede borrar cualquier cosa.
Para ir más hondoLas tres reglas en Python+
Así se ven las tres reglas con un evaluador de juguete y los roles del servicio de documentos. Cópialo y córrelo:
from fnmatch import fnmatch
politicas = { # rol → lista de (efecto, acción, recurso); * vale «cualquier cosa»
"docs-api": [("Allow", "s3:PutObject", "docs/raw/*")],
"doc-worker": [("Allow", "s3:GetObject", "docs/raw/*"),
("Allow", "s3:PutObject", "docs/derivados/*"),
("Deny", "s3:PutObject", "docs/raw/*")],
"rol-de-todo": [("Allow", "s3:*", "*")],
}
def decide(rol, accion, recurso):
efectos = [e for e, a, r in politicas[rol] if fnmatch(accion, a) and fnmatch(recurso, r)]
if "Deny" in efectos: return "DENEGADO (un Deny explícito gana)"
if "Allow" in efectos: return "permitido"
return "DENEGADO (nadie lo permitió)"
for rol, accion, recurso in [("docs-api", "s3:PutObject", "docs/raw/f-881.pdf"),
("docs-api", "s3:GetObject", "docs/derivados/f-881.json"),
("doc-worker", "s3:GetObject", "docs/raw/f-881.pdf"),
("doc-worker", "s3:PutObject", "docs/raw/f-881.pdf"),
("rol-de-todo", "s3:DeleteObject", "docs/raw/f-881.pdf")]:
print(f"{rol:<11} {accion:<16} {recurso:<26} → {decide(rol, accion, recurso)}")docs-api s3:PutObject docs/raw/f-881.pdf → permitido
docs-api s3:GetObject docs/derivados/f-881.json → DENEGADO (nadie lo permitió)
doc-worker s3:GetObject docs/raw/f-881.pdf → permitido
doc-worker s3:PutObject docs/raw/f-881.pdf → DENEGADO (un Deny explícito gana)
rol-de-todo s3:DeleteObject docs/raw/f-881.pdf → permitidoCada renglón aplica las tres reglas en orden. En el cuarto decide el Deny; el último es el rol para todo, que deja hasta borrar.
Mínimo privilegio
Mínimo privilegio (least privilege) es la regla de dar a cada componente solo los permisos que necesita, sobre solo los recursos que necesita. No evita que te ataquen: limita el daño cuando pasa.
Piensa en un pod comprometido: alguien encontró una falla de seguridad en una biblioteca y ya corre su código adentro. Si todos los pods usan el mismo rol, o el rol de la máquina (el que tiene el nodo mismo y que puede usar cualquier pod que corra en él), con s3:* sobre *, el atacante hereda todos los buckets de la cuenta: las fotos, los logs y cualquier otro que guarde datos personales. Si cada componente tiene su rol acotado por prefijo, solo ve lo que ese pod veía.
¿Cuánto cuesta hacerlo bien? Poco: un rol por componente, acotado por prefijo, cuesta una tarde de infraestructura como código. La infraestructura como código (IaC) es escribir los recursos de la nube, roles incluidos, en archivos que viven en Git, con herramientas como Terraform. Así los permisos se revisan como cualquier cambio de código.
La identidad de un programa: sin llaves guardadas
EsencialA program's identity: no stored keys
Ya sabes qué permisos tiene el rol de Triton. Falta lo más delicado: ¿cómo demuestra el pod de Triton, al llamar a S3, que es Triton?
La cuenta de servicio
Una persona entra con su usuario. Un programa no debería usar el usuario de una persona: si Ana se va de la empresa y se borra su usuario, el servicio se cae; y si el programa se compromete, el atacante actúa como Ana. Un programa tiene su propia identidad: una cuenta de servicio (service account).
En Kubernetes, una cuenta de servicio es un objeto con nombre, como triton en el namespace classifier (la carpeta de Kubernetes que agrupa los objetos de un equipo, como viste en la lección de configuración). Cada pod corre con una, y Kubernetes le da al pod un token firmado que dice «soy classifier/triton». En Google Cloud también se llaman cuentas de servicio; en AWS, ese papel lo hace un rol.
La llave que caduca sola
La forma ingenua de darle permisos a Triton es crear una llave de acceso (un identificador y una clave secreta que no caducan) y meterla en un Secret. Funciona. Pero esa llave es una credencial estática: vale hasta que alguien la borre. Si se filtra, por un log, por un repositorio o por una laptop robada, sirve meses después, desde cualquier lugar.
Las credenciales temporales (temporary credentials) son lo contrario. AWS las entrega, con su servicio STS (Security Token Service), a quien asume un rol, y caducan solas, normalmente en una hora. El programa pide unas nuevas antes de que venzan, sin que nadie haga nada. Si alguien se roba unas, le sirven minutos.
En la lección de configuración viste la escalera de dónde guardar un secreto, de peor a mejor: en la imagen o en el repositorio (nunca), en una variable de entorno (aceptable), en un archivo que llega de un gestor de secretos (bueno) y, en el escalón más alto, no tenerlo: la mejor forma de manejar un secreto es no tenerlo. Este es ese escalón.
La identidad del workload: IRSA y Pod Identity
La identidad del workload (workload identity) conecta las dos ideas: la cuenta de servicio del pod se cambia por credenciales temporales de un rol de IAM. Nadie guarda ninguna llave. En EKS hay dos formas, IRSA (IAM Roles for Service Accounts) y la más nueva, EKS Pod Identity. En Google Cloud se llama Workload Identity Federation; en Azure, Entra Workload ID. Todas hacen lo mismo:
- Pod de Triton · con el SDK de AWS
No trae ninguna llave en su imagen, ni en variables de entorno, ni en un Secret. Solo sabe con qué cuenta de servicio corre. - Cuenta de servicio · classifier/triton
La identidad del programa dentro de Kubernetes. Kubernetes monta en el pod un token firmado que dice «soy classifier/triton», y lo renueva antes de que venza. - Emisor OIDC · del cluster
OIDC (OpenID Connect) es un estándar para que un sistema le demuestre a otro quién es con un token firmado. El cluster firma los tokens de sus cuentas de servicio. AWS tiene registrado este emisor y puede revisar la firma: así sabe que el token no es falso. - STS · da credenciales
STS (Security Token Service) es el servicio de AWS que cambia una prueba de identidad por credenciales temporales de un rol. Caducan solas, normalmente en una hora. - Rol alba-triton · confianza + política
Su política de confianza dice quién puede asumirlo: solo tokens declassifier/tritonde este cluster. Su política de permisos dice qué puede hacer: leertriton/*. - S3 · alba-artefactos
En cadaGetObject, IAM revisa que las credenciales sean válidas y que la política del rol permita leer esa llave. Si no, 403. - Alguien de fuera · con credenciales robadas
Copió las credenciales de un log. Le sirven solo hasta que vencen, y solo para lo que el rol permite.
Con IRSA, la cuenta de servicio lleva escrito qué rol de IAM le toca. Y del lado de AWS, el rol alba-triton tiene una segunda política, la política de confianza (trust policy). No dice qué puede hacer el rol, sino quién puede asumirlo: solo los tokens de la cuenta de servicio classifier/triton de ese cluster. Un pod de otro namespace, con otra cuenta de servicio, no puede asumirlo aunque conozca el nombre del rol.
Para ir más hondoCómo se escribe con IRSA+
La conexión se declara en la cuenta de servicio con una anotación, una nota de texto pegada al objeto. Una ilustración en YAML (el número de cuenta es inventado):
apiVersion: v1
kind: ServiceAccount
metadata:
name: triton
namespace: classifier
annotations:
eks.amazonaws.com/role-arn: arn:aws:iam::111122223333:role/alba-tritonLa última línea dice qué rol usa. La política de confianza del rol, del lado de AWS, cierra el círculo: nombra a classifier/triton como el único que puede asumirlo.
En el código de Triton o del gateway no cambia nada: el SDK de AWS (la biblioteca que usa el programa para hablarle a la nube) encuentra las credenciales solo y las renueva solo.
Para ir más hondoIRSA contra Pod Identity+
Las dos llegan al mismo lugar por caminos distintos. Con IRSA, el cluster tiene su propio emisor de tokens, que hay que registrar en IAM, y cada rol escribe en su política de confianza qué cuenta de servicio de qué cluster lo puede asumir. Si tienes diez clusters, cada rol tiene que nombrar a los diez.
Con EKS Pod Identity, la conexión se declara del lado de EKS: «la cuenta de servicio classifier/triton de este cluster usa el rol alba-triton». Un agente que corre en cada nodo entrega las credenciales al pod. El rol solo dice que confía en el servicio de Pod Identity, y el mismo rol sirve en varios clusters sin cambiarlo.
Para quien escribe el programa, da igual: el SDK encuentra las credenciales en los dos casos. La diferencia es para quien administra los permisos.
Para ir más hondoCuando sí hace falta un secreto+
La identidad del workload funciona para hablar con la propia nube: S3, SageMaker AI, un gestor de secretos. Para la contraseña de una base de datos de otro proveedor, o la API key de un servicio externo, sigue haciendo falta un secreto. Entonces el pod usa su identidad para leer ese secreto de un gestor de secretos: AWS Secrets Manager cobra ≈ US$0.40 por secreto al mes más US$0.05 por cada 10,000 lecturas (noviembre de 2026). Diez secretos, ≈ US$4 al mes, más las lecturas. El secreto vive en un solo lugar, se rota ahí, y cada lectura queda registrada.
La misma idea llega más allá de Kubernetes. Un job de CI que hace deploy en la nube puede recibir credenciales de corta vida por OIDC, un estándar para que un sistema le demuestre a otro quién es con un token firmado, en vez de guardar una llave de AWS en la configuración del repositorio. La idea, en tres palabras: sin llaves guardadas.
Errores comunes
EsencialCommon mistakes
1. Comparar solo el precio por hora
«SageMaker AI cuesta 40 % más por hora, así que es 40 % más caro.» En Alba, el sobreprecio de las máquinas son ≈ US$307 al mes (1,075 − 768); los cobros por GB, ≈ US$1,212 (737 de datos procesados + 475 del endpoint de interfaz).
Cómo evitarlo: sumar todas las líneas: máquinas, datos procesados, el camino privado de red, y el costo de la gente que lo opera en cada lado.
2. Olvidar quién lo va a operar
Elegir el lado propio porque la factura es menor, en un equipo chico, sin nadie que sepa Kubernetes. O elegir gestionado en una empresa que ya tiene un equipo de plataforma que opera EKS para todos.
Cómo evitarlo: contestar primero la pregunta «¿quién lo opera?», con nombres. Si nadie, gestionado.
3. Usar escala a cero en un servicio con latencia estricta
Poner el modelo online en Cloud Run con mínimo 0 instancias, o dejar KEDA con su minReplicaCount por omisión, que es 0. La primera request de la mañana espera segundos o minutos.
Cómo evitarlo: escala a cero solo donde el SLO es de minutos (backfill, colas, herramientas internas). En lo online, un mínimo explícito de réplicas, escrito en el manifiesto (el archivo que describe el servicio).
4. Confiar en el autoscaling para los picos
«El autoscaling llega a 20 réplicas, aguantamos cualquier pico.» Con nodos de GPU, una réplica nueva tarda ≈ 5–13 minutos; el pico ya pasó.
Cómo evitarlo: capacidad de sobra ya prendida para los picos de segundos; el autoscaling para los cambios que duran horas.
5. Un rol para todo
Todos los pods con el rol de la máquina, o un rol con s3:* sobre * porque «así no falla nada». Un pod comprometido hereda todo.
Cómo evitarlo: un rol por componente, con las acciones exactas y acotado por prefijo, escrito como infraestructura como código. Revisa cada * como si fuera un bug.
6. Llaves de acceso guardadas
Una llave de AWS en una variable de entorno, en el repositorio o en la imagen del contenedor, porque era lo más rápido para la demo. No caduca, y nadie se acuerda de que existe.
Cómo evitarlo: identidad del workload en Kubernetes, OIDC en CI y credenciales temporales en todo lo demás. Si encuentras una llave estática, rótala y bórrala.
En la vida real
ExtraIn real life
Alba: qué es gestionado y qué no
| Pieza | Quién la opera | Por qué |
|---|---|---|
| Plano de control de Kubernetes | AWS (EKS) | ≈ US$73 al mes por no operar el cerebro del cluster |
| Nodos con T4 y Triton | El equipo de Alba | Alba ya opera EKS y el payload es grande: con el endpoint gestionado, el sistema costaría ≈ US$3.3k al mes contra ≈ US$1.8k, ≈ 1.8× |
| Fine-tune mensual | AWS (job de SageMaker AI) | ≈ US$10–50 al mes, se apaga solo |
| Workers del backfill | El equipo, con KEDA | Bajan a cero: nadie espera su respuesta en segundos |
| Permisos | IAM, con IRSA o Pod Identity | Triton lee sus pesos de S3, Fluent Bit (el programa que junta los logs) escribe los logs en su prefijo y el job de etiquetado lee las fotos seleccionadas; nadie guarda llaves |
Al ALB, la puerta de entrada, le llega un token firmado del backend que llama (JWT), y lo verifica. El gateway usa el cliente que viene en ese token verificado, nunca un dato que el cliente escribe en un header. Y Triton no tiene entrada desde afuera del cluster: solo lo llama el gateway.
El servicio de documentos: comprar el OCR y separar los roles
El servicio de documentos del ejemplo usa Textract: ≈ US$279 al mes, contra ≈ US$768 en GPU más la gente. Y separa cuatro roles: la API de documentos (escribe los originales, no lee los resultados), el worker (lee los originales, escribe resultados, no puede escribir en los originales), la herramienta de revisión (solo los recortes de los campos de las tareas asignadas a cada persona) y el job de entrenamiento (lee una copia en otra cuenta). Si un pedazo cae, el daño queda en su carril.
Las láminas de microscopio: la GPU desechable
El servicio de láminas de microscopio tiene una promesa de 60 minutos. Sus workers leen trabajos de una cola y escalan con KEDA de 0 a 4. Su regla: la capa de GPU es desechable y escala a cero; los resultados son durables. Si un worker muere a la mitad, el trabajo vuelve a la cola y otro lo toma. De noche no corre ninguna GPU y la factura de GPU es cero. El precio es un arranque de 3 a 5 minutos para el primer trabajo de la mañana, que cabe de sobra en 60 minutos.
Los LLM: alquilar el modelo completo
Los sistemas con modelos de lenguaje (servir un LLM propio, un asistente que responde con los documentos internos de una empresa, o un agente que usa herramientas) hacen la pregunta gestionado contra propio en grande. Alba tiene uno de esos asistentes para sus ≈ 8,000 empleados. La pregunta es si correr el modelo propio en EKS con vLLM (un servidor de LLMs) o pagar una API por token. Entre los dos extremos hay servicios como Bedrock en AWS, que sirve modelos abiertos totalmente gestionados. Las mismas cuatro preguntas deciden; el volumen de tokens hace la cuenta.
La moderación de contenido: cuando la gente pesa más que las GPUs
En un sistema de moderación de contenido, con supuestos típicos, el costo de las personas es mucho mayor que el de las GPUs. Ahí, una plataforma de ML gestionada ni se discute: cada hora que el equipo no pasa operando nodos es una hora que pasa en el modelo.
Fuera de ML: la lavandería
Tener lavadora en casa conviene si lavas todos los días: la máquina es tuya, la usas cuando quieres y por carga sale barata. Si lavas una vez al mes, la lavandería de la esquina cobra más por carga y te ahorra comprar, instalar y reparar una lavadora. Es la cuenta de las horas activas al día, con ropa en vez de GPUs.
Ejercicios
EsencialExercises
Resuélvelos con lápiz antes de abrir la solución. Usa los precios de la lección (us-east-1, noviembre de 2026) y 730 horas al mes.
- 1Fácil
El SLA de EKS promete 99.95 %. ¿Cuántos minutos puede estar caído en un mes de 30 días? Si en esos minutos tus pods siguen corriendo, ¿qué deja de funcionar y qué no?
Ver la solución paso a paso
- Minutos caído = (100 % − SLA) × días × 1,440 minutos por día: (100 % − 99.95 %) × 30 × 1,440 = 0.0005 × 43,200 = 21.6 minutos al mes.
- Lo que cubre es la API de Kubernetes: mientras está caída no puedes desplegar, escalar ni ver el estado del cluster.
- Los pods que ya corren siguen atendiendo; los nodos no se apagan. Pero si un pod se cae en ese rato, nadie crea otro hasta que la API vuelva. Tu disponibilidad no es la de ese SLA.
- 2Fácil
Alguien propone servir el modelo de Alba en AWS Lambda «para no operar nada». Da tres razones por las que no funciona; dos salen de la tabla de límites.
Ver la solución paso a paso
- Sin GPU: la ResNet-50 en CPU tardaría mucho más y necesitaría muchas más copias para 10 M de fotos al día.
- Payload síncrono de 6 MB: algunas fotos pesan hasta 10 MB.
- Tráfico 24/7: Lambda brilla cuando hay ratos sin tráfico; Alba nunca baja de decenas de requests por segundo, así que paga por uso todo el día.
- (Además, cada copia nueva paga su arranque en frío, y Alba promete un p99 de 200 ms o menos.)
- 3Fácil
Fluent Bit, el programa que junta los logs de Alba, escribe los archivos de logs de predicciones en el prefijo
predicciones/del bucketalba-logs. Escribe su permiso como (efecto, acción, recurso). ¿Debería poder leer o borrar?Ver la solución paso a paso
- (
Allow,s3:PutObject,arn:aws:s3:::alba-logs/predicciones/*). - No necesita leer ni borrar: solo escribe archivos nuevos. Darle
s3:GetObjectos3:DeleteObjectsolo aumenta el daño si alguien lo compromete.
- (
- 4Medio
Supón un OCR propio del servicio de documentos en CPU: 2 ×
c6i.xlarge, ≈ US$248 al mes. ¿Cuál es el punto de equilibrio contra Textract (US$1.50 por 1,000 páginas) solo por factura? ¿Y si sumas ≈ US$2,500 de ingeniería, sabiendo que arriba de 1 M de páginas Textract cobra US$0.60 por 1,000?Ver la solución paso a paso
- Usa las letras de la cuenta del OCR: P=
H+ ; si P ≤ 1,500, x∗=E P÷ ; si no, x∗=a× 1,000 106+ .(P− 1,500)÷ b× 1,000 - Solo factura: H = 248 y E = 0, así que P = 248, menos de 1,500. x∗ = 248 ÷ 1.50 × 1,000 ≈ 165,000 páginas. El servicio procesa x = 186,000: por factura, ya ganaría el OCR propio en CPU.
- Con la gente: P = 248 + 2,500 = 2,748 al mes, más de 1,500. El primer millón de páginas cuesta 1,500 en Textract; faltan 2,748 − 1,500 = 1,248, a b = 0.60 por 1,000: 1,248 ÷ 0.60 × 1,000 = 2.08 M.
- Equilibrio: x∗ = 1 M + 2.08 M ≈ 3.08 M páginas, ≈ 16.6 veces el volumen del servicio (3.08 M ÷ 186,000). Con la gente contada, Textract sigue ganando.
- Usa las letras de la cuenta del OCR: P=
- 5Medio
La herramienta de moderación crece a 6 horas de GPU activa al día. ¿Cuánto cuesta en Cloud Run al mes? ¿Y a 20 horas? ¿En qué momento cambiarías a una L4 dedicada?
Ver la solución paso a paso
- Usa Cs=
s× con s = 1.05, contra Cd=h× 30.4 d× = 0.805 × 730 ≈ US$588.730 - 6 h: Cs = 1.05 × 6 × 30.4 ≈ US$192 al mes, contra ≈ US$588 de la dedicada. Sigue ganando Cloud Run.
- 20 h: Cs = 1.05 × 20 × 30.4 ≈ US$638 al mes: ya cuesta más que la dedicada.
- El cruce está en h∗=
24× = 24 × 0.805 ÷ 1.05 ≈ 18.4 horas activas al día. Antes de cambiar, revisa también el arranque en frío: si con la dedicada ya no lo tienes, eso también cuenta.d÷ s
- Usa Cs=
- 6Medio
Los workers del servicio de láminas de microscopio escalan con KEDA: meta de 15 mensajes por worker, mínimo 0 y máximo 4. ¿Cuántos workers corren con 0, 10, 45 y 200 mensajes en la cola? ¿Qué pasa con el primer mensaje después de una noche vacía?
Ver la solución paso a paso
- Usa w=
min(⌈q÷ con m = 15 y el mínimo en 0.m⌉,4) - q = 0: 0 workers. q = 10: ⌈10 ÷ 15⌉ = ⌈0.67⌉ = 1. q = 45: ⌈45 ÷ 15⌉ = 3. q = 200: ⌈200 ÷ 15⌉ = ⌈13.3⌉ = 14, pero el tope es 4.
- Con 200 la cola tarda más en vaciarse: el máximo es una decisión de costo.
- El primer mensaje de la mañana espera un arranque en frío completo, de ≈ 3–5 minutos en este servicio. Con un SLO de 60 minutos, no importa.
- Usa w=
- 7Reto
Repite la cuenta de la capa de GPU de Alba en SageMaker AI, pero con el tensor en FP32: 3 × 224 × 224 números de 4 bytes. ¿Cuánto pesa cada request? ¿Cuánto cuestan solo los datos procesados de entrada? ¿Cuántas veces el costo de las dos T4 propias?
Ver la solución paso a paso
- Usa V=
R× y c=t V× .k - Por request: t = 3 × 224 × 224 × 4 = 602,112 bytes, 4 veces el UINT8 (150,528 × 4).
- Al mes: V = 304 M × 602,112 B ≈ 183,000 GB. Con k = 0.016: c = 183,000 × 0.016 ≈ US$2,929.
- Contra las dos T4 propias (≈ US$768): 2,929 ÷ 768 ≈ 3.8 veces, solo en esa línea. Y el endpoint de interfaz también cobra por GB: (183,000 + 304) × 0.01 + 2 × 0.01 × 730 ≈ US$1,848.
- Lección: con payloads grandes y mucho tráfico, el tipo de dato del tensor puede decidir el diseño.
- Usa V=
- 8Reto
Diseña los roles de Alba con mínimo privilegio para cuatro componentes: Triton (lee los pesos), el gateway, Fluent Bit (escribe logs) y el job de etiquetado (lee las fotos seleccionadas y escribe etiquetas). Para cada uno, las acciones y los recursos. Luego: un atacante entra al pod del gateway. ¿Qué puede leer en S3 con tu diseño, y qué podría leer con un
s3:*sobre*?Ver la solución paso a paso
- Triton:
s3:GetObjectsobrealba-artefactos/triton/*ys3:ListBucketcon ese prefijo. - Gateway: ningún permiso de S3. En el diseño base recibe los bytes de la foto en la request. Que un componente no tenga rol también es una respuesta válida.
- Fluent Bit:
s3:PutObjectsobrealba-logs/predicciones/*. - Etiquetado:
s3:GetObjectsobrealba-etiquetado/seleccionadas/*ys3:PutObjectsobrealba-etiquetado/etiquetas/*. - Con tu diseño, el atacante en el gateway no lee nada de S3. Con
s3:*sobre*, leería los pesos, todos los logs y las fotos para etiquetar, y además podría borrarlos.
- Triton:
- 9Reto
Un hospital quiere segmentar tomografías: cada estudio pesa ≈ 400 MB, la promesa es entregar en 2 horas y llegan ≈ 30 estudios al día, casi todos de 8:00 a 16:00. Cada estudio tarda ≈ 70 minutos en una GPU. ¿Endpoint de tiempo real, inferencia asíncrona gestionada o workers propios con cola? Justifica con los límites de la lección.
Ver la solución paso a paso
- Tiempo real: no. 400 MB ≫ 6 MiB de payload, y 70 minutos ≫ 60 s de respuesta.
- Asíncrona gestionada: el payload cabe (≤ 1 GB), pero 70 minutos > 1 hora de tiempo máximo por trabajo. Tal como está, no cabe.
- Workers propios con cola y escala a cero: encaja. Nadie espera en segundos, hay horas sin tráfico (de noche) y la promesa de 2 horas deja lugar a un arranque en frío de minutos.
- Alternativa: si el modelo se acelera para bajar de 1 hora, la inferencia asíncrona gestionada vuelve a ser opción, sin operar workers. Primero, la pregunta de siempre: ¿quién opera la cola y los workers?
Lo que sigue
EsencialWhat comes next
- Con esta lección termina «La nube». Sigue la fase «Seguridad», que empieza donde se queda IAM. «Cifrado, llaves y certificados» explica cómo se cifran los datos y dónde se guardan las llaves (en AWS, con KMS, su servicio de llaves). «Autenticación y permisos» explica cómo demuestra quién es un cliente de fuera de la nube, que no tiene rol de IAM (por ejemplo, con un token firmado o una API key), y qué puede hacer.
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.
Servicio gestionadomanaged serviceUn servicio de la nube donde el proveedor opera por ti una parte de lo que hace funcionar un servicio (máquinas, sistema operativo, software): la instala, la actualiza, la repara y la escala. Tú lo usas por su API y pagas más por unidad.Más +
Operar es todo lo que hay que hacer para que algo siga funcionando: parches, máquinas descompuestas, escalar, guardias de noche. Un servicio gestionado se lleva ese trabajo y lo cobra dentro del precio. Va de poco (Kubernetes gestionado: el proveedor opera solo el plano de control) a todo (un producto listo como Textract). Cada escalón quita trabajo y control, y suele cobrar más por unidad. Es la versión práctica de la escalera IaaS, PaaS y SaaS.
Analogía. Pedir comida a domicilio en vez de cocinar: pagas más por plato y no lavas trastes. Se rompe porque algunos servicios cobran además por cada GB que les mandas.
Ejemplo. Textract lee páginas a ≈ US$1.50 por 1,000 (noviembre de 2026): un servicio de documentos con 186,000 páginas al mes paga ≈ US$279 y no opera ninguna GPU.
Gestionado contra propiomanaged vs self-hostedLa decisión de pagarle al proveedor para que opere una pieza o operarla tú. Se decide con cuatro preguntas, y la primera casi siempre gana: ¿quién lo va a operar?Más +
Las cuatro preguntas: (1) ¿quién lo opera?; (2) ¿cuánto volumen y qué tamaño tiene cada request?; (3) ¿qué tan especial es lo que corre?; (4) ¿qué tan rápido hay que salir y qué piden los datos? Gestionado cobra más por unidad y ahorra gente; propio es más barato por unidad y necesita un equipo que lo opere. La cuenta honesta suma la factura y la gente de cada lado.
Ejemplo. OCR de un servicio de documentos con 186,000 páginas al mes: Textract ≈ US$279 al mes contra ≈ US$768 de dos GPUs propias. Por factura, lo propio gana arriba de ≈ 512,000 páginas; con ≈ US$2,500 de gente, arriba de ≈ 3.9 M.
Kubernetes gestionadomanaged Kubernetes (EKS / GKE / AKS)Kubernetes (el sistema que reparte programas entre un grupo de máquinas) en el que el proveedor opera el cerebro, el plano de control, y tú operas las máquinas que hacen el trabajo. En AWS se llama EKS; en Google Cloud, GKE, y en Azure, AKS.Más +
Kubernetes tiene un cerebro, el plano de control, y unos nodos donde corren los pods. Operar el cerebro a mano es delicado: su base de datos guarda todo el clúster. Con Kubernetes gestionado el proveedor lo corre (EKS, en varias zonas), lo actualiza y lo respalda. Tú sigues operando los grupos de nodos, los drivers de la GPU y tus programas.
Ejemplo. El plano de control de EKS cuesta ≈ US$0.10 por hora, ≈ US$73 al mes (noviembre de 2026); con una versión vieja en soporte extendido, ≈ US$0.60 por hora.
Plano de controlcontrol planeEl cerebro de Kubernetes: guarda lo que pediste que corra (el estado deseado) y lo hace cumplir. Recibe lo que pides por su API y manda crear o quitar copias de tus programas. No corre tus programas.Más +
Guarda lo que pediste («2 copias de Triton») y unos controladores comparan sin parar lo que hay contra lo que se pidió. En Kubernetes gestionado lo opera el proveedor. Su SLA cubre su API, no tus pods: si un nodo se queda sin memoria, el proveedor cumplió y tu servicio está caído. Si el plano de control se cae un rato, lo que ya corre sigue corriendo, pero nada nuevo se crea.
Analogía. El gerente de un restaurante: tiene la lista de lo que debe haber y manda a reponerlo, pero no cocina. Se rompe porque si el gerente se va un rato, la cocina sigue sirviendo.
Ejemplo. EKS promete 99.95 %: hasta ≈ 21.6 minutos al mes con la API caída, sin que tus pods dejen de atender.
Plataforma de ML gestionadamanaged ML platform (SageMaker AI / Agent Platform / Azure ML)Una caja de servicios de la nube para entrenar, servir y registrar modelos sin operar servidores: Amazon SageMaker AI, Gemini Enterprise Agent Platform de Google Cloud (antes Vertex AI) y Azure Machine Learning.Más +
Trae piezas sueltas: jobs de entrenamiento, endpoints de tiempo real, inferencia asíncrona, serverless, batch, pipelines, registro de modelos, feature store y monitoreo. Nadie usa todas. Para entrenar casi siempre conviene: cobra por segundo y apaga las máquinas sola. Para servir, depende: sobreprecio por hora, cobros por GB, límites de payload y menos visibilidad. Sus máquinas salen de la misma capacidad que las normales y tienen cuotas propias.
Ejemplo. El fine-tune mensual de Alba corre como job gestionado por ≈ US$10–50; el serving se queda en EKS porque con el endpoint gestionado la infraestructura costaría ≈ 1.8× (≈ US$3.3k contra ≈ US$1.8k al mes).
Endpoint gestionadomanaged endpointUna dirección de una plataforma de ML (aprendizaje automático) que recibe requests y contesta predicciones, con las máquinas operadas por el proveedor: las prende, las cambia si se caen y agrega copias.Más +
A cambio de no operar nodos, aceptas tres cosas: un sobreprecio por hora (≈ 40 % en GPU en SageMaker AI), un cobro por cada GB que entra y sale, y un contrato para tu contenedor (en SageMaker AI: puerto 8080, POST /invocations, GET /ping, cuerpo de hasta 6 MiB y respuesta en 60 s). Con payloads grandes y mucho tráfico, los cobros por GB pesan más que el sobreprecio.
Ejemplo. Alba en SageMaker AI: máquinas ≈ US$1,075 + datos procesados ≈ US$737 + endpoint de interfaz ≈ US$475 ≈ US$2,287 al mes, contra ≈ US$768 de dos T4 propias, con el tensor en UINT8. Alba hoy lo manda en FP32: solo los datos procesados de entrada subirían a ≈ US$2,929.
Inferencia asíncrona gestionadaasynchronous inferenceUn modo de endpoint para requests grandes o lentas: subes el archivo a un almacén (como S3, en la nube de Amazon), pides la predicción y el resultado aparece ahí minutos después. Puede bajar a cero máquinas.Más +
En SageMaker AI acepta archivos de hasta 1 GB y trabajos de hasta 1 hora; los trabajos esperan en una cola interna. Como nadie espera en segundos, puede escalar a cero y pagar el arranque en frío solo cuando llega trabajo. Agent Platform y Azure ML no tienen un modo igual: se arma con una cola y workers o con batch.
Ejemplo. Estudios grandes con promesa de 60 minutos, como las láminas de microscopio de un servicio de imágenes médicas: un arranque de 3–5 minutos no importa, y de noche no se paga GPU. Ojo: esas láminas pesan ≈ 1 GB (algunas, 3 GB), en el límite de la asíncrona o arriba; por eso ese servicio usa su propia cola y workers.
ServerlessserverlessUna forma de usar la nube donde pagas por uso (por segundo o por request) y el proveedor escala por ti, a veces hasta cero. Sí hay servidores: no los ves ni los pagas parados.Más +
Viene en dos formas: funciones (código suelto que corre con cada evento, como Lambda) y contenedores (tu imagen completa, como Cloud Run). Hay que hacerse dos preguntas separadas: ¿tiene la GPU que necesito?, y ¿su modo de cobrar y de arrancar encaja con mi tráfico? Gana con tráfico esporádico; pierde con tráfico 24/7 y con latencia estricta desde cero.
Analogía. Un taxi contra un coche propio: pagas solo los viajes, más caro por kilómetro. Se rompe porque el taxi a veces tarda en llegar: ese es el arranque en frío.
Ejemplo. Una L4 en Cloud Run (≈ US$1.05 por hora prendida, sin redundancia zonal) gana a una dedicada (≈ US$588 al mes) mientras esté prendida menos de ≈ 18.4 horas al día.
Función serverlessserverless function (AWS Lambda)Un pedazo de código que el proveedor corre cada vez que llega un evento (una request, un archivo nuevo, un mensaje) y que te cobran por milisegundos de ejecución. La más conocida es AWS Lambda, de la nube de Amazon.Más +
Sus límites deciden para qué sirve. Lambda: sin GPU, hasta 10,240 MB de memoria, 15 minutos por llamada, imagen de hasta 10 GB sin comprimir y 6 MB de payload síncrono. Es ideal para el pegamento (redimensionar una foto, validar un archivo, mandar una notificación) y mala para servir modelos grandes en GPU.
Ejemplo. Las fotos de Alba de hasta 10 MB no caben en los 6 MB de Lambda, y la ResNet-50 necesitaría GPU para su volumen.
Contenedor serverlessserverless container (Cloud Run / Container Apps)Un servicio que corre tu imagen de contenedor completa, con su servidor web, y la escala según las requests, hasta cero. Cloud Run y Azure Container Apps, además, ofrecen GPU.Más +
A diferencia de una función, corre lo que quieras dentro de tu imagen. Cloud Run ofrece L4 y RTX PRO 6000, una por instancia, en regiones limitadas; Container Apps, T4 y A100. Cobra más por hora que una GPU dedicada, pero solo las horas que la instancia está prendida (con GPU, incluidos hasta ≈ 10 minutos de espera después de la última request). Las instancias mínimas quitan el arranque en frío y se pagan siempre.
Ejemplo. Herramienta interna de moderación con ≈ 2 h de GPU al día, con el trabajo junto en lotes: ≈ US$64 al mes en Cloud Run contra ≈ US$588 de una L4 dedicada.
AutoscalingautoscalingAjustar solo cuánta capacidad corre según la carga. En Kubernetes hay dos niveles: copias de un programa, que se agregan en segundos, y máquinas, que tardan minutos.Más +
Un lazo agrega o quita réplicas según una métrica (uso de GPU, requests por segundo, mensajes en cola): en Kubernetes, HPA o KEDA. El otro pide o devuelve nodos a la nube cuando las réplicas no caben o sobran: Karpenter o el Cluster Autoscaler. Los pods no escalan más allá de los nodos que existen. Sirve para cambios que duran horas; los picos de segundos se cubren con capacidad de sobra ya prendida. La mecánica fina está en la lección «Kubernetes».
Ejemplo. Un servicio de láminas de microscopio escala sus workers con KEDA de 0 a 4, a 15 mensajes por worker: con 45 en la cola, corren ⌈45 ÷ 15⌉ = 3.
Arranque en fríocold startEl tiempo desde que el sistema decide agregar una copia hasta que esa copia contesta su primera request: prender la máquina, bajar la imagen, cargar el modelo y pasar la prueba de listo.Más +
En Alba, con un nodo nuevo: detectar 0.5–1.5 min, nodo 2–5, imagen 2–5, engine 10–60 s, listo 5–15 s: ≈ 5 a 13 minutos. Por eso el autoscaling no absorbe picos de segundos. En serverless es al revés de lo que parece: escalar hasta cero es lo que crea el arranque en frío, y lo que lo elimina (instancias mínimas, concurrencia aprovisionada) se paga siempre.
Analogía. Prender el boiler cuando ya te quieres bañar: el agua sale fría un rato. Se rompe porque aquí el «rato» puede ser de minutos, y la request ya se cansó de esperar.
Ejemplo. A 500 requests por segundo, 13 minutos de arranque son 390,000 requests que tienen que atender las réplicas que ya estaban prendidas.
Escalar a ceroscale to zeroDejar que las copias de un servicio bajen hasta 0 cuando no hay trabajo. Ahorra la máquina entera en las horas sin tráfico; la siguiente request paga un arranque en frío completo.Más +
Conviene donde nadie espera la respuesta en segundos: workers de una cola, backfills, herramientas internas, inferencia asíncrona. No conviene en un servicio online con latencia estricta. Ojo con los valores por omisión: KEDA tiene minReplicaCount en 0.
Ejemplo. Los workers del backfill de Alba y la capa de GPU de un servicio de láminas de microscopio bajan a cero; el Triton online de Alba nunca.
IAMIAM (Identity and Access Management)El sistema de la nube que decide quién puede hacer qué acción sobre qué recurso. Toda llamada a la API de la nube, de una persona o de un programa, pasa por él.Más +
Resuelve dos preguntas distintas: autenticación (¿quién eres?) y autorización (¿qué puedes hacer?). Las identidades son usuarios, roles y, en Kubernetes, cuentas de servicio conectadas a roles. Lo que se puede hacer lo dicen las políticas. Por omisión todo se niega. Es lo que en Linux hacen los permisos, llevado a toda la nube.
Ejemplo. Cuando Triton pide s3:GetObject de alba-artefactos/triton/modelo.plan, IAM revisa quién lo pide y si alguna política se lo permite.
Política de permisosIAM policyUn documento con reglas de qué acciones se permiten o se niegan sobre qué recursos. Cada regla tiene un efecto (Allow o Deny), unas acciones y unos recursos.Más +
En AWS se escribe en JSON. Se evalúa con tres reglas: por omisión, todo se niega; un Allow que coincide lo permite; un Deny explícito gana siempre. Los recursos se nombran con ARN y pueden acotarse por prefijo (alba-artefactos/triton/*). Hay más capas (reglas de la organización, políticas del bucket), pero estas tres son el corazón.
Ejemplo. {"Effect": "Allow", "Action": "s3:GetObject", "Resource": "arn:aws:s3:::alba-artefactos/triton/*"}: leer, solo bajo triton/, de ese bucket.
Rol de IAMIAM roleUna identidad de la nube con políticas pegadas que no pertenece a nadie: se asume. Quien lo asume recibe sus permisos por un rato, con credenciales temporales.Más +
Un usuario es una persona con contraseña; un rol es un gafete que se presta. Cada rol tiene dos políticas: la de confianza (quién puede asumirlo) y la de permisos (qué puede hacer). Lo normal es un rol por componente: la API, el worker, el job de entrenamiento.
Analogía. Un gafete de visitante: te lo prestan en la entrada, abre solo ciertas puertas y caduca al final del día. Se rompe porque aquí el gafete se renueva solo mientras el programa lo necesite.
Ejemplo. Un servicio de documentos: docs-api escribe originales y no lee resultados; doc-worker lee originales, escribe resultados y tiene prohibido escribir originales.
Mínimo privilegioleast privilegeDar a cada componente solo los permisos que necesita, sobre solo los recursos que necesita. No evita un ataque: limita el daño cuando pasa.Más +
La regla práctica: un rol por componente, acotado por prefijo, escrito como infraestructura como código para revisarlo como cualquier cambio. Lo contrario, un rol para todo o s3:* sobre *, hace que un pod comprometido herede todos los buckets.
Ejemplo. Si el gateway de Alba no tiene permisos de S3, un atacante que entra a su pod no lee nada de S3; con s3:* sobre *, leería pesos, logs y fotos.
Cuenta de servicioservice accountLa identidad de un programa, no de una persona. En Kubernetes es un objeto con nombre, como classifier/triton; cada pod corre con una y recibe un token firmado que prueba quién es.Más +
Un programa no debe usar el usuario de una persona: si ella se va, el servicio se cae, y si el programa se compromete, el atacante actúa como ella. En Google Cloud también se llaman cuentas de servicio; en AWS ese papel lo hace un rol. Con la identidad del workload, la cuenta de servicio de Kubernetes se conecta con un rol de la nube.
Ejemplo. El pod de Triton corre con la cuenta triton del namespace classifier; solo esa cuenta puede asumir el rol alba-triton.
Credenciales temporalestemporary credentialsCredenciales que la nube entrega al asumir un rol y que caducan solas, normalmente en una hora. El programa pide unas nuevas antes de que venzan.Más +
Lo contrario de una credencial estática (una llave de acceso que vale hasta que alguien la borre). Si se filtran, sirven minutos y no meses, y solo para lo que permite el rol. En AWS las da STS (Security Token Service), el servicio que cambia una prueba de identidad por credenciales. Son el último escalón de la escalera de secretos: «la mejor forma de manejar un secreto es no tenerlo».
Ejemplo. Una llave de AWS en un repositorio sirve hasta que alguien la rote; unas credenciales temporales copiadas de un log vencen en ≈ 1 hora.
Identidad del workloadworkload identity (IRSA / EKS Pod Identity)Conectar la cuenta de servicio de un pod con un rol de la nube, para que el pod reciba credenciales temporales sin que nadie guarde una llave. En EKS, el Kubernetes gestionado de Amazon, se hace con IRSA (IAM Roles for Service Accounts) o con Pod Identity.Más +
Con IRSA, Kubernetes da al pod un token firmado de su cuenta de servicio; el SDK de AWS lo cambia en STS por credenciales temporales del rol, cuya política de confianza solo acepta esa cuenta de servicio. Pod Identity hace lo mismo con un agente en el nodo. En Google Cloud es Workload Identity Federation; en Azure, Entra Workload ID. El código no cambia: el SDK encuentra y renueva las credenciales solo.
Ejemplo. La cuenta classifier/triton lleva la anotación del rol alba-triton; Triton lee sus pesos de S3 sin ninguna llave en la imagen ni en un Secret.
Chequeo
EsencialCheck
Intenta responder en tu cabeza antes de abrir cada respuesta.
1¿Cuál de las cuatro preguntas de gestionado contra propio suele ganar, y por qué?Ver respuesta
«¿Quién lo opera?» Porque la gente cuesta más que casi cualquier diferencia de factura: si nadie sabe operarlo, el lado propio sale caro aunque la factura sea menor.
2¿Qué cubre el SLA de EKS y qué no?Ver respuesta
Cubre la API del plano de control de Kubernetes. No cubre tus pods ni tus nodos: tu disponibilidad la construyes tú.
3En Alba, ¿de dónde sale casi toda la diferencia entre SageMaker AI y el Triton propio?Ver respuesta
De los cobros por GB (datos procesados y el endpoint de interfaz), ≈ US$1,212 al mes; el sobreprecio de las máquinas son ≈ US$307.
4¿Qué número decide si serverless con GPU sale más barato que una GPU dedicada?Ver respuesta
Las horas de GPU activa al día. Con la L4 de la lección, el cruce está en ≈ 18 horas.
5¿Por qué el autoscaling no absorbe un pico de segundos?Ver respuesta
Porque una réplica nueva sin nodo libre tarda ≈ 5–13 minutos en contestar (nodo, imagen, engine). Los picos se cubren con capacidad de sobra ya prendida.
6¿Por qué un Deny explícito gana sobre un Allow?Ver respuesta
Para poder prohibir algo con seguridad aunque otra regla, escrita después o por otra persona, dé un permiso de más.
7¿Qué ganas con la identidad del workload frente a una llave en un Secret?Ver respuesta
Que no hay llave que guardar ni que se filtre: el pod recibe credenciales temporales que caducan solas, y solo los pods con esa cuenta de servicio pueden asumir el rol.