Der Shop ist online

Wir bauen Workstation AI-Maschinen für Websites, KI-Agenten und LLM-Training – online konfigurieren und kaufen.

Händlerpreise erhalten
KI-Produkte
KI-LabsOpenAI-AgentenClaude-AgentenGrok-BotWorkstation AI-natives CRMMarketingAlle Produkte
KI-Lösungen
Angewandte KIKI-AgentenGenerative KIKI-AutomatisierungKI-WeiterbildungKI-Pakete für KMUEnterprise AI LabKI-WorkstationsNVIDIA-Hardware & -SoftwareNVIDIA Accelerated ComputingPrivate KIGPU-Private-CloudGPU-ClusterEdge-KIKI nach Branche
KI-Services
PlattformmodernisierungDigital EngineeringDatengrundlagen & KIAutonomer BetriebKI-BeratungDevOps-AutomatisierungCybersicherheitSoftwareentwicklungAgentenentwicklungMLOps-EinrichtungGPU-LeasingGPU-Private-Cloud
Über uns
UnternehmenUnsere GeschichtePartnerKundengeschichten
KI-Rechenzentren
KI-RechenzentrenGPU-Private-CloudGPU-ClusterGPU-Leasing
KI-EinblickeJev-ReiheBenchmark LabModellauswahl
Technische Hinweise
Dokumentation
Linux-BetriebssystemeUbuntuRed Hat Enterprise LinuxSUSE LinuxAlpine LinuxDebian, Rocky & AlmaLinux
KI-Cloud-PlattformenAWS & Amazon BedrockGoogle Cloud & Vertex AIMicrosoft Azure & AI FoundryGPU-Clouds & Marktplätze
Private KI-RechenzentrenFür AnwaltskanzleienFür Steuer- und WirtschaftsprüfungskanzleienOn-Premises-PlattformenVollständig abgesicherte Cloud
ToolsRing PromoterJobshout
News
Blog
KontaktAnmelden

KI-Workstations, Multi-Agenten-KI-Software, GPU-Infrastruktur und intelligente Agentenlösungen für moderne Unternehmen.

Kontakt

KI-Lösungen

Angewandte KIKI-AgentenGenerative KIKI-AutomatisierungKI-WeiterbildungKI-Pakete für KMUEnterprise AI LabKI nach Branche

Produkte

Alle ProdukteWorkstation AI-natives CRM & ERPMarketingOpenAI-AgentenRing PromoterJobshout

Unternehmen

Über unsUnternehmenKI-RechenzentrenWarum WorkstationPartnerKundengeschichtenPreiseKontaktTenthMatrix

Ressourcen

KI-EinblickeTechnische HinweiseDokumentationLinux-BetriebssystemeKI-Cloud-PlattformenPrivate KI-RechenzentrenBlogSucheSitemap
Büro Belgien
Workstation SRL, Rue Vanderkindere 34, 1180 Uccle, BrusselsBE 0751.518.683Mo – Fr: 9:00 – 18:00 Uhr MEZ
+32 492 45 67 46
Hauptsitz Großbritannien
77-79 Marlowes, Hemel Hempstead HP1 1LFAnfahrt – Ausfahrt 20 der M25 (Outer London)Handelsregisternr.: 11641870Mo – Fr: 9:00 – 18:00 Uhr GMT
+44 7515 356 146
Büro Indien
#159 Sector 9, Pocket 1, DDA Flats, 110077 Dwarka, New Delhi
+91 98881 98841
Büro Taiwan
3F, No. 2-4, Aisi Rd., Ren'ai Dist., Keelung City 200, Taiwan基隆市仁愛區愛四路2之4號3樓Mo – Fr: 9:00 – 18:00 Uhr Taiwan-Zeit (GMT+8)
+886 926 892 701+32 492 45 67 46
Büro Estland
Aleksander Puškini tn 30-25, 20306 Narva, EstoniaMo - Fr: 9:00 - 18:00 Uhr estnischer Zeit (EET)
+32 492 45 67 46

© 2026 Workstation AI. Alle Rechte vorbehalten.

DatenschutzDatenlöschungCookiesNutzungsbedingungenWebsite-Sitemap

NVIDIA, das NVIDIA-Logo, RTX, RTX PRO, Blackwell, CUDA, NVLink, MGX, Omniverse, Spectrum-X, Quantum, BlueField, DGX und HGX sind Marken und/oder eingetragene Marken der NVIDIA Corporation in den USA und anderen Ländern. AMD, das AMD-Arrow-Logo, EPYC, Instinct, Ryzen und Threadripper sind Marken von Advanced Micro Devices, Inc. Dell und PowerEdge sind Marken der Dell Inc. oder ihrer Tochtergesellschaften. Intel und Xeon sind Marken der Intel Corporation oder ihrer Tochtergesellschaften. AMAX, AceleMax und LiquidMax sind Marken der AMAX Engineering Corporation. Alle anderen Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Inhaber. Wir verwenden sie ausschließlich, um die Produkte zu kennzeichnen, die wir beschreiben, liefern oder unterstützen; ihre Verwendung bedeutet nicht, dass ihre Inhaber uns empfehlen.

Startseite / Technische Hinweise / Technology
AIHardwareObservability

NVIDIA Minerva AIOps in der Praxis: Architektur, Telemetrie, sichere Agenten, Behebung mit Ansible und schrittweise Einführung

Datenfluss und Telemetrieschichten, topologiebewusste Korrelation, Leitplanken für Sherlock und MCP, Closed-Loop-Behebung unter Change Control, drei Referenzarchitekturen, validierte Konfiguration für OpenTelemetry, Prometheus, Alertmanager und Ansible, UK GDPR, Hochverfügbarkeit und Dimensionierung der Collectors sowie ein Einführungs-Runbook

9. November 2026Technology29 min read

Ein Praxisleitfaden für die Einführung von NVIDIA Minerva, der AIOps-Plattform von NVIDIA für KI-Fabriken, und ihre Einbindung in eine bestehende Betriebslandschaft. Er behandelt die Architektur und den Datenfluss, die Telemetriequellen Schicht für Schicht, wie topologiebewusste Korrelation einen Ereignissturm in einen einzigen Vorfall verwandelt, den sicheren Einsatz des Sherlock-Assistenten und des MCP-Servers, Closed-Loop-Behebung mit Ansible unter Change Control, die drei Bezugsmodelle als Referenzarchitekturen, die Integration mit Prometheus, Grafana, dem Elastic Stack, ServiceNow und PagerDuty, On-Premises versus SaaS und UK GDPR, Hochverfügbarkeit und Dimensionierung der Collector-Ebene, ein Runbook für die schrittweise Einführung und die Störungsübungen, die wir bei der Übergabe durchführen. Die geschäftliche Begründung finden Sie im begleitenden Blogbeitrag.

Interaktive Version: siebzehn Beispiel-Dashboards für eine Minerva-Einführung durchsuchen, jeweils mit ihren Signalen und Hinweisen zu Alarmen.

