Vous n'aimez pas externaliser votre authentification pour la pile Docker Traefik vers des services tiers comme Google OAuth? Alors ce tutoriel Docker Authelia est fait pour vous. Authelia est une couche d'authentification autonome et locale pour les services Docker.

Comme vous le savez peut-être, je suis un grand fan de Docker et Traefik pour divers services. Au cours des derniers mois, j'ai travaillé pour améliorer la sécurité de mes services Docker.

Il y a quelques mois, nous vous avons montré comment placer vos applications docker derrière l'authentification Google OAuth 2. J'ai aimé Google OAuth 2.0 et j'ai rarement eu à me connecter car je suis généralement connecté à mon compte Google sur Chrome.

Je n'ai jamais vraiment eu de problèmes avec Google OAuth mais l'idée d'utiliser ma couche d'authentification privée qui est open-source m'a fascinée. Authelia est désormais un composant clé protégeant la configuration de ma maison intelligente et j'en suis assez satisfait.

Donc, dans ce guide Authelia, je vais vous montrer comment configurer Authelia sur Docker et comment mettre vos services derrière Traefik sur l'authentification Authelia.

Informations générales sur Authelia

Authelia est un serveur d'authentification et d'autorisation open-source fournissant une authentification à 2 facteurs et une authentification unique (SSO) pour vos applications via un portail Web. Il agit comme un compagnon de proxys inverses tels que Nginx, Traefik ou HAProxy pour leur faire savoir si les requêtes doivent passer. Les utilisateurs non authentifiés sont redirigés vers le portail de connexion Authelia à la place.

Le schéma ci-dessous montre comment Authelia s'intègre dans le grand schéma des choses.

Schéma d'Authelia Traefik

Des informations détaillées sont disponibles sur la page GitHub d'Authelia et sa documentation.

Fonctionnalités d'Authelia

Voici quelques fonctionnalités clés d'Authelia:

• Plusieurs types de deuxième facteur:
  1. Clé de sécurité (U2F) avec Yubikey.
  2. Mot de passe à usage unique basé sur le temps avec Google Authenticator.
  3. Notifications push mobiles avec Duo.
• Réinitialisation du mot de passe avec vérification d'identité par e-mail de confirmation.
• Méthode d'authentification à facteur unique uniquement disponible.
• Restriction d'accès après trop de tentatives d'authentification.
• Contrôle d'accès précis par sous-domaine, utilisateur, ressource et réseau.
• Prise en charge de l'authentification de base pour les terminaux protégés par un facteur unique.
• Hautement disponible en utilisant une base de données distante et Redis en tant que magasin KV hautement disponible.

Types de déploiement d'Authelia

Authelia prend en charge trois scénarios:

1. Local: Destiné à être utilisé pour les scénarios où le serveur n'est pas exposé à Internet. Les domaines seront définis dans le fichier d'hôtes local et des certificats auto-signés seront utilisés. Ceci est utile pour les tests.
2. Léger: Authelia Lite est destiné aux scénarios dans lesquels le serveur sera exposé à Internet avec les domaines, DNS et certificats LetsEncrypt appropriés. L'élément Lite fait référence à des dépendances externes minimales; Stockage utilisateur basé sur fichier, stockage de configuration basé sur SQLite. Dans cette configuration, le service n'évoluera pas correctement.
3. Plein: Authelia full, est similaire à Lite mais avec une configuration évolutive qui inclut des dépendances externes; Stockage utilisateur basé sur LDAP, stockage de configuration basé sur une base de données (MariaDB, MySQL ou Postgres).

Dans ce guide, nous allons utiliser Authelia Lite. Cependant, nous allons également le rendre légèrement évolutif avec la configuration Redis et MySQL. Seul le stockage utilisateur LDAP n'est pas couvert ici.

Alternatives à Authelia

Existe-t-il des alternatives à Authelia? Sûr. Il existe même une alternative open source bien établie.

Nous avons déjà discuté de Google OAuth. Keycloak est une autre alternative à Authelia merveilleuse et open source. Keycloak a un énorme succès.

Authelia contre Keycloak

Je n'ai personnellement pas administré Keycloak mais je l'ai utilisé et parlé à d'autres personnes qui l'administrent. J'utilise Authelia depuis plusieurs mois. À ma connaissance limitée, je pense qu'Authelia est beaucoup plus simple à administrer et à utiliser que Keycloak pour protéger les services Docker. Authelia a également répondu à tous mes besoins jusqu'à présent.

