Monitoring Sunshine Game Streaming with Vigilmon

Sunshine is the open-source replacement for NVIDIA GeForce Experience's GameStream — it implements the NVIDIA GameStream protocol so you can stream your PC's desktop, games, or any application to any Moonlight client on Android, iOS, Apple TV, or another PC. Unlike the official NVIDIA solution, Sunshine works with any GPU and runs as a self-hosted service you control. But that self-hosting means you're also responsible for knowing when Sunshine crashes, when streaming ports are unreachable from outside your network, or when a GPU encoder configuration breaks. Vigilmon gives you uptime monitoring for the Sunshine web UI, REST API, streaming port availability, and a heartbeat check on the GPU encoder configuration.

What You'll Set Up

• TCP probe for Sunshine web UI availability (port 47990)
• API health check via the /api/apps endpoint
• TCP probe for the Moonlight streaming port (port 47984)
• SSL certificate alert for custom-domain Sunshine deployments
• Heartbeat monitor for GPU encoder configuration health

Prerequisites

• Sunshine installed and running on your host PC
• Moonlight client connected and verified working
• A free Vigilmon account

Step 1: Monitor Sunshine Web UI Availability

Sunshine's configuration web UI runs on port 47990 with a self-signed HTTPS certificate. Because the certificate is self-signed, standard HTTPS monitoring will fail certificate validation. Use a TCP probe instead — it confirms the Crow HTTP server is listening without caring about the certificate:

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to TCP Port.
3. Enter your host IP or hostname and port 47990.
4. Set Check interval to 1 minute.
5. Click Save.

If you've set up a reverse proxy (nginx/Caddy) with a valid certificate in front of Sunshine, you can use HTTP / HTTPS monitoring instead:

1. Click Add Monitor → HTTP / HTTPS.
2. Enter: https://sunshine.yourdomain.com
3. Set Expected HTTP status to 200.
4. Click Save.

A failed TCP probe on port 47990 means the Sunshine process has crashed and the web UI is completely unreachable.

Step 2: Monitor the Sunshine REST API

Sunshine exposes a REST API for managing apps and sessions. The /api/apps endpoint returns the configured application list — a healthy response confirms the API is operational and the app configuration database is accessible.

Sunshine's API requires HTTP Basic Authentication. Set up the monitor with credentials:

1. Click Add Monitor → HTTP / HTTPS.
2. Enter: https://your-sunshine-host:47990/api/apps
3. Set Check interval to 2 minutes.
4. Set Expected HTTP status to 200.
5. Under Authentication, select Basic Auth and enter your Sunshine username and password.
6. Set SSL verification to disabled (self-signed certificate).
7. Click Save.

Test it from the command line:

curl -sk -u admin:yourpassword https://localhost:47990/api/apps
# Returns JSON array of configured applications

An authentication failure (401) means the credentials changed or Sunshine reset its configuration. A 500 or timeout means the API layer has an internal error.

Step 3: Monitor Moonlight Streaming Port Availability

Moonlight clients connect to Sunshine using ports 47984–47990. Port 47984 is the primary pairing and streaming control port used during session negotiation. A TCP probe to this port from outside your network confirms that:

• The Sunshine service is running
• Your firewall or router port forwarding is correctly configured
• Moonlight clients outside your LAN can reach the host

1. Click Add Monitor → TCP Port.
2. Enter your external IP or dynamic DNS hostname and port 47984.
3. Set Check interval to 2 minutes.
4. Click Save.

If you use a dynamic DNS hostname (e.g. myhome.duckdns.org), Vigilmon's checks from external probe servers will catch both Sunshine crashes and port forwarding failures that would affect remote Moonlight clients.

Step 4: Monitor the Pairing PIN Page

Sunshine's pairing PIN entry page at /pin/ is publicly accessible (no authentication required) and confirms the Sunshine HTTP server is serving dynamic content rather than just static files:

1. Click Add Monitor → HTTP / HTTPS.
2. Enter: https://your-sunshine-host:47990/pin/
3. Set Expected HTTP status to 200.
4. Set SSL verification to disabled.
5. Under Keyword match, enter pin to confirm the pairing page content is present.
6. Click Save.

