Dozzle

https://dozzle.dev/guide
Admin
Dozzle is a real-time log viewer for Docker containers, offering features like alerts, webhooks, and...
Tokens:23,070
Snippets:303
Trust Score:8.4
Update:2 months ago
Show doc for...
Tokens:
Raw
### Enable and Start User Podman Socket

Source: https://dozzle.dev/guide/podman

Enables and starts the user-level Podman socket for rootless containers.

```bash
systemctl --user enable podman.socket
systemctl --user start podman.socket
```

--------------------------------

### Install and Verify Metrics Server

Source: https://dozzle.dev/guide/k8s

Commands to install the Kubernetes Metrics API and verify its status, which is required for resource usage monitoring.

```bash
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml
```

```bash
kubectl top pod
```

--------------------------------

### Enable and Start Podman Socket

Source: https://dozzle.dev/guide/podman

Enables and starts the system-wide Podman socket for Dozzle to connect to the Docker socket.

```bash
sudo systemctl enable podman.socket
sudo systemctl start podman.socket
```

--------------------------------

### Install dtop with Homebrew

Source: https://dozzle.dev/guide/dtop

Install dtop using the Homebrew package manager. This is a straightforward installation method for macOS and Linux users.

```bash
brew install dtop
```

--------------------------------

### Enable and Start Dozzle Service with Quadlet

Source: https://dozzle.dev/guide/podman

Reloads systemd configuration and enables/starts the Dozzle service managed by Quadlet.

```bash
systemctl --user daemon-reload
systemctl --user enable --now dozzle.service
```

--------------------------------

### Configure Simple Authentication

Source: https://dozzle.dev/guide/authentication

Examples for enabling simple authentication using CLI flags, docker-compose, and the required users.yml file structure.

```sh
$ docker run -v /var/run/docker.sock:/var/run/docker.sock -v /path/to/dozzle/data:/data -p 8080:8080 amir20/dozzle --auth-provider simple
```

```yaml
services:
  dozzle:
    image: amir20/dozzle:latest
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /path/to/dozzle/data:/data
    ports:
      - 8080:8080
    environment:
      DOZZLE_AUTH_PROVIDER: simple
```

```yaml
users:
  admin:
    email: me@email.net
    name: Admin
    password: $2a$11$9ho4vY2LdJ/WBopFcsAS0uORC0x2vuFHQgT/yBqZyzclhHsoaIkzK
```

```yaml
services:
  dozzle:
    image: amir20/dozzle:latest
    environment:
      - DOZZLE_AUTH_PROVIDER=simple
    secrets:
      - source: users
        target: /data/users.yml
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - dozzle:/data
secrets:
  users:
    file: users.yml
volumes:
  dozzle:
```

--------------------------------

### Enable and Start Dozzle Agent Service with Quadlet

Source: https://dozzle.dev/guide/podman

Reloads systemd configuration and enables/starts the Dozzle agent service managed by Quadlet.

```bash
systemctl --user daemon-reload
systemctl --user enable dozzle-agent.service
systemctl --user start dozzle-agent.service
```

--------------------------------

### Run Rootless Dozzle Agent

Source: https://dozzle.dev/guide/podman

Starts a Dozzle agent for a specific user, connecting to their rootless Podman socket for remote monitoring.

```bash
sudo -u appuser podman run -d \
  --name dozzle-agent \
  -v /run/user/$(id -u appuser)/podman/podman.sock:/var/run/docker.sock:ro \
  -p 7007:7007 \
  ghcr.io/amir20/dozzle:latest agent
```

--------------------------------

### Run Dozzle with Docker CLI

Source: https://dozzle.dev/guide/getting-started

The simplest way to start Dozzle is using the Docker CLI. Ensure Docker Engine is 19.03 or newer. Mount the docker.sock and expose port 8080.

```sh
docker run -d -v /var/run/docker.sock:/var/run/docker.sock -v dozzle_data:/data -p 8080:8080 amir20/dozzle:latest
```

--------------------------------

### Run Dozzle Server with Agents via Command Line

Source: https://dozzle.dev/guide/podman

Start the Dozzle server in detached mode, exposing port 3000 and specifying agent endpoints directly.

```bash
podman run -d \
  --name dozzle \
  -p 3000:8080 \
  ghcr.io/amir20/dozzle:latest \
  --agent "host1.example.com:7007" \
  --agent "host2.example.com:7007"
```

--------------------------------

### Run dtop with Docker

Source: https://dozzle.dev/guide/dtop

Run dtop directly using Docker without a local installation. This method requires Docker to be installed and mounts the Docker socket for access.

```bash
docker run -v /var/run/docker.sock:/var/run/docker.sock -it ghcr.io/amir20/dtop:latest
```

--------------------------------

### Event Alert Expressions

Source: https://dozzle.dev/guide/alerts-and-webhooks

Examples of expressions used to trigger alerts based on Docker container lifecycle events.

```text
Container: labels["env"] == "production"
Event:     name == "die"
```

```text
Container: true
Event:     name == "oom"
```

```text
Container: true
Event:     name == "health_status" && attributes["healthStatus"] == "unhealthy"
```

```text
Container: name contains "worker"
Event:     name == "die" && !(attributes["exitCode"] in ["0", "130", "143", "137"])
```