Combiné avec Cloudflare, Authelia a considérablement amélioré la sécurité de ma configuration.[[Lis: Paramètres Cloudflare pour Traefik Docker: DDNS, CNAME et Tweaks]

Passons maintenant à la configuration d'Authelia.

Configuration Authelia

C'est vrai. Nous allons commencer par configurer Authelia avant de le configurer. Authelia a besoin d'une configuration de base pour que le service Docker Authelia puisse démarrer correctement.

Exigences

Avant de commencer avec la configuration du docker Authelia, assurez-vous d'avoir lu et suivi mon précédent guide Docker Traefik. Vous devez avoir une pile Traefik Docker fonctionnelle avec le dossier racine Docker défini à l'aide de la variable d'environnement $ USERDIR.

Dans le dossier racine du docker, dans mon cas / home / utilisateur / docker, créez un dossier appelé authelia. Cela fait, commençons à configurer Authelia.

1. Configuration "requise" d'Authelia

Les configurations Authelia sont définies dans configuration.yml. Certains sont obligatoires et certains sont facultatifs. Alors commencez par créer un vide configuration.yml fichier et ajoutez-y du contenu comme défini ci-dessous.

À tout moment, vous pouvez consulter la documentation Authelia pour personnaliser davantage votre configuration.

Mise en garde: Faites attention à l'indentation et aux espaces. YAML lancera des erreurs si l'indentation / l'espacement corrects ne sont pas respectés.

Configuration de base

Tout d'abord, ajoutons les informations de base ci-dessous.

################################################ #############
# Configuration Authelia #
################################################ #############

hôte: 0.0.0.0
port: 9091
log_level: avertir

Les valeurs par défaut ci-dessus devraient fonctionner pour la plupart des configurations de Docker Authelia. Lors de la création de règles de contournement ou du dépannage, vous pouvez modifier le log_level à déboguer, trace, ou Info.

Ensuite, ajoutons jwt_secret. J'ai commencé par définir le secret dans configuration.yml mais est ensuite passé à l'utilisation des secrets Docker pour une sécurité améliorée. Si vous préférez l'ajouter ici à la place, vous pouvez en créer un en utilisant ce site Web, décommenter jwt_secret ligne et remplacez SECRET_GOES_HERE.

# Ce secret peut également être défini à l'aide des variables d'environnement AUTHELIA_JWT_SECRET_FILE
# jwt_secret: SECRET_GOES_HERE # utiliser le fichier secret de docker à la place AUTHELIA_JWT_SECRET_FILE

Ensuite, ajoutez les lignes suivantes:

# https://docs.authelia.com/configuration/miscellaneous.html#default-redirection-url
default_redirection_url: https://authelia.example.com

Remplacer example.com avec votre nom de domaine.

Configuration de mot de passe à usage unique en fonction du temps

Authelia utilise des mots de passe à usage unique basés sur le temps (TOTP). Laissez-nous configurer cela ensuite:

totp:
  émetteur: authelia.com
  période: 30
  inclinaison: 1

Les détails des paramètres ci-dessus sont disponibles ici. Cependant, il est fortement recommandé de ne pas les manipuler.

Backend d'authentification

Ensuite, ajoutons le backend d'authentification Authelia. Nous allons utiliser l'authentification basée sur les fichiers avec l'un des algorithmes de hachage les plus puissants pour les mots de passe (argon2id).

authentication_backend:
  fichier:
    chemin: /config/users_database.yml
    mot de passe:
      algorithme: argon2id
      itérations: 1
      longueur_ sel: 16
      parallélisme: 8
      mémoire: 1024 # bloque autant de RAM. Réglez ceci.

Nous allons stocker les informations utilisateur dans users_database.yml fichier, que nous créerons plus tard.

Pour les mots de passe, argon2id est l'algorithme de hachage recommandé. Vous pouvez choisir d'utiliser sha512 (recommandé pour les appareils à faible puissance). Les valeurs par défaut indiquées ci-dessus pour les itérations, salt_length, parallélisme et mémoire devraient fonctionner pour la plupart des instances.

Vous pouvez les personnaliser en vous basant sur cette documentation. Notez que la personnalisation des valeurs aura un impact énorme sur l'utilisation des ressources.

Contrôle d'accès

Ensuite, ajoutons des configurations de contrôle d'accès.

contrôle d'accès:
  default_policy: refuser
  règles:
    - domaine: authelia.example.com
      politique: contourner
    - domaine:
        - "* .example.com"
        - "example.com"
      politique: two_factor

Remplacer example.com avec votre nom de domaine. Vous pouvez laisser le reste des lignes tel quel pour commencer. Par défaut, nous refusons l'accès à tout, en contournant l'authentification pour authelia.example.com. Tout le reste nécessitera une authentification à deux facteurs.

Vous avez la possibilité de contourner l'authentification dans certaines situations. Par exemple, ajouter le bloc ci-dessous à règles vous permettrait de contourner l'authentification tout en accédant aux services de votre réseau domestique.

        - domaine:
        - "* .example.com"
        - "example.com"
      politique: contourner
      réseaux:
        - 192.168.1.0/24
        - ADRESSE IP HOME-WAN

Reportez-vous à la documentation de contrôle d'accès authelia pour plus de façons de personnaliser les règles de contournement.

Configuration de la session Authelia

Ensuite, nous configurons la façon dont les sessions d'authentification sont stockées. Ajoutez le bloc suivant à votre configuration.yml.

session:
  nom: authelia_session
  # Ce secret peut également être défini à l'aide des variables d'environnement AUTHELIA_SESSION_SECRET_FILE
  # secret: SECRET_GOES_HERE # utiliser le fichier secret de docker à la place AUTHELIA_SESSION_SECRET_FILE
  expiration: 3600 # 1 heure
  inactivité: 300 # 5 minutes
  domain: example.com # Doit correspondre quel que soit votre domaine protégé racine

Nous allons définir le secret de session à l'aide des secrets Docker comme décrit plus tard (plus sécurisé). Mais si vous le souhaitez, vous pouvez utiliser la même méthode que pour jwt_secret, générer un nouveau secret et remplacer SECRET_GOES_HERE.

Remplacer, example.com avec votre nom de domaine. Le reste peut être laissé par défaut ou personnalisé pour avoir des intervalles de session plus ou moins longs. Des intervalles plus courts entraîneront une authentification multifacteur plus fréquente.

Vous pouvez encore améliorer les performances du stockage de session en utilisant un backend de base de données et Redis comme décrit plus loin. Mais cela est facultatif et les améliorations sont marginales dans un environnement mono-utilisateur.

Régulation

Authelia dispose d'une protection intégrée contre les attaques malveillantes par force brute. Pour configurer cela, ajoutez le bloc suivant.

régulation:
  max_retries: 3
  find_time: 120
  ban_time: 300

Vous trouverez plus d'informations sur la réglementation ici. La configuration ci-dessus interdirait tout utilisateur qui a 3 connexions incorrectes en 120 secondes (2 min), pour une durée d'interdiction de 300 secondes (5 min).

Stockage de session

Authelia dispose d'un stockage de session intégré utilisant SQLite. Ceci est suffisant pour un environnement mono-utilisateur.

Ajoutez le bloc suivant à configuration.yml:

espace de rangement:
  local:
    chemin: /config/db.sqlite3

Le remplacement de SQLite par une base de données telle que MySQL (décrite plus loin) offre des performances, une évolutivité et la possibilité d'exécuter plusieurs instances authelia.

Notifications Authelia

Le dernier bit de configuration requis est les notifications, qui peuvent être via des e-mails ou des fichiers texte. Pour commencer, gardons les choses simples et sauvegardons toutes les notifications dans un fichier texte appelé notifications.txt.

notifiant:
  # À des fins de test, les notifications peuvent être envoyées dans un fichier. Assurez-vous de mapper le volume dans docker-compose.
  système de fichiers:
    nom de fichier: /config/notification.txt

Assurez-vous de créer un fichier vide appelé notification.txt dans le dossier authelia (/ home / user / docker / authelia).

2. Configuration facultative d'Authelia

Certaines configurations Authelia en option offrent des améliorations de commodité et de performances. Nous les examinerons ensuite dans ce didacticiel Authelia.

Redis

En termes simples, Redis est un mécanisme de mise en cache clé-valeur qui peut améliorer les performances des applications qui accèdent fréquemment aux bases de données. Si vous n'avez pas Redis, il est assez facile de le faire fonctionner avec Docker. Vérifiez mes fichiers de dépôt GitHub pour le docker-compose Redis.

Si vous avez une instance Redis disponible, ajoutez le bloc suivant sous session: pour activer l'utilisation de Redis (faites attention à l'indentation).

    redis:
    hôte: redis
    port: 6379
    # Ce secret peut également être défini à l'aide des variables d'environnement AUTHELIA_SESSION_REDIS_PASSWORD_FILE
    # mot de passe: authelia

