Como Configurar Authelia + Caddy com Docker Compose

Authelia é um servidor de autenticação e autorização de código aberto que fornece autenticação de múltiplos fatores e login único (SSO) para seus aplicativos por meio de um portal web. Ele atua como um complemento para proxies reversos comuns.

Ele é leve, rápido e seguro. Também suporta vários métodos de segundo fator, regulação de login, redefinição de senha e políticas de autorização.

Índice

Introdução

Neste guia, você será orientado sobre como instalar o Authelia usando docker. Além disso, utilizaremos o Caddy como proxy reverso para a geração de certificados. Por fim, testaremos a proteção em uma aplicação.

Esta será uma configuração básica, voltada para homelabbing, com certificados gerados automaticamente pelo Caddy. Além disso, contará com métodos de autenticação de dois fatores e Single Sign-On (SSO).

Pré-requisitos

Antes de começar, certifique-se de que você tem o Docker e o Docker Compose instalados em seu sistema. Se não, você pode seguir este guia de instalação do Docker

Um Nome de Domínio (ex: seudominio.com).

Encaminhamento de porta (port forwarding) nas portas 80 e 443 no seu roteador.

Configuração do Authelia

Abaixo segue os arquivos e diretorios que serao usados pelo container

/mnt
└── docker
         └── authelia
                  └── config
                           ├── configuration.yml
                           └── users_database.yml
                           └── db.sqlite

Para criar os diretórios e o arquivo do banco de dados, você pode usar o seguinte comando:

sudo mkdir -p /mnt/docker/authelia
sudo mkdir -p /mnt/docker/authelia/config
sudo touch /mnt/docker/authelia/config/db.sqlite3

Criando o arquivo users_database.yml

caminho

/mnt
└── docker
         └── authelia
                  └── config
                           └── users_database.yml

sudo nano /mnt/docker/authelia/config/users_database.yml

users_database.yml

---
###############################################################
#                         Users Database                      #
###############################################################

# This file can be used if you do not have an LDAP set up.

# List of users
users:
  authelia:
    disabled: false
    displayname: "Authelia User"
    password: seu argo2 hash
    email: [email protected]
    groups:
      - admins
      - dev

Este arquivo é onde seu nome de usuário será armazenado. Ele está configurado para o nome de usuário “authelia”, e você precisará criar uma senha para ele. Você pode utilizar uma ferramenta online para gerar um hash de senha de forma segura no site Argon2 Hash Generator

Após a criação substitua no arquivo onde esta escrito “seu argo2 hash”

Criando o arquivo configuration.yml

caminho do arquivo

/mnt
└── docker
         └── authelia
                  └── config
                           └── configuration.yml

sudo nano /mnt/docker/authelia/config/configuration.yml

configuration.yml


---
theme: dark
jwt_secret: sua_string_aqui
default_redirection_url: https://seusite.com
default_2fa_method: ""
server:
  host: 0.0.0.0
  port: 9091
  path: ""
  enable_pprof: false
  enable_expvars: false
  disable_healthcheck: false
log:
  level: debug
telemetry:
  metrics:
    enabled: false
    address: tcp://0.0.0.0:9959
totp:
  disable: false
  issuer: authelia.com
  algorithm: sha1
  digits: 6
  period: 30
  skew: 1
  secret_size: 32
webauthn:
  disable: false
  timeout: 60s
  display_name: Authelia
  attestation_conveyance_preference: indirect
  user_verification: preferred
ntp:
  address: time.cloudflare.com:123
  version: 4
  max_desync: 3s
  disable_startup_check: false
  disable_failure: false
authentication_backend:
  password_reset:
    disable: false
    custom_url: ""
  refresh_interval: 5m
  file:
    path: /config/users_database.yml
    watch: false
    search:
      email: false
      case_insensitive: false
    password:
      algorithm: argon2
      argon2:
        variant: argon2id
        iterations: 3
        memory: 65536
        parallelism: 4
        key_length: 32
        salt_length: 16
password_policy:
  standard:
    enabled: false
    min_length: 8
    max_length: 0
    require_uppercase: true
    require_lowercase: true
    require_number: true
    require_special: true
  zxcvbn:
    enabled: false
    min_score: 3
access_control:
  default_policy: one_factor
  rules:
    - domain: seudominio.com
      policy: bypass
    - domain: whoami.seudominio.com
      policy: one_factor
    - domain: teste.seudominio.com
      policy: one_factor
session:
  name: authelia_session
  domain: seudominio.com
  same_site: lax
  secret: seu_secret_aqui
  expiration: 1h
  inactivity: 5m
  remember_me_duration: 1M
regulation:
  max_retries: 3
  find_time: 2m
  ban_time: 5m
storage:
  encryption_key: seu_secret_storage_key_aqui
  local:
    path: /config/db.sqlite3
notifier:
  disable_startup_check: false
  filesystem:
    filename: /config/notification.txt

