Authelia 2FA no Nginx: Guia de Instalação e Configuração

Introdução à Segurança de Acesso com Authelia

A segurança de aplicações web e serviços internos não se resume apenas à proteção da periferia da rede. Em um cenário moderno de infraestrutura, onde muitas vezes expomos serviços através de proxies reversos como o Nginx, a autenticação robusta é crítica. O Authelia surge como uma solução poderosa, open-source e self-hosted, atuando como um gateway de autenticação centralizado. Ele fornece Two-Factor Authentication (2FA) e login multifator para proteger seus aplicativos contra acessos não autorizados.

Diferente de soluções proprietárias que exigem licenças caras ou dependência de nuvem externa, o Authelia permite que você mantenha o controle total sobre seus dados e segredos. Este tutorial guia você através da instalação e configuração do install authelia nginx, utilizando Docker Compose para facilitar a gestão e escalabilidade. Ao final, você terá implementado uma camada de vps security tutorial essencial, garantindo que apenas usuários legítimos com credenciais válidas e tokens MFA possam acessar seus serviços protegidos.

Pré-requisitos e Arquitetura do Sistema

Antes de prosseguir com a instalação, é fundamental entender os componentes que interagirão neste ambiente. Para este tutorial, utilizaremos uma stack baseada em contêineres Docker, o que isola as dependências e facilita a manutenção. A arquitetura proposta envolve três pilares principais:

• Authelia: O servidor de autenticação que gerencia usuários, políticas de acesso e geração de tokens MFA.
• Nginx (Reverse Proxy): Atua como a porta de entrada para o tráfego HTTP/HTTPS. Ele interceptará as requisições, redirecionando-as para o Authelia quando necessário e injetando cabeçalhos de autenticação nos backends.
• Aplicação Backend: Seu serviço protegido (por exemplo, um painel de controle, GitLab, ou API interna) que receberá as requisições já autenticadas.

Você precisará ter o Docker e o Docker Compose instalados em seu servidor Linux. Além disso, é recomendável ter um domínio configurado apontando para o IP do seu servidor, pois o Authelia depende de URLs estáveis para a geração de links de recuperação de senha e notificações.

Passo 1: Preparação do Ambiente Docker

A primeira etapa consiste em criar a estrutura de diretórios e os arquivos de configuração necessários. Vamos organizar tudo em um diretório dedicado, por exemplo, /opt/authelia. Isso facilita o backup e a migração futura.

sudo mkdir -p /opt/authelia/config
cd /opt/authelia

Agora, criaremos o arquivo principal docker-compose.yml. Este arquivo definirá os serviços que compõem sua infraestrutura de segurança. Abaixo está a configuração inicial básica para subir o Authelia e um Nginx simples para testes.

version: '3'
services:
  authelia:
    image: authelia/authelia:latest
    container_name: authelia
    restart: unless-stopped
    ports:
      - "9091:9091"
    volumes:
      - ./config:/config
    networks:
      - web

  nginx:
    image: nginx:alpine
    container_name: nginx-proxy
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/conf.d:/etc/nginx/conf.d
    depends_on:
      - authelia
    networks:
      - web

networks:
  web:
    driver: bridge

Nesta configuração, o Authelia escuta na porta 9091 internamente. O Nginx atua como o proxy reverso exposto nas portas padrão 80 e 443. Ambos compartilham uma rede Docker chamada web, permitindo comunicação interna segura.

Passo 2: Configuração do Authelia

O coração do sistema reside no arquivo de configuração do Authelia, localizado em /opt/authelia/config/configuration.yml. Este arquivo define as regras de acesso, o método de armazenamento de usuários e os provedores de autenticação.

Crie o arquivo e adicione a seguinte estrutura base. Note que utilizaremos o banco de dados SQLite para simplificar o setup inicial, mas em produção recomenda-se PostgreSQL ou MySQL.

theme: dark
log:
  level: info
