Skip to content
ProHomeLab
RU

Monitoring & Logs

Dozzle - A Convenient Real-Time Log Viewer for Docker Containers

Stilicho2011Updated 21 min read55 views

Also available in: RU

Dozzle - A Convenient Real-Time Log Viewer for Docker Containers
Part 17 of 24 in the series Self-Hosting
  1. Pros and Cons of Fedora Server 42
  2. Linkwarden Overview - A Modern Self-Hosted Bookmark Manager
  3. PostgreSQL and pgAdmin in Docker - Beginner Setup Guide
  4. Mealie Recipe Manager - Self-Hosted Meal Planning on Docker
  5. Vaultwarden in Docker - Your Own Password Vault, Not Bitwarden's
  6. Diun - Get Notified When Your Docker Images Have Updates
  7. How to Upgrade Linux Server Distributions
  8. How to Start a Homelab - Hardware, Hypervisor, and Your First Service
  9. The Best Self-Hosted Apps of 2025 - A Personal Roundup
  10. Best Bookmark Manager - Linkwarden or Karakeep
  11. BookLore - A Self-Hosted Library and Reader for Your Book Collection
  12. Grimmory - A Self-Hosted Library and Reader for Your Book Collection
  13. Pangolin Tunnel Setup - Expose Homelab Services Without Ports
  14. NetBird Self-Hosted - Mesh VPN Without Port Forwarding
  15. Postiz - Trying to Automate YouTube, VK, and RuTube, and Why Only One Out of Three Actually Works
  16. Connecting Applications to a Shared PostgreSQL and Learning Basic Maintenance - Part 2
  17. Dozzle - A Convenient Real-Time Log Viewer for Docker Containers
  18. Docker Hit Its Network Limit - How I Diagnosed and Fixed It with default-address-pools
  19. Gotify - Your Own Push Notification Server for the Hypervisor and Beyond
  20. Forgejo + Komodo - Turning Docker Compose into GitOps
  21. GitOps for Homelab - Deploying Forgejo and Komodo From Scratch
  22. GitLab, Gitea, and Forgejo. A Comparison for Grown-Ups - What Actually Fits Your Homelab
  23. Auto-Updating Docker Containers - Renovate + Forgejo + Komodo
  24. Matrix Synapse - Setting Up Your Own Server for Decentralized Chat
Contents
Tip

If you enjoyed this article, you can become a sponsor on Boosty.

Updated October 9, 2026

Brought up to date for Dozzle 11.3: the setup wizard, GitHub and OIDC sign-in, container updates and auto-updates with automatic rollback, custom certificates for agents, host metrics and per-container disk usage.

What is Dozzle

Dozzle is a lightweight open-source web app for viewing Docker container logs in real time, with no database, no complex configuration, and no log storage anywhere other than Docker itself.

Project site: dozzle.dev
Source code: github.com/amir20/dozzle

Essentially, Dozzle is a convenient web wrapper around docker logs -f - except for all the containers on the host at once, with search, highlighting, and a nice interface that's easy to navigate, instead of a bare terminal.

Key features:

  • Real-time viewing of logs for all containers through a browser
  • Search and filtering by text and regular expressions
  • Highlighting of log levels and pretty-printing for JSON logs
  • Container stats - CPU, memory, network, and since 11.3 how much disk each container takes up
  • Host metrics - uptime, load, disk usage
  • Start/stop/restart and update containers directly from the interface (optional)
  • New image detection and scheduled container auto-updates that roll back on failure
  • Alerts on logs, metrics, and Docker events
  • Download logs as a file
  • Multi-host mode - a single Dozzle instance can show logs from several servers at once

Over the summer and autumn of 2026, Dozzle went from 10.7 to 11.3 and grew from a "just let me take a quick peek at the logs" tool into a genuinely solid everyday workhorse. It now has a setup wizard, proper OIDC sign-in, and can even stand in for Watchtower. All of that is still optional - if logs are all you want, Dozzle is the same small container you're used to.


Why you'd want Dozzle

