Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 4: Go für SRE – llm-gateway

Ziel: Den mandantenfähigen Reverse Proxy llm-gateway selbst bauen, testen, profilen und als distroless-Container ausliefern · Dauer: ca. 180 min · Voraussetzung: Tag 3

Briefing

  • Das Gateway übersetzt API-Key → Mandant, entfernt den Key und setzt X-Tenant für den Modellserver.
  • Pro Mandant ein Token-Bucket (x/time/rate), Metriken mit client_golang, Logs mit log/slog.
  • httputil.ReverseProxy macht das Proxying; Streams (stream=true) werden sofort durchgereicht.
  • Graceful Shutdown, damit laufende Generierungen beim Rollout nicht abreißen.
  • Ergebnis: ein statisches Binary in einem ca. 20 MB großen distroless-Image.
Client --Bearer lab-key-acme--> [auth -> rate limit -> proxy] --X-Tenant--> Modell
                                  |           |          |
                                 401         429   usage -> gateway_tokens_total

Drill 1: Modul anlegen

In Tag 3 lief die fertige Version aus ~/sre-lab/code/llm-gateway. Du baust sie jetzt daneben neu und vergleichst am Ende.

mkdir -p ~/sre-lab/tag04/llm-gateway && cd ~/sre-lab/tag04/llm-gateway
go mod init example.com/llm-gateway
go get github.com/prometheus/[email protected] golang.org/x/[email protected]

Erwartet (gekürzt):

go: creating new go.mod: module example.com/llm-gateway
go: github.com/prometheus/[email protected] requires go >= 1.26.0;
    switching to go1.26.9
go: upgraded go 1.25.5 => 1.26.0
go: added github.com/prometheus/client_golang v1.25.0
go: added golang.org/x/time v0.16.0

Warum? Versionen explizit pinnen; go.sum hält die Prüfsummen fest (Supply Chain, Tag 13). Mit GOTOOLCHAIN=auto (Default) lädt Go die nötige Toolchain selbst nach.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Konfiguration und Metriken

Die Imports enthalten schon alles für Drill 3 und 4; kompilieren kannst du deshalb erst am Ende von Drill 4.

cat > main.go <<'EOF'
// llm-gateway: mandantenfähiger Reverse Proxy vor einem OpenAI-kompatiblen
// Modellserver (Ollama, llama.cpp, vLLM). Lab-Code aus "LLM-Plattformen zum Anfassen".
package main

import (
    "bytes"
    "context"
    "encoding/json"
    "errors"
    "io"
    "log/slog"
    "net/http"
    "net/http/httputil"
    "net/url"
    "os"
    "os/signal"
    "strconv"
    "strings"
    "sync"
    "syscall"
    "time"

    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
    "golang.org/x/time/rate"
)

var (
    requests = prometheus.NewCounterVec(prometheus.CounterOpts{
        Name: "gateway_requests_total",
        Help: "Anfragen pro Mandant und Statuscode.",
    }, []string{"tenant", "code"})
    duration = prometheus.NewHistogramVec(prometheus.HistogramOpts{
        Name:    "gateway_request_duration_seconds",
        Help:    "Gesamtdauer einer Anfrage inkl. Modellserver.",
        Buckets: []float64{0.1, 0.25, 0.5, 1, 2, 5, 10, 20, 30, 60},
    }, []string{"tenant"})
    tokens = prometheus.NewCounterVec(prometheus.CounterOpts{
        Name: "gateway_tokens_total",
        Help: "Tokens laut usage-Feld der Antwort.",
    }, []string{"tenant", "type"})
    limited = prometheus.NewCounterVec(prometheus.CounterOpts{
        Name: "gateway_ratelimited_total",
        Help: "Wegen Rate-Limit abgewiesene Anfragen.",
    }, []string{"tenant"})
)

type ctxKey struct{}

// config liest alles aus Umgebungsvariablen (12-Factor).
type config struct {
    listen   string
    upstream *url.URL
    keys     map[string]string // API-Key -> Mandant
    rps      float64
    burst    int
}

