ComfyUI ist eine node-basierte Oberfläche für KI-Bildgenerierung mit Stable Diffusion. Statt eines starren Formulars baust du den Generierungs-Ablauf als Graph aus einzelnen Bausteinen (Nodes) zusammen – vom Laden des Checkpoints über Prompt-Encoding und KSampler bis zum Speichern des Bildes. Das macht ComfyUI extrem flexibel für txt2img, img2img, ControlNet, LoRA oder Video-Workflows und gleichzeitig sparsam mit VRAM. In dieser Anleitung self-hostest du ComfyUI per Docker Compose auf einem Linux-Server (Debian 12 / Ubuntu 24.04) – idealerweise mit NVIDIA-GPU – und richtest Persistenz, Modelle, den ComfyUI-Manager und einen Reverse-Proxy ein.

Wichtig vorab: Es gibt kein offizielles ComfyUI-Docker-Image. Ein entsprechender Pull-Request (Comfy-Org/ComfyUI#9305) wurde am 22.04.2026 abgelehnt – das Projekt überlässt Docker bewusst der Community. Wir nutzen daher das gut gepflegte Community-Image mmartial/comfyui-nvidia-docker, das auf den offiziellen NVIDIA-CUDA-Containern aufbaut und den ComfyUI-Manager bereits integriert hat. (Auch AUTOMATIC1111 / Stable Diffusion WebUI hat übrigens kein offizielles Docker-Image.)

Kurzfassung: NVIDIA Container Toolkit installieren, dann im Projektordner die Volume-Ordner anlegen und den Stack starten:

# 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/checkpoints/ & Co. Updates per docker compose pull && docker compose up -d.

Voraussetzungen

Bevor du startest, sollte die Basis stehen. ComfyUI läuft technisch auch ohne GPU, dann aber unbrauchbar langsam – plane für ernsthafte Nutzung 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 dir unsere Einführung in Docker Compose und Stacks.
GPU (empfohlen): NVIDIA-Grafikkarte, offiziell die 20er-Serie und neuer (für die 10er-Serie gibt es einen separaten CUDA-12.6-Build). Dazu aktuelle NVIDIA-Treiber und das nvidia-container-toolkit.
VRAM: der eigentliche Engpass. Faustwerte: Stable Diffusion 1.5 ca. 4–6 GB, SDXL ca. 8–12 GB, FLUX deutlich mehr. Zu wenig VRAM führt zu CUDA out of memory.
RAM/Storage: einige GB RAM und reichlich Plattenplatz – pro Checkpoint mehrere GB. Modelle im Format .safetensors sind empfohlen.
Domain (optional): nur nötig, wenn du ComfyUI über einen Reverse-Proxy mit HTTPS von außerhalb erreichbar machen willst.

Schritt 1: NVIDIA Container Toolkit installieren

Damit Docker-Container auf die GPU zugreifen können, brauchst du das nvidia-container-toolkit. Die NVIDIA-Treiber müssen auf dem Host bereits installiert sein (Test: nvidia-smi auf dem Host). Anschließend richtest du das Toolkit 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

Danach prüfst du den GPU-Passthrough mit einem Wegwerf-Container. Erscheint die Tabelle von nvidia-smi, ist alles bereit:

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

Schritt 2: Projektordner und Volumes anlegen

Lege 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). Beide Ordner müssen vor dem ersten Start existieren.

mkdir -p /opt/comfyui
cd /opt/comfyui
mkdir run basedir

# UID/GID des aktuellen Benutzers ermitteln (für die compose.yaml)
id -u
id -g

Merke dir die Ausgaben von id -u und id -g – sie kommen gleich als WANTED_UID und WANTED_GID in die Konfiguration, damit die Dateirechte in den gemounteten Ordnern stimmen.

Schritt 3: compose.yaml anlegen

Erstelle im Ordner /opt/comfyui die Datei compose.yaml. Diese Konfiguration bindet die Web-UI bewusst nur an 127.0.0.1 – ComfyUI hat keine eigene Authentifizierung, deshalb nie ungeschützt ins Netz stellen. Passe WANTED_UID / WANTED_GID an deine Werte aus Schritt 2 an.

