Skypilot Multi Cloud Orchestration

SkyPilot Multi-Cloud Orchestration

Guia abrangente para executar workloads de ML entre nuvens com otimização automática de custos usando SkyPilot.

Quando usar SkyPilot

Use SkyPilot quando:

• Executar workloads de ML em múltiplas nuvens (AWS, GCP, Azure, etc.)
• Precisar de otimização de custos com seleção automática de nuvem/região
• Executar jobs longos em instâncias spot com auto-recuperação
• Gerenciar treinamento distribuído multi-nó
• Quiser interface unificada para 20+ provedores de nuvem
• Precisar evitar vendor lock-in

Principais características:

• Multi-nuvem: AWS, GCP, Azure, Kubernetes, Lambda, RunPod, 20+ provedores
• Otimização de custos: Seleção automática da nuvem/região mais barata
• Instâncias spot: Economia de 3-6x com recuperação automática
• Treinamento distribuído: Jobs multi-nó com gang scheduling
• Jobs gerenciados: Auto-recuperação, checkpointing, tolerância a falhas
• Sky Serve: Serving de modelos com autoscaling

Use alternativas em vez disso:

• Modal: Para serverless GPU mais simples com API nativa em Python
• RunPod: Para pods persistentes em nuvem única
• Kubernetes: Para infraestrutura K8s existente
• Ray: Para orquestração pura baseada em Ray

Quick start

Installation

pip install "skypilot[aws,gcp,azure,kubernetes]"

# Verificar credenciais de nuvem
sky check

Hello World

Crie hello.yaml:

resources:
  accelerators: T4:1

run: |
  nvidia-smi
  echo "Hello from SkyPilot!"

Inicie:

sky launch -c hello hello.yaml

# SSH para o cluster
ssh hello

# Terminar
sky down hello

Conceitos principais

Estrutura de Task YAML

# Nome da task (opcional)
name: my-task

# Requisitos de recurso
resources:
  cloud: aws              # Opcional: auto-selecionar se omitido
  region: us-west-2       # Opcional: auto-selecionar se omitido
  accelerators: A100:4    # Tipo e quantidade de GPU
  cpus: 8+                # Mínimo de CPUs
  memory: 32+             # Memória mínima (GB)
  use_spot: true          # Usar instâncias spot
  disk_size: 256          # Tamanho do disco (GB)

# Número de nós para treinamento distribuído
num_nodes: 2

# Diretório de trabalho (sincronizado para ~/sky_workdir)
workdir: .

# Comandos de setup (executados uma vez)
setup: |
  pip install -r requirements.txt

# Comandos de execução
run: |
  python train.py

Comandos principais

Configuração de GPU

Aceleradores disponíveis

# NVIDIA GPUs
accelerators: T4:1
accelerators: L4:1
accelerators: A10G:1
accelerators: L40S:1
accelerators: A100:4
accelerators: A100-80GB:8
accelerators: H100:8

# Cloud-específico
accelerators: V100:4         # AWS/GCP
accelerators: TPU-v4-8       # GCP TPUs

Fallbacks de GPU

resources:
  accelerators:
    H100: 8
    A100-80GB: 8
    A100: 8
  any_of:
    - cloud: gcp
    - cloud: aws
    - cloud: azure

Instâncias spot

resources:
  accelerators: A100:8
  use_spot: true
  spot_recovery: FAILOVER  # Auto-recuperar em preempção

Gerenciamento de cluster

Iniciar e executar

# Iniciar novo cluster
sky launch -c mycluster task.yaml

# Executar em cluster existente (pular setup)
sky exec mycluster another_task.yaml

# SSH interativo
ssh mycluster

# Stream de logs
sky logs mycluster

Autostop

resources:
  accelerators: A100:4
  autostop:
    idle_minutes: 30
    down: true  # Terminar em vez de parar

# Definir autostop via CLI
sky autostop mycluster -i 30 --down

Status do cluster

# Todos os clusters
sky status

# Visualização detalhada
sky status -a

Treinamento distribuído

Configuração multi-nó

resources:
  accelerators: A100:8

num_nodes: 4  # 4 nós × 8 GPUs = 32 GPUs total

setup: |
  pip install torch torchvision

run: |
  torchrun \
    --nnodes=$SKYPILOT_NUM_NODES \
    --nproc_per_node=$SKYPILOT_NUM_GPUS_PER_NODE \
    --node_rank=$SKYPILOT_NODE_RANK \
    --master_addr=$(echo "$SKYPILOT_NODE_IPS" | head -n1) \
    --master_port=12355 \
    train.py

Variáveis de ambiente

Execução somente no nó head

run: |
  if [ "${SKYPILOT_NODE_RANK}" == "0" ]; then
    python orchestrate.py
  fi

Jobs gerenciados

Recuperação de spot

# Iniciar job gerenciado com recuperação de spot
sky jobs launch -n my-job train.yaml

Checkpointing

name: training-job

file_mounts:
  /checkpoints:
    name: my-checkpoints
    store: s3
    mode: MOUNT

resources:
  accelerators: A100:8
  use_spot: true

run: |
  python train.py \
    --checkpoint-dir /checkpoints \
    --resume-from-latest

Gerenciamento de jobs

# Listar jobs
sky jobs queue

# Visualizar logs
sky jobs logs my-job

# Cancelar job
sky jobs cancel my-job

File mounts e armazenamento

Sincronização de arquivo local

workdir: ./my-project  # Sincronizado para ~/sky_workdir

file_mounts:
  /data/config.yaml: ./config.yaml
  ~/.vimrc: ~/.vimrc

Armazenamento em nuvem

file_mounts:
  # Montar bucket S3
  /datasets:
    source: s3://my-bucket/datasets
    mode: MOUNT  # Transmitir do S3

  # Copiar bucket GCS
  /models:
    source: gs://my-bucket/models
    mode: COPY  # Pré-buscar para disco

  # Cache mount (escritas rápidas)
  /outputs:
    name: my-outputs
    store: s3
    mode: MOUNT_CACHED

Modos de armazenamento

Sky Serve (Model Serving)

Serviço básico

# service.yaml
service:
  readiness_probe: /health
  replica_policy:
    min_replicas: 1
    max_replicas: 10
    target_qps_per_replica: 2.0

resources:
  accelerators: A100:1

run: |
  python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-7b-chat-hf \
    --port 8000

# Implantar
sky serve up -n my-service service.yaml

# Verificar status
sky serve status

# Obter endpoint
sky serve status my-service

Políticas de autoscaling

service:
  replica_policy:
    min_replicas: 1
    max_replicas: 10
    target_qps_per_replica: 2.0
    upscale_delay_seconds: 60
    downscale_delay_seconds: 300
  load_balancing_policy: round_robin

Otimização de custos

Seleção automática de nuvem

# SkyPilot encontra a opção mais barata
resources:
  accelerators: A100:8
  # Nenhuma nuvem especificada - auto-selecionar mais barata

# Mostrar decisão do otimizador
sky launch task.yaml --dryrun

Preferências de nuvem

resources:
  accelerators: A100:8
  any_of:
    - cloud: gcp
      region: us-central1
    - cloud: aws
      region: us-east-1
    - cloud: azure

Variáveis de ambiente

envs:
  HF_TOKEN: $HF_TOKEN  # Herdado do env local
  WANDB_API_KEY: $WANDB_API_KEY

# Ou usar secrets
secrets:
  - HF_TOKEN
  - WANDB_API_KEY

Workflows comuns

Workflow 1: Fine-tuning com checkpoints

name: llm-finetune

file_mounts:
  /checkpoints:
    name: finetune-checkpoints
    store: s3
    mode: MOUNT_CACHED

resources:
  accelerators: A100:8
  use_spot: true

setup: |
  pip install transformers accelerate

run: |
  python train.py \
    --checkpoint-dir /checkpoints \
    --resume

Workflow 2: Hyperparameter sweep

name: hp-sweep-${RUN_ID}

envs:
  RUN_ID: 0
  LEARNING_RATE: 1e-4
  BATCH_SIZE: 32

resources:
  accelerators: A100:1
  use_spot: true

run: |
  python train.py \
    --lr $LEARNING_RATE \
    --batch-size $BATCH_SIZE \
    --run-id $RUN_ID

# Iniciar múltiplos jobs
for i in {1..10}; do
  sky jobs launch sweep.yaml \
    --env RUN_ID=$i \
    --env LEARNING_RATE=$(python -c "import random; print(10**random.uniform(-5,-3))")
done

Debugging

# SSH para o cluster
ssh mycluster

# Visualizar logs
sky logs mycluster

# Verificar fila de jobs
sky queue mycluster

# Visualizar logs de job gerenciado
sky jobs logs my-job

Problemas comuns

Referências

• Advanced Usage - Multi-nuvem, otimização, padrões de produção
• Troubleshooting - Problemas comuns e soluções

Recursos

• Documentation: https://docs.skypilot.co
• GitHub: https://github.com/skypilot-org/skypilot
• Slack: https://slack.skypilot.co
• Examples: https://github.com/skypilot-org/skypilot/tree/master/examples