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-Observability mit OpenTelemetry: UFM-SDK-Plugins, DCGM, DOCA und NetQ in Mimir, Grafana und den Elastic Stack

Jedes UFM-SDK-Plugin, UFM-Telemetrie und REST-Endpunkte, die Umbenennungen von Metriken in dcgm-exporter 4.9.0, ein OpenTelemetry-Design mit Agenten und Gateways samt validierter Konfiguration, Alarmregeln, Labeling, Kardinalität, Tracing für Inferenz und ein hochverfügbarer Observability-Stack

9. November 2026Technology34 min read

Ein Praxisleitfaden zu den Observability-Werkzeugen von NVIDIA für KI-Cluster und dazu, wie wir sie mit OpenTelemetry verbinden. Er behandelt UFM und seine offenen SDK-Plugins, die UFM-REST-API und die Telemetrie-Endpunkte, DCGM und dcgm-exporter für GPUs (einschließlich der Umbenennungen von Metriken in dcgm-exporter 4.9.0), den DOCA Telemetry Service auf BlueField, NetQ für Spectrum-X Ethernet und das Referenzdesign von Workstation: ein OpenTelemetry-Collector-Agent auf jedem Knoten, ein Gateway-Paar und zwei Backends (Prometheus-kompatible Metriken in Grafana Mimir mit Grafana und Tempo sowie der Elastic Stack). Lauffähige Konfiguration, Alarmregeln, ein Labeling-Schema, Kardinalitätsberechnungen und das Hochverfügbarkeitsdesign für das Monitoring selbst sind enthalten. Die geschäftliche Begründung finden Sie im begleitenden Blogbeitrag.

Interaktive Version: siebzehn Beispiel-Dashboards durchsuchen, jeweils mit ihrem PromQL oder KQL und Alarmschwellen.

Telemetrie von GPUs, InfiniBand- und Ethernet-Switches, BlueField-DPUs und KI-Diensten fließt über OpenTelemetry Collectors zu Prometheus, Mimir und Grafana sowie zu Elasticsearch und Kibana.

Zusammenfassung. Erfassen Sie jedes Signal einmal, so nah an seiner Quelle wie sinnvoll, versehen Sie es mit einem flottenweiten Labeling-Schema und verteilen Sie es an die Backends, die die Beteiligten bereits nutzen. GPU-Zähler stammen aus DCGM, Zähler und Ereignisse der InfiniBand-Fabric aus UFM, Daten der Ethernet-Fabric aus NetQ oder von den Switches, DPU-Zähler aus dem DOCA Telemetry Service und Request-Traces aus den KI-Diensten über das OpenTelemetry SDK. OpenTelemetry Collectors übernehmen Labeling, Filterung, Sampling und Routing. Metriken und Traces gehen an Mimir und Tempo, Logs und Ereignisse an Elasticsearch, und die gesamte Pipeline wird selbst überwacht und ist hochverfügbar.

Dieser Artikel folgt der Haltung unserer früheren Technote zu Big Prometheus und MoSCoW: OpenTelemetry ist der Telemetrie-Vertrag, Prometheus-Semantik und PromQL sind die Sprache für Metriken, und ein horizontal skalierbarer Speicher (hier Grafana Mimir) kommt zum Einsatz, sobald ein einzelnes Prometheus flottenweite Fragen nicht mehr beantwortet. Das Einzige, was wir für KI-Cluster ergänzen, ist ein zweites Backend für Logs, weil der Elastic Stack bei Security- und Betriebsteams so häufig bereits vorhanden ist. Logs gehen in einen primären Speicher, wie jener Artikel empfiehlt; wir schreiben dieselben Logs nicht zweimal.

1. Die Signale, auf die es in einem KI-Cluster ankommt

Ein KI-Cluster fällt schichtweise aus. Ein brauchbares Monitoring-Design benennt jede Schicht, das NVIDIA-Werkzeug, das sie kennt, und wie die Daten dieses Werkzeug verlassen.

SchichtTypische FehlerNVIDIA-QuelleWie wir sie erfassen
GPU und NVLinkXID-Fehler, ECC- und Row-Remap-Ereignisse, thermische oder leistungsbedingte Drosselung, NVLink-Fehler, untätige GPUs in laufenden JobsDCGM (Host Engine) und dcgm-exporterPrometheus-Scrape auf dem Knoten durch den Collector-Agenten
InfiniBand-Compute- und -Storage-FabricLink-Flaps, Symbol- und Integritätsfehler, mit falscher Geschwindigkeit oder Breite trainierte Links, Überlastung, heiße oder ausfallende Transceiver, Änderungen am Subnet ManagerUFM Telemetry und UFM Enterprise (Ereignisse, Alarme, Topologie, REST-API), SDK-PluginsPrometheus-Scrape der UFM-Telemetrie; UFM-Ereignisse per Syslog oder Fluentd; REST-Polling für die Topologie
Ethernet-Fabric (Spectrum-X, Storage und Frontend)Paketverluste, PFC-Stürme, ECN-Markierung, RoCE-Überlastung, BGP- oder EVPN-ÄnderungenNetQ; Streaming-Telemetrie der SwitchesNetQ-API oder gNMI- bzw. OTLP-Streaming der Switches in das Gateway
BlueField-DPUPort- und Offload-Zähler, DPU-ZustandDOCA Telemetry ServiceScrape seines Endpunkts im Prometheus-Format
Host und Storage-ClientsSpeicherdruck, NVMe-Verschleiß, Dateisystem-Latenz, NIC-Fehler(Standard-Linux-Werkzeuge)node-exporter, filelog- und journald-Receiver
Scheduler und OrchestrierungHängende Jobs, gedrainte Knoten, GPU-Anforderungen ohne Auslastung(Slurm, Kubernetes), UFM-Slurm-IntegrationJob-zu-GPU-Labels aus dcgm-exporter; Scheduler-Exporter; Kubernetes-Metadaten
KI-DiensteLangsame Time to First Token, Warteschlangen, Fehler, Einbrüche beim Token-Durchsatz(Modellserver wie NIM, Triton oder vLLM)Traces und Metriken des OpenTelemetry SDK per OTLP

2. NVIDIA UFM: Stufen, Telemetrie-Endpunkte und REST-API

Unified Fabric Manager (siehe die offizielle NVIDIA-UFM-Seite) betreibt und beobachtet InfiniBand-Fabrics. Es gibt ihn in drei aufeinander aufbauenden Stufen:

  • UFM Telemetry erfasst Leistungs- und Fehlerzähler von jedem Port der Fabric zusammen mit Kabel- und Transceiverdaten und stellt sie bereit oder streamt sie. Es ist ausschließlich eine Sichtbarkeitsebene.
  • UFM Enterprise ergänzt das Fabric-Management: Erkennung und Topologie, Steuerung des Subnet Managers, Verwaltung von Partition Keys (PKeys), Ereignisse und Alarme, Zustands- und Topologieberichte, die REST-API, Integrationen mit Schedulern und Cluster-Managern sowie ein Active/Standby-Hochverfügbarkeitspaar.
  • UFM Cyber-AI wendet Analytik und maschinelles Lernen auf die Telemetriehistorie von Enterprise an, um ausfallende Links und Kabel vorherzusagen und Leistungs- oder Nutzungsanomalien zu kennzeichnen.

Telemetrie-Endpunkte

Der Telemetriedienst von UFM liefert seine Zähler über HTTP, standardmäßig auf Port 9001. Es gibt eine CSV-Ansicht (zum Beispiel /csv/metrics, dazu Ansichten für Zählersätze wie /csv/xcset/ib_basic_debug) und, wenn die Erzeugung von Prometheus-Labels aktiviert ist, einen Prometheus-Endpunkt, dessen Pfad die SDK-Dokumentation mit labels/enterprise angibt. Die Ansichten für Zählersätze akzeptieren Sharding-Parameter (num_shards, shard, sharding_field=port_guid), was hilft, wenn eine einzelne Anfrage für eine große Fabric zu umfangreich ist, um innerhalb eines Scrape-Intervalls beantwortet zu werden.

Die Zählernamen folgen den Attributen des InfiniBand-Performance-Managements. Diejenigen, die wir in NVIDIAs eigenem SDK-Material bestätigt haben und auf denen wir unten aufbauen, sind:

ZählerWas er Ihnen sagt
PortXmitDataExtended, PortRcvDataExtendedAm Port gesendete und empfangene Daten; als Rate gibt er die Bandbreite an (NVIDIAs eigenes Grafana-Dashboard multipliziert die Rate mit 8, um Bits pro Sekunde anzuzeigen)
LinkDownedCounterExtendedWie oft der Link ausgefallen ist: das Signal für Link-Flaps
LinkErrorRecoveryCounterExtendedWie oft der Link neu trainiert wurde, um sich von Fehlern zu erholen: oft das erste Anzeichen eines grenzwertigen Kabels
LocalLinkIntegrityErrorsExtendedLokale physische Fehler, die den Integritätsschwellenwert überschreiten
ExcessiveBufferOverrunErrorsExtendedAufeinanderfolgende Pufferüberläufe am Port
Normalized_CBWEin Wert für die Überlastungsbandbreite, den UFM bereitstellt; NVIDIAs Dashboard stellt sein Maximum nach Topologieebene dar
dev_temperatureGerätetemperatur