--------------------------------

### Deploy Dozzle with Simple Authentication in Swarm Mode

Source: https://dozzle.dev/guide/swarm-mode

Configure Dozzle in Swarm Mode with simple authentication using a Docker secret for the users.yml file. This example sets the authentication provider and debug logging level.

```yaml
services:
  dozzle:
    image: amir20/dozzle:latest
    environment:
      - DOZZLE_LEVEL=debug
      - DOZZLE_MODE=swarm
      - DOZZLE_AUTH_PROVIDER=simple
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /opt/dozzle/data:/data
    secrets:
      - source: users
        target: /data/users.yml

    ports:
      - "8080:8080"
    networks:
      - dozzle
    deploy:
      mode: global

networks:
  dozzle:
    driver: overlay
secrets:
  users:
    file: users.yml
```

--------------------------------

### Run Rootful Dozzle Agent

Source: https://dozzle.dev/guide/podman

Starts a Dozzle agent in detached mode, connecting to the system Podman socket for remote monitoring.

```bash
podman run -d \
  --name dozzle-agent \
  -v /run/podman/podman.sock:/var/run/docker.sock:ro \
  -p 7007:7007 \
  ghcr.io/amir20/dozzle:latest agent
```

--------------------------------

### Metric Alert Expressions

Source: https://dozzle.dev/guide/alerts-and-webhooks

Examples of expressions used to trigger alerts based on CPU and memory usage thresholds.

```text
Container: labels["env"] == "production"
Metric:    cpu > 90
```

```text
Container: name contains "api"
Metric:    memory > 85
```

```text
Container: name == "postgres"
Metric:    memoryUsage > 1073741824
```

--------------------------------

### Count All Logs

Source: https://dozzle.dev/guide/sql-engine

Use this query to get the total number of log entries available for analysis.

```sql
SELECT COUNT(*) FROM logs
```

--------------------------------

### Configure Nginx proxy buffering

Source: https://dozzle.dev/guide/faq

Example configuration for Nginx to disable buffering for Dozzle's SSE streams.

```nginx
server {
    ...

    location / {
        proxy_pass                  http://<dozzle.container.ip.address>:8080;
    }

    location /api {
        proxy_pass                  http://<dozzle.container.ip.address>:8080;
```

--------------------------------

### Identify Duplicate Host ID Error

Source: https://dozzle.dev/guide/faq

Example of the log entry indicating a duplicate host ID conflict.

```text
time="2024-07-10T13:35:53Z" level=warning msg="duplicate host ID: *********, Endpoint: 1.1.1.1:7007 found, skipping"
```

--------------------------------

### Run Dozzle with Docker Compose

Source: https://dozzle.dev/guide/getting-started

Configure Dozzle using a docker-compose.yml file for easier management. This setup includes volume mounting for data persistence and port mapping.

```yaml
# Run with docker compose up -d
services:
  dozzle:
    image: amir20/dozzle:latest
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - dozzle_data:/data
    ports:
      - 8080:8080
    environment:
      # Uncomment to enable container actions (stop, start, restart). See https://dozzle.dev/guide/actions
      # - DOZZLE_ENABLE_ACTIONS=true
      #
      # Uncomment to allow access to container shells. See https://dozzle.dev/guide/shell
      # - DOZZLE_ENABLE_SHELL=true
      #
      # Uncomment to enable authentication. See https://dozzle.dev/guide/authentication
      # - DOZZLE_AUTH_PROVIDER=simple
      #
      # Label this Dozzle instance (shown in the header and multi-host menu). See https://dozzle.dev/guide/hostname
      # - DOZZLE_HOSTNAME=my-server
      #
      # Connect to one or more remote agents to monitor other Docker hosts. See https://dozzle.dev/guide/agent
      # - DOZZLE_REMOTE_AGENT=192.168.1.10:7007,192.168.1.11:7007
      #
      # Only show containers matching a filter. See https://dozzle.dev/guide/filters
      # - DOZZLE_FILTER=label=com.example.app
v
olumes:
  dozzle_data:

```

--------------------------------

### Run Docker Socket Proxy

Source: https://dozzle.dev/guide/remote-hosts

Start a Docker Socket Proxy to expose the docker.sock file without TLS. This allows Dozzle to connect directly. Ensure necessary environment variables like CONTAINERS=1 and INFO=1 are set for required API access.

```sh
docker container run --privileged -e CONTAINERS=1 -e INFO=1 -v /var/run/docker.sock:/var/run/docker.sock -p 2375:2375 tecnativa/docker-socket-proxy
```

--------------------------------

### Run Dozzle Agent with Docker CLI

Source: https://dozzle.dev/guide/agent

This command starts a Dozzle agent, exposing Docker containers on the host. It mounts the Docker socket and maps port 7007 for communication.

```sh
docker run -v /var/run/docker.sock:/var/run/docker.sock -p 7007:7007 amir20/dozzle:latest agent
```

--------------------------------

### Set Agent Container Filters

Source: https://dozzle.dev/guide/agent

Limit the containers the agent can access by setting environment variables for Docker filters. This example filters by label.

```yaml
services:
  dozzle-agent:
    image: amir20/dozzle:latest
    command: agent
    environment:
      - DOZZLE_FILTER=label=color
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
```

