Web Development

Why Web Development Matters

When building a modern web application that needs to serve millions of users, process real-time data, and maintain 99.9% uptime, your choice of web framework and architecture determines whether your application can scale, handle concurrent users efficiently, and respond quickly under load. Go's web development capabilities are designed for exactly these challenges.

Real-World Impact:

• Netflix streams billions of hours of content using Go HTTP servers
• Uber handles millions of ride requests per day with Go microservices
• Dropbox serves petabytes of file storage through Go APIs
• Cloudflare processes billions of HTTP requests daily using Go

Why Go Excels at Web Development:

• Millions of Connections: Single Go server can handle millions of concurrent connections
• Sub-millisecond Latency: Compiled performance + efficient goroutine scheduling
• Minimal Memory: ~2KB per connection vs ~100KB in Node.js
• Built-in HTTP/2: No external dependencies for modern protocols
• Production Ready: Battle-tested at Google scale for over a decade

Learning Objectives

After completing this article, you will be able to:

✅ Build HTTP Servers - Create robust servers from scratch using only standard library
✅ Handle High Concurrency - Serve thousands of simultaneous connections efficiently
✅ Design REST APIs - Build scalable APIs with proper routing and middleware
✅ Process Forms & JSON - Handle user input and data serialization
✅ Implement Security - Add authentication, CORS, and security headers
✅ Master Performance - Optimize for throughput and low latency
✅ Deploy with Confidence - Understand production patterns and deployment strategies

Core Concepts - Go's Web Architecture

Go approaches web development differently from other languages. Understanding this foundation is crucial for building efficient applications.

The Goroutine Advantage

Unlike traditional thread-per-request models, Go uses lightweight goroutines:

Traditional Model:
┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│ Thread 1    │    │ Thread 2    │    │ Thread 3    │  ← Heavy, ~1MB each
│ 2KB Stack   │    │ 2KB Stack   │    │ 2KB Stack   │
└─────────────┘    └─────────────┘    └─────────────┘

Go Model:
┌──────┐  ┌──────┐  ┌──────┐  ┌──────┐  ┌──────┐
│ Go 1 │  │ Go 2 │  │ Go 3 │  │ Go 4 │  │ Go 5 │  ← Lightweight, ~2KB each
│2KB Stk│  │2KB Stk│  │2KB Stk│  │2KB Stk│  │2KB Stk│
└──────┘  └──────┘  └──────┘  └──────┘  └──────┘

Result: 1000x more concurrent connections with same memory!

Key Package Architecture

Go's web development centers around net/http with complementary packages:

Request Processing Flow

1. Client sends HTTP request
       ↓
2. Connection accepted
       ↓
3. Router matches URL pattern
       ↓
4. Middleware chain executes
       ↓
5. Handler processes request
       ↓
6. Response written and sent
       ↓
7. Connection closed or kept alive

Understanding HTTP Handlers

Every HTTP server in Go is built on the concept of handlers - functions that process requests and generate responses.

The Handler Interface

At the core of Go's HTTP package is the http.Handler interface:

1type Handler interface {
2    ServeHTTP(ResponseWriter, *Request)
3}

Two Ways to Create Handlers:

1. Handler Functions - Simple functions for basic routes
2. Handler Types - Custom types implementing ServeHTTP for stateful handlers

Handler Functions vs Handler Types

 1// run
 2package main
 3
 4import (
 5    "fmt"
 6    "net/http"
 7    "sync/atomic"
 8)
 9
10// Pattern 1: Handler Function - Stateless, simple
11func simpleHandler(w http.ResponseWriter, r *http.Request) {
12    fmt.Fprintf(w, "Hello from handler function!\n")
13}
14
15// Pattern 2: Handler Type - Stateful, reusable
16type CounterHandler struct {
17    count atomic.Int64
18}
19
20func (h *CounterHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
21    count := h.count.Add(1)
22    fmt.Fprintf(w, "Request count: %d\n", count)
23}
24
25func main() {
26    // Register handler function
27    http.HandleFunc("/simple", simpleHandler)
28
29    // Register handler type
30    counter := &CounterHandler{}
31    http.Handle("/counter", counter)
32
33    fmt.Println("Server with both handler patterns on :8080...")
34    http.ListenAndServe(":8080", nil)
35}

When to Use Each Pattern:

HTTP Request Anatomy

Understanding the *http.Request structure is essential for processing web requests effectively.

Request Components Breakdown

 1// run
 2package main
 3
 4import (
 5    "fmt"
 6    "io"
 7    "net/http"
 8    "strings"
 9)
