Comparer des fichiers avec diff

diff est la commande de référence pour détecter les changements entre deux fichiers. C'est le moteur derrière git diff, patch, et la plupart des outils de revue de code. En administration système, vous l'utilisez pour comparer des configurations avant/après, vérifier des migrations et propager des changements entre serveurs.

Le guide des fondamentaux couvre la syntaxe de base. Ce guide se concentre sur les usages réels : format unifié, comparaison récursive et workflow diff → patch.

Ce que vous allez apprendre

• Lire les trois formats de sortie de diff (normal, -u, -y)
• Comparer deux répertoires entiers avec diff -r
• Générer un fichier patch et l'appliquer avec patch
• Exploiter les codes de retour dans un script de vérification

Dans quel contexte ?

Vous remettez un serveur en production après une intervention. Vous voulez vous assurer que la configuration est exactement celle qui était en place avant, pas « à peu près la même », exactement la même. Ou vous devez propager un correctif d'un fichier de configuration d'un environnement à un autre, sans écraser les adaptations locales. Ou encore vous gérez des dizaines de serveurs et vous suspectez qu'un d'entre eux a une configuration qui a dérivé. diff est l'outil de confiance dans ces situations : il dit précisément ce qui a changé, ligne par ligne, sans ambiguïté. C'est aussi le moteur de git diff : les deux produisent le même format unifié, avec les mêmes en-têtes @@ et les mêmes préfixes de ligne, donc savoir lire l'un revient à savoir lire l'autre.

Les formats de sortie de diff

diff sait présenter le même écart de trois manières, et le choix n'est pas cosmétique : seul le format unifié contient assez d'information pour être rejoué par patch. Les exemples ci-dessous comparent deux versions d'une configuration nginx, v1.conf et v2.conf. Le fichier passé en premier argument est toujours l'ancien, le second le nouveau ; inverser les deux inverse le sens des ajouts et des suppressions.

Format normal (par défaut)

Sans option, diff n'affiche que les lignes qui changent, sans aucune ligne de contexte autour. C'est le format le plus compact, mais il est inexploitable par patch dès que le fichier cible a bougé.

diff v1.conf v2.conf

2,3c2,3
< server_name example.com;
< listen 80;
---
> server_name example.com www.example.com;
> listen 443 ssl;
5,6c5,7
< worker_processes 2;
< access_log /var/log/nginx/access.log;
---
> worker_processes 4;
> access_log /var/log/nginx/access.log combined;
> error_log /var/log/nginx/error.log warn;

Lecture : 2,3c2,3 signifie « les lignes 2-3 du fichier gauche changent pour devenir les lignes 2-3 du fichier droit ». Les lignes prefixées par < viennent du fichier gauche, celles par > du fichier droit.

Les trois actions possibles sont a (ajout), d (suppression) et c (changement).

Format unifié, le plus utile

L'option -u ajoute deux lignes d'en-tête avec les noms de fichiers et leurs dates de modification, puis entoure chaque changement de trois lignes de contexte inchangées. C'est ce contexte qui permet à patch de retrouver l'emplacement à modifier même si les numéros de lignes ont bougé.

diff -u v1.conf v2.conf

--- v1.conf     2026-04-09 15:27:28
+++ v2.conf     2026-04-09 15:27:28
@@ -1,6 +1,7 @@
 # Configuration nginx
-server_name example.com;
-listen 80;
+server_name example.com www.example.com;
+listen 443 ssl;
 root /var/www/html;
-worker_processes 2;
-access_log /var/log/nginx/access.log;
+worker_processes 4;
+access_log /var/log/nginx/access.log combined;
+error_log /var/log/nginx/error.log warn;

C'est le format de git diff. Chaque bloc commence par @@ qui indique les numéros de lignes. Les lignes sans préfixe sont le contexte (inchangées), - ce qui disparaît, + ce qui arrive.

