Monitoring Kubernetes Clusters Managed with Lens Using Vigilmon

Lens (now OpenLens) is the most widely used Kubernetes IDE — it gives you a full desktop GUI for navigating workloads, logs, metrics, and cluster state across multiple contexts. But Lens only shows you what's happening while you have it open. Vigilmon provides the continuous, external monitoring layer your Lens-managed clusters need: uptime checks, SSL certificate alerts, and CronJob heartbeats that run around the clock, notifying you the moment something breaks.

What You'll Set Up

• HTTP uptime monitors for services and ingress endpoints in Lens-managed clusters
• TCP port monitoring for the Kubernetes API server
• CronJob heartbeat monitoring to detect silent job failures
• SSL certificate expiry alerts for ingress TLS endpoints
• Maintenance window integration for cluster upgrades

Prerequisites

• A Kubernetes cluster managed via Lens (local or remote context)
• At least one ingress or service exposed over HTTP/HTTPS
• A free Vigilmon account

Step 1: Identify and Monitor Exposed Service Endpoints

In Lens, navigate to Network → Services in the left sidebar to see all services in your cluster. Any service with type LoadBalancer or NodePort is externally reachable. For production clusters, use Network → Ingresses to find your ingress hostnames.

Add a Vigilmon HTTP monitor for each critical service:

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter the ingress or service URL, e.g. https://api.yourdomain.com.
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Click Save.

If your service exposes a Kubernetes-style health endpoint, use it:

https://api.yourdomain.com/healthz

Lens shows the pod readiness status in Workloads → Pods, but that's an internal cluster view. Vigilmon's external HTTP check validates that the entire path — DNS → ingress → service → pod — is working.

Step 2: Add Health Endpoints to Your Kubernetes Services

Expose a /healthz or /health route from each monitored service. This gives Vigilmon a meaningful signal beyond a simple port check:

Python / FastAPI

@app.get("/healthz")
async def health():
    return {"status": "ok"}

Java / Spring Boot

// Spring Boot Actuator exposes /actuator/health automatically
// Add to application.properties:
management.endpoints.web.exposure.include=health
management.endpoint.health.show-details=never

Then monitor https://api.yourdomain.com/actuator/health.

Node.js

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

After deploying, confirm in Lens under Workloads → Pods that the pod is Running and the container is Ready. Then verify externally:

curl -s https://api.yourdomain.com/healthz
# {"status":"ok"}

Step 3: Monitor the Kubernetes API Server

The Kubernetes API server is the control plane backbone. If it becomes unreachable, Lens will lose connection and show your cluster as offline. Add a TCP monitor in Vigilmon so you're alerted before you open Lens:

1. In Vigilmon, click Add Monitor → TCP Port.
2. Set Host to your control plane IP or endpoint hostname.
3. Set Port to 6443 (default API server port).
4. Set Check interval to 1 minute.
5. Click Save.

Find your API server endpoint from the Lens Cluster Settings view (the cluster name at the top left → Settings), or via kubectl:

kubectl cluster-info
# Kubernetes control plane is running at https://12.34.56.78:6443

For managed Kubernetes services (EKS, GKE, AKS), the API endpoint is in Lens under Cluster → Info in the sidebar.

Step 4: CronJob Heartbeat Monitoring

Kubernetes CronJobs that fail silently — completing with an error, or never being scheduled — won't appear as "down" in Lens unless you actively look for them. Vigilmon's heartbeat monitor catches these cases automatically.

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

Update your CronJob to ping Vigilmon on success:

apiVersion: batch/v1
kind: CronJob
metadata:
  name: report-generator
spec:
  schedule: "0 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          restartPolicy: OnFailure
          containers:
            - name: generator
              image: report-generator:latest
              command:
                - /bin/sh
                - -c
                - |
                  python generate_report.py && \
                  curl -fsS https://vigilmon.online/heartbeat/abc123

Apply the update:

kubectl apply -f cronjob.yaml

In Lens, navigate to Workloads → CronJobs to verify the Last Schedule and Last Successful timestamps. Vigilmon complements this with external alerting when the interval is missed.

Step 5: SSL Certificate Alerts for Ingress TLS

Lens shows certificate details in the Config → Secrets view for kubernetes.io/tls secrets, but it won't proactively alert you when they're close to expiry. Vigilmon does:

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

For clusters using cert-manager, check the certificate renewal status in Lens under Custom Resources → certificates.cert-manager.io, or via kubectl:

kubectl get certificates -A
# NAME        READY   SECRET        AGE
# api-cert    True    api-tls       45d

A READY: False status combined with an approaching expiry is a cert-manager renewal failure. Vigilmon's 21-day alert window gives you enough time to investigate and manually trigger renewal if needed:

kubectl delete certificate api-cert -n default
# cert-manager will recreate and re-request

Step 6: Configure Alert Channels and Maintenance Windows

1. In Vigilmon, go to Alert Channels and add Slack, email, PagerDuty, or a webhook endpoint.
2. Set Consecutive failures before alert to 2 to reduce false positives during rolling deployments.
3. When performing cluster upgrades or node drains from Lens, open a maintenance window via the Vigilmon API:

# Suppress alerts during a Lens-initiated node upgrade
curl -X POST https://vigilmon.online/api/maintenance \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{"monitor_id": "abc123", "duration_minutes": 20}'

# Perform the upgrade in Lens or kubectl
kubectl drain node1 --ignore-daemonsets --delete-emptydir-data
# ... upgrade node OS / Kubernetes version ...
kubectl uncordon node1

# Maintenance window auto-expires after 20 minutes

You can also integrate maintenance windows into your CI/CD pipeline for zero-noise deployments.

Summary

| Monitor | Target | What It Catches | |---|---|---| | HTTP uptime | https://api.yourdomain.com/healthz | Pod crash, ingress misconfiguration | | TCP port | Control plane :6443 | API server unreachable | | Cron heartbeat | Vigilmon heartbeat URL | CronJob failure or missed schedule | | SSL certificate | Ingress TLS endpoint | cert-manager renewal failure |

Lens gives you one of the best visual experiences for managing Kubernetes — but a great dashboard is only useful when you're looking at it. Vigilmon closes the gap with continuous external monitoring, ensuring that pod crashes, expired certificates, and missed CronJob runs are surfaced to you immediately, even at 3am when Lens is closed and no one is watching.