De shop is live

Wij bouwen Workstation AI-machines voor websites, AI-agents en LLM-training — configureer en koop online.

Bekijk handelsprijzen
AI-producten
AI LabsOpenAI-agentsClaude-agentsGrok-botWorkstation AI native CRMMarketingAlle producten
AI-oplossingen
Toegepaste AIAI-agentsGeneratieve AIAI-automatiseringAI-bijscholingAI-pakketten voor het mkbEnterprise AI LabAI-werkstationsNVIDIA-hardware en -softwareNVIDIA Accelerated ComputingPrivate AIGPU private cloudGPU-clustersEdge AIAI per sector
AI-diensten
PlatformmoderniseringDigitale engineeringDatafundamenten en AIAutonome operatiesAI-adviesDevOps-automatiseringCybersecuritySoftwareontwikkelingAgentontwikkelingMLOps-opzetGPU-leasingGPU private cloud
Over ons
BedrijfOns verhaalPartnersKlantverhalen
AI-datacenters
AI-datacentersGPU private cloudGPU-clustersGPU-leasing
AI-inzichtenJev-reeksBenchmarklabModelkeuze
Technische notities
Documentatie
Linux-OSUbuntuRed Hat Enterprise LinuxSUSE LinuxAlpine LinuxDebian, Rocky & AlmaLinux
AI-cloudplatformsAWS & Amazon BedrockGoogle Cloud & Vertex AIMicrosoft Azure & AI FoundryGPU-clouds en -marktplaatsen
Private AI-datacentersVoor advocatenkantorenVoor accountantskantorenOn-premises platformsVolledig beveiligde cloud
ToolsRing PromoterJobshout
Nieuws
Blog
Neem contact opInloggen

AI-werkstations, AI multi-agent software, GPU-infrastructuur en intelligente agentoplossingen voor moderne bedrijven.

Neem contact op

AI-oplossingen

Toegepaste AIAI-agentsGeneratieve AIAI-automatiseringAI-bijscholingAI-pakketten voor het mkbEnterprise AI LabAI per sector

Producten

Alle productenWorkstation AI-native CRM & ERPMarketingOpenAI-agentsRing PromoterJobshout

Bedrijf

Over onsBedrijfAI-datacentersWaarom WorkstationPartnersKlantverhalenPrijzenContactTenthMatrix

Bronnen

AI-inzichtenTechnische notitiesDocumentatieLinux-OSAI-cloudplatformsPrivate AI-datacentersBlogZoekenSitemap
Kantoor België
Workstation SRL, Rue Vanderkindere 34, 1180 Uccle, BrusselsBE 0751.518.683Ma - Vr: 9:00 - 18:00 CET
+32 492 45 67 46
Hoofdkantoor VK
77-79 Marlowes, Hemel Hempstead HP1 1LFRoute: neem afrit 20 van de M25, Outer LondonBedrijfsnummer: 11641870Ma - Vr: 9:00 - 18:00 GMT
+44 7515 356 146
Kantoor India
#159 Sector 9, Pocket 1, DDA Flats, 110077 Dwarka, New Delhi
+91 98881 98841
Kantoor Taiwan
3F, No. 2-4, Aisi Rd., Ren'ai Dist., Keelung City 200, Taiwan基隆市仁愛區愛四路2之4號3樓Ma - Vr: 9:00 - 18:00 Taiwanese tijd (GMT+8)
+886 926 892 701+32 492 45 67 46
Kantoor Estland
Aleksander Puškini tn 30-25, 20306 Narva, EstoniaMa - vr: 9:00 - 18:00 uur Estse tijd (EET)
+32 492 45 67 46

© 2026 Workstation AI. Alle rechten voorbehouden.

PrivacyGegevensverwijderingCookiesServicevoorwaardenWebsite-sitemap

NVIDIA, het NVIDIA-logo, RTX, RTX PRO, Blackwell, CUDA, NVLink, MGX, Omniverse, Spectrum-X, Quantum, BlueField, DGX en HGX zijn handelsmerken en/of gedeponeerde handelsmerken van NVIDIA Corporation in de VS en andere landen. AMD, het AMD Arrow-logo, EPYC, Instinct, Ryzen en Threadripper zijn handelsmerken van Advanced Micro Devices, Inc. Dell en PowerEdge zijn handelsmerken van Dell Inc. of haar dochterondernemingen. Intel en Xeon zijn handelsmerken van Intel Corporation of haar dochterondernemingen. AMAX, AceleMax en LiquidMax zijn handelsmerken van AMAX Engineering Corporation. Alle andere productnamen, logo's en merken zijn eigendom van hun respectieve eigenaren. Wij gebruiken ze uitsluitend om de producten aan te duiden die wij beschrijven, leveren of ondersteunen; het gebruik ervan betekent niet dat de eigenaren ons onderschrijven.

