tutorial

Monitoring InvokeAI with Vigilmon

InvokeAI is a professional-grade Stable Diffusion platform with a FastAPI backend and node-based canvas. Here's how to monitor the web UI, REST API health, generation queue, and SSL certificates with Vigilmon.

InvokeAI is a professional-grade open-source Stable Diffusion interface and toolkit — a Python FastAPI backend paired with a React frontend and a node-based Unified Canvas for structured AI image creation workflows. It runs a comprehensive REST API on port 9090 and is used by digital artists, creative studios, and AI production pipelines that need version history, project management, and a structured node-based approach alongside standard text-to-image generation. When your InvokeAI instance goes down, you need to know immediately. Vigilmon gives you web UI availability monitoring, FastAPI health checks, generation queue heartbeats, and SSL certificate alerts for every InvokeAI deployment.

What You'll Set Up

  • HTTP uptime monitor for the InvokeAI web UI and FastAPI server (port 9090)
  • /api/v1/app/version REST API endpoint monitor for backend health
  • /api/v1/app/config endpoint monitor confirming model pipeline initialization
  • SSL certificate expiry alerts for HTTPS InvokeAI deployments
  • Cron heartbeat for InvokeAI queue health via /api/v1/queue/default/status

Prerequisites

  • InvokeAI installed and running (default port 9090)
  • Network access to the InvokeAI host from the internet (direct or via reverse proxy)
  • A free Vigilmon account

Step 1: Monitor the InvokeAI Web UI

InvokeAI's FastAPI server serves the React SPA on port 9090. A 200 response on the root path confirms both the FastAPI server is running and static asset serving is operational — the minimum requirement for any client to load the canvas UI.

  1. Log in to vigilmon.online and click Add Monitor.
  2. Set Type to HTTP / HTTPS.
  3. Enter the InvokeAI URL: http://your-server-ip:9090 (or your proxied domain https://invoke.yourdomain.com).
  4. Set Check interval to 1 minute.
  5. Set Expected HTTP status to 200.
  6. Click Save.

Verify InvokeAI is bound to an accessible address by checking its configuration:

# Check InvokeAI binding — default is 127.0.0.1, change to 0.0.0.0 for remote access
grep "host" ~/.invokeai/invokeai.yaml

If you need remote access, set host: 0.0.0.0 in invokeai.yaml or use a reverse proxy.

Step 2: Monitor the /api/v1/app/version REST API Endpoint

InvokeAI exposes a /api/v1/app/version endpoint that returns JSON with the application version and commit hash. This is a reliable FastAPI backend health check — a 200 response proves the API is serving requests, regardless of frontend state.

  1. Click Add Monitor in Vigilmon.
  2. Set Type to HTTP / HTTPS.
  3. Enter: http://your-server-ip:9090/api/v1/app/version
  4. Set Method to GET.
  5. Set Check interval to 1 minute.
  6. Set Expected HTTP status to 200.
  7. Optionally, set Expected response body contains to "version" for a JSON shape check.
  8. Click Save.

Test the endpoint manually:

curl http://your-server-ip:9090/api/v1/app/version
# {"version": "4.x.x", "app_name": "InvokeAI"}

This endpoint requires no authentication and returns quickly — making it the ideal lightweight API layer health check.

Step 3: Monitor the /api/v1/app/config REST API Endpoint

The /api/v1/app/config endpoint returns InvokeAI's model and feature configuration as JSON. A 200 response confirms the model pipeline is initialized and the configuration has been successfully loaded — a deeper health signal than the version endpoint alone.

  1. Click Add Monitor in Vigilmon.
  2. Set Type to HTTP / HTTPS.
  3. Enter: http://your-server-ip:9090/api/v1/app/config
  4. Set Method to GET.
  5. Set Check interval to 2 minutes.
  6. Set Expected HTTP status to 200.
  7. Click Save.

This unauthenticated endpoint is safe to monitor from an external probe and catches model pipeline initialization failures that won't surface on the version endpoint.

Step 4: SSL Certificate Alerts for HTTPS Deployments

InvokeAI deployments exposed to the internet should run behind a reverse proxy with TLS. Certificate expiry silently locks users out of their canvas and breaks API integrations.

Add a certificate expiry monitor for your InvokeAI domain:

  1. Open the HTTP monitor for your proxied InvokeAI domain (created in Step 1).
  2. Enable Monitor SSL certificate under the SSL section.
  3. Set Alert when certificate expires in less than 21 days.
  4. Click Save.

A sample nginx reverse proxy configuration for InvokeAI:

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

    ssl_certificate /etc/letsencrypt/live/invoke.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/invoke.yourdomain.com/privkey.pem;

    client_max_body_size 100M;

    location / {
        proxy_pass http://127.0.0.1:9090;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_read_timeout 300s;
    }
}

InvokeAI uses WebSocket connections for real-time canvas updates — the Upgrade and Connection headers are required.

Step 5: Heartbeat Monitoring for the Generation Queue

InvokeAI manages image generation through a queue service. The /api/v1/queue/default/status endpoint returns the current queue state including item count and status. Monitoring this endpoint as a heartbeat confirms InvokeAI's generation queue service is operational and ready to accept work from the canvas or API clients.

  1. In Vigilmon, click Add Monitor → Cron Heartbeat.
  2. Set the expected ping interval to 10 minutes.
  3. Copy the heartbeat URL (e.g. https://vigilmon.online/heartbeat/abc123).

Create a script that polls the queue status endpoint and pings the heartbeat when the queue service responds:

#!/bin/bash
# invokeai-heartbeat.sh — run via cron every 10 minutes

QUEUE_STATUS="http://127.0.0.1:9090/api/v1/queue/default/status"
HEARTBEAT="https://vigilmon.online/heartbeat/abc123"

response=$(curl -sf --max-time 10 "$QUEUE_STATUS")
if [ $? -eq 0 ] && echo "$response" | grep -q '"queue"'; then
    curl -sf "$HEARTBEAT" > /dev/null
fi

Add to crontab:

*/10 * * * * /path/to/invokeai-heartbeat.sh

A valid JSON response from /api/v1/queue/default/status confirms InvokeAI's generation queue service is alive. Queue status looks like:

{"queue": {"item_count": 0, "status": "idle"}}

If InvokeAI crashes or the queue service hangs, the endpoint stops responding and Vigilmon alerts after the 10-minute window passes.

Step 6: Configure Alert Channels

  1. Go to Alert Channels in Vigilmon and add Slack, email, or a webhook.
  2. Set Consecutive failures before alert to 2 on the web UI monitor — InvokeAI model loading at startup can take 30–90 seconds for large checkpoints.
  3. On API endpoint monitors (/api/v1/app/version and /api/v1/app/config), set Consecutive failures to 1 — API failures while the web UI responds are always actionable.
  4. Use Maintenance windows in Vigilmon to suppress alerts during InvokeAI upgrades, which require a service restart.

Summary

| Monitor | Target | What It Catches | |---|---|---| | Web UI | http://host:9090/ | FastAPI crash, static serving failure | | API version | /api/v1/app/version | FastAPI backend failure | | API config | /api/v1/app/config | Model pipeline initialization failure | | SSL certificate | HTTPS proxied domain | Let's Encrypt renewal failure | | Queue heartbeat | /api/v1/queue/default/status cron | Queue service stall, backend hang |

InvokeAI gives creative professionals a structured, node-based AI image generation platform — but that professional-grade power requires professional-grade monitoring. With Vigilmon watching the FastAPI backend, the model pipeline, the generation queue, and your SSL certificates, you get the observability layer that keeps your InvokeAI instance production-ready.

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