De shop is live

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

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

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

Neem contact op

AI-oplossingen

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

Producten

Alle productenWorkstation AI-native CRM & ERPMarketingOpenAI-agentsRing PromoterJobshout

Bedrijf

Over onsBedrijfAI-datacentersWaarom WorkstationPartnersKlantverhalenPrijzenContactTenthMatrix

Bronnen

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

© 2026 Workstation AI. Alle rechten voorbehouden.

PrivacyGegevensverwijderingCookiesServicevoorwaardenWebsite-sitemap

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

Home / Technische notities / Technology
AIHardwareObservability

NVIDIA-observability met OpenTelemetry: UFM SDK-plug-ins, DCGM, DOCA en NetQ naar Mimir, Grafana en de Elastic-stack

Elke UFM SDK-plug-in, telemetrie- en REST-endpoints van UFM, de hernoemde metrics in dcgm-exporter 4.9.0, een OpenTelemetry-ontwerp met agents en gateways en gevalideerde configuratie, alertregels, labeling, kardinaliteit, tracing voor inferentie en een high-available observability-stack

9 november 2026Technology35 min read

Een praktijkgids voor de observability-tooling van NVIDIA voor AI-clusters en hoe wij die met OpenTelemetry verbinden. De gids behandelt UFM en de open SDK-plug-ins, de REST-API en telemetrie-endpoints van UFM, DCGM en dcgm-exporter voor GPU's (inclusief de hernoemde metrics in dcgm-exporter 4.9.0), DOCA Telemetry Service op BlueField, NetQ voor Spectrum-X Ethernet en het referentieontwerp van Workstation: een OpenTelemetry Collector-agent op elke node, een gatewaypaar en twee backends (Prometheus-compatibele metrics in Grafana Mimir met Grafana en Tempo, en de Elastic-stack). Werkende configuratie, alertregels, een labelschema, kardinaliteitsberekeningen en het high-availability-ontwerp voor de monitoring zelf zijn inbegrepen. De businesscase staat in de bijbehorende blogpost.

Interactieve versie: bekijk zeventien voorbeelddashboards, elk met de bijbehorende PromQL of KQL en alertdrempels.

Telemetrie van GPU's, InfiniBand- en Ethernet-switches, BlueField-DPU's en AI-diensten stroomt via OpenTelemetry Collectors naar Prometheus, Mimir en Grafana, en naar Elasticsearch en Kibana.

Samenvatting. Verzamel elk signaal één keer, zo dicht bij de bron als zinvol is, label het met één schema voor de hele vloot en verdeel het over de backends die mensen al gebruiken. GPU-tellers komen uit DCGM, tellers en events van de InfiniBand-fabric uit UFM, data van de Ethernet-fabric uit NetQ of de switches, DPU-tellers uit DOCA Telemetry Service en request-traces uit de AI-diensten via de OpenTelemetry SDK. OpenTelemetry Collectors verzorgen labeling, filtering, sampling en routering. Metrics en traces gaan naar Mimir en Tempo, logs en events naar Elasticsearch, en de hele pipeline wordt zelf gemonitord en is high-available.

Dit artikel volgt het standpunt van onze eerdere technote over Big Prometheus en MoSCoW: OpenTelemetry is het telemetriecontract, de semantiek van Prometheus en PromQL zijn de taal voor metrics, en een horizontaal schaalbare opslag (hier Grafana Mimir) wordt ingezet zodra één Prometheus vragen over de hele vloot niet meer kan beantwoorden. Het enige dat we voor AI-clusters toevoegen, is een tweede backend voor logs, omdat de Elastic-stack zo vaak al aanwezig is voor security- en operationele teams. Logs gaan naar één primaire opslag, zoals dat artikel aanbeveelt; we schrijven dezelfde logs niet twee keer weg.

1. De signalen die ertoe doen in een AI-cluster

Een AI-cluster faalt in lagen. Een bruikbaar monitoringontwerp benoemt elke laag, de NVIDIA-tool die erover weet en hoe de data die tool verlaat.

LaagTypische storingenNVIDIA-bronHoe we het verzamelen
GPU en NVLinkXID-fouten, ECC- en row-remap-events, thermische of vermogensthrottling, NVLink-fouten, ongebruikte GPU's in lopende jobsDCGM (host engine) en dcgm-exporterPrometheus-scrape op de node door de Collector-agent
InfiniBand-fabric voor compute en opslagLink flaps, symbool- en integriteitsfouten, links die op de verkeerde snelheid of breedte zijn getraind, congestie, hete of falende transceivers, wijzigingen van de subnet managerUFM Telemetry en UFM Enterprise (events, alarmen, topologie, REST-API), SDK-plug-insPrometheus-scrape van UFM-telemetrie; UFM-events via syslog of Fluentd; REST-polling voor topologie
Ethernet-fabric (Spectrum-X, opslag en front-end)Drops, PFC-stormen, ECN-markering, RoCE-congestie, wijzigingen in BGP of EVPNNetQ; streaming telemetry van switchesNetQ-API of gNMI- of OTLP-streaming van switches naar de gateway
BlueField-DPUPoort- en offloadtellers, gezondheid van de DPUDOCA Telemetry ServiceScrape van het endpoint in Prometheus-formaat
Hosts en opslagclientsGeheugendruk, NVMe-slijtage, latency van het bestandssysteem, NIC-fouten(standaard Linux-tooling)node-exporter, filelog- en journald-receivers
Scheduler en orkestratieVastgelopen jobs, gedrainde nodes, GPU-aanvragen zonder utilisatie(Slurm, Kubernetes), UFM-integratie met SlurmJob-naar-GPU-labels uit dcgm-exporter; scheduler-exporters; Kubernetes-metadata
AI-dienstenTrage time to first token, wachtrijen, fouten, dalende tokendoorvoer(modelservers zoals NIM, Triton of vLLM)Traces en metrics via de OpenTelemetry SDK over OTLP

