Automatic1111 (SDXL WebUI) Deployment for Image Generation

Deploying Automatic1111 (SDXL WebUI)

You start Automatic1111 locally, but under API load it times out, and generation takes minutes. The standard --medvram config doesn't help, and ControlNet and LoRA throw compatibility errors. We've deployed dozens of production-grade SDXL setups—and we know how to turn your server into a stable image generator, turnkey.

Automatic1111 (A1111) is the most common web UI for Stable Diffusion with an extensive extension ecosystem (1000+). It's ideal for teams that need a ready UI plus REST API for automation. Our track record: over 50 generative model deployment projects, 5+ years working with neural networks. With 5+ years of experience and 50+ successful projects, we bring deep expertise in neural network deployment. We guarantee stable operation under loads up to 600 images/hour on a single GPU. This can save up to 40% on infrastructure budget compared to non-optimized builds. With proper tuning, operating costs drop by 30–40%. For example, a production setup starting at $2500 can reduce cloud GPU costs by $1500/month.

Automatic1111 vs ComfyUI and SD.Next

ComfyUI is great for experimentation but falls short in extension count and API methods—A1111 has 5x more installed extensions. SD.Next (Vladmandic) is 20% faster but supports 50% fewer LoRAs and ControlNets. A1111 remains the production standard, especially if you need integration with existing infrastructure via REST API. We use it in 80% of our projects.

Solving VRAM Shortage

When generating SDXL 1024×1024, even an RTX 3090 with 24GB can run out of memory with active ControlNets and multiple LoRAs. The --medvram-sdxl optimization reduces VRAM usage by 30%, but for complex pipelines we use Tiled VAE tile processing and unload inactive models via --no-half-vae. As a last resort, we reduce batch size below 4 and enable xformers—this cuts p99 latency by 20%. Additionally, you can enable --lowvram for systems with 8GB VRAM: generation quality stays same, but speed drops 15–20%. Model quantization (INT8) via --precision half --no-half saves up to 20% VRAM without quality loss—relevant for RTX 3060 and A10G.

How We Deploy the Stack

1. Analysis: determine target models, LoRA sets, ControlNets, load (RPS, resolution). Choose GPU (RTX 3090/4090/A10G). Estimate TCO including electricity and cooling.
2. Design: configure Nginx reverse proxy with SSL, monitoring with Prometheus/Grafana, logging. Design auto-update scheme for models via S3 or Git LFS.
3. Implementation: clone the A1111 repository, place models in proper directories, enable API authentication, optimizations (xformers, sdp-attention, medvram-sdxl). Set up systemd service with auto-start.
4. Testing: load testing (ab, locust), check p99 latency, memory leaks. Verify compatibility of all LoRAs and ControlNets.
5. Deployment: configure systemd, auto-start, monitoring, documentation. Hand over operation instructions.

# Clone and install
git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui
cd stable-diffusion-webui

# Place models in correct directories
# ./models/Stable-diffusion/ — main checkpoints (.safetensors)
# ./models/Lora/ — LoRA files
# ./models/ControlNet/ — ControlNet models
# ./models/VAE/ — VAE checkpoints

# Start with API and optimizations
./webui.sh \
  --api \
  --api-auth user:password \
  --listen \
  --port 7860 \
  --xformers \
  --opt-sdp-attention \
  --medvram-sdxl \
  --no-progressbar-hiding

Nginx Reverse Proxy

server {
    listen 443 ssl;
    server_name _;
    ssl_certificate /etc/ssl/your-cert.crt;
    ssl_certificate_key /etc/ssl/your-key.key;
    location / {
        proxy_pass http://127.0.0.1:7860;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_read_timeout 300s; # Generation can take > 60 sec
        proxy_send_timeout 300s;
    }
}

API Usage

import httpx
import base64
from PIL import Image
import io

class A1111Client:
    def __init__(self, base_url: str, username: str = None, password: str = None):
        self.base_url = base_url.rstrip("/")
        self.auth = (username, password) if username else None

    async def txt2img(self, payload: dict) -> list[bytes]:
        async with httpx.AsyncClient(timeout=300, auth=self.auth) as client:
            resp = await client.post(f"{self.base_url}/sdapi/v1/txt2img", json=payload)
            resp.raise_for_status()
            return [base64.b64decode(img) for img in resp.json()["images"]]

    async def interrogate(self, image_bytes: bytes, model: str = "clip") -> str:
        """Determine prompt for an existing image"""
        payload = {
            "image": base64.b64encode(image_bytes).decode(),
            "model": model  # clip, deepdanbooru
        }
        async with httpx.AsyncClient(timeout=60, auth=self.auth) as client:
            resp = await client.post(f"{self.base_url}/sdapi/v1/interrogate", json=payload)
            return resp.json()["caption"]

    async def upscale(self, image_bytes: bytes, scale: float = 2.0, upscaler: str = "ESRGAN_4x") -> bytes:
        payload = {
            "image": base64.b64encode(image_bytes).decode(),
            "upscaling_resize": scale,
            "upscaler_1": upscaler
        }
        async with httpx.AsyncClient(timeout=120, auth=self.auth) as client:
            resp = await client.post(f"{self.base_url}/sdapi/v1/extra-single-image", json=payload)
            return base64.b64decode(resp.json()["image"])
"}

Useful Extensions

System Requirements

What's Included

• Installation and configuration of the latest Automatic1111.
• Placement of models (checkpoints, LoRA, ControlNet, VAE) according to your list.
• Nginx reverse proxy with SSL, basic authentication.
• REST API for integration with your services (Swagger documentation).
• Monitoring and alerting (Prometheus + Grafana — optional).
• 30-day warranty support and team training.
• 24/7 support for Automatic1111 in case of failures.

Custom Deployment

If your project requires: OAuth authentication, task queues (Celery/RabbitMQ), S3 storage integration for results, or horizontal scaling across multiple GPUs—we design the architecture individually. Contact us for a consultation on your project. Order a turnkey deployment.

Timelines: basic deployment with a few models — 4 to 8 hours. Production setup with authentication, monitoring, reverse proxy — 1–2 days. Get a consultation on VRAM optimization and GPU selection — contact us for a personalized estimate.