Hardware eisen voor zelfgehoste AI image generator

Wat een zelfgehoste AI-afbeeldingsgenerator werkelijk nodig heeft

Een zelfgehoste AI-afbeeldingsgenerator bestaat uit één webapplicatie en één modelbestand. De applicatie is ComfyUI en deze draait op elke Linux-server. Het model bepaalt welke hardware u nodig heeft. Een checkpoint van het SDXL-type is één enkel bestand van 6.94 GB dat in het GPU-geheugen moet worden geladen. Dat ene feit bepaalt het volledige budget; bekijk daarom de onderstaande hardware-hiërarchie voordat u iets huurt.

De eerlijke samenvatting: een VPS die alleen op de CPU draait, kan de software installeren en uitvoeren. Hiermee kunnen afbeeldingen van 512x512 worden gegenereerd met een ouder Stable Diffusion 1.5-model in één tot twee minuten per afbeelding. Dezelfde server die SDXL draait op 1024x1024 doet er tien tot twintig minuten over per afbeelding. Dit is geen defecte configuratie. Het is een kwestie van rekenkunde, en deze handleiding legt dit uit.

Waarom de modelgrootte de machine bepaalt

Het genereren van afbeeldingen voert een denoising-loop uit. Een render van 30 stappen voert de denoiser, de UNet van SDXL, 30 keer uit over de afbeelding, waarbij elke pass elk UNet-gewicht inleest. De twee tekst-encoders draaien eenmaal vóór de loop en de VAE decodeert eenmaal erna; zij maken dus geen deel uit van de kosten per stap. De UNet van SDXL is bij half-precision 5,14 GB aan gewichten, dus in dit vereenvoudigde beeld verplaatst een render van 30 stappen ongeveer 154 GB aan gewichten door het geheugen voordat u een afbeelding ziet, en de tussenliggende tensors voegen daar nog meer aan toe.

Een GPU met 24 GB aan videogeheugen (VRAM, het geheugen dat naast de grafische chip is gesoldeerd) leest met honderden gigabytes per seconde en houdt alle 6,9 GB tegelijk vast. Een CPU VPS leest systeem-RAM met tientallen gigabytes per seconde en beschikt niet over matrix-hardware voor de convoluties, waardoor dezelfde loop één tot twee ordes van grootte langzamer draait. Dit is hetzelfde argument over geheugenbandbreedte dat geldt voor tekstmodellen, en het is de moeite waard om dit te lezen in combinatie met wanneer een VPS met een GPU daadwerkelijk het geld waard is.

Het genereren van afbeeldingen verschilt op één belangrijk punt van het genereren van tekst. Een chatmodel streamt tokens, waardoor een trage machine nog steeds bruikbaar aanvoelt omdat woorden verschijnen terwijl u leest. Een afbeelding verschijnt pas wanneer de laatste stap is voltooid. Traag betekent hier staren naar een voortgangsbalk.

De hardwareladder, met reële cijfers

Het onderstaande blok bevat typische waarden voor één SDXL-afbeelding op 1024x1024, 30 stappen, Euler-sampler, per juli 2026. Beschouw deze als een orde van grootte. Uw sampler, aantal stappen en resolutie beïnvloeden deze waarden.

[
  {
    "label": "8 vCPU VPS, no GPU",
    "seconds_per_image": 780
  },
  {
    "label": "8GB VRAM GPU",
    "seconds_per_image": 32
  },
  {
    "label": "12GB VRAM GPU",
    "seconds_per_image": 18
  },
  {
    "label": "24GB VRAM GPU",
    "seconds_per_image": 9
  }
]

De CPU-rij is 780 seconden, ongeveer dertien minuten. De 24 GB-kaart is 9 seconden. Dat is het verschil waarvoor u betaalt.

Lees de ladder op deze manier. Onder 8 GB VRAM draait SDXL nog steeds, omdat ComfyUI VRAM en systeem-RAM samen beheert en modelgewichten automatisch uitlagert. Sinds oktober 2026 stelt de README van het project de ondergrens op 4 GB VRAM plus 8 GB systeem-RAM, gebruikmakend van asynchrone gewichtstreaming. Uitlageren kost tijd bij elke stap, waardoor een 6 GB-kaart dichter bij een minuut per afbeelding uitkomt dan bij dertig seconden. Bij 8 GB past het basismodel en verloopt het renderen comfortabel. Bij 12 GB kunt u een ControlNet of twee naast het checkpoint behouden zonder uitlageren. Bij 24 GB kunt u SDXL plus de refiner plus upscaling in één workflow draaien, en LoRA-adapters trainen met ruimte over. Trainen past in minder dan dat: de SDXL-trainingshandleiding voor de kohya-ss sd-scripts trainer stelt dat LoRA-training kan worden gedaan met 8 GB GPU-geheugen, waarbij 10 GB wordt aanbevolen. Om dit te bereiken, wordt geadviseerd om alleen de U-Net te trainen, gradient checkpointing in te schakelen, de text encoder-outputs en latents te cachen, een 8-bit optimizer of Adafactor te gebruiken, en de LoRA-dim op een 8 GB-kaart te verlagen naar 4 tot 8. De LoRA-handleiding voor de kohya_ss GUI, die deze scripts verpakt, is voorzichtiger: deze adviseert een GPU met ten minste 12 GB geheugen voor LoRA-training.

