Ollama en Proxmox con GPU passthrough: corre Qwen 2.5 32B en local

La economía cambió. Hace no tanto, correr un modelo de 32B parámetros en local significaba una GPU de consumo de más de $3.000 o conformarte con un 7B que frustra con su razonamiento superficial. Hoy, con un nodo de Proxmox y una GPU de consumo con suficiente VRAM, puedes correr Qwen 2.5 32B con cuantización Q4 y obtener respuestas que, para muchas tareas de ingeniería, compiten con los modelos de la nube, a costo marginal cero por consulta.

Esta guía te lleva por el setup completo y te ayuda a evitar las horas de depuración que suelen causar los fallos de VFIO y los grupos IOMMU. Así se hace bien a la primera.

Passthrough de GPU vs. un equipo dedicado a IA

La pregunta obvia: ¿por qué no correr Ollama directamente en bare metal? Por dos razones:

Proxmox te da snapshots y vuelta atrás. Experimentar con versiones de drivers CUDA, distintas builds de Ollama o configuraciones de modelos es mucho menos riesgoso cuando puedes hacer un snapshot de la VM antes de romper algo. Volver atrás te salva cuando una actualización de nvidia-driver-545 rompe en silencio tu stack de inferencia.

Compartir recursos. Cuando la GPU no está haciendo inferencia, puedes usarla en otras VMs (una VM a la vez sin SR-IOV, que las tarjetas de consumo no soportan). Por ejemplo, una RTX 3060 de 12 GB puede servir también para transcodificar en Jellyfin cuando la VM de IA está suspendida.

La contrapartida es una pequeña pérdida de rendimiento (~3-5% frente a bare metal) y el dolor inicial de configurar el passthrough. Para un homelab, vale la pena.

Requisitos previos

• Proxmox VE 8.x
• CPU con soporte IOMMU (Intel VT-d o AMD-Vi activado en la BIOS)
• La GPU en su propio grupo IOMMU, o disposición a pasar el grupo completo
• Una VM con Ubuntu 22.04 LTS
• GPU: una RTX 3060 de 12 GB es un buen punto de partida, pero ten en cuenta que Qwen 2.5 32B en Q4 pesa unos 20 GB, así que con 12 GB de VRAM Ollama tiene que dejar parte del modelo en la CPU (y será bastante más lento). Para que un 32B quepa entero en la GPU necesitas 24 GB, como una RTX 3090; una RTX 3080 o una RTX 3060 de 12 GB rinden mejor con modelos de 7B-14B
• Al menos 32 GB de RAM DDR4 en el sistema (64 GB o más recomendados para modelos grandes y para la descarga parcial a CPU)
• Un SSD NVMe rápido para guardar los modelos: los de 32B pesan ~20 GB cada uno y se van acumulando

Paso 1: activa IOMMU en el host de Proxmox

Edita GRUB en el host de Proxmox:

nano /etc/default/grub

# Intel:
GRUB_CMDLINE_LINUX_DEFAULT="quiet intel_iommu=on iommu=pt"

# AMD:
GRUB_CMDLINE_LINUX_DEFAULT="quiet amd_iommu=on iommu=pt"

update-grub

El flag iommu=pt (passthrough) reduce la sobrecarga para los dispositivos que no se pasan a la VM y suele resolver problemas de estabilidad que causa iommu=on a secas.

Agrega los módulos VFIO para que carguen al arrancar:

echo "vfio" >> /etc/modules
echo "vfio_iommu_type1" >> /etc/modules
echo "vfio_pci" >> /etc/modules
echo "vfio_virqfd" >> /etc/modules

Pon NVIDIA en la lista negra del host para que no tome la GPU antes que VFIO:

echo "blacklist nouveau" >> /etc/modprobe.d/blacklist.conf
echo "blacklist nvidia" >> /etc/modprobe.d/blacklist.conf
echo "blacklist nvidiafb" >> /etc/modprobe.d/blacklist.conf

Reinicia y verifica:

dmesg | grep -e DMAR -e IOMMU
# Should see: DMAR: IOMMU enabled

Paso 2: identifica el grupo IOMMU de tu GPU

#!/bin/bash
for d in /sys/kernel/iommu_groups/*/devices/*; do
  n=${d#*/iommu_groups/*}; n=${n%%/*}
  printf 'IOMMU Group %s ' "$n"
  lspci -nns "${d##*/}"
done | sort -V

Busca tu GPU y anota todo lo que comparte su grupo. En la mayoría de las placas Intel de consumo, la GPU y su dispositivo de audio HD comparten grupo: tendrás que pasar ambos. Anota los IDs PCI (por ejemplo, 10de:2504 para la RTX 3060 y 10de:228e para su audio).

Asocia VFIO a esos IDs:

echo "options vfio-pci ids=10de:2504,10de:228e" > /etc/modprobe.d/vfio.conf
update-initramfs -u
reboot

Verifica la asociación:

lspci -nnk | grep -A3 "VGA\|3D\|Audio"
# Kernel driver in use: vfio-pci  ← this is what you want

Paso 3: configura la VM

Crea una VM con al menos 16 GB de RAM (24 GB o más recomendados para modelos de 32B). En la interfaz web de Proxmox: VM → Hardware → Add → PCI Device:

• Selecciona tu GPU
• Marca All Functions (pasa la GPU y el audio juntos)
• Marca PCI-Express
• Marca ROM-Bar
• Deja Primary GPU sin marcar para inferencia sin pantalla

Configura el tipo de CPU como host en lugar del predeterminado kvm64: así se exponen AVX-512 y otras extensiones que aprovechan los kernels de cuantización.

