tutorial

How to Monitor Eclipse Che with Vigilmon

Eclipse Che is the enterprise cloud IDE — a Kubernetes-native workspace platform that provisions containerized development environments at scale. Organizatio...

Eclipse Che is the enterprise cloud IDE — a Kubernetes-native workspace platform that provisions containerized development environments at scale. Organizations running Che for hundreds of developers need the same reliability guarantees they'd apply to production services. When Che goes down, development stops.

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

Why Eclipse Che needs external monitoring

Eclipse Che is a multi-component system running on Kubernetes. Each component is a failure point, and Kubernetes health probes only catch what happens inside the cluster:

  • Che Server unavailability — the central API server can fail or become unresponsive while pods show Running. Workspaces can't be created or joined
  • Dashboard unreachability — the Che dashboard is the developer-facing entry point. Ingress misconfigurations, certificate failures, or load balancer issues can make it unreachable without affecting pod health
  • Keycloak/OIDC provider failures — Che relies on an identity provider for authentication. If Keycloak degrades, developers can't log in and existing sessions may break
  • Workspace controller failures — the DevWorkspace operator can get stuck, leaving workspace provisioning in a permanent pending state
  • Persistent volume attachment issues — workspace PVCs can fail to attach after node rescheduling, leaving workspaces that appear to be starting but never become accessible
  • Namespace quota exhaustion — a cluster quota limit silently rejects new workspace creation without surfacing an error to the monitoring layer

External monitoring from Vigilmon detects these failures from outside the cluster, the same way a developer's browser would.

