Go-modules en afhankelijkheidsbeheer

Inleiding tot afhankelijkheidsbeheer in Go

Afhankelijkhedenbeheer is een kritisch aspect van elk softwareproject, omdat het helpt bij het beheren van de versies van bibliotheken en pakketten waar je project op vertrouwt. In Go (Golang) zorgt afhankelijkhedenbeheer ervoor dat je Go-projecten reproduceerbaar en onderhoudbaar zijn door het gemakkelijker te maken om versieproblemen op te lossen, compatibiliteit met andere pakketten te behouden en het algehele ontwikkelproces te stroomlijnen.

Voor Go Modules was het beheer van afhankelijkheden in Go minder gestroomlijnd. Ontwikkelaars namen vaak hun toevlucht tot tools zoals dep, glide of govendor om hun afhankelijkheden te beheren. Hoewel deze tools nuttig waren, maakten ze geen deel uit van het officiële Go-project en zorgden ze dus voor frictie bij de adoptie van Go als taal voor sommige ontwikkelaars.

Het tijdperk van Go-modules

In 2018 introduceerde het Go-team het concept van "modules", een nieuwe standaard voor het beheer van afhankelijkheden in Go-projecten. Modules zijn verzamelingen van gerelateerde pakketten die samen in versie worden gebracht en zo alle noodzakelijke afhankelijkheden voor je codebase bieden. Met de introductie van Go Modules in Go 1.11 werd afhankelijkhedenbeheer eenvoudiger, veelzijdiger en officieel ondersteund door het Go-project. Go Modules introduceerde functies zoals:

• Versiebeheer van afhankelijkheden met behulp van Semantic Versioning (SemVer)
• Vereenvoudigde commando's voor het beheer van afhankelijkheden (bijv. go get, go mod tidy)
• Automatisch genereren van een manifestbestand(go.mod) met gedetailleerde afhankelijkheidsinformatie
• Automatisch downloaden en cachen van vereiste afhankelijkheden

Met Go Modules ben je niet langer verplicht om je code in de $GOPATH map te plaatsen, wat voorheen een beperking was bij het ontwikkelen van Go. Dit nieuwe systeem maakt een flexibelere projectstructuur mogelijk, waardoor het gemakkelijker wordt om aan Go-projecten te werken wanneer je tussen verschillende repositories schakelt.

Je Go-moduleproject opzetten

Aan de slag gaan met Go Modules is eenvoudig. Volg de onderstaande stappen om een nieuw Go Modules project op te zetten.

1. Zorg er eerst voor dat je Go versie 1.11 of later op je systeem hebt geïnstalleerd. Je kunt je Go-versie controleren door go version uit te voeren in de terminal.
2. Ga naar de gewenste locatie en maak een nieuwe projectmap aan met een beschrijvende naam, bijvoorbeeld my-go-project.
3. Navigeer naar de nieuw aangemaakte map in de opdrachtregel.
4. Initialiseer een nieuwe Go-module door het commando go mod init uit te voeren, gevolgd door het pad van de module. Je kunt bijvoorbeeld go mod init github.com/uw-gebruikersnaam/mijn-go-project uitvoeren als je van plan bent om het project op GitHub te hosten. Dit commando genereert een nieuw bestand met de naam go.mod in je project map.

Het go.mod bestand is het hart van je Go Modules project. Het bevat metadata over de module, zoals de naam, en geeft een lijst van alle afhankelijkheden die het nodig heeft. Je zult het go.mod bestand gedurende de levenscyclus van je Go project gebruiken om je afhankelijkheden te beheren. Nu je Go-moduleproject is opgezet, ben je klaar om te beginnen met het toevoegen en beheren van afhankelijkheden met behulp van het Go-modulesysteem.

Afhankelijkheden beheren binnen Go Modules

Go Modules bieden een eenvoudige en effectieve aanpak om de afhankelijkheden van je project te beheren. Je kunt specifieke versies van afhankelijkheden toevoegen, bijwerken of verwijderen, waardoor je controle houdt over je project en de interacties met andere pakketten. Dit hoofdstuk leidt je door het proces van het beheren van afhankelijkheden binnen je Go Modules project.

Een afhankelijkheid toevoegen

