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 🚀.

Paso 4: instalar CUDA Toolkit

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

Paso 6: habilitar el NVIDIA Container Toolkit

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.

Arma tu propio Servidor de Inteligencia Artificial Privado con Debian 12 + NVIDIA y Docker

Arma tu propio Servidor de Inteligencia Artificial Privado con Debian 12 + NVIDIA y Docker

Introducción

Beneficios de tener tu propio Servidor de IA Privado

Punto de partida: un servidor en blanco

Verificar la placa de video

Paso 1: habilitar repositorios no libres en Debian

Paso 2: fijar versión de los controladores NVIDIA

Paso 3: instalando los controladores NVIDIA

Paso 4: instalar CUDA Toolkit

Paso 5: instalando Docker en Debian 12 (opcional)

Paso 6: habilitar el NVIDIA Container Toolkit

Paso 7: la prueba final dentro de un contenedor

Paso 8: desplegar Ollama con WebUI

Validar Ollama por API

Conclusión

Artículos Relacionados