Cloud Server for Stable Diffusion in Europe: GPU Setup
Stable Diffusion is the open-source image generation model that powers product photo creation, marketing assets, creative workflows, and AI-assisted design. Running it on a dedicated EU cloud server gives you unlimited generations, full control over your prompts and outputs, and keeps any user data or proprietary visual assets within EU jurisdiction under GDPR.
This guide covers the GPU hardware Stable Diffusion needs, how to set up the two most popular interfaces, and what image generation speeds to expect on an EU cloud server.
Why EU Hosting Matters for Stable Diffusion
When you generate images using a third-party API, the prompts you send - which may describe products, people, or proprietary concepts - leave your control and may be logged, used for training, or subject to US jurisdiction. For businesses generating images from user-provided descriptions or proprietary brand guidelines, this creates both GDPR and IP exposure.
Self-hosting Stable Diffusion on a DCXV EU cloud server means prompts never leave your infrastructure, generated images are stored only on your servers, and all processing stays within EU jurisdiction. There are also no per-image API costs - server time is the only variable.
GPU Requirements for Stable Diffusion
VRAM is the primary constraint. Model size and resolution determine minimum requirements:
- SD 1.5 (768px, standard) - 4 GB VRAM minimum, 8 GB recommended
- SDXL 1.0 (1024px) - 8 GB VRAM minimum, 12-16 GB recommended
- SDXL with ControlNet + LoRA - 16+ GB VRAM for comfortable headroom
- SD 3.5 / Flux.1 - 16-24 GB VRAM for full quality, 8 GB with quantization
For production batch generation or multi-user API use, more VRAM means more images in parallel and faster generation through larger batch sizes.
Minimum Specs for Stable Diffusion
- Entry (SD 1.5, personal use) - 4 vCPU, 16 GB RAM, 8 GB VRAM (RTX 3070/4060), 200 GB NVMe
- Standard (SDXL, small team) - 8 vCPU, 32 GB RAM, 16 GB VRAM (RTX 4080/A4000), 500 GB NVMe
- Production (SDXL + Flux, API service) - 8 vCPU, 64 GB RAM, 24 GB VRAM (RTX 4090/A5000), 1 TB NVMe
- High-throughput (batch generation) - 16 vCPU, 128 GB RAM, 80 GB VRAM (A100), 2 TB NVMe
Storage matters because model checkpoints are large: an SDXL base model is 6-7 GB, ControlNet models are 1-2 GB each, and LoRA collections grow quickly. Plan for at least 500 GB if you intend to run multiple model variants.
Recommended DCXV Configuration
DCXV cloud servers provide GPU instances on Tier III EU infrastructure with NVMe storage for fast model loading:
- GPU server, 16 GB VRAM - SDXL production, 4-8 images per minute at 1024px
- GPU server, 24 GB VRAM - SDXL + Flux.1, ControlNet workflows, small API service
- GPU server, 80 GB VRAM - high-throughput batch generation, multi-user API
Contact sales@dcxv.com to discuss GPU availability and storage configuration for model libraries.
Quick Setup Commands
# Prepare the server - install CUDA and Python dependencies
sudo apt update && sudo apt install -y python3 python3-pip python3-venv git wget nvidia-cuda-toolkit
# Verify GPU is detected
nvidia-smi
# Option 1: AUTOMATIC1111 WebUI (most popular, feature-rich)
cd /opt
git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git
cd stable-diffusion-webui
# Download SDXL base model
mkdir -p models/Stable-diffusion
wget -O models/Stable-diffusion/sd_xl_base_1.0.safetensors \
https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors
# Launch with API enabled and listening on private network
./webui.sh --listen --port 7860 --api --nowebui \
--xformers --no-half-vae
# Remove --nowebui to use the browser interface
# Option 2: ComfyUI (node-based, more flexible for workflows)
cd /opt
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
pip install -r requirements.txt
# Download a model to models/checkpoints/
# Then launch:
python main.py --listen 10.0.0.5 --port 8188 \
--highvram # use --normalvram on 8-12 GB cards
# Use the AUTOMATIC1111 REST API for batch generation
curl http://10.0.0.5:7860/sdapi/v1/txt2img \
-H "Content-Type: application/json" \
-d '{
"prompt": "professional product photo, white background, soft lighting",
"negative_prompt": "blurry, watermark, text",
"width": 1024,
"height": 1024,
"steps": 20,
"cfg_scale": 7,
"sampler_name": "DPM++ 2M Karras",
"batch_size": 1
}' | python3 -c "
import sys, json, base64
r = json.load(sys.stdin)
with open('output.png', 'wb') as f:
f.write(base64.b64decode(r['images'][0]))
print('Saved output.png')
"
# Run as a systemd service for production uptime
cat > /etc/systemd/system/stable-diffusion.service << 'EOF'
[Unit]
Description=Stable Diffusion API
After=network.target
[Service]
Type=simple
User=ubuntu
WorkingDirectory=/opt/stable-diffusion-webui
ExecStart=/opt/stable-diffusion-webui/webui.sh --listen --port 7860 --api --nowebui --xformers
Restart=always
RestartSec=10
[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable stable-diffusion
sudo systemctl start stable-diffusion
Expected Performance Benchmarks
RTX 4090 (24 GB VRAM), SDXL 1.0, 1024x1024, 20 steps:
- DPM++ 2M Karras - 12-18 seconds per image
- LCM sampler (4 steps) - 2-4 seconds per image
- Batch of 4 images - 35-50 seconds total
A100 40 GB, SDXL 1.0, 1024x1024, 20 steps:
- DPM++ 2M Karras - 6-10 seconds per image
- Batch of 8 images - 35-55 seconds total
- Throughput - 5-8 images per minute sustained
RTX 4080 (16 GB VRAM), SD 1.5, 512x512, 20 steps:
- Euler a sampler - 2-4 seconds per image
- Throughput - 15-25 images per minute
These are expectations for hardware of this class, not measurements from our own lab. Treat them as a starting point for sizing and measure your own workload: real numbers depend on your data, your queries and your tuning far more than on the provider.
Bottom Line
Stable Diffusion on an EU cloud server gives you unlimited, private image generation under GDPR-compliant EU jurisdiction. SDXL on a 24 GB GPU produces production-quality images in 12-18 seconds each - fast enough for real-time product photography workflows and marketing asset pipelines. DCXV provides the GPU hardware and EU infrastructure to run Stable Diffusion at scale without per-image API costs.
