Surveillez Vos GPU NVIDIA en Temps Réel avec GPU Hot

Si vous exécutez des charges de travail d'IA, des serveurs d'inférence LLM, ou des applications gourmandes en GPU, vous avez probablement ressenti la frustration de ne pas savoir ce que font vos GPU en un coup d'œil. La commande nvidia-smi est pratique pour une vérification rapide, mais elle ne fournit ni tendances historiques, ni agrégation multi-nœuds, ni tableau de bord à épingler dans votre navigateur.

C'est là qu'intervient GPU Hot — un tableau de bord de surveillance GPU léger, open-source et basé sur Docker, qui vous offre une visibilité en temps réel sur vos GPU NVIDIA avec un rafraîchissement sub-seconde. Conçu pour les configurations mono-machine comme pour les clusters multi-nœuds, il est idéal pour les homelabs, les serveurs de recherche en IA et les flottes de GPU en production.

Pourquoi Est-IL Tendance ?

GPU Hot a gagné plus de 1 500 étoiles GitHub en peu de temps car il résout un vrai problème : la surveillance GPU ne devrait pas nécessiter un doctorat en observabilité. Contrairement aux solutions complexes comme Prometheus + Grafana + DCGM Exporter (qui exigent plusieurs services, une configuration compliquée et des ressources importantes), GPU Hot est un conteneur Docker unique qui fonctionne directement. Une seule commande suffit pour obtenir un tableau de bord élégant avec graphiques, mises à jour WebSocket en temps réel et agrégation multi-nœuds.

Architecture

L'architecture suit une pile verticale claire :

1. Navigateur / Client API — Accédez au tableau de bord via HTTP sur le port 1312, ou utilisez l'API REST / WebSocket pour un accès programmatique
2. Frontend Dashboard — Interface utilisateur basée sur Chart.js + Socket.IO qui affiche les métriques GPU en temps réel avec des graphiques interactifs
3. WebSocket Handler — Envoie les métriques GPU à tous les clients connectés en temps réel (intervalles sub-secondes)
4. nvidia-smi Fallback — Source de données alternative pour les GPU plus anciens qui ne supportent pas NVML directement
5. Serveur FastAPI — Serveur web central exposant des endpoints REST et des connexions WebSocket, construit avec FastAPI + Uvicorn
6. Moniteur NVML — Interroge les métriques GPU via la NVIDIA Management Library (nvidia-ml-py) toutes les 0,5 secondes
7. GPU NVIDIA — La couche matérielle surveillée (CUDA, nvidia-smi, NVML)
8. Hub Aggregator — Mode multi-nœuds optionnel qui collecte les métriques depuis des serveurs GPU distants via NODE_URLS

Des liaisons peer optionnelles connectent le Hub Aggregator au serveur FastAPI pour les configurations multi-nœuds, et le fallback nvidia-smi assure la rétrocompatibilité avec les GPU plus anciens.

Prérequis

• Une machine Linux avec des GPU NVIDIA (ou une VM avec passage GPU)
• Docker installé (20.10+)
• NVIDIA Container Toolkit installé
• Pilotes NVIDIA installés (testez avec nvidia-smi)

Installation

GPU Hot se configure en moins de 60 secondes. Voici comment :

Étape 1 : Installer NVIDIA Container Toolkit

Si ce n'est pas déjà fait, installez le NVIDIA Container Toolkit pour permettre l'accès GPU dans Docker :

# Ubuntu / Debian
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit
sudo systemctl restart docker

Étape 2 : Lancer GPU Hot (Machine Unique)

docker run -d \
--gpus all \
-p 1312:1312 \
--name gpu-hot \
--restart unless-stopped \
ghcr.io/psalias2006/gpu-hot:latest

C'est tout. Ouvrez http://localhost:1312 dans votre navigateur pour voir le tableau de bord.

Étape 3 : Vérifier le Fonctionnement

# Vérifier que le conteneur tourne
docker ps | grep gpu-hot

# Tester l'API
curl -s http://localhost:1312/api/gpu-data | head -30

# Vérifier que le tableau de bord se charge
curl -s http://localhost:1312/ | grep -o '<title>.*</title>'

Étape 4 : Surveiller des GPU Spécifiques

Pour surveiller uniquement certains GPU :

docker run -d \
--gpus all \
-p 1312:1312 \
-e NVIDIA_VISIBLE_DEVICES=0,1 \
--name gpu-hot \
--restart unless-stopped \
ghcr.io/psalias2006/gpu-hot:latest

Configuration Multi-Nœuds

Pour surveiller plusieurs serveurs GPU depuis un seul tableau de bord :

Sur chaque nœud GPU :

docker run -d \
--gpus all \
-p 1312:1312 \
-e NODE_NAME=$(hostname) \
--name gpu-hot \
--restart unless-stopped \
ghcr.io/psalias2006/gpu-hot:latest

Sur la machine hub (peut être une VM légère sans GPU) :

