How to Monitor Kubermatic Kubernetes Platform with Vigilmon

Kubermatic Kubernetes Platform (KKP) is an enterprise-grade multi-cloud Kubernetes management platform that provisions, manages, and monitors Kubernetes clusters across on-premises, public cloud, and edge environments from a single control plane. It consists of the KKP Dashboard, the KKP API (Master Controller Manager), and the seed clusters that host user cluster control planes.

In this tutorial you'll set up external uptime monitoring for KKP using Vigilmon — free tier, no credit card required.

Why Kubermatic Kubernetes Platform needs external monitoring

KKP is itself the infrastructure that manages other infrastructure. When any KKP component fails:

• Cluster provisioning breaks — new cluster creation requests time out silently; teams waiting for environments are blocked
• Cluster reconciliation halts — the Master Controller Manager stops reconciling user clusters, leaving control planes in drift
• Dashboard unavailability — platform teams and developers lose self-service access to create, scale, and delete clusters
• Seed controller failures — user cluster API servers in a seed become unmanaged; add-on deployments stop updating
• Kubeconfig rotations miss — credential rotation tasks queue up; access tokens expire for users

Kubernetes liveness probes within KKP's own deployment tell you that pods are alive. They cannot confirm that the KKP API is serving requests to external clients, that the dashboard is reachable from your users' browsers, or that seed cluster connectivity is intact. External monitoring covers all of this.

What you'll need

• A running KKP installation with a master cluster and at least one seed cluster
• The KKP Dashboard/API exposed via LoadBalancer or Ingress (typically with a custom domain)
• A free Vigilmon account

Step 1: Identify your KKP endpoints

KKP exposes several key services. Find them in the kubermatic namespace:

# List KKP services
kubectl get svc -n kubermatic

# Key services you'll want to monitor:
# kubermatic-api         - the KKP REST API
# kubermatic-dashboard   - the web UI
# kubermatic-master-controller-manager - internal, not typically exposed directly

# Get external IPs (or check your Ingress)
kubectl get ingress -n kubermatic

If you've set up KKP with an Ingress controller and a domain (e.g., kubermatic.example.com), that's your primary endpoint.

Verify the API responds:

curl -s https://kubermatic.example.com/api/v2/healthz
# {"kubermatic":"ok","apiserver":"ok"}

The /api/v2/healthz endpoint is KKP's built-in health check. It reports the status of both the KKP API and its connection to the Kubernetes API server.

Step 2: Set up HTTP monitoring for the KKP API

1. Log in to vigilmon.online and go to Monitors → New Monitor
2. Choose HTTP / HTTPS as the type
3. URL: https://kubermatic.example.com/api/v2/healthz
4. Set the check interval to 1 minute
5. Under Expected response:
   • Status code: 200
   • Response body contains: "kubermatic":"ok"
6. Save the monitor

The body check for "kubermatic":"ok" ensures you get alerted even in partially-degraded states where the API server is reachable but KKP itself is reporting internal failures.

Step 3: Monitor the KKP Dashboard

The dashboard is a separate component from the API. It's what your platform teams and developers use daily. Monitor it independently:

1. Go to Monitors → New Monitor
2. Choose HTTP / HTTPS
3. URL: https://kubermatic.example.com/ (the root path of the dashboard)
4. Set interval to 1 minute
5. Expected status code: 200
6. Save

A dashboard failure that doesn't affect the API (e.g., a front-end build deployment gone wrong, an nginx config error) will be caught by this separate monitor.

Step 4: Monitor seed cluster API servers

KKP seed clusters host the control planes of all user clusters. If a seed's API server becomes unreachable, all user clusters provisioned on that seed lose their control plane.

# Get seed cluster kubeconfigs
# Seed API servers are typically exposed as LoadBalancer services
# Check the seed cluster's kube-apiserver endpoint
kubectl get svc -n kube-system kubernetes
# This is in the seed cluster's context

# Or check KKP seed configuration
kubectl get seeds -n kubermatic
kubectl get seed <seed-name> -n kubermatic -o jsonpath='{.spec.kubeconfig}'

For each seed cluster, add a TCP monitor for its API server port (typically 6443):

1. Go to Monitors → New Monitor
2. Choose TCP Port
3. Host: seed-cluster.example.com
4. Port: 6443
5. Save

This catches seed API server failures before they cascade into user cluster outages.

Step 5: Monitor user cluster API endpoints (optional, for critical clusters)

For high-priority user clusters managed by KKP, you can add direct monitors. Each user cluster gets its own kubeconfig with a unique API server URL:

# Get the API server URL for a user cluster
kubectl get cluster <cluster-name> -n kubermatic -o jsonpath='{.status.address.url}'

Add an HTTP monitor for <cluster-api-url>/healthz:

curl -sk https://user-cluster.kubermatic.example.com/healthz
# ok

This gives you visibility into individual cluster health beyond what KKP's internal reconciliation reports.

Step 6: Configure alert channels

KKP is the control plane for your entire Kubernetes fleet. Outages must be caught immediately.

Email alerts

1. Go to Alert Channels → Add Channel → Email
2. Add your platform engineering on-call address
3. Assign to all KKP monitors

Webhook alerts

1. Go to Alert Channels → Add Channel → Webhook
2. Enter your PagerDuty, Opsgenie, or Slack webhook URL

Example Vigilmon payload:

{
  "monitor_name": "KKP API /healthz",
  "status": "down",
  "url": "https://kubermatic.example.com/api/v2/healthz",
  "started_at": "2024-01-15T10:23:00Z",
  "duration_seconds": 120
}

Incident runbook when this fires:

# 1. Check KKP control plane pods
kubectl get pods -n kubermatic

# 2. Check Master Controller Manager logs
kubectl logs -n kubermatic -l app.kubernetes.io/name=kubermatic-master-controller-manager --tail=100

# 3. Check API server pod logs
kubectl logs -n kubermatic -l app.kubernetes.io/name=kubermatic-api --tail=100

# 4. Check seed controller health
kubectl get pods -n kubermatic -l app.kubernetes.io/name=kubermatic-seed-controller-manager

# 5. Verify the Ingress/LoadBalancer is routing correctly
kubectl describe ingress -n kubermatic

Step 7: Create a platform status page

Platform teams using KKP across multiple regions need a central place to track KKP health. Create a status page:

1. Go to Status Pages → New Status Page
2. Name it: "Kubernetes Platform (KKP)"
3. Add monitors: KKP API, KKP Dashboard, Seed cluster API servers
4. Publish

Share with all platform consumers so they know whether an issue is in their application or in the underlying KKP infrastructure.

Monitor summary

| Monitor | Type | What it catches | |---------|------|-----------------| | https://kubermatic.example.com/api/v2/healthz | HTTP (expect 200, body check) | KKP API health, internal connectivity to k8s | | https://kubermatic.example.com/ | HTTP (expect 200) | Dashboard availability | | seed-cluster.example.com:6443 | TCP | Seed API server reachability | | user-cluster-api.example.com/healthz | HTTP | Per-cluster control plane health |

What's next

• Certificate monitoring — KKP manages TLS across many clusters; SSL expiry monitoring in Vigilmon catches certificate issues before they become outages
• Multi-datacenter coverage — if you run KKP across multiple datacenters or cloud regions, add a monitor for each regional entry point
• Heartbeat monitoring — if KKP runs etcd backup CronJobs, add Vigilmon heartbeats to alert when backups stop completing

Get started free at vigilmon.online — no credit card, monitors start running in under a minute.