Comment créer des exécutables GO dans Ubuntu 17

L'un des systèmes d'exploitation les plus polyvalents Linux C'est sans aucun doute Ubuntu qui, grâce à ses fonctionnalités, nous offre un environnement sécurisé et hautement configurable.

En plus de ce grand avantage, nous pouvons trouver de nombreux outils et applications qui permettent d'augmenter les niveaux de performance et de productivité offerts par Ubuntu et sur la base de cette possibilité, nous analyserons aujourd'hui un outil qui nous offre la possibilité de créer des fichiers exécutables de divers systèmes d'exploitation pour être exécutés ultérieurement en toute confiance, cet outil s'appelle Aller.

C'est quoi GOGo est une application open source qui nous permet de créer des logiciels simples, fiables et hautement productifs.

Go a été conçu avec un large portefeuille d'outils qui permettent d'obtenir des packages et de créer des exécutables de manière pratique.

Avec Go, en tant qu'administrateurs système, nous aurons la possibilité de créer des exécutables pour plusieurs systèmes d'exploitation et de les gérer tous à partir d'un seul serveur sans avoir besoin d'aller sur chaque plate-forme pour télécharger l'exécutable correspondant.

Avec Go, nous pouvons créer des exécutables pour Windows, Linux, Mac OS, entre autres.

Avant de voir comment créer l'exécutable, nous donnerons un bref aperçu de la façon d'installer Go dans Ubuntu 17.

1. Comment installer et mettre à jour le système Ubuntu 17

Étape 1
La première étape à effectuer consiste à exécuter les commandes suivantes pour mettre à jour les packages système et leurs correctifs de bogues respectifs :

 sudo apt-get update sudo apt-get -y upgrade

Étape 2
Une fois le système mis à jour, nous procédons au téléchargement des binaires Go respectifs en exécutant la ligne suivante :

 wget https://storage.googleapis.com/golang/go1.7.4.linux-amd64.tar.gz 

AGRANDIR

NoterEn cas d'exigence des binaires pour les éditions 32 bits, nous pouvons accéder au lien suivant :

Étape 3
Une fois le fichier téléchargé, on procède à son extraction en exécutant la ligne suivante :

 sudo tar -xvf go1.7.4.linux-amd64.tar.gz 

AGRANDIR

Étape 4
Nous allons déplacer le contenu vers le chemin /usr/local :

 sudo mv go / usr / local

2. Comment ajuster l'environnement Go Ubuntu 17

Étape 1
Pour que Go fonctionne correctement, nous devrons saisir les lignes suivantes associées au chemin et à l'accès de Go :

 export GOROOT = / usr / local / go export GOPATH = $ HOME / Solvetic / go export PATH = $ GOPATH / bin : $ GOROOT / bin : $ PATH

AGRANDIR

Étape 2
Il est important de noter que le chemin GOPATH est l'endroit où les fichiers de construction seront hébergés.
Une fois cela fait, nous pouvons exécuter les commandes suivantes pour vérifier la version et l'environnement de Go :

 aller version aller env

AGRANDIR

Étape 3
Avec cela, nous avons déjà installé Go et nous pouvons procéder à la création des exécutables.
Il est à noter que Go version 1.8 est actuellement en version bêta, mais si nous voulons l'installer nous pouvons exécuter les commandes suivantes :

 sudo add-apt-repository ppa: longsleep / golang-backports sudo apt-get update sudo apt-get install golang-go

3. Comment télécharger le code source dans Ubuntu 17

C'est la première étape avant de créer un exécutable avec Go, en obtenant son code source que nous obtenons en utilisant le paramètre go get.

Le processus comprend clonage des packages dans le chemin GOPATH/src/ et plus tard, si vous les appliquez, ils seront construits dans le chemin GOPATH / bin.

Étape 1
La syntaxe à utiliser pour télécharger le code source est :

 aller chercher (chemin du paquet)

Le chemin se trouve généralement dans la base de Github. Nous ajouterons également le paramètre -ou alors qui installe toutes les dépendances ou la mise à jour de celles-ci.

Étape 2
Pour ce cas nous utiliserons Caddy qui est un serveur web écrit en Go et nous exécuterons la ligne suivante pour le télécharger :

 allez chercher -u github.com/mholt/caddy/caddy

Étape 3
Comme on peut le voir, aucun résultat visible n'est affiché mais tout le contenu sera stocké dans le chemin

 GOPATH / src / github.com / mholt / caddy.

Si nous voulons le vérifier, nous pouvons exécuter la ligne quel caddie. Dans certains cas, Erreurs associées à Git, pour cela, nous exécuterons ce qui suit pour sa correction :

 sudo apt installer git

4. Comment construire l'exécutable dans Ubuntu 17

Étape 1
Une fois Caddy téléchargé et pour cela nous exécuterons la ligne suivante :

 allez construire github.com/mholt/caddy/caddy 

Étape 2
Cette commande n'affichera pas non plus de résultats visibles. Si nous voulons spécifier une route spéciale, nous pouvons ajouter le paramètre -o comme suit. Nous pouvons changer l'itinéraire build / caddie-serveur pour celui que vous désirez. Cette commande va créer le fichier exécutable et accessoirement, s'il n'existe pas, le répertoire ./construire.

 allez construire -o construire / caddy-server github.com/mholt/caddy/caddy 

5. Comment installer l'exécutable dans Ubuntu 17

L'installation d'un exécutable consiste à créer le fichier .exe et rangez-le dans le GOPATH / chemin bin. Pour ce processus, nous utiliserons la commande va installer qui créera l'exécutable au bon endroit.

