Cómo instalar Ollama en Ubuntu 24.04 para ejecutar LLMs

Ollama es un servidor de inferencia que descarga, gestiona y ejecuta modelos de lenguaje abiertos (Llama, Qwen, Mistral, Gemma y muchos más) en tu propio servidor, sin enviar datos a terceros. En este tutorial instalarás Ollama como servicio systemd en Ubuntu 24.04, descargarás y probarás un modelo, lo consultarás a través de su API REST y crearás una variante personalizada con un Modelfile. Todo funciona en CPU, y si el servidor tiene una GPU NVIDIA, Ollama la usará automáticamente.

Requisitos previos

Para seguir esta guía necesitas:

• Un servidor con Ubuntu 24.04 LTS de 64 bits, por ejemplo un VPS de CubePath.
• Un usuario no root con privilegios sudo.
• Memoria y disco suficientes para el modelo que quieras ejecutar (ver la tabla siguiente).
• Opcional: una GPU NVIDIA con al menos 4 GB de VRAM para acelerar la inferencia.

Como referencia, estos son los recursos aproximados para modelos cuantizados a 4 bits, que es lo que Ollama descarga por defecto:

En CPU los modelos de 1B y 3B responden con fluidez; a partir de 7B la generación se vuelve lenta sin GPU.

Paso 1: Preparar la GPU NVIDIA (opcional)

Si tu servidor no tiene GPU, salta al paso 2. Ollama incluye sus propias librerías CUDA, así que solo necesita el driver de NVIDIA. La forma más sencilla de instalar el driver recomendado en Ubuntu es ubuntu-drivers:

sudo apt update
sudo apt install ubuntu-drivers-common
sudo ubuntu-drivers install

Reinicia el servidor para cargar el módulo del kernel:

sudo reboot

Tras volver a conectarte, comprueba que el driver ve la tarjeta:

nvidia-smi

La salida debe mostrar el modelo de GPU, la versión del driver y la memoria disponible. Si el comando no existe o devuelve NVIDIA-SMI has failed, el driver no se ha cargado; revisa sudo dmesg | grep -i nvidia antes de continuar.

Paso 2: Instalar Ollama

Ollama distribuye un script de instalación oficial que descarga el binario, crea el usuario de sistema ollama y registra el servicio systemd. Descárgalo primero para poder revisarlo:

curl -fsSL https://ollama.com/install.sh -o ollama-install.sh
less ollama-install.sh

Cuando estés conforme con su contenido, ejecútalo:

sh ollama-install.sh

El script pide la contraseña de sudo y termina con un mensaje similar a este:

>>> Creating ollama user...
>>> Adding ollama user to render group...
>>> Adding ollama user to video group...
>>> Creating ollama systemd service...
>>> Enabling and starting ollama service...
>>> The Ollama API is now available at 127.0.0.1:11434.
>>> Install complete. Run "ollama" from the command line.

Si no hay GPU, verás además WARNING: No NVIDIA/AMD GPU detected. Ollama will run in CPU-only mode., lo cual es normal.

Comprueba la versión instalada y el estado del servicio:

ollama --version
systemctl status ollama --no-pager

ollama version is 0.12.3
● ollama.service - Ollama Service
     Loaded: loaded (/etc/systemd/system/ollama.service; enabled; preset: enabled)
     Active: active (running) since ...

Por defecto Ollama escucha solo en 127.0.0.1:11434, así que la API no queda expuesta a Internet. Puedes borrar el script con rm ollama-install.sh.

Paso 3: Descargar y ejecutar un modelo

Los modelos se descargan desde la biblioteca pública de Ollama (ollama.com/library). Empieza por Llama 3.2 de 3B, que funciona bien incluso sin GPU:

ollama pull llama3.2

La descarga muestra el progreso de cada capa y termina con success. Lanza una pregunta de prueba sin entrar en el modo interactivo:

ollama run llama3.2 "Explica en dos frases qué es un proceso zombi en Linux."

La primera respuesta tarda unos segundos más porque el modelo se carga en memoria. Para una conversación interactiva ejecuta ollama run llama3.2 sin texto y sal con /bye.