2. NVIDIA UFM: niveaus, telemetrie-endpoints en REST-API

Unified Fabric Manager (zie de officiële NVIDIA UFM-pagina) beheert en observeert InfiniBand-fabrics. Het bestaat in drie niveaus die op elkaar voortbouwen:

  • UFM Telemetry bemonstert prestatie- en fouttellers van elke poort in de fabric, samen met kabel- en transceiverdata, en stelt die beschikbaar of streamt ze. Het is alleen een zichtbaarheidslaag.
  • UFM Enterprise voegt fabricbeheer toe: discovery en topologie, aansturing van de subnet manager, beheer van partition keys (PKeys), events en alarmen, gezondheids- en topologierapporten, de REST-API, integraties met schedulers en clustermanagers, en een actief/standby-paar voor high availability.
  • UFM Cyber-AI past analytics en machine learning toe op de telemetriehistorie van Enterprise om falende links en kabels te voorspellen en afwijkingen in prestaties of gebruik te signaleren.

Telemetrie-endpoints

De telemetriedienst van UFM serveert de tellers via HTTP, standaard op poort 9001. Er is een CSV-weergave (bijvoorbeeld /csv/metrics, plus weergaven per tellerset zoals /csv/xcset/ib_basic_debug) en, als het genereren van Prometheus-labels is ingeschakeld, een Prometheus-endpoint waarvan de SDK-documentatie het pad opgeeft als labels/enterprise. Weergaven per tellerset accepteren shardingparameters (num_shards, shard, sharding_field=port_guid), wat helpt wanneer één verzoek voor een grote fabric te groot is om binnen een scrape-interval te beantwoorden.

Tellernamen volgen de performance-management-attributen van InfiniBand. De tellers die we in het eigen SDK-materiaal van NVIDIA hebben bevestigd, en waarop we hieronder voortbouwen, zijn:

TellerWat het u vertelt
PortXmitDataExtended, PortRcvDataExtendedVerzonden en ontvangen data op de poort; neem de rate voor bandbreedte (NVIDIA's eigen Grafana-dashboard vermenigvuldigt de rate met 8 om bits per seconde te tonen)
LinkDownedCounterExtendedAantal keren dat de link down ging: het signaal voor link flaps
LinkErrorRecoveryCounterExtendedAantal keren dat de link opnieuw trainde om van fouten te herstellen: vaak het eerste teken van een marginale kabel
LocalLinkIntegrityErrorsExtendedLokale fysieke fouten boven de integriteitsdrempel
ExcessiveBufferOverrunErrorsExtendedOpeenvolgende bufferoverruns op de poort
Normalized_CBWEen congestiebandbreedtecijfer dat UFM beschikbaar stelt; NVIDIA's dashboard plot het maximum per topologieniveau
dev_temperatureApparaattemperatuur

De exacte set en labelnamen hangen af van de tellerset die u inschakelt en de UFM-versie, dus vraag altijd op wat uw endpoint daadwerkelijk serveert voordat u regels schrijft: curl -s http://<ufm-host>:9001/csv/metrics | head.

REST-API

De REST-API van UFM Enterprise staat onder /ufmRest op de UFM-server, met verwante prefixen voor andere authenticatiemethoden: /ufmRestV2 (sessie), /ufmRestV3 (access token) en /ufmRestKrb (Kerberos). Tokens worden aangemaakt met een POST naar /app/tokens. Voor monitoring gebruiken we drie read-only resources, die allemaal in de SDK-voorbeelden van NVIDIA voorkomen:

# 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

We verpakken de links-aanroep in een kleine exporter die elke vijf minuten een info-metric publiceert, ws_ib_link_info{node, hca_port, switch, port}. Met die metric kan een query van een Slurm-job naar zijn GPU's naar de exacte switchpoorten lopen waar zijn verkeer overheen gaat. Het is onze conventie, geen NVIDIA-metric.

High availability

UFM Enterprise draait als actief/standby-paar dat wordt beheerd door de eigen HA-tooling (ufm_ha_cluster), met configuratie die tussen de twee servers wordt gerepliceerd en een virtueel IP-adres dat bij failover meeverhuist. Laat elke scrape, REST-client en syslog-bestemming naar het virtuele IP-adres wijzen, nooit naar een node. Waar een plug-in in HA wordt gebruikt, schrijven de instructies van NVIDIA voor het container-image ook op de standby-node te laden, zodat het na failover klaarstaat.

3. De UFM SDK en de plug-ins

NVIDIA publiceert een open SDK voor UFM op github.com/Mellanox/ufm_sdk_3.0. Het grootste deel is een set plug-ins: containers die UFM beheert via de plug-inmanager (vanuit de web-UI, of met /opt/ufm/scripts/manage_ufm_plugins.sh add -p <name> op een standalone- of HA-installatie). Hieronder staat wat elke plug-in doet en hoe die in ons ontwerp past.

Plug-inWat het doetWaar het past
grafana_infiniband_telemetry_pluginServeert een tweede Prometheus-endpoint (poort 8982, pad /labels/enterprise) met leesbare labels, zoals apparaatnamen in plaats van labels op basis van GUID's, en levert een voorbeelddashboard voor Grafana.Ons favoriete scrape-target voor fabrictellers: leesbare labels betekenen minder relabelregels.
grafana_telemetry_pluginInstructies en een dashboard om het eigen Prometheus-endpoint van UFM Telemetry (poort 9001) direct te scrapen.Gebruik dit als u de plug-in hierboven niet kunt draaien; reken op labels op basis van GUID's.
grafana_ufm_monitoring_pluginEen dashboard voor de eigen systeemgezondheid van UFM, gescraped van /ufmRest/system_monitoring/metrics via HTTPS met basic authentication.Monitort de monitor: CPU, geheugen en API-gezondheid van de UFM-servers.
ufm_events_grafana_dashboard_pluginParseert het event.log van UFM met Fluentd, pusht het naar een meegeleverde Loki en toont het in een meegeleverde Grafana.Goed voor een snelle start; in productie sturen we events in plaats daarvan naar de centrale logopslag.
fluentd_telemetry_plugin (TFS)Pollt een of meer UFM-telemetrie-endpoints met een eigen interval per endpoint en streamt de tellers naar een Fluentd-bestemming (standaard het forward-protocol op 24224, of HTTP). Attributen kunnen via de REST-API worden in- of uitgeschakeld of hernoemd, en de plug-in publiceert eigen streamingstatistieken in Prometheus-formaat.De route voor fabrictellers naar Elasticsearch wanneer een klant ook voor metrics, naast logs, op Elastic heeft gestandaardiseerd.
fluentd_topology_pluginHaalt topologie op via de UFM-API en streamt die via het Fluentd-protocol.Topologiesnapshots in de logopslag, zodat u ziet hoe de fabric eruitzag op het moment van een incident.
ufm_syslog_streaming_plugin (EFS)Haalt UFM-events uit de syslog en streamt ze naar Fluentd (compatibel met Fluent Bit), en kan UFM-syslog ook kopiëren naar een externe syslog-server.Onze hoofdroute voor UFM-events en -alarmen naar Elasticsearch.
zabbix_telemetry_pluginInstructies om UFM-events via de Zabbix-agent en log-items naar Zabbix te streamen.Voor operationele teams die Zabbix al als eventconsole gebruiken.
SLURM-IntegrationSlurm-prolog- en -epilog-hooks die UFM voor elke job aanroepen: statische of dynamische (per job, afgeleid van de job-ID) partition keys, waarbij UFM SHARP-reserveringen automatisch beheert op basis van PKey-lidmaatschap. Ondersteunt token-, basic- of Kerberos-authenticatie. UFM moet in managementmodus draaien, niet alleen in monitoringmodus.Netwerkisolatie per job en een registratie van welke job welke poorten gebruikte.
pdr_deterministic_pluginProblem Detection and Resolution: gebruikt dynamische UFM-telemetrie om bitfoutfrequenties, temperaturen en link-down-delta's te berekenen, isoleert poorten die drempels overschrijden, registreert ze en heft de isolatie op na een schone testperiode. Heeft een dry-run-modus en een uitsluitingslijst.Automatische isolatie van slechte links zodat jobs eromheen routeren; zie sectie 4.
UFM_NDT_PluginVergelijking met de Network Design Tool: upload de beoogde topologie, vergelijk die eenmalig of volgens schema met wat UFM ontdekte, en lees de rapporten via de REST-API.Bewijst bij de overdracht en na onderhoud dat de gerealiseerde bekabeling overeenkomt met het ontwerp.
gnmi_nvos_events_pluginAbonneert zich via gNMI op "on change"-systeemevents van door NVOS beheerde switches en zet die om in externe UFM-events.Brengt events aan de switchkant (bijvoorbeeld een transceiver-reset) in dezelfde UFM-eventstroom.
snmp_receiver_pluginLuistert naar SNMP-traps van beheerde switches en leidt ze als events naar UFM.Hetzelfde idee voor switches die alleen traps versturen.
grpc_streamer_pluginEen gRPC-server die UFM-REST-data (events, alarmen, links en andere) eenmalig of als periodieke stream teruggeeft, optioneel alleen de wijzigingen. NVIDIA markeert hem als in ontwikkeling.Nog niet in ons productieontwerp; we volgen het als alternatief met lagere latency voor REST-polling.
ufm_log_analyzer_pluginAnalyseert offline een UFM-sysdump of logs en levert bevindingen en een pdf-rapport op. NVIDIA markeert hem als in ontwikkeling en voor intern gebruik.Nuttig voor supportcases; geen onderdeel van live monitoring.
bright_pluginVerbindt UFM met Bright Cluster Manager (nu NVIDIA Base Command Manager) en haalt nodestatus en jobtoewijzingen naar UFM.Zet workloadcontext naast netwerkevents voor root-cause-onderzoek op clusters die met BCM worden beheerd.

De meeste plug-ins worden geleverd als images op Docker Hub (mellanox/ufm-plugin-*); PDR wordt gedownload van het NVIDIA Licensing Portal. Voor air-gapped locaties documenteert de SDK de gebruikelijke route met docker save en docker load, en we nemen de images op in de offline bundel die we vóór verzending klaarzetten.

4. Problem Detection and Resolution in de praktijk

PDR is de plug-in die de operatie het meest verandert, dus die verdient een eigen sectie. Het configuratiebestand stelt de drempels direct beschikbaar. De standaardwaarden in de SDK op het moment van schrijven zijn:

InstellingStandaardBetekenis
INTERVAL300 sHoe vaak telemetrietellers worden opgevraagd
MAX_NUM_ISOLATE10Bovengrens voor geïsoleerde poorten (de grootste van deze waarde en 0,5% van de fabricgrootte)
TMAX / D_TMAX70 °C / 10Maximale temperatuur en maximale temperatuurstijging
MAX_PDR1e-12Maximale packet drop rate
CONFIGURED_BER_CHECK, CONFIGURED_TEMP_CHECK, LINK_DOWN_ISOLATIONTrueWelke controles isolatie mogen activeren
SWITCH_TO_HOST_ISOLATIONTrueOf toegangslinks naar hosts mogen worden geïsoleerd
DRY_RUNFalseBeslissingen loggen in plaats van handelen
DEISOLATE_CONSIDER_TIME5 minHoe lang een poort gezond moet ogen voordat hij weer in gebruik wordt genomen
MAX_PORT_RESET_NUM2 per weekToegestane poortresets voordat een resetvenster wordt vrijgegeven

De bitfoutcontrole bewaakt symboolfouten over korte en lange vensters (ongeveer 12 en 125 minuten), en daarom vangt de plug-in kabels die degraderen in plaats van alleen kabels die al zijn uitgevallen. Onze uitrol is altijd hetzelfde:

  1. Schakel in met DRY_RUN=True voor twee tot vier weken en stuur het log naar Elasticsearch. Elke regel "would isolate" wordt een ticket dat we toetsen aan de UFM-tellers.
  2. Spreek via de REST-API van de plug-in de uitsluitingslijst af (poorten die PDR nooit mag aanraken, zoals enkelvoudig aangesloten opslaglinks).
  3. Schakel over op live isolatie, waarbij SWITCH_TO_HOST_ISOLATION per locatie wordt bepaald: het isoleren van een hostlink haalt die node uit jobs, wat soms gewenst is en soms niet.
  4. Alert bij elke isolatie en opheffing daarvan, en maak een onderhoudsticket aan voor de fysieke reparatie.

5. GPU-telemetrie: DCGM en dcgm-exporter

NVIDIA Data Center GPU Manager (DCGM) is de dienst voor GPU-gezondheid en -telemetrie; dcgm-exporter zet de velden ervan om in Prometheus-metrics, standaard op poort 9400. Op Kubernetes wordt het normaal uitgerold door de NVIDIA GPU Operator; op Slurm-clusters draaien we het als systemd-service of container naast de DCGM host engine.

dcgm-exporter 4.9.0 hernoemde de standaardmetrics

Release 4.9.0 (november 2026) hernoemt de standaard- en profilingvelden naar hun DCGM 4.7-namen, en bij elf daarvan verandert de eenheid: klokfrequenties naar hertz, energie naar joule, utilisatie van een percentage naar een ratio van 0 tot 1, geheugen van MiB naar bytes en NVLink-doorvoer naar bytes per seconde. Dashboards en alerts die voor 4.8.x zijn geschreven, worden ongemerkt leeg, of erger: ze vergelijken een ratio met een percentage. De standaardmetrics die we het meest gebruiken:

Naam in 4.8.xNaam in 4.9.0Wijziging van eenheid
DCGM_FI_DEV_GPU_UTILDCGM_FI_DEV_GPU_UTIL_RATIO% naar 0–1
DCGM_FI_DEV_FB_USEDDCGM_FI_DEV_FB_USED_BYTESMiB naar bytes
DCGM_FI_DEV_GPU_TEMPDCGM_FI_DEV_GPU_TEMP_CELSIUSgeen
DCGM_FI_DEV_POWER_USAGEDCGM_FI_DEV_BOARD_POWER_WATTSgeen
DCGM_FI_DEV_TOTAL_ENERGY_CONSUMPTIONDCGM_FI_DEV_GPU_ENERGY_JOULES_TOTALmJ naar J
DCGM_FI_DEV_XID_ERRORSDCGM_FI_DEV_XID_ERRORgeen (laatste XID-waarde)
DCGM_FI_DEV_NVLINK_BANDWIDTH_TOTALDCGM_FI_DEV_NVLINK_THROUGHPUT_BYTES_PER_SECONDMB/s naar B/s
DCGM_FI_DEV_UNCORRECTABLE_REMAPPED_ROWSDCGM_FI_DEV_ROW_REMAP_UNCORRECTABLE_TOTALgeen
DCGM_FI_DEV_ROW_REMAP_FAILUREDCGM_FI_DEV_ROW_REMAP_FAILEDgeen
DCGM_FI_DEV_PCIE_REPLAY_COUNTERDCGM_FI_DEV_PCIE_REPLAY_TOTALgeen
DCGM_FI_PROF_GR_ENGINE_ACTIVEDCGM_FI_PROF_GR_ENGINE_UTIL_RATIOgeen (ratio)
DCGM_FI_PROF_PIPE_TENSOR_ACTIVEDCGM_FI_PROF_TENSOR_UTIL_RATIOgeen (ratio)
DCGM_FI_PROF_DRAM_ACTIVEDCGM_FI_PROF_DRAM_UTIL_RATIOgeen (ratio)

Ook het label voor de driverversie verandert, van DCGM_FI_DRIVER_VERSION naar DCGM_FI_SYSTEM_DRIVER_VERSION. Lees de upgradechecklist van NVIDIA voordat u upgradet. Tijdens een uitrol met gemengde versies overbruggen we de twee met recording rules, zodat dashboards alleen de ws:-namen bevragen:

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

Elk voorbeeld in de rest van dit artikel gebruikt de namen van 4.9.0.

Welke GPU-metric betekent "bezet"?

DCGM_FI_DEV_GPU_UTIL_RATIO zegt alleen dat er tijdens de sample een kernel draaide; een GPU die binnen een collective op het netwerk wacht, kan nog steeds dicht bij 1 uitkomen. Voor efficiëntierapportage gebruiken we de profilingvelden: DCGM_FI_PROF_GR_ENGINE_UTIL_RATIO en DCGM_FI_PROF_TENSOR_UTIL_RATIO. Die vereisen de profilingmodule van DCGM en kunnen conflicteren met andere profilers zoals Nsight Compute op dezelfde GPU, dus we pauzeren het verzamelen van profilingmetrics wanneer engineers handmatig profilen.

Job- en podlabels

Op Kubernetes voegt dcgm-exporter de labels namespace, pod en container toe voor de workload die elke GPU gebruikt. Op Slurm leest de HPC-jobmapping een map met bestanden per GPU die een Slurm-prolog schrijft en de epilog leegmaakt, en voegt een label hpc_job toe. Versie 4.9.0 maakt dit robuuster (symbolische links in de mappingmap worden geweigerd en de grootte van bestanden en job-ID's wordt begrensd) en hernoemt elk podlabel met de naam hpc_job, zodat de twee niet botsen.

NVLink en NVSwitch

Binnen een HGX- of DGX B300-systeem communiceren GPU's via NVLink door NVSwitch. De standaardset geeft de totale NVLink-doorvoer per GPU; de NVLink-fouttellers zijn optioneel en verschillen per GPU-generatie, dus we schakelen de juiste in via de counters-CSV: op Blackwell-systemen zoals B300 de recoverytellers (DCGM_FI_DEV_NVLINK_RECOVERY_EVENT_TOTAL, DCGM_FI_DEV_NVLINK_RECOVERY_SUCCESSFUL_TOTAL en DCGM_FI_DEV_NVLINK_RECOVERY_FAILED_TOTAL); op Hopper de data-link-tellers (DCGM_FI_DEV_NVLINK_CRC_ERROR_TOTAL, DCGM_FI_DEV_NVLINK_REPLAY_TOTAL, DCGM_FI_DEV_NVLINK_RECOVERY_TOTAL). De oudere velden …_CRC_FLIT_ERROR_TOTAL en …_REPLAY_ERROR_TOTAL gelden alleen voor GPU's van vóór Hopper. NVL72-systemen op rackschaal voegen tussen trays een NVLink-switchfabric toe met eigen beheersoftware, en die behandelen we in het labelschema als een aparte fabric.

6. BlueField-DPU's en Spectrum-X Ethernet

DOCA Telemetry Service (DTS) draait als container op BlueField-DPU's (en kan draaien op hosts met ConnectX-adapters). De dienst verzamelt via een set providers tellers van de DPU en de poorten ervan en stelt die onder meer beschikbaar op een endpoint in Prometheus-formaat. We scrapen dat endpoint vanuit de fabric-collector met een bestandsgebaseerde targetlijst van managementadressen van DPU's, en labelen elke DPU met de host die hij bedient.

NetQ is de monitoring- en validatietool van NVIDIA voor Ethernet-fabrics op basis van Cumulus Linux en SONiC, inclusief Spectrum-X. Het verzamelt status en tellers van agents op de switches, bewaart historie zodat u kunt vragen wat er wanneer veranderde, en valideert de fabric tegen de beoogde configuratie. Voor AI-fabrics op basis van RoCE zijn de belangrijkste tellers drops, PFC-pauseframes, met ECN gemarkeerde pakketten en bufferbezetting. Er zijn drie praktische manieren om dit in de centrale stack te brengen, en we kiezen per locatie:

  • NetQ houden als tool van het netwerkteam en samenvattingen en events uit de API ervan naar de logopslag halen;
  • direct vanaf de switches streamen (gNMI, of OTLP op recente releases van Cumulus Linux; controleer de documentatie van uw versie) naar de gateway-collectors;
  • voor oudere switches terugvallen op SNMP en syslog.

Tellernamen verschillen tussen deze paden, dus we normaliseren ze naar onze eigen namen voor recording rules (ws:eth_pfc_pause_rx:rate5m, ws:eth_ecn_marked:rate5m, ws:eth_drops:rate5m) en bouwen dashboards alleen daarop.

7. Het OpenTelemetry-referentieontwerp van Workstation

Referentiearchitectuur: GPU-nodes draaien dcgm-exporter, node-exporter en een OpenTelemetry Collector-agent; endpoints van UFM, NetQ en DOCA worden gescraped door een fabric-collector; een paar gateway-collectors voegt labels toe, filtert en samplet en exporteert naar Mimir, Tempo, Grafana en Alertmanager en naar Logstash, Elasticsearch en Kibana.

Het ontwerp heeft drie lagen Collectors:

  • Een agent op elke GPU-, opslag- en loginnode, draaiend als systemd-service of Kubernetes-DaemonSet. De agent scrapet lokale exporters via loopback, volgt lokale logs, ontvangt OTLP van lokale diensten, voegt host- en Kubernetes-metadata toe en stuurt alles door naar de gateways. Hij houdt een kleine persistente wachtrij bij, zodat een herstart van een gateway niets kost.
  • Een gatewaypaar (of meer), achter een virtueel IP-adres of DNS-naam. Gateways passen beleid voor de hele vloot toe: labels, opschonen van attributen, filtering, tail sampling van traces en routering naar backends. Credentials voor de backends staan alleen hier.
  • Een fabric-pipeline op de gatewayhosts die endpoints van UFM, DOCA en switches scrapet en syslog ontvangt. Beide gateways draaien die; de dubbele samples worden in Mimir verwijderd door de HA-tracker (sectie 16).

Waarom laat u niet elke node rechtstreeks naar de backends schrijven? Omdat de gateway de plek is waar beleidswijzigingen één keer gebeuren, waar secrets van honderden nodes weg blijven, en waar een backendmigratie (bijvoorbeeld Elasticsearch toevoegen voor een securityteam) een configuratiewijziging op twee servers is in plaats van een uitrol over de hele vloot.

8. Configuratie van de Collector-agent

Dit is de agent die we op een Slurm-GPU-node uitrollen, alleen ontdaan van locatiespecifieke certificaten. Hij vereist de distributie otelcol-contrib, of een eigen build met dezelfde componenten.

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

Op Kubernetes-nodes voegen we de processor k8sattributes toe aan de agent (niet aan de gateway, want tegen de tijd dat data een gateway bereikt, is het oorspronkelijke pod-IP-adres verdwenen) en filteren we die op de lokale node:

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. Gatewayconfiguratie en de twee backends

De gateway ontvangt OTLP van agents, draait de fabric-scrapes en syslog en exporteert naar beide backends. Er zijn twee metrics-pipelines: één voor data die van agents wordt doorgestuurd (uniek, dus geen replica-label) en één voor de fabric-scrapes die beide gateways draaien (gelabeld met de replicanaam van de gateway, zodat Mimir één kopie bewaart).

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

Toelichting bij de keuzes:

  • Het scrape-interval voor fabrictellers is 60 seconden. Sneller helpt zelden: de UFM-sample zelf, het alertvenster en de menselijke reactie bepalen de detectietijd (zie de figuur over de datastroom hieronder), en series per poort zijn waar het volume zit.
  • De keep-list op ufm-telemetry is de effectiefste kostenbeheersing in het hele ontwerp. Begin smal; voeg een teller toe wanneer een dashboard of alert die nodig heeft.
  • resource_to_telemetry_conversion zet resource-attributen om in labels. Daardoor staan site, cluster, rack en fabric op elke serie, en zo ontstaan ook kardinaliteitsongelukken; daarom stellen de agents alleen de attributen in die we willen en verwijdert de hygiëneprocessor bekende boosdoeners.
  • Optioneel Loki. Waar een klant Grafana verkiest voor logs, voegt u een exporter otlphttp/loki toe die naar het native OTLP-endpoint van Loki wijst, en stuurt u logs daarheen in plaats van naar Elasticsearch, niet daarnaast.
  • Traces naar Elastic. Klanten die op Elastic Observability hebben gestandaardiseerd, kunnen traces naar de OTLP-intake van Elastic sturen in plaats van naar Tempo; de rest van het ontwerp blijft ongewijzigd.

10. Scrape-configuratie voor Prometheus (als u Prometheus draait)

Sommige klanten houden per locatie een Prometheus-HA-paar, omdat ze dat al hebben of om lokale alerting werkend te houden als de verbinding met de centrale opslag uitvalt. Dezelfde targets, uitgedrukt als gewone Prometheus-configuratie, zien er zo uit. Het externe label replica is het enige dat tussen de twee servers verschilt.

# 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

De targetbestanden dragen de rack- en rollabels, dus ze komen uit dezelfde bron van waarheid als de omgevingsvariabelen van de agents (onze inventaris), nooit met de hand getypt:

# /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. Labelschema voor de hele vloot

Datastroom: een GPU-teller gelezen door DCGM, een teller van een netwerkadapter gelezen door node-exporter of DOCA en een teller van een switchpoort gelezen door UFM Telemetry worden verzameld, gelabeld met locatie, cluster, fabric, rack, node en rail, opgeslagen in Mimir of Elasticsearch en gebruikt in Grafana, Kibana en alertregels.

Labels zijn de joins van observability. Als GPU-metrics host="gpu-r07-03.lon2" zeggen en fabricmetrics node="GPU-R07-03", zal geen enkele query ze ooit verbinden. We leggen één schema vast voor elke klant en elke bron:

LabelVoorbeeldOpRegel
sitelon2allesDatacenter of hal; ingesteld door de collector
clusterai-prod-1allesOok het HA-clusterlabel van Mimir
envprodallesprod, staging, lab
fabricib-computenetwerkmetricsib-compute, ib-storage, eth-frontend, eth-storage, nvlink
rackr07nodes en switchesUit de inventaris, nooit tijdens de query afgeleid uit hostnamen
nodegpu-r07-03nodemetricsKorte hostnaam, kleine letters; we relabelen Hostname van DCGM zodat die overeenkomt
rail3GPU- en NIC-metricsRailnummer in rail-geoptimaliseerde fabrics; gelijk aan de GPU-index bij de meeste HGX-ontwerpen
gpu, UUID3, GPU-…alleen GPU-metricsUit dcgm-exporter; de UUID volgt de fysieke GPU door RMA's heen
switch, portleaf-r07-a, 17fabricmetricsBij het relabelen genormaliseerd uit de apparaat- en poortlabels van UFM
tenantgenomicsworkloadmetricsUit labels van Kubernetes-namespaces of het Slurm-account
hpc_job4471823alleen GPU-metricsNooit op fabric- of nodemetrics (zie kardinaliteit)

Als dat staat, is de join van job naar fabric een paar PromQL-joins via onze twee info-metrics, ws_job_node_info{hpc_job, node} (uit de scheduler-exporter) en ws_ib_link_info{node, hca_port, switch, port} (uit de 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. Alertregels

Deze regels draaien in de Mimir-ruler (of Prometheus) en lopen via Alertmanager. Ernst page maakt iemand wakker; ticket gaat naar de wachtrij. Drempels zijn startpunten die we in de eerste maand per locatie afstemmen.

# 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

Twee vuistregels. Ten eerste linkt elke page naar een runbook dat zegt wat er in de eerste tien minuten moet gebeuren. Ten tweede hebben alerts die met increase() op tellers afgaan een venster nodig van minstens vier keer het scrape-interval, anders verbergt één gemiste scrape het event; daarom zijn de fabricvensters 15 minuten bij scrapes van 60 seconden.

13. Logs en events naar de Elastic-stack

UFM-events, switch-syslog, PDR-beslissingen, Slurm- en UFM-Slurm-logs en hostlogs gaan naar Elasticsearch. Nodelogs komen binnen via de Collector-pipeline hierboven. De eigen stromen van UFM komen binnen via de op Fluentd gebaseerde plug-ins, die we laten eindigen op een Fluentd-aggregator (of Logstash) naast de gateways.

Fluentd: event- en telemetriestromen van UFM naar Elasticsearch

De plug-ins EFS (syslog-streaming) en TFS (telemetrie) versturen via het forward-protocol van Fluentd. Deze aggregator ontvangt beide, voegt de vlootlabels toe en schrijft met een schijfbuffer naar data streams, zodat een storing van Elasticsearch geen events kost. Hij gebruikt de output 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 de praktijk splitsen we dit met twee <match>-blokken op de tags die de twee plug-ins volgens hun configuratie versturen, zodat events en telemetrie in aparte data streams met verschillende bewaartermijnen terechtkomen. Telemetrietellers per poort naar Elasticsearch sturen is alleen de moeite waard als Elastic de enige metrics-opslag van de klant is; anders gaan tellers naar Mimir en krijgt Elasticsearch de events.

Logstash: switch-syslog

Voor locaties met een bestaande Logstash-laag kunnen switch- en UFM-syslog daar binnenkomen in plaats van op de syslog-receiver van de Collector:

# /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"]
  }
}

Bewaring met 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": {} } }
    }
  }
}

