blumfontein/docker-stable-diffusion repository overview

# 1. Build the Docker image
docker build -t sd-api .

# 2. Run with your Hugging Face token and API key
docker run --gpus all -p 8000:8000 \
  -e HUGGING_FACE_HUB_TOKEN=hf_your_token_here \
  -e API_KEY=your_api_key_here \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  sd-api

# 3. Test the API
curl -X POST http://localhost:8000/v1/images/generations \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "A beautiful sunset over mountains", "n": 1, "size": "1024x1024"}'

docker pull blumfontein/docker-stable-diffusion
docker run --gpus all -p 8000:8000 \
  -e HUGGING_FACE_HUB_TOKEN=your_token_here \
  -e API_KEY=your_api_key_here \
  blumfontein/docker-stable-diffusion

docker build -t sd-api:latest .

docker build -t sd-api:v1.0.0 .

docker build --build-arg BUILDKIT_INLINE_CACHE=1 -t sd-api:latest .

docker run --gpus all -p 8000:8000 \
  -e HUGGING_FACE_HUB_TOKEN=your_token_here \
  -e API_KEY=your_api_key_here \
  sd-api

docker run --gpus all -p 8000:8000 \
  -e HUGGING_FACE_HUB_TOKEN=your_token_here \
  -e API_KEY=your_api_key_here \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  sd-api

docker run --gpus all -p 8000:8000 \
  -e HUGGING_FACE_HUB_TOKEN=your_token_here \
  -e API_KEY=your_api_key_here \
  -e MODEL_ID=stabilityai/stable-diffusion-3.5-large \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  sd-api

docker run --gpus all -p 8000:8000 \
  -e HUGGING_FACE_HUB_TOKEN=your_token_here \
  -e API_KEY=your_api_key_here \
  -e GPU_MEMORY_UTILIZATION=0.7 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  sd-api

docker run -d --name sd-api --gpus all -p 8000:8000 \
  -e HUGGING_FACE_HUB_TOKEN=your_token_here \
  -e API_KEY=your_api_key_here \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  sd-api

# View logs
docker logs -f sd-api

# Stop container
docker stop sd-api

curl -X POST http://localhost:8000/v1/images/generations \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "A beautiful sunset over mountains"}'

curl http://localhost:8000/health

{
  "status": "healthy",
  "model_loaded": true
}

curl -X POST http://localhost:8000/v1/images/generations \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A beautiful sunset over mountains, digital art, high quality",
    "n": 1,
    "size": "1024x1024",
    "response_format": "b64_json"
  }'

{
  "created": 1706450400,
  "data": [
    {
      "b64_json": "iVBORw0KGgoAAAANSUhEUgAABAAAAAQA..."
    }
  ]
}

# Generate and save to file
curl -s -X POST http://localhost:8000/v1/images/generations \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "A majestic mountain landscape"}' \
  | jq -r '.data[0].b64_json' | base64 -d > output.png

http://localhost:8000/docs

http://localhost:8000/redoc

{
  "error": "Error message describing what went wrong",
  "code": "error_code",
  "param": null
}

version: '3.8'

services:
  sd-api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HUGGING_FACE_HUB_TOKEN}
      - API_KEY=${API_KEY}
      - MODEL_ID=stabilityai/stable-diffusion-3.5-large-turbo
    volumes:
      - huggingface-cache:/root/.cache/huggingface
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 300s

volumes:
  huggingface-cache:

export HUGGING_FACE_HUB_TOKEN=your_token_here
export API_KEY=your_api_key_here
docker-compose up -d

import base64
import requests

# Generate an image
response = requests.post(
    "http://localhost:8000/v1/images/generations",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "prompt": "A cyberpunk city at night, neon lights, rain",
        "n": 1,
        "size": "1024x1024"
    }
)

# Save the image
data = response.json()
image_b64 = data["data"][0]["b64_json"]
image_bytes = base64.b64decode(image_b64)

with open("generated_image.png", "wb") as f:
    f.write(image_bytes)

print("Image saved to generated_image.png")

from openai import OpenAI

# Point to local SD API
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="your-api-key"  # Must match the API_KEY environment variable
)

response = client.images.generate(
    prompt="A serene Japanese garden with cherry blossoms",
    n=1,
    size="1024x1024"
)

# Access the base64 image data
image_b64 = response.data[0].b64_json

# Test token access
curl -H "Authorization: Bearer YOUR_TOKEN" \
  https://huggingface.co/api/models/stabilityai/stable-diffusion-3.5-large-turbo

docker logs -f sd-api

.
├── Dockerfile              # Docker image definition
├── requirements.txt        # Python dependencies
├── README.md               # This documentation
└── app/
    ├── __init__.py         # Package initialization
    ├── main.py             # FastAPI application and endpoints
    ├── models.py           # Pydantic request/response models
    └── generator.py        # Model loading and image generation