If your server runs more than a couple of containers, sooner or later you'll need to quickly check what's going on - with Nextcloud, with Authentik, with a service that just crashed, and so on. There aren't many options:

  • SSH in and run docker logs -f <container> for one container at a time;
  • set up a full monitoring stack (Loki + Grafana, ELK) - slow, heavy, and possibly overkill for a home server, given how much there is to configure;
  • install Dozzle - one small container that immediately gives you a web UI with all the logs on the host.

Dozzle isn't a replacement for proper long-term logging (a Loki/Mimir/Grafana stack is undoubtedly a better fit for that - I've got an article on setting one up in the works, and I'll add a link here once it's published) - it's a fast, lightweight tool for "see what's happening right now," and for a home server that's usually more than enough.

By the way, if you've already read the Diun article - these two make a great pair. Diun tells you when a new image version is out, and Dozzle lets you immediately check the container's logs after updating it, to confirm everything came back up cleanly. That said, as of version 11 Dozzle can find and install updates by itself - more on that in Updating containers from Dozzle below - so these days Diun is more of a nod to the past. Still a great app, though.


Installing via Docker Compose

The base docker-compose.yml:

yaml
services:
dozzle:
image: amir20/dozzle:latest
container_name: dozzle
volumes:
- /var/run/docker.sock:/var/run/docker.sock
- ./data:/data # users, settings, alerts, sessions
environment:
- TZ=Europe/Moscow
- DOZZLE_NO_ANALYTICS=true # disable anonymous telemetry
- DOZZLE_TAILSIZE=300 # how many recent lines to load on open
restart: unless-stopped
security_opt:
- no-new-privileges:true
networks:
proxy:
labels:
- "traefik.enable=true"
- "traefik.http.routers.dozzle.entrypoints=web"
- "traefik.http.routers.dozzle.rule=Host(`dozzle.stilicho.ru`)"
- "traefik.http.middlewares.dozzle-https-redirect.redirectscheme.scheme=https"
- "traefik.http.routers.dozzle.middlewares=dozzle-https-redirect"
- "traefik.http.routers.dozzle-secure.entrypoints=websecure"
- "traefik.http.routers.dozzle-secure.rule=Host(`dozzle.stilicho.ru`)"
- "traefik.http.routers.dozzle-secure.tls=true"
- "traefik.http.routers.dozzle-secure.tls.certresolver=cloudflare"
- "traefik.http.routers.dozzle-secure.service=dozzle"
- "traefik.http.services.dozzle.loadbalancer.server.port=8080"
- "traefik.docker.network=proxy"
networks:
proxy:
external: true

Start the service:

Terminal window
docker compose up -d

Then open https://dozzle.stilicho.ru in your browser. Dozzle discovers every container on the host through the Docker socket and shows their logs right away, and on a fresh install the first thing you'll see is the setup wizard (covered in the next section).

For the details of wiring a service into Traefik with labels, see Traefik in Docker.

Why the /data folder. The video didn't have one, but with Dozzle 11 it's effectively mandatory. /data holds user data (users.yml), the wizard's settings (dozzle.yml), alerts and notification destinations, and the secret used to sign sessions. If the /data folder doesn't survive restarts, that secret is regenerated every time - so every container restart logs everyone out, and your settings and alerts vanish along with it.

Warning

The Docker socket (/var/run/docker.sock) grants full control over Docker on the host - effectively root on the host. The video mounted it with :ro, but as the Dozzle docs point out, :ro does not restrict the Docker API: it only makes the socket file itself read-only on disk, while API calls go through it just as before - creating, removing, and recreating containers all still work. The flag doesn't hurt, but it won't fully protect you either. The only real way to restrict access is a socket-proxy such as tecnativa/docker-socket-proxy - more on that in the "Security" section below.


First run - the setup wizard

