tutorial

Monitoring Containers and Kubernetes Managed with Podman Desktop Using Vigilmon

Podman Desktop lets you manage containers and Kubernetes locally without a Docker daemon, but it has no built-in uptime monitoring. Here's how to add external health checks, port monitoring, and cron heartbeats to your Podman-managed workloads with Vigilmon.

Podman Desktop is the open-source desktop application for managing containers and Kubernetes workloads without a Docker daemon — daemonless, rootless, and OCI-compliant. It's become a popular alternative for developers who want a familiar GUI for podman commands and local Kubernetes via Kind or Podman's built-in Kubernetes support. But Podman Desktop is a developer tool, not a monitoring service. Vigilmon adds the continuous external monitoring layer: HTTP uptime checks, TCP port monitoring, SSL certificate alerts, and heartbeats for scheduled containers.

What You'll Set Up

  • HTTP uptime monitors for containers and pods exposed by Podman Desktop
  • TCP port checks for Podman's local Kubernetes API
  • Cron heartbeats for scheduled container tasks
  • SSL certificate monitoring for TLS-enabled endpoints
  • Alert channels for downtime notification

Prerequisites

  • Podman Desktop installed with at least one running container or pod
  • A service exposed on a host port (via -p or a Kubernetes port mapping)
  • A free Vigilmon account

Step 1: Monitor Exposed Container Ports

When you run a container with Podman Desktop and publish a port, it's accessible on localhost (or a specific host interface). Add a Vigilmon HTTP monitor for each published web service:

  1. Log in to vigilmon.online and click Add Monitor.
  2. Set Type to HTTP / HTTPS.
  3. Enter the container's host port URL: http://localhost:8080 or https://myapp.local.
  4. Set Check interval to 1 minute.
  5. Set Expected HTTP status to 200.
  6. Click Save.

To find published ports in Podman Desktop, open the Containers view, click on a container, and check the Ports tab. You can also use the CLI:

podman ps --format "{{.Names}}\t{{.Ports}}"
# myapp    0.0.0.0:8080->8080/tcp

For production-like local deployments, use a custom hostname via /etc/hosts and add the full URL to Vigilmon. If the service runs on a remote VM managed through Podman Desktop's SSH connection feature, use the VM's IP instead of localhost.

Step 2: Add Health Endpoints to Your Containers

A dedicated health route gives Vigilmon a richer signal than a plain port check. Add one to your container application:

Python / Flask

@app.route('/health')
def health():
    return {'status': 'ok', 'container': 'podman'}, 200

Go

http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    fmt.Fprint(w, `{"status":"ok"}`)
})

Node.js

app.get('/health', (req, res) => res.json({ status: 'ok' }));

Rebuild and restart the container in Podman Desktop (click the container → Restart, or Delete and re-run with the new image). Then verify:

podman build -t myapp:latest .
podman run -d -p 8080:8080 --name myapp myapp:latest
curl http://localhost:8080/health
# {"status":"ok"}

You can also use Podman's built-in health check in the container definition:

podman run -d \
  --name myapp \
  -p 8080:8080 \
  --health-cmd="curl -f http://localhost:8080/health || exit 1" \
  --health-interval=30s \
  --health-retries=3 \
  myapp:latest

Podman Desktop shows the health status in the Containers list. Vigilmon provides the external view from outside the container runtime.

Step 3: Monitor Podman's Built-in Kubernetes API

Podman Desktop includes built-in Kubernetes support — it can run a local Kubernetes cluster via podman kube play. The Kubernetes API server runs locally and is accessible on port 6443. Monitor it with a TCP check:

  1. In Vigilmon, click Add Monitor → TCP Port.
  2. Set Host to localhost (or the Podman machine IP on macOS/Windows).
  3. Set Port to 6443.
  4. Set Check interval to 1 minute.
  5. Click Save.

On macOS and Windows, Podman runs in a lightweight virtual machine. Find the machine's IP:

podman machine inspect --format '{{.NetworkSettings.IPAddress}}'
# 192.168.127.2

Use that IP in the TCP monitor instead of localhost. This check confirms the Kubernetes API server is running even when Podman Desktop is closed.

Step 4: Heartbeat Monitoring for Scheduled Containers

Podman supports scheduled containers via podman generate systemd or by using cron to launch one-off containers. Vigilmon's heartbeat monitor detects when these scheduled tasks stop running.

  1. In Vigilmon, click Add Monitor → Cron Heartbeat.
  2. Set Expected ping interval to match the container's schedule (e.g. 60 minutes).
  3. Copy the heartbeat URL: https://vigilmon.online/heartbeat/abc123.

For a cron-driven container, add the ping at the end of the task script:

#!/bin/bash
# /etc/cron.hourly/run-backup-container

podman run --rm \
  -e BACKUP_TARGET=/data \
  -v /data:/data:ro \
  backup-image:latest && \
  curl -fsS https://vigilmon.online/heartbeat/abc123

For a systemd-managed Podman container (generated via podman generate systemd), add ExecStartPost to the unit file:

[Service]
ExecStart=/usr/bin/podman start -a mybackup
ExecStartPost=/usr/bin/curl -fsS https://vigilmon.online/heartbeat/abc123

If the container crashes or the cron job is removed, Vigilmon alerts after the expected interval passes with no ping.

Step 5: SSL Certificate Monitoring for TLS-Enabled Containers

If you run containers with TLS termination (using a local certificate, mkcert, or a reverse proxy like Traefik), add SSL monitoring in Vigilmon:

  1. Open the HTTP monitor for your HTTPS endpoint.
  2. Enable Monitor SSL certificate.
  3. Set Alert when certificate expires in less than 21 days.
  4. Click Save.

For local development certificates created with mkcert, check expiry with:

openssl x509 -in ~/.local/share/mkcert/rootCA.pem -noout -dates
# notAfter=Jul  9 00:00:00 2027 GMT

For containers fronted by Traefik in Podman:

# docker-compose.yml (Podman-compatible)
services:
  traefik:
    image: traefik:latest
    command:
      - "--certificatesresolvers.myresolver.acme.email=you@example.com"
      - "--certificatesresolvers.myresolver.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - letsencrypt:/letsencrypt
      - /run/user/1000/podman/podman.sock:/var/run/docker.sock:ro

Vigilmon's external SSL check validates the certificate the client actually receives — not just that it exists in the container.

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 to avoid false alarms during container restarts.
  3. For Podman Desktop containers on a development machine that goes to sleep, use Maintenance windows in Vigilmon to suppress overnight alerts:
# Suppress monitoring from 10pm to 8am
curl -X POST https://vigilmon.online/api/maintenance \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{"monitor_id": "abc123", "duration_minutes": 600}'

For always-on services running on a dedicated server managed by Podman Desktop (via SSH remote connection), keep maintenance windows short and only open them during planned updates.

Summary

| Monitor | Target | What It Catches | |---|---|---| | HTTP uptime | http://localhost:8080/health | Container crash, app errors | | TCP port | Kubernetes API :6443 | API server down | | Cron heartbeat | Vigilmon heartbeat URL | Scheduled container failure | | SSL certificate | HTTPS endpoint | TLS certificate expiry |

Podman Desktop gives you a clean, daemonless way to run containers and Kubernetes workloads — but like any local runtime, it needs external eyes. Vigilmon watches your published ports, Kubernetes API, and scheduled containers continuously, so you know immediately when a workload goes down rather than discovering it the next time you open Podman Desktop.

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