M

MLOG

മലയാളം

ടോക്കൺ ബക്കറ്റ് അൽഗോരിതത്തിൽ ശ്രദ്ധ കേന്ദ്രീകരിച്ച് റേറ്റ് ലിമിറ്റിംഗ് തന്ത്രങ്ങൾ മനസ്സിലാക്കുക. ഇതിന്റെ നിർവ്വഹണം, ഗുണങ്ങൾ, ദോഷങ്ങൾ, പ്രതിരോധശേഷിയുള്ളതും വികസിപ്പിക്കാവുന്നതുമായ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിനുള്ള പ്രായോഗിക ഉപയോഗങ്ങൾ എന്നിവയെക്കുറിച്ച് പഠിക്കുക.

റേറ്റ് ലിമിറ്റിംഗ്: ടോക്കൺ ബക്കറ്റ് ഇംപ്ലിമെൻ്റേഷനിലേക്കുള്ള ഒരു ആഴത്തിലുള്ള பார்வை

ഇന്നത്തെ പരസ്പരം ബന്ധപ്പെട്ടിരിക്കുന്ന ഡിജിറ്റൽ ലോകത്ത്, ആപ്ലിക്കേഷനുകളുടെയും എപിഐ-കളുടെയും സ്ഥിരതയും ലഭ്യതയും ഉറപ്പാക്കേണ്ടത് അത്യാവശ്യമാണ്. ഉപയോക്താക്കൾക്കോ ക്ലയൻ്റുകൾക്കോ അഭ്യർത്ഥനകൾ നൽകാൻ കഴിയുന്ന നിരക്ക് നിയന്ത്രിക്കുന്നതിലൂടെ ഈ ലക്ഷ്യം കൈവരിക്കുന്നതിൽ റേറ്റ് ലിമിറ്റിംഗ് ഒരു പ്രധാന പങ്ക് വഹിക്കുന്നു. ഈ ബ്ലോഗ് പോസ്റ്റ് റേറ്റ് ലിമിറ്റിംഗ് തന്ത്രങ്ങളെക്കുറിച്ചുള്ള സമഗ്രമായ ഒരു പര്യവേക്ഷണം നൽകുന്നു, ടോക്കൺ ബക്കറ്റ് അൽഗോരിതം, അതിൻ്റെ നിർവ്വഹണം, ഗുണങ്ങൾ, ദോഷങ്ങൾ എന്നിവയിൽ പ്രത്യേക ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു.

എന്താണ് റേറ്റ് ലിമിറ്റിംഗ്?

ഒരു നിശ്ചിത കാലയളവിൽ ഒരു സെർവറിലേക്കോ സേവനത്തിലേക്കോ അയയ്ക്കുന്ന ട്രാഫിക്കിൻ്റെ അളവ് നിയന്ത്രിക്കാൻ ഉപയോഗിക്കുന്ന ഒരു സാങ്കേതികതയാണ് റേറ്റ് ലിമിറ്റിംഗ്. ഇത് സിസ്റ്റങ്ങളെ അമിതമായ അഭ്യർത്ഥനകളാൽ തകരാറിലാകുന്നതിൽ നിന്ന് സംരക്ഷിക്കുകയും, ഡിനയൽ-ഓഫ്-സർവീസ് (DoS) ആക്രമണങ്ങൾ, ദുരുപയോഗം, അപ്രതീക്ഷിത ട്രാഫിക് വർദ്ധനവ് എന്നിവ തടയുകയും ചെയ്യുന്നു. അഭ്യർത്ഥനകളുടെ എണ്ണത്തിൽ പരിധികൾ നടപ്പിലാക്കുന്നതിലൂടെ, റേറ്റ് ലിമിറ്റിംഗ് ന്യായമായ ഉപയോഗം ഉറപ്പാക്കുകയും മൊത്തത്തിലുള്ള സിസ്റ്റം പ്രകടനം മെച്ചപ്പെടുത്തുകയും സുരക്ഷ വർദ്ധിപ്പിക്കുകയും ചെയ്യുന്നു.