Home / Technische notities / Technology
AIHardwareObservability

NVIDIA Minerva AIOps in de praktijk: architectuur, telemetrie, veilige agents, herstel met Ansible en een gefaseerde uitrol

Datastroom en telemetrielagen, topologiebewuste correlatie, guardrails voor Sherlock en MCP, closed-loop-herstel onder change control, drie referentiearchitecturen, gevalideerde configuratie voor OpenTelemetry, Prometheus, Alertmanager en Ansible, UK GDPR, HA en dimensionering van collectors, en een uitrolrunbook

9 november 2026Technology30 min read

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.

Vijf telemetrielagen, compute, NVLink scale-up, Spectrum-X scale-out, jobs en faciliteit, voeden verzameling, een topologische kennisgraaf en ML-correlatie, die incidenten afleveren bij mensen, agents en herstel achter een goedkeuringspoort.

Samenvatting. Minerva verzamelt via open standaarden telemetrie uit alle lagen van een AI-fabriek, houdt een live graaf bij van hoe hardware, fabrics en jobs met elkaar verbonden zijn, leert baselines met machine learning en gebruikt de graaf om gerelateerde alerts te groeperen tot één incident met een waarschijnlijke oorzaak en een impactgebied. Daaromheen zetten wij alleen open, verifieerbare componenten in: een OpenTelemetry Collector-paar voor bronnen en backends die de klant al heeft, dcgm-exporter en Slurm-metadata, Prometheus-regels en Alertmanager voor het monitoren van de monitoring, en Ansible-playbooks die alleen achter een goedkeuringspoort draaien. Endpoints, schema's en instellingen aan de Minerva-kant worden geconfigureerd volgens de Minerva-documentatie van NVIDIA; dit artikel verzint ze niet.
Scope en eerlijkheidsverklaring. Dit artikel is geschreven op basis van de publieke productpagina en het datasheet van NVIDIA voor Minerva, niet op basis van de technische documentatie. We beschrijven de interne werking, API's en configuratie van Minerva daarom alleen op het niveau dat NVIDIA heeft gepubliceerd, en we tonen geen Minerva-configuratiebestanden, CLI-commando's, metricnamen of prijzen. Elk configuratieblok hieronder is voor een open component rond Minerva en is gevalideerd met de eigen tooling van dat component; zie sectie 15, Bronnen en verificatienotities.

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:

OnderwerpWat NVIDIA stelt (geparafraseerd)Wat het betekent voor het ontwerp
PositioneringEen 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.
TelemetriescopeGPU'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-standaardenOpenTelemetry, gNMI, syslog, DCGM, Slurm en JSON.Bestaande OpenTelemetry-pipelines kunnen ernaar doorsturen; switches streamen met gNMI.
AnalyticsEen 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.
InteractieSherlock, 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.
ActieHerstelaanbevelingen en closed-loop-herstel; integraties met Slack, Microsoft Teams, ServiceNow, PagerDuty, Ansible, Grafana en infrastructuur-API's.Routeer via change control; zie sectie 7.
FaciliteitDe 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.
ImplementatieOn-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.
AfnameDIY Observability, AIOps with DIY Observability en Turnkey.Drie referentiearchitecturen; zie sectie 8.
ResultatenUitgedrukt 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

Referentiearchitectuur: bronnen uit GPU-nodes, NVLink-switchtrays, Spectrum-X-switches, SuperNICs en DPU's, NCCL en workloads, schedulers, opslag en faciliteit voeden de Minerva Collector en een optioneel OpenTelemetry Collector-paar; het Minerva AIOps-platform bevat de kennisgraaf, ML-anomaliedetectie, correlatie, root-cause-analyse, Sherlock, de MCP-server en dashboards; afnemers zijn onder meer Grafana, Slack en Teams, PagerDuty en ServiceNow, agents van klanten, Ansible achter goedkeuring en de Elastic-stack.

We denken over een Minerva-implementatie als vier vlakken. Door ze gescheiden te houden, valt goed te redeneren over eigenaarschap, beveiliging en faalwijzen.

  1. 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.
  2. 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.
  3. Interactievlak. De UI en dashboards van Minerva, Sherlock, de MCP-server voor agents van klanten, en Grafana waar de klant eigen weergaven bijhoudt.
  4. 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.

