Hardware specs para sa self-hosted AI image generator
Alamin ang totoong hardware requirements para sa Stable Diffusion at ComfyUI. Kasama rito ang disk space, GPU memory para sa SDXL, at performance ng CPU-only na VPS.
Ano ang tunay na kailangan ng isang self-hosted AI image generator
Ang isang self-hosted AI image generator ay binubuo ng isang web app at isang model file. Ang app ay ComfyUI, at tumatakbo ito sa kahit anong Linux box. Ang model ang nagtatakda ng kailangan mong hardware. Ang isang SDXL-class checkpoint ay isang file na may sukat na 6.94 GB, at kailangan nitong manatili sa GPU memory. Ang katotohanang ito ang nagtatakda ng buong budget, kaya basahin ang hardware ladder sa ibaba bago ka umupa ng kahit ano.
Ang tapat na buod: ang isang CPU-only VPS ay kayang mag-install at mag-serve ng software, at kaya nitong gumawa ng mga image sa 512x512 gamit ang lumang Stable Diffusion 1.5 model. Ang estimate ng guide na ito noong October 2026 ay isang minuto o dalawa bawat image, at sampu hanggang dalawampung minuto para sa SDXL sa 1024x1024. Ang mga timing na ito ay hindi pa na-revalidate sa kasalukuyang hardware. Hindi ito broken setup. Arithmetic lang ito, at ipinapaliwanag ito ng guide na ito.
Bakit ang laki ng model ang nagtatakda ng kailangang machine
Ang image generation ay gumagamit ng denoising loop. Ang isang 30-step render ay nagpapatakbo ng denoiser, ang UNet ng SDXL, nang 30 beses sa imahe, at bawat pass ay nagbabasa ng lahat ng UNet weights. Ang dalawang text encoder ay tumatakbo nang isang beses bago ang loop at ang VAE ay nagde-decode nang isang beses pagkatapos nito, kaya hindi sila bahagi ng per-step cost. Ang UNet ng SDXL sa half precision ay may 5.14 GB na weights, kaya sa simpleng pagtaya, ang isang 30-step render ay naglilipat ng humigit-kumulang 154 GB ng weights sa memory bago ka makakita ng larawan, at ang mga intermediate tensor ay nagdaragdag pa rito.
Ang isang GPU na may 24 GB ng video memory (VRAM, ang memory na nakakabit sa tabi ng graphics chip) ay nagbabasa sa bilis na daan-daang gigabytes bawat segundo, at kaya nitong hawakan ang lahat ng 6.9 GB nang sabay-sabay. Ang isang CPU VPS ay nagbabasa ng system RAM sa bilis na sampu-sampung gigabytes bawat segundo. Ang agwat sa bilis ay nakadepende sa CPU at GPU, hindi lang sa kanilang memory capacity. Ito ang parehong memory-bandwidth argument na nagtatakda sa mga text model, at sulit itong basahin kasabay ng kung kailan sulit ang bayad sa isang VPS na may GPU.
Ang image generation ay naiiba sa text generation sa isang mahalagang aspeto. Ang isang chat model ay nag-i-stream ng tokens, kaya ang mabagal na machine ay nararamdaman pa ring magagamit dahil lumalabas ang mga salita habang nagbabasa ka. Ang isang imahe ay lumalabas lamang kapag natapos na ang huling step. Ang mabagal ay nangangahulugan ng pagtitig sa isang progress bar.
Ang hardware ladder, gamit ang mga totoong numero
Ang block sa ibaba ay naglalaman ng mga estimate para sa Hulyo 2026 ng gabay na ito para sa isang SDXL image sa 1024x1024, 30 steps, Euler sampler. Ang mga historical timing na ito ay hindi na-revalidate sa kasalukuyang hardware. Ituring ang mga ito bilang order of magnitude. Ang iyong sampler, step count, at resolution ay magpapabago sa mga numerong ito.
Ang datos sa likod ng tsart na ito
[
{
"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
}
]Ang CPU row ay 780 na segundo, humigit-kumulang labintatlong minuto. Ang 24 GB card ay 9 na segundo. Iyan ang agwat na binabayaran mo.
Basahin ang ladder sa ganitong paraan. Sa ibaba ng 8 GB ng VRAM, tumatakbo pa rin ang SDXL dahil pinamamahalaan ng ComfyUI ang VRAM at system RAM nang magkasama at awtomatikong nag-o-offload ng model weights. Simula noong Oktubre 2026, inilalarawan sa README ng proyekto ang pagtakbo ng mga model na may kasing-liit ng 4 GB ng VRAM at 8 GB ng system RAM, gamit ang asynchronous weight streaming nito. Ang mas malaking VRAM ay nagbibigay ng espasyo para sa ControlNet, refiner, at upscaling nang hindi na kailangang mag-offload; ang workflow ang nagtatakda kung gaano karami ang kakasya. Ang training ay kasya sa mas maliit na memory: ayon sa SDXL training guide para sa kohya-ss sd-scripts trainer, ang LoRA training ay maaaring gawin gamit ang 8 GB ng GPU memory, kung saan 10 GB ang inirerekomenda. Para makamit ito, sinasabi nito na i-train lang ang U-Net, i-on ang gradient checkpointing, i-cache ang text encoder outputs at latents, gumamit ng 8-bit optimizer o Adafactor, at ibaba ang LoRA dim sa 4 hanggang 8 sa isang 8 GB card. Ang LoRA guide para sa kohya_ss GUI, na bumabalot sa mga script na iyon, ay mas maingat: sinasabi nito na gumamit ng GPU na may hindi bababa sa 12 GB ng memory para sa LoRA training.
Ano ang kayang gawin at hindi kayang gawin ng isang CPU VPS
Mas marami itong kayang gawin kaysa sa inaakala ng marami, at mas kaunti kaysa sa ipinapahiwatig ng marketing. Maging tiyak sa hangganan nito.
Ang isang CPU VPS ay kayang mag-install ng ComfyUI, mag-serve ng web interface, mag-imbak ng iyong model library, magpatakbo ng queue, at mag-generate ng mga imahe kahit walang GPU. Gamit ang Stable Diffusion 1.5 sa 512x512 at 20 steps, ang pagtataya ng gabay na ito noong October 2026 ay humigit-kumulang 60 hanggang 150 segundo bawat imahe sa 8 modernong vCPU na may 16 GB ng RAM. Para sa isang batch job na tumatakbo nang magdamag, o isang low-volume image endpoint sa likod ng isang queue, sapat na ito.
Hindi angkop ang CPU VPS para sa interactive na trabaho. Ang prompt iteration ay nangangahulugan ng dalawampung render sa loob ng isang oras, at sa historical estimate na labintatlong minuto bawat isa, apat lang ang matatapos mo. Gumamit ng GPU para sa training.
Ang panuntunan sa memory para sa CPU-only ay iba sa panuntunan para sa GPU. Ang mga weight ay naglo-load sa system RAM, kaya maglaan ng budget para sa model at sa working space; ang 16 GB para sa SDXL at 8 GB para sa SD 1.5 ay mga planning budget lamang, hindi fixed na requirement. Ang isang 4 GB na box ay maaaring maubusan ng memory, ngunit hindi lang ang kapasidad ng RAM ang nagtatakda kung kailan papatayin ng Linux ang proseso. Mahalaga ang swap, memory limits, at allocation policy. Sa overcommit mode 2, karaniwang tinatanggihan ng Linux ang mga allocation na lumalagpas sa commit limit nito sa halip na patayin ang proseso kapag in-access nito ang mga page na iyon.
Pag-install ng ComfyUI sa isang GPU machine
Ito ang mga upstream command. Magsimula sa isang malinis na Ubuntu 24.04 install na mayroon nang NVIDIA driver. I-verify muna ang driver, dahil ang bawat susunod na error ay magmumukhang pareho kung hindi ito gagawin.
nvidia-smiDapat itong mag-print ng table na nagpapakita ng iyong card at ng CUDA version. Ang command not found, o NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver, ay nangangahulugang kulang ang driver o hindi nag-load ang kernel module matapos ang isang upgrade. Ayusin muna ito bago magpatuloy, dahil ang default NVIDIA path ng ComfyUI ay mag-fe-fail kung walang gumaganang CUDA device; ang CPU execution ay nangangailangan ng --cpu. Ang mga CUDA 13.0 wheel sa ibaba ay nangangailangan ng NVIDIA driver mula sa 580 series o mas bago.
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.txtAng virtual environment ay hindi opsyonal na payo. Ang PyTorch ay humihila ng malaking dependency tree, at ang pag-install nito nang system-wide sa isang server na nagpapatakbo ng ibang serbisyo ay magdudulot ng sira sa ibang app. I-verify na nakikita ng PyTorch ang card bago magpatuloy.
python -c "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0))"Ang True kasama ang pangalan ng iyong card ay nangangahulugang gumagana ang stack. Kung hindi available ang CUDA, ang command na ito ay maglalabas ng error kapag hiningi nito ang pangalan ng card. Suriin ang driver, GPU visibility, at ang naka-install na PyTorch build bago i-reinstall ang mga CUDA wheel.
Kumuha ng model, at magplano para sa disk
Ang ComfyUI ay walang kasamang weights. Ang mga checkpoint ay inilalagay sa models/checkpoints, ang mga VAE file sa models/vae, at ang mga LoRA adapter sa models/loras.
cd ~/ComfyUI/models/checkpoints
wget https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensorsLaging piliin ang .safetensors kaysa sa .ckpt. Ang isang checkpoint na base sa pickle ay maaaring magpatakbo ng code sa pamamagitan ng isang unrestricted loader; ang kasalukuyang ComfyUI ay gumagamit ng restricted weights_only=True loader ng PyTorch para sa mga file na ito. Ang format na safetensors ay nag-iimbak ng mga tensor nang walang mechanism ng pickle para sa pagpapatakbo ng code.
Ang storage ang gastos na madalas makalimutan ng mga tao. Ang isang SDXL base checkpoint ay 6.94 GB. Ang refiner ay dagdag na 6 GB. Ang isang SDXL ControlNet model ay naglalaro mula 320 MB para sa maliit na Canny model hanggang 2.5 GB para sa full model sa half precision. Ang upscaler ay maliit lamang: ang standard na Real-ESRGAN x4plus model ay 67 MB, ang anime model nito ay 17.9 MB, at ang anime video model nito ay 2.5 MB. Ang isang LoRA ay naglalaro mula sampu-sampung megabyte hanggang 787 MB para sa mga Hyper-SDXL adapter ng ByteDance. Sinumang nag-e-enjoy dito ay magda-download ng pangalawa at pangatlong base model sa loob ng isang linggo. Maglaan ng 100 GB na disk para sa isang working install, at bantayan din ang directory ng mga output: ang laki ng PNG ay nakadepende sa content at metadata ng imahe, at ang isang unattended batch ay tahimik na nakakapuno ng maliit na disk. Ilagay ang models/ at output/ sa isang volume na maaari mong palakihin, at i-back up ang iyong mga workflow JSON file gamit ang encrypted incremental backups to object storage. Ang mga weight ay maaaring i-download muli. Ang mga workflow na na-tune mo ay hindi.
Patakbuhin ito, at i-access nang ligtas
cd ~/ComfyUI
. venv/bin/activate
python main.py --listen 127.0.0.1 --port 8188Ang ComfyUI ay tumatakbo sa port 8188. Sa isang CPU-only na server, idagdag ang --cpu, na pumipilit sa CPU path sa halip na mag-fail dahil sa kawalan ng CUDA device.
I-bind ito sa 127.0.0.1, hindi sa 0.0.0.0. May mga account na ang ComfyUI ngayon, pero wala sa mga ito ang nagla-lock ng iyong server. Ang login sa ilalim ng Settings, sa seksyong User, ay nagla-log in sa iyo sa isang Comfy account, at gumagana ito mula sa isang local install: nakalista sa docs ng Comfy ang email, Google, GitHub, at API key sign-in. Inilalarawan ng docs ang account na iyon bilang access mo sa mga partner node at Comfy Cloud subscription, at walang anumang bahagi nito ang nagpapakita na paraan ito para lagyan ng password ang sarili mong server. Ang --multi-user flag ay nag-e-enable lamang ng per-user storage: simula noong October 2026, kinukuha ng server ang user ID mula sa isang comfy-user request header at hindi ito nag-che-check ng password. Anumang makakaabot sa port ay maaaring mag-queue ng mga job at kumuha ng mga na-generate na image. Gamit ang --enable-manager, ang pag-install ng custom-node ay nagpapatakbo rin ng code sa iyong server, depende sa security settings ng Manager. Ang kasalukuyang default ng Manager ay humaharang sa arbitrary Git URL at standalone pip install; ang pag-enable sa mga ito ay nangangailangan ng mga explicit flag at loopback listener. Ang pag-install ng registered-node ay nananatiling available sa ilalim ng normal na security policy nito. I-access ito sa pamamagitan ng isang SSH tunnel mula sa iyong laptop sa halip.
ssh -N -L 8188:127.0.0.1:8188 you@your-serverPagkatapos, buksan ang http://127.0.0.1:8188 nang local. Kung kailangan mo ng totoong multi-user access, maglagay ng reverse proxy na may authentication sa harap nito at panatilihing naka-bind ang app sa localhost. Ang parehong lohika ay nalalapat sa anumang unauthenticated na self-hosted service, at ito ang standard na pattern sa Docker Compose deployments sa isang VPS.
Panatilihing tumatakbo ito sa ilalim ng systemd
Ang isang render queue na namamatay kapag nagsara ang iyong SSH session ay hindi maituturing na isang service. Patakbuhin ito bilang isang comfy user na walang login, huwag bilang ikaw: ang mga custom node ay code, at ang code na iyon ay hindi dapat tumatakbo nang may access sa iyong home directory. Gumawa ng user at ilipat ang install sa home directory nito:
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/ComfyUIGawin muli ang virtual environment pagkatapos ng paglipat, dahil ang mga installed script ay naglalaman ng mga absolute path patungo sa lumang lokasyon nito.
sudo -u comfy python3 -m venv --clear /home/comfy/ComfyUI/venv
sudo -u comfy /home/comfy/ComfyUI/venv/bin/python -m pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu130
sudo -u comfy /home/comfy/ComfyUI/venv/bin/python -m pip install -r /home/comfy/ComfyUI/requirements.txtPagkatapos, isulat ang /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.targetsudo systemctl daemon-reload
sudo systemctl enable --now comfyui
systemctl status comfyuiAng active (running) at isang log line na nagbabasa ng To see the GUI go to: http://127.0.0.1:8188 ay nangangahulugang ito ay up na. Tandaan na ang ExecStart ay direktang tumutukoy sa interpreter sa loob ng virtual environment, dahil hindi pinapatakbo ng systemd ang iyong shell profile at hindi kailanman mangyayari ang activate.
Ang pragmatikong rekomendasyon ayon sa budget
Kung nais mong sumubok ng image generation at mas mahalaga ang budget kaysa sa bilis, kumuha ng CPU VPS na may 16 GB ng RAM, patakbuhin ang SD 1.5 sa 512x512, at sukatin ang iyong render time bago maglaan ng workload. Ito rin ang tamang lugar para i-host ang model library at mga workflow habang nagdedesisyon ka.
Kung nag-i-iterate ka ng mga prompt araw-araw, umupa ng GPU na may hindi bababa sa 12 GB ng VRAM kada oras mula sa isang GPU cloud, at i-shut down ito kapag tapos ka na. Ang image generation ay isang bursty na trabaho, at ang idle GPU na binabayaran buwan-buwan ang pinakakaraniwang dahilan ng labis na gastos. Panatilihin ang mga checkpoint sa murang block storage at i-mount ang mga ito.
Kung nagsisilbi ka sa ibang tao, o regular kang nagte-train ng mga LoRA adapter, magplano para sa 24 GB ng VRAM at isang machine na pagmamay-ari mo. Sinasabi ng sd-scripts SDXL guide na ang LoRA training ay maaaring gawin sa 8 GB, na may rekomendasyong 10 GB, gamit ang mga memory-saving settings nito, at ang LoRA guide ng kohya_ss GUI ay nangangailangan ng hindi bababa sa 12 GB. Inilalarawan din ng guide ang SDXL fine-tuning gamit ang 24 GB sa batch size 1, na nagrerekomenda ng U-Net-only training, gradient checkpointing, cached text-encoder outputs at latents, at Adafactor. Ito ay isang conditional configuration, hindi isang unibersal na requirement sa memory para sa pag-train ng buong model. Sa puntong iyon, ang parehong machine ay karaniwang kumikita na rin sa pamamagitan ng pagpapatakbo ng isang local language model, na siyang setup na inilalarawan sa self-hosting an LLM with Ollama.
Anuman ang antas na piliin mo, sukatin ang sarili mong machine bago maniwala sa anumang nailathalang figure. I-queue ang parehong prompt nang limang beses at basahin ang seconds-per-iteration na ipinapakita ng ComfyUI sa console nito. Ang numerong iyon ang iyong tunay na posisyon sa hagdan.
FAQ
Maaari ba akong magpatakbo ng Stable Diffusion nang walang GPU?
Oo. Tumatakbo ang ComfyUI gamit ang python main.py --cpu at nakakagawa ng mga totoong imahe kahit walang graphics card. Ang mga estimate noong Oktubre 2026 sa gabay na ito ay humigit-kumulang 60 hanggang 150 segundo bawat imahe para sa Stable Diffusion 1.5 sa 512x512, at sampu hanggang dalawampung minuto para sa SDXL sa 1024x1024, gamit ang 8 modernong vCPU. Ang mga timing na ito ay hindi pa muling na-validate sa kasalukuyang hardware. Gumagana ito para sa mga batch na pinapatakbo sa magdamag at mga low-volume endpoint. Gumamit ng GPU para sa prompt iteration at training.
Gaano karaming VRAM ang kailangan ko para sa SDXL?
Awtomatikong inililipat ng ComfyUI ang mga model weight sa system RAM, kaya hindi lang ang VRAM capacity ang nagtatakda ng fixed minimum para sa bawat SDXL workflow. Simula noong Oktubre 2026, inilalarawan ng README nito ang pagtakbo ng mga model na may kasing-liit ng 4 GB ng VRAM at 8 GB ng system RAM gamit ang asynchronous weight streaming. Ang ControlNet, refiner, at upscaling ay nagdaragdag sa memory budget. Sinasabi ng gabay ng kohya-ss sd-scripts na ang SDXL LoRA training ay maaaring gawin gamit ang 8 GB, na may 10 GB na inirerekomenda, kung gagamitin mo ang mga memory-saving setting nito, habang ang LoRA guide ng kohya_ss GUI ay nangangailangan ng hindi bababa sa 12 GB. Inilalarawan ng sd-scripts guide ang fine-tuning gamit ang 24 GB sa batch size 1, na nagrerekomenda ng U-Net-only training, gradient checkpointing, cached text-encoder outputs at latents, at Adafactor. Hindi nito itinatakda ang unibersal na 24 GB na requirement para sa full-model training.
Gaano karaming disk space ang kailangan ng mga model?
Ang SDXL base checkpoint pa lamang ay 6.94 GB, at ang refiner ay nagdaragdag ng humigit-kumulang 6 GB pa. Ang mga SDXL ControlNet model ay tumatakbo mula 320 MB hanggang 2.5 GB bawat isa sa half precision, ang mga LoRA adapter ay mula sampu-sampung megabytes hanggang 787 MB, at ang mga Real-ESRGAN upscaler ay mula 2.5 MB hanggang 67 MB. Maglaan ng 100 GB para sa isang working install na may ilang base model, at bantayan nang hiwalay ang output directory, dahil ang laki ng PNG ay nakadepende sa content ng imahe at metadata.
Ligtas bang ilantad ang ComfyUI sa public internet?
Hindi. Ang Comfy account login sa mga setting ng ComfyUI ay gumagana mula sa isang local install, ngunit nagbibigay ito sa iyo ng access sa mga partner node at cloud subscription ng Comfy, at walang anuman sa mga dokumento ng Comfy ang nagpapakita nito bilang proteksyon para sa iyong server. Ang --multi-user flag ay naghihiwalay lamang ng storage bawat user nang hindi nag-che-check ng anumang password. Kapag naka-enable ang ComfyUI-Manager, ang mga pinapayagang custom-node installation ay nagpapatakbo ng Python code sa iyong server. Nililimitahan ng security settings ng Manager ang mga installation route, ngunit hindi nito ina-authenticate ang access sa ComfyUI. I-bind ito sa 127.0.0.1, i-access ito sa pamamagitan ng SSH tunnel gamit ang ssh -N -L 8188:127.0.0.1:8188 you@your-server, at maglagay ng authenticating reverse proxy sa harap nito kung higit sa isang tao ang nangangailangan ng access.
Bakit napatay ang aking render nang walang error message?
Ang isang prosesong nawawala na may Killed at walang Python traceback ay hindi awtomatikong patunay ng isang out-of-memory kill. Suriin ang dmesg o ang kernel journal para sa isang OOM report na nagpapangalan sa proseso. Sa isang CPU-only box, ang mga weight ay nasa system RAM, ngunit ang memory na kailangan ay nakadepende sa model, precision, resolution, at workflow. Ang RAM capacity, swap, memory limits, at overcommit policy ang nagtatakda kung mabibigo ang allocation o mapapatay ang proseso. Sa overcommit mode 2, ang Linux ay karaniwang nagbabalik ng mga allocation error sa halip na patayin ang proseso kapag in-access nito ang mga page. Kung kumpirmado sa mga log ang memory exhaustion, magdagdag ng RAM, suriin ang swap at memory limits, o gumamit ng mas maliit na model at mas mababang resolution.