func loadConfig() (config, error) {
    c := config{listen: env("LISTEN_ADDR", ":8080"), keys: map[string]string{}}
    u, err := url.Parse(env("UPSTREAM_URL", "http://127.0.0.1:11434"))
    if err != nil || u.Host == "" {
        return c, errors.New("UPSTREAM_URL ungültig")
    }
    c.upstream = u
    // TENANT_KEYS="acme:lab-key-acme,globex:lab-key-globex"
    for _, pair := range strings.Split(env("TENANT_KEYS", ""), ",") {
        tenant, key, ok := strings.Cut(strings.TrimSpace(pair), ":")
        if ok && tenant != "" && key != "" {
            c.keys[key] = tenant
        }
    }
    if len(c.keys) == 0 {
        return c, errors.New("TENANT_KEYS leer")
    }
    c.rps, err = strconv.ParseFloat(env("RATE_LIMIT_RPS", "5"), 64)
    if err != nil || c.rps <= 0 {
        return c, errors.New("RATE_LIMIT_RPS ungültig")
    }
    c.burst, err = strconv.Atoi(env("RATE_LIMIT_BURST", "10"))
    if err != nil || c.burst <= 0 {
        return c, errors.New("RATE_LIMIT_BURST ungültig")
    }
    return c, nil
}

func env(k, def string) string {
    if v := os.Getenv(k); v != "" {
        return v
    }
    return def
}

EOF

Warum? Alle Einstellungen aus Umgebungsvariablen (12-Factor) und harte Validierung beim Start: Ein Gateway mit RATE_LIMIT_RPS=0 soll gar nicht erst hochkommen. Die Histogramm-Buckets reichen bis 60 s – Default-Buckets enden bei 10 s und wären für LLM-Latenzen blind.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Rate-Limit, Proxy und Auth-Middleware

Token-Bucket pro Mandant und ein ResponseWriter, der den Statuscode mitschreibt:

cat >> main.go <<'EOF'
// limiters hält einen Token-Bucket pro Mandant.
type limiters struct {
    mu    sync.Mutex
    rps   rate.Limit
    burst int
    m     map[string]*rate.Limiter
}

func (l *limiters) get(tenant string) *rate.Limiter {
    l.mu.Lock()
    defer l.mu.Unlock()
    lim, ok := l.m[tenant]
    if !ok {
        lim = rate.NewLimiter(l.rps, l.burst)
        l.m[tenant] = lim
    }
    return lim
}

// statusRecorder merkt sich den Statuscode für Metriken und Logs.
type statusRecorder struct {
    http.ResponseWriter
    code int
}

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

// Flush reicht gestreamte Antworten (stream=true) sofort an den Client durch.
func (r *statusRecorder) Flush() {
    if f, ok := r.ResponseWriter.(http.Flusher); ok {
        f.Flush()
    }
}

EOF

Der Proxy. Rewrite (seit Go 1.20) ersetzt das alte Director und entfernt Hop-by-Hop-Header sicher:

cat >> main.go <<'EOF'
func newProxy(c config) *httputil.ReverseProxy {
    p := &httputil.ReverseProxy{
        Rewrite: func(pr *httputil.ProxyRequest) {
            pr.SetURL(c.upstream)
            pr.Out.Header.Del("Authorization") // Mandanten-Key nie an den Modellserver
            pr.Out.Header.Set("X-Tenant", pr.In.Context().Value(ctxKey{}).(string))
        },
        ModifyResponse: countTokens,
        ErrorHandler: func(w http.ResponseWriter, r *http.Request, err error) {
            slog.Error("upstream", "err", err)
            jsonError(w, "upstream unavailable", http.StatusBadGateway)
        },
    }
    return p
}

// countTokens liest usage.prompt_tokens/completion_tokens aus JSON-Antworten.
func countTokens(resp *http.Response) error {
    if !strings.HasPrefix(resp.Header.Get("Content-Type"), "application/json") {
        return nil // Streams (text/event-stream) werden nicht gepuffert
    }
    body, err := io.ReadAll(resp.Body)
    resp.Body.Close()
    if err != nil {
        return err
    }
    resp.Body = io.NopCloser(bytes.NewReader(body))
    var u struct {
        Usage struct {
            Prompt     int `json:"prompt_tokens"`
            Completion int `json:"completion_tokens"`
        } `json:"usage"`
    }
    if json.Unmarshal(body, &u) == nil {
        tenant := resp.Request.Context().Value(ctxKey{}).(string)
        tokens.WithLabelValues(tenant, "prompt").Add(float64(u.Usage.Prompt))
        tokens.WithLabelValues(tenant, "completion").Add(float64(u.Usage.Completion))
    }
    return nil
}

// jsonError antwortet wie OpenAI-kompatible APIs mit einem JSON-Fehlerobjekt.
func jsonError(w http.ResponseWriter, msg string, code int) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(code)
    json.NewEncoder(w).Encode(map[string]string{"error": msg})
}

EOF

Warum? countTokens puffert nur JSON-Antworten; SSE-Streams laufen ungepuffert durch, sonst sähe der Client die Tokens erst am Ende. Fehler kommen als JSON mit passendem Content-Type, wie bei OpenAI-kompatiblen APIs.

