TL;DR — Résumé Rapide

Déployez Authelia comme proxy SSO et 2FA. Couvre Docker Compose, Traefik, TOTP, WebAuthn, backends LDAP et configuration du fournisseur OpenID Connect.

Authelia est un portail d’authentification open-source fonctionnant comme companion forward-auth pour votre reverse proxy. Au lieu d’ajouter des formulaires de connexion à chaque service auto-hébergé, Authelia intercepte chaque requête, valide la session et applique les politiques 2FA depuis un portail unique. Ce guide couvre un déploiement complet en production avec Docker Compose, Traefik, TOTP et un fournisseur OpenID Connect.

Prérequis

  • Docker et Docker Compose v2 sur un hôte Linux.
  • Traefik v2/v3 configuré (ou Nginx/Caddy — notes d’intégration incluses).
  • Un domaine avec DNS pointant vers votre serveur (Authelia requiert un vrai domaine pour les cookies).
  • Connaissance de base de YAML et des réseaux de conteneurs.

Architecture d’Authelia

Le flux d’une requête est :

  1. Le navigateur demande app.exemple.com.
  2. Traefik intercepte et appelle l’endpoint ForwardAuth sur auth.exemple.com/api/authz/forward-auth.
  3. Authelia vérifie le cookie de session, applique les règles de contrôle d’accès et retourne 200 OK ou 401 Unauthorized.
  4. En cas de 401, Traefik redirige l’utilisateur vers le portail de connexion Authelia.
  5. L’utilisateur s’authentifie (mot de passe + 2FA), reçoit un cookie de session signé et est redirigé.

Composants clés :

  • Portail d’authentification — Interface de connexion servie sur le sous-domaine Authelia.
  • Stockage de sessions — Redis pour les déploiements distribués/HA ; en mémoire pour nœud unique.
  • Backend de stockage — SQLite (nœud unique) ou PostgreSQL/MySQL pour HA.
  • Moteur de politiques — Règles de contrôle d’accès évaluées de haut en bas.

Étape 1 : Stack Docker Compose

Créez /opt/authelia/docker-compose.yml :

version: "3.9"
networks:
  proxy:
    external: true

services:
  authelia:
    image: authelia/authelia:latest
    container_name: authelia
    restart: unless-stopped
    volumes:
      - ./config:/config
    environment:
      - AUTHELIA_JWT_SECRET_FILE=/config/secrets/jwt_secret
      - AUTHELIA_SESSION_SECRET_FILE=/config/secrets/session_secret
      - AUTHELIA_STORAGE_ENCRYPTION_KEY_FILE=/config/secrets/storage_key
    networks:
      - proxy
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.authelia.rule=Host(`auth.exemple.com`)"
      - "traefik.http.routers.authelia.entrypoints=websecure"
      - "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"

  redis:
    image: redis:7-alpine
    container_name: authelia-redis
    restart: unless-stopped
    networks:
      - proxy
    volumes:
      - redis-data:/data

volumes:
  redis-data:

Générez les secrets :

mkdir -p /opt/authelia/config/secrets
tr -dc 'A-Za-z0-9' </dev/urandom | head -c 64 > /opt/authelia/config/secrets/jwt_secret
tr -dc 'A-Za-z0-9' </dev/urandom | head -c 64 > /opt/authelia/config/secrets/session_secret
tr -dc 'A-Za-z0-9' </dev/urandom | head -c 64 > /opt/authelia/config/secrets/storage_key

Étape 2 : Configuration Principale

Créez /opt/authelia/config/configuration.yml :

server:
  host: 0.0.0.0
  port: 9091

log:
  level: info

totp:
  issuer: exemple.com
  period: 30
  skew: 1

authentication_backend:
  file:
    path: /config/users.yml
    password:
      algorithm: argon2id
      iterations: 3
      memory: 65536
      parallelism: 4

access_control:
  default_policy: deny
  rules:
    - domain: "auth.exemple.com"
      policy: bypass
    - domain: "*.exemple.com"
      subject: "group:admins"
      policy: two_factor
    - domain: "interne.exemple.com"
      networks:
        - 192.168.1.0/24
      policy: one_factor

session:
  name: authelia_session
  domain: exemple.com
  expiration: 1h
  inactivity: 5m
  remember_me: 1M
  redis:
    host: redis
    port: 6379

