tutorial

How to Monitor DevSpace-Deployed Applications with Vigilmon

A step-by-step guide to monitoring DevSpace (Kubernetes development and deployment tool) applications with Vigilmon — covering UI server health, deployed endpoints, port-forward availability, sync status, and CI deployment checks.

DevSpace is a Kubernetes development and deployment tool built for speed. It handles image building, hot-reloading source into running containers, port forwarding for local development, and deploying to any Kubernetes cluster. Whether you're using devspace dev for an iterative inner loop or devspace deploy to ship to staging, DevSpace removes the operational friction from Kubernetes development.

But once DevSpace finishes its job, you're left with a running service. DevSpace doesn't tell you whether that service is reachable from the outside, whether latency is acceptable, or whether the port-forwarded local endpoint stays healthy across a long development session. That external visibility is what Vigilmon provides.

This tutorial walks through monitoring your DevSpace-managed applications — from the DevSpace UI server and port-forward endpoints to deployed staging services and CI pipeline heartbeats.

The Monitoring Gap in DevSpace Workflows

DevSpace gives you rich feedback during devspace dev: real-time logs, sync status, terminal access to containers. What it doesn't provide:

  • Continuous external endpoint monitoring for services deployed via devspace deploy
  • Alerts when a port-forwarded endpoint stops responding
  • Visibility into whether the DevSpace UI dashboard is accessible across your team
  • Heartbeat monitoring to detect when CI devspace deploy jobs silently fail
  • Latency tracking over time for staging services

These are exactly the gaps Vigilmon fills — an external, always-on monitor that watches from the network edge, independent of your DevSpace session.

What You'll Set Up

  • HTTP monitors for DevSpace-deployed application endpoints
  • DevSpace UI server availability check
  • Port-forward endpoint monitoring during development
  • Heartbeat monitoring for DevSpace CI deployments
  • Alert routing to your team

You'll need a free Vigilmon account — no credit card required.

Step 1: Add Health Endpoints to Your Application

Before configuring monitors, ensure your application exposes a health endpoint. DevSpace can use this for readiness detection during deploys.

// HealthController.java — Spring Boot example
package com.example.api.health;

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.Instant;
import java.util.Map;

@RestController
public class HealthController {

    private final Instant startTime = Instant.now();

    @GetMapping("/health")
    public ResponseEntity<Map<String, Object>> health() {
        return ResponseEntity.ok(Map.of(
            "status", "ok",
            "service", System.getenv().getOrDefault("SERVICE_NAME", "unknown"),
            "environment", System.getenv().getOrDefault("DEVSPACE_ENV", "unknown"),
            "uptime_seconds", Instant.now().getEpochSecond() - startTime.getEpochSecond()
        ));
    }
}

Wire the health check into your DevSpace configuration:

# devspace.yaml
version: v2beta1

images:
  app:
    image: my-registry/my-api
    buildKit: {}

deployments:
  app:
    helm:
      chart:
        name: ./charts/my-api
      values:
        image:
          repository: my-registry/my-api
          tag: ${DEVSPACE_TIMESTAMP}
        readinessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 10
          periodSeconds: 5

dev:
  app:
    imageSelector: my-registry/my-api
    sync:
      - path: ./src:/app/src
    ports:
      - port: "8080:8080"
    logs:
      enabled: true

The readinessProbe config ensures DevSpace waits for /health to return 200 before considering the deploy complete — the same endpoint Vigilmon will monitor externally.

Step 2: Monitor Your DevSpace-Deployed Staging Endpoints

When you use devspace deploy to push to a staging environment, the deployed service gets an external hostname via Ingress or LoadBalancer. Set up Vigilmon to watch it:

  1. Log in to vigilmon.online and go to Monitors → New Monitor
  2. Choose HTTP / HTTPS
  3. Set the URL: https://staging-api.yourdomain.com/health
  4. Check interval: 1 minute
  5. Expected response:
    • Status code: 200
    • Body contains: "status":"ok"
    • Response time threshold: 2000ms
  6. Save

Vigilmon probes from multiple geographic regions and uses multi-region consensus before opening an incident — a single region blip won't page you.

Monitoring Multiple Environments

DevSpace supports multiple environments via devspace use namespace and environment variables. Mirror this in your Vigilmon monitors:

| Monitor Name | URL | DevSpace Target | |---|---|---| | [staging] my-api | https://staging-api.yourdomain.com/health | staging namespace | | [preview] my-api | https://preview-api.yourdomain.com/health | preview namespace | | [prod] my-api | https://api.yourdomain.com/health | production namespace |

Group the staging and preview monitors together in a Vigilmon status page for your development team, separate from production monitors.

Step 3: Monitor the DevSpace UI Server

The DevSpace UI server runs at localhost:8090 during devspace dev sessions and provides a browser-accessible dashboard for logs, syncs, and port forwards. If you expose this on a shared host or tunnel it for remote development, monitoring its availability helps your team know if the development environment is live.

DevSpace exposes a status endpoint you can query:

# Check DevSpace UI availability
curl http://devspace-host:8090/api/commands

Add a Vigilmon monitor if your DevSpace UI is accessible from a fixed host:

  1. Go to Monitors → New Monitor → HTTP / HTTPS
  2. URL: http://devspace-host:8090/
  3. Check interval: 5 minutes
  4. Expected response: status code 200
  5. Name: devspace-ui
  6. Save

For remote development setups where DevSpace is tunneled via SSH or a reverse proxy, monitor the proxy endpoint instead:

  1. URL: https://devspace.yourteam.internal/
  2. Check interval: 5 minutes
  3. Name: devspace-ui-remote

