La fragmentation est un problème de longue date en matière de stockage. Il survient lorsque, en raison d'une utilisation prolongée, les supports de stockage obtiennent des morceaux de blocs alloués avec l'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 à différents moments. Le fait d'avoir des morceaux d'espace non alloué entre les données réduit l'espace disponible total dans le disque (efficacité de stockage) et également les performances du disque, car les données ne sont pas stockées dans un grand morceau contigu mais réparti sur le disque.

Ce problème est particulièrement apparent dans les médias magnétiques bien que les SSD en souffrent également. Essayons de défragmenter un système de fichiers XFS dans ce post.

Configuration du bac à sable

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

Allez simplement aux paramètres de votre machine virtuelle 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 désactivée lorsque vous faites cela.

Une fois le nouveau disque créé, allumez la machine virtuelle et ouvrez le terminal. La commande lsblk Répertorie tous les appareils de bloc disponibles.

$ lsblk
SDA 8: 0 0 60G 0 Disque
├ssda1 8: 1 0 1m 0 partie
└─Sda2 8: 2 0 60g 0 partie /
SDB 8:16 0 100G 0 Disque
SR0 11: 0 1 1024M 0 ROM

En dehors de l'appareil de bloc principal SDA, Là où le système d'exploitation est installé, il y a maintenant un nouvel appareil SDB. Créons rapidement une partition à partir de celui-ci et le formations avec le système de fichiers XFS.

Ouvrez l'utilité séparée en tant qu'utilisateur root:

$ séparé -a optimal / dev / sdb

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

(séparé) Mklabel gpt
(séparé) Mkpart primaire 0 107
(séparé) imprimer
(séparé) arrêter

D'accord, 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 comme XFS et montons-le dans le répertoire / mnt. Encore une fois, effectuez les actions suivantes comme racine:

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

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

Ensuite, nous écrivons un tas de fichiers en tant que données factice pour défragment ici:

$ dd if = / dev / urandom de = / mnt / myfile.Txt Count = 1024 BS = 1024

La commande ci-dessus écrire un fichier myfile.txt de la taille de 1 Mo. Vous pouvez automatiquement automatiquement cette commande en une boucle simple à l'aide de bash et générer plus de tels fichiers. Les répartir dans divers répertoires si vous le souhaitez. Supprimer quelques-uns d'entre eux au hasard. Faites tout cela à l'intérieur du système de fichiers XFS (monté sur / mnt), puis vérifiez la fragmentation. Tout cela est, bien sûr, facultatif.

Défragment 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éé plus tôt était sur le nœud de périphérique / dev / sdb. Nous pouvons utiliser l'utilitaire XFS_DB (signifie XFS Debogging) pour vérifier le niveau de fragmentation.

$ xfs_db -c frag -r / dev / sdb1

Le drapeau -c prend diverses commandes parmi lesquelles est la commande FRAG pour vérifier le niveau de fragmentation. Le drapeau -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 de 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 comme un cronjob qui surveillera régulièrement votre système de fichiers. Mais faire ça pour XFS n'a pas de sens. L'allocation de XFS basée sur l'étendue garantit que des 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 implique 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 et beaucoup de «trous» dans votre stockage. Les blocs de mémoire ne sont pas remplis de continument, ce qui rend la quantité d'espace disponible de plus en plus petit dans le temps.

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