Tudo bem, pessoal, cobrimos muito até agora: autenticação JWT, conexões de banco de dados, registro e tratamento de erros. Mas o que acontece quando sua API começa a receber solicitações? Sem controle, o tráfego intenso pode levar a tempos de resposta lentos ou até mesmo a períodos de inatividade. ?

Esta semana, vamos resolver isso implementando limitação de taxa para controlar o fluxo de tráfego. Usaremos o pacote simples e eficaz golang.org/x/time/rate. Mais tarde, quando minha própria solução ThrottleX estiver pronta, mostrarei como integrá-la como uma opção mais escalonável. (Psiu, confira meu GitHub em github.com/neelp03/throttlex para atualizações! Sinta-se à vontade para comentar quaisquer problemas que você encontrar lá o7)

Por que limitar a taxa? ?

A limitação de taxa é como um segurança para sua API: ela controla o número de solicitações que os usuários podem fazer em um determinado período. Isso evita que sua API fique sobrecarregada, garantindo um acesso tranquilo e justo para todos os usuários. A limitação de taxa é essencial para:

• Prevenção de abusos: impede que atores mal-intencionados ou usuários excessivamente entusiasmados sobrecarreguem sua API.
• Estabilidade: mantém sua API responsiva e confiável, mesmo durante picos de tráfego.
• Equidade: permite que os recursos sejam compartilhados igualmente entre os usuários.

Etapa 1: Instalando o pacote de tempo/taxa

O pacote golang.org/x/time/rate faz parte das bibliotecas Go estendidas e fornece um limitador de taxa simples baseado em token. Para começar, você precisará instalá-lo:

go get golang.org/x/time/rate

Etapa 2: Configurando o Limitador de Taxa

Vamos criar um middleware limitador de taxa que controle o número de solicitações que um cliente pode fazer. Neste exemplo, limitaremos os clientes a 5 solicitações por minuto.

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
}

Etapa 3: Criando o Middleware de Limitação de Taxa

Agora, vamos usar a função getClientLimiter em um middleware que restringirá o acesso com base no limite de taxa.

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)
    })
}

Como funciona:

1. Limitação baseada em IP: Cada cliente é identificado por seu endereço IP. Verificamos o IP do cliente e atribuímos um limitador de taxa a ele.
2. Request Check: O método limiter.Allow() verifica se o cliente está dentro do limite de taxa. Se estiverem, a solicitação segue para o próximo manipulador; caso contrário, responderemos com 429 Too Many Requests.

Etapa 4: Aplicando o Middleware Globalmente?

Agora vamos conectar nosso limitador de taxa à API para que cada solicitação passe por ele:

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))
}

Ao aplicar r.Use(rateLimitingMiddleware), garantimos que cada solicitação recebida seja verificada pelo limitador de taxa antes de atingir qualquer endpoint.

Etapa 5: Testando a limitação de taxa?

Inicie seu servidor:

go run main.go

Agora, vamos acessar a API com algumas solicitações. Você pode usar um loop com curl para simular várias solicitações seguidas:

for i in {1..10}; do curl http://localhost:8000/books; done

Como definimos o limite para 5 solicitações por minuto, você verá 429 solicitações demais respostas quando exceder a taxa permitida.

O que vem a seguir?

E aí está: limitação de taxa com golang.org/x/time/rate para manter sua API estável e responsiva sob pressão. A limitação de taxa é uma ferramenta crucial para qualquer API escalonável, e estamos apenas arranhando a superfície aqui.

Assim que o ThrottleX estiver pronto para produção, postarei um tutorial de acompanhamento para mostrar como integrá-lo à sua API Go para obter ainda mais flexibilidade e limitação de taxa distribuída. Fique de olho no meu repositório ThrottleX GitHub para atualizações!

Na próxima semana, colocaremos nossa API em contêineres com Docker, para que ela esteja pronta para ser executada em qualquer lugar. Fique ligado e boa codificação! ??