Fünf Telemetrieschichten, Compute, NVLink Scale-up, Spectrum-X Scale-out, Jobs und Facility, speisen die Erfassung, einen Topologie-Wissensgraphen und ML-Korrelation, die Vorfälle an Menschen, Agenten und die Behebung hinter einem Freigabe-Gate liefern.

Zusammenfassung. Minerva erfasst Telemetrie aus allen Schichten einer KI-Fabrik über offene Standards, führt einen Live-Graphen darüber, wie Hardware, Fabrics und Jobs zusammenhängen, lernt Baselines mit maschinellem Lernen und nutzt den Graphen, um zusammengehörige Alarme zu einem Vorfall mit wahrscheinlicher Ursache und Auswirkungsradius zu bündeln. Darum herum setzen wir ausschließlich offene, überprüfbare Komponenten ein: ein OpenTelemetry-Collector-Paar für Quellen und Backends, die der Kunde bereits hat, dcgm-exporter und Slurm-Metadaten, Prometheus-Regeln und Alertmanager für die Überwachung der Überwachung sowie Ansible-Playbooks, die nur hinter einem Freigabe-Gate laufen. Endpunkte, Schemas und Einstellungen auf der Minerva-Seite werden gemäß der Minerva-Dokumentation von NVIDIA konfiguriert; dieser Artikel erfindet sie nicht.
Hinweis zu Umfang und Transparenz. Dieser Artikel wurde auf Grundlage der öffentlichen Produktseite und des Datenblatts von NVIDIA zu Minerva verfasst, nicht auf Grundlage der technischen Dokumentation. Wir beschreiben die Interna, APIs und Konfiguration von Minerva daher nur auf dem Niveau, das NVIDIA veröffentlicht hat, und zeigen keine Minerva-Konfigurationsdateien, CLI-Befehle, Metriknamen oder Preise. Jeder Konfigurationsblock unten betrifft eine offene Komponente rund um Minerva und wurde mit den eigenen Werkzeugen dieser Komponente validiert; siehe Abschnitt 15, Quellen und Hinweise zur Überprüfung.

1. Was Minerva ist, nach NVIDIAs eigener Beschreibung

NVIDIA hat Minerva im Oktober 2026 angekündigt. Die offizielle NVIDIA-Minerva-Seite und das Minerva-Datenblatt sind die maßgeblichen Quellen. In eigenen Worten zusammengefasst sind dies die veröffentlichten Fakten, auf die wir unser Design ausrichten:

ThemaWas NVIDIA angibt (sinngemäß)Was das für das Design bedeutet
PositionierungEine durchgängige AIOps-Plattform, rund um KI konzipiert, und das primäre Observability-Produkt für NVIDIA-KI-Fabriken, einschließlich Vera-Rubin- und Blackwell-Systemen.Betrachten Sie sie als zentrale Vorfallsintelligenz für die GPU-Landschaft, nicht als ein weiteres Dashboard.
TelemetrieumfangGPUs, NVLink-Switches, Spectrum-X Ethernet, SuperNICs, DPUs, NCCL, Scheduler wie Slurm und Run:ai, Storage und KI-Workloads.Planen Sie die Erfassung pro Schicht; siehe Abschnitt 3.
Ingest-StandardsOpenTelemetry, gNMI, Syslog, DCGM, Slurm und JSON.Bestehende OpenTelemetry-Pipelines können an sie weiterleiten; Switches streamen per gNMI.
AnalytikEin dynamischer, topologiebewusster Wissensgraph; ML, das normales Verhalten über Milliarden von Datenpunkten pro Stunde lernt; automatisierte Ursachenanalyse, wenn Jobs hinterherhinken oder fehlschlagen; Rauschunterdrückung, die Ereignisstürme zu einem Vorfall zusammenführt.Liefern Sie ihr genaue Topologie- und Job-Metadaten und dann eine Baselining-Phase, bevor Sie alarmieren.
InteraktionSherlock, ein Multi-Agenten-Assistent für die Triage in natürlicher Sprache auf Live-Telemetrie, und ein MCP-Server, damit Kunden-Agenten sich integrieren können.Steuern Sie den Agentenzugriff wie jede privilegierte API; siehe Abschnitt 6.
AktionBehebungsempfehlungen und Closed-Loop-Behebung; Integrationen mit Slack, Microsoft Teams, ServiceNow, PagerDuty, Ansible, Grafana und Infrastruktur-APIs.Über Change Control leiten; siehe Abschnitt 7.
FacilityDer Minerva Collector ist Teil von NVIDIA DSX OS und liefert eine Sicht von der GPU bis zum Stromnetz, mit korrelierten Facility-Signalen.Bringen Sie Strom und Kühlung in dieselbe Vorfall-Zeitleiste.
BereitstellungOn-Premises oder als SaaS aus der Cloud von NVIDIA; skaliert auf Hunderttausende GPUs; Datensouveränität bleibt gewahrt; offene APIs, modulare Funktionen und Grafana-Integration.Entscheiden Sie das Hosting-Modell früh; siehe Abschnitt 10.
BezugDIY Observability, AIOps mit DIY Observability und Turnkey.Drei Referenzarchitekturen; siehe Abschnitt 8.
ErgebnisseAusgedrückt als GPU-Stunden, Goodput, Verfügbarkeit, MTBI, MTTR und Token-Produktion.Berichten Sie vom ersten Tag an über dieselben KPIs.

Minerva und UFM

Unsere Technote zu UFM, DCGM und OpenTelemetry behandelt NVIDIA Unified Fabric Manager, der InfiniBand-Fabrics verwaltet und überwacht. Die Minerva-Unterlagen von NVIDIA nennen Spectrum-X Ethernet (Scale-out, Scale-across und Scale-in) und NVLink (Scale-up) als Netzwerkumfang und beschreiben, soweit wir gelesen haben, keine Aufnahme von InfiniBand-Daten. An einem gemischten Standort behalten wir UFM als InfiniBand-Fabric-Manager und klären mit NVIDIA für das jeweils eingesetzte Release, wie UFM-Ereignisse und -Telemetrie Minerva erreichen sollen. Bis das geklärt ist, kann die OpenTelemetry-Ebene aus Abschnitt 9 UFM-Daten genau wie in der UFM-Technote an die bestehenden Backends des Kunden liefern.

2. Architektur und Datenfluss

Referenzarchitektur: Quellen von GPU-Knoten, NVLink-Switch-Trays, Spectrum-X-Switches, SuperNICs und DPUs, NCCL und Workloads, Schedulern, Storage und Facility speisen den Minerva Collector und ein optionales OpenTelemetry-Collector-Paar; die Minerva-AIOps-Plattform enthält den Wissensgraphen, ML-Anomalieerkennung, Korrelation, Ursachenanalyse, Sherlock, den MCP-Server und Dashboards; zu den Verbrauchern gehören Grafana, Slack und Teams, PagerDuty und ServiceNow, Kunden-Agenten, Ansible hinter einer Freigabe und der Elastic Stack.

