Inicio›Guías›Ollama en Docker: el comando, el volumen, el puerto y la GPU, probados en la v0.40.15

Instalar · Guía

Ollama en Docker: el comando, el volumen, el puerto y la GPU, probados en la v0.40.15

Para correr Ollama en Docker: docker run -d -v ollama:/root/.ollama -p 127.0.0.1:11434:11434 --name ollama ollama/ollama y luego docker exec -it ollama ollama run llama3.2. El volumen guarda tus modelos aunque borres el contenedor; el 127.0.0.1 deja el puerto en tu equipo. Probado en la v0.40.15: 3,4 GB de descarga, 8,5 GB en disco.

Medido y escrito por Local AI ScopePublicado el Cifras medidas por Local AI Scope

Para correr Ollama en Docker: docker run -d -v ollama:/root/.ollama -p 127.0.0.1:11434:11434 --name ollama ollama/ollama y luego docker exec -it ollama ollama run llama3.2. El volumen guarda tus modelos aunque borres el contenedor; el 127.0.0.1 deja el puerto en tu equipo. Probado en la v0.40.15: 3,4 GB de descarga, 8,5 GB en disco.

Docker es una forma estupenda de tener Ollama: un comando, nada instalado en el sistema y actualizar es cambiar de imagen. Pero la imagen oficial no es solo «Ollama metido en una caja»: cambia la dirección en la que escucha Ollama, y eso apaga una de sus 2 protecciones. Así que el 6 de noviembre de 2026 bajamos ollama/ollama:0.40.15 a un servidor Linux (Docker 29.9.3, ufw encendido, sin tarjeta NVIDIA y con una gráfica integrada de AMD), cargamos un modelo diminuto de 135 millones de parámetros (smollm2:135m) y medimos qué hace cada opción: puertos, volúmenes, variables, GPU y Compose. Todo lo que aquí dice «medimos» sale de esas pruebas, entre las 15:52 y las 16:01 UTC, y de una más el 7 de noviembre a las 08:21 UTC con el comando de la primera sección; lo que sale de la documentación, lo decimos.

OllamaOllamaFicha del programa

Ollama en Docker con 1 comando (y los 2 detalles que importan)

Este es el comando que te recomendamos. Lo ejecutamos el 7 de noviembre a las 08:21 UTC, con nuestro modelo diminuto en lugar de llama3.2 y una pregunta suelta («Name one planet.») en vez del chat:

docker run -d -v ollama:/root/.ollama -p 127.0.0.1:11434:11434 --name ollama ollama/ollama
docker exec -it ollama ollama run llama3.2
curl http://127.0.0.1:11434/api/version

La primera línea arranca el servidor en segundo plano, la segunda descarga un modelo y abre un chat con él dentro del contenedor (el nuestro se bajó sus 270 MB y contestó sin nombrar ni un planeta, que es más o menos lo que dan de sí 135 millones de parámetros), y la tercera comprueba que la API responde desde tu equipo (a nosotros nos devolvió {"version":"0.40.15"}, y docker port enseñó solo 127.0.0.1:11434). El 127.0.0.1: delante del puerto es el primer detalle que importa, y en las secciones siguientes verás por qué. El segundo es el -v: sin él, tus modelos viven y mueren con el contenedor.

Qué trae la imagen, leído en su configuración y en su Dockerfile: Ubuntu 24.04, el binario ollama (44,2 MB) y 4,64 GB de librerías de GPU en /usr/lib/ollama, que es lo que la hace tan pesada. Corre como root (no hay línea USER; id dentro dijo uid=0(root)), fija OLLAMA_HOST=0.0.0.0:11434 para que el servidor escuche en todas las interfaces del contenedor y no declara ningún volumen. Bajarla fueron 3,39 GB, un minuto y pico con la fibra de nuestro servidor; en disco ocupó 8,51 GB. Tu disco lo va a notar más que tu factura de la luz.

Etiqueta (a 7-11-2026) Qué lleva Plataformas Descarga
latest = 0.40.15 Procesador y NVIDIA (CUDA 12 y 13); Vulkan en amd64 y Jetson (JetPack) en arm64 amd64 y arm64 3,39 GB (amd64) · 2,87 GB (arm64)
rocm = 0.40.15-rocm Procesador y AMD ROCm 7.2.1 Solo amd64 1,46 GB

El 7 de noviembre de 2026 latest era la misma imagen que 0.40.15 (el mismo digest en Docker Hub); desde el 9 de noviembre de 2026 apunta a 0.40.16 (y rocm, a 0.40.16-rocm). Si escribes la versión, como en ollama/ollama:0.40.15, decides tú cuándo actualizar en vez de enterarte después de un docker pull.