regulation:
  max_retries: 5
  find_time: 2m
  ban_time: 10m

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

notifier:
  smtp:
    host: smtp.exemple.com
    port: 587
    username: noreply@exemple.com
    password: votremotdepasse
    sender: "Authelia <noreply@exemple.com>"

Étape 3 : Backends d’Authentification

Basé sur Fichier (users.yml)

users:
  pierre:
    displayname: "Pierre Dupont"
    password: "$argon2id$v=19$m=65536,t=3,p=4$..."
    email: pierre@exemple.com
    groups:
      - admins
      - users

Générez les hachages argon2 :

docker run authelia/authelia:latest authelia crypto hash generate argon2 --password 'votremotdepasse'

Backend LDAP / Active Directory

authentication_backend:
  ldap:
    address: ldap://ldap.exemple.com:389
    implementation: activedirectory
    base_dn: dc=exemple,dc=com
    username_attribute: sAMAccountName
    users_filter: "(&({username_attribute}={input})(objectClass=person))"
    groups_filter: "(member={dn})"
    user: cn=authelia,ou=CompteService,dc=exemple,dc=com
    password: ldappassword

Étape 4 : Contrôle d’Accès

Les règles sont évaluées de haut en bas ; la première correspondance l’emporte.

ChampDescriptionExemple
domainDomaine(s) avec joker"*.exemple.com"
resourcesRegex de chemin URL["^/api/.*"]
subjectUtilisateur ou groupe"group:admins"
networksBlocs CIDR["10.0.0.0/8"]
policyActionone_factor, two_factor, bypass, deny

Étape 5 : Méthodes de Double Facteur

TOTP

Les utilisateurs s’inscrivent sur le portail Authelia. Compatible avec Google Authenticator, Authy et toute app TOTP.

WebAuthn / Passkeys FIDO2

Supporté dans tous les navigateurs modernes. Les utilisateurs enregistrent une clé matérielle (YubiKey) ou un authentificateur de plateforme (Face ID, Windows Hello).

Duo Push

duo_api:
  hostname: api-XXXXXXXX.duosecurity.com
  integration_key: DIXXXXXXXXXXXXXXXXXX
  secret_key: votre_secret_duo

Étape 6 : Fournisseur OpenID Connect

identity_providers:
  oidc:
    hmac_secret: un_secret_aleatoire_dau_moins_32_caracteres
    clients:
      - id: grafana
        secret: "$argon2id$v=19$..."
        authorization_policy: two_factor
        redirect_uris:
          - "https://grafana.exemple.com/login/generic_oauth"
        scopes:
          - openid
          - profile
          - email
          - groups
        pkce_challenge_method: S256

Authelia vs Alternatives

FonctionnalitéAutheliaAuthentikKeycloakVouch ProxyOAuth2 Proxy
2FA/MFATOTP, WebAuthn, DuoTOTP, WebAuthn, DuoTOTP, WebAuthnSelon IdPSelon IdP
Fournisseur OIDCOui (v4.34+)Oui (IdP complet)Oui (enterprise)NonNon
LDAP/ADOuiOuiOuiNonNon
RAM~50 Mo~300 Mo~512 Mo~10 Mo~10 Mo
ComplexitéFaible-MoyenneMoyenneÉlevéeFaibleFaible

Résolution de Problèmes

ProblèmeSolution
Boucle 401 après connexionVérifiez que session.domain correspond au domaine de cookie de tous les services protégés
Email d’inscription 2FA non reçuTestez SMTP avec startup_check_address ; vérifiez les logs du notifier
Échec d’enregistrement WebAuthnAssurez-vous que HTTPS est actif ; le RP ID doit correspondre exactement au domaine de session
Échec auth LDAPActivez log.level: debug ; vérifiez les identifiants du bind DN et base DN
Régulation bloquant des utilisateurs légitimesVérifiez regulation.find_time ; augmentez max_retries si des IPs partagées existent

Récapitulatif

  • Authelia est un proxy SSO + 2FA léger avec moteur de politiques intégré.
  • Le pattern forward-auth permet à tout reverse proxy d’appliquer l’authentification sans toucher aux apps en amont.
  • TOTP, WebAuthn et Duo offrent des options 2FA flexibles.
  • Le fournisseur OIDC permet à Authelia d’agir comme IdP complet pour les apps OAuth2.
  • La régulation fournit une protection brute-force native.

Articles Connexes