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
Bureau de Belgique
Workstation SRL, Rue Vanderkindere 34, 1180 Uccle, BrusselsBE 0751.518.683Lun - Ven : 9h00 - 18h00 CET
+32 492 45 67 46
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 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

NVIDIA Minerva AIOps en pratique : architecture, télémétrie, agents sûrs, remédiation avec Ansible et déploiement par phases

Flux de données et couches de télémétrie, corrélation tenant compte de la topologie, garde-fous pour Sherlock et MCP, remédiation en boucle fermée sous contrôle des changements, trois architectures de référence, configurations OpenTelemetry, Prometheus, Alertmanager et Ansible validées, RGPD britannique, haute disponibilité et dimensionnement des collecteurs, et runbook de déploiement

9 novembre 2026Technology36 min read

Un guide pratique pour déployer NVIDIA Minerva, la plateforme AIOps de NVIDIA pour les usines d'IA, et l'intégrer à un parc d'exploitation existant. Il couvre l'architecture et le flux de données, les sources de télémétrie couche par couche, la manière dont une corrélation tenant compte de la topologie transforme une avalanche d'événements en un seul incident, l'usage sûr de l'assistant Sherlock et du serveur MCP, la remédiation en boucle fermée avec Ansible sous contrôle des changements, les trois modèles de consommation sous forme d'architectures de référence, l'intégration avec Prometheus, Grafana, la suite Elastic, ServiceNow et PagerDuty, le choix entre sur site et SaaS et le RGPD britannique, la haute disponibilité et le dimensionnement de la couche de collecte, un runbook de déploiement par phases et les exercices de panne que nous menons à la remise. L'argumentaire économique se trouve dans l'article de blog associé.

Version interactive : parcourez dix-sept exemples de tableaux de bord pour un déploiement de Minerva, chacun avec ses signaux et ses recommandations d'alerte.

Cinq couches de télémétrie, calcul, scale-up NVLink, scale-out Spectrum-X, jobs et installations, alimentent la collecte, un graphe de connaissances de la topologie et la corrélation par ML, qui transmettent des incidents aux personnes, aux agents et à la remédiation derrière une barrière d'approbation.

Synthèse. Minerva collecte la télémétrie de toutes les couches d'une usine d'IA au moyen de standards ouverts, tient à jour un graphe dynamique des liens entre le matériel, les fabrics et les jobs, apprend des références de comportement par apprentissage automatique, et utilise le graphe pour regrouper les alertes liées en un seul incident, avec une cause probable et un rayon d'impact. Autour de lui, nous ne déployons que des composants ouverts et vérifiables : une paire d'OpenTelemetry Collectors pour les sources et les backends dont le client dispose déjà, dcgm-exporter et les métadonnées Slurm, des règles Prometheus et Alertmanager pour la supervision de la supervision, et des playbooks Ansible qui ne s'exécutent que derrière une barrière d'approbation. Les endpoints, schémas et paramètres côté Minerva sont configurés conformément à la documentation de Minerva de NVIDIA ; cet article ne les invente pas.
Périmètre et note d'honnêteté. Cet article a été rédigé à partir de la page produit publique et de la fiche technique de Minerva publiées par NVIDIA, et non à partir de sa documentation technique. Nous ne décrivons donc le fonctionnement interne, les API et la configuration propres à Minerva qu'au niveau publié par NVIDIA, et nous ne montrons ni fichiers de configuration de Minerva, ni commandes CLI, ni noms de métriques, ni prix. Chaque bloc de configuration ci-dessous concerne un composant ouvert gravitant autour de Minerva et a été validé avec les outils propres à ce composant ; voir la section 15, Sources et notes de vérification.

1. Ce qu'est Minerva, d'après la description de NVIDIA

NVIDIA a annoncé Minerva en octobre 2026. La page officielle NVIDIA Minerva et la fiche technique de Minerva font foi. Résumés avec nos propres mots, les faits publiés autour desquels nous concevons sont les suivants :

SujetCe qu'indique NVIDIA (paraphrasé)Ce que cela implique pour la conception
PositionnementUne plateforme AIOps de bout en bout conçue autour de l'IA, et le principal produit d'observabilité pour les usines d'IA NVIDIA, y compris les systèmes Vera Rubin et Blackwell.La considérer comme le cerveau de gestion des incidents du parc GPU, et non comme un tableau de bord de plus.
Périmètre de télémétrieGPU, switches NVLink, Ethernet Spectrum-X, SuperNIC, DPU, NCCL, ordonnanceurs comme Slurm et Run:ai, stockage et charges de travail d'IA.Planifier la collecte couche par couche ; voir la section 3.
Standards d'ingestionOpenTelemetry, gNMI, syslog, DCGM, Slurm et JSON.Les pipelines OpenTelemetry existants peuvent y transmettre ; les switches diffusent en gNMI.
AnalytiqueUn graphe de connaissances dynamique tenant compte de la topologie ; un ML qui apprend le comportement normal sur des milliards de points de données par heure ; une analyse automatisée des causes profondes lorsque des jobs traînent ou échouent ; une réduction du bruit qui fusionne les avalanches d'événements en un seul incident.Lui fournir une topologie et des métadonnées de jobs exactes, puis une période d'apprentissage des références avant d'activer les astreintes.
InteractionSherlock, un assistant multi-agents pour le tri en langage naturel sur la télémétrie en direct, et un serveur MCP permettant l'intégration des agents des clients.Encadrer l'accès des agents comme toute API à privilèges ; voir la section 6.
ActionRecommandations de remédiation et remédiation en boucle fermée ; intégrations avec Slack, Microsoft Teams, ServiceNow, PagerDuty, Ansible, Grafana et des API d'infrastructure.Passer par le contrôle des changements ; voir la section 7.
InstallationsLe Minerva Collector fait partie de NVIDIA DSX OS, offrant une vue du GPU jusqu'au réseau électrique avec corrélation des signaux des installations.Intégrer l'alimentation et le refroidissement dans la même chronologie d'incident.
DéploiementSur site ou en SaaS depuis le cloud de NVIDIA ; passe à l'échelle de centaines de milliers de GPU ; souveraineté des données préservée ; API ouvertes, fonctionnalités modulaires et intégration Grafana.Choisir tôt le modèle d'hébergement ; voir la section 10.
ConsommationDIY Observability, AIOps with DIY Observability et Turnkey.Trois architectures de référence ; voir la section 8.
RésultatsExprimés en heures GPU, goodput, disponibilité, MTBI, MTTR et production de tokens.Rendre compte des mêmes indicateurs clés dès le premier jour.

Minerva et UFM

