Chapters ▾ 2nd Edition

2.5 Git Basics - Werk met afgeleë bewaarplekke (remotes)

Werk met afgeleë bewaarplekke (remotes)

Om op enige Git-projek te kan saamwerk, moet jy weet hoe om jou afgeleë bewaarplekke (remote repositories) te bestuur. Afgeleë bewaarplekke (remote repositories) is weergawes van jou projek wat iewers op die internet of op 'n netwerk gehuisves word. Jy kan verskeie van hulle hê, waarvan elkeen oor die algemeen óf leesalleen (read-only) óf lees/skryf (read/write) vir jou is. Om met ander saam te werk, behels die bestuur van hierdie afgeleë bewaarplekke (remote repositories) en om data na en van hulle te push en te pull wanneer jy werk moet deel. Die bestuur van afgeleë bewaarplekke (remote repositories) sluit in om te weet hoe om afgeleë bewaarplekke (remote repositories) by te voeg, ongeldige remotes te verwyder, verskeie remote branches te bestuur en hulle as tracked of nie te definieer nie, en meer. In hierdie afdeling sal ons van hierdie remote-bestuursvaardighede dek.

Note
Afgeleë bewaarplekke (remote repositories) kan op jou plaaslike masjien wees.

Dit is heeltemal moontlik dat jy met 'n “remote” bewaarplek (remote repository) werk wat in werklikheid op dieselfde gasheer (host) is as waarop jy werk. Die woord “remote” impliseer nie noodwendig dat die bewaarplek iewers anders op die netwerk of internet is nie, net dat dit elders is. Om met so 'n afgeleë bewaarplek (remote repository) te werk, sal steeds al die standaard push-, pull- en fetch-bewerkings behels soos met enige ander remote.

Jou remotes wys

Om te sien watter remote bedieners jy opgestel het, kan jy die git remote opdrag uitvoer. Dit lys die kortname (shortnames) van elke remote-hanteerder wat jy gespesifiseer het. As jy jou bewaarplek gekloon het, behoort jy ten minste origin te sien — dit is die versteknaam wat Git gee aan die bediener waarvan jy gekloon het:

$ git clone https://github.com/schacon/ticgit
Cloning into 'ticgit'...
remote: Reusing existing pack: 1857, done.
remote: Total 1857 (delta 0), reused 0 (delta 0)
Receiving objects: 100% (1857/1857), 374.35 KiB | 268.00 KiB/s, done.
Resolving deltas: 100% (772/772), done.
Checking connectivity... done.
$ cd ticgit
$ git remote
origin

Jy kan ook -v spesifiseer, wat vir jou die URL’e wys wat Git vir die kortnaam gestoor het om gebruik te word wanneer daar na daardie remote gelees en geskryf word:

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

As jy meer as een remote het, lys die opdrag hulle almal. Byvoorbeeld, 'n bewaarplek met veelvuldige remotes om saam met verskeie medewerkers te werk, kan dalk so iets lyk:

$ 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)

Dit beteken ons kan bydraes van enige van hierdie gebruikers redelik maklik pull. Ons kan moontlik ook toestemming hê om na een of meer van hulle te push, alhoewel ons dit nie hier kan sien nie.

Let daarop dat hierdie remotes 'n verskeidenheid protokolle gebruik; ons sal meer hieroor dek in Git op 'n Bediener kry (Getting Git on a Server).

Afgeleë bewaarplekke (remote repositories) byvoeg

Ons het genoem en gedemonstreer hoe die git clone opdrag implisiet die origin remote vir jou byvoeg. Hier is hoe om 'n nuwe remote eksplisiet by te voeg. Om 'n nuwe afgeleë Git-bewaarplek (remote Git repository) by te voeg as 'n kortnaam waarna jy maklik kan verwys, voer git remote add <kortnaam> <url> uit:

$ 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)

Nou kan jy die string pb op die opdragreël gebruik in plaas van die hele URL. Byvoorbeeld, as jy al die inligting wil fetch wat Paul het, maar wat jy nog nie in jou bewaarplek het nie, kan jy git fetch pb uitvoer:

$ git fetch pb
remote: Counting objects: 43, done.
remote: Compressing objects: 100% (36/36), done.
remote: Total 43 (delta 10), reused 31 (delta 5)
Unpacking objects: 100% (43/43), done.
From https://github.com/paulboone/ticgit
 * [new branch]      master     -> pb/master
 * [new branch]      ticgit     -> pb/ticgit

Paul se master branch is nou plaaslik toeganklik as pb/master — jy kan dit in een van jou branches merge, of jy kan 'n plaaslike branch op daardie punt checkout as jy dit wil inspekteer. Ons sal in baie meer detail in Git Branching oorgaan wat branches is en hoe om dit te gebruik.

Vanaf jou remotes fetch en pull

Soos jy pas gesien het, om data van jou remote projekte te kry, kan jy die volgende uitvoer:

$ git fetch <remote>

Die opdrag gaan na daardie remote projek en haal al die data van daardie remote projek af wat jy nog nie het nie. Nadat jy dit gedoen het, behoort jy verwysings te hê na al die branches van daardie remote, wat jy enige tyd kan merge of inspekteer.

As jy 'n bewaarplek (repository) kloon, voeg die opdrag daardie afgeleë bewaarplek (remote repository) outomaties by onder die naam “origin”. Dus, git fetch origin fetch enige nuwe werk wat na daardie bediener gepush is sedert jy dit gekloon het (of laas daarvan gefetch het). Dit is belangrik om daarop te let dat die git fetch opdrag slegs die data na jou plaaslike bewaarplek (local repository) aflaai — dit merge dit nie outomaties met enige van jou werk of verander dit waaraan jy tans werk nie. Jy moet dit met die hand in jou werk merge wanneer jy gereed is.