10
11func requestAnalyzer(w http.ResponseWriter, r *http.Request) {
12    w.Header().Set("Content-Type", "text/plain")
13
14    fmt.Fprintf(w, "Request Analysis\n")
15    fmt.Fprintf(w, "================\n\n")
16
17    // HTTP Method
18    fmt.Fprintf(w, "Method: %s\n", r.Method)
19
20    // URL Components
21    fmt.Fprintf(w, "\nURL Analysis:\n")
22    fmt.Fprintf(w, "  Full URL: %s\n", r.URL.String())
23    fmt.Fprintf(w, "  Path: %s\n", r.URL.Path)
24    fmt.Fprintf(w, "  Query String: %s\n", r.URL.RawQuery)
25
26    // Query Parameters
27    if len(r.URL.Query()) > 0 {
28        fmt.Fprintf(w, "\nQuery Parameters:\n")
29        for key, values := range r.URL.Query() {
30            for _, value := range values {
31                fmt.Fprintf(w, "  %s = %s\n", key, value)
32            }
33        }
34    }
35
36    // Headers
37    fmt.Fprintf(w, "\nHeaders:\n")
38    for name, values := range r.Header {
39        for _, value := range values {
40            fmt.Fprintf(w, "  %s: %s\n", name, value)
41        }
42    }
43
44    // Body (for POST/PUT requests)
45    if r.Method == "POST" || r.Method == "PUT" {
46        body, err := io.ReadAll(r.Body)
47        if err == nil && len(body) > 0 {
48            fmt.Fprintf(w, "\nRequest Body:\n")
49            fmt.Fprintf(w, "  Length: %d bytes\n", len(body))
50            fmt.Fprintf(w, "  Content: %s\n", string(body))
51        }
52    }
53
54    // Client Information
55    fmt.Fprintf(w, "\nClient Info:\n")
56    fmt.Fprintf(w, "  Remote Address: %s\n", r.RemoteAddr)
57    fmt.Fprintf(w, "  Protocol: %s\n", r.Proto)
58
59    // Cookies
60    if len(r.Cookies()) > 0 {
61        fmt.Fprintf(w, "\nCookies:\n")
62        for _, cookie := range r.Cookies() {
63            fmt.Fprintf(w, "  %s = %s\n", cookie.Name, cookie.Value)
64        }
65    }
66}
67
68func main() {
69    http.HandleFunc("/analyze", requestAnalyzer)
70
71    fmt.Println("Request Analyzer Server on :8080")
72    fmt.Println("Try: curl 'http://localhost:8080/analyze?user=alice&age=30' -H 'X-Custom: value'")
73    http.ListenAndServe(":8080", nil)
74}

Reading Request Bodies Safely

Different content types require different handling approaches:

  1// run
  2package main
  3
  4import (
  5    "encoding/json"
  6    "fmt"
  7    "io"
  8    "net/http"
  9    "net/url"
 10)
 11
 12type User struct {
 13    Name  string `json:"name"`
 14    Email string `json:"email"`
 15    Age   int    `json:"age"`
 16}
 17
 18func handleJSON(w http.ResponseWriter, r *http.Request) {
 19    if r.Method != "POST" {
 20        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
 21        return
 22    }
 23
 24    // Check Content-Type
 25    if r.Header.Get("Content-Type") != "application/json" {
 26        http.Error(w, "Content-Type must be application/json", http.StatusBadRequest)
 27        return
 28    }
 29
 30    // Limit request body size (10MB max)
 31    r.Body = http.MaxBytesReader(w, r.Body, 10<<20)
 32
 33    var user User
 34    decoder := json.NewDecoder(r.Body)
 35    decoder.DisallowUnknownFields() // Reject unknown fields
 36
 37    if err := decoder.Decode(&user); err != nil {
 38        http.Error(w, fmt.Sprintf("Invalid JSON: %v", err), http.StatusBadRequest)
 39        return
 40    }
 41
 42    // Validate data
 43    if user.Name == "" || user.Email == "" {
 44        http.Error(w, "Name and email are required", http.StatusBadRequest)
 45        return
 46    }
 47
 48    // Process user...
 49    w.Header().Set("Content-Type", "application/json")
 50    json.NewEncoder(w).Encode(map[string]interface{}{
 51        "message": "User created successfully",
 52        "user":    user,
 53    })
 54}
 55
 56func handleForm(w http.ResponseWriter, r *http.Request) {
 57    if r.Method != "POST" {
 58        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
 59        return
 60    }
 61
 62    // Parse form data (automatically handles application/x-www-form-urlencoded)
 63    if err := r.ParseForm(); err != nil {
 64        http.Error(w, "Failed to parse form", http.StatusBadRequest)
 65        return
 66    }
 67
 68    name := r.FormValue("name")
 69    email := r.FormValue("email")
 70
 71    if name == "" || email == "" {
 72        http.Error(w, "Name and email are required", http.StatusBadRequest)
 73        return
 74    }
 75
 76    fmt.Fprintf(w, "Form submitted: name=%s, email=%s\n", name, email)
 77}
 78
 79func handleMultipart(w http.ResponseWriter, r *http.Request) {
 80    if r.Method != "POST" {
 81        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
 82        return
 83    }
 84
 85    // Parse multipart form (for file uploads)
 86    // Limit to 32MB in memory, rest spills to disk
 87    if err := r.ParseMultipartForm(32 << 20); err != nil {
 88        http.Error(w, "Failed to parse multipart form", http.StatusBadRequest)
 89        return
 90    }
 91
 92    // Access form fields
 93    name := r.FormValue("name")
 94
 95    // Access uploaded files
 96    file, header, err := r.FormFile("file")
 97    if err != nil {
 98        http.Error(w, "File upload failed", http.StatusBadRequest)
 99        return
100    }
101    defer file.Close()
102
103    // Read file content
104    content, _ := io.ReadAll(file)
105
106    fmt.Fprintf(w, "File uploaded: %s (%d bytes)\n", header.Filename, len(content))
107    fmt.Fprintf(w, "Name field: %s\n", name)
108}
109
110func main() {
111    http.HandleFunc("/api/users", handleJSON)
112    http.HandleFunc("/form", handleForm)
113    http.HandleFunc("/upload", handleMultipart)
114
115    fmt.Println("Body Parser Server on :8080")
116    fmt.Println("Endpoints:")
117    fmt.Println("  POST /api/users - JSON payload")
118    fmt.Println("  POST /form      - Form data")
119    fmt.Println("  POST /upload    - Multipart file upload")
120    http.ListenAndServe(":8080", nil)
121}

