Hvordan lage GO -kjørbare filer i Ubuntu 17

Et av de mest allsidige operativsystemene i Linux Det er utvilsomt Ubuntu som, takket være funksjonene, gir oss et sikkert og svært konfigurerbart miljø.

I tillegg til denne store fordelen, kan vi finne mange verktøy og applikasjoner som gjør det mulig å øke ytelsen og produktiviteten Ubuntu og basert på denne muligheten i dag vil vi analysere et verktøy som gir oss muligheten til å lage kjørbare filer for forskjellige operativsystemer for senere å bli utført med full tillit, dette verktøyet kalles Gå.

Hva er GOGo er en åpen kildekode -applikasjon som lar oss lage enkel, pålitelig og svært produktiv programvare.

Go er designet med en stor portefølje av verktøy som gjør det mulig å skaffe pakker og lage kjørbare filer på en praktisk måte.

Med Go, som systemadministratorer, har vi muligheten til å lage kjørbare filer for flere operativsystemer og administrere dem alle fra en enkelt server uten å måtte gå til hver plattform for å laste ned den tilsvarende kjørbare.

Med Go kan vi lage kjørbare filer for blant annet Windows, Linux, Mac OS.

Før vi fortsetter å se hvordan du lager den kjørbare, gir vi en kort gjennomgang av hvordan du installerer Go i Ubuntu 17.

1. Slik installerer og oppdaterer du Ubuntu 17 -systemet

Trinn 1
Det første trinnet å utføre er å utføre følgende kommandoer for å oppdatere systempakkene og deres respektive feilrettinger:

 sudo apt-get oppdatering sudo apt-get -y oppgradering

Steg 2
Når systemet er oppdatert, fortsetter vi med å laste ned de respektive Go -binærene ved å utføre følgende linje:

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

FORSTØRRE

MerkHvis du trenger binære filer for 32-biters utgaver, kan vi gå til følgende lenke:

Trinn 3
Når filen er lastet ned, går vi videre til utpakkingen ved å kjøre følgende linje:

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

FORSTØRRE

Trinn 4
Vi flytter innholdet til / usr / local banen:

 sudo mv go / usr / local

2. Slik justerer du Go Ubuntu 17 -miljøet

Trinn 1
For at Go skal fungere riktig, må vi skrive inn følgende linjer knyttet til Go's bane og tilgang:

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

FORSTØRRE

Steg 2
Det er viktig å merke seg at GOPATH -banen er bygningsfilene som skal lagres.
Når dette er gjort, kan vi utføre følgende kommandoer for å bekrefte versjonen og miljøet til Go:

 go versjon go env

FORSTØRRE

Trinn 3
Med dette har vi allerede installert Go, og vi kan fortsette til opprettelsen av kjørbare filer.
Det skal bemerkes at Go versjon 1.8 for øyeblikket er i beta, men hvis vi vil installere det kan vi utføre følgende kommandoer:

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

3. Hvordan laste ned kildekoden i Ubuntu 17

Dette er det første trinnet før du oppretter noen kjørbar med Go, og får kildekoden som vi får tak i ved hjelp av go get -parameteren.

Prosessen inkluderer kloning av pakkene i banen GOPATH / src / og senere hvis du bruker disse, blir de bygget i GOPATH / bin -banen.

Trinn 1
Syntaksen som skal brukes for nedlasting av kildekoden er:

 gå hente (pakkebane)

Stien finnes vanligvis i foten av Github. Vi vil også legge til parameteren -eller som installerer alle avhengighetene eller oppdateringen av disse.

Steg 2
I dette tilfellet vil vi bruke Caddy som er en webserver skrevet i Go, og vi vil kjøre følgende linje for å laste den ned:

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

Trinn 3
Som vi kan se, vises ikke noe synlig resultat, men alt innholdet vil bli lagret i banen

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

Hvis vi vil kontrollere det, kan vi utføre linjen hvilken caddie. I noen tilfeller, Git-assosierte feil, for dette vil vi utføre følgende for korrigering:

 sudo apt installere git

4. Hvordan bygge den kjørbare i Ubuntu 17

Trinn 1
Når Caddy er lastet ned, og for dette, vil vi utføre følgende linje:

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

Steg 2
Denne kommandoen vil heller ikke vise noen synlige resultater. Hvis vi vil spesifisere en spesiell rute, kan vi legge til parameteren -o som følger. Vi kan endre ruten build / caddy-server for den ønskede. Denne kommandoen vil opprette den kjørbare filen og for øvrig, hvis den ikke eksisterer, katalogen ./bygge.

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

5. Slik installerer du den kjørbare filen i Ubuntu 17

Installering av en kjørbar består av lag .exe -filen og lagre den i GOPATH / bin -bane. For denne prosessen bruker vi kommandoen gå installere som vil lage den kjørbare filen på riktig sted.

Vi vil utføre følgende. Når du utfører kommandoen, vil heller ikke noe resultat være synlig for brukeren, men filen vil ha blitt opprettet i GOPATH / bin -banen.

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

6. bygge kjørbare filer for forskjellige systemer på Ubuntu 17

På dette tidspunktet vil vi se kraften til Go og hvordan den blir en verdifull alliert takket være de mange mulighetene for å lage kjørbare filer.

