Dans les versions antérieures de Go, sa configuration nécessitait la mise en place de certaines variables d’environnement. Avec le temps, ces exigences ont été supprimées, mais beaucoup de tutoriels en ligne mentionnent encore ces variables, ce qui entraîne une certaine confusion.

Récemment, une nouvelle fonctionnalité appelée Go Modules a été publiée qui rend finalement le GOPATH inutile. Dans ce post, je vais expliquer ce qu’est le GOPATH, pourquoi les Go Modules sont préférés et comment configurer un projet pour utiliser les Go Modules (ce qui est étonnamment facile).

Le GOPATH est une variable d’environnement qui indiquera à Go où il doit lire et télécharger tous les fichiers sources qu’il utilisera pour compiler votre projet. Ce concept s’accompagne de quelques restrictions inhabituelles que vous ne voyez pas sur d’autres langages de programmation :

• Il vous oblige à écrire vos projets Go à l’intérieur de ce répertoire pointé par la variable GOPATH (par défaut ~/go), même si vos autres projets résident ailleurs ;
• La hiérarchie des répertoires à l’intérieur du répertoire GOPATH doit refléter l’URL de votre projet. Par exemple, si votre URL est github.com/foo/bar, vous devez créer un répertoire $GOPATH/src/github.com , puis, créer un nouveau répertoire à l’intérieur de celui-ci : foo/ et à l’intérieur de celui-ci un nouveau répertoire bar/ . Ensuite, à l’intérieur du répertoire bar/ vous devez mettre votre projet git réel;
• Il n’y a pas de moyen intégré pour garder la trace des versions des paquets que vous utilisez.

Le pire problème avec cette configuration est qu’elle est complètement différente de ce à quoi nous sommes habitués sur la plupart des autres langages de programmation. De plus, comme GOPATH est une variable d’environnement, cela nécessite que les utilisateurs en sachent un peu sur la configuration de votre OS, ce qui est source d’erreurs surtout pour les débutants.

Pourquoi devriez-vous utiliser Go Modules?

Go Modules ne dépend d’aucune des dépendances mentionnées ci-dessus pour la configuration de variables d’environnement spécifiques, ni des exigences pour mettre votre projet sur un répertoire spécifique comme c’est le cas avec GOPATH.

Il est également rétro-compatible, sûr et facile à utiliser :

1. Il nécessite une seule commande pour migrer un projet existant afin d’utiliser Go Modules;
2. Il n’affecte que votre environnement de développement (comme le fait GOPATH) donc il n’affectera en aucun cas votre déploiement de production;
3. Il est rétro-compatible avec GOPATH, ce qui signifie que si vous mettez à jour un projet pour utiliser Go Modules et que vos collègues préfèrent toujours utiliser GOPATH, ils peuvent le faire sans aucun problème.

Une autre raison d’apprendre à utiliser Go Modules est que GOPATH cessera probablement d’être largement adopté dans le futur, donc vous devrez l’apprendre tôt ou tard.

Il y a, cependant, quelques caveats:

Caveat 1 : GoLang version 1.11 ou supérieure

Go Modules ne fonctionnera qu’avec GoLang version 1.11 ou supérieure. Au moment de la rédaction de ce post, certaines distributions Linux, Ubuntu inclus, utilisaient encore GoLang 1.10.

Vous pouvez tester la version actuelle de votre paquet Go installé avec la commande suivante:

go version

Il devrait sortir quelque chose comme:

go version go1.11.2 linux/amd64

Si la version que vous voyez est inférieure à 1.11.x, vous devrez le désinstaller et suivre les étapes ci-dessous pour installer la version Go requise. Notez également que les instructions ci-dessous ont été conçues pour fonctionner sur Ubuntu et les distros dérivées, si vous utilisez une autre distro, vous devrez adapter les commandes pour qu’elles fonctionnent pour vous.

D’abord, ouvrez un terminal puis vous pouvez exécuter les commandes suivantes :