Personnalisez l'hôte avec l'hôte exécutant Redis. Le port est généralement 6379. L'utilisation d'un mot de passe est facultative. Encore une fois, dans un système non occupé, l'utilisation de Redis aura un impact minimal. Mais j'utilise déjà Redis pour d'autres applications, donc l'ajouter a été facile pour moi.

Stockage MySQL

Authelia propose plusieurs backends de stockage. Dans cet exemple, utilisons MySQL. Ajoutez le bloc suivant sous espace de rangement:, en faisant attention à l'indendation.

    mysql:
    hôte: MYSQL_HOST
    port: 3306
    base de données: authelia
    nom d'utilisateur: DBUSERNAME
    # Le mot de passe peut également être défini à l'aide des variables d'environnement AUTHELIA_STORAGE_MYSQL_PASSWORD_FILE
    # mot de passe: PASSWORD_GOES_HERE # utiliser le fichier secret de docker à la place AUTHELIA_STORAGE_MYSQL_PASSWORD_FILE

Créez une base de données MySQL appelée authelia et fournissez les détails de connexion ci-dessus. Nous pouvons fournir le mot de passe ici ou sous forme de secret (décrit plus loin).

Si vous utilisez MySQL, assurez-vous de commenter ou de supprimer le backend de stockage SQLite dans le configuration.yml fichier.

