Utiliser Go (Golang)

Aperçu

Go, souvent appelé Golang, est un langage de programmation compilé, statiquement typé et open source, conçu par Google. Il séduit les développeurs grâce à sa syntaxe épurée, sa vitesse de compilation fulgurante, ses excellentes capacités de gestion de la concurrence (via les goroutine légères et le mécanisme de communication channel), ainsi qu'à son garbage collector intégré performant. Go excelle particulièrement pour la création de services réseaux hautes performances, de systèmes distribués, de microservices et d’outils en ligne de commande. Il s’est imposé comme l’un des choix majeurs pour les applications cloud natives modernes et le développement backend.

Prise en charge de Go par ServBay

ServBay, un environnement de développement Web local intégré conçu spécialement pour macOS, propose un support transparent et puissant pour les développeurs Go. Avec ServBay, installer, gérer et basculer entre différentes versions de Go devient un jeu d’enfant, sans avoir à configurer manuellement des variables d’environnement complexes comme GOROOT ou GOPATH. Cela simplifie considérablement l’installation et la gestion de vos environnements Go.

ServBay intègre l’ensemble de la chaîne d’outils Go, et prend en charge un large éventail de versions de Go, des versions historiques jusqu’à la plus récente, afin de répondre aux besoins spécifiques de chacun de vos 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 toutes les versions ultérieures prises en charge par les mises à jour ServBay)

Prise en charge des Go Modules

L’environnement ServBay active par défaut et recommande l’utilisation de Go Modules pour la gestion des dépendances. Il s’agit de la solution standard introduite et conseillée par l’équipe Go depuis la version 1.11. Depuis le terminal ServBay, vous pouvez gérer vos dépendances à l’aide des commandes associées (go mod init, go get, go mod tidy, etc.), sans vous soucier des paramètres traditionnels de $GOPATH.

Prérequis

ServBay doit être installé et fonctionnel sur votre macOS.
Maîtriser les bases de la programmation en Go.
Savoir utiliser les commandes de base dans le Terminal.

Installer Go

L’installation de Go via l’interface graphique intuitive proposée par ServBay est très simple :

Lancez l’application ServBay.
Dans la barre de navigation à gauche, cliquez sur Packages (ou « Logiciels »).
Localisez la catégorie Go dans la liste déroulante des packages.
Cliquez sur Go pour voir la liste des versions disponibles à l’installation via ServBay.
Sélectionnez la version de Go souhaitée (il est généralement conseillé de prendre la version stable la plus récente, comme Go 1.24) et cliquez sur le bouton Installer à côté.
ServBay téléchargera et installera automatiquement la version de Go sélectionnée. Le temps de téléchargement dépendra de la rapidité de votre connexion internet.

Après installation, l’état de la version choisie passera à « Installé ». Vous pourrez alors installer d’autres versions si besoin ou bien alterner rapidement entre les versions déjà installées.

Utiliser Go

Une fois Go installé, vous pouvez utiliser immédiatement l’ensemble des commandes go depuis votre terminal.

Pour vérifier que Go est bien installé et voir la version active, tapez :

bash

go version

Vous devriez voir s’afficher une ligne indiquant la version de Go actuellement activée via ServBay :

go version go1.24.1 darwin/arm64

Compiler et exécuter une application Web Go simple

Allons plus loin avec la création, compilation et exécution dans ServBay d’un serveur HTTP Go très basique.

Créer un dossier de projet : Il est conseillé de créer votre dossier de projet Go sous le répertoire racine par défaut de ServBay, à savoir /Applications/ServBay/www. Par exemple, créons un dossier appelé go-servbay-demo :
bash
```
cd /Applications/ServBay/www
mkdir go-servbay-demo
cd go-servbay-demo
```
1
2
3
Initialiser les Go Modules : Dans le dossier racine de votre projet (go-servbay-demo), lancez la commande suivante pour initialiser Go Modules. Pour le nom du module, utilisez généralement un identifiant unique lié à votre dépôt ou projet (nous allons utiliser le nom du dossier pour l’exemple).
bash
```
go mod init go-servbay-demo
```
1
Cette commande génère un fichier go.mod à la racine du dossier, qui servira à suivre vos dépendances.

