Crééz votre premier microservice en Golang

Un microservice est une petite application autonome qui fait partie d'une architecture plus large. Contrairement aux applications monolithiques, les microservices sont conçus pour être indépendants, faciles à déployer et à mettre à l'échelle. Dans ce guide, nous allons créer un microservice simple en Golang.

Pourquoi utiliser des microservices ?

Les microservices offrent plusieurs avantages par rapport aux architectures monolithiques :

• Indépendance : Chaque microservice peut être développé, déployé et mis à l'échelle indépendamment.
• Résilience : Si un microservice tombe en panne, les autres peuvent continuer à fonctionner.
• Flexibilité technologique : Chaque microservice peut utiliser la technologie la plus adaptée à ses besoins.
• Maintenance facilitée : Les équipes peuvent se concentrer sur des services spécifiques, ce qui simplifie la maintenance et les mises à jour.
• Scalabilité : Les microservices peuvent être mis à l'échelle individuellement en fonction de la demande, ce qui optimise l'utilisation des ressources.

Inconvénients des microservices

Bien que les microservices offrent de nombreux avantages, ils présentent également certains défis :

• Complexité accrue : La gestion de plusieurs services indépendants peut être complexe.
• Communication inter-services : Les microservices doivent souvent communiquer entre eux, ce qui peut introduire des latences et des points de défaillance.
• Déploiement et orchestration : La mise en place d'un environnement de déploiement pour plusieurs microservices peut être plus compliquée que pour une application monolithique.
• Gestion des données : La cohérence des données peut être plus difficile à maintenir lorsque chaque microservice possède sa propre base de données.

Construction d'un microservice en Golang

Nous allons créer un microservice simple en Golang qui expose une API REST pour gérer des paiements avec Stripe. Ce microservice permettra de créer, lire, mettre à jour et supprimer des paiements.

Structure du projet

La structure de notre projet sera la suivante :

.
├── internal
│   ├── app
│   ├── handlers
│   ├── ticker
│   └── utils
│       └── requests
└── tests
    ├── e2e
    ├── integration
    └── utils

graph TD
    A[Start] --> B[Load Routes]
    B --> C[Initialize App]
    C --> D[Start Server]
    D --> E[Handle Requests]
    E --> F[Shutdown Server]

Le dossier app contiendra toute la logique pour gérer et lancer le serveur HTTP, y compris la configuration des routes, des middlewares et du serveur lui-même. Il utilisera chi comme routeur.

Le dossier handlers contiendra les gestionnaires pour les différentes routes de l'API. Chaque fichier dans ce dossier correspondra à un ensemble de routes liées à une entité spécifique, comme les articles de blog.

Le dossier ticker pourra contenir des tâches périodiques ou des jobs planifiés qui s'exécutent à intervalles réguliers en arrière-plan, comme l'envoi de notifications, la vérification de certaines routes API externes ou la mise à jour de certaines données.

Le dossier utils contiendra des fonctions utilitaires réutilisables dans tout le projet, comme la des fonctions pou renvoyer des requêtes en format JSON.

1. Première étape construire le serveur HTTP

Il faut voir HttpApp comme le point d'entrée principal pour gérer le serveur HTTP. Il encapsule donc la configuration du serveur, le routeur, le canal des erreurs et le contexte d'exécution.

package app

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "os"
    "strconv"
    "time"

    "github.com/Zadigo/gopurchase/internal/models"
    "github.com/go-chi/chi"
    "github.com/redis/go-redis/v9"
)

type HttpApp struct {
    serverApp   models.ServerAppInterface
    router      *chi.Mux
    chErrors    chan error
    ctx         context.Context
}

func (a *HttpApp) Start() error {
    port, err := strconv.ParseUint(os.Getenv("PORT"), 10, 16)
    if err != nil {
        log.Panicf("Invalid port: %v", err)
    }

    log.Printf("Starting %s HTTP server on port %d...", port)
    server := &http.Server{
        Addr:    fmt.Sprintf(":%d", port),
        Handler: a.router,
    }

    go func() {
        log.Printf("HTTP server ready to receive requests...")
        a.chErrors <- server.ListenAndServe()
    }()

    select {
    case err := <-a.chErrors:
        log.Printf("HTTP server error: %v", err)
        return err
    case <-a.ctx.Done():
        log.Println("⚡️ Shutting down HTTP server...")

        timeoutCtx, cancel := context.WithTimeout(a.ctx, 10*time.Second)
        defer cancel()

        return server.Shutdown(timeoutCtx)
    }
}

