LLM local con Ollama: ejecutar modelos y monitorizarlos (métricas, logs, trazas)

LLM local con Ollama: instálalo, sirve un primer modelo y monitorízalo con sondas de API, logs, métricas de GPU y trazas OpenTelemetry hacia Dynatrace.
Ollama en local : faire tourner des LLM et les superviser (métriques, logs, traces)

Tener un LLM local con Ollama se ha convertido en la puerta de entrada más sencilla a los LLM autoalojados: un comando para instalarlo, otro para descargar un modelo y una API HTTP lista para responder. Es uno de los proyectos de código abierto más seguidos en GitHub, y se usa desde el portátil del desarrollador hasta el servidor con GPU de un equipo. En cuanto un LLM local con Ollama da servicio a varias personas, merece monitorizarse como cualquier otro servicio: métricas, logs y trazas.

Esa sencillez tiene un reverso. Mientras Ollama sea una herramienta personal, nadie se pregunta cuánto tarda en cargarse un modelo ni por qué una respuesta tarda doce segundos en llegar. En cuanto se convierte en un servicio del que dependen otras aplicaciones, hay que tratarlo como cualquier componente de producción: saber si responde, a qué velocidad, con qué consumo de memoria de GPU y para qué llamantes.

Este artículo presenta el proyecto, lo instala paso a paso y muestra después cómo monitorizarlo: qué expone la API de forma nativa, cómo recuperar los logs, cómo producir trazas de OpenTelemetry en el lado del cliente y cómo todo ello llega a una herramienta de observabilidad como Dynatrace.

LLM local con Ollama: ¿qué es y para qué sirve?

Ollama es un motor de ejecución de modelos de lenguaje que empaqueta la descarga, la cuantización y el servicio de los modelos detrás de una interfaz de línea de comandos y una API REST. Internamente se apoya en llama.cpp y en el formato GGUF, lo que le permite funcionar en CPU, en GPU de NVIDIA o AMD y en chips Apple Silicon.

Sus ventajas para un equipo técnico:

  • una biblioteca de modelos listos para usar (Llama, Mistral, Gemma, Qwen y muchos más), identificados por un nombre y una etiqueta;
  • una API nativa (/api/generate, /api/chat, /api/tags…) y una API compatible con OpenAI bajo /v1, lo que permite reutilizar los SDK existentes;
  • la gestión automática de la carga y descarga de los modelos en memoria.

Sus límites son igual de claros: Ollama busca la sencillez más que el máximo rendimiento. Para atender a muchos usuarios simultáneos en GPU de centro de datos, un servidor como vLLM en producción suele ser más adecuado.

En la práctica: instalar Ollama y servir un primer modelo

Paso 1: instalar el servicio

En Linux, el script oficial instala el binario y crea un servicio de systemd:

curl -fsSL https://ollama.com/install.sh | sh
systemctl status ollama

En macOS y Windows se ofrece un instalador gráfico. En contenedor, la imagen oficial se usa así (añade --gpus=all si tienes instalado el NVIDIA Container Toolkit):

docker run -d --name ollama \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  ollama/ollama

Paso 2: descargar y probar un modelo

ollama pull llama3.2
ollama run llama3.2 "Explique ce qu'est un SLO en deux phrases."
ollama ps     # modèles chargés en mémoire, CPU ou GPU
ollama list   # modèles présents sur le disque

Los nombres y etiquetas disponibles cambian continuamente: consulta la biblioteca de modelos en el sitio del proyecto antes de fijar un nombre en un script.

Paso 3: llamar a la API

Por defecto, el servidor escucha en el puerto 11434 de la máquina local. Una llamada sin streaming devuelve, además del texto, información de duración muy útil para la monitorización:

curl -s http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Pourquoi le ciel est-il bleu ?",
  "stream": false
}' | jq '{total_duration, load_duration, prompt_eval_count, eval_count, eval_duration}'

Las duraciones se expresan en nanosegundos. load_duration revela el coste de una carga en frío, y eval_count dividido por eval_duration da el rendimiento de generación en tokens por segundo.

Paso 4: abrir el servicio con cautela

Para exponer Ollama a otras máquinas, la variable OLLAMA_HOST define la dirección de escucha. Otras variables regulan el tiempo que un modelo se mantiene en memoria o el paralelismo. Su lista y su comportamiento exacto cambian de una versión a otra: consulta las preguntas frecuentes de la documentación oficial de Ollama. La API no incluye autenticación: coloca delante un reverse proxy con control de acceso y no la expongas nunca directamente a Internet.

¿Cómo monitorizar Ollama en local y en producción?

La monitorización de un LLM local se apoya en cuatro familias de señales. Ollama solo aporta una parte de forma nativa; el resto se construye alrededor.

Disponibilidad y estado de los modelos

Una simple llamada a /api/tags o a la raíz del servidor basta como sonda de disponibilidad. El endpoint /api/ps lista los modelos cargados, su tamaño y la parte colocada en memoria de GPU: es el equivalente en API de ollama ps, fácil de consultar desde un monitor sintético.

Métricas

Que sepamos, Ollama no expone un endpoint de Prometheus nativo en el momento en que escribimos; comprueba las notas de versión, el tema se discute con regularidad. Las métricas útiles se calculan, por tanto, a partir de las respuestas de la API (latencia total, tiempo de carga, tokens de entrada y de salida, rendimiento) y de las métricas de infraestructura. En el lado de la GPU, el exportador DCGM de NVIDIA o un agente de host aporta la utilización, la memoria y la temperatura de las tarjetas.

