La fragmentation est un problème de longue date en matière de stockage. Cela se produit lorsque, en raison d'une utilisation prolongée, le support de stockage reçoit des morceaux de blocs alloués avec un espace libre entre eux. Cela se produit parce que divers programmes demandent de la mémoire dans un ordre différent, puis libèrent la mémoire à des moments différents. Le fait d'avoir des morceaux d'espace non alloué entre les données réduit l'espace total disponible sur le disque (efficacité du stockage) ainsi que les performances du disque, car les données ne sont pas stockées dans un gros morceau contigu mais réparties sur le disque.

Ce problème est particulièrement apparent dans les supports magnétiques, bien que les SSD en souffrent également. Essayons de défragmenter un système de fichiers XFS dans cet article.

Configuration du bac à sable

Tout d'abord, pour expérimenter avec le système de fichiers XFS, j'ai décidé de créer un banc d'essai au lieu de travailler avec des données critiques sur un disque. Ce banc de test est constitué d'une VM Ubuntu à laquelle est connecté un disque virtuel fournissant un stockage brut. Vous pouvez utiliser VirtualBox pour créer la VM, puis créer un disque supplémentaire à attacher à la VM

Allez simplement dans les paramètres de votre VM et sous Paramètres → Stockage section vous pouvez ajouter un nouveau disque au contrôleur SATA vous pouvez créer un nouveau disque. Comme indiqué ci-dessous, mais assurez-vous que votre machine virtuelle est éteinte lorsque vous faites cela.

Une fois le nouveau disque créé, allumez la VM et ouvrez le terminal. La commande lsblk répertorie tous les périphériques de bloc disponibles.

$ lsblk
sda      8:0    0   60G  0 disque
├─sda1   8:1    0    1M  0 partie
└─sda2   8:2    0   60G  0 partie /
sdb      8:16   0  100 G  0 disque
sr0     11:0    1 1024M  0 rom

En dehors du dispositif de bloc principal sda, là où le système d'exploitation est installé, il y a maintenant un nouveau périphérique sdb. Créons rapidement une partition à partir de celle-ci et formatons-la avec le système de fichiers XFS.

Ouvrez l'utilitaire parted en tant qu'utilisateur root :

$ parted -a optimal /dev/sdb

Créons d'abord une table de partition à l'aide de mklabel, suivi de la création d'une seule partition sur l'ensemble du disque (d'une taille de 107 Go). Vous pouvez vérifier que la partition est créée en la répertoriant à l'aide de la commande print :

(séparé) mklabel gpt
(séparé) mkpart primaire 0 107
impression (séparée)
(séparé) quitter

Bon, maintenant nous pouvons voir en utilisant lsblk qu'il y a un nouveau périphérique de bloc sous le périphérique sdb, appelé sdb1.

Formatons ce stockage en xfs et montons-le dans le répertoire /mnt. Encore une fois, effectuez les actions suivantes en tant que root :

$ mkfs.xfs /dev/sdb1
$ monter /dev/sdb1 /mnt
$ df -h

La dernière commande imprimera tous les systèmes de fichiers montés et vous pourrez vérifier que /dev/sdb1 est monté sur /mnt.

Ensuite, nous écrivons un tas de fichiers en tant que données factices à défragmenter ici :

$ dd if=/dev/urandom of=/mnt/myfile.txt compte = 1024 bs = 1024

La commande ci-dessus écrirait un fichier myfile.txt d'une taille de 1 Mo. Vous pouvez automatiser cette commande dans une simple boucle for en utilisant bash et générer plus de fichiers de ce type. Répartissez-les dans différents répertoires si vous le souhaitez. Supprimez-en quelques-uns au hasard. Faites tout cela dans le système de fichiers xfs (monté sur /mnt), puis vérifiez la fragmentation. Tout cela est bien entendu facultatif.

Défragmentez votre système de fichiers

La première chose que nous devons faire est de déterminer comment vérifier la quantité de fragmentation. Par exemple, le système de fichiers xfs que nous avons créé précédemment était sur le nœud de périphérique /dev/sdb. Nous pouvons utiliser l'utilitaire xfs_db (pour xfs debugging) pour vérifier le niveau de fragmentation.

$ xfs_db -c frag -r /dev/sdb1

L'indicateur -c prend diverses commandes parmi lesquelles la commande frag pour vérifier le niveau de fragmentation. L'indicateur -r utilisé pour s'assurer que l'opération est entièrement en lecture seule.

Si nous constatons qu'il y a une fragmentation dans ce système de fichiers, nous exécutons la commande xfs_fsr sur le nœud du périphérique :

$ xfs_fsr /dev/sdb1

Cette dernière commande est tout ce qu'il y a pour défragmenter votre système de fichiers, vous pouvez l'ajouter en tant que cronjob qui surveillera régulièrement votre système de fichiers. Mais faire ça pour xfs n'a pas de sens. L'allocation basée sur l'étendue de XFS garantit que les problèmes tels que la fragmentation restent au minimum.

Cas d'utilisation

Les cas d'utilisation où vous devez vous soucier le plus de la fragmentation du système de fichiers impliquent des applications où de nombreux petits morceaux de données sont écrits et réécrits. Une base de données en est un exemple classique et les bases de données sont connues pour laisser beaucoup, beaucoup de « trous » dans votre stockage. Les blocs de mémoire ne sont pas remplis de manière contiguë, ce qui réduit de plus en plus la quantité d'espace disponible au fil du temps.

Le problème se pose non seulement en termes d'espace utilisable réduit, mais également en termes d'IOPS réduites, ce qui pourrait nuire aux performances de votre application. Avoir un script pour surveiller en permanence le niveau de fragmentation est un moyen conservateur de maintenir le système. Vous ne voulez pas qu'un script automatisé commence au hasard à défragmenter votre système de fichiers, en particulier lorsqu'il est utilisé à une charge maximale.