Authentik : Le Fournisseur d'Identité Open-Source qui Remplace Keycloak

Introduction : La gestion d'identité, un enjeu critique en 2025-2026

Dans un monde où chaque service auto-hébergé possède son propre système d'authentification, gérer des dizaines de comptes et mots de passe différents devient rapidement un cauchemar. Que vous administriez un homelab avec Grafana, Portainer, Proxmox et Nextcloud, ou une infrastructure d'entreprise avec des dizaines d'applications, la question se pose : comment centraliser l'authentification ?

La réponse s'appelle un Identity Provider (IdP), un fournisseur d'identité qui gère l'authentification de manière centralisée et permet le Single Sign-On (SSO). Pendant des années, Keycloak était la référence open-source incontestée. Mais son interface vieillissante, sa consommation de ressources élevée (Java/JBoss) et sa complexité de configuration ont ouvert la porte à une alternative moderne : Authentik.

Architecture en un coup d'œil

Authentik est un fournisseur d'identité open-source écrit en Python (Django) avec une interface utilisateur en TypeScript (Lit). Il est conçu pour être plus léger, plus intuitif et plus flexible que Keycloak, tout en offrant un ensemble de fonctionnalités comparable. Dans cet article approfondi, nous allons explorer Authentik en détail : son installation, ses concepts fondamentaux, ses intégrations et sa comparaison avec les alternatives.

Qu'est-ce qu'Authentik ?

Un Identity Provider moderne

Authentik est un Identity Provider (IdP) et Security Platform open-source qui fournit :

• Single Sign-On (SSO) : connectez-vous une seule fois et accédez à toutes vos applications
• OAuth2 / OpenID Connect (OIDC) : le standard moderne d'authentification utilisé par Google, GitHub, etc.
• SAML 2.0 : pour les applications d'entreprise qui utilisent ce protocole
• LDAP Proxy : fournit un serveur LDAP virtuel pour les applications legacy
• Proxy d'authentification : protège les applications web qui n'ont pas de support SSO natif
• Authentification multi-facteurs (MFA) : TOTP, WebAuthn/FIDO2, SMS, email
• Enrollment et self-service : inscription, récupération de mot de passe, gestion de profil
• Flows visuels : éditeur graphique pour concevoir des parcours d'authentification personnalisés

Pourquoi Authentik plutôt que Keycloak ?

Keycloak est un excellent logiciel, mais il présente plusieurs inconvénients que Authentik adresse directement :

En résumé, Authentik est le choix idéal si vous cherchez un IdP plus léger, plus moderne et plus facile à prendre en main que Keycloak, sans sacrifier les fonctionnalités essentielles.

Installation avec Docker Compose

Prérequis

• Docker et Docker Compose installés
• 2 Go de RAM minimum (4 Go recommandés)
• 2 vCPUs recommandés
• Un nom de domaine avec un sous-domaine dédié (ex: auth.mondomaine.fr)
• Un reverse proxy (Nginx, Traefik, Caddy) ou Cloudflare Tunnel pour l'accès HTTPS

Docker Compose complet

Voici le fichier docker-compose.yml officiel et optimisé pour la production :

version: "3.8"

