Self-hosted AI image generator: hardware అవసరాలు

self-hosted AI image generator కు నిజంగా అవసరమైనవి

self-hosted AI image generator‌లో ఒక web app మరియు ఒక model file ఉంటాయి. ఆ app ComfyUI, ఇది ఏ Linux box‌పైనైనా నడుస్తుంది. మీ hardware అవసరాలను నిర్ణయించేది model. SDXL-class checkpoint ఒకే 6.94 GB file‌గా ఉంటుంది. అది GPU memoryలో ఉండాలి. ఈ ఒక్క విషయం మొత్తం budget‌ను నిర్ణయిస్తుంది. అందువల్ల ఏదైనా rent చేయడానికి ముందు దిగువ hardware ladder‌ను చదవండి.

సూటిగా చెప్పాలంటే: CPU-only VPS software‌ను install చేసి అందించగలదు. పాత Stable Diffusion 1.5 model‌తో 512x512 పరిమాణంలో image‌ను ఒక్క నిమిషం లేదా రెండు నిమిషాల్లో generate చేయగలదు. అదే box‌లో SDXL‌ను 1024x1024 పరిమాణంలో నడిపితే ఒక్క image‌కు పది నుంచి ఇరవై నిమిషాలు పడుతుంది. ఇది setup విఫలమైందని అర్థం కాదు. ఇది లెక్కల ఫలితం. ఈ guide ఆ లెక్కలను వివరిస్తుంది.

మోడల్ పరిమాణమే యంత్రాన్ని నిర్ణయిస్తుంది

చిత్రం రూపొందించడానికి denoising loop నడుస్తుంది. 30-step render సమయంలో denoiser అయిన SDXL's UNet చిత్రంపై 30 సార్లు పనిచేస్తుంది. ప్రతి pass లో ప్రతి UNet weight చదవబడుతుంది. రెండు text encoderలు loop ప్రారంభానికి ముందు ఒక్కసారి మాత్రమే నడుస్తాయి. VAE loop పూర్తయిన తర్వాత ఒక్కసారి decode చేస్తుంది. అందువల్ల అవి ప్రతి step కు సంబంధించిన ఖర్చులో భాగం కావు. Half precision లో SDXL's UNet weights పరిమాణం 5.14 GB. కాబట్టి ఈ సరళీకృత అంచనాలో 30-step render సమయంలో చిత్రం కనిపించేలోపు సుమారు 154 GB weights memory ద్వారా తరలించబడతాయి. దీనికి intermediate tensors మరింత memory traffic ను జోడిస్తాయి.

24 GB video memory (VRAM, graphics chip పక్కనే solder చేసిన memory) కలిగిన GPU సెకనుకు వందల gigabytes వేగంతో చదవగలదు. అది మొత్తం 6.9 GB ను ఒకేసారి ఉంచగలదు. CPU VPS system RAM ను సెకనుకు కొన్ని tens of gigabytes వేగంతో మాత్రమే చదువుతుంది. Convolutionల కోసం దానికి matrix hardware ఉండదు. అందువల్ల అదే loop ఒకటి లేదా రెండు orders of magnitude నెమ్మదిగా నడుస్తుంది. Text models పనితీరును నిర్ణయించే memory-bandwidth కారణం ఇదే. దీనితో పాటు GPU ఉన్న VPS కు నిజంగా డబ్బు ఖర్చు చేయడం ఎప్పుడు సమంజసం చదవడం ఉపయోగకరం.

Image generation, text generationకు మధ్య ముఖ్యమైన ఒక తేడా ఉంది. Chat model tokens ను stream చేస్తుంది. అందువల్ల యంత్రం నెమ్మదిగా ఉన్నా పదాలు చదువుతున్నప్పుడు కనిపిస్తాయి కాబట్టి ఉపయోగించగలిగినట్లుగా అనిపిస్తుంది. చిత్రం మాత్రం చివరి step పూర్తయిన తర్వాత మాత్రమే కనిపిస్తుంది. నెమ్మదిగా ఉంటే progress bar ను చూస్తూ వేచి ఉండాలి.

వాస్తవ సంఖ్యలతో hardware స్థాయులు

