aluferraz / go-expert-rate-limiter Goto Github PK

Executar o projeto:

docker compose up --build

Testes também presentes no github-actions.

README do Projeto

Visão Geral

O código fornecido consiste em três pacotes principais do Go: rate_limit, middleware e web.

Pacote rate_limit:

O pacote rate_limit oferece uma maneira de limitar o número de solicitações feitas por clientes individuais a uma aplicação. A ideia básica por trás da limitação de taxa é controlar com que frequência usuários autenticados, ou, neste caso, endereços IP (ou chaves de API), podem fazer solicitações ao seu servidor.

Como Funciona:

Contadores de Solicitação: Quando um cliente faz uma solicitação, a estrutura RateLimitRepositoryRedis verifica se já existe um contador para esse cliente específico no Redis. Se não existir, ele cria um com um valor inicial de session.GetRequestsLimitInSeconds(). Esse contador representa quantas solicitações ainda podem ser feitas antes que o cliente seja limitado pela taxa.

go-expert-rate-limiter/internal/infra/persistence/rate_limit/rate_limit_redis.go

Lines 23 to 32 in f3e1443

 func (rlim *RateLimitRepositoryRedis) SetRequestCounter(session *web_session.WebSession) error { 

 ctx := context.Background() 

 counterKey, maxRequest := session.GetRequestCounterId(), uint(session.GetRequestsLimitInSeconds()) 

 err := rlim.Client.Set(ctx, counterKey, maxRequest, 0).Err() 

 if err != nil { 

 return err 

 } 

 return rlim.Client.Set(ctx, session.GetRequestTimerId(), time.Now().Unix(), 0).Err() 

 }

Diminuir o Token Bucket: Cada vez que um cliente faz uma solicitação, o contador é diminuído. Se o contador atingir zero, significa que o cliente fez tantas solicitações quanto permitido dentro da janela de tempo atual (1 segundo neste caso), e solicitações adicionais serão limitadas até que a próxima janela de tempo comece.

go-expert-rate-limiter/internal/infra/persistence/rate_limit/rate_limit_redis.go

Lines 46 to 94 in f3e1443

 func (rlim *RateLimitRepositoryRedis) DecreaseTokenBucket(session *web_session.WebSession) (bool, error) { 

 ctx := context.Background() 

 counterKey := session.GetRequestCounterId() 

 // Transactional function, optimistic lock. 

 txf := func(tx *redis.Tx) error { 

 // Get the current value or zero. 

 remaingRequests, err := tx.Get(ctx, counterKey).Int() 

 if err != nil && err != redis.Nil { 

 return err 

 } 

 if remaingRequests <= 0 { 

 throttledError := ThrottledError{} 

 return throttledError.ThrottledError() 

 } 

 // Actual operation (local in optimistic lock). 

 remaingRequests-- 

 // Operation is commited only if the watched keys remain unchanged. 

 _, err = tx.TxPipelined(ctx, func(pipe redis.Pipeliner) error { 

 pipe.Set(ctx, counterKey, remaingRequests, 0) 

 return nil 

 }) 

 return err 

 } 

 var err error 

 throttledError := ThrottledError{} 

 lastResetTime, err := rlim.GetLastRequestTime(session) 

 if err != nil { 

 return false, err 

 } 

 if (time.Now().Unix() - lastResetTime) >= session.GetExpireInSeconds() { 

 // if elapsed, reset the counter 

 err = rlim.SetRequestCounter(session) 

 return false, err 

 } 

 for i := 0; i < int(session.GetRequestsLimitInSeconds()); i++ { 

 err = rlim.Client.Watch(ctx, txf, counterKey) // Will return error if not possible. 

 if errors.Is(err, redis.Nil) || err == nil { 

 return false, nil 

 } 

 if err != nil && err.Error() == throttledError.ThrottledError().Error() { 

 return true, err 

 } 

 log.Info().Msgf("Optimistic lock failed. %d.", i) 

 log.Info().Msg(err.Error()) 

 } 

 return err != nil, err 

 }

