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.ServeMuxkann seit Go 1.22 Methoden und Platzhalter:GET /{code},r.PathValue("code").- Middleware ist nur eine Funktion
http.Handler -> http.Handler. log/slogschreibt strukturierte JSON-Logs,client_golangliefert/metricsfü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/storetestErwartet (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
}
EOFDie 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
}
EOFWarum 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)
}
})
}
EOFcat > 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() })
}
EOFgo 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)
}
EOFWarum 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)
})
}
EOFWarum 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
}
EOFWarum 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)
}
}
EOFgo 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 echterhttptest.Servertestet 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 %1Erwartet (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)
})
}
EOFDann 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 2pErwartet:
--- 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 einpreStop-Sleep, damit der Load Balancer keine neuen Anfragen mehr schickt. /metricsnicht ö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.