Vamos precisar fazer algumas alterações nesse arquivo.

jwt_secret

Precisamos gerar uma string alfanumérica aleatória para o jwt secret.

use o comando abaixo para gerar

openssl rand -hex 64

copie e cole a string gerado no campo jwt_secret

default_redirection_url

Insira um site para o qual deseja fazer redirecionamentos ex: google.com meusite.com etc.

access_control:

O parâmetro default_policy no arquivo de configuração do Authelia Docker define a política aplicada se nenhuma regra se aplicar às informações conhecidas sobre a solicitação. Aqui estão as opções que você pode usar para este parâmetro:

deny: Esta é a política recomendada para ser configurada por razões de segurança. Sites que você não deseja proteger com o Authelia não devem ser configurados em seu proxy reverso para realizar autenticação com o Authelia.
bypass: Authelia não exigirá autenticação.
one_factor: Apenas um usuário/senha é necessário.
two_factor: (padrão) Nome de usuário/senha, bem como um segundo fator, são necessários.

Altere no arquivo conforme o tipo de aplicacao voce quer proteger e qual metodo

Exemplo:

rules:
– domain: whoami.seudominio.com
policy: two_factor

NOTA: No exemplo acima, a aplicação localizada em whoami.seudominio.com estaria sendo protegida utilizando a política de segurança de autenticação de dois fatores.

session

Na parte session você deve adicionar o nome do seu domínio em domain

NOTA: O autenticador também deve estar nesse domínio.

Mais abaixo em secret adicione uma string alfanumérica aleatória que pode ser criada com o comando:

openssl rand -hex 64

storage

Em storage você deve adicionar também uma string alfanumérica aleatória.

Essas seriam as configurações básicas para o funcionamento do authelia mais informações sobre a configurações de arquivo podem ser encontradas em Authelia Files

Configuração do Caddy

Frequentemente considerado um dos proxies reversos mais fáceis de configurar, sendo amplamente utilizado em ambientes de homelabing devido à sua simplicidade. No entanto, para ambientes de produção, existem opções mais robustas disponíveis como o Traefik.

caminho do diretórios

/mnt
└── docker
         └── caddy

sudo mkdir -p /mnt/docker/caddy

Criando o Arquivo de Configuração do Caddy

O Caddy utiliza um arquivo de configuração denominado Caddyfile. Este arquivo armazena todas as configurações necessárias para o funcionamento do Caddy.

caminho do arquivo

/mnt
└── docker
         └── caddy
                  └── Caddyfile


sudo nano /mnt/docker/caddy/Caddyfile

Caddyfile

{
    # Global options block. Entirely optional, https is on by default
    # Optional email key for lets encrypt
    email [email protected] 
    # Optional staging lets encrypt for testing. Comment out for production.
    #acme_ca https://acme-staging-v02.api.letsencrypt.org/directory
}

(trusted_proxy_list) {

       trusted_proxies 10.0.0.0/8 172.16.0.0/16 192.168.0.0/16 fc00::/7
}

# Authelia Portal.
authelia.seudominio.com {
        reverse_proxy authelia:9091 {
                
                import trusted_proxy_list
        }
}

# Endpoint Protegido.
whoami.seudominio.com {
        forward_auth authelia:9091 {
                uri /api/verify?rd=https://authelia.seudominio.com/
                copy_headers Remote-User Remote-Groups Remote-Name Remote-Email

                
                import trusted_proxy_list
        }
        reverse_proxy whoami:80 {
                
                import trusted_proxy_list
        }
}

O primeiro campo, email, será o e-mail associado ao certificado Let’s Encrypt que será gerado. Caso seja necessário renová-lo no futuro, você utilizará o e-mail informado aqui.

Neste arquivo de configuração é criado uma lista de endereços locais, denominada trusted_proxy_list, que são considerados confiáveis.

No bloco abaixo ele configura o domínio authelia.dominio.com para ser um proxy reverso para authelia:9091

INFO: Observe que ele utiliza o nome do contêiner Docker, Authelia, e a porta padrão do serviço, que é 9091.

No próximo bloco, whoami.seudominio.com é configurado para utilizar a autenticação avançada (forward auth) com authelia:9091 e para atuar como um proxy reverso para whoami:80.

O whoami será utilizado como um exemplo prático de como proteger uma aplicação utilizando o Authelia.

INFO: Whoami é uma pequena aplicação web que imprime informações sobre a solicitação HTTP recebida. É útil para depuração e teste de configurações de rede e proxy, pois permite ver exatamente o que o servidor está recebendo.

ATENÇÃO: É crucial lembrar de substituir “seudominio.com” pelo nome real do seu domínio ao seguir as instruções ou exemplos. Isso assegura que as configurações sejam aplicadas corretamente ao seu domínio específico.

Criando o Arquivo Docker Compose

caminho dos arquivos

/mnt
└── docker
         └── docker-compose.yaml

