rsync (Français) - ArchWiki

Jump to content
Toggle the table of contents

# rsync (Français)

6 languages

- Deutsch
- English
- Español
- 日本語
- Русский
- 中文（简体）

From ArchWiki

État de la traduction: Cet article est la version francophone de rsync. Date de la dernière traduction: 2022-10-03. Vous pouvez aider à synchroniser la traduction s'il y a eu des changements dans la version anglaise.

Related articles

- System backup
- Synchronization and backup programs

rsync est un utilitaire open source permettant des transferts de fichiers rapides et incrémentés.

## Installation

Installez le paquet rsync

rsync doit être présent sur les deux machines, source et destination.

### Interfaces

- Grsync — Une interface GTK+.

  https://www.opbyte.it/grsync/ || grsync

- JotaSync — Application graphique en Java Swing avec planificateur intégré.

  https://trixon.se/projects/jotasync/ || jotasyncAUR

- luckyBackup — Interface Qt écrite en C++.

  https://luckybackup.sourceforge.net/index.html || luckybackupAUR

D'autres outils utilisant rsync sont rdiff-backupAUR, osyncAUR et yarsyncAUR.

## Comme alternative à cp/mv

Note: L'utilisation de rsync au lieu de cp/mv est efficace sur différents systèmes de fichiers, mais pas pour copier ou déplacer des fichiers sur le même système de fichiers. Consultez [1]

rsync peut être utilisé comme alternative avancée aux commandes `cp` ou`mv` , particulièrement le transfert de de fichiers volumineux:

    $ rsync -P source destination

L'option `-P`, soit `--partial --progress` garde les fichiers partiellement transférés et affiche une barre de progression.

Pour copier récursivement les sous-répertoires l'option est `-r --recursive` .

Les fichiers peuvent être copiés localement comme avec la commande cp, mais le but essentiel de rsync est la copie à distance, c.a.d.. d'un hôte à un autre. L'emplacement distant sera signifié par la syntaxe deux-points : , ex:

    $ rsync source host:destination

ou

    $ rsync host:source destination

Les transferts par le réseau utilisent le protocole SSH par défaut et `host` peut être un nom réel d'hôte existant ou un profil/alias prédéfini dans `.ssh/config`.

Qu'il s'agisse d'un transfert de fichiers en local ou à distance, Rsync crée d'abord une liste des fichiers avec leurs données (par défaut, taille du fichier et dernier horodatage de modification) qui sera ensuite utilisée pour déterminer si un fichier doit être construit. Pour chaque fichier à construire, une somme de contrôle faible et forte est trouvée pour tous les blocs de sorte que chaque bloc est de longueur S octets, sans chevauchement, et ait un décalage divisible par S. En utilisant cette information, rsync peut construire un fichier de grande taille sans avoir à le transférer en entier. Pour une explication pratique et mathématique détaillée, reportez-vous respectivement au fonctionnement de rsync et à l'algorithme de rsync.

Pour utiliser rapidement des valeurs par défaut sensées, vous pouvez utiliser des alias :

    cpr() {
     rsync --archive -hh --partial --info=stats1 --info=progress2 --modify-window=1 "$@"
    }
    mvr() {
     rsync --archive -hh --partial --info=stats1 --info=progress2 --modify-window=1 --remove-source-files "$@"
    }

- `-hh` : affiche les chiffres dans un format lisible humainement
- `--info=stats1,progress2` : `stats1` affiche les statistiques de transfert rsync avec un niveau de verbosité de 1. `progress2` imprime la progression totale du transfert par opposition à la progression du transfert par fichier (`progress1`).
- `--modify-window=1` : lorsque vous comparez les horodatages de deux fichiers, traitez leurs horodatages comme étant équivalents si leur différence est inférieure à 1 seconde.
- `--remove-source-files` : supprime les fichiers du répertoire source après qu'ils aient été synchronisés avec succès.

Note: L'utilisation du terme checksum n'est pas superposable au comportement de l'option `--checksum`. L'option `--checksum` affecte l'heuristique de saut d'un fichier utilisée avant tout transfert. Indépendamment de `--checksum`, une somme de contrôle est toujours utilisée pour la construction de fichier par blocs qui est la façon dont rynsc transfère un fichier.

### Mise en garde sur la terminaison par slash

