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.
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.
| Schicht | Typische Fehler | NVIDIA-Quelle | Wie wir sie erfassen |
|---|---|---|---|
| GPU und NVLink | XID-Fehler, ECC- und Row-Remap-Ereignisse, thermische oder leistungsbedingte Drosselung, NVLink-Fehler, untätige GPUs in laufenden Jobs | DCGM (Host Engine) und dcgm-exporter | Prometheus-Scrape auf dem Knoten durch den Collector-Agenten |
| InfiniBand-Compute- und -Storage-Fabric | Link-Flaps, Symbol- und Integritätsfehler, mit falscher Geschwindigkeit oder Breite trainierte Links, Überlastung, heiße oder ausfallende Transceiver, Änderungen am Subnet Manager | UFM Telemetry und UFM Enterprise (Ereignisse, Alarme, Topologie, REST-API), SDK-Plugins | Prometheus-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-Änderungen | NetQ; Streaming-Telemetrie der Switches | NetQ-API oder gNMI- bzw. OTLP-Streaming der Switches in das Gateway |
| BlueField-DPU | Port- und Offload-Zähler, DPU-Zustand | DOCA Telemetry Service | Scrape seines Endpunkts im Prometheus-Format |
| Host und Storage-Clients | Speicherdruck, NVMe-Verschleiß, Dateisystem-Latenz, NIC-Fehler | (Standard-Linux-Werkzeuge) | node-exporter, filelog- und journald-Receiver |
| Scheduler und Orchestrierung | Hängende Jobs, gedrainte Knoten, GPU-Anforderungen ohne Auslastung | (Slurm, Kubernetes), UFM-Slurm-Integration | Job-zu-GPU-Labels aus dcgm-exporter; Scheduler-Exporter; Kubernetes-Metadaten |
| KI-Dienste | Langsame 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ähler | Was er Ihnen sagt |
|---|---|
PortXmitDataExtended, PortRcvDataExtended | Am 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) |
LinkDownedCounterExtended | Wie oft der Link ausgefallen ist: das Signal für Link-Flaps |
LinkErrorRecoveryCounterExtended | Wie oft der Link neu trainiert wurde, um sich von Fehlern zu erholen: oft das erste Anzeichen eines grenzwertigen Kabels |
LocalLinkIntegrityErrorsExtended | Lokale physische Fehler, die den Integritätsschwellenwert überschreiten |
ExcessiveBufferOverrunErrorsExtended | Aufeinanderfolgende Pufferüberläufe am Port |
Normalized_CBW | Ein Wert für die Überlastungsbandbreite, den UFM bereitstellt; NVIDIAs Dashboard stellt sein Maximum nach Topologieebene dar |
dev_temperature | Gerä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.
| Plugin | Was es tut | Wo es hineinpasst |
|---|---|---|
grafana_infiniband_telemetry_plugin | Stellt 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_plugin | Anleitung 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_plugin | Ein 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_plugin | Parst 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_plugin | Extrahiert 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_plugin | Anleitung zum Streamen von UFM-Ereignissen in Zabbix über den Zabbix-Agenten und Log-Items. | Für Betriebsteams, die Zabbix bereits als Ereigniskonsole nutzen. |
SLURM-Integration | Slurm-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_plugin | Problem 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_Plugin | Abgleich 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_plugin | Abonniert 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_plugin | Empfä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_plugin | Ein 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_plugin | Analysiert 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_plugin | Verbindet 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:
| Einstellung | Standard | Bedeutung |
|---|---|---|
INTERVAL | 300 s | Wie oft Telemetriezähler abgefragt werden |
MAX_NUM_ISOLATE | 10 | Obergrenze für isolierte Ports (der größere Wert aus diesem und 0,5 % der Fabric-Größe) |
TMAX / D_TMAX | 70 °C / 10 | Maximale Temperatur und maximaler Temperaturanstieg |
MAX_PDR | 1e-12 | Maximale Paketverlustrate |
CONFIGURED_BER_CHECK, CONFIGURED_TEMP_CHECK, LINK_DOWN_ISOLATION | True | Welche Prüfungen eine Isolierung auslösen dürfen |
SWITCH_TO_HOST_ISOLATION | True | Ob Zugangslinks zu Hosts isoliert werden dürfen |
DRY_RUN | False | Entscheidungen protokollieren statt handeln |
DEISOLATE_CONSIDER_TIME | 5 min | Wie lange ein Port fehlerfrei aussehen muss, bevor er wieder in Betrieb genommen wird |
MAX_PORT_RESET_NUM | 2 pro Woche | Erlaubte 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:
- Mit
DRY_RUN=Truefü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. - Die Ausschlussliste (Ports, die PDR nie anfassen darf, etwa einfach angebundene Storage-Links) über die REST-API des Plugins vereinbaren.
- Auf Live-Isolierung umstellen, wobei
SWITCH_TO_HOST_ISOLATIONpro Standort entschieden wird: Das Isolieren eines Host-Links entfernt diesen Knoten aus Jobs, was manchmal gewünscht ist und manchmal nicht. - 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.x | Name in 4.9.0 | Einheitenänderung |
|---|---|---|
DCGM_FI_DEV_GPU_UTIL | DCGM_FI_DEV_GPU_UTIL_RATIO | % zu 0–1 |
DCGM_FI_DEV_FB_USED | DCGM_FI_DEV_FB_USED_BYTES | MiB zu Bytes |
DCGM_FI_DEV_GPU_TEMP | DCGM_FI_DEV_GPU_TEMP_CELSIUS | keine |
DCGM_FI_DEV_POWER_USAGE | DCGM_FI_DEV_BOARD_POWER_WATTS | keine |
DCGM_FI_DEV_TOTAL_ENERGY_CONSUMPTION | DCGM_FI_DEV_GPU_ENERGY_JOULES_TOTAL | mJ zu J |
DCGM_FI_DEV_XID_ERRORS | DCGM_FI_DEV_XID_ERROR | keine (letzter XID-Wert) |
DCGM_FI_DEV_NVLINK_BANDWIDTH_TOTAL | DCGM_FI_DEV_NVLINK_THROUGHPUT_BYTES_PER_SECOND | MB/s zu B/s |
DCGM_FI_DEV_UNCORRECTABLE_REMAPPED_ROWS | DCGM_FI_DEV_ROW_REMAP_UNCORRECTABLE_TOTAL | keine |
DCGM_FI_DEV_ROW_REMAP_FAILURE | DCGM_FI_DEV_ROW_REMAP_FAILED | keine |
DCGM_FI_DEV_PCIE_REPLAY_COUNTER | DCGM_FI_DEV_PCIE_REPLAY_TOTAL | keine |
DCGM_FI_PROF_GR_ENGINE_ACTIVE | DCGM_FI_PROF_GR_ENGINE_UTIL_RATIO | keine (Verhältnis) |
DCGM_FI_PROF_PIPE_TENSOR_ACTIVE | DCGM_FI_PROF_TENSOR_UTIL_RATIO | keine (Verhältnis) |
DCGM_FI_PROF_DRAM_ACTIVE | DCGM_FI_PROF_DRAM_UTIL_RATIO | keine (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
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-telemetryist 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_conversionwandelt Ressourcenattribute in Labels um. Das setztsite,cluster,rackundfabricauf 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
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:
| Label | Beispiel | Auf | Regel |
|---|---|---|---|
site | lon2 | allem | Rechenzentrum oder Halle; vom Collector gesetzt |
cluster | ai-prod-1 | allem | Zugleich das HA-Cluster-Label von Mimir |
env | prod | allem | prod, staging, lab |
fabric | ib-compute | Netzwerkmetriken | ib-compute, ib-storage, eth-frontend, eth-storage, nvlink |
rack | r07 | Knoten und Switches | Aus dem Inventar, nie zur Abfragezeit aus Hostnamen abgeleitet |
node | gpu-r07-03 | Knotenmetriken | Kurzer Hostname, Kleinbuchstaben; wir relabeln den Hostname von DCGM entsprechend |
rail | 3 | GPU- und NIC-Metriken | Rail-Nummer in rail-optimierten Fabrics; entspricht bei den meisten HGX-Designs dem GPU-Index |
gpu, UUID | 3, GPU-… | nur GPU-Metriken | Aus dcgm-exporter; die UUID folgt der physischen GPU über RMAs hinweg |
switch, port | leaf-r07-a, 17 | Fabric-Metriken | Beim Relabeling aus den Geräte- und Port-Labels von UFM normalisiert |
tenant | genomics | Workload-Metriken | Aus Kubernetes-Namespace-Labels oder dem Slurm-Account |
hpc_job | 4471823 | nur GPU-Metriken | Nie 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):
| Quelle | Zeitreihen | Intervall | Samples pro Sekunde |
|---|---|---|---|
| UFM-Fabric-Zähler, 8 behaltene Zähler × ~1.000 Ports | ~8.000 | 60 s | ~135 |
| Dasselbe, wenn jeder Zähler eines Debug-Zählersatzes gestreamt wird (~100) | ~100.000 | 60 s | ~1.670 |
| DCGM, ~27 Standardfelder × 256 GPUs | ~6.900 | 15 s | ~460 |
| node-exporter nach der Keep-List, ~300 × 40 Knoten | ~12.000 | 15 s | ~800 |
| Collectors, Exporter, UFM-System, Dienste | ~5.000 | 15–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_jobnur auf GPU-Zeitreihen und verknüpfen Sie überws_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:
| Daten | Speicher | Aufbewahrung |
|---|---|---|
| Metriken (roh) | Mimir | 13 Monate für Cluster bis zu einigen hundert GPUs |
| Metriken (lokal, falls Prometheus verwendet wird) | Prometheus | 15 Tage |
| Traces | Tempo | 14 Tage, nach Tail Sampling (alle Fehler, alle langsamen Anfragen, 10 % des Rests) |
| Fabric- und Host-Logs und -Ereignisse | Elasticsearch | Hot 7 Tage, Warm bis 30, Cold bis 90, danach löschen |
| Audit- und Sicherheits-Logs | Elasticsearch | Wie es die Richtlinie des Kunden verlangt, oft ein Jahr oder mehr |
| Topologie-Snapshots und NDT-Berichte | Elasticsearch oder Objektspeicher | Lebensdauer des Clusters |
16. Hochverfügbarkeit des Observability-Stacks
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:
- 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.
- 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.
- Ein Gateway stoppen: kein Datenverlust, eine
GatewayRedundancyLost-Alarmierung und Wiederherstellung, wenn es zurückkehrt. - Einen Elasticsearch-Knoten und eine Mimir-Zone stoppen: Abfragen werden weiterhin beantwortet, Schreibvorgänge laufen weiter, Zustandsalarme lösen aus.
- PDR im Dry-Run ausführen gegen ein absichtlich grenzwertiges Kabel an einem Laborport: Die Entscheidung „würde isolieren“ erscheint im Log-Speicher.
- 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.csvund 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:oderws_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.