Die Einschr?nkung des PHP -API -Stroms kann durch feste Fensterz?hler, Schiebeberken, undichte Bucket -Algorithmen und Token -Bucket -Algorithmen erreicht werden. 1. Der feste Fensterschalter begrenzt die Anzahl der Anforderungen durch das Zeitfenster. 2. Der Schiebungsfensterschalter verfeinert das Zeitfenster, um eine genauere Strombegrenzung zu erm?glichen. 3. Der undichte Eimer -Algorithmus -Verfahren fordert mit konstanter Geschwindigkeit ein, um den Burst -Verkehr zu verhindern. 4. Der Token -Bucket -Algorithmus erm?glicht ein gewisses Ma? an Burst -Verkehr und steuert Anfragen durch den Verzehr von Token.

Einführung

Die Ratenbegrenzung ist ein unverzichtbarer Bestandteil des Aufbaues effizienter und sicherer PHP -APIs. Die aktuelle Begrenzung schützt nicht nur Ihre API vor Missbrauchs- und DDOS -Angriffen, sondern gew?hrleistet auch einen geringen Nutzung von Diensten und eine angemessene Zuweisung von Ressourcen. In diesem Artikel werden ausführliche verschiedene Technologien für PHP-API-Current-Limitierungen untersucht, um Ihre Implementierungsprinzipien, -vorteile und -Abwindungen sowie ihre Anwendung in tats?chlichen Projekten zu verstehen.

Durch das Lesen dieses Artikels erfahren Sie, wie Sie verschiedene aktuelle limitierende Strategien in PHP implementieren, wie Sie die entsprechende aktuelle Grenzmethode für Ihr Anwendungsszenario ausw?hlen und einige praktische Best Practices und Optimierungstechniken beherrschen.

überprüfung des Grundwissens

Die Kernidee der aktuellen Begrenzung besteht darin, die Anzahl der vom Kunden gestellten Anfragen innerhalb eines bestimmten Zeitraums auf die API zu begrenzen. Zu den üblichen Strombegrenzungsalgorithmen geh?ren feste Fensterz?hler, Schiebebergen, undichte Bucket -Algorithmen und Token -Bucket -Algorithmen. Als weit verbreitete serverseitige Skriptsprache bietet PHP mehrere M?glichkeiten zur Implementierung dieser Algorithmen.

In PHP wird die Strombegrenzung normalerweise durch Middleware oder eigenst?ndige Dienste erreicht. Middleware kann Anforderungen abfangen und die aktuelle limitierende Logik ausführen, w?hrend unabh?ngige Dienste eine gr??ere Flexibilit?t und Skalierbarkeit bieten k?nnen.

Kernkonzept oder Funktionsanalyse

Definition und Funktion des Strombegrenzungsalgorithmus

Der Zweck des aktuellen begrenzenden Algorithmus besteht darin, die H?ufigkeit von Anforderungen auf API -Ebene zu steuern, um zu verhindern, dass überm??ige Anforderungen an Systemabstürzen oder Leistungsverschlechterungen verursacht werden. Hier sind einige gemeinsame Strombegrenzungsalgorithmen:

• Fensterz?hler festgelegt : Die Zeit unterteilt die Zeit in fester Gr??e, und die Anforderungsanzahl in jedem Fenster überschreitet den festgelegten Schwellenwert nicht.
• Schiebefensterz?hler : Verfeinern Sie das Zeitfenster auf der Grundlage fester Fenster weiter, um eine genauere Strombegrenzung zu erm?glichen.
• Leck -Bucket -Algorithmus : Anfragen, um mit konstanter Geschwindigkeit auszuflie?en, ?hnlich wie bei Trichterleckagen, wodurch der Burst -Fluss verhindert wird.
• Token -Eimer -Algorithmus : Fügen Sie mit konstanter Geschwindigkeit Token in den Eimer. Die Anfrage muss das Token konsumieren und ein gewisses Ma? an Burst -Verkehr erm?glichen.