క్రింది పట్టికలో 2026 జూలై నాటికి 1024x1024 పరిమాణం, 30 steps, Euler sampler ఉపయోగించిన ఒక SDXL image కు సంబంధించిన సాధారణ గణాంకాలు ఉన్నాయి. వీటిని సుమారు పరిమాణాలుగా పరిగణించండి. మీ sampler, step count, resolution ఆధారంగా ఇవి మారుతాయి.

[
  {
    "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
  }
]

CPU వరుసలో 780 seconds ఉన్నాయి. అంటే సుమారు thirteen minutes. 24 GB card కు 9 seconds పడుతుంది. మీరు కొనుగోలు చేస్తున్న ప్రధాన తేడా ఇదే.

ఈ hardware స్థాయులను ఇలా అర్థం చేసుకోండి. 8 GB VRAM కంటే తక్కువ ఉన్నా SDXL నడుస్తుంది. ComfyUI, VRAM మరియు system RAM ను కలిసి నిర్వహించి, model weights ను స్వయంచాలకంగా offload చేస్తుంది. 2026 అక్టోబర్ నాటికి, asynchronous weight streaming ఉపయోగించినప్పుడు కనీస అవసరం 4 GB VRAM మరియు 8 GB system RAM అని project README పేర్కొంటుంది. ప్రతి step లో offloading చేయాల్సి రావడం వల్ల సమయం పెరుగుతుంది. అందువల్ల 6 GB card పై image కు 30 seconds కంటే ఒక minute కు దగ్గరగా సమయం పడుతుంది.

8 GB వద్ద base model memory లో సరిపోతుంది. Render కూడా సౌకర్యవంతంగా నడుస్తుంది. 12 GB వద్ద checkpoint తో పాటు ఒకటి లేదా రెండు ControlNet models ను offloading లేకుండా memory లో ఉంచవచ్చు. 24 GB వద్ద ఒకే workflow లో SDXL, refiner, upscaling ను నడపవచ్చు. అదనంగా, తగినంత memory మిగిలి ఉండగానే LoRA adapters ను train చేయవచ్చు.

Training కు ఇంతకంటే తక్కువ memory కూడా సరిపోతుంది. kohya-ss sd-scripts trainer కోసం ఉన్న SDXL training guide ప్రకారం, LoRA training ను 8 GB GPU memory తో చేయవచ్చు. అయితే 10 GB సిఫారసు చేస్తుంది. 8 GB card పై ఈ స్థాయికి చేరుకోవడానికి U-Net ను మాత్రమే train చేయాలని, gradient checkpointing ను ప్రారంభించాలని, text encoder outputs మరియు latents ను cache చేయాలని guide సూచిస్తుంది. అలాగే 8-bit optimizer లేదా Adafactor ఉపయోగించి, LoRA dim ను 4 నుంచి 8కు తగ్గించాలి.

ఈ scripts ను ఉపయోగించే kohya_ss GUI కోసం ఉన్న LoRA guide మరింత జాగ్రత్తగా సూచిస్తుంది. LoRA training కోసం కనీసం 12 GB memory ఉన్న GPU ను ఉపయోగించాలని అది చెబుతుంది.

CPU VPS చేయగలవి, చేయలేనివి

ఇది చాలామంది ఊహించినదానికంటే ఎక్కువ చేయగలదు. మార్కెటింగ్‌లో చెప్పినదానికంటే తక్కువ కూడా చేయగలదు. ఆ పరిమితిని స్పష్టంగా అర్థం చేసుకోవాలి.

CPU VPSలో ComfyUIను ఇన్‌స్టాల్ చేయవచ్చు, web interface అందించవచ్చు, model libraryని నిల్వ చేయవచ్చు, queueను నడపవచ్చు. GPU అసలు లేకపోయినా imagesను generate చేయవచ్చు. Stable Diffusion 1.5ను 512x512 పరిమాణంలో 20 stepsతో నడిపితే, 16 GB RAM కలిగిన 8 ఆధునిక vCPUలపై ఒక్క imageకు సుమారు 60 నుంచి 150 seconds పడుతుందని అంచనా వేయాలి. రాత్రంతా నడిచే batch jobకు లేదా queue వెనుక పనిచేసే తక్కువ-పరిమాణ image endpointకు ఇది నిజంగా సరిపోతుంది.

