Spécifications

• Système de fichier: BTRFS au dessus de LUKS2 (chiffrement)
• Gestionnaire de boot: systemd-boot
• Type de démarrage: UEFI

Matériel

Comme je réalise régulièrement des installations de différents OS j'utilise un IODD ST400 sur lequel j'ajoute simplement mes fichiers ISO et me permettant de créer des lecteurs CD virtuels via USB.

En ce qui concerne la machine sur laquelle je fais faire cette installation il s'agit d'un Framework Laptop 16:

• AMD Ryzen™ 9 7940HS
• 64Go RAM DDR5
• 2x2To SSD
• Radeon™ RX 7700S

Cette installation sera donc pour les processeurs AMD, avec la configuration pour une carte graphique AMD et sur le premier SSD.

Connexion au Wifi

Afin de vous connecter au wifi nous allons utiliser la iwd.

Dans un premier temps vous devez récupérer le nom de votre carte réseau, dans mon cas il s'agit de wlan0:

# iwctl station list

Ensuite vous pouvez vous connecter à votre réseau:

# iwctl station <carte reseau> connect <SSID>

Stockage

Afin de pouvoir procéder à l'installation nous devons commencer par préparer le disque sur lequel mettre notre système.

Création des partitions

Vous pouvez identifier ce disque :

# lsblk
NAME        MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
loop0         7:0    0 794.4M  1 loop /run/archiso/airootfs
sda           8:0    1 931.5G  0 disk
└─sda1        8:1    1 931.5G  0 part
sr0          11:0    1   1.1G  0 rom  /run/archiso/bootmnt
nvme0n1     259:4    0   1.9T  0 disk

Ici mon disque est nvme0n1.

Maintenant que le disque est identifié (assurez-vous qu'il s'agit du bon) nous allons supprimer la table de partition actuellement existente:

sgdisk --zap-all /dev/nvme0n1

Ensuite nous allons définir notre table de partition enn y incluant des labels. Ayant beaucoup de RAM et un disque SSD je ne vais pas mettre de SWAP sur mon disque. Il n'y aura donc que 2 partitions :

sgdisk --clear --new=1:0:+512MiB --typecode=1:ef00 --change-name=1:EFI --new=2:0:0 --typecode=2:8300 --change-name=2:cryptsystem /dev/nvme0n1

La première partition sera utilisée pour le boot EFI et la deuxième pour le système.

Nous pouvons vérifier la table de partition :

# fdisk -l /dev/nvme0n1
Disk /dev/nvme0n1: 1.86 TiB, 2048408248320 bytes, 4000797360 sectors
Disk model: WD PC SN740 SDDPTQE-2T00
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: gpt
Disk identifier: 33857BEA-76EC-43B4-AAD5-4743FCF68B43

Device           Start        End    Sectors  Size Type
/dev/nvme0n1p1    2048    1050623    1048576  512M EFI System
/dev/nvme0n1p2 1050624 4000797326 3999746703  1.9T Linux filesystem

Ensuite procédons à la création de notre partition chiffrée :

cryptsetup luksFormat --type luks2 --align-payload=8192 -s 256 -c aes-xts-plain64 /dev/disk/by-partlabel/cryptsystem

Puis ouvrir le conteneur chiffré :

cryptsetup open /dev/disk/by-partlabel/cryptsystem system

Création des système de fichiers

Nous allons procéder au formatage des partitions, BTRFS pour le partition systèmè et vfat pour la partition EFI.

Système

mkfs.btrfs --label system /dev/mapper/system

Maintenant il faut définir un layout pour BTRFS afin de pouvoir gérer correctement la fonction de snapshots du système de fichier par la suite. Voici mon layout :

Pour procéder à la création des sous volumes nous allons monter la partition :

mount -t btrfs LABEL=system /mnt

Et procéder à la création de ces derniers:

btrfs subvolume create /mnt/@
btrfs subvolume create /mnt/@home
btrfs subvolume create /mnt/@root
btrfs subvolume create /mnt/@snapshots
btrfs subvolume create /mnt/@opt
btrfs subvolume create /mnt/@srv
btrfs subvolume create /mnt/@tmp
btrfs subvolume create /mnt/@usr_local
btrfs subvolume create /mnt/@var
btrfs subvolume create /mnt/@var_log
btrfs subvolume create /mnt/@var_cache
btrfs subvolume create /mnt/@var_tmp
btrfs subvolume create /mnt/@libvirt

Il faut ensuite monter les sous volumes:

mount -t btrfs -o defaults,x-mount.mkdir,compress=zstd,ssd,noatime,subvol=@ LABEL=system /mnt/
mount -t btrfs -o defaults,x-mount.mkdir,compress=zstd,ssd,noatime,subvol=@home LABEL=system /mnt/home
mount -t btrfs -o defaults,x-mount.mkdir,compress=zstd,ssd,noatime,subvol=@root LABEL=system /mnt/root
mount -t btrfs -o defaults,x-mount.mkdir,compress=zstd,ssd,noatime,subvol=@snapshots LABEL=system /mnt/.snapshots
mount -t btrfs -o defaults,x-mount.mkdir,compress=zstd,ssd,noatime,subvol=@opt LABEL=system /mnt/opt
mount -t btrfs -o defaults,x-mount.mkdir,compress=zstd,ssd,noatime,subvol=@srv LABEL=system /mnt/srv
mount -t btrfs -o defaults,x-mount.mkdir,compress=zstd,ssd,noatime,subvol=@tmp LABEL=system /mnt/tmp
mount -t btrfs -o defaults,x-mount.mkdir,compress=zstd,ssd,noatime,subvol=@usr_local LABEL=system /mnt/usr/local
mount -t btrfs -o defaults,x-mount.mkdir,compress=zstd,ssd,noatime,subvol=@var LABEL=system /mnt/var
mount -t btrfs -o defaults,x-mount.mkdir,compress=zstd,ssd,noatime,subvol=@var_log LABEL=system /mnt/var/log
mount -t btrfs -o defaults,x-mount.mkdir,compress=zstd,ssd,noatime,subvol=@var_cache LABEL=system /mnt/var/cache
mount -t btrfs -o defaults,x-mount.mkdir,compress=zstd,ssd,noatime,subvol=@var_tmp LABEL=system /mnt/var/tmp
mount -t btrfs -o defaults,x-mount.mkdir,compress=zstd,ssd,noatime,nodatacow,subvol=@libvirt LABEL=system /mnt/var/lib/libvirt/images

