Git 🌙
Chapters ▾ 2nd Edition

2.5 Les bases de Git - Travailler avec des dépôts distants

Travailler avec des dépôts distants

Pour pouvoir collaborer sur un projet Git, il est nécessaire de savoir comment gérer les dépôts distants. Les dépôts distants sont des versions de votre projet qui sont hébergées sur Internet ou le réseau d’entreprise. Vous pouvez en avoir plusieurs, pour lesquels vous pouvez avoir des droits soit en lecture seule, soit en lecture/écriture. Collaborer avec d’autres personnes consiste à gérer ces dépôts distants, en poussant ou tirant des données depuis et vers ces dépôts quand vous souhaitez partager votre travail. Gérer des dépôts distants inclut savoir comment ajouter des dépôts distants, effacer des dépôts distants qui ne sont plus valides, gérer des branches distantes et les définir comme suivies ou non, et plus encore. Dans cette section, nous traiterons des commandes de gestion distante.

Note
Les dépôts distants peuvent aussi être sur votre machine

Il est tout à fait possible de travailler avec un dépôt « distant » qui est en fait, sur la même machine. Les mot « distant » ne veut pas forcément dire que le dépôt est ailleurs sur le réseau ou Internet, seulement qu’il est ailleurs. Travailler avec un tel dépôt distant impliquera tout de même les opérations de poussée, de tirage ou de récupération comme pour tout autre dépôt distant.

Afficher les dépôts distants

Pour visualiser les serveurs distants que vous avez enregistrés, vous pouvez lancer la commande git remote. Elle liste les noms des différentes références distantes que vous avez spécifiées. Si vous avez cloné un dépôt, vous devriez au moins voir l’origine origin — c’est-à-dire le nom par défaut que Git donne au serveur à partir duquel vous avez cloné :

$ git clone https://github.com/schacon/ticgit
Clonage dans 'ticgit'...
remote: Counting objects: 1857, done.
remote: Total 1857 (delta 0), reused 0 (delta 0)
Réception d'objets: 100% (1857/1857), 374.35 KiB | 243.00 KiB/s, fait.
Résolution des deltas: 100% (772/772), fait.
Vérification de la connectivité... fait.
$ cd ticgit
$ git remote
origin

Vous pouvez aussi spécifier -v, qui vous montre l’URL que Git a stockée pour chaque nom court :

$ git remote -v
origin	https://github.com/schacon/ticgit (fetch)
origin	https://github.com/schacon/ticgit (push)

Si vous avez plus d’un dépôt distant, la commande précédente les liste tous. Par exemple, un dépôt avec plusieurs dépôts distants permettant de travailler avec quelques collaborateurs pourrait ressembler à ceci.

$ cd grit
$ git remote -v
bakkdoor  https://github.com/bakkdoor/grit (fetch)
bakkdoor  https://github.com/bakkdoor/grit (push)
cho45     https://github.com/cho45/grit (fetch)
cho45     https://github.com/cho45/grit (push)
defunkt   https://github.com/defunkt/grit (fetch)
defunkt   https://github.com/defunkt/grit (push)
koke      git://github.com/koke/grit.git (fetch)
koke      git://github.com/koke/grit.git (push)
origin    git@github.com:mojombo/grit.git (fetch)
origin    git@github.com:mojombo/grit.git (push)

Cela signifie que vous pouvez facilement tirer les contributions de tous ces utilisateurs. Nous pouvons de plus avoir les permissions en poussée sur certain d’entre eux, bien qu’on ne puisse pas le dire ici.

Notez que ces dépôts distants sont accessibles au moyen de différents protocoles ; nous traiterons des protocoles au chapitre Installation de Git sur un serveur.

Ajouter des dépôts distants

J’ai expliqué et donné des exemples d’ajout de dépôts distants dans les chapitres précédents, mais voici spécifiquement comment faire. Pour ajouter un nouveau dépôt distant Git comme nom court auquel il est facile de faire référence, lancez git remote add [nomcourt] [url] :

