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

Rejet du push (non-fast-forward)

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	Sans objet	Non
git pull	git fetch + git merge	Oui
git pull --rebase	git fetch + git rebase	Oui

Glissez pour voir

Recommandation : pull.rebase true

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.

1. Forkez le projet sur GitHub/GitLab

2. Clonez votre fork :

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

3. Ajoutez le dépôt original :

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

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

Glissez pour voir

À 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

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

10 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

Pour aller plus loin

• Pull requests et code review : Le circuit de relecture qui encadre ce que vous poussez vers le dépôt partagé.
• Workflows Git : Les stratégies de branches qui décident de ce qui part sur le remote, et quand.
• Protocoles Git : HTTPS, SSH et les autres transports mobilisés par chaque fetch et chaque push.
• Stockage des credentials : La configuration qui évite de retaper un jeton à chaque opération réseau.

×

📖 Voir la documentation →