LaagTypische storingenIngest-route volgens NVIDIAOpen componenten die we inzetten of controleren
GPU (compute)XID-fouten, ECC- en row-remap-events, thermische of vermogensthrottling, ongebruikte GPU's in lopende jobsDCGMDCGM host engine; dcgm-exporter waar de locatie ook Prometheus-kopieën bijhoudt
NVLink scale-upLink-recovery-events, gedegradeerde links binnen een NVL72-domein, storingen in switchtraysMinerva Collector (NVLink-switches)NVLink-tellers per GPU in DCGM als kruiscontrole
Spectrum-X EthernetDrops, PFC-pausestormen, ECN-markering, bufferdruk, flappende links, te warme opticsgNMI-streaming, sysloggNMI-subscriptions en syslog-forwarding op switches; onze syslog-receiver voor bestaande opslag
SuperNICs en DPU'sCongestion-control-events, retransmissies, poortfouten, gezondheid van DPU'sMinerva CollectorBlueField DOCA Telemetry Service waar die al is uitgerold
NCCLTrage of vastgelopen collectives, één rank die achterloopt op de restMinerva Collector (NCCL-telemetrie)Joblogs met NCCL-debugoutput vastgelegd in de logopslag
SchedulersJobs die falen of vastlopen, gedrainde nodes, GPU's toegewezen maar ongebruiktSlurm; Run:aiSlurm-prolog en -epilog voor jobmapping in dcgm-exporter; Kubernetes-metadata
OpslagTrager wordende checkpoint-writes, metadatalatency, clientfoutenOpenTelemetry, JSON, syslogDe exporter van de opslagleverancier, doorgestuurd via onze gateways
WorkloadsStijgende step time, stijgende time to first token, dalende tokendoorvoerOpenTelemetryOpenTelemetry SDK in modelservers en trainingsharnesses
FaciliteitPower capping, afwijkingen in koelmiddeltemperatuur of -debiet, PDU-storingenMinerva Collector in DSX OSIntegratie 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:

  1. 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.
  2. 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.
  3. 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.
  4. 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

Illustratieve incidentcorrelatie: één degraderende optic op leaf-07 veroorzaakt alerts van switch, SuperNIC, NCCL, GPU en scheduler, ongeveer 4.800 in 20 minuten; het doorlopen van de graaf vindt leaf-07 als gedeelde node stroomopwaarts; één incident met prioriteit 2 noemt de oorzaak, een impactgebied van 3 jobs en 288 GPU's, bewijs en een voorgestelde actie; de levenscyclus loopt via detecteren, correleren, notificeren, triage, goedkeuren en herstellen, verifiëren en sluiten.

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:

FaseWat er gebeurtWat we eromheen configureren
DetecterenAnomalie ten opzichte van een geleerde baseline, of overschrijding van een harde drempelBaselineperiode met paging uit (sectie 12)
CorrelerenGerelateerde anomalieën gegroepeerd op topologie en tijdNauwkeurige topologie- en jobmetadata (sectie 4)
NotificerenEén bericht per incident, bijgewerkt naarmate het zich ontwikkeltRoutering per tenant en ernst naar Slack of Teams, PagerDuty en ServiceNow
TriageEngineer beoordeelt oorzaak en impactgebied, kan Sherlock raadplegenRunbooklinks per incidenttype; read-only agenttoegang
Goedkeuren en herstellenVoorgestelde actie goedgekeurd en uitgevoerdChange record, goedkeuringspoort, Ansible-job (sectie 7)
Verifiëren en sluitenSignalen keren terug naar de baseline; incident opgelostAutomatisch 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.
ActieklasseVoorbeeldenWie mag startenGoedkeuring
LezenVragen naar een incident, achterblijvers opsommen, het pad van een job door de fabric tonenSherlock, MCP-clients, engineersGeen; gelogd
AnnoterenEen notitie aan een incident toevoegen, een ticket koppelenSherlock, MCP-clients met write-notes-scopeGeen; gelogd
Omkeerbare operationele wijzigingEen node drainen in Slurm, een job bij het volgende checkpoint verplaatsen, één flappende poort uitschakelenEngineer, of een agent die het voorsteltMet naam genoemde goedkeurder; standaard change record
Verstorende wijzigingNodes herstarten, firmware opnieuw flashen, fabricconfiguratie wijzigenAlleen een engineerNormale 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:

  1. Voorstellen. Het incident bevat een aanbevolen actie en een link naar het runbook; een mens voert het werk uit.
  2. 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.
  3. 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 ObservabilityAIOps with DIY ObservabilityTurnkey