L'option ssd est à définir uniquement sur les disques SSD. Je désactive également la fonction de Copy-on-Write avec l'option nodatacow pour le répertoire des disques des VMs libvirt.

EFI

# Formatage de la partition
mkfs.fat -F32 -n EFI /dev/disk/by-partlabel/EFI
# Création du point de montage dans la partition racine
mkdir /mnt/efi
# Montage de la partition
mount LABEL=EFI /mnt/efi

Installation du système

Maintenant que l'architecture de notre système est créé nous allons pouvoir installer la base du système et le kernel.

J'utilise la version zen du kernel linux, pour la version standard, vous pouvez remplacer linnux-zen par linux. Si vous avez un processeur Intel et non AMD remplacer également amd-ucode par intel-ucode.

pacstrap /mnt base linux-zen linux-firmware amd-ucode iptables-nft nftables vim

Je procède à l'installation de nftables lors de cette étape pour être sûr que iptables ne soit pas installé comme dépendant d'un autre paquet.

Ensuite nous allons généré le fichier fstab en utilisant les labels pour les partitions :

genfstab -L -p /mnt >> /mnt/etc/fstab

Il faut également définir un nom pour notre nouveau système, ici ce sera nowhere.

echo "nowhere" > /etc/hostname

Il faut également définir le contenu du fichier /etc/hosts, je vais ça en une seule commande mais vous pouvez également éditer le fichier manuellement :

cat <<EOF> /etc/hosts
127.0.0.1       localhost.localdomain  localhost
127.0.1.1       nowhere.nowhere        nowhere

::1             localhost ip6-localhost ip6-loopback
ff02::1         ip6-allnodes
ff02::2         ip6-allrouters
EOF

Configuration du système

Configuration basique

Dans un premier temps nous devons entrer dans notre nouveau système:

arch-chroot /mnt

Puis définir la zone temporelle et définir l'heure matériel sur notre machine, pour moi il s'agit de Paris:

ln -sf /usr/share/zoneinfo/Europe/Paris /etc/localtime
hwclock --systohc

Cette configuration sera faite pour le français mais vous pouvez adapter fr_FR par la langue de votre choix.

sed -i '/fr_FR.UTF-8 UTF-8/s/^#//g' /etc/locale.gen
locale-gen
echo "LANG=fr_FR.UTF-8" > /etc/locale.conf

Installation des paquets supplémentaires

Nous allons ensuite ajouter des paquets supplémentaires utiles pour l'installation de notre système.

pacman -Syu networkmanager base-devel efibootmgr btrfs-progs gptfdisk neovim zsh sudo ttf-dejavu sbctl polkit git openssh wget

Préparation de notre système de boot

Pour cette installation j'ai décidé d'utiliser systemd-init à la place de busybox-init notamment pour son meilleur support de plymouth avec le chiffrement complet du disque.

Dans le fichier /etc/mkinitcpio.conf nous allons modifier les variables MODULES pour le support du GPU, BINARIES pour corriger un problème d'affichage avec plymouth et HOOKS pour correspondre à la configuration de notre système en ajoutant le hook BTRFS notamment.

MODULES=(amdgpu)
BINARIES=(setfont)
HOOKS=(base systemd plymouth autodetect microcode modconf kms keyboard sd-vconsole sd-encrypt block btrfs filesystems fsck)

Ensuite dans le fichier /etc/kernel/cmdline nous allons définir les paramètres de démarrage de notre kernel, notamment pour lui indiquer sur quel partition démarré :

fbcon=nodefer rw rd.luks.allow-discards plymouth.use-simpledrm quiet bgrt_disable root=LABEL=system rootflags=subvol=@root,rw splash vt.global_cursor_default=0

plymouth.use-simpledrm est spécifique à l'utilisation de plymouth avec un GPU AMD qui peut causer des problèmes d'affichage.

Puis comme notre système est chiffré il faut ajouter la configuration nécessaire pour le démarrage dans le fichier /etc/crypttab.initramfs :

system /dev/disk/by-partlabel/cryptsystem none timeout=180

Pour le support du secure boot nous devons créer les clé de signatures :

sbctl create-keys

Et généré l'image efi du kernel :

sbctl bundle -k /boot/vmlinuz-linux-zen -f /boot/initramfs-linux-zen.img -s /efi/main.efi

Avec le kernel standard de linux la commande n'a pas besoin des chemins comme avec le kernel zen : sbctl bundle -s /efi/main.efi

Ensuite nous ajoutons dans notre UEFI l'entrée pour le boot de notre système :

efibootmgr --create --disk /dev/nvme0n1 --part 1 --label "Arch Linux" --loader 'main.efi' --unicode

Ici /dev/nvme0n1 est le disque sur lequel j'ai fait l'installation et 1 le numéro de partition EFI. C'est informations sont vérifiable avec fdisk -l.

utilisateur

Nous allons pouvoir ajouter un utilisateur qui nous servira également pour l'installation de la version de developpement de plymouth pour la gestion de l'écran de démarrage.

Dans un premier temps changeons le mot de passe de l'utilisateur root:

passwd

Puis ajoutons notre utilisateur qui utilisera zsh comme terminal, le nom de ce dernier sera nothing dans mon cas. Nous allons également en profiter pour définir son mot de passe :

useradd -m -G wheel,storage,power,tty,systemd-journal --btrfs-subvolume-home -s /usr/bin/zsh nothing

passwd nothing

Libre à vous de modifier les groups auquel appartiendra votre utilisateur cependant dans le cas de mon utilisation quotitienne l'appartenance à ces groupes est nécessaire.

