> ## Documentation Index
> Fetch the complete documentation index at: https://blog.onetsolutions.net/llms.txt
> Use this file to discover all available pages before exploring further.

# Sauvegarder un VPS Linux avec restic : fichiers et bases

> Sauvegardez fichiers et bases MySQL, MariaDB et PostgreSQL de votre VPS Linux avec restic : chiffré, planifié par systemd, restauration testée. OnetSolutions.

*Publié le 16 novembre 2026*

Sauvegarder un VPS Linux avec restic, c'est garder une copie chiffrée de vos fichiers et de vos bases de données hors du serveur, avec des mois d'historique, et pouvoir en restaurer un seul élément en une commande.

La [sauvegarde automatique du VPS](https://blog.onetsolutions.net/fr/essai-gratuit-sauvegarde-vps.md) copie le disque entier chaque nuit et le restaure d'un bloc depuis la console. restic la complète : il restaure un fichier de configuration, un dossier de site ou une base précise, sur ce serveur ou sur un autre, sans toucher au reste.

Ce guide met en place les deux étages sur Debian, Ubuntu, AlmaLinux et Rocky Linux : sauvegarde des fichiers et des bases, planification, rétention, vérification et test de restauration.

## Sauvegarde VPS, snapshot ou restic ?

| | Sauvegarde du VPS | Snapshot | restic |
| - | - | - | - |
| Ce qui est copié | Le disque entier | L'état du VPS à un instant | Les fichiers et les bases que vous choisissez |
| Déclenchement | Chaque nuit, ou à la demande | À la demande, avant un changement | Votre timer systemd |
| Stockage | Géré par OnetSolutions | Géré par OnetSolutions | Le dépôt S3-compatible ou SFTP de votre choix |
| Restauration | Le VPS entier, depuis la console | Le VPS entier, depuis la console | Un fichier, un dossier ou une base, où vous voulez |
| Historique | Les sauvegardes nocturnes | Le snapshot pris | La politique de rétention que vous fixez |

> [!TIP]
>
> Les trois se complètent : un [snapshot](https://help.onetsolutions.net/fr/vps/snapshot) avant une mise à jour, la [sauvegarde nocturne](https://help.onetsolutions.net/fr/vps/backup) pour remettre le serveur sur pied, restic pour récupérer une donnée précise.

## Installer restic

Versions dans les dépôts officiels, relevées le 16 novembre 2026. La dernière version publiée par le projet est la 0.19.1 (5 juillet 2026).

| Distribution | Paquet | Version | `--stdin-from-command` |
| - | - | - | - |
| Debian 12 (Bookworm) | `restic` | 0.14.0 | Non |
| Debian 13 (Trixie) | `restic` | 0.18.0 | Oui |
| Ubuntu 24.04 LTS | `restic` | 0.16.4 | Non |
| Ubuntu 26.04 LTS | `restic` | 0.18.1 | Oui |
| AlmaLinux 9 et 10, Rocky Linux 9 et 10 | `restic` (EPEL) | 0.19.1 | Oui |

`--stdin-from-command` envoie la sortie d'une commande de dump directement dans le dépôt. Il est arrivé avec restic 0.17.0. Pour les versions antérieures, une variante est donnée plus bas.

```bash theme={null}
# Debian, Ubuntu
sudo apt install restic

# AlmaLinux, Rocky Linux
sudo dnf install epel-release
sudo dnf install restic

restic version
```

## Préparer le dépôt de sauvegarde

Un dépôt restic est chiffré et dédupliqué : seuls les blocs nouveaux sont envoyés à chaque passage. Il doit se trouver hors du VPS.

### Les identifiants dans un seul fichier

restic lit son dépôt et son mot de passe dans des variables d'environnement. Regroupez-les dans un fichier lisible par root seul :

```bash theme={null}
sudo install -d -m 700 /etc/restic

# Mot de passe du dépôt, généré aléatoirement
head -c 32 /dev/urandom | base64 | sudo tee /etc/restic/mot-de-passe >/dev/null
sudo chmod 600 /etc/restic/mot-de-passe
```

> [!WARNING]
>
> Copiez ce mot de passe dans votre gestionnaire de mots de passe, hors du serveur. La documentation restic est claire : sans lui, les données du dépôt sont perdues. Si le VPS disparaît, c'est la seule clé de vos sauvegardes.

### Option 1 : un stockage S3-compatible

```bash theme={null}
sudo tee /etc/restic/env >/dev/null <<'EOF'
RESTIC_REPOSITORY=s3:https://s3.example.com/mon-bucket
RESTIC_PASSWORD_FILE=/etc/restic/mot-de-passe
RESTIC_CACHE_DIR=/var/cache/restic
AWS_ACCESS_KEY_ID=VOTRE_CLE_D_ACCES
AWS_SECRET_ACCESS_KEY=VOTRE_CLE_SECRETE
EOF
sudo chmod 600 /etc/restic/env
```

Si votre fournisseur impose une région, ajoutez `AWS_DEFAULT_REGION=` avec sa valeur.

### Option 2 : un serveur SFTP

restic passe par le client `ssh` du système. La connexion doit se faire par clé, sans mot de passe, sinon le timer ne pourra pas tourner seul :

```bash theme={null}
# Clé dédiée à restic, pour root
sudo ssh-keygen -t ed25519 -f /root/.ssh/restic -N ''
sudo ssh-copy-id -i /root/.ssh/restic.pub sauvegarde@depot.example.com

# Un alias SSH pour le dépôt
sudo tee -a /root/.ssh/config >/dev/null <<'EOF'
Host restic-depot
    HostName depot.example.com
    User sauvegarde
    IdentityFile /root/.ssh/restic
    ServerAliveInterval 60
    ServerAliveCountMax 240
EOF
sudo chmod 600 /root/.ssh/config

# Première connexion : acceptez la clé d'hôte, puis tapez bye
sudo sftp restic-depot
```

Les deux lignes `ServerAlive` viennent de la documentation restic : elles évitent que le serveur coupe la connexion pendant le parcours d'un gros volume de fichiers inchangés.

```bash theme={null}
sudo tee /etc/restic/env >/dev/null <<'EOF'
# Chemin relatif au répertoire personnel de l'utilisateur distant
RESTIC_REPOSITORY=sftp:restic-depot:sauvegardes/mon-vps
RESTIC_PASSWORD_FILE=/etc/restic/mot-de-passe
RESTIC_CACHE_DIR=/var/cache/restic
EOF
sudo chmod 600 /etc/restic/env
```

Pour gérer les clés SSH de votre VPS, voir [Clés SSH](https://help.onetsolutions.net/fr/vps/ssh-keys).

### Initialiser le dépôt

```bash theme={null}
# Ouvre un shell root avec les variables du fichier
sudo -i
set -a; . /etc/restic/env; set +a

restic init
```

**Vérification.** `restic cat config` affiche la configuration du dépôt sans erreur. Gardez ce shell ouvert pour la suite.

## Sauvegarder les fichiers

**Problème.** Le système se réinstalle, pas votre configuration ni vos sites.

**Solution.** Sauvegardez les répertoires qui portent vos données, en écartant les caches :

```bash theme={null}
tee /etc/restic/exclusions >/dev/null <<'EOF'
/var/www/*/cache
/home/*/.cache
*.tmp
EOF

restic backup --tag fichiers \
  --one-file-system \
  --exclude-caches \
  --exclude-file /etc/restic/exclusions \
  /etc /var/www /home /root
```

`--one-file-system` reste sur le système de fichiers de chaque chemin. `--exclude-caches` ignore les répertoires qui contiennent un fichier `CACHEDIR.TAG`. Adaptez la liste des chemins à votre serveur : `/srv`, `/opt`, les volumes Docker.

**Vérification.** `restic snapshots --tag fichiers` liste le snapshot créé.

## Sauvegarder MySQL et MariaDB de façon cohérente

**Problème.** Copier `/var/lib/mysql` pendant que le serveur tourne donne des fichiers incohérents.

**Solution.** Faites un dump logique avec `--single-transaction` : il lit les tables InnoDB dans l'état exact du début de la transaction, sans bloquer les applications. restic stocke la sortie directement, sans fichier intermédiaire sur le disque :

```bash theme={null}
# Un snapshot par base, pour pouvoir en restaurer une seule
for DB in $(mariadb -N -e 'SHOW DATABASES' | grep -Ev '^(information_schema|performance_schema|sys)$'); do
  restic backup --tag mariadb --stdin-filename "mariadb-$DB.sql" \
    --stdin-from-command -- \
    mariadb-dump --single-transaction --quick --routines --events "$DB"
done
```

Avec MySQL, remplacez `mariadb` par `mysql` et `mariadb-dump` par `mysqldump` : les options sont les mêmes. `--routines` et `--events` ajoutent les procédures stockées et les événements planifiés ; les triggers sont inclus par défaut.

En root, la connexion passe par le socket Unix sur Debian et Ubuntu. Si votre serveur demande un mot de passe, placez-le dans `/root/.my.cnf` :

```ini theme={null}
[client]
user=root
password=VOTRE_MOT_DE_PASSE
```

```bash theme={null}
chmod 600 /root/.my.cnf
```

Avec `--stdin-from-command`, restic surveille le code de sortie du dump. Si `mariadb-dump` échoue, la sauvegarde est annulée et aucun snapshot n'est créé.

**Vérification.** `restic snapshots --tag mariadb` affiche une ligne par base, avec le chemin `/mariadb-<base>.sql`.

## Sauvegarder PostgreSQL

**Problème.** Même contrainte : les fichiers de `/var/lib/postgresql` ne se copient pas à chaud.

**Solution.** `pg_dump` produit un export cohérent même pendant que la base est utilisée, sans bloquer lecteurs ni écrivains. Il exporte une base à la fois ; les rôles se sauvegardent à part avec `pg_dumpall --globals-only` :

```bash theme={null}
# Une base par snapshot
for DB in $(runuser -u postgres -- psql -At -c 'SELECT datname FROM pg_database WHERE NOT datistemplate'); do
  restic backup --tag postgresql --stdin-filename "postgresql-$DB.sql" \
    --stdin-from-command -- \
    runuser -u postgres -- pg_dump "$DB"
done

# Rôles et tablespaces
restic backup --tag postgresql --stdin-filename postgresql-globals.sql \
  --stdin-from-command -- \
  runuser -u postgres -- pg_dumpall --globals-only
```

Gardez le format SQL brut, sans compression : restic compresse déjà les données (format de dépôt 2, par défaut depuis restic 0.14.0), et un fichier non compressé se déduplique bien d'une nuit à l'autre.

**Vérification.** `restic snapshots --tag postgresql` affiche une ligne par base, plus `postgresql-globals.sql`.

> [!NOTE]
>
> Sur Debian 12 et Ubuntu 24.04, la version packagée de restic précède `--stdin-from-command`. Écrivez le dump dans un fichier, puis sauvegardez le répertoire :
>
> ```bash theme={null}
> install -d -m 700 /var/backups/dumps
> mariadb-dump --single-transaction --quick --routines --events app > /var/backups/dumps/mariadb-app.sql \
>   && restic backup --tag mariadb /var/backups/dumps
> ```
>
> Évitez `mariadb-dump ... | restic backup --stdin` : la documentation restic le déconseille, car un dump en échec produit quand même un snapshot.

## Planifier la sauvegarde avec un timer systemd

**Problème.** Une sauvegarde lancée à la main finit par ne plus l'être.

**Solution.** Un script regroupe les étapes, un service le lance, un timer le planifie.

```bash theme={null}
tee /usr/local/sbin/restic-sauvegarde >/dev/null <<'EOF'
#!/bin/sh
# Sauvegarde restic : fichiers, MariaDB, PostgreSQL, rétention, vérification.
# Supprimez les blocs des moteurs absents du serveur.
STATUT=0

restic backup --tag fichiers --one-file-system --exclude-caches \
  --exclude-file /etc/restic/exclusions \
  /etc /var/www /home /root || STATUT=1

for DB in $(mariadb -N -e 'SHOW DATABASES' | grep -Ev '^(information_schema|performance_schema|sys)$'); do
  restic backup --tag mariadb --stdin-filename "mariadb-$DB.sql" --stdin-from-command -- \
    mariadb-dump --single-transaction --quick --routines --events "$DB" || STATUT=1
done

for DB in $(runuser -u postgres -- psql -At -c 'SELECT datname FROM pg_database WHERE NOT datistemplate'); do
  restic backup --tag postgresql --stdin-filename "postgresql-$DB.sql" --stdin-from-command -- \
    runuser -u postgres -- pg_dump "$DB" || STATUT=1
done
restic backup --tag postgresql --stdin-filename postgresql-globals.sql --stdin-from-command -- \
  runuser -u postgres -- pg_dumpall --globals-only || STATUT=1

restic forget --prune --keep-daily 7 --keep-weekly 5 --keep-monthly 12 || STATUT=1
restic check --read-data-subset=5% || STATUT=1

exit $STATUT
EOF
chmod 700 /usr/local/sbin/restic-sauvegarde
```

```ini theme={null}
# /etc/systemd/system/restic-sauvegarde.service
[Unit]
Description=Sauvegarde restic des fichiers et des bases
Wants=network-online.target
After=network-online.target

[Service]
Type=oneshot
EnvironmentFile=/etc/restic/env
ExecStart=/usr/local/sbin/restic-sauvegarde
Nice=10
IOSchedulingClass=idle
```

```ini theme={null}
# /etc/systemd/system/restic-sauvegarde.timer
[Unit]
Description=Sauvegarde restic quotidienne

[Timer]
OnCalendar=*-*-* 03:30:00
RandomizedDelaySec=30min
Persistent=true

[Install]
WantedBy=timers.target
```

`Persistent=true` rattrape une exécution manquée si le VPS était éteint à l'heure prévue. `RandomizedDelaySec` étale le départ, utile quand plusieurs serveurs écrivent dans le même stockage.

```bash theme={null}
systemctl daemon-reload
systemctl enable --now restic-sauvegarde.timer

# Premier passage tout de suite, sans attendre la nuit
systemctl start restic-sauvegarde.service
journalctl -u restic-sauvegarde.service -n 50
```

**Vérification.** `systemctl list-timers restic-sauvegarde.timer` donne la prochaine exécution, et `systemctl status restic-sauvegarde.service` affiche `status=0/SUCCESS` après le premier passage.

## Rétention : restic forget --prune

**Problème.** Sans politique de rétention, le dépôt ne fait que grossir.

**Solution.** La ligne `forget` du script garde le dernier snapshot de chacun des 7 derniers jours, des 5 dernières semaines et des 12 derniers mois. restic regroupe les snapshots par hôte et par chemins avant d'appliquer la règle : chaque base garde donc son propre historique. `--prune` libère ensuite l'espace des données qui ne servent plus.

Avant de changer la politique, simulez :

```bash theme={null}
restic forget --dry-run --keep-daily 7 --keep-weekly 5 --keep-monthly 12
```

**Vérification.** `restic snapshots` ne remonte pas au-delà de la politique choisie une fois les premiers mois passés.

## Vérifier le dépôt : restic check

**Problème.** Une sauvegarde jamais vérifiée est une hypothèse.

**Solution.** `restic check` contrôle la structure du dépôt. `--read-data-subset=5%` relit en plus un échantillon aléatoire des données à chaque passage : au fil des nuits, tout le dépôt est relu. Une fois par mois, une relecture complète :

```bash theme={null}
restic check --read-data
```

Sur un stockage S3 facturé au volume téléchargé, `--read-data` télécharge tout le dépôt : un échantillon régulier suffit le reste du temps.

**Vérification.** La sortie se termine par `no errors were found`.

## Tester la restauration

C'est l'étape qui fait d'une copie une sauvegarde. Faites-la à la mise en place, puis régulièrement.

### Restaurer un fichier ou un dossier

```bash theme={null}
# Ce que contient le dernier snapshot de fichiers
restic ls latest --tag fichiers /etc/nginx

# Restaurer un fichier à côté de l'original
restic restore latest --tag fichiers \
  --target /tmp/restauration \
  --include /etc/nginx/nginx.conf

diff /tmp/restauration/etc/nginx/nginx.conf /etc/nginx/nginx.conf
```

Les fichiers sont restaurés sous `--target` avec leur chemin complet. Pour un site entier, remplacez le fichier par son dossier : `--include /var/www/monsite`. Pour une version plus ancienne, prenez l'identifiant donné par `restic snapshots` à la place de `latest`.

### Restaurer une base dans une base de test

```bash theme={null}
# MariaDB : import dans une base temporaire
mariadb -e 'CREATE DATABASE test_restauration'
restic dump --tag mariadb latest /mariadb-app.sql | mariadb test_restauration
mariadb -e 'SHOW TABLES' test_restauration
mariadb -e 'DROP DATABASE test_restauration'

# PostgreSQL : même principe
runuser -u postgres -- createdb test_restauration
restic dump --tag postgresql latest /postgresql-app.sql | runuser -u postgres -- psql -q -d test_restauration
runuser -u postgres -- psql -d test_restauration -c '\dt'
runuser -u postgres -- dropdb test_restauration
```

Le dump est écrit sans `CREATE DATABASE` : il s'importe dans n'importe quelle base vide, sur ce serveur ou sur un autre. Pour remplacer la base de production, importez-le dans la base d'origine après l'avoir vidée.

`restic dump` combine `latest` et `--tag` : il prend le dernier snapshot portant ce tag, puis y lit le fichier indiqué.

### Parcourir les sauvegardes avec restic mount

```bash theme={null}
mkdir -p /mnt/restic
restic mount /mnt/restic
```

Dans un second terminal, `ls /mnt/restic` montre les répertoires `snapshots`, `tags`, `hosts` et `ids`. Copiez ce dont vous avez besoin, puis arrêtez `restic mount` avec Ctrl-C. Le montage passe par FUSE : sur Linux, le module `fuse` doit être chargé et la commande `fusermount` disponible. Pour beaucoup de fichiers, `restic restore` est nettement plus rapide.

**Vérification.** Le fichier restauré est identique à l'original, et la base de test contient les tables attendues.

## Que restaurer, et comment

| Situation | Action |
| - | - |
| Un fichier de configuration modifié par erreur | `restic restore latest --tag fichiers --include <fichier>` |
| Un site supprimé ou écrasé | `restic restore` avec `--include /var/www/<site>`, puis copie en place |
| Une table ou une base corrompue | `restic dump` vers une base de test, vérification, puis import |
| Le VPS ne démarre plus | [Mode rescue](https://blog.onetsolutions.net/fr/mode-rescue-vps-reparer-serveur-qui-ne-demarre-plus.md), ou restauration de la [sauvegarde du VPS](https://help.onetsolutions.net/fr/vps/backup) |
| Le serveur doit être reconstruit ailleurs | Installez restic sur le nouveau serveur, copiez `/etc/restic`, puis `restic restore` |

## Pièges courants

**Le mot de passe du dépôt n'existe que sur le serveur.** Si le VPS est perdu, les sauvegardes le sont aussi. Gardez une copie du mot de passe et de `/etc/restic/env` ailleurs.

**`latest` sans `--tag`.** Le dernier snapshot du dépôt est souvent celui d'une base. Ajoutez toujours `--tag`, ou donnez un identifiant de snapshot.

**Un dump envoyé par un pipe.** `mariadb-dump | restic backup --stdin` crée un snapshot même si le dump échoue. Utilisez `--stdin-from-command`.

**La clé d'hôte SFTP jamais acceptée.** Le timer échoue sur une question à laquelle personne ne répond. Faites la première connexion à la main, en root.

**`forget` sans `--prune`.** Les snapshots disparaissent de la liste, mais l'espace n'est libéré que par `prune`.

**Des tables MyISAM.** `--single-transaction` ne garantit la cohérence que pour InnoDB. Convertissez ces tables ou sauvegardez-les dans une fenêtre calme.

**Un verrou laissé par une exécution interrompue.** `restic unlock` retire les verrous créés par d'autres processus restic. Vérifiez d'abord qu'aucune sauvegarde ne tourne.

## Pour aller plus loin

* [Essai gratuit de la sauvegarde VPS](https://blog.onetsolutions.net/fr/essai-gratuit-sauvegarde-vps.md) : la copie complète du serveur chaque nuit, en un clic
* [Sauvegardes](https://help.onetsolutions.net/fr/vps/backup) et [snapshots](https://help.onetsolutions.net/fr/vps/snapshot) : les deux protections gérées depuis la console
* [Clés SSH](https://help.onetsolutions.net/fr/vps/ssh-keys) : l'authentification par clé, aussi utile pour le dépôt SFTP
* [VPS qui ne démarre plus : le mode rescue](https://blog.onetsolutions.net/fr/mode-rescue-vps-reparer-serveur-qui-ne-demarre-plus.md), pas à pas
* [Disque plein sur un VPS Linux](https://blog.onetsolutions.net/fr/disque-plein-vps-linux-no-space-left-on-device.md) : le cache restic et les dumps prennent aussi de la place
* [Mises à jour de sécurité automatiques](https://blog.onetsolutions.net/fr/mises-a-jour-securite-automatiques-vps-linux.md) : l'autre réglage à faire tourner seul

Une question sur un serveur hébergé chez nous ? [Notre équipe est disponible](https://help.onetsolutions.net/fr/console/support) depuis votre espace client.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.