Szybka odpowiedź: jak wdrożyć rate limiting w Next.js z Upstash?
Upstash Redis z @upstash/ratelimit działa w Node.js i daje wspólny magazyn, którego serverless nie zapewni w pamięci.
Sliding window to domyślny algorytm, fixed window to prostsza opcja, a token bucket obsłuży nagłe skoki ruchu.
Limity dobieraj do endpointu, łagodne dla odczytu i surowe dla uwierzytelniania.
Pokazany matcher /api/:path* nie obejmuje akcji wywoływanych na adresach stron, więc tam limit sprawdzasz osobno.
Zalogowanych identyfikuj po ID, a anonimowych po IP z zaufanego proxy, bo x-forwarded-for bywa fałszowany.
Po co rate limiting w aplikacji Next.js?
Bez , czyli ograniczania liczby żądań, każdy wyśle do Twojego API tyle zapytań, ile zechce: celowo (brute force, prosty flood) albo zupełnie przypadkiem (scraper, pętla z błędem). Serwer się dławi, rachunek rośnie, a użytkownik dostaje błąd. Limit z jednego źródła w oknie czasu ogranicza ten scenariusz. To jedno z podstawowych zabezpieczeń aplikacji, obok ochrony przed CSRF, XSS i injection, o których pisałem osobno. Nie zastępuje jednak ani ochrony przed .
W Next.js możesz połączyć ogólny limit w lub z dokładniejszym limitem bezpośrednio w albo . Nie jest to obowiązkowe połączenie, bo dwa limitery oznaczają dwa budżety, większy koszt i potencjalnie dwie operacje sieciowe. Ochronę wolumetryczną najlepiej zatrzymywać przed aplikacją, a Upstash wykorzystywać do limitów biznesowych per użytkownik, konto lub endpoint.
Upstash Redis i rate limiting w Node.js
to serverless Redis z HTTP API — aplikacja Node.js/serverless nie musi utrzymywać stałego połączenia Redis TCP. Zgodność SDK z innymi środowiskami edge nie oznacza wsparcia dla przestarzałego w aktualnym Next.js. Pakiet
@upstash/ratelimit daje gotowe algorytmy rate limitingu.
// lib/rate-limit.tsimport { Ratelimit } from '@upstash/ratelimit'import { Redis } from '@upstash/redis'export const redis = Redis.fromEnv()// Algorytm sliding window — 10 requestów na 10 sekundexport const rateLimiter = new Ratelimit({ redis, limiter: Ratelimit.slidingWindow(10, '10 s'), analytics: true, prefix: '@app/ratelimit', // Wbudowany timeout jest fail-open; wynik ma wtedy reason: 'timeout'. timeout: 1000, // Lokalny cache w pamięci instancji — odsiewa źródła już // zablokowane bez odpytywania Redisa, mniej operacji i niższy koszt ephemeralCache: new Map(),})// Osobny limiter dla auth — 5 prób na minutęexport const authRateLimiter = new Ratelimit({ redis, limiter: Ratelimit.slidingWindow(5, '1 m'), prefix: '@app/auth-ratelimit', timeout: 1000,})// Łagodniejszy limiter dla ogólnych stron — 60 req/minexport const pageRateLimiter = new Ratelimit({ redis, limiter: Ratelimit.slidingWindow(60, '1 m'), prefix: '@app/page-ratelimit',})
ephemeralCache jest domyślnie włączony; jawny Map w przykładzie pokazuje, że cache powinien powstać poza handlerem i przetrwać kolejne wywołania tej samej ciepłej instancji. Cache przechowuje tylko identyfikatory, które już przekroczyły limit. Nie synchronizuje stanu między instancjami i nie zmienia decyzji zapisanej w Redisie.
analytics: true wykonuje dodatkową komendę i zapisuje identyfikatory używane przez limiter. Jeżeli są nimi adresy IP lub ID użytkowników, uwzględnij retencję, podstawę prawną i dostęp do danych albo wyłącz analytics. Token REST jest sekretem serwerowym — nie używaj prefiksu NEXT_PUBLIC_ i nie umieszczaj go w logach.
Proxy z rate limitingiem w Next.js
Code
// proxy.ts — w Next.js 16 działa w runtime Node.jsimport { NextResponse, type NextFetchEvent, type NextRequest,} from 'next/server'import { rateLimiter, authRateLimiter } from '@/lib/rate-limit'import { getTrustedClientIp } from '@/lib/client-ip'export async function proxy(request: NextRequest, event: NextFetchEvent) { const { pathname } = request.nextUrl // Rate limiting dla API if (pathname.startsWith('/api')) { const isSensitive = pathname.startsWith('/api/auth') const limiter = isSensitive ? authRateLimiter : rateLimiter const ip = getTrustedClientIp(request.headers) if (!ip) { console.error('Brak zaufanego adresu klienta dla rate limitingu') return isSensitive ? NextResponse.json( { error: 'Usługa chwilowo niedostępna' }, { status: 503, headers: { 'Cache-Control': 'no-store' } }, ) : NextResponse.next() } const identifier = `${isSensitive ? 'auth' : 'api'}:${ip}` try { const { success, limit, remaining, reset, pending, reason } = await limiter.limit(identifier) // pending obejmuje m.in. zapis analytics; nie blokuje odpowiedzi. event.waitUntil(pending.catch(() => console.error('Błąd zadania w tle limitera'))) // Timeout SDK jest domyślnie fail-open; decyzję podejmujemy jawnie. if (reason === 'timeout') { console.error('Timeout limitera w Proxy') return isSensitive ? NextResponse.json( { error: 'Usługa chwilowo niedostępna' }, { status: 503, headers: { 'Retry-After': '1', 'Cache-Control': 'no-store' } }, ) : NextResponse.next() } const retryAfter = Math.max(1, Math.ceil((reset - Date.now()) / 1000)) if (!success) { return NextResponse.json( { error: 'Zbyt wiele żądań', message: `Spróbuj ponownie za ${retryAfter} sekund.`, }, { status: 429, headers: { 'RateLimit-Limit': limit.toString(), 'RateLimit-Remaining': remaining.toString(), 'RateLimit-Reset': retryAfter.toString(), 'Retry-After': retryAfter.toString(), 'Cache-Control': 'no-store', }, }, ) } const response = NextResponse.next() response.headers.set('RateLimit-Limit', limit.toString()) response.headers.set('RateLimit-Remaining', remaining.toString()) response.headers.set('RateLimit-Reset', retryAfter.toString()) return response } catch (error) { console.error('Rate limiter niedostępny', { error, pathname }) return isSensitive ? NextResponse.json( { error: 'Usługa chwilowo niedostępna' }, { status: 503, headers: { 'Cache-Control': 'no-store' } }, ) : NextResponse.next() } } return NextResponse.next()}export const config = { matcher: ['/api/:path*'],}
Pola RateLimit-* są szeroko stosowaną konwencją, ale ich dokładny kontrakt powinien być udokumentowany dla klientów API. W przykładzie RateLimit-Reset i Retry-After oznaczają liczbę sekund do ponownej próby; nie przekazuj bez opisu wartości reset z Upstash, bo jest timestampem w milisekundach. Zwracaj 429 tylko wtedy, gdy limit faktycznie został przekroczony. Awaria zależności zasługuje na 503.
Algorytmy rate limitingu: fixed window, sliding window i token bucket
Upstash oferuje trzy algorytmy:
Fixed window w rate limitingu
to stałe okno czasu, np. 10 żądań na
minutę. Licznik resetuje się co minutę. Problem pojawia się na granicy okien:
użytkownik może wysłać 20 żądań w 2 sekundy, czyli 10 na końcu starego okna i 10
na początku nowego.
Code
Ratelimit.fixedWindow(10, '1 m')
Sliding window w rate limitingu
wygładza problem granicy okien.
Implementacja Upstash wylicza przybliżenie na podstawie bieżącego i poprzedniego
okna, zamiast zapisywać timestamp każdego żądania. Jest dokładniejsza od fixed
window, ale wykonuje więcej operacji i nadal może zwrócić wynik przybliżony. W
konfiguracji multi-region dodatkowe komendy zwiększają też opóźnienie.
Code
Ratelimit.slidingWindow(10, '10 s')
Token bucket w rate limitingu
W algorytmie tokeny odnawiają się w ustalonym tempie, a każde żądanie zużywa 1 token. Pozwala to na krótką serię żądań do pojemności bucketa, a następnie ogranicza ruch zgodnie z tempem uzupełniania. W poniższym przykładzie przybywa 10 tokenów na sekundę, a bucket mieści maksymalnie 30.
Code
Ratelimit.tokenBucket(10, '1 s', 30) // 10 tokenów/s, max 30 w buckecie
Rekomenduje sliding window dla większości API, token bucket dla endpointów, gdzie chcesz pozwolić na krótkie serie, np. przeszukiwanie z autocomplete, a z kolei fixed window tam, gdzie prostota i niższa liczba operacji są ważniejsze od precyzji na granicy okna.
Identyfikacja źródła żądania i ryzyko fałszywych nagłówków
Cały rate limiting zależy od tego, czym zidentyfikujesz źródło żądania. Surowy x-forwarded-for można sfałszować, jeżeli aplikacja nie wie, które proxy dopisało konkretną część łańcucha. Nie ma jednego uniwersalnego i bezpiecznego parsera dla każdego wdrożenia, ponieważ wybór odpowiedniej reguły zależy od specyfiki platformy, liczby zaufanych węzłów pośredniczących oraz tego, czy serwer źródłowy można wywołać bezpośrednio z pominięciem proxy.
Na Vercel użyj x-vercel-forwarded-for, który platforma nadpisuje adresem klienta. cf-connecting-ip jest wiarygodny dopiero wtedy, gdy serwer źródłowy przyjmuje ruch wyłącznie z Cloudflare. Przy self-hostingu skonfiguruj zaufane proxy tak, aby usuwało nagłówki przesłane przez klienta, i odczytuj adres zgodnie z liczbą zaufanych hopów. Dla zalogowanych użytkowników limituj przede wszystkim po ID ze zweryfikowanej sesji, a nie po wartości podanej przez klienta w body lub nagłówku.
Code
// lib/client-ip.ts — Node.jsimport { isIP } from 'node:net'export function getTrustedClientIp(headers: Headers): string | null { // Wybór ustawiasz w konfiguracji serwera, nigdy na podstawie żądania. const source = process.env.CLIENT_IP_SOURCE let raw: string | null = null if (source === 'vercel' && process.env.VERCEL === '1') { raw = headers.get('x-vercel-forwarded-for') } else if (source === 'cloudflare') { // Wymaga zablokowanego dostępu do origin z pominięciem Cloudflare. raw = headers.get('cf-connecting-ip') } const ip = raw?.trim() // Kontrakt tych nagłówków: pojedynczy adres, bez portu, listy i zone ID. if (!ip || ip.includes('%') || !isIP(ip)) return null if (isIP(ip) === 4) return ip const normalized = new URL(`http://[${ip}]/`).hostname.slice(1, -1) // IPv4-mapped IPv6 sprowadź do tego samego klucza co IPv4. const mapped = /^::ffff:([0-9a-f]+):([0-9a-f]+)$/.exec(normalized) if (mapped) { const high = parseInt(mapped[1], 16) const low = parseInt(mapped[2], 16) return [high >> 8, high & 255, low >> 8, low & 255].join('.') } return normalized}
CLIENT_IP_SOURCE=vercel ustawiaj tylko dla wdrożenia na Vercel, a CLIENT_IP_SOURCE=cloudflare tylko przy zaufanym wejściu Cloudflare. Inne self-hostowane proxy wymaga osobnej, jawnej reguły; helper celowo nie zgaduje infrastruktury po nagłówkach.
Nie zastępuj braku adresu wspólnym kluczem unknown, bo jedna nierozpoznana osoba wyczerpie limit wszystkim pozostałym. Dla odczytu możesz świadomie zastosować , a dla logowania lub formularza zwrócić 503. Przy logowaniu warto utrzymywać dwa niezależne limity: per zaufany adres IP i per znormalizowane konto. Sam limit per konto pozwala na celowe blokowanie ofiary, a sam limit per IP nie zatrzyma rozproszonego ataku. Nie zapisuj surowego e-maila w kluczu Redis — użyj stabilnego hasha albo wewnętrznego ID.
Co zrobić, gdy Redis padnie: fail-open czy fail-closed?
Sprawdzenie limitu zwykle wymaga kontaktu z Upstash, ale ephemeralCache może lokalnie odrzucić już zablokowany identyfikator. Analytics może mimo tego wykonywać zapis w tle. Ustal, co dzieje się w przypadku timeoutu, awarii Redisa lub przekroczenia limitu planu. Do dyspozycji pozostają dwie strategie, przy czym wybór każdej z nich nie stanowi wyłącznie decyzji technicznej, a biznesową.
przepuszcza ruch, gdy limiter nie działa, co oznacza wybór dostępności kosztem ochrony. Użytkownicy nie zobaczą błędu w przypadku awarii Redisa, jednak aplikacja na ten czas traci zabezpieczenia. Może to być rozsądny wybór dla taniego publicznego odczytu. Kosztowne wyszukiwanie lub generowanie raportów też może wymagać fail-closed — sama metoda GET nie przesądza o strategii.
odrzuca ruch, gdy limiter nie działa, co stanowi wybór bezpieczeństwa kosztem dostępności. Takie podejście sprawdza się przy logowaniu, płatnościach oraz innych wrażliwych ścieżkach, gdzie brak mechanizmu ograniczeń niesie za sobą większe ryzyko niż chwilowa niedostępność usługi.
Domyślny timeout biblioteki wynosi pięć sekund i działa w trybie fail-open, dlatego warto ustawić go jawnie zgodnie z budżetem opóźnienia aplikacji, a przy strategii fail-closed kontrolować zarówno wyjątki, jak i sytuacje przekroczenia czasu oczekiwania. Niezależnie od wybranego podejścia należy rejestrować każde takie zdarzenie w logach, ponieważ cicha awaria mechanizmu ograniczeń zazwyczaj ujawnia się dopiero w momencie realnego ataku.
Rate limiting per endpoint w Next.js
Code
// lib/rate-limit.ts// Różne limity per typ endpointuexport const apiLimiters = { // Odczyt — łagodny limit read: new Ratelimit({ redis, limiter: Ratelimit.slidingWindow(60, '1 m'), prefix: 'rl:read', timeout: 1000, }), // Zapis — bardziej restrykcyjny limit write: new Ratelimit({ redis, limiter: Ratelimit.slidingWindow(10, '1 m'), prefix: 'rl:write', timeout: 1000, }), // Uwierzytelnianie — bardzo restrykcyjny limit auth: new Ratelimit({ redis, limiter: Ratelimit.slidingWindow(5, '5 m'), prefix: 'rl:auth', timeout: 1000, }), // Upload — limitowany upload: new Ratelimit({ redis, limiter: Ratelimit.slidingWindow(5, '10 m'), prefix: 'rl:upload', timeout: 1000, }), // Formularz kontaktowy — 3 wiadomości na 10 minut contact: new Ratelimit({ redis, limiter: Ratelimit.slidingWindow(3, '10 m'), prefix: 'rl:contact', timeout: 1000, }),}
Podane wartości stanowią jedynie przykłady, a nie uniwersalne i bezpieczne progi. Należy dobrać je indywidualnie na podstawie analizy normalnego ruchu, kosztów operacji oraz konsekwencji przypadkowego zablokowania użytkownika. Stosowanie różnych prefiksów skutecznie izoluje liczniki, jednak każde dodatkowe wywołanie metody limit() generuje osobną kontrolę oraz dodatkowy koszt.
Rate limiting w Route Handlerach
Code
// app/api/search/route.ts — domyślny runtime Node.jsimport { apiLimiters } from '@/lib/rate-limit'import { getTrustedClientIp } from '@/lib/client-ip'import { checkRateLimit } from '@/lib/rate-limit-check'import { searchPosts } from '@/lib/search' // Własna implementacja wyszukiwania.import { after, type NextRequest } from 'next/server'export async function GET(request: NextRequest) { const ip = getTrustedClientIp(request.headers) const responseHeaders = { 'Cache-Control': 'no-store' } // Ten przykład zakłada tani publiczny odczyt i świadomy fail-open. if (!ip) console.error('Brak zaufanego IP dla wyszukiwania') const decision = ip ? await checkRateLimit(apiLimiters.read, `search:${ip}`, false, (work) => after(() => work.then(() => {}))) : { status: 'allowed' as const } if (decision.status === 'limited') { return Response.json({ error: 'Zbyt wiele żądań' }, { status: 429, headers: { ...responseHeaders, 'Retry-After': String(decision.retryAfter) }, }) } if (decision.status === 'unavailable') { return Response.json({ error: 'Usługa chwilowo niedostępna' }, { status: 503, headers: { ...responseHeaders, 'Retry-After': '1' }, }) } // Wspólna ścieżka również dla fail-open. Błąd wyszukiwania nie jest // awarią limitera i nie zostaje zamieniony na pustą odpowiedź 200. const query = request.nextUrl.searchParams.get('q')?.trim() ?? '' if (query.length > 200) { return Response.json({ error: 'Zbyt długie zapytanie' }, { status: 400, headers: responseHeaders, }) } const results = await searchPosts(query) return Response.json({ results }, { headers: responseHeaders })}
W aktualnym Next.js 16 usuń deklarację runtime = 'edge'; domyślnie działa w Node.js, a sposób użycia Upstash pozostaje bez zmian. searchPosts jest funkcją projektu, nie API Next.js — powinna zwracać ograniczoną liczbę wyników zgodnie z kontraktem aplikacji. W przypadku endpointów dla zalogowanych użytkowników najpierw zweryfikuj sesję oraz uprawnienia, a dopiero potem zastosuj klucz oparty na identyfikatorze, na przykład user:$.
Rate limiting w Server Actions
Code
// lib/rate-limit-action.tsimport { apiLimiters } from '@/lib/rate-limit'import { getTrustedClientIp } from '@/lib/client-ip'import { headers } from 'next/headers'export async function checkContactRateLimit() { const headersList = await headers() const ip = getTrustedClientIp(headersList) // Formularz jest ścieżką zapisu, więc brak wiarygodnego ID blokujemy. if (!ip) { console.error('Brak zaufanego IP dla formularza') return { allowed: false, unavailable: true } } try { const result = await apiLimiters.contact.limit(`contact:${ip}`) // Dla antyspamu wybieramy fail-closed także przy timeout SDK. if (result.reason === 'timeout') { console.error('Timeout limitera formularza') return { allowed: false, unavailable: true } } if (!result.success) { const retryIn = Math.max(1, Math.ceil((result.reset - Date.now()) / 1000)) return { allowed: false, error: `Zbyt wiele prób. Spróbuj ponownie za ${retryIn} sekund.`, } } return { allowed: true, remaining: result.remaining } } catch (error) { console.error('Rate limiter formularza jest niedostępny', error) return { allowed: false, unavailable: true } }}
Code
// actions/contact-actions.ts'use server'import { checkContactRateLimit } from '@/lib/rate-limit-action'export async function submitContactForm(formData: FormData) { // Rate limit — max 3 wiadomości na 10 minut const rateCheck = await checkContactRateLimit() if (!rateCheck.allowed) { return { error: rateCheck.unavailable ? 'Formularz jest chwilowo niedostępny.' : rateCheck.error, } } // ... walidacja danych i ochrona przed CSRF // ... wysyłanie formularza}
Pokazany matcher Proxy /api/:path*nie obejmuje typowych wywołań na adresach stron. Inny matcher może obejmować te adresy, ale nie zastępuje kontroli wewnątrz akcji. Wywołanie akcji jest żądaniem POST do adresu strony, na której jej użyto, dlatego limit, uwierzytelnianie i autoryzację egzekwuj ponownie wewnątrz akcji. Dla akcji dostępnej tylko po zalogowaniu zamiast IP użyj ID ze zweryfikowanej sesji.
Alternatywa bez Redisa: rate limiting w pamięci podczas developmentu
Dla środowiska deweloperskiego lub pojedynczego, długo działającego procesu możesz użyć prostego limitera w pamięci:
Code
// lib/rate-limit-memory.tsconst requests = new Map<string, { count: number; resetAt: number }>()export function rateLimit( identifier: string, limit: number = 10, windowMs: number = 60000,): { success: boolean; remaining: number } { const now = Date.now() const record = requests.get(identifier) if (!record || now > record.resetAt) { if (record) requests.delete(identifier) requests.set(identifier, { count: 1, resetAt: now + windowMs }) return { success: true, remaining: limit - 1 } } if (record.count >= limit) { return { success: false, remaining: 0 } } record.count++ return { success: true, remaining: limit - record.count }}
To uproszczony przykład: w realnym procesie potrzebujesz okresowego usuwania wygasłych kluczy, inaczej losowe identyfikatory mogą bez końca zwiększać pamięć. W i Edge Runtime każda instancja ma osobny Map, a cold start zeruje stan, więc nie uzyskasz globalnego limitu. W rozproszonym środowisku produkcyjnym użyj współdzielonego magazynu, np. Upstash Redis.
Monitoring, testy i koszty rate limitingu
Po wdrożeniu systemu kontroluj liczbę dozwolonych oraz zablokowanych żądań, przyczyny decyzji, opóźnienia wywołań i częstotliwość timeoutów. Twój system alarmowy powinien rozróżniać faktyczne odpowiedzi z kodem 429 od trybów awaryjnych typu fail-open oraz fail-closed. Pamiętaj też o ochronie prywatności i nigdy nie zapisuj w logach pełnych adresów IP, adresów e-mail ani tokenów. Jeśli potrzebujesz korelacji danych, skracaj lub hashuj identyfikator użytkownika.
Kompleksowy test integracyjny musi weryfikować przepuszczanie pierwszych żądań, poprawność zwracanego kodu 429 oraz nagłówka Retry-After po przekroczeniu limitu, a także powrót do obsługi ruchu po wygaśnięciu okna czasowego. Sprawdzaj też niezależność liczników dla różnych identyfikatorów, zachowanie systemu przy serii równoległych zapytań oraz reakcję na błędy lub timeouty połączenia z Upstash. Testy uruchamiaj na osobnym prefiksie kluczy i dedykowanej instancji Redisa, aby poszczególne przebiegi nie wpływały na siebie nawzajem.
Ostateczny koszt rozwiązania zależy od wybranego algorytmu i dodatkowych funkcji. Sliding window oraz token bucket generują więcej operacji niż prosty fixed window, moduł analityczny dokłada kolejne zapytania, a dwupoziomowe ograniczenia zwielokrotniają liczbę weryfikacji. Zadbaj o to, aby baza danych znajdowała się jak najbliżej środowiska uruchomieniowego, stale monitoruj opóźnienia na percentylach p95 oraz p99 i zachowaj szczególną ostrożność przy sliding window w architekturze wieloregionowej.
Elastyczne i wydajne narzędzia dla biznesu, które dotrzymają kroku Twojemu rozwojowi.
Cennik Upstash zmienia się w czasie, więc sprawdzaj aktualne limity w ich panelu. Plan darmowy może wystarczyć w małym projekcie, ale przy publicznym API policz realną liczbę żądań przed wdrożeniem. Pojedyncze sprawdzenie limitu może wykonać kilka komend Redis, zależnie od algorytmu, cache i analytics.
Czy rate limiting chroni przed DDoS?
Częściowo. Rate limiting na poziomie aplikacji chroni przed prostymi atakami brute force i nadużyciami. Przy wolumetrycznym DDoS, czyli zalewie ruchem z tysięcy źródeł, potrzebujesz ochrony na poziomie sieci, np. Cloudflare albo AWS Shield, bo do warstwy aplikacji takie żądania nie powinny w ogóle docierać.
Jak identyfikować użytkowników za NAT?
Sam adres IP nie jest idealny, ponieważ wielu użytkowników za NAT współdzieli jeden adres, przez co limit może uderzyć w niewinnych. Nie doklejaj nagłówka User-Agent do klucza ograniczenia, ponieważ klient może go modyfikować i obchodzić zabezpieczenia. Dla zalogowanych użytkowników stosuj zweryfikowane ID konta lub klucz API, a na szczególnie wrażliwych endpointach łącz oba podejścia: osobny limit per konto i osobny limit per zaufany adres IP.
Który algorytm rate limitingu wybrać?
Sliding window dla większości API — wygładza problem granicy okien, przy której fixed window pozwala na podwójny skok ruchu. Token bucket tam, gdzie chcesz świadomie dopuścić krótkie serie żądań, np. autocomplete albo przeszukiwanie. Fixed window tylko wtedy, gdy zależy Ci na maksymalnej prostocie.
Dlaczego in-memory rate limiter nie działa na produkcji?
Bo w serverless i Edge Runtime każda instancja funkcji ma osobną pamięć. Limit liczony w Map jednej instancji nie wie o żądaniach obsłużonych przez inną. Atakujący trafiający na różne instancje obejdzie limit. Potrzebujesz współdzielonego stanu, czyli np. Redisa w Upstash.
Co się dzieje, gdy Redis przestanie odpowiadać?
To zależy od strategii, którą świadomie wybierzesz. Fail-open przepuszcza ruch, gdy limiter nie działa. API zostaje na chwilę bez ochrony, ale użytkownicy nie widzą błędu; może być rozsądnym wyborem dla taniego, publicznego odczytu; kosztowne wyszukiwanie lub raport mogą wymagać fail-closed. Fail-closed odrzuca ruch przy awarii limitera. Wybierasz bezpieczeństwo kosztem dostępności, co ma sens dla logowania i płatności. Owiń wywołanie limitera w try/catch, ale sprawdzaj też reason: 'timeout': wbudowany timeout SDK domyślnie zwraca wtedy wynik fail-open zamiast rzucać wyjątek. Zaloguj zdarzenie i zwróć decyzję zgodną z wybraną strategią.
Jak ograniczyć liczbę operacji na Redisie i koszt rate limitingu?
ephemeralCache jest domyślnie włączony w Ratelimit; możesz też przekazać własny Map utworzony poza handlerem. Zapamiętuje lokalnie już zablokowane identyfikatory do czasu resetu i dla kolejnych odrzuceń nie odpytuje Redisa. Działa tylko w obrębie ciepłej instancji, więc zmniejsza koszt podczas powtarzalnego nadużycia, ale nie zastępuje współdzielonego limitu.
O autorze
Maciej Sala
Maciej Sala — konsultant technologiczny produktów cyfrowych i web developer z bogatym doświadczeniem w marketingu internetowym oraz SEO. Na co dzień pracuje z Reactem, Next.js i TypeScriptem, a ostatnio także z Astro i narzędziami do automatyzacji procesów AI. Sprawnie łączy perspektywę produktową z praktycznym podejściem do kodu. Przez kilka lat był związany z branżą gier wideo jako project manager i game designer. Absolwent historii na Uniwersytecie Jagiellońskim oraz studiów podyplomowych z marketingu internetowego na AGH w Krakowie. Po godzinach trenuje na siłowni, maluje figurki i rozwija własne projekty.
Większość deweloperów może kojarzyć middleware w Next.js ze sprawdzaniem, czy użytkownik jest zalogowany, podczas gdy dla żądań objętych matcherem może ono podjąć decyzję jeszcze przed routingiem: przypisać wariant eksperymentu, zastosować limit, wykonać rewrite albo dodać zależny od requestu nagłówek. W artykule chciałem omówić siedem zastosowań Proxy wraz z ich ograniczeniami.
Maciej Sala
Founder StriveLab
Zarządzanie pamięcią podręczną cache w Next.js może wydawać się proste, dopóki nie napotkamy wyzwań w środowisku produkcyjnym. Wiele instancji, webhooki z systemów CMS oraz dane, które bywają nieaktualne po wdrożeniu, potrafią skomplikować sytuację. App Router oferuje rozszerzony fetch, unstable cache, deduplikację żądań oraz Cache Components. Redis z kolei dostarcza wspólny magazyn, który jest łatwiejszy do monitorowania. Zastanówmy się więc, jaki konkretny problem próbujemy rozwiązać za pomocą mechanizmów buforowania?
Maciej Sala
Founder StriveLab
To trzecia część mojej małej serii „Backend dla frontendowca” i po fundamentach API oraz tematach real-time, webhooków i uwierzytelniania zostaje warstwa, która decyduje o tym, czy aplikacja wytrzyma prawdziwe użytkowanie: cache , kolejki, pliki, deployment, monitoring i bezpieczeństwo .