Il faut noter plusieurs choses. Dans un premier temps, le serveur sera lancé dans une goroutine ce qui permet de ne pas bloquer le thread principal et de gérer les erreurs de manière asynchrone comme illustré ci-dessous.

go func() {
    log.Printf("HTTP server ready to receive requests...")
    a.chErrors <- server.ListenAndServe()
}()

Le select permet de gérer plusieurs canaux de manière concurrente. Dans notre cas, il attend soit une erreur provenant du serveur HTTP, soit la fin du contexte d'exécution. Cela permet de réagir rapidement aux erreurs tout en assurant une fermeture propre du serveur lorsque le contexte est annulé.

select {
case err := <-a.chErrors:
    log.Printf("HTTP server error: %v", err)
    return err
case <-a.ctx.Done():
    log.Println("⚡️ Shutting down HTTP server...")

    timeoutCtx, cancel := context.WithTimeout(a.ctx, 10*time.Second)
    defer cancel()

    return server.Shutdown(timeoutCtx)
}

La première branche stoppe le serveur immédiatement en cas d'erreur, tandis que la seconde branche gère la fermeture propre de ce dernier lorsque le contexte est annulé.

Une fois le struct codé, il faudra l'initialiser avant de pouvoir l'utiliser. Nous le ferons avec la fonction NewApp.

func NewApp(ctx context.Context) models.AppInterface {
    app := &HttpApp{
        ctx:         ctx,
        chErrors:    make(chan error),
    }

    app.loadRoutes()
    return app
}

Nous utilisons le contexte du parent pour gérer le cycle de vie de notre application HTTP. Cela permet de propager les annulations et les délais d'attente depuis le contexte principal vers notre serveur HTTP.

Finalement les routes sont pré-chargées lors de l'initialisation de l'application grâce à l'appel à la méthode loadRoutes() dans la fonction NewApp.

Ce struct HttpApp représente donc notre application HTTP principale qui sera lancé avec la fonction Start().

2. Pré-chargement des routes

Nous allons maintenant construire la fonction responsable du pré-chargement des routes dans notre application HTTP. Cette organisation permet une plus grande modularité et facilite la maintenance du code. Si certaines routes ne nous paraissent pas nécessaires immédiatement, elles peuvent être ajoutées plus tard sans modifier la structure principale de l'application.

package app

import (
    "log"
    "time"

    "github.com/Zadigo/gopurchase/internal/handlers"
    "github.com/go-chi/chi"
    "github.com/go-chi/chi/middleware"
    "github.com/stripe/stripe-go/v85"
)

func (a *HttpApp) loadRoutes() {
    router := chi.NewRouter()

    router.Use(middleware.RequestID)
    router.Use(middleware.RealIP)
    router.Use(Cors)
    router.Use(Authorization)
    router.Use(middleware.AllowContentType("application/json"))
    router.Use(middleware.Throttle(1000))
    router.Use(middleware.Logger)
    router.Use(middleware.Recoverer)
    router.Use(JsonHeartbeat("/health"))
    router.Use(middleware.Timeout(60 * time.Second))

    router.Route("/payments", a.loadPaymentRoutes)
    a.router = router
}

Cette fonction créer un nouveau routeur Chi, applique les middlewares nécessaires et configure les routes pour les paiements et l'authentification avant de l'assigner au champ router de l'application HTTP.

func JsonHeartbeat(endpoint string) func(http.Handler) http.Handler {
    f := func(h http.Handler) http.Handler {
        fn := func(w http.ResponseWriter, r *http.Request) {
            if (r.Method == "GET" || r.Method == "HEAD") && strings.EqualFold(r.URL.Path, endpoint) {
                w.Header().Set("Content-Type", "application/json")
                w.WriteHeader(http.StatusOK)
                w.Write([]byte(`{"status":"ok"}`))
                return
            }
            h.ServeHTTP(w, r)
        }
        return http.HandlerFunc(fn)
    }
    return f
}

