BestHub
Sign in
Tagged articles
575 articles
Page 2 of 6
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.

BackendIdempotencyapi-design
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.

Concurrency ControlPHPReactPHP
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.

Cloud NativeJavaMicroservices
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.

Distributedannotationrate 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.

Backend DevelopmentNacosRule Persistence
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.

GuavaSpring Boot Starterrate 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 BreakingJavaMicroservices
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.

Circuit BreakingLoad Testingasynchronous processing
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.

Idempotencybackend designdistributed-lock
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.

AIGCBackendMessage Queue
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.

Distributed SystemsJavabackend algorithms
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.

BackendDistributed Systemsrate limiting
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 PerformanceDatabase Optimizationasynchronous processing
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 BreakingDistributed SystemsMicroservices
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.

PolarisToken Bucketrate 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
FunTester
FunTester
Mar 2, 2025 · Operations

Common Fault Propagation Patterns and Prevention Strategies in Distributed Systems

The article examines typical fault propagation scenarios such as avalanche effects, cascading failures, resource exhaustion, data pollution, and dependency cycles in distributed systems, and outlines proactive measures like rate limiting, circuit breaking, isolation, monitoring, and chaos engineering to prevent small issues from escalating into large-scale outages.

chaos engineeringcircuit breakerfault tolerance
0 likes · 11 min read
Common Fault Propagation Patterns and Prevention Strategies in Distributed Systems
MaGe Linux Operations
MaGe Linux Operations
Feb 25, 2025 · Backend Development

Mastering Nginx: From Basics to Advanced Load Balancing and High‑Concurrency Techniques

This comprehensive guide explains what Nginx is, its advantages, typical use cases, request processing, high‑concurrency architecture, forward and reverse proxy concepts, directory layout, configuration directives, cookie vs session, load‑balancing algorithms, rate limiting, static‑dynamic separation, CDN integration, health checks, compression, and worker process tuning, providing practical code examples for each topic.

Configurationload balancingrate limiting
0 likes · 31 min read
Mastering Nginx: From Basics to Advanced Load Balancing and High‑Concurrency Techniques
Architecture and Beyond
Architecture and Beyond
Feb 6, 2025 · Operations

Analyzing DeepSeek’s Availability Issues and Applying Traditional Internet Reliability Strategies to AIGC

This article examines DeepSeek’s frequent service interruptions, contrasts the inherent reliability challenges of AIGC products with traditional internet applications, and proposes adopting proven isolation, rate‑limiting, and elastic‑scaling techniques to improve AI service availability and user experience.

AIGCAvailabilityDeepSeek
0 likes · 12 min read
Analyzing DeepSeek’s Availability Issues and Applying Traditional Internet Reliability Strategies to AIGC
Code Ape Tech Column
Code Ape Tech Column
Jan 27, 2025 · Backend Development

Comprehensive Guide to Rate Limiting Strategies and Implementations in Microservice Architecture

This article systematically explains the importance of rate limiting in microservice systems, compares various governance frameworks such as Dubbo and Spring Cloud, introduces common algorithms like token‑bucket and leaky‑bucket, and provides detailed implementation examples using Guava, Sentinel, Redis+Lua, and a custom Spring Boot starter.

JavaMicroservicesSpring Boot
0 likes · 25 min read
Comprehensive Guide to Rate Limiting Strategies and Implementations in Microservice Architecture
Tencent Cloud Developer
Tencent Cloud Developer
Jan 22, 2025 · Cloud Native

Rate Limiting: Concepts, Algorithms, and Distributed Solutions

Rate limiting protects micro‑service stability by rejecting excess traffic, using algorithms such as fixed‑window, sliding‑window, leaky‑bucket and token‑bucket, and can be deployed locally or distributed via Redis, load‑balancers, or coordination services, each offering different trade‑offs in precision, scalability, and complexity.

Distributed SystemsGolangMicroservices
0 likes · 31 min read
Rate Limiting: Concepts, Algorithms, and Distributed Solutions
Tencent Cloud Developer
Tencent Cloud Developer
Jan 15, 2025 · Operations

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

This article explains why rate limiting is essential for microservice reliability, outlines the key factors to consider before applying limits, compares major algorithms such as fixed‑window, sliding‑window, leaky‑bucket and token‑bucket, describes post‑limit actions, and details how Tencent Service Framework (TSF) implements configurable, tag‑based rate limiting in cloud‑native environments.

