Authelia self-hosted : SSO + 2FA pour stack web — déploiement (2026)

Introduction

Imaginez la situation suivante : votre équipe tech à Dakar gère cinq applications internes — un Gitea, un Grafana, un Portainer, un wiki Outline et un panel d’administration maison. Chaque outil a son propre système de login. Les mots de passe se répètent, les comptes ne sont jamais désactivés quand un collaborateur part, et personne ne se souvient s’il faut taper son email ou son pseudo sur tel ou tel service. Ce scénario est la norme dans les PME tech d’Afrique de l’Ouest — et c’est précisément le problème qu’Authelia résout.

Authelia est un portail d’authentification open-source écrit en Go, conçu pour fonctionner comme un Forward Auth provider devant un reverse-proxy (Traefik, Nginx ou Caddy). Concrètement, c’est un service unique que vous déployez une seule fois, et qui prend en charge l’authentification de toutes vos applications — même celles qui n’ont pas nativement de système de login. Authelia intercepte chaque requête HTTP entrante via votre reverse-proxy, vérifie que l’utilisateur est authentifié, et si ce n’est pas le cas le redirige vers sa propre page de login avant de renvoyer le trafic vers l’application cible.

Ce qui distingue Authelia de solutions comme Keycloak ou Authentik, c’est sa légèreté remarquable : le binaire compilé en Go consomme environ 30 Mo de RAM au repos, et peut tourner confortablement sur un VPS à 256 Mo de RAM total. C’est un avantage décisif pour les PME qui hébergent sur de petits serveurs Hetzner CX22 ou équivalents. Authelia supporte nativement le SSO (Single Sign-On), le second facteur via TOTP (Google Authenticator, Aegis, 2FAS) ou WebAuthn/Passkeys, les politiques d’accès par domaine, et peut s’interfacer aussi bien avec un simple fichier d’utilisateurs qu’avec un annuaire LDAP complet.

Dans ce tutoriel, vous allez déployer Authelia de zéro, le connecter à Traefik, activer le 2FA TOTP, puis (optionnellement) brancher un annuaire LLDAP pour la gestion multi-utilisateurs. Comptez environ 30 à 45 minutes si vous connaissez déjà Docker et Traefik.

Prérequis

• Système : Linux (Ubuntu 22.04 LTS ou Debian 12 recommandé) avec accès root ou sudo
• Docker Engine 24+ et Docker Compose v2 installés (docs.docker.com)
• Traefik v3 déjà opérationnel avec un certificat TLS wildcard ou au moins un domaine configuré (ex. auth.votredomaine.com)
• Un domaine valide pointant vers votre serveur — Authelia refuse de fonctionner sur une IP nue ou en HTTP non-sécurisé en production
• Niveau : intermédiaire — vous savez lire un fichier Docker Compose et éditer du YAML
• Temps estimé : 30 à 45 minutes

Étape 1 — Architecture : comprendre ce qu’on déploie

Avant d’écrire la moindre ligne de configuration, il est essentiel de comprendre comment les briques s’articulent. Une mauvaise compréhension de l’architecture est la source numéro un des erreurs de déploiement Authelia, notamment les boucles de redirections ou les cookies de session qui ne se propagent pas correctement.

L’architecture standard comprend trois composants principaux. Le premier est Authelia lui-même : un processus Go qui écoute sur le port 9091, expose une interface web de login, et répond aux requêtes de vérification envoyées par Traefik. Le deuxième est Redis : Authelia utilise Redis comme store de sessions distribué, ce qui lui permet de maintenir les sessions utilisateurs de manière persistante même après un redémarrage du conteneur. Sans Redis, chaque redémarrage déconnecte tous les utilisateurs. Le troisième composant est le backend d’utilisateurs : en mode simple, c’est un fichier YAML (users_database.yml) contenant les comptes hashés ; en mode avancé, c’est un serveur LDAP (on utilisera LLDAP, un LDAP minimaliste en Rust, à l’étape 7).