HTTP Response Patterns

The http.ResponseWriter interface provides methods for building responses. Understanding response patterns is crucial for API design.

Response Status Codes

  1// run
  2package main
  3
  4import (
  5    "encoding/json"
  6    "fmt"
  7    "net/http"
  8)
  9
 10type ErrorResponse struct {
 11    Error   string `json:"error"`
 12    Code    int    `json:"code"`
 13    Message string `json:"message"`
 14}
 15
 16func sendJSON(w http.ResponseWriter, status int, data interface{}) {
 17    w.Header().Set("Content-Type", "application/json")
 18    w.WriteHeader(status)
 19    json.NewEncoder(w).Encode(data)
 20}
 21
 22func sendError(w http.ResponseWriter, status int, message string) {
 23    sendJSON(w, status, ErrorResponse{
 24        Error:   http.StatusText(status),
 25        Code:    status,
 26        Message: message,
 27    })
 28}
 29
 30// Success Responses
 31func handleSuccess(w http.ResponseWriter, r *http.Request) {
 32    // 200 OK - Standard success response
 33    sendJSON(w, http.StatusOK, map[string]string{
 34        "message": "Operation successful",
 35    })
 36}
 37
 38func handleCreated(w http.ResponseWriter, r *http.Request) {
 39    // 201 Created - Resource created successfully
 40    w.Header().Set("Location", "/api/users/123")
 41    sendJSON(w, http.StatusCreated, map[string]interface{}{
 42        "id":      123,
 43        "message": "User created",
 44    })
 45}
 46
 47func handleNoContent(w http.ResponseWriter, r *http.Request) {
 48    // 204 No Content - Success with no response body
 49    w.WriteHeader(http.StatusNoContent)
 50}
 51
 52// Client Error Responses
 53func handleBadRequest(w http.ResponseWriter, r *http.Request) {
 54    // 400 Bad Request - Invalid client input
 55    sendError(w, http.StatusBadRequest, "Invalid request format")
 56}
 57
 58func handleUnauthorized(w http.ResponseWriter, r *http.Request) {
 59    // 401 Unauthorized - Authentication required
 60    w.Header().Set("WWW-Authenticate", "Bearer")
 61    sendError(w, http.StatusUnauthorized, "Authentication credentials required")
 62}
 63
 64func handleForbidden(w http.ResponseWriter, r *http.Request) {
 65    // 403 Forbidden - Authenticated but not authorized
 66    sendError(w, http.StatusForbidden, "You don't have permission to access this resource")
 67}
 68
 69func handleNotFound(w http.ResponseWriter, r *http.Request) {
 70    // 404 Not Found - Resource doesn't exist
 71    sendError(w, http.StatusNotFound, "The requested resource was not found")
 72}
 73
 74// Server Error Responses
 75func handleServerError(w http.ResponseWriter, r *http.Request) {
 76    // 500 Internal Server Error - Unexpected server problem
 77    sendError(w, http.StatusInternalServerError, "An unexpected error occurred")
 78}
 79
 80func handleServiceUnavailable(w http.ResponseWriter, r *http.Request) {
 81    // 503 Service Unavailable - Temporary unavailability
 82    w.Header().Set("Retry-After", "60")
 83    sendError(w, http.StatusServiceUnavailable, "Service temporarily unavailable")
 84}
 85
 86func main() {
 87    // Success responses
 88    http.HandleFunc("/success", handleSuccess)
 89    http.HandleFunc("/created", handleCreated)
 90    http.HandleFunc("/nocontent", handleNoContent)
 91
 92    // Client errors
 93    http.HandleFunc("/badrequest", handleBadRequest)
 94    http.HandleFunc("/unauthorized", handleUnauthorized)
 95    http.HandleFunc("/forbidden", handleForbidden)
 96    http.HandleFunc("/notfound", handleNotFound)
 97
 98    // Server errors
 99    http.HandleFunc("/error", handleServerError)
100    http.HandleFunc("/unavailable", handleServiceUnavailable)
101
102    fmt.Println("HTTP Status Code Examples on :8080")
103    http.ListenAndServe(":8080", nil)
104}

Response Headers and Content Types

 1// run
 2package main
 3
 4import (
 5    "encoding/json"
 6    "encoding/xml"
 7    "fmt"
 8    "net/http"
 9)
