tutorial

Monitoring EasyPanel with Vigilmon

EasyPanel is your self-hosted Heroku alternative for deploying apps on a VPS — but if the panel goes down, you lose control of every app running on it. Here's how to monitor the EasyPanel dashboard, tRPC API, Docker socket proxy, SSL certificates, and application heartbeats with Vigilmon.

EasyPanel is a modern server management panel for self-hosted application deployment — it handles Docker containers, databases, and reverse proxy configuration through a clean web UI, without the complexity of Kubernetes. But EasyPanel is also infrastructure: if the panel itself goes down, you lose visibility into and control over every application running on your server. Vigilmon monitors the EasyPanel dashboard, tRPC API, Docker management layer, SSL certificates, and the applications EasyPanel deploys — so your management plane and apps are always accounted for.

What You'll Set Up

  • HTTP uptime monitor for the EasyPanel dashboard login page (port 3000)
  • tRPC API availability check via the auth.getUser endpoint
  • Docker TCP socket proxy health check for the container management layer
  • SSL certificate expiry alerts for the EasyPanel dashboard and deployed applications
  • Cron heartbeat monitoring for EasyPanel-managed application health

Prerequisites

  • EasyPanel installed on a VPS (Docker-based, port 3000)
  • EasyPanel dashboard accessible over HTTPS
  • At least one application deployed and running via EasyPanel
  • A free Vigilmon account

Step 1: Monitor the EasyPanel Dashboard Login Page

The EasyPanel dashboard on port 3000 is your control plane. If it's down, you cannot view application status, restart crashed containers, update environment variables, or deploy new versions — even if all your apps are still running.

  1. Log in to vigilmon.online and click Add Monitor.
  2. Set Type to HTTP / HTTPS.
  3. Enter the EasyPanel URL: https://your-server-ip:3000 or https://panel.yourdomain.com
  4. Set Check interval to 2 minutes.
  5. Set Expected HTTP status to 200.
  6. Under Keyword check, add EasyPanel or Login to confirm the dashboard is serving the real interface — not a crash page.
  7. Click Save.

EasyPanel typically runs with a self-signed certificate on initial install. If you've configured a custom domain with Let's Encrypt through EasyPanel's built-in certificate management, keep certificate verification enabled. For self-signed certificates, disable it in the monitor settings while you set up a proper certificate.

Step 2: Monitor the tRPC API Endpoint

EasyPanel's backend uses a tRPC API that the dashboard frontend calls for all operations. Monitoring the auth.getUser tRPC endpoint verifies that the API layer is responsive and the session/authentication system is functional.

  1. Click Add Monitor → HTTP / HTTPS.
  2. Enter the tRPC endpoint URL: https://panel.yourdomain.com/api/trpc/auth.getUser
  3. Set Check interval to 5 minutes.
  4. Set Expected HTTP status to 200 (returns user data or an auth error — the API is responding either way; a 401 or 403 is also valid as long as the server is up).
  5. Under Keyword check, add "result" to confirm a tRPC response envelope is returned.
  6. Click Save.

The tRPC endpoint returns a JSON envelope regardless of authentication status:

curl -s https://panel.yourdomain.com/api/trpc/auth.getUser | jq .
# {"result":{"data":{"json":null}}} (unauthenticated)
# {"result":{"data":{"json":{"id":"...","email":"..."}}}} (authenticated)

Both responses confirm the API is alive. If Vigilmon gets a 502 or a non-JSON response, the EasyPanel backend process has crashed or the Docker container is stopped.

Step 3: Check the Docker Socket Proxy Health

EasyPanel manages Docker containers through a Docker socket proxy — the component that translates EasyPanel API calls into Docker engine operations. If this proxy fails, EasyPanel can't start, stop, or inspect any containers, even though the dashboard UI might still load.

EasyPanel runs its Docker proxy internally. To monitor it from outside, create a lightweight HTTP health endpoint using a small container sidecar:

# Add to your docker-compose.yml or run manually
docker run -d \
  --name docker-health-proxy \
  --restart unless-stopped \
  -p 2376:2376 \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -e DOCKER_HOST=unix:///var/run/docker.sock \
  alpine/curl sh -c 'while true; do
    if curl -s --unix-socket /var/run/docker.sock http://localhost/version > /dev/null 2>&1; then
      echo -e "HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok" | nc -l -p 2376 -q 1
    else
      echo -e "HTTP/1.1 503 Service Unavailable\r\nContent-Length: 4\r\n\r\ndown" | nc -l -p 2376 -q 1
    fi
  done'

Then add a Vigilmon TCP monitor:

  1. Click Add Monitor → TCP Port.
  2. Enter your server address and port 2376.
  3. Set Check interval to 5 minutes.
  4. Click Save.

Alternatively, use EasyPanel's built-in /api/health endpoint if your version exposes one:

curl -s https://panel.yourdomain.com/api/health

Step 4: SSL Certificate Alerts for EasyPanel and Deployed Apps

