CAFÉ Trastear, romper y documentarlo antes de olvidarlo.

posts

Ejecutar modelos de IA gratis con Kaggle Notebooks + Ollama (y sus contras, que también importan)

2026-11-048 min de lectura #ia-local#ollama#kaggle#cloudflare#tutorial

Este post está inspirado en el vídeo FREE 32GB VRAM Server for Running AI Models Locally de Abi, que explica el mismo truco. Aquí lo desarrollo paso a paso en español y con los contras que el vídeo no menciona.

Si alguna vez has querido probar un modelo de lenguaje grande —un 14B, un 27B— y tu PC no tiene GPU (o tiene una que se queda corta), te has topado con el muro de siempre: la VRAM cuesta dinero. En este post explico cómo montar un “servidor” de modelos gratis usando Kaggle Notebooks, Ollama y un túnel de Cloudflare. Funciona, es gratis de verdad y se monta en quince minutos. Pero también te cuento las pegas al final, porque las hay, y no son pocas.

1. La idea en una frase

Un notebook de Kaggle es, en realidad, una máquina Linux con GPU a la que solo puedes llegar a través de un navegador. El truco consiste en darse cuenta de que desde un notebook puedes ejecutar comandos de shell como en cualquier servidor: instalar Ollama, descargar un modelo y exponerlo a internet con un túnel. El notebook deja de ser un notebook y se convierte en tu backend de inferencia.

2. Por qué esto es gratis

Kaggle es la plataforma de competiciones de data science que Google compró en 2017. Regala cómputo —GPUs T4, en concreto— porque es su vivero de talento: quiere que los data scientists vivan dentro de su ecosistema. Las cuotas estrictas —unas 30 horas de GPU a la semana por usuario— mantienen el coste bajo control. Es marketing y reclutamiento subvencionado, y nosotros podemos aprovecharlo para experimentar.

Lo que te dan gratis:

  • 2× NVIDIA T4, con 16 GB de VRAM cada una (~32 GB sumando)
  • unas 30 h/semana de GPU, contadas por tiempo encendido y no por peticiones
  • sesiones de hasta 12 horas de duración (9 si usas TPU)

3. Lo que necesitas

  1. Una cuenta de Kaggle verificada con teléfono (obligatorio para usar GPU y activar internet)
  2. Un navegador
  3. Quince minutos

No necesitas instalar nada en tu PC: todo corre en la nube, y desde tu máquina solo harás peticiones HTTP al modelo.

4. Paso a paso

En Kaggle escribes en celdas de Python, y las líneas que empiezan por ! son escapes al shell del contenedor. Todo lo que sigue se pega tal cual en una celda.

Paso 0: crear el notebook y activar acelerador + internet

Entra en kaggle.com/code y crea un notebook nuevo (File → New Notebook). Antes de escribir nada, en el panel derecho:

  • Settings → Accelerator → GPU T4 x2 (sin esto, Ollama irá en CPU y será inusable para modelos grandes)
  • Settings → Internet → On (necesario para instalar Ollama y descargar el modelo)

Verifica que la GPU está visible ejecutando en una celda:

!nvidia-smi

Deberías ver dos T4 listadas.

Paso 1: instalar Ollama y cloudflared

Ollama es un binario autocontenido y se instala con su script oficial. Cloudflared es el cliente del túnel de Cloudflare: lo bajo directamente de su GitHub.

# Instalar Ollama
!curl -fsSL https://ollama.com/install.sh | sh

# Instalar cloudflared (cliente de Cloudflare Tunnel)
!curl -fsSL -o /usr/local/bin/cloudflared \
  https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64
!chmod +x /usr/local/bin/cloudflared

# Comprobar versiones
!ollama --version && cloudflared --version

El instalador de Ollama avisa de que no hay systemd (en un contenedor no lo hay). Es un aviso, no un error: el binario queda en /usr/local/bin y lo arrancamos a mano en el paso siguiente.

Paso 2: arrancar el servidor de Ollama

El servidor de Ollama escucha por defecto en el puerto 11434 y solo en 127.0.0.1, que es justo lo que queremos: cloudflared corre en la misma máquina. Lo arranco en segundo plano y guardo su log en un archivo, para que si algo falla pueda leer el motivo en vez de quedarme a ciegas:

!nohup ollama serve > /kaggle/working/ollama.log 2>&1 &

# Darle un par de segundos y comprobar que responde
import time; time.sleep(3)
!curl -s http://localhost:11434/api/tags

Si responde con un JSON (aunque sea con la lista de modelos vacía), el servidor está vivo.

Paso 3: descargar un modelo

Elige el modelo según la VRAM disponible y tu caso de uso. Estos son los tamaños que descarga Ollama por defecto, en cuantización Q4:

  • qwen2.5:7b — unos 4,7 GB. Cabe de sobra en una T4 y va rápido.
  • qwen2.5:14b — unos 9 GB. Entra entero en una T4, con sitio para el contexto.
  • gemma2:27b — unos 16 GB. No cabe en una T4: necesita las dos.
  • qwen2.5:32b — unos 20 GB. Justo: reparte capas entre las dos T4 y pierde velocidad por el camino.

Bájalo de forma no interactiva (ollama pull, no ollama run, que abre un chat y bloquea la celda):

!ollama pull qwen2.5:14b

La primera descarga tarda según el tamaño (un 14B son unos 9 GB). Ojo: se descarga al disco efímero del runtime, no a tu espacio persistente. Más sobre esto en las pegas.

