Git Remote: een complete gids met voorbeelden

Git is een populair versiebeheersysteem (VCS) dat in softwareontwikkeling wordt gebruikt om wijzigingen in bestanden in de tijd bij te houden. Het faciliteert samenwerking doordat ontwikkelaars gelijktijdig kunnen werken zonder elkaars bijdragen te overschrijven. Omdat alle ontwikkelaars volledige lokale kopieën van de projectgeschiedenis behouden, kan iedereen onafhankelijk offline werken en hun wijzigingen veilig mergen wanneer ze daar klaar voor zijn.

Een remote repository, of remote, is een versie van je Git-project die in de cloud gehost wordt via een online dienst zoals GitHub of BitBucket.

In dit artikel duiken we dieper in Git-remotes. Als je net begint met Git, lees dan ook onze Git-tutorial voor beginners. 

Wat is een Git Remote?

Een Git-remote biedt een centrale locatie waar een repository kan worden opgeslagen, gedeeld en door anderen benaderd. Gebruikers kunnen hun lokale wijzigingen naar de remote pushen en updates die teamgenoten hebben gemaakt vanaf de remote pullen. Remotes zijn ook handig voor het back-uppen van code en het deployen van code naar productieomgevingen.

Een lokale repository staat op je eigen computer, zodat je lokaal code kunt schrijven, commits kunt maken en wijzigingen kunt testen. Een remote repository, die online staat, wordt gebruikt om code te delen, samen te werken met anderen en je werk te back-uppen. In dit artikel bekijken we hoe je wijzigingen tussen lokale en remote repos synchroniseert met Git-commando’s.

Git-workflow

Een typische Git-workflow begint met het “clonen” van een remote repository naar je lokale machine. Na het clonen maak je mogelijk een nieuwe branch om aan een feature of fix te werken, breng je wijzigingen aan en commit je die lokaal. 

Wanneer je werk klaar is, “push” je de branch naar de remote en open je een pull request voor review. Na goedkeuring merge je de wijzigingen in de main-branch. 

Gedurende het proces “pull” je regelmatig updates om je lokale repository in sync te houden met de remote.

Een typische Git-workflow (Afbeelding uit de cursus Introduction to Git)

Laten we dit proces in meer detail bekijken.

Een repo clonen

Stel dat je een kopie wilt maken van een remote repository, een proces dat “clonen” van de repo wordt genoemd. Met een lokale kopie kun je de code aanpassen en nieuwe features testen.

Om Git te gebruiken, zorg dat het is geïnstalleerd, open vervolgens een terminal en gebruik dit commando: git clone <URL>.

Om bijvoorbeeld een project met de naam “project” te clonen van een GitHub-pagina met gebruikersnaam “datacamp”, gebruik je

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

Standaard-remote: 'origin'

Wanneer je een repository clonet, maakt Git een standaard-remote met de naam origin. Dit label origin fungeert als alias voor de URL van de repository waar je van hebt gecloned.

In typische Git-workflows, wanneer je commando’s zoals git push of git pull uitvoert, gaat Git ervan uit dat je naar origin verwijst, tenzij je een andere remote specificeert. Dit vereenvoudigt het synchroniseren van wijzigingen tussen je lokale kopie en de gedeelde repository. Later in dit artikel kijken we nader naar pushen en pullen.

Git-remotes beheren

Veelvoorkomende beheeracties zijn het bekijken van bestaande remotes met git remote en het toevoegen van een nieuwe remote met git remote add.

Bestaande remotes bekijken

Gebruik het commando git remote om bestaande remotes te bekijken. 

git remote
>> origin

In ons voorbeeld wordt het remote-alias origin weergegeven, maar de URL niet. Als je de URL die aan elke remote is gekoppeld wilt zien, gebruik dan de -v-vlag.

git remote -v
>> origin	https://github.com/datacamp/project.git (fetch)
>> origin	https://github.com/datacamp/project.git (push)

Een nieuwe remote toevoegen

