BestHub
Sign in
Tagged articles

rate limiting

656 articles · Page 2 of 7
Architect's Guide
Architect's Guide
Feb 27, 2026 · Backend Development

Mastering Rate Limiting: Algorithms, Strategies, and Practical Implementations

This article explains why rate limiting is essential for both physical venues and online services, outlines common throttling strategies such as circuit breaking, service degradation, delay processing, and privilege handling, compares caching, degradation, and limiting, and details popular algorithms and concrete code examples for implementing rate limiting in Java and Nginx/Lua environments.

GuavaLuarate limiting
0 likes · 15 min read
Mastering Rate Limiting: Algorithms, Strategies, and Practical Implementations
Java Companion
Java Companion
Feb 21, 2026 · Backend Development

Build Your Own Spring Boot API Guard: Anti‑Duplicate Submissions and Rate Limiting

The article introduces Guardian, a lightweight Spring Boot starter that provides independent anti‑duplicate‑submission and rate‑limiting modules, explains why a custom solution is preferable to raw Redis locks, and walks through annotation and YAML configurations, key generation, response handling, storage options, concurrency safety, and observability.

API GuardAnti-duplicate SubmissionRedis
0 likes · 17 min read
Build Your Own Spring Boot API Guard: Anti‑Duplicate Submissions and Rate Limiting
Ops Community
Ops Community
Feb 12, 2026 · Operations

Why Did Our Nginx Hit Connection Limits? A Deep Dive into Misdiagnosis and Rate‑Limiting Redesign

This postmortem explains how a Nginx connection‑saturation incident was initially misidentified as traffic surge, details the metrics and command‑line checks that revealed a connection‑lifecycle failure, and describes the step‑by‑step redesign of rate‑limiting, budgeting, monitoring, and run‑book procedures that restored stability.

Nginxconnection limitsincident response
0 likes · 32 min read
Why Did Our Nginx Hit Connection Limits? A Deep Dive into Misdiagnosis and Rate‑Limiting Redesign
Go Development Architecture Practice
Go Development Architecture Practice
Feb 4, 2026 · Backend Development

Master Go Rate Limiting: Sliding Window, Token Bucket, and Redis Techniques

This article presents four practical Go rate‑limiting implementations—a sliding‑window algorithm, a token‑bucket approach, the built‑in golang.org/x/time/rate package, and a Redis‑backed distributed limiter—complete with code samples, usage guidance, and recommendations for different deployment scenarios.

Redisgolang.org/x/time/raterate limiting
0 likes · 11 min read
Master Go Rate Limiting: Sliding Window, Token Bucket, and Redis Techniques
Shuge Unlimited
Shuge Unlimited
Feb 2, 2026 · Artificial Intelligence

Moltbook Architecture Deep Dive: Design Philosophy Behind the First OpenClaw AI Agent Social Network

Moltbook is a pioneering AI‑only social platform that lets agents post, comment and like, built with a Next.js front‑end, RESTful API back‑end, semantic vector search, heartbeat checks, dual human/agent modes and strict rate‑limiting to encourage quality over quantity while addressing scalability and security challenges.

MoltbookNext.jsRESTful API
0 likes · 18 min read
Moltbook Architecture Deep Dive: Design Philosophy Behind the First OpenClaw AI Agent Social Network
Ray's Galactic Tech
Ray's Galactic Tech
Jan 27, 2026 · Backend Development

Resilient Go Microservices: Rate Limiting, Circuit Breaking & K8s Architecture

This guide walks you through implementing a complete stability engineering system for Go microservices—covering token‑bucket rate limiting, concurrency and Redis‑based throttling, circuit breakers with slow‑request detection, graceful degradation strategies, Kubernetes‑aware deployment, monitoring, dynamic configuration, and load‑testing to set safe thresholds.

Circuit BreakerResiliencerate limiting
0 likes · 10 min read
Resilient Go Microservices: Rate Limiting, Circuit Breaking & K8s Architecture
LuTiao Programming
LuTiao Programming
Jan 19, 2026 · Backend Development

How to Build a High‑Concurrency Flash‑Sale System with Spring Boot, Redis, and Lua

The article analyzes why flash‑sale systems often crash under extreme traffic and presents a step‑by‑step solution using Spring Boot, Redis, and Lua that prevents overselling, pre‑warms stock, applies token‑bucket rate limiting, executes atomic stock deductions, and decouples order creation asynchronously while adding monitoring and safety measures.

Atomic ScriptLuaRedis
0 likes · 9 min read
How to Build a High‑Concurrency Flash‑Sale System with Spring Boot, Redis, and Lua
Selected Java Interview Questions
Selected Java Interview Questions
Jan 15, 2026 · Backend Development

How to Build a Lightweight, Annotation‑Driven Rate Limiter with Spring AOP and Guava

This article explains how to create a non‑intrusive, configurable rate‑limiting component for Spring services by combining Spring AOP, a custom @RateLimit annotation, and Google Guava's RateLimiter, covering token‑bucket fundamentals, API usage, implementation details, common AOP pitfalls, and migration to distributed limiting.

BackendGuava RateLimiterJava
0 likes · 12 min read
How to Build a Lightweight, Annotation‑Driven Rate Limiter with Spring AOP and Guava
Java Companion
Java Companion
Jan 15, 2026 · Backend Development

Implement Multi‑Dimensional Bandwidth Throttling in Spring Boot 3

This article presents a complete Spring Boot 3 solution for multi‑dimensional network bandwidth throttling using a manually implemented token‑bucket algorithm, custom HandlerInterceptor, HttpServletResponseWrapper, and RateLimitedOutputStream, with detailed code samples, configuration options, and performance tuning guidance.

HandlerInterceptorJavaSpring Boot
0 likes · 13 min read
Implement Multi‑Dimensional Bandwidth Throttling in Spring Boot 3
Tech Freedom Circle
Tech Freedom Circle
Jan 12, 2026 · Backend Development

Why Sentinel Fails for Per‑User Hourly Limits and How Redis + Lua Solves It

