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 — comprendre diff directement, c’est comprendre ce que Git fait sous le capot quand il compare vos commits.

Les formats de sortie de diff

Format normal (par défaut)

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

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

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.

Comparer deux répertoires

diff -r — récursif

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

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.)

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

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.

Générer le patch
Fenêtre de terminal
```
diff -u v1.conf v2.conf > changes.patch
```
Le fichier changes.patch contient toutes les modifications au format unifié.
Vérifier le patch avant application
Fenêtre de terminal
```
patch --dry-run v1.conf < changes.patch
```
L’option --dry-run simule sans modifier le fichier. Utile pour valider avant de toucher à la production.
Appliquer le patch
Fenêtre de terminal
```
patch v1.conf < changes.patch
```
patch crée automatiquement une sauvegarde v1.conf.orig.

Vérifier le résultat

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

Annuler un patch

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

Options utiles en administration

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)

# 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

Vérifier une migration de configuration

# 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

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

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

À 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.

Prochaines étapes

Expressions régulières de base Écrire des patterns pour grep, sed et awk.

Transformer du texte avec cut, tr et paste Extraire des colonnes, convertir et fusionner du texte.

Trier, compter et dédoublonner sort, uniq, wc et comm pour analyser des listes et des logs.

Filtrer et extraire du texte grep, cut, sort, uniq et diff — les fondamentaux du traitement de texte.