Since 11.1, the first time Dozzle starts (while /data is still empty) it opens a setup wizard that walks you through:

  1. Login. Your options: a Dozzle account (creates users.yml, simple provider), "My proxy" (forward-proxy - Authentik/Authelia handles auth in front of Dozzle), OIDC (the wizard tells you which variables to set), or carry on without a login.
  2. Actions and shell - whether to allow container control and a terminal inside containers. Shell is off by default, and unless you really need it, you're probably better off leaving it that way.
  3. Hosts - connecting agents on other servers.
  4. Dozzle Cloud - optionally linking to the cloud service run by Dozzle's author (more below).
  5. Auto-update - off/daily/weekly, the time, and which containers to update. This step only works with actions enabled.
  6. Restart - Dozzle restarts its own container to apply everything.

Your choices are saved to /data/dozzle.yml:

yaml
authProvider: simple
enableActions: true
enableShell: false
autoUpdate: weekly
autoUpdateTime: "03:00"
updateContainers: labelled

Environment variables (DOZZLE_AUTH_PROVIDER, DOZZLE_ENABLE_ACTIONS, DOZZLE_ENABLE_SHELL, DOZZLE_AUTO_UPDATE and so on) take precedence over the file - so if you'd rather keep all your config in compose, you can switch the wizard off with DOZZLE_DISABLE_SETUP_WIZARD=true. You can still launch it later from Settings → About.

Warning

If you pick "no login" in the wizard, settings can only be changed from the UI during the first 15 minutes after a new install first starts. That's a safeguard, but also a good reason not to leave a fresh Dozzle sitting open on your network unattended. Go through every step of the wizard right after docker compose up -d.


Traefik compatibility - compression breaks live logs (SSE)

Dozzle streams logs in real time using Server-Sent Events (SSE) - a one-way HTTP stream of data from the server to the browser. Traefik handles WebSocket upgrades automatically, with no extra configuration needed, but SSE has a catch: if you have the compress middleware enabled (often added globally to compress responses for every service), it can break this particular stream - logs in the interface simply stop updating in real time, even though Dozzle itself keeps running without errors.

To fix this, exclude text/event-stream from compression:

yaml
http:
middlewares:
middlewares-compress:
compress:
excludedContentTypes:
- text/event-stream

Then apply this middleware to the Dozzle router (or, if compress is already shared across all your services, just add the exclusion to your existing configuration).

A typical labels block for the Dozzle service, accounting for this, looks something like this:

yaml
services:
dozzle:
image: amir20/dozzle:latest
labels:
- traefik.enable=true
- traefik.http.routers.dozzle.rule=Host(`dozzle.stilicho.ru`)
- traefik.http.routers.dozzle.entrypoints=websecure
- traefik.http.routers.dozzle.tls.certresolver=letsencrypt
- traefik.http.services.dozzle.loadbalancer.server.port=8080
Note

If you don't use the compress middleware globally, you don't need to change anything - this issue only shows up when it's in use. But if, after setting up Dozzle, the logs stop updating in real time and you have to refresh the page manually, this is the first thing to check.


Setting up authentication

With no authentication configured, Dozzle doesn't ask for a login - which is only fine if the service is reachable exclusively from inside your network, or already sits behind a reverse proxy with its own auth. Dozzle now gives you four options:

Method Who owns the users When it fits
simple Dozzle, in users.yml You don't have an auth system of your own
simple + GitHub/OIDC sign-in Dozzle, in users.yml Same users, but they sign in with GitHub, Authentik, Keycloak, etc. instead of a password
oidc Your identity provider Users and their permissions live in Authentik/Keycloak/Pocket ID, no users.yml needed
forward-proxy Your proxy Authentik/Authelia/Cloudflare Access handles auth entirely in front of Dozzle

Simple authentication

The easiest way is to create a user right in the setup wizard. If you prefer doing it by hand, the Dozzle image can generate one:

Terminal window
mkdir -p ./data
docker run --rm -it amir20/dozzle generate admin --name "Admin" --email admin@stilicho.ru > ./data/users.yml

The command prompts for the password interactively, so it never ends up in your shell history. The resulting users.yml with the password hash lands in ./data, which the compose file above already mounts as the container's /data. All that's left is to enable the provider:

yaml
environment:
- DOZZLE_AUTH_PROVIDER=simple

