Utiliser Go (Golang)

Vue d'ensemble

Go (souvent appelé Golang) est un langage de programmation open-source, statiquement typé et compilé, conçu par Google. Il séduit les développeurs par sa syntaxe épurée, sa vitesse de compilation exceptionnelle, sa gestion avancée de la concurrence (grâce aux goroutines légères et aux channels pour la communication) et son ramasse-miettes intégré performant. Go excelle dans la création de services réseau hautement performants, de systèmes distribués, de microservices et d’outils en ligne de commande. Il s’impose comme un choix incontournable pour le cloud natif et le développement back-end moderne.

Prise en charge de Go par ServBay

ServBay, environnement de développement Web local intégré compatible macOS et Windows, offre un support puissant et transparent pour les développeurs Go. Grâce à ServBay, il est extrêmement facile d’installer, de gérer et de basculer entre différentes versions de Go, sans avoir à configurer manuellement des variables d’environnement complexes telles que GOROOT ou GOPATH, simplifiant grandement l’initialisation et la maintenance de votre environnement Go.

ServBay inclut l’ensemble des outils Go et prend en charge une vaste gamme de versions, des plus anciennes aux plus récentes et stables, répondant ainsi à tous vos besoins projets :

Go 1.11
Go 1.12
Go 1.13
Go 1.14
Go 1.15
Go 1.16
Go 1.17
Go 1.18
Go 1.19
Go 1.20
Go 1.21
Go 1.22
Go 1.23
Go 1.24 (ainsi que les versions plus récentes prises en charge par ServBay lors de futures mises à jour)

Prise en charge de Go Modules

L’environnement ServBay active par défaut et recommande fortement l’utilisation de Go Modules pour la gestion des dépendances. Depuis la version 1.11, c’est la solution standard préconisée par l’équipe Go. Dans le terminal ServBay, utilisez directement les commandes go mod (go mod init, go get, go mod tidy, etc.) pour gérer les dépendances de vos projets, sans vous soucier des réglages du $GOPATH hérités.

Prérequis

ServBay doit être installé et fonctionnel sur votre macOS.
Vous maîtrisez les bases de la programmation en Go.
Vous êtes à l’aise avec les commandes de base au terminal/shell.

Installation de Go

Installer Go via l’interface graphique intuitive (GUI) ServBay est très facile :

Lancez l’application ServBay.
Dans la barre latérale gauche, cliquez sur Paquets.
Recherchez la section Go dans la liste des paquets développée.
Cliquez sur Go pour l’étendre et affichez toutes les versions prises en charge.
Sélectionnez la version souhaitée (il est recommandé de choisir la plus récente et stable, par exemple Go 1.24) et cliquez sur le bouton Installer correspondant.
ServBay télécharge et installe automatiquement la version de Go choisie ; la durée dépend de votre connexion Internet.

Une fois l’installation terminée, le statut de la version apparaît comme installée. Vous pouvez installer d’autres versions ou basculer facilement entre celles déjà présentes.

Utiliser Go

Après l’installation, accédez directement à l’ensemble des commandes Go dans votre terminal macOS.

Pour vérifier que Go est bien installé et afficher la version active :

bash

go version

Le terminal devrait afficher une information similaire, correspondant à la version Go gérée par ServBay :

go version go1.24.1 darwin/arm64

Compiler et exécuter une simple application Web Go

Nous allons créer un exemple de serveur HTTP basique en Go, le compiler et l’exécuter dans l’environnement ServBay.

Créer le dossier du projet : Il est conseillé de créer un nouveau dossier pour votre projet Go dans le répertoire racine par défaut de ServBay : /Applications/ServBay/www. Par exemple, créons go-servbay-demo.
bash
```
cd /Applications/ServBay/www
mkdir go-servbay-demo
cd go-servbay-demo
```
1
2
3
Initialiser Go Modules : Dans le dossier racine de votre projet (go-servbay-demo), initialisez les modules Go avec go mod init. Pour le chemin du module, utilisez de préférence l’identifiant du dépôt ou un nom unique, ici nous prenons le nom du dossier.
bash
```
go mod init go-servbay-demo
```
1
Cette commande génère un fichier go.mod dans le répertoire courant, permettant de suivre les dépendances du projet.

Écrire le code Go : Créez un fichier source appelé main.go et copiez-y le code suivant :

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
)

func handler(w http.ResponseWriter, r *http.Request) {
	hostname, _ := os.Hostname()
	fmt.Fprintf(w, "Hello from Go on ServBay!\nHostname: %s\nPath: %s\n", hostname, r.URL.Path)
}

