Chapitre 10. Gestion des données

# Chapitre 10. Gestion des données

Des outils et astuces pour gérer les données binaires ou textuelles sur le système sont décrits.

## 10.1. Partager, copier et archiver

| Avertissement
Il ne faut pas accéder de manière non coordonnée en écriture à des périphériques et des fichiers à haut trafic depuis différents processus pour éviter une compétition d’accès (« race condition ». Pour l’éviter, on peut utiliser les mécanismes de verrouillage de fichier (« File locking » en utilisant `flock`(1).

La sécurité des données et leur partage contrôlé présentent plusieurs aspects.

- La création d’une archive des données

- L’accès à un stockage distant

- La duplication

- Le suivi de l’historique des modifications

- La facilité de partage des données

- La prévention de l’accès non autorisé aux données

- La détection des modifications de fichier non autorisées

Cela peut être réalisé avec certaines combinaisons d’outils.

- Outils d’archivage et de compression

- Outils de copie et de synchronisation

- Systèmes de fichiers par le réseau

- Supports d’enregistrement amovibles

- L’interpréteur de commandes sécurisé

- Le système d’authentification

- Outils de système de contrôle de version

- Outils de hachage et de chiffrement

### 10.1.1. Outils d’archivage et de compression

Voici un résumé des outils d’archivage et de compression disponible sur le système Debian :

Tableau 10.1. Liste des outils d’archivage et de compression

paquet | popularité | taille | extension | commande | commentaire
--- | --- | --- | --- | --- | ---
`tar` | V:889, I:999 | 3085 | `.tar` | `tar`(1) | archiveur standard (standard de fait)
`cpio` | V:404, I:998 | 1201 | `.cpio` | `cpio`(1) | archiveur de style UNIX System V, utiliser avec `find`(1)
`binutils` | V:184, I:636 | 1119 | `.ar` | `ar`(1) | archiveur pour la création de bibliothèques statiques
`fastjar` | V:1, I:10 | 183 | `.jar` | `fastjar`(1) | archiveur pour Java (semblable à zip)
`pax` | V:5, I:10 | 167 | `.pax` | `pax`(1) | nouvel archiveur standard POSIX, compromis entre `tar` et `cpio`
`gzip` | V:885, I:999 | 256 | `.gz` | `gzip`(1), `zcat`(1), … | utilitaire de compression GNU LZ77 (standard de fait)
`bzip2` | V:168, I:972 | 114 | `.bz2` | `bzip2`(1), `bzcat`(1), … | utilitaire de transformée par tri de blocs de Burrows-Wheeler permettant un taux de compression plus élevé que `gzip`(1) (plus lent que `gzip` avec une syntaxe similaire)
`lzma` | V:0, I:11 | 349 | `.lzma` | `lzma`(1) | utilitaire de compression LZMA avec un taux de compression supérieur à `gzip`(1) (obsolète)
`xz-utils` | V:309, I:980 | 1475 | `.xz` | `xz`(1), `xzdec`(1), … | utilitaire de compression XZ avec un plus haut taux de compression que `bzip2`(1) (plus lent que `gzip` mais plus rapide que `bzip2` ; le remplaçant de LZMA utilitaire de compression)
`zstd` | V:265, I:777 | 2313 | `.zstd` | `zstd`(1), `zstdcat`(1), … | utilitaire de compression sans perte rapide Zstandard
`p7zip` | V:8, I:237 | 8 | `.7z` | `7zr`(1), `p7zip`(1) | archiveur de fichiers 7-Zip avec un haut taux de compression (compression LZMA)
`p7zip-full` | V:27, I:259 | 12 | `.7z` | `7z`(1), `7za`(1) | archiveur de fichiers 7-Zip avec un haut taux de compression (compression LZMA et autres)
`lzop` | V:12, I:137 | 164 | `.lzo` | `lzop`(1) | utilitaire de compression LZO avec de plus hautes vitesses de compression et de décompression que `gzip`(1) (plus faible taux de compression que `gzip` avec une syntaxe similaire)
`zip` | V:50, I:367 | 627 | `.zip` | `zip`(1) | InfoZIP : outil d’archive et de compression DOS
`unzip` | V:116, I:759 | 387 | `.zip` | `unzip`(1) | InfoZIP : outil de désarchivage et de décompression DOS

| Avertissement
Ne positionnez par la variable « `$TAPE` » à moins que vous ne sachiez à quoi vous attendre. Elle modifie le comportement de `tar`(1).

- L’archive `tar`(1) utilise l’extension de fichier « `.tgz` » ou `« .tar.gz` ».

- L’archive `tar`(1) avec compression xz utilise l’extension de fichier « `.txz` » ou `« .tar.xz` ».

- La méthode de compression habituelle des outils FOSS tels que `tar`(1) a été modifiée de la manière suivante : `gzip` → `bzip2` → `xz`

- `cp`(1), `scp`(1) et `tar`(1) peuvent avoir certaines limitations pour des fichiers spéciaux. `cpio`(1) est plus souple.

- `cpio`(1) est conçu pour être utilisé avec `find`(1) et d’autres commandes et est adapté à la création de scripts de sauvegarde car la partie correspondant à la sélection de fichier du script peut être testée indépendamment.

- La structure interne des fichiers de données de Libreoffice est composée de fichiers « `.jar` » qui peut être ouvert également par `unzip`.

- L'outil d'archivage de facto de la plateforme est `zip`. Utilisez-le sous la forme « `zip -rX` » pour obtenir une compatibilité maximale. Utilisez également l'option « `-s` », si la taille maximale du fichier est importante.

### 10.1.2. Outils de copie et de synchronisation

Voici une liste d’outils simples de copie et de sauvegarde sur le système Debian :

Tableau 10.2. Liste des outils de copie et de synchronisation

paquet | popularité | taille | outil | fonction
--- | --- | --- | --- | ---
`coreutils` | V:892, I:999 | 18457 | GNU cp | copier localement des fichiers et répertoires (« -a » pour récursif)
`openssh-client` | V:898, I:996 | 5133 | scp | copier à distance des fichiers et des répertoires (client, « `-r` » pour récursif)
`openssh-server` | V:745, I:804 | 3502 | sshd | copier à distance des fichiers et des répertoires (serveur distant)
`rsync` | V:200, I:539 | 814 |  | synchronisation et sauvegarde distantes unidirectionnelles
`unison` | V:3, I:13 | 14 |  | synchronisation et sauvegarde distantes bidirectionnelles

Copier des fichiers avec `rsync`(8) offres des fonctionnalités plus riches que les autres méthodes.

- algorithme de transfert delta qui n’envoie que la différence entre les fichiers source et les fichiers existants sur la destination

- algorithme de vérification rapide (par défaut) recherchant les fichiers dont la taille ou l’heure de dernière modification a été modifiée

- Les options « `--exclude` » et « `--exclude-from` » sont semblables à celles de `tar`(1)

- La syntaxe « un slash en fin de répertoire source » qui évite la création d’un niveau de répertoire supplémentaire à la destination.

| Astuce
Les outils de système de contrôle de version (VCS) de Tableau 10.14, « Liste des autres outils de système de gestion de versions » peuvent fonctionner comme outils de synchronisation et de copie multi-voies.

### 10.1.3. Idiomes pour les archives

Voici quelques manières d’archiver et de désarchiver le contenu entier du répertoire « `./source` » en utilisant différents outils.

GNU `tar`(1) :

    $ tar -cvJf archive.tar.xz ./source
    $ tar -xvJf archive.tar.xz

ou encore, comme suit :

    $ find ./source -xdev -print0 | tar -cvJf archive.tar.xz --null -T -

`cpio`(1) :

    $ find ./source -xdev -print0 | cpio -ov --null > archive.cpio; xz archive.cpio
    $ zcat archive.cpio.xz | cpio -i

### 10.1.4. Idiomes pour la copie

Voici quelques manières d’archiver et de désarchiver le contenu entier du répertoire « `./source` » en utilisant différents outils.

- Copie locale du répertoire « `./source` » → répertoire « `/dest` »

- Faire le copie distante du répertoire « `./source` » de la machine locale → répertoire « `/dest` » situé sur la machine « `user@host.dom` »

`rsync`(8) :

    # cd ./source; rsync -aHAXSv . /dest
    # cd ./source; rsync -aHAXSv . user@host.dom:/dest

Vous pouvez, en remplacement, utiliser la syntaxe « un slash en fin du répertoire source ».

    # rsync -aHAXSv ./source/ /dest
    # rsync -aHAXSv ./source/ user@host.dom:/dest

ou encore, comme suit :

    # cd ./source; find . -print0 | rsync -aHAXSv0 --files-from=- . /dest
    # cd ./source; find . -print0 | rsync -aHAXSv0 --files-from=- . user@host.dom:/dest

GNU `cp`(1) et openSSH `scp`(1) :

    # cd ./source; cp -a . /dest
    # cd ./source; scp -pr . user@host.dom:/dest

GNU `tar`(1) :

    # (cd ./source && tar cf - . ) | (cd /dest && tar xvfp - )
    # (cd ./source && tar cf - . ) | ssh user@host.dom '(cd /dest && tar xvfp - )'

`cpio`(1) :

    # cd ./source; find . -print0 | cpio -pvdm --null --sparse /dest

Vous pouvez remplacer « `.` » par « `truc` » dans tous les exemples comportant « `.` » pour copier les fichiers du répertoire « `./source/truc` » vers le répertoire « `/dest/truc` ».

Vous pouvez remplacer « `.` » par le chemin absolu « `/chemin/vers/source/truc` » dans tous les exemples comportant « `.` » pour éviter « `cd ./source;` ». Cela permet de copier les fichiers vers différents emplacements selon les outils utilisés de la manière suivante :

- « `/dest/truc` » : `rsync`(8), GNU `cp`(1) et `scp`(1)

- « `/dest/chemin/vers/source/truc` » : GNU `tar`(1) et `cpio`(1)

| Astuce
`rsync`(8) et GNU `cp`(1) possèdent l’option « `-u` » pour sauter les fichiers qui sont plus récents sur la destination.

### 10.1.5. Idiomes pour la sélection de fichiers

`find`(1) est utilisé pour la sélection de fichiers pour les commandes d’archive et de copie (consultez Section 10.1.3, « Idiomes pour les archives » et Section 10.1.4, « Idiomes pour la copie ») ou pour `xargs`(1) (consultez Section 9.4.9, « Répéter une commande en bouclant entre des fichiers »). Cela peut être amélioré en utilisant ces paramètres de commande.

La syntaxe de base de `find`(1) peut être résumée comme suit :

- Ses paramètres conditionnels sont évalués de gauche à droite.

- L’évaluation s’arrête lors que son résultat est déterminé.

- Le « OU logique » (indiqué par « `-o` » entre les éléments conditionnels) a une plus faible priorité que le « ET logique » (indiqué par « `-a` » ou rien entre éléments conditionnels).

- Le « NON logique » (indiqué par « `!` » avant un élément conditionnel) a une priorité plus élevée que le « ET logique ».

- « `-prune` » retourne toujours un VRAI logique et, si c’est un répertoire, la recherche de fichier est arrêtée au-delà de ce point.

- « `-name` » correspond à la base du nom de fichier avec les motifs génériques de l’interpréteur de commandes (voir Section 1.5.6, « Motifs génériques (« glob ») de l’interpréteur de commandes ») mais il correspond aussi à son « `.` » de début avec des métacaractères comme « `*` » et « `?` » (nouvelle fonctionnalité POSIX).

- « `-regex` » correspond au chemin complet par défaut dans le style BRE Emacs (consultez Section 1.6.2, « Expressions rationnelles »).

- « `-size` » correspond au fichier en se basant sur la taille du fichier (valeur précédée de « `+` » pour plus grand et précédée de « `-` » pour plus petit)

- « `-newer` » correspond au fichier plus récent que celui indiqué comme paramètre.

- « `-print0` » retourne toujours la valeur logique VRAI et affiche sur la sortie standard le nom de fichier en entier (terminé par le caractère null).

`find`(1) est souvent utilisé dans un style idiomatique comme ce qui suit :

    # find /path/to \
        -xdev -regextype posix-extended \
        -type f -regex ".*\.cpio|.*~" -prune -o \
        -type d -regex ".*/\.git" -prune -o \
        -type f -size +99M -prune -o \
        -type f -newer /path/to/timestamp -print0

Cela signifie que les actions suivantes doivent être effectuées :

1. rechercher tous les fichiers en partant de « `/chemin/vers` » ;

2. limiter globalement sa recherche à l’intérieur du système de fichiers et utiliser ERE (consultez Section 1.6.2, « Expressions rationnelles ») ;

3. exclure les fichiers correspondant à l’expression rationnelle de « `.*\.cpio` » ou « `.*~` » de la recherche en arrêtant le traitement ;

4. exclure les répertoires qui correspondent à l’expression rationnelle de « `.*/\.git` » de la recherche en arrêtant le traitement ;

5. exclure les fichiers plus gros que 99 Megaoctets (unités de 1048576 octets) de la recherche en arrêtant le traitement ;

6. Afficher les noms de fichiers qui satisfont aux conditions de recherche ci-dessus et qui sont plus récents que « `/chemin/vers/horodatage` ».

Remarquez l’utilisation idiomatique de « `-prune -o` » pour exclure les fichiers dans l’exemple ci-dessus.

| Note
Pour les systèmes UNIX-like autre que Debian, certaines options peuvent ne pas être prises en compte par `find`(1). Dans un tel cas, essayez d’adapter la méthode de correspondance et remplacez « `-print0` » par « `-print` ». Vous devrez aussi ajuster les commandes associées.

### 10.1.6. Support d’archive

Lors du choix d’un support d’enregistrement de données informatiques destiné à l’archivage de données importantes, il faut faire attention à leurs limitations. Pour des petites sauvegardes de données personnelles, j’utilise des CD-R et des DVD-R provenant d’une grande marque et je les range dans un endroit frais, à l’ombre, sec et propre. (Les supports d’archive sur bande semblent être populaires pour les utilisations professionnelles.)

| Note
Un coffre-fort anti-feu est destiné aux documents sur papier. La plupart des supports de stockage de données informatiques ont une tolérance en température inférieure à celle du papier. J’utilise en général plusieurs copies chiffrées stockées dans différents endroits sûrs.

Durées de vie optimistes des moyens d’archivage trouvées sur le net (la plupart à partir d’informations des constructeurs).

- 100 ans et plus : papier non acide et encre

- 100 ans : stockage optique (CD/DVD, CD/DVD-R)

- 30 ans : supports magnétiques (bande, disquette)

- 20 ans : disque optique à changement de phase (CD-RW)

Cela ne prend pas en compte les défaillances mécaniques dues aux manipulations, etc.

Nombre de cycles d’écriture optimistes des moyens d’archivage trouvées sur le net (la plupart à partir d’informations des constructeurs).

- plus de 250 000 : disque dur

- plus de 10 000 cycles : mémoires Flash

- 1000 cycles : CD/DVD-RW

- 1 cycle : CD/DVD-R, papier

| Attention
Ces chiffres de durée de vie et de nombre de cycles ne devront pas être utilisés pour des décisions concernant l’enregistrement de données critiques. Veuillez consulter les informations spécifiques au produit fournies par le constructeur.

| Astuce
Comme les CD/DVD-R et le papier n’ont qu’un cycle d’écriture de 1, ils évitent de manière inhérente le risque de perte de données par écrasement. C’est un avantage !

| Astuce
Si vous devez faire des sauvegardes fréquentes et rapides d’un gros volume de données, un disque dur sur une liaison réseau à haute vitesse peut être la seule option réaliste.

| Astuce
Si vous utilisez des médias réinscriptibles pour vos sauvegardes, l'utilisation d'un système de fichiers tel que btrfs ou zfs qui prend en charge les instantanés en lecture seule peut être une bonne idée.

### 10.1.7. Périphériques d’enregistrement amovibles

Les périphériques d’enregistrement amovibles possibles sont les suivants.

- Clé USB

- Disque dur

- Graveur de disque optique

- Appareil photographique numérique

- Lecteur de musique numérique

Ils peuvent être connectés à l’aide de n’importe quel moyen suivant.

- USB

- FireWire

- PC-Card

Les environnements de bureau modernes comme GNOME et KDE peuvent monter ces périphériques amovibles automatiquement sans entrée correspondante dans « `/etc/fstab` ».

- Le paquet `udisks2` fournit un démon et les utilitaires associés pour monter et démonter ces périphériques.

- D-bus crée les événements pour initialiser les processus automatiques.

- PolicyKit fournit les droits nécessaires.

| Astuce
Les périphériques montés automatiquement pourraient avoir l’option de montage « `uhelper=` » qui est utilisée par `umount`(8).

| Astuce
Le montage automatique sous les environnements de bureau modernes ne se produit que lorsque ces périphériques amovibles ne se trouvent pas dans « `/etc/fstab` ».

Le nom choisi du point de montage dans les environnements de bureau modernes est « `/media/nom_utilisateur/étiquette_disque` » et il peut être personnalisé avec les outils suivants :

- `mlabel`(1) pour le système de fichiers FAT ;

- `genisoimage`(1) avec l’option « `-V` » pour le système de fichiers ISO9660 ;

- `tune2fs`(1) avec l’option « `-L` » pour le système de fichiers ext2, ext3 ou ext4 ;

| Astuce
Le choix du codage doit être fourni comme option de montage (consultez Section 8.1.3, « Coder les noms de fichiers »).

| Astuce
L'utilisation d'une interface graphique pour démonter un système de fichiers peut supprimer son point de montage créé dynamiquement tel que « `/dev/sdc` ». Si vous souhaitez conserver son point de montage, démontez-le à l'aide de la commande `umount`(8) lancée depuis un interpréteur de commandes.

### 10.1.8. Choix de système de fichiers pour les données partagées

Lors du partage de données avec d’autres systèmes à l’aide de périphériques de stockage amovibles, vous devez les formatez avec un système de fichiers pris en charge par les deux systèmes. Voici une liste de choix de systèmes de fichiers :

| Note
"Hard disk like device" means storage devices such as HDD / SSD / USB flash drive / ... . Their device names have several variants; `/dev/sda`, `/dev/nvme0`, `/dev/mmcblk0`, ... .

Tableau 10.3. Liste de choix de systèmes de fichiers pour des périphériques amovibles avec des scénarios typiques d’utilisation

nom du système de fichiers | scénario d'utilisation typique
--- | ---
FAT12 | partage de données à l’aide de disquettes entre plateformes (<32Mio)
FAT16 | partage de données à l’aide de périphériques semblables à des disques durs de faible capacité (<2Gio) entre plateformes
FAT32 | partage de données à l’aide de périphériques semblables à des disques durs de grande capacité (<8Tio, pris en charge par plus récent que MS Windows95 OSR2) entre plateformes
exFAT | partage de données à l’aide de périphériques semblables à des disques durs de grande capacité (<8Tio, pris en charge par WindowsXP, Mac OS X Snow Leopard 10.6.5 et Linux depuis la version 5.4) entre plateformes
NTFS | partage de données sur périphériques semblables à des disques durs de grande capacité (pris en charge de manière native par MS Windows NT et versions plus récentes, et pris en charge par NTFS-3G à l’aide de FUSE sous Linux) entre plateformes
ISO9660 | partage de données à l’aide d’un CD-R ou DVD+/-R entre plateformes
UDF | écriture incrémentale de CD-R et de DVD+/-R (nouveau)
MINIX | enregistrement efficace en matière d’espace disque de fichiers de données unix sur disquette
ext2 | partage de données sur disque dur avec les anciens systèmes Linux
ext3 | partage de données sur disque dur avec les anciens systèmes Linux
ext4 | partage de données sur disque dur avec les systèmes Linux actuels
btrfs | partage des données sur le disque dur comme le dispositif avec les systèmes Linux actuels avec des instantanés en lecture seule

| Astuce
Consultez Section 9.9.1, « Chiffrement des disques amovibles à l’aide de dm-crypt/LUKS » pour le partage de données entre plateformes en utilisant le chiffrement au niveau du périphérique.

Le système de fichiers FAT est pris en charge par la plupart des systèmes d’exploitation modernes et est assez utile pour l'échange des données par l’intermédiaire de supports du type disque dur amovible.

Pour le formatage de périphériques de type disque dur amovible pour l’échange de données entre plateformes avec un système de fichiers FAT, ce qui suit peut être un choix sûr :

- les partitionner avec `fdisk`(8), `cfdisk`(8) ou `parted`(8) (consultez Section 9.6.2, « Configuration de la partition du disque ») en une seule partition primaire et la marquer comme suit :

  - type « 6 » pour FAT16 pour les supports faisant moins de 2Go.

  - type « c » pour FAT32 (LBA) pour les supports plus gros.

- formater la partition primaire avec `mkfs.vfat`(8) comme suit :

  - simplement son nom de périphérique, par exemple « `/dev/sda1` », pour la FAT16

  - l’option explicite et le nom du périphérique, par exemple « `-F 32 /dev/sda1` », pour la FAT32.

Lors de l’utilisation des systèmes de fichiers FAT ou ISO9660 pour le partage de données ce qui suit sera une précaution sûre :

- Archiver d’abord les fichiers dans un fichier d’archive en utilisant `tar`(1) ou `cpio`(1) afin de conserver les noms de fichiers longs, les permissions de fichiers d’origine d’UNIX et les informations de propriétaire.

- Découper le fichier d’archive en éléments de moins de 2 Gio à l’aide de la commande `split`(1) afin de le protéger contre les limitations de taille de fichier.

- Chiffrer le fichier d’archive afin de sécuriser son contenu contre un accès non autorisé.

| Note
La taille maximale d’un fichier FAT, par conception, est de `(2^32 - 1) octets = (4GiB - 1 octet)`. Pour certaines applications sur le système 32 bits plus ancien, la taille maximale était même plus faible `(2^31 - 1) octets = (2Gio - 1 octet)`. Debian ne souffre pas de ce dernier problème.

| Note
Microsoft lui-même ne recommande pas l’utilisation de FAT pour des disques ou des partitions de plus de 200 Mo. Microsoft met en avant ces limitations comme une utilisation inefficace de l’espace disque dans ses « Informations générales sur les systèmes de fichiers FAT, HPFS et NTFS ». Bien sûr, on peut normalement utiliser le système de fichiers ext4 pour Linux.

| Astuce
Pour davantage d’informations sur les systèmes de fichiers et les accès aux systèmes de fichiers, veuillez consulter « Filesystems HOWTO ».

### 10.1.9. Partage de données au travers du réseau

Lors du partage de données avec d’autres systèmes au travers du réseau, vous devrez utiliser un service commun. Voici quelques éléments :

Tableau 10.4. Liste des services réseau à choisir avec le scénario typique d’utilisation

service réseau | description d’un scénario typique d’utilisation
--- | ---
SMB/CIFS système de fichiers monté avec Samba | partage de fichiers par l’intermédiaire de « Microsoft Windows Network », consultez `smb.conf`(5) et le HOWTO et guide de référence officiel de Samba 3.x.x ou le paquet `samba-doc`
système de fichiers monté au travers du réseau NFS avec le noyau Linux | partager des fichiers par « UNIX/Linux Network », consultez `exports`(5) et Linux NFS-HOWTO
service HTTP | partager des fichiers entre client et serveur web
service HTTPS | partager des fichiers entre le client et le serveur web avec un chiffrement Secure Sockets Layer (SSL) ou Transport Layer Security (TLS)
service FTP | partager des fichiers entre serveur et client FTP

Bien que ces systèmes de fichiers montés au travers du réseau et les méthodes de transfert au travers du réseau soient assez pratiques pour partager des données, elles peuvent être non sûres. Leur connexion réseau doit être sécurisée par ce qui suit :

- chiffrez-la avec SSL/TLS

- tunnelez-la par SSH

- tunnelez-la par VPN

- limitez-la derrière un pare-feu sûr

consultez aussi Section 6.5, « Autres serveurs d’applications réseau » et Section 6.6, « Autres clients d’applications réseau ».

## 10.2. Sauvegarde et restauration

Nous savons tous que les ordinateurs sont parfois victimes de pannes ou que des erreurs humaines provoquent des dommages au système et aux données. Les opérations de sauvegarde et de restauration sont les parties essentielles d’une administration système réussie. Vous serez victime, un jour ou l’autre, de tous les modes de défaillance possibles.

| Astuce
Mettez en place un système de sauvegardes simple et faites une sauvegarde fréquente de votre système. Avoir des données de sauvegarde est plus important que la qualité technique de votre méthode de sauvegarde.

### 10.2.1. Politique de sauvegarde et de restauration

Il y a 3 facteurs-clé qui permettent de définir une méthode pratique de sauvegarde et de restauration.

1. Ce qu’il faut sauvegarder et restaurer :

   - les fichiers que vous avez directement créés : données de « `~/` » ;

   - les fichiers de données créés par les applications que vous utilisez : données de « `/var/` » (sauf « `/var/cache/` », « `/var/run/` » et « `/var/tmp/` ») ;

   - les fichiers de configuration du système : fichiers de « `/etc/` » ;

   - programmes locaux : données dans « `/usr/local/` » ou « `/opt/` » ;

   - informations concernant l’installation du système : un mémo en texte concernant les étapes-clés ((partition, …) ;

   - un jeu de données testé : confirmé par des opérations de restauration expérimentales réalisées à l’avance :

     - tâches cron en tant que processus utilisateur : fichiers dans le répertoire « `/var/spool/cron/crontabs` » et redémarrage de `cron`(8). Consulter la Section 9.4.14, « Planifier des tâches qui s’exécutent régulièrement » pour `cron`(8) et `crontab`(1) ;

     - tâches de Systemd liées au temps en tant que processus utilisateur : fichiers dans le répertoire «`~/.config/systemd/user` ». Consulter `systemd.timer`(5) et `systemd.service`(5) ;

     - tâches de démarrage automatique en tant que processus utilisateur : fichiers dans le répertoire « `~/.config/autostart` ». Consulter Spécifications pour le démarrage automatique des applications de bureau.

2. Comment sauvegarder et restaurer :

   - entreposer les données de manière sûre : protection des données contre la réécriture et les défaillances du système ;

   - sauvegardes fréquentes ! sauvegardes planifiées ;

   - sauvegardes redondantes : duplication (miroir) des données ;

   - processus indéréglable : sauvegarde facile en une seule commande.

3. Risques et coûts :

   - risque de perte de données :

     - les données devraient être au moins sur des partitions différentes de disque, de préférence sur différents disques et machines pour résister à la corruption du système de fichiers. Il est préférable de stocker les données importantes sur un système de fichiers en lecture seule[4].

   - risque de violation des données :

     - Les données d’identité sensibles telles que « `/etc/ssh/ssh_host_*_key` », « `~/.gnupg/*` », « `~/.ssh/*` », « `~/.local/share/keyrings/*` », « `/etc/passwd` », « `/etc/shadow` », « `popularity-contest.conf` », « `/etc/ppp/pap-secrets`», et « `/etc/exim4/passwd.client` » doivent être sauvegardées en étant chiffrées[5]. (Consulter la Section 9.9, « Astuces de chiffrement des données ».)

     - ne jamais coder en dur le mot de passe de connexion au système ou la phrase de passe de décryptage dans un script, même sur un système de confiance. (Consulter la Section 10.3.6, « Trousseau de mots de passe ».)

   - mode de défaillance avec leur probabilité :

     - le matériel (en particulier le disque dur) va casser ;

     - le système de fichiers peut être corrompu et les données qu'il contient peuvent être perdues ;

     - le système de stockage distant n’est pas fiable à cause des failles de sécurité ;

     - une protection par mot de passe faible peut être facilement compromise ;

     - le système de permissions des fichiers peut être compromis.

   - ressources nécessaires pour effectuer les sauvegardes : humaines, matérielles, logicielles, …

     - sauvegarde automatique planifiée avec une tâche cron ou une tâche de minuterie de systemd.

| Astuce
Vous pouvez récupérer les données de configuration de debconf avec « `debconf-set-selections debconf-selections` » et les données de sélection de dpkg avec « `dpkg --set-selection <dpkg-selections.list`".

| Note
Ne sauvegardez pas le contenu des pseudo systèmes de fichiers se trouvant dans `/proc`, `/sys`, `/tmp`, et `/run` (voir Section 1.2.12, « procfs et sysfs » et Section 1.2.13, « tmpfs »). À moins que vous ne sachiez exactement ce que vous faites, ce ne sont que d’énormes quantités de données inutiles.

| Note
Il faudra peut-être arrêter certains démons d’applications comme le MTA (consultez Section 6.2.4, « Agent de transport de courrier électronique (« MTA ») ») lors de la sauvegarde des données.

### 10.2.2. Suites d’utilitaires de sauvegarde

Voici une liste d’utilitaires de sauvegarde notables disponibles sur le système Debian :

Tableau 10.5. Liste de suites d’utilitaires de sauvegarde

paquet | popularité | taille | description
--- | --- | --- | ---
`bacula-common` | V:6, I:7 | 2501 | Bacula : sauvegarde, restauration et vérification par le réseau - fichiers communs
`bacula-client` | V:0, I:2 | 199 | Bacula : sauvegarde, restauration et vérification par le réseau - métapaquet du client
`bacula-console` | V:0, I:2 | 112 | Bacula : sauvegarde, restauration et vérification par le réseau - console en mode texte
`bacula-server` | I:0 | 199 | Bacula : sauvegarde, restauration et vérification par le réseau - métapaquet du serveur
`amanda-common` | V:0, I:2 | 9851 | Amanda : Advanced Maryland Automatic Network Disk Archiver (Libs). (Archiveur de disque par le réseau de Maryland avancé et automatique
`amanda-client` | V:0, I:2 | 1099 | Amanda : Advanced Maryland Automatic Network Disk Archiver (Client)
`amanda-server` | V:0, I:0 | 1093 | Amanda : Advanced Maryland Automatic Network Disk Archiver (Serveur)
`backuppc` | V:1, I:1 | 3088 | BackupPC est un système de hautes performances pour effectuer la sauvegarde de PC au niveau de l’entreprise (basé sur disques)
`duplicity` | V:6, I:50 | 2649 | sauvegarde incrémentale (distante)
`deja-dup` | V:30, I:45 | 5031 | frontal graphique pour duplicity
`borgbackup` | V:12, I:28 | 3478 | sauvegarde sans doublon (distante)
`borgmatic` | V:3, I:4 | 946 | assistant pour borgbackup
`rdiff-backup` | V:2, I:7 | 1207 | sauvegarde incrémentale (distante)
`restic` | V:5, I:10 | 24708 | sauvegarde incrémentale (distante)
`backupninja` | V:2, I:2 | 360 | système de sauvegarde meta-backup léger et extensible
`slbackup` | V:0, I:0 | 147 | sauvegarde incrémentale (distante)
`backup-manager` | V:0, I:0 | 573 | outil de sauvegarde en ligne de commandes
`backup2l` | V:0, I:0 | 110 | outil de sauvegarde et restauration de faible maintenance pour des supports pouvant être montés (basé sur disque)

Les outils de sauvegarde ont chacun des objectifs particuliers.

- Mondo Rescue est un système de sauvegarde qui facilite la restauration rapide d’un système complet depuis de CD/DVD etc. sans passer par le processus normal d’installation d’un système.

- Bacula, Amanda et BackupPC sont des suites de sauvegardes ayant des fonctionnalités avancées qui sont orientées vers les sauvegardes fréquentes au travers du réseau.

- Duplicity et Borg sont des utilitaires très simples de sauvegarde pour les stations de travail typiques.

### 10.2.3. Astuces de sauvegarde

Pour une station de travail personnelle, les utilitaires de suite de sauvegarde remplis de fonctionnalités et conçus pour des environnements de serveur peuvent ne pas être très adaptés. En outre, les utilitaires de sauvegarde pour les stations de travail peuvent avoir quelques défauts.

Voici quelques astuces pour faciliter la sauvegarde avec un minimum d’efforts pour l’utilisateur. Ces techniques peuvent être utilisées avec n’importe quel utilitaire de sauvegarde.

Dans un but de démonstration, supposons que l’utilisateur principal et le groupe soient `penguin` et créons un script d’instantané et de sauvegarde « `/usr/local/bin/bkss.sh` » :

    #!/bin/sh -e
    SRC="$1" # source data path
    DSTFS="$2" # backup destination filesystem path
    DSTSV="$3" # backup destination subvolume name
    DSTSS="${DSTFS}/${DSTSV}-snapshot" # snapshot destination path
    if [ "$(stat -f -c %T "$DSTFS")" != "btrfs" ]; then
      echo "E: $DESTFS needs to be formatted to btrfs" >&2 ; exit 1
    fi
    MSGID=$(notify-send -p "bkup.sh $DSTSV" "in progress ...")
    if [ ! -d "$DSTFS/$DSTSV" ]; then
      btrfs subvolume create "$DSTFS/$DSTSV"
      mkdir -p "$DSTSS"
    fi
    rsync -aHxS --delete --mkpath "${SRC}/" "${DSTFS}/${DSTSV}"
    btrfs subvolume snapshot -r "${DSTFS}/${DSTSV}" ${DSTSS}/$(date -u --iso=min)
    notify-send -r "$MSGID" "bkup.sh $DSTSV" "finished!"

Ici, seul l’outil basique `rsync`(1) est utiliser pour faciliter la sauvegarde du système et l’espace de stockage est utilisé efficacement par Btrfs.

| Astuce
Pour information, l’auteur utilise son propre script similaire d’interpréteur « bss : utilitaire d’instantané de sous-volume » pour sa station de travail.

#### 10.2.3.1. Sauvegarde depuis une interface graphique

Voici un exemple pour configurer une sauvegarde par clic sur une interface graphique.

- Préparez un périphérique de stockage USB pour la sauvegarde :

  - formatez un périphérique de stockage USB avec une seule partition en btrfs avec comme nom « `BKUP` » et qui peut être chiffrée (consulter la Section 9.9.1, « Chiffrement des disques amovibles à l’aide de dm-crypt/LUKS ») ;

  - enfichez le périphérique dans le système. Le système de bureau le montera automatiquement comme « `/media/penguin/BKUP` » ;

  - exécutez « `sudo chown penguin:penguin /media/penguin/BKUP` » pour le rendre éditable par l’utilisateur.

- Créez « `~/.local/share/applications/BKUP.desktop` » en suivant les techniques décrites dans la Section 9.4.10, « Lancer un programme depuis l’interface graphique » contenant :

      [Desktop Entry]
      Name=bkss
      Comment=Backup and snapshot of ~/Documents
      Exec=/usr/local/bin/bkss.sh /home/penguin/Documents /media/penguin/BKUP Documents
      Type=Application

Pour chaque clic d’interface graphique, les données sont sauvegardées de « `~/Documents` » vers le périphérique USB et un instantané en lecture seule est créé.

#### 10.2.3.2. Sauvegarde déclenchée par des évènements de montage

Voici un exemple de configuration pour une sauvegarde automatique déclenchée par un évènement de montage.

- Préparez un périphérique de stockage USB à utiliser pour une sauvegarde comme dans la Section 10.2.3.1, « Sauvegarde depuis une interface graphique ».

- Créez un fichier d’unité de service systemd « `~/.config/systemd/user/back-BKUP.service` » contenant :

      [Unit]
      Description=USB Disk backup
      Requires=media-%u-BKUP.mount
      After=media-%u-BKUP.mount

      [Service]
      ExecStart=/usr/local/bin/bkss.sh %h/Documents /media/%u/BKUP Documents
      StandardOutput=append:%h/.cache/systemd-snap.log
      StandardError=append:%h/.cache/systemd-snap.log

      [Install]
      WantedBy=media-%u-BKUP.mount

- activer cette configuration d’unité de systemd avec :

       $ systemctl --user enable bkup-BKUP.service

Pour chaque évènement de montage, les données sont sauvegardées de « `~/Documents` » vers le périphérique de stockage USB et un instantané en lecture seule est créé.

Ici, les noms d’unité de montage de systemd que celui-ci a actuellement en mémoire peuvent être demandés au gestionnaire de services de l’utilisateur appelant avec « `systemctl --user list-units --type=mount` ».

#### 10.2.3.3. Sauvegarde déclenchée par des évènements d’horloge

Voici un exemple de configuration de sauvegarde automatique déclenchée par un évènement d’horloge.

- Préparez un périphérique de stockage USB à utiliser pour une sauvegarde comme dans la Section 10.2.3.1, « Sauvegarde depuis une interface graphique ».

- Créez un fichier d’unité d’horloge de systemd « `~/.config/systemd/user/snap-Documents.timer` » contenant :

      [Unit]
      Description=Run btrfs subvolume snapshot on timer
      Documentation=man:btrfs(1)

      [Timer]
      OnStartupSec=30
      OnUnitInactiveSec=900

      [Install]
      WantedBy=timers.target

- Créez un fichier d’unité de service de systemd « `~/.config/systemd/user/snap-Documents.service` » contenant :

      [Unit]
      Description=Run btrfs subvolume snapshot
      Documentation=man:btrfs(1)

      [Service]
      Type=oneshot
      Nice=15
      ExecStart=/usr/local/bin/bkss.sh %h/Documents /media/%u/BKUP Documents
      IOSchedulingClass=idle
      CPUSchedulingPolicy=idle
      StandardOutput=append:%h/.cache/systemd-snap.log
      StandardError=append:%h/.cache/systemd-snap.log

- activer cette configuration d’unité de systemd avec :

       $ systemctl --user enable snap-Documents.timer

Pour chaque évènement d’horloge, les données sont sauvegardées de « `~/Documents` » vers le périphérique de stockage USB et un instantané en lecture seule est créé.

Ici, les noms d’unités d’horloge de systemd que celui-ci a en mémoire peuvent être demandés au gestionnaire de services de l’utilisateur appelant avec « `systemctl --user list-units --type=timer` ».

Pour les systèmes de bureau modernes, cette approche de systemd peut offrir un contrôle plus fin que celles traditionnelles d’Unix utilisant `at`(1), `cron`(8) ou `anacron`(8).

## 10.3. Infrastructure de sécurité des données

L’infrastructure de sécurité des données est fournie par la combinaison d’un outil de chiffrement des données, d’un outil de condensé de messages et d’un outil de signature.

Tableau 10.6. Liste des outils d’une infrastructure de sécurité des données

paquet | popularité | taille | commande | description
--- | --- | --- | --- | ---
`gnupg` | V:367, I:872 | 468 | `gpg`(1) | GNU Privacy Guard - outil de signature et de chiffrement OpenPGP
`gpgv` | V:258, I:955 | 559 | `gpgv`(1) | GNU Privacy Guard - outil de vérification de signature OpenPGP
`sq` | V:0, I:17 | 22408 | `sq`(1) | Sequoia-PGP - OpenPGP encryption and outil de signature et de chiffrement OpenPGP
`sqv` | V:324, I:406 | 1813 | `sqv`(1) | Sequoia-PGP - outil de vérification de signature OpenPGP
`paperkey` | V:1, I:13 | 58 | `paperkey`(1) | extraire seulement l’information secrète de clés secrètes OpenPGP
`cryptsetup` | V:30, I:80 | 465 | `cryptsetup`(8), … | utilitaires pour chiffrement de périphérique en mode bloc dm-crypt prenant en charge le chiffrement LUKS
`coreutils` | V:892, I:999 | 18457 | `md5sum`(1) | calculer et vérifier un condensé MD5 de message
`coreutils` | V:892, I:999 | 18457 | `sha1sum`(1) | calculer et vérifier un condensé SHA1 de message
`openssl` | V:834, I:995 | 2503 | `openssl`(1ssl) | calculer un condensé de message avec « `openssl dgst` » (OpenSSL)
`libsecret-tools` | V:0, I:9 | 49 | `secret-tool`(1) | stocker et récupérer les mots de passe (CLI)
`seahorse` | V:81, I:273 | 7971 | `seahorse`(1) | outil de gestion des clés (GNOME)

Consultez la Section 9.9, « Astuces de chiffrement des données » sur dm-crypt et fscrypt qui mettent en œuvre une infrastructure de chiffrement automatique des données à l’aide des modules du noyau Linux.

### 10.3.1. Gestion de clés pour GnuPG

Voici les commandes de GNU Privacy Guard pour la gestion de base des clés :

Tableau 10.7. Liste des commandes de GNU Privacy Guard pour la gestion des clés

commande | description
--- | ---
`gpg --gen-key` | générer une nouvelle clé
`gpg --gen-revoke ID_de_mon_utilisateur` | générer une clé de révocation pour ID_de_mon_utilisateur
`gpg --edit-key ID_utilisateur` | éditer la clé de manière interactive, « help » pour obtenir de l’aide
`gpg -o fichier --export` | export all public keys to file
`gpg -o file --export-secret-keys` | export all private key to file
`gpg --import fichier` | importer toutes les clés depuis fichier
`gpg --send-keys ID_utilisateur` | envoyer la clé de ID_utilisateur vers le serveur de clés
`gpg --recv-keys ID_utilisateur` | recevoir la clé de ID_utilisateur du serveur de clés
`gpg --list-keys ID_utilisateur` | afficher la liste des clés de ID_utilisateur
`gpg --list-sigs ID_utilisateur` | afficher la liste des signatures de ID_utilisateur
`gpg --check-sigs ID_utilisateur` | vérifier la signature de ID_utilisateur
`gpg --fingerprint ID_utilisateur` | vérifier l’empreinte de ID_utilisateur
`gpg --refresh-keys` | mettre à jour le porte-clé local

Voici la signification du code de confiance.

Tableau 10.8. Liste de la signification des codes de confiance

code | description de la confiance
--- | ---
`-` | pas de confiance d’utilisateur assignée/pas encore calculée
`e` | échec du calcul de la confiance
`q` | pas assez d’informations pour le calcul
`n` | ne jamais faire confiance à cette clé
`m` | confiance marginale
`f` | confiance complète
`u` | confiance ultime

The following generates my key "`9563FC29932C409F1A77F9C1AB8A1522D8234C6A`".

    $ gpg --gen-key
    gpg (GnuPG) 2.4.7; Copyright (C) 2024 g10 Code GmbH
    ...
    GnuPG needs to construct a user ID to identify your key.

    Real name: Osamu Aoki
    Email address: osamu@debian.org
    You selected this USER-ID:
        "Osamu Aoki <osamu@debian.org>"

    Change (N)ame, (E)mail, or (O)kay/(Q)uit? o
    ...
    public and secret key created and signed.

    pub   ed25519 2026-02-14 [SC] [expires: 2029-02-13]
          9563FC29932C409F1A77F9C1AB8A1522D8234C6A
    uid                      Osamu Aoki <osamu@debian.org>
    sub   cv25519 2026-02-14 [E] [expires: 2029-02-13]

Ce qui suit permet d’envoyer ma clé « `9563FC29932C409F1A77F9C1AB8A1522D8234C6A` » vers le serveur de clés populaire « `hkp://keys.gnupg.net` » :

    $ gpg --keyserver hkp://keys.gnupg.net --send-keys 9563FC29932C409F1A77F9C1AB8A1522D8234C6A

Une bonne configuration de serveur de clés dans « `~/.gnupg/gpg.conf` » (ou à l’ancien emplacement « `~/.gnupg/options` ») contient ce qui suit :

    keyserver hkp://keys.gnupg.net

Ce qui suit obtient les clés inconnues du serveur de clés :

    $ gpg --list-sigs --with-colons | grep '^sig.*\[User ID not found\]' |\
              cut -d ':' -f 5| sort | uniq | xargs gpg --recv-keys

Il y avait un bogue dans OpenPGP Public Key Server (pre version 0.9.6) qui corrompait les clés ayant plus de 2 sous-clés. Le paquet du serveur `gnupg` (>1.2.1-2) peut gérer ces sous-clés corrompues. Consultez `gpg`(1) sous l’option « `--repair-pks-subkey-bug` ».

Use of SHA-1 for hash has been deprecated. If your old RSA based openPGP key uses SHA-1 for hash, fix it using FixKeyWithSha1.

| Astuce
The `sq`(1) and `sqv`(1) commands are an alternative set of openPGP commands. See sq user documentation and A Practical Introduction to using sq, Sequoia PGP’s CLI.

### 10.3.2. Utilisation de GnuPG sur des fichiers

Voici des exemples d’utilisation des commandes de GNU Privacy Guard sur des fichiers :

Tableau 10.9. Liste des commandes de GNU Privacy Guard sur des fichiers

commande | description
--- | ---
`gpg -a -s fichier` | signer « fichier » dans un fichier ASCII blindé fichier.asc
`gpg --armor --sign fichier` | , ,
`gpg --clearsign fichier` | signer un fichier en clair
`gpg --clearsign fichier|mail truc@example.org` | envoyer un message signé en clair à `truc@example.org`
`gpg --clearsign --not-dash-escaped fichier_rustine` | signer en clair un fichier_rustine
`gpg --verify fichier` | vérifier fichier signé en texte clair
`gpg -o fichier.sig -b fichier` | créer une signature détachée
`gpg -o fichier.sig --detach-sign fichier` | , ,
`gpg --verify fichier.sig fichier` | vérifier un fichier avec fichier.sig
`gpg -o fichier_chiffré.gpg -r nom -e fichier` | chiffrement par clé publique destiné au « nom » depuis le « fichier » vers « fichier_chiffré.gpg » binaire
`gpg -o fichier_chiffré.gpg --recipient nom --encrypt fichier` | , ,
`gpg -o fichier_chiffré.asc -a -r nom -e fichier` | chiffrement par clé publique destiné au « nom » depuis le « fichier » vers le fichier ASCII blindé « fichier_chiffré.asc »
`gpg -o fichier_chiffré.gpg -c fichier` | chiffrement symétrique depuis « fichier » vers « fichier_chiffré.gpg »
`gpg -o fichier_chiffré.gpg --symmetric fichier` | , ,
`gpg -o fichier_chiffré.asc -a -c fichier` | chiffrement symétrique prévu destiné au « nom » depuis le « fichier » vers le fichier ASCII blindé « fichier_chiffré.asc »
`gpg -o fichier -d fichier_crypt.gpg -r nom` | déchiffrement
`gpg -o fichier --decrypt fichier_chiffré.gpg` | , ,

### 10.3.3. Utiliser GnuPG avec Mutt

Ajoutez ce qui suit à « `~/.muttrc` » afin d’éviter que GnuPG qui est lent ne démarre automatiquement, tout en permettant son utilisation en entrant « `S` » depuis l’index du menu :

    macro index S ":toggle pgp_verify_sig\n"
    set pgp_verify_sig=no

### 10.3.4. Utiliser GnuPG avec Vim

Le greffon `gnupg` vous permet de lancer GnuPG de manière transparente pour les fichiers ayant l’extension « `.gpg` », « `.asc` » et « `.pgp` ».[6]

    $ sudo aptitude install vim-scripts
    $ echo "packadd! gnupg" >> ~/.vim/vimrc

### 10.3.5. La somme de contrôle MD5

`md5sum`(1) fournit un utilitaire permettant de créer un fichier de résumé en utilisant la méthode se trouvant dans rfc1321 et en l’utilisant pour vérifier chaque fichier qu’il contient.

    $ md5sum foo bar >baz.md5
    $ cat baz.md5
    d3b07384d113edec49eaa6238ad5ff00  foo
    c157a79031e1c40f85931829bc5fc552  bar
    $ md5sum -c baz.md5
    foo: OK
    bar: OK

| Note
Le calcule de somme de contrôle MD5 consomme moins de ressources processeur que celles utilisées pour le chiffrement des signatures en utilisant GNU Privacy Guard (GnuPG). Habituellement, pour s’assurer de l’intégrité des données, seul le résumé de plus haut niveau est signé par chiffrement.

### 10.3.6. Trousseau de mots de passe

Sur le système GNOME, l'outil graphique `seahorse`(1) gère les mots de passe et les stocke de manière sécurisée dans le trousseau `~/.local/share/keyrings/*`.

`secret-tool`(1) peut stocker le mot de passe du trousseau de clés à partir de la ligne de commande.

Stockons la phrase secrète utilisée pour l’image disque cryptée LUKS/dm-crypt :

    $ secret-tool store --label='LUKS passphrase for disk.img' LUKS my_disk.img
    Password: ********

Ce mot de passe stocké peut être récupéré et transmis à d’autres programmes, par exemple, `cryptsetup`(8) :

    $ secret-tool lookup LUKS my_disk.img | \
      cryptsetup open disk.img disk_img --type luks --keyring -
    $ sudo mount /dev/mapper/disk_img /mnt

| Astuce
Chaque fois que vous devez fournir un mot de passe dans un script, utilisez `secret-tool` et évitez de coder directement en dur la phrase secrète qu’il contient.

## 10.4. Outils pour fusionner le code source

Il existe de nombreux outils pour fusionner du code source. Les commandes qui suivent ont attiré mon attention :

Tableau 10.10. Liste d’outils destinés à fusionner du code source

paquet | popularité | taille | commande | description
--- | --- | --- | --- | ---
`patch` | V:97, I:712 | 242 | `patch`(1) | appliquer un fichier de différences (« diff ») à un original
`vim` | V:86, I:346 | 4089 | `vimdiff`(1) | comparer deux fichiers côte à côte dans vim
`imediff` | V:0, I:0 | 348 | `imediff`(1) | outil interactif plein écran pour fusionner 2 ou 3 fichiers
`meld` | V:5, I:25 | 3546 | `meld`(1) | comparer et fusionner des fichiers (GTK)
`wiggle` | V:0, I:0 | 175 | `wiggle`(1) | appliquer les rustines rejetées
`diffutils` | V:875, I:998 | 1768 | `diff`(1) | comparer des fichiers ligne à ligne
`diffutils` | V:875, I:998 | 1768 | `diff3`(1) | comparer et fusionner trois fichiers ligne par ligne
`quilt` | V:1, I:18 | 880 | `quilt`(1) | gérer une série de rustines
`wdiff` | V:6, I:42 | 651 | `wdiff`(1) | afficher les différences de mots entre deux fichiers texte
`diffstat` | V:10, I:104 | 79 | `diffstat`(1) | afficher un histogramme des modifications apportées par le fichier de différences
`patchutils` | V:13, I:103 | 242 | `combinediff`(1) | créer une rustine (patch) cumulative à partir de deux rustines incrémentales
`patchutils` | V:13, I:103 | 242 | `dehtmldiff`(1) | extraire un fichier de différences d’une page HTML
`patchutils` | V:13, I:103 | 242 | `filterdiff`(1) | extraire ou exclure des différences d’un fichier de différences
`patchutils` | V:13, I:103 | 242 | `fixcvsdiff`(1) | corriger les fichiers de différences créés par CVS que `patch`(1) interprète mal
`patchutils` | V:13, I:103 | 242 | `flipdiff`(1) | échanger l’ordre de deux rustines
`patchutils` | V:13, I:103 | 242 | `grepdiff`(1) | afficher quels sont les fichiers modifiés par une rustine correspondant un une expression rationnelle
`patchutils` | V:13, I:103 | 242 | `interdiff`(1) | afficher les différences entre deux fichiers de différence unifiés
`patchutils` | V:13, I:103 | 242 | `lsdiff`(1) | afficher quels sont les fichiers modifiés par une rustine
`patchutils` | V:13, I:103 | 242 | `recountdiff`(1) | recalculer les nombres et les décalages dans un contexte unifié de fichiers de différences
`patchutils` | V:13, I:103 | 242 | `rediff`(1) | corriger les décalages et les nombres d’un fichier de différences édité manuellement
`patchutils` | V:13, I:103 | 242 | `splitdiff`(1) | séparer les rustines incrémentales
`patchutils` | V:13, I:103 | 242 | `unwrapdiff`(1) | réparer les correctifs dont les mots ont été coupés
`dirdiff` | V:0, I:1 | 167 | `dirdiff`(1) | afficher les différences et fusionner les modifications entre deux arbres de répertoires
`docdiff` | V:0, I:0 | 554 | `docdiff`(1) | comparer deux fichiers mot par mot ou caractère par caractère
`makepatch` | V:0, I:0 | 99 | `makepatch`(1) | créer des fichiers de rustines étendus
`makepatch` | V:0, I:0 | 99 | `applypatch`(1) | appliquer des fichiers de rustines étendus

### 10.4.1. Extraire des différences pour des fichiers sources

La procédure suivante vous permet d'extraire les différences entre deux fichiers sources et créer un fichier de différences unifié « `fichier.patch0` » ou « `fichier.patch1` » selon l’emplacement du fichier.

    $ diff -u file.old file.new > file.patch0
    $ diff -u old/file new/file > file.patch1

### 10.4.2. Fusionner les mises à jour des fichiers source

Le fichier de différences (« diff » (encore appelé fichier « patch » ou rustine) est utilisé pour envoyer une mise à jour de programme. Celui qui reçoit applique cette mise à jour à un autre fichier de la manière suivante :

    $ patch -p0 file < file.patch0
    $ patch -p1 file < file.patch1

### 10.4.3. Fusion interactive

Si vous avez deux versions d'un code source, vous pouvez effectuer une fusion des deux de manière interactive en utilisant `imediff`(1) de la manière suivante :

    $ imediff -o file.merged file.old file.new

Si vous avez trois versions d'un code source, vous pouvez effectuer une fusion des trois de manière interactive en utilisant `imediff`(1) de la manière suivante :

    $ imediff -o file.merged file.yours file.base file.theirs

## 10.5. Git

Git est l'outil de prédilection de nos jours pour un système de gestion de versions (VCS) car Git peut tout faire pour la gestion à la fois du code source local et celui distant.

Debian fournit des services Git gratuits avec le service Salsa de Debian. Sa documentation se trouve sur https://wiki.debian.org/Salsa.

Voici quelques paquets relatifs à Git.

Tableau 10.11. Liste des paquets et des commandes relatifs à git

paquet | popularité | taille | commande | description
--- | --- | --- | --- | ---
`git` | V:382, I:597 | 50172 | `git`(7) | Git, système de contrôle de version rapide, évolutif et distribué
`gitk` | V:4, I:29 | 2003 | `gitk`(1) | Interface graphique de navigateur de dépôt Git avec historique
`git-gui` | V:1, I:18 | 2508 | `git-gui`(1) | Interface graphique pour Git (pas d’historique)
`git-email` | V:0, I:10 | 1187 | `git-send-email`(1) | envoyer une série de rustines sous forme de courriel à partir de Git
`git-buildpackage` | V:1, I:7 | 2030 | `git-buildpackage`(1) | automatise la mise en paquet Debian avec Git
`dgit` | V:0, I:1 | 724 | `dgit`(1) | interopérabilité de git avec l'archive Debian
`imediff` | V:0, I:0 | 348 | `git-ime`(1) | outil interactif d'aide pour des commits séparés de git
`stgit` | V:0, I:0 | 604 | `stg`(1) | quilt par-dessus git (Python)
`git-doc` | I:11 | 14238 | N/A | Documentation officielle de git
`gitmagic` | I:0 | 721 | N/A | « Git Magic », le guide le plus facile à comprendre pour Git

### 10.5.1. Configuration du client Git

Vous pourrez définir certains éléments de configuration globaux, comme votre nom et votre adresse de courriel utilisée par Git, dans « `~/.gitconfig` » de la manière suivante :

    $ git config --global user.name "Name Surname"
    $ git config --global user.email yourname@example.com

Vous pouvez également personnaliser le comportement par défaut de Git de la manière suivante :

    $ git config --global init.defaultBranch main
    $ git config --global pull.rebase true
    $ git config --global push.default current

Si vous avez l’habitude d’utiliser les commandes de CVS ou de Subversion, vous pourrez définir certains alias de commandes comme suit :

    $ git config --global alias.ci "commit -a"
    $ git config --global alias.co checkout

Vous pouvez vérifier votre configuration globale de la manière suivante :

    $ git config --global --list

### 10.5.2. Commandes de base pour Git

L’opération Git implique plusieurs données.

- L’arborescence de travail qui contient les fichiers concernant l’utilisateur et auxquels vous apportez des modifications.

  - Les changements à enregistrer doivent être explicitement sélectionnés et ajoutés dans un index. Il s'agit des commandes `git add` et `git rm`.

- L'index qui contient les fichiers ajoutés.

  - Les fichiers ajoutés seront validés dans le référentiel local lors de la demande suivante. Il s'agit de la commande `git commit`.

- Le dépôt local qui détient des fichiers validés.

  - Git enregistre l’historique lié aux données validées et organise celles-ci en branches dans le dépôt.

  - Le dépôt local peut envoyer des données au dépôt distant avec la commande `git push`.

  - Le dépôt local peut recevoir des données du dépôt distant avec les commandes `git fetch` et `git pull`.

    - La commande `git pull` effectue `git merge` ou `git rebase` après la commande `git fetch`.

    - Ici, `git merge` combine finalement deux branches distinctes de l'historique à un certain moment. (C'est par défaut `git pull` sans personnalisation et cela peut être valable pour les personnes en amont qui publient la branche vers de nombreuses personnes.)

    - Ici, `git rebase` crée une seule branche de l'historique séquentiel de la branche distante, suivie par la branche locale. (C'est le cas de la personnalisation`pull.rebase true` et cela peut être valable pour nous autres.)

- Le dépôt distant qui contient des fichiers validés.

  - La communication vers le dépôt distant utilise des protocoles de communication sécurisés tels que SSH ou HTTPS.

L’arborescence de travail est constituée de fichiers situés en dehors du répertoire `.git/`. Les fichiers contenus dans le répertoire `.git/` contiennent l’index, les données du dépôt local et certains fichiers texte de configuration git.

Voici un aperçu des principales commandes Git.

Tableau 10.12. Principales commandes de Git

commande de Git | fonction
--- | ---
`git init` | créer le dépôt (local)
`git clone URL` | cloner le dépôt distant vers un dépôt local avec l'arborescence de travail
`git pull origin main` | mettre à jour la branche locale `main` avec le dépôt distant `origin`
`git add .` | ajouter le(s) fichier(s) de l'arbre de travail à l'index pour les fichiers préexistants dans l'index seulement
`git add -A .` | ajouter le(s) fichier(s) dans l'arbre de travail à l'index pour tous les fichiers, y compris les suppressions
`git rm fichier` | supprimer des fichiers de l’arborescence de travail et de l’index
`git commit` | valider les modifications préparées dans l'index dans le dépôt
`git commit -a` | ajouter toutes les modifications de l'arbre de travail à l'index et les valider dans le référentiel local (add + commit)
`git push -u origin branche` | mettre à jour le dépôt distant `origine` avec la `branche` locale (invocation initiale)
`git push origine branche` | mettre à jour le dépôt distant `origine` avec la `branche` locale (invocation ultérieure)
`git diff arbre1 arbre2` | afficher la différence entre le commit arbre1 et arbre2
`gitk` | affichage graphique de l'arbre des historiques de branche du dépôt VCS

### 10.5.3. Conseils pour Git

Voici quelques conseils pour Git.

Tableau 10.13. Conseils pour Git

ligne de commande de Git | fonction
--- | ---
`gitk --all` | voir l'historique complet de Git et agir dessus, par exemple en réinitialisant HEAD à un autre commit, en choisissant librement des correctifs, en créant des étiquettes et des branches...
`git stash` | revenir à un arbre de travail propre sans perdre de données
`git remote -v` | vérifier les paramètres pour le dépôt distant
`git branch -vv` | vérifier les paramètres de la branche de dépôt
`git status` | afficher l'état de l'arborescence de travail
`git config -l` | lister les paramètres de git
`git reset --hard HEAD; git clean -x -d -f` | revenir sur toutes les modifications de l'arbre de travail et les nettoyer complètement
`git rm --cached nom_fichier` | annuler l’ajout dans l’index intermédiaire modifié par `git add filename`
`git reflog` | obtenir le journal de référence (utile pour récupérer les commits de la branche supprimée)
`git branch nom_nouvelle_branche HEAD@{6}` | créer une nouvelle branche à partir des informations de reflog
`git remote add nouveau_distant URL` | ajouter un dépôt distant `nouveau_distant` pointé par URL
`git remote rename origin upstream` | renommer le nom du dépôt distant de `origine` à `amont`
`git branch -u upstream/branch_name` | définir le suivi à distance du dépôt distant `amont` et son nom de branche `nom_branche`.
`git remote set-url origine https://toto/titi.git` | changer l’URL de `origine`
`git remote set-url --push upstream DISABLED` | désactiver push vers `amont` (Éditer `.git/config` pour le réactiver)
`git remote update upstream` | récupérer les mises à jour de toutes les branches distantes du dépôt `upstream`
`git fetch upstream foo:upstream-foo` | créer une branche locale (éventuellement orpheline) `upstream-foo` en tant que copie de la branche `foo` du dépôt `upstream`
`git checkout -b topic_branch ; git push -u topic_branch origin` | créer une nouvelle branche `branche_sujet` et l’incorporer dans `origine`
`git branch -m ancien_nom nouveau_nom` | renommer le nom de la branche locale
`git push -d origine branche_à_supprimer` | supprimer la branche distante (nouvelle méthode)
`git push origine :branche_à_supprimer` | supprimer la branche distante (ancienne méthode)
`git checkout --orphan non_connectée` | créer une nouvelle branche `sans lien`
`git rebase -i origine/main` | réorganiser/abandonner/écraser les validations de `origine/main` pour nettoyer l’historique des branches
`git reset HEAD^ ; git commit --amend` | compresser les deux derniers commits en un seul
`git checkout topic_branch ; git merge --squash topic_branch` | agglomérer l'ensemble de `branche_sujet` dans un commit
`git fetch --unshallow --update-head-ok origine '+refs/heads/*:refs/heads/*'` | convertir un clone superficiel en un clone complet de toutes les branches
`git ime` | diviser le dernier commit en une série de commits plus petits, fichier par fichier, etc. (paquet `imediff` requis)
`git repack -a -d; git prune` | reconditionner le dépôt local en un seul paquet (cela peut limiter les possibilités de récupération de données perdues à partir d’une branche effacée, etc.)

| Avertissement
Ne pas utiliser d'espaces dans la chaîne de balise même si certains outils comme `gitk`(1) vous permettent de le faire. Cela peut perturber d'autres commandes de `git`.

| Attention
Si une branche locale qui a été intégrée dans un dépôt distant est rebasée ou compressée, pousser cette branche comporte des risques et nécessite l'option `--force`. Cela n'est généralement pas acceptable pour la branche `main` mais peut l'être pour une branche_sujet avant de fusionner avec la branche `main` .

| Attention
L’appel d’une sous-commande `git` directement avec « `git-xyz` » depuis la ligne de commandes est devenu obsolète depuis début 2006.

| Astuce
S'il existe un fichier exécutable « `git-toto` » dans le chemin spécifié par « `$PATH` » alors entrer la commande « `git toto` » sans trait d’union dans la ligne de commande appellera ce « `git-toto` ». C'est une fonctionnalité de la commande « `git` ».

### 10.5.4. Références de Git

Consultez ce qui suit.

- page de manuel : git(1) (`/usr/share/doc/git-doc/git.html`)

- Manuel de l’utilisateur de Git (`/usr/share/doc/git-doc/user-manual.html`)

- Un tutoriel d’introduction à git « A tutorial introduction to git » (`/usr/share/doc/git-doc/gittutorial.html`)

- Un tutoriel d’introduction à git : deuxième partie (`/usr/share/doc/git-doc/gittutorial-2.html`)

- Utilisation de tous les jours de GIT en 20 commandes (`/usr/share/doc/git-doc/giteveryday.html`)

- La magie de Git « Git Magic » (`/usr/share/doc/gitmagic/html/index.html`)

### 10.5.5. Autres systèmes de gestion de versions

Les systèmes de gestion de versions (VCS) sont parfois appelés système de gestion de révisions (RCS) ou gestion de configuration logicielle (SCM).

Voici un récapitulatif des autres VCS notables pour le système Debian.

Tableau 10.14. Liste des autres outils de système de gestion de versions

paquet | popularité | taille | outil | type du VCS | commentaire
--- | --- | --- | --- | --- | ---
`mercurial` | V:3, I:26 | 2579 | Mercurial | distribué | DVCS en Python avec un peu de C
`darcs` | V:0, I:3 | 38784 | Darcs | distribué | DVCS avec une algèbre intelligente des rustines (lent)
`bzr` | I:4 | 28 | GNU Bazaar | distribué | DVCS influencé par `tla` écrit en Python (historique)
`tla` | V:0, I:0 | 1022 | GNU arch | distribué | DVCS principalement par Tom Lord (historique)
`subversion` | V:10, I:59 | 4849 | Subversion | distant | « CVS en mieux », remplaçant standard du VCS (historique) distant
`cvs` | V:3, I:26 | 4835 | CVS | distant | VCS distant standard précédent (historique)
`tkcvs` | V:0, I:0 | 34 | CVS, … | distant | interface graphique d’affichage d’une arborescence de dépôt VCS (CVS, Subversion, RCS)
`rcs` | V:1, I:9 | 578 | RCS | local | « SCCS UNIX en mieux » (historique)
`cssc` | V:0, I:0 | 2044 | CSSC | local | clone de SCCS UNIX (historique)

[4] Un média à écriture unique tel qu’un CD/DVD-R peut éviter les accidents d’écrasement. (Consulter la Section 9.8, « Les données binaires » pour savoir comment écrire sur le média de stockage à partir de la ligne de commande d’interpréteur. L’environnement graphique de bureau GNOME vous donne un accès facile avec le menu : « Places→CD / DVD Creator ».)

[5] Certaines de ces données ne peuvent pas être régénérées en saisissant la même chaîne d'entrée dans le système.

[6] Si vous utilisez « `~/.vimrc` » au lieu de « `~/.vim/vimrc` », veuillez substituer en conséquence.

Chapitre 9. Astuces du système |  | Chapitre 11. Conversion de données