Step 5: SSL Certificate Alert for Custom-Domain Deployments

If you've placed Sunshine behind a reverse proxy with a real SSL certificate (Let's Encrypt or similar), monitor the certificate to catch renewal failures:

1. Open the HTTPS monitor for your Sunshine reverse proxy (created in Step 1 if using a proxy).
2. Enable Monitor SSL certificate.
3. Set Alert when certificate expires in less than 21 days.
4. Click Save.

For the default self-signed certificate, skip this step — self-signed certs have long expiry windows and users are already accepting the browser warning.

Step 6: Heartbeat Monitor for GPU Encoder Health

Sunshine can use NVENC (NVIDIA), AMD AMF, Intel QSV, or software x264/HEVC encoding. If the GPU becomes unavailable — due to a driver update, GPU reset, or display driver crash — Sunshine may continue running but fall back to software encoding or refuse to stream. A heartbeat that checks the encoder configuration catches this silently degraded state.

1. In Vigilmon, click Add Monitor → Cron Heartbeat.
2. Set the expected ping interval to 10 minutes.
3. Copy the heartbeat URL (e.g. https://vigilmon.online/heartbeat/abc123).
4. On the Sunshine host, create a script at C:\sunshine-health-check.ps1 (Windows) or /usr/local/bin/sunshine-health-check.sh (Linux):

Windows (PowerShell):

# Check Sunshine encoder configuration
$response = Invoke-RestMethod -Uri "https://localhost:47990/api/config" `
  -Credential (New-Object PSCredential("admin", (ConvertTo-SecureString "yourpassword" -AsPlainText -Force))) `
  -SkipCertificateCheck

if ($response.encoder -ne $null) {
  Invoke-WebRequest -Uri "https://vigilmon.online/heartbeat/abc123" -UseBasicParsing | Out-Null
}

Linux (Bash):

#!/bin/bash
response=$(curl -sk -u admin:yourpassword https://localhost:47990/api/config)
encoder=$(echo "$response" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('encoder',''))" 2>/dev/null)

if [ -n "$encoder" ]; then
  curl -s https://vigilmon.online/heartbeat/abc123 > /dev/null
fi

5. Schedule the script every 10 minutes:

Windows Task Scheduler:

$action = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-File C:\sunshine-health-check.ps1"
$trigger = New-ScheduledTaskTrigger -RepetitionInterval (New-TimeSpan -Minutes 10) -Once -At (Get-Date)
Register-ScheduledTask -TaskName "SunshineHealthCheck" -Action $action -Trigger $trigger -RunLevel Highest

Linux cron:

chmod +x /usr/local/bin/sunshine-health-check.sh
echo "*/10 * * * * /usr/local/bin/sunshine-health-check.sh" | crontab -

The /api/config response includes the encoder field showing nvenc, amd, intel, or software. If the script cannot reach the API or the encoder field is missing, the heartbeat is not sent and Vigilmon alerts after 10 minutes of silence.

Step 7: Configure Alert Channels

1. Go to Alert Channels in Vigilmon and add Slack, email, or a webhook.
2. Set Consecutive failures before alert to 2 on the TCP port monitor — brief Sunshine restarts (e.g. after a Sunshine update) resolve within seconds.
3. Set consecutive failures to 1 on the heartbeat monitor — a missing GPU encoder ping indicates a deeper hardware or driver problem that needs immediate investigation.

Summary

| Monitor | Target | What It Catches | |---|---|---| | TCP probe | Port 47990 | Sunshine process crashed | | API check | /api/apps | REST API failure, config DB error | | Streaming port | Port 47984 TCP | Port forwarding broken, remote access lost | | PIN page | /pin/ | HTTP server degraded | | SSL certificate | Reverse proxy domain | Certificate expiry | | Cron heartbeat | /api/config | GPU encoder down, driver crash |

Sunshine gives you the freedom to stream your GPU from any device without paying for cloud gaming subscriptions — but that freedom means owning the reliability too. With Vigilmon watching every layer of the Sunshine stack, you know immediately when the service crashes, streaming ports become unreachable, or the GPU encoder stops responding, so you can fix it before your next gaming session.