Intelligence ArtificielleGuidesPublié le 18 mars 2026 à 12:20• 10 min de lecture

ComfyUI : installation avancée et workflows personnalisés

Installation manuelle de ComfyUI, configuration multi-GPU, chemins de modèles partagés, custom nodes, workflows avancés et optimisation VRAM. Guide technique complet.

ComfyUI : installation avancée et workflows personnalisés

Ce guide couvre l'installation manuelle de ComfyUI, la configuration fine de l'environnement, le partage de modèles entre instances, l'ajout de custom nodes, et l'optimisation des performances GPU. On vise une installation propre, reproductible et maintenable.

Prérequis

Python 3.10 à 3.13 (Miniconda ou pyenv recommandé)
Git
GPU NVIDIA avec CUDA 12.x (6+ Go VRAM), GPU AMD avec ROCm 6.0+, ou Mac Apple Silicon
30+ Go d'espace disque (modèles + cache)
Pilotes GPU à jour (NVIDIA 535+ pour CUDA 12.1)

Installation de l'environnement

Option A : Miniconda (recommandé)

bash

## Installer Miniconda (si pas déjà fait)
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash Miniconda3-latest-Linux-x86_64.sh -b -p $HOME/miniconda3
eval "$($HOME/miniconda3/bin/conda shell.bash hook)"
conda init

## Créer l'environnement dédié
conda create -n comfyui python=3.12 -y
conda activate comfyui

Option B : pyenv + venv

bash

## Installer la version Python souhaitée
pyenv install 3.12.8
pyenv local 3.12.8

## Créer un venv classique
python -m venv .venv
source .venv/bin/activate

Cloner et installer ComfyUI

bash

git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

Installer PyTorch selon le GPU

NVIDIA CUDA 12.1 (stable) :

bash

conda install pytorch torchvision torchaudio pytorch-cuda=12.1 -c pytorch -c nvidia

NVIDIA CUDA 12.6 (GPU séries 10xx et plus anciennes) :

bash

pip install torch torchvision torchaudio —index-url https://download.pytorch.org/whl/cu126

AMD ROCm 6.0 (Linux) :

bash

pip3 install torch torchvision torchaudio —index-url https://download.pytorch.org/whl/rocm6.0

Apple Silicon (macOS) :

bash

conda install pytorch-nightly::pytorch torchvision torchaudio -c pytorch-nightly

Installer les dépendances ComfyUI

bash

pip install -r requirements.txt

Vérifier l'installation PyTorch

bash

python -c "import torch; print(f'PyTorch {torch.__version__}'); print(f'CUDA disponible: {torch.cuda.is_available()}'); print(f'GPU: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else \"N/A\"}'); print(f'VRAM: {torch.cuda.get_device_properties(0).total_mem / 1e9:.1f} Go' if torch.cuda.is_available() else '')"

Sur macOS Apple Silicon :

bash

python -c "import torch; print(f'PyTorch {torch.__version__}'); print(f'MPS disponible: {torch.backends.mps.is_available()}')"

Lancement et options CLI

bash

## Lancement standard
python main.py

## Écouter sur toutes les interfaces (accès réseau local)
python main.py —listen 0.0.0.0

## Port personnalisé
python main.py —port 8190

## Mode basse VRAM (GPU < 6 Go)
python main.py —lowvram

## Mode CPU uniquement (lent mais fonctionnel)
python main.py —cpu

## Désactiver les nœuds API cloud
python main.py —disable-api-nodes

## Preview haute qualité avec TAESD
python main.py —preview-method taesd

## Utiliser un GPU spécifique (multi-GPU)
CUDA_VISIBLE_DEVICES=1 python main.py

## Combiner plusieurs options
python main.py —listen 0.0.0.0 —port 8190 —preview-method taesd

Structure des répertoires modèles

ComfyUI organise les modèles dans des sous-dossiers spécifiques :

terminal

ComfyUI/models/
├── checkpoints/      # Modèles principaux (.safetensors, .ckpt)
├── clip/             # Modèles CLIP (encodeurs texte)
├── clip_vision/      # Modèles CLIP vision
├── controlnet/       # Modèles ControlNet
├── diffusion_models/ # Modèles de diffusion standalone (Flux, etc.)
├── embeddings/       # Embeddings / textual inversion
├── loras/            # LoRA et LyCORIS
├── style_models/     # Modèles de style
├── upscale_models/   # Upscalers (ESRGAN, SwinIR, etc.)
└── vae/              # Autoencodeurs variationnels

Partager les modèles entre instances

Si vous avez plusieurs installations (ComfyUI + AUTOMATIC1111, ou plusieurs ComfyUI), vous pouvez pointer vers un répertoire commun.

Copiez le fichier d'exemple :

bash

cp extra_model_paths.yaml.example extra_model_paths.yaml

Éditez extra_model_paths.yaml :

yaml

## Modèles partagés sur un disque dédié
shared_models:
    base_path: /data/ai-models/
    is_default: true
    checkpoints: checkpoints/
    clip: clip/
    clip_vision: clip_vision/
    controlnet: controlnet/
    diffusion_models: diffusion_models/
    embeddings: embeddings/
    loras: loras/
    upscale_models: upscale_models/
    vae: vae/

