Inferência de LLMs na Nuvem: Guia Completo 2026

As Opções para Inferência de LLMs

vLLM — Alto Throughput

O **vLLM** é o padrão de fato para inferência de LLMs em produção em 2026. Com PagedAttention e continuous batching, oferece até 24x mais throughput que a implementação naive do HuggingFace.

```bash

pip install vllm

python -m vllm.entrypoints.openai.api_server --model meta-llama/Meta-Llama-3-8B-Instruct --dtype bfloat16 --max-model-len 8192

```

Compatível com API OpenAI — substitua a base URL nos seus clientes.

Ollama — Facilidade de Uso

**Ollama** é a melhor escolha para desenvolvimento local e staging. Um comando para rodar qualquer modelo:

```bash

curl https://ollama.ai/install.sh | sh

ollama run llama3.1:8b

```

Menor throughput que vLLM, mas setup instantâneo.

llama.cpp — Eficiência Máxima em CPU/GPU Misto

**llama.cpp** com quantização GGUF permite rodar LLMs em GPUs menores e até parcialmente em CPU. Útil para ambientes com VRAM limitada.

Recomendações de GPU por Tamanho de Modelo

| Modelo | VRAM mínima | GPU recomendada | Throughput (vLLM) |

|---|---|---|---|

| 7B FP16 | 16GB | RTX 4090 | ~3.200 tok/s |

| 7B INT4 | 6GB | RTX 3080 | ~1.800 tok/s |

| 13B FP16 | 28GB | A100 40GB | ~2.100 tok/s |

| 70B FP16 | 160GB | 2×A100 80GB | ~900 tok/s |

| 70B INT4 | 48GB | A100 80GB | ~650 tok/s |

Custo por 1 Milhão de Tokens (Março 2026)

| GPU | Custo/hr | Throughput (tok/s, LLaMA 8B) | Custo/1M tokens |

|---|---|---|---|

| RTX 3090 | $0,22 | 1.900 | $0,032 |

| RTX 4090 | $0,44 | 3.200 | $0,038 |

| A100 80GB | $1,89 | 5.100 | $0,103 |

| H100 SXM | $3,99 | 11.200 | $0,099 |

**Insight:** O H100 tem custo por token similar ao A100 para o LLaMA 8B, mas brilha em modelos maiores onde o throughput escala mais.

Serverless vs Instâncias Dedicadas

Serverless — Melhor para tráfego variável

**RunPod Serverless:**

```python

handler.py

import runpod

from vllm import LLM, SamplingParams

llm = LLM(model="meta-llama/Meta-Llama-3-8B-Instruct")

def handler(job):

prompt = job["input"]["prompt"]

params = SamplingParams(temperature=0.7, max_tokens=512)

output = llm.generate(prompt, params)

return output[0].outputs[0].text

runpod.serverless.start({"handler": handler})

```

Instância Dedicada — Melhor para carga constante

**Break-even:** Se receber >4 requests/min de forma consistente, instância dedicada é mais econômico.

Configurando RunPod Serverless para Produção

1. Faça push da sua imagem Docker com vLLM para Docker Hub ou GHCR

2. No RunPod, crie um **Serverless Endpoint**

3. Configure:

- **Container Image:** sua imagem

- **GPU:** RTX 4090 ou A100 (depende do modelo)

- **Min Workers:** 0 (escala a zero quando ocioso)

- **Max Workers:** depende do tráfego esperado

4. Use a API REST gerada:

```python

import requests

response = requests.post(

"https://api.runpod.io/v2/{endpoint_id}/runsync",

headers={"Authorization": f"Bearer {RUNPOD_API_KEY}"},

json={"input": {"prompt": "Explique machine learning em 3 frases"}}

)

```

Escalonamento para Produção

Conclusão

Para 2026, vLLM + RunPod Serverless é a combinação mais eficiente para APIs de LLM. Comece com serverless, migre para instâncias dedicadas quando o tráfego justificar.

Deploy seu LLM no RunPod → →