MicroservicesSliding WindowToken Bucket
0 likes · 19 min read
Mastering Microservice Rate Limiting: Strategies, Algorithms, and TSF Implementation
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jan 8, 2025 · Backend Development

Eight High‑Performance Architecture Solutions for Large‑Scale Systems

This article outlines eight essential high‑performance architecture techniques—including load balancing, asynchronous processing, database optimization, caching, distributed clusters, CDN, microservices, and rate‑limiting/circuit‑breaking—to improve scalability, availability, and responsiveness of large‑scale backend systems.

Database Optimizationasynchronous processingcaching
0 likes · 9 min read
Eight High‑Performance Architecture Solutions for Large‑Scale Systems
Architecture Digest
Architecture Digest
Jan 3, 2025 · Operations

Designing High‑Availability Architecture with Rate Limiting, Circuit Breaking, and Degradation Strategies

This article explains how to build a highly available distributed e‑commerce system by using load‑balancing, redundant servers, rate‑limiting techniques, circuit‑breaker patterns, and graceful degradation methods, and provides concrete Spring Cloud and Java code examples for each strategy.

BackendCircuit BreakingDistributed Systems
0 likes · 18 min read
Designing High‑Availability Architecture with Rate Limiting, Circuit Breaking, and Degradation Strategies
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 30, 2024 · Backend Development

How to Define and Tackle High Concurrency: Strategies and Code Samples

This article explains what constitutes high concurrency, categorizes load levels, and presents practical solutions such as load balancing, database sharding, query optimization, caching, message queues, and rate‑limiting, complete with code examples for implementing these techniques in backend systems.

database shardinghigh concurrencyload balancing
0 likes · 7 min read
How to Define and Tackle High Concurrency: Strategies and Code Samples
Tencent Cloud Developer
Tencent Cloud Developer
Dec 12, 2024 · Backend Development

Common Rate Limiting Algorithms: Fixed Window, Sliding Window, Sliding Log, Leaky Bucket, and Token Bucket

The article examines five common rate‑limiting algorithms—Fixed Window, Sliding Window, Sliding Log, Leaky Bucket, and Token Bucket—detailing their principles, pros and cons, and providing complete C++ implementations to help developers choose the best approach for controlling traffic bursts and ensuring system stability.

BackendC++Distributed Systems
0 likes · 14 min read
Common Rate Limiting Algorithms: Fixed Window, Sliding Window, Sliding Log, Leaky Bucket, and Token Bucket
Architect
Architect
Dec 8, 2024 · Backend Development

16 Essential Redis Patterns Every Backend Engineer Should Master

This article compiles sixteen practical Redis use‑cases—from caching and distributed locks to rate limiting, bitmaps, shopping carts, timelines, queues, likes, tags, filtering, follow/fan relationships, and leaderboards—providing code snippets and command examples to help backend developers design scalable systems.

BackendDesign Patternscaching
0 likes · 11 min read
16 Essential Redis Patterns Every Backend Engineer Should Master
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Dec 4, 2024 · Operations

Service Reliability Essentials: Rate Limiting, Circuit Breaking & Degradation

This article explains common service problems and presents practical solutions such as rate limiting, circuit breaking, and degradation, detailing their principles, implementation methods—including Nginx, token‑bucket, sliding‑window algorithms, and Go‑zero code examples—while highlighting key considerations for building resilient microservice systems.

go-zerorate limitingservice degradation
0 likes · 15 min read
Service Reliability Essentials: Rate Limiting, Circuit Breaking & Degradation
IT Services Circle
IT Services Circle
Nov 15, 2024 · Backend Development

Best Practices for Designing Secure and Robust API Controller Interfaces

This guide outlines comprehensive techniques for building safe, repeatable, and maintainable API controller interfaces, covering signature generation, encryption, IP whitelisting, rate limiting, parameter validation, unified responses, exception handling, logging, idempotency, request size limits, stress testing, asynchronous processing, data masking, and complete documentation.

APIException HandlingIdempotency
0 likes · 15 min read
Best Practices for Designing Secure and Robust API Controller Interfaces
php Courses
php Courses
Nov 14, 2024 · Information Security

Best Practices for Securing Laravel Web Applications

