La Cross-compilazione Andare su OSX?

Sto cercando di cross-compilare un go app, su OSX, per costruire i binari per windows e linux. Ho letto tutto quello che ho potuto trovare in rete. Più vicina esempio che ho trovato è stato pubblicato su (oltre a molti incompiuta discussioni sui go-noci mailing list):

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

ancora non funziona sulla mia installazione. Devo andare 1.0.2. Come 1.0.2 è abbastanza recente a me sembra che tutti esempi di cui sopra non si applicano a questa versione.

Provato a fare ./make.bash --no-clean ENV vars insieme a 386/windows, fa costruire go, tuttavia si costruisce per il mio impianto che è darwin/amd64 e ignora completamente ciò che è impostato in ENV che supponiamo di costruire diverse compilatore.

Eventuali consigli come si può fare (se si può fare)?

  • in parallelo a questo, ho chiesto la stessa domanda su golang-noci mailing list, e con l’aiuto e la pazienza di gente che c’è definitivo ricetta ha cucinato… questo è il thread di discussione: groups.google.com/forum/?fromgroups=#!argomento/golang-noci/… ci sono stati diversi passaggi e conclusioni, ho sbagliato il modo, ma ora la ricetta sembra abbastanza semplice – 3 fasi e alcune iterazioni.
  • ora che sto andando oltre il recap, mi aggiro perché ENV vars non attivato corretta compilazione – forse perché ho fatto sudo (probabile che vorrei ottenere diversi unix ENV quando usare sudo in modo GOOS & GOARCH non sarebbero disponibili se non vengono fatti inline)
  • re: jdi – stavo solo cercando di compilare il mio “mockup” go app per win/lin binari su mac, ma, per farlo ho dovuto costruire go stessa per ogni combinazione di piattaforma/processore. (non può rispondere alla mia domanda ancora – non avendo sufficiente reputazione qui)
  • Hai tipo esattamente quello che ho detto nell’esempio? CGO_ENABLED=0 GOOS=windows GOARCH=amd64 ./make.bash – se si è tentato di dividere su più di una riga, la variabile di ambiente non essere esportati che si adatta i sintomi
  • Fare attenzione a non confondere host di destinazione e di architettura. Si dovrebbe vedere questa uscita: “# Costruzione di compilatori e Andare bootstrap strumento per host, darwin/amd64.” “# La creazione di pacchetti e i comandi per l’host, darwin/amd64.” “# La creazione di pacchetti e i comandi per windows/386.”
  • Questo mi ha aiutato molto: code.google.com/p/go-wiki/wiki/WindowsCrossCompiling
  • per: code.google.com/p/go-wiki/wiki/WindowsCrossCompiling mi ha aiutato molto, ma su un ultimo line – come compilare il target. Il resto è confusione per me, lo è per qualcuno che conosce gli script di shell in dettagli e sembra che è costruito per l’installazione di linux, forse sarebbe il lavoro su mac quindi non ho seguito quello che ho voluto imparare la procedura esatta. Io non sono bravo con gli script di shell.
  • Re Nick: Sì, inizialmente ho fatto export GOOS=windows e tutti gli altri, prima di procedere alla compilazione compilatori. Io non so che cosa fare non ho pensato di non fare cross compilazione mia app, ma poi ho imparato davvero compila un compilatore. SUDO non possono ereditare ENV così ho il sospetto che alcuni dei miei primi tentativi sono falliti a causa di questo UNIX avvertimento.
  • la pagina wiki: sì, funziona bene su mac, ma hai ragione, avete bisogno di un po ‘ di script di shell conoscenza. Dopo aver eseguito lo script, posso farlo ora: impostare le variabili di ambiente GOARCH e GOOS e la compilazione costruisce un lavoro binari per la piattaforma/sistema operativo in queste variabili.
  • Presumo che in molti casi x-compilazione succede se si sta lavorando sul codice su alcune workstation che poi viene distribuito ad alcuni server che si occupa di altri os. Ad esempio, io di sviluppare su Mac e distribuire su Linux e il mio ciclo sarebbe la scrittura di codice, la compilazione per linux, il trasferimento di server. In tal caso presumo esportazione di GOOS/GOARCH sarebbe la soluzione migliore. La definizione di inline è migliore opzione per me, perché il mio tentativo è quello di scrivere un’app che possono essere distribuite su diversi Sistemi operativi.
  • sudo pulisce l’ambiente, in modo che potrebbe aver contribuito al problema. Vedere l’argomento-E per sudo, se si ha realmente bisogno.
  • Ho trovato questo articolo a proposito di cross-compilazione di andare. Il ragazzo che ha scritto ha anche un molto utile util per esso.

InformationsquelleAutor ljgww | 2012-08-28



