TOC

Comment construire à partir de la source sur Ubuntu 16.04

introduction

Go est un langage de programmation moderne à code source ouvert développé par Google. C’est simple et dispose d’un ensemble robuste de bibliothèques et d’outils facilitant la création d’applications fiables et efficaces.

Si vous souhaitez tester votre application Go avec la version la plus récente du langage, contribuer à la base de code Go ou bénéficier d’une meilleure gestion des versions de Go, vous devez créer Go à partir du code source. Ce tutoriel vous montrera comment construire Go, couvrir quelques considérations pratiques et construire une application de test «Hello, World».

Conditions préalables

Pour suivre ce tutoriel, vous aurez besoin de:

Étape 1 - Installation des dépendances de construction

Avant de commencer, assurez-vous que votre cache de référentiel est à jour.

sudo apt-get update

Par défaut, Ubuntu ne contient pas tous les packages nécessaires à la construction de Go, à l’instar de ses compilateurs, bibliothèques et outils. Il est facile d’installer les dépendances de compilation et de compilation en installant + build-essential +, un paquet qui inclut + gcc + pour compiler C, + g +` pour compiler C et `+ make +, un outil d’automatisation de la compilation.

sudo apt-get install build-essential

Une fois l’installation terminée, vous aurez tous les outils nécessaires pour compiler Go à partir du source. Ensuite, vous aurez besoin des binaires Go 1.4.

Étape 2 - Installation de Go 1.4.3

Pour construire Go 1.5+, vous devez avoir Go 1.4. En effet, les chaînes d’outils pour Go 1.5+ sont écrites dans Go lui-même. Vous pouvez utiliser Go 1.4 ou n’importe quelle version ponctuelle (1.4.1, 1.4.2 ou 1.4.3); Dans ce tutoriel, nous utiliserons Go 1.4.3.

Les fichiers binaires Go avec les sommes de contrôle SHA1 sont disponibles sur la page de téléchargement Go. Téléchargez le fichier intitulé «+ go1.4.3.linux-amd64.tar.gz +» dans votre répertoire personnel.

cd ~
curl -O https://storage.googleapis.com/golang/

Bien que ce fichier ait été téléchargé à partir d’une source authentique, la vérification de l’intégrité de ce que vous avez téléchargé reste une bonne pratique de sécurité. Cela se fait le plus facilement en comparant le hachage de fichier fourni sur la page de téléchargement et le hachage du fichier téléchargé.

Commencez par obtenir le hachage du fichier que vous avez téléchargé.

sha1sum go1.4.3.linux-amd64.tar.gz

Comparez le résultat de cette commande avec la somme de contrôle fournie sur la page de téléchargement de Go.

Output332b64236d30a8805fc8dd8b3a269915b4c507fe  go1.4.3.linux-amd64.tar.gz

Si les sommes de contrôle correspondent, vous pouvez décompresser les fichiers.

tar xvf go1.4.3.linux-amd64.tar.gz

L’indicateur + x + signifie e X tract, + v + indique + tar + d’utiliser V erbose (c.-à-d. pour lister les fichiers en cours d’extraction), et + f + nous permet de spécifier le F ilename.

Go 1.4 est maintenant décompressé dans un répertoire appelé + go +, mais le script de compilation Go recherche les binaires de Go 1.4 dans + ~ / go1.4 + par défaut. Renommez le répertoire en utilisant la commande + mv +.

mv go go1.4

Vous avez maintenant les dépendances nécessaires pour construire Go from source. Si vous souhaitez déplacer Go 1.4 de votre répertoire personnel vers un autre emplacement, vous pouvez suivre l’étape suivante. Sinon, vous pouvez passer à l’étape 4 pour cloner les sources Go.

Étape 3 - Déplacement de Go 1.4.3 (facultatif)

Lors de l’exécution du script de génération Go, Go 1.4 sera basé sur une variable d’environnement appelée + GOROOT_BOOTSTRAP. Si cette variable n’est pas définie, ce qui est le cas par défaut, le script de construction suppose que le répertoire + go1.4 + se trouve dans votre répertoire de base. Vous pouvez utiliser la variable + GOROOT_BOOTSTRAP si vous souhaitez déplacer Go 1.4 vers un autre emplacement. Ici, nous allons le déplacer vers + / usr / local / go1.4 +.

