Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Infraestrutura e GPUs

Aula 13 de 14 Atualizada a 29 de julho de 2026 Avancado
Nesta página
  1. Dimensionamento da Sua Infraestrutura de GPU
  2. Requisitos de Cada Modelo
  3. Quantização: Trocar Precisão por Memória
  4. SkyPilot: Orquestração Multi-Nuvem
  5. Cerebrium: GPU Serverless
  6. Gestão de Carga de Produção
  7. Pontos-chave

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.

ModeloParâmetrosVRAM MínimaGPU Recomendada
Mistral 7B7B16 GB1x A10G / L4
Mistral Nemo12B24 GB1x A10G / RTX 4090
Mixtral 8x7B46.7B100 GB2x A100-80GB
Mixtral 8x22B141B300 GB4x A100-80GB
Mistral Large 2123B250 GB4x A100-80GB
Codestral22B48 GB1x 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
ModeloFP16FP8Redução
Mistral 7B14 GB7 GB-50%
Mistral Nemo24 GB12 GB-50%
Mixtral 8x7B100 GB50 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ãoMemóriaQualidadeVelocidade
FP16BaseBaseBase
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:

ModeloConfiguração SkyPilotCusto Estimado na Nuvem
Mistral 7BA10G:1~$1/h
Mixtral 8x7BA100-80GB:2~$6/h
Mixtral 8x22BA100-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