services:
  comfyui-nvidia:
    image: mmartial/comfyui-nvidia-docker:latest
    container_name: comfyui-nvidia
    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 aktuell auf ubuntu24_cuda12.8-latest. Wenn du eine feste Version willst, kannst du stattdessen einen konkreten Tag setzen, etwa ubuntu24_cuda12.6.3 oder ubuntu22_cuda12.4-latest. Besitzer einer NVIDIA-10er-Karte greifen zum passenden CUDA-12.6-Build.

Schritt 4: Stack starten und Logs prüfen

Jetzt startest du den Container. Der erste Start dauert länger, weil das Image im run/-Volume erst die Python-venv und die ComfyUI-Quelle einrichtet. Beobachte die Logs, bis ComfyUI meldet, dass es auf Port 8188 lauscht.

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

Mit Strg+C beendest du nur die Log-Anzeige, nicht den Container. Falls du keine GPU hast und nur testen willst, ist ein CPU-Betrieb über das offizielle ComfyUI mit main.py --cpu möglich – aber wirklich nur zum Ausprobieren, da extrem langsam:

# Nur zum Vergleich, CPU-only und sehr langsam (manuelle ComfyUI-Installation)
python main.py --cpu --listen 0.0.0.0 --port 8188

Schritt 5: Web-UI öffnen und Modelle ablegen

Rufe die Oberfläche im Browser auf. Lokal ist das http://127.0.0.1:8188; wenn du nur per SSH auf dem Server bist, leite 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)
`clip/`, `clip_vision/`	Text- und Bild-Encoder
`upscale_models/`	Upscaler (z. B. ESRGAN)
`embeddings/`	Textual Inversions
`diffusion_models/` (bzw. `unet/`)	separate Diffusionsmodelle

Ein klassischer Einstieg ist Stable Diffusion 1.5. Lade 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/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned-emaonly.safetensors

Nach dem Ablegen klickst du in der UI auf Refresh (oder lädst die Seite neu), sonst taucht das Modell im Loader-Node nicht auf. Wer mehrere Tools die gleichen Modelle nutzen lassen will, kann über extra_model_paths.yaml auf einen zentralen Modellordner verweisen – der Code durchsucht Unterordner und folgt auch Symlinks.

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 – wähle hier deinen gerade abgelegten Checkpoint aus.
CLIP Text Encode (positiv) – dein gewünschter 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 passiert die eigentliche Diffusion.
VAE Decode → Save Image – das Latent wird in ein Bild umgewandelt und gespeichert.

Trage Prompts ein, wähle den Checkpoint und klicke auf Queue (bzw. Run). Das fertige Bild erscheint im Save-Image-Node und liegt zusätzlich unter basedir/output/. Damit hast du deine erste KI-Bildgenerierung erfolgreich durchlaufen.

Schritt 7: ComfyUI-Manager und Custom Nodes

Der ComfyUI-Manager ist im mmartial-Image bereits integriert (gesteuert über USE_NEW_MANAGER=true). Über ihn installierst du Custom Nodes, lädst fehlende Modelle nach und aktualisierst ComfyUI selbst. Beim offiziellen ComfyUI würde man ihn dagegen über python main.py --enable-manager (nach pip install -r manager_requirements.txt) aktivieren – im Container ist das schon erledigt.

Wichtig: Custom Nodes führen beliebigen Code aus. Das ist ein echtes Sicherheitsrisiko. Setze SECURITY_LEVEL nicht leichtfertig auf weak und installiere nur Nodes, denen du vertraust. Installierte Nodes landen unter basedir/custom_nodes/ und überleben so einen Container-Neuaufbau.

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

Soll ComfyUI von außerhalb erreichbar sein, stelle niemals Port 8188 direkt ins Internet. ComfyUI bringt keine Authentifizierung mit. Die saubere Lösung: an 127.0.0.1 gebunden lassen und einen Reverse-Proxy (Nginx, Caddy oder Traefik) mit Basic-Auth und HTTPS davorsetzen. So sieht ein minimaler Nginx-Block aus:

server {
    listen 443 ssl;
    server_name comfyui.DEINE-DOMAIN.de;

    # 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;
    }
}

Die Upgrade-Header sind wichtig, weil ComfyUI WebSockets für Live-Updates nutzt. Eine vollständige Schritt-für-Schritt-Variante inklusive Zertifikat von Let’s Encrypt findest du in unserer Anleitung zum Nginx Reverse-Proxy mit TLS.

Schritt 9: Update und Backup

