Install & Run

Run Schedy with Docker, Docker Compose, a prebuilt binary, on Kubernetes, or build it from source.

Docker

docker run -p 8080:8080 ghcr.io/ksamirdev/schedy:latest

Also available on Docker Hub as ksamirdev/schedy, and pinned to a version tag:

docker run -p 8080:8080 ghcr.io/ksamirdev/schedy:v1.0.0

To keep your tasks across restarts, mount a volume at /data (where Schedy stores its database):

docker run -p 8080:8080 -v schedy-data:/data ghcr.io/ksamirdev/schedy:latest

Docker Compose

For a persistent, self-restarting deployment, use Compose. Save this as docker-compose.yml:

services:
  schedy:
    image: ghcr.io/ksamirdev/schedy:latest
    # Pin a release tag for production, e.g. ghcr.io/ksamirdev/schedy:v1.0.0
    ports:
      - "8080:8080"
    environment:
      # Strongly recommended: set a key so every endpoint requires X-API-Key.
      # Leave unset to run open - fine for a local trial, not for the internet.
      SCHEDY_API_KEY: ${SCHEDY_API_KEY:-}
      SCHEDY_HISTORY_TTL: ${SCHEDY_HISTORY_TTL:-72h}
    volumes:
      - schedy-data:/data
    restart: unless-stopped
    healthcheck:
      # /readyz returns 200 only when the store is reachable (no auth needed).
      test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://localhost:8080/readyz"]
      interval: 30s
      timeout: 5s
      retries: 3
      start_period: 5s

volumes:
  schedy-data:

Then start it in the background:

docker compose up -d

Your tasks live in the named schedy-data volume, so they survive docker compose down followed by docker compose up. Only docker compose down -v (which deletes volumes) wipes them.

To require an API key, put it in a .env file next to docker-compose.yml:

# .env
SCHEDY_API_KEY=your-secret

Compose reads .env automatically, and every endpoint then needs the X-API-Key header. See Configuration for all environment variables and Backup & Restore for snapshotting the volume safely.

Binary

Grab a prebuilt binary from the Releases page, or build from source:

go build -o schedy ./cmd/schedy
./schedy --port 8080

Requires Go 1.23+.

Kubernetes

Deploy Schedy on Kubernetes with health probes:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: schedy
spec:
  replicas: 1
  selector:
    matchLabels:
      app: schedy
  template:
    metadata:
      labels:
        app: schedy
    spec:
      containers:
      - name: schedy
        image: ghcr.io/ksamirdev/schedy:v1.0.0
        ports:
        - containerPort: 8080
        env:
        - name: SCHEDY_API_KEY
          valueFrom:
            secretKeyRef:
              name: schedy-secrets
              key: api-key
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 10
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /readyz
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5
        volumeMounts:
        - name: data
          mountPath: /data
      volumes:
      - name: data
        persistentVolumeClaim:
          claimName: schedy-data

For more details on health probes, see Health checks.

Persistence

Data persists to the data/ directory (BadgerDB), so tasks survive restarts. To preserve scheduled work, take a safe online snapshot rather than copying the live directory - see Backup & Restore.