Crie o arquivo abaixo:

sudo nano /mnt/docker/docker-compose.yaml

docker-compose.yaml

---
version: "3.7"
networks:
  proxy:
    external: false
  app-network:
    external: false
services:
  caddy:
    image: caddy:latest
    restart: unless-stopped
    ports:
      - 80:80
      - 443:443
    volumes:
      - ./caddy/Caddyfile:/etc/caddy/Caddyfile
    networks:
      - proxy
      - app-network
  authelia:
    image: authelia/authelia
    restart: unless-stopped
    volumes:
      - ./authelia/config:/config
    networks:
      - app-network
      - proxy

após a criação do arquivo suba o serviço com o comando


cd /mnt/docker/ && sudo docker compose up -d

Configuração do DNS

Primeiramente, você precisará configurar uma entrada A em seu DNS para apontar para o seu servidor. Por exemplo, você pode criar uma entrada A para authelia.meudominio.com e outra para whoami.meudominio.com que aponta para o endereço IP do seu servidor.

Caso voce já tenha feito isso siga para o proximo passo caso contrario siga os passos abaixo para configuração usando o Cloudflare.(Você precisa estar utilizando o Cloudflare como seus servidores de nomes (Name servers))

Configurar DNS Cloudflare

Depois de apontar seu domínio para o Cloudflare, você pode adicionar as entradas A para os subdomínios authelia.dominio.com e whoami.dominio.com:
Dentro do site da cloudflare cloudflare.com
Faça Login na sua conta
Vá a guia de configurações DNS.
Clique em “Adicionar registro”.
Escolha o tipo de registro como A.
No campo “Nome”, insira o subdomínio que você deseja mapear (por exemplo, “authelia” ou “whoami”).
No campo “IPv4”, insira “1.1.1.1” (mude para seu ip real).
Clique em “Salvar”.
Repita os passos 2 a 6 para o segundo subdomínio.

Por favor, note que o IP “1.1.1.1” é apenas um exemplo. Você deve substituí-lo pelo IP real para o qual você deseja apontar o registro A. Além disso, você deve substituir “dominio.com” pelo seu domínio real e os nameservers fornecidos pelo Cloudflare pelos nameservers reais fornecidos para o seu domínio.
Durante os testes iniciais, certifique-se de desmarcar a opção “Proxied” e deixá-la em cinza.

Acessando o Authelia

Para acessar o Authelia, abra o endereço do subdomínio criado no seu navegador:

ex : https://authelia.seudominio.com

Ao fazer isso, você deverá ver uma tela de login semelhante à ilustrada abaixo.

Insira o nome de usuário e a senha que você criou anteriormente, os quais estão armazenados no arquivo users_database.yml.

Após a autenticação, você será redirecionado para o endereço especificado no arquivo configuration.yml.

Protegendo uma Aplicação

Vamos utilizar a aplicação “whoami” como um caso de teste para a proteção do Authelia.

caminhos:

/mnt
└── docker
         └── whoami
                  └── docker-compose.yaml

sudo mkdir -p /mnt/docker/whoami

crie o arquivo docker-compose.yaml

sudo nano /mnt/docker/whoami/docker-compose.yaml

version: '3'
services:
  whoami:
    image: containous/whoami
    networks:
      - docker_proxy
networks:
  docker_proxy:
    external: true

NOTA: Se você tem seguido o tutorial, deve existir uma rede chamada docker_proxy. No entanto, se você já criou suas próprias redes, faça a substituição correspondente no arquivo docker-compose. É importante lembrar que o aplicativo deve estar na mesma rede que o caddy

suba o serviço utilizando o comando

cd /mnt/docker/whoami && sudo docker compose up -d

abra o arquivo de configuração do Authelia

sudo nano /mnt/docker/authelia/config/configuration.yaml

Vá ate a sessão access_control rules:

No campo domain, insira o subdomínio que você usou para o “whoami”. Em seguida, na opção policy, selecione “one_factor”. Isso irá configurar a política de autenticação para o seu subdomínio.

Neste exemplo, estamos utilizando a política de autenticação “one_factor”. Caso você queira utilizar a autenticação de dois fatores, altere a opção para “two_factor”. Após realizar o login, selecione a opção “Outros métodos”.

Finalmente, inicie uma sessão anônima no seu navegador e visite https://whoami.seudominio.com. Você será recebido por uma tela de login do Authelia. Uma vez que você se autentique com sucesso, terá acesso à aplicação.

Conclusão

Entre os vários portais de autenticação disponíveis, como Keycloak e Authentik, o Authelia se destaca pela facilidade de configuração e economia de recursos. Normalmente, ele ocupa apenas cerca de 30 megabytes de memória RAM, tornando-se uma opção eficiente. Quando combinado com o proxy Caddy, que é conhecido por sua segurança e facilidade de uso, o Authelia pode ser uma excelente opção para homelabbing.