Updates des Containers sind ein Zweizeiler. Dabei wird das neueste Image gezogen und der Stack neu erstellt:

docker compose pull
docker compose up -d

ComfyUI selbst und einzelne Custom Nodes lassen sich zusätzlich über den ComfyUI-Manager aktualisieren. Beim Backup gilt: Nur was in den Volumes liegt, überlebt einen Neuaufbau. Sichere daher den basedir/-Ordner – er enthält Modelle, Workflows, Custom Nodes und Benutzerdaten:

tar czf comfyui-backup-$(date +%F).tar.gz basedir/

Den run/-Ordner musst du nicht zwingend sichern; er wird beim nächsten Start bei Bedarf neu aufgebaut. Wer auch Whisper-Transkription oder andere KI-Dienste betreibt, kann das Backup-Schema einfach übernehmen – siehe etwa unsere 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üfe vorab mit docker run --rm --gpus all nvidia/cuda:12.8.0-base-ubuntu24.04 nvidia-smi.
CUDA out of memory: klassischer VRAM-Mangel. SDXL und FLUX brauchen deutlich mehr VRAM als SD1.5. Abhilfe: kleineres Modell, geringere Bildgröße, --lowvram bzw. im Notfall --cpu oder eine größere GPU.
Modell erscheint nicht im Loader-Node: liegt es im richtigen Unterordner (z. B. basedir/models/checkpoints/) und ist es ein .safetensors? Nach dem Ablegen Refresh in der UI klicken.
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 ewig: normal – im run/-Volume werden venv und ComfyUI eingerichtet. Mit docker compose logs -f den Fortschritt beobachten.

Häufige Fragen

Gibt es ein offizielles ComfyUI-Docker-Image?

Nein. Der PR Comfy-Org/ComfyUI#9305 für offiziellen Docker-Support wurde am 22.04.2026 abgelehnt; Docker bleibt Community-Sache. Deshalb nutzen wir hier das gepflegte Community-Image mmartial/comfyui-nvidia-docker.

Geht ComfyUI auch ohne GPU?

Technisch ja, über main.py --cpu, aber so langsam, dass es nur zum Ausprobieren taugt. Für produktive Bildgenerierung ist eine NVIDIA-GPU mit ausreichend VRAM praktisch Pflicht.

Wie viel VRAM brauche ich?

Als Faustwert: SD1.5 ca. 4–6 GB, SDXL ca. 8–12 GB, FLUX deutlich mehr. Reicht der VRAM nicht, kommt es zu CUDA out of memory – dann ein kleineres Modell oder den Low-VRAM-Modus nutzen.

Wohin gehören meine Modelle?

In den passenden Unterordner unter basedir/models/, also Checkpoints nach checkpoints/, LoRAs nach loras/, VAEs nach vae/ usw. – idealerweise als .safetensors. Danach in der UI Refresh klicken.

Ist die Web-UI passwortgeschützt?

Nein, ComfyUI hat von Haus aus keinen Login. Binde die UI an 127.0.0.1 und setze für externen Zugriff einen Reverse-Proxy mit Basic-Auth und HTTPS davor.

Wie bekomme ich Updates?

Für das Image: docker compose pull && docker compose up -d. ComfyUI und Custom Nodes lassen sich zusätzlich über den ComfyUI-Manager aktualisieren.

Fazit

Mit dem Community-Image mmartial/comfyui-nvidia-docker hast du ComfyUI in wenigen Schritten als sauberen Docker-Compose-Stack laufen: GPU-Zugriff über das NVIDIA Container Toolkit, Persistenz über die Volumes run/ und basedir/, Modelle in den richtigen Unterordnern und den ComfyUI-Manager für Custom Nodes. Achte auf die zwei wichtigsten Punkte: genügend VRAM für dein Modell und ein Reverse-Proxy mit Authentifizierung, bevor ComfyUI öffentlich erreichbar wird. Dann steht deiner node-basierten KI-Bildgenerierung auf dem eigenen Server nichts im Weg.

Weiterführende Anleitungen und Quellen

Passend dazu aus unserem Wissensbereich:

Quellen:

ComfyUI – offizielles GitHub-Repo (README, Installation, GPU/Modelle): github.com/comfyanonymous/ComfyUI
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 – abgelehnter offizieller Docker-Support: github.com/Comfy-Org/ComfyUI/pull/9305