Observed Signal · Jul 3, 2026 · Technical Guide · Source: DEV Community · Impact: 1/5 · Sentiment: Positive
Token-bucket API rate limiting with Bucket4j and Redis
A developer diary entry describes adding a distributed token-bucket rate limiter to OrderHub using the JVM library Bucket4j and Redis. The post explains the token-bucket model (capacity and refill rate), shows example Bucket4j configuration including refillGreedy, and implements per-client buckets keyed by X-API-Key or client IP. Enforcement runs in a servlet filter (OncePerRequestFilter) that returns 429 with Retry-After and exposes X-RateLimit-Remaining. To enforce limits cluster-wide, the author uses Bucket4j's Lettuce-based proxy manager which stores bucket state in Redis and uses an atomic compare-and-swap Lua script; if Redis is unavailable at startup the app falls back to per-instance buckets. Configuration is driven by @ConfigurationProperties and an integration test verifies behavior. Source code and a live demo are linked.
Practical engineering tutorial improving backend robustness; useful to backend/platform engineers but not industry-shifting for AdTech/MarTech.
Track Redis Signals & Market Shifts in Real-Time
Polaris7 autonomous intelligence agents track regulatory filings, primary sources, executive changes, and deal flow 24/7. Create your Polaris7 workspace to monitor these entities.
Key Takeaways & Evidence Grounding
- Author implemented a token-bucket rate limiter for OrderHub using Bucket4j on the JVM.
- Example Bucket4j config shown: capacity(20) with refillGreedy(20, Duration.ofMinutes(1)).
- Per-client buckets are keyed by a stable identity (X-API-Key) or caller IP and enforced in a servlet filter using OncePerRequestFilter and tryConsumeAndReturnRemaining.
- Cluster-wide enforcement uses Redis with Bucket4j's Lettuce-based ProxyManager (CAS-based builder) that stores bucket state under Redis keys and mutates it with an atomic compare-and-swap Lua script; fallback to per-instance buckets if Redis is unreachable at startup.
- Configuration is exposed via @ConfigurationProperties and an integration test validates allowed requests and expected 429 responses.
Connected Companies & Entities
“Since we already run Redis for the cache, we let the buckets live there. Bucket4j's LettuceBasedProxyManager stores each client's bucket sta...”
“Code: [https://github.com/dev48v/order-hub-from-zero]”
Ontology Mapping & Concepts
Related Market Signals & Shifts
Recent verified developments and strategic activity across this market segment.
Rate Limiting in Spring Boot with Bucket4j and Redis
A technical tutorial (published 2026-06-04) describing how to implement rate limiting in Spring Boot REST APIs using the Bucket4j Java library with Redis as a distributed backend. The author, Shubham Bhati (Backend Engineer at AlignBits LLC), documents a production deployment using Java 21 and Spring Boot 3.2, shares code examples for a token-bucket configuration and a servlet filter that returns HTTP 429 when limits are exceeded, and explains using Spring Data Redis and Lettuce for Redis connectivity. Monitoring is covered via storing counters in Redis and scraping metrics with Prometheus. The author reports a production p99 latency improvement from 800ms to 120ms after implementing rate limiting.
Token‑Aware Rate Limiting for LLM Applications
This technical how‑to explains why traditional request‑count rate limiting is insufficient for applications using large language model (LLM) APIs and shows how to implement token‑aware limits. LLM providers charge by tokens, not requests, so long context windows can exhaust budgets despite low request counts; OpenAI exposes tokens‑per‑minute (TPM) and requests‑per‑minute (RPM) limits as an example. The post defines four production limit types — request rate, token rate, budget cap and scope — and compares two implementation patterns: application‑level middleware (example Redis code that estimates tokens pre‑call) and gateway‑level proxies that centralize enforcement. It highlights gateway implementations (Bifrost, LiteLLM, Kong AI Gateway), discusses tradeoffs (overhead, reconciling estimated vs. actual token counts, multi‑tenant isolation) and recommends per‑customer token and budget caps.
Rate Limiting in Go: Token, Leaky, Sliding Window
A technical tutorial explaining three common rate-limiting algorithms—token bucket, leaky bucket, and sliding window—and how to implement or use them in Go. The article demonstrates using golang.org/x/time/rate for token-bucket semantics (Allow/Wait/Reserve), go.uber.org/ratelimit for strictly spaced (leaky-bucket) output with optional slack, and a simple in-process sliding-log implementation for exact rolling-window limits. It covers per-client limiters, janitor/eviction patterns for maps of limiters, correct placement of Wait() for outbound throttling, and trade-offs between accuracy and memory (sliding log vs sliding-window counter). For distributed limits it recommends Redis and the github.com/go-redis/redis_rate package (GCRA-based) and notes distributed limiting is a separate topic for a follow-up. The post was published on 2026-05-20.
Receive all future signals for Redis & competitors in your briefing
Never miss material M&A deals, leadership changes, account wins, or product rollouts. Polaris7 monitors 20,000+ primary sources 24/7, delivering verified telemetry directly into your executive briefing.