Het kan zijn dat je je lokale repository wilt verbinden met een andere remote. Als je bijvoorbeeld een project hebt geforkt, wil je naast wijzigingen aan de main-remote ook wijzigingen in de originele repository bijhouden. Of je wilt je code naar meerdere platforms pushen, zoals GitHub en GitLab.

Gebruik het commando git remote add <name> <URL> om een nieuwe remote toe te voegen. Laten we een nieuwe remote toevoegen met de naam new_remote.

git remote add new_remote https://github.com/datacamp/project

Een remote een naam geven is handig zodat je bij het mergen niet steeds de URL hoeft te typen.

Remotes hernoemen en verwijderen

Een remote hernoemen is eenvoudig. Gebruik het commando git remote rename <old-name> <new-name>.​ Bijvoorbeeld,

git remote rename new_remote original_remote

Gebruik git remote om te verifiëren dat de remote is hernoemd.

Om een remote te verwijderen, gebruik je git remote remove <name>.​ Voor ons voorbeeld:

git remote remove new_remote

Lijst nu de remotes om te verifiëren.

git remote
>> origin

We zien dat de enige remote origin is.

Werken met remote branches

Een branch in Git is een pad onafhankelijk van main waarmee je los van de hoofdversie van je project aan wijzigingen kunt werken. Zodra je werk klaar is en beoordeeld, kun je de branch terug mergen in het hoofdproject.

Remote branches opvragen

Om remote branches te tonen gebruiken we het commando git branch -r.

git branch -r
>> origin/HEAD -> origin/main
>> origin/main

Laten we de output interpreteren. De regel origin/main geeft aan dat er een remote branch main bestaat op de remote origin. De regel origin/HEAD -> origin/main laat zien dat de standaardbranch op de remote origin/main is. Deze output vertelt je dus dat main de standaardbranch is op de origin-remote, en dat dit momenteel de enige remote branch is die wordt vermeld.

Een remote branch tracken

Je wilt vaak een lokale branch koppelen aan een remote branch om je code in sync te houden. Wanneer een lokale branch een remote branch trackt, kun je wijzigingen pullen en pushen zonder elke keer de remote- en branchnamen te hoeven opgeven. 

Git houdt ook bij hoeveel commits je lokale branch vóór- of achterloopt op de remote, wat het beheren van wijzigingen makkelijker maakt.

Het commando git checkout --track origin/<branch-name> maakt een nieuwe lokale branch die de opgegeven remote branch trackt. Het zet een lokale branch op met dezelfde naam als <branch-name> en koppelt die aan de remote-versie. Zo zullen toekomstige git pull- en git push-commando’s automatisch met de juiste remote branch werken. Je kunt meer leren over Git Push en Pull in onze tutorial. 

Fetch en pullen van remotes

Om je lokale branch gesynchroniseerd te houden met de wijzigingen van andere ontwikkelaars, moet je content in je lokale branch pullen. “Pullen” betekent de nieuwste wijzigingen van de corresponderende branch op de remote downloaden en die in je lokale versie van die branch mergen. Zo werk je met de meest actuele code.

Stel dat we alle branches willen ophalen van de remote met de naam origin. Dit doe je met het commando git fetch origin. Als je slechts één specifieke branch wilt fetchen, zoals main, specificeer die dan, zoals in git fetch origin main.

Na het fetchen moet je nog synchroniseren door de opgehaalde wijzigingen in je huidige lokale branch te mergen. Voer hiervoor git merge origin/<branch-name> uit, waarbij je <branch-name> vervangt door de naam van de branch die je hebt gefetched. Om bijvoorbeeld wijzigingen van de remote main-branch te mergen, gebruik je git merge origin/main.

Omdat het gebruikelijk is om fetch en merge na elkaar te doen, biedt Git één commando dat beide uitvoert: git pull. Om bijvoorbeeld wijzigingen van de main-branch op de remote origin op te halen en te mergen, kun je git pull origin main gebruiken.

Wanneer gebruik je fetch en merge en wanneer gebruik je pull? Het tweestapsproces van fetch en merge geeft je meer controle over het updateproces. Met fetch kun je zien wat er op de remote is veranderd voordat je het in je lokale branch merget. Dit is handig als je updates wilt reviewen, verschillen wilt vergelijken of mogelijke conflicten zorgvuldig wilt afhandelen. 