services:
  # --- Base de données PostgreSQL ---
  postgresql:
    image: docker.io/library/postgres:16-alpine
    container_name: authentik-db
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -d $${POSTGRES_DB} -U $${POSTGRES_USER}"]
      start_period: 20s
      interval: 30s
      retries: 5
      timeout: 5s
    volumes:
      - authentik-db:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: ${PG_PASS:?Le mot de passe PostgreSQL est requis}
      POSTGRES_USER: ${PG_USER:-authentik}
      POSTGRES_DB: ${PG_DB:-authentik}
    networks:
      - authentik-internal

  # --- Cache Redis ---
  redis:
    image: docker.io/library/redis:7-alpine
    container_name: authentik-redis
    command: --save 60 1 --loglevel warning
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "redis-cli ping | grep PONG"]
      start_period: 20s
      interval: 30s
      retries: 5
      timeout: 3s
    volumes:
      - authentik-redis:/data
    networks:
      - authentik-internal

  # --- Authentik Server (interface web + API) ---
  server:
    image: ghcr.io/goauthentik/server:2025.2
    container_name: authentik-server
    restart: unless-stopped
    command: server
    environment:
      AUTHENTIK_REDIS__HOST: redis
      AUTHENTIK_POSTGRESQL__HOST: postgresql
      AUTHENTIK_POSTGRESQL__USER: ${PG_USER:-authentik}
      AUTHENTIK_POSTGRESQL__NAME: ${PG_DB:-authentik}
      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS}
      AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY:?La clé secrète est requise}
      # Configuration email (optionnel)
      AUTHENTIK_EMAIL__HOST: ${AUTHENTIK_EMAIL_HOST:-smtp.mondomaine.fr}
      AUTHENTIK_EMAIL__PORT: ${AUTHENTIK_EMAIL_PORT:-587}
      AUTHENTIK_EMAIL__USERNAME: ${AUTHENTIK_EMAIL_USERNAME:-noreply@mondomaine.fr}
      AUTHENTIK_EMAIL__PASSWORD: ${AUTHENTIK_EMAIL_PASSWORD:-}
      AUTHENTIK_EMAIL__USE_TLS: ${AUTHENTIK_EMAIL_USE_TLS:-true}
      AUTHENTIK_EMAIL__FROM: ${AUTHENTIK_EMAIL_FROM:-noreply@mondomaine.fr}
      # Paramètres avancés
      AUTHENTIK_ERROR_REPORTING__ENABLED: "false"
      AUTHENTIK_DISABLE_UPDATE_CHECK: "false"
      AUTHENTIK_DISABLE_STARTUP_ANALYTICS: "true"
    volumes:
      - authentik-media:/media
      - authentik-custom-templates:/templates
    ports:
      - "${COMPOSE_PORT_HTTP:-9000}:9000"
      - "${COMPOSE_PORT_HTTPS:-9443}:9443"
    depends_on:
      postgresql:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - authentik-internal

  # --- Authentik Worker (tâches de fond) ---
  worker:
    image: ghcr.io/goauthentik/server:2025.2
    container_name: authentik-worker
    restart: unless-stopped
    command: worker
    environment:
      AUTHENTIK_REDIS__HOST: redis
      AUTHENTIK_POSTGRESQL__HOST: postgresql
      AUTHENTIK_POSTGRESQL__USER: ${PG_USER:-authentik}
      AUTHENTIK_POSTGRESQL__NAME: ${PG_DB:-authentik}
      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS}
      AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY}
      AUTHENTIK_EMAIL__HOST: ${AUTHENTIK_EMAIL_HOST:-smtp.mondomaine.fr}
      AUTHENTIK_EMAIL__PORT: ${AUTHENTIK_EMAIL_PORT:-587}
      AUTHENTIK_EMAIL__USERNAME: ${AUTHENTIK_EMAIL_USERNAME:-noreply@mondomaine.fr}
      AUTHENTIK_EMAIL__PASSWORD: ${AUTHENTIK_EMAIL_PASSWORD:-}
      AUTHENTIK_EMAIL__USE_TLS: ${AUTHENTIK_EMAIL_USE_TLS:-true}
      AUTHENTIK_EMAIL__FROM: ${AUTHENTIK_EMAIL_FROM:-noreply@mondomaine.fr}
    user: root
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - authentik-media:/media
      - authentik-certs:/certs
      - authentik-custom-templates:/templates
    depends_on:
      postgresql:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - authentik-internal

volumes:
  authentik-db:
    driver: local
  authentik-redis:
    driver: local
  authentik-media:
    driver: local
  authentik-certs:
    driver: local
  authentik-custom-templates:
    driver: local

networks:
  authentik-internal:
    driver: bridge

Fichier .env

Créez un fichier .env à côté de votre docker-compose.yml :

# Mot de passe PostgreSQL
PG_PASS=UnMotDePasseTresSecurise2025!

# Clé secrète Authentik (générez-la une fois, ne la changez jamais)
# Utilisez : openssl rand -base64 60
AUTHENTIK_SECRET_KEY=VotreCleSecreteSuperLongueEtAleatoire...

# Configuration email (optionnel mais recommandé)
AUTHENTIK_EMAIL_HOST=smtp.mondomaine.fr
AUTHENTIK_EMAIL_PORT=587
AUTHENTIK_EMAIL_USERNAME=noreply@mondomaine.fr
AUTHENTIK_EMAIL_PASSWORD=MotDePasseSmtp
AUTHENTIK_EMAIL_USE_TLS=true
AUTHENTIK_EMAIL_FROM=Authentik <noreply@mondomaine.fr>

# Ports (optionnel)
COMPOSE_PORT_HTTP=9000
COMPOSE_PORT_HTTPS=9443

Démarrage

# Créer le répertoire du projet
mkdir -p /opt/authentik && cd /opt/authentik

# Générer la clé secrète
echo "AUTHENTIK_SECRET_KEY=$(openssl rand -base64 60 | tr -d '\n')" >> .env

# Démarrer les services
docker compose up -d

# Suivre les logs
docker compose logs -f server

# Vérifier que tout fonctionne
docker compose ps

Configuration initiale

Après le premier démarrage, accédez à l'interface de configuration initiale :

# L'interface de setup est accessible sur :
# http://votre-serveur:9000/if/flow/initial-setup/

# Vous y créerez le compte administrateur (akadmin)
# Définissez un mot de passe fort pour ce compte

Après la configuration initiale, vous accédez au dashboard d'administration sur http://votre-serveur:9000/if/admin/ et à l'interface utilisateur sur http://votre-serveur:9000/if/user/.

Concepts fondamentaux d'Authentik

Avant de plonger dans les intégrations, il est essentiel de comprendre les concepts clés d'Authentik. Ces concepts sont ce qui rend Authentik si flexible et puissant.

Flows (Flux)

