Een praktijkgids voor het uitrollen van NVIDIA Minerva, het AIOps-platform van NVIDIA voor AI-fabrieken, en het inpassen ervan in een bestaande operationele omgeving. De gids behandelt de architectuur en datastroom, de telemetriebronnen laag voor laag, hoe topologiebewuste correlatie van een eventstorm één incident maakt, veilig gebruik van de Sherlock-assistent en de MCP-server, closed-loop-herstel met Ansible onder change control, de drie afnamemodellen als referentiearchitecturen, integratie met Prometheus, Grafana, de Elastic-stack, ServiceNow en PagerDuty, on-premises versus SaaS en de UK GDPR, HA en dimensionering voor de collectorlaag, een runbook voor gefaseerde uitrol en de storingsoefeningen die we bij de overdracht uitvoeren. De businesscase staat in de bijbehorende blogpost.
Interactieve versie: bekijk zeventien voorbeelddashboards voor een Minerva-implementatie, elk met de bijbehorende signalen en alertadviezen.
1. Wat Minerva is, volgens NVIDIA's eigen beschrijving
NVIDIA kondigde Minerva aan in oktober 2026. De officiële NVIDIA Minerva-pagina en het Minerva-datasheet zijn de gezaghebbende bronnen. In onze eigen woorden samengevat zijn de gepubliceerde feiten waaromheen we ontwerpen:
| Onderwerp | Wat NVIDIA stelt (geparafraseerd) | Wat het betekent voor het ontwerp |
|---|---|---|
| Positionering | Een end-to-end AIOps-platform ontworpen rond AI en het primaire observability-product voor NVIDIA AI-fabrieken, inclusief Vera Rubin- en Blackwell-systemen. | Behandel het als het incidentbrein van de GPU-omgeving, niet als zoveelste dashboard. |
| Telemetriescope | GPU's, NVLink-switches, Spectrum-X Ethernet, SuperNICs, DPU's, NCCL, schedulers zoals Slurm en Run:ai, opslag en AI-workloads. | Plan de verzameling per laag; zie sectie 3. |
| Ingest-standaarden | OpenTelemetry, gNMI, syslog, DCGM, Slurm en JSON. | Bestaande OpenTelemetry-pipelines kunnen ernaar doorsturen; switches streamen met gNMI. |
| Analytics | Een dynamische, topologiebewuste kennisgraaf; ML die normaal gedrag leert over miljarden datapunten per uur; geautomatiseerde root-cause-analyse wanneer jobs achterblijven of falen; ruisreductie die eventstormen samenvoegt tot één incident. | Geef het nauwkeurige topologie- en jobmetadata, en daarna een baselineperiode vóór het pagen. |
| Interactie | Sherlock, een multi-agentassistent voor triage in natuurlijke taal op live telemetrie, en een MCP-server zodat agents van klanten kunnen integreren. | Beheer agenttoegang zoals elke geprivilegieerde API; zie sectie 6. |
| Actie | Herstelaanbevelingen en closed-loop-herstel; integraties met Slack, Microsoft Teams, ServiceNow, PagerDuty, Ansible, Grafana en infrastructuur-API's. | Routeer via change control; zie sectie 7. |
| Faciliteit | De Minerva Collector is onderdeel van NVIDIA DSX OS en geeft een GPU-tot-stroomnet-beeld met gecorreleerde faciliteitssignalen. | Breng stroom en koeling in dezelfde incidenttijdlijn. |
| Implementatie | On-premises of als SaaS vanuit de cloud van NVIDIA; schaalt naar honderdduizenden GPU's; datasoevereiniteit blijft behouden; open API's, modulaire mogelijkheden en Grafana-integratie. | Beslis vroeg over het hostingmodel; zie sectie 10. |
| Afname | DIY Observability, AIOps with DIY Observability en Turnkey. | Drie referentiearchitecturen; zie sectie 8. |
| Resultaten | Uitgedrukt in GPU-uren, goodput, uptime, MTBI, MTTR en tokenproductie. | Rapporteer vanaf dag één op dezelfde KPI's. |
Minerva en UFM
Onze technote over UFM, DCGM en OpenTelemetry behandelt NVIDIA Unified Fabric Manager, dat InfiniBand-fabrics beheert en monitort. Het Minerva-materiaal van NVIDIA noemt Spectrum-X Ethernet (scale-out, scale-across en scale-in) en NVLink (scale-up) als netwerkscope en beschrijft, voor zover wij lazen, geen ingestie van InfiniBand. Op een gemengde locatie houden we UFM als InfiniBand-fabricmanager en stemmen we met NVIDIA af, voor de release die wordt uitgerold, hoe UFM-events en -telemetrie Minerva moeten bereiken. Tot dat bevestigd is, kan de OpenTelemetry-laag in sectie 9 UFM-data naar de bestaande backends van de klant brengen, precies zoals in de UFM-technote.
2. Architectuur en datastroom
We denken over een Minerva-implementatie als vier vlakken. Door ze gescheiden te houden, valt goed te redeneren over eigenaarschap, beveiliging en faalwijzen.
- Verzamelvlak. De Minerva Collector, plus ons optionele OpenTelemetry Collector-paar voor alles wat de klant al verzamelt of ook elders naartoe moet sturen. De taak is elk signaal één keer van de bron te halen, consistente identiteit toe te voegen (locatie, cluster, rack, node, rail, job), tijdens storingen te bufferen en door te sturen.
- Analytics-vlak. Minerva zelf: de kennisgraaf, baselines, anomaliedetectie, correlatie, root-cause-analyse en de incidentopslag. On-premises draait het op infrastructuur die we samen met NVIDIA dimensioneren; als SaaS draait het in de cloud van NVIDIA.
- Interactievlak. De UI en dashboards van Minerva, Sherlock, de MCP-server voor agents van klanten, en Grafana waar de klant eigen weergaven bijhoudt.
- Actievlak. Notificaties (Slack, Teams), paging en tickets (PagerDuty, ServiceNow) en automatisering (Ansible). Alles hier valt onder het changeproces van de klant.
Het pad van een signaal is: bron, naar collector (gelabeld en gebufferd), naar het analytics-vlak (gekoppeld aan een node in de graaf, vergeleken met de baseline), naar een incident (gegroepeerd met gerelateerde anomalieën), naar mensen en agents (één keer genotificeerd, met context), en mogelijk naar een goedgekeurde actie, waarvan het resultaat als telemetrie terugstroomt zodat het incident kan worden geverifieerd en gesloten.
3. Telemetriebronnen, laag voor laag
De tabel noemt per laag wat daar misgaat, de ingest-standaard die NVIDIA ervoor noemt en de open componenten die we eromheen inzetten of controleren. Waar we "Minerva Collector" schrijven, wordt het inschakelen van die bron geconfigureerd volgens de Minerva-documentatie van NVIDIA.
| Laag | Typische storingen | Ingest-route volgens NVIDIA | Open componenten die we inzetten of controleren |
|---|---|---|---|
| GPU (compute) | XID-fouten, ECC- en row-remap-events, thermische of vermogensthrottling, ongebruikte GPU's in lopende jobs | DCGM | DCGM host engine; dcgm-exporter waar de locatie ook Prometheus-kopieën bijhoudt |
| NVLink scale-up | Link-recovery-events, gedegradeerde links binnen een NVL72-domein, storingen in switchtrays | Minerva Collector (NVLink-switches) | NVLink-tellers per GPU in DCGM als kruiscontrole |
| Spectrum-X Ethernet | Drops, PFC-pausestormen, ECN-markering, bufferdruk, flappende links, te warme optics | gNMI-streaming, syslog | gNMI-subscriptions en syslog-forwarding op switches; onze syslog-receiver voor bestaande opslag |
| SuperNICs en DPU's | Congestion-control-events, retransmissies, poortfouten, gezondheid van DPU's | Minerva Collector | BlueField DOCA Telemetry Service waar die al is uitgerold |
| NCCL | Trage of vastgelopen collectives, één rank die achterloopt op de rest | Minerva Collector (NCCL-telemetrie) | Joblogs met NCCL-debugoutput vastgelegd in de logopslag |
| Schedulers | Jobs die falen of vastlopen, gedrainde nodes, GPU's toegewezen maar ongebruikt | Slurm; Run:ai | Slurm-prolog en -epilog voor jobmapping in dcgm-exporter; Kubernetes-metadata |
| Opslag | Trager wordende checkpoint-writes, metadatalatency, clientfouten | OpenTelemetry, JSON, syslog | De exporter van de opslagleverancier, doorgestuurd via onze gateways |
| Workloads | Stijgende step time, stijgende time to first token, dalende tokendoorvoer | OpenTelemetry | OpenTelemetry SDK in modelservers en trainingsharnesses |
| Faciliteit | Power capping, afwijkingen in koelmiddeltemperatuur of -debiet, PDU-storingen | Minerva Collector in DSX OS | Integratie met het gebouwbeheersysteem, geconfigureerd volgens de DSX OS-documentatie van NVIDIA |
GPU's: DCGM en dcgm-exporter
DCGM is de dienst voor GPU-gezondheid en -telemetrie die NVIDIA als Minerva-bron noemt. Waar een klant GPU-metrics ook in de eigen Prometheus bewaart, draaien we daarnaast dcgm-exporter. Let op: dcgm-exporter 4.9.0 hernoemde de standaardmetrics en veranderde verschillende eenheden (utilisatie werd een ratio van 0 tot 1, geheugen werd bytes); de volledige tabel en een set overbruggende recording rules staan in onze technote over UFM en DCGM. Alle PromQL in dit artikel gebruikt de namen van 4.9.0.
Spectrum-X-switches: gNMI en syslog
gNMI is het OpenConfig-gRPC-protocol voor het streamen van telemetrie vanaf netwerkapparatuur. In algemene termen abonneren we ons op interfacetellers in sample-modus met een vast interval en op operationele status (link up of down, transceiver-alarmen) bij wijziging, wat de belasting laag houdt en statuswijzigingen direct zichtbaar maakt. Op welke paden Minerva zich abonneert, en of het naar de switches inbelt of zij naar Minerva uitbellen, wordt ingesteld volgens de documentatie van NVIDIA en de eigen handleiding van het switchbesturingssysteem; wij zorgen alleen dat het managementnetwerk, de certificaten en de access lists het toestaan. Syslog van elke switch gaat ook naar de collector, omdat flaps en transceiver-alarmen daar vaak het eerst verschijnen.
Schedulers: Slurm en Run:ai
Correlatie is maar zo goed als de koppeling tussen jobs en hardware. Voor Slurm controleren we dat metadata over job, gebruiker, partitie en nodelijst Minerva bereikt zoals NVIDIA documenteert, en gebruiken we de Slurm-prolog en -epilog om de HPC-jobmapping van dcgm-exporter bij te houden, zodat GPU-series een hpc_job-label dragen in de eigen Prometheus van de klant. Voor Run:ai en Kubernetes controleren we dat namen van workloads en projecten doorkomen. Gebruikersnamen zijn persoonsgegevens; zie sectie 10 voor hoe we ze pseudonimiseren waar ze de locatie verlaten.
Workloads: OpenTelemetry SDK
Modelservers en trainingsharnesses die met de OpenTelemetry SDK zijn geïnstrumenteerd, sturen traces en metrics via OTLP naar het gatewaypaar, dat ze doorstuurt naar Minerva en, als de klant dat wil, naar de eigen trace-opslag. De belangrijkste signalen zijn step time en wachttijd van de data-loader voor training, en wachtrijtijd, time to first token en tokens per seconde voor inferentie.
4. De kennisgraaf en topologiebewuste correlatie
NVIDIA heeft de interne algoritmen van Minerva in het materiaal dat wij lazen niet gepubliceerd, dus deze sectie legt het idee in algemene termen uit; dat is wat operators nodig hebben om het goed te voeden.
Een kennisgraaf is hier een live model van de omgeving: entiteiten (GPU's, NVLink-switchtrays, nodes, NIC's, switchpoorten, switches, racks, stroomvoedingen, opslagtargets, jobs, tenants) en relaties daartussen (deze GPU zit in deze node; deze NIC-poort is bekabeld naar die leaf-poort; deze job draait op deze 72 GPU's; dit rack wordt gevoed door die stroomvoeding). Relaties veranderen in de tijd, vooral de plaatsing van jobs, dus elke relatie heeft een tijdsbereik.
Correlatie werkt dan grofweg zo:
- Anomalieën worden aan entiteiten gekoppeld. Een stijging van FEC-correcties hoort bij een switchpoort; een trage all-reduce hoort bij een job; een dip in utilisatie hoort bij een GPU.
- Anomalieën die dicht bij elkaar in de tijd liggen, worden getoetst op een gedeeld pad in de graaf. Als de GPU's van de trage job de fabric allemaal bereiken via NIC's die naar één leaf zijn bekabeld, en die leaf een degraderende poort heeft, is die poort een kandidaat-oorzaak en is alles stroomafwaarts een symptoom.
- Kandidaten worden gerangschikt. Positie stroomopwaarts, hoe vroeg de anomalie begon, hoe ver die van de baseline afwijkt en hoeveel symptomen die verklaart, tellen allemaal mee.
- Het impactgebied wordt berekend door de graaf stroomafwaarts te doorlopen: welke jobs, tenants en GPU's op dit moment afhankelijk zijn van het verdachte component.
Daar volgen twee praktische consequenties uit. Ten eerste is nauwkeurige topologie een voorwaarde: een niet-bekabelde of verkeerd gelabelde poort in de inventaris levert verkeerde oorzaken op. We valideren het bekabelingsplan tegen LLDP en het eigen beeld van de switches voordat we baselines opbouwen. Ten tweede moet jobmetadata tijdig zijn: als de plaatsing van jobs minuten te laat binnenkomt, kunnen symptomen niet worden gekoppeld aan de job die ze raken.
5. Ruisreductie en de levenscyclus van een incident
In een grote AI-fabric kan één fysieke storing duizenden alerts veroorzaken, omdat elke GPU, NIC en job die ermee in aanraking komt zijn eigen symptoom meldt. NVIDIA beschrijft hoe Minerva deze groepeert tot één geprioriteerd incident met context, afgeleverd bij tools zoals Slack of ServiceNow. Onze taak is ervoor te zorgen dat die incidentstroom past bij het operationele model van de klant:
| Fase | Wat er gebeurt | Wat we eromheen configureren |
|---|---|---|
| Detecteren | Anomalie ten opzichte van een geleerde baseline, of overschrijding van een harde drempel | Baselineperiode met paging uit (sectie 12) |
| Correleren | Gerelateerde anomalieën gegroepeerd op topologie en tijd | Nauwkeurige topologie- en jobmetadata (sectie 4) |
| Notificeren | Eén bericht per incident, bijgewerkt naarmate het zich ontwikkelt | Routering per tenant en ernst naar Slack of Teams, PagerDuty en ServiceNow |
| Triage | Engineer beoordeelt oorzaak en impactgebied, kan Sherlock raadplegen | Runbooklinks per incidenttype; read-only agenttoegang |
| Goedkeuren en herstellen | Voorgestelde actie goedgekeurd en uitgevoerd | Change record, goedkeuringspoort, Ansible-job (sectie 7) |
| Verifiëren en sluiten | Signalen keren terug naar de baseline; incident opgelost | Automatisch oplossen in ServiceNow en PagerDuty; evaluatie na het incident |
Voorkom dubbel pagen
Wanneer Minerva de correlatie verzorgt, mogen de bestaande alerts per symptoom van de klant voor dezelfde hardware niet ook pagen. Onze vuistregel: in de AIOps- en Turnkey-modellen zakken bestaande Prometheus-alerts voor symptomen van GPU's, NIC's en switches naar ernst ticket (of worden ze onderdrukt), en houden alleen alerts over de monitoring zelf, zoals storingen in collector en intake, de ernst page. Controleer voor ServiceNow en PagerDuty dat de incidentidentificatie die Minerva meestuurt als deduplicatiesleutel wordt gebruikt, zodat updates van één incident nooit een tweede ticket openen; hoe Minerva dat veld vult, wordt geconfigureerd volgens de documentatie van NVIDIA.
6. Sherlock en MCP: veilig omgaan met agents
Sherlock is de multi-agentassistent van Minerva voor triage in natuurlijke taal, en met de MCP-server kunnen de eigen agents van de klant Minerva vragen stellen. Beide zijn krachtig omdat ze de hele omgeving zien. We behandelen ze als geprivilegieerde interfaces en passen dezelfde controles toe als op elk automatiseringsaccount:
- Standaard read-only. Agents beginnen met alleen toegang om telemetrie, incidenten en topologie te bevragen. In de eerste fase van een uitrol heeft geen enkele agentidentiteit rechten om infrastructuur te wijzigen.
- Gescheiden identiteiten. Elke agent of integratie gebruikt een eigen service-identiteit met een eigen scope, nooit een gedeeld beheerdersaccount, zodat acties herleidbaar en intrekbaar zijn.
- Goedkeuringspoorten voor alles wat de status wijzigt. Een agent mag een drain, het uitschakelen van een poort of een herstart voorstellen; een met naam genoemde persoon keurt het goed, en de uitvoering verloopt via de onder change control vallende automatisering in sectie 7, niet via de eigen credentials van de agent.
- Behandel telemetrie als onvertrouwde input. Jobnamen, logregels en hostnamen kunnen tekst bevatten die door gebruikers is geschreven. Een agent die ze leest, kan worden gestuurd door instructies die erin zijn geplant. Agents mogen geen acties uitvoeren op basis van tekst die in telemetrie is gevonden, en toolrechten moeten aan de serverkant worden afgedwongen, niet via de prompt.
- Log elk gesprek en elke tool call in de auditopslag, met de identiteit, de vraag, de gebruikte tools en het antwoord. Beoordeel de eerste maanden wekelijks een steekproef.
- Houd secrets buiten de context. Credentials verschijnen nooit in prompts, antwoorden of tooloutput; baken MCP-tools zo af dat ze die niet kunnen teruggeven.
- Rate limits en budgetten. Begrens hoeveel queries een agent per minuut kan doen, zodat een agent in een lus het platform niet kan belasten.
| Actieklasse | Voorbeelden | Wie mag starten | Goedkeuring |
|---|---|---|---|
| Lezen | Vragen naar een incident, achterblijvers opsommen, het pad van een job door de fabric tonen | Sherlock, MCP-clients, engineers | Geen; gelogd |
| Annoteren | Een notitie aan een incident toevoegen, een ticket koppelen | Sherlock, MCP-clients met write-notes-scope | Geen; gelogd |
| Omkeerbare operationele wijziging | Een node drainen in Slurm, een job bij het volgende checkpoint verplaatsen, één flappende poort uitschakelen | Engineer, of een agent die het voorstelt | Met naam genoemde goedkeurder; standaard change record |
| Verstorende wijziging | Nodes herstarten, firmware opnieuw flashen, fabricconfiguratie wijzigen | Alleen een engineer | Normale change met CAB-goedkeuring en een onderhoudsvenster |
7. Closed-loop-herstel met Ansible en change control
NVIDIA beschrijft hoe Minerva oplossingen aanbeveelt en de kringloop sluit via integraties, waaronder Ansible. Wij introduceren automatisering in drie niveaus, en een klant gaat pas een niveau omhoog als het vorige een schoon trackrecord heeft:
- Voorstellen. Het incident bevat een aanbevolen actie en een link naar het runbook; een mens voert het werk uit.
- Goedkeuren om te draaien. De aanbevolen actie is gekoppeld aan een vooraf geschreven Ansible-playbook in de automation controller (AWX of Red Hat Ansible Automation Platform). Een goedkeuringsstap in de workflow, gekoppeld aan een standaard change in ServiceNow, laat een met naam genoemde goedkeurder het met één klik uitvoeren.
- Vooraf goedgekeurde standaard changes. Een korte lijst van omkeerbare acties met laag risico, zoals het drainen van een node met herhaalde XID-fouten, draait zonder menselijke klik, nog steeds onder een standaard change-template en nog steeds gelogd. Verstorende acties bereiken dit niveau nooit.
Hoe Minerva een actie overdraagt aan de automation controller (webhook, API-aanroep of ServiceNow-trigger) wordt geconfigureerd volgens de Minerva-documentatie van NVIDIA. Het playbook zelf is van ons en bewust defensief: het weigert te draaien zonder change- en incidentreferentie, draint in plaats van te killen, wacht op lopende jobs, draait een DCGM-diagnose en laat de node gedraind achter, zodat een engineer hem weer kan vrijgeven.
# 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"
Elk playbook in de bibliotheek heeft een bijbehorende rollback (hier scontrol update nodename=... state=resume na de controle door de engineer), een in het lab geteste dry-run-modus en een eigenaar. Het joblog van de automation controller wordt automatisch aan het change record gekoppeld.
8. De drie afnamemodellen als referentiearchitecturen
| DIY Observability | AIOps with DIY Observability | Turnkey | |
|---|---|---|---|
| Verzameling | Minerva Collector | Minerva Collector | Minerva Collector |
| Opslag en dashboards | Prometheus of Mimir en Grafana van de klant | Grafana van de klant; Minerva-inzichten erin gevoed | Eigen dashboards van Minerva; Grafana optioneel |
| Anomaliedetectie en correlatie | Eigen regels van de klant | Minerva | Minerva |
| Assistent en agents | Geen vanuit Minerva | Inzichten naar de agentische tools van de klant | Sherlock plus MCP |
| Incidenten | Alertmanager naar Slack en PagerDuty | Minerva naar ServiceNow en PagerDuty | Minerva naar ServiceNow, PagerDuty, Slack of Teams |
| Ons OpenTelemetry-paar | Meestal wel, voor labeling en fan-out | Ja, voor bestaande bronnen en backends | Alleen voor bronnen die niet van NVIDIA zijn |
| Typische klant | Volwassen SRE-team, één cluster | Enterprise met een gevestigde toolchain | AI-fabriek of neocloud |
DIY Observability. De collector voedt de Prometheus-compatibele opslag van de klant. We zetten de Prometheus-regels en Alertmanager-routes uit sectie 9 in, de Grafana-dashboards uit de bijbehorende galerij en het labelschema uit de UFM-technote. De klant is eigenaar van de correlatie; Minerva geeft consistente data die aansluit bij NVIDIA.
AIOps with DIY Observability. Zoals hierboven, plus de analytics van Minerva. Het ontwerpwerk zit in deduplicatie (sectie 5), het routeren van incidenten naar de juiste toewijzingsgroepen in ServiceNow en het tonen van Minerva-inzichten naast bestaande Grafana-panelen, zodat engineers niet van tool hoeven te wisselen.
Turnkey. Minerva is de primaire operationele console. We houden toch een onafhankelijke, minimale Prometheus die de collectors, de Minerva-intake en de dead man's switch bewaakt, omdat een monitoringplatform niet het enige mag zijn dat zichzelf bewaakt.
9. Integratie met Prometheus, Grafana, Elastic, ServiceNow en PagerDuty
Het OpenTelemetry-gatewaypaar
Waar de klant al bronnen heeft die de Minerva Collector niet dekt, of een kopie in de eigen backends moet houden, draaien we per locatie twee OpenTelemetry Collector-gateways achter één DNS-naam. Deze configuratie stuurt door naar een OTLP-intake van Minerva en naar Mimir en Elasticsearch van de klant, labelt alles met locatie en cluster, verwijdert bekende attributen met hoge kardinaliteit en gevoelige attributen, en pseudonimiseert Slurm-gebruikersnamen voordat data de locatie verlaat. Het endpoint otlp/minerva, de authenticatie ervan en welke signalen het accepteert, zijn placeholders die worden geconfigureerd volgens de Minerva-documentatie van 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
Gevalideerd met otelcol-contrib validate uit het image otel/opentelemetry-collector-contrib:0.165.0. Toelichting bij de keuzes:
- Wachtrij op schijf voor de Minerva-exporter, zodat een Minerva-upgrade of netwerkonderbreking geen data kost; dimensioneer het volume voor minstens een uur piekdoorvoer.
- Het externe label
replicalaat Mimir de scrapes van de twee gateways dedupliceren met zijn HA-tracker, zoals in de UFM-technote. - Agents op nodes (indien gebruikt) sturen via OTLP naar het gatewaypaar; de agentconfiguratie uit de UFM-technote geldt ongewijzigd.
Prometheus-regels voor rendement en voor de collectorlaag
Deze recording rules leveren de eigen cijfers van de klant voor GPU-uren en bezettingsgraad, handig om de rapporten van Minerva onafhankelijk te controleren, en de alerts bewaken de collectorlaag en de Minerva-intake. Gevalideerd met 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 naar Slack en PagerDuty
Voor de alerts die de Prometheus van de klant nog afgeeft (vooral het monitoren van de monitoring) pagt Alertmanager via PagerDuty en post het naar Slack, waarbij de dead man's switch naar een externe heartbeat-dienst gaat. Gevalideerd met 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 en de Elastic-stack
- Grafana. NVIDIA noemt Grafana-integratie. In de DIY- en AIOps-modellen behoudt de Grafana van de klant zijn dashboards; wij voegen de weergaven uit de bijbehorende galerij toe en, waar Minerva ze volgens de documentatie van NVIDIA beschikbaar stelt, panelen of links voor Minerva-incidenten naast de ruwe signalen.
- Elastic. Logs gaan naar één primaire opslag. Als de logopslag van de klant Elasticsearch is, schrijft de gateway daar documenten in ECS-vorm naartoe en stuurt dezelfde logs door naar Minerva; we draaien geen tweede logopslag alleen voor AI-hardware.
- ServiceNow en PagerDuty. NVIDIA noemt beide als integraties. We koppelen de Minerva-prioriteit aan impact en urgentie in ServiceNow, stellen toewijzingsgroepen per laag in (compute, fabric, platform, faciliteit) en bevestigen het gedrag van de deduplicatiesleutel uit sectie 5.
10. On-premises of SaaS, en de UK GDPR
NVIDIA biedt Minerva on-premises of als SaaS vanuit de eigen cloud aan en benadrukt datasoevereiniteit. Telemetrie oogt technisch, maar delen ervan zijn persoonsgegevens onder de UK GDPR: gebruikersnamen in Slurm en Run:ai, jobnamen met namen van mensen, e-mailadressen in de accounting van de scheduler en de vragen die engineers in Sherlock typen. Onze checklist:
- Bepaal de rolverdeling. On-premises is de klant verwerkingsverantwoordelijke en verwerken zijn medewerkers en wij volgens zijn instructies. Bij SaaS moeten de rol en de voorwaarden van NVIDIA voor de gehoste dienst worden beoordeeld door de functionaris voor gegevensbescherming van de klant.
- Voer een DPIA uit waar telemetrie activiteit koppelt aan identificeerbare onderzoekers of medewerkers, vooral als die wordt gebruikt voor prestatiebeoordeling of interne doorbelasting.
- Minimaliseer en pseudonimiseer aan de rand. Hash gebruikersnamen op de gateway (zoals in de configuratie hierboven), laat vrije-tekstvelden weg die niet nodig zijn en houd de koppeltabel op locatie.
- Internationale doorgiften. Als een SaaS-regio buiten het VK ligt, bevestig dan het doorgiftemechanisme (Britse adequaatheidsregelingen, of de International Data Transfer Agreement of het Addendum) voordat er data stroomt.
- Bewaring. Stel bewaartermijnen per signaaltype in: telemetrie met hoge resolutie wekenlang, incidenten en aggregaten langer, gesprekslogs van agents volgens het auditbeleid van de klant.
- Toegang. Single sign-on met rolgebaseerde toegang; tenants in een neocloud zien alleen hun eigen jobs en incidenten.
Voor klanten in de Britse publieke sector, defensiegerelateerd onderzoek en gereguleerde financiële dienstverlening kiezen we standaard voor on-premises; dat is de configuratie die we in het uitrolplan beschrijven.
11. HA en dimensionering voor de collectorlaag
De HA en dimensionering van Minerva zelf worden door NVIDIA gespecificeerd. Waar wij eigenaar van zijn, is de verzamellaag eromheen, en die mag niet de zwakke schakel worden.
- Minstens twee gateways per locatie, in verschillende racks op verschillende stroomvoedingen, achter één DNS-naam of load balancer. Agents en switches proberen het opnieuw bij de gateway die beschikbaar is.
- Wachtrijen op schijf bij elke exporter, op lokale NVMe, gedimensioneerd voor minstens een uur piekdoorvoer.
memory_limiterals eerste in elke pipeline, zodat overbelasting tot back-pressure en eenCollectorRefusingData-alert leidt in plaats van een crash door geheugentekort.- Gescheiden faaldomeinen voor monitoring en gemonitorde systemen. Gateways draaien op managementnodes, niet op de GPU-nodes die ze monitoren.
- Onafhankelijke bewaker. Een kleine Prometheus buiten de hoofdstack scrapet de gezondheid van de gateways en de Minerva-intake, en de Watchdog-alert bewijst het alertpad van begin tot eind.
Een schatting van de dimensionering voor het voorbeeld van ongeveer 1.000 GPU's uit de blog (veertien NVL72-racks, ter illustratie):
| Bron | Aanname | Actieve series (ca.) |
|---|---|---|
| GPU-metrics via dcgm-exporter | 1.008 GPU's × ~40 velden | 40.000 |
| NVLink-recoverytellers (per GPU, alle links; Blackwell en nieuwer) | 1.008 GPU's × 3 tellers | 3.000 |
| Ethernet-switchpoorten | ~2.000 poorten × ~25 tellers | 50.000 |
| Hosts | 252 compute trays × ~60 series na filtering | 15.000 |
| Workloads en scheduler | metrics voor jobs, diensten en wachtrijen | 10.000 tot 30.000 |
| Totaal voor de eigen opslag van de klant | ~120.000 tot 140.000 |
Bij een interval van 15 tot 30 seconden is dat ruwweg 4.000 tot 9.500 samples per seconde, ruim binnen de capaciteit van één paar bescheiden gateways (we beginnen met 8 vCPU en 16 GB per gateway en doen een loadtest vóór de livegang). De cijfers zijn exclusief wat Minerva direct verzamelt; dat dimensioneert NVIDIA. Series van switchpoorten domineren naarmate fabrics groeien, dus keep-lists op switchtellers zijn de effectiefste kostenbeheersing, precies zoals bij UFM.
12. Implementatierunbook: een gefaseerde uitrol
Fase 1: Discovery (week 1 tot 2)
- Inventariseer elke bron per laag (sectie 3), met eigenaren, versies en managementadressen.
- Spreek het afnamemodel, het hostingmodel en het standpunt over gegevensbescherming af.
- Verzamel het bekabelingsplan en valideer het tegen LLDP en de switchstatus.
- Spreek een RACI af: wie eigenaar is van Minerva, de collectors, elke integratie en elk playbook.
- Exitpoort: ondertekende broninventaris en ontwerp.
Fase 2: Collectors en integraties (week 2 tot 5)
- Installeer de Minerva Collector volgens de documentatie van NVIDIA; schakel bronnen laag voor laag in.
- Zet indien nodig het OpenTelemetry-gatewaypaar neer; valideer de configuratie in CI met
otelcol-contrib validate. - Koppel Slurm- of Run:ai-metadata; bevestig de koppeling tussen job en GPU met een testjob.
- Koppel Slack of Teams, ServiceNow en PagerDuty in een testmodus die niet pagt.
- Exitpoort: elke laag rapporteert, en de topologie in Minerva komt overeen met het gevalideerde bekabelingsplan.
Fase 3: Baselining (week 4 tot 8)
- Draai representatieve workloads: grote trainingsjobs, inferentie op piekbelasting, checkpointstormen.
- Minerva leert baselines; de incidenten gaan alleen naar een reviewkanaal.
- Bestaande alerting blijft zoals die is, zodat er niets verloren gaat.
- Exitpoort: baselines twee weken stabiel, en beoordeelde incidenten grotendeels als correct beoordeeld.
Fase 4: Afstemming van alerts en ruisreductie (week 7 tot 10)
- Stel prioriteiten, routering en toewijzingsgroepen in; zet paging aan voor prioriteit 1 en 2.
- Verlaag of onderdruk overlappende bestaande alerts (sectie 5).
- Volg ruwe alerts per incident en pages per week als KPI's.
- Exitpoort: het afgesproken ruisdoel, bijvoorbeeld minder dan 20 pages per week zonder gemist incident met prioriteit 1 in oefeningen.
Fase 5: Agents inschakelen (week 9 tot 12)
- Schakel Sherlock read-only in voor het operationele team.
- Registreer agents van de klant bij de MCP-server onder hun eigen identiteiten en read-only scopes.
- Zet auditlogging aan en beoordeel wekelijks steekproeven.
- Exitpoort: securityreview afgetekend; geen enkele agent heeft wijzigingsrechten.
Fase 6: Herstelautomatisering (week 11 tot 16)
- Bouw de playbookbibliotheek met rollback, eigenaren en dry-run-tests.
- Koppel goedkeuringsstappen aan standaard changes in ServiceNow; begin op niveau 2 ("goedkeuren om te draaien").
- Promoveer afzonderlijke playbooks pas na een schoon trackrecord tot vooraf goedgekeurde standaard changes.
- Exitpoort: alleen goedgekeurde runbooks zijn aanroepbaar, en elke run is gekoppeld aan een change record.
13. Storingsoefeningen bij de overdracht
We dragen geen incidentstroom over die we niet hebben zien werken. Terwijl de klant meekijkt, voeren we uit en leggen we vast:
- Trek een optic uit op een leaf-naar-spine-link tijdens een testjob: één incident, juiste oorzaak, juist impactgebied, één page, ServiceNow-ticket geopend en later automatisch opgelost.
- Kill één trainingsrank of throttle één GPU zodat een job achterblijft: de achterblijver wordt benoemd en de eigenaar van de job wordt geïdentificeerd.
- Stop één gateway: geen dataverlies, een
GatewayRedundancyLost-page, herstel zodra hij terugkomt. - Blokkeer de Minerva-intake vanaf de gateways gedurende 15 minuten:
MinervaExportFailingpagt, wachtrijen lopen vol en daarna leeg zonder gat. - Simuleer een koelingsalarm via de faciliteitsintegratie in een testvenster: het incident toont de getroffen racks en jobs.
- Keur een drain-playbook goed en voer het uit op een labnode, en voer daarna de rollback uit; beide verschijnen in het change record.
- Vraag Sherlock een wijziging door te voeren: het kan de actie beschrijven, maar niet uitvoeren.
14. Hoe Workstation dit levert en beheert
Workstation is NVIDIA-partner, dus naast de hardware leveren we engineering, software en mensen om AI-datacenters van begin tot eind in te richten en te beheren: ontwerp, installatie, het opleveren van de fabric, de inrichting van Minerva en observability, en de engineers die het daarna samen met u beheren.
- Levering: Minerva-licenties, Vera Rubin NVL72 en andere GPU-systemen, Spectrum-X Ethernet, SuperNICs en DPU's, samen gespecificeerd.
- Bouw: collectors, de OpenTelemetry-laag, integraties met uw tools, schedulermetadata, de playbookbibliotheek en de goedkeuringsworkflow, allemaal vanuit geversioneerde configuratie.
- Beheer: ondersteuning voor Minerva en de omliggende softwarediensten, ruisafstemming, upgrades, capaciteitsplanning voor de collectorlaag en een maandrapport over GPU-uren, goodput, MTBI, MTTR en pages per week.
Bekijk NVIDIA Minerva in onze shop, of vraag onze AI Sales Engineer om een gesprek over dimensionering.
15. Bronnen en verificatienotities
- Feiten over Minerva (scope, ingest-standaarden, kennisgraaf, ML, Sherlock, MCP, integraties, DSX OS, implementatie- en afnamemodellen, KPI's): de officiële pagina NVIDIA Minerva, gelezen in november 2026, en de landingspagina van het Minerva-datasheet. Alle formuleringen hier zijn onze eigen samenvatting.
- Niet geverifieerd: de technische documentatie, API's, configuratieformaten, metricnamen, interne algoritmen, het HA-ontwerp, de dimensionering, prijzen en licenties van Minerva. Overal waar we "geconfigureerd volgens de Minerva-documentatie van NVIDIA" schrijven, raadpleegt u die documentatie voor de release die u uitrolt. Hoe Minerva en UFM samenwerken op InfiniBand-locaties, moet per release met NVIDIA worden bevestigd.
- Gatewayconfiguratie van de OpenTelemetry Collector: gevalideerd met
otelcol-contrib validateinotel/opentelemetry-collector-contrib:0.165.0. Het Minerva-endpoint is een placeholder. - Prometheus-regels: gevalideerd met
promtool check rules, Prometheus 3.12.0. Metricnamen volgen dcgm-exporter 4.9.0 en de interne telemetrie van de Collector zelf; namen die beginnen metws:zijn recording rules van Workstation. - Alertmanager-configuratie: gevalideerd met
amtool check-config, Alertmanager 0.34.2. - Ansible-playbook: gevalideerd met
ansible-playbook --syntax-check, ansible-core 2.21. De aanroepen vanscontrol,squeueendcgmi diagzijn standaardcommando's van Slurm en DCGM; test in een lab vóór productie. - Illustratieve cijfers (aantallen alerts, kosten per GPU-uur, schattingen van series, uitrolweken) zijn uitgewerkte voorbeelden, geen metingen van een klantsysteem.
Erkenning van rechten: NVIDIA, het NVIDIA-logo, Minerva, Sherlock (als naam van de assistent van NVIDIA), DSX, DSX OS, DGX, HGX, Vera Rubin, Blackwell, Spectrum, Spectrum-X, NVLink, ConnectX, SuperNIC, BlueField, DOCA, DCGM, NCCL, Run:ai en Unified Fabric Manager (UFM) zijn handelsmerken en/of gedeponeerde handelsmerken van NVIDIA Corporation in de Verenigde Staten en andere landen. NVIDIA-producten en -technologieën kunnen worden beschermd door octrooien en andere intellectuele-eigendomsrechten van NVIDIA Corporation, en al deze rechten worden erkend en voorbehouden aan hun eigenaren. Productinformatie is in onze eigen woorden samengevat uit het publieke materiaal van NVIDIA; de website en documentatie van NVIDIA zijn de gezaghebbende bron. Andere bedrijfs- en productnamen, waaronder Grafana, Prometheus, Grafana Mimir, Elasticsearch, Slack, Microsoft Teams, PagerDuty, ServiceNow, Ansible, Red Hat, OpenTelemetry, OpenConfig, Slurm en Kubernetes, kunnen handelsmerken van hun respectieve eigenaren zijn. De eigen dashboards, configuraties en teksten van Workstation zijn © Workstation.