📊 Monitoring de la stack d'inférence
Architecture de monitoring
flowchart TD
subgraph Sources["Sources de métriques"]
A["vLLM /metrics"]
B["nvidia-smi"] --> C["nvidia-dcgm-exporter"]
D["OS"] --> E["node-exporter"]
end
Sources --> P["Prometheus\n(scrape + store)"]
P --> G["Grafana\n(dashboards + alertes)"]
1. Stack Docker Compose complète
services:
prometheus: image: prom/prometheus:latest container_name: prometheus volumes: - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro - prometheus_data:/prometheus command: - '--config.file=/etc/prometheus/prometheus.yml' - '--storage.tsdb.retention.time=30d' ports: - "9090:9090" restart: unless-stopped
grafana: image: grafana/grafana-oss:latest container_name: grafana volumes: - grafana_data:/var/lib/grafana environment: - GF_SECURITY_ADMIN_PASSWORD=changeme - GF_USERS_ALLOW_SIGN_UP=false ports: - "3000:3000" restart: unless-stopped depends_on: - prometheus
nvidia-dcgm-exporter: image: nvcr.io/nvidia/k8s/dcgm-exporter:latest container_name: dcgm-exporter runtime: nvidia environment: - NVIDIA_VISIBLE_DEVICES=all ports: - "9400:9400" restart: unless-stopped cap_add: - SYS_ADMIN
node-exporter: image: prom/node-exporter:latest container_name: node-exporter volumes: - /proc:/host/proc:ro - /sys:/host/sys:ro - /:/rootfs:ro command: - '--path.procfs=/host/proc' - '--path.sysfs=/host/sys' ports: - "9100:9100" restart: unless-stopped
volumes: prometheus_data: grafana_data:docker compose -f docker-compose.monitoring.yml up -d2. Configuration Prometheus
global: scrape_interval: 15s evaluation_interval: 15s
scrape_configs:
- job_name: 'vllm' static_configs: - targets: ['host.docker.internal:8000'] # adapter si vLLM sur autre machine metrics_path: '/metrics'
- job_name: 'nvidia-gpu' static_configs: - targets: ['dcgm-exporter:9400']
- job_name: 'node' static_configs: - targets: ['node-exporter:9100']
# Si Ollama : pas de /metrics natif — scraper les métriques du reverse proxy placé devant # Ollama (Caddy : endpoint admin :2019/metrics ; Nginx : nginx-prometheus-exporter) - job_name: 'ollama-proxy' static_configs: - targets: ['host.docker.internal:2019'] # endpoint /metrics du reverse proxyLe endpoint /metrics de vLLM n’est pas protégé par --api-key : ne l’exposez qu’au réseau de Prometheus. Version minimale : vLLM ≥ 0.34.0 (voir Sécurité de l'inférence locale).
3. Métriques vLLM — les essentielles
vLLM expose ses métriques sur GET /metrics1. Voici celles à surveiller en priorité :
Débit et files d’attente
| Métrique | Description | Seuil d’alerte |
|---|---|---|
vllm:num_requests_running | Requêtes en cours de traitement | > 80% de --max-num-seqs |
vllm:num_requests_waiting | Requêtes en file d’attente | > 0 pendant > 30 s |
rate(vllm:generation_tokens_total[1m]) | Débit de génération en tokens/s (dérivé du compteur ; la jauge V0 avg_generation_throughput_toks_per_s a disparu)1 | < seuil défini par usage |
vllm:prompt_tokens_total | Tokens de prompt traités (cumulé) | — (trend) |
vllm:generation_tokens_total | Tokens générés (cumulé) | — (trend) |
vllm:request_success_total | Requêtes terminées | — |
La documentation vLLM nomme les compteurs sans suffixe (vllm:generation_tokens, vllm:num_preemptions) ; l’exposition Prometheus leur ajoute _total, d’où vllm:generation_tokens_total dans les requêtes ci-dessus1.
KV Cache
| Métrique | Description | Seuil d’alerte |
|---|---|---|
vllm:kv_cache_usage_perc | Fraction du KV Cache occupée (1 = 100 %) | > 0.90 |
vllm:num_preemptions_total | Requêtes préemptées (KV Cache plein) | > 0 régulier |
Latences
| Métrique | Description |
|---|---|
vllm:time_to_first_token_seconds | Distribution TTFT par requête |
vllm:inter_token_latency_seconds | Latence entre deux tokens générés (histogramme)1 |
vllm:request_time_per_output_token_seconds | Temps moyen par token de sortie, par requête (remplace vllm:time_per_output_token_seconds)1 |
vllm:e2e_request_latency_seconds | Latence end-to-end |
4. Métriques GPU (DCGM Exporter)
NVIDIA DCGM Exporter expose des métriques GPU détaillées5 :
| Métrique DCGM | Description | Seuil d’alerte |
|---|---|---|
DCGM_FI_DEV_GPU_UTIL | Utilisation GPU (%) | < 10% pendant > 5 min (gaspillage) |
DCGM_FI_DEV_MEM_COPY_UTIL | Utilisation bus mémoire (%) | > 90% soutenu |
DCGM_FI_DEV_FB_USED | VRAM utilisée (MiB) | > 95% de la VRAM totale (sauf GPU servis par vLLM ≥ 0.34, qui occupe volontairement presque toute la VRAM : surveiller plutôt vllm:kv_cache_usage_perc) |
DCGM_FI_DEV_GPU_TEMP | Température GPU (°C) | > 83°C (throttling probable) |
DCGM_FI_DEV_POWER_USAGE | Consommation (W) | > TDP déclaré |
DCGM_FI_DEV_NVLINK_BANDWIDTH_TOTAL | Débit NVLink agrégé (Mo/s) | — (trend sur clusters) |
DCGM_FI_DEV_FB_TOTAL n’est pas exporté par défaut : ajoutez DCGM_FI_DEV_FB_TOTAL, gauge, Framebuffer total (MiB) au fichier de compteurs (etc/default-counters.csv, monté dans le conteneur) ou utilisez DCGM_FI_DEV_FB_FREE dans l’alerte VRAMAlmostFull5.
Requête Prometheus — VRAM utilisée par GPU
DCGM_FI_DEV_FB_USED{gpu=~".*"}5. Dashboards Grafana recommandés
Import depuis Grafana.com
- Ouvrir Grafana → Dashboards → Import
- Entrer l’ID du dashboard :
| Dashboard | ID Grafana | Usage |
|---|---|---|
| NVIDIA DCGM Exporter | 12239 | GPU utilization, mémoire, température6 |
| Node Exporter Full | 1860 | CPU, RAM, réseau, disque hôte7 |
Panels essentiels à construire manuellement
Panel “Débit tokens/s” :
rate(vllm:generation_tokens_total[1m])Panel “KV Cache %” :
vllm:kv_cache_usage_perc * 100Panel “File d’attente” :
vllm:num_requests_waitingPanel “TTFT P95” (95e percentile) :
histogram_quantile(0.95, rate(vllm:time_to_first_token_seconds_bucket[5m]))6. Alertes Prometheus
# alerts.yml — à référencer dans prometheus.yml sous rule_files:groups: - name: inference-alerts rules:
- alert: VLLMKVCacheHigh expr: vllm:kv_cache_usage_perc > 0.90 for: 2m labels: severity: warning annotations: summary: "KV Cache vLLM > 90%" description: "Le KV Cache est à {{ $value | humanizePercentage }}. Risque de préemption."
- alert: VLLMRequestQueueBacklog expr: vllm:num_requests_waiting > 0 for: 1m labels: severity: warning annotations: summary: "File d'attente vLLM non vide" description: "{{ $value }} requêtes en attente depuis plus d'1 minute."
- alert: GPUTemperatureHigh expr: DCGM_FI_DEV_GPU_TEMP > 83 for: 5m labels: severity: critical annotations: summary: "GPU {{ $labels.gpu }} en surchauffe" description: "Température GPU à {{ $value }}°C — throttling probable."
- alert: VRAMAlmostFull # Sur les GPU servis par vLLM ≥ 0.34, qui réserve volontairement presque toute la VRAM, cette alerte se déclencherait en permanence : excluez ces GPU et surveillez plutôt vllm:kv_cache_usage_perc (alerte VLLMKVCacheHigh) # DCGM_FI_DEV_FB_TOTAL doit être ajouté au fichier de compteurs (section 4) ; # sinon : DCGM_FI_DEV_FB_USED / (DCGM_FI_DEV_FB_USED + DCGM_FI_DEV_FB_FREE) expr: (DCGM_FI_DEV_FB_USED / DCGM_FI_DEV_FB_TOTAL) > 0.95 for: 2m labels: severity: critical annotations: summary: "VRAM GPU {{ $labels.gpu }} critique" description: "{{ $value | humanizePercentage }} de VRAM utilisée."Pour activer les alertes dans Prometheus :
# prometheus.yml — ajouterrule_files: - "alerts.yml"
alerting: alertmanagers: - static_configs: - targets: ['alertmanager:9093'] # si Alertmanager déployé7. Monitoring Ollama (sans Prometheus natif)
Si vous utilisez Ollama, quelques commandes de monitoring immédiat9 :
# Modèles chargés et VRAM occupéeollama ps
# Logs en temps réel (incluent les durées de génération) — pas de sous-commande `ollama logs`# Linux (systemd)journalctl -u ollama --no-pager --follow --pager-end# macOS : cat ~/.ollama/logs/server.log — Docker : docker logs <conteneur>
# Métriques dans la réponse API (durées en nanosecondes)curl -s http://localhost:11434/api/generate \ -d '{"model":"llama3.2","prompt":"test","stream":false}' \ | python3 -c "import sys, jsonr = json.load(sys.stdin)print(f'TTFT: {r[\"prompt_eval_duration\"]/1e9:.2f}s')print(f'Génération: {r[\"eval_duration\"]/1e9:.2f}s')print(f'Débit: {r[\"eval_count\"]/(r[\"eval_duration\"]/1e9):.1f} tok/s')"8. Traces vs. Métriques — OpenTelemetry pour les stacks agentiques
Prometheus et Grafana répondent à la question “Le serveur va-t-il bien ?”. Ils ne répondent pas à “Pourquoi cette requête a-t-elle pris 30 secondes ?”.
Le problème agentique
Dans un pipeline RAG ou multi-agents, une requête traverse plusieurs services avant de produire une réponse. Si un utilisateur se plaint d’une latence de 30s, Grafana vous dira que le GPU était à 70% d’utilisation — ce qui ne suffit pas à diagnostiquer la cause. Ce qu’il faut, c’est la trace de la requête complète :
Requête utilisateur (30s total)├── VectorDB Qdrant — 4s (recherche sémantique)├── Agent routing — 2s (choix de l'outil)├── SearXNG web search — 20s (timeout réseau ⚠️)└── LLM generation — 4s (200 tokens @ 50 tok/s)Sans traces, l’ingénieur cherche dans les logs de chaque service séparément. Avec des traces OpenTelemetry, la requête complète est visualisée en un seul waterfall dans un outil dédié.
OpenTelemetry (OTEL) — intégration native vLLM et LiteLLM
LiteLLM et vLLM supportent OpenTelemetry nativement10 :
# vLLM — activer OTEL (exporte vers un collector local)vllm serve meta-llama/Llama-3.1-70B-Instruct \ --otlp-traces-endpoint http://localhost:4317# --collect-detailed-traces model pour des traces détaillées (coûteuses ; all|model|worker)[^11]
# LiteLLM — litellm_config.yamllitellm_settings: callbacks: ["otel"]# et dans l'environnement du proxy LiteLLM :# OTEL_EXPORTER=otlp_grpc# OTEL_ENDPOINT=http://localhost:4317 # OTLP gRPCStack d’observabilité LLM recommandée
Pour une infrastructure on-premise souveraine, trois options :
| Outil | Type | Points forts | Déploiement |
|---|---|---|---|
| Langfuse (self-hosted, v4) | Traces + éval LLM | Interface dédiée LLM, coûts par token, évaluation qualité | Docker Compose officiel (usage local et tests) ; Helm en production11 |
| Jaeger | Traces distribuées | Standard CNCF, léger, intégré Kubernetes | Docker jaegertracing/all-in-one |
| Arize Phoenix | Traces + debug agent | Spécialisé agents/RAG, gratuit ; licence Elastic 2.0 (source-available, non OSI, interdit de le proposer en service managé) | pip install arize-phoenix1213 |
Stack minimale recommandée pour un agent custodien :
# docker-compose.yml — ajouter au stack existant# Langfuse (v4) n'est plus un conteneur unique : il faut PostgreSQL, ClickHouse,# Redis/Valkey et un stockage S3 (MinIO en local). Partez du docker-compose.yml# officiel du dépôt Langfuse (positionné « usage local et tests ») ; pour la# production, le chart Helm. Voir la note [^6].# git clone https://github.com/langfuse/langfuse && cd langfuse && docker compose up -d
otel-collector: image: otel/opentelemetry-collector-contrib:latest volumes: - ./otel-config.yaml:/etc/otel-config.yaml command: ["--config=/etc/otel-config.yaml"] ports: - "4317:4317" # OTLP gRPC - "4318:4318" # OTLP HTTPSauvegarde de l’état applicatif (DRP)
Le monitoring détecte les pannes — mais sans sauvegarde, le redémarrage après incident peut prendre des heures ou perdre des données. Voici les états à protéger dans une stack d’inférence locale.
Ce qu’il faut sauvegarder
| Composant | Données critiques | Méthode recommandée |
|---|---|---|
| Qdrant (base vectorielle) | Collections + snapshots d’index | POST /collections/{name}/snapshots → snapshot local ; copier vers stockage externe |
| Milvus (base vectorielle) | Collections, segments, métadonnées | Milvus Backup CLI (milvus-backup create) vers S3 local ou NAS |
| SQLite (Memory Tree, historiques) | Fichier .db | cp avec rotation quotidienne ou sqlite3 .backup en chaud |
| Configuration vLLM / Ollama | config.yaml, scripts de démarrage | Versionné dans Git — déjà couvert |
| Modèles et adaptateurs | Poids GGUF, LoRA fine-tunés | Poids de base = immuables (retélécharger) ; adaptateurs fine-tunés = sauvegarder sur NAS |
Fréquences suggérées
Qdrant snapshot → quotidien (cron 02:00), conservation 7 joursMilvus backup → quotidien (cron 03:00), conservation 7 joursSQLite Memory Tree → toutes les heures (si écriture fréquente), sinon quotidienAdaptateurs LoRA → à chaque fin d'entraînementExemple de snapshot Qdrant (curl)
# Créer un snapshotcurl -X POST http://localhost:6333/collections/my_collection/snapshots
# Lister les snapshots disponiblescurl http://localhost:6333/collections/my_collection/snapshots
# Copier vers stockage externe (exemple NAS monté)cp /qdrant/snapshots/my_collection/*.snapshot /mnt/backup/qdrant/Procédure de reprise (RTO indicatif)
- Redémarrer le conteneur vLLM ou Ollama → rechargement des poids depuis SSD (~15–120 s selon modèle)
- Restaurer Qdrant depuis le dernier snapshot →
PUT /collections/{name}/snapshots/recover - Restaurer SQLite → copier le fichier
.dbde sauvegarde à la place du fichier corrompu - Vérifier l’endpoint de santé (
/healthou/v1/models)
Voir aussi
- ⚙️ Configurer vLLM multi-GPU — endpoint
/metricset paramètres - 🖥️ Scénario C — monitoring Exo/Thunderbolt
- 🏭 Scénario D — monitoring datacenter RoCE
Sources et Références
Footnotes
-
vLLM Project, Metrics (endpoint
/metrics, liste complète des métriques Prometheus exposées —vllm:kv_cache_usage_perc,vllm:num_preemptions,vllm:simple_kv_offload_*— politique de dépréciation des métriques), consulté le 2026-10-09. https://docs.vllm.ai/en/stable/usage/metrics/ ↩ ↩2 ↩3 ↩4 ↩5 ↩6 ↩7 ↩8 -
Ollama, API Reference (endpoints
/api/generate,/api/chatet champseval_count/eval_duration/prompt_eval_duration; aucun endpoint/metrics), consulté le 2026-10-09. https://docs.ollama.com/api ↩ -
vLLM Project, Engine Arguments (
--gpu-memory-utilization,--max-model-len,--max-num-seqs), consulté le 2026-10-09. https://docs.vllm.ai/en/stable/configuration/engine_args/ ↩ -
vLLM Project, Disaggregated Prefill and Decode (
--kv-transfer-config,OffloadingConnectorpour le déport CPU du KV Cache), consulté le 2026-10-09. https://docs.vllm.ai/en/stable/features/disagg_prefill/ ↩ -
NVIDIA, DCGM Exporter (
etc/default-counters.csv: GPU_UTIL, MEM_COPY_UTIL, FB_USED, FB_FREE, GPU_TEMP, POWER_USAGE, NVLINK_BANDWIDTH_TOTAL en MB/s ; FB_TOTAL absent des compteurs par défaut), consulté le 2026-10-09. https://github.com/NVIDIA/dcgm-exporter ↩ ↩2 -
Grafana Labs, NVIDIA DCGM Exporter Dashboard (ID 12239, GPU metrics visualization). https://grafana.com/grafana/dashboards/12239-nvidia-dcgm-exporter-dashboard/ ↩
-
Grafana Labs, Node Exporter Full Dashboard (ID 1860, system metrics — CPU, memory, disk, network). https://grafana.com/grafana/dashboards/1860-node-exporter-full/ ↩
-
vLLM Project, dépôt
vllm-project/vllm,examples/observability/prometheus_grafana/(README,docker-compose.yaml,prometheus.yaml,grafana.json) etexamples/observability/dashboards/grafana/(performance_statistics.json,query_statistics.json), arborescencemainconsultée le 2026-10-10. https://github.com/vllm-project/vllm/tree/main/examples/observability/prometheus_grafana ↩ -
Ollama, Troubleshooting (emplacement des logs :
journalctl -u ollama,~/.ollama/logs/server.log,docker logs), consulté le 2026-10-09 · dépôtollama/ollama,cmd/cmd.go(liste des sous-commandes, sanslogs). https://docs.ollama.com/troubleshooting · https://github.com/ollama/ollama ↩ -
LiteLLM, OpenTelemetry Integration (
litellm_settings.callbacks: ["otel"], variablesOTEL_EXPORTER/OTEL_ENDPOINT), consulté le 2026-10-09 · vLLM Project, CLI Reference —vllm serve(--otlp-traces-endpoint,--collect-detailed-traces all|model|worker), consulté le 2026-10-09. https://docs.litellm.ai/docs/observability/opentelemetry_integration · https://docs.vllm.ai/en/stable/cli/serve/ ↩ -
Langfuse, Self-Hosting (v4 : PostgreSQL + ClickHouse + Redis/Valkey + stockage S3 ; Docker Compose pour l’usage local, Helm pour la production), consulté le 2026-10-09. https://langfuse.com/self-hosting ↩
-
Arize AI, Arize Phoenix — LLM Observability (traces agentiques, RAG debugging, OTEL-compatible), consulté le 2026-10-09. https://arize.com/docs/phoenix ↩
-
Arize AI, dépôt
Arize-ai/phoenix, fichierLICENSE(Elastic License 2.0) et Release arize-phoenix-v20.0.0, 2026-08-11. https://github.com/Arize-ai/phoenix/blob/main/LICENSE · https://github.com/Arize-ai/phoenix/releases/tag/arize-phoenix-v20.0.0 ↩