Wir betrachten eine Minerva-Einführung als vier Ebenen. Wenn man sie getrennt hält, lassen sich Zuständigkeit, Sicherheit und Fehlerarten leicht nachvollziehen.

  1. Erfassungsebene. Der Minerva Collector sowie unser optionales OpenTelemetry-Collector-Paar für alles, was der Kunde bereits erfasst oder zusätzlich anderswohin senden muss. Ihre Aufgabe ist es, jedes Signal einmal von der Quelle abzuholen, eine einheitliche Identität hinzuzufügen (Standort, Cluster, Rack, Knoten, Rail, Job), Ausfälle zu überbrücken und weiterzuleiten.
  2. Analyseebene. Minerva selbst: der Wissensgraph, Baselines, Anomalieerkennung, Korrelation, Ursachenanalyse und der Vorfallspeicher. On-Premises läuft es auf Infrastruktur, die wir gemeinsam mit NVIDIA dimensionieren; als SaaS läuft es in der Cloud von NVIDIA.
  3. Interaktionsebene. Die Oberfläche und die Dashboards von Minerva, Sherlock, der MCP-Server für Kunden-Agenten und Grafana, wo der Kunde seine eigenen Ansichten pflegt.
  4. Aktionsebene. Benachrichtigungen (Slack, Teams), Alarmierung und Tickets (PagerDuty, ServiceNow) sowie Automatisierung (Ansible). Alles hier unterliegt dem Change-Prozess des Kunden.

Der Weg eines Signals ist: Quelle, zum Collector (gelabelt und gepuffert), zur Analyseebene (einem Knoten im Graphen zugeordnet, mit seiner Baseline verglichen), zu einem Vorfall (mit zugehörigen Anomalien gruppiert), zu Menschen und Agenten (einmal benachrichtigt, mit Kontext) und möglicherweise zu einer freigegebenen Aktion, deren Ergebnis als Telemetrie zurückfließt, sodass der Vorfall überprüft und geschlossen werden kann.

3. Telemetriequellen, Schicht für Schicht

Die Tabelle nennt für jede Schicht, was dort schiefgeht, den Ingest-Standard, den NVIDIA dafür angibt, und die offenen Komponenten, die wir darum herum einsetzen oder prüfen. Wo wir „Minerva Collector“ schreiben, wird die Aktivierung dieser Quelle gemäß der Minerva-Dokumentation von NVIDIA konfiguriert.

SchichtTypische FehlerVon NVIDIA genannter Ingest-WegOffene Komponenten, die wir einsetzen oder prüfen
GPU (Compute)XID-Fehler, ECC- und Row-Remap-Ereignisse, thermische oder leistungsbedingte Drosselung, untätige GPUs in laufenden JobsDCGMDCGM Host Engine; dcgm-exporter, wo der Standort zusätzlich Prometheus-Kopien vorhält
NVLink Scale-upLink-Recovery-Ereignisse, degradierte Links innerhalb einer NVL72-Domäne, Fehler an Switch-TraysMinerva Collector (NVLink-Switches)DCGM-NVLink-Zähler pro GPU als Gegenprüfung
Spectrum-X EthernetPaketverluste, PFC-Pause-Stürme, ECN-Markierung, Pufferdruck, flatternde Links, überhitzte OptikengNMI-Streaming, SysloggNMI-Subscriptions der Switches und Syslog-Weiterleitung; unser Syslog-Receiver für bestehende Speicher
SuperNICs und DPUsEreignisse der Überlastkontrolle, Retransmits, Port-Fehler, DPU-ZustandMinerva CollectorBlueField DOCA Telemetry Service, wo bereits eingesetzt
NCCLLangsame oder hängende Collectives, ein Rank, der hinter den anderen zurückbleibtMinerva Collector (NCCL-Telemetrie)Job-Logs mit NCCL-Debug-Ausgabe, im Log-Speicher erfasst
SchedulerJobs, die fehlschlagen oder hängen, gedrainte Knoten, zugewiesene, aber untätige GPUsSlurm; Run:aiSlurm-Prolog und -Epilog für das Job-Mapping von dcgm-exporter; Kubernetes-Metadaten
StorageLangsamer werdende Checkpoint-Schreibvorgänge, Metadaten-Latenz, Client-FehlerOpenTelemetry, JSON, SyslogDer Exporter des Storage-Herstellers, über unsere Gateways weitergeleitet
WorkloadsSteigende Step-Zeit, steigende Time to First Token, sinkender Token-DurchsatzOpenTelemetryOpenTelemetry SDK in Modellservern und Trainings-Harnesses
FacilityLeistungsbegrenzung, Abweichungen bei Kühlmitteltemperatur oder -durchfluss, PDU-FehlerMinerva Collector in DSX OSIntegration der Gebäudeleittechnik, konfiguriert gemäß der DSX-OS-Dokumentation von NVIDIA

GPUs: DCGM und dcgm-exporter

DCGM ist der Dienst für GPU-Zustand und -Telemetrie, den NVIDIA als Minerva-Quelle nennt. Wo ein Kunde GPU-Metriken zusätzlich in seinem eigenen Prometheus vorhält, betreiben wir außerdem dcgm-exporter. Beachten Sie, dass dcgm-exporter 4.9.0 seine Standardmetriken umbenannt und mehrere Einheiten geändert hat (die Auslastung wurde zu einem Verhältnis von 0 bis 1, der Speicher zu Bytes); die vollständige Tabelle und ein überbrückender Satz von Recording Rules stehen in unserer Technote zu UFM und DCGM. Sämtliches PromQL in diesem Artikel verwendet die Namen aus 4.9.0.

Spectrum-X-Switches: gNMI und Syslog

gNMI ist das OpenConfig-gRPC-Protokoll für Streaming-Telemetrie von Netzwerkgeräten. Allgemein abonnieren wir Schnittstellenzähler im Sample-Modus mit festem Intervall und Betriebszustände (Link aktiv oder inaktiv, Transceiver-Alarme) bei Änderung, was die Last niedrig hält und Zustandsänderungen sofort sichtbar macht. Welche Pfade Minerva abonniert und ob es sich bei den Switches einwählt oder diese sich bei ihm einwählen, wird gemäß der Dokumentation von NVIDIA und dem Handbuch des Switch-Betriebssystems festgelegt; wir stellen nur sicher, dass Managementnetz, Zertifikate und Zugriffslisten es zulassen. Syslog von jedem Switch geht ebenfalls an den Collector, weil Flaps und Transceiver-Alarme dort oft zuerst auftauchen.

Scheduler: Slurm und Run:ai

Die Korrelation ist nur so gut wie die Zuordnung von Jobs zu Hardware. Für Slurm bestätigen wir, dass Metadaten zu Job, Benutzer, Partition und Knotenliste Minerva so erreichen, wie NVIDIA es dokumentiert, und wir nutzen Slurm-Prolog und -Epilog, um das HPC-Job-Mapping von dcgm-exporter zu pflegen, sodass GPU-Zeitreihen im eigenen Prometheus des Kunden ein hpc_job-Label tragen. Für Run:ai und Kubernetes prüfen wir, dass Workload- und Projektnamen durchgereicht werden. Benutzernamen sind personenbezogene Daten; in Abschnitt 10 lesen Sie, wie wir sie pseudonymisieren, wenn sie den Standort verlassen.

Workloads: OpenTelemetry SDK

