Effi/docs/WOL-ET-DEMARRAGE-AUTO.md

# 🔌 Wake On LAN (WOL) et Démarrage Automatique

Guide pour s'assurer que tous les services Effi démarrent automatiquement après un WOL.

---

## 📋 Architecture des services sur folzo-Corp

| Service | Port | Docker | Dépendance WOL |
|---------|------|--------|----------------|
| **llama.cpp** (instance A — qwen3.8-27b Q4_K_M) | 8080 | Native (systemd) | Oui |
| **llama.cpp** (instance B — qwen3.8-27b-iq4xs) | 8081 | Native (systemd) | Oui |
| **Ollama** | 11434 | ✅ | Oui |
| **Effi-STT** | 8200 | ✅ | Oui |
| **ComfyUI** | 8188 | ✅ | Oui |

> **Note :** le TTS (openedai-speech, port 8100) tourne désormais sur l'effi-server,
> pas sur folzo-Corp. Il n'a donc pas besoin de WOL.

> **Note VRAM :** les 2 instances llama.cpp partagent les 32 Go de VRAM. Une seule
> doit tourner à la fois : démarre l'instance voulue sur le PC, et active-la dans
> l'UI du proxy (http://192.168.1.27:3017).

Le réveil est géré automatiquement par **`llm-proxy`** (effi-server) : au premier appel
vers une cible éteinte, il envoie 3 paquets magic (MAC du PC) puis attend que le service
soit prêt. Aucun script manuel nécessaire.

---

## 🚀 Configuration du démarrage automatique

### 1. Activer Docker au boot

Sur **folzo-Corp**, exécutez une fois :

```bash
sudo systemctl enable docker
```

Cela garantit que Docker démarre automatiquement à chaque boot.

### 2. Vérifier la politique de redémarrage des conteneurs

Tous les services Docker doivent avoir `restart: unless-stopped` dans leur `docker-compose.yml`.

**Vérification :**
```bash
# Vérifier les politiques de redémarrage
sudo docker inspect -f '{{.Name}} - {{.HostConfig.RestartPolicy.Name}}' $(sudo docker ps -aq)
```

**Résultat attendu :**
```
/ollama - unless-stopped
/comfyui - unless-stopped
/effi-stt - unless-stopped
/openedai-speech - unless-stopped
```

Si un conteneur n'a pas `unless-stopped`, modifiez son `docker-compose.yml` et redémarrez-le.

---

## ⚡ Procédure après un WOL

### Méthode 1 : Script automatique (recommandé)

Après que folzo-Corp soit réveillé par WOL, exécutez sur le PC :

```bash
~/Documents/OpenCode/Projets/Effi/scripts/start-all-services.sh
```

Ce script va :
1. Démarrer Docker si nécessaire
2. Démarrer tous les conteneurs
3. Vérifier que tout répond correctement

### Méthode 2 : Vérification rapide

Pour vérifier que tout fonctionne :

```bash
~/Documents/OpenCode/Projets/Effi/scripts/check-services.sh
```

### Méthode 3 : Démarrage manuel

Si vous préférez démarrer un service spécifique :

```bash
# Ollama
cd ~ && sudo docker compose up -d

# ComfyUI
cd ~/Documents/OpenCode/Projets/Effi/comfyui && sudo docker compose up -d

# Effi-STT
cd ~/Documents/OpenCode/Projets/Effi/effi-stt && sudo docker compose up -d

# openedai-speech
cd ~/openedai-speech && sudo docker compose up -d
```

---

## 🔄 Créer un démarrage automatique complet

### Option A : Script au boot (systemd)

Créer un service systemd qui démarre tous les conteneurs :

```bash
# Créer le fichier de service
sudo tee /etc/systemd/system/effi-services.service > /dev/null <<EOF
[Unit]
Description=Effi Services (Ollama, ComfyUI, STT, TTS)
After=docker.service
Requires=docker.service

[Service]
Type=oneshot
User=folzo
Group=folzo
ExecStart=/home/folzo/Documents/OpenCode/Projets/Effi/scripts/start-all-services.sh
RemainAfterExit=yes

[Install]
WantedBy=multi-user.target
EOF

# Activer le service
sudo systemctl daemon-reload
sudo systemctl enable effi-services.service
```

**Avantage** : Tout démarre automatiquement au boot, sans intervention.

### Option B : Script de vérification périodique