## Compatibilité avec une install AUTOMATIC1111 existante
a111:
    base_path: /home/user/stable-diffusion-webui/
    checkpoints: models/Stable-diffusion
    vae: models/VAE
    loras: |
        models/Lora
        models/LyCORIS
    embeddings: embeddings
    controlnet: models/ControlNet

Redémarrez ComfyUI après toute modification.

Gestion des custom nodes

ComfyUI Manager

L'extension indispensable pour gérer les custom nodes :

bash

cd custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git
cd ..
python main.py

Après redémarrage, le bouton « Manager » dans l'interface permet :

Installer/désinstaller des custom nodes
Détecter les nœuds manquants dans un workflow importé
Mettre à jour les extensions installées

Installation manuelle de custom nodes

bash

cd custom_nodes
## Exemple : installer ComfyUI-Impact-Pack
git clone https://github.com/ltdrdata/ComfyUI-Impact-Pack.git
cd ComfyUI-Impact-Pack
pip install -r requirements.txt
cd ../..
python main.py

Custom nodes populaires

| Extension | Usage |

|—-|—-|

| ComfyUI-Impact-Pack | Détection de visages, segmentation, détail |

| ComfyUI-Inspire-Pack | Nœuds utilitaires avancés |

| ComfyUI-AnimateDiff-Evolved | Animation / vidéo à partir d'images |

| ComfyUI_IPAdapter_plus | Transfert de style par image de référence |

| ComfyUI-KJNodes | Collection de nœuds utilitaires |

| rgthree-comfy | Nœuds de QoL (reroute, seed, etc.) |

Workflows avancés

Workflow img2img avec ControlNet

Un workflow classique pour guider la génération depuis une image existante :