Pour la suite il est nécessaire de donner à notre utilisateur des droits sudo. Une solution commune est d'éditer le /etc/sudoers avec la commande visudo pour décommenter une des lignes donnant ces droits via le groupe wheel.

Ici je vais simplement ajouter une ligne dédié à mon utilisateur :

echo "nothing ALL=(ALL:ALL) ALL" > /etc/sudoers.d/nothing

Nous allons maintenant prendre l'identité de cet utilisateur mais avec le shell bash pour éviter la configuration de zsh :

su -s /usr/bin/bash - nothing

Afin d'installer les paquets AUR d'Arch Linux j'utile yay mais plusieurs autres solution sont possibles comme aura, paru ou l'installation des AUR directement via makepkg.

cd /tmp
git clone https://aur.archlinux.org/yay.git
cd yay
makepkg -si

Nous pouvons ensuite installer plymouth et si vous le souhaitez mkinitcpio-firmware pour limiter les message d'avertissement de mkinitcpio indiquant des firmwares manquants.

yay -Sy plymouth-git mkinitcpio-firmware

Nous allons ensuite définir le thème pour notre plymouth :

sudo plymouth-set-default-theme -R spinner

Si vous ne savez pas le quel choisir je vous recommande de laisser celui-ci pour le moment et de le changer après le redémarrage de votre système.

Nous allons regénéré l'image efi :

sudo sbctl generate-bundles -s

Finalisation

Sortez de votre utilisateur non root et du chroot puis redémarrez le système. Nous continuerons une fois le système démarré.

exit
exit
reboot

Si tout est bien configuré votre système devrait démarrer et vous demander votre mot de passe pour dévérouiller le disque.

Une fois le système redémarré et connecté avec notre utilisateur nous allons ajouté les clés secure boot dans l'EFI du système.

Si vous avez un dual-boot avec Windows il faudra rajouter l'argument -m à cette commande.

sudo sbctl enroll-keys

Activons la synchronisation du temps:

sudo timedatectl set-ntp true

Il faut définir le type de clavier pour vconsole, dans mon il s'agit de us-acentos, vous pouvez obtenir la liste avec la commande localectl list-keymaps:

sudo localectl set-keymap us-acentos

Framework Laptop 16

Comme je suis sur un Framework Laptop 16 il y a quelques ajustements conseillés pour ce matériel dans la documentation.

Ici je ne traiterais que les configurations utiles avant la présence d'un environnement graphique.

Paramètres Wifi

Afin d'assurer le bon fonctionnement de la carte Wifi en utilisant les fréquence de notre zone géographique l'installation de la base de donnée des zones géographiques et sa configuration est nécessaire:

sudo pacman -S wireless-regdb
sudo sed -i '/WIRELESS_REGDOM="FR"/s/^#//g' /etc/conf.d/wireless-regdom
echo "country=FR" | sudo tee /etc/wpa_supplicant/wpa_supplicant.conf

L'application de cette configuration nécessitera un redémarrage.

Désactivation de la sortie de veille par clavier ou touchpad

Dans certains cas de transport l'écran peut appuyer sur le clavier et sorti l'ordiateur de veille ce qui peut poser problème. Pour que la sortie de veille ne se fasse qu'avec le bouton d'alimentation dans le fichier /etc/udev/rules.d/90-disable-keyboard-wake.rules il faut ajouter le contenu:

ACTION=="add", SUBSYSTEM=="usb", ATTRS{idVendor}=="32ac", ATTRS{idProduct}=="0012", ATTR{power/wakeup}="disabled"

Et recharger les règles :

sudo udevadm control --reload
sudo udevadm trigger

Gestion des capteurs

La récupération des informations provenant des capteurs et souvent faite via lm_sensors cependant la configuration pour les framework.

Nous allons donc ajouter la configuration nécessaire :

sudo pacman -S lm_sensors --needed
sudo curl https://raw.githubusercontent.com/FrameworkComputer/lm-sensors/refs/heads/framework/configs/Framework/Framework16-AMD.conf -o /etc/sensors.d/Framework16-AMD.conf

Personnalisations

La suite de l'installation concerne les personnalisations comme l'environnement de bureau.
Je ne détaillerais pas cette partie ici cependant vous trouverez mes dotfiles pour cette partie ici.
J'ai deux configurations avec Plasma6 ou Sway que je gère avec l'outil chezmoi.

J'espère que cette article vous a été utile, n'hésitez pas à laisser un commentaire.

Malheureusement après quelques recherches on voit que son déploiement n'est pas très documenté sur machine Linux pour une utilisation supérieur à du simple test mais ne nécessitant pas un cluster pour la gestion de millions d'utilisateurs.

Passons à la partie amusante en voyant comment déployer cette solution sur une machine Linux.

Pour cette article j'utilise une VM Ubuntu 22.04 avec 4vCPU, 8Go de RAM et 80 Go de disque avec un utilisateur qui a toutes les permissions avec sudo.

Nous aurons besoin de mettre en place une base de données PostgreSQL puis un reverse-proxy pour simplifier la gestion du SSL, j'ai choisi d'utiliser Caddy qui gère déjà mes domaines sur mon infrastructure cependant il est possible d'utiliser Nginx ou encore de passer par Cloudflare, les autres solutions sont documentées ici.
Pour la base de données Zitadel recommande l'utilisation de Cockroach en production mais à nouveau dans cette exemple nous sommes sur une petite production où la mise en place d'un cluster de ce type serait surdimensionné.

Installation de PostgreSQL

Installation

Nous aurons besoin d'une installation basique de PostgreSQL en ajoutant les dépôts officiel via le script présent dans la distribution Ubuntu :

sudo apt install -y postgresql-common

sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh

Configuration

Nous devons ensuite créer un utilisateur et une base de donnée pour Zitadel :

sudo -u postgres psql

CREATE USER zitadel WITH PASSWORD '<mot de passe>';
CREATE DATABASE zitadel;
GRANT CONNECT, CREATE ON DATABASE zitadel TO zitadel;

Installation de Zitadel

L'installation de Zitadel est une opération manuelle.

Voici un résumé des étapes que nous allons réaliser :