6 Replies
  1. 127

    Con 1,5 sembrano aver migliorato la croce processo di compilazione, il che significa che è costruito in ora. Non ./make.bash-ing o brew-ing richiesto. Il processo è descritto qui ma per il TLDR-ers (come me) che c’è: è sufficiente impostare il GOOS e il GOARCH variabili di ambiente e avviare go costruire.

    Per l’ancora più pigro copia-sbobinatori (come me) là fuori, fare qualcosa di simile a questo, se siete su un sistema *nix:

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

    È anche imparato il env trucco, che consentono di impostare le variabili di ambiente per il comando, in modo completamente gratuito.

    • C’è un vantaggio per env FOO=bar cmd oltre FOO=bar cmd?
    • Il env comando viene eseguito solo che chiamare in un ambiente personalizzato e ‘azzera’ dopo che è stato fatto. Ad esempio, eseguire export GOOS=windows, quindi il comando con o senza il env e echo $GOOS dopo. Con il env GOOS non è stato modificato.
    • lo stesso è vero (almeno in Bash) senza env. Ho eseguito export GOOS=windows poi GOOS=linux bash -c 'echo "GOOS: $GOOS"' poi echo "GOOS: $GOOS". Non env garantire la maggiore compatibilità con altre shell dialetti o con altre piattaforme? Se non ci sembra superfluo qui.
    • Dopo aver perso un po ‘ di più, ti sembra di essere corretto in questo caso. Tuttavia l’uso di GOOS=windows senza il comando riportato di seguito (accidentalmente l’aggiunta di un && per esempio) farà la stessa export GOOS=windows e impostare la variabile di ambiente, quindi dovrete stare attenti lì. Il env garanzie di lasciare l’ambiente in tatto, e ha più funzioni utili, ad esempio l’aggiunta di -i vi darà un ambiente vuoto, e la sua esecuzione, senza alcun comando di stampa corrente variabili di ambiente. man env vi darà tutti i dettagli.
    • In BASH sono equivalenti. Mentre in alcune altre Shell, ad esempio PESCE shell, esso non supporta FOO=bar cmd, quindi devi usare env FOO=bar cmd. Quindi penso che il più grande vantaggio di utilizzare env FOO=bar cmd è la compatibilità.
    • Incredibile risposta proprio qui. Hai risolto il mio problema, mi ha insegnato un nuovo trucco, e mi ha fatto sorridere tra me e me.
    • Grande risposta, grazie! Per la compilazione per l’uso su heroku (intel x86) ho leggermente modificato la linea di env GOOS=linux GOARCH=386 go build -v github.com/path/to/your/app e funziona come un campione

  2. 134

    Grazie per la gentile e paziente aiuto golang le noci, la ricetta è la seguente:

    1) si deve compilare Andare compilatore per i vari target di piattaforme e architetture. Questo è fatto da src cartella in vai di installazione. Nel mio caso Andare installazione è situato in /usr/local/go, quindi, di compilare un compilatore è necessario emettere make utilità. Prima di fare questo, è necessario sapere alcune cose.

    C’è un problema CGO libreria quando cross compiling quindi è necessario disattivare CGO biblioteca.

    Compilazione viene fatto modificando la posizione di origine dir, dal momento che la compilazione deve essere fatta in quella cartella

    cd /usr/local/go/src

    quindi compilare il Passare del compilatore:

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

    È necessario ripetere questo passaggio per ogni OS e di Architettura che si desidera per la cross-compilazione cambiando il GOOS e GOARCH parametri.

    Se si lavora in modalità utente, come faccio io, sudo è necessaria perché Andare compilatore è nel sistema dir. In caso contrario è necessario essere registrati come super utente. Su Mac, potrebbe essere necessario abilitare e configurare SU accesso (non è disponibile per impostazione predefinita), ma se sono riuscito a installare Go è probabilmente già avete accesso root.

    2) una Volta che avete tutte croce compilatori costruito, si può tranquillamente croce compilare la vostra applicazione utilizzando le seguenti impostazioni per esempio:

    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

    Cambiare il GOOS e GOARCH per gli obiettivi che si desidera costruire.

    Se si verificano problemi con CGO includono CGO_ENABLED=0 nella riga di comando. Nota anche che i binari per linux e mac non hanno estensione, può aggiungere l’estensione per il gusto di avere un file diversi. -o parametro consente di Andare a fare file di output simile a quello dei vecchi compilatori per c/c++, quindi, utilizzato soprattutto appname.linux può essere qualsiasi altra estensione.

    • Quello che inizialmente mi ha confuso è che nella prima parte della compilation fare dice: # Building compilers and Go bootstrap tool for host, darwin/amd64 ma poi si finisce, infatti, come: --- Installed Go for windows/386 in /usr/local/go Installed commands in /usr/local/go/bin così si deve osservare che termina piuttosto che l’inizio di compilazione il compilatore.
    • tutto è iniziato cercando di fare: $ GOARCH=386 GOOS=linux go build app.go e sempre errore # runtime /usr/local/go/src/pkg/runtime/extern.go:137: undefined: theGoos /usr/local/go/src/pkg/runtime/extern.go:137: cannot use theGoos as type string in const initializer
    • secondo la confusione del mio stato: ho dato per scontato che make costruire target app per me, non quello che effettivamente make fa – la costruzione di un compilatore per il target di compilazione. Questi fatti devono essere chiaramente spiegato.
    • Go pacchetto in Homebrew è un’opzione “–cross-compile-tutti”, che creerà automaticamente tutti a croce compilatori.
    • grande suggerimento @nimrodm! per ricompilare il go di installazione, è necessario eseguire brew reinstall go --cross-compile-all
    • Dopo l’esecuzione di questo, ottengo: go install runtime/cgo: open /usr/local/go/pkg/linux_amd64/runtime/cgo.a: permission denied quando si fa go get o go install, qual è il fix?
    • Silva direi che si sta tentando di fare questo, a livello utente, forse avete bisogno di “sudo”
    • non sono ENV configurato. Ho finito per usare chown su /usr/local/go/pkg/linux_amd64/
    • Può confermare questo lavorato su Mac OSX El Capitan 10.11.2 per l’esportazione di linux. Ci sono altre estensioni di file posso rinominare .linux, anche se?
    • Si prega di aggiornare questa risposta per riflettere la nuova versione di Go. meonlol risposta qui sotto è tutto ciò che è necessario in una corrente di Andare.
    • siete pregati di notare che questo thread si applica per le prime versioni di andare (1.0.2) – come era al momento della domanda.

  3. 63

    Se si utilizza Homebrew su OS X, si ha quindi 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 reinstall se si dispone già di go installato.

    • Notando l’aggiornamento interruttori sono: –cross-compile-Costruire tutti i cross-compilatori di runtime e di supporto per tutte le piattaforme supportate –cross-compile-comune di Costruire il cross-compilatori e supporto runtime per darwin, linux e windows
    • --cross-compile-all è ora --with-cc-all
    • risolto. Grazie!
    • Queste bandiere non esistono più da quello che posso dire. L’unica opzione che vedo è-senza-cgo 🙁
    • Dal momento che Vai a 1,5, non ci sono separata cross-compilatori, si utilizza solo il flag ora tip.golang.org/doc/go1.5#compiler_and_tools
  4. 21

    È possibile farlo abbastanza facilmente utilizzando la finestra Mobile, in modo che nessun extra libs richiesto. 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
    '

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

    • Perché qualcuno dovrebbe voler installare finestra Mobile per fare questo quando si potrebbe fare solo un guscio loop su env GOOS=x GOARCH=y go install something/... e finiscono con il file binari appropriati sotto $GOPATH/bin/$GOOS_$GOARCH?? E BTW, Go supporta più di tre Sistemi operativi elenco, perché non l’amore per la Bsd?
    • Non installare finestra Mobile proprio per questo, ma se la si ha, è più facile e più pulito di alternative.
  5. 5

    per le persone che hanno bisogno di CGO abilitato e la cross-compilazione da OSX targeting
    windows

    Ho bisogno di CGO attivata durante la compilazione per windows dal mio mac da quando avevo importato il https://github.com/mattn/go-sqlite3 e bisogno.
    La compilazione secondo le altre risposte mi ha dato errore:

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

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

    1.Stiamo andando per la cross-compilazione per windows con un CGO dipendente della biblioteca. Prima abbiamo bisogno di un cross-compilatore installato come mingw-w64

    brew install mingw-w64

    Questo probabilmente installarlo qui /usr/local/opt/mingw-w64/bin/.

    2.Proprio come le altre risposte prima di tutto dobbiamo aggiungere il nostro windows arco per la nostra compilatore toolchain ora. La compilazione di un compilatore ha bisogno di un compilatore (strano frase) la compilazione di andare compilatore ha bisogno di un separato pre-costruito compilatore. Siamo in grado di scaricare un precompilati binario o della compilazione da sorgente in una cartella es: ~/Documents/go
    ora siamo in grado di migliorare il nostro Andare compilatore, secondo la risposta in alto, ma questa volta con CGO_ENABLED=1 e separati precompilati compilatore 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, mentre la compilazione della nostra Go codice mingw di compilare il file vai targeting per 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
  6. 5

    Il processo di creazione di file eseguibili per molte piattaforme può essere un po ‘ noioso, quindi suggerisco di utilizzare 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 su OSX solo

    gist – go-executable-build.sh

Lascia un commento