


Avec l'utilisation croissante des applications Web modernes, de nombreuses demandes d'utilisateurs commencent à affluer sur le serveur, ce qui provoque certains problèmes. D'une part, les performances du serveur sont limitées et il n'y a aucune garantie que toutes les requêtes puissent être traitées ; d'autre part, un grand nombre de requêtes arrivant en même temps peut rendre le service instable ; À l'heure actuelle, limiter le taux de requêtes est devenu un choix inévitable. Ce qui suit présente comment utiliser Golang pour implémenter la limitation du courant de requête.
Qu'est-ce que la limitation actuelle ?
La limitation actuelle fait référence à la limitation du nombre maximum de requêtes ou de trafic de données qu'une application, un système ou un service peut supporter pendant une certaine période de temps. La limitation actuelle peut nous aider à atténuer les attaques réseau et à prévenir les abus de bande passante et de ressources. Nous appelons généralement cette limite « contrôle de flux », qui peut hiérarchiser les demandes de différents types et sources et traiter les demandes de différents types et sources dans différentes proportions.
Implémenter la limitation de courant de demande
Algorithme de limitation de courant de fenêtre basé sur la fenêtre de temps
L'algorithme le plus simple et le plus direct est l'algorithme de limitation de courant basé sur la fenêtre de temps. Il vérifie si le nombre total de requêtes envoyées au cours de la période la plus récente dépasse un seuil. La durée de la fenêtre temporelle peut être ajustée en fonction des caractéristiques de l'application pour obtenir des performances optimales et un taux de fausses alarmes minimum.
Supposons que nous devions limiter le nombre maximum d'accès par seconde à une API. Nous pouvons utiliser le package time de Golang pour compter le trafic et utiliser des canaux tampons pour implémenter des files d'attente de requêtes. Le code est le suivant :
type ApiLimiter struct { rate float64 // 时间窗口内最大请求数 capacity int // 请求队列最大长度,即最多能有多少请求同时被处理 requestNum int // 时间窗口内已处理请求总数 queue chan int // 缓冲通道,用于实现请求队列 } func NewApiLimiter(rate float64, capacity int) *ApiLimiter { return &ApiLimiter{ rate: rate, capacity: capacity, requestNum: 0, queue: make(chan int, capacity), } } func (al *ApiLimiter) Request() bool { now := time.Now().UnixNano() maxRequestNum := int(float64(now)/float64(time.Second)*al.rate) + 1 // 统计最近一秒内应该处理的请求数量 if maxRequestNum <p>Dans cet exemple, nous utilisons chan dans Golang pour implémenter la file d'attente des requêtes et utilisons le package time pour calculer le nombre de requêtes dans la fenêtre de temps. Une fois que chaque requête atteint le serveur, nous mettrons la requête dans la file d'attente et le volume de la requête sera également comparé au nombre maximum de requêtes. Si le nombre maximum de requêtes est dépassé, false sera renvoyé. </p><h3 id="Leaky-Bucket-Algorithm">Leaky Bucket Algorithm</h3><p>Leaky Bucket Algorithm est un autre algorithme de limitation de courant célèbre. À tout moment, le bucket qui fuit conserve un certain nombre de requêtes. Lorsqu'une nouvelle demande arrive, vérifiez d'abord si le nombre de demandes restant dans le compartiment qui fuit atteint le montant maximum de la demande. Si tel est le cas, rejetez la nouvelle demande, sinon, placez la nouvelle demande dans le compartiment et réduisez le nombre de demandes dans le compartiment. par un. </p><p>L'algorithme du bucket qui fuit peut être implémenté à l'aide de coroutines et de minuteries dans Golang. Nous pouvons utiliser une minuterie pour représenter notre seau qui fuit et qui s'écoule lentement des requêtes au fil du temps. Le code est le suivant : </p><pre class="brush:php;toolbar:false">type LeakyBucket struct { rate float64 // 漏桶每秒处理的请求量(R) capacity int // 漏桶的大小(B) water int // 漏桶中当前的水量(当前等待处理的请求个数) lastLeaky int64 // 上一次请求漏出的时间,纳秒 leakyTimer *time.Timer // 漏桶接下来漏水需要等待的时间 reject chan int // 被拒绝的请求通道 } func NewLeakyBucket(rate float64, capacity int) *LeakyBucket { bucket := &LeakyBucket{ rate: rate, capacity: capacity, water: 0, reject: make(chan int, 1000), } bucket.leakyTimer = time.NewTimer(time.Second / time.Duration(rate)) return bucket } func (lb *LeakyBucket) Request() chan int { select { case 0 { lb.water -= 1 lb.leakyTimer.Reset(time.Second / time.Duration(lb.rate)) return nil // 请求被允许 } lb.leakyTimer.Reset(time.Second / time.Duration(lb.rate)) return lb.reject // 请求被拒绝 default: if lb.water >= lb.capacity { return lb.reject // 请求被拒绝 } else { lb.water += 1 // 请求被允许 return nil } } }
Dans cet exemple, nous utilisons le timer de Golang pour réaliser le taux de sortie du seau qui fuit, et utilisons chan pour réaliser la mise en mémoire tampon des requêtes. Nous avons d'abord créé une minuterie pour vérifier régulièrement le nombre de demandes restantes (eau) dans le seau qui fuit. Avant que la demande ne soit acceptée, nous vérifierons d'abord si elle a atteint la capacité maximale à traiter. Si tel est le cas, nous renverrons un rejet ; sinon, nous le mettrons dans un seau qui fuit et ajouterons 1 à la quantité d'eau.
Autres réflexions
Dans cet article, nous présentons deux algorithmes courants de limitation de courant de requête : l'algorithme de limitation de courant basé sur une fenêtre et l'algorithme de compartiment à fuite. Cependant, il existe de nombreuses autres variantes de ces algorithmes, telles que le contrôle de flux basé sur l'importance de la requête ou combiné à des structures de données de file d'attente. Golang lui-même présente d'excellents modèles de concurrence et de coroutine, ce qui en fait l'un des meilleurs outils pour implémenter la limitation des requêtes.
À l'avenir, avec le développement en profondeur de l'intelligence artificielle, du big data et d'autres technologies, nous aurons besoin de meilleurs algorithmes de limitation de courant pour prendre en charge le fonctionnement de nos applications. Alors, avant d’aller plus loin, explorons et étudions ensemble ce domaine en constante évolution.
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!

Cet article explique les mécanismes d'importation des packages de Go: les importations nommées (par exemple, importation & quot; fmt & quot;) et les importations vierges (par exemple, importation _ & quot; fmt & quot;). Les importations nommées rendent le contenu du package accessible, tandis que les importations vierges ne font que l'exécuter t

Cet article détaille la conversion efficace de la requête MySQL Resulte en tranches de structure GO. Il met l'accent sur l'utilisation de la méthode de numérisation de la base de données / SQL pour des performances optimales, en évitant l'analyse manuelle. Meilleures pratiques pour la cartographie des champs struct à l'aide de balises DB et de robus

Cet article explique la fonction Newflash () de Beego pour le transfert de données inter-pages dans les applications Web. Il se concentre sur l'utilisation de NewFlash () pour afficher les messages temporaires (succès, erreur, avertissement) entre les contrôleurs, en tirant parti du mécanisme de session. Limiter

Cet article montre la création de simulations et de talons dans GO pour les tests unitaires. Il met l'accent sur l'utilisation des interfaces, fournit des exemples d'implémentations simulées et discute des meilleures pratiques telles que la tenue de simulations concentrées et l'utilisation de bibliothèques d'assertion. L'articl

Cet article explore les contraintes de type personnalisé de Go pour les génériques. Il détaille comment les interfaces définissent les exigences de type minimum pour les fonctions génériques, améliorant la sécurité du type et la réutilisabilité du code. L'article discute également des limitations et des meilleures pratiques

Cet article détaille la rédaction de fichiers efficace dans GO, en comparant OS.WriteFile (adapté aux petits fichiers) avec OS.OpenFile et Buffered Writes (optimal pour les fichiers volumineux). Il met l'accent sur la gestion robuste des erreurs, l'utilisation de différer et la vérification des erreurs spécifiques.

L'article traite des tests d'unité d'écriture dans GO, couvrant les meilleures pratiques, des techniques de moquerie et des outils pour une gestion efficace des tests.

Cet article explore l'utilisation d'outils de traçage pour analyser le flux d'exécution des applications GO. Il traite des techniques d'instrumentation manuelles et automatiques, de comparaison d'outils comme Jaeger, Zipkin et OpenTelelemetry, et mettant en évidence une visualisation efficace des données


Outils d'IA chauds

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.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

ZendStudio 13.5.1 Mac
Puissant environnement de développement intégré PHP

Adaptateur de serveur SAP NetWeaver pour Eclipse
Intégrez Eclipse au serveur d'applications SAP NetWeaver.

Version crackée d'EditPlus en chinois
Petite taille, coloration syntaxique, ne prend pas en charge la fonction d'invite de code

DVWA
Damn Vulnerable Web App (DVWA) est une application Web PHP/MySQL très vulnérable. Ses principaux objectifs sont d'aider les professionnels de la sécurité à tester leurs compétences et leurs outils dans un environnement juridique, d'aider les développeurs Web à mieux comprendre le processus de sécurisation des applications Web et d'aider les enseignants/étudiants à enseigner/apprendre dans un environnement de classe. Application Web sécurité. L'objectif de DVWA est de mettre en pratique certaines des vulnérabilités Web les plus courantes via une interface simple et directe, avec différents degrés de difficulté. Veuillez noter que ce logiciel

Télécharger la version Mac de l'éditeur Atom
L'éditeur open source le plus populaire
