0Pricing
Go Academy · Lekcja

Middleware uwierzytelniania i limitowania ruchu

Weryfikacja JWT i limitowanie ruchu metodą token bucket

Middleware uwierzytelniania i limitowania ruchu to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Go Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Go Academy zawiera 4 lekcji w sumie.

Middleware uwierzytelniania JWT

Należy wyodrębnić, sparsować i zweryfikować JWT z nagłówka Authorization:

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))
        })
    }
}

Uwierzytelnianie za pomocą klucza API

Należy zweryfikować klucz API z nagłówka względem bazy danych lub zbioru przechowywanego w pamięci:

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)
        })
    }
}

Ogranicznik częstotliwości żądań typu token bucket

Należy użyć golang.org/x/time/rate wraz z mapą ograniczników dla poszczególnych adresów IP:

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)
}

Middleware ograniczania częstotliwości żądań

Należy sprawdzać ogranicznik w middleware i zwracać 429 po przekroczeniu limitu:

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)
    })
}

Nagłówek Retry-After

Należy dołączyć nagłówek Retry-After z liczbą sekund, przez które klient powinien zaczekać przed ponowieniem próby:

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

Kontrola dostępu oparta na rolach

Po uwierzytelnieniu należy sprawdzić role użytkownika w claims kontekstu przed wywołaniem Next:

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)
        })
    }
}

Czyszczenie ograniczników

Stare ograniczniki dla poszczególnych adresów IP gromadzą się w pamięci. Należy je czyścić za pomocą działającej w tle goroutine, która usuwa wpisy, do których nie uzyskano dostępu w ciągu ostatnich N minut.

Rozproszone ograniczanie częstotliwości żądań

Ograniczniki działające w procesie nie działają w wielu instancjach. W celu rozproszonego ograniczania częstotliwości żądań należy użyć Redis oraz skryptu implementującego przesuwne okno lub algorytm token bucket.

429 vs 503

Należy zwracać 429 Too Many Requests, gdy limitowi podlega pojedynczy klient. Należy zwracać 503 Service Unavailable, gdy cała usługa jest przeciążona i ogranicza obciążenie.

Łączenie uwierzytelniania i ograniczania częstotliwości żądań

Należy zastosować je jako osobne middleware w łańcuchu. Najpierw uwierzytelnianie: ograniczać częstotliwość żądań tylko uwierzytelnionych użytkowników, aby różnicować ich na podstawie identyfikatora użytkownika, a nie adresu IP.

Testowanie middleware uwierzytelniania

Należy użyć httptest do przekazania prawidłowych i nieprawidłowych tokenów oraz sprawdzić, czy zwracane są właściwe kody statusu i ustawiane są odpowiednie wartości w kontekście.

Szybkie sprawdzenie

Jaki kod statusu HTTP powinno zwracać middleware ograniczania częstotliwości żądań po przekroczeniu limitu przez klienta?

Podsumowanie: uwierzytelnianie i ograniczanie częstotliwości żądań

Najważniejsze informacje:

  • Middleware JWT: wyodrębnić token Bearer → sparsować → dołączyć claims do kontekstu
  • Ograniczać częstotliwość żądań za pomocą golang.org/x/time/rate według adresu IP lub użytkownika
  • Po przekroczeniu limitu zwracać 429 + nagłówek Retry-After
  • W środowisku rozproszonym używać Redis do ograniczania częstotliwości żądań w wielu instancjach

Często zadawane pytania

Czy lekcja „Middleware uwierzytelniania i limitowania ruchu” jest bezpłatna?

Tak — pełny tekst „Middleware uwierzytelniania i limitowania ruchu” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Go Academy, przejdź na CoddyKit PRO. Kurs Go Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Middleware uwierzytelniania i limitowania ruchu”?

Weryfikacja JWT i limitowanie ruchu metodą token bucket Ćwiczysz Go Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Go Academy?

Nie wymagamy żadnego doświadczenia. Go Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Middleware uwierzytelniania i limitowania ruchu”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Go Academy?

Tak. Każda lekcja Go Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Podstawy łańcucha middleware HTTP
  2. Middleware logowania i identyfikatora żądania
  3. Middleware uwierzytelniania i limitowania ruchu
  4. Middleware CORS i odzyskiwania po panic
← Powrót do Go Academy