Der genaue Satz und die Label-Namen hängen vom aktivierten Zählersatz und der UFM-Version ab; listen Sie also immer auf, was Ihr Endpunkt tatsächlich liefert, bevor Sie Regeln schreiben: curl -s http://<ufm-host>:9001/csv/metrics | head.

REST-API

Die REST-API von UFM Enterprise befindet sich unter /ufmRest auf dem UFM-Server, mit benachbarten Präfixen für andere Authentifizierungsmethoden: /ufmRestV2 (Session), /ufmRestV3 (Access Token) und /ufmRestKrb (Kerberos). Tokens werden mit einem POST an /app/tokens erzeugt. Für das Monitoring verwenden wir drei schreibgeschützte Ressourcen, die alle in NVIDIAs SDK-Beispielen vorkommen:

# Current alarms and recent events (use a read-only monitoring account)
curl -sk -u monitor:"$UFM_PASSWORD" https://ufm-vip.obs.internal/ufmRest/app/alarms
curl -sk -u monitor:"$UFM_PASSWORD" https://ufm-vip.obs.internal/ufmRest/app/events

# Every link in the fabric, with both ends: the basis of our node-to-switch-port map
curl -sk -u monitor:"$UFM_PASSWORD" https://ufm-vip.obs.internal/ufmRest/resources/links

# UFM's own health in Prometheus format (scrape every few minutes, not seconds)
curl -sk -u monitor:"$UFM_PASSWORD" https://ufm-vip.obs.internal/ufmRest/system_monitoring/metrics

Wir kapseln den Links-Aufruf in einen kleinen Exporter, der alle fünf Minuten eine Info-Metrik, ws_ib_link_info{node, hca_port, switch, port}, veröffentlicht. Diese Metrik erlaubt es einer Abfrage, von einem Slurm-Job über seine GPUs bis zu den genauen Switch-Ports zu gelangen, die sein Datenverkehr durchquert. Sie ist unsere Konvention, keine NVIDIA-Metrik.

Hochverfügbarkeit

UFM Enterprise läuft als Active/Standby-Paar, das von seinen HA-Werkzeugen (ufm_ha_cluster) verwaltet wird, mit zwischen den beiden Servern replizierter Konfiguration und einer virtuellen IP, die beim Failover wechselt. Richten Sie jeden Scrape, jeden REST-Client und jedes Syslog-Ziel auf die virtuelle IP, nie auf einen Knoten. Wo ein Plugin in einer HA-Umgebung verwendet wird, sehen die Anweisungen von NVIDIA vor, sein Container-Image auch auf dem Standby-Knoten zu laden, damit es nach einem Failover bereitsteht.

3. Das UFM SDK und seine Plugins

NVIDIA veröffentlicht ein offenes SDK für UFM unter github.com/Mellanox/ufm_sdk_3.0. Der Großteil davon ist ein Satz von Plugins: Container, die UFM über seinen Plugin-Manager verwaltet (über die Weboberfläche oder mit /opt/ufm/scripts/manage_ufm_plugins.sh add -p <name> bei einer Einzel- oder HA-Installation). Hier steht, was jedes Plugin tut und wie es in unser Design passt.

PluginWas es tutWo es hineinpasst
grafana_infiniband_telemetry_pluginStellt einen zweiten Prometheus-Endpunkt bereit (Port 8982, Pfad /labels/enterprise) mit gut lesbaren Labels wie Gerätenamen statt GUID-basierter Labels und liefert ein Beispiel-Dashboard für Grafana mit.Unser bevorzugtes Scrape-Ziel für Fabric-Zähler: Lesbare Labels bedeuten weniger Relabeling-Regeln.
grafana_telemetry_pluginAnleitung und ein Dashboard für das direkte Scrapen des eigenen Prometheus-Endpunkts von UFM Telemetry (Port 9001).Verwenden, wenn Sie das Plugin oben nicht betreiben können; rechnen Sie mit GUID-basierten Labels.
grafana_ufm_monitoring_pluginEin Dashboard für den Systemzustand von UFM selbst, gescrapt von /ufmRest/system_monitoring/metrics über HTTPS mit Basic Authentication.Überwacht den Überwacher: CPU, Speicher und API-Zustand der UFM-Server.
ufm_events_grafana_dashboard_pluginParst das event.log von UFM mit Fluentd, überträgt es an ein mitgeliefertes Loki und zeigt es in einem mitgelieferten Grafana an.Gut für einen schnellen Einstieg; in der Produktion senden wir Ereignisse stattdessen an den zentralen Log-Speicher.
fluentd_telemetry_plugin (TFS)Fragt einen oder mehrere UFM-Telemetrie-Endpunkte in einem eigenen Intervall pro Endpunkt ab und streamt die Zähler an ein Fluentd-Ziel (standardmäßig Forward-Protokoll auf 24224 oder HTTP). Attribute lassen sich über seine REST-API aktivieren, deaktivieren oder umbenennen, und es veröffentlicht eigene Streaming-Statistiken im Prometheus-Format.Der Weg für Fabric-Zähler nach Elasticsearch, wenn ein Kunde sowohl für Metriken als auch für Logs auf Elastic standardisiert hat.
fluentd_topology_pluginExtrahiert die Topologie über die UFM-API und streamt sie über das Fluentd-Protokoll.Topologie-Snapshots im Log-Speicher, damit Sie sehen, wie die Fabric zum Zeitpunkt eines Vorfalls aussah.
ufm_syslog_streaming_plugin (EFS)Extrahiert UFM-Ereignisse aus seinem Syslog und streamt sie an Fluentd (kompatibel mit Fluent Bit); kann außerdem das UFM-Syslog auf einen entfernten Syslog-Server kopieren.Unser Hauptweg für UFM-Ereignisse und -Alarme nach Elasticsearch.
zabbix_telemetry_pluginAnleitung zum Streamen von UFM-Ereignissen in Zabbix über den Zabbix-Agenten und Log-Items.Für Betriebsteams, die Zabbix bereits als Ereigniskonsole nutzen.
SLURM-IntegrationSlurm-Prolog- und -Epilog-Hooks, die UFM für jeden Job aufrufen: statische oder dynamische (pro Job, aus der Job-ID abgeleitete) Partition Keys, wobei UFM SHARP-Reservierungen automatisch aus der PKey-Mitgliedschaft verwaltet. Unterstützt Token-, Basic- oder Kerberos-Authentifizierung. UFM muss im Management-Modus laufen, nicht im reinen Monitoring-Modus.Netzwerkisolierung pro Job und ein Nachweis, welcher Job welche Ports genutzt hat.
pdr_deterministic_pluginProblem Detection and Resolution: nutzt die dynamische Telemetrie von UFM, um Bitfehlerraten, Temperaturen und Link-Down-Deltas zu berechnen, isoliert Ports, die Schwellenwerte überschreiten, protokolliert sie und hebt die Isolierung nach einer fehlerfreien Testphase wieder auf. Bietet einen Dry-Run-Modus und eine Ausschlussliste.Automatische Isolierung fehlerhafter Links, damit Jobs um sie herum geroutet werden; siehe Abschnitt 4.
UFM_NDT_PluginAbgleich mit dem Network Design Tool: die geplante Topologie hochladen, sie einmalig oder nach Zeitplan mit dem vergleichen, was UFM erkannt hat, und die Berichte über die REST-API lesen.Belegt bei der Übergabe und nach Wartungsarbeiten, dass die tatsächliche Verkabelung dem Design entspricht.
gnmi_nvos_events_pluginAbonniert Systemereignisse „bei Änderung“ von NVOS-verwalteten Switches über gNMI und wandelt sie in externe UFM-Ereignisse um.Bringt switchseitige Ereignisse (zum Beispiel ein Transceiver-Reset) in denselben UFM-Ereignisstrom.
snmp_receiver_pluginEmpfängt SNMP-Traps von verwalteten Switches und leitet sie als Ereignisse in UFM um.Dieselbe Idee für Switches, die nur Traps senden.
grpc_streamer_pluginEin gRPC-Server, der UFM-REST-Daten (Ereignisse, Alarme, Links und anderes) einmalig oder als periodischen Stream zurückgibt, optional nur die Änderungen. NVIDIA kennzeichnet es als in Entwicklung.Noch nicht in unserem Produktionsdesign; wir beobachten es als Alternative mit geringerer Latenz zum REST-Polling.
ufm_log_analyzer_pluginAnalysiert einen UFM-Sysdump oder Logs offline und erstellt Befunde und einen PDF-Bericht. NVIDIA kennzeichnet es als in Entwicklung und für den internen Gebrauch.Nützlich für Supportfälle; nicht Teil des Live-Monitorings.
bright_pluginVerbindet UFM mit Bright Cluster Manager (heute NVIDIA Base Command Manager) und holt Knotenstatus und Job-Zuweisungen in UFM.Stellt bei der Ursachenanalyse auf BCM-verwalteten Clustern den Workload-Kontext neben die Netzwerkereignisse.

Die meisten Plugins werden als Images auf Docker Hub ausgeliefert (mellanox/ufm-plugin-*); PDR wird aus dem NVIDIA Licensing Portal heruntergeladen. Für Standorte ohne Internetverbindung dokumentiert das SDK den üblichen Weg über docker save und docker load, und wir nehmen die Images in das Offline-Paket auf, das wir vor dem Versand bereitstellen.

