Costruire Servizi HTTP in Produzione con Go

package main

import (
    "errors"
    "log/slog"
    "net/http"
)

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("GET /health", healthHandler)

    srv := &http.Server{
        Addr:    ":8080",
        Handler: mux,
    }

    slog.Info("avvio server", "addr", srv.Addr)
    if err := srv.ListenAndServe(); !errors.Is(err, http.ErrServerClosed) {
        slog.Error("errore server", "err", err)
    }
}

func healthHandler(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`{"status":"ok"}`))
}

package main

import "net/http"

func registerRoutes(mux *http.ServeMux) {
    mux.HandleFunc("GET /users", listUsersHandler)
    mux.HandleFunc("POST /users", createUserHandler)
    mux.HandleFunc("GET /users/{id}", getUserHandler)
    mux.HandleFunc("PUT /users/{id}", updateUserHandler)
    mux.HandleFunc("DELETE /users/{id}", deleteUserHandler)
}

func getUserHandler(w http.ResponseWriter, r *http.Request) {
    id := r.PathValue("id")
    // id è il valore catturato da {id} nel pattern
    w.Write([]byte("user id: " + id))
}

package main

import (
    "context"
    "log/slog"
    "net/http"
    "time"

    "github.com/google/uuid"
)

type contextKey string

const requestIDKey contextKey = "requestID"

// RequestID inietta un ID univoco nel contesto di ogni richiesta e nell'header di risposta.
func RequestID(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        id := uuid.New().String()
        ctx := context.WithValue(r.Context(), requestIDKey, id)
        w.Header().Set("X-Request-ID", id)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

// Logger registra metodo, path, status code e durata per ogni richiesta.
func Logger(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        rw := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}
        next.ServeHTTP(rw, r)
        slog.Info("request",
            "method", r.Method,
            "path", r.URL.Path,
            "status", rw.statusCode,
            "duration_ms", time.Since(start).Milliseconds(),
            "request_id", r.Context().Value(requestIDKey),
        )
    })
}

// responseWriter avvolge http.ResponseWriter per catturare lo status code.
type responseWriter struct {
    http.ResponseWriter
    statusCode int
}

func (rw *responseWriter) WriteHeader(code int) {
    rw.statusCode = code
    rw.ResponseWriter.WriteHeader(code)
}

// Chain applica il middleware in ordine: Chain(h, A, B, C) esegue A(B(C(h))).
func Chain(h http.Handler, middleware ...func(http.Handler) http.Handler) http.Handler {
    for i := len(middleware) - 1; i >= 0; i-- {
        h = middleware[i](h)
    }
    return h
}

handler := Chain(mux, RequestID, Logger)
srv := &http.Server{Addr: ":8080", Handler: handler}

srv := &http.Server{
    Addr:    ":8080",
    Handler: handler,

    // Tempo per leggere la richiesta completa incluso il body.
    ReadTimeout: 5 * time.Second,

    // Tempo per leggere solo gli header della richiesta. Protegge da attacchi con header lenti.
    // Deve essere minore o uguale a ReadTimeout.
    ReadHeaderTimeout: 2 * time.Second,

    // Tempo per scrivere la risposta completa. Contato dalla fine degli header della richiesta.
    WriteTimeout: 10 * time.Second,

    // Tempo in cui una connessione keep-alive inattiva rimane aperta.
    IdleTimeout: 120 * time.Second,
}

package main

import (
    "context"
    "errors"
    "log/slog"
    "net/http"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    mux := http.NewServeMux()
    registerRoutes(mux)
    handler := Chain(mux, RequestID, Logger)

    srv := &http.Server{
        Addr:              ":8080",
        Handler:           handler,
        ReadHeaderTimeout: 2 * time.Second,
        ReadTimeout:       5 * time.Second,
        WriteTimeout:      10 * time.Second,
        IdleTimeout:       120 * time.Second,
    }

    // ctx viene cancellato quando si riceve SIGINT o SIGTERM.
    ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
    defer stop()

    go func() {
        slog.Info("avvio server", "addr", srv.Addr)
        if err := srv.ListenAndServe(); !errors.Is(err, http.ErrServerClosed) {
            slog.Error("errore server", "err", err)
        }
    }()

    // Blocca fino al segnale.
    <-ctx.Done()
    slog.Info("segnale di shutdown ricevuto")

    // Dai alle richieste in volo fino a 30 secondi per completarsi.
    shutdownCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    if err := srv.Shutdown(shutdownCtx); err != nil {
        slog.Error("errore di shutdown", "err", err)
    }
    slog.Info("server fermato")
}

package main

import (
    "encoding/json"
    "net/http"
    "time"
)

type healthResponse struct {
    Status    string `json:"status"`
    Timestamp string `json:"timestamp"`
}

func healthHandler(w http.ResponseWriter, r *http.Request) {
    resp := healthResponse{
        Status:    "ok",
        Timestamp: time.Now().UTC().Format(time.RFC3339),
    }
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(resp)
}