ഒരു ഫ്ലാഷ് വിൽപ്പന സമയത്ത് ഒരു ഇ-കൊമേഴ്‌സ് പ്ലാറ്റ്‌ഫോം പരിഗണിക്കുക. റേറ്റ് ലിമിറ്റിംഗ് ഇല്ലാതെ, ഉപയോക്തൃ അഭ്യർത്ഥനകളിലെ പെട്ടെന്നുള്ള വർദ്ധനവ് സെർവറുകളെ തകർക്കുകയും, പ്രതികരണ സമയം കുറയുന്നതിനോ അല്ലെങ്കിൽ സേവന തടസ്സങ്ങൾക്കോ ഇടയാക്കും. ഒരു നിശ്ചിത സമയപരിധിക്കുള്ളിൽ ഒരു ഉപയോക്താവിന് (അല്ലെങ്കിൽ IP വിലാസത്തിന്) നടത്താനാകുന്ന അഭ്യർത്ഥനകളുടെ എണ്ണം പരിമിതപ്പെടുത്തിക്കൊണ്ട് റേറ്റ് ലിമിറ്റിംഗിന് ഇത് തടയാൻ കഴിയും, ഇത് എല്ലാ ഉപയോക്താക്കൾക്കും സുഗമമായ അനുഭവം ഉറപ്പാക്കുന്നു.

എന്തുകൊണ്ടാണ് റേറ്റ് ലിമിറ്റിംഗ് പ്രധാനമാകുന്നത്?

റേറ്റ് ലിമിറ്റിംഗ് നിരവധി നേട്ടങ്ങൾ നൽകുന്നു, അവയിൽ ഉൾപ്പെടുന്നവ:

സാധാരണ റേറ്റ് ലിമിറ്റിംഗ് അൽഗോരിതങ്ങൾ

റേറ്റ് ലിമിറ്റിംഗ് നടപ്പിലാക്കാൻ നിരവധി അൽഗോരിതങ്ങൾ ഉപയോഗിക്കാം. ഏറ്റവും സാധാരണമായവയിൽ ചിലത് ഉൾപ്പെടുന്നു:

ഈ ബ്ലോഗ് പോസ്റ്റ് അതിൻ്റെ വഴക്കവും വ്യാപകമായ പ്രായോഗികതയും കാരണം ടോക്കൺ ബക്കറ്റ് അൽഗോരിതത്തിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കും.

ടോക്കൺ ബക്കറ്റ് അൽഗോരിതം: ഒരു വിശദമായ വിവരണം

ലളിതത്വവും ഫലപ്രാപ്തിയും തമ്മിൽ ഒരു സന്തുലിതാവസ്ഥ നൽകുന്ന, വ്യാപകമായി ഉപയോഗിക്കുന്ന ഒരു റേറ്റ് ലിമിറ്റിംഗ് സാങ്കേതികതയാണ് ടോക്കൺ ബക്കറ്റ് അൽഗോരിതം. ടോക്കണുകൾ സൂക്ഷിക്കുന്ന ഒരു "ബക്കറ്റ്" എന്ന ആശയം നിലനിർത്തിയാണ് ഇത് പ്രവർത്തിക്കുന്നത്. വരുന്ന ഓരോ അഭ്യർത്ഥനയും ബക്കറ്റിൽ നിന്ന് ഒരു ടോക്കൺ ഉപയോഗിക്കുന്നു. ബക്കറ്റിൽ ആവശ്യത്തിന് ടോക്കണുകളുണ്ടെങ്കിൽ, അഭ്യർത്ഥന അനുവദിക്കപ്പെടും; അല്ലാത്തപക്ഷം, അഭ്യർത്ഥന നിരസിക്കപ്പെടും (അല്ലെങ്കിൽ നടപ്പാക്കലിനെ ആശ്രയിച്ച് ക്യൂവിൽ നിർത്തും). ഒരു നിശ്ചിത നിരക്കിൽ ബക്കറ്റിലേക്ക് ടോക്കണുകൾ ചേർക്കപ്പെടുന്നു, ഇത് ലഭ്യമായ ശേഷി പുനഃസ്ഥാപിക്കുന്നു.

