From 7db7aa2e9d02d263ec0853ba77f2addb8d5886dd Mon Sep 17 00:00:00 2001 From: alkatrazz Date: Wed, 13 May 2026 23:10:56 +0200 Subject: [PATCH] =?UTF-8?q?docs:=20mise=20=C3=A0=20jour=20documentation=20?= =?UTF-8?q?monitoring=20+=20llama-server=20+=20r=C3=A9seau?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - monitoring.md : refonte complète — architecture corrigée (ROCm via textfile_collector port 9100, plus de port 9101), dashboards Grafana (funk-k8s1, funk-inf1, funk-ai01) avec URLs directes et workflow GitOps, tableaux de règles d'alertes par catégorie, commandes admin Prometheus/AlertManager, structure fichiers annotée - llama_server.md : mis à jour Qwen3-8B (depuis Qwen2.5-14B), ajout des 3 instances systemd (GPU 1234 + CPU system 1236 + CPU monitor 1237), section Métriques Prometheus avec flag --metrics obligatoire et liste des métriques llamacpp réelles, performances mises à jour - reseau.md : ajout ports 9100 (node_exporter) et 9093 (alertmanager webhook) dans la table nftables, note sur l'ordre des règles (insert avant drop, pas add) Co-Authored-By: Claude Sonnet 4.6 --- admin/llama_server.md | 106 ++++++++---- admin/monitoring.md | 368 +++++++++++++++++++++++++++++++----------- admin/reseau.md | 7 + 3 files changed, 358 insertions(+), 123 deletions(-) diff --git a/admin/llama_server.md b/admin/llama_server.md index 2c67a20..6efb7cb 100644 --- a/admin/llama_server.md +++ b/admin/llama_server.md @@ -1,30 +1,52 @@ # llama-server — Inférence LLM (gpu-01) -llama-server (llama.cpp compilé with ROCm 7.x) tourne en service systemd sur **gpu-01** (`192.168.10.20:1234`). +llama-server (llama.cpp compilé with ROCm 7.x) tourne en **trois instances systemd** sur **gpu-01** (`192.168.10.20`). API 100% compatible OpenAI — remplace LM Studio pour l'inférence. --- +## Trois instances + +| Service systemd | Port | Modèle | Backend | Usage | +|---|---|---|---|---| +| `llama-server` | 1234 | Qwen3-8B Q4_K_M | GPU (RX 6700XT) | Inférence principale — Hermes + LiteLLM | +| `llama-server-system` | 1236 | Qwen3-1.7B Q4_K_M | CPU | Profil Hermes `system` (tâches légères) | +| `llama-server-monitor` | 1237 | Qwen3-1.7B Q4_K_M | CPU | Profil Hermes `monitor` (supervision) | + +Les instances CPU (`system`, `monitor`) partagent le même binaire mais des configs distinctes. +Les modèles sont sur NFS monté depuis storage-01 (`/mnt/models`). + +--- + ## Service systemd ```bash -# Depuis gpu-01 +# Instance GPU (principale) sudo systemctl status llama-server sudo systemctl restart llama-server sudo journalctl -u llama-server -f -sudo journalctl -u llama-server -n 50 + +# Instance CPU — profil system +sudo systemctl status llama-server-system +sudo systemctl restart llama-server-system +sudo journalctl -u llama-server-system -f + +# Instance CPU — profil monitor +sudo systemctl status llama-server-monitor +sudo systemctl restart llama-server-monitor +sudo journalctl -u llama-server-monitor -f ``` --- -## Modèle actuel +## Modèle actuel (GPU) | Paramètre | Valeur | |---|---| -| Modèle | Qwen2.5-14B-Instruct Q4_K_M | -| Alias API | `qwen2.5-14b-instruct` | -| Chemin | `/mnt/models/bartowski/Qwen2.5-14B-Instruct-GGUF/Qwen2.5-14B-Instruct-Q4_K_M.gguf` | -| Contexte | 16384 tokens (limité par VRAM — voir ci-dessous) | +| Modèle | Qwen3-8B Q4_K_M | +| Alias API | `qwen3-8b` | +| Chemin | `/mnt/models/bartowski/Qwen3-8B-GGUF/Qwen3-8B-Q4_K_M.gguf` | +| Contexte | 32768 tokens | | GPU offload | 99 layers (tout sur GPU) | | Parallélisme | 1 slot (requis pour Hermes — voir bug parallel) | | Embeddings | activés (`--embeddings --pooling mean`) | @@ -33,12 +55,9 @@ sudo journalctl -u llama-server -n 50 | Élément | VRAM | |---|---| -| Modèle Q4_K_M 14B | ~8 GB | -| KV cache à 16384 ctx | ~3 GB | -| **Total** | **~11 GB** ✅ | - -À 32768 tokens de contexte, le KV cache monte à ~6 GB → total ~14 GB → segfault. -**Ne pas augmenter `llama_ctx_size` au-delà de 16384 pour le 14B.** +| Modèle Q4_K_M 8B | ~5 GB | +| KV cache à 32768 ctx | ~4 GB | +| **Total** | **~9 GB** ✅ | --- @@ -52,20 +71,20 @@ Le flag `--pooling mean` est obligatoire pour les LLM causaux (sinon : erreur 40 # Test embeddings depuis storage-01 curl -s -X POST http://192.168.10.20:1234/v1/embeddings \ -H "Content-Type: application/json" \ - -d '{"model":"qwen2.5-14b-instruct","input":["test"]}' | jq '.data[0].embedding | length' -# → 5120 (dimension Qwen2.5-14B) + -d '{"model":"qwen3-8b","input":["test"]}' | jq '.data[0].embedding | length' +# → 3584 (dimension Qwen3-8B) ``` --- ## Performances (RX 6700XT, ROCm 7.x) -| Métrique | Qwen2.5-7B | Qwen2.5-14B | +| Métrique | Qwen3-1.7B (CPU) | Qwen3-8B (GPU) | |---|---|---| -| Prefill | ~400 tok/s | ~200 tok/s | -| Génération | ~70 tok/s | ~35 tok/s | -| TTFT Hermes (15k tokens) | ~35s | ~75s | -| VRAM modèle | ~4 GB | ~8 GB | +| Prefill | ~50 tok/s | ~300 tok/s | +| Génération | ~15 tok/s | ~60 tok/s | +| TTFT Hermes (15k tokens) | ~300s | ~50s | +| VRAM modèle | — (CPU only) | ~5 GB | --- @@ -75,25 +94,57 @@ curl -s -X POST http://192.168.10.20:1234/v1/embeddings \ # Depuis storage-01 ou n'importe quelle machine du LAN cluster curl -s http://192.168.10.20:1234/v1/models | jq '.data[].id' -# Test inférence rapide +# Test inférence rapide (GPU) curl http://192.168.10.20:1234/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ - "model": "qwen2.5-14b-instruct", + "model": "qwen3-8b", "messages": [{"role": "user", "content": "Dis bonjour"}], "max_tokens": 50 }' + +# Test instances CPU +curl -s http://192.168.10.20:1236/v1/models | jq '.data[].id' +curl -s http://192.168.10.20:1237/v1/models | jq '.data[].id' ``` --- +## Métriques Prometheus + +Le flag `--metrics` est requis dans le service systemd pour activer l'endpoint `/metrics`. +Sans lui, llama-server retourne `501 Not Implemented`. + +```bash +# Vérifier que les métriques sont disponibles +curl -s http://192.168.10.20:1234/metrics | grep llamacpp + +# Métriques clés exposées +curl -s http://192.168.10.20:1234/metrics | grep -E \ + "llamacpp:prompt_tokens_total|llamacpp:tokens_predicted_total|llamacpp:requests_deferred|llamacpp:kv_cache_usage_ratio" +``` + +| Métrique | Description | +|---|---| +| `llamacpp:prompt_tokens_total` | Tokens de prompt traités (cumul) | +| `llamacpp:tokens_predicted_total` | Tokens générés (cumul) | +| `llamacpp:prompt_tokens_seconds` | Débit prefill (tok/s) | +| `llamacpp:predicted_tokens_seconds` | Débit génération (tok/s) | +| `llamacpp:requests_deferred` | Requêtes en file d'attente (backpressure) | +| `llamacpp:kv_cache_usage_ratio` | Occupation KV cache (0–1) | +| `llamacpp:kv_cache_tokens` | Tokens actuellement en KV cache | + +Ces métriques sont scrapées par Prometheus via les jobs `llama-server-gpu`, `llama-server-system`, `llama-server-monitor` définis dans `k8s/infra/monitoring/values.yaml`. + +--- + ## Changer de modèle 1. Modifier `host_vars/gpu-01/vars.yml` : ```yaml llama_model_path: "/mnt/models/bartowski/NouveauModele.gguf" llama_model_alias: "nouveau-alias" - llama_ctx_size: 16384 # ajuster selon VRAM disponible + llama_ctx_size: 32768 # ajuster selon VRAM disponible ``` 2. Redéployer : @@ -132,8 +183,9 @@ sudo systemctl restart llama-server |---|---| | GPU non officiel | RX 6700XT (gfx1031) — `HSA_OVERRIDE_GFX_VERSION=10.3.0` dans le service | | ROCm version | 7.2.3 — libs dans `/opt/rocm` | -| VRAM limite | 14B + 16k ctx = ~11 GB — ne pas dépasser 16384 tokens | +| --metrics obligatoire | Sans ce flag, `/metrics` retourne `501 Not Implemented` — Prometheus ne scrappe rien | | parallel=1 obligatoire | `--parallel 4` divise le ctx en slots → contexte insuffisant pour Hermes | -| pooling mean obligatoire | sans `--pooling mean` l'endpoint `/v1/embeddings` retourne erreur 400 | +| pooling mean obligatoire | Sans `--pooling mean`, l'endpoint `/v1/embeddings` retourne erreur 400 | | Gemma 4 interdit | Crash ROCm sur prompts >800 tokens | -| Modèles sur NFS | `/mnt/models` monté depuis storage-01 (NFS) | +| Modèles sur NFS | `/mnt/models` monté depuis storage-01 (NFS) — si NFS down, les 3 services échouent au démarrage | +| 3 services indépendants | Chaque instance a son propre service systemd — redémarrer l'un n'affecte pas les autres | diff --git a/admin/monitoring.md b/admin/monitoring.md index 9470981..b13f418 100644 --- a/admin/monitoring.md +++ b/admin/monitoring.md @@ -1,7 +1,8 @@ # Monitoring — Grafana + Prometheus + AlertManager -Stack de monitoring déployée via ArgoCD dans le namespace `monitoring`. +Stack déployée via ArgoCD dans le namespace `monitoring`. Chart : `kube-prometheus-stack` v85.0.2 (Prometheus Operator). +Dashboards et alertes custom versionnés dans `k8s/infra/monitoring/`. --- @@ -10,11 +11,11 @@ Chart : `kube-prometheus-stack` v85.0.2 (Prometheus Operator). | Service | URL | Login | Mot de passe | |---|---|---|---| | **Grafana** | http://grafana.lab.local | `admin` | `funk-grafana` | -| **AlertManager** | http://alertmanager.lab.local | — | — | | **Prometheus** | http://prometheus.lab.local | — | — | +| **AlertManager** | http://alertmanager.lab.local | — | — | -> DNS `*.lab.local` ne résout que depuis le cluster LAN (192.168.10.0/24). -> Depuis le poste perso (192.168.1.x), les entrées sont dans `/etc/hosts` : +> DNS `*.lab.local` ne résout que depuis le LAN cluster (192.168.10.0/24). +> Depuis le poste perso (192.168.1.x), ajouter dans `/etc/hosts` : > ``` > 192.168.10.200 grafana.lab.local argocd.lab.local prometheus.lab.local alertmanager.lab.local > ``` @@ -25,32 +26,127 @@ Chart : `kube-prometheus-stack` v85.0.2 (Prometheus Operator). ``` Prometheus (k8s, namespace monitoring) - ├── kube-state-metrics → ressources k8s (pods, deployments, nodes) - ├── node-exporter (daemonset) → métriques système compute-01/02/03 - ├── scrape storage-01:9100 → métriques système storage-01 - ├── scrape gpu-01:9100 → métriques système gpu-01 - ├── scrape gpu-01:9101 (ROCm) → température GPU, VRAM, utilisation - └── scrape gpu-01:1234/1236/1237 → llama-server (tokens/s, slots, queue) + ├── kube-state-metrics → ressources k8s (pods, deployments, nodes) + ├── node-exporter (DaemonSet) → métriques système compute-01/02/03 + ├── scrape storage-01:9100 → métriques système storage-01 (job=storage-01) + ├── scrape gpu-01:9100 → métriques système + ROCm gpu-01 (job=gpu-01-node) + │ └── textfile_collector → rocm_gpu_temperature/utilization/vram (rocm_scraper.timer) + ├── scrape gpu-01:1234 → llama-server GPU Qwen3-8B (job=llama-server-gpu) + ├── scrape gpu-01:1236 → llama-server CPU system (job=llama-server-system) + └── scrape gpu-01:1237 → llama-server CPU monitor (job=llama-server-monitor) ↓ AlertManager - └── webhook → storage-01:9093/webhook → ask-agent monitor → Hermes profil monitor + ├── receiver "null" → alerte Watchdog (heartbeat interne — silencé) + └── receiver "hermes-monitor" → webhook storage-01:9093 → ask-agent monitor → Hermes ``` --- -## Installation (déjà faite via ArgoCD) +## Dashboards Grafana -Le monitoring est géré par ArgoCD. Pour le redéployer depuis zéro : +Trois dashboards custom auto-importés via ConfigMaps (label `grafana_dashboard: "1"`). +Versionnés dans `k8s/infra/monitoring/dashboards/`. -```bash -# Ajouter le repo Helm -helm repo add prometheus-community https://prometheus-community.github.io/helm-charts -helm repo update +| Dashboard | UID | Contenu | +|---|---|---| +| **Funk — Kubernetes** | `funk-k8s1` | Cluster overview, CPU/RAM par nœud, pod restarts, PVCs | +| **Funk — Infrastructure** | `funk-inf1` | Hardware compute/storage-01/gpu-01 — CPU, RAM, disque, réseau, GPU ROCm | +| **Funk — IA / Hermes** | `funk-ai01` | Tokens/s llama-server (GPU+CPU), requêtes, VRAM, température GPU | -# L'application est créée automatiquement par ArgoCD depuis k8s/infra/monitoring/ -# Forcer un refresh si nécessaire : -kubectl -n argocd annotate application kube-prometheus-stack \ - argocd.argoproj.io/refresh=hard --overwrite +URLs directes : +- http://grafana.lab.local/d/funk-k8s1 +- http://grafana.lab.local/d/funk-inf1 +- http://grafana.lab.local/d/funk-ai01 + +### Ajouter un dashboard custom (GitOps) + +1. Créer `k8s/infra/monitoring/dashboards/mon-dashboard.yaml` : + +```yaml +apiVersion: v1 +kind: ConfigMap +metadata: + name: grafana-dashboard-mon-dashboard + namespace: monitoring + labels: + grafana_dashboard: "1" +data: + mon-dashboard.json: | + { ... JSON exporté depuis Grafana ... } +``` + +2. `git add` + `git push` → ArgoCD applique → sidecar Grafana importe automatiquement. + +Pour exporter un dashboard depuis Grafana : **Dashboard → Share → Export → Save to file**. + +--- + +## Règles d'alerte + +Versionnées dans `k8s/infra/monitoring/alerts/` comme `PrometheusRule`. +Déclenchent AlertManager → webhook storage-01:9093 → profil `monitor` Hermes. + +### Nœuds (`alerts-node.yaml`) + +| Alerte | Seuil | Sévérité | +|---|---|---| +| `NodeHighCPU` | CPU > 90% pendant 5 min | warning | +| `NodeCriticalCPU` | CPU > 98% pendant 2 min | critical | +| `NodeHighMemory` | RAM > 90% pendant 5 min | warning | +| `NodeCriticalMemory` | RAM > 97% pendant 2 min | critical | +| `NodeDiskSpaceLow` | Disque > 80% pendant 10 min | warning | +| `NodeDiskSpaceCritical` | Disque > 93% pendant 5 min | critical | +| `Storage01Down` | `up{job="storage-01"} == 0` pendant 2 min | critical | +| `Gpu01Down` | `up{job="gpu-01-node"} == 0` pendant 2 min | critical | +| `NodeHighLoad` | Load5 > 8 pendant 10 min | warning | + +### Kubernetes (`alerts-k8s.yaml`) + +| Alerte | Seuil | Sévérité | +|---|---|---| +| `KubeNodeNotReady` | Nœud NotReady pendant 5 min | critical | +| `PodCrashLooping` | > 3 restarts en 15 min | warning | +| `PodFailedLong` | Pod Failed/Unknown pendant 10 min | warning | +| `PodPendingLong` | Pod Pending pendant 15 min | warning | +| `DeploymentUnavailable` | Réplicas < spec pendant 5 min | warning | +| `PVCNotBound` | PVC non Bound pendant 10 min | warning | +| `ArgoCDAppOutOfSync` | App ArgoCD OutOfSync pendant 30 min | warning | + +### IA / LLM (`alerts-ai.yaml`) + +| Alerte | Seuil | Sévérité | +|---|---|---| +| `LlamaServerGPUDown` | `up{job="llama-server-gpu"} == 0` pendant 2 min | critical | +| `LlamaServerSystemDown` | `up{job="llama-server-system"} == 0` pendant 2 min | warning | +| `LlamaServerMonitorDown` | `up{job="llama-server-monitor"} == 0` pendant 2 min | warning | +| `GPUTemperatureHigh` | Temp GPU > 80°C pendant 5 min | warning | +| `GPUTemperatureCritical` | Temp GPU > 90°C pendant 2 min | critical | +| `GPUVRAMAlmostFull` | VRAM > 95% pendant 5 min | warning | +| `LlamaServerHighQueueGPU` | Requêtes deferred > 5 pendant 2 min | warning | + +### Ajouter une règle d'alerte + +```yaml +# k8s/infra/monitoring/alerts/ma-regle.yaml +apiVersion: monitoring.coreos.com/v1 +kind: PrometheusRule +metadata: + name: funk-ma-regle + namespace: monitoring + labels: + release: kube-prometheus-stack # obligatoire — sélecteur du Prometheus operator +spec: + groups: + - name: funk.custom + rules: + - alert: MonAlerte + expr: ma_metrique > seuil + for: 5m + labels: + severity: warning + annotations: + summary: "Description courte" + description: "Détail avec {{ $value }}" ``` --- @@ -60,44 +156,76 @@ kubectl -n argocd annotate application kube-prometheus-stack \ ### Nœuds hors cluster (storage-01, gpu-01) `node_exporter` v1.9.1 déployé via Ansible (rôle `node_exporter`). +Prérequis firewall : port 9100 ouvert depuis 192.168.10.0/24 (nftables storage-01, firewalld gpu-01). ```bash -# Vérifier node_exporter -systemctl status node_exporter +# État node_exporter +ssh storage-01 "systemctl status node_exporter" +ssh gpu-01 "systemctl status node_exporter" + +# Vérifier les métriques directement curl -s http://192.168.10.1:9100/metrics | grep node_memory_MemAvailable curl -s http://192.168.10.20:9100/metrics | grep node_memory_MemAvailable + +# Vérifier le statut des targets dans Prometheus +curl -s http://prometheus.lab.local/api/v1/targets | python3 -c " +import sys, json +d = json.load(sys.stdin) +for t in d['data']['activeTargets']: + job = t['labels'].get('job','?') + print(t['health'], job, t.get('lastError','')[:60]) +" | grep -E "storage-01|gpu-01|llama" ``` -### Métriques GPU AMD (gpu-01) +### Métriques GPU AMD (gpu-01) — ROCm via textfile_collector -Collecteur sysfs via `rocm_scraper.timer` (toutes les 30s). -Lit directement `/sys/class/drm/card0/device/` — pas de dépendance `rocm-smi`. +Collecteur sysfs `rocm_scraper.timer` (toutes les 30s) écrit dans `/var/lib/node_exporter/textfile_collector/rocm.prom`. +Servi par node_exporter sur port 9100 — **pas de port séparé**. +Lit `/sys/class/drm/card0/device/` directement (rocm-smi retiré dans ROCm 7.x). ```bash # Vérifier les métriques ROCm -ssh ansible@192.168.10.20 "cat /var/lib/node_exporter/textfile_collector/rocm.prom" +ssh gpu-01 "cat /var/lib/node_exporter/textfile_collector/rocm.prom" # Forcer une collecte manuelle -ssh ansible@192.168.10.20 "sudo systemctl start rocm_scraper" +ssh gpu-01 "sudo systemctl start rocm_scraper" + +# Vérifier le timer +ssh gpu-01 "systemctl status rocm_scraper.timer" ``` -Métriques disponibles : -| Métrique | Description | -|---|---| -| `rocm_gpu_temperature_celsius` | Température (°C) | -| `rocm_gpu_utilization_percent` | Utilisation GPU (%) | -| `rocm_vram_used_bytes` | VRAM utilisée (bytes) | -| `rocm_vram_total_bytes` | VRAM totale (bytes) | +Métriques disponibles (labels : `gpu="0"`, `model="gfx1031"`) : + +| Métrique | Description | Valeur typique | +|---|---|---| +| `rocm_gpu_temperature_celsius` | Température (°C) | 40–85 | +| `rocm_gpu_utilization_percent` | Utilisation GPU (%) | 0–100 | +| `rocm_vram_used_bytes` | VRAM utilisée | ~10 GB (modèle chargé) | +| `rocm_vram_total_bytes` | VRAM totale | 12.9 GB (RX 6700XT) | ### llama-server /metrics -llama.cpp expose des métriques Prometheus nativement sur `/metrics` : -- `llamacpp:kv_cache_usage_ratio` — utilisation du contexte -- `llamacpp:requests_processing` — requêtes en cours -- `llamacpp:tokens_per_second` — débit +llama.cpp expose ses métriques sur `/metrics` — activé via `--metrics` dans le service systemd. + +| Métrique | Description | +|---|---| +| `llamacpp:prompt_tokens_seconds` | Débit prompt moyen (tokens/s) | +| `llamacpp:predicted_tokens_seconds` | Débit génération moyen (tokens/s) | +| `llamacpp:prompt_tokens_total` | Tokens prompt totaux (compteur) | +| `llamacpp:tokens_predicted_total` | Tokens générés totaux (compteur) | +| `llamacpp:requests_processing` | Requêtes en cours de traitement | +| `llamacpp:requests_deferred` | Requêtes en file d'attente | +| `llamacpp:n_decode_total` | Nombre total d'appels llama_decode() | ```bash +# Métriques GPU (Qwen3-8B) curl -s http://192.168.10.20:1234/metrics | grep llamacpp + +# Métriques CPU system +curl -s http://192.168.10.20:1236/metrics | grep llamacpp + +# Métriques CPU monitor +curl -s http://192.168.10.20:1237/metrics | grep llamacpp ``` --- @@ -105,23 +233,41 @@ curl -s http://192.168.10.20:1234/metrics | grep llamacpp ## AlertManager → Hermes monitor AlertManager envoie les alertes en POST vers `http://192.168.10.1:9093/webhook`. -Le service `alertmanager-webhook` (Python, storage-01) reçoit les alertes et appelle : - -```bash -ask-agent monitor "Alertes Prometheus : — analyse et recommandations" -``` - +Le service `alertmanager-webhook` (Python, storage-01) reçoit les alertes et appelle `ask-agent monitor`. Hermes (profil `monitor`) analyse et répond dans ses logs. ```bash # Vérifier le webhook -systemctl status alertmanager-webhook -journalctl -u alertmanager-webhook -n 20 --no-pager --output=cat +ssh storage-01 "systemctl status alertmanager-webhook" +ssh storage-01 "journalctl -u alertmanager-webhook -n 20 --no-pager --output=cat" # Tester manuellement curl -s -X POST http://192.168.10.1:9093/webhook \ -H "Content-Type: application/json" \ -d '{"alerts":[{"status":"firing","labels":{"alertname":"TestAlert","severity":"warning","instance":"storage-01"},"annotations":{"summary":"Test alerte","description":"Vérification du webhook"}}]}' + +# Voir les alertes actives dans AlertManager +curl -s http://alertmanager.lab.local/api/v2/alerts | python3 -m json.tool +``` + +--- + +## Persistance des données + +Prometheus et Grafana stockent leurs données sur le RAID5 de storage-01 via NFS. +Provisioner : `nfs-subdir-external-provisioner`, StorageClass `nfs`. + +| Service | PVC | Taille | Rétention | +|---|---|---|---| +| Prometheus | `prometheus-...-db-prometheus-...-0` | 20 Gi | 15 jours / 8 GB | +| Grafana | `kube-prometheus-stack-grafana` | 2 Gi | — | + +```bash +# Espace consommé sur le RAID5 +ssh storage-01 "du -sh /srv/data/nfs/k8s/*" + +# État des PVCs +kubectl get pvc -n monitoring ``` --- @@ -130,38 +276,31 @@ curl -s -X POST http://192.168.10.1:9093/webhook \ ### Changer le mot de passe admin +Via API : ```bash -# Via l'API curl -X PUT http://admin:funk-grafana@grafana.lab.local/api/user/password \ -H "Content-Type: application/json" \ -d '{"oldPassword":"funk-grafana","newPassword":"","confirmNew":""}' ``` -Ou mettre à jour `k8s/infra/monitoring/values.yaml` → `grafana.adminPassword` → `git push`. +Ou modifier `k8s/infra/monitoring/values.yaml` → `grafana.adminPassword` → `git push`. -### Importer un dashboard +### Datasources -```bash -# Via l'API (ID depuis grafana.com/dashboards) -curl -X POST http://admin:funk-grafana@grafana.lab.local/api/dashboards/import \ - -H "Content-Type: application/json" \ - -d '{"dashboard":{"id":null},"overwrite":true,"inputs":[{"name":"DS_PROMETHEUS","type":"datasource","pluginId":"prometheus","value":"prometheus"}],"folderId":0}' -``` - -Dashboards recommandés : -| Dashboard | ID Grafana.com | Usage | -|---|---|---| -| Node Exporter Full | 1860 | CPU, RAM, disque, réseau par nœud | -| Kubernetes cluster | 7249 | Vue d'ensemble k8s | -| kube-prometheus-stack | 15761 | Santé du monitoring lui-même | - -### Datasources configurées automatiquement - -| Nom | Type | URL | +| Nom | Type | URL (interne cluster) | |---|---|---| | Prometheus | prometheus | `http://kube-prometheus-stack-prometheus:9090` | | Alertmanager | alertmanager | `http://kube-prometheus-stack-alertmanager:9093` | +Configurées automatiquement au démarrage — ne pas modifier depuis l'UI (écrasé à chaque redémarrage). + +### Lister les dashboards disponibles + +```bash +curl -s http://admin:funk-grafana@grafana.lab.local/api/search?type=dash-db \ + | python3 -c "import sys,json; [print(d['title'],'—',d['uid']) for d in json.load(sys.stdin)]" +``` + --- ## Administration Prometheus @@ -169,19 +308,48 @@ Dashboards recommandés : ### Vérifier les targets de scrape ```bash -# Via port-forward -kubectl port-forward svc/kube-prometheus-stack-prometheus -n monitoring 9090:9090 & -curl -s http://localhost:9090/api/v1/targets | python3 -m json.tool | grep -E '"health"|"job"' | head -30 +# Depuis l'UI +open http://prometheus.lab.local/targets + +# Via API +curl -s http://prometheus.lab.local/api/v1/targets | python3 -c " +import sys, json +d = json.load(sys.stdin) +for t in d['data']['activeTargets']: + print(t['health'], t['labels'].get('job','?'), t.get('lastError','')[:60]) +" | sort ``` ### Ajouter un scrape config Modifier `k8s/infra/monitoring/values.yaml` → section `additionalScrapeConfigs` → `git push`. -### Règles d'alerte +```yaml +prometheus: + prometheusSpec: + additionalScrapeConfigs: + - job_name: mon-service + static_configs: + - targets: ['192.168.10.x:9xxx'] + labels: + instance: mon-instance +``` -Les règles par défaut couvrent : OOMKill, NodeNotReady, PodCrashLooping, DiskPressure, etc. -Pour ajouter des règles custom, créer un `PrometheusRule` dans `k8s/infra/monitoring/`. +### Vérifier les règles d'alerte + +```bash +# Depuis l'UI +open http://prometheus.lab.local/alerts + +# Via API — alertes actuellement firing +curl -s http://prometheus.lab.local/api/v1/alerts | python3 -c " +import sys, json +d = json.load(sys.stdin) +for a in d['data']['alerts']: + if a['state'] == 'firing': + print(a['labels']['alertname'], a['labels'].get('instance',''), a['state']) +" +``` --- @@ -200,29 +368,35 @@ kubectl logs -n monitoring -l app.kubernetes.io/name=grafana --tail=50 # Logs AlertManager kubectl logs -n monitoring alertmanager-kube-prometheus-stack-alertmanager-0 --tail=50 -# Redémarrer Grafana +# Redémarrer Grafana (recharge les ConfigMaps dashboards) kubectl rollout restart deployment kube-prometheus-stack-grafana -n monitoring -# Forcer re-sync ArgoCD -kubectl -n argocd annotate application kube-prometheus-stack \ - argocd.argoproj.io/refresh=hard --overwrite +# Forcer re-sync ArgoCD (dashboards, alertes, config) +kubectl -n argocd annotate application monitoring argocd.argoproj.io/refresh=hard --overwrite +kubectl -n argocd annotate application kube-prometheus-stack argocd.argoproj.io/refresh=hard --overwrite ``` --- -## Persistance des données +## Structure des fichiers -Les données sont persistées sur le RAID5 de storage-01 via NFS (provisioner `nfs-subdir-external-provisioner`). - -| PVC | Taille | Emplacement NFS | -|---|---|---| -| Prometheus | 20 Gi | `/srv/data/nfs/k8s/monitoring-prometheus-...-db-...` | -| Grafana | 2 Gi | `/srv/data/nfs/k8s/monitoring-kube-prometheus-stack-grafana-...` | - -```bash -# Vérifier l'espace consommé -ssh storage-01 "du -sh /srv/data/nfs/k8s/*" ``` +k8s/infra/monitoring/ +├── helmrelease.yaml # Application ArgoCD (multi-source Helm kube-prometheus-stack) +├── namespace.yaml # Namespace monitoring (labels PodSecurity privileged) +├── values.yaml # Valeurs Helm : ressources, ingress, scrape configs, alertmanager +├── dashboards/ +│ ├── dashboard-kubernetes.yaml # ConfigMap — Funk Kubernetes (uid: funk-k8s1) +│ ├── dashboard-infrastructure.yaml # ConfigMap — Funk Infrastructure (uid: funk-inf1) +│ └── dashboard-ai.yaml # ConfigMap — Funk IA/Hermes (uid: funk-ai01) +└── alerts/ + ├── alerts-node.yaml # PrometheusRule — CPU, RAM, disque, nodes hors cluster + ├── alerts-k8s.yaml # PrometheusRule — k8s : pods, nodes, PVCs, ArgoCD + └── alerts-ai.yaml # PrometheusRule — llama-server, GPU temp, VRAM +``` + +> ArgoCD Application `monitoring` utilise `directory.recurse: true` pour scanner +> récursivement le répertoire et ses sous-dossiers. --- @@ -230,11 +404,13 @@ ssh storage-01 "du -sh /srv/data/nfs/k8s/*" | Sujet | Détail | |---|---| -| Persistance Prometheus | **Active** — 20 Gi NFS sur RAID5 storage-01. Rétention : 15 jours / 8 GB | -| Persistance Grafana | **Active** — 2 Gi NFS sur RAID5 storage-01. Dashboards conservés | -| RAM compute nodes | Prometheus + Grafana : ~1 GB total. Limites définies dans values.yaml | -| Talos — composants désactivés | `kubeEtcd`, `kubeScheduler`, `kubeControllerManager`, `kubeProxy` désactivés (non accessibles depuis Talos) | -| DNS lab.local | Résout uniquement depuis LAN (192.168.10.0/24) — ajouter `/etc/hosts` sur le poste perso pour grafana/argocd | -| ROCm scraper | Lit sysfs directement (`/sys/class/drm/`), pas de `rocm-smi` (retiré dans ROCm 7.x) | -| Webhook port 9093 | Ouvert uniquement depuis 192.168.10.0/24 (nftables storage-01) | -| nfs-provisioner OutOfSync | La StorageClass peut disparaître si ArgoCD prune l'app. Forcer sync : `argocd app sync nfs-provisioner` | +| Persistance | **Active** — Prometheus 20 Gi + Grafana 2 Gi sur RAID5 NFS storage-01 | +| Dashboards GitOps | ConfigMaps dans `dashboards/` → importés automatiquement par le sidecar Grafana | +| Alertes GitOps | PrometheusRules dans `alerts/` → label `release: kube-prometheus-stack` obligatoire | +| Receiver `null` | Doit exister dans la config AlertManager — requis par les sous-routes internes du chart (Watchdog) | +| nftables storage-01 | Port 9100 doit être avant la règle `drop` dans la chaîne `input` (sinon context deadline) | +| ROCm port | Métriques GPU via textfile_collector sur port **9100** — pas de port séparé 9101 | +| llama-server `--metrics` | Flag requis dans le service systemd pour activer l'endpoint `/metrics` | +| Talos — composants désactivés | `kubeEtcd`, `kubeScheduler`, `kubeControllerManager`, `kubeProxy` désactivés (non accessibles) | +| PodSecurity privileged | Namespace `monitoring` doit être `privileged` pour node-exporter (hostNetwork/hostPID/hostPath) | +| nfs-provisioner | StorageClass peut disparaître si ArgoCD prune l'app — forcer sync si PVC Pending | diff --git a/admin/reseau.md b/admin/reseau.md index 258d5b3..659974e 100644 --- a/admin/reseau.md +++ b/admin/reseau.md @@ -66,8 +66,15 @@ ansible-playbook -i inventory.yml playbooks/storage-01.yml --tags gateway | 6333, 6334 | TCP | 192.168.10.0/24 | Qdrant | | 8080 | TCP | 192.168.1.0/24, 192.168.10.0/24 | Hermes gateway | | 9000, 9001 | TCP | 192.168.10.0/24 | MinIO | +| 9093 | TCP | 192.168.10.0/24 | AlertManager webhook (réception alertes Prometheus) | +| 9100 | TCP | 192.168.10.0/24 | node_exporter (métriques Prometheus — inclut ROCm via textfile_collector) | | 9119 | TCP | 192.168.1.10 uniquement | Hermes dashboard | +> **Règle nftables importante** : les règles doivent être insérées **avant** la règle `drop` terminale. +> Utiliser `nft insert rule inet filter input position ` et non `nft add rule` +> (qui ajoute en fin de chaîne, après le drop). +> Vérifier l'ordre : `sudo nft -n -a list chain inet filter input` + ### Forwarding ```