Modellserver und Trainings-Harnesses, die mit dem OpenTelemetry SDK instrumentiert sind, senden Traces und Metriken per OTLP an das Gateway-Paar, das sie an Minerva und, falls der Kunde es wünscht, an seinen eigenen Trace-Speicher weiterleitet. Die wichtigsten Signale sind beim Training Step-Zeit und Wartezeit des Data Loaders, bei der Inferenz Wartezeit in der Queue, Time to First Token und Tokens pro Sekunde.

4. Der Wissensgraph und topologiebewusste Korrelation

NVIDIA hat die internen Algorithmen von Minerva in den Unterlagen, die wir gelesen haben, nicht veröffentlicht; dieser Abschnitt erklärt die Idee daher allgemein, und genau das brauchen Betreiber, um das System gut zu versorgen.

Ein Wissensgraph ist hier ein Live-Modell der Landschaft: Entitäten (GPUs, NVLink-Switch-Trays, Knoten, NICs, Switch-Ports, Switches, Racks, Stromzuführungen, Storage-Ziele, Jobs, Mandanten) und Beziehungen zwischen ihnen (diese GPU steckt in diesem Knoten; dieser NIC-Port ist mit jenem Leaf-Port verkabelt; dieser Job läuft auf diesen 72 GPUs; dieses Rack bezieht Strom aus jener Zuführung). Beziehungen ändern sich im Laufe der Zeit, insbesondere die Platzierung von Jobs, daher hat jede einen Zeitbereich.

Die Korrelation funktioniert dann ungefähr so:

  1. Anomalien werden Entitäten zugeordnet. Ein Anstieg der FEC-Korrekturen gehört zu einem Switch-Port; ein langsames All-Reduce gehört zu einem Job; ein Einbruch der Auslastung gehört zu einer GPU.
  2. Zeitlich nahe Anomalien werden auf einen gemeinsamen Pfad im Graphen geprüft. Wenn die GPUs des langsamen Jobs die Fabric alle über NICs erreichen, die mit einem Leaf verkabelt sind, und dieses Leaf einen sich verschlechternden Port hat, ist der Port ein Kandidat für die Ursache, und alles stromabwärts ist ein Symptom.
  3. Kandidaten werden gewichtet. Es zählen die Position stromaufwärts, wie früh die Anomalie begann, wie weit sie von der Baseline abweicht und wie viele Symptome sie erklärt.
  4. Der Auswirkungsradius wird berechnet, indem der Graph stromabwärts durchlaufen wird: Welche Jobs, Mandanten und GPUs hängen gerade von der verdächtigen Komponente ab?

Daraus folgen zwei praktische Konsequenzen. Erstens ist die Genauigkeit der Topologie eine Voraussetzung: Ein nicht verkabelter oder falsch beschrifteter Port im Inventar erzeugt falsche Ursachen. Wir validieren den Verkabelungsplan vor dem Baselining gegen LLDP und die eigene Sicht der Switches. Zweitens müssen Job-Metadaten zeitnah sein: Wenn die Job-Platzierung Minuten zu spät eintrifft, lassen sich Symptome nicht dem Job zuordnen, dem sie schaden.

5. Rauschunterdrückung und der Lebenszyklus eines Vorfalls

Beispielhafte Vorfallskorrelation: Eine einzige sich verschlechternde Optik an leaf-07 erzeugt Switch-, SuperNIC-, NCCL-, GPU- und Scheduler-Alarme, etwa 4.800 in 20 Minuten; das Durchlaufen des Graphen findet leaf-07 als gemeinsamen Knoten stromaufwärts; ein Vorfall der Priorität 2 nennt die Ursache, einen Auswirkungsradius von 3 Jobs und 288 GPUs, Belege und eine empfohlene Aktion; der Lebenszyklus verläuft über Erkennen, Korrelieren, Benachrichtigen, Triage, Freigeben und Beheben, Überprüfen und Schließen.

In einer großen KI-Fabric kann ein einziger physischer Fehler Tausende von Alarmen auslösen, weil jede GPU, jede NIC und jeder Job, der damit in Berührung kommt, sein eigenes Symptom meldet. NVIDIA beschreibt, dass Minerva diese zu einem priorisierten Vorfall mit Kontext bündelt, der an Werkzeuge wie Slack oder ServiceNow geliefert wird. Unsere Aufgabe ist es, diesen Vorfallsablauf an das Betriebsmodell des Kunden anzupassen:

PhaseWas passiertWas wir darum herum konfigurieren
ErkennenAnomalie gegenüber der gelernten Baseline oder Überschreitung eines festen SchwellenwertsBaselining-Phase mit abgeschalteter Alarmierung (Abschnitt 12)
KorrelierenZusammengehörige Anomalien werden nach Topologie und Zeit gruppiertGenaue Topologie- und Job-Metadaten (Abschnitt 4)
BenachrichtigenEine Nachricht pro Vorfall, aktualisiert, während er sich entwickeltRouting pro Mandant und Schweregrad an Slack oder Teams, PagerDuty und ServiceNow
TriageEin Engineer prüft Ursache und Auswirkungsradius, fragt eventuell SherlockRunbook-Links pro Vorfallstyp; schreibgeschützter Agentenzugriff
Freigeben und behebenEmpfohlene Aktion wird freigegeben und ausgeführtChange-Eintrag, Freigabe-Gate, Ansible-Job (Abschnitt 7)
Überprüfen und schließenSignale kehren zur Baseline zurück; Vorfall gelöstAutomatisches Auflösen in ServiceNow und PagerDuty; Nachbetrachtung des Vorfalls

Doppelte Alarmierung vermeiden

Wenn Minerva die Korrelation übernimmt, dürfen die bestehenden symptombezogenen Alarme des Kunden für dieselbe Hardware nicht zusätzlich alarmieren. Unsere Faustregel: In den Modellen AIOps und Turnkey werden bestehende Prometheus-Alarme für GPU-, NIC- und Switch-Symptome auf den Schweregrad ticket herabgestuft (oder unterdrückt), und nur Alarme zur Überwachung selbst, etwa Ausfälle von Collector und Intake, behalten page. Prüfen Sie bei ServiceNow und PagerDuty, dass die von Minerva gesendete Vorfallskennung als Deduplizierungsschlüssel verwendet wird, damit Aktualisierungen eines Vorfalls nie ein zweites Ticket öffnen; wie Minerva dieses Feld befüllt, wird gemäß der Dokumentation von NVIDIA konfiguriert.

6. Sherlock und MCP: Agenten sicher einsetzen

