Authelia 2FA no Servidor: Proteção Avançada para Nginx

Introdução à Segurança Zero Trust com Authelia

No cenário atual de infraestrutura de TI, a perímetro de segurança tradicional (castle-and-moat) tornou-se insuficiente. Com o aumento do trabalho remoto e a migração para serviços em nuvem, a necessidade de autenticação forte deixou de ser um diferencial para tornar-se uma exigência fundamental. O Authelia surge como a solução definitiva para quem busca implementar um servidor de autenticação centralizado, seguindo os princípios de Zero Trust.

Este tutorial explica como configurar o authelia 2fa servidor integrado ao Nginx em um ambiente Linux. Ao final deste guia, você terá implementado uma camada robusta de mfa linux (Multi-Factor Authentication) que protege seus serviços internos contra acessos não autorizados, garantindo que apenas usuários verificados possam acessar aplicações expostas via nginx reverse proxy.

Pré-requisitos e Visão Geral da Arquitetura

Para executar este tutorial authelia, você precisará de um ambiente Linux (Ubuntu, Debian ou CentOS) já configurado com Docker e Docker Compose. A arquitetura proposta utiliza contêineres isolados para garantir a modularidade e facilidade de manutenção, características essenciais para uma estratégia eficaz de vps segurança.

A estrutura dos serviços será a seguinte:

• Nginx (Reverse Proxy): Gerencia o tráfego HTTPS e encaminha requisições não autenticadas para o Authelia.
• Authelia: Servidor de autenticação que valida credenciais, gera tokens JWT e gerena políticas de acesso.
• PostgreSQL: Banco de dados persistente para armazenar usuários, grupos e configurações do Authelia.

Não utilizaremos banco de dados SQLite para ambientes de produção, pois o PostgreSQL oferece melhor concorrência e integridade de dados. Vamos começar instalando as dependências básicas.

Passo 1: Preparação do Ambiente Linux

O primeiro passo é garantir que seu sistema operacional esteja atualizado e com os utilitários necessários instalados. Isso evita problemas de compatibilidade durante a instalação dos contêineres.

sudo apt update && sudo apt upgrade -y
sudo apt install -y curl git docker.io docker-compose-plugin

Após instalar o Docker, verifique se os serviços estão ativos e configurados para iniciar automaticamente com o sistema:

sudo systemctl enable --now docker

Crie um diretório dedicado para a configuração do seu projeto de self-hosted security. Isso mantém seu sistema organizado e facilita backups futuros.

mkdir -p ~/authelia-project/{config,secrets}
cd ~/authelia-project

Passo 2: Configuração do Banco de Dados PostgreSQL

O Authelia requer um banco de dados relacional. Vamos criar uma rede Docker isolada para garantir que apenas os contêineres autorizados possam se comunicar entre si, aumentando a segurança da sua infraestrutura.

docker network create authelia-net

Agora, inicie o contêiner do PostgreSQL. Definiremos variáveis de ambiente seguras para o usuário e senha do banco:

docker run -d \
  --name postgres-authelia \
  --network authelia-net \
  -e POSTGRES_USER=authelia \
  -e POSTGRES_PASSWORD=SuaSenhaForteAqui123! \
  -e POSTGRES_DB=authelia_db \
  -v pg-data:/var/lib/postgresql/data \
  postgres:15-alpine

Nota de segurança: Em produção, nunca armazene senhas em texto puro nas variáveis de ambiente do Docker. Utilize segredos gerenciados ou arquivos .env protegidos.

Passo 3: Estruturação dos Arquivos de Configuração

O coração do sistema é o arquivo configuration.yml. Este arquivo define as regras de acesso, os métodos de autenticação suportados e a conexão com o banco de dados.

Crie o arquivo config/configuration.yml e insira a seguinte configuração base:

server:
  host: 0.0.0.0
  port: 9091

log:
  level: info
  format: json

theme: dark

# Conexão com o Banco de Dados
authentication_backend:
  file:
    path: /config/users.yml
    watch: true