Paso 4: abrir el túnel de Cloudflare

Aquí está la magia. Tu notebook no tiene IP pública ni puertos abiertos, así que nadie de fuera puede llegar al puerto 11434. La solución es un Quick Tunnel de Cloudflare: cloudflared abre una conexión saliente hacia Cloudflare y te devuelve una URL HTTPS pública que viaja por ese túnel. Sin registro, sin dominio y sin abrir puertos.

!nohup cloudflared tunnel --url http://localhost:11434 \
  > /kaggle/working/tunnel.log 2>&1 &

import time; time.sleep(5)

# Extraer la URL pública del log
!grep -o 'https://[a-z0-9-]*\.trycloudflare\.com' /kaggle/working/tunnel.log | head -1

Te devolverá algo como https://algo-con-palabras-aleatorias.trycloudflare.com. Esa es tu URL de acceso al modelo desde cualquier dispositivo.

Paso 5: probarlo desde fuera

Ya puedes hablar con tu modelo desde tu portátil, tu móvil o cualquier cliente que hable el formato de OpenAI. Dos endpoints útiles:

# Listar modelos instalados (sustituye TU_URL por la del túnel)
curl -s https://TU_URL.trycloudflare.com/api/tags

# Generación con el endpoint compatible con OpenAI
curl -s https://TU_URL.trycloudflare.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen2.5:14b",
    "messages": [{"role": "user", "content": "Hola, ¿quién eres?"}]
  }'

La primera petición puede tardar: Ollama tiene que cargar los pesos en la VRAM. A partir de ahí responde, y si pasa cinco minutos sin actividad los descarga y la siguiente vuelve a empezar.

Cualquier herramienta que acepte una base_url estilo OpenAI (Ollama en tu PC apuntando a remoto, clientes de chat, agentes…) funciona apuntándola a la URL del túnel con /v1 detrás.

5. Las pegas

Esto es un juguete buenísimo para experimentar, pero no es un servidor. Las pongo de menos a más importante:

  1. No hay concurrencia. Una T4 con un 14B responde a velocidad de lectura, no de servicio: dos o tres peticiones a la vez y la cola se nota, porque el modelo ocupa la VRAM y no queda sitio para atender varias generaciones en paralelo.

  2. La cuota es semanal y compartida. 30 horas suenan a muchas hasta que las usas. Y si te quedas sin, no hay opción de pago: toca esperar a la semana siguiente.

  3. “32 GB de VRAM” no es lo mismo que una GPU de 32 GB. Son dos T4 separadas de 16 GB, sin NVLink. Ollama reparte capas entre ambas, pero eso añade comunicación por PCIe y el rendimiento no equivale al de una GPU única de 32 GB. Además, si el modelo cabe en 16 GB solo se usa una: la segunda está parada, salvo que fuerces el reparto. Para modelos de 14B a 27B cuantizados va sobrado; para algo más grande, se sufre.

  4. Estás en zona gris de los términos de servicio. Kaggle está pensado para entrenar y evaluar modelos, no para servir inferencia como backend de una aplicación. No es minar criptomonedas ni nada parecido, pero un uso intensivo tipo “servidor 24/7” puede acarrear la suspensión de la cuenta. Para sesiones puntuales de prueba, nadie te dice nada; para colgar tu startup encima, no.

  5. El túnel es público y sin autenticación. Un Quick Tunnel expone tu API a cualquiera que tenga la URL. La URL es aleatoria, pero no es un secreto en el sentido criptográfico, y quien la tenga consume tu cuota. No dejes nada sensible en ese modelo y no compartas la URL. Si quieres algo más serio, necesitarías poner un proxy con autenticación delante, y en ese momento ya estás montando infraestructura de verdad.

  6. La sesión caduca. Como máximo 12 horas, y el runtime se duerme si no hay actividad. La gente lo mantiene vivo con clics automáticos del ratón: es frágil y, a la larga, incómodo. Y cada vez que reinicias, el túnel es otro: la URL cambia, así que apunta la nueva antes de tocar la configuración de tus clientes.

  7. Todo es efímero. Al cerrar la sesión se borra todo lo que no esté en /kaggle/working, y ese espacio son unos 20 GB que tampoco sobreviven entre sesiones salvo que guardes el notebook como versión y el modelo acabe en el output. Los modelos, además, se descargan en /root/.ollama, fuera de esa carpeta. Un modelo de 14B cabe justo; uno de 32B, no. Traducción práctica: re-descargarás el modelo en cada sesión, una y otra vez.

6. Para qué sirve

Para lo que yo lo uso: probar antes de comprar. Quieres saber si un modelo de 14B te sirve para un proyecto antes de gastar en una GPU, o antes de montar el servicio en tu homelab. Quieres comparar tres modelos en una tarde. Quieres jugar un fin de semana con algo que tu portátil no mueve.

Para todo eso es imbatible: cero coste, cero instalación y en quince minutos estás hablando con un modelo que “no cabe” en tu hardware.

Para servir un modelo de forma estable y continua, no: para eso hay alternativas de pago por hora (RunPod, Vast.ai, Lambda) o, si el hobby te lo pide, comprar GPU propia y asumir el zumbido del ventilador.

Guía probada con Ollama y Qwen2.5 sobre el entorno gratuito de Kaggle con GPU T4 x2. Las cuotas y los límites exactos pueden cambiar: comprueba siempre las condiciones actuales en kaggle.com/docs.

relacionado