Un Flow est un parcours d'authentification composé d'étapes séquentielles. C'est le concept central d'Authentik. Chaque action utilisateur (connexion, inscription, récupération de mot de passe, etc.) est gérée par un Flow.

Les types de Flows disponibles sont :

• Authentication : processus de connexion
• Authorization : consentement OAuth2/OIDC (écran "Autoriser cette application ?")
• Enrollment : inscription d'un nouvel utilisateur
• Recovery : récupération de mot de passe
• Unenrollment : suppression de compte
• Stage Configuration : configuration d'un stage (ex: setup TOTP)

Authentik fournit des Flows par défaut qui fonctionnent immédiatement, mais vous pouvez les personnaliser ou en créer de nouveaux via l'éditeur visuel.

Stages (Étapes)

Un Stage est une étape individuelle dans un Flow. Chaque Stage effectue une action spécifique :

• Identification Stage : demande le nom d'utilisateur ou l'email
• Password Stage : demande le mot de passe
• Authenticator Validation Stage : vérifie le second facteur (TOTP, WebAuthn)
• Authenticator Setup Stage : configure un nouveau dispositif MFA
• Email Stage : envoie un email de vérification
• User Write Stage : crée ou met à jour un utilisateur
• Consent Stage : affiche l'écran de consentement OAuth2
• Captcha Stage : vérifie que l'utilisateur n'est pas un robot
• Deny Stage : bloque l'accès
• Prompt Stage : affiche un formulaire personnalisé
• Invitation Stage : vérifie un lien d'invitation

Les Stages sont assemblés dans un Flow comme des blocs de construction. Par exemple, un Flow d'authentification typique enchaîne : Identification -> Password -> Authenticator Validation.

Policies (Politiques)

Les Policies sont des règles qui contrôlent le comportement des Flows et des Stages. Elles permettent une logique conditionnelle dans vos parcours d'authentification :

• Expression Policy : code Python personnalisé pour une logique complexe
• Password Policy : règles de complexité des mots de passe (longueur, caractères spéciaux, etc.)
• Reputation Policy : bloque les tentatives après trop d'échecs (rate limiting)
• Event Matcher Policy : déclenche des actions basées sur des événements
• GeoIP Policy : restreint l'accès par localisation géographique

Les Policies peuvent être attachées aux Flows, aux Stages et aux Stage Bindings pour créer des parcours conditionnels. Par exemple : "Si l'utilisateur se connecte depuis un nouveau pays, exiger le MFA. Sinon, autoriser la connexion avec le mot de passe seul."

Providers (Fournisseurs)

Un Provider définit le protocole utilisé pour communiquer avec une application. Les types de Providers sont :

• OAuth2/OIDC Provider : pour les applications modernes supportant OAuth2 ou OpenID Connect
• SAML Provider : pour les applications d'entreprise utilisant SAML 2.0
• LDAP Provider : expose un serveur LDAP virtuel pour les applications legacy
• Proxy Provider : protège les applications web via un reverse proxy d'authentification (forward auth)
• RADIUS Provider : pour les équipements réseau (VPN, Wi-Fi)
• SCIM Provider : synchronisation automatique des utilisateurs vers des services tiers

Applications

Une Application dans Authentik représente un service externe que vous souhaitez protéger. Chaque Application est associée à un Provider et apparaît dans le dashboard utilisateur comme une tuile cliquable. Les utilisateurs voient uniquement les applications auxquelles ils ont accès.

Outposts (Avant-postes)

Les Outposts sont des composants déployés séparément qui étendent les fonctionnalités d'Authentik. Il existe trois types :

• Proxy Outpost : reverse proxy d'authentification pour protéger des applications web (utilisé avec Nginx, Traefik, Caddy)
• LDAP Outpost : serveur LDAP virtuel qui traduit les requêtes LDAP en requêtes vers Authentik
• RADIUS Outpost : serveur RADIUS pour l'authentification réseau

Les Outposts peuvent être déployés de trois manières :

• Embedded : intégré directement dans le serveur Authentik (le plus simple)
• Docker : conteneur Docker séparé, géré automatiquement par Authentik
• Kubernetes : déployé comme un pod Kubernetes

Configurer le SSO avec OAuth2/OIDC

Créer un Provider OAuth2

Prenons l'exemple d'une intégration avec Grafana. Voici les étapes dans l'interface d'administration d'Authentik :

1. Allez dans Applications > Providers
2. Cliquez sur "Create"
3. Sélectionnez "OAuth2/OpenID Connect Provider"
4. Configurez :
   • Name : grafana-provider
   • Authorization flow : default-provider-authorization-implicit-consent (ou explicit si vous voulez un écran de consentement)
   • Client type : Confidential
   • Client ID : auto-généré (notez-le)
   • Client Secret : auto-généré (notez-le)
   • Redirect URIs : https://grafana.mondomaine.fr/login/generic_oauth
   • Signing Key : sélectionnez votre certificat de signature
   • Scopes : openid profile email

Créer l'Application

