La boutique est ouverte

Nous construisons les machines Workstation AI pour les sites web, les agents IA et l'entraînement de LLM — configurez-les et achetez-les en ligne.

Obtenir les prix pro
Produits IA
Labs IAAgents OpenAIAgents ClaudeGrok BotCRM natif Workstation AIMarketingTous les produits
Solutions IA
IA appliquéeAgents IAIA générativeAutomatisation par IAMontée en compétence IAOffres IA pour PMELaboratoire IA d'entrepriseStations de travail IAMatériel et logiciels NVIDIACalcul accéléré NVIDIAIA privéeCloud privé GPUClusters GPUIA en périphérieIA par secteur
Services IA
Modernisation des plateformesIngénierie numériqueFondations data et IAOpérations autonomesConseil IAAutomatisation DevOpsCybersécuritéDéveloppement logicielCréation d'agentsMise en place MLOpsLocation de GPUCloud privé GPU
À propos
EntrepriseNotre histoirePartenairesTémoignages clients
Centres de données IA
Centres de données IACloud privé GPUClusters GPULocation de GPU
Analyses IASérie JevLabo de benchmarksChoix de modèles
Notes techniques
Documentation
OS LinuxUbuntuRed Hat Enterprise LinuxSUSE LinuxAlpine LinuxDebian, Rocky & AlmaLinux
Plateformes cloud d'IAAWS & Amazon BedrockGoogle Cloud & Vertex AIMicrosoft Azure & AI FoundryClouds et places de marché GPU
Centres de données IA privésPour les cabinets d'avocatsPour les cabinets comptablesPlateformes sur siteCloud entièrement sécurisé
OutilsRing PromoterJobshout
Actualités
Blog
Nous contacterSe connecter

Stations de travail IA, logiciels multi-agents IA, infrastructure GPU et solutions d'agents intelligents pour les entreprises modernes.

Nous contacter

Solutions IA

IA appliquéeAgents IAIA générativeAutomatisation par IAMontée en compétence IAOffres IA pour PMELaboratoire IA d'entrepriseIA par secteur

Produits

Tous les produitsCRM & ERP natifs Workstation AIMarketingAgents OpenAIRing PromoterJobshout

Entreprise

À proposEntrepriseCentres de données IAPourquoi WorkstationPartenairesTémoignages clientsTarifsContactTenthMatrix

Ressources

Analyses IANotes techniquesDocumentationOS LinuxPlateformes cloud d'IACentres de données IA privésBlogRechercherPlan du site
Siège social au Royaume-Uni
77-79 Marlowes, Hemel Hempstead HP1 1LFItinéraire : prenez la sortie 20 de la M25, Outer LondonN° d'entreprise: 11641870Lun - Ven : 9h00 - 18h00 GMT
+44 7515 356 146
Bureau de Belgique
Workstation SRL, Rue Vanderkindere 34, 1180 Uccle, BrusselsBE 0751.518.683Lun - Ven : 9h00 - 18h00 CET
+32 492 45 67 46
Bureau de l'Inde
#159 Sector 9, Pocket 1, DDA Flats, 110077 Dwarka, New Delhi
+91 98881 98841
Bureau de Taïwan
3F, No. 2-4, Aisi Rd., Ren'ai Dist., Keelung City 200, Taiwan基隆市仁愛區愛四路2之4號3樓Lun - Ven : 9 h 00 - 18 h 00, heure de Taïwan (GMT+8)
+886 926 892 701+32 492 45 67 46
Bureau en Estonie
Aleksander Puškini tn 30-25, 20306 Narva, EstoniaLun - Ven : 9 h 00 - 18 h 00, heure d’Estonie (EET)
+32 492 45 67 46

© 2026 Workstation AI. Tous droits réservés.

ConfidentialitéSuppression des donnéesCookiesConditions d'utilisationPlan du site web

NVIDIA, le logo NVIDIA, RTX, RTX PRO, Blackwell, CUDA, NVLink, MGX, Omniverse, Spectrum-X, Quantum, BlueField, DGX et HGX sont des marques commerciales et/ou des marques déposées de NVIDIA Corporation aux États-Unis et dans d'autres pays. AMD, le logo AMD Arrow, EPYC, Instinct, Ryzen et Threadripper sont des marques commerciales d'Advanced Micro Devices, Inc. Dell et PowerEdge sont des marques commerciales de Dell Inc. ou de ses filiales. Intel et Xeon sont des marques commerciales d'Intel Corporation ou de ses filiales. AMAX, AceleMax et LiquidMax sont des marques commerciales d'AMAX Engineering Corporation. Tous les autres noms de produits, logos et marques appartiennent à leurs propriétaires respectifs. Nous les utilisons uniquement pour identifier les produits que nous décrivons, fournissons ou prenons en charge ; leur utilisation ne signifie pas que leurs propriétaires nous cautionnent.