Securityrelevante stromen (UFM-audit, authenticatie) hebben meestal een langere bewaring nodig dan 90 dagen; geef ze een eigen data stream en policy in plaats van alles te verlengen.

Nuttige Kibana-query's (KQL) om als weergave op te slaan:

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 van AI-inferentie- en trainingsdiensten

Metrics vertellen u dat de time to first token is gestegen; traces vertellen u waar de tijd naartoe ging. Voor een inferentieverzoek zijn de nuttige spans het verzoek, de tokenizer, de aanroep van de modelserver en de eigen wachtrij-, prefill- en decodefase van de modelserver. Recente modelservers (waaronder vLLM, Triton en NVIDIA NIM) kunnen zelf OpenTelemetry-traces uitsturen als ze een OTLP-endpoint krijgen; controleer de flags voor uw versie. De applicatiekant ziet er zo uit, met de attribuutnamen uit de GenAI-semantische conventies van OpenTelemetry:

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)

De GPU zelf stuurt geen spans uit. We koppelen de trace aan de hardware via de resource-attributen die de agent toevoegt (node, rack) en, waar de server die rapporteert, de GPU-UUID, en gebruiken daarna de trace-to-metrics-links van Grafana om vanuit een trage span naar de DCGM-panelen van die GPU en de fabricpoorten van die node voor dezelfde minuut te springen. Histogrammen van requestlatency dragen exemplars, zodat een piek op een latencypaneel direct naar een voorbeeldtrace linkt.

