Stable Diffusion WebUI de AUTOMATIC1111 es una interfaz web para generar imágenes con modelos de Stable Diffusion: texto a imagen, imagen a imagen, inpainting y un ecosistema amplio de extensiones. En este tutorial la instalarás en un servidor Ubuntu 24.04 con GPU NVIDIA, bajo un usuario dedicado, descargarás el modelo SDXL base, accederás a la interfaz de forma segura mediante un túnel SSH, generarás una imagen a través de su API y la dejarás funcionando como servicio systemd.

Requisitos previos

Para seguir esta guía necesitas:

  • Un servidor con Ubuntu 24.04 LTS de 64 bits y una GPU NVIDIA con al menos 8 GB de VRAM para SDXL (con 4-6 GB puedes usar modelos SD 1.5), por ejemplo un servidor con GPU de CubePath.
  • Al menos 16 GB de RAM y 40 GB libres en disco: el entorno de Python ocupa unos 10 GB y cada modelo entre 2 y 7 GB.
  • Un usuario no root con privilegios sudo.
  • Un cliente SSH en tu equipo local para el túnel.

Generar imágenes solo con CPU es posible, pero tarda minutos por imagen, así que esta guía asume una GPU NVIDIA.

Paso 1: Instalar el driver de NVIDIA

WebUI instala PyTorch con sus propias librerías CUDA, así que en el sistema solo hace falta el driver de NVIDIA. Instala el driver recomendado para tu tarjeta:

sudo apt update
sudo apt install ubuntu-drivers-common
sudo ubuntu-drivers install
sudo reboot

Tras reconectarte, comprueba que la GPU está disponible:

nvidia-smi --query-gpu=name,driver_version,memory.total --format=csv

name, driver_version, memory.total [MiB]
NVIDIA L4, 570.172.08, 23034 MiB

Paso 2: Instalar Python 3.11 y las dependencias

WebUI está probado con Python 3.10 y 3.11, y sus versiones fijadas de PyTorch no se instalan con el Python 3.12 que trae Ubuntu 24.04. El propio proyecto recomienda instalar Python 3.11 desde el PPA deadsnakes:

sudo apt install software-properties-common
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt update
sudo apt install python3.11 python3.11-venv

Instala también Git y las librerías del sistema que usan las dependencias de procesamiento de imágenes. google-perftools aporta tcmalloc, que WebUI carga automáticamente para reducir el consumo de memoria:

sudo apt install git wget libgl1 libglib2.0-0t64 google-perftools

Comprueba la versión de Python:

python3.11 --version

Python 3.11.13

Paso 3: Crear un usuario dedicado y clonar WebUI

El script de arranque se niega a ejecutarse como root, y tener WebUI bajo su propio usuario aísla sus archivos del resto del sistema. Crea el usuario sd:

sudo useradd --create-home --shell /bin/bash sd

Clona el repositorio oficial en su directorio personal:

sudo -u sd git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git /home/sd/stable-diffusion-webui

La configuración de arranque se hace en webui-user.sh, que webui.sh carga cada vez. Ábrelo:

sudo -u sd nano /home/sd/stable-diffusion-webui/webui-user.sh

El archivo tiene todas las líneas comentadas. Añade al final:

export python_cmd="python3.11"
export COMMANDLINE_ARGS="--xformers --api --medvram-sdxl"
  • python_cmd: fuerza el uso de Python 3.11 al crear el entorno virtual.
  • --xformers: instala y usa xformers, que reduce la VRAM necesaria y acelera la generación en GPUs NVIDIA.
  • --api: habilita la API REST en /sdapi/v1/, que usarás en el paso 6.
  • --medvram-sdxl: reparte el modelo entre VRAM y RAM solo cuando cargas un modelo SDXL. Con 16 GB de VRAM o más puedes quitarlo; con menos de 8 GB usa --medvram o --lowvram.

Por defecto WebUI escucha solo en 127.0.0.1:7860, así que no queda expuesto a Internet.

Paso 4: Descargar un modelo

WebUI busca los modelos (checkpoints) en models/Stable-diffusion. Descarga el modelo base de SDXL 1.0 desde el repositorio oficial de Stability AI en Hugging Face (unos 6,9 GB):

sudo -u sd wget -P /home/sd/stable-diffusion-webui/models/Stable-diffusion \
  https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors

Si tu GPU tiene menos de 8 GB de VRAM, descarga en su lugar Stable Diffusion 1.5 (unos 4 GB), que genera a 512x512 y necesita mucha menos memoria:

sudo -u sd wget -P /home/sd/stable-diffusion-webui/models/Stable-diffusion \
  https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5/resolve/main/v1-5-pruned-emaonly.safetensors

Usa siempre archivos .safetensors. Los checkpoints en formato .ckpt son archivos pickle de Python que pueden ejecutar código al cargarse. Comprueba que el modelo está en su sitio:

ls -lh /home/sd/stable-diffusion-webui/models/Stable-diffusion/

Paso 5: Primer arranque

El primer arranque crea el entorno virtual en venv/ e instala PyTorch, xformers y el resto de dependencias, lo que puede tardar entre 10 y 20 minutos. Hazlo en primer plano para ver el progreso y los posibles errores:

sudo -u sd -i bash -c 'cd ~/stable-diffusion-webui && ./webui.sh'

Cuando termine de instalar y cargar el modelo, verás:

Running on local URL:  http://127.0.0.1:7860
...
Model loaded in 12.3s (...)

Para abrir la interfaz desde tu navegador, crea un túnel SSH desde tu equipo local en otra terminal, sustituyendo your_user y your_server_ip:

ssh -N -L 7860:127.0.0.1:7860 your_user@your_server_ip

Abre http://localhost:7860 en tu navegador. En la pestaña txt2img, escribe un prompt como a lighthouse on a rocky coast at sunset, photograph, pon la resolución a 1024x1024 si usas SDXL y pulsa Generate. Mientras genera, nvidia-smi en el servidor mostrará el proceso de Python ocupando VRAM.

Cuando hayas comprobado que funciona, detén WebUI con Ctrl+C en la terminal del servidor. En el siguiente paso lo convertirás en un servicio.

Paso 6: Generar imágenes con la API

Con --api, WebUI expone endpoints REST que permiten integrar la generación en otros programas. Vuelve a arrancarlo en primer plano (ya no reinstala nada) y, en otra sesión SSH al servidor, lista los modelos disponibles:

curl -s http://127.0.0.1:7860/sdapi/v1/sd-models | python3 -m json.tool | grep '"title"'

        "title": "sd_xl_base_1.0.safetensors [31e35c80fc]",

Genera una imagen. El endpoint txt2img devuelve las imágenes codificadas en base64 dentro de un JSON, así que la extraes y decodificas con jq y base64:

sudo apt install jq
curl -s http://127.0.0.1:7860/sdapi/v1/txt2img \
  -H "Content-Type: application/json" \
  -d '{"prompt": "a lighthouse on a rocky coast at sunset, photograph", "steps": 25, "width": 1024, "height": 1024}' \
  | jq -r '.images[0]' | base64 -d > faro.png

Comprueba que el archivo es una imagen válida:

file faro.png

faro.png: PNG image data, 1024 x 1024, 8-bit/color RGB, non-interlaced

Con la interfaz abierta, la ruta http://localhost:7860/docs muestra la documentación interactiva de todos los endpoints. Detén de nuevo WebUI con Ctrl+C.

Paso 7: Ejecutar WebUI como servicio systemd

Para que WebUI arranque con el sistema y se reinicie si falla, crea una unidad de systemd:

sudo nano /etc/systemd/system/sd-webui.service

[Unit]
Description=Stable Diffusion WebUI
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=sd
Group=sd
WorkingDirectory=/home/sd/stable-diffusion-webui
ExecStart=/home/sd/stable-diffusion-webui/webui.sh
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target

Carga la unidad y arranca el servicio:

sudo systemctl daemon-reload
sudo systemctl enable --now sd-webui

Sigue el log hasta que aparezca la URL local; la carga del modelo tarda algunos segundos:

sudo journalctl -u sd-webui -f

Sal con Ctrl+C y confirma que el puerto está en escucha solo en local:

sudo ss -tlnp | grep 7860

LISTEN 0      2048       127.0.0.1:7860       0.0.0.0:*    users:(("python",pid=4312,fd=25))

Paso 8: Añadir extensiones de forma controlada

Las extensiones amplían WebUI (por ejemplo, ControlNet para controlar la composición) y se instalan clonando su repositorio en extensions/. Como ejecutan código Python con los permisos del usuario sd, instala solo las que conozcas. Para añadir ControlNet:

sudo -u sd git clone https://github.com/Mikubill/sd-webui-controlnet.git /home/sd/stable-diffusion-webui/extensions/sd-webui-controlnet
sudo systemctl restart sd-webui

En el siguiente arranque la extensión instala sus dependencias y aparece como un panel nuevo en txt2img. Sus modelos se colocan en models/ControlNet.

Solución de problemas

torch.cuda.OutOfMemoryError: CUDA out of memory. La GPU no tiene VRAM suficiente para la resolución o el modelo elegido. Añade --medvram (o --lowvram en GPUs de 4 GB) a COMMANDLINE_ARGS, reduce la resolución o el tamaño de lote, o usa un modelo SD 1.5.

Torch is not able to use GPU. PyTorch no ve la GPU. Comprueba que nvidia-smi funciona; si acabas de instalar el driver, reinicia el servidor. No uses --skip-torch-cuda-test para ocultarlo, porque WebUI acabaría generando en CPU.

La instalación falla con ERROR: Could not find a version that satisfies the requirement torch. El entorno virtual se creó con Python 3.12. Comprueba que python_cmd="python3.11" está en webui-user.sh, borra el entorno con sudo -u sd rm -rf /home/sd/stable-diffusion-webui/venv y vuelve a arrancar.

El modelo no aparece en la lista. Revisa que el archivo termina en .safetensors, que está en models/Stable-diffusion y que pertenece al usuario sd. Pulsa el botón de recargar junto al selector de modelo.

Conclusión

Tienes Stable Diffusion WebUI funcionando en Ubuntu 24.04 con aceleración NVIDIA, un modelo SDXL, acceso seguro mediante túnel SSH, API REST para automatizar la generación y un servicio systemd que lo mantiene en marcha. Como siguientes pasos, prueba modelos derivados de SDXL en formato .safetensors, añade LoRA en models/Lora para estilos concretos o, si otras personas necesitan acceso sin túnel, colócalo detrás de un proxy inverso con HTTPS y autenticación.