Microservices en Go : architecture et pratique de A à Z

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Introduction aux microservices en Go

L'architecture microservices est devenue le standard de facto pour la construction de systèmes distribués modernes. Le langage Go (Golang) avec ses goroutines légères, ses hautes performances et sa simplicité de déploiement est idéal pour implémenter des microservices. Dans cet article, nous analyserons l'architecture des microservices en Go, du concept à la mise en œuvre pratique avec des exemples de code.

Go offre un support intégré de la concurrence, un démarrage rapide et une taille réduite des fichiers binaires — tous ces éléments sont essentiels pour les microservices. Nous verrons comment concevoir un service, implémenter une API REST, ajouter un middleware et préparer l'application à la conteneurisation.

Architecture d'un microservice en Go

1. Structure du projet

Une bonne organisation du code est la base d'un microservice maintenable. Structure recommandée :

myservice/├── cmd/│   └── server/│       └── main.go          # Point d'entrée├── internal/│   ├── handler/             # Gestionnaires HTTP│   ├── service/             # Logique métier│   ├── repository/          # Accès aux données│   └── middleware/          # Middlewares├── pkg/│   └── models/              # Modèles de données communs├── config/│   └── config.go            # Configuration├── go.mod└── Dockerfile

Cette structure respecte les principes de la Clean Architecture : handler → service → repository. Cela permet de tester facilement chaque couche indépendamment.

2. Configuration et démarrage

Commençons par un serveur HTTP simple utilisant la bibliothèque standard net/http :

// cmd/server/main.gopackage main

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

func main() {    port := os.Getenv("PORT")    if port == "" {        port = "8080"    }

    http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {        w.WriteHeader(http.StatusOK)        fmt.Fprintf(w, `{"status": "ok"}`)    })

    log.Printf("Server starting on :%s", port)    log.Fatal(http.ListenAndServe(":"+port, nil))}

Voici un microservice minimal. Pour la production, utilisez un routeur avec support middleware, comme gorilla/mux ou chi.

Implémentation pratique d'un microservice

3. API REST avec gorilla/mux

Installons gorilla/mux et implémentons le CRUD pour l'entité "Utilisateur" :

// go.modmodule github.com/youruser/userservice

go 1.21

require github.com/gorilla/mux v1.8.1

// internal/handler/user.gopackage handler

import (    "encoding/json"    "net/http"    "github.com/gorilla/mux")

type User struct {    ID   string `json:"id"`    Name string `json:"name"`    Age  int    `json:"age"`}

var users = []User{    {ID: "1", Name: "Alice", Age: 30},}

func GetUsers(w http.ResponseWriter, r *http.Request) {    w.Header().Set("Content-Type", "application/json")    json.NewEncoder(w).Encode(users)}

func CreateUser(w http.ResponseWriter, r *http.Request) {    var newUser User    if err := json.NewDecoder(r.Body).Decode(&newUser); err != nil {        http.Error(w, err.Error(), http.StatusBadRequest)        return    }    users = append(users, newUser)    w.WriteHeader(http.StatusCreated)    json.NewEncoder(w).Encode(newUser)}

// cmd/server/main.go (suite)package main

import (    "log"    "net/http"    "github.com/gorilla/mux"    "yourproject/internal/handler")

func main() {    r := mux.NewRouter()    r.HandleFunc("/users", handler.GetUsers).Methods("GET")    r.HandleFunc("/users", handler.CreateUser).Methods("POST")

    log.Println("Server started on :8080")    log.Fatal(http.ListenAndServe(":8080", r))}