hashget — est un dédupliqueur gratuit et open source — un outil semblable à un compresseur qui permet de réduire considérablement la taille des sauvegardes, ainsi que d'organiser des schémas de sauvegarde incrémentielle et différentielle, et bien plus encore. Cet article est une vue d'ensemble des possibilités. L'utilisation de hashget (assez simple) est décrite dans

le projet et README la documentation wiki Selon les règles du genre, je commencerai par l'intrigue — la comparaison des résultats :.

Comparaison

Échantillon de données

taille non compressée
hashget .tar.gz
.tar.gz
WordPress-5.1.1

43 Mo
11 Mo ( 26 % )
155 Ko (
Noyau Linux 5.0.4 0.3% )

934 Mo
161 Mo ( 20 % )
4,7 Mo (
Debian 9 (LAMP) LXC VM 0.5% )

724 Mo
165 Mo ( 23 % )
4,1 Mo (
Contexte, à quoi devrait ressembler une sauvegarde idéale et efficace 0.5% )

Chaque fois que je faisais une sauvegarde d'une nouvelle machine virtuelle, j'avais l'impression que je faisais quelque chose de travers. Pourquoi ai-je une sauvegarde lourde d'un système où ma précieuse création immortelle est un simple index.html avec le texte « Hello world » ?

Pourquoi ma sauvegarde contient-elle un fichier 16 Mo /usr/sbin/mysqld ? Est-ce moi qui ai l'honneur de conserver ce fichier crucial, et si je n'y parviens pas, il sera perdu pour l'humanité ? Probablement pas. Il est stocké sur des serveurs Debian hautement fiables (la fiabilité et la disponibilité de ceux-ci ne peuvent en aucun cas être comparées à ce que je peux offrir), ainsi que dans des sauvegardes (millions) d'autres administrateurs. Avons-nous vraiment besoin de créer 10 000 000 + 1 copies de ce fichier important pour augmenter la fiabilité ?

En gros

et résout ce problème. Lors de l'archivage — il crée une sauvegarde très petite. Lors de la restauration — un système complètement restauré, similaire à celui qui aurait été obtenu avec hashget tar -c tar -x / . (En d'autres termes, c'est un archivage sans perte)Comment fonctionne hashget

Dans hashget, il y a des concepts de Package et HashPackage, avec lesquels il réalise la déduplication.

(package). Un fichier (généralement un archive .deb ou .tar.gz) qui peut être téléchargé en toute sécurité depuis le réseau, et dont il est possible d'extraire un ou plusieurs fichiers.

Package HashPackage

— un petit fichier JSON représentant le Package, contenant notamment l'URL du paquet et les sommes de contrôle (sha256) des fichiers à l'intérieur. Par exemple, pour le paquet mariadb-server-core de 5 mégaoctets, la taille de hashpackage est de seulement 6 Ko. Environ mille fois plus petit. La déduplication

— consiste à créer une archive sans fichiers dupliqués (si le dédupliqueur sait où le paquet d'origine peut être téléchargé, il réduit les duplicatas de l'archive). Archivage

Compression

