ComfyUI

Node-basierte Stable-Diffusion-Oberfläche mit ComfyUI auf Clore.ai

Knotenbasierte Oberfläche für Stable Diffusion mit maximaler Flexibilität auf CLORE.AI-GPUs.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

Serveranforderungen

Parameter	Minimum	Empfohlen
RAM	16 GB	32 GB+
VRAM	8 GB (SDXL)	12 GB+
Netzwerk	500 Mbit/s	1 Gbit/s+
Startzeit	5-10 Minuten	-

Startzeit: Beim ersten Start werden Abhängigkeiten und Modelle heruntergeladen (5–10 Minuten je nach Netzwerkgeschwindigkeit). HTTP 502 ist in dieser Zeit normal.

Wichtig: ComfyUI mit FLUX-Modellen benötigt 16 GB+ VRAM. Für SDXL mit ControlNet stellen Sie sicher, dass mindestens 10 GB VRAM vorhanden sind.

Warum ComfyUI?

• Knotenbasierter Workflow - Visuelle Programmierung zur Bildgenerierung

• Maximale Kontrolle - Jeden Schritt der Pipeline feinabstimmen

• Effizient - Geringerer VRAM-Verbrauch als Alternativen

• Erweiterbar - Riesiges Ökosystem an benutzerdefinierten Knoten

• Workflow-Freigabe - Import/Export als JSON

Schnellbereitstellung auf CLORE.AI

Docker-Image:

yanwk/comfyui-boot:cu130-slim

Ports:

22/tcp
8188/http

Umgebung:

CLI_ARGS=--listen 0.0.0.0

Prüfen, ob es funktioniert

Nach der Bereitstellung findest du deine http_pub URL in Meine Bestellungen:

# Prüfen, ob die UI zugänglich ist (beim ersten Start kann es 5–10 Min. dauern)
curl https://your-http-pub.clorecloud.net/

Wenn Sie länger als 15 Minuten HTTP 502 erhalten, prüfen Sie:

1. Server hat 16 GB+ RAM

2. Server hat 8 GB+ VRAM für SDXL, 16 GB+ für FLUX

3. Die Netzwerkgeschwindigkeit ist ausreichend, um Modelle herunterzuladen

Auf deinen Dienst zugreifen

Wenn auf CLORE.AI bereitgestellt, greifen Sie über die http_pub URL:

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

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

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

Alle localhost:8188 Die folgenden Beispiele funktionieren bei einer SSH-Verbindung. Für externen Zugriff ersetzen Sie https://your-http-pub.clorecloud.net/ die URL.

Installation

Verwendung von Docker (empfohlen)

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

Manuelle Installation

# Repository klonen
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

# Virtuelle Umgebung erstellen
python -m venv venv
source venv/bin/activate

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

# Abhängigkeiten installieren
pip install -r requirements.txt

# Ausführen
python main.py --listen 0.0.0.0

Verzeichnisstruktur

ComfyUI/
├── models/
│   ├── checkpoints/     # SD-Modelle (.safetensors)
│   ├── loras/           # LoRA-Modelle
│   ├── vae/             # VAE-Modelle
│   ├── controlnet/      # ControlNet-Modelle
│   ├── upscale_models/  # Hochskalierer
│   └── clip/            # CLIP-Modelle
├── input/               # Eingabebilder
├── output/              # Generierte Bilder
└── custom_nodes/        # Erweiterungen

Modelle herunterladen

Stable Diffusion-Checkpoints

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 (kleiner, schneller)
wget https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned.safetensors

# Realistic Vision (fotorealistisch)
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

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

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

LoRAs

cd ComfyUI/models/loras

# Von CivitAI oder HuggingFace herunterladen
# .safetensors-Dateien hier ablegen

Grundlegender Workflow

Text zu Bild

1. Knoten hinzufügen:

   • Checkpoint laden → Modell auswählen

   • CLIP-Text-Kodierung (x2) → positive und negative Prompts

   • Leeres Latent-Bild → Abmessungen festlegen

   • KSampler → alles verbinden

   • VAE-Decodierung → von Latent zu Bild

   • Bild speichern → Ausgabe