CPU VPSతో interactive work చేయలేరు. Prompt iteration అంటే ఒక గంటలో 20 renders చేయడం. ఒక్క renderకు 13 minutes పడితే, మీరు 4 మాత్రమే చేయగలరు. Training కూడా చేయలేరు. CPUపై LoRA fine-tuningకు hours కాదు, days పడతాయి. అందువల్ల దాన్ని అందుబాటులో లేనిదిగా పరిగణించాలి.

CPU-only విధానంలో memory నియమం GPU విధానానికి భిన్నంగా ఉంటుంది. Weights system RAMలోకి load అవుతాయి. అందువల్ల model sizeతో పాటు working space కూడా అవసరం. SDXLకు సుమారు 16 GB RAM, SD 1.5కు సుమారు 8 GB RAM అవసరం. 4 GB ఉన్న machineలో ComfyUI ప్రారంభమవుతుంది. అయితే మొదటి render మధ్యలో out-of-memory killer దాన్ని నిలిపివేస్తుంది. అప్పుడు process అదృశ్యమవుతుంది; Killedలో dmesg కనిపిస్తుంది, కానీ Python traceback ఉండదు.

GPU యంత్రంపై ComfyUI ఇన్‌స్టాల్ చేయడం

ఇవి upstream కమాండ్లు. NVIDIA driver ఇప్పటికే ఉన్న clean Ubuntu 24.04 install నుంచి ప్రారంభించండి. ముందుగా driver ను నిర్ధారించండి. ఈ తనిఖీ లేకపోతే తరువాతి ప్రతి failure ఒకేలా కనిపిస్తుంది.

nvidia-smi

ఇది మీ card మరియు CUDA version ఉన్న table ను చూపాలి. command not found లేదా NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver కనిపిస్తే driver అందుబాటులో లేదు లేదా upgrade తర్వాత kernel module load కాలేదు. కొనసాగించే ముందు దీనిని సరిచేయండి. లేకపోతే ComfyUI నిశ్శబ్దంగా CPUకి fallback అవుతుంది. అప్పుడు సమస్యను software పై తప్పుగా మోపుతారు.

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

Virtual environment optional advice కాదు. PyTorch పెద్ద dependency tree ను ఇన్‌స్టాల్ చేస్తుంది. ఇతర పనులు నడిచే యంత్రంలో దాన్ని system-wide గా ఇన్‌స్టాల్ చేస్తే ఇతర software విఫలమయ్యే అవకాశం ఉంది. తరువాతి దశకు వెళ్లే ముందు PyTorch card ను గుర్తించగలదో నిర్ధారించండి.

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

True తో పాటు మీ card name కనిపిస్తే stack సరిగ్గా పనిచేస్తోంది. False కనిపిస్తే మీరు ఇన్‌స్టాల్ చేసిన wheel driver కు సరిపోలడం లేదు. సాధారణంగా CPU-only torch wheel ఇప్పటికే cache కావడం వల్ల ఇది జరుగుతుంది. పై index URL ఉపయోగించి మళ్లీ ఇన్‌స్టాల్ చేయండి.

మోడల్ పొందండి, డిస్క్ కోసం ప్రణాళిక రూపొందించండి

ComfyUIలో weights ఉండవు. Checkpoints models/checkpoints లో, VAE files models/vae లో, LoRA adapters 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

ఎల్లప్పుడూ .ckpt కంటే .safetensors ను ఉపయోగించండి. .ckpt file అనేది pickled Python object. దాన్ని load చేస్తే, దాన్ని రూపొందించిన వ్యక్తి చేర్చిన code అమలు అవుతుంది. safetensors format లో tensors మాత్రమే ఉంటాయి. అందువల్ల హానికరమైన file ఏదీ అమలు చేయలేను.

