Uptime monitoring for Sablier workload orchestrator

Sablier is an open source workload startup and shutdown orchestrator for Docker, Docker Swarm, and Kubernetes. It dynamically starts containers on demand and shuts them down after idle periods — making it a critical piece of infrastructure for cost-efficient deployments. When Sablier's HTTP API goes down or its provider connection breaks, all on-demand container orchestration stops cold: requests time out, dynamic workloads never spin up, and users see blank pages.

This tutorial covers production-grade uptime monitoring for Sablier using Vigilmon. We will walk through:

• Monitoring the Sablier HTTP API health endpoint
• Monitoring container lifecycle management pipeline health
• Monitoring provider connectivity (Docker, Docker Swarm, Kubernetes)
• Monitoring dynamic session tracking
• Monitoring reverse proxy integration health

Prerequisites

• Sablier running on port 10000 (Docker, Docker Swarm, or Kubernetes)
• A free account at vigilmon.online

Part 1: Monitor the Sablier HTTP API health endpoint

Sablier exposes its HTTP API on port 10000 by default. The API serves both session management requests and health-check endpoints. Monitoring the root or a known route confirms that the Go HTTP server is accepting connections.

Check the Sablier health endpoint

curl -s http://localhost:10000/health

If you are running Sablier with Docker Compose:

# docker-compose.yml
version: "3.8"

services:
  sablier:
    image: sablierapp/sablier:latest
    command:
      - start
      - --provider.name=docker
    ports:
      - "10000:10000"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.sablier.rule=Host(`sablier.example.com`)"

Set up the Vigilmon HTTP monitor

1. Log in to vigilmon.online and click Add Monitor.
2. Choose HTTP(S) monitor.
3. Enter: http://your-sablier-host:10000/health
4. Set interval to 1 minute.
5. Set expected status code to 200.
6. Name it Sablier API Health.
7. Click Save.

This monitor confirms the Sablier Go HTTP server is alive and accepting requests. A DOWN event here means all workload orchestration is broken.

Part 2: Monitor the dynamic session tracking API

Sablier manages dynamic sessions — tracking which workloads are active and which have gone idle. The /api/strategies/dynamic endpoint is the core session management path. If sessions cannot be created or queried, containers never start on demand.

Test the dynamic session endpoint

# Query a dynamic session for a workload group named "myapp"
curl -s "http://localhost:10000/api/strategies/dynamic?group=myapp&session_duration=5m"

A healthy response returns either a 200 OK (session ready) or 202 Accepted (starting) — both indicate the session management layer is functioning. A 500 or connection refused indicates the session tracking subsystem has failed.

Vigilmon setup for session tracking

1. Click Add Monitor in Vigilmon.
2. Choose HTTP(S) monitor.
3. Enter: http://your-sablier-host:10000/api/strategies/dynamic?group=healthcheck&session_duration=1m
4. Set interval to 2 minutes.
5. Under Advanced, set accepted status codes to 200,202.
6. Name it Sablier Session Tracking.
7. Click Save.

Part 3: Monitor provider connectivity

Sablier supports three providers: Docker (local), Docker Swarm, and Kubernetes. If the provider connection breaks, Sablier cannot start or stop any containers even if its own API is healthy. Monitor the provider health path to catch these failures separately.

Docker provider health

When using the Docker provider, Sablier communicates over the Docker socket. A socket permission error, Docker daemon restart, or volume mount issue breaks provider connectivity:

# Verify the Docker provider is responding through Sablier
curl -s http://localhost:10000/api/strategies/dynamic?group=healthcheck&session_duration=1m \
  -H "Accept: application/json"

Kubernetes provider health

For Kubernetes deployments, Sablier uses the in-cluster service account to scale deployments. Monitor the API server reachability from within the cluster:

# sablier-deployment.yaml (partial)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: sablier
  namespace: sablier
spec:
  replicas: 1
  selector:
    matchLabels:
      app: sablier
  template:
    spec:
      serviceAccountName: sablier
      containers:
        - name: sablier
          image: sablierapp/sablier:latest
          args:
            - start
            - --provider.name=kubernetes
          ports:
            - containerPort: 10000

Expose the Sablier service for external monitoring:

apiVersion: v1
kind: Service
metadata:
  name: sablier
  namespace: sablier