This article outlines essential Laravel security practices, including built‑in authentication, CSRF protection, input validation, HTTPS enforcement, secure session handling, regular dependency updates, and rate limiting, providing developers with concrete steps to protect web applications from common attacks.

AuthenticationCSRFHTTPS
0 likes · 6 min read
Best Practices for Securing Laravel Web Applications
JD Cloud Developers
JD Cloud Developers
Nov 13, 2024 · Backend Development

Mastering Sentinel: Deep Dive into Java Flow Control and Cloud‑Native Governance

Sentinel, an open‑source flow‑control component born from Alibaba’s ecosystem, offers out‑of‑the‑box circuit‑breaking, rate‑limiting, and real‑time monitoring for Java microservices, with extensive rule types, dashboard visualization, datasource integrations, and adaptable architecture that supports multiple protocols, making it a versatile solution for cloud‑native traffic governance.

Circuit BreakingFlow ControlJava
0 likes · 19 min read
Mastering Sentinel: Deep Dive into Java Flow Control and Cloud‑Native Governance
JD Tech
JD Tech
Nov 7, 2024 · Big Data

JDQ Kafka Bandwidth Control and Rate Limiting Architecture

This article analyzes the limitations of native Apache Kafka rate‑limiting, introduces JDQ's multi‑dimensional, dynamic, priority‑aware bandwidth control framework, and demonstrates its effectiveness through partition‑level, single‑machine, and hierarchical elastic throttling experiments for large‑scale e‑commerce data streams.

Distributed StreamingElastic ThrottlingKafka
0 likes · 18 min read
JDQ Kafka Bandwidth Control and Rate Limiting Architecture
Sohu Tech Products
Sohu Tech Products
Oct 30, 2024 · Backend Development

How to Build Dynamic Parameter‑Level Rate Limiting with Sentinel

This article explains the need for dynamic, fine‑grained rate limiting in high‑traffic services, describes Sentinel's core mechanisms, and details a three‑step implementation—data collection, rule management, and traffic verification—using sliding‑window counters and priority‑based throttling.

BackendDynamic ThrottlingMicroservices
0 likes · 17 min read
How to Build Dynamic Parameter‑Level Rate Limiting with Sentinel
Architect
Architect
Oct 27, 2024 · Backend Development

How We Scaled a Lottery System to Over 1M Daily Users: Architecture & Performance Hacks

This article details the end‑to‑end architecture and step‑by‑step performance tuning of a high‑traffic lottery platform, covering server‑level rate limiting, application‑level throttling, semaphore usage, user‑behavior detection, caching strategies, database optimizations, and hardware upgrades that together enabled stable handling of millions of daily requests.

Backend ArchitecturePerformance Optimizationdatabase scaling
0 likes · 15 min read
How We Scaled a Lottery System to Over 1M Daily Users: Architecture & Performance Hacks
Architect
Architect
Oct 1, 2024 · Backend Development

How We Engineered a Million‑User Lottery System to Survive Massive Spikes

This article details the end‑to‑end architecture, rate‑limiting strategies, caching layers, database optimizations, and hardware upgrades that enabled a lottery service to handle daily traffic exceeding one million users during peak promotional events.

Backend ArchitecturePerformance Optimizationcaching
0 likes · 15 min read
How We Engineered a Million‑User Lottery System to Survive Massive Spikes
DaTaobao Tech
DaTaobao Tech
Sep 30, 2024 · Backend Development

KLimiter: Adaptive Rate Limiter for Downstream Resource Protection

KLimiter is an adaptive rate‑limiter that continuously monitors downstream resource water‑levels, computes impact coefficients from historical traffic, and dynamically throttles multiple upstream entries according to their priorities, using gradual reductions, slow‑start and fallback strategies to maintain stability and efficiency beyond static threshold methods.

Backendadaptive algorithmrate limiting
0 likes · 11 min read
KLimiter: Adaptive Rate Limiter for Downstream Resource Protection
Java Architecture Stack
Java Architecture Stack
Sep 30, 2024 · Backend Development

Mastering Unbounded and Bounded Queues in Java: When to Use Each

This article explains the concepts, characteristics, and ideal scenarios for unbounded and bounded queues in Java, provides step‑by‑step Maven setup and complete code examples for asynchronous task scheduling, event‑driven processing, and API rate‑limiting, and highlights practical considerations such as resource management and performance.