Die Middleware verbindet alles:

cat >> main.go <<'EOF'
func gateway(c config, lim *limiters, next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        key := strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer ")
        tenant, ok := c.keys[key]
        if !ok {
            requests.WithLabelValues("unknown", "401").Inc()
            jsonError(w, "invalid api key", http.StatusUnauthorized)
            return
        }
        if !lim.get(tenant).Allow() {
            limited.WithLabelValues(tenant).Inc()
            requests.WithLabelValues(tenant, "429").Inc()
            w.Header().Set("Retry-After", "1")
            jsonError(w, "rate limit", http.StatusTooManyRequests)
            return
        }
        start := time.Now()
        rec := &statusRecorder{ResponseWriter: w, code: http.StatusOK}
        ctx := context.WithValue(r.Context(), ctxKey{}, tenant)
        next.ServeHTTP(rec, r.WithContext(ctx))
        d := time.Since(start)
        duration.WithLabelValues(tenant).Observe(d.Seconds())
        requests.WithLabelValues(tenant, strconv.Itoa(rec.code)).Inc()
        slog.Info("request", "tenant", tenant, "method", r.Method, "path", r.URL.Path,
            "status", rec.code, "duration_ms", d.Milliseconds())
    })
}

EOF

Sicherheit: Der Mandant kommt ausschließlich aus dem Key. Ein vom Client mitgeschickter X-Tenant-Header wird im Rewrite mit Set überschrieben.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Probes, Router, Graceful Shutdown – und live

cat >> main.go <<'EOF'
// ready prüft, ob der Modellserver antwortet (GET /v1/models).
func ready(c config) http.HandlerFunc {
    client := &http.Client{Timeout: 2 * time.Second}
    return func(w http.ResponseWriter, r *http.Request) {
        resp, err := client.Get(c.upstream.JoinPath("/v1/models").String())
        if err != nil {
            http.Error(w, "upstream not ready", http.StatusServiceUnavailable)
            return
        }
        resp.Body.Close() // auch bei Status != 200 schließen, sonst Verbindungsleck
        if resp.StatusCode != http.StatusOK {
            http.Error(w, "upstream not ready", http.StatusServiceUnavailable)
            return
        }
        io.WriteString(w, "ok\n")
    }
}

func newMux(c config) *http.ServeMux {
    lim := &limiters{rps: rate.Limit(c.rps), burst: c.burst,
        m: map[string]*rate.Limiter{}}
    mux := http.NewServeMux()
    mux.Handle("/v1/", gateway(c, lim, newProxy(c)))
    mux.Handle("GET /metrics", promhttp.Handler())
    mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) {
        io.WriteString(w, "ok\n")
    })
    mux.HandleFunc("GET /readyz", ready(c))
    return mux
}

func main() {
    slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stdout, nil)))
    prometheus.MustRegister(requests, duration, tokens, limited)
    c, err := loadConfig()
    if err != nil {
        slog.Error("config", "err", err)
        os.Exit(1)
    }
    srv := &http.Server{
        Addr:              c.listen,
        Handler:           newMux(c),
        ReadHeaderTimeout: 5 * time.Second,
    }

    ctx, stop := signal.NotifyContext(context.Background(),
        syscall.SIGINT, syscall.SIGTERM)
    defer stop()
    go func() {
        slog.Info("listening", "addr", c.listen, "upstream", c.upstream.String(),
            "tenants", len(c.keys))
        err := srv.ListenAndServe()
        if err != nil && !errors.Is(err, http.ErrServerClosed) {
            slog.Error("listen", "err", err)
            os.Exit(1)
        }
    }()
    <-ctx.Done()
    // Graceful Shutdown: laufende Generierungen bis zu 30 s zu Ende bringen
    shutdownCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    slog.Info("shutting down")
    if err := srv.Shutdown(shutdownCtx); err != nil {
        slog.Error("shutdown", "err", err)
    }
}
EOF
go mod tidy
gofmt -l . ; go vet ./... && go build -o llm-gateway . && echo "build ok"

Erwartet:

build ok

Warum? go mod tidy trägt die indirekten Abhängigkeiten in go.mod/go.sum ein; ohne meldet go vet „missing go.sum entry”. /healthz sagt nur „Prozess lebt” (Liveness), /readyz prüft den Modellserver (Readiness). Würde Liveness den Upstream prüfen, startet Kubernetes bei einem Modellserver-Ausfall alle Gateways neu – ohne jeden Nutzen.