Sherlock ist der Multi-Agenten-Assistent von Minerva für die Triage in natürlicher Sprache, und der MCP-Server erlaubt den eigenen Agenten des Kunden, Minerva Fragen zu stellen. Beide sind mächtig, weil sie die gesamte Landschaft sehen. Wir behandeln sie als privilegierte Schnittstellen und wenden dieselben Kontrollen an wie bei jedem Automatisierungskonto:

  • Standardmäßig schreibgeschützt. Agenten erhalten zunächst nur Zugriff zum Abfragen von Telemetrie, Vorfällen und Topologie. In der ersten Phase einer Einführung hat keine Agentenidentität Rechte, Infrastruktur zu verändern.
  • Getrennte Identitäten. Jeder Agent und jede Integration verwendet eine eigene Dienstidentität mit eigenem Berechtigungsumfang, nie ein gemeinsames Administratorkonto, damit Aktionen zurechenbar und widerrufbar sind.
  • Freigabe-Gates für alles, was einen Zustand ändert. Ein Agent darf ein Drain, das Abschalten eines Ports oder einen Neustart vorschlagen; eine namentlich benannte Person gibt es frei, und die Ausführung erfolgt über die Change-kontrollierte Automatisierung aus Abschnitt 7, nicht über die eigenen Zugangsdaten des Agenten.
  • Telemetrie als nicht vertrauenswürdige Eingabe behandeln. Job-Namen, Logzeilen und Hostnamen können von Benutzern geschriebenen Text enthalten. Ein Agent, der sie liest, kann durch darin platzierte Anweisungen gesteuert werden. Agenten dürfen keine Aktionen aufgrund von Text ausführen, der in Telemetrie gefunden wurde, und Tool-Berechtigungen müssen serverseitig durchgesetzt werden, nicht über den Prompt.
  • Jede Unterhaltung und jeden Tool-Aufruf protokollieren, im Audit-Speicher, mit Identität, Frage, verwendeten Tools und Antwort. Prüfen Sie in den ersten Monaten wöchentlich eine Stichprobe.
  • Geheimnisse aus dem Kontext heraushalten. Zugangsdaten erscheinen nie in Prompts, Antworten oder Tool-Ausgaben; begrenzen Sie MCP-Tools so, dass sie sie nicht zurückgeben können.
  • Rate Limits und Budgets. Begrenzen Sie, wie viele Abfragen ein Agent pro Minute stellen kann, damit ein in einer Schleife hängender Agent die Plattform nicht belasten kann.
AktionsklasseBeispieleWer auslösen darfFreigabe
LesenNach einem Vorfall fragen, Nachzügler auflisten, den Pfad eines Jobs durch die Fabric anzeigenSherlock, MCP-Clients, EngineersKeine; protokolliert
AnnotierenEine Notiz zu einem Vorfall hinzufügen, ein Ticket verknüpfenSherlock, MCP-Clients mit Berechtigung zum Schreiben von NotizenKeine; protokolliert
Reversible betriebliche ÄnderungEinen Knoten in Slurm drainen, einen Job beim nächsten Checkpoint verschieben, einen einzelnen flatternden Port abschaltenEngineer oder ein vorschlagender AgentNamentlich benannte freigebende Person; Standard-Change-Eintrag
Störende ÄnderungKnoten neu starten, Firmware neu flashen, Fabric-Konfiguration ändernNur EngineersNormaler Change mit CAB-Freigabe und Wartungsfenster

7. Closed-Loop-Behebung mit Ansible und Change Control

NVIDIA beschreibt, dass Minerva Korrekturen empfiehlt und den Kreis über Integrationen wie Ansible schließt. Wir führen Automatisierung in drei Stufen ein, und ein Kunde steigt erst dann eine Stufe auf, wenn die vorherige eine saubere Bilanz hat:

  1. Vorschlagen. Der Vorfall enthält eine empfohlene Aktion und einen Link zum Runbook; ein Mensch erledigt die Arbeit.
  2. Ausführung freigeben. Die empfohlene Aktion entspricht einem vorab geschriebenen Ansible-Playbook im Automatisierungs-Controller (AWX oder Red Hat Ansible Automation Platform). Ein Freigabeschritt im Workflow, verknüpft mit einem ServiceNow-Standard-Change, lässt eine namentlich benannte freigebende Person es mit einem Klick ausführen.
  3. Vorab freigegebene Standard-Changes. Eine kurze Liste risikoarmer, reversibler Aktionen, etwa das Drainen eines Knotens mit wiederholten XID-Fehlern, läuft ohne menschlichen Klick, aber weiterhin unter einer Standard-Change-Vorlage und weiterhin protokolliert. Störende Aktionen erreichen diese Stufe nie.

Wie Minerva eine Aktion an den Automatisierungs-Controller übergibt (Webhook, API-Aufruf oder ServiceNow-Trigger), wird gemäß der Minerva-Dokumentation von NVIDIA konfiguriert. Das Playbook selbst stammt von uns und ist bewusst defensiv: Es verweigert die Ausführung ohne Change- und Vorfallsreferenz, drainiert statt abzubrechen, wartet auf laufende Jobs, führt eine DCGM-Diagnose aus und lässt den Knoten im Drain-Zustand, damit ein Engineer ihn wieder freigibt.

# 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"

Jedes Playbook in der Bibliothek hat ein passendes Rollback (hier scontrol update nodename=... state=resume nach der Prüfung durch einen Engineer), einen im Labor getesteten Dry-Run-Modus und eine verantwortliche Person. Das Job-Log des Automatisierungs-Controllers wird automatisch an den Change-Eintrag angehängt.

8. Die drei Bezugsmodelle als Referenzarchitekturen

DIY ObservabilityAIOps mit DIY ObservabilityTurnkey
ErfassungMinerva CollectorMinerva CollectorMinerva Collector
Speicherung und DashboardsPrometheus oder Mimir und Grafana des KundenGrafana des Kunden; Minerva-Erkenntnisse werden eingespeistEigene Dashboards von Minerva; Grafana optional
Anomalieerkennung und KorrelationEigene Regeln des KundenMinervaMinerva
Assistent und AgentenKeine von MinervaErkenntnisse an die agentischen Werkzeuge des KundenSherlock plus MCP
VorfälleAlertmanager an Slack und PagerDutyMinerva an ServiceNow und PagerDutyMinerva an ServiceNow, PagerDuty, Slack oder Teams
Unser OpenTelemetry-PaarMeist ja, für Labeling und VerteilungJa, für bestehende Quellen und BackendsNur für Quellen, die nicht von NVIDIA stammen
Typischer KundeErfahrenes SRE-Team, ein einzelner ClusterUnternehmen mit etablierter ToolchainKI-Fabrik oder Neocloud

DIY Observability. Der Collector speist den Prometheus-kompatiblen Speicher des Kunden. Wir setzen die Prometheus-Regeln und Alertmanager-Routen aus Abschnitt 9, die Grafana-Dashboards aus der begleitenden Galerie und das Labeling-Schema aus der UFM-Technote ein. Die Korrelation liegt beim Kunden; Minerva liefert ihm einheitliche, auf NVIDIA abgestimmte Daten.

AIOps mit DIY Observability. Wie oben, plus die Analytik von Minerva. Die Designarbeit liegt in der Deduplizierung (Abschnitt 5), im Routing von Vorfällen in die richtigen ServiceNow-Zuweisungsgruppen und darin, die Erkenntnisse von Minerva neben bestehenden Grafana-Panels anzuzeigen, damit Engineers nicht zwischen Werkzeugen wechseln müssen.