2. Verbinden:

[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]

Bild zu Bild

Ersetzen Leeres Latent-Bild durch:

1. Bild laden → Ihr Quellbild

2. VAE-Kodierung → in Latent umwandeln

3. Anpassen Entrauschen im KSampler (0.5–0.8)

ComfyUI Manager

ComfyUI Manager ist eine unverzichtbare Erweiterung die eine GUI zum Installieren, Aktualisieren und Verwalten von benutzerdefinierten Knoten hinzufügt. Es ist der Standardweg, ComfyUI zu erweitern.

Installation

cd ComfyUI/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git
# ComfyUI neu starten — in der Symbolleiste erscheint ein "Manager"-Button

Verwendung von ComfyUI Manager

Nach dem Neustart erscheint ein Manager -Button oben rechts in der ComfyUI-Oberfläche.

Wichtige Funktionen:

Funktion	Zugriffsmöglichkeiten
Benutzerdefinierte Knoten installieren	Manager → Benutzerdefinierte Knoten installieren
Alle Knoten aktualisieren	Manager → Alle aktualisieren
Knoten deaktivieren/aktivieren	Manager → Knoten-Manager für benutzerdefinierte Knoten
Fehlende Knoten installieren	Manager → Fehlende benutzerdefinierte Knoten installieren
Modellinformationen abrufen	Manager → Modell-Manager
Snapshot wiederherstellen	Manager → Snapshot-Manager

Workflow: Installation eines neuen Knotenpakets

1. Klicken Sie auf Manager Schaltfläche

2. Wähle Benutzerdefinierte Knoten installieren

3. Nach Namen suchen (z. B. "FLUX", "AnimateDiff")

4. Klicken Sie auf Installieren für das gewünschte Paket

5. Klicken Sie auf Neustarten wenn Sie dazu aufgefordert werden

6. Neue Knoten erscheinen im Hinzufügen-Menü per Rechtsklick

Fehlende Knoten automatisch installieren: Wenn Sie ein Workflow-JSON importieren, das Knoten verwendet, die Sie nicht haben, erkennt Manager sie und bietet an, sie automatisch zu installieren über Fehlende benutzerdefinierte Knoten installieren.

Knoten aktuell halten

# Über die CLI (Alternative zur GUI):
cd ComfyUI/custom_nodes/ComfyUI-Manager
git pull

# Oder verwenden Sie im UI Manager → Update All

---

FLUX-Workflow in ComfyUI

FLUX verwendet eine andere Knotenstruktur als Standard-SD-Modelle. Unten ist ein vollständiger FLUX.1-dev-Workflow.

Benötigte Dateien

Vor dem Ausführen des Workflows herunterladen:

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

# Text-Encoder
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

FLUX.1-dev-Workflow-JSON

Speichern unter flux_dev_workflow.json und importieren über die Laden Schaltfläche in 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": ["Eine atemberaubende fotorealistische Landschaft, Golden-Hour-Beleuchtung, 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
}

FLUX.1-schnell-Workflow (4 Schritte)

Für schnell ändern Sie die KSampler-Einstellungen im obigen JSON:

• num_inference_steps: 4

• cfg: 1.0

• scheduler: "simple"

• Modelldatei: flux1-schnell.safetensors

Oder über die UI festlegen: KSampler → Schritte: 4, cfg: 1.0, sampler: euler, scheduler: simple

Wichtige Knotenunterschiede: FLUX vs. SD

Knoten	SD/SDXL	FLUX
Modelllader	Checkpoint laden	UNETLoader
Text-Encoder	CLIPTextEncode	DualCLIPLoader + CLIPTextEncode
Latent	Leeres Latent-Bild	EmptySD3LatentImage
Extra	—	ModelSamplingFlux
Negativer Prompt	Erforderlich	Optional (leer lassen)

---

Wichtige benutzerdefinierte Nodes

Empfohlene Knotenpakete

