3.4 : Récupérer le travail des autres : fetch, pull, les remotes

Le message que vous allez rencontrer

Vous avez travaillé, enregistré, et vous publiez. Et là :

 ! [rejected]        main -> main (fetch first)
error: failed to push some refs to 'https://forge.nordika.local/...'
hint: Updates were rejected because the remote contains work that you do
hint: not have locally. This is usually caused by another repository pushing
hint: to the same ref.

Rien n’est cassé. Git vous dit simplement : le serveur a avancé pendant que vous travailliez. Un collègue a publié quelque chose que vous n’avez pas.

Git refuse de publier par-dessus, parce que cela écraserait le travail de l’autre. C’est une protection, et c’est exactement le comportement que vous voulez.

La solution tient en trois commandes — mais autant comprendre ce qu’elles font, parce que c’est ici que se joue la moitié des incompréhensions autour de Git.


fetch et pull : la distinction fondamentale

git fetch    # « va voir ce qu'il y a de neuf, sans rien toucher chez moi »
git pull     # « va voir, ET intègre chez moi »

git pull fait deux choses en une : fetch puis merge. C’est ce cumul qui déroute, parce qu’on ne sait plus laquelle des deux a produit le résultat qu’on observe.

Voici ce qui se passe, étape par étape.

git fetch — se renseigner

   AVANT                              APRÈS git fetch

   main         a3f9c21               main         a3f9c21   ← inchangé
   origin/main  a3f9c21               origin/main  7d2e881   ← mis à jour

Souvenez-vous de la leçon 3.2 : origin/main est votre dernière connaissance de la branche du serveur. fetch met à jour cette connaissance.

Vos fichiers ne bougent pas. Votre branche ne bouge pas. Rien de ce que vous avez sur l’établi n’est touché. Vous savez simplement ce qui existe ailleurs.

C’est une commande sans aucun risque. Vous pouvez la lancer à tout moment, y compris au milieu d’un travail en cours.

git merge — intégrer

git merge origin/main

Là, Git réunit réellement les deux histoires et modifie vos fichiers.

git pull — les deux à la suite

Pratique au quotidien, et parfaitement adapté quand vous savez qu’il n’y a rien de surprenant à récupérer.


Le réflexe qui vous fera gagner du temps

Plutôt que de tirer à l’aveugle, prenez cette habitude :

git fetch
git log --oneline HEAD..origin/main

La seconde commande affiche ce qui arrive — les enregistrements présents sur le serveur et absents chez vous :

7d2e881 Correction du chemin de sauvegarde
b91c4f2 Ajout du serveur SRV-BDD02 à l'inventaire

Deux lignes, cinq secondes, et vous savez ce que vous vous apprêtez à intégrer.

La commande symétrique montre ce qui partira quand vous publierez :

git log --oneline origin/main..HEAD

Et pour voir le détail des changements avant de les intégrer :

git diff HEAD origin/main

La notation A..B se lit « ce qui est dans B mais pas dans A ». Retenez-la, elle revient constamment : HEAD..origin/main pour ce qui arrive, origin/main..HEAD pour ce qui part.

Ce réflexe n’a rien d’excessif quand le dépôt contient les scripts qui s’exécutent sur deux cents postes. Savoir ce qu’on intègre avant de l’intégrer, c’est le minimum.


Débloquer le push rejeté

Le cas standard, dans l’ordre :

git fetch                              # 1. se renseigner
git log --oneline HEAD..origin/main    # 2. regarder ce qui arrive
git pull                               # 3. intégrer
git push                               # 4. publier

Si personne n’a touché aux mêmes fichiers que vous, pull se déroule sans un mot et push passe.

Si vous avez tous les deux modifié le même fichier au même endroit, vous obtiendrez un conflit. Ce n’est ni grave ni rare, et cela mérite un traitement à part : nous y consacrerons la leçon 4.3.


Le commit de fusion

Après un pull qui intègre du travail, vous verrez parfois apparaître un enregistrement que vous n’avez pas écrit :

