serv_benchmark/docs/DEPLOYMENT_GUIDE.md

# Guide de Déploiement - Linux BenchTools

## Modifications Apportées

### 1. Backend API
- ✅ **Schémas Pydantic mis à jour** ([backend/app/schemas/hardware.py](backend/app/schemas/hardware.py))
  - `RAMInfo` : Ajout de `used_mb`, `free_mb`, `shared_mb`
  - `StorageDevice` : `capacity_gb` changé de `int` à `float`

- ✅ **API endpoint mis à jour** ([backend/app/api/benchmark.py](backend/app/api/benchmark.py))
  - Sauvegarde des nouveaux champs RAM

- ✅ **Modèles de base de données** ([backend/app/models/](backend/app/models/))
  - `HardwareSnapshot` : Nouveaux champs RAM
  - `DiskSMART` : Nouveau modèle pour données SMART (créé mais pas encore utilisé)

### 2. Docker
- ✅ **Service iperf3 ajouté** ([docker-compose.yml](docker-compose.yml))
  - Port 5201 TCP/UDP exposé

### 3. Script Client
- ✅ **Script bench.sh complètement réécrit** ([scripts/bench.sh](scripts/bench.sh))
  - Génère le payload JSON directement
  - Collecte toutes les données hardware
  - Exécute les benchmarks
  - Envoie au serveur API

## Déploiement

### Étape 1: Arrêter les Services

```bash
cd /home/gilles/Documents/vscode/serv_benchmark
docker-compose down
```

### Étape 2: Appliquer les Migrations Base de Données

Si la base de données existe déjà, appliquez les scripts dans l'ordre :

```bash
cd backend
python3 apply_migration.py
python3 apply_migration_002.py
python3 apply_migration_003.py
python3 apply_migration_004.py
python3 apply_migration_005.py
```

**OU** si vous préférez partir de zéro (⚠️ PERTE DE DONNÉES) :

```bash
rm -f backend/data/data.db
```

### Étape 3: Démarrer les Services

```bash
docker-compose up -d
```

Vérifier les logs :

```bash
docker-compose logs -f backend
docker-compose logs iperf3
```

### Étape 4: Tester le Serveur iperf3

Depuis un client :

```bash
iperf3 -c 10.0.0.50 -p 5201
```

Vous devriez voir le test de bande passante s'exécuter.

### Étape 5: Exécuter le Script Bench

Depuis un client Linux :

```bash
# Option 1: Télécharger et exécuter
curl -sSL https://gitea.maison43.duckdns.org/gilles/serv_benchmark/raw/branch/main/scripts/bench.sh | sudo bash

# Option 2: Exécuter localement
cd /chemin/vers/serv_benchmark
sudo bash scripts/bench.sh
```

**Note** : Le script `bench.sh` a les paramètres serveur codés en dur :
- `SERVER_URL="10.0.0.50:8007"`
- `API_TOKEN="29855796dacf5cfe75ff9b02d6adf3dd0f9c52db5b53e7abfb4c0df7ece1be0a"`
- `IPERF_SERVER="10.0.0.50"`

Pour les modifier, éditez le fichier ou passez-les en variables d'environnement.

## Vérification

### 1. Vérifier la Base de Données

```bash
sqlite3 backend/data/data.db

# Lister les tables
.tables

# Vérifier les colonnes de hardware_snapshots
PRAGMA table_info(hardware_snapshots);

# Voir les derniers benchmarks
SELECT id, device_id, global_score, run_at FROM benchmarks ORDER BY run_at DESC LIMIT 5;

# Voir les données RAM détaillées
SELECT
    d.hostname,
    h.ram_total_mb,
    h.ram_used_mb,
    h.ram_free_mb,
    h.ram_shared_mb
FROM hardware_snapshots h
JOIN devices d ON h.device_id = d.id
ORDER BY h.captured_at DESC
LIMIT 5;
```

### 2. Vérifier l'API

```bash
# Tester l'endpoint
curl http://10.0.0.50:8007/docs

# Voir les devices
curl http://10.0.0.50:8007/api/devices
```

### 3. Consulter le Frontend

Ouvrir dans un navigateur :
```
http://10.0.0.50:8087
```

## Troubleshooting

### Erreur: HTTP 422 "Input should be a valid integer"

