Arma tu propio Servidor de Inteligencia Artificial Privado con Debian 12 + NVIDIA y Docker
Introducción
¿Tienes grandes planes en el ámbito de la Inteligencia Artificial y quieres llevar a cabo tus proyectos por tu cuenta? ¿Deseas desarrollar soluciones personalizadas para tu negocio o clientes sin depender de servicios externos?
Tener un Servidor de IA Privado te brinda la libertad y el control para implementar proyectos de manera individual y segura. Muchas empresas se enfrentan a obstáculos como altos costos de hardware, limitaciones de seguridad o infraestructuras poco flexibles. Con un entorno bien configurado en tu propio servidor, esos problemas desaparecen: puedes enfocarte en el desarrollo de tus modelos y aplicaciones, manteniendo el control total sobre los datos y la infraestructura.
Este artículo muestra, en un recorrido práctico, cómo preparar un servidor con Debian 12 + GPU NVIDIA + Docker, pensado para correr proyectos de IA de forma ordenada, estable y profesional. El objetivo no es solo listar comandos, sino compartir la experiencia real: qué configuraciones aplicar, cómo resolver incompatibilidades y qué buenas prácticas seguir para mantener un entorno limpio y controlado.
Beneficios de tener tu propio Servidor de IA Privado
Antes de entrar en lo técnico, vale la pena repasar por qué conviene montar un entorno propio de IA:
- Control total: decides qué modelos correr, cómo configurarlos y dónde almacenar los datos.
- Seguridad: toda la información sensible queda en tu infraestructura, sin depender de terceros.
- Flexibilidad: puedes probar distintos frameworks, librerías y modelos sin limitaciones externas.
- Escalabilidad a medida: comienzas con un servidor y luego puedes crecer según la demanda.
- Rentabilidad: evitas costos recurrentes de servicios en la nube y aprovechas al máximo tu hardware.
- Buenas prácticas: al usar Docker y GPU integradas, mantienes el host limpio y evitas tener que reinstalar el sistema al probar nuevos proyectos.
Con esta base clara, ahora sí pasamos a la preparación técnica del entorno.
Punto de partida: un servidor en blanco
Me gusta comenzar con un host limpio, sin librerías ni paquetes adicionales que se van acumulando cuando probamos distintos proyectos (como múltiples dependencias de Python, compiladores o toolkits). Ese tipo de pruebas termina “ensuciando” el sistema operativo y, al poco tiempo, obliga a formatear el servidor para empezar de nuevo.
Por eso, como buena práctica, elijo preparar un servidor exclusivo para proyectos de IA en Docker, integrando la GPU mediante el NVIDIA Container Toolkit. De esta forma, todo lo que pruebo queda encapsulado en contenedores, el host se mantiene limpio y puedo desplegar o eliminar proyectos sin comprometer la estabilidad del sistema.
Todo arranca con un servidor recién instalado con Debian 12.
Lo primero que pensé fue: “Quiero tener todo lo necesario para correr mis contenedores de IA sin sufrir con configuraciones incompatibles”.
Eso significaba preparar tres cosas clave:
- Drivers NVIDIA
- CUDA Toolkit
- Docker + soporte para GPU
Verificar la placa de video
Antes de comenzar con la configuración, siempre verifico que el sistema detecte correctamente mi GPU NVIDIA. Para eso utilizo:
lspci | grep "VGA"
La salida en mi caso es:
01:00.0 VGA compatible controller: NVIDIA Corporation GA104 [GeForce RTX 3070] (rev a1)
Con esto confirmo que la tarjeta fue reconocida y puedo continuar con la instalación.
Paso 1: habilitar repositorios no libres en Debian
Como buen Debian, los controladores propietarios no vienen activados por defecto.
Lo primero fue sumar contrib, non-free y non-free-firmware a mis repositorios:
apt update
apt install -y software-properties-common
add-apt-repository contrib
add-apt-repository non-free
add-apt-repository non-free-firmware
apt update
Paso 2: fijar versión de los controladores NVIDIA
En la última versión de Debian (12 — Bookworm), los controladores estándar de NVIDIA suelen instalarse solo hasta la versión 535. Sin embargo, al instalar el cuda-keyring, el repositorio oficial de NVIDIA se añade a mis fuentes, lo que hace que el sistema sugiera actualizar a los controladores más recientes (actualmente la versión 570). Aunque esto no representa un problema en sí mismo, puede generar incompatibilidades con herramientas como nvidia-smi, que en mi caso funciona correctamente con la rama 560.
Para evitar este inconveniente, configuro mi sistema para no instalar versiones superiores a 560.35.05-1 creando una política de APT:
tee /etc/apt/preferences.d/controladores-nvidia > /dev/null <<'EOF'
Package: *nvidia*
Pin: version 560.35.05-1
Pin-Priority: 1001
Package: cuda-drivers*
Pin: version 560.35.05-1
Pin-Priority: 1001
Package: libcuda*
Pin: version 560.35.05-1
Pin-Priority: 1001
Package: libxnvctrl*
Pin: version 560.35.05-1
Pin-Priority: 1001
Package: libnv*
Pin: version 560.35.05-1
Pin-Priority: 1001
EOF
Con esto, limito explícitamente todos los paquetes relacionados a NVIDIA a la versión 560.35.05-1 y evito que se actualicen automáticamente a ramas superiores.
Luego actualizo los índices:
apt update
Paso 3: instalando los controladores NVIDIA
Con la política aplicada, instalo directamente la versión deseada:
apt-get install -y nvidia-driver=560.35.05-1
reboot
nvidia-smi
Cuando vi la salida de nvidia-smi mostrando mi GPU lista, supe que estaba en buen camino 🚀.
El siguiente paso fue traer el toolkit CUDA desde los repositorios oficiales de NVIDIA:
wget https://developer.download.nvidia.com/compute/cuda/repos/debian12/x86_64/cuda-keyring_1.1-1_all.deb
dpkg -i cuda-keyring_1.1-1_all.deb
apt-get update
apt-get -y install cuda-toolkit-12-8
reboot
Esto me permitió compilar, probar y ejecutar código optimizado para GPU.
Paso 5: instalando Docker en Debian 12 (opcional)
En CNSoluciones usamos Docker todos los días, pero quería asegurarme de instalarlo limpio, desde el repositorio oficial:
apt-get remove docker.io podman-docker containerd runc
apt-get update
apt-get install ca-certificates curl gnupg
install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.asc
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian $(. /etc/os-release && echo \"$VERSION_CODENAME\") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
apt-get update
apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
Y verifiqué con:
docker run hello-world
El secreto para que Docker use la GPU es el NVIDIA Container Toolkit:
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
apt-get update
apt-get install -y nvidia-container-toolkit
# Configurar Docker para usar NVIDIA como runtime
test -d /etc/docker || sudo mkdir -p /etc/docker
tee /etc/docker/daemon.json > /dev/null <<'EOF'
{
"log-driver": "json-file",
"log-opts": {
"max-size": "10m"
},
"runtimes": {
"nvidia": {
"args": [],
"path": "nvidia-container-runtime"
}
}
}
EOF
systemctl restart docker
Paso 7: la prueba final dentro de un contenedor
Llegó el momento de la verdad.
Quería ver si dentro de un contenedor Docker podía usar mi GPU. Así que corrí:
docker run --rm --gpus all nvidia/cuda:11.0.3-base-ubuntu20.04 nvidia-smi
Cuando la salida de nvidia-smi apareció dentro del contenedor, sentí la satisfacción de que todo había valido la pena 🎉.
Paso 8: desplegar Ollama con WebUI
Para completar la preparación del entorno, me gusta desplegar Ollama junto con su WebUI usando Docker Compose. De esta forma puedo probar rápidamente modelos y tener una interfaz simple.
Primero creo el directorio de trabajo:
mkdir -p /opt/ollama
cd /opt/ollama
Luego creo un archivo docker-compose.yml con este contenido:
services:
ollama:
container_name: ollama
hostname: ollama
image: ollama/ollama:latest
restart: unless-stopped
ports:
- "11434:11434"
environment:
- NVIDIA_VISIBLE_DEVICES=all
- NVIDIA_DRIVER_CAPABILITIES=compute,utility
- CUDA_VISIBLE_DEVICES=0
deploy:
resources:
reservations:
devices:
- driver: nvidia
count: all
capabilities: [gpu]
volumes:
- ./user-data:/root/.ollama
runtime: nvidia
# command: ollama serve
ollama-webui:
container_name: ollama-webui
hostname: ollama-webui
restart: unless-stopped
image: ghcr.io/open-webui/open-webui:latest
depends_on:
- ollama
ports:
- 3000:8080
volumes:
- ./user-open-webui-data:/app/backend/data
environment:
- OLLAMA_URL=http://ollama:11434
Con este archivo listo, simplemente despliego:
docker compose up -d
Y ya tengo corriendo Ollama con acceso vía navegador en http://localhost:3000 🚀.
Como paso adicional, puedo descargar un modelo dentro del contenedor Ollama. Por ejemplo, para bajar y ejecutar llama3**:latest**, utilizo:
docker compose exec ollama ollama run llama3:latest
Validar Ollama por API
Una vez desplegado Ollama y descargado el modelo, valido que la API esté funcionando correctamente.
Primero verifico que el servicio responda:
curl -s http://127.0.0.1:11434/
Salida esperada:
Ollama is running
Luego reviso los modelos instalados:
curl -s http://localhost:11434/api/tags | jq
Ejemplo de salida:
{
"models": [
{
"name": "llama3:latest",
"model": "llama3:latest",
"modified_at": "2025-08-17T13:31:09.994616511Z",
"size": 4661224676,
"digest": "365c0bd3c000a25d28ddbf732fe1c6add414de7275464c4e4d1c3b5fcb5d8ad1",
"details": {
"parent_model": "",
"format": "gguf",
"family": "llama",
"families": [
"llama"
],
"parameter_size": "8.0B",
"quantization_level": "Q4_0"
}
}
]
}
Finalmente, pruebo un chat sencillo:
curl -s http://localhost:11434/api/chat -d '{
"model": "llama3:latest",
"messages": [
{"role": "system", "content": "Eres un asistente útil y respondes en español."},
{"role": "user", "content": "Hola Llama3, ¿cómo estás?"}
]
}' | jq -r 'select(.message.content!=null) | .message.content' | tr -d '
'
Salida esperada:
¡Hola! Estoy funcionando correctamente, gracias por preguntar. Soy una inteligencia artificial entrenada para ayudarte con cualquier pregunta o tarea que tengas. ¿En qué puedo apoyarte hoy?
Conclusión
Así es como preparo mis entornos de IA en Debian 12 con NVIDIA y Docker.
Este camino me permitió tener servidores listos para entrenar modelos de Machine Learning, correr inferencias de IA y mantener una infraestructura estable y portable gracias a los contenedores.
En CNSoluciones trabajamos todos los días en este tipo de desafíos: desde levantar entornos optimizados para IA hasta desplegar sistemas en la nube para nuestros clientes.
Espero que esta información te sirva como guía y te anime a experimentar con tu propia GPU en Docker.
Si querés ayuda para implementar soluciones de IA en tu empresa, podés contactarnos en 👉 cnsoluciones.com.