Notifications par email

Le stockage des notifications dans un fichier texte n'est pas idéal. Si vous avez un serveur de messagerie (j'utilise et recommande Mailgun, qui est gratuit), vous pouvez activer la notification par e-mail en ajoutant le bloc suivant sous notifiant::

    smtp:
    nom d'utilisateur: SMTP_USERNAME
    # Ce secret peut également être défini à l'aide des variables d'environnement AUTHELIA_NOTIFIER_SMTP_PASSWORD_FILE
    # mot de passe: PASSWORD_GOES_HERE # utiliser le fichier secret du docker à la place AUTHELIA_NOTIFIER_SMTP_PASSWORD_FILE
    hôte: SMTP_HOST
    port: 587 # ou 465
    expéditeur: SENDER_EMAIL

Remplacez les détails d'accès SMTP ci-dessus. Le mot de passe, encore une fois, peut être fourni en tant que secret ou ajouté ici en remplaçant PASSWORD_GOES_HERE.

Après avoir activé les notifications par e-mail, vous pouvez choisir de désactiver l'écriture de notifications dans le notification.txt fichier (commentez ou supprimez ces lignes).

3. Secrets d'Authelia

Le stockage d'Authelia à l'aide de secrets Docker peut améliorer la sécurité. Tous les secrets supportés par Authelia sont listés ici. Créons ceux que nous avons utilisés ci-dessus.

L'ajout de secrets à Docker est essentiellement un processus en plusieurs étapes, que je décrirai en détail dans un article séparé. Mais voici un bref processus.

1. Créer un dossier Secrets

Dans le dossier racine du docker, créez un secrets dossier. Le dossier doit appartenir à racine: racine et avoir 600 autorisation comme indiqué ci-dessous.

Autorisations du dossier Docker Secrets

Utilisez la commande suivante pour définir les autorisations:

sudo chown root: racine ~ / docker / secrets
sudo chmod 600 ~ / docker / secrets

2. Créez un fichier secret

Une fois le dossier secrets créé, créons les secrets. Chaque valeur secrète est un fichier distinct dans le dossier secrets. Voici les secrets que j'ai créés pour Authelia.

Secrets pour Authelia

Notez qu'ils ont tous les mêmes autorisations (propriétaire racine, groupe racine et 600 autorisations) que le secrets dossier.

Par exemple, créons un secret pour jwt_secret chez Authelia's configuration.yml fichier.

Tout d'abord, obtenez les privilèges root en utilisant sudo su afin que vous puissiez accéder au dossier secrets. Ensuite, en utilisant votre éditeur de texte préféré (j'utilise nano), créez un fichier appelé authelia_jwt_secret.

nano authelia_jwt_secret

Copiez-collez le jwt_secret que vous avez créé dans le fichier. Il ne devrait y avoir rien d'autre dans le fichier que le secret. Enregistrez et fermez le fichier. De même, créez tous les autres secrets utilisés dans le configuration.yml fichier.

3. Ajoutez le secret à Docker globalement