10
11type Product struct {
12    XMLName xml.Name `xml:"product" json:"-"`
13    ID      int      `xml:"id" json:"id"`
14    Name    string   `xml:"name" json:"name"`
15    Price   float64  `xml:"price" json:"price"`
16}
17
18func negotiateContent(w http.ResponseWriter, r *http.Request) {
19    product := Product{
20        ID:    1,
21        Name:  "Laptop",
22        Price: 999.99,
23    }
24
25    // Content negotiation based on Accept header
26    accept := r.Header.Get("Accept")
27
28    switch accept {
29    case "application/xml":
30        w.Header().Set("Content-Type", "application/xml")
31        w.WriteHeader(http.StatusOK)
32        xml.NewEncoder(w).Encode(product)
33
34    case "application/json":
35        fallthrough
36    default:
37        w.Header().Set("Content-Type", "application/json")
38        w.WriteHeader(http.StatusOK)
39        json.NewEncoder(w).Encode(product)
40    }
41}
42
43func setCachingHeaders(w http.ResponseWriter, r *http.Request) {
44    // Cache static resources aggressively
45    w.Header().Set("Cache-Control", "public, max-age=31536000, immutable")
46    w.Header().Set("Expires", "Wed, 01 Jan 2025 00:00:00 GMT")
47
48    fmt.Fprintf(w, "This response can be cached for 1 year")
49}
50
51func setNoCacheHeaders(w http.ResponseWriter, r *http.Request) {
52    // Don't cache dynamic content
53    w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
54    w.Header().Set("Pragma", "no-cache")
55    w.Header().Set("Expires", "0")
56
57    fmt.Fprintf(w, "This response should never be cached")
58}
59
60func setCORSHeaders(w http.ResponseWriter, r *http.Request) {
61    // Enable cross-origin requests
62    w.Header().Set("Access-Control-Allow-Origin", "*")
63    w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
64    w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
65    w.Header().Set("Access-Control-Max-Age", "3600")
66
67    if r.Method == "OPTIONS" {
68        w.WriteHeader(http.StatusOK)
69        return
70    }
71
72    fmt.Fprintf(w, "CORS headers set for cross-origin access")
73}
74
75func setSecurityHeaders(w http.ResponseWriter, r *http.Request) {
76    // Security best practices
77    w.Header().Set("X-Content-Type-Options", "nosniff")
78    w.Header().Set("X-Frame-Options", "DENY")
79    w.Header().Set("X-XSS-Protection", "1; mode=block")
80    w.Header().Set("Content-Security-Policy", "default-src 'self'")
81    w.Header().Set("Strict-Transport-Security", "max-age=31536000; includeSubDomains")
82
83    fmt.Fprintf(w, "Security headers configured")
84}
85
86func main() {
87    http.HandleFunc("/product", negotiateContent)
88    http.HandleFunc("/cache", setCachingHeaders)
89    http.HandleFunc("/nocache", setNoCacheHeaders)
90    http.HandleFunc("/cors", setCORSHeaders)
91    http.HandleFunc("/security", setSecurityHeaders)
92
93    fmt.Println("Response Headers Demo on :8080")
94    fmt.Println("Try different Accept headers:")
95    fmt.Println("  curl -H 'Accept: application/json' http://localhost:8080/product")
96    fmt.Println("  curl -H 'Accept: application/xml' http://localhost:8080/product")
97    http.ListenAndServe(":8080", nil)
98}

Advanced Routing Patterns

The standard library's http.ServeMux provides basic routing. For production applications, understanding routing patterns is essential.

URL Pattern Matching

 1// run
 2package main
 3
 4import (
 5    "fmt"
 6    "net/http"
 7    "strings"
 8)
 9
10// Custom router with parameter extraction
11type Router struct {
12    routes map[string]http.HandlerFunc
13}
14
15func NewRouter() *Router {
16    return &Router{
17        routes: make(map[string]http.HandlerFunc),
18    }
19}
20
21func (router *Router) Handle(pattern string, handler http.HandlerFunc) {
22    router.routes[pattern] = handler
23}
24
25func (router *Router) ServeHTTP(w http.ResponseWriter, r *http.Request) {
26    path := r.URL.Path
27
28    // Exact match first
29    if handler, ok := router.routes[path]; ok {
30        handler(w, r)
31        return
32    }
33
34    // Pattern matching with parameters
35    for pattern, handler := range router.routes {
36        if params := matchPattern(pattern, path); params != nil {
37            // Store params in context (simplified here)
38            handler(w, r)
39            return
40        }
41    }
42
43    http.NotFound(w, r)
44}
45
46func matchPattern(pattern, path string) map[string]string {
47    patternParts := strings.Split(strings.Trim(pattern, "/"), "/")
48    pathParts := strings.Split(strings.Trim(path, "/"), "/")
49
50    if len(patternParts) != len(pathParts) {
51        return nil
52    }
53
54    params := make(map[string]string)
55
56    for i, part := range patternParts {
57        if strings.HasPrefix(part, ":") {
58            // This is a parameter
59            paramName := part[1:]
60            params[paramName] = pathParts[i]
61        } else if part != pathParts[i] {
62            // Not a match
63            return nil
64        }
65    }
66
67    return params
68}
69
70func main() {
71    router := NewRouter()
72
73    // Static routes
74    router.Handle("/", func(w http.ResponseWriter, r *http.Request) {
75        fmt.Fprintf(w, "Home page\n")
76    })
77
78    router.Handle("/about", func(w http.ResponseWriter, r *http.Request) {
79        fmt.Fprintf(w, "About page\n")
80    })
81
82    // Dynamic routes (pattern matching)
83    router.Handle("/users/:id", func(w http.ResponseWriter, r *http.Request) {
84        // In a real implementation, extract ID from context
85        fmt.Fprintf(w, "User profile\n")
86    })
87
88    router.Handle("/posts/:id/comments/:commentId", func(w http.ResponseWriter, r *http.Request) {
89        fmt.Fprintf(w, "Post comment detail\n")
90    })
91
92    fmt.Println("Custom Router on :8080")
93    fmt.Println("Try:")
94    fmt.Println("  /")
95    fmt.Println("  /about")
96    fmt.Println("  /users/123")
97    fmt.Println("  /posts/456/comments/789")
98    http.ListenAndServe(":8080", router)
99}

