Leçons du module (5/5)
Mini-projet : un serveur HTTP
Le package net/http stdlib est suffisant pour construire un serveur HTTP prêt pour la production : routage, gestionnaires, middleware, arrêt progressif. Aucun cadre requis. Pour les API REST typiques, c'est la base.
Bonjour le monde
package main
import (
"fmt"
"net/http"
)
func main() {
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "hello %s", r.URL.Path[1:])
})
if err := http.ListenAndServe(":8080", nil); err != nil {
panic(err)
}
}http.ListenAndServe bloque et ne renvoie qu'en cas d'erreur. nil comme deuxième argument = "utiliser le DefaultServeMux".
La signature du gestionnaire
Tous les gestionnaires partagent la même signature :
func(w http.ResponseWriter, r *http.Request)w http.ResponseWriter— sortie : en-têtes, code d'état, corps.r *http.Request— entrée : méthode, URL, en-têtes, corps, contexte.
Modèle typique :
func ping(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
return
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK) // optional, defaults to 200
fmt.Fprintln(w, `{"ok":true}`)
}Routage avec ServeMux
*http.ServeMux est le routeur de base. Depuis Go 1.22, il prend en charge les modèles avec des paramètres de méthode et de chemin :
mux := http.NewServeMux()
mux.HandleFunc("GET /users/{id}", func(w http.ResponseWriter, r *http.Request) {
id := r.PathValue("id")
fmt.Fprintln(w, "user", id)
})
mux.HandleFunc("POST /users", createUser)
http.ListenAndServe(":8080", mux)Pour les routeurs plus sophistiqués (groupes, middleware intégré, regex), il existe chi, gorilla/mux, gin, echo. La stdlib couvre 90% des cas.
Middleware en tant que décorateur
Un middleware est une fonction func(http.Handler) http.Handler :
func logMW(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
next.ServeHTTP(w, r)
log.Printf("%s %s %s", r.Method, r.URL.Path, time.Since(start))
})
}
http.ListenAndServe(":8080", logMW(mux))Pour les enchaîner : logMW(authMW(rateLimitMW(mux))). Chaque middleware décore le suivant.
http.Server pour un contrôle précis
http.ListenAndServe(addr, h) est un raccourci. Pour les délais d'attente, TLS et l'arrêt progressif, vous devez instancier http.Server :
srv := &http.Server{
Addr: ":8080",
Handler: mux,
ReadHeaderTimeout: 5 * time.Second,
ReadTimeout: 30 * time.Second,
WriteTimeout: 30 * time.Second,
IdleTimeout: 2 * time.Minute,
}
log.Fatal(srv.ListenAndServe())Arrêt progressif avec contexte
Lorsque le processus reçoit SIGINT/SIGTERM, vous souhaitez terminer les requêtes en cours avant de fermer :
ctx, stop := signal.NotifyContext(context.Background(),
os.Interrupt, syscall.SIGTERM)
defer stop()
srv := &http.Server{Addr: ":8080", Handler: mux}
go func() {
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
log.Fatal(err)
}
}()
<-ctx.Done() // wait for the signal
shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := srv.Shutdown(shutdownCtx); err != nil {
log.Println("shutdown:", err)
}srv.Shutdown cesse d'accepter de nouvelles connexions et attend la fin des connexions actives (jusqu'à la date limite indiquée).
Lecture du corps JSON
type CreateUserReq struct {
Name string `json:"name"`
}
func createUser(w http.ResponseWriter, r *http.Request) {
var req CreateUserReq
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
// ... use req.Name
w.WriteHeader(http.StatusCreated)
}r.Body est un io.ReadCloser : le serveur le ferme automatiquement, mais json.NewDecoder ne lit pas au-delà du premier objet JSON (utile pour valider la saisie).
Exercices
Enregistrez le gestionnaire bonjour sur la route '/' en utilisant http.HandleFunc.
Solution disponible après 3 tentatives
Avvia le serveur su :8080 avec http.ListenAndServe et l'erreur est non nulle.
Solution disponible après 3 tentatives
Qu'est-ce que la société idiomatique d'un gestionnaire HTTP dans Go ?
func H(???) { ... }