func main() {
	http.HandleFunc("/", handler)

	port := "8080" // Définir le port d’écoute du serveur
	log.Printf("Go web server starting on port %s...", port)
	log.Printf("Access it at http://localhost:%s", port)

	// Démarrer le serveur HTTP
	err := http.ListenAndServe(":"+port, nil)
	if err != nil {
		log.Fatalf("Error starting server: %s\n", err)
	}
}

Ce code définit un serveur HTTP simple à l’écoute sur le port local 8080. Pour chaque requête, il renvoie un texte incluant “Hello from Go on ServBay!”, le nom du poste et le chemin de la requête.

Exécuter l’application Go : Assurez-vous d’être toujours dans le dossier du projet sous ServBay (/Applications/ServBay/www/go-servbay-demo) puis compilez et lancez votre programme Go :
bash
```
go run main.go
```
1
Si tout est correct, le terminal affichera des logs indiquant que le serveur a démarré avec succès :
```
2024/05/20 15:00:00 Go web server starting on port 8080...
2024/05/20 15:00:00 Access it at http://localhost:8080
```
1
2
Accéder à l’application : Ouvrez votre navigateur et rendez-vous sur http://localhost:8080. Vous verrez un message du style : “Hello from Go on ServBay! Hostname: your-mac-hostname Path: /”.

Configurer le reverse proxy avec ServBay (fortement recommandé)

Il est possible d’accéder directement via localhost:8080, mais pour le développement local, il est préférable d’employer un nom de domaine convivial (par ex., go-app.servbay.demo), et de passer par le serveur Web intégré à ServBay (Caddy, Apache ou Nginx) via un reverse proxy. Cela simule un environnement de production, facilite l’utilisation de fonctionnalités avancées (HTTPS auto, intégration de services) et standardise l’accès HTTP/HTTPS.

Créer le site dans ServBay :
- Ouvrez l’interface ServBay et rendez-vous dans la section Sites.
- Cliquez sur Ajouter un site.
- Nom de domaine : Saisissez le nom souhaité pour le développement local, par exemple go-app.servbay.demo.
- Type de site : Choisissez Reverse Proxy.
- Adresse IP : Entrez 127.0.0.1.
- Port : Entrez 8080.

Sauvegarder et recharger la configuration : Enregistrez vos changements sur la configuration du site dans ServBay et redémarrez (ou rechargez) le serveur Web concerné (Caddy ou Nginx) pour que la nouvelle configuration soit prise en compte.
Accéder à l’application par domaine : Vous pouvez désormais accéder à votre application Web Go via https://go-app.servbay.demo dans le navigateur. Le serveur Web de ServBay réceptionne les requêtes et les redirige automatiquement vers votre programme Go.

Gestion des versions Go

ServBay simplifie au maximum la gestion et le basculement entre plusieurs versions de Go.

Basculement de version : Dans l’interface ServBay, section Paquets > Go, toutes les versions installées sont listées. Ouvrez le menu latéral Paramètres pour définir une version de Go comme valeur par défaut.
Vérification du basculement : Après avoir basculé, ouvrez un nouveau terminal et exécutez go version pour vérifier que la version affichée correspond bien à celle sélectionnée.

Gérer la version Go d’un projet avec `.servbay.config`

Outre la gestion globale, ServBay propose un mécanisme fin de contrôle de version par projet, via un fichier .servbay.config placé à la racine du projet.

Fonctionnement :

Lorsque vous utilisez le terminal intégré ServBay pour cd vers un dossier contenant un fichier .servbay.config, ServBay le détecte et lit sa configuration (par exemple GO_VERSION). La session terminal adapte alors l’environnement temporairement afin que les commandes Go pointent vers la version précisée.

Format du fichier :

.servbay.config est un simple fichier texte à base de paires clé-valeur. Pour fixer la version de Go d’un projet, ajoutez une ligne GO_VERSION :

ini

# Exemple de fichier .servbay.config
# Définit Go 1.22 pour ce projet
GO_VERSION=1.22

# Il est possible de fixer simultanément les versions d’autres outils
# PHP_VERSION=8.3
# NODE_VERSION=20
# PYTHON_VERSION=3.11
# ... autres options possibles ...
# GOPROXY=https://goproxy.cn,direct

Avantages :

