Aprende de Cerebras: Monta tu Mini-Infraestructura IA en Casa

Aprende de Cerebras: Cómo Montar tu Mini-Infraestructura IA en Casa

Tiempo de lectura: 9 minutos

Cerebras acaba de recaudar $1,100 millones para expandir sus datacenters de IA. Pero aquí la pregunta interesante: ¿qué podemos aprender de su arquitectura para aplicarlo a nuestro homelab?

Este artículo no va de inversiones millonarias. Va de extraer los principios técnicos que hacen que la infraestructura de Cerebras sea tan eficiente, y replicarlos a escala homelab con hardware accesible.

• Cerebras: 6 nuevos datacenters con capacidad 20x superior
• Wafer-Scale Engine: Chip único vs arquitectura multi-GPU
• 40M tokens/seg Llama 70B: Inferencia distribuida masiva
• Lecciones aplicables: Clustering, networking, almacenamiento distribuido
• Tu versión homelab: Replica sus principios con ~€500-€2,000

Tabla de Contenidos

• Qué Está Haciendo Cerebras y Por Qué Importa
• El Wafer-Scale Engine: Arquitectura Única
• Lecciones de Cerebras para tu Homelab
• Tutorial: Clustering IA Básico en Casa
• Networking para Inferencia Distribuida
• Almacenamiento Eficiente de Modelos
• Monitorización y Optimización
• Escalabilidad: De 1 GPU a N GPUs
• Preguntas Frecuentes

Qué Está Haciendo Cerebras y Por Qué Importa

Cerebras Systems acaba de anunciar una expansión masiva de su infraestructura de inferencia de IA:

• $1,100 millones recaudados en Serie G
• 6 nuevos datacenters en EE.UU., Canadá y Europa
• Capacidad 20x superior a su infraestructura actual
• 40 millones tokens/seg para Llama 70B en su red completa

Su tecnología clave es el Wafer-Scale Engine (WSE): en lugar de usar múltiples GPUs pequeñas, utilizan un solo chip gigante del tamaño de una oblea de silicio completa (21.5 cm x 21.5 cm). Esto elimina la latencia entre chips y permite memoria compartida real.

¿Por Qué Nos Debería Importar Esto?

Porque los principios arquitectónicos que aplican son escalables:

1. Clustering inteligente: Distribuir inferencia entre múltiples nodos
2. Memoria compartida: Reducir copias de modelos entre GPUs
3. Networking de baja latencia: 10GbE/25GbE entre nodos
4. Almacenamiento distribuido: Modelos accesibles desde cualquier nodo
5. Orquestación automatizada: Balanceo de carga y failover

Todos estos conceptos se pueden aplicar a un homelab, aunque sea con 2-3 máquinas en lugar de 300 CS-3 Superchips.

El Wafer-Scale Engine: Arquitectura Única

Cómo Funciona el WSE

El chip WSE-3 de Cerebras tiene:

• 900,000 núcleos IA optimizados para redes neuronales
• 44 GB SRAM on-chip (memoria directa en chip, sin latencia VRAM)
• 21 PB/s bandwidth interno (20,000x más rápido que GPUs consumer)
• Arquitectura dataflow: Los datos fluyen entre cores sin control central

Por Qué No Podemos Replicarlo Exactamente

El WSE cuesta cientos de miles de dólares y requiere fabricación especializada. Pero sí podemos replicar sus ventajas arquitectónicas con GPUs consumer:

Lecciones de Cerebras para tu Homelab

1. La Memoria Compartida es Oro

Cerebras pone todo el modelo en SRAM on-chip para evitar cargarlo múltiples veces. En homelab:

• Almacenamiento NFS/Samba centralizado: Un solo servidor con los modelos
• Caché local en NVMe: Primera carga desde red, luego desde disco local
• Evitar duplicación: No copies Llama 70B (140GB) en cada máquina

Arquitectura recomendada:

[Servidor NAS]
    ├─ /models/llama-3.3-70b/ (140GB)
    ├─ /models/qwen-2.5-72b/ (146GB)
    └─ /models/flux-schnell/ (24GB)
         ↓ 10GbE Network
    [Nodo GPU 1] [Nodo GPU 2] [Nodo GPU 3]
    Cache local  Cache local  Cache local

2. El Networking No es Opcional

Cerebras usa networking de 200G QSFP. Nosotros podemos usar:

• 10 Gigabit Ethernet: Suficiente para inferencia distribuida (€150-€300 total)
• 25GbE: Si necesitas más (€500-€800 total)
• Bonding de interfaces: 2x 2.5GbE = 5Gbps efectivos (€0 si ya tienes las interfaces)