Le flux d’une requête se déroule ainsi : le navigateur de l’utilisateur contacte Traefik pour accéder à grafana.votredomaine.com. Traefik, avant de transmettre la requête à Grafana, interroge Authelia via un middleware ForwardAuth en envoyant une requête GET à https://auth.votredomaine.com/api/authz/forward-auth. Authelia examine les cookies de session présents. Si la session est valide et que la politique d’accès autorise l’utilisateur, Authelia renvoie un statut HTTP 200 et Traefik laisse passer la requête. Sinon, Authelia renvoie un 302 vers sa page de login, Traefik redirige le navigateur, l’utilisateur s’authentifie, et Authelia renvoie finalement le navigateur vers l’URL d’origine.

Cette architecture signifie qu’Authelia doit impérativement être accessible publiquement (via HTTPS) pour que les redirections fonctionnent. Le domaine auth.votredomaine.com est donc lui-même protégé uniquement par Traefik (pas de ForwardAuth dessus — ce serait une boucle infinie).

Étape 2 — Déployer Authelia via Docker Compose

On commence par créer la structure de répertoires et le fichier Docker Compose. Gardez toute la configuration Authelia dans un répertoire dédié sur votre serveur pour faciliter la maintenance et les sauvegardes.

# Créer l'arborescence de configuration
mkdir -p /opt/authelia/config
mkdir -p /opt/authelia/secrets
cd /opt/authelia

Ensuite, créez le fichier docker-compose.yml suivant. Il définit les trois services — Authelia, Redis et une base de données SQLite (pour stocker les inscriptions TOTP et WebAuthn) — ainsi que les variables d’environnement essentielles.

# /opt/authelia/docker-compose.yml
version: '3.8'

services:
  authelia:
    image: authelia/authelia:latest
    container_name: authelia
    restart: unless-stopped
    volumes:
      - ./config:/config  # Contient configuration.yml et users_database.yml
    environment:
      - AUTHELIA_JWT_SECRET_FILE=/run/secrets/jwt_secret
      - AUTHELIA_SESSION_SECRET_FILE=/run/secrets/session_secret
      - AUTHELIA_STORAGE_ENCRYPTION_KEY_FILE=/run/secrets/storage_key
    secrets:
      - jwt_secret
      - session_secret
      - storage_key
    networks:
      - traefik-public
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.authelia.rule=Host(`auth.votredomaine.com`)"
      - "traefik.http.routers.authelia.entrypoints=websecure"
      - "traefik.http.routers.authelia.tls.certresolver=letsencrypt"
      - "traefik.http.services.authelia.loadbalancer.server.port=9091"

  redis:
    image: redis:7-alpine
    container_name: authelia-redis
    restart: unless-stopped
    volumes:
      - redis_data:/data
    networks:
      - traefik-public
    command: redis-server --save 60 1 --loglevel warning

volumes:
  redis_data:

secrets:
  jwt_secret:
    file: ./secrets/jwt_secret
  session_secret:
    file: ./secrets/session_secret
  storage_key:
    file: ./secrets/storage_key

networks:
  traefik-public:
    external: true  # Le réseau Docker partagé avec Traefik

Avant de démarrer, générez les trois secrets cryptographiques dont Authelia a besoin. Ces valeurs doivent être aléatoires et suffisamment longues (au moins 64 caractères hexadécimaux). Ne les réutilisez jamais entre environnements.

# Générer les trois secrets cryptographiques
openssl rand -hex 64 > /opt/authelia/secrets/jwt_secret
openssl rand -hex 64 > /opt/authelia/secrets/session_secret
openssl rand -hex 64 > /opt/authelia/secrets/storage_key