Accueil / Notes techniques / Technology
AIHardwareObservability

Observabilité NVIDIA avec OpenTelemetry : plugins du SDK UFM, DCGM, DOCA et NetQ vers Mimir, Grafana et la suite Elastic

Tous les plugins du SDK UFM, la télémétrie et les endpoints REST d'UFM, les renommages de métriques de dcgm-exporter 4.9.0, une architecture OpenTelemetry agents et passerelles avec configuration validée, des règles d'alerte, l'étiquetage, la cardinalité, le traçage de l'inférence et une pile d'observabilité hautement disponible

9 novembre 2026Technology42 min read

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.

La télémétrie des GPU, des switches InfiniBand et Ethernet, des DPU BlueField et des services d'IA transite par des OpenTelemetry Collectors vers Prometheus, Mimir et Grafana, ainsi que vers Elasticsearch et Kibana.

Synthèse. Collectez chaque signal une seule fois, aussi près de sa source que cela a du sens, étiquetez-le selon un schéma unique pour tout le parc, et diffusez-le vers les backends que les équipes utilisent déjà. Les compteurs GPU proviennent de DCGM, les compteurs et événements de la fabric InfiniBand d'UFM, les données de la fabric Ethernet de NetQ ou des switches, les compteurs des DPU de DOCA Telemetry Service, et les traces des requêtes des services d'IA via le SDK OpenTelemetry. Les OpenTelemetry Collectors se chargent de l'étiquetage, du filtrage, de l'échantillonnage et du routage. Les métriques et les traces vont dans Mimir et Tempo, les journaux et les événements dans Elasticsearch, et l'ensemble du pipeline est lui-même supervisé et hautement disponible.

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.

CouchePannes typiquesSource NVIDIAComment nous la collectons
GPU et NVLinkErreurs XID, événements ECC et de remappage de lignes, bridage thermique ou électrique, erreurs NVLink, GPU inactifs dans des jobs en coursDCGM (moteur hôte) et dcgm-exporterCollecte Prometheus sur le nœud par l'agent Collector
Fabric InfiniBand de calcul et de stockageInstabilité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 managerUFM Telemetry et UFM Enterprise (événements, alarmes, topologie, API REST), plugins SDKCollecte 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 EVPNNetQ ; télémétrie en streaming des switchesAPI NetQ ou streaming gNMI ou OTLP des switches vers la passerelle
DPU BlueFieldCompteurs de ports et de délestage, santé des DPUDOCA Telemetry ServiceCollecte de son endpoint au format Prometheus
Hôtes et clients de stockagePression 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 orchestrationJobs 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'IADé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 :

CompteurCe qu'il vous apprend
PortXmitDataExtended, PortRcvDataExtendedDonné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)
LinkDownedCounterExtendedNombre de fois où le lien est tombé : le signal d'instabilité de lien
LinkErrorRecoveryCounterExtendedNombre de fois où le lien s'est renégocié pour se remettre d'erreurs : souvent le premier signe d'un câble limite
LocalLinkIntegrityErrorsExtendedErreurs physiques locales dépassant le seuil d'intégrité
ExcessiveBufferOverrunErrorsExtendedDépassements de buffer consécutifs sur le port
Normalized_CBWUn indicateur de bande passante de congestion exposé par UFM ; le tableau de bord de NVIDIA en trace le maximum par niveau de topologie
dev_temperatureTempé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.

