Santé & Supervision¶

Surveillez l'état opérationnel de Repod, intégrez-le à votre pile d'alerting, et interprétez les endpoints de santé.

Endpoints de santé¶

Trois endpoints sont disponibles pour différents scénarios de supervision :

Endpoint	Auth	Cas d'usage
`GET /health/live`	Public	Sonde de vivacité du conteneur — le processus tourne-t-il ?
`GET /health/ready`	Public	Sonde de disponibilité — toutes les dépendances sont-elles prêtes ?
`GET /health`	Jeton Bearer	Rapport de statut complet — détail au niveau composant

Sonde de vivacité¶

curl http://localhost:8000/health/live

{"status": "ok"}

Renvoie 200 tant que le processus uvicorn est vivant. À utiliser pour le HEALTHCHECK Docker et le livenessProbe Kubernetes.

Sonde de disponibilité¶

curl http://localhost:8000/health/ready

{"status": "ok", "ready": true}

Renvoie 200 quand la base de données et les services critiques sont prêts. Renvoie 503 pendant le démarrage ou quand une dépendance critique est indisponible. À utiliser pour le readinessProbe Kubernetes et les vérifications de santé du load balancer.

Rapport de santé complet¶

TOKEN=$(curl -s -X POST http://localhost:8000/api/v1/auth/token \
  -H "Content-Type: application/json" \
  -d '{"username":"admin","password":"Admin1234!"}' | jq -r .access_token)

curl -s -H "Authorization: Bearer $TOKEN" http://localhost:8000/health | jq .

{
  "status": "ok",
  "version": "v1.2.0",
  "uptime_seconds": 86432,
  "components": {
    "database": {"ok": true},
    "clamav": {"ok": true, "version": "ClamAV 1.4.3/27509"},
    "grype": {"ok": true, "db_age_hours": 4.2},
    "gpg": {"ok": true, "key_count": 1}
  }
}

Configuration du health check Docker¶

Le docker-compose.yaml inclut un health check intégré pour le backend :

docker-compose.yaml (extrait)

  backend-api:
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health/live"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 120s   # laisse le temps au chargement des signatures ClamAV

Vérifier le statut de santé :

docker compose ps
# Rechercher (healthy) ou (unhealthy) à côté de backend-api

Métriques Prometheus¶

Repod expose des métriques Prometheus depuis le backend via la bibliothèque prometheus-client. Les métriques sont disponibles sur :

GET http://localhost:8000/metrics

Métriques clés :

Métrique	Type	Description
`repod_packages_total`	Gauge	Nombre total de paquets dans le pool
`repod_uploads_total`	Counter	Tentatives d'upload (labels : `status`)
`repod_cve_findings_total`	Counter	Détections CVE (labels : `severity`)
`repod_pending_review_total`	Gauge	Paquets en attente de décision RSSI
`repod_quarantine_total`	Gauge	Paquets en quarantaine
`repod_clamav_last_update`	Gauge	Timestamp Unix de la dernière mise à jour de la base ClamAV
`repod_grype_db_age_seconds`	Gauge	Âge de la base de vulnérabilités Grype
`http_requests_total`	Counter	Requêtes HTTP (labels : `method`, `path`, `status`)
`http_request_duration_seconds`	Histogram	Latence des requêtes

Configuration du scraping Prometheus¶

prometheus.yml

scrape_configs:
  - job_name: repod
    static_configs:
      - targets: ["repod-backend:8000"]
    metrics_path: /metrics
    scrape_interval: 30s
    # Ajouter bearer_token si /metrics est protégé en production

Dashboard Grafana¶

Importez le dashboard communautaire d'ID XXXXX (rechercher « Repod » sur grafana.com) ou construisez le vôtre à partir des métriques ci-dessus.

Panels recommandés :

Taux de succès des uploads (dernière heure)
Détections CVE par sévérité (7 derniers jours)
Profondeur de la file de revue en attente (série temporelle)
Âge de la base ClamAV (alerte si > 48 h)
Âge de la base Grype (alerte si > 24 h)
Latence des requêtes HTTP (p50 / p95 / p99)

Supervision des logs¶

Consulter les logs en temps réel¶

# Tous les conteneurs
docker compose logs -f

# Backend uniquement (200 dernières lignes)
docker compose logs backend-api --tail=200

# Filtrer les erreurs
docker compose logs backend-api 2>&1 | grep -iE "error|exception|traceback"

# Filtrer les événements de sécurité
docker compose logs backend-api 2>&1 | grep -E "UPLOAD|SECURITY|CVE"

Journal d'audit structuré¶

Le journal d'audit dans /repos/audit/YYYY-MM-DD.jsonl est l'enregistrement faisant foi de tous les événements pertinents pour la sécurité. Interrogez-le avec les outils UNIX standard :

# Journal d'audit du jour — mis en forme
docker exec backend-api tail -n 50 \
  /repos/audit/$(date +%Y-%m-%d).jsonl | python3 -m json.tool

# Tous les échecs de connexion du jour
docker exec backend-api grep '"action":"LOGIN"' \
  /repos/audit/$(date +%Y-%m-%d).jsonl | grep '"result":"FAILURE"'