Wat een CPU VPS wel en niet kan

Een CPU VPS kan meer dan men verwacht, maar minder dan de marketing suggereert. Wees specifiek over waar de grens ligt.

Een CPU VPS kan ComfyUI installeren, de webinterface aanbieden, uw modelbibliotheek opslaan, de wachtrij beheren en afbeeldingen genereren zonder dat er een GPU aanwezig is. Met Stable Diffusion 1.5 op 512x512 en 20 stappen kunt u rekenen op ongeveer 60 tot 150 seconden per afbeelding op 8 moderne vCPU's met 16 GB RAM. Voor een batch-taak die 's nachts draait, of een image-endpoint met een laag volume achter een wachtrij, is dat uitstekend bruikbaar.

Een CPU VPS is niet geschikt voor interactief werk. Het itereren op prompts vereist twintig renders per uur, en met dertien minuten per stuk haalt u er slechts vier. Het is ook niet geschikt voor training. LoRA fine-tuning op een CPU wordt gemeten in dagen, niet in uren; beschouw dit daarom als onmogelijk.

De geheugenregel voor CPU-only wijkt af van de GPU-regel. De gewichten worden in het systeem-RAM geladen, dus u heeft de modelgrootte plus werkgeheugen nodig: ongeveer 16 GB RAM voor SDXL en ongeveer 8 GB voor SD 1.5. Een server met 4 GB RAM zal ComfyUI wel starten, maar wordt tijdens de eerste render voortijdig beëindigd door de out-of-memory killer. Dit uit zich in het verdwijnen van het proces met Killed in dmesg, zonder dat er een Python-traceback verschijnt.

ComfyUI installeren op een machine met GPU

Dit zijn de upstream-commando's. Begin met een schone installatie van Ubuntu 24.04 waarbij de NVIDIA-driver al aanwezig is. Controleer eerst de driver, omdat elke latere foutmelding er hetzelfde uitziet zonder deze controle.

nvidia-smi

Dit moet een tabel weergeven met uw kaart en een CUDA-versie. command not found of NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver betekent dat de driver ontbreekt of dat de kernelmodule niet is geladen na een upgrade. Los dit op voordat u verdergaat, omdat ComfyUI anders stilzwijgend terugvalt op de CPU en u de software de schuld zult geven.

sudo apt update
sudo apt install -y git python3-venv python3-pip wget
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
python3 -m venv venv
. venv/bin/activate
pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu130
pip install -r requirements.txt

De virtuele omgeving is geen optioneel advies. PyTorch haalt een grote boom aan afhankelijkheden binnen, en het systeembreed installeren op een machine die ook andere zaken draait, is de manier om die andere zaken te verbreken. Controleer of PyTorch de kaart kan zien voordat u verdergaat.

python -c "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0))"

True plus de naam van uw kaart betekent dat de stack werkt. False betekent dat de wheel die u heeft geïnstalleerd niet overeenkomt met de driver, meestal omdat er al een CPU-only torch-wheel in de cache stond. Installeer opnieuw met de bovenstaande index-URL.

Een model ophalen en de schijfruimte plannen

ComfyUI wordt geleverd zonder gewichten. Checkpoints plaatst u in models/checkpoints, VAE-bestanden in models/vae en LoRA-adapters in models/loras.

cd ~/ComfyUI/models/checkpoints
wget https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors

Geef altijd de voorkeur aan .safetensors boven .ckpt. Een .ckpt-bestand is een gepickled Python-object; het laden hiervan voert code uit van de maker van het bestand. Het safetensors-formaat bevat enkel tensors, waardoor een kwaadaardig bestand geen code kan uitvoeren.

Opslag is de kostenpost die vaak wordt vergeten. Eén SDXL-basischeckpoint is 6.94 GB. De refiner voegt daar nog eens 6 GB aan toe. Een SDXL ControlNet-model varieert van 320 MB voor het kleine Canny-model tot 2.5 GB voor de volledige versie op halve precisie. Een upscaler is klein: het standaard Real-ESRGAN x4plus-model is 67 MB, de anime-variant is 17.9 MB en het anime-videomodel is 2.5 MB. Een LoRA varieert van enkele tientallen megabytes tot 787 MB voor de Hyper-SDXL-adapters van ByteDance. Wie dit proces leuk vindt, downloadt binnen een week een tweede en derde basismodel. Reserveer 100 GB schijfruimte voor een werkende installatie en houd ook de output-directory in de gaten: 1024x1024 PNG-bestanden zijn elk 1 tot 2 MB groot, en een onbeheerde batch vult een kleine schijf geruisloos. Plaats models/ en output/ op een volume dat u kunt uitbreiden en maak back-ups van uw workflow JSON-bestanden met bijvoorbeeld versleutelde incrementele back-ups naar objectopslag. De gewichten zijn opnieuw te downloaden. De workflows die u heeft afgesteld, zijn dat niet.

