ComfyUI ist eine node-basierte Oberfläche für KI-Bildgenerierung mit Stable Diffusion. Sie bauen den Ablauf als Graph aus Bausteinen (Nodes) zusammen, vom Laden des Checkpoints über Prompt-Encoding und KSampler bis zum Speichern des Bildes. Das eignet sich für txt2img, img2img, ControlNet, LoRA und Video-Workflows. Diese Anleitung zeigt den Betrieb per Docker Compose auf einem Linux-Server (Debian 12 oder Ubuntu 24.04) mit NVIDIA-GPU, inklusive Persistenz, Modellen, ComfyUI-Manager und Reverse-Proxy.

Wichtig vorab: Es gibt kein offizielles ComfyUI-Docker-Image. Der Pull-Request Comfy-Org/ComfyUI#9305 für offiziellen Docker-Support wurde am 22.04.2026 ohne Übernahme geschlossen. Diese Anleitung nutzt deshalb das gepflegte Community-Image mmartial/comfyui-nvidia-docker, das auf den offiziellen NVIDIA-CUDA-Images aufbaut und den ComfyUI-Manager mitbringt.

Kurzfassung: Installieren Sie das NVIDIA Container Toolkit, legen Sie im Projektordner die Volume-Ordner und die compose.yaml an und starten Sie den Stack:

# GPU-Passthrough prüfen
docker run --rm --gpus all nvidia/cuda:12.8.0-base-ubuntu24.04 nvidia-smi
# Volumes anlegen und Stack hochfahren
mkdir run basedir
docker compose up -d

Danach ist die Web-UI unter http://127.0.0.1:8188 erreichbar. Modelle gehören nach basedir/models/, Updates laufen per docker compose pull && docker compose up -d. ComfyUI hat keinen Login: Veröffentlichen Sie es nur hinter einem Reverse-Proxy mit Authentifizierung.

Voraussetzungen

ComfyUI läuft auch ohne GPU, dann aber nur zum Ausprobieren brauchbar. Für den Einsatz planen Sie eine NVIDIA-GPU ein.

Server/OS: Linux mit Docker Engine und Docker Compose v2 (Debian 12 oder Ubuntu 24.04). Falls Docker noch fehlt, hilft unsere Einführung in Docker Compose und Stacks.
GPU: NVIDIA-Grafikkarte ab der 20er-Serie; für die 10er-Serie gibt es einen eigenen CUDA-12.6-Tag (siehe Schritt 3). Dazu ein NVIDIA-Treiber, der zur CUDA-Version des Image-Tags passt (nvidia-smi zeigt oben rechts die maximal unterstützte CUDA Version; für den aktuellen Tag mit CUDA 12.9 ist das Treiber 575 oder neuer), und das nvidia-container-toolkit.
VRAM: Stable Diffusion 1.5 ab 4 GB, SDXL ab 8 GB, FLUX deutlich mehr.
RAM/Speicher: mindestens 16 GB RAM, rund 20 GB für Image und Python-Umgebung plus 2 bis 25 GB je Modell. Verwenden Sie Modelle im Format .safetensors.
Domain (optional): nur nötig, wenn Sie ComfyUI über einen Reverse-Proxy mit HTTPS von außen erreichbar machen.

Hardware für diese Anleitung

Enthält Werbelinks

Grafikkarte mit viel VRAM	Der Grafikspeicher entscheidet, welche Modelle laufen. Faustregel bei 4-Bit-Quantisierung: 8 GB für 7–8B-Modelle, 16 GB für 14B, 24 GB für die 30B-Klasse.	Grafikkarten bei Amazon (Werbelink)
Arbeitsspeicher	32 GB RAM, damit Modelle, die nicht ganz in den Grafikspeicher passen, auf die CPU ausweichen können.	Bei Amazon ansehen (Werbelink)
Welche Karte passt?	Unsere Kaufberatung vergleicht die Karten nach VRAM und Budget.	Zur Kaufberatung

Vorhandene Hardware reicht oft. Die Liste zeigt, worauf es bei einem Neukauf ankommt. * Werbelink

Schritt 1: NVIDIA Container Toolkit installieren

Damit Container auf die GPU zugreifen, braucht Docker das nvidia-container-toolkit. Der NVIDIA-Treiber muss auf dem Host installiert sein (nvidia-smi zeigt die GPU). Richten Sie dann das Toolkit nach der NVIDIA-Anleitung ein:

# NVIDIA Container Toolkit (Debian 12 / Ubuntu 24.04)
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey \
  | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list \
  | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' \
  | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit
# Docker-Runtime für NVIDIA konfigurieren und Docker neu starten
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

Verifizieren: Ein Wegwerf-Container muss dieselbe nvidia-smi-Tabelle wie der Host zeigen:

