Cluster Self-Hosted para Treino de LLMs

──────────────────────────────────────────────────────────────┐
│                     Cluster de Treino LLM                      │
│                                                               │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐           │
│  │   Node 1    │  │   Node 2    │  │   Node N    │           │
│  │  4× A100    │  │  4× A100    │  │  4× A100    │           │
│  │  2× CPU     │  │  2× CPU     │  │  2× CPU     │           │
│  │  512GB RAM  │  │  512GB RAM  │  │  512GB RAM  │           │
│  ──────┬──────┘  └──────┬──────┘  └──────┬──────┘           │
│         │                │                │                    │
│         └────────────────┼────────────────┘                    │
│                          │                                     │
│                   ┌──────▼──────┐                              │
│                   │  Switch IB  │  ← InfiniBand NDR/XDR        │
│                   │  (32/64 port)│    200/400 Gbps              │
│                   └──────┬──────┘                              │
│                          │                                     │
│                   ┌──────▼──────┐                              │
│                   │  Storage    │  ← Lustre / Ceph / WekaIO    │
│                   │  (100TB+)   │    Parallel filesystem        │
│                   └─────────────┘                              │
│                                                               │
│  ┌─────────────┐                                              │
│  │  Head Node  │  ← Kubernetes master / Slurm controller      │
│  │  (CPU only) │                                              │
│  └─────────────┘                                              │
└──────────────────────────────────────────────────────────────┘

Fat-Tree topology (padrão para clusters GPU):

  GPU Nodes          Spine Switches        Leaf Switches
  ┌──┐ ┌──┐          ┌── ┌──┐            ┌──┐ ┌──┐
  │N1│─│N2│──────────│S1│─│S2│────────────│L1│─│L2│
  └──┘ └──          └──┘ └──            └──┘ └──┘
  ┌──┐ ┌──┐          ┌──┐ ┌──┐            ┌──┐ ┌──┐
  │N3│─│N4│──────────│S3│─│S4│────────────│L3│─│L4│
  └──┘ └──┘          └──┘ └──┘            └── └──┘

  Bisection bandwidth: non-blocking (cada nó tem banda total)

/storage/
├── datasets/               ← Datasets de treino (read-only para workers)
│   ├── code/
│   ├── text/
│   └── multimodal/
├── checkpoints/            ← Checkpoints de treino (write-heavy)
│   ├── run_001/
│   │   ├── step_1000/
│   │   ├── step_2000/
│   │   └── ...
│   └── run_002/
── logs/                   ← Logs de treino
├── models/                 ← Modelos finais exportados
└── scratch/                ← Dados temporários (por job)

# Exemplo de job de treino no Kubernetes
apiVersion: batch/v1
kind: Job
metadata:
  name: llm-training-run-001
spec:
  parallelism: 8
  completions: 8
  template:
    spec:
      containers:
      - name: trainer
        image: pytorch/pytorch:2.3.0-cuda12.1
        command: ["python", "train.py", "--config", "llm_7b.yaml"]
        resources:
          limits:
            nvidia.com/gpu: 1
            memory: 128Gi
            cpu: "32"
        volumeMounts:
        - name: datasets
          mountPath: /storage/datasets
        - name: checkpoints
          mountPath: /storage/checkpoints
      volumes:
      - name: datasets
        persistentVolumeClaim:
          claimName: datasets-pvc
      - name: checkpoints
        persistentVolumeClaim:
          claimName: checkpoints-pvc
      restartPolicy: Never

#!/bin/bash
#SBATCH --job-name=llm-training
#SBATCH --nodes=8
#SBATCH --gpus-per-node=4
#SBATCH --ntasks-per-node=4
#SBATCH --cpus-per-task=32
#SBATCH --mem=512G
#SBATCH --time=72:00:00
#SBATCH --partition=gpu

srun python train.py --config llm_7b.yaml

Nível 1: Sistema operacional
  → Ubuntu 22.04 LTS ou Rocky Linux 9

Nível 2: Drivers e runtime
  → NVIDIA Driver 550+
  → CUDA 12.4
  → cuDNN 9.x
  → NCCL 2.20+ (comunicação GPU-GPU)

Nível 3: Networking
  → OFED (OpenFabrics Enterprise Distribution)
  → InfiniBand drivers
  → UCX (Unified Communication X)

Nível 4: Storage
  → Lustre client ou WekaIO agent
  → NFS client

Nível 5: Orquestração
  → Kubernetes + Volcano ou Slurm

Nível 6: ML Framework
  → PyTorch 2.3+
  → DeepSpeed / Megatron-LM / FSDP

Nível 7: Monitoring
  → Prometheus + Grafana
  → DCGM (NVIDIA Data Center GPU Manager)
  → Slurm accounting ou Kubernetes metrics

import torch.distributed as dist

# Inicializar processo grupo com NCCL backend
dist.init_process_group(backend="nccl")

# All-reduce: somar gradients em todas as GPUs
torch.distributed.all_reduce(tensor, op=dist.ReduceOp.SUM)

# Variáveis de ambiente para otimizar NCCL
export NCCL_PROTO=simple      # simple ou ll (low latency)
export NCCL_ALGO=Ring         # Ring, Tree, ou CollNet
export NCCL_SOCKET_IFNAME=eth0
export NCCL_IB_DISABLE=0      # Usar InfiniBand
export NCCL_IB_HCA=mlx5       # HCA driver
export NCCL_IB_TC=106         # Traffic class

Semana 1–2: Infraestrutura física
  → Instalar racks, cabos, switches InfiniBand
  → Configurar storage (NFS ou WekaIO)
  → Instalar OS em todos os nós

Semana 3: Software base
  → Drivers NVIDIA, CUDA, cuDNN
  → NCCL, UCX, InfiniBand stack
  → Testar comunicação GPU-GPU (NCCL tests)

Semana 4: Orquestração
  → Instalar Kubernetes + Volcano ou Slurm
  → Configurar GPU scheduling
  → Testar job distribuído

Semana 5: ML stack
  → PyTorch, DeepSpeed/FSDP, Megatron-LM
  → Configurar monitoring (DCGM, Prometheus)
  → Testar treino de modelo pequeno

Semana 6+: Otimização
  → Tuning de NCCL, I/O, parallelism
  → Benchmark de throughput
  → Documentar procedimentos

Fase 1: Cloud para treino (Lambda Labs / CoreWeave)
  → Alugar 8–16 A100 por semana
  → Treinar modelo
  → Custo: $5K–$15K por treino

Fase 2: On-premise para inferência
  → 2× RTX 4090 para serving
  → Custo: $5K em hardware

Fase 3: Migrar treino para on-premise quando justificar
  → Quando custo cloud > custo on-premise em 12 meses