Arch Linux utilise par défaut la convention GNU de la commande cp (du paquet coreutils). Tandis que rsync suit la convention BSD de cp, qui accorde un traitement spécial aux répertoires sources avec barre oblique "/" finale (trailing slash). Ainsi la commande:

    $ rsync -r source destination

créera le répertoire "destination/source" avec le contenu de "source", alors que la commande:

    $ rsync -r source/ destination

ne copie que les fichiers de "source/" directement dans "destination", sans créer le sous-répertoire "destination/source" - comme si vous aviez lancé:

    $ rsync -r source/. destination

Ce comportement est différent de celui de GNU/cp, qui traite "source" et "source/" de la même façon (mais non "source/."). De plus certains shells ajoutent automatiquement la barre oblique aux noms des répertoires en cas de complétion par touche <Tab>. En conséquence cette somme de facteurs pourraient amener des utilisateurs nouveaux ou occasionnels de rsync, oubliant ce comportement différent, à désorganiser ou même écraser des répertoires importants par le maintien d'une barre oblique en fin de la <source> dans la commande.

Aussi il peut être prudent d'envelopper la commande par un script enlevant automatiquement cette barre avant le lancement de rsync:

    #!/bin/bash
    new_args=()
    for i in "${@}"; do
        case "${i}" in
            /)
                i="/"
            ;;
            */)
                i="${i%/}"
            ;;
            esac
        new_args+=("${i}")
    done
    exec rsync "${new_args[@]}"

Ce script peut être placé quelque part dans le chemin, et aliasé à rsync dans le fichier de démarrage du shell.

## Comme un utilitaire de sauvegarde

Le protocole rsync est facile à utiliser pour les tâches de sauvegarde, ne transférant que les fichiers modifiés depuis la précédente sauvegarde. Ce paragraphe décrit une sauvegarde programmée très simple avec un script utilisant rsync, typiquement utilisé lors de copies sur un support amovible.

### Sauvegardes automatisées

Pour les besoins de cet exemple, le script est créé dans le répertoire `/etc/cron.daily`, pour se lancer chaque jour si le daemon cron est installé et correctement configuré. Configurer et utiliser cron n'appartient pas à cet article.

D'abord, créer un script avec les options de commande appropriées:

    /etc/cron.daily/backup

    #!/bin/sh
    rsync -a --delete --quiet /path/to/backup /location/of/backup

- `-a` : indique quels fichiers doivent être archivés, entendu que la plupart de leurs attributs soient préservés (mais non les ACLs, liens matériels (hard links), ni attributs étendus tels les capabilités.
- `--delete` : signifie que les fichiers supprimés sur la source doivent également être supprimés sur la sauvegarde.

Ici, `/path/to/backup` sera remplacé par le chemin des données à sauvegarder (`/home`, par exemple) et `/location/of/backup` sera le chemin de destination de la sauvegarde (`/media/disk`, par exemple).

Terminer en rendant le script exécutable

### Sauvegarde automatique avec SSH

Si vous sauvegardez sur un hôte distant en utilisant SSH, utilisez ce script à la place :

    /etc/cron.daily/backup

    #!/bin/bash
    rsync -a --delete --quiet -e ssh /folder/to/backup remoteuser@remotehost:/location/of/backup

- `-e ssh` : indique à rsync d'utiliser SSH
- `remoteuser` : est le nom de l'hôte distant `remotehost`
- `-a` : regroupe les options `-rlptgoD` (recursive, links, perms, times, group, owner, devices)

Note: Rsync essaiera de modifier tous les fichiers précédemment sauvegardés sur la machine cible pour qu'ils correspondent à leur état actuel sur la machine source, à chaque sauvegarde incrémentale. Cela signifie que lors de la sauvegarde de fichiers appartenant à root via SSH (et lors de la préservation des permissions et des propriétaires, comme avec l'option `-a`), un accès root à la machine cible est nécessaire. La meilleure façon d'y parvenir pour l'automatisation est de configurer le daemon SSH pour permettre à root de se connecter à l'aide d'une clé publique sans mot de passe et d'exécuter la commande rsync en tant que root.

### Sauvegarde automatique avec NetworkManager

Ce script démarre une sauvegarde après connexion au réseau.