docker run --rm --gpus all nvidia/cuda:12.8.0-base-ubuntu24.04 nvidia-smi

Schritt 2: Projektordner und Volumes anlegen

Legen Sie einen Ordner für den Stack an. Das Image nutzt zwei Volumes: /comfy/mnt (interner run/-Ordner mit venv, ComfyUI-Quelle und HuggingFace-Cache) und /basedir (der basedir/-Ordner mit models, input, output, custom_nodes und user). Legen Sie beide Ordner vor dem ersten Start als der Benutzer an, unter dem ComfyUI laufen soll, sonst legt Docker sie mit root-Rechten an.

sudo mkdir -p /opt/comfyui
sudo chown $(id -u):$(id -g) /opt/comfyui
cd /opt/comfyui
mkdir run basedir
# UID/GID des aktuellen Benutzers ermitteln (für die compose.yaml)
id -u
id -g

Die Ausgaben von id -u und id -g tragen Sie in Schritt 3 als WANTED_UID und WANTED_GID ein, damit die Dateirechte in den gemounteten Ordnern stimmen.

Verifizieren: ls -ld run basedir zeigt Ihren Benutzer als Besitzer.

Schritt 3: compose.yaml anlegen

Erstellen Sie in /opt/comfyui die Datei compose.yaml. Die Konfiguration bindet die Web-UI nur an 127.0.0.1, weil ComfyUI keine eigene Authentifizierung hat. Passen Sie WANTED_UID und WANTED_GID an Ihre Werte aus Schritt 2 an.

services:
  comfyui-nvidia:
    image: mmartial/comfyui-nvidia-docker:latest
    container_name: comfyui-nvidia
    init: true                  # leitet Stop-Signale sauber weiter
    ports:
      - 127.0.0.1:8188:8188   # nur lokal erreichbar; für LAN/Proxy: 8188:8188
    volumes:
      - ./run:/comfy/mnt
      - ./basedir:/basedir
    restart: unless-stopped
    environment:
      - USE_UV=true             # schnellere Paketinstallation
      - WANTED_UID=1000         # an 'id -u' anpassen
      - WANTED_GID=1000         # an 'id -g' anpassen
      - BASE_DIRECTORY=/basedir
      - SECURITY_LEVEL=normal   # nicht leichtfertig auf 'weak' setzen
      - USE_NEW_MANAGER=true
      - NVIDIA_VISIBLE_DEVICES=all
      - NVIDIA_DRIVER_CAPABILITIES=all
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu, compute, utility]

Der Tag latest zeigt derzeit auf ubuntu24_cuda12.9-latest und wechselt mit neuen Releases die CUDA-Version. Damit ein Update nicht an einem zu alten Treiber scheitert, setzen Sie einen festen Tag, dessen CUDA-Version höchstens der von nvidia-smi angezeigten entspricht, zum Beispiel ubuntu24_cuda12.9-latest oder ubuntu24_cuda13.0-latest. Die Ubuntu-22-Tags sind abgekündigt. Für GTX-10er-Karten nutzen Sie ubuntu24_cuda12.6.3 und ergänzen PREINSTALL_TORCH=true sowie USE_PIPUPGRADE=false.

Verifizieren: docker compose config gibt die Konfiguration ohne Fehlermeldung aus.

Schritt 4: Stack starten und Logs prüfen

Starten Sie den Container. Der erste Start dauert 5 bis 15 Minuten, weil das Image im run/-Volume die Python-Umgebung, PyTorch und die ComfyUI-Quelle einrichtet.

docker compose up -d
docker compose logs -f comfyui-nvidia

Verifizieren: Das Log meldet To see the GUI go to: http://0.0.0.0:8188 und nennt unter Device: Ihre GPU (cuda:0 NVIDIA …). Mit Strg+C beenden Sie nur die Log-Anzeige, nicht den Container.

Schritt 5: Web-UI öffnen und Modelle ablegen

Rufen Sie die Oberfläche im Browser auf. Lokal ist das http://127.0.0.1:8188; arbeiten Sie per SSH auf dem Server, leiten Sie den Port per SSH-Tunnel weiter (ssh -L 8188:127.0.0.1:8188 user@SERVER-IP). ComfyUI benötigt mindestens einen Checkpoint, um Bilder zu erzeugen. Modelle liegen unter basedir/models/ in thematischen Unterordnern:

Unterordner	Inhalt
`checkpoints/`	Haupt-Modelle (SD1.5, SDXL, FLUX) als `.safetensors`
`vae/`	VAE-Dateien für bessere Farben und Details
`loras/`	LoRA-Feinabstimmungen
`controlnet/`	ControlNet-Modelle (Pose, Tiefe, Kanten)
`text_encoders/` (früher `clip/`), `clip_vision/`	Text- und Bild-Encoder
`upscale_models/`	Upscaler (z. B. ESRGAN)
`embeddings/`	Textual Inversions
`diffusion_models/` (früher `unet/`)	separate Diffusionsmodelle, etwa FLUX