Voor training is een span per stap veel te veel. We tracen de grove fasen (jobstart, data laden, elk opslaan en herstellen van een checkpoint, evaluatie) en registreren de step time als histogram-metric met het joblabel. Een plotselinge stijging van de step time bij vlakke GPU-utilisatie en stijgende link-error-recovery op de poorten van de job is de klassieke signatuur van een fabricstoring, en de join van job naar fabric in sectie 11 vindt de poort.

15. Kardinaliteit en bewaring

Kardinaliteit, het aantal verschillende labelcombinaties, bepaalt geheugen, opslag en querykosten. AI-clusters gedragen zich goed als u er bewust mee omgaat. Een uitgewerkt voorbeeld voor een cluster van 32 nodes en 256 GPU's met een rail-geoptimaliseerde InfiniBand-computefabric (ongeveer 1.000 poorten, host- en switchzijde samen):

BronSeriesIntervalSamples per seconde
UFM-fabrictellers, 8 behouden tellers × ~1.000 poorten~8.00060 s~135
Idem, als elke teller in een debug-tellerset wordt gestreamd (~100)~100.00060 s~1.670
DCGM, ~27 standaardvelden × 256 GPU's~6.90015 s~460
node-exporter na de keep-list, ~300 × 40 nodes~12.00015 s~800
Collectors, exporters, UFM-systeem, diensten~5.00015–60 s~200
Totaal (behouden tellers)~32.000~1.600

