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.
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 :
| Sujet | Ce qu'indique NVIDIA (paraphrasé) | Ce que cela implique pour la conception |
|---|---|---|
| Positionnement | Une 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étrie | GPU, 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'ingestion | OpenTelemetry, gNMI, syslog, DCGM, Slurm et JSON. | Les pipelines OpenTelemetry existants peuvent y transmettre ; les switches diffusent en gNMI. |
| Analytique | Un 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. |
| Interaction | Sherlock, 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. |
| Action | Recommandations 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. |
| Installations | Le 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éploiement | Sur 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. |
| Consommation | DIY Observability, AIOps with DIY Observability et Turnkey. | Trois architectures de référence ; voir la section 8. |
| Résultats | Exprimé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
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.
- 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.
- 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.
- 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.
- 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.
| Couche | Pannes typiques | Voie d'ingestion citée par NVIDIA | Composants 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 cours | DCGM | Moteur 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 switches | Minerva Collector (switches NVLink) | Compteurs NVLink par GPU de DCGM comme contrôle croisé |
| Ethernet Spectrum-X | Pertes de paquets, tempêtes de pauses PFC, marquage ECN, pression sur les buffers, liens instables, optiques en surchauffe | Streaming gNMI, syslog | Abonnements 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 DPU | Minerva Collector | BlueField DOCA Telemetry Service lorsqu'il est déjà déployé |
| NCCL | Opérations collectives lentes ou bloquées, un rang en retard sur les autres | Minerva Collector (télémétrie NCCL) | Journaux des jobs avec la sortie de débogage NCCL capturée dans le stockage des journaux |
| Ordonnanceurs | Jobs en échec ou bloqués, nœuds drainés, GPU alloués mais inactifs | Slurm ; Run:ai | Prolog et epilog Slurm pour l'association des jobs dans dcgm-exporter ; métadonnées Kubernetes |
| Stockage | Ralentissement des écritures de checkpoints, latence des métadonnées, erreurs côté client | OpenTelemetry, JSON, syslog | L'exporter du fournisseur de stockage, transmis via nos passerelles |
| Charges de travail | Hausse du temps par étape, hausse du délai avant le premier token, baisse du débit de tokens | OpenTelemetry | SDK OpenTelemetry dans les serveurs de modèles et les frameworks d'entraînement |
| Installations | Plafonnement de puissance, écarts de température ou de débit du liquide de refroidissement, pannes de PDU | Minerva Collector dans DSX OS | Inté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 :
- 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.
- 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.
- 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.
- 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
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 :
| Étape | Ce qui se passe | Ce que nous configurons autour |
|---|---|---|
| Détecter | Anomalie par rapport à la référence apprise, ou dépassement d'un seuil strict | Période d'apprentissage des références sans astreinte (section 12) |
| Corréler | Anomalies liées regroupées par topologie et par temps | Topologie et métadonnées de jobs exactes (section 4) |
| Notifier | Un message par incident, mis à jour au fil de son évolution | Routage par locataire et par sévérité vers Slack ou Teams, PagerDuty et ServiceNow |
| Trier | L'ingénieur examine la cause et le rayon d'impact, et peut interroger Sherlock | Liens vers les runbooks par type d'incident ; accès des agents en lecture seule |
| Approuver et remédier | L'action suggérée est approuvée et exécutée | Enregistrement de changement, barrière d'approbation, job Ansible (section 7) |
| Vérifier et clore | Les signaux reviennent à leur référence ; l'incident est résolu | Ré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'action | Exemples | Qui peut la déclencher | Approbation |
|---|---|---|---|
| Lecture | Poser une question sur un incident, lister les jobs à la traîne, afficher le chemin d'un job dans la fabric | Sherlock, clients MCP, ingénieurs | Aucune ; journalisée |
| Annotation | Ajouter une note à un incident, lier un ticket | Sherlock, clients MCP disposant du périmètre d'écriture de notes | Aucune ; journalisée |
| Changement opérationnel réversible | Drainer un nœud dans Slurm, déplacer un job à son prochain checkpoint, arrêter un port instable | Ingénieur, ou agent à titre de proposition | Approbateur nommément désigné ; enregistrement de changement standard |
| Changement perturbateur | Redémarrer des nœuds, reflasher un firmware, modifier la configuration de la fabric | Ingénieur uniquement | Changement 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 :
- Suggérer. L'incident comporte une action recommandée et un lien vers le runbook ; une personne effectue le travail.
- 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.
- 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 Observability | AIOps with DIY Observability | Turnkey | |
|---|---|---|---|
| Collecte | Minerva Collector | Minerva Collector | Minerva Collector |
| Stockage et tableaux de bord | Prometheus ou Mimir et Grafana du client | Grafana du client ; alimenté par les analyses de Minerva | Tableaux de bord propres à Minerva ; Grafana facultatif |
| Détection d'anomalies et corrélation | Règles propres au client | Minerva | Minerva |
| Assistant et agents | Aucun fourni par Minerva | Analyses transmises aux outils agentiques du client | Sherlock plus MCP |
| Incidents | Alertmanager vers Slack et PagerDuty | Minerva vers ServiceNow et PagerDuty | Minerva vers ServiceNow, PagerDuty, Slack ou Teams |
| Notre paire OpenTelemetry | Généralement oui, pour l'étiquetage et la diffusion multiple | Oui, pour les sources et backends existants | Uniquement pour les sources non NVIDIA |
| Client type | Équipe SRE mature, cluster unique | Grande entreprise dotée d'une chaîne d'outils établie | Usine 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
replicapermet à 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_limiteren premier dans chaque pipeline, afin qu'une surcharge provoque une contre-pression et une alerteCollectorRefusingDataplutô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) :
| Source | Hypothèse | Séries actives (approx.) |
|---|---|---|
| Métriques GPU via dcgm-exporter | 1 008 GPU × ~40 champs | 40 000 |
| Compteurs de récupération NVLink (par GPU, tous liens confondus ; Blackwell et ultérieurs) | 1 008 GPU × 3 compteurs | 3 000 |
| Ports de switches Ethernet | ~2 000 ports × ~25 compteurs | 50 000 |
| Hôtes | 252 plateaux de calcul × ~60 séries après filtrage | 15 000 |
| Charges de travail et ordonnanceur | métriques de jobs, de services et de files d'attente | 10 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
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 :
- 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.
- 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é.
- Arrêter une passerelle : aucune perte de données, une astreinte
GatewayRedundancyLost, rétablissement à son retour. - 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. - 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.
- 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.
- 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 validatedansotel/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 parws: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,squeueetdcgmi diagsont 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.