Method-Based Routing

  1// run
  2package main
  3
  4import (
  5    "encoding/json"
  6    "fmt"
  7    "net/http"
  8)
  9
 10// MethodRouter routes based on HTTP method
 11type MethodRouter struct {
 12    handlers map[string]http.HandlerFunc
 13}
 14
 15func NewMethodRouter() *MethodRouter {
 16    return &MethodRouter{
 17        handlers: make(map[string]http.HandlerFunc),
 18    }
 19}
 20
 21func (mr *MethodRouter) GET(handler http.HandlerFunc) {
 22    mr.handlers["GET"] = handler
 23}
 24
 25func (mr *MethodRouter) POST(handler http.HandlerFunc) {
 26    mr.handlers["POST"] = handler
 27}
 28
 29func (mr *MethodRouter) PUT(handler http.HandlerFunc) {
 30    mr.handlers["PUT"] = handler
 31}
 32
 33func (mr *MethodRouter) DELETE(handler http.HandlerFunc) {
 34    mr.handlers["DELETE"] = handler
 35}
 36
 37func (mr *MethodRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 38    handler, ok := mr.handlers[r.Method]
 39    if !ok {
 40        w.Header().Set("Allow", mr.allowedMethods())
 41        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
 42        return
 43    }
 44
 45    handler(w, r)
 46}
 47
 48func (mr *MethodRouter) allowedMethods() string {
 49    methods := ""
 50    for method := range mr.handlers {
 51        if methods != "" {
 52            methods += ", "
 53        }
 54        methods += method
 55    }
 56    return methods
 57}
 58
 59func main() {
 60    // RESTful user endpoint with method routing
 61    userRouter := NewMethodRouter()
 62
 63    userRouter.GET(func(w http.ResponseWriter, r *http.Request) {
 64        users := []map[string]interface{}{
 65            {"id": 1, "name": "Alice"},
 66            {"id": 2, "name": "Bob"},
 67        }
 68        w.Header().Set("Content-Type", "application/json")
 69        json.NewEncoder(w).Encode(users)
 70    })
 71
 72    userRouter.POST(func(w http.ResponseWriter, r *http.Request) {
 73        var user map[string]interface{}
 74        json.NewDecoder(r.Body).Decode(&user)
 75        user["id"] = 3
 76
 77        w.Header().Set("Content-Type", "application/json")
 78        w.WriteHeader(http.StatusCreated)
 79        json.NewEncoder(w).Encode(user)
 80    })
 81
 82    userRouter.PUT(func(w http.ResponseWriter, r *http.Request) {
 83        var user map[string]interface{}
 84        json.NewDecoder(r.Body).Decode(&user)
 85
 86        w.Header().Set("Content-Type", "application/json")
 87        json.NewEncoder(w).Encode(user)
 88    })
 89
 90    userRouter.DELETE(func(w http.ResponseWriter, r *http.Request) {
 91        w.WriteHeader(http.StatusNoContent)
 92    })
 93
 94    http.Handle("/api/users", userRouter)
 95
 96    fmt.Println("Method Router on :8080")
 97    fmt.Println("Try:")
 98    fmt.Println("  GET    /api/users - List users")
 99    fmt.Println("  POST   /api/users - Create user")
100    fmt.Println("  PUT    /api/users - Update user")
101    fmt.Println("  DELETE /api/users - Delete user")
102    http.ListenAndServe(":8080", nil)
103}

Server Configuration and Timeouts

Production HTTP servers require proper timeout configuration to prevent resource exhaustion.

