procedure:installation_de_gentiane_serveur_de_backup_borg [Association Ilico]

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== 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.

===== Architecture =====

<code>
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
</code>

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.

===== Installation de Debian =====

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''.

<code>
su -
apt update
apt install sudo
adduser NOM_UTILISATEUR sudo
</code>

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

Vérification essentielle :

<code>
id
sudo whoami
</code>

===== Activer les dépôts nécessaires =====

ZFS est distribué dans le composant APT ''contrib''.

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

<code>
sudo nano /etc/apt/sources.list
</code>

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

Mettre à jour les index et installer les outils :

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

Vérifications :

<code>
sudo modprobe zfs
zpool --version
sudo /usr/sbin/dkms status
</code>

===== Identifier le disque de sauvegarde =====

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

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

<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>

===== Créer LUKS2 sur le disque SATA =====

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

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

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é.

<code>
sudo wipefs -a /dev/sdX
sudo lsblk -f /dev/sdX
</code>

Créer le conteneur LUKS2 :

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

Ouvrir le volume sous le nom ''crypt-backup'' :

<code>
sudo cryptsetup open /dev/sdX crypt-backup
</code>

Vérification :

<code>
sudo cryptsetup status crypt-backup
</code>

===== Créer le pool ZFS =====

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

<code>
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
</code>

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

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

Vérifications :

<code>
sudo zpool status backup
sudo zfs list
findmnt /srv/borg
</code>

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

===== Configuration de démarrage manuel =====

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 :

<code>
sudo cryptsetup luksUUID /dev/sdX
</code>

Ajouter dans ''/etc/crypttab'' :

<code>
sudo cp -a /etc/crypttab /etc/crypttab.before-backup
sudo nano /etc/crypttab
</code>

<code>
crypt-backup UUID=UUID_LUKS_REEL none luks,noauto
</code>

Recharger systemd :

<code>
sudo systemctl daemon-reload
</code>

Configurer le cache et les services ZFS :

<code>
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
</code>

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

===== Script de déverrouillage =====

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

<code>
sudo nano /usr/local/sbin/unlock-backup
</code>

<code>
#!/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
</code>

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

Appliquer les permissions :

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

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

<code>
sudo /usr/local/sbin/unlock-backup
</code>

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 :

<code>
sudo zpool status backup
findmnt /srv/borg
</code>

===== Installation de Borg =====

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

<code>
sudo /usr/local/sbin/unlock-backup
</code>

Installer Borg :

<code>
sudo apt update
sudo apt install borgbackup
borg --version
</code>

Créer le compte de service :

<code>
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
</code>

Créer un répertoire par client :

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

===== Autoriser un client Borg =====

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

<code>
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
</code>

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''.

<code>
command -v borg
sudo nano /srv/borg/.ssh/authorized_keys
</code>

Exemple sans mode append-only :

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

Exemple en mode append-only :

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

Appliquer les permissions :

<code>
sudo chown borg:borg /srv/borg/.ssh/authorized_keys
sudo chmod 0600 /srv/borg/.ssh/authorized_keys
</code>

===== Initialiser un dépôt depuis le client =====

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

<code>
sudo nano /root/.ssh/config
</code>

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

Puis protéger ce fichier :

<code>
sudo chmod 0600 /root/.ssh/config
</code>

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

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

Créer une première archive :

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

Vérifications sur le client :

<code>
sudo borg list ssh://borg-gentiane/./NOM_CLIENT
sudo borg check ssh://borg-gentiane/./NOM_CLIENT
</code>

===== Installer Wiregard =====

<code> sudo apt install wireguard </code>

== Création des clés publique et privé == 

<code> wg genkey | sudo tee /etc/wireguard/wg-private.key | wg pubkey | sudo tee /etc/wireguard/wg-public.key </code>
La valeur retournée suite à cette commande est la clé publique de VOTRE serveur à envoyer à support@ilico.org

== Configuration Wireguard ==

Pour la visualiser :
<code> sudo cat /etc/wireguard/wg-private.key </code>
Puis l'inscrire dans :
<code> sudo nano /etc/wireguard/wg0.conf </code>

<code> 
[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
 </code>

== Utilisation ==
Pour lancer wireguard :
<code> sudo wg-quick up wg0 </code>

Pour vérifier l'existence de l'interface wg0
<code> ip a </code>

Pour afficher la configuration de l'interface "wg0"
<code> sudo wg show wg0 </code>

Pour activer le lancement de wireguard au démarrage
<code> sudo systemctl enable wg-quick@wg0.service </code>


===== Maintenance =====

Vérifier l’état ZFS :

<code>
sudo zpool status backup
</code>

Lancer périodiquement un scrub ZFS :

<code>
sudo zpool scrub backup
sudo zpool status backup
</code>

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

<code>
sudo smartctl -a /dev/sdX
</code>

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

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

===== Notes de sécurité =====

* 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.