Trinn 1
Syntaksen som skal implementeres vil være følgende. Kommandoen env har ansvaret for å lage et modifisert miljø for bruk av de respektive variablene.

 env GOOS = OS Goal GOARCH = Arkitektur go build Pakkebane 

Steg 2
Følgende er en tabell med alle alternativene som Go tilbyr oss:

Trinn 3
I dette tilfellet vil vi lage en Windows-kjørbar med en 64-biters amd-arkitektur, vi vil utføre følgende:

 env GOOS = windows GOARCH = amd64 gå bygge github.com/mholt/caddy/caddy 

Som det er vanlig i Go, vil vi ikke se noen synlige resultater, men prosessen er utført internt.

Trinn 4
Dette vil opprette .exe -filen basert på det valgte systemet, og for å kontrollere den vil vi utføre følgende linje:

 ls caddy.exe 

7. Slik oppretter du manuset for tvers-plattform-kompilering i Ubuntu 17

Med dette målet vil vi lage et skript kalt gå-kjørbar-build.bash som vil være et skript som er ansvarlig for å utføre alle samlehandlingene på en praktisk måte og kan brukes på et generelt nivå med full kompatibilitet.

Trinn 1
Til dette vil vi bruke linje cd ~ og vi vil utføre følgende:

 nano go-executable-build.bash

Steg 2
Der må vi legge inn følgende informasjon:

 #! / usr / bin / env bash package = $ 1 if [[-z "$ package"]]; ekko deretter "bruk: $ 0" exit 1 fi package_split = ($ {package // \ //}) package_name = $ {package_split [-1]} plattformer = ("windows / amd64" "windows / 386" "darwin / amd64 ") for plattform i" $ {platforms [@]} "do platform_split = ($ {platform // \ //}) GOOS = $ {platform_split [0]} GOARCH = $ {platform_split [1]} output_name = $ package_name '-' $ GOOS '-' $ GOARCH if [$ GOOS = "windows"]; deretter output_name + = '. exe' fi env GOOS = $ GOOS GOARCH = $ GOARCH gå bygge -o $ output_name $ pakke hvis [$? -ne 0]; ekko deretter 'Det har oppstått en feil! Avbryter kjøring av skriptet … 'exit 1 fi ferdig

Trinn 3
Dette vil være skriptet og funksjonen er følgende:

 #! / usr / bin / env bash: Denne linjen indikerer at tolk vil analysere skriptet. 

 package = $ 1: Denne linjen tar det første argumentet fra kommandolinjen og lagrer det i variabelen. hvis [[-z "$ pakke"]]; ekko deretter "bruk: $ 0" exit 1 fi

Trinn 4
Disse linjene har ansvaret for å vise en melding i tilfelle verdien ikke er angitt.
Parameter hvis analyserer verdien av variabelen pakke.

 package_split = ($ {package // \ //}): Denne linjen deler pakkeimportbanen i en matrise ved hjelp av /delimiter. package_name = $ {package_split [-1]}: Denne linjen tar navnet på matrisen. plattformer = ("windows / amd64" "windows / 386" "darwin / amd64"): Der går vi inn i operativsystemet og arkitekturen som skal opprettes. for plattform i "$ {platforms [@]}" gjør platform_split = ($ {platform // \ //}) GOOS = $ {platform_split [0]} GOARCH = $ {platform_split [1]} Ferdig

Trinn 5
Disse linjene deler plattformverdiene i GOOS- og GOARCH -variablene.

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

Trinn 6
Med denne sekvensen vil vi lage navnet på den kjørbare filen, og når det gjelder Windows -operativsystemer må vi legge til utvidelsen .exe.

 env GOOS = $ GOOS GOARCH = $ GOARCH go build -o $ output_name $ pakke: Denne linjen lar oss lage den kjørbare filen. hvis [$? -ne 0]; ekko deretter 'Det har oppstått en feil! Avbryter kjøring av skriptet … 'exit 1

Trinn 7
Med disse linjene vil en feilmelding vises i tilfelle den kjørbare konstruksjonen er feil.

Trinn 8
Når vi har lagt inn denne informasjonen lagrer vi endringene ved hjelp av tastekombinasjonen

Ctrl + O.

og vi lar redaktøren bruke

Ctrl + X

Trinn 9
Vi vil tildele tillatelsene for at skriptet skal kunne kjøres med følgende linje:

 chmod + x go-executable-build.bash

Trinn 10
Det siste trinnet vil være å teste skriptkonfigurasjonen ved å kjøre følgende. Som vi kan se, har det ikke blitt generert noen feil.

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

8. Hvordan sjekke kjørbare filer i Ubuntu 17

For å kontrollere at vi har riktige kjørbare filer i Go, bare kjør følgende linje:

 er caddy *

Der vil vi se både 32-biters og 64-biters kjørbare filer for det valgte systemet, i dette tilfellet Windows. Hvis vi vil bruke andre plattformer, er det bare å få tilgang til skriptet og gjøre endringene i linjen plattformer.

Vi har sett hvordan Go er en grunnleggende applikasjon når det er nødvendig å ha flere kjørbare filer, noe som letter administrering og distribusjon av disse i organisasjonen.