access_control:
  default_policy: deny_one_factor
  rules:
    # Regra para permitir acesso ao próprio Authelia sem MFA (apenas login)
    - domain: authelia.seudominio.com
      policy: bypass
    
    # Regra para proteger seus serviços internos
    - domain: "*.seudominio.com"
      policy: one_factor

session:
  name: authelia_session
  secret: UmSegredoAleatorioMuitoLongoEComplexoAqui123!
  expiration: 3600 # 1 hora
  inactivity: 600 # 10 minutos
  redis:
    host: redis-server
    port: 6379

regulation:
  max_retries: 3
  find_time: 120
  ban_time: 300

storage:
  postgres:
    host: postgres-authelia
    port: 5432
    database: authelia_db
    username: authelia
    password: SuaSenhaForteAqui123!
    timeout: 5s

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

Observe a diretiva access_control. O padrão deny_one_factor exige autenticação forte (senha + MFA) para acessar os recursos protegidos. A regra de domínio específica para o Authelia usa bypass, pois não podemos pedir MFA para logar no próprio sistema de MFA.

Passo 4: Definição dos Usuários e Credenciais

Crie o arquivo config/users.yml na raiz do projeto. Este arquivo YAML define os usuários que terão acesso ao sistema. Para este exemplo, criaremos um usuário administrador e um usuário padrão.

users:
  admin:
    display_name: "Administrador"
    email: "admin@seudominio.com"
    groups:
      - admins
    password: "$argon2id$v=19$m=65536,t=3,p=4$..." # Hash gerado via authelia hash-password
  
  usuario_comum:
    display_name: "Usuário Teste"
    email: "user@seudominio.com"
    groups: []
    password: "$argon2id$v=19$m=65536,t=3,p=4$..." # Hash gerado via authelia hash-password

Importante: Não use senhas em texto claro. Use a ferramenta de linha de comando do Authelia para gerar hashes seguros:

docker run --rm authelia/authelia:latest authelia hash-password "SuaSenhaSegura"

Cole o hash resultante no campo password correspondente. O algoritmo Argon2id é utilizado por ser resistente a ataques de força bruta e hardware especializado.

Passo 5: Configuração do Nginx como Reverse Proxy

O Nginx atuará como a porta de entrada, interceptando requisições e verificando se o usuário está autenticado. Se não estiver, ele redireciona para o Authelia.

Crie o arquivo config/nginx.conf:

upstream authelia {
    server authelia:9091;
}

