Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 9: HTTP-Server – shorturl

Ziel: Ein URL-Kürzer mit JSON-API, Routing per ServeMux-Mustern, Middleware für Logs und Metriken und sauberem Shutdown – getestet mit httptest · Dauer: ca. 150 min · Voraussetzung: Tag 8

Briefing

  • http.ServeMux kann seit Go 1.22 Methoden und Platzhalter: GET /{code}, r.PathValue("code").
  • Middleware ist nur eine Funktion http.Handler -> http.Handler.
  • log/slog schreibt strukturierte JSON-Logs, client_golang liefert /metrics für Prometheus.
  • Graceful Shutdown: Bei SIGTERM keine neuen Verbindungen, laufende Anfragen dürfen fertig werden.
  • Speicher hinter einem Interface: heute eine Map, an Tag 10 SQLite – ohne den Server anzufassen.
Anfrage -> recoverer -> instrument -> logRequests -> ServeMux -> Handler -> Store
             (panic)   (Prometheus)    (slog)       Muster     JSON     Memory
                                                                       (Tag 10: SQLite)

Drill 1: Modul und Abhängigkeit

mkdir -p ~/go-lab/tag09-shorturl && cd ~/go-lab/tag09-shorturl
go mod init example.com/shorturl
go get github.com/prometheus/[email protected]
mkdir -p cmd/shorturl internal/server internal/store/storetest

Erwartet (gekürzt):

go: creating new go.mod: module example.com/shorturl
go: added github.com/prometheus/client_golang v1.25.0

Fortschritt speichern? Kostenlos registrieren

Drill 2: Der Store-Vertrag

Das Interface beschreibt, was gespeichert wird, nicht wie. Fehler sind Sentinels (Tag 3), damit der Server 404 und 409 unterscheiden kann, egal welche Implementierung dahinter steckt.

cat > internal/store/store.go <<'EOF'
// Package store definiert, wie Kurzlinks gespeichert werden. Tag 10 ersetzt den
// Speicher durch SQLite – Server und Tests bleiben unverändert.
package store

import (
    "context"
    "errors"
    "time"
)

var (
    ErrNotFound = errors.New("store: Link nicht gefunden")
    ErrExists   = errors.New("store: Code existiert bereits")
)

// Link ist ein Kurzlink.
type Link struct {
    Code    string    `json:"code"`
    URL     string    `json:"url"`
    Hits    int64     `json:"hits"`
    Created time.Time `json:"created"`
}

// Store ist der Vertrag zwischen HTTP-Schicht und Speicher.
type Store interface {
    Create(ctx context.Context, l Link) error           // ErrExists
    Get(ctx context.Context, code string) (Link, error) // ErrNotFound
    Hit(ctx context.Context, code string) (Link, error) // Hits+1; ErrNotFound
    Delete(ctx context.Context, code string) error      // ErrNotFound
}
EOF

Die erste Implementierung ist eine Map mit sync.RWMutex – HTTP-Handler laufen nebenläufig (Tag 8), ungeschützte Map-Zugriffe würden das Programm mit fatal error: concurrent map writes beenden.

cat > internal/store/memory.go <<'EOF'
package store

import (
    "context"
    "sync"
)

// Memory hält Links in einer Map. Nach einem Neustart ist alles weg (bis Tag 10).
type Memory struct {
    mu    sync.RWMutex // viele Leser (Redirects), wenige Schreiber
    links map[string]Link
}

var _ Store = (*Memory)(nil) // Compiler prüft: Memory erfüllt Store

// NewMemory liefert einen leeren Speicher.
func NewMemory() *Memory {
    return &Memory{links: make(map[string]Link)}
}

func (m *Memory) Create(_ context.Context, l Link) error {
    m.mu.Lock()
    defer m.mu.Unlock()
    if _, ok := m.links[l.Code]; ok {
        return ErrExists
    }
    m.links[l.Code] = l
    return nil
}

func (m *Memory) Get(_ context.Context, code string) (Link, error) {
    m.mu.RLock()
    defer m.mu.RUnlock()
    l, ok := m.links[code]
    if !ok {
        return Link{}, ErrNotFound
    }
    return l, nil
}

func (m *Memory) Hit(_ context.Context, code string) (Link, error) {
    m.mu.Lock() // schreibt: Hits erhöhen
    defer m.mu.Unlock()
    l, ok := m.links[code]
    if !ok {
        return Link{}, ErrNotFound
    }
    l.Hits++
    m.links[code] = l
    return l, nil
}

