skip to content
Scraplab

Monitoring van mijn VPS en Raspberry Pi

/ 4 min read

View more blogs with the tag dev , View more blogs with the tag infra , View more blogs with the tag monitoring
Table of Contents

Introductie

Nu mijn homelab en VPS steeds meer taken uitvoeren, begon er iets te knagen: hoe weet ik eigenlijk zeker dat alles nog werkt als ik niet kijk?
Vooral de verbinding tussen mijn VPS en mijn Raspberry Pi is cruciaal. Die loopt volledig via ZeroTier, en als die verbinding wegvalt, kan een groot deel van mijn setup niet meer functioneren.

Als je het niet meet, weet je niet dat het kapot is.

Ik wilde dus een simpele en betrouwbare manier om te controleren of mijn VPS mijn RPi nog kan bereiken. Zo niet, dan wil ik daar direct een seintje van krijgen. Geen dashboards, geen grafana, geen overkill. Gewoon: werkt het nog, ja of nee?

Eisen

Voordat ik begon heb ik voor mezelf een paar eisen opgesteld:

  • Er mag geen vals alarm zijn bij een korte hick-up
  • Bij structureel falen wil ik een e-mail
  • Zo min mogelijk afhankelijkheden

Kortom: een simpel scriptje, geen monitoring-suite.

ZeroTier als fundament

ZeroTier vormt de lijm tussen mijn VPS en mijn thuisnetwerk. Zowel de VPS als de Raspberry Pi zijn lid van hetzelfde virtuele netwerk en hebben daarbinnen een vast IP-adres.

Het grote voordeel hiervan is dat ik geen rekening hoef te houden met:

  • NAT
  • dynamische IP’s
  • port forwarding

Voor mijn monitoring betekent dit dat ik de RPi gewoon kan benaderen alsof hij lokaal in hetzelfde netwerk hangt.

De aanpak

De kern van de oplossing is verrassend simpel:

  1. Ping de RPI vanaf de VPS
  2. Lukt dit niet? → sla de status op
  3. Lukt het twee keer achter elkaar niet? → stuur een e-mail
  4. Herstelt de verbinding? → reset de status

Door pas bij twee opeenvolgende failures te alarmeren voorkom ik meldingen bij:

  • korte netwerkfluctuaties
  • herstartende services
  • tijdelijke packet loss

Door de state bij te houden voorkom ik dat ik mijn eigen inbox opblaas met meldingen, iets wat wel zo fijn is.

Het scriptje

Ik heb gekozen voor een klein Python-script. Geen externe libraries, alleen standaard tooling. De VPS kan al mail versturen via sendmail, dus daar maak ik dankbaar gebruik van.

De state wordt opgeslagen in /tmp, wat voldoende is voor dit doeleinde. Hij probeert twee keer te pingen naar mijn RPi, lukt dat niet; dan wordt er een mailtje gestuurd.

#!/usr/bin/env python3


import subprocess
import time
import sys
from email.message import EmailMessage
import smtplib


RPI_IP = "10.0.0.1"
PING_COUNT = 2
PING_TIMEOUT = 3
STATE_FILE = "/tmp/rpi_monitor_state"
ALERT_EMAIL = "brian@mail.nl"
FROM_EMAIL = "monitor@vps.local"


def ping_host():
    try:
        result = subprocess.run(
            ["ping", "-c", str(PING_COUNT), "-W", str(PING_TIMEOUT), RPI_IP],
            stdout=subprocess.DEVNULL,
            stderr=subprocess.DEVNULL,
        )
        return result.returncode == 0
    except Exception:
        return False


def send_alert():
    msg = EmailMessage()
    msg["Subject"] = "ALERT: VPS cannot reach RPI over ZeroTier"
    msg["From"] = FROM_EMAIL
    msg["To"] = ALERT_EMAIL
    msg.set_content(
        f"""The VPS failed to reach the RPI at {RPI_IP}
twice in a row.


Timestamp: {time.ctime()}
"""
    )


    with smtplib.SMTP("localhost") as smtp:
        smtp.send_message(msg)


def read_previous_failure():
    try:
        with open(STATE_FILE, "r") as f:
            return f.read().strip() == "fail"
    except FileNotFoundError:
        return False


def write_state(state):
    with open(STATE_FILE, "w") as f:
        f.write(state)


if __name__ == "__main__":
    reachable = ping_host()
    previous_failed = read_previous_failure()


    if reachable:
        write_state("ok")
        sys.exit(0)


    if previous_failed:
        send_alert()
        write_state("alerted")
    else:
        write_state("fail")

Simpel, maar effectief. De code is gegenereerd met een prompt in ChatGPT. In eerste instantie ging ChatGPT een eigen ICMP ping methode bouwen in Python, maar door te leunen op het shell commando sh kunnen we die logica overlaten aan het OS.

Automatiseren met cron

Het script draait elke 5 minuten via cron:

*/5 * * * * /usr/local/bin/rpi_monitor.py

Meer is het niet. Geen containers, geen extra services, geen overhead. Waarom geen uitgebreidere monitoring?

Natuurlijk had ik dit ook kunnen oplossen met Grafana + Prometheus, maar eerlijk is eerlijk: dat had het probleem niet beter opgelost. Voor één kritische verbinding is eenvoud hier juist een voordeel. Minder bewegende delen betekent minder dat er kapot kan.

Conclusie

Met een paar regels Python en een cronjob heb ik nu:

  • Vertrouwen dat mijn VPS verbinding heeft met mijn RPi.
  • Een directe melding als dat niet zo is
  • Geen extra infrastructuur om te onderhouden

Dit soort kleine scripts zijn wat mij betreft de ruggengraat van een stabiele homelab-setup. Niet alles hoeft groots of complex te zijn, zolang het maar doet wat het moet doen.

— Brian