PluginCe qu'il faitSa place
grafana_infiniband_telemetry_pluginSert 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_pluginDes 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_pluginUn 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_pluginAnalyse 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_pluginExtrait 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_pluginDes 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-IntegrationDes 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_pluginProblem 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_PluginComparaison 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_pluginS'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_pluginUn 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_pluginAnalyse 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_pluginConnecte 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ètreValeur par défautSignification
INTERVAL300 sFréquence à laquelle les compteurs de télémétrie sont demandés
MAX_NUM_ISOLATE10Nombre 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_TMAX70 °C / 10Température maximale et hausse maximale de température
MAX_PDR1e-12Taux maximal de perte de paquets
CONFIGURED_BER_CHECK, CONFIGURED_TEMP_CHECK, LINK_DOWN_ISOLATIONTrueLes contrôles qui peuvent déclencher une isolation
SWITCH_TO_HOST_ISOLATIONTrueSi les liens d'accès vers les hôtes peuvent être isolés
DRY_RUNFalseJournaliser les décisions au lieu d'agir
DEISOLATE_CONSIDER_TIME5 minDurée pendant laquelle un port doit paraître sain avant d'être remis en service
MAX_PORT_RESET_NUM2 par semaineNombre 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 :

  1. L'activer avec DRY_RUN=True pendant deux à quatre semaines et envoyer son journal vers Elasticsearch. Chaque ligne « isolerait » devient un ticket que nous examinons au regard des compteurs UFM.
  2. 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.
  3. Passer à l'isolation réelle, en décidant de SWITCH_TO_HOST_ISOLATION site par site : isoler un lien d'hôte retire ce nœud des jobs, ce qui est parfois souhaitable et parfois non.
  4. 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.xNom en 4.9.0Changement d'unité
DCGM_FI_DEV_GPU_UTILDCGM_FI_DEV_GPU_UTIL_RATIO% vers 0–1
DCGM_FI_DEV_FB_USEDDCGM_FI_DEV_FB_USED_BYTESMio vers octets
DCGM_FI_DEV_GPU_TEMPDCGM_FI_DEV_GPU_TEMP_CELSIUSaucun
DCGM_FI_DEV_POWER_USAGEDCGM_FI_DEV_BOARD_POWER_WATTSaucun
DCGM_FI_DEV_TOTAL_ENERGY_CONSUMPTIONDCGM_FI_DEV_GPU_ENERGY_JOULES_TOTALmJ vers J
DCGM_FI_DEV_XID_ERRORSDCGM_FI_DEV_XID_ERRORaucun (dernière valeur XID)
DCGM_FI_DEV_NVLINK_BANDWIDTH_TOTALDCGM_FI_DEV_NVLINK_THROUGHPUT_BYTES_PER_SECONDMo/s vers o/s
DCGM_FI_DEV_UNCORRECTABLE_REMAPPED_ROWSDCGM_FI_DEV_ROW_REMAP_UNCORRECTABLE_TOTALaucun
DCGM_FI_DEV_ROW_REMAP_FAILUREDCGM_FI_DEV_ROW_REMAP_FAILEDaucun
DCGM_FI_DEV_PCIE_REPLAY_COUNTERDCGM_FI_DEV_PCIE_REPLAY_TOTALaucun
DCGM_FI_PROF_GR_ENGINE_ACTIVEDCGM_FI_PROF_GR_ENGINE_UTIL_RATIOaucun (ratio)
DCGM_FI_PROF_PIPE_TENSOR_ACTIVEDCGM_FI_PROF_TENSOR_UTIL_RATIOaucun (ratio)
DCGM_FI_PROF_DRAM_ACTIVEDCGM_FI_PROF_DRAM_UTIL_RATIOaucun (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

Architecture de référence : les nœuds GPU exécutent dcgm-exporter, node-exporter et un agent OpenTelemetry Collector ; les endpoints UFM, NetQ et DOCA sont collectés par un collecteur de fabric ; une paire de collecteurs passerelles ajoute des étiquettes, filtre et échantillonne, puis exporte vers Mimir, Tempo, Grafana et Alertmanager ainsi que vers Logstash, Elasticsearch et Kibana.

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-telemetry est 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_conversion transforme les attributs de ressource en étiquettes. C'est ce qui place site, cluster, rack et fabric sur 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/loki pointant 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

Flux de données : un compteur GPU lu par DCGM, un compteur d'adaptateur réseau lu par node-exporter ou DOCA, et un compteur de port de switch lu par UFM Telemetry sont collectés, étiquetés avec le site, le cluster, la fabric, la baie, le nœud et le rail, stockés dans Mimir ou Elasticsearch, et utilisés dans Grafana, Kibana et les règles d'alerte.

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 :

ÉtiquetteExempleSurRègle
sitelon2toutCentre de données ou salle ; défini par le collecteur
clusterai-prod-1toutSert aussi d'étiquette de cluster HA pour Mimir
envprodtoutprod, staging, lab
fabricib-computemétriques réseauib-compute, ib-storage, eth-frontend, eth-storage, nvlink
rackr07nœuds et switchesIssue de l'inventaire, jamais déduite des noms d'hôtes au moment de la requête
nodegpu-r07-03métriques des nœudsNom d'hôte court, en minuscules ; nous réétiquetons le Hostname de DCGM pour qu'il corresponde
rail3métriques GPU et cartes réseauNuméro de rail dans les fabrics optimisées par rail ; égal à l'index du GPU sur la plupart des conceptions HGX
gpu, UUID3, GPU-…métriques GPU uniquementIssues de dcgm-exporter ; l'UUID suit le GPU physique au fil des RMA
switch, portleaf-r07-a, 17métriques de la fabricNormalisées à partir des étiquettes d'équipement et de port d'UFM lors du réétiquetage
tenantgenomicsmétriques des charges de travailIssue des étiquettes de namespace Kubernetes ou du compte Slurm
hpc_job4471823métriques GPU uniquementJamais 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) :

