ComfyUI - Guide complet d'installation et d'utilisation¶

ComfyUI est une interface node-based puissante pour Stable Diffusion, permettant de créer des workflows complexes de génération d'images avec un contrôle total sur chaque étape du processus.

Présentation¶

Architecture¶

┌─────────────────────────────────────────────┐
│  ComfyUI Web Interface (port 8188)          │
│  - Workflow editor (node-based)             │
│  - Image generator                          │
│  - Model manager                            │
└──────────────────┬──────────────────────────┘
                   │
         ┌─────────▼─────────┐
         │  Python Backend   │
         │  - PyTorch        │
         │  - CUDA 12.1      │
         └─────────┬─────────┘
                   │
    ┌──────────────┼──────────────┐
    │              │              │
┌───▼───┐      ┌───▼───┐    ┌────▼────┐
│GPU 0  │      │GPU 1  │    │ Models  │
│64 GB  │      │64 GB  │    │ /data/  │
└───────┘      └───────┘    └─────────┘

Installation¶

Automatique (via Ansible)¶

L'installation est gérée par Ansible et le pipeline GitLab CI/CD :

# 1. Installation de ComfyUI (automatique sur push main)
#    Job GitLab : ansible:install-comfyui

# 2. Téléchargement des modèles (manuel)
cd /opt/probatiovault-ia-server/ansible
ansible-playbook -i inventory/hosts playbooks/download-comfyui-models.yml

Note : Le téléchargement des modèles est un job GitLab manuel car il télécharge ~22.5 GB de données. Pour le lancer depuis GitLab : 1. Aller sur https://gitlab.com/probatiovault/probatiovault-ia-server/-/pipelines 2. Cliquer sur le dernier pipeline 3. Trouver le job ansible:download-comfyui-models 4. Cliquer sur le bouton ▶️ (play) pour lancer le téléchargement

Modèles téléchargés automatiquement¶

Le playbook download-comfyui-models.yml télécharge depuis HuggingFace :

Total : ~22.5 GB

Premier démarrage¶

1. Vérifier que ComfyUI est démarré¶

# Vérifier le service
systemctl status comfyui

# Vérifier les logs
journalctl -u comfyui -f

# Vérifier que le port 8188 est ouvert
curl http://localhost:8188

2. Accéder à l'interface web¶

1. Ouvrir http://192.168.1.82:8188 dans un navigateur
2. L'interface node-based s'affiche avec un workflow par défaut
3. Si aucun modèle n'est disponible, lancer le téléchargement (voir ci-dessus)

3. Charger un workflow par défaut¶

ComfyUI charge automatiquement un workflow de base (text-to-image). Sinon :

1. Cliquer sur Load en haut à droite
2. Sélectionner default workflow ou example workflows

Utilisation¶

Workflow simple : Text-to-Image (SDXL)¶

Interface node-based : chaque boîte est un "node" qui fait une opération.

┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│ Load Model   │────>│   Sampler    │────>│ Save Image   │
│ (SDXL Base)  │     │ (KSampler)   │     │              │
└──────────────┘     └──────┬───────┘     └──────────────┘
                            │
                     ┌──────▼───────┐
                     │ Prompt       │
                     │ (CLIP Text)  │
                     └──────────────┘

Étapes :

1. Load Checkpoint :
2. Node : CheckpointLoaderSimple

3. Modèle : sd_xl_base_1.0.safetensors

4. CLIP Text Encode (Prompt) :

5. Node : CLIPTextEncode
6. Positive : a beautiful landscape with mountains, dramatic lighting, photorealistic

7. Negative : blurry, low quality, text, watermark

8. KSampler :

9. Steps : 20-30 (qualité vs vitesse)
10. CFG Scale : 7.0 (respect du prompt)
11. Sampler : euler ou dpm_2m

12. Scheduler : karras

13. VAE Decode :

14. Convertit latent → image

15. Save Image :

16. Sauvegarde dans /data/comfyui/output/

17. Cliquer sur "Queue Prompt" (en bas à droite)

Workflow avancé : Text-to-Image + Refiner¶

┌──────────────┐     ┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│ Load Model   │────>│  KSampler    │────>│ Load Refiner │────>│ Save Image   │
│ (SDXL Base)  │     │ (20 steps)   │     │ (10 steps)   │     │              │
└──────────────┘     └──────────────┘     └──────────────┘     └──────────────┘

Le Refiner améliore les détails après la génération initiale.

Configuration : - Base : 20 steps (CFG 7.0) - Refiner : 10 steps (CFG 7.0) - Résolution : 1024×1024

Workflow ControlNet : Image-to-Image guidée¶

ControlNet permet de guider la génération avec une image de référence (contours, profondeur, pose).

Exemple : Canny (contours)

┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│ Load Image   │────>│ Canny Edge   │────>│ ControlNet   │
│              │     │ Detection    │     │ Apply        │
└──────────────┘     └──────────────┘     └──────┬───────┘
                                                  │