Bounded QueueJavaProducer Consumer
0 likes · 23 min read
Mastering Unbounded and Bounded Queues in Java: When to Use Each
Java Architect Essentials
Java Architect Essentials
Sep 26, 2024 · Backend Development

Implementing Interface Rate Limiting in Spring Boot Using Interceptor, Redis, and Custom Annotations

This article demonstrates how to build a flexible API rate‑limiting solution in Spring Boot by combining a HandlerInterceptor, Redis counters, and custom annotations with reflection, covering configuration, code examples, mapping rules, time‑window nuances, path‑parameter handling, and real‑IP considerations.

Custom AnnotationInterceptorJava
0 likes · 18 min read
Implementing Interface Rate Limiting in Spring Boot Using Interceptor, Redis, and Custom Annotations
Su San Talks Tech
Su San Talks Tech
Sep 22, 2024 · Backend Development

Mastering Rate Limiting: From Fixed Windows to Redis Distributed Solutions

This article explains why rate limiting is essential for microservice stability, introduces basic concepts like thresholds and rejection strategies, and walks through multiple algorithms—including fixed‑window, sliding‑window, sliding‑log, leaky‑bucket, token‑bucket—and their Java implementations as well as Redis‑based distributed approaches, complete with code samples and performance considerations.

Backend DevelopmentDistributed SystemsJava
0 likes · 25 min read
Mastering Rate Limiting: From Fixed Windows to Redis Distributed Solutions
Architect
Architect
Sep 20, 2024 · Backend Development

18 Essential API Design Rules Every Backend Engineer Should Follow

This article presents a comprehensive checklist of 18 practical API design rules—including signature, encryption, IP whitelisting, rate limiting, validation, unified responses, exception handling, logging, idempotency, pagination, stress testing, async processing, data masking, documentation, request methods, headers, batch operations, and single‑responsibility principles—to help developers build secure, maintainable, and high‑performance services.

BackendDocumentationIdempotency
0 likes · 18 min read
18 Essential API Design Rules Every Backend Engineer Should Follow
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Sep 19, 2024 · Backend Development

Understanding High Concurrency: TPS Thresholds and Architectural Solutions

The article explains what high concurrency means, defines TPS thresholds for moderate, high, and ultra‑high traffic, and outlines key backend techniques such as distributed and microservice architectures, caching, load balancing, traffic shaping, and rate‑limiting/circuit‑breaking to handle massive request volumes.

TPScachingdistributed architecture
0 likes · 6 min read
Understanding High Concurrency: TPS Thresholds and Architectural Solutions
Java Tech Enthusiast
Java Tech Enthusiast
Sep 12, 2024 · Backend Development

Rate Limiting Algorithms and Implementations in Java Microservices

The article explains service rate limiting and demonstrates six Java implementations—Fixed Window, Sliding Window, Leaky Bucket, Token Bucket, Sentinel middleware, and Spring Cloud Gateway—detailing their algorithms, code examples, and configuration to protect microservices from overload.

JavaMicroservicesSpring Cloud
0 likes · 20 min read
Rate Limiting Algorithms and Implementations in Java Microservices
Tencent Cloud Developer
Tencent Cloud Developer
Sep 3, 2024 · Backend Development

Rate Limiting: Purpose, Algorithms, Implementation Methods, Strategies, and Considerations

Rate limiting safeguards system stability by capping request rates, employing algorithms such as fixed‑window, sliding‑window, leaky‑bucket, and token‑bucket, and can be applied at application, proxy, or hardware layers while using strategies like threshold setting, request classification, feedback, and ensuring fairness, flexibility, and transparency.

BackendDistributed SystemsGolang
0 likes · 28 min read
Rate Limiting: Purpose, Algorithms, Implementation Methods, Strategies, and Considerations
JavaEdge
JavaEdge
Aug 15, 2024 · Backend Development

How to Implement Rate Limiting in Event‑Driven Microservices with Resilience4j

This article explains how to use a token‑bucket rate limiter, such as the one provided by Resilience4j, to keep event‑driven microservices within the request/response API traffic limits, detailing the underlying problem, integration steps, code example, and practical considerations.

Token Bucketrate limitingresilience4j
0 likes · 7 min read
How to Implement Rate Limiting in Event‑Driven Microservices with Resilience4j
Top Architect
Top Architect
Aug 15, 2024 · Backend Development

