GO-uitvoerbare bestanden maken in Ubuntu 17

Een van de meest veelzijdige besturingssystemen in Linux Het is ongetwijfeld Ubuntu dat ons dankzij zijn functies een veilige en zeer configureerbare omgeving biedt.

Naast dit grote voordeel kunnen we tal van tools en toepassingen vinden die het mogelijk maken om de prestatie- en productiviteitsniveaus van Ubuntu en op basis van deze mogelijkheid zullen we vandaag een tool analyseren die ons de mogelijkheid biedt om uitvoerbare bestanden van verschillende besturingssystemen te maken om later met volledig vertrouwen uit te voeren, deze tool wordt genoemd Gaan.

Wat is GOGo is een open source applicatie waarmee we eenvoudige, betrouwbare en zeer productieve software kunnen maken.

Go is ontworpen met een groot aantal tools waarmee u op een praktische manier pakketten kunt verkrijgen en uitvoerbare bestanden kunt maken.

Met Go hebben we als systeembeheerders de mogelijkheid om uitvoerbare bestanden voor meerdere besturingssystemen te maken en ze allemaal vanaf één server te beheren zonder dat we naar elk platform hoeven te gaan om het bijbehorende uitvoerbare bestand te downloaden.

Met Go kunnen we uitvoerbare bestanden maken voor onder andere Windows, Linux, Mac OS.

Voordat we verder gaan met het maken van het uitvoerbare bestand, zullen we een korte bespreking geven van hoe Go te installeren in Ubuntu 17.

1. Het Ubuntu 17-systeem installeren en bijwerken

Stap 1
De eerste stap die u moet uitvoeren, is het uitvoeren van de volgende opdrachten om de systeempakketten en hun respectievelijke bugfixes bij te werken:

 sudo apt-get update sudo apt-get -y upgrade

Stap 2
Nadat het systeem is bijgewerkt, gaan we verder met het downloaden van de respectieve Go-binaries door de volgende regel uit te voeren:

 wget https://storage.googleapis.com/golang/go1.7.4.linux-amd64.tar.gz 

VERGROTEN

OpmerkingAls we de binaire bestanden voor 32-bits edities nodig hebben, kunnen we naar de volgende link gaan:

Stap 3
Nadat het bestand is gedownload, gaan we verder met de extractie door de volgende regel uit te voeren:

 sudo tar -xvf go1.7.4.linux-amd64.tar.gz 

VERGROTEN

Stap 4
We zullen de inhoud naar het / usr / lokale pad verplaatsen:

 sudo mv go / usr / local

2. Hoe de Go Ubuntu 17-omgeving aan te passen

Stap 1
Om Go correct te laten werken, moeten we de volgende regels invoeren die zijn gekoppeld aan het pad en de toegang van Go:

 export GOROOT = / usr / local / ga export GOPATH = $ HOME / Solvetic / ga export PATH = $ GOPATH / bin: $ GOROOT / bin: $ PATH

VERGROTEN

Stap 2
Het is belangrijk op te merken dat het GOPATH-pad is waar de buildbestanden worden gehost.
Zodra dit is gebeurd, kunnen we de volgende opdrachten uitvoeren om de versie en omgeving van Go te verifiëren:

 ga versie ga env

VERGROTEN

Stap 3
Hiermee hebben we Go al geïnstalleerd en kunnen we doorgaan met het maken van de uitvoerbare bestanden.
Opgemerkt moet worden dat Go-versie 1.8 momenteel in bèta is, maar als we het willen installeren, kunnen we de volgende opdrachten uitvoeren:

 sudo add-apt-repository ppa: longsleep / golang-backports sudo apt-get update sudo apt-get install golang-go

3. Hoe de broncode te downloaden in Ubuntu 17

Dit is de eerste stap voordat een uitvoerbaar bestand met Go wordt gemaakt, waarbij de broncode wordt verkregen die we verkrijgen met behulp van de go get-parameter.

Het proces omvat: het klonen van de pakketten in het pad GOPATH / src / en als u deze later toepast, worden ze gebouwd in het GOPATH / bin-pad.

