Come creare eseguibili GO in Ubuntu 17

Uno dei sistemi operativi più versatili in Linux È senza dubbio Ubuntu che, grazie alle sue funzionalità, ci offre un ambiente sicuro e altamente configurabile.

Oltre a questo grande vantaggio, possiamo trovare numerosi strumenti e applicazioni che consentono di aumentare i livelli di prestazioni e produttività offerti da Ubuntu e in base a questa possibilità oggi analizzeremo uno strumento che ci offre la possibilità di creare file eseguibili di vari sistemi operativi per essere successivamente eseguiti con completa sicurezza, questo strumento si chiama andare.

Cos'è GOGo è un'applicazione open source che ci consente di creare software semplice, affidabile e altamente produttivo.

Go è stato progettato con un ampio portafoglio di strumenti che consentono di ottenere pacchetti e creare eseguibili in modo pratico.

Con Go, in qualità di amministratori di sistema, avremo la possibilità di creare eseguibili per più sistemi operativi e gestirli tutti da un unico server senza la necessità di recarci su ciascuna piattaforma per scaricare l'eseguibile corrispondente.

Con Go possiamo creare eseguibili per Windows, Linux, Mac OS, tra gli altri.

Prima di passare a vedere come creare l'eseguibile daremo una breve rassegna di come installare Go in Ubuntu 17.

1. Come installare e aggiornare il sistema Ubuntu 17

Passo 1
Il primo passo da eseguire è eseguire i seguenti comandi per aggiornare i pacchetti di sistema e le rispettive correzioni di bug:

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

Passo 2
Una volta aggiornato il sistema, procediamo al download dei rispettivi binari di Go eseguendo la seguente riga:

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

INGRANDIRE

NotaIn caso di richiesta dei binari per le edizioni a 32 bit, possiamo andare al seguente link:

Passaggio 3
Una volta scaricato il file, procediamo alla sua estrazione eseguendo la seguente riga:

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

INGRANDIRE

Passaggio 4
Sposteremo il contenuto nel percorso /usr/local:

 sudo mv go / usr / local

2. Come regolare l'ambiente Go Ubuntu 17

Passo 1
Affinché Go funzioni correttamente, sarà necessario inserire le seguenti righe associate al percorso e all'accesso di Go:

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

INGRANDIRE

Passo 2
È importante notare che il percorso GOPATH è dove verranno ospitati i file di build.
Fatto ciò, possiamo eseguire i seguenti comandi per verificare la versione e l'ambiente di Go:

 vai versione vai env

INGRANDIRE

Passaggio 3
Con questo abbiamo già installato Go e possiamo procedere alla creazione degli eseguibili.
Va notato che la versione Go 1.8 è attualmente in beta, ma se vogliamo installarla possiamo eseguire i seguenti comandi:

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

3. Come scaricare il codice sorgente in Ubuntu 17

Questo è il passaggio iniziale prima di creare qualsiasi eseguibile con Go, ottenendo il suo codice sorgente che otteniamo utilizzando il parametro go get.

Il processo include clonando i pacchetti nel percorso GOPATH / src / e in seguito, se li applichi, verranno compilati nel percorso GOPATH / bin.

Passo 1
La sintassi da utilizzare per scaricare il codice sorgente è:

 vai a prendere (percorso del pacchetto)

Il percorso si trova solitamente alla base di Github. Aggiungeremo anche il parametro -o che installa tutte le dipendenze o l'aggiornamento di queste.

Passo 2
Per questo caso utilizzeremo Caddy che è un web server scritto in Go ed eseguiremo la seguente riga per scaricarlo:

 vai a prendere -u github.com/mholt/caddy/caddy

Passaggio 3
Come possiamo vedere, non viene visualizzato alcun risultato visibile ma tutto il contenuto verrà memorizzato nel percorso

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

Se vogliamo verificarlo, possiamo eseguire la riga quale caddie. In alcuni casi, Errori associati a Git, per questo eseguiremo quanto segue per la sua correzione:

 sudo apt install git

4. Come compilare l'eseguibile in Ubuntu 17

Passo 1
Una volta che Caddy è stato scaricato e per questo eseguiremo la seguente riga:

 vai a costruire github.com/mholt/caddy/caddy 

Passo 2
Anche questo comando non visualizzerà alcun risultato visibile. Se vogliamo specificare un percorso speciale, possiamo aggiungere il parametro -o come segue. Possiamo cambiare il percorso build/caddy-server per quello desiderato. Questo comando creerà il file eseguibile e incidentalmente, se non esiste, la directory ./costruire.

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

5. Come installare l'eseguibile in Ubuntu 17

L'installazione di un eseguibile consiste in creare il file .exe e conservalo in GOPATH / percorso bin. Per questo processo useremo il comando vai all'installazione che creerà l'eseguibile nella posizione corretta.

Eseguiremo quanto segue. Durante l'esecuzione del comando, nessun risultato sarà visibile nemmeno all'utente, ma il file sarà stato creato nel percorso GOPATH / bin.

 vai a installare github.com/mholt/caddy/caddy 

6. crea eseguibili per vari sistemi su Ubuntu 17