Bij ruwweg 1,5 byte per gecomprimeerde sample is 1.600 samples per seconde ongeveer 75 GB objectopslag per jaar. Dat is klein genoeg om bij clusters van deze omvang ruwe data 13 maanden te bewaren; de bewaring in Mimir is per tenant, dus zeer grote vloten zetten recording rules voor de lange termijn in een aparte tenant met een langere bewaring dan de ruwe data.

Wat budgetten opblaast, zijn labels, niet metrics:

  • Job-ID's op fabric- of nodeseries. Een druk Slurm-cluster draait duizenden jobs per dag; elke nieuwe waarde maakt nieuwe series. Houd hpc_job alleen op GPU-series en join via ws_job_node_info.
  • Pod-UID's, container-ID's, request-ID's en trace-ID's als labels. Verwijder ze in de gateway; trace-ID's horen in exemplars.
  • Tellers per lane en per link overal. Schakel NVLink-fouttellers per link en fabrictellers per lane in voor diagnose, beperkt tot de nodes die worden onderzocht, niet standaard.
  • Ruwe GUID's naast namen. Gebruik het gelabelde UFM-endpoint en houd namen; één identiteitslabel per object is genoeg.

De bewaartermijnen waarmee we beginnen, en die we per klant aanpassen:

DataOpslagBewaring
Metrics (ruw)Mimir13 maanden voor clusters tot een paar honderd GPU's
Metrics (lokaal, als Prometheus wordt gebruikt)Prometheus15 dagen
TracesTempo14 dagen, na tail sampling (alle fouten, alle trage verzoeken, 10% van de rest)
Fabric- en hostlogs en -eventsElasticsearchhot 7 dagen, warm tot 30, cold tot 90, daarna verwijderen
Audit- en securitylogsElasticsearchZoals het beleid van de klant vereist, vaak een jaar of langer
Topologiesnapshots en NDT-rapportenElasticsearch of objectopslagLevensduur van het cluster