Terminal 0 – der Fake-Modellserver aus Tag 3 (Ollama mit echtem Mistral-Modell folgt in Tag 5):

python3 ~/sre-lab/code/llmctl/examples/fakellm.py

Terminal 1 (Keys sind Lab-Werte):

export UPSTREAM_URL=http://127.0.0.1:11434
TENANT_KEYS="acme:lab-key-acme,globex:lab-key-globex" ./llm-gateway

Terminal 2:

curl -si localhost:8080/v1/models | sed -n '1,2p;$p'
curl -s localhost:8080/v1/chat/completions -H 'Authorization: Bearer lab-key-acme' \
  -d '{"model":"mistral","max_tokens":10,
       "messages":[{"role":"user","content":"Sag nur: bonjour"}]}' \
  | jq -c '{c: .choices[0].message.content, u: .usage}'
seq 15 | xargs -P 15 -I{} curl -s -o /dev/null -w '%{http_code}\n' \
  -H 'Authorization: Bearer lab-key-acme' localhost:8080/v1/models | sort | uniq -c
curl -s localhost:8080/metrics | grep -E '^gateway_(requests|tokens|ratelimited)'

Erwartet (gekürzt, Zahlen variieren):

HTTP/1.1 401 Unauthorized
Content-Type: application/json
{"error":"invalid api key"}
{"c":"[fake] Sag nur: bonjour","u":{"prompt_tokens":3,"completion_tokens":10,
 "total_tokens":13}}
  10 200
   5 429
gateway_ratelimited_total{tenant="acme"} 5
gateway_requests_total{code="200",tenant="acme"} 11
gateway_requests_total{code="401",tenant="unknown"} 1
gateway_requests_total{code="429",tenant="acme"} 5
gateway_tokens_total{tenant="acme",type="completion"} 10
gateway_tokens_total{tenant="acme",type="prompt"} 3

Der Chat hat ein Token aus dem Burst von 10 verbraucht, nachgefüllt wird mit 5/s – ein Teil der 15 parallelen Anfragen kommt durch, der Rest bekommt 429 mit Retry-After: 1. Terminal 0 zeigt fake: tenant=acme auth=None – der Key kommt nie beim Modellserver an. Jetzt Upstream weg (Terminal 1: Ctrl-C, dann):

UPSTREAM_URL=http://127.0.0.1:1 TENANT_KEYS="acme:lab-key-acme" ./llm-gateway
curl -s -w ' %{http_code}\n' localhost:8080/healthz
curl -s -w ' %{http_code}\n' localhost:8080/readyz
curl -s -w ' %{http_code}\n' -H 'Authorization: Bearer lab-key-acme' \
  localhost:8080/v1/models

Erwartet:

ok
 200
upstream not ready
 503
{"error":"upstream unavailable"}
 502

Im Log von Terminal 1 steht der Grund: "msg":"upstream","err":"dial tcp 127.0.0.1:1: connect: connection refused". Beende das Gateway und starte es wieder normal.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Graceful Shutdown unter Last

Eine Generierung starten (der Fake braucht 50 ms pro Token, also 10 s) und dem Gateway währenddessen SIGTERM schicken – so wie Kubernetes beim Rollout:

curl -s -o /dev/null -w 'client: %{http_code} nach %{time_total}s\n' \
  localhost:8080/v1/chat/completions -H 'Authorization: Bearer lab-key-globex' \
  -d '{"model":"mistral","max_tokens":200,
       "messages":[{"role":"user","content":"Erzähle eine Geschichte."}]}' &
sleep 1; pkill -TERM -x llm-gateway
sleep 0.3; curl -s -m 2 localhost:8080/healthz; echo "neue Verbindung: exit $?"
wait

Erwartet (Terminal 2 und Log aus Terminal 1, gekürzt):

neue Verbindung: exit 7
client: 200 nach 10.004316s
{"time":"...:32.199976+02:00","level":"INFO","msg":"shutting down"}
{"time":"...:41.205073+02:00","level":"INFO","msg":"request","tenant":"globex",
 "method":"POST","path":"/v1/chat/completions","status":200,"duration_ms":10002}

Neue Verbindungen werden sofort abgelehnt (curl exit 7), die laufende Anfrage wird fertig. Dauert sie länger als die 30 s aus context.WithTimeout, reißt sie ab. Wiederhole den Versuch mit "max_tokens":700 (35 s):

client: 000 nach 31.010759s
{"time":"...:43.230094+02:00","level":"INFO","msg":"shutting down"}
{"time":"...:13.230874+02:00","level":"ERROR","msg":"shutdown",
 "err":"context deadline exceeded"}