Tout d’abord, déplacez le répertoire lui-même.

sudo mv go1.4

Ensuite, vous devez définir le chemin dans votre environnement en modifiant le fichier + ~ / .profile +.

sudo nano ~/.profile

A la fin du fichier, ajoutez la ligne suivante:

~ / .profile

. . .
export GOROOT_BOOTSTRAP=go1.4

Enregistrez le fichier et quittez. Pour que cette modification prenne effet, actualisez votre profil.

source ~/.profile

Ensuite, vous clonerez les sources Go.

Étape 4 - Obtention des sources de Go

L’emplacement recommandé pour stocker les fichiers binaires Go est + / usr / local +, ce que nous allons utiliser dans ce tutoriel. Cependant, vous pouvez le stocker où vous le souhaitez.

Déplacez-vous dans + / usr / local + et utilisez Git pour cloner le référentiel.

cd
sudo git clone https://go.googlesource.com/go

Nous devons exécuter + git clone + avec les privilèges root car + / usr / local + appartient à * root *. Si vous clonez dans un répertoire dans lequel votre utilisateur dispose d’autorisations en écriture, vous pouvez exécuter cette commande sans utiliser sudo.

Une fois le clone terminé, il créera un répertoire + go + dans + / usr / local. Déplacer dans ce répertoire.

cd go

Avant de construire, nous devons choisir quelle version de Go nous voulons.

Étape 5 - Choisir une version Go

Les sources Go ont une branche Git différente pour chaque version disponible. Les noms des branches sont:

  • + master + pour la dernière version en développement

  • + go + pour les versions stables

Ici, nous allons utiliser Go 1.7.4, ce qui signifie que nous voulons utiliser la branche + go1.7.4 +.

Pour changer de branche, utilisez la commande + git checkout +. Vous devez exécuter ces commandes avec les privilèges root car + / usr / local et` + / usr / local / go 1.4 + `appartiennent à * root *.

sudo git checkout

Une fois cette étape terminée, vous avez téléchargé le code source Go de votre version préférée. Vous êtes prêt à passer à l’essentiel de ce didacticiel: construire Go lui-même.

Étape 6 - Construire Go

Pour construire, vous devez exécuter un script bash, + src / all.bash +, fourni avec le code source. Le script vérifiera que vous avez toutes les dépendances nécessaires, exécutera des tests et complétera la construction.

Exécutez le script, mais notez que si vous modifiez l’emplacement des fichiers binaires de Go 1.4.3, vous devrez ajouter l’indicateur + -E + (c’est-à-dire + sudo -E bash. / all.bash +) pour préserver les variables d’environnement.

cd src
sudo bash ./all.bash

Le script prendra un peu de temps pour terminer. Une fois la construction terminée, vous verrez le résultat suivant:

Output of src/all.bashALL TESTS PASSED

---
Installed Go for linux/amd64 in /usr/local/go
Installed commands in /usr/local/go/bin
*** You need to add /usr/local/go/bin to your PATH.

Maintenant que Go est construit, vous devez lui définir des variables d’environnement.

Étape 7 - Définition des variables Go

Les variables d’environnement sont un moyen puissant de personnaliser votre installation de Go. Nous allons parcourir les plus importants et utiles.