The article compares four user‑level rate‑limiting approaches—Sentinel hotspot parameters, Sentinel ordinary flow control with cluster mode, Redis ZSet + Lua scripts, and Guava RateLimiter—explaining why Sentinel is unsuitable for long‑window low‑frequency limits and why Redis + Lua is the optimal solution for high‑traffic e‑commerce scenarios.

Distributed ConsistencyLong WindowLua
0 likes · 26 min read
Why Sentinel Fails for Per‑User Hourly Limits and How Redis + Lua Solves It
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jan 2, 2026 · Backend Development

Implementing High‑Concurrency Circuit Breaking in Nginx with Lua

This guide explains how to use Nginx and OpenResty Lua scripts to implement rate limiting and circuit‑breaking for high‑concurrency services, detecting error rates and response latency, automatically opening and closing a 30‑second break window, and returning custom JSON responses when downstream services fail.

Circuit BreakingLuaNginx
0 likes · 5 min read
Implementing High‑Concurrency Circuit Breaking in Nginx with Lua
Java Architect Handbook
Java Architect Handbook
Dec 31, 2025 · Backend Development

Mastering API Rate Limiting with Spring Interceptor and Redis

This article walks through building a Spring MVC interceptor that leverages Redis to enforce per‑IP request limits, explains configurable parameters, shows how to apply protection selectively via mapping rules or custom annotations, and discusses practical pitfalls such as sliding‑window logic, path‑parameter handling, and real‑IP detection.

API SecurityBackendInterceptor
0 likes · 20 min read
Mastering API Rate Limiting with Spring Interceptor and Redis
Data Integration and Governance
Data Integration and Governance
Dec 26, 2025 · Backend Development

Building High‑Performance APIs: Design, Optimization, and Security Best Practices

This article examines why APIs are more than data pipes, outlines three essential design questions, and provides concrete strategies—including single‑purpose endpoints, clear naming, batch calls, async core logic, caching, compression, HTTPS, token authentication, rate limiting, versioning, and maintenance practices—to create stable, efficient, and secure APIs.

API DesignCachingPerformance Optimization
0 likes · 11 min read
Building High‑Performance APIs: Design, Optimization, and Security Best Practices
php Courses
php Courses
Dec 18, 2025 · Backend Development

Master Go Rate Limiting: Token Bucket, IP-Based, and Redis Distributed Strategies

This article explains how to protect Go services from overload by implementing HTTP request rate limiting using the standard token‑bucket limiter, per‑IP throttling with a map and mutex, and a distributed approach with Redis and Lua scripts, complete with practical code examples and middleware integration.

GoHTTPRedis
0 likes · 7 min read
Master Go Rate Limiting: Token Bucket, IP-Based, and Redis Distributed Strategies
DeWu Technology
DeWu Technology
Dec 15, 2025 · Backend Development

How Go Powers High‑Concurrency, High‑Availability Systems: 5 Real‑World Scenarios

This article explores five typical high‑concurrency, high‑availability scenarios—gRPC microservice communication, real‑time WebSocket messaging, API‑gateway rate limiting and circuit breaking, Redis‑Stream task queues, and Redis RedLock distributed locks—detailing the problems, Go‑centric solutions, code implementations, and supporting theory.

GoWebSocketgRPC
0 likes · 47 min read
How Go Powers High‑Concurrency, High‑Availability Systems: 5 Real‑World Scenarios
Java Baker
Java Baker
Nov 27, 2025 · Backend Development

Mastering Rate Limiting: Token Bucket & Sliding Window Algorithms in Java

This article explains the principles and implementation details of common rate‑limiting algorithms—token bucket and sliding‑window counting—including their core concepts, key processes, Java code examples, and how to extend them to distributed scenarios with Redis Lua scripts.

Redisdistributedrate limiting
0 likes · 19 min read
Mastering Rate Limiting: Token Bucket & Sliding Window Algorithms in Java
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 24, 2025 · Backend Development

How to Prevent Cache Penetration in High‑Concurrency Systems

The article explains what cache penetration is in high‑concurrency architectures, why it occurs, and presents four practical mitigation strategies—including caching empty values, using Bloom filters, validating request data, and applying rate‑limiting—to protect backend databases from overload.

Bloom Filtercachecache penetration
0 likes · 6 min read
How to Prevent Cache Penetration in High‑Concurrency Systems
SpringMeng
SpringMeng
Nov 19, 2025 · Backend Development

Building a High‑Performance Seckill System with SpringBoot, RabbitMQ and Redis (Full Code)

This article walks through the design and implementation of a complete seckill (flash‑sale) system built on SpringBoot, MyBatis, MySQL, RabbitMQ and Redis, covering double MD5 password hashing, distributed sessions, unified exception handling, caching strategies, memory flags, pre‑decrement inventory, asynchronous order processing, oversell prevention, and rate limiting, with code snippets and UI screenshots.

Distributed SessionOptimistic LockRabbitMQ
0 likes · 9 min read
Building a High‑Performance Seckill System with SpringBoot, RabbitMQ and Redis (Full Code)
Full-Stack DevOps & Kubernetes
Full-Stack DevOps & Kubernetes
Nov 18, 2025 · Operations

How to Stop Brute‑Force Logins with Nginx Rate Limiting

Learn how to protect your web application from brute‑force login attacks by configuring Nginx rate limiting, with step‑by‑step instructions, example configurations, testing methods, custom error pages, and best‑practice tips such as IP whitelisting, HTTPS enforcement, and complementary security measures.

Nginxbrute-force protectionrate limiting
0 likes · 8 min read
How to Stop Brute‑Force Logins with Nginx Rate Limiting
Su San Talks Tech
Su San Talks Tech
Nov 12, 2025 · Operations

Master Nginx: From Reverse Proxy to HTTPS in Six Practical Scenarios

This guide walks backend engineers through six real‑world Nginx configurations—reverse proxy and load balancing, static asset handling, rate limiting with IP black/white lists, HTTPS encryption, and step‑by‑step deployment—showing how to secure, accelerate, and stabilize services.

HTTPSNginxrate limiting
0 likes · 10 min read
Master Nginx: From Reverse Proxy to HTTPS in Six Practical Scenarios
Code Mala Tang
Code Mala Tang
Nov 5, 2025 · Backend Development

