Hur man skapar GO -körbara filer i Ubuntu 17

Ett av de mest mångsidiga operativsystemen i Linux Det är utan tvekan Ubuntu som tack vare dess funktioner erbjuder oss en säker och mycket konfigurerbar miljö.

Förutom denna stora fördel kan vi hitta många verktyg och applikationer som gör det möjligt att öka prestandan och produktiviteten Ubuntu och baserat på denna möjlighet idag kommer vi att analysera ett verktyg som erbjuder oss möjligheten att skapa körbara filer i olika operativsystem för att senare köras med fullständigt förtroende, detta verktyg kallas Gå.

Vad är GOGo är en öppen källkodsprogram som gör att vi kan skapa enkel, pålitlig och mycket produktiv programvara.

Go har utformats med en stor portfölj av verktyg som gör det möjligt att skaffa paket och skapa körbara filer på ett praktiskt sätt.

Med Go, som systemadministratörer, har vi möjlighet att skapa körbara filer för flera operativsystem och hantera dem alla från en enda server utan att behöva gå till varje plattform för att ladda ner motsvarande körbar.

Med Go kan vi skapa körbara filer för bland annat Windows, Linux, Mac OS.

Innan vi fortsätter med att se hur du skapar den körbara ger vi en kort genomgång av hur du installerar Go i Ubuntu 17.

1. Hur man installerar och uppdaterar Ubuntu 17 -systemet

Steg 1
Det första steget att utföra är att utföra följande kommandon för att uppdatera systempaketen och deras respektive buggfixar:

 sudo apt-get update sudo apt-get -y uppgradering

Steg 2
När systemet har uppdaterats fortsätter vi att ladda ner respektive Go -binärer genom att köra följande rad:

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

FÖRSTORA

NoteraOm vi ​​behöver binära filer för 32-bitarsversioner kan vi gå till följande länk:

Steg 3
När filen har laddats ner fortsätter vi till dess extraktion genom att köra följande rad:

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

FÖRSTORA

Steg 4
Vi flyttar innehållet till / usr / local -sökvägen:

 sudo mv go / usr / local

2. Hur man justerar Go Ubuntu 17 -miljö

Steg 1
För att Go ska fungera korrekt måste vi ange följande rader som är associerade med Go's sökväg och åtkomst:

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

FÖRSTORA

Steg 2
Det är viktigt att notera att GOPATH -sökvägen är där byggfilerna kommer att vara värd.
När detta är gjort kan vi utföra följande kommandon för att verifiera versionen och miljön för Go:

 go version go env

FÖRSTORA

Steg 3
Med detta har vi redan installerat Go och vi kan fortsätta att skapa körbara filer.
Det bör noteras att Go version 1.8 för närvarande är i beta, men om vi vill installera det kan vi utföra följande kommandon:

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

3. Hur man laddar ner källkoden i Ubuntu 17

Detta är det första steget innan du skapar någon körbar med Go, för att få sin källkod som vi får med parametern go get.

Processen inkluderar kloning av paketen i sökvägen GOPATH / src / och senare om du tillämpar dessa kommer de att byggas i GOPATH / bin -sökvägen.

Steg 1
Syntaxen som ska användas för nedladdning av källkoden är:

 gå hämta (paketväg)

Vägen finns vanligtvis i basen av Github. Vi lägger också till parametern -eller som installerar alla beroenden eller uppdateringen av dessa.

Steg 2
I det här fallet kommer vi att använda Caddy som är en webbserver skriven i Go och vi kommer att köra följande rad för att ladda ner den:

 gå till -u github.com/mholt/caddy/caddy

Steg 3
Som vi kan se visas inget synligt resultat men allt innehåll lagras i sökvägen

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

Om vi ​​vill kontrollera det kan vi köra raden vilken caddie. I vissa fall, Git-associerade fel, för detta kommer vi att utföra följande för dess korrigering:

 sudo apt installera git

4. Hur man bygger den körbara i Ubuntu 17

Steg 1
När Caddy har laddats ner och för detta kör vi följande rad:

 gå att bygga github.com/mholt/caddy/caddy 

Steg 2
Detta kommando visar inte heller några synliga resultat. Om vi ​​vill ange en särskild rutt kan vi lägga till parametern -o enligt följande. Vi kan ändra rutten build / caddy-server för den önskade. Detta kommando skapar den körbara filen och för övrigt, om den inte existerar, katalogen ./bygga.

 gå build -o build/caddy -server github.com/mholt/caddy/caddy 

5. Så här installerar du den körbara filen i Ubuntu 17

Att installera en körbar består av skapa .exe -filen och förvara den i GOPATH / bin -sökväg. För denna process kommer vi att använda kommandot gå installera som skapar den körbara filen på rätt plats.

Vi kommer att utföra följande. När kommandot körs kommer inget resultat att synas för användaren heller, men filen har skapats i GOPATH / bin -sökvägen.

 gå installera github.com/mholt/caddy/caddy 

6. bygga körbara filer för olika system på Ubuntu 17

Vid denna tidpunkt kommer vi att se kraften hos Go och hur det blir en värdefull allierad tack vare de många möjligheterna att skapa körbara filer.