Notre note technique sur UFM, DCGM et OpenTelemetry traite de NVIDIA Unified Fabric Manager, qui gère et supervise les fabrics InfiniBand. La documentation de NVIDIA sur Minerva cite Ethernet Spectrum-X (scale-out, scale-across et scale-in) et NVLink (scale-up) comme périmètre réseau et ne décrit pas, dans ce que nous avons lu, l'ingestion d'InfiniBand. Sur un site mixte, nous conservons UFM comme gestionnaire de la fabric InfiniBand et confirmons avec NVIDIA, pour la version déployée, comment les événements et la télémétrie d'UFM doivent parvenir à Minerva. En attendant cette confirmation, la couche OpenTelemetry de la section 9 peut acheminer les données d'UFM vers les backends existants du client, exactement comme dans la note technique sur UFM.

2. Architecture et flux de données

Architecture de référence : les sources issues des nœuds GPU, des plateaux de switches NVLink, des switches Spectrum-X, des SuperNIC et DPU, de NCCL et des charges de travail, des ordonnanceurs, du stockage et des installations alimentent le Minerva Collector et une paire optionnelle d'OpenTelemetry Collectors ; la plateforme AIOps Minerva contient le graphe de connaissances, la détection d'anomalies par ML, la corrélation, l'analyse des causes profondes, Sherlock, le serveur MCP et les tableaux de bord ; les consommateurs comprennent Grafana, Slack et Teams, PagerDuty et ServiceNow, les agents des clients, Ansible derrière une approbation et la suite Elastic.

Nous considérons un déploiement de Minerva comme quatre plans. Les garder séparés permet de raisonner facilement sur les responsabilités, la sécurité et les modes de défaillance.

  1. Plan de collecte. Le Minerva Collector, plus notre paire optionnelle d'OpenTelemetry Collectors pour tout ce que le client collecte déjà ou doit aussi envoyer ailleurs. Son rôle est de récupérer chaque signal une seule fois à la source, d'y ajouter une identité cohérente (site, cluster, baie, nœud, rail, job), de mettre en mémoire tampon pendant les interruptions et de transmettre.
  2. Plan analytique. Minerva lui-même : le graphe de connaissances, les références, la détection d'anomalies, la corrélation, l'analyse des causes profondes et le stockage des incidents. Sur site, il s'exécute sur une infrastructure que nous dimensionnons avec NVIDIA ; en SaaS, il s'exécute dans le cloud de NVIDIA.
  3. Plan d'interaction. L'interface et les tableaux de bord de Minerva, Sherlock, le serveur MCP pour les agents des clients, et Grafana lorsque le client conserve ses propres vues.
  4. Plan d'action. Les notifications (Slack, Teams), les astreintes et les tickets (PagerDuty, ServiceNow) et l'automatisation (Ansible). Tout ce qui se trouve ici est régi par le processus de gestion des changements du client.

Le parcours d'un signal est le suivant : la source, puis le collecteur (étiquetage et mise en mémoire tampon), puis le plan analytique (rattachement à un nœud du graphe, comparaison avec sa référence), puis un incident (regroupement avec les anomalies liées), puis les personnes et les agents (notifiés une seule fois, avec le contexte), et éventuellement une action approuvée, dont le résultat revient sous forme de télémétrie afin que l'incident puisse être vérifié et clos.

3. Sources de télémétrie, couche par couche

Le tableau liste chaque couche, ce qui peut y mal tourner, le standard d'ingestion cité par NVIDIA et les composants ouverts que nous déployons ou vérifions autour. Lorsque nous indiquons « Minerva Collector », l'activation de cette source se configure conformément à la documentation de Minerva de NVIDIA.

CouchePannes typiquesVoie d'ingestion citée par NVIDIAComposants ouverts que nous déployons ou vérifions
GPU (calcul)Erreurs XID, événements ECC et de remappage de lignes, bridage thermique ou électrique, GPU inactifs dans des jobs en coursDCGMMoteur hôte DCGM ; dcgm-exporter lorsque le site conserve aussi des copies dans Prometheus
Scale-up NVLinkÉvénements de récupération de liens, liens dégradés dans un domaine NVL72, pannes de plateaux de switchesMinerva Collector (switches NVLink)Compteurs NVLink par GPU de DCGM comme contrôle croisé
Ethernet Spectrum-XPertes de paquets, tempêtes de pauses PFC, marquage ECN, pression sur les buffers, liens instables, optiques en surchauffeStreaming gNMI, syslogAbonnements gNMI des switches et transfert syslog ; notre récepteur syslog pour les stockages existants
SuperNIC et DPUÉvénements de contrôle de congestion, retransmissions, erreurs de port, santé des DPUMinerva CollectorBlueField DOCA Telemetry Service lorsqu'il est déjà déployé
NCCLOpérations collectives lentes ou bloquées, un rang en retard sur les autresMinerva Collector (télémétrie NCCL)Journaux des jobs avec la sortie de débogage NCCL capturée dans le stockage des journaux
OrdonnanceursJobs en échec ou bloqués, nœuds drainés, GPU alloués mais inactifsSlurm ; Run:aiProlog et epilog Slurm pour l'association des jobs dans dcgm-exporter ; métadonnées Kubernetes
StockageRalentissement des écritures de checkpoints, latence des métadonnées, erreurs côté clientOpenTelemetry, JSON, syslogL'exporter du fournisseur de stockage, transmis via nos passerelles
Charges de travailHausse du temps par étape, hausse du délai avant le premier token, baisse du débit de tokensOpenTelemetrySDK OpenTelemetry dans les serveurs de modèles et les frameworks d'entraînement
InstallationsPlafonnement de puissance, écarts de température ou de débit du liquide de refroidissement, pannes de PDUMinerva Collector dans DSX OSIntégration à la gestion technique du bâtiment, configurée conformément à la documentation de DSX OS de NVIDIA

GPU : DCGM et dcgm-exporter

DCGM est le service de santé et de télémétrie des GPU que NVIDIA cite comme source de Minerva. Lorsqu'un client conserve également les métriques GPU dans son propre Prometheus, nous exécutons aussi dcgm-exporter. Notez que dcgm-exporter 4.9.0 a renommé ses métriques par défaut et modifié plusieurs unités (l'utilisation est devenue un ratio de 0 à 1, la mémoire est passée en octets) ; le tableau complet et un ensemble de recording rules de transition figurent dans notre note technique sur UFM et DCGM. Toutes les requêtes PromQL de cet article utilisent les noms de la version 4.9.0.

Switches Spectrum-X : gNMI et syslog

gNMI est le protocole gRPC d'OpenConfig pour le streaming de télémétrie depuis les équipements réseau. De manière générale, nous nous abonnons aux compteurs d'interface en mode échantillonné à intervalle fixe, et à l'état opérationnel (lien actif ou inactif, alarmes des transceivers) en mode sur changement, ce qui limite la charge tout en rendant les changements d'état immédiats. Les chemins auxquels Minerva s'abonne, et le fait qu'il se connecte aux switches ou que ceux-ci se connectent à lui, se définissent selon la documentation de NVIDIA et le guide du système d'exploitation des switches ; nous nous assurons seulement que le réseau d'administration, les certificats et les listes d'accès le permettent. Le syslog de chaque switch est également envoyé au collecteur, car les instabilités de liens et les alarmes des transceivers y apparaissent souvent en premier.

