---
title: "Cómo instalar Stable Diffusion WebUI en Ubuntu 24.04"
description: "Instala Stable Diffusion WebUI (AUTOMATIC1111) en Ubuntu 24.04 con GPU NVIDIA, descarga un modelo SDXL, genera imágenes por API y ejecútalo con systemd."
category: "Infraestructura de IA y ML"
language: es
source: https://cubepath.com/es/docs/infraestructura-de-ia-y-ml/instalacion-de-stable-diffusion-webui-en-linux
updated: 2026-09-25
---

# Cómo instalar Stable Diffusion WebUI en Ubuntu 24.04

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:

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

Tras reconectarte, comprueba que la GPU está disponible:

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

```output
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:

```bash
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:

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

Comprueba la versión de Python:

```bash
python3.11 --version
```

```output
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`:

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

Clona el repositorio oficial en su directorio personal:

```bash
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:

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

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

```bash
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):

```bash
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:

```bash
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:

```bash
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:

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

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

```output
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`:

```bash
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:

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

```output
        "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`:

```bash
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:

```bash
file faro.png
```

```output
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:

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

```ini
[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:

```bash
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:

```bash
sudo journalctl -u sd-webui -f
```

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

```bash
sudo ss -tlnp | grep 7860
```

```output
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:

```bash
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.