**Solution** : Cette erreur a été corrigée en changeant `capacity_gb` de `int` à `float` dans le schéma.

Si vous rencontrez encore cette erreur :
1. Vérifiez que le backend a bien été redémarré après les modifications
2. Vérifiez les logs : `docker-compose logs backend`

### Port 5201 déjà utilisé

```bash
# Trouver le processus
sudo lsof -i :5201

# Arrêter le service Docker iperf3
docker-compose stop iperf3
```

### Script bench.sh ne trouve pas les dépendances

```bash
# Installer manuellement
sudo apt-get update
sudo apt-get install -y curl jq sysbench fio iperf3 dmidecode smartmontools ethtool
```

### Base de données verrouillée (SQLite locked)

```bash
# Arrêter tous les services
docker-compose down

# Supprimer les locks
rm -f backend/data/data.db-shm backend/data/data.db-wal

# Redémarrer
docker-compose up -d
```

## Structure des Données Envoyées

Le script `bench.sh` envoie un payload JSON avec cette structure :

```json
{
  "device_identifier": "hostname",
  "bench_script_version": "1.1.0",
  "hardware": {
    "cpu": {
      "vendor": "GenuineIntel",
      "model": "Intel(R) Core(TM) i5-2400 CPU @ 3.10GHz",
      "cores": 4,
      "threads": 4,
      ...
    },
    "ram": {
      "total_mb": 7771,
      "used_mb": 6123,    // NOUVEAU
      "free_mb": 923,     // NOUVEAU
      "shared_mb": 760,   // NOUVEAU
      "slots_total": 4,
      "slots_used": 4,
      "ecc": false,
      "layout": [...]
    },
    "storage": {
      "devices": [
        {
          "name": "/dev/sda",
          "type": "SSD",
          "capacity_gb": 447.1,  // FLOAT maintenant
          ...
        }
      ],
      "partitions": []
    },
    "network": {
      "interfaces": [...]
    },
    "motherboard": {...},
    "os": {...}
  },
  "results": {
    "cpu": {
      "events_per_sec": 1206.65,
      "duration_s": 10.0,
      "score": 12.06
    },
    "memory": {...},
    "disk": {...},
    "network": {...},
    "gpu": null,
    "global_score": 10.85
  }
}
```

## Prochaines Étapes

### À Implémenter

1. **Données SMART des disques**
   - Le modèle `DiskSMART` existe mais n'est pas encore utilisé
   - Modifier `bench.sh` pour collecter les données SMART
   - Adapter l'API pour sauvegarder dans `disk_smart_data`

2. **Wake-on-LAN**
   - Ajouter le champ dans le schéma `NetworkInterface`
   - Collecter dans `bench.sh`
   - Afficher dans le frontend

3. **Frontend**
   - Afficher les nouvelles données RAM
   - Graphiques d'utilisation
   - Dashboard SMART pour la santé des disques

4. **Amélioration du script bench.sh**
   - Supporter les arguments en ligne de commande
   - Mode verbose/debug
   - Retry automatique en cas d'échec

## Logs Utiles

### Backend
```bash
docker-compose logs -f backend
```

### iperf3
```bash
docker-compose logs -f iperf3
```

### Tous les services
```bash
docker-compose logs -f
```

## Performance

Le script `bench.sh` prend environ **3-5 minutes** pour :
- Collecter toutes les données hardware (30s)
- Benchmark CPU (10s)
- Benchmark RAM (10s)
- Benchmark Disk (2-3 minutes avec fio)
- Benchmark Network (optionnel, 20s)

## Sécurité

⚠️ **Le token API est codé en dur dans le script** :
```bash
API_TOKEN="29855796dacf5cfe75ff9b02d6adf3dd0f9c52db5b53e7abfb4c0df7ece1be0a"
```

**Recommandations** :
- Changer ce token en production
- Utiliser des variables d'environnement
- Limiter l'accès au serveur API par IP
- Utiliser HTTPS en production

## Support

Pour toute question ou problème :
1. Consulter les logs Docker
2. Vérifier le fichier [IMPLEMENTATION_STATUS.md](IMPLEMENTATION_STATUS.md)
3. Tester manuellement avec `curl` :

```bash
# Test manuel de l'API
curl -X POST http://10.0.0.50:8007/api/benchmark \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d @result.json
```