docker run -d \
-p 1312:1312 \
-e GPU_HOT_MODE=hub \
-e NODE_URLS=http://gpu-server-1:1312,http://gpu-server-2:1312,http://gpu-server-3:1312 \
--name gpu-hot-hub \
--restart unless-stopped \
ghcr.io/psalias2006/gpu-hot:latest

Tous vos serveurs GPU apparaissent maintenant sur un seul tableau de bord à http://hub-ip:1312.

Utilisation de Docker Compose

Pour une configuration plus reproductible, utilisez Docker Compose :

services:
gpu-hot:
  image: ghcr.io/psalias2006/gpu-hot:latest
  container_name: gpu-hot
  ports:
    - "1312:1312"
  environment:
    - NVIDIA_VISIBLE_DEVICES=all
    - NVIDIA_DRIVER_CAPABILITIES=all
    - NODE_NAME=${HOSTNAME}
  deploy:
    resources:
      reservations:
        devices:
          - driver: nvidia
            count: all
            capabilities: [gpu]
  init: true
  pid: "host"
  restart: unless-stopped
  healthcheck:
    test: ["CMD", "curl", "-f", "http://localhost:1312/api/gpu-data"]
    interval: 30s
    timeout: 10s
    retries: 3
    start_period: 40s

Sauvegardez ceci dans compose.yml et exécutez :

docker compose up -d

Options de Configuration

GPU Hot utilise des variables d'environnement pour la configuration :

• NVIDIA_VISIBLE_DEVICES — Index des GPU à surveiller (séparés par des virgules). Défaut : all
• NVIDIA_SMI — Force le mode nvidia-smi pour les GPU anciens. Défaut : false
• GPU_HOT_MODE — Définir à hub pour l'agrégation multi-nœuds. Défaut : (mono-nœud)
• NODE_NAME — Nom d'affichage du nœud. Défaut : nom d'hôte
• NODE_URLS — URLs des nœuds (séparées par des virgules, requis en mode hub)

Métriques Disponibles

Le tableau de bord fournit des graphiques et cartes en temps réel pour :

• Utilisation GPU — Pourcentage de capacité de calcul utilisée
• Température — Température actuelle du GPU en Celsius
• Mémoire — VRAM utilisée vs totale
• Consommation — Puissance électrique en watts
• Vitesse du ventilateur — RPM et pourcentage
• Fréquences d'horloge — Fréquences du cœur et de la mémoire
• Informations PCIe — Vitesse et largeur de lien
• P-State — État de performance
• Statut de throttling — Indicateurs de throttling thermique et électrique
• Sessions encodeur/décodeur — Utilisation du codage/décodage matériel
• Processus — Utilisation mémoire GPU par processus avec PID

Référence API

GPU Hot expose une API simple pour un accès programmatique :

# Obtenir un instantané JSON des métriques
curl http://localhost:1312/api/gpu-data

# Vérifier la version
curl http://localhost:1312/api/version

Pour un flux en temps réel, connectez-vous à l'endpoint WebSocket :

const ws = new WebSocket('ws://localhost:1312/socket.io/');
ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  console.log(data.gpus);      // métriques par GPU
  console.log(data.processes); // processus GPU actifs
  console.log(data.system);    // CPU, RAM, swap, disque, réseau
};

Dépannage

Aucun GPU détecté dans le tableau de bord :

# Vérifiez que nvidia-smi fonctionne sur l'hôte
nvidia-smi

# Testez l'accès GPU Docker
docker run --rm --gpus all nvidia/cuda:12.1.0-base-ubuntu22.04 nvidia-smi

Le hub ne peut pas se connecter aux nœuds :

# Testez la connectivité depuis la machine hub
curl http://ip-du-noeud:1312/api/gpu-data

# Vérifiez le pare-feu
sudo ufw allow 1312/tcp

Problèmes de performance : Augmentez l'intervalle de mise à jour en construisant depuis les sources et en modifiant core/config.py :

UPDATE_INTERVAL = 1.0  # La valeur par défaut est 0,5 seconde

Comparaison : GPU Hot vs Alternatives

• GPU Hot — Un seul conteneur Docker, rafraîchissement sub-seconde, hub multi-nœuds, graphiques intégrés. Meilleur pour une configuration rapide et une surveillance en temps réel.
• Prometheus + DCGM Exporter + Grafana — Stack d'observabilité complet avec alertes, stockage à long terme et tableaux de bord personnalisés. Trop lourd pour la plupart des cas.
• nvidia-smi + watch — Pas d'historique, pas de tableau de bord, pas de multi-nœuds.
• nvtop — Interface terminal, idéal pour une utilisation interactive mais pas accessible via le web.

Ressources

• GitHub : github.com/psalias2006/gpu-hot
• Démo en direct : psalias2006.github.io/gpu-hot/demo.html
• Licence : MIT
• Documentation NVIDIA Container Toolkit : docs.nvidia.com/datacenter/cloud-native/container-toolkit