Etape 1 (V1) – Installation – Secure Boot EFI & ZFS Mirror on Debian Bookworm avec Proxmox (sans cryptage / serveur local)

0. Mises à jour

• 11/11/2017 : Version de base
• 21/05/2022 : Actualisation pour Debian 11 (testé sur un serveur HP ProLiant DL180 Gen9)
• 25/02/2025 : Actualisation pour Debian 12 (Bookworm) (toujours sur un serveur HP ProLiant DL180 Gen9), nombreuses corrections d’erreurs ou imprécisions.

1. Introduction

Nous allons voir ici comment installer proxmox sur un serveur local (donc inutile de crypter la partition vous savez que le matériel ne peut être utilisé que par vous).

Pour sécuriser les données, je vous propose d’utiliser le système de fichier ZFS, en partant du principe que vous avez 2 disques de taille identique que vous souhaitez utiliser comme disque système.

ZFS est un système de fichier initialement conçu par Sun pour Solaris. Il est utilisé par défaut dans FreeBSD et surtout FreeNAS.

L’avantage de ce système de fichier c’est qu’il permets de faire de la redondance de fichier (comme le RAID), avec un système de contrôle d’intégrité des fichiers.

Cette page est largement inspirée de :
– Debian Bookworm Root on ZFS
– Install Proxmox VE on Debian 12 Bookworm

2 ZFS on Debian – Prérequis

2.1 Debian Live

Par défaut l’installateur de Debian ne prends pas en charge ZFS, il faudra donc passer par un live cd.

Vous pouvez prendre n’importe quelle version, en fonction de vos habitudes (KDE, Gnome…), cela n’a aucune incidence pour la suite…

2.2 Matériel

ZFS peut théoriquement fonctionner sur n’importe quel type de hardware mais il est recommandé d’avoir de la RAM compatible ECC (mais ce n’est pas consensuel la preuve sur ce site)

3. Préparation de l’environnement d’installation

3.1 Accès SSH et installations des packages

• Booter en EFI la version live (difficile de décrire exactement la procédure, mais la plupart du temps il s’agit d’un réglage système et bien veiller à démarrer dans ce mode)

• Installer le serveur SSH (par le biais d’un terminal ou sur un écran secondaire en tapant CTRL+ALT+F2) :

sudo -s

apt update
apt install --yes openssh-server
sed -i "s/#PasswordAuthentication yes/PasswordAuthentication yes/g" /etc/ssh/sshd_config
systemctl restart ssh

• Connexion en SSH depuis autre ordinateur (faire ip -a sur le serveur pour connaitre l’IP si non connue). Le mot de passe est « live » :

ssh -l user 123.123.123.123

• On installe et charge le module ZFS :

sudo -s

sed -i "s/bookworm main non-free-firmware/bookworm main contrib non-free non-free-firmware/g" /etc/apt/sources.list
apt update
echo "zfs-dkms zfs-dkms/note-incompatible-licenses note true" | sudo debconf-set-selections
apt install --yes debootstrap gdisk zfsutils-linux

3.2 Formatage des disques systèmes

• Dans les lignes qui suivent il faut remplacer scsi-SATA_disk* par les disques adaptés (faire un ls -l /dev/disk/by-id/) pour les identifier.

• On enregistre 2 variables qui servirons par la suite

DISK1=/dev/disk/by-id/scsi-SATA_disk1
DISK2=/dev/disk/by-id/scsi-SATA_disk2

mdadm  --stop /dev/md*
mdadm --zero-superblock --force ${DISK1}*
mdadm --zero-superblock --force ${DISK2}*

wipefs -a $DISK1
wipefs -a $DISK2

• On efface les 2 disques :

sgdisk --zap-all $DISK1
sgdisk --zap-all $DISK2

• Puis on partitionne CHAQUE disque :

sgdisk -n1:1M:+512M -t1:EF00 -c1:"EFI Partition - Disk 1" -n2:0:+1G -t2:BF01 -c2:"ZFS Boot Pool - Disk 1" -n3:0:0 -t3:BF01 -c3:"ZFS Root Pool - Disk 1" -p $DISK1
sgdisk -n1:1M:+512M -t1:EF00 -c1:"EFI Partition - Disk 2" -n2:0:+1G -t2:BF01 -c2:"ZFS Boot Pool - Disk 2" -n3:0:0 -t3:BF01 -c3:"ZFS Root Pool - Disk 2" -p $DISK2

3.3 Création des pools ZFS

• On crée tout d’abord le pool ZFS correspondant à la partition /boot :