Lors de l'archivage, tous les fichiers du répertoire à archiver sont examinés, leurs sommes de contrôle sont calculées et si la somme est trouvée dans l'un des HashPackages connus, les métadonnées du fichier (nom, hachage, droits d'accès, etc.) sont enregistrées dans un fichier spécial .hashget-restore.json, qui sera également inclus dans l'archive.

L'archivage lui-même ressemble, dans son cas le plus simple, à un tar :

hashget -zf /tmp/mybackup.tar.gz --pack /path/to/data

Extraction

L'extraction se fait en deux étapes. D'abord, l'extraction tar classique :

tar -xf mybackup.tar.gz -C /path/to/data

puis la restauration depuis le réseau :

hashget -u /path/to/data

Lors de la restauration, hashget lit le fichier .hashget-restore.json, télécharge les paquets nécessaires, les extrait et place les fichiers requis aux emplacements appropriés, en définissant les propriétaires, groupes et permissions nécessaires.

Des choses plus complexes

Ce qui est décrit ci-dessus est suffisant pour ceux qui veulent « comme tar, mais qui emballe mon Debian en 4 mégaoctets». Passons maintenant à des choses plus complexes.

Indexation

Si hashget n'avait pas eu un seul HashPackage, il n'aurait tout simplement pas pu dédupliquer quoi que ce soit.

On peut créer un HashPackage manuellement (simplement : hashget --submit https://wordpress.org/wordpress-5.1.1.zip -p my), mais il y a une méthode plus pratique.

Pour obtenir les HashPackages nécessaires, il y a une étape d'indexation (elle s'exécute automatiquement lors de la commande --packDeep Speech d'heuristique. Lors de l'indexation, hashget «présente» chaque fichier trouvé à toutes les heuristiques disponibles qui l'intéressent. Les heuristiques peuvent ensuite indexer un Package afin de créer un HashPackage.

Par exemple, l'heuristique Debian aime le fichier /var/lib/dpkg/status et détecte les paquets Debian installés, et s'ils ne sont pas indexés (si aucun HashPackage n'a été créé pour eux), elle les télécharge et les indexe. Cela a un effet très agréable : hashget dédupliquera toujours efficacement les systèmes d'exploitation Debian, même s'ils contiennent les paquets les plus récents.

Fichiers d'indice (hints)

Si votre réseau utilise un paquet propriétaire ou un paquet public qui n'est pas inclus dans les heuristiques de hashget, vous pouvez ajouter un simple fichier de hints hashget-hint.json au format suivant :

{
    "project": "wordpress.org",
    "url": "https://ru.wordpress.org/wordpress-5.1.1-ru_RU.zip"
}

Ensuite, chaque fois qu'une archive est créée, le paquet sera indexé (s'il ne l'a pas été auparavant), et les fichiers du paquet seront dédupliqués de l'archive. Il n'est pas nécessaire de programmer, tout peut être fait depuis vim et économiser à chaque sauvegarde. Notez qu'en raison de l'approche par hachage, si des fichiers du paquet sont modifiés localement (par exemple, un fichier de configuration a été modifié) — les fichiers modifiés seront conservés dans l'archive « tels quels » et ne seront pas réduits.

Si un de vos propres paquets est mis à jour régulièrement, mais que les changements ne sont pas très importants, vous pouvez faire un hint uniquement pour les versions principales. Par exemple, dans la version 1.0, un hint a été fait pointant vers mypackage-1.0.tar.gz, et il sera complètement dédupliqué, puis la version 1.1 a été publiée, qui est légèrement différente, sans mettre à jour le hint. Ce n'est pas grave. Seuls les fichiers qui correspondent (qui peuvent être restaurés) à la version 1.0 seront dédupliqués.

L'heuristique qui traite le fichier hint — est un bon exemple pour comprendre le mécanisme interne de fonctionnement des heuristiques. Elle traite uniquement les fichiers hashget-hint.json (ou .hashget-hint.json avec un point) et ignore tous les autres. À partir de ce fichier, elle détermine quelle URL de paquet doit être indexée, et hashget l'indexe (s'il ne l'a pas fait auparavant).

HashServer

Il serait assez laborieux de procéder à l'indexation complète lors de la création de sauvegardes. Pour cela, il faudrait télécharger chaque paquet, le décompresser, l'indexer. C'est pourquoi hashget utilise un schéma avec HashServer. Lorsqu'un paquet debian installé est détecté, s'il ne se trouve pas dans les HashPackage locaux, une tentative est d'abord faite pour simplement télécharger HashPackage depuis le serveur de hachage. Et seulement si cela échoue — hashget télécharge et hachète le paquet lui-même (et le télécharge sur hashserver, afin que, par la suite, hashserver puisse le fournir).

HashServer n'est pas un élément obligatoire du schéma, il n'est pas critique, il sert uniquement à accélérer et à réduire la charge sur les dépôts. Il peut être facilement désactivé (avec l'option --hashserver sans paramètres). De plus, il est facile de créer votre propre hashserver..

Sauvegardes incrémentales et différentielles, expiration planifiée

hashget permettent de créer très facilement un schéma de sauvegardes incrémentales et différentielles.Pourquoi ne pas indexer notre propre sauvegarde (avec tous nos fichiers uniques) ? Une commande --submit Et c'est prêt ! La prochaine sauvegarde que créera hashget n'inclura pas les fichiers de cette archive.

Mais ce n'est pas une bonne approche, car il peut arriver qu'en cas de restauration, nous devions solliciter toutes les sauvegardes hashget de l'historique (si chacune contient au moins un fichier unique). Pour cela, il existe un mécanisme de péremption planifiée des sauvegardes. Lors de l'indexation, vous pouvez spécifier la date d'expiration de HashPackage --expires 2019-06-01, et à l'arrivée de cette date (à 00:00), il ne sera pas utilisé. L'archive elle-même peut être conservée après cette date (bien que hashget puisse facilement montrer les URL de toutes les sauvegardes qui ont expiré ou expireront à ce moment-là ou à toute date donnée).

Par exemple, si nous faisons une sauvegarde complète le 1er et que nous l'indexons avec une durée de vie jusqu'à la fin du mois, nous obtiendrons un schéma de sauvegarde différentielle.

Si nous indexons également les nouvelles sauvegardes de cette manière, nous aurons un schéma de sauvegardes incrémentales.

Contrairement aux schémas traditionnels, hashget permet d'utiliser plusieurs sources de base. La sauvegarde sera réduite à la fois par la réduction des fichiers des sauvegardes précédentes (s'ils existent) et par les fichiers publics (ce qui peut être téléchargé).

Si, pour une raison quelconque, nous ne faisons pas confiance à la fiabilité des ressources Debian (https://snapshot.debian.org/) ou utilisons une autre distribution, nous pouvons simplement effectuer une sauvegarde complète avec tous les paquets une fois, et nous appuyer sur elle par la suite (désactivant l'heuristique). Maintenant, si tous nos serveurs de distribution deviennent inaccessibles (dans un Internet souvenir ou lors d'un apocalypse zombie), mais que nos sauvegardes sont en ordre, nous pourrons nous restaurer à partir de n'importe quelle sauvegarde différentielle courte, en nous appuyant uniquement sur nos sauvegardes antérieures.

Hashget s'appuie uniquement sur des sources de restauration fiables à votre convenance. Celles que vous jugez fiables seront utilisées.

FilePool et Glacier

Le mécanisme FilePool permet de ne pas avoir à se connecter en permanence à des serveurs externes pour télécharger des paquets, mais d'utiliser des paquets à partir d'un répertoire local ou d'un serveur d'entreprise, par exemple :

$ hashget -u . --pool /tmp/pool

ou

$ hashget -u . --pool http://myhashdb.example.com/

Pour créer un pool dans un répertoire local, il suffit de créer un répertoire et d'y ajouter des fichiers, hashget trouvera ce dont il a besoin par hachage. Pour rendre le pool accessible via HTTP, il faut créer des liens symboliques d'une manière spéciale, cela se fait avec une seule commande (hashget-admin --build /var/www/html/hashdb/ --pool /tmp/pool). Le HTTP FilePool concerne des fichiers statiques, donc n'importe quel serveur web simple peut le gérer, la charge sur le serveur est presque nulle.

Grâce à FilePool, il est possible d'utiliser non seulement des ressources http(s) comme ressources de base, mais aussi, par exemple,, Amazon Glacier.

Après avoir téléchargé la sauvegarde sur Glacier, nous obtenons son ID de téléchargement et l'utilisons comme URL. Par exemple :

hashget --submit Glacier_Upload_ID --file /tmp/my-glacier-backup.tar.gz --project glacier --hashserver --expires 2019-09-01

Maintenant, les nouvelles sauvegardes (différentielles) se baseront sur cette sauvegarde et seront plus courtes. Après déballage tar de la sauvegarde différentielle, nous pouvons voir sur quelles ressources elle s'appuie :

hashget --info /tmp/unpacked/ list

et simplement avec un script shell, télécharger tous ces fichiers depuis Glacier dans le pool et lancer la restauration normale : hashget -u /tmp/unpacked --pool /tmp/pool

Est-ce que ça vaut vraiment le coup

Dans le plus simple des cas, vous paierez simplement moins pour les sauvegardes (si vous les stockez quelque part dans le cloud à des frais). Peut-être beaucoup moins.

Mais ce n'est pas tout. La quantité se transforme en qualité. Vous pouvez utiliser cela pour obtenir une amélioration significative de votre schéma de sauvegarde. Par exemple, puisque nos sauvegardes sont maintenant plus courtes, nous pouvons effectuer des sauvegardes non plus mensuelles, mais quotidiennes. Les conserver pendant 5 ans au lieu de 6 mois, comme auparavant. Auparavant, elles étaient stockées dans un « entrepôt froid » lent mais bon marché (Glacier), maintenant vous pouvez les stocker dans un entrepôt chaud, d'où vous pouvez toujours rapidement télécharger la sauvegarde et vous restaurer en quelques minutes, au lieu d'un jour.

Vous pouvez augmenter la fiabilité du stockage des sauvegardes. Si nous les stockons actuellement dans un seul entrepôt, en réduisant le volume des sauvegardes, nous pourrons les conserver dans 2-3 entrepôts et survivre sans problème si l'un d'eux est endommagé.

Comment essayer et commencer à utiliser ?

Rendez-vous sur la page GitLab https://gitlab.com/yaroslaff/hashget, installez avec une seule commande (pip3 install hashget[plugins]) et il suffit de lire et d'exécuter le quick-start. Je pense que tout ce qui est simple à faire prendra environ 10-15 minutes. Ensuite, on peut essayer de compresser nos machines virtuelles, créer des fichiers hint si nécessaire pour une compression plus efficace, jouer avec les pools, la base de données de hachages locale et le hachage serveur, si cela vous intéresse, et le lendemain, voir quelle sera la taille de la sauvegarde incrémentielle par rapport à celle d'hier.

Source : habr.com