Consulta qué modelos tienes descargados y cuáles están cargados en memoria:

ollama list
ollama ps

NAME               ID              SIZE      MODIFIED
llama3.2:latest    a80c4f17acd5    2.0 GB    2 minutes ago

NAME               ID              SIZE      PROCESSOR    CONTEXT    UNTIL
llama3.2:latest    a80c4f17acd5    3.4 GB    100% GPU     4096       4 minutes from now

La columna PROCESSOR indica dónde se ejecuta el modelo: 100% GPU, 100% CPU o un reparto entre ambos si el modelo no cabe entero en la VRAM. Es la forma más rápida de confirmar que la GPU se está usando.

Otros comandos útiles para gestionar modelos:

• ollama show llama3.2: muestra la arquitectura, el tamaño de contexto y la cuantización.
• ollama pull qwen2.5:7b: descarga una etiqueta concreta. Qwen 2.5 responde muy bien en español.
• ollama rm llama3.2: borra un modelo y libera su espacio.

El servicio guarda los modelos en /usr/share/ollama/.ollama/models. Para ver cuánto ocupan:

sudo du -sh /usr/share/ollama/.ollama/models

Paso 4: Ajustar la configuración del servicio

Ollama se configura con variables de entorno. En lugar de editar el archivo de la unidad, que el instalador sobrescribe al actualizar, crea un override de systemd:

sudo systemctl edit ollama

Añade el bloque siguiente entre los comentarios que indica el editor:

[Service]
Environment="OLLAMA_KEEP_ALIVE=30m"
Environment="OLLAMA_MAX_LOADED_MODELS=1"
Environment="OLLAMA_NUM_PARALLEL=2"

• OLLAMA_KEEP_ALIVE: tiempo que un modelo permanece en memoria tras la última petición (por defecto 5m). Un valor mayor evita recargas lentas.
• OLLAMA_MAX_LOADED_MODELS: número de modelos cargados a la vez. Limitarlo a 1 evita quedarte sin RAM o VRAM en servidores pequeños.
• OLLAMA_NUM_PARALLEL: peticiones simultáneas que atiende cada modelo. Cada una reserva su propio contexto, así que aumenta el consumo de memoria.

Si quieres guardar los modelos en otro disco, añade también Environment="OLLAMA_MODELS=/ruta/al/directorio" y da la propiedad del directorio al usuario ollama con sudo chown -R ollama:ollama /ruta/al/directorio.

Aplica los cambios y comprueba que el servicio los ha recogido:

sudo systemctl restart ollama
systemctl show ollama --property=Environment

La salida debe incluir las variables que acabas de definir.

Paso 5: Usar la API REST

Ollama expone una API HTTP en el puerto 11434 que usan tanto su propio cliente como aplicaciones externas. Comprueba que responde:

curl http://127.0.0.1:11434/api/version

{"version":"0.12.3"}

Envía un mensaje de chat con la API nativa. "stream": false devuelve la respuesta completa en un único JSON en lugar de token a token:

curl http://127.0.0.1:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [
    {"role": "user", "content": "¿Qué comando muestra los puertos en escucha?"}
  ],
  "stream": false
}'

La respuesta incluye el texto en message.content y métricas como eval_count (tokens generados) y eval_duration (tiempo en nanosegundos), útiles para medir el rendimiento.

Ollama también ofrece un endpoint compatible con la API de OpenAI en /v1, de modo que cualquier SDK o herramienta que hable con OpenAI puede usar tu servidor cambiando solo la URL base:

curl http://127.0.0.1:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3.2",
    "messages": [
      {"role": "system", "content": "Eres un administrador de sistemas Linux. Responde de forma breve."},
      {"role": "user", "content": "¿Cómo veo qué proceso usa más memoria?"}
    ]
  }'

Desde Python puedes usar la librería oficial ollama. Instálala en un entorno virtual:

sudo apt install python3-venv
python3 -m venv ~/ollama-env
~/ollama-env/bin/pip install ollama

Crea un script de prueba:

nano ~/prueba_ollama.py

from ollama import chat