How to Build a Production-Ready Async LLM API with FastAPI

Learn how to design and deploy a high‑performance, production‑grade LLM API using FastAPI, covering async routing, type‑safe Pydantic models, streaming via SSE/WebSockets, middleware, caching, rate limiting, observability, retries, and cost‑control strategies for robust AI services.

@AsyncFastAPILLM
0 likes · 12 min read
How to Build a Production-Ready Async LLM API with FastAPI
Architect's Guide
Architect's Guide
Oct 28, 2025 · Backend Development

How to Prevent API Scraping in High‑Traffic Seckill Systems with Java

During high‑traffic flash‑sale events like Double 11, malicious users can flood seckill APIs, causing service collapse and inventory errors; this article explains the business pain points and presents a multi‑layer anti‑scraping solution—including rate limiting, behavior detection, captchas, request signing, token mechanisms, and asynchronous order processing—with concrete Java implementations.

API SecurityCAPTCHAJava
0 likes · 7 min read
How to Prevent API Scraping in High‑Traffic Seckill Systems with Java
Java Baker
Java Baker
Oct 27, 2025 · Backend Development

Master Java Rate Limiting: Guava, Sentinel, and Redisson Solutions

This article compares three Java rate‑limiting approaches—Guava RateLimiter for single‑node control, Sentinel for both single‑node and cluster scenarios, and Redisson RateLimiter for distributed limits—detailing their usage, advantages, disadvantages, and code examples to help developers choose the right solution for their traffic management needs.

BackendGuavaJava
0 likes · 12 min read
Master Java Rate Limiting: Guava, Sentinel, and Redisson Solutions
Python Programming Learning Circle
Python Programming Learning Circle
Oct 18, 2025 · Information Security

Master Nginx Rate Limiting & Anti‑Crawler: Complete Guide with Token Bucket, GeoIP, Lua & JS Challenges

This comprehensive guide explains why modern web services need rate limiting and anti‑crawler protection, compares token‑bucket and leaky‑bucket algorithms, and provides step‑by‑step Nginx configurations for IP, URI, and geographic throttling, advanced user‑agent filtering, JavaScript challenges, real‑time monitoring, performance tuning, and troubleshooting.

Nginxanti‑crawlerrate limiting
0 likes · 18 min read
Master Nginx Rate Limiting & Anti‑Crawler: Complete Guide with Token Bucket, GeoIP, Lua & JS Challenges
Lin is Dream
Lin is Dream
Oct 14, 2025 · Backend Development

Designing a Scalable Short‑Link System: From Base62 Encoding to Security

This article explains how to build a production‑grade short‑link service, covering the background of SMS short URLs, Base62 encoding principles, database schema design, request routing, security measures such as custom alphabets, rate limiting, and signed links, and additional management features for operation and monitoring.

backend architecturebase62database design
0 likes · 16 min read
Designing a Scalable Short‑Link System: From Base62 Encoding to Security
Ray's Galactic Tech
Ray's Galactic Tech
Oct 13, 2025 · Information Security

How to Implement Dynamic IP Blocking in Nginx: 3 Proven Methods

This guide explains three practical ways to achieve dynamic IP blocking in Nginx—using Fail2ban, Lua with Redis, and Nginx's built‑in limit modules—detailing configuration steps, code examples, advantages, drawbacks, and best‑practice recommendations for various deployment scenarios.

Fail2banIP blockingLua
0 likes · 7 min read
How to Implement Dynamic IP Blocking in Nginx: 3 Proven Methods
Su San Talks Tech
Su San Talks Tech
Oct 10, 2025 · Operations

How to Boost System Stability: Observability, Resilience, and High‑Availability Strategies

This comprehensive guide explains how to improve system stability and reduce online incidents by building observability, implementing distributed tracing, applying rate‑limiting and circuit‑breaker patterns, adopting blue‑green and gray deployments, managing data consistency with distributed transactions, planning capacity, optimizing performance, and preparing emergency response plans.

Circuit BreakerDeployment Strategiesdistributed tracing
0 likes · 19 min read
How to Boost System Stability: Observability, Resilience, and High‑Availability Strategies
Code Ape Tech Column
Code Ape Tech Column
Sep 19, 2025 · Backend Development

Sentinel Deep Dive: Flow Control, Circuit Breaking & Rate Limiting

This comprehensive tutorial introduces Alibaba Sentinel, explaining its core concepts, installation, configuration of flow control, degradation, hotspot parameters, system adaptive limits, black‑white lists, persistence with Nacos, cluster flow control, and advanced customization techniques such as custom block handlers and fallback strategies for resilient microservice architectures.

Circuit BreakingFlow ControlSentinel
0 likes · 39 min read
Sentinel Deep Dive: Flow Control, Circuit Breaking & Rate Limiting
Tech Freedom Circle
Tech Freedom Circle
Sep 19, 2025 · Interview Experience

Designing a Rock‑Solid High‑Availability Solution for Unreliable Third‑Party Services

When third‑party services frequently fail, this article walks through a systematic high‑availability design—including an ACL anti‑corruption layer, strategy‑pattern master‑slave routing, precise rate limiting, circuit‑breaker fallback, full observability, async degradation, and mock testing—to keep external dependencies as stable as a mountain.

ACLCircuit BreakerStrategy Pattern
0 likes · 24 min read
Designing a Rock‑Solid High‑Availability Solution for Unreliable Third‑Party Services
Su San Talks Tech
Su San Talks Tech
Sep 18, 2025 · Backend Development

Designing a Million‑QPS Rate Limiter for Backend System Interviews

This article walks through a complete, interview‑ready design of a high‑performance rate‑limiting system that can handle up to one million queries per second, covering requirements, core entities, algorithm choices, distributed state storage with Redis, scalability, high availability, latency optimization, hot‑key mitigation, and dynamic rule configuration.

System Designbackend architecturedistributed systems
0 likes · 29 min read
Designing a Million‑QPS Rate Limiter for Backend System Interviews
Ops Community
Ops Community
Sep 17, 2025 · Operations