1. Allez dans Applications > Applications
2. Cliquez sur "Create"
3. Configurez :
   • Name : Grafana
   • Slug : grafana
   • Provider : sélectionnez grafana-provider
   • Launch URL : https://grafana.mondomaine.fr
   • Icon : uploadez une icône Grafana (optionnel)

Configurer Grafana

Côté Grafana, configurez l'authentification OAuth2 dans le fichier grafana.ini ou via des variables d'environnement :

# Variables d'environnement pour Grafana (docker-compose.yml)
environment:
  # Authentification OAuth2 via Authentik
  - GF_AUTH_GENERIC_OAUTH_ENABLED=true
  - GF_AUTH_GENERIC_OAUTH_NAME=Authentik
  - GF_AUTH_GENERIC_OAUTH_CLIENT_ID=VotreClientID
  - GF_AUTH_GENERIC_OAUTH_CLIENT_SECRET=VotreClientSecret
  - GF_AUTH_GENERIC_OAUTH_SCOPES=openid profile email
  - GF_AUTH_GENERIC_OAUTH_AUTH_URL=https://auth.mondomaine.fr/application/o/authorize/
  - GF_AUTH_GENERIC_OAUTH_TOKEN_URL=https://auth.mondomaine.fr/application/o/token/
  - GF_AUTH_GENERIC_OAUTH_API_URL=https://auth.mondomaine.fr/application/o/userinfo/
  - GF_AUTH_GENERIC_OAUTH_ROLE_ATTRIBUTE_PATH=contains(groups[*], 'grafana-admins') && 'Admin' || contains(groups[*], 'grafana-editors') && 'Editor' || 'Viewer'
  - GF_AUTH_GENERIC_OAUTH_SIGNOUT_REDIRECT_URL=https://auth.mondomaine.fr/application/o/grafana/end-session/
  - GF_AUTH_SIGNOUT_REDIRECT_URL=https://auth.mondomaine.fr/application/o/grafana/end-session/
  - GF_SERVER_ROOT_URL=https://grafana.mondomaine.fr

Les URLs OAuth2 d'Authentik suivent un pattern standard :

# Endpoints OAuth2/OIDC pour l'application "grafana"
# Authorization : https://auth.mondomaine.fr/application/o/authorize/
# Token         : https://auth.mondomaine.fr/application/o/token/
# UserInfo      : https://auth.mondomaine.fr/application/o/userinfo/
# JWKS          : https://auth.mondomaine.fr/application/o/grafana/jwks/
# End Session   : https://auth.mondomaine.fr/application/o/grafana/end-session/
# OpenID Config : https://auth.mondomaine.fr/application/o/grafana/.well-known/openid-configuration

# Vérifiez la configuration OIDC
curl -s https://auth.mondomaine.fr/application/o/grafana/.well-known/openid-configuration | jq .

Intégration avec des applications courantes

Portainer

Portainer supporte nativement OAuth2. Dans l'interface Portainer :

1. Allez dans Settings > Authentication
2. Sélectionnez "OAuth"
3. Configurez avec les URLs d'Authentik (Authorization URL, Token URL, Resource URL, etc.)
4. Entrez le Client ID et Client Secret du Provider Authentik

Proxmox VE

Proxmox supporte l'authentification OIDC depuis la version 7.x :

1. Dans Authentik, créez un Provider OAuth2/OIDC pour Proxmox
2. Redirect URI : https://proxmox.mondomaine.fr:8006
3. Dans Proxmox : Datacenter > Permissions > Realms > Add > OpenID Connect
4. Configurez l'Issuer URL, le Client ID et le Client Secret

Nginx Proxy Manager avec Proxy Provider

Pour les applications qui n'ont pas de support SSO natif, Authentik propose le Proxy Provider qui fonctionne avec le mécanisme de forward authentication de Nginx, Traefik ou Caddy :

1. Créez un Proxy Provider dans Authentik :
   • External host : https://app.mondomaine.fr
   • Mode : Forward auth (single application) ou Forward auth (domain level)
