akadmin/Funk-lab
1
0
Fork 0
mirror of https://github.com/Alkatrazz24/Funk-lab.git synced 2026-07-12 16:34:43 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

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

Browse source 
- 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>
This commit is contained in:
alkatrazz 2026-05-13 23:10:56 +02:00
parent 630bdee1a2
commit 7db7aa2e9d
3 changed files with 358 additions and 123 deletions
Download patch file Download diff file Expand all files Collapse all files

106
admin/llama_server.md
View file

@ -1,30 +1,52 @@
# llama-server — Inférence LLM (gpu-01) # 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. 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 ## Service systemd
```bash ```bash
# Depuis gpu-01 # Instance GPU (principale)
sudo systemctl status llama-server sudo systemctl status llama-server
sudo systemctl restart llama-server sudo systemctl restart llama-server
sudo journalctl -u llama-server -f 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 | | Paramètre | Valeur |
|---|---| |---|---|
| Modèle | Qwen2.5-14B-Instruct Q4_K_M | | Modèle | Qwen3-8B Q4_K_M |
| Alias API | `qwen2.5-14b-instruct` | | Alias API | `qwen3-8b` |
| Chemin | `/mnt/models/bartowski/Qwen2.5-14B-Instruct-GGUF/Qwen2.5-14B-Instruct-Q4_K_M.gguf` | | Chemin | `/mnt/models/bartowski/Qwen3-8B-GGUF/Qwen3-8B-Q4_K_M.gguf` |
| Contexte | 16384 tokens (limité par VRAM — voir ci-dessous) | | Contexte | 32768 tokens |
| GPU offload | 99 layers (tout sur GPU) | | GPU offload | 99 layers (tout sur GPU) |
| Parallélisme | 1 slot (requis pour Hermes — voir bug parallel) | | Parallélisme | 1 slot (requis pour Hermes — voir bug parallel) |
| Embeddings | activés (`--embeddings --pooling mean`) | | Embeddings | activés (`--embeddings --pooling mean`) |
@ -33,12 +55,9 @@ sudo journalctl -u llama-server -n 50
| Élément | VRAM | | Élément | VRAM |
|---|---| |---|---|
| Modèle Q4_K_M 14B | ~8 GB | | Modèle Q4_K_M 8B | ~5 GB |
| KV cache à 16384 ctx | ~3 GB | | KV cache à 32768 ctx | ~4 GB |
| **Total** | **~11 GB** ✅ | | **Total** | **~9 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.**
--- ---
@ -52,20 +71,20 @@ Le flag `--pooling mean` est obligatoire pour les LLM causaux (sinon : erreur 40
# Test embeddings depuis storage-01 # Test embeddings depuis storage-01
curl -s -X POST http://192.168.10.20:1234/v1/embeddings \ curl -s -X POST http://192.168.10.20:1234/v1/embeddings \
-H "Content-Type: application/json" \ -H "Content-Type: application/json" \
-d '{"model":"qwen2.5-14b-instruct","input":["test"]}' | jq '.data[0].embedding | length' -d '{"model":"qwen3-8b","input":["test"]}' | jq '.data[0].embedding | length'
# → 5120 (dimension Qwen2.5-14B) # → 3584 (dimension Qwen3-8B)
``` ```
--- ---
## Performances (RX 6700XT, ROCm 7.x) ## 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 | | Prefill | ~50 tok/s | ~300 tok/s |
| Génération | ~70 tok/s | ~35 tok/s | | Génération | ~15 tok/s | ~60 tok/s |
| TTFT Hermes (15k tokens) | ~35s | ~75s | | TTFT Hermes (15k tokens) | ~300s | ~50s |
| VRAM modèle | ~4 GB | ~8 GB | | 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 # Depuis storage-01 ou n'importe quelle machine du LAN cluster
curl -s http://192.168.10.20:1234/v1/models | jq '.data[].id' 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 \ curl http://192.168.10.20:1234/v1/chat/completions \
-H "Content-Type: application/json" \ -H "Content-Type: application/json" \
-d '{ -d '{
"model": "qwen2.5-14b-instruct", "model": "qwen3-8b",
"messages": [{"role": "user", "content": "Dis bonjour"}], "messages": [{"role": "user", "content": "Dis bonjour"}],
"max_tokens": 50 "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 ## Changer de modèle
1. Modifier `host_vars/gpu-01/vars.yml` : 1. Modifier `host_vars/gpu-01/vars.yml` :
```yaml ```yaml
llama_model_path: "/mnt/models/bartowski/NouveauModele.gguf" llama_model_path: "/mnt/models/bartowski/NouveauModele.gguf"
llama_model_alias: "nouveau-alias" llama_model_alias: "nouveau-alias"
llama_ctx_size: 16384 # ajuster selon VRAM disponible llama_ctx_size: 32768 # ajuster selon VRAM disponible
``` ```
2. Redéployer : 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 | | 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` | | 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 | | 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 | | 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 |

368
admin/monitoring.md
View file

@ -1,7 +1,8 @@
# Monitoring — Grafana + Prometheus + AlertManager # 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). 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 | | Service | URL | Login | Mot de passe |
|---|---|---|---| |---|---|---|---|
| **Grafana** | http://grafana.lab.local | `admin` | `funk-grafana` | | **Grafana** | http://grafana.lab.local | `admin` | `funk-grafana` |
| **AlertManager** | http://alertmanager.lab.local | — | — |
| **Prometheus** | http://prometheus.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). > DNS `*.lab.local` ne résout que depuis le LAN cluster (192.168.10.0/24).
> Depuis le poste perso (192.168.1.x), les entrées sont dans `/etc/hosts` : > 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 > 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) Prometheus (k8s, namespace monitoring)
├── kube-state-metrics → ressources k8s (pods, deployments, nodes) ├── kube-state-metrics → ressources k8s (pods, deployments, nodes)
├── node-exporter (daemonset) → métriques système compute-01/02/03 ├── node-exporter (DaemonSet) → métriques système compute-01/02/03
├── scrape storage-01:9100 → métriques système storage-01 ├── scrape storage-01:9100 → métriques système storage-01 (job=storage-01)
├── scrape gpu-01:9100 → métriques système gpu-01 ├── scrape gpu-01:9100 → métriques système + ROCm gpu-01 (job=gpu-01-node)
├── scrape gpu-01:9101 (ROCm) → température GPU, VRAM, utilisation │ └── textfile_collector → rocm_gpu_temperature/utilization/vram (rocm_scraper.timer)
└── scrape gpu-01:1234/1236/1237 → llama-server (tokens/s, slots, queue) ├── 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 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 | Dashboard | UID | Contenu |
# Ajouter le repo Helm |---|---|---|
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts | **Funk — Kubernetes** | `funk-k8s1` | Cluster overview, CPU/RAM par nœud, pod restarts, PVCs |
helm repo update | **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/ URLs directes :
# Forcer un refresh si nécessaire : - http://grafana.lab.local/d/funk-k8s1
kubectl -n argocd annotate application kube-prometheus-stack \ - http://grafana.lab.local/d/funk-inf1
argocd.argoproj.io/refresh=hard --overwrite - 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) ### Nœuds hors cluster (storage-01, gpu-01)
`node_exporter` v1.9.1 déployé via Ansible (rôle `node_exporter`). `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 ```bash
# Vérifier node_exporter # État node_exporter
systemctl status 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.1:9100/metrics | grep node_memory_MemAvailable
curl -s http://192.168.10.20: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). Collecteur sysfs `rocm_scraper.timer` (toutes les 30s) écrit dans `/var/lib/node_exporter/textfile_collector/rocm.prom`.
Lit directement `/sys/class/drm/card0/device/` — pas de dépendance `rocm-smi`. 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 ```bash
# Vérifier les métriques ROCm # 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 # 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étriques disponibles (labels : `gpu="0"`, `model="gfx1031"`) :
| Métrique | Description |
|---|---| | Métrique | Description | Valeur typique |
| `rocm_gpu_temperature_celsius` | Température (°C) | |---|---|---|
| `rocm_gpu_utilization_percent` | Utilisation GPU (%) | | `rocm_gpu_temperature_celsius` | Température (°C) | 40–85 |
| `rocm_vram_used_bytes` | VRAM utilisée (bytes) | | `rocm_gpu_utilization_percent` | Utilisation GPU (%) | 0–100 |
| `rocm_vram_total_bytes` | VRAM totale (bytes) | | `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-server /metrics
llama.cpp expose des métriques Prometheus nativement sur `/metrics` : llama.cpp expose ses métriques sur `/metrics` — activé via `--metrics` dans le service systemd.
- `llamacpp:kv_cache_usage_ratio` — utilisation du contexte
- `llamacpp:requests_processing` — requêtes en cours | Métrique | Description |
- `llamacpp:tokens_per_second` — débit |---|---|
| `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 ```bash
# Métriques GPU (Qwen3-8B)
curl -s http://192.168.10.20:1234/metrics | grep llamacpp 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 → Hermes monitor
AlertManager envoie les alertes en POST vers `http://192.168.10.1:9093/webhook`. 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 : Le service `alertmanager-webhook` (Python, storage-01) reçoit les alertes et appelle `ask-agent monitor`.
```bash
ask-agent monitor "Alertes Prometheus : <données> — analyse et recommandations"
```
Hermes (profil `monitor`) analyse et répond dans ses logs. Hermes (profil `monitor`) analyse et répond dans ses logs.
```bash ```bash
# Vérifier le webhook # Vérifier le webhook
systemctl status alertmanager-webhook ssh storage-01 "systemctl status alertmanager-webhook"
journalctl -u alertmanager-webhook -n 20 --no-pager --output=cat ssh storage-01 "journalctl -u alertmanager-webhook -n 20 --no-pager --output=cat"
# Tester manuellement # Tester manuellement
curl -s -X POST http://192.168.10.1:9093/webhook \ curl -s -X POST http://192.168.10.1:9093/webhook \
-H "Content-Type: application/json" \ -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"}}]}' -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 ### Changer le mot de passe admin
Via API :
```bash ```bash
# Via l'API
curl -X PUT http://admin:funk-grafana@grafana.lab.local/api/user/password \ curl -X PUT http://admin:funk-grafana@grafana.lab.local/api/user/password \
-H "Content-Type: application/json" \ -H "Content-Type: application/json" \
-d '{"oldPassword":"funk-grafana","newPassword":"<nouveau>","confirmNew":"<nouveau>"}' -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 | Nom | Type | URL (interne cluster) |
# 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 |
|---|---|---| |---|---|---|
| Prometheus | prometheus | `http://kube-prometheus-stack-prometheus:9090` | | Prometheus | prometheus | `http://kube-prometheus-stack-prometheus:9090` |
| Alertmanager | alertmanager | `http://kube-prometheus-stack-alertmanager:9093` | | 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 ## Administration Prometheus
@ -169,19 +308,48 @@ Dashboards recommandés :
### Vérifier les targets de scrape ### Vérifier les targets de scrape
```bash ```bash
# Via port-forward # Depuis l'UI
kubectl port-forward svc/kube-prometheus-stack-prometheus -n monitoring 9090:9090 & open http://prometheus.lab.local/targets
curl -s http://localhost:9090/api/v1/targets | python3 -m json.tool | grep -E '"health"|"job"' | head -30
# 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 ### Ajouter un scrape config
Modifier `k8s/infra/monitoring/values.yaml` → section `additionalScrapeConfigs` → `git push`. 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. ### Vérifier les règles d'alerte
Pour ajouter des règles custom, créer un `PrometheusRule` dans `k8s/infra/monitoring/`.
```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 # Logs AlertManager
kubectl logs -n monitoring alertmanager-kube-prometheus-stack-alertmanager-0 --tail=50 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 kubectl rollout restart deployment kube-prometheus-stack-grafana -n monitoring
# Forcer re-sync ArgoCD # Forcer re-sync ArgoCD (dashboards, alertes, config)
kubectl -n argocd annotate application kube-prometheus-stack \ kubectl -n argocd annotate application monitoring argocd.argoproj.io/refresh=hard --overwrite
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 | | Sujet | Détail |
|---|---| |---|---|
| Persistance Prometheus | **Active** — 20 Gi NFS sur RAID5 storage-01. Rétention : 15 jours / 8 GB | | Persistance | **Active** — Prometheus 20 Gi + Grafana 2 Gi sur RAID5 NFS storage-01 |
| Persistance Grafana | **Active** — 2 Gi NFS sur RAID5 storage-01. Dashboards conservés | | Dashboards GitOps | ConfigMaps dans `dashboards/` → importés automatiquement par le sidecar Grafana |
| RAM compute nodes | Prometheus + Grafana : ~1 GB total. Limites définies dans values.yaml | | Alertes GitOps | PrometheusRules dans `alerts/` → label `release: kube-prometheus-stack` obligatoire |
| Talos — composants désactivés | `kubeEtcd`, `kubeScheduler`, `kubeControllerManager`, `kubeProxy` désactivés (non accessibles depuis Talos) | | Receiver `null` | Doit exister dans la config AlertManager — requis par les sous-routes internes du chart (Watchdog) |
| DNS lab.local | Résout uniquement depuis LAN (192.168.10.0/24) — ajouter `/etc/hosts` sur le poste perso pour grafana/argocd | | nftables storage-01 | Port 9100 doit être avant la règle `drop` dans la chaîne `input` (sinon context deadline) |
| ROCm scraper | Lit sysfs directement (`/sys/class/drm/`), pas de `rocm-smi` (retiré dans ROCm 7.x) | | ROCm port | Métriques GPU via textfile_collector sur port **9100** — pas de port séparé 9101 |
| Webhook port 9093 | Ouvert uniquement depuis 192.168.10.0/24 (nftables storage-01) | | llama-server `--metrics` | Flag requis dans le service systemd pour activer l'endpoint `/metrics` |
| nfs-provisioner OutOfSync | La StorageClass peut disparaître si ArgoCD prune l'app. Forcer sync : `argocd app sync nfs-provisioner` | | 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 |

7
admin/reseau.md
View file

@ -66,8 +66,15 @@ ansible-playbook -i inventory.yml playbooks/storage-01.yml --tags gateway
| 6333, 6334 | TCP | 192.168.10.0/24 | Qdrant | | 6333, 6334 | TCP | 192.168.10.0/24 | Qdrant |
| 8080 | TCP | 192.168.1.0/24, 192.168.10.0/24 | Hermes gateway | | 8080 | TCP | 192.168.1.0/24, 192.168.10.0/24 | Hermes gateway |
| 9000, 9001 | TCP | 192.168.10.0/24 | MinIO | | 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 | | 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 ### Forwarding
``` ```