Mastering System Fault Tolerance: From Theory to Production‑Ready High‑Availability

This comprehensive guide explores the philosophy, core patterns, and practical techniques for designing fault‑tolerant, highly available systems, covering circuit breakers, retries, rate limiting, monitoring, cloud‑native deployment, and real‑world case studies to help engineers build resilient production architectures.

Circuit Breakercloud-nativefault tolerance
0 likes · 24 min read
Mastering System Fault Tolerance: From Theory to Production‑Ready High‑Availability
Architect's Guide
Architect's Guide
Sep 17, 2025 · Backend Development

How to Build a High‑Performance Flash‑Sale System: 7 Key Architecture Strategies

This article explains the characteristics of flash‑sale traffic and presents a comprehensive backend architecture—including Nginx static separation, Redis caching and locking, MQ buffering, rate‑limiting, async order processing, database sharding, captcha protection, and page optimization—to handle massive concurrent requests while ensuring security and reliability.

Nginxflash salehigh concurrency
0 likes · 11 min read
How to Build a High‑Performance Flash‑Sale System: 7 Key Architecture Strategies
Architect's Journey
Architect's Journey
Sep 15, 2025 · Backend Development

Token Bucket vs Leaky Bucket: Deep Dive into Core Traffic‑Control Algorithms

This article compares the token‑bucket and leaky‑bucket rate‑limiting algorithms, explaining their core principles, Java implementation details, key advantages and drawbacks, suitable application scenarios, interview‑style Q&A, and advanced hybrid strategies for building robust high‑concurrency systems.

Javadistributed systemsleaky-bucket
0 likes · 9 min read
Token Bucket vs Leaky Bucket: Deep Dive into Core Traffic‑Control Algorithms
MaGe Linux Operations
MaGe Linux Operations
Sep 13, 2025 · Information Security

How to Build an Enterprise‑Grade WAF with OpenResty from Scratch

This guide walks through constructing a high‑performance, cost‑effective enterprise‑level Web Application Firewall using OpenResty, covering why OpenResty is ideal, core architecture, modules for request lifecycle management, IP control, rate limiting, SQL injection and XSS detection, intelligent CC protection, monitoring, performance tuning, deployment tips, real‑world case study, and future enhancements.

LuaNginxSQL injection
0 likes · 24 min read
How to Build an Enterprise‑Grade WAF with OpenResty from Scratch
Architect's Guide
Architect's Guide
Sep 7, 2025 · Backend Development

User Login & Token Management: Flow, Rate Limiting, and Security

This article explains the complete user login process, from mobile verification and automatic registration to token generation, validation, expiration policies, logout handling, anonymous access strategies, rate‑limiting via authorized tokens, path‑regex checks, and blacklist management, illustrated with diagrams and Java‑Spring code examples.

API SecurityUser Authenticationrate limiting
0 likes · 10 min read
User Login & Token Management: Flow, Rate Limiting, and Security
Architect's Guide
Architect's Guide
Sep 4, 2025 · Information Security

How to Secure Public APIs: Essential Measures and Java Implementation Guide

This article outlines essential security measures for public APIs—including data encryption, signing, timestamp validation, AppId authentication, rate limiting, blacklist handling, and data validation—explaining why each is needed and providing concrete Java implementation examples such as HTTPS, MD5 signatures, token‑bucket algorithms, and RateLimiter usage.

API SecurityAppIdencryption
0 likes · 10 min read
How to Secure Public APIs: Essential Measures and Java Implementation Guide
macrozheng
macrozheng
Sep 3, 2025 · Backend Development

How to Build a Lightweight Spring Boot API Firewall for Real‑Time Protection

This article walks through the design and implementation of a lightweight API firewall embedded in a Spring Boot application, covering background pain points, core capabilities such as blacklist/whitelist, QPS and user‑limit controls, online configuration via a modern web console, technical choices, detailed code examples, deployment tips, and practical use cases for small‑to‑medium services.

Interceptorapi-firewallblacklist
0 likes · 24 min read
How to Build a Lightweight Spring Boot API Firewall for Real‑Time Protection
Selected Java Interview Questions
Selected Java Interview Questions
Sep 2, 2025 · Backend Development

Master Nginx: Essential Configurations for Backend Engineers

This guide walks backend engineers through essential Nginx configurations—including reverse proxy, load balancing, static file handling, rate limiting, and HTTPS—providing code examples and deployment steps to ensure stable, secure, and high‑performance services while keeping servers resilient during traffic spikes.

HTTPSload balancingrate limiting
0 likes · 10 min read
Master Nginx: Essential Configurations for Backend Engineers
Architect
Architect
Aug 29, 2025 · Backend Development

Mastering Rate Limiting and Circuit Breaking: Practical Guidelines with Sentinel

This article explains how to identify interfaces that need pre‑emptive rate limiting, allocate resources for isolation, apply circuit‑breaking wisely, calculate thresholds based on resource capacity, and leverage Sentinel's features to ensure stable backend performance.

Backend PerformanceCircuit BreakingSentinel
0 likes · 10 min read
Mastering Rate Limiting and Circuit Breaking: Practical Guidelines with Sentinel
Coder Life Journal
Coder Life Journal
Aug 29, 2025 · Backend Development

Designing High‑Concurrency Systems: Tips from a 10‑Year Java Veteran

The article defines high concurrency, explains how to locate bottlenecks and understand user traffic patterns, then outlines practical measures such as distributed architecture, clustering, caching, asynchronous queues, rate limiting, database tuning, preloading, and fault‑tolerant monitoring to build robust high‑throughput systems.

CachingDatabase OptimizationDistributed Architecture
0 likes · 4 min read
Designing High‑Concurrency Systems: Tips from a 10‑Year Java Veteran
Top Architect
Top Architect
Aug 26, 2025 · Backend Development

Dynamic IP Blacklist with Nginx, Lua, and Redis: A Step‑by‑Step Guide

This article explains how to build a dynamic IP blacklist using Nginx, Lua scripts, and Redis, covering the problem definition, environment setup, design choices, Nginx configuration, Lua script implementation, testing, and extensions such as use‑case scenarios and advanced features.

Dynamic blockingIP blacklistLua
0 likes · 12 min read
Dynamic IP Blacklist with Nginx, Lua, and Redis: A Step‑by‑Step Guide
Su San Talks Tech
Su San Talks Tech
Aug 25, 2025 · Backend Development

How to Build a High‑Concurrency Queue System with OpenResty, Lua, and Redis

This article analyzes current system performance bottlenecks, compares hard‑rate‑limiting and flexible queuing strategies, and presents a non‑intrusive traffic‑control solution built with OpenResty+Lua and Redis that offers zero‑code changes, high performance, scalability, and real‑time visual feedback for high‑concurrency scenarios.

LuaRedishigh concurrency
0 likes · 18 min read
How to Build a High‑Concurrency Queue System with OpenResty, Lua, and Redis
Tech Freedom Circle
Tech Freedom Circle
Aug 15, 2025 · Backend Development

Calculating a 100k QPS Rate‑Limiting Threshold: Methods and Best Practices

This article explains how to determine a 100 000‑QPS rate‑limiting threshold by covering the purpose of throttling, the three core elements of limiting, common algorithms, target dimensions, capacity estimation for single‑service and full‑link scenarios, pressure‑testing techniques, monitoring data, and adaptive configuration strategies.

QPSadaptive throttlingbackend algorithms
0 likes · 18 min read
Calculating a 100k QPS Rate‑Limiting Threshold: Methods and Best Practices
mikechen
mikechen
Aug 6, 2025 · Big Data

How to Diagnose and Fix Kafka Message Backlog in High‑Concurrency Environments

In high‑concurrency systems, Kafka message backlog occurs when producers outpace consumers, leading to unprocessed messages that threaten stability and real‑time performance, and this article explains the root causes and provides practical producer‑side and consumer‑side optimization techniques to resolve the issue.

Batch Processingconsumer optimizationhigh concurrency
0 likes · 5 min read
How to Diagnose and Fix Kafka Message Backlog in High‑Concurrency Environments
Architect's Guide
Architect's Guide
Jul 21, 2025 · Operations

How to Achieve Five Nines: Practical High‑Availability Strategies for Modern Web Systems

This article explains key high‑availability concepts such as availability metrics, microservice modularization, load balancing, rate limiting, circuit breaking, isolation, retry strategies, rollback plans, stress testing, monitoring, and on‑call processes, providing concrete design guidelines for building resilient internet services.

Circuit Breakinghigh availabilityload balancing
0 likes · 12 min read
How to Achieve Five Nines: Practical High‑Availability Strategies for Modern Web Systems
Architect's Guide
Architect's Guide
Jul 20, 2025 · Information Security

Unlocking API Security: 10 Common Vulnerabilities Every Tester Must Know

This article explains the most frequent API security flaws—including information disclosure, broken object and function level authorizations, excessive data exposure, rate‑limiting gaps, mass‑assignment, misconfigurations, asset‑management errors, and business‑logic bugs—while providing practical examples, detection techniques, and code snippets for each vulnerability.

API SecurityBFLABOLA
0 likes · 16 min read
Unlocking API Security: 10 Common Vulnerabilities Every Tester Must Know
Architect Practice
Architect Practice
Jul 19, 2025 · Backend Development

Sliding Window Rate Limiting with Redis Lua and Java

This article explains how to implement precise sliding‑window rate limiting using a Redis Lua script and a Spring‑based Java component, compares it with fixed‑window and token‑bucket approaches, and provides advanced techniques, production tips, and performance optimizations.

JavaLuaRedis
0 likes · 14 min read
Sliding Window Rate Limiting with Redis Lua and Java
Architect Practice
Architect Practice
Jul 19, 2025 · Backend Development

Fixed-Window Rate Limiting: Java and Redis Implementation Guide

The article explains the fixed‑window rate‑limiting algorithm, details a thread‑safe Java implementation, shows how to realize distributed limiting with Redis Lua scripts, compares advantages and drawbacks, provides performance benchmarks, and offers practical usage scenarios and production recommendations.

Fixed WindowJavaPerformance
0 likes · 9 min read
Fixed-Window Rate Limiting: Java and Redis Implementation Guide
Java Backend Technology
Java Backend Technology
Jul 14, 2025 · Backend Development

Mastering Rate Limiting: 4 Proven Strategies to Boost System Resilience

This article explores four common rate‑limiting algorithms—fixed window, sliding window, leaky bucket, and token bucket—explains their core principles, shows Java and Redis implementations, discusses real‑world production cases, and provides practical tips for avoiding pitfalls and optimizing performance.

Redisrate limiting
0 likes · 10 min read
Mastering Rate Limiting: 4 Proven Strategies to Boost System Resilience
Java Architect Essentials
Java Architect Essentials
Jul 12, 2025 · Backend Development

Why Reactive Programming Fails Without Backpressure and How to Fix It

During high‑traffic spikes, traditional servlet‑based services often crash due to thread‑pool exhaustion, while reactive systems using Reactor can still fail if backpressure is ignored; this article explains the pitfalls, compares models, and provides practical backpressure solutions such as dynamic rate limiting, bounded buffering, and circuit breaking.

BackpressureCircuit BreakingJava
0 likes · 11 min read
Why Reactive Programming Fails Without Backpressure and How to Fix It
Lin is Dream
Lin is Dream
Jul 7, 2025 · Backend Development

Master Sliding‑Window Rate Limiting with Redis Sorted Sets

This article explains how to implement a precise sliding‑window rate‑limiting algorithm using Redis Sorted Sets, detailing the problem scenario, the algorithm steps, Lua script implementation, Java integration, and practical extensions for high‑performance backend services.

BackendJavaLua
0 likes · 8 min read
Master Sliding‑Window Rate Limiting with Redis Sorted Sets
Tencent Cloud Middleware
Tencent Cloud Middleware
Jun 25, 2025 · Cloud Computing

How Tencent Cloud TDMQ Serverless RabbitMQ Implements Distributed Rate Limiting for High‑Concurrency

This article deeply examines Tencent Cloud TDMQ RabbitMQ Serverless's distributed rate‑limiting mechanism, covering its necessity, design principles, token‑based throttling architecture, implementation challenges, client‑side error handling, and practical guidelines for planning load and configuring alerts to ensure stable high‑throughput messaging.

RabbitMQServerlessTDMQ
0 likes · 20 min read
How Tencent Cloud TDMQ Serverless RabbitMQ Implements Distributed Rate Limiting for High‑Concurrency
Code Mala Tang
Code Mala Tang
Jun 17, 2025 · Backend Development

Mastering Rate Limiting: Algorithms, Redis & Lua for Scalable Backend APIs

This article explains the concept of rate limiting, compares five common algorithms—including fixed‑window, sliding‑log, sliding‑window counter, token bucket and leaky bucket—covers distributed designs using Redis and Lua scripts, and provides complete FastAPI implementation and pytest tests for both fixed‑window and sliding‑log strategies.

BackendFastAPILua
0 likes · 13 min read
Mastering Rate Limiting: Algorithms, Redis & Lua for Scalable Backend APIs
IT Services Circle
IT Services Circle
Jun 13, 2025 · Information Security

Defending Against Million‑QPS Attacks: Rate Limiting, Fingerprinting & Real‑Time Rules

This article explains how to protect systems from massive malicious traffic reaching millions of queries per second by combining gateway rate limiting, distributed circuit breaking, device fingerprinting, behavior analysis, dynamic rule engines, and real‑time risk scoring, illustrated with Nginx‑Lua, Sentinel, Drools, and Flink examples.

Backend SecurityDDoS mitigationdevice fingerprinting
0 likes · 15 min read
Defending Against Million‑QPS Attacks: Rate Limiting, Fingerprinting & Real‑Time Rules
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jun 12, 2025 · Backend Development

How Spring Cloud Gateway Handles Millions of Requests with Reactive Non‑Blocking Architecture

This article explains how Spring Cloud Gateway leverages an asynchronous non‑blocking model built on Netty and Project Reactor, along with rate limiting, circuit breaking, and degradation strategies, to sustain million‑level concurrent traffic while protecting backend services.

Circuit BreakingSpring Cloud Gatewaybackend development
0 likes · 5 min read
How Spring Cloud Gateway Handles Millions of Requests with Reactive Non‑Blocking Architecture
Su San Talks Tech
Su San Talks Tech
Jun 12, 2025 · Information Security

Defending Against Million‑QPS Attacks: Rate Limiting, Fingerprinting, and Dynamic Rules

This article explains why a million‑QPS flood can cripple systems, outlines attackers' tactics, and presents a three‑layer defense strategy—including gateway rate limiting with Nginx + Lua, distributed circuit breaking via Sentinel, device fingerprinting, behavior analysis, and a dynamic rule engine—to protect high‑traffic services.

DDoSbehavior analysishigh QPS
0 likes · 14 min read
Defending Against Million‑QPS Attacks: Rate Limiting, Fingerprinting, and Dynamic Rules
Architecture and Beyond
Architecture and Beyond
Jun 8, 2025 · Backend Development

Designing Queueing and Rate Limiting for Scalable AIGC Services

This article explains why queueing systems and rate‑limiting strategies are essential for AIGC platforms, describes the user‑facing product behaviors they produce, outlines design considerations, compares technical options, and provides practical implementation guidance to keep services stable, cost‑effective, and user‑friendly.

AIGCBackendQueue
0 likes · 30 min read
Designing Queueing and Rate Limiting for Scalable AIGC Services
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jun 4, 2025 · Backend Development

Understanding Spring Cloud Gateway’s Non‑Blocking Architecture for Million‑Level Concurrency

The article explains how Spring Cloud Gateway leverages a fully non‑blocking, reactive architecture built on Project Reactor and Netty to handle millions of concurrent requests, and discusses essential protection mechanisms such as rate limiting, circuit breaking, and degradation for high‑traffic scenarios.

Circuit BreakingSpring Cloud Gatewayhigh-concurrency
0 likes · 6 min read
Understanding Spring Cloud Gateway’s Non‑Blocking Architecture for Million‑Level Concurrency
Su San Talks Tech
Su San Talks Tech
May 30, 2025 · Backend Development

How to Build Secure, Reliable API Controllers: Signatures, Encryption, Rate Limiting and More

This article explains how to design robust API controller interfaces by covering signature verification, RSA encryption, IP whitelisting, rate limiting, parameter validation, unified response formats, exception handling, request logging, idempotency, record limits, stress testing, asynchronous processing, data masking, and comprehensive documentation.

API DesignBackendidempotency
0 likes · 15 min read
How to Build Secure, Reliable API Controllers: Signatures, Encryption, Rate Limiting and More
Open Source Tech Hub
Open Source Tech Hub
May 25, 2025 · Backend Development

How to Rate‑Limit Asynchronous Tasks with ReactPHP‑MQ

ReactPHP‑MQ provides a lightweight, SOLID‑designed queue for managing concurrent asynchronous operations, offering features like configurable concurrency limits, solid test coverage, and advanced methods such as all(), any(), and timeout handling for robust rate‑limiting in PHP applications.

PHPReactPHPasynchronous queue
0 likes · 5 min read
How to Rate‑Limit Asynchronous Tasks with ReactPHP‑MQ
JD Cloud Developers
JD Cloud Developers
May 15, 2025 · Cloud Native

How Sentinel Empowers Cloud‑Native Traffic Governance and Resilience

This article introduces Sentinel, a cloud‑native flow‑control component born from Alibaba's ecosystem, explains its resource‑based rule model, core implementation—including rule‑control chain, datasource, and dashboard—and discusses practical deployment considerations and extension strategies for Java microservices.

JavaSentinelcloud-native
0 likes · 20 min read
How Sentinel Empowers Cloud‑Native Traffic Governance and Resilience
Java Captain
Java Captain
May 14, 2025 · Backend Development

Rate Limiting in Java: Redis, Spring AOP, and Custom Annotations

This article explains the concept of rate limiting, introduces common algorithms such as token bucket and leaky bucket, and provides a complete Spring‑Boot implementation using Redis, custom annotations, AOP, and utility classes for distributed request throttling.

