Go
Compilazione incrociata

introduzione

Sintassi

• GOOS = linux GOARCH = amd64 go build

Osservazioni

Compilare tutte le architetture usando un Makefile

Questo Makefile eseguirà il cross-compile e comprimerà i file eseguibili per Windows, Mac e Linux (ARM e x86).

# Replace demo with your desired executable name
appname := demo

sources := $(wildcard *.go)

build = GOOS=$(1) GOARCH=$(2) go build -o build/$(appname)$(3)
tar = cd build && tar -cvzf $(1)_$(2).tar.gz $(appname)$(3) && rm $(appname)$(3)
zip = cd build && zip $(1)_$(2).zip $(appname)$(3) && rm $(appname)$(3)

.PHONY: all windows darwin linux clean

all: windows darwin linux

clean:
    rm -rf build/

##### LINUX BUILDS #####
linux: build/linux_arm.tar.gz build/linux_arm64.tar.gz build/linux_386.tar.gz build/linux_amd64.tar.gz

build/linux_386.tar.gz: $(sources)
    $(call build,linux,386,)
    $(call tar,linux,386)

build/linux_amd64.tar.gz: $(sources)
    $(call build,linux,amd64,)
    $(call tar,linux,amd64)

build/linux_arm.tar.gz: $(sources)
    $(call build,linux,arm,)
    $(call tar,linux,arm)

build/linux_arm64.tar.gz: $(sources)
    $(call build,linux,arm64,)
    $(call tar,linux,arm64)

##### DARWIN (MAC) BUILDS #####
darwin: build/darwin_amd64.tar.gz

build/darwin_amd64.tar.gz: $(sources)
    $(call build,darwin,amd64,)
    $(call tar,darwin,amd64)

##### WINDOWS BUILDS #####
windows: build/windows_386.zip build/windows_amd64.zip

build/windows_386.zip: $(sources)
    $(call build,windows,386,.exe)
    $(call zip,windows,386,.exe)

build/windows_amd64.zip: $(sources)
    $(call build,windows,amd64,.exe)
    $(call zip,windows,amd64,.exe)

(sii ​​prudente che Makefile abbia bisogno di schede rigide e non spazi )

Semplice compilazione incrociata con go build

Dalla directory del progetto, eseguire il comando go build e specificare il sistema operativo e la destinazione dell'architettura con le variabili di ambiente GOOS e GOARCH :

Compilazione per Mac (64 bit):

GOOS=darwin GOARCH=amd64 go build

Compilazione per il processore x86 di Windows:

GOOS=windows GOARCH=386 go build

Si potrebbe anche voler impostare manualmente il nome file dell'eseguibile di output per tenere traccia dell'architettura:

GOOS=windows GOARCH=386 go build -o appname_win_x86.exe

Dalla versione 1.7 in poi è possibile ottenere un elenco di tutte le possibili combinazioni GOOS e GOARCH con:

go tool dist list

(o per un consumo più semplice della macchina, go tool dist list -json )

Compilazione incrociata usando gox

Un'altra soluzione conveniente per la compilazione incrociata è l'utilizzo di gox : https://github.com/mitchellh/gox

Installazione

L'installazione viene eseguita molto facilmente eseguendo go get github.com/mitchellh/gox . L'eseguibile risultante viene inserito nella directory binaria di Go, ad esempio /golang/bin o ~/golang/bin . Assicurati che questa cartella sia parte del tuo percorso per poter utilizzare il comando gox da una posizione arbitraria.

uso

All'interno della cartella radice di un progetto Go (dove si esegue es. go build ), eseguire gox per creare tutti i possibili binari per qualsiasi architettura (ad esempio x86, ARM) e il sistema operativo (ad es. Linux, macOS, Windows) che è disponibile.

Per costruire per un determinato sistema operativo, usa ad esempio gox -os="linux" . Anche l'opzione architettura potrebbe essere definita: gox -osarch="linux/amd64" .

Semplice esempio: compila helloworld.go per l'architettura arm sulla macchina Linux

Preparare helloworld.go (trova sotto)

package main

import "fmt"

func main(){
        fmt.Println("hello world")
}

Esegui GOOS=linux GOARCH=arm go build helloworld.go

Copia il file helloworld (arm eseguibile) generato nel computer di destinazione.