16. High availability van de observability-stack

HA-topologie: twee managementracks op aparte stroomvoedingen bevatten elk een UFM-server van een actief/standby-paar, een gateway-collector, een Prometheus-replica, een Mimir-zone, een Alertmanager-peer, Grafana, een master-eligible Elasticsearch-node, Logstash en Kibana; een derde quorumzone bevat de derde Mimir-zone, een Alertmanager-peer en een voting-only Elasticsearch-master; objectopslag bevat Mimir-blocks en snapshots.

Monitoring die tegelijk uitvalt met wat ze monitort, is decoratie. Het ontwerp verdeelt elk stateful component over drie faalzones (twee managementracks op aparte stroomvoedingen en een kleine derde zone voor quorum):

  • UFM: actief/standby over de twee racks; alles communiceert met het virtuele IP-adres. Plug-ins worden op beide nodes geladen.
  • Collector-gateways: minstens twee, beide actief. Agents gebruiken de poolnaam en een persistente wachtrij, dus het verlies van een gateway is een retry, geen gat. Fabric-scrapes draaien op beide en worden in Mimir gededupliceerd.
  • Mimir: zonebewuste replicatie met een replicatiefactor van 3, en de HA-tracker voor de fabric-scrapes en eventuele Prometheus-paren.
  • Alertmanager: drie peers in gossip, zodat elke notificatie één keer uitgaat, plus een externe dead man's switch gevoed door de Watchdog-alert.
  • Elasticsearch: drie master-eligible nodes (één voting-only in de quorumzone), één replica per shard, shard allocation awareness op het zone-attribuut en snapshots naar objectopslag.
  • Grafana en Kibana: elk twee instanties, stateless achter een load balancer; Grafana gebruikt een gedeelde database, en beide worden vanuit Git geprovisioned, zodat een herbouw een deploy is.

