---
title: Authentik
description: Installer Authentik comme fournisseur d'identité auto-hébergé, configurer le MFA et protéger vos services avec du SSO et l'authentification via reverse proxy.
---


:ellipsis{left=0px width=40rem top=10rem blur=140px zIndex=60}

::note

Authentik est une alternative avancée à [TinyAuth](/serveex/security/tinyauth) et [Pocket ID](/serveex/security/pocket-id) : une seule application qui assume à la fois le rôle de proxy forward-auth et de fournisseur OIDC, avec du LDAP, du SAML et des politiques d'accès de type RBAC intégrés (restreindre qui peut atteindre quelle application, pas seulement s'il est connecté), le tout par-dessus sa propre interface d'administration des utilisateurs, groupes et outposts. TinyAuth et Pocket ID restent plus légers et plus simples pour un petit homelab ; Authentik devient intéressant dès que vous avez besoin d'un contrôle d'accès plus fin ou d'une couverture de protocoles plus large qu'OIDC seul.
::

[Authentik](https://goauthentik.io) est un outil d'authentification unique (SSO) qui permet de se connecter une seule fois à toutes les plateformes compatibles OpenID. Il peut aussi sécuriser l'accès à vos services exposés en s'injectant via SWAG dans les requêtes vers ces services.

Par exemple, si vous exposez Dockge en ligne sur `dockge.mondomaine.fr`, vous arriverez d'abord sur une page de connexion Authentik. Si vous vous êtes déjà authentifié sur un autre service protégé par Authentik, vous n'aurez pas à vous reconnecter. Cela permet de ne s'authentifier qu'une fois par jour pour tous les services protégés.

Authentik gère aussi l'authentification multifacteur, dont le TOTP (un code généré par l'application d'authentification de votre choix). Il permet en outre de se connecter via un compte Microsoft ou Google, à condition d'avoir configuré l'une de ces applications.

C'est une excellente alternative au VPN pour exposer des services en toute sécurité, en particulier ceux qui n'ont ni MFA ni protection de connexion (le tableau de bord de SWAG par exemple).

Authentik dispose d'une [documentation fournie](https://docs.goauthentik.io/docs/installation/docker-compose) et de [très bons tutoriels de Cooptonian](https://www.youtube.com/@cooptonian). Ici, nous verrons les bases en prenant Dockge comme exemple.

Il y a deux modes principaux à connaître :

- Le premier permet aux applications gérant nativement le SSO compatible OpenID de se connecter directement à Authentik. C'est la méthode à privilégier, puisque l'application décide elle-même de ce qui est public et de ce qui est protégé.

![Picture](/img/serveex/auth-native.svg)

- La seconde méthode injecte l'authentification Authentik via SWAG avant d'atteindre le service cible.

![Picture](/img/serveex/auth-proxy.svg)

Les deux modes se configurent application par application.

## Installation

::file-tree
---
tree:
  /:
    - srv:
      - docker:
        - authentik:
          - .env
          - compose.yml
          - media/
          - certs/
          - custom-template/
          - ssh/
---
::

::steps{level="3"}
### Créer les dossiers

```bash [Terminal]
sudo mkdir -p /srv/docker/authentik/media /srv/docker/authentik/certs /srv/docker/authentik/custom-template /srv/docker/authentik/ssh
```

### Générer les secrets

Placez-vous dans le dossier `authentik` avec `cd /srv/docker/authentik` et générez un mot de passe et une clé secrète à inclure dans le fichier `.env` :

```bash [Terminal]
sudo echo "PG_PASS=$(openssl rand 36 | base64)" >> .env
sudo echo "AUTHENTIK_SECRET_KEY=$(openssl rand 60 | base64)" >> .env
```

::note

Pour générer les clés, nous avons créé les dossiers avant le déploiement par Dockge. Dockge vous empêchera de créer une stack du même nom dans ces dossiers tant qu'un fichier `compose.yml` n'existe pas. Créez donc un `compose.yml` vide pour qu'elle apparaisse comme stack inactive :
    ```bash [Terminal]
    sudo nano /srv/docker/authentik/compose.yml
    ```
::

### Déployer la stack

Ouvrez Dockge et cherchez « authentik » dans les stacks inactives.
Nommez la stack `authentik` et collez la configuration suivante, en remplaçant `{AUTHENTIK_TAG:-2026.2}`{lang=properties} par [la dernière version d'Authentik](https://goauthentik.io/docs/releases). 

```yaml [compose.yaml]
---
services:

  postgresql:
    image: docker.io/library/postgres:16-alpine
    container_name: authentik-postgresql
    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:
      - database:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: ${PG_PASS:?database password required}
      POSTGRES_USER: ${PG_USER:-authentik}
      POSTGRES_DB: ${PG_DB:-authentik}
    env_file:
      - .env

  redis:
    image: docker.io/library/redis: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:
      - redis:/data
  
  server:
    image: ${AUTHENTIK_IMAGE:-ghcr.io/goauthentik/server}:${AUTHENTIK_TAG:-2026.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}
    volumes:
      - ./media:/media
      - ./custom-templates:/templates
      - ./ssh:/authentik/.ssh
    env_file:
      - .env
    ports:
      - ${COMPOSE_PORT_HTTP:-9000}:9000
      - ${COMPOSE_PORT_HTTPS:-9443}:9443
    depends_on:
      - postgresql
      - redis

  worker:
    image: ${AUTHENTIK_IMAGE:-ghcr.io/goauthentik/server}:${AUTHENTIK_TAG:-2026.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}
    # `user: root` and the docker socket volume are optional.
    # See more for the docker socket integration here:
    # https://goauthentik.io/docs/outposts/integrations/docker
    # Removing `user: root` also prevents the worker from fixing the permissions
    # on the mounted folders, so when removing this make sure the folders have the correct UID/GID
    # (1000:1000 by default)
    user: root
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./media:/media
      - ./certs:/certs
      - ./custom-templates:/templates
      - ./ssh:/authentik/.ssh
    env_file:
      - .env
    depends_on:
      - postgresql
      - redis

volumes:
  database:
    driver: local
  redis:
    driver: local
```

### Démarrer la configuration initiale

Dans le fichier `.env`, les variables `PG_PASS` et `AUTHENTIK_SECRET_KEY` sont déjà renseignées.
Déployez la stack.

Vous pouvez ensuite commencer la configuration initiale en visitant :  
`http://ipdevotreserveur:9000/if/flow/initial-setup/`

::warning

__Attention :__ il est recommandé de créer un nouveau compte administrateur et de **désactiver** le compte `akadmin` par défaut.
::

### Terminé !
::

## Exposer Authentik
Pour utiliser Authentik en dehors de votre réseau local, vous devez l'exposer.

::note
📋 __Prérequis :__  <br/><br/>
Nous partons du principe que vous avez déjà créé un sous-domaine du type `auth.mondomaine.fr` dans votre [zone DNS](/general/networking/dns), avec un CNAME pointant vers `mondomaine.fr`. Par ailleurs, à moins d'utiliser [Cloudflare Zero Trust](/serveex/security/cloudflare), vous devez déjà avoir redirigé le port `443` de votre box vers le port `443` de votre serveur dans vos [règles NAT](/general/networking/nat).
::

::steps{level="3"}
### Vérifier authentik-server.conf

Ouvrez le fichier `authentik-server.conf` :

::tip{icon="" to="/serveex/files/file-browser-quantum"}
✨ __Astuce pour les allergiques au terminal :__
vous pouvez utiliser **File Browser Quantum** pour naviguer et modifier vos fichiers plutôt que des commandes dans le terminal.
::

```bash [Terminal]
sudo nano /srv/docker/swag/config/nginx/authentik-server.conf
```

Vérifiez que les variables suivantes sont correctement réglées :

```nginx [authentik-server.conf]
set $upstream_authentik authentik-server;
proxy_pass http://$upstream_authentik:9000;
```

Sinon, faites les modifications nécessaires, puis enregistrez avec :kbd{value="Ctrl+O"}, :kbd{value="Enter"}, et quittez avec :kbd{value="Ctrl+X"}.

### Créer le fichier subdomain.conf

Créez le fichier `auth.subdomain.conf` :

```bash [Terminal]
sudo nano /srv/docker/swag/config/nginx/proxy-confs/auth.subdomain.conf
```

Collez la configuration suivante :

```nginx [auth.subdomain.conf]
## Version 2023/05/31
# Ensure your authentik container is named authentik-server
# Ensure your DNS has a CNAME for authentik

server {
    listen 443 ssl;
    listen [::]:443 ssl;

    server_name auth.*;

    include /config/nginx/ssl.conf;

    client_max_body_size 0;

    location / {
        include /config/nginx/proxy.conf;
        include /config/nginx/resolver.conf;
        set $upstream_app authentik-server;
        set $upstream_port 9000;
        set $upstream_proto http;
        proxy_pass $upstream_proto://$upstream_app:$upstream_port;
    }

    location ~ (/authentik)?/api {
        include /config/nginx/proxy.conf;
        include /config/nginx/resolver.conf;
        set $upstream_app authentik-server;
        set $upstream_port 9000;
        set $upstream_proto http;
        proxy_pass $upstream_proto://$upstream_app:$upstream_port;
    }
}
```

Enregistrez avec :kbd{value="Ctrl+O"}, puis :kbd{value="Enter"}, et quittez avec :kbd{value="Ctrl+X"}.

### Ajouter le réseau d'Authentik à SWAG

Allez dans Dockge, et modifiez le fichier compose de SWAG pour y ajouter le réseau d'Authentik :

```yaml [compose.yaml]
---
services:
  swag:
     container_name: # ...
      # ...
     networks:               # Attach the container to the custom network
      # ...           
      - authentik            # Name of the network declared in the stack

networks:                    # Define the custom network
  # ...
  authentik:                 # Name of the network declared in the stack
    name: authentik_default  # Actual name of the external network
    external: true           # Indicates it's an external network
```

Redémarrez la stack et attendez que SWAG soit pleinement opérationnel.

### Terminé !
::

Vous pouvez maintenant accéder à Authentik via `https://auth.mondomaine.fr`

## Activer l'authentification multifacteur
Le principal intérêt d'Authentik est d'utiliser l'authentification multifacteur pour toutes les applications protégées.

::steps{level="3"}
### Se connecter à Authentik

Allez sur `https://auth.mondomaine.fr` et connectez-vous.

### Enregistrer une méthode MFA

Allez dans _Settings_, cliquez sur la section _MFA_, puis sur _Register_. Choisissez une méthode comme _TOTP device_ (il vous faudra une application d'authentification du type Google Authenticator) et suivez les étapes.

### Terminé !
::

Un code à usage unique vous sera désormais demandé à chaque connexion.

## Protéger une app native
Authentik est nativement compatible avec plusieurs applications. Vous trouverez la liste et [le support ici](https://docs.goauthentik.io/integrations/services/).

## Protéger une app par reverse proxy
SWAG permet d'insérer la page de connexion d'Authentik entre une requête et l'accès à votre service. Pour cela :

- Configurez le fournisseur d'authentification dans Authentik.
- Modifiez le fichier proxy du domaine pour que SWAG intercepte la requête.

Pourquoi faire cela alors que Dockge a déjà une authentification ? Parce que Dockge utilise une authentification HTTP faible. Avec Authentik, vous obtenez une authentification MFA robuste et une connexion automatique à toutes les applications protégées par Authentik. Cela sécurise l'accès à Dockge et aux autres applications sans avoir besoin d'un VPN.

::steps{level="3"}
### Configuration d'Authentik

- Allez dans Authentik
- Ouvrez le panneau d'administration
- Choisissez _Applications_ puis _Create with wizard_
- Remplissez les champs comme suit :

![Picture](/img/serveex/auth1.png)

- À l'étape suivante, choisissez « Forward authentication (single application) » et configurez comme suit (les flows sont importants) :

![Picture](/img/serveex/auth2.png)

- Ensuite, allez dans le menu _Outposts_ à gauche et modifiez _authentik Embedded Outpost_ :

![Picture](/img/serveex/auth3.png)

- Ajoutez l'application `dockge` en la déplaçant dans la colonne de droite et enregistrez.

### Configuration de SWAG

Modifiez le fichier `dockge.mondomaine.fr` :

```bash [Terminal]
sudo nano /srv/docker/swag/config/nginx/proxy-confs/dockge.subdomain.conf
```

Décommentez les deux lignes `#include /config/nginx/authentik-server.conf;`

Appuyez sur :kbd{value="Ctrl+O"}, puis :kbd{value="Enter"} pour enregistrer, et :kbd{value="Ctrl+X"} pour quitter.

::tip{icon=""}
✨ __Astuce :__ dans les réglages de Dockge, vous pouvez désactiver l'authentification de Dockge pour éviter une double connexion. **Attention** : cela signifie que si le port est ouvert sur votre réseau local, il n'y aura plus aucune authentification.
::

### Terminé !
::

Désormais, en accédant à `https://dockge.mondomaine.fr`, vous serez redirigé vers l'écran de connexion d'Authentik.

::note

Répétez cette procédure pour chaque application que vous voulez protéger (sauf si elle a une intégration native avec Authentik).
::

Votre nouvelle architecture ressemble à ceci :

![Picture](/img/serveex/authentik.svg)

## Protéger un service sur un serveur distant
Pour une [application native](/serveex/advanced/authentik/#protecting-a-native-app) (via OAuth 2.0 ou autre), rien ne change.

Pour une application non native derrière un reverse proxy, vous devez déployer un __Outpost__. Un Outpost est un conteneur qui fait office de proxy local. C'est la cible des requêtes d'authentification de votre application, et le seul autorisé à communiquer avec votre API Authentik.

::note
Prérequis :

- Installer [Docker](/serveex/core/docker) sur le serveur distant qui héberge le service.
- Si l'application n'a pas d'intégration native, utiliser un reverse proxy compatible. Nous utiliserons [SWAG](/serveex/core/swag) ici.
::

Ce conteneur transmettra les requêtes à votre instance [Authentik](/serveex/advanced/authentik#authentik) principale via internet (ou votre réseau local). Le serveur effectuera les vérifications et répondra à l'Outpost, qui autorisera ou bloquera l'accès en conséquence.

![auth-outpost](/img/serveex/auth-outpost.svg)

::steps{level="3"}
### Configuration d'Authentik

Créez vos [providers et applications](/serveex/advanced/authentik/#protecting-a-native-app) comme montré plus haut.

Puis, dans le panneau d'administration, allez dans _Applications > Outposts_, et créez un nouvel outpost.

Remplissez comme suit :

| Champ           | Valeur                                                                 |
|----------------|------------------------------------------------------------------------|
| `Name`         | Le nom de votre choix                                                  |
| `Type`         | `Proxy`                                                                |
| `Integration`  | Laisser vide                                                           |
| `Applications` | Sélectionnez les applications créées précédemment                      |

Dans la section `Advanced settings`, effacez le contenu existant et saisissez :

```yaml
log_level: info
docker_labels: null
authentik_host: https://your_authentik_server_domain/
object_naming_template: ak-outpost-%(name)s
authentik_host_insecure: false
container_image:
docker_network: null
docker_map_ports: true
docker_labels: null
```

Enregistrez avec :kbd{value="Ctrl+O"}, puis :kbd{value="Enter"}, et quittez avec :kbd{value="Ctrl+X"}.

Dans la liste des outposts créés, repérez le nouveau et cliquez sur _Show details_ en fin de ligne. Copiez soigneusement le token d'accès.

Nous partons du principe que vous avez déjà installé [Docker](/serveex/core/docker) et [SWAG](/serveex/core/swag) sur cette machine distante. Voici comment la configurer :

### Créer le dossier de la stack

Sur votre machine distante, utilisez [Dockge](/serveex/core/docker/#installer-dockge-pour-gérer-et-déployer-les-conteneurs) pour créer une stack nommée `authentik-outpost`.

Si vous n'avez pas installé [Dockge](/serveex/core/docker/#installer-dockge-pour-gérer-et-déployer-les-conteneurs), créez un dossier `/srv/docker/authentik-outpost`, ou directement en ligne de commande :

```bash [Terminal]
sudo mkdir -P /srv/docker/authentik-outpost
```

::tip{icon="" to="/serveex/files/file-browser-quantum"}
✨ __Astuce pour les allergiques au terminal :__
vous pouvez utiliser **File Browser Quantum** pour naviguer et modifier vos fichiers plutôt que des commandes dans le terminal.
::

### Créer le fichier compose

Créez le fichier `compose.yaml` ou collez la configuration directement dans Dockge s'il est installé.

En ligne de commande :

```bash [Terminal]
sudo nano /srv/docker/authentik-outpost/compose.yaml
```
Collez la configuration suivante, en mettant à jour la version dans `{AUTHENTIK_TAG:proxy:2024.2.3}`{lang=properties} pour correspondre à celle de votre serveur Authentik.

```yaml [compose.yaml]
---
version: "3.5"
services:
  authentik_proxy:
    container_name: authentik-outpost
    image: ghcr.io/goauthentik/proxy:2024.2.3
    # Optionally specify which networks the container should be
    # might be needed to reach the core authentik server
    restart: unless-stopped
    env_file:
      - .env
    ports:
      - 9000:9000
      - 9443:9443
    environment:
      AUTHENTIK_HOST: ${HOST}
      AUTHENTIK_INSECURE: "false"
      AUTHENTIK_TOKEN: ${TOKEN}
```

### Ajouter le réseau de l'outpost à SWAG

Allez sur la stack SWAG de la machine distante (ou modifiez-la directement dans Dockge) et ajoutez le réseau authentik-outpost dans le fichier de configuration comme suit (voir la section `networks`) :

```bash [Terminal]
sudo nano /srv/docker/swag/compose.yaml
```

```yaml [compose.yaml]
---
services:
  swag:
     container_name: #...
      # ... 
     networks:                      # Attach the container to the custom network

      - authentik-outpost           # Network name as declared in the stack

networks:                           # Define the custom network
  #...
  authentik-outpost:                # Name of the network declared in the stack
    name: authentik-outpost_default # Actual name of the external network
    external: true                  # Marks it as an external network
```

Appuyez sur :kbd{value="Ctrl+O"}, puis :kbd{value="Enter"} pour enregistrer, et :kbd{value="Ctrl+X"} pour quitter.

::note

Nous partons du principe que le nom du réseau de Dockge est `authentik-outpost_default`.
::

### Redémarrer SWAG

Si vous utilisez [Dockge](/serveex/core/docker/#installer-dockge-pour-gérer-et-déployer-les-conteneurs), redémarrez SWAG.

Sinon, via le terminal :

```bash [Terminal]
cd /srv/docker/swag/
sudo docker compose up -d
```

### Renseigner vos variables d'environnement

Créez (ou remplissez via Dockge) le fichier `.env` dans le dossier `authentik-outpost` :

En ligne de commande :

```bash [Terminal]
sudo nano /srv/docker/authentik-outpost/.env
```

Collez la configuration suivante :

```properties [.env]
HOST=
TOKEN=
```

Renseignez les valeurs :

| Variable | Valeur | Exemple |
|----------|-------|---------|
| `HOST`{lang=properties} | L'URL de votre serveur Authentik | `https://auth.domaine.fr` |
| `TOKEN`{lang=properties} | Le token d'accès copié précédemment | `Q2pVEqsTNRkJSO9SkJzU3KZ2` |

Appuyez sur :kbd{value="Ctrl+O"}, puis :kbd{value="Enter"} pour enregistrer, et :kbd{value="Ctrl+X"} pour quitter.

### Déployer la stack

Si vous utilisez Dockge, déployez la stack.

Sinon, via le terminal :

```bash [Terminal]
cd /srv/docker/authentik-outpost/
sudo docker compose up -d
```

Le conteneur tourne à présent. Vous pouvez vérifier son état depuis le panneau d'administration de votre instance Authentik, dans _Applications > Outposts_.

### Pointer SWAG vers l'outpost

Configurons maintenant SWAG.

Ouvrez le fichier `authentik-server.conf` :

```bash [Terminal]
sudo nano /srv/docker/swag/config/nginx/authentik-server.conf
```

Dans le fichier, remplacez `authentik-server` par `authentik-outpost` comme suit :

```nginx [authentik-server.conf]
set $upstream_authentik authentik-outpost;
proxy_pass http://$upstream_authentik:9000;
```

Enregistrez avec :kbd{value="Ctrl+O"}, puis :kbd{value="Enter"}, et quittez avec :kbd{value="Ctrl+X"}.

### Terminé !
::

Configurez ensuite les applications à protéger comme vous l'avez fait sur votre serveur principal, qu'elles soient [natives](/serveex/advanced/authentik/#protecting-a-native-app) ou protégées via [reverse proxy](/serveex/advanced/authentik#protecting-an-app-via-reverse-proxy).

## Migrer une base de données Authentik

::note

Les commandes ci-dessous partent du principe que le conteneur Postgres s'appelle `authentik-postgresql`, comme dans la section [Installation](#installation) plus haut. Adaptez si vous l'avez renommé.
::

::steps{level="3"}
### Exporter la base

Sur la machine source, exportez la base :

```bash [Terminal]
sudo docker exec authentik-postgresql pg_dump -U authentik -F t authentik > /chemin/vers/mabase.tar
```

### Transférer l'export

Transférez-le sur la machine cible, puis copiez le fichier dans le conteneur Docker :

```bash [Terminal]
cp /chemin/vers/mabase.tar authentik-postgresql:/chemin/vers/ou-vous-voulez
```

### Purger les tables existantes

(Facultatif) Purgez les tables existantes :

```bash [Terminal]
sudo docker exec -i authentik-postgresql psql -U authentik -c "SELECT pg_terminate_backend(pg_stat_activity.pid) FROM pg_stat_activity WHERE pg_stat_activity.datname = 'authentik' AND pid <> pg_backend_pid();" && sudo docker exec -i authentik-postgresql psql -U authentik -d postgres -c "DROP DATABASE IF EXISTS authentik;" && sudo docker exec -i authentik-postgresql psql -U authentik -d postgres -c "CREATE DATABASE authentik;"
```

### Restaurer la base

Restaurez la base :

```bash [Terminal]
sudo docker exec authentik-postgresql pg_restore -U authentik -d authentik /chemin/vers/ou-vous-voulez/mabase.tar
```

### Terminé !
::