Dans votre fichier docker-compose, ajoutez une section pour les secrets comme indiqué ci-dessous. Notez que la variable d'environnement $ SECRETSDIR doit être défini dans le .env fichier. Si vous avez suivi mon guide Docker Traefik, cela devrait être / home / utilisateur / docker / secrets.

########################## SECRETS
secrets:
  authelia_jwt_secret:
    fichier: $ SECRETSDIR / authelia_jwt_secret
  authelia_session_secret:
    fichier: $ SECRETSDIR / authelia_session_secret
  authelia_storage_mysql_password:
    fichier: $ SECRETSDIR / authelia_storage_mysql_password
  authelia_notifier_smtp_password:
    fichier: $ SECRETSDIR / authelia_notifier_smtp_password
  authelia_duo_api_secret_key:
    fichier: $ SECRETSDIR / authelia_duo_api_secret_key

Si vous avez des questions sur l'endroit exact où cela est ajouté, reportez-vous aux fichiers docker-compose dans mon GitHub Repo.

Je l'ai ajouté juste au-dessus de mon prestations de service: bloquer.

4. Ajouter un secret au service Authelia

Après avoir défini les secrets globalement, vous devrez faire en sorte que le service les utilise. Pour ce faire, vous devrez ajouter deux éléments à votre extrait de code docker-compose pour le service:

• Bloc de secrets au sein du service
• Variables d'environnement au sein du service pointant vers les fichiers secrets

Ceci est illustré dans l'extrait de code Authelia Docker plus loin dans ce guide.

4. Utilisateurs Authelia

Il y a une dernière information à configurer: les utilisateurs. Dans notre configuration.yml fichier que nous avons dit que les utilisateurs sont dans le users_database.yml fichier, qui est décrit ici.

dans le / home / utilisateur / docker / authelia dossier, créez un fichier appelé users_database.yml ajoutez-y ce qui suit:

utilisateurs:
  Nom d'utilisateur:
    nom d'affichage: "John Doe"
    mot de passe: "HASHED_PASSWORD"
    email: [email protected]
    groupes:
      - administrateurs
      - dev

Personnalisez le Afficher un nom et email.

Pour hacher le mot de passe, utilisez la commande suivante (vous devrez peut-être utiliser sudo devant):

docker exécutez authelia / authelia: dernier mot de passe de hachage authelia YOUR_PASSWORD

Remplacer VOTRE MOT DE PASSE avec votre mot de passe fort. Votre mot de passe sera haché à l'aide de l'algorithme argon2id et affiché comme indiqué ci-dessous.

Mot de passe haché par Authelia

Copiez le mot de passe haché dans son intégralité (mis en évidence par une case rouge) et remplacez-le HASHED_PASSWORD dans le users_database.yml.

Enregistrez le fichier et quittez.

Configuration d'Authelia Traefik

Maintenant que la configuration d'Authelia est terminée. Configurons Traefik pour utiliser Authelia.

En nous basant sur le même framework que nous avons construit à l'aide du guide Docker-Traefik, nous devons ajouter deux sections à la configuration de Traefik: un middleware pour authelia et une chaîne middleware pour authelia.

La configuration de Google OAuth utilise également un cadre similaire.

Intergiciel Authelia Traefik

Tout d'abord, créons un middleware am Authelia Traefik qui transmettra l'authentification au conteneur Authelia.

Ajoutez le bloc de code suivant à votre middleware. Si vous avez suivi mon guide Traefik exactement, ce serait middlewares.yml.

        middlewares-authelia:
      forwardAuth:
        adresse: "http: // authelia: 9091 / api / verify? rd = https: //authelia.example.com"
        trustForwardHeader: vrai
        authResponseHeaders:
          - "Utilisateur distant"
          - "Groupes distants"

Remplacer, example.com avec votre domaine. Rien d'autre à changer.

Traefik Middleware Chain pour Authelia

Ensuite, créez une nouvelle chaîne middleware et incluez la limitation de débit et les en-têtes de sécurité pour une sécurité supplémentaire. Pour ce faire, ajoutez le bloc de code suivant à middlewares-chains.yml:

        chaîne-authelia:
      chaîne:
        middlewares:
          - middlewares-rate-limit
          - middlewares-secure-headers
          - middlewares-authelia

le middlewares-rate-limit et middlewares-secure-headers les middlewares sont décrits dans mon guide du docker Traefik. C'est tout pour la configuration traefik. Plus loin dans ce guide, je vous montrerai comment utiliser ces middlewares pour placer des services derrière l'authentification Authelia.

