Infraestrutura e GPUs
Nesta página
Dimensionamento da Sua Infraestrutura de GPU
Escolher a GPU certa, a capacidade de memória e a ferramenta de orquestração é um passo crítico na auto-hospedagem. Um modelo subdimensionado não degrada graciosamente: recusa-se a iniciar ou falha sob a primeira carga real. Vamos abordar os requisitos de hardware para os modelos Mistral, técnicas de quantização que reduzem as necessidades de memória e duas ferramentas de orquestração: SkyPilot e Cerebrium.
Requisitos de Cada Modelo
A tabela seguinte lista os requisitos em FP16 sem quantização — a base para qualquer cálculo de dimensionamento.
| Modelo | Parâmetros | VRAM Mínima | GPU Recomendada |
|---|---|---|---|
| Mistral 7B | 7B | 16 GB | 1x A10G / L4 |
| Mistral Nemo | 12B | 24 GB | 1x A10G / RTX 4090 |
| Mixtral 8x7B | 46.7B | 100 GB | 2x A100-80GB |
| Mixtral 8x22B | 141B | 300 GB | 4x A100-80GB |
| Mistral Large 2 | 123B | 250 GB | 4x A100-80GB |
| Codestral | 22B | 48 GB | 1x A100-80GB |
Não precisa desta tabela para estimar um modelo que não esteja listado. Em FP16, conte aproximadamente 2 GB de VRAM por mil milhões de parâmetros: para um modelo de 7B, 7 x 2 = 14 GB no mínimo, mais a sobrecarga para a cache KV e o motor de inferência — é por isso que a tabela indica 16 GB. Esta margem explica por que uma placa de 16 GB mal consegue lidar com o Mistral 7B e por que não será suficiente assim que servir contextos longos a múltiplos utilizadores simultâneos.
Quantização: Trocar Precisão por Memória
A quantização reduz a precisão dos pesos do modelo para diminuir o consumo de memória, muitas vezes com um impacto mínimo na qualidade. Em FP8 (oito bits por peso), o uso de memória é reduzido para metade em comparação com o FP16, e a ativação ajusta-se com um argumento simples:
# Serve a model in FP8 with vLLM
vllm serve mistralai/Mistral-Nemo-Instruct-2407 \
--tokenizer_mode mistral \
--config_format mistral \
--load_format mistral \
--dtype float8_e4m3fn
| Modelo | FP16 | FP8 | Redução |
|---|---|---|---|
| Mistral 7B | 14 GB | 7 GB | -50% |
| Mistral Nemo | 24 GB | 12 GB | -50% |
| Mixtral 8x7B | 100 GB | 50 GB | -50% |
A consequência prática é clara: um Mixtral 8x7B que exigia duas placas A100-80GB em FP16 cabe numa única placa em FP8, cortando a sua fatura horária para metade. O INT4 (quatro bits) vai ainda mais longe, mas o impacto na qualidade torna-se notório; está ativado no TGI através de um argumento dedicado:
# AWQ quantization with TGI
docker run --gpus all --shm-size 1g \
-p 8080:80 \
-e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \
ghcr.io/huggingface/text-generation-inference:2.0.3 \
--model-id mistralai/Mistral-7B-Instruct-v0.3 \
--quantize awq
| Precisão | Memória | Qualidade | Velocidade |
|---|---|---|---|
| FP16 | Base | Base | Base |
| FP8 | -50% | -1 a -2% | +10-20% |
| INT4 | -75% | -3 a -5% | +30-50% |
Na prática, recomendamos o FP8 para produção — a perda de qualidade é negligenciável. O INT4 funciona para prototipagem ou ambientes com restrições de memória, tipicamente uma demonstração numa estação de trabalho com uma GPU de consumo.
SkyPilot: Orquestração Multi-Nuvem
O SkyPilot é uma estrutura de código aberto para implementar LLMs em qualquer nuvem — AWS, GCP, Azure, Lambda Labs e outras. Seleciona automaticamente a GPU mais barata e gere o aprovisionamento, para que não tenha de comparar manualmente os preços spot em três fornecedores antes de cada lançamento. A Mistral fornece ficheiros YAML prontos a usar, cuja estrutura descreve a máquina, a configuração e o comando de serviço:
# mistral-7b.yaml
resources:
accelerators: A10G:1
cloud: aws
setup: |
pip install vllm
run: |
vllm serve mistralai/Mistral-7B-Instruct-v0.3 \
--tokenizer_mode mistral \
--config_format mistral \
--load_format mistral
O ciclo de vida completo de um cluster resume-se então a quatro comandos:
# Install SkyPilot
pip install "skypilot[aws,gcp,azure]"
# Launch the cluster
sky launch -c mistral-7b mistral-7b.yaml --region us-east-1
# Check status
sky status
# Stop (to save money)
sky stop mistral-7b
# Delete
sky down mistral-7b
Estes dois últimos comandos são aqueles que as pessoas esquecem. Um cluster A10G deixado a funcionar durante um fim de semana custa tanto como um mês de uso da API para cargas de trabalho moderadas, razão pela qual é importante conhecer as ordens de grandeza:
| Modelo | Configuração SkyPilot | Custo Estimado na Nuvem |
|---|---|---|
| Mistral 7B | A10G:1 | ~$1/h |
| Mixtral 8x7B | A100-80GB:2 | ~$6/h |
| Mixtral 8x22B | A100-80GB:4 | ~$12/h |
Um último ponto merece a sua atenção: o SkyPilot cria VMs com portas abertas por predefinição. Em produção, restrinja o acesso à rede com Grupos de Segurança ou Regras de Firewall, coloque um balanceador de carga com autenticação à frente do serviço e nunca deixe a porta 8000 exposta à internet. Um servidor vLLM sem autenticação acessível publicamente é uma GPU que está a pagar em nome de outra pessoa.
Cerebrium: GPU Serverless
O Cerebrium adota a abordagem oposta à do SkyPilot: em vez de gerir máquinas, descreve um serviço e paga apenas pela computação que realmente utiliza, com escalabilidade automática. Começar requer apenas três comandos:
pip install cerebrium
cerebrium login
cerebrium init mistral-vllm
Toda a implementação é então descrita num ficheiro cerebrium.toml:
[cerebrium.deployment]
name = "mistral-nemo"
python_version = "3.11"
[cerebrium.hardware]
gpu = "AMPERE_A10"
cpu = 4
memory = 16
[cerebrium.scaling]
min_replicas = 0
max_replicas = 5
cooldown = 60
[cerebrium.dependencies.pip]
vllm = "latest"
A definição min_replicas = 0 é a principal vantagem desta abordagem: quando ninguém chama o serviço, não custa nada. A contrapartida é que o primeiro pedido após um período de inatividade deve aguardar o arranque de uma instância. O comando cerebrium deploy é tudo o que precisa para publicar; a plataforma trata do aprovisionamento da GPU, da escalabilidade automática de zero a N réplicas, do balanceamento de carga e da monitorização.
Gestão de Carga de Produção
Para aumentar o throughput, não procure uma GPU maior — multiplique as instâncias atrás de um balanceador de carga, cada uma a servir o mesmo modelo na sua própria placa:
┌─── vLLM instance 1 (GPU A)
Load Balancer ──────┼─── vLLM instance 2 (GPU B)
└─── vLLM instance 3 (GPU C)
Cinco métricas são suficientes para gerir toda a configuração: tokens por segundo mede o throughput de geração; TTFB (Time To First Byte) indica a latência antes do primeiro token, que é o que o utilizador percebe; a utilização da GPU deve exceder 80% sob carga, caso contrário está a pagar por hardware ocioso; monitore a memória da GPU para antecipar erros OOM; e a profundidade da fila, o número de pedidos pendentes, sinaliza saturação antes que os utilizadores se queixem. Numa única máquina, uma simples atualização contínua já lhe fornece o essencial:
# Monitor GPU utilization
watch -n 1 nvidia-smi
Pontos-chave
- Conte ~2 GB de VRAM por mil milhões de parâmetros em FP16
- A quantização FP8 reduz o uso de memória para metade com impacto negligenciável na qualidade
- O SkyPilot simplifica a implementação multi-nuvem com configurações YAML prontas a usar
- O Cerebrium oferece GPU serverless com escalabilidade automática (pagamento por computação)
- Em produção, adicione um balanceador de carga e monitore continuamente as métricas da GPU