Om een nieuwe afhankelijkheid toe te voegen, hoef je alleen maar het gewenste pakket in je Go-code te importeren. Als je bijvoorbeeld github.com/gorilla/mux wilt toevoegen aan je project, importeer je het als volgt:

import ( "github.com/gorilla/mux" )

De volgende keer dat je go build of go test uitvoert, zal Go automatisch het benodigde pakket downloaden, de bestanden go.mod en go.sum bijwerken en je project configureren om het gespecificeerde pakket te gebruiken. Je kunt ook het commando go get gebruiken om expliciet een nieuwe afhankelijkheid toe te voegen:

go get github.com/gorilla/mux

Dit zal niet alleen het pakket ophalen, maar ook de go.mod en go.sum bestanden van je project bijwerken.

Een afhankelijkheid bijwerken

Om een specifieke afhankelijkheid bij te werken naar een nieuwe versie, gebruik je het commando go get gevolgd door het importpad van het pakket en het gewenste versienummer:

go get github.com/gorilla/[email protected]

Deze opdracht zal het go.mod bestand bijwerken met de nieuwe versie van het pakket en de broncode downloaden. Merk op dat als het bijgewerkte pakket brekende veranderingen introduceert, u mogelijk uw code dienovereenkomstig moet aanpassen.

Een afhankelijkheid verwijderen

Om een afhankelijkheid uit je project te verwijderen, verwijder je eerst de overeenkomstige importverklaringen uit je broncode. Voer daarna het commando go mod tidy uit om het bestand go.mod op te ruimen:

Try AppMaster today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

go mod tidy

Dit commando verwijdert alle ongebruikte afhankelijkheden uit het go.mod bestand en zorgt ervoor dat je project schoon en georganiseerd blijft.

Semantische versiebeheer en Go-modules

Semantic Versioning (SemVer) is een veelgebruikt versiebeheersysteem dat unieke versienummers toekent aan softwarereleases. Het gebruikt een driedelige nummerindeling: Major.Minor.Patch (bijvoorbeeld 1.2.3). In SemVer:

• Grote versieveranderingen geven brekende veranderingen aan en vereisen handmatige code-aanpassingen.
• Kleine versieveranderingen introduceren nieuwe functies terwijl ze achterwaarts compatibel blijven.
• Patch versie veranderingen bevatten bug fixes en kleine prestatieverbeteringen, ook achterwaarts compatibel.

Go Modules bevat Semantic Versioning om versiebeheer van afhankelijkheden af te handelen, waardoor ontwikkelaars updates, achterwaartse compatibiliteit en wijzigingen gemakkelijker kunnen beheren. Bij het specificeren van afhankelijkheidsversies met Go Modules kun je versiebereiken of specifieke versienummers gebruiken. Bijvoorbeeld: - Om de laatste stabiele versie van een pakket op te halen, gebruikt u het pakketimportpad zonder versienummer: go get github.com/gorilla/mux. - Om een specifieke versie op te halen, voeg je het versienummer toe na het @ symbool: go get github.com/gorilla/[email protected].- Om de laatste minor of patch update binnen een specifieke hoofdversie op te halen, gebruik je het ^ (caret) symbool: go get github.com/gorilla/mux@^v1.0.0.

Algemene Go Modules commando's en hun gebruik

Hier zijn enkele van de meest gebruikte Go Modules commando's en hun gebruiksscenario's:

go mod init

go mod init initialiseert een nieuw Go Modules project in de huidige map. Het genereert een go.mod bestand, dat informatie bevat over de module, zijn afhankelijkheden en versiebeperkingen.

go mod init voorbeeld.com/myproject

Vervang example.com/myproject door het pad van je module.

go get

go get is een veelzijdig commando dat wordt gebruikt om een afhankelijkheid toe te voegen, bij te werken of te verwijderen. Geef het pad op voor het importeren van het pakket, optioneel gevolgd door een versienummer of een bereik.

go get github.com/gorilla/[email protected]

Dit commando voegt het github.com/gorilla/mux pakket toe of werkt het bij naar versie v1.8.0.

go mod tidy

go mod tidy verwijdert ongebruikte afhankelijkheden uit het go.mod bestand en werkt het bij om de import verklaringen in de broncode van je project weer te geven.

go mod tidy

Voer dit commando uit na het verwijderen van importverklaringen voor ongewenste afhankelijkheden.

