Lambda Labs Gpu Cloud

Lambda Labs GPU Cloud

Guia abrangente para executar cargas de trabalho de ML em GPU cloud da Lambda Labs com instâncias sob demanda e Clusters 1-Click.

Quando usar Lambda Labs

Use Lambda Labs quando:

• Você precisa de instâncias GPU dedicadas com acesso SSH completo
• Executando trabalhos de treinamento longos (horas a dias)
• Quer preços simples sem taxas de saída
• Precisa de armazenamento persistente entre sessões
• Requer clusters multi-node de alto desempenho (16-512 GPUs)
• Quer stack ML pré-instalado (Lambda Stack com PyTorch, CUDA, NCCL)

Características principais:

• Variedade de GPUs: B200, H100, GH200, A100, A10, A6000, V100
• Lambda Stack: PyTorch, TensorFlow, CUDA, cuDNN, NCCL pré-instalados
• Sistemas de arquivos persistentes: Mantenha dados entre reinicializações de instância
• Clusters 1-Click: Clusters Slurm de 16-512 GPUs com InfiniBand
• Preços simples: Pague por minuto, sem taxas de saída
• Regiões globais: 12+ regiões em todo o mundo

Use alternativas:

• Modal: Para cargas de trabalho serverless e auto-scaling
• SkyPilot: Para orquestração multi-cloud e otimização de custos
• RunPod: Para instâncias spot mais baratas e endpoints serverless
• Vast.ai: Para marketplace de GPU com preços mais baixos

Quick start

Configuração de conta

1. Crie conta em https://lambda.ai
2. Adicione método de pagamento
3. Gere chave API do dashboard
4. Adicione chave SSH (obrigatório antes de iniciar instâncias)

Iniciar via console

1. Vá para https://cloud.lambda.ai/instances
2. Clique em "Launch instance"
3. Selecione tipo de GPU e região
4. Escolha chave SSH
5. Opcionalmente anexe filesystem
6. Inicie e aguarde 3-15 minutos

Conectar via SSH

# Obtenha IP da instância do console
ssh ubuntu@<INSTANCE-IP>

# Ou com chave específica
ssh -i ~/.ssh/lambda_key ubuntu@<INSTANCE-IP>

Instâncias GPU

GPUs disponíveis

Configurações de instância

8x GPU: Melhor para treinamento distribuído (DDP, FSDP)
4x GPU: Modelos grandes, treinamento multi-GPU
2x GPU: Cargas de trabalho médias
1x GPU: Fine-tuning, inferência, desenvolvimento

Tempos de inicialização

• Single-GPU: 3-5 minutos
• Multi-GPU: 10-15 minutos

Lambda Stack

Todas as instâncias vêm com Lambda Stack pré-instalado:

# Software incluído
- Ubuntu 22.04 LTS
- NVIDIA drivers (versão mais recente)
- CUDA 12.x
- cuDNN 8.x
- NCCL (para multi-GPU)
- PyTorch (versão mais recente)
- TensorFlow (versão mais recente)
- JAX
- JupyterLab

Verificar instalação

# Verificar GPU
nvidia-smi

# Verificar PyTorch
python -c "import torch; print(torch.cuda.is_available())"

# Verificar versão CUDA
nvcc --version

Python API

Instalação

pip install lambda-cloud-client

Autenticação

import os
import lambda_cloud_client

# Configure com chave API
configuration = lambda_cloud_client.Configuration(
    host="https://cloud.lambdalabs.com/api/v1",
    access_token=os.environ["LAMBDA_API_KEY"]
)

Listar instâncias disponíveis

with lambda_cloud_client.ApiClient(configuration) as api_client:
    api = lambda_cloud_client.DefaultApi(api_client)

    # Obtenha tipos de instância disponíveis
    types = api.instance_types()
    for name, info in types.data.items():
        print(f"{name}: {info.instance_type.description}")

Iniciar instância

from lambda_cloud_client.models import LaunchInstanceRequest

request = LaunchInstanceRequest(
    region_name="us-west-1",
    instance_type_name="gpu_1x_h100_sxm5",
    ssh_key_names=["my-ssh-key"],
    file_system_names=["my-filesystem"],  # Opcional
    name="training-job"
)