4. Problem Detection and Resolution in der Praxis

PDR ist das Plugin, das den Betrieb am stärksten verändert, und verdient daher einen eigenen Abschnitt. Seine Konfigurationsdatei legt die Schwellenwerte direkt offen. Die Standardwerte im SDK zum Zeitpunkt der Erstellung sind:

EinstellungStandardBedeutung
INTERVAL300 sWie oft Telemetriezähler abgefragt werden
MAX_NUM_ISOLATE10Obergrenze für isolierte Ports (der größere Wert aus diesem und 0,5 % der Fabric-Größe)
TMAX / D_TMAX70 °C / 10Maximale Temperatur und maximaler Temperaturanstieg
MAX_PDR1e-12Maximale Paketverlustrate
CONFIGURED_BER_CHECK, CONFIGURED_TEMP_CHECK, LINK_DOWN_ISOLATIONTrueWelche Prüfungen eine Isolierung auslösen dürfen
SWITCH_TO_HOST_ISOLATIONTrueOb Zugangslinks zu Hosts isoliert werden dürfen
DRY_RUNFalseEntscheidungen protokollieren statt handeln
DEISOLATE_CONSIDER_TIME5 minWie lange ein Port fehlerfrei aussehen muss, bevor er wieder in Betrieb genommen wird
MAX_PORT_RESET_NUM2 pro WocheErlaubte Port-Resets, bevor ein Reset-Fenster zurückgesetzt wird

Seine Prüfung der Bitfehlerrate beobachtet Symbolfehler über kurze und lange Zeitfenster (etwa 12 und 125 Minuten); deshalb erkennt sie Kabel, die sich verschlechtern, und nicht nur solche, die bereits ausgefallen sind. Unsere Einführung läuft immer gleich ab:

  1. Mit DRY_RUN=True für zwei bis vier Wochen aktivieren und das Log an Elasticsearch senden. Jede Zeile „würde isolieren“ wird zu einem Ticket, das wir anhand der UFM-Zähler prüfen.
  2. Die Ausschlussliste (Ports, die PDR nie anfassen darf, etwa einfach angebundene Storage-Links) über die REST-API des Plugins vereinbaren.
  3. Auf Live-Isolierung umstellen, wobei SWITCH_TO_HOST_ISOLATION pro Standort entschieden wird: Das Isolieren eines Host-Links entfernt diesen Knoten aus Jobs, was manchmal gewünscht ist und manchmal nicht.
  4. Bei jeder Isolierung und Aufhebung alarmieren und ein Wartungsticket für die physische Reparatur anlegen.

5. GPU-Telemetrie: DCGM und dcgm-exporter

NVIDIA Data Center GPU Manager (DCGM) ist der Dienst für GPU-Zustand und -Telemetrie; dcgm-exporter wandelt seine Felder in Prometheus-Metriken um, standardmäßig auf Port 9400. Auf Kubernetes wird er normalerweise vom NVIDIA GPU Operator bereitgestellt; auf Slurm-Clustern betreiben wir ihn als systemd-Dienst oder Container neben der DCGM Host Engine.

dcgm-exporter 4.9.0 hat die Standardmetriken umbenannt

Release 4.9.0 (November 2026) benennt die Standard- und Profiling-Felder nach ihren Namen in DCGM 4.7 um, und bei elf von ihnen ändert sich die Einheit: Takte zu Hertz, Energie zu Joule, Auslastung von einem Prozentwert zu einem Verhältnis von 0 bis 1, Speicher von MiB zu Bytes und NVLink-Durchsatz zu Bytes pro Sekunde. Dashboards und Alarme, die für 4.8.x geschrieben wurden, werden stillschweigend leer bleiben oder, schlimmer noch, ein Verhältnis mit einem Prozentwert vergleichen. Die Standardmetriken, die wir am häufigsten verwenden:

Name in 4.8.xName in 4.9.0Einheitenänderung
DCGM_FI_DEV_GPU_UTILDCGM_FI_DEV_GPU_UTIL_RATIO% zu 0–1
DCGM_FI_DEV_FB_USEDDCGM_FI_DEV_FB_USED_BYTESMiB zu Bytes
DCGM_FI_DEV_GPU_TEMPDCGM_FI_DEV_GPU_TEMP_CELSIUSkeine
DCGM_FI_DEV_POWER_USAGEDCGM_FI_DEV_BOARD_POWER_WATTSkeine
DCGM_FI_DEV_TOTAL_ENERGY_CONSUMPTIONDCGM_FI_DEV_GPU_ENERGY_JOULES_TOTALmJ zu J
DCGM_FI_DEV_XID_ERRORSDCGM_FI_DEV_XID_ERRORkeine (letzter XID-Wert)
DCGM_FI_DEV_NVLINK_BANDWIDTH_TOTALDCGM_FI_DEV_NVLINK_THROUGHPUT_BYTES_PER_SECONDMB/s zu B/s
DCGM_FI_DEV_UNCORRECTABLE_REMAPPED_ROWSDCGM_FI_DEV_ROW_REMAP_UNCORRECTABLE_TOTALkeine
DCGM_FI_DEV_ROW_REMAP_FAILUREDCGM_FI_DEV_ROW_REMAP_FAILEDkeine
DCGM_FI_DEV_PCIE_REPLAY_COUNTERDCGM_FI_DEV_PCIE_REPLAY_TOTALkeine
DCGM_FI_PROF_GR_ENGINE_ACTIVEDCGM_FI_PROF_GR_ENGINE_UTIL_RATIOkeine (Verhältnis)
DCGM_FI_PROF_PIPE_TENSOR_ACTIVEDCGM_FI_PROF_TENSOR_UTIL_RATIOkeine (Verhältnis)
DCGM_FI_PROF_DRAM_ACTIVEDCGM_FI_PROF_DRAM_UTIL_RATIOkeine (Verhältnis)

Auch das Label für die Treiberversion ändert sich, von DCGM_FI_DRIVER_VERSION zu DCGM_FI_SYSTEM_DRIVER_VERSION. Lesen Sie vor dem Upgrade die Upgrade-Checkliste von NVIDIA. Während einer Einführung mit gemischten Versionen überbrücken wir beide mit Recording Rules, sodass Dashboards ausschließlich die ws:-Namen abfragen:

groups:
  - name: dcgm-bridge
    rules:
      - record: ws:gpu_util:ratio
        expr: DCGM_FI_DEV_GPU_UTIL_RATIO or (DCGM_FI_DEV_GPU_UTIL / 100)
      - record: ws:gpu_fb_used:bytes
        expr: DCGM_FI_DEV_FB_USED_BYTES or (DCGM_FI_DEV_FB_USED * 1048576)
      - record: ws:gpu_power:watts
        expr: DCGM_FI_DEV_BOARD_POWER_WATTS or DCGM_FI_DEV_POWER_USAGE

Jedes Beispiel im Rest dieses Artikels verwendet die Namen aus 4.9.0.

Welche GPU-Metrik bedeutet „ausgelastet“?

DCGM_FI_DEV_GPU_UTIL_RATIO sagt nur, dass während des Samples ein Kernel lief; eine GPU, die innerhalb eines Collectives auf das Netzwerk wartet, kann trotzdem nahe 1 anzeigen. Für Effizienzberichte verwenden wir die Profiling-Felder: DCGM_FI_PROF_GR_ENGINE_UTIL_RATIO und DCGM_FI_PROF_TENSOR_UTIL_RATIO. Sie benötigen das Profiling-Modul von DCGM und können mit anderen Profilern wie Nsight Compute auf derselben GPU in Konflikt geraten; daher pausieren wir die Erfassung von Profiling-Metriken, wenn Engineers manuell profilieren.

Job- und Pod-Labels

Auf Kubernetes fügt dcgm-exporter die Labels namespace, pod und container für den Workload hinzu, der jede GPU nutzt. Auf Slurm liest sein HPC-Job-Mapping ein Verzeichnis mit Dateien pro GPU, die ein Slurm-Prolog schreibt und der Epilog leert, und fügt ein hpc_job-Label hinzu. Version 4.9.0 härtet das ab (sie weist symbolische Links im Mapping-Verzeichnis zurück und begrenzt die Größe von Dateien und Job-IDs) und benennt jedes Pod-Label namens hpc_job um, damit sich beide nicht in die Quere kommen.

NVLink und NVSwitch

Innerhalb eines HGX- oder DGX-B300-Systems kommunizieren GPUs über NVLink durch NVSwitch. Der Standardsatz liefert den gesamten NVLink-Durchsatz pro GPU; die NVLink-Fehlerzähler sind optional und unterscheiden sich je nach GPU-Generation, daher aktivieren wir die passenden in der Zähler-CSV: auf Blackwell-Systemen wie B300 die Recovery-Zähler (DCGM_FI_DEV_NVLINK_RECOVERY_EVENT_TOTAL, DCGM_FI_DEV_NVLINK_RECOVERY_SUCCESSFUL_TOTAL und DCGM_FI_DEV_NVLINK_RECOVERY_FAILED_TOTAL); auf Hopper die Data-Link-Zähler (DCGM_FI_DEV_NVLINK_CRC_ERROR_TOTAL, DCGM_FI_DEV_NVLINK_REPLAY_TOTAL, DCGM_FI_DEV_NVLINK_RECOVERY_TOTAL). Die älteren Felder …_CRC_FLIT_ERROR_TOTAL und …_REPLAY_ERROR_TOTAL gelten nur für GPUs vor Hopper. NVL72-Systeme im Rack-Maßstab ergänzen zwischen den Trays eine NVLink-Switch-Fabric mit eigener Management-Software, die wir im Labeling-Schema als separate Fabric behandeln.