1. Récupérer le binaire de Zitadel
2. Créer un utilisateur
3. Créer les répertoires
4. Définir les permissions sur les répertoires
5. Créer le service

Commençons par la récupération du binaire à partir de la dernière version publiée sur Github :

LATEST=$(curl -i https://github.com/zitadel/zitadel/releases/latest | grep location: | cut -d '/' -f 8 | tr -d '\r'); wget -c https://github.com/zitadel/zitadel/releases/download/$LATEST/zitadel-linux-amd64.tar.gz -O - | tar -xz && sudo mv zitadel-linux-amd64/zitadel /usr/local/bin

Ici en une ligne nous récupérons la dernière version disponible, nous téléchargeons cette version, la décompressons puis déplaçons le binaire.
Sur la documentation officielle vous trouverez une méthode qui prend également en compte l'architecture de la machine.

Nous créons un utilisateur pour notre outil :

sudo useradd -r -U -M -d /var/lib/zitadel/ -s /usr/sbin/nologin zitadel

Nous utilisons plusieurs arguments:

• -r permet d'indiquer quíl s'agit d'un utilisateur système
• -U pour créer un groupe avec le même nom que l'utilisateur
• -M pour ne pas créer de répertoire HOME
• -d pour définir le répertoire à utiliser comme dossier HOME
• -s pour définir le Shell de connexion de l'utilisateur (ici notre utilisateur n'ayant pas besoin de se connecter au système de façon interactive nous pouvons utiliser /usr/sbin/nologin)

Ensuite il faut créer les dossiers qui seront utilisés par Zitadel :

sudo mkdir -p /var/lib/zitadel /etc/zitadel
tr -dc A-Za-z0-9 </dev/urandom | head -c 32 | sudo tee /etc/zitadel/zitadel-masterkey
sudo touch /etc/zitadel/config.yaml /etc/default/zitadel
sudo chown -R zitadel:zitadel /var/lib/zitadel
sudo chown -R root:zitadel /etc/zitadel
sudo chown root:root /etc/default/zitadel
sudo chmod 640 /etc/zitadel/config.yaml /etc/default/zitadel /etc/zitadel/zitadel-masterkey

La deuxième commande permettra de générer la clé de sécurité pour le chiffrement des données dans Zitadel.

Nous pouvons ensuite créer le service qui permettra de lancer notre outil :

[Unit]
Description=Zitadel

[Service]
RestartSec=2s
Type=simple
User=zitadel
Group=zitadel
EnvironmentFile=/etc/default/zitadel
WorkingDirectory=/var/lib/zitadel
ExecStart=/usr/local/bin/zitadel start --config /etc/zitadel/config.yaml --masterkeyFile ${MASTERKEYFILE} --tlsMode ${TLSMODE}
ExecReload=/bin/kill -HUP $MAINPID
KillMode=process
Restart=on-failure

[Install]
WantedBy=multi-user.target

Comme certains paramètres en arguments nous allons définir les valeurs associées :

USER=zitadel
GROUP=zitadel
HOME=/var/lib/zitadel
TLSMODE=external
MASTERKEYFILE=/etc/zitadel/zitadel-masterkey

Il faut ensuite recharger le daemon systemd pour appliquer la configuration du service :

sudo systemctl daemon-reload

Configuration de Zitadel

La première configuration consiste à définir les ports d'écoute et la connexion à la base de donnée. Nous allons donc éditer le fichier /etc/zitadel/config.yaml:

Port: 8080
ExternalPort: 443
ExternalDomain: <votre domaine>
ExternalSecure: true
TLS:
  Enabled: false
Database:
  postgres:
    Host: localhost
    Port: 5432
    Database: zitadel
    User:
      Username: zitadel
      Password: <mot de passe>
      SSL:
        Mode: disable

Vous trouverez toutes les options de configuration dans la documentation.

Nous pouvons maintenant lancer l'initialisation de Zitadel via la commande appropriée :

sudo -u zitadel -g zitadel zitadel init --config /etc/zitadel/config.yaml zitadel
sudo -u zitadel -g zitadel zitadel setup --config /etc/zitadel/config.yaml --tlsMode external --masterkeyFile /etc/zitadel/zitadel-masterkey --init-projections

Comme nous avons déjà créer la base de donnée et l'utilisateur associé (afin de ne pas fournir de compte avec des droits élevés sur la base). La première commande permet de vérifier la configuration et de créer le schéma dans la base de données, la deuxième effectue les migrations nécessaire pour peupler cette dernière.

Cette étape va également configurer le compte administrateur avec les informations suivantes :

• Utilisateur: zitadel-admin@<hostname VM>.<domaine Zitadel>
• Mot de passe: Password1!

Vous pouvez également utiliser PostgreSQL pour récupérer le nom d'utilisateur :

sudo -u postgres psql -d zitadel -c '\x' -c 'SELECT user_name FROM auth.users2;'

Installation du reverse proxy

Comme indiqué plus haut nous allons installer et configurer Caddy qui sera notre reverse proxy. Comme nous avons définir le mode TLS comme external il sera en charge d'ajouter cette couche.

Un des avantages de Caddy est la génération de certificats automatiquement avec Let's Encrypt.

Il est disponible depuis les dépôts Ubuntu :

sudo apt install Caddy

Nous pouvons ensuite le configurer avec notre domaine pour transmettre les requêtes à Zitadel en grpc. Cette configuration se fait via le fichier /etc/caddy/Caddyfile qu'il faut créer s'il n'existe pas.

zitadel.thystips.net {
	reverse_proxy h2c://127.0.0.1:8080
}

Cette configuration est suffisante pour mettre en place le reverse proxy dont nous avons besoin. Caddy utilisera le challenge HTTP01 pour demander un certificat à Let's Encrypt.

Si cette solution n'est pas adapté pour vous je vous invite à lire la documentation de Caddy sur les autres possibilité de configuration du TLS.

Démarrage de la solution

Maintenant nous pouvons lancer les deux services nécessaire pour que notre solution soit accessible :

sudo systemctl enable --now zitadel.service caddy.service