$ git remote
origin
$ git remote add pb https://github.com/paulboone/ticgit
$ git remote -v
origin	https://github.com/schacon/ticgit (fetch)
origin	https://github.com/schacon/ticgit (push)
pb	https://github.com/paulboone/ticgit (fetch)
pb	https://github.com/paulboone/ticgit (push)

Maintenant, vous pouvez utiliser le mot-clé pb sur la ligne de commande au lieu de l’URL complète. Par exemple, si vous voulez récupérer toute l’information que Paul a mais que vous ne souhaitez pas l’avoir encore dans votre branche, vous pouvez lancer git fetch pb :

$ git fetch pb
remote: Counting objects: 43, done.
remote: Compressing objects: 100% (36/36), done.
remote: Total 43 (delta 10), reused 31 (delta 5)
Dépaquetage des objets: 100% (43/43), fait.
Depuis https://github.com/paulboone/ticgit
 * [nouvelle branche] master     -> pb/master
 * [nouvelle branche] ticgit     -> pb/ticgit

La branche master de Paul est accessible localement en tant que pb/master — vous pouvez la fusionner dans une de vos propres branches, ou vous pouvez extraire une branche localement si vous souhaitez l’inspecter. Nous traiterons plus en détail de la nature des branches et de leur utilisation au chapitre Les branches avec Git.

Récupérer et tirer depuis des dépôts distants

Comme vous venez tout juste de le voir, pour obtenir les données des dépôts distants, vous pouvez lancer :

$ git fetch [remote-name]

Cette commande s’adresse au dépôt distant et récupère toutes les données de ce projet que vous ne possédez pas encore. Après cette action, vous possédez toutes les références à toutes les branches contenues dans ce dépôt, que vous pouvez fusionner ou inspecter à tout moment.

Si vous clonez un dépôt, le dépôt distant est automatiquement ajouté sous le nom « origin ». Donc, git fetch origin récupère tout ajout qui a été poussé vers ce dépôt depuis que vous l’avez cloné ou la dernière fois que vous avez récupéré les ajouts. Il faut noter que la commande fetch tire les données dans votre dépôt local mais sous sa propre branche — elle ne les fusionne pas automatiquement avec aucun de vos travaux ni ne modifie votre copie de travail. Vous devez volontairement fusionner ses modifications distantes dans votre travail lorsque vous le souhaitez.

Si vous avez créé une branche pour suivre l’évolution d’une branche distante (cf. la section suivante et le chapitre Les branches avec Git pour plus d’information), vous pouvez utiliser la commande git pull qui récupère et fusionne automatiquement une branche distante dans votre branche locale. Ce comportement peut correspondre à une méthode de travail plus confortable, sachant que par défaut la commande git clone paramètre votre branche locale pour qu’elle suive la branche master du dépôt que vous avez cloné (en supposant que le dépôt distant ait une branche master). Lancer git pull récupère généralement les données depuis le serveur qui a été initialement cloné et essaie de les fusionner dans votre branche de travail actuel.

Note

Depuis Git version 2.27, git pull affichera un avertissement si la variable pull.rebase n’est pas paramétrée. Git continuera à vous avertir tant que la variable ne sera pas paramétrée.

Si vous souhaitez le comportement par défaut de git (avance-rapide si possible, sinon créer un commit de fusion) : git config --global pull.rebase "false"

Si vous souhaitez rebaser lors du tirage : git config --global pull.rebase "true"

Pousser son travail sur un dépôt distant

Lorsque votre dépôt vous semble prêt à être partagé, il faut le pousser en amont. La commande pour le faire est simple : git push <nom-distant> <nom-de-branche>. Si vous souhaitez pousser votre branche master vers le serveur origin (pour rappel, cloner un dépôt définit automatiquement ces noms pour vous), alors vous pouvez lancer ceci pour pousser votre travail vers le serveur amont :

$ git push origin master