2. Créez une Application associée
3. Créez ou utilisez un Outpost de type Proxy (l'outpost embedded convient pour la plupart des cas)

Configuration Nginx pour le forward auth :

# Configuration Nginx pour forward auth avec Authentik
server {
    listen 443 ssl http2;
    server_name app.mondomaine.fr;

    ssl_certificate /etc/letsencrypt/live/app.mondomaine.fr/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/app.mondomaine.fr/privkey.pem;

    # Forward auth vers Authentik
    location /outpost.goauthentik.io {
        internal;
        proxy_pass https://auth.mondomaine.fr/outpost.goauthentik.io;
        proxy_pass_request_body off;
        proxy_set_header Content-Length "";
        proxy_set_header X-Original-URL $scheme://$http_host$request_uri;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-Host $http_host;
    }

    # Application protégée
    location / {
        auth_request /outpost.goauthentik.io;
        # Transmettre les headers d'authentification à l'application
        auth_request_set $authentik_username $upstream_http_x_authentik_username;
        auth_request_set $authentik_groups $upstream_http_x_authentik_groups;
        auth_request_set $authentik_email $upstream_http_x_authentik_email;
        auth_request_set $authentik_name $upstream_http_x_authentik_name;

        proxy_set_header X-authentik-username $authentik_username;
        proxy_set_header X-authentik-groups $authentik_groups;
        proxy_set_header X-authentik-email $authentik_email;
        proxy_set_header X-authentik-name $authentik_name;

        # Redirection vers Authentik si non authentifié
        error_page 401 = @goauthentik_proxy_signin;

        proxy_pass http://localhost:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    location @goauthentik_proxy_signin {
        internal;
        add_header Set-Cookie "rd=$scheme://$http_host$request_uri; HttpOnly; Secure; Path=/";
        return 302 https://auth.mondomaine.fr/outpost.goauthentik.io/start?rd=$scheme://$http_host$request_uri;
    }
}

Traefik avec Forward Auth

Pour Traefik, la configuration est plus élégante grâce aux labels Docker :

# docker-compose.yml avec Traefik et forward auth Authentik
services:
  mon-app:
    image: mon-app:latest
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.mon-app.rule=Host(`app.mondomaine.fr`)"
      - "traefik.http.routers.mon-app.entrypoints=websecure"
      - "traefik.http.routers.mon-app.tls.certresolver=letsencrypt"
      # Forward auth middleware vers Authentik
      - "traefik.http.routers.mon-app.middlewares=authentik@docker"

  # Middleware Authentik pour Traefik
  authentik-proxy:
    image: ghcr.io/goauthentik/proxy:2025.2
    environment:
      AUTHENTIK_HOST: https://auth.mondomaine.fr
      AUTHENTIK_INSECURE: "false"
      AUTHENTIK_TOKEN: ${AUTHENTIK_OUTPOST_TOKEN}
    labels:
      - "traefik.enable=true"
      - "traefik.http.middlewares.authentik.forwardauth.address=http://authentik-proxy:9000/outpost.goauthentik.io/auth/traefik"
      - "traefik.http.middlewares.authentik.forwardauth.trustForwardHeader=true"
      - "traefik.http.middlewares.authentik.forwardauth.authResponseHeaders=X-authentik-username,X-authentik-groups,X-authentik-email,X-authentik-name,X-authentik-uid"
    restart: unless-stopped

Authentification Multi-Facteurs (MFA)

TOTP (Time-based One-Time Password)

Le TOTP est la méthode MFA la plus courante, compatible avec des applications comme Google Authenticator, Authy, Microsoft Authenticator ou Bitwarden :

1. Dans Authentik, le TOTP est activé par défaut dans le Flow d'authentification
2. Les utilisateurs peuvent configurer leur TOTP depuis leur profil (/if/user/)
3. Lors de la configuration, un QR code est affiché pour scanner avec l'application

WebAuthn / FIDO2

WebAuthn est le standard moderne d'authentification sans mot de passe, supportant les clés de sécurité physiques (YubiKey, Titan Key) et les passkeys (Touch ID, Windows Hello, empreinte digitale) :

• Authentik supporte nativement WebAuthn/FIDO2
• Les utilisateurs peuvent enregistrer plusieurs dispositifs
• Peut être utilisé comme second facteur ou comme facteur unique (passwordless)

SMS et Email

Authentik supporte aussi l'envoi de codes OTP par SMS (via des fournisseurs comme Twilio) et par email. Ces méthodes sont moins sécurisées que TOTP ou WebAuthn mais offrent une alternative pour les utilisateurs non techniques.

Configurer le MFA obligatoire

Pour rendre le MFA obligatoire pour tous les utilisateurs :

1. Modifiez le Flow d'authentification par défaut
2. Ajoutez un Authenticator Validation Stage après le Password Stage
3. Dans ce Stage, cochez les méthodes acceptées (TOTP, WebAuthn, etc.)
4. Cochez "Not configured action: Force user to configure" pour obliger les utilisateurs qui n'ont pas encore configuré le MFA

Enrollment et Self-Service

Inscription des utilisateurs

Authentik offre un système d'inscription (enrollment) flexible :

• Inscription ouverte : tout le monde peut créer un compte
• Inscription par invitation : seuls les utilisateurs avec un lien d'invitation peuvent s'inscrire
• Inscription fermée : seul l'administrateur peut créer des comptes

Le Flow d'enrollment peut inclure des étapes personnalisées : vérification d'email, captcha, formulaire avec des champs personnalisés (département, rôle...), approbation manuelle par un administrateur.

Récupération de mot de passe

Le Flow de récupération de mot de passe est précconfiguré et fonctionne par email : l'utilisateur entre son email, reçoit un lien de réinitialisation, et peut définir un nouveau mot de passe. Vous pouvez personnaliser ce Flow pour ajouter des vérifications supplémentaires.

Gestion de profil

L'interface utilisateur (/if/user/) permet aux utilisateurs de :

• Modifier leurs informations personnelles (nom, email)
• Changer leur mot de passe
• Gérer leurs dispositifs MFA (TOTP, WebAuthn)
• Voir les sessions actives et les révoquer
• Voir les applications auxquelles ils ont accès
• Gérer les tokens et les consentements OAuth2

LDAP Proxy

De nombreuses applications legacy ne supportent que l'authentification LDAP. Authentik résout ce problème avec son LDAP Outpost qui expose un serveur LDAP virtuel traduisant les requêtes LDAP en authentification Authentik.

# Configuration d'un LDAP Provider dans Authentik :
# 1. Applications > Providers > Create > LDAP Provider
# 2. Name: ldap-provider
# 3. Base DN: DC=mondomaine,DC=fr
# 4. Bind Flow: default-authentication-flow
# 5. Search Group: sélectionnez un groupe (les membres peuvent chercher dans l'annuaire)

# 3. Créer un Outpost de type LDAP
# Applications > Outposts > Create
# Type: LDAP
# Integration: Docker (ou Embedded)
# Application: votre application LDAP

# L'outpost LDAP écoute sur le port 3389 (LDAP) et 6636 (LDAPS)

# Tester la connexion LDAP
ldapsearch -x -H ldap://auth.mondomaine.fr:3389 \
  -D "cn=ldapservice,ou=users,dc=mondomaine,dc=fr" \
  -w "MotDePasse" \
  -b "dc=mondomaine,dc=fr" \
  "(objectClass=user)"

Cela permet d'utiliser Authentik comme source d'authentification pour des applications comme Nextcloud (mode LDAP), des NAS Synology, des serveurs de messagerie, des imprimantes réseau, et bien d'autres appareils et services legacy.

Branding personnalisé

Authentik permet une personnalisation poussée de l'apparence :

• Logo : remplacez le logo sur les pages de connexion
• Favicon : icône personnalisée dans l'onglet du navigateur
• Titre : nom de votre organisation
• CSS personnalisé : injectez du CSS pour modifier complètement l'apparence
• Footer links : ajoutez des liens dans le pied de page (mentions légales, CGU, etc.)
• Backgrounds : image de fond personnalisée pour les pages de connexion

La personnalisation se fait dans System > Brands dans l'interface d'administration. Vous pouvez créer plusieurs "brands" et les associer à différents domaines, ce qui permet d'avoir une apparence différente selon le domaine d'accès.

Groupes et permissions

Gestion des groupes

Authentik supporte une gestion fine des groupes :

• Groupes hiérarchiques : les groupes peuvent avoir des groupes parents, créant une hiérarchie
• Groupes comme attributs OIDC : les groupes d'un utilisateur sont automatiquement inclus dans le token OIDC (claim "groups"), permettant aux applications de gérer les rôles basés sur les groupes Authentik
• Superuser : un attribut de groupe qui donne les droits administrateur Authentik
• Attributs personnalisés : chaque groupe peut avoir des attributs arbitraires (JSON) utilisables dans les Policies et les Providers

Mapping des rôles

Le mapping des rôles entre Authentik et les applications cibles se fait via les Scope Mappings et les Property Mappings. Par exemple, pour mapper les groupes Authentik aux rôles Grafana :

{
  "groups": ["grafana-admins", "grafana-editors"],
  "email": "user@mondomaine.fr",
  "name": "Jean Dupont",
  "preferred_username": "jdupont"
}

Côté Grafana, l'expression role_attribute_path utilise JMESPath pour extraire le rôle :

# Si l'utilisateur est dans le groupe grafana-admins -> Admin
# Si l'utilisateur est dans le groupe grafana-editors -> Editor
# Sinon -> Viewer
GF_AUTH_GENERIC_OAUTH_ROLE_ATTRIBUTE_PATH=contains(groups[*], 'grafana-admins') && 'Admin' || contains(groups[*], 'grafana-editors') && 'Editor' || 'Viewer'

API REST

Authentik expose une API REST complète avec une documentation Swagger/OpenAPI interactive accessible à https://auth.mondomaine.fr/api/v3/.

L'API permet de tout gérer programmatiquement :

# Créer un token API dans l'interface : Directory > Tokens > Create
# Type: API Token

# Lister les utilisateurs
curl -s "https://auth.mondomaine.fr/api/v3/core/users/" \
  -H "Authorization: Bearer VOTRE_TOKEN_API" | jq '.results[].username'

# Créer un utilisateur
curl -X POST "https://auth.mondomaine.fr/api/v3/core/users/" \
  -H "Authorization: Bearer VOTRE_TOKEN_API" \
  -H "Content-Type: application/json" \
  -d '{
    "username": "nouveau_user",
    "name": "Nouveau Utilisateur",
    "email": "nouveau@mondomaine.fr",
    "is_active": true,
    "groups": ["xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"]
  }'