Handling Interface‑Level Failures: Degradation, Circuit Breaking, Rate Limiting, and Queuing

The article explains how interface‑level faults—where the system stays up but business performance degrades—can be mitigated through four core techniques (degradation, circuit breaking, rate limiting, and queuing), detailing their principles, implementation patterns, and practical trade‑offs for backend services.

Backendcircuit breakerdegradation
0 likes · 20 min read
Handling Interface‑Level Failures: Degradation, Circuit Breaking, Rate Limiting, and Queuing
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Aug 1, 2024 · Backend Development

Backend API Design Best Practices

This article outlines comprehensive backend API design guidelines, covering parameter validation, extensibility, idempotency, logging, thread‑pool isolation, third‑party error handling, asynchronous processing, parallel queries, rate limiting, security, lock granularity, and strategies to avoid long‑running transactions.

AsynchronousBackendIdempotency
0 likes · 11 min read
Backend API Design Best Practices
Top Architecture Tech Stack
Top Architecture Tech Stack
Jul 16, 2024 · Cloud Native

Designing Fault‑Tolerant Microservices Architecture: Patterns and Practices

The article explains how to build reliable microservices by isolating failures, applying graceful degradation, change‑management, health checks, self‑healing, fallback caching, retry strategies, rate limiting, fast‑fail principles, circuit breakers, and failure‑testing to ensure high availability in distributed cloud‑native systems.

Cloud NativeMicroservicesOperations
0 likes · 14 min read
Designing Fault‑Tolerant Microservices Architecture: Patterns and Practices
Yum! Tech Team
Yum! Tech Team
Jul 3, 2024 · Backend Development

Implementing Sentinel for Traffic Protection and Rate Limiting in a Large-Scale Restaurant Digital Platform

This article details how a large restaurant chain leveraged the open‑source Sentinel framework to implement comprehensive traffic protection, rate limiting, and circuit‑breaking across millions of daily orders, describing challenges, design choices, high‑availability rule distribution, monitoring, user‑experience considerations, and providing Java code examples for integration.

BackendJavaObservability
0 likes · 11 min read
Implementing Sentinel for Traffic Protection and Rate Limiting in a Large-Scale Restaurant Digital Platform
Java Tech Enthusiast
Java Tech Enthusiast
Jul 2, 2024 · Databases

Practical Redis Use Cases and Code Examples

This guide walks backend developers through twenty real‑world Redis use cases—from basic caching, lotteries, and like/collect features to ranking, PV/UV counting, Bloom filters, sign‑in, geo‑search, rate limiting, ID generation, distributed locks, messaging, session sharing, and more—providing Spring Boot code samples, limitations, and best‑practice advice.

Backend DevelopmentData StructuresDistributed Systems
0 likes · 55 min read
Practical Redis Use Cases and Code Examples
Top Architect
Top Architect
Jun 26, 2024 · Backend Development

High Availability Traffic Governance: Circuit Breakers, Isolation, Retries, Timeouts, and Rate Limiting

This article explains how to achieve high‑availability in microservice systems through traffic governance techniques such as circuit breakers, various isolation strategies, retry mechanisms, timeout controls, and rate‑limiting, illustrating each concept with examples, formulas, and pseudo‑code.

RetryTimeoutcircuit breaker
0 likes · 31 min read
High Availability Traffic Governance: Circuit Breakers, Isolation, Retries, Timeouts, and Rate Limiting
Architect
Architect
Jun 24, 2024 · Operations

Traffic Governance and High‑Availability Strategies for Microservices

This article explains how traffic governance—including circuit breaking, isolation, retry mechanisms, degradation, timeout control, and rate limiting—helps microservice systems achieve the three‑high goals of high performance, high availability, and easy scalability, using concrete formulas, algorithms, and practical examples.

MicroservicesRetryTimeout
0 likes · 29 min read
Traffic Governance and High‑Availability Strategies for Microservices
Sanyou's Java Diary
Sanyou's Java Diary
Jun 20, 2024 · Backend Development

Mastering Traffic Governance: From Circuit Breakers to Rate Limiting for High‑Availability Systems

This article explains how traffic governance—through circuit breaking, isolation, retry strategies, degradation, timeout handling, and rate limiting—keeps distributed systems highly available, performant, and scalable, using concrete examples, formulas, and best‑practice patterns for modern microservice architectures.