--------------------------------

### Enable Cgroups on ARM Devices

Source: https://dozzle.dev/guide/faq

Add these parameters to /boot/cmdline.txt to enable memory tracking on ARM devices.

```text
cgroup_enable=cpuset cgroup_enable=memory cgroup_memory=1
```

--------------------------------

### Configure Custom Certificates with Command-Line Flags

Source: https://dozzle.dev/guide/agent

Use --cert and --key flags with `docker run` to specify custom certificate paths.

```sh
docker run -v /var/run/docker.sock:/var/run/docker.sock -v ./certs:/certs -p 7007:7007 amir20/dozzle:latest agent --cert /certs/my-cert.pem --key /certs/my-cert.pem
```

--------------------------------

### Authelia Configuration File

Source: https://dozzle.dev/guide/authentication

Sets up the authentication backend, access control rules, and session security for the Authelia server.

```yaml
###############################################################
#                   Authelia configuration                      #
###############################################################

jwt_secret: a_very_important_secret
default_redirection_url: https://public.example.com

server:
  host: 0.0.0.0
  port: 9091

log:
  level: info

totp:
  issuer: authelia.com

authentication_backend:
  file:
    path: /config/users_database.yml

access_control:
  default_policy: deny
  rules:
    - domain: traefik.example.com
      policy: one_factor
    - domain: dozzle.example.com
      policy: one_factor

session:
  secret: unsecure_session_secret
  domain: example.com # Should match whatever your root protected domain is

regulation:
  max_retries: 3
  find_time: 120
  ban_time: 300

storage:
  encryption_key: you_must_generate_a_random_string_of_more_than_twenty_chars_and_configure_this
  local:
    path: /config/db.sqlite3

notifier:
  filesystem:
    filename: /config/notification.txt
```

--------------------------------

### Enable Deployments with Docker Run

Source: https://dozzle.dev/guide/deployments

Run Dozzle with persistent data volume and enabled actions to manage deployments.

```sh
docker run \
  --volume=/var/run/docker.sock:/var/run/docker.sock \
  --volume=/path/to/data:/data \
  -p 8080:8080 \
  amir20/dozzle --enable-actions
```

--------------------------------

### Initial Table Creation for SQL Engine

Source: https://dozzle.dev/guide/sql-engine

This query is run initially by Dozzle to create a virtual table from JSON logs, making them queryable.

```sql
CREATE TABLE logs AS SELECT unnest(m) FROM 'logs.json'
```

--------------------------------

### Enable MCP via CLI

Source: https://dozzle.dev/guide/mcp

Run the Dozzle container with the --enable-mcp flag to expose the MCP endpoint.

```sh
docker run --volume=/var/run/docker.sock:/var/run/docker.sock -p 8080:8080 amir20/dozzle --enable-mcp
```

--------------------------------

### Traefik Service Labels for Dozzle

Source: https://dozzle.dev/guide/changing-base

Example Traefik labels for routing to a Dozzle service. Ensure the correct port is exposed and TLS is configured.

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

--------------------------------

### Enable Memory Delegation for User Slice

Source: https://dozzle.dev/guide/podman

Configure systemd to delegate memory and other controllers to the user slice by creating a drop-in configuration file.

```bash
sudo mkdir -p /etc/systemd/system/user@.service.d
sudo tee /etc/systemd/system/user@.service.d/delegate.conf <<'EOF'
[Service]
Delegate=cpu cpuset io memory pids
EOF
sudo systemctl daemon-reload
```

--------------------------------

### Configure Custom Certificates with Environment Variables

Source: https://dozzle.dev/guide/agent

Specify custom paths for certificates using DOZZLE_CERT and DOZZLE_KEY environment variables, mounting a local certs directory.

```yaml
services:
  agent:
    image: amir20/dozzle:latest
    command: agent
    environment:
      - DOZZLE_CERT=/certs/my-cert.pem
      - DOZZLE_KEY=/certs/my-key.pem
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./certs:/certs
    ports:
      - 7007:7007
```

--------------------------------

### Run Dozzle with System Podman

Source: https://dozzle.dev/guide/podman

Runs Dozzle in standalone mode, connecting to the system-wide Podman daemon via its socket.

```bash
podman run -v /run/podman/podman.sock:/var/run/docker.sock:ro \
  -p 3000:8080 \
  ghcr.io/amir20/dozzle:latest
```

--------------------------------

### Enable Actions with Docker Run

Source: https://dozzle.dev/guide/actions

Run Dozzle with the Docker socket mounted and the DOZZLE_ENABLE_ACTIONS environment variable set to true to enable container actions.

```sh
docker run --volume=/var/run/docker.sock:/var/run/docker.sock -p 8080:8080 amir20/dozzle --enable-actions
```

--------------------------------

### Generate users.yml via CLI

Source: https://dozzle.dev/guide/authentication

Use the Dozzle generate command to create user configurations. Password input can be provided via flags or interactively via stdin.

```sh
docker run -it --rm amir20/dozzle generate admin --password password --email test@email.net --name "John Doe" --user-filter name=foo --user-roles shell > users.yml
```

```sh
docker run -it --rm amir20/dozzle generate admin --email test@email.net --name "John Doe" > users.yml
```