As jou huidige branch opgestel is om 'n remote branch te track (sien die volgende afdeling en Git Branching vir meer inligting), kan jy die git pull opdrag gebruik om daardie remote branch outomaties te fetch en dan in jou huidige branch te merge. Dit kan dalk 'n makliker of gemakliker werkvloei vir jou wees; en by verstek stel die git clone opdrag outomaties jou plaaslike master branch op om die remote master branch (of wat die verstek-branch ook al genoem word) te track op die bediener waarvan jy gekloon het. Om git pull uit te voer, fetch oor die algemeen data van die bediener af waarvan jy oorspronklik gekloon het en probeer outomaties om dit te merge in die kode waaraan jy tans werk.

Note

Vanaf Git weergawe 2.27 sal git pull 'n waarskuwing gee as die pull.rebase veranderlike nie gestel is nie. Git sal aanhou om jou te waarsku totdat jy die veranderlike stel.

As jy die verstekgedrag van Git wil hê (fast-forward as dit moontlik is, andersins skep 'n merge commit): git config --global pull.rebase "false"

As jy wil rebase wanneer jy pull: git config --global pull.rebase "true"

Na jou remotes push

Wanneer jou projek by 'n punt is waar jy dit wil deel, moet jy dit stroomop (upstream) push. Die opdrag hiervoor is eenvoudig: git push <remote> <branch>. As jy jou master branch na jou origin bediener wil push (weereens, kloning stel oor die algemeen albei daardie name outomaties vir jou op), dan kan jy hierdie uitvoer om enige commits wat jy gedoen het terug op die bediener te push:

$ git push origin master

Hierdie opdrag werk slegs as jy gekloon het van 'n bediener waartoe jy skryftoegang het en as niemand intussen gepush het nie. As jy en iemand anders terselfdertyd kloon en hulle push upstream en dan push jy upstream, sal jou push tereg verwerp word. Jy sal eers hul werk moet fetch en dit by joune inkorporeer voordat jy toegelaat sal word om te push. Sien Git Branching vir meer gedetailleerde inligting oor hoe om na remote bedieners te push.

'n Remote inspekteer

As jy meer inligting oor 'n spesifieke remote wil sien, kan jy die git remote show <remote> opdrag gebruik. As jy hierdie opdrag met 'n spesifieke kortnaam uitvoer, soos origin, kry jy iets soos hierdie:

$ git remote show origin
* remote origin
  Fetch URL: https://github.com/schacon/ticgit
  Push  URL: https://github.com/schacon/ticgit
  HEAD branch: master
  Remote branches:
    master                               tracked
    dev-branch                           tracked
  Local branch configured for 'git pull':
    master merges with remote master
  Local ref configured for 'git push':
    master pushes to master (up to date)

Dit lys die URL vir die afgeleë bewaarplek (remote repository) asook die tracking branch inligting. Die opdrag vertel jou behulpsaam dat as jy op die master branch is en jy git pull uitvoer, dit outomaties die remote se master branch in die plaaslike een sal merge nadat dit gefetch is. Dit lys ook al die remote verwysings wat dit gepull het.

Dit is 'n eenvoudige voorbeeld wat jy waarskynlik sal teëkom. Wanneer jy Git egter meer intensief gebruik, sal jy dalk baie meer inligting by git remote show sien:

$ git remote show origin
* remote origin
  URL: https://github.com/my-org/complex-project
  Fetch URL: https://github.com/my-org/complex-project
  Push  URL: https://github.com/my-org/complex-project
  HEAD branch: master
  Remote branches:
    master                           tracked
    dev-branch                       tracked
    markdown-strip                   tracked
    issue-43                         new (next fetch will store in remotes/origin)
    issue-45                         new (next fetch will store in remotes/origin)
    refs/remotes/origin/issue-11     stale (use 'git remote prune' to remove)
  Local branches configured for 'git pull':
    dev-branch merges with remote dev-branch
    master     merges with remote master
  Local refs configured for 'git push':
    dev-branch                     pushes to dev-branch                     (up to date)
    markdown-strip                 pushes to markdown-strip                 (up to date)
    master                         pushes to master                         (up to date)

Hierdie opdrag wys na watter branch daar outomaties gepush word wanneer jy git push uitvoer terwyl jy op sekere branches is. Dit wys ook vir jou watter remote branches op die bediener jy nog nie het nie, watter remote branches jy het wat van die bediener verwyder is, en verskeie plaaslike branches wat outomaties met hul remote-tracking branch kan merge wanneer jy git pull uitvoer.

Remotes hernoem en verwyder

Jy kan git remote rename uitvoer om 'n remote se kortnaam te verander. Byvoorbeeld, as jy pb na paul wil hernoem, kan jy dit doen met git remote rename:

$ git remote rename pb paul
$ git remote
origin
paul

Dit is die moeite werd om te noem dat dit al jou remote-tracking branch name ook verander. Wat voorheen na verwys is as pb/master, is nou paul/master.

As jy om een of ander rede 'n remote wil verwyder — jy het die bediener geskuif of gebruik nie meer 'n spesifieke spieël (mirror) nie, of miskien dra 'n medewerker nie meer by nie — kan jy óf git remote remove óf git remote rm gebruik:

$ git remote remove paul
$ git remote
origin

Sodra jy die verwysing na 'n remote op hierdie manier uitvee, word alle remote-tracking branches en konfigurasie-instellings wat met daardie remote geassosieer word, ook uitgevee.