ComfyUI

Interface Stable Diffusion basée sur des nœuds avec ComfyUI sur Clore.ai

Interface basée sur des nœuds pour Stable Diffusion avec une flexibilité ultime sur les GPU CLORE.AI.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Exigences du serveur

Paramètre	Minimum	Recommandé
RAM	16 Go	32 Go+
VRAM	8 Go (SDXL)	12 Go+
Réseau	500 Mbps	1 Gbps+
Temps de démarrage	5 à 10 minutes	-

Temps de démarrage : Au premier lancement, les dépendances et les modèles sont téléchargés (5 à 10 minutes selon la vitesse du réseau). Un code HTTP 502 pendant ce temps est normal.

Important : ComfyUI avec les modèles FLUX nécessite 16 Go+ de VRAM. Pour SDXL avec ControlNet, assurez-vous d'avoir au moins 10 Go de VRAM.

Pourquoi ComfyUI ?

• Flux de travail basé sur des nœuds - Programmation visuelle pour la génération d'images

• Contrôle maximal - Ajustez finement chaque étape du pipeline

• Efficace - Utilisation de VRAM plus faible que les alternatives

• Extensible - Un vaste écosystème de nœuds personnalisés

• Partage de workflows - Import/export au format JSON

Déploiement rapide sur CLORE.AI

Image Docker :

yanwk/comfyui-boot:cu130-slim

Ports :

22/tcp
8188/http

Environnement :

CLI_ARGS=--listen 0.0.0.0

Vérifier que cela fonctionne

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

# Vérifiez si l'interface est accessible (peut prendre 5 à 10 min au premier lancement)
curl https://your-http-pub.clorecloud.net/

Si vous obtenez un HTTP 502 pendant plus de 15 minutes, vérifiez :

1. Le serveur dispose de 16 Go+ de RAM

2. Le serveur dispose de 8 Go+ de VRAM pour SDXL, 16 Go+ pour FLUX

3. La vitesse du réseau est suffisante pour télécharger les modèles

Accéder à votre service

Lors du déploiement sur CLORE.AI, accédez à ComfyUI via la http_pub URL :

• Interface Web : https://your-http-pub.clorecloud.net/

• API : https://your-http-pub.clorecloud.net/prompt

• WebSocket : wss://your-http-pub.clorecloud.net/ws

Tous localhost:8188 les exemples ci-dessous fonctionnent lorsque vous êtes connecté via SSH. Pour un accès externe, remplacez par votre https://your-http-pub.clorecloud.net/ URL.

Installation

Utilisation de Docker (recommandé)

docker run -d --gpus all \\
  -p 8188:8188 \\
  -v comfyui-data:/root \\
  -e CLI_ARGS="--listen 0.0.0.0" \\
  yanwk/comfyui-boot:cu130-slim

Installation manuelle

# Cloner le dépôt
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

# Créer un environnement virtuel
python -m venv venv
source venv/bin/activate

# Installer PyTorch avec CUDA
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128

# Installer les dépendances
pip install -r requirements.txt

# Exécuter
python main.py --listen 0.0.0.0

Structure du répertoire

ComfyUI/
├── models/
│   ├── checkpoints/     # modèles SD (.safetensors)
│   ├── loras/           # modèles LoRA
│   ├── vae/             # modèles VAE
│   ├── controlnet/      # modèles ControlNet
│   ├── upscale_models/  # upscalers
│   └── clip/            # modèles CLIP
├── input/               # images d'entrée
├── output/              # images générées
└── custom_nodes/        # extensions

Télécharger les modèles

Checkpoints Stable Diffusion

cd ComfyUI/models/checkpoints

# SDXL Base
wget https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors

# SDXL Refiner
wget https://huggingface.co/stabilityai/stable-diffusion-xl-refiner-1.0/resolve/main/sd_xl_refiner_1.0.safetensors

# SD 1.5 (plus petit, plus rapide)
wget https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned.safetensors

# Realistic Vision (photoréaliste)
wget https://huggingface.co/SG161222/Realistic_Vision_V6.0_B1_noVAE/resolve/main/Realistic_Vision_V6.0_B1_fp16.safetensors

VAE

cd ComfyUI/models/vae

# VAE SDXL
wget https://huggingface.co/stabilityai/sdxl-vae/resolve/main/sdxl_vae.safetensors

# VAE SD 1.5 (meilleures couleurs)
wget https://huggingface.co/stabilityai/sd-vae-ft-mse-original/resolve/main/vae-ft-mse-840000-ema-pruned.safetensors

LoRAs

cd ComfyUI/models/loras

