Quartz 5

Docker, Dozzle, Dashy & Iperf

4 min read

Raspberry Pi Lab: Docker, Uptime Kuma, Dozzle and Dashy

Scenario

The next stage of the Raspberry Pi experiment was to take advantage of the docker service running on the pi and add to the Uptime Kuma network monitor with other containers enlarging the Pi’s place as a small homelab management node. Docker makes this practical because lightweight services can run independently without requiring full virtual machines. The goal of this experimentation was to expand observability of network activity and containers running on the pi.

The current direction is:

Raspberry Pi
│
├── SSH
│
├── Docker
│   ├── Uptime Kuma
│   ├── Dozzle
│   └── Dashy
│
└── Network / system tools
    ├── iperf3
    ├── btop
    ├── ss
    └── vcgencmd

Each service has a different role.

Uptime Kuma

Uptime Kuma acts as the monitoring layer. Its purpose is to answer questions such as:

  • Is the Raspberry Pi reachable?
  • Is a web service responding?
  • Is another server on the LAN available?
  • Has a Docker-hosted service stopped responding?

Rather than manually checking each service, Uptime Kuma provides a central monitoring interface. This makes it particularly useful as the homelab grows.

Installing Additional Docker Services

The next two services added were:

  • Dozzle
  • Dashy

These complement Uptime Kuma rather than replacing it. The basic idea is:

Uptime Kuma → Is the service alive?
 
Dozzle → What is the container saying?
 
Dashy → Where do I access everything?

Dozzle

Dozzle provides a browser-based interface for viewing Docker container logs.

Normally logs are inspected from the command line using commands such as:

docker logs -f container-name

The -f option follows the log output in real time.

Dozzle provides a lightweight graphical alternative. Instead of repeatedly connecting by SSH and checking individual containers, logs can be viewed from a browser. This is useful when troubleshooting problems such as:

  • containers repeatedly restarting
  • application errors
  • failed connections
  • configuration errors
  • service startup messages

Dozzle therefore acts as a simple observability tool for the Docker environment.

Dashy

Dashy serves a different purpose. Dashy is a homelab dashboard that provides links to services from a single interface. Instead of remembering ports and IP addresses such as:

192.168.1.105:3001
192.168.1.105:3002
192.168.1.111:9090

the dashboard can provide named tiles such as:

Uptime Kuma
Dozzle
Fedora Cockpit
Open WebUI
Router
Raspberry Pi

The dashboard becomes the front page for the homelab.

Dashy Configuration

Dashy is a little tricky, it uses YAML configuration. One of the key lessons from setting it up was how sensitive YAML is to indentation. For example:

pageInfo:
  title: Fastigiata Homelab
 
sections:
  - name: Raspberry Pi
    items:
      - title: Uptime Kuma
        url: http://192.168.1.105:3001
      - title: Dozzle
        url: http://192.168.1.105:8080

Spacing matters. incorrect indentation can cause the configuration to fail even when the values themselves are correct. This was a useful practical lesson because YAML is widely used in infrastructure configuration like Cloudflare Pages , GitHub Actions, Docker Compose and Kubernetes. As with the linux cli spacing matters

Network Testing with iperf3

I also tested network throughput between the MintBookPro and Raspberry Pi.

The Pi ran the iperf3 server:

iperf3 -s

The client was then run from the MintBookPro:

iperf3 -c 192.168.1.105

Initial connection failed because the server was not yet running:

Connection refused

Once the server was running, the test succeeded. Result:

Sender:   2.41 Mbits/sec
Receiver: 2.30 Mbits/sec
Retransmits: 0

The absence of retransmissions was positive, although the throughput was quite low. This creates a useful future experiment:

Raspberry Pi Wi-Fi
        VS
Raspberry Pi Ethernet

Using iperf3 would make it possible to directly quantify the difference.

Emerging Homelab Architecture

The Pi is gradually becoming a lightweight management node rather than just another Linux machine.

A possible architecture is:

                 FASTIGIATA HOMELAB
 
                      Dashy
                        │
        ┌───────────────┼────────────────┐
        │               │                │
   Uptime Kuma        Dozzle        Other Services
        │               │
        │               └── Docker logs
        │
        ├── Raspberry Pi
        ├── Fedora Server
        ├── MintBookPro
        ├── MX Linux
        └── Web Services

Dashy provides navigation. Uptime Kuma provides health monitoring. Dozzle provides container visibility. Docker provides the underlying service platform.

Learning

This experiment combined several skills:

  • Docker container management
  • browser-based observability
  • YAML configuration
  • network benchmarking
  • service monitoring
  • Linux administration
  • homelab architecture

The most important shift is conceptual. The Raspberry Pi is no longer simply a machine I SSH into. It is starting to function as a small homelab control and observability node. That makes it a useful place to experiment with monitoring, networking, containers, and infrastructure without the overhead of running full virtual machines.

Graph View

Backlinks