Pour s'assurer que les services restent en ligne :

```bash
# Ajouter au crontab
crontab -e

# Ajouter cette ligne pour vérifier toutes les 5 minutes
*/5 * * * * /home/folzo/Documents/OpenCode/Projets/Effi/scripts/check-services.sh > /dev/null 2>&1
```

---

## 🧪 Test du WOL complet

### Procédure de test

1. **Éteindre folzo-Corp** normalement
2. **Attendre 10 secondes**
3. **Envoyer le paquet WOL** depuis effi-server :
   ```bash
   wakeonlan XX:XX:XX:XX:XX:XX  # MAC de folzo-Corp
   ```
4. **Attendre le boot** (~30-60 secondes)
5. **Vérifier les services** :
   ```bash
   ssh folzo@192.168.1.11 "~/Documents/OpenCode/Projets/Effi/scripts/check-services.sh"
   ```
6. **Tester une génération d'image** via OpenWebUI

### Si un service ne démarre pas

```bash
# Voir les logs d'un service
sudo docker logs comfyui

# Redémarrer un service spécifique
sudo docker restart comfyui

# Vérifier l'état de tous les conteneurs
sudo docker ps -a
```

---

## 📊 Monitoring

### Vérifier l'état des services

```bash
# Tous les services
sudo docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"

# Utilisation GPU
rocm-smi

# Espace disque
df -h
```

### Alertes

Si un service est down, vous pouvez créer une alerte simple :

```bash
# Dans le crontab
crontab -e

# Vérifier toutes les minutes et envoyer notification si KO
* * * * * /home/folzo/Documents/OpenCode/Projets/Effi/scripts/check-services.sh || echo "Services Effi down" | mail -s "Alerte Effi" votre@email.com
```

---

## 🐛 Dépannage

### Problème : Docker ne démarre pas au boot

```bash
# Vérifier l'état
sudo systemctl status docker

# Activer au boot
sudo systemctl enable docker

# Démarrer manuellement
sudo systemctl start docker
```

### Problème : Les conteneurs ne démarrent pas

```bash
# Vérifier la politique de redémarrage
sudo docker inspect -f '{{.Name}} - {{.HostConfig.RestartPolicy.Name}}' comfyui

# Si ce n'est pas "unless-stopped", le corriger
cd ~/Documents/OpenCode/Projets/Effi/comfyui
sudo docker compose up -d
```

### Problème : ComfyUI ne répond pas après WOL

Cela arrive si ROCm n'est pas prêt. Solution :

```bash
# Attendre que le GPU soit prêt
sleep 10

# Redémarrer ComfyUI
sudo docker restart comfyui

# Vérifier les logs
sudo docker logs comfyui | tail -20
```

### Problème : Timeout après WOL

Si les services mettent trop de temps à répondre après un WOL :

1. **Augmenter le délai d'attente** dans le script
2. **Vérifier les performances du disque** (peut-être en veille)
3. **Désactiver la veille du disque** :
   ```bash
   sudo hdparm -S 0 /dev/sda  # Désactiver la veille
   ```

---

## ✅ Checklist post-WOL

Après chaque WOL, vérifiez :

- [ ] Docker est démarré : `sudo systemctl is-active docker`
- [ ] Ollama répond : `curl http://localhost:11434`
- [ ] ComfyUI répond : `curl http://localhost:8188`
- [ ] Effi-STT répond : `curl http://localhost:8200/health`
- [ ] openedai-speech répond : `curl http://localhost:8100/health`
- [ ] GPU disponible : `rocm-smi`
- [ ] Test de génération d'image via OpenWebUI

---

## 📝 Résumé des commandes utiles

| Action | Commande |
|--------|----------|
| Tout démarrer | `~/Documents/OpenCode/Projets/Effi/scripts/start-all-services.sh` |
| Vérifier les services | `~/Documents/OpenCode/Projets/Effi/scripts/check-services.sh` |
| Activer démarrage auto | `sudo systemctl enable docker` |
| Voir les logs | `sudo docker logs <nom>` |
| Redémarrer un service | `sudo docker restart <nom>` |
| Voir tous les conteneurs | `sudo docker ps -a` |
| État du GPU | `rocm-smi` |

---

**Note** : Pour une expérience optimale, configurez le service systemd (Option A) pour un démarrage 100% automatique sans intervention.

*Document créé le 6 avril 2026*