Turnkey. Minerva ist die primäre Betriebskonsole. Wir behalten trotzdem ein unabhängiges, minimales Prometheus, das die Collectors, den Minerva-Intake und den Dead Man's Switch überwacht, denn eine Monitoring-Plattform darf nicht das Einzige sein, das sich selbst überwacht.

9. Integration mit Prometheus, Grafana, Elastic, ServiceNow und PagerDuty

Das OpenTelemetry-Gateway-Paar

Wo der Kunde bereits Quellen hat, die der Minerva Collector nicht abdeckt, oder eine Kopie in seinen eigenen Backends vorhalten muss, betreiben wir pro Standort zwei OpenTelemetry-Collector-Gateways hinter einem DNS-Namen. Diese Konfiguration leitet an einen Minerva-OTLP-Intake sowie an Mimir und Elasticsearch des Kunden weiter, versieht alles mit Standort- und Cluster-Labels, entfernt bekannte Attribute mit hoher Kardinalität und sensible Attribute und pseudonymisiert Slurm-Benutzernamen, bevor Daten den Standort verlassen. Der Endpunkt otlp/minerva, seine Authentifizierung und welche Signale er akzeptiert, sind Platzhalter, die gemäß der Minerva-Dokumentation von NVIDIA zu konfigurieren sind.

# /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

Validiert mit otelcol-contrib validate aus dem Image otel/opentelemetry-collector-contrib:0.165.0. Hinweise zu den Entscheidungen:

  • Festplattengestützte Queue für den Minerva-Exporter, damit ein Minerva-Upgrade oder eine Netzwerkunterbrechung keine Daten verliert; dimensionieren Sie das Volume für mindestens eine Stunde Spitzendurchsatz.
  • Das externe Label replica erlaubt Mimir, die Scrapes der beiden Gateways mit seinem HA-Tracker zu deduplizieren, wie in der UFM-Technote.
  • Agenten auf Knoten (falls verwendet) senden per OTLP an das Gateway-Paar; die Agentenkonfiguration aus der UFM-Technote gilt unverändert.

Prometheus-Regeln für die Ausbeute und für die Collector-Ebene

Diese Recording Rules liefern dem Kunden eigene Zahlen zu GPU-Stunden und Auslastungsquote, nützlich, um die Berichte von Minerva unabhängig zu überprüfen, und die Alarme überwachen die Collector-Ebene und den Minerva-Intake. Validiert mit 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 an Slack und PagerDuty

Für die Alarme, die das Prometheus des Kunden weiterhin auslöst (hauptsächlich die Überwachung der Überwachung), alarmiert Alertmanager über PagerDuty und postet in Slack, wobei der Dead Man's Switch an einen externen Heartbeat-Dienst geht. Validiert mit 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 und der Elastic Stack

  • Grafana. NVIDIA nennt eine Grafana-Integration. In den Modellen DIY und AIOps behält das Grafana des Kunden seine Dashboards; wir ergänzen die Ansichten aus der begleitenden Galerie und, wo Minerva sie gemäß der Dokumentation von NVIDIA bereitstellt, Panels oder Links für Minerva-Vorfälle neben den Rohsignalen.
  • Elastic. Logs gehen in einen primären Speicher. Ist der Log-Speicher des Kunden Elasticsearch, schreibt das Gateway dort ECS-konforme Dokumente und leitet dieselben Logs an Minerva weiter; wir betreiben keinen zweiten Log-Speicher nur für KI-Hardware.
  • ServiceNow und PagerDuty. NVIDIA nennt beide als Integrationen. Wir bilden die Minerva-Priorität auf Auswirkung und Dringlichkeit in ServiceNow ab, legen Zuweisungsgruppen pro Schicht fest (Compute, Fabric, Plattform, Facility) und bestätigen das Verhalten des Deduplizierungsschlüssels aus Abschnitt 5.

10. On-Premises oder SaaS, und UK GDPR

NVIDIA bietet Minerva On-Premises oder als SaaS aus seiner Cloud an und betont die Datensouveränität. Telemetrie wirkt technisch, aber Teile davon sind personenbezogene Daten im Sinne der UK GDPR: Benutzernamen aus Slurm und Run:ai, Job-Namen mit Personennamen, E-Mail-Adressen im Scheduler-Accounting und die Fragen, die Engineers in Sherlock eintippen. Unsere Checkliste:

  • Die Rollenverteilung festlegen. On-Premises ist der Kunde Verantwortlicher, und seine Mitarbeitenden und wir verarbeiten nach seinen Weisungen. Bei SaaS müssen die Rolle von NVIDIA und die Bedingungen für den gehosteten Dienst vom Datenschutzbeauftragten des Kunden geprüft werden.
  • Eine DSFA durchführen, wo Telemetrie Aktivitäten identifizierbaren Forschenden oder Mitarbeitenden zuordnet, besonders wenn sie für Leistungsbeurteilung oder interne Verrechnung genutzt wird.
  • Am Rand minimieren und pseudonymisieren. Hashen Sie Benutzernamen am Gateway (wie in der Konfiguration oben), entfernen Sie nicht benötigte Freitextfelder und behalten Sie die Zuordnungstabelle vor Ort.
  • Internationale Übermittlungen. Liegt eine SaaS-Region außerhalb des Vereinigten Königreichs, bestätigen Sie den Übermittlungsmechanismus (britische Angemessenheitsregelungen oder das International Data Transfer Agreement bzw. Addendum), bevor Daten fließen.
  • Aufbewahrung. Legen Sie die Aufbewahrung pro Signaltyp fest: hochaufgelöste Telemetrie für Wochen, Vorfälle und Aggregate länger, Protokolle von Agenten-Unterhaltungen gemäß der Audit-Richtlinie des Kunden.
  • Zugriff. Single Sign-on mit rollenbasiertem Zugriff; Mandanten in einer Neocloud sehen nur ihre eigenen Jobs und Vorfälle.

Für Kunden aus dem britischen öffentlichen Sektor, aus verteidigungsnaher Forschung und aus regulierten Finanzdienstleistungen wählen wir standardmäßig On-Premises; das ist die Konfiguration, die wir im Einführungsplan beschreiben.

11. Hochverfügbarkeit und Dimensionierung der Collector-Ebene

Hochverfügbarkeit und Dimensionierung von Minerva selbst werden von NVIDIA festgelegt. In unserer Verantwortung liegt die Erfassungsebene darum herum, und sie darf nicht zum schwächsten Glied werden.

  • Mindestens zwei Gateways pro Standort, in verschiedenen Racks an verschiedenen Stromzuführungen, hinter einem DNS-Namen oder Load Balancer. Agenten und Switches wiederholen ihre Versuche bei dem, das gerade verfügbar ist.
  • Festplattengestützte Queues an jedem Exporter, auf lokalem NVMe, dimensioniert für mindestens eine Stunde Spitzendurchsatz.
  • memory_limiter an erster Stelle in jeder Pipeline, damit Überlast zu Gegendruck und einem CollectorRefusingData-Alarm führt statt zu einem Absturz wegen Speichermangels.
  • Getrennte Fehlerdomänen für Überwachung und Überwachtes. Gateways laufen auf Management-Knoten, nicht auf den GPU-Knoten, die sie überwachen.
  • Unabhängiger Beobachter. Ein kleines Prometheus außerhalb des Haupt-Stacks scrapt den Zustand der Gateways und den Minerva-Intake, und der Watchdog-Alarm belegt den Alarmpfad von Ende zu Ende.