# Lister les applications
curl -s "https://auth.mondomaine.fr/api/v3/core/applications/" \
  -H "Authorization: Bearer VOTRE_TOKEN_API" | jq '.results[].name'

# Lister les providers
curl -s "https://auth.mondomaine.fr/api/v3/providers/all/" \
  -H "Authorization: Bearer VOTRE_TOKEN_API" | jq '.results[] | {name, pk, type}'

# Vérifier la santé de l'instance
curl -s "https://auth.mondomaine.fr/api/v3/admin/system/" \
  -H "Authorization: Bearer VOTRE_TOKEN_API" | jq .

Outposts : déploiement avancé

Outpost Embedded

L'outpost embedded est intégré directement dans le serveur Authentik. C'est la méthode la plus simple : aucun conteneur supplémentaire à déployer. L'outpost embedded est automatiquement créé et supporte les modes Proxy et LDAP.

C'est la méthode recommandée pour les petites et moyennes installations.

Outpost Docker

Pour des installations plus importantes ou si vous avez besoin de séparer les charges :

# Ajouter un outpost proxy en tant que conteneur Docker séparé
services:
  authentik-proxy-outpost:
    image: ghcr.io/goauthentik/proxy:2025.2
    container_name: authentik-proxy-outpost
    restart: unless-stopped
    environment:
      AUTHENTIK_HOST: https://auth.mondomaine.fr
      AUTHENTIK_INSECURE: "false"
      AUTHENTIK_TOKEN: ${AUTHENTIK_OUTPOST_TOKEN}
    ports:
      - "9000:9000"  # HTTP
      - "9443:9443"  # HTTPS
    networks:
      - authentik-internal