MicroservicesRetrySystem Design
0 likes · 30 min read
Mastering Traffic Governance: From Circuit Breakers to Rate Limiting for High‑Availability Systems
Wukong Talks Architecture
Wukong Talks Architecture
Jun 19, 2024 · Backend Development

Design and Optimization of a High‑Concurrency Lottery System

This article details how a large‑scale lottery service was architected and tuned for extreme traffic spikes by applying server‑side rate limiting, application‑level throttling, behavior‑based filtering, caching strategies, database optimizations, and hardware upgrades, resulting in a ten‑fold performance improvement.

Backend ArchitectureDatabase Tuninghigh concurrency
0 likes · 12 min read
Design and Optimization of a High‑Concurrency Lottery System
macrozheng
macrozheng
May 30, 2024 · Backend Development

18 Essential API Design Rules Every Backend Developer Should Follow

Learn 18 essential API design rules covering signature, encryption, IP whitelisting, rate limiting, parameter validation, unified responses, exception handling, logging, idempotency, pagination, stress testing, async processing, data masking, documentation, request methods, headers, batch operations, and single‑responsibility principles for robust backend services.

Securityapi-designrate limiting
0 likes · 17 min read
18 Essential API Design Rules Every Backend Developer Should Follow
Lobster Programming
Lobster Programming
May 27, 2024 · Backend Development

Mastering Rate Limiting: 5 Algorithms to Prevent Service Avalanches

This article explains why rate limiting is essential in high‑traffic microservice architectures, illustrates the avalanche effect, and introduces five practical algorithms—including counter, sliding window, leaky bucket, token bucket, and Redis‑based implementations—complete with code examples and usage scenarios.

Backendrate limitingtraffic control
0 likes · 7 min read
Mastering Rate Limiting: 5 Algorithms to Prevent Service Avalanches
21CTO
21CTO
May 25, 2024 · Backend Development

Mastering E‑Commerce API Design: Best Practices, Protocols, and Versioning

This article walks developers through the fundamentals of designing robust e‑commerce APIs, covering CRUD operations, protocol choices such as REST, GraphQL and gRPC, versioning strategies, rate limiting, CORS, and best practices for request idempotency and backward compatibility.

CRUDGraphQLVersioning
0 likes · 8 min read
Mastering E‑Commerce API Design: Best Practices, Protocols, and Versioning
Su San Talks Tech
Su San Talks Tech
May 24, 2024 · Backend Development

18 Must‑Know API Design Rules for Secure and Scalable Backends

This article presents 18 essential API design rules covering signature verification, encryption, IP whitelisting, rate limiting, parameter validation, unified responses and error handling, logging, idempotency, request size limits, stress testing, asynchronous processing, data masking, comprehensive documentation, proper HTTP methods, header usage, batch operations, and single‑responsibility principles.

Idempotencyapi-designrate limiting
0 likes · 17 min read
18 Must‑Know API Design Rules for Secure and Scalable Backends
Architect
Architect
May 10, 2024 · Backend Development

Rate Limiting Algorithms: Fixed Window, Sliding Window, Leaky Bucket, Token Bucket, and Distributed Rate Limiting

This article explains the importance of rate limiting in microservice architectures, introduces four basic algorithms—fixed window, sliding window, leaky bucket, and token bucket—compares their advantages and disadvantages, and presents both single-machine and distributed implementations with Go code examples.

Distributed SystemsGolangMicroservices
0 likes · 29 min read
Rate Limiting Algorithms: Fixed Window, Sliding Window, Leaky Bucket, Token Bucket, and Distributed Rate Limiting
macrozheng
macrozheng
May 7, 2024 · Information Security

10 Proven Strategies to Secure Your API Data

Ensuring API data security involves encrypting transmission, using signatures, token authentication, timestamps, nonces, rate limiting, black/white lists, data masking, and parameter validation, with detailed explanations of symmetric/asymmetric encryption, HTTPS, RSA, MD5, and practical implementation steps for robust protection.

API Securityencryptionrate limiting
0 likes · 13 min read
10 Proven Strategies to Secure Your API Data
Architect
Architect
Apr 27, 2024 · Information Security

How to Stop Malicious API Calls: 8 Practical Defense Strategies

This article walks through eight concrete techniques—firewall rules, captchas, authentication checks, IP whitelists, HTTPS encryption, rate limiting, monitoring, and an API gateway—to prevent abusive requests from draining resources or compromising critical services.

