# Cómo exponer Ollama en un servidor Linux local con Cloudflare Tunnel y un subdominio propio

En esta guía voy a explicar cómo dejar accesible una instancia local de Ollama desde Internet usando Cloudflare Tunnel y un subdominio propio, en este caso `ollama.tonyhelper.com`.

La idea es sencilla: Ollama sigue ejecutándose en local dentro del servidor Linux, pero Cloudflare crea un túnel saliente seguro que permite acceder desde fuera sin abrir puertos en el router y sin depender de una IP pública fija.

## Objetivo

Queremos conseguir que un servidor Linux local con Ollama responda a peticiones externas como esta:

```bash
curl https://ollama.tonyhelper.com/api/tags
```

Y que internamente ese tráfico termine llegando a:

```bash
http://localhost:11434
```

Esto es especialmente útil cuando el servidor está detrás de un router doméstico o de operador, donde la IP pública puede cambiar y donde no siempre interesa abrir puertos hacia el exterior.

## Qué necesitamos

Antes de empezar, conviene tener esto preparado:

*   Un dominio gestionado en Cloudflare, en este caso `tonyhelper.com`.
    
*   Un subdominio que vamos a dedicar a Ollama: `ollama.tonyhelper.com`.
    
*   Un servidor Linux local con Ollama ya instalado y funcionando.
    
*   `cloudflared` instalado en el servidor.
    
*   Acceso a la cuenta de Cloudflare para autorizar la creación del túnel.
    

## Paso 1. Comprobar que Ollama funciona en local

Antes de tocar Cloudflare, lo primero es verificar que Ollama responde correctamente dentro del servidor.

```bash
curl http://127.0.0.1:11434/api/tags
```

Si queremos comprobar que el modelo responde, podemos hacer una prueba sencilla:

```bash
curl http://127.0.0.1:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "prompt": "Di hola en una frase",
    "stream": false
  }'
```

Si estas pruebas funcionan, significa que la base está bien y podemos continuar.

## Paso 2. Instalar `cloudflared`

En Ubuntu o Debian podemos instalar `cloudflared` desde el repositorio oficial de Cloudflare.

```bash
sudo mkdir -p --mode=0755 /usr/share/keyrings
curl -fsSL https://pkg.cloudflare.com/cloudflare-main.gpg | sudo tee /usr/share/keyrings/cloudflare-main.gpg >/dev/null
echo 'deb [signed-by=/usr/share/keyrings/cloudflare-main.gpg] https://pkg.cloudflare.com/cloudflared any main' | sudo tee /etc/apt/sources.list.d/cloudflared.list
sudo apt update
sudo apt install cloudflared
cloudflared version
```

Con esto dejamos instalado el cliente que se encargará de mantener el túnel abierto desde el servidor hacia Cloudflare.

## Paso 3. Autorizar `cloudflared` con nuestra cuenta

El siguiente paso es autenticar el servidor contra la cuenta de Cloudflare:

```bash
cloudflared tunnel login
```

Este comando abre el navegador para iniciar sesión y seleccionar la zona del dominio. Al completarlo, Cloudflare guarda el certificado de cuenta en la carpeta de configuración local.

Podemos comprobarlo así:

```bash
ls -l ~/.cloudflared/cert.pem
```

Ese archivo es importante porque permite crear y gestionar túneles desde la línea de comandos.

## Paso 4. Crear un túnel nombrado

En este caso vamos a usar un nombre claro para el túnel:

```bash
cloudflared tunnel create ollama-aiserver
```

Al ejecutarlo, Cloudflare genera un UUID para el túnel y un archivo JSON de credenciales dentro de `~/.cloudflared/`.

Podemos verlo con:

```bash
cloudflared tunnel list
ls -l ~/.cloudflared/
```

Aquí aparecerá el nombre del túnel, su UUID y el archivo de credenciales correspondiente.

## Paso 5. Crear el DNS del subdominio

Una vez creado el túnel, toca vincular el subdominio `ollama.tu-dominio.com` a ese túnel:

```bash
cloudflared tunnel route dns ollama-aiserver ollama.tu-dominio.com
```

Este comando crea el registro DNS necesario en Cloudflare. A partir de ese momento, `ollama.tu-dominio.com` quedará apuntando al túnel.

## Paso 6. Crear el archivo de configuración

Ahora hay que decirle al túnel qué debe hacer cuando reciba tráfico para ese subdominio.

Creamos o editamos el archivo:

```bash
nano ~/.cloudflared/config.yml
```

Y añadimos este contenido, sustituyendo `TU_UUID` por el UUID real generado al crear el túnel:

```yaml
tunnel: TU_UUID
credentials-file: /home/TU-USUARIO/.cloudflared/TU_UUID.json

ingress:
  - hostname: ollama.tu-dominio.com
    service: http://localhost:11434
    originRequest:
      httpHostHeader: localhost:11434

  - service: http_status:404
```

Este bloque hace algo muy concreto:

*   Cuando llega tráfico para `ollama.tu-dominio.com`,
    
*   Cloudflare lo envía por el túnel,
    
*   y `cloudflared` lo reenvía a `http://localhost:11434`, que es donde escucha Ollama.
    

La cabecera `httpHostHeader: localhost:11434` ayuda a mantener la compatibilidad esperada por Ollama en este escenario.

## Paso 7. Ejecutar el túnel

Con el archivo listo, arrancamos el túnel:

```bash
cloudflared tunnel run
```

También podría arrancarse indicando el nombre:

```bash
cloudflared tunnel run ollama-aiserver
```

Si todo está correcto, el túnel quedará conectado y el subdominio empezará a funcionar como punto de acceso externo al servicio local.

## Paso 8. Probar desde fuera

Desde otro equipo o una red externa, ya podemos probar el subdominio:

```bash
curl https://ollama.tu-dominio.com/api/tags
```

Y también una llamada real al modelo:

```bash
curl https://ollama.tu-dominio.com/api/generate \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "prompt": "Prueba externa",
    "stream": false
  }'
```

Si esta prueba responde correctamente, el despliegue ya está funcionando.

## Qué hemos conseguido con este enfoque

La ventaja de este sistema es que no hemos necesitado:

*   abrir puertos en el router,
    
*   contratar una IP fija,
    
*   configurar DDNS,
    
*   ni exponer directamente el puerto 11434 a Internet.
    

El túnel sale desde el propio servidor Linux hacia Cloudflare, y Cloudflare se encarga de enrutar las peticiones al servicio local de Ollama.

## Siguiente paso recomendable

Una vez comprobado que el acceso funciona, el siguiente paso lógico es endurecer la seguridad.

Lo más recomendable es proteger `ollama.tu-dominio.com` con Cloudflare Access, de modo que solo determinados usuarios o servicios autorizados puedan consumir la API. Esto es especialmente importante si el endpoint va a ser utilizado por aplicaciones remotas, un VPS o un cliente como Jan.

## Conclusión

Exponer Ollama con Cloudflare Tunnel es una forma práctica y limpia de publicar un modelo local hacia Internet sin complicarse con la IP del operador ni con configuraciones agresivas en el router.

En este caso, el flujo correcto ha sido:

1.  comprobar Ollama en local,
    
2.  instalar y autenticar `cloudflared`,
    
3.  crear un túnel nombrado,
    
4.  asociar el subdominio,
    
5.  mapear el tráfico al servicio local,
    
6.  arrancar el túnel,
    
7.  y probar desde el exterior.
    

Con esto ya tenemos una base sólida para conectar clientes remotos y seguir evolucionando la arquitectura de forma más segura.