tutorial

Monitoring Komiser: Keep Your Cloud Cost Visibility Platform Healthy

How to set up uptime monitoring for Komiser so your cloud cost dashboard is always available when you need it, with Vigilmon HTTP and heartbeat monitors.

Komiser is an open-source cloud-agnostic cost intelligence platform. It connects to your AWS, GCP, Azure, OCI, and DigitalOcean accounts, inventories every resource, tracks spending trends, and surfaces cost anomalies before they hit your invoice. If Komiser itself goes down, your engineers lose cloud cost visibility at exactly the moment they need it most — during incident investigations, budget reviews, and architecture decisions.

This tutorial shows you how to add external uptime monitoring to Komiser so you know the moment your cost dashboard becomes unavailable.

What Is Komiser?

Komiser runs as a single Go binary (or Docker container) that:

  • Polls cloud provider APIs on a configurable schedule to build a real-time resource inventory
  • Stores resource and cost data in PostgreSQL or SQLite
  • Serves a web dashboard on a configurable HTTP port (default 3000)
  • Exposes cloud spending grouped by service, region, tag, and account
  • Sends Slack or custom webhook alerts when spending anomalies are detected

Because Komiser is self-hosted, its availability is entirely your responsibility. Cloud providers don't know if your Komiser instance is running. Your team only discovers the dashboard is down when someone tries to open it.

Why Monitoring Komiser Matters

Budget review interruptions — monthly cost reviews and architecture discussions depend on the dashboard being up. A silent Komiser outage means decisions get made without data.

Anomaly detection gaps — Komiser scans for cost anomalies on a schedule. If the process crashes between scans, anomalies accumulate silently until the next restart. A heartbeat monitor catches this gap.

Database connection failures — Komiser talks to PostgreSQL continuously. A dropped database connection causes the dashboard to return errors while the process appears running. External monitoring catches the user-facing failure that internal health checks miss.

Docker / Kubernetes restart loops — Komiser running in a container can enter a crash-restart loop that looks healthy in kubectl get pods or docker ps but serves partial or stale responses. Probing the actual HTTP endpoint reveals this.

What You'll Set Up

  • HTTP monitor for the Komiser dashboard endpoint
  • Heartbeat monitor to verify scheduled cost scans complete
  • Response time alerting for database query slowdowns
  • Alert routing to Slack

You'll need a free Vigilmon account — no credit card required.

Step 1: Configure a Health Endpoint

Komiser v3+ exposes a /health endpoint at the same port as the dashboard. Verify it's accessible:

curl http://your-komiser-host:3000/health
# Expected response: {"status":"healthy"}

If you run Komiser behind a reverse proxy (Nginx, Caddy, Traefik), make sure /health is forwarded without authentication so Vigilmon can probe it.

Nginx Pass-Through for /health

server {
    listen 443 ssl;
    server_name komiser.yourdomain.com;

    # Health endpoint — no auth required for monitoring
    location /health {
        proxy_pass http://localhost:3000/health;
        proxy_set_header Host $host;
    }

    # Dashboard — behind auth
    location / {
        auth_basic "Komiser";
        auth_basic_user_file /etc/nginx/.htpasswd;
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
    }
}

Step 2: Add an HTTP Monitor for the Komiser Dashboard

  1. Log in to vigilmon.online and go to Monitors → New Monitor
  2. Choose HTTP / HTTPS
  3. Set the URL: https://komiser.yourdomain.com/health
  4. Set check interval: 2 minutes
  5. Configure expected response:
    • Status code: 200
    • Response body contains: "status":"healthy"
    • Response time threshold: 3000ms
  6. Save the monitor

Komiser queries cloud provider APIs on demand when you open certain dashboard views. A 3-second response time threshold catches database slowdowns before they make the dashboard unusable.

Step 3: Heartbeat Monitor for Scheduled Cost Scans

Komiser polls cloud providers on a schedule to refresh its resource inventory. Run a wrapper script that verifies the scan completed and pings Vigilmon:

#!/bin/bash
# komiser-scan-heartbeat.sh
set -e

KOMISER_URL="${KOMISER_URL:-http://localhost:3000}"
HEARTBEAT_URL="${VIGILMON_HEARTBEAT_URL}"
MAX_AGE_SECONDS=7200  # alert if resource data is older than 2 hours

# Check the last scan timestamp via Komiser API
LAST_SCAN=$(curl -sf "$KOMISER_URL/api/v1/resources/scan/status" | \
  jq -r '.lastScanAt // empty')