Ajoutez un nœud Load Image (source d'entrée)
Connectez-le à un nœud ControlNet Apply avec un modèle ControlNet Canny ou Depth
Le ControlNet Apply se branche sur le KSampler via le conditioning
Ajustez le strength du ControlNet entre 0.4 et 0.8 selon le niveau de fidélité souhaité

Workflow Hires Fix (upscale en deux passes)

Pour des images haute résolution sans artefacts :

Première passe : génération à 512x512 (SD1.5) ou 1024x1024 (SDXL)
Nœud Upscale Latent ou Upscale Image (facteur 1.5x à 2x)
Second KSampler avec denoise entre 0.3 et 0.5
VAE Decode et Save Image

Workflow avec Flux

Pour les modèles Flux (plus récents, meilleure qualité) :

Nœud Load Diffusion Model (pas Load Checkpoint, Flux utilise un format séparé)
Nœuds DualCLIPLoader pour charger les deux encodeurs texte
Nœud Load VAE séparé
Le reste du pipeline est similaire (KSampler, VAE Decode, Save)

Les modèles Flux se placent dans models/diffusion_models/ (pas checkpoints).

Optimisation des performances

Gestion de la VRAM

bash

## Mode auto (par défaut, adapte selon la VRAM détectée)
python main.py

## Forcer le mode basse VRAM (4-6 Go)
python main.py —lowvram

## Mode ultra-basse VRAM (moins de 4 Go)
python main.py —novram

## Forcer le calcul en FP16 (économise la VRAM)
python main.py —force-fp16

## Désactiver le smart memory (libère la VRAM entre les nœuds)
python main.py —disable-smart-memory

Taille d'image et VRAM nécessaire (indicatif)

|—-|—-|—-|—-|

| 512x512 | ~3 Go | ~5 Go | ~8 Go |

| 768x768 | ~4 Go | ~7 Go | ~10 Go |

| 1024x1024 | ~6 Go | ~10 Go | ~14 Go |

Previews haute qualité

Téléchargez les modèles TAESD pour des previews rapides pendant la génération :

bash

## Pour SD1.5/SDXL
wget -P models/vae_approx/ https://github.com/madebyollin/taesd/raw/main/taesd_decoder.pth
wget -P models/vae_approx/ https://github.com/madebyollin/taesd/raw/main/taesdxl_decoder.pth

Puis lancez avec :

bash

python main.py —preview-method taesd

Lancer ComfyUI comme service (Linux)

Pour un serveur dédié, créez un service systemd :

bash

sudo tee /etc/systemd/system/comfyui.service << 'EOF'
[Unit]
Description=ComfyUI Server
After=network.target

[Service]
Type=simple
User=comfyui
WorkingDirectory=/home/comfyui/ComfyUI
ExecStart=/home/comfyui/miniconda3/envs/comfyui/bin/python main.py —listen 0.0.0.0 —port 8188
Restart=on-failure
RestartSec=10
Environment=CUDA_VISIBLE_DEVICES=0

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable comfyui
sudo systemctl start comfyui

Vérifier le statut :

bash

sudo systemctl status comfyui
journalctl -u comfyui -f

Reverse proxy Nginx (accès distant sécurisé)

Si ComfyUI tourne sur un serveur distant, placez un reverse proxy devant :

nginx

server {
    listen 443 ssl;
    server_name comfyui.example.com;

    ssl_certificate /etc/letsencrypt/live/comfyui.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/comfyui.example.com/privkey.pem;

    # Authentification basique
    auth_basic "ComfyUI";
    auth_basic_user_file /etc/nginx/.htpasswd;

    location / {
        proxy_pass http://127.0.0.1:8188;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_read_timeout 300s;
        proxy_send_timeout 300s;
        client_max_body_size 100M;
    }
}

Les headers Upgrade et Connection sont nécessaires : ComfyUI utilise des WebSockets pour les previews en temps réel et la file de génération.

Créez le fichier .htpasswd :

bash

sudo apt install apache2-utils
sudo htpasswd -c /etc/nginx/.htpasswd comfyui_user
sudo nginx -t && sudo systemctl reload nginx

Script de mise à jour automatique

bash

#!/bin/bash
## update-comfyui.sh
set -e

COMFYUI_DIR="$HOME/ComfyUI"
LOG_FILE="$COMFYUI_DIR/update.log"

echo "[$(date)] Début de la mise à jour" >> "$LOG_FILE"

## Activer l'environnement
source "$HOME/miniconda3/etc/profile.d/conda.sh"
conda activate comfyui

## Mettre à jour ComfyUI
cd "$COMFYUI_DIR"
git pull >> "$LOG_FILE" 2>&1
pip install -r requirements.txt —quiet >> "$LOG_FILE" 2>&1

## Mettre à jour les custom nodes
for dir in custom_nodes/*/; do
    if [ -d "$dir/.git" ]; then
        echo "  Mise à jour: $dir" >> "$LOG_FILE"
        cd "$COMFYUI_DIR/$dir"
        git pull —quiet >> "$LOG_FILE" 2>&1
        if [ -f requirements.txt ]; then
            pip install -r requirements.txt —quiet >> "$LOG_FILE" 2>&1
        fi
    fi
done

echo "[$(date)] Mise à jour terminée" >> "$LOG_FILE"

## Redémarrer le service si actif
if systemctl is-active —quiet comfyui; then
    sudo systemctl restart comfyui
    echo "[$(date)] Service redémarré" >> "$LOG_FILE"
fi

Rendez-le exécutable et planifiez-le :

bash

chmod +x update-comfyui.sh
## Mise à jour hebdomadaire le dimanche à 4h
crontab -e
## Ajouter : 0 4 * * 0 /home/user/update-comfyui.sh

Dépannage

CUDA out of memory

terminal

torch.cuda.OutOfMemoryError: CUDA out of memory.

Solutions par ordre de priorité :

Réduire la résolution de l'image
Lancer avec —lowvram ou —novram
Ajouter —force-fp16
Fermer les autres applications GPU (navigateur, jeux)
Utiliser un modèle plus léger (SD1.5 au lieu de SDXL)

Nœuds manquants au chargement d'un workflow

terminal

Missing nodes: ['NodeName']

Avec ComfyUI Manager installé, cliquez « Manager » puis « Install Missing Custom Nodes ». Sans Manager :

bash

## Chercher le nom du nœud dans les repos GitHub
## puis cloner dans custom_nodes/
cd custom_nodes
git clone <url_du_repo>
pip install -r <repo>/requirements.txt

Erreur « No module named 'torch' »

L'environnement virtuel n'est pas activé :

bash

conda activate comfyui
## ou
source .venv/bin/activate

Le serveur ne répond pas sur le réseau local

Par défaut, ComfyUI écoute uniquement sur localhost. Lancez avec :

bash

python main.py —listen 0.0.0.0

Vérifiez aussi le pare-feu :

bash

sudo ufw allow 8188/tcp

Performances dégradées après mise à jour

Certaines mises à jour de PyTorch ou de custom nodes peuvent casser la compatibilité. Revenez à un commit stable :

bash

cd ComfyUI
git log —oneline -10
git checkout <commit_hash>
pip install -r requirements.txt

Images corrompues ou entièrement noires

Vérifiez que le VAE correspond au modèle utilisé. Certains checkpoints (surtout SD2.x) nécessitent un VAE spécifique. Ajoutez un nœud Load VAE explicite dans votre workflow.

Bonnes pratiques sécurité

Ne jamais exposer ComfyUI directement sur Internet sans authentification. Utilisez un reverse proxy avec auth basique ou un VPN
Le flag —disable-api-nodes empêche l'utilisation des nœuds cloud payants (utile sur un serveur partagé)
Les fichiers .ckpt (ancien format) peuvent contenir du code Python arbitraire. Préférez toujours les fichiers .safetensors
Si ComfyUI tourne comme service, utilisez un utilisateur dédié sans privilèges root
Mettez en place un pare-feu restrictif sur le port ComfyUI si le serveur est accessible depuis l'extérieur

—-

Vérifié mars 2026. ComfyUI suit un cycle de release hebdomadaire (~v0.7.x). Portable Windows avec Python 3.13 + CUDA 13.0. Desktop disponible Windows/macOS. Dépôt : github.com/Comfy-Org/ComfyUI

ComfyUI : installation avancée et workflows personnalisés