Building production-grade HTTP servers in Go requires deliberate design choices. I’ve learned through experience that overlooking key patterns can lead to unstable systems. Let’s explore critical techniques that form the backbone of resilient Go services.

Timeouts are non-negotiable for production systems. I always configure three critical timeouts: ReadTimeout guards against slow clients sending headers, WriteTimeout limits response transmission duration, and IdleTimeout cleans up stale connections. These values depend on your specific workload. For API services, I typically start with 5 seconds for reads, 10 seconds for writes, and 60 seconds for idle connections.

server := &http.Server{
    Addr: ":8080",
    ReadTimeout: 5 * time.Second,
    WriteTimeout: 10 * time.Second,
    IdleTimeout: 60 * time.Second,
}

Graceful shutdown preserves request integrity during deployments. I implement signal handling to catch termination requests from orchestrators. The shutdown sequence gives active connections time to complete while preventing new requests. A context timeout acts as safety net - I usually allow 30 seconds for clean shutdown before forcing termination.

quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit

ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
if err := server.Shutdown(ctx); err != nil {
    log.Fatal("Forced shutdown:", err)
}

Middleware chains simplify cross-cutting concerns. I structure them as nested handlers that wrap core logic. This approach keeps authentication, logging, and recovery separated from business logic. The key is preserving the http.Handler interface contract throughout the chain.

func secureHeaders(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("X-XSS-Protection", "1; mode=block")
        w.Header().Set("X-Frame-Options", "deny")
        next.ServeHTTP(w, r)
    })
}

func main() {
    mux := http.NewServeMux()
    mux.Handle("/", secureHeaders(logMiddleware(authMiddleware(handler))))
}

Connection limiting prevents resource exhaustion. I use a buffered channel as semaphore to control concurrency. When the channel fills, additional requests receive immediate 503 responses. This simple pattern protects against traffic spikes.

var limiter = make(chan struct{}, 100)

func limitMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        select {
        case limiter <- struct{}{}:
            defer func() { <-limiter }()
            next.ServeHTTP(w, r)
        default:
            http.Error(w, "Service unavailable", http.StatusServiceUnavailable)
        }
    })
}

Security headers form your first defense layer. I automate their injection via middleware rather than manual per-handler setup. Critical headers include Content-Security-Policy, Strict-Transport-Security, and X-Content-Type-Options. These mitigate common web vulnerabilities without changing application logic.

Error standardization creates predictable failure modes. I define error types with HTTP status mappings and JSON structures. A central error handler wraps handlers, converting Go errors into consistent client responses. This pattern simplifies client error handling.

type appError struct {
    Status  int    `json:"status"`
    Message string `json:"message"`
}

func errorWrapper(h func(http.ResponseWriter, *http.Request) error) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        err := h(w, r)
        if err == nil {
            return
        }
        
        var ae *appError
        if !errors.As(err, &ae) {
            ae = &appError{Status: http.StatusInternalServerError, Message: "Internal error"}
        }
        
        w.WriteHeader(ae.Status)
        json.NewEncoder(w).Encode(ae)
    }
}

Health endpoints enable infrastructure automation. I implement separate /live and /ready endpoints. Liveness checks simply indicate process health, while readiness checks verify dependencies like databases. Kubernetes and load balancers use these for traffic management.

mux.HandleFunc("/live", func(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
})

mux.HandleFunc("/ready", func(w http.ResponseWriter, r *http.Request) {
    if db.Ping() != nil {
        http.Error(w, "DB unavailable", http.StatusServiceUnavailable)
        return
    }
    w.WriteHeader(http.StatusOK)
})

Context propagation maintains request-scoped data. I pass context through middleware and handlers for distributed tracing and cancellation. When making downstream calls, I propagate the original request context to maintain trace coherence and respect timeout hierarchies.

func handler(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    
    result, err := fetchFromService(ctx, "https://backend/api")
    if err != nil {
        handleError(w, err)
        return
    }
    // Process result
}

func fetchFromService(ctx context.Context, url string) ([]byte, error) {
    req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
    resp, err := http.DefaultClient.Do(req)
    // Handle response
}

These patterns form a robust foundation for Go HTTP services. Each addresses specific production concerns while complementing others. Implement them systematically to create systems that withstand real-world operational pressures while maintaining developer clarity and maintainability.