Ordonnanceurs : Slurm et Run:ai

La corrélation ne vaut que ce que vaut la correspondance entre jobs et matériel. Pour Slurm, nous vérifions que les métadonnées de job, d'utilisateur, de partition et de liste de nœuds parviennent à Minerva comme le documente NVIDIA, et nous utilisons le prolog et l'epilog de Slurm pour maintenir l'association des jobs HPC dans dcgm-exporter, afin que les séries GPU portent une étiquette hpc_job dans le Prometheus du client. Pour Run:ai et Kubernetes, nous vérifions que les noms des charges de travail et des projets sont bien transmis. Les noms d'utilisateurs sont des données personnelles ; voir la section 10 pour la manière dont nous les pseudonymisons lorsqu'ils quittent le site.

Charges de travail : SDK OpenTelemetry

Les serveurs de modèles et les frameworks d'entraînement instrumentés avec le SDK OpenTelemetry envoient des traces et des métriques en OTLP à la paire de passerelles, qui les transmet à Minerva et, si le client le souhaite, à son propre stockage de traces. Les signaux les plus importants sont le temps par étape et l'attente du chargeur de données pour l'entraînement, et le temps d'attente en file, le délai avant le premier token et le nombre de tokens par seconde pour l'inférence.

4. Le graphe de connaissances et la corrélation tenant compte de la topologie

NVIDIA n'a pas publié les algorithmes internes de Minerva dans la documentation que nous avons consultée ; cette section explique donc l'idée en termes généraux, ce dont les exploitants ont besoin pour bien l'alimenter.

Un graphe de connaissances est ici un modèle vivant du parc : des entités (GPU, plateaux de switches NVLink, nœuds, cartes réseau, ports de switch, switches, baies, arrivées électriques, cibles de stockage, jobs, locataires) et les relations qui les unissent (ce GPU se trouve dans ce nœud ; ce port de carte réseau est câblé à ce port de leaf ; ce job s'exécute sur ces 72 GPU ; cette baie est alimentée par cette arrivée électrique). Les relations évoluent dans le temps, notamment le placement des jobs ; chacune possède donc une plage temporelle.

La corrélation fonctionne alors à peu près ainsi :

  1. Les anomalies sont rattachées à des entités. Une hausse des corrections FEC appartient à un port de switch ; un all-reduce lent appartient à un job ; une baisse d'utilisation appartient à un GPU.
  2. Les anomalies proches dans le temps sont examinées pour trouver un chemin commun dans le graphe. Si les GPU du job lent accèdent tous à la fabric via des cartes réseau câblées à un même leaf, et que ce leaf présente un port qui se dégrade, ce port est une cause profonde candidate et tout ce qui se trouve en aval est un symptôme.
  3. Les candidats sont classés. La position en amont, la précocité du début de l'anomalie, l'ampleur de l'écart par rapport à la référence et le nombre de symptômes qu'elle explique entrent tous en ligne de compte.
  4. Le rayon d'impact est calculé en parcourant le graphe vers l'aval : quels jobs, locataires et GPU dépendent à cet instant du composant suspecté.

Deux conséquences pratiques en découlent. Premièrement, l'exactitude de la topologie est une condition préalable : un port non câblé ou mal étiqueté dans l'inventaire produit de fausses causes profondes. Nous validons le plan de câblage par rapport à LLDP et à la vue propre des switches avant l'apprentissage des références. Deuxièmement, les métadonnées des jobs doivent arriver à temps : si le placement des jobs arrive avec plusieurs minutes de retard, les symptômes ne peuvent pas être rattachés au job qu'ils affectent.

5. Réduction du bruit et cycle de vie des incidents

Exemple de corrélation d'incident : une seule optique défaillante sur leaf-07 provoque des alertes de switch, de SuperNIC, de NCCL, de GPU et d'ordonnanceur, environ 4 800 en 20 minutes ; le parcours du graphe identifie leaf-07 comme nœud amont commun ; un seul incident de priorité 2 indique la cause profonde, un rayon d'impact de 3 jobs et 288 GPU, les éléments probants et une action suggérée ; le cycle de vie va de la détection à la corrélation, la notification, le tri, l'approbation et la remédiation, puis la vérification et la clôture.

Dans une grande fabric d'IA, une seule panne physique peut déclencher des milliers d'alertes, car chaque GPU, carte réseau et job qui en dépend signale son propre symptôme. NVIDIA décrit Minerva comme regroupant ces alertes en un seul incident priorisé et contextualisé, transmis à des outils tels que Slack ou ServiceNow. Notre travail consiste à adapter ce flux d'incidents au modèle d'exploitation du client :

ÉtapeCe qui se passeCe que nous configurons autour
DétecterAnomalie par rapport à la référence apprise, ou dépassement d'un seuil strictPériode d'apprentissage des références sans astreinte (section 12)
CorrélerAnomalies liées regroupées par topologie et par tempsTopologie et métadonnées de jobs exactes (section 4)
NotifierUn message par incident, mis à jour au fil de son évolutionRoutage par locataire et par sévérité vers Slack ou Teams, PagerDuty et ServiceNow
TrierL'ingénieur examine la cause et le rayon d'impact, et peut interroger SherlockLiens vers les runbooks par type d'incident ; accès des agents en lecture seule
Approuver et remédierL'action suggérée est approuvée et exécutéeEnregistrement de changement, barrière d'approbation, job Ansible (section 7)
Vérifier et cloreLes signaux reviennent à leur référence ; l'incident est résoluRésolution automatique dans ServiceNow et PagerDuty ; revue post-incident

Éviter les doubles astreintes

Lorsque Minerva gère la corrélation, les alertes existantes du client par symptôme pour le même matériel ne doivent pas déclencher d'astreinte en plus. Notre règle empirique : dans les modèles AIOps et Turnkey, les alertes Prometheus existantes sur les symptômes des GPU, des cartes réseau et des switches passent en sévérité ticket (ou sont inhibées), et seules les alertes concernant la supervision elle-même, comme les pannes des collecteurs et de l'ingestion, conservent la sévérité page. Pour ServiceNow et PagerDuty, vérifiez que l'identifiant d'incident envoyé par Minerva sert de clé de dédoublonnage, afin que les mises à jour d'un incident n'ouvrent jamais un second ticket ; la manière dont Minerva renseigne ce champ se configure conformément à la documentation de NVIDIA.

6. Sherlock et MCP : utiliser les agents en toute sécurité

Sherlock est l'assistant multi-agents de Minerva pour le tri en langage naturel, et le serveur MCP permet aux agents du client d'interroger Minerva. Tous deux sont puissants parce qu'ils voient l'ensemble du parc. Nous les traitons comme des interfaces à privilèges et leur appliquons les mêmes contrôles qu'à tout compte d'automatisation :

  • Lecture seule par défaut. Les agents commencent avec un accès limité à l'interrogation de la télémétrie, des incidents et de la topologie. Aucune identité d'agent ne détient de droits de modification de l'infrastructure dans la première phase d'un déploiement.
  • Identités séparées. Chaque agent ou intégration utilise sa propre identité de service avec son propre périmètre, jamais un compte administrateur partagé, afin que les actions soient attribuables et révocables.
  • Barrières d'approbation pour tout ce qui modifie un état. Un agent peut proposer un drainage, l'arrêt d'un port ou un redémarrage ; une personne nommément désignée l'approuve, et l'exécution passe par l'automatisation soumise au contrôle des changements de la section 7, et non par les propres identifiants de l'agent.
  • Traiter la télémétrie comme une entrée non fiable. Les noms de jobs, les lignes de journaux et les noms d'hôtes peuvent contenir du texte écrit par des utilisateurs. Un agent qui les lit peut être manipulé par des instructions qui y ont été placées. Les agents ne doivent pas exécuter d'actions sur la foi d'un texte trouvé dans la télémétrie, et les permissions des outils doivent être appliquées côté serveur, pas par le prompt.
  • Journaliser chaque conversation et chaque appel d'outil dans le stockage d'audit, avec l'identité, la question, les outils utilisés et la réponse. Examinez un échantillon chaque semaine au cours des premiers mois.
  • Tenir les secrets hors du contexte. Les identifiants n'apparaissent jamais dans les prompts, les réponses ou les sorties d'outils ; limitez le périmètre des outils MCP pour qu'ils ne puissent pas les renvoyer.
  • Limites de débit et budgets. Plafonnez le nombre de requêtes qu'un agent peut effectuer par minute, afin qu'un agent qui tourne en boucle ne puisse pas surcharger la plateforme.
Classe d'actionExemplesQui peut la déclencherApprobation
LecturePoser une question sur un incident, lister les jobs à la traîne, afficher le chemin d'un job dans la fabricSherlock, clients MCP, ingénieursAucune ; journalisée
AnnotationAjouter une note à un incident, lier un ticketSherlock, clients MCP disposant du périmètre d'écriture de notesAucune ; journalisée
Changement opérationnel réversibleDrainer un nœud dans Slurm, déplacer un job à son prochain checkpoint, arrêter un port instableIngénieur, ou agent à titre de propositionApprobateur nommément désigné ; enregistrement de changement standard
Changement perturbateurRedémarrer des nœuds, reflasher un firmware, modifier la configuration de la fabricIngénieur uniquementChangement normal avec approbation du CAB et fenêtre de maintenance

7. Remédiation en boucle fermée avec Ansible et contrôle des changements

NVIDIA décrit Minerva comme recommandant des correctifs et bouclant la boucle grâce à des intégrations, notamment Ansible. Nous introduisons l'automatisation en trois niveaux, et un client ne passe au niveau supérieur que lorsque le précédent affiche un historique irréprochable :

  1. Suggérer. L'incident comporte une action recommandée et un lien vers le runbook ; une personne effectue le travail.
  2. Approuver pour exécuter. L'action recommandée correspond à un playbook Ansible prérédigé dans le contrôleur d'automatisation (AWX ou Red Hat Ansible Automation Platform). Une étape d'approbation dans le workflow, liée à un changement standard ServiceNow, permet à un approbateur désigné de l'exécuter en un clic.
  3. Changements standard pré-approuvés. Une courte liste d'actions réversibles et à faible risque, comme le drainage d'un nœud présentant des erreurs XID répétées, s'exécute sans clic humain, toujours dans le cadre d'un modèle de changement standard et toujours journalisée. Les actions perturbatrices n'atteignent jamais ce niveau.

La manière dont Minerva transmet une action au contrôleur d'automatisation (webhook, appel d'API ou déclencheur ServiceNow) se configure conformément à la documentation de Minerva de NVIDIA. Le playbook lui-même est le nôtre et se veut délibérément défensif : il refuse de s'exécuter sans référence de changement et d'incident, draine plutôt que de tuer, attend la fin des jobs en cours, lance un diagnostic DCGM et laisse le nœud drainé pour qu'un ingénieur le remette en service.