# Télécharger depuis CivitAI ou HuggingFace
# Placez les fichiers .safetensors ici

Workflow de base

Texte vers image

1. Ajouter des nœuds :

   • Charger un checkpoint → sélectionner le modèle

   • Encodage de texte CLIP (x2) → prompts positif et négatif

   • Image latente vide → définir les dimensions

   • KSampler → tout connecter

   • Décodage VAE → latent vers image

   • Enregistrer l'image → sortie

2. Connectez :

[Checkpoint] → MODEL → [KSampler]
[Checkpoint] → CLIP → [CLIP Text Encode +]
[Checkpoint] → CLIP → [CLIP Text Encode -]
[Checkpoint] → VAE → [VAE Decode]
[Text Encode +] → CONDITIONING → [KSampler]
[Text Encode -] → CONDITIONING → [KSampler]
[Empty Latent] → LATENT → [KSampler]
[KSampler] → LATENT → [VAE Decode]
[VAE Decode] → IMAGE → [Save Image]

Image vers image

Remplacer Image latente vide par :

1. Charger une image → votre image source

2. Encodage VAE → convertir en latent

3. Ajuster dénoiser dans KSampler (0,5-0,8)

ComfyUI Manager

ComfyUI Manager est une extension essentielle qui ajoute une interface graphique pour installer, mettre à jour et gérer les nœuds personnalisés. C'est la méthode standard pour étendre ComfyUI.

Installation

cd ComfyUI/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git
# Redémarrez ComfyUI — un bouton « Manager » apparaîtra dans la barre d'outils

Utilisation de ComfyUI Manager

Après le redémarrage, un Manager bouton apparaît en haut à droite de l'interface ComfyUI.

Fonctionnalités clés :

Fonctionnalité	Comment y accéder
Installer des nœuds personnalisés	Manager → Installer des nœuds personnalisés
Mettre à jour tous les nœuds	Manager → Tout mettre à jour
Désactiver/activer des nœuds	Manager → Gestionnaire de nœuds personnalisés
Installer les nœuds manquants	Manager → Installer les nœuds personnalisés manquants
Récupérer les informations du modèle	Manager → Gestionnaire de modèles
Restaurer un instantané	Manager → Gestionnaire d'instantanés

Workflow : installation d'un nouveau pack de nœuds

1. Cliquez sur Manager bouton

2. Sélectionnez Installer des nœuds personnalisés

3. Rechercher par nom (par ex. « FLUX », « AnimateDiff »)

4. Cliquez sur Installer sur le pack souhaité

5. Cliquez sur Redémarrer lorsque vous y êtes invité

6. Les nouveaux nœuds apparaissent dans le menu d'ajout au clic droit

Installation automatique des nœuds manquants : Lorsque vous importez un JSON de workflow qui utilise des nœuds que vous n'avez pas, Manager les détecte et propose de les installer automatiquement via Installer les nœuds personnalisés manquants.

Maintenir les nœuds à jour

# Depuis le CLI (alternative à l'interface graphique) :
cd ComfyUI/custom_nodes/ComfyUI-Manager
git pull

# Ou utilisez Manager → Tout mettre à jour dans l'interface

---

Workflow FLUX dans ComfyUI

FLUX utilise une structure de nœuds différente de celle des modèles SD standard. Vous trouverez ci-dessous un workflow complet FLUX.1-dev.

Fichiers requis

Avant d'exécuter le workflow, téléchargez :

# Modèle FLUX (dev ou schnell)
cd ComfyUI/models/unet
wget https://huggingface.co/black-forest-labs/FLUX.1-dev/resolve/main/flux1-dev.safetensors

# Encodeurs de texte
cd ../clip
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/clip_l.safetensors
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/t5xxl_fp16.safetensors

# VAE
cd ../vae
wget https://huggingface.co/black-forest-labs/FLUX.1-dev/resolve/main/ae.safetensors

JSON du workflow FLUX.1-dev

Enregistrer sous flux_dev_workflow.json et importer via Charger bouton dans ComfyUI :

{
  "last_node_id": 12,
  "last_link_id": 20,
  "nodes": [
    {
      "id": 1,
      "type": "UNETLoader",
      "pos": [100, 100],
      "size": [300, 60],
      "inputs": [],
      "outputs": [{"name": "MODEL", "type": "MODEL", "links": [1]}],
      "properties": {},
      "widgets_values": ["flux1-dev.safetensors", "default"]
    },
    {
      "id": 2,
      "type": "DualCLIPLoader",
      "pos": [100, 200],
      "size": [350, 80],
      "inputs": [],
      "outputs": [{"name": "CLIP", "type": "CLIP", "links": [2, 3]}],
      "properties": {},
      "widgets_values": ["clip_l.safetensors", "t5xxl_fp16.safetensors", "flux"]
    },
    {
      "id": 3,
      "type": "CLIPTextEncode",
      "pos": [500, 150],
      "size": [425, 180],
      "inputs": [{"name": "clip", "type": "CLIP", "link": 2}],
      "outputs": [{"name": "CONDITIONING", "type": "CONDITIONING", "links": [4]}],
      "properties": {},
      "widgets_values": ["Un paysage photoréaliste époustouflant, éclairage de l'heure dorée, 8K"]
    },
    {
      "id": 4,
      "type": "EmptySD3LatentImage",
      "pos": [100, 350],
      "size": [300, 100],
      "inputs": [],
      "outputs": [{"name": "LATENT", "type": "LATENT", "links": [5]}],
      "properties": {},
      "widgets_values": [1024, 1024, 1]
    },
    {
      "id": 5,
      "type": "ModelSamplingFlux",
      "pos": [500, 350],
      "size": [300, 80],
      "inputs": [{"name": "model", "type": "MODEL", "link": 1}],
      "outputs": [{"name": "MODEL", "type": "MODEL", "links": [6]}],
      "properties": {},
      "widgets_values": [1.15, 0.5, 1024, 1024]
    },
    {
      "id": 6,
      "type": "KSampler",
      "pos": [850, 250],
      "size": [350, 240],
      "inputs": [
        {"name": "model", "type": "MODEL", "link": 6},
        {"name": "positive", "type": "CONDITIONING", "link": 4},
        {"name": "negative", "type": "CONDITIONING", "link": 7},
        {"name": "latent_image", "type": "LATENT", "link": 5}
      ],
      "outputs": [{"name": "LATENT", "type": "LATENT", "links": [8]}],
      "properties": {},
      "widgets_values": [42, "fixed", 20, 3.5, "euler", "simple", 1.0]
    },
    {
      "id": 7,
      "type": "CLIPTextEncode",
      "pos": [500, 500],
      "size": [300, 60],
      "inputs": [{"name": "clip", "type": "CLIP", "link": 3}],
      "outputs": [{"name": "CONDITIONING", "type": "CONDITIONING", "links": [7]}],
      "properties": {},
      "widgets_values": [""]
    },
    {
      "id": 8,
      "type": "VAELoader",
      "pos": [100, 500],
      "size": [300, 60],
      "inputs": [],
      "outputs": [{"name": "VAE", "type": "VAE", "links": [9]}],
      "properties": {},
      "widgets_values": ["ae.safetensors"]
    },
    {
      "id": 9,
      "type": "VAEDecode",
      "pos": [1250, 300],
      "size": [210, 46],
      "inputs": [
        {"name": "samples", "type": "LATENT", "link": 8},
        {"name": "vae", "type": "VAE", "link": 9}
      ],
      "outputs": [{"name": "IMAGE", "type": "IMAGE", "links": [10]}],
      "properties": {}
    },
    {
      "id": 10,
      "type": "SaveImage",
      "pos": [1500, 300],
      "size": [300, 270],
      "inputs": [{"name": "images", "type": "IMAGE", "link": 10}],
      "outputs": [],
      "properties": {},
      "widgets_values": ["flux_output"]
    }
  ],
  "links": [
    [1, 1, 0, 5, 0, "MODEL"],
    [2, 2, 0, 3, 0, "CLIP"],
    [3, 2, 0, 7, 0, "CLIP"],
    [4, 3, 0, 6, 1, "CONDITIONING"],
    [5, 4, 0, 6, 3, "LATENT"],
    [6, 5, 0, 6, 0, "MODEL"],
    [7, 7, 0, 6, 2, "CONDITIONING"],
    [8, 6, 0, 9, 0, "LATENT"],
    [9, 8, 0, 9, 1, "VAE"],
    [10, 9, 0, 10, 0, "IMAGE"]
  ],
  "groups": [],
  "config": {},
  "extra": {"ds": {"scale": 0.8, "offset": [0, 0]}},
  "version": 0.4
}

Workflow FLUX.1-schnell (4 étapes)

Pour schnell, modifiez les paramètres de KSampler dans le JSON ci-dessus :

• num_inference_steps: 4

• cfg: 1.0

• ordonnanceur: "simple"

• Fichier du modèle : flux1-schnell.safetensors

Ou définissez via l'interface : KSampler → étapes : 4, cfg : 1.0, échantillonneur : euler, ordonnanceur : simple