പ്രധാന ആശയങ്ങൾ

ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു

  1. ഒരു അഭ്യർത്ഥന വരുമ്പോൾ, ബക്കറ്റിൽ ആവശ്യത്തിന് ടോക്കണുകളുണ്ടോ എന്ന് അൽഗോരിതം പരിശോധിക്കുന്നു.
  2. ആവശ്യത്തിന് ടോക്കണുകളുണ്ടെങ്കിൽ, അഭ്യർത്ഥന അനുവദിക്കുകയും അതിനനുസരിച്ചുള്ള ടോക്കണുകളുടെ എണ്ണം ബക്കറ്റിൽ നിന്ന് നീക്കം ചെയ്യുകയും ചെയ്യുന്നു.
  3. ആവശ്യത്തിന് ടോക്കണുകളില്ലെങ്കിൽ, അഭ്യർത്ഥന നിരസിക്കപ്പെടും (സാധാരണയായി HTTP 429 എന്ന "വളരെയധികം അഭ്യർത്ഥനകൾ" എന്ന പിശക് നൽകുന്നു) അല്ലെങ്കിൽ പിന്നീട് പ്രോസസ്സ് ചെയ്യുന്നതിനായി ക്യൂവിൽ നിർത്തും.
  4. അഭ്യർത്ഥനയുടെ വരവ് പരിഗണിക്കാതെ, നിശ്ചിത റീഫിൽ നിരക്കിൽ, ബക്കറ്റിൻ്റെ ശേഷി വരെ, ടോക്കണുകൾ ആനുകാലികമായി ബക്കറ്റിലേക്ക് ചേർക്കുന്നു.

ഉദാഹരണം

10 ടോക്കൺ ശേഷിയും സെക്കൻഡിൽ 2 ടോക്കൺ റീഫിൽ നിരക്കുമുള്ള ഒരു ടോക്കൺ ബക്കറ്റ് സങ്കൽപ്പിക്കുക. തുടക്കത്തിൽ, ബക്കറ്റ് നിറഞ്ഞിരിക്കുന്നു (10 ടോക്കണുകൾ). അൽഗോരിതം എങ്ങനെ പ്രവർത്തിച്ചേക്കാം എന്നത് ഇതാ:

ടോക്കൺ ബക്കറ്റ് അൽഗോരിതം നടപ്പിലാക്കുന്നു

ടോക്കൺ ബക്കറ്റ് അൽഗോരിതം വിവിധ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ നടപ്പിലാക്കാൻ കഴിയും. ഗോലാംഗ്, പൈത്തൺ, ജാവ എന്നിവയിലെ ഉദാഹരണങ്ങൾ താഴെ നൽകുന്നു:

ഗോലാംഗ്

```go package main import ( "fmt" "sync" "time" ) // TokenBucket represents a token bucket rate limiter. type TokenBucket struct { capacity int tokens int rate time.Duration lastRefill time.Time mu sync.Mutex } // NewTokenBucket creates a new TokenBucket. func NewTokenBucket(capacity int, rate time.Duration) *TokenBucket { return &TokenBucket{ capacity: capacity, tokens: capacity, rate: rate, lastRefill: time.Now(), } } // Allow checks if a request is allowed based on token availability. func (tb *TokenBucket) Allow() bool { tb.mu.Lock() defer tb.mu.Unlock() now := time.Now() tb.refill(now) if tb.tokens > 0 { tb.tokens-- return true } return false } // refill adds tokens to the bucket based on the elapsed time. func (tb *TokenBucket) refill(now time.Time) { elapsed := now.Sub(tb.lastRefill) newTokens := int(elapsed.Seconds() * float64(tb.capacity) / tb.rate.Seconds()) if newTokens > 0 { tb.tokens += newTokens if tb.tokens > tb.capacity { tb.tokens = tb.capacity } tb.lastRefill = now } } func main() { bucket := NewTokenBucket(10, time.Second) for i := 0; i < 15; i++ { if bucket.Allow() { fmt.Printf("Request %d allowed\n", i+1) } else { fmt.Printf("Request %d rate limited\n", i+1) } time.Sleep(100 * time.Millisecond) } } ```

