Por que a performance importa?

O que é Rate Limiting?

Tipos de algoritmos de Rate Limiting:

1. Fixed Window (Janela fixa): contabiliza requisições em intervalos fixos, como 60 segundos.

2. Sliding Window (Janela deslizante): oferece mais flexibilidade, analisando as requisições em intervalos móveis.

3. Token Bucket: permite explosões controladas de requisições ao consumir "tokens" de um balde.

4. Leaky Bucket: similar ao Token Bucket, mas limita a taxa de saída de requisições de forma constante.

Com o Redis, esses algoritmos podem ser implementados de forma eficiente, aproveitando comandos como INCR e EXPIRE para criar limitadores de taxa.

Implementando Rate Limiting com Redis

Python

import redis
import time

r = redis.StrictRedis(host='localhost', port=6379, decode_responses=True)

def is_rate_limited(user_id):
    key = f"rate_limit:{user_id}"
    current_count = r.get(key)
    if current_count and int(current_count) >= 10:
        return True
    pipe = r.pipeline()
    pipe.incr(key, 1)
    pipe.expire(key, 60)
    pipe.execute()
    return False

Node.js

const redis = require("redis");
const client = redis.createClient();

function rateLimiter(req, res, next) {
    const key = `rate_limit:${req.ip}`;
    client.incr(key, (err, count) => {
        if (count === 1) {
            client.expire(key, 60); // Expira após 60 segundos
        }
        if (count > 10) {
            return res.status(429).send("Too many requests");
        }
        next();
    });
}

O que é Caching?

Estratégias comuns de Caching:

1. Write-through: atualiza o cache e a fonte de dados simultaneamente.

2. Read-through: busca primeiro no cache, recorrendo ao banco apenas quando necessário.

3. Write-behind: atualiza o banco após o cache, otimizando o desempenho.

Implementando Caching com Redis

Java

import redis.clients.jedis.Jedis;

public class CacheExample {
    private static Jedis jedis = new Jedis("localhost");

    public static String getCachedData(String key) {
        String value = jedis.get(key);
        if (value == null) {
            value = fetchDataFromDatabase(key); // Simulação de consulta ao banco
            jedis.setex(key, 3600, value); // Expira em 1 hora
        }
        return value;
    }
}

Go

import (
    "github.com/go-redis/redis/v8"
    "context"
    "time"
)

var ctx = context.Background()
var rdb = redis.NewClient(&redis.Options{
    Addr: "localhost:6379",
})

func getCachedData(key string) string {
    val, err := rdb.Get(ctx, key).Result()
    if err == redis.Nil {
        val = fetchDataFromDB(key) // Simulação
        rdb.Set(ctx, key, val, 3600*time.Second)
    }
    return val
}

Boas práticas com Redis

1. Escolha da estrutura de dados: use listas, conjuntos ou hashes conforme a necessidade.

2. Monitoramento: acompanhe o desempenho do Redis com ferramentas como o RedisInsight.

3. Configuração do TTL: sempre defina tempos de expiração para evitar uso excessivo de memória.

4. Clustering: para alto volume de tráfego, considere usar Redis Cluster.

Exemplos práticos em PHP e C#

PHP: limitando requisições com Predis

<?php
require 'vendor/autoload.php';

$redis = new Predis\Client();

function rateLimit($key) {
    global $redis;
    $current = $redis->incr($key);

    if ($current == 1) {
        $redis->expire($key, 60); // Expira após 60 segundos
    }

    if ($current > 10) {
        http_response_code(429);
        die('Too many requests');
    }
}

// Exemplo de uso
$apiKey = "user:123";
rateLimit($apiKey);

// Lógica da API
echo "Request handled successfully";

Esse código cria um limitador simples que impede mais de 10 requisições por minuto, retornando o status 429 quando o limite é atingido.

C#: criando um limitador de taxa distribuído

using StackExchange.Redis;
using System;

class Program
{
    static void Main(string[] args)
    {
        var redis = ConnectionMultiplexer.Connect("localhost");
        var db = redis.GetDatabase();

        string userKey = "rate_limit:user:123";
        var requests = db.StringIncrement(userKey);

        if (requests == 1)
        {
            db.KeyExpire(userKey, TimeSpan.FromMinutes(1));
        }

        if (requests > 10)
        {
            Console.WriteLine("Too many requests");
            return;
        }

        Console.WriteLine("Request processed successfully");
    }
}

Esse código permite no máximo 10 requisições por minuto para um usuário, gerenciando limites de forma eficiente e distribuída.

Conclusão

Explore nossos cursos, conecte-se à comunidade e avance na sua jornada dev, construindo soluções ainda mais escaláveis e robustas.