Différences clés des nœuds : FLUX vs SD

Nœud	SD/SDXL	FLUX
Chargeur de modèle	Charger un checkpoint	UNETLoader
Encodeur de texte	CLIPTextEncode	DualCLIPLoader + CLIPTextEncode
Latent	Image latente vide	EmptySD3LatentImage
Supplémentaire	—	ModelSamplingFlux
Prompt négatif	Requis	Facultatif (laisser vide)

---

Nœuds personnalisés essentiels

Packs de nœuds recommandés

Pack de nœuds	GitHub	Cas d’utilisation
ComfyUI-Manager	ltdrdata/ComfyUI-Manager	Installer et gérer tous les autres nœuds
ComfyUI-FLUX	XLabs-AI/x-flux-comfyui	Nœuds ControlNet FLUX
was-node-suite	WASasquatch/was-node-suite-comfyui	Plus de 100 nœuds utilitaires
ComfyUI-Impact-Pack	ltdrdata/ComfyUI-Impact-Pack	Détection de visages, SAM, ADetailer
ComfyUI-Inspire-Pack	ltdrdata/ComfyUI-Inspire-Pack	Échantillonneurs avancés, workflows
ComfyUI-AnimateDiff	Kosinkadink/ComfyUI-AnimateDiff-Evolved	Génération de vidéo / animation
ComfyUI-VideoHelperSuite	Kosinkadink/ComfyUI-VideoHelperSuite	Gestion des E/S vidéo
ComfyUI-GGUF	city96/ComfyUI-GGUF	Exécuter des modèles GGUF quantifiés
ComfyUI-KJNodes	kijai/ComfyUI-KJNodes	Nœuds utilitaires et de masque
rgthree-comfy	rgthree/rgthree-comfy	Assistants de workflow, meilleure interface

ComfyUI-FLUX (XLabs-AI)

Ajoute la prise en charge de ControlNet pour FLUX dans ComfyUI :

cd ComfyUI/custom_nodes
git clone https://github.com/XLabs-AI/x-flux-comfyui
cd x-flux-comfyui
pip install -r requirements.txt

Ajoute les nœuds : Appliquer ControlNet (FLUX), Charger le modèle ControlNet (FLUX), Échantillonneur XFlux

was-node-suite

Plus de 100 nœuds utilitaires pour des workflows avancés :

cd ComfyUI/custom_nodes
git clone https://github.com/WASasquatch/was-node-suite-comfyui
cd was-node-suite-comfyui
pip install -r requirements.txt

Nœuds clés : lot d'images, opérations sur le texte, analyse d'image, nœud cache, nœud bus, mise à l'échelle, opérations sur les masques

Installer via le gestionnaire

1. Cliquez sur Manager bouton

2. Installer des nœuds personnalisés

3. Rechercher et installer

4. Redémarrer ComfyUI

Workflows avancés

ControlNet

# Télécharger les modèles ControlNet
cd ComfyUI/models/controlnet

# Canny
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_canny.pth

# Profondeur
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11f1p_sd15_depth.pth

# OpenPose
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_openpose.pth

Workflow :

1. Charger l'image → Détecteur de contours Canny

2. Appliquer ControlNet → KSampler

3. Générer avec guidage de pose/de contour

Mise à l'échelle

# Télécharger l'upscaler
cd ComfyUI/models/upscale_models
wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth

Workflow :

1. Générer l'image à plus faible résolution (768x768)

2. Nœud Upscale Image (Model)

3. Optionnel : passage img2img pour plus de détails

SDXL + Refiner

1. Générer avec la base SDXL (étapes 1-20)

2. Passer le latent au raffineur SDXL (étapes 21-30)

3. Décoder le résultat final avec le VAE

Raccourcis clavier

Touche	Action
Ctrl+Entrée	Mettre l'invite en file d'attente
Ctrl+Maj+Entrée	Mettre l'invite en file d'attente (en tête)
Ctrl+Z	Annuler
Ctrl+Y	Rétablir
Ctrl+S	Enregistrer le workflow
Ctrl+O	Charger le workflow
Ctrl+A	Tout sélectionner
Suppr	Supprimer la sélection
Ctrl+M	Mettre le nœud en sourdine
Ctrl+B	Contourner le nœud

Utilisation de l’API

Mettre l'invite en file d'attente

import json
import urllib.request

# Pour un accès externe, utilisez votre URL http_pub :
SERVER = "your-http-pub.clorecloud.net"
# Ou via SSH : SERVER = "localhost:8188"

