Limite de requisições

import { readFileSync } from "node:fs";
import { createClient } from "redis";

const redis = await createClient({ url: process.env.REDIS_URL }).connect();
const BALDE = readFileSync(new URL("./balde.lua", import.meta.url), "utf8");

export type Decisao = { permitido: boolean; restantes: number; esperarSegundos: number };

export async function consumir(cliente: string, capacidade = 10, porSegundo = 5): Promise<Decisao> {
  const [permitido, restantes, espera] = (await redis.eval(BALDE, {
    keys: [`limite:${cliente}`],
    arguments: [String(capacidade), String(porSegundo)],
  })) as number[];
  return { permitido: permitido === 1, restantes, esperarSegundos: espera };
}

import os
from pathlib import Path

import redis

cliente_redis = redis.Redis.from_url(os.environ["REDIS_URL"])
# register_script usa EVALSHA: o script é enviado ao Redis só uma vez
balde = cliente_redis.register_script(Path(__file__).with_name("balde.lua").read_text())


def consumir(cliente: str, capacidade: int = 10, por_segundo: float = 5) -> dict:
    permitido, restantes, espera = balde(keys=[f"limite:{cliente}"], args=[capacidade, por_segundo])
    return {"permitido": permitido == 1, "restantes": restantes, "esperar_segundos": espera}

package limite

import (
	"context"
	_ "embed"
	"fmt"

	"github.com/redis/go-redis/v9"
)

//go:embed balde.lua
var codigoBalde string

// NewScript usa EVALSHA e reenvia o script só se o Redis não o tiver
var balde = redis.NewScript(codigoBalde)

type Decisao struct {
	Permitido       bool
	Restantes       int64
	EsperarSegundos int64
}

func Consumir(ctx context.Context, rdb *redis.Client, cliente string, capacidade int, porSegundo float64) (Decisao, error) {
	r, err := balde.Run(ctx, rdb, []string{"limite:" + cliente}, capacidade, fmt.Sprint(porSegundo)).Int64Slice()
	if err != nil {
		return Decisao{}, err
	}
	return Decisao{Permitido: r[0] == 1, Restantes: r[1], EsperarSegundos: r[2]}, nil
}

import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import redis.clients.jedis.JedisPooled;

public class Limitador {
    public record Decisao(boolean permitido, long restantes, long esperarSegundos) {}

    private final JedisPooled redis;
    private final String balde;

    public Limitador(JedisPooled redis) throws Exception {
        this.redis = redis;
        this.balde = Files.readString(Path.of("balde.lua"));
    }

    @SuppressWarnings("unchecked")
    public Decisao consumir(String cliente, int capacidade, double porSegundo) {
        var r = (List<Long>) redis.eval(balde,
            List.of("limite:" + cliente),
            List.of(String.valueOf(capacidade), String.valueOf(porSegundo)));
        return new Decisao(r.get(0) == 1, r.get(1), r.get(2));
    }
}

using StackExchange.Redis;

public record Decisao(bool Permitido, long Restantes, long EsperarSegundos);

public class Limitador(IConnectionMultiplexer conexao)
{
    private static readonly string Balde = File.ReadAllText("balde.lua");
    private readonly IDatabase redis = conexao.GetDatabase();

    public async Task<Decisao> Consumir(string cliente, int capacidade = 10, double porSegundo = 5)
    {
        var r = (RedisResult[])(await redis.ScriptEvaluateAsync(
            Balde,
            [new RedisKey($"limite:{cliente}")],
            [capacidade, porSegundo]))!;
        return new Decisao((long)r[0] == 1, (long)r[1], (long)r[2]);
    }
}