Sauvegarde et restauration
Rediacc sauvegarde des dépôts chiffrés et les restaure sur la même machine ou sur une machine différente. Les sauvegardes sont chiffrées parce que le dépôt l’est : ce qui quitte la machine, c’est le texte chiffré, et l’identifiant LUKS de votre dépôt est nécessaire pour la restauration.
Il existe deux façons de sauvegarder, et elles répondent à des questions différentes.
- Les instantanés vers le stockage fragmenté (
rdc backup snapshot) conservent un historique dans lequel vous pouvez remonter. C’est la voie principale. - Une copie sur une autre machine (
rdc repo push,rdc repo pull) conserve le dépôt tel qu’il est maintenant, sur du matériel que vous contrôlez. Aucun compte cloud n’est impliqué.
Elles sont indépendantes. Un dépôt sauvegardé d’une façon n’est pas sauvegardé de l’autre.
Comment fonctionnent les instantanés
L’image du dépôt est découpée en cellules de taille fixe sur une grille fixe. Chaque cellule est soit un trou, ce qui signifie que rien n’y a jamais été écrit, soit elle est stockée sous une clé qui est le SHA-256 du texte chiffré de cette cellule.
C’est de cette seule décision que découlent les propriétés.
Seuls les vrais changements coûtent quelque chose. Le premier instantané envoie chaque cellule écrite. Chaque exécution suivante demande au système de fichiers quels extents ont été touchés, ne lit et ne hashe que ceux-là, et n’envoie que les cellules que le stockage ne possède pas encore. Un dépôt dont les données ont à peine bougé n’envoie presque rien, et l’exécution prend quelques minutes plutôt qu’un temps proportionnel à la taille de l’image.
Les données identiques sont stockées une seule fois. Comme la clé est le hash du contenu, deux instantanés qui partagent une cellule partagent le même objet, et il en va de même pour un dépôt et ses forks : une famille de forks se sauvegarde contre une lignée unique plutôt que de dupliquer son parent.
Restaurer un ancien instantané n’est pas plus lent que d’en restaurer un récent. Il n’y a pas de chaîne d’incréments à rejouer. La restauration résout l’instantané en une liste complète de cellules et récupère ces cellules directement, si bien que le temps de restauration dépend de la taille de l’image et de votre bande passante, pas de la durée pendant laquelle vous faites des sauvegardes. Les trous restent des trous, si bien qu’une image creuse se restaure creuse, et une cellule qui apparaît à plusieurs endroits de l’image n’est téléchargée qu’une seule fois.
Chaque instantané tient tout seul. Il n’y a pas de « sauvegarde complète » que vous ne devez pas perdre, ni de fenêtre où un incrément défectueux invalide ceux qui suivent. Tout instantané de la liste est directement restaurable.
La vérification, c’est du rehachage, pas de la confiance. Comme la clé est le hash du contenu, vérifier une sauvegarde signifie récupérer des cellules et les hacher. rdc backup verify échantillonne ; rdc backup verify --deep rehache chaque cellule enregistrée.
Une exécution interrompue n’est pas gaspillée. L’envoi reprend sans renvoyer les cellules déjà arrivées, et le redémarrage d’une restauration partielle rehache ce qui est déjà sur le disque et le réutilise plutôt que de le retélécharger.
Ce que cela vous coûte
Le quota est compté en octets physiques uniques stockés : ce qui est réellement conservé après déduplication, pas la somme de ce que vos instantanés représentent logiquement. Trente instantanés d’un dépôt qui change lentement coûtent presque comme un seul. rdc backup usage affiche les octets stockés par rapport à votre quota, un nombre par abonnement qui commence à 10 Go sur une offre Community.
Une machine sous licence gratuite n’a pas de sauvegarde hébergée, et les verbes de sauvegarde la refusent avec un message de mise à niveau. Créez un compte (le forfait Community est gratuit), connectez-y la machine et ses sauvegardes compteront dans les 10 Go de stockage hébergé.
Ce dont les instantanés ont besoin
L’envoi d’un instantané passe par le serveur de compte, qui autorise chaque exécution par rapport à la licence installée du dépôt et remet à la machine une autorisation d’écriture de courte durée. Cette voie nécessite donc un serveur de compte que la machine peut atteindre et un dépôt sous licence. Sans eux, l’instantané est refusé plutôt que discrètement ignoré, et rdc backup manifests, rdc backup usage et rdc backup retention n’ont rien à lire.
Cela inclut --dry-run. La licence est lue avant que l’exécution ne décide si elle planifie ou envoie, si bien qu’une exécution à blanc est un aperçu du travail, pas un moyen d’essayer la commande sans identifiants.
Le push et le pull de machine à machine n’ont besoin ni de l’un ni de l’autre. Ce sont des transferts directs entre deux machines déjà présentes dans votre configuration.
Ce qu’un instantané ne promet pas
- Un instantané couvre un dépôt, pas toute votre machine à la fois. Chaque dépôt est capturé à son propre instant. Si deux dépôts dépendent l’un de l’autre, leurs instantanés ne forment pas une paire coordonnée.
- Ce n’est pas une réplication continue. Un instantané est un point que vous avez pris, et vous pouvez perdre tout ce qui a été écrit depuis le dernier. Combien dépend de la fréquence à laquelle vous l’exécutez.
- Les objets stockés sont en écriture unique, pas un WORM certifié. Les cellules sont écrites avec une condition de création seule, l’autorisation qu’obtient une machine ne peut rien supprimer, et les suppressions se font côté serveur selon la politique de rétention. C’est une vraie barrière contre une machine compromise qui détruirait ses propres sauvegardes. Ce n’est pas une certification de conformité, et ce n’est pas audité comme telle.
Destinations
Une stratégie peut écrire dans le store home, dans une seconde région hébergée ou dans un bucket client enregistré, et chaque destination est son propre point de récupération. Les stores, la désignation du store d’une destination, la restauration avec --from et l’état par destination sont décrits sur la page Destinations de sauvegarde. --to et --from sur repo push et repo pull ne désignent toujours qu’une machine.
Commandes de stockage fragmenté
# Envoyer un instantané. La première exécution amorce, les suivantes n'envoient que les cellules modifiées.
rdc backup snapshot my-app
# Planifier sans envoyer : indique ce qui serait déplacé.
rdc backup snapshot my-app --dry-run
# Arrêter les conteneurs, geler, redémarrer, puis envoyer.
rdc backup snapshot my-app --cold
# Ne pas faire confiance à l'ancre locale et renvoyer tout l'inventaire.
# Ceci renvoie tout et recharge le quota ; à n'utiliser que lorsque
# l'ancre est connue pour être défaillante.
rdc backup snapshot my-app --reseed
# Vérifier l'inventaire stocké et votre quota.
rdc backup verify my-app
rdc backup manifests my-app
rdc backup usage
| Option | Description |
|---|---|
<repo-ref> (positionnel) | Dépôt à sauvegarder |
--dry-run | Planification seule : pas d’envoi. Indique ce qui serait déplacé |
--cold | Arrêter les conteneurs, geler, redémarrer, puis envoyer. Ne se combine pas avec --dry-run |
--reseed | Ne pas faire confiance à l’ancre locale et envoyer un inventaire complet. Renvoie tout et recharge le quota |
--accept-identity-change | Adopter l’image comme nouvelle base quand son identité LUKS a changé ou qu’elle a rétréci. Envoie un instantané complet, et une exécution planifiée ne l’applique jamais |
--read-bwlimit <limit> | Plafond de la vitesse à laquelle l’instantané lit l’image sur le disque, dans les mêmes unités que --bwlimit (par défaut 50M, 0 = illimité) |
--hash-parallelism <n> | Nombre de workers de hachage (par défaut 1, 0 = un par CPU, jusqu’à 16) |
--debug | Activer la sortie détaillée |
Le plafond d’envoi et le plafond de lecture sont distincts. --bwlimit limite ce qui est envoyé et est illimité par défaut ; --read-bwlimit limite la vitesse à laquelle l’image est lue et hachée depuis le disque. ionice n’agit que sur l’ordonnanceur d’E/S BFQ : avec mq-deadline ou none, c’est le plafond de lecture qui borne la charge du disque.
Instantanés à froid (--cold)
Un instantané à froid arrête un dépôt avant de le figer : l’image stockée est donc cohérente au niveau applicatif plutôt que cohérente en cas de crash. La commande s’exécute sur la machine elle-même :
# Tous les dépôts du datastore par défaut.
sudo renet backup snapshot --cold
# Uniquement les dépôts nommés. --repo prend un GUID de dépôt et se répète.
sudo renet backup snapshot --cold --repo <guid> --repo <guid>
--cold ne se combine pas avec --dry-run. Une exécution à blanc qui arrête des conteneurs n’est pas à blanc, et une qui ne les arrête pas n’est pas à froid : renet refuse donc la combinaison au lieu de choisir un sens à votre place.
Ce que fait une exécution à froid
Pour chaque dépôt sélectionné, dans cet ordre :
- Arrêter ses conteneurs.
- Écrire sur disque le montage du dépôt et le datastore.
- Vérifier que les conteneurs se sont réellement arrêtés.
- Prendre un reflink copie-sur-écriture de l’image du dépôt.
- Redémarrer les conteneurs.
L’envoi ne commence qu’ensuite, alors que tous les dépôts sont déjà repartis.
Le temps d’arrêt, c’est le gel, pas le transfert. Un reflink ne touche que des métadonnées : il prend le même temps que le dépôt pèse 1 GB ou 100 GB. Un envoi, lui, grandit avec les octets modifiés, et un premier instantané envoie tout l’inventaire non nul. Garder les conteneurs arrêtés jusqu’à la fin de l’envoi lierait le temps d’arrêt au volume des données, soit des heures au lieu de quelques millisecondes lors du premier envoi.
Tous les dépôts sélectionnés sont arrêtés dans une seule fenêtre plutôt qu’un par un. Cela coûte un peu plus de temps d’arrêt par dépôt, et cela offre un point de cohérence unique sur l’ensemble.
Un dépôt sans conteneur en cours d’exécution est déjà au repos. Il est capturé sans le moindre temps d’arrêt, et c’est un résultat normal, pas un échec.
Ce que coûte le temps d’arrêt
Mesuré sur une machine réelle, le temps d’arrêt total a été de 222 ms :
| Phase | Mesuré | Ce qui se passe |
|---|---|---|
cold_down | 64 ms | Les conteneurs s’arrêtent |
cold_sync | 26 ms | Montages du dépôt et datastore écrits sur disque |
cold_verify | 31 ms | Arrêt des conteneurs confirmé |
cold_stage | 0 ms | Reflink de l’image du dépôt |
cold_up | 99 ms | Les conteneurs redémarrent |
Le redémarrage des conteneurs domine, et la préparation ne coûte pratiquement rien : le reflink n’apparaît même pas à la milliseconde près. Lisez tout de même ce zéro à côté des enregistrements de chaque dépôt, et non isolément. Une exécution qui a refusé tous les dépôts affiche elle aussi cold_stage=0ms, et seuls les enregistrements disent lequel des deux cas vous avez sous les yeux.
Ce détail est la preuve, pas de la décoration. Aucune de ces cinq phases ne lit ni n’envoie de données du dépôt, donc aucune ne grandit quand la sauvegarde grandit. La partie qui grandit, l’envoi, se déroule une fois le temps d’arrêt terminé.
renet affiche les mêmes chiffres à la fin d’une exécution, pour que vous mesuriez vos propres machines au lieu de nous croire sur parole :
Cold backup: <n> repositories quiesced, outage 222ms (cold_down=64ms cold_sync=26ms cold_verify=31ms cold_stage=0ms cold_up=99ms)
Chaque enregistrement JSON de dépôt porte le même temps d’arrêt et les mêmes phases, si bien qu’on distingue plus tard un instantané à froid d’un instantané à chaud sans le deviner d’après les durées.
Quand choisir le froid
Le mode à chaud est celui par défaut, et c’est le bon choix pour la plupart des dépôts. Un instantané à chaud est cohérent en cas de crash, c’est-à-dire dans l’état où serait un dépôt après une coupure de courant, et il ne coûte aucun temps d’arrêt. La plupart des bases de données et des files d’attente s’en remettent toutes seules.
Choisissez le froid pour des données qu’on ne peut pas capturer sans risque pendant leur écriture. Une base de données avec son propre journal d’écriture anticipée et son état en mémoire est le cas typique. Vous échangez un court temps d’arrêt mesuré contre un instantané que l’application peut ouvrir sans devoir se réparer d’abord.
Ce qu’une exécution à froid refuse
Le refus est la fonctionnalité. Une sauvegarde étiquetée à froid qui n’a rien mis au repos est un mensonge que vous ne découvririez qu’à la restauration : renet ne rétrograde donc jamais une exécution à froid en exécution à chaud.
- Des conteneurs qui ne se sont pas arrêtés. Après l’arrêt, renet demande au socket Docker du dépôt si quelque chose tourne encore. Si oui, ce dépôt est refusé au lieu d’être capturé. Le contrôle tranche du côté sûr : si le socket est injoignable ou la liste des conteneurs illisible, la mise au repos est considérée comme non vérifiée, et non vérifiée signifie refusée.
- Une licence illisible. Les licences sont vérifiées avant le temps d’arrêt et non après, car un dépôt dont la licence est illisible n’aurait de toute façon rien pu envoyer. Un tel dépôt est ignoré sans être arrêté. Si aucun des dépôts sélectionnés n’a de licence lisible, toute l’exécution est refusée avant qu’un seul conteneur ne s’arrête.
- Une deuxième exécution à froid sur le même datastore. Le verrou couvre le datastore entier, et un verrou déjà pris est refusé immédiatement, sans avoir rien arrêté. Deux exécutions qui se chevauchent arrêteraient chacune des conteneurs que l’autre croit lui appartenir, et la seconde redémarrerait des dépôts que la première est encore en train de figer. Sauter l’exécution et attendre la suivante vaut mieux que cela.
Si une exécution est interrompue alors que les conteneurs sont arrêtés, par un systemctl stop ou un redémarrage, renet les relance avant de quitter. La reprise sur la machine sert de filet : elle repère une sauvegarde à froid dont le propriétaire a disparu et remet ces dépôts en marche.
Envoyer une sauvegarde vers une autre machine
Copiez un dépôt vers une seconde machine par SSH :
rdc repo push my-app --to server-1
--to <machine> résout la destination depuis votre configuration, et --to-machine <machine> dit la même chose explicitement. Un nom de stockage est refusé : cette voie est retirée.
L’image chiffrée est copiée avec le MÊME GUID : il s’agit donc d’une sauvegarde ou d’une migration, pas d’un fork. Pour obtenir une copie indépendante, exécutez d’abord rdc repo fork puis envoyez le fork.
Le premier envoi transporte l’image entière. Chaque envoi suivant n’envoie que les blocs modifiés par rapport à une image de base immuable conservée sur les deux machines, sans aucun indicateur à définir. --delta-base <guid> nomme cette base vous-même si besoin.
La copie envoyée atterrit sur la cible comme un artefact de sauvegarde plutôt que comme un dépôt en cours d’exécution. Transformez-la en un dépôt avec rdc backup restore :
rdc backup restore my-app@server-1 --as my-app --machine server-1 --up
Pour une sauvegarde à un instant donné, utilisez plutôt le stockage fragmenté : rdc backup snapshot my-app n’envoie que les cellules modifiées, et rdc backup restore my-app --at <snapshot> en récupère n’importe laquelle.
| Option | Description |
|---|---|
<ref> (positionnel) | Réf du dépôt à envoyer |
--to <remote> | Machine ou cluster de destination |
--to-machine <machine> | Machine de destination, indiquée explicitement |
--provision <provider> | Provisionner la machine cible via ce fournisseur cloud si elle n’existe pas |
--checkpoint | Créer un checkpoint CRIU avant l’envoi (pour les conteneurs avec le label rediacc.checkpoint=true). La cible se restaure automatiquement lors du repo up |
--force | Écraser une sauvegarde existante |
--bwlimit <limit> | Limite de bande passante pour le transfert rsync (p. ex. 10M, 500K) |
--delta-base <guid> | Ne transférer que les blocs modifiés par rapport à cette GUID de base immuable. Omettre pour une base automatique |
--strategy <strategy> | Stratégie de delta de blocs lors de l’utilisation d’une base delta : auto, physical ou shared |
--debug | Activer la sortie détaillée |
--skip-router-restart | Ignorer le redémarrage du serveur de routes après l’opération |
Récupérer une sauvegarde depuis une autre machine
Ramenez un dépôt depuis la machine qui le détient :
rdc repo pull my-app --from server-1
Ajoutez --up pour le monter et le déployer dans la même commande. Pour restaurer depuis le stockage fragmenté à la place, utilisez rdc backup restore my-app --at <snapshot-id>.
Pull refuse d’écraser un dépôt actuellement monté. Démontez-le d’abord, effectuez le pull, puis remontez-le avec rdc repo up. Les dépôts basés sur un répertoire font exception : ils se synchronisent sur place même montés.
| Option | Description |
|---|---|
<ref> (positionnel) | Réf du dépôt à récupérer |
--from <remote> | Machine ou cluster source |
--from-machine <machine> | Machine source, indiquée explicitement |
--force | Écraser la sauvegarde locale existante |
--up | Monter et déployer le dépôt après la récupération |
--bwlimit <limit> | Limite de bande passante pour le transfert rsync (p. ex. 10M, 500K) |
--delta-base <guid> | Ne recevoir que les blocs modifiés par rapport à cette GUID de base immuable |
--strategy <strategy> | Stratégie de delta de blocs lors de l’utilisation d’une base delta : auto, physical ou shared |
--debug | Activer la sortie détaillée |
--skip-router-restart | Ignorer le redémarrage du serveur de routes après l’opération |
Lister les sauvegardes
Listez les instantanés dans le stockage fragmenté :
rdc backup manifests my-app
Chaque ligne est un point dans le temps stocké :
| Colonne | Signification |
|---|---|
Repo | Nom du dépôt résolu depuis votre configuration locale (retombe sur le GUID pour les dépôts absents de la configuration) |
Snapshot | L’id de l’instantané. C’est ce que prend rdc backup restore --at |
Created | Heure UTC à laquelle l’instantané a été pris |
Total | Taille de l’image du dépôt que cet instantané représente |
Added | Octets que cet instantané a réellement envoyés en plus des précédents |
Chunks | Combien de cellules il a ajoutées |
Pour voir ce qu’un rdc repo push --to <machine> a laissé sur la destination, demandez à cette machine ce qu’elle détient :
rdc repo list --machine server-1
La copie envoyée apparaît sous son propre nom. Une seconde ligne portant un GUID brut à côté est la base delta conservée, ce qui rend le prochain envoi vers cette machine incrémental plutôt qu’un transfert complet.
rdc backup list --machine <machine> lit les dossiers hot/ et cold/ dans lesquels écrivent les exécutions planifiées, ce qui en fait le mauvais outil pour une copie qu’un envoi y a placée, et il ne vous montrera rien.
| Colonne | Signification |
|---|---|
Mode | hot ou cold. Dans quel dossier de sauvegarde planifiée cette entrée se trouve |
Name | Nom du dépôt résolu depuis votre configuration locale (retombe sur le GUID pour les dépôts absents de la configuration) |
GUID | Le GUID du dépôt sur disque |
Size | Taille lisible de la sauvegarde |
Modified | Horodatage UTC du fichier sur la machine |
Rétention
Le serveur applique une politique de rétention sur le stockage fragmenté, si bien que les anciens instantanés sont élagués sans rien supprimer à la main. Une politique appartient à la lignée d’un dépôt : un dépôt et ses forks partagent un même historique, et une politique définie sur le nom du dépôt couvre toute la famille. Au sein d’une lignée, chaque flux de sauvegarde (un dépôt sur une machine) est aussi protégé séparément, si bien que la rétention ne laisse jamais un flux sans ses instantanés les plus récents ni son ancre actuelle, quelle que soit la politique. Une seconde machine ou un fork qui élague son propre historique ne peut pas consommer le plancher d’un autre flux.
Sans politique déclarée, une valeur par défaut du serveur s’applique (celle de l’offre, quand l’offre en définit une) et les instantanés les plus récents de chaque flux sont conservés.
# Ce qui est actuellement appliqué, et d'où cela vient.
rdc backup retention my-app
# Ce que le prochain passage supprimerait, et l'espace libéré. Rien n'est supprimé.
rdc backup retention preview my-app
# Conserver une fenêtre glissante : 7 quotidiens, 4 hebdomadaires, 6 mensuels.
rdc backup retention set my-app --keep-daily 7 --keep-weekly 4 --keep-monthly 6
# Appliquer une politique différente à un seul flux de sauvegarde.
rdc backup retention set my-app --stream <stream-id> --keep-last 3
# Retirer la politique déclarée.
rdc backup retention clear my-app
rdc backup retention clear my-app --stream <stream-id>
# Supprimer un instantané maintenant. Les données que lui seul utilisait sont libérées par le prochain GC.
rdc backup snapshots delete my-app <snapshot-id>
Une stratégie peut déclarer la politique des dépôts qu’elle couvre : rdc backup strategy set daily --retention last=7,daily=7,weekly=4,monthly=6 (--retention none la retire).
| Option | Description |
|---|---|
--keep-last <n> | Conserver ce nombre d’instantanés les plus récents |
--keep-hourly <n> | Conserver l’instantané le plus récent de chacune de ces heures |
--keep-daily <n> | Conserver l’instantané le plus récent de chacun de ces jours |
--keep-weekly <n> | Conserver l’instantané le plus récent de chacune de ces semaines |
--keep-monthly <n> | Conserver l’instantané le plus récent de chacun de ces mois |
--keep-yearly <n> | Conserver l’instantané le plus récent de chacune de ces années |
--keep-within <duration> | Conserver tous les instantanés dont l’âge, par rapport au plus récent du flux, ne dépasse pas cette durée, par exemple 24h ; la durée se mesure depuis l’instantané le plus récent et non depuis maintenant, si bien qu’un flux à l’arrêt ne supprime rien de sa fenêtre |
--stream <id> | Appliquer la politique à un seul flux de sauvegarde plutôt qu’à la valeur par défaut du dépôt entier |
Donnez au moins une règle. set remplace chaque paramètre au lieu de fusionner, donc la politique complète est transmise à chaque appel. set sans règles est refusé plutôt que traité comme « ne rien conserver », car supprimer une politique, c’est précisément à cela que sert clear. clear retire la politique déclarée, si bien que la valeur par défaut du forfait ou du serveur s’applique de nouveau ; cela ne signifie jamais « ne rien conserver » ni « tout conserver ».
Restaurer
rdc backup restore transforme une sauvegarde en dépôt vivant, et c’est la même commande pour les deux voies. Ce qui diffère, c’est ce que vous lui indiquez.
# Un point dans le temps depuis le stockage fragmenté.
rdc backup restore my-app --as my-app-yesterday --at <snapshot-id> --up
# Un artefact laissé par un envoi sur une machine.
rdc backup restore my-app@server-1 --as my-app --machine server-1 --up
--at prend un id d’instantané depuis rdc backup manifests, ou une heure RFC 3339 comme 2026-08-14T12:00:00Z, qui se résout à l’instantané le plus récent pris à ce moment ou avant. Une heure sans instantané à ce moment ou avant est refusée plutôt qu’arrondie vers l’avant.
Une heure se résout uniquement parmi les instantanés de ce dépôt sur sa machine source. Les instantanés écrits par d’autres machines ou par des forks de la même lignée ne sont pas pris en compte, sauf si --any-stream élargit volontairement la recherche. Quand le flux propre du dépôt ne peut pas être déterminé, la restauration est refusée et demande --any-stream au lieu de deviner.
Lorsque plusieurs stores contiennent le dépôt, la restauration lit le store dont l’instantané le plus récent a passé la dernière vérification, et passe au store suivant quand un store échoue. --from <storeId> lit un seul store nommé et ne bascule jamais. Voir Destinations de sauvegarde.
Restaurer sous un nouveau nom avec --as n’écrase rien, si bien qu’un exercice de restauration est sûr à exécuter sur une machine en direct. Restaurer sur un nom déjà existant est refusé.
| Option | Description |
|---|---|
<artifact-ref> (positionnel) | Ce qu’il faut restaurer. repo pour un instantané du stockage fragmenté, repo@place pour un artefact sur une machine |
--as <name> | Nom pour le dépôt restauré (par défaut, le nom de l’artefact) |
-m, --machine <machine> | Machine sur laquelle restaurer |
--datastore <name> | Restaurer dans ce datastore nommé, dont la machine attachée l’héberge |
--at <time> | Restaurer un point dans le temps : un id d’instantané ou une heure RFC 3339 |
--from <storeId> | Lire l’instantané depuis ce store de sauvegarde. Sans cette option, le store qui détient l’instantané vérifié le plus récent est lu, puis le suivant en cas d’échec d’un store. Avec --from, il n’y a pas de repli |
--any-stream | Avec --at, considère aussi les instantanés d’autres machines et de forks de cette lignée |
--up | Déployer le dépôt restauré après le transfert |
--allow-unopenable | Placer l’image même si la phrase secrète du dépôt ne l’ouvre pas (instantané antérieur à un changement de phrase secrète) |
--salvage | Poursuivre malgré les chunks perdus ou corrompus et laisser leurs cellules comme trous. Nécessite --as |
--health-window <seconds> | Durée d’observation de la santé du dépôt déployé |
--health-timeout <seconds> | Durée d’attente qu’il devienne sain |
-y, --yes | Ignorer la confirmation |
--debug | Activer la sortie détaillée |
Restaurer un dépôt nécessite son identifiant LUKS, qui vit dans votre configuration. Si vous avez activé le stockage de configuration, cet identifiant revient avec votre configuration sur une machine neuve. Sinon, gardez une copie de la configuration quelque part que la machine défaillante n’emportera pas avec elle.
Une restauration vérifie la phrase secrète avant de placer quoi que ce soit. Une fois l’image assemblée et sa taille et son en-tête LUKS validés, la phrase secrète de la configuration tente d’ouvrir l’image à titre d’essai. Si elle s’ouvre, la restauration annonce un succès. Sinon, la restauration échoue et ne place rien, et l’image assemblée reste en attente pour qu’une nouvelle tentative avec la bonne phrase secrète ne la télécharge pas de nouveau. Un instantané pris avant un changement de phrase secrète ne s’ouvre qu’avec l’ancienne ; --allow-unopenable place malgré tout une telle image et indique qu’elle n’a pas été ouverte.
Prouvez la restauration sur chaque machine
Une machine qui n’a jamais bouclé le cycle complet n’est pas sauvegardée, aussi verts que paraissent ses envois. Les envois et les restaurations échouent pour des raisons différentes, et le second type ne se manifeste que lorsque vous l’essayez.
Faites-le une fois par machine, avant de compter sur les sauvegardes :
- Prenez un instantané :
rdc backup snapshot my-app. - Confirmez qu’il est enregistré :
rdc backup manifests my-app. - Restaurez-le sous un nom jetable :
rdc backup restore my-app --as my-app-drill --at <snapshot-id>. - Comparez le dépôt restauré à la source, puis supprimez la copie d’exercice avec
rdc repo delete my-app-drill --yes.
Rien dans cette séquence ne touche le dépôt en direct, elle est donc sans danger sur une machine qui sert du trafic. Si vous quittez un ancien dispositif de sauvegarde, gardez-le en fonctionnement jusqu’à ce que cela ait réussi sur cette machine au moins une fois. Deux voies de sauvegarde coûtent du stockage ; une voie non prouvée coûte les données.
Synchroniser un dépôt à la fois
Push et pull agissent sur un seul dépôt, identifié par sa réf (name, name:tag ou name@machine). Il n’existe pas de forme « tous les dépôts en une fois » : exécutez la commande une fois par dépôt.
Une réf nommant un fork et une machine fonctionne comme un nom simple :
rdc repo push shop:nightly@server-1 --to server-2
rdc repo pull shop:nightly@server-1 --from server-2
Les listes d’options complètes se trouvent sous Envoyer une sauvegarde vers une autre machine et Récupérer une sauvegarde depuis une autre machine.
Vérifier et réparer les sauvegardes
Un instantané envoyé n’est pas encore un instantané qui se restaure. Chaque instantané porte un état de vérification, que les contrôles ci-dessous font évoluer.
L’échelle de vérification
| État | Défini par | Prouve |
|---|---|---|
unverified | Chaque nouvel instantané | Rien encore |
verified | Le contrôle ponctuel après une exécution, --deep, ou un passage --store sans erreur | L’ancre de la machine ou les chunks stockés correspondent à leurs empreintes. Le système de fichiers à l’intérieur n’est pas jugé |
proven | rdc backup check, ou --restore-test | La phrase secrète ouvre un vrai contenu |
failed | Tout contrôle qui a trouvé un problème | À ne pas utiliser comme référence |
Un instantané failed le reste jusqu’à ce qu’un contrôle portant sur les mêmes données réussisse. La rétention conserve l’instantané verified le plus récent et l’instantané proven le plus récent de chaque flux qui n’est pas failed, en plus du nombre d’instantanés à garder, si bien qu’une série de mauvaises nuits ne peut pas évincer toutes les bonnes versions. La suppression de l’un de ces deux instantanés est refusée.
rdc backup verify my-app --deep
rdc backup verify my-app --store
rdc backup verify my-app --restore-test
--deep recalcule l’empreinte de chaque cellule sur la machine. --store demande au serveur de recalculer l’empreinte de chaque chunk stocké et de nommer ceux qui manquent ou sont corrompus. --restore-test restaure l’instantané de l’ancre sous un nom jetable directement depuis le stockage, le compare, enregistre le résultat et supprime la copie. Les trois options ne se combinent pas.
Calendrier de vérification
rdc backup schedule ajoute la vérification aux unités qu’il génère. Le service d’instantané se termine par un contrôle ponctuel de cellules tirées au hasard, et un instantané en échec n’est jamais vérifié. Un minuteur quotidien, à une heure décalée, lance une vérification complète d’un dépôt par exécution sous CPUQuota=100%, en parcourant les dépôts à tour de rôle : le cycle est le plus grand entre 7 et le nombre de dépôts, en nuits. Un bloc verify facultatif de la stratégie règle cela avec spotAfterRun, deepSchedule (une expression cron) et off, qui ne génère ni le contrôle ponctuel ni le minuteur.
Les unités planifiées ne détiennent aucune phrase secrète par conception, donc les deux contrôles qui en ont besoin, rdc backup check et --restore-test, s’exécutent depuis la CLI, là où se trouve la configuration. Une fois par mois pour le premier et une fois par trimestre pour le second est un rythme raisonnable.
Prouver la phrase secrète
rdc backup check my-app
rdc backup check ouvre avec la phrase secrète la liste stockée d’un instantané récent, restaure un fichier dans un répertoire temporaire, le compare à la taille indiquée et enregistre proven ou failed. Seul le répertoire temporaire est supprimé. --path <file> choisit le fichier ; par défaut, c’est le plus petit fichier non vide. Un instantané sans liste stockée est signalé clairement et n’est pas proven.
Réparation et récupération
rdc backup repair my-app --dry-run
rdc backup repair my-app
rdc backup restore my-app --at <snapshot-id> --as my-app-salvage --salvage
La clé d’un chunk est l’empreinte de ses octets : un objet stocké dont l’empreinte ne correspond pas à sa clé ne pourra jamais satisfaire une restauration. rdc backup repair demande au serveur de relire chaque objet endommagé, de ne le supprimer que s’il est toujours erroné, puis renvoie la cellule depuis l’ancre de cette machine après avoir recalculé son empreinte. La commande refuse de s’exécuter tant qu’une sauvegarde détient la lignée, nomme les instantanés qui utilisaient les chunks endommagés et les marque failed. Un chunk que l’ancre de la machine ne contient pas ne peut pas être réparé, et la commande se termine avec un code non nul. --dry-run ne modifie rien.
--salvage sert pour un instantané impossible à réparer. Il ne restaure que sous un nouveau nom avec --as, jamais par-dessus un dépôt existant, écrit chaque cellule défectueuse comme un trou, liste les trous par plage d’octets et se termine avec un code non nul et le statut restored-damaged. Un trou dans l’en-tête LUKS rend l’image impossible à ouvrir, et le rapport le dit. Un fichier isolé, éloigné de toute cellule défectueuse, se restaure toujours proprement avec --path.
Clés de liste
La liste de navigation d’un instantané est scellée avec une clé publique, de sorte que la machine puisse l’écrire sans détenir la phrase secrète. La CLI dérive cette clé de l’identifiant du dépôt et installe la moitié publique au déploiement du calendrier. Si une machine détient déjà une clé différente, un avertissement est émis avec le nom du dépôt, et la clé n’est pas écrasée.
rdc backup toc-key sync my-app --dry-run
rdc backup toc-key sync my-app --replace
--replace installe la clé dérivée à la place d’une clé différente et envoie la phrase secrète pour le prouver. Un dépôt qui détient une clé mais n’a ni fichier de clé ni montage n’obtient aucune liste, et le journal de l’unité le signale. Un tel instantané se restaure quand même en entier ; seuls la navigation et rdc backup check ont besoin de la liste.
Alertes d’échec
Un instantané ou une vérification en échec parvient au compte par un rapport d’échec, et un flux qui cesse de rapporter au-delà de son délai de grâce est signalé lui aussi. Le compte envoie un e-mail récapitulatif par abonnement et par jour, selon la préférence de santé des sauvegardes de la page Notifications du portail, activée par défaut. rdc machine health affiche une vérification en échec comme un avertissement et se termine avec un code non nul. Un flux avec une cible déclarée qui n’a rien signalé à l’heure prévue de son prochain passage, ou dont les trois derniers passages ont chacun manqué la cible, envoie sa propre alerte, au plus une par flux et par période de 6 heures, indiquant la cible, la valeur atteinte et la raison. Le délai de détection est celui du balayage de maintenance, soit une heure, de sorte qu’une alerte peut arriver jusqu’à une heure après le manquement. Un flux sans cible reste dans le résumé quotidien.
Sauvegardes de niveau critique
Un dépôt qui doit perdre des minutes plutôt qu’une journée déclare une cible de protection. Les instantanés s’exécutent alors à courte cadence, les cellules modifiées sont envoyées à chaque passage, et le compte surveille la cible.
Déclarer une cible
# Mesurer ce qui change entre deux exécutions, puis lire la projection et la recommandation de taille de cellule.
rdc backup churn mail --samples 12 --interval 5m
# Déclarer un objectif de 15 minutes pour un dépôt sur une stratégie.
rdc backup strategy set nightly-hot --repo-rpo mail=15m
# Ou un seul objectif pour chaque dépôt couvert par la stratégie (5m au minimum ; none le supprime).
rdc backup strategy set nightly-hot --rpo 15m
La cible est une fenêtre de perte : le temps écoulé entre la dernière modification qu’une restauration peut récupérer et une panne, durée de l’envoi comprise. Un passage qui se termine après la cible compte comme manqué, même si l’instantané lui-même a réussi. rdc machine health affiche la valeur atteinte à côté de la cible. La définition d’une cible affiche une estimation du coût mensuel d’après la mesure du churn ; un dépôt sans mesure est refusé tant que rdc backup churn <repo> n’a pas été exécuté, ou que --no-estimate n’est pas passé. --dry-run montre le changement sans l’écrire.
Un passage ne demande au stockage que les cellules modifiées depuis l’instantané précédent, plus un échantillon tournant de 16 cellules inchangées que le stockage doit toujours détenir. Une cellule échantillonnée manquante oblige ce passage à tout demander et à renvoyer ce qui a disparu. Un dépôt inchangé enregistre un passage unchanged au lieu d’un nouvel instantané. Chaque passage est borné par une échéance : un passage bloqué est tué et compte comme manqué, au lieu d’arrêter silencieusement le minuteur.
Les dépôts d’une même machine partagent un seul créneau d’exécution, si bien que deux cibles ne lancent jamais deux envois en même temps.
Hook de pré-sauvegarde
Un dépôt peut mettre son application au repos autour du gel. Deux fonctions facultatives de son Rediaccfile s’en chargent.
backup_prepare() { docker exec db psql -c "CHECKPOINT"; }
backup_finish() { :; }
Lors d’un passage à chaud, backup_prepare s’exécute, le système de fichiers est synchronisé et cloné par reflink, puis backup_finish s’exécute toujours ensuite, même après l’échec de prepare. Le hachage et l’envoi ne démarrent qu’après le retour de backup_finish, de sorte que l’application n’est jamais retenue pendant l’envoi. Chaque fonction a un délai de 30 secondes par défaut et de 300 au maximum, et une fonction qui dépasse son délai est tuée avec tout son groupe de processus. Les écritures qu’un hook retient prennent fin au retour de backup_finish. Si renet lui-même est tué, un minuteur armé avant le hook exécute backup_finish dans un délai de deux fois le délai imparti plus 30 secondes. Un instantané passé par le hook est enregistré comme app-quiesced ; sans hook, il est crash-consistent. Un passage à froid n’utilise jamais le hook, puisqu’il arrête lui-même les services.
Remarque de sécurité : le hook est du code du dépôt. Il s’exécute avec un environnement construit, et non celui de l’unité de sauvegarde, de sorte que les identifiants de sauvegarde lui restent invisibles. Docker n’est accessible que par le proxy de politique du dépôt, avec ses restrictions en vigueur. Un hook qui échoue ou dépasse son délai est enregistré avec son résultat (failed, timeout) et signalé, et un finish arrivé à expiration déclenche une alerte immédiate, car l’application peut encore être au repos.
Taille des cellules
L’image est découpée par défaut en cellules de 4 MiB. Un dépôt d’écritures petites et dispersées, comme une boîte de messagerie, envoie bien moins d’octets avec 1 MiB, alors que de grosses écritures groupées ne gagnent rien à une cellule plus petite et ne font que multiplier les requêtes. rdc backup churn recommande une taille d’après le profil d’écriture mesuré, et --repo-cell-size mail=1M l’applique. Changer la taille des cellules réamorce le dépôt : chaque cellule est renvoyée et facturée comme active jusqu’à ce que la rétention supprime l’ancienne chaîne, et les forks restés sur l’ancienne grille cessent de dédupliquer. Un passage planifié ne modifie jamais la grille de lui-même. Une taille qui découperait l’image en plus de 262 144 cellules est refusée, car l’élagage est différé au-delà (256 GiB à 1 MiB).
Destruction différée
rdc backup immutability show
rdc backup immutability set 7
rdc backup undelete <snapshot-id>
Avec une fenêtre de D jours (0 à 30), la suppression d’un instantané, la purge d’un dépôt et un changement de rétention qui conserve moins attendent tous D jours avant de prendre effet, et chacun peut être annulé d’ici là (rdc backup undelete, purge --cancel). Un instantané supprimé reste restaurable pendant son attente. Un changement qui conserve davantage s’applique immédiatement, et le raccourcissement ou la désactivation de la fenêtre elle-même attend l’écoulement de l’ancienne fenêtre. Chacune de ces actions notifie immédiatement le propriétaire et les administrateurs. Les octets disparaissent après la fenêtre et le délai d’attente de 7 jours, soit D + 7 jours après la demande.
Les limites sont énoncées sans détour. Ce mécanisme est appliqué par le serveur du compte, et non par le stockage d’objets : ce n’est pas un stockage WORM et aucun verrou de bucket ou d’objet n’est utilisé. Il ne protège pas contre un propriétaire ou un administrateur qui laisse passer la fenêtre, ni contre la perte du stockage lui-même, puisqu’il n’existe pas de seconde destination. La réparation supprime immédiatement un objet corrompu, car un nouveau hachage prouve qu’il est défectueux, et chaque réparation est journalisée et signalée. La fusion d’une chaîne de manifestes réécrit l’historique sans retirer aucun état restaurable. Un abonnement résilié avec conservation à la résiliation suit son propre balayage de 60 jours.
Stockage actif et en attente
rdc backup usage rapporte deux valeurs. Actif correspond à ce que les instantanés conservés peuvent restaurer, et lui seul est imputé sur le quota de l’offre. En attente désigne le stockage qu’aucun instantané conservé ne référence plus et qui attend un délai de grâce de 7 jours avant suppression ; il n’est pas facturé, et le résumé d’utilisation l’affiche comme en attente de suppression.
Le stockage en attente n’est pas illimité. Le plafond de churn est le double du quota de l’offre. Au-delà, un flux qui a validé il y a moins de 60 minutes se voit refuser un nouvel envoi tant que le stockage en attente n’a pas diminué, la machine enregistre le passage comme throttled, et il compte comme une cible manquée avec le plafond pour raison. Un flux qui s’exécute toutes les heures ou plus lentement n’est jamais refusé.
Alertes de cible manquée
Un flux avec une cible envoie sa propre alerte lorsqu’il dépasse son prochain passage attendu ou qu’il a manqué trois passages de suite, au plus une par flux et par période de 6 heures, sans attendre le résumé quotidien. L’alerte indique la cible, la valeur atteinte et la raison. Le délai de détection est celui du balayage de maintenance, soit une heure, de sorte qu’une alerte peut arriver jusqu’à une heure après le manquement. Une demande destructive soumise à la destruction différée notifie immédiatement.
Sauvegardes planifiées
Rediacc utilise des stratégies de sauvegarde nommées. Chaque stratégie définit un calendrier, un mode de sauvegarde, une limite de bande passante optionnelle, des filtres de dépôts et la rétention des instantanés. Les noms de stratégie sont liés aux machines pour déterminer quelles sauvegardes s’exécutent sur elles.
Modes de sauvegarde
| Mode | Comportement | Temps d’arrêt |
|---|---|---|
hot | Image du dépôt gelée pendant que les services continuent de tourner (cohérent en cas de crash) | Aucun |
cold | Services arrêtés, snapshot pris, services redémarrés, snapshot chargé (cohérent au niveau applicatif) | Fenêtre stop+start par dépôt, parallélisée entre les dépôts. Voir « Estimer le temps d’arrêt d’une sauvegarde froide » ci-dessous. |
Utilisez hot pour les services qui tolèrent les snapshots cohérents en cas de crash. Utilisez cold quand vous avez besoin d’une cohérence garantie et pouvez accepter un bref redémarrage.
Sémantique de la sauvegarde froide
Une sauvegarde froide s’exécute en trois phases par dépôt inclus : arrêt, snapshot, démarrage. Comprendre où finissent les garanties permet de détecter rapidement les défaillances partielles.
Ce que la sauvegarde froide garantit :
- Avant le snapshot, chaque conteneur en cours d’exécution dans chaque dépôt inclus est arrêté gracieusement via le hook
down()du Rediaccfile, et le Docker daemon par dépôt est mis en veille. Le snapshot est donc cohérent au niveau applicatif, et pas seulement cohérent en cas de crash. - L’ensemble des IDs de conteneur qui étaient en cours d’exécution avant le snapshot est persisté dans un fichier sidecar à
/var/run/rediacc/cold-backup-<guid>.running.json. C’est la source de vérité pour « ce qui doit être de nouveau actif une fois terminé ». - Après le snapshot, le hook
up()du Rediaccfile du dépôt est invoqué pour restaurer le stack compose complet. - Un fichier sidecar de statut par exécution à
/var/run/rediacc/cold-backup-<guid>.status.jsonenregistre la phase, le résultat et toute erreur de chaque tentative.
Ce que la sauvegarde froide ne garantit PAS :
up()est au mieux-effort. Il peut échouer pour des raisons hors du contrôle de la sauvegarde froide (une conditiondepends_on: service_healthyencore en attente, une erreur de syntaxe dans le fichier compose, une défaillance réseau transitoire lors du pull d’une image). En cas d’échec, la sauvegarde froide journalise l’erreur au niveau erreur, écrit le sidecar de statut, et passe au dépôt suivant.- Quand
up()échoue, un redémarrage direct de secours se déclenche : le sidecar d’exécution est lu et chaque ID de conteneur enregistré est redémarré directement via l’API Docker (sans compose). Cela remet les services en marche même si le flux compose rencontre un problème, mais sans ré-exécuter les hooks Rediaccfile. - Si même le secours échoue pour certains IDs de conteneur (par exemple, le Docker daemon lui-même est hors service), le sidecar est laissé en place pour que le watchdog du routeur puisse continuer à réessayer à chaque tick.
Récupération par le watchdog : à chaque tick, le watchdog vérifie la présence d’un sidecar d’exécution. Tout ID de conteneur listé là qui est actuellement arrêté est redémarré, indépendamment de la restart_policy sauvegardée du conteneur. Cela signifie que les services avec restart: on-failure (que Docker ne redémarrerait PAS après un arrêt propre) reviennent quand même après une sauvegarde froide. Une fois que tous les conteneurs listés sont en cours d’exécution, le sidecar est supprimé.
Comment les opérateurs détectent les défaillances :
rdc machine status <machine> --containersaffiche l’état d’exécution. Comparez avec l’ensemble attendu./var/run/rediacc/cold-backup-<guid>.status.jsonsur la machine. Inspectez viardc term connect <repo> -c "cat /var/run/rediacc/cold-backup-$GUID.status.json".success: falseavec unstartedAtobsolète signifie que la dernière sauvegarde ne s’est pas terminée proprement.- Les journaux du run de sauvegarde renet (
journalctl -u renet-*ou l’invocation directerdc backup schedule) émettent une ligne de résumé finale de la formeCold backup: post-snapshot restart summary total=N compose_ok=N fallback_ok=N failed=N failed_repos=[...]. Unfailed_reposnon vide est la cible de grep.
Estimer le temps d’arrêt d’une sauvegarde froide
Chaque dépôt n’est arrêté que pendant sa propre fenêtre down() + up(). Sur un hôte déjà en fonctionnement, ces durées sont typiquement :
| Profil du dépôt | Stop+start typique |
|---|---|
| Petit (1-2 conteneurs, sans DB) | 5-15 s |
| Moyen (application web + cache) | 20-45 s |
| Lourd (DB + files + mail) | 60-120 s |
L’étape de gel est un reflink copie-sur-écriture de l’image du dépôt. Elle ne touche que des métadonnées, si bien qu’elle prend le même temps que le dépôt pèse 1 GB ou 100 GB, et sur une exécution mesurée elle n’est même pas apparue à la milliseconde près. Un dépôt n’est pas maintenu arrêté pendant le gel des autres dépôts. L’envoi s’exécute ensuite contre la copie gelée, pendant que chaque dépôt est déjà redémarré.
La durée totale d’exécution est déterminée par le nombre de dépôts qui redémarrent en parallèle. Renet dérive cette valeur de l’hôte :
concurrency = min(repoCount, max(2, NumCPU/2), 8)
Exemples :
| Hôte | Dépôts | Concurrence | Redémarrage wall-clock |
|---|---|---|---|
| VM 4 CPU | 5 dépôts, moyenne 30 s chacun | 2 | ~75 s |
| Serveur 16 CPU | 10 dépôts, moyenne 40 s chacun | 8 | ~80 s |
| Nœud de flotte 64 CPU | 50 dépôts, moyenne 40 s chacun | 8 | ~4 min |
Surcharge via variable d’environnement : définissez REDIACC_COLD_BACKUP_CONCURRENCY=N dans l’environnement du service de sauvegarde (généralement via un drop-in systemd) pour fixer une valeur précise. =1 force des redémarrages strictement séquentiels, utile pour déboguer une boucle de crash dans le hook up() d’un dépôt.
Si vous exploitez un dépôt sensible à la latence (application web publique, mail), son temps d’arrêt est borné par son propre stop+start (typiquement 30-90 s), pas par la durée totale du run. Les dépôts sont planifiés dans les slots de concurrence selon leur ordre de découverte ; il n’existe pas de file de priorité. Donnez aux dépôts lourds leur propre stratégie délimitée par --include si vous avez besoin d’une planification plus fine.
Sauvegardes longues et calendriers qui se chevauchent
Une sauvegarde froide qui dure plus longtemps que son propre intervalle de calendrier (par exemple, un premier seeding d’un dépôt de 500 Go sur un lien modeste peut légitimement nécessiter plus de 24 h, pendant lesquelles le minuteur nocturne se déclenche à nouveau) ne met en file d’attente ni ne lance une seconde exécution. L’unité systemd Type=oneshot est une instance unique : lorsque le minuteur se déclenche et que le service est déjà activating, systemd fusionne le démarrage dans la tâche existante. Aucun nouveau processus ne démarre, aucune exécution n’est mise en file d’attente pour plus tard.
Concrètement, une exécution qui démarre le lundi à 03:00 UTC et se termine le jeudi midi :
| Jour | Déclenchement à 03:00 UTC | Résultat |
|---|---|---|
| Lundi | Premier déclenchement | L’exécution commence |
| Mardi | Deuxième déclenchement | Abandonné silencieusement (l’exécution précédente est toujours active) |
| Mercredi | Troisième déclenchement | Abandonné silencieusement (l’exécution précédente est toujours active) |
| Jeudi | L’exécution se termine à midi | Pas de rattrapage ; la prochaine exécution est le vendredi 03:00 UTC |
La directive Persistent=true du minuteur ne sauve pas ces déclenchements. Persistent=true rejoue les déclenchements qui ont été manqués parce que le minuteur lui-même était inactif (système éteint, minuteur désactivé). Les déclenchements abandonnés parce que le service était occupé sont perdus.
Ce comportement par défaut est délibéré. Exécuter deux sauvegardes froides en parallèle sur le même datastore entrerait en conflit sur le chemin de gel, l’envoi, et les sidecars par dépôt à /var/run/rediacc/cold-backup-<guid>.status.json. Attendre derrière une instance en cours d’exécution vaut mieux que de malmener les mêmes données depuis deux directions. Le verrou du datastore l’impose : une seconde exécution à froid trouve le verrou occupé et est refusée d’emblée, sans avoir rien arrêté.
Implication pour la surveillance. Une sauvegarde bloquée (par exemple, un envoi coincé sur un trou noir réseau) abandonne silencieusement chaque déclenchement de minuteur suivant. Le planificateur n’émet aucune alarme. Surveillez systemctl show <unit> -p ActiveEnterTimestamp : si le service est activating depuis plus longtemps que votre durée d’exécution attendue (par exemple, plus de 48 h sur un minuteur nocturne), investiguez.
Si vous avez besoin que chaque déclenchement planifié s’exécute, passez le minuteur de OnCalendar=<cron> à OnUnitInactiveSec=<intervalle>. Cela déclenche N heures après la fin de l’exécution précédente plutôt que sur un calendrier mural fixe, donc les exécutions longues ne causent pas d’abandons. Elles repoussent simplement l’exécution suivante. Le compromis est la dérive de calendrier : votre nocturne à 03:00 devient « 24 h après la fin du dernier ».
Instantanés, interruptions et espace dans le pool
Chaque push fonctionne à partir d’un instantané momentané du datastore, de sorte que les données chargées sont cohérentes même pendant que les dépôts continuent d’écrire. Pendant l’exécution de la sauvegarde, cet instantané continue de référencer chaque bloc qu’il partage avec les dépôts actifs : les suppressions et les trims libèrent moins d’espace dans le pool jusqu’à la fin du cycle et la suppression de l’instantané. Le rapport de santé du stockage indique l’espace que les instantanés de sauvegarde immobilisent actuellement.
Les interruptions sont sans danger. Arrêter le service (ou redémarrer la machine) provoque l’abandon du transfert et la suppression de l’instantané avant la sortie ; l’exécution planifiée suivante reprend là où elle s’était arrêtée, car les cellules déjà stockées ne sont pas renvoyées. Si le processus est tué trop brutalement pour nettoyer (coupure de courant), l’instantané orphelin est détecté et supprimé automatiquement par le mainteneur de stockage en quelques minutes.
Définir une stratégie
Le défaut canonique est un partage en deux stratégies : un flux hot horaire rapide qui capture chaque dépôt, et un flux cold hebdomadaire plus lent qui met les conteneurs au repos pour des snapshots cohérents au niveau applicatif. Les deux écrivent dans le même stockage fragmenté, et les blocs partagés sont stockés une seule fois plutôt que par flux.
rdc backup strategy set hourly-hot \
--destination hosted \
--cron "0 * * * *" \
--mode hot \
--bwlimit 20M \
--enable
rdc backup strategy set weekly-cold \
--destination hosted \
--cron "15 3 * * 0" \
--mode cold \
--include shop,mail \
--enable
--destination <name> nomme la destination à l’intérieur de la stratégie ; c’est une étiquette choisie par stratégie, et la destination est toujours le stockage fragmenté hébergé par le service. --include prend une liste de dépôts à sauvegarder séparés par des virgules (--include shop,mail). Omettez-le et la stratégie couvre chaque dépôt du datastore. Un nom seul couvre le dépôt et tous ses forks ; name:tag couvre un seul fork. Les noms inconnus sont refusés à l’enregistrement de la stratégie, si bien qu’une faute de frappe ne peut pas planifier une sauvegarde de rien.
--exclude prend la même forme séparée par des virgules et ignore les dépôts nommés. --include et --exclude s’excluent mutuellement : en définir un efface l’autre, et la valeur none efface un filtre.
| Option | Description |
|---|---|
<strategy> (positionnel) | Nom de la stratégie (utilisé pour la liaison à la machine) |
--destination <name> | Nom de destination à l’intérieur de la stratégie. Toujours un stockage fragmenté hébergé par le service |
--cron <expression> | Expression cron (p. ex. "0 2 * * *" pour tous les jours à 2h du matin) |
--mode <hot|cold> | Mode de sauvegarde |
--bwlimit <limit> | Limite de bande passante pour les chargements (p. ex. 10M) |
--read-bwlimit <limit> | Plafond de la vitesse à laquelle les instantanés lisent l’image sur le disque (p. ex. 50M, 0 = illimité). none le supprime |
--include <repos> | Dépôts couverts par cette stratégie (séparés par des virgules) |
--exclude <repos> | Dépôts à ignorer (séparés par des virgules) |
--retention <spec> | Rétention des instantanés, par exemple last=7,daily=7,weekly=4,monthly=6. none la retire |
--enable / --disable | Activer ou désactiver la stratégie |
Afficher les stratégies
rdc backup strategy list
rdc backup strategy show weekly-cold
Supprimer une stratégie
rdc backup strategy remove weekly-cold
Associer des stratégies à une machine
Une stratégie non associée à une machine n’est jamais déployée. Associez-en une ou plusieurs à une machine :
rdc backup strategy bind hourly-hot --machine hostinger
rdc backup strategy bind weekly-cold --machine hostinger
rdc backup strategy unbind weekly-cold --machine hostinger
L’association est enregistrée dans votre configuration comme une liste sur la machine, ce que lit rdc backup schedule pour décider quelles unités déployer :
{
"machines": {
"hostinger": {
"backupStrategies": ["hourly-hot", "weekly-cold"]
}
}
}
La liaison ne concerne que la configuration locale. Définir une stratégie et la lier à une machine n’agit pas sur la machine. Exécutez
rdc backup schedule -m <machine>(voir Déployer le calendrier sur une machine) pour déployer les minuteurs systemd, et relancez-le après tout changement de stratégie ou de liaison.
Choisir entre hot et cold et filtrage par dépôt
Hot vs cold en un coup d’œil
| Hot | Cold | |
|---|---|---|
| Cohérence | Cohérent en cas de crash (image gelée pendant l’exécution) | Cohérent au niveau applicatif (arrêt, snapshot, démarrage) |
| Temps d’arrêt | Aucun | Fenêtre stop+start par dépôt (typiquement 5-120 s) |
| Fréquence adaptée | Élevée (p. ex. horaire) | Faible (p. ex. quotidienne ou hebdomadaire) |
| Usage typique | Filet de sécurité fréquent | Sauvegarde planifiée avec cohérence garantie |
Hot est le bon choix par défaut pour les exécutions à haute fréquence. Les services continuent de fonctionner pendant la prise du snapshot, de sorte qu’il n’y a pas de temps d’arrêt pour vos applications. Le snapshot est cohérent en cas de crash : il équivaut à ce que vous obtiendriez après un arrêt incorrect. Pour la plupart des bases de données modernes et des files de messages, c’est acceptable.
Cold est approprié quand vous avez besoin d’un snapshot applicatif garanti et que vous pouvez accepter un bref redémarrage par dépôt. Les services sont arrêtés avant le snapshot et redémarrés avant le début du chargement, de sorte qu’un chargement lent ou échoué ne prolonge jamais la fenêtre de temps d’arrêt. Consultez Sémantique de la sauvegarde froide pour le modèle de garantie complet.
Les deux modes écrivent dans le même stockage fragmenté, et le mode concerne la façon dont le dépôt est traité pendant que l’image est gelée, pas l’endroit où atterrissent les données. Un dépôt couvert à la fois par un calendrier hot horaire et un calendrier cold hebdomadaire stocke les cellules qu’ils partagent une seule fois plutôt que deux.
Délimiter les dépôts par stratégie
Une stratégie sans --include couvre chaque dépôt du datastore. --include la restreint aux dépôts nommés, séparés par des virgules, comparés au nom de dépôt de la configuration locale.
# Stratégie hot : sauvegarder tout toutes les heures
rdc backup strategy set hourly-hot \
--destination hosted \
--cron "0 * * * *" \
--mode hot \
--bwlimit 6M \
--enable
# Stratégie cold : hebdomadaire, et seulement les dépôts qui ont besoin d'être mis au repos
rdc backup strategy set weekly-cold \
--destination hosted \
--cron "15 3 * * 0" \
--mode cold \
--include shop,mail \
--enable
Quand garder un dépôt hors de la stratégie hot fréquente
Nommez les dépôts que vous voulez dans l’exécution haute fréquence, plutôt que de la laisser tout prendre, quand :
- Un dépôt est volumineux et entièrement régénérable à partir des données sources déjà présentes sur le volume, de sorte que chaque sauvegarde horaire dépense de la bande passante sans apporter de valeur de récupération.
- L’exécution de sauvegarde dépasserait son propre intervalle de calendrier à votre vitesse de chargement disponible.
Exemple. Un dépôt analytics-demo contient environ 114 Go de tables Postgres dérivées pouvant être reconstruites à partir des fichiers CSV bruts stockés dans le même volume. Avec une limite de chargement à 6 Mo/s, un premier instantané de ce dépôt prend plus de 5 heures. En l’exécutant toutes les heures, chaque exécution est encore en cours quand la suivante se déclenche, si bien que chaque déclenchement suivant est abandonné silencieusement (voir Sauvegardes longues et calendriers qui se chevauchent). Lister les autres dépôts dans hourly-hot et laisser analytics-demo à weekly-cold signifie qu’il est sauvegardé une fois par semaine plutôt que jamais.
Si les données sont purement régénérables, envisagez si vous avez vraiment besoin de les sauvegarder. Une alternative est de ne sauvegarder que les entrées sources brutes (les dumps CSV dans cet exemple) et d’ignorer entièrement la copie dérivée. Une sauvegarde froide hebdomadaire des entrées sources est bien plus petite et entièrement suffisante pour la récupération.
Un dépôt que les deux stratégies couvrent obtient des instantanés horaires cohérents en cas de crash et un instantané hebdomadaire cohérent au niveau applicatif. rdc backup manifests <repo> les affiche ensemble, et les cellules qu’ils partagent ne sont stockées qu’une seule fois.
Opérations de sauvegarde
Déployer le calendrier sur une machine
Envoyez les stratégies associées vers une machine en tant que timers systemd :
rdc backup schedule -m server-1
rdc backup schedule -m server-1 --dry-run
Le déploiement est un réconciliateur d’état. Il lit les fichiers d’unité actuels et l’état de systemd sur la machine, les compare à ce que la configuration produirait (SHA-256 par fichier) et ne touche que les unités dont le contenu a réellement changé. Relancer sans changement de configuration est un no-op : pas d’écritures, pas de daemon-reload, pas d’agitation des minuteurs.
--dry-run affiche le plan pour chaque stratégie (created, updated (service, timer, env), unchanged, removed) sans toucher à la machine. Combinez avec --debug pour afficher également les corps d’unités générés, avec les identifiants masqués. Une unité de stockage fragmenté n’en porte de toute façon aucun : la machine s’authentifie avec sa propre licence de dépôt signée, et le serveur renvoie une autorisation de courte durée, si bien que rien de sensible n’est écrit dans le fichier d’unité.
Si une sauvegarde est en cours d’exécution pour une stratégie que vous êtes sur le point de mettre à jour ou de supprimer, le déploiement échoue rapidement avec une indication pour l’annuler ou passer --force. Avec --force, l’invocation en cours conserve son unité en mémoire et la nouvelle configuration s’applique au prochain tick du minuteur, de sorte que la sauvegarde en cours n’est jamais interrompue.
--reset-failed est opt-in. Lorsqu’il est passé, il efface l’état d’échec de systemd sur les services modifiés après un déploiement réussi. Désactivé par défaut pour que les signaux d’échec précédents restent visibles pour les alertes.
Exécuter une sauvegarde maintenant
Déclenchez une sauvegarde immédiatement sans attendre le timer. Fonctionne même sans timers déployés, en utilisant systemd-run pour une exécution ad hoc :
rdc backup run -m server-1
rdc backup run weekly-cold -m server-1
Voir le statut de la sauvegarde
Affiche le statut actuel des timers de sauvegarde et les résultats récents des tâches :
rdc backup status -m server-1
rdc backup status hourly-hot -m server-1
Annuler une sauvegarde en cours
rdc backup cancel -m server-1
rdc backup cancel weekly-cold -m server-1
Migration de dépôt
Déplacer un dépôt d’une machine à une autre :
rdc repo migrate my-app@server-1 --to server-2
| Option | Description |
|---|---|
<ref> (positionnel) | Réf du dépôt à migrer ; son @machine indique la source |
--to <place> | Machine ou cluster cible |
--provision <provider> | Provisionner automatiquement la machine cible via ce fournisseur cloud (p. ex. hetzner, linode) |
--checkpoint | Créer un checkpoint CRIU avant la migration, pour que la mémoire du processus se déplace aussi |
--delta-base <guid> | GUID de base immuable pour le delta de bascule. Par défaut, la base de la première phase |
--strategy <strategy> | Stratégie de delta de blocs pour la bascule : auto, physical ou shared |
--skip-dns | Ignorer la mise à jour des enregistrements DNS après la migration |
--keep-source | Conserver les images source après une migration réussie |
--bwlimit <limit> | Limite de bande passante pour le transfert (p. ex. 50M) |
La migration transfère les données du dépôt chiffré via rsync en deux phases : un transfert en masse pendant que le dépôt continue de tourner, puis un bref arrêt pour le delta. La migration déplace le dépôt, si bien que les images source sont supprimées une fois le déplacement réussi. Passez --keep-source pour les conserver. C’est la différence entre repo migrate et repo push : push laisse la source en fonctionnement et intacte.
Bonnes pratiques
- Planifier des sauvegardes froides quotidiennes pour des copies cohérentes au niveau applicatif des données critiques
- Utiliser les sauvegardes chaudes pour des exécutions haute fréquence où aucune interruption n’est acceptable
- Tester les restaurations périodiquement.
rdc backup restore --as <new-name>n’écrase rien, si bien qu’un exercice est sûr sur une machine en direct - Définir une politique de rétention plutôt que d’élaguer à la main, pour que la fenêtre conservée soit écrite
- Garder une copie de machine à machine en plus des instantanés si vous voulez une copie sur du matériel que vous contrôlez
- Garder les identifiants en sécurité ; les sauvegardes sont chiffrées mais l’identifiant LUKS est nécessaire pour la restauration