--------------------------------

### Configure Forward Proxy Authentication

Source: https://dozzle.dev/guide/authentication

Enable forward proxy authentication by setting the auth-provider flag or environment variable.

```sh
$ docker run -v /var/run/docker.sock:/var/run/docker.sock -p 8080:8080 amir20/dozzle --auth-provider forward-proxy
```

```yaml
services:
  dozzle:
    image: amir20/dozzle:latest
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    ports:
      - 8080:8080
    environment:
      DOZZLE_AUTH_PROVIDER: forward-proxy
```

--------------------------------

### Run Dozzle with Rootless Podman

Source: https://dozzle.dev/guide/podman

Runs Dozzle in standalone mode, connecting to a specific user's rootless Podman daemon.

```bash
podman run -v /run/user/$(id -u appuser)/podman/podman.sock:/var/run/docker.sock:ro \
  -p 3000:8080 \
  ghcr.io/amir20/dozzle:latest
```

--------------------------------

### Create a Custom Container Group with Docker CLI

Source: https://dozzle.dev/guide/container-groups

Use the 'dev.dozzle.group' label with the 'docker run' command to assign a container to a custom group.

```bash
docker run --label dev.dozzle.group=myapp hello-world
```

--------------------------------

### Run Dozzle Server with Agents via Environment Variable

Source: https://dozzle.dev/guide/podman

Deploy Dozzle using an environment variable to list remote agent endpoints, suitable for simpler configurations.

```bash
podman run -d \
  --name dozzle \
  -e DOZZLE_REMOTE_AGENT="host1.example.com:7007,host2.example.com:7007" \
  -p 3000:8080 \
  ghcr.io/amir20/dozzle:latest
```

--------------------------------

### Combine Container Expression Conditions

Source: https://dozzle.dev/guide/alerts-and-webhooks

Use logical operators like &&, ||, and ! to combine multiple container monitoring conditions.

```text
name contains "api" && labels["env"] == "production"
```

--------------------------------

### Verify Docker Memory Support

Source: https://dozzle.dev/guide/faq

Check for memory limit warnings in Docker system information.

```bash
WARNING: No memory limit support
WARNING: No swap limit support
```

--------------------------------

### Enable Deployments with Docker Compose

Source: https://dozzle.dev/guide/deployments

Configure Dozzle in a Docker Compose file to enable deployments by setting the DOZZLE_ENABLE_ACTIONS environment variable and persisting the /data volume.

```yaml
services:
  dozzle:
    image: amir20/dozzle:latest
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /path/to/data:/data
    ports:
      - 8080:8080
    environment:
      DOZZLE_ENABLE_ACTIONS: true
```

--------------------------------

### Configure Dozzle Server with Agents using Quadlet

Source: https://dozzle.dev/guide/podman

Define Dozzle as a systemd container service using a Quadlet file, specifying agents via environment variables and port mappings.

```ini
# dozzle-server.container
[Unit]
Description=Dozzle Server with Remote Agents
After=network-online.target
Wants=network-online.target

[Container]
Image=ghcr.io/amir20/dozzle:latest
PublishPort=3000:8080
Environment=DOZZLE_REMOTE_AGENT=host1.example.com:7007,host2.example.com:7007

HealthCmd=/dozzle healthcheck
HealthInterval=5s
HealthTimeout=10s
HealthRetries=5
HealthStartPeriod=15s

[Service]
Restart=on-failure
RestartSec=10

[Install]
WantedBy=default.target
```

--------------------------------

### Create OAuth2 Proxy Configuration

Source: https://dozzle.dev/guide/authentication

Define the OIDC provider settings and cookie security parameters in the oauth2-proxy.cfg file.

```toml
 client_id = "xxx"                            # from Pocket ID
 client_secret = "xxx"                        # from Pocket ID
 cookie_secret = "xxx"                        # generate with openssl rand -base64 32 | tr -- '+/' '-_'
 upstreams = "http://dozzle:8080"             # upstream to Dozzle containers internal port
 code_challenge_method = "S256"               # PKCE challenges plain or S256
 cookie_expire = "0"                          # seconds, 0 for session
 cookie_name = "__Host-oauth2-proxy"          # or __Secure-oauth2-proxy (less secure)
 cookie_secure = true                         # uses the secure HTTPS cookie
 email_domains = ["*"]                        # allows any email domain to authenticate
 http_address = "0.0.0.0:4180"                # port oauth2-proxy listens on
 oidc_issuer_url = "https://id.example.com"   # your Pocket base URL
 provider_display_name = "Pocket ID"          # display name for OIDC login
 provider = "oidc"                            # use OpenID connect
 reverse_proxy = true                         # reverse proxy the traffic
 scope = "openid email profile groups"        # passthru these OIDC scopes
```

--------------------------------

### Generate Podman Engine ID using uuidgen

Source: https://dozzle.dev/guide/podman

Create a directory for the engine ID and generate a unique UUID using `uuidgen`, then verify its content.

```bash
# Create directory if needed
sudo mkdir -p /var/lib/docker

# Generate UUID
sudo sh -c 'uuidgen > /var/lib/docker/engine-id'

# Verify
cat /var/lib/docker/engine-id
```

--------------------------------

### Tail Mounted Log File with Alpine