VerzamelingMinerva CollectorMinerva CollectorMinerva Collector
Opslag en dashboardsPrometheus of Mimir en Grafana van de klantGrafana van de klant; Minerva-inzichten erin gevoedEigen dashboards van Minerva; Grafana optioneel
Anomaliedetectie en correlatieEigen regels van de klantMinervaMinerva
Assistent en agentsGeen vanuit MinervaInzichten naar de agentische tools van de klantSherlock plus MCP
IncidentenAlertmanager naar Slack en PagerDutyMinerva naar ServiceNow en PagerDutyMinerva naar ServiceNow, PagerDuty, Slack of Teams
Ons OpenTelemetry-paarMeestal wel, voor labeling en fan-outJa, voor bestaande bronnen en backendsAlleen voor bronnen die niet van NVIDIA zijn
Typische klantVolwassen SRE-team, één clusterEnterprise met een gevestigde toolchainAI-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 replica laat 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_limiter als eerste in elke pipeline, zodat overbelasting tot back-pressure en een CollectorRefusingData-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):

BronAannameActieve series (ca.)
GPU-metrics via dcgm-exporter1.008 GPU's × ~40 velden40.000
NVLink-recoverytellers (per GPU, alle links; Blackwell en nieuwer)1.008 GPU's × 3 tellers3.000
Ethernet-switchpoorten~2.000 poorten × ~25 tellers50.000
Hosts252 compute trays × ~60 series na filtering15.000
Workloads en schedulermetrics voor jobs, diensten en wachtrijen10.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

Gefaseerde uitrol over ongeveer zestien weken: discovery, collectors, baselining zonder paging, afstemming van alerts, read-only inschakelen van agents en herstelautomatisering achter goedkeuringspoorten, elk met een exitpoort, gevolgd door storingsoefeningen bij de overdracht.

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:

  1. 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.
  2. Kill één trainingsrank of throttle één GPU zodat een job achterblijft: de achterblijver wordt benoemd en de eigenaar van de job wordt geïdentificeerd.
  3. Stop één gateway: geen dataverlies, een GatewayRedundancyLost-page, herstel zodra hij terugkomt.
  4. Blokkeer de Minerva-intake vanaf de gateways gedurende 15 minuten: MinervaExportFailing pagt, wachtrijen lopen vol en daarna leeg zonder gat.
  5. Simuleer een koelingsalarm via de faciliteitsintegratie in een testvenster: het incident toont de getroffen racks en jobs.
  6. Keur een drain-playbook goed en voer het uit op een labnode, en voer daarna de rollback uit; beide verschijnen in het change record.
  7. 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 validate in otel/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 met ws: 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 van scontrol, squeue en dcgmi diag zijn 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.

Deel dit artikel

Meer in Technology

AI-developerlaptops: LLM's lokaal draaien onder Linux met GPU's van 16 GB en 24 GB (gids 2026)

AI-developerlaptops: LLM's lokaal draaien onder Linux met GPU's van 16 GB en 24 GB (gids 2026)

Wat er past op een RTX 5080 of RTX 5090 Laptop GPU, de geheugenberekening, de open modellen die de moeite waard zijn, Ubuntu 26.04 inrichten met de NVIDIA-stack, Ollama, llama.cpp en vLLM, codeerassistenten, LoRA-fine-tuning, beveiliging, en wanneer werk naar een server moet

Lees meer
ML- en LLM-systemen testen die u niet correct kunt bewijzen: een Python-kit voor bewijsmateriaal

ML- en LLM-systemen testen die u niet correct kunt bewijzen: een Python-kit voor bewijsmateriaal

Bewijsmateriaal in plaats van bewijzen, in ongeveer 400 regels Python met echte output: slice-metrics met bootstrap-intervallen en een pass/fail-contract, property- en metamorfe tests met Hypothesis, kalibratie en conformal prediction, Pydantic-contracten en regressie-evals voor LLM-output, driftcontroles, een CI-gate en exacte verificatie van een klein neuraal netwerk

Lees meer
TorchCurves in de praktijk: leerbare B-spline- en Legendre-curves in PyTorch

TorchCurves in de praktijk: leerbare B-spline- en Legendre-curves in PyTorch

torchcurves installeren, een curve fitten en dimensioneren, kiezen tussen B-spline en Legendre en de input map, een monotone kalibratiecurve en een additief model op tabeldata bouwen, vergelijken met SciPy, scikit-learn, een KAN en een MLP, coëfficiënten naar JSON exporteren, testen en in productie draaien, met echte output

Lees meer