PricingLoginStart free
Mønstre for API-ratebegrensning og skalerbarhet · leksjon

Velge riktig algoritme for hastighetsbegrensning

Sammenlign de grunnleggende algoritmene for hastighetsbegrensning – fixed window, sliding window, token bucket og leaky bucket – og lær når hver av dem passer til trafikkprofilen og målene for rettferdighet.

Leksjon 4 av 413 trinn

Velge riktig algoritme for hastighetsbegrensning er en gratis leksjon i Mønstre for API-ratebegrensning og skalerbarhet på CoddyKit. Dette er leksjon 4 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Mønstre for API-ratebegrensning og skalerbarhet, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Mønstre for API-ratebegrensning og skalerbarhet inneholder totalt 4 leksjoner.

Hvorfor algoritmen er viktig

En policy for hastighetsbegrensning er bare så god som algoritmen som håndhever den. Den samme grensen på 100 requests/minute oppfører seg svært forskjellig avhengig av hvordan De teller.

I denne leksjonen sammenligner vi fire klassiske tilnærminger og lærer hvordan vi velger én basert på behovene for rettferdighet, topper og nøyaktighet.

Teller for fast vindu

Den enkleste tilnærmingen: Tell forespørsler i et fast tidsvindu, for eksempel hvert kalenderminutt, og tilbakestill telleren ved grenseovergangen.

  • Fordeler: svært enkel å implementere, lav minnebruk
  • Ulemper: tillater en topp på 2x grensen rundt vindusgrensen
def allow(counter, limit):
    if counter['count'] >= limit:
        return False
    counter['count'] += 1
    return True

Problemet med topper ved grensen

Med et fast vindu kan en klient sende limit forespørsler klokken 00:59 og ytterligere limit klokken 01:00. Det er dobbelt så høy hastighet som tilsiktet i løpet av ett sekund.

Algoritmer med glidende vindu finnes for å jevne ut nettopp denne toppen.

Logg for glidende vindu

Lagre et tidsstempel for hver forespørsel. For å ta en avgjørelse fjerner De tidsstempler som er eldre enn vinduet, og teller det som gjenstår.

  • Fordeler: nøyaktig, ingen topper ved grensen
  • Ulemper: minnebruken øker med trafikkmengden
def allow(log, now, window, limit):
    cutoff = now - window
    log[:] = [t for t in log if t > cutoff]
    if len(log) >= limit:
        return False
    log.append(now)
    return True

Teller for glidende vindu

En hybrid: Behold tellingene for det gjeldende og det forrige faste vinduet, og estimer deretter hastigheten ved hjelp av et vektet overlapp.

Den tilnærmer seg loggen for det glidende vinduet med langt mindre minnebruk, og derfor foretrekkes den av API-gatewayer og CDN-er.

weighted = prev_count * overlap + curr_count
allowed = weighted < limit

Token bucket

En bøtte inneholder tokens opptil en angitt kapasitet. Tokens fylles på med jevn hastighet, og hver forespørsel bruker ett token. En tom bøtte betyr avvisning.

  • Tillater kontrollerte topper opptil bøttekapasiteten
  • Jevner ut det langsiktige gjennomsnittet til påfyllingshastigheten
def allow(bucket, now, rate, capacity):
    elapsed = now - bucket['ts']
    bucket['tokens'] = min(capacity, bucket['tokens'] + elapsed * rate)
    bucket['ts'] = now
    if bucket['tokens'] < 1:
        return False
    bucket['tokens'] -= 1
    return True

Leaky bucket

Forespørsler legges i en kø som lekker med konstant hastighet. Hvis køen blir full, forkastes forespørsler.

I motsetning til token bucket håndhever leaky bucket en jevn utdatahastighet – ideelt når en nedstrøms tjeneste ikke tåler topper.

Token bucket kontra leaky bucket

  • Token bucket lar trafikken få topper opptil kapasiteten, og begrenser deretter hastigheten – egnet for brukerrettede API-er som skal oppleves responsive.
  • Leaky bucket tvinger frem en jevn, konstant flyt – egnet for å beskytte sårbare backend-systemer.

Avveininger mellom minne og nøyaktighet

Velg basert på begrensningene:

  • Lavest minnebruk: fast vindu
  • Høyest nøyaktighet: logg for glidende vindu
  • Beste balanse: teller for glidende vindu
  • Egnet for topper: token bucket

Distribuerte hensyn

På tvers av mange servere kan ikke hver node ha sin egen teller, ellers blir den reelle grensen multiplisert. Bruk et delt lagringssystem som Redis med atomiske operasjoner, slik at tellingen blir global.

Både token bucket og telleren for glidende vindu kan enkelt tilpasses Redis-primitiver.

-- Redis atomic counter with expiry
INCR rate:user:42
EXPIRE rate:user:42 60

En sjekkliste for valg

Spør:

  • Trenger jeg å tillate korte topper? → token bucket
  • Må systemet nedstrøms se en jevn hastighet? → leaky bucket
  • Er nøyaktighet avgjørende for fakturering? → logg for glidende vindu
  • Ønsker jeg noe enkelt og billig? → teller for fast eller glidende vindu

Kjapp sjekk

Test forståelsen Deres av valg av algoritme.

Besvar den i den interaktive leksjonen

Oppsummering

De sammenlignet fire algoritmer for hastighetsbegrensning:

  • Fast vindu – billig, men tillater topper ved grensen
  • Glidende vindu – nøyaktig og jevner ut grenseoverganger
  • Token bucket – egnet for topper og jevner ut gjennomsnittet
  • Leaky bucket – konstant utdatahastighet

Velg basert på hvor store topper De aksepterer, nøyaktighet og tilgjengelig minnebudsjett.

Gratis å komme i gang

Lær deg Mønstre for API-ratebegrensning og skalerbarhet med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
12
Leksjoner
48
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Velge riktig algoritme for hastighetsbegrensning» gratis?

Ja – hele teksten i «Velge riktig algoritme for hastighetsbegrensning» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Mønstre for API-ratebegrensning og skalerbarhet-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Mønstre for API-ratebegrensning og skalerbarhet inneholder totalt 4 leksjoner.

Hva lærer jeg i «Velge riktig algoritme for hastighetsbegrensning»?

Sammenlign de grunnleggende algoritmene for hastighetsbegrensning – fixed window, sliding window, token bucket og leaky bucket – og lær når hver av dem passer til trafikkprofilen og målene for rettfe… Du øver på Mønstre for API-ratebegrensning og skalerbarhet med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Mønstre for API-ratebegrensning og skalerbarhet?

Ingen tidligere erfaring er nødvendig. Mønstre for API-ratebegrensning og skalerbarhet på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Velge riktig algoritme for hastighetsbegrensning»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Mønstre for API-ratebegrensning og skalerbarhet-leksjonen?

Ja. Alle Mønstre for API-ratebegrensning og skalerbarhet-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Throttling kontra hastighetsbegrensning forklart
  2. Retningslinjer for trafikkøkninger og nådeperioder
  3. Grenser på klientsiden kontra serversiden
  4. Velge riktig algoritme for hastighetsbegrensning
← Tilbake til Mønstre for API-ratebegrensning og skalerbarhet