Remotes fondamentaux : travailler avec des dépôts distants

Un remote est un dépôt Git hébergé ailleurs (GitHub, GitLab, serveur interne). Le cycle de collaboration repose sur trois opérations : fetch (récupérer), merge/rebase (intégrer), push (envoyer). Ce guide détaille chaque étape et la gestion de plusieurs remotes.

Prérequis : Branches distantes et Les bases de Git.

Ce que vous allez apprendre

Configurer un remote : ajouter, renommer, supprimer avec git remote
Synchroniser votre dépôt : fetch → merge/rebase → push
Travailler avec plusieurs remotes (origin, upstream, fork)
Comprendre la différence entre git fetch et git pull

Qu’est-ce qu’un remote ?

Un remote est un alias vers l’URL d’un dépôt distant. Quand vous clonez un dépôt, Git crée automatiquement un remote nommé origin :

git remote -v

origin  https://github.com/user/project.git (fetch)
origin  https://github.com/user/project.git (push)

L’URL de fetch et de push peuvent être différentes (rare mais possible).

Gérer les remotes

Ajouter un remote

git remote add upstream https://github.com/original/project.git

Cas d’usage : vous travaillez sur un fork et ajoutez le dépôt original comme upstream pour synchroniser.

Lister les remotes

# Noms uniquement
git remote

# Avec les URLs
git remote -v

# Détails complets (branches trackées, HEAD, etc.)
git remote show origin

Renommer un remote

git remote rename origin github

Toutes les références (github/main, github/develop) sont automatiquement mises à jour.

Supprimer un remote

git remote remove upstream

Les branches de tracking associées (upstream/main, etc.) sont également supprimées.

Le cycle de collaboration

Le workflow standard suit trois étapes :

Serveur distant          Votre machine
     │                        │
     │   1. git fetch          │
     │ ──────────────────────► │  (télécharge les commits)
     │                        │
     │   2. merge / rebase    │
     │                        │  (intègre localement)
     │                        │
     │   3. git push          │
     │ ◄────────────────────── │  (envoie vos commits)
     │                        │

1. `git fetch` : récupérer

git fetch origin

Télécharge tous les nouveaux commits, branches et tags depuis origin. Ne modifie pas vos branches locales.

# Fetch depuis tous les remotes
git fetch --all

# Fetch + suppression des refs périmées
git fetch --prune

2. Intégrer : merge ou rebase

Après le fetch, intégrez les changements distants dans votre branche :

# Option merge (conserve l'historique)
git merge origin/main

# Option rebase (historique linéaire)
git rebase origin/main

3. `git push` : envoyer

# Push de la branche courante
git push

# Premier push (crée la branche distante + tracking)
git push -u origin feature/login

# Push de toutes les branches
git push --all origin

# Push des tags
git push --tags

Si le remote a des commits que vous n’avez pas, Git rejette le push :

! [rejected] main -> main (non-fast-forward)

Solution : git pull --rebase puis git push. Ne faites jamais git push --force sur une branche partagée sans concertation.

`git pull` : le raccourci

git pull combine fetch + merge (ou fetch + rebase) :

# fetch + merge (par défaut)
git pull origin main

# fetch + rebase
git pull --rebase origin main

Commande	Équivalent	Modifie la branche locale ?
`git fetch`	—	Non
`git pull`	`git fetch` + `git merge`	Oui
`git pull --rebase`	`git fetch` + `git rebase`	Oui

git pull --rebase est préférable à git pull par défaut. Il évite de créer des commits de merge parasites quand vos branches locales et distantes ont divergé. Pour en faire le comportement par défaut :

git config --global pull.rebase true

Si vous préférez garder le contrôle explicitement, utilisez git fetch + git log origin/main..main (inspection) + git merge ou git rebase selon le contexte.

Travailler avec plusieurs remotes

Cas typique : vous contribuez à un projet open source via un fork.

Forkez le projet sur GitHub/GitLab

Clonez votre fork :

git clone https://github.com/vous/project.git

Ajoutez le dépôt original :

git remote add upstream https://github.com/original/project.git

Synchronisez régulièrement :

git fetch upstream
git switch main
git merge upstream/main
git push origin main

Vos remotes :

git remote -v

origin    https://github.com/vous/project.git (fetch)
origin    https://github.com/vous/project.git (push)
upstream  https://github.com/original/project.git (fetch)
upstream  https://github.com/original/project.git (push)

Changer l’URL d’un remote

Si le dépôt change d’hébergement ou si vous passez de HTTPS à SSH :

# Voir l'URL actuelle
git remote get-url origin

# Changer l'URL
git remote set-url origin git@github.com:user/project.git

Dépannage : problèmes courants

Symptôme	Cause probable	Solution
`fatal: 'origin' does not appear to be a git repository`	Remote mal configuré	`git remote -v`, vérifiez l’URL
`! [rejected] (non-fast-forward)`	Remote en avance sur vos commits	`git pull --rebase` puis `git push`
`Permission denied (publickey)`	Clé SSH non configurée	Vérifiez `ssh -T git@github.com`
`remote: Repository not found`	URL incorrecte ou accès refusé	Vérifiez l’URL et vos permissions
Fetch ne ramène rien	Déjà à jour	`git log origin/main..main` pour vérifier la diff

À retenir

origin est l’alias par défaut du remote créé au clone
Le cycle : fetch → merge/rebase → push
git fetch récupère sans modifier — git pull récupère et intègre
git push -u crée la branche distante et configure le tracking
Plusieurs remotes : origin (votre fork) + upstream (dépôt original) pour les contributions open source

Prochaines étapes

Workflows distribués Centralisé, Integration-Manager, Dictator.

Pull requests et code review Collaborez avec les PR/MR.

Branches distantes Tracking, ahead/behind, synchronisation.