Un guide pratique des outils d'observabilité de NVIDIA pour les clusters d'IA et de la manière dont nous les relions à OpenTelemetry. Il couvre UFM et ses plugins SDK ouverts, l'API REST et les endpoints de télémétrie d'UFM, DCGM et dcgm-exporter pour les GPU (y compris les renommages de métriques de dcgm-exporter 4.9.0), DOCA Telemetry Service sur BlueField, NetQ pour l'Ethernet Spectrum-X, ainsi que l'architecture de référence de Workstation : un agent OpenTelemetry Collector sur chaque nœud, une paire de passerelles et deux backends (métriques compatibles Prometheus dans Grafana Mimir avec Grafana et Tempo, et la suite Elastic). Des configurations fonctionnelles, des règles d'alerte, un schéma d'étiquetage, des calculs de cardinalité et la conception de la haute disponibilité de la supervision elle-même sont inclus. L'argumentaire économique se trouve dans l'article de blog associé.
Version interactive : parcourez dix-sept exemples de tableaux de bord, chacun avec ses requêtes PromQL ou KQL et ses seuils d'alerte.
Cet article suit la position de notre précédente note technique sur Big Prometheus et MoSCoW : OpenTelemetry est le contrat de télémétrie, la sémantique Prometheus et PromQL constituent le langage des métriques, et un stockage à mise à l'échelle horizontale (ici Grafana Mimir) est utilisé dès qu'un Prometheus unique ne suffit plus à répondre aux questions portant sur l'ensemble du parc. La seule chose que nous ajoutons pour les clusters d'IA est un second backend pour les journaux, car la suite Elastic est très souvent déjà en place pour les équipes de sécurité et d'exploitation. Les journaux vont dans un seul stockage principal, comme le recommande cet article ; nous n'écrivons pas deux fois les mêmes journaux.
1. Les signaux qui comptent dans un cluster d'IA
Un cluster d'IA tombe en panne par couches. Une conception de supervision utile nomme chaque couche, l'outil NVIDIA qui la connaît et la manière dont les données sortent de cet outil.
| Couche | Pannes typiques | Source NVIDIA | Comment nous la collectons |
|---|---|---|---|
| GPU et NVLink | Erreurs XID, événements ECC et de remappage de lignes, bridage thermique ou électrique, erreurs NVLink, GPU inactifs dans des jobs en cours | DCGM (moteur hôte) et dcgm-exporter | Collecte Prometheus sur le nœud par l'agent Collector |
| Fabric InfiniBand de calcul et de stockage | Instabilités de liens, erreurs de symboles et d'intégrité, liens négociés à une vitesse ou une largeur incorrecte, congestion, transceivers en surchauffe ou défaillants, changements du subnet manager | UFM Telemetry et UFM Enterprise (événements, alarmes, topologie, API REST), plugins SDK | Collecte Prometheus de la télémétrie UFM ; événements UFM par syslog ou Fluentd ; interrogation REST pour la topologie |
| Fabric Ethernet (Spectrum-X, stockage et frontal) | Pertes de paquets, tempêtes PFC, marquage ECN, congestion RoCE, changements BGP ou EVPN | NetQ ; télémétrie en streaming des switches | API NetQ ou streaming gNMI ou OTLP des switches vers la passerelle |
| DPU BlueField | Compteurs de ports et de délestage, santé des DPU | DOCA Telemetry Service | Collecte de son endpoint au format Prometheus |
| Hôtes et clients de stockage | Pression mémoire, usure NVMe, latence du système de fichiers, erreurs de carte réseau | (outils Linux standard) | node-exporter, récepteurs filelog et journald |
| Ordonnanceur et orchestration | Jobs bloqués, nœuds drainés, GPU demandés sans utilisation | (Slurm, Kubernetes), intégration Slurm d'UFM | Étiquettes d'association jobs-GPU de dcgm-exporter ; exporters d'ordonnanceur ; métadonnées Kubernetes |
| Services d'IA | Délai avant le premier token élevé, mise en file d'attente, erreurs, baisses du débit de tokens | (serveurs de modèles comme NIM, Triton ou vLLM) | Traces et métriques du SDK OpenTelemetry en OTLP |
2. NVIDIA UFM : niveaux, endpoints de télémétrie et API REST
Unified Fabric Manager (voir la page officielle NVIDIA UFM) exploite et observe les fabrics InfiniBand. Il se décline en trois niveaux qui s'appuient les uns sur les autres :
- UFM Telemetry échantillonne les compteurs de performance et d'erreurs de chaque port de la fabric, ainsi que les données des câbles et des transceivers, et les expose ou les diffuse. Il s'agit uniquement d'une couche de visibilité.
- UFM Enterprise ajoute la gestion de la fabric : découverte et topologie, pilotage du subnet manager, gestion des clés de partition (PKey), événements et alarmes, rapports de santé et de topologie, API REST, intégrations avec les ordonnanceurs et les gestionnaires de clusters, et une paire actif/passif pour la haute disponibilité.
- UFM Cyber-AI applique l'analytique et l'apprentissage automatique à l'historique de télémétrie d'Enterprise pour prédire les liens et les câbles défaillants et signaler les anomalies de performance ou d'utilisation.
Endpoints de télémétrie
Le service de télémétrie d'UFM sert ses compteurs en HTTP, par défaut sur le port 9001. Il existe une vue CSV (par exemple /csv/metrics, ainsi que des vues par ensemble de compteurs comme /csv/xcset/ib_basic_debug) et, lorsque la génération d'étiquettes Prometheus est activée, un endpoint Prometheus dont la documentation du SDK indique le chemin labels/enterprise. Les vues par ensemble de compteurs acceptent des paramètres de partitionnement (num_shards, shard, sharding_field=port_guid), ce qui est utile lorsqu'une requête unique sur une grande fabric est trop volumineuse pour obtenir une réponse dans l'intervalle de collecte.
Les noms des compteurs suivent les attributs de gestion des performances d'InfiniBand. Ceux que nous avons confirmés dans la documentation SDK de NVIDIA, et sur lesquels nous nous appuyons ci-dessous, sont les suivants :
| Compteur | Ce qu'il vous apprend |
|---|---|
PortXmitDataExtended, PortRcvDataExtended | Données envoyées et reçues sur le port ; calculez-en le taux pour obtenir la bande passante (le tableau de bord Grafana de NVIDIA multiplie le taux par 8 pour afficher des bits par seconde) |
LinkDownedCounterExtended | Nombre de fois où le lien est tombé : le signal d'instabilité de lien |
LinkErrorRecoveryCounterExtended | Nombre de fois où le lien s'est renégocié pour se remettre d'erreurs : souvent le premier signe d'un câble limite |
LocalLinkIntegrityErrorsExtended | Erreurs physiques locales dépassant le seuil d'intégrité |
ExcessiveBufferOverrunErrorsExtended | Dépassements de buffer consécutifs sur le port |
Normalized_CBW | Un indicateur de bande passante de congestion exposé par UFM ; le tableau de bord de NVIDIA en trace le maximum par niveau de topologie |
dev_temperature | Température de l'équipement |
L'ensemble exact et les noms des étiquettes dépendent de l'ensemble de compteurs que vous activez et de la version d'UFM : listez donc toujours ce que votre endpoint sert réellement avant d'écrire des règles : curl -s http://<ufm-host>:9001/csv/metrics | head.
API REST
L'API REST d'UFM Enterprise se trouve sous /ufmRest sur le serveur UFM, avec des préfixes voisins pour d'autres méthodes d'authentification : /ufmRestV2 (session), /ufmRestV3 (jeton d'accès) et /ufmRestKrb (Kerberos). Les jetons sont créés par un POST sur /app/tokens. Pour la supervision, nous utilisons trois ressources en lecture seule, qui figurent toutes dans les exemples du SDK de NVIDIA :
# Current alarms and recent events (use a read-only monitoring account)
curl -sk -u monitor:"$UFM_PASSWORD" https://ufm-vip.obs.internal/ufmRest/app/alarms
curl -sk -u monitor:"$UFM_PASSWORD" https://ufm-vip.obs.internal/ufmRest/app/events
# Every link in the fabric, with both ends: the basis of our node-to-switch-port map
curl -sk -u monitor:"$UFM_PASSWORD" https://ufm-vip.obs.internal/ufmRest/resources/links
# UFM's own health in Prometheus format (scrape every few minutes, not seconds)
curl -sk -u monitor:"$UFM_PASSWORD" https://ufm-vip.obs.internal/ufmRest/system_monitoring/metrics
Nous encapsulons l'appel aux liens dans un petit exporter qui publie toutes les cinq minutes une métrique d'information, ws_ib_link_info{node, hca_port, switch, port}. C'est cette métrique qui permet à une requête de remonter d'un job Slurm à ses GPU, puis aux ports de switch exacts que traverse son trafic. C'est notre convention, et non une métrique NVIDIA.
Haute disponibilité
UFM Enterprise s'exécute sous forme de paire actif/passif gérée par ses outils de haute disponibilité (ufm_ha_cluster), avec une configuration répliquée entre les deux serveurs et une IP virtuelle qui bascule en cas de failover. Faites pointer chaque collecte, client REST et destination syslog vers l'IP virtuelle, jamais vers un nœud. Lorsqu'un plugin est utilisé en haute disponibilité, NVIDIA recommande de charger aussi son image de conteneur sur le nœud passif, afin qu'il soit prêt après le basculement.
3. Le SDK UFM et ses plugins
NVIDIA publie un SDK ouvert pour UFM à l'adresse github.com/Mellanox/ufm_sdk_3.0. Il se compose pour l'essentiel d'un ensemble de plugins : des conteneurs qu'UFM gère via son gestionnaire de plugins (depuis l'interface web, ou avec /opt/ufm/scripts/manage_ufm_plugins.sh add -p <name> sur une installation autonome ou en haute disponibilité). Voici le rôle de chacun et sa place dans notre architecture.
| Plugin | Ce qu'il fait | Sa place |
|---|---|---|
grafana_infiniband_telemetry_plugin | Sert un second endpoint Prometheus (port 8982, chemin /labels/enterprise) avec des étiquettes lisibles, comme les noms des équipements, au lieu d'étiquettes fondées sur les GUID, et fournit un exemple de tableau de bord Grafana. | Notre cible de collecte privilégiée pour les compteurs de la fabric : des étiquettes lisibles signifient moins de règles de réétiquetage. |
grafana_telemetry_plugin | Des instructions et un tableau de bord pour collecter directement l'endpoint Prometheus propre à UFM Telemetry (port 9001). | À utiliser lorsque vous ne pouvez pas exécuter le plugin ci-dessus ; attendez-vous à des étiquettes fondées sur les GUID. |
grafana_ufm_monitoring_plugin | Un tableau de bord pour la santé du système UFM lui-même, collecté depuis /ufmRest/system_monitoring/metrics en HTTPS avec une authentification basique. | Supervise le superviseur : CPU, mémoire et santé de l'API des serveurs UFM. |
ufm_events_grafana_dashboard_plugin | Analyse le fichier event.log d'UFM avec Fluentd, l'envoie vers un Loki fourni et l'affiche dans un Grafana fourni. | Pratique pour démarrer rapidement ; en production, nous envoyons plutôt les événements vers le stockage central des journaux. |
fluentd_telemetry_plugin (TFS) | Interroge un ou plusieurs endpoints de télémétrie UFM, à son propre intervalle pour chaque endpoint, et diffuse les compteurs vers une destination Fluentd (protocole forward sur le port 24224 par défaut, ou HTTP). Les attributs peuvent être activés, désactivés ou renommés via son API REST, et il publie ses propres statistiques de streaming au format Prometheus. | La voie d'acheminement des compteurs de la fabric vers Elasticsearch lorsqu'un client a standardisé Elastic pour les métriques comme pour les journaux. |
fluentd_topology_plugin | Extrait la topologie via l'API UFM et la diffuse selon le protocole Fluentd. | Des instantanés de topologie dans le stockage des journaux, pour voir à quoi ressemblait la fabric au moment d'un incident. |
ufm_syslog_streaming_plugin (EFS) | Extrait les événements UFM de son syslog et les diffuse vers Fluentd (compatible Fluent Bit), et peut aussi copier le syslog d'UFM vers un serveur syslog distant. | Notre voie principale pour acheminer les événements et alarmes UFM vers Elasticsearch. |
zabbix_telemetry_plugin | Des instructions pour diffuser les événements UFM dans Zabbix via l'agent Zabbix et des éléments de journal. | Pour les équipes d'exploitation qui utilisent déjà Zabbix comme console d'événements. |
SLURM-Integration | Des hooks prolog et epilog Slurm qui appellent UFM pour chaque job : clés de partition statiques ou dynamiques (par job, dérivées de l'ID du job), UFM gérant automatiquement les réservations SHARP à partir de l'appartenance aux PKey. Prend en charge l'authentification par jeton, basique ou Kerberos. UFM doit fonctionner en mode gestion, et non en mode supervision seule. | Isolation réseau par job et trace des ports utilisés par chaque job. |
pdr_deterministic_plugin | Problem Detection and Resolution : utilise la télémétrie dynamique d'UFM pour calculer les taux d'erreur binaire, les températures et les variations de pertes de lien, isole les ports qui franchissent les seuils, les enregistre, puis lève leur isolation après une période de test sans erreur. Dispose d'un mode simulation et d'une liste d'exclusion. | Isolation automatique des liens défectueux pour que les jobs les contournent ; voir la section 4. |
UFM_NDT_Plugin | Comparaison avec le Network Design Tool : chargez la topologie prévue, comparez-la avec celle qu'UFM a découverte, une fois ou de façon planifiée, et consultez les rapports via l'API REST. | Prouve que le câblage réalisé correspond à la conception, à la remise et après chaque maintenance. |
gnmi_nvos_events_plugin | S'abonne en gNMI aux événements système « on change » des switches gérés par NVOS et les transforme en événements externes UFM. | Intègre les événements côté switch (par exemple la réinitialisation d'un transceiver) au même flux d'événements UFM. |
snmp_receiver_plugin | Écoute les traps SNMP des switches gérés et les redirige vers UFM sous forme d'événements. | Même principe pour les switches qui n'envoient que des traps. |
grpc_streamer_plugin | Un serveur gRPC qui renvoie les données REST d'UFM (événements, alarmes, liens et autres) une seule fois ou sous forme de flux périodique, éventuellement limité aux changements. NVIDIA l'indique comme en cours de développement. | Pas encore dans notre architecture de production ; nous le suivons comme alternative à plus faible latence à l'interrogation REST. |
ufm_log_analyzer_plugin | Analyse hors ligne un sysdump ou des journaux UFM et produit des constats et un rapport PDF. NVIDIA l'indique comme en cours de développement et destiné à un usage interne. | Utile pour les dossiers de support ; ne fait pas partie de la supervision en temps réel. |
bright_plugin | Connecte UFM à Bright Cluster Manager (désormais NVIDIA Base Command Manager) et importe dans UFM l'état des nœuds et les affectations de jobs. | Place le contexte des charges de travail à côté des événements réseau pour l'analyse des causes profondes sur les clusters gérés par BCM. |
La plupart des plugins sont fournis sous forme d'images sur Docker Hub (mellanox/ufm-plugin-*) ; PDR se télécharge depuis le NVIDIA Licensing Portal. Pour les sites isolés du réseau, le SDK documente la voie habituelle par docker save et docker load, et nous incluons les images dans le paquet hors ligne que nous préparons avant l'expédition.
4. Problem Detection and Resolution en pratique
PDR est le plugin qui modifie le plus l'exploitation ; il mérite donc sa propre section. Son fichier de configuration expose directement les seuils. Les valeurs par défaut du SDK au moment de la rédaction sont les suivantes :
| Paramètre | Valeur par défaut | Signification |
|---|---|---|
INTERVAL | 300 s | Fréquence à laquelle les compteurs de télémétrie sont demandés |
MAX_NUM_ISOLATE | 10 | Nombre maximal de ports isolés (la plus grande des deux valeurs entre celle-ci et 0,5 % de la taille de la fabric) |
TMAX / D_TMAX | 70 °C / 10 | Température maximale et hausse maximale de température |
MAX_PDR | 1e-12 | Taux maximal de perte de paquets |
CONFIGURED_BER_CHECK, CONFIGURED_TEMP_CHECK, LINK_DOWN_ISOLATION | True | Les contrôles qui peuvent déclencher une isolation |
SWITCH_TO_HOST_ISOLATION | True | Si les liens d'accès vers les hôtes peuvent être isolés |
DRY_RUN | False | Journaliser les décisions au lieu d'agir |
DEISOLATE_CONSIDER_TIME | 5 min | Durée pendant laquelle un port doit paraître sain avant d'être remis en service |
MAX_PORT_RESET_NUM | 2 par semaine | Nombre de réinitialisations de port autorisées avant la remise à zéro d'une fenêtre de réinitialisation |
Son contrôle du taux d'erreur binaire surveille les erreurs de symboles sur des fenêtres courtes et longues (environ 12 et 125 minutes), ce qui explique qu'il détecte les câbles en cours de dégradation et pas seulement ceux qui sont déjà défaillants. Notre déploiement suit toujours le même schéma :
- L'activer avec
DRY_RUN=Truependant deux à quatre semaines et envoyer son journal vers Elasticsearch. Chaque ligne « isolerait » devient un ticket que nous examinons au regard des compteurs UFM. - Convenir de la liste d'exclusion (les ports que PDR ne doit jamais toucher, comme les liens de stockage à attachement unique) via l'API REST du plugin.
- Passer à l'isolation réelle, en décidant de
SWITCH_TO_HOST_ISOLATIONsite par site : isoler un lien d'hôte retire ce nœud des jobs, ce qui est parfois souhaitable et parfois non. - Alerter à chaque isolation et levée d'isolation, et créer un ticket de maintenance pour la réparation physique.
5. Télémétrie GPU : DCGM et dcgm-exporter
NVIDIA Data Center GPU Manager (DCGM) est le service de santé et de télémétrie des GPU ; dcgm-exporter transforme ses champs en métriques Prometheus, par défaut sur le port 9400. Sur Kubernetes, il est normalement déployé par le NVIDIA GPU Operator ; sur les clusters Slurm, nous l'exécutons comme service systemd ou comme conteneur à côté du moteur hôte DCGM.
dcgm-exporter 4.9.0 a renommé les métriques par défaut
La version 4.9.0 (novembre 2026) renomme les champs par défaut et de profilage selon leurs noms DCGM 4.7, et onze d'entre eux changent d'unité : les fréquences passent en hertz, l'énergie en joules, l'utilisation d'un pourcentage à un ratio de 0 à 1, la mémoire de Mio en octets, et le débit NVLink en octets par seconde. Les tableaux de bord et les alertes écrits pour la version 4.8.x deviendront silencieusement vides ou, pire, compareront un ratio à un pourcentage. Les métriques par défaut que nous utilisons le plus :
| Nom en 4.8.x | Nom en 4.9.0 | Changement d'unité |
|---|---|---|
DCGM_FI_DEV_GPU_UTIL | DCGM_FI_DEV_GPU_UTIL_RATIO | % vers 0–1 |
DCGM_FI_DEV_FB_USED | DCGM_FI_DEV_FB_USED_BYTES | Mio vers octets |
DCGM_FI_DEV_GPU_TEMP | DCGM_FI_DEV_GPU_TEMP_CELSIUS | aucun |
DCGM_FI_DEV_POWER_USAGE | DCGM_FI_DEV_BOARD_POWER_WATTS | aucun |
DCGM_FI_DEV_TOTAL_ENERGY_CONSUMPTION | DCGM_FI_DEV_GPU_ENERGY_JOULES_TOTAL | mJ vers J |
DCGM_FI_DEV_XID_ERRORS | DCGM_FI_DEV_XID_ERROR | aucun (dernière valeur XID) |
DCGM_FI_DEV_NVLINK_BANDWIDTH_TOTAL | DCGM_FI_DEV_NVLINK_THROUGHPUT_BYTES_PER_SECOND | Mo/s vers o/s |
DCGM_FI_DEV_UNCORRECTABLE_REMAPPED_ROWS | DCGM_FI_DEV_ROW_REMAP_UNCORRECTABLE_TOTAL | aucun |
DCGM_FI_DEV_ROW_REMAP_FAILURE | DCGM_FI_DEV_ROW_REMAP_FAILED | aucun |
DCGM_FI_DEV_PCIE_REPLAY_COUNTER | DCGM_FI_DEV_PCIE_REPLAY_TOTAL | aucun |
DCGM_FI_PROF_GR_ENGINE_ACTIVE | DCGM_FI_PROF_GR_ENGINE_UTIL_RATIO | aucun (ratio) |
DCGM_FI_PROF_PIPE_TENSOR_ACTIVE | DCGM_FI_PROF_TENSOR_UTIL_RATIO | aucun (ratio) |
DCGM_FI_PROF_DRAM_ACTIVE | DCGM_FI_PROF_DRAM_UTIL_RATIO | aucun (ratio) |
L'étiquette de version du pilote change également, de DCGM_FI_DRIVER_VERSION à DCGM_FI_SYSTEM_DRIVER_VERSION. Lisez la liste de contrôle de mise à niveau de NVIDIA avant de mettre à niveau. Pendant un déploiement avec des versions mixtes, nous faisons le lien entre les deux au moyen de recording rules, afin que les tableaux de bord n'interrogent jamais que les noms ws: :
groups:
- name: dcgm-bridge
rules:
- record: ws:gpu_util:ratio
expr: DCGM_FI_DEV_GPU_UTIL_RATIO or (DCGM_FI_DEV_GPU_UTIL / 100)
- record: ws:gpu_fb_used:bytes
expr: DCGM_FI_DEV_FB_USED_BYTES or (DCGM_FI_DEV_FB_USED * 1048576)
- record: ws:gpu_power:watts
expr: DCGM_FI_DEV_BOARD_POWER_WATTS or DCGM_FI_DEV_POWER_USAGE
Tous les exemples de la suite de cet article utilisent les noms de la version 4.9.0.
Quelle métrique GPU signifie « occupé » ?
DCGM_FI_DEV_GPU_UTIL_RATIO indique seulement qu'un kernel s'exécutait pendant l'échantillon ; un GPU qui attend le réseau au sein d'une opération collective peut quand même afficher une valeur proche de 1. Pour les rapports d'efficacité, nous utilisons les champs de profilage : DCGM_FI_PROF_GR_ENGINE_UTIL_RATIO et DCGM_FI_PROF_TENSOR_UTIL_RATIO. Ils nécessitent le module de profilage de DCGM et peuvent entrer en conflit avec d'autres profileurs, comme Nsight Compute, sur le même GPU : nous suspendons donc la collecte des métriques de profilage lorsque les ingénieurs effectuent un profilage manuel.
Étiquettes de jobs et de pods
Sur Kubernetes, dcgm-exporter ajoute les étiquettes namespace, pod et container de la charge de travail qui utilise chaque GPU. Sur Slurm, son association des jobs HPC lit un répertoire de fichiers par GPU qu'un prolog Slurm écrit et que l'epilog vide, et ajoute une étiquette hpc_job. La version 4.9.0 renforce ce mécanisme (elle rejette les liens symboliques dans le répertoire d'association et limite la taille des fichiers et des ID de jobs), et renomme toute étiquette de pod nommée hpc_job afin d'éviter les conflits.
NVLink et NVSwitch
Dans un système HGX ou DGX B300, les GPU communiquent en NVLink via NVSwitch. L'ensemble par défaut fournit le débit NVLink total par GPU ; les compteurs d'erreurs NVLink sont facultatifs et diffèrent selon la génération de GPU, c'est pourquoi nous activons les bons dans le CSV des compteurs : sur les systèmes Blackwell comme le B300, les compteurs de récupération (DCGM_FI_DEV_NVLINK_RECOVERY_EVENT_TOTAL, DCGM_FI_DEV_NVLINK_RECOVERY_SUCCESSFUL_TOTAL et DCGM_FI_DEV_NVLINK_RECOVERY_FAILED_TOTAL) ; sur Hopper, les compteurs de la couche liaison de données (DCGM_FI_DEV_NVLINK_CRC_ERROR_TOTAL, DCGM_FI_DEV_NVLINK_REPLAY_TOTAL, DCGM_FI_DEV_NVLINK_RECOVERY_TOTAL). Les anciens champs …_CRC_FLIT_ERROR_TOTAL et …_REPLAY_ERROR_TOTAL ne s'appliquent qu'aux GPU antérieurs à Hopper. Les systèmes NVL72 à l'échelle de la baie ajoutent entre les plateaux une fabric de switches NVLink dotée de son propre logiciel de gestion, que nous traitons comme une fabric distincte dans le schéma d'étiquetage.
6. DPU BlueField et Ethernet Spectrum-X
DOCA Telemetry Service (DTS) s'exécute sous forme de conteneur sur les DPU BlueField (et peut s'exécuter sur des hôtes équipés d'adaptateurs ConnectX). Il recueille les compteurs du DPU et de ses ports au moyen d'un ensemble de fournisseurs et les expose, entre autres options, sur un endpoint au format Prometheus. Nous collectons cet endpoint depuis le collecteur de la fabric à l'aide d'une liste de cibles dans un fichier contenant les adresses d'administration des DPU, et nous étiquetons chaque DPU avec l'hôte qu'il dessert.
NetQ est l'outil de supervision et de validation de NVIDIA pour les fabrics Ethernet construites sur Cumulus Linux et SONiC, y compris Spectrum-X. Il collecte l'état et les compteurs à partir d'agents installés sur les switches, conserve un historique qui permet de savoir ce qui a changé et quand, et valide la fabric par rapport à sa configuration prévue. Pour les fabrics d'IA basées sur RoCE, les compteurs les plus importants sont les pertes de paquets, les trames de pause PFC, les paquets marqués ECN et l'occupation des buffers. Il existe trois manières pratiques d'intégrer ces données dans la pile centrale, et nous choisissons site par site :
- conserver NetQ comme outil de l'équipe réseau et importer les synthèses et les événements depuis son API dans le stockage des journaux ;
- diffuser directement depuis les switches (gNMI, ou OTLP sur les versions récentes de Cumulus Linux ; consultez la documentation de votre version) vers les collecteurs passerelles ;
- se replier sur SNMP et syslog pour les switches plus anciens.
Les noms des compteurs diffèrent selon ces voies : nous les normalisons donc sous nos propres noms de recording rules (ws:eth_pfc_pause_rx:rate5m, ws:eth_ecn_marked:rate5m, ws:eth_drops:rate5m) et ne construisons les tableaux de bord que sur ceux-ci.
7. L'architecture de référence OpenTelemetry de Workstation
L'architecture comporte trois niveaux de Collector :
- Un agent sur chaque nœud GPU, de stockage et de connexion, exécuté comme service systemd ou comme DaemonSet Kubernetes. Il collecte les exporters locaux via l'interface loopback, suit les journaux locaux, reçoit l'OTLP des services locaux, ajoute les métadonnées de l'hôte et de Kubernetes, et transmet le tout aux passerelles. Il conserve une petite file d'attente persistante afin qu'un redémarrage de passerelle ne fasse rien perdre.
- Une paire de passerelles (ou davantage), derrière une IP virtuelle ou un nom DNS. Les passerelles appliquent la politique à l'échelle du parc : étiquettes, nettoyage des attributs, filtrage, échantillonnage des traces en fin de chaîne et routage vers les backends. Les identifiants des backends ne résident qu'ici.
- Un pipeline de fabric sur les hôtes des passerelles, qui collecte les endpoints UFM, DOCA et des switches et reçoit le syslog. Les deux passerelles l'exécutent ; les échantillons en double sont supprimés dans Mimir par son HA tracker (section 16).
Pourquoi ne pas laisser chaque nœud écrire directement dans les backends ? Parce que la passerelle est l'endroit où les changements de politique se font en une seule fois, où les secrets restent à l'écart de centaines de nœuds, et où une migration de backend (par exemple l'ajout d'Elasticsearch pour une équipe sécurité) se résume à un changement de configuration sur deux serveurs plutôt qu'à un déploiement sur tout le parc.
8. Configuration de l'agent Collector
Voici l'agent que nous déployons sur un nœud GPU Slurm, dont seuls les certificats propres au site ont été retirés. Il nécessite la distribution otelcol-contrib, ou un build personnalisé qui inclut les mêmes composants.
# /etc/otelcol-contrib/config.yaml (agent, one per node)
extensions:
health_check:
endpoint: 127.0.0.1:13133
file_storage:
directory: /var/lib/otelcol/queue
create_directory: true
receivers:
otlp:
protocols:
grpc:
endpoint: 127.0.0.1:4317
http:
endpoint: 127.0.0.1:4318
prometheus:
config:
scrape_configs:
- job_name: dcgm
scrape_interval: 15s
static_configs:
- targets: ["127.0.0.1:9400"]
- job_name: node
scrape_interval: 15s
static_configs:
- targets: ["127.0.0.1:9100"]
metric_relabel_configs:
# keep what the dashboards use; node-exporter's full output is large
- source_labels: [__name__]
regex: "node_(cpu_seconds_total|load1|load5|memory_.+|pressure_.+|filesystem_(avail|size)_bytes|disk_(read|written)_bytes_total|network_(receive|transmit)_(bytes|errs|drop)_total|infiniband_.+|hwmon_temp_celsius|nvme_.+|textfile_.+)"
action: keep
filelog:
include:
- /var/log/syslog
- /var/log/slurm/slurmd.log
- /var/log/slurm/ufm_slurm.log
include_file_path: true
start_at: end
storage: file_storage
processors:
memory_limiter:
check_interval: 1s
limit_percentage: 75
spike_limit_percentage: 20
resourcedetection:
detectors: [env, system]
system:
hostname_sources: [os]
resource/fleet:
attributes:
- key: site
value: ${env:WS_SITE}
action: upsert
- key: cluster
value: ${env:WS_CLUSTER}
action: upsert
- key: rack
value: ${env:WS_RACK}
action: upsert
- key: node_role
value: ${env:WS_NODE_ROLE}
action: upsert
batch:
send_batch_size: 8192
timeout: 5s
exporters:
otlp/gateway:
endpoint: otel-gateway.obs.internal:4317
tls:
ca_file: /etc/otelcol-contrib/ca.pem
sending_queue:
enabled: true
storage: file_storage
queue_size: 5000
retry_on_failure:
enabled: true
max_elapsed_time: 30m
# traces are routed by trace ID so every span of a trace reaches the same
# gateway, which tail sampling needs
loadbalancing/traces:
routing_key: traceID
protocol:
otlp:
tls:
ca_file: /etc/otelcol-contrib/ca.pem
resolver:
dns:
hostname: otel-gateway-pool.obs.internal
port: "4317"
service:
extensions: [health_check, file_storage]
pipelines:
metrics:
receivers: [otlp, prometheus]
processors: [memory_limiter, resourcedetection, resource/fleet, batch]
exporters: [otlp/gateway]
logs:
receivers: [otlp, filelog]
processors: [memory_limiter, resourcedetection, resource/fleet, batch]
exporters: [otlp/gateway]
traces:
receivers: [otlp]
processors: [memory_limiter, resourcedetection, resource/fleet, batch]
exporters: [loadbalancing/traces]
telemetry:
metrics:
level: detailed
readers:
- pull:
exporter:
prometheus:
host: 0.0.0.0
port: 8888
Sur les nœuds Kubernetes, nous ajoutons le processeur k8sattributes à l'agent (et non à la passerelle, car lorsque les données atteignent une passerelle, l'IP d'origine du pod a disparu) et le filtrons sur le nœud local :
processors:
k8sattributes:
auth_type: serviceAccount
filter:
node_from_env_var: K8S_NODE_NAME
extract:
metadata:
- k8s.namespace.name
- k8s.pod.name
- k8s.deployment.name
- k8s.node.name
labels:
- tag_name: tenant
key: workstation.co.uk/tenant
from: namespace
9. Configuration de la passerelle et des deux backends
La passerelle reçoit l'OTLP des agents, exécute les collectes de la fabric et le syslog, et exporte vers les deux backends. Il existe deux pipelines de métriques : l'un pour les données transmises par les agents (uniques, donc sans étiquette de réplica) et l'autre pour les collectes de la fabric qu'exécutent les deux passerelles (étiquetées avec le nom de réplica de la passerelle afin que Mimir n'en conserve qu'une copie).
# /etc/otelcol-contrib/config.yaml (gateway, two or more)
extensions:
health_check:
endpoint: 0.0.0.0:13133
file_storage:
directory: /var/lib/otelcol/queue
create_directory: true
basicauth/ufm:
client_auth:
username: ${env:UFM_MONITOR_USER}
password: ${env:UFM_MONITOR_PASSWORD}
basicauth/es:
client_auth:
username: ${env:ES_USER}
password: ${env:ES_PASSWORD}
receivers:
otlp:
protocols:
grpc:
endpoint: 0.0.0.0:4317
tls:
cert_file: /etc/otelcol-contrib/tls/gateway.crt
key_file: /etc/otelcol-contrib/tls/gateway.key
prometheus/fabric:
config:
scrape_configs:
- job_name: ufm-telemetry
scrape_interval: 60s
scrape_timeout: 50s
metrics_path: /labels/enterprise
static_configs:
- targets: ["ufm-vip.obs.internal:8982"]
metric_relabel_configs:
- source_labels: [__name__]
regex: "PortXmitDataExtended|PortRcvDataExtended|LinkDownedCounterExtended|LinkErrorRecoveryCounterExtended|LocalLinkIntegrityErrorsExtended|ExcessiveBufferOverrunErrorsExtended|Normalized_CBW|dev_temperature"
action: keep
- job_name: ufm-system
scrape_interval: 4m
scrape_timeout: 60s
scheme: https
metrics_path: /ufmRest/system_monitoring/metrics
basic_auth:
username: ${env:UFM_MONITOR_USER}
password: ${env:UFM_MONITOR_PASSWORD}
tls_config:
ca_file: /etc/otelcol-contrib/ufm-ca.pem
static_configs:
- targets: ["ufm-vip.obs.internal:443"]
metric_relabel_configs:
- source_labels: [__name__]
regex: "rest_api_response_time_histogram.*"
action: drop
- job_name: doca-telemetry
scrape_interval: 30s
file_sd_configs:
- files: ["/etc/otelcol-contrib/targets/dpu-*.yaml"]
syslog/fabric:
tcp:
listen_address: 0.0.0.0:5514
protocol: rfc5424
processors:
memory_limiter:
check_interval: 1s
limit_percentage: 75
spike_limit_percentage: 20
resource/fabric:
attributes:
- key: site
value: ${env:WS_SITE}
action: upsert
- key: cluster
value: ${env:WS_CLUSTER}
action: upsert
- key: fabric
value: ib-compute
action: upsert
transform/hygiene:
error_mode: ignore
metric_statements:
- context: datapoint
statements:
- delete_key(attributes, "pod_uid")
- delete_key(attributes, "container_id")
log_statements:
- context: log
statements:
- delete_key(attributes, "http.request.header.authorization")
tail_sampling:
decision_wait: 10s
num_traces: 100000
policies:
- name: keep-errors
type: status_code
status_code:
status_codes: [ERROR]
- name: keep-slow
type: latency
latency:
threshold_ms: 2000
- name: baseline
type: probabilistic
probabilistic:
sampling_percentage: 10
batch:
send_batch_size: 8192
timeout: 5s
exporters:
prometheusremotewrite/mimir:
endpoint: https://mimir.obs.internal/api/v1/push
headers:
X-Scope-OrgID: ${env:WS_TENANT}
resource_to_telemetry_conversion:
enabled: true
remote_write_queue:
enabled: true
queue_size: 20000
num_consumers: 8
retry_on_failure:
enabled: true
max_elapsed_time: 30m
prometheusremotewrite/mimir-ha:
endpoint: https://mimir.obs.internal/api/v1/push
headers:
X-Scope-OrgID: ${env:WS_TENANT}
external_labels:
replica: ${env:WS_GATEWAY_NAME}
resource_to_telemetry_conversion:
enabled: true
otlp/tempo:
endpoint: tempo-distributor.obs.internal:4317
tls:
ca_file: /etc/otelcol-contrib/ca.pem
sending_queue:
enabled: true
storage: file_storage
elasticsearch/logs:
endpoints:
- https://es-hot-1.obs.internal:9200
- https://es-hot-2.obs.internal:9200
logs_index: logs-ai.cluster-prod
# ECS field names, so existing Kibana views and detection rules keep working
mapping:
allowed_modes: [ecs]
auth:
authenticator: basicauth/es
tls:
ca_file: /etc/otelcol-contrib/es-ca.pem
service:
extensions: [health_check, file_storage, basicauth/ufm, basicauth/es]
pipelines:
metrics/forwarded:
receivers: [otlp]
processors: [memory_limiter, transform/hygiene, batch]
exporters: [prometheusremotewrite/mimir]
metrics/fabric:
receivers: [prometheus/fabric]
processors: [memory_limiter, resource/fabric, batch]
exporters: [prometheusremotewrite/mimir-ha]
logs:
receivers: [otlp, syslog/fabric]
processors: [memory_limiter, transform/hygiene, batch]
exporters: [elasticsearch/logs]
traces:
receivers: [otlp]
processors: [memory_limiter, tail_sampling, batch]
exporters: [otlp/tempo]
telemetry:
metrics:
level: detailed
readers:
- pull:
exporter:
prometheus:
host: 0.0.0.0
port: 8888
Remarques sur les choix :
- L'intervalle de collecte des compteurs de la fabric est de 60 secondes. Plus rapide aide rarement : l'échantillon UFM lui-même, la fenêtre d'alerte et le temps de réaction humain dominent le délai de détection (voir le schéma du flux de données ci-dessous), et ce sont les séries par port qui représentent le volume.
- La liste de conservation sur
ufm-telemetryest le levier de maîtrise des coûts le plus efficace de toute l'architecture. Commencez de manière restreinte ; ajoutez un compteur lorsqu'un tableau de bord ou une alerte en a besoin. resource_to_telemetry_conversiontransforme les attributs de ressource en étiquettes. C'est ce qui placesite,cluster,racketfabricsur chaque série, et c'est aussi ainsi que surviennent les accidents de cardinalité, raison pour laquelle les agents ne définissent que les attributs souhaités et le processeur d'hygiène supprime les fauteurs de troubles connus.- Loki en option. Lorsqu'un client préfère Grafana pour les journaux, ajoutez un exporter
otlphttp/lokipointant vers l'endpoint OTLP natif de Loki et envoyez-y les journaux à la place d'Elasticsearch, et non en plus. - Traces vers Elastic. Les clients ayant standardisé Elastic Observability peuvent envoyer les traces vers le point d'ingestion OTLP d'Elastic au lieu de Tempo ; le reste de l'architecture est inchangé.
10. Configuration de collecte Prometheus (si vous exploitez Prometheus)
Certains clients conservent une paire Prometheus en haute disponibilité par site, soit parce qu'ils en ont déjà une, soit pour maintenir l'alerting local en cas de défaillance du lien vers le stockage central. Les mêmes cibles, exprimées en configuration Prometheus standard, se présentent ainsi. L'étiquette externe replica est la seule différence entre les deux serveurs.
# prometheus.yml (replica "a"; replica "b" is identical except for the label)
global:
scrape_interval: 15s
evaluation_interval: 30s
external_labels:
site: lon2
cluster: ai-prod-1
replica: a
rule_files:
- /etc/prometheus/rules/*.yaml
scrape_configs:
- job_name: dcgm
file_sd_configs:
- files: ["/etc/prometheus/targets/gpu-nodes.yaml"]
relabel_configs:
- source_labels: [__address__]
regex: "([^:]+):.*"
target_label: node
replacement: "$1"
action: replace
- job_name: ufm-telemetry
scrape_interval: 60s
scrape_timeout: 50s
metrics_path: /labels/enterprise
static_configs:
- targets: ["ufm-vip.obs.internal:8982"]
labels:
fabric: ib-compute
metric_relabel_configs:
- source_labels: [__name__]
regex: "PortXmitDataExtended|PortRcvDataExtended|LinkDownedCounterExtended|LinkErrorRecoveryCounterExtended|LocalLinkIntegrityErrorsExtended|ExcessiveBufferOverrunErrorsExtended|Normalized_CBW|dev_temperature"
action: keep
- job_name: otel-collectors
file_sd_configs:
- files: ["/etc/prometheus/targets/otel-*.yaml"]
remote_write:
- url: https://mimir.obs.internal/api/v1/push
headers:
X-Scope-OrgID: ai-prod
queue_config:
max_samples_per_send: 5000
Les fichiers de cibles portent les étiquettes de baie et de rôle ; ils proviennent donc de la même source de vérité que les variables d'environnement des agents (notre inventaire), et ne sont jamais saisis à la main :
# /etc/prometheus/targets/gpu-nodes.yaml
- targets: ["gpu-r07-01:9400", "gpu-r07-02:9400", "gpu-r07-03:9400", "gpu-r07-04:9400"]
labels:
rack: r07
node_role: gpu
11. Schéma d'étiquetage à l'échelle du parc
Les étiquettes sont les jointures de l'observabilité. Si les métriques GPU indiquent host="gpu-r07-03.lon2" et les métriques de la fabric node="GPU-R07-03", aucune requête ne pourra jamais les relier. Nous fixons un schéma unique pour chaque client et chaque source :
| Étiquette | Exemple | Sur | Règle |
|---|---|---|---|
site | lon2 | tout | Centre de données ou salle ; défini par le collecteur |
cluster | ai-prod-1 | tout | Sert aussi d'étiquette de cluster HA pour Mimir |
env | prod | tout | prod, staging, lab |
fabric | ib-compute | métriques réseau | ib-compute, ib-storage, eth-frontend, eth-storage, nvlink |
rack | r07 | nœuds et switches | Issue de l'inventaire, jamais déduite des noms d'hôtes au moment de la requête |
node | gpu-r07-03 | métriques des nœuds | Nom d'hôte court, en minuscules ; nous réétiquetons le Hostname de DCGM pour qu'il corresponde |
rail | 3 | métriques GPU et cartes réseau | Numéro de rail dans les fabrics optimisées par rail ; égal à l'index du GPU sur la plupart des conceptions HGX |
gpu, UUID | 3, GPU-… | métriques GPU uniquement | Issues de dcgm-exporter ; l'UUID suit le GPU physique au fil des RMA |
switch, port | leaf-r07-a, 17 | métriques de la fabric | Normalisées à partir des étiquettes d'équipement et de port d'UFM lors du réétiquetage |
tenant | genomics | métriques des charges de travail | Issue des étiquettes de namespace Kubernetes ou du compte Slurm |
hpc_job | 4471823 | métriques GPU uniquement | Jamais sur les métriques de fabric ou de nœud (voir la cardinalité) |
Une fois ce schéma en place, la jointure entre jobs et fabric se fait par une paire de jointures PromQL au travers de nos deux métriques d'information, ws_job_node_info{hpc_job, node} (issue de l'exporter de l'ordonnanceur) et ws_ib_link_info{node, hca_port, switch, port} (issue de l'exporter des liens UFM) :
# link-error recoveries in the last hour on every switch port used by job 4471823
sum by (switch, port) (
increase(LinkErrorRecoveryCounterExtended[1h])
* on (switch, port) group_left (node)
(ws_ib_link_info * on (node) group_left () ws_job_node_info{hpc_job="4471823"})
)
12. Règles d'alerte
Ces règles s'exécutent dans le ruler de Mimir (ou dans Prometheus) et sont acheminées par Alertmanager. La sévérité page réveille quelqu'un ; ticket part dans la file d'attente. Les seuils sont des points de départ que nous ajustons site par site au cours du premier mois.
# rules/ai-cluster.yaml
groups:
- name: gpu
rules:
- alert: GPUXidErrorReported
expr: changes(DCGM_FI_DEV_XID_ERROR[10m]) > 0 and DCGM_FI_DEV_XID_ERROR != 0
labels:
severity: page
annotations:
summary: "XID error reported on {{ $labels.node }} GPU {{ $labels.gpu }}"
runbook: "https://runbooks.obs.internal/gpu/xid"
- alert: GPURowRemapFailed
expr: DCGM_FI_DEV_ROW_REMAP_FAILED > 0
labels:
severity: page
annotations:
summary: "Row remapping failed on {{ $labels.node }} GPU {{ $labels.gpu }}: drain and RMA"
- alert: GPUUncorrectableRowRemaps
expr: increase(DCGM_FI_DEV_ROW_REMAP_UNCORRECTABLE_TOTAL[1h]) > 0
labels:
severity: ticket
annotations:
summary: "New uncorrectable-error row remaps on {{ $labels.node }} GPU {{ $labels.gpu }}"
- alert: GPUTemperatureHigh
# set per platform: air-cooled and liquid-cooled systems differ
expr: max_over_time(DCGM_FI_DEV_GPU_TEMP_CELSIUS[10m]) > 85
for: 10m
labels:
severity: ticket
- alert: GPUPCIeReplays
expr: increase(DCGM_FI_DEV_PCIE_REPLAY_TOTAL[15m]) > 100
labels:
severity: ticket
- alert: GPUAllocatedButIdle
expr: avg by (cluster, hpc_job) (avg_over_time(DCGM_FI_DEV_GPU_UTIL_RATIO{hpc_job!=""}[30m])) < 0.05
for: 30m
labels:
severity: ticket
annotations:
summary: "Job {{ $labels.hpc_job }} has held GPUs for 30 minutes at under 5% utilisation"
- alert: DCGMExporterDown
expr: up{job="dcgm"} == 0
for: 5m
labels:
severity: page
- name: infiniband
rules:
- record: ws:ib_port_tx_bps:rate5m
expr: rate(PortXmitDataExtended[5m]) * 8
- record: ws:ib_port_rx_bps:rate5m
expr: rate(PortRcvDataExtended[5m]) * 8
- alert: IBLinkFlapping
expr: increase(LinkDownedCounterExtended[15m]) >= 2
labels:
severity: page
annotations:
summary: "Link flapping on {{ $labels.switch }} port {{ $labels.port }}"
- alert: IBLinkErrorRecovery
expr: increase(LinkErrorRecoveryCounterExtended[15m]) > 0
labels:
severity: ticket
annotations:
summary: "Link retrained after errors on {{ $labels.switch }} port {{ $labels.port }}: check cable and transceiver"
- alert: IBLinkIntegrityErrors
expr: increase(LocalLinkIntegrityErrorsExtended[15m]) > 0
labels:
severity: ticket
- alert: IBBufferOverruns
expr: increase(ExcessiveBufferOverrunErrorsExtended[15m]) > 0
labels:
severity: ticket
- alert: IBDeviceHot
# PDR's default maximum temperature is also 70 C
expr: dev_temperature > 70
for: 10m
labels:
severity: ticket
- alert: UFMTelemetryDown
expr: up{job="ufm-telemetry"} == 0
for: 5m
labels:
severity: page
- alert: UFMTelemetryMissing
expr: absent_over_time(PortXmitDataExtended{fabric="ib-compute"}[10m])
labels:
severity: page
- name: pipeline
rules:
- alert: CollectorExportFailing
expr: sum by (instance, exporter) (rate(otelcol_exporter_send_failed_metric_points_total[5m])) > 0
for: 10m
labels:
severity: page
- alert: CollectorQueueFilling
expr: max by (instance, exporter) (otelcol_exporter_queue_size / otelcol_exporter_queue_capacity) > 0.8
for: 10m
labels:
severity: ticket
- alert: GatewayRedundancyLost
expr: count(up{job="otel-gateway"} == 1) < 2
for: 5m
labels:
severity: page
- alert: ElasticsearchClusterRed
expr: max(elasticsearch_cluster_health_status{color="red"}) == 1
for: 2m
labels:
severity: page
- alert: Watchdog
# always firing; an external dead man's switch pages if it stops arriving
expr: vector(1)
labels:
severity: heartbeat
Deux règles empiriques. Premièrement, chaque astreinte renvoie à un runbook qui indique quoi faire dans les dix premières minutes. Deuxièmement, les alertes déclenchées sur des compteurs avec increase() nécessitent une fenêtre d'au moins quatre fois l'intervalle de collecte, sinon une seule collecte manquée masque l'événement ; c'est pourquoi les fenêtres de la fabric sont de 15 minutes pour des collectes à 60 secondes.
13. Journaux et événements dans la suite Elastic
Les événements UFM, le syslog des switches, les décisions de PDR, les journaux de Slurm et d'UFM-Slurm ainsi que les journaux des hôtes sont envoyés vers Elasticsearch. Les journaux des nœuds arrivent par le pipeline Collector ci-dessus. Les flux propres à UFM arrivent par ses plugins basés sur Fluentd, que nous terminons sur un agrégateur Fluentd (ou Logstash) à côté des passerelles.
Fluentd : flux d'événements et de télémétrie UFM vers Elasticsearch
Les plugins EFS (streaming syslog) et TFS (télémétrie) envoient leurs données selon le protocole forward de Fluentd. Cet agrégateur reçoit les deux, ajoute les étiquettes du parc et écrit dans des data streams avec un buffer sur disque, afin qu'une panne d'Elasticsearch ne fasse perdre aucun événement. Il utilise la sortie fluent-plugin-elasticsearch.
# /etc/fluent/fluentd.conf (aggregator next to the gateways)
<source>
@type forward
port 24224
bind 0.0.0.0
</source>
<filter **>
@type record_transformer
<record>
site lon2
cluster ai-prod-1
fabric ib-compute
</record>
</filter>
<match **>
@type elasticsearch_data_stream
data_stream_name logs-ufm.events-prod
hosts https://es-hot-1.obs.internal:9200,https://es-hot-2.obs.internal:9200
user "#{ENV['ES_USER']}"
password "#{ENV['ES_PASSWORD']}"
ca_file /etc/fluent/es-ca.pem
<buffer>
@type file
path /var/lib/fluentd/buffer/es
flush_interval 10s
chunk_limit_size 8MB
total_limit_size 4GB
retry_max_interval 60s
retry_forever true
</buffer>
</match>
En pratique, nous le scindons en deux blocs <match> sur les tags que les deux plugins sont configurés pour envoyer, afin que les événements et la télémétrie aboutissent dans des data streams distincts avec des durées de conservation différentes. Envoyer les compteurs de télémétrie par port vers Elasticsearch n'a d'intérêt que lorsqu'Elastic est l'unique stockage de métriques du client ; sinon, les compteurs vont dans Mimir et Elasticsearch reçoit les événements.
Logstash : syslog des switches
Pour les sites disposant déjà d'une couche Logstash, le syslog des switches et d'UFM peut y aboutir au lieu du récepteur syslog du Collector :
# /etc/logstash/conf.d/fabric-syslog.conf
input {
syslog {
port => 5514
}
}
filter {
if [message] =~ /(?i)link (down|up)|transceiver|module (inserted|removed)/ {
mutate { add_tag => ["fabric_link_event"] }
}
mutate {
add_field => {
"site" => "lon2"
"cluster" => "ai-prod-1"
}
}
}
output {
elasticsearch {
hosts => ["https://es-hot-1.obs.internal:9200", "https://es-hot-2.obs.internal:9200"]
data_stream => "true"
data_stream_type => "logs"
data_stream_dataset => "network.switch"
data_stream_namespace => "prod"
user => "${ES_USER}"
password => "${ES_PASSWORD}"
ssl_certificate_authorities => ["/etc/logstash/es-ca.pem"]
}
}
Conservation avec la gestion du cycle de vie des index
PUT _ilm/policy/ai-cluster-logs
{
"policy": {
"phases": {
"hot": { "actions": { "rollover": { "max_age": "1d", "max_primary_shard_size": "50gb" } } },
"warm": { "min_age": "7d", "actions": { "forcemerge": { "max_num_segments": 1 } } },
"cold": { "min_age": "30d", "actions": { "set_priority": { "priority": 0 } } },
"delete": { "min_age": "90d", "actions": { "delete": {} } }
}
}
}
Les flux pertinents pour la sécurité (audit d'UFM, authentification) nécessitent généralement une conservation supérieure à 90 jours ; attribuez-leur leur propre data stream et leur propre politique plutôt que d'allonger la durée pour tout.
Requêtes Kibana (KQL) utiles à enregistrer comme vues :
data_stream.dataset : "network.switch" and tags : "fabric_link_event" and host.name : leaf-r07-*
data_stream.dataset : "ufm.events" and message : (*isolat* or *deisolat*)
data_stream.dataset : "ufm.events" and log.level : ("critical" or "error") and not message : *test*
14. Traçage des services d'inférence et d'entraînement d'IA
Les métriques vous indiquent que le délai avant le premier token a augmenté ; les traces vous disent où le temps a été passé. Pour une requête d'inférence, les spans utiles sont la requête, le tokeniseur, l'appel au serveur de modèles, ainsi que la mise en file d'attente, le prefill et le decode du serveur de modèles lui-même. Les serveurs de modèles récents (notamment vLLM, Triton et NVIDIA NIM) peuvent émettre eux-mêmes des traces OpenTelemetry lorsqu'on leur fournit un endpoint OTLP ; vérifiez les options de votre version. Côté application, cela se présente ainsi, en utilisant les noms d'attributs des conventions sémantiques GenAI d'OpenTelemetry :
from opentelemetry import trace
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
provider = TracerProvider(resource=Resource.create({
"service.name": "chat-gateway",
"deployment.environment.name": "prod",
"cluster": "ai-prod-1",
}))
# the local Collector agent; it adds node and rack labels
provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter(endpoint="http://127.0.0.1:4317", insecure=True)))
trace.set_tracer_provider(provider)
tracer = trace.get_tracer("ws.inference")
def handle_chat(req, tokenizer, model_client):
with tracer.start_as_current_span("chat.completions", kind=trace.SpanKind.SERVER) as span:
span.set_attribute("gen_ai.operation.name", "chat")
span.set_attribute("gen_ai.request.model", req.model)
with tracer.start_as_current_span("tokenize") as s:
ids = tokenizer.encode(req.prompt)
s.set_attribute("gen_ai.usage.input_tokens", len(ids))
# the client propagates the W3C traceparent header, so the model
# server's own spans (queue, prefill, decode) join this trace
with tracer.start_as_current_span("model_server.generate", kind=trace.SpanKind.CLIENT) as s:
out = model_client.generate(ids, max_tokens=req.max_tokens)
s.set_attribute("gen_ai.usage.output_tokens", out.output_tokens)
s.set_attribute("server.address", out.server)
if out.gpu_uuid: # if the server reports which GPU served the request
s.set_attribute("ws.gpu.uuid", out.gpu_uuid)
with tracer.start_as_current_span("detokenize"):
return tokenizer.decode(out.token_ids)
Le GPU lui-même n'émet pas de spans. Nous relions la trace au matériel par les attributs de ressource qu'ajoute l'agent (node, rack) et, lorsque le serveur le signale, par l'UUID du GPU, puis nous utilisons les liens trace-vers-métriques de Grafana pour passer d'un span lent aux panneaux DCGM de ce GPU et aux ports de fabric de ce nœud pour la même minute. Les histogrammes de latence des requêtes portent des exemplars, de sorte qu'un pic sur un panneau de latence renvoie directement à un exemple de trace.
Pour l'entraînement, un span par étape serait beaucoup trop. Nous traçons les phases grossières (démarrage du job, chargement des données, chaque sauvegarde et restauration de checkpoint, évaluation) et enregistrons le temps par étape sous forme de métrique d'histogramme avec l'étiquette du job. Une hausse soudaine du temps par étape avec une utilisation GPU stable et une hausse des récupérations d'erreurs de lien sur les ports du job est la signature classique d'une panne de fabric, et la jointure entre jobs et fabric de la section 11 permet de trouver le port.
15. Cardinalité et conservation
La cardinalité, c'est-à-dire le nombre de combinaisons distinctes d'étiquettes, détermine la consommation de mémoire, le stockage et le coût des requêtes. Les clusters d'IA se comportent bien si l'on y prête une attention délibérée. Un exemple chiffré pour un cluster de 32 nœuds et 256 GPU doté d'une fabric de calcul InfiniBand optimisée par rail (environ 1 000 ports en comptant les extrémités côté hôte et côté switch) :
| Source | Séries | Intervalle | Échantillons par seconde |
|---|---|---|---|
| Compteurs de fabric UFM, 8 compteurs conservés × ~1 000 ports | ~8 000 | 60 s | ~135 |
| Idem, si chaque compteur d'un ensemble de compteurs de débogage est diffusé (~100) | ~100 000 | 60 s | ~1 670 |
| DCGM, ~27 champs par défaut × 256 GPU | ~6 900 | 15 s | ~460 |
| node-exporter après la liste de conservation, ~300 × 40 nœuds | ~12 000 | 15 s | ~800 |
| Collecteurs, exporters, système UFM, services | ~5 000 | 15–60 s | ~200 |
| Total (compteurs conservés) | ~32 000 | ~1 600 |
À environ 1,5 octet par échantillon compressé, 1 600 échantillons par seconde représentent environ 75 Go de stockage objet par an. C'est suffisamment faible pour que nous conservions les données brutes pendant 13 mois pour des clusters de cette taille ; la conservation dans Mimir se définit par tenant, si bien que les très grands parcs placent les recording rules à long terme dans un tenant distinct dont la conservation est plus longue que celle des données brutes.
Ce qui fait exploser les budgets, ce sont les étiquettes, pas les métriques :
- Des ID de jobs sur les séries de fabric ou de nœud. Un cluster Slurm chargé exécute des milliers de jobs par jour ; chaque nouvelle valeur crée de nouvelles séries. Gardez
hpc_jobuniquement sur les séries GPU, et faites la jointure viaws_job_node_info. - Des UID de pods, des ID de conteneurs, des ID de requêtes et des ID de traces en guise d'étiquettes. Supprimez-les dans la passerelle ; les ID de traces ont leur place dans les exemplars.
- Des compteurs par voie et par lien partout. Activez les compteurs d'erreurs NVLink par lien et les compteurs de fabric par voie pour le diagnostic, en les limitant aux nœuds examinés, et non par défaut.
- Des GUID bruts en plus des noms. Utilisez l'endpoint UFM étiqueté et conservez les noms ; une seule étiquette d'identité par objet suffit.
Les durées de conservation dont nous partons, et que nous ajustons pour chaque client :
| Données | Stockage | Conservation |
|---|---|---|
| Métriques (brutes) | Mimir | 13 mois pour des clusters allant jusqu'à quelques centaines de GPU |
| Métriques (locales, si Prometheus est utilisé) | Prometheus | 15 jours |
| Traces | Tempo | 14 jours, après échantillonnage en fin de chaîne (toutes les erreurs, toutes les requêtes lentes, 10 % du reste) |
| Journaux et événements de la fabric et des hôtes | Elasticsearch | hot 7 jours, warm jusqu'à 30, cold jusqu'à 90, puis suppression |
| Journaux d'audit et de sécurité | Elasticsearch | Selon la politique du client, souvent un an ou plus |
| Instantanés de topologie et rapports NDT | Elasticsearch ou stockage objet | Durée de vie du cluster |
16. Haute disponibilité de la pile d'observabilité
Une supervision qui tombe en panne en même temps que ce qu'elle supervise n'est que de la décoration. L'architecture répartit chaque composant avec état sur trois zones de défaillance (deux baies d'administration sur des arrivées électriques séparées et une petite troisième zone pour le quorum) :
- UFM : actif/passif sur les deux baies ; tout communique avec l'IP virtuelle. Les plugins sont chargés sur les deux nœuds.
- Passerelles Collector : au moins deux, toutes deux actives. Les agents utilisent le nom du pool et une file d'attente persistante : la perte d'une passerelle entraîne une nouvelle tentative, pas un trou dans les données. Les collectes de la fabric s'exécutent sur les deux et sont dédoublonnées dans Mimir.
- Mimir : réplication consciente des zones avec un facteur de réplication de 3, et le HA tracker pour les collectes de la fabric et les éventuelles paires Prometheus.
- Alertmanager : trois pairs en gossip pour que chaque notification ne parte qu'une fois, plus un dead man's switch externe alimenté par l'alerte
Watchdog. - Elasticsearch : trois nœuds éligibles maître (dont un à vote seul dans la zone de quorum), un réplica par shard, la prise en compte de l'allocation des shards sur l'attribut de zone, et des instantanés vers le stockage objet.
- Grafana et Kibana : deux instances chacun, sans état, derrière un équilibreur de charge ; Grafana utilise une base de données partagée, et tous deux sont provisionnés depuis Git, de sorte qu'une reconstruction se résume à un déploiement.
La configuration qui compte, dans Mimir :
# mimir.yaml (excerpt)
distributor:
ha_tracker:
enable_ha_tracker: true
kvstore:
store: etcd
etcd:
endpoints: ["etcd-1.obs.internal:2379", "etcd-2.obs.internal:2379", "etcd-3.obs.internal:2379"]
limits:
accept_ha_samples: true
ha_cluster_label: cluster
ha_replica_label: replica
compactor_blocks_retention_period: 395d
ingester:
ring:
replication_factor: 3
zone_awareness_enabled: true
# set per instance: zone-a, zone-b or zone-c
instance_availability_zone: zone-a
Et dans Elasticsearch, pour chaque nœud :
# elasticsearch.yml (zone A hot node; the zone C node uses node.roles: [ master, voting_only ])
cluster.name: obs-ai-prod
node.roles: [ master, data_hot, data_content, ingest ]
node.attr.zone: a
cluster.routing.allocation.awareness.attributes: zone
discovery.seed_hosts: [ "es-hot-1.obs.internal", "es-hot-2.obs.internal", "es-quorum-1.obs.internal" ]
La supervision de la supervision fonctionne hors bande : un petit Prometheus séparé (ou un contrôle hébergé) surveille les passerelles, Mimir, la santé d'Elasticsearch et le dead man's switch, afin que la perte totale de la pile principale soit elle-même détectée.
17. Prouver que cela fonctionne : exercices de panne lors de la remise
Nous ne remettons pas un tableau de bord que nous n'avons pas vu passer au rouge. Pour chaque nouveau cluster, nous exécutons et consignons les exercices suivants :
- Débrancher un câble entre un leaf et un spine pendant un job de test : l'alerte d'instabilité de lien déclenche une astreinte dans la fenêtre attendue, UFM génère un événement, l'événement figure dans Kibana, et la vue jobs-fabric montre quel job traversait ce port.
- Mettre en panne le serveur UFM actif : le serveur passif reprend l'IP virtuelle, les collectes reprennent, et le trou dans les données de la fabric est plus court que la fenêtre d'alerte.
- Arrêter une passerelle : aucune perte de données, une astreinte
GatewayRedundancyLost, et un rétablissement à son retour. - Arrêter un nœud Elasticsearch et une zone Mimir : les requêtes obtiennent toujours une réponse, les écritures se poursuivent, les alertes de santé se déclenchent.
- Exécuter PDR en mode simulation sur un câble volontairement limite raccordé à un port de laboratoire : la décision « isolerait » apparaît dans le stockage des journaux.
- Comparer le câblage réalisé avec la conception à l'aide du plugin NDT et joindre le rapport au dossier de remise.
18. Comment Workstation livre et exploite ce dispositif
Workstation est partenaire de NVIDIA : en plus du matériel, nous fournissons l'ingénierie, les logiciels et le personnel pour mettre en place et exploiter des centres de données d'IA de bout en bout : conception, installation, mise en service de la fabric, mise en place d'UFM et de l'observabilité, et les ingénieurs qui l'exploitent ensuite avec vous. La présentation d'UFM par NVIDIA se trouve sur la page officielle NVIDIA Unified Fabric Manager (UFM).
- Fourniture : systèmes GPU, switches InfiniBand et Ethernet, adaptateurs, optiques et licences UFM, spécifiés ensemble.
- Construction : haute disponibilité d'UFM, plugins, intégration Slurm ou Kubernetes, DCGM et dcgm-exporter, agents et passerelles Collector, et nos backends hébergés ou les vôtres, le tout à partir d'une configuration versionnée.
- Exploitation : observabilité gérée 24 h/24 : réglage des alertes, mises à niveau (y compris des migrations comme les renommages de dcgm-exporter 4.9.0), planification de la capacité de la pile de supervision, et rapport mensuel sur l'efficacité des GPU, les pannes de fabric et le coût par heure GPU utile.
Pour un échange sur le dimensionnement, interrogez notre ingénieur commercial IA ou parcourez les gammes réseau et DGX de la boutique.
19. Sources et notes de vérification
- Présentation et niveaux de NVIDIA UFM : la page officielle NVIDIA Unified Fabric Manager (UFM).
- Plugins du SDK UFM, ports, chemins, noms de compteurs et valeurs par défaut de PDR : les README et tableaux de bord de Mellanox/ufm_sdk_3.0, consultés en novembre 2026. Le comportement des plugins change d'une version à l'autre ; consultez le README de la version que vous déployez.
- Noms des métriques de dcgm-exporter et renommages de la version 4.9.0 :
etc/default-counters.csvet les notes de version 4.9.0 dans NVIDIA/dcgm-exporter. - Les composants d'OpenTelemetry Collector proviennent de la distribution contrib ; les clés de configuration évoluent d'une version à l'autre, validez donc avec
otelcol-contrib validate --config=...avant de déployer. - Le découpage des niveaux d'UFM, NetQ et DOCA Telemetry Service sont décrits de manière générale ; consultez la documentation actuelle de NVIDIA pour connaître les fonctionnalités exactes et les licences de vos versions.
- Les noms de compteurs préfixés par
ws:ouws_sont des conventions de Workstation (recording rules et métriques d'information), et non des métriques NVIDIA.
Mention des droits : NVIDIA, le logo NVIDIA, DGX, HGX, Quantum, Spectrum, Spectrum-X, BlueField, ConnectX, NVLink, DOCA, DCGM et Unified Fabric Manager (UFM) sont des marques commerciales et/ou des marques déposées de NVIDIA Corporation aux États-Unis et dans d'autres pays. Les produits et technologies NVIDIA peuvent être couverts par des brevets et d'autres droits de propriété intellectuelle détenus par NVIDIA Corporation, et tous ces droits sont reconnus et réservés à leurs titulaires. Les informations sur les produits sont résumées avec nos propres mots à partir de la documentation publique de NVIDIA ; le site web et la documentation de NVIDIA font foi. Les autres noms de sociétés et de produits, notamment Prometheus, Grafana, Elasticsearch, Kibana, Logstash, OpenTelemetry, Kubernetes et Slurm, peuvent être des marques commerciales de leurs propriétaires respectifs. Les tableaux de bord, configurations et textes propres à Workstation sont © Workstation.