3.5 : Résoudre son premier conflit

Le mot qui fait peur

« Conflit ». Le terme est mal choisi : il évoque une perte de données, une erreur, quelque chose de cassé.

En réalité, un conflit signifie simplement ceci : deux personnes ont modifié les mêmes lignes du même fichier, et Git ne veut pas choisir à votre place. Il s’arrête et vous demande de trancher.

C’est exactement le comportement souhaitable. Un outil qui choisirait tout seul écraserait silencieusement le travail de quelqu’un.

Déroulons un cas complet, ligne par ligne.


La situation de départ

Chez Nordika, le script de connexion Logon.ps1 est dans le dépôt infrastructure/scripts-powershell. Le voici, dans sa version publiée — l’enregistrement a3f9c21 :

# Logon.ps1 - Script de connexion Nordika
$groupes = (Get-ADUser $env:USERNAME -Properties MemberOf).MemberOf

# Lecteur commun à tous
New-PSDrive -Name "S" -PSProvider FileSystem -Root "\\srv-fic01\commun" -Persist

# Lecteurs par service
if ($groupes -match "Compta") {
    New-PSDrive -Name "P" -PSProvider FileSystem -Root "\\srv-fic01\compta" -Persist
}

Write-EventLog -LogName Application -Source "NordikaLogon" -EventId 1000 -Message "Connexion OK"

Deux personnes vont y toucher le même matin, sans le savoir. Voyons d’abord ce qui se passe la plupart du temps.


Scénario 1 — Git s’en sort tout seul

9h00 — Romain et Nicolas font tous deux git pull. Ils sont à jour, sur a3f9c21.

9h15 — Nicolas apprend que le partage comptabilité a migré vers un nouveau serveur. Il corrige le chemin :

if ($groupes -match "Compta") {
    New-PSDrive -Name "P" -PSProvider FileSystem -Root "\\srv-fic02\compta" -Persist
}
git add Logon.ps1
git commit -m "Migration du partage compta vers SRV-FIC02"
git push

Publié. Le serveur est sur 7d2e881. Romain ne le sait pas.

9h40 — Romain, de son côté, répond à une demande du service RH. Il ajoute un bloc, plus bas dans le fichier :

# Lecteurs par service
if ($groupes -match "Compta") {
    New-PSDrive -Name "P" -PSProvider FileSystem -Root "\\srv-fic01\compta" -Persist
}

if ($groupes -match "RH") {
    New-PSDrive -Name "P" -PSProvider FileSystem -Root "\\srv-fic02\RH" -Persist
}
git add Logon.ps1
git commit -m "Ajout du lecteur P: pour le service RH"
git push
 ! [rejected]        main -> main (fetch first)

Même rejet que tout à l’heure : le serveur a avancé. Romain tire :

git pull
Auto-merging Logon.ps1
Merge made by the 'ort' strategy.
 Logon.ps1 | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

Aucun conflit. Git a fusionné seul, et le fichier contient maintenant les deux changements :

# Lecteurs par service
if ($groupes -match "Compta") {
    New-PSDrive -Name "P" -PSProvider FileSystem -Root "\\srv-fic02\compta" -Persist
}

if ($groupes -match "RH") {
    New-PSDrive -Name "P" -PSProvider FileSystem -Root "\\srv-fic02\RH" -Persist
}

Un git push, et c’est terminé. Romain n’a rien eu à faire.

Pourquoi ça marche

Git raisonne ligne par ligne, pas fichier par fichier.

Il compare les deux versions à leur ancêtre commun et constate :

Zone du fichier Modifiée par
La ligne du lecteur P: de la Compta Nicolas seulement
Les lignes du nouveau bloc RH Romain seulement

Aucune ligne n’a été touchée par les deux. Git applique donc les deux changements l’un après l’autre, crée un enregistrement de fusion, et n’a rien à vous demander.

C’est le cas le plus courant, et c’est ce qui rend le travail à plusieurs praticable. Deux personnes peuvent modifier le même fichier toute la journée sans jamais se gêner, tant qu’elles ne travaillent pas sur les mêmes lignes.

La nuance de la proximité

Un détail qui surprend : Git considère quelques lignes de contexte autour de chaque modification. Si les deux changements sont immédiatement adjacents — collés l’un à l’autre, sans ligne inchangée entre eux — il peut malgré tout signaler un conflit, par prudence.

Dans notre exemple, la ligne de fermeture } et la ligne vide séparent suffisamment les deux blocs. Mais si Romain avait ajouté sa ligne juste au-dessus de celle que Nicolas modifiait, un conflit serait apparu — alors qu’aucune ligne commune n’aurait réellement changé.

Ce n’est pas un défaut : dans le doute, Git préfère demander.

⚠️ Attention : fusionné ne veut pas dire correct