Wie es funktioniert

Fixed Fensterschalter

Der feste Fensterschalter ist der einfachste Strombegrenzungsalgorithmus. Hier ist eine einfache PHP -Implementierung:

 Klasse FixedWindowratelimiter {
    privat $ limit;
    private $ Windowsize;
    private $ Anfragen;

    ?ffentliche Funktion __construct ($ limit, $ Windowsize) {
        $ this-> limit = $ limit;
        $ this-> windows = $ Windowsize;
        $ this-> Anfragen = [];
    }

    ?ffentliche Funktion erlaubensRequest ($ clientID) {
        $ jetzt = Zeit ();
        $ windowStart = $ jetzt - ($ jetzt % $ this-> Windowsize);

        if (! isset ($ this-> Anfragen [$ clientID]) || $ this-> Anfragen [$ clientID] [&#39;start&#39;] <$ windowStart) {
            $ this-> Anfragen [$ clientID] = [&#39;start&#39; => $ windowStart, &#39;count&#39; => 1];
            zurückkehren;
        }

        if ($ this-> Anfragen [$ clientID] [&#39;count&#39;] <$ this-> limit) {
            $ this-> Anfragen [$ clientID] [&#39;count&#39;];
            zurückkehren;
        }

        false zurückgeben;
    }
}

In dieser Implementierung verwenden wir ein Array, um die Anzahl der Anfragen und die Fensterzeit für jeden Client aufzuzeichnen. Jedes Mal, wenn wir anfordern, überprüfen wir, ob die aktuelle Zeit in ein neues Fenster eingeht, und setzen Sie den Z?hler zurück. Andernfalls prüfen Sie, ob die Anzahl der Anforderungen im aktuellen Fenster die Grenze überschreitet.

Schieberfensterschalter

Der Schiebungsfensterschalter verfeinert das Zeitfenster basierend auf dem festen Fenster, um eine genauere Strombegrenzung bereitzustellen. Hier ist eine einfache PHP -Implementierung:

 Klasse Slidingwindowratelimiter {
    privat $ limit;
    private $ Windowsize;
    private $ Anfragen;

    ?ffentliche Funktion __construct ($ limit, $ Windowsize) {
        $ this-> limit = $ limit;
        $ WindowSize = $ Windowsize;
        $ this-> Anfragen = [];
    }

    ?ffentliche Funktion erlaubensRequest ($ clientID) {
        $ jetzt = Zeit ();
        $ this-> Anfragen [$ clientID] = array_filter ($ this-> Anfragen [$ clientID] ?? [], Funktion ($ timestamp) verwenden ($ jetzt, $ Windowsize) {
            Return $ timestamp> $ jetzt - $ Windowsize;
        });

        if (count ($ this-> Anfragen [$ clientID]) <$ this-> limit) {
            $ this-> Anfragen [$ clientID] [] = $ jetzt;
            zurückkehren;
        }

        false zurückgeben;
    }
}

In dieser Implementierung verwenden wir ein Array, um den Anforderungszeitstempel jedes Clients aufzuzeichnen. Jedes Mal, wenn wir anfordern, filtern wir Zeitstempel, die au?erhalb des Fensters liegen, und prüfen dann, ob die Anzahl der Anforderungen im aktuellen Fenster das Grenzwert überschreitet.

Leck -Eimer -Algorithmus

Der undichte Eimer -Algorithmus realisiert die Stromgrenze, indem der Prozess der Wasserleckage im Trichter simuliert wird. Hier ist eine einfache PHP -Implementierung:

 Klasse LactyBucketRatelimiter {
    private Kapazit?t;
    privat $ leckrate;
    privat $ currentAmount;
    private $ lastLeakTime;

    ?ffentliche Funktion __construct ($ CAPAPIT, $ leckrate) {
        $ this-> Kapazit?t = $ Kapazit?t;
        $ this-> lactrate = $ lactrate;
        $ this-> currentAmount = 0;
        $ this-> lastLeakTime = time ();
    }

    ?ffentliche Funktion erlaubtRequest () {
        $ jetzt = Zeit ();
        $ lecked = ($ jetzt-$ this-> lastLeakTime) * $ this-> leckrate;
        $ this-> currentAmount = max (0, $ this-> currentAmount-$ durchgesickert);
        $ this-> lastLeakTime = $ jetzt;

        if ($ this-> currentAmount 1 <= $ this-> Kapazit?t) {
            $ this-> currentAmount;
            zurückkehren;
        }

        false zurückgeben;
    }
}

In dieser Implementierung verwenden wir eine Variable, um die Wassermenge im aktuellen Eimer aufzuzeichnen. Jedes Mal, wenn wir anfordern, berechnen wir zun?chst die fehlende Wassermenge und prüfen dann, ob genügend Platz ist, um eine neue Anfrage hinzuzufügen.

Token -Bucket -Algorithmus

Der Token -Bucket -Algorithmus implementiert die Stromgrenze, indem der Prozess des Hinzufügens von Token zum Eimer simuliert wird. Hier ist eine einfache PHP -Implementierung:

 Klasse tokenbucketratelimiter {
    private Kapazit?t;
    privat $ fillrate;
    private $ tokens;
    private $ lastFilltime;

    ?ffentliche Funktion __construct ($ CAPAPIT, $ fillrate) {
        $ this-> Kapazit?t = $ Kapazit?t;
        $ this-> fillrate = $ fillrate;
        $ this-> tokens = $ Kapazit?t;
        $ this-> lastfilltime = time ();
    }

    ?ffentliche Funktion erlaubtRequest () {
        $ jetzt = Zeit ();
        $ tokenstoadd = ($ jetzt-$ this-> lastfilltime) * $ this-> fillrate;
        $ this-> tokens = min ($ this-> Kapazit?t, $ this-> tokens $ tokenstoadd);
        $ this-> lastfilltime = $ jetzt;

        if ($ this-> tokens> = 1) {
            $ this-> tokens--;
            zurückkehren;
        }

        false zurückgeben;
    }
}

In dieser Implementierung verwenden wir eine Variable, um die Anzahl der Token im aktuellen Eimer aufzuzeichnen. Jedes Mal, wenn wir anfordern, berechnen wir zun?chst die Anzahl der hinzugefügten Token und prüfen dann, ob genügend Token vorhanden sind, um die Anfrage zu verarbeiten.

Beispiel für die Nutzung

Grundnutzung

Hier ist ein einfaches Beispiel, das zeigt, wie die Limitierung des festen Fensterz?hlerstroms in der PHP -API verwendet wird:

 $ limator = neuer festerWindowratelimiter (10, 60); // bis zu 10 Anfragen pro Minute $ clientId = 'user123';
if ($ limper-> erlaubteRequest ($ clientID)) {
    // die Anfrage echo "Anfrage zul?ssig" verarbeiten;
} anders {
    // Rückgabefehlermeldung Echo "Ratenlimit überschritten";
}

Erweiterte Verwendung

In praktischen Anwendungen müssen Sie m?glicherweise mehrere aktuelle limitierende Algorithmen kombinieren, um komplexere Strategien für die aktuelleren limitierenden zu implementieren. Sie k?nnen beispielsweise den Token -Bucket -Algorithmus verwenden, um den Burst -Verkehr zu verarbeiten, w?hrend Sie einen festen Fensterz?hler verwenden, um die Gesamtanforderungsfrequenz zu begrenzen. Hier ist ein Beispiel:

 $ tokenbucket = neuer tokenbucketratelimiter (100, 1); // bis zu 100 Anfragen pro Sekunde $ FixedWindow = neuer festerWindowratelimiter (1000, 60); // bis zu 1000 Anfragen pro Minute $ clientId = 'user123';
if ($ tokenbucket-> erlaubteRequest () && $ FixedWindow-> erlaubteRequest ($ clientID)) {
    // die Anfrage echo "Anfrage zul?ssig" verarbeiten;
} anders {
    // Rückgabefehlermeldung Echo "Ratenlimit überschritten";
}

H?ufige Fehler und Debugging -Tipps

H?ufige Fehler bei der Implementierung der Strombegrenzung umfassen:

• Zeitfensterberechnung Fehler : Stellen Sie sicher, dass die Start- und Endzeit des Zeitfensters korrekt berechnet wird, und vermeiden Sie eine Fehleinsch?tzung, ob sich die Anforderung im selben Fenster befindet.
• Parallelit?tsproblem : Stellen Sie in einer hohen Genauigkeitsumgebung sicher, dass die aktuelle Logik mit Thread-Safe ist und vermeiden, dass mehrere Anfragen gleichzeitig die aktuelle Grenzüberprüfung bestehen.
• Datenpersistenzproblem : Wenn Sie Speicher zum Speichern von Stream -Limiting -Daten verwenden, stellen Sie sicher, dass die Daten nach dem Neustart des Servers nicht verloren gehen.

Zu den Debugging -F?higkeiten geh?ren:

• Protokollierung : Erfasst die aktuellen Limit -Check -Ergebnisse für jede Anfrage, um die Effektivit?t der aktuellen Grenzstrategie zu analysieren.
• Testwerkzeug : Verwenden Sie Lasttest -Tools, um hohe gleichzeitige Anforderungen zu simulieren und die Richtigkeit und Leistung der aktuellen Grenzstrategie zu überprüfen.

Leistungsoptimierung und Best Practices

In praktischen Anwendungen ist es sehr wichtig, die Leistung und Wartbarkeit der aktuellen Grenzstrategie zu optimieren. Hier sind einige Vorschl?ge:

• Die Verwendung von Redis oder anderen verteilten Caches : Die Verwendung verteilter Caches wie Redis zum Speichern von streambegrenzten Daten in hohen Parallelit?tsumgebungen kann die Leistung und Skalierbarkeit verbessern.
• Asynchrone Verarbeitung : Asynchronisieren Sie die aktuelle limitierende Logik, um die Blockierung der Anforderungsverarbeitung zu verringern.
• Dynamisch die aktuellen limitierenden Parameter einstellen : Passen Sie die aktuellen limitierenden Parameter dynamisch entsprechend dem tats?chlichen Durchfluss und der Systembelastung an, um eine flexiblere Strategie zur Strombegrenzung zu erreichen.

Bei der Auswahl eines aktuellen begrenzenden Algorithmus müssen die folgenden Faktoren berücksichtigt werden:

• Genauigkeit : Gleitfenster -Z?hler und Token -Bucket -Algorithmen sind genauer als feste Fensterz?hler, aber auch eine h?here Implementierungskomplexit?t aufweisen.
• Burst -Verkehrsverarbeitung : Der Token -Bucket -Algorithmus kann den Burst -Verkehr besser verarbeiten, w?hrend der Leck -Bucket -Algorithmus besser für einen reibungslosen Verkehr geeignet ist.
• Implementierungskomplexit?t : Der festste Fensterschalter ist der einfachste, kann jedoch zu einer ungenauen Strombegrenzung führen. Die Implementierung des Schiebungsfenster -Z?hlers und des Token -Bucket -Algorithmus ist komplexer, aber der aktuelle begrenzende Effekt ist besser.

Durch die Untersuchung dieses Artikels sollten Sie die grundlegenden Konzepte und Implementierungsmethoden der PHP -API -Stromlimit beherrschen. Hoffentlich hilft Ihnen dieses Wissen Ihnen, Ihre API in realen Projekten besser zu schützen und zu optimieren.

Das obige ist der detaillierte Inhalt vonBeschreiben Sie die Rate -Limiting -Techniken für PHP -APIs.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!