Source: https://dozzle.dev/guide/log-files-on-disk

Use this command to tail a mounted log file from a host machine using Alpine Linux. Ensure the log file is mounted into the container.

```sh
docker run -v /var/log/system.log:/var/log/test.log alpine tail -f /var/log/test.log
```

--------------------------------

### Quadlet Configuration for Dozzle

Source: https://dozzle.dev/guide/podman

Defines a Quadlet container file for running Dozzle as a systemd service, connecting to a user's rootless Podman socket.

```ini
[Unit]
Description=Dozzle Log Viewer
After=network-online.target
Wants=network-online.target

[Container]
Image=ghcr.io/amir20/dozzle:latest
PublishPort=3000:8080
Volume=/run/user/%U/podman/podman.sock:/var/run/docker.sock:ro

HealthCmd=/dozzle healthcheck
HealthInterval=5s
HealthTimeout=10s
HealthRetries=5
HealthStartPeriod=15s

[Service]
Restart=on-failure
RestartSec=10

[Install]
WantedBy=default.target
```

--------------------------------

### Quadlet Configuration for Dozzle Agent

Source: https://dozzle.dev/guide/podman

Defines a Quadlet container file for running the Dozzle agent, connecting to a user's rootless Podman socket.

```ini
# dozzle-agent.container
[Unit]
Description=Dozzle Agent
After=network-online.target
Wants=network-online.target

[Container]
Image=ghcr.io/amir20/dozzle:latest
PublishPort=7007:7007
Volume=/run/user/%U/podman/podman.sock:/var/run/docker.sock:ro
Exec=agent

HealthCmd=/dozzle healthcheck
HealthInterval=5s
HealthTimeout=10s
HealthRetries=5
HealthStartPeriod=15s

[Service]
Restart=on-failure
RestartSec=10

[Install]
WantedBy=default.target
```

--------------------------------

### Enable MCP via Docker Compose

Source: https://dozzle.dev/guide/mcp

Configure the Dozzle service in docker-compose.yml using the DOZZLE_ENABLE_MCP environment variable.

```yaml
services:
  dozzle:
    image: amir20/dozzle:latest
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    ports:
      - 8080:8080
    environment:
      DOZZLE_ENABLE_MCP: true
```

--------------------------------

### Configure Traefik Compression Middleware

Source: https://dozzle.dev/guide/faq

Standard Traefik middleware configuration for enabling compression.

```yaml
http:
  middlewares:
    middlewares-compress:
      compress: {}
```

--------------------------------

### Configure Claude Desktop MCP

Source: https://dozzle.dev/guide/mcp

Add the Dozzle MCP server configuration to your Claude Desktop settings.

```json
{
  "mcpServers": {
    "dozzle": {
      "type": "streamable-http",
      "url": "http://localhost:8080/api/mcp"
    }
  }
}
```

--------------------------------

### Configure VS Code MCP Settings

Source: https://dozzle.dev/guide/mcp

Add the Dozzle MCP server configuration to your .vscode/mcp.json file.

```json
{
  "servers": {
    "dozzle": {
      "type": "http",
      "url": "http://localhost:8080/api/mcp"
    }
  }
}
```

--------------------------------

### Enable Shell Access with Docker Run

Source: https://dozzle.dev/guide/shell

Run Dozzle with the `--enable-shell` flag to allow shell access to containers. Ensure the Docker socket is mounted.

```shell
docker run --volume=/var/run/docker.sock:/var/run/docker.sock -p 8080:8080 amir20/dozzle --enable-shell
```

--------------------------------

### Alert on Authentication Failures via Regex

Source: https://dozzle.dev/guide/alerts-and-webhooks

Use case-insensitive regex matching to detect unauthorized or forbidden access attempts.

```text
Container: name contains "auth" || name contains "gateway"
Log:       message matches "(?i)(unauthorized|forbidden|invalid token)"
```

--------------------------------

### Configure Custom Certificates with Command-Line Flags in Docker Compose

Source: https://dozzle.dev/guide/agent

Specify custom certificate paths directly in the `command` for the agent service in docker-compose.yml.

```yaml
services:
  agent:
    image: amir20/dozzle:latest
    command: agent --cert /certs/my-cert.pem --key /certs/my-cert.pem
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./certs:/certs
    ports:
      - 7007:7007
```

--------------------------------

### Run Dozzle with a Custom Base Path

Source: https://dozzle.dev/guide/changing-base

Use the --base flag with the docker run command to specify a custom base path for Dozzle. This makes Dozzle accessible at a sub-path instead of the root.

```docker
docker run --volume=/var/run/docker.sock:/var/run/docker.sock -p 8080:8080 amir20/dozzle --base /foobar
```

--------------------------------

### Connect to Multiple Remote Hosts with TLS (Docker Compose)

Source: https://dozzle.dev/guide/remote-hosts

Configure multiple remote Docker hosts using a comma-separated list for the DOZZLE_REMOTE_HOST environment variable in docker-compose.yml. Mount necessary certificates to /certs.

```yaml
services:
  dozzle:
    image: amir20/dozzle:latest
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /path/to/certs:/certs
    ports:
      - 8080:8080
    environment:
      DOZZLE_REMOTE_HOST: tcp://167.99.1.1:2376,tcp://167.99.1.2:2376
```