Steg 1
Syntaxen som ska implementeras kommer att vara följande. Kommandot env ansvarar för att skapa en modifierad miljö för användning av respektive variabler.

 env GOOS = OS -mål GOARCH = Arkitektur go build Paketväg 

Steg 2
Följande är en tabell med alla de alternativ som Go erbjuder oss:

Steg 3
I det här fallet kommer vi att skapa en Windows-körbar med en 64-bitars amd-arkitektur, vi kommer att utföra följande:

 env GOOS = windows GOARCH = amd64 go build github.com/mholt/caddy/caddy 

Som vanligt i Go kommer vi inte att se några synliga resultat, men processen har genomförts internt.

Steg 4
Detta skapar .exe -filen baserad på det valda systemet och för att kontrollera det kör vi följande rad:

 ls caddy.exe 

7. Hur man skapar manuset för plattformsoberoende kompilering i Ubuntu 17

Med detta mål kommer vi att skapa ett skript som heter go-executable-build.bash som kommer att vara ett manus som är ansvarigt för att utföra alla sammanställningsåtgärder på ett praktiskt sätt och kan användas på en generell nivå med full kompatibilitet.

Steg 1
För detta kommer vi att använda rad cd ~ och vi kommer att utföra följande:

 nano go-executable-build.bash

Steg 2
Där måste vi ange följande information:

 #! / usr / bin / env bash package = $ 1 if [[-z "$ package"]]; eko sedan "usage: $ 0" exit 1 fi package_split = ($ {package // \ //}) package_name = $ {package_split [-1]} platforms = ("windows / amd64" "windows / 386" "darwin / amd64 ") för plattform i" $ {platforms [@]} "gör platform_split = ($ {platform // \ //}) GOOS = $ {platform_split [0]} GOARCH = $ {platform_split [1]} output_name = $ package_name '-' $ GOOS '-' $ GOARCH if [$ GOOS = "windows"]; sedan output_name + = '. exe' fi env GOOS = $ GOOS GOARCH = $ GOARCH go build -o $ output_name $ package if [$? -ne 0]; eko sedan 'Ett fel har inträffat! Avbryter körningen av skriptet … 'avsluta 1 fi klar

Steg 3
Detta kommer att vara skriptet och dess funktion är följande:

 #! / usr / bin / env bash: Den här raden indikerar att tolk kommer att analysera skriptet. 

 package = $ 1: Denna rad tar det första argumentet från kommandoraden och lagrar det i dess variabel. om [[-z "$ paket"]]; eko sedan "användning: $ 0" avsluta 1 fi

Steg 4
Dessa rader är ansvariga för att visa ett meddelande om värdet inte har angetts.
Parameter om analyserar värdet på variabeln paket.

 package_split = ($ {package // \ //}): Den här raden delar paketimportvägen i en array med hjälp av /delimiter. package_name = $ {package_split [-1]}: Den här raden tar namnet på arrayen. plattformar = ("windows / amd64" "windows / 386" "darwin / amd64"): Där kommer vi in ​​i operativsystemet och arkitekturen för att skapa. för plattform i "$ {platforms [@]}" gör platform_split = ($ {platform // \ //}) GOOS = $ {platform_split [0]} GOARCH = $ {platform_split [1]} Klar

Steg 5
Dessa rader delar upp plattformens värden i GOOS- och GOARCH -variablerna.

 output_name = $ package_name '-' $ GOOS '-' $ GOARCH if [$ GOOS = "windows"]; sedan output_name + = '. exe' fi

Steg 6
Med den här sekvensen skapar vi namnet på den körbara filen och när det gäller Windows -operativsystem måste vi lägga till tillägget .exe.

 env GOOS = $ GOOS GOARCH = $ GOARCH go build -o $ output_name $ package: Denna rad tillåter oss att skapa den körbara filen. om [$? -ne 0]; eko sedan 'Ett fel har inträffat! Avbryter körningen av skriptet … 'avsluta 1

Steg 7
Med dessa rader visas ett felmeddelande om den körbara konstruktionen är fel.

Steg 8
När vi har skrivit in denna information sparar vi ändringarna med hjälp av tangentkombinationen

Ctrl + O

och vi lämnar redaktören med

Ctrl + X

Steg 9
Vi tilldelar behörigheterna för att skriptet ska köras med följande rad:

 chmod + x go-executable-build.bash

Steg 10
Det sista steget blir att testa skriptkonfigurationen genom att köra följande. Som vi kan se har inget fel genererats.

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

8. Hur man kontrollerar körbara filer i Ubuntu 17

För att kontrollera att vi har rätt körbara filer i Go, kör bara följande rad:

 ls caddy *

Där kommer vi att se både 32-bitars och 64-bitars körbara filer för det valda systemet, i det här fallet Windows. Om vi ​​vill använda andra plattformar är det bara att komma åt skriptet och göra ändringarna i raden plattformar.

Vi har sett hur Go är en grundläggande applikation när det krävs att ha flera körbara filer, vilket underlättar hantering och distribution av dessa i organisationen.