func (m *Memory) Delete(_ context.Context, code string) error {
    m.mu.Lock()
    defer m.mu.Unlock()
    if _, ok := m.links[code]; !ok {
        return ErrNotFound
    }
    delete(m.links, code)
    return nil
}
EOF

Warum ist Hit ein eigener Aufruf statt Get plus Update? Lesen und Erhöhen müssen eine Einheit sein; sonst gehen bei parallelen Redirects Zählungen verloren – genau der Race aus Tag 8. Mit SQLite wird daraus ein einzelnes UPDATE … SET hits = hits + 1.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Vertragstests

Einmal schreiben, für jede Implementierung ausführen: storetest.Run bekommt eine Fabrikfunktion. Tag 10 ruft dieselben Tests mit SQLite auf.

cat > internal/store/storetest/storetest.go <<'EOF'
// Package storetest prüft jede Store-Implementierung gegen denselben Vertrag.
// Tag 10 ruft Run mit SQLite auf.
package storetest

import (
    "context"
    "errors"
    "sync"
    "testing"
    "time"

    "example.com/shorturl/internal/store"
)

// Run führt alle Vertragstests aus; newStore liefert pro Test einen leeren Store.
func Run(t *testing.T, newStore func(t *testing.T) store.Store) {
    ctx := context.Background()
    link := store.Link{Code: "go", URL: "https://go.dev",
        Created: time.Date(2026, 10, 10, 9, 0, 0, 0, time.UTC)}

    t.Run("CreateGet", func(t *testing.T) {
        s := newStore(t)
        if err := s.Create(ctx, link); err != nil {
            t.Fatal(err)
        }
        got, err := s.Get(ctx, "go")
        if err != nil || got.URL != link.URL || !got.Created.Equal(link.Created) {
            t.Errorf("Get = %+v, %v", got, err)
        }
        if err := s.Create(ctx, link); !errors.Is(err, store.ErrExists) {
            t.Errorf("doppeltes Create: err = %v, want ErrExists", err)
        }
    })

    t.Run("NotFound", func(t *testing.T) {
        s := newStore(t)
        if _, err := s.Get(ctx, "nix"); !errors.Is(err, store.ErrNotFound) {
            t.Errorf("Get: %v", err)
        }
        if _, err := s.Hit(ctx, "nix"); !errors.Is(err, store.ErrNotFound) {
            t.Errorf("Hit: %v", err)
        }
        if err := s.Delete(ctx, "nix"); !errors.Is(err, store.ErrNotFound) {
            t.Errorf("Delete: %v", err)
        }
    })

    t.Run("HitsParallel", func(t *testing.T) {
        s := newStore(t)
        if err := s.Create(ctx, link); err != nil {
            t.Fatal(err)
        }
        var wg sync.WaitGroup
        for range 50 {
            wg.Go(func() {
                if _, err := s.Hit(ctx, "go"); err != nil {
                    t.Error(err)
                }
            })
        }
        wg.Wait()
        if got, _ := s.Get(ctx, "go"); got.Hits != 50 {
            t.Errorf("Hits = %d, want 50", got.Hits)
        }
    })

    t.Run("Delete", func(t *testing.T) {
        s := newStore(t)
        if err := s.Create(ctx, link); err != nil {
            t.Fatal(err)
        }
        if err := s.Delete(ctx, "go"); err != nil {
            t.Fatal(err)
        }
        if _, err := s.Get(ctx, "go"); !errors.Is(err, store.ErrNotFound) {
            t.Errorf("nach Delete: %v", err)
        }
    })
}
EOF
cat > internal/store/memory_test.go <<'EOF'
package store_test

import (
    "testing"

    "example.com/shorturl/internal/store"
    "example.com/shorturl/internal/store/storetest"
)

func TestMemory(t *testing.T) {
    storetest.Run(t, func(*testing.T) store.Store { return store.NewMemory() })
}
EOF
go test -race -count=1 -v ./internal/store/ 2>&1 | grep -E '^(\s*---|ok)'

Erwartet:

--- PASS: TestMemory (0.00s)
    --- PASS: TestMemory/CreateGet (0.00s)
    --- PASS: TestMemory/NotFound (0.00s)
    --- PASS: TestMemory/HitsParallel (0.00s)
    --- PASS: TestMemory/Delete (0.00s)
