SenseiTeoría desde cero0/59

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.

⏱ 66 min lo esencial · 79 min todo20 conceptos nuevos2 calculadoras10 ejerciciosModelo y Orquestación
Secciones14
  1. 01La instancia: lo que de verdad rentas
  2. 02Las GPUs que se rentan
  3. 03La GPU-hora: el mismo chip, muchos precios
  4. 04Hora facturada contra hora trabajando
  5. 05On-demand y spot
  6. 06Compromisos: pagar menos a cambio de un plazo
  7. 07Cuotas, capacidad y reservas
  8. 08Más allá de una GPU entera extra
  9. 09Errores comunes
  10. 10En la vida real extra
  11. 11Ejercicios
  12. 12Lo que sigue extra
  13. 13Palabras que vas a oír
  14. 14Chequeo
La pregunta

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.

01

La instancia: lo que de verdad rentas

Esencial

The 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.

Cómo se lee el nombre de una instancia de AWS. Primer ejemplo, g4dn.xlarge, partido en cuatro piezas: g es la familia, GPUs para inferencia; 4 es la generación; dn son extras, d de disco NVMe local y n de red más rápida; xlarge es el tamaño, 4 vCPU. Segundo ejemplo, p5.48xlarge: p es la familia de GPUs grandes; 5 es la generación; 48xlarge es el tamaño, 48 por 4 igual a 192 vCPU, con 8 GPUs H100. CÓMO SE LEE EL NOMBRE g 4 dn . xlarge g · familia: GPUs para inferencia 4 · generación (la 6 es más nueva) dn · extras: disco NVMe local, red rápida xlarge · tamaño: 4 vCPU, 1 T4 p 5 . 48xlarge p · familia: GPUs grandes 5 · generación 48xlarge · 48 × 4 = 192 vCPU, 8 H100
El nombre de una instancia de AWS, por partes. Arriba, la de Alba; abajo, la de ocho H100. La regla de los tamaños (cada «xlarge» son 4 vCPU) se cumple en las instancias de las tablas.
  • 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 g6 es más nueva que una g4dn, 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. La i de c6i dice que el procesador es de Intel.
  • Después del punto, el tamaño. large son 2 vCPU y xlarge son 4. El número de adelante multiplica esos 4: 2xlarge son 2 × 4 = 8, 12xlarge son 48 y 48xlarge son 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.

InstanciavCPURAMGPUs≈ US$/h (us-east-1, nov. 2026)
c6i.xlarge (el gateway de Alba)48 GiBninguna0.17
g4dn.xlarge (Alba)416 GiB1 × T40.526
g6.xlarge416 GiB1 × L40.805
g5.xlarge416 GiB1 × A10G1.006
g6e.xlarge432 GiB1 × L40S1.861
g4dn.12xlarge48192 GiB4 × T43.912
p5.48xlarge1922,048 GiB8 × H10055.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.

02

Las GPUs que se rentan

Esencial

The 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.

GPUVRAMAncho de bandaFP16 densoBF16 · FP8Potencia≈ US$ por GPU-hora en AWS (us-east-1)
T4 (2018)16 GB GDDR6320 GB/s65 TFLOPSNo · No70 W0.526 (g4dn.xlarge)
L4 (2023)24 GB GDDR6300 GB/s121Sí · Sí72 W0.805 (g6.xlarge)
A10G (2021)24 GB GDDR6600 GB/s70Sí · No300 W1.006 (g5.xlarge)
L40S (2023)48 GB GDDR6864 GB/s362Sí · Sí350 W1.861 (g6e.xlarge)
A100 80 GB (2020)80 GB HBM2e2,039 GB/s312Sí · No400 W3.43 (p4de.24xlarge ÷ 8)
H100 SXM (2022)80 GB HBM33,350 GB/s989.5Sí · Sí700 W6.88 (p5.48xlarge ÷ 8)
H200 (2023)141 GB HBM3e4,800 GB/s989.5Sí · Sí700 W7.91 (p5en.48xlarge ÷ 8)
B200 (2024)180 GB HBM3e≈ 8,000 GB/s2,250Sí · Síhasta 1,000 W14.24 (p6-b200.48xlarge ÷ 8)
AMD MI300X (2023)192 GB HBM35,300 GB/s1,300Sí · 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.