Detalle crítico: desactiva el adaptador de pantalla virtual (pon Display en "none") una vez que tengas SSH funcionando. Dejarlo activado mientras pasas una GPU activa la detección de hipervisor del driver de NVIDIA: el famoso "Error 43".

Agrega esto a /etc/pve/qemu-server/.conf:

args: -cpu host,kvm=off

kvm=off oculta la firma del hipervisor KVM al sistema invitado, lo que evita que falle la verificación del driver de NVIDIA.

Paso 4: instala los drivers de NVIDIA en la VM

Arranca Ubuntu 22.04 y luego:

sudo apt update && sudo apt install -y ubuntu-drivers-common
sudo ubuntu-drivers install

# Or pin a version:
sudo apt install -y nvidia-driver-550

sudo reboot

Después de reiniciar:

nvidia-smi
# Should show your GPU name, VRAM, driver version

Si nvidia-smi falla con "couldn't communicate with the NVIDIA driver", o te falta kvm=off o todavía tienes la pantalla virtual activada. Esos dos problemas causan el 90% de los Error 43.

Paso 5: instala y configura Ollama

curl -fsSL https://ollama.com/install.sh | sh

Por defecto, Ollama solo escucha en localhost. Para exponerlo en la red:

sudo systemctl edit ollama

[Service]
Environment="OLLAMA_HOST=0.0.0.0"
Environment="OLLAMA_MODELS=/data/ollama/models"

Conviene guardar los modelos en un volumen aparte (/data), respaldado por un SSD NVMe de 2 TB, para que no compitan con el disco del sistema. Descarga el modelo:

ollama pull qwen2.5:32b

Son unos 20 GB de descarga con cuantización Q4_K_M. La primera carga tarda unos segundos en llenar la memoria; las llamadas siguientes son inmediatas porque los pesos se quedan residentes.

Rendimiento: qué esperar

El rendimiento depende sobre todo de cuánto del modelo cabe en la VRAM:

Como referencia, un modelo de 8B como Llama 3.1 cabe holgadamente en 12 GB y genera texto mucho más rápido en la misma tarjeta. El 32B es más lento, pero la diferencia de calidad se nota en tareas de razonamiento: revisión de código, decisiones de arquitectura, depuración en varios pasos. Para completados rápidos, un 8B o 14B sigue siendo mejor relación calidad-velocidad.

¿Quieres correr modelos de 70B? Necesitas una RTX 3090 de 24 GB con descarga parcial a CPU y bastante RAM, o un par de RTX 3080 de 10 GB con descarga a CPU, aunque esta última opción pierde rendimiento.

Interfaz: Open WebUI

docker run -d \
  --name open-webui \
  --restart unless-stopped \
  -p 3000:8080 \
  -e OLLAMA_BASE_URL=http://<your-vm-ip>:11434 \
  -v open-webui:/app/backend/data \
  ghcr.io/open-webui/open-webui:main

Esto te da una interfaz completa tipo ChatGPT respaldada por inferencia local. Agrégala a tu red de Tailscale y tienes IA privada accesible desde cualquier lugar sin que un solo token salga de tu infraestructura.

Hardware recomendado según presupuesto

Si vas a armar un nodo dedicado para esto en lugar de reutilizar hardware:

• Económico (~$400-500): un Minisforum UM870 con una RTX 3060 de 12 GB usada en una carcasa de GPU externa, o una estación de trabajo usada con ranura PCIe; ideal para modelos de 7B-14B
• Gama media (~$800-1000): una torre con RTX 3080 de 10 GB + 64 GB de RAM DDR4: 14B en GPU y 32B con descarga parcial a CPU
• Gama alta (~$1500+): RTX 3090 de 24 GB + 128 GB de DDR4: 32B entero en GPU y 70B con descarga parcial a CPU

Advertencias y cuándo no hacerlo

Cuándo el passthrough de GPU no vale la pena:

• Tu GPU comparte grupo IOMMU con otros dispositivos que necesitas. Existe el parche ACS override como solución, pero es un riesgo para la estabilidad del kernel.
• Necesitas inferencia con varias GPU (70B repartido en dos tarjetas). Las GPU pasadas a una VM no pueden usar NVLink ni transferencias peer-to-peer.
• Puedes tolerar unos pocos tokens por segundo y tienes una CPU con muchos núcleos y 64 GB o más de RAM: la inferencia solo con CPU usando llama.cpp funciona y es mucho más simple.

Alternativas que conviene conocer:

• Contenedores LXC con GPU: Proxmox soporta pasar la GPU a un LXC con un poco menos de sobrecarga que una VM completa, aunque pierdes algo de aislamiento
• Ollama en bare metal: sáltate Proxmox por completo si administrar VMs no es prioridad y tienes un nodo dedicado
• Varios modelos más pequeños: enviar distintos tipos de tareas a modelos de 8B o 32B según la complejidad puede darte mejor rendimiento general que usar siempre el de 32B

En resumen

Una vez que el passthrough de GPU funciona en Proxmox, simplemente funciona. El costo de configuración único se paga rápido: inferencia de LLMs de nivel producción a costo cero por consulta, en hardware que ya tienes, con control total sobre las versiones de los modelos y sin que ningún dato salga de tu red.

Qwen 2.5 32B maneja bien muchas de las tareas típicas de ingeniería: revisión de código, generación de SQL o redactar mensajes de commit a partir de diffs. Con la VRAM adecuada, es una pieza de infraestructura que vale la pena tener.

Algunos enlaces de este artículo son de afiliado de Amazon. Si compras a través de ellos, puedo ganar una pequeña comisión sin costo extra para ti.