API SecurityAuthenticationCaptcha
0 likes · 11 min read
How to Stop Malicious API Calls: 8 Practical Defense Strategies
Architect
Architect
Apr 22, 2024 · Operations

Flow Governance and High‑Availability Strategies for Microservice Systems

This article explains how to achieve high availability in microservice architectures by applying flow governance techniques such as circuit breaking, isolation, retry policies, degradation, timeout management, and rate limiting, while detailing key metrics like MTBF and MTTR and providing practical implementation guidance.

Flow ControlMicroservicesRetry
0 likes · 30 min read
Flow Governance and High‑Availability Strategies for Microservice Systems
Architect
Architect
Apr 4, 2024 · Backend Development

Mastering High Availability: 9 Essential Design Techniques for Scalable Systems

The article walks through nine practical techniques—system splitting, decoupling, asynchronous processing, retry, compensation, backup, multi‑active deployment, rate limiting, circuit breaking, and degradation—explaining why each is needed, how they are implemented in real‑world microservice architectures, and what trade‑offs to consider.

Distributed SystemsMicroservicesSystem Design
0 likes · 13 min read
Mastering High Availability: 9 Essential Design Techniques for Scalable Systems
Zhuanzhuan Tech
Zhuanzhuan Tech
Apr 3, 2024 · Backend Development

Design and Implementation of an Elasticsearch Data Synchronization Service (ECP) for Large‑Scale Order Data

This article describes the challenges and technical solutions for synchronizing billions of order records from a relational database to Elasticsearch, including multi‑source data reading, dynamic rate limiting, retry strategies, SPI‑based service integration, environment isolation, health‑checking, smooth migration, and structured logging, all implemented in a backend service called ECP.

JavaSPIbackend service
0 likes · 21 min read
Design and Implementation of an Elasticsearch Data Synchronization Service (ECP) for Large‑Scale Order Data
FunTester
FunTester
Mar 18, 2024 · Backend Development

Implementing Dynamic Rate Limiting with Caffeine Cache in Java

This article explains how to replace a simple Map‑based rate limiter with a Caffeine cache‑backed solution that supports dynamic TPS configuration, outlines the data structures, limit‑checking logic, and provides full Java/Groovy code examples along with a test script and its output.

BackendCaffeine CacheJava
0 likes · 6 min read
Implementing Dynamic Rate Limiting with Caffeine Cache in Java
Architect
Architect
Mar 13, 2024 · Information Security

11 Essential Practices to Secure Your APIs – From Validation to Risk Control

This article outlines eleven practical techniques for protecting API endpoints, covering parameter validation, unified response wrapping, XSS escaping, captcha integration, rate limiting, IP whitelisting, sensitive‑word checks, HTTPS adoption, data encryption, and comprehensive risk control measures, each illustrated with concrete code snippets and step‑by‑step workflows.

API SecurityHTTPSParameter Validation
0 likes · 18 min read
11 Essential Practices to Secure Your APIs – From Validation to Risk Control
IT Services Circle
IT Services Circle
Mar 11, 2024 · Backend Development

Cache Penetration, Cache Breakdown, and Cache Avalanche: Causes and Solutions

This article explains cache penetration, cache breakdown, and cache avalanche, describing their causes, differences, and practical mitigation strategies such as parameter validation, caching null keys, Bloom filters, rate limiting, hot‑key pre‑warming, and distributed locking, with Java code examples.

Cachebloom-filtercache-avalanche
0 likes · 10 min read
Cache Penetration, Cache Breakdown, and Cache Avalanche: Causes and Solutions
Sanyou's Java Diary
Sanyou's Java Diary
Mar 7, 2024 · Backend Development

Mastering Rate Limiting: Algorithms, Pros, Cons, and Distributed Solutions

This article explores why rate limiting is essential for high‑concurrency services, introduces four core algorithms with Go implementations, compares their strengths and weaknesses, and presents practical distributed limiting strategies using Redis, load balancers, and coordination services.

GolangMicroservicesalgorithm
0 likes · 30 min read
Mastering Rate Limiting: Algorithms, Pros, Cons, and Distributed Solutions
FunTester
FunTester
Mar 4, 2024 · Backend Development

How to Build a Simple Java Rate Limiter from Scratch