De configuratie die ertoe doet, 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

En in Elasticsearch, per node:

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

Het monitoren van de monitoring loopt out-of-band: een kleine aparte Prometheus (of een gehoste check) bewaakt de gateways, Mimir, de gezondheid van Elasticsearch en de dead man's switch, zodat ook een volledig verlies van de hoofdstack wordt gedetecteerd.

17. Bewijzen dat het werkt: storingsoefeningen bij de overdracht

We dragen geen dashboard over dat we niet rood hebben zien worden. Voor elk nieuw cluster voeren we uit en leggen we vast:

  1. Trek een kabel los tussen een leaf en een spine tijdens een testjob: de flap-alert pagt binnen het verwachte venster, UFM genereert een event, het event staat in Kibana, en de weergave van job naar fabric toont welke job over die poort liep.
  2. Laat de actieve UFM-server uitvallen: de standby neemt het virtuele IP-adres over, scrapes worden hervat, en het gat in de fabricdata is korter dan het alertvenster.
  3. Stop een gateway: geen dataverlies, een GatewayRedundancyLost-page, en herstel zodra hij terugkomt.
  4. Stop een Elasticsearch-node en een Mimir-zone: query's worden nog steeds beantwoord, writes gaan door, gezondheidsalerts gaan af.
  5. Draai PDR in dry-run tegen een bewust marginale kabel op een labpoort: de beslissing "would isolate" verschijnt in de logopslag.
  6. Vergelijk de gerealiseerde situatie met het ontwerp met de NDT-plug-in en voeg het rapport toe aan het overdrachtspakket.

18. Hoe Workstation dit levert en beheert

Workstation is NVIDIA-partner, dus naast de hardware leveren we engineering, software en mensen om AI-datacenters van begin tot eind in te richten en te beheren: ontwerp, installatie, het opleveren van de fabric, de inrichting van UFM en observability, en de engineers die het daarna samen met u beheren. NVIDIA's eigen overzicht van UFM staat op de officiële pagina NVIDIA Unified Fabric Manager (UFM).

  • Levering: GPU-systemen, InfiniBand- en Ethernet-switches, adapters, optics en UFM-licenties, samen gespecificeerd.
  • Bouw: UFM-HA, plug-ins, integratie met Slurm of Kubernetes, DCGM en dcgm-exporter, Collector-agents en -gateways, en onze gehoste backends of de uwe, allemaal vanuit geversioneerde configuratie.
  • Beheer: managed observability rond de klok: afstemming van alerts, upgrades (inclusief migraties zoals de hernoemingen in dcgm-exporter 4.9.0), capaciteitsplanning voor de monitoringstack en een maandrapport over GPU-efficiëntie, fabricstoringen en kosten per nuttig GPU-uur.

Voor een gesprek over dimensionering kunt u onze AI Sales Engineer raadplegen of de assortimenten netwerken en DGX in de shop bekijken.

19. Bronnen en verificatienotities

  • Overzicht en niveaus van NVIDIA UFM: de officiële pagina NVIDIA Unified Fabric Manager (UFM).
  • UFM SDK-plug-ins, poorten, paden, tellernamen en standaardwaarden van PDR: de README's en dashboards in Mellanox/ufm_sdk_3.0, gelezen in november 2026. Het gedrag van plug-ins verandert tussen releases; controleer de README voor de versie die u uitrolt.
  • Metricnamen van dcgm-exporter en de hernoemingen in 4.9.0: etc/default-counters.csv en de releasenotes van 4.9.0 in NVIDIA/dcgm-exporter.
  • Componenten van de OpenTelemetry Collector komen uit de contrib-distributie; configuratiesleutels verschuiven tussen releases, dus valideer met otelcol-contrib validate --config=... vóór de uitrol.
  • De indeling van UFM-niveaus en de details van NetQ en DOCA Telemetry Service zijn in algemene termen beschreven; raadpleeg de actuele documentatie van NVIDIA voor exacte functies en licenties voor uw versies.
  • Tellernamen met ws: of ws_ zijn conventies van Workstation (recording rules en info-metrics), geen NVIDIA-metrics.

Erkenning van rechten: NVIDIA, het NVIDIA-logo, DGX, HGX, Quantum, Spectrum, Spectrum-X, BlueField, ConnectX, NVLink, DOCA, DCGM en Unified Fabric Manager (UFM) zijn handelsmerken en/of gedeponeerde handelsmerken van NVIDIA Corporation in de Verenigde Staten en andere landen. NVIDIA-producten en -technologieën kunnen worden beschermd door octrooien en andere intellectuele-eigendomsrechten van NVIDIA Corporation, en al deze rechten worden erkend en voorbehouden aan hun eigenaren. Productinformatie is in onze eigen woorden samengevat uit de publieke documentatie van NVIDIA; de website en documentatie van NVIDIA zijn de gezaghebbende bron. Andere bedrijfs- en productnamen, waaronder Prometheus, Grafana, Elasticsearch, Kibana, Logstash, OpenTelemetry, Kubernetes en Slurm, kunnen handelsmerken van hun respectieve eigenaren zijn. De eigen dashboards, configuraties en teksten van Workstation zijn © Workstation.

Deel dit artikel

Meer in Technology

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

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

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

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

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

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

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

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

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

Lees meer