Le token de l'outpost est généré automatiquement lors de la création de l'outpost dans l'interface d'administration, ou peut être récupéré dans Applications > Outposts.

Outpost Kubernetes

Pour les déploiements Kubernetes, Authentik peut gérer automatiquement les Outposts via l'API Kubernetes. Il crée les Deployments, Services et Ingress nécessaires. Cette fonctionnalité nécessite que le worker Authentik ait accès au cluster Kubernetes (via un ServiceAccount avec les permissions appropriées).

SAML 2.0

Authentik supporte pleinement SAML 2.0, tant en tant qu'Identity Provider (IdP) que pour la fédération avec d'autres IdP. La configuration SAML est similaire à OAuth2 :

1. Créez un SAML Provider dans Authentik
2. Configurez l'ACS URL (Assertion Consumer Service) de l'application
3. Configurez l'Issuer et l'Audience
4. Téléchargez les métadonnées SAML pour les importer dans l'application cible

Les métadonnées SAML sont disponibles à :

# URL des métadonnées SAML pour une application
https://auth.mondomaine.fr/api/v3/providers/saml/APPLICATION_SLUG/metadata/?download

Comparaison avec les alternatives

Quand choisir Authentik ?

• Vous voulez un IdP complet avec une interface moderne et intuitive
• Vous avez besoin de proxy authentication intégré (forward auth pour Nginx/Traefik)
• Vous voulez des flows d'authentification personnalisables visuellement
• Vous gérez un homelab ou une PME avec 10-500 utilisateurs
• Vous voulez du LDAP pour des applications legacy sans déployer un serveur LDAP séparé
• Vous préférez Python à Java pour la maintenance et les extensions

Quand choisir Keycloak plutôt ?

• Vous êtes dans un environnement enterprise avec des milliers d'utilisateurs
• Vous avez besoin de fonctionnalités avancées : User Federation complexe, Client Policies avancées, User Managed Access (UMA)
• Vous avez une équipe Java qui peut maintenir et étendre Keycloak via des SPI
• Vous avez besoin d'une certification OpenID Connect (Keycloak est certifié)

Quand choisir Authelia plutôt ?

• Vous avez besoin uniquement de forward auth (proxy authentication) pour Nginx/Traefik
• Vous voulez une solution ultra-légère (~50 Mo de RAM)
• Vous n'avez pas besoin d'OAuth2/OIDC comme Provider (Authelia a un support OIDC basique mais limité)
• Vous préférez une configuration 100% YAML sans interface web d'administration

Bonnes pratiques de production

Sécurité

• HTTPS obligatoire : Authentik doit toujours être derrière un reverse proxy HTTPS
• Clé secrète forte : la variable AUTHENTIK_SECRET_KEY doit être longue et aléatoire
• Mot de passe admin fort : le compte akadmin est la cible principale des attaques
• MFA pour les admins : activez obligatoirement le MFA pour les comptes administrateurs
• Rate limiting : Authentik inclut une Reputation Policy qui bloque les tentatives de brute force
• Audit logs : consultez régulièrement les événements dans Events > Logs

Sauvegardes

#!/bin/bash
# Script de sauvegarde Authentik
BACKUP_DIR="/opt/backups/authentik"
DATE=$(date +%Y%m%d_%H%M%S)

mkdir -p "$BACKUP_DIR"

# Sauvegarde de la base de données PostgreSQL
docker exec authentik-db pg_dump -U authentik authentik | \
  gzip > "$BACKUP_DIR/db_${DATE}.sql.gz"

# Sauvegarde des médias (logos, icônes uploadées)
docker cp authentik-server:/media - | \
  gzip > "$BACKUP_DIR/media_${DATE}.tar.gz"

# Sauvegarde du fichier .env
cp /opt/authentik/.env "$BACKUP_DIR/env_${DATE}.bak"

