TechniquePratique9 min de lecture (+1 technique)
Observabilité HPC : les fondamentaux
Les fondamentaux de l'observabilité HPC : ce que chaque composant du cluster expose, les métriques par job, le rattachement des métriques GPU aux jobs Slurm et un tableau de bord lisible par un directeur.
Pour : ingénieurs et SRE · architectesPrérequis : Ligne de commande Linux, bases de Prometheus ou Grafana.
Mardi, 2 h 42. L’entraînement vient de mourir.
Section intitulée « Mardi, 2 h 42. L’entraînement vient de mourir. »Scénario illustratif, construit pour la formation.
Un entraînement d’IA tournait depuis quatre heures sur huit GPU A100 (des processeurs graphiques NVIDIA pour centre de données). Il vient de s’arrêter. Quatre heures sur huit GPU, ce sont 32 heures-GPU perdues, à multiplier par le prix horaire de votre fournisseur ou par votre coût interne. Les prix changent vite et varient selon les contrats : ce guide n’en donne pas, utilisez la grille datée de votre fournisseur.
Voici les dernières lignes du journal du job :
02:42:14 INFO job 184729 step 14 done02:42:15 INFO rank 0 allreduce init02:42:16 ERROR ECC error GPU 302:42:17 WARN retrying step 1502:42:18 WARN retrying step 1502:42:19 INFO job 184729 terminated, exit 137Le pas 14 s’est terminé. Le processus numéro 0 (le « rang » 0) a lancé l’AllReduce, l’échange qui met en commun les résultats de tous les GPU, puis la mémoire du GPU 3 a signalé une erreur ECC : son code de correction d’erreurs a détecté une donnée corrompue. Deux tentatives plus tard, le job s’arrête.
Sauriez-vous dire, en cinq minutes, quel GPU a lâché, sur quel nœud et pour quel utilisateur ? Si le matériel se dégradait déjà les jours précédents ? Quel compte vient d’absorber ces 32 heures-GPU ?
Sans corrélation préparée à l’avance, la réponse demande de croiser à la main les journaux du job, les métriques des GPU et la comptabilité de Slurm, l’ordonnanceur qui attribue les machines. Les données existent, mais elles restent dispersées entre des outils que personne n’a reliés. Cette formation apprend à les relier.
Pourquoi maintenant ?
Section intitulée « Pourquoi maintenant ? »Trois évolutions rendent cette observabilité nécessaire. La première est l’échelle des entraînements d’IA : un entraînement mobilise des dizaines à des milliers de GPU pendant des jours ou des semaines (c’est un ordre de grandeur). Une dégradation silencieuse d’un GPU fait alors perdre une part de ce calcul.
La deuxième est la pression réglementaire. NIS2 s’applique aux entités concernées. La directive (UE) 2023/1791 relative à l’efficacité énergétique impose, par son article 12, aux centres de données d’au moins 500 kW de puissance informatique installée de déclarer chaque année leur performance énergétique. Les allocations de calcul exigent aussi des comptes rendus d’usage. Dans tous ces cas, les auditeurs demandent qui a fait quoi, quand.
La troisième est la responsabilité envers plusieurs clients. Quand plusieurs équipes ou clients partagent le cluster, la refacturation et le partage équitable supposent de savoir à quel compte attribuer chaque joule consommé.
Ce que le HPC change aux métriques, logs et traces
Section intitulée « Ce que le HPC change aux métriques, logs et traces »Les trois signaux de base restent les mêmes : les métriques (des mesures chiffrées dans le temps), les logs (les journaux d’événements) et les traces (le parcours d’une opération à travers le système). Le HPC y ajoute trois contraintes.
La cardinalité, c’est-à-dire le nombre de séries de mesures distinctes, est plus forte, puisqu’on suit chaque GPU et chaque rang. La rétention s’allonge, car les chercheurs comparent volontiers avec des exécutions vieilles de plusieurs années. Enfin, chaque observation doit être rattachée à un job, un utilisateur et un compte. Sans ce rattachement, elle ne sert ni à la refacturation ni à l’audit.
Le contenu : trois modules et un projet final
Section intitulée « Le contenu : trois modules et un projet final »Module 1 : l’anatomie physique du cluster
Section intitulée « Module 1 : l’anatomie physique du cluster »Le premier module passe en revue les cinq composants du cluster et ce que chacun expose. Côté serveurs, node_exporter publie les métriques système et révèle le placement NUMA (la façon dont processeurs et mémoire sont regroupés dans une machine, qui joue sur les performances). Côté GPU, l’exportateur DCGM (Data Center GPU Manager, l’outil NVIDIA de supervision des GPU) identifie chaque carte par un label UUID, son identifiant unique. Le réseau livre ses compteurs de ports InfiniBand ou RoCE (de l’Ethernet capable de transferts directs de mémoire à mémoire). Le stockage parallèle se présente sous trois formes courantes : Lustre, IBM Storage Scale (ex-Spectrum Scale) et BeeGFS. Slurm, enfin, expose ses jobs, ses comptes et ses partitions (les groupes de machines entre lesquels il répartit le travail).
Lab L1 : écrire un premier exportateur Redfish en Python (Redfish est l’interface standard de gestion matérielle des serveurs, qui donne accès aux températures et aux alimentations), le faire collecter par VictoriaMetrics (ou Prometheus), l’afficher dans Grafana et déclencher une alerte thermique par injection de panne.
Module 2 : les métriques par job
Section intitulée « Module 2 : les métriques par job »Le deuxième module traite le rattachement des métriques GPU aux jobs, le cœur du scénario de 2 h 42. Slurm sait lancer deux scripts autour de chaque job : le prolog au démarrage, l’epilog à la fin. Le prolog écrit, pour chaque GPU alloué, l’identifiant du job dans un répertoire que lit dcgm-exporter. Les métriques de ce GPU reçoivent alors un label hpc_job. On relie ensuite ce job à son utilisateur et à son compte avec sacct (la commande de comptabilité de Slurm) ou un exportateur Slurm, pour obtenir une réponse métier : la puissance consommée par compte.
Lab L2 : faire tourner côte à côte dcgm-exporter avec ce rattachement et un exportateur Slurm, écrire une jointure PromQL sur l’identifiant de job qui attribue la puissance GPU aux comptes, puis une alerte sur budget énergétique.
Lab L3 : détecter la contention dans un GPU découpé avec MIG (Multi-Instance GPU, qui partage une carte entre plusieurs utilisateurs). Une GPU instance MIG peut contenir plusieurs compute instances, qui partagent la mémoire et la bande passante de cette instance. Elles peuvent donc se gêner. Cette contention reste invisible aux métriques d’utilisation standard.
Pour les équipes techniques : le paramètre du rattachement
Le répertoire lu par dcgm-exporter se configure avec l’option --hpc-job-mapping-dir ou la variable d’environnement DCGM_HPC_JOB_MAPPING_DIR. Les métriques des GPU concernés portent ensuite le label hpc_job.
Un lab publié : la facture d’énergie de chaque job
Section intitulée « Un lab publié : la facture d’énergie de chaque job »Ce rattachement tourne déjà dans un lab publié sur la forge, slurm-otel-energy, qui va jusqu’à la facture. Pensez à la facture d’électricité d’un immeuble qu’on voudrait répartir par appartement, puis par pièce. Le lab fait la même chose pour un cluster GPU. Pour chaque job terminé, il dit quel code a tourné, sur quels GPU, pendant combien de temps et combien d’énergie a coûté chaque phase : chargement des données, calcul, évaluation, sauvegarde.
Tout passe par OpenTelemetry. La facture n’est donc pas un rapport maison : c’est une trace et des métriques que n’importe quel outil compatible sait lire. Le lab tourne sur un ordinateur portable avec des GPU simulés et sur de vrais GPU NVIDIA avec le même code.
Le scénario fourni lance trois jobs pour trois utilisateurs. L’un d’eux est un notebook qui garde un GPU sans jamais s’en servir. Il rappelle une vérité peu connue : un GPU réservé consomme de l’énergie même quand rien ne tourne dessus. Le dépôt dit aussi ce que le lab ne sait pas encore mesurer. Les phases très courtes restent floues, la part du serveur attribuée à chaque job est une convention de répartition et non une mesure. Enfin, un GPU partagé entre plusieurs jobs est réparti à parts égales.
Une première version, plus simple, reste publiée : hpctrace. Elle tient sur un seul nœud Slurm et fait de chaque job une trace OpenTelemetry, avec l’énergie par job et par phase. Elle fonctionne sans GPU ou avec une vraie carte NVIDIA. Elle a servi de base à une proposition de conventions sémantiques pour le HPC, c’est-à-dire des noms d’attributs communs (hpc.job.id, par exemple) pour que tous les outils décrivent un job de la même façon.
Pour les équipes techniques : lancer le lab et ce qu'il démontre
Il faut Docker avec Compose v2, une machine x86_64 et environ 4 Go de mémoire libre. Aucun GPU n’est nécessaire : le simulateur parle exactement comme dcgm-exporter.
git clone https://forge.erythix.tech/labstraining/labs/slurm-otel-energy.gitcd slurm-otel-energydocker compose up -d --builddocker compose exec slurmctld /opt/lab/jobs/submit-scenario.shLe prolog écrit l’identifiant du job pour chaque GPU, au format que dcgm-exporter comprend déjà. Le TaskProlog donne au job un TRACEPARENT calculé à partir de son identifiant : chaque nœud retrouve ainsi la même trace sans se concerter. L’application ouvre un span par phase avec le SDK OpenTelemetry standard. Après le job, un service de comptabilité lit Slurm, prend l’énergie des compteurs matériels des GPU, la vérifie contre l’intégrale des mesures de puissance et la découpe par phase. Sur le passage de référence publié dans le dépôt, avec des GPU simulés, les deux calculs concordent à quelques centièmes de pour cent près.
Module 3 : l’intégration
Section intitulée « Module 3 : l’intégration »Le troisième module demande un vrai livrable. Le contexte : un cluster GPU de plusieurs centaines de nœuds partagé entre 6 comptes. Le livrable : un tableau de bord qui passe le test des cinq secondes devant un directeur (en cinq secondes, il doit comprendre si tout va bien) et trois alertes qui ne réveillent l’astreinte que si c’est nécessaire.
Projet final : concevoir le tableau de bord (6 panneaux maximum), le construire dans Grafana et vmalert (le moteur d’alertes de VictoriaMetrics), le valider contre trois pannes injectées, puis le défendre en cinq minutes.
Chaque lab fournira un fichier de départ, une solution de référence, des validateurs automatiques et des scripts d’injection de panne.
Ce que vous saurez faire
Section intitulée « Ce que vous saurez faire »À la fin de la formation, vous saurez :
- déployer une stack standard de zéro : VictoriaMetrics (ou Prometheus), Grafana, vmalert, Alertmanager ;
- lire couramment les métriques DCGM et Slurm, en connaissant les cinq métriques GPU et les six métriques Slurm qui comptent ;
- écrire un petit exportateur Prometheus en Python, en respectant les conventions de nommage et la discipline des labels ;
- rattacher des métriques de collecteurs différents à un job, puis à un compte Slurm, pour attribuer la consommation ;
- concevoir un tableau de bord qui passe le test des cinq secondes devant un interlocuteur non technique ;
- écrire une règle d’alerte qui ne « bat » pas (qui ne s’allume et ne s’éteint pas en boucle), avec une procédure associée et un seuil justifié.
Public et prérequis
Section intitulée « Public et prérequis »La formation vise les SRE et ingénieurs plateforme qui découvrent le HPC, les administrateurs HPC qui modernisent leur supervision et les équipes DevOps qui accueillent des charges d’IA. Elle sert aussi aux équipes de calcul scientifique sous pression d’audit et aux équipes de cloud souverain qui préparent une infrastructure d’IA.
Elle ne couvre pas la recherche en apprentissage automatique, l’administration de Slurm ni les plateformes centrées sur Kubernetes.
Il faut connaître la ligne de commande Linux et avoir des bases de Prometheus ou Grafana. Si vous débutez complètement, commencez par Comprendre le HPC.
Approfondissements prévus
Section intitulée « Approfondissements prévus »Deux suites sont prévues. La première porte sur l’instrumentation, le réseau et le stockage. On y écrit en Go un exportateur Slurm de production, avec pour objectif de lab de tenir une charge simulée de 5 000 jobs par seconde. Elle couvre aussi l’observabilité InfiniBand, Lustre en profondeur, la prévision de capacité et d’attente et une refacturation complète.
La seconde porte sur l’entraînement d’IA, la stack souveraine et l’AIOps (l’usage de l’apprentissage automatique pour l’exploitation). On y détecte des anomalies rang par rang sur un entraînement simulé à 64 rangs, avec un autoencodeur (un réseau de neurones qui apprend à reconnaître le comportement normal), pour attraper un traînard injecté : un rang plus lent que les autres, dont le lab fixe la pénalité (par exemple 30 % de débit, un paramètre de simulation et non une mesure). Suivent la santé des communications collectives, une stack isolée du réseau et la prédiction de pannes.
Révisé le 2 octobre 2026 : prix retirés, coût du scénario exprimé en heures-GPU, rattachement des métriques GPU aux jobs décrit avec le job mapping de dcgm-exporter, contention MIG précisée (compute instances d’une même GPU instance), référence à la directive (UE) 2023/1791, IBM Storage Scale, état réel des labs.