Nous exécuterons ce qui suit. Lors de l'exécution de la commande, aucun résultat ne sera non plus visible pour l'utilisateur, mais le fichier aura été créé dans le chemin GOPATH/bin.

 allez installer github.com/mholt/caddy/caddy 

6. construire des exécutables pour divers systèmes sur Ubuntu 17

À ce stade, nous verrons la puissance de Go et comment il devient un allié précieux grâce aux multiples possibilités de création d'exécutables.

Étape 1
La syntaxe à implémenter sera la suivante. La commande env est en charge de créer un environnement modifié pour l'utilisation des variables respectives.

 env GOOS = OS Goal GOARCH = Architecture go build Chemin du package 

Étape 2
Ce qui suit est un tableau avec toutes les options que Go nous propose :

Étape 3
Dans ce cas, nous allons créer un exécutable Windows avec une architecture amd 64 bits, nous allons exécuter ce qui suit :

 env GOOS = windows GOARCH = amd64 go build github.com/mholt/caddy/caddy 

Comme il est d'usage au Go, nous ne verrons aucun résultat visible, mais le processus a été effectué en interne.

Étape 4
Cela créera le fichier .exe basé sur le système choisi et pour le vérifier nous exécuterons la ligne suivante :

 ls caddy.exe 

7. Comment créer le script pour la compilation multiplateforme dans Ubuntu 17

Avec cet objectif, nous allons créer un script appelé go-executable-build.bash qui sera un script chargé d'effectuer toutes les actions de compilation de manière pratique et pouvant être utilisé à un niveau général avec une compatibilité totale.

Étape 1
Pour cela, nous utiliserons le CD de ligne ~ et nous exécuterons ce qui suit :

 nano go-executable-build.bash

Étape 2
Là, nous devons entrer les informations suivantes:

 #! / usr / bin / env bash package = $ 1 if [[-z "$ package"]]; then echo "usage: $ 0" exit 1 fi package_split = ($ {package // \ //}) package_name = $ {package_split [-1]} plates-formes = ("windows / amd64" "windows / 386" "darwin / amd64 ") pour la plate-forme dans" $ {plates-formes [@]} "do platform_split = ($ {plate-forme // \ //}) 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 'Une erreur s'est produite ! Abandon de l'exécution du script… 'exit 1 fi done

Étape 3
Ce sera le script et sa fonction est la suivante :

 #! / usr / bin / env bash : Cette ligne indique que l'interpréteur va analyser le script. 

 package = $ 1 : cette ligne prendra le premier argument de la ligne de commande et le stockera dans sa variable. if [[-z "$ package"]]; then echo "usage: $ 0" exit 1 fi

Étape 4
Ces lignes sont chargées d'afficher un message au cas où la valeur n'aurait pas été saisie.
Paramètre si analyse la valeur de la variable paquet.

 package_split = ($ {package // \ //}) : cette ligne divise le chemin d'importation du package en un tableau à l'aide du délimiteur /. package_name = $ {package_split [-1]} : cette ligne prend le nom du tableau. plates-formes = ("windows / amd64" "windows / 386" "darwin / amd64") : Là, nous entrerons dans le système d'exploitation et l'architecture à créer. pour la plate-forme dans "$ {plates-formes [@]}" do platform_split = ($ {platform // \ //}) GOOS = $ {platform_split [0]} GOARCH = $ {platform_split [1]} Done

Étape 5
Ces lignes divisent les valeurs de la plate-forme en variables GOOS et GOARCH.

 nom_sortie = $ nom_paquet '-' $ GOOS '-' $ GOARCH if [$ GOOS = "windows"]; alors output_name + = '.exe' fi

Étape 6
Avec cette séquence, nous allons créer le nom de l'exécutable et en ce qui concerne les systèmes d'exploitation Windows, nous devons ajouter l'extension .exe.

 env GOOS = $ GOOS GOARCH = $ GOARCH go build -o $ output_name $ package : Cette ligne nous permet de créer le fichier exécutable. si [$? -ne 0]; then echo 'Une erreur s'est produite ! Abandon de l'exécution du script… 'exit 1

Étape 7
Avec ces lignes, un message d'erreur sera affiché au cas où la construction de l'exécutable est erronée.

Étape 8
Une fois ces informations saisies, nous enregistrons les modifications à l'aide de la combinaison de touches

Ctrl + O

et nous laissons l'éditeur utiliser

Ctrl + X

Étape 9
Nous attribuerons les autorisations pour que le script soit exécutable en utilisant la ligne suivante :

 chmod + x go-executable-build.bash

Étape 10
La dernière étape consistera à tester la configuration du script en exécutant ce qui suit. Comme on peut le voir, aucune erreur n'a été générée.

 ./go-executable-build.bash github.com/mholt/caddy/caddy 

8. Comment vérifier les fichiers exécutables dans Ubuntu 17

Pour vérifier que nous avons les bons exécutables dans Go, il suffit d'exécuter la ligne suivante :

 caddy *

Là, nous verrons à la fois les exécutables 32 bits et 64 bits pour le système sélectionné, dans ce cas Windows. Si nous voulons utiliser d'autres plates-formes, accédez simplement au script et effectuez les modifications dans la ligne plates-formes.

Nous avons vu à quel point Go est une application fondamentale lorsqu'il est nécessaire d'avoir plusieurs exécutables, facilitant la gestion et la distribution de ceux-ci dans l'organisation.