GPUGoogle Cloud (us-central1)Azure (East US)Neocloud
T4US$0.35 la GPU más la VM que la hospeda0.526 (NC4as_T4_v3)—
L40.71 (g2-standard-4)—RunPod 0.69
A100 80 GB5.07 por GPU (a2-ultragpu-1g)3.67 (NC24ads_A100_v4, PCIe)Lambda 3.19 · RunPod 2.19
H10011.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.

03

La GPU-hora: el mismo chip, muchos precios

Esencial

The 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:

GPU-hora y costo al mes
c=PG
cmes=c×730
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$
De la hora al mes, y de la instancia a la GPULa cuenta
Una T4 de Albag4dn.xlarge, us-east-1, nov. 2026: P = 0.526, G = 1
cmes=c×730 = 0.526 × 730
≈ US$384 al mes
Las dos de Albauna por zona
2 × 384
≈ US$768 al mes
Ocho H100p5.48xlarge: P = 55.04, G = 8
c=P÷G = 55.04 ÷ 8
≈ US$6.88 por GPU-hora
Una H100 todo el mes
cmes = 6.88 × 730
≈ US$5,022
Resultado
La nube cobra por hora; para planear se multiplica por 730, las horas de un mes promedio (8,760 ÷ 12).

El 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÷G = 3.912 ÷ 4 ≈ US$0.978 por GPU-hora. Casi el doble.

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.

Python
# 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} ¢")
Salida
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
Precio on-demand de una hora de la misma GPU H100 SXM según el proveedor, en dólares por GPU-hora, noviembre de 2026. Azure, East US: 12.29. Google Cloud, us-central1: 11.06. AWS, us-east-1: 6.88. Lambda, vigente desde el 16 de noviembre: 4.59. RunPod: 4.39. Las tres primeras son nubes de hiperescala y las dos últimas, neoclouds. Una H100 todo el mes cuesta cerca de 8,972 dólares en Azure y cerca de 3,205 en RunPod. LA MISMA H100 SXM, CINCO PRECIOS US$ por GPU-hora, on-demand, nov. 2026 Azure HIPERESCALA 12.29 Google HIPERESCALA 11.06 AWS HIPERESCALA 6.88 Lambda NEOCLOUD 4.59 RunPod NEOCLOUD 4.39 Todo el mes: ≈ US$8,972 en Azure, ≈ 3,205 en RunPod. Lambda: precio vigente desde el 16 de noviembre.
Lo que cuesta una hora de la misma H100 SXM según quién la rente, en noviembre de 2026 (RunPod: su Secure Cloud). La más cara cuesta casi tres veces la más barata.

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.xlarge para abrir y cortar en pedazos las enormes imágenes de microscopio, y se usa la g6.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.

04

Hora facturada contra hora trabajando

Esencial

Billed 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=P×h: el precio por hora P de la instancia por las horas h del mes. Con una 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:

Costo por 1,000 predicciones
F=c×r×730
Q=T×3,600×730
K=FQ÷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=T÷(r×m), donde m es el máximo de predicciones por segundo que aguanta una GPU (se mide en una prueba de carga). El T de la fórmula no es lo que la GPU podría hacer: es lo que de verdad le llega. Si trabajara a tope (T=r×m), la fórmula se simplifica a Ktope=c÷(m×3,600÷1,000): el costo por 1,000 de una GPU a tope.

Lo que cuestan 1,000 predicciones de AlbaLa cuenta
Si la T4 trabajara a tope, Ktopem ≈ 1,200 fotos/s, medidas por el equipo de Alba
Ktope=c÷(m×3,600÷1,000) = 0.526 ÷ (1,200 × 3,600 ÷ 1,000)
≈ US$0.00012
A la capacidad planificada600 fotos/s en vez de m: se planea a la mitad del máximo, para dejar margen
0.526 ÷ (600 × 3,600 ÷ 1,000)
≈ US$0.00024
Lo que de verdad llega, QT ≈ 116 fotos/s en promedio, entre las dos
Q=T×3,600×730 = 116 × 3,600 × 730
≈ 304.8 M al mes
Lo que se paga, Fr = 2 T4 todo el mes
F=c×r×730 = 0.526 × 2 × 730
≈ US$768 al mes
Costo real, K
K=F÷(Q÷1,000) = 768 ÷ (304.8 M ÷ 1,000)
≈ US$0.0025
Utilización, u
u=T÷(r×m) = 116 ÷ (2 × 1,200)
≈ 4.8 %
Resultado
El costo real es ≈ 20 veces el de la GPU a tope (K÷Ktope = 0.0025 ÷ 0.00012), porque cada T4 trabaja al ≈ 5 %.

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.

