serv_benchmark/docs/DEPLOYMENT.md

# Deployment Guide - Linux BenchTools

Guide de déploiement complet pour Linux BenchTools.

## 📋 Prérequis

### Serveur hôte

- **OS** : Linux (Debian 11+, Ubuntu 20.04+ recommandé)
- **RAM** : Minimum 512 MB (1 GB recommandé)
- **Disque** : Minimum 2 GB d'espace libre
- **Réseau** : Accès réseau local pour les clients

### Logiciels requis

- Docker 20.10+
- Docker Compose plugin 2.0+
- Git (optionnel, pour clonage)

### Installation des prérequis

```bash
# Installer Docker
curl -fsSL https://get.docker.com | sh

# Ajouter l'utilisateur au groupe docker
sudo usermod -aG docker $USER

# Se déconnecter/reconnecter pour appliquer les changements
# ou utiliser:
newgrp docker

# Vérifier l'installation
docker --version
docker compose version
```

## 🚀 Déploiement Standard

### 1. Récupérer le code

```bash
# Via Git
git clone https://gitea.maison43.duckdns.org/gilles/linux-benchtools.git
cd linux-benchtools

# Ou télécharger et extraire l'archive
```

### 2. Exécuter l'installation

```bash
./install.sh
```

Le script crée automatiquement :
- `.env` avec un token API aléatoire sécurisé
- Répertoires `backend/data/` et `uploads/`
- Images Docker
- Conteneurs en arrière-plan

### 3. Vérifier le déploiement

```bash
# Vérifier les conteneurs
docker compose ps

# Tester le backend
curl http://localhost:8007/api/health

# Tester le frontend
curl -I http://localhost:8087
```

## 🔧 Déploiement Personnalisé

### Configuration avancée

Créez un fichier `.env` personnalisé avant l'installation :

```bash
# .env
API_TOKEN=votre-token-personnalise-securise
DATABASE_URL=sqlite:////app/data/data.db
UPLOAD_DIR=/app/uploads
BACKEND_PORT=8007
FRONTEND_PORT=8087
```

### Ports personnalisés

```bash
# Modifier .env
BACKEND_PORT=9000
FRONTEND_PORT=9001

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

### Reverse Proxy (Nginx/Traefik)

#### Exemple Nginx

```nginx
# /etc/nginx/sites-available/benchtools

upstream benchtools_backend {
    server localhost:8007;
}

upstream benchtools_frontend {
    server localhost:8087;
}

server {
    listen 80;
    server_name bench.maison43.local;

    # Frontend
    location / {
        proxy_pass http://benchtools_frontend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    # Backend API
    location /api/ {
        proxy_pass http://benchtools_backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    # WebSocket support (si besoin futur)
    location /ws/ {
        proxy_pass http://benchtools_backend;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}
```

```bash
# Activer le site
sudo ln -s /etc/nginx/sites-available/benchtools /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx
```

## 📊 Monitoring et Logs

### Consulter les logs

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

# Backend uniquement
docker compose logs -f backend

# Dernières 100 lignes
docker compose logs --tail=100 backend

# Logs depuis une date
docker compose logs --since 2025-12-07T10:00:00 backend
```

### Métriques système

```bash
# Utilisation des ressources
docker stats

# Espace disque
du -sh backend/data uploads
```

## 🔄 Maintenance

### Backup

```bash
#!/bin/bash
# backup.sh

BACKUP_DIR="./backups/$(date +%Y%m%d_%H%M%S)"
mkdir -p "$BACKUP_DIR"

# Backup base de données
docker compose exec backend sqlite3 /app/data/data.db ".backup /app/data/backup.db"
docker cp linux_benchtools_backend:/app/data/backup.db "$BACKUP_DIR/"

# Backup uploads
cp -r uploads "$BACKUP_DIR/"

# Backup .env
cp .env "$BACKUP_DIR/"

echo "Backup créé dans $BACKUP_DIR"
```

### Restore

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

# Restaurer la base
cp backup/data.db backend/data/data.db

# Restaurer les uploads
cp -r backup/uploads ./

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

### Mise à jour

```bash
# Récupérer les dernières modifications
git pull

# Reconstruire et redémarrer
docker compose up -d --build

# Ou sans interruption (rolling update)
docker compose build
docker compose up -d --no-deps --build backend
docker compose up -d --no-deps --build frontend
```

### Nettoyage

```bash
# Supprimer les anciens benchmarks (exemple : > 6 mois)
docker compose exec backend sqlite3 /app/data/data.db \
  "DELETE FROM benchmarks WHERE run_at < datetime('now', '-6 months');"

# Nettoyer les images Docker inutilisées
docker image prune -a

# Nettoyer les volumes inutilisés
docker volume prune
```

## 🔒 Sécurité

### Recommandations

1. **Token API** : Utiliser un token fort généré aléatoirement
2. **Firewall** : Limiter l'accès aux ports 8007/8087 au réseau local
3. **Reverse Proxy** : Utiliser HTTPS si exposition Internet
4. **Backup** : Backup régulier de la base et des uploads
5. **Mises à jour** : Maintenir Docker et le système à jour

### Firewall (UFW)

```bash
# Autoriser seulement le réseau local
sudo ufw allow from 192.168.1.0/24 to any port 8007
sudo ufw allow from 192.168.1.0/24 to any port 8087
```

### HTTPS avec Let's Encrypt

Si exposé sur Internet :

```bash
# Installer Certbot
sudo apt install certbot python3-certbot-nginx

# Obtenir un certificat
sudo certbot --nginx -d bench.votredomaine.com
```

## 📈 Scaling

### Augmenter les performances

```yaml
# docker-compose.yml

services:
  backend:
    # ...
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 2G
        reservations:
          cpus: '1'
          memory: 1G
```

### Multiple workers

Modifier le Dockerfile backend :

```dockerfile
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8007", "--workers", "4"]
```

## 🐛 Troubleshooting

### Port déjà utilisé

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

# Changer le port dans .env
BACKEND_PORT=8008

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

### Base de données verrouillée

```bash
# Arrêter le backend
docker compose stop backend

# Vérifier les processus SQLite
docker compose exec backend sh -c "ps aux | grep sqlite"

# Redémarrer
docker compose start backend
```

### Espace disque plein

```bash
# Nettoyer les logs Docker
sudo sh -c "truncate -s 0 /var/lib/docker/containers/*/*-json.log"

# Nettoyer les anciens benchmarks
docker compose exec backend sqlite3 /app/data/data.db \
  "DELETE FROM benchmarks WHERE run_at < datetime('now', '-3 months');"
```

## 📞 Support

- Documentation : Fichiers `.md` dans le dépôt
- Issues : Gitea repository
- Logs : `docker compose logs`

## ✅ Checklist de déploiement

- [ ] Docker et Docker Compose installés
- [ ] Ports 8007 et 8087 disponibles
- [ ] Espaces disque suffisant (>2GB)
- [ ] `install.sh` exécuté avec succès
- [ ] Health check OK (`curl localhost:8007/api/health`)
- [ ] Frontend accessible (`http://localhost:8087`)
- [ ] Token API noté en lieu sûr
- [ ] Backup configuré
- [ ] Firewall configuré (optionnel)
- [ ] Reverse proxy configuré (optionnel)

Bon déploiement ! 🚀