# playbooks/drain-gpu-node.yml
# Runs only from the automation controller, only with an approved change record.
# Usage: ansible-playbook drain-gpu-node.yml -l gpu-r09-02 \
#          -e change_id=CHG0041234 -e incident_id=INC-2193 -e approved_by=ops-lead
- name: Drain a GPU node and run DCGM diagnostics
  hosts: gpu_nodes
  serial: 1
  gather_facts: false
  vars:
    drain_wait_minutes: 60
  tasks:
    - name: Refuse to run without an approved change and incident reference
      ansible.builtin.assert:
        that:
          - change_id is defined and change_id is match('^CHG[0-9]+$')
          - incident_id is defined and incident_id | length > 0
          - approved_by is defined and approved_by | length > 0
        fail_msg: "change_id, incident_id and approved_by are required"

    - name: Drain the node in Slurm so no new jobs land on it
      ansible.builtin.command:
        argv:
          - scontrol
          - update
          - "nodename={{ inventory_hostname }}"
          - state=drain
          - "reason={{ incident_id }} {{ change_id }} via automation"
      delegate_to: "{{ groups['slurm_controllers'][0] }}"
      changed_when: true

    - name: Wait for running jobs on the node to finish
      ansible.builtin.command:
        argv: [squeue, --noheader, --nodelist, "{{ inventory_hostname }}", --format, "%i"]
      delegate_to: "{{ groups['slurm_controllers'][0] }}"
      register: jobs_left
      until: jobs_left.stdout | trim | length == 0
      retries: "{{ drain_wait_minutes }}"
      delay: 60
      changed_when: false

    - name: Run DCGM diagnostics (level 2, a few minutes)
      ansible.builtin.command:
        argv: [dcgmi, diag, -r, "2"]
      become: true
      register: diag
      changed_when: false
      failed_when: false

    - name: Record the result for the change and incident
      ansible.builtin.debug:
        msg: "{{ inventory_hostname }} diag rc={{ diag.rc }}; node stays drained until an engineer resumes it"

Chaque playbook de la bibliothèque dispose d'un retour arrière correspondant (ici, scontrol update nodename=... state=resume après la vérification de l'ingénieur), d'un mode simulation testé en laboratoire et d'un responsable. Le journal du job du contrôleur d'automatisation est automatiquement joint à l'enregistrement de changement.