Redefinir o Contador: A cada segundo, uma tarefa em segundo plano é executada, redefinindo o contador de solicitações para cada cliente ao seu limite máximo.

Limitar o Cliente: Se um cliente fizer mais solicitações do que o permitido em um segundo, ele será limitado e não poderá fazer mais solicitações até que o tempo definido na variável de ambiente EXPIRATION termine.

Com o middleware configurado o método DecreaseTokenBucket é chamado em cada solicitação e caso retorne um erro (significando que o cliente foi limitado), retorna um código de status HTTP 429 (Too Many Requests) para o cliente. Estratégia de rate limit aplicada:

https://en.wikipedia.org/wiki/Token_bucket

Variáveis de Ambiente

A tabela abaixo lista as variáveis de ambiente utilizadas pelo projeto, junto com suas descrições e valores padrão:

Variável de Ambiente	Descrição	Valor Padrão
WEBSERVER_PORT	A porta na qual o servidor web escutará as conexões recebidas.	8080
REDIS_URI	A URI do servidor Redis usado para armazenar dados de limitação de taxa. Inclui host e porta.	redis:6379
IP_THROTTLING	O número máximo de solicitações por segundo que um endereço IP pode fazer.	5
API_THROTTLING	O número máximo de solicitações por segundo que um usuário autenticado pode fazer	10
EXPIRATION	A duração do intervalo de tempo, em segundos, durante o qual os limites de taxa são aplicados.	60

aluferraz / go-expert-rate-limiter Goto Github PK

go-expert-rate-limiter's Introduction

README do Projeto

Visão Geral

Pacote rate_limit:

Como Funciona:

Variáveis de Ambiente

go-expert-rate-limiter's People

Contributors

Watchers

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent

	func (rlim RateLimitRepositoryRedis) SetRequestCounter(session web_session.WebSession) error {
	ctx := context.Background()
	counterKey, maxRequest := session.GetRequestCounterId(), uint(session.GetRequestsLimitInSeconds())
	err := rlim.Client.Set(ctx, counterKey, maxRequest, 0).Err()
	if err != nil {
	return err
	}
	return rlim.Client.Set(ctx, session.GetRequestTimerId(), time.Now().Unix(), 0).Err()

	}

	func (rlim RateLimitRepositoryRedis) DecreaseTokenBucket(session web_session.WebSession) (bool, error) {
	ctx := context.Background()
	counterKey := session.GetRequestCounterId()
	// Transactional function, optimistic lock.
	txf := func(tx *redis.Tx) error {
	// Get the current value or zero.
	remaingRequests, err := tx.Get(ctx, counterKey).Int()
	if err != nil && err != redis.Nil {
	return err
	}
	if remaingRequests <= 0 {
	throttledError := ThrottledError{}
	return throttledError.ThrottledError()
	}

	// Actual operation (local in optimistic lock).
	remaingRequests--
	// Operation is commited only if the watched keys remain unchanged.
	_, err = tx.TxPipelined(ctx, func(pipe redis.Pipeliner) error {
	pipe.Set(ctx, counterKey, remaingRequests, 0)
	return nil
	})
	return err
	}
	var err error
	throttledError := ThrottledError{}
	lastResetTime, err := rlim.GetLastRequestTime(session)
	if err != nil {
	return false, err
	}
	if (time.Now().Unix() - lastResetTime) >= session.GetExpireInSeconds() {
	// if elapsed, reset the counter
	err = rlim.SetRequestCounter(session)
	return false, err
	}
	for i := 0; i < int(session.GetRequestsLimitInSeconds()); i++ {

	err = rlim.Client.Watch(ctx, txf, counterKey) // Will return error if not possible.
	if errors.Is(err, redis.Nil) \|\| err == nil {
	return false, nil
	}
	if err != nil && err.Error() == throttledError.ThrottledError().Error() {
	return true, err
	}
	log.Info().Msgf("Optimistic lock failed. %d.", i)
	log.Info().Msg(err.Error())
	}
	return err != nil, err
	}