Python
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")
Salida
  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,000

La 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.

Lo que cuesta cada predicciónCalculadora

La factura depende de cuántas GPUs tienes encendidas; el costo por predicción, de cuánto trabajo les llega. La calculadora aplica F=c×r×730, Q=T×3,600×730, K=F÷(Q÷1,000) y u=T÷(r×m). Arranca con Alba, el marketplace del curso: 2 T4 (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.

Factura al mes, F, en US$F=c×r×730; no depende del tráfico768
Predicciones al mes, QQ=T×3,600×730; si T pasa de r×m, solo cuenta lo que las GPUs alcanzan a atender304,848,000
Utilización de las GPUs, uu=T÷(r×m): tráfico ÷ lo que aguantan todas juntas; si llega a 100 %, faltan GPUs y lo que sobra no se atiende4.8 %
US$ por 1,000 predicciones con este tráfico, KK=F÷(Q÷1,000)0.00252
US$ por 1,000 si la GPU trabajara a tope, KtopeKtope=c÷(m×3,600÷1,000)0.00012
Cuántas veces más caro que a topeK÷Ktope20.7×

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):

Terminal
aws ec2 create-tags --resources i-0abc123de456f7890 \
  --tags Key=equipo,Value=catalogo Key=modelo,Value=alba-categorias Key=ambiente,Value=staging

Con 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».

05

On-demand y spot

Esencial

On-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 checkpointsSíPierdes lo que no estaba guardado y sigues
Trabajos por lotes (batch) y asíncronos, idempotentes, como la segmentación de imágenes médicasSíEl mensaje vuelve a la cola y otro lo hace
Backfills, CI, pruebasSíNadie espera la respuesta en segundos
Réplicas extra para una ráfagaCon cuidadoSi se van, las demás aguantan un rato
El mínimo en línea (las 2 T4 de Alba)NoUn 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.

Trabajo en spot: cola, checkpoint y otra máquina · Toca cada caja para ver por qué está ahí. Los dos recorridos cuentan un pedazo normal y uno que se interrumpe a la mitad.
  • 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 (una g4dn.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.xlarge en 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.

Python
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")
Salida
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 promedio

Con 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=1−Ps÷P: uno menos el precio spot Ps entre el on-demand P (en la T4, 1 − 0.27 ÷ 0.526 ≈ 49 %).

InstanciaOn-demandSpot observadoDescuento
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:

Lo que cuesta un trabajo en spot
Fod=P×h
Fs=Ps×(h+hrep)
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$
Un fine-tune de 40 horas en spotLa cuenta
On-demand, Fodg5.xlarge, us-east-1: P = 1.006, h = 40
Fod=P×h = 1.006 × 40
≈ US$40.24
Horas repetidas, hrep4 interrupciones; cada una repite ≈ 25 min
4 × 25 ÷ 60
≈ 1.67 h
Spot, FsPs ≈ 0.462 (la tabla lo redondea a 0.46)
Fs=Ps×(h+hrep) = 0.462 × (40 + 1.67)
≈ US$19.25
Ahorro
1−Fs÷Fod = 1 − 19.25 ÷ 40.24
≈ 52 %
Resultado
Del ≈ 54 % de descuento spot de ese día quedan ≈ 52 % después de repetir trabajo: sigue valiendo la pena, porque los checkpoints son frecuentes.
06

Compromisos: pagar menos a cambio de un plazo

Esencial

Commitments: 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∗:

On-demand contra compromiso
Fod=P×h
Fc=P×(1−d)×730
h∗=730×(1−d)
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×(1−d) = 0.526 × 0.63 ≈ US$0.331 la hora, y Fc = 0.331 × 730 ≈ US$242 al mes. El punto de equilibrio es h∗ = 730 × 0.63 ≈ 460 horas. Dividido entre 730, eso dice que el compromiso conviene solo si usarías la máquina más de 1−d = 63 % de las horas.

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?».

Un día de GPUs de un sistema en línea, un ejemplo. El eje horizontal son las 24 horas y el vertical, cuántas GPUs están encendidas, de 0 a 6. Abajo, una franja de 2 GPUs que nunca se apaga en todo el día: la base, que se compromete con un Savings Plan. Encima, de las 7 a las 18 horas hay 1 GPU más, y de las 18 a las 22 horas, 2 más: el pico, que va on-demand. De la 1 a las 5 de la madrugada hay 3 GPUs más para un backfill que puede repetirse: esas van en spot. UN DÍA DE GPUs (EJEMPLO) GPUs encendidas, hora por hora 0 2 4 6 0 h 6 12 18 24 Base · nunca se apaga: compromiso Pico · sube y baja: on-demand Backfill · se puede repetir: spot Comprometer el pico: pagar 4 GPUs las 24 horas.
Un día de GPUs de un sistema en línea. La franja de abajo nunca se apaga: esa se compromete. Lo que sube y baja con el tráfico va on-demand. El trabajo de la madrugada, que puede repetirse, va en spot.

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×1,016: ≈ US$305–406 al mes. Lo que no se compromete es el máximo del autoscaler (el programa que enciende y apaga réplicas según el tráfico; lo verás en autoscaling): las réplicas que existen solo en las horas pico.

El error de comprometer el picoLa cuenta
Comprometer las 4 T4el máximo del autoscaler de Alba; P×(1−d) ≈ 0.331
4×Fc = 4 × 0.331 × 730
≈ US$967 al mes
Pagarlas on-demanden promedio hay ≈ 2.33 T4 encendidas: las 2 de siempre, más las que el autoscaler agrega unas horas al día
Fod=P×h, por 2.33 T4 = 2.33 × 0.526 × 730
≈ US$895 al mes
Diferencia
967 − 895
≈ US$72 al mes
Uso de las 4 comprometidas
2.33 ÷ 4
≈ 58 %
Resultado
Comprometer el pico cuesta ≈ US$72 más al mes que no comprometer nada. Usarías las 4 T4 solo ≈ 58 % de las horas, menos que el 1−d = 63 % que pide el descuento.

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.

On-demand, compromiso o spotCalculadora

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=P×h, Fc=P×(1−d)×730, Fs=P×(1−s)×(h+hrep) y h∗=730×(1−d).

On-demand, Fod, en US$ al mesFod=P×h: solo las horas que usas263
Comprometida, Fc, en US$ al mesFc=P×(1−d)×730: las 730 horas, la uses o no242
Spot, Fs, en US$ al mesFs=P×(1−s)×(h+hrep); solo si el trabajo aguanta que te quiten la máquina148
Uso del mesh÷73068.5 %
El compromiso gana desde estas horas al mes, h∗h∗=730×(1−d)460
Lo que ahorra el compromiso contra on-demand1−Fc÷Fod; negativo: pagas por horas que no usas8.0 %

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∗=730×(1−d), ≈ 460 horas con d = 37 %. Luego baja el descuento de spot a 1 %, el que tenía la L40S el día de la foto.

07

Cuotas, capacidad y reservas

Esencial

Quotas, 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.

De «necesito otra GPU» a «la GPU ya atiende» · Toca cada caja; los recorridos cuentan el caso feliz, las dos maneras de quedarte sin máquina y lo que cambia una reserva.
  • 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 en us-east-1b o se pide una g4dn.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: cada g4dn.xlarge gasta 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 responde InsufficientInstanceCapacity, 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.xlarge gasta 4 vCPU de la cuota G; una p5.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=máquinas×vCPU: las máquinas que puede haber en el peor momento, por los vCPU de cada una. En Alba:

La cuota de AlbaLa cuenta
Máximo del autoscalerpara el pico de diseño, 500 fotos por segundo
4
4 máquinas
Más una de sobra al desplegar una versión nuevael surge: la versión nueva arranca antes de apagar la vieja
4 + 1
5 máquinas
Más staging y CIuna para cada uno
5 + 1 + 1
7 máquinas
Totalcada g4dn.xlarge gasta 4 vCPU
7 × 4 vCPU
28 vCPU de instancias G
Resultado
Si el cluster puede usar también g4dn.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):

Terminal
aws service-quotas get-service-quota --region us-east-1 \
  --service-code ec2 --quota-code L-DB2E81BA