Comprehensive Server Configuration

 1// run
 2package main
 3
 4import (
 5    "context"
 6    "fmt"
 7    "log"
 8    "net/http"
 9    "os"
10    "os/signal"
11    "syscall"
12    "time"
13)
14
15func createProductionServer() *http.Server {
16    mux := http.NewServeMux()
17
18    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
19        fmt.Fprintf(w, "Production server responding\n")
20    })
21
22    mux.HandleFunc("/slow", func(w http.ResponseWriter, r *http.Request) {
23        // Simulate slow operation
24        time.Sleep(3 * time.Second)
25        fmt.Fprintf(w, "Slow operation completed\n")
26    })
27
28    server := &http.Server{
29        Addr:    ":8080",
30        Handler: mux,
31
32        // Timeouts prevent resource exhaustion
33        ReadTimeout:       10 * time.Second, // Time to read request headers + body
34        ReadHeaderTimeout: 5 * time.Second,  // Time to read request headers
35        WriteTimeout:      10 * time.Second, // Time to write response
36        IdleTimeout:       120 * time.Second, // Time before closing idle connections
37
38        // Limits
39        MaxHeaderBytes: 1 << 20, // 1 MB max header size
40
41        // Error logging
42        ErrorLog: log.New(os.Stderr, "HTTP: ", log.LstdFlags),
43    }
44
45    return server
46}
47
48func main() {
49    server := createProductionServer()
50
51    // Start server in goroutine
52    go func() {
53        fmt.Printf("Production server starting on %s\n", server.Addr)
54        fmt.Println("Timeout configuration:")
55        fmt.Println("  ReadTimeout:       10s")
56        fmt.Println("  WriteTimeout:      10s")
57        fmt.Println("  IdleTimeout:       120s")
58        fmt.Println("  ReadHeaderTimeout: 5s")
59
60        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
61            log.Fatalf("Server failed: %v", err)
62        }
63    }()
64
65    // Graceful shutdown
66    quit := make(chan os.Signal, 1)
67    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
68    <-quit
69
70    fmt.Println("\nShutting down server...")
71
72    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
73    defer cancel()
74
75    if err := server.Shutdown(ctx); err != nil {
76        log.Fatalf("Server forced to shutdown: %v", err)
77    }
78
79    fmt.Println("Server gracefully stopped")
80}

Connection Pooling for HTTP Clients

 1// run
 2package main
 3
 4import (
 5    "fmt"
 6    "io"
 7    "net"
 8    "net/http"
 9    "time"
10)
11
12func createOptimizedClient() *http.Client {
13    transport := &http.Transport{
14        // Connection pooling
15        MaxIdleConns:        100,              // Maximum idle connections across all hosts
16        MaxIdleConnsPerHost: 10,               // Maximum idle connections per host
17        MaxConnsPerHost:     100,              // Maximum connections per host
18
19        // Timeouts
20        IdleConnTimeout:       90 * time.Second,  // Time before closing idle connections
21        TLSHandshakeTimeout:   10 * time.Second,  // TLS handshake timeout
22        ResponseHeaderTimeout: 10 * time.Second,  // Time to receive response headers
23        ExpectContinueTimeout: 1 * time.Second,   // Time to wait for 100-Continue
24
25        // Connection settings
26        DisableKeepAlives:   false,            // Enable keep-alive
27        DisableCompression:  false,            // Enable gzip compression
28        ForceAttemptHTTP2:   true,             // Try HTTP/2
29
30        // Dialer configuration
31        DialContext: (&net.Dialer{
32            Timeout:   30 * time.Second,       // Connection timeout
33            KeepAlive: 30 * time.Second,       // Keep-alive period
34        }).DialContext,
35    }
36
37    client := &http.Client{
38        Transport: transport,
39        Timeout:   30 * time.Second,           // Total request timeout
40    }
41
42    return client
43}
44
45func main() {
46    client := createOptimizedClient()
47
48    // Make multiple requests to demonstrate connection reuse
49    urls := []string{
50        "https://httpbin.org/get",
51        "https://httpbin.org/headers",
52        "https://httpbin.org/user-agent",
53    }
54
55    fmt.Println("Making requests with optimized HTTP client...")
56    fmt.Println("Connection pooling enabled for better performance\n")
57
58    for i, url := range urls {
59        start := time.Now()
60
61        resp, err := client.Get(url)
62        if err != nil {
63            fmt.Printf("Request %d failed: %v\n", i+1, err)
64            continue
65        }
66
67        // Read and discard body
68        io.Copy(io.Discard, resp.Body)
69        resp.Body.Close()
70
71        duration := time.Since(start)
72        fmt.Printf("Request %d: %s (Status: %d, Duration: %v)\n",
73            i+1, url, resp.StatusCode, duration)
74    }
75
76    fmt.Println("\nConnection pooling configuration:")
77    fmt.Println("  MaxIdleConns:        100")
78    fmt.Println("  MaxIdleConnsPerHost: 10")
79    fmt.Println("  IdleConnTimeout:     90s")
80}

Your First HTTP Server

Let's start with the simplest possible web server. In just 8 lines of code, you'll have a working HTTP server that can handle requests from any web browser or HTTP client.

💡 Key Takeaway: Go's philosophy is "batteries included" - you don't need external frameworks or libraries to build production-ready web services. Everything you need is already in the standard library.

 1// run
 2package main
 3
 4import (
 5    "fmt"
 6    "net/http"
 7)
 8
 9func main() {
10    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
11        fmt.Fprintf(w, "Hello, World!")
12    })
13
14    fmt.Println("Server starting on :8080...")
15    http.ListenAndServe(":8080", nil)
16}

⚠️ Important: The server will run forever until you stop it. This is normal for web services - they're designed to run continuously and handle requests as they come in.

Visit http://localhost:8080 to see your server in action! You'll see "Hello, World!" in your browser.

