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.
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.
| Laag | Typische storingen | NVIDIA-bron | Hoe we het verzamelen |
|---|---|---|---|
| GPU en NVLink | XID-fouten, ECC- en row-remap-events, thermische of vermogensthrottling, NVLink-fouten, ongebruikte GPU's in lopende jobs | DCGM (host engine) en dcgm-exporter | Prometheus-scrape op de node door de Collector-agent |
| InfiniBand-fabric voor compute en opslag | Link flaps, symbool- en integriteitsfouten, links die op de verkeerde snelheid of breedte zijn getraind, congestie, hete of falende transceivers, wijzigingen van de subnet manager | UFM Telemetry en UFM Enterprise (events, alarmen, topologie, REST-API), SDK-plug-ins | Prometheus-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 EVPN | NetQ; streaming telemetry van switches | NetQ-API of gNMI- of OTLP-streaming van switches naar de gateway |
| BlueField-DPU | Poort- en offloadtellers, gezondheid van de DPU | DOCA Telemetry Service | Scrape van het endpoint in Prometheus-formaat |
| Hosts en opslagclients | Geheugendruk, NVMe-slijtage, latency van het bestandssysteem, NIC-fouten | (standaard Linux-tooling) | node-exporter, filelog- en journald-receivers |
| Scheduler en orkestratie | Vastgelopen jobs, gedrainde nodes, GPU-aanvragen zonder utilisatie | (Slurm, Kubernetes), UFM-integratie met Slurm | Job-naar-GPU-labels uit dcgm-exporter; scheduler-exporters; Kubernetes-metadata |
| AI-diensten | Trage 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:
| Teller | Wat het u vertelt |
|---|---|
PortXmitDataExtended, PortRcvDataExtended | Verzonden 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) |
LinkDownedCounterExtended | Aantal keren dat de link down ging: het signaal voor link flaps |
LinkErrorRecoveryCounterExtended | Aantal keren dat de link opnieuw trainde om van fouten te herstellen: vaak het eerste teken van een marginale kabel |
LocalLinkIntegrityErrorsExtended | Lokale fysieke fouten boven de integriteitsdrempel |
ExcessiveBufferOverrunErrorsExtended | Opeenvolgende bufferoverruns op de poort |
Normalized_CBW | Een congestiebandbreedtecijfer dat UFM beschikbaar stelt; NVIDIA's dashboard plot het maximum per topologieniveau |
dev_temperature | Apparaattemperatuur |
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-in | Wat het doet | Waar het past |
|---|---|---|
grafana_infiniband_telemetry_plugin | Serveert 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_plugin | Instructies 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_plugin | Een 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_plugin | Parseert 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_plugin | Haalt 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_plugin | Instructies om UFM-events via de Zabbix-agent en log-items naar Zabbix te streamen. | Voor operationele teams die Zabbix al als eventconsole gebruiken. |
SLURM-Integration | Slurm-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_plugin | Problem 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_Plugin | Vergelijking 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_plugin | Abonneert 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_plugin | Luistert naar SNMP-traps van beheerde switches en leidt ze als events naar UFM. | Hetzelfde idee voor switches die alleen traps versturen. |
grpc_streamer_plugin | Een 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_plugin | Analyseert 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_plugin | Verbindt 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:
| Instelling | Standaard | Betekenis |
|---|---|---|
INTERVAL | 300 s | Hoe vaak telemetrietellers worden opgevraagd |
MAX_NUM_ISOLATE | 10 | Bovengrens voor geïsoleerde poorten (de grootste van deze waarde en 0,5% van de fabricgrootte) |
TMAX / D_TMAX | 70 °C / 10 | Maximale temperatuur en maximale temperatuurstijging |
MAX_PDR | 1e-12 | Maximale packet drop rate |
CONFIGURED_BER_CHECK, CONFIGURED_TEMP_CHECK, LINK_DOWN_ISOLATION | True | Welke controles isolatie mogen activeren |
SWITCH_TO_HOST_ISOLATION | True | Of toegangslinks naar hosts mogen worden geïsoleerd |
DRY_RUN | False | Beslissingen loggen in plaats van handelen |
DEISOLATE_CONSIDER_TIME | 5 min | Hoe lang een poort gezond moet ogen voordat hij weer in gebruik wordt genomen |
MAX_PORT_RESET_NUM | 2 per week | Toegestane 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:
- Schakel in met
DRY_RUN=Truevoor twee tot vier weken en stuur het log naar Elasticsearch. Elke regel "would isolate" wordt een ticket dat we toetsen aan de UFM-tellers. - Spreek via de REST-API van de plug-in de uitsluitingslijst af (poorten die PDR nooit mag aanraken, zoals enkelvoudig aangesloten opslaglinks).
- Schakel over op live isolatie, waarbij
SWITCH_TO_HOST_ISOLATIONper locatie wordt bepaald: het isoleren van een hostlink haalt die node uit jobs, wat soms gewenst is en soms niet. - 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.x | Naam in 4.9.0 | Wijziging van eenheid |
|---|---|---|
DCGM_FI_DEV_GPU_UTIL | DCGM_FI_DEV_GPU_UTIL_RATIO | % naar 0–1 |
DCGM_FI_DEV_FB_USED | DCGM_FI_DEV_FB_USED_BYTES | MiB naar bytes |
DCGM_FI_DEV_GPU_TEMP | DCGM_FI_DEV_GPU_TEMP_CELSIUS | geen |
DCGM_FI_DEV_POWER_USAGE | DCGM_FI_DEV_BOARD_POWER_WATTS | geen |
DCGM_FI_DEV_TOTAL_ENERGY_CONSUMPTION | DCGM_FI_DEV_GPU_ENERGY_JOULES_TOTAL | mJ naar J |
DCGM_FI_DEV_XID_ERRORS | DCGM_FI_DEV_XID_ERROR | geen (laatste XID-waarde) |
DCGM_FI_DEV_NVLINK_BANDWIDTH_TOTAL | DCGM_FI_DEV_NVLINK_THROUGHPUT_BYTES_PER_SECOND | MB/s naar B/s |
DCGM_FI_DEV_UNCORRECTABLE_REMAPPED_ROWS | DCGM_FI_DEV_ROW_REMAP_UNCORRECTABLE_TOTAL | geen |
DCGM_FI_DEV_ROW_REMAP_FAILURE | DCGM_FI_DEV_ROW_REMAP_FAILED | geen |
DCGM_FI_DEV_PCIE_REPLAY_COUNTER | DCGM_FI_DEV_PCIE_REPLAY_TOTAL | geen |
DCGM_FI_PROF_GR_ENGINE_ACTIVE | DCGM_FI_PROF_GR_ENGINE_UTIL_RATIO | geen (ratio) |
DCGM_FI_PROF_PIPE_TENSOR_ACTIVE | DCGM_FI_PROF_TENSOR_UTIL_RATIO | geen (ratio) |
DCGM_FI_PROF_DRAM_ACTIVE | DCGM_FI_PROF_DRAM_UTIL_RATIO | geen (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
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-telemetryis de effectiefste kostenbeheersing in het hele ontwerp. Begin smal; voeg een teller toe wanneer een dashboard of alert die nodig heeft. resource_to_telemetry_conversionzet resource-attributen om in labels. Daardoor staansite,cluster,rackenfabricop 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/lokitoe 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
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:
| Label | Voorbeeld | Op | Regel |
|---|---|---|---|
site | lon2 | alles | Datacenter of hal; ingesteld door de collector |
cluster | ai-prod-1 | alles | Ook het HA-clusterlabel van Mimir |
env | prod | alles | prod, staging, lab |
fabric | ib-compute | netwerkmetrics | ib-compute, ib-storage, eth-frontend, eth-storage, nvlink |
rack | r07 | nodes en switches | Uit de inventaris, nooit tijdens de query afgeleid uit hostnamen |
node | gpu-r07-03 | nodemetrics | Korte hostnaam, kleine letters; we relabelen Hostname van DCGM zodat die overeenkomt |
rail | 3 | GPU- en NIC-metrics | Railnummer in rail-geoptimaliseerde fabrics; gelijk aan de GPU-index bij de meeste HGX-ontwerpen |
gpu, UUID | 3, GPU-… | alleen GPU-metrics | Uit dcgm-exporter; de UUID volgt de fysieke GPU door RMA's heen |
switch, port | leaf-r07-a, 17 | fabricmetrics | Bij het relabelen genormaliseerd uit de apparaat- en poortlabels van UFM |
tenant | genomics | workloadmetrics | Uit labels van Kubernetes-namespaces of het Slurm-account |
hpc_job | 4471823 | alleen GPU-metrics | Nooit 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):
| Bron | Series | Interval | Samples per seconde |
|---|---|---|---|
| UFM-fabrictellers, 8 behouden tellers × ~1.000 poorten | ~8.000 | 60 s | ~135 |
| Idem, als elke teller in een debug-tellerset wordt gestreamd (~100) | ~100.000 | 60 s | ~1.670 |
| DCGM, ~27 standaardvelden × 256 GPU's | ~6.900 | 15 s | ~460 |
| node-exporter na de keep-list, ~300 × 40 nodes | ~12.000 | 15 s | ~800 |
| Collectors, exporters, UFM-systeem, diensten | ~5.000 | 15–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_joballeen op GPU-series en join viaws_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:
| Data | Opslag | Bewaring |
|---|---|---|
| Metrics (ruw) | Mimir | 13 maanden voor clusters tot een paar honderd GPU's |
| Metrics (lokaal, als Prometheus wordt gebruikt) | Prometheus | 15 dagen |
| Traces | Tempo | 14 dagen, na tail sampling (alle fouten, alle trage verzoeken, 10% van de rest) |
| Fabric- en hostlogs en -events | Elasticsearch | hot 7 dagen, warm tot 30, cold tot 90, daarna verwijderen |
| Audit- en securitylogs | Elasticsearch | Zoals het beleid van de klant vereist, vaak een jaar of langer |
| Topologiesnapshots en NDT-rapporten | Elasticsearch of objectopslag | Levensduur van het cluster |
16. High availability van de observability-stack
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:
- 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.
- 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.
- Stop een gateway: geen dataverlies, een
GatewayRedundancyLost-page, en herstel zodra hij terugkomt. - Stop een Elasticsearch-node en een Mimir-zone: query's worden nog steeds beantwoord, writes gaan door, gezondheidsalerts gaan af.
- Draai PDR in dry-run tegen een bewust marginale kabel op een labpoort: de beslissing "would isolate" verschijnt in de logopslag.
- 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.csven 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:ofws_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.