func Cors(next http.Handler) http.Handler {
    fn := func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Access-Control-Allow-Origin", "*")
        w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
        w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")

        if r.Method == "OPTIONS" {
            w.WriteHeader(http.StatusOK)
            return
        }

        origin := r.Header.Get("Origin")

        if _, ok := utils.AllowedOrigins[origin]; !ok {
            log.Printf("🟠 Origin not allowed: %s", origin)
            http.Error(w, "Origin not allowed", http.StatusForbidden)
            return
        }

        next.ServeHTTP(w, r)
    }
    return http.HandlerFunc(fn)
}

package utils

var AllowedOrigins = map[string]bool{
    "Postman/x":             true,
    "http://localhost:3000": true,
    "http://127.0.0.1:8000": true,
}

func Authorization(next http.Handler) http.Handler {
    fn := func(w http.ResponseWriter, r *http.Request) {
        authHeader := r.Header.Get("Authorization")
        if authHeader == "" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }

        // Ici, vous pouvez ajouter la logique pour vérifier la validité du token d'autorisation.

        next.ServeHTTP(w, r)
    }
    return http.HandlerFunc(fn)
}

func (a *HttpApp) loadPaymentRoutes(router chi.Router) {
    paymentApi := handlers.PaymentApi{
        PaymentClient: &stripe.Client{},
        App:           a,
        Ctx:           a.ctx,
    }

    err := paymentApi.SetupStripeClient()
    if err != nil {
        log.Fatalf("Failed to setup Stripe client: %v", err)
    }

    router.Post("/intent", paymentApi.CreateIntent)
    router.Post("/update", paymentApi.UpdateIntent)
    router.Post("/capture", paymentApi.CaptureIntent)
}

type PaymentApi struct {
    PaymentClient *stripe.Client
    App           models.AppInterface
    Ctx           context.Context
}

func (p *PaymentApi) SetupStripeClient() error {
    key := os.Getenv("STRIPE_API_KEY")
    if key == "" {
        return fmt.Errorf("STRIPE_API_KEY environment variable is not set")
    }
    p.PaymentClient = stripe.NewClient(key)
    return nil
}

func (p *PaymentApi) CreateIntent(w http.ResponseWriter, r *http.Request) {
    // Implémentation de la création d'un intent de paiement
}

func (p *PaymentApi) UpdateIntent(w http.ResponseWriter, r *http.Request) {
    // Implémentation de la mise à jour d'un intent de paiement
}

func (p *PaymentApi) CaptureIntent(w http.ResponseWriter, r *http.Request) {
    // Implémentation de la capture d'un intent de paiement
}

package main

import (
    "context"
    "log"
    "os"
    "os/signal"

    "github.com/Zadigo/gopurchase/internal/app"
    "github.com/Zadigo/gopurchase/internal/utils"
    "github.com/joho/godotenv"
)

func main() {
    err := godotenv.Load(".env")
    if err != nil {
        panic(err)
    }

    ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
    defer cancel()

    absPath, err := utils.GetAbsolutePath(".")
    if err != nil {
        log.Panicf("Could not get absolute path: %v", err)
    }

    ctx = context.WithValue(ctx, "rootDir", absPath)
    ctx = context.WithValue(ctx, "debug", os.Getenv("DEBUG") == "true")

    app := app.NewApp(ctx)
    err = app.Start()
    if err != nil {
        log.Panicf("Could not start server: %v", err)
    }
}

ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
defer cancel()

ctx = context.WithValue(ctx, "rootDir", absPath)
ctx = context.WithValue(ctx, "debug", os.Getenv("DEBUG") == "true")

package utils

import (
    "fmt"
    "path"
    "path/filepath"
)

func GetAbsolutePath(strPath string) (string, error) {
    absPath, err := filepath.Abs(strPath)
    if err != nil {
        return "", fmt.Errorf("Failed to get absolute path: %v", err)
    }

    result := path.Ext(absPath)
    if result != "" {
        return "", fmt.Errorf("Base directory should be a directory, got a file: %s", absPath)
    }

    return absPath, nil
}

go run .