generate also takes --user-roles and --user-filter. For example, you can give someone access to the logs of specific containers only, with no right to control them.

GitHub or OIDC sign-in (as part of the simple method)

Since version 11, users from users.yml can sign in with GitHub or any OIDC provider - Authentik, Keycloak, Pocket ID, Zitadel - instead of a password. The key point: users.yml remains the allowlist. An external account that isn't linked to a user in the file can't get in, and no accounts are ever created automatically. Password login keeps working alongside it - handy if the OAuth app ever breaks.

For GitHub, you create an OAuth App with the callback URL https://dozzle.stilicho.ru/api/auth/callback and add DOZZLE_AUTH_GITHUB_CLIENT_ID and DOZZLE_AUTH_GITHUB_CLIENT_SECRET to your compose file.

OpenID Connect (oidc)

The oidc provider arrived in 11.1. Here the identity provider itself owns the user data. Dozzle doesn't read users.yml at all, and takes roles (shell, actions, download, etc.) and container filters from the token. Add a user in Authentik and they can sign in; remove their role and they can't. Simple as that.

yaml
environment:
- DOZZLE_AUTH_PROVIDER=oidc
- DOZZLE_AUTH_OIDC_ISSUER=https://auth.stilicho.ru/application/o/dozzle/
- DOZZLE_AUTH_OIDC_CLIENT_ID=dozzle
- DOZZLE_AUTH_OIDC_CLIENT_SECRET=<client_secret>

The redirect URI on the provider side is https://dozzle.stilicho.ru/api/auth/callback. Dozzle looks for roles in the dozzle_roles claim, then resource_access.<client-id>.roles, then roles. The groups claim is deliberately ignored. Otherwise, any Authentik user who belongs to any group at all would get access to every log. If your permissions are group-based, map them into dozzle_roles on the provider side. I covered creating an OIDC provider in Authentik in OIDC, OAuth2 and Proxy Provider in Authentik.

Authentication via a reverse proxy (forward-proxy)

If you already have Authentik, Authelia, or Keycloak set up (the blog has a whole Single Sign On series) - there's no need for yet another separate login: route Dozzle through the same proxy's forward-auth instead:

yaml
environment:
- DOZZLE_AUTH_PROVIDER=forward-proxy
- DOZZLE_AUTH_HEADER_USER=Remote-User # the header carrying the username that your proxy passes through

This way, Dozzle trusts the authentication already performed at the Traefik/Authentik level, and won't ask for a separate password.

Warning

In forward-proxy mode, Dozzle trusts the Remote-User header on every request, and if the proxy doesn't send a roles header, the user gets every permission. So never publish Dozzle's port directly (ports:): anyone who reaches the container by going around the proxy can sign in as whoever they like just by setting that header. Dozzle should only be reachable through Traefik - like in the compose file above, which has no ports: section at all. Maybe I'm being a bit paranoid about security here, but forewarned is forearmed.

Note

Upgrading to Dozzle 11 logs everyone out once. Sessions are now signed with a random secret stored in /data/session_secret. That's expected. If you get logged out after every restart, though, the contents of /data aren't being persisted (see the installation section).


Interface and features

Once you open the web interface, you get:

  • a list of all containers on the host with a status indicator (running/exited/restarting);
  • a live log stream with auto-scroll and on-the-fly text/regex search;
  • highlighting of log levels (error, warn, info, etc.) and automatic formatting of JSON log lines into a readable form;
  • a stats tab for each container - CPU, memory, network, disk;
  • downloading a container's log as a file for a chosen time range (as JSON too, since 10.10);
  • with Actions enabled (see below) - buttons to start, stop, restart, and update a container right from the interface.

Actions - the container control buttons - are disabled by default and need to be enabled separately (or in the setup wizard):

yaml
environment:
- DOZZLE_ENABLE_ACTIONS=true
Note

Only enable Actions if you actually need to manage containers straight from Dozzle, and make sure the service is behind authentication (simple, oidc, or forward-proxy from the section above) - otherwise anyone who gets access to the web interface can stop or restart any container on the host. The same goes double for shell (DOZZLE_ENABLE_SHELL=true) - that's basically docker exec from a browser.