Knotenpaket	GitHub	Anwendungsfall
ComfyUI-Manager	ltdrdata/ComfyUI-Manager	Alle anderen Knoten installieren und verwalten
ComfyUI-FLUX	XLabs-AI/x-flux-comfyui	FLUX-ControlNet-Knoten
was-node-suite	WASasquatch/was-node-suite-comfyui	100+ Utility-Knoten
ComfyUI-Impact-Pack	ltdrdata/ComfyUI-Impact-Pack	Gesichtserkennung, SAM, ADetailer
ComfyUI-Inspire-Pack	ltdrdata/ComfyUI-Inspire-Pack	Erweiterte Sampler, Workflows
ComfyUI-AnimateDiff	Kosinkadink/ComfyUI-AnimateDiff-Evolved	Video-/Animationsgenerierung
ComfyUI-VideoHelperSuite	Kosinkadink/ComfyUI-VideoHelperSuite	Video-I/O-Verarbeitung
ComfyUI-GGUF	city96/ComfyUI-GGUF	Quantisierte GGUF-Modelle ausführen
ComfyUI-KJNodes	kijai/ComfyUI-KJNodes	Hilfs- und Maskenknoten
rgthree-comfy	rgthree/rgthree-comfy	Workflow-Hilfen, bessere Benutzeroberfläche

ComfyUI-FLUX (XLabs-AI)

Fügt ControlNet-Unterstützung für FLUX in ComfyUI hinzu:

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

Fügt Knoten hinzu: Apply ControlNet (FLUX), Load ControlNet Model (FLUX), XFlux Sampler

was-node-suite

Über 100 Hilfsknoten für fortgeschrittene Workflows:

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

Wichtige Knoten: Bild-Batch, Textoperationen, Bildanalyse, Cache-Knoten, Bus-Knoten, Hochskalierung, Maskenoperationen

Über den Manager installieren

1. Klicken Sie auf Manager Schaltfläche

2. Benutzerdefinierte Knoten installieren

3. Suchen und installieren

4. ComfyUI neu starten

Erweiterte Workflows

ControlNet

# ControlNet-Modelle herunterladen
cd ComfyUI/models/controlnet

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

# Tiefe
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. Bild laden → Canny-Kantenerkennung

2. ControlNet anwenden → KSampler

3. Generieren mit Pose-/Kantenführung

Hochskalierung

# Upscaler herunterladen
cd ComfyUI/models/upscale_models
wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth

Workflow:

1. Bild in niedrigerer Auflösung generieren (768x768)

2. Knoten „Bild hochskalieren (Modell)“

3. Optional: img2img-Durchlauf für Details

SDXL + Refiner

1. Mit SDXL-Basis generieren (Schritte 1–20)

2. Latent an SDXL-Refiner übergeben (Schritte 21–30)

3. VAE dekodiert das Endergebnis

Tastenkombinationen

Taste	Aktion
Strg+Eingabe	Prompt in Warteschlange
Strg+Umschalt+Eingabe	Prompt vorne in Warteschlange
Strg+Z	Rückgängig
Strg+Y	Wiederholen
Strg+S	Workflow speichern
Strg+O	Workflow laden
Strg+A	Alles auswählen
Entf	Ausgewählte löschen
Strg+M	Knoten stummschalten
Strg+B	Knoten umgehen

API-Nutzung

Prompt in Warteschlange

import json
import urllib.request

# Für externen Zugriff verwende deine http_pub-URL:
SERVER = "your-http-pub.clorecloud.net"
# Oder per 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)

# Workflow-JSON laden und in die Warteschlange stellen
with open("workflow.json") as f:
    workflow = json.load(f)
queue_prompt(workflow)

WebSocket für den Fortschritt

import websocket
import json

# Für externen Zugriff verwende wss:// mit deiner http_pub-URL
ws = websocket.WebSocket()
ws.connect(f"wss://{SERVER}/ws")

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

Leistungstipps

1. --lowvram aktivieren für <8 GB VRAM

2. fp16 verwenden Modelle, wenn möglich