Écrire le code Go : Créez un fichier source nommé 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 service
	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 petit serveur HTTP à l’écoute du port local 8080. Pour chaque requête reçue, il retourne le message "Hello from Go on ServBay!", accompagné du nom d’hôte de votre machine et du chemin de la requête.

Exécuter l’application Go : Restez dans le dossier du projet (/Applications/ServBay/www/go-servbay-demo) et exécutez la commande suivante pour compiler et lancer le serveur :
bash
```
go run main.go
```
1
Si tout s’est bien passé, le terminal affichera des logs similaires à :
```
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 : Rendez-vous dans votre navigateur à l’adresse http://localhost:8080. Vous devriez voir une page avec un message ressemblant à : « Hello from Go on ServBay! Hostname: votre-nom-de-mac Path: / ».

Configurer un proxy inverse avec ServBay (fortement recommandé)

Même si vous pouvez accéder à votre application via localhost:8080, l’idéal pour le développement local est d’utiliser un nom de domaine personnalisé (par exemple go-app.servbay.demo) et de tirer parti du serveur Web intégré de ServBay (Caddy, Apache ou Nginx) pour mettre en place un proxy inverse. Cela vous permet d’accéder à votre application Go comme en production via les ports standard HTTP/HTTPS, et de profiter des fonctionnalités ServBay (HTTPS automatique, intégration avec d’autres services, etc.).

Créer un site dans ServBay :
- Dans l’interface ServBay, rendez-vous dans la section Sites.
- Cliquez sur le bouton Ajouter un site.
- Nom de domaine : entrez le domaine local que vous souhaitez, par exemple go-app.servbay.demo.
- Type de site : choisissez Proxy inverse.
- Adresse IP : saisissez 127.0.0.1.
- Port : saisissez 8080.

Enregistrer et recharger la configuration : Enregistrez les modifications dans ServBay et assurez-vous de redémarrer ou recharger la configuration du serveur Web (Caddy ou Nginx) afin que les nouveaux paramètres soient pris en compte.
Accéder à l’application via le domaine : Vous pouvez maintenant accéder à votre application web Go à l’adresse https://go-app.servbay.demo dans votre navigateur. Le serveur Web de ServBay prendra en charge les requêtes et les transmettra automatiquement à votre serveur Go.

Gérer les versions de Go

ServBay simplifie à l’extrême la gestion et la commutation entre plusieurs versions de Go.

Changer de version : Dans la section Packages -> Go de ServBay, vous verrez toutes les versions installées. Depuis le menu latéral Paramètres, vous pouvez définir la version de Go qui sera utilisée par défaut.
Vérifier le changement : Après avoir basculé d’une version à l’autre, ouvrez un nouveau terminal et lancez go version pour confirmer que la version activée est bien celle demandée.

Gérer la version Go par projet avec `.servbay.config`

Au-delà de la bascule globale entre versions, ServBay propose un système poussé de gestion de version à l’échelle du projet, via un fichier .servbay.config placé à la racine du répertoire concerné.

Principe de fonctionnement :

Lorsque vous utilisez le terminal intégré de ServBay et que vous naviguez (cd) dans un dossier contenant un fichier .servbay.config, ServBay détectera et lira automatiquement ce fichier. Selon la configuration présente (ex : GO_VERSION), la session shell ajustera temporairement son environnement de façon à ce que la commande go pointe vers la version souhaitée.

Format du fichier de configuration :

.servbay.config est simplement un fichier texte avec un format clé-valeur. Pour assigner une version de Go à votre projet, il suffit d’ajouter une ligne GO_VERSION :

ini

# Exemple de fichier .servbay.config
# Indique que ce projet utilise Go version 1.22
GO_VERSION=1.22

# Vous pouvez également spécifier d’autres outils pour le projet
# PHP_VERSION=8.3
# NODE_VERSION=20
# PYTHON_VERSION=3.11
# ... autres options éventuelles ...
# GOPROXY=https://goproxy.cn,direct

Avantages :

Changement de version automatique : Dès l’entrée dans le dossier projet, la version Go spécifique est activée sans intervention manuelle.
Isolation des projets : Chaque projet compile et s’exécute dans la version Go qui lui est prévue, évitant ainsi conflits et incompatibilités.
Travail en équipe : En versionnant le fichier .servbay.config dans Git, vous assurez un environnement Go cohérent à tous vos collaborateurs dès le clonage du dépôt.

Scénarios types :

Supposons que vous gériez deux projets :

project-a nécessite Go 1.12
project-b utilise la version Go 1.22 la plus récente

Vous créerez un fichier .servbay.config distinct pour chaque projet, à la racine respective :

/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

Quand vous entrez dans /Applications/ServBay/www/project-a avec le terminal ServBay et tapez go version, vous verrez Go 1.12.x. Et pour /Applications/ServBay/www/project-b, ce sera Go 1.22.x.

Remarque : .servbay.config agit principalement sur la version globale de Go vue par ServBay. Pour la gestion fine des dépendances, il reste fortement recommandé d’adopter Go Modules (fichier go.mod).

FAQ (Questions fréquentes)

Q : Lors de l’exécution d’une commande go dans le terminal ServBay, j’ai l’erreur "command not found" ?
R : Vérifiez d’abord que votre terminal hérite bien du PATH de ServBay. Ensuite, assurez-vous d’avoir installé au moins une version de Go dans la section Packages -> Go de l’interface ServBay, et qu’une version par défaut est bien activée.
Q : Comment mettre Go à jour vers la dernière version avec ServBay ?
R : Consultez régulièrement la section Packages -> Go dans ServBay. Dès qu’une nouvelle version est disponible, elle apparaîtra dans la liste, vous pourrez alors l’installer et la choisir comme version active via l’interface.
Q : J’ai des difficultés de connexion ou des téléchargements très lents des dépendances Go Modules ?
R : Par défaut, Go Modules télécharge via proxy.golang.org. Depuis la Chine continentale ou toute zone réseau restreinte, cela peut poser problème. Configurez la variable d’environnement GOPROXY pour utiliser un miroir rapide, tel que https://goproxy.cn ou https://goproxy.io. Cela peut être défini à l’échelle globale dans ServBay, ou par projet dans .servbay.config (par exemple : GOPROXY=https://goproxy.cn,direct).
Q : Mon application Web Go signale que le port est déjà utilisé (address already in use) ?
R : Cette erreur signifie que le port (par exemple 8080) est occupé par un autre processus. Vous avez deux options : modifiez le code Go pour écouter un autre port libre (8081, 9000, etc.), ou bien identifiez puis tuez le processus en question. Sur macOS, utilisez lsof -i :<numéro_de_port> (ex : lsof -i :8080) pour trouver le PID, puis kill <PID> pour l’arrêter.
Q : Quelle différence entre .servbay.config et le changement de version Go global ? Que dois-je utiliser ?
R : La commutation globale (depuis l’interface ServBay) modifie la version Go par défaut pour tout le système. .servbay.config autorise une gestion fine et temporaire : dans chaque dossier projet, la session terminal adapte automatiquement la version de Go à celle souhaitée. L’usage de .servbay.config est vivement recommandé pour isoler l’environnement de chaque projet et garantir la reproductibilité, surtout si vous gérez plusieurs projets nécessitant des versions Go différentes. Le réglage global sert principalement à définir votre version préférée par défaut.

Conclusion

ServBay offre aux développeurs Go sous macOS un environnement local à la fois puissant, flexible et convivial. Son interface graphique facilite la gestion de multiples versions de Go, tandis que .servbay.config vous permet de verrouiller les versions à l’échelle du projet. Associé à Go Modules pour la gestion des dépendances et aux serveurs Web internes de ServBay pour l’hébergement applicatif (avec proxy automatique), vous pouvez rapidement créer, tester et déployer vos applications Go. Grâce à ServBay, oubliez les difficultés de configuration : concentrez-vous sur l’essentiel — coder et innover en Go.

Utiliser Go (Golang) ​

Aperçu ​

Prise en charge de Go par ServBay ​

Prérequis ​

Installer Go ​

Utiliser Go ​

Compiler et exécuter une application Web Go simple ​

Configurer un proxy inverse avec ServBay (fortement recommandé) ​

Gérer les versions de Go ​

Gérer la version Go par projet avec .servbay.config ​

FAQ (Questions fréquentes) ​

Conclusion ​