Most containers have a web UI of their own, and since 10.10 you can link to it straight from Dozzle with the dev.dozzle.url label:

yaml
labels:
- "dev.dozzle.url=https://grafana.stilicho.ru"

The link shows up next to the container name - in the sidebar, in the container table, and in the container page's title bar. A nice touch if everything goes through Traefik: for containers without the label, Dozzle reads the Host(...) rule from the Traefik labels and offers a ready-made snippet. It only becomes a link once you put the label into your compose file yourself.

Host metrics and disk usage

Since 11.2, the host card shows uptime, load average, and how full the disk holding Docker's data is. Disk works out of the box, but for uptime and load the container needs the host's /proc mounted - otherwise Dozzle only sees its own container's /proc and, to its credit, shows nothing rather than wrong numbers:

yaml
volumes:
- /var/run/docker.sock:/var/run/docker.sock
- /proc:/host/proc:ro
- ./data:/data

11.3 added a Disk column: the container's writable layer plus its volumes. Bind mounts (./data:/var/lib/postgresql/data) aren't counted - Docker knows nothing about what's inside them, so a database on a bind mount will show a few kilobytes. Next to the host's disk meter you'll also see Reclaimable - how much space you could free up (unused images, volumes, stopped containers, build cache), the same figure as docker system df.

Alerts

Alerts were rebuilt from scratch in 10.10. A rule is two expressions - which containers to watch and what to fire on. Alert types:

  • log - a log line matches a pattern (5xx errors, stack traces);
  • metric - CPU or memory crosses a threshold;
  • event - Docker events like an OOM kill or a container going unhealthy.

Destinations are webhook, Slack, Discord, and ntfy, and for webhooks you can write your own payload template. Alert settings live in /data too - one more reason to make sure that folder persists.

Dozzle Cloud

Dozzle Cloud is an optional paid service (with a free tier) from Dozzle's author that groups alerts, sends them to Telegram, email, push, and so on, and on paid plans also reads your logs and hunts for problems with an AI assistant. Your Dozzle connects to it outbound, so no inbound ports need opening.

But be aware that once linked, logs from every running container are sent to the cloud by default. For a self-hosted tool, that's an important point and, in my view, a pretty significant one. If you do want the cloud, you can limit what gets sent with a container label: dev.dozzle.cloud.min_level=warn (warnings and errors only) or dev.dozzle.cloud.min_level=disabled (nothing at all). Without linking, Dozzle sends nothing anywhere, and the cloud panel doesn't even show up in the UI.


Updating containers from Dozzle

The biggest addition this autumn: Dozzle can now update containers and is, for all practical purposes, a Watchtower replacement.

Update checks. Dozzle compares the digest of the image a container is running with what the registry currently serves for that tag. It does this with a so-called HEAD request for the manifest, so no layers are downloaded and Docker Hub rate limits aren't touched, and answers are cached for six hours. When a newer version is out, a dot appears on the container's menu. Checks work even with actions off, and you can turn them off with DOZZLE_IMAGE_CHECK_MODE=off (or manual to only check on demand). For a single container, use the dev.dozzle.update=off label. Locally built images, images pinned by digest, and images from private registries aren't checked.

Manual updates. With actions on, each container gets an Update button, and the dashboard gets an N updates button that updates everything you select in one go (one container at a time per host, with Dozzle itself last). This only makes sense for floating tags like latest or stable: a container on postgres:18.1 has nowhere to go.

Safe swap with rollback. The best part: Dozzle doesn't just recreate the container. The old one is renamed and kept around until the new one has run for 10 seconds without restarting (and reported healthy, if the image has a healthcheck). If the new container fails to start, exits, restarts, or turns unhealthy, Dozzle removes it and puts the old one back. Volumes and bind mounts are kept - only data written to the container's writable layer is lost. After a successful update, Dozzle cleans up old images on its own, keeping one previous image around for a possible rollback.

