Go is een statisch getypeerde programmeertaal. Oorspronkelijk ontworpen door Google, vertoont Go overeenkomsten met C wat betreft syntaxis. Qua functionaliteit biedt Go echter extra functies zoals geheugenveiligheid, garbage collection, structurele typering, enz. De afgelopen jaren heeft Go een enorme populariteit gewonnen.
Deze gids zal de stappen doorlopen voor het bouwen en installeren van Go-programma's met behulp van een demo Go-programma.
Go bouwen en installeren
Voordat we verder gaan, volgt hier een kort overzicht van wat bouwen en installeren betekent in de context van programmeren in Go.
In de programmeertaal Go verwijst bouwen naar het proces van het vertalen van de broncode naar een binair uitvoerbaar bestand. Het uitvoerbare bestand bevat de benodigde ondersteunende code, zodat het onafhankelijk op het doelplatform kan draaien. In tegenstelling tot Ruby/Python-programma's hebben binaire Go-bestanden over het algemeen geen systeemafhankelijkheden nodig om op een nieuw systeem te draaien.
Het plaatsen van het binaire Go-bestand in een uitvoerbaar bestandspad op het systeem wordt het installeren van het programma genoemd. Zoals eerder vermeld, zal deze gids het uitvoeren, bouwen en installeren van een eenvoudig Go 'Hello world'-programma demonstreren.
Vereisten
Voordat we beginnen, doorlopen we de vereisten waaraan u moet voldoen om de tutorial te volgen:
- Een correct geconfigureerde Ubuntu 20.04. Bekijk hoe u een Ubuntu-server installeert en configureert.
- Een niet-rootgebruiker met sudo-rechten. Root-rechten zijn vereist om wijzigingen op systeemniveau uit te voeren. In deze tutorial leert u hoe u sudo-rechten verleent aan een niet-root-gebruiker.
- Correct geconfigureerde Go-programmeeromgeving.
Eerst zullen we snel het installeren en configureren van de Go-programmeeromgeving doorlopen. Voor een meer diepgaande stapsgewijze gids voor het installeren van Go, kijk hier.
Go installeren
Go is beschikbaar op alle grote platforms (Windows, Linux en macOS). Het is officieel rechtstreeks verkrijgbaar bij Golang. Vanwege de naam van de website wordt Go vaak aangeduid als Golang. Hier zullen we de programmeertaal Go altijd aanduiden als Go en de Golang-website als Golang.
Golang biedt gedetailleerde documentatie over Go-installatie voor alle ondersteunde platforms. De officiële methode beschrijft echter handmatige installatie. Telkens wanneer er een nieuwe versie wordt uitgebracht, moet u de installatie handmatig bijwerken naar de nieuwste versie. In plaats daarvan kunnen we Go rechtstreeks installeren met behulp van APT (vanuit de standaard Ubuntu-repositories) of snap (vanuit Snapcraft).
● Go installeren met APT
Go is rechtstreeks beschikbaar vanuit de officiële Ubuntu-repositories. Het is echter niet altijd de nieuwste versie van Go. Er zijn ook twee varianten van Go beschikbaar in de Ubuntu-repository: golang-go en gccgo-go. Terwijl golang-go de officiële versie van Golang is, is gccgo-go de Go-frontend voor GCC (als onderdeel van de GNU-compiler). Over het algemeen is golang-go de voorkeurskeuze.
Om golang-go te installeren, voert u de volgende APT-opdracht uit:
|
1 |
sudo apt update && sudo apt install golang-go |
Controleer de Go-versie:
|
1 |
go version |
● Go installeren met snap
Snaps zijn universele Linux-pakketten die op elke ondersteunde distributie kunnen worden geïnstalleerd. Snapcraft vermeldt alle ondersteunde distributies met installatiegidsen. Op Ubuntu is snap-ondersteuning standaard ingeschakeld. Go is ook beschikbaar als een snap. Houd er rekening mee dat dit niet officieel wordt onderhouden door Golang. Het snap-pakket wordt beheerd door een externe partij.
Om de Go-snap te installeren, voert u de volgende opdracht uit:
|
1 |
sudo snap install go --classic |
Teven, controleer de Go-versie:
|
1 |
go version |
Een Go-project opzetten
Ons systeem beschikt over alle benodigde tools om apps in Go te gaan ontwikkelen. Tijd om ons demoproject op te zetten. Maak eerst een speciale map aan voor ons project:
|
1 |
mkdir -v demo_project |
Navigeer vervolgens naar de nieuw gemaakte map:
|
1 |
cd demo_project/ |
Maak hier een nieuw tekstbestand aan met de naam main.go:
|
1 |
nano main.go |
De volgende code bevat een eenvoudig programma dat 'Hello world' zal afdrukken wanneer het wordt uitgevoerd. Kopieer de code:
|
1 2 3 4 5 6 7 |
package main import "fmt" func main() { fmt.Println("hello world!") } |
Sla het bestand op en sluit de editor. Controleer of de code correct functioneert:
|
1 |
go run main.go |
De Go-compiler heeft het bronbestand gecompileerd naar een binair bestand en dit uitgevoerd. Het controleert ook of het programma succesvol functioneert.
Go-werkruimteconfiguratie
Om Go-programma's correct te installeren, moeten we de Go-werkruimte en GOPATH configureren.
Maak eerst de mappenstructuur aan:
|
1 |
mkdir -pv $HOME/go/{bin,src} |
Vervolgens moeten we de waarde declareren van GOPATH en deze toevoegen aan PATH. Open het bashrc bestand:
|
1 |
nano ~/.bashrc |
Voeg de volgende regels toe aan het einde van het bestand:
|
1 2 3 |
export GOPATH=$HOME/go export GOBIN=$GOPATH/bin export PATH=$PATH:$GOPATH/bin:/usr/local/go/bin |
Herlaad bashrc:
|
1 |
source ~/.bashrc |
Controleer of de wijziging succesvol was:
|
1 |
echo $PATH |
Go-binaire bestanden bouwen
In deze sectie wordt gedemonstreerd hoe u Go-code compileert naar een distribueerbaar, zelfstandig binair bestand. Het binaire bestand bevat niet alleen de Go-code, maar ook aanvullende systeemcode om het binaire bestand uit te voeren. Voer de volgende opdracht uit om onze code te compileren:
|
1 |
go build main.go |
Als er meerdere Go-codebestanden zijn, gebruik dan de volgende opdracht:
|
1 |
go build |
Als er geen bestand is opgegeven, zoekt Go naar Go-bestanden in de huidige map en compileert deze allemaal. Elk binair bestand is vernoemd naar het bijbehorende Go-bronbestand. In dit voorbeeld heeft Go het programma main. Voer het programma uit:
|
1 |
./main |
Dit programma is klaar om naar andere computers te worden gedistribueerd.
● De naam van het binaire bestand wijzigen
Bij het bouwen selecteert Go automatisch een naam voor het uitvoerbare bestand. Er zijn twee mogelijke opties voor het kiezen van de naam.
- Als Go modules worden gebruikt, gebruikt het uitvoerbare bestand het laatste deel van de naam van de module.
- Als er geen Go-module wordt gebruikt, gebruikt Go de naam van de huidige map of de naam van het bronbestand.
Het werken met complexere programma's vereist een andere naamgevingsconventie. In dergelijke scenario's zijn deze standaard naamgevingsmethoden niet erg handig. In een dergelijke situatie is de beste manier om de uitvoer aan te passen met de vlag -o. Laten we een korte demonstratie geven. Bouw het Go-programma met de vlag -o om een andere bestandsnaam aan te duiden:
|
1 |
go build -o bin/hello |
De -o vlag vertelt Go om de uitvoer te matchen met het opgegeven argument. In dit geval bevindt het uitvoerbare bestand zich in de map bin en krijgt het de naam hello.
Test vervolgens het nieuwe uitvoerbare bestand:
|
1 |
./bin/hello |
Go-programma's installeren
Tot nu toe hebben we gedemonstreerd hoe u distribueerbare Go-binaire bestanden bouwt vanuit bronbestanden. We kunnen ze distribueren naar andere systemen, implementeren en tests uitvoeren. Ze kunnen echter niet buiten hun bronmappen worden uitgevoerd. Als u van plan bent het programma actief te gebruiken, kan deze beperking erg vervelend zijn. Om het eenvoudiger te maken, kunnen we de Go-programma's installeren en ze overal in het systeem openen.
Om het programma te installeren, voert u de volgende Go-opdracht uit in de bronmap:
|
1 |
go install |
Deze opdracht werkt op dezelfde manier als go build. In plaats van het uitvoerbare bestand in de bronmap achter te laten, wordt het echter in de volgende map geplaatst:
|
1 |
$GOPATH/bin |
De variabelen GOPATH en GOBIN vertellen Go waar het moet zoeken naar Go-werkruimtes. GOPATH is standaard de locatie $HOME/go. We stellen GOBIN handmatig in op $GOPATH/bin. Om de locatie te controleren van GOPATH en GOBIN gebruikt u de volgende opdracht:
|
1 |
go env GOPATH |
|
1 |
go env GOBIN |
Controleer de inhoud van $GOPATH/bin. Ons programma zou daar moeten staan:
|
1 |
ls $GOPATH/bin |
Tijd om te controleren of de installatie succesvol was. Wijzig de huidige map naar een andere locatie en probeer het Go-programma uit te voeren:
|
1 |
demo_project |
Ten slotte zou je in staat moeten zijn om je programma's te nemen en ze op je systeem te installeren. Je kunt ze gebruiken waar en wanneer je ze maar nodig hebt.
Laatste gedachten
In deze handleiding hebben we met succes gedemonstreerd hoe je Go-toolchains gebruikt om uitvoerbare binaire bestanden te bouwen van broncode. Deze binaire bestanden kunnen op andere systemen worden gebruikt, zelfs zonder enige Go-configuratie. Ten slotte hebben we gedemonstreerd hoe je het Go-programma installeert zodat het overal in het systeem beschikbaar is.
Voor ontwikkelaars, CloudSigma biedt Go API-ondersteuning om je cloudservers te beheren. Hiermee kun je bronnen bewerken en de infrastructuur schalen.
Veel computerplezier!
Reacties
Nog geen reacties. Wees de eerste.