Cross-References from Other Articles

This article serves as the canonical reference for basic HTTP patterns. Other articles in this tutorial reference this content for:

• Basic HTTP server setup - Hello World, routing, handlers
• Request/response handling - JSON, forms, headers, status codes
• HTTP clients - Making requests, handling responses
• Middleware patterns - Logging, authentication, CORS
• REST API development - Complete RESTful patterns
• Best practices - Error handling, timeouts, security

If you're looking for basic HTTP patterns that are referenced from other articles like cloud-native services, migration guides, or ecosystem tools, you're in the right place!

Advanced Topics and Related Content

For domain-specific implementations, see:

• Real-World Applications - Web frameworks, GraphQL servers, microservices
• Cloud Native Go - Kubernetes deployments, Docker containers, serverless functions
• Testing & Quality - Web API testing, contract testing, load testing

Learning Path

1. Start here - Master basic HTTP patterns in this comprehensive guide
2. Explore frameworks - See Real-World Applications for framework-specific patterns
3. Deploy to cloud - Check Cloud Native Go for production deployment
4. Ensure quality - Review Testing & Quality for API testing strategies

💡 Note: Other articles in this tutorial reference this guide for basic HTTP patterns. If you arrived here from another article looking for fundamental HTTP concepts, you're in the right place!

Practice Exercises

Exercise 1: Basic HTTP Server with Routes

Learning Objectives: Create your first HTTP server, implement basic routing with different endpoints, and handle HTTP requests and responses using Go's net/http package.

Difficulty: ⭐⭐ Beginner
Time Estimate: 20 minutes

Build a simple HTTP server that serves different content at multiple routes. This exercise teaches you the fundamentals of HTTP server creation, request routing, and response writing in Go. You'll learn how to set up HTTP handlers, work with request/response objects, and understand the basic structure of web applications.

Real-World Context: Every web application starts with basic routing. Whether you're building a REST API, a web server, or a microservice, understanding how to create HTTP endpoints and route requests is fundamental. This pattern is used in all web frameworks and is the foundation for building any web-based service or API.

 1// run
 2package main
 3
 4import (
 5    "fmt"
 6    "net/http"
 7    "time"
 8)
 9
10func homeHandler(w http.ResponseWriter, r *http.Request) {
11    if r.URL.Path != "/" {
12        http.NotFound(w, r)
13        return
14    }
15
16    fmt.Fprintf(w, `
17        <html>
18        <head><title>Home Page</title></head>
19        <body>
20            <h1>Welcome to My Web Server!</h1>
21            <p>This is the home page.</p>
22            <p><a href="/about">About Us</a> | <a href="/api/status">API Status</a></p>
23        </body>
24        </html>
25    `)
26}
27
28func aboutHandler(w http.ResponseWriter, r *http.Request) {
29    fmt.Fprintf(w, `
30        <html>
31        <head><title>About Us</title></head>
32        <body>
33            <h1>About This Server</h1>
34            <p>This is a simple web server built with Go's net/http package.</p>
35            <p><a href="/">Back to Home</a></p>
36        </body>
37        </html>
38    `)
39}
40
41func apiStatusHandler(w http.ResponseWriter, r *http.Request) {
42    w.Header().Set("Content-Type", "application/json")
43    fmt.Fprintf(w, `{
44        "status": "healthy",
45        "timestamp": "%s",
46        "uptime": "running",
47        "version": "1.0.0"
48    }`, time.Now().Format(time.RFC3339))
49}
50
51func main() {
52    // Register handlers for different routes
53    http.HandleFunc("/", homeHandler)
54    http.HandleFunc("/about", aboutHandler)
55    http.HandleFunc("/api/status", apiStatusHandler)
56
57    // Add a custom 404 handler
58    http.NotFoundHandler()
59
60    fmt.Println("Server starting on :8080...")
61    fmt.Println("Available routes:")
62    fmt.Println("  /           - Home page")
63    fmt.Println("  /about      - About page")
64    fmt.Println("  /api/status - API status")
65
66    err := http.ListenAndServe(":8080", nil)
67    if err != nil {
68        fmt.Println("Server error:", err)
69    }
70}

Exercise 2: RESTful API with JSON

Learning Objectives: Build a complete REST API, handle JSON requests and responses, implement CRUD operations, and understand HTTP methods.

Difficulty: ⭐⭐⭐ Intermediate
Time Estimate: 30 minutes

Create a RESTful API for managing a collection of books with full CRUD operations. This exercise teaches you to work with JSON encoding/decoding, handle different HTTP methods, implement RESTful design patterns, and build a complete API that can be consumed by frontend applications.

Real-World Context: REST APIs are the backbone of modern web applications. Every mobile app, single-page application, and microservice architecture relies on RESTful APIs for data communication. Understanding how to build robust, well-designed APIs is essential for any backend developer working on web applications or distributed systems.

  1// run
  2package main
  3
  4import (
  5    "encoding/json"
  6    "fmt"
  7    "log"
  8    "net/http"
  9    "sync"
 10    "time"
 11)
 12
 13type Book struct {
 14    ID        int       `json:"id"`
 15    Title     string    `json:"title"`
 16    Author    string    `json:"author"`
 17    Published int       `json:"published"`
 18    ISBN      string    `json:"isbn"`
 19    CreatedAt time.Time `json:"created_at"`
 20    UpdatedAt time.Time `json:"updated_at"`
 21}
 22
 23type BookStore struct {
 24    books   map[int]Book
 25    nextID  int
 26    mutex   sync.RWMutex
 27}
 28
 29var store = &BookStore{
 30    books:  make(map[int]Book),
 31    nextID: 1,
 32}
 33
 34func main() {
 35    // Initialize with some sample data
 36    store.books[1] = Book{
 37        ID:        1,
 38        Title:     "The Go Programming Language",
 39        Author:    "Alan Donovan",
 40        Published: 2015,
 41        ISBN:      "978-0134190440",
 42        CreatedAt: time.Now(),
 43        UpdatedAt: time.Now(),
 44    }
 45    store.nextID = 2
 46
 47    // Define routes
 48    http.HandleFunc("/api/books", booksHandler)
 49    http.HandleFunc("/api/books/", bookHandler)
 50
 51    // Enable CORS
 52    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 53        w.Header().Set("Access-Control-Allow-Origin", "*")
 54        w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
 55        w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
 56
 57        if r.Method == "OPTIONS" {
 58            w.WriteHeader(http.StatusOK)
 59            return
 60        }
 61
 62        http.NotFound(w, r)
 63    })
 64
 65    fmt.Println("Book API Server starting on :8080...")
 66    fmt.Println("Available endpoints:")
 67    fmt.Println("  GET    /api/books       - List all books")
 68    fmt.Println("  POST   /api/books       - Create new book")
 69    fmt.Println("  GET    /api/books/{id}  - Get specific book")
 70    fmt.Println("  PUT    /api/books/{id}  - Update book")
 71    fmt.Println("  DELETE /api/books/{id}  - Delete book")
 72
 73    log.Fatal(http.ListenAndServe(":8080", nil))
 74}
 75
 76func booksHandler(w http.ResponseWriter, r *http.Request) {
 77    w.Header().Set("Access-Control-Allow-Origin", "*")
 78    w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
 79    w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
 80
 81    if r.Method == "OPTIONS" {
 82        w.WriteHeader(http.StatusOK)
 83        return
 84    }
 85
 86    w.Header().Set("Content-Type", "application/json")
 87
 88    switch r.Method {
 89    case "GET":
 90        store.mutex.RLock()
 91        defer store.mutex.RUnlock()
 92
 93        books := make([]Book, 0, len(store.books))
 94        for _, book := range store.books {
 95            books = append(books, book)
 96        }
 97
 98        json.NewEncoder(w).Encode(books)
 99
100    case "POST":
101        var book Book
102        if err := json.NewDecoder(r.Body).Decode(&book); err != nil {
103            http.Error(w, err.Error(), http.StatusBadRequest)
104            return
105        }
106
107        store.mutex.Lock()
108        defer store.mutex.Unlock()
109
110        book.ID = store.nextID
111        book.CreatedAt = time.Now()
112        book.UpdatedAt = time.Now()
113        store.books[book.ID] = book
114        store.nextID++
115
116        w.WriteHeader(http.StatusCreated)
117        json.NewEncoder(w).Encode(book)
118
119    default:
120        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
121    }
122}
123
124func bookHandler(w http.ResponseWriter, r *http.Request) {
125    w.Header().Set("Access-Control-Allow-Origin", "*")
126    w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
127    w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
128
129    if r.Method == "OPTIONS" {
130        w.WriteHeader(http.StatusOK)
131        return
132    }
133
134    w.Header().Set("Content-Type", "application/json")
135
136    // Extract ID from URL path
137    path := r.URL.Path
138    if len(path) < len("/api/books/") {
139        http.NotFound(w, r)
140        return
141    }
142
143    idStr := path[len("/api/books/"):]
144    var id int
145    if _, err := fmt.Sscanf(idStr, "%d", &id); err != nil {
146        http.Error(w, "Invalid book ID", http.StatusBadRequest)
147        return
148    }
149
150    store.mutex.RLock()
151    book, exists := store.books[id]
152    store.mutex.RUnlock()
153
154    if !exists {
155        http.Error(w, "Book not found", http.StatusNotFound)
156        return
157    }
158
159    switch r.Method {
160    case "GET":
161        json.NewEncoder(w).Encode(book)
162
163    case "PUT":
164        var updatedBook Book
165        if err := json.NewDecoder(r.Body).Decode(&updatedBook); err != nil {
166            http.Error(w, err.Error(), http.StatusBadRequest)
167            return
168        }
169
170        store.mutex.Lock()
171        defer store.mutex.Unlock()
172
173        // Preserve immutable fields
174        updatedBook.ID = book.ID
175        updatedBook.CreatedAt = book.CreatedAt
176        updatedBook.UpdatedAt = time.Now()
177
178        store.books[id] = updatedBook
179        json.NewEncoder(w).Encode(updatedBook)
180
181    case "DELETE":
182        store.mutex.Lock()
183        defer store.mutex.Unlock()
184
185        delete(store.books, id)
186        w.WriteHeader(http.StatusNoContent)
187
188    default:
189        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
190    }
191}