go mod grafiek

go mod graph geeft de afhankelijkheidsstructuur van het project weer en toont zowel directe als indirecte afhankelijkheden in een leesbaar formaat. Dit commando kan handig zijn bij het debuggen van complexe afhankelijkheidsproblemen.

go mod grafiek

go mod verifiëren

go mod verify controleert de integriteit van de afhankelijkheden in het bestand go.sum. Als de checksum van een afhankelijkheid niet overeenkomt met de opgenomen waarde, zal het commando een fout melden.

go mod verifiëren

Afhankelijkheidsconflicten oplossen

Afhankelijkheidsconflicten kunnen ontstaan wanneer je project afhankelijk is van meerdere pakketten met verschillende versievereisten voor gedeelde afhankelijkheden. Go Modules biedt een ingebouwd mechanisme om deze conflicten op te lossen met behulp van de richtlijnen replace en exclude in het bestand go.mod.

De vervang richtlijn

Met de vervang richtlijn kun je de versie van een module wijzigen in een andere versie of deze toewijzen aan een lokaal pad. Dit kan handig zijn in situaties waar je specifieke versies, gevorkte projecten of lokale wijzigingen moet testen voordat je ze vastlegt in een remote repository. Om de replace richtlijn te gebruiken, voeg je de volgende regel toe aan je go.mod bestand:

replace example.com/original/module v1.2.3 => example.com/new/module v1.4.0

Dit vervangt example.com/original/module versie v1.2.3 door example.com/new/module versie v1.4.0. Je kunt een module ook vervangen door een lokaal pad:

vervang example.com/original/module v1.2.3 => ../local/path/to/new/module

De richtlijn uitsluiten

Je kunt de richtlijn uitsluiten gebruiken om te voorkomen dat specifieke versies van een module in je project worden gebruikt. Dit is handig als je weet dat een bepaalde versie compatibiliteitsproblemen of beveiligingslekken heeft. Om een versie van een module uit te sluiten, voeg je de volgende regel toe aan je go.mod bestand:

exclude example.com/target/module v1.2.3

Vergeet niet om go mod tidy uit te voeren na het toepassen van deze wijzigingen om het go.sum bestand bij te werken en de afhankelijkheidsstructuur opnieuw te berekenen.

Privé Go modules en archiefbeheer

Het werken met private Go modules en repositories is vergelijkbaar met het werken met publieke, maar er zijn enkele extra stappen om de juiste authenticatie en privacy te garanderen.

GOPRIVATE configureren

Om het lekken van importpaden naar publieke servers te voorkomen, configureer je de GOPRIVATE omgevingsvariabele. Deze variabele specificeert een door komma's gescheiden lijst van importpad patronen voor privé repositories.