--------------------------------

### Configure Swarm Mode Overlay Network

Source: https://dozzle.dev/guide/faq

Use a dedicated overlay network for Dozzle instances in Swarm Mode to resolve connectivity and load balancing issues.

```yaml
services:
  logs:
    ...
    networks: [ traefik, dozzle ]
    ...

networks:
  dozzle:
    driver: overlay
  traefik:
    external: true
```

--------------------------------

### Deploy Dozzle in Swarm Mode (Global)

Source: https://dozzle.dev/guide/swarm-mode

Deploy Dozzle as a global service on every node in the swarm. This ensures Dozzle is available on all hosts for log aggregation. The DOZZLE_MODE=swarm environment variable enables swarm discovery.

```yaml
services:
  dozzle:
    image: amir20/dozzle:latest
    environment:
      - DOZZLE_MODE=swarm
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /opt/dozzle/data:/data
    ports:
      - 8080:8080
    networks:
      - dozzle
    deploy:
      mode: global
networks:
  dozzle:
    driver: overlay
```

--------------------------------

### Configure Log Forwarding with Labels

Source: https://dozzle.dev/guide/dozzle-cloud

Use the `dev.dozzle.cloud.min_level` label to control which log lines are forwarded to Dozzle Cloud. Set to `disabled` to skip a container entirely, or specify a minimum log level (`warn`, `error`, `fatal`) to filter logs.

```yaml
services:
  zigbee2mqtt:
    image: koenkk/zigbee2mqtt
    labels:
      # Only forward warn/error/fatal to Dozzle Cloud
      - dev.dozzle.cloud.min_level=warn

  noisy-debug-tool:
    image: example/debug
    labels:
      # Don't send anything from this container
      - dev.dozzle.cloud.min_level=disabled
```

--------------------------------

### Manually Run Podman Healthcheck

Source: https://dozzle.dev/guide/podman

Execute a manual healthcheck for a specific container using its ID, useful for debugging when automatic checks fail.

```bash
# Manual healthcheck run
podman healthcheck run <container_id>
```

--------------------------------

### Connect to Multiple Remote Hosts with TLS (CLI)

Source: https://dozzle.dev/guide/remote-hosts

Use the --remote-host flag multiple times to specify multiple remote Docker hosts when connecting with TLS certificates. Ensure certificates are mounted to the /certs directory.

```sh
docker run -v /var/run/docker.sock:/var/run/docker.sock -v /path/to/certs:/certs -p 8080:8080 amir20/dozzle --remote-host tcp://167.99.1.1:2376 --remote-host tcp://167.99.1.2:2376
```

--------------------------------

### Generate Engine ID for Podman

Source: https://dozzle.dev/guide/faq

Commands to manually generate and set an engine-id file when using Podman.

```bash
mkdir -p /var/lib/docker
uuidgen > engine-id
```

--------------------------------

### Configure Agent Healthcheck

Source: https://dozzle.dev/guide/agent

Set up a healthcheck for the agent to monitor its connection to Docker. If Docker is unreachable, the agent is marked unhealthy.

```yaml
services:
  dozzle-agent:
    image: amir20/dozzle:latest
    command: agent
    healthcheck:
      test: ["CMD", "/dozzle", "healthcheck"]
      interval: 5s
      retries: 5
      start_period: 5s
      start_interval: 5s
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
    ports:
      - 7007:7007
```

--------------------------------

### Create Podman Engine ID using Ansible

Source: https://dozzle.dev/guide/podman

Use Ansible to create the `/var/lib/docker` directory and generate an engine-id file using the system's hostname.

```yaml
- name: Create /var/lib/docker
  ansible.builtin.file:
    path: /var/lib/docker
    state: directory
    mode: "755"

- name: Create engine-id and derive UUID from hostname
  ansible.builtin.lineinfile:
    path: /var/lib/docker/engine-id
    line: "{{ hostname | to_uuid }}"
    create: true
    mode: "0644"
    insertafter: "EOF"
```

--------------------------------

### Check Cgroup Controllers for Memory Delegation

Source: https://dozzle.dev/guide/podman

Inspect the `cgroup.controllers` file to determine if the `memory` controller is delegated to the user slice.

```bash
cat /sys/fs/cgroup/user.slice/user-$(id -u).slice/cgroup.controllers
```

--------------------------------

### Configure Custom Certificates with Docker Compose Secrets

Source: https://dozzle.dev/guide/agent

Provide custom certificates for agent communication using Docker Compose secrets, mounting them to default paths.

```yaml
services:
  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
secrets:
  cert:
    file: ./cert.pem
  key:
    file: ./key.pem
```

--------------------------------

### Quadlet Healthcheck Command Format

Source: https://dozzle.dev/guide/podman

Specify the healthcheck command for Quadlet using a plain command line, not a JSON array.

```ini
HealthCmd=/dozzle healthcheck
```

--------------------------------

### Running Dozzle in Agent Mode

Source: https://dozzle.dev/guide/supported-env-vars

This command demonstrates how to run Dozzle in agent mode, which is useful for monitoring a remote Docker host. It requires mounting the Docker socket and specifying the remote agent's IP and port.

