artubss/SKILLS-CLAUDE-CODE / skills/skills/ai-research/infrastructure-lambda-labs
lambda-labs-gpu-cloud
UnverifiedInstâncias GPU em nuvem reservadas e sob demanda para treinamento e inferência de ML. Use quando você precisar de instâncias GPU dedicadas com acesso SSH simples, sistemas de arquivos persistentes ou clusters multi-node de alto desempenho para treinamento em larga escala.
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
- Crie conta em https://lambda.ai
- Adicione método de pagamento
- Gere chave API do dashboard
- Adicione chave SSH (obrigatório antes de iniciar instâncias)
Iniciar via console
- Vá para https://cloud.lambda.ai/instances
- Clique em "Launch instance"
- Selecione tipo de GPU e região
- Escolha chave SSH
- Opcionalmente anexe filesystem
- 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
| GPU | VRAM | Preço/GPU/hr | Melhor Para |
|---|---|---|---|
| B200 SXM6 | 180 GB | $4.99 | Maiores modelos, treinamento mais rápido |
| H100 SXM | 80 GB | $2.99-3.29 | Treinamento de modelos grandes |
| H100 PCIe | 80 GB | $2.49 | H100 com melhor custo-benefício |
| GH200 | 96 GB | $1.49 | Modelos grandes com uma GPU |
| A100 80GB | 80 GB | $1.79 | Treinamento em produção |
| A100 40GB | 40 GB | $1.29 | Treinamento padrão |
| A10 | 24 GB | $0.75 | Inferência, fine-tuning |
| A6000 | 48 GB | $0.80 | Bom ratio VRAM/preço |
| V100 | 16 GB | $0.55 | Treinamento com orçamento limitado |
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
- Vá para Storage no console Lambda
- Clique em "Create filesystem"
- Selecione região (deve corresponder à região da instância)
- 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_namesna 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
- Vá para a página Instances
- Clique em "Launch" na coluna Cloud IDE
- 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
| Tarefa | GPU Recomendada |
|---|---|
| Fine-tuning de LLM (7B) | A100 40GB |
| Fine-tuning de LLM (70B) | 8x H100 |
| Inferência | A10, A6000 |
| Desenvolvimento | V100, A10 |
| Máximo desempenho | B200 |
Reduza custos
- Use filesystems: Evite re-download de dados
- Checkpoint frequentemente: Retome treinamento interrompido
- Right-size: Não sobre-provisione GPUs
- 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
| Problema | Solução |
|---|---|
| Instância não inicia | Verifique disponibilidade de região, tente GPU diferente |
| Conexão SSH recusada | Aguarde inicialização da instância (3-15 min) |
| Dados perdidos após encerramento | Use filesystems persistentes |
| Transferência de dados lenta | Use filesystem na mesma região |
| GPU não detectada | Reinicie instância, verifique drivers |
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
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 192k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 192k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 192k | Updated | Claude CodeCodex | Verified | Install |