How Dozzle updates a container and rolls back on failure: the old container is kept until the new one has run for 10 seconds and is healthy

Scheduled auto-updates. Set them up under Settings → Updates or in the wizard:

yaml
environment:
- DOZZLE_ENABLE_ACTIONS=true # auto-update doesn't work without actions
- DOZZLE_AUTO_UPDATE=weekly # off / daily / weekly (weekly runs on Sunday)
- DOZZLE_AUTO_UPDATE_TIME=04:00 # server time, 03:00 by default
- DOZZLE_UPDATE_CONTAINERS=labelled # off - Dozzle only, labelled - by label, all - everything

In labelled mode (the default), only Dozzle itself and containers with this label get updated:

yaml
labels:
- "dev.dozzle.update=auto"
Warning

all mode (Everything) is exactly how postgres:latest ends up jumping to a new major version at 3 a.m. - one that can't read your old data files, because the maintainers decided to move paths around inside the container and nobody told you. Sure, the rollback might save the container, but not your nerves. Label your databases, and anything else holding data you care about, with dev.dozzle.update=off. And if you'd rather have updates to important services go through you, there's Diun for notifications, or a GitOps approach with Renovate, where every update is a pull request.

Dozzle updates itself using the same mechanism, via a short-lived helper container called dozzle-self-update-*. But only if it runs on the latest tag: a pinned version like amir20/dozzle:v11.3.0 never updates. Rolling back an update that succeeded but started misbehaving later is a Dozzle Cloud feature. The automatic rollback on a failed start works without the cloud.


Multi-host mode (agents)

If you have more than one server (say, a Proxmox cluster with a couple of nodes plus a separate mini PC) - you don't need to run Dozzle on every single one. You can install an agent on the remote hosts and connect them to one main Dozzle instance.

On the remote host:

yaml
services:
dozzle-agent:
image: amir20/dozzle:latest
container_name: dozzle-agent
command: agent
volumes:
- /var/run/docker.sock:/var/run/docker.sock
ports:
- 7007:7007
restart: unless-stopped

On the main host, where the web interface runs, add a variable pointing to the agent:

yaml
environment:
- DOZZLE_REMOTE_AGENT=192.168.1.20:7007|docker-01

The format is address:port|name|group, with name and group optional. List several agents separated by commas; groups collapse in the sidebar and can show merged logs from every host in the group:

yaml
environment:
- DOZZLE_REMOTE_AGENT=192.168.1.20:7007|docker-01|Prod,192.168.1.21:7007|docker-02|Prod,192.168.1.30:7007|test|Lab

You can also add an agent from the UI - Settings → Hosts → Add host, or the Hosts step of the wizard. It connects immediately, no restart needed, and is saved to /data/dozzle.yml. Agents defined in DOZZLE_REMOTE_AGENT can't be removed from the UI.

To get uptime and load on a remote host's card, give the agent the same /proc:/host/proc:ro mount as the main Dozzle. The agent itself updates like any other container - including through Dozzle's auto-update.

Note

Don't confuse agents with DOZZLE_REMOTE_HOST. That variable (format tcp://address:2375|name) is for connecting to a Docker API exposed over TCP, not to an agent on port 7007. For a homelab, agents are both simpler and safer than putting the Docker API on the network.

Agent certificates - port 7007 is access to the whole host

Caution

Everyone who uses agents needs to know this.

The built-in certificate the agent and main Dozzle use to encrypt their connection is identical in every copy of the image - anyone can pull it out of the public image. So the connection is encrypted, but the agent can't tell your Dozzle from someone else's. Anyone who can reach port 7007 can point their own Dozzle at your agent, read every log on that host, and run commands inside its containers. The agent doesn't look at DOZZLE_ENABLE_SHELL or DOZZLE_ENABLE_ACTIONS at all - those only control what the UI offers.