ok      example.com/shorturl/internal/store 1.165s

Warum package store_test? Der Test sieht das Paket nur von außen, wie jeder andere Aufrufer – und darf storetest importieren, ohne einen Import-Zyklus zu erzeugen.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Routen und Handler

Die Muster sagen alles: Methode, Pfad, Platzhalter. Bei Überschneidung gewinnt das spezifischere Muster – GET /healthz schlägt GET /{code}. Für eine falsche Methode antwortet der Mux selbst mit 405 und Allow-Header.

cat > internal/server/server.go <<'EOF'
// Package server stellt die HTTP-API von shorturl bereit.
package server

import (
    "crypto/rand"
    "encoding/json"
    "errors"
    "fmt"
    "log/slog"
    "net/http"
    "net/url"
    "regexp"
    "time"

    "example.com/shorturl/internal/store"
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
)

var validCode = regexp.MustCompile(`^[A-Za-z0-9_-]{3,32}$`)

type server struct {
    store   store.Store
    log     *slog.Logger
    baseURL string
}

// New baut den Handler mit allen Routen und Middleware.
func New(st store.Store, log *slog.Logger, baseURL string,
    reg *prometheus.Registry) http.Handler {
    s := &server{store: st, log: log, baseURL: baseURL}
    mux := http.NewServeMux()
    mux.HandleFunc("POST /api/links", s.create)
    mux.HandleFunc("GET /api/links/{code}", s.get)
    mux.HandleFunc("DELETE /api/links/{code}", s.delete)
    mux.HandleFunc("GET /{code}", s.redirect)
    mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, _ *http.Request) {
        fmt.Fprintln(w, "ok")
    })
    mux.Handle("GET /metrics", promhttp.HandlerFor(reg, promhttp.HandlerOpts{}))
    return recoverer(log, instrument(reg, logRequests(log, mux)))
}

type createReq struct {
    URL  string `json:"url"`
    Code string `json:"code,omitempty"` // optional, sonst zufällig
}

type createResp struct {
    store.Link
    Short string `json:"short"`
}

func (s *server) create(w http.ResponseWriter, r *http.Request) {
    var req createReq
    dec := json.NewDecoder(http.MaxBytesReader(w, r.Body, 8<<10))
    dec.DisallowUnknownFields()
    if err := dec.Decode(&req); err != nil {
        httpError(w, http.StatusBadRequest, "ungültiges JSON: "+err.Error())
        return
    }
    if u, err := url.ParseRequestURI(req.URL); err != nil || u.Host == "" ||
        (u.Scheme != "http" && u.Scheme != "https") {
        httpError(w, http.StatusBadRequest, "url muss http(s)://host... sein")
        return
    }
    if req.Code != "" && (!validCode.MatchString(req.Code) || reserved(req.Code)) {
        httpError(w, http.StatusBadRequest, "code: 3-32 Zeichen A-Z a-z 0-9 _ -")
        return
    }

    link := store.Link{Code: req.Code, URL: req.URL, Created: time.Now().UTC()}
    var err error
    for range 5 { // zufälliger Code kollidiert selten – dann neu würfeln
        if req.Code == "" {
            link.Code = randomCode()
        }
        err = s.store.Create(r.Context(), link)
        if req.Code != "" || !errors.Is(err, store.ErrExists) {
            break
        }
    }
    switch {
    case errors.Is(err, store.ErrExists):
        httpError(w, http.StatusConflict, "code existiert bereits")
    case err != nil:
        s.internal(w, r, err)
    default:
        writeJSON(w, http.StatusCreated, createResp{link, s.baseURL + "/" + link.Code})
    }
}

func (s *server) get(w http.ResponseWriter, r *http.Request) {
    link, err := s.store.Get(r.Context(), r.PathValue("code"))
    if s.handleErr(w, r, err) {
        return
    }
    writeJSON(w, http.StatusOK, link)
}

func (s *server) delete(w http.ResponseWriter, r *http.Request) {
    err := s.store.Delete(r.Context(), r.PathValue("code"))
    if s.handleErr(w, r, err) {
        return
    }
    w.WriteHeader(http.StatusNoContent)
}

func (s *server) redirect(w http.ResponseWriter, r *http.Request) {
    link, err := s.store.Hit(r.Context(), r.PathValue("code"))
    if s.handleErr(w, r, err) {
        return
    }
    http.Redirect(w, r, link.URL, http.StatusFound)
}

// handleErr schreibt 404 bzw. 500 und meldet, ob ein Fehler vorlag.
func (s *server) handleErr(w http.ResponseWriter, r *http.Request, err error) bool {
    switch {
    case err == nil:
        return false
    case errors.Is(err, store.ErrNotFound):
        httpError(w, http.StatusNotFound, "unbekannter code")
    default:
        s.internal(w, r, err)
    }
    return true
}

// internal loggt Details, der Client sieht nur eine allgemeine Meldung.
func (s *server) internal(w http.ResponseWriter, r *http.Request, err error) {
    s.log.ErrorContext(r.Context(), "interner Fehler", "path", r.URL.Path, "err", err)
    httpError(w, http.StatusInternalServerError, "interner Fehler")
}

func writeJSON(w http.ResponseWriter, status int, v any) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(status)
    _ = json.NewEncoder(w).Encode(v)
}

func httpError(w http.ResponseWriter, status int, msg string) {
    writeJSON(w, status, map[string]string{"error": msg})
}

func reserved(code string) bool {
    return code == "api" || code == "healthz" || code == "metrics"
}

const alphabet = "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789"

// randomCode: 7 Zeichen ohne Verwechsler (l/1, O/0) aus crypto/rand.
func randomCode() string {
    b := make([]byte, 7)
    rand.Read(b) // liefert nie einen Fehler (Go 1.24+)
    for i := range b {
        b[i] = alphabet[int(b[i])%len(alphabet)]
    }
    return string(b)
}
EOF

Warum so viel Validierung? Der Server nimmt Daten aus dem Internet an: MaxBytesReader begrenzt den Body auf 8 KiB, DisallowUnknownFields macht Tippfehler im Client sichtbar, und nur http(s) verhindert javascript:-Links als offene Weiterleitung. Interne Fehler landen im Log, nie im Response.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Middleware – Logs, Metriken, Panics

statusRecorder bettet den ResponseWriter ein und überschreibt nur WriteHeader – so erfährt die Middleware den Status, den der Handler gesetzt hat.

cat > internal/server/middleware.go <<'EOF'
package server

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

    "github.com/prometheus/client_golang/prometheus"
)

// statusRecorder merkt sich den Statuscode, den der Handler schreibt.
type statusRecorder struct {
    http.ResponseWriter
    status int
}

func (r *statusRecorder) WriteHeader(code int) {
    r.status = code
    r.ResponseWriter.WriteHeader(code)
}

// logRequests schreibt pro Anfrage eine strukturierte Logzeile.
func logRequests(log *slog.Logger, next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
        next.ServeHTTP(rec, r)
        log.InfoContext(r.Context(), "request", "method", r.Method,
            "path", r.URL.Path, "status", rec.status,
            "ms", time.Since(start).Milliseconds())
    })
}

// instrument zählt Anfragen pro Route (Muster, nicht Pfad!) und Status.
func instrument(reg *prometheus.Registry, next http.Handler) http.Handler {
    requests := prometheus.NewCounterVec(prometheus.CounterOpts{
        Name: "shorturl_http_requests_total",
        Help: "HTTP-Anfragen nach Route und Status.",
    }, []string{"route", "code"})
    duration := prometheus.NewHistogramVec(prometheus.HistogramOpts{
        Name:    "shorturl_http_request_duration_seconds",
        Help:    "Bearbeitungsdauer nach Route.",
        Buckets: prometheus.DefBuckets,
    }, []string{"route"})
    reg.MustRegister(requests, duration)

    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
        next.ServeHTTP(rec, r)
        route := r.Pattern // vom ServeMux gesetzt, z. B. "GET /{code}"
        if route == "" {
            route = "unmatched"
        }
        requests.WithLabelValues(route, strconv.Itoa(rec.status)).Inc()
        duration.WithLabelValues(route).Observe(time.Since(start).Seconds())
    })
}

// recoverer fängt Panics ab: 500 statt abgerissener Verbindung.
func recoverer(log *slog.Logger, next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if v := recover(); v != nil {
                log.ErrorContext(r.Context(), "panic", "path", r.URL.Path, "panic", v)
                httpError(w, http.StatusInternalServerError, "interner Fehler")
            }
        }()
        next.ServeHTTP(w, r)
    })
}
EOF

Warum r.Pattern als Label und nicht r.URL.Path? Jeder Kurzcode wäre sonst eine eigene Zeitreihe – nach einer Million Links hätte Prometheus eine Million Serien (Kardinalitätsexplosion). Das Muster GET /{code} ist genau eine.

Fortschritt speichern? Kostenlos registrieren

Drill 6: main – Timeouts und Graceful Shutdown

Ein http.Server ohne Timeouts lässt sich mit langsam tröpfelnden Headern lahmlegen (Slowloris). ListenAndServe läuft in einer Goroutine; main wartet per select auf Fehler oder Signal.

cat > cmd/shorturl/main.go <<'EOF'
// shorturl ist ein URL-Kürzer mit JSON-API, Metriken und Graceful Shutdown.
package main

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

    "example.com/shorturl/internal/server"
    "example.com/shorturl/internal/store"
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/collectors"
)

func main() {
    addr := flag.String("addr", cmp.Or(os.Getenv("SHORTURL_ADDR"), "127.0.0.1:8080"),
        "Listen-Adresse")
    baseURL := flag.String("base-url", "", "öffentliche URL (Default http://ADDR)")
    flag.Parse()
    if *baseURL == "" {
        *baseURL = "http://" + *addr
    }

    log := slog.New(slog.NewJSONHandler(os.Stdout, nil))
    if err := serve(*addr, *baseURL, log); err != nil {
        log.Error("Abbruch", "err", err)
        os.Exit(1)
    }
}

func serve(addr, baseURL string, log *slog.Logger) error {
    reg := prometheus.NewRegistry()
    reg.MustRegister(collectors.NewGoCollector(),
        collectors.NewProcessCollector(collectors.ProcessCollectorOpts{}))

    srv := &http.Server{
        Addr:              addr,
        Handler:           server.New(store.NewMemory(), log, baseURL, reg),
        ReadHeaderTimeout: 5 * time.Second, // Schutz gegen Slowloris
        ReadTimeout:       10 * time.Second,
        WriteTimeout:      10 * time.Second,
        IdleTimeout:       60 * time.Second,
    }

    // SIGTERM schickt Kubernetes beim Pod-Stopp, SIGINT ist Strg+C.
    ctx, stop := signal.NotifyContext(context.Background(),
        os.Interrupt, syscall.SIGTERM)
    defer stop()

    errc := make(chan error, 1)
    go func() {
        log.Info("shorturl startet", "addr", addr, "base_url", baseURL)
        errc <- srv.ListenAndServe()
    }()

    select {
    case err := <-errc: // z. B. Port belegt
        return err
    case <-ctx.Done():
    }
    log.Info("fahre herunter, warte auf laufende Anfragen")
    shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    if err := srv.Shutdown(shutdownCtx); err != nil {
        return err
    }
    if err := <-errc; !errors.Is(err, http.ErrServerClosed) {
        return err
    }
    log.Info("sauber beendet")
    return nil
}
EOF

Warum 127.0.0.1 als Default? Im Lab soll der Server nicht im WLAN erreichbar sein. Im Container setzt du SHORTURL_ADDR=:8080.

Server im Hintergrund starten und durchspielen:

go mod tidy && go build -o shorturl ./cmd/shorturl
./shorturl > server.log &
sleep 1
curl -s localhost:8080/api/links \
  -d '{"url":"https://go.dev/doc/effective_go","code":"effgo"}' | jq -c '{code, short}'
curl -s localhost:8080/api/links -d '{"url":"https://openbao.org"}' | jq -c '{code}'
curl -si localhost:8080/effgo | grep -E '^(HTTP|Location)'
curl -s localhost:8080/api/links/effgo | jq -c '{code, hits}'
curl -s localhost:8080/api/links -d '{"url":"javascript:alert(1)"}'
curl -si -X PUT localhost:8080/api/links/effgo | grep -E '^(HTTP|Allow)'
curl -s -X DELETE -w '%{http_code}\n' localhost:8080/api/links/effgo
curl -s localhost:8080/effgo
curl -s localhost:8080/metrics | grep '^shorturl_http_requests_total'
kill -TERM %1; sleep 1
jq -c 'del(.time, .level)' server.log | sed -n '1p;5p;$p'

Erwartet (Code und Zeiten variieren):

{"code":"effgo","short":"http://127.0.0.1:8080/effgo"}
{"code":"RhRn9iG"}
HTTP/1.1 302 Found
Location: https://go.dev/doc/effective_go
{"code":"effgo","hits":1}
{"error":"url muss http(s)://host... sein"}
HTTP/1.1 405 Method Not Allowed
Allow: DELETE, GET, HEAD
204
{"error":"unbekannter code"}
shorturl_http_requests_total{code="200",route="GET /api/links/{code}"} 1
shorturl_http_requests_total{code="201",route="POST /api/links"} 2
shorturl_http_requests_total{code="204",route="DELETE /api/links/{code}"} 1
shorturl_http_requests_total{code="302",route="GET /{code}"} 1
shorturl_http_requests_total{code="400",route="POST /api/links"} 1
shorturl_http_requests_total{code="404",route="GET /{code}"} 1
shorturl_http_requests_total{code="405",route="unmatched"} 1
{"msg":"shorturl startet","addr":"127.0.0.1:8080","base_url":"http://127.0.0.1:8080"}
{"msg":"request","method":"GET","path":"/api/links/effgo","status":200,"ms":0}
{"msg":"sauber beendet"}

Warum unmatched beim 405? Kein Muster passte vollständig, also setzt der Mux kein r.Pattern. GET erlaubt automatisch auch HEAD. Und kill -TERM ist genau das, was Kubernetes beim Stoppen eines Pods schickt – der Server meldet „sauber beendet” statt abzureißen.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Handler-Tests mit httptest

Der komplette Handler-Stack läuft gegen einen httptest.Server – mit eigener Prometheus-Registry pro Test, damit sich Metriken nicht doppelt registrieren. Der Client folgt Redirects bewusst nicht.

cat > internal/server/server_test.go <<'EOF'
package server

import (
    "encoding/json"
    "io"
    "log/slog"
    "net/http"
    "net/http/httptest"
    "strings"
    "testing"

    "example.com/shorturl/internal/store"
    "github.com/prometheus/client_golang/prometheus"
)

func newTestServer(t *testing.T) *httptest.Server {
    t.Helper()
    log := slog.New(slog.NewTextHandler(io.Discard, nil))
    h := New(store.NewMemory(), log, "http://short.test", prometheus.NewRegistry())
    srv := httptest.NewServer(h)
    t.Cleanup(srv.Close)
    return srv
}

// noRedirect: Der Test will die 302 sehen, nicht dem Link folgen.
var noRedirect = &http.Client{
    CheckRedirect: func(*http.Request, []*http.Request) error {
        return http.ErrUseLastResponse
    },
}

func do(t *testing.T, method, url, body string) *http.Response {
    t.Helper()
    req, err := http.NewRequest(method, url, strings.NewReader(body))
    if err != nil {
        t.Fatal(err)
    }
    resp, err := noRedirect.Do(req)
    if err != nil {
        t.Fatal(err)
    }
    t.Cleanup(func() { resp.Body.Close() })
    return resp
}

const godev = `{"url":"https://go.dev","code":"godev"}`

func TestLebenszyklus(t *testing.T) {
    srv := newTestServer(t)
    resp := do(t, "POST", srv.URL+"/api/links", godev)
    var created createResp
    if err := json.NewDecoder(resp.Body).Decode(&created); err != nil ||
        resp.StatusCode != 201 || created.Short != "http://short.test/godev" {
        t.Fatalf("create: %d %+v %v", resp.StatusCode, created, err)
    }

    resp = do(t, "GET", srv.URL+"/godev", "")
    if resp.StatusCode != 302 || resp.Header.Get("Location") != "https://go.dev" {
        t.Errorf("redirect: %d %q", resp.StatusCode, resp.Header.Get("Location"))
    }

    var link store.Link
    resp = do(t, "GET", srv.URL+"/api/links/godev", "")
    if err := json.NewDecoder(resp.Body).Decode(&link); err != nil || link.Hits != 1 {
        t.Errorf("stats: %+v %v", link, err)
    }

    if resp = do(t, "DELETE", srv.URL+"/api/links/godev", ""); resp.StatusCode != 204 {
        t.Errorf("delete: %d", resp.StatusCode)
    }
    if resp = do(t, "GET", srv.URL+"/godev", ""); resp.StatusCode != 404 {
        t.Errorf("nach delete: %d", resp.StatusCode)
    }
}

func TestFehlerfaelle(t *testing.T) {
    srv := newTestServer(t)
    do(t, "POST", srv.URL+"/api/links", godev)
    tests := []struct {
        name, method, path, body string
        want                     int
    }{
        {"kein JSON", "POST", "/api/links", `url=x`, 400},
        {"unbekanntes Feld", "POST", "/api/links", `{"url":"https://a.b","x":1}`, 400},
        {"ftp-URL", "POST", "/api/links", `{"url":"ftp://a.b"}`, 400},
        {"reserviert", "POST", "/api/links", `{"url":"https://a.b","code":"api"}`, 400},
        {"Code belegt", "POST", "/api/links", godev, 409},
        {"falsche Methode", "PUT", "/api/links/godev", ``, 405},
        {"unbekannt", "GET", "/api/links/nix", ``, 404},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            resp := do(t, tt.method, srv.URL+tt.path, tt.body)
            if resp.StatusCode != tt.want {
                t.Errorf("Status %d, want %d", resp.StatusCode, tt.want)
            }
        })
    }
}

func TestZufallscodeUndMetriken(t *testing.T) {
    srv := newTestServer(t)
    resp := do(t, "POST", srv.URL+"/api/links", `{"url":"https://kubernetes.io"}`)
    var created createResp
    if err := json.NewDecoder(resp.Body).Decode(&created); err != nil ||
        !validCode.MatchString(created.Code) {
        t.Fatalf("Code %q, %v", created.Code, err)
    }
    do(t, "GET", srv.URL+"/"+created.Code, "")

    body, _ := io.ReadAll(do(t, "GET", srv.URL+"/metrics", "").Body)
    want := `shorturl_http_requests_total{code="302",route="GET /{code}"} 1`
    if !strings.Contains(string(body), want) {
        t.Errorf("Metrik fehlt: %s", want)
    }
}
EOF
go test -race -count=1 -v ./internal/server 2>&1 | grep -E '^(\s*---|ok)'

Erwartet:

--- PASS: TestLebenszyklus (0.00s)
--- PASS: TestFehlerfaelle (0.00s)
    --- PASS: TestFehlerfaelle/kein_JSON (0.00s)
    --- PASS: TestFehlerfaelle/unbekanntes_Feld (0.00s)
    --- PASS: TestFehlerfaelle/ftp-URL (0.00s)
    --- PASS: TestFehlerfaelle/reserviert (0.00s)
    --- PASS: TestFehlerfaelle/Code_belegt (0.00s)
    --- PASS: TestFehlerfaelle/falsche_Methode (0.00s)
    --- PASS: TestFehlerfaelle/unbekannt (0.00s)
--- PASS: TestZufallscodeUndMetriken (0.00s)
ok      example.com/shorturl/internal/server    1.196s

Tipp: Für einzelne Handler ohne Netzwerk gibt es httptest.NewRecorder(). Ein echter httptest.Server testet zusätzlich Mux, Middleware und HTTP-Semantik (405, Redirects) – für eine API meist die bessere Wahl.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Das Tool ist fertig

cp ../tag08-urlcheck/.golangci.yml .
gofmt -l . && go vet ./... && ~/go-lab/bin/lint run ./...
go test -race -count=1 ./...

Erwartet:

0 issues.
?       example.com/shorturl/cmd/shorturl   [no test files]
ok      example.com/shorturl/internal/server    1.210s
ok      example.com/shorturl/internal/store 1.302s
?       example.com/shorturl/internal/store/storetest   [no test files]

Einmal noch mit Blick auf Prometheus – neben deinen Metriken liefert die Registry Go-Runtime- und Prozesswerte:

./shorturl > server.log &
sleep 1
curl -s localhost:8080/metrics | grep -E '^(go_goroutines|process_resident)'
kill -TERM %1

Erwartet (Werte variieren):

go_goroutines 9
process_resident_memory_bytes 8.716288e+06

Für shorturl gilt ab jetzt: Die API bleibt, der Speicher wechselt. An Tag 10 implementierst du store.Store mit SQLite und rufst storetest.Run damit auf.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

cd ~/go-lab/tag09-shorturl
ok() { echo "✔ $1"; }; nok() { echo "✘ $1"; }
go vet ./... && go test -race -count=1 ./... >/dev/null && ok "Tests mit -race" \
  || nok "Tests"
./shorturl > server.log & sleep 1
curl -s localhost:8080/api/links -d '{"url":"https://go.dev","code":"check"}' \
  | grep -q '"short"' && ok "Link angelegt" || nok "POST"
[ "$(curl -s -o /dev/null -w '%{http_code}' localhost:8080/check)" = 302 ] \
  && ok "Redirect 302" || nok "Redirect"
curl -s localhost:8080/metrics | grep -q 'route="GET /{code}"' \
  && ok "Metrik mit Routenmuster" || nok "Metriken"
kill -TERM %1; sleep 1
grep -q '"sauber beendet"' server.log && ok "Graceful Shutdown" || nok "Shutdown"

Erwartet:

✔ Tests mit -race
✔ Link angelegt
✔ Redirect 302
✔ Metrik mit Routenmuster
✔ Graceful Shutdown

Challenge

Baue eine Middleware requestID: Sie übernimmt einen eingehenden X-Request-ID-Header (vom Ingress) oder erzeugt eine neue ID, setzt sie in der Antwort und logRequests schreibt sie als request_id ins Log.

Hinweis: rand.Text() aus crypto/rand (seit Go 1.24) liefert eine zufällige 26-Zeichen-ID; die Middleware muss vor logRequests laufen.

Lösung

cat >> internal/server/middleware.go <<'EOF'

// requestID übernimmt X-Request-ID vom Client/Ingress oder erzeugt eine neue.
func requestID(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        id := r.Header.Get("X-Request-ID")
        if id == "" {
            id = rand.Text() // 26 Zeichen Base32 aus crypto/rand
            r.Header.Set("X-Request-ID", id)
        }
        w.Header().Set("X-Request-ID", id)
        next.ServeHTTP(w, r)
    })
}
EOF

Dann drei kleine Änderungen: in middleware.go "crypto/rand" importieren und in logRequests das Attribut ergänzen, in server.go die Kette erweitern:

            "path", r.URL.Path, "status", rec.status,
            "request_id", r.Header.Get("X-Request-ID"),

    return recoverer(log, instrument(reg, requestID(logRequests(log, mux))))

Test anhängen:

cat >> internal/server/server_test.go <<'EOF'

func TestRequestID(t *testing.T) {
    srv := newTestServer(t)
    id := do(t, "GET", srv.URL+"/healthz", "").Header.Get("X-Request-ID")
    if len(id) != 26 {
        t.Errorf("neue ID = %q", id)
    }
    req, _ := http.NewRequest("GET", srv.URL+"/healthz", nil)
    req.Header.Set("X-Request-ID", "lab-123")
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        t.Fatal(err)
    }
    resp.Body.Close()
    if got := resp.Header.Get("X-Request-ID"); got != "lab-123" {
        t.Errorf("übernommene ID = %q", got)
    }
}
EOF
go test -race -count=1 -run RequestID -v ./internal/server | grep -E '^(---|ok)'
go build -o shorturl ./cmd/shorturl && ./shorturl > server.log & sleep 1
curl -si localhost:8080/healthz -H 'X-Request-ID: lab-123' | grep -i request-id
kill -TERM %1; sleep 1
jq -c '{msg, path, request_id}' server.log | sed -n 2p

Erwartet:

--- PASS: TestRequestID (0.00s)
ok      example.com/shorturl/internal/server    1.197s
X-Request-Id: lab-123
{"msg":"request","path":"/healthz","request_id":"lab-123"}

Go schreibt Header kanonisch (X-Request-Id) – HTTP-Header sind ohnehin case-insensitive.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Ein In-Memory-Store verliert bei jedem Rollout alle Daten und funktioniert nicht mit mehreren Replikas – deshalb Tag 10 (SQLite) bzw. in Produktion PostgreSQL.
  • Für Kubernetes: Liveness (/healthz) und Readiness trennen; Readiness bei Shutdown sofort auf „nicht bereit”, dazu ein preStop-Sleep, damit der Load Balancer keine neuen Anfragen mehr schickt.
  • /metrics nicht öffentlich exponieren: eigener Port oder NetworkPolicy, Scrape per ServiceMonitor.
  • URL-Kürzer sind Phishing-Magnete: Rate-Limit pro Client, Authentifizierung für POST/DELETE, Abgleich mit Safe-Browsing-Listen.
  • Logs ohne personenbezogene Daten (keine vollen Query-Strings, keine IPs ohne Rechtsgrundlage) – DSGVO gilt auch für Access-Logs.