Liens rapides :

• Dépôt GitHub
• Documentation Wiki

Introduction:

Salut, passionnés d'open source et aficionados de Go ! Je suis de retour avec un rapide aperçu de mon projet open source, ThrottleX, un limiteur de débit distribué pour les API. Je suis encore assez nouveau dans ce monde open source, donc vos conseils sont toujours les bienvenus ! ?

ThrottleX est conçu pour vous aider à gérer efficacement le trafic API, en gardant votre système fluide et équitable. Qu'il s'agisse de prévenir les abus ou de gérer une charge élevée, ThrottleX est là pour vous. Explorons certains des algorithmes de limitation de débit qui rendent ThrottleX puissant. ?

Les algorithmes de limitation de débit expliqués ?‍?

ThrottleX est livré avec trois algorithmes de base pour vous aider à gérer le trafic de votre API :

1. Limitation de débit de fenêtre fixe

Comment ça marche : Imaginez diviser le temps en intervalles fixes. Au cours de chaque intervalle, vous autorisez un nombre fixe de requêtes, par exemple 100 requêtes par minute. Une fois la fenêtre fermée, le compteur se réinitialise.

Cas d'utilisation : idéal pour les modèles de trafic prévisibles, mais méfiez-vous du « problème de limite », où de nombreuses requêtes proches de la fin de la fenêtre peuvent contourner la limite de débit prévue.

2. Limitation de débit par fenêtre coulissante

Comment ça marche : c'est comme une moyenne mobile : au lieu de se réinitialiser complètement à la fin de chaque fenêtre, la limite de débit « glisse » dans le temps, offrant un contrôle plus fluide.

Cas d'utilisation : parfait pour éviter les pics et répartir les demandes plus uniformément.

3. Limitation du taux de compartiment de jetons

Comment ça marche : Imaginez un seau qui se remplit de jetons à un rythme constant. Les requêtes consomment des jetons, et si le compartiment est vide, les requêtes sont bloquées jusqu'à ce qu'il se remplisse.

Cas d'utilisation : idéal pour permettre des rafales soudaines de trafic si les jetons sont enregistrés.

Exemple d'utilisation ?️

Voici un exemple simple utilisant le limiteur de débit à fenêtre fixe :

package main

import (
    "github.com/neelp03/throttlex/ratelimiter"
    "github.com/neelp03/throttlex/store"
    "time"
    "fmt"
)

func main() {
    // Initialize an in-memory store and a Fixed Window rate limiter
    memStore := store.NewMemoryStore()
    limiter, err := ratelimiter.NewFixedWindowLimiter(memStore, 10, time.Minute)
    if err != nil {
        fmt.Println("Failed to create limiter:", err)
        return
    }

    // Simulate API requests
    key := "user1"
    for i := 0; i 



Résultat attendu :



Request 1 allowed
Request 2 allowed
... (up to 10 allowed)
Request 11 blocked
Request 12 blocked
... (up to 15 blocked)





  
  
  Quelle est la prochaine étape pour ThrottleX ? ?

• Limitation de débit prioritaire : différentes priorités pour différents utilisateurs.
• Limitation de débit dynamique : ajustez les limites en fonction de la charge du serveur.
• Limite de concurrence : gérer les demandes simultanées.

Restez à l'écoute de ces futures mises à jour qui rendront ThrottleX encore plus puissant !

Comment pouvez-vous contribuer ?

Je suis encore nouveau dans l'open source et j'aimerais que vous fassiez partie de ce voyage ! Les contributions sont toujours les bienvenues, qu'il s'agisse de corrections de bugs, de suggestions ou d'améliorations de la documentation.

Consultez le dépôt : ThrottleX GitHub Repo et donnez-lui une étoile si vous le trouvez utile. N'hésitez pas à ouvrir des tickets ou à tirer des demandes : chaque geste compte !

Réflexions finales

ThrottleX est ma tentative de rendre la limitation du débit de l'API plus accessible et plus efficace. Rendons cela amusant (et moins pénible) ! ?