SmartHomeBeginner propose des didacticiels approfondis assez faciles à comprendre, même pour les débutants. Cela demande un travail considérable. Si cet article vous aide, pensez à nous soutenir en guise de remerciement:

• Vous vous sentez généreux? Achetez-moi un café (ou deux).
• Peut-être un autre jour? Achetez sur Amazon en utilisant nos liens. Vos prix ne changeront pas mais nous percevons une petite commission.
• Vous n'avez pas envie de dépenser? Vous pouvez toujours montrer votre soutien en partageant ce message, en y créant un lien dans les forums ou même en commentant ci-dessous.

Authelia Docker Compose

Maintenant que toute la partie configuration est terminée. Ajoutons le service docker Authelia.

Avec Traefik déjà opérationnel, ajoutez l'extrait suivant à votre docker-compose:

    # Authelia (Lite) - Authentification unique auto-hébergée et authentification à deux facteurs
  authelia:
    nom_conteneur: authelia
    # image: authelia / authelia: dernière
    image: authelia / authelia: 4.21.0
    redémarrer: toujours
    réseaux:
      - t2_proxy
    dépend de:
      - mariadb
      - redis
    volumes:
      - $ DOCKERDIR / authelia: / config
    environnement:
      - TZ = $ TZ
      - AUTHELIA_JWT_SECRET_FILE = / run / secrets / authelia_jwt_secret
      - AUTHELIA_SESSION_SECRET_FILE = / run / secrets / authelia_session_secret
      - AUTHELIA_STORAGE_MYSQL_PASSWORD_FILE = / run / secrets / authelia_storage_mysql_password
      - AUTHELIA_NOTIFIER_SMTP_PASSWORD_FILE = / run / secrets / authelia_notifier_smtp_password
      - AUTHELIA_DUO_API_SECRET_KEY_FILE = / run / secrets / authelia_duo_api_secret_key
    secrets:
      - authelia_jwt_secret
      - authelia_session_secret
      - authelia_storage_mysql_password
      - authelia_notifier_smtp_password
      - authelia_duo_api_secret_key
    Étiquettes:
      - "traefik.enable = true"
      ## Routeurs HTTP
      - "traefik.http.routers.authelia-rtr.entrypoints = https"
      - "traefik.http.routers.authelia-rtr.rule = HostHeader (` authelia. $ DOMAINNAME`) "
      ## Middlewares
      - "traefik.[email protected]"
      ## Services HTTP
      - "traefik.http.routers.authelia-rtr.service = authelia-svc"
      - "traefik.http.services.authelia-svc.loadbalancer.server.port = 9091"

Quelques notes sur l'extrait de code Authelia docker-compose:

• image: Notez que je spécifie le numéro de version d'Authelia à utiliser explicitement (4.21.0 au moment de la rédaction de ce guide). D'après mon expérience, il y a eu des changements de rupture avec le développement d'Authelia qui ont rendu mes services indisponibles. Alors maintenant, je vérifie la liste des changements de rupture et met à niveau authelia manuellement.
• dépend de: J'utilise MySQL et Redis pour le stockage. Ceux-ci sont définis comme des services séparés dans ma pile de docker et donc le conteneur authelia dépend de ces deux. Si l'un d'eux est en panne, Authelia ne fonctionnera pas.
• volumes: Conteneur Authelia / config le volume est mappé au dossier Authelia dans la racine du docker. Ce dossier contient configuration.yml, users_database.yml, et notification.txt.
• environnement: Comme indiqué précédemment, l'ajout de secrets aux services nécessite deux ajouts supplémentaires à l'extrait de code docker-compose pour le service. Sous environnement, notez la liste des secrets. Ils sont définis comme VARIABLE_NAME_FILE = / run / secrets / secret_file_name. le / run / secrets / doit être utilisé tel quel et le secret_file_name est le nom de fichier des secrets que nous avons créés dans / home / utilisateur / docker / secrets dossier, précédemment.
• secrets: Il s'agit de la deuxième section de l'extrait de code docker-compose où les secrets sont répertoriés. Tous les noms de fichiers des secrets utilisés dans le service sont répertoriés ici.
• Étiquettes: Aucune modification n'est requise ici. Nous utilisons le chaîne authelia fichier de chaîne middleware que nous avons créé précédemment.

Enregistrez votre docker-compose, démarrez le conteneur Authelia et vérifiez les journaux du conteneur Authelia. Vous devriez voir une sortie indiquant qu'Authelia écoute sur le port 9091.

Démarrage réussi du conteneur Authelia Docker

