Monitoring Radius Applications with Vigilmon

Radius is Microsoft's open-source cloud-native application platform that lets teams define applications using a consistent model and deploy them across Azure, AWS, Kubernetes, and on-prem environments. Radius tracks your app's components, connections, and environments in one place — but it doesn't monitor whether those components are actually serving traffic. That's where Vigilmon comes in. Add external uptime monitoring so you know the moment a Radius-managed service stops responding.

What You'll Set Up

• HTTP monitor for each Radius application endpoint
• Heartbeat monitor for scheduled Radius deployment jobs or rad deploy automation
• TCP monitor for backend components like databases and queues
• Alert channel to notify your team when a component goes down

Prerequisites

• Radius installed and a working rad CLI (rad install kubernetes or Azure deployment)
• At least one application defined with app.bicep or app.yaml and deployed
• A free Vigilmon account
• Shell access to query deployed Radius application URLs

Step 1: Find Your Radius Application Endpoints

After deploying a Radius application, retrieve the URLs exposed by its containers or services:

# List all applications in the current workspace
rad app list

# Show the status of all resources in an app
rad resource list containers --application my-app

# Get the URL of a specific container
rad resource show containers frontend --application my-app

For applications deployed to Kubernetes, Radius creates standard Kubernetes Services. Get the external address:

kubectl get svc -l radapp.io/application=my-app
# NAME       TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)       AGE
# frontend   LoadBalancer   10.96.42.100   203.0.113.50    80:31000/TCP  5m

Your Radius application containers should expose a health endpoint. Add one if not already present:

// Node.js example health endpoint
app.get('/health', (_req, res) => {
  res.json({ status: 'ok', component: 'frontend', timestamp: new Date().toISOString() });
});

Step 2: Add HTTP Monitors for Application Components

Each Radius component that serves traffic should have its own Vigilmon monitor.

1. Log in to vigilmon.online and click Add Monitor.
2. Select HTTP / HTTPS.
3. Enter the URL for your component: https://203.0.113.50/health or your mapped domain.
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Click Save.

Repeat for each externally reachable component — frontend, API gateway, any public-facing service. Vigilmon probes from multiple geographic regions so you catch regional routing failures that internal Kubernetes health probes never see.

For multi-environment Radius setups (staging, production), create a separate monitor per environment and group them in a Vigilmon status page:

| Environment | Component | URL | |---|---|---| | production | frontend | https://app.example.com/health | | production | api | https://api.example.com/health | | staging | frontend | https://staging.example.com/health |

Step 3: Add a Heartbeat for Automated rad deploy Jobs

If your team runs automated deployments via CI or a scheduled cron job, add a Vigilmon heartbeat to confirm deployments are completing on schedule.

1. In Vigilmon, click Add Monitor → Cron Heartbeat.
2. Set the expected interval to match your deployment cadence — for example, 60 minutes for hourly deploys or 1440 minutes (24 hours) for nightly.
3. Copy the heartbeat URL: https://vigilmon.online/heartbeat/abc123.

Add the ping to your deployment script:

#!/bin/bash
set -e

echo "Deploying Radius application..."
rad deploy app.bicep --environment production

echo "Deployment succeeded — pinging Vigilmon heartbeat"
curl -s "https://vigilmon.online/heartbeat/abc123"

In a GitHub Actions workflow:

- name: Deploy Radius application
  run: rad deploy app.bicep --environment production
  env:
    AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
    AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}

- name: Ping Vigilmon heartbeat
  if: success()
  run: curl -s https://vigilmon.online/heartbeat/abc123

If the deployment fails or the runner crashes before pinging, Vigilmon alerts after the expected interval. You'll know immediately that automated deployments have gone silent.

Step 4: Monitor Backend Components via TCP

Radius manages connections to databases, message queues, and caches as first-class components. Monitor their reachability at the TCP layer as a low-level canary.

For a PostgreSQL database linked via Radius:

# Find the connection host from the Radius resource
rad resource show postgresqldatabases mydb --application my-app

Then in Vigilmon:

1. Click Add Monitor → TCP.
2. Enter the database hostname and port: db.example.com : 5432.
3. Set Check interval to 1 minute.
4. Click Save.

Do the same for Redis (6379), RabbitMQ (5672), or any other component Radius provisions connections to. A TCP check catches host-level failures before your application surfaces connection errors to users.

Step 5: Set Up Alert Channels

1. Go to Alert Channels in Vigilmon.
2. Add your team's email, Slack webhook, or PagerDuty integration.
3. Assign the channels to all your Radius application monitors.

For critical production components, set Consecutive failures before alert to 1 — Radius applications typically have fast failover and a single failure in production warrants immediate attention.

Use the Vigilmon API to create maintenance windows around planned Radius environment upgrades:

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

Step 6: Create a Status Page for Radius Environments

Give stakeholders a single view across all your Radius-managed environments:

1. Go to Status Pages → New Status Page.
2. Name it "Application Platform Status".
3. Add all your component monitors grouped by environment.
4. Publish and share the URL.

This gives non-technical stakeholders visibility into production health without needing access to Azure, rad CLI, or Kubernetes dashboards.

Summary

| Monitor | Target | What It Catches | |---|---|---| | HTTP health | Frontend/API components | App crashes, ingress failures, misrouted traffic | | Cron heartbeat | Automated rad deploy job | Silent deployment failures | | TCP | Database/queue | Backend component unreachable | | HTTP health | Per-environment endpoints | Environment-specific outages |

Radius gives you a portable, consistent application model — Vigilmon gives you portable, consistent visibility into whether those applications are actually running.

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