go env -w GOPRIVATE=voorbeeld.nl/private/path/*

Toegangstokens gebruiken

Om privé repositories te gebruiken, moet je je meestal authenticeren bij je broncode hosting service, zoals GitHub of GitLab. Maak een persoonlijk toegangstoken aan met geschikte rechten (zoals repo scope voor GitHub). Raadpleeg de documentatie van je hostingservice voor de specifieke stappen om een toegangstoken aan te maken. Na het verkrijgen van het toegangstoken, configureer je de omgevingsvariabele voor authenticatie. Gebruik de juiste omgevingsvariabele gebaseerd op je VCS service.

Try AppMaster today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

export GIT_TERMINAL_PROMPT=0 export GITHUB_TOKEN=JOUW_ACCESS_TOKEN

Hierdoor kan het go commando privé repositories downloaden en verifiëren als Go Modules. Als je met meerdere VCS diensten werkt, kun je individuele toegangstokens voor elk configureren door indien nodig aparte omgevingsvariabelen te definiëren.

Migreren van vorige afhankelijkheidsbeheersystemen

Vóór Go Modules waren er verschillende systemen voor het beheren van afhankelijkheden, zoals Dep, glide of aangepaste oplossingen voor leveranciersdirectories. Als je deze systemen nog steeds gebruikt, is het tijd om te migreren naar Go Modules om up-to-date te blijven en de voordelen van modern Golang afhankelijkhedenbeheer te benutten. Om te migreren van een vorig afhankelijkhedenbeheersysteem naar Go Modules, volgt u deze stappen:

1. Maak een back-up van je oorspronkelijke project om er zeker van te zijn dat je terug kunt keren naar de vorige staat als dat nodig is.
2. Verwijder alle bestaande bestanden voor afhankelijkheidbeheer (bijvoorbeeld Gopkg.toml of Gopkg.lock).
3. Navigeer naar de root van je project in een terminal en voer go mod init uit om een nieuw go.mod bestand aan te maken. Dit zal ook proberen om je vorige dependency bestand, indien aanwezig, te converteren naar Go Modules entries.
4. Voer go mod tidy uit om het go.mod bestand te vullen met afhankelijkheden van uw vorige systeem. Dit commando zorgt ervoor dat alleen noodzakelijke pakketten deel uitmaken van de afhankelijkheidsstructuur.
5. Op dit punt kan het nodig zijn om aanpassingen te maken in uw go.mod bestand om afhankelijkheidsconflicten op te lossen of om specifieke versies af te dwingen. Gebruik de replace en exclude directieven om deze problemen op te lossen.
6. Controleer of je project nog steeds bouwt en tests doorstaat zoals verwacht.

Door deze stappen te volgen, zou je project nu moeten werken met Go Modules, waardoor het beheer van afhankelijkheden gestroomlijnd wordt en het op de lange termijn beter te onderhouden is. Eventuele problemen zouden opgelost moeten worden door het bestand go.mod aan te passen of je importpaden te controleren om er zeker van te zijn dat ze het juiste formaat hebben.

AppMaster: Versnellen van Golang-gebaseerde applicatie ontwikkeling

Het integreren van Go Modules en dependency management best practices in je dagelijkse workflow is van vitaal belang om een onderhoudbaar en schaalbaar Golang-gebaseerd softwareproject te garanderen. Maar wat als je het hele applicatieontwikkelingsproces zou kunnen versnellen, terwijl je nog steeds de kracht van Golang gebruikt?

Enter AppMaster.io, een uitgebreid no-code platform met de nadruk op het genereren van Golang-gebaseerde backend applicaties met behulp van een visuele ontwikkelomgeving. Naast backendtoepassingen kunnen met AppMaster web- en mobiele toepassingen worden gemaakt met behulp van een geïntegreerde aanpak die is ontworpen om het ontwikkelingsproces te stroomlijnen.

Met AppMaster kunnen gebruikers datamodellen (databaseschema's) maken, bedrijfsprocessen ontwerpen en REST API en WebSocket endpoints definiëren via een visuele UI. Webapplicaties worden gemaakt met behulp van een drag-and-drop interface in combinatie met een Web Business Process designer voor een volledig interactieve gebruikerservaring. Mobiele applicaties worden op dezelfde manier ontworpen, met een mobiele Business Process designer en UI-ontwerpmogelijkheden.

AppMasterHet platform neemt je blauwdrukken en genereert broncode voor je applicaties zodra je op de knop 'Publiceren' drukt. Het compileert de applicaties, voert tests uit, verpakt ze in Docker-containers (voor back-end applicaties) en zet alles in de cloud, allemaal binnen enkele seconden.

Back-end applicaties worden gegenereerd met Golang (Go), waarbij we profiteren van de prestaties, eenvoud en onderhoudbaarheid die Golang biedt. Webapplicaties worden gegenereerd met behulp van het Vue3-framework en JavaScript/TypeScript, terwijl mobiele applicaties gebruikmaken van het servergestuurde framework AppMaster, Kotlin en Jetpack Compose voor Android en SwiftUI voor iOS-applicaties.

Dankzij het krachtige AppMaster platform kunnen zelfs mensen zonder codeerervaring een complete, schaalbare softwareoplossing maken die server backends, websites, klantportals en native mobiele applicaties omvat. AppMaster versnelt niet alleen het hele softwareontwikkelingsproces, maar elimineert ook volledig de technische schuld door applicaties vanaf nul te genereren telkens als de vereisten worden gewijzigd.

Als je overweegt om een no-code platform te gaan gebruiken voor je software ontwikkeling, en dan met name een platform dat gebruik maakt van de voordelen van Golang, dan zou AppMaster bovenaan je lijst moeten staan. Meld u aan voor een gratis account en verken de toekomst van applicatieontwikkeling met een oplossing die 10x sneller en 3x kosteneffectiever is.