Por qué importa: Transferir activaciones entre GPUs en un modelo distribuido genera ~2-5 GB/s de tráfico. Con Gigabit Ethernet (125 MB/s) te conviertes en cuello de botella. Con 10GbE (1,250 MB/s) va fluido.

3. La Distribución Inteligente Multiplica Capacidad

Cerebras puede ejecutar 405B parámetros distribuidos. Tú puedes ejecutar 70B en 2x GPUs o 123B en 3x GPUs con tensor parallelism.

Tensor Parallelism: El modelo se divide horizontalmente entre GPUs. Cada GPU procesa una porción de cada capa, y se sincronizan entre capas.

Pipeline Parallelism: Diferentes capas del modelo en diferentes GPUs. GPU1 hace capas 1-20, GPU2 hace 21-40, etc.

Para homelab, tensor parallelism con vLLM es la opción más práctica.

4. La Monitorización es Crítica

Cerebras monitoriza 300+ sistemas CS-3 en tiempo real. Tú necesitas monitorizar tus 2-3 nodos para:

• Detectar cuellos de botella: GPU underutilized = problema de red o I/O
• Optimizar costes: No dejes GPUs encendidas sin usar (€0.15/kWh)
• Prevenir fallos: Temperatura >85°C = throttling = inferencia lenta

Herramientas: Prometheus + Grafana + nvidia-smi exporter.

Tutorial: Clustering IA Básico en Casa

Vamos a montar una mini-infraestructura tipo Cerebras con 2 máquinas y networking 10GbE.

Hardware Necesario

Opción Económica (2 nodos, ~€3,500 total):

NODO 1 (Servidor principal):
├─ GPU: RTX 4070 Ti Super 16GB        → €900
├─ CPU: AMD Ryzen 5 7600              → €200
├─ RAM: 32GB DDR5                     → €100
├─ SSD: 2TB NVMe (modelos)            → €150
├─ NIC: 10GbE SFP+ (Mellanox CX3)     → €50 (usado)
└─ Resto (placa, PSU, caja)           → €400

NODO 2 (Nodo inferencia):
├─ GPU: RTX 4070 Super 12GB           → €650
├─ CPU: AMD Ryzen 5 7600              → €200
├─ RAM: 32GB DDR5                     → €100
├─ NIC: 10GbE SFP+ (Mellanox CX3)     → €50 (usado)
└─ Resto (placa, PSU, caja)           → €400

NETWORKING:
├─ Switch 10GbE SFP+ 8 puertos        → €200 (MikroTik CRS309)
└─ 2x cables DAC SFP+ 1m              → €30

TOTAL: ~€3,430

Capacidad combinada:

• 28GB VRAM total (16+12)
• Llama 3.3 70B Q4 distribuido
• Mistral Large 123B Q2 distribuido (calidad justa)
• Qwen 2.5 72B Q4 distribuido

Instalación del Software

1. Sistema base en ambos nodos (Ubuntu 24.04 LTS)

# Actualizar
sudo apt update && sudo apt upgrade -y

# Drivers NVIDIA
sudo apt install -y nvidia-driver-550 nvidia-utils-550

# Docker + NVIDIA Container Toolkit
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

sudo apt update
sudo apt install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

2. Configurar almacenamiento compartido (Nodo 1 = servidor NFS)

# En NODO 1 (servidor NFS)
sudo apt install -y nfs-kernel-server

# Crear directorio de modelos
sudo mkdir -p /mnt/models
sudo chown $USER:$USER /mnt/models

# Exportar via NFS
echo "/mnt/models 192.168.10.0/24(rw,sync,no_subtree_check,no_root_squash)" | sudo tee -a /etc/exports
sudo exportfs -ra
sudo systemctl restart nfs-server

# En NODO 2 (cliente NFS)
sudo apt install -y nfs-common
sudo mkdir -p /mnt/models
echo "192.168.10.1:/mnt/models /mnt/models nfs defaults 0 0" | sudo tee -a /etc/fstab
sudo mount -a

3. Instalar vLLM con soporte multi-GPU

# En ambos nodos
docker pull vllm/vllm-openai:latest

# Descargar modelo en NODO 1 (se sincroniza via NFS a NODO 2)
cd /mnt/models
git lfs install
git clone https://huggingface.co/meta-llama/Llama-3.3-70B-Instruct

4. Configurar Ray Cluster para distribución