Gebruik pull wanneer je zeker weet dat de remote-wijzigingen meteen veilig te mergen zijn en je je branch snel wilt bijwerken. Het is handig en combineert beide stappen in één, maar geeft je minder zicht voorafgaand aan de merge.

Pushen naar een remote repository

“Pushen” van content naar een remote vanaf een lokale branch betekent dat je je lokale wijzigingen naar de corresponderende branch op de remote repository stuurt. Dit werkt de remote bij met je nieuwste werk zodat anderen het kunnen zien, pullen of erop kunnen voortbouwen. Pushen deelt je bijdrage en helpt de remote repository up-to-date te houden voor iedereen die aan het project werkt.

Lokale wijzigingen naar de remote uploaden is een proces in drie stappen.

1. Gebruik git add om de bestanden te stagen die je wilt meenemen. Om alle wijzigingen toe te voegen, gebruik je

git add

Om een specifiek bestand toe te voegen, geef je de bestandsnaam op.

git add <filename>

2. Commit je wijzigingen. Voeg een bericht toe om te beschrijven wat je hebt gedaan.

git commit -m “Your commit message here”

3. Push naar de remote.

git push origin branch-name

Praktische voorbeelden

Laten we enkele praktische voorbeelden bekijken: een repo clonen en samenwerken met meerdere remotes.

Een repository clonen

Hier is een stapsgewijze handleiding voor het clonen van een repo.

1. Haal de repository-URL op. Kopieer de URL van de repository die je wilt clonen. Deze URL is beschikbaar bij je cloudprovider, zoals GitHub of BitBucket.
2. Kies een map. Navigeer naar de map op je computer waar je de repo gekopieerd wilt hebben.
3. Clone de repository. Voer het commando git clone <URL> uit. Voer bijvoorbeeld git clone https://github.com/datacamp/project uit.Dit maakt een nieuwe map met de naam project met de repo-inhoud erin.
4. Geconfigureerde remotes tonen. Controleer na het clonen de remotes met het commando git remote.In ons voorbeeld zie je origin, de standaardnaam die Git geeft aan de remote waar je van hebt gecloned en de bijbehorende URL.

Samenwerken met meerdere remotes

Wanneer je bijdraagt aan een open-sourceproject of samenwerkt via een persoonlijke kopie (fork), is het gebruikelijk om met twee remotes te werken: origin, jouw fork van de repo, en upstream, de repo waarvan je hebt geforkt. Meestal heb je schrijfrechten op origin maar niet op upstream.

Er zijn enkele best practices voor het beheren van meerdere remotes om in gedachten te houden.

1. Voeg de upstream-remote toe. Houd na het clonen van je fork de originele repo bij als upstream:git remote add upstream <URL>.
2. Houd je fork up-to-date. Fetch regelmatig wijzigingen van de upstream-repo met het commando git fetch upstream. Merge of rebase vervolgens die wijzigingen in je lokale branch.
3. Vermijd pushen naar de upstream-repo. Meestal heb je geen (of geen nood aan) push-toegang tot de upstream-repo. Al je wijzigingen moeten naar origin worden gepusht, en pull requests maak je van daaruit.
4. Gebruik beschrijvende branchnamen. Houd je lokale branches georganiseerd. Het is een goed idee ze te vernoemen naar de feature of issue waaraan je werkt.
5. Controleer je remotes. Gebruik git remote -v om je remote-instellingen te bekijken en te verifiëren dat de URL’s voor origin en upstream kloppen.
6. Blijf in sync voordat je begint met werken. Pull altijd de nieuwste wijzigingen van upstream in je main-branch voordat je nieuw werk start, zodat je up-to-date blijft en latere conflicten voorkomt.

Best practices en tips voor Git Remote

Hier zijn enkele best practices die je moet volgen bij het gebruik van Git-remote: 

Remotes up-to-date houden