spec:
  selector:
    app: sablier
  ports:
    - port: 10000
      targetPort: 10000
  type: ClusterIP

Then set up an ingress and monitor https://sablier.example.com/health.

Vigilmon setup for provider health

Create a separate monitor for the provider connectivity test:

1. Click Add Monitor.
2. Choose HTTP(S) monitor.
3. Enter the Sablier API URL with a known test group: http://your-sablier-host:10000/api/strategies/dynamic?group=provider-test&session_duration=1m
4. Set interval to 3 minutes.
5. Accepted status codes: 200,202,404 (404 is valid if no matching group exists — it still means the provider is reachable).
6. Name it Sablier Provider Connectivity.
7. Click Save.

Part 4: Monitor reverse proxy integration health

Sablier integrates with reverse proxies — Traefik, Nginx, Caddy — through middleware or plugins. The reverse proxy plugin queries Sablier before forwarding each request, waiting for the workload to be ready. If this integration breaks, users see gateway errors even when both the proxy and Sablier are running.

Traefik plugin integration check

When Sablier is used as Traefik middleware, every inbound request to a dynamic route goes through Sablier:

# traefik dynamic config
http:
  middlewares:
    sablier-middleware:
      plugin:
        sablier:
          sablierUrl: http://sablier:10000
          sessionDuration: 5m
          names: myapp
          group: myapp
          dynamic:
            displayName: "Loading myapp..."
            theme: hacker-terminal

Monitor the loading page endpoint to confirm the middleware is functional:

# This should return the Sablier waiting/loading page (200 or redirect)
curl -I http://your-traefik-host/your-dynamic-route

Vigilmon setup for proxy integration

1. Click Add Monitor.
2. Choose HTTP(S) monitor.
3. Enter the URL of a Traefik-routed service that uses Sablier middleware: https://dynamic-service.example.com/
4. Set interval to 2 minutes.
5. Accepted status codes: 200,202,301,302 (Sablier loading pages often return 200 with a waiting UI).
6. Name it Sablier Proxy Integration.
7. Click Save.

Part 5: SSL certificate monitoring

If Sablier is exposed behind a reverse proxy with TLS, monitor the certificate to catch renewal failures before they break the integration:

1. In Vigilmon, click Add Monitor.
2. Choose SSL monitor.
3. Enter: sablier.example.com
4. Set alert threshold to 14 days before expiry.
5. Add your alert channel.
6. Click Save.

Part 6: Webhook alerts

Configure Vigilmon webhooks to receive DOWN/UP events and trigger automated remediation when Sablier goes offline:

// webhook-receiver.ts
import express from 'express';

const app = express();
app.use(express.json());

app.post('/webhook/vigilmon', (req, res) => {
  const { monitor_name, status, url, response_code, checked_at } = req.body;

  if (status === 'down') {
    console.error('[VIGILMON] Sablier monitor DOWN', {
      monitor: monitor_name,
      url,
      code: response_code,
      at: checked_at,
    });

    // Restart Sablier container, alert on-call, etc.
    triggerSablierRestart({ monitor: monitor_name });
  } else if (status === 'up') {
    console.info('[VIGILMON] Sablier recovered', { monitor: monitor_name });
  }

  res.sendStatus(204);
});

Vigilmon sends this payload on DOWN and UP transitions:

{
  "monitor_id": "mon_abc123",
  "monitor_name": "Sablier API Health",
  "status": "down",
  "url": "http://your-sablier-host:10000/health",
  "checked_at": "2026-06-30T08:01:00Z",
  "response_code": 503,
  "response_time_ms": 5001
}

Summary

Your Sablier deployment now has four layers of monitoring:

1. API Health — confirms the Sablier HTTP server is alive and accepting requests.
2. Session Tracking — verifies the core dynamic session management subsystem is functional.
3. Provider Connectivity — catches Docker/Swarm/Kubernetes provider failures independently of the API layer.
4. Reverse Proxy Integration — validates that Traefik or other proxy middleware can reach Sablier and serve dynamic routes.

Vigilmon handles check scheduling, multi-region polling, alert routing, and uptime history. Any failure in your Sablier orchestration stack triggers an alert within 60 seconds.

Monitor your Sablier deployment free at vigilmon.online

#sablier #docker #kubernetes #devops #monitoring