Dimensionamento guia · 10 min de leitura

# Quantas pessoas uma GPU realmente atende.

Uma máquina que comporta o seu modelo não é uma máquina que atende os seus usuários. Os pesos são um pedágio, pago uma vez; o que sobra depois deles é todo o orçamento que você tem para atender pessoas. Essa sobra — não o tamanho da placa — decide a sua capacidade, e ela muda muito mais rápido do que a memória.

A resposta curta

- **A capacidade é a sobra, não a placa:** **Llama 3.3 70B** em 4 bits reserva **40 GB** antes de atender qualquer pessoa. Cada requisição simultânea depois dessa custa mais **2.9 GB**.
- **Por isso a memória paga duas vezes:** Na mesma placa, ir de 48 GB para 240 GB multiplica a memória por 5.0× e o número de vagas por **35×**. Os pesos já estão pagos.
- **A pior compra da pré-seleção:** [NVIDIA L40S](https://gpuserver.io/pt/gpu/l40s) por **$714** ao mês comporta 2 requisições simultâneas — **$357.00** por vaga.
- **A melhor custa menos:** [4 × NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) por **$564** comporta 19 — **$29.68** por vaga, com uma fatura mais barata.

## A versão resumida

Todo guia que diz se um modelo *cabe* está respondendo a uma pergunta sobre uma única requisição. Um produto não é uma única requisição. No momento em que duas pessoas usam o seu endpoint ao mesmo tempo, a máquina precisa de uma segunda cópia da conversa na memória — e uma terceira, e uma quadragésima — enquanto os pesos em si ficam armazenados exatamente uma vez.

Então o número que decide quantas pessoas você consegue atender não é o tamanho da placa. É o tamanho da placa *menos* o modelo, dividido pelo que custa uma conversa. Os dois termos são conhecidos antes de você pedir qualquer coisa, o que faz da capacidade uma das poucas coisas em machine learning que dá para calcular no papel e acertar.

**Os pesos são um pedágio.** Pago uma vez, na entrada, seja qual for o seu tráfego. Eles não crescem com os seus usuários e nunca voltam.

**O cache de chave/valor é o aluguel.** Pago por requisição simultânea, enquanto essa requisição estiver aberta, e proporcional à duração da conversa.

**A capacidade é o que sobra, dividido pelo aluguel.** É por isso que uma máquina com o dobro de memória muitas vezes atende dez vezes mais pessoas, em vez de apenas o dobro.

**E por que a máquina mais barata que cabe costuma ser o pior custo-benefício.** Ela cabe porque quase não sobra nada, e o que sobra é a única parte que você está realmente comprando.

Tudo abaixo segue a mesma aritmética do [configurador](https://gpuserver.io/pt/configure), no mesmo catálogo, em 4 bits com 8k de contexto. Se a fórmula de memória em si for nova para você, [ela tem um guia só dela](https://gpuserver.io/pt/guides/vram-sizing) — esta página é o que acontece com ela quando mais de uma pessoa aparece.

## O que sobra depois dos pesos

Pegue o modelo de referência deste site e coloque-o em cada tamanho de nó construído a partir da mesma placa. Mesmo silício, mesmo preço por placa, tudo igual — só a quantidade de memória muda. Observe as duas últimas colunas se movendo em velocidades completamente diferentes.

**Requisições simultâneas para Llama 3.3 70B em 4 bits e 8k de contexto, em cada nó construído a partir da mesma placa**

| Nó | Memória | Sobra depois dos pesos | Requisições simultâneas | Por mês |
|---|---|---|---|---|
| [NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) | 24 GB | — | não o comporta | $125 |
| [2 × NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) | 48 GB | 8 GB | 2 | $285 |
| [4 × NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) | 96 GB | 56 GB | 19 | $564 |
| [8 × NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) | 192 GB | 152 GB | 52 | $1,106 |
| [10 × NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) | 240 GB | 200 GB | 69 | $1,371 |

A primeira linha é a lição inteira: uma placa que nem sequer comporta os pesos não atende ninguém, e não chega nem perto. As linhas seguintes ganham memória em passos iguais e ganham vagas em passos cada vez maiores, porque o pedágio de 40 GB é pago na primeira linha e nunca mais.

**A aritmética, em uma linha.** `vagas = (memória − pesos) ÷ cache_por_requisição`. Para Llama 3.3 70B em 4 bits, isso é 40 GB de pedágio e 2.9 GB de aluguel por conversa aberta. Subtraia antes de dividir — fazer na ordem contrária é como uma máquina acaba comprada para uma demonstração e o erro só aparece em produção.

## O que um usuário realmente custa

Agora os mesmos modelos, ordenados da forma como um comprador os ordena: mais barato primeiro. A última coluna é o preço mensal dividido pelo número de pessoas que a máquina comporta de uma vez — a única coluna que compara duas máquinas com honestidade quando você está construindo algo além de uma demonstração.

Uma suposição, declarada porque muda cada número: cada número de vagas vale para *uma única* instância do modelo distribuída por todo o nó, que é o que `--tensor-parallel-size` oferece. Os pesos ficam armazenados uma vez, e cada placa contribui com a sua memória restante para o mesmo pool de conversas. Rode duas cópias separadas no mesmo nó, em vez disso, e você paga o pedágio duas vezes, por um total menor de vagas.

**Os dez nós mais baratos que comportam Llama 3.3 70B, com o que cada um custa por usuário simultâneo**

| Nó | Memória | Por mês | Requisições simultâneas | Por usuário |
|---|---|---|---|---|
| [2 × NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) 2 placas · 24 GB cada | 48 GB | $285 | 2 | $142.50 |
| [NVIDIA RTX A6000](https://gpuserver.io/pt/gpu/rtx-a6000) Uma placa · 48 GB | 48 GB | $286 | 2 | $143.00 |
| [2 × NVIDIA RTX 4090](https://gpuserver.io/pt/gpu/rtx-4090) 2 placas · 24 GB cada | 48 GB | $416 | 2 | $208.00 |
| [4 × NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) 4 placas · 24 GB cada | 96 GB | $564 | 19 | $29.68 |
| [2 × NVIDIA RTX A6000](https://gpuserver.io/pt/gpu/rtx-a6000) 2 placas · 48 GB cada | 96 GB | $597 | 19 | $31.42 |
| [2 × NVIDIA RTX 5090](https://gpuserver.io/pt/gpu/rtx-5090) 2 placas · 32 GB cada | 64 GB | $692 | 8 | $86.50 |
| [NVIDIA L40S](https://gpuserver.io/pt/gpu/l40s) Uma placa · 48 GB | 48 GB | $714 | 2 | $357.00 |
| [2 × NVIDIA A100 PCIe](https://gpuserver.io/pt/gpu/a100-40gb) 2 placas · 40 GB cada | 80 GB | $802 | 13 | $61.69 |
| [4 × NVIDIA RTX 4090](https://gpuserver.io/pt/gpu/rtx-4090) 4 placas · 24 GB cada | 96 GB | $814 | 19 | $42.84 |
| [NVIDIA A100 PCIe](https://gpuserver.io/pt/gpu/a100-80gb) Uma placa · 80 GB | 80 GB | $1,091 | 13 | $83.92 |

Leia as duas células coloridas junto com a sua coluna de preço. NVIDIA L40S custa $714 ao mês e comporta 2; 4 × NVIDIA L4 custa $564 — *menos dinheiro* — e comporta 19. Isso é 10× as vagas por 0.79× da fatura, e a mais cara é a que a maioria das pré-seleções mantém, porque é a única em que o modelo cabe em uma única placa.

**Isto não é um argumento contra máquinas de uma única placa.** Um modelo que cabe em uma única placa não precisa de sharding, de interconexão, nem de flags de paralelismo tensorial, e responde a um único usuário mais rápido do que o mesmo modelo dividido entre quatro placas. Se a sua carga é uma requisição de cada vez — um job em lote, uma ferramenta interna, uma demonstração — essa máquina é a compra certa, e a coluna por usuário é irrelevante para você. Essa coluna só passa a importar quando as pessoas chegam ao mesmo tempo, e a partir daí importa enormemente.

Em todo o catálogo, e não apenas nas dez primeiras linhas, o melhor preço por vaga para este modelo é [8 × NVIDIA RTX A6000](https://gpuserver.io/pt/gpu/rtx-a6000) por $2,239 ao mês: 119 requisições simultâneas, a $18.82 cada. É uma fatura bem maior do que qualquer coisa na pré-seleção acima, e ainda assim é a forma mais barata de acomodar um usuário — e é essa frase que decide se você está dimensionando um produto ou um protótipo.

## O tamanho do contexto é o outro multiplicador

Tudo acima presumiu 8k de contexto. Essa suposição pesa mais do que a escolha da máquina. O cache é pago por token, além de por usuário, então o mesmo nó acomoda um número completamente diferente de pessoas dependendo de quanto você deixa uma conversa crescer.

Uma máquina, quatro modelos, quatro tamanhos de contexto. O nó é [8 × NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) por $1,106 ao mês — o mais barato do nosso catálogo que comporta os quatro modelos ao mesmo tempo, de modo que todo número abaixo é medido contra a mesma memória.

**Requisições simultâneas em um nó, por modelo e tamanho do contexto, em 4 bits**

| Modelo | Cache 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 |

Em uma única máquina, sem nenhuma alteração, Llama 3.3 70B passa de 105 usuários simultâneos para 3 — um fator de 35× — só por causa de um número que você define na linha de comando. Nada no hardware mudou.

Duas coisas decorrem disso. A primeira é que a coluna de contexto que você deve ler é a que você realmente atende, não a que a ficha do modelo anuncia — um modelo que *suporta* 128k não obriga você a reservá-lo. A segunda é que o cache por token varia enormemente entre modelos de tamanho semelhante, porque ele é definido pelo design de atenção, e não pelo número de parâmetros; [os maiores modelos dessa tabela têm alguns dos menores caches](https://gpuserver.io/pt/guides/mixture-of-experts), o que é o fato mais contraintuitivo de toda essa área.

## Quatro formas de recuperar capacidade

Em ordem decrescente de quanto entregam pelo quanto custam. A primeira é praticamente grátis e quase sempre fica sem ser aproveitada.

Limite o contexto declarado Grátis, e o maior ganho Os stacks de inferência reservam cache para o tamanho máximo que você declara, não o tamanho que você usa. Declarar 128k e servir 8k desperdiça dezesseis vezes a memória que você precisava — e essa memória era toda a sua capacidade em vagas. Defina `--max-model-len` para o seu teto real desde o primeiro dia.

Quantize o cache para 8 bits Praticamente dobra as vagas Quantizar os *pesos* para 4 bits não faz nada ao cache: ele permanece em 16 bits em todo stack comum, a menos que você peça. Pedir é uma única flag, o custo em qualidade costuma ser invisível em cargas de trabalho de chat, e a tabela abaixo mostra o que isso retorna.

Quantize ainda mais os pesos Ajuda uma vez, depois para Reduzir os pesos pela metade repassa a diferença diretamente para o cache, então isso compra vagas em uma máquina lotada. Mas é um ganho único contra um pedágio fixo, e custa qualidade — [qual formato custa quanto](https://gpuserver.io/pt/guides/awq-vs-gptq-vs-fp8) é uma decisão à parte.

Alugue a sobra, não a placa O ajuste estrutural Toda alavanca acima age na margem. Migrar para um nó cuja memória excede os seus pesos por uma margem ampla muda a natureza do problema, e é a única das quatro que continua compensando conforme você cresce.

**Requisições simultâneas no mesmo nó com cache de 16 bits e com cache de 8 bits, em 8k de contexto**

| Modelo | cache de 16 bits | cache de 8 bits | Vagas ganhas |
|---|---|---|---|
| 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 |

Mesmo nó, mesmos pesos, mesmo dinheiro. A única mudança é a precisão em que o cache é armazenado, e é essa a diferença entre uma máquina que atende uma equipe e uma máquina que atende um produto.

## Vagas não são o mesmo que atendimento

Uma correção antes de dimensionar qualquer coisa com os números acima, e é essa correção que mantém esta página honesta. Tudo aqui conta quantas conversas a máquina consegue manter *abertas*. Isso não promete que todas estejam sendo respondidas rapidamente.

Memória e largura de banda são dois tetos diferentes. Em [8 × NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4), Llama 3.3 70B tem espaço para 52 conversas simultâneas, enquanto um único usuário sozinho nessa máquina vê cerca de 17 tokens por segundo. Preencher todas as 52 vagas não dá a cada uma delas 17 tokens por segundo — a geração compartilha a mesma largura de banda de memória, então o total agregado sobe com o processamento em lote e a taxa por usuário cai. O teto de largura de banda é atingido bem antes do teto de memória.

**Use o número de vagas como teto, não como meta.** Uma máquina carregada até a última vaga é uma máquina em que todo mundo está esperando. O número de vagas indica qual hardware sequer é capaz da sua concorrência — ele elimina as máquinas que não são, o que representa a maior parte da pré-seleção — e então você mede a taxa que realmente quer por usuário e se afasta do teto. Dimensionar pelo teto é o segundo erro mais comum na hora de comprar a máquina errada, logo depois de ignorar o cache por completo.

A boa notícia é que os dois tetos se movem juntos: as máquinas com uma grande quantidade de memória sobrando depois dos pesos são, com poucas exceções, também as máquinas com mais largura de banda. Escolher pela margem raramente custa velocidade. [Configurar o stack de inferência](https://gpuserver.io/pt/guides/serve-llama-70b) na máquina que você escolher é um guia à parte, e as flags que ele cobre são onde esses números se transformam em resultado real.

## Escolhendo para o seu próprio número de usuários

Em ordem. Pare na primeira linha que descrever a sua carga.

1. **Uma requisição de cada vez.** Jobs em lote, uma ferramenta interna, um único desenvolvedor. Compre a máquina mais barata que comporte o modelo em uma única placa e pare de ler — toda coluna desta página responde a uma pergunta que você não tem.
2. **Um punhado de pessoas, ocasionalmente.** Uma ferramenta de equipe, um produto inicial. Calcule o seu pico de requisições simultâneas, não o número de usuários: cem usuários cadastrados raramente significam mais que um punhado de simultâneos. Depois, escolha a máquina mais barata cujo número de vagas fique confortavelmente acima desse pico.
3. **Um produto real, com tráfego real.** Ordene o catálogo por preço por vaga em vez de por preço, limite o seu contexto ao que você realmente atende, reduza o cache para 8 bits, e espere que a vencedora seja uma máquina que você não teria pré-selecionado pelo preço mensal.
4. **Documentos longos ou conversas longas.** Leia primeiro a tabela de contexto, depois a tabela de máquinas. A partir de 32k, o cache domina tão completamente que a escolha do modelo importa menos do que o design de atenção por trás dele.
5. **Tráfego instável e imprevisível.** Dimensione para o pico que você não pode falhar, porque o cache não pode ser emprestado quando se esgota — uma requisição que não tem onde colocar a sua conversa espera na fila. Se o pico for raro e enorme, [uma API cobrada por token para o excedente](https://gpuserver.io/pt/guides/api-vs-self-hosting) sai mais barata do que uma máquina dimensionada para um pico que acontece duas vezes por mês.

Seja qual for a linha em que você parou, faça a subtração antes de mais nada: pegue a memória da máquina, remova os pesos do seu modelo na precisão em que você vai servir, e veja o que sobra. Essa sobra é o produto que você está alugando. O [configurador](https://gpuserver.io/pt/configure) roda a mesma aritmética em cada nó que operamos, e [quanto custa um mês disso](https://gpuserver.io/pt/guides/monthly-vs-hourly) é calculado à parte.

## Dimensione a máquina para os usuários, não para o modelo.

O configurador reúne todo nó que alugamos, roda a mesma aritmética de memória desta página, e mostra o que sobra depois que o seu modelo é carregado — antes de você pagar por qualquer coisa.

[Abrir o configurador](https://gpuserver.io/pt/configure) [Ler os guias](https://gpuserver.io/pt/guides)

## Outros guias

- [Custo · 6 min Quando o aluguel mensal supera o por hora O ponto de equilíbrio calculado com números reais, três custos que um preço por hora esconde até a fatura, e a armadilha do tempo ocioso que triplica uma estimativa. Ler o guia](https://gpuserver.io/pt/guides/monthly-vs-hourly)
- [Custo · 9 min Hospedagem própria contra uma API por token O ponto de equilíbrio entre pagar uma API por token e alugar uma GPU, calculado com nossos preços e throughput — e as quatro coisas que a aritmética deixa de fora. Ler o guia](https://gpuserver.io/pt/guides/api-vs-self-hosting)
- [Prática · 11 min Servindo o Llama 3.3 70B em um nó De uma máquina entregue a um endpoint compatível com OpenAI, com as flags que importam e as duas que reduzem seu throughput pela metade, silenciosamente. Ler o guia](https://gpuserver.io/pt/guides/serve-llama-70b)

---

Fonte: https://gpuserver.io/pt/guides/concurrent-users/. Este arquivo é gerado a partir dos mesmos dados que o site; se um número aqui divergir de uma página, a página prevalece e este arquivo está desatualizado — a fonte canônica é https://gpuserver.io/.