Logs

Instalado como servicio, Ollama escribe en el journal de systemd; en contenedor, en la salida estándar:

journalctl -u ollama -f
docker logs -f ollama

Estos logs indican, entre otras cosas, la detección de las GPU, la carga de los modelos y los errores de memoria. El modo detallado se activa con una variable de depuración descrita en la documentación. Un agente de recopilación (OneAgent, OpenTelemetry Collector con el receptor filelog o journald) los centraliza.

Trazas de OpenTelemetry en la aplicación

Lo más rico ocurre en el lado del llamante. El proyecto OpenLLMetry publica instrumentaciones de OpenTelemetry para varios proveedores, entre ellos Ollama, que producen un span por llamada con el modelo, los tokens consumidos y la duración, siguiendo las convenciones semánticas GenAI. Ejemplo en Python:

pip install ollama opentelemetry-sdk opentelemetry-exporter-otlp \
  opentelemetry-instrumentation-ollama
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.instrumentation.ollama import OllamaInstrumentor
import ollama

provider = TracerProvider()
provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter()))
trace.set_tracer_provider(provider)
OllamaInstrumentor().instrument()

reponse = ollama.chat(model="llama3.2",
                      messages=[{"role": "user", "content": "Bonjour"}])
print(reponse["message"]["content"])

Comprueba el nombre exacto del paquete y de la clase en el repositorio de OpenLLMetry: estas instrumentaciones evolucionan rápido. Comparamos este enfoque con Langfuse en nuestro artículo sobre Langfuse y OpenLLMetry.

Enviar la telemetría de Ollama a Dynatrace

El exportador OTLP se configura con las variables estándar de OpenTelemetry. Para un envío directo a Dynatrace SaaS, bastan el endpoint OTLP del entorno y un token de API con los permisos de ingesta adecuados (trazas, métricas, logs):

export OTEL_SERVICE_NAME="assistant-interne"
export OTEL_EXPORTER_OTLP_ENDPOINT="https://<environnement>.live.dynatrace.com/api/v2/otlp"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Api-Token%20<jeton>"
export OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"

En un despliegue más serio se prefiere pasar por un OpenTelemetry Collector, que recibe trazas y logs, añade los atributos de host y de Kubernetes y exporta después al backend. Los spans aparecen entonces en la vista de trazas distribuidas, asociados al servicio llamante, y el host que ejecuta Ollama queda correlacionado con sus métricas de GPU. El principio es el mismo que el descrito en OpenTelemetry de extremo a extremo: el valor viene del vínculo entre la llamada al modelo, el servicio y la infraestructura.

Los dashboards útiles son pocos: latencia p50 y p95 por modelo, tokens generados por minuto, proporción de llamadas con carga en frío, memoria de GPU ocupada y tasa de errores. Una alerta sobre la latencia p95 y otra sobre la saturación de memoria cubren lo esencial.

Buenas prácticas

  • Precarga los modelos críticos y ajusta su tiempo de permanencia en memoria para evitar cargas en frío en las horas punta.
  • No publiques nunca el puerto de Ollama sin autenticación ni filtrado de red.
  • Instrumenta al llamante con OpenTelemetry en lugar de deducir el rendimiento solo de los logs del servidor.
  • Evita registrar los prompts y las respuestas completos en las trazas si contienen datos personales.
  • Vigila la memoria de GPU: un modelo que desborda hacia la CPU sigue funcionando, pero se vuelve mucho más lento.

Preguntas frecuentes

¿Puede Ollama sustituir a una API de LLM alojada?

Para usos internos, prototipos o datos sensibles, sí, siempre que aceptes modelos más pequeños y dimensiones el hardware. Para mucho tráfico concurrente, es preferible un servidor orientado al rendimiento.

¿Expone Ollama métricas de Prometheus?

No de forma nativa, que sepamos. Se combinan las duraciones que devuelve la API, las trazas de OpenTelemetry de la aplicación y las métricas de GPU del host. Comprueba las últimas versiones, puede cambiar.

¿Cómo saber si un modelo se ejecuta en la GPU?

El comando ollama ps o el endpoint /api/ps indica el reparto entre CPU y GPU de cada modelo cargado; los logs de arranque también muestran las GPU detectadas.

Conclusión

Ollama hace que la inferencia local sea casi trivial, pero un LLM compartido sigue siendo un servicio de producción. Combinando sondas sobre la API, logs centralizados, métricas de GPU y trazas de OpenTelemetry en la aplicación, se obtiene una visión completa, lista para explotarse en Dynatrace o en otro backend. Para situar Ollama entre las demás piezas, consulta nuestra comparativa de pilas de IA de código abierto autoalojadas, y para añadirle una interfaz de chat, nuestra guía de Open WebUI.

span.observer es un blog independiente de la comunidad, no afiliado a Dynatrace LLC ni a los proyectos citados. Las marcas citadas pertenecen a sus propietarios. Las herramientas evolucionan rápido: comprueba los comandos y opciones en su documentación oficial.

Total
0
Shares
Leave a Reply

Your email address will not be published. Required fields are marked *

Previous Post
Platform engineering en 2026 : cinq défis et le rôle de l'observabilité pour les relever

Platform engineering 2026: cinco desafíos y el papel de la observabilidad para afrontarlos

Next Post
vLLM production : serveur compatible OpenAI, métriques Prometheus et supervision des GPU

vLLM en producción: servidor compatible con OpenAI, métricas de Prometheus y monitorización de GPU

Related Posts