Eine Dimensionierungsschätzung für das Beispiel mit rund 1.000 GPUs aus dem Blog (vierzehn NVL72-Racks, zur Veranschaulichung):

QuelleAnnahmeAktive Zeitreihen (ca.)
GPU-Metriken über dcgm-exporter1.008 GPUs × ~40 Felder40.000
NVLink-Recovery-Zähler (pro GPU, alle Links; Blackwell und neuer)1.008 GPUs × 3 Zähler3.000
Ethernet-Switch-Ports~2.000 Ports × ~25 Zähler50.000
Hosts252 Compute-Trays × ~60 Zeitreihen nach Filterung15.000
Workloads und SchedulerJob-, Service- und Queue-Metriken10.000 bis 30.000
Gesamt für den eigenen Speicher des Kunden~120.000 bis 140.000

Bei einem Intervall von 15 bis 30 Sekunden sind das etwa 4.000 bis 9.500 Samples pro Sekunde, problemlos zu bewältigen von einem einzigen Paar bescheidener Gateways (wir starten mit je 8 vCPU und 16 GB und führen vor dem Go-live Lasttests durch). Die Zahlen schließen nicht ein, was Minerva direkt erfasst; das dimensioniert NVIDIA. Mit wachsenden Fabrics dominieren die Zeitreihen der Switch-Ports, daher sind Keep-Lists für Switch-Zähler die wirksamste Kostenkontrolle, genau wie bei UFM.

12. Deployment-Runbook: eine schrittweise Einführung

Schrittweise Einführung über etwa sechzehn Wochen: Bestandsaufnahme, Collectors, Baselining ohne Alarmierung, Alarm-Tuning, schreibgeschützte Aktivierung der Agenten und Behebungsautomatisierung hinter Freigabe-Gates, jeweils mit einem Abschluss-Gate, gefolgt von Störungsübungen bei der Übergabe.

Phase 1: Bestandsaufnahme (Wochen 1 bis 2)

  • Jede Quelle nach Schicht inventarisieren (Abschnitt 3), mit Verantwortlichen, Versionen und Management-Adressen.
  • Bezugsmodell, Hosting-Modell und Datenschutzposition vereinbaren.
  • Den Verkabelungsplan einholen und gegen LLDP und den Switch-Zustand validieren.
  • Eine RACI vereinbaren: wer für Minerva, die Collectors, jede Integration und jedes Playbook verantwortlich ist.
  • Abschluss-Gate: unterzeichnetes Quelleninventar und Design.

Phase 2: Collectors und Integrationen (Wochen 2 bis 5)

  • Den Minerva Collector gemäß der Dokumentation von NVIDIA installieren; Quellen Schicht für Schicht aktivieren.
  • Bei Bedarf das OpenTelemetry-Gateway-Paar einsetzen; die Konfiguration in CI mit otelcol-contrib validate validieren.
  • Slurm- oder Run:ai-Metadaten anbinden; die Zuordnung von Jobs zu GPUs an einem Testjob bestätigen.
  • Slack oder Teams, ServiceNow und PagerDuty in einem Testmodus anbinden, der nicht alarmiert.
  • Abschluss-Gate: Jede Schicht meldet, und die Topologie in Minerva stimmt mit dem validierten Verkabelungsplan überein.

Phase 3: Baselining (Wochen 4 bis 8)

  • Repräsentative Workloads ausführen: große Trainingsjobs, Inferenz unter Spitzenlast, Checkpoint-Stürme.
  • Minerva lernt Baselines; seine Vorfälle gehen nur an einen Prüfkanal.
  • Die bestehende Alarmierung bleibt unverändert, sodass nichts verloren geht.
  • Abschluss-Gate: Baselines zwei Wochen lang stabil, und geprüfte Vorfälle überwiegend als korrekt beurteilt.

Phase 4: Alarm-Tuning und Rauschunterdrückung (Wochen 7 bis 10)

  • Prioritäten, Routing und Zuweisungsgruppen festlegen; Alarmierung für Priorität 1 und 2 einschalten.
  • Sich überschneidende Altalarme herabstufen oder unterdrücken (Abschnitt 5).
  • Rohalarme pro Vorfall und Alarmierungen pro Woche als KPIs verfolgen.
  • Abschluss-Gate: das vereinbarte Rauschziel, zum Beispiel weniger als 20 Alarmierungen pro Woche, ohne verpassten Vorfall der Priorität 1 in Übungen.

Phase 5: Aktivierung der Agenten (Wochen 9 bis 12)

  • Sherlock für das Betriebsteam aktivieren, schreibgeschützt.
  • Kunden-Agenten beim MCP-Server mit eigenen Identitäten und schreibgeschützten Berechtigungen registrieren.
  • Audit-Logging einschalten und wöchentlich Stichproben prüfen.
  • Abschluss-Gate: Sicherheitsprüfung abgenommen; kein Agent hat Änderungsrechte.

Phase 6: Behebungsautomatisierung (Wochen 11 bis 16)

  • Die Playbook-Bibliothek mit Rollback, Verantwortlichen und Dry-Run-Tests aufbauen.
  • Freigabeschritte mit ServiceNow-Standard-Changes verknüpfen; auf Stufe 2 („Ausführung freigeben“) beginnen.
  • Einzelne Playbooks erst nach einer sauberen Bilanz zu vorab freigegebenen Standard-Changes hochstufen.
  • Abschluss-Gate: Nur freigegebene Runbooks sind aufrufbar, und jeder Lauf ist an einen Change-Eintrag angehängt.

13. Störungsübungen bei der Übergabe

Wir übergeben keinen Vorfallsablauf, den wir nicht haben funktionieren sehen. Im Beisein des Kunden führen wir Folgendes durch und zeichnen es auf:

  1. Eine Optik ziehen an einer Leaf-zu-Spine-Verbindung während eines Testjobs: ein Vorfall, korrekte Ursache, korrekter Auswirkungsradius, eine Alarmierung, ServiceNow-Ticket geöffnet und später automatisch gelöst.
  2. Einen Trainings-Rank beenden oder eine GPU drosseln, sodass ein Job hinterherhinkt: Der Nachzügler wird benannt, und der Eigentümer des Jobs wird identifiziert.
  3. Ein Gateway stoppen: kein Datenverlust, eine GatewayRedundancyLost-Alarmierung, Wiederherstellung, wenn es zurückkehrt.
  4. Den Minerva-Intake blockieren, 15 Minuten lang von den Gateways aus: MinervaExportFailing alarmiert, die Queues füllen sich und leeren sich danach ohne Lücke.
  5. Einen Kühlungsalarm simulieren über die Facility-Integration in einem Testfenster: Der Vorfall zeigt betroffene Racks und Jobs.
  6. Ein Drain-Playbook freigeben und ausführen gegen einen Laborknoten, dann sein Rollback ausführen; beides erscheint im Change-Eintrag.
  7. Sherlock um eine Änderung bitten: Es kann die Aktion beschreiben, aber nicht ausführen.