Storage ఖర్చును చాలామంది పరిగణనలోకి తీసుకోరు. ఒక SDXL base checkpoint పరిమాణం 6.94 GB. refiner కు మరో 6 GB అవసరం. SDXL ControlNet model పరిమాణం small Canny model కు 320 MB నుంచి, half precision లో full model కు 2.5 GB వరకు ఉంటుంది. upscaler పరిమాణం తక్కువగా ఉంటుంది: ప్రామాణిక Real-ESRGAN x4plus model 67 MB, దాని anime model 17.9 MB, దాని anime video model 2.5 MB ఉంటుంది. LoRA పరిమాణం కొన్ని పదుల megabytes నుంచి ByteDance యొక్క Hyper-SDXL adapters కు 787 MB వరకు ఉంటుంది. ఈ విధానాన్ని తరచుగా ఉపయోగించే వారు ఒక వారంలోనే రెండవ, మూడవ base model ను download చేస్తారు. పనిచేసే installation కోసం 100 GB disk కేటాయించండి. outputs directory ను కూడా monitor చేయండి: 1024x1024 PNG files ఒక్కొక్కటి 1 నుంచి 2 MB ఉంటాయి, unattended batch చిన్న disk ను నిశ్శబ్దంగా నింపుతుంది. models/ మరియు output/ ను పెంచగలిగే volume లో ఉంచండి. మీ workflow JSON files కు object storage కు encrypted incremental backups వంటి పద్ధతితో backup తీసుకోండి. weights ను మళ్లీ download చేయవచ్చు. మీరు సర్దుబాటు చేసిన workflows ను మళ్లీ పొందలేరు.

దీన్ని అమలు చేసి, సురక్షితంగా చేరుకోండి

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

ComfyUI port 8188 పై సేవ అందిస్తుంది. CPU-only server పై --cpu ను జోడించండి. ఇది CUDA device అందుబాటులో లేకపోవడం వల్ల విఫలమవకుండా CPU path ను బలవంతంగా ఉపయోగిస్తుంది.

127.0.0.1 కు bind చేయండి, 0.0.0.0 కు కాదు. ComfyUIలో ఇప్పుడు accounts ఉన్నాయి. అయితే వాటిలో ఏదీ మీ serverను రక్షించదు. Settings లోని User section ద్వారా చేసే login మీకు Comfy accountలో sign in చేస్తుంది. ఇది local install నుంచీ పనిచేస్తుంది. Comfy documentationలో email, Google, GitHub మరియు API key sign-inలను పేర్కొన్నారు. ఆ accountను partner nodes మరియు Comfy Cloud subscriptionsకు మీ accessగా documentation వివరిస్తుంది. మీ స్వంత serverకు password protection అందించే విధానంగా దాన్ని ఎక్కడా పేర్కొనలేదు. --multi-user flag per-user storageను మాత్రమే enable చేస్తుంది. October 2026 నాటికి server user nameను comfy-user request header నుంచి తీసుకుంటుంది. ఇది passwordను తనిఖీ చేయదు. ఆ portను చేరుకోగల ఎవరైనా మీరు రూపొందించిన ప్రతి imageను చదవగలరు, jobsను queue చేయగలరు. మీరు దీన్ని --enable-managerతో ప్రారంభించి ఉంటే custom nodesను install చేయగలరు. అంటే మీ serverపై arbitrary code execution సాధ్యమవుతుంది. బదులుగా మీ laptop నుంచి SSH tunnel ద్వారా దాన్ని చేరుకోండి.

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

తర్వాత స్థానికంగా http://127.0.0.1:8188 ను తెరవండి. నిజమైన multi-user access అవసరమైతే, authentication కలిగిన reverse proxyను దాని ముందు ఉంచండి. Appను localhostకు bind చేసి ఉంచండి. ఇదే విధానం authentication లేని ఏ self-hosted serviceకైనా వర్తిస్తుంది. VPSపై Docker Compose deploymentsలో ఇది standard pattern.

systemd కింద నిరంతరం నడపండి

మీ SSH session మూసుకున్నప్పుడు ఆగిపోయే render queue ఒక service కాదు. దాన్ని మీ పేరుతో కాకుండా login లేని comfy user గా నడపండి. Custom nodes code కాబట్టి, ఆ code మీ home directory ని access చేసే అనుమతితో నడవకూడదు. User ను సృష్టించి, install ను దాని 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