Relisez le résultat de la fusion. Il y a un problème.

Les deux blocs montent un lecteur P:. Un utilisateur appartenant à la fois au groupe Compta et au groupe RH — cas très banal chez une assistante de direction, par exemple — verra le second New-PSDrive échouer, ou écraser le premier.

Git n’a rien vu. Il ne pouvait rien voir : il fusionne du texte, pas du sens. Les deux changements étaient valides pris séparément ; c’est leur coexistence qui pose problème.

Retenez-le, car c’est un point de fond : une fusion automatique réussie ne garantit pas que le résultat fonctionne. C’est précisément pour cette raison que nous mettrons en place la relecture en section 4, puis les vérifications automatiques en section 9.

Le réflexe minimal, après tout pull qui fusionne quelque chose :

git diff HEAD~1 HEAD     # que contient réellement cette fusion ?

Cinq secondes, et Romain aurait repéré la collision.


Scénario 2 — Le conflit

Changeons une seule chose. Nicolas fait exactement la même modification qu’avant. Mais cette fois, Romain ne crée pas de nouveau bloc : il touche au bloc existant, parce que la comptabilité lui a demandé un lecteur supplémentaire pour la paie.


La chronologie

9h00 — Les deux sont à jour sur a3f9c21.

9h15 — Nicolas publie exactement la même correction de serveur que dans le premier scénario. La forge passe à 7d2e881. Romain ne le sait toujours pas.

9h40 — Romain répond à une demande de la comptabilité : ajouter un lecteur pour la paie. Cette fois, il modifie le bloc que Nicolas vient de corriger :

if ($groupes -match "Compta") {
    New-PSDrive -Name "P" -PSProvider FileSystem -Root "\\srv-fic01\compta" -Persist
    New-PSDrive -Name "Q" -PSProvider FileSystem -Root "\\srv-fic01\paie" -Persist
}
git add Logon.ps1
git commit -m "Ajout du lecteur Q: pour la paie"

9h45 — Romain publie.

 ! [rejected]        main -> main (fetch first)
error: failed to push some refs

Rien de nouveau jusqu’ici : c’est le message de la leçon 3.4, identique au premier scénario. C’est la suite qui va différer.


Visualiser la divergence

                                        ┌── 7d2e881  Migration compta vers SRV-FIC02
                                        │            (Nicolas, sur la forge)
   a3f9c21 ─────────────────────────────┤
   (le point commun)                    │
                                        └── e5b1c93  Ajout du lecteur Q: pour la paie
                                                     (Romain, en local)

Les deux histoires ont un ancêtre commun — a3f9c21 — puis divergent. Git va devoir les réunir.

Romain applique la procédure vue en 3.4 :

git fetch
git log --oneline HEAD..origin/main
7d2e881 Migration du partage compta vers SRV-FIC02

Un seul enregistrement arrive. Il tire :

git pull

Le conflit

Auto-merging Logon.ps1
CONFLICT (content): Merge conflict in Logon.ps1
Automatic merge failed; fix conflicts and then commit the result.

Rien n’est perdu. Ni le travail de Romain, ni celui de Nicolas. Git a simplement mis le fichier dans un état intermédiaire où les deux versions coexistent, en attendant l’arbitrage.

Regardons où on en est :

git status
On branch main
You have unmerged paths.
  (fix conflicts and run "git commit")
  (use "git merge --abort" to abort the merge)

Unmerged paths:
  (use "git add <file>..." to mark resolution)
        both modified:   Logon.ps1

Trois informations : la fusion est en cours, Logon.ps1 est modifié des deux côtés, et il existe une sortie de secours (git merge --abort).


Ouvrir le fichier

Voici ce que Romain trouve dans Logon.ps1 :

# Logon.ps1 - Script de connexion Nordika
$groupes = (Get-ADUser $env:USERNAME -Properties MemberOf).MemberOf

# Lecteur commun à tous
New-PSDrive -Name "S" -PSProvider FileSystem -Root "\\srv-fic01\commun" -Persist

# Lecteurs par service
if ($groupes -match "Compta") {
<<<<<<< HEAD
    New-PSDrive -Name "P" -PSProvider FileSystem -Root "\\srv-fic01\compta" -Persist
    New-PSDrive -Name "Q" -PSProvider FileSystem -Root "\\srv-fic01\paie" -Persist
=======
    New-PSDrive -Name "P" -PSProvider FileSystem -Root "\\srv-fic02\compta" -Persist
>>>>>>> 7d2e881 (Migration du partage compta vers SRV-FIC02)
}

Write-EventLog -LogName Application -Source "NordikaLogon" -EventId 1000 -Message "Connexion OK"

