Skip to content

How I Monitor My Homelab

One of the things I have learned from running a homelab is that no single monitoring application really tells me everything I want to know.

I run three Docker servers — minipc, micropc and micro2pc — and use several different applications to keep an eye on them.

Rather than trying to make one application do everything, I use different tools for different jobs.

My main monitoring and notification setup consists of:

  • Netdata — server performance and health
  • Dozzle — Docker container logs
  • NetAlertX — devices appearing on my network
  • ntfy — notifications when something needs my attention

Together, they give me a fairly complete picture of what is happening in my homelab.

My Three Servers

My Docker services are spread across three Ubuntu servers:

Server Role
minipc Main homelab server
micropc Dell OptiPlex Micro
micro2pc Another Ubuntu server

I don't try to make every server identical.

Different applications run on different machines depending on what I need them to do, and the monitoring tools allow me to see the overall state of the homelab without having to log into every server individually.

Netdata — Server Performance

I use Netdata to monitor the underlying servers themselves.

I run a Netdata node on:

  • minipc
  • micropc
  • micro2pc

The three nodes can be viewed from the same Netdata interface.

This gives me a quick way of answering questions such as:

  • Is a server running normally?
  • How much CPU is being used?
  • How much memory is available?
  • Is disk activity unusually high?
  • Is network traffic behaving normally?
  • Is a server under unusual load?

Netdata is therefore my first choice when I want to know:

Is the server itself healthy?

For more information about my Netdata setup, see the Netdata Guide.

Dozzle — Docker Logs

Netdata tells me about the server, but it doesn't give me the best view of what individual Docker containers are doing.

For that I use Dozzle.

Dozzle provides a web interface for viewing Docker container logs.

I run a main Dozzle instance and Dozzle agents on my other servers. This means I can view containers running on the different machines from a single interface.

This is particularly useful when:

  • a container stops working
  • an application behaves unexpectedly
  • a Docker container repeatedly restarts
  • I need to see what happened immediately before a failure
  • I am troubleshooting a new deployment

Dozzle answers a different question:

What are my Docker containers actually saying?

For more information about my setup, see the Dozzle Guide.

NetAlertX — Network Devices

NetAlertX monitors something different again.

Instead of concentrating on the servers and Docker containers, it watches the network for devices.

This allows me to see devices appearing on or disappearing from my network and gives me another useful source of information about what is happening around the homelab.

For example, I can use it to investigate:

  • Which devices are currently visible?
  • Has a device appeared on the network?
  • Has a known device disappeared?
  • What devices have been detected recently?

This is particularly useful because my network contains considerably more than just my three Docker servers.

NetAlertX answers the question:

What is happening on my network?

For more information about my setup, see the NetAlertX Guide.

ntfy — Getting Notified

The final part of my monitoring setup is ntfy.

There is not much point in having monitoring systems if I have to remember to open each one several times a day to check whether something has happened.

I use ntfy to receive notifications from various parts of my homelab.

For example, I receive notifications for:

  • Docker image updates
  • Mind notifications
  • Change Detection notifications
  • other scripts and services that need to tell me something

This changes the way I use monitoring.

Instead of constantly checking everything, I can carry on with other things and let the homelab tell me when something deserves my attention.

ntfy therefore answers a slightly different question:

Does something need my attention?

For more information about how I use ntfy, see How I Use ntfy in My Homelab.

For the installation itself, see the ntfy Guide.

How the Pieces Fit Together

The important thing for me is that these applications are not really competing with each other.

They each provide a different view of the homelab.

flowchart TD
    A[My Homelab] --> B[Servers]
    A --> C[Docker]
    A --> D[Network]

    B --> E[Netdata]
    C --> F[Dozzle]
    D --> G[NetAlertX]

    E --> H[ntfy]
    F --> H
    G --> H

    H --> I[Me]

This gives me four different levels of visibility.

Netdata

How healthy are my servers?

Dozzle

What are my containers doing?

NetAlertX

What is happening on my network?

ntfy

Does anything need my attention?

Monitoring Without Constantly Watching

One of the things I like about this arrangement is that it doesn't require me to sit looking at dashboards all day.

The dashboards are there when I need them.

If I am investigating a problem, I can open Netdata or Dozzle and look at what is happening.

If I want to investigate something on the network, I can look at NetAlertX.

But for things that genuinely require my attention, I prefer to receive a notification.

This makes the monitoring system much less intrusive.

When Something Goes Wrong

If something appears to be wrong, I generally work through the different layers.

For example, suppose a web application is not responding.

I might start by asking:

  1. Is the server healthy?

Check Netdata.

  1. Is the Docker container running?

Check Docker or Dozzle.

  1. What does the container log say?

Check Dozzle.

  1. Is there a network problem?

Check NetAlertX and the network itself.

  1. Did another service already report a problem?

Check my ntfy notifications.

This gives me a reasonably systematic way of troubleshooting rather than simply restarting things and hoping for the best.

Why I Use Several Monitoring Tools

It might seem unnecessarily complicated to run four different monitoring applications.

For me, it isn't.

Each application has a fairly clear purpose:

Tool What I use it for
Netdata Server performance and health
Dozzle Docker container logs
NetAlertX Network device visibility
ntfy Notifications and alerts

Trying to make one application perform all four jobs would probably make the monitoring system more complicated, not less.

I would rather have several simple tools that each do one job well.

My Monitoring Philosophy

My approach to homelab monitoring is fairly simple:

Monitor the things that matter, and notify me when I need to know.

I don't need every possible metric.

I don't need a complicated enterprise monitoring platform.

What I want is to be able to answer four questions quickly:

  • Are my servers healthy?
  • Are my containers healthy?
  • What is happening on my network?
  • Does anything need my attention?

At the moment, Netdata, Dozzle, NetAlertX and ntfy give me a good answer to all four.