Stap 1
De syntaxis die moet worden gebruikt voor het downloaden van de broncode is:

 ga halen (pakketpad)

Het pad is meestal te vinden in de basis van Github. We zullen ook de parameter toevoegen: -of die alle afhankelijkheden of de update hiervan installeert.

Stap 2
In dit geval zullen we Caddy gebruiken, een webserver geschreven in Go en we zullen de volgende regel uitvoeren om het te downloaden:

 ga halen -u github.com/mholt/caddy/caddy

Stap 3
Zoals we kunnen zien, wordt er geen zichtbaar resultaat weergegeven, maar alle inhoud wordt opgeslagen in het pad

 GOPATH / src / github.com / mholt / caddy.

Als we het willen controleren, kunnen we de regel uitvoeren welke caddie. In sommige gevallen, Git-geassocieerde fouten, hiervoor zullen we het volgende uitvoeren voor de correctie:

 sudo apt install git

4. Hoe het uitvoerbare bestand te bouwen in Ubuntu 17

Stap 1
Zodra Caddy is gedownload en hiervoor zullen we de volgende regel uitvoeren:

 ga bouwen github.com/mholt/caddy/caddy 

Stap 2
Deze opdracht geeft ook geen zichtbare resultaten weer. Als we een speciale route willen specificeren, kunnen we de parameter -o als volgt toevoegen. We kunnen de route veranderen build / caddy-server voor de gewenste. Met deze opdracht wordt het uitvoerbare bestand gemaakt en overigens, als het niet bestaat, de map ./bouwen.

 ga build -o build / caddy-server github.com/mholt/caddy/caddy 

5. Hoe het uitvoerbare bestand te installeren in Ubuntu 17

Het installeren van een uitvoerbaar bestand bestaat uit: maak het .exe-bestand en bewaar het in de GOPATH / bin pad. Voor dit proces gebruiken we het commando ga installeren waarmee het uitvoerbare bestand op de juiste plaats wordt gemaakt.

We zullen het volgende uitvoeren. Bij het uitvoeren van de opdracht zal ook geen resultaat zichtbaar zijn voor de gebruiker, maar het bestand zal zijn aangemaakt in het GOPATH / bin-pad.

 ga github.com/mholt/caddy/caddy installeren 

6. uitvoerbare bestanden bouwen voor verschillende systemen op Ubuntu 17

Op dit punt zullen we de kracht van Go zien en hoe het een waardevolle bondgenoot wordt dankzij de meerdere mogelijkheden om uitvoerbare bestanden te maken.

Stap 1
De te implementeren syntaxis is de volgende. Het bevel benijden is verantwoordelijk voor het creëren van een aangepaste omgeving voor het gebruik van de respectieve variabelen.

 env GOOS = OS Doel GARCH = Architectuur go build Pakketpad 

Stap 2
Hieronder een tabel met alle mogelijkheden die Go ons biedt:

Stap 3
In dit geval zullen we een Windows-uitvoerbaar bestand maken met een 64-bits amd-architectuur, we zullen het volgende uitvoeren:

 env GOOS = windows GARCH = amd64 ga bouwen github.com/mholt/caddy/caddy 

Zoals gebruikelijk in Go zullen we geen zichtbare resultaten zien, maar het proces is intern uitgevoerd.

Stap 4
Hiermee wordt het .exe-bestand gemaakt op basis van het gekozen systeem en om het te controleren, voeren we de volgende regel uit:

 ls caddy.exe 

7. Hoe het script te maken voor platformonafhankelijke compilatie in Ubuntu 17

Met dit doel zullen we een script maken met de naam go-executable-build.bash wat een script zal zijn dat verantwoordelijk is voor het uitvoeren van alle compilatieacties op een praktische manier en dat op een algemeen niveau kan worden gebruikt met volledige compatibiliteit.

Stap 1
Hiervoor gebruiken we de regel cd ~ en we zullen het volgende uitvoeren:

 nano go-executable-build.bash

