Gentiane — Installation Debian, stockage chiffré ZFS et réception Borg

Cette page décrit l’installation et la mise en service du serveur de sauvegarde. Les valeurs spécifiques au site (adresses IP, clés publiques, UUID, mots de passe et noms de clients) doivent être remplacées par des valeurs locales.

NVMe
└── Debian : /, /boot/efi, swap

Disque SATA dédié aux sauvegardes
└── LUKS2 : crypt-backup
    └── zpool ZFS : backup
        └── dataset : backup/borg
            └── monté sur /srv/borg
                └── dépôts Borg chiffrés côté clients

Le disque de sauvegarde est chiffré par LUKS. Le pool ZFS est créé au-dessus du volume déchiffré. Borg chiffre en plus chaque dépôt côté client.

Installer Debian par netinstall.

* Installer le système sur le NVMe. * Créer un point de montage /srv sur le disque SATA pendant l’installation si souhaité. * Activer SSH pendant l’installation. * Créer un utilisateur administrateur, puis lui donner accès à sudo.

su -
apt update
apt install sudo
adduser NOM_UTILISATEUR sudo

Se déconnecter puis se reconnecter pour prendre en compte le groupe sudo.

Vérification essentielle :

id
sudo whoami

ZFS est distribué dans le composant APT contrib.

Éditer le fichier de sources Debian, généralement :

sudo nano /etc/apt/sources.list

Vérifier que chaque ligne Components: main contrib non-free-firmware

Mettre à jour les index et installer les outils :

sudo apt update
sudo apt install linux-headers-$(uname -r) cryptsetup zfs-dkms zfsutils-linux zfs-zed smartmontools systemd-cryptsetup 

Vérifications :

sudo modprobe zfs
zpool --version
sudo /usr/sbin/dkms status

Avant toute commande destructive, identifier formellement le disque SATA destiné aux sauvegardes.

sudo lsblk -o NAME,SIZE,MODEL,SERIAL,TYPE,FSTYPE,UUID,MOUNTPOINTS
sudo findmnt /srv

<WRAP center round important 90%> Les commandes suivantes détruisent définitivement le contenu du disque SATA ciblé. Vérifier le modèle, la taille et le numéro de série. Ne jamais viser le NVMe système. </WRAP>

Supprimer l’ancien montage /srv du fichier /etc/fstab, puis démonter le volume.

sudo cp -a /etc/fstab /etc/fstab.before-zfs
sudo nano /etc/fstab
sudo umount /srv

Dans /etc/fstab, commenter ou supprimer uniquement la ligne correspondant à l’ancien montage /srv sur le SATA.

Effacer les signatures existantes. Remplacer /dev/sdX par le disque SATA réellement identifié.

sudo wipefs -a /dev/sdX
sudo lsblk -f /dev/sdX

Créer le conteneur LUKS2 :

sudo cryptsetup luksFormat \
  --type luks2 \
  --pbkdf argon2id \
  /dev/sdX

Ouvrir le volume sous le nom crypt-backup :

sudo cryptsetup open /dev/sdX crypt-backup

Vérification :

sudo cryptsetup status crypt-backup

Créer le pool ZFS sur le périphérique déchiffré, jamais directement sur le disque LUKS.

sudo zpool create \
  -o ashift=12 \
  -O mountpoint=none \
  -O compression=zstd \
  -O atime=off \
  -O xattr=sa \
  -O acltype=posixacl \
  backup /dev/mapper/crypt-backup

Créer le dataset destiné aux dépôts Borg :

sudo zfs create \
  -o mountpoint=/srv/borg \
  backup/borg

Vérifications :

sudo zpool status backup
sudo zfs list
findmnt /srv/borg

Résultat attendu : pool backup en état ONLINE et dataset backup/borg monté sur /srv/borg.

Le système Debian est installé sur le NVMe et doit démarrer même si le disque de sauvegarde chiffré est fermé. Le volume LUKS est donc marqué noauto dans crypttab.

Récupérer l’UUID LUKS :

sudo cryptsetup luksUUID /dev/sdX

Ajouter dans /etc/crypttab :

sudo cp -a /etc/crypttab /etc/crypttab.before-backup
sudo nano /etc/crypttab

crypt-backup UUID=UUID_LUKS_REEL none luks,noauto

Recharger systemd :

sudo systemctl daemon-reload

Configurer le cache et les services ZFS :

sudo zpool set cachefile=/etc/zfs/zpool.cache backup
sudo systemctl enable zfs-import-cache.service
sudo systemctl enable zfs-mount.service
sudo systemctl enable zfs-zed.service

Le chemin /srv/borg ne doit pas être ajouté à /etc/fstab : ZFS gère le montage du dataset.

Créer le script /usr/local/sbin/unlock-backup :

sudo nano /usr/local/sbin/unlock-backup

#!/bin/sh
set -eu

MAPPER=crypt-backup
POOL=backup
DEVICE=/dev/disk/by-uuid/UUID_LUKS_REEL

if ! cryptsetup status "$MAPPER" >/dev/null 2>&1; then
    cryptsetup open "$DEVICE" "$MAPPER"
fi

if ! zpool list -H -o name 2>/dev/null | grep -Fxq "$POOL"; then
    zpool import "$POOL"
fi

zpool status "$POOL"
findmnt /srv/borg

Remplacer UUID_LUKS_REEL par l’UUID retourné par cryptsetup luksUUID.

Appliquer les permissions :

sudo chown root:root /usr/local/sbin/unlock-backup
sudo chmod 0750 /usr/local/sbin/unlock-backup

Après chaque démarrage, se connecter en SSH puis déverrouiller le stockage :

sudo /usr/local/sbin/unlock-backup