Step 4: Port-Forward Availability Monitoring

DevSpace's port forwarding maps container ports to local ports for development access. When a sync cycle restarts a container or a network interruption breaks a tunnel, port forwards can silently fail — DevSpace will re-establish them, but there's a window where localhost:8080 returns connection refused.

During active development sessions, you can run a local monitoring check using a simple shell loop:

#!/bin/bash
# check-port-forward.sh
# Run alongside devspace dev to alert on port-forward failures

PORT=${1:-8080}
ENDPOINT="http://localhost:$PORT/health"
INTERVAL=30

while true; do
  response=$(curl -s -o /dev/null -w "%{http_code}" "$ENDPOINT" 2>/dev/null)
  if [ "$response" != "200" ]; then
    echo "$(date): Port forward health check FAILED (HTTP $response) on $ENDPOINT"
    # Optionally notify a local webhook
    # curl -s -X POST http://localhost:9999/alert -d "{\"status\":\"down\"}"
  fi
  sleep $INTERVAL
done

For staging environments where port forwarding is used persistently (e.g., database tunnels), wrap the port-forward in a service with a health check, then monitor that service with Vigilmon.

Step 5: Heartbeat Monitoring for DevSpace CI Deployments

CI pipelines that run devspace deploy benefit from heartbeat monitoring the same way any scheduled deployment does — if the pipeline fails silently, you want to know.

Set Up the Heartbeat

  1. In Vigilmon, go to Monitors → New Monitor → Heartbeat
  2. Name: devspace-ci-deploy
  3. Expected interval: 1 day
  4. Grace period: 2 hours
  5. Save and copy the ping URL

Store the URL as VIGILMON_HEARTBEAT_URL in your CI secrets.

Wire Into Your CI Pipeline

# .github/workflows/devspace-deploy.yml
name: DevSpace Deploy

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up kubectl
        uses: azure/setup-kubectl@v3

      - name: Configure kubeconfig
        run: echo "${{ secrets.KUBECONFIG }}" | base64 -d > $HOME/.kube/config

      - name: Install DevSpace
        run: |
          curl -L -o devspace \
            "https://github.com/loft-sh/devspace/releases/latest/download/devspace-linux-amd64"
          chmod +x devspace && sudo mv devspace /usr/local/bin/

      - name: Deploy to staging
        run: devspace deploy --namespace=staging --no-warn
        env:
          DEVSPACE_ENV: staging

      - name: Verify deployment health
        run: |
          sleep 10
          curl -f https://staging-api.yourdomain.com/health || exit 1

      - name: Notify Vigilmon heartbeat
        if: success()
        run: curl -fsS "${{ secrets.VIGILMON_HEARTBEAT_URL }}" > /dev/null

The heartbeat fires only on success(). If devspace deploy fails, if the post-deploy health check fails, or if any step errors out, the ping never fires — Vigilmon alerts after the grace period.

Step 6: Sync Status and Container Health

DevSpace's file sync keeps your container source in sync with local changes. When sync breaks, your running container runs stale code. While Vigilmon can't directly observe sync state, you can instrument your application to expose its build version:

# devspace.yaml — inject build timestamp as env var
deployments:
  app:
    helm:
      values:
        env:
          - name: BUILD_TIMESTAMP
            value: ${DEVSPACE_TIMESTAMP}
          - name: GIT_COMMIT
            value: ${DEVSPACE_GIT_COMMIT}

@GetMapping("/health")
public ResponseEntity<Map<String, Object>> health() {
    return ResponseEntity.ok(Map.of(
        "status", "ok",
        "build_timestamp", System.getenv().getOrDefault("BUILD_TIMESTAMP", "unknown"),
        "git_commit", System.getenv().getOrDefault("GIT_COMMIT", "unknown")
    ));
}

When Vigilmon alerts fire, the body check captures the version in the response. If the timestamp is stale, sync likely broke before the failure. This narrows root cause instantly.

Step 7: Configure Alert Channels

Slack Integration

  1. Create a Slack incoming webhook for #staging-alerts
  2. In Vigilmon, go to Alert Channels → New Channel → Webhook
  3. Paste the webhook URL
  4. Assign to all DevSpace staging monitors

Alert Channel by Environment

Configure separate alert channels so the right team gets the right alerts:

  • Production monitors → #pagerduty-oncall (immediate escalation)
  • Staging monitors → #staging-alerts (developer team visibility)
  • CI heartbeat → #ci-failures (platform team)
  • DevSpace UI → #dev-tooling (low urgency, tooling team)

Vigilmon's per-monitor alert channel configuration makes this straightforward to maintain.

Summary

DevSpace accelerates Kubernetes development by handling builds, syncs, and deploys. Vigilmon provides the continuous external monitoring that covers what DevSpace's development lifecycle cannot — external reachability, response time tracking, CI pipeline health, and environment availability.

| Concern | Tool | Coverage | |---|---|---| | Image builds and hot sync | DevSpace | Source-to-container sync | | Deployment readiness | DevSpace readinessProbe | In-cluster pod readiness | | External endpoint health | Vigilmon HTTP monitor | Full external path | | DevSpace UI availability | Vigilmon HTTP monitor | UI server on port 8090 | | SSL certificate health | Vigilmon SSL monitor | Certificate expiry | | CI deploy heartbeat | Vigilmon heartbeat | Deploy pipeline cadence | | Response time SLOs | Vigilmon response time threshold | External latency |

Start monitoring your DevSpace deployments for free at vigilmon.online — your first monitor is running in two minutes, giving you immediate external visibility into every environment DevSpace manages.

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