Stap 2
Daar moeten we de volgende gegevens invullen:

 #! / usr / bin / env bash-pakket = $ 1 als [[-z "$ pakket"]]; dan echo "usage: $ 0" exit 1 fi package_split = ($ {package // \ //}) package_name = $ {package_split [-1]} platforms = ("windows / amd64" "windows / 386" "darwin / amd64 ") voor platform in" $ {platforms [@]} "do platform_split = ($ {platform // \ //}) GOOS = $ {platform_split [0]} GOARCH = $ {platform_split [1]} output_name = $ pakketnaam '-' $ GOOS '-' $ GARCH if [$ GOOS = "windows"]; dan output_name + = '.exe' fi env GOOS = $ GOOS GARCH = $ GARCH go build -o $ output_name $ pakket als [$? -ne 0]; dan echo 'Er is een fout opgetreden! De uitvoering van het script afbreken… 'exit 1 fi done'

Stap 3
Dit wordt het script en de functie ervan is als volgt:

 #! / usr / bin / env bash: Deze regel geeft aan dat de interpreter het script zal ontleden. 

 package = $ 1: Deze regel neemt het eerste argument van de opdrachtregel en slaat het op in zijn variabele. if [[-z "$ pakket"]]; dan echo "gebruik: $ 0" exit 1 fi

Stap 4
Deze regels zijn verantwoordelijk voor het weergeven van een bericht in het geval dat de waarde niet is ingevoerd.
Parameter indien ontleedt de waarde van de variabele pakket.

 package_split = ($ {package // \ //}): Deze regel splitst het importpad van het pakket in een array met het / scheidingsteken. package_name = $ {package_split [-1]}: Deze regel krijgt de naam van de array. platforms = ("windows / amd64" "windows / 386" "darwin / amd64"): Daar gaan we het besturingssysteem en de te creëren architectuur invoeren. voor platform in "$ {platforms [@]}" doe platform_split = ($ {platform // \ //}) GOOS = $ {platform_split [0]} GOARCH = $ {platform_split [1]} Klaar

Stap 5
Deze lijnen verdelen de platformwaarden in de GOOS- en GARCH-variabelen.

 output_name = $ pakketnaam '-' $ GOOS '-' $ GARCH if [$ GOOS = "windows"]; dan output_name + = '.exe' fi

Stap 6
Met deze reeks zullen we de naam van het uitvoerbare bestand maken en als het gaat om Windows-besturingssystemen, moeten we de extensie .exe toevoegen.

 env GOOS = $ GOOS GOARCH = $ GOARCH go build -o $ output_name $ pakket: Met deze regel kunnen we het uitvoerbare bestand maken. als [$? -ne 0]; dan echo 'Er is een fout opgetreden! De uitvoering van het script afbreken… 'exit 1'

Stap 7
Met deze regels wordt een foutmelding weergegeven in het geval dat de uitvoerbare constructie verkeerd is.

Stap 8
Zodra we deze informatie hebben ingevoerd, slaan we de wijzigingen op met de toetsencombinatie

Ctrl + O

en we verlaten de editor met

Ctrl + X

Stap 9
We zullen de machtigingen toewijzen om het script uitvoerbaar te maken met behulp van de volgende regel:

 chmod + x go-executable-build.bash

Stap 10
De laatste stap is het testen van de scriptconfiguratie door het volgende uit te voeren. Zoals we kunnen zien, is er geen fout gegenereerd.

 ./go-executable-build.bash github.com/mholt/caddy/caddy 

8. Hoe uitvoerbare bestanden te controleren in Ubuntu 17

Om te controleren of we de juiste uitvoerbare bestanden in Go hebben, voert u gewoon de volgende regel uit:

 ls caddie *

Daar zullen we zowel de 32-bits als de 64-bits uitvoerbare bestanden zien voor het geselecteerde systeem, in dit geval Windows. Als we andere platforms willen gebruiken, opent u gewoon het script en brengt u de wijzigingen aan in de regel platformen.

We hebben gezien hoe Go een fundamentele toepassing is wanneer het nodig is om meerdere uitvoerbare bestanden te hebben, waardoor het beheer en de distributie ervan in de organisatie wordt vergemakkelijkt.