Go est un langage de programmation statiquement typé. Conçu à l'origine par Google, Go partage des similitudes avec C en termes de syntaxe. Cependant, en termes de fonctionnalités, Go intègre des fonctionnalités supplémentaires telles que la sécurité de la mémoire, le ramasse-miettes (garbage collection), le typage structurel, etc. Au cours des dernières années, Go a gagné une popularité incroyable.
Ce guide va passer en revue les étapes de compilation et d'installation de programmes Go à l'aide d'un programme Go de démonstration.
Compilation et installation de Go
Avant d'aller plus loin, voyons rapidement ce que signifient la compilation et l'installation dans le contexte de la programmation Go.
Dans la programmation Go, la compilation fait référence au processus de traduction du code source en un exécutable binaire. L'exécutable contiendra les codes de support nécessaires pour pouvoir s'exécuter de manière indépendante sur la plateforme cible. Contrairement aux Ruby/Python programmes, les binaires Go ne nécessitent généralement aucune dépendance système pour s'exécuter sur un nouveau système.
Placer le binaire Go dans un chemin de fichier exécutable sur le système est appelé installer le programme. Comme mentionné précédemment, ce guide présentera l'exécution, la compilation et l'installation d'un simple programme Go « Hello world ».
Prérequis
Avant de commencer, passons en revue les prérequis que vous devrez remplir pour suivre ce tutoriel :
- Un Ubuntu 20.04 correctement configuré. Découvrez comment installer et configurer un serveur Ubuntu.
- Un utilisateur non-root avec les privilèges sudo. La permission root est requise pour effectuer des modifications au niveau du système. Grâce à ce tutoriel, vous pouvez apprendre comment accorder la permission sudo à un utilisateur non-root user.
- Un environnement de programmation Go correctement configuré.
Tout d'abord, nous allons rapidement passer en revue l'installation et la configuration de l'environnement de programmation Go. Pour un guide étape par étape plus détaillé sur l'installation de Go, cliquez ici.
Installer Go
Go est disponible sur toutes les plateformes majeures (Windows, Linux et macOS). Il est officiellement disponible directement depuis Golang. En raison du nom du site Web, Go est souvent appelé Golang. Ici, nous ferons toujours référence au langage de programmation Go sous le nom de Go et au site Web Golang sous le nom de Golang.
Golang propose une documentation détaillée sur l'installation de Go pour toutes les plateformes prises en charge. Cependant, la méthode officielle décrit une installation manuelle. Chaque fois qu'une nouvelle version est publiée, vous devez mettre à jour manuellement l'installation vers la dernière version. Au lieu de cela, nous pouvons installer directement Go à l'aide d'APT (depuis les dépôts Ubuntu par défaut) ou de snap (depuis Snapcraft).
● Installer Go à l'aide d'APT
Go est directement disponible depuis les dépôts officiels d'Ubuntu. Cependant, il ne s'agit pas toujours de la dernière version de Go. Il existe également deux variantes de Go disponibles dans le dépôt Ubuntu : golang-go et gccgo-go. Alors que golang-go est la version officielle de Golang, gccgo-go est le frontend Go pour GCC (faisant partie du compilateur GNU). En général, golang-go est le choix préféré.
Pour installer golang-go, exécutez la commande APT suivante :
|
1 |
sudo apt update && sudo apt install golang-go |
Vérifiez la version de Go :
|
1 |
go version |
● Installer Go à l'aide de snap
Les snaps sont des paquets Linux universels qui peuvent être installés sur n'importe quelle distribution prise en charge. Snapcraft répertorie toutes les distributions prises en charge avec des guides d'installation. Sur Ubuntu, la prise en charge de snap est activée par défaut. Go est également disponible sous forme de snap. Vous devez garder à l'esprit qu'il n'est pas officiellement maintenu par Golang. Le paquet snap est géré par un fournisseur tiers.
Pour installer le snap Go, exécutez la commande suivante :
|
1 |
sudo snap install go --classic |
Ensuite, vérifiez la version de Go :
|
1 |
go version |
Configuration d'un projet Go
Notre système dispose de tous les outils nécessaires pour commencer à développer des applications en Go. Il est temps de créer notre projet de démonstration. Tout d'abord, créez un répertoire dédié pour notre projet :
|
1 |
mkdir -v demo_project |
Ensuite, changez le répertoire actuel pour le répertoire nouvellement créé :
|
1 |
cd demo_project/ |
Ici, créez un nouveau fichier texte nommé main.go:
|
1 |
nano main.go |
Le code suivant présente un programme simple qui affichera « Hello world » lorsqu'il sera exécuté. Copiez le code :
|
1 2 3 4 5 6 7 |
package main import "fmt" func main() { fmt.Println("hello world!") } |
Enregistrez le fichier et fermez l'éditeur. Vérifiez que le code fonctionne correctement :
|
1 |
go run main.go |
Le compilateur Go a compilé le fichier source en un fichier binaire et l'a exécuté. Il vérifie également que le programme fonctionne correctement.
Configuration de l'espace de travail Go
Afin d'installer correctement les programmes Go, nous devons configurer l'espace de travail Go et GOPATH.
Tout d'abord, créez la structure des répertoires :
|
1 |
mkdir -pv $HOME/go/{bin,src} |
Ensuite, nous devons déclarer la valeur de GOPATH et l'ajouter à PATH. Ouvrez le fichier bashrc :
|
1 |
nano ~/.bashrc |
Ajoutez les lignes suivantes à la fin du fichier :
|
1 2 3 |
export GOPATH=$HOME/go export GOBIN=$GOPATH/bin export PATH=$PATH:$GOPATH/bin:/usr/local/go/bin |
Rechargez bashrc:
|
1 |
source ~/.bashrc |
Vérifiez si la modification a réussi :
|
1 |
echo $PATH |
Compilation de binaires Go
Cette section va montrer comment compiler du code Go en un fichier binaire autonome distribuable. Le binaire contiendra non seulement le code Go mais aussi du code système supplémentaire pour exécuter le binaire. Pour compiler notre code, exécutez la commande suivante :
|
1 |
go build main.go |
S'il y a plusieurs fichiers de code Go, utilisez alors la commande suivante :
|
1 |
go build |
Si aucun fichier n'est spécifié, Go recherchera les fichiers Go dans le répertoire actuel et les compilera tous. Chaque fichier binaire porte le nom de son fichier Go source. Dans cet exemple, Go a compilé le programme main. Exécutez le programme :
|
1 |
./main |
Ce programme est prêt à être distribué sur d'autres ordinateurs.
● Modification du nom du binaire
Lors de la compilation, Go sélectionne automatiquement un nom pour le fichier exécutable. Il existe deux options possibles pour le choix du nom.
- Si modules Go sont utilisés, l'exécutable utilisera alors la dernière partie du nom du module.
- Si aucun module Go n'est utilisé, Go utilisera alors le nom du répertoire actuel ou le nom du fichier source.
Travailler avec des programmes plus complexes nécessite une convention de nommage différente. Dans de tels scénarios, ces méthodes de nommage par défaut ne sont pas très utiles. Dans une telle situation, la meilleure façon est de personnaliser la sortie en utilisant le drapeau -o. Faisons une démonstration rapide. Compilez le programme Go avec le drapeau -o pour désigner un nom de fichier différent :
|
1 |
go build -o bin/hello |
Le drapeau -o indique à Go de faire correspondre la sortie avec l'argument donné. Dans ce cas, l'exécutable sera situé sous le répertoire bin et sera nommé hello.
Ensuite, testez le nouveau fichier exécutable :
|
1 |
./bin/hello |
Installation de programmes Go
Jusqu'à présent, nous avons montré comment compiler des binaires Go distribuables à partir de fichiers sources. Nous pouvons les distribuer sur d'autres systèmes, les déployer et effectuer des tests. Cependant, ils ne peuvent pas être exécutés en dehors de leurs répertoires sources. Si vous prévoyez d'utiliser activement le programme, cette contrainte peut être très ennuyeuse. Pour faciliter les choses, nous pouvons installer les programmes Go et y accéder de n'importe où dans le système.
Pour installer le programme, exécutez la commande Go suivante dans le répertoire source :
|
1 |
go install |
Cette commande se comporte de la même manière que go build. Cependant, au lieu de laisser le fichier exécutable dans le répertoire source, il est placé dans le répertoire suivant :
|
1 |
$GOPATH/bin |
Les variables GOPATH et GOBIN indiquent à Go où chercher les espaces de travail Go. GOPATH par défaut est l'emplacement $HOME/go. Nous définissons manuellement GOBIN sur $GOPATH/bin. Pour vérifier l'emplacement de GOPATH et GOBIN utilisez la commande suivante :
|
1 |
go env GOPATH |
|
1 |
go env GOBIN |
Vérifiez le contenu de $GOPATH/bin. Notre programme devrait s'y trouver :
|
1 |
ls $GOPATH/bin |
Il est temps de vérifier si l'installation a réussi. Changez le répertoire actuel pour un autre emplacement et essayez d'exécuter le programme Go :
|
1 |
demo_project |
Enfin, vous devriez être en mesure de prendre vos programmes et de les installer sur votre système. Vous pouvez les utiliser où et quand vous en avez besoin.
Dernières réflexions
Dans ce tutoriel, nous avons démontré avec succès comment utiliser les chaînes d'outils Go pour compiler des binaires exécutables à partir de codes sources. Ces binaires peuvent être utilisés sur d'autres systèmes, même sans aucune configuration Go. Enfin, nous avons démontré comment installer le programme Go pour qu'il soit disponible de n'importe où dans le système.
Pour les développeurs, CloudSigma propose un support pour l'API Go pour gérer vos serveurs cloud. Il permet de modifier les ressources et de mettre à l'échelle l'infrastructure.
Bonne programmation !
Commentaires
Aucun commentaire pour l'instant. Soyez le premier.