Workspaces, cross-compilatie en uitvoering in Linux

In dit artikel gaan we een uitleg geven van hoe je workspaces kan aanmaken en tevens binaire Go-bestanden bouwen, compileren, cross-compileren en uitvoeren van Go applicaties. Deze onderwerpen zijn erg belangrijk als je van plan bent om grootschalige Go-applicaties te ontwikkelen en implementeren in een productieomgeving.

Voordat we verder gaan met deze onderwerp, moeten we eerst uitleggen wat een workspace is en waarom je deze nodig hebt.

workspaces

Een workspace in Go is een directory die bestaat uit de volgende hiërarchie:

Bin

De bin directory staat voor binair en dit bestand bevat alle binaire bestanden van de project.

Pkg

De pkg directory staat voor pakketten en in deze bestand worden alle externe pakketten opgeslagen die tot het project behoren.

Src

De src is de broncodes map waarbij alle broncodes opgeslagen worden inclusief hun dependency.

Wanneer je Go op Linux installeren is je standaardomgeving /usr waar alle benodigde bestanden/packages worden opgeslagen. De vraag is nu: waarom een workspace aanmaken? Een workspace is een werkruimte waar alleen de benodigde pakketten en binaire bestanden van je project worden opgeslagen.

In al onze gebruikte voorbeeld tot nu toe gebruikten we de standaardomgeving (bekend als GOROOT) om onze Go broncodes uit te voeren. Een workspace biedt de mogelijkheid om pakketten en broncodes in je eigen werkruimte te importeren. Zodra je werkruimte is aangemaakt, worden alle pakketten die geïmporteerd zijn voor je project opgeslagen in de pkg map van je werkruimte.

Wanneer je de GOPATH vaststellen, verwacht Go een uitvoerbaar bestand in de opgegeven directory. De GOPATH geef aan de locatie van je workspace.

In Linux worden de Go omgevingsvariabelen in je .bashrc bestand vastgesteld. De volgende instructies geef aan hoe je een basisdirectory aanmaakt voor de workspace en tevens GOPATH in de omgevingsvariabelen instellen.

Begin met het maken van je project map. In dit voorbeeld gaan we deze map op ons bureaublad maken.

Nadat de project map is aangemaakt, moet je de src map aanmaken waarin de broncodes worden opgeslagen.

Vervolgens moet je het Go-bestand aanmaken die de main package bevat. Aangezien het ten minste één .go bestand vereist om een workspace te creëren in de opgegeven map. Voor dit voorbeeld gebruiken we Atom als onze code-editor, maar het hangt allemaal af van uw persoonlijke voorkeur. Lees dit artikel voor meer informatie over code-editors die kunnen worden gebruikt.

Maak een nieuw leeg bestand aan

Typ de volgende Go-codes

package main

func main(){

}

Sla het bestand op in je src map

Nu komt de meest belangrijke stap en dat is het specificeren van je GOPATH om de workspace te creëren. Voordat we door kunnen gaan met deze stap, moet je het absolute pad van de map ophalen. Dat doe je door op de rechtermuisknop te klikken op de project map en selecteert properties.

Deze pad zal je GOPATH zijn. Vervolgens om de GOPATH in te stellen, start terminal en voer de ls -la opdracht in om de lijst van alle mappen op te halen van je HOME-map (inclusief verborgen bestanden/mappen).

Druk op Return en de lijst met bestanden/mappen verschijnt en kijk of het .bashrc bestand in de resultaat staat. In Linux moet de GOPATH worden opgeslagen in het .bashrc -bestand.

Vervolgens open het .bashrc -bestand door de volgende opdracht uit te voeren:

nano .bashrc

Eenmaal het .bashrc -bestand opent, moet je het absoluut pad van je project map GOPATH en GOBIN toevoegen. In dit voorbeeld voeg de volgende regels toe in je .bashrc -bestand:

export GOPATH=$HOME/Bureaublad/go_project

export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

export GOBIN=$GOPATH/bin

Om je .bashrc-wijzigingen op te slaan, druk je op ctrl + x, druk je op ‘y‘ en druk op Return.

Sla de .bashrc -wijzigingen op en sluit de terminal volledig om de wijzigingen door te voeren. Voer de volgende opdracht uit om te controleren of de wijzigingen zijn doorgevoerd:

go env

Controleer vanuit het Go-omgevingsresultaat of de GOBIN en GOPATH zijn ingesteld.

Als alles is correct ingesteld moeten we alleen de laatste stap nog uitvoeren, namelijk het creëren van de workspace. Opent de terminal en navigeert naar de map src van de project map waar het .go-bestand zich bevindt:

cd ‘/home/[gebruiker]/Bureaublad/go_project/src’

En voert de volgende opdracht uit:

go install

Wanneer je deze opdracht op de project map uitvoeren worden de uitvoerbare bestanden gecompileerd en opslagen in de bin map.

Gefeliciteerd! Je workspace is aangemaakt en vanaf nu kun je pakketten importeren met behulp van de go get commando. Voer bijvoorbeeld de volgende opdracht uit:

go get -u github.com/gorilla/mux

En je pkg -map verschijnt met het geïmporteerde pakket in je workspace.

Tijdens het uitvoeren van zo’n opdracht zal Go door de volledig codebase heen lopen en zoek naar alle externe referenties. Indien externe referenties zijn gedetecteerd zal Go het package importeren en beschikbaar maken in je workspace.