A questo punto vedremo la potenza di Go e come diventi un prezioso alleato grazie alle molteplici possibilità di creare eseguibili.

Passo 1
La sintassi da implementare sarà la seguente. Il comando env ha il compito di creare un ambiente modificato per l'utilizzo delle rispettive variabili.

 env GOOS = Obiettivo del sistema operativo GOARCH = Architecture go build Percorso del pacchetto 

Passo 2
Quella che segue è una tabella con tutte le opzioni che Go ci offre:

Passaggio 3
In questo caso creeremo un eseguibile Windows con architettura amd a 64 bit, eseguiremo quanto segue:

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

Come è consuetudine in Go, non vedremo alcun risultato visibile, ma il processo è stato eseguito internamente.

Passaggio 4
Questo creerà il file .exe in base al sistema scelto e per verificarlo eseguiremo la seguente riga:

 ls caddy.exe 

7. Come creare lo script per la compilazione multipiattaforma in Ubuntu 17

Con questo obiettivo creeremo uno script chiamato go-executable-build.bash che sarà uno script che si occupa di svolgere tutte le azioni di compilazione in modo pratico e può essere utilizzato a livello generale con piena compatibilità.

Passo 1
Per questo useremo il linea cd ~ ed eseguiremo quanto segue:

 nano go-executable-build.bash

Passo 2
Lì dobbiamo inserire le seguenti informazioni:

 #! / usr / bin / env bash pacchetto = $ 1 if [[-z "$ pacchetto"]]; then echo "usage: $ 0" exit 1 fi package_split = ($ {package // \ //}) package_name = $ {package_split [-1]} piattaforme = ("windows / amd64" "windows / 386" "darwin / amd64 ") for platform in" $ {platforms [@]} "do platform_split = ($ {platform // \ //}) GOOS = $ {platform_split [0]} GOARCH = $ {platform_split [1]} output_name = $ nome_pacchetto '-' $ GOOS '-' $ GOARCH if [$ GOOS = "windows"]; then output_name + = '.exe' fi env GOOS = $ GOOS GOARCH = $ GOARCH go build -o $ output_name $ pacchetto if [$? -ne 0]; then echo 'Si è verificato un errore! Interruzione dell'esecuzione dello script… 'exit 1 fi done

Passaggio 3
Questo sarà lo script e la sua funzione è la seguente:

 #! / usr / bin / env bash: questa riga indica che l'interprete analizzerà lo script. 

 pacchetto = $ 1: Questa riga prenderà il primo argomento dalla riga di comando e lo memorizzerà nella sua variabile. if [[-z "$ pacchetto"]]; poi echo "utilizzo: $ 0" exit 1 fi

Passaggio 4
Queste righe hanno il compito di visualizzare un messaggio nel caso in cui il valore non sia stato inserito.
Parametro Se analizza il valore della variabile pacchetto.

 package_split = ($ {package // \ //}): questa riga divide il percorso di importazione del pacchetto in un array utilizzando il delimitatore /. package_name = $ {package_split [-1]}: questa riga prende il nome dell'array. platform = ("windows / amd64" "windows / 386" "darwin / amd64"): Lì entreremo nel sistema operativo e nell'architettura da creare. per la piattaforma in "$ {platforms [@]}" do platform_split = ($ {platform // \ //}) GOOS = $ {platform_split [0]} GOARCH = $ {platform_split [1]} Fatto

Passaggio 5
Queste linee dividono i valori della piattaforma nelle variabili GOOS e GOARCH.

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

Passaggio 6
Con questa sequenza creeremo il nome dell'eseguibile e quando si tratta di sistemi operativi Windows dobbiamo aggiungere l'estensione .exe.

 env GOOS = $ GOOS GOARCH = $ GOARCH go build -o $ nome_output $ pacchetto: Questa riga ci permette di creare il file eseguibile. se [$? -ne 0]; then echo 'Si è verificato un errore! Interruzione dell'esecuzione dello script… 'exit 1'

Passaggio 7
Con queste righe verrà visualizzato un messaggio di errore nel caso in cui la costruzione dell'eseguibile sia errata.

Passaggio 8
Una volta inserite queste informazioni, salviamo le modifiche utilizzando la combinazione di tasti

Ctrl + O

e lasciamo l'editor usando

Ctrl + X

Passaggio 9
Assegniamo i permessi affinché lo script sia eseguibile utilizzando la seguente riga:

 chmod + x go-executable-build.bash

Passaggio 10
L'ultimo passaggio sarà testare la configurazione dello script eseguendo quanto segue. Come possiamo vedere, non è stato generato alcun errore.

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

8. Come controllare i file eseguibili in Ubuntu 17

Per verificare di avere gli eseguibili corretti in Go, basta eseguire la seguente riga:

 caddie *

Lì vedremo sia gli eseguibili a 32 bit che a 64 bit per il sistema selezionato, in questo caso Windows. Se vogliamo usare altre piattaforme, basta accedere allo script e apportare le modifiche nella riga piattaforme.

Abbiamo visto come Go sia un'applicazione fondamentale quando è necessario disporre di più eseguibili, facilitandone la gestione e la distribuzione all'interno dell'organizzazione.