Cette commande ne fonctionne que si vous avez cloné depuis un serveur sur lequel vous avez des droits d’accès en écriture et si personne n’a poussé dans l’intervalle. Si vous et quelqu’un d’autre clonez un dépôt au même moment et que cette autre personne pousse ses modifications et qu’après vous tentez de pousser les vôtres, votre poussée sera rejetée à juste titre. Vous devrez tout d’abord tirer les modifications de l’autre personne et les fusionner avec les vôtres avant de pouvoir pousser. Référez-vous au chapitre Les branches avec Git pour de plus amples informations sur les techniques pour pousser vers un serveur distant.

Inspecter un dépôt distant

Si vous souhaitez visualiser plus d’informations à propos d’un dépôt distant particulier, vous pouvez utiliser la commande git remote show [nom-distant]. Si vous lancez cette commande avec un nom court particulier, tel que origin, vous obtenez quelque chose comme :

$ git remote show origin
* distante origin
  URL de rapatriement : https://github.com/schacon/ticgit
  URL push : https://github.com/schacon/ticgit
  Branche HEAD : master
  Branches distantes :
    master suivi
    ticgit suivi
  Branche locale configurée pour 'git pull' :
    master fusionne avec la distante master
  Référence locale configurée pour 'git push' :
    master pousse vers master (à jour)

Cela donne la liste des URL pour le dépôt distant ainsi que la liste des branches distantes suivies. Cette commande vous informe que si vous êtes sur la branche master et si vous lancez git pull, il va automatiquement fusionner la branche master du dépôt distant après avoir récupéré toutes les références sur le serveur distant. Cela donne aussi la liste des autres références qu’il aura tirées.

Le résultat ci-dessus est un exemple simple mais réaliste de dépôt distant. Lors d’une utilisation plus intense de Git, la commande git remote show fournira beaucoup d’information :

$ git remote show origin
* distante origin
  URL: https://github.com/my-org/complex-project
  URL de rapatriement : https://github.com/my-org/complex-project
  URL push : https://github.com/my-org/complex-project
  Branche HEAD : master
  Branches distantes :
    master                           suivi
    dev-branch                       suivi
    markdown-strip                   suivi
    issue-43                         nouveau (le prochain rapatriement (fetch) stockera dans remotes/origin)
    issue-45                         nouveau (le prochain rapatriement (fetch) stockera dans remotes/origin)
    refs/remotes/origin/issue-11     dépassé (utilisez 'git remote prune' pour supprimer)
  Branches locales configurées pour 'git pull' :
    dev-branch fusionne avec la distante dev-branch
    master     fusionne avec la distante master
  Références locales configurées pour 'git push' :
    dev-branch                     pousse vers dev-branch        (à jour)
    markdown-strip                 pousse vers markdown-strip    (à jour)
    master                         pousse vers master            (à jour)

Cette commande affiche les branches poussées automatiquement lorsqu’on lance git push dessus. Elle montre aussi les branches distantes qui n’ont pas encore été rapatriées, les branches distantes présentes localement mais effacées sur le serveur, et toutes les branches qui seront fusionnées quand on lancera git pull.

Retirer et renommer des dépôts distants

Vous pouvez lancer git remote rename pour modifier le nom court d’un dépôt distant. Par exemple, si vous souhaitez renommer pb en paul, vous pouvez le faire avec git remote rename :

$ git remote rename pb paul
$ git remote
origin
paul

Il faut mentionner que ceci modifie aussi les noms de branches distantes. Celles qui étaient référencées sous pb/master le sont maintenant sous paul/master.

Si vous souhaitez retirer un dépôt distant pour certaines raisons — vous avez changé de serveur ou vous n’utilisez plus ce serveur particulier, ou peut-être un contributeur a cessé de contribuer — vous pouvez utiliser git remote rm :

$ git remote rm paul
$ git remote
origin

Une fois que vous avez supprimé la référence à un dépôt distant de cette manière, toutes les branches de suivi à distance et les réglages de configuration associés à ce dépôt distant sont aussi effacés.

scroll-to-top