diff --git a/docs/platform/llm-server/monitoring/GNMON-000-DOC_Index.md b/docs/platform/llm-server/monitoring/GNMON-000-DOC_Index.md index 839e0f2..7bee154 100644 --- a/docs/platform/llm-server/monitoring/GNMON-000-DOC_Index.md +++ b/docs/platform/llm-server/monitoring/GNMON-000-DOC_Index.md @@ -1,32 +1,59 @@ # Monitoring – Dokumentationsindex und Projektstand **Dokumenten-ID:** GNMON-000-DOC -**Stand:** 2026-10-19 -**Status:** Planungsabschluss; Implementierung noch nicht begonnen +**Stand:** 2026-11-04 +**Status:** Revision v2.0 (03.11.2026) übernommen; Meilenstein M1 (Metrikpfad) auf der Workstation implementiert und verifiziert ## Dokumente | Dokument | Zweck / Zielgruppe | | --- | --- | -| [GNMON-001-PLAN_Architecture.md](GNMON-001-PLAN_Architecture.md) | Host-Monitoring: Metriken, Collector, Dashboard, Anbindung Encoding; Infrastrukturadministratoren | +| [GNMON-001-PLAN_Architecture.md](GNMON-001-PLAN_Architecture.md) | Host-Monitoring: Metriken, Log-Pipeline, Dashboard, Anbindung Encoding; Infrastrukturadministratoren | +| [docs/planning/gnmon-001-v2-0-monitoring-architektur-revision.md](../../../planning/gnmon-001-v2-0-monitoring-architektur-revision.md) | Arbeitskopie der v2.0-Revision (Betreiber-Rechercheordner) | ## Bestätigter Stand -- Planungsabschluss 19.10.2026: host-weites Monitoring für `ghostnet-ki`, - fachlich getrennt vom Encoding-Workload (aus GNENC ausgegliedert). -- Komponenten: host-seitiger Metrics-Collector (systemd-Service, schreibt - `state/system.json` alle 10 s) und Dashboard-Container unter `gn-dashboard` - (984). -- Metriken: CPU, RAM, Disk (Root + NFS-Export), GPU-Util, VRAM. -- Dashboard: Python/Flask, read-only Mounts, kein GPU-/Schreibzugriff; - erreichbar über NPM (CT-103) mit Keycloak. -- Anbindung Encoding: Dashboard liest `state/jobs/*.json` read-only - (`state/` group-readable via `gn-media`). -- Noch nicht implementiert: Konto `gn-dashboard`, Collector-Service, - Dashboard-Quadlet, Image-Bau. +- Revision v2.0 (03.11.2026): Blazor Server statt Flask, Zeitreihen- + (VictoriaMetrics + node_exporter mit AMD-Textfile-Skript) und Log-Stack + (Alloy + Loki) statt `state/system.json`-Schnappschuss; Konten + `gn-monitor` (983, geplant) für Datenhaltung, `gn-dashboard` (984) für + die Web-App. +- Anlass für die zügige Umsetzung: thermischer GPU0-SW-CTF-Vorfall vom + 03.11.2026 (GNAI-010 Abschnitt 10.10) – ohne laufende Sensorüberwachung + lief die Karte ~19 Minuten unbeobachtet auf die Abschaltung zu. + +### M1: Metrikpfad (implementiert 04.11.2026, Workstation-Entwicklung) + +Entwickelt und getestet auf dem Betreiber-Laptop (CachyOS, rootless, +User-Scope-systemd) im Verzeichnis `llm-server/monitoring/`: + +- `amdgpu-textfile-collector.py` (sysfs-only, kein ROCm erforderlich): + Util, VRAM used/total, Edge/Junction/Memory-Temperatur, Lüfter-RPM und + PWM je Karte; atomarer Textfile-Wechsel; auf der Laptop-APU gegen echte + Sensordaten verifiziert, auf diskreten Karten (RX 6900 XT) in M5 zu + bestätigen. +- `gnmon_collector`-Rolle: node_exporter v1.12.1 (Upstream-Tarball, + SHA256SUMS-verifiziert), Collector-Systemd-Timer (10 s), Port 9100 + host-lokal. +- `gnmon_victoria_metrics`-Rolle: rootless Quadlet, `Network=host`, + VictoriaMetrics **v1.154.1** (Digest + `sha256:c7884f32920dd45a9d86542a717227e63af03e060e53bbf8031e6e6fd0e1e05d`, + verifizierter Pull 04.11.2026), Scrape-Intervall 10 s, Retention 60 d, + Health-Check im Playbook. +- Verifikation: PromQL-Abfrage liefert `gn_gpu_edge_temp_celsius` (51 °C + auf der Workstation-APU); Idempotenzlauf `changed=0, failed=0`. ## Noch offen -1. NPM-Hostname und Keycloak-Client (Umsetzung). -2. Collector-Identität (root vs. Metrics-Account mit `render`-Gruppe). -3. Erweiterung um LLM-Metriken (später). +1. Punkte 1–6 aus GNMON-001 v2.0 Abschnitt 9 (Metrics-Account-Identität, + NPM-Hostname/Keycloak-Client, UID/GID `gn-monitor`, Chart-Bibliothek, + LLM-Metriken, Retention-Feinjustierung). +2. **Alarmierung (Planlücke):** v2.0 deckt Sammeln und Anzeigen ab, aber + keinen Schwellwert-Alarm (Motivation des Vorfalls). Vorschlag: + `vmalert`-Regeln gegen VictoriaMetrics mit Notification-Kanal; Kanal- + Auswahl (Mail/ntfy/Matrix) ist eine Betreiberentscheidung. +3. M2 (Loki + Alloy Log-Pipeline) und M3 (Blazor-Dashboard) auf der + Workstation. +4. M5 Server-Rollout auf `ghostnet-ki` nach Behebung des GPU0-Kühldefekts + (GNAI-010 10.10): System-Scope-Rollen, Konten 983/984, nftables, + Abnahmekriterien aus GNMON-001 Abschnitt 10. diff --git a/docs/platform/llm-server/monitoring/GNMON-001-PLAN_Architecture.md b/docs/platform/llm-server/monitoring/GNMON-001-PLAN_Architecture.md index 6a639b5..9ad9e30 100644 --- a/docs/platform/llm-server/monitoring/GNMON-001-PLAN_Architecture.md +++ b/docs/platform/llm-server/monitoring/GNMON-001-PLAN_Architecture.md @@ -1,107 +1,154 @@ # Monitoring **Dokumenten-ID:** GNMON-001-PLAN -**Titel:** Host-Monitoring auf dem KI-Server: Systemmetriken und Workload-Dashboards -**Stand:** 2026-10-19 -**Status:** Finaler Plan nach Betreiberentscheidungen vom 19.10.2026 -**Referenzen:** [GNENC-001](../encoding/GNENC-001-PLAN_Architecture.md), [GNENC-002](../encoding/GNENC-002-PLAN_Pipeline.md), [GNAI-005](../../GNAI-005-SEC_Access-Control.md), [GNAI-006](../../proxmox-server/lxc/ct-103-reverse-proxy/GNAI-006-SEC_Reverse-Proxy.md) +**Titel:** Host-Monitoring auf dem KI-Server: Systemmetriken, Log-Pipeline und Blazor-Dashboard +**Stand:** 03.11.2026 +**Status:** Revidierter Plan (v2.0) nach Betreiberentscheidungen vom 03.11.2026; Implementierung noch nicht begonnen +**Referenzen:** [GNENC-001](https://git.ghostnet.selfhost.eu/ghostnet.ai/infrastructure/raw/branch/main/docs/platform/llm-server/encoding/GNENC-001-PLAN_Architecture.md), [GNENC-002](https://git.ghostnet.selfhost.eu/ghostnet.ai/infrastructure/raw/branch/main/docs/platform/llm-server/encoding/GNENC-002-PLAN_Pipeline.md), [GNAI-005](https://git.ghostnet.selfhost.eu/ghostnet.ai/infrastructure/raw/branch/main/docs/platform/GNAI-005-SEC_Access-Control.md), [GNAI-006](https://git.ghostnet.selfhost.eu/ghostnet.ai/infrastructure/raw/branch/main/docs/platform/proxmox-server/lxc/ct-103-reverse-proxy/GNAI-006-SEC_Reverse-Proxy.md) + +## Änderungsverlauf + +| Datum | Version | Autor | Beschreibung | +| --- | --- | --- | --- | +| 19.10.2026 | 1.0 | Betreiber | Planungsabschluss: Metrics-Collector (system.json) + Flask-Dashboard | +| 03.11.2026 | 2.0 | Betreiber / Mistral Vibe | Revision: Dashboard auf ASP.NET Core Blazor Server; Metriken über VictoriaMetrics + Exporter statt system.json-Schnappschuss; neue Log-Pipeline (Alloy + Loki) für journald-, Container- und Encoding-Logs | + +## Änderungen gegenüber v1.0 + +1. **Dashboard-Technik:** Python/Flask → **ASP.NET Core Blazor Server (.NET 10 LTS)**, C#. Betreiberentscheidung 03.11.2026; löst die Festlegung aus v1.0 ab. +2. **Metrikpfad:** Der host-seitige Metrics-Collector mit `state/system.json` (10-s-Schnappschuss, keine Historie) **entfällt**. Ersetzt durch node_exporter mit AMD-GPU-Textfile-Skript und **VictoriaMetrics** als Zeitreihen-Store. Damit sind Verläufe (24 h / 7 d / 30 d) möglich. +3. **Neu: Log-Pipeline.** v1.0 hatte keine Log-Anzeige. Neu: **Grafana Alloy** (host-seitig) → **Loki** für journald-, Podman-Container- und Encoding-Job-Logs. +4. **Workload-Status unverändert:** Das Filesystem-Handover für Encoding (`state/jobs/*.json`, read-only Mount) bleibt wie in v1.0 bzw. GNENC-002. +5. **Neues Konto `gn-monitor`** für die Datenhaltung (VictoriaMetrics, Loki); `gn-dashboard` (984) bleibt auf die Web-App beschränkt. ## 1. Zweck und Abgrenzung -Host-weites Monitoring für `ghostnet-ki`: Systemmetriken (CPU, RAM, Disk, -GPU-Util, VRAM) und Dashboards für Workloads. Aktuell angebunden ist die -Encoding-Pipeline (GNENC-002); später erweiterbar um LLM-Metriken (GPU-Util -unter Inferenz, llama.cpp-Statistik). Der Bereich ist fachlich getrennt vom -Encoding-Workload (aus GNENC ausgegliedert, Betreiberentscheidung 19.10.2026), eilt aber Hardware und Host-Basis. +Host-weites Monitoring für `ghostnet-ki` (10.0.0.90) mit drei Datenpfaden: -## 2. Architekturprinzip +- **Zeitreihen** (CPU, RAM, Disk inkl. NFS-Export, GPU-Util, VRAM, Temperatur/Power) über VictoriaMetrics, +- **Logs** (journald, Podman-Container-Logs, Encoding-Job-Logs) über Loki, +- **Workload-Zustände** (Encoding-Jobs) über read-only Dateizugriff. -Filesystem-Handover wie in der Encoding-Pipeline: Der Metrics-Collector -(host-seitig) schreibt `state/system.json` atomar; Workloads stellen ihre -Status-Dateien bereit (Encoding: `state/jobs/*.json`). Das Dashboard liest -ausschließlich Dateien (read-only Mounts) und hat weder GPU- noch -Schreibzugriff. +Später erweiterbar um LLM-Metriken (GPU-Util unter Inferenz, Serving-Statistik) — eigenes Thema im AI-Bereich. Der Bereich bleibt fachlich getrennt vom Encoding-Workload. + +Bewusste Abgrenzung: **Grafana/OpenSearch kommen nicht zum Einsatz.** Ziel ist ein einziges, selbst erweiterbares Dashboard in einem Stack; VictoriaMetrics und Loki behalten dennoch ihre Standard-HTTP-APIs, sodass ein späteres Grafana zum Debuggen jederzeit andockbar wäre, ohne die Architektur zu ändern. + +## 2. Architektur + +```mermaid +flowchart LR + Browser["Browser (LAN / WireGuard)"] --> NPM["NPM CT-103 (TLS)"] + NPM --> KC["Keycloak CT-102 (OIDC, MFA)"] + NPM --> DB["Blazor-Dashboard, gn-dashboard (984), 10.0.0.90:8080"] + DB -->|"PromQL, 10.0.0.90:8428"| VM["VictoriaMetrics, gn-monitor (983)"] + DB -->|"LogQL, 10.0.0.90:3100"| LK["Loki, gn-monitor (983)"] + DB -->|"read-only Mount"| ST["Encoding state/jobs"] + subgraph HOST["Host-systemd auf ghostnet-ki"] + NE["node_exporter (9100) mit AMD-Textfile-Skript"] + AL["Grafana Alloy: journald + Job-Logfiles"] + end + NE --> VM + AL --> LK +``` + +Architekturprinzip: Die Dashboard-App bleibt eine **read-only, GPU-lose Einheit ohne Schreibzugriff** auf Pipeline oder Host. Historie und Log-Aggregation liegen in zwei dedizierten, rootless betriebenen Diensten; die App fragt deren HTTP-APIs ab. ## 3. Komponenten -| Komponente | Konto | Image | Aufgabe | Betrieb | -| --- | --- | --- | --- | --- | -| Metrics-Collector | host-seitig (systemd-Service; root oder dedizierter Metrics-Account mit `render`-Gruppe) | — | sampelt alle 10 s CPU, RAM, Disk (Root + NFS-Export), GPU-Util und VRAM (rocm-smi/sysfs, lesend); schreibt `state/system.json` atomar | dauerhaft | -| Dashboard | `gn-dashboard` (984) | Dashboard-Image (Eigenbau, gepinnt; Python + Flask) | liest `system.json` + `state/jobs/*.json` (Encoding, read-only Mount); zeigt Ressourcen und Workload-Übersicht | dauerhaft | +| Komponente | Konto / Betrieb | Aufgabe | Laufzeit | +| --- | --- | --- | --- | +| node_exporter | Host-systemd, Metrics-Account (siehe Abschnitt 9, offener Punkt 1) | CPU, RAM, Disk (Root + NFS-Export), Load; liest Textfile-Verzeichnis | dauerhaft | +| AMD-GPU-Textfile-Skript | Host-systemd-Timer (10 s) | liest rocm-smi/sysfs (Util, VRAM, Junction-Temp, Power je Karte); schreibt `.prom`-Textfile atomar für node_exporter | dauerhaft | +| Grafana Alloy | Host-systemd, Metrics-Account, Gruppen `systemd-journal` + `gn-media` | liest journald (System + Container) und Encoding-Logfiles; pusht nach Loki | dauerhaft | +| VictoriaMetrics (single) | `gn-monitor` (983), rootless Quadlet | scrapet node_exporter (10 s); speichert Zeitreihen; `/api/v1/query` + `query_range` (Prometheus-API-kompatibel) | dauerhaft | +| Loki | `gn-monitor` (983), rootless Quadlet | Log-Aggregation; `/loki/api/v1/query_range`; Filesystem-Store, kein S3 | dauerhaft | +| Blazor-Dashboard | `gn-dashboard` (984), rootless Quadlet | UI: Ressourcen-Charts, GPU-Detail, Encoding-Übersicht, Log-Browser; Keycloak-OIDC | dauerhaft | -## 4. Konto `gn-dashboard` +**Entscheidungen mit Begründung:** -UID/GID 984, subid/subgid ab 624288 (65536 Stück), Home -`/var/lib/ghostnet-dashboard`, Config `/etc/ghostnet-dashboard`, Quadlets -`/etc/containers/systemd/users/984`, eigener rootless Podman-Store, gesperrt -(Passwort `!`, Shell `/usr/sbin/nologin`, Linger aktiv). Mitglied der Gruppe -`gn-media` (nur lesender Zugriff auf `state/` und `queue/` der -Encoding-Pipeline). Keine GPU-Gruppenmitgliedschaft, keine `/dev/kfd`-/ -`/dev/dri`-Weitergabe. +- **VictoriaMetrics statt Prometheus:** ein einzelnes, statisches Binary, deutlich geringerer RAM-Bedarf, integrierter Scrape (`-promscrape.config`), Prometheus-Query-API-kompatibel. Ein späterer Wechsel zu Prometheus wäre für das Dashboard transparent. +- **Loki statt OpenSearch:** Single-Binary, kein JVM-Cluster, indexiert nur Labels — passend zu Single-Host-Betrieb ohne HA-Aussage (vgl. GNAI-001). +- **Alloy statt Promtail:** Promtail ist eingefroren; Alloy ist der offizielle Nachfolger und liest journald nativ (`loki.source.journal`) sowie Dateien (`local.file_match` + `loki.source.file`). +- **AMD-GPU-Metriken als eigenes Textfile-Skript** statt fremdem Exporter: Abhängigkeitsfrei, identische Quelle (rocm-smi/sysfs) wie bereits 2026-11-01 beim thermischen Lastprofil verwendet; Skript liegt versioniert im Repo (Abschnitt 8). -## 5. Metrics-Collector +## 4. Metrikpfad -- Sampling alle 10 s; atomares Schreiben (`state/tmp/` + `mv`) nach - `/var/lib/ghostnet-pipeline/state/system.json` (Mode `0644`). -- Schema: +- **Scrape:** VictoriaMetrics → node_exporter auf `10.0.0.90:9100`, Intervall 10 s. +- **GPU:** Das Textfile-Skript schreibt pro Karte Metriken wie `gn_gpu_utilization_percent{card="0"}`, `gn_gpu_vram_used_bytes`, `gn_gpu_junction_temp_celsius`, `gn_gpu_power_watts` — Werte aus rocm-smi bzw. `/sys/class/drm/card*/device/gpu_metrics`. Modus `0644`, atomarer Schreibwechsel (`.tmp` + `rename`). +- **Disk:** node_exporter erfasst Root-Dateisystem und den gemounteten NFS-Export (CT-101) über die Host-Mount-Tabelle. +- **Retention:** `-retentionPeriod=60d` (Startwert; Anpassung nach erstem Realbetrieb). +- **Zugriff:** Port 8428 (VM) und 9100 (node_exporter) nur host-lokal bzw. aus dem Dashboard-Container; nftables-Regeln siehe Abschnitt 7. -```json -{ - "ts": "…", - "cpu_util_pct": 0.0, - "ram_total_bytes": 0, - "ram_used_bytes": 0, - "disks": [{"mount": "/", "total_bytes": 0, "used_bytes": 0}], - "gpu_util_pct": 0.0, - "vram_used_bytes": 0, - "vram_total_bytes": 0 -} -``` +## 5. Logpfad -- GPU-Metriken werden host-seitig gelesen (rocm-smi oder sysfs); der - Dashboard-Container selbst hat keinen GPU-Zugriff. -- Ressourcenlimits: MemoryMax 512M, CPUWeight 50. +- **System-/Dienst-Logs:** Alloy liest journald über die Mitgliedschaft `systemd-journal`; Labels mindestens `unit`, `priority`, `hostname`. +- **Podman-Container-Logs:** Die Workload-Quadlets (Encoding, später LLM) setzen `log_driver=journald`, damit Container-Logs einheitlich im Journal landen und dort `_UID` des jeweiligen Workload-Kontos sowie `CONTAINER_NAME` als Labels nutzbar sind. Rootless-Stores fremder Konten werden **nicht** gelesen. +- **Encoding-Job-Logs:** Alloy verfolgt die Logdateien der Pipeline (read-only über `gn-media`); Label `job` aus dem Dateinamen/Pfad. +- **Retention:** Loki Filesystem-Store, `retention_period: 30d` (Startwert), Compactor aktiv. +- **Zugriff:** Port 3100 (Loki) nur host-lokal bzw. Dashboard-Container. -## 6. Dashboard +## 6. Dashboard (Blazor Server) -- **Views:** Ressourcen (CPU, RAM, Disk, GPU-Util, VRAM aus `system.json`); - Encoding-Übersicht (aktive Jobs mit Fortschritt, Queue-Tiefe pro Profil, - Historie done/failed der letzten 30 Tage, Fehlerfälle mit Ablageort in - `output/_failed/`); später LLM-Metriken. -- **Technik:** Python/Flask, server-seitig gerendert, ohne JS-Framework. Nur - read-only Mounts (`state/`, `queue/`); kein GPU-Zugriff, kein Schreibzugriff. -- **Erreichbarkeit:** Ingress über NPM (CT-103) mit TLS, zugriffsgeschützt - über Keycloak — analog zu den bestehenden Admin-Pfaden - (GNAI-005/GNAI-006). -- **Image:** schlankes Python-Base-Image + Flask, Eigenbau unter - `llm-server/monitoring/images/`, Digest gepinnt. +- **Technik:** ASP.NET Core Blazor Web App, Render Mode **Interactive Server**, .NET 10 (LTS). Ein Projekt, keine separate API; WebSocket-Upgrade in NPM aktivieren. +- **Views:** + 1. **Ressourcen:** Live-Werte + Verlaufscharts (1 h / 24 h / 7 t) für CPU, RAM, Disk je Mount. + 2. **GPU-Detail:** je RX 6900 XT Util, VRAM, Junction-Temp, Power — Live + Verlauf. + 3. **Encoding:** aktive Jobs mit Fortschritt, Queue-Tiefe pro Profil, Historie done/failed (30 Tage), Fehlerfälle mit Ablageort `output/_failed/` — aus `state/jobs/*.json` (read-only Mount, unverändert zu v1.0). + 4. **Logs:** Browser über Loki `query_range` mit Filter `unit`/`container`/`job` und Live-Tail (Polling alle 2 s). +- **Charts:** Blazor-ApexCharts (NuGet, C#-API, kapselt die JS-Abhängigkeit). v1.0-Grundsatz „kein JS-Framework" bleibt gewahrt: kein Frontend-Framework, nur eine Chart-Komponentenbibliothek. Falls auch das unerwünscht ist: Alternative sind server-seitig gerenderte SVG-Charts (offener Punkt 4). +- **Live-Updates:** server-seitige Timer/Streaming-Rendering für Live-Kacheln; keine Client-seitige Logik außer der Chart-Rendering-Bibliothek. +- **Image:** `llm-server/monitoring/images/dashboard/Containerfile`, Base `mcr.microsoft.com/dotnet/aspnet:10.x`, Digest gepinnt, Non-Root-User im Image (gemappte UID 984). -## 7. Anbindung Encoding-Pipeline +## 7. Authentifizierung und Erreichbarkeit -- Der Encoding-Worker schreibt `state/jobs/*.json` (Schema in GNENC-002 - Abschnitt 7); das Dashboard liest read-only. -- `state/` ist `gn-encoding:gn-media` mit Mode `2750`, damit `gn-dashboard` - lesen kann; Schreibzugriffe bleiben beim Worker (`state/jobs/`, `state/tmp/` - `0750`) und beim Collector (`state/system.json`). -- Das Dashboard hat keine Schreibzugriffe in die Pipeline. +- **Ingress:** NPM (CT-103) mit TLS und Split-DNS-Name (Hostname offen, Punkt 2); Proxy auf `10.0.0.90:8080`, WebSocket-Upgrade erforderlich. Hostname folgt dem Muster der bestehenden Admin-Pfade (GNAI-005/GNAI-006). +- **OIDC:** Die App authentifiziert selbst über `Microsoft.AspNetCore.Authentication.OpenIdConnect` mit PKCE (Confidential Client `gn-dashboard` in Keycloak CT-102) — analog zum bestätigten Vaultwarden-OIDC-Muster. Rollen-Claim (Realm-Rolle `dashboard-admin`) für die Autorisierung; **MFA wird über die Keycloak-Realm-Policy erzwungen**, nicht in der App. +- **Forwarded Headers:** `ForwardedHeaders`-Middleware, da TLS an NPM endet. +- **Netzwerksegmentierung (host-nftables auf `ghostnet-ki`):** + - 8080 (Dashboard) → erlaubt von 10.0.0.10 (NPM), + - 8428, 9100, 3100 → nur host-lokal / aus den rootless Containern desselben Hosts; per Regel von LAN und WireGuard abweisbar testen. +- **Rootless-Besonderheit:** Die Quadlets laufen unter verschiedenen Konten mit getrennten Netz-Namespaces; Quartett-übergreifender Verkehr läuft über die an die Host-IP gebundenen Ports (PublishPort, unprivilegiert >1024). Das ist der Grund für die nftables-Regeln oben; Abnahme mit Positiv-/Negativtest. ## 8. Repository-Grenzen ```text llm-server/monitoring/ -├── ansible/ # Playbook + Rolle (Collector-Service, Dashboard-Quadlet, Konto-Zustand) -├── images/ # Dashboard-Containerfile -└── scripts/ # Metrics-Collector +├── ansible/ # Playbooks + Rollen: Konten, systemd-Units, Quadlet-Rollen, nftables +├── images/ +│ └── dashboard/ # Containerfile (Blazor-App), Digest-Pin +├── scripts/ +│ ├── amdgpu-textfile-collector.py (o. ä.) +│ └── scrape.yml # VictoriaMetrics-Promscrape-Konfig +└── src/ + └── Ghostnet.Dashboard/ # Blazor-Projekt (später ggf. Solution mit Tests) ``` -Eigene Programme liegen versioniert unter `llm-server/monitoring/scripts/`; -das Dashboard-Image wird gebaut und per Digest gepinnt (analog GNENC-001 -Abschnitt 5). +VictoriaMetrics und Loki laufen mit gepinnten Upstream-Images (kein Eigenbau-Image nötig); Loki-/VM-Konfiguration liegt versioniert unter `ansible/` (Rollen) bzw. `images/`. ## 9. Offene Punkte -1. NPM-Hostname und Keycloak-Client für das Dashboard (Umsetzung mit - GNAI-005/GNAI-006). -2. Collector-Identität: root oder dedizierter Metrics-Account mit - `render`-Gruppe — finale Festlegung bei der Umsetzung. -3. Erweiterung um LLM-Metriken (später, eigenes Thema im AI-Bereich). +1. **Metrics-Account-Identität** (aus v1.0 übernommen): root vs. dedizierter Account mit `render`- und `systemd-journal`-Gruppe — bei der Umsetzung festlegen; Empfehlung: dedizierter Account. +2. **NPM-Hostname und Keycloak-Client** `gn-dashboard` (Umsetzung mit GNAI-005/GNAI-006). +3. **UID/GID für `gn-monitor`**: geplant 983 (nahe 984); freie ID bei Umsetzung prüfen. +4. **Chart-Bibliothek:** Blazor-ApexCharts vs. server-seitiges SVG (Entscheidung bei Implementierung). +5. **LLM-Metriken** (später, eigenes Thema im AI-Bereich): scrape-fähiger Endpoint des Serving-Containers oder Textfile — Aufnahme erst mit dauerhaftem Serving. +6. **Retention-Feinjustierung** (60 d Metriken / 30 d Logs) nach erstem Realbetriebsmonat. + +## 10. Abnahmekriterien (Auszug für die Umsetzung) + +- Ansible-Rollen idempotent: zweiter Lauf `changed=0`, `failed=0` (Konvention des Host-Projekts). +- Dashboard zeigt Live-Metriken und 24-h-Verläufe für CPU, RAM, Disk, beide GPUs. +- Logs aller drei Quellen (journald, Podman-Container, Encoding-Jobs) im Log-Browser auffindbar; Container-Log eines gestoppten/gestarteten Testcontainers erscheint/verschwindet korrekt. +- Login ohne Keycloak-Session abgewiesen; mit Realm-Rolle `dashboard-admin` und MFA erfolgreich; ohne Rolle abgewiesen (Negativtest). +- nftables-Negativtest: 8428/9100/3100 aus LAN nicht erreichbar; 8080 nur von NPM. +- Dashboard-Container hat keinen Schreibzugriff auf `state/` (Negativtest) und kein `/dev/kfd`, `/dev/dri`. + +--- + +## Folgeänderung für GNMON-000 (Dokumentationsindex) + +Beim Einchecken dieser Revision GNMON-000 anpassen: + +- **Bestätigter Stand:** „Komponenten: node_exporter + AMD-Textfile-Skript, VictoriaMetrics, Loki + Alloy (host-seitig), Dashboard unter `gn-dashboard` (984) als Blazor-Server-Quadlet; Metriken mit Verlaufshistorie, Logs aus journald, Containern und Encoding." +- **Statuszeile:** „Revision v2.0 (03.11.2026): Blazor statt Flask, Zeitreihen- und Log-Stack ergänzt." +- **Noch offen:** Punkte 1–6 aus Abschnitt 9 übernehmen; Punkt „system.json-Collector" entfällt. \ No newline at end of file diff --git a/llm-server/monitoring/ansible/ansible.cfg b/llm-server/monitoring/ansible/ansible.cfg new file mode 100644 index 0000000..b13fcf0 --- /dev/null +++ b/llm-server/monitoring/ansible/ansible.cfg @@ -0,0 +1,12 @@ +[defaults] +home = .ansible +host_key_checking = True +interpreter_python = auto_silent +local_tmp = .ansible/tmp +retry_files_enabled = False +roles_path = roles:../../../shared/ansible/roles +timeout = 15 + +[ssh_connection] +pipelining = True +ssh_args = -o ControlMaster=auto -o ControlPersist=60s diff --git a/llm-server/monitoring/ansible/inventories/workstation/group_vars/all.yml b/llm-server/monitoring/ansible/inventories/workstation/group_vars/all.yml new file mode 100644 index 0000000..df1a3b3 --- /dev/null +++ b/llm-server/monitoring/ansible/inventories/workstation/group_vars/all.yml @@ -0,0 +1,10 @@ +# GNMON-001 v2.0 workstation (development) inventory group vars. +# Role defaults carry the M1 development values; this file only pins the +# deployment-specific bits. + +# VictoriaMetrics image: by tag during development. The digest of the +# verified pull is recorded by the role and pinned here before M5. +# Tag choice: v1.154.1 is the newest patch release of the second-newest +# line (the v1.136 LTS line has no bare OSS tags in the Docker registry). +gnmon_victoria_metrics_image_tag: v1.154.1 +gnmon_victoria_metrics_image_digest: null diff --git a/llm-server/monitoring/ansible/inventories/workstation/hosts.yml b/llm-server/monitoring/ansible/inventories/workstation/hosts.yml new file mode 100644 index 0000000..7f4f57c --- /dev/null +++ b/llm-server/monitoring/ansible/inventories/workstation/hosts.yml @@ -0,0 +1,10 @@ +# GNMON-001 section 2: workstation inventory for the development phase. +# The monitoring suite is developed and first tested on the operator's +# CachyOS laptop (rootless, user-scope systemd) before the server rollout +# (ghostnet-ki) in milestone M5. +all: + hosts: + gnmon-workstation: + ansible_connection: local + ansible_user: ghost + # No become: everything in user scope during development. diff --git a/llm-server/monitoring/ansible/playbooks/monitor.yml b/llm-server/monitoring/ansible/playbooks/monitor.yml new file mode 100644 index 0000000..374ba00 --- /dev/null +++ b/llm-server/monitoring/ansible/playbooks/monitor.yml @@ -0,0 +1,28 @@ +--- +# GNMON-001 v2.0: host monitoring deployment. +# M1 (workstation): metrics path (collector + node_exporter + VictoriaMetrics). +# Tags: `metrics` for the M1 path; log path (M2) and dashboard (M3) follow. +- name: GNMON metrics path + hosts: all + connection: local + roles: + - role: gnmon_collector + tags: [collector] + - role: gnmon_victoria_metrics + tags: [metrics] + post_tasks: + - name: Verify the GPU metrics are ingested + ansible.builtin.uri: + url: "http://127.0.0.1:{{ gnmon_victoria_metrics_port }}/api/v1/query?query=gn_gpu_edge_temp_celsius" + status_code: 200 + register: gnmon_query_result + retries: 15 + delay: 4 + until: >- + gnmon_query_result.json is defined + and gnmon_query_result.json.data.result | length > 0 + tags: [metrics] + - name: Show the ingested GPU temperature sample + ansible.builtin.debug: + msg: "gn_gpu_edge_temp_celsius = {{ gnmon_query_result.json.data.result[0].value[1] }} °C" + tags: [metrics] diff --git a/llm-server/monitoring/ansible/roles/gnmon_collector/defaults/main.yml b/llm-server/monitoring/ansible/roles/gnmon_collector/defaults/main.yml new file mode 100644 index 0000000..54140e8 --- /dev/null +++ b/llm-server/monitoring/ansible/roles/gnmon_collector/defaults/main.yml @@ -0,0 +1,22 @@ +# GNMON-001 v2.0 section 3: node_exporter + AMD-GPU textfile collector. +# +# M1 scope: user-scope deployment for the workstation development phase +# (CachyOS laptop). The system scope for ghostnet-ki (metrics account, +# host-systemd, journald groups) is added with milestone M5. + +gnmon_collector_scope: user +gnmon_collector_user_home: "{{ lookup('ansible.builtin.env', 'HOME') }}" +gnmon_collector_textfile_dir: "{{ gnmon_collector_user_home }}/.local/state/gnmon/textfile" +gnmon_collector_binary_dir: "{{ gnmon_collector_user_home }}/.local/bin" +gnmon_collector_script_dir: "{{ gnmon_collector_user_home }}/.local/share/gnmon" +gnmon_collector_cache_dir: "{{ gnmon_collector_user_home }}/.cache/gnmon" + +# Collection cadence (GNMON-001 section 3: host-systemd-Timer, 10 s). +gnmon_collector_interval_seconds: 10 + +# node_exporter: pinned upstream release, verified against the release +# SHA256SUMS file at download time. +gnmon_collector_node_exporter_version: "1.12.1" +gnmon_collector_node_exporter_url: "https://github.com/prometheus/node_exporter/releases/download" +gnmon_collector_node_exporter_port: 9100 +gnmon_collector_node_exporter_listen: "127.0.0.1:{{ gnmon_collector_node_exporter_port }}" diff --git a/llm-server/monitoring/ansible/roles/gnmon_collector/handlers/main.yml b/llm-server/monitoring/ansible/roles/gnmon_collector/handlers/main.yml new file mode 100644 index 0000000..5c831f1 --- /dev/null +++ b/llm-server/monitoring/ansible/roles/gnmon_collector/handlers/main.yml @@ -0,0 +1,14 @@ +# GNMON-001: collector role handlers (user scope, M1). +- name: Restart collector timer + ansible.builtin.systemd: + name: gnmon-amdgpu-collector.timer + scope: user + state: restarted + daemon_reload: true + +- name: Restart node_exporter + ansible.builtin.systemd: + name: gnmon-node-exporter.service + scope: user + state: restarted + daemon_reload: true diff --git a/llm-server/monitoring/ansible/roles/gnmon_collector/tasks/main.yml b/llm-server/monitoring/ansible/roles/gnmon_collector/tasks/main.yml new file mode 100644 index 0000000..569c52f --- /dev/null +++ b/llm-server/monitoring/ansible/roles/gnmon_collector/tasks/main.yml @@ -0,0 +1,106 @@ +# GNMON-001 v2.0 section 3: AMD-GPU textfile collector + node_exporter. +# M1: user-scope deployment on the workstation inventory. +- name: Validate collector declarations + ansible.builtin.assert: + that: + - gnmon_collector_scope == 'user' + - gnmon_collector_user_home is match('^/') + - gnmon_collector_interval_seconds | int >= 5 + - gnmon_collector_node_exporter_version is match('^[0-9]+\\.[0-9]+\\.[0-9]+$') + fail_msg: >- + gnmon_collector only implements scope 'user' in milestone M1 and + requires absolute paths and a pinned node_exporter release. + +- name: Create collector directories + ansible.builtin.file: + path: "{{ item }}" + state: directory + mode: "0755" + loop: + - "{{ gnmon_collector_textfile_dir }}" + - "{{ gnmon_collector_binary_dir }}" + - "{{ gnmon_collector_script_dir }}" + - "{{ gnmon_collector_cache_dir }}" + +- name: Install the AMD GPU textfile collector + ansible.builtin.copy: + src: "{{ playbook_dir }}/../../scripts/amdgpu-textfile-collector.py" + dest: "{{ gnmon_collector_script_dir }}/amdgpu-textfile-collector.py" + mode: "0755" + notify: Restart collector timer + +- name: Fetch the node_exporter release checksums + ansible.builtin.get_url: + url: "{{ gnmon_collector_node_exporter_url }}/v{{ gnmon_collector_node_exporter_version }}/sha256sums.txt" + dest: "{{ gnmon_collector_cache_dir }}/node_exporter-{{ gnmon_collector_node_exporter_version }}.SHA256SUMS" + mode: "0644" + +- name: Record the pinned node_exporter tarball checksum + ansible.builtin.set_fact: + gnmon_collector_tarball_name: "node_exporter-{{ gnmon_collector_node_exporter_version }}.linux-amd64.tar.gz" + gnmon_collector_tarball_checksum: "{{ lookup('ansible.builtin.file', + gnmon_collector_cache_dir ~ '/node_exporter-' ~ gnmon_collector_node_exporter_version ~ '.SHA256SUMS') + | regex_findall('^([0-9a-f]{64})\\s+node_exporter-' ~ gnmon_collector_node_exporter_version ~ '\\.linux-amd64\\.tar\\.gz$', multiline=True) | first }}" + +- name: Download node_exporter {{ gnmon_collector_node_exporter_version }} + ansible.builtin.get_url: + url: "{{ gnmon_collector_node_exporter_url }}/v{{ gnmon_collector_node_exporter_version }}/{{ gnmon_collector_tarball_name }}" + dest: "{{ gnmon_collector_cache_dir }}/{{ gnmon_collector_tarball_name }}" + checksum: "sha256:{{ gnmon_collector_tarball_checksum }}" + mode: "0644" + +- name: Extract node_exporter + ansible.builtin.unarchive: + src: "{{ gnmon_collector_cache_dir }}/{{ gnmon_collector_tarball_name }}" + dest: "{{ gnmon_collector_cache_dir }}" + remote_src: true + creates: "{{ gnmon_collector_cache_dir }}/node_exporter-{{ gnmon_collector_node_exporter_version }}.linux-amd64" + +- name: Install the node_exporter binary + ansible.builtin.copy: + src: "{{ gnmon_collector_cache_dir }}/node_exporter-{{ gnmon_collector_node_exporter_version }}.linux-amd64/node_exporter" + dest: "{{ gnmon_collector_binary_dir }}/node_exporter" + mode: "0755" + notify: Restart node_exporter + +- name: Install the collector service unit + ansible.builtin.template: + src: gnmon-amdgpu-collector.service.j2 + dest: "{{ gnmon_collector_user_home }}/.config/systemd/user/gnmon-amdgpu-collector.service" + mode: "0644" + notify: Restart collector timer + +- name: Install the collector timer unit + ansible.builtin.template: + src: gnmon-amdgpu-collector.timer.j2 + dest: "{{ gnmon_collector_user_home }}/.config/systemd/user/gnmon-amdgpu-collector.timer" + mode: "0644" + notify: Restart collector timer + +- name: Install the node_exporter service unit + ansible.builtin.template: + src: gnmon-node-exporter.service.j2 + dest: "{{ gnmon_collector_user_home }}/.config/systemd/user/gnmon-node-exporter.service" + mode: "0644" + notify: Restart node_exporter + +- name: Run the collector once to seed the textfile + ansible.builtin.command: + cmd: "/usr/bin/python3 {{ gnmon_collector_script_dir }}/amdgpu-textfile-collector.py --textfile-dir {{ gnmon_collector_textfile_dir }}" + creates: "{{ gnmon_collector_textfile_dir }}/amdgpu.prom" + +- name: Enable and start the collector timer + ansible.builtin.systemd: + name: gnmon-amdgpu-collector.timer + scope: user + enabled: true + state: started + daemon_reload: true + +- name: Enable and start node_exporter + ansible.builtin.systemd: + name: gnmon-node-exporter.service + scope: user + enabled: true + state: started + daemon_reload: true diff --git a/llm-server/monitoring/ansible/roles/gnmon_collector/templates/gnmon-amdgpu-collector.service.j2 b/llm-server/monitoring/ansible/roles/gnmon_collector/templates/gnmon-amdgpu-collector.service.j2 new file mode 100644 index 0000000..50c6eb6 --- /dev/null +++ b/llm-server/monitoring/ansible/roles/gnmon_collector/templates/gnmon-amdgpu-collector.service.j2 @@ -0,0 +1,9 @@ +[Unit] +Description=GNMON AMD GPU textfile collector (GNMON-001) +Documentation=https://github.com/ghostnet/infrastructure + +[Service] +Type=oneshot +ExecStart=/usr/bin/python3 {{ gnmon_collector_script_dir }}/amdgpu-textfile-collector.py --textfile-dir {{ gnmon_collector_textfile_dir }} +# A failing sample must surface in the journal, not silently skip cycles. +Nice=5 diff --git a/llm-server/monitoring/ansible/roles/gnmon_collector/templates/gnmon-amdgpu-collector.timer.j2 b/llm-server/monitoring/ansible/roles/gnmon_collector/templates/gnmon-amdgpu-collector.timer.j2 new file mode 100644 index 0000000..96912c0 --- /dev/null +++ b/llm-server/monitoring/ansible/roles/gnmon_collector/templates/gnmon-amdgpu-collector.timer.j2 @@ -0,0 +1,10 @@ +[Unit] +Description=GNMON AMD GPU textfile collector timer (GNMON-001) + +[Timer] +OnBootSec=15s +OnUnitActiveSec={{ gnmon_collector_interval_seconds }}s +AccuracySec=1s + +[Install] +WantedBy=timers.target diff --git a/llm-server/monitoring/ansible/roles/gnmon_collector/templates/gnmon-node-exporter.service.j2 b/llm-server/monitoring/ansible/roles/gnmon_collector/templates/gnmon-node-exporter.service.j2 new file mode 100644 index 0000000..2ce034d --- /dev/null +++ b/llm-server/monitoring/ansible/roles/gnmon_collector/templates/gnmon-node-exporter.service.j2 @@ -0,0 +1,11 @@ +[Unit] +Description=GNMON node_exporter (GNMON-001) +Documentation=https://github.com/prometheus/node_exporter + +[Service] +ExecStart={{ gnmon_collector_binary_dir }}/node_exporter --collector.textfile.directory={{ gnmon_collector_textfile_dir }} --web.listen-address={{ gnmon_collector_node_exporter_listen }} +Restart=on-failure +RestartSec=2s + +[Install] +WantedBy=default.target diff --git a/llm-server/monitoring/ansible/roles/gnmon_victoria_metrics/defaults/main.yml b/llm-server/monitoring/ansible/roles/gnmon_victoria_metrics/defaults/main.yml new file mode 100644 index 0000000..82a569e --- /dev/null +++ b/llm-server/monitoring/ansible/roles/gnmon_victoria_metrics/defaults/main.yml @@ -0,0 +1,27 @@ +# GNMON-001 v2.0 sections 3-4: VictoriaMetrics (single) as rootless quadlet. +# +# M1 scope: user-scope quadlet under the current user on the workstation. +# The image runs by tag during development; M5 pins the digest of the +# verified pull in the server inventory (repo convention: digest pin). + +gnmon_victoria_metrics_image: docker.io/victoriametrics/victoria-metrics +gnmon_victoria_metrics_image_tag: v1.154.1 +# Digest of the verified pull on the workstation (2026-11-04, M1). +gnmon_victoria_metrics_image_digest: c7884f32920dd45a9d86542a717227e63af03e060e53bbf8031e6e6fd0e1e05d + +gnmon_victoria_metrics_user_home: "{{ lookup('ansible.builtin.env', 'HOME') }}" +gnmon_victoria_metrics_quadlet_dir: "{{ gnmon_victoria_metrics_user_home }}/.config/containers/systemd" +gnmon_victoria_metrics_config_dir: "{{ gnmon_victoria_metrics_user_home }}/.config/gnmon" +gnmon_victoria_metrics_data_dir: "{{ gnmon_victoria_metrics_user_home }}/.local/share/gnmon/victoria-metrics-data" + +gnmon_victoria_metrics_port: 8428 +gnmon_victoria_metrics_retention_days: 60 +gnmon_victoria_metrics_scrape_interval_seconds: 10 + +# node_exporter target (same host; NetworkMode=host in the quadlet). +gnmon_victoria_metrics_node_target: "127.0.0.1:9100" + +gnmon_victoria_metrics_image_ref: >- + {{ (gnmon_victoria_metrics_image_digest is not none) + | ternary(gnmon_victoria_metrics_image ~ '@sha256:' ~ gnmon_victoria_metrics_image_digest, + gnmon_victoria_metrics_image ~ ':' ~ gnmon_victoria_metrics_image_tag) }} diff --git a/llm-server/monitoring/ansible/roles/gnmon_victoria_metrics/handlers/main.yml b/llm-server/monitoring/ansible/roles/gnmon_victoria_metrics/handlers/main.yml new file mode 100644 index 0000000..7af1a79 --- /dev/null +++ b/llm-server/monitoring/ansible/roles/gnmon_victoria_metrics/handlers/main.yml @@ -0,0 +1,7 @@ +# GNMON-001: VictoriaMetrics role handlers (user scope, M1). +- name: Restart VictoriaMetrics + ansible.builtin.systemd: + name: gnmon-victoria-metrics.service + scope: user + state: restarted + daemon_reload: true diff --git a/llm-server/monitoring/ansible/roles/gnmon_victoria_metrics/tasks/main.yml b/llm-server/monitoring/ansible/roles/gnmon_victoria_metrics/tasks/main.yml new file mode 100644 index 0000000..197955b --- /dev/null +++ b/llm-server/monitoring/ansible/roles/gnmon_victoria_metrics/tasks/main.yml @@ -0,0 +1,62 @@ +# GNMON-001 v2.0 sections 3-4: VictoriaMetrics rootless quadlet (M1: user scope). +- name: Validate VictoriaMetrics declarations + ansible.builtin.assert: + that: + - gnmon_victoria_metrics_user_home is match('^/') + - gnmon_victoria_metrics_retention_days | int >= 1 + - gnmon_victoria_metrics_node_target | length > 0 + fail_msg: VictoriaMetrics declarations are incomplete or ambiguous. + +- name: Create VictoriaMetrics directories + ansible.builtin.file: + path: "{{ item }}" + state: directory + mode: "0755" + loop: + - "{{ gnmon_victoria_metrics_quadlet_dir }}" + - "{{ gnmon_victoria_metrics_config_dir }}" + - "{{ gnmon_victoria_metrics_data_dir }}" + +- name: Install the promscrape configuration + ansible.builtin.template: + src: scrape.yml.j2 + dest: "{{ gnmon_victoria_metrics_config_dir }}/scrape.yml" + mode: "0644" + notify: Restart VictoriaMetrics + +- name: Install the VictoriaMetrics quadlet + ansible.builtin.template: + src: gnmon-victoria-metrics.container.j2 + dest: "{{ gnmon_victoria_metrics_quadlet_dir }}/gnmon-victoria-metrics.container" + mode: "0644" + notify: Restart VictoriaMetrics + +- name: Enable and start VictoriaMetrics + ansible.builtin.systemd: + name: gnmon-victoria-metrics.service + scope: user + enabled: true + state: started + daemon_reload: true + +- name: Record the running image digest + ansible.builtin.command: + cmd: "podman inspect --format '{{ '{{' }}.ImageDigest{{ '}}' }}' gnmon-victoria-metrics" + changed_when: false + register: gnmon_victoria_metrics_inspect + failed_when: false + +- name: Show the running image digest (digest pin for M5) + ansible.builtin.debug: + msg: >- + gnmon-victoria-metrics runs {{ gnmon_victoria_metrics_image }}:{{ gnmon_victoria_metrics_image_tag }} + (digest {{ gnmon_victoria_metrics_inspect.stdout | default('n/a') }}) + +- name: Wait for the VictoriaMetrics health endpoint + ansible.builtin.uri: + url: "http://127.0.0.1:{{ gnmon_victoria_metrics_port }}/health" + status_code: 200 + register: gnmon_victoria_metrics_health + retries: 30 + delay: 2 + until: gnmon_victoria_metrics_health.status == 200 diff --git a/llm-server/monitoring/ansible/roles/gnmon_victoria_metrics/templates/gnmon-victoria-metrics.container.j2 b/llm-server/monitoring/ansible/roles/gnmon_victoria_metrics/templates/gnmon-victoria-metrics.container.j2 new file mode 100644 index 0000000..f73c33c --- /dev/null +++ b/llm-server/monitoring/ansible/roles/gnmon_victoria_metrics/templates/gnmon-victoria-metrics.container.j2 @@ -0,0 +1,19 @@ +[Unit] +Description=GNMON VictoriaMetrics (GNMON-001) +Documentation=https://docs.victoriametrics.com/ + +[Container] +ContainerName=gnmon-victoria-metrics +Image={{ gnmon_victoria_metrics_image_ref }} +# Rootless quadlet reaches node_exporter on the host loopback interface. +Network=host +Exec=-promscrape.config=/etc/gnmon/scrape.yml -promscrape.suppressDuplicateScrapeTargetErrors -retentionPeriod={{ gnmon_victoria_metrics_retention_days }}d +Volume={{ gnmon_victoria_metrics_config_dir }}/scrape.yml:/etc/gnmon/scrape.yml:ro,Z +Volume={{ gnmon_victoria_metrics_data_dir }}:/victoria-metrics-data:Z + +[Service] +# Quadlet services are user units; pods are transient managed containers. +Restart=on-failure + +[Install] +WantedBy=default.target diff --git a/llm-server/monitoring/ansible/roles/gnmon_victoria_metrics/templates/scrape.yml.j2 b/llm-server/monitoring/ansible/roles/gnmon_victoria_metrics/templates/scrape.yml.j2 new file mode 100644 index 0000000..37eb122 --- /dev/null +++ b/llm-server/monitoring/ansible/roles/gnmon_victoria_metrics/templates/scrape.yml.j2 @@ -0,0 +1,9 @@ +# GNMON-001 section 4: VictoriaMetrics promscrape configuration. +global: + scrape_interval: {{ gnmon_victoria_metrics_scrape_interval_seconds }}s + +scrape_configs: + - job_name: node + static_configs: + - targets: + - "{{ gnmon_victoria_metrics_node_target }}" diff --git a/llm-server/monitoring/scripts/amdgpu-textfile-collector.py b/llm-server/monitoring/scripts/amdgpu-textfile-collector.py new file mode 100755 index 0000000..e81dc3e --- /dev/null +++ b/llm-server/monitoring/scripts/amdgpu-textfile-collector.py @@ -0,0 +1,213 @@ +#!/usr/bin/env python3 +"""AMD GPU textfile collector for Prometheus node_exporter (GNMON-001 v2.0). + +Reads amdgpu metrics directly from sysfs (no rocm-smi, no ROCm runtime +required) and writes them as a Prometheus textfile exposition for the +node_exporter textfile collector. Same data source as the thermal load +profile from 2026-11-01 (GNAI-010 section 10.8). + +Per AMD GPU (vendor 0x1002) the following metrics are emitted when the +underlying sysfs file exists (APUs expose a subset, discrete cards all): + + gn_gpu_up{card,gpu} + gn_gpu_utilization_percent{card,gpu} + gn_gpu_vram_used_bytes{card,gpu} + gn_gpu_vram_total_bytes{card,gpu} + gn_gpu_edge_temp_celsius{card,gpu} + gn_gpu_junction_temp_celsius{card,gpu} + gn_gpu_memory_temp_celsius{card,gpu} + gn_gpu_fan_rpm{card,gpu} + gn_gpu_fan_pwm_percent{card,gpu} + gn_gpu_power_watts{card,gpu} + +The output file is written atomically (tmp + rename) with mode 0644 so the +node_exporter textfile directory never exposes a partial file. + +Usage: amdgpu-textfile-collector.py --textfile-dir DIR [--drm-root /sys/class/drm] +""" + +from __future__ import annotations + +import argparse +import os +import sys +import tempfile +from pathlib import Path + +AMD_VENDOR_ID = "0x1002" + + +def _read_int(path: Path) -> int | None: + try: + return int(path.read_text().strip()) + except (OSError, ValueError): + return None + + +def _read_text(path: Path) -> str | None: + try: + return path.read_text().strip() + except OSError: + return None + + +def _read_hwmon_temps(device_dir: Path) -> dict[str, float]: + """Map hwmon temperature labels (edge/junction/mem/mcd) to celsius.""" + temps: dict[str, float] = {} + for hwmon_dir in sorted(device_dir.glob("hwmon/hwmon*")): + for input_path in sorted(hwmon_dir.glob("temp*_input")): + value = _read_int(input_path) + if value is None: + continue + label_path = input_path.with_name( + input_path.name.replace("_input", "_label") + ) + label = _read_text(label_path) or "" + label = label.lower() + if "junction" in label: + temps["junction"] = value / 1000.0 + elif "edge" in label: + temps["edge"] = value / 1000.0 + elif "mem" in label or "mcd" in label: + temps.setdefault("memory", value / 1000.0) + return temps + + +def collect(drm_root: Path) -> list[str]: + lines: list[str] = [] + for device_link in sorted(drm_root.glob("card*")): + if "-" in device_link.name: + continue # connector entries like card0-eDP-1 + device_dir = device_link / "device" + if not device_dir.is_dir(): + continue + vendor = _read_text(device_dir / "vendor") + if vendor != AMD_VENDOR_ID: + continue + card = device_link.name.removeprefix("card") + gpu = _read_text(device_dir / "product_name") or "unknown" + + def emit(metric: str, value, help_text: str, metric_type: str) -> None: + lines.append(f"# HELP {metric} {help_text}") + lines.append(f"# TYPE {metric} {metric_type}") + if value is not None: + lines.append(f'{metric}{{card="{card}",gpu="{gpu}"}} {value}') + + emit("gn_gpu_up", 1, "AMD GPU is visible in sysfs", "gauge") + emit( + "gn_gpu_utilization_percent", + _read_int(device_dir / "gpu_busy_percent"), + "GPU utilization in percent (amdgpu sysfs)", + "gauge", + ) + emit( + "gn_gpu_vram_used_bytes", + _read_int(device_dir / "mem_info_vram_used"), + "Used VRAM in bytes", + "gauge", + ) + emit( + "gn_gpu_vram_total_bytes", + _read_int(device_dir / "mem_info_vram_total"), + "Total VRAM in bytes", + "gauge", + ) + temps = _read_hwmon_temps(device_dir) + emit( + "gn_gpu_edge_temp_celsius", + temps.get("edge"), + "GPU edge temperature in celsius", + "gauge", + ) + emit( + "gn_gpu_junction_temp_celsius", + temps.get("junction"), + "GPU junction (hotspot) temperature in celsius", + "gauge", + ) + emit( + "gn_gpu_memory_temp_celsius", + temps.get("memory"), + "GPU memory temperature in celsius", + "gauge", + ) + for hwmon_dir in sorted(device_dir.glob("hwmon/hwmon*")): + for fan_path in sorted(hwmon_dir.glob("fan*_input")): + fan_index = fan_path.name.removeprefix("fan").removesuffix("_input") + rpm = _read_int(fan_path) + if rpm is None: + continue + lines.append(f"# HELP gn_gpu_fan_rpm GPU fan speed in rpm") + lines.append(f"# TYPE gn_gpu_fan_rpm gauge") + lines.append( + f'gn_gpu_fan_rpm{{card="{card}",gpu="{gpu}",fan="{fan_index}"}} {rpm}' + ) + pwm = _read_int(hwmon_dir / "pwm1") + if pwm is not None: + lines.append(f"# HELP gn_gpu_fan_pwm_percent Requested fan PWM in percent") + lines.append(f"# TYPE gn_gpu_fan_pwm_percent gauge") + lines.append( + f'gn_gpu_fan_pwm_percent{{card="{card}",gpu="{gpu}"}} {pwm / 255.0 * 100:.2f}' + ) + # AMD power sensors report microwatts (power1_average preferred). + for power_name in ("power1_average", "power1_input"): + microwatts = _read_int(hwmon_dir / power_name) + if microwatts is not None: + lines.append(f"# HELP gn_gpu_power_watts GPU board power in watts") + lines.append(f"# TYPE gn_gpu_power_watts gauge") + lines.append( + f'gn_gpu_power_watts{{card="{card}",gpu="{gpu}"}} {microwatts / 1e6:.3f}' + ) + break + return lines + + +def write_textfile(lines: list[str], textfile_dir: Path) -> Path: + textfile_dir.mkdir(parents=True, exist_ok=True) + target = textfile_dir / "amdgpu.prom" + fd, tmp_name = tempfile.mkstemp( + dir=textfile_dir, prefix=".amdgpu.prom.", suffix=".tmp" + ) + try: + with os.fdopen(fd, "w", encoding="ascii") as handle: + handle.write("\n".join(lines) + "\n") + os.chmod(tmp_name, 0o644) + os.replace(tmp_name, target) + except BaseException: + try: + os.unlink(tmp_name) + except OSError: + pass + raise + return target + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + "--textfile-dir", + type=Path, + default=Path("/var/lib/node_exporter/textfile"), + help="node_exporter textfile directory (default: %(default)s)", + ) + parser.add_argument( + "--drm-root", + type=Path, + default=Path("/sys/class/drm"), + help="sysfs DRM root (default: %(default)s)", + ) + parser.add_argument( + "--stdout", action="store_true", help="print exposition to stdout instead" + ) + args = parser.parse_args() + + lines = collect(args.drm_root) + if args.stdout: + print("\n".join(lines)) + return 0 + write_textfile(lines, args.textfile_dir) + return 0 + + +if __name__ == "__main__": + sys.exit(main())