When you have as much random crap as I do running on your home network, it is nice to have something in place that will let you know when things aren’t working properly. There are a few free uptime monitoring solutions out there, but Uptime Kuma may be the easiest to set up and use.
The Basics
Uptime Kuma is a simple tool that can let you know if your self-hosted services are online. Of course, this won’t work so well if Uptime Kuma itself goes down, so it makes sense to host this off-site. In my case, I bought a cheap VPS from my domain registrar and threw it on there. It can connect to basically any service with a little bit of configuration, and it can also send notifications many different ways.
Connecting Online Services
A service that serves a web page (that is accessible from the internet) should work without any extra setup at all. Just point Uptime Kuma to the URL and tell it what status codes it should be expecting.
I would suggest allowing a few retries for any service that doesn’t really stay 100% operational all the time, or else you may get quite a few false alarm notifications.
Connecting Local Services
If you want to remotely monitor the uptime of services that you also do not want to expose to the internet, you need to get a little bit more creative. You could VPN in with your VPS, but I decided to do something a little bit different. I set up a Flask webserver (running via Gunicorn) on a Raspberry Pi that handles this for me.
The Python script is actually very basic, but it may grow more complicated depending on the type of services you intend to connect to.
from flask import Flask,jsonify,request
import requests
from icmplib import ping
app = Flask(__name__)
@app.route('/local_service', methods = ['GET'])
def ReturnLocalService():
response = requests.get('http://192.168.1.9:port/')
data = {
"local_service" : response.status_code,
}
return(jsonify(data))
@app.route('/local_ping', methods = ['GET'])
def ReturnLocalPing():
result = ping('192.168.1.10', count=1)
status = result.packets_sent == result.packets_received
data = {
"local_ping" : str(status),
}
return(jsonify(data))
if __name__=='__main__':
app.run(debug=True)
This script has two types of API routes. One is just a simple proxy, that will return the exact status code of the local website. The other type will ping the server via SNMP and return ‘True’ if the server is accessible. The local ping option in Uptime Kuma will look a little bit different.
Instead of just choosing an HTTP monitor, we use a Json Query to specify what we are expecting to receive. In this case, we are looking for ‘local_ping’ and it should return ‘True’.
Power Outages
The Raspberry Pi running the proxy script, my router, and my Fios ONT are all powered by a UPS, so even if the power goes out the Pi should stay online. Unfortunately, the server rack in the garage will go down (no UPS yet), but we can solve that problem when we feel like spending hundreds of dollars on a rack mounted UPS.
Notifications
There are many different ways to get Uptime Kuma to send notifications, but the easiest is probably to use Signal. You can spin up signal-rest-api on your VPS to be able to send Signal messages to yourself or others. I already use Signal to message family members, so this worked out great for me.
One issue you may run into is the signal-rest-api container changing IPs randomly. I have no idea what is up with this, and I haven’t implemented a solution yet. So sometimes I don’t get notifications when things go down. Which kind of defeats the whole purpose of this. All I do to combat this is manually test the notifications every few weeks or so.
Status Pages
You can put all of the monitors into groups and add them to status pages. This works great when you have self-hosted services that friends or family rely on. This way instead of getting texts from people whining about things not working, you can just tell them to check the status page.
Leave a Reply