# Toutes les décisions CVE des 7 derniers jours
for d in $(seq 0 6); do
  date --date="-$d days" +%Y-%m-%d
done | while read day; do
  f="/repos/audit/$day.jsonl"
  [ -f "$f" ] && grep '"action":"SECURITY_DECISION"' "$f"
done

Envoyer les logs vers un SIEM¶

Le format JSONL est directement ingérable par la plupart des plateformes SIEM :

Elastic / LogstashSplunkLoki / Grafana

logstash.conf

input {
  file {
    path  => "/opt/repod/repos/audit/*.jsonl"
    codec => "json"
    start_position => "beginning"
  }
}

filter {
  date {
    match => ["timestamp", "ISO8601"]
    target => "@timestamp"
  }
}

output {
  elasticsearch {
    hosts => ["http://elasticsearch:9200"]
    index => "repod-audit-%{+YYYY.MM.dd}"
  }
}

Configurez une entrée de surveillance sur un Universal Forwarder :

inputs.conf

[monitor:///opt/repod/repos/audit/*.jsonl]
disabled  = false
sourcetype = repod_audit
index     = security

promtail-config.yml

scrape_configs:
  - job_name: repod-audit
    static_configs:
      - targets: [localhost]
        labels:
          job: repod
          __path__: /opt/repod/repos/audit/*.jsonl
    pipeline_stages:
      - json:
          expressions:
            action: action
            result: result
            user: user
      - labels:
          action:
          result:

Recommandations d'alerting¶

Alertes critiques (astreinte immédiate)¶

Condition	Requête / vérification
Conteneur backend en mauvaise santé	`docker inspect backend-api --format='{{.State.Health.Status}}'` ≠ `healthy`
ClamAV inaccessible	`components.clamav.ok == false` dans `/health`
Base CVE obsolète > 48 h	`repod_grype_db_age_seconds > 172800`
File de revue en attente en croissance	`repod_pending_review_total > 10` (à ajuster selon l'organisation)
Pic d'échecs de connexion	> 20 événements d'audit `FAILURE` en 5 min

Alertes d'avertissement (notification à l'équipe)¶

Condition	Requête / vérification
Base ClamAV non mise à jour depuis 24 h	Âge de `repod_clamav_last_update` > 86400 s
Espace disque faible	`df -h /opt/repod/repos` < 10 Go libres
Taux d'erreur d'upload > 5 %	`repod_uploads_total{status!="published"}` / total

Supervision des événements de sécurité¶

Surveillez ces types d'événements d'audit pour les opérations de sécurité :

Événement	Signal de sécurité
`LOGIN` avec `result=FAILURE`	Tentative de force brute ou de bourrage d'identifiants
`USER_CREATE`	Nouveau compte provisionné — vérifier l'intention
`USER_ROLE_CHANGE`	Élévation de privilèges — vérifier l'intention
`SECURITY_DECISION` avec `approve`	Exception CVE approuvée — vérifier la justification
`UPLOAD` avec `status=quarantined`	Malware ou CVE critique détecté
`SETTINGS_CHANGE`	Changement de configuration — vérifier l'intention

Vérifier manuellement le statut des composants¶

# ClamAV — version et date des signatures
docker exec backend-api clamdscan --version

# Grype — âge de la base
docker exec backend-api grype db status

# GPG — lister les clés du trousseau
docker exec backend-api gpg --homedir /repos/gnupg --list-keys

# PostgreSQL — connexion et vérification de cohérence des tables
docker exec repod-db psql -U repod -d repod -c \
  "SELECT count(*) AS users FROM users;
   SELECT count(*) AS packages FROM package_index;"

Utilisation des ressources¶

Surveiller l'utilisation des ressources Docker avec :

docker stats backend-api frontend-ui depot-apt

Limites de ressources par défaut dans docker-compose.yaml :

Conteneur	Limite CPU	Limite mémoire
`backend-api`	1,5 CPU	2,5 Go
`frontend-ui`	0,5 CPU	256 Mo
`depot-apt` / `depot-rpm`	0,5 CPU	128 Mo

Augmentez les limites si les scans ClamAV ou Grype saturent le CPU :

docker-compose.yaml

  backend-api:
    deploy:
      resources:
        limits:
          cpus: "3.0"
          memory: 4g

Gestion de l'espace disque¶

# Espace total utilisé par le volume repos
du -sh /opt/repod/repos/

# Répartition par sous-répertoire
du -sh /opt/repod/repos/* | sort -rh

# Plus gros paquets du pool
du -sh /opt/repod/repos/pool/* 2>/dev/null | sort -rh | head -20

# Contenu de la quarantaine (à examiner avant suppression)
ls -lh /opt/repod/repos/staging/quarantine/

# Taille de la base ClamAV
du -sh /opt/repod/repos/clamav-db/

# Taille de la base Grype
du -sh /opt/repod/repos/grype-db/

Configurez le nettoyage automatique de rétention dans Paramètres → Rétention dans l'interface web (défaut : 90 jours pour les journaux d'audit, pas de nettoyage automatique des paquets).