What to do about it:

  • keep port 7007 on a private network - or better, don't publish it at all (ports:) if the main Dozzle and the agent share a Docker network;
  • when adding an agent from the UI, leave the Private certificate toggle on (it's on by default for new hosts). Dozzle creates its own key pair in /data/agent_cert.pem and /data/agent_key.pem and hands you a ready-made compose snippet for the agent with the keys in DOZZLE_CERT_PEM/DOZZLE_KEY_PEM. That snippet contains the private key - treat it like a password and keep it out of public git repos;
  • or generate your own pair for the main Dozzle and all agents:
Terminal window
docker run --rm -v "$PWD":/out amir20/dozzle:latest generate-certs --cert-out /out/dozzle_cert.pem --key-out /out/dozzle_key.pem

Both files go on the main Dozzle and on every agent - by default they're looked up at /dozzle_cert.pem and /dozzle_key.pem:

yaml
services:
dozzle-agent:
image: amir20/dozzle:latest
command: agent
volumes:
- /var/run/docker.sock:/var/run/docker.sock
secrets:
- source: cert
target: /dozzle_cert.pem
- source: key
target: /dozzle_key.pem
ports:
- 7007:7007
restart: unless-stopped
secrets:
cert:
file: ./dozzle_cert.pem
key:
file: ./dozzle_key.pem

From then on, the agent only accepts connections from a Dozzle holding the same key pair. Restart the main Dozzle and the agents together.

Note

You can't put an agent behind a socket-proxy - the agent itself takes the place of one. If you want to restrict permissions with a socket-proxy, connect to the remote host via DOZZLE_REMOTE_HOST instead of using an agent.


Security

  • :ro on docker.sock doesn't restrict the Docker API - requests to create, remove, and recreate containers go through the socket regardless. If you don't need actions, the only real way to restrict access is a socket-proxy like tecnativa/docker-socket-proxy, which only lets through the Docker API endpoints you allow.
  • If you plan to use Actions, shell, or auto-updates - make sure authentication is enabled, otherwise it's an open door into managing your entire Docker host. Even if your network is locked down tighter than Fort Knox, it's still better to stick to basic security hygiene.
  • In multi-user setups, restrict users with roles and filters: without explicit roles, a user sees every container Dozzle can see.
  • In forward-proxy mode, never publish Dozzle's port directly - only through the proxy.
  • Agent port 7007 should be reachable by nothing but the main Dozzle, and if you can't guarantee that, use your own certificates.
  • As with any service that has access to the Docker socket, don't expose Dozzle directly to the internet without a reverse proxy, SSL, and authentication.

Pros and cons

Pros

  • Free and open source.
  • Genuinely zero-configuration - install it and you immediately see logs, and with the setup wizard the initial config takes a couple of minutes.
  • Lightweight - minimal resource usage, a great fit for a homelab.
  • Multi-host mode via agents - logs from all your servers in one window.
  • Built-in authentication, with the option to lock it down further, including OIDC or forward-proxy with an SSO you already have.
  • Container updates with automatic rollback - can replace Watchtower.

Cons

  • Logs aren't stored separately - Dozzle just shows what Docker itself physically keeps, and the history disappears after log rotation or container removal.
  • Not a replacement for a full logging stack (Loki/Grafana, ELK) for long-term storage and complex analytics.
  • Actions, shell, and auto-updates are powerful features that require careful authentication setup, or they become a security risk.
  • The built-in agent certificate is the same in every install - setting up your own is on you.
  • The project is growing fast: with Dozzle Cloud and an AI assistant on board, the "simple log viewer" isn't quite so simple anymore - good thing all the new stuff is optional.

Conclusion

Dozzle is one of those tools you install once and afterwards can't imagine how you ever lived without it (though, to be fair, you lived just fine. But something was missing, wasn't it?). It's not a substitute for full monitoring and doesn't keep logs long-term, but it solves the main task - quickly seeing what a container is doing right now - without touching a terminal. Version 11 is also a serious overhaul: OIDC sign-in, host metrics, container updates with rollback. It pairs nicely with Diun, which you may already know from my blog, and with management panels like Komodo or Dockhand - together they cover most of the day-to-day work of maintaining a Docker host (although, to be honest, they can show logs themselves too).