response = api.launch_instance(request)
instance_id = response.data.instance_ids[0]
print(f"Launched: {instance_id}")

Listar instâncias em execução

instances = api.list_instances()
for instance in instances.data:
    print(f"{instance.name}: {instance.ip} ({instance.status})")

Encerrar instância

from lambda_cloud_client.models import TerminateInstanceRequest

request = TerminateInstanceRequest(
    instance_ids=[instance_id]
)
api.terminate_instance(request)

Gerenciamento de chaves SSH

from lambda_cloud_client.models import AddSshKeyRequest

# Adicionar chave SSH
request = AddSshKeyRequest(
    name="my-key",
    public_key="ssh-rsa AAAA..."
)
api.add_ssh_key(request)

# Listar chaves
keys = api.list_ssh_keys()

# Deletar chave
api.delete_ssh_key(key_id)

CLI com curl

Listar tipos de instância

curl -u $LAMBDA_API_KEY: \
  https://cloud.lambdalabs.com/api/v1/instance-types | jq

Iniciar instância

curl -u $LAMBDA_API_KEY: \
  -X POST https://cloud.lambdalabs.com/api/v1/instance-operations/launch \
  -H "Content-Type: application/json" \
  -d '{
    "region_name": "us-west-1",
    "instance_type_name": "gpu_1x_h100_sxm5",
    "ssh_key_names": ["my-key"]
  }' | jq

Encerrar instância

curl -u $LAMBDA_API_KEY: \
  -X POST https://cloud.lambdalabs.com/api/v1/instance-operations/terminate \
  -H "Content-Type: application/json" \
  -d '{"instance_ids": ["<INSTANCE-ID>"]}' | jq

Armazenamento persistente

Filesystems

Filesystems persistem dados entre reinicializações de instância:

# Local de montagem
/lambda/nfs/<FILESYSTEM_NAME>

# Exemplo: salvar checkpoints
python train.py --checkpoint-dir /lambda/nfs/my-storage/checkpoints

Criar filesystem

1. Vá para Storage no console Lambda
2. Clique em "Create filesystem"
3. Selecione região (deve corresponder à região da instância)
4. Nomeie e crie

Anexar à instância

Filesystems devem ser anexados no tempo de inicialização da instância:

• Via console: Selecione filesystem ao iniciar
• Via API: Inclua file_system_names na solicitação de inicialização

Melhores práticas

# Armazenar em filesystem (persiste)
/lambda/nfs/storage/
  ├── datasets/
  ├── checkpoints/
  ├── models/
  └── outputs/

# SSD local (mais rápido, efêmero)
/home/ubuntu/
  └── working/  # Arquivos temporários

Configuração SSH

Adicionar chave SSH

# Gere chave localmente
ssh-keygen -t ed25519 -f ~/.ssh/lambda_key

# Adicione chave pública ao console Lambda
# Ou via API

Múltiplas chaves

# Na instância, adicione mais chaves
echo 'ssh-rsa AAAA...' >> ~/.ssh/authorized_keys

Importar do GitHub

# Na instância
ssh-import-id gh:username

SSH tunneling

# Encaminhar Jupyter
ssh -L 8888:localhost:8888 ubuntu@<IP>

# Encaminhar TensorBoard
ssh -L 6006:localhost:6006 ubuntu@<IP>

# Múltiplas portas
ssh -L 8888:localhost:8888 -L 6006:localhost:6006 ubuntu@<IP>

JupyterLab

Iniciar do console

1. Vá para a página Instances
2. Clique em "Launch" na coluna Cloud IDE
3. JupyterLab abre no navegador

Acesso manual

# Na instância
jupyter lab --ip=0.0.0.0 --port=8888

# Da máquina local com tunnel
ssh -L 8888:localhost:8888 ubuntu@<IP>
# Abra http://localhost:8888

Workflows de treinamento

Treinamento com uma GPU

# SSH para instância
ssh ubuntu@<IP>

# Clone repo
git clone https://github.com/user/project
cd project

# Instale dependências
pip install -r requirements.txt