Unit దాని python ను నేరుగా call చేస్తుంది కాబట్టి, తరలించిన తర్వాత కూడా virtual environment పనిచేస్తుంది. తరువాత /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) మరియు To see the GUI go to: http://127.0.0.1:8188 ను చదివే log line అది నడుస్తోందని అర్థం. ExecStart virtual environment లోని interpreter ను నేరుగా సూచిస్తుందని గమనించండి. systemd మీ shell profile ను run చేయదు కాబట్టి activate ఎప్పటికీ జరగదు.

బడ్జెట్‌ ఆధారంగా ఆచరణాత్మక సిఫార్సు

మీరు image generation ప్రయత్నించాలనుకుంటే, వేగం కంటే ఖర్చు ముఖ్యమైతే, 16 GB RAM ఉన్న CPU VPS తీసుకుని, SD 1.5 ను 512x512 వద్ద నడపండి. ప్రతి image కు ఒకటి లేదా రెండు నిమిషాలు పట్టడాన్ని అంగీకరించండి. ఇది నిజాయితీగల ప్రారంభ ఎంపిక. GPU కలిగిన ఏ ఎంపికతో పోల్చినా దీని ఖర్చు చాలా తక్కువ. మీరు నిర్ణయం తీసుకునే వరకు model library మరియు workflows ను host చేయడానికి కూడా ఇది సరైన ప్రదేశం.

మీరు ప్రతిరోజూ prompts పై iterations చేస్తే, GPU cloud నుంచి కనీసం 12 GB VRAM ఉన్న GPU ను గంటల వారీగా rent చేయండి. మీరు ఆపినప్పుడు దాన్ని shut down చేయండి. Image generation సాధారణంగా తాత్కాలికంగా ఎక్కువ వనరులు అవసరమయ్యే పని. ఉపయోగించని GPU కు నెలవారీగా చెల్లించడం ఈ సందర్భంలో అధికంగా ఖర్చు చేయడానికి అత్యంత సాధారణ కారణం. Checkpoints ను చవకైన block storage లో ఉంచి, వాటిని mount చేయండి.

మీరు ఇతరులకు సేవ అందిస్తే లేదా LoRA adapters ను క్రమం తప్పకుండా train చేస్తే, 24 GB VRAM మరియు నిరంతరం ఉంచే machine కోసం ప్రణాళిక వేయండి. sd-scripts SDXL guide ప్రకారం memory-saving settings ఉపయోగిస్తే LoRA training ను 8 GB తో చేయవచ్చు; 10 GB సిఫార్సు చేయబడింది. kohya_ss GUI యొక్క LoRA guide కనీసం 12 GB కోరుతుంది. sd-scripts guide లోని 24 GB పరిమాణం batch size 1 తో పూర్తి SDXL fine-tuning కోసం ఉద్దేశించబడింది. అందువల్ల 24 GB card LoRA పనికి సరిపోతుంది. Fine-tuning ను కూడా అందుబాటులో ఉంచుతుంది. ఈ దశలో అదే box సాధారణంగా local language model ను కూడా నడుపుతూ తన ఖర్చును సమర్థించుకుంటుంది. ఈ setup ను Ollama తో స్వయంగా LLM host చేయడం లో వివరించారు.

మీరు ఏ స్థాయిని ఎంచుకున్నా, ప్రచురించిన ఏ సంఖ్యనైనా నమ్మే ముందు మీ స్వంత machine ను కొలవండి. అదే prompt ను ఐదుసార్లు queue చేసి, ComfyUI తన console లో చూపించే seconds-per-iteration విలువను చదవండి. ఆ సంఖ్యే మీ వాస్తవ స్థాయి.

FAQ

GPU లేకుండా Stable Diffusion నడపవచ్చా?

అవును. ComfyUI python main.py --cpu తో నడుస్తుంది. Graphics card లేకపోయినా నిజమైన images ను generate చేస్తుంది. 8 ఆధునిక vCPUలపై Stable Diffusion 1.5 ను 512x512 resolutionలో అమలు చేస్తే ఒక్క imageకు సుమారు 60 నుంచి 150 seconds పడుతుందని అంచనా వేయండి. SDXL ను 1024x1024 resolutionలో అమలు చేస్తే 10 నుంచి 20 minutes పడవచ్చు. Overnight batches మరియు తక్కువ పరిమాణంలోని endpoints కోసం ఇది సరిపోతుంది. Promptలను వరుసగా మార్చి ఫలితాలను పరీక్షించడానికి ఇది అనుకూలం కాదు. Training పూర్తిగా సాధ్యంకాదు.