EasyPanel manages Let's Encrypt certificates for both the panel itself and the applications it deploys. Certificate renewal failures are particularly dangerous in EasyPanel setups because one failed renewal can cascade across multiple application domains managed by the same nginx reverse proxy.

Monitor the EasyPanel Dashboard Certificate

  1. Open the EasyPanel dashboard monitor 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.

Monitor Each Deployed Application's Certificate

For each application deployed through EasyPanel with a custom domain, add a separate SSL monitor:

  1. Click Add Monitor → HTTP / HTTPS.
  2. Enter the application URL: https://myapp.yourdomain.com
  3. Enable Monitor SSL certificate.
  4. Set Alert when certificate expires in less than 21 days.
  5. Click Save.

List your EasyPanel-managed domains to know which need monitoring:

# On your VPS — list nginx virtual host configs managed by EasyPanel
ls /etc/nginx/sites-enabled/
# or check EasyPanel's nginx config directory
docker exec easypanel cat /etc/nginx/conf.d/*.conf | grep server_name

Add a Vigilmon monitor for each unique domain. EasyPanel automatically renews Let's Encrypt certificates, but the renewal process can fail if:

  • Port 80 is blocked by a firewall rule
  • The domain's DNS record points to a different IP
  • The certbot or acme.sh container is stopped

A 21-day alert window gives you enough time to investigate and manually trigger renewal through the EasyPanel UI under Settings → Certificates.

Step 5: Heartbeat Monitoring for EasyPanel-Managed Applications

Applications deployed through EasyPanel — APIs, web apps, background workers — can crash independently of the panel itself. EasyPanel restarts crashed containers, but a container stuck in a crash loop, a worker that's running but not processing, or an app that's up but returning errors won't be caught by Docker's restart policy.

Use Vigilmon's cron heartbeat for each critical application deployed via EasyPanel.

  1. In Vigilmon, click Add Monitor → Cron Heartbeat.
  2. Set the expected ping interval to match the application's natural activity cycle.
  3. Copy the heartbeat URL (e.g., https://vigilmon.online/heartbeat/abc123).
  4. Configure the application to send the heartbeat ping.

For a Web Application

Add a health check route to your application and point a Vigilmon HTTP monitor at it:

// Express.js — add to your app
app.get('/health', (req, res) => {
  res.json({ status: 'ok', uptime: process.uptime() });
});

Set the EasyPanel health check for this app in the project settings:

  • Health Check Path: /health
  • Health Check Port: your application port

Then add an HTTP monitor in Vigilmon pointing to https://myapp.yourdomain.com/health.

For a Background Worker

Add the heartbeat ping at the end of each successful job cycle:

# Python worker — ping after each successful batch
import httpx
import asyncio

HEARTBEAT_URL = "https://vigilmon.online/heartbeat/abc123"

async def process_batch():
    # ... your job logic ...
    await asyncio.sleep(0)  # yield

async def worker_loop():
    while True:
        await process_batch()
        async with httpx.AsyncClient() as client:
            await client.get(HEARTBEAT_URL, timeout=5)
        await asyncio.sleep(60)  # wait for next cycle

EasyPanel makes it easy to add environment variables to your app — store the heartbeat URL as VIGILMON_HEARTBEAT_URL in the app's environment settings in the EasyPanel UI.

Step 6: Configure Alert Channels

  1. Go to Alert Channels in Vigilmon and add email, Slack, or a webhook.
  2. For the dashboard and tRPC API monitors, set Consecutive failures before alert to 2 — EasyPanel container restarts take 10–30 seconds.
  3. For application monitors, set Consecutive failures before alert based on the application's criticality — 1 for APIs serving users, 2–3 for background workers.
  4. For heartbeat monitors, leave the threshold at 1 missed ping.

Consider creating separate alert channels for:

  • Panel alerts (dashboard + tRPC): route to system admin — management plane issues
  • Application alerts: route to the application's owning team or on-call
# Test your alert channel with a manual pause/unpause
curl -X POST https://vigilmon.online/api/monitors/YOUR_MONITOR_ID/pause \
  -H "Authorization: Bearer YOUR_API_KEY"
# Wait for alert, then unpause
curl -X POST https://vigilmon.online/api/monitors/YOUR_MONITOR_ID/unpause \
  -H "Authorization: Bearer YOUR_API_KEY"

Summary

| Monitor | Target | What It Catches | |---|---|---| | EasyPanel dashboard | https://panel.domain.com:3000 | Panel crash, process exit | | tRPC API | /api/trpc/auth.getUser | Backend failure, API errors | | Docker proxy | TCP port 2376 | Docker socket unavailable | | SSL — panel | Panel domain | Panel certificate expiry | | SSL — apps | Each app domain | App certificate expiry | | App heartbeat | Heartbeat URL | App crash loop, worker stall |

EasyPanel gives indie developers and small teams the power of a managed PaaS on their own VPS — but the management panel is itself infrastructure that needs monitoring. With Vigilmon watching the EasyPanel dashboard, tRPC API, Docker management layer, certificates for both the panel and every deployed app, and application heartbeats configured through EasyPanel's project settings, you have full-stack visibility from the control plane down to individual applications.

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