Ajout d'une limitation de débit d'API à votre API Go
Très bien, les amis, nous avons abordé beaucoup de choses jusqu'à présent : l'authentification JWT, les connexions à la base de données, la journalisation et la gestion des erreurs. Mais que se passe-t-il lorsque votre API commence à être critiquée par des requêtes ? Sans contrôle, un trafic élevé peut entraîner des temps de réponse lents, voire des temps d'arrêt. ?
Cette semaine, nous allons résoudre ce problème en mettant en œuvre une limitation du débit pour contrôler le flux du trafic. Nous utiliserons le package simple et efficace golang.org/x/time/rate. Plus tard, lorsque ma propre solution ThrottleX sera prête, je vous montrerai comment l'intégrer en tant qu'option plus évolutive. (Psst, consultez mon GitHub sur github.com/neelp03/throttlex pour les mises à jour ! N'hésitez pas à commenter tout problème que vous y voyez o7)
Pourquoi limiter les taux ? ?
La limitation de débit est comme un videur pour votre API : elle contrôle le nombre de requêtes que les utilisateurs peuvent effectuer dans un délai donné. Cela évite que votre API ne soit submergée, garantissant un accès fluide et équitable à tous les utilisateurs. La limitation du débit est essentielle pour :
- Prévenir les abus : empêche les mauvais acteurs ou les utilisateurs trop enthousiastes de surcharger votre API.
- Stabilité : maintient votre API réactive et fiable, même en cas de pics de trafic.
- Équité : permet de partager les ressources de manière égale entre les utilisateurs.
Étape 1 : Installation du package temps/taux
Le package golang.org/x/time/rate fait partie des bibliothèques Go étendues et fournit un limiteur de débit simple basé sur des jetons. Pour commencer, vous devrez l'installer :
go get golang.org/x/time/rate
Étape 2 : configuration du limiteur de débit
Créons un middleware limitant le débit qui contrôle le nombre de requêtes qu'un client peut effectuer. Dans cet exemple, nous limiterons les clients à 5 requêtes par minute.
package main
import (
"net/http"
"golang.org/x/time/rate"
"sync"
"time"
)
// Create a struct to hold each client's rate limiter
type Client struct {
limiter *rate.Limiter
}
// In-memory storage for clients
var clients = make(map[string]*Client)
var mu sync.Mutex
// Get a client's rate limiter or create one if it doesn't exist
func getClientLimiter(ip string) *rate.Limiter {
mu.Lock()
defer mu.Unlock()
// If the client already exists, return the existing limiter
if client, exists := clients[ip]; exists {
return client.limiter
}
// Create a new limiter with 5 requests per minute
limiter := rate.NewLimiter(5, 1)
clients[ip] = &Client{limiter: limiter}
return limiter
}
Étape 3 : Création du middleware de limitation de débit
Utilisons maintenant la fonction getClientLimiter dans un middleware qui restreindra l'accès en fonction de la limite de débit.
func rateLimitingMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ip := r.RemoteAddr
limiter := getClientLimiter(ip)
// Check if the request is allowed
if !limiter.Allow() {
http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
return
}
next.ServeHTTP(w, r)
})
}
Comment ça marche :
- Limitation basée sur IP : Chaque client est identifié par son adresse IP. Nous vérifions l'adresse IP du client et lui attribuons un limiteur de débit.
- Request Check : la méthode limiteur.Allow() vérifie si le client est dans la limite de débit. Si tel est le cas, la demande est transmise au gestionnaire suivant ; sinon, nous répondons avec 429 demandes trop nombreuses.
Étape 4 : appliquer le middleware à l’échelle mondiale ?
Connectons maintenant notre limiteur de débit à l'API pour que chaque requête doive passer par elle :
func main() {
db = connectDB()
defer db.Close()
r := mux.NewRouter()
// Apply rate-limiting middleware globally
r.Use(rateLimitingMiddleware)
// Other middlewares
r.Use(loggingMiddleware)
r.Use(errorHandlingMiddleware)
r.HandleFunc("/login", login).Methods("POST")
r.Handle("/books", authenticate(http.HandlerFunc(getBooks))).Methods("GET")
r.Handle("/books", authenticate(http.HandlerFunc(createBook))).Methods("POST")
fmt.Println("Server started on port :8000")
log.Fatal(http.ListenAndServe(":8000", r))
}
En appliquant r.Use(rateLimitingMiddleware), nous garantissons que chaque requête entrante est vérifiée par le limiteur de débit avant qu'elle n'atteigne un point final.
Étape 5 : tester la limitation de débit ?
Démarrez votre serveur :
go run main.go
Maintenant, passons à l'API avec quelques requêtes. Vous pouvez utiliser une boucle avec curl pour simuler plusieurs requêtes d'affilée :
for i in {1..10}; do curl http://localhost:8000/books; done
Puisque nous avons fixé la limite à 5 requêtes par minute, vous devriez voir 429 trop de demandes réponses une fois que vous dépassez le taux autorisé.
Quelle est la prochaine étape ?
Et voilà : limitation du débit avec golang.org/x/time/rate pour maintenir votre API stable et réactive sous pression. La limitation de débit est un outil crucial pour toute API évolutive, et nous ne faisons qu’effleurer la surface ici.
Une fois que ThrottleX sera prêt pour la production, je publierai un didacticiel de suivi pour vous montrer comment l'intégrer dans votre API Go pour encore plus de flexibilité et une limitation du débit distribué. Gardez un œil sur mon dépôt ThrottleX GitHub pour les mises à jour !
La semaine prochaine, nous allons conteneuriser notre API avec Docker, afin qu'elle soit prête à fonctionner n'importe où. Restez à l'écoute et bon codage ! ??
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Outils d'IA chauds
Undress AI Tool
Images de déshabillage gratuites
Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes
AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.
Clothoff.io
Dissolvant de vêtements AI
Video Face Swap
Échangez les visages dans n'importe quelle vidéo sans effort grâce à notre outil d'échange de visage AI entièrement gratuit !
Article chaud
Outils chauds
Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit
SublimeText3 version chinoise
Version chinoise, très simple à utiliser
Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP
Dreamweaver CS6
Outils de développement Web visuel
SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)
Développer des opérateurs de Kubernetes en Go
Jul 25, 2025 am 02:38 AM
La façon la plus efficace d'écrire un kubernetesoperator est d'utiliser Go pour combiner kubebuilder et contrôleur-runtime. 1. Comprendre le modèle de l'opérateur: définir les ressources personnalisées via CRD, écrivez un contrôleur pour écouter les changements de ressources et effectuer des boucles de réconciliation pour maintenir l'état attendu. 2. Utilisez KubeBuilder pour initialiser le projet et créer des API pour générer automatiquement les CRD, les contrôleurs et les fichiers de configuration. 3. Définissez la structure de spécification et de statut de CRD dans API / V1 / MYAPP_TYPES.go, et exécutez MakeManifests pour générer CRDYAML. 4. Réconcilier dans le contrôleur
Passez l'exemple de l'exemple de journalisation du middleware http
Aug 03, 2025 am 11:35 AM
HTTP Log Middleware dans GO peut enregistrer les méthodes de demande, les chemins de requête, la propriété intellectuelle du client et le temps qui prend du temps. 1. Utilisez http.handlerfunc pour envelopper le processeur, 2. Enregistrez l'heure de début et l'heure de fin avant et après l'appel Suivant.Servehttp, 3. Obtenez le vrai client IP via R.RemoteAddr et X-Forwared-For Headers, 4. Utilisez le log.printf aux journaux de demande de sortie, 5. L'exemple de code complet a été vérifié pour s'exécuter et convient au démarrage d'un projet petit et moyen. Les suggestions d'extension incluent la capture des codes d'état, la prise en charge des journaux JSON et le suivi des ID de demande.
La lecture de Stdin dans GO par l'exemple
Jul 27, 2025 am 04:15 AM
Utilisez fmt.scanf pour lire l'entrée formatée, adaptée aux données structurées simples, mais la chaîne est coupée lors de la rencontre des espaces; 2. Il est recommandé d'utiliser Bufio.Scanner pour lire la ligne par ligne, prend en charge les entrées multi-lignes, la détection EOF et l'entrée du pipeline et peut gérer les erreurs de numérisation; 3. Utilisez io.readall (os.stdin) pour lire toutes les entrées à la fois, adapté au traitement de grandes données de bloc ou de flux de fichiers; 4. La réponse clé en temps réel nécessite des bibliothèques tierces telles que golang.org/x/term, et Bufio est suffisant pour les scénarios conventionnels; Suggestions pratiques: utilisez fmt.scan pour une entrée simple interactive, utilisez bufio.scanner pour une entrée de ligne ou un pipeline, utilisez io.readall pour les données de gros bloc et gérez toujours
Comment fonctionne l'instruction Switch?
Jul 30, 2025 am 05:11 AM
L'instruction Switch de Go ne sera pas exécutée tout au long du processus par défaut et quittera automatiquement après la correspondance de la première condition. 1. Switch commence par un mot-clé et peut transporter une valeur ou aucune valeur; 2. Les matchs de cas de haut en bas dans l'ordre, seul le premier match est exécuté; 3. Plusieurs conditions peuvent être répertoriées par des virgules pour correspondre au même cas; 4. Il n'est pas nécessaire d'ajouter manuellement la pause, mais peut être forcé; 5.Default est utilisé pour les cas inégalés, généralement placés à la fin.
Passez par l'exemple des génériques
Jul 29, 2025 am 04:10 AM
Les génériques GO sont pris en charge depuis 1.18 et sont utilisés pour écrire du code générique pour le type de type. 1. La fonction générique imprimslice [tany] (s [] t) peut imprimer des tranches de tout type, telles que [] int ou [] chaîne. 2. Grâce au nombre de contraintes de type, les limites des types numériques tels que int et float, sum [tnumber] (tranche [] t) t La sommation sûre est réalisée. 3. La boîte de type générique de structure [tany] struct {Valuet} peut encapsuler n'importe quelle valeur de type et être utilisée avec le constructeur newbox [tany] (VT) * Box [t]. 4. Ajouter SET (VT) et Get () T Méthodes T à boxer [t] sans
Quelle est la disposition du projet standard pour une application GO?
Aug 02, 2025 pm 02:31 PM
La réponse est: les applications GO n'ont pas de disposition de projet obligatoire, mais la communauté adopte généralement une structure standard pour améliorer la maintenabilité et l'évolutivité. 1.CMD / Stocke l'entrée du programme, chaque sous-répertoire correspond à un fichier exécutable, tel que cmd / myapp / main.go; 2. Le code privé à l'intérieur / stocke ne peut pas être importé par des modules externes et est utilisé pour encapsuler la logique et les services commerciaux; 3.PKG / Stores Bibliothèques réutilisables publiquement pour importer d'autres projets; 4.API / stocke éventuellement OpenAPI, Protobuf et autres fichiers de définition d'API; 5.Config /, Scripts / et Web / Store Files de configuration, scripts et ressources Web respectivement; 6. Le répertoire racine contient Go.mod et Go.sum
Intégrer Go avec Kafka pour les données de streaming
Jul 26, 2025 am 08:17 AM
L'intégration GO et Kafka est une solution efficace pour créer des systèmes de données en temps réel haute performance. La bibliothèque client appropriée doit être sélectionnée en fonction des besoins: 1. La priorité est donnée à Kafka-Go pour obtenir des API de style go simple et un bon soutien de contexte, adapté à un développement rapide; 2. Sélectionnez Sarama lorsque des fonctions de contrôle fin ou avancées sont nécessaires; 3. Lors de la mise en œuvre des producteurs, vous devez configurer l'adresse du courtier, le thème et la stratégie d'équilibrage de chargement et gérer les délais d'expiration et les fermetures à travers le contexte; 4. Les consommateurs doivent utiliser des groupes de consommateurs pour atteindre l'évolutivité et la tolérance aux défauts, soumettre automatiquement les décalages et utiliser raisonnablement un traitement simultané; 5. Utilisez JSON, AVRO ou Protobuf pour la sérialisation, et il est recommandé de combiner Schemaregist
Comment implémenter efficacement une structure de données définie dans GO?
Jul 25, 2025 am 03:58 AM
GO n'a pas de type de collecte intégré, mais il peut être implémenté efficacement via des cartes. Utiliser la carte [t] struct {} Pour stocker les touches d'élément, les structures vides ont zéro surcharge de mémoire et la mise en œuvre de l'addition, de l'inspection, de la suppression et d'autres opérations sont O (1) complexité temporelle; Dans un environnement simultané, Sync.RwMutex ou Sync.MAP peut être combiné pour assurer la sécurité des filetages; En termes de performances, d'utilisation de la mémoire, de coût et de désordre de hachage; Il est recommandé d'encapsuler ADD, supprimer, contient, taille et autres méthodes pour simuler le comportement de collecte standard.
