Introduzione

Il comando go run per compilare automaticamente il codice sorgente ed eseguire l'eseguibile risultante è utile per testare il codice sulla riga di comando, per distribuire o distribuire l'applicazione è necessario creare il codice in un eseguibile binario condivisibile o in un singolo file contenente il codice byte macchina che può eseguire l'applicazione. Per fare questo, è possibile utilizzare il toolchain Go per compilare e installare il programma.

In Go, il processo di traduzione del codice sorgente in un eseguibile binario è chiamato building. Una volta creato questo eseguibile, conterrà non solo la tua applicazione, ma anche tutto il codice di supporto necessario per eseguire il binario sulla piattaforma di destinazione. Ciò significa che un binario Go non ha bisogno sistema di dipendenze come Go per l'esecuzione su un nuovo sistema, a differenza di altri linguaggi come Ruby, Python  o Node.js. Inserendo questi file eseguibili in un percorso file eseguibile sul proprio sistema, sarà possibile eseguire il programma da qualsiasi punto del sistema.

In questa esercitazione, verrà utilizzata la toolchain Go per eseguire, creare e installare un programma di esempio Hello, World!, che consente di utilizzare e distribuire le applicazioni future in modo efficace.

Prerequisiti

Per seguire l'esempio in questo articolo, avrai bisogno di Go installato sul tuo sistema:

Installare ed eseguire Go Binary

Innanzitutto, creiamo un'applicazione da utilizzare come esempio per la toolchain Go. Per fare questo, utilizzeremo il classico programma Hello, World!.

Crea una directory chiamata greeter nella tua directory src:

mkdir greeter

Quindi, passa alla directory appena creata, con il comando cd, e crea il file main.go nell'editor di testo che preferisci:

cd greeter
nano main.go

Una volta aperto il file, aggiungi i seguenti contenuti:

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}
src/greeter/main.go

Quando eseguito, questo programma stamperà la frase Hello, World! sulla console, quindi il programma verrà chiuso correttamente.

Salva ed esci dal file.

Per testare il programma, usa il comando go run:

go run main.go

Riceverai il seguente output:

Hello, World!

Come accennato in precedenza, il comando go run ha incorporato il file sorgente in un file binario eseguibile, quindi ha eseguito il programma compilato. Tuttavia, questo tutorial mira a costruire il binario in modo tale da poterlo condividere e distribuire a piacimento. Per fare ciò, utilizzerai il comando go build nel passaggio successivo.

Costruire i binari con go build

Utilizzando go build, è possibile generare un file binario eseguibile per la nostra applicazione Go di esempio, che consente di distribuire e distribuire il programma dove si desidera.

Prova questo con main.go. Nella tua directory greeter, esegui il seguente comando:

go build

Se non si fornisce un argomento a questo comando, go build compilerà automaticamente il programma nella directory corrente main.go. Il comando includerà tutti i tuoi file *.go nella directory. Costruirà anche tutto il codice di supporto necessario per essere in grado di eseguire il file binario su qualsiasi computer con la stessa architettura di sistema, indipendentemente dal fatto che quel sistema abbia i file .go di origine o persino un'installazione Go.

In questo caso, l'applicazione greeter è stata creata in un file eseguibile che è stato aggiunto alla directory corrente. Controlla questo eseguendo il comando ls:

ls

Se stai eseguendo macOS o Linux, troverai un nuovo file eseguibile che è stato nominato dopo la directory in cui hai creato il tuo programma:

greeter  main.go
Nota: su Windows, l'eseguibile sarà greeter.exe.

Per impostazione predefinita go build genererà un eseguibile per la piattaforma e l'architettura correnti. Ad esempio, se costruito su un sistema linux/386, l'eseguibile sarà compatibile con qualsiasi altro sistema linux/386, anche se Go non è installato.

Ora che hai creato il tuo eseguibile, eseguilo per assicurarti che il binario sia stato creato correttamente. Su macOS o Linux, esegui il seguente comando:

./greeter

Su Windows, esegui:

greeter.exe

L'output del binario corrisponderà all'output di quando hai eseguito il programma con go run:

Hello, World!

Ora hai creato un singolo binario eseguibile che contiene, non solo il tuo programma, ma anche tutto il codice di sistema necessario per eseguire quel binario. Ora puoi distribuire questo programma su nuovi sistemi o distribuirlo su un server, sapendo che il file eseguirà sempre lo stesso programma.

Nella prossima sezione, questo tutorial spiegherà come viene chiamato un binario e come puoi cambiarlo, in modo da poter avere un miglior controllo sul processo di compilazione del tuo programma.

Modificare il nome binario

Ora che sai come generare un eseguibile, il passo successivo è identificare come Go sceglie un nome per il binario e personalizzare questo nome per il tuo progetto.

Quando si esegue go build, l'impostazione predefinita è Go per decidere automaticamente il nome dell'eseguibile generato. Lo fa in due modi: Se stai usando Go Modules, Go utilizzerà l'ultima parte del nome del tuo modulo; in caso contrario, Go utilizzerà il nome della directory corrente. Questo è il metodo utilizzato nell'ultima sezione, quando è stata creata la directory greeter, modificata in essa e quindi eseguita go build.

Diamo un'occhiata più da vicino al metodo del modulo. Se nel progetto era presente un file go.mod con una dichiarazione module come la seguente:

module github.com/noviello/shark
go.mod

Quindi il nome predefinito per l'eseguibile generato sarebbe shark.

Nei programmi più complessi che richiedono convenzioni di denominazione specifiche, questi valori predefiniti non saranno sempre la scelta migliore per nominare il tuo binario. In questi casi, sarebbe meglio personalizzare l'output con il flag -o.

Per provarlo, cambia il nome del file eseguibile che hai creato nell'ultima sezione in hello e posizionalo in una sottocartella chiamata bin. Non è necessario creare questa cartella, Go lo farà da solo durante il processo di compilazione.

Esegui il comando go build seguente con il flag -o:

go build -o bin/hello

Il flag -o fa in modo che Go corrisponda l'output del comando a qualsiasi argomento tu abbia scelto. In questo caso, il risultato è un nuovo eseguibile denominato hello in una sottocartella denominata bin.

Per testare il nuovo eseguibile, passa alla nuova directory ed esegui il binario:

cd bin
./hello

Riceverai il seguente output:

Hello, World!

Ora puoi personalizzare il nome del tuo eseguibile per adattarlo alle esigenze del tuo progetto. Ma con go build, sei ancora limitato all'esecuzione del tuo binario dalla directory corrente. Per utilizzare gli eseguibili da qualsiasi parte del sistema, è possibile installarlo utilizzando go install.

Installare i programmi Go con go install

Finora in questo articolo, abbiamo discusso su come generare file binari eseguibili dai nostri file di origine .go. Questi eseguibili sono utili per distribuire e testare, ma non possono ancora essere eseguiti al di fuori delle loro directory di origine. Questo sarebbe un problema se si desidera utilizzare attivamente il programma, ad esempio se si è sviluppato uno strumento da riga di comando per aiutare il flusso di lavoro sul proprio sistema. Per semplificare l'utilizzo dei programmi, è possibile installarli nel sistema e accedervi da qualsiasi luogo.

Per capire cosa si intende con questo, si utilizzerà il comando go install per installare l'applicazione di esempio.

Il comando go install si comporta in modo quasi identico a go build, ma invece di lasciare l'eseguibile nella directory corrente o in una directory specificata dal flag -o, posiziona l'eseguibile nella directory $GOPATH/bin.

Per trovare dove si trova la tua directory $GOPATH, esegui il seguente comando:

go env GOPATH

L'output ricevuto varierà, ma l'impostazione predefinita è la directory go all'interno della directory $HOME:

$HOME/go

Poiché go install inserirà gli eseguibili generati in una sottodirectory di $GOPATH denominata bin, questa directory deve essere aggiunta alla variabile di ambiente $PATH.

Con la directory impostata $GOPATH/bin, tornare alla directory greeter:

cd ..

Ora esegui il comando di installazione:

go install

Questo costruirà il tuo binario e lo inserirà $GOPATH/bin. Per verificare ciò, eseguire quanto segue:

ls $GOPATH/bin

Questo elencherà i contenuti di $GOPATH/bin:

greeter
Nota: il comando go install non supporta il flag -o, quindi utilizzerà uno dei nomi predefiniti descritti in precedenza per denominare l'eseguibile.

Con il file binario installato, verifica se il programma verrà eseguito dall'esterno della directory di origine. Torna alla tua home directory:

cd $HOME

Utilizzare quanto segue per eseguire il programma:

greeter

Ciò produrrà quanto segue:

Hello, World!

Ora puoi prendere i programmi che scrivi e installarli nel tuo sistema, permettendoti di usarli ovunque, quando ne hai bisogno.

Conclusione

In questo tutorial, hai imparato in che modo la toolchain Go semplifica la creazione di file binari eseguibili dal codice sorgente. Questi binari possono essere distribuiti per essere eseguiti su altri sistemi, anche su quelli che non dispongono di strumenti e ambienti Go. Inoltre, go install crea e installa automaticamente i nostri programmi come file eseguibili nei sistemi $PATH. Con go build e go install, ora hai la possibilità di condividere e utilizzare la tua applicazione a piacimento.