Für den Einstieg eignet sich Stable Diffusion 1.5 (rund 4 GB). Laden Sie den Checkpoint direkt in den richtigen Ordner:

mkdir -p basedir/models/checkpoints
wget -O basedir/models/checkpoints/v1-5-pruned-emaonly.safetensors \
  https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5/resolve/main/v1-5-pruned-emaonly.safetensors

Laden Sie danach die Seite neu oder drücken Sie R (Modelle neu einlesen). Einen gemeinsamen Modellordner für mehrere Werkzeuge binden Sie über extra_model_paths.yaml ein.

Verifizieren: Im Node Load Checkpoint steht v1-5-pruned-emaonly.safetensors zur Auswahl.

Schritt 6: Erstes Bild mit dem Default-Workflow erzeugen

ComfyUI lädt beim Start automatisch einen Standard-txt2img-Graph. Die Nodes verknüpfen genau die Stable-Diffusion-Pipeline:

Load Checkpoint: der abgelegte Checkpoint.
CLIP Text Encode (positiv): der gewünschte Bildinhalt, z. B. a cozy reading nook, warm light, photorealistic.
CLIP Text Encode (negativ): was vermieden werden soll, z. B. blurry, lowres, deformed.
Empty Latent Image: Bildgröße und Batch-Anzahl (bei SD1.5 z. B. 512×512).
KSampler: Sampler, Steps und CFG-Skala; hier läuft die Diffusion.
VAE Decode und Save Image: wandeln das Latent in ein Bild um und speichern es.

Tragen Sie die Prompts ein, wählen Sie den Checkpoint und klicken Sie auf Run (ältere Versionen: Queue Prompt).

Verifizieren: Das Bild erscheint im Node Save Image und liegt als PNG unter basedir/output/. nvidia-smi zeigt während der Berechnung einen Python-Prozess auf der GPU.

Schritt 7: ComfyUI-Manager und Custom Nodes

Seit ComfyUI 0.5.0 ist der ComfyUI-Manager Teil von ComfyUI; das Image aktiviert ihn über USE_NEW_MANAGER=true. Damit installieren Sie Custom Nodes, laden fehlende Modelle nach und aktualisieren ComfyUI. Bei einer manuellen Installation aktivieren Sie ihn mit python main.py --enable-manager nach pip install -r manager_requirements.txt.

Custom Nodes führen beliebigen Code im Container aus. Belassen Sie SECURITY_LEVEL=normal und installieren Sie nur Nodes aus vertrauenswürdigen Quellen mit aktiver Pflege. Installierte Nodes landen unter basedir/custom_nodes/ und bleiben bei einem Neuaufbau des Containers erhalten.

Verifizieren: In der Menüleiste erscheint der Eintrag Manager; nach der Installation eines Nodes und dem Neustart liegt sein Ordner unter basedir/custom_nodes/.

Schritt 8: Reverse-Proxy mit HTTPS und Basic-Auth

Soll ComfyUI von außen erreichbar sein, geben Sie Port 8188 nicht direkt frei. Lassen Sie ComfyUI an 127.0.0.1 gebunden und setzen Sie einen Reverse-Proxy (Nginx, Caddy oder Traefik) mit Basic-Auth und HTTPS davor. Legen Sie zuerst den Benutzer an (htpasswd aus dem Paket apache2-utils):

sudo apt install apache2-utils
sudo htpasswd -c /etc/nginx/.htpasswd BENUTZERNAME

Ein minimaler Nginx-Block:

server {
    listen 443 ssl;
    server_name comfyui.example.de;
    client_max_body_size 100M;   # Bild-Uploads
    # ssl_certificate / ssl_certificate_key via Certbot (Let's Encrypt)
    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_read_timeout 3600s;   # lange Generierungen über WebSocket
    }
}

Verifizieren: sudo nginx -t meldet syntax is ok; curl -I https://comfyui.example.de liefert ohne Zugangsdaten 401, im Browser erscheint nach der Anmeldung die Oberfläche mit Fortschrittsanzeige.

Die Upgrade-Header sind nötig, weil ComfyUI WebSockets für Fortschrittsanzeigen nutzt. Zertifikat und HTTP-Umleitung beschreibt die Anleitung zum Nginx Reverse-Proxy mit TLS.

Schritt 9: Update und Backup

Sichern Sie vor einem Update basedir/. Das Update zieht das neueste Image und erstellt den Container neu:

docker compose pull
docker compose up -d