```sh
docker run --volume=/var/run/docker.sock:/var/run/docker.sock -p 8080:8080 amir20/dozzle --remote-agent remote-ip:7007
```

--------------------------------

### Run Dozzle with Persistent Data

Source: https://dozzle.dev/guide/alerts-and-webhooks

Mount the /data directory to ensure notification settings and alert configurations persist across container restarts.

```sh
docker run -v /var/run/docker.sock:/var/run/docker.sock -v /path/to/data:/data -p 8080:8080 amir20/dozzle:latest
```

```yaml
services:
  dozzle:
    image: amir20/dozzle:latest
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /path/to/data:/data
    ports:
      - 8080:8080
```

--------------------------------

### Define users in YAML configuration

Source: https://dozzle.dev/guide/authentication

The structure for defining users in the file-based authentication system.

```yaml
users:
```

--------------------------------

### Caddy Configuration for Dozzle with Disabled Buffering

Source: https://dozzle.dev/guide/changing-base

Configure Caddy to reverse proxy to Dozzle, disabling response buffering using 'flush_interval -1'. This is crucial for streaming endpoints like SSE.

```caddy
dozzle.example.com {
    reverse_proxy dozzle:8080 {
        flush_interval -1
    }
}
```

--------------------------------

### Add Labels to Remote Hosts (Docker Compose)

Source: https://dozzle.dev/guide/remote-hosts

Configure remote hosts with labels in docker-compose.yml by appending the label to the connection string with a pipe (|) in the DOZZLE_REMOTE_HOST environment variable. This allows for custom identification in the UI.

```yaml
services:
  dozzle:
    image: amir20/dozzle:latest
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /path/to/certs:/certs
    ports:
      - 8080:8080
    environment:
      DOZZLE_REMOTE_HOST: tcp://167.99.1.1:2376|foo.com,tcp://167.99.1.2:2376|bar.com
```

--------------------------------

### Configure Authenticated VS Code MCP Settings

Source: https://dozzle.dev/guide/mcp

Include a Bearer token in the headers section of your VS Code MCP configuration when using simple authentication.

```json
{
  "servers": {
    "dozzle": {
      "type": "http",
      "url": "http://localhost:8080/api/mcp",
      "headers": {
        "Authorization": "Bearer <your-jwt-token>"
      }
    }
  }
}
```

--------------------------------

### Configure Dozzle with Pocket ID

Source: https://dozzle.dev/guide/authentication

Add these environment variables to your Dozzle service configuration when using an OIDC-compliant forward proxy like oauth2-proxy.

```yaml
environment:
  DOZZLE_AUTH_PROVIDER: forward-proxy
  DOZZLE_AUTH_HEADER_USER: X-Forwarded-User
  DOZZLE_AUTH_HEADER_EMAIL: X-Forwarded-Email
  DOZZLE_AUTH_HEADER_NAME: X-Forwarded-Preferred-Username
```

--------------------------------

### Docker Compose for Following Mounted Log Files

Source: https://dozzle.dev/guide/log-files-on-disk

This docker-compose configuration allows you to follow a mounted log file. It ensures the log stream persists across server reboots. The Alpine image is used for its small memory footprint.

```yaml
services:
  dozzle-from-file:
    container_name: dozzle-from-file
    image: alpine
    volumes:
      - /var/log/system.log:/var/log/stream.log
    command:
      - tail
      - -f
      - /var/log/stream.log
    network_mode: none
    restart: unless-stopped
```

--------------------------------

### Enable Actions with Docker Compose

Source: https://dozzle.dev/guide/actions

Configure Dozzle in your docker-compose.yml file to enable container actions by setting the DOZZLE_ENABLE_ACTIONS environment variable.

```yaml
services:
  dozzle:
    image: amir20/dozzle:latest
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    ports:
      - 8080:8080
    environment:
      DOZZLE_ENABLE_ACTIONS: true
```

--------------------------------

### Connect to Multiple Dozzle Agents with Grouping (Docker Compose)

Source: https://dozzle.dev/guide/agent

Configures a Dozzle UI to connect to multiple remote agents, organizing them into groups using the DOZZLE_REMOTE_AGENT environment variable. Multiple agents and groups can be specified.

```yaml
services:
  dozzle:
    image: amir20/dozzle:latest
    environment:
      - DOZZLE_REMOTE_AGENT=agent1:7007|web-1|Production,agent2:7007|web-2|Production,agent3:7007|dev-1|Development
    ports:
      - 8080:8080
```

--------------------------------

### Dozzle and Authelia Docker Compose Configuration

Source: https://dozzle.dev/guide/authentication

Defines the services for Authelia, Traefik, and Dozzle with the required labels for forward authentication.