server {
    listen 80;
    server_name seu*.seudominio.com authelia.seudominio.com;

    # Redirecionar todo o tráfego para HTTPS
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    server_name seu*.seudominio.com authelia.seudominio.com;

    ssl_certificate /etc/ssl/certs/seu_cert.pem;
    ssl_certificate_key /etc/ssl/private/seu_key.pem;

    # Cabeçalhos de segurança
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-XSS-Protection "1; mode=block" always;

    location / {
        # Verificar sessão
        include authelia-location.conf;
    }

    location /authelia/ {
        # Permitir acesso ao Authelia sem redirecionamento infinito
        proxy_pass http://authelia;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Agora, crie o arquivo config/authelia-location.conf que contém a lógica de verificação:

# Se não houver sessão, redirecionar para Authelia
auth_request /authelia/check;

error_page 401 =302 https://authelia.seudominio.com/?rd=$scheme://$host$request_uri;

location = /authelia/check {
    internal;
    proxy_pass http://authelia:9091/api/verify?rd=$scheme://$host$request_uri&next=$scheme://$host$request_uri;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-Host $http_host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
}

Passo 6: Orquestração com Docker Compose

Para facilitar a gestão, utilizaremos o docker-compose.yml. Este arquivo define os serviços Authelia e Nginx, conectando-os à rede criada anteriormente.

version: '3.8'

services:
  authelia:
    image: authelia/authelia:latest
    container_name: authelia
    restart: unless-stopped
    networks:
      - authelia-net
    volumes:
      - ./config:/config
    environment:
      - TZ=America/Sao_Paulo

  nginx:
    image: nginx:alpine
    container_name: nginx-proxy
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./config/nginx.conf:/etc/nginx/nginx.conf
      - ./config/authelia-location.conf:/etc/nginx/authelia-location.conf
      - /etc/letsencrypt:/etc/ssl/certs # Se usar Certbot
    depends_on:
      - authelia
    networks:
      - authelia-net

networks:
  authelia-net:
    external: true

Passo 7: Implementação do Two Factor Authentication (TOTP)

Agora que a infraestrutura está pronta, vamos habilitar o two factor authentication. O Authelia suporta TOTP (Time-based One-Time Password), compatível com aplicativos como Google Authenticator, Authy ou Microsoft Authenticator.

Inicie os serviços:

docker-compose up -d

Acesse https://authelia.seudominio.com no seu navegador. Faça login com as credenciais definidas em users.yml.

Após o primeiro login, o sistema detectará que você ainda não possui um método MFA configurado e exibirá uma tela solicitando a configuração do TOTP.

1. Abra seu aplicativo de autenticação móvel.
2. Escaneie o QR Code exibido na tela do navegador.
3. Insira o código numérico de 6 dígitos gerado pelo app.

O Authelia validará o código e salvará a chave secreta criptografada no banco de dados. A partir deste momento, todas as tentativas de acesso aos seus serviços protegidos exigirão não apenas a senha, mas também o código TOTP atualizado a cada 30 segundos.

Passo 8: Testes e Validação da Segurança

Para confirmar que o authelia 2fa servidor está funcionando corretamente, realize os seguintes testes:

1. Acesso não autorizado: Tente acessar um serviço protegido (ex: app.seudominio.com) sem estar logado. Você deve ser redirecionado automaticamente para a página de login do Authelia.
2. Autenticação dupla: Após inserir a senha, o sistema deve solicitar o código TOTP. Insira um código inválido e verifique se o acesso é negado.
3. Sessão expirada: Aguarde o tempo de inatividade configurado (10 minutos no exemplo) e tente acessar novamente. O navegador deve pedir autenticação novamente.

Verifique os logs do contêiner Nginx para garantir que não há erros de configuração:

docker logs -f nginx-proxy

Melhores Práticas e Manutenção Contínua

A implementação bem-sucedida desta arquitetura exige disciplina na manutenção. Para garantir a longevidade e a eficácia da sua vps segurança, considere os seguintes pontos:

• Certificados SSL/TLS: Utilize o Let's Encrypt ou Certbot para automatizar a renovação dos certificados. Nunca exponha serviços HTTP sem HTTPS em produção.
• Backup de Configurações: Faça backups regulares do diretório config e do volume do PostgreSQL. A perda da chave secreta de sessão ou do banco de dados pode resultar em lockout permanente dos usuários.
• Monitoramento: Integre os logs do Authelia com ferramentas como Prometheus e Grafana para monitorar tentativas de login falhas, o que pode indicar ataques de força bruta.

A configuração de mfa linux via contêineres oferece flexibilidade. Se precisar migrar para outro servidor, basta transferir os arquivos de configuração e o banco de dados, reiniciar os contêineres e a segurança estará operacional novamente.

Conclusão

A implementação do Authelia representa um salto qualitativo na maturidade de segurança da sua infraestrutura. Ao combinar nginx reverse proxy com autenticação centralizada, você elimina a necessidade de gerenciar credenciais分散 em múltiplas aplicações. Este modelo de self-hosted security é escalável, econômico e altamente seguro.

Agora que você domina a instalação básica, explore personalizações avançadas, como integração com LDAP/Active Directory para grandes corporações ou uso de WebAuthn (chaves de segurança físicas) para níveis máximos de proteção. A segurança é um processo contínuo, e esta ferramenta coloca o controle em suas mãos.