two_factor:
  authelia_url: https://auth.seudominio.com
totp:
  issuer: Authelia
authentication_backend:
  file:
    path: /config/users.yml
access_control:
  default_policy: deny_one_factor
  rules:
    - domain: "*.seudominio.com"
      policy: one_factor
session:
  name: authelia_session
  secret: UM_SEGREDO_MUITO_LONGO_E_SEGURO_PARA_PRODUCAO_1234567890
  expiration: 3600
  inactivity: 3600
  remember_me_duration: 30d
regulation:
  max_retries: 3
  find_time: 120
  ban_time: 300
storage:
  encryption_key: OUTRO_SEGREDO_MUITO_LONGO_E_SEGURO_1234567890
  local:
    path: /config/db.sqlite
notifier:
  filesystem:
    filename: /config/notifier.txt

É crucial entender os campos chave aqui:

• default_policy: deny_one_factor: Isso significa que, por padrão, todas as requisições exigirão autenticação. Se o usuário não estiver logado, será redirecionado para o Authelia.
• access_control rules: Permite granularidade. No exemplo acima, definimos que subdomínios de seudominio.com requerem apenas um fator (senha), enquanto outras rotas podem exigir dois fatores dependendo da regra específica.
• session secret e storage encryption key: Estes valores devem ser gerados aleatoriamente para garantir a integridade das sessões e dados sensíveis. Nunca use os exemplos acima em produção.

Passo 3: Definição de Usuários e Senhas

O Authelia utiliza um arquivo YAML simples para gerenciar usuários na configuração inicial. Crie o arquivo /opt/authelia/config/users.yml.

users:
  admin:
    display_name: Administrador
    password: "SENHA_FORTE_HASH_AQUI" # Use a ferramenta abaixo para gerar
    groups:
      - admins
  user1:
    display_name: Usuário Comum
    password: "OUTRA_SENHA_FORTE"
    groups:
      - users

Importante: Não escreva senhas em texto puro. O Authelia exige hashes criptografados. Você pode gerar o hash executando um comando no container do Authelia ou usando ferramentas online compatíveis com bcrypt/argon2. Para testar localmente, você pode usar o seguinte comando docker:

docker run --rm authelia/authelia authelia hash-password "SuaSenhaSegura123!"

Copie a saída (que começa com $argon2id$...) e substitua o valor no arquivo users.yml.

Passo 4: Configuração do Nginx como Proxy Reverso

Agora, configuramos o Nginx para integrar-se ao Authelia. O Nginx precisa saber quando enviar a requisição para o Authelia e como passar as informações de autenticação para o backend.

Crie o diretório /opt/authelia/nginx/conf.d e crie o arquivo authelia.conf.

server {
    listen 80;
    server_name seu.domínio.com www.seu.dominio.com;

    # Rotas públicas que não requerem autenticação (ex: login, recuperação)
    location /api/verify/account/compromise {
        proxy_pass http://authelia:9091;
    }

    location /api/verify {
        proxy_pass http://authelia:9091;
    }

    # Rota do próprio Authelia
    location / {
        auth_request /authelia-check-auth;
        error_page 401 =200 /login.html;
        
        location = /login.html {
            internal;
            proxy_pass http://authelia:9091;
        }

        location = /public/ {
            proxy_pass http://authelia:9091;
        }
    }

    # Endpoint de verificação de autenticação (Interno)
    location = /authelia-check-auth {
        internal;
        proxy_pass http://authelia:9091/api/verify?rd=$scheme://$host$request_uri;
        proxy_pass_request_body off;
        proxy_set_header Content-Length "";
        
        # Cabeçalhos essenciais para o Authelia entender o contexto
        proxy_set_header X-Forwarded-Host $http_host;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Authorization "";
    }
}

Esta configuração é complexa, mas fundamental. O bloco auth_request faz uma chamada silenciosa ao Authelia para verificar se o usuário está autenticado. Se não estiver, o Nginx retorna um redirect ou exibe a tela de login.