Pakketten importeren

De meeste pakketten worden geïmporteerd vanuit andere repositories via een versiebeheersysteem zoals Git, Mercurial, SVN en Bazaar. Wanneer je een pakket importeert, haalt Go alle codebase op uit Git en checkt de laatste commit uit de standaard branch.

Go build

Om Go-applicaties te bouwen, moet je de go build opdracht uitvoeren waarmee het uitvoerbare bestand wordt gegenereerd. Wanneer je een uitvoerbaar bestand maakt, betekent het dat deze bestand geen externe bibliotheken nodig hebben om te kunnen draaien. Dus een standalone uitvoerbare bestand.

Voordat een uitvoerbaar bestand gemaakt kunnen worden zal Go door een aantal regels heen lopen. Dit zorgt ervoor om fouten en bugs te voorkomen. De go build opdracht helpt je ook om je code leesbaarder.

Je moet altijd onthouden dat de Go-compiler is om je te helpen en niet een ellende van te maken.

Het doel van de compiler is om je Go-code te compileren en de kwaliteit van je broncodes te verbeteren.

Een van de regels zijn dat iedere package die geïmporteerd worden in je project moet gebruikt worden.

package main
import (
“fmt”
“os”
)

func main() {
fmt.Println(“Hello world!”)
}

Dit zal de volgende foutmelding weergeven wanneer je een uitvoerbaar bestand probeer te maken:

# command-line-arguments
./main.go:5:1: imported and not used: “os”

Hoewel je deze regel kan omzeilen door een onderstrepingsteken te gebruiken.

package main
import (
“fmt”
_”os”
)

func main() {
fmt.Println(“Hello world!”)
}

Het gebruik van puntkomma’s worden streng gecontroleerd door de compiler omdat Go in veel contexten gebruik de puntkomma’s als terminator van instructies. De compiler voegt automatisch de vereiste puntkomma’s in wanneer hij denkt dat dit nodig is. Bekijk het volgende voorbeeld:

package main
import (
“fmt”
)

func main()
{
fmt.Println(“Hello world!”)
}

De code ziet er goed uit, maar als je een uitvoerbaar bestand probeer van te maken krijgt je de volgende syntaxisfoutmelding en de code zal niet compileren:

# command-line-arguments
./main.go:7:6: missing function body
./main.go:8:1: syntax error: unexpected semicolon or newline before {

Dit komt omdat het plaatsen van de haakje { in een nieuwe regel ervoor zorgt dat de Go-compiler een puntkomma invoegt aan het einde van main (). Vandaar de foutmelding.

Go format (fmt)

Met de go fmt commando kan broncodes weer in het juiste formaat gesteld worden. Dat betekent dat als je code er rommelig uitziet, kun je met deze commando ervoor zorgen dat ze weer netjes uitziet.

Cross-compileren

Cross-compilatie is een belangrijke functie als je uitvoerbare bestanden wilt genereren voor verschillende machines met een andere besturingssysteem en architectuur. Gelukkig heeft Go een ingebouwde ondersteuning voor cross-compilatie, wat betekent dat je alleen maar één machine nodig hebt voor het ontwikkelen van je Go applicatie.

Voor het cross-compileren van een Go-bestand, moet je de GOOS (besturingssysteem van keuze) en GOARCH (architectuur van keuze) instellen. Voer de volgende opdracht uit om deze gegevens op te achterhalen:

  • go version
  • go version go1.10.3 linux/amd64

In dit voorbeeld is de GOOS linux en amd64 de GOARCH. De cross-compilatie kan gedaan worden door de volgende opdracht uit te voeren:

env GOOS=[besturingssysteem] GOARCH=[architectuur] go build [go bestand]

Voor onze voorbeeld is de wordt de opdracht als volgt:

env GOOS=linux GOARCH=arm64 go build main.go

Het resultaat ziet als volgt uit:

Deze opdracht genereert een uitvoerbaar bestand dat werkt op Linux met een ARM-architectuur. Zie de lijst van alle ondersteunde Go GOOS en GOARCH.

Voer Go-codes uit

In bijna alle onze eerdere artikelen wordt de go run opdracht gebruikt. Bij het uitvoeren van go run zal de Go-compiler een tijdelijk uitvoerbaar bestand aanmaken. Na de uitvoering van de Go-applicatie wordt deze uitvoerbare bestand verwijderd. Dat betekent dat Go geen bestanden op je harde schijf achterlaat.

Voor het maken van zelfstandig uitvoerbaar bestanden moet je de go build opdracht gebruiken. Doormiddel van deze opdracht wordt deze uitvoerbare bestand gemaakt die rechtstreeks uitgevoerd kunnen worden zonder go run te gebruiken. Een go build opdracht ziet er als volgt uit:

Go build [go bestandsnaam]

In een voorbeeld waar je de bestandsnaam main.go hebt, zal de go build opdracht als volgt uitziet:

go build main.go

Zodra de uitvoering voltooid is, wordt de uitvoerbare bestand(en) gemaakt en opgeslagen in de src-map. Om de main uitvoerbare bestand uit te voeren, moet je naar de src-map navigeren:

cd ‘/home/[gebruiker]/Bureaublad/go_project/src’

En voer de volgende opdracht uit:

./main

Geef een antwoord

Het e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *