Guía de Dimensionamiento · 10 min de lectura

# Cuántas personas puede servir realmente una GPU.

Una máquina en la que cabe su modelo no es una máquina que sirva a sus usuarios. Los pesos son un peaje que se paga una vez; lo que queda después de ellos es todo el presupuesto que tiene para servir personas. Ese remanente —no el tamaño de la tarjeta— determina su capacidad, y cambia mucho más rápido que la memoria.

La respuesta corta

- **La capacidad es el remanente, no la tarjeta:** **Llama 3.3 70B** en 4 bits reserva **40 GB** antes de servir a nadie. Cada solicitud concurrente a partir de ahí cuesta **2.9 GB** más.
- **Por eso la memoria se paga dos veces:** En una misma tarjeta, pasar de 48 GB a 240 GB multiplica la memoria por 5.0× y el número de plazas por **35×**. Los pesos ya están pagados.
- **La peor compra de la preselección:** [NVIDIA L40S](https://gpuserver.io/es/gpu/l40s) a **$714** al mes soporta 2 solicitudes concurrentes — **$357.00** por plaza.
- **La mejor opción cuesta menos:** [4 × NVIDIA L4](https://gpuserver.io/es/gpu/nvidia-l4) a **$564** da para 19 — **$29.68** por plaza, con una factura más barata.

## La versión corta

Toda guía que le dice si un modelo *cabe* responde a una pregunta sobre una sola solicitud. Un producto no es una sola solicitud. En el momento en que dos personas usan su endpoint a la vez, la máquina necesita una segunda copia de la conversación en memoria —y una tercera, y una cuadragésima—, mientras que los pesos en sí se almacenan exactamente una vez.

Así que el número que decide a cuántas personas puede servir no es el tamaño de la tarjeta. Es el tamaño de la tarjeta *menos* el modelo, dividido entre lo que cuesta una conversación. Ambos términos se conocen antes de pedir nada, lo que convierte la capacidad en una de las pocas cosas del machine learning que se pueden calcular sobre el papel y acertar.

**Los pesos son un peaje.** Se pagan una vez, al entrar, sea cual sea su tráfico. No crecen con sus usuarios y nunca se recuperan.

**La caché KV es el alquiler.** Se paga por cada solicitud concurrente, mientras esa solicitud esté abierta, y en proporción a la duración de la conversación.

**La capacidad es lo que queda, dividido entre el alquiler.** Por eso una máquina con el doble de memoria suele servir a diez veces más personas, no solo al doble.

**Y por qué la máquina más barata que cabe suele ser la peor compra.** Cabe porque casi no le queda nada, y lo que le queda es la única parte que realmente está comprando.

Todo lo que sigue aplica la misma aritmética que [el configurador](https://gpuserver.io/es/configure), sobre el mismo catálogo, en 4 bits y con 8k de contexto. Si la fórmula de la memoria en sí le resulta nueva, [tiene su propia guía](https://gpuserver.io/es/guides/vram-sizing) —esta página es lo que le ocurre cuando aparece más de una persona.

## Lo que queda después de los pesos

Tome el modelo de referencia de este sitio y colóquelo en cada tamaño de nodo construido con la misma tarjeta. Mismo silicio, mismo precio por tarjeta, todo igual —solo cambia la cantidad de memoria. Observe cómo las dos últimas columnas se mueven a velocidades completamente distintas.

**Solicitudes concurrentes para Llama 3.3 70B en 4 bits y 8k de contexto, en cada nodo construido con la misma tarjeta**

| Nodo | Memoria | Lo que queda tras los pesos | Solicitudes concurrentes | Al mes |
|---|---|---|---|---|
| [NVIDIA L4](https://gpuserver.io/es/gpu/nvidia-l4) | 24 GB | — | no cabe | $125 |
| [2 × NVIDIA L4](https://gpuserver.io/es/gpu/nvidia-l4) | 48 GB | 8 GB | 2 | $285 |
| [4 × NVIDIA L4](https://gpuserver.io/es/gpu/nvidia-l4) | 96 GB | 56 GB | 19 | $564 |
| [8 × NVIDIA L4](https://gpuserver.io/es/gpu/nvidia-l4) | 192 GB | 152 GB | 52 | $1,106 |
| [10 × NVIDIA L4](https://gpuserver.io/es/gpu/nvidia-l4) | 240 GB | 200 GB | 69 | $1,371 |

La primera fila es toda la lección: una tarjeta en la que ni siquiera caben los pesos no sirve a nadie, y no por poco. Las filas siguientes ganan memoria en pasos iguales y ganan plazas en pasos cada vez mayores, porque el peaje de 40 GB se paga en la primera fila y nunca más.

**La aritmética, en una línea.** `seats = (memory − weights) ÷ cache_per_request`. Para Llama 3.3 70B en 4 bits, son 40 GB de peaje y 2.9 GB de alquiler por cada conversación abierta. Reste antes de dividir —hacerlo al revés es como se acaba comprando una máquina para una demo y descubriendo el problema ya en producción.

## Lo que cuesta realmente un usuario

Ahora, los mismos modelos, ordenados como los ordenaría un comprador: el más barato primero. La última columna es el precio mensual dividido entre el número de personas que la máquina puede atender a la vez —la única columna que compara dos máquinas con honestidad cuando se está construyendo algo más que una demo.

Una premisa, indicada porque cambia todos los números: cada número de plazas corresponde a *una* sola instancia del modelo repartida por todo el nodo, que es lo que da `--tensor-parallel-size`. Los pesos se almacenan una vez, y cada tarjeta aporta su memoria restante a ese mismo fondo común de conversaciones. Si en cambio ejecuta dos copias separadas en el mismo nodo, paga el peaje dos veces, para menos plazas en total.

**Los diez nodos más baratos en los que cabe Llama 3.3 70B, con lo que cuesta cada uno por usuario concurrente**

| Nodo | Memoria | Al mes | Solicitudes concurrentes | Por usuario |
|---|---|---|---|---|
| [2 × NVIDIA L4](https://gpuserver.io/es/gpu/nvidia-l4) 2 tarjetas · 24 GB cada una | 48 GB | $285 | 2 | $142.50 |
| [NVIDIA RTX A6000](https://gpuserver.io/es/gpu/rtx-a6000) Una tarjeta · 48 GB | 48 GB | $286 | 2 | $143.00 |
| [2 × NVIDIA RTX 4090](https://gpuserver.io/es/gpu/rtx-4090) 2 tarjetas · 24 GB cada una | 48 GB | $416 | 2 | $208.00 |
| [4 × NVIDIA L4](https://gpuserver.io/es/gpu/nvidia-l4) 4 tarjetas · 24 GB cada una | 96 GB | $564 | 19 | $29.68 |
| [2 × NVIDIA RTX A6000](https://gpuserver.io/es/gpu/rtx-a6000) 2 tarjetas · 48 GB cada una | 96 GB | $597 | 19 | $31.42 |
| [2 × NVIDIA RTX 5090](https://gpuserver.io/es/gpu/rtx-5090) 2 tarjetas · 32 GB cada una | 64 GB | $692 | 8 | $86.50 |
| [NVIDIA L40S](https://gpuserver.io/es/gpu/l40s) Una tarjeta · 48 GB | 48 GB | $714 | 2 | $357.00 |
| [2 × NVIDIA A100 PCIe](https://gpuserver.io/es/gpu/a100-40gb) 2 tarjetas · 40 GB cada una | 80 GB | $802 | 13 | $61.69 |
| [4 × NVIDIA RTX 4090](https://gpuserver.io/es/gpu/rtx-4090) 4 tarjetas · 24 GB cada una | 96 GB | $814 | 19 | $42.84 |
| [NVIDIA A100 PCIe](https://gpuserver.io/es/gpu/a100-80gb) Una tarjeta · 80 GB | 80 GB | $1,091 | 13 | $83.92 |

Compare las dos celdas coloreadas con su columna de precio. NVIDIA L40S cuesta $714 al mes y da para 2; 4 × NVIDIA L4 cuesta $564 —*menos dinero*— y da para 19. Eso es 10× las plazas por 0.79× la factura, y la opción cara es la que casi todas las preselecciones conservan, porque es aquella en la que el modelo cabe en una sola tarjeta.

**Esto no es un argumento contra las máquinas de una sola tarjeta.** Un modelo que cabe en una sola tarjeta no necesita sharding, ni interconexión, ni flags tensor-parallel, y responde a un único usuario más rápido que ese mismo modelo repartido entre cuatro tarjetas. Si su carga es una solicitud a la vez —un trabajo por lotes, una herramienta interna, una demo—, esa máquina es la compra correcta y la columna por usuario no le importa. Esa columna solo empieza a importar cuando llegan varias personas a la vez, y a partir de ahí importa muchísimo.

En todo el catálogo, no solo en las diez primeras filas, el mejor precio por plaza para este modelo es [8 × NVIDIA RTX A6000](https://gpuserver.io/es/gpu/rtx-a6000) a $2,239 al mes: 119 solicitudes concurrentes, a $18.82 cada una. Es una factura mucho mayor que cualquiera de la preselección anterior, y aun así es la forma más barata de dar plaza a un usuario —la frase que decide si está dimensionando un producto o un prototipo.

## La longitud de contexto es el otro multiplicador

Todo lo anterior suponía 8k de contexto. Esa suposición pesa más que la elección de la máquina. La caché se paga por token además de por usuario, así que el mismo nodo da plaza a un número de personas completamente distinto según cuánto deje crecer una conversación.

Una máquina, cuatro modelos, cuatro longitudes de contexto. El nodo es [8 × NVIDIA L4](https://gpuserver.io/es/gpu/nvidia-l4) a $1,106 al mes —el más barato de nuestro catálogo en el que caben los cuatro modelos a la vez—, de modo que cada cifra de abajo se mide contra la misma memoria.

**Solicitudes concurrentes en un nodo, por modelo y longitud de contexto, en 4 bits**

| Modelo | Caché por token | 4k | 8k | 32k | 128k |
|---|---|---|---|---|---|
| Llama 3.1 8B 4 GB de pesos | 128 KiB | 325 | 162 | 40 | 10 |
| Qwen 3 32B 16 GB de pesos | 256 KiB | 150 | 75 | 18 | 4 |
| Llama 3.3 70B 35 GB de pesos | 320 KiB | 105 | 52 | 13 | 3 |
| Qwen 3 235B-A22B (MoE) 118 GB de pesos | 188 KiB | 67 | 33 | 8 | 2 |

En una misma máquina sin cambios, Llama 3.3 70B pasa de 105 usuarios concurrentes a 3 —un factor de 35×— solo por un número que se fija en la línea de comandos. El hardware no cambió en nada.

De aquí se siguen dos cosas. La primera es que la columna de contexto que debe leer es la que realmente sirve, no la que anuncia la ficha del modelo —que un modelo *admita* 128k no le obliga a reservarlo. La segunda es que la caché por token varía enormemente entre modelos de tamaño parecido, porque la determina el diseño de atención y no el número de parámetros; [los modelos más grandes de esa tabla tienen algunas de las cachés más pequeñas](https://gpuserver.io/es/guides/mixture-of-experts), el hecho más contraintuitivo de toda esta cuestión.

## Cuatro formas de recuperar capacidad

En orden descendente de cuánto dan a cambio de cuánto cuestan. La primera es casi gratuita y casi siempre se deja escapar.

Limite el contexto declarado Gratis, y la mayor ganancia Los stacks de servicio reservan caché para la longitud máxima que se declara, no para la que se usa. Declarar 128k y servir 8k desperdicia dieciséis veces la memoria que necesitaba —y esa memoria era toda su capacidad de plazas. Fije `--max-model-len` en su límite real desde el primer día.

Cuantice la caché a 8 bits Duplica aproximadamente las plazas Cuantizar los *pesos* a 4 bits no le hace nada a la caché: se queda en 16 bits en cualquier stack habitual, a menos que se le pida lo contrario. Pedirlo es un solo flag, el coste en calidad suele ser invisible en cargas de chat, y la tabla de abajo es lo que se obtiene a cambio.

Cuantice más los pesos Ayuda una vez, luego nada Reducir los pesos a la mitad entrega esa diferencia directamente a la caché, así que compra plazas en una máquina saturada. Pero es una ganancia puntual frente a un peaje fijo, y cuesta calidad —[qué formato cuesta cuánto](https://gpuserver.io/es/guides/awq-vs-gptq-vs-fp8) es una decisión aparte.

Alquile el remanente, no la tarjeta La solución estructural Cada palanca anterior actúa sobre el margen. Pasar a un nodo cuya memoria supera sus pesos por un margen amplio cambia la naturaleza del problema, y es la única de las cuatro que sigue dando resultado a medida que crece.

**Solicitudes concurrentes en el mismo nodo con caché de 16 bits y con caché de 8 bits, a 8k de contexto**

| Modelo | Caché de 16 bits | Caché de 8 bits | Plazas ganadas |
|---|---|---|---|
| Llama 3.1 8B | 162 | 325 | +163 |
| Qwen 3 32B | 75 | 150 | +75 |
| Llama 3.3 70B | 52 | 105 | +53 |
| Qwen 3 235B-A22B (MoE) | 33 | 67 | +34 |

Mismo nodo, mismos pesos, mismo dinero. Lo único que cambia es la precisión en la que se almacena la caché, y esa es la diferencia entre una máquina que sirve a un equipo y una máquina que sirve a un producto.

## Las plazas no son lo mismo que el servicio

Una corrección antes de dimensionar nada con los números anteriores, y es la que mantiene esta página honesta. Todo lo de aquí cuenta cuántas conversaciones puede mantener *abiertas* la máquina. No promete que todas se estén respondiendo con rapidez.

La memoria y el ancho de banda son dos límites distintos. En [8 × NVIDIA L4](https://gpuserver.io/es/gpu/nvidia-l4), Llama 3.3 70B tiene sitio para 52 conversaciones concurrentes, mientras que un único usuario solo en esa máquina ve unos 17 tokens por segundo. Llenar las 52 plazas no da a cada una 17 tokens por segundo —la generación comparte el mismo ancho de banda de memoria, así que el total sube con el procesamiento por lotes y la tasa por usuario baja. El límite de ancho de banda se alcanza mucho antes que el de memoria.

**Use el número de plazas como límite, no como objetivo.** Una máquina cargada hasta su última plaza es una máquina en la que todo el mundo espera. El número de plazas le dice qué hardware es siquiera capaz de su concurrencia —elimina las máquinas que no lo son, que es la mayor parte de la preselección— y después mide la velocidad que realmente quiere por usuario y se aleja del límite. Dimensionar al límite es la segunda forma más habitual de comprar la máquina equivocada, justo después de ignorar la caché por completo.

La buena noticia es que los dos límites se mueven juntos: las máquinas a las que les queda mucha memoria después de los pesos son, salvo pocas excepciones, también las que tienen más ancho de banda. Elegir por margen rara vez le cuesta velocidad. [Configurar el stack de servicio](https://gpuserver.io/es/guides/serve-llama-70b) en la máquina que termine eligiendo es una guía aparte, y los flags que cubre son donde estas cifras se hacen realidad.

## Elegir según su número de usuarios

En orden. Deténgase en la primera línea que describa su carga.

1. **Una solicitud a la vez.** Trabajos por lotes, una herramienta interna, un solo desarrollador. Compre la máquina más barata donde el modelo quepa en una sola tarjeta y deje de leer aquí: cada columna de esta página responde a una pregunta que usted no tiene.
2. **Un puñado de personas, de vez en cuando.** Una herramienta de equipo, un producto incipiente. Calcule su pico de solicitudes concurrentes, no su número de usuarios: cien usuarios registrados rara vez significan más de un puñado simultáneo. Luego elija la máquina más barata cuyo número de plazas supere ese pico con holgura.
3. **Un producto real con tráfico real.** Ordene el catálogo por precio por plaza y no por precio, limite el contexto a lo que realmente sirve, baje la caché a 8 bits, y espere que la ganadora sea una máquina que no habría preseleccionado por su precio mensual.
4. **Documentos largos o conversaciones largas.** Lea primero la tabla de contexto y después la de máquinas. A partir de 32k, la caché domina tanto que el modelo elegido importa menos que el diseño de atención que hay detrás.
5. **Tráfico irregular e impredecible.** Dimensione para el pico que no puede permitirse fallar, porque la caché no se puede pedir prestada cuando se agota: una solicitud que no tiene dónde colocar su conversación espera en una cola. Si el pico es raro y enorme, [una API por token para el desbordamiento](https://gpuserver.io/es/guides/api-vs-self-hosting) sale más barata que una máquina dimensionada para un pico que ocurre dos veces al mes.

Sea cual sea la línea en la que se haya detenido, haga la resta antes que cualquier otra cosa: tome la memoria de la máquina, quite los pesos de su modelo en la precisión que va a servir, y mire lo que queda. Ese remanente es el producto que está alquilando. El [configurador](https://gpuserver.io/es/configure) aplica esta misma aritmética a todos los nodos que operamos, y [lo que cuesta un mes de eso](https://gpuserver.io/es/guides/monthly-vs-hourly) se calcula aparte.

## Dimensione la máquina según los usuarios, no según el modelo.

El configurador incluye todos los nodos que alquilamos, aplica la misma aritmética de memoria que esta página, y muestra lo que queda una vez cargado su modelo —antes de que pague nada.

[Abrir el configurador](https://gpuserver.io/es/configure) [Leer las guías](https://gpuserver.io/es/guides)

## Otras guías

- [Coste · 6 min Cuándo el alquiler mensual gana al alquiler por horas El punto de equilibrio con cifras reales, los tres costes que un precio por hora oculta hasta la factura, y la trampa del tiempo inactivo que la triplica. Leer la guía](https://gpuserver.io/es/guides/monthly-vs-hourly)
- [Coste · 9 min Autoalojamiento frente a una API por token El punto de equilibrio entre pagar una API por token y alquilar una GPU, con nuestros precios y rendimiento reales — y las cuatro cosas que la aritmética omite. Leer la guía](https://gpuserver.io/es/guides/api-vs-self-hosting)
- [Práctica · 11 min Servir Llama 3.3 70B en un nodo De una máquina entregada a un endpoint compatible con OpenAI, con los parámetros que importan y los dos que reducen a la mitad su rendimiento sin avisar. Leer la guía](https://gpuserver.io/es/guides/serve-llama-70b)

---

Fuente: https://gpuserver.io/es/guides/concurrent-users/. Este archivo se genera a partir de los mismos datos que el sitio web; si una cifra aquí difiere de la de una página, prevalece la página y este archivo está desactualizado: la fuente canónica es https://gpuserver.io/.