14. Wie Workstation das umsetzt und betreibt

Workstation ist NVIDIA-Partner und stellt deshalb neben der Hardware Engineering, Software und Personal bereit, um KI-Rechenzentren durchgängig aufzubauen und zu betreiben: Design, Installation, Inbetriebnahme der Fabric, Einrichtung von Minerva und Observability und die Engineers, die das Ganze danach gemeinsam mit Ihnen betreiben.

  • Lieferung: Minerva-Lizenzen, Vera Rubin NVL72 und andere GPU-Systeme, Spectrum-X Ethernet, SuperNICs und DPUs, gemeinsam spezifiziert.
  • Aufbau: Collectors, die OpenTelemetry-Ebene, Integrationen mit Ihren Werkzeugen, Scheduler-Metadaten, die Playbook-Bibliothek und der Freigabe-Workflow, alles aus versionierter Konfiguration.
  • Betrieb: Support für Minerva und die umgebenden Softwaredienste, Rausch-Tuning, Upgrades, Kapazitätsplanung für die Collector-Ebene und ein monatlicher Bericht zu GPU-Stunden, Goodput, MTBI, MTTR und Alarmierungen pro Woche.

Sehen Sie sich NVIDIA Minerva in unserem Shop an, oder fragen Sie unseren KI-Sales-Engineer nach einem Gespräch zur Dimensionierung.

15. Quellen und Hinweise zur Überprüfung

  • Fakten zu Minerva (Umfang, Ingest-Standards, Wissensgraph, ML, Sherlock, MCP, Integrationen, DSX OS, Bereitstellungs- und Bezugsmodelle, KPIs): die offizielle Seite NVIDIA Minerva, gelesen im November 2026, und die Einstiegsseite zum Minerva-Datenblatt. Alle Formulierungen hier sind unsere eigene Zusammenfassung.
  • Nicht überprüft: die technische Dokumentation von Minerva, APIs, Konfigurationsformate, Metriknamen, interne Algorithmen, HA-Design, Dimensionierung, Preise und Lizenzierung. Überall, wo wir „gemäß der Minerva-Dokumentation von NVIDIA konfiguriert“ schreiben, ziehen Sie diese Dokumentation für das Release heran, das Sie einsetzen. Wie Minerva und UFM an InfiniBand-Standorten zusammenspielen, ist pro Release mit NVIDIA zu klären.
  • OpenTelemetry Collector, Gateway-Konfiguration: validiert mit otelcol-contrib validate in otel/opentelemetry-collector-contrib:0.165.0. Der Minerva-Endpunkt ist ein Platzhalter.
  • Prometheus-Regeln: validiert mit promtool check rules, Prometheus 3.12.0. Die Metriknamen folgen dcgm-exporter 4.9.0 und der internen Telemetrie des Collectors selbst; Namen, die mit ws: beginnen, sind Recording Rules von Workstation.
  • Alertmanager-Konfiguration: validiert mit amtool check-config, Alertmanager 0.34.2.
  • Ansible-Playbook: validiert mit ansible-playbook --syntax-check, ansible-core 2.21. Die Aufrufe von scontrol, squeue und dcgmi diag sind Standardbefehle von Slurm und DCGM; testen Sie sie vor der Produktion im Labor.
  • Beispielzahlen (Alarmanzahlen, Kosten pro GPU-Stunde, Schätzungen von Zeitreihen, Einführungswochen) sind durchgerechnete Beispiele, keine Messungen an einem Kundensystem.

Hinweis zu Schutzrechten: NVIDIA, das NVIDIA-Logo, Minerva, Sherlock (als Name des Assistenten von NVIDIA), DSX, DSX OS, DGX, HGX, Vera Rubin, Blackwell, Spectrum, Spectrum-X, NVLink, ConnectX, SuperNIC, BlueField, DOCA, DCGM, NCCL, Run:ai und Unified Fabric Manager (UFM) sind Marken und/oder eingetragene Marken der NVIDIA Corporation in den Vereinigten Staaten und anderen Ländern. NVIDIA-Produkte und -Technologien können durch Patente und andere geistige Eigentumsrechte der NVIDIA Corporation geschützt sein; alle diese Rechte werden anerkannt und bleiben ihren Inhabern vorbehalten. Produktinformationen sind in eigenen Worten aus öffentlichem Material von NVIDIA zusammengefasst; maßgebliche Quelle sind die Website und die Dokumentation von NVIDIA. Andere Firmen- und Produktnamen, darunter Grafana, Prometheus, Grafana Mimir, Elasticsearch, Slack, Microsoft Teams, PagerDuty, ServiceNow, Ansible, Red Hat, OpenTelemetry, OpenConfig, Slurm und Kubernetes, können Marken ihrer jeweiligen Inhaber sein. Die eigenen Dashboards, Konfigurationen und Texte von Workstation sind © Workstation.

Diesen Artikel teilen

Mehr zu Technology

Laptops für KI-Entwickler: LLMs lokal unter Linux mit GPUs mit 16 GB und 24 GB betreiben (Leitfaden 2026)

Laptops für KI-Entwickler: LLMs lokal unter Linux mit GPUs mit 16 GB und 24 GB betreiben (Leitfaden 2026)

Was auf eine RTX 5080 oder RTX 5090 Laptop GPU passt, die Speicherrechnung, die lohnenden offenen Modelle, die Einrichtung von Ubuntu 26.04 mit dem NVIDIA-Stack, Ollama, llama.cpp und vLLM, Coding-Assistenten, LoRA-Fine-Tuning, Sicherheit und wann Arbeit auf einen Server gehört

Weiterlesen
ML- und LLM-Systeme testen, deren Korrektheit sich nicht beweisen lässt: ein Python-Evidenz-Kit

ML- und LLM-Systeme testen, deren Korrektheit sich nicht beweisen lässt: ein Python-Evidenz-Kit

Evidenz statt Beweise, in etwa 400 Zeilen Python mit echter Ausgabe: Slice-Metriken mit Bootstrap-Intervallen und einem Pass/Fail-Vertrag, Property- und metamorphe Tests mit Hypothesis, Kalibrierung und Conformal Prediction, Pydantic-Verträge und Regressionsevaluierungen für LLM-Ausgaben, Drift-Prüfungen, ein CI-Gate und die exakte Verifikation eines kleinen neuronalen Netzes

Weiterlesen
TorchCurves in der Praxis: lernbare B-Spline- und Legendre-Kurven in PyTorch

TorchCurves in der Praxis: lernbare B-Spline- und Legendre-Kurven in PyTorch

torchcurves installieren, eine Kurve anpassen und dimensionieren, B-Spline oder Legendre und die Eingabeabbildung wählen, eine monotone Kalibrierungskurve und ein additives Modell auf tabellarischen Daten bauen, mit SciPy, scikit-learn, einem KAN und einem MLP vergleichen, Koeffizienten nach JSON exportieren, testen und in der Produktion betreiben, mit echten Ausgaben

Weiterlesen