Observation importante : seul le bloc en conflit est marqué. Le reste du fichier — la ligne du lecteur S:, le journal d’événements — est intact. Git a fusionné tout seul ce qui ne posait pas de problème.

Décoder les marqueurs

<<<<<<< HEAD
        │
        └── VOTRE version (ce que vous aviez en local, avant de tirer)

=======
        │
        └── la frontière entre les deux

>>>>>>> 7d2e881 (Migration du partage compta vers SRV-FIC02)
        │
        └── LEUR version (ce qui arrive du serveur), avec son empreinte et son message

Retenez ces trois repères :

Marqueur Signification
<<<<<<< HEAD Début de votre version
======= Séparateur
>>>>>>> <empreinte> (message) Fin de leur version

Le message de commit affiché à droite est précieux : il vous dit pourquoi l’autre a fait ce changement. « Migration du partage compta vers SRV-FIC02 » — voilà une information que Romain n’avait pas il y a trente secondes.


Le vrai travail : décider

C’est ici que se joue toute la leçon, et c’est la partie que les tutoriels expédient.

Un conflit n’est pas un match. La question n’est pas « qui gagne ? », mais « quel est l’état correct du fichier ? ».

Examinons les deux changements :

  • Nicolas a corrigé le serveur : le partage a réellement migré. Son changement est indispensable.
  • Romain a ajouté un lecteur : la demande de la comptabilité est réelle. Son changement est indispensable aussi.

Les deux ont raison. La bonne résolution conserve les deux changements, en appliquant le nouveau serveur aux deux lecteurs.

C’est le cas le plus fréquent en administration système, et c’est pourquoi les commandes du type « garder ma version » sont si souvent le mauvais réflexe : elles vous font perdre le travail de l’autre sans même le lire.

Écrire la résolution

Romain supprime les trois marqueurs et écrit le résultat voulu :

# Lecteurs par service
if ($groupes -match "Compta") {
    New-PSDrive -Name "P" -PSProvider FileSystem -Root "\\srv-fic02\compta" -Persist
    New-PSDrive -Name "Q" -PSProvider FileSystem -Root "\\srv-fic02\paie" -Persist
}

Notez qu’il a fait plus que combiner : il a appliqué le nouveau serveur au lecteur Q: également. Ni sa version ni celle de Nicolas ne contenait cette ligne — c’est le fruit de l’arbitrage.

C’est exactement ce qu’un outil automatique n’aurait jamais pu deviner. Et c’est aussi le bug que Romain aurait introduit s’il avait bêtement gardé sa version.

⚠️ Vérifiez qu’il ne reste aucun marqueur. Un <<<<<<< oublié dans un script PowerShell produit une erreur de syntaxe — et si ce script est distribué par GPO, sur deux cents postes. Cherchez-les avant de valider :

git grep -n "<<<<<<<"

Terminer la fusion

git add Logon.ps1

git add a ici un sens particulier : il signifie « ce fichier est résolu ».

git status
All conflicts fixed but you are still merging.
  (use "git commit" to conclude merge)

Puis :

git commit

Git propose un message pré-rempli du type Merge branch 'main' of https://forge.nordika.local/.... Vous pouvez le garder, mais c’est une occasion à ne pas gaspiller :

Fusion : migration SRV-FIC02 et ajout du lecteur Q:

Les deux changements sont conservés. Le lecteur Q: pointe désormais
lui aussi vers SRV-FIC02, conformément à la migration.

Six mois plus tard, quelqu’un qui remontera l’historique comprendra immédiatement ce qui s’est passé et pourquoi le lecteur Q: a changé de serveur alors que personne ne l’avait demandé.

git push

Cette fois, ça passe.

L’histoire finale

   a3f9c21 ──┬── 7d2e881 (Nicolas) ──┬── f4a8d02  Fusion : migration SRV-FIC02
             │                        │           et ajout du lecteur Q:
             └── e5b1c93 (Romain) ────┘

Les deux branches d’histoire se rejoignent. Aucun travail n’est perdu, et l’enregistrement de fusion documente l’arbitrage.


Les autres cas de résolution

La combinaison n’est pas toujours la réponse. Trois autres situations.

Garder uniquement votre version

Quand le changement d’en face est obsolète, ou fait par erreur.

git checkout --ours Logon.ps1
git add Logon.ps1

Garder uniquement leur version

Quand vous vous rendez compte que votre modification était mauvaise, ou déjà faite mieux par l’autre.

git checkout --theirs Logon.ps1
git add Logon.ps1

⚠️ Ces deux commandes prennent le fichier entier, pas seulement le bloc en conflit. Vous perdez donc toutes vos autres modifications sur ce fichier, y compris celles que Git avait fusionnées sans difficulté. À n’utiliser que si vous êtes certain de vouloir jeter une version complète.