പൈത്തൺ

```python import time import threading class TokenBucket: def __init__(self, capacity, refill_rate): self.capacity = capacity self.tokens = capacity self.refill_rate = refill_rate self.last_refill = time.time() self.lock = threading.Lock() def allow(self): with self.lock: self._refill() if self.tokens > 0: self.tokens -= 1 return True return False def _refill(self): now = time.time() elapsed = now - self.last_refill new_tokens = elapsed * self.refill_rate self.tokens = min(self.capacity, self.tokens + new_tokens) self.last_refill = now if __name__ == '__main__': bucket = TokenBucket(capacity=10, refill_rate=2) # 10 tokens, refills 2 per second for i in range(15): if bucket.allow(): print(f"Request {i+1} allowed") else: print(f"Request {i+1} rate limited") time.sleep(0.1) ```

ജാവ

```java import java.util.concurrent.locks.ReentrantLock; import java.util.concurrent.TimeUnit; public class TokenBucket { private final int capacity; private double tokens; private final double refillRate; private long lastRefillTimestamp; private final ReentrantLock lock = new ReentrantLock(); public TokenBucket(int capacity, double refillRate) { this.capacity = capacity; this.tokens = capacity; this.refillRate = refillRate; this.lastRefillTimestamp = System.nanoTime(); } public boolean allow() { try { lock.lock(); refill(); if (tokens >= 1) { tokens -= 1; return true; } else { return false; } } finally { lock.unlock(); } } private void refill() { long now = System.nanoTime(); double elapsedTimeInSeconds = (double) (now - lastRefillTimestamp) / TimeUnit.NANOSECONDS.toNanos(1); double newTokens = elapsedTimeInSeconds * refillRate; tokens = Math.min(capacity, tokens + newTokens); lastRefillTimestamp = now; } public static void main(String[] args) throws InterruptedException { TokenBucket bucket = new TokenBucket(10, 2); // 10 tokens, refills 2 per second for (int i = 0; i < 15; i++) { if (bucket.allow()) { System.out.println("Request " + (i + 1) + " allowed"); } else { System.out.println("Request " + (i + 1) + " rate limited"); } TimeUnit.MILLISECONDS.sleep(100); } } } ```

ടോക്കൺ ബക്കറ്റ് അൽഗോരിതത്തിന്റെ ഗുണങ്ങൾ

ടോക്കൺ ബക്കറ്റ് അൽഗോരിതത്തിന്റെ ദോഷങ്ങൾ

ടോക്കൺ ബക്കറ്റ് അൽഗോരിതത്തിൻ്റെ ഉപയോഗങ്ങൾ

ടോക്കൺ ബക്കറ്റ് അൽഗോരിതം ഇനിപ്പറയുന്നവ ഉൾപ്പെടെ നിരവധി റേറ്റ് ലിമിറ്റിംഗ് ഉപയോഗങ്ങൾക്ക് അനുയോജ്യമാണ്:

ഡിസ്ട്രിബ്യൂട്ടഡ് സിസ്റ്റങ്ങളിൽ ടോക്കൺ ബക്കറ്റ് നടപ്പിലാക്കുന്നു