Le contexte (3 lignes par défaut) permet de localiser le changement même si le fichier a été modifié entre-temps. On peut l'ajuster avec -U :

diff -u --unified=5 v1.conf v2.conf   # 5 lignes de contexte
diff -u --unified=0 v1.conf v2.conf   # sans contexte

Format côte à côte

L'option -y affiche les deux fichiers dans deux colonnes, y compris les lignes identiques : la sortie est donc aussi longue que le fichier lui-même. Elle sert à la lecture humaine sur des fichiers courts, jamais à produire un patch.

diff -y v1.conf v2.conf

# Configuration nginx                     # Configuration nginx
server_name example.com;               |  server_name example.com www.example.com;
listen 80;                              |  listen 443 ssl;
root /var/www/html;                        root /var/www/html;
worker_processes 2;                     |  worker_processes 4;
access_log /var/log/nginx/access.log;  |  access_log /var/log/nginx/access.log combined;
                                        >  error_log /var/log/nginx/error.log warn;

Le | marque une ligne modifiée, > une ligne ajoutée à droite, < une ligne supprimée à droite.

Largeur d'affichage

Par défaut diff -y utilise 130 colonnes. Ajustez avec --width=N si vos lignes sont longues.

Comparer deux répertoires

Comparer deux arborescences répond à deux questions différentes : quels fichiers n'existent que d'un côté, et lesquels existent des deux côtés mais diffèrent. diff -r traite les deux d'un seul passage. Attention, il compare le contenu et rien d'autre : ni les permissions, ni le propriétaire, ni les dates ne sont examinés.

diff -r, récursif

L'option -r descend dans tous les sous-répertoires et compare les fichiers de même chemin relatif.

diff -r dir_v1 dir_v2

Only in dir_v2: extra.conf
diff -r dir_v1/nginx.conf dir_v2/nginx.conf
2,3c2,3
< server_name example.com;
...
Only in dir_v1: script_v1.sh
Only in dir_v2: script_v2.sh

diff -r signale aussi les fichiers présents dans un seul des deux répertoires (Only in). C'est utile pour détecter une dérive de configuration entre deux serveurs.

Pour avoir juste la liste des différences sans le détail :

diff -rq dir_v1 dir_v2

Only in dir_v2: extra.conf
Files dir_v1/nginx.conf and dir_v2/nginx.conf differ
Only in dir_v1: script_v1.sh
Only in dir_v2: script_v2.sh

Ignorer certains fichiers

--exclude prend un motif de nom de fichier, pas un chemin, et se répète autant de fois que nécessaire.

diff -r --exclude='*.log' --exclude='*.pid' dir_v1 dir_v2

Utile pour comparer des répertoires d'application en ignorant les fichiers runtime.

Codes de retour

diff retourne un code de sortie utilisable dans des scripts :

Code	Signification
0	Fichiers identiques
1	Fichiers différents
2	Erreur (fichier introuvable, etc.)

Glissez pour voir

if diff -q fichier_reference.conf fichier_actuel.conf > /dev/null 2>&1; then
    echo "Configuration cohérente"
else
    echo "ALERTE : dérive détectée"
    diff -u fichier_reference.conf fichier_actuel.conf
fi

Code 1 ≠ erreur

Un code de retour 1 signifie simplement "différents", pas une erreur. Ne pas confondre avec les outils qui retournent 1 en cas d'échec.

Workflow diff → patch

Le workflow diff -u → patch sert à propager un changement d'un fichier vers un autre, même quand les deux ont divergé, ou pour distribuer une correction.

1. Générer le patch

   diff -u v1.conf v2.conf > changes.patch

   Le fichier changes.patch contient toutes les modifications au format unifié.

2. Vérifier le patch avant application

   patch --dry-run v1.conf < changes.patch

   L'option --dry-run simule sans modifier le fichier. Utile pour valider avant de toucher à la production.