Merge branch 'main' of https://forge.nordika.local/infrastructure/scripts

C’est un enregistrement de fusion. Il ne contient aucune modification propre : il note simplement que deux histoires se sont rejointes à cet endroit.

Il est parfaitement normal. Certains le trouvent inesthétique et préfèrent une autre stratégie d’intégration, le rebase, qui produit un historique linéaire.

Nous avons configuré la fusion classique en leçon 1.6 (pull.rebase false), et je vous conseille de vous y tenir pour l’instant : c’est la stratégie qui ne perd jamais rien et qui ne réécrit pas l’histoire. Nous reparlerons de l’alternative en section 4, une fois les branches acquises.


Le cas du travail en cours

Vous avez modifié des fichiers sans les enregistrer, et vous tentez de tirer :

error: Your local changes to the following files would be overwritten by merge:
        Logon.ps1
Please commit your changes or stash them before you merge.

Git protège votre travail en cours. Deux solutions.

La bonne : enregistrer d’abord

git add Logon.ps1
git commit -m "Ajustement du lecteur P: en cours"
git pull

C’est presque toujours le bon choix. Un enregistrement ne coûte rien, et il est local — vous pourrez toujours le reprendre avec --amend avant de publier.

L’autre : mettre de côté temporairement

git stash          # range les modifications en cours
git pull           # intègre
git stash pop      # remet vos modifications par-dessus

git stash met votre travail en cours dans une pile, laissant l’établi propre. stash pop le récupère.

C’est utile quand vos modifications ne forment pas encore un ensemble cohérent et que vous ne voulez pas produire un enregistrement bâclé.

⚠️ Le défaut du stash : on l’oublie. Un travail rangé là n’apparaît pas dans git status et ne part jamais sur la forge. Trois semaines plus tard, vous ne saurez plus ce qu’il contient. Vérifiez régulièrement :

git stash list

Ma recommandation : privilégiez l’enregistrement, et réservez le stash aux interruptions de quelques minutes.


Récupérer sans être dérangé

Un dernier cas, fréquent en administration : vous voulez savoir ce qui se passe sur le dépôt sans rien intégrer, parce que vous êtes au milieu d’autre chose.

git fetch
git log --oneline --graph --all

Ou, avec l’alias configuré en leçon 1.6 :

git fetch && git lg

Vous voyez les deux histoires côte à côte, la vôtre et celle du serveur, sans qu’aucun de vos fichiers ne bouge. Vous intégrerez quand vous serez prêt.


Les erreurs classiques

Symptôme Cause et solution
Updates were rejected (fetch first) Le serveur a avancé : pull puis push
Your local changes would be overwritten Enregistrez ou rangez votre travail en cours
There is no tracking information La branche n’a pas de lien de suivi : git push -u origin main
CONFLICT (content): Merge conflict Deux modifications au même endroit — voir leçon 4.3
git status affiche des informations périmées origin/main n’est pas à jour : git fetch
Un pull a produit un enregistrement non désiré C’est l’enregistrement de fusion : normal
Du travail a disparu Il est peut-être dans le stash : git stash list

Ce qu’il faut retenir

  • fetch se renseigne, pull intègre. pull = fetch + merge.
  • fetch ne présente aucun risque : ni vos fichiers ni votre branche ne bougent.
  • Le réflexe : fetch, regarder, puis intégrer.
  • HEAD..origin/main montre ce qui arrive ; origin/main..HEAD ce qui partira.
  • Un push rejeté signifie simplement que le serveur a avancé.
  • L’enregistrement de fusion est normal ; il ne contient aucune modification propre.
  • Avant de tirer, enregistrez votre travail en cours plutôt que de le ranger au stash.
  • Un stash oublié ne part jamais sur la forge : git stash list de temps en temps.

Dans la leçon suivante

Nous avons évoqué plusieurs fois le fichier qui empêche certaines choses de partir sur la forge. Il est temps de le mettre en place.

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