Achtung: In Kubernetes muss terminationGracePeriodSeconds größer sein als dieser Timeout plus die längste erwartete Generierung (Tag 7).

Fortschritt speichern? Kostenlos registrieren

Drill 6: Tests mit httptest und Race Detector

cat > main_test.go <<'EOF'
package main

import (
    "io"
    "net/http"
    "net/http/httptest"
    "net/url"
    "strings"
    "sync"
    "testing"

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

// fakeModel spielt einen OpenAI-kompatiblen Modellserver.
func fakeModel(t *testing.T) *httptest.Server {
    h := func(w http.ResponseWriter, r *http.Request) {
        if r.Header.Get("Authorization") != "" {
            t.Error("Authorization darf nicht zum Upstream durchgereicht werden")
        }
        if r.Header.Get("X-Tenant") == "" && r.URL.Path != "/v1/models" {
            t.Error("X-Tenant fehlt")
        }
        w.Header().Set("Content-Type", "application/json")
        io.WriteString(w, `{"choices":[{"message":{"content":"hi"}}],`+
            `"usage":{"prompt_tokens":7,"completion_tokens":3}}`)
    }
    return httptest.NewServer(http.HandlerFunc(h))
}

func testConfig(up string, rps float64, burst int) config {
    u, _ := url.Parse(up)
    keys := map[string]string{"k-acme": "acme"}
    return config{upstream: u, keys: keys, rps: rps, burst: burst}
}

func post(h http.Handler, key string) *httptest.ResponseRecorder {
    body := strings.NewReader(`{}`)
    req := httptest.NewRequest("POST", "/v1/chat/completions", body)
    req.Header.Set("Authorization", "Bearer "+key)
    rec := httptest.NewRecorder()
    h.ServeHTTP(rec, req)
    return rec
}

func TestLoadConfig(t *testing.T) {
    type kv = map[string]string
    tests := []struct {
        name    string
        env     kv
        wantErr bool
    }{
        {"ok", kv{"TENANT_KEYS": "acme:k1,globex:k2"}, false},
        {"keine Keys", kv{}, true},
        {"kaputtes Paar", kv{"TENANT_KEYS": "acme"}, true},
        {"rps null", kv{"TENANT_KEYS": "a:k", "RATE_LIMIT_RPS": "0"}, true},
        {"burst text", kv{"TENANT_KEYS": "a:k", "RATE_LIMIT_BURST": "x"}, true},
        {"ohne host", kv{"TENANT_KEYS": "a:k", "UPSTREAM_URL": "ollama:11434"}, true},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            for _, k := range []string{"TENANT_KEYS", "RATE_LIMIT_RPS",
                "RATE_LIMIT_BURST", "UPSTREAM_URL"} {
                t.Setenv(k, tt.env[k]) // leer = Default
            }
            _, err := loadConfig()
            if (err != nil) != tt.wantErr {
                t.Fatalf("err = %v, wantErr %v", err, tt.wantErr)
            }
        })
    }
}

func TestUnknownKey(t *testing.T) {
    up := fakeModel(t)
    defer up.Close()
    rec := post(newMux(testConfig(up.URL, 5, 5)), "falsch")
    if rec.Code != 401 {
        t.Fatalf("Status = %d, erwartet 401", rec.Code)
    }
    if ct := rec.Header().Get("Content-Type"); ct != "application/json" {
        t.Fatalf("Content-Type = %q, erwartet application/json", ct)
    }
}

func TestProxyCountsTokens(t *testing.T) {
    up := fakeModel(t)
    defer up.Close()
    completion := tokens.WithLabelValues("acme", "completion")
    before := testutil.ToFloat64(completion)
    if got := post(newMux(testConfig(up.URL, 5, 5)), "k-acme").Code; got != 200 {
        t.Fatalf("Status = %d, erwartet 200", got)
    }
    if d := testutil.ToFloat64(completion) - before; d != 3 {
        t.Fatalf("completion tokens = %v, erwartet 3", d)
    }
}

func TestRateLimit(t *testing.T) {
    up := fakeModel(t)
    defer up.Close()
    h := newMux(testConfig(up.URL, 1, 2))
    codes := []int{post(h, "k-acme").Code, post(h, "k-acme").Code,
        post(h, "k-acme").Code}
    if codes[2] != 429 {
        t.Fatalf("Codes = %v, dritte Anfrage sollte 429 sein", codes)
    }
}

