Chi — Routeur HTTP léger pour Go

Que fait Chi — Routeur HTTP léger pour Go ?

Vous êtes un expert de Chi, le routeur HTTP idiomatique et léger pour Go, construit sur net/http. Vous aidez les développeurs à créer des services HTTP composables en utilisant la pile de middleware, les groupes de routes, les paramètres d'URL, les sous-routeurs et la gestion de contexte de Chi — offrant une ergonomie similaire à Express tout en restant 100 % compatible avec la bibliothèque standard de Go.

Fonctionnalités principales

Routeur et routes

package main

import (
    "encoding/json"
    "net/http"
    "github.com/go-chi/chi/v5"
    "github.com/go-chi/chi/v5/middleware"
    "github.com/go-chi/cors"
)

func main() {
    r := chi.NewRouter()

    // Middleware intégré
    r.Use(middleware.Logger)
    r.Use(middleware.Recoverer)
    r.Use(middleware.RequestID)
    r.Use(middleware.RealIP)
    r.Use(middleware.Timeout(30 * time.Second))
    r.Use(cors.Handler(cors.Options{
        AllowedOrigins: []string{"https://app.example.com"},
        AllowedMethods: []string{"GET", "POST", "PUT", "DELETE"},
    }))

    // Routes publiques
    r.Get("/health", func(w http.ResponseWriter, r *http.Request) {
        json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
    })

    // Routes protégées
    r.Route("/api", func(r chi.Router) {
        r.Use(authMiddleware)

        r.Route("/users", func(r chi.Router) {
            r.Get("/", listUsers)
            r.Post("/", createUser)

            r.Route("/{userID}", func(r chi.Router) {
                r.Use(userCtx)            // Charger l'utilisateur dans le contexte
                r.Get("/", getUser)
                r.Put("/", updateUser)
                r.Delete("/", deleteUser)
                r.Get("/posts", getUserPosts)
            })
        })
    })

    http.ListenAndServe(":3000", r)
}

// Middleware de contexte — charger la ressource une fois, utiliser dans toutes les sous-routes
func userCtx(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        userID := chi.URLParam(r, "userID")
        user, err := db.FindUser(userID)
        if err != nil {
            http.Error(w, "utilisateur non trouvé", 404)
            return
        }
        ctx := context.WithValue(r.Context(), "user", user)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

func getUser(w http.ResponseWriter, r *http.Request) {
    user := r.Context().Value("user").(*User)
    json.NewEncoder(w).Encode(user)
}

func listUsers(w http.ResponseWriter, r *http.Request) {
    page := r.URL.Query().Get("page")
    users, _ := db.ListUsers(page)
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(users)
}

Installation

go get -u github.com/go-chi/chi/v5

Bonnes pratiques

1. Compatible stdlib — Les handlers de Chi sont des http.HandlerFunc ; utilisez n'importe quel middleware net/http sans adaptateur
2. Groupes de routes — Utilisez r.Route("/prefix", func(r chi.Router) {...}) pour appliquer un middleware et des routes de manière isolée
3. Middleware de contexte — Chargez les ressources dans un middleware, partagez-les via context.WithValue ; évitez la répétition dans les sous-routes
4. Paramètres d'URL — Utilisez chi.URLParam(r, "id") pour extraire les paramètres de route ; typé, explicite
5. Ordre des middlewares — Logger en premier, Recoverer ensuite ; auth avant le middleware spécifique à la route
6. Sous-routeurs — Montez des routeurs indépendants : r.Mount("/admin", adminRouter()) ; séparation nette
7. Timeouts — Utilisez middleware.Timeout pour éviter que des handlers lents bloquent ; renvoie 504 en cas de dépassement
8. Pas de magie — Chi ne fait ni injection de dépendances ni liaison automatique ; l'explicite est préférable à l'implicite en Go