# Treine
python train.py --epochs 100 --checkpoint-dir /lambda/nfs/storage/checkpoints

Treinamento multi-GPU (nó único)

# train_ddp.py
import torch
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP

def main():
    dist.init_process_group("nccl")
    rank = dist.get_rank()
    device = rank % torch.cuda.device_count()

    model = MyModel().to(device)
    model = DDP(model, device_ids=[device])

    # Training loop...

if __name__ == "__main__":
    main()

# Iniciar com torchrun (8 GPUs)
torchrun --nproc_per_node=8 train_ddp.py

Checkpoint para filesystem

import os

checkpoint_dir = "/lambda/nfs/my-storage/checkpoints"
os.makedirs(checkpoint_dir, exist_ok=True)

# Salve checkpoint
torch.save({
    'epoch': epoch,
    'model_state_dict': model.state_dict(),
    'optimizer_state_dict': optimizer.state_dict(),
    'loss': loss,
}, f"{checkpoint_dir}/checkpoint_{epoch}.pt")

Clusters 1-Click

Visão geral

Clusters Slurm de alto desempenho com:

• 16-512 GPUs NVIDIA H100 ou B200
• InfiniBand NVIDIA Quantum-2 400 Gb/s
• GPUDirect RDMA em 3200 Gb/s
• Stack ML distribuído pré-instalado

Software incluído

• Ubuntu 22.04 LTS + Lambda Stack
• NCCL, Open MPI
• PyTorch com DDP e FSDP
• TensorFlow
• Drivers OFED

Armazenamento

• 24 TB NVMe por nó de computação (efêmero)
• Filesystems Lambda para dados persistentes

Treinamento multi-node

# Em cluster Slurm
srun --nodes=4 --ntasks-per-node=8 --gpus-per-node=8 \
  torchrun --nnodes=4 --nproc_per_node=8 \
  --rdzv_backend=c10d --rdzv_endpoint=$MASTER_ADDR:29500 \
  train.py

Rede

Largura de banda

• Inter-instância (mesma região): até 200 Gbps
• Saída de internet: máx. 20 Gbps

Firewall

• Padrão: Apenas porta 22 (SSH) aberta
• Configure portas adicionais no console Lambda
• Tráfego ICMP permitido por padrão

IPs privados

# Encontre IP privado
ip addr show | grep 'inet '

Workflows comuns

Workflow 1: Fine-tuning de LLM

# 1. Iniciar instância 8x H100 com filesystem

# 2. SSH e configuração
ssh ubuntu@<IP>
pip install transformers accelerate peft

# 3. Baixe modelo para filesystem
python -c "
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained('meta-llama/Llama-2-7b-hf')
model.save_pretrained('/lambda/nfs/storage/models/llama-2-7b')
"

# 4. Fine-tune com checkpoints em filesystem
accelerate launch --num_processes 8 train.py \
  --model_path /lambda/nfs/storage/models/llama-2-7b \
  --output_dir /lambda/nfs/storage/outputs \
  --checkpoint_dir /lambda/nfs/storage/checkpoints

Workflow 2: Inferência em lote

# 1. Iniciar instância A10 (custo-efetivo para inferência)

# 2. Execute inferência
python inference.py \
  --model /lambda/nfs/storage/models/fine-tuned \
  --input /lambda/nfs/storage/data/inputs.jsonl \
  --output /lambda/nfs/storage/data/outputs.jsonl

Otimização de custos

Escolha a GPU certa

Reduza custos

1. Use filesystems: Evite re-download de dados
2. Checkpoint frequentemente: Retome treinamento interrompido
3. Right-size: Não sobre-provisione GPUs
4. Encerre idle: Sem auto-stop, termine manualmente

Monitore uso

• Dashboard mostra utilização de GPU em tempo real
• API para monitoramento programático

Problemas comuns

Referências

• Uso Avançado - Treinamento multi-node, automação de API
• Solução de Problemas - Problemas comuns e soluções

Recursos

• Documentação: https://docs.lambda.ai
• Console: https://cloud.lambda.ai
• Preços: https://lambda.ai/instances
• Suporte: https://support.lambdalabs.com
• Blog: https://lambda.ai/blog