Basculement automatique : Plus besoin de changer la version globale ; la bonne version Go est utilisée dès l’entrée dans le dossier projet.
Isolement par projet : Chaque projet compile et s’exécute dans son environnement Go prévu, limitant les conflits de version.
Travail en équipe : En versionnant le fichier .servbay.config dans Git ou autre VCS, tous les membres du projet bénéficient d’un environnement Go homogène lors du clonage.

Cas d’usage :

Supposons que :

project-a nécessite Go 1.12
project-b requiert Go 1.22

Placez un fichier .servbay.config approprié dans la racine de chaque projet :

/Applications/ServBay/www/project-a/.servbay.config :
ini
```
GO_VERSION=1.12
```
1
/Applications/ServBay/www/project-b/.servbay.config :
ini
```
GO_VERSION=1.22
```
1

En vous positionnant dans /Applications/ServBay/www/project-a à l’aide du terminal et en exécutant go version, vous verrez Go 1.12.x. Dans /Applications/ServBay/www/project-b, la commande indiquera Go 1.22.x.

Remarque : .servbay.config permet surtout de régler la version de base Go gérée par ServBay. Pour la gestion des dépendances spécifiques au projet, il reste recommandé d’employer Go Modules (go.mod).

Foire aux questions (FAQ)

Q : En lançant la commande go dans le terminal ServBay, j’obtiens “command not found” ?
R : Vérifiez que votre terminal est bien configuré avec la variable PATH propre à ServBay. Assurez-vous aussi qu’au moins une version de Go est installée et activée par défaut dans Paquets > Go dans l’interface ServBay.
Q : Comment mettre à jour Go à la dernière version dans ServBay ?
R : Consultez régulièrement la section Paquets > Go. ServBay affiche les nouvelles versions dès qu’elles sont prises en charge : installez-les en un clic via la GUI. Pour utiliser la nouvelle version, sélectionnez-la comme version par défaut.
Q : Go Modules télécharge lentement les dépendances ou rencontre des problèmes réseau ?
R : Par défaut, Go Modules utilise proxy.golang.org, qui peut poser problème depuis la Chine ou certaines régions. Configurez la variable d’environnement GOPROXY pour accélérer le téléchargement, en passant par des miroirs tels que https://goproxy.cn ou https://goproxy.io. Cela s’effectue dans les réglages globaux ServBay ou simplement dans votre fichier .servbay.config (ex :GOPROXY=https://goproxy.cn,direct).
Q : Mon application Web Go signale que le port est déjà utilisé (“address already in use”) ?
R : Cela signifie que le port (ex : 8080) choisi dans votre code est occupé par un autre processus. Deux options : modifiez votre application pour utiliser un port libre (par ex., 8081, 9000…), ou trouvez et stoppez le processus en conflit. Sous macOS, utilisez lsof -i :<port_number> (ex :lsof -i :8080) pour identifier le PID, puis kill <PID> pour l’arrêter.
Q : Quelle est la différence entre le fichier .servbay.config et le changement global de version Go ? Lequel privilégier ?
R : Le changement global (via l’interface ServBay) affecte la version Go par défaut sur tout le système. Le fichier .servbay.config applique une gestion fine au niveau du projet : seule la session terminal dans le dossier contenant ce fichier bascule sur la version spécifiée. Il est recommandé d’utiliser .servbay.config pour les besoins spécifiques à chaque projet, car cela garantit l’isolation et la reproductibilité de l’environnement (notamment en cas de gestion simultanée de plusieurs projets nécessitant des versions Go différentes). Le changement global est à réserver à l’usage général lorsqu’une version est utilisée en permanence.

Conclusion

ServBay propose un environnement local très efficace et convivial pour le développement Go (Golang) sous macOS. Grâce à son interface graphique simple, installez et gérez facilement plusieurs versions de Go, contrôlez la version au niveau du projet via .servbay.config, exploitez Go Modules pour la gestion des dépendances, et bénéficiez du serveur Web intégré pour reverse proxy et hébergement. ServBay permet de mettre en place, tester et faire évoluer vos applications Go en toute simplicité, tout en éliminant les contraintes habituelles de configuration d’environnement – ce qui vous laisse plus de temps pour innover dans votre code Go.

Utiliser Go (Golang) ​

Vue d'ensemble ​

Prise en charge de Go par ServBay ​

Prérequis ​

Installation de Go ​

Utiliser Go ​

Compiler et exécuter une simple application Web Go ​

Configurer le reverse proxy avec ServBay (fortement recommandé) ​

Gestion des versions Go ​

Gérer la version Go d’un projet avec .servbay.config ​

Foire aux questions (FAQ) ​

Conclusion ​