Le script demande la passphrase LUKS dans la session SSH, importe le pool ZFS, puis le dataset est monté automatiquement sur /srv/borg.

Vérifications :

sudo zpool status backup
findmnt /srv/borg

Déverrouiller le stockage avant toute opération Borg :

sudo /usr/local/sbin/unlock-backup

Installer Borg :

sudo apt update
sudo apt install borgbackup
borg --version

Créer le compte de service :

sudo adduser \
  --system \
  --group \
  --home /srv/borg \
  --shell /usr/sbin/nologin \
  borg

sudo chown borg:borg /srv/borg
sudo chmod 0750 /srv/borg

sudo install -d -o borg -g borg -m 0700 /srv/borg/.ssh
sudo install -o borg -g borg -m 0600 /dev/null /srv/borg/.ssh/authorized_keys

Créer un répertoire par client :

sudo install -d -o borg -g borg -m 0700 /srv/borg/NOM_CLIENT

Sur le client, créer une clé SSH dédiée :

sudo install -d -m 0700 /root/.ssh
sudo ssh-keygen \
  -t ed25519 \
  -f /root/.ssh/id_ed25519_borg_gentiane \
  -C "borg-NOM_CLIENT-vers-gentiane"

sudo cat /root/.ssh/id_ed25519_borg_gentiane.pub

Sur le serveur, ajouter la clé publique du client dans /srv/borg/.ssh/authorized_keys avec une commande forcée. Adapter le chemin de Borg affiché par command -v borg.

command -v borg
sudo nano /srv/borg/.ssh/authorized_keys

Exemple sans mode append-only :

command="/usr/bin/borg serve --restrict-to-path /srv/borg/NOM_CLIENT",restrict ssh-ed25519 CLE_PUBLIQUE_CLIENT commentaire

Exemple en mode append-only :

command="/usr/bin/borg serve --append-only --restrict-to-path /srv/borg/NOM_CLIENT",restrict ssh-ed25519 CLE_PUBLIQUE_CLIENT commentaire

Appliquer les permissions :

sudo chown borg:borg /srv/borg/.ssh/authorized_keys
sudo chmod 0600 /srv/borg/.ssh/authorized_keys

Créer une configuration SSH dédiée sur le client :

sudo nano /root/.ssh/config

Host borg-gentiane
    HostName ADRESSE_DU_SERVEUR
    User borg
    IdentityFile /root/.ssh/id_ed25519_borg_gentiane
    IdentitiesOnly yes

Puis protéger ce fichier :

sudo chmod 0600 /root/.ssh/config

Avec Borg 1.x, initialiser le dépôt chiffré depuis le client :

sudo borg init \
  --encryption=repokey-blake2 \
  ssh://borg-gentiane/./NOM_CLIENT

Créer une première archive :

sudo borg create \
  --verbose \
  --stats \
  --compression zstd,6 \
  --exclude-caches \
  ssh://borg-gentiane/./NOM_CLIENT::'{hostname}-{now:%Y-%m-%d_%H-%M}' \
  /etc /home

Vérifications sur le client :

sudo borg list ssh://borg-gentiane/./NOM_CLIENT
sudo borg check ssh://borg-gentiane/./NOM_CLIENT

 sudo apt install wireguard 

Création des clés publique et privé

 wg genkey | sudo tee /etc/wireguard/wg-private.key | wg pubkey | sudo tee /etc/wireguard/wg-public.key 

La valeur retournée suite à cette commande est la clé publique de VOTRE serveur à envoyer à support@ilico.org

= Configuration Wireguard =

Pour la visualiser :

 sudo cat /etc/wireguard/wg-private.key 

Puis l'inscrire dans :

 sudo nano /etc/wireguard/wg0.conf 

 
[Interface]
# Adresse IP du client à l'intérieur du VPN
Address = <IPV4>, <IPV6>
# Clef privée du client
PrivateKey = <VOTRE CLÉ PRIVÉE À INSCRIRE ICI>
DNS = 80.67.180.1, 9.9.9.9

# === Configuration liée au serveur ===
[Peer]
# Clef publique du du serveur
PublicKey = <CLÉ PUBLIC FOURNIE PAR ILICO>
# Adresse et port du serveur
Endpoint = 80.67.180.4:37448
# Range d'adresses IP qui doivent être routées à travers le VPN
AllowedIPs = 0.0.0.0/0, ::/0
# Et pour finir, le keepalive pour éviter d'avoir des soucis
# si le client se trouve derrière un routeur NAT
PersistentKeepalive = 25
 

= Utilisation = Pour lancer wireguard :

 sudo wg-quick up wg0 

Pour vérifier l'existence de l'interface wg0

 ip a 

Pour afficher la configuration de l'interface “wg0”

 sudo wg show wg0 

Pour activer le lancement de wireguard au démarrage

 sudo systemctl enable wg-quick@wg0.service 

Vérifier l’état ZFS :

sudo zpool status backup

Lancer périodiquement un scrub ZFS :

sudo zpool scrub backup
sudo zpool status backup

Vérifier l’état SMART du disque SATA :

sudo smartctl -a /dev/sdX

Fermer proprement le stockage si nécessaire, hors période de sauvegarde :

cd ~
sudo zfs unmount backup/borg
sudo zpool export backup
sudo cryptsetup close crypt-backup

* Le chiffrement Borg doit être activé à la création de chaque dépôt. * Utiliser une clé SSH distincte par client Borg. * Restreindre chaque clé SSH à son seul chemin de dépôt avec borg serve –restrict-to-path. * Le mode –append-only protège mieux les archives existantes contre un client compromis, mais empêche les suppressions et la maintenance habituelles depuis ce client. * Un pool ZFS à un seul disque détecte les corruptions, mais ne peut pas les réparer automatiquement.