SourceSériesIntervalleÉchantillons par seconde
Compteurs de fabric UFM, 8 compteurs conservés × ~1 000 ports~8 00060 s~135
Idem, si chaque compteur d'un ensemble de compteurs de débogage est diffusé (~100)~100 00060 s~1 670
DCGM, ~27 champs par défaut × 256 GPU~6 90015 s~460
node-exporter après la liste de conservation, ~300 × 40 nœuds~12 00015 s~800
Collecteurs, exporters, système UFM, services~5 00015–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_job uniquement sur les séries GPU, et faites la jointure via ws_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éesStockageConservation
Métriques (brutes)Mimir13 mois pour des clusters allant jusqu'à quelques centaines de GPU
Métriques (locales, si Prometheus est utilisé)Prometheus15 jours
TracesTempo14 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ôtesElasticsearchhot 7 jours, warm jusqu'à 30, cold jusqu'à 90, puis suppression
Journaux d'audit et de sécuritéElasticsearchSelon la politique du client, souvent un an ou plus
Instantanés de topologie et rapports NDTElasticsearch ou stockage objetDurée de vie du cluster

16. Haute disponibilité de la pile d'observabilité

Topologie de haute disponibilité : deux baies d'administration sur des arrivées électriques séparées contiennent chacune un serveur UFM d'une paire actif/passif, un collecteur passerelle, un réplica Prometheus, une zone Mimir, un pair Alertmanager, Grafana, un nœud Elasticsearch éligible maître, Logstash et Kibana ; une troisième zone de quorum contient la troisième zone Mimir, un pair Alertmanager et un maître Elasticsearch à vote seul ; le stockage objet contient les blocs Mimir et les instantanés.

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 :

  1. 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.
  2. 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.
  3. Arrêter une passerelle : aucune perte de données, une astreinte GatewayRedundancyLost, et un rétablissement à son retour.
  4. 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.
  5. 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.
  6. 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.csv et 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: ou ws_ 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.

Partager cet article

Plus dans Technology

Portables pour développeurs IA : exécuter des LLM en local sous Linux avec des GPU de 16 GB et 24 GB (guide 2026)

Portables pour développeurs IA : exécuter des LLM en local sous Linux avec des GPU de 16 GB et 24 GB (guide 2026)

Ce qui tient sur un GPU RTX 5080 ou RTX 5090 Laptop, le calcul de mémoire, les modèles ouverts qui valent la peine, la configuration d'Ubuntu 26.04 avec la pile NVIDIA, Ollama, llama.cpp et vLLM, les assistants de code, l'affinage LoRA, la sécurité, et quand passer le travail sur un serveur

Lire la suite
Tester des systèmes ML et LLM impossibles à prouver corrects : une boîte à outils Python d'éléments probants

Tester des systèmes ML et LLM impossibles à prouver corrects : une boîte à outils Python d'éléments probants

Des éléments probants à la place des preuves, en environ 400 lignes de Python avec une sortie réelle : métriques par segment avec intervalles bootstrap et contrat de réussite ou d'échec, tests de propriétés et métamorphiques avec Hypothesis, calibration et prédiction conforme, contrats Pydantic et évaluations de non-régression pour les sorties LLM, contrôles de dérive, barrière en CI et vérification exacte d'un petit réseau de neurones

Lire la suite
TorchCurves en pratique : courbes B-spline et de Legendre apprenables dans PyTorch

TorchCurves en pratique : courbes B-spline et de Legendre apprenables dans PyTorch

Installer torchcurves, ajuster et dimensionner une courbe, choisir entre B-spline et Legendre ainsi que l’application d’entrée, construire une courbe de calibration monotone et un modèle additif sur des données tabulaires, comparer avec SciPy, scikit-learn, un KAN et un MLP, exporter les coefficients en JSON, tester et exploiter en production, avec des sorties réelles

Lire la suite