Pour commencer à utiliser Go, vous devez ajouter le chemin des fichiers binaires Go, + go / bin +, aux variables d’environnement + PATH + et + + GOPATH + . `+ GOPATH + est l’emplacement où sont stockés le code de l’application Go et les fichiers binaires, que nous spécifierons sous la forme + ~ / work +, bien que vous puissiez le personnaliser.

Ajoutez ces variables au fichier + ~ / .profile +. Ouvrez-le avec votre éditeur de texte préféré:

nano ~/.profile

A la fin du fichier, ajoutez les lignes suivantes:

~ / .profile

. . .
export GOPATH=
export PATH=$PATH:go/bin:$GOPATH/bin

Si vous avez installé Go dans un chemin autre que celui par défaut, c’est-à-dire autre chose que + / usr / local / go +, vous devrez définir la variable + GOROOT +. Dans ce cas, ajoutez également les lignes suivantes:

~ / .profile

export GOROOT=
export GOPATH=
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

Enregistrez le fichier et quittez. Pour que ces modifications prennent effet, actualisez votre profil.

source ~/.profile

Une fois cette étape terminée avec succès, vous disposez d’une installation Go entièrement fonctionnelle. Nous allons ensuite le tester pour nous assurer que tout fonctionne comme prévu.

Étape 8 - Test de l’installation de Go

Une méthode courante pour tester le fonctionnement de Go consiste à écrire et à exécuter une application simple «Hello, World».

Pour ce faire, nous allons d’abord créer et déplacer un répertoire pour les fichiers de l’application basé sur votre + GOPATH +. Vous pouvez choisir ce que vous voulez dans votre chemin Go, mais comme exemple ici, nous allons définir le type de hiérarchie dont vous aurez besoin si vous use GitHub pour gérer votre code. Cette hiérarchie fonctionnera même sans compte GitHub, cependant.

mkdir -p $GOPATH/src/github.com//test_project
cd $GOPATH/src/github.com//test_project

Créez ensuite un fichier Go “Hello, World” appelé + hello.go +.

nano hello.go

Ajoutez le code suivant au fichier:

bonjour.go

package main

import "fmt"

func main() {
   fmt.Printf("Hello World!\n")
}

Cet exemple utilise le package + fmt +, qui implémente des fonctions d’E / S telles que + Printf () +, et définit la fonction + main () + qui imprimera * Hello World * lors de l’exécution du programme.

Enregistrez-le et quittez le fichier, puis compilez-le à l’aide de la commande Aller + install.

go install github.com//test_project

Lorsque la compilation est terminée, vous pouvez l’exécuter avec la commande suivante:

hello

  • Hello World! * S’affiche sur le terminal, ce qui signifie que votre installation Go fonctionne.

Étape 9 - Modification des versions de Go (facultatif)

Ce tutoriel a mis en place Go 1.7.4. Si vous souhaitez utiliser une version différente, vous devez modifier la branche Git active et reconstruire Go.

Pour vérifier votre version actuelle de Go, vous pouvez utiliser + version go + +.

go version
Outputgo version go1.7.4 linux/amd64

Par exemple, nous allons passer de la version Go à la version 1.6.4. Cette version est située dans la branche + go1.6.4 +, donc basculez-y.

cd /go
sudo git checkout

Pour vous assurer que tout est à jour, exécutez + git pull pour obtenir les dernières modifications pour la branche sélectionnée.

sudo git pull origin

Maintenant, exécutez le script de construction comme avant, en veillant à ajouter l’indicateur + -E + si vous avez déplacé Go 1.4 à l’étape 3.

cd src
sudo bash ./all.bash

Cela prendra du temps pour finir. Lorsque la construction est terminée, vous verrez la sortie suivante:

Output of src/all.bashALL TESTS PASSED

---
Installed Go for linux/amd64 in /usr/local/go
Installed commands in /usr/local/go/bin
*** You need to add /usr/local/go/bin to your PATH.

Vous avez déjà défini les variables Go dans + ~ / .profile + à partir de l’étape 5, c’est donc tout ce que vous devez faire pour changer de version.

Conclusion

En construisant à partir des sources et en configurant des chemins, vous disposez désormais d’une base idéale pour développer et tester des applications Go ou pour contribuer à la base de code Go.

Pour en savoir plus, vous pouvez explorer how pour commencer à utiliser avec Go ou https: // www. digitalocean.com/community/tutorials/how-to-use-martini-to-serve-go-applications-behind-an-nginx-server-on-ubuntu[comment servir les applications Go avec Martini], qui est un Go Web cadre. Si vous recherchez de l’inspiration pour contribuer à Open source Go, vous pouvez en savoir plus sur go-qemu et go-libvirt projets.

Related