What you'll need

  • A running Eclipse Che deployment on Kubernetes (installed via the Che Operator or chectl)
  • The Che dashboard URL accessible externally (typically https://che.yourdomain.com)
  • A free Vigilmon account (sign up takes 30 seconds)

Step 1: Verify your Che deployment is accessible

After installing Che via the operator, get the dashboard URL:

# Using chectl
chectl server:status

# Using kubectl directly
kubectl get checluster -n eclipse-che -o jsonpath='{.status.cheURL}'
# https://che.yourdomain.com

Verify the dashboard responds:

curl -I https://che.yourdomain.com
# HTTP/2 200
# content-type: text/html

Also verify the Che server API:

curl https://che.yourdomain.com/api/
# {"implementationVersion":"7.x.x",...}

Check the health endpoints

Eclipse Che exposes health and readiness endpoints on the Che server:

# Che server health (internal, via port-forward)
kubectl port-forward -n eclipse-che svc/che 8080:8080 &
curl http://localhost:8080/api/system/state
# {"status":"RUNNING"}

# Or via the external URL if Che routes the health API
curl https://che.yourdomain.com/api/system/state

The /api/system/state endpoint returns a status field. When Che is healthy it returns RUNNING. This is the ideal endpoint to monitor.

Step 2: Set up HTTP monitoring in Vigilmon

Add your Che endpoints to Vigilmon:

Monitor 1: The Che Dashboard

  1. Log in to vigilmon.online and go to Monitors → New Monitor
  2. Choose HTTP / HTTPS as the monitor type
  3. Set the URL to: https://che.yourdomain.com
  4. Set the check interval to 1 minute
  5. Expected response: status code 200
  6. Save the monitor

This confirms developers can reach the entry point of your Che instance.

Monitor 2: The Che API health endpoint

  1. Create another monitor
  2. Set the URL to: https://che.yourdomain.com/api/system/state
  3. Check interval: 1 minute
  4. Expected response:
    • Status code: 200
    • Response body contains: RUNNING
  5. Save the monitor

This is more precise than the dashboard check — it verifies the Che server process is operational, not just that the ingress is routing.

Monitor 3: Keycloak / Identity Provider

If you're running Keycloak alongside Che (standard for Che 7.x):

  1. Create a monitor for: https://keycloak.yourdomain.com/health
  2. Check interval: 1 minute
  3. Expected status: 200

Keycloak has its own health endpoint at /health (Keycloak 17+) or /auth/realms/che for older versions:

# Keycloak 17+ health check
curl https://keycloak.yourdomain.com/health
# {"status":"UP","checks":[]}

# Older Keycloak — check realm existence
curl https://keycloak.yourdomain.com/auth/realms/che
# {"realm":"che",...}

Use whichever endpoint your Keycloak version supports.

Step 3: Monitor the TCP layer

HTTP monitoring tells you if the application responds correctly. TCP monitoring catches lower-level failures — port binding issues, load balancer routing failures, or network policy changes:

  1. In Vigilmon, go to Monitors → New Monitor
  2. Choose TCP Port
  3. Host: che.yourdomain.com, port: 443
  4. Save the monitor

If the TCP monitor fails while the HTTP monitor is still reported as up, you have a TLS termination or ingress controller problem.

For Che deployments that expose additional ports (for workspace SSH access or WebSocket connections), add TCP monitors for those as well:

che.yourdomain.com:443   → HTTPS/WSS dashboard and API
che.yourdomain.com:2222  → SSH access to workspaces (if enabled)

Step 4: Configure alert channels

When Che goes down for an organization running developer workflows on it, the blast radius is large. Alert routing should reflect the severity.

Email alerts

  1. In Vigilmon, go to Alert Channels → Add Channel → Email
  2. Add your platform engineering team's email
  3. Assign the channel to all Che monitors

Webhook alerts for Slack or PagerDuty

  1. Go to Alert Channels → Add Channel → Webhook
  2. Enter your Slack webhook or PagerDuty Events API URL
  3. Assign to your Che monitors

Vigilmon sends this payload when a monitor fails:

{
  "monitor_name": "eclipse-che/api-health",
  "status": "down",
  "url": "https://che.yourdomain.com/api/system/state",
  "started_at": "2024-01-15T10:23:00Z",
  "duration_seconds": 120
}

Automated recovery on webhook

When the Che server health check fails, your webhook handler can attempt automatic recovery:

#!/bin/bash
# restart-che-server.sh — triggered by Vigilmon webhook on che/api-health failure
kubectl rollout restart deployment/che -n eclipse-che
kubectl rollout status deployment/che -n eclipse-che --timeout=120s

if [ $? -eq 0 ]; then
  echo "Che server restarted successfully"
else
  echo "Restart timed out — manual intervention required"
  # Escalate via PagerDuty or email
fi

Step 5: Diagnose Che failures when alerts fire

When Vigilmon alerts you that Che is down, use this diagnostic sequence:

# 1. Check overall Che resource status
kubectl get checluster -n eclipse-che
kubectl get pods -n eclipse-che

# 2. Check Che server logs
kubectl logs -n eclipse-che deployment/che --tail=100

# 3. Check the DevWorkspace operator
kubectl get pods -n devworkspace-controller
kubectl logs -n devworkspace-controller deployment/devworkspace-controller-manager --tail=50

# 4. Check the ingress
kubectl get ingress -n eclipse-che
kubectl describe ingress che -n eclipse-che

# 5. Check Keycloak
kubectl get pods -n keycloak
kubectl logs -n keycloak deployment/keycloak --tail=50

# 6. Test the health endpoint directly via port-forward (bypasses ingress)
kubectl port-forward -n eclipse-che svc/che 8080:8080
curl http://localhost:8080/api/system/state

If the health endpoint works via port-forward but Vigilmon shows the URL as down, the problem is in the ingress layer — check your ingress controller logs:

# nginx-ingress
kubectl logs -n ingress-nginx deployment/ingress-nginx-controller --tail=50

# If using OpenShift / Route instead of Ingress
oc get route che -n eclipse-che

Step 6: TLS certificate monitoring

Che installations often use cert-manager with Let's Encrypt. Certificate renewal failures are silent — the process keeps running, but browsers start rejecting connections when the cert expires.

Vigilmon automatically monitors certificate expiry for all HTTPS monitors. You'll receive alerts:

  • 30 days before expiry — investigate renewal failures
  • 7 days before expiry — urgent action required
  • On expiry — the HTTP monitor will start failing as browsers refuse the connection

Check cert-manager certificate status proactively:

# List certificates in the Che namespace
kubectl get certificates -n eclipse-che

# Describe to see renewal status
kubectl describe certificate che-tls -n eclipse-che

# Check cert-manager controller logs
kubectl logs -n cert-manager deployment/cert-manager --tail=50

Step 7: Monitor workspace-level health with heartbeats

Beyond monitoring Che's infrastructure, you can monitor whether Che is actually creating working workspaces. Use Vigilmon's heartbeat monitors for this:

  1. In Vigilmon, go to Monitors → New Monitor
  2. Choose Heartbeat as the monitor type
  3. Create a heartbeat monitor with a 15-minute interval
  4. Copy the heartbeat URL

Then schedule a workspace smoke test as a Kubernetes CronJob that sends a heartbeat on success:

# che-smoke-test-cronjob.yaml
apiVersion: batch/v1
kind: CronJob
metadata:
  name: che-smoke-test
  namespace: eclipse-che
spec:
  schedule: "*/15 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
            - name: smoke-test
              image: curlimages/curl:latest
              command:
                - /bin/sh
                - -c
                - |
                  # Test Che API is healthy
                  STATUS=$(curl -sf https://che.yourdomain.com/api/system/state | grep -o '"RUNNING"')
                  if [ "$STATUS" = '"RUNNING"' ]; then
                    # Send heartbeat to Vigilmon
                    curl -sf "https://hb.vigilmon.online/your-heartbeat-id"
                    echo "Smoke test passed"
                  else
                    echo "Smoke test failed: Che not in RUNNING state"
                    exit 1
                  fi
          restartPolicy: Never

If the CronJob stops sending heartbeats — because Che is unhealthy or because the job itself fails to run — Vigilmon alerts you. This catches degraded states that appear healthy from a basic HTTP check but fail in practice.

Step 8: Create a status page for developers

When Che is down, developers notice immediately. A status page lets them self-diagnose rather than filing tickets.

  1. In Vigilmon, go to Status Pages → New Status Page
  2. Name it: "Eclipse Che — Developer Platform"
  3. Add your monitors organized by component:
    • Dashboard: Che dashboard URL
    • API: Che server health endpoint
    • Identity: Keycloak health
  4. Publish the page and share it in your developer onboarding documentation

Putting it all together

Here's the recommended monitoring setup for an Eclipse Che deployment:

| Monitor | Type | What it catches | |---------|------|-----------------| | https://che.yourdomain.com | HTTP | Dashboard availability, ingress routing | | https://che.yourdomain.com/api/system/state | HTTP | Che server process health | | https://keycloak.yourdomain.com/health | HTTP | Authentication provider health | | che.yourdomain.com:443 | TCP | TLS and port-level connectivity | | Workspace smoke test | Heartbeat | End-to-end workspace functionality |

What's next

  • Multi-cluster coverage — if you run Che on multiple Kubernetes clusters (e.g., per region or per team), add monitors for each instance and group them on a single status page
  • Response time baselines — Vigilmon tracks historical response times. Watch for the Che API's response time creeping up over days — a leading indicator of resource pressure before outages occur
  • Incident history — Vigilmon's uptime reports give you monthly availability data, useful for SLA reporting to engineering leadership

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

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