Segundo 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á haya g4dn.2xlarge (la misma T4) o g6.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.xlarge en us-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-demandNoNoNo
SpotSí, ≈ 25–55 % (inferencia), a veces nadaNo, y te la quitanNo
Savings Plan, RI regional, CUD flexibleSí, ≈ 35–37 % a 1 añoNoSí, el compromiso
Reserva de capacidadNo (salvo que la combines con un Savings Plan)SíSí
Bloque de capacidadPrecio propioSí, en sus fechasSí, por adelantado
08

Más allá de una GPU entera

Extra

Beyond 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 (la g4-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=A÷P, con A el precio de compra y P la renta por hora.

¿Cuántas horas de renta pagan la tarjeta?La cuenta
Horas de renta que valen lo mismo, heqA = 16,399 · P = 2.69
heq=A÷P = 16,399 ÷ 2.69
≈ 6,096 horas
En meses, encendida 24/7
6,096 ÷ 730
≈ 8.4 meses
Si solo la usas 8 h al día8 × 30.4 días ≈ 243 h al mes
6,096 ÷ 243
≈ 25 meses
Resultado
Comprar gana si la vas a usar casi todo el tiempo durante años. Si la usas poco, rentar gana por mucho. Y con la renta más barata (≈ US$1.69 en el Community Cloud de RunPod) el punto de equilibrio se aleja a 16,399 ÷ 1.69 ≈ 9,700 horas, más de 13 meses 24/7.

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.

09

Errores comunes

Esencial

Common 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.

10

En la vida real

Extra

In 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.

11

Ejercicios

Esencial

Exercises

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.

  1. 1Fácil

    La g6e.12xlarge trae 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 la g6e.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÷G, con P = 10.49 y G = 4: 10.49 ÷ 4 ≈ US$2.62 por GPU-hora.
    • 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.
  2. 2Fácil

    ¿Cuánto cuesta al mes una p5.48xlarge encendida 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÷G = 55.04 ÷ 8 = 6.88 por hora; cmes=c×730 = 6.88 × 730 ≈ US$5,022 al mes.
  3. 3Fácil

    La g4dn.xlarge trae 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.
  4. 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.
  5. 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×r×730, Q=T×3,600×730 y K=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÷(TGPU×3,600÷1,000), 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.
  6. 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×h, Ps=P×(1−s) y Fs=Ps×(h+hrep), con P = 0.8048, h = 23 y s = 0.25.
    • 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.
  7. 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×h, Fc=P×(1−d)×730 y h∗=730×(1−d), con P = 0.98, h = 450 y d = 0.35.
    • 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.
  8. 8Medio

    Un sistema en us-east-1 tiene un autoscaler que llega a 6 g5.xlarge, despliega con 1 de sobra, y tiene una de staging. Sus workers de batch corren en spot, 4 g4dn.2xlarge como máximo. ¿Qué cuotas pide y de cuántos vCPU?

    Ver la solución paso a paso
    • La regla: cuota=máquinas×vCPU (las máquinas en el peor momento, por los vCPU de cada una), una cuota por grupo de familias.
    • 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.
  9. 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÷S y Ktok=P÷(v×3,600)×106, 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×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.
  10. 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÷(P−W×L): 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.
    • (a) La luz al mes: W×730×L = 0.6 × 730 = 438 kWh; 438 × 0.15 ≈ US$66 al mes.
    • (b) Cada hora propia ahorra P−W×L = 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.
    • (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.
12

Lo que sigue

Extra

What 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.

13

Palabras que vas a oír

Esencial

Words 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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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.

Ver en el glosario →

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).

Ver en el glosario →

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.

Ver en el glosario →

14

Chequeo

Esencial

Check

Intenta responder en tu cabeza antes de abrir cada respuesta.

  1. 1¿Qué rentas exactamente cuando pides una g4dn.xlarge, y qué dice cada parte del nombre?Ver respuesta

    Una máquina virtual con 4 vCPU, 16 GiB de RAM y una T4. La g es la familia de GPUs para inferencia, el 4 la generación, dn los extras (disco NVMe local y red rápida) y xlarge el tamaño: 4 vCPU.

  2. 2¿Por qué una T4 cuesta casi el doble en la g4dn.12xlarge que en la g4dn.xlarge?Ver respuesta

    Porque 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.

  3. 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. 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. 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.

  6. 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.

Repasar los 20 conceptos de esta lección con tarjetas Sigue · 41Redes en la nube: VPC, subredes y egressLa nube ← 39 · Regiones, zonas y disponibilidad