annotationdistributedrate limiting
0 likes · 21 min read
Rate Limiting in Java: Redis, Spring AOP, and Custom Annotations
Pan Zhi's Tech Notes
Pan Zhi's Tech Notes
May 6, 2025 · Backend Development

Persist Sentinel Rate‑Limiting Rules with Nacos to Prevent Loss After Restart

The article explains why Sentinel rate‑limiting rules disappear after a client restart, demonstrates how to store those rules permanently in Nacos by creating a JSON configuration, adding a Nacos data source to the Sentinel client, and modifying the Sentinel Dashboard source code to achieve bidirectional synchronization, followed by verification steps.

NacosRule PersistenceSentinel
0 likes · 14 min read
Persist Sentinel Rate‑Limiting Rules with Nacos to Prevent Loss After Restart
Liangxu Linux
Liangxu Linux
May 5, 2025 · Backend Development

How to Dynamically Block IPs with Nginx, Lua, and Redis

This guide explains how to use Nginx, Lua (via OpenResty), and Redis to automatically block any IP that exceeds 60 requests per minute, storing the blacklist in Redis with a default one‑day ban and providing performance optimizations and testing steps.

BackendIP blockingLua
0 likes · 7 min read
How to Dynamically Block IPs with Nginx, Lua, and Redis
macrozheng
macrozheng
Apr 29, 2025 · Backend Development

How to Tame a 100× Traffic Surge: Practical Strategies for Backend Engineers

This guide walks backend developers through a step‑by‑step approach to handle sudden 100‑fold traffic spikes, covering emergency response, traffic analysis, robust system design, scaling techniques, circuit breaking, message queuing, and stress testing to keep services resilient and performant.

Backend PerformanceCircuit Breakingrate limiting
0 likes · 12 min read
How to Tame a 100× Traffic Surge: Practical Strategies for Backend Engineers
Selected Java Interview Questions
Selected Java Interview Questions
Apr 27, 2025 · Backend Development

Comprehensive Guide to Rate Limiting in Microservice Architecture Using Dubbo, Spring Cloud, Guava, Sentinel, Redis, and a Custom Spring Boot Starter

This article explains why rate limiting is critical for microservice stability, compares implementations across Dubbo, Spring Cloud, and gateway layers, details common algorithms such as token bucket, leaky bucket, and sliding window, and provides step‑by‑step code examples for Guava, Sentinel, Redis‑Lua, and a reusable Spring Boot starter to enforce rate limits in Java back‑end services.

GuavaSentinelrate limiting
0 likes · 25 min read
Comprehensive Guide to Rate Limiting in Microservice Architecture Using Dubbo, Spring Cloud, Guava, Sentinel, Redis, and a Custom Spring Boot Starter
Pan Zhi's Tech Notes
Pan Zhi's Tech Notes
Apr 27, 2025 · Cloud Native

Why Alibaba’s Open‑Source Sentinel Beats Other Service Rate‑Limiting Tools

This article introduces Sentinel, Alibaba’s open‑source traffic‑governance component, compares it with Hystrix, demonstrates quick‑start code, shows SpringBoot integration, annotation usage, console setup, and OpenFeign adaptation, illustrating how to implement service rate limiting and circuit breaking in microservices.

Circuit BreakingJavaSentinel
0 likes · 17 min read
Why Alibaba’s Open‑Source Sentinel Beats Other Service Rate‑Limiting Tools
IT Services Circle
IT Services Circle
Apr 23, 2025 · Backend Development

Handling Sudden Traffic Spikes in Backend Systems

The article outlines a comprehensive approach for backend engineers to manage a sudden 100‑fold increase in traffic, covering emergency response, traffic analysis, robust system design, rate limiting, circuit breaking, scaling, sharding, pooling, caching, asynchronous processing, and stress testing to ensure system stability and performance.

CachingCircuit BreakingLoad Testing
0 likes · 13 min read
Handling Sudden Traffic Spikes in Backend Systems
IT Services Circle
IT Services Circle
Apr 18, 2025 · Backend Development

Preventing Duplicate Orders under 100k QPS: Full‑Stack Strategies

This article explains how to prevent duplicate orders in a high‑traffic system handling 100,000 QPS by combining frontend safeguards such as button disabling and token mechanisms with backend techniques including NGINX rate limiting, gateway token validation, idempotent database design, sharding, distributed locks, optimistic locking, and comprehensive logging and monitoring.

backend designdistributed lockduplicate order
0 likes · 7 min read
Preventing Duplicate Orders under 100k QPS: Full‑Stack Strategies
ITPUB
ITPUB
Apr 17, 2025 · Databases

Migrate 700TB Over 2Mbps: Scripts, Sneakernet & Practical Steps

When a manager demands a script to move a 700‑terabyte database under a 2 Mbps bandwidth cap, the realistic solution combines physical Sneakernet transfer with a carefully staged export‑transform‑load script that handles field mapping, compression, rate‑limited transport, and fault‑tolerant import.

ETLJavalarge data transfer
0 likes · 8 min read
Migrate 700TB Over 2Mbps: Scripts, Sneakernet & Practical Steps
macrozheng
macrozheng
Apr 17, 2025 · Backend Development

Mastering Rate Limiting: 4 Proven Strategies to Protect Your Services

Facing a sudden 35% error rate in a payment API, the article explores why unprotected services crash, then details four common rate‑limiting algorithms—fixed window, sliding window, leaky bucket, token bucket—offering Java implementations, real‑world case studies, pitfalls, and performance tuning tips for production systems.

BackendJavarate limiting
0 likes · 10 min read
Mastering Rate Limiting: 4 Proven Strategies to Protect Your Services
Architecture and Beyond
Architecture and Beyond
Apr 12, 2025 · Backend Development

How to Keep Your AIGC Service Stable: Queueing and Rate‑Limiting Strategies

This article explains why AIGC services need queueing systems and rate‑limiting, describes the user‑facing behaviors of both mechanisms, outlines design goals, compares queue and limiter implementations, and provides practical guidance on selecting middleware, monitoring, and integrating them into a production workflow.