SDXL కోసం ఎంత VRAM అవసరం?

1024x1024 resolutionలో SDXLను సౌకర్యవంతంగా నడపడానికి 8 GB VRAM సరిపోతుంది. అంతకంటే తక్కువ VRAM ఉంటే ComfyUI model weights ను స్వయంచాలకంగా system RAMకు offload చేస్తుంది. అయినా అది పనిచేస్తుంది. October 2026 నాటికి, దాని README ప్రకారం కనీసంగా 4 GB VRAM మరియు 8 GB system RAM అవసరం. Offload చేసే ప్రతి stepకు అదనపు సమయం పడుతుంది. 12 GB VRAM ఉంటే checkpointతో పాటు ControlNetను memoryలో ఉంచవచ్చు. 24 GB ఉంటే base model, refiner, upscalingలను ఒకే workflowలో నిర్వహించవచ్చు. kohya-ss sd-scripts guide ప్రకారం memory-saving settings ఉపయోగిస్తే SDXL LoRA trainingను 8 GBతో చేయవచ్చు. అయితే 10 GB సిఫార్సు చేయబడింది. kohya_ss GUI యొక్క LoRA guide కనీసం 12 GB కోరుతుంది. Batch size 1 వద్ద పూర్తి SDXL fine-tuningకు 24 GB అవసరం.

Modelsకు ఎంత disk space అవసరం?

SDXL base checkpoint ఒక్కటే 6.94 GB ఉంటుంది. Refiner మరో 6 GB వరకు జోడిస్తుంది. Half precisionలో SDXL ControlNet models ఒక్కొక్కటి 320 MB నుంచి 2.5 GB వరకు ఉంటాయి. LoRA adapters కొన్ని tens of megabytes నుంచి 787 MB వరకు ఉంటాయి. Real-ESRGAN upscalers 2.5 MB నుంచి 67 MB వరకు ఉంటాయి. కొన్ని base modelsతో పనిచేసే installation కోసం 100 GB కేటాయించండి. Output directoryని విడిగా పర్యవేక్షించండి. 1024x1024 PNG files ఒక్కొక్కటి 1 నుంచి 2 MB వరకు ఉండవచ్చు.

ComfyUIను public internetకు అందుబాటులో ఉంచడం సురక్షితమేనా?

లేదు. ComfyUI settingsలోని Comfy account login local installation నుంచి పనిచేస్తుంది. అయితే అది Comfy partner nodes మరియు cloud subscriptionsకు access ఇస్తుంది. Comfy documentationలో దాన్ని మీ serverకు protectionగా ఎక్కడా పేర్కొనలేదు. --multi-user flag ప్రతి user storageను మాత్రమే వేరు చేస్తుంది. ఇది ఏ passwordనూ తనిఖీ చేయదు. ComfyUI-Manager enabledగా ఉంటే interface custom nodesను install చేస్తుంది. Custom nodes మీ serverపై నడిచే Python code. అందువల్ల open port ద్వారా remote code executionకు అవకాశం ఉంటుంది. దాన్ని 127.0.0.1కు bind చేయండి. ssh -N -L 8188:127.0.0.1:8188 you@your-serverతో SSH tunnel ద్వారా access చేయండి. ఒకరికి మించి access అవసరమైతే దాని ముందు authentication కలిగిన reverse proxy ఉంచండి.

ఎలాంటి error message లేకుండా నా render ఎందుకు kill అయింది?

dmesgలో Killed కనిపిస్తూ Python traceback లేకుండా process అదృశ్యమైతే, అది ComfyUI bug కాదు. Linux out-of-memory killer ఆ processను నిలిపివేసింది. CPU-only machineలో model weights system RAMలో ఉంటాయి. అందువల్ల SDXLకు సుమారు 16 GB, SD 1.5కు సుమారు 8 GB అవసరం. దీనికి అదనంగా working space కూడా కావాలి. RAMను పెంచండి, swapను జోడించండి లేదా చిన్న model మరియు తక్కువ resolution ఉపయోగించండి.