8. Les trois modèles de consommation comme architectures de référence

DIY ObservabilityAIOps with DIY ObservabilityTurnkey
CollecteMinerva CollectorMinerva CollectorMinerva Collector
Stockage et tableaux de bordPrometheus ou Mimir et Grafana du clientGrafana du client ; alimenté par les analyses de MinervaTableaux de bord propres à Minerva ; Grafana facultatif
Détection d'anomalies et corrélationRègles propres au clientMinervaMinerva
Assistant et agentsAucun fourni par MinervaAnalyses transmises aux outils agentiques du clientSherlock plus MCP
IncidentsAlertmanager vers Slack et PagerDutyMinerva vers ServiceNow et PagerDutyMinerva vers ServiceNow, PagerDuty, Slack ou Teams
Notre paire OpenTelemetryGénéralement oui, pour l'étiquetage et la diffusion multipleOui, pour les sources et backends existantsUniquement pour les sources non NVIDIA
Client typeÉquipe SRE mature, cluster uniqueGrande entreprise dotée d'une chaîne d'outils établieUsine d'IA ou neocloud

DIY Observability. Le collecteur alimente le stockage compatible Prometheus du client. Nous déployons les règles Prometheus et les routes Alertmanager de la section 9, les tableaux de bord Grafana de la galerie associée et le schéma d'étiquetage de la note technique sur UFM. Le client gère la corrélation ; Minerva lui fournit des données cohérentes et alignées sur NVIDIA.

AIOps with DIY Observability. Comme ci-dessus, avec en plus l'analytique de Minerva. Le travail de conception porte sur le dédoublonnage (section 5), le routage des incidents vers les bons groupes d'affectation ServiceNow, et l'affichage des analyses de Minerva à côté des panneaux Grafana existants afin que les ingénieurs n'aient pas à changer d'outil.

Turnkey. Minerva est la console d'exploitation principale. Nous conservons malgré tout un Prometheus minimal et indépendant qui surveille les collecteurs, l'ingestion de Minerva et le dead man's switch, car une plateforme de supervision ne doit pas être la seule à se surveiller elle-même.

9. Intégration avec Prometheus, Grafana, Elastic, ServiceNow et PagerDuty

La paire de passerelles OpenTelemetry

Lorsque le client dispose déjà de sources que le Minerva Collector ne couvre pas, ou doit conserver une copie dans ses propres backends, nous exécutons deux passerelles OpenTelemetry Collector par site derrière un même nom DNS. Cette configuration transmet à un point d'ingestion OTLP de Minerva ainsi qu'au Mimir et à l'Elasticsearch du client, étiquette tout avec le site et le cluster, supprime les attributs connus pour leur forte cardinalité ou leur caractère sensible, et pseudonymise les noms d'utilisateurs Slurm avant que les données ne quittent le site. L'endpoint otlp/minerva, son authentification et les signaux qu'il accepte sont des valeurs provisoires à configurer conformément à la documentation de Minerva de NVIDIA.

# /etc/otelcol-contrib/config.yaml  (Workstation gateway, two per site)
extensions:
  health_check:
    endpoint: 0.0.0.0:13133
  file_storage:
    directory: /var/lib/otelcol/queue
    create_directory: true

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

  # Only for nodes the Minerva Collector does not already cover, or when the
  # site keeps its own Prometheus copy of GPU metrics.
  prometheus/nodes:
    config:
      scrape_configs:
        - job_name: dcgm
          scrape_interval: 15s
          file_sd_configs:
            - files: ["/etc/otelcol-contrib/targets/dcgm-*.yaml"]
        - job_name: node
          scrape_interval: 30s
          file_sd_configs:
            - files: ["/etc/otelcol-contrib/targets/node-*.yaml"]
          metric_relabel_configs:
            - source_labels: [__name__]
              regex: "node_(load1|memory_MemAvailable_bytes|filesystem_(avail|size)_bytes|network_(receive|transmit)_(bytes|errs|drop)_total|hwmon_temp_celsius|textfile_.+)"
              action: keep

  syslog/switches:
    tcp:
      listen_address: 0.0.0.0:5514
    protocol: rfc5424

processors:
  memory_limiter:
    check_interval: 1s
    limit_percentage: 75
    spike_limit_percentage: 20
  resource/fleet:
    attributes:
      - key: site
        value: ${env:WS_SITE}
        action: upsert
      - key: cluster
        value: ${env:WS_CLUSTER}
        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")
          # pseudonymise scheduler user names before they leave the site
          - set(attributes["slurm.user"], SHA256(attributes["slurm.user"])) where attributes["slurm.user"] != nil
  batch:
    send_batch_size: 8192
    timeout: 5s

exporters:
  # Minerva-side OTLP intake: the endpoint, authentication and which signals
  # it accepts are configured per NVIDIA's Minerva documentation.
  otlp/minerva:
    endpoint: ${env:MINERVA_OTLP_ENDPOINT}
    tls:
      ca_file: /etc/otelcol-contrib/tls/minerva-ca.pem
    sending_queue:
      enabled: true
      storage: file_storage
      queue_size: 10000
    retry_on_failure:
      enabled: true
      max_elapsed_time: 30m

  # The customer's existing Prometheus-compatible store (Mimir here).
  prometheusremotewrite/existing:
    endpoint: https://mimir.obs.internal/api/v1/push
    external_labels:
      replica: ${env:WS_GATEWAY_NAME}
    resource_to_telemetry_conversion:
      enabled: true
    remote_write_queue:
      enabled: true
      queue_size: 20000
      num_consumers: 8

  # The customer's existing Elastic stack, with ECS field names.
  elasticsearch/logs:
    endpoints: ["https://es-hot-1.obs.internal:9200", "https://es-hot-2.obs.internal:9200"]
    logs_index: logs-ai.factory-prod
    mapping:
      allowed_modes: [ecs]
    tls:
      ca_file: /etc/otelcol-contrib/tls/es-ca.pem

service:
  extensions: [health_check, file_storage]
  pipelines:
    metrics:
      receivers: [otlp, prometheus/nodes]
      processors: [memory_limiter, resource/fleet, transform/hygiene, batch]
      exporters: [otlp/minerva, prometheusremotewrite/existing]
    logs:
      receivers: [otlp, syslog/switches]
      processors: [memory_limiter, resource/fleet, transform/hygiene, batch]
      exporters: [otlp/minerva, elasticsearch/logs]
    traces:
      receivers: [otlp]
      processors: [memory_limiter, resource/fleet, batch]
      exporters: [otlp/minerva]
  telemetry:
    metrics:
      level: detailed
      readers:
        - pull:
            exporter:
              prometheus:
                host: 0.0.0.0
                port: 8888