L'interface d'administration est maintenant accessible via : https://<votre domaine>/ui/console, dans mon cas il s'agit donc de https://zitadel.thystips.net.

Une fois connecté vous serrez amené à changer le mot de passe de l'utilisateur et si vous le souhaitez à définir un second facteur d'authentification pour sécurisé votre compte.

Après avoir jouer avec pendant quelques heures on remarque que l'intégration LDAP n'est pas encore très aboutie au moment où je rédige cet article.
Je reste à l’affût de plusieurs issues et discussions à ce sujet sur Github :

• Discussion sur le fonctionnement de l'intégration LDAP
• Choix du certificats pour le vérifier le LDAPS
• Synchronisation des groupes LDAP

Peut-être que je ferais un autre article pour parler un peu de mon retour d'expérience en détail et faire une présentation de la configuration de l'outil.

RADIUS (Remote Authentication Dial-In User Service) est un protocole client-serveur permettant de centraliser des données d'authentification. Le protocole RADIUS a été inventé et développé en 1991 par la société Livingston enterprise (rachetée par Lucent Technologies), qui fabriquait des serveurs d'accès au réseau pour du matériel uniquement équipé d'interfaces série; il a fait ultérieurement l'objet d'une normalisation par l'IETF.

Fonctionnement d’un RADIUS

Le fonctionnement de RADIUS est basé sur un scénario proche de celui-ci (schéma ci-dessus) :

• Un utilisateur envoie une requête au NAS afin d’autoriser une connexion à distance ;
• Le NAS achemine la demande au serveur RADIUS ;
• Le serveur RADIUS consulte la base de données d’identification afin de connaître le type de scénario d’identification démandé pour l’utilisateur. Soit le scénario actuel convient, soit une autre méthode d’identification est demandée à l’utilisateur.

Les étapes d’installation d’un serveur RADIUS (Windows serveur)

Installation du serveur RADIUS

• Dans le gestionnaire windows serveur vous allez ajouter un rôle (Add Roles and Features) et dans « Server Roles » selectionnez l’option « Network Policy and Access services »
• Cliquez sur « Add Features »
• Ensuite allez sur « Role service » et cochez « Network Policy Server »
• Et confirmez et cliquez sur « Install »

Intégration Active Directory

Après l’installation du serveur RADIUS vous devez créer un groupe d'utilisateurs autorisés à s'authentifier à l'aide de Radius. Créez le groupe RADIUS-USER (par exemple).

Ajouter des périphériques clients

• Après avoir intégrer un groupe sur le serveur, ouvrez l’application « Network policy Server ».Vous devez autoriser le serveur Radius sur la base de données Active Directory. Clique-droit sur NPS (local) et sélectionnez l’option « register server in Active Directory » ;
• Ensuite il faut configurer les clients RADIUS. Les clients Radius sont des périphériques qui seront autorisés à demander l'authentification du serveur Radius. Important! Ne confondez pas les clients Radius avec les utilisateurs Radius. Clique-droit sur le dossier Radius Clients et sélectionnez l'option Nouveau.
• Vous devez définir la configuration suivante:
  • Nom convivial du périphérique.
  • Adresse IP du périphérique.
  • Secret partagé par périphérique.

Le secret partagé sera utilisé pour autoriser le périphérique à utiliser le serveur Radius.

Configurer une stratégie réseau

Maintenant, vous devez créer une police de réseau pour permettre l'authentification.

• Cliquez avec le bouton droit sur le dossier Stratégies de réseau et sélectionnez l'option Nouveau. Entrez un nom pour la stratégie réseau et cliquez sur le bouton Suivant.
• Cliquez sur le bouton Ajouter une condition. Nous allons permettre aux membres du groupe RADIUS-SERS de s'authentifier.
• Sélectionnez l'option Groupe d'utilisateurs et cliquez sur le bouton Ajouter.
• Cliquez sur le bouton Ajouter des groupes et localisez le groupe RADIUS-USERS.
• Sélectionnez l'option Accès accordé et cliquez sur le bouton Suivant. Cela permettra aux membres du groupe RADIUS-USERS de s'authentifier sur le serveur Radius.
• Je définis la méthode d’authentification Authentification non chiffrée (PAP, SPAP).

Aujourd'hui j'ai décidé de mettre en place une nouvelle plateforme pour la gestion des demandes supports avec Zammad.

Zammad est une solution de gestion des demandes support très complète et disponible en en version commerciale sur https://zammad.com/ ou open-source https://zammad.org/.
Vous y trouverez toutes les fonctionnalités nécessaires pour une plateforme support mais parmis les raisons de mon coup de coeur nous retrouvons les grandes possibilités d'intégration (LDAP, GPG, S/MINE, Exchange, VoIP, supervision, etc. liste exhaustive ici), la possibilité de recherche dans le contenu des tickets (nécessite Elasticsearch) et la présence de nombreux canaux de communication (interface web, formulaires, mail, chat, sms et plus encore).

Prérequis

Pour ce tutoriel nous allons déployer Zammad sur une machine virtuel Ubuntu 22.04, l'accès depuis l'extérieur se fera via un reverse proxy Caddy hébergé sur une autre machine.

En terme de spécification Zammad recommande au minimum :
- vCPU : 2
- RAM : 4Go (+4Go si vous voulez utiliser Elasticsearch pour les recherches)
Plus d'information dans la documentation.

Pour ce qui est de l'espace disque Zammad ne donne pas de recommandation comme il s'agit d'un point à définir en fonction de votre utilisation. Ici je vais partir sur 50Go afin d'avoir un dimensionnement suffisant pour un moment.

Installation

Nous allons maintenant passer à l'installation de notre plateforme.

Dépendances

Commençons par l'installation des dépendances :

sudo apt install apt-transport-https wget curl gnupg

Memcached

Pour la gestion du cache de Zammad j'ai choisi d'utiliser Memcached qui n'est pas obligatoire. Sans Memcached le cache sera stocké dans /opt/zammad/tmp/cache*.

sudo apt install memcached

Une valeur raisonnable pour la taille du cache est de 1Go que nous pouvons définir en modifiant la configuration de memcached :

-m 1024

