# Déploiement Docker - Module Périphériques

Guide pour déployer Linux BenchTools avec le module Périphériques dans Docker.

## 🐳 Prérequis

- Docker >= 20.10
- Docker Compose >= 2.0
- Git

## 📦 Installation

### 1. Cloner le dépôt

```bash
git clone <votre-repo>
cd serv_benchmark
```

### 2. Configuration

Copier et éditer le fichier d'environnement :

```bash
cp .env.example .env
nano .env
```

**Variables importantes pour le module périphériques :**

```bash
# Activer le module périphériques
PERIPHERALS_MODULE_ENABLED=true

# Base de données périphériques (sera créée automatiquement)
PERIPHERALS_DB_URL=sqlite:////app/data/peripherals.db

# Qualité compression images (1-100)
IMAGE_COMPRESSION_QUALITY=85
```

### 3. Lancement

```bash
# Build et démarrage
docker-compose up -d --build

# Vérifier les logs
docker-compose logs -f backend

# Vous devriez voir :
# ✅ Main database initialized: sqlite:////app/data/data.db
# ✅ Peripherals database initialized: sqlite:////app/data/peripherals.db
# ✅ Peripherals upload directories created: /app/uploads/peripherals
```

### 4. Vérification

```bash
# Vérifier que le backend fonctionne
curl http://localhost:8007/api/health

# Vérifier le module périphériques
curl http://localhost:8007/api/peripherals/statistics/summary

# Accéder au frontend
# http://localhost:8087/peripherals.html
```

## 📁 Structure des volumes Docker

Le docker-compose.yml monte les volumes suivants :

```yaml
volumes:
  # Base de données (data.db + peripherals.db)
  - ./backend/data:/app/data

  # Uploads (photos, documents périphériques)
  - ./uploads:/app/uploads

  # Code backend (hot-reload en dev)
  - ./backend/app:/app/app

  # Configuration YAML (lecture seule)
  - ./config:/app/config:ro
```

### Structure sur l'hôte

```
serv_benchmark/
├── backend/data/
│   ├── data.db              # Base principale (benchmarks)
│   └── peripherals.db       # Base périphériques (auto-créée)
│
├── uploads/
│   └── peripherals/
│       ├── photos/          # Photos de périphériques
│       │   └── {id}/
│       ├── documents/       # Documents PDF, factures...
│       │   └── {id}/
│       └── locations/
│           ├── images/      # Photos de localisations
│           └── qrcodes/     # QR codes générés
│
└── config/
    ├── peripheral_types.yaml    # Types de périphériques
    ├── locations.yaml           # Types de localisations
    ├── image_processing.yaml    # Config compression
    └── notifications.yaml       # Config rappels
```

## 🔧 Gestion du conteneur

### Commandes utiles

```bash
# Redémarrer après modification de code
docker-compose restart backend

# Voir les logs en temps réel
docker-compose logs -f backend

# Accéder au shell du conteneur
docker-compose exec backend /bin/bash

# Vérifier les bases de données
docker-compose exec backend ls -lh /app/data/

# Rebuild complet (après modif requirements.txt)
docker-compose down
docker-compose up -d --build
```

### Sauvegardes

```bash
# Backup des bases de données
docker-compose exec backend tar -czf /tmp/backup.tar.gz /app/data/*.db
docker cp linux_benchtools_backend:/tmp/backup.tar.gz ./backup-$(date +%Y%m%d).tar.gz

# Backup des uploads
tar -czf uploads-backup-$(date +%Y%m%d).tar.gz uploads/
```

### Restauration

```bash
# Arrêter les conteneurs
docker-compose down

# Restaurer les données
tar -xzf backup-20251230.tar.gz
tar -xzf uploads-backup-20251230.tar.gz

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

## 🔒 Sécurité

### Générer un token API sécurisé

```bash
# Méthode 1 : openssl
openssl rand -hex 32

# Méthode 2 : Python
python3 -c "import secrets; print(secrets.token_hex(32))"

