Forward proxy

Dozzle se puede configurar para leer cabeceras de proxy poniendo --auth-provider en forward-proxy.

clidocker-compose.yml

$ docker run -v /var/run/docker.sock:/var/run/docker.sock -v /path/to/dozzle/data:/data -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
      - /path/to/dozzle/data:/data
    ports:
      - 8080:8080
    environment:
      DOZZLE_AUTH_PROVIDER: forward-proxy

Monta /data también aquí. Los ajustes por usuario se escriben en disco también en modo forward proxy, y sin el volumen se pierden cada vez que se recrea el contenedor.

En este modo, Dozzle espera las siguientes cabeceras:

Remote-User para el nombre de usuario, por ejemplo johndoe
Remote-Email para la dirección de correo del usuario. Ese correo también se usa para encontrar el Gravatar correcto.
Remote-Name para un nombre visible como John Doe
Remote-Filter para una lista de filtros permitidos al usuario, separados por comas.
Remote-Roles para una lista de roles permitidos al usuario, separados por comas.

Además, puedes configurar una URL de cierre de sesión con:

yaml

DOZZLE_AUTH_LOGOUT_URL: http://oauth2.example.ru/oauth2/sign_out

Configurar Dozzle con Authelia

Authelia es un servidor y portal de autenticación y autorización de código abierto que cubre la gestión de identidades y accesos. Configurar Authelia queda fuera del alcance de esta sección, pero la configuración se puede compartir como ejemplo para montar Dozzle con Authelia.

➡️ Haz clic para desplegar el ejemplo de Authelia

docker-compose.ymlconfiguration.yml

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/authz/forward-auth"
      - "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:v3.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
      - dozzle:/data
    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

volumes:
  dozzle:

yaml

###############################################################
#                   Authelia configuration                      #
###############################################################

server:
  address: tcp://0.0.0.0:9091

log:
  level: info

totp:
  issuer: authelia.com

identity_validation:
  reset_password:
    jwt_secret: a_very_important_secret

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
  cookies:
    - domain: example.com # Debe coincidir con el dominio raíz protegido que uses
      authelia_url: https://authelia.example.com
      default_redirection_url: https://public.example.com

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

Se necesitan claves SSL válidas porque Authelia solo funciona con SSL.

Authelia envía la pertenencia a grupos en Remote-Groups, y Dozzle no lee esa cabecera por defecto. Para asociar los grupos de Authelia con los roles de Dozzle, pon DOZZLE_AUTH_HEADER_ROLES: Remote-Groups en el servicio de Dozzle y nombra los grupos como los roles. Los alias con prefijo dozzle_ existen para esto, así que un grupo llamado dozzle_shell concede el rol shell y los demás nombres de grupo se ignoran. Sin esa asociación, todo usuario autenticado recibe todos los roles.

Configurar Dozzle con Cloudflare Zero Trust

Cloudflare Zero Trust es un servicio para dar acceso autenticado a software autoalojado. Esta sección explica cómo configurar Dozzle para usar Cloudflare Zero Trust como autenticación.

yaml

services:
  dozzle:
    image: amir20/dozzle:latest
    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
      - dozzle:/data
    expose:
      - 8080
    restart: unless-stopped

volumes:
  dozzle:

expose mantiene el puerto 8080 fuera del host, así que la única entrada es a través del túnel. Publicarlo con ports permitiría a cualquiera en el host poner la cabecera Cf-Access-Authenticated-User-Email por su cuenta y saltarse Cloudflare por completo.

Después de arrancar el contenedor de Dozzle, configura la aplicación en el panel de Cloudflare Zero Trust siguiendo esta guía.

Configurar Dozzle con Pocket ID

TIP

Dozzle ya habla OpenID Connect de forma nativa, así que puedes apuntar --auth-oidc-issuer directamente a Pocket ID y saltarte oauth2-proxy por completo. Consulta Iniciar sesión con GitHub y OIDC. La receta de abajo sigue aquí para quien ya use oauth2-proxy o quiera que el proxy proteja algo más que Dozzle.

Primero tienes que montar un contenedor que pase la autenticación OpenID Connect a través de tu proxy inverso.

Aquí tienes un ejemplo con oauth2-proxy.

➡️ Haz clic para desplegar el ejemplo de oauth2-proxy

Crea un nuevo cliente OIDC en Pocket ID para Dozzle:
- Nombre: Dozzle
- URLs de callback: https://dozzle.example.com/oauth2/callback
- PKCE: Enabled
Copia los valores de Client ID y Client Secret para usarlos después.
Añade lo siguiente al compose de Dozzle que ya tengas:
yml
```
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
```
Comenta los puertos de Dozzle, ya que los vamos a redirigir a través del nuevo contenedor de autenticación.
Este método no debería requerir cambios en la configuración de tu proxy inverso.
yml
```
# ports:
#   - 8080:8080
```

Añade un nuevo servicio de contenedor oauth2-proxy al compose de Dozzle:

yml

services:
  # ...
  oauth2-proxy:
    image: quay.io/oauth2-proxy/oauth2-proxy:latest
    restart: unless-stopped
    container_name: dozzle-oidc
    command: --config /oauth2-proxy.cfg
    volumes:
      - "./oauth2-proxy.cfg:/oauth2-proxy.cfg"
    ports:
      - 8080:4180

Crea el archivo de configuración de oauth2-proxy.

En el directorio donde está tu archivo compose, crea oauth2-proxy.cfg:

toml

 client_id = "xxx"                            # de Pocket ID
 client_secret = "xxx"                        # de Pocket ID
 cookie_secret = "xxx"                        # genéralo con openssl rand -base64 32 | tr -- '+/' '-_'
 upstreams = "http://dozzle:8080"             # upstream al puerto interno del contenedor de Dozzle
 code_challenge_method = "S256"               # desafíos PKCE plain o S256
 cookie_expire = "0"                          # segundos, 0 para sesión
 cookie_name = "__Host-oauth2-proxy"          # o __Secure-oauth2-proxy (menos seguro)
 cookie_secure = true                         # usa la cookie segura HTTPS
 email_domains = ["*"]                        # permite autenticarse desde cualquier dominio de correo
 http_address = "0.0.0.0:4180"                # puerto en el que escucha oauth2-proxy
 oidc_issuer_url = "https://id.example.com"   # tu URL base de Pocket
 provider_display_name = "Pocket ID"          # nombre visible para el inicio de sesión OIDC
 provider = "oidc"                            # usa OpenID connect
 reverse_proxy = true                         # pasa el tráfico por el proxy inverso
 scope = "openid email profile groups"        # deja pasar estos scopes OIDC

Rellena las variables según los comentarios.

Por último, reinicia tu stack de Docker compose.
Tu proxy inverso ya debería autenticarte en Dozzle a través de oauth2-proxy.
Revisa los logs para solucionar problemas.

Forward proxy ​

Configurar Dozzle con Authelia ​

Configurar Dozzle con Cloudflare Zero Trust ​

Configurar Dozzle con Pocket ID ​

Forward proxy

Configurar Dozzle con Authelia

Configurar Dozzle con Cloudflare Zero Trust

Configurar Dozzle con Pocket ID