Puis activer et redémarrer le service

sudo systemctl enable memcached.service
sudo systemctl restart memcached.service

Installation d'Elasticsearch

Que vous choisissiez d'utiliser Elasticsearch pour les fonctionnalités de recherche ou non sont installation avec le plugin "attachment" est nécessaire car il s'agit d'une dépendance obligatoire de Zammad.

Pour simplifier notre installation nous allons utiliser la version 7 d'Elasticsearch sur notre machine. Cependant il est également possible d'utiliser la version 8 ou un cluster distant, dans ces cas d'utilisation je vous invite à prendre connaissance de la documentation.

echo "deb [signed-by=/etc/apt/trusted.gpg.d/elasticsearch.gpg] https://artifacts.elastic.co/packages/7.x/apt stable main"| \
  sudo tee -a /etc/apt/sources.list.d/elastic-7.x.list > /dev/null
curl -fsSL https://artifacts.elastic.co/GPG-KEY-elasticsearch | \
  gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/elasticsearch.gpg> /dev/null
sudo apt update
sudo apt install elasticsearch
sudo /usr/share/elasticsearch/bin/elasticsearch-plugin install ingest-attachment

Configuration d'Elasticsearch

La documentation recommande quelques modification afin de lancer le service afin de permettre un fonctionnement optimal des fonctions de recherche.

# Nom du cluster Elasticsearch
cluster.name: zammad
# Stockage des données (valeur définie par défaut)
path.data: /var/lib/elasticsearch
# Stockage des journaux (valeur définie par défaut)
path.logs: /var/log/elasticsearch

# Taille maximum d'indexation d'un ticket (risque de perte de performance au-delà de cette valeur)
http.max_content_length: 400mb
# Autoriser les requêtes de recherche plus complexe (Au dessus de cette valeur l'utilisation des ressources système peut devenir trop intensive)
indices.query.bool.max_clause_count: 2000

Nous pouvons maintenant passer démarrer le service Elasticsearch

sudo systemctl daemon-reload
sudo systemctl enable --now elasticsearch

Définition des locales

Afin d'assurer une bon fonctionnement pour notre langue nous allons définir les données de langage.

sudo apt install locales
sudo locale-gen fr_FR.UTF-8
echo "LANG=fr_FR.UTF-8" | sudo tee /etc/default/locale

Installation de Zammad

L'installation de Zammad se fait directement via un paquet qui est disponible dans le dépôt officiel que nous allons ajouter :

curl -fsSL https://dl.packager.io/srv/zammad/zammad/key | \
  gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/pkgr-zammad.gpg> /dev/null
echo "deb [signed-by=/etc/apt/trusted.gpg.d/pkgr-zammad.gpg] https://dl.packager.io/srv/deb/zammad/zammad/stable/ubuntu 22.04 main"| \
  sudo tee /etc/apt/sources.list.d/zammad.list > /dev/null
sudo apt update

$ sudo apt install zammad

Configuration du serveur

Maintenant nous allons voir quelques étapes de configuration.

Connexion à Elasticsearch

Nous allons indiquer à Zammad les informations nécessaires pour la connexion à notre service Elasticsearch :

# Adresse pour se connecter à Elasticsearch
sudo zammad run rails r "Setting.set('es_url', 'http://localhost:9200')"

# Ignore l'indexationn de certains types de fichiers pour préserver les performance
sudo zammad run rails r "Setting.set('es_attachment_ignore',\
  [ '.png', '.jpg', '.jpeg', '.mpeg', '.mpg', '.mov', '.bin', '.exe', '.box', '.mbox' ] )"

# Définition de la taille maximal en MB des fichiers joints à indexer
sudo zammad run rails r "Setting.set('es_attachment_max_size_in_mb', 50)"

# Lancer la recréation de l'index
sudo zammad run rake zammad:searchindex:rebuild
Dropping indexes... done.
Deleting pipeline... done.
Creating indexes... done.
Creating pipeline... done.
Reloading data...
  - Chat::Session...
    done in 0 seconds.
  - Cti::Log...
    done in 0 seconds.
  - Group...
    done in 0 seconds.
  - KnowledgeBase::Answer::Translation...
    done in 0 seconds.
  - KnowledgeBase::Category::Translation...
    done in 0 seconds.
  - KnowledgeBase::Translation...
    done in 0 seconds.
  - Organization...
    done in 0 seconds.
  - StatsStore...
    done in 0 seconds.
  - Ticket::Priority...
    done in 1 seconds.
  - Ticket::State...
    done in 1 seconds.
  - Ticket...
    done in 0 seconds.
  - User...
    done in 0 seconds.

Utilisation de Memcached pour le cache

L'utilisation de Memcached se fait simplement en indiquant l'adresse du service. Si ce dernier est installé sur la même machine que Zammad :

sudo zammad config:set MEMCACHE_SERVERS=127.0.0.1:11211

Dernier ajustements

Nous devons maintenant définir le nom de domaine qui sera utilisé ainsi que le protocole, dans cet example le nom de domaine sera support.thystips.net et en HTTPS. Nous allons ensuite redémarrer le service Zammad.

sudo zammad config:set ZAMMAD_FQDN=suport.thystips.net
sudo zammad config:set ZAMMAD_HTTP_TYPE=https
sudo systemctl restart zammad

Configuration du serveur web

Nous allons maintenant configurer notre serveur web, Nginx sera utilisé comme serveur web et nous verrons plus types de configurations.

Je vous laisse choisir uniquement la sous section qui convient à votre besoin :

• Déploiement uniquement pour des tests vous pouvez vous diriger vers la section : Sans SSL.
• Machine hébergeant Zammad directement accessible depuis l'extérieur (IP publique ou NAT) : Service exposée publiquement.
• Utilisation de Caddy comme reverse-proxy : Sans SSL puis Reverse proxy Caddy.

Sans SSL

Pour une utilisation en locale sans SSL nous allons récupérer le fichier d'exemple fourni avec le paquet Zammad.

sudo cp /opt/zammad/contrib/nginx/zammad.conf /etc/nginx/sites-available/