# Restreindre les permissions — Authelia tourne en tant qu'utilisateur 1000:1000
chmod 600 /opt/authelia/secrets/*

Ces fichiers contiennent des valeurs sensibles : ils ne doivent jamais être commités dans un dépôt Git ni exposés publiquement. La mécanique Docker Secrets les monte dans le conteneur sous /run/secrets/ avec des permissions restreintes, ce qui est plus sûr que de les passer directement en variables d’environnement en clair.

Étape 3 — Configurer configuration.yml

Le fichier configuration.yml est le cerveau d’Authelia. Il définit tout : comment les sessions sont gérées, quels utilisateurs ont accès à quoi, comment le TOTP est configuré, et comment Authelia se connecte à ses backends. La documentation officielle complète se trouve sur authelia.com/configuration.

# /opt/authelia/config/configuration.yml
---
theme: dark  # ou light
default_2fa_method: totp

# URL publique d'Authelia — doit correspondre exactement au domaine exposé par Traefik
server:
  address: 'tcp://0.0.0.0:9091'

log:
  level: info
  format: text

# Totp : compatble avec tout app RFC 6238 (Aegis, 2FAS, Google Authenticator)
totp:
  issuer: votredomaine.com  # Apparaît dans l'app authenticator
  algorithm: sha1           # Compatibilité maximale avec les apps tierces
  digits: 6
  period: 30
  skew: 1                   # Accepte ±1 période pour décalage horloge

webauthn:
  disable: false
  display_name: ITSkillsCenter SSO
  attestation_conveyance_preference: indirect
  user_verification: preferred
  timeout: 60s

# Authentification : simple fichier (voir Étape 7 pour LDAP)
authentication_backend:
  password_reset:
    disable: false
  file:
    path: /config/users_database.yml
    password:
      algorithm: argon2id   # Algorithme de hachage recommandé par Authelia
      argon2:
        iterations: 3
        memory: 65536
        parallelism: 4
        key_length: 32
        salt_length: 16

# Contrôle d'accès : du plus restrictif au plus permissif
access_control:
  default_policy: deny      # Tout refuser par défaut — sécurité maximale
  rules:
    # Authelia lui-même ne doit PAS avoir de ForwardAuth (boucle infinie)
    - domain: auth.votredomaine.com
      policy: bypass
    # Pages publiques (si applicable)
    - domain: www.votredomaine.com
      policy: bypass
    # Outils d'administration : 2FA obligatoire
    - domain:
        - 'portainer.votredomaine.com'
        - 'grafana.votredomaine.com'
        - 'gitea.votredomaine.com'
      policy: two_factor
    # Outils internes : login seul suffit
    - domain: 'wiki.votredomaine.com'
      policy: one_factor

# Sessions : géré par Redis
session:
  name: authelia_session
  same_site: lax
  expiration: 1h           # Session expire après 1h d'inactivité
  inactivity: 10m          # Déconnexion si inactif 10 min
  remember_me: 1w          # "Se souvenir de moi" : 1 semaine
  cookies:
    - domain: votredomaine.com   # Domaine racine pour le cookie partagé
      authelia_url: https://auth.votredomaine.com
      default_redirection_url: https://www.votredomaine.com
  redis:
    host: authelia-redis   # Nom du service Docker
    port: 6379

# Stockage SQLite pour TOTP/WebAuthn (utiliser PostgreSQL en prod multi-instances)
storage:
  local:
    path: /config/db.sqlite3

# Notifications (réinitialisation mot de passe, enrôlement TOTP)
notifier:
  disable_startup_check: false
  smtp:
    address: smtp://smtp.gmail.com:587
    username: votre@gmail.com
    password: 'votre-app-password-gmail'
    sender: "ITSkillsCenter SSO "
    subject: "[Authelia] {title}"

Notez la section access_control : Authelia applique les règles dans l’ordre, de la première à la dernière. La règle bypass sur auth.votredomaine.com est impérative — sans elle, Authelia essaierait de se protéger lui-même, créant une boucle de redirection infinie que les navigateurs signalent avec l’erreur ERR_TOO_MANY_REDIRECTS. La politique default_policy: deny garantit que tout nouveau sous-domaine ajouté sans règle explicite sera bloqué automatiquement, ce qui est un excellent filet de sécurité.

Étape 4 — Forward Auth Traefik middleware

C’est l’étape qui branche Authelia dans votre flux réseau. Traefik doit être configuré pour interroger Authelia avant de transmettre chaque requête aux applications en aval. Cette configuration se fait via un middleware de type ForwardAuth, que vous définissez une seule fois et appliquez ensuite à autant de routers que souhaité.

Si vous gérez votre configuration Traefik via des fichiers statiques (plutôt que via des labels Docker sur chaque service), ajoutez ce middleware dans votre fichier de configuration dynamique Traefik :

# /etc/traefik/dynamic/authelia.yml
http:
  middlewares:
    authelia:
      forwardAuth:
        address: "http://authelia:9091/api/authz/forward-auth"
        # Authelia doit recevoir les headers originaux pour construire l'URL de retour
        trustForwardHeader: true
        authResponseHeaders:
          - Remote-User
          - Remote-Groups
          - Remote-Email
          - Remote-Name

    # Variante pour applications qui ont besoin d'une session de base seulement
    authelia-basic:
      forwardAuth:
        address: "http://authelia:9091/api/authz/forward-auth?authelia-redirect-url=/"
        trustForwardHeader: true
        authResponseHeaders:
          - Remote-User
          - Remote-Groups
          - Remote-Email
          - Remote-Name

Notez l’adresse http://authelia:9091 (HTTP, pas HTTPS) : la communication entre Traefik et Authelia est interne au réseau Docker, donc le chiffrement TLS n’est pas nécessaire sur ce segment. L’HTTPS est géré uniquement sur la couche Traefik exposée à Internet. Une fois ce middleware défini, vous pouvez l’appliquer à n’importe quel service via un label Docker :

# Exemple sur un service Grafana dans son propre docker-compose.yml
labels:
  - "traefik.enable=true"
  - "traefik.http.routers.grafana.rule=Host(`grafana.votredomaine.com`)"
  - "traefik.http.routers.grafana.entrypoints=websecure"
  - "traefik.http.routers.grafana.tls.certresolver=letsencrypt"
  # Appliquer le middleware Authelia
  - "traefik.http.routers.grafana.middlewares=authelia@file"
  - "traefik.http.services.grafana.loadbalancer.server.port=3000"

Après avoir appliqué ces changements, vérifiez que Traefik a bien rechargé sa configuration (la commande docker logs traefik 2>&1 | grep -i "config\\|error" vous montrera les éventuelles erreurs de parsing). Tentez ensuite d’accéder à https://grafana.votredomaine.com depuis un navigateur en navigation privée — vous devriez être immédiatement redirigé vers https://auth.votredomaine.com.

Étape 5 — Configurer le 2FA TOTP avec Aegis ou 2FAS

Authelia n’impose pas l’utilisation d’une application authenticator spécifique. Il supporte le standard RFC 6238 (TOTP), ce qui signifie qu’il est compatible avec Google Authenticator, Aegis Authenticator (open-source, recommandé sur Android), 2FAS (iOS/Android), Raivo (iOS) et même les gestionnaires de mots de passe modernes comme Bitwarden. Pour le contexte ouest-africain, Aegis est particulièrement recommandé car il permet l’export chiffré des seeds — précieux si vous changez de téléphone sans accès stable à Internet.

Commencez par créer le fichier d’utilisateurs avec un premier compte administrateur. Authelia fournit une commande intégrée pour hasher les mots de passe avec Argon2id :

# Générer un hash Argon2id pour le mot de passe "MonMotDePasse123!"
docker run --rm authelia/authelia:latest authelia crypto hash generate argon2 \
  --password 'MonMotDePasse123!'

# Output attendu (la valeur exacte sera différente à chaque exécution) :
# Digest: $argon2id$v=19$m=65536,t=3,p=4$abc123...$xyz789...

Copiez ce digest et créez le fichier d’utilisateurs :

# /opt/authelia/config/users_database.yml
users:
  admin:
    disabled: false
    displayname: "Administrateur"
    password: "$argon2id$v=19$m=65536,t=3,p=4$VOTRE_HASH_ICI"
    email: admin@votredomaine.com
    groups:
      - admins
      - users
  collaborateur1:
    disabled: false
    displayname: "Mamadou Diallo"
    password: "$argon2id$v=19$m=65536,t=3,p=4$HASH_COLLABORATEUR"
    email: mdiallo@votredomaine.com
    groups:
      - users

Démarrez maintenant le stack complet et surveillez les logs au démarrage :

# Démarrer le stack
docker compose -f /opt/authelia/docker-compose.yml up -d

# Surveiller les logs (Ctrl+C pour quitter)
docker compose -f /opt/authelia/docker-compose.yml logs -f authelia

Les logs doivent afficher Authelia listening for connections on '[::]:9091' sans erreur. Si vous voyez des erreurs de type secret file not found ou YAML parse error, c’est généralement un problème de chemin de fichier ou d’indentation dans configuration.yml.

Pour enrôler le TOTP, connectez-vous à https://auth.votredomaine.com avec votre compte, saisissez votre mot de passe, puis Authelia vous présentera un QR code à scanner avec Aegis ou 2FAS. Une fois scanné, saisissez le code à 6 chiffres affiché par l’application pour confirmer l’enrôlement. À partir de maintenant, toute connexion sur un service protégé en two_factor demandera ce code en plus du mot de passe.

Étape 6 — WebAuthn et Passkeys

WebAuthn est le protocole derrière les Passkeys : au lieu d’un code TOTP à 6 chiffres, l’utilisateur s’authentifie avec une clé cryptographique stockée sur son appareil (capteur d’empreinte du téléphone, clé USB YubiKey, capteur de visage). C’est plus sécurisé que le TOTP car la clé privée ne quitte jamais l’appareil et il est impossible de phisher un challenge WebAuthn.

Authelia supporte WebAuthn nativement depuis la v4.36. La section webauthn que vous avez ajoutée dans configuration.yml à l’étape 3 est suffisante pour l’activer. La seule contrainte est que WebAuthn exige HTTPS avec un domaine valide — ce qui est déjà notre cas puisque Traefik gère les certificats Let’s Encrypt.

Pour enrôler une clé WebAuthn, l’utilisateur se connecte à https://auth.votredomaine.com, accède à son profil (icône en haut à droite), puis clique sur Ajouter un périphérique WebAuthn. Le navigateur déclenchera alors la procédure native du système d’exploitation : sur Android, une empreinte digitale ou le déverrouillage par code PIN ; sur un poste Windows avec une YubiKey, l’appui sur la clé physique. L’expérience utilisateur est fluide et ne nécessite aucune application tierce.

Dans un contexte PME ouest-africain, il est conseillé de proposer WebAuthn comme second facteur complémentaire plutôt que principal, car tous les collaborateurs n’ont pas forcément un appareil compatible (certains téléphones Android économiques ne supportent pas encore WebAuthn via le navigateur). Laissez TOTP actif en parallèle comme fallback.

Étape 7 — Backend LDAP avec LLDAP (optionnel)

Le fichier users_database.yml fonctionne très bien pour des équipes de moins de dix personnes. Au-delà, ou si vous voulez centraliser la gestion des utilisateurs avec une interface graphique, LLDAP (Lightweight LDAP) est la solution recommandée dans l’écosystème Authelia. LLDAP est un serveur LDAP minimaliste écrit en Rust, avec une interface web moderne, qui expose uniquement ce qu’Authelia a besoin — sans la complexité d’OpenLDAP.

Ajoutez LLDAP à votre stack Docker Compose :

# À ajouter dans docker-compose.yml, section services:
  lldap:
    image: lldap/lldap:stable
    container_name: lldap
    restart: unless-stopped
    volumes:
      - lldap_data:/data
    environment:
      - LLDAP_JWT_SECRET_FILE=/run/secrets/lldap_jwt
      - LLDAP_LDAP_BASE_DN=dc=votredomaine,dc=com
      - LLDAP_LDAP_USER_EMAIL=admin@votredomaine.com
      - LLDAP_LDAP_USER_PASS_FILE=/run/secrets/lldap_admin_pass
    secrets:
      - lldap_jwt
      - lldap_admin_pass
    networks:
      - traefik-public
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.lldap.rule=Host(`ldap.votredomaine.com`)"
      - "traefik.http.routers.lldap.entrypoints=websecure"
      # Protéger l'interface LLDAP avec Authelia en two_factor !
      - "traefik.http.routers.lldap.middlewares=authelia@file"
      - "traefik.http.services.lldap.loadbalancer.server.port=17170"

Puis modifiez la section authentication_backend dans configuration.yml pour pointer vers LLDAP :

authentication_backend:
  ldap:
    address: ldap://lldap:3890
    base_dn: DC=votredomaine,DC=com
    username_attribute: uid
    mail_attribute: mail
    additional_users_dn: OU=people
    users_filter: "(&({username_attribute}={input})(objectClass=person))"
    additional_groups_dn: OU=groups
    groups_filter: "(member={dn})"
    group_name_attribute: cn
    user: uid=admin,ou=people,dc=votredomaine,dc=com
    password: 'votre-mot-de-passe-lldap-admin'

Une fois LLDAP démarré, accédez à https://ldap.votredomaine.com pour créer vos groupes (admins, users) et ajouter vos utilisateurs via l’interface graphique. Les changements sont répercutés en temps réel dans Authelia sans nécessiter de redémarrage.

Erreurs fréquentes

Adaptation au contexte ouest-africain

Authelia est un excellent choix pour les PME tech d’Afrique de l’Ouest pour plusieurs raisons pratiques. Sa consommation mémoire est typiquement de 30 à 60 Mo au repos, et moins de 100 Mo en charge modérée — ce qui le rend parfaitement adapté à un Hetzner CX22 (2 vCPU, 4 Go RAM, 3,79 €/mois) sur lequel tourne déjà votre stack Traefik, Redis et quelques services. Sur un CAX11 ARM (2 vCPU, 4 Go RAM, 3,29 €/mois), les performances sont similaires. Contrairement à Keycloak qui nécessite au minimum 512 Mo de RAM (et idéalement 1 Go), Authelia ne grève pas votre budget serveur.

Sur la question du deuxième facteur en contexte mobile africain : tous vos collaborateurs ne disposent pas forcément d’un smartphone récent avec une application authenticator. Pour gérer ce cas, configurez un fallback SMS via Twilio Verify. Authelia supporte les notifications externes via webhook ; vous pouvez brancher un script Python léger qui appelle l’API Twilio Verify pour envoyer un OTP par SMS. Cette option est documentée dans la section Notifier de la documentation Authelia, et Twilio propose des numéros locaux sénégalais et ivoiriens. Le coût par SMS est faible (environ 0,05 $ par message) et se finance facilement via Mobile Money (Wave ou Orange Money permettent de charger un compte Twilio).

Concernant les durées de session : dans les cybercafés et sur les PC partagés fréquents dans la région, une session inactivité de 10 minutes (inactivity: 10m) est particulièrement importante pour éviter qu’un collègue ou un client suivant ne se retrouve connecté sur le compte d’un utilisateur précédent. Désactivez systématiquement l’option Se souvenir de moi pour les postes partagés en ajoutant une règle d’accès plus restrictive sur les sous-domaines critiques. Pour la gestion des coupures réseau fréquentes (délestage SENELEC, fluctuations MTN/Moov), le store Redis avec persistance (--save 60 1) garantit que les sessions survivent à un redémarrage du conteneur Authelia dû à un reboot du serveur après coupure.

Tutoriels frères

• Keycloak self-hosted : SSO OAuth2/OIDC pour stack web — déploiement (2026) — solution IAM complète pour les stacks qui ont besoin de fédération d’identité et de flux OAuth2 standards
• Authentik self-hosted : SSO + RBAC avancé — déploiement (2026) — alternative à Authelia avec interface graphique riche et gestion RBAC granulaire
• Traefik v3 : reverse-proxy Docker avec TLS automatique (2026) — prérequis de ce tutoriel, configuration complète de Traefik avant de brancher Authelia

Pour aller plus loin

• Retour au pilier : IAM open-source pour PME : Keycloak, Authelia, Authentik comparés (2026)
• Documentation officielle Authelia : authelia.com/docs — référence complète des options de configuration
• Dépôt GitHub officiel : github.com/authelia/authelia — changelog, issues, discussions communautaires
• LLDAP (LDAP léger en Rust) : github.com/lldap/lldap
• Prochaine étape recommandée dans le cluster : le tutoriel Authentik, pour évaluer si vous avez besoin de plus de granularité RBAC que ce qu’Authelia propose

FAQ

Q : Authelia est-il vraiment gratuit pour un usage commercial ?

Oui. Authelia est publié sous licence Apache 2.0 (github.com/authelia/authelia), ce qui autorise tout usage commercial sans frais de licence. Vous payez uniquement votre infrastructure (serveur, domaine, éventuellement Twilio pour les SMS).

Q : Peut-on utiliser Authelia avec Nginx au lieu de Traefik ?

Oui, Authelia supporte le ForwardAuth avec Nginx via le module ngx_http_auth_request_module. La configuration est un peu plus verbeuse que dans Traefik : vous devez définir un bloc location /authelia qui proxifie vers http://authelia:9091/api/authz/forward-auth, puis utiliser la directive auth_request dans vos vhosts. La documentation officielle couvre ce cas sur authelia.com/integration/proxies/nginx.

Q : Quelle est la différence entre one_factor et two_factor dans les politiques d’accès ?

one_factor signifie que l’utilisateur doit saisir son mot de passe uniquement. two_factor signifie mot de passe + TOTP (ou WebAuthn). bypass laisse passer sans authentification. deny bloque systématiquement. Ces politiques s’appliquent par domaine et peuvent être combinées avec des conditions sur les groupes LDAP ou les plages IP source.

Q : Comment migrer d’un fichier d’utilisateurs vers LLDAP sans perdre les sessions TOTP enrôlées ?

Les enrôlements TOTP et WebAuthn sont stockés dans la base SQLite (db.sqlite3), pas dans le fichier d’utilisateurs. Lors du passage à LLDAP, tant que les uid LDAP correspondent aux noms d’utilisateurs du fichier YAML, Authelia retrouvera automatiquement les enrôlements existants. Aucune réinitialisation des seconds facteurs n’est nécessaire si les identifiants sont préservés.

Q : Authelia peut-il protéger des applications qui ont leur propre authentification ?

Oui, mais le comportement dépend de l’application. Pour des outils comme Grafana ou Gitea qui supportent l’authentification par proxy (proxy auth), vous pouvez configurer l’application pour faire confiance aux headers Remote-User et Remote-Email envoyés par Authelia — l’utilisateur est alors automatiquement connecté dans l’outil sans avoir à entrer de credentials une deuxième fois. Pour des applications sans cette fonctionnalité, l’utilisateur devra s’authentifier deux fois (Authelia puis l’app), ce qui n’est pas idéal mais reste fonctionnel.

Q : Comment sécuriser l’accès à Authelia lui-même contre les attaques par force brute ?

Authelia intègre un mécanisme de limitation de débit et de régulation (regulation) natif. Activez-le dans configuration.yml avec la section regulation : définissez max_retries: 5, find_time: 2m et ban_time: 10m. Après 5 tentatives échouées en 2 minutes depuis la même IP, Authelia bannit automatiquement l’IP pendant 10 minutes. Pour une protection supplémentaire, placez Authelia derrière le rate-limiting de Traefik ou Cloudflare.

Site réalisé par [ITS] ITSkillsCenter — Formation IT pour l’Afrique de l’Ouest