Dans le doute, éditez à la main. C’est plus lent et c’est plus sûr.

Tout annuler et réfléchir

git merge --abort

Tout revient à l’état d’avant le pull. Vos enregistrements locaux sont intacts, rien n’est perdu, et vous pouvez aller demander à votre collègue ce qu’il avait en tête avant de recommencer.

Cette commande est votre filet de sécurité. Utilisez-la sans hésiter dès que vous ne comprenez pas ce que vous avez sous les yeux.


Les outils qui aident

Voir uniquement les conflits

git diff

Pendant une fusion, git diff affiche une vue combinée des seuls blocs en conflit. Pratique sur un fichier long.

Comparer aux trois versions

git log --merge -p Logon.ps1

Affiche les enregistrements des deux côtés qui touchent au fichier — utile pour comprendre l’intention de chacun.

L’éditeur

VS Code détecte les marqueurs et affiche quatre boutons au-dessus du bloc : Accepter l’actuel, Accepter l’entrant, Accepter les deux, Comparer.

C’est confortable, à une réserve près : « Accepter les deux » colle les deux versions l’une après l’autre. Dans notre exemple, cela aurait produit deux lignes New-PSDrive -Name "P" contradictoires — un script cassé. La combinaison intelligente reste votre travail.

Le mode graphique

git mergetool

Ouvre un outil de fusion à trois panneaux (votre version, la leur, l’ancêtre commun), si vous en avez configuré un. Utile sur des conflits volumineux, superflu sur trois lignes.


Éviter les conflits

Un conflit se résout en cinq minutes. Autant en avoir moins.

Tirez souvent. Un conflit naît de l’écart entre deux versions. Deux heures d’écart produisent un conflit trivial ; deux semaines, un cauchemar.

Publiez souvent. Symétriquement : votre travail non publié est un conflit en préparation pour les autres.

Prévenez. « Je touche au script de connexion ce matin » dans le canal de l’équipe évite plus de conflits que n’importe quel outil.

Découpez vos fichiers. Un Logon.ps1 de mille lignes que tout le monde modifie génère mécaniquement des conflits. Des fichiers thématiques en génèrent beaucoup moins. Nous y reviendrons en section 5.

Faites des enregistrements petits et fréquents. Ils réduisent la surface de contact — et quand un conflit survient, il porte sur peu de lignes.


Les erreurs classiques

Symptôme Cause
Le script ne s’exécute plus après résolution Un marqueur <<<<<<< a été oublié
git commit refuse : Unmerged paths Il manque un git add sur un fichier résolu
Des modifications ont disparu --ours ou --theirs a écrasé le fichier entier
Le conflit revient au pull suivant La fusion n’a jamais été conclue par un commit
Impossible de s’en sortir git merge --abort et on recommence calmement
Le fichier est illisible, plein de marqueurs Plusieurs blocs en conflit : traitez-les un par un, de haut en bas

Ce qu’il faut retenir

  • La plupart du temps, Git fusionne seul : il raisonne ligne par ligne, pas fichier par fichier.
  • Deux personnes peuvent modifier le même fichier sans se gêner, tant qu’elles ne touchent pas aux mêmes lignes.
  • ⚠️ Une fusion automatique réussie ne garantit pas un résultat correct : Git fusionne du texte, pas du sens.
  • Le réflexe après un pull qui fusionne : git diff HEAD~1 HEAD.
  • Un conflit signifie que Git refuse de choisir à votre place — c’est une protection.
  • Rien n’est perdu : les deux versions sont dans le fichier, en attente d’arbitrage.
  • <<<<<<< HEAD = votre version · ======= = séparateur · >>>>>>> = celle qui arrive.
  • Seuls les blocs réellement en conflit sont marqués ; le reste est fusionné automatiquement.
  • La question n’est pas « qui gagne » mais « quel est l’état correct du fichier » — souvent, il faut garder les deux.
  • Vérifiez qu’aucun marqueur ne subsiste avant de valider : git grep -n "<<<<<<<".
  • git add marque un fichier comme résolu ; git commit conclut la fusion.
  • --ours et --theirs prennent le fichier entier : à manier avec précaution.
  • git merge --abort annule tout et ne perd rien : votre filet de sécurité.
  • Tirer et publier souvent est la meilleure prévention.

Dans la leçon suivante

Vous savez travailler à plusieurs sur un dépôt. Reste à contrôler ce qui y entre.

Le .gitignore est le garde-fou le plus important de votre dépôt : c’est lui qui empêchera votre fichier .env — celui qui contient le mot de passe de la base de votre forge — de se retrouver dans un historique consultable par toute l’équipe. Nous verrons comment l’écrire, quoi y mettre pour un dépôt d’administration système, et pourquoi il ne protège pas ce qui a déjà été enregistré.