# Exécution du système de fichiers BTRFS avec le noyau ARM64 sur le Raspberry Pi et sauvegarde avec btrbk BTRFS est l'un des candidats à la succession d'EXT4, qui existe déjà depuis quelques années. Aujourd'hui, je vais vous montrer comment configurer BTRFS sur un système Raspberry Pi 64 bits dans le noyau et comment créer une solution de sauvegarde automatisée avec btrbk. ## Avantages de BTRFS * Fonctionnalités avancées : BTRFS offre des fonctionnalités avancées telles que les instantanés, l'allocation dynamique d'inodes, le support RAID intégré et les contrôles d'intégrité des données. * Possibilité de créer des instantanés et de revenir en arrière : BTRFS vous permet de créer des instantanés de vos données, ce qui peut être utile pour la sauvegarde et la récupération des données. * Auto-réparation bit-red : BTRFS peut détecter les données endommagées et, s'il est configuré en RAID, les réparer automatiquement. * Copie sur écriture efficace (CoW) : Cela permet des processus de sauvegarde et de clonage efficaces. ## Avantages de btrbk * btrbk est taillé sur mesure pour les sauvegardes, capable de transférer des instantanés vers des emplacements tels que des disques externes ou des serveurs distants, ce qui est essentiel pour les sauvegardes hors site. * Politiques de rétention avancées : Offre des paramètres de rétention détaillés, permettant de personnaliser la conservation des instantanés sur différentes périodes (de l'heure à l'année). * Automatise la création, le transfert et le nettoyage des instantanés en fonction des règles de conservation, ce qui simplifie les opérations de sauvegarde régulières. Vous avez besoin de * un [Raspberry Pi](/RaspberryPi#) puis Télécharger [raspberry-pi-os-64-bit](https://www.raspberrypi.com/software/operating-systems/#raspberry-pi-os-64-bit) et flasher sur [SSDUSB3](/SSDUSB3), choisissez le ROSE. ``` sudo raspi-config ``` * Activer SSH + WayLand ## Préparation du Raspberry Pi installez intiramfs-tools, btrfs et btrbk : ``` sudo apt install initramfs-tools btrfs-progs btrbk ``` [anime article ](https://pad.p2p.legal/s/ZWDSFKQWU) Ajoutez le module btrfs via les modules initramfs dans ```/etc/initramfs-tools/modules``` en ajoutant simplement ```btrfs``` à la fin du fichier : ``` # Liste des modules que vous souhaitez inclure dans votre initramfs. # Ils seront chargés au démarrage dans l'ordre suivant. # # Syntaxe : nom_du_module [args ...] # # Vous devez exécuter update-initramfs(8) pour effectuer ce changement. # # Exemples : # # raid1 # sd_mod btrfs ``` > ```/etc/initramfs-tools/modules``` Si vous exécutez la commande mkinitramfs, vous obtiendrez des erreurs étranges comme "Missing /boot/config-[kernel_version]" et que zstd ou gzip n'est pas supporté par le noyau actuel. ```mkinitramfs``` n'a pas encore (en date de janvier 2024) été configuré pour le RaspberryPi 64Bit, nous devons donc faire un changement dans le fichier d'installation. Dans ```/usr/sbin/mkinitramfs```, ajoutez les lignes suivantes sous le shebang existant ```#!/bin/sh``` : ``` #!/bin/sh sudo modprobe configs && zcat /proc/config.gz > /boot/config-$(uname -r) ``` > ```/usr/sbin/mkinitramfs/usr/sbin/mkinitramfs``` et créez un nouvel initramfs : ```mkinitramfs -o /boot/initramfs-btrfs.gz``` Attention : A partir de là, votre Raspberry Pi sera basculé sur BTRFS après le redémarrage. Si vous ne changez pas le système de fichiers par la suite, votre Raspberry Pi ne démarrera plus. Allez maintenant dans le répertoire ```/boot/``` et remplacez ext4 par btrfs dans ```/boot/cmdline.txt``` manuellement avec un éditeur comme nano ou vim. ``` root=<mountpoint root> rootflags=subvol=@root rootfstype=btrfs ``` Chargez la nouvelle configuration du noyau à chaque démarrage avec l'entrée suivante à la fin de la configuration dans ```/boot/config.txt``` : ``` initramfs initramfs-btrfs.gz ``` > ```/boot/config.txt``` La dernière modification est effectuée dans le fichier ```/etc/fstab```. Changez le système de fichiers pour la partition racine (pas pour le boot) en btrfs. ``` <point de montage root> / btrfs subvol=@root,defaults,noatime 0 1 ``` > ```/etc/fstab``` Maintenant, éteignez votre Raspberry Pi, retirez votre clé USB et branchez-la sur un autre système. ``` shutdown now ``` --- ## Convertir votre système de fichiers EXT4 en BTRFS Votre clé USB ne doit pas être montée et btrfs-progs doit être installé sur votre système. Vérifiez votre lecteur avec ```lsblk```. ``` lsblk -f ├─sdd1 vfat FAT32 bootfs 0B22-0000 └─sdd2 ext4 rootfs dd569980-a77f-4eaa-0000-0000b2072a8e ``` > Système de fichiers de la clé USB Par défaut, votre Raspberry Pi utilise deux partitions. Nous voulons convertir rootfs. bootfs reste intact. Vérifiez bien qu'il s'agit bien de la bonne partition que vous souhaitez convertir en btrfs. Dans l'exemple, sdd2 est la bonne partition. Ce n'est pas forcément le cas pour vous. Vérifiez d'abord que la partition ne contient pas d'erreurs. Cette étape n'est pas absolument nécessaire. ``` e2fsck -fvy /dev/sdd2 ``` Vous pouvez ensuite utiliser la fonction btrfs-convert. ``` btrfs-convert /dev/sdd2 crée un système de fichiers btrfs : taille de bloc : 4096 taille des noeuds : 16384 caractéristiques : extref, skinny-metadata (default) somme de contrôle : crc32c rapport sur l'espace libre : total : 128048168960 libre : 8599547904 (6.72%) ``` Ce processus peut prendre beaucoup de temps. Il se compose de trois étapes : * création d'un fichier image ext2 * création des métadonnées btrfs * copie des inodes Le processus critique est le premier, car il peut échouer en raison d'un espace disque insuffisant. Dès que le processus est terminé, vous recevez le message "conversion complete". Si vous convertissez votre système de fichiers à l'aide de btrfs-convert, vous créez un système de fichiers BTRFS avec deux sous-volumes pour ext2_saved et un autre pour rootfs sans UUID. Il n'est pas possible de créer des instantanés de sous-volumes [sans UUID avec btrbk](https://github.com/digint/btrbk/blob/master/doc/FAQ.md). Montez à nouveau vos périphériques localement et vérifiez que tout va bien (cela devrait être le cas). ``` mount /dev/sdd2 /mnt ``` Allez à votre point de montage /mnt et créez un nouveau sous-volume pour votre périphérique racine. ``` btrfs subvolume create @root ``` Les sous-volumes Btrfs se comportent comme des répertoires normaux sous Linux. Toutes les opérations telles que ```rm``` ou ```ls``` fonctionnent également ici. Nous utilisons ce fait pour migrer les données de la racine vers le nouveau sous-volume. Par convention de nommage, les sous-volumes sont précédés du caractère @. Vérifiez si la création du sous-volume a fonctionné : ``` btrfs subvolume show /mnt/@root/ @racine Nom : @racine UUID: 16197b0e-0000-a24e-0000-9b09c6fbae1b UUID parent : - UUID reçu : - Heure de création : 2024-01-11 00:28:42 +0100 ID du sous-volume : 396 Génération : 3795 Génération à la création : 3794 Parent ID : 5 ID de niveau supérieur : 5 Drapeaux : - Snapshot(s) : : ``` Nous devons maintenant déplacer les fichiers de / vers le nouveau sous-volume. De nombreux tutoriels sur Internet spécifient une commande rsync pour des raisons que je ne comprends pas. Cependant, une simple commande ```mv``` est suffisante et beaucoup plus rapide. Cette commande déplacera tous les répertoires de votre disque monté vers le sous-volume @root, à l'exception de @root lui-même.. : ``` for dir in */ ; do [ "$dir" != "@root/" ] && mv -v "$dir" "@root/" ; done ``` > Migrer le système de fichiers racine vers le sous-volume btrfs @root Cela prendra beaucoup de temps, en fonction de la consommation de stockage, mais c'est toujours plus rapide que rsync. --- ## Démarrer Raspberry Pi Reconnectez votre clé USB à votre Raspberry Pi et laissez-le démarrer. Testez si tout va bien et supprimez le sous-volume ext2_saved car il prend beaucoup de place : ``` cd / btrfs subvolume delete ext2_saved ``` > delete ext2_saved ``` btrfs subvolume show / Nom : <FS_TREE> UUID : - UUID parent : - UUID reçu : - Heure de création : - ID du sous-volume : 5 Génération : 2032 Génération à la création : 0 Parent ID : 0 ID de niveau supérieur : 0 Drapeaux : - Transid. d'envoi : 0 Heure d'envoi : - Transid de réception : 0 Temps de réception : - Instantané(s) : ``` Comme vous pouvez le voir, il n'y a pas encore d'instantané. Créez le premier instantané avec la commande : ``` btrfs subvolume snapshot / snapshots ``` Cette commande crée un instantané dans le répertoire /snaphosts, qui ne prend pratiquement pas d'espace disque. --- ## Éviter le problème du fichier d'échange BTRFS Si vous utilisez un fichier d'échange, vous devrez procéder à des modifications supplémentaires. Les étapes sont très bien décrites dans la documentation officielle, mais malgré ces mesures, il n'est pas possible de créer des instantanés sans désactiver au préalable le fichier d'échange. Vous obtenez le message d'erreur suivant ``` ERROR : cannot snapshot '/' : Fichier texte occupé ``` Théoriquement, ce problème pourrait être évité en créant un sous-volume distinct pour le fichier d'échange. Une autre solution consiste à utiliser zram comme alternative à swapfile. zram alloue le fichier d'échange en RAM. Un petit effet secondaire positif est le gain de performance. La configuration est simple. ``` sudo apt install zram-tools ``` Commentez la ligne ```PERCENT=50``` dans le fichier ```/etc/default/zramswap``` et activez le service : ``` systemctl enable --now zramswap.service ``` --- ## Sauvegarde avec btrbk Créez un nouveau fichier ```/etc/btrbk/btrbk.conf``` et ajoutez-y ce qui suit : ``` transaction_log /var/log/btrbk.log timestamp_format short snapshot_dir SNAPSHOTS snapshot_create always volume / subvolume / snapshot_preserve_min 7d snapshot_preserve 7d ``` > /etc/btrbk/btrbk.conf Nous avons maintenant besoin d'un répertoire d'instantanés. Dans la configuration ci-dessus, je l'ai appelé SNAPSHOT. btrbk ne crée pas ce répertoire, nous devons donc le faire : ``` mkdir /SNAPSHOTS ``` Nous pouvons maintenant tester la configuration : ``` btrbk -c /etc/btrbk/btrbk.conf run ``` Un test réussi devrait donner les résultats suivants : ``` -------------------------------------------------------------------------------- Backup Summary (btrbk command line client, version 0.32.5) Date: Thu Jan 11 00:21:08 2024 Config: /etc/btrbk/btrbk.conf Legend: === up-to-date subvolume (source snapshot) +++ created subvolume (source snapshot) --- deleted subvolume *** received subvolume (non-incremental) >>> received subvolume (incremental) -------------------------------------------------------------------------------- / +++ /SNAPSHOTS/ROOT.20240111 ``` Le répertoire /etc/btrbk contient également un exemple de configuration plus détaillé. Il est également possible, par exemple, d'effectuer des sauvegardes pull et push à distance avec btrbk via SSH. Le fichier s'appelle btrbk.conf.example et est bien commenté. La configuration actuelle crée 7 sauvegardes quotidiennes. Cependant, nous devons également déclencher le processus de sauvegarde. Pour ce faire, nous créons un fichier de configuration de l'unité SystemD dans ```/etc/systemd/system``` ``` [Unit] Description=Daily btrbk snapshot [Service] Type=oneshot ExecStart=/usr/bin/btrbk -c /etc/btrbk/btrbk.conf ``` > btrbk-local-snapshot.service ``` [Unit] Description=Run btrbk.service daily at 23:55 [Timer] OnCalendar=*-*-* 23:55:00 Persistent=true [Install] WantedBy=timers.target ``` > btrbk-local-snapshot.timer Dans l'exemple, un instantané est pris tous les soirs à 23:55. --- ## Restaurer l'instantané ``` sudo btrfs subvolume delete /mnt/@root sudo btrfs subvolume snapshot /mnt/path/to/btrbk/snapshots/@root.20210101 /mnt/@root ``` Ce qu'il faut garder à l'esprit Tant que BTRFS n'est pas dans le noyau par défaut, vous devrez refaire les ajustements à initramfs à chaque mise à jour du noyau (étape mkinitramfs). Cependant, cela deviendra de plus en plus rapide avec le temps. --- Article Source https://okxo.de/running-the-btrfs-file-system-with-arm64-kernel-on-the-raspberry-pi/