Ollama API sin contraseña: riesgos y tres soluciones
Ollama no incluye autenticación: cualquiera con acceso al puerto 11434 puede ejecutar, descargar y eliminar modelos. Conoce las tres soluciones, en orden.
La API de Ollama no tiene contraseña
La API de Ollama no tiene autenticación. No hay usuario, contraseña ni comprobación de clave de API para los clientes entrantes. Cualquier cliente que pueda abrir una conexión TCP al puerto 11434 puede enumerar sus modelos, ejecutarlos, descargar otros y eliminar los que ya tiene.
La documentación oficial lo indica claramente: «La API local en http://localhost:11434 no requiere autenticación». La palabra local define todo el modelo de seguridad. Ollama se enlaza a 127.0.0.1 de forma predeterminada, por lo que, en un portátil, la interfaz de loopback actúa como control de acceso. Si cambia ese listener a una dirección pública, el control de acceso desaparece, porque nada lo sustituye.
Por eso esto es importante en un VPS (servidor privado virtual). La configuración predeterminada es segura. El primer cambio que suele hacerse, abrir el listener para que otra máquina pueda usar el modelo, es precisamente el que elimina todas las protecciones de una vez.
Lo que expone un puerto 11434 abierto
Todos los endpoints. No hay un modo de solo lectura ni un puerto de administración independiente. Estas son las solicitudes reales, dirigidas a la dirección del servidor en lugar de localhost:
# List every model on the box
curl http://SERVER_IP:11434/api/tags
# See what is loaded into memory right now
curl http://SERVER_IP:11434/api/ps
# Run a prompt on your hardware
curl http://SERVER_IP:11434/api/generate -d '{"model":"llama3.2","prompt":"Why is the sky blue?"}'
# Write several gigabytes to your disk
curl http://SERVER_IP:11434/api/pull -d '{"model":"llama3.2"}'
# Remove a model
curl -X DELETE http://SERVER_IP:11434/api/delete -d '{"model":"llama3.2"}'Desde el punto de vista operativo, se producen cuatro problemas:
- Tu CPU o GPU ejecuta inferencias para otra persona. En un plan con una cuota de CPU de uso razonable, una carga sostenida consume tu cuota por parte de un desconocido, y mantener bajo control los costes de las cargas de trabajo de IA en un VPS resulta mucho más difícil cuando no eres el único cliente.
/api/pullescribe en tu disco. El tamaño de los modelos varía; inclusollama3.2:1bocupa 1.3 GB. Un ciclo de descargas llena el volumen, y un disco lleno interrumpe todos los demás servicios del equipo, no solo Ollama.- Las solicitudes llegan a tu proceso y se registran. Con el nivel de registro predeterminado, Ollama registra solo metadatos: el endpoint, el estado, la latencia y la dirección del cliente, no el texto del prompt. Sigue siendo un registro de quién usó tu equipo y para qué, almacenado en tu journal, que tú no decidiste recopilar.
/api/deleteelimina modelos. Para recuperarlos hay que descargarlos de nuevo usando tu propio ancho de banda.
Nada de esto requiere un exploit. Es la API documentada funcionando exactamente según su diseño.
La clave Ed25519 no controla el acceso
Si buscas "Ollama API key", encontrarás dos elementos diferentes. Ninguno es una contraseña para tu servidor. Distinguirlos elimina la mayor parte de la confusión.
El primero es el par de claves de identidad. Ollama genera un par de claves Ed25519 en el primer inicio. En Linux, el script de instalación crea un usuario del sistema llamado ollama, con el directorio de inicio en /usr/share/ollama. Por tanto, el par se encuentra aquí:
/usr/share/ollama/.ollama/id_ed25519
/usr/share/ollama/.ollama/id_ed25519.pubEsta clave se usa para la comunicación saliente. ollama signin registra la parte pública en tu cuenta de ollama.com. También autoriza el envío de un modelo al registro o la descarga de un modelo privado. Identifica tu máquina ante ollama.com. No solicita nada a los clientes que se conectan a tu máquina. Eliminarla, rotarla o no crearla no cambia quién puede llamar a tu API.
El segundo es OLLAMA_API_KEY. Esa variable contiene una clave que creas en https://ollama.com/settings/keys. Tu cliente la envía como Authorization: Bearer $OLLAMA_API_KEY al llamar a la API alojada en https://ollama.com/api. Es una credencial para su servicio, que tú utilizas como cliente. Tu propio ollama serve no la usa para autenticar las solicitudes entrantes. Establecer OLLAMA_API_KEY en tu VPS no añade una contraseña a tu VPS.
Por tanto, no hay ninguna opción que activar. Las tres defensas siguientes funcionan de la misma forma: mantener el puerto inaccesible y colocar delante algo que sí compruebe la autenticación.
Compruebe en qué direcciones está escuchando ahora el servidor
sudo ss -tlnp | grep 11434El resultado seguro muestra la dirección de loopback:
LISTEN 0 4096 127.0.0.1:11434 0.0.0.0:* users:(("ollama",pid=812,fd=3))El resultado expuesto muestra todas las interfaces:
LISTEN 0 4096 0.0.0.0:11434 0.0.0.0:* users:(("ollama",pid=812,fd=3))0.0.0.0 representa todas las direcciones IPv4 del sistema, incluida la pública. *:11434 y [::]:11434 son listeners comodín en todas las direcciones IPv6. Que también acepten IPv4 depende de la opción IPV6_V6ONLY del socket, que Linux deja desactivada de forma predeterminada (net.ipv6.bindv6only=0). Por tanto, considere expuestas cualquiera de las tres.
Ahora confirme el acceso desde fuera. Ejecute esto en su equipo portátil, no en el servidor:
curl -m 5 http://YOUR_SERVER_IP:11434/api/versioncurl: (28) Connection timed out after 5001 milliseconds es la respuesta esperada, al igual que curl: (7) Failed to connect ... Connection refused. Un objeto JSON que incluya un campo version indica que cualquier persona que lo solicite puede acceder a toda la API. Probar con curl en el propio servidor no demuestra que otra máquina pueda acceder a él. Si el servidor tiene una dirección IPv6, repita la prueba contra ella con curl -6 -m 5 http://[YOUR_SERVER_IPV6]:11434/api/version, porque un puerto IPv4 cerrado no dice nada sobre un listener IPv6.
La exposición suele producirse de una de estas dos formas. La primera es una modificación deliberada, porque alguien necesitaba que otra máquina accediera al modelo:
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"Esa única línea es toda la exposición. La segunda forma es Docker, y no requiere editar nada. Se explica en su propia sección más adelante.
Defensa 1: mantenerlo en localhost y acceder mediante un túnel
Pruebe esta opción primero. No requiere instalar software nuevo ni crea credenciales que puedan filtrarse. El puerto nunca existe en una interfaz pública, por lo que un escaneo no puede encontrarlo.
Establezca explícitamente la dirección de escucha en lugar de depender del valor predeterminado:
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_HOST=127.0.0.1:11434"Esto escribe /etc/systemd/system/ollama.service.d/override.conf. Aplíquelo y compruébelo:
sudo systemctl daemon-reload
sudo systemctl restart ollama
sudo ss -tlnp | grep 11434ss debería mostrar ahora 127.0.0.1:11434. Si todavía muestra 0.0.0.0, otro archivo drop-in tiene prioridad. Ejecute systemctl cat ollama.service para mostrar la unidad y todos los archivos drop-in con sus rutas, y elimine el que esté obsoleto.
Para usar el modelo desde su portátil, reenvíe el puerto mediante SSH:
ssh -N -L 11434:127.0.0.1:11434 you@your-server-L 11434:127.0.0.1:11434 abre el puerto 11434 en su portátil y envía todo lo que llega allí a 127.0.0.1:11434, visto desde el servidor. -N indica a SSH que no ejecute ningún comando remoto, por lo que el proceso sólo mantiene abierto el túnel. Mientras se ejecuta, esto funciona en su portátil:
curl -s http://localhost:11434/api/tagsEncontrará dos fallos habituales. bind [127.0.0.1]:11434: Address already in use significa que esa dirección y ese puerto locales ya están en uso, ya sea por Ollama, por otro túnel SSH o por otro programa. Elija otro puerto local con -L 11500:127.0.0.1:11434 y dirija el cliente al puerto 11500. Si una solicitud a través del túnel devuelve una respuesta vacía, compruebe ss en el servidor y la salida de errores de SSH antes de determinar qué servicio ha fallado.
Para varias máquinas cliente, una red privada es mejor que un túnel por persona. Conecte las máquinas mediante WireGuard o Tailscale y vincule Ollama a su dirección en esa red, en lugar de vincularlo a 0.0.0.0:
[Service]
Environment="OLLAMA_HOST=10.8.0.1:11434"El puerto sólo existirá en una interfaz a la que sea necesario acceder con una clave. Esto también evita que un error del firewall lo exponga, porque una regla que permita accidentalmente el acceso desde cualquier origen no puede exponer un servicio de escucha que la interfaz pública no tenga.
Defensa 2: un proxy inverso que comprueba un token bearer
Cuando algo en Internet público debe llamar al modelo, mantenga Ollama en loopback y coloque un proxy delante. El proxy termina TLS (seguridad de la capa de transporte) y rechaza las peticiones que no incluyan la cabecera correcta. Ollama sigue aceptando conexiones sólo desde 127.0.0.1, por lo que el proxy es la única ruta de acceso.
Genere primero un token real. No lo invente manualmente:
openssl rand -base64 36Un sitio de nginx que lo comprueba:
map $http_authorization $ollama_ok {
default 0;
"Bearer PASTE_YOUR_GENERATED_TOKEN_HERE" 1;
}
server {
listen 443 ssl;
server_name llm.example.com;
ssl_certificate /etc/letsencrypt/live/llm.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/llm.example.com/privkey.pem;
location = /api/pull { return 403; }
location = /api/delete { return 403; }
location = /api/push { return 403; }
location / {
if ($ollama_ok = 0) { return 401; }
proxy_pass http://127.0.0.1:11434;
proxy_set_header Host 127.0.0.1:11434;
proxy_buffering off;
proxy_read_timeout 600s;
}
}Cinco líneas hacen el trabajo real. Cada una evita un fallo que, de otro modo, encontraría.
if dentro de un bloque location suele ser una mala idea en nginx, pero un cuerpo de exactamente return es una de las dos formas que se comportan de manera predecible, por lo que este uso es seguro.
location = /api/pull es una coincidencia exacta, y nginx da prioridad a las coincidencias exactas sobre el prefijo location /. Por tanto, esos tres endpoints se rechazan antes de comprobar el token. Un token válido todavía permite acceder a otros endpoints de administración del modelo, incluidos /api/create y /api/blobs/:digest, por lo que estos tres bloques no impiden todas las escrituras en disco.
proxy_set_header Host 127.0.0.1:11434; es importante porque Ollama inspecciona las cabeceras Host y Origin entrantes. Pasar directamente el nombre de host público del proxy puede producir un 403 Forbidden procedente de Ollama y no de nginx, lo que dificulta la depuración. OLLAMA_ORIGINS es el otro mecanismo, para un cliente de navegador que necesita permitir un origen específico.
proxy_buffering off; es importante porque Ollama transmite su respuesta token a token. Con el almacenamiento en búfer activado, nginx almacena la respuesta antes de enviarla, lo que retrasa la entrega de los tokens transmitidos.
proxy_read_timeout 600s; es importante porque nginx usa 60 segundos de forma predeterminada. Ese temporizador se ejecuta entre dos lecturas sucesivas de Ollama, no durante toda la respuesta. Una respuesta transmitida que sigue generando tokens reinicia el temporizador cada vez. Una petición en la que Ollama no envía nada durante 60 segundos lo activa. Esto puede ocurrir con una petición enviada mediante "stream": false, que devuelve la respuesta completa al final, o tras un silencio prolongado antes de que llegue el primer token. El cliente recibe 504 Gateway Time-out y /var/log/nginx/error.log registra upstream timed out (110: Connection timed out) while reading response header from upstream. La petición seguía procesándose. nginx la abandonó.
Recargue y pruebe ambas rutas:
sudo nginx -t && sudo systemctl reload nginx
curl -s -o /dev/null -w '%{http_code}\n' https://llm.example.com/api/tags
curl -s -H "Authorization: Bearer YOUR_TOKEN" https://llm.example.com/api/tagsLa primera debería mostrar 401. La segunda debería mostrar la lista de modelos. Si la primera también devuelve la lista de modelos, compruebe qué servidor y qué ubicación gestionaron la petición y si la recarga se completó correctamente. Un bloque map en el ámbito incorrecto invalida la configuración. Debe estar en el nivel http, así que colóquelo en un archivo bajo /etc/nginx/conf.d/ o por encima del bloque server, nunca dentro de server.
Caddy hace el mismo trabajo con autenticación básica en cuatro líneas. Esto se adapta mejor a un cliente de navegador que un token bearer:
llm.example.com {
basic_auth {
apiuser PASTE_BCRYPT_HASH_HERE
}
reverse_proxy 127.0.0.1:11434
}Ejecute caddy hash-password para generar el hash bcrypt que espera. Hay un detalle sobre el nombre: la directiva era basicauth antes de Caddy v2.8 y ahora es basic_auth. Caddy todavía acepta la forma antigua como alias obsoleto, por lo que una configuración copiada de una guía anterior se carga, pero Caddy advierte que basicauth está obsoleta y le pide que use basic_auth. Cámbiela cuando vea esa advertencia.
Independientemente del proxy que elija, se trata de un único secreto compartido por todos. Todos los clientes que lo poseen tienen el mismo acceso, y revocarlo implica editar la configuración y actualizar todos los clientes al mismo tiempo.
Defensa 3: una gateway que emite claves por cliente
Cuando más de una persona o aplicación llama al modelo, un token compartido deja de ser suficiente. No puede saber qué cliente causó la carga ni bloquear a uno sin bloquearlos a todos. Una gateway ocupa el lugar del proxy, utiliza la misma API compatible con OpenAI, emite una clave independiente para cada cliente y registra el uso de cada clave. Una gateway LiteLLM autohospedada suele ser la opción habitual. Además del control de acceso, añade presupuestos por clave y registros de solicitudes.
La regla de la defensa 1 no cambia. Ollama se enlaza a 127.0.0.1, la gateway es el único proceso que se comunica con él y la gateway es el único servicio con un puerto público a la escucha. Una gateway en un equipo cuyo puerto 11434 sigue abierto a Internet es sólo decorativa, porque los clientes pueden evitarla fácilmente.
La trampa del firewall: un puerto de contenedor publicado omite UFW
Por eso hay instancias expuestas en servidores cuyos administradores configuraron correctamente el firewall.
UFW (uncomplicated firewall) escribe sus reglas en la cadena INPUT de la tabla filter del kernel, y INPUT gestiona los paquetes dirigidos al propio host. La opción -p de Docker escribe una regla de NAT de destino (traducción de direcciones de red) en la cadena PREROUTING de la tabla nat, que el kernel evalúa antes de decidir adónde se dirige el paquete. Cuando se toma la decisión de enrutamiento, el destino ya se ha reescrito a la dirección del contenedor. Por tanto, el paquete se reenvía en lugar de entregarse localmente y atraviesa FORWARD en vez de INPUT. Las reglas INPUT de UFW nunca se consultan. El paquete rodea el firewall en lugar de atravesarlo.
Por eso esta secuencia deja abierto a Internet el puerto 11434:
sudo ufw default deny incoming
sudo ufw enable
docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollamaY sudo ufw status sigue mostrando que el firewall está activo con una política predeterminada de denegación. Ambas lecturas son correctas al mismo tiempo. Precisamente por eso se confía en la lectura equivocada. Puede ver la regla responsable:
sudo iptables -t nat -L DOCKER -nLa solución consiste en indicar una dirección en la opción de publicación:
docker rm -f ollama
docker run -d -v ollama:/root/.ollama -p 127.0.0.1:11434:11434 --name ollama ollama/ollama-p 11434:11434 no especifica ninguna dirección del host. Por eso Docker publica el puerto en todas las direcciones del host, tanto IPv4 (0.0.0.0) como IPv6 ([::]). Especificar 127.0.0.1 vincula el lado del host de la asignación a loopback. Así, el túnel SSH y el reverse proxy todavía pueden acceder al puerto, pero Internet no. Las versiones de Docker anteriores a 28.0.0 tienen una excepción: los equipos del mismo segmento de red pueden acceder a los puertos publicados en localhost. Actualice Docker antes de depender de esta protección. Recrear el contenedor es seguro en este caso porque los modelos están en el volumen con nombre ollama, no dentro del contenedor.
Confirme que ambas vistas coinciden:
docker port ollama
sudo ss -tlnp | grep 11434docker port ollama debería mostrar 11434/tcp -> 127.0.0.1:11434. Si muestra 0.0.0.0:11434 o [::]:11434, el servicio sigue expuesto. Cuando aprende este mecanismo, puede aplicarlo a cualquier contenedor que publique: por qué los puertos publicados de Docker omiten UFW explica la cadena DOCKER-USER y las reglas que permanecen después de reiniciar Docker. Si todavía está definiendo la política del host, las reglas de UFW que necesita un VPS nuevo explica la base sobre la que se apoya. En Rocky o AlmaLinux no hay que configurar UFW. En ese caso, empiece por la misma política base escrita en firewalld.
Quién ejecuta el proceso
El script de instalación de Linux crea una cuenta dedicada y ejecuta el servicio con ella:
useradd -r -s /bin/false -U -m -d /usr/share/ollama ollamaLa unidad en /etc/systemd/system/ollama.service establece User=ollama y Group=ollama. No modifique esa configuración. Un ollama serve iniciado manualmente en una terminal se ejecuta con la cuenta del usuario que inició sesión. Si esa cuenta es root, una API sin autenticación puede escribir archivos como root. Compruebe cuál es el caso:
ps -o user= -C ollamaLa respuesta debe ser ollama. Cualquier otro resultado indica que hay un proceso iniciado manualmente ejecutándose junto a la unidad o en lugar de ella. El mismo criterio se aplica a cada daemon que añada más adelante, y ejecutar servicios con usuarios con privilegios mínimos permite configurarlo correctamente.
Cómo comprobar que el endpoint de la API de Ollama es seguro
Independientemente de la opción elegida, una prueba lo confirma y debe ejecutarse desde otra máquina:
curl -m 5 http://YOUR_SERVER_IP:11434/api/version
curl -m 5 http://YOUR_SERVER_IP:11434/api/tagsAmbos intentos deben agotar el tiempo de espera o ser rechazados. Si configuró un proxy, las mismas dos rutas en el nombre de host del proxy deben devolver 401 sin credenciales y JSON real con ellas.
Después, revise una vez el registro de acceso para las solicitudes realizadas mientras el puerto estaba abierto:
journalctl -u ollama --since "-30 days" | grep GINOllama escribe una línea por solicitud e incluye la dirección del cliente:
[GIN] 2026/08/12 - 14:01:10 | 200 | 103.965898ms | 127.0.0.1 | POST "/api/generate"Esa dirección procede de ClientIP() de Gin, que también comprueba las cabeceras X-Forwarded-For y X-Real-IP procedentes de proxies de confianza. Por tanto, una solicitud a través de un proxy inverso de loopback puede mostrar la dirección pública del cliente mientras Ollama está correctamente vinculado a 127.0.0.1. Una dirección pública en esa columna no demuestra que exista acceso directo al puerto 11434, y la ausencia de líneas coincidentes no demuestra que nadie haya llegado a él. Compare las marcas de tiempo con los registros del proxy y la configuración, y use la prueba de conexión externa para comprobar la exposición actual. Si esta parte del modelo es nueva para usted, ejecutar Ollama en un VPS explica la instalación, el dimensionamiento del modelo y los límites de memoria que determinan qué se cargará realmente.
FAQ
¿Ollama tiene una clave de API o una contraseña?
No. El servidor que ejecuta no tiene ningún tipo de autenticación, y la documentación oficial indica que la API local no requiere autenticación. Las dos cosas denominadas «clave de API de Ollama» apuntan en otra dirección. El par Ed25519 de /usr/share/ollama/.ollama/ demuestra la identidad de su máquina ante ollama.com para que pueda enviar modelos y descargar modelos privados. OLLAMA_API_KEY es una credencial que el cliente envía a la API alojada en https://ollama.com/api. Su propio ollama serve no usa ninguna de las dos para autenticar a los clientes entrantes, por lo que el control de acceso debe proceder de la red o de un proxy situado delante.
¿Es seguro OLLAMA_HOST=0.0.0.0 si tengo un firewall?
Sólo si el firewall bloquea correctamente el acceso a ese listener. 0.0.0.0 significa que el listener existe realmente en la interfaz pública y que confía únicamente en el firewall para mantenerlo inaccesible. Un puerto de Ollama publicado por Docker requiere atención aparte, porque la regla DNAT que Docker añade a la tabla nat se evalúa antes de que el paquete llegue a la cadena INPUT, donde se encuentra UFW; por tanto, el paquete se reenvía y las reglas INPUT de UFW nunca lo ven. Enlazar con 127.0.0.1 o con la dirección de un túnel privado elimina el listener de la interfaz pública, por lo que un error del firewall ya no puede exponer nada.
¿Cómo compruebo si mi puerto de Ollama está abierto a Internet?
Ejecute sudo ss -tlnp | grep 11434 en el servidor y curl -m 5 http://YOUR_SERVER_IP:11434/api/version desde otra máquina. Que ss muestre 127.0.0.1:11434 y que curl remoto agote el tiempo de espera es el resultado que busca. Si ss muestra 0.0.0.0:11434 o *:11434 y curl remoto devuelve JSON, significa que se puede acceder a la API completa. Probar con curl en el propio servidor no demuestra si otra máquina puede acceder a él.
¿Puedo cambiar el puerto de 11434 a uno aleatorio?
No, y conviene explicar el motivo. Usar otro puerto no ralentiza nada, salvo un análisis de un único puerto. Los escáneres recorren todo el rango, y una petición a /api/tags identifica el servicio independientemente del puerto al que haya llegado. Cambiar el puerto también rompe los valores predeterminados de todos los clientes y dificulta entender su propia configuración más adelante. Enlace con loopback en su lugar; así elimina el listener en vez de trasladarlo.
Alguien accedió a mi Ollama abierto. ¿Qué debo comprobar?
Enlace primero con 127.0.0.1 y reinicie el servicio para detener la exposición antes de iniciar la investigación. Después, ejecute journalctl -u ollama --since "-30 days" | grep GIN para revisar las direcciones de los clientes, los endpoints y las marcas de tiempo. Gin también lee las cabeceras reenviadas con la dirección del cliente, por lo que debe comparar esas entradas con los registros del proxy antes de considerar una dirección como prueba de acceso directo. Compare ollama list con los modelos que esperaba tener, porque /api/pull no requiere autenticación y un modelo que no descargó representa tanto uso de disco como una evidencia. Compruebe el espacio libre con df -h. El registro de acceso predeterminado contiene metadatos de la petición, no el nombre del modelo, el texto de la solicitud ni la respuesta generada.