if [ -z "$LAST_SCAN" ]; then
  echo "ERROR: Could not retrieve last scan timestamp"
  exit 1
fi

# Convert to epoch and check age
SCAN_EPOCH=$(date -d "$LAST_SCAN" +%s 2>/dev/null || \
             python3 -c "import datetime; print(int(datetime.datetime.fromisoformat('$LAST_SCAN'.replace('Z','+00:00')).timestamp()))")
NOW_EPOCH=$(date +%s)
AGE=$((NOW_EPOCH - SCAN_EPOCH))

if [ "$AGE" -gt "$MAX_AGE_SECONDS" ]; then
  echo "ERROR: Last scan was $((AGE/60)) minutes ago — exceeds $((MAX_AGE_SECONDS/60)) minute threshold"
  exit 1
fi

echo "Komiser scan current: last ran $((AGE/60)) minutes ago"
curl -fsS "$HEARTBEAT_URL" > /dev/null
echo "Heartbeat sent."

Run as a cron job on the same host as Komiser:

# Add to crontab
*/30 * * * * /opt/komiser/komiser-scan-heartbeat.sh >> /var/log/komiser-heartbeat.log 2>&1

Set up the heartbeat in Vigilmon:

  1. Go to Monitors → New Monitor → Heartbeat
  2. Name it Komiser cost scan
  3. Expected interval: 30 minutes
  4. Grace period: 20 minutes
  5. Copy the ping URL and set it as the VIGILMON_HEARTBEAT_URL environment variable

Step 4: Monitor Komiser in Docker or Kubernetes

Docker Health Check

If you run Komiser via Docker Compose, add a native health check that Vigilmon can also probe:

# docker-compose.yml
services:
  komiser:
    image: ghcr.io/tailwarden/komiser:latest
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URI=postgresql://komiser:secret@db:5432/komiser
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
    volumes:
      - ./config.toml:/root/.komiser/config.toml

Kubernetes Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: komiser
  namespace: monitoring
spec:
  replicas: 1
  selector:
    matchLabels:
      app: komiser
  template:
    metadata:
      labels:
        app: komiser
    spec:
      containers:
        - name: komiser
          image: ghcr.io/tailwarden/komiser:latest
          ports:
            - containerPort: 3000
          livenessProbe:
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 30
            periodSeconds: 30
          readinessProbe:
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 10
            periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
  name: komiser
  namespace: monitoring
spec:
  selector:
    app: komiser
  ports:
    - port: 3000
      targetPort: 3000
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: komiser
  namespace: monitoring
spec:
  rules:
    - host: komiser.yourdomain.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: komiser
                port:
                  number: 3000

Kubernetes readiness probes keep Komiser out of service rotation when it's unhealthy. Vigilmon monitors the external Ingress URL — catching the failure modes that internal probes miss (Ingress misconfiguration, DNS failure, TLS expiry).

Step 5: Configure Alert Channels

  1. Go to Alert Channels → New Channel → Webhook in Vigilmon
  2. Add your Slack Incoming Webhook URL for #cloud-cost-alerts
  3. Assign all Komiser monitors to this channel

Sample alert when Komiser dashboard goes down:

{
  "monitor_name": "Komiser Dashboard /health",
  "status": "down",
  "url": "https://komiser.yourdomain.com/health",
  "started_at": "2026-07-12T14:30:00Z",
  "duration_seconds": 0,
  "regions_failing": ["eu-west", "us-east"]
}

Recommended Alert Thresholds

| Monitor | Interval | Threshold | Alert channel | |---|---|---|---| | Komiser dashboard /health | 2 min | 200, "status":"healthy", < 3s | #cloud-cost-alerts | | Cost scan heartbeat | 30 min | Grace 20 min | #cloud-cost-alerts | | Database query latency | 2 min | Response > 5s | #infrastructure-alerts |

Summary

Komiser gives you cloud cost visibility — but only when it's running. External monitoring ensures that visibility is itself reliable:

| Failure | Impact | Vigilmon monitor | |---|---|---| | Process crash | Dashboard unavailable | HTTP /health monitor | | Database connection drop | Silent errors on page load | HTTP response + body check | | Scan schedule stall | Stale resource data | Heartbeat monitor | | Ingress misconfiguration | Dashboard unreachable externally | External HTTP monitor |

Start free at vigilmon.online and have Komiser monitored in under two minutes.

Monitor your app with Vigilmon

Free plan — 5 monitors, no credit card required. Up and running in 60 seconds.

Start free →
← Back to all articles