Passo 5: Implementação do MFA (Two-Factor Authentication)

Para habilitar o authelia 2fa servidor, precisamos configurar o provedor TOTP (Time-based One-Time Password). No arquivo configuration.yml que criamos anteriormente, a seção two_factor já está presente. No entanto, para produção, é altamente recomendável usar um serviço de e-mail real para enviar links de recuperação, caso o usuário perca acesso ao aplicativo autenticador.

Edite configuration.yml para adicionar as configurações do SMTP (exemplo usando Gmail ou SendGrid):

notifier:
  smtp:
    host: smtp.gmail.com
    port: 587
    username: [email protected]
    password: SENHA_DO_APP_DO_GMAIL
    sender: [email protected]

Com isso, quando um usuário fizer login pela primeira vez em um novo dispositivo, o Authelia solicitará a configuração do QR Code para leitura pelo Google Authenticator ou Authy. Se ele perder o acesso, poderá recuperar via e-mail.

Passo 6: Inicialização e Verificação

Com todos os arquivos configurados, inicie os contêineres:

docker-compose up -d

Aguarde alguns segundos e verifique se os serviços estão rodando corretamente:

docker-compose ps

Acesse http://seudominio.com. Você deve ser redirecionado para a tela de login do Authelia. Insira o usuário admin e a senha configurada.

No primeiro login, o sistema detectará que é um novo dispositivo e solicitará a configuração do MFA. Escaneie o QR Code com seu aplicativo autenticador móvel e insira o código gerado.

Otimizações de Segurança para Produção

Agora que o self-hosted auth está funcionando, há várias etapas críticas para garantir a proteção robusta do servidor.

1. Habilitar HTTPS com Let's Encrypt

Nunca expose o Authelia ou seu proxy via HTTP puro em produção. Utilize o Nginx Proxy Manager ou configure certificados TLS manualmente usando Certbot ou Traefik. A configuração de redirecionamento forçado de HTTP para HTTPS deve ser feita no bloco server do Nginx.

2. Isolamento de Rede

No seu docker-compose.yml, defina redes explícitas. O Authelia não deve estar acessível diretamente da internet, apenas através do Nginx. Isso previne ataques diretos à porta 9091.

3. Atualizações Regulares

Mantenha suas imagens Docker atualizadas. Execute docker-compose pull && docker-compose up -d periodicamente para aplicar patches de segurança do Authelia e do Nginx.

4. Políticas de Acesso Granulares

No arquivo configuration.yml, refine as regras de access_control. Você pode definir que grupos específicos, como admins, devam passar por verificação de dois fatores em todas as requisições (policy: two_factor), enquanto usuários comuns podem ter acesso com apenas senha (policy: one_factor) para rotas não sensíveis.

access_control:
  default_policy: deny_one_factor
  rules:
    - domain: "app.seudominio.com"
      policy: two_factor
      subjects:
        - group:admins
    - domain: "blog.seudominio.com"
      policy: one_factor

Conclusão

A implementação do Authelia com Nginx representa um salto significativo na maturidade de segurança da sua infraestrutura. Ao adotar este modelo de vps security tutorial, você centraliza a gestão de identidades, elimina a necessidade de expor painéis de administração sem proteção e oferece uma experiência de login segura aos usuários finais.

Lembre-se que a segurança é um processo contínuo. Monitore os logs do Authelia em /config/authelia.log para detectar tentativas de login falhas e ajustes finos nas suas políticas. Com esta configuração, seu servidor está muito mais resiliente contra ataques de força bruta e acessos não autorizados, alinhando-se às melhores práticas de web app security contemporâneas.

Para expandir sua stack, considere integrar o Authelia com outros provedores de identidade (OIDC/SAML) ou conectar ao backend de usuários via LDAP/Active Directory conforme sua organização cresce. O Authelia é escalável e flexível para atender desde projetos pessoais até ambientes corporativos complexos.