zpool create \
    -o ashift=12 \
    -o autotrim=on \
    -o compatibility=grub2 \
    -o cachefile=/etc/zfs/zpool.cache \
    -O devices=off \
    -O acltype=posixacl -O xattr=sa \
    -O compression=lz4 \
    -O normalization=formD \
    -O relatime=on \
    -O canmount=off -O mountpoint=/boot -R /newdebian \
    bpool mirror ${DISK1}-part2 ${DISK2}-part2

Si vous avez des messages d’erreur comme quoi les disques sont occupés, il faut redémarrer la machine.

• On crée enfin le pool ZFS correspondant à la partition / (hormis /boot) :

zpool create \
    -o ashift=12 \
    -o autotrim=on \
    -O acltype=posixacl -O xattr=sa -O dnodesize=auto \
    -O compression=lz4 \
    -O normalization=formD \
    -O relatime=on \
    -O canmount=off -O mountpoint=/ -R /newdebian \
    rpool mirror ${DISK1}-part3 ${DISK2}-part3

3.4 Création des datasets

Par défaut un pool contient un dataset, mais il est possible de découper un pool en plusieurs datasets qui seront visualisés par le système comme des « disques » (mais totalement géré par ZFS, pas de passage par fstab par exemple).

Le concept est extrêmement fort car il permets par exemple :
– De faire des snapshots de datasets (des points de restauration et de restaurer à ce moment exactement)
– De limiter un dataset en espace disque.
– De faire plusieurs datasets de boot par exemple et de switcher d’un dataset à l’autre pour booter le système (et ne pas perdre de donner)
– De créer des sous-datasets (avec héritage des propriétés)
– Et bien plus…

• On commence par créer le dataset ROOT qui va servir à contenir les sous-datasets système :

zfs create -o canmount=off -o mountpoint=none rpool/ROOT
zfs create -o canmount=noauto -o mountpoint=/ rpool/ROOT/debian
zfs mount rpool/ROOT/debian

• Puis on crée le dataset BOOT :

zfs create -o canmount=off -o mountpoint=none bpool/BOOT
zfs create -o mountpoint=/boot bpool/BOOT/debian

• On crée un dataset home dans lequel on va mettre tous les répertoires des users y compris celui du root :

zfs create -o setuid=off rpool/home
zfs create -o mountpoint=/root rpool/home/root
chmod 700 /newdebian/root

• On crée un dataset var avec les sous-datasets log,cache,tmp que l’on exclura des snapshots

zfs create -o canmount=off rpool/var
zfs create -o canmount=off rpool/var/lib
zfs create rpool/var/log
zfs create rpool/var/spool
zfs create -o com.sun:auto-snapshot=false rpool/var/cache
zfs create -o com.sun:auto-snapshot=false rpool/var/tmp
chmod 1777 /newdebian/var/tmp

• On créée un tmpfs utile par la suite :

mkdir /newdebian/run
mount -t tmpfs tmpfs /newdebian/run
mkdir /newdebian/run/lock

4. Installation du système de base

• On installe une debian de base (la commande peut mettre plusieurs minutes à s’exécuter):

debootstrap --arch amd64 bookworm /newdebian http://ftp.fr.debian.org/debian
...
I: Configuring ifupdown...
I: Configuring tasksel-data...
I: Configuring tasksel...
I: Configuring libc-bin...
I: Base system installed successfully.

• On installe copie le zpool.cache

mkdir /newdebian/etc/zfs
cp /etc/zfs/zpool.cache /newdebian/etc/zfs/

5. Configuration du système de base

5.1 Nom de la machine

hostname MonServeur
hostname > /newdebian/etc/hostname

5.2 Interfaces réseaux

• On recherche le nom des interfaces réseaux (ici pour l’exemple eno1):

ip addr show
1: lo:  mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
2: eno1:  mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 00:1a:1b:1c:1d:1e brd ff:ff:ff:ff:ff:ff
    inet 123.123.123.123/24 brd 123.123.123.255 scope global dynamic eno1
       valid_lft 1569sec preferred_lft 1569sec
    inet6 fe80::abcd/64 scope link 
       valid_lft forever preferred_lft forever

• On crée les fichiers de configuration réseau (utilisé la commande nano), à adapter selon votre environnement réseau :

auto eno1
iface eno1 inet dhcp

auto eno1
iface eno1 inet static
address 192.168.100.1
netmask 255.255.255.0
broadcast 192.168.100.255
gateway 192.168.100.254

