Décompresser Go depuis l'archive officielle prend cinq minutes et vous donne la release courante, pas ce que votre distribution a figé il y a deux ans. Ce guide couvre le téléchargement, l'extraction, les variables d'environnement qui font trébucher le plus de monde, et un premier programme pour prouver que la toolchain fonctionne. Chaque étape s'exécute pareil sur Ubuntu, Debian, Rocky et Fedora, avec des notes pour macOS et Windows.
À retenir
- Prenez l'archive sur go.dev, pas dans votre gestionnaire de paquets. Les paquets de distribution accumulent plusieurs releases de retard.
- Extrayez dans /usr/local, puis ajoutez le répertoire bin de la toolchain au PATH. Cette seule étape rend l'outil go disponible.
- GOPATH pointe par défaut vers ~/go et n'a plus besoin d'être défini pour le travail en modules. Une variable contrôle où atterrissent les outils compilés.
- Vérifiez avec go version et un programme Hello World avant de vous fier à l'installation.
- Utilisez GVM ou asdf quand un projet fige une release plus ancienne et que vous avez besoin de deux versions côte à côte.
Prérequis
Quatre choses à vérifier d'abord.
- Une machine Linux 64 bits. Toute distribution courante convient. Contrôlez la plateforme avec uname -m, qui affiche x86_64 sur Intel et AMD, aarch64 sur Arm.
- Privilèges. L'extraction écrit dans /usr/local, donc sudo y est nécessaire.
- Accès réseau. HTTPS sortant sur le port 443 vers go.dev et, plus tard, vers le proxy de modules proxy.golang.org. Aucun port entrant à ouvrir pour l'installation elle-même.
- Environ 1 Go d'espace disque libre. La toolchain pèse environ 250 Mo une fois extraite ; le cache et les modules poussent à partir de là.
Aucun compilateur n'est requis : l'archive embarque une toolchain complète. Toute la procédure tient en quatre étapes.
Télécharger le binaire Go
Fixez la version ou laissez le téléchargement résoudre la release courante. La seconde option vieillit mieux :
GO_VERSION=$(curl -sL 'https://go.dev/VERSION?m=text' | head -1)echo "$GO_VERSION"
curl -sLO "https://go.dev/dl/${GO_VERSION}.linux-amd64.tar.gz"Au moment d'écrire, cela résout vers go1.26.6, donc l'archive arrive sous le nom go1.26.6.linux-amd64.tar.gz, autour de 64 Mo. Sur matériel arm64, remplacez l'architecture dans le nom de fichier. Sur macOS, prenez l'archive darwin-arm64, et sous Windows l'installeur MSI de la même page.
Vérifiez le téléchargement avant l'extraction. Une archive tronquée produit des erreurs déroutantes bien plus tard :
curl -sLO "https://go.dev/dl/${GO_VERSION}.linux-amd64.tar.gz.sha256"sha256sum -c "${GO_VERSION}"*.sha256
Extraire et installer Go
Retirez toute installation précédente, puis décompressez dans /usr/local :
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf "${GO_VERSION}.linux-amd64.tar.gz"Le rm -rf compte. Extraire par-dessus un arbre existant laisse des fichiers périmés de l'ancienne release, et les incohérences de version qui en résultent sont difficiles à diagnostiquer. Refaites ce geste avant chaque mise à niveau, et la même procédure couvre un downgrade.
La toolchain repose maintenant sous /usr/local/go et fonctionne aussitôt par chemin complet :
/usr/local/go/bin/go versionConfigurer les variables d'environnement (GOROOT et GOPATH)
Trois variables comptent, et une seule est obligatoire.
PATH a besoin du répertoire bin de la toolchain pour que l'outil go se résolve sans chemin complet. Ajoutez ces variables d'environnement au profil de votre shell :
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
echo 'export GOBIN=$HOME/go/bin' >> ~/.bashrc
echo 'export PATH=$PATH:$GOBIN' >> ~/.bashrcsource ~/.bashrc
GOROOT pointe vers la toolchain elle-même. Ne le définissez pas : l'outil go le déduit de son propre emplacement, et une valeur fausse est une cause classique d'installation cassée.
GOPATH vaut ~/go par défaut. Les modules l'ont rendu beaucoup moins central, mais il accueille encore trois répertoires : pkg pour le cache de modules, src pour les arbres de code pré-modules, et bin pour les exécutables compilés. GOBIN prime sur ce dernier, et c'est la variable qui mérite d'être posée délibérément, puisque go install écrit l'exécutable là et que vous le voulez sur le PATH.
Contrôlez la configuration obtenue à tout instant :
go env GOPATH GOMODCACHE GOPROXY
💡 Astuce : une configuration système globale se place dans /etc/profile.d/go.sh plutôt que dans le ~/.bashrc d'un seul utilisateur, pour que chaque compte et chaque service systemd charge le même PATH et que les permissions de fichiers restent prévisibles.
Vérifier l'installation
Deux commandes confirment une toolchain opérationnelle :
go version
go env GOROOT GOPATH
La première affiche la release et la plateforme, par exemple go version go1.26.6 linux/amd64. La seconde rapporte GOROOT et GOPATH pour vous laisser confirmer leur état.
✅ Résultat attendu go version affiche la release téléchargée. Si le shell répond « command not found », votre modification du PATH ne s'est pas appliquée à cette session.
Créer un espace de travail Go
Les modules ont supprimé l'obligation de garder un workspace dans GOPATH, donc un projet vit où vous voulez :
mkdir -p ~/projects/hello && cd ~/projects/hello
go mod init example.com/helloCela écrit un fichier go.mod qui enregistre le chemin du module et la version de Go. Chaque dépendance se résout via le proxy de modules et se met en cache sous GOPATH/pkg/mod, en cache partagé entre tous les projets de la machine : un second build ne télécharge rien.
Si vous maintenez du code ancien antérieur aux modules, GOPATH/src est l'endroit où cet arbre de code reste à sa place, et src y est le seul répertoire qui compte. Le travail neuf n'a rien à y faire.
Écrire et exécuter un programme Hello World
Créez le fichier main.go dans le répertoire du workspace. Tout programme Go exige un package main :
package main
import "fmt"
func main() {
fmt.Println("Hello from Go")
}
Puis exécutez-le, compilez-le et installez-le :
go run main.go
go build -o hellogo install
go run compile le programme vers un emplacement temporaire et l'exécute. go build laisse un artefact nommé hello dans le répertoire courant. go install copie cet exécutable dans GOBIN, raison pour laquelle avoir ce répertoire sur le PATH est commode. La func main dans package main est le point d'entrée que l'éditeur de liens recherche.
Le résultat est un exécutable statique unique sans dépendance runtime, ce qui rend Go pratique pour auto-héberger vos applications : copier un fichier, le lancer. La même application tourne à l'identique sur toute machine de la même plateforme, sans aucune dépendance réseau au démarrage.
Facultatif : installer Go via gestionnaire de paquets (yum, apt, dnf)
Une commande, au prix d'une release plus ancienne :
sudo apt install -y golang-go # Debian, Ubuntu
sudo dnf install -y golang # Fedora, Rocky, RHELDebian 13 embarque Go 1.24 et Ubuntu 24.04 embarque 1.22, tous deux bien en retard sur la version courante. Fedora suit de plus près. L'un ou l'autre passe pour un outil scripté, et pose problème à tout projet dont le go.mod exige une version plus récente.
N'utilisez pas les deux méthodes. Mélanger le binaire packagé et l'archive produit un go version incohérent selon l'ordre du PATH. Choisissez-en une, et si vous changez, retirez d'abord le paquet.
Gérer plusieurs versions de Go avec GVM ou asdf
Deux outils règlent le cas. GVM est spécifique à Go ; asdf gère plusieurs langages avec une seule interface, le meilleur choix si vous l'utilisez déjà :
asdf plugin add golang
asdf install golang 1.26.6
asdf set golang 1.26.6
Il existe aussi une option intégrée sans outil supplémentaire. Une ligne toolchain dans go.mod fait télécharger et activer cette release précise par la commande go, ce qui suffit souvent à éviter entièrement un gestionnaire de versions.
Problèmes courants et dépannage
| Symptôme | Cause | Correctif |
|---|---|---|
| go: command not found | Répertoire de la toolchain absent du PATH | Re-sourcez votre profil, ou ouvrez une nouvelle session |
| Les exécutables compilent mais ne tournent pas | GOBIN hors du PATH | export PATH=$PATH:$HOME/go/bin |
| go: cannot find main module | Hors d'un répertoire de module | Lancez go mod init ou cd dans le projet |
| Les téléchargements de modules se bloquent | Proxy ou pare-feu bloque le HTTPS sortant | Vérifiez go env GOPROXY, permettez proxy.golang.org |
| Version erronée signalée | Deux installations sur le PATH | which -a go, retirez le paquet de distribution |
Si une compilation échoue après une montée de version, videz le cache avec go clean -cache -modcache et recommencez. C'est sans danger, et cela élimine les artefacts périmés avant de chercher plus loin. Deux autres cas : un permission denied signifie généralement qu'un autre utilisateur en est propriétaire, et un go get bloqué vient presque toujours du proxy, pas de votre code.
Pour une alternative par conteneurs à l'installation directe de la toolchain, notre guide sur l'installation de Docker couvre le même terrain pour les builds d'images.
FAQ
Quelle est la RAM minimale pour faire tourner Go sur un serveur dédié ?
La toolchain compile confortablement dans 1 Go, et un service compilé typique dort en quelques dizaines de Mo à l'exécution. La compilation est l'étape exigeante : éditer les liens d'un gros exécutable peut dépasser 2 Go, donc dimensionnez la machine pour cet instant plutôt que pour l'application finie.
Puis-je installer plusieurs versions de Go sur la même machine ?
Oui. Utilisez asdf ou GVM, ou ajoutez une directive toolchain au go.mod et laissez la commande go aller chercher ce que chaque projet demande. Gardez une release sous /usr/local par défaut pour tout le reste.
Comment définir correctement le GOPATH sur un serveur dédié Linux ?
En général, vous n'en avez pas besoin. GOPATH vaut ~/go par défaut et c'est correct pour le travail en modules. Si vous le substituez, exportez-le dans /etc/profile.d plutôt que dans le shell d'un utilisateur, et posez la cible bin à côté pour que go install ait une destination prévisible.
Est-il sûr de faire tourner des applications Go en root ?
Non, et il n'y a aucune raison de le faire. Compilez comme utilisateur sans privilège, puis lancez l'exécutable depuis un service systemd avec son propre compte de service et des permissions fichier minimales. Accordez CAPNETBIND_SERVICE si le service doit binder un port bas, ce qui est plus sûr que des privilèges complets. Le même contrôle s'applique à l'hébergement de serveurs de jeu et à toute charge exposée.
Comment mettre à jour Go vers la dernière version sur un serveur dédié ?
Reprenez le téléchargement et l'extraction, en commençant par sudo rm -rf /usr/local/go. Vos modules et GOPATH restent intacts, rien à reconfigurer. Lancez go version après coup pour vérifier l'état, puis recompilez vos applications contre la nouvelle toolchain.
Conclusion
L'installation elle-même tient en deux commandes. Ce qui fait trébucher, c'est l'environnement : un PATH sans le répertoire bin de la toolchain, cette variable laissée vide pour que les outils compilés disparaissent, ou un paquet de distribution qui écrase l'archive. Ces trois points résolus, et la toolchain reste hors de votre chemin des années.
Prêt à déployer votre première application Go ? Les serveurs dédiés Kimsufi démarrent à 11,10 $/mois, avec accès root complet et Anti-DDoS inclus.