Idle Sleep

Overview

GoDoxy puts containers to sleep after a period of inactivity and wakes them automatically when traffic arrives. This feature is ideal for development environments, staging servers, or services with unpredictable usage patterns.

Supported Platforms

• Docker
• Proxmox LXCs

Supported Protocols

Quick Reference

How It Works

Sleep Behavior

1. Container receives no traffic for idle_timeout duration
2. GoDoxy executes stop_method on the container
3. Container dependencies are stopped in order
4. Traffic to the route triggers wake-up sequence

Wake Behavior

1. Request arrives for sleeping route
2. For an HTML navigation, GoDoxy returns the loading page immediately and starts one background wake operation
3. Dependencies start first (if configured)
4. Main container starts
5. The loading page receives startup progress over server-sent events
6. GoDoxy waits up to wake_timeout for readiness, then the loading page refreshes into the active service

Non-HTML requests, and all requests when no_loading_page is enabled, wait for wake-up so GoDoxy can proxy the original request after the service becomes ready. Canceling an HTML navigation after its loading page has been returned does not cancel the shared wake operation.

Idle start, ready, sleep, pause, and error transitions appear in the WebUI Live Activity feed.

Dependency Management

Containers with depends_on are managed as a group. This ensures related services start and stop together.

Condition Types

Control when dependencies are considered ready:

Docker Compose Example

# Without conditions (implies service_started)
depends_on:
  - redis
  - postgres

# With explicit conditions
depends_on:
  redis:
    condition: service_healthy
  postgres:
    condition: service_started

Label Syntax

labels:
  proxy.depends_on: |
    - redis:service_healthy
    - postgres:service_started

Docker Configuration

Enable idle sleep by adding labels to your container:

services:
  app:
    image: nginx:latest
    container_name: my-app
    labels:
      # Required
      proxy.idle_timeout: 1h30s
      # Optional
      proxy.wake_timeout: 30s
      proxy.stop_method: stop
      proxy.stop_timeout: 10s
      proxy.stop_signal: SIGINT
      proxy.start_endpoint: /start
      proxy.no_loading_page: true
    depends_on:
      redis:
        condition: service_healthy
      postgres:
        condition: service_healthy

  redis:
    image: redis:alpine
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  postgres:
    image: postgres:16
    # Healthcheck configured via GoDoxy health monitoring

Proxmox LXC Configuration

See Proxmox Integration for detailed configuration options.

Property Reference

Core Properties

Stop Control

UI Options

Duration Format

Use standard duration notation:

Examples

Development Environment

services:
  dev-api:
    image: myapp/api:latest
    labels:
      proxy.idle_timeout: 30m
      proxy.wake_timeout: 60s
      proxy.stop_method: kill
      proxy.stop_timeout: 5s
    depends_on:
      dev-db:
        condition: service_healthy
  dev-db:
    image: postgres:16
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 3s

Staging with Specific Wake Endpoint

services:
  staging-app:
    image: myapp/staging:latest
    labels:
      proxy.idle_timeout: 2h
      proxy.start_endpoint: /api/wake
      proxy.no_loading_page: false

Best Practices

1. Use healthchecks with service_healthy condition for reliable dependencies
2. Set appropriate timeouts based on your service startup time
3. Test wake behavior before deploying to production
4. Monitor container logs during initial setup
5. Use consistent stop signals that match your application