Start het proces en benader het veilig

cd ~/ComfyUI
. venv/bin/activate
python main.py --listen 127.0.0.1 --port 8188

ComfyUI draait op poort 8188. Voeg op een systeem zonder GPU --cpu toe; dit dwingt het gebruik van het CPU-pad af in plaats van te stoppen bij een ontbrekend CUDA-apparaat.

Bind de service aan 127.0.0.1, niet aan 0.0.0.0. ComfyUI ondersteunt inmiddels accounts, maar deze beveiligen uw server niet. De inlogoptie onder Settings, in de sectie User, koppelt u aan een Comfy-account; dit werkt ook bij een lokale installatie. De documentatie van Comfy vermeldt inlogmethoden via e-mail, Google, GitHub en API-keys. Volgens de documentatie biedt dit account toegang tot partner-nodes en Comfy Cloud-abonnementen; het is geen methode om uw eigen server met een wachtwoord te beveiligen. De vlag --multi-user schakelt enkel opslag per gebruiker in: per oktober 2026 haalt de server de gebruikersnaam uit een comfy-user-request header zonder een wachtwoord te controleren. Iedereen die de poort bereikt, kan taken in de wachtrij plaatsen, alle gegenereerde afbeeldingen inzien en, indien u de server startte met --enable-manager, custom nodes installeren. Dit staat gelijk aan willekeurige code-uitvoering op uw server. Benader de interface daarom via een SSH-tunnel vanaf uw laptop.

ssh -N -L 8188:127.0.0.1:8188 you@your-server

Open vervolgens http://127.0.0.1:8188 op uw lokale machine. Als u daadwerkelijke toegang voor meerdere gebruikers nodig heeft, plaats dan een reverse proxy met authenticatie voor de applicatie en laat de service gebonden aan localhost. Deze redenering geldt voor elke zelfgehoste service zonder authenticatie en is de standaardwerkwijze bij Docker Compose-implementaties op een VPS.

Draaiende houden onder systemd

Een render-wachtrij die stopt zodra uw SSH-sessie wordt beëindigd, is geen service. Draai deze als een comfy-gebruiker zonder inlogmogelijkheid, niet als uzelf: custom nodes zijn code en die code mag geen toegang hebben tot uw home-directory. Maak de gebruiker aan en verplaats de installatie naar de bijbehorende home-directory:

sudo useradd --system --create-home --home-dir /home/comfy --shell /usr/sbin/nologin comfy
sudo mv ~/ComfyUI /home/comfy/
sudo chown -R comfy:comfy /home/comfy/ComfyUI

De virtual environment blijft werken na de verplaatsing, omdat de unit direct het python-pad aanroept. Schrijf vervolgens /etc/systemd/system/comfyui.service.

[Unit]
Description=ComfyUI
After=network-online.target

[Service]
User=comfy
WorkingDirectory=/home/comfy/ComfyUI
ExecStart=/home/comfy/ComfyUI/venv/bin/python main.py --listen 127.0.0.1 --port 8188
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now comfyui
systemctl status comfyui

active (running) en een logregel met de tekst To see the GUI go to: http://127.0.0.1:8188 betekenen dat de service actief is. Let op: ExecStart benoemt de interpreter binnen de virtual environment direct, omdat systemd uw shell-profiel niet uitvoert en activate nooit plaatsvindt.

Het pragmatische advies per budget

Wilt u experimenteren met het genereren van afbeeldingen en zijn de kosten belangrijker dan de snelheid? Kies dan voor een CPU VPS met 16 GB RAM, draai SD 1.5 op 512x512 en accepteer een verwerkingstijd van één of twee minuten per afbeelding. Dit is het eerlijke startpunt en het kost een fractie van een systeem met een GPU. Het is tevens de juiste plek om de modellibrary en workflows te hosten terwijl u uw keuzes maakt.

Als u dagelijks prompts itereert, huur dan per uur een GPU met minimaal 12 GB VRAM bij een GPU-cloudprovider en schakel deze uit wanneer u klaar bent. Het genereren van afbeeldingen is een taak met pieken; een inactieve GPU die maandelijks wordt gefactureerd, is de meest voorkomende reden voor onnodig hoge kosten. Bewaar de checkpoints op goedkope block storage en mount deze.

