Microservices en Go : par où commencer et ne pas abandonner

Pourquoi Go est le meilleur choix pour les microservices (et quand ce n'est pas le cas)

Imaginez que vous construisez un centre commercial. Au lieu d'ériger un seul bâtiment géant, vous construisez des pavillons individuels : un café, une librairie, une épicerie. Chacun fonctionne indépendamment, mais ensemble ils forment un complexe unique. L'ascenseur est en panne quelque part ? La librairie continue de fonctionner. Les gobelets sont épuisés au café ? On ferme seulement celui-ci, pas tout le complexe.

C'est ce qu'on appelle l'architecture microservices. Et Go (Golang) est le matériau idéal pour construire ces « pavillons ». Pourquoi ?

• Démarrage rapide : compilation en un seul binaire. Pas de JDK, de machines virtuelles ou de node_modules.
• Performance : Go fonctionne au niveau du C++, mais s'écrit comme Python.
• Concurrence intégrée : les goroutines et les canaux (channels) sont un super-pouvoir pour traiter des centaines de requêtes par seconde.
• Simplicité : Go est volontairement limité. Pas de génériques (jusqu'à Go 1.18, il n'y en avait pas), pas d'héritage. Le code se lit comme un mode d'emploi d'aspirateur — on comprend immédiatement ce que chaque ligne fait.

Mais il y a aussi des inconvénients. Go ne convient pas si vous avez besoin :

• D'héritage de classes lourd (il n'existe pas ici).
• D'une énorme quantité de bibliothèques prêtes à l'emploi pour n'importe quelle tâche (l'écosystème est plus pauvre que celui de Java ou Python).
• De typage dynamique (Go est fortement typé, vous devrez écrire plus de code passe-partout).

Si votre projet est une API à forte charge, un backend pour un chat, une passerelle de paiement ou un système de surveillance — Go est votre choix. Si vous écrivez un prototype en un week-end et que la vitesse vous importe peu — prenez Python.

Étape 1. Préparer sa valise : outils et structure du projet

Ce qu'il faut installer

Avant d'écrire du code, configurons l'environnement. Vous aurez besoin de :

• Go (version 1.21+). Téléchargez-le depuis go.dev.
• Docker (pour la conteneurisation).
• curl ou Postman (pour tester l'API).
• N'importe quel IDE : GoLand, VS Code avec le plugin Go, Vim. Je recommande VS Code — gratuit et pratique.

Structure de dossiers correcte

Mettons-nous d'accord tout de suite : pas de bricolage. Voici la structure standard pour un microservice en Go :

/user-service├── cmd/│   └── server/│       └── main.go        # point d'entrée├── internal/│   ├── handler/           # gestionnaires HTTP│   ├── service/           # logique métier│   ├── repository/        # interaction avec la base de données│   └── model/             # structures de données├── pkg/│   └── middleware/        # utilitaires communs├── Dockerfile├── go.mod└── go.sum

Pourquoi ainsi ? Go est un langage où la structure des dossiers dicte l'architecture. cmd/ — le point d'entrée. internal/ — tout ce qui ne peut pas être importé de l'extérieur (protection contre les erreurs). pkg/ — ce qui peut être partagé avec d'autres services.

Étape 2. Écrire notre premier microservice : Hello, World! 2.0

Écrivons un simple serveur HTTP en Go qui renverra du JSON. Ce sera notre « microservice de salutations ».

Étape 1. Initialisation du module

mkdir hello-servicecd hello-servicego mod init github.com/votre-nom-utilisateur/hello-service

Étape 2. Écrire main.go

package main

import (    "encoding/json"    "log"    "net/http"    "time")

// GreetingResponse — structure de la réponsetype GreetingResponse struct {    Message   string `json:"message"`    Timestamp string `json:"timestamp"`}

func greetHandler(w http.ResponseWriter, r *http.Request) {    // Définir les en-têtes    w.Header().Set("Content-Type", "application/json")    w.WriteHeader(http.StatusOK)

    // Créer la réponse    response := GreetingResponse{        Message:   "Bonjour, les microservices!",