┌──────────────┐     ┌──────────────┐            │
│ Load Model   │────>│  KSampler    │<───────────┘
│ (SDXL Base)  │     │              │
└──────────────┘     └──────┬───────┘
                            │
                     ┌──────▼───────┐
                     │ Save Image   │
                     └──────────────┘

Étapes :

1. Upload une image de référence
2. Détection des contours (Canny)
3. ControlNet guide la génération pour suivre ces contours
4. Le prompt décrit ce que vous voulez générer

Cas d'usage : - Transformer un croquis en image photoréaliste - Changer le style d'une image en gardant la composition - Générer des variantes d'une image

Upscaling : Améliorer la résolution¶

┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│ Load Image   │────>│ RealESRGAN   │────>│ Save Image   │
│ (512×512)    │     │ Upscale x4   │     │ (2048×2048)  │
└──────────────┘     └──────────────┘     └──────────────┘

Modèle : RealESRGAN_x4plus.pth Résultat : Image 4× plus grande avec détails améliorés

Gestion des modèles¶

Structure des répertoires¶

/data/comfyui/models/
├── checkpoints/          # Modèles principaux (.safetensors)
│   ├── sd_xl_base_1.0.safetensors
│   ├── sd_xl_refiner_1.0.safetensors
│   └── v1-5-pruned-emaonly.safetensors
├── vae/                  # VAE (améliore couleurs)
│   ├── sdxl_vae.safetensors
│   └── vae-ft-mse-840000-ema-pruned.safetensors
├── controlnet/           # ControlNet (contrôle guidé)
│   ├── controlnet-canny-sdxl-1.0.safetensors
│   └── controlnet-depth-sdxl-1.0.safetensors
├── loras/                # LoRA (ajustements rapides)
│   └── (à télécharger manuellement)
├── upscale_models/       # Upscalers
│   └── RealESRGAN_x4plus.pth
├── embeddings/           # Text embeddings
└── clip_vision/          # CLIP vision models

Ajouter des modèles manuellement¶

Depuis HuggingFace :

# Exemple : télécharger un LoRA
cd /data/comfyui/models/loras
wget https://huggingface.co/<user>/<repo>/resolve/main/<model>.safetensors

# Fixer les permissions
chown comfyui:comfyui <model>.safetensors

Depuis Civitai :

1. Trouver le modèle sur https://civitai.com
2. Copier le lien de téléchargement
3. Télécharger dans le bon répertoire

Recharger les modèles : - Cliquer sur Refresh dans le menu (ou F5)

Modèles recommandés (à télécharger)¶

Workflows prêts à l'emploi¶

ComfyUI inclut des workflows d'exemple :

1. SDXL Basic (text-to-image)¶

• Prompt → Image 1024×1024
• Temps : ~30s (20 steps)

2. SDXL Refiner (haute qualité)¶

• Base (20 steps) + Refiner (10 steps)
• Temps : ~45s

3. Img2Img (image-to-image)¶

• Upload image + Prompt → Variation
• Denoise strength : 0.5-0.8

4. ControlNet Canny¶

• Image de référence → Contours → Génération guidée
• Temps : ~35s

5. Upscale 4׶

• Image 512×512 → 2048×2048
• Temps : ~10s

API et intégration¶

ComfyUI expose une API HTTP pour automatisation.

Endpoint¶

http://192.168.1.82:8188

Soumettre un workflow (Python)¶

import requests
import json

# Charger un workflow JSON
with open('workflow.json', 'r') as f:
    workflow = json.load(f)

# Modifier le prompt
workflow['3']['inputs']['text'] = "a beautiful sunset over the ocean"

# Soumettre
response = requests.post(
    'http://192.168.1.82:8188/prompt',
    json={'prompt': workflow}
)

prompt_id = response.json()['prompt_id']
print(f"Prompt submitted: {prompt_id}")

Récupérer les images générées¶

import websocket
import json

def on_message(ws, message):
    data = json.loads(message)
    if data['type'] == 'executed':
        print(f"Image generated: {data['data']['output']}")

ws = websocket.WebSocketApp(
    'ws://192.168.1.82:8188/ws',
    on_message=on_message
)
ws.run_forever()

Télécharger l'image¶

# Les images sont dans /data/comfyui/output/
curl http://192.168.1.82:8188/view?filename=ComfyUI_00001_.png --output image.png

Intégration Homer¶

ComfyUI est référencé dans le dashboard Homer :

- name: "IA & Machine Learning"
  items:
    - name: "ComfyUI"
      logo: "assets/tools/comfyui.png"
      subtitle: "Node-based Stable Diffusion interface"
      url: "http://192.168.1.82:8188"
      tag: "gpu"

Accès depuis Homer : http://192.168.1.82:8080

Troubleshooting¶

ComfyUI ne démarre pas¶

# Vérifier les logs
journalctl -u comfyui -n 50

# Erreurs communes :
# - "CUDA out of memory" : Modèle trop gros pour VRAM
# - "No module named 'torch'" : Dépendances Python manquantes

# Redémarrer le service
systemctl restart comfyui

Modèles non détectés¶

# Vérifier que les modèles sont dans le bon répertoire
ls -lh /data/comfyui/models/checkpoints/