Als u diensten aanbiedt aan anderen of regelmatig LoRA-adapters traint, plan dan 24 GB VRAM in op een machine die u in eigen beheer houdt. De sd-scripts SDXL-handleiding stelt dat LoRA-training mogelijk is met 8 GB, waarbij 10 GB wordt aanbevolen bij gebruik van de geheugenbesparende instellingen. De LoRA-handleiding van de kohya_ss GUI vereist minimaal 12 GB. De 24 GB uit de sd-scripts handleiding is bedoeld voor volledige SDXL fine-tuning bij een batch size van 1; een kaart met 24 GB dekt dus zowel LoRA-werkzaamheden als fine-tuning. Op dat punt verdient dezelfde machine zichzelf vaak terug door ook een lokaal taalmodel te draaien, zoals beschreven in self-hosting an LLM with Ollama.

Welke trede u ook kiest, meet uw eigen machine voordat u uitgaat van gepubliceerde cijfers. Plaats dezelfde prompt vijf keer in de wachtrij en lees het aantal seconden per iteratie af dat ComfyUI in de console weergeeft. Dat getal is uw werkelijke positie op de ladder.

FAQ

Kan ik Stable Diffusion draaien zonder GPU?

Ja. ComfyUI draait met python main.py --cpu en genereert echte afbeeldingen zonder dat er een grafische kaart aanwezig is. Reken op ongeveer 60 tot 150 seconden per afbeelding voor Stable Diffusion 1.5 op 512x512, en tien tot twintig minuten voor SDXL op 1024x1024, op 8 moderne vCPU's. Dit is bruikbaar voor batchverwerking 's nachts en endpoints met een laag volume. Het is niet geschikt voor snelle iteratie van prompts, en training is volledig onmogelijk.

Hoeveel VRAM heb ik nodig voor SDXL?

Met 8 GB draait SDXL comfortabel op 1024x1024. Daaronder verplaatst ComfyUI modelgewichten automatisch naar het systeem-RAM en blijft het werken. Sinds oktober 2026 vermeldt de README een ondergrens van 4 GB VRAM plus 8 GB systeem-RAM, waarbij elke verplaatste stap tijd kost. Met 12 GB kunt u een ControlNet naast het checkpoint laden, en 24 GB volstaat voor base, refiner en upscaling in één workflow. De kohya-ss sd-scripts handleiding stelt dat SDXL LoRA-training mogelijk is met 8 GB, waarbij 10 GB wordt aanbevolen, mits u de geheugenbesparende instellingen gebruikt. De LoRA-handleiding van de kohya_ss GUI vraagt echter om minimaal 12 GB. Volledige SDXL fine-tuning vereist 24 GB bij een batchgrootte van 1.

Hoeveel schijfruimte hebben de modellen nodig?

Het SDXL base-checkpoint alleen al is 6,94 GB, en de refiner voegt daar nog ongeveer 6 GB aan toe. SDXL ControlNet-modellen variëren van 320 MB tot 2,5 GB per stuk bij half-precision, LoRA-adapters van tientallen megabytes tot 787 MB, en Real-ESRGAN upscalers van 2,5 MB tot 67 MB. Reken op 100 GB voor een werkende installatie met enkele basismodellen, en bewaak de uitvoermap afzonderlijk, aangezien 1024x1024 PNG-bestanden elk 1 tot 2 MB groot zijn.

Is het veilig om ComfyUI bloot te stellen aan het openbare internet?

Nee. De Comfy-accountlogin in de instellingen van ComfyUI werkt vanuit een lokale installatie, maar geeft u toegang tot de partner-nodes en cloud-abonnementen van Comfy. Niets in de documentatie van Comfy presenteert dit als beveiliging voor uw server. De --multi-user-vlag scheidt alleen de opslag per gebruiker zonder een wachtwoord te controleren. Als ComfyUI-Manager is ingeschakeld, installeert de interface custom nodes; dit is Python-code die op uw server draait, dus een open poort betekent remote code execution. Bind de service aan 127.0.0.1, benader deze via een SSH-tunnel met ssh -N -L 8188:127.0.0.1:8188 you@your-server, en plaats een authenticerende reverse proxy ervoor als meer dan één persoon toegang nodig heeft.

Waarom werd mijn render beëindigd zonder foutmelding?

Als het proces verdwijnt met Killed in dmesg en er geen Python-traceback verschijnt, is dit de Linux out-of-memory killer en geen bug in ComfyUI. Op een systeem zonder GPU bevinden de gewichten zich in het systeem-RAM; SDXL heeft daarom ongeveer 16 GB nodig en SD 1.5 ongeveer 8 GB, plus werkgeheugen. Voeg RAM toe, voeg swap toe, of stap over naar een kleiner model en een lagere resolutie.