Ratenbegrenzung für Anfänger: Was es ist und wie man eine solche in Go erstellt

Ratenbegrenzung ist ein entscheidendes Konzept in der Webentwicklung und im API-Design. Es stellt sicher, dass Benutzer oder Systeme innerhalb eines bestimmten Zeitraums nur eine begrenzte Anzahl von Anfragen an einen Server stellen können. In diesem Blogbeitrag werden wir untersuchen, was Ratenbegrenzung ist, warum sie wichtig ist und wie man eine einfache Ratenbegrenzung in Go implementiert.

Was ist Ratenbegrenzung?

Stellen Sie sich einen Themenpark mit einer Achterbahnfahrt vor, in der alle 10 Minuten nur 10 Personen Platz finden. Wenn mehr als 10 Personen versuchen, innerhalb dieses Zeitraums weiterzukommen, müssen sie warten. Diese Analogie spiegelt das Prinzip der Ratenbegrenzung in Softwaresystemen wider.

Technisch gesehen begrenzt die Ratenbegrenzung die Anzahl der Anfragen, die ein Client (z. B. ein Benutzer, ein Gerät oder eine IP-Adresse) innerhalb eines vordefinierten Zeitraums an einen Server senden kann. Es hilft:

1. Verhindern Sie Missbrauch und sorgen Sie für eine faire Nutzung der Ressourcen.
2. Schützen Sie Server vor Überlastung durch übermäßigen Datenverkehr.
3. Vermeiden Sie die kostspielige übermäßige Nutzung von APIs oder Diensten Dritter.

Zum Beispiel könnte eine API 100 Anfragen pro Minute und Benutzer zulassen. Wenn ein Benutzer dieses Limit überschreitet, lehnt der Server weitere Anfragen ab, bis das Limit zurückgesetzt wird.

Wie funktioniert die Ratenbegrenzung?

Eine gängige Methode zur Implementierung einer Ratenbegrenzung ist der Token-Bucket-Algorithmus. So funktioniert es:

1. Ein Bucket beginnt mit einer festen Anzahl von Token (z. B. 10).
2. Jede Anfrage entfernt ein Token aus dem Bucket.
3. Wenn der Bucket keine Token mehr hat, wird die Anfrage abgelehnt.
4. Tokens werden mit einer gleichmäßigen Rate (z. B. 1 Token pro Sekunde) aufgefüllt, bis der Eimer voll ist.

Erstellen eines einfachen Ratenbegrenzers in Go

Lassen Sie uns einen Ratenbegrenzer in Go erstellen, der jeden Client auf 3 Anfragen pro Minute begrenzt.

Schritt 1: Definieren Sie die Ratenbegrenzerstruktur

Wir verwenden den sync.Mutex, um die Thread-Sicherheit zu gewährleisten und Informationen wie die Anzahl der Token, die maximale Kapazität und die Nachfüllrate zu speichern.

package main

import (
    "sync"
    "time"
)

type RateLimiter struct {
    tokens         float64   // Current number of tokens
    maxTokens      float64   // Maximum tokens allowed
    refillRate     float64   // Tokens added per second
    lastRefillTime time.Time // Last time tokens were refilled
    mutex          sync.Mutex
}

func NewRateLimiter(maxTokens, refillRate float64) *RateLimiter {
    return &RateLimiter{
        tokens:         maxTokens,
        maxTokens:      maxTokens,
        refillRate:     refillRate,
        lastRefillTime: time.Now(),
    }
}

Schritt 2: Implementieren Sie die Token-Nachfülllogik

Tokens sollten regelmäßig basierend auf der seit der letzten Auffüllung verstrichenen Zeit aufgefüllt werden.

func (r *RateLimiter) refillTokens() {
    now := time.Now()
    duration := now.Sub(r.lastRefillTime).Seconds()
    tokensToAdd := duration * r.refillRate

    r.tokens += tokensToAdd
    if r.tokens > r.maxTokens {
        r.tokens = r.maxTokens
    }
    r.lastRefillTime = now
}

Schritt 3: Prüfen Sie, ob eine Anfrage zulässig ist

Die Allow-Methode bestimmt anhand der verfügbaren Token, ob eine Anfrage fortgesetzt werden kann.

func (r *RateLimiter) Allow() bool {
    r.mutex.Lock()
    defer r.mutex.Unlock()

    r.refillTokens()

    if r.tokens >= 1 {
        r.tokens--
        return true
    }
    return false
}

Schritt 4: Wenden Sie eine Ratenbegrenzung pro IP an

Um die Anfragen pro Client zu begrenzen, erstellen wir eine Zuordnung der IP-Adressen zu ihren jeweiligen Ratenbegrenzern.

type IPRateLimiter struct {
    limiters map[string]*RateLimiter
    mutex    sync.Mutex
}

func NewIPRateLimiter() *IPRateLimiter {
    return &IPRateLimiter{
        limiters: make(map[string]*RateLimiter),
    }
}

func (i *IPRateLimiter) GetLimiter(ip string) *RateLimiter {
    i.mutex.Lock()
    defer i.mutex.Unlock()

    limiter, exists := i.limiters[ip]
    if !exists {
        // Allow 3 requests per minute
        limiter = NewRateLimiter(3, 0.05)
        i.limiters[ip] = limiter
    }

    return limiter
}

Schritt 5: Erstellen Sie Middleware für die Ratenbegrenzung

Zuletzt erstellen wir eine HTTP-Middleware, die das Ratenlimit für jeden Client durchsetzt.

package main

import (
    "sync"
    "time"
)

type RateLimiter struct {
    tokens         float64   // Current number of tokens
    maxTokens      float64   // Maximum tokens allowed
    refillRate     float64   // Tokens added per second
    lastRefillTime time.Time // Last time tokens were refilled
    mutex          sync.Mutex
}

func NewRateLimiter(maxTokens, refillRate float64) *RateLimiter {
    return &RateLimiter{
        tokens:         maxTokens,
        maxTokens:      maxTokens,
        refillRate:     refillRate,
        lastRefillTime: time.Now(),
    }
}

Schritt 6: Richten Sie den Server ein

Hier erfahren Sie, wie Sie alles zusammenfügen und den Ratenbegrenzer testen.

func (r *RateLimiter) refillTokens() {
    now := time.Now()
    duration := now.Sub(r.lastRefillTime).Seconds()
    tokensToAdd := duration * r.refillRate

    r.tokens += tokensToAdd
    if r.tokens > r.maxTokens {
        r.tokens = r.maxTokens
    }
    r.lastRefillTime = now
}

Testen des Ratenbegrenzers

Starten Sie den Server und testen Sie ihn mit Curl oder Ihrem Browser:

func (r *RateLimiter) Allow() bool {
    r.mutex.Lock()
    defer r.mutex.Unlock()

    r.refillTokens()

    if r.tokens >= 1 {
        r.tokens--
        return true
    }
    return false
}

• Senden Sie schnell 3 Anfragen: Alle sollten erfolgreich sein.
• Senden Sie innerhalb derselben Minute eine vierte Anfrage: Sie sollten die Meldung „Ratenlimit überschritten“ sehen.
• Warten Sie 20 Sekunden und versuchen Sie es erneut: Der Eimer wird wieder aufgefüllt und die Anfragen sollten erfolgreich sein.

Quellcode

GitHub Repo

Das obige ist der detaillierte Inhalt vonRatenbegrenzung für Anfänger: Was es ist und wie man eine solche in Go erstellt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!