Modules Go

Un module Go est une unité versionnable composée d'un ou plusieurs packages. C'est le fondement du système de dépendances moderne (Go 1.11+) : plus de GOPATH, plus de vendor obligatoire, des dépendances explicites et reproductibles.

go.mod : le manifeste du module

module example.com/myapp

go 1.22

require (
    github.com/google/uuid v1.6.0
    golang.org/x/time     v0.5.0
)

Trois directives principales :

• module <path> — le chemin d'importation du module. Tous les packages internes sont importés en tant que example.com/myapp/sub/pkg. Il n'est pas nécessaire qu'il s'agisse d'une véritable URL, mais pour publier via go get, elle doit être résolue.
• go <version> — la version Go minimale requise (également utilisée pour contrôler les fonctionnalités de langue autorisées, par exemple range-over-func dans 1.23).
• require — les dépendances directes avec leur version exacte.

Autres directives : replace (remplace un dépôt par un fork ou un chemin local), exclude, retract.

go.sum : le fichier de verrouillage cryptographique

Aux côtés de go.mod, go.sum contient un hachage cryptographique de CHAQUE version téléchargée (y compris les dépendances transitives). Il garantit la reproductibilité : si quelqu'un altère une version publiée, la construction échoue.

Toujours le valider. Il est mis à jour automatiquement par les commandes go.

Commandes essentielles

go mod init example.com/myapp        # create go.mod
go get github.com/google/uuid        # add the dep at its latest version
go get github.com/google/uuid@v1.5.0 # specific version
go get -u ./...                      # upgrade every dep
go mod tidy                          # remove unused deps, add missing ones
go mod download                      # download everything into the cache
go mod why github.com/x/y            # explain why a dep is included
go mod graph                         # full dependency graph

go mod tidy est celui que vous exécutez après chaque modification des importations : il garantit que go.mod reflète exactement les packages réellement utilisés.

Versionnement d'importation sémantique (SIV)

Les versions suivent SemVer : v1.2.3 = MAJOR.MINOR.PATCH. La partie intéressante est majeure v2+ :

• Majeur v0 et v1 → chemin normal : github.com/foo/bar.
• Majeur v2 ou version ultérieure → le chemin inclut la version majeure : github.com/foo/bar/v2.

import "github.com/foo/bar/v2"

Cela vous permet d'importer simultanément v1 et v2 de la même bibliothèque (utile lors des migrations progressives).

Importer les chemins et les packages internes

Si votre module est example.com/myapp, un sous-dossier utils/ est importé comme :

import "example.com/myapp/utils"

Le chemin dépend uniquement du nom déclaré dans go.mod, pas de l'emplacement sur le disque : le même code dans un dossier différent continue de fonctionner.

Mode Espace de travail (Go 1.18+)

Pour travailler sur plusieurs modules qui se référencent les uns les autres en même temps (par exemple une bibliothèque et une application qui l'utilise) :

go work init ./lib ./app

Cela crée go.work : go build utilisera la version locale de ./lib au lieu de télécharger celle publiée. Ne validez pas go.work (c'est un environnement de développement).

Exercices

$ go mod ???