```yaml
networks:
  net:
    driver: bridge

services:
  authelia:
    image: authelia/authelia
    container_name: authelia
    volumes:
      - ./authelia:/config
    networks:
      - net
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.authelia.rule=Host(`authelia.example.com`)"
      - "traefik.http.routers.authelia.entrypoints=https"
      - "traefik.http.routers.authelia.tls=true"
      - "traefik.http.routers.authelia.tls.options=default"
      - "traefik.http.middlewares.authelia.forwardauth.address=http://authelia:9091/api/verify?rd=https://authelia.example.com"
      - "traefik.http.middlewares.authelia.forwardauth.trustForwardHeader=true"
      - "traefik.http.middlewares.authelia.forwardauth.authResponseHeaders=Remote-User,Remote-Groups,Remote-Name,Remote-Email"
    expose:
      - 9091
    restart: unless-stopped

  traefik:
    image: traefik:2.10.5
    container_name: traefik
    volumes:
      - ./traefik:/etc/traefik
      - /var/run/docker.sock:/var/run/docker.sock
    networks:
      - net
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.api.rule=Host(`traefik.example.com`)"
      - "traefik.http.routers.api.entrypoints=https"
      - "traefik.http.routers.api.service=api@internal"
      - "traefik.http.routers.api.tls=true"
      - "traefik.http.routers.api.tls.options=default"
      - "traefik.http.routers.api.middlewares=authelia@docker"
    ports:
      - "80:80"
      - "443:443"
    command:
      - "--api"
      - "--providers.docker=true"
      - "--providers.docker.exposedByDefault=false"
      - "--providers.file.filename=/etc/traefik/certificates.yml"
      - "--entrypoints.http=true"
      - "--entrypoints.http.address=:80"
      - "--entrypoints.http.http.redirections.entrypoint.to=https"
      - "--entrypoints.http.http.redirections.entrypoint.scheme=https"
      - "--entrypoints.https=true"
      - "--entrypoints.https.address=:443"
      - "--log=true"
      - "--log.level=DEBUG"

  dozzle:
    image: amir20/dozzle:latest
    networks:
      - net
    environment:
      DOZZLE_AUTH_PROVIDER: forward-proxy
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.dozzle.rule=Host(`dozzle.example.com`)"
      - "traefik.http.routers.dozzle.entrypoints=https"
      - "traefik.http.routers.dozzle.tls=true"
      - "traefik.http.routers.dozzle.tls.options=default"
      - "traefik.http.routers.dozzle.middlewares=authelia@docker"
    expose:
      - 8080
    restart: unless-stopped
```

--------------------------------

### Deploy Dozzle Stack in Swarm

Source: https://dozzle.dev/guide/getting-started

Command to deploy the Dozzle stack defined in a docker-compose.yml file to a Swarm cluster.

```bash
docker stack deploy -c dozzle-stack.yml <name>
```

--------------------------------

### Configure Dozzle with Cloudflare Zero Trust

Source: https://dozzle.dev/guide/authentication

Use these environment variables in your Docker Compose file to enable authentication via Cloudflare Zero Trust headers.

```yaml
services:
  dozzle:
    image: amir20/dozzle:latest
    networks:
      - net
    environment:
      DOZZLE_AUTH_PROVIDER: forward-proxy
      DOZZLE_AUTH_HEADER_USER: Cf-Access-Authenticated-User-Email
      DOZZLE_AUTH_HEADER_EMAIL: Cf-Access-Authenticated-User-Email
      DOZZLE_AUTH_HEADER_NAME: Cf-Access-Authenticated-User-Email
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    expose:
      - 8080
    restart: unless-stopped
```

--------------------------------

### Connect to a Dozzle Agent with Docker CLI

Source: https://dozzle.dev/guide/agent

This command runs a Dozzle UI instance that connects to a remote agent. It maps port 8080 for the UI and specifies the agent's address as 'agent:7007'.

```sh
docker run -p 8080:8080 amir20/dozzle:latest --remote-agent agent:7007
```

--------------------------------

### Connect to Multiple Dozzle Agents with Grouping (Docker CLI)

Source: https://dozzle.dev/guide/agent

Connects to multiple Dozzle agents, assigning them to named groups for better organization in the UI. Each agent is specified with its endpoint, an optional name override, and a group name.

```sh
docker run -p 8080:8080 amir20/dozzle:latest \
  --remote-agent agent1:7007|web-1|Production \
  --remote-agent agent2:7007|web-2|Production \
  --remote-agent agent3:7007|dev-1|Development
```

--------------------------------

### Enable Shell Access with Docker Compose

Source: https://dozzle.dev/guide/shell

Configure Dozzle in `docker-compose.yml` to enable shell access by setting the `DOZZLE_ENABLE_SHELL` environment variable to `true`. Mount the Docker socket.

```yaml
services:
  dozzle:
    image: amir20/dozzle:latest
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    ports:
      - 8080:8080
    environment:
      DOZZLE_ENABLE_SHELL: true
```

--------------------------------

### Alert on Production Errors

Source: https://dozzle.dev/guide/alerts-and-webhooks

Monitor production containers for error-level log messages.

```text
Container: labels["env"] == "production"
Log:       level == "error"
```

--------------------------------

### Run Dozzle in Swarm Mode

Source: https://dozzle.dev/guide/getting-started

Deploy Dozzle across all nodes in a Swarm cluster using a stack file. This configuration sets the mode to 'swarm' and uses an overlay network.

```yaml
# Run with docker stack deploy -c dozzle-stack.yml <name>
services:
  dozzle:
    image: amir20/dozzle:latest
    environment:
      - DOZZLE_MODE=swarm
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    ports:
      - 8080:8080
    networks:
      - dozzle
    deploy:
      mode: global
networks:
  dozzle:
    driver: overlay

```
Tokens:
Raw