Página de Docker Hub de la imagen oficial ollama/ollama, pestaña Tags: rocm para linux/amd64 y latest para linux/amd64 y linux/arm64
La imagen oficial ollama/ollama en Docker Hub. Sus tamaños van en unidades binarias: los 3,16 GB de latest para amd64 son los 3.392 millones de bytes que descargamos Captura: Docker Hub, 7-11-2026

En el vídeo el puerto se publica sin 127.0.0.1, para que lleguen otros equipos de la red: así Ollama queda abierto a toda tu red. Si solo lo usas en tu equipo, añade 127.0.0.1 como contamos más abajo, en el apartado del puerto.

Se abre en YouTube (sin cookies) solo si pulsas.

Que no se pierdan los modelos: volumen con nombre o carpeta

Sin -v, el modelo que descargas va a la capa escribible del propio contenedor. Lo comprobamos: modelo copiado dentro del contenedor, ollama list lo enseñaba, docker rm -f, el mismo docker run otra vez… y ollama list salió vacío. Con un volumen con nombre (-v ollama:/root/.ollama), el mismo borrado y la misma recreación dejaron el modelo en su sitio. En Linux, Docker guardó nuestro volumen de prueba en /var/lib/docker/volumes/<nombre>/_data (el tuyo, en …/ollama/_data), con root como dueño.

La otra opción es una carpeta tuya: -v /home/tu-usuario/ollama:/root/.ollama. Funciona, con una pega que vimos: los ficheros que crea aparecen en tu equipo como de root (uid 0) aunque la carpeta sea tuya, así que para borrarlos luego te hará falta sudo. Si quieres los modelos en otra ruta dentro del contenedor, -e OLLAMA_MODELS=/datos/models los lleva allí, siempre que montes el volumen en esa ruta (-v ollama:/datos): así lo probamos, y ollama list encontró el modelo en esa ruta.

El volumen guarda además un fichero pequeño en el que no se suele pensar. En su primer arranque el servidor crea /root/.ollama/id_ed25519, la clave con la que ese Ollama se identifica ante ollama.com. Sin volumen, cada contenedor nuevo estrena clave.

Para actualizar, el volumen hace todo el trabajo: docker pull ollama/ollama:<versión nueva>, docker rm -f ollama y el mismo docker run con la etiqueta nueva. Los modelos siguen donde estaban. Para quitarlo todo: docker rm -f ollama, docker volume rm ollama y docker rmi ollama/ollama (o la etiqueta que usaras), que libera ese espacio. Para quitar un Ollama instalado fuera de Docker, en Mac, Windows o Linux, mira cómo desinstalar Ollama.

El puerto: 127.0.0.1 o toda tu red (y ufw no lo frena)

Esta es la sección que subrayaríamos dos veces. Con -p 127.0.0.1:11434:11434 medimos que Docker abre el puerto solo en la dirección local: ss -ltn enseñó una única línea 127.0.0.1, curl 127.0.0.1 devolvió la versión y una petición a la dirección de red del propio servidor fue rechazada (esa última prueba, en un puerto alto, el 18434).

La forma corta, -p 11434:11434, es otra historia. La probamos con un servidor web de pega en lugar de Ollama, durante 2 segundos, para no dejar un modelo abierto: docker port enseñó 0.0.0.0 y [::], es decir, todas las direcciones IPv4 e IPv6 de la máquina, y una petición a su dirección de red recibió un 200. Con ufw activo y sin ninguna regla para ese puerto. Docker manda ese tráfico por reglas propias (una redirección en la tabla nat y sus cadenas colocadas antes que las de ufw en FORWARD), y su documentación lo dice sin rodeos: los puertos publicados se saltan los ajustes de ufw. Nuestra petición salió del propio servidor hacia su dirección de red; que otro equipo entre igual es lo que documenta Docker, y las reglas que leímos dicen lo mismo.

Un detalle de la documentación de Docker: antes de Docker 28.0.0, los equipos del mismo segmento de red local podían llegar a los puertos publicados en 127.0.0.1. Mira tu versión con docker version; con la 28 o posterior, 127.0.0.1 es lo que dice. Y si de verdad quieres usar Ollama desde otro equipo, un túnel SSH (ssh -L 11434:127.0.0.1:11434 tu-usuario@servidor) te da la API allí sin abrir nada a la red.