6. BlueField-DPUs und Spectrum-X Ethernet

DOCA Telemetry Service (DTS) läuft als Container auf BlueField-DPUs (und kann auf Hosts mit ConnectX-Adaptern laufen). Er sammelt über eine Reihe von Providern Zähler von der DPU und ihren Ports und stellt sie unter anderem auf einem Endpunkt im Prometheus-Format bereit. Wir scrapen diesen Endpunkt vom Fabric-Collector aus mit einer dateibasierten Zielliste von DPU-Management-Adressen und versehen jede DPU mit dem Label des Hosts, den sie bedient.

NetQ ist das Werkzeug von NVIDIA zur Überwachung und Validierung von Ethernet-Fabrics auf Basis von Cumulus Linux und SONiC, einschließlich Spectrum-X. Es erfasst Zustände und Zähler von Agenten auf den Switches, führt eine Historie, sodass Sie fragen können, was sich wann geändert hat, und validiert die Fabric gegen ihre beabsichtigte Konfiguration. Bei RoCE-basierten KI-Fabrics sind die wichtigsten Zähler Paketverluste, PFC-Pause-Frames, ECN-markierte Pakete und Pufferbelegung. Es gibt drei praktische Wege, das in den zentralen Stack zu bringen, und wir wählen pro Standort:

  • NetQ als Werkzeug des Netzwerkteams behalten und Zusammenfassungen und Ereignisse über seine API in den Log-Speicher holen;
  • direkt von den Switches streamen (gNMI oder, bei neueren Cumulus-Linux-Releases, OTLP; prüfen Sie die Dokumentation Ihrer Version) in die Gateway-Collectors;
  • bei älteren Switches auf SNMP und Syslog zurückgreifen.

Die Zählernamen unterscheiden sich zwischen diesen Wegen; daher normalisieren wir sie in eigene Namen für Recording Rules (ws:eth_pfc_pause_rx:rate5m, ws:eth_ecn_marked:rate5m, ws:eth_drops:rate5m) und bauen Dashboards ausschließlich darauf auf.

7. Das OpenTelemetry-Referenzdesign von Workstation

Referenzarchitektur: GPU-Knoten betreiben dcgm-exporter, node-exporter und einen OpenTelemetry-Collector-Agenten; UFM-, NetQ- und DOCA-Endpunkte werden von einem Fabric-Collector gescrapt; ein Paar von Gateway-Collectors fügt Labels hinzu, filtert und sampelt und exportiert an Mimir, Tempo, Grafana und Alertmanager sowie an Logstash, Elasticsearch und Kibana.

Das Design hat drei Collector-Ebenen:

  • Ein Agent auf jedem GPU-, Storage- und Login-Knoten, betrieben als systemd-Dienst oder Kubernetes-DaemonSet. Er scrapt lokale Exporter über Loopback, liest lokale Logs mit, empfängt OTLP von lokalen Diensten, fügt Host- und Kubernetes-Metadaten hinzu und leitet alles an die Gateways weiter. Er führt eine kleine persistente Queue, damit ein Gateway-Neustart nichts verliert.
  • Ein Gateway-Paar (oder mehr) hinter einer virtuellen IP oder einem DNS-Namen. Gateways wenden flottenweite Richtlinien an: Labels, Bereinigung von Attributen, Filterung, Tail Sampling von Traces und Routing zu Backends. Zugangsdaten für die Backends liegen nur hier.
  • Eine Fabric-Pipeline auf den Gateway-Hosts, die UFM-, DOCA- und Switch-Endpunkte scrapt und Syslog empfängt. Beide Gateways betreiben sie; die doppelten Samples werden in Mimir von dessen HA-Tracker entfernt (Abschnitt 16).

Warum schreibt nicht jeder Knoten direkt in die Backends? Weil am Gateway Richtlinienänderungen einmal erfolgen, Geheimnisse von Hunderten Knoten ferngehalten werden und eine Backend-Migration (etwa das Hinzufügen von Elasticsearch für ein Security-Team) eine Konfigurationsänderung auf zwei Servern ist statt eines flottenweiten Rollouts.

8. Konfiguration des Collector-Agenten

Dies ist der Agent, den wir auf einem Slurm-GPU-Knoten einsetzen, nur um standortspezifische Zertifikate gekürzt. Er benötigt die Distribution otelcol-contrib oder einen eigenen Build mit denselben Komponenten.

# /etc/otelcol-contrib/config.yaml  (agent, one per node)
extensions:
  health_check:
    endpoint: 127.0.0.1:13133
  file_storage:
    directory: /var/lib/otelcol/queue
    create_directory: true

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 127.0.0.1:4317
      http:
        endpoint: 127.0.0.1:4318

  prometheus:
    config:
      scrape_configs:
        - job_name: dcgm
          scrape_interval: 15s
          static_configs:
            - targets: ["127.0.0.1:9400"]
        - job_name: node
          scrape_interval: 15s
          static_configs:
            - targets: ["127.0.0.1:9100"]
          metric_relabel_configs:
            # keep what the dashboards use; node-exporter's full output is large
            - source_labels: [__name__]
              regex: "node_(cpu_seconds_total|load1|load5|memory_.+|pressure_.+|filesystem_(avail|size)_bytes|disk_(read|written)_bytes_total|network_(receive|transmit)_(bytes|errs|drop)_total|infiniband_.+|hwmon_temp_celsius|nvme_.+|textfile_.+)"
              action: keep

  filelog:
    include:
      - /var/log/syslog
      - /var/log/slurm/slurmd.log
      - /var/log/slurm/ufm_slurm.log
    include_file_path: true
    start_at: end
    storage: file_storage

processors:
  memory_limiter:
    check_interval: 1s
    limit_percentage: 75
    spike_limit_percentage: 20
  resourcedetection:
    detectors: [env, system]
    system:
      hostname_sources: [os]
  resource/fleet:
    attributes:
      - key: site
        value: ${env:WS_SITE}
        action: upsert
      - key: cluster
        value: ${env:WS_CLUSTER}
        action: upsert
      - key: rack
        value: ${env:WS_RACK}
        action: upsert
      - key: node_role
        value: ${env:WS_NODE_ROLE}
        action: upsert
  batch:
    send_batch_size: 8192
    timeout: 5s

exporters:
  otlp/gateway:
    endpoint: otel-gateway.obs.internal:4317
    tls:
      ca_file: /etc/otelcol-contrib/ca.pem
    sending_queue:
      enabled: true
      storage: file_storage
      queue_size: 5000
    retry_on_failure:
      enabled: true
      max_elapsed_time: 30m
  # traces are routed by trace ID so every span of a trace reaches the same
  # gateway, which tail sampling needs
  loadbalancing/traces:
    routing_key: traceID
    protocol:
      otlp:
        tls:
          ca_file: /etc/otelcol-contrib/ca.pem
    resolver:
      dns:
        hostname: otel-gateway-pool.obs.internal
        port: "4317"

service:
  extensions: [health_check, file_storage]
  pipelines:
    metrics:
      receivers: [otlp, prometheus]
      processors: [memory_limiter, resourcedetection, resource/fleet, batch]
      exporters: [otlp/gateway]
    logs:
      receivers: [otlp, filelog]
      processors: [memory_limiter, resourcedetection, resource/fleet, batch]
      exporters: [otlp/gateway]
    traces:
      receivers: [otlp]
      processors: [memory_limiter, resourcedetection, resource/fleet, batch]
      exporters: [loadbalancing/traces]
  telemetry:
    metrics:
      level: detailed
      readers:
        - pull:
            exporter:
              prometheus:
                host: 0.0.0.0
                port: 8888

Auf Kubernetes-Knoten ergänzen wir den Prozessor k8sattributes im Agenten (nicht im Gateway, denn wenn Daten ein Gateway erreichen, ist die ursprüngliche Pod-IP verloren) und filtern ihn auf den lokalen Knoten:

processors:
  k8sattributes:
    auth_type: serviceAccount
    filter:
      node_from_env_var: K8S_NODE_NAME
    extract:
      metadata:
        - k8s.namespace.name
        - k8s.pod.name
        - k8s.deployment.name
        - k8s.node.name
      labels:
        - tag_name: tenant
          key: workstation.co.uk/tenant
          from: namespace

9. Gateway-Konfiguration und die beiden Backends

Das Gateway empfängt OTLP von den Agenten, führt die Fabric-Scrapes und Syslog aus und exportiert an beide Backends. Es gibt zwei Metrik-Pipelines: eine für von Agenten weitergeleitete Daten (eindeutig, daher kein Replica-Label) und eine für die Fabric-Scrapes, die beide Gateways ausführen (mit dem Replica-Namen des Gateways gelabelt, damit Mimir eine Kopie behält).