Si Zammad est le seul hébergé par Nginx sur cette machine nous pouvons le définir comme site par défaut :

[...]
server {
    listen 80 default_server;
    listen [::]:80 default_server;

    server_name _;
[...]

sudo rm /etc/nginx/sites-enabled/default
sudo ln -s /etc/nginx/sites-{available,enabled}/zammad.conf
sudo systemctl restart nginx.service

Zammad est maintenant accessible sans SSL sur le port défini (ici 80) via l'IP de votre machine.

Service exposée publiquement

Si votre machine est accessible publiquement et que vous avez un domaine pointant vers cette dernière, par exemple support.thys.tips pour cet exemple.

Premièrement je vous recommande bien sécuriser votre machine en configurant correctement votre pare-feu (UFW sur ubuntu par défaut mais j'ai une préférence pour firewalld) et en utilisant une clé SSH pour la connexion à votre machine par exemple.

Afin de générer les certificats nécessaires nous allons utiliser certbot et l'exemple de configuration de Zammad sans SSL.

Les premières étapes sont proches de la section précédente :

sudo cp /opt/zammad/contrib/nginx/zammad.conf /etc/nginx/sites-available/

Ensuite vous devez modifier server_name dans le fichier /etc/nginx/sites-available/zammad.conf afin d'y mettre le nom de domaine que vous avez choisi.

Vous pouvez ensuite activer et recharger la configuration Nginx :

sudo ln -s /etc/nginx/sites-{available,enabled}/zammad.conf
sudo systemctl restart nginx.service 

Nous pouvons ensuite passer à la génération des certificats :

sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx --hsts --staple-ocsp -d <votre-domaine>

Vous pouvez indiquer que vous souhaitez la redirection HTTP vers HTTPS.

Certbot se chargera de modifier la configuration pour y inclure le nécessaire pour l'activation du SSL.

Votre instance de Zammad est maintenant accessible depuis : https://<votre-domaine>.

Reverse proxy Caddy

Après avoir suivi les instruction de la section Sans SSL nous pouvons configurer Caddy comme reverse proxy.

Caddy s'installe directement via son paquet :

sudo apt install caddy

La configuration de Caddy se fait dans le fichier `/etc/caddy/Caddyfile`, afin de simplifier la configuration ultérieure de plusieurs domaines j'utilise des blocs que je peux importer :

# Configuration par défaut
{
    # Email pour la génération des certificats
    email <votre-email-pour-letsencrypt>
}

# Définition des paramètres pour obtenir les logs sous forme de fichier
(logging) {
    log {
        output file /var/log/caddy/caddy-{args[0]}.log {
            roll_size 1Mib
            roll_local_time
            roll_keep 24
            roll_keep_for 7d
        }
    }
}

# Définition des entêtes pour la sécurité
(headers) {
    header {
        -server
        Permissions-Policy interest-cohort=()
        Strict-Transport-Security max-age=31536000;
        X-Content-Type-Options nosniff
        X-Frame-Options DENY
        Referrer-Policy no-referrer-when-downgrade
    }
}

Ensuite en dessous de cette configuration nous pouvons définir la configuration pour notre service Zammad :

<votre-domaine> {
	reverse_proxy http://<ip-de-zammad> {
		header_up X-Real-IP {remote_host}
	}
	encode zstd gzip
	import logging <nom-du-fichier-de-log>
	import headers
}

Voici la configuration que j'utilise :

support.thystips.net {
	reverse_proxy http://10.1.70.20 {
		header_up X-Real-IP {remote_host}
	}
	encode zstd gzip
	import logging support
	import headers
}

Il faut ensuite redémarrer le service associé afin que Caddy recharge sa configuration et commence la génération des certificats.

Vous instance Zammad est accessible depuis : https://<votre-domaine>.

Première connexion

Maintenant que vous avez accès à l'interface de Zammad vous devriez avoir la page suivante :

Nous allons pouvons procéder à la configuration de notre solution.

Commencez par créer votre compte administrateur :

Ensuite définir des informations de basiques au sujet de votre organisation :

La configuration d'un SMTP externe lors de la première configuration a tendance à être en échec, vous pouvez passer cette étape et revenir sur cette configuration par la suite :

Je vous recommande également de sauter l'étape suivant et de revenir sur la configuration des canaux de communication par la suite.

Configuration de Zammad

Nous pouvons maintenant passer à la configuration granulaire de notre plateforme support pour répondre à nos besoin.

L'accès aux paramètres se fait via l'icon en forme de roulette en bas à gauche de l'interface. Pensez également à bien valider les modification en appuyant sur le bouton Envoyer.

Nom de l'instance

Nous avons déjà défini le nom de notre organisation pendant la première connexion mais le nom de la plateforme est tout celui par défaut :

Groupes

Vous pouvez créer des groupes pour isoler différents services sur votre plateforme support. Ici j'ai simplement remplacer le groupe Users par un nom que j'ai défini.

Email

J'ai conseillé plus haut de sauter la configuration du serveur SMTP, nous allons y revenir maintenant.
La première chose à faire et de définir l'adresse qui devra être utilisée pour l'envoi des notifications :

Vous pouvez maintenant définir le serveur SMTP pour les notifications.

Enfin si vous souhaitez configurer la création de ticket par email vous pouvez définir des comptes et les attacher aux groupes définis plus haut.

Authentification externe

Il est possible de relier Zammad à un serveur LDAP afin de récupérer les utilisateurs depuis ce dernier.

On commence par définir les information pour joindre le serveur LDAP :

Puis la définition de l'utilisateur qu'utilisera Zammad pour s'y connecter :

Nous pouvons ensuite définir les attributs LDAP qui seront utilisés dans Zammad, cette configuration est adapté pour OpenLDAP et FreeIPA pour Active Directory l'attribut UID sera samAccountName. Vous pouvez également lié des groupes LDAP à des rôles dans Zammad comme ici où j'ai un groupe pour les administrateurs, un pour les agent et un dernier pour les personne ayant accès à la plateforme en tant que client.

Vous aurez ensuite un récapitulatif du nombre d'utilisateurs qui seront importés.