Validé avec otelcol-contrib validate à partir de l'image otel/opentelemetry-collector-contrib:0.165.0. Remarques sur les choix :

  • File d'attente sur disque pour l'exporter Minerva, afin qu'une mise à niveau de Minerva ou une coupure réseau ne fasse perdre aucune donnée ; dimensionnez le volume pour au moins une heure de débit de pointe.
  • L'étiquette externe replica permet à Mimir de dédoublonner les collectes des deux passerelles grâce à son HA tracker, comme dans la note technique sur UFM.
  • Les agents sur les nœuds (le cas échéant) envoient à la paire de passerelles en OTLP ; la configuration des agents de la note technique sur UFM s'applique sans changement.

Règles Prometheus pour le rendement et pour la couche de collecte

Ces recording rules fournissent au client ses propres chiffres d'heures GPU et de taux d'occupation, utiles pour vérifier de manière indépendante les rapports de Minerva, et les alertes surveillent la couche de collecte et l'ingestion de Minerva. Validé avec promtool check rules (Prometheus 3.12.0).

# rules/minerva-surround.yaml  (Prometheus or Mimir ruler)
groups:
  - name: ws-gpu-yield
    interval: 1m
    rules:
      # GPUs that report at all, and GPUs a Slurm job holds (dcgm-exporter's hpc_job label)
      - record: ws:gpus_present:count
        expr: count by (cluster) (DCGM_FI_DEV_GPU_UTIL_RATIO)
      - record: ws:gpus_allocated:count
        expr: count by (cluster) (DCGM_FI_DEV_GPU_UTIL_RATIO{hpc_job!=""})
      # How busy allocated GPUs really are (graphics engine activity, 0 to 1)
      - record: ws:gpu_busy_allocated:ratio
        expr: avg by (cluster) (DCGM_FI_PROF_GR_ENGINE_UTIL_RATIO{hpc_job!=""})
      # GPU hours delivered to jobs per hour; sum over a day for the yield report
      - record: ws:gpu_hours_allocated:rate1h
        expr: avg_over_time(ws:gpus_allocated:count[1h])

  - name: ws-gpu-health
    rules:
      - alert: GPUXidErrorReported
        expr: changes(DCGM_FI_DEV_XID_ERROR[10m]) > 0 and DCGM_FI_DEV_XID_ERROR != 0
        labels:
          severity: ticket
        annotations:
          summary: "XID {{ $value }} on {{ $labels.Hostname }} GPU {{ $labels.gpu }}"
      - alert: GPURowRemapFailed
        expr: DCGM_FI_DEV_ROW_REMAP_FAILED > 0
        labels:
          severity: page
        annotations:
          summary: "Row remap failed on {{ $labels.Hostname }} GPU {{ $labels.gpu }}: drain and replace"
      - alert: GPUAllocatedButIdle
        expr: avg by (cluster, hpc_job) (avg_over_time(DCGM_FI_DEV_GPU_UTIL_RATIO{hpc_job!=""}[30m])) < 0.05
        for: 15m
        labels:
          severity: ticket
        annotations:
          summary: "Job {{ $labels.hpc_job }} holds GPUs that have been idle for 30 minutes"
      - alert: DCGMExporterDown
        expr: up{job="dcgm"} == 0
        for: 5m
        labels:
          severity: ticket

  - name: ws-collector-tier
    rules:
      - alert: GatewayDown
        expr: up{job="otel-gateway"} == 0
        for: 2m
        labels:
          severity: ticket
      - alert: GatewayRedundancyLost
        expr: count by (site) (up{job="otel-gateway"} == 1) < 2
        for: 5m
        labels:
          severity: page
      - alert: MinervaExportFailing
        expr: sum by (instance) (rate(otelcol_exporter_send_failed_metric_points_total{exporter="otlp/minerva"}[5m])) > 0
        for: 10m
        labels:
          severity: page
        annotations:
          summary: "{{ $labels.instance }} cannot deliver metrics to the Minerva intake"
      - alert: CollectorQueueFilling
        expr: max by (instance, exporter) (otelcol_exporter_queue_size / otelcol_exporter_queue_capacity) > 0.8
        for: 10m
        labels:
          severity: ticket
      - alert: CollectorRefusingData
        expr: sum by (instance) (rate(otelcol_receiver_refused_metric_points_total[5m])) > 0
        for: 5m
        labels:
          severity: ticket
        annotations:
          summary: "{{ $labels.instance }} is refusing data, usually memory_limiter back-pressure"
      - alert: Watchdog
        expr: vector(1)
        labels:
          severity: none
        annotations:
          summary: "Dead man's switch: an external check pages if this stops arriving"

Alertmanager vers Slack et PagerDuty

Pour les alertes que le Prometheus du client continue de déclencher (principalement la supervision de la supervision), Alertmanager déclenche les astreintes via PagerDuty et publie dans Slack, le dead man's switch étant envoyé à un service externe de heartbeat. Validé avec amtool check-config (Alertmanager 0.34.2).

# alertmanager.yml  (for the alerts your own Prometheus still raises)
global:
  resolve_timeout: 5m

route:
  receiver: slack-ops
  group_by: [alertname, cluster, site]
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 4h
  routes:
    - matchers: ['severity="none"']
      receiver: deadmans-switch
      repeat_interval: 1m
    - matchers: ['severity="page"']
      receiver: pagerduty-oncall
      continue: true
    - matchers: ['severity=~"page|ticket"']
      receiver: slack-ops

inhibit_rules:
  # one gateway down is noise while redundancy-lost is already paging
  - source_matchers: ['alertname="GatewayRedundancyLost"']
    target_matchers: ['alertname="GatewayDown"']
    equal: [site]

receivers:
  - name: slack-ops
    slack_configs:
      - api_url_file: /etc/alertmanager/secrets/slack-webhook
        channel: "#ai-factory-ops"
        send_resolved: true
        title: '{{ .CommonLabels.alertname }} ({{ .CommonLabels.cluster }})'
        text: '{{ range .Alerts }}{{ .Annotations.summary }}{{ "\n" }}{{ end }}'
  - name: pagerduty-oncall
    pagerduty_configs:
      - routing_key_file: /etc/alertmanager/secrets/pagerduty-routing-key
        severity: critical
  - name: deadmans-switch
    webhook_configs:
      - url_file: /etc/alertmanager/secrets/heartbeat-url