# /etc/otelcol-contrib/config.yaml  (gateway, two or more)
extensions:
  health_check:
    endpoint: 0.0.0.0:13133
  file_storage:
    directory: /var/lib/otelcol/queue
    create_directory: true
  basicauth/ufm:
    client_auth:
      username: ${env:UFM_MONITOR_USER}
      password: ${env:UFM_MONITOR_PASSWORD}
  basicauth/es:
    client_auth:
      username: ${env:ES_USER}
      password: ${env:ES_PASSWORD}

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

  prometheus/fabric:
    config:
      scrape_configs:
        - job_name: ufm-telemetry
          scrape_interval: 60s
          scrape_timeout: 50s
          metrics_path: /labels/enterprise
          static_configs:
            - targets: ["ufm-vip.obs.internal:8982"]
          metric_relabel_configs:
            - source_labels: [__name__]
              regex: "PortXmitDataExtended|PortRcvDataExtended|LinkDownedCounterExtended|LinkErrorRecoveryCounterExtended|LocalLinkIntegrityErrorsExtended|ExcessiveBufferOverrunErrorsExtended|Normalized_CBW|dev_temperature"
              action: keep
        - job_name: ufm-system
          scrape_interval: 4m
          scrape_timeout: 60s
          scheme: https
          metrics_path: /ufmRest/system_monitoring/metrics
          basic_auth:
            username: ${env:UFM_MONITOR_USER}
            password: ${env:UFM_MONITOR_PASSWORD}
          tls_config:
            ca_file: /etc/otelcol-contrib/ufm-ca.pem
          static_configs:
            - targets: ["ufm-vip.obs.internal:443"]
          metric_relabel_configs:
            - source_labels: [__name__]
              regex: "rest_api_response_time_histogram.*"
              action: drop
        - job_name: doca-telemetry
          scrape_interval: 30s
          file_sd_configs:
            - files: ["/etc/otelcol-contrib/targets/dpu-*.yaml"]

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

processors:
  memory_limiter:
    check_interval: 1s
    limit_percentage: 75
    spike_limit_percentage: 20
  resource/fabric:
    attributes:
      - key: site
        value: ${env:WS_SITE}
        action: upsert
      - key: cluster
        value: ${env:WS_CLUSTER}
        action: upsert
      - key: fabric
        value: ib-compute
        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")
  tail_sampling:
    decision_wait: 10s
    num_traces: 100000
    policies:
      - name: keep-errors
        type: status_code
        status_code:
          status_codes: [ERROR]
      - name: keep-slow
        type: latency
        latency:
          threshold_ms: 2000
      - name: baseline
        type: probabilistic
        probabilistic:
          sampling_percentage: 10
  batch:
    send_batch_size: 8192
    timeout: 5s

exporters:
  prometheusremotewrite/mimir:
    endpoint: https://mimir.obs.internal/api/v1/push
    headers:
      X-Scope-OrgID: ${env:WS_TENANT}
    resource_to_telemetry_conversion:
      enabled: true
    remote_write_queue:
      enabled: true
      queue_size: 20000
      num_consumers: 8
    retry_on_failure:
      enabled: true
      max_elapsed_time: 30m
  prometheusremotewrite/mimir-ha:
    endpoint: https://mimir.obs.internal/api/v1/push
    headers:
      X-Scope-OrgID: ${env:WS_TENANT}
    external_labels:
      replica: ${env:WS_GATEWAY_NAME}
    resource_to_telemetry_conversion:
      enabled: true
  otlp/tempo:
    endpoint: tempo-distributor.obs.internal:4317
    tls:
      ca_file: /etc/otelcol-contrib/ca.pem
    sending_queue:
      enabled: true
      storage: file_storage
  elasticsearch/logs:
    endpoints:
      - https://es-hot-1.obs.internal:9200
      - https://es-hot-2.obs.internal:9200
    logs_index: logs-ai.cluster-prod
    # ECS field names, so existing Kibana views and detection rules keep working
    mapping:
      allowed_modes: [ecs]
    auth:
      authenticator: basicauth/es
    tls:
      ca_file: /etc/otelcol-contrib/es-ca.pem

service:
  extensions: [health_check, file_storage, basicauth/ufm, basicauth/es]
  pipelines:
    metrics/forwarded:
      receivers: [otlp]
      processors: [memory_limiter, transform/hygiene, batch]
      exporters: [prometheusremotewrite/mimir]
    metrics/fabric:
      receivers: [prometheus/fabric]
      processors: [memory_limiter, resource/fabric, batch]
      exporters: [prometheusremotewrite/mimir-ha]
    logs:
      receivers: [otlp, syslog/fabric]
      processors: [memory_limiter, transform/hygiene, batch]
      exporters: [elasticsearch/logs]
    traces:
      receivers: [otlp]
      processors: [memory_limiter, tail_sampling, batch]
      exporters: [otlp/tempo]
  telemetry:
    metrics:
      level: detailed
      readers:
        - pull:
            exporter:
              prometheus:
                host: 0.0.0.0
                port: 8888

Hinweise zu den Entscheidungen:

  • Das Scrape-Intervall für Fabric-Zähler beträgt 60 Sekunden. Schneller hilft selten: Das UFM-Sample selbst, das Alarmfenster und die menschliche Reaktion bestimmen die Erkennungszeit (siehe die Datenfluss-Abbildung unten), und die Zeitreihen pro Port machen das Volumen aus.
  • Die Keep-List bei ufm-telemetry ist die mit Abstand wirksamste Kostenkontrolle im gesamten Design. Beginnen Sie eng; ergänzen Sie einen Zähler, wenn ein Dashboard oder ein Alarm ihn braucht.
  • resource_to_telemetry_conversion wandelt Ressourcenattribute in Labels um. Das setzt site, cluster, rack und fabric auf jede Zeitreihe, und genau so entstehen auch Kardinalitätsunfälle; deshalb setzen die Agenten nur die gewünschten Attribute, und der Hygiene-Prozessor entfernt bekannte Störenfriede.
  • Optional Loki. Wo ein Kunde Grafana für Logs bevorzugt, ergänzen Sie einen otlphttp/loki-Exporter, der auf den nativen OTLP-Endpunkt von Loki zeigt, und senden Logs dorthin statt an Elasticsearch, nicht zusätzlich.
  • Traces an Elastic. Kunden, die auf Elastic Observability standardisiert haben, können Traces statt an Tempo an den OTLP-Intake von Elastic senden; der Rest des Designs bleibt unverändert.

10. Prometheus-Scrape-Konfiguration (falls Sie Prometheus betreiben)

Manche Kunden behalten pro Standort ein Prometheus-HA-Paar, entweder weil sie bereits eines haben oder damit die lokale Alarmierung weiter funktioniert, wenn die Verbindung zum zentralen Speicher ausfällt. Dieselben Ziele sehen als reine Prometheus-Konfiguration so aus. Das externe Label replica ist das Einzige, was sich zwischen den beiden Servern unterscheidet.

# prometheus.yml (replica "a"; replica "b" is identical except for the label)
global:
  scrape_interval: 15s
  evaluation_interval: 30s
  external_labels:
    site: lon2
    cluster: ai-prod-1
    replica: a

