docs: mise à jour documentation monitoring + llama-server + réseau

- 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 <noreply@anthropic.com>
2026-07-08 15:14:43 +02:00 · 2026-05-13 23:10:56 +02:00 · 2026-05-13 23:10:56 +02:00 · 7db7aa2e9d
commit 7db7aa2e9d
parent 630bdee1a2
3 changed files with 358 additions and 123 deletions
--- 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 |
--- 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 : <données> — 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":"<nouveau>","confirmNew":"<nouveau>"}'
 ```

-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 |
--- 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 <handle_avant_drop>` 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

 ```