def queue_prompt(prompt, server=SERVER):
    data = json.dumps({"prompt": prompt}).encode('utf-8')
    req = urllib.request.Request(f"https://{server}/prompt", data=data)
    urllib.request.urlopen(req)

# Charger le JSON du workflow et mettre en file d'attente
with open("workflow.json") as f:
    workflow = json.load(f)
queue_prompt(workflow)

WebSocket pour la progression

import websocket
import json

# Pour un accès externe, utilisez wss:// avec votre URL http_pub
ws = websocket.WebSocket()
ws.connect(f"wss://{SERVER}/ws")

while True:
    msg = json.loads(ws.recv())
    if msg['type'] == 'progress':
        print(f"Étape {msg['data']['value']}/{msg['data']['max']}")
    elif msg['type'] == 'executed':
        print("Terminé !")
        break

Conseils de performance

1. Activer --lowvram pour <8 Go de VRAM

2. Utiliser fp16 modèles si possible

3. Taille du lot 1 pour une VRAM limitée

4. VAE en tuiles pour les images haute résolution

5. Désactiver l'aperçu pour une génération plus rapide

Exigences GPU

Modèle	VRAM minimale	VRAM recommandée	RAM minimale
SD 1.5	4 Go	8 Go	16 Go
SDXL	8 Go	12 Go	16 Go
SDXL + ControlNet	10GB	16 Go	16 Go
FLUX	16 Go	24GB	32 Go

Préréglages GPU

RTX 3060 12 Go (économique)

# Lancer avec optimisations
python main.py --lowvram --force-fp16

# Paramètres recommandés :
# - SDXL : 768x768, lot 1
# - SD 1.5 : 512x512, lot 4
# - Utiliser le tuilage VAE
# - 20-30 étapes

Idéal pour : SD 1.5, SDXL (avec limites)

RTX 3090 24 Go (optimal)

# Lancement standard
python main.py --force-fp16

# Paramètres recommandés :
# - SDXL : 1024x1024, lot 2
# - FLUX schnell : 1024x1024, lot 1-2
# - ControlNet + SDXL fonctionne bien
# - 30-50 étapes

Idéal pour : SDXL, workflows ControlNet, FLUX modéré

RTX 4090 24 Go (performance)

# Lancement à pleine vitesse
python main.py

# Paramètres recommandés :
# - SDXL : 1024x1024, lot 4
# - FLUX dev : 1024x1024, lot 1-2
# - Workflows complexes avec plusieurs ControlNets
# - 50+ étapes pour la qualité

Idéal pour : FLUX, workflows complexes, génération par lots

A100 40 Go/80 Go (production)

# Performances maximales
python main.py --highvram

# Paramètres recommandés :
# - SDXL : 1024x1024, lot 8+
# - FLUX : 1024x1024, lot 2-4
# - Plusieurs modèles chargés simultanément
# - Sorties haute résolution (2048x2048)

Idéal pour : Charges de travail de production, FLUX, génération haute résolution

Estimation des coûts

Tarifs habituels de la place de marché CLORE.AI :

GPU	VRAM	Prix/jour	Vitesse SDXL
RTX 3060	12 Go	0,15–0,30 $	~15 s/image
RTX 3090	24GB	0,30–1,00 $	~8 s/image
RTX 4090	24GB	0,50–2,00 $	~4 s/image
A100	40 Go	1,50–3,00 $	~3 s/image

Prix en USD/jour. Les tarifs varient selon le fournisseur — vérifier la place de marché CLORE.AI les tarifs actuels.

Dépannage

HTTP 502 pendant longtemps

1. Vérifier la RAM : Le serveur doit avoir 16 Go+ de RAM

2. Vérifier la VRAM : 8 Go+ pour SDXL, 16 Go+ pour FLUX

3. Téléchargement des dépendances : La première exécution prend 5 à 10 min

4. Téléchargement du modèle : Les grands modèles prennent plus de temps

Mémoire insuffisante

# Exécuter en mode faible VRAM
python main.py --lowvram

# Ou forcer fp16
python main.py --force-fp16

Images noires

• Vérifier que le VAE est chargé

• Essayer un autre VAE

• Réduire la taille de l'image

Génération lente

• Activer CUDA

• Utiliser des modèles fp16

• Réduire les étapes (20 à 30 suffisent souvent)

Exemples de workflows

Importez ces workflows JSON dans ComfyUI :

• txt2img de base

• SDXL + Refiner

• ControlNet Canny

• Vidéo AnimateDiff

Étapes suivantes

• Guide ControlNet

• Mise à l’échelle Real-ESRGAN

• Entraînement Kohya - Entraîner des LoRA personnalisés

• Fooocus - Alternative plus simple