3. Appliquer le patch

   patch -b v1.conf < changes.patch

   L'option -b (--backup) conserve la version d'origine dans v1.conf.orig. Sans elle, patch ne crée aucune sauvegarde : le fichier est modifié en place, sans filet. C'est une erreur répandue de croire que la sauvegarde est automatique.

4. Vérifier le résultat

   diff v1.conf v2.conf   # doit être vide

Annuler un patch

Le rollback exige le fichier patch d'origine : sans lui, aucun retour en arrière n'est possible, sauf à disposer de la sauvegarde produite par -b.

patch -R v1.conf < changes.patch

L'option -R applique le patch en sens inverse (rollback).

Patches multi-fichiers

Pour un projet entier :

# Générer
diff -ru dir_v1/ dir_v2/ > projet.patch

# Appliquer depuis la racine du projet
patch -p1 < projet.patch

-p1 et les chemins

L'option -p1 supprime le premier composant de chemin (ex : dir_v1/nginx.conf → nginx.conf). Ajustez selon la structure du patch.

Options utiles en administration

Sur des fichiers de configuration, le bruit vient rarement du fond : indentation retouchée, ligne vide ajoutée, retours chariot d'un éditeur Windows. Ces options écartent ce bruit pour ne laisser que les écarts réels. Ne les utilisez pas pour générer un patch : un diff produit avec -w ou -B ne reflète plus le fichier tel qu'il est, et patch échouera.

Option	Effet
-i	Ignore la casse
-w	Ignore tous les espaces
-b	Ignore les espaces en fin de ligne
-B	Ignore les lignes vides
--strip-trailing-cr	Ignore les \r (fichiers Windows)

Glissez pour voir

# Comparer deux configs en ignorant les commentaires et lignes vides
grep -v '^#' v1.conf | grep -v '^$' > v1_clean.conf
grep -v '^#' v2.conf | grep -v '^$' > v2_clean.conf
diff v1_clean.conf v2_clean.conf

Cas d'usage admin

Les trois situations ci-dessous couvrent l'essentiel de l'usage quotidien de diff en exploitation : contrôler ce qu'une intervention a réellement modifié, confronter deux serveurs censés être identiques, et mesurer l'écart entre l'état réel d'un serveur et sa référence versionnée.

Vérifier une migration de configuration

La copie de référence doit être prise avant toute modification : sans elle, il n'y a plus rien à comparer une fois l'intervention terminée.

# Avant migration : sauvegarder
cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak

# Après migration : voir ce qui a changé
diff -u /etc/nginx/nginx.conf.bak /etc/nginx/nginx.conf

Comparer la config entre deux serveurs

diff ne travaille que sur des fichiers locaux : il faut donc rapatrier les deux versions d'abord. Un cat distant convient pour un fichier de configuration lisible, mais perd les permissions et le propriétaire.

ssh serveur1 'cat /etc/nginx/nginx.conf' > nginx_serveur1.conf
ssh serveur2 'cat /etc/nginx/nginx.conf' > nginx_serveur2.conf
diff -u nginx_serveur1.conf nginx_serveur2.conf

Détecter la dérive d'un répertoire de configuration

L'option -q se contente de lister les fichiers qui diffèrent, ce qui donne un rapport court, exploitable dans un contrôle périodique. Pensez à exclure le répertoire .git de la copie de référence, sinon il apparaît systématiquement en Only in.

# Référence versionnée dans un dépôt Git
diff -rq /etc/nginx/ ~/git/infra/nginx/

Contrôle de connaissances

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

6 questions

6 min.

70% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

À retenir

• diff -u est le format standard pour les patches et les revues, lisez-le comme un git diff.
• diff -r compare des répertoires complets et signale les fichiers absents.
• Le workflow diff -u → patch → patch -R permet de propager ou annuler un changement de manière contrôlée.
• Le code de retour 0/1/2 est utilisable dans les scripts de vérification.
• Sans -u, patch n'a pas assez de contexte, toujours utiliser diff -u pour générer un patch.

×

📖 Voir la documentation →