Server HTTP dari pustaka standar

net/http bukan mainan. Ia HTTP/1.1 dan HTTP/2 lengkap, dengan connection pooling, TLS, dan satu goroutine per permintaan — dan ia yang mendasari setiap framework Go yang akan kamu temui.

Server minimum

package main

import (
	"log"
	"net/http"
)

func main() {
	mux := http.NewServeMux()

	mux.HandleFunc("GET /halo", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
		w.Write([]byte("halo\n"))
	})

	log.Fatal(http.ListenAndServe(":8080", mux))
}

Bentuk yang layak dipakai

srv := &http.Server{
	Addr:              ":8080",
	Handler:           mux,
	ReadHeaderTimeout: 5 * time.Second,
	ReadTimeout:       15 * time.Second,
	WriteTimeout:      15 * time.Second,
	IdleTimeout:       60 * time.Second,
	MaxHeaderBytes:    1 << 20,
	ErrorLog:          slog.NewLogLogger(logger.Handler(), slog.LevelError),
}

if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
	log.Fatal(err)
}

Perhatikan pemeriksaan http.ErrServerClosed: itu error yang dikembalikan saat server dimatikan dengan sengaja. Tanpa pengecualian itu, setiap graceful shutdown akan tercatat sebagai kegagalan.

Satu goroutine per permintaan

Klien A ──┐
Klien B ──┼──► Listener ──► goroutine A ──► handler
Klien C ──┘              ├─► goroutine B ──► handler
                         └─► goroutine C ──► handler

Server membuat goroutine baru untuk setiap koneksi yang masuk. Konsekuensinya langsung ke cara kamu menulis handler:

Handler sebagai struct berisi dependensi

type Handler struct {
	produk  *produk.Layanan
	log     *slog.Logger
	tmpl    *template.Template
}

func New(p *produk.Layanan, log *slog.Logger) *Handler {
	return &Handler{produk: p, log: log}
}

func (h *Handler) Daftar(w http.ResponseWriter, r *http.Request) {
	hasil, err := h.produk.Cari(r.Context(), r.URL.Query().Get("q"))
	if err != nil {
		h.tulisError(w, r, err)
		return
	}
	h.tulisJSON(w, http.StatusOK, hasil)
}

Menulis respons dengan benar

func tulisJSON(w http.ResponseWriter, status int, v any) {
	buf, err := json.Marshal(v)
	if err != nil {
		http.Error(w, "gagal encode", http.StatusInternalServerError)
		return
	}

	// Urutannya WAJIB: header dulu, status kedua, body terakhir.
	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.WriteHeader(status)
	w.Write(buf)
}

Membaca permintaan

r.Method                          // "GET"
r.URL.Path                        // "/produk/42"
r.PathValue("id")                 // parameter rute (Go 1.22+)
r.URL.Query().Get("q")            // query string
r.Header.Get("Authorization")     // header
r.Context()                       // context permintaan — SELALU teruskan
r.RemoteAddr                      // alamat peer — di belakang ALB ini alamat ALB

// Form dan body
r.ParseForm()
r.FormValue("nama")
io.ReadAll(http.MaxBytesReader(w, r.Body, 1<<20))   // selalu batasi

TLS dan HTTP/2

srv.ListenAndServeTLS("cert.pem", "key.pem")   // HTTP/2 aktif otomatis

Begitu TLS menyala, negosiasi ALPN membuat klien yang mendukung HTTP/2 memakainya — tanpa konfigurasi tambahan. Di AWS (Fase 10), TLS biasanya diterminasi di ALB atau CloudFront, sehingga aplikasimu sendiri melayani HTTP polos di dalam VPC. Itu wajar dan aman selama lalu lintasnya tidak keluar dari VPC.

Kenapa pustaka standar sering sudah cukup

Yang tidak ada: pengikatan & validasi otomatis, dokumentasi OpenAPI, dan sekumpulan middleware siap pakai. Fase 7 membandingkan framework yang menyediakannya — tapi semuanya dibangun di atas http.Handler yang sama, jadi apa pun yang kamu pelajari di sini tetap terpakai.