# Vérifier les permissions
chown -R comfyui:comfyui /data/comfyui/models/

# Relancer ComfyUI
systemctl restart comfyui

Génération très lente¶

Causes possibles :

1. CUDA non détecté :

   # Vérifier CUDA
   nvidia-smi
   
   # Vérifier que PyTorch utilise CUDA
   python3 -c "import torch; print(torch.cuda.is_available())"
   

2. Modèle trop lourd :

3. Utiliser SD 1.5 au lieu de SDXL (plus rapide)

4. Réduire le nombre de steps (10-15 au lieu de 20-30)

5. GPU occupé :

   # Vérifier l'utilisation GPU
   nvidia-smi
   
   # Tuer les processus GPU si nécessaire
   pkill -f comfyui
   systemctl restart comfyui
   

Erreur "Out of Memory"¶

# SDXL nécessite ~12 GB VRAM. Avec 2× RTX 5090 (64 GB), aucun problème.
# Si l'erreur persiste :

# 1. Vérifier la VRAM disponible
nvidia-smi

# 2. Utiliser un modèle plus léger
# → SD 1.5 au lieu de SDXL

# 3. Réduire la résolution
# → 768×768 au lieu de 1024×1024

Images floues ou de mauvaise qualité¶

Solutions :

1. Utiliser un VAE :
2. SDXL : sdxl_vae.safetensors

3. SD 1.5 : vae-ft-mse-840000-ema-pruned.safetensors

4. Augmenter les steps :

5. Minimum : 20 steps

6. Qualité : 30-40 steps

7. Améliorer le prompt :

8. Ajouter des mots-clés qualité : photorealistic, high quality, detailed, 8k

9. Negative prompt : blurry, low quality, pixelated, jpeg artifacts

10. Utiliser le Refiner (SDXL) :

11. Base + Refiner = meilleure qualité

Performance¶

Temps de génération (estimés)¶

Optimisation¶

Générations multiples en parallèle :

ComfyUI peut utiliser les 2 GPU simultanément. Pour activer :

# Éditer le script de démarrage
sudo vim /opt/comfyui/start.sh

# Ajouter --use-multi-device-mode
python3 main.py --listen 0.0.0.0 --port 8188 --use-multi-device-mode

# Redémarrer
systemctl restart comfyui

Batch processing :

Générer plusieurs images en une seule exécution :

1. Node KSampler → paramètre batch_size: 4
2. Génère 4 images simultanément

Maintenance¶

Mise à jour ComfyUI¶

# Arrêter le service
systemctl stop comfyui

# Mettre à jour le code
cd /opt/comfyui
sudo -u comfyui git pull origin master

# Mettre à jour les dépendances Python
pip3 install -r requirements.txt --upgrade --break-system-packages

# Redémarrer
systemctl start comfyui

Sauvegarde des modèles¶

# Sauvegarder les modèles (22.5 GB)
sudo tar czf /tmp/comfyui-models-backup-$(date +%Y%m%d).tar.gz /data/comfyui/models/

# Copier ailleurs (NAS, S3, etc.)
cp /tmp/comfyui-models-backup-*.tar.gz /mnt/nas/backups/

Sauvegarde des workflows¶

# Les workflows sont dans le navigateur (localStorage).
# Export manuel depuis l'interface :
# 1. Cliquer sur "Save" → "Export workflow"
# 2. Sauvegarder le fichier JSON

# Ou copier les outputs générés
sudo tar czf /tmp/comfyui-output-backup-$(date +%Y%m%d).tar.gz /data/comfyui/output/

Nettoyage des images générées¶

# Supprimer les images > 30 jours
find /data/comfyui/output/ -name "*.png" -mtime +30 -delete

# Vérifier l'espace disque
du -sh /data/comfyui/output/

Ressources¶

• GitHub officiel : https://github.com/comfyanonymous/ComfyUI
• Documentation : https://github.com/comfyanonymous/ComfyUI/wiki
• Workflows communautaires : https://comfyworkflows.com
• Modèles (HuggingFace) : https://huggingface.co/models?pipeline_tag=text-to-image
• Modèles (Civitai) : https://civitai.com

Résumé des commandes¶

# Service
systemctl status comfyui
systemctl restart comfyui
journalctl -u comfyui -f

# Modèles
ls -lh /data/comfyui/models/checkpoints/
ansible-playbook -i inventory/hosts playbooks/download-comfyui-models.yml

# GPU
nvidia-smi
watch -n 1 nvidia-smi

# Espace disque
du -sh /data/comfyui/
df -h /data/

# Tests
curl http://localhost:8188
bash /opt/probatiovault-ia-server/scripts/test-comfyui.sh

Différences avec Midjourney / DALL-E¶

Avantages ComfyUI : - ✅ Données privées (RGPD compliant) - ✅ Pas de coût récurrent - ✅ Contrôle total (workflows complexes) - ✅ Extensible (custom nodes)

Avantages Midjourney/DALL-E : - ✅ Qualité optimisée (modèles propriétaires) - ✅ Pas de gestion infrastructure - ✅ Interface simplifiée (prompts uniquement)