serv_benchmark/DOCKER_DEPLOYMENT.md

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

git clone <votre-repo>
cd serv_benchmark

2. Configuration

Copier et éditer le fichier d'environnement :

cp .env.example .env
nano .env

Variables importantes pour le module périphériques :

# 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

# 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

# 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 :

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

# 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

# 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

# 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é

# 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

# 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 :

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

Logs

# Backend
docker-compose logs backend | tail -100

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

# iperf3
docker-compose logs iperf3

Métriques

# 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)

# 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

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

4. Limiter les ressources Docker

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

5. Utiliser un volume Docker pour la persistance

# 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

# 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

# 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

# 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

# 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
• Spécifications : docs/PERIPHERALS_MODULE_SPECIFICATION.md
• API Docs : http://localhost:8007/docs (FastAPI Swagger UI)

---

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