Tutoriales de VPS
ComfyUI en VPS GPU: Docker, modelos, HTTPS y lotes (2026)
Despliega ComfyUI con NVIDIA, verifica controlador y runtime, conserva modelos, protege acceso y recupera lotes, calculando VRAM, almacenamiento y facturación.

ComfyUI funciona en CPU, pero generar a una velocidad útil suele requerir una GPU compatible. Este tutorial usa un servidor cloud con NVIDIA: comprueba controlador, despliega el contenedor, conserva modelos y resultados, protege el acceso y prueba un flujo pequeño antes de procesar lotes. Una imagen de 1024×1024 en CPU puede tardar muchos minutos; depende del modelo y equipo.
Consulta selección de GPU si aún no has elegido máquina. El procedimiento es internacional; los presupuestos en RMB del original son ejemplos del mercado chino, no precios actuales mundiales.
Una RTX 4060 de portátil con 8 GB puede ejecutar ciertos flujos SDXL y quedarse sin memoria con una configuración Flux mayor. Es una comparación orientativa, no una medición propia. Alquilar tiene sentido si:
- La VRAM local no permite el modelo o flujo.
- Necesitas lotes desatendidos, por ejemplo cientos de imágenes autorizadas para un conjunto de datos.
- Un equipo comparte modelos y flujos.
- El proyecto temporal no justifica comprar hardware.
Para uso ocasional puede salir mejor trabajar localmente. El original estimó una 4090 encendida continuamente en torno a CNY 3000/mes; pide una cotización real con impuestos y condiciones.
| Modalidad | Cobro | Tras detener | Datos |
|---|---|---|---|
| GPU local | Compra y electricidad | Sin cargo cloud de cómputo | Disco local y backups |
| Cloud por uso | Segundos/horas según proveedor | El cómputo deja de cobrarse según sus reglas; almacenamiento puede seguir | Disco efímero puede borrarse al liberar |
| VPS GPU o servidor mensual | Contrato mensual | Normalmente continúa el cobro | Persistencia según contrato y protección del disco |
Los ejemplos originales fueron CNY 2–4/hora y CNY 2000–4000/mes para 4090, sin validez universal. Prueba unas horas y calcula almacenamiento, transferencia y tiempo inactivo. Detener y liberar una instancia son operaciones distintas.
La capacidad VRAM limita qué flujo cabe; velocidad también depende de cómputo, kernels, ancho de banda y descarga de pesos a RAM. Cifras aproximadas del original:
| Modelo | Archivo | VRAM orientativa | Ejemplo |
|---|---|---|---|
| SD 1.5 | ~2 GB | ~4 GB | GPU de 6 GB |
| SDXL | ~6.9 GB | ~7–8 GB | 8 GB ajustados; 12 GB con margen |
| Flux.1 dev fp16 | ~23 GB | 20 GB+ | 3090/4090 de 24 GB; offloading cambia requisitos |
| Flux.1 dev fp8 | ~12 GB | ~11 GB | 12 GB con configuración adecuada |
| Flux GGUF Q5_K_S | ~8.5 GB | ~7.5 GB | 8 GB ajustados; 12 GB con margen |
| Flux GGUF Q4_K_S | ~6.8 GB | ~6.5 GB | 6–8 GB siguen limitados |
Añade VAE, ControlNet, ampliadores y LoRA: 100 GB se llenan pronto. NVMe suele ayudar a cargar modelos, sin multiplicador garantizado. 32 GB de RAM es un presupuesto inicial útil para offloading; mide el flujo porque RAM/swap son mucho más lentos que VRAM. Prueba conectividad de descarga en tu región, sin deducir velocidad del país del servidor.
nvidia-smi
Comprueba GPU, memoria y controlador. La versión CUDA de nvidia-smi expresa capacidad del controlador, no necesariamente el runtime del contenedor. Que falte el comando no demuestra por sí solo que falte el controlador; consulta la imagen y herramientas del proveedor.
Si falta el repositorio, sigue primero la instalación oficial de Container Toolkit. Reiniciar Docker afecta otros contenedores:
sudo apt update
sudo apt install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker
docker run --rm --gpus all nvidia/cuda:12.8.0-base-ubuntu24.04 nvidia-smi
La prueba CUDA 12.8 verifica ese contenedor, sin garantizar una aplicación CUDA 13. Revisa controlador, arquitectura GPU y runtime de la imagen real.
mkdir -p ~/comfyui/{models,custom_nodes,input,output,user}
cd ~/comfyui
Crea docker-compose.yml:
services:
comfyui:
image: yanwk/comfyui-boot:cu130-slim-v2
container_name: comfyui
restart: unless-stopped
ports:
- "127.0.0.1:8188:8188"
volumes:
- ./models:/root/ComfyUI/models
- ./custom_nodes:/root/ComfyUI/custom_nodes
- ./input:/root/ComfyUI/input
- ./output:/root/ComfyUI/output
- ./user:/root/ComfyUI/user
environment:
- NVIDIA_VISIBLE_DEVICES=all
- NVIDIA_DRIVER_CAPABILITIES=compute,utility
deploy:
resources:
reservations:
devices:
- driver: nvidia
count: all
capabilities: [gpu]
shm_size: "8gb"
La etiqueta de ejemplo cu130-slim-v2 estaba disponible en el registro del autor al comprobarla el 2026-11-16, con digest sha256:ad3e5eb6b791a93a5f62d5ce8007ee02fb1ecfbab9b758d4da0f6e95809f5a9d. Su existencia no demuestra compatibilidad del controlador ni revisión de seguridad; verifica y fija el artefacto para tu GPU.
Comprueba imagen comunitaria y tag en la documentación del autor, y fija una versión/digest revisado. CUDA 13.0 no es requisito universal de ComfyUI: mandan PyTorch y dependencias de los nodos. Verifica si ese tag incluye Manager y qué permisos necesita.
Usa 127.0.0.1:8188:8188 en lugar de 8188:8188 para mantener privado el acceso directo. shm_size: "8gb" amplía memoria compartida respecto a los 64 MB habituales de Docker; 8 GB no son obligatorios para todo flujo y deben ajustarse a la RAM disponible.
docker compose up -d
docker compose logs -f
Comprueba puerto 8188 y Total VRAM en logs frente a la GPU contratada. Conserva también configuración y estado del usuario y revisa permisos de cada volumen.
Dentro de models:
| Directorio | Contenido |
|---|---|
checkpoints/ | Checkpoints completos compatibles |
unet/ | UNet/difusión y GGUF según cargador instalado |
clip/ | Codificadores de texto; Flux puede necesitar t5xxl y clip_l |
vae/ | VAE |
loras/ | LoRA |
controlnet/ | ControlNet |
embeddings/ | Embeddings Textual Inversion |
upscale_models/ | Ampliadores como ESRGAN |
Actualiza la lista de modelos tras copiar. Los fragmentos Diffusers de un repositorio no equivalen automáticamente a un checkpoint único: sigue los archivos exactos del flujo compatible. Este ejemplo original emplea un mirror externo orientado a China, opcional y sujeto a confianza, disponibilidad y licencia; prefiere origen oficial cuando resulte adecuado:
export HF_ENDPOINT=https://hf-mirror.com
pip install -U "huggingface_hub[cli]"
hf download black-forest-labs/FLUX.1-schnell \
--include "*.safetensors" \
--local-dir ~/comfyui/models/checkpoints
Civitai puede exigir cuenta/token autorizado. Reemplaza el marcador con la URL correcta y privada; wget -c reanuda solo si el servidor lo permite:
wget -c -O ~/comfyui/models/checkpoints/model.safetensors "复制的直链"
Empieza con un SDXL y uno o dos LoRA compatibles. Genera antes de acumular 200 GB. Los nodos personalizados ejecutan código: revisa origen y dependencias y restringe su instalador.
Considera el despliegue sin autenticación hasta verificar su protección. TLS solo no evita que otros consuman GPU. Sustituye marcadores y valida la sintaxis Caddy instalada; versiones actuales usan basic_auth:
comfy.example.com {
encode gzip
basicauth {
admin $2a$14$这里换成你的密码哈希
}
reverse_proxy 127.0.0.1:8188
}
Genera el hash en privado. Escribir contraseña en línea de comandos puede dejarla en historial/procesos; prefiere entrada interactiva:
caddy hash-password --plaintext '你的密码'
Certificados necesitan DNS y desafíos ACME accesibles. WebSocket lleva progreso y previsualizaciones: revisa errores si no actualizan. Cloudflare Tunnel también necesita una política de acceso; ocultar origen no autentica usuarios.
Para uso individual, un túnel SSH evita el proxy público:
ssh -L 8188:127.0.0.1:8188 user@你的服务器
Abre http://127.0.0.1:8188 en tu ordenador. Mantén privada la escucha local y protege SSH.
Activa Developer Mode Options y Export (API), según tu versión. El JSON visual normal es diferente del formato API. Ajusta IDs y campos al flujo real:
import json, time, uuid, urllib.request
SERVER = "http://127.0.0.1:8188"
CLIENT_ID = str(uuid.uuid4())
with open("workflow_api.json") as f:
wf = json.load(f)
# 改掉节点里的提示词和随机种子
wf["6"]["inputs"]["text"] = "a cat sitting on a server rack, cinematic lighting"
wf["3"]["inputs"]["seed"] = 12345
payload = json.dumps({"prompt": wf, "client_id": CLIENT_ID}).encode()
req = urllib.request.Request(
f"{SERVER}/prompt", data=payload,
headers={"Content-Type": "application/json"},
)
prompt_id = json.loads(urllib.request.urlopen(req).read())["prompt_id"]
while True:
with urllib.request.urlopen(f"{SERVER}/history/{prompt_id}") as r:
history = json.loads(r.read())
if prompt_id in history:
break
time.sleep(1)
for node in history[prompt_id]["outputs"].values():
for img in node.get("images", []):
print(img["filename"], img.get("subfolder", ""))
/promptrequiere IDs string:["4", 1], no[4, 1]./historypuede estar vacío mientras espera/ejecuta. Revisa cola y errores; empieza con sondeo de 1 segundo, no 100 ms./historyno persiste tras reinicio. Guardaprompt_id, flujo, semillas y resultados; un ID no recupera historial borrado.- Aceptación en
/promptno significa generación correcta. Verifica estados/errores y nodos en/object_info; algunos flujos inválidos se rechazan inmediatamente. /promptencola. Limita envíos y añade timeouts y gestión de errores: el bucle mínimo del ejemplo puede esperar indefinidamente.
Ante CUDA out of memory, mira otros procesos antes de pasar directamente a --lowvram. Comprueba flags de tu versión y avanza:
Predeterminado → --normalvram → --lowvram → --novram → --cpu.
- SDXL intermitente en 12 GB: evalúa
--reserve-vram 2para reservar margen. - Cambios de modelo/caché: considera
--cache-none. - GPU serie 10/20 con Flux:
--use-split-cross-attentiony--lowvramsi las dependencias admiten la arquitectura. - Fragmentación/offloading: revisa
--disable-dynamic-vramen documentación actual.
| Formato | Archivo | VRAM orientativa | Compromiso |
|---|---|---|---|
| fp16 | ~23 GB | 20 GB+ | Alta precisión y memoria |
| fp8 | ~12 GB | ~11 GB | Menos memoria; calidad/compatibilidad variables |
| Q5_K_S | ~8.5 GB | ~7.5 GB | Cargador específico; velocidad/calidad dependen del flujo |
| Q4_K_S | ~6.8 GB | ~6.5 GB | Más compresión y posible pérdida de detalle |
GGUF necesita ComfyUI-GGUF revisado y Unet Loader (GGUF). Usa models/unet/, no checkpoints/, donde lo requiera el cargador. Baja resolución de 1024 a 768, batch de 4 a 1 y separa flujos con dos modelos grandes. Mide: el ahorro no tiene un porcentaje fijo.
Detén/libera mediante la operación que realmente cesa cobro; apagar dentro del sistema puede no bastar. Usa programación del proveedor si conviene. Copia modelos/resultados antes de liberar disco efímero; discos retenidos siguen pudiendo cobrarse. Incluye transferencias de modelos/imágenes y evita dejar GPU cara encendida solo para sitios o bases ajenos al trabajo.
Interfaz abierta sin progreso: revisa WebSocket, cola, errores de nodos y actividad GPU.
Nodos desaparecen tras recrear: persiste custom_nodes y documenta versiones/dependencias.
413 al subir: comprueba límites en todos los proxies/CDN; Nginx suele necesitar client_max_body_size. Caddy/aplicación también pueden imponer límites.
Menor velocidad que una prueba ajena: mira nvidia-smi -l 1, VRAM/RAM, resolución y sampler. Compara misma GPU y flujo; más RAM no soluciona todo.
Contenedor termina: revisa docker compose logs por VRAM ocupada, controlador/runtime, permisos y dependencias.
Prueba GPU/controlador con alquiler por horas, genera un flujo mínimo y después añade modelos, HTTPS y lotes. Así cada fallo tiene una capa concreta que revisar.