• S’il s’agit d’un serveur local à 2 interfaces (une vers le réseau externe, l’autre vers le réseau local :

auto eno2
iface eno2 inet static
address 192.168.0.1
netmask 255.255.255.0

5.3 Chrooter dans le nouveau système

mount --make-private --rbind /dev  /newdebian/dev
mount --make-private --rbind /proc /newdebian/proc
mount --make-private --rbind /sys  /newdebian/sys
chroot /newdebian /bin/bash --login

• On monte /tmp dans la ram (TMPFS) :

cp /usr/share/systemd/tmp.mount /etc/systemd/system/
systemctl enable tmp.mount

• On modifie le mot de passe root (ne pas oublier cette étape sinon vous allez vous retrouver dehors) :

passwd

5.4 Apt

• On modifie les sources :

# Debian Bookworm - Depot officiel
deb http://ftp.fr.debian.org/debian bookworm main non-free-firmware contrib non-free

# Debian Bookworm - Updates
deb http://ftp.fr.debian.org/debian bookworm-updates main non-free-firmware contrib non-free

# Debian Bookworm - Security updates
deb http://security.debian.org bookworm-security main non-free-firmware contrib non-free

• On actualise les sources et on met à jour :

apt update
apt upgrade

• On installe aptitude (optionnel mais bien pratique) :

apt install --yes aptitude

5.5 Locales

• On installe Locales :

apt install --yes locales
dpkg-reconfigure locales

• On sélectionne en_US.UTF-8 & fr_FR.UTF-8 avec fr_FR.UTF-8 par défaut :

5.6 Console-setup

• On installe Console-setup :

apt install --yes console-setup

• On sélectionne French :

5.7 Tzdata

• On lance la reconfiguration du paquet :

dpkg-reconfigure tzdata

• Puis on sélectionne Europe, puis Paris :

• Un petit screen (cf l’article sur le mémo des commandes)

apt install screen
screen

5.8 SSH

• On installe le serveur SSH :

apt install --yes openssh-server

• Temporairement on autorise le root à s’authentifier (nous modifierons la configuration SSH dans l’étape suivante) :

sed -i "s/#PermitRootLogin prohibit-password/PermitRootLogin yes/g" /etc/ssh/sshd_config

5.9 Installation des packages nécessaires au boot

• On lance la commande suivante :

echo "zfs-dkms zfs-dkms/note-incompatible-licenses note true" | sudo debconf-set-selections
apt install --yes dpkg-dev linux-headers-amd64 linux-image-amd64 zfs-initramfs
echo REMAKE_INITRD=yes > /etc/dkms/zfs.conf

• On configure la partition EFI :

apt install --yes dosfstools
mkdosfs -F 32 -n EFI /dev/disk/by-id/scsi-SATA_disk1-part1
mkdosfs -F 32 -n EFI /dev/disk/by-id/scsi-SATA_disk2-part1
echo PARTUUID=$(blkid -s PARTUUID -o value /dev/disk/by-id/scsi-SATA_disk1-part1) /boot/efi vfat defaults 0 0 >> /etc/fstab
echo "#"PARTUUID=$(blkid -s PARTUUID -o value /dev/disk/by-id/scsi-SATA_disk2-part1) /boot/efi vfat defaults 0 0  >> /etc/fstab
mkdir /boot/efi
mount /boot/efi

• On installe Grub :

apt install --yes grub-efi-amd64 shim-signed

• On teste (vous devez obtenir en retour zfs) :

grub-probe /boot
zfs

• On met à jour l’initramfs (qui a pour seul et unique but de monter le système de fichier racine) :

update-initramfs -u -k all

• On désinstalle os-prober (utile uniquement en cas de double boot) :

apt purge --yes os-prober

• On configure grub pour aller chercher le bon pool ZFS :

sed -i 's/GRUB_CMDLINE_LINUX=""/GRUB_CMDLINE_LINUX="root=ZFS=rpool\/ROOT\/debian"/g' /etc/default/grub

• On met à jour la configuration de Grub :

update-grub

• On l’installe en mode EFI :

grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=debian --recheck --no-floppy

grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=debian --recheck --no-floppy
Could not prepare Boot variable: No space left on device

efibootmgr
BootCurrent: 0001
Timeout: 0 seconds
BootOrder: 0002,2001,0001,2002,2003
Boot0000* ManjaLinux
Boot0001* Debian
Boot0002* rEFInd Boot Manager
Boot2001* EFI USB Device
Boot2002* EFI DVD/CDROM

efibootmgr -Bb 0000

• Et on verifie que le module ZFS est bien installé dans Grub :

ls /boot/grub/*/zfs.mod
/boot/grub/x86_64-efi/zfs.mod

5.10 Import automatique de bpool

• Apriori il est recommandé de créer un service qui va importer automatiquement bpool

• On crée le fichier /etc/systemd/system/zfs-import-bpool.service :

[Unit]
DefaultDependencies=no
Before=zfs-import-scan.service
Before=zfs-import-cache.service

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/sbin/zpool import -N -o cachefile=none bpool
# Work-around to preserve zpool cache:
ExecStartPre=-/bin/mv /etc/zfs/zpool.cache /etc/zfs/preboot_zpool.cache
ExecStartPost=-/bin/mv /etc/zfs/preboot_zpool.cache /etc/zfs/zpool.cache

[Install]
WantedBy=zfs-import.target

• On execute enfin la commande suivante pour activer le service :

systemctl enable zfs-import-bpool.service

5.11 Configuration des montages automatique des partitions.

• On commence par lancer les commandes suivante :

sed -i "s/ZED_SYSLOG_SUBCLASS_EXCLUDE/#ZED_SYSLOG_SUBCLASS_EXCLUDE/g" /etc/zfs/zed.d/zed.rc
mkdir /etc/zfs/zfs-list.cache
touch /etc/zfs/zfs-list.cache/bpool
touch /etc/zfs/zfs-list.cache/rpool
zed -F &

• On vérifie que les fichiers sont mis à jour :

cat /etc/zfs/zfs-list.cache/bpool
cat /etc/zfs/zfs-list.cache/rpool

• S’ils sont vides, on redémarre zed :

fg

zed -F &

• Si le fichier est bien alimenté, on ferme zed :

fg

• On corrige les chemins en retirant /newdebian :

sed -Ei "s|/newdebian/?|/|" /etc/zfs/zfs-list.cache/bpool
sed -Ei "s|/newdebian/?|/|" /etc/zfs/zfs-list.cache/rpool

6. Premier redémarrage

• On fait un premier screenshot des 2 datasets :

zfs snapshot bpool/BOOT/debian@install
zfs snapshot rpool/ROOT/debian@install

• Si screen lancé :

exit

• Puis, on quitte tout :

exit
mount | grep -v zfs | tac | awk '/\/newdebian/ {print $3}' |xargs -i{} umount -lf {}
umount /newdebian/*
umount -l /newdebian
grep /newdebian /proc/*/mounts | tac| awk '{print $3}' FS="/" | uniq | xargs -i{} kill -9 {}
zpool export -a
reboot -f

• N’oubliez pas de retirer la clé USB ou de démonter l’iso

7. Swap

Il existe toujours une question existentielle concernant la taille du swap. Pendant longtemps il était communément admis de dire que le swap faisait 2 fois la taille de la RAM.

Aujourd’hui après avoir écumé de nombreux forum je peux vous dire :

– Que la taille du SWAP doit être au moins 1 fois la taille de la RAM pour les systèmes qui sont amenés à se mettre en hibernation (mise en veille prolongée), donc pas le sujet ici.
– Qu’étant donné la RAM des serveurs actuels (8 / 16 / 32 voire 64 Go), 8 Go semble tout à fait suffisant.

• On crée un zvol (qui sera visible comme un disque dans /dev/zvol/) de 8 Go

zfs create -V 8G -b $(getconf PAGESIZE) -o compression=zle -o logbias=throughput -o sync=always -o primarycache=metadata -o secondarycache=none -o com.sun:auto-snapshot=false rpool/swap

• On crée un swap

swapon -av

• On active le swap

mkswap -f /dev/zvol/rpool/swap
echo /dev/zvol/rpool/swap none swap defaults 0 0 >> /etc/fstab
echo RESUME=none > /etc/initramfs-tools/conf.d/resume

8. Paquets utiles

Voici quelques paquets bien pratique :

• apt-transport-https :

apt install --yes apt-transport-https

Permet de se connecter en HTTPS aux miroirs APT.

• man :

apt install --yes man-db

• command-not-found :

apt install --yes command-not-found
apt update
update-command-not-found

• bash-completion :

apt install --yes bash-completion

9. Installation de Promox

Vous avez désormais un debian de base prêt à recevoir la surcouche Proxmox, il faut maintenant configurer cette installation pour pouvoir lancer proxmox

9.1 Pré-configuration du système

• On crée le fichier /etc/apt/sources.list.d/pve.list :

deb http://download.proxmox.com/debian/pve bookworm pve-no-subscription

• On met à jour le fichier /etc/hosts :

# IPv4
127.0.0.1 localhost
SERVEUR.MON.IP monserveur monserveur.mondomaine.com

# IPv6
::1     localhost ip6-localhost ip6-loopback
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters

• On authentifie le serveur Proxmox et on met à jours les dépôts :

apt install --yes wget
wget https://enterprise.proxmox.com/debian/proxmox-release-bookworm.gpg -O /etc/apt/trusted.gpg.d/proxmox-release-bookworm.gpg 
apt update
apt full-upgrade

9.2 Installation de Proxmox

• On installe le kernel Proxmox :

apt install proxmox-default-kernel

• Redémarrez ! :

systemctl reboot

• Une fois le redémarrage terminé et que vous vous êtes identifiés de nouveau, lancez l’installation

apt install --yes proxmox-ve postfix open-iscsi chrony

• A l’écran mettre : « Pas de configuration »

9.3 Configuration du boot pour être compatible ZFS / EFI / Secure boot

• Tout d’abord on démonte la partition /boot/efi

umount /boot/efi

• On installe ce qu’il faut pour le secure boot:

apt install proxmox-secure-boot-support
proxmox-boot-tool init /dev/disk/by-id/scsi-SATA_disk2-part1 grub
proxmox-boot-tool init /dev/disk/by-id/scsi-SATA_disk1-part1 grub
efibootmgr -c -g -d /dev/disk/by-id/scsi-SATA_disk2 -p 1 -L "proxmox-2" -l '/EFI/proxmox/shimx64.efi'
update-initramfs -u -k all

• Puis on clone la partition

dd if=/dev/disk/by-id/scsi-SATA_disk1-part1 of=/dev/disk/by-id/scsi-SATA_disk2-part1
efibootmgr -c -g -d /dev/disk/by-id/scsi-SATA_disk2 -p 1 -L "proxmox-2" -l '\EFI\proxmox\shimx64.efi'

• Et on remonte la partition précédemment démontée

mount /boot/efi

• Retirer le kernel inutile (en fonction des cas et adapter la version au cas où) :

apt remove linux-image-amd64 'linux-image-6.1*'
apt autoremove
update-grub

10. Ajustement de la configuration de Proxmox

• D’abord, on crée un dataset pour les backups de proxmox :

zfs create rpool/proxdata

• Entrez dans l’interface proxmox de votre serveur : https://IP.DU.SERVEUR:8006

• Allez dans le menu de gauche dans « Datacenter« , puis dans la section « Storage« 

• Désactivez « local » et créez « proxdata« . Vous devez avoir ceci :

• Un petit nettoyage de snapshot juste pour la fin

zfs destroy bpool/BOOT/debian@install
zfs destroy rpool/ROOT/debian@install

• Et on crée des snapshots de post installation

zfs snapshot bpool/BOOT/debian@postinstall
zfs snapshot rpool/ROOT/debian@postinstall

• Optionnel : installation du dernier micro-code (processeur intel) :

bash -c "$(wget -qLO - https://github.com/community-scripts/ProxmoxVE/raw/main/misc/microcode.sh)"

11. En cas de maintenance

Voici les commandes nécessaires en cas de boot depuis une rescue

• D’abord on désactive le secure boot dans le bios

• On réinstalle ssh etc..

apt update
apt install -y zfsutils-linux
modprobe zfs

si vous avez l’erreur : modprobe: ERROR: could not insert ‘zfs’: Key was rejected by service c’est que vous avez oublié de désactiver le secure boot.

• On monte les datasets :

zpool import
zpool import -f -R /mnt rpool
zfs mount rpool/ROOT/debian
zfs mount -a

• On chroot le système :

mount --make-private --rbind /dev  /mnt/dev
mount --make-private --rbind /proc /mnt/proc
mount --make-private --rbind /sys  /mnt/sys
mount -t tmpfs tmpfs /mnt/run
mkdir /mnt/run/lock
chroot /mnt /bin/bash --login

• Faites ce que vous avez à faire

• Et on quitte

exit
mount | grep -v zfs | tac | awk '/\/actudebian/ {print $3}' | xargs -i{} umount -lf {}
umount /actudebian/*
umount -l /actudebian
grep /actudebian /proc/*/mounts | tac| awk '{print $3}' FS="/" | uniq | xargs -i{} kill -9 {}
/sbin/zpool export -a
/sbin/reboot -f