Djeex/docudjeex
1
1
Fork 0
Code Issues Pull Requests Projects Wiki Activity

Complete the French mirror of the remaining articles

Browse Source
This commit is contained in:
Djeex
2026-09-05 17:55:36 +02:00
parent 1894ac7ead
commit 2e041bcfb0
11 changed files with 1928 additions and 1249 deletions
Download Patch File Download Diff File Expand all files Collapse all files
content/fr/3.serveex/91.advanced/1.authentik.md
+216 -152
View File
@@ -6,64 +6,79 @@ description: Installer Authentik comme fournisseur d'identité auto-hébergé, c
:ellipsis{left=0px width=40rem top=10rem blur=140px zIndex=60}
[Authentik](https://goauthentik.io) est un outil d'authentification unique permettant de vous logger une seule fois sur les plateformes compatibles OpenID. Il permet également de sécuriser l'accès aux services que vous exposez, en s'injectant via SWAG aux requetes vers vos services.
::note
Ainsi, si vous exposez Dockge sur internet via `dockge.mondomaine.fr`, au moment de l'accès à cette page, vous tomberez sur une page de login d'authentik. Si vous avez déjà été identifié sur un autre service sécurisé par authentik auparavant, alors vous serez déjà identifié. cela permet d'avoir à vous identifiez qu'une seule fois par jour sur l'ensemble des services protégés par authentik.
C'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 vaut la configuration supplémentaire 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 permet aussi d'utiliser le multi-facteur, notamment par TOTP (code généré par une application d'authentification de votre choix. Enfin, authentik permet aussi de se connecter directement via un compte Microsoft ou Google, si vous avez configuré une application d'un de ces services.
[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.
C'est une bonne manière de se passer de VPN pour exposer vos services, et d'exposer des services qui ne sont pas protégés par du MFA voir pas protégés par des login (comme le dashboard de swag).
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 dipose d'[une doc très fournie](https://docs.goauthentik.io/docs/installation/docker-compose) et des [fabuleux tuto de Cooptonian](https://www.youtube.com/@cooptonian). Ici, nous montrerons juste les bases, avec l'exemple de l'exposition de Dockge.
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.
Deux modes principaux sont à connaitre:
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).
- Le premier permet à une application qui dispose nativement d'une intégration avec du SSO compatible OpenID de se connecter directement à Authentik. C'est la solution à privilégier car elle permet de laisser l'application décider de ce qui est public et de ce qui est protégé.
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)
- Le second permet d'injecter une authentification via authentik grace à SWAG avant d'arriver sur le service désiré.
- 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 son configurables application par application.
Les deux modes se configurent application par application.
## Installation
Structure des dossiers :
```text [Arborescence]
root
└── docker
└── authentik
├── .env
├── compose.yml
├── media
├── certs
├── custom-template
└── ssh
```
Créez les dossiers :
::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
```
Positionnez vous dans le dossier `authentik` via `cd /srv/docker/authentik` et générez un mot de passe et une clé secrete que l'on va intégrer dans le .env :
### 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
Afin de générer la clé, nous avons créé les dossiers en amont du déploiement via Dockge. Dockge vous empechera de créer une stack du meme nom dans ces dossiers s'il n'existe pas de `compose.yml`. Il faut donc créer un `compose.yml` vide afin que ce dernier la reconnaisse comme existante dans les stacks inactives :
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
```
::
Ouvrez dockge, et cherchez "authentik" dans les stack inactives.
Nommez la stack authentik et collez la configuration suivante, en changeant les chiffres de `{AUTHENTIK_TAG:-2026.2}`{lang=properties} par [la dernière version de Authentik](https://goauthentik.io/docs/releases).
### 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]
---
@@ -105,7 +120,7 @@ services:
timeout: 3s
volumes:
- redis:/data
server:
image: ${AUTHENTIK_IMAGE:-ghcr.io/goauthentik/server}:${AUTHENTIK_TAG:-2026.2}
container_name: authentik-server
@@ -167,57 +182,67 @@ volumes:
driver: local
```
Dans le point `.env`, les variables `PG_PASS` et `AUTHENTIK_SECRET_KEY` sont déjà remplies.
### 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 alors commencer le set-up d'authentik en tappant `http://ipduserveur:9000/if/flow/initial-setup/`.
Vous pouvez ensuite commencer la configuration initiale en visitant :
`http://ipdevotreserveur:9000/if/flow/initial-setup/`
::warning
__Attention :__ il est conseillé de créer un nouveau compte admin, et de **désactiver** le compte admin de base `akadmin`.
__Attention :__ il est recommandé de créer un nouveau compte administrateur et de **désactiver** le compte `akadmin` par défaut.
::
## Exposer authentik
Pour être utilisable hors de chez vous, vous devez exposer authentik.
### Terminé !
::
## Exposer Authentik
Pour utiliser Authentik en dehors de votre réseau local, vous devez l'exposer.
::note
📋 __Au préalable :__ <br/><br/>
Nous partons du principe quer vous avez créé dans votre [zone DNS](/general/networking/dns) un sous domaine du type `auth.mondomaine.fr` avec pour CNAME `mondomaine.fr` et, [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/security/cloudflare), vous avez déjà redirigé le port `443` de votre box vers le `443` de votre serveur dans [les règles NAT](/general/networking/nat).
📋 __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).
::
Ouvrez le fichier `authentik-server.conf`.
::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 dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du 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 dans chaque cas les variables ci-dessous sont correctes :
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;
```
Si ce n'est pas le cas, éditez-les, puis enregistrez avec :kbd{value="Ctrl+O"} et :kbd{value="Entrée"}, et quittez avec :kbd{value="Ctrl+X"}.
Sinon, faites les modifications nécessaires, puis enregistrez avec :kbd{value="Ctrl+O"}, :kbd{value="Enter"}, et quittez avec :kbd{value="Ctrl+X"}.
Créez le fichier `auth.subdomain.conf`
### 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
# make sure that your authentik container is named authentik-server
# make sure that your dns has a cname set for authentik
# Ensure your authentik container is named authentik-server
# Ensure your DNS has a CNAME for authentik
server {
listen 443 ssl;
@@ -230,14 +255,12 @@ server {
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 {
@@ -247,143 +270,156 @@ 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="Entrée"}, puis quittez avec :kbd{value="Ctrl+X"}.
Enregistrez avec :kbd{value="Ctrl+O"}, puis :kbd{value="Enter"}, et quittez avec :kbd{value="Ctrl+X"}.
Rendez-vous dans dockge, et éditez le compose de SWAG en ajoutant le réseau d'Authentik :
### 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: # Relie le conteneur au réseau custom
# ...
networks: # Attach the container to the custom network
# ...
- authentik # Nom du réseau déclaré dans la stack
- authentik # Name of the network declared in the stack
networks: # Définit le réseau custom
networks: # Define the custom network
# ...
authentik: # Nom du réseau déclaré dans la stack
name: authentik_default # Nom véritable du réseau externe
external: true # Précise que c'est un réseau à rechercher en externe
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
```
Relancez la stack et patientez le temps que SWAG soit complètement opérationnel.
Redémarrez la stack et attendez que SWAG soit pleinement opérationnel.
Et voilà ! Vous pouvez accéder à authentik via `https://auth.mondomaine.fr`
### Terminé !
::
## Activer le multifacteur
Tout l'intérêt de authentik c'est de disposer du multifacteur pour toutes les apps que l'on protègera.
Vous pouvez maintenant accéder à Authentik via `https://auth.mondomaine.fr`
- Rendez vous sur `https://auth.mondomaine.fr`
- Identifiez-vous
- Rendez-vous dans _paramètres_
- Cliquez sur la section _MFA_
- Cliquez sur _s'inscrire_
- Choisissez une méthode comme _TOTP device_ ( dans ce cas vous devrez utilisez une app d'authentification telle que Google Authenticator par exemple)
- Suivez les étapes
## Activer l'authentification multifacteur
Le principal intérêt d'Authentik est d'utiliser l'authentification multifacteur pour toutes les applications protégées.
Et voilà, vous serez invité à saisir un code à usage unique à chaque connexion.
::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 compatible nativement avec un certain nombre d'application, vous retrouverez la liste et [le support ici](https://docs.goauthentik.io/integrations/services/)
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'intercaler la page d'authentik entre la requête et l'accès à votre service. Pour cela il va falloir :
SWAG permet d'insérer la page de connexion d'Authentik entre une requête et l'accès à votre service. Pour cela :
- Configurer le service d'authentification dans authentik.
- Configurer le fichier proxy du domaine pour que swag puisse intercaler la page.
- Configurez le fournisseur d'authentification dans Authentik.
- Modifiez le fichier proxy du domaine pour que SWAG intercepte la requête.
Pourquoi le faire alors que Dockge a déjà une page d'authentification ? Tout simplement parce que l'authentification HTTP utilisée par Dockge est faible. Avec Authentik, vous aurez directement une authentification forte par MFA, et vous serez loggé automatiquement à toutes vos apps déjà protégées par authentik. Cela permet de sécuriser l'accès à Dockge et aux autres apps que vous protégerez, sans avoir à passer par un VPN.
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.
### Configuration de Authentik
::steps{level="3"}
### Configuration d'Authentik
- Rendez vous dans Authentik
- Allez dans le panneau d'administration
- Sélectionnez _application_ puis _créer avec l'assistant_
- Renseignez les champs comme suit :
- Allez dans Authentik
- Ouvrez le panneau d'administration
- Choisissez _Applications_ puis _Create with wizard_
- Remplissez les champs comme suit :
![Picture](/img/serveex/auth1.png)
- Puis à l'étape suivante choisissez "Transférer l'authentification (application unique)" et éditez comme suit (attention aux flow, c'est important) :
- À 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 à gauche dans _Avant-poste_ et éditez _authentik Embedded Outpost_
- Ensuite, allez dans le menu _Outposts_ à gauche et modifiez _authentik Embedded Outpost_ :
![Picture](/img/serveex/auth3.png)
- Ajoutez l'application `dockge` en la faisant passer à droite et validez.
- Ajoutez l'application `dockge` en la déplaçant dans la colonne de droite et enregistrez.
### Configuration de SWAG
Ensuite rendez-vous dans le fichier `dockge.mondomaine.fr`.
Modifiez le fichier `dockge.mondomaine.fr` :
```bash [Terminal]
sudo nano /srv/docker/swag/config/nginx/proxy-confs/dockge.subdomain.conf
```
Puis enlevez les `#` des deux lignes `#include /config/nginx/authentik-server.conf;`{lang=nginx}.
Décommentez les deux lignes `#include /config/nginx/authentik-server.conf;`
Enregistrez avec :kbd{value="Ctrl+O"} puis :kbd{value="Entrée"}, puis quittez avec :kbd{value="Ctrl+X"}.
Et voilà ! En tapant `https://dockge.mondomaine.fr`, vous tomberez à présent sur la mire d'authentification de authentik.
Appuyez sur :kbd{value="Ctrl+O"}, puis :kbd{value="Enter"} pour enregistrer, et :kbd{value="Ctrl+X"} pour quitter.
::tip{icon=""}
✨ __Astuce :__ dans Dockge, dans les paramètres, vous pouvez désactiver l'authentification de Dockge afin de ne pas avoir à vous identifier deux fois. **Attention**, cela voudra dire que si vous avez exposé un port sur votre réseau local, il n'y aura plus aucune authentification.
✨ __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
Vous pouvez répétez l'opération pour chaque application que vous souhaitez protéger (si elle ne dipose pas d'intégration directe avec Authentik).
Répétez cette procédure pour chaque application que vous voulez protéger (sauf si elle a une intégration native avec Authentik).
::
Voilà votre nouvelle architecture :
Votre nouvelle architecture ressemble à ceci :
![Picture](/img/serveex/authentik.svg)
## Protéger un service sur un serveur distant
Dans le cas d'une application [native](/serveex/advanced/authentik#protéger-une-app-native) (via OAuth 2.0 ou autre), rien ne change.
Pour une [application native](/serveex/advanced/authentik/#protecting-a-native-app) (via OAuth 2.0 ou autre), rien ne change.
Dans le cas d'une application non native à protéger derrière un reverse proxy, vous devrez déployer un __avant-poste__. Un avant-poste est un conteneur qui jouera le rôle de proxy local, c'est à dire que c'est vers ce conteneur que les requêtes d'authentification de vos applications seront redirigées. C'est le seul qui est autorisé à dialoguer avec l'API de votre instance authentik.
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 :
Prérequis :
- Avoir installé [docker](/serveex/core/docker) sur votre machine distante hébergeant le service à protéger.
- Si l'application n'a pas d'intégration native, avoir un reverse proxy compatible. Comme partout ici, nous utiliserons [SWAG](/serveex/core/swag).
- 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 redirigera ensuite les requetes vers votre instance [Authentik](/serveex/advanced/authentik#authentik) principale, à travers le web (ou votre réseau local). Le serveur executera les controle et renverra la réponse à l'_avant-poste_, qui bloquera ou non la connexion à l'app protégée.
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 [fournisseurs et applications](/serveex/advanced/authentik#protéger-une-app-native) comme nous l'avons vu plus haut.
Créez vos [providers et applications](/serveex/advanced/authentik/#protecting-a-native-app) comme montré plus haut.
Puis, dans votre panneau admin, allez dans la rubrique _Applications > Avant-postes_, puis créez un nouvel avant-poste.
Puis, dans le panneau d'administration, allez dans _Applications > Outposts_, et créez un nouvel outpost.
Remplissez comme suit :
| Champs | Valeur |
|----------------|-----------------------------------------------------------------------|
| `Nom` | Le nom que vous souhaitez |
| `Type` | `Proxy` |
| `Intégration` | Laissez vide |
| `Applications` | Sélectionnez le ou les applications que vous avez créées précédemment |
| 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 `Paramètres avancés`, supprimez l'existant, et complétez comme suit :
Dans la section `Advanced settings`, effacez le contenu existant et saisissez :
```yaml
log_level: info
docker_labels: null
authentik_host: https://domaine_de_votre_serveur_authentik/
authentik_host: https://your_authentik_server_domain/
object_naming_template: ak-outpost-%(name)s
authentik_host_insecure: false
container_image:
@@ -392,17 +428,17 @@ docker_map_ports: true
docker_labels: null
```
Enrtegistrez et quittez.
Enregistrez avec :kbd{value="Ctrl+O"}, puis :kbd{value="Enter"}, et quittez avec :kbd{value="Ctrl+X"}.
Sur l'écran affichant les avant-postes créés, vous verrez le nouvel avant-poste que vous venez de créer. A la fin de la ligne, cliquez sur _afficher les informations_, et copiez précieusement le jeton d'accès.
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.
### Configuration de la machine distante
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 :
Nous partons du principe que vous avez déjà installé [Docker](/serveex/core/docker) et [SWAG](/serveex/core/swag) sur cette machine distante.
### Créer le dossier de la stack
Sur votre machine distante, à l'aide de [Dockge](/serveex/core/docker#installer-dockge-pour-gérer-et-déployer-les-conteneurs), créez une stack `authentik-outpost`.
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 :
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
@@ -410,17 +446,19 @@ 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 dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
vous pouvez utiliser **File Browser Quantum** pour naviguer et modifier vos fichiers plutôt que des commandes dans le terminal.
::
Créez le fichier `compose.yaml` ou copiez la configuration directement dans le champs si vous avez [Dockge](/serveex/core/docker#installer-dockge-pour-gérer-et-déployer-les-conteneurs)
### 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 changeant les chiffres de `{AUTHENTIK_TAG:proxy:2024.2.3}`{lang=properties} par la meme version que celle de votre serveur Authentik.
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]
---
@@ -434,7 +472,6 @@ services:
restart: unless-stopped
env_file:
- .env
# - foo
ports:
- 9000:9000
- 9443:9443
@@ -442,12 +479,11 @@ services:
AUTHENTIK_HOST: ${HOST}
AUTHENTIK_INSECURE: "false"
AUTHENTIK_TOKEN: ${TOKEN}
# Starting with 2021.9, you can optionally set this too
# when authentik_host for internal communication doesn't match the public URL
# AUTHENTIK_HOST_BROWSER: https://external-domain.tld
```
Rendez-vous sur la stack de SWAG de la machine distante (ou remplissez directement si vous avez [Dockge](/serveex/core/docker#installer-dockge-pour-gérer-et-déployer-les-conteneurs)) et ajoutez le réseau de authentik-outpost dans le fichier de conf sur ce modele (les champs `networks`) :
### 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
@@ -459,25 +495,27 @@ services:
swag:
container_name: #...
# ...
networks: # Relie le conteneur au réseau custom
networks: # Attach the container to the custom network
- authentik-outpost # Nom du réseau déclaré dans la stack
- authentik-outpost # Network name as declared in the stack
networks: # Définit le réseau custom
networks: # Define the custom network
#...
authentik-outpost: # Nom du réseau déclaré dans la stack
name: authentik-outpost_default # Nom véritable du réseau externe
external: true # Précise que c'est un réseau à rechercher en externe
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
```
Enregistrez avec :kbd{value="Ctrl+O"} puis :kbd{value="Entrée"}, puis quittez avec :kbd{value="Ctrl+X"}.
Appuyez sur :kbd{value="Ctrl+O"}, puis :kbd{value="Enter"} pour enregistrer, et :kbd{value="Ctrl+X"} pour quitter.
::note
Ici nous partons du principe que le nom du réseau de dockge est `authentik-outpost_default`.
Nous partons du principe que le nom du réseau de Dockge est `authentik-outpost_default`.
::
Si vous avez [Dockge](/serveex/core/docker#installer-dockge-pour-g"rer-et-d"ployer-les-conteneurs), relancez SWAG.
### 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 :
@@ -486,7 +524,9 @@ cd /srv/docker/swag/
sudo docker compose up -d
```
Creez (ou remplissez directement si vous avez [Dockge](/serveex/core/docker#installer-dockge-pour-gérer-et-déployer-les-conteneurs)) le fichier `.env` dans le dossier de l'avant poste authentik :
### Renseigner vos variables d'environnement
Créez (ou remplissez via Dockge) le fichier `.env` dans le dossier `authentik-outpost` :
En ligne de commande :
@@ -494,22 +534,25 @@ En ligne de commande :
sudo nano /srv/docker/authentik-outpost/.env
```
Collez la configuration suivante
Collez la configuration suivante :
```properties [.env]
HOST=
TOKEN=
```
Remplissez comme suit
| Variable | Valeur | Exemple |
|-------------------------|---------------------------------------------------------|----------------------------|
| `HOST`{lang=properties} | L'url de votre serveur authentik | `https://auth.domaine.fr` |
| `TOKEN`{lang=properties} | Le token que vous avez précédemment copié précieusement | `Q2pVEqsTNRkJSO9SkJzU3KZ2` |
Renseignez les valeurs :
Enregistrez avec :kbd{value="Ctrl+O"} puis :kbd{value="Entrée"}, puis quittez avec :kbd{value="Ctrl+X"}.
| 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` |
Si vous avez [Dockge](/serveex/core/docker#installer-dockge-pour-g"rer-et-d"ployer-les-conteneurs), déployez la stack.
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 :
@@ -518,50 +561,71 @@ cd /srv/docker/authentik-outpost/
sudo docker compose up -d
```
Le conteneur est en route, vous pouvez vérifier son état dans votre panneau admin de votre instance Authentik, section _Applications > Avant-postes_.
Le conteneur tourne à présent. Vous pouvez vérifier son état depuis le panneau d'administration de votre instance Authentik, dans _Applications > Outposts_.
Nous allons a présent configurer SWAG.
### Pointer SWAG vers l'outpost
Ouvrez le fichier `authentik-server.conf`.
Configurons maintenant SWAG.
Ouvrez le fichier `authentik-server.conf` :
```bash [Terminal]
sudo nano /srv/docker/swag/config/nginx/authentik-server.conf
```
Dans le fichier, changez `authentik-server` par `authentik-outpost` comme suit :
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="Entrée"}, puis quittez avec :kbd{value="Ctrl+X"}.
Enregistrez avec :kbd{value="Ctrl+O"}, puis :kbd{value="Enter"}, et quittez avec :kbd{value="Ctrl+X"}.
Ensuite, configurez les applications à protéger selon si elles sont [natives](/serveex/advanced/authentik#protéger-une-app-native) ou par [proxy](/serveex/advanced/authentik#protéger-une-app-par-reverse-proxy) comme vous l'avez fait sur votre serveur principal.
### Terminé !
::
## Migrer une base authentik
Sur la machine d'origine, dumper la bdd :
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-postgres pg_dump -U authentik -F t authentik > /path/to/mydb.tar
sudo docker exec authentik-postgresql pg_dump -U authentik -F t authentik > /chemin/vers/mabase.tar
```
Puis l'envoyer sur la machine cible. Sur la machine cible, copier le fichier dans le container docker
### Transférer l'export
Transférez-le sur la machine cible, puis copiez le fichier dans le conteneur Docker :
```bash [Terminal]
cp /path/to/mydb.tar authentik-postgres:/path/to/wherever
cp /chemin/vers/mabase.tar authentik-postgresql:/chemin/vers/ou-vous-voulez
```
(Optionnel) Purgez les tables existantes :
### Purger les tables existantes
(Facultatif) Purgez les tables existantes :
```bash [Terminal]
sudo docker exec -i authentik-postgres 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-postgres psql -U authentik -d postgres -c "DROP DATABASE IF EXISTS authentik;" && \
sudo docker exec -i authentik-postgres psql -U authentik -d postgres -c "CREATE DATABASE authentik;" && \
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;"
```
Restaurez la bdd
### Restaurer la base
Restaurez la base :
```bash [Terminal]
sudo docker exec authentik-postgresql pg_restore -U authentik -d authentik /path/to/wherever/mydb.tar
sudo docker exec authentik-postgresql pg_restore -U authentik -d authentik /chemin/vers/ou-vous-voulez/mabase.tar
```
### Terminé !
::