Crea tu HomeLab Casero desde Cero: Guía Evergreen Completa

Introducción

Un homelab es más que un servidor casero: es una plataforma de aprendizaje, experimentación y control total sobre tu infraestructura digital. Esta guía te llevará desde cero hasta un sistema completo con virtualización, contenedores, DNS privado, almacenamiento robusto, backups automatizados, monitorización profesional y seguridad enterprise.

Prerrequisitos

Hardware Mínimo Recomendado

• RAM: 8 GB mínimo (16 GB recomendado)
• Almacenamiento: 100 GB SSD para sistema + discos adicionales para datos
• CPU: 4 núcleos físicos (8+ con Hyper-Threading)
• Red: NIC Gigabit Ethernet mínimo

Software y Conocimientos

• ISO de Proxmox VE disponible en proxmox.com
• Conocimientos básicos de Linux y redes
• Pendrive de 8 GB para instalación

Paso 1: Instalación de Proxmox VE

Descargar e Instalar la ISO

1. Visita proxmox.com/software/proxmox-ve/
2. Descarga la última ISO estable de Proxmox VE
3. Graba en pendrive con Balena Etcher
4. Arranca desde el pendrive y sigue el instalador

Configuración Post-Instalación

⚠️ IMPORTANTE: Desactiva la suscripción enterprise para evitar avisos:

sed -i 's/enterprise/no-subscription/g' /etc/apt/sources.list.d/pve-enterprise.list
apt update && apt dist-upgrade -y

Paso 2: Contenedores LXC con Docker

Crear Contenedor LXC para Docker

Via la UI de Proxmox:

1. Nuevo → Contenedor LXC
2. Plantilla: Debian 12 (bookworm)
3. RAM: 2 GB mínimo
4. Disco: 20 GB
5. Nesting: ACTIVADO (crítico para Docker)
6. Bridge: vmbr0 con IP estática

Instalar Docker en el LXC

# Actualizar y añadir repositorios
curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian bookworm stable" > /etc/apt/sources.list.d/docker.list
apt update && apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

# Iniciar y habilitar Docker
systemctl enable --now docker

Paso 3: DNS Privado con Pi-hole + Unbound

Instalación de Pi-hole (Docker)

version: "3.8"
services:
  pihole:
    container_name: pihole
    image: pihole/pihole:latest
    ports:
      - "53:53/tcp"
      - "53:53/udp"
      - "8080:80/tcp"
    environment:
      TZ: 'Europe/Madrid'
      WEBPASSWORD: 'tu-password-seguro'
      FTLCONF_LOCAL_IPV4: '192.168.1.10'
      PIHOLE_DNS_: '127.0.0.1#5335'
    volumes:
      - './etc-pihole:/etc/pihole'
      - './etc-dnsmasq.d:/etc/dnsmasq.d'
    cap_add:
      - NET_ADMIN
    restart: unless-stopped

Instalación de Unbound (DNS recursivo)

unbound:
  container_name: unbound
  image: mvance/unbound:latest
  ports:
    - "5335:53/tcp"
    - "5335:53/udp"
  volumes:
    - './unbound:/opt/unbound/etc/unbound'
  restart: unless-stopped

Configurar Unbound (/etc/unbound/unbound.conf)

server:
  interface: 127.0.0.1
  port: 5335
  access-control: 127.0.0.1/32 allow
  access-control: ::1 allow
  hide-identity: yes
  hide-version: yes
  cache-min-ttl: 3600
  cache-max-ttl: 86400
  do-tcp: yes
  module-config:
    - validator
    - iterator
  auto-trust-anchor-file: "/var/lib/unbound/root.key"
  prefetch: yes
  num-threads: 2

Configurar Router para usar Pi-hole como DNS

En la configuración DHCP del router:

• Primary DNS Server: IP de Pi-hole (ej. 192.168.1.10)
• Secondary DNS: dejar vacío o 1.1.1.1 como fallback

Paso 4: Almacenamiento con TrueNAS/ZFS

Estrategia de Almacenamiento

• Separación física: Sistema en SSD NVMe, datos en HDDs RAID
• ZFS: Pool con datasets separados por función
• RAID recomendado: RAID-Z2 para 3+ discos (protección contra 2 fallos)

Estructura de Pools Recomendada

tank/                    # Pool principal
├── media/               # Archivos multimedia
├── backups/             # Backups de VMs y contenedores
├── nextcloud/           # Datos Nextcloud
└── docker/              # Volúmenes Docker

Paso 5: Estrategia de Backups

Backups ZFS Automáticos

# Snapshot cada 15 minutos en datasets críticos
*/15 * * * * root zfs snapshot -r tank/media@$(date +\%Y-\%m-\%dT\%H-\%M-\%S)

# Replicación incremental a sitio remoto (WireGuard)
0 * * * * root /usr/local/bin/zfs-replicate.sh

Script de Replicación ZFS

#!/bin/bash
SRC_POOL="tank/media"
DST_HOST="backup.remote"
DST_POOL="backup/media"
SSH_OPTS="-i /root/.ssh/wg_key -o StrictHostKeyChecking=no"

LAST_SENT=$(ssh $SSH_OPTS $DST_HOST "zfs list -t snapshot -H -o name -s creation -r $DST_POOL | tail -1")

if [[ -z $LAST_SENT ]]; then
  SEND_OPTS="-R"
else
  SEND_OPTS="-i $LAST_SENT"
fi

zfs send $SEND_OPTS $SRC_POOL@$(date +\%Y-\%m-\%dT\%H-\%M-\%S) | \\
  ssh $SSH_OPTS $DST_HOST "zfs receive -F $DST_POOL"

Proxmox Backup Server (PBS)

# En Proxmox VE, configurar backup a PBS
pvesm add local-lvm backups --size 50G
pvesm resize local-lvm

Paso 6: Monitorización con Uptime Kuma + Grafana

Stack de Monitorización Docker Compose

version: "3.8"
services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: uptime-kuma
    restart: unless-stopped
    ports:
      - "3001:3001"
    volumes:
      - ./uptime-kuma-data:/app/data
      - /var/run/docker.sock:/var/run/docker.sock:ro

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

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

  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    restart: unless-stopped
    ports:
      - "9100:9100"
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--path.rootfs=/rootfs'
      - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'

volumes:
  prometheus-data:
  grafana-data:

Configurar Prometheus (prometheus.yml)

global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'node'
    static_configs:
      - targets: ['node-exporter:9100']

Monitores Recomendados en Uptime Kuma

Paso 7: Seguridad con Firewall y WireGuard

Configurar UFW (Ubuntu/Debian)

# Permitir SSH solo desde IPs confiables
ufw allow from 192.168.1.0/24 to any port 22 proto tcp

# Permitir tráfico DNS interno
ufw allow from 192.168.1.0/24 to any port 53 proto udp
ufw allow from 192.168.1.0/24 to any port 53 proto tcp

# Permitir servicios web con HTTPS
ufw allow from any to any port 443 proto tcp
ufw allow from any to any port 80 proto tcp

# Denegar todo lo demás por defecto
ufw default deny incoming
ufw default allow outgoing
ufw --force enable

Configurar WireGuard VPN

# Generar claves
cd /etc/wireguard
generate-key > private.key
cat private.key | base64 -w0 > public.key

# Configurar interfaz wg0
cat > /etc/wireguard/wg0.conf <