# Nettoyage des anciennes sauvegardes (+ de 30 jours)
find "$BACKUP_DIR" -type f -mtime +30 -delete

echo "Sauvegarde Authentik terminée : $BACKUP_DIR"

Monitoring

Authentik expose des métriques Prometheus sur le port 9300 par défaut. Vous pouvez les scraper avec Prometheus et les visualiser dans Grafana :

# prometheus.yml - Ajoutez la cible Authentik
scrape_configs:
  - job_name: 'authentik'
    static_configs:
      - targets: ['authentik-server:9300']

Les métriques incluent le nombre de connexions, les erreurs d'authentification, les temps de réponse, l'utilisation des Flows, et plus encore.

Haute disponibilité

Pour une haute disponibilité, vous pouvez déployer plusieurs instances du serveur Authentik et du worker derrière un load balancer. La base de données PostgreSQL et Redis doivent être externalisées et configurées en haute disponibilité (réplication, clustering).

# Exemple de scaling horizontal
services:
  server:
    image: ghcr.io/goauthentik/server:2025.2
    deploy:
      replicas: 3
    # ... reste de la configuration

  worker:
    image: ghcr.io/goauthentik/server:2025.2
    command: worker
    deploy:
      replicas: 2
    # ... reste de la configuration

Mises à jour

Authentik suit un cycle de release régulier avec des versions nommées par année et mois (ex: 2025.2). Les mises à jour se font simplement en changeant le tag de l'image Docker :

# Mettre à jour Authentik
cd /opt/authentik

# Modifier le tag dans docker-compose.yml
# De: ghcr.io/goauthentik/server:2025.1
# Vers: ghcr.io/goauthentik/server:2025.2

# Appliquer la mise à jour
docker compose pull
docker compose up -d

# Vérifier les logs pour les migrations
docker compose logs -f server

# Les migrations de base de données sont automatiques

Il est recommandé de sauvegarder la base de données avant chaque mise à jour et de lire les release notes pour les breaking changes éventuels.

Cas d'usage concrets

Homelab complet

Dans un homelab typique, Authentik centralise l'authentification pour tous vos services :

• Grafana : OAuth2/OIDC avec mapping des rôles par groupes
• Portainer : OAuth2 pour la gestion Docker
• Proxmox : OIDC pour l'hyperviseur
• Nextcloud : OIDC ou LDAP
• Jellyfin : LDAP (pas de support OIDC natif)
• Vaultwarden : Proxy authentication via forward auth
• Wiki.js : OIDC natif
• Gitea/Forgejo : OAuth2/OIDC
• Uptime Kuma : Proxy authentication
• Applications internes : Proxy authentication pour tout service web

L'utilisateur se connecte une seule fois sur Authentik et accède à tous ses services sans re-saisir ses identifiants.

PME / Startup

Pour une PME de 20-100 employés, Authentik fournit :

• SSO pour toutes les applications internes et SaaS (via SAML ou OIDC)
• MFA obligatoire pour la sécurité
• Self-service pour la réinitialisation des mots de passe (réduction des tickets support)
• Provisionnement automatique via SCIM vers les outils SaaS
• Audit trail complet pour la conformité

Éducation

Les établissements éducatifs peuvent utiliser Authentik pour :

• Fournir un portail SSO aux étudiants et au personnel
• Gérer les inscriptions via des Flows d'enrollment personnalisés
• LDAP pour les applications legacy (systèmes de gestion scolaire, imprimantes)
• Branding personnalisé avec le logo de l'établissement

Conclusion

Authentik s'impose en 2025-2026 comme une alternative crédible et moderne à Keycloak pour la gestion d'identité auto-hébergée. Son interface intuitive, sa consommation de ressources raisonnable, ses Flows visuels personnalisables et son proxy d'authentification intégré en font un choix excellent pour les homelabs, les PME et les équipes DevOps.

Le système de Flows, Stages et Policies offre une flexibilité remarquable pour modéliser n'importe quel parcours d'authentification, du plus simple au plus complexe. Le support multi-protocole (OAuth2/OIDC, SAML, LDAP, RADIUS, Proxy) garantit la compatibilité avec pratiquement toutes les applications, qu'elles soient modernes ou legacy.

L'écosystème Authentik est en pleine croissance, avec une communauté active, une documentation exemplaire et un rythme de développement soutenu. Si vous gérez plusieurs services et que vous en avez assez de jongler avec des dizaines de comptes différents, Authentik est probablement la solution qu'il vous faut.

L'installation avec Docker Compose prend moins de 15 minutes, et les intégrations avec les applications les plus courantes (Grafana, Portainer, Proxmox, Nextcloud, Traefik, Nginx) sont bien documentées. N'hésitez pas à commencer par quelques applications et à étendre progressivement votre déploiement.

Ressources utiles :
Site officiel : goauthentik.io
Documentation : docs.goauthentik.io
GitHub : github.com/goauthentik/authentik
Discord communautaire : discord.gg/jg33eMhnj6
Intégrations : docs.goauthentik.io/integrations
Blog : goauthentik.io/blog