ComfyUI und Custom Nodes aktualisiert zusätzlich das Image beim Start (USE_PIPUPGRADE, Standard true) oder der ComfyUI-Manager. Beim Backup gilt: Nur Daten in den Volumes bleiben erhalten. Sichern Sie basedir/ mit Modellen, Workflows, Custom Nodes und Benutzerdaten:

cd /opt/comfyui
tar czf comfyui-backup-$(date +%F).tar.gz --exclude=basedir/models basedir/ compose.yaml

Modelle lassen sich neu herunterladen und sprengen schnell das Backup; sichern Sie basedir/models nur bei Bedarf separat.

Verifizieren: tar tzf comfyui-backup-*.tar.gz | head listet basedir/user/ mit Ihren Workflows; nach dem Update zeigt das Log die neue ComfyUI-Version und die Web-UI lädt.

Den run/-Ordner müssen Sie nicht sichern; er wird beim nächsten Start neu aufgebaut. Dasselbe Schema passt für andere KI-Dienste, etwa aus der Anleitung zum Transkribieren von Audio und Video mit Whisper im Docker-Container.

Troubleshooting

Container startet nicht oder rechnet auf der CPU: meist fehlt das korrekt eingerichtete nvidia-container-toolkit oder der GPU-Zugriff. Prüfen Sie mit docker run --rm --gpus all nvidia/cuda:12.8.0-base-ubuntu24.04 nvidia-smi.
Log meldet CUDA driver version is insufficient: Der Image-Tag braucht eine neuere CUDA-Version, als der Treiber unterstützt. Wählen Sie einen Tag mit niedrigerer CUDA-Version oder aktualisieren Sie den Treiber.
CUDA out of memory: klassischer VRAM-Mangel. SDXL und FLUX brauchen deutlich mehr VRAM als SD1.5. Abhilfe: kleineres Modell, geringere Bildgröße oder COMFY_CMDLINE_EXTRA=--lowvram in der compose.yaml.
Modell erscheint nicht im Loader-Node: liegt es im richtigen Unterordner (z. B. basedir/models/checkpoints/) und ist es ein .safetensors? Danach die Seite neu laden.
Schreibrechte-Fehler in den Ordnern: WANTED_UID / WANTED_GID stimmen nicht mit dem Host-Benutzer überein. Auf id -u / id -g setzen und sicherstellen, dass run/ und basedir/ vor dem ersten Start existierten.
Erster Start dauert lange: normal, im run/-Volume werden Python-Umgebung und ComfyUI eingerichtet. Den Fortschritt zeigt docker compose logs -f.

Häufige Fragen

Gibt es ein offizielles ComfyUI-Docker-Image?

Nein, siehe Einleitung.

Geht ComfyUI auch ohne GPU?

Ja, mit dem Startparameter --cpu (im Container per COMFY_CMDLINE_EXTRA=--cpu), aber ein SD-1.5-Bild dauert dann Minuten statt Sekunden. Für den regelmäßigen Einsatz brauchen Sie eine NVIDIA-GPU.

Wie viel VRAM brauche ich?

SD 1.5 ab 4 GB, SDXL ab 8 GB, FLUX deutlich mehr; Details siehe Voraussetzungen und Troubleshooting.

Wohin gehören meine Modelle?

In den passenden Unterordner unter basedir/models/, siehe Tabelle in Schritt 5.

Ist die Web-UI passwortgeschützt?

Nein. Schützen Sie den Zugriff wie in Schritt 8 beschrieben.

Wie bekomme ich Updates?

Per docker compose pull && docker compose up -d nach einem Backup, siehe Schritt 9.

Fazit

Mit dem Community-Image mmartial/comfyui-nvidia-docker läuft ComfyUI als Docker-Compose-Stack: GPU-Zugriff über das NVIDIA Container Toolkit, Persistenz über run/ und basedir/, Modelle in den passenden Unterordnern und der ComfyUI-Manager für Custom Nodes. Entscheidend sind ein Image-Tag passend zum Treiber, genug VRAM für das Modell und ein Reverse-Proxy mit Authentifizierung, bevor ComfyUI von außen erreichbar ist.

Weiterführende Anleitungen und Quellen

Passend dazu aus unserem Wissensbereich:

Quellen:

ComfyUI – offizielles GitHub-Repo (README, Installation, GPU/Modelle): github.com/Comfy-Org/ComfyUI
NVIDIA Container Toolkit – Installationsanleitung: docs.nvidia.com
ComfyUI Official Documentation – Models (Verzeichnisstruktur): docs.comfy.org/development/core-concepts/models
mmartial/ComfyUI-Nvidia-Docker – Community Docker-Image: github.com/mmartial/ComfyUI-Nvidia-Docker
Comfy-Org/ComfyUI PR #9305 – geschlossener Pull-Request für offiziellen Docker-Support: github.com/Comfy-Org/ComfyUI/pull/9305