Regelmatig wijzigingen fetchen helpt om je lokale kopie van de repository up-to-date te houden met de remote-versie. Door git fetch uit te voeren, download je nieuwe wijzigingen van de remote zonder je huidige branch te beïnvloeden. 

Dit houdt je op de hoogte van wat collega’s hebben gepusht, laat je wijzigingen vergelijken en helpt je je voor te bereiden op benodigde updates of merges. Consistent fetchen verkleint de kans op conflicten en houdt je samenwerkingsworkflow soepel.

Na verloop van tijd, wanneer branches in de remote repository worden verwijderd, kan je lokale Git-instelling die oude branches nog steeds tonen als remote-tracking branches. Dit worden “verouderde” remote-tracking branches genoemd. 

Voer git remote prune origin uit om je branches op te schonen en remote-tracking branches te verwijderen die niet langer bestaan op de origin-remote. 

Dit regelmatig doen helpt je lokale repository georganiseerd te houden, maakt het eenvoudiger om relevante branches te vinden en zorgt ervoor dat je niet naar verouderd werk verwijst.

Conflicten met remotes afhandelen

Remote-conflicten kunnen lastig op te lossen zijn. De beste oplossing is voorkomen door ervoor te zorgen dat niet meerdere mensen tegelijk aan dezelfde delen van de code werken. Maar dit is niet altijd mogelijk. 

Ondanks de beste bedoelingen kunnen conflicten toch ontstaan. Volg in dat geval dit stappenplan om ze effectief af te handelen.

1. Gebruik git status om te zien welke conflicten je aandacht vragen.
2. Open de conflicterende bestanden en bewerk ze om de wijzigingen op te lossen.
3. Gebruik een merge-tool. Tools zoals VS Code of git mergetool tonen vergelijkingen naast elkaar en laten je kiezen welke versie van de code je wilt behouden.
4. Communiceer met het team. Als het conflict onduidelijk is, check dan met je collega’s voordat je het oplost. Zorg dat je begrijpt welke regels je moet behouden en welke je moet verwijderen.
5. Test je code nadat je het conflict hebt opgelost om te verzekeren dat niets stuk is en alles werkt zoals verwacht.
6. Commit je wijzigingen. Nadat alle conflicten zijn opgelost, stage je de bestanden en maak je een commit om de merge te voltooien.

Rebase

Het gebruik van git pull --rebase kan de kans op complexe merge-conflicten verkleinen door jouw wijzigingen boven op de laatste remote-commits toe te passen.

Wanneer je git pull --rebase gebruikt, fetcht Git eerst de nieuwste wijzigingen van de remote en past vervolgens jouw lokale commits daarbovenop toe, alsof jouw werk daarna heeft plaatsgevonden.

Deze aanpak helpt een schonere, lineaire commitgeschiedenis te creëren en kan de kans op rommelige merge-conflicten verkleinen.

In plaats van een merge-commit te maken die de geschiedenissen combineert, laat rebase het lijken alsof jouw wijzigingen na de remote-updates zijn gedaan. Je kunt meer leren in onze Git Rebase-tutorial. 

Conclusie

Git-remotes zijn cruciaal voor collaboratieve ontwikkeling en verbinden lokale repositories met gedeelde codebases. In deze gids hebben we essentiële remote-operaties behandeld, waaronder het opzetten, synchroniseren via de commando’s fetch, pull en push, en het beheren van meerdere remote-verbindingen.

Het beheersen van de concepten die we hebben behandeld, helpt je efficiënter samen te werken, een heldere projectgeschiedenis te behouden en bij te dragen aan je developmentteam.

Voor meer informatie over git-remote-branches, bekijk de resources van DataCamp.

• Git Checkout Remote Branch: stapsgewijze gids 
• Git Push en Pull-tutorial
• Git Pull Force: hoe je een lokale branch overschrijft met remote
• Cursus Introduction to Git
• Cursus Intermediate Git 
• Cursus Advanced Git
• Introduction to GitHub Concepts
• GitHub en Git-tutorial voor beginners
• Hoe leer je Git in 2025: een complete gids voor beginners
• Git-cheatsheet