PricingLoginStart free
Go Academy · Lektion

Middleware für Authentifizierung und Rate Limiting

JWT-Validierung und Rate Limiting mit Token-Bucket

Lektion 3 von 413 Schritte

Middleware für Authentifizierung und Rate Limiting ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

JWT-Authentifizierungs-Middleware

Ein JWT aus dem Authorization-Header extrahieren, parsen und validieren:

func JWTAuth(secret []byte) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            header := r.Header.Get("Authorization")
            if !strings.HasPrefix(header, "Bearer ") {
                http.Error(w, "missing token", 401); return
            }
            token := strings.TrimPrefix(header, "Bearer ")
            claims, err := parseJWT(token, secret)
            if err != nil {
                http.Error(w, "invalid token", 401); return
            }
            ctx := context.WithValue(r.Context(), claimsKey{}, claims)
            next.ServeHTTP(w, r.WithContext(ctx))
        })
    }
}

API-Key-Authentifizierung

Einen API-Key aus einem Header anhand einer Datenbank oder einer im Speicher gehaltenen Menge validieren:

func APIKeyAuth(validKeys map[string]bool) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            key := r.Header.Get("X-API-Key")
            if !validKeys[key] {
                http.Error(w, "forbidden", 403); return
            }
            next.ServeHTTP(w, r)
        })
    }
}

Token-Bucket-Rate-Limiter

golang.org/x/time/rate mit einer Rate-Limiter-Map pro IP-Adresse verwenden:

var limiters sync.Map

func getLimiter(ip string) *rate.Limiter {
    v, _ := limiters.LoadOrStore(ip, rate.NewLimiter(rate.Every(time.Second), 10))
    return v.(*rate.Limiter)
}

Rate-Limiting-Middleware

Den Limiter in der Middleware prüfen und bei Überschreitung des Limits 429 zurückgeben:

func RateLimit(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ip, _, _ := net.SplitHostPort(r.RemoteAddr)
        if !getLimiter(ip).Allow() {
            http.Error(w, "rate limit exceeded", 429); return
        }
        next.ServeHTTP(w, r)
    })
}

Retry-After-Header

Einen Retry-After-Header mit der Anzahl der Sekunden mitsenden, die der Client vor einem erneuten Versuch warten sollte:

w.Header().Set("Retry-After", "1")
http.Error(w, "rate limit exceeded", 429)

Rollenbasierte Zugriffskontrolle

Nach der Authentifizierung die Rollen des Benutzers aus den Context-Claims prüfen, bevor Next aufgerufen wird:

func RequireRole(role string) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            claims := claimsFromContext(r.Context())
            if !claims.HasRole(role) {
                http.Error(w, "forbidden", 403); return
            }
            next.ServeHTTP(w, r)
        })
    }
}

Aufräumen des Limiters

Alte Limiter pro IP-Adresse sammeln sich im Speicher an. Entfernen Sie sie mit einer Hintergrund-Goroutine, die Einträge löscht, auf die in den letzten N Minuten nicht zugegriffen wurde.

Verteiltes Rate Limiting

Limiter innerhalb eines Prozesses funktionieren nicht über mehrere Instanzen hinweg. Verwenden Sie Redis zusammen mit einem Sliding-Window- oder Token-Bucket-Skript für verteiltes Rate Limiting.

429 vs 503

Geben Sie 429 Too Many Requests zurück, wenn das Rate Limit des einzelnen Clients erreicht ist. Geben Sie 503 Service Unavailable zurück, wenn der gesamte Dienst überlastet ist und Last abweist.

Authentifizierung und Rate Limiting kombinieren

Wenden Sie beide als separate Middleware in der Kette an. Authentifizierung zuerst: Begrenzen Sie nur authentifizierte Benutzer, damit Sie anhand der Benutzer-ID statt der IP-Adresse unterscheiden können.

Authentifizierungs-Middleware testen

Verwenden Sie httptest, um gültige und ungültige Tokens zu übergeben, und prüfen Sie, ob die richtigen Statuscodes zurückgegeben und die Context-Werte gesetzt werden.

Kurzer Check

Welchen HTTP-Statuscode sollte eine Rate-Limiting-Middleware zurückgeben, wenn ein Client sein Limit überschreitet?

Beantworte es in der interaktiven Lektion

Zusammenfassung: Authentifizierung und Rate Limiting

Wichtige Punkte:

  • JWT-Middleware: Bearer-Token extrahieren → parsen → Claims im Context ablegen
  • Rate Limiting mit golang.org/x/time/rate pro IP-Adresse oder Benutzer
  • Bei überschrittenem Limit 429 und einen Retry-After-Header zurückgeben
  • Verteilt: Redis für Rate Limiting über mehrere Instanzen verwenden
Kostenlos starten

Lerne Go mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse
51
Lektionen
203
Kostenlos lernenDen vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Middleware für Authentifizierung und Rate Limiting“ kostenlos?

Ja — der vollständige Text von „Middleware für Authentifizierung und Rate Limiting“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Middleware für Authentifizierung und Rate Limiting“?

JWT-Validierung und Rate Limiting mit Token-Bucket Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Go Academy zu starten?

Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Middleware für Authentifizierung und Rate Limiting“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?

Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Grundlagen der HTTP-Middleware-Kette
  2. Logging- und Request-ID-Middleware
  3. Middleware für Authentifizierung und Rate Limiting
  4. CORS- und Panic-Recovery-Middleware
← Zurück zu Go Academy