Go
Compilation croisée

Introduction

Syntaxe

• GOOS = linux GOARCH = amd64 go build

Remarques

Compiler toutes les architectures en utilisant un Makefile

Ce Makefile recoupera et compilera les exécutables pour Windows, Mac et Linux (ARM et 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)

(Faites attention à ce que le fichier Makefile nécessite des onglets durs et non des espaces )

Compilation croisée simple avec go build

À partir du répertoire de votre projet, exécutez la commande go build et spécifiez la cible du système d'exploitation et de l'architecture avec les variables d'environnement GOOS et GOARCH :

Compilation pour Mac (64 bits):

GOOS=darwin GOARCH=amd64 go build

Compilation pour Windows x86:

GOOS=windows GOARCH=386 go build

Vous pouvez également définir manuellement le nom du fichier exécutable de sortie pour suivre l'architecture:

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

A partir de la version 1.7 et suivantes, vous pouvez obtenir une liste de toutes les combinaisons GOOS et GOARCH possibles avec:

go tool dist list

(ou pour faciliter la consommation de la machine, go tool dist list -json )

Compilation croisée en utilisant gox

Une autre solution pratique pour la compilation croisée est l'utilisation de gox : https://github.com/mitchellh/gox

Installation

L'installation se fait très facilement en exécutant go get github.com/mitchellh/gox . L'exécutable résultant est placé dans le répertoire binaire de Go, par exemple /golang/bin ou ~/golang/bin . Assurez-vous que ce dossier fait partie de votre chemin afin d'utiliser la commande gox partir d'un emplacement arbitraire.

Usage

Dans le dossier racine du projet Go (où vous exécutez par exemple la go build ), exécutez gox afin de créer tous les binaires possibles pour toute architecture (par exemple x86, ARM) et système d'exploitation (par exemple Linux, macOS, Windows).

Pour construire pour un certain système d'exploitation, utilisez par exemple gox -os="linux" place. L'option d'architecture pourrait également être définie: gox -osarch="linux/amd64" .

Exemple simple: compiler helloworld.go pour une architecture de bras sur une machine Linux

Préparez helloworld.go (trouvez ci-dessous)

package main

import "fmt"

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

Exécuter GOOS=linux GOARCH=arm go build helloworld.go

Copiez le helloworld généré helloworld (arm executable) sur votre machine cible.