Mettre les services Docker derrière Authelia

Si vous avez créé l'intergiciel authelia traefik et la chaîne d'intergiciels évoqués ci-dessus, il est simple de placer les services docker derrière l'authentification Authelia. Tout ce que vous avez à faire est d'ajouter le middleware suivant aux étiquettes docker-compose:

            ## Middlewares
      - "[email protected]"

service-rtr pourrait être différent pour différents services. Comme toujours, vérifiez les fichiers docker-compose dans le référentiel GitHub pour des exemples de travail.

Mettre les services non-Docker derrière Authelia

L'ajout d'applications non-docker ou d'applications à partir d'un hôte docker ou d'hôtes externes est également assez simple. Vérifiez le dossier de règles Traefik dans mon dépôt GitHub pour des exemples de travail.

L'exemple YAML ci-dessous montre comment placer PiHole sur un hôte externe derrière l'authentification Authelia.[[Lis: Comment exécuter PiHole dans Docker sur Ubuntu, avec et sans proxy inverse?]

http:
  routeurs:
    pihole-rtr:
      règle: "HostHeader (` pihole.example.com`) "
      points d'entrée:
        - https
      middlewares:
        - chaîne-authelia
        - pihole-add-admin
      service: pihole-svc
      tls:
        certResolver: dns-cloudflare
  middlewares:
    pihole-add-admin:
      addPrefix:
        préfixe: "/ admin"
  prestations de service:
    pihole-svc:
      loadBalancer:
        les serveurs:
          - url: "http://192.168.1.26:80"

Notez que PiHole écoute sur un port non SSL.[[Lis: Comment exécuter PiHole dans Docker sur Ubuntu, avec et sans proxy inverse?]

Certains services (par exemple, NextCloud, contrôleur UniFi, etc.) ont besoin de routeurs TCP au lieu de routeurs HTTP car ils utilisent des certificats auto-signés.[[Lis: Comment installer UniFi Controller sur Docker avec Reverse Proxy (Traefik)?]

Utilisation d'Authelia

Maintenant que le conteneur Authelia Docker est opérationnel. Laissez-nous le tester.

Première utilisation et enregistrement d'Authelia

Lors de l'accès à un service protégé par Authelia, pour la première fois, vous devriez voir le formulaire de connexion suivant.

Formulaire de connexion Authelia

Connectez-vous en utilisant le nom d'utilisateur et le mot de passe que vous avez définis dans users_database.yml fichier.

Ensuite, vous devrez enregistrer votre appareil. Cliquer sur Méthodes, choisissez Mot de passe à usage unique, puis cliquez sur Pas encore inscrit?, comme indiqué ci-dessous.

Enregistrement unique du mot de passe Authelia Docker

Un lien d'inscription sera envoyé à l'ID de messagerie de l'utilisateur défini dans le users_database.yml fichier.

Lien de messagerie Authelia OTP

Mais il y a un problème. Que faire si vous n'avez pas configuré le serveur SMTP pour les notifications par e-mail? Eh bien, dans ce cas, le lien d'enregistrement est intégré dans la notification enregistrée dans notification.txt fichier.

Lien d'enregistrement Authelia OTP dans notification.txt

Vous devrez trouver ce lien et ouvrez-le dans le même navigateur que celui où vous essayez d'accéder au service qui se trouve derrière Authelia.

Si vous avez configuré SMTP pour les notifications par e-mail, vous devriez recevoir un e-mail comme celui illustré ci-dessous.

Ouverture du lien d'inscription Authelia

Cliquez et ouvrez le lien d'inscription.

Remarque: Si vous n'ouvrez pas le lien d'enregistrement sur le même appareil à l'origine de l'enregistrement authelia, l'enregistrement échouera.

Le lien doit ouvrir un code QR, comme indiqué dans la capture d'écran ci-dessous. Vous pouvez utiliser l'une des applications d'authentification (Duo, Authy, Google Authenticator, etc.) pour scanner le code. Je recommande Duo car il prend en charge les notifications push, ce qui facilite les authentifications (décrites plus loin).

Scannez le code QR Authelia OTP sur Duo (recommandé), Authy ou Google Authenticator

Après la numérisation, entrez le code OTP de l'application d'authentification dans Authelia.

Premier enregistrement avec code OTP

Cela devrait terminer l'enregistrement de votre appareil pour Authelia et vous devriez voir quelque chose comme la capture d'écran ci-dessous.

Authentification réussie d'Authelia avec OTP

C'est à peu près tout. Vous pouvez maintenant commencer à utiliser l'authentification multifacteur Authelia pour vos applications Docker. Authelia protège certaines de mes applications d'administration clés telles que Guacamole.[[Lis: Installez Guacamole sur Docker – VNC, SSH, SFTP et RDP comme un boss!]

Activation de la notification push Duo pour Authelia

Comme je l'ai déjà dit, j'aime Duo car il prend en charge les notifications push qui permettent des approbations de connexion faciles en un clic par rapport à l'entrée dans l'OTP. L'activer est un peu de travail et peu intuitif.

Mais ne vous inquiétez pas, je vais vous guider à travers et c'est GRATUIT.

Tout d'abord, rendez-vous sur le site Web de Duo et créez un compte.

1. Créez un utilisateur Duo

Du Utilisateurs menu, cliquez sur Ajouter un utilisateur comme indiqué ci-dessous et créez un nouvel utilisateur.

Ajouter un utilisateur Duo pour l'authentification Authelia Push

Remplissez les détails de l'utilisateur.

Remarque: le le nom d'utilisateur doit être le même que celui que vous avez utilisé pour Authelia dans users_database.yml.

Faites défiler vers le bas et ajoutez un numéro de téléphone.

2. Activez l'utilisateur

Vous devriez voir un message d'avertissement (illustré ci-dessous) sur la page d'administration de Duo qui indique que l'utilisateur n'est pas activé.

Activer un nouvel utilisateur Duo

Envoyez le lien d'activation à l'utilisateur / à votre téléphone et cliquez sur le lien reçu pour activer l'utilisateur.

3. Créez une application

Sous Applications, sélectionnez Protéger une application, rechercher API Partner Auth et cliquez Protéger, comme indiqué ci-dessous.

Ajouter une nouvelle application pour l'authentification Duo Push

Une fois créé, copiez le Clé d'intégration, Clef secrète, et Nom d'hôte de l'API.

4. Configurer l'API Duo dans la configuration Authelia

Ouvrez Authelia's configuration.yml et ajoutez-y le bloc de code suivant. Je l'ai ajouté entre totp: et authentication_backend: blocs.

# Activez ce qui suit pour la prise en charge de Duo Push Notification
duo_api:
  nom d'hôte: API_HOSTNAME_GOES_HERE
  clé_intégration: INTEGRATION_KEY_GOES_HERE
  # Ce secret peut également être défini à l'aide des variables d'environnement AUTHELIA_DUO_API_SECRET_KEY_FILE
  # secret_key: SECRET_KEY_GOES_HERE # utiliser le fichier secret de docker à la place AUTHELIA_DUO_API_SECRET_KEY_FILE

Utilisez les détails copiés de l'étape précédente pour personnaliser le code ci-dessus. Encore une fois, nous définissons ici le clef secrète comme un secret de docker. Suivez donc les étapes décrites précédemment. Vous pouvez également choisir de remplacer SECRET_KEY_GOES_HERE avec la clé secrète.

C'est tout. Maintenant, enregistrez la configuration d'Authelia et redémarrez le service docker authelia.

5. Tester la notification push Authelia Duo

Essayez d'accéder à une application Docker derrière Authelia. Cette fois de Méthodes, choisissez Notification push comme indiqué ci-dessous.

Enregistrement d'authentification Authelia Push

Vous devriez recevoir une notification push sur votre téléphone et tout ce que vous avez à faire est d'approuver en un clic et votre connexion devrait passer.

Réflexions finales sur Authelia pour Docker Traefik

Cela semblait être un processus long, mais en réalité, la mise en œuvre de ce didacticiel Docker Authelia ne devrait pas prendre plus d'une heure. J'ai été très satisfait de Google OAuth. Mais je suis encore plus heureux avec Authelia.

Je ne sais pas si Authelia offre plus de protection que Google OAuth mais j'ai l'impression d'avoir plus de contrôle. Et l'autorisation push duo a rendu son utilisation plus simple. J'ai déplacé tous mes services de Google OAuth vers Authelia, y compris ceux qui fonctionnent sur ma pile Synology Docker Traefik.

Authelia offre un support pour les clés de sécurité matérielles. Je n'ai pas encore exploré ceux-ci, mais si vous le faites, vous y êtes également couvert.

Si vous avez des informations manquantes, n'hésitez pas à ajouter des commentaires pour aider les autres. Sinon, j'espère que ce guide Docker-Traefik Authelia a été utile pour rendre votre pile plus sécurisée.