3. Batchgröße 1 bei begrenztem VRAM

4. Gekacheltes VAE für hochauflösende Bilder

5. Vorschau deaktivieren für schnellere Generierung

GPU-Anforderungen

Modell	Minimales VRAM	Empfohlenes VRAM	Min. RAM
SD 1.5	4 GB	8 GB	16 GB
SDXL	8 GB	12 GB	16 GB
SDXL + ControlNet	10 GB	16 GB	16 GB
FLUX	16 GB	24 GB	32 GB

GPU-Voreinstellungen

RTX 3060 12GB (Budget)

# Mit Optimierungen starten
python main.py --lowvram --force-fp16

# Empfohlene Einstellungen:
# - SDXL: 768x768, Batch 1
# - SD 1.5: 512x512, Batch 4
# - VAE-Kachelung verwenden
# - 20-30 Schritte

Am besten für: SD 1.5, SDXL (mit Einschränkungen)

RTX 3090 24GB (Optimal)

# Standardstart
python main.py --force-fp16

# Empfohlene Einstellungen:
# - SDXL: 1024x1024, Batch 2
# - FLUX schnell: 1024x1024, Batch 1
# - ControlNet + SDXL funktioniert gut
# - 30-50 Schritte

Am besten für: SDXL, ControlNet-Workflows, moderates FLUX

RTX 4090 24GB (Leistung)

# Start mit voller Geschwindigkeit
python main.py

# Empfohlene Einstellungen:
# - SDXL: 1024x1024, Batch 4
# - FLUX dev: 1024x1024, Batch 1-2
# - Komplexe Workflows mit mehreren ControlNets
# - 50+ Schritte für Qualität

Am besten für: FLUX, komplexe Workflows, Batch-Generierung

A100 40GB/80GB (Produktion)

# Maximale Leistung
python main.py --highvram

# Empfohlene Einstellungen:
# - SDXL: 1024x1024, Batch 8+
# - FLUX: 1024x1024, Batch 2-4
# - Mehrere Modelle gleichzeitig geladen
# - Hochauflösende Ausgaben (2048x2048)

Am besten für: Produktions-Workloads, FLUX, hochauflösende Generierung

Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise:

GPU	VRAM	Preis/Tag	SDXL-Geschwindigkeit
RTX 3060	12 GB	$0.15–0.30	~15 Sek./Bild
RTX 3090	24 GB	$0.30–1.00	~8 Sek./Bild
RTX 4090	24 GB	$0.50–2.00	~4 Sek./Bild
A100	40 GB	$1.50–3.00	~3 Sek./Bild

Preise in USD/Tag. Die Tarife variieren je nach Anbieter — prüfen CLORE.AI-Marktplatz für aktuelle Preise.

Fehlerbehebung

HTTP 502 über längere Zeit

1. RAM prüfen: Server muss über 16 GB+ RAM verfügen

2. VRAM prüfen: 8 GB+ für SDXL, 16 GB+ für FLUX

3. Abhängigkeiten werden heruntergeladen: Der erste Lauf dauert 5–10 Min.

4. Modell wird heruntergeladen: Große Modelle brauchen länger

Speicher erschöpft

# Im Low-VRAM-Modus ausführen
python main.py --lowvram

# Oder fp16 erzwingen
python main.py --force-fp16

Schwarze Bilder

• Prüfe, ob VAE geladen ist

• Versuche ein anderes VAE

• Bildgröße reduzieren

Langsame Generierung

• CUDA aktivieren

• fp16-Modelle verwenden

• Schritte reduzieren (20–30 reichen oft aus)

Workflow-Beispiele

Importiere diese JSON-Workflows in ComfyUI:

• Einfaches txt2img

• SDXL + Refiner

• ControlNet Canny

• AnimateDiff-Video

Nächste Schritte

• ControlNet-Anleitung

• Real-ESRGAN-Hochskalierung

• Kohya-Training - Benutzerdefinierte LoRAs trainieren

• Fooocus - Einfachere Alternative