This article explains the concept and benefits of rate limiting, reviews popular Java libraries, and walks through a custom implementation using maps, locks, and atomic counters, complete with full source code and a test script demonstrating a 2‑requests‑per‑2‑seconds policy.

Backend DevelopmentJavaToken Bucket
0 likes · 9 min read
How to Build a Simple Java Rate Limiter from Scratch
FunTester
FunTester
Mar 4, 2024 · Backend Development

Implementing Custom Rate Limiting in Java with ReentrantLock and AtomicInteger

This article explains the purpose and benefits of rate limiting, reviews popular Java rate‑limiting libraries, and provides a step‑by‑step guide with complete source code for building a simple, thread‑safe custom rate limiter using maps, ReentrantLock, and AtomicInteger.

JavaToken Bucketconcurrency
0 likes · 9 min read
Implementing Custom Rate Limiting in Java with ReentrantLock and AtomicInteger
Architect
Architect
Mar 2, 2024 · Backend Development

Decoupling Business Messaging: A Deep Dive into the X‑Pigeon Platform Architecture

This article analyzes the challenges of tightly coupled message‑business code, duplicated service implementations, and intermittent message loss, then details the design of the X‑Pigeon centralized messaging platform—including its three‑element model, lifecycle states, rate‑limiting strategies, and template system—to achieve scalable, reliable communication across microservices.

BackendCloud NativeMessaging
0 likes · 11 min read
Decoupling Business Messaging: A Deep Dive into the X‑Pigeon Platform Architecture
Selected Java Interview Questions
Selected Java Interview Questions
Feb 29, 2024 · Information Security

How to Prevent Malicious API Abuse: Firewalls, Captchas, Authentication, IP Whitelists, Encryption, Rate Limiting, Monitoring, and Gateways

This article explains a comprehensive set of techniques—including firewalls, captchas, authentication checks, IP whitelists, data encryption, rate limiting, monitoring, and API gateways—to protect interfaces from malicious abuse and ensure secure, reliable service operation.

API SecurityAuthenticationCaptcha
0 likes · 12 min read
How to Prevent Malicious API Abuse: Firewalls, Captchas, Authentication, IP Whitelists, Encryption, Rate Limiting, Monitoring, and Gateways
Java Architect Essentials
Java Architect Essentials
Feb 28, 2024 · Backend Development

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

This article explains why a custom business risk‑control (rate‑limiting) component is needed for AI‑intensive services, compares open‑source solutions, and provides a complete backend implementation using Redis+Lua scripts, Kotlin code, Spring AOP annotations, and real‑time adjustable rules.

BackendKotlinLua
0 likes · 10 min read
Design and Implementation of a Business Rate‑Limiting Component Using Redis Lua Scripts and Custom Annotations in Kotlin
Tencent Cloud Developer
Tencent Cloud Developer
Feb 28, 2024 · Backend Development

Comprehensive Guide to Rate Limiting Algorithms and Distributed Rate Limiting Solutions

This guide explains why rate limiting is essential for micro‑service stability, outlines six design principles, details four classic algorithms—fixed window, sliding window, leaky bucket, and token bucket—and compares centralized Redis, load‑balancer cache, and coordination‑service distributed solutions.

Distributed SystemsGolangMicroservices
0 likes · 30 min read
Comprehensive Guide to Rate Limiting Algorithms and Distributed Rate Limiting Solutions
macrozheng
macrozheng
Feb 20, 2024 · Databases

10 Real-World Redis Use Cases Every Backend Engineer Should Know

Discover ten practical Redis scenarios—from counting page visits and caching category trees to implementing distributed locks, leaderboards, rate limiting, bitmap analytics, message queues, and global ID generation—each illustrated with concise code snippets and best‑practice tips for robust backend development.

BitmapMessage Queuecaching
0 likes · 11 min read
10 Real-World Redis Use Cases Every Backend Engineer Should Know
Su San Talks Tech
Su San Talks Tech
Feb 16, 2024 · Information Security

How to Prevent Malicious API Abuse: 8 Practical Security Measures

This article outlines eight effective techniques—including firewalls, captchas, authentication checks, IP whitelists, data encryption, rate limiting, monitoring, and API gateways—to protect interfaces from malicious traffic and costly abuse while balancing user experience.

API SecurityCaptchaencryption
0 likes · 9 min read
How to Prevent Malicious API Abuse: 8 Practical Security Measures