respuesta = chat(
    model="llama3.2",
    messages=[{"role": "user", "content": "Resume qué es una VPN en una frase."}],
)
print(respuesta.message.content)

Ejecútalo:

~/ollama-env/bin/python ~/prueba_ollama.py

Deberías ver la respuesta del modelo impresa en la terminal.

Paso 6: Crear un modelo personalizado con un Modelfile

Un Modelfile define una variante de un modelo existente con sus propios parámetros y mensaje de sistema. Es la forma de tener, por ejemplo, un asistente que responda siempre en español y con un estilo concreto sin repetir las instrucciones en cada petición.

Crea el archivo:

mkdir -p ~/modelos
nano ~/modelos/Modelfile

FROM llama3.2

PARAMETER temperature 0.3
PARAMETER num_ctx 8192

SYSTEM """
Eres un experto en administración de sistemas Linux.
Responde siempre en español, de forma concisa, e incluye el comando exacto cuando sea útil.
"""

temperature controla la creatividad (valores bajos dan respuestas más deterministas) y num_ctx fija el tamaño de la ventana de contexto en tokens. Un contexto mayor consume más memoria.

Crea el modelo y pruébalo:

ollama create asistente-linux -f ~/modelos/Modelfile
ollama run asistente-linux "¿Cómo compruebo el espacio libre en disco?"

gathering model components
using existing layer sha256:...
writing manifest
success

El nuevo modelo aparece en ollama list y está disponible también a través de la API con el nombre asistente-linux. No ocupa espacio extra, porque reutiliza las capas de llama3.2.

Paso 7: Acceder a la API desde otro equipo

La API de Ollama no tiene autenticación, así que no la expongas directamente a Internet. La opción más segura para usarla desde tu equipo es un túnel SSH. Ejecuta esto en tu máquina local, sustituyendo your_user y your_server_ip:

ssh -N -L 11434:127.0.0.1:11434 your_user@your_server_ip

Mientras el túnel esté abierto, http://localhost:11434 en tu equipo apunta al Ollama del servidor, y herramientas como Open WebUI o extensiones de editor pueden usarlo sin cambios.

Si necesitas que otros servidores de tu red privada accedan directamente, añade Environment="OLLAMA_HOST=0.0.0.0:11434" al override del paso 4, reinicia el servicio y permite el puerto solo desde la IP de origen:

sudo ufw allow from 10.0.0.5 to any port 11434 proto tcp

Sustituye 10.0.0.5 por la IP del cliente. Para acceso público, coloca un proxy inverso con TLS y autenticación delante de Ollama.

Solución de problemas

ollama ps muestra 100% CPU aunque hay GPU. Revisa el arranque del servicio con sudo journalctl -u ollama -b --no-pager | grep -i -E "gpu|cuda". Si no detecta la tarjeta, comprueba que nvidia-smi funciona y reinicia el servicio con sudo systemctl restart ollama. Si el modelo es mayor que la VRAM, Ollama lo reparte entre GPU y CPU; usa un modelo más pequeño o una cuantización menor.

Error: could not connect to ollama app, is it running? El servicio está parado. Consulta el motivo con sudo journalctl -u ollama -n 50 --no-pager. Un fallo habitual es que el puerto 11434 ya esté ocupado por un ollama serve lanzado a mano; compruébalo con sudo ss -tlnp | grep 11434.

La descarga se corta. Vuelve a ejecutar ollama pull con el mismo nombre: continúa desde donde se quedó.

El sistema se queda sin memoria al cargar un modelo. Baja OLLAMA_NUM_PARALLEL y num_ctx, o usa un modelo más pequeño. Comprueba el consumo real con ollama ps y free -h.

Conclusión

Ya tienes Ollama funcionando como servicio en Ubuntu 24.04, con modelos descargados, una API REST nativa y compatible con OpenAI, y un modelo personalizado definido con un Modelfile. Como siguientes pasos puedes instalar Open WebUI para tener una interfaz de chat en el navegador, integrar la API en tus aplicaciones mediante el SDK de OpenAI o, si necesitas servir muchas peticiones concurrentes en GPU, evaluar un servidor de alto rendimiento como vLLM.