7 · La nubeLección 3 de 5
Máquinas, GPUs y cómo se cobran
Machines, GPUs and how they are billed
Qué es exactamente lo que rentas cuando pides una GPU en la nube, cómo se lee su nombre, cuánto cuesta cada hora y cada predicción, y las cuatro maneras de pagarla.
Secciones14
- 01La instancia: lo que de verdad rentas
- 02Las GPUs que se rentan
- 03La GPU-hora: el mismo chip, muchos precios
- 04Hora facturada contra hora trabajando
- 05On-demand y spot
- 06Compromisos: pagar menos a cambio de un plazo
- 07Cuotas, capacidad y reservas
- 08Más allá de una GPU entera extra
- 09Errores comunes
- 10En la vida real extra
- 11Ejercicios
- 12Lo que sigue extra
- 13Palabras que vas a oír
- 14Chequeo
Alba, el marketplace que seguimos en el curso, paga ≈ US$768 al mes por dos GPUs que trabajan al 5 %. ¿Qué renta exactamente, por qué cuesta eso, y cómo se paga menos sin que un día se quede sin máquinas?
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. Eso son ≈ 10 millones de fotos al día, ≈ 116 por segundo en promedio (10 millones ÷ 86,400 s). Su modelo, una ResNet-50, corre en dos máquinas g4dn.xlarge, una en cada zona. Cada una trae una GPU T4 y cuesta ≈ US$0.526 la hora en la región us-east-1, en Virginia (noviembre de 2026). Al mes son ≈ US$768. En un día normal, cada T4 atiende ≈ 58 fotos por segundo (la mitad de las ≈ 116), y aguanta ≈ 1,200. Trabaja al ≈ 5 % de lo que podría (58 ÷ 1,200).
Eso no es un error de diseño: la segunda T4 está ahí para que el sistema sobreviva si se cae una zona, como viste en la lección de regiones. Pero sí dice algo importante sobre cómo cobra la nube. Te cobra la máquina encendida, no el trabajo que hace. Una GPU al 5 % cuesta casi lo mismo que al 100 %.
En la lección de CPU y GPU viste qué hay dentro de una GPU, y en la de FLOPS, qué tan rápido calcula y lee memoria. En la de nube viste que lo que rentas es una máquina virtual, cobrada con pago por uso. Aquí juntas las tres: qué máquinas hay, qué GPUs traen, cuánto cuestan y cómo se paga menos. Al final harás la cuenta que hace cualquier equipo antes de elegir una GPU: cuánto cuesta cada predicción, con el tráfico de verdad.
La instancia: lo que de verdad rentas
EsencialThe instance: what you actually rent
Una instancia (instance) es una máquina virtual que rentas por hora a un proveedor de nube. No es una computadora física entera: es un pedazo de una, apartado para ti por el hipervisor. Tú ves una computadora completa, con su sistema operativo, y el proveedor reparte la máquina física entre varios clientes.
Cada instancia trae cinco cosas, y las cinco importan para ML:
- vCPU. La unidad de CPU que renta la nube. En la lección de CPU y GPU viste que en las máquinas de Intel de AWS un vCPU es un hilo de hardware, medio núcleo físico. La CPU decodifica las fotos, arma los lotes y le da trabajo a la GPU.
- RAM. La memoria de la CPU, en GiB. Ahí viven el programa, las bibliotecas de CUDA y los datos mientras pasan a la GPU.
- Disco. Casi siempre, un disco de red que se cobra aparte: vive en otro servidor y la máquina lo ve como si fuera suyo, a través de la red (en AWS se llama EBS). Algunas familias traen además un SSD NVMe local: pegado a la máquina física y conectado por la vía más rápida que existe para un SSD. Es rapidísimo, pero se borra cuando apagas la máquina.
- Red. Cuántos gigabits por segundo puede mandar y recibir: por ahí llegan las fotos y se baja el modelo. La lección de redes en la nube lo detalla.
- GPUs. Cero, una, cuatro u ocho, de un modelo fijo. No eliges la GPU por separado: eliges una instancia que la trae.
El precio por hora cubre todo eso junto (menos el disco de red). Por eso dos instancias con la misma GPU pueden costar muy distinto: una puede traer el doble de CPU y de RAM.
Familias y tamaños: leer g4dn.xlarge
AWS ordena sus instancias en familias (instance families): grupos de máquinas con el mismo tipo de hardware, en varios tamaños. El nombre se lee por partes.
- La letra dice para qué es la familia. Las de GPU son dos: la g (GPUs para inferencia y gráficos: T4, A10G, L4, L40S) y la p (GPUs grandes para entrenar y para modelos enormes: A100, H100, H200, B200). Otras letras son de CPU: la c es de cómputo (el gateway de Alba, la puerta que recibe las peticiones antes del modelo, es una
c6i.xlarge), la m es de uso general y la r trae mucha RAM. - El número es la generación. Una
g6es más nueva que unag4dn, y casi siempre trae otra GPU. - Las letras de después son extras. En
g4dn, la d dice que trae disco NVMe local y la n, red más rápida. Laidec6idice que el procesador es de Intel. - Después del punto, el tamaño.
largeson 2 vCPU yxlargeson 4. El número de adelante multiplica esos 4:2xlargeson 2 × 4 = 8,12xlargeson 48 y48xlargeson 192.
En las familias de GPU, el tamaño también decide cuántas GPUs vienen. Las xlarge traen una. Una g4dn.12xlarge trae cuatro T4 y 48 vCPU. Una p5.48xlarge trae ocho H100 y 192 vCPU. Y hay tamaños en medio, como la g6.2xlarge, que trae la misma L4 que la g6.xlarge pero con el doble de vCPU y de RAM.
| Instancia | vCPU | RAM | GPUs | ≈ US$/h (us-east-1, nov. 2026) |
|---|---|---|---|---|
c6i.xlarge (el gateway de Alba) | 4 | 8 GiB | ninguna | 0.17 |
g4dn.xlarge (Alba) | 4 | 16 GiB | 1 × T4 | 0.526 |
g6.xlarge | 4 | 16 GiB | 1 × L4 | 0.805 |
g5.xlarge | 4 | 16 GiB | 1 × A10G | 1.006 |
g6e.xlarge | 4 | 32 GiB | 1 × L40S | 1.861 |
g4dn.12xlarge | 48 | 192 GiB | 4 × T4 | 3.912 |
p5.48xlarge | 192 | 2,048 GiB | 8 × H100 | 55.04 |
Instancias de un grupo: el nodo
Las dos g4dn.xlarge de Alba no viven solas. Son parte de un cluster: un grupo de máquinas que trabajan juntas bajo un mismo programa que reparte el trabajo. En Alba ese programa es Kubernetes, el orquestador que decide en qué máquina corre cada programa. Cada máquina del grupo se llama nodo (node). Un nodo es una instancia vista desde el cluster: su CPU, su RAM y sus GPUs son el espacio donde el cluster acomoda programas.
La diferencia importa por una razón: cuando el cluster necesita otra GPU, no basta con arrancar otra copia de Triton, el programa que sirve el modelo de Alba. Hay que pedirle a la nube otra instancia, esperar a que arranque y a que se una al grupo. Eso toma minutos, no segundos. La lección «Kubernetes» explica quién hace ese pedido; aquí te importa lo que pasa del otro lado: si hay cuota, si hay máquinas y cuánto se cobra desde ese momento.
Las GPUs que se rentan
EsencialThe GPUs you can rent
En la lección de FLOPS aprendiste los tres números de una GPU que deciden casi todo: cuánta memoria tiene (la VRAM, que dice qué modelo cabe), qué tan rápido la lee (el ancho de banda de memoria, que manda cuando el trabajo es memory-bound) y cuántas operaciones hace por segundo (los TFLOPS, que mandan cuando es compute-bound). Aquí van esos números para las GPUs que de verdad se rentan, con su precio.
La tabla sale de las hojas de datos de los fabricantes y de las listas de precios oficiales, consultadas el 13 de noviembre de 2026. El año entre paréntesis es el del anuncio del fabricante. Los TFLOPS son densos, en FP16 con tensor cores: los que ve un modelo normal, sin el truco de la sparsity que se explica abajo.
Dos columnas más piden explicación. La de «BF16 · FP8» dice si la GPU calcula en esos dos formatos de números (BF16 y FP8). Junto a la VRAM va su tipo: GDDR6 es la memoria de las tarjetas de video comunes; HBM es memoria apilada junto al chip, mucho más rápida y más cara.
| GPU | VRAM | Ancho de banda | FP16 denso | BF16 · FP8 | Potencia | ≈ US$ por GPU-hora en AWS (us-east-1) |
|---|---|---|---|---|---|---|
| T4 (2018) | 16 GB GDDR6 | 320 GB/s | 65 TFLOPS | No · No | 70 W | 0.526 (g4dn.xlarge) |
| L4 (2023) | 24 GB GDDR6 | 300 GB/s | 121 | Sí · Sí | 72 W | 0.805 (g6.xlarge) |
| A10G (2021) | 24 GB GDDR6 | 600 GB/s | 70 | Sí · No | 300 W | 1.006 (g5.xlarge) |
| L40S (2023) | 48 GB GDDR6 | 864 GB/s | 362 | Sí · Sí | 350 W | 1.861 (g6e.xlarge) |
| A100 80 GB (2020) | 80 GB HBM2e | 2,039 GB/s | 312 | Sí · No | 400 W | 3.43 (p4de.24xlarge ÷ 8) |
| H100 SXM (2022) | 80 GB HBM3 | 3,350 GB/s | 989.5 | Sí · Sí | 700 W | 6.88 (p5.48xlarge ÷ 8) |
| H200 (2023) | 141 GB HBM3e | 4,800 GB/s | 989.5 | Sí · Sí | 700 W | 7.91 (p5en.48xlarge ÷ 8) |
| B200 (2024) | 180 GB HBM3e | ≈ 8,000 GB/s | 2,250 | Sí · Sí | hasta 1,000 W | 14.24 (p6-b200.48xlarge ÷ 8) |
| AMD MI300X (2023) | 192 GB HBM3 | 5,300 GB/s | 1,300 | Sí · Sí | 750 W | — (Azure, eastus2: 6.00) |
Tres cosas saltan a la vista:
- El precio sube más rápido que la memoria. De la T4 a la H100, la VRAM crece 5 veces y el precio por hora, 13. Si tu modelo cabe en 16 GB, pagar por 80 es tirar dinero.
- La H200 tiene el mismo cómputo que la H100. Lo que cambia es la memoria: 141 GB y 4,800 GB/s. Para un LLM que genera texto, limitado por memoria, eso es casi todo; para una ResNet-50, casi nada.
- La A10G y la L4 se parecen en VRAM y no en lo demás. La A10G lee el doble de rápido (600 contra 300 GB/s) y gasta cuatro veces la energía. La L4 calcula más y trae FP8. Cuál conviene depende de si tu modelo es memory-bound o compute-bound.
Para ir más hondoPor qué las GPUs grandes vienen de a ocho+
La A100 y la H100 de AWS (salvo la p5.4xlarge) solo se rentan en máquinas de ocho. No es capricho. Esas GPUs son SXM: no se enchufan en una ranura PCIe como una tarjeta de video, sino que se montan en una placa que trae ocho y un chip, el NVSwitch, que conecta a cada una con las otras siete por NVLink: a 900 GB/s en la H100 y a 600 GB/s en la A100. Los 900 son ≈ 7 veces lo que da un PCIe Gen5 (128 GB/s). Para repartir un modelo de 140 GB entre dos o más GPUs, o para entrenar con las ocho a la vez, esos cables son lo que importa: las GPUs se pasan pedazos del modelo o de los gradientes en cada paso.
Por eso la unidad mínima de A100 en AWS es una instancia de ≈ US$22–27 la hora. La p5.4xlarge, con una H100 suelta a ≈ US$6.88, existe para quien solo necesita una; cuesta lo mismo por GPU-hora que la de ocho. Y la H100 NVL de Azure es otra solución: tarjetas PCIe unidas por un puente NVLink de dos en dos, a 600 GB/s.
Para ir más hondoLas mismas GPUs en Google, Azure y las neoclouds+
AWS no es la única opción, ni la más barata. Google Cloud y Azure tienen casi las mismas GPUs. Y existen las neoclouds, proveedores que solo rentan GPUs, como Lambda y RunPod.
| GPU | Google Cloud (us-central1) | Azure (East US) | Neocloud |
|---|---|---|---|
| T4 | US$0.35 la GPU más la VM que la hospeda | 0.526 (NC4as_T4_v3) | — |
| L4 | 0.71 (g2-standard-4) | — | RunPod 0.69 |
| A100 80 GB | 5.07 por GPU (a2-ultragpu-1g) | 3.67 (NC24ads_A100_v4, PCIe) | Lambda 3.19 · RunPod 2.19 |
| H100 | 11.06 por GPU (a3-highgpu-8g ÷ 8) | 12.29 por GPU (ND96isr_H100_v5 ÷ 8) | Lambda 4.59 · RunPod 4.39 |
Precios de lista on-demand por GPU-hora, en US$, de noviembre de 2026. Los de Lambda son los que publica desde el 16 de noviembre. Los de RunPod son los de su Secure Cloud (centros de datos certificados); en su Community Cloud, con máquinas de terceros, cuestan menos (la H100 SXM, US$2.69; la A100 SXM, 1.39).
Fíjate en la T4 de Google: es la única fila donde la GPU se cobra aparte. Rentas una máquina normal de la familia N1 y le «enchufas» una T4 por US$0.35 la hora más. En las familias nuevas de Google (A2, A3, G2, G4) la GPU ya va incluida en el precio de la máquina, como en AWS. Si comparas el US$0.35 contra el US$0.526 de AWS sin sumar la VM, comparas una GPU sola contra una computadora completa.
La GPU-hora: el mismo chip, muchos precios
EsencialThe GPU-hour: one chip, many prices
Para comparar máquinas con distinto número de GPUs se usa una unidad: la GPU-hora (GPU-hour), una GPU encendida durante una hora. Se calcula dividiendo el precio de la instancia entre sus GPUs, y para el mes se multiplica por 730 horas:
- donde
- P
- el precio por hora de la instancia completa, en US$/h
- G
- cuántas GPUs trae la instancia
- c
- el precio por GPU-hora: lo que cuesta una GPU encendida una hora, en US$/h
- 730
- las horas de un mes promedio (8,760 ÷ 12)
- cmes
- lo que cuesta una GPU encendida todo el mes, en US$
g4dn.xlarge, us-east-1, nov. 2026: P = 0.526, G = 1p5.48xlarge: P = 55.04, G = 8El número de 730 horas es una convención: las 8,760 horas de un año de 365 días, repartidas en 12 meses iguales. Así lo usan las calculadoras de los proveedores.
Más grande no es más barato
En el súper, el paquete grande sale más barato por kilo. En la nube, casi nunca. Mira cuánto cuesta cada T4 según la instancia que la trae:
- En la
g4dn.xlarge: ≈ US$0.526 por GPU-hora. - En la
g4dn.12xlarge, con cuatro: c=P÷ = 3.912 ÷ 4 ≈ US$0.978 por GPU-hora. Casi el doble.G
La T4 es la misma. Lo que pagas de más es la CPU y la RAM: la grande trae 48 vCPU y 192 GiB, doce veces más que la chica, para cuatro veces más GPUs. Con la L4 pasa lo mismo: en la g6.xlarge cuesta ≈ US$0.805 y en la g6.48xlarge, con ocho, ≈ US$1.67 cada una.
Para ir más hondoLa GPU-hora de todas las instancias, en Python+
El programa hace la misma división para cada instancia de las tablas y agrega una columna: cuánto cuesta cada GB de VRAM por hora.
# instancia: (GPUs, US$/h en us-east-1, VRAM por GPU en GB) — AWS, noviembre de 2026
instancias = {
"g4dn.xlarge": (1, 0.526, 16),
"g4dn.12xlarge": (4, 3.912, 16),
"g6.xlarge": (1, 0.8048, 24),
"g5.xlarge": (1, 1.006, 24),
"g6e.xlarge": (1, 1.861, 48),
"p4de.24xlarge": (8, 27.44705, 80),
"p5.48xlarge": (8, 55.04, 80),
"p5en.48xlarge": (8, 63.296, 141),
}
print(f"{'instancia':15} {'GPU-hora':>9} {'al mes':>8} {'por GB de VRAM':>15}")
for nombre, (gpus, hora, vram) in instancias.items():
gpu_hora = hora / gpus # lo que cuesta una GPU durante una hora
mes = gpu_hora * 730 # una GPU encendida todo el mes
por_gb = gpu_hora / vram * 100 # centavos por GB de VRAM por hora
print(f"{nombre:15} {gpu_hora:9.3f} {mes:8,.0f} {por_gb:12.2f} ¢")instancia GPU-hora al mes por GB de VRAM
g4dn.xlarge 0.526 384 3.29 ¢
g4dn.12xlarge 0.978 714 6.11 ¢
g6.xlarge 0.805 588 3.35 ¢
g5.xlarge 1.006 734 4.19 ¢
g6e.xlarge 1.861 1,359 3.88 ¢
p4de.24xlarge 3.431 2,505 4.29 ¢
p5.48xlarge 6.880 5,022 8.60 ¢
p5en.48xlarge 7.912 5,776 5.61 ¢La última columna es una manera de ver qué tan cara es la memoria. La H200 (p5en) cuesta 15 % más por hora que la H100 y trae 76 % más memoria: por GB sale bastante más barata. Si tu problema es que el modelo no cabe, esa columna importa más que los TFLOPS.
El mismo chip en cinco nubes
La H100 SXM es la misma tarjeta en todos lados. Su precio no: en noviembre de 2026, una hora costaba ≈ US$12.29 en Azure y ≈ US$4.39 en RunPod, casi tres veces menos. Y los precios cambian seguido. Antes de diseñar, consulta el precio del día.
Para ir más hondoCinco precios para el mismo chip+
Las nubes grandes (las de hiperescala: AWS, Google Cloud y Azure, con centros de datos en medio mundo) cobran más por la misma GPU porque venden algo más que la GPU: la red privada, los permisos, el almacenamiento a un lado, el soporte, las zonas, y que tu sistema ya vive ahí. Una neocloud es más barata por GPU-hora y trae menos de todo eso. La lección de nube explica cuándo vale la pena.
Y las listas de precios no siguen la lógica del hardware. En Google, una hora de H200 (≈ US$10.60) cuesta menos que una de H100 (≈ US$11.06), aunque la H200 es mejor. Los precios los decide cada proveedor según sus costos, su inventario y su competencia, y cambian: AWS bajó los de P4 y P5 hasta 45 % en junio de 2025.
Right-sizing: la más chica que cumple
Juntando todo sale una regla que vas a oír mucho: para inferencia, gana la instancia más chica que trae tu GPU. Eso se llama right-sizing (la instancia más chica que cumple): elegir el tamaño justo, ni más ni menos. Tres razones:
- Por GPU-hora, la chica es más barata, como acabas de ver.
- Escalas más fino. Con instancias de una GPU, el sistema crece de una en una. Con instancias de cuatro, cada paso es de cuatro GPUs, aunque te falte una.
- Una falla se lleva menos. Si se cae una máquina de una GPU, pierdes una; si se cae una de ocho, pierdes ocho.
Hay excepciones, y las tres tienen sentido:
- El modelo no cabe en una GPU. Un modelo de 140 GB no entra en ninguna tarjeta de 80. Hay que repartirlo entre varias GPUs de la misma máquina, que se hablan por NVLink: por eso las A100 y H100 vienen de a ocho.
- Entrenar con muchas GPUs. Las GPUs se pasan gradientes todo el tiempo y necesitan los cables rápidos de la misma máquina.
- El preproceso necesita CPU. En un servicio de segmentación de imágenes médicas (un ejemplo con supuestos típicos), cada L4 necesita más CPU de la que trae la
g6.xlargepara abrir y cortar en pedazos las enormes imágenes de microscopio, y se usa lag6.2xlarge: la misma GPU, el doble de vCPU, ≈ US$0.98 la hora. Ahí «se paga por la CPU, no por la GPU».
Y el right-sizing tiene un paso más: elegir la GPU, no solo el tamaño. Una H100 hace todo lo que hace una T4, y más rápido. Pero si tu modelo cabe en una T4 y la T4 aguanta tu tráfico, la H100 cuesta 13 veces más por hora para hacer lo mismo. La pregunta no es «¿cuál es la mejor GPU?», sino «¿cuál es la más barata que cumple?». Y para responderla hay que medir el costo de cada predicción.
Hora facturada contra hora trabajando
EsencialBilled hours versus busy hours
La nube cobra por hora facturada: cada hora que la instancia existe y está encendida, haga algo o no. En AWS, las máquinas Linux se cobran por segundo, con un mínimo de un minuto. Apagarla detiene el cobro de cómputo; lo que sigue cobrando es su disco de red.
Por eso hay dos relojes distintos:
- Horas facturadas: las que la máquina estuvo encendida.
- Horas trabajando: las que de verdad hizo algo útil.
La diferencia es dinero tirado. En el servicio de segmentación de imágenes médicas del ejemplo, los workers (los programas que toman trabajo de una cola y lo hacen) procesan las imágenes de microscopio que los laboratorios suben durante el día. Trabajan ≈ 8.3 horas diarias. Pero entre que el sistema enciende máquinas, espera un rato por si llega más trabajo y las vuelve a apagar, quedan encendidas ≈ 15. Lo que cuesta un mes es F=g6.2xlarge a P ≈ US$0.98 y meses de 30 días:
- Trabajando: htrab = 8.3 h × 30 días = 249 h; F = 0.98 × 249 ≈ US$244.
- Facturado: hfact = 15 h × 30 días = 450 h; F = 0.98 × 450 ≈ US$441.
Casi la mitad (1 − 244 ÷ 441 ≈ 45 %) es máquina encendida sin hacer nada. No es un error: bajar una GPU y volverla a subir toma minutos, y alguien decidió esperar un rato antes de apagarla. Pero es una decisión con precio, y conviene verla.
El costo de cada predicción
El precio por hora no dice si una GPU es cara. Una GPU que cuesta el doble pero atiende el triple sale más barata. Lo que importa es el costo por predicción, que se suele dar por cada 1,000. Se divide lo que pagas en un mes entre las predicciones que hiciste ese mes, en grupos de 1,000:
- donde
- c
- el precio por GPU-hora, en US$/h (0.526 la T4 de Alba)
- r
- cuántas GPUs (réplicas del modelo) están encendidas todo el mes
- F
- la factura del mes de esas GPUs, en US$
- T
- el tráfico promedio que de verdad llega a todo el sistema, en predicciones por segundo
- 3,600
- los segundos de una hora
- Q
- las predicciones que se hacen en el mes
- K
- lo que cuesta cada grupo de 1,000 predicciones, en US$
Y aquí entra la utilización: la fracción de su capacidad que de verdad usan las GPUs, u=
Ese «20 veces» no se arregla con una GPU más barata: se arregla usando mejor la que ya pagas, o aceptándolo porque compra otra cosa. En Alba compra disponibilidad: la segunda T4 está para cuando falle una zona. La cuenta no dice que esté mal; dice cuánto cuesta esa decisión.
def costo_por_mil(usd_hora, replicas, req_s_promedio):
"""US$ por cada 1,000 predicciones con el tráfico de verdad."""
usd_mes = usd_hora * 730 * replicas
predicciones_mes = req_s_promedio * 3600 * 730
return usd_mes, usd_mes / (predicciones_mes / 1000)
maximo_t4 = 1200 # fotos por segundo que aguanta una T4 (medido)
for req_s in (116, 600, 1200, 2400): # tráfico promedio de todo el sistema
mes, mil = costo_por_mil(0.526, 2, req_s)
uso = req_s / (2 * maximo_t4)
print(f"{req_s:5} fotos/s uso {uso:6.1%} US${mes:,.0f}/mes US${mil:.6f} por 1,000") 116 fotos/s uso 4.8% US$768/mes US$0.002519 por 1,000
600 fotos/s uso 25.0% US$768/mes US$0.000487 por 1,000
1200 fotos/s uso 50.0% US$768/mes US$0.000244 por 1,000
2400 fotos/s uso 100.0% US$768/mes US$0.000122 por 1,000La factura no se mueve: US$768 en las cuatro filas. Lo que cambia es cuánto sale cada predicción. Duplicar el tráfico T duplica Q y divide K entre dos, sin tocar nada. Por eso, cuando propongas una GPU (en el trabajo o en una entrevista de diseño), di el precio por hora y luego el costo por 1,000 con tu utilización real. Una comparación de GPUs que solo mira US$/h o TFLOPS está incompleta.
La factura depende de cuántas GPUs tienes encendidas; el costo por predicción, de cuánto trabajo les llega. La calculadora aplica F=g4dn.xlarge, ≈ US$0.526 la hora en us-east-1, noviembre de 2026), que aguantan ≈ 1,200 fotos por segundo cada una, con ≈ 116 fotos por segundo en promedio.
No cuenta el gateway, la red ni el almacenamiento: solo las GPUs. El máximo por GPU sale de una prueba de carga con tu modelo; los ≈ 1,200 de la T4 con la ResNet-50 son los que midió el equipo de Alba; para la L4, el equipo supone ≈ 2.5 veces la T4 (≈ 1,500 planificadas, ≈ 3,000 de máximo), un supuesto que hay que confirmar con una prueba de carga. En la práctica se planea a ≈ 50 % del máximo para dejar margen.
Sube el tráfico y mira cómo baja el costo por predicción sin que cambie la factura. Después prueba una L4: c = US$0.805 la hora y un máximo m ≈ 3,000 fotos por segundo. Ese máximo es un supuesto del equipo de Alba (≈ 2.5 veces los 1,200 de la T4), que hay que confirmar con una prueba de carga.
¿De quién es esta GPU? Las etiquetas
Cuando una empresa tiene cien instancias, la factura dice «EC2: US$40,000» (EC2 es el servicio de máquinas virtuales de AWS). No dice qué equipo, qué modelo ni qué ambiente gastó cada dólar. (Un ambiente es una copia completa del sistema para un fin, como staging, la copia donde se prueba antes de pasar a producción.)
Para eso existen las etiquetas de asignación de costos (cost allocation tags): pares de llave y valor que le pegas a cada recurso, como equipo=catalogo, modelo=alba-categorias o ambiente=staging. Cuando las activas en la consola de facturación, la factura se puede partir por cada etiqueta.
El comando de abajo es solo una ilustración de cómo se pegan (no lo corras; necesita una cuenta de AWS y el id de una instancia real):
aws ec2 create-tags --resources i-0abc123de456f7890 \
--tags Key=equipo,Value=catalogo Key=modelo,Value=alba-categorias Key=ambiente,Value=stagingCon etiquetas, preguntas como «¿cuánto cuesta staging?» tienen respuesta. En Alba, staging es una T4 (g4dn.xlarge, US$0.526 la hora) encendida 24/7: 0.526 × 730 ≈ US$384 al mes. Encendida solo en horas de trabajo, ≈ 60 horas a la semana (60 × 52 ÷ 12 = 260 horas al mes), baja a 0.526 × 260 ≈ US$137. Sin etiquetas, esos US$250 al mes se esconden en una sola línea que dice «EC2».
On-demand y spot
EsencialOn-demand and spot
Hasta aquí, todos los precios eran on-demand (bajo demanda) (bajo demanda): el precio de lista, sin compromiso, contra el que se mide cualquier descuento. La pides, la usas, la apagas y pagas solo esas horas. Su ventaja: no te compromete a nada. Su desventaja: es el precio más alto.
La primera manera de pagar menos es instancia spot (en Google, Spot VM). La idea: el proveedor tiene máquinas que nadie está usando en este momento. En vez de dejarlas apagadas, te las renta más baratas, con una condición: te las puede quitar cuando las necesite alguien que paga precio completo.
El aviso de interrupción
Cuando el proveedor necesita la máquina, te avisa un poco antes de apagarla. Ese aviso de interrupción (interruption notice) es corto:
- AWS: 2 minutos.
- Google Cloud y Azure: 30 segundos.
Y es best effort: el proveedor intenta avisar, pero no lo promete. Tu programa tiene que leer el aviso y, en ese tiempo, guardar lo que pueda y salir en orden. En AWS hay dos maneras de enterarse: preguntarle cada pocos segundos a una dirección especial que cada máquina tiene para consultar datos de sí misma, o escuchar el evento (un mensaje automático) que la nube publica.
Esos segundos deciden qué puede correr en spot. La pregunta no es «¿cuánto ahorro?», sino «¿qué le pasa a mi sistema si me quitan la máquina con 2 minutos de aviso?»:
- Si solo se repite un pedazo de trabajo, sirve. Un entrenamiento que guarda un checkpoint cada media hora pierde, como mucho, media hora. Un backfill (volver a procesar datos viejos, como todo el catálogo) partido en pedazos repite solo el pedazo que iba.
- Si un usuario ve un error, no sirve. Si la T4 que atiende a Ana desaparece, su foto falla. Por eso el mínimo de réplicas en línea de Alba (las copias del modelo que atienden en vivo) nunca va en spot.
| Trabajo | ¿Spot? | Por qué |
|---|---|---|
| Entrenamiento con checkpoints | Sí | Pierdes lo que no estaba guardado y sigues |
| Trabajos por lotes (batch) y asíncronos, idempotentes, como la segmentación de imágenes médicas | Sí | El mensaje vuelve a la cola y otro lo hace |
| Backfills, CI, pruebas | Sí | Nadie espera la respuesta en segundos |
| Réplicas extra para una ráfaga | Con cuidado | Si se van, las demás aguantan un rato |
| El mínimo en línea (las 2 T4 de Alba) | No | Un usuario ve el error |
Cómo se vuelve seguro: cola, checkpoint y otra máquina
El diagrama muestra el patrón más común para los trabajos en spot. Los pedazos de trabajo esperan en una cola. Un worker en spot toma uno y, mientras lo procesa, el mensaje queda invisible por un rato (el visibility timeout de la lección de colas). Si el worker termina, borra el mensaje. Si desaparece, el mensaje reaparece y otro worker lo toma.
- Cola · un mensaje por pedazo
Cada mensaje es un pedazo de trabajo: una imagen, mil fotos del backfill o una época del entrenamiento. Mientras un worker lo procesa, el mensaje queda invisible; si nadie lo borra antes de su visibility timeout, reaparece. - Worker A · g4dn.xlarge · zona 1a
Un worker (trabajador): un programa que toma pedazos de la cola y los procesa, en una instancia instancia spot. Esa instancia sale ≈ 49 % más barata en la foto de precios de un día de octubre de 2026 (unag4dn.xlarge: ≈ 0.27 contra 0.526 US$/h), pero la nube se la puede llevar con 2 minutos de aviso. - Worker B · g5.xlarge · zona 1b
Otro tipo en otra zona: diversificar hace que una interrupción no se lleve a todos los workers juntos. Ojo: un engine de TensorRT compilado para T4 no corre en su A10G; hace falta uno para cada GPU. - EC2 · recupera la máquina
EC2 es el servicio de máquinas virtuales de AWS. Cuando alguien que paga precio completo necesita la máquina, manda el aviso de interrupción: 2 minutos en AWS, 30 segundos en Google Cloud y Azure. Es best effort: casi siempre llega, pero no se promete. - S3 · checkpoints y salidas
S3 es el almacén de archivos de AWS. Lo que no se puede perder vive ahí, fuera del worker: los checkpoints y las salidas de cada pedazo, cada una en una llave fija para que repetir un pedazo no haga daño.
Dos detalles hacen que funcione:
- Diversificar. Si todos tus workers son
g4dn.xlargeen una zona, cuando el proveedor necesite esas máquinas te las quita todas a la vez. Si pides varios tipos y varias zonas, una interrupción se lleva solo una parte. AWS tiene una estrategia que elige automáticamente dónde hay más capacidad sobrante y mejor precio (price-capacity-optimized). Ojo: muchos equipos compilan su modelo con TensorRT, la herramienta de NVIDIA que lo convierte en un archivo optimizado (un engine) para un modelo exacto de GPU. Un engine hecho para una T4 no corre en una L4. Diversificar pide tener un engine para cada GPU. - Elegir cada cuánto guardar. Guardar un checkpoint cuesta tiempo; no guardarlo cuesta repetir trabajo. En la práctica se guarda cada pocos minutos o cada hora, nunca «solo al recibir el aviso»: con 30 segundos no alcanza a guardar un modelo grande.
Para ir más hondoSimular cada cuánto guardar+
El programa de abajo simula un entrenamiento de 40 horas en spot, con el supuesto de que la nube quita la máquina, en promedio, dos veces al día, y que arrancar otra y cargar el checkpoint toma ≈ 15 minutos.
import random
random.seed(7)
def horas_pagadas(trabajo_h, cada_h, interrupciones_por_dia):
"""Simula un entrenamiento en spot que guarda un checkpoint cada `cada_h` horas."""
hecho, pagado = 0.0, 0.0
while hecho < trabajo_h:
# cuánto dura la máquina antes de que la nube la recupere (al azar)
vida = random.expovariate(interrupciones_por_dia / 24)
falta = trabajo_h - hecho
if vida >= falta: # termina antes de que se la quiten
return pagado + falta
pagado += vida
hecho += (vida // cada_h) * cada_h # solo cuenta lo que quedó en un checkpoint
pagado += 0.25 # ≈ 15 min para arrancar otra y cargar el checkpoint
return pagado
for cada in (0.25, 1, 4, 12):
corridas = [horas_pagadas(40, cada, 2) for _ in range(2000)]
print(f"checkpoint cada {cada:5} h → {sum(corridas) / len(corridas):5.1f} h pagadas en promedio")checkpoint cada 0.25 h → 41.3 h pagadas en promedio
checkpoint cada 1 h → 42.6 h pagadas en promedio
checkpoint cada 4 h → 48.5 h pagadas en promedio
checkpoint cada 12 h → 67.5 h pagadas en promedioCon checkpoints cada 15 minutos, pagas 41 horas por 40 de trabajo. Cada 12 horas, pagas 67: el descuento de spot se va en repetir. La simulación no cuenta lo que tarda guardar cada checkpoint (con un modelo grande, minutos), y por eso el mejor intervalo real no es «lo más seguido posible», sino uno de minutos a una hora.
Cuánto ahorra de verdad
AWS anuncia descuentos de spot «de hasta 90 %», Google «de hasta 91 %» y Azure «de hasta 90 %». Son techos de publicidad. Lo que se observa en GPUs es otra cosa. Esta es una foto de los precios spot en us-east-1, tomada un día de octubre de 2026. El descuento de cada fila es s=
| Instancia | On-demand | Spot observado | Descuento |
|---|---|---|---|
g4dn.xlarge (T4) | ≈ 0.526 | ≈ 0.27 | ≈ 49 % |
g5.xlarge (A10G) | ≈ 1.006 | ≈ 0.46 | ≈ 54 % |
g6.xlarge (L4) | ≈ 0.805 | ≈ 0.60 | ≈ 25 % |
g6e.xlarge (L40S) | ≈ 1.861 | ≈ 1.84 | ≈ 1 % |
p5.48xlarge (8 × H100) | ≈ 55.04 | ≈ 21.5 | ≈ 61 % |
Es una foto de un día, no un promedio: el precio spot lo fija el proveedor según cuánta capacidad le sobra, y cambia. Las GPUs que todos quieren (como la L40S ese día) casi no tienen descuento; las demás de inferencia, de ≈ 25 a ≈ 54 %; la p5 (8 H100), 61 %. Hay que restarle el trabajo repetido.
Un ejemplo: un fine-tune (seguir entrenando un modelo ya entrenado, con tus propios datos) de 40 horas, en una A10G. On-demand pagas las horas de trabajo a precio de lista; en spot pagas un precio más bajo, pero también las horas que se repiten:
- donde
- P,Ps
- el precio por hora on-demand y el spot de ese día, en US$/h
- h
- las horas de trabajo útil que necesita el trabajo
- hrep
- las horas que se repiten, porque te quitaron la máquina antes de guardar
- Fod,Fs
- lo que pagas por el trabajo on-demand y en spot, en US$
g5.xlarge, us-east-1: P = 1.006, h = 40Compromisos: pagar menos a cambio de un plazo
EsencialCommitments: a lower price for a term
La segunda manera de pagar menos es prometer. Le dices al proveedor «voy a gastar esto durante uno o tres años, pase lo que pase», y a cambio te cobra menos por hora. Es el mismo trueque en las tres nubes, con nombres distintos:
- Savings Plan (AWS): te comprometes a gastar un monto por hora (por ejemplo, US$0.70 cada hora) durante 1 o 3 años. Todo lo que uses hasta ese monto sale con descuento; lo que pase de ahí, a precio on-demand. Si usas menos, pagas el monto igual. El Compute Savings Plan aplica a cualquier familia y región; el EC2 Instance Savings Plan se amarra a una familia en una región, a cambio de más descuento.
- Instancia reservada (Reserved Instance, RI, en AWS y Azure) y CUD (Committed Use Discount, en Google): te comprometes a una instancia o a una cantidad de recursos, no a un monto (Google también tiene un CUD flexible, por monto). El trueque es el mismo: plazo por precio.
Los descuentos máximos anunciados son de «hasta 72 %» en las RIs y en el EC2 Instance Savings Plan, «hasta 66 %» en el Compute Savings Plan, «hasta 55 %» en los CUD de Google y «hasta 72 %» en Azure. Pero, como en spot, el máximo es para 3 años con pago adelantado y para ciertas máquinas. Para GPUs de inferencia a 1 año, sin pagar adelantado, en las listas de precios se observan ≈ 35–37 % (g4dn.xlarge y g5.xlarge ≈ 37 %, g6.xlarge ≈ 35 %), y a 3 años ≈ 54–57 %.
La regla: comprometer la base, nunca el pico
Un compromiso convierte una máquina que pagas por hora en una que pagas siempre. On-demand pagas el precio de lista por cada hora que de verdad la usas; comprometida, pagas un precio con descuento las 730 horas del mes, la uses o no. Las dos cuentas se igualan en un número de horas h∗:
- donde
- P
- el precio on-demand por hora, en US$/h
- h
- las horas del mes que de verdad usas la máquina
- d
- el descuento del compromiso, como fracción (0.37 = 37 %)
- Fod,Fc
- lo que pagas al mes on-demand y comprometida, en US$
- h∗
- las horas en que las dos salen igual; arriba de ellas gana el compromiso
Con un descuento d = 0.37, una T4 comprometida cuesta P×
Debajo de ese uso, on-demand sale más barato. Por eso se compromete solo la base. Se define con una pregunta: «¿qué parte de mi uso estoy seguro de que existirá todo el año?».
En Alba, la base son las 2 T4 y los 2 nodos del gateway (dos c6i.xlarge), que nunca se apagan: ≈ US$768 de las T4 + ≈ US$248 del gateway (2 × 0.17 × 730) ≈ US$1,016 al mes. Un Savings Plan de 1 año con d entre 0.30 y 0.40 ahorra d×
Dos consejos más: espera de 2 a 3 meses de uso real antes de comprometer (para conocer tu base de verdad) y empieza por 1 año. Un compromiso de 3 años sobre una T4 apuesta a que tu modelo seguirá corriendo en una GPU de 2018 hasta el final del plazo.
Una instancia, tres maneras de pagarla. Arranca con una g4dn.xlarge (≈ US$0.526 la hora en us-east-1, noviembre de 2026) que se usa 500 horas al mes, con los descuentos de la lección: 37 % por un compromiso de 1 año y ≈ 49 % en spot. La calculadora aplica Fod=
Un compromiso baja el precio pero no aparta máquinas, y spot puede no tener capacidad el día que la pidas. Los descuentos varían por tipo, región y día: los de spot son una foto de un día de octubre de 2026 en us-east-1 (≈ 25–55 % en GPUs de inferencia), y los del compromiso, a 1 año sin pago adelantado.
Mueve las horas h y mira dónde el compromiso empieza a ganar: justo en h∗=
Cuotas, capacidad y reservas
EsencialQuotas, capacity and reservations
Hay algo que sorprende la primera vez: pagar no te garantiza que haya máquinas. Para que una instancia arranque tienen que pasar dos filtros distintos, y ninguno de los dos depende del precio.
- Autoscaler · pide 1 g4dn.xlarge
Puede ser una persona en la consola o el programa del cluster que agrega nodos cuando faltan GPUs. Los dos hacen lo mismo: una llamada a la API de la nube que dice qué instancia, en qué zona y cuántas. - Plan B · otra zona u otro tipo
Si la zona no tiene T4 libres, se pide enus-east-1bo se pide unag4dn.2xlarge, que trae la misma T4. Pedir una L4 también sirve, pero solo si hay un engine compilado para ella. - Cuota · 28 vCPU de instancias G
La cuota es un límite de tu cuenta en la región. AWS la cuenta en vCPU: cadag4dn.xlargegasta 4. Si te pasas, el error llega al instante y solo se arregla pidiendo más, lo que puede tardar días. - Capacidad · ¿hay T4 libres en 1a?
Las GPUs son físicas: la zona tiene un número fijo. Si están ocupadas, la nube respondeInsufficientInstanceCapacity, el error de capacidad. No es tu cuota y no se arregla pagando más. - Reserva · 2 T4 apartadas
Una reserva de capacidad aparta máquinas en una zona y se paga se usen o no. Es lo único que garantiza que el mínimo arranque. Un Savings Plan no hace esto. - Factura · corre el reloj
Desde que la instancia arranca se cobra cada segundo que está encendida, trabaje o no: es la hora facturada. A ≈ US$0.526 la hora, ≈ US$384 al mes. - Instancia · arranca en minutos
La máquina virtual con sus 4 vCPU, 16 GiB y su T4. Arrancar, bajar la imagen de Triton y cargar el modelo toma minutos, no segundos. - Nodo · Triton ya atiende
La instancia se une al cluster como nodo y el cluster le pone una copia de Triton. Hasta aquí, la GPU nueva no ayudó en nada al pico que la pidió.
Primer filtro: la cuota
Una cuota de servicio (service quota) es un límite administrativo: cuántos recursos de un tipo puede tener tu cuenta en una región. Existe para proteger al proveedor y a ti (un script con un error no puede encender mil GPUs). Cada nube la cuenta distinto:
- AWS cuenta vCPUs, por grupo de familias y por región. Hay una cuota para las instancias G y VT on-demand (VT es una familia para procesar video), otra para las P y otra para las G y VT en spot. Una
g4dn.xlargegasta 4 vCPU de la cuota G; unap5.48xlarge, 192 de la cuota P. - Google Cloud cuenta GPUs por modelo y región, más una cuota global de GPUs en todas las regiones (
GPUS_ALL_REGIONS). - Azure cuenta vCPUs por familia de máquina y región.
Si pides una máquina y te pasas, el error llega al instante y no se arregla esperando: hay que pedir más cuota, y eso puede tardar de horas a días, porque a veces la revisa una persona. En cuentas nuevas, las cuotas de GPU suelen ser chicas. Las de SageMaker AI, el servicio de AWS que entrena y sirve modelos por ti, son aparte, y muchas arrancan en 0.
La cuota se pide para el máximo, no para el promedio, y antes del lanzamiento. En AWS sale de cuota=
g4dn.xlarge gasta 4 vCPUg4dn.2xlarge (8 vCPU, la misma T4), en el peor caso las 7 son de ese tamaño: 7 × 8 = 56 vCPU de cuota.Así se ve en AWS. El comando es una ilustración: muestra la cuota de instancias G on-demand de una región (necesita una cuenta y permisos):
aws service-quotas get-service-quota --region us-east-1 \
--service-code ec2 --quota-code L-DB2E81BASegundo filtro: la capacidad
Tener cuota no quiere decir que haya máquinas. Las GPUs son físicas: en una zona hay un número fijo de servidores con T4, y si otros clientes ya los están usando, no hay más. Entonces la nube responde con un error de capacidad insuficiente: en AWS, InsufficientInstanceCapacity (ICE, en la jerga).
No es tu culpa ni de tu cuota. Se arregla de tres maneras:
- Otra zona. La misma región tiene varias, y la capacidad de cada una es distinta.
- Otro tipo. Si no hay
g4dn.xlarge, quizá hayag4dn.2xlarge(la misma T4) og6.xlarge(otra GPU, que necesita su propio engine de TensorRT). - Reservar antes. Lo único que garantiza que haya máquinas.
Reservas: lo único que garantiza máquinas
Aquí está la confusión más cara de esta lección: un descuento no es una reserva. Un Savings Plan, una RI regional (la que vale en cualquier zona de la región) o un CUD flexible de Google te bajan el precio de lo que uses. No apartan ninguna máquina. Si el día del pico no hay T4 en la zona, tu Savings Plan no te consigue una. La excepción confirma la regla: en Google, un CUD de GPUs por recursos exige adjuntarle una reserva de esas mismas GPUs, y es la reserva, no el descuento, la que las aparta.
Para eso hay dos productos:
- Reserva de capacidad (On-Demand Capacity Reservation, en AWS): apartas, por ejemplo, 2
g4dn.xlargeenus-east-1a. Están ahí para ti siempre, y las pagas se usen o no, a precio on-demand (un Savings Plan puede bajarle el precio). Sirve para el mínimo que no puede fallar: en Alba, las 2 T4. - Bloque de capacidad para ML (Capacity Blocks for ML): para GPUs grandes, por días o semanas con fecha fija. Por ejemplo, 8 H100 del 3 al 10 de diciembre para un entrenamiento. Se aparta hasta 8 semanas antes, se paga por adelantado y no se cancela.
| Producto | ¿Baja el precio? | ¿Garantiza máquinas? | ¿Pagas si no la usas? |
|---|---|---|---|
| On-demand | No | No | No |
| Spot | Sí, ≈ 25–55 % (inferencia), a veces nada | No, y te la quitan | No |
| Savings Plan, RI regional, CUD flexible | Sí, ≈ 35–37 % a 1 año | No | Sí, el compromiso |
| Reserva de capacidad | No (salvo que la combines con un Savings Plan) | Sí | Sí |
| Bloque de capacidad | Precio propio | Sí, en sus fechas | Sí, por adelantado |
Más allá de una GPU entera
ExtraBeyond one whole GPU
Las secciones anteriores suponen que rentas GPUs completas, de NVIDIA, a una nube. Hay otras tres opciones: rentar un pedazo de GPU, usar chips que diseñó el propio proveedor, o comprar la GPU.
Partir una GPU: MIG y fracciones
Si tu modelo usa 3 GB de una GPU de 80, pagar la GPU entera es caro. Hay dos maneras de compartirla.
MIG (Multi-Instance GPU) parte una GPU grande en hasta 7 pedazos con aislamiento de hardware: cada pedazo tiene su propia memoria y sus propios SMs (los bloques de cómputo de la GPU), y lo que pase en uno no frena a los otros. Existe, entre otras, en la A100, la H100, la H200 y la B200 (y en hasta 4 pedazos en la RTX PRO 6000, una tarjeta de escritorio que vuelve al final de esta sección). Un pedazo de H100 se llama, por ejemplo, 1g.10gb: una séptima parte del cómputo y 10 GB. Si repartes el precio de la H100 (US$6.88 por GPU-hora) entre sus 7 pedazos, cada uno cuesta ≈ 6.88 ÷ 7 ≈ US$0.98 por hora: casi el doble de una T4 completa. MIG no existe en la T4, la L4, la A10G ni la L40S.
Las fracciones de GPU comparten sin aislamiento:
- Time-slicing: varios programas se turnan la GPU. Kubernetes anuncia, por ejemplo, «4 GPUs» donde hay una. Dicho corto: multiplica el número anunciado, no la capacidad. Si un programa usa mucha memoria, los otros se quedan sin ella.
- MPS (Multi-Process Service): varios procesos corren a la vez en la misma GPU, con mejor uso que turnarse, pero si uno falla puede afectar a los demás.
- La fracción del proveedor: AWS renta la
g6f.large, con 1/8 de una L4 (≈ 3 GB), por ≈ US$0.20 la hora. Google tiene algo parecido con la RTX PRO 6000 (lag4-standard-6, 1/8 de GPU, ≈ US$0.65 la hora en us-central1).
Para Alba conviene otra cosa: compartir las T4 que ya paga con modelos chicos de otros equipos, sirviendo varios modelos en el mismo Triton. Las T4 trabajan al ≈ 5 % (58 de las 1,200 fotos por segundo que aguantan); ahí cabe mucho. Ahorra ≈ US$250 al mes de GPUs que no hay que rentar.
Aceleradores propios de cada nube
Las nubes grandes diseñan sus propios chips para ML: los aceleradores propios.
- Google tiene las TPU (Tensor Processing Unit), solo en Google Cloud. Se programan con XLA, un compilador que usan las bibliotecas de ML JAX, TensorFlow y PyTorch/XLA (la versión de PyTorch para TPU).
- AWS tiene Inferentia (instancias
inf2), para inferencia, y Trainium (trn), para entrenar. Se usan con el Neuron SDK, que compila el modelo para ese chip.
Suelen salir más baratos por predicción que una GPU equivalente. El precio: tu modelo tiene que compilarse con otra herramienta, no todos los modelos ni todas las operaciones funcionan igual, y quedas más atado a esa nube (la dependencia del proveedor de la lección de la nube). Por eso se evalúan con la misma prueba de carga que una GPU, midiendo costo por 1,000 predicciones, no con la hoja de datos.
Rentar contra comprar
La última opción es no rentar: comprar la GPU. Hagamos la cuenta corta con una tarjeta de workstation (una computadora de escritorio muy potente, para diseño o ciencia): la RTX PRO 6000 Blackwell, con 96 GB. En noviembre de 2026 se veía en una tienda de EE. UU. en ≈ US$16,399, y la tienda de NVIDIA la pedía en US$16,000 (un precio volátil, que casi duplicó los ≈ US$8,565 de su lanzamiento). Rentada en el Secure Cloud de RunPod cuesta ≈ US$2.69 la hora. La cuenta corta es cuántas horas de renta valen lo mismo que la tarjeta: heq=
Y la cuenta de verdad tiene más renglones: la computadora donde va la tarjeta, la luz (600 W encendida 730 horas son ≈ 438 kWh al mes), el enfriamiento, quién la repara si falla, que en 3 años habrá GPUs mucho mejores, y que una tarjeta en tu oficina no tiene zonas ni N+1 (una de sobra por si falla otra). Del otro lado, comprar te da algo que la renta no: los datos y el modelo nunca salen de tu edificio.
Esa cuenta completa (con luz, servidor, depreciación y cuántos usuarios atiende cada tarjeta) es la que hace quien monta un sistema de IA que corre en máquinas propias, sin nube, con modelos de pesos abiertos. Esta lección te deja la unidad con la que se hace: la GPU-hora, y el costo por predicción con la utilización de verdad.
Errores comunes
EsencialCommon mistakes
Elegir la GPU por el precio por hora, o por los TFLOPS
Qué pasa: «la T4 es la más barata, usamos T4» o «la H100 tiene más TFLOPS, usamos H100». Ninguna de las dos frases dice cuánto cuesta cada predicción. Cómo evitarlo: mide en una prueba de carga cuántas predicciones por segundo hace cada GPU con tu modelo, y compara US$ por 1,000 predicciones con tu tráfico real. Una GPU que cuesta el doble y atiende el triple sale más barata.
Comparar una GPU sola contra una máquina completa
Qué pasa: la T4 de Google «cuesta US$0.35» y la de AWS US$0.526, y se concluye que Google es más barato. Pero en Google la GPU se cobra aparte de la VM que la hospeda. Cómo evitarlo: compara siempre el costo de la máquina completa que necesitas, con su CPU y su RAM. Y divide entre las GPUs que trae (una p5.48xlarge cuesta US$55.04 por ocho H100).
Creerle a la hoja de datos sin leer la letra chica
Qué pasa: «la L40S tiene 733 TFLOPS» (es con sparsity: los densos son 362), «la H100 tiene 3.35 TB/s» (la SXM; la PCIe tiene ≈ 2) o «16 GiB de RAM son 16 GB» (son ≈ 17.2). Cómo evitarlo: busca «sparsity» y divide entre 2; revisa qué versión de la GPU trae la instancia; convierte GiB y GB antes de sumar.
«Spot ahorra 90 %»
Qué pasa: se planea el presupuesto con el descuento máximo anunciado. Cómo evitarlo: usa el descuento que observas en tu tipo y tu región (en GPUs de inferencia, ≈ 25–55 %, a veces casi nada) y réstale el trabajo repetido. Y nunca pongas en spot lo que un usuario ve fallar.
Comprometer el máximo del autoscaler
Qué pasa: se compra un Savings Plan por las 4 T4 del pico, que solo existen unas horas al día. Se paga por máquinas que no corren. Cómo evitarlo: compromete solo la base que corre todo el año, después de 2 o 3 meses de uso real. El compromiso conviene si la usarías más de 1 − descuento de las horas.
Creer que el descuento aparta máquinas
Qué pasa: «tenemos Savings Plan, no nos vamos a quedar sin GPUs». El día del pico llega InsufficientInstanceCapacity. Cómo evitarlo: el descuento baja el precio; la reserva de capacidad aparta máquinas. Para el mínimo que no puede fallar, reserva. Y pide la cuota para el máximo antes de lanzar.
Olvidar las horas encendidas sin trabajo
Qué pasa: el staging, el notebook de alguien o el worker que espera «por si llega algo» quedan encendidos toda la noche. Cómo evitarlo: etiqueta cada recurso, revisa la factura por etiqueta y apaga lo que no trabaja. Staging de Alba (una T4) en horario de oficina pasa de ≈ US$384 a ≈ US$137 al mes.
En la vida real
ExtraIn real life
Alba, el marketplace. Dos g4dn.xlarge on-demand, una por zona: ≈ US$768 al mes. No son por el tráfico (una sola aguanta el pico de 500 fotos por segundo) sino por la disponibilidad. Trabajan al ≈ 5 %, y la predicción sale en ≈ US$0.0025 por 1,000 solo de GPUs (≈ US$0.006 con toda la infraestructura). El equipo de Alba lo comparó con 2 L4: 2 × 0.805 × 730 ≈ US$1,175 al mes, 53 % más por hora (0.805 ÷ 0.526 ≈ 1.53). Hoy gana la T4; la L4 ganaría si el tráfico creciera de 3 a 5 veces y una prueba de carga confirmara que atiende ≈ 2.5 veces más (si atendiera solo 1.25 veces más, no le alcanzaría para pagar su precio, ≈ 1.53 veces el de la T4).
En Alba, spot queda solo para el backfill del catálogo (≈ 200 millones de fotos viejas, en 4 g4dn.2xlarge durante ≈ 14 h: 4 × 14 ≈ 56 GPU-horas, 56 × 0.752 ≈ US$42 on-demand) y el entrenamiento. La base (≈ US$1,016 al mes) va a un Savings Plan de 1 año. Si la zona anda escasa de T4, las 2 mínimas pueden ir además con reserva de capacidad. Cuota pedida: 28 vCPU.
Segmentación de imágenes médicas. Workers en g6.2xlarge (1 L4, 8 vCPU) a ≈ US$0.98 la hora, porque el cuello está en la CPU que abre y corta las imágenes de microscopio. Facturan ≈ 450 horas al mes (≈ US$441) y trabajan ≈ 249. Como el trabajo es asíncrono e idempotente, va en spot: con la cola y su visibility timeout, una interrupción solo repite un pedazo. Cuota: 4 nodos × 8 vCPU = 32, y 40 contando el surge.
Video en tiempo real con varias cámaras. Para 5,000 cuadros por segundo hacen falta 19 g6.xlarge, ≈ US$11.2k al mes. Aquí no hay spot: el video no espera. El ahorro viene de un compromiso sobre la base, y de medir cuántos cuadros por segundo saca de verdad cada L4.
Recomendación. El ranker (el modelo que ordena qué recomendar primero) corre en 4 g6.2xlarge (≈ US$2.9k al mes). La g6.xlarge tenía la misma L4, pero su red sostenida (≈ 2.5 Gb/s) se saturaba con las features que recibe en cada petición. Se pagó ≈ US$126 más al mes por nodo para tener más red, no más GPU. Es el mismo right-sizing, con otro cuello.
Moderación de contenido. 10 g6.xlarge encendidas 24/7, ≈ US$5.9k al mes, en dos etapas: 6 para la primera (≈ US$3.5k) y 4 para la segunda (≈ US$2.35k). Como el tráfico nunca baja a cero, esas 10 son base: el candidato perfecto para un compromiso.
Un servicio que sirve su propio LLM. 32 H100 en 4 p5.48xlarge: ≈ US$160.7k al mes a ≈ US$6.88 por H100-hora. La alternativa era una API de un proveedor de modelos: ≈ US$442k al mes. Con GPUs tan caras, cada punto de utilización vale miles de dólares, y aquí sí se piensa en bloques de capacidad y en neoclouds.
Fuera de ML. El mismo trueque existe en el transporte. Rentar un auto por día es on-demand: caro por día, sin compromiso. Un arrendamiento de 3 años es un compromiso: barato por día, lo pagas aunque no salgas. El auto de una plataforma que te cancela si aparece un viaje mejor es spot. Y comprar el auto es comprar: gana si manejas mucho, durante años. Dónde se rompe: la plataforma te cancela antes de que te subas, y spot te baja a medio camino. Y ninguna arrendadora cobra por segundo.
Ejercicios
EsencialExercises
Resuélvelos con lápiz antes de abrir la solución. Usa los precios de las tablas de la lección (on-demand, us-east-1, noviembre de 2026, salvo que se diga otra cosa) y 730 horas al mes.
- 1Fácil
La
g6e.12xlargetrae 4 L40S y cuesta ≈ US$10.49 la hora. ¿Cuántos vCPU tiene, según la regla de los tamaños? ¿Cuánto cuesta por GPU-hora, y cuánto más que una L40S en lag6e.xlarge?Ver la solución paso a paso
- La regla: vCPU = número antes de
xlarge× 4.12xlarge= 12 × 4 = 48 vCPU. - GPU-hora, c=
P÷ , con P = 10.49 y G = 4: 10.49 ÷ 4 ≈ US$2.62 por GPU-hora.G - Contra 1.861: 2.62 ÷ 1.861 ≈ 1.41, ≈ 41 % más por la misma L40S. La diferencia es la CPU y la RAM de más.
- La regla: vCPU = número antes de
- 2Fácil
¿Cuánto cuesta al mes una
p5.48xlargeencendida todo el tiempo? ¿Y cada una de sus H100?Ver la solución paso a paso
- La instancia completa: P×
730 = 55.04 × 730 ≈ US$40,179 al mes. - Por H100: c=
P÷ = 55.04 ÷ 8 = 6.88 por hora; cmes=G c× = 6.88 × 730 ≈ US$5,022 al mes.730
- La instancia completa: P×
- 3Fácil
La
g4dn.xlargetrae 16 GiB de RAM y una T4 de 16 GB de VRAM. ¿Son la misma cantidad de bytes? ¿Cuántos GB son 16 GiB?Ver la solución paso a paso
- No. 1 GiB = 2³⁰ bytes y 1 GB = 10⁹ bytes. 16 GiB = 16 × 2³⁰ = 17,179,869,184 bytes ≈ 17.2 GB.
- 16 GB = 16 × 10⁹ = 16,000,000,000 bytes. La RAM tiene ≈ 7 % más bytes.
- 4Fácil
Una tabla de proveedor dice que la L40S hace «733 TFLOPS en FP16, with sparsity». ¿Cuántos ve un modelo normal? ¿Cuántas veces es eso los 312 de la A100?
Ver la solución paso a paso
- La regla: denso ≈ con sparsity ÷ 2. 733 ÷ 2 ≈ 366.5 TFLOPS. La página de NVIDIA publica el denso exacto: 362.
- 362 ÷ 312 ≈ 1.16 veces. Sin dividir, parecería 2.35 veces: la trampa duplica la ventaja.
- 5Medio
Alba cambia sus 2 T4 por 2 L4 (
g6.xlarge), con el mismo tráfico (≈ 116 fotos por segundo en promedio). ¿Cuánto paga al mes y cuánto le cuesta cada 1,000 predicciones? ¿Y si las dos GPUs trabajaran a su capacidad planificada (la mitad de su máximo): ≈ 600 fotos por segundo la T4 y, con el supuesto del equipo de Alba de que la L4 atiende ≈ 2.5 veces más, ≈ 1,500 la L4?Ver la solución paso a paso
- Usa las fórmulas del costo por 1,000: F=
c× , Q=r× 730 T× y K=3,600× 730 F÷ .(Q÷ 1,000) - Al mes, con c = 0.8048 y r = 2: F = 0.8048 × 2 × 730 ≈ US$1,175.
- Predicciones, con T = 116: Q = 116 × 3,600 × 730 ≈ 304.8 M al mes, que son 304,848 grupos de 1,000. K = 1,175 ÷ 304,848 ≈ US$0.0039 por 1,000, contra ≈ US$0.0025 con T4.
- Planificada: por hora y por GPU, K=
c÷ , con TGPU las fotos por segundo que atiende cada GPU. La L4 hace 1,500 × 3,600 = 5.4 M predicciones por hora, o sea 5,400 grupos de 1,000: K = 0.8048 ÷ 5,400 ≈ US$0.00015 por 1,000. La T4, a 600 fotos por segundo, hace 2,160 grupos de 1,000 por hora: 0.526 ÷ 2,160 ≈ US$0.00024. Llena, la L4 sale ≈ 39 % más barata por predicción (1 − 0.00015 ÷ 0.00024, con los valores sin redondear); con el tráfico de hoy, la T4 gana. La L4 conviene solo si atiende más de ≈ 1.53 veces lo de una T4 (su precio entre el de la T4) y ese tráfico existe.(TGPU× 3,600÷ 1,000)
- Usa las fórmulas del costo por 1,000: F=
- 6Medio
Un servicio de búsqueda semántica con embeddings vuelve a calcular los embeddings de todo su catálogo en ≈ 23 L4-horas (un supuesto del ejemplo). ¿Cuánto cuesta on-demand? ¿Y en spot, con el ≈ 25 % de descuento que se observó en la
g6.xlarge? ¿Y si además repite ≈ 10 % del trabajo por interrupciones?Ver la solución paso a paso
- Usa Fod=
P× , Ps=h P× y Fs=(1− s) Ps× , con P = 0.8048, h = 23 y s = 0.25.(h+ hrep) - On-demand: Fod = 0.8048 × 23 ≈ US$18.5.
- Spot sin repetir (hrep = 0): Ps = 0.8048 × 0.75, así que Fs = 18.5 × 0.75 ≈ US$13.9.
- Con 10 % repetido (hrep = 0.1 × 23 = 2.3 h): Fs = 0.8048 × 0.75 × (23 + 2.3) = 13.9 × 1.1 ≈ US$15.3. El ahorro baja de US$4.6 a US$3.2. Vale la pena, pero poco: con descuentos chicos, spot apenas compensa.
- Usa Fod=
- 7Medio
Los workers de segmentación de imágenes médicas del ejemplo (
g6.2xlarge, ≈ US$0.98 la hora) facturan 450 horas al mes. ¿Conviene comprometer uno a 1 año con 35 % de descuento? ¿Desde cuántas horas al mes conviene?Ver la solución paso a paso
- Usa Fod=
P× , Fc=h P× y h∗=(1− d)× 730 730× , con P = 0.98, h = 450 y d = 0.35.(1− d) - On-demand: Fod = 0.98 × 450 = US$441.
- Comprometido: Fc = 0.98 × 0.65 × 730 ≈ US$465, se use o no.
- No conviene: 465 − 441 = US$24 más caro. El punto de equilibrio es h∗ = 730 × (1 − 0.35) ≈ 475 horas al mes (≈ 65 % del tiempo). Por encima, gana el compromiso.
- Usa Fod=
- 8Medio
Un sistema en
us-east-1tiene un autoscaler que llega a 6g5.xlarge, despliega con 1 de sobra, y tiene una de staging. Sus workers de batch corren en spot, 4g4dn.2xlargecomo máximo. ¿Qué cuotas pide y de cuántos vCPU?Ver la solución paso a paso
- La regla: cuota=
máquinas× (las máquinas en el peor momento, por los vCPU de cada una), una cuota por grupo de familias.vCPU - Cuota de instancias G y VT on-demand: (6 del autoscaler + 1 de sobra + 1 de staging) × 4 vCPU de cada
g5.xlarge= 32 vCPU. - Cuota de instancias G y VT spot, aparte: 4 máquinas × 8 vCPU de cada
g4dn.2xlarge= 32 vCPU. - Las dos se piden antes del lanzamiento, en
us-east-1. Tenerlas no garantiza capacidad.
- La regla: cuota=
- 9Reto
Un modelo de lenguaje de 60 GB (pesos en BF16) tiene que servirse en una sola GPU. Al generar texto con una sola petición a la vez, cada token lee todos los pesos: los tokens por segundo ≈ ancho de banda ÷ 60 GB. Compara la A100 80 GB PCIe de Azure (US$3.673/h, 1,935 GB/s), la H100 SXM de AWS (
p5.4xlarge, US$6.88/h, 3,350 GB/s) y la H100 NVL de Azure (US$6.98/h, 3,900 GB/s): tokens por segundo, US$ al mes y US$ por millón de tokens. ¿Cabe en una L40S?Ver la solución paso a paso
- Usa v≈
B÷ y Ktok=S P÷ , con B el ancho de banda en GB/s, S = 60 GB el tamaño de los pesos, v los tokens por segundo, P el precio por hora y Ktok los US$ por millón de tokens. Al mes, P×(v× 3,600)× 106 730 . - En una L40S no: tiene 48 GB.
- A100 PCIe: v = 1,935 ÷ 60 ≈ 32 tokens/s (32.25); 3.673 × 730 ≈ US$2,681 al mes; Ktok = 3.673 ÷ (32.25 × 3,600) × 10⁶ ≈ US$31.6 por millón.
- H100 SXM: v = 3,350 ÷ 60 ≈ 56 tokens/s (55.8); 6.88 × 730 ≈ US$5,022 al mes; Ktok = 6.88 ÷ (55.8 × 3,600) × 10⁶ ≈ US$34.2 por millón.
- H100 NVL: v = 3,900 ÷ 60 = 65 tokens/s; 6.98 × 730 ≈ US$5,095 al mes; Ktok = 6.98 ÷ (65 × 3,600) × 10⁶ ≈ US$29.8 por millón.
- La H100 es casi el doble de rápida y casi el doble de cara: por token salen parecidas. Con una sola petición a la vez, el trabajo es memory-bound y se paga por ancho de banda. Con muchas peticiones juntas (batching) la cuenta cambia, y la H100 gana más.
- Usa v≈
- 10Reto
Una startup duda entre comprar una RTX PRO 6000 (≈ US$16,399) o rentarla en el Secure Cloud de RunPod (≈ US$2.69 la hora). La tarjeta gasta 600 W y la luz le cuesta US$0.15 por kWh (un supuesto). (a) Encendida 24/7, ¿cuánto cuesta la luz al mes? (b) ¿En cuántas horas de uso se paga la compra, contando la luz? (c) ¿Y si la usan 8 horas al día? (d) Di dos costos que la cuenta todavía no incluye.
Ver la solución paso a paso
- Usa heq=
A÷ : cada hora con la tarjeta propia te ahorra la renta P menos la luz que gasta, con A = 16,399 el precio de compra, W = 0.6 kW la potencia y L = 0.15 US$/kWh el precio de la luz.(P− W× L) - (a) La luz al mes: W×
730× = 0.6 × 730 = 438 kWh; 438 × 0.15 ≈ US$66 al mes.L - (b) Cada hora propia ahorra P−
W× = 2.69 − 0.6 × 0.15 = US$2.60. heq = 16,399 ÷ 2.60 ≈ 6,307 horas: 6,307 ÷ 730 ≈ 8.6 meses 24/7.L - (c) A ≈ 243 horas al mes (8 × 30.4): 6,307 ÷ 243 ≈ 26 meses, más de dos años.
- (d) La computadora que la hospeda (CPU, RAM, fuente de poder), el enfriamiento, el tiempo de quien la mantiene, que no tiene N+1 ni zonas, y que en tres años valdrá mucho menos.
- Usa heq=
Lo que sigue
ExtraWhat comes next
En Sensei: la siguiente lección, «Redes en la nube: VPC, subredes y egress», cobra lo que esta no: los bytes que cruzan de zona, el NAT y la salida a internet. En Alba, si cada request pudiera cruzar de una zona a otra, el cruce de zona costaría ≈ US$1.8k al mes (≈ US$3.6k con el resto de la factura), más del doble de los ≈ US$768 de sus dos T4; mandando cada request a las máquinas de su misma zona, baja a ≈ US$140 de red en total. Después, «Servicios gestionados, serverless y permisos» compara servir en tus propias instancias contra un endpoint gestionado y explica el cold start. La lección «Kubernetes» cuenta quién pide los nodos, por qué tarda minutos y cómo se reparten las GPUs entre los programas.
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.
InstanciainstanceUna máquina virtual que rentas por hora en la nube, con un número fijo de vCPU, RAM, red y, a veces, GPUs. Es la unidad que se pide, se enciende y se cobra.Más +
Una instancia es una máquina virtual que el proveedor aparta para ti dentro de una computadora física, con su hipervisor. Trae cinco cosas: vCPU, RAM (en GiB), disco (casi siempre un disco de red que se cobra aparte), red y, en las familias de GPU, cero, una, cuatro u ocho GPUs de un modelo fijo. No eliges la GPU por separado: eliges una instancia que la trae. El precio por hora cubre todo junto, y por eso dos instancias con la misma GPU pueden costar muy distinto.
Analogía. Como rentar un departamento amueblado en un edificio: tienes tu espacio y tus muebles fijos, pero el edificio es del dueño y lo comparte con otros inquilinos. Se rompe en que el departamento lo rentas por mes; la instancia, por segundo.
Ejemplo. Una g4dn.xlarge trae 4 vCPU, 16 GiB de RAM y una GPU T4, por ≈ US$0.526 la hora en us-east-1 (noviembre de 2026): ≈ US$384 al mes encendida todo el tiempo.
Familia de instanciasinstance familyUn grupo de instancias con el mismo tipo de hardware, en varios tamaños. En AWS (la nube de Amazon) el nombre dice la familia, la generación, los extras y el tamaño: g4dn.xlarge.Más +
AWS nombra sus instancias por partes. La letra es la familia: g (GPUs para inferencia: T4, A10G, L4, L40S), p (GPUs grandes: A100, H100, H200, B200), c (cómputo), m (uso general), r (mucha RAM). El número es la generación. Las letras siguientes son extras (en g4dn, d = disco NVMe local, n = red más rápida; en c6i, i = procesador Intel). Después del punto va el tamaño: large = 2 vCPU, xlarge = 4, 12xlarge = 48, 48xlarge = 192. En las familias de GPU, el tamaño decide también cuántas GPUs vienen.
Ejemplo. p5.48xlarge: familia p, generación 5, tamaño 48 × 4 = 192 vCPU, con 8 H100. g6.2xlarge: la misma L4 que la g6.xlarge, con el doble de vCPU y RAM.
NodonodeUna máquina que forma parte de un grupo que trabaja junto, como un clúster de Kubernetes (el sistema que reparte programas entre máquinas). Es una instancia vista desde el grupo: su CPU, RAM y GPUs son lugar para acomodar programas.Más +
Cuando varias instancias trabajan bajo un mismo programa que reparte el trabajo (un clúster), cada una se llama nodo. La diferencia práctica: si el clúster necesita otra GPU y no hay lugar en sus nodos, no basta con arrancar otra copia del programa; hay que pedirle a la nube otra instancia, esperar a que arranque y se una al grupo. Eso toma minutos y pasa por la cuota y la capacidad de la zona. Ese pedido lo hace un programa del clúster, el autoscaler de nodos.
Ejemplo. Las dos g4dn.xlarge de Alba, el marketplace del curso, son dos nodos del clúster EKS, uno por zona. Cada uno aloja una copia de Triton.
GPU-horaGPU-hourUna GPU encendida durante una hora. Es la unidad para comparar precios: el precio de la instancia dividido entre sus GPUs.Más +
Las instancias traen distinto número de GPUs, así que su precio por hora no se puede comparar directo. Se divide entre las GPUs: una p5.48xlarge a ≈ US$55.04 la hora con 8 H100 da ≈ US$6.88 por GPU-hora. Así se ve que la misma GPU cuesta distinto según la instancia (la T4 cuesta ≈ US$0.53 en la g4dn.xlarge y ≈ US$0.98 en la g4dn.12xlarge) y según el proveedor. Ojo: en las T4 de Google la GPU se cobra aparte de la VM; ahí la GPU-hora sola no es el costo de la máquina.
Ejemplo. H100 SXM por GPU-hora en noviembre de 2026: ≈ US$12.29 en Azure, ≈ 11.06 en Google, ≈ 6.88 en AWS, ≈ 4.39 en RunPod (su Secure Cloud). Por 730 horas, una H100 de AWS cuesta ≈ US$5,022 al mes.
Right-sizing (la instancia más chica que cumple)right-sizingElegir la instancia y la GPU más chicas que cumplen con el modelo y el tráfico. Para inferencia, casi siempre gana la instancia de una sola GPU.Más +
Por GPU-hora, las instancias chicas son más baratas (la grande cobra CPU y RAM de más), escalan de una en una y una falla se lleva menos. Las excepciones: el modelo no cabe en una GPU y hay que repartirlo entre varias de la misma máquina por NVLink; entrenar con muchas GPUs; o el preproceso necesita más CPU (entonces se sube el tamaño, no la GPU). El paso siguiente es elegir la GPU: la más barata que cumple, medida en costo por predicción, no la mejor.
Ejemplo. Una T4 cuesta ≈ US$0.526 por hora en la g4dn.xlarge y ≈ US$0.978 en la g4dn.12xlarge. Para servir una ResNet-50, la chica gana.
Hora facturada (contra hora trabajando)billed hour versus busy hourLa nube cobra cada hora que la máquina está encendida, haga algo útil o no. La diferencia entre horas facturadas y horas trabajando es dinero tirado.Más +
Una instancia se cobra mientras existe y está encendida (en AWS, las Linux por segundo, con mínimo de un minuto). Apagarla detiene el cobro de cómputo, no el del disco. Como encender una GPU tarda minutos, los sistemas suelen dejarla encendida un rato por si llega más trabajo: esas horas se pagan sin trabajo. Medir horas facturadas contra trabajando dice cuánto cuesta esa espera.
Ejemplo. Unos workers de segmentación de imágenes médicas, en g6.2xlarge a ≈ US$0.98 la hora, trabajan ≈ 8.3 h al día pero quedan encendidos ≈ 15: al mes, 0.98 × 249 h ≈ US$244 de trabajo contra 0.98 × 450 h ≈ US$441 facturados, ≈ 45 % ocioso.
Costo por prediccióncost per prediction (per 1,000 predictions)Lo que cuesta cada predicción, normalmente por cada 1,000: el precio por hora entre las predicciones que de verdad se hacen en esa hora. Manda la utilización: qué parte de lo que la GPU podría hacer le llega de verdad.Más +
US$ por 1,000 = US$ por hora ÷ (predicciones por hora ÷ 1,000). Las predicciones por hora son las que llegan, no las que la GPU podría hacer. Por eso una GPU que trabaja al 5 % cuesta 20 veces más por predicción que a tope, con la misma factura. Es la manera correcta de comparar GPUs: una que cuesta el doble y atiende el triple sale más barata. Se mide con una prueba de carga con el modelo real.
Ejemplo. Alba, el marketplace del curso: 2 T4 cuestan ≈ US$768 al mes y, con ≈ 116 fotos por segundo, hacen ≈ 304.8 M predicciones, o 304,848 grupos de 1,000: 768 ÷ 304,848 ≈ US$0.0025 por 1,000, solo de GPUs (con toda la infraestructura, ≈ US$0.006). Una T4 a tope (≈ 1,200 por segundo) daría ≈ US$0.00012.
Etiqueta de asignación de costoscost allocation tagUn par llave-valor que se le pega a cada recurso de la nube (como equipo=catalogo) para poder partir la factura por equipo, modelo o ambiente.Más +
La factura de la nube agrupa por servicio («EC2: US$40,000»). Con etiquetas, cada recurso lleva datos como equipo, modelo y ambiente, y al activarlas en la consola de facturación se puede ver cuánto gastó cada uno. Sirven para encontrar lo que nadie apagó, cobrarle a cada equipo lo suyo y medir el costo de un modelo. Solo cuentan desde que se activan, y los recursos sin etiqueta quedan en una bolsa sin dueño.
Ejemplo. Con ambiente=staging, Alba, el marketplace del curso, ve que su staging cuesta ≈ US$384 al mes con una T4 24/7, y que encendiéndola solo en horario de oficina baja a ≈ US$137.
On-demand (bajo demanda)on-demand instanceRentar una instancia al precio de lista, sin compromiso: la pides, la usas, la apagas y pagas solo esas horas. Es el precio contra el que se miden todos los descuentos.Más +
On-demand es la manera más flexible y la más cara de pagar. No te compromete a nada y nadie te quita la máquina mientras la tengas, pero tampoco te garantiza que haya máquinas cuando las pidas: eso solo lo hace una reserva de capacidad.
Ejemplo. Una g4dn.xlarge on-demand cuesta ≈ US$0.526 la hora en us-east-1 (noviembre de 2026); en spot se vio a ≈ 0.27, y con un compromiso de 1 año, ≈ 0.331.
Instancia spotspot instance / Spot VMCapacidad sobrante que la nube renta con descuento, a cambio de poder quitártela con un aviso corto cuando la necesita para un cliente que paga completo.Más +
El proveedor fija el precio spot según cuánta capacidad le sobra, y cambia. Los descuentos anunciados («hasta 90 %») son techos; en las GPUs de inferencia que se observaron, ≈ 25–55 %, y a veces casi nada. La pregunta que decide si algo va en spot no es cuánto ahorras, sino qué pasa si te quitan la máquina: si solo se repite un pedazo de trabajo (entrenamiento con checkpoints, batch idempotente, backfills, CI), sirve; si un usuario ve un error, no. Se diversifica entre tipos y zonas para que una interrupción no se lleve todo.
Analogía. Un asiento de avión de último minuto: más barato, pero si llega alguien con boleto completo, te bajan. Se rompe en que en spot te bajan a medio vuelo.
Ejemplo. Un fine-tune de 40 h en g5.xlarge: ≈ US$40 on-demand; en spot a ≈ 0.462 con 4 interrupciones que repiten 25 min cada una, ≈ US$19.
Aviso de interrupciónspot interruption noticeEl aviso que da la nube antes de quitarte una máquina spot: 2 minutos en AWS (la nube de Amazon) y 30 segundos en Google Cloud y Azure. Es lo que tienes para guardar y salir en orden.Más +
El aviso es best effort: el proveedor intenta darlo, no lo promete. Tu programa lo lee (en AWS, preguntándole a una dirección especial que la máquina tiene para consultar datos de sí misma, o escuchando un evento que publica la nube) y en ese tiempo deja de tomar trabajo nuevo, guarda un checkpoint si puede y sale. Lo que no termine vuelve a la cola cuando vence su visibility timeout. Con 30 segundos no alcanza a guardar un checkpoint grande: por eso se guardan seguido, no solo al recibir el aviso.
Ejemplo. Un worker de segmentación de imágenes médicas recibe el aviso de 2 minutos a la mitad de una imagen: deja de pedir mensajes, no borra el actual y se apaga. A los minutos, el mensaje reaparece y otro worker lo hace desde el principio.
Savings PlanSavings PlanUn compromiso con AWS (la nube de Amazon) de gastar cierto monto por hora durante 1 o 3 años, a cambio de descuento. Lo que pases del monto va a precio on-demand; si usas menos, pagas el monto igual.Más +
El Compute Savings Plan aplica a cualquier familia y región; el EC2 Instance Savings Plan se amarra a una familia en una región a cambio de más descuento (máximos anunciados: hasta 66 % y 72 %, a 3 años con pago adelantado). En GPUs de inferencia, a 1 año y sin pago adelantado, se observan ≈ 35–37 %. Conviene si usarías esas máquinas más de 1 − descuento de las horas: se compromete la base estable, nunca el pico. No aparta máquinas: solo baja el precio.
Ejemplo. La base de Alba, el marketplace del curso (2 T4 + 2 nodos del gateway: ≈ 768 + 248 ≈ US$1,016 al mes), con un plan de 1 año al 30–40 % ahorra 0.30 × 1,016 a 0.40 × 1,016 ≈ US$305–406 al mes.
Instancia reservada y CUDreserved instance / committed use discountUn descuento a cambio de un plazo: te comprometes a usar una instancia o cierta cantidad de recursos durante 1 o 3 años, y pagas menos por hora, la uses o no. AWS y Azure lo llaman instancia reservada (RI); Google, CUD.Más +
AWS y Azure las llaman instancias reservadas (Reserved Instances, RI); Google, descuentos por uso comprometido (Committed Use Discounts, CUD). Comprometes un tipo o una cantidad de recursos, no un monto de dinero. El descuento máximo anunciado es de hasta 72 % en AWS y Azure y hasta 55 % en los CUD de Google. Una RI regional, igual que un Savings Plan, baja el precio pero no garantiza capacidad. El nombre engaña: «reservada» no quiere decir que haya máquinas apartadas. La excepción está en Google: un CUD de GPUs por recursos exige adjuntarle una reserva de esas mismas GPUs, y esa reserva sí las aparta.
Ejemplo. Una g4dn.xlarge con 37 % de descuento a 1 año: ≈ 0.526 × 0.63 ≈ US$0.331 por hora, las 730 horas del mes.
Cuota de servicioservice quotaUn límite administrativo de cuántos recursos de un tipo puede tener tu cuenta en una región. Si te pasas, la nube te dice que no al instante; se arregla pidiendo más, con anticipación.Más +
Cada nube cuenta distinto: AWS cuenta vCPUs por grupo de familias (una cuota para instancias G y VT on-demand, otra para P, otra para spot), Google cuenta GPUs por modelo y región más una cuota global (GPUS_ALL_REGIONS), y Azure cuenta vCPUs por familia. Se pide para el máximo (autoscaler, despliegues, staging, CI) y antes de lanzar, porque aumentarla puede tardar. Tener cuota no garantiza que haya máquinas: eso es la capacidad.
Ejemplo. Alba, el marketplace del curso: (4 del autoscaler + 1 al desplegar + 1 staging + 1 CI) × 4 vCPU = 28 vCPU de instancias G en us-east-1.
Error de capacidad insuficienteinsufficient capacity error (InsufficientInstanceCapacity, ICE)Cuando la zona no tiene máquinas libres del tipo que pediste, aunque tengas cuota y dinero. En AWS (la nube de Amazon) se llama InsufficientInstanceCapacity.Más +
Las GPUs son físicas y cada zona tiene un número fijo. Si otros clientes las están usando, no hay. No es tu cuota (eso sería otro error) y no se arregla pagando más. Se arregla pidiendo en otra zona, otro tipo de instancia con una GPU equivalente (si el modelo está compilado para una GPU exacta, hay que compilarlo también para la otra) o con una reserva de capacidad hecha antes. Una plataforma gestionada no te salva: saca sus máquinas de la misma capacidad física.
Ejemplo. En un pico, el autoscaler de Alba pide una tercera g4dn.xlarge en us-east-1a y recibe ICE; prueba en us-east-1b o pide una g4dn.2xlarge, que trae la misma T4.
Reserva de capacidadcapacity reservationApartar máquinas de un tipo en una zona para que estén ahí cuando las pidas. Es lo único que garantiza capacidad, y se paga se use o no.Más +
En AWS se llama On-Demand Capacity Reservation: eliges tipo, zona y cantidad, y esas máquinas quedan para ti a precio on-demand (un Savings Plan puede bajarle el precio). Sirve para el mínimo que no puede fallar, porque un descuento como un Savings Plan o una RI regional no aparta nada. Si no la usas, la pagas igual.
Ejemplo. Si Alba, el marketplace del curso, reserva 2 g4dn.xlarge, una en us-east-1a y otra en us-east-1b, su mínimo de 2 T4 siempre puede arrancar, aunque la zona se quede sin T4 para otros. Paga esas 2 máquinas las 730 horas, como ya las paga hoy.
Bloque de capacidad para MLCapacity Blocks for MLUn producto de AWS (la nube de Amazon) para apartar GPUs grandes por días o semanas con fecha fija, por ejemplo para un entrenamiento. Se aparta con hasta 8 semanas de anticipación y se paga por adelantado.Más +
Las GPUs grandes (H100, H200, B200) son escasas y on-demand puede no haber. Un bloque de capacidad aparta un número de instancias en fechas exactas: tienes las máquinas esas fechas, y solo esas. Se paga por adelantado y no se cancela. Es la respuesta a «necesito 8 H100 la semana que viene durante 7 días».
Ejemplo. Un equipo aparta una p5.48xlarge (8 H100) del 3 al 10 de diciembre para un fine-tune; paga antes de empezar, aunque termine en 5 días.
MIG (GPU multi-instancia)Multi-Instance GPUPartir una GPU grande (A100, H100, H200) en hasta 7 pedazos con aislamiento de hardware: cada uno con su propia memoria y sus propios bloques de cómputo (SMs), como si fueran GPUs chicas separadas.Más +
Con MIG, lo que pasa en un pedazo no frena a los otros: es como tener varias GPUs chicas. Cada pedazo se nombra por su tamaño, como 1g.10gb en una H100 (una séptima parte del cómputo y 10 GB). Existe, entre otras, en A100, H100, H200 y B200 (hasta 7) y en la RTX PRO 6000 (hasta 4). No existe en la T4, la L4, la A10G ni la L40S. Las particiones se configuran de antemano y no cambian solas.
Ejemplo. Un pedazo 1g.10gb de una H100 de AWS sale en ≈ US$6.88 ÷ 7 ≈ US$0.98 por hora: casi el doble de una T4 completa.
Fracción de GPUGPU fraction (time-slicing, MPS)Compartir una GPU entre varios programas sin aislamiento de hardware: turnándose (time-slicing), corriendo a la vez (MPS, el Multi-Process Service de NVIDIA) o rentando una fracción que vende el proveedor.Más +
Con time-slicing, varios programas se turnan la GPU y Kubernetes anuncia más GPUs de las que hay: multiplica el número anunciado, no la capacidad, y si uno se come la memoria, los otros fallan. Con MPS, varios procesos corren a la vez en la misma GPU, con mejor uso, pero un error en uno puede afectar a los demás. Algunos proveedores rentan fracciones directamente. Otra manera de compartir es servir varios modelos en el mismo model server.
Ejemplo. AWS renta la g6f.large con 1/8 de una L4 (≈ 3 GB) por ≈ US$0.20 la hora. Alba puede servir modelos chicos de otros equipos en sus T4, que trabajan al ≈ 5 % (58 de 1,200 fotos por segundo).
Acelerador propio de la nubecustom cloud accelerator (TPU, Inferentia, Trainium)Chips para aprendizaje automático (ML) diseñados por la misma nube: las TPU de Google, e Inferentia y Trainium de AWS (Amazon). Suelen salir más baratos por predicción, a cambio de compilar con otra herramienta y quedar más atado a esa nube.Más +
Las TPU solo existen en Google Cloud y se programan con XLA (JAX, TensorFlow, PyTorch/XLA). Inferentia (instancias inf2) es para inferencia y Trainium (trn) para entrenar; las dos usan el Neuron SDK de AWS, que compila el modelo para el chip. No todas las operaciones de todos los modelos funcionan igual. Se evalúan con la misma prueba de carga que una GPU, en costo por 1,000 predicciones, y aumentan la dependencia del proveedor.
Ejemplo. Un equipo compila su modelo con Neuron para una inf2 y lo compara contra una g6.xlarge con la misma prueba de carga; elige por US$ por 1,000 predicciones y por cuánto le costaría volver a GPU.
Chequeo
EsencialCheck
Intenta responder en tu cabeza antes de abrir cada respuesta.
1¿Qué rentas exactamente cuando pides una
g4dn.xlarge, y qué dice cada parte del nombre?Ver respuestaUna máquina virtual con 4 vCPU, 16 GiB de RAM y una T4. La
ges la familia de GPUs para inferencia, el4la generación,dnlos extras (disco NVMe local y red rápida) yxlargeel tamaño: 4 vCPU.2¿Por qué una T4 cuesta casi el doble en la
g4dn.12xlargeque en lag4dn.xlarge?Ver respuestaPorque la grande trae mucha más CPU y RAM por GPU: 3.912 ÷ 4 ≈ US$0.98 contra US$0.526. Para inferencia gana la instancia más chica que trae tu GPU.
3Alba paga lo mismo con 116 o con 1,200 fotos por segundo. ¿Qué cambia?Ver respuesta
El costo por predicción: de ≈ US$0.0025 a ≈ US$0.00024 por 1,000. La nube cobra horas encendidas, no trabajo.
4¿Qué decide si un trabajo puede ir en spot?Ver respuesta
Lo que pasa si te quitan la máquina con 2 minutos de aviso (30 s en Google y Azure). Si solo se repite un pedazo, sí; si un usuario ve un error, no.
5¿Cuándo conviene un compromiso con 37 % de descuento?Ver respuesta
Si usarías esa máquina más del 63 % de las horas. Por eso se compromete la base que corre todo el año, nunca el pico.
6Tienes Savings Plan y cuota de sobra. ¿Por qué puede fallar el arranque de una GPU?Ver respuesta
Porque la zona puede no tener máquinas de ese tipo (
InsufficientInstanceCapacity). El descuento no aparta nada; solo una reserva de capacidad lo garantiza.