Go: Production Code Snippets

Go snippets: HTTP servers, worker pools, rate limiting, database configuration.

Python JavaScript TypeScript Java C# C++ Go PHP Rust SQL

On this page:

31. Go: HTTP Server with Graceful Shutdown 32. Go: Channel-Based Worker Pool 33. Go: Token Bucket Rate Limiter 34. Go: Authentication Middleware 35. Go: SQL Connection Pool Configuration

31. Go: HTTP Server with Graceful Shutdown

Handling requests with context.Context propagation and safe shutdown.

package main

import (
    "net/http"
)

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        w.Write([]byte("OK"))
    })
    http.ListenAndServe(":8080", mux)
}

When to use

The foundation of any HTTP service in Go — a starting point for building an API or microservice.

Common pitfalls

This example doesn't handle actual graceful shutdown (catching the SIGTERM signal) — in production you need to add signal handling and http.Server.Shutdown().

32. Go: Channel-Based Worker Pool

Distributing tasks across a fixed number of concurrent workers.

package main

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        results <- j * 2
    }
}

func startPool() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }
}

When to use

Use it when you have many independent tasks and want to control the number of parallel workers instead of spawning unbounded goroutines.

Common pitfalls

The results channel must be read from, otherwise workers will block on write once the buffer fills up (a deadlock).

33. Go: Token Bucket Rate Limiter

Implementation of a network traffic throughput algorithm.

package main

import "golang.org/x/time/rate"

var limiter = rate.NewLimiter(1, 5)

func checkLimit() bool {
    return limiter.Allow()
}

When to use

Useful for limiting how often an external API or your own endpoints are called.

Common pitfalls

A limiter defined as a global variable shares state across all requests — per-user limits require a separate instance for each client.

34. Go: Authentication Middleware

Checking tokens and injecting session data into the context.

package main

import "net/http"

func AuthMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if token != "Bearer secret" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        next.ServeHTTP(w, r)
    })
}

When to use

A basic pattern for protecting endpoints from unauthorized access in simple APIs.

Common pitfalls

Comparing tokens with plain == is vulnerable to timing attacks — in production use a constant-time comparison function, e.g. subtle.ConstantTimeCompare.

35. Go: SQL Connection Pool Configuration

Configuring optimal database connection limits.

package main

import (
    "database/sql"
    "time"
)

func configurePool(db *sql.DB) {
    db.SetMaxOpenConns(25)
    db.SetMaxIdleConns(5)
    db.SetConnMaxLifetime(5 * time.Minute)
}

When to use

Worth setting for every database connection — Go's defaults tend to be too permissive for production load.

Common pitfalls

Too high a SetMaxOpenConns can overload the database during a traffic spike — the value should match the database's own limits.