rule_files:
  - /etc/prometheus/rules/*.yaml

scrape_configs:
  - job_name: dcgm
    file_sd_configs:
      - files: ["/etc/prometheus/targets/gpu-nodes.yaml"]
    relabel_configs:
      - source_labels: [__address__]
        regex: "([^:]+):.*"
        target_label: node
        replacement: "$1"
        action: replace

  - job_name: ufm-telemetry
    scrape_interval: 60s
    scrape_timeout: 50s
    metrics_path: /labels/enterprise
    static_configs:
      - targets: ["ufm-vip.obs.internal:8982"]
        labels:
          fabric: ib-compute
    metric_relabel_configs:
      - source_labels: [__name__]
        regex: "PortXmitDataExtended|PortRcvDataExtended|LinkDownedCounterExtended|LinkErrorRecoveryCounterExtended|LocalLinkIntegrityErrorsExtended|ExcessiveBufferOverrunErrorsExtended|Normalized_CBW|dev_temperature"
        action: keep

  - job_name: otel-collectors
    file_sd_configs:
      - files: ["/etc/prometheus/targets/otel-*.yaml"]

remote_write:
  - url: https://mimir.obs.internal/api/v1/push
    headers:
      X-Scope-OrgID: ai-prod
    queue_config:
      max_samples_per_send: 5000

Die Zieldateien tragen die Rack- und Rollen-Labels; sie stammen also aus derselben verlässlichen Quelle wie die Umgebungsvariablen der Agenten (unserem Inventar) und werden nie von Hand eingetippt:

# /etc/prometheus/targets/gpu-nodes.yaml
- targets: ["gpu-r07-01:9400", "gpu-r07-02:9400", "gpu-r07-03:9400", "gpu-r07-04:9400"]
  labels:
    rack: r07
    node_role: gpu

11. Flottenweites Labeling-Schema

Datenfluss: Ein von DCGM gelesener GPU-Zähler, ein von node-exporter oder DOCA gelesener Netzwerkadapter-Zähler und ein von UFM Telemetry gelesener Switch-Port-Zähler werden erfasst, mit Standort, Cluster, Fabric, Rack, Knoten und Rail gelabelt, in Mimir oder Elasticsearch gespeichert und in Grafana, Kibana und Alarmregeln verwendet.

Labels sind die Verknüpfungen der Observability. Wenn GPU-Metriken host="gpu-r07-03.lon2" sagen und Fabric-Metriken node="GPU-R07-03", wird keine Abfrage sie je verbinden. Wir legen ein Schema für jeden Kunden und jede Quelle fest:

LabelBeispielAufRegel
sitelon2allemRechenzentrum oder Halle; vom Collector gesetzt
clusterai-prod-1allemZugleich das HA-Cluster-Label von Mimir
envprodallemprod, staging, lab
fabricib-computeNetzwerkmetrikenib-compute, ib-storage, eth-frontend, eth-storage, nvlink
rackr07Knoten und SwitchesAus dem Inventar, nie zur Abfragezeit aus Hostnamen abgeleitet
nodegpu-r07-03KnotenmetrikenKurzer Hostname, Kleinbuchstaben; wir relabeln den Hostname von DCGM entsprechend
rail3GPU- und NIC-MetrikenRail-Nummer in rail-optimierten Fabrics; entspricht bei den meisten HGX-Designs dem GPU-Index
gpu, UUID3, GPU-…nur GPU-MetrikenAus dcgm-exporter; die UUID folgt der physischen GPU über RMAs hinweg
switch, portleaf-r07-a, 17Fabric-MetrikenBeim Relabeling aus den Geräte- und Port-Labels von UFM normalisiert
tenantgenomicsWorkload-MetrikenAus Kubernetes-Namespace-Labels oder dem Slurm-Account
hpc_job4471823nur GPU-MetrikenNie auf Fabric- oder Knotenmetriken (siehe Kardinalität)

Ist das eingerichtet, ist die Verknüpfung von Job und Fabric ein Paar PromQL-Joins über unsere beiden Info-Metriken, ws_job_node_info{hpc_job, node} (aus dem Scheduler-Exporter) und ws_ib_link_info{node, hca_port, switch, port} (aus dem UFM-Links-Exporter):

# link-error recoveries in the last hour on every switch port used by job 4471823
sum by (switch, port) (
  increase(LinkErrorRecoveryCounterExtended[1h])
    * on (switch, port) group_left (node)
      (ws_ib_link_info * on (node) group_left () ws_job_node_info{hpc_job="4471823"})
)

12. Alarmregeln

Diese Regeln laufen im Mimir-Ruler (oder in Prometheus) und werden über Alertmanager geroutet. Der Schweregrad page weckt jemanden auf; ticket geht in die Warteschlange. Die Schwellenwerte sind Ausgangspunkte, die wir im ersten Monat pro Standort justieren.

# rules/ai-cluster.yaml
groups:
  - name: gpu
    rules:
      - alert: GPUXidErrorReported
        expr: changes(DCGM_FI_DEV_XID_ERROR[10m]) > 0 and DCGM_FI_DEV_XID_ERROR != 0
        labels:
          severity: page
        annotations:
          summary: "XID error reported on {{ $labels.node }} GPU {{ $labels.gpu }}"
          runbook: "https://runbooks.obs.internal/gpu/xid"
      - alert: GPURowRemapFailed
        expr: DCGM_FI_DEV_ROW_REMAP_FAILED > 0
        labels:
          severity: page
        annotations:
          summary: "Row remapping failed on {{ $labels.node }} GPU {{ $labels.gpu }}: drain and RMA"
      - alert: GPUUncorrectableRowRemaps
        expr: increase(DCGM_FI_DEV_ROW_REMAP_UNCORRECTABLE_TOTAL[1h]) > 0
        labels:
          severity: ticket
        annotations:
          summary: "New uncorrectable-error row remaps on {{ $labels.node }} GPU {{ $labels.gpu }}"
      - alert: GPUTemperatureHigh
        # set per platform: air-cooled and liquid-cooled systems differ
        expr: max_over_time(DCGM_FI_DEV_GPU_TEMP_CELSIUS[10m]) > 85
        for: 10m
        labels:
          severity: ticket
      - alert: GPUPCIeReplays
        expr: increase(DCGM_FI_DEV_PCIE_REPLAY_TOTAL[15m]) > 100
        labels:
          severity: ticket
      - alert: GPUAllocatedButIdle
        expr: avg by (cluster, hpc_job) (avg_over_time(DCGM_FI_DEV_GPU_UTIL_RATIO{hpc_job!=""}[30m])) < 0.05
        for: 30m
        labels:
          severity: ticket
        annotations:
          summary: "Job {{ $labels.hpc_job }} has held GPUs for 30 minutes at under 5% utilisation"
      - alert: DCGMExporterDown
        expr: up{job="dcgm"} == 0
        for: 5m
        labels:
          severity: page

  - name: infiniband
    rules:
      - record: ws:ib_port_tx_bps:rate5m
        expr: rate(PortXmitDataExtended[5m]) * 8
      - record: ws:ib_port_rx_bps:rate5m
        expr: rate(PortRcvDataExtended[5m]) * 8
      - alert: IBLinkFlapping
        expr: increase(LinkDownedCounterExtended[15m]) >= 2
        labels:
          severity: page
        annotations:
          summary: "Link flapping on {{ $labels.switch }} port {{ $labels.port }}"
      - alert: IBLinkErrorRecovery
        expr: increase(LinkErrorRecoveryCounterExtended[15m]) > 0
        labels:
          severity: ticket
        annotations:
          summary: "Link retrained after errors on {{ $labels.switch }} port {{ $labels.port }}: check cable and transceiver"
      - alert: IBLinkIntegrityErrors
        expr: increase(LocalLinkIntegrityErrorsExtended[15m]) > 0
        labels:
          severity: ticket
      - alert: IBBufferOverruns
        expr: increase(ExcessiveBufferOverrunErrorsExtended[15m]) > 0
        labels:
          severity: ticket
      - alert: IBDeviceHot
        # PDR's default maximum temperature is also 70 C
        expr: dev_temperature > 70
        for: 10m
        labels:
          severity: ticket
      - alert: UFMTelemetryDown
        expr: up{job="ufm-telemetry"} == 0
        for: 5m
        labels:
          severity: page
      - alert: UFMTelemetryMissing
        expr: absent_over_time(PortXmitDataExtended{fabric="ib-compute"}[10m])
        labels:
          severity: page

  - name: pipeline
    rules:
      - alert: CollectorExportFailing
        expr: sum by (instance, exporter) (rate(otelcol_exporter_send_failed_metric_points_total[5m])) > 0
        for: 10m
        labels:
          severity: page
      - alert: CollectorQueueFilling
        expr: max by (instance, exporter) (otelcol_exporter_queue_size / otelcol_exporter_queue_capacity) > 0.8
        for: 10m
        labels:
          severity: ticket
      - alert: GatewayRedundancyLost
        expr: count(up{job="otel-gateway"} == 1) < 2
        for: 5m
        labels:
          severity: page
      - alert: ElasticsearchClusterRed
        expr: max(elasticsearch_cluster_health_status{color="red"}) == 1
        for: 2m
        labels:
          severity: page
      - alert: Watchdog
        # always firing; an external dead man's switch pages if it stops arriving
        expr: vector(1)
        labels:
          severity: heartbeat

Zwei Faustregeln. Erstens verlinkt jede Alarmierung ein Runbook, das sagt, was in den ersten zehn Minuten zu tun ist. Zweitens brauchen Alarme, die mit increase() auf Zählern auslösen, ein Fenster von mindestens dem Vierfachen des Scrape-Intervalls, sonst verdeckt ein einzelner verpasster Scrape das Ereignis; deshalb betragen die Fabric-Fenster bei 60-Sekunden-Scrapes 15 Minuten.

13. Logs und Ereignisse in den Elastic Stack

UFM-Ereignisse, Switch-Syslog, PDR-Entscheidungen, Slurm- und UFM-Slurm-Logs sowie Host-Logs gehen an Elasticsearch. Knoten-Logs kommen über die Collector-Pipeline oben an. Die eigenen Streams von UFM kommen über seine Fluentd-basierten Plugins an, die wir auf einem Fluentd-Aggregator (oder Logstash) neben den Gateways terminieren.

Fluentd: UFM-Ereignis- und -Telemetrie-Streams an Elasticsearch

Die Plugins EFS (Syslog-Streaming) und TFS (Telemetrie) senden über das Fluentd-Forward-Protokoll. Dieser Aggregator empfängt beide, fügt die Flotten-Labels hinzu und schreibt mit einem Festplattenpuffer in Data Streams, sodass ein Ausfall von Elasticsearch keine Ereignisse verliert. Er verwendet die Ausgabe fluent-plugin-elasticsearch.

# /etc/fluent/fluentd.conf  (aggregator next to the gateways)
<source>
  @type forward
  port 24224
  bind 0.0.0.0
</source>

<filter **>
  @type record_transformer
  <record>
    site lon2
    cluster ai-prod-1
    fabric ib-compute
  </record>
</filter>

<match **>
  @type elasticsearch_data_stream
  data_stream_name logs-ufm.events-prod
  hosts https://es-hot-1.obs.internal:9200,https://es-hot-2.obs.internal:9200
  user "#{ENV['ES_USER']}"
  password "#{ENV['ES_PASSWORD']}"
  ca_file /etc/fluent/es-ca.pem
  <buffer>
    @type file
    path /var/lib/fluentd/buffer/es
    flush_interval 10s
    chunk_limit_size 8MB
    total_limit_size 4GB
    retry_max_interval 60s
    retry_forever true
  </buffer>
</match>

In der Praxis teilen wir das mit zwei <match>-Blöcken auf die Tags auf, für deren Versand die beiden Plugins konfiguriert sind, sodass Ereignisse und Telemetrie in getrennten Data Streams mit unterschiedlicher Aufbewahrung landen. Telemetriezähler pro Port an Elasticsearch zu senden lohnt sich nur, wenn Elastic der einzige Metrikspeicher des Kunden ist; andernfalls gehen Zähler an Mimir und Elasticsearch erhält die Ereignisse.

Logstash: Switch-Syslog

An Standorten mit bestehender Logstash-Ebene kann Switch- und UFM-Syslog dort landen statt auf dem Syslog-Receiver des Collectors:

# /etc/logstash/conf.d/fabric-syslog.conf
input {
  syslog {
    port => 5514
  }
}

filter {
  if [message] =~ /(?i)link (down|up)|transceiver|module (inserted|removed)/ {
    mutate { add_tag => ["fabric_link_event"] }
  }
  mutate {
    add_field => {
      "site"    => "lon2"
      "cluster" => "ai-prod-1"
    }
  }
}

output {
  elasticsearch {
    hosts => ["https://es-hot-1.obs.internal:9200", "https://es-hot-2.obs.internal:9200"]
    data_stream => "true"
    data_stream_type => "logs"
    data_stream_dataset => "network.switch"
    data_stream_namespace => "prod"
    user => "${ES_USER}"
    password => "${ES_PASSWORD}"
    ssl_certificate_authorities => ["/etc/logstash/es-ca.pem"]
  }
}

Aufbewahrung mit Index Lifecycle Management

PUT _ilm/policy/ai-cluster-logs
{
  "policy": {
    "phases": {
      "hot":    { "actions": { "rollover": { "max_age": "1d", "max_primary_shard_size": "50gb" } } },
      "warm":   { "min_age": "7d",  "actions": { "forcemerge": { "max_num_segments": 1 } } },
      "cold":   { "min_age": "30d", "actions": { "set_priority": { "priority": 0 } } },
      "delete": { "min_age": "90d", "actions": { "delete": {} } }
    }
  }
}

Sicherheitsrelevante Streams (UFM-Audit, Authentifizierung) brauchen meist eine längere Aufbewahrung als 90 Tage; geben Sie ihnen einen eigenen Data Stream und eine eigene Richtlinie, statt alles zu verlängern.

Nützliche Kibana-Abfragen (KQL), die Sie als Ansichten speichern sollten:

data_stream.dataset : "network.switch" and tags : "fabric_link_event" and host.name : leaf-r07-*
data_stream.dataset : "ufm.events" and message : (*isolat* or *deisolat*)
data_stream.dataset : "ufm.events" and log.level : ("critical" or "error") and not message : *test*

14. Tracing von KI-Inferenz- und -Trainingsdiensten

Metriken sagen Ihnen, dass die Time to First Token gestiegen ist; Traces sagen Ihnen, wo die Zeit geblieben ist. Für eine Inferenzanfrage sind die nützlichen Spans die Anfrage, der Tokenizer, der Aufruf des Modellservers und das eigene Queueing, Prefill und Decode des Modellservers. Neuere Modellserver (darunter vLLM, Triton und NVIDIA NIM) können selbst OpenTelemetry-Traces ausgeben, wenn man ihnen einen OTLP-Endpunkt gibt; prüfen Sie die Flags für Ihre Version. Die Anwendungsseite sieht so aus, mit den Attributnamen der OpenTelemetry-GenAI-Semantic-Conventions:

from opentelemetry import trace
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter

provider = TracerProvider(resource=Resource.create({
    "service.name": "chat-gateway",
    "deployment.environment.name": "prod",
    "cluster": "ai-prod-1",
}))
# the local Collector agent; it adds node and rack labels
provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter(endpoint="http://127.0.0.1:4317", insecure=True)))
trace.set_tracer_provider(provider)
tracer = trace.get_tracer("ws.inference")


def handle_chat(req, tokenizer, model_client):
    with tracer.start_as_current_span("chat.completions", kind=trace.SpanKind.SERVER) as span:
        span.set_attribute("gen_ai.operation.name", "chat")
        span.set_attribute("gen_ai.request.model", req.model)

        with tracer.start_as_current_span("tokenize") as s:
            ids = tokenizer.encode(req.prompt)
            s.set_attribute("gen_ai.usage.input_tokens", len(ids))

        # the client propagates the W3C traceparent header, so the model
        # server's own spans (queue, prefill, decode) join this trace
        with tracer.start_as_current_span("model_server.generate", kind=trace.SpanKind.CLIENT) as s:
            out = model_client.generate(ids, max_tokens=req.max_tokens)
            s.set_attribute("gen_ai.usage.output_tokens", out.output_tokens)
            s.set_attribute("server.address", out.server)
            if out.gpu_uuid:  # if the server reports which GPU served the request
                s.set_attribute("ws.gpu.uuid", out.gpu_uuid)

        with tracer.start_as_current_span("detokenize"):
            return tokenizer.decode(out.token_ids)

Die GPU selbst gibt keine Spans aus. Wir verknüpfen den Trace mit der Hardware über die Ressourcenattribute, die der Agent hinzufügt (node, rack), und, wo der Server sie meldet, die GPU-UUID, und nutzen dann die Trace-to-Metrics-Links von Grafana, um von einem langsamen Span zu den DCGM-Panels dieser GPU und den Fabric-Ports dieses Knotens für dieselbe Minute zu springen. Latenz-Histogramme von Anfragen tragen Exemplars, sodass eine Spitze in einem Latenz-Panel direkt auf einen Beispiel-Trace verweist.

Beim Training wäre ein Span pro Step viel zu viel. Wir tracen die groben Phasen (Job-Start, Laden der Daten, jedes Speichern und Wiederherstellen eines Checkpoints, Evaluierung) und erfassen die Step-Zeit als Histogramm-Metrik mit dem Job-Label. Ein plötzlicher Anstieg der Step-Zeit bei gleichbleibender GPU-Auslastung und steigender Link-Error-Recovery an den Ports des Jobs ist die klassische Signatur eines Fabric-Fehlers, und die Verknüpfung von Job und Fabric aus Abschnitt 11 findet den Port.

15. Kardinalität und Aufbewahrung

Die Kardinalität, also die Anzahl unterschiedlicher Label-Kombinationen, bestimmt Speicherbedarf, Speicherplatz und Abfragekosten. KI-Cluster verhalten sich gutmütig, wenn Sie damit bewusst umgehen. Ein durchgerechnetes Beispiel für einen Cluster mit 32 Knoten und 256 GPUs mit einer rail-optimierten InfiniBand-Compute-Fabric (etwa 1.000 Ports, Host- und Switch-Enden zusammengezählt):

QuelleZeitreihenIntervallSamples pro Sekunde
UFM-Fabric-Zähler, 8 behaltene Zähler × ~1.000 Ports~8.00060 s~135
Dasselbe, wenn jeder Zähler eines Debug-Zählersatzes gestreamt wird (~100)~100.00060 s~1.670
DCGM, ~27 Standardfelder × 256 GPUs~6.90015 s~460
node-exporter nach der Keep-List, ~300 × 40 Knoten~12.00015 s~800
Collectors, Exporter, UFM-System, Dienste~5.00015–60 s~200
Gesamt (behaltene Zähler)~32.000~1.600

Bei etwa 1,5 Bytes pro komprimiertem Sample entsprechen 1.600 Samples pro Sekunde etwa 75 GB Objektspeicher pro Jahr. Das ist klein genug, dass wir Rohdaten für Cluster dieser Größe 13 Monate lang aufbewahren; die Aufbewahrung in Mimir gilt pro Mandant, daher legen sehr große Flotten langfristige Recording Rules in einen separaten Mandanten mit längerer Aufbewahrung als die Rohdaten.

Was Budgets sprengt, sind Labels, nicht Metriken:

  • Job-IDs auf Fabric- oder Knoten-Zeitreihen. Ein ausgelasteter Slurm-Cluster führt Tausende von Jobs pro Tag aus; jeder neue Wert erzeugt neue Zeitreihen. Behalten Sie hpc_job nur auf GPU-Zeitreihen und verknüpfen Sie über ws_job_node_info.
  • Pod-UIDs, Container-IDs, Request-IDs und Trace-IDs als Labels. Entfernen Sie sie im Gateway; Trace-IDs gehören in Exemplars.
  • Zähler pro Lane und pro Link überall. Aktivieren Sie NVLink-Fehlerzähler pro Link und Fabric-Zähler pro Lane für die Diagnose, beschränkt auf die untersuchten Knoten, nicht standardmäßig.
  • Rohe GUIDs zusätzlich zu Namen. Verwenden Sie den gelabelten UFM-Endpunkt und behalten Sie Namen; ein Identitäts-Label pro Objekt genügt.

Aufbewahrungsfristen, mit denen wir beginnen und die wir pro Kunde anpassen:

DatenSpeicherAufbewahrung
Metriken (roh)Mimir13 Monate für Cluster bis zu einigen hundert GPUs
Metriken (lokal, falls Prometheus verwendet wird)Prometheus15 Tage
TracesTempo14 Tage, nach Tail Sampling (alle Fehler, alle langsamen Anfragen, 10 % des Rests)
Fabric- und Host-Logs und -EreignisseElasticsearchHot 7 Tage, Warm bis 30, Cold bis 90, danach löschen
Audit- und Sicherheits-LogsElasticsearchWie es die Richtlinie des Kunden verlangt, oft ein Jahr oder mehr
Topologie-Snapshots und NDT-BerichteElasticsearch oder ObjektspeicherLebensdauer des Clusters

16. Hochverfügbarkeit des Observability-Stacks

HA-Topologie: Zwei Management-Racks an getrennten Stromzuführungen enthalten jeweils einen UFM-Server eines Active/Standby-Paars, einen Gateway-Collector, ein Prometheus-Replikat, eine Mimir-Zone, einen Alertmanager-Peer, Grafana, einen master-fähigen Elasticsearch-Knoten, Logstash und Kibana; eine dritte Quorum-Zone enthält die dritte Mimir-Zone, einen Alertmanager-Peer und einen reinen Voting-Master von Elasticsearch; Objektspeicher enthält Mimir-Blöcke und Snapshots.

Ein Monitoring, das gleichzeitig mit dem Überwachten ausfällt, ist Dekoration. Das Design verteilt jede zustandsbehaftete Komponente über drei Fehlerzonen (zwei Management-Racks an getrennten Stromzuführungen und eine kleine dritte Zone für das Quorum):

  • UFM: Active/Standby über die beiden Racks; alles kommuniziert mit der virtuellen IP. Plugins sind auf beiden Knoten geladen.
  • Collector-Gateways: mindestens zwei, beide aktiv. Agenten verwenden den Pool-Namen und eine persistente Queue, sodass der Verlust eines Gateways einen erneuten Versuch bedeutet, keine Lücke. Fabric-Scrapes laufen auf beiden und werden in Mimir dedupliziert.
  • Mimir: zonenbewusste Replikation mit Replikationsfaktor 3 und der HA-Tracker für die Fabric-Scrapes und eventuelle Prometheus-Paare.
  • Alertmanager: drei Peers im Gossip-Verbund, sodass jede Benachrichtigung einmal hinausgeht, plus ein externer Dead Man's Switch, gespeist vom Watchdog-Alarm.
  • Elasticsearch: drei master-fähige Knoten (einer davon reiner Voting-Knoten in der Quorum-Zone), ein Replikat pro Shard, Shard Allocation Awareness auf dem Zonenattribut und Snapshots in den Objektspeicher.
  • Grafana und Kibana: jeweils zwei Instanzen, zustandslos hinter einem Load Balancer; Grafana nutzt eine gemeinsame Datenbank, und beide werden aus Git bereitgestellt, sodass ein Neuaufbau ein Deployment ist.

Die entscheidende Konfiguration in Mimir:

# mimir.yaml (excerpt)
distributor:
  ha_tracker:
    enable_ha_tracker: true
    kvstore:
      store: etcd
      etcd:
        endpoints: ["etcd-1.obs.internal:2379", "etcd-2.obs.internal:2379", "etcd-3.obs.internal:2379"]

limits:
  accept_ha_samples: true
  ha_cluster_label: cluster
  ha_replica_label: replica
  compactor_blocks_retention_period: 395d

ingester:
  ring:
    replication_factor: 3
    zone_awareness_enabled: true
    # set per instance: zone-a, zone-b or zone-c
    instance_availability_zone: zone-a

Und in Elasticsearch, pro Knoten:

# elasticsearch.yml (zone A hot node; the zone C node uses node.roles: [ master, voting_only ])
cluster.name: obs-ai-prod
node.roles: [ master, data_hot, data_content, ingest ]
node.attr.zone: a
cluster.routing.allocation.awareness.attributes: zone
discovery.seed_hosts: [ "es-hot-1.obs.internal", "es-hot-2.obs.internal", "es-quorum-1.obs.internal" ]

Die Überwachung der Überwachung läuft außerhalb des Hauptpfads: Ein kleines separates Prometheus (oder eine gehostete Prüfung) überwacht die Gateways, Mimir, den Zustand von Elasticsearch und den Dead Man's Switch, sodass auch ein Totalausfall des Haupt-Stacks erkannt wird.

17. Der Nachweis, dass es funktioniert: Störungsübungen bei der Übergabe

Wir übergeben kein Dashboard, das wir nicht haben rot werden sehen. Für jeden neuen Cluster führen wir Folgendes durch und zeichnen es auf:

  1. Ein Kabel ziehen zwischen einem Leaf und einem Spine während eines Testjobs: Der Flap-Alarm alarmiert innerhalb des erwarteten Fensters, UFM löst ein Ereignis aus, das Ereignis ist in Kibana, und die Job-zu-Fabric-Ansicht zeigt, welcher Job diesen Port durchquert hat.
  2. Den aktiven UFM-Server ausfallen lassen: Der Standby übernimmt die virtuelle IP, die Scrapes werden fortgesetzt, und die Lücke in den Fabric-Daten ist kürzer als das Alarmfenster.
  3. Ein Gateway stoppen: kein Datenverlust, eine GatewayRedundancyLost-Alarmierung und Wiederherstellung, wenn es zurückkehrt.
  4. Einen Elasticsearch-Knoten und eine Mimir-Zone stoppen: Abfragen werden weiterhin beantwortet, Schreibvorgänge laufen weiter, Zustandsalarme lösen aus.
  5. PDR im Dry-Run ausführen gegen ein absichtlich grenzwertiges Kabel an einem Laborport: Die Entscheidung „würde isolieren“ erscheint im Log-Speicher.
  6. Ist-Zustand mit Design vergleichen mithilfe des NDT-Plugins und den Bericht in das Übergabepaket aufnehmen.

18. 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 UFM und Observability und die Engineers, die das Ganze danach gemeinsam mit Ihnen betreiben. NVIDIAs eigene Übersicht zu UFM finden Sie auf der offiziellen Seite NVIDIA Unified Fabric Manager (UFM).

  • Lieferung: GPU-Systeme, InfiniBand- und Ethernet-Switches, Adapter, Optiken und UFM-Lizenzen, gemeinsam spezifiziert.
  • Aufbau: UFM-HA, Plugins, Slurm- oder Kubernetes-Integration, DCGM und dcgm-exporter, Collector-Agenten und -Gateways sowie entweder unsere gehosteten Backends oder Ihre, alles aus versionierter Konfiguration.
  • Betrieb: Managed Observability rund um die Uhr: Alarm-Tuning, Upgrades (einschließlich Migrationen wie der Umbenennungen in dcgm-exporter 4.9.0), Kapazitätsplanung für den Monitoring-Stack und ein monatlicher Bericht zu GPU-Effizienz, Fabric-Fehlern und Kosten pro nutzbarer GPU-Stunde.

Für ein Gespräch zur Dimensionierung fragen Sie unseren KI-Sales-Engineer oder stöbern Sie in den Sortimenten Netzwerk und DGX im Shop.

19. Quellen und Hinweise zur Überprüfung

  • Übersicht und Stufen von NVIDIA UFM: die offizielle Seite NVIDIA Unified Fabric Manager (UFM).
  • UFM-SDK-Plugins, Ports, Pfade, Zählernamen und PDR-Standardwerte: die READMEs und Dashboards in Mellanox/ufm_sdk_3.0, gelesen im November 2026. Das Verhalten der Plugins ändert sich zwischen Releases; prüfen Sie das README für die Version, die Sie einsetzen.
  • Metriknamen von dcgm-exporter und die Umbenennungen in 4.9.0: etc/default-counters.csv und die Release Notes zu 4.9.0 in NVIDIA/dcgm-exporter.
  • Die Komponenten des OpenTelemetry Collectors stammen aus der Contrib-Distribution; Konfigurationsschlüssel ändern sich zwischen Releases, validieren Sie daher vor dem Deployment mit otelcol-contrib validate --config=....
  • Paketierung der UFM-Stufen sowie Details zu NetQ und zum DOCA Telemetry Service werden allgemein beschrieben; ziehen Sie für genaue Funktionen und Lizenzierung Ihrer Versionen die aktuelle Dokumentation von NVIDIA heran.
  • Mit ws: oder ws_ gekennzeichnete Zählernamen sind Konventionen von Workstation (Recording Rules und Info-Metriken), keine NVIDIA-Metriken.

Hinweis zu Schutzrechten: NVIDIA, das NVIDIA-Logo, DGX, HGX, Quantum, Spectrum, Spectrum-X, BlueField, ConnectX, NVLink, DOCA, DCGM 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 der öffentlichen Dokumentation von NVIDIA zusammengefasst; maßgebliche Quelle sind die Website und die Dokumentation von NVIDIA. Andere Firmen- und Produktnamen, darunter Prometheus, Grafana, Elasticsearch, Kibana, Logstash, OpenTelemetry, Kubernetes und Slurm, 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