recherche
Maisondéveloppement back-endGolangComment utiliser Golang pour implémenter la limitation du courant des requêtes

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!

Déclaration
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
GO Language Pack Import: Quelle est la différence entre le soulignement et sans soulignement?GO Language Pack Import: Quelle est la différence entre le soulignement et sans soulignement?Mar 03, 2025 pm 05:17 PM

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

Comment convertir la liste des résultats de la requête MySQL en une tranche de structure personnalisée dans le langage Go?Comment convertir la liste des résultats de la requête MySQL en une tranche de structure personnalisée dans le langage Go?Mar 03, 2025 pm 05:18 PM

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

Comment mettre en œuvre le transfert d'informations à court terme entre les pages du cadre Beego?Comment mettre en œuvre le transfert d'informations à court terme entre les pages du cadre Beego?Mar 03, 2025 pm 05:22 PM

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

Comment écrire des objets et des talons simulés pour les tests en Go?Comment écrire des objets et des talons simulés pour les tests en Go?Mar 10, 2025 pm 05:38 PM

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

Comment puis-je définir des contraintes de type personnalisé pour les génériques en Go?Comment puis-je définir des contraintes de type personnalisé pour les génériques en Go?Mar 10, 2025 pm 03:20 PM

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

Comment écrire des fichiers dans GO Language de manière pratique?Comment écrire des fichiers dans GO Language de manière pratique?Mar 03, 2025 pm 05:15 PM

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.

Comment rédigez-vous des tests unitaires en Go?Comment rédigez-vous des tests unitaires en Go?Mar 21, 2025 pm 06:34 PM

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.

Comment puis-je utiliser des outils de traçage pour comprendre le flux d'exécution de mes applications GO?Comment puis-je utiliser des outils de traçage pour comprendre le flux d'exécution de mes applications GO?Mar 10, 2025 pm 05:36 PM

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

See all articles

Outils d'IA chauds

Undresser.AI Undress

Undresser.AI Undress

Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover

AI Clothes Remover

Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool

Undress AI Tool

Images de déshabillage gratuites

Clothoff.io

Clothoff.io

Dissolvant de vêtements AI

AI Hentai Generator

AI Hentai Generator

Générez AI Hentai gratuitement.

Article chaud

R.E.P.O. Crystals d'énergie expliqués et ce qu'ils font (cristal jaune)
2 Il y a quelques semainesBy尊渡假赌尊渡假赌尊渡假赌
Repo: Comment relancer ses coéquipiers
4 Il y a quelques semainesBy尊渡假赌尊渡假赌尊渡假赌
Hello Kitty Island Adventure: Comment obtenir des graines géantes
3 Il y a quelques semainesBy尊渡假赌尊渡假赌尊渡假赌

Outils chauds

ZendStudio 13.5.1 Mac

ZendStudio 13.5.1 Mac

Puissant environnement de développement intégré PHP

Adaptateur de serveur SAP NetWeaver pour Eclipse

Adaptateur de serveur SAP NetWeaver pour Eclipse

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

Version crackée d'EditPlus en chinois

Version crackée d'EditPlus en chinois

Petite taille, coloration syntaxique, ne prend pas en charge la fonction d'invite de code

DVWA

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

Télécharger la version Mac de l'éditeur Atom

L'éditeur open source le plus populaire