Implémentation de la limitation de débit en Go

GolangGolangBeginner
Pratiquer maintenant

This tutorial is from open-source community. Access the source code

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Le laboratoire montre comment implémenter la limitation de débit en Go à l'aide de goroutines, de canaux et de décompteurs.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL go(("Golang")) -.-> go/ConcurrencyGroup(["Concurrency"]) go/ConcurrencyGroup -.-> go/rate_limiting("Rate Limiting") subgraph Lab Skills go/rate_limiting -.-> lab-15498{{"Implémentation de la limitation de débit en Go"}} end

Limitation de débit

Le problème est de limiter la gestion des requêtes entrantes pour maintenir la qualité de service et contrôler l'utilisation des ressources.

  • Langage de programmation Go
  • Compréhension de base des goroutines, des canaux et des décompteurs
## Lorsque nous exécutons notre programme, nous voyons que la première
## série de requêtes est traitée une fois toutes les ~200 millisecondes,
## comme prévu.
$ go run rate-limiting.go
requête 1 2012-10-19 00:38:18.687438 +0000 UTC
requête 2 2012-10-19 00:38:18.887471 +0000 UTC
requête 3 2012-10-19 00:38:19.087238 +0000 UTC
requête 4 2012-10-19 00:38:19.287338 +0000 UTC
requête 5 2012-10-19 00:38:19.487331 +0000 UTC

## Pour la deuxième série de requêtes, nous traitons les 3 premières
## immédiatement en raison de la limitation de débit pouvant supporter
## des pics, puis nous traitons les 2 restantes avec un retard d'environ
## 200 ms chacun.
requête 1 2012-10-19 00:38:20.487578 +0000 UTC
requête 2 2012-10-19 00:38:20.487645 +0000 UTC
requête 3 2012-10-19 00:38:20.487676 +0000 UTC
requête 4 2012-10-19 00:38:20.687483 +0000 UTC
requête 5 2012-10-19 00:38:20.887542 +0000 UTC

Voici le code complet ci-dessous :

// [_Limitation de débit_](https://en.wikipedia.org/wiki/Rate_limiting)
// est un mécanisme important pour contrôler l'utilisation des ressources
// et maintenir la qualité de service. Go prend en charge
// élégamment la limitation de débit avec des goroutines,
// des canaux et des [décompteurs](tickers).

package main

import (
	"fmt"
	"time"
)

func main() {

	// Tout d'abord, nous allons examiner la limitation de débit de base.
	// Supposons que nous voulions limiter la gestion de nos requêtes
	// entrantes. Nous allons traiter ces requêtes à partir d'un canal
	// du même nom.
	requêtes := make(chan int, 5)
	for i := 1; i <= 5; i++ {
		requêtes <- i
	}
	close(requêtes)

	// Ce canal `limiteur` recevra une valeur toutes les 200 millisecondes.
	// C'est le régulateur de notre schéma de limitation de débit.
	limiteur := time.Tick(200 * time.Millisecond)

	// En bloquant la réception d'un message du canal `limiteur`
	// avant de traiter chaque requête, nous nous limitons à 1 requête
	// toutes les 200 millisecondes.
	for req := range requêtes {
		<-limiteur
		fmt.Println("requête", req, time.Now())
	}

	// Nous pouvons vouloir autoriser de courts pics de requêtes dans
	// notre schéma de limitation de débit tout en conservant la limite
	// de débit globale. Nous pouvons le faire en mettant en mémoire
	// tampon notre canal limiteur. Ce canal `limiteur à pics` permettra
	// des pics de jusqu'à 3 événements.
	limiteurAPics := make(chan time.Time, 3)

	// Remplissons le canal pour représenter le pic autorisé.
	for i := 0; i < 3; i++ {
		limiteurAPics <- time.Now()
	}

	// Toutes les 200 millisecondes, nous allons essayer d'ajouter une
	// nouvelle valeur à `limiteurAPics`, jusqu'à sa limite de 3.
	go func() {
		for t := range time.Tick(200 * time.Millisecond) {
			limiteurAPics <- t
		}
	}()

	// Maintenant, simulons 5 nouvelles requêtes entrantes. Les 3 premières
	// bénéficieront de la capacité de pic de `limiteurAPics`.
	requêtesAPics := make(chan int, 5)
	for i := 1; i <= 5; i++ {
		requêtesAPics <- i
	}
	close(requêtesAPics)
	for req := range requêtesAPics {
		<-limiteurAPics
		fmt.Println("requête", req, time.Now())
	}
}

Résumé

Le laboratoire montre comment implémenter la limitation de débit en Go à l'aide de goroutines, de canaux et de décompteurs pour contrôler l'utilisation des ressources et maintenir la qualité de service.