Qué cambia dentro del contenedor: la comprobación de Host y el CORS

Con su dirección de fábrica (127.0.0.1), Ollama tiene 2 barreras contra las páginas web que intentan llegar a tu servidor local. La primera mira la cabecera Host y rechaza los nombres que no conoce, lo que frena el truco de un dominio que apunta a 127.0.0.1 (DNS rebinding). La segunda es el CORS, la lista de orígenes a los que el navegador deja pasar. En nuestra guía de la API de Ollama probamos la primera con el binario a secas escuchando en 127.0.0.1: un 403.

Dentro de la imagen oficial, la primera se apaga. Con la imagen tal cual y el puerto en 127.0.0.1, nuestra petición con un Host inventado (atacante.example) recibió un 200. La misma imagen con -e OLLAMA_HOST=127.0.0.1:11434, en un contenedor sin red y preguntando desde dentro: 403. Con -p esa variable no sirve (el servidor solo escucharía dentro del contenedor). El motivo está en el código (server/routes.go): cuando el servidor escucha en una dirección que no es la de bucle local, no comprueba el Host, y la imagen fija 0.0.0.0. El CORS sí sigue funcionando: un origen ajeno (https://ejemplo.com) recibió un 403 y http://localhost:3000, un 200.

Logotipo de Ollama
Logotipo de Ollama. Dentro de su imagen oficial, la v0.40.15 escucha en 0.0.0.0 y la comprobación de Host queda apagada Logotipo: Ollama

No es para alarmarse: de 2 barreras se apaga una y la otra sigue. Si quieres las 2 en Linux, hay una forma que probamos: --network host -e OLLAMA_HOST=127.0.0.1:11435 (usamos el 11435 para no chocar con nada; si no tienes otro Ollama en la máquina, el 11434 vale). El contenedor usa entonces la red del equipo, ss enseñó solo 127.0.0.1:11435 y el Host inventado volvió a recibir su 403. Sin -p: con --network host no hay nada que publicar. Y nunca --network host sin esa variable: el OLLAMA_HOST=0.0.0.0 de la propia imagen escucharía entonces en todas las direcciones de tu equipo.

Docker Compose: un fichero mínimo que probamos

Lo mismo, en un fichero que puedes guardar. Arrancamos este compose.yaml con docker compose up -d (Compose v5.7.0):

services:
  ollama:
    image: ollama/ollama:0.40.15
    ports:
      - "127.0.0.1:11434:11434"   # solo este equipo; sin la IP delante se abre en todas las direcciones
    volumes:
      - ollama:/root/.ollama      # los modelos sobreviven a down/up y a los cambios de versión
    environment:
      - OLLAMA_NO_CLOUD=1         # sin modelos ni rutas de la nube de Ollama
    restart: unless-stopped

volumes:
  ollama:

Lo que vimos: el puerto solo en 127.0.0.1:11434, la API respondiendo con la versión, la política de reinicio en unless-stopped (según Docker, vuelve tras un fallo o un reinicio de Docker, salvo que lo hayas parado tú) y el volumen montado en /root/.ollama. Un docker compose down seguido de up -d conservó el modelo, y volvió a responder. docker compose down -v borra también el volumen, modelos incluidos: guárdate el -v para cuando lo quieras de verdad. Para chatear con un modelo: docker compose exec ollama ollama run llama3.2. Y OLLAMA_NO_CLOUD=1 no te impide descargar modelos: esa misma mañana del 6 de noviembre, en una prueba anterior con el binario a secas, bajamos uno de ollama.com con la variable puesta.

GPU en Docker: NVIDIA, AMD (ROCm), Vulkan y gráfica integrada

La imagen viene preparada para la tarjeta gráfica, pero Docker no se la pasa si no se lo pides. Lo de NVIDIA y ROCm lo leímos en la documentación de Ollama para la v0.40.15; lo de la gráfica integrada lo probamos.

Estación con RTX 4090 24 GBEstación con RTX 4090 24 GBFicha del equipo

NVIDIA. Primero el NVIDIA Container Toolkit en el anfitrión (del repositorio apt o yum de NVIDIA), después sudo nvidia-ctk runtime configure --runtime=docker y sudo systemctl restart docker, y por último el mismo docker run con --gpus=all. En Windows va por WSL2 con el mismo toolkit. En Compose, la documentación de Docker (leída el 7 de noviembre) pide un bloque deploy dentro del servicio; capabilities es obligatorio y count admite un número o all. No lo hemos ejecutado, porque no tenemos tarjeta NVIDIA:

    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
Tarjeta gráfica NVIDIA GeForce RTX 4090
NVIDIA GeForce RTX 4090. En Docker, Ollama solo ve una tarjeta NVIDIA con el Container Toolkit instalado y --gpus=all (o el bloque deploy en Compose) Foto: NVIDIA

AMD con ROCm. La otra imagen: docker run -d --device /dev/kfd --device /dev/dri -v ollama:/root/.ollama -p 127.0.0.1:11434:11434 --name ollama ollama/ollama:rocm. Solo existe para amd64 y está pensada para tarjetas AMD que funcionan con ROCm.

Vulkan y gráfica integrada (probado). La imagen normal para amd64 también lleva Vulkan, encendido de serie cuando ve los dispositivos. En nuestro servidor, con --device /dev/kfd --device /dev/dri, Ollama encontró la gráfica integrada de AMD («AMD Radeon Graphics (RADV RENOIR)») y acto seguido la descartó: dropping integrated GPU; to enable, set OLLAMA_IGPU_ENABLE=1. Añadimos -e OLLAMA_IGPU_ENABLE=1 y el registro enseñó library=Vulkan, type=iGPU, con las 31 capas del modelo, todas, en la GPU. Con un modelo de 135M no fue más rápida que el procesador: tómalo como «se enciende así», no como velocidad.

PC con Ryzen AI Max+ 395 y 128 GB unificadosPC con Ryzen AI Max+ 395 y 128 GB unificadosFicha del equipo
Framework Desktop, uno de los PC con este chip
Framework Desktop, con el AMD Ryzen AI Max+ 395 y su gran gráfica integrada. Con la imagen normal (Vulkan) necesita OLLAMA_IGPU_ENABLE=1; según el código de Ollama 0.40.15, la imagen rocm la acepta de serie Foto: Framework

En un Mac, mejor sin Docker. Las preguntas frecuentes de Ollama lo dicen claro: Docker Desktop en macOS no pasa la GPU al contenedor, así que trabaja solo con el procesador. La aplicación de Ollama para Mac sí usa la GPU del chip, con Metal.

Mac con M4 y 16 GB unificadosMac con M4 y 16 GB unificadosFicha del equipo

Si la GPU funciona un rato y luego el modelo se cae al procesador, es una trampa conocida de Docker (el controlador de cgroups), y la explicamos, con la prueba de nvidia-smi dentro de un contenedor, en Ollama no funciona.

Se abre en YouTube (sin cookies) solo si pulsas.

Este vídeo corto (en inglés) enseña las 4 comprobaciones fuera de Docker: ollama ps, el registro del servidor, la salida de ollama serve y el monitor de rendimiento del sistema. En un contenedor son las mismas con docker exec ollama delante, y el registro es docker logs ollama.

Sin red y sin nube: OLLAMA_NO_CLOUD, keep_alive y a dónde intenta salir

Las variables se pasan con -e, y comprobamos que la imagen las respeta. Con -e OLLAMA_NO_CLOUD=1 -e OLLAMA_KEEP_ALIVE=30s -e OLLAMA_MODELS=/datos/models, el propio registro del servidor listó las 3 e imprimió Ollama cloud disabled: true. /api/balance, una ruta que pregunta a ollama.com por tu cuenta, respondió 403 sin intentar salir. Y el modelo, después de responder, se quedó en memoria 30 segundos exactos (el expires_at de /api/ps), en vez de los 5 minutos que trae de serie.

¿A dónde intenta salir si no pones nada? Arrancamos la imagen sin esa variable y sin red: en el primer milisegundo intentó 2 llamadas a ollama.com, el catálogo de modelos recomendados y la lista de modelos de la nube, y las 2 fallaron con «network is unreachable». Con OLLAMA_NO_CLOUD=1, ninguna. Si quieres un contenedor 100 % desconectado, --network none lo consigue, siempre que los modelos ya estén en el volumen; la pega es que tampoco publica ningún puerto, así que se entra con docker exec.

Si prefieres instalar Ollama directamente en el sistema, nuestra guía de Ollama en local empieza desde cero, con el túnel SSH paso a paso. Las rutas de la API que acabas de publicar, el CORS y keep_alive están en la API de Ollama, y si las respuestas salen cortadas, la longitud de contexto en Ollama explica cómo subirla. Y si quieres una ventana de chat tipo ChatGPT encima de este contenedor, Open WebUI con Ollama va en un segundo contenedor en la misma red de Docker; medimos a dónde se conecta y cómo dejarlo en cero.