Tag 4: Go für SRE – llm-gateway
Ziel: Den mandantenfähigen Reverse Proxy
llm-gatewayselbst 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-Tenantfür den Modellserver. - Pro Mandant ein Token-Bucket (
x/time/rate), Metriken mitclient_golang, Logs mitlog/slog. httputil.ReverseProxymacht 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
}
EOFWarum? 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()
}
}
EOFDer 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})
}
EOFWarum? 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())
})
}
EOFSicherheit: Der Mandant kommt ausschließlich aus dem Key. Ein vom Client mitgeschickter
X-Tenant-Header wird imRewritemitSetü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.pyTerminal 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-gatewayTerminal 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-gatewaycurl -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/modelsErwartet:
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 $?"
waitErwartet (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
terminationGracePeriodSecondsgröß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.goErwartet (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 gwErwartet (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 mitFAKE_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-pprofTerminal 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.outErwartet (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ändertgo 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 8Erwartet (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?” –
ReverseProxymitRewrite, 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).