Compilazione incrociata Vai su OSX?

Sto cercando di compilare in modo incrociato un'app go su OSX per creare binari per Windows e Linux. Ho letto tutto quello che ho potuto trovare in rete. L'esempio più vicino che ho trovato è stato pubblicato su (a parte molte discussioni non finite sulla mailing list go-nuts):

http://solovyov.net/en/2012/03/09/cross-compiling-go/

tuttavia non funziona sulla mia installazione. Sono andato 1.0.2. Poiché 1.0.2 è abbastanza recente, mi sembra che tutti gli esempi sopra riportati non si applichino a questa versione.

Ho provato a fare ./make.bash --no-cleancon ENV vars impostato su 386 / windows, build go go, tuttavia build va per la mia installazione che è darwin/amd64e ignora completamente ciò che è impostato in ENV che suppone di costruire un compilatore diverso.

Qualcuno consiglia come può essere fatto (se può essere fatto affatto)?

Con Go 1.5 sembrano aver migliorato il processo di compilazione incrociata, il che significa che è integrato ora. Nessuna necessità ./make.basho brewnecessità. Il processo è descritto qui, ma per i TLDR (come me) là fuori: hai appena impostato il GOOSe ilGOARCH variabili e ambiente ed eseguire go build.

Per i copia-paster ancora più pigri (come me) là fuori, fai qualcosa di simile se sei su un sistema * nix:

env GOOS=linux GOARCH=arm go build -v github.com/path/to/your/app

Hai persino imparato il envtrucco, che ti consente di impostare le variabili di ambiente solo per quel comando, completamente gratuito.

Grazie al gentile e paziente aiuto delle noci di Golang, la ricetta è la seguente:

1) È necessario compilare il compilatore Go per diverse piattaforme e architetture di destinazione. Questo viene fatto dalla cartella src nell'installazione go. Nel mio caso, l'installazione di Go si trova in /usr/local/gomodo da compilare un compilatore che è necessario emettere makeutility. Prima di farlo devi conoscere alcuni avvertimenti.

Si è verificato un problema con la libreria CGO durante la compilazione incrociata, pertanto è necessario disabilitare la libreria CGO.

La compilazione viene eseguita modificando la posizione nella directory di origine, poiché la compilazione deve essere eseguita in quella cartella

cd /usr/local/go/src

quindi compilare il compilatore Go:

sudo GOOS=windows GOARCH=386 CGO_ENABLED=0 ./make.bash --no-clean

È necessario ripetere questo passaggio per ciascun sistema operativo e architettura che si desidera incrociare compilando modificando i parametri GOOS e GOARCH.

Se lavori in modalità utente come faccio io, sudo è necessario perché il compilatore Go è nella directory di sistema. Altrimenti devi essere loggato come superutente. Su Mac potrebbe essere necessario abilitare / configurare l'accesso SU (non è disponibile per impostazione predefinita), ma se sei riuscito a installare Go potresti avere già l'accesso root.

2) Dopo aver creato tutti i compilatori incrociati, è possibile compilare felicemente l'applicazione compilando ad esempio le seguenti impostazioni:

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

GOOS=linux GOARCH=386 CGO_ENABLED=0 go build -o appname.linux appname.go

Cambia GOOS e GOARCH in target che desideri costruire.

In caso di problemi con CGO, includere CGO_ENABLED = 0 nella riga di comando. Si noti inoltre che i file binari per Linux e Mac non hanno estensione, quindi è possibile aggiungere l'estensione per avere file diversi. -o switch indica Go per rendere il file di output simile ai vecchi compilatori per c / c ++, quindi appname.linux sopra usato può essere qualsiasi altra estensione.

Se usi Homebrew su OS X, hai una soluzione più semplice:

$ brew install go --with-cc-common # Linux, Darwin, and Windows

o..

$ brew install go --with-cc-all # All the cross-compilers

Utilizzare reinstallse si è già goinstallato.

Puoi farlo abbastanza facilmente usando Docker, quindi non sono necessarie ulteriori librerie. Basta eseguire questo comando:

docker run --rm -it -v "$GOPATH":/go -w /go/src/github.com/iron-io/ironcli golang:1.4.2-cross sh -c '
for GOOS in darwin linux windows; do
  for GOARCH in 386 amd64; do
    echo "Building $GOOS-$GOARCH"
    export GOOS=$GOOS
    export GOARCH=$GOARCH
    go build -o bin/ironcli-$GOOS-$GOARCH
  done
done
'

Puoi trovare maggiori dettagli in questo post: https://medium.com/iron-io-blog/how-to-cross-compile-go-programs-using-docker-beaa102a316d

Il processo di creazione di eseguibili per molte piattaforme può essere un po 'noioso, quindi suggerisco di usare uno script:

#!/usr/bin/env bash

package=$1
if [[ -z "$package" ]]; then
  echo "usage: $0 <package-name>"
  exit 1
fi
package_name=$package

#the full list of the platforms: https://golang.org/doc/install/source#environment
platforms=(
"darwin/386"
"dragonfly/amd64"
"freebsd/386"
"freebsd/amd64"
"freebsd/arm"
"linux/386"
"linux/amd64"
"linux/arm"
"linux/arm64"
"netbsd/386"
"netbsd/amd64"
"netbsd/arm"
"openbsd/386"
"openbsd/amd64"
"openbsd/arm"
"plan9/386"
"plan9/amd64"
"solaris/amd64"
"windows/amd64"
"windows/386" )

for platform in "${platforms[@]}"
do
    platform_split=(${platform//\// })
    GOOS=${platform_split[0]}
    GOARCH=${platform_split[1]}
    output_name=$package_name'-'$GOOS'-'$GOARCH
    if [ $GOOS = "windows" ]; then
        output_name+='.exe'
    fi

    env GOOS=$GOOS GOARCH=$GOARCH go build -o $output_name $package
    if [ $? -ne 0 ]; then
        echo 'An error has occurred! Aborting the script execution...'
        exit 1
    fi
done

Ho controllato questo script solo su OSX

gist - go-executable-build.sh

per le persone che necessitano di CGO abilitato e compilazione incrociata dalle finestre di targeting OSX

Avevo bisogno di abilitare CGO durante la compilazione per Windows dal mio mac poiché avevo importato https://github.com/mattn/go-sqlite3 e ne aveva bisogno. Compilare secondo altre risposte mi ha dato ed errore:

/usr/local/go/src/runtime/cgo/gcc_windows_amd64.c:8:10: fatal error: 'windows.h' file not found

Se sei come me e devi compilare con CGO. Questo è quello che ho fatto:

1. Effettueremo la compilazione incrociata per Windows con una libreria dipendente dalla CGO. Per prima cosa abbiamo bisogno di un compilatore incrociato installato comemingw-w64

brew install mingw-w64

Questo probabilmente lo installerà qui /usr/local/opt/mingw-w64/bin/ .

2. Proprio come le altre risposte, per prima cosa dobbiamo aggiungere il nostro arco di Windows alla nostra toolchain di compilatore go ora. La compilazione di un compilatore richiede un compilatore (frase strana), mentre il compilatore go richiede un compilatore predefinito separato. Possiamo scaricare un binario predefinito o compilare dal sorgente in una cartella, ad esempio: ~/Documents/go ora possiamo migliorare il nostro compilatore Go, in base alla risposta più alta, ma questa volta con CGO_ENABLED=1e il nostro compilatore precompilato separato GOROOT_BOOTSTRAP(Pooya è il mio nome utente):

cd /usr/local/go/src
sudo GOOS=windows GOARCH=amd64 CGO_ENABLED=1 GOROOT_BOOTSTRAP=/Users/Pooya/Documents/go ./make.bash --no-clean
sudo GOOS=windows GOARCH=386 CGO_ENABLED=1 GOROOT_BOOTSTRAP=/Users/Pooya/Documents/go ./make.bash --no-clean

3.Ora durante la compilazione del nostro codice Go utilizzare mingwper compilare il nostro file go targeting windows con CGO abilitato:

GOOS="windows" GOARCH="386" CGO_ENABLED="1" CC="/usr/local/opt/mingw-w64/bin/i686-w64-mingw32-gcc" go build hello.go
GOOS="windows" GOARCH="amd64" CGO_ENABLED="1" CC="/usr/local/opt/mingw-w64/bin/x86_64-w64-mingw32-gcc" go build hello.go