README_DOCKER.md

# 🐳 Déploiement Docker - Classificateur de Déchets IA

Guide complet pour dockeriser et déployer l'interface de classification de déchets avec Docker.

## 📋 Prérequis

1. **Docker** : Installé sur votre machine
2. **Docker Compose** : Pour la gestion des services
3. **Modèles entraînés** : Assurez-vous que vos modèles v1 et v2 sont disponibles

## 🚀 Démarrage rapide

### 1. Construction et lancement automatique

```bash
# Construire l'image et démarrer le conteneur
./run_docker.sh build && ./run_docker.sh start

# Ou en une seule commande
docker-compose up --build -d
```

### 2. Accès à l'interface

Ouvrez votre navigateur à l'adresse : `http://localhost:8501`

## 🔧 Commandes disponibles

### Script de gestion

```bash
# Construire l'image Docker
./run_docker.sh build

# Démarrer le conteneur
./run_docker.sh start

# Arrêter le conteneur
./run_docker.sh stop

# Redémarrer le conteneur
./run_docker.sh restart

# Voir les logs en temps réel
./run_docker.sh logs

# Vérifier le statut
./run_docker.sh status

# Nettoyer les ressources Docker
./run_docker.sh clean

# Afficher l'aide
./run_docker.sh help
```

### Commandes Docker Compose

```bash
# Démarrer en arrière-plan
docker-compose up -d

# Voir les logs
docker-compose logs -f

# Arrêter
docker-compose down

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

# Voir le statut
docker-compose ps
```

## 📁 Structure des fichiers

```
code/
├── app.py                    # Interface Streamlit principale
├── requirements.txt          # Dépendances Python
├── Dockerfile               # Configuration Docker
├── docker-compose.yml       # Configuration Docker Compose
├── .dockerignore           # Fichiers à ignorer lors du build
├── run_docker.sh           # Script de gestion Docker
├── README_DOCKER.md        # Cette documentation
└── models/                 # Dossier des modèles (créé automatiquement)
    ├── waste_classifier_v1.h5
    └── waste_classifier_v2.h5
```

## ⚙️ Configuration

### Variables d'environnement

Vous pouvez configurer l'application via des variables d'environnement :

```bash
# URLs des modèles
export MODEL_V1_URL="https://votre-url.com/model_v1.h5"
export MODEL_V2_URL="https://votre-url.com/model_v2.h5"

# Port de l'application
export STREAMLIT_SERVER_PORT=8501
```

### Fichier docker-compose.yml

```yaml
version: '3.8'

services:
  waste-classifier:
    build: .
    ports:
      - "8501:8501"
    volumes:
      - model_cache:/app/models
    environment:
      - MODEL_V1_URL=https://votre-url.com/model_v1.h5
      - MODEL_V2_URL=https://votre-url.com/model_v2.h5
    restart: unless-stopped
```

## 🔄 Gestion des modèles

### Option 1 : Modèles locaux

1. Créez le dossier `models/`
2. Copiez vos modèles :
   ```bash
   mkdir -p models
   cp training_output/training/models/waste_classifier_best.h5 models/waste_classifier_v1.h5
   cp training_output_v2/v2.0/training/v2.0/models/waste_classifier_v2.0_best.h5 models/waste_classifier_v2.h5
   ```

### Option 2 : Téléchargement automatique

L'application télécharge automatiquement les modèles depuis les URLs configurées.

### Option 3 : Volume Docker

Les modèles sont persistés dans un volume Docker pour éviter les re-téléchargements.

## 📊 Monitoring et logs

### Voir les logs

```bash
# Logs en temps réel
./run_docker.sh logs

# Ou avec docker-compose
docker-compose logs -f
```

### Vérifier la santé

```bash
# Statut du conteneur
./run_docker.sh status

# Health check
docker inspect waste-classifier-app | grep -A 10 Health
```

### Métriques de performance

```bash
# Utilisation des ressources
docker stats waste-classifier-app

# Informations détaillées
docker inspect waste-classifier-app
```

## 🐛 Dépannage

### Problèmes courants

1. **Port déjà utilisé**
   ```bash
   # Changer le port dans docker-compose.yml
   ports:
     - "8502:8501"  # Utiliser le port 8502
   ```

2. **Modèles non trouvés**
   - Vérifiez que les modèles sont dans le dossier `models/`
   - Vérifiez les URLs dans les variables d'environnement

3. **Erreur de mémoire**
   ```bash
   # Augmenter la limite de mémoire
   docker run --memory=4g waste-classifier
   ```

4. **Conteneur ne démarre pas**
   ```bash
   # Voir les logs d'erreur
   docker-compose logs
   
   # Redémarrer proprement
   ./run_docker.sh clean
   ./run_docker.sh build
   ./run_docker.sh start
   ```

### Nettoyage

```bash
# Nettoyer tout (conteneurs, images, volumes)
./run_docker.sh clean

# Nettoyer seulement les conteneurs arrêtés
docker container prune -f

# Nettoyer les images non utilisées
docker image prune -f
```

## 🚀 Déploiement en production

### 1. Build pour la production

```bash
# Build avec optimisations
docker build -t waste-classifier:prod --target production .
```

### 2. Déploiement sur un serveur

```bash
# Copier les fichiers sur le serveur
scp -r . user@server:/path/to/app/

# Sur le serveur
cd /path/to/app
./run_docker.sh build
./run_docker.sh start
```

### 3. Configuration Nginx (optionnel)

```nginx
server {
    listen 80;
    server_name votre-domaine.com;
    
    location / {
        proxy_pass http://localhost:8501;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}
```

## 🔒 Sécurité

### 1. Utilisateur non-root

Le conteneur s'exécute avec un utilisateur non-root pour la sécurité.

### 2. Variables d'environnement sensibles

```bash
# Utiliser un fichier .env
echo "MODEL_V1_URL=https://votre-url-secure.com/model_v1.h5" > .env
echo "MODEL_V2_URL=https://votre-url-secure.com/model_v2.h5" >> .env
```

### 3. Limitation des ressources

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

## 📈 Optimisations

### 1. Image multi-stage

```dockerfile
# Stage 1: Build
FROM python:3.11-slim as builder
# ... installation des dépendances

# Stage 2: Production
FROM python:3.11-slim
# ... copie des fichiers nécessaires
```

### 2. Cache des dépendances

```dockerfile
# Copier requirements.txt d'abord pour utiliser le cache Docker
COPY requirements.txt .
RUN pip install -r requirements.txt
```

### 3. Compression des modèles

```python
# Dans votre script d'entraînement
model.save('model_compressed.h5', include_optimizer=False)
```

## 🌐 Intégration avec d'autres services

### 1. Base de données

```yaml
# Ajouter dans docker-compose.yml
services:
  database:
    image: postgres:13
    environment:
      POSTGRES_DB: waste_classifier
    volumes:
      - db_data:/var/lib/postgresql/data

  waste-classifier:
    depends_on:
      - database
    environment:
      - DATABASE_URL=postgresql://user:pass@database:5432/waste_classifier
```

### 2. Redis pour le cache

```yaml
services:
  redis:
    image: redis:alpine
    ports:
      - "6379:6379"

  waste-classifier:
    depends_on:
      - redis
    environment:
      - REDIS_URL=redis://redis:6379
```

## 📞 Support

- **Logs** : `./run_docker.sh logs`
- **Statut** : `./run_docker.sh status`
- **Nettoyage** : `./run_docker.sh clean`

---

**Bon déploiement Docker ! 🐳**