ഒരു ഡിസ്ട്രിബ്യൂട്ടഡ് സിസ്റ്റത്തിൽ ടോക്കൺ ബക്കറ്റ് അൽഗോരിതം നടപ്പിലാക്കുന്നതിന് സ്ഥിരത ഉറപ്പാക്കാനും റേസ് കണ്ടീഷനുകൾ ഒഴിവാക്കാനും പ്രത്യേക പരിഗണനകൾ ആവശ്യമാണ്. ചില പൊതുവായ സമീപനങ്ങൾ ഇതാ:

റെഡിസ് ഉപയോഗിച്ചുള്ള ഉദാഹരണം (ആശയം)

ഒരു ഡിസ്ട്രിബ്യൂട്ടഡ് ടോക്കൺ ബക്കറ്റിനായി റെഡിസ് ഉപയോഗിക്കുന്നതിൽ ടോക്കൺ എണ്ണം കൈകാര്യം ചെയ്യുന്നതിന് അതിൻ്റെ ആറ്റോമിക് പ്രവർത്തനങ്ങൾ (`INCRBY`, `DECR`, `TTL`, `EXPIRE` പോലുള്ളവ) പ്രയോജനപ്പെടുത്തുന്നത് ഉൾപ്പെടുന്നു. അടിസ്ഥാന പ്രവാഹം ഇതായിരിക്കും:

  1. നിലവിലുള്ള ബക്കറ്റിനായി പരിശോധിക്കുക: ഉപയോക്താവിനായി/എപിഐ എൻഡ്‌പോയിൻ്റിനായി റെഡിസിൽ ഒരു കീ നിലവിലുണ്ടോയെന്ന് നോക്കുക.
  2. ആവശ്യമെങ്കിൽ സൃഷ്ടിക്കുക: ഇല്ലെങ്കിൽ, കീ സൃഷ്ടിക്കുക, ടോക്കൺ എണ്ണം കപ്പാസിറ്റിയിലേക്ക് ആരംഭിക്കുക, റീഫിൽ കാലയളവുമായി പൊരുത്തപ്പെടുന്നതിന് ഒരു കാലാവധി (TTL) സജ്ജമാക്കുക.
  3. ടോക്കൺ ഉപയോഗിക്കാൻ ശ്രമിക്കുക: ആറ്റോമിക് ആയി ടോക്കൺ എണ്ണം കുറയ്ക്കുക. ഫലം >= 0 ആണെങ്കിൽ, അഭ്യർത്ഥന അനുവദിക്കപ്പെടും.
  4. ടോക്കൺ തീരുന്നത് കൈകാര്യം ചെയ്യുക: ഫലം < 0 ആണെങ്കിൽ, കുറച്ചത് പഴയപടിയാക്കുക (ആറ്റോമിക് ആയി തിരികെ വർദ്ധിപ്പിക്കുക) അഭ്യർത്ഥന നിരസിക്കുക.
  5. റീഫിൽ ലോജിക്: ഒരു പശ്ചാത്തല പ്രോസസ്സിനോ ആനുകാലിക ടാസ്ക്കിനോ ബക്കറ്റുകൾ റീഫിൽ ചെയ്യാനും കപ്പാസിറ്റി വരെ ടോക്കണുകൾ ചേർക്കാനും കഴിയും.

ഡിസ്ട്രിബ്യൂട്ടഡ് നിർവഹണത്തിനുള്ള പ്രധാന പരിഗണനകൾ:

ടോക്കൺ ബക്കറ്റിന് പകരമുള്ളവ

ടോക്കൺ ബക്കറ്റ് അൽഗോരിതം ഒരു ജനപ്രിയ തിരഞ്ഞെടുപ്പാണെങ്കിലും, നിർദ്ദിഷ്ട ആവശ്യകതകളെ ആശ്രയിച്ച് മറ്റ് റേറ്റ്-ലിമിറ്റിംഗ് സാങ്കേതിക വിദ്യകൾ കൂടുതൽ അനുയോജ്യമായേക്കാം. ചില ബദലുകളുമായുള്ള ഒരു താരതമ്യം ഇതാ:

ശരിയായ അൽഗോരിതം തിരഞ്ഞെടുക്കുന്നു:

ഏറ്റവും മികച്ച റേറ്റ്-ലിമിറ്റിംഗ് അൽഗോരിതം തിരഞ്ഞെടുക്കുന്നത് ഇനിപ്പറയുന്ന ഘടകങ്ങളെ ആശ്രയിച്ചിരിക്കുന്നു:

റേറ്റ് ലിമിറ്റിംഗിനുള്ള മികച്ച രീതികൾ

റേറ്റ് ലിമിറ്റിംഗ് ഫലപ്രദമായി നടപ്പിലാക്കുന്നതിന് ശ്രദ്ധാപൂർവ്വമായ ആസൂത്രണവും പരിഗണനയും ആവശ്യമാണ്. പിന്തുടരാനുള്ള ചില മികച്ച രീതികൾ ഇതാ:

ഉപസംഹാരം

പ്രതിരോധശേഷിയുള്ളതും വികസിപ്പിക്കാവുന്നതുമായ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിനുള്ള ഒരു പ്രധാന സാങ്കേതികതയാണ് റേറ്റ് ലിമിറ്റിംഗ്. ഉപയോക്താക്കൾക്കോ ക്ലയിൻ്റുകൾക്കോ അഭ്യർത്ഥനകൾ നൽകാൻ കഴിയുന്ന നിരക്ക് നിയന്ത്രിക്കുന്നതിനും, സിസ്റ്റങ്ങളെ ദുരുപയോഗത്തിൽ നിന്ന് സംരക്ഷിക്കുന്നതിനും, ന്യായമായ ഉപയോഗം ഉറപ്പാക്കുന്നതിനും, മൊത്തത്തിലുള്ള പ്രകടനം മെച്ചപ്പെടുത്തുന്നതിനും ടോക്കൺ ബക്കറ്റ് അൽഗോരിതം വഴക്കമുള്ളതും ഫലപ്രദവുമായ ഒരു മാർഗ്ഗം നൽകുന്നു. ടോക്കൺ ബക്കറ്റ് അൽഗോരിതത്തിൻ്റെ തത്വങ്ങൾ മനസ്സിലാക്കുകയും നിർവ്വഹണത്തിനുള്ള മികച്ച രീതികൾ പിന്തുടരുകയും ചെയ്യുന്നതിലൂടെ, ഡെവലപ്പർമാർക്ക് ഏറ്റവും ആവശ്യപ്പെടുന്ന ട്രാഫിക് ലോഡുകൾ പോലും കൈകാര്യം ചെയ്യാൻ കഴിയുന്ന കരുത്തുറ്റതും വിശ്വസനീയവുമായ സിസ്റ്റങ്ങൾ നിർമ്മിക്കാൻ കഴിയും.

ഈ ബ്ലോഗ് പോസ്റ്റ് ടോക്കൺ ബക്കറ്റ് അൽഗോരിതം, അതിൻ്റെ നിർവ്വഹണം, ഗുണങ്ങൾ, ദോഷങ്ങൾ, ഉപയോഗങ്ങൾ എന്നിവയെക്കുറിച്ചുള്ള സമഗ്രമായ ഒരു അവലോകനം നൽകി. ഈ അറിവ് പ്രയോജനപ്പെടുത്തി, നിങ്ങളുടെ സ്വന്തം ആപ്ലിക്കേഷനുകളിൽ നിങ്ങൾക്ക് ഫലപ്രദമായി റേറ്റ് ലിമിറ്റിംഗ് നടപ്പിലാക്കാനും ലോകമെമ്പാടുമുള്ള ഉപയോക്താക്കൾക്കായി നിങ്ങളുടെ സേവനങ്ങളുടെ സ്ഥിരതയും ലഭ്യതയും ഉറപ്പാക്കാനും കഴിയും.