D'abord, créez un script avec les options de commande appropriées:

    /etc/NetworkManager/dispatcher.d/backup

    #!/bin/bash

    if [ x"$2" = "xup" ] ; then
            rsync --force --ignore-errors -a --delete --bwlimit=2000 --files-from=files.rsync /path/to/backup /location/of/backup
    fi

- `-a` : groupe toutes les options `-rlptgoD` recursive, links, perms, times, group, owner, devices
- `--files-from` : lire le chemin relatif de /path/to/backup à partir de ce fichier
- `--bwlimit` : limite la bande passante E/S; Kilo-octets par seconde

Le script doit appartenir à root (consultez NetworkManager (Français)#Services réseau avec le répartiteur NetworkManager pour plus de détails).

### Sauvegarde automatique avec systemd et inotify

Note:

- Du fait des limitations de systemd et inotify (voir cette question et réponse), la surveillance récursive du système de fichiers n'est pas possible. Bien que vous puissiez surveiller un répertoire et son contenu, il n'effectuera pas de récursion dans les sous-répertoires et ne surveillera pas leur contenu ; vous devez spécifier explicitement chaque répertoire à surveiller, même si ce répertoire est l'enfant d'un répertoire déjà surveillé.
- Cette configuration est basée sur une instance de systemd (Français)/User (Français).

- Au lieu d'exécuter des sauvegardes avec une programmation basée sur des intervalles temporels, comme avec cron, il est possible d'exécuter une sauvegarde à chaque modification d'un des fichiers à sauvegarder.

Les unités de chemin `systemd.path` utilisent `inotify` pour surveiller le système de fichiers, en conjonction avec des fichiers `systemd.service` pour démarrer n'importe quel processus (dans ce cas, votre sauvegarde rsync) basé alors sur un événement dans le système de fichiers.

D'abord, créez l'unité de chemin `systemd.path`, lançant la surveillance des fichiers à sauvegarder:

    ~/.config/systemd/user/backup.path

    [Unit]
    Description=Vérification dans les chemins de changements dans les répertoires à sauvegarder

    [Path]
    PathChanged=%h/documents
    PathChanged=%h/music

    [Install]
    WantedBy=default.target

Puis le service `systemd.service` qui sera activé par toute modification. Par défaut, un fichier de service du même nom que l'unité path (dans ce cas `backup.path`) sera activé, mais avec l'extension `.service` au lieu de `.path` (dans notre cas `backup.service`).

Note: Si vous avez besoin de lancer plusieurs commandes rsync, utilisez `Type=oneshot`. ceci vous permettra de spécifier de multiples paramètres `ExecStart=`, un pour chaque commande rsync, qui sera exécuté. Alternativement, vous pouvez créer un script pour effectuer toutes vos sauvegardes, exactement comme un script cron.

    ~/.config/systemd/user/backup.service

    [Unit]
    Description=Sauvagarde les fichiers

    [Service]
    ExecStart=/usr/bin/rsync %h/./documents %h/./music -CERrltm --delete ubuntu:

Maintenant activez et démarrez simplement `backup.path` comme un service systemd normal et il commencera à surveiller les changements de fichiers et démarrera automatiquement `backup.service`.

### Sauvegarde différentielle sur une semaine

Autre possibilité utile des option de rsync, qui permet d'obtenir une sauvegarde complète (à chaque exécution) et de conserver une copie de sauvegarde différentielle des fichiers modifiés uniquement dans un répertoire distinct pour chaque jour de la semaine.

D'abord, créez un script avec les options de commande appropriées:

    /etc/cron.daily/backup

    #!/bin/bash

    DAY=$(date +%A)

    if [ -e /location/to/backup/incr/$DAY ] ; then
      rm -fr /location/to/backup/incr/$DAY
    fi

    rsync -a --delete --quiet --inplace --backup --backup-dir=/location/to/backup/incr/$DAY /folder/to/backup/ /location/to/backup/full/

L'option `--inplace` implique `--partial` et met à jour les fichiers en place dans le répertoire de destination.

### Sauvegardes par instantanés (Snapshots)

La même démarche peut servir au maintien d'un arbre d'instantanés de vos fichiers. Autrement dit, un répertoire avec des copies des fichiers rangées par date. Ces copies seront faites par utilisation de liens matériels (hard links, attribution d'un seul i-nœud) ce qui signifie que seuls les fichiers modifiés occuperont un espace supplémentaire. D'une manière générale, c'est l'idée qui sous-tend les TimeMachine d'Apple.

Ce script de base est facile à implémenter, il crée des snapshots incrémentaux rapides en utilisant l'option `--link-dest` pour lier des fichiers non modifiés:

    /usr/local/bin/snapbackup.sh

    #!/bin/sh

    # Basic snapshot-style rsync backup script

    # Configurer
    OPT="-aPh"
    LINK="--link-dest=/snapshots/username/last/"
    SRC="/home/username/files/"
    SNAP="/snapshots/username/"
    LAST="/snapshots/username/last"
    date=`date "+%Y-%b-%d:_%T"`

    # Lancement de rsync pour créer un instantanét
    rsync $OPT $LINK $SRC ${SNAP}$date

    # Suppression du lien symbolique vers l'instantané précédent
    rm -f $LAST

    # Création d'un nouveau lien symbolique vers le dernier instantané pour le lien matériel vers la prochaine sauvegarde
    ln -s ${SNAP}$date $LAST

Il doit y avoir un lien symbolique vers une sauvegarde complète déjà existante en tant que cible pour `--link-dest`. En cas d'effacement du plus récent des instantanés il faut recréer un lien symbolique vers le plus récent suivant. Si `--link-dest` ne trouve pas de lien symbolique fonctionnel, rsync devra re-copier la source entière au lieu des seuls fichiers modifiés.

Une version plus sophistiquée conserve une sauvegarde complète à jour `$SNAP/latest` et dans le cas où un certain nombre de fichiers ont été modifiés depuis la dernière sauvegarde complète, elle crée un instantané `$SNAP/$DATETAG` de la sauvegarde complète actuelle en utilisant `cp -al` pour lier les fichiers inchangés :

    /usr/local/bin/rsnapshot.sh

    #!/bin/sh

    ## my own rsync-based snapshot-style backup procedure
    ## (cc) marcio rps AT gmail.com

    # config vars

    SRC="/home/username/files/" #ne PAS oublier la barre oblique finale !
    SNAP="/snapshots/username"
    OPTS="-rltgoi --delay-updates --delete --chmod=a-w"
    MINCHANGES=20

    # lancer le processus avec une priorité vraiment basse

    ionice -c 3 -p $$
    renice +12  -p $$

    # synchronisation

    rsync $OPTS $SRC $SNAP/latest >> $SNAP/rsync.log

    # test d'un nombre suffisant de fichiers modifiés
    # création d'une copie en lien matériel nommée avec la date

    COUNT=$( wc -l $SNAP/rsync.log|cut -d" " -f1 )
    if [ $COUNT -gt $MINCHANGES ] ; then
            DATETAG=$(date +%Y-%m-%d)
            if [ ! -e $SNAP/$DATETAG ] ; then
                    cp -al $SNAP/latest $SNAP/$DATETAG
                    chmod u+w $SNAP/$DATETAG
                    mv $SNAP/rsync.log $SNAP/$DATETAG
                   chmod u-w $SNAP/$DATETAG
             fi
    fi

Pour faire très très simple ce script peut-être lancé depuis une unité systemd/Timers.

### Sauvegarde système complète

Cette section concerne l'utilisation de rsync pour transférer une copie de l'arborescence `/` entière, à l'exception de quelques répertoires sélectionnés. Cette approche est considérée comme meilleure que le clonage de disque avec `dd` car elle permet d'utiliser une taille, une table de partition et un système de fichiers différents, et meilleure que la copie avec `cp -a` également, car elle permet un meilleur contrôle des permissions de fichiers, des attributs, des listes de contrôle des accès (ACL) et des attributs étendus.

rsync fonctionnera même lorsque le système est en cours d'exécution, mais les fichiers modifiés pendant le transfert peuvent ou non être transférés, ce qui peut entraîner un comportement indéfini de certains programmes utilisant les fichiers transférés.

Cette approche fonctionne bien pour migrer une installation existante vers un nouveau disque dur ou SSD.

Exécutez la commande suivante en tant que root pour vous assurer que rsync peut accéder à tous les fichiers système et en préserver la propriété :

    # rsync -aAXv --exclude={"/dev/*","/proc/*","/sys/*","/tmp/*","/run/*","/mnt/*","/media/*","/home/*","/lost+found"} / /path/to/backup/directory

Les options `-aAX`, définissent un transfert en mode archive avec conservation des liens symboliques, des périphériques rattachés, autorisations et propriétés, dates de modification, ACLs et attributs étendus (à condition que le système de fichiers cible prenne en charge ces fonctions. L'option `-H` préserve les liens matériels mais consomme plus de mémoire.

L'option `--exclude` définit les fichiers à exclure, correspondant aux motifs définis. Les répertoires `/dev`, `/proc`, `/sys`, `/tmp`, et `/run` sont inclus dans la commande ci-dessus, mais le contenu de ces répertoires est exclu. Cela est dû au fait qu'ils sont remplis au démarrage, mais que les répertoires eux-mêmes ne sont pas créés. `/lost+found` est spécifique au système de fichiers. La commande ci-dessus dépend de l'expansion des accolades disponible dans les shells bash et zsh. Si vous utilisez un autre shell, les motifs `--exclude` doivent être répétés manuellement. Citer les motifs d'exclusion évitera l'expansion par le shell, ce qui est nécessaire, par exemple, lors de la sauvegarde via SSH. Terminer les chemins exclus par `*` garantit que les répertoires eux-mêmes sont créés s'ils n'existent pas déjà.

Note:

- Si vous prévoyez de sauvegarder votre système ailleurs que dans `/mnt` ou `/media`, n'oubliez pas de l'ajouter à la liste des motifs d'exclusion pour éviter une boucle infinie.
- S'il y a des montages bind dans le système, ils doivent être exclus également afin que le contenu du montage bind ne soit copié qu'une seule fois.
- Si vous utilisez un fichier d'échange, assurez-vous de l'exclure également.
- Réfléchissez si vous voulez sauvegarder le répertoire `/home/`. S'il contient vos données, il peut être considérablement plus grand que le système. Sinon, pensez à exclure les sous-répertoires sans importance tels que `/home/*/.thumbnails/*`, `/home/*/.cache/mozilla/*`, `/home/*/.cache/chromium/*`, et `/home/*/.local/share/Trash/*`, en fonction des logiciels installés sur le système.
- Si GVFS est installé, `/home/*/.gvfs` doit être exclu pour éviter les erreurs de rsync.
- Si Dhcpcd ≥ 9.0.0 est installé, excluez le répertoire `/var/lib/dhcpcd/*` car il y monte plusieurs répertoires système en tant que sous-répertoires.

Vous pouvez inclure des options rsync supplémentaires, ou en supprimer certaines, comme les suivantes. Consultez rsync(1) pour la liste complète.

- Si vous travaillez sur un système avec très peu de mémoire, envisagez de supprimer l'option `-H` ; cependant, cela ne devrait pas poser de problème sur la plupart des machines modernes. Il peut y avoir de nombreux liens durs sur le système de fichiers en fonction du logiciel utilisé (par exemple, si vous utilisez Flatpak). De nombreux liens durs résident dans le répertoire `/usr/`.
- Vous pouvez ajouter l'option `--delete` de rsync si vous l'exécutez plusieurs fois dans le même répertoire de sauvegarde. Dans ce cas, assurez-vous que le chemin d'accès à la source ne se termine pas par `/*`, ou cette option n'aura d'effet que sur les fichiers situés dans les sous-répertoires du répertoire source, mais elle n'aura aucun effet sur les fichiers résidant directement dans le répertoire source.
- Si vous utilisez des fichiers épars, tels que des disques virtuels, des images Docker et autres, vous devez ajouter l'option `-S`.
- L'option `--numeric-ids` désactivera le mappage des noms d'utilisateurs et de groupes ; à la place, les ID numériques des groupes et des utilisateurs seront transférés. Ceci est utile lors de la sauvegarde via SSH ou lors de l'utilisation d'un système actif pour sauvegarder un disque système différent.
- Choisir l'option `--info=progress2` au lieu de `-v` montrera l'information de progression globale et la vitesse de transfert au lieu de la liste des fichiers en cours de transfert.
- Pour éviter de traverser une frontière de système de fichiers lors d'une récursion, ajoutez l'option `-x`/`--one-file-system`. Ceci empêchera la sauvegarde de tout point de montage dans la hiérarchie.

### Restauration de la sauvegarde

Si vous souhaitez restaurer la sauvegarde, utilisez la même commande rsync que précédemment, mais en inversant source et destination.

## Clonage du système de fichiers

rsync fournit le moyen de copier toutes les données d'un système de fichiers en préservant autant d'information que possible, y compris les metadata du système. C'est une procédure de clonage de données au niveau du système de fichiers où les systèmes de fichiers source et destination n'ont pas besoin d'être du même type. Il peut être utilisé pour la sauvegarde, la migration de systèmes de fichiers ou la récupération de données.

Le mode archive de rsync (option -a) est presque adapté à cette tâche, sauf qu'il ne sauvegarde pas les métadonnées spéciales du système de fichiers telles que les listes de contrôle d'accès, les attributs étendus ou les propriétés de fichiers éparses. Pour un clonage réussi au niveau du système de fichiers, certaines options supplémentaires doivent être fournies:

    rsync -qaHAXS SOURCE_DIR DESTINATION_DIR

Ce qui signifie (selon la page de manuel):

    -H, --hard-links      preserve hard links
    -A, --acls            preserve ACLs (implies --perms)
    -X, --xattrs          preserve extended attributes
    -S, --sparse          handle sparse files efficiently

De plus, utilisez `-x` si vous avez d'autres systèmes de fichiers montés sous l'arbre que vous voulez exclure de la copie. La copie produite peut être simplement relue et vérifiée (par exemple après une tentative de récupération de données) au niveau du système de fichiers avec l'option récursive de `diff`:

    diff -r SOURCE_DIR DESTINATION_DIR

Il est possible d'effectuer une migration réussie du système de fichiers en utilisant rsync comme décrit ici puis en mettant à jour les paramètres fstab et chargeur d'amorçage comme décrit dans Migrer une installation vers un nouveau matériel (en). Ceci fournit essentiellement un moyen de convertir n'importe quel système de fichiers racine à un autre.

## Comme un daemon

rsync peut-être lancé en tant que daemon sur un serveur, à l'écoute du port `873`.

Editez le modèle `/etc/rsyncd.conf`, configurez un partage et démarrez le `rsyncd.service`.

Note: A partir de rsync 3.2.0-1, le paquet a adopté les fichiers d'unitées systemd en amont `rsyncd.service` et `rsyncd@.service`. Le changement pour `ProtectHome` a été commenté, la fonction de sécurité `ProtectSystem=full` sous la section `[Service]` est toujours active. Cela rend les répertoires `/boot/`, `/etc/` et `/usr/` en lecture seule. Si vous avez besoin que rsyncd écrive les répertoires système, éditez l'unité et définissez `ProtectSystem=off` dans la section `[Service]` du snippet overriding.

Utilisation depuis le client, par exemple lister le contenu du serveur:

    $ rsync rsync://server/share

transférer le fichier du client au serveur:

    $ rsync local-file rsync://server/share/

Penser à ouvrir le port `873` dans iptables et l'authentification utilisateur.

Note: Toutes les données transférées, y compris l'authentification de l'utilisateur, ne sont pas chiffrées.

### Exemple de configuration

#### Partage à partir d'une liste de fichiers

    /etc/rsyncd.conf

    ...

    # Nécessaire pour traverser les frontières du système de fichiers.
    #use chroot = no
    read only = oui

    ...

    [sync]
        path = /
    # Liste des fichiers à copier.
        include from = /backup.list
    # Exclure le reste.
        exclude = *

Dans la liste de fichiers, tous les chemins intermédiaires sont nécessaires, sauf lorsque le caractère générique `***` est utilisé :

    /backup.list

    /etc/
    /etc/conf.d/
    /etc/conf.d/hwclock
    /etc/fonts/***

## Voir aussi

- D'autres exemples d'utilisation peuvent être trouvées sur la page du projet, dans les Community Contributions, et General Programming forums
- Howto – local and remote snapshot backup using rsync with hard links Inclut la déduplication des fichiers avec des liens matériels, la vérification d'intégrité par somme-MD5 et integrité de signature, protection par 'chattr' , règles de filtrage, quota de disques, politique de rétention avec une distribution exponentielle (rotation des sauvegardes tout en sauvegardant des sauvegardes plus récentes que les anciennes)
- Usage des fichiers/clés d'identification SSH avec rsync
- Fil de discussion du forum international sur les Sauvegardes

Categories:

- Synchronization (Français)
- Backup (Français)
- Commands (Français)