# If you have already installed the Go package remove it:
sudo apt-get remove --purge --auto-remove golang# Make sure your system is up-to-date:
sudo apt-get update
sudo apt-get -y upgrade# Download the Go 1.11 package and extract it:
wget https://dl.google.com/go/go1.11.linux-amd64.tar.gz
sudo tar -xvf go1.11.linux-amd64.tar.gz# Install it manually on your /usr/local directory: 
sudo mv go /usr/local
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc# Then close your terminal, open a new one and test if Go is at the correct version:
which go # should output: /usr/local/go/bin/go
go version # should output: go version go1.11.x linux/amd64 or similar

• Téléchargez le paquet Go 1.11 (ou plus récent) et extrayez-le :
  wget https://dl.google.com/go/go1.11.linux-amd64.tar.gz
sudo tar -xvf go1.11.linux-amd64.tar.gz
• Installez-le manuellement sur votre répertoire /usr/local :
  sudo mv go /usr/local
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
• Puis fermez votre terminal, ouvrez-en un nouveau et testez si Go est à la bonne version:
  which go, devrait sortir : /usr/local/go/bin/go
go version, devrait sortir : go version go1.11.x linux/amd64 ou similaire
• Si vous avez déjà installé le paquet Go, supprimez-le:
  sudo apt-get remove --purge --auto-remove golang
• Vérifiez que votre système est à jour:
  sudo apt-get update
sudo apt-get -y upgrade
• Téléchargez le paquet Go 1.11 et extrayez-le:
  wget https://dl.google.com/go/go1.11.linux-amd64.tar.gz
sudo tar -xvf go1.11.linux-amd64.tar.gz
• Installez-le manuellement sur votre /usr/local répertoire :
  sudo mv go /usr/local
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
• Puis fermez votre terminal, ouvrez-en un nouveau et testez si Go est à la bonne version:
  which go, devrait sortir : /usr/local/go/bin/go
go version, devrait sortir : go version go1.11.x linux/amd64 ou similaire

Caveat 2 : Annuler les changements à GOPATH et GOROOT

Si vous avez fait des changements aux valeurs par défaut de votre GOPATH ou GOROOT, il pourrait être sage de supprimer ces changements. Elles ne sont pas nécessaires et mélanger les configurations GOPATH avec les modules Go est un moyen de provoquer la confusion. Plus précisément:

1. La valeur par défaut du GOPATH (lorsqu’il n’est pas défini) est ~/go , donc lorsque je mentionne le répertoire ~/go, je veux dire le répertoire par défaut utilisé par Go. Si vous avez fait des changements sur votre GOPATH, ce répertoire pourrait être ailleurs, donc, je vous suggère d’annuler ces changements pour éviter toute confusion.
2. Vous ne devriez pas avoir à changer la variable d’environnement GOROOT puisque nous avons installé Go sur le répertoire par défaut : /usr/local. Si, toutefois, vous avez modifié cette variable d’environnement, je vous suggère de l’annuler pour éviter toute confusion.

Caveat 3 : Vous n’avez pas besoin de modifier le répertoire ~/go

Comme mentionné précédemment ~/goest le répertoire par défaut où Go s’attend à lire vos fichiers lorsque GOPATH n’est pas défini. Cependant, cela ne fait une différence que si vous prévoyez de créer vos projets en utilisant GOPATH.

Si vous voulez utiliser les modules de Go, vous n’avez pas besoin de créer, de modifier ou même de lire le répertoire ~/go. S’il n’existe pas encore, il sera créé automatiquement pour vous, et s’il existe, vous ne devriez pas avoir besoin de modifier quoi que ce soit là-dedans.

Vous pouvez donc ignorer toutes les étapes du tutoriel qui vous demandent d’apporter des modifications sur ce répertoire car elles font probablement référence aux exigences de GOPATH.

