Muy bien, amigos, hemos cubierto mucho hasta ahora: autenticación JWT, conexiones de bases de datos, registros y manejo de errores. Pero, ¿qué sucede cuando su API comienza a recibir solicitudes? Sin control, el tráfico elevado puede provocar tiempos de respuesta lentos o incluso tiempos de inactividad. ?

Esta semana, vamos a resolver esto implementando limitación de velocidad para controlar el flujo de tráfico. Usaremos el paquete simple y efectivo golang.org/x/time/rate. Más adelante, cuando mi propia solución ThrottleX esté lista, les mostraré cómo integrarla como una opción más escalable. (Psst, ¡visita mi GitHub en github.com/neelp03/throttlex para obtener actualizaciones! No dudes en comentar cualquier problema que veas allí o7)

¿Por qué limitar la velocidad? ?

La limitación de tasas es como un dispositivo de seguridad para tu API: controla la cantidad de solicitudes que los usuarios pueden realizar dentro de un período de tiempo determinado. Esto evita que su API se sature y garantiza un acceso justo y fluido para todos los usuarios. La limitación de tarifas es esencial para:

• Prevención del abuso: evita que los malos actores o los usuarios demasiado entusiastas abrumen tu API.
• Estabilidad: Mantiene tu API receptiva y confiable, incluso durante picos de tráfico.
• Equidad: permite que los recursos se compartan equitativamente entre los usuarios.

Paso 1: Instalar el paquete hora/tarifa

El paquete golang.org/x/time/rate es parte de las bibliotecas Go extendidas y proporciona un limitador de tasa sencillo basado en token. Para comenzar, deberás instalarlo:

go get golang.org/x/time/rate

Paso 2: configurar el limitador de velocidad

Creemos un middleware limitador de velocidad que controle la cantidad de solicitudes que puede realizar un cliente. En este ejemplo, limitaremos los clientes a 5 solicitudes 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
}

Paso 3: creación del middleware limitador de velocidad

Ahora, usemos la función getClientLimiter en un middleware que restringirá el acceso según el límite de velocidad.

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

Cómo funciona:

1. Limitación basada en IP: Cada cliente se identifica por su dirección IP. Comprobamos la IP del cliente y le asignamos un limitador de tarifa.
2. Solicitar verificación: El método limiter.Allow() verifica si el cliente está dentro del límite de tarifa. Si es así, la solicitud pasa al siguiente controlador; si no, respondemos con 429 Demasiadas solicitudes.

Paso 4: ¿Aplicar el middleware globalmente?

Ahora conectemos nuestro limitador de velocidad a la API para que cada solicitud tenga que pasar por ella:

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

Al aplicar r.Use(rateLimitingMiddleware), nos aseguramos de que el limitador de velocidad verifique cada solicitud entrante antes de que llegue a cualquier punto final.

Paso 5: ¿Probar el límite de velocidad?

Inicia tu servidor:

go run main.go

Ahora, accedamos a la API con algunas solicitudes. Puedes usar un bucle con curl para simular múltiples solicitudes seguidas:

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

Dado que establecimos el límite en 5 solicitudes por minuto, deberías ver 429 Demasiadas solicitudes respuestas una vez que excedas la tasa permitida.

¿Qué sigue?

Y ahí lo tiene: limitación de velocidad con golang.org/x/time/rate para mantener su API estable y receptiva bajo presión. La limitación de velocidad es una herramienta crucial para cualquier API escalable, y aquí solo estamos arañando la superficie.

Una vez que ThrottleX esté listo para producción, publicaré un tutorial de seguimiento para mostrarle cómo integrarlo en su API Go para obtener aún más flexibilidad y limitación de velocidad distribuida. ¡Esté atento a mi repositorio ThrottleX GitHub para obtener actualizaciones!

La próxima semana, vamos a contener nuestra API con Docker, para que esté lista para ejecutarse en cualquier lugar. ¡Estén atentos y feliz codificación! ??