# Éditer .env
API_TOKEN=<votre_token_généré>
```

### Permissions des fichiers

```bash
# S'assurer que les répertoires sont accessibles
chmod -R 755 backend/data
chmod -R 755 uploads
chmod -R 755 config

# Le conteneur tourne en tant que root par défaut
# Pour un déploiement production, considérer un user non-root
```

## 📊 Monitoring

### Healthcheck

Le backend expose un endpoint de healthcheck :

```bash
curl http://localhost:8007/api/health
# Réponse : {"status":"ok"}
```

### Logs

```bash
# Backend
docker-compose logs backend | tail -100

# Frontend (nginx)
docker-compose logs frontend | tail -100

# iperf3
docker-compose logs iperf3
```

### Métriques

```bash
# Stats Docker
docker stats linux_benchtools_backend

# Taille des bases de données
docker-compose exec backend du -h /app/data/*.db

# Espace utilisé par les uploads
du -sh uploads/
```

## 🚀 Production

### Recommandations

1. **Utiliser un reverse proxy (nginx/Traefik)**

```nginx
# Exemple nginx
server {
    listen 80;
    server_name benchtools.example.com;

    location /api/ {
        proxy_pass http://localhost:8007/api/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    location / {
        proxy_pass http://localhost:8087/;
    }
}
```

2. **Activer HTTPS avec Let's Encrypt**

3. **Configurer les backups automatiques**

```bash
# Cron job exemple (tous les jours à 2h)
0 2 * * * cd /path/to/serv_benchmark && ./backup.sh
```

4. **Limiter les ressources Docker**

```yaml
# Dans docker-compose.yml
services:
  backend:
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 2G
```

5. **Utiliser un volume Docker pour la persistance**

```yaml
# Au lieu de bind mounts
volumes:
  db_data:
  uploads_data:

services:
  backend:
    volumes:
      - db_data:/app/data
      - uploads_data:/app/uploads
```

## 🐛 Troubleshooting

### Le module périphériques ne se charge pas

```bash
# Vérifier les logs
docker-compose logs backend | grep -i peripheral

# Vérifier la config
docker-compose exec backend cat /app/app/core/config.py | grep PERIPHERAL

# Forcer la recréation de la DB
docker-compose exec backend rm /app/data/peripherals.db
docker-compose restart backend
```

### Les images ne s'uploadent pas

```bash
# Vérifier les permissions
docker-compose exec backend ls -la /app/uploads/peripherals/

# Créer les dossiers manuellement si nécessaire
docker-compose exec backend mkdir -p /app/uploads/peripherals/{photos,documents,locations/images,locations/qrcodes}
```

### Pillow/QRCode ne s'installe pas

```bash
# Rebuild avec --no-cache
docker-compose build --no-cache backend

# Vérifier les dépendances système
docker-compose exec backend apk list --installed | grep -E 'jpeg|zlib|freetype'
```

### Import USB ne fonctionne pas

```bash
# Tester le parser directement
docker-compose exec backend python3 -c "
from app.utils.usb_parser import parse_lsusb_verbose
with open('/tmp/test_usb.txt', 'r') as f:
    result = parse_lsusb_verbose(f.read())
    print(result)
"
```

## 📝 Notes

- Le module est **activé par défaut** (`PERIPHERALS_MODULE_ENABLED=true`)
- La base de données `peripherals.db` est créée **automatiquement** au premier démarrage
- Les fichiers de configuration YAML dans `config/` sont montés en **lecture seule**
- Pour modifier les types de périphériques, éditer `config/peripheral_types.yaml` et redémarrer

## 🔗 Liens utiles

- Documentation complète : [README_PERIPHERALS.md](README_PERIPHERALS.md)
- Spécifications : [docs/PERIPHERALS_MODULE_SPECIFICATION.md](docs/PERIPHERALS_MODULE_SPECIFICATION.md)
- API Docs : http://localhost:8007/docs (FastAPI Swagger UI)

---

**Dernière mise à jour :** 2025-12-30