Aussi, si vous avez un projet Go actuellement à l’intérieur de ce répertoire et que vous voulez qu’il fonctionne avec les modules Go, vous devriez le déplacer à l’extérieur puisque les anciennes versions de Go désactiveraient go mod à l’intérieur du GOPATH même s’il avait un fichier go.mod.

Utiliser les modules de Go

Utiliser les modules de Go consiste essentiellement à utiliser la commande suivante :

go mod init <your_projects_import_path>

Pour créer un nouveau projet, il suffit de créer un nouveau répertoire (n’importe où en dehors de ~/go/) puis de l’initialiser comme un module, c’est-à-dire :

mkdir myProject/
cd myProject
go mod init github.com/myGithubName/myProject

La commande go mod init créera un nouveau fichier appelé go.mod sur le répertoire de votre projet. Ce fichier contiendra le chemin d’importation de votre projet (généralement l’URL de votre repo) et une liste avec tous les paquets que vous utilisez actuellement sur ce projet.

Vous ne devriez pas avoir besoin de modifier ce fichier car il est géré automatiquement par la plupart des commandes go telles que go run et go get . Ainsi, après avoir exécuté ces 3 commandes, vous avez fini de configurer ce répertoire comme un module Go.

Pour le tester, créez un nouveau fichier main.go à l’intérieur de ce répertoire avec ces lignes de code:

package mainimport "fmt"func main() {
fmt.Println("Hello Go Modules")
}

Puis testez-le en utilisant la commande go run:

go run main.go 

Qui devrait donner Hello Go Modules comme prévu.

Mais j’ai déjà un projet qui utilise GOPATH, comment migrer ?

Le processus est similaire :

1. Déplacez le répertoire de votre projet n’importe où en dehors de ~/go/
2. Initialisez-le comme un module Go, par exemple.:

mv ~/go/src/github.com/myGithubName/myProject ~/anywhere_else/
cd ~/anywhere_else/myProject
go mod init github.com/myGithubName/myProject

Puis vous pouvez tester si tout fonctionne avec soit go test ./... ou go run main.go , les deux commandes téléchargeront automatiquement leurs dépendances et mettront à jour le fichier go.mod.

C’est cool, alors dois-je créer des modules, des sous-modules et des sous-sous-modules ? Nope.

Bien qu’il soit possible de créer plusieurs modules dans un seul projet, cela est presque toujours inutile. Si vous voulez un sous-dossier pour organiser votre code Go, vous recherchez des packages, pas des modules. Vous ne devriez exécuter la commande go mod init qu’une fois par projet, pas plus.

Que dois-je faire avec les fichiers `go.mod` et `go.sum` ?

Comme avec les package.json et package-lock.json de NPM, le concept de modules Go crée aussi quelques fichiers pour garder la trace de toutes les versions de vos dépendances, à savoir les fichiers go.mod et go.sum.

Vous ne devriez pas avoir besoin de modifier ces 2 fichiers puisqu’ils sont gérés automatiquement par certains outils go tels que go get et go test. C’est aussi une bonne idée de les ajouter à vos commits puisqu’ils sont nécessaires pour effectuer des builds reproductibles de votre projet, c’est-à-dire compiler avec toutes les mêmes versions et paquets que vous avez localement.

Conclusion

Vous devriez maintenant être prêt à utiliser les modules Go sur vos propres projets. L’utiliser n’est pas obligatoire mais si vous avez lu jusqu’ici, vous avez probablement remarqué à quel point les Go Modules sont plus faciles et plus intuitifs par rapport à GOPATH. Il y a également une fonctionnalité que seuls les Go Modules vous offriront : Les builds reproductibles.

Si vous voulez apprendre plus de détails sur Go Modules, je vous suggère de lire ce post pour une version plus courte ou celui-ci pour une version plus longue, les deux sont très concis et faciles à lire. Je vous recommande aussi vivement de faire vos propres recherches, il y a plusieurs grands posts sur ce sujet sur le Web. Bon codage !