Grafana et la suite Elastic

  • Grafana. NVIDIA mentionne l'intégration avec Grafana. Dans les modèles DIY et AIOps, le Grafana du client conserve ses tableaux de bord ; nous ajoutons les vues de la galerie associée et, lorsque Minerva les expose conformément à la documentation de NVIDIA, des panneaux ou des liens vers les incidents Minerva à côté des signaux bruts.
  • Elastic. Les journaux vont dans un seul stockage principal. Si le stockage de journaux du client est Elasticsearch, la passerelle y écrit des documents au format ECS et transmet les mêmes journaux à Minerva ; nous n'exploitons pas un second stockage de journaux uniquement pour le matériel d'IA.
  • ServiceNow et PagerDuty. NVIDIA cite les deux comme intégrations. Nous faisons correspondre la priorité de Minerva à l'impact et à l'urgence de ServiceNow, définissons des groupes d'affectation par couche (calcul, fabric, plateforme, installations) et vérifions le comportement de la clé de dédoublonnage décrit à la section 5.

10. Sur site ou SaaS, et RGPD britannique

NVIDIA propose Minerva sur site ou en SaaS depuis son cloud et met en avant la souveraineté des données. La télémétrie paraît technique, mais une partie relève des données personnelles au sens du RGPD britannique : les noms d'utilisateurs Slurm et Run:ai, les noms de jobs contenant des noms de personnes, les adresses e-mail dans la comptabilité de l'ordonnanceur, et les questions que les ingénieurs saisissent dans Sherlock. Notre liste de contrôle :

  • Définir la répartition des rôles. Sur site, le client est responsable du traitement, et son personnel comme nous-mêmes traitons les données selon ses instructions. En SaaS, le rôle de NVIDIA et les conditions du service hébergé doivent être examinés par le délégué à la protection des données du client.
  • Réaliser une AIPD lorsque la télémétrie relie une activité à des chercheurs ou des membres du personnel identifiables, en particulier si elle sert à la gestion de la performance ou à la refacturation.
  • Minimiser et pseudonymiser en périphérie. Hachez les noms d'utilisateurs au niveau de la passerelle (comme dans la configuration ci-dessus), supprimez les champs de texte libre inutiles et conservez la table de correspondance sur site.
  • Transferts internationaux. Si une région SaaS se trouve hors du Royaume-Uni, confirmez le mécanisme de transfert (règlements d'adéquation britanniques, ou International Data Transfer Agreement ou Addendum) avant tout flux de données.
  • Conservation. Fixez la durée de conservation par type de signal : quelques semaines pour la télémétrie haute résolution, plus longtemps pour les incidents et les agrégats, et selon la politique d'audit du client pour les journaux de conversations des agents.
  • Accès. Authentification unique avec contrôle d'accès basé sur les rôles ; dans un neocloud, les locataires ne voient que leurs propres jobs et incidents.

Pour les clients du secteur public britannique, de la recherche liée à la défense et des services financiers réglementés, nous optons par défaut pour le déploiement sur site ; c'est la configuration que nous décrivons dans le plan de déploiement.

11. Haute disponibilité et dimensionnement de la couche de collecte

La haute disponibilité et le dimensionnement de Minerva lui-même sont spécifiés par NVIDIA. Ce dont nous sommes responsables, c'est de la couche de collecte qui l'entoure, et elle ne doit pas devenir le maillon faible.

  • Au moins deux passerelles par site, dans des baies différentes sur des arrivées électriques différentes, derrière un même nom DNS ou un même équilibreur de charge. Les agents et les switches réessaient sur celle qui est disponible.
  • Des files d'attente sur disque pour chaque exporter, sur NVMe local, dimensionnées pour au moins une heure de débit de pointe.
  • memory_limiter en premier dans chaque pipeline, afin qu'une surcharge provoque une contre-pression et une alerte CollectorRefusingData plutôt qu'un plantage par manque de mémoire.
  • Des domaines de défaillance distincts pour la supervision et ce qui est supervisé. Les passerelles s'exécutent sur des nœuds d'administration, pas sur les nœuds GPU qu'elles supervisent.
  • Un observateur indépendant. Un petit Prometheus hors de la pile principale collecte l'état de santé des passerelles et de l'ingestion de Minerva, et l'alerte Watchdog prouve le bon fonctionnement de la chaîne d'alerte de bout en bout.

Une estimation du dimensionnement pour l'exemple d'environ 1 000 GPU présenté dans le blog (quatorze baies NVL72, à titre d'illustration) :

SourceHypothèseSéries actives (approx.)
Métriques GPU via dcgm-exporter1 008 GPU × ~40 champs40 000
Compteurs de récupération NVLink (par GPU, tous liens confondus ; Blackwell et ultérieurs)1 008 GPU × 3 compteurs3 000
Ports de switches Ethernet~2 000 ports × ~25 compteurs50 000
Hôtes252 plateaux de calcul × ~60 séries après filtrage15 000
Charges de travail et ordonnanceurmétriques de jobs, de services et de files d'attente10 000 à 30 000
Total pour le stockage propre au client~120 000 à 140 000

Avec un intervalle de 15 à 30 secondes, cela représente environ 4 000 à 9 500 échantillons par seconde, ce qu'une seule paire de passerelles modestes absorbe sans difficulté (nous partons de 8 vCPU et 16 Go chacune et effectuons des tests de charge avant la mise en service). Ces chiffres excluent ce que Minerva collecte directement, dont NVIDIA assure le dimensionnement. Les séries des ports de switches prédominent à mesure que les fabrics grandissent : les listes de conservation sur les compteurs de switches sont donc le levier de maîtrise des coûts le plus efficace, exactement comme pour UFM.

12. Runbook de déploiement : un déploiement par phases

Déploiement par phases sur environ seize semaines : découverte, collecteurs, apprentissage des références sans astreinte, réglage des alertes, activation des agents en lecture seule et automatisation de la remédiation derrière des barrières d'approbation, chacune avec un critère de sortie, suivies des exercices de panne lors de la remise.

Phase 1 : Découverte (semaines 1 à 2)

  • Inventorier chaque source par couche (section 3), avec ses responsables, ses versions et ses adresses d'administration.
  • Convenir du modèle de consommation, du modèle d'hébergement et de la position en matière de protection des données.
  • Recueillir le plan de câblage et le valider par rapport à LLDP et à l'état des switches.
  • Convenir d'une matrice RACI : qui est responsable de Minerva, des collecteurs, de chaque intégration et de chaque playbook.
  • Critère de sortie : inventaire des sources et conception signés.

Phase 2 : Collecteurs et intégrations (semaines 2 à 5)

  • Installer le Minerva Collector conformément à la documentation de NVIDIA ; activer les sources couche par couche.
  • Déployer la paire de passerelles OpenTelemetry si nécessaire ; valider la configuration en CI avec otelcol-contrib validate.
  • Connecter les métadonnées Slurm ou Run:ai ; vérifier l'association entre jobs et GPU sur un job de test.
  • Connecter Slack ou Teams, ServiceNow et PagerDuty dans un mode de test qui ne déclenche pas d'astreinte.
  • Critère de sortie : chaque couche remonte des données, et la topologie dans Minerva correspond au plan de câblage validé.

Phase 3 : Apprentissage des références (semaines 4 à 8)

  • Exécuter des charges de travail représentatives : grands jobs d'entraînement, inférence en pointe, rafales de checkpoints.
  • Minerva apprend les références ; ses incidents sont envoyés uniquement vers un canal de revue.
  • L'alerting existant reste en place, de sorte que rien n'est perdu.
  • Critère de sortie : références stables pendant deux semaines, et incidents examinés jugés majoritairement corrects.

Phase 4 : Réglage des alertes et réduction du bruit (semaines 7 à 10)

  • Définir les priorités, le routage et les groupes d'affectation ; activer les astreintes pour les priorités 1 et 2.
  • Rétrograder ou inhiber les alertes historiques qui se recoupent (section 5).
  • Suivre comme indicateurs clés le nombre d'alertes brutes par incident et le nombre d'astreintes par semaine.
  • Critère de sortie : l'objectif de bruit convenu, par exemple moins de 20 astreintes par semaine sans aucun incident de priorité 1 manqué lors des exercices.

Phase 5 : Activation des agents (semaines 9 à 12)

  • Activer Sherlock pour l'équipe d'exploitation, en lecture seule.
  • Enregistrer les agents du client auprès du serveur MCP sous leurs propres identités et avec des périmètres en lecture seule.
  • Activer la journalisation d'audit et examiner des échantillons chaque semaine.
  • Critère de sortie : revue de sécurité validée ; aucun agent ne détient de droits de modification.

Phase 6 : Automatisation de la remédiation (semaines 11 à 16)

  • Constituer la bibliothèque de playbooks avec retour arrière, responsables et tests en mode simulation.
  • Relier les étapes d'approbation aux changements standard ServiceNow ; commencer au niveau 2 (« approuver pour exécuter »).
  • Ne promouvoir un playbook au rang de changement standard pré-approuvé qu'après un historique irréprochable.
  • Critère de sortie : seuls les runbooks approuvés peuvent être appelés, et chaque exécution est jointe à un enregistrement de changement.

13. Exercices de panne lors de la remise

Nous ne remettons pas un flux d'incidents que nous n'avons pas vu fonctionner. Sous les yeux du client, nous exécutons et consignons les exercices suivants :

  1. Retirer une optique sur un lien leaf-spine pendant un job de test : un seul incident, la bonne cause profonde, le bon rayon d'impact, une seule astreinte, un ticket ServiceNow ouvert puis résolu automatiquement.
  2. Tuer un rang d'entraînement ou brider un GPU pour qu'un job prenne du retard : le retardataire est nommé et le propriétaire du job est identifié.
  3. Arrêter une passerelle : aucune perte de données, une astreinte GatewayRedundancyLost, rétablissement à son retour.
  4. Bloquer l'ingestion de Minerva depuis les passerelles pendant 15 minutes : astreinte MinervaExportFailing, les files d'attente se remplissent puis se vident ensuite sans trou.
  5. Simuler une alarme de refroidissement via l'intégration des installations pendant une fenêtre de test : l'incident affiche les baies et les jobs concernés.
  6. Approuver et exécuter un playbook de drainage sur un nœud de laboratoire, puis exécuter son retour arrière ; les deux apparaissent dans l'enregistrement de changement.
  7. Demander à Sherlock d'effectuer un changement : il peut décrire l'action mais ne peut pas l'exécuter.

14. 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 de Minerva et de l'observabilité, et les ingénieurs qui l'exploitent ensuite avec vous.

  • Fourniture : licences Minerva, Vera Rubin NVL72 et autres systèmes GPU, Ethernet Spectrum-X, SuperNIC et DPU, spécifiés ensemble.
  • Construction : collecteurs, couche OpenTelemetry, intégrations avec vos outils, métadonnées de l'ordonnanceur, bibliothèque de playbooks et workflow d'approbation, le tout à partir d'une configuration versionnée.
  • Exploitation : support de Minerva et des services logiciels associés, réglage du bruit, mises à niveau, planification de la capacité de la couche de collecte, et rapport mensuel sur les heures GPU, le goodput, le MTBI, le MTTR et le nombre d'astreintes par semaine.

Découvrez NVIDIA Minerva dans notre boutique, ou interrogez notre ingénieur commercial IA pour un échange sur le dimensionnement.

15. Sources et notes de vérification

  • Informations sur Minerva (périmètre, standards d'ingestion, graphe de connaissances, ML, Sherlock, MCP, intégrations, DSX OS, modèles de déploiement et de consommation, indicateurs clés) : la page officielle NVIDIA Minerva, consultée en novembre 2026, et la page d'accueil de la fiche technique de Minerva. Toutes les formulations sont notre propre résumé.
  • Non vérifié : la documentation technique de Minerva, ses API, ses formats de configuration, ses noms de métriques, ses algorithmes internes, sa conception de la haute disponibilité, son dimensionnement, ses tarifs et ses licences. Partout où nous écrivons « configuré conformément à la documentation de Minerva de NVIDIA », consultez cette documentation pour la version que vous déployez. L'interopérabilité entre Minerva et UFM sur les sites InfiniBand est à confirmer avec NVIDIA pour chaque version.
  • Configuration des passerelles OpenTelemetry Collector : validée avec otelcol-contrib validate dans otel/opentelemetry-collector-contrib:0.165.0. L'endpoint Minerva est une valeur provisoire.
  • Règles Prometheus : validées avec promtool check rules, Prometheus 3.12.0. Les noms de métriques suivent dcgm-exporter 4.9.0 et la télémétrie interne du Collector ; les noms commençant par ws: sont des recording rules de Workstation.
  • Configuration d'Alertmanager : validée avec amtool check-config, Alertmanager 0.34.2.
  • Playbook Ansible : validé avec ansible-playbook --syntax-check, ansible-core 2.21. Les appels à scontrol, squeue et dcgmi diag sont des commandes standard de Slurm et de DCGM ; testez-les en laboratoire avant la production.
  • Les chiffres donnés à titre d'illustration (nombres d'alertes, coûts des heures GPU, estimations de séries, semaines de déploiement) sont des exemples chiffrés, et non des mesures issues d'un système client.

Mention des droits : NVIDIA, le logo NVIDIA, Minerva, Sherlock (en tant que nom de l'assistant de NVIDIA), DSX, DSX OS, DGX, HGX, Vera Rubin, Blackwell, Spectrum, Spectrum-X, NVLink, ConnectX, SuperNIC, BlueField, DOCA, DCGM, NCCL, Run:ai 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 Grafana, Prometheus, Grafana Mimir, Elasticsearch, Slack, Microsoft Teams, PagerDuty, ServiceNow, Ansible, Red Hat, OpenTelemetry, OpenConfig, Slurm et Kubernetes, 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