-
1. Démarrage rapide
-
2. Les bases de Git
-
3. Les branches avec Git
-
4. Git sur le serveur
- 4.1 Protocoles
- 4.2 Installation de Git sur un serveur
- 4.3 Génération des clés publiques SSH
- 4.4 Mise en place du serveur
- 4.5 Démon (Daemon) Git
- 4.6 HTTP intelligent
- 4.7 GitWeb
- 4.8 GitLab
- 4.9 Git hébergé
- 4.10 Résumé
-
5. Git distribué
-
6. GitHub
-
7. Utilitaires Git
- 7.1 Sélection des versions
- 7.2 Indexation interactive
- 7.3 Remisage et nettoyage
- 7.4 Signer votre travail
- 7.5 Recherche
- 7.6 Réécrire l’historique
- 7.7 Reset démystifié
- 7.8 Fusion avancée
- 7.9 Rerere
- 7.10 Déboguer avec Git
- 7.11 Sous-modules
- 7.12 Empaquetage (bundling)
- 7.13 Replace
- 7.14 Stockage des identifiants
- 7.15 Résumé
-
8. Personnalisation de Git
- 8.1 Configuration de Git
- 8.2 Attributs Git
- 8.3 Crochets Git
- 8.4 Exemple de politique gérée par Git
- 8.5 Résumé
-
9. Git et les autres systèmes
- 9.1 Git comme client
- 9.2 Migration vers Git
- 9.3 Résumé
-
10. Les tripes de Git
- 10.1 Plomberie et porcelaine
- 10.2 Les objets de Git
- 10.3 Références Git
- 10.4 Fichiers groupés
- 10.5 La refspec
- 10.6 Les protocoles de transfert
- 10.7 Maintenance et récupération de données
- 10.8 Les variables d’environnement
- 10.9 Résumé
-
A1. Annexe A: Git dans d’autres environnements
- A1.1 Interfaces graphiques
- A1.2 Git dans Visual Studio
- A1.3 Git dans Visual Studio Code
- A1.4 Git dans IntelliJ / PyCharm / WebStorm / PhpStorm / RubyMine
- A1.5 Git dans Sublime Text
- A1.6 Git dans Bash
- A1.7 Git dans Zsh
- A1.8 Git dans PowerShell
- A1.9 Résumé
-
A2. Annexe B: Embarquer Git dans vos applications
- A2.1 Git en ligne de commande
- A2.2 Libgit2
- A2.3 JGit
- A2.4 go-git
- A2.5 Dulwich
-
A3. Commandes Git
- A3.1 Installation et configuration
- A3.2 Obtention et création des projets
- A3.3 Capture d’instantané basique
- A3.4 Création de branches et fusion
- A3.5 Partage et mise à jour de projets
- A3.6 Inspection et comparaison
- A3.7 Débogage
- A3.8 Patchs
- A3.9 Courriel
- A3.10 Systèmes externes
- A3.11 Administration
- A3.12 Commandes de plomberie
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, Si vous souhaitez le comportement par défaut de git (avance-rapide si possible, sinon créer un commit de fusion) :
Si vous souhaitez rebaser lors du tirage :
|
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.