Premier ticket

La création de ticket peut se faire de plusieurs façon en fonction de votre configuration (interface web, mail, chat, etc.), comme nous avons configurer une boîte mail dans la section Email nous allons faire un test.

Voici le mail que je viens d'envoyer sur l'adresse configurée dans Zammad :

En retour j'ai automatiquement reçu ce mail pour confirmer la création de ma demande :

Il faudra que je pense à modifier ce message.

Maintenant allons faire un petit tour sur notre interface et probablement qu'il n'y aura pas de ticket 🥲
Si vous avez fait comme moi vous avez le rôle Admin mais pas le rôle Agent sauf que les tickets sont traités par les agents et non les admins donc on va rectifier ça !

Afin de se donner les droits d'Agent pour traiter les tickets :

Maintenant allons voir nos nouveaux tickets :

Comme vous pouvez le voir nous avons un nouveau ticket.

Une fois ouvert nous avons accès à une interface assez complète afin de répondre et classifier notre ticket.

Une fois les modification faites vous pouvez les valider avec le bouton Mise à jour en bas à droite.

J'espère que vous avez trouvez cet article utile !

N'hésitez pas à laisser un commentaire.

Pour cette raison voici un tutoriel pour réaliser cette action en réseau via SSH.

Prérequis

• Ubuntu (testé sur ubuntu 20.04)
• Partition chiffrée
• Adresse IP fixe (ou équivalent)
• Pair de clés SSH

Mise à jour du système

Dans un premier temps il faut que le système soit à jour.

apt update
apt upgrade -y

Installation de dropbear pour initramfs

Dans cette partie nous allons installer une version spécifique du serveur SSH Dropbear avec des fonctionnalités lui permettant de fonctionner dans un environnement initramfs qui est utilisé pendant le démarrage.

apt install dropbear-initramfs

NOTE: À l'installation l'erreur suivante peut s'afficher :

dropbear: WARNING: Invalid authorized_keys file, remote unlocking of cryptroot via SSH won't work!

Cette erreur sera réglée par la suite.

Configuration de dropbear

Le fichier de configuration spécifique au paquet dropbear-initramfs est le suivant :
/etc/dropbear-initramfs/config.

Changement du port par défaut

Comme l'environnment initramfs ne permet pas l'usage d'un pare-feu il est recommandé de changer le port utilisé par le serveur dropbear.

Par exemple utiliser le port 9210 il faut ajouter la ligne suivante au fichier de configuration :

/etc/dropbear-initramfs/config

DROPBEAR_OPTIONS="-p 9210"

Méthode alternative

Pendant les recherches j'ai vu que certaines personne avait eu des problèmes avec cette configuration. Il semblerait que dans certains cas, mettre la ligne DROPBEAR_OPTION dans le fichier /etc/initramfs-tools/initramfs.conf permettrait de régler le problème.

Ajustement

Pour voir les options toutes disponibles utilisez la commande man dropbear.

Personnellement j'ai choisi d'ajouter les options :

• -s : Désactive la connexion par mot de passe
• -j : Désactivation du forwarding de port local
• -k : Désactivation du forwarding de port distant
• -I 60 : Temps avant la coupure de la connexion lorsqu'il n'y a pas de transmission de traffic

Résultat nous avons la configuration suivante :

/etc/dropbear-initramfs/config

DROPBEAR_OPTIONS="-p 9210 -s -j -k -I 60"

Authentification SSH

Maintenant comme nous avons désactivé la connexion par mot de passe il faut ajouter votre clé publique aux clés ssh autorisées.

Cette clé doit être ajoutée dans le fichier /etc/dropbear-initramfs/authorized_keys, une clé par ligne.

Si vous voulez réduire les privilèges liés à une clé pour n'autorisé que l'action de déchiffrement vous pouvez ajouter les instructions suivantes au début de la ligne:
no-port-forwarding,no-agent-forwarding,no-x11-forwarding,command="/bin/cryptroot-unlock".

NOTE: Pour rappel, dans le cas d'une clé RSA le vôtre est probablement dans le fichier ~/.ssh/id_rsa.pub sur votre machine et non le serveur.
Si vous avez besoin d'en générer une la commande ssh-keygen de votre station de travail a cette fonction.

Après avoir modifié la configuration de dropbear, il ne faut pas oublier de reconstruire l'envirronement initramfs: update-initramfs -u.

Paramètres IP du Kernel

Afin d'avoir une IP fixe lors du démarrage il faut définir les paramètres IP au niveau du kernel.

Définition d'une IP statique

Il est possible de définir une IP statique au démarrage en modifiant le paramètre GRUB_CMDLINE_LINUX_DEFAULT du fichier /etc/default/grub.
Pour se faire il faut ajouter l'instruction suivante : ip=<ip>::<ip-passerelle>:<masque>.

Voici un exemple :

GRUB_CMDLINE_LINUX_DEFAULT="maybe-ubiquity ip=192.168.1.2::192.168.1.1:255.255.255.0"

Ensuite il ne faut pas oublier de mettre à jour la configuration de grub :

update-grub

Méthode alternative

Pour cette étape aussi j'ai pu observer que pour certaines personnes cette méthode ne fonctionne pas correctement, si vous êtes dans cette situation vous pouvez essayer ce qui suit.

À la place de modifier le fichier /etc/default/grub, il est possible d'ajouter la ligne : IP="<ip>::<ip-passerelle>:<masque>::eth0:off" au fichier /etc/initramfs-tools/initramfs.conf.

NOTE:: Le mot clé IP est en majuscule.

Et ensuite il ne faut pas oublier de reconstruire initramfs avec la commande update-initramfs -u.

Connexion

Maintenant faisons un essai en redémarrant la machine :

reboot

Ensuite connectons-nous à la machine :

ssh -p 9210 root@192.168.127.146

Enfin il ne reste plus que le déverrouillage de la partition :

cryptroot-unlock
Please unlock disk dm_crypt-0:

Une fois la connexion automatiquement coupée, la partition est ouverte, le système termine son démarrage et il est maintenant possible de se connecter.