# En NODO 1 (head node)
docker run -d --name ray-head --gpus all --network host \
  -v /mnt/models:/models \
  rayproject/ray:latest-gpu ray start --head --port=6379

# En NODO 2 (worker node)
docker run -d --name ray-worker --gpus all --network host \
  -v /mnt/models:/models \
  rayproject/ray:latest-gpu ray start --address='192.168.10.1:6379'

# Verificar cluster
docker exec ray-head ray status

5. Lanzar vLLM distribuido

# En NODO 1, lanzar vLLM con tensor parallelism
docker run -d --name vllm-server \
  --gpus all \
  --network host \
  -v /mnt/models:/models \
  -e RAY_ADDRESS=192.168.10.1:6379 \
  vllm/vllm-openai:latest \
  --model /models/Llama-3.3-70B-Instruct \
  --tensor-parallel-size 2 \
  --host 0.0.0.0 \
  --port 8000

# Verificar que detecta ambas GPUs
docker logs vllm-server | grep "tensor_parallel_size"

6. Probar inferencia distribuida

# Desde cualquier máquina en la red
curl http://192.168.10.1:8000/v1/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "/models/Llama-3.3-70B-Instruct",
    "prompt": "Explica qué es tensor parallelism en 100 palabras",
    "max_tokens": 200
  }'

# Monitorizar GPUs en tiempo real
# En NODO 1
watch -n 1 nvidia-smi

# En NODO 2
watch -n 1 nvidia-smi

Deberías ver ambas GPUs trabajando simultáneamente con utilización >80%.

Networking para Inferencia Distribuida

¿Por Qué 10GbE y No Gigabit?

Durante inferencia distribuida con tensor parallelism, las GPUs intercambian activaciones entre capas:

• Llama 70B: ~2-4 GB/s de tráfico inter-GPU
• Gigabit Ethernet: 125 MB/s teóricos, ~100 MB/s reales
• 10 Gigabit Ethernet: 1,250 MB/s teóricos, ~1,100 MB/s reales

Con Gigabit, las GPUs pasan el 70% del tiempo esperando datos de red. Con 10GbE, pasan el 5% esperando.

Configuración de Red Optimizada

# Configurar IPs estáticas en interfaz 10GbE (ejemplo: ens1)
# En NODO 1
sudo ip addr add 192.168.10.1/24 dev ens1
sudo ip link set ens1 up

# En NODO 2
sudo ip addr add 192.168.10.2/24 dev ens1
sudo ip link set ens1 up

# Hacer permanente (netplan en Ubuntu)
cat <

# Instalar ifenslave
sudo apt install -y ifenslave

# Cargar módulo bonding
echo "bonding" | sudo tee -a /etc/modules

# Configurar bond0 (netplan)
cat <

#!/bin/bash
# cache_model.sh - Cachea modelo desde NFS a local

MODEL_NAME=$1
NFS_PATH="/mnt/models"
CACHE_PATH="/var/cache/models"

if [ ! -d "$CACHE_PATH/$MODEL_NAME" ]; then
    echo "📦 Cacheando $MODEL_NAME desde NFS..."
    rsync -avP "$NFS_PATH/$MODEL_NAME" "$CACHE_PATH/" --bwlimit=1000000  # 1 GB/s max
    echo "✅ $MODEL_NAME cacheado localmente"
else
    echo "✅ $MODEL_NAME ya está en caché"
fi

echo "$CACHE_PATH/$MODEL_NAME"

# Comprimir modelo inactivo
zstd -19 --threads=16 /mnt/cold/llama-3.1-405b-q4.gguf

# Ahorra ~30-40% de espacio
# Descomprimir cuando lo necesites (1-2 min en CPU moderno)
zstd -d /mnt/cold/llama-3.1-405b-q4.gguf.zst

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus-data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.retention.time=30d'
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    volumes:
      - grafana-data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    restart: unless-stopped

  nvidia-exporter-node1:
    image: utkuozdemir/nvidia_gpu_exporter:latest
    container_name: nvidia-exporter-node1
    ports:
      - "9835:9835"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped

volumes:
  prometheus-data:
  grafana-data:

global:
  scrape_interval: 5s

scrape_configs:
  - job_name: 'nvidia-gpu-node1'
    static_configs:
      - targets: ['192.168.10.1:9835']
        labels:
          node: 'nodo1'

  - job_name: 'nvidia-gpu-node2'
    static_configs:
      - targets: ['192.168.10.2:9835']
        labels:
          node: 'nodo2'

cd ~/monitoring
docker compose up -d