AIGCBackendSystem Design
0 likes · 28 min read
How to Keep Your AIGC Service Stable: Queueing and Rate‑Limiting Strategies
IT Services Circle
IT Services Circle
Apr 9, 2025 · Backend Development

Practical Guide to Rate Limiting: Algorithms, Implementation, and Production Cases

This article explains the fundamentals and practical implementations of common rate‑limiting algorithms—including fixed‑window, sliding‑window, leaky‑bucket, and token‑bucket—provides Java and Redis code samples, discusses their advantages, pitfalls, and real‑world production scenarios, and offers performance‑tuning tips.

Javabackend algorithmsdistributed systems
0 likes · 10 min read
Practical Guide to Rate Limiting: Algorithms, Implementation, and Production Cases
Su San Talks Tech
Su San Talks Tech
Apr 8, 2025 · Backend Development

Mastering Rate Limiting: Practical Algorithms and Real‑World Cases

This article explains why rate limiting is essential for high‑traffic services, compares four classic algorithms (fixed‑window, sliding‑window, leaky‑bucket, token‑bucket), provides Java and Redis implementations, shares production case studies, highlights common pitfalls, and offers performance‑tuning tips for robust backend systems.

BackendRedisdistributed systems
0 likes · 11 min read
Mastering Rate Limiting: Practical Algorithms and Real‑World Cases
Java Captain
Java Captain
Apr 4, 2025 · Backend Development

High Concurrency: Principles, Impacts, and Practical Solutions for Backend Systems

This comprehensive guide explains the nature of high concurrency, distinguishes it from parallelism, outlines its potential consequences across application, database, and service layers, and presents a systematic set of mitigation strategies—including rate limiting, asynchronous processing, redundancy, caching, and queue‑based designs—supported by real‑world case studies and code examples.

Backend PerformanceCachingDatabase Optimization
0 likes · 27 min read
High Concurrency: Principles, Impacts, and Practical Solutions for Backend Systems
Cognitive Technology Team
Cognitive Technology Team
Apr 2, 2025 · Backend Development

Understanding Rate Limiting: Importance, Types, Algorithms, and Implementation

This article explains the concept of rate limiting in system design, covering its importance, common use cases, various types, popular algorithms such as token bucket and leaky bucket, implementation across different system layers, and the challenges associated with configuring and scaling rate‑limiting solutions.

BackendSystem Designalgorithm
0 likes · 10 min read
Understanding Rate Limiting: Importance, Types, Algorithms, and Implementation
Code Mala Tang
Code Mala Tang
Mar 21, 2025 · Backend Development

How to Implement Rate Limiting in FastAPI with SlowAPI

This tutorial explains how to add request rate limiting to a FastAPI application using the SlowAPI library, covering both IP‑based limits and custom token‑based strategies, with installation steps, code examples, and best‑practice recommendations.

BackendFastAPIPython
0 likes · 5 min read
How to Implement Rate Limiting in FastAPI with SlowAPI
Mingyi World Elasticsearch
Mingyi World Elasticsearch
Mar 18, 2025 · Databases

Six Real-World Enterprise Use Cases of INFINI Gateway for Elasticsearch

The article examines six practical enterprise scenarios where INFINI Gateway enhances Elasticsearch clusters—covering zero‑cost security, intelligent query protection, automated slow‑query circuit breaking, high‑performance proxy architecture, fine‑grained read/write throttling, and end‑to‑end request logging—detailing problems, traditional limitations, and the gateway’s concrete solutions.

ElasticsearchINFINI GatewayLog Auditing
0 likes · 6 min read
Six Real-World Enterprise Use Cases of INFINI Gateway for Elasticsearch
FunTester
FunTester
Mar 18, 2025 · Operations

How to Build a Fault‑Isolation Shield for High‑Traffic Distributed Systems

The article explains how to construct a comprehensive fault‑isolation and protection system for modern distributed applications, covering entry‑side rate limiting, exit‑side circuit breaking, internal resource isolation, monitoring, chaos‑engineering validation, and automatic self‑healing mechanisms using tools such as Sentinel, Nginx, Hystrix, SkyWalking, Prometheus and Kubernetes.

Circuit Breakingauto recoverychaos engineering
0 likes · 7 min read
How to Build a Fault‑Isolation Shield for High‑Traffic Distributed Systems
Tencent Cloud Middleware
Tencent Cloud Middleware
Mar 17, 2025 · Backend Development

Mastering Microservice Rate Limiting: Strategies, Algorithms, and TSF Implementation

This article explains why rate limiting is essential for high‑traffic microservices, outlines the key design considerations, compares major algorithms such as fixed‑window, sliding‑window, leaky‑bucket and token‑bucket, and details how Tencent Service Framework (TSF), Polaris, and TSF‑Consul implement distributed rate limiting with practical configuration examples and post‑limit handling strategies.

PolarisService Governancerate limiting
0 likes · 23 min read
Mastering Microservice Rate Limiting: Strategies, Algorithms, and TSF Implementation
Alibaba Cloud Developer
Alibaba Cloud Developer
Mar 14, 2025 · Artificial Intelligence

Solving Rate Limiting, Load Balancing, and Data Challenges in AI Inference with Tair

This article explains how AI inference services can tackle five core problems—rate limiting, load balancing, asynchronous processing, user data management, and index enhancement—by leveraging Tair's rich data structures, offering practical code examples, architectural diagrams, and a comparison with alternative solutions.

AI inferenceRAGTair
0 likes · 20 min read
Solving Rate Limiting, Load Balancing, and Data Challenges in AI Inference with Tair
Selected Java Interview Questions
Selected Java Interview Questions
Mar 14, 2025 · Backend Development

Design and Implementation of a Business Rate‑Limiting Component Using Redis Lua Scripts and Kotlin Annotations

This article explains how to design and implement a business-specific rate‑limiting component in Kotlin using Redis Lua scripts and Spring AOP annotations, covering the motivation, rule definitions, counting strategies, Lua script details, annotation creation, and a practical usage example.

KotlinLuarate limiting
0 likes · 10 min read
Design and Implementation of a Business Rate‑Limiting Component Using Redis Lua Scripts and Kotlin Annotations