Microservices en Go : architecture et pratique de A à Z

Introduction : Pourquoi Go est-il le langage idéal pour les microservices ?

L'architecture microservices est devenue le standard de facto pour la construction d'applications modernes et évolutives. Le langage Go (Golang), créé au sein de Google, est parfaitement adapté à cette tâche grâce à sa simplicité, ses performances et son support intégré de la concurrence. Dans cet article, nous allons décomposer le cycle complet de création d'un microservice en Go : de la conception de l'architecture au déploiement en production.

Go offre une compilation rapide, une consommation mémoire minimale et un travail natif avec les goroutines — des threads légers. Cela en fait un excellent choix pour les systèmes distribués à forte charge. Nous examinerons les concepts clés, écrirons des exemples de code et discuterons des meilleures pratiques.

1. Conception de l'architecture d'un microservice en Go

1.1. Principes de l'architecture microservices

Avant d'écrire du code, il est nécessaire de définir les limites des microservices. Les principes de base :

\n
• Responsabilité unique (Single Responsibility) — chaque service est responsable d'une fonction métier.
\n
• Indépendance de déploiement — chaque microservice peut être mis à jour sans arrêter l'ensemble du système.
\n
• Couplage faible (Loose Coupling) — les services communiquent via des API clairement définies.
\n
• Décentralisation de la gestion des données — chaque service possède sa propre base de données.
\n

1.2. Structure de projet Go pour un microservice

Structure de dossiers recommandée pour un microservice en Go :

my-service/\n├── cmd/\n│   └── server/\n│       └── main.go          # Point d'entrée\n├── internal/\n│   ├── handler/             # Gestionnaires HTTP/gRPC\n│   ├── service/             # Logique métier\n│   ├── repository/          # Interaction avec la base de données\n│   └── model/               # Structures de données\n├── pkg/\n│   └── api/                 # Fichiers proto communs (gRPC)\n├── config/\n│   └── config.go            # Configuration\n├── migrations/              # Migrations de base de données\n├── Dockerfile\n└── go.mod

1.3. Exemple d'un microservice simple

Créons un microservice HTTP de base pour la gestion des utilisateurs. Commençons par définir le modèle et le repository :

// internal/model/user.go\npackage model\n\ntype User struct {\n    ID    int64  `json:"id"`\n    Name  string `json:"name"`\n    Email string `json:"email"`\n}\n\n// internal/repository/user_repo.go\npackage repository\n\nimport (\n    "context"\n    "my-service/internal/model"\n)\n\ntype UserRepository interface {\n    GetByID(ctx context.Context, id int64) (*model.User, error)\n    Create(ctx context.Context, user *model.User) (int64, error)\n}\n\ntype inMemoryRepo struct {\n    users map[int64]*model.User\n    nextID int64\n}\n\nfunc NewInMemoryRepo() UserRepository {\n    return &inMemoryRepo{\n        users:  make(map[int64]*model.User),\n        nextID: 1,\n    }\n}\n\nfunc (r *inMemoryRepo) GetByID(ctx context.Context, id int64) (*model.User, error) {\n    user, ok := r.users[id]\n    if !ok {\n        return nil, fmt.Errorf("user not found")\n    }\n    return user, nil\n}\n\nfunc (r *inMemoryRepo) Create(ctx context.Context, user *model.User) (int64, error) {\n    user.ID = r.nextID\n    r.users[user.ID] = user\n    r.nextID++\n    return user.ID, nil\n}

2. Communication entre microservices : REST, gRPC et files d'attente

2.1. API REST en Go

Pour l'interaction synchrone, on utilise le plus souvent REST ou gRPC. Examinons un contrôleur REST utilisant la bibliothèque standard net/http et le routeur chi :

// internal/handler/user_handler.go\npackage handler\n\nimport (\n    "encoding/json"\n    "net/http"\n    "strconv"\n    "my-service/internal/service"\n    "github.com/go-chi/chi/v5"\n)\n\ntype UserHandler struct {\n    svc *service.UserService\n}\n\nfunc NewUserHandler(svc *service.UserService) *UserHandler {\n