// TestConcurrentTenants ist für "go test -race" da: viele Mandanten gleichzeitig.
func TestConcurrentTenants(t *testing.T) {
    up := fakeModel(t)
    defer up.Close()
    c := testConfig(up.URL, 100, 100)
    c.keys = map[string]string{"k-a": "a", "k-b": "b", "k-c": "c", "k-d": "d"}
    h := newMux(c)
    var wg sync.WaitGroup
    for i := range 40 {
        wg.Go(func() { post(h, []string{"k-a", "k-b", "k-c", "k-d"}[i%4]) })
    }
    wg.Wait()
}

func TestReadyz(t *testing.T) {
    up := fakeModel(t)
    h := newMux(testConfig(up.URL, 5, 5))
    get := func() int {
        rec := httptest.NewRecorder()
        h.ServeHTTP(rec, httptest.NewRequest("GET", "/readyz", nil))
        return rec.Code
    }
    if got := get(); got != 200 {
        t.Fatalf("readyz = %d, erwartet 200", got)
    }
    up.Close() // Modellserver weg -> nicht mehr ready
    if got := get(); got != 503 {
        t.Fatalf("readyz = %d, erwartet 503", got)
    }
}
EOF
go mod tidy   # testutil zieht weitere Abhängigkeiten nach
go test -race -count=1 -v ./... 2>&1 | grep -E '^(--- |ok|FAIL)'
go test -count=1 -cover ./...

Erwartet (gekürzt):

--- PASS: TestLoadConfig (0.00s)
--- PASS: TestUnknownKey (0.00s)
--- PASS: TestProxyCountsTokens (0.00s)
--- PASS: TestRateLimit (0.00s)
--- PASS: TestConcurrentTenants (0.01s)
--- PASS: TestReadyz (0.00s)
ok      example.com/llm-gateway 1.303s
ok      example.com/llm-gateway 0.257s  coverage: 74.1% of statements

Warum? httptest.NewServer spielt den Modellserver, httptest.NewRecorder den Client – kein Netzwerk, keine Ports. Die Tabelle in TestLoadConfig macht neue Fehlerfälle zu einer Zeile. t.Setenv setzt Umgebungsvariablen nur für diesen Test.

Jetzt den Race Detector arbeiten sehen. Mutex im Limiter auskommentieren:

sed -i.bak -e 's|^\tl.mu.Lock()|\t// l.mu.Lock()|' \
  -e 's|^\tdefer l.mu.Unlock()|\t// defer l.mu.Unlock()|' main.go
go test -race -count=1 -run Concurrent ./... 2>&1 \
  | grep -E 'WARNING|race detected|^FAIL' | sort | uniq -c
mv main.go.bak main.go

Erwartet (Anzahl variiert):

   1     testing.go:1712: race detected during execution of test
   2 FAIL
   1 FAIL   example.com/llm-gateway 0.230s
   3 WARNING: DATA RACE

Ohne -race wäre der Test vermutlich grün – oder der Prozess stirbt irgendwann in Produktion mit concurrent map writes.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Container – distroless und nonroot

cat > Dockerfile <<'EOF'
FROM golang:1.26 AS build
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY *.go ./
RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /llm-gateway .

FROM gcr.io/distroless/static-debian12:nonroot
COPY --from=build /llm-gateway /llm-gateway
EXPOSE 8080
USER nonroot:nonroot
ENTRYPOINT ["/llm-gateway"]
EOF
docker build -t llm-gateway:dev .
docker images llm-gateway:dev
docker image inspect llm-gateway:dev --format '{{.Config.User}}'

Erwartet (gekürzt):

IMAGE             ID             DISK USAGE   CONTENT SIZE   EXTRA
llm-gateway:dev   5b05a1eb9a58       18.6MB         4.25MB
nonroot:nonroot

Warum? CGO_ENABLED=0 erzeugt ein statisches Binary, das ohne libc läuft; -trimpath -ldflags="-s -w" entfernt lokale Pfade und Debug-Symbole. Das distroless-Image enthält keine Shell und keinen Paketmanager – weniger CVEs, weniger Angriffsfläche.

Beende das Gateway in Terminal 1 (Port 8080 wird frei), dann:

docker run -d --name gw -p 8080:8080 \
  --add-host=host.docker.internal:host-gateway \
  -e UPSTREAM_URL=http://host.docker.internal:11434 \
  -e TENANT_KEYS="acme:lab-key-acme,globex:lab-key-globex" llm-gateway:dev
curl -s localhost:8080/readyz
docker exec gw sh -c id
docker stop gw && docker logs gw 2>&1 | tail -1
docker rm gw

Erwartet (gekürzt):

ok
OCI runtime exec failed: exec failed: unable to start container process:
exec: "sh": executable file not found in $PATH
gw
{"time":"...","level":"INFO","msg":"shutting down"}
gw

Keine Shell im Container: Debugging läuft über Logs, Metriken und kubectl debug mit Ephemeral Container (Tag 7).

Achtung: Auf Linux erreicht der Container den Host über die Bridge-IP, nicht über 127.0.0.1. Starte den Fake dort mit FAKE_HOST=0.0.0.0 (nur im Lab).

Fortschritt speichern? Kostenlos registrieren

Drill 8: pprof als Debugging-Werkzeug

pprof gehört nicht ins Produktions-Binary auf einen offenen Port. Ein Build-Tag schaltet es nur bei Bedarf ein (Terminal 1, Upstream ist weiter der Fake):

cat > pprof.go <<'EOF'
//go:build pprof

package main

import (
    "log/slog"
    "net/http"
    _ "net/http/pprof" // registriert /debug/pprof/* am DefaultServeMux
)

// Nur mit "go build -tags pprof": Profiling auf eigenem, lokalem Port.
// Das Gateway nutzt eine eigene ServeMux, /debug/pprof ist dort nicht erreichbar.
func init() {
    go func() {
        slog.Info("pprof", "addr", "127.0.0.1:6060")
        err := http.ListenAndServe("127.0.0.1:6060", nil)
        slog.Error("pprof", "err", err)
    }()
}
EOF
go build -tags pprof -o gw-pprof .
RATE_LIMIT_RPS=100000 RATE_LIMIT_BURST=100000 \
  TENANT_KEYS="acme:lab-key-acme" ./gw-pprof

Terminal 2 – Last erzeugen (ab aus apache2-utils, auf macOS vorinstalliert) und 3 s CPU profilen. Auf Linux zählst du TIME_WAIT mit ss -tan state time-wait | grep -c 11434.

curl -s -o /dev/null -w '%{http_code}\n' localhost:8080/debug/pprof/
ab -q -t 5 -n 1000000 -c 20 -H 'Authorization: Bearer lab-key-acme' \
  http://127.0.0.1:8080/v1/models > ab.out &
sleep 1
curl -s 'http://127.0.0.1:6060/debug/pprof/goroutine?debug=1' | head -1
go tool pprof -top -cum -nodecount=12 \
  'http://127.0.0.1:6060/debug/pprof/profile?seconds=3'
netstat -an | grep 11434 | grep -c TIME_WAIT
wait; grep -E 'apr_|Total of|Complete|Failed|Requests per|99%' ab.out

Erwartet (gekürzt, Werte hängen von deiner Hardware ab):

404
goroutine profile: total 6353
Duration: 3.01s, Total samples = 2.64s (87.82%)
      flat  flat%   sum%        cum   cum%
     1.46s 55.30% 55.30%      1.46s 55.30%  syscall.rawsyscalln
         0     0% 55.30%      0.65s 24.62%  net/http.(*conn).serve
         0     0% 56.06%      0.49s 18.56%  net/http.(*Transport).dialConnFor
         0     0% 56.06%      0.46s 17.42%  net.(*Dialer).DialContext
9285
Benchmarking 127.0.0.1 (be patient)...apr_socket_recv: Operation timed out (60)
Total of 25995 requests completed

Warum? 404 auf Port 8080 beweist: pprof hängt nur am lokalen Port 6060. Der Befund: über 6000 Goroutines, 17 % der CPU in DialContext und über 9000 Sockets in TIME_WAIT – das Gateway baut für fast jede Anfrage eine neue Verbindung zum Modellserver auf. Nach rund 26 000 Anfragen sind die lokalen Ports erschöpft und ab bricht ab. Das ist deine Challenge.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
cd ~/sre-lab/tag04/llm-gateway
check "gofmt sauber" "test -z \"\$(gofmt -l .)\""
check "go vet" "go vet ./... && go vet -tags pprof ./..."
check "Tests mit -race" "go test -race -count=1 ./..."
check "identisch mit Referenz" \
  "diff -q main.go ~/sre-lab/code/llm-gateway/main.go"
check "Image gebaut" "docker image inspect llm-gateway:dev"
check "Image läuft als nonroot" \
  "docker image inspect llm-gateway:dev --format '{{.Config.User}}' | grep -q nonroot"
check "Gateway ready" "curl -sf localhost:8080/readyz"
check "Metriken da" "curl -s localhost:8080/metrics | grep -q gateway_requests_total"

Erwartet (Gateway in Terminal 1 läuft):

✔ gofmt sauber
✔ go vet
✔ Tests mit -race
✔ identisch mit Referenz
✔ Image gebaut
✔ Image läuft als nonroot
✔ Gateway ready
✔ Metriken da

Challenge

Beseitige den DialContext-Hotspot aus Drill 8 und belege die Wirkung mit einem zweiten Profil und den ab-Zahlen.

Hinweis: Der ReverseProxy nutzt ohne eigenen Transport das http.DefaultTransport – schau dir dessen MaxIdleConnsPerHost an.

Lösung

http.DefaultTransport hält nur 2 Leerlauf-Verbindungen pro Host (DefaultMaxIdleConnsPerHost); bei 20 parallelen Clients wird fast jede Verbindung nach Gebrauch geschlossen. In newProxy einen eigenen Transport setzen:

func newProxy(c config) *httputil.ReverseProxy {
    t := http.DefaultTransport.(*http.Transport).Clone()
    t.MaxIdleConnsPerHost = 100 // Default 2: ständig neue Verbindungen
    p := &httputil.ReverseProxy{
        Transport: t,
        Rewrite: func(pr *httputil.ProxyRequest) {
        // ... Rest unverändert
go test -race -count=1 ./... && go build -tags pprof -o gw-pprof .
# gw-pprof neu starten, TIME_WAIT abklingen lassen, dann Last + Profil wie in Drill 8

Erwartet (gekürzt, Werte hängen von deiner Hardware ab):

ok      example.com/llm-gateway 1.351s
...
goroutine profile: total 172
Duration: 3.10s, Total samples = 6.74s (217.20%)
         0     0% 53.12%      2.30s 34.12%  net/http.(*conn).serve
0
Complete requests:      67634
Failed requests:        0
Requests per second:    13526.80 [#/sec] (mean)
  99%      5

Kein DialContext mehr unter den Top-Einträgen, 172 statt 6353 Goroutines, kein TIME_WAIT zum Upstream, und ab läuft durch. Clone() übernimmt Proxy-Einstellungen aus der Umgebung und die Timeouts des Default-Transports. Bei echten LLM-Anfragen (Sekunden statt Millisekunden) ist der Effekt kleiner, aber bei vielen kurzen Anfragen wie /v1/models, Embeddings oder Health-Checks genau so real.

Fortschritt speichern? Kostenlos registrieren

Interview-Notiz

  • „Wie baust du einen Proxy vor einem Modellserver?” – ReverseProxy mit Rewrite, Auth und Rate-Limit als Middleware, Streams nie puffern, Fehler als JSON, Readiness getrennt von Liveness.
  • Rate-Limit pro Mandant als Token-Bucket: Burst für interaktive Nutzer, Dauerrate schützt die GPU. Bei mehreren Replikas ist das Limit pro Pod – global braucht es Redis oder Envoy.
  • Graceful Shutdown ist bei LLMs kein Detail: Eine abgebrochene 30-s-Generierung ist ein sichtbarer Fehler und verbrannte GPU-Zeit.
  • Brücke: „Bei OpenShift-Kunden haben wir Vault-Agents und Sidecars mit Readiness-Gates und PreStop-Hooks ausgerollt – dieselbe Disziplin brauchst du für Inference-Gateways.”
  • Wann Python, wann Go? Kurz begründen können:
Kriterium Python Go
Typischer Einsatz CLIs, Automatisierung, Eval/Analyse Proxies, Controller, Daemons
Auslieferung Wheel + Interpreter (pipx, venv) ein statisches Binary, distroless
Nebenläufigkeit asyncio, gut für I/O Goroutines, I/O und CPU
Ökosystem LLM SDKs, Tokenizer, vLLM-Tools Kubernetes, Prometheus, Envoy-Umfeld

Enterprise-Notiz

  • API-Keys nicht im Klartext als Env-Variable: aus Secret bzw. OpenBao laden, gehasht vergleichen und rotieren können (Tag 13).
  • TLS bis zum Modellserver (mTLS oder Service Mesh); Kunden mit eigener CA brauchen konfigurierbare Trust Stores.
  • Regulierte Kunden fragen nach FIPS: Go bringt ein FIPS-140-3-Modul mit (GOFIPS140), vorher mit dem Kunden die Zertifizierungsanforderung klären.
  • pprof nur per Build-Tag oder hinter Auth und nur auf localhost; Zugriff im Cluster über kubectl port-forward.
  • Image signieren, SBOM anhängen, Basis-Image-Digest pinnen (Tag 13); Air-Gap-Kunden bekommen das Image als Tarball (Tag 14).