BestHub
Sign in
Tagged articles

rate limiting

656 articles · Page 6 of 7
Programmer DD
Programmer DD
Jun 4, 2021 · Operations

Mastering Fault‑Tolerant Microservices: Patterns for Reliable Distributed Systems

This article explores essential patterns and techniques—such as graceful degradation, change management, health checks, failover caching, retry logic, rate limiting, circuit breakers, and chaos testing—to build highly available microservice architectures that can withstand network, hardware, and application failures.

Circuit Breakercloud-nativefault tolerance
0 likes · 15 min read
Mastering Fault‑Tolerant Microservices: Patterns for Reliable Distributed Systems
Ops Development Stories
Ops Development Stories
May 25, 2021 · Backend Development

Master Rate Limiting: Counter, Sliding Window, Leaky & Token Bucket Algorithms

This article introduces common rate‑limiting algorithms—counter, sliding‑window, leaky bucket, and token bucket—explains their principles, compares their advantages and drawbacks, and provides Java code examples, including how Sentinel 1.8.0 implements each technique using structures such as LeapArray and WarmUpController.

JavaSentinelalgorithm
0 likes · 17 min read
Master Rate Limiting: Counter, Sliding Window, Leaky & Token Bucket Algorithms
dbaplus Community
dbaplus Community
May 20, 2021 · Backend Development

Mastering API Gateways with Spring Cloud Gateway: Routing, Rate Limiting, and Dynamic Configuration

This article explains the purpose and principles of API gateways in microservice architectures, introduces Spring Cloud Gateway's core concepts and workflow, and provides step‑by‑step examples for basic routing, weighted routing, rate limiting, and dynamic route management with complete code snippets.

API GatewaySpring Cloud Gatewaydynamic-configuration
0 likes · 19 min read
Mastering API Gateways with Spring Cloud Gateway: Routing, Rate Limiting, and Dynamic Configuration
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 20, 2021 · Backend Development

Designing a High‑Concurrency Flash‑Sale (秒杀) System: From Naïve Implementation to Optimized Solutions

This article walks through the design of a flash‑sale system, starting with a simple SpringBoot‑MyBatis implementation, then addressing overselling with pessimistic and optimistic locks, applying rate‑limiting algorithms, time‑window controls, interface hiding, frequency limits, and a suite of production‑grade optimizations such as CDN, Nginx load balancing, Redis caching, message queues, and short‑URL handling.

Optimistic LockPessimistic LockRedis
0 likes · 14 min read
Designing a High‑Concurrency Flash‑Sale (秒杀) System: From Naïve Implementation to Optimized Solutions
360 Smart Cloud
360 Smart Cloud
Apr 30, 2021 · Backend Development

Understanding Rate Limiting: Concepts, Architectures, Algorithms, and a Redis‑Lua Token Bucket Implementation

This article explains what rate limiting is, why it is needed, the typical actions taken when limits are reached, compares single‑node and distributed architectures, reviews four classic limiting algorithms, and provides a practical Redis‑Lua token‑bucket implementation with code examples.

Backendalgorithmrate limiting
0 likes · 14 min read
Understanding Rate Limiting: Concepts, Architectures, Algorithms, and a Redis‑Lua Token Bucket Implementation
Top Architect
Top Architect
Apr 26, 2021 · Backend Development

Comprehensive Guide to Spring Cloud Zuul Gateway: Functions, Configuration, Filters, Fault Tolerance, Rate Limiting, and Performance Tuning

This article provides an in‑depth tutorial on Spring Cloud Zuul as a microservice gateway, covering its purpose, when to use it, routing configurations, starter dependencies, global variables, filter implementation, Hystrix‑based fault tolerance, rate‑limit protection, and detailed timeout and retry tuning for optimal performance.

API GatewaySpring CloudZuul
0 likes · 18 min read
Comprehensive Guide to Spring Cloud Zuul Gateway: Functions, Configuration, Filters, Fault Tolerance, Rate Limiting, and Performance Tuning
Wukong Talks Architecture
Wukong Talks Architecture
Apr 15, 2021 · Backend Development

Flash Sale System Design and Optimization

This article outlines common flash‑sale scenarios, identifies key concerns such as overselling, anti‑fraud, and user experience, and progressively presents system designs from a basic SpringBoot‑MyBatis implementation to pessimistic and optimistic locking, rate‑limiting, token‑bucket algorithms, and various performance and security optimizations.

flash salerate limiting
0 likes · 15 min read
Flash Sale System Design and Optimization
Tencent Cloud Developer
Tencent Cloud Developer
Mar 31, 2021 · Backend Development

Design and Implementation of a Distributed Timer Service at Tencent

The article details Tencent’s design and implementation of a distributed timer service—using a multi‑level time‑wheel stored in a KV system, a scheduler daemon, broker, and notifier—to support reliable, low‑latency delayed tasks such as order closure and SMS activation, while addressing isolation, rate limiting, disaster recovery, and delivery guarantees.

KV storagedistributed timerhigh availability
0 likes · 15 min read
Design and Implementation of a Distributed Timer Service at Tencent
New Oriental Technology
New Oriental Technology
Mar 29, 2021 · Backend Development

Sentinel Flow Control Component: Quick Start, Rules, Annotations, and Internal Mechanisms

This article introduces Alibaba Sentinel, an open‑source flow‑control framework for distributed services, covering Maven integration, dashboard setup, configuration of flow, degrade and hotspot rules, the @SentinelResource annotation, XCloud Sentinel starter usage, and a deep dive into its slot‑chain architecture and sliding‑window algorithm.

Circuit BreakerFlow ControlHotSpot
0 likes · 12 min read
Sentinel Flow Control Component: Quick Start, Rules, Annotations, and Internal Mechanisms
Efficient Ops
Efficient Ops
Mar 25, 2021 · Backend Development

How to Build a Robust Flash‑Sale System that Handles Millions of Requests

This article explores the challenges of designing a flash‑sale (秒杀) system—such as overselling, high concurrency, request flooding, URL protection, and database bottlenecks—and presents a complete backend architecture using Redis, Nginx, rate‑limiting, asynchronous order processing, and service degradation to achieve a stable, high‑throughput solution.

Redisbackend architectureflash sale
0 likes · 14 min read
How to Build a Robust Flash‑Sale System that Handles Millions of Requests
Selected Java Interview Questions
Selected Java Interview Questions
Mar 20, 2021 · Backend Development

Interview Reflections: HTTP GET Issue, Rate‑Limiting, and ThreadPool Mechanics

The article shares three interview scenarios—a puzzling HTTP GET failure, a rate‑limiting challenge solved with token‑bucket logic, and a deep dive into Java ThreadPoolExecutor behavior—each followed by personal insights on problem‑solving, algorithm application, and understanding underlying principles.

HTTPThread Poolrate limiting
0 likes · 10 min read
Interview Reflections: HTTP GET Issue, Rate‑Limiting, and ThreadPool Mechanics
Senior Brother's Insights
Senior Brother's Insights
Mar 14, 2021 · Backend Development

Inside Zhaozhuan’s Service Governance: Architecture, Registration, and Monitoring

Facing the complexities of microservice adoption, Zhaozhuan’s service governance platform integrates service registration, discovery, configuration, monitoring, authentication, and rate limiting via an SDK‑driven architecture, illustrating AP‑style registration, node grouping, gray‑release discovery, real‑time metrics aggregation, and method‑level access control.

AuthenticationService Governancerate limiting
0 likes · 14 min read
Inside Zhaozhuan’s Service Governance: Architecture, Registration, and Monitoring
Zhuanzhuan Tech
Zhuanzhuan Tech
Mar 10, 2021 · Backend Development

Service Governance Architecture and Practices at Zhuanzhuan

This article explains how Zhuanzhuan’s service management platform implements comprehensive service governance—including registration, discovery, configuration, monitoring, authentication, rate limiting, and alerting—to support micro‑service architectures and improve reliability, scalability, and operational efficiency.

configuration managementmicroservicesmonitoring
0 likes · 10 min read
Service Governance Architecture and Practices at Zhuanzhuan
php Courses
php Courses
Mar 1, 2021 · Backend Development

Implementing API Rate Limiting with Redis in PHP

This article explains how to implement API request frequency control in PHP using Redis, detailing a function that tracks per‑user request counts within a configurable time window, removes outdated entries, and returns appropriate responses when the limit is exceeded.

APIBackendPHP
0 likes · 3 min read
Implementing API Rate Limiting with Redis in PHP
Top Architect
Top Architect
Feb 14, 2021 · Backend Development

An Introduction to Rate Limiting: Concepts, Classifications, and Go Implementation

This article explains the fundamentals of rate limiting, its importance for high‑availability services, various classification dimensions, common algorithms such as fixed‑window, sliding‑window, leaky‑bucket and token‑bucket, and demonstrates practical usage with Go's golang.org/x/time/rate library including code examples and configuration tips.

algorithmdistributed systemsgolang
0 likes · 26 min read
An Introduction to Rate Limiting: Concepts, Classifications, and Go Implementation
Alibaba Terminal Technology
Alibaba Terminal Technology
Feb 8, 2021 · Cloud Computing

How Alibaba’s Serverless FC Powers Double‑12 Traffic Peaks Without Ops

This article explains how Alibaba Cloud Function Compute (FC) was integrated into internal services to support the Double‑12 promotion, detailing the business requirements, network challenges, hybrid‑cloud solutions, container types, auto‑scaling, rate‑limiting, and the serverless platform’s deployment and gray‑release mechanisms.

Function ComputeServerlesshybrid cloud
0 likes · 15 min read
How Alibaba’s Serverless FC Powers Double‑12 Traffic Peaks Without Ops
Code Ape Tech Column
Code Ape Tech Column
Jan 27, 2021 · Backend Development

An Introduction to Rate Limiting: Concepts, Classifications, Algorithms, and Go Implementation

This article introduces rate limiting, explains its purpose and classifications, compares fixed and sliding windows, describes common algorithms such as token bucket, leaky bucket, and counter, and provides detailed Go code examples using the golang.org/x/time/rate library for practical implementation.

golangleaky-bucketrate limiting
0 likes · 25 min read
An Introduction to Rate Limiting: Concepts, Classifications, Algorithms, and Go Implementation
21CTO
21CTO
Jan 16, 2021 · Backend Development

How to Build a Go‑Based Log Collection System with etcd, Context, and Kafka

This article walks through designing and implementing a Go log‑collection agent that uses etcd for configuration storage, context for timeout and metadata handling, and Kafka for message consumption, complete with code examples, setup instructions, and a rate‑limiting utility.

ContextGoKafka
0 likes · 16 min read
How to Build a Go‑Based Log Collection System with etcd, Context, and Kafka
Top Architect
Top Architect
Jan 15, 2021 · Backend Development

Design and Technical Solutions for a High‑Concurrency Flash Sale System

This article examines the challenges of building a flash‑sale (秒杀) system—such as overselling, massive concurrent requests, URL exposure, and database bottlenecks—and presents a comprehensive backend architecture that combines separate databases, dynamic URLs, static pages, Redis clustering, Nginx load balancing, SQL optimization, rate‑limiting, asynchronous order processing, and service degradation techniques.

JavaNginxRedis
0 likes · 13 min read
Design and Technical Solutions for a High‑Concurrency Flash Sale System
21CTO
21CTO
Jan 9, 2021 · Backend Development

How to Build a Robust Flash‑Sale System that Handles Millions of Requests

This article explores the key challenges of designing a flash‑sale (秒杀) system—such as overselling, high concurrency, request flooding, and database strain—and presents a comprehensive backend architecture with database design, dynamic URLs, caching, rate limiting, async ordering, and service degradation techniques.

Redisasynchronous-processingbackend architecture
0 likes · 13 min read
How to Build a Robust Flash‑Sale System that Handles Millions of Requests
dbaplus Community
dbaplus Community
Jan 7, 2021 · Information Security

Understanding CC Attacks and Slow DDoS: Mechanisms, Tools, and Defenses

This article explains how CC (Challenge Collapsar) attacks and their slow‑request variants overwhelm web services, describes the underlying botnet concepts, shows practical attack commands with tools like slowhttptest, and outlines multiple mitigation strategies such as rate limiting, IP hiding, high‑protection IP services, and static page optimization.

DDoSSlow Attackbotnet
0 likes · 18 min read
Understanding CC Attacks and Slow DDoS: Mechanisms, Tools, and Defenses
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Dec 25, 2020 · Backend Development

Implementing Message Queues with Redis: Lists, Zsets, Pub/Sub, and Streams

This article explains how Redis can be used to build lightweight, high‑performance message queues by leveraging lists for simple queues, sorted sets for delayed delivery, Pub/Sub for multicast, and the Stream data structure for durable, scalable messaging, while also covering practical PHP implementations, acknowledgment, retry, graceful restart, and rate‑limiting techniques.

PHPRedisStream
0 likes · 19 min read
Implementing Message Queues with Redis: Lists, Zsets, Pub/Sub, and Streams
Python Crawling & Data Mining
Python Crawling & Data Mining
Dec 25, 2020 · Backend Development

Mastering Python Rate Limiting: From ratelimiter to SlowAPI

This article explains how to control request frequency in Python using the ratelimiter library for synchronous and asynchronous code, and introduces SlowAPI as a flexible solution for FastAPI and Flask, helping backend developers reduce server load and protect APIs from abuse.

FastAPIPythonasyncio
0 likes · 6 min read
Mastering Python Rate Limiting: From ratelimiter to SlowAPI
Java Backend Technology
Java Backend Technology
Dec 19, 2020 · Databases

Deep Dive into Redis: Data Structures, Persistence, and High Availability

This comprehensive guide explores Redis internals, covering its core data types and their low‑level implementations, persistence mechanisms like RDB and AOF, performance tricks, common pitfalls such as cache avalanche and split‑brain, distributed locking strategies, expiration and eviction policies, high‑availability architectures, and rate‑limiting techniques.

PersistenceRedishigh availability
0 likes · 35 min read
Deep Dive into Redis: Data Structures, Persistence, and High Availability
Programmer DD
Programmer DD
Dec 13, 2020 · Backend Development

Master Sliding Window Rate Limiting in Java with Simple Code

This article introduces a straightforward Java implementation of a sliding‑window rate‑limiting algorithm for single‑machine use, explains its core logic, demonstrates its behavior with sample output, and visualizes the step‑by‑step process of how timestamps are managed within the window.

Javaalgorithmrate limiting
0 likes · 8 min read
Master Sliding Window Rate Limiting in Java with Simple Code
vivo Internet Technology
vivo Internet Technology
Dec 2, 2020 · Cloud Native

In‑Depth Analysis of Sentinel's Rate‑Limiting Mechanism

Sentinel implements rate‑limiting through a chain‑of‑responsibility where annotated methods trigger SphU.entry, creating a Context, Node, and Entry; slots such as NodeSelectorSlot, ClusterBuilderSlot, StatisticSlot, and FlowSlot update sliding‑window metrics via LeapArray and enforce QPS thresholds, throwing BlockException on violations.

Circuit BreakingJavaSentinel
0 likes · 18 min read
In‑Depth Analysis of Sentinel's Rate‑Limiting Mechanism
Laravel Tech Community
Laravel Tech Community
Nov 26, 2020 · Backend Development

Design and Technical Solutions for a High-Concurrency Flash Sale System

This article examines the challenges of building a flash‑sale (秒杀) system—such as overselling, high concurrency, request flooding, URL security, and database strain—and presents a comprehensive backend design using separate databases, Redis clustering, dynamic URLs, static pages, Nginx, rate‑limiting, asynchronous order processing, and service degradation strategies.

asynchronous-processingbackend designflash sale
0 likes · 11 min read
Design and Technical Solutions for a High-Concurrency Flash Sale System
HaoDF Tech Team
HaoDF Tech Team
Nov 17, 2020 · Backend Development

Introduction to API Gateway and Kong Implementation at Haodf

This article introduces the fundamentals of API gateways, explains why Haodf replaced Nginx with Kong, details Kong's architecture, plugins, traffic segmentation, rate‑limiting strategies, monitoring, and operational considerations for deploying Kong in a micro‑service environment.

API GatewayKongbackend development
0 likes · 16 min read
Introduction to API Gateway and Kong Implementation at Haodf
Wukong Talks Architecture
Wukong Talks Architecture
Oct 21, 2020 · Backend Development

Flash Sale (Seckill) System Architecture Explained Through a Sci‑Fi Narrative

This article uses a sci‑fi story set on the A‑731 e‑commerce planet to illustrate the core principles of flash‑sale systems, including single‑responsibility services, independent deployment, stock pre‑heating, request encryption, static‑dynamic separation, traffic shaping, rate limiting, queue‑based load smoothing, and the role of Redis, Nginx, CDN and Redisson in handling massive order spikes.

flash salerate limitingseckill
0 likes · 10 min read
Flash Sale (Seckill) System Architecture Explained Through a Sci‑Fi Narrative
Top Architect
Top Architect
Oct 21, 2020 · Backend Development

Design and Technical Solutions for a High‑Concurrency Flash Sale System

This article examines the challenges of building a flash‑sale (秒杀) system—such as overselling, high concurrency, request throttling, and database strain—and presents a comprehensive backend design using separate databases, dynamic URLs, static pages, Redis clustering, Nginx, token‑bucket rate limiting, asynchronous order processing, and service degradation strategies.

Redisasynchronous-processingbackend design
0 likes · 15 min read
Design and Technical Solutions for a High‑Concurrency Flash Sale System
Architects' Tech Alliance
Architects' Tech Alliance
Oct 12, 2020 · Operations

Designing Resilient Microservices: Patterns for Fault Tolerance and Failure Management

This article examines the inherent risks of microservice architectures and presents practical patterns—such as graceful degradation, change management, health checks, self‑healing, fallback caching, retries, rate limiting, bulkheads, and circuit breakers—to build highly available, fault‑tolerant services.

Circuit BreakerResiliencebulkhead
0 likes · 15 min read
Designing Resilient Microservices: Patterns for Fault Tolerance and Failure Management
Java Architect Essentials
Java Architect Essentials
Oct 5, 2020 · Backend Development

Implementing Distributed Rate Limiting in Spring Cloud Gateway with Token Bucket and Lua Script

This article explains how Spring Cloud Gateway uses a token‑bucket algorithm backed by Redis and a Lua script to perform distributed rate limiting, reviews common limiting algorithms, provides detailed Java and Lua code examples, and analyzes each step of the implementation for high‑concurrency systems.

LuaSpring Cloud Gatewaydistributed systems
0 likes · 7 min read
Implementing Distributed Rate Limiting in Spring Cloud Gateway with Token Bucket and Lua Script
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 22, 2020 · Operations

How to Build Highly Available, Scalable, and Resilient Systems

This article explains the principles and practical techniques for achieving high availability, scalability, isolation, decoupling, rate limiting, degradation, and circuit breaking in modern software systems, providing concrete examples, algorithms, and deployment patterns to improve reliability and performance.

Circuit BreakerSystem Designhigh availability
0 likes · 18 min read
How to Build Highly Available, Scalable, and Resilient Systems
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 20, 2020 · Backend Development

How to Build a Robust Flash Sale System: Architecture, Challenges, and Code Solutions

This article examines the critical issues of overselling, high concurrency, request throttling, and database design in flash‑sale systems, then outlines a comprehensive backend architecture with Redis clustering, Nginx load balancing, dynamic URLs, rate‑limiting, asynchronous order processing, and Java code examples to achieve a resilient high‑throughput solution.

Javabackend architectureflash sale
0 likes · 13 min read
How to Build a Robust Flash Sale System: Architecture, Challenges, and Code Solutions
Aikesheng Open Source Community
Aikesheng Open Source Community
Sep 17, 2020 · Backend Development

Understanding Rate Limiting: Leaky Bucket and Token Bucket Algorithms with a Python Example

This article explains the principles of leaky‑bucket and token‑bucket rate‑limiting algorithms, compares their behavior in high‑concurrency e‑commerce scenarios, and provides a complete Python implementation to illustrate how token‑bucket can handle burst traffic while maintaining system stability.

Pythonhigh concurrencyleaky-bucket
0 likes · 7 min read
Understanding Rate Limiting: Leaky Bucket and Token Bucket Algorithms with a Python Example
Liangxu Linux
Liangxu Linux
Aug 6, 2020 · Backend Development

Mastering Nginx Rate Limiting: From Basics to Advanced Configurations

This guide explains how Nginx implements rate limiting using the leaky‑bucket algorithm, walks through basic and advanced configurations—including limit_req_zone, limit_req, burst, nodelay, whitelisting, multiple limits, logging, and custom status codes—while providing concrete code examples and practical tips.

Configurationleaky-bucketlimit_req
0 likes · 14 min read
Mastering Nginx Rate Limiting: From Basics to Advanced Configurations
IT Architects Alliance
IT Architects Alliance
Aug 4, 2020 · Backend Development

Designing Effective Rate Limiting and Circuit Breaking for Microservice APIs

This article examines the motivations, resource granularity, rule definition, and calculation logic behind implementing rate limiting and circuit breaking in microservice architectures, using examples like Sentinel and Hystrix, and outlines a step-by-step design for integrating these controls with API gateways.

API GatewayCircuit BreakingHystrix
0 likes · 14 min read
Designing Effective Rate Limiting and Circuit Breaking for Microservice APIs
21CTO
21CTO
Jul 22, 2020 · Information Security

Why RESTful API Security Matters and How to Protect Your APIs

This article explains the critical importance of securing RESTful APIs—covering data protection, DoS risks, and business impact—and outlines practical measures such as authentication, API keys, access control, rate limiting, and input validation with code examples.

API SecurityAccess ControlAuthentication
0 likes · 8 min read
Why RESTful API Security Matters and How to Protect Your APIs
MaGe Linux Operations
MaGe Linux Operations
Jul 18, 2020 · Backend Development

Master Nginx Rate Limiting: From Basics to Advanced Configurations

This article explains Nginx rate‑limiting fundamentals and advanced configurations, covering the leaky‑bucket algorithm, basic directives, burst and nodelay handling, whitelisting with geo/map, multiple limit rules, logging details, and custom error responses to protect servers and mitigate attacks.

ConfigurationNginxrate limiting
0 likes · 11 min read
Master Nginx Rate Limiting: From Basics to Advanced Configurations
Selected Java Interview Questions
Selected Java Interview Questions
Jun 28, 2020 · Backend Development

Rate Limiting Strategies and Guava RateLimiter for High Concurrency Traffic

This article explains the concept of high traffic, compares common mitigation techniques such as caching, degradation and rate limiting, and then details four classic rate‑limiting algorithms—counter, sliding window, leaky bucket and token bucket—followed by a practical Guava RateLimiter example and a brief note on distributed scenarios.

Guavadistributed systemshigh concurrency
0 likes · 7 min read
Rate Limiting Strategies and Guava RateLimiter for High Concurrency Traffic
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 24, 2020 · Backend Development

Choosing the Right Rate‑Limiting Algorithm: Simple Window, Sliding Window, Leaky Bucket, Token Bucket & Sliding Log

This article explains the purpose of flow control, compares various rate‑limiting algorithms—including simple window, sliding window, leaky bucket, token bucket, and sliding log—provides Java interface definitions and code examples, discusses their complexity, precision, smoothness, and suitability for single‑machine and distributed scenarios, and offers practical deployment tips using Sentinel, Nginx, Guava, Tair, and Redis.

JavaRedisalgorithm
0 likes · 31 min read
Choosing the Right Rate‑Limiting Algorithm: Simple Window, Sliding Window, Leaky Bucket, Token Bucket & Sliding Log
37 Interactive Technology Team
37 Interactive Technology Team
Jun 12, 2020 · Cloud Native

Implementing Dynamic Rate Limiting with the APISIX API Gateway

This tutorial shows how to use the open‑source APISIX API gateway—built on OpenResty and etcd—to create a dynamic rate‑limiting plugin in Lua, configure route matching with a radix tree, and demonstrate the feature with a test endpoint that enforces one request per second and returns HTTP 503 when exceeded.

API GatewayAPISIXDynamic Rate Limiting
0 likes · 14 min read
Implementing Dynamic Rate Limiting with the APISIX API Gateway
Beike Product & Technology
Beike Product & Technology
Jun 5, 2020 · Cloud Native

Fundamentals of Microservice Architecture: Service Splitting, Registration, Load Balancing, Rate Limiting, and Circuit Breaking

This article provides a comprehensive introduction to microservice architecture, covering service decomposition, registration and discovery methods, client‑driven load balancing, rate‑limiting and circuit‑breaking strategies, and the design of a self‑built application delivery platform for cloud‑native environments.

Circuit Breakingcloud-nativeload balancing
0 likes · 23 min read
Fundamentals of Microservice Architecture: Service Splitting, Registration, Load Balancing, Rate Limiting, and Circuit Breaking
FunTester
FunTester
May 27, 2020 · Backend Development

How to Simulate Fixed QPS Mock APIs with Java Semaphore and Moco

This article explains how to overcome the difficulty of isolating external service performance during load testing by creating a fixed‑QPS mock endpoint using Java's Semaphore and a custom Moco ResponseHandler, includes code samples, accuracy observations, and practical guidelines.

JavaMoCoMock API
0 likes · 5 min read
How to Simulate Fixed QPS Mock APIs with Java Semaphore and Moco
JD Retail Technology
JD Retail Technology
May 25, 2020 · Backend Development

Understanding Rate Limiting: Counter, Leaky Bucket, and Token Bucket Algorithms

This article explains the fundamentals of rate limiting for high‑concurrency systems, covering why it is needed, the conditions that trigger it, and detailed introductions to the three main algorithms—counter (fixed and sliding windows), leaky bucket, and token bucket—along with their advantages, drawbacks, and sample pseudo‑code implementations.

Backendcounter algorithmleaky-bucket
0 likes · 13 min read
Understanding Rate Limiting: Counter, Leaky Bucket, and Token Bucket Algorithms
58 Tech
58 Tech
May 22, 2020 · Backend Development

Design and Implementation of a Distributed Retry System Based on Distributed Scheduling

This article presents a comprehensive distributed retry system that leverages a distributed scheduling mechanism to ensure eventual consistency, reduce manual recovery costs, and provide flexible retry strategies, automatic recovery detection, visual management, rate limiting, and intelligent retry for backend services.

Retry Mechanismbackend developmentfault tolerance
0 likes · 13 min read
Design and Implementation of a Distributed Retry System Based on Distributed Scheduling
Java Captain
Java Captain
May 17, 2020 · Information Security

Common API Security Measures and Their Implementation

This article outlines essential API security mechanisms—including encryption, signing, timestamps, AppId authentication, rate limiting, blacklisting, and data validation—and provides practical Java implementation examples and code snippets.

AppIdblacklistencryption
0 likes · 10 min read
Common API Security Measures and Their Implementation
Java Backend Technology
Java Backend Technology
May 14, 2020 · Backend Development

How to Build a High‑Performance Flash Sale System: Architecture & Code

This article explores the key challenges of designing a flash‑sale (秒杀) backend—such as overselling, high concurrency, request throttling, and database bottlenecks—and presents a complete solution that includes database schema, dynamic URLs, static page rendering, Redis clustering, Nginx load balancing, SQL optimization, token‑bucket rate limiting, asynchronous order processing, and service degradation strategies.

backend architectureflash salehigh concurrency
0 likes · 14 min read
How to Build a High‑Performance Flash Sale System: Architecture & Code
58 Tech
58 Tech
May 13, 2020 · Information Security

Dynamic Signature Strategies for API Security: Attack and Defense Techniques

This article explores the cat‑and‑mouse battle between crawlers and API endpoints, detailing how dynamic signatures, token‑based authentication, time‑bound hashes, rate‑limiting, and code obfuscation can be used to defend against scraping while also showing how attackers can reverse‑engineer and bypass these defenses.

API SecurityToken Authenticationanti‑crawling
0 likes · 12 min read
Dynamic Signature Strategies for API Security: Attack and Defense Techniques
Top Architect
Top Architect
May 12, 2020 · Backend Development

Design and Technical Solutions for a High‑Concurrency Flash Sale System

This article explores the challenges of building a flash‑sale (秒杀) backend—such as overselling, massive concurrent requests, URL protection, and database bottlenecks—and presents a comprehensive architecture that leverages Redis clustering, token‑bucket rate limiting, static page rendering, asynchronous order processing, and service degradation techniques.

flash salehigh concurrencyrate limiting
0 likes · 12 min read
Design and Technical Solutions for a High‑Concurrency Flash Sale System
21CTO
21CTO
May 2, 2020 · Backend Development

Master Distributed Caching, Rate Limiting, Locks & Idempotency with Alibaba Tools

This article introduces Alibaba's distributed‑tools component, explaining how to configure Redis/Tair cache, implement fixed‑window rate limiting, use a high‑performance distributed lock template, and apply idempotency mechanisms with annotations and templates to ensure reliable microservice operations.

CachingSpringBootdistributed lock
0 likes · 15 min read
Master Distributed Caching, Rate Limiting, Locks & Idempotency with Alibaba Tools
Programmer DD
Programmer DD
Apr 29, 2020 · Operations

How to Keep Your Distributed System Running Even When Upstream Services Fail

The article explains why distributed systems must stay alive despite upstream or downstream failures, emphasizing rate limiting and circuit breaking as essential practices to prevent fault propagation and ensure service reliability, and it invites developers to assess their own safeguards.

Circuit Breakingdistributed systemsrate limiting
0 likes · 3 min read
How to Keep Your Distributed System Running Even When Upstream Services Fail
Tencent Cloud Developer
Tencent Cloud Developer
Apr 22, 2020 · Cloud Native

Designing High‑Quality Service Architecture Under Traffic Peaks: Load Balancing, Rate Limiting, Retries, Timeouts, and Failure Mitigation

Drawing on Google SRE principles, Bilibili’s technical director outlines a systematic, cloud‑native framework for high‑quality service architecture during traffic peaks, covering frontend and internal load balancing, distributed rate limiting, controlled retries, fail‑fast timeouts, and comprehensive failure‑mitigation strategies.

SREcloud-nativeload balancing
0 likes · 13 min read
Designing High‑Quality Service Architecture Under Traffic Peaks: Load Balancing, Rate Limiting, Retries, Timeouts, and Failure Mitigation
Programmer DD
Programmer DD
Apr 20, 2020 · Information Security

Essential API Security Measures and How to Implement Them

This article outlines key security mechanisms for public APIs—including data encryption, signing, timestamp validation, AppId authentication, rate limiting, blacklist handling, and data validation—and provides practical Java code examples for each technique.

API SecurityAuthenticationData Validation
0 likes · 11 min read
Essential API Security Measures and How to Implement Them
Architecture Digest
Architecture Digest
Apr 14, 2020 · Operations

Nginx Rate Limiting: Token‑Bucket, Leaky‑Bucket Algorithms and Configuration Examples

This article explains the principles of token‑bucket and leaky‑bucket rate‑limiting algorithms, shows how Nginx implements them with the limit_req and limit_conn modules, and provides detailed configuration examples—including burst, nodelay, and custom status codes—to control request rates and concurrent connections.

leaky-bucketlimit_connlimit_req
0 likes · 12 min read
Nginx Rate Limiting: Token‑Bucket, Leaky‑Bucket Algorithms and Configuration Examples
Xiao Lou's Tech Notes
Xiao Lou's Tech Notes
Apr 11, 2020 · Backend Development

Why Sentinel Misses Docker CPU Usage and How to Fix It

This article explains Sentinel's role in microservice rate limiting, details a Docker-specific bug where CPU utilization is incorrectly reported, clarifies the difference between CPU load and utilization, and outlines the code fix and its remaining limitations.

CPU utilizationDockerJava
0 likes · 6 min read
Why Sentinel Misses Docker CPU Usage and How to Fix It
Architecture Digest
Architecture Digest
Mar 30, 2020 · Backend Development

Design and Technical Solutions for a High‑Concurrency Flash Sale System

This article examines the challenges of building a flash‑sale (秒杀) system—such as overselling, massive concurrent requests, URL exposure, and database overload—and presents a comprehensive backend architecture that leverages Redis clustering, dynamic URLs, Nginx load balancing, rate‑limiting, asynchronous order processing, and service degradation techniques to achieve robust, scalable performance.

asynchronous-processingbackend architectureflash sale
0 likes · 12 min read
Design and Technical Solutions for a High‑Concurrency Flash Sale System
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 28, 2020 · Backend Development

Master Rate Limiting: Algorithms, Guava RateLimiter, and Java Implementation

This article introduces the background and necessity of rate limiting, explains the leaky bucket and token bucket algorithms with visual diagrams, and provides a comprehensive Java implementation using Guava's RateLimiter, custom annotations, AOP interception, and controller integration to protect high‑traffic applications.

AOPGuavarate limiting
0 likes · 10 min read
Master Rate Limiting: Algorithms, Guava RateLimiter, and Java Implementation
macrozheng
macrozheng
Mar 25, 2020 · Backend Development

Mastering Token Bucket Rate Limiting and Lock Strategies in Flash Sale Systems

This article explains how to implement token‑bucket rate limiting with Guava's RateLimiter, compare it to leaky‑bucket algorithms, and combine it with optimistic and pessimistic locking techniques to prevent overselling in high‑concurrency flash‑sale applications.

JavaOptimistic LockPessimistic Lock
0 likes · 15 min read
Mastering Token Bucket Rate Limiting and Lock Strategies in Flash Sale Systems
21CTO
21CTO
Mar 24, 2020 · Operations

Mastering System Resilience: Rate Limiting, Circuit Breaking, and Degradation

To keep systems highly available under sudden traffic spikes, developers employ three core strategies—rate limiting, circuit breaking, and service degradation—each controlling request flow, isolating failures, and gracefully reducing functionality to maintain stability, with practical examples and algorithmic approaches explained.

Circuit Breakingoperationsrate limiting
0 likes · 5 min read
Mastering System Resilience: Rate Limiting, Circuit Breaking, and Degradation
Youzan Coder
Youzan Coder
Mar 11, 2020 · Backend Development

Youzan Task Scheduling Platform (TSP): Design, Implementation, and Future Roadmap

Youzan’s Task Scheduling Platform (TSP) unifies its legacy cron and timeout systems into a modular, extensible framework that supports both timed and delayed tasks, offering per‑task rate limiting, sharding, isolation, retry policies, and a rich SDK, while its roadmap adds end‑to‑end monitoring, workflow orchestration, domain‑level clustering, transactional messaging, and dynamic task registration.

BackendTSParchitecture
0 likes · 14 min read
Youzan Task Scheduling Platform (TSP): Design, Implementation, and Future Roadmap
21CTO
21CTO
Feb 26, 2020 · Backend Development

Mastering Distributed Rate Limiting: Caching, Degradation, and Flow Control Techniques

This article explains how caching, degradation, and various rate‑limiting strategies—including semaphore‑based concurrency control, token‑bucket algorithms, Guava RateLimiter, custom annotations, Redis interceptors, and Nginx modules—protect high‑concurrency distributed systems, with practical Java code samples and configuration snippets.

Cachingdegradationdistributed systems
0 likes · 19 min read
Mastering Distributed Rate Limiting: Caching, Degradation, and Flow Control Techniques
Big Data Technology & Architecture
Big Data Technology & Architecture
Feb 22, 2020 · Backend Development

Understanding Rate Limiting: Leaky Bucket, Token Bucket, and Guava RateLimiter

The article explains the principles of traffic shaping through leaky‑bucket and token‑bucket algorithms, details how Google Guava's RateLimiter implements token‑bucket rate limiting, and provides Java code examples illustrating token generation, acquisition, and practical usage in high‑concurrency backend systems.

BackendGuavaJava
0 likes · 10 min read
Understanding Rate Limiting: Leaky Bucket, Token Bucket, and Guava RateLimiter
Qunar Tech Salon
Qunar Tech Salon
Feb 4, 2020 · Backend Development

Bilibili's Exploration and Practice of Microservice Governance

This article presents Bilibili's exploration of microservice governance, detailing the challenges of service splitting and large‑scale management, the design and evolution of its Go‑based Discovery service discovery framework, advanced load‑balancing algorithms, adaptive rate‑limiting, circuit‑breaking strategies, and future directions for resilient backend systems.

Circuit BreakingGoload balancing
0 likes · 13 min read
Bilibili's Exploration and Practice of Microservice Governance
Programmer DD
Programmer DD
Jan 7, 2020 · Backend Development

Designing Secure and User‑Friendly SMS Verification Systems

This article explores common pitfalls and best‑practice design patterns for SMS verification, covering cross‑origin issues, rate‑limiting, captcha integration, IP/Cookie restrictions, and alert mechanisms to balance security and user experience across web and mobile platforms.

SMS verificationmobilerate limiting
0 likes · 9 min read
Designing Secure and User‑Friendly SMS Verification Systems
Qunar Tech Salon
Qunar Tech Salon
Jan 7, 2020 · Operations

Comprehensive Dependency Governance for High‑Availability Backend Systems

This article outlines a systematic approach to dependency governance in high‑traffic backend services, covering service classification, rate limiting, Dubbo, HTTP, database, and message‑queue management to enhance availability, reduce failure impact, and improve overall system stability.

Dubbodependency managementoperations
0 likes · 10 min read
Comprehensive Dependency Governance for High‑Availability Backend Systems
Programmer DD
Programmer DD
Jan 1, 2020 · Backend Development

How to Build a High‑Performance Flash Sale System: Architecture & Code

This article examines the key challenges of flash‑sale (秒杀) systems—overselling, massive concurrency, URL exposure, and database coupling—and presents a complete backend design featuring dedicated databases, dynamic URLs, static pages, Redis clustering, Nginx proxy, rate‑limiting, token‑bucket control, asynchronous order queues, and service degradation strategies.

Redisbackend architectureflash sale
0 likes · 14 min read
How to Build a High‑Performance Flash Sale System: Architecture & Code
Senior Brother's Insights
Senior Brother's Insights
Dec 27, 2019 · Backend Development

How to Build a High‑Performance Flash Sale System: Architecture, Strategies & Code

This article examines the challenges of designing a robust flash‑sale backend—preventing oversell, handling massive concurrent requests, securing URLs, isolating databases, and applying techniques such as Redis clustering, Nginx load balancing, rate limiting, asynchronous processing, and service degradation—to enable stable, low‑latency sales spikes.

Nginxbackend architectureflash sale
0 likes · 15 min read
How to Build a High‑Performance Flash Sale System: Architecture, Strategies & Code
Java Captain
Java Captain
Dec 2, 2019 · Backend Development

Implementing Interface Rate Limiting in Spring Boot with Annotations and Redis

This article demonstrates how to create a custom @AccessLimit annotation, implement a Spring MVC interceptor that uses Redis to count requests, register the interceptor in a Spring Boot application, and apply the annotation to controller methods to achieve rate‑limiting functionality.

InterceptorJavaRedis
0 likes · 6 min read
Implementing Interface Rate Limiting in Spring Boot with Annotations and Redis
Youku Technology
Youku Technology
Nov 5, 2019 · Backend Development

Traffic Shaping Strategies for High‑Concurrency Events: Staggering, Rate Limiting, and Peak Cutting

The article explains how Youku’s engineers mitigate extreme traffic spikes during large‑scale events by applying three core techniques—staggering requests across time, enforcing client‑side rate limits, and cutting peaks through minimum intervals, probabilistic sending and fairness algorithms—to lower maximum QPS, improve stability, and preserve user experience.

QPShigh concurrencyload balancing
0 likes · 8 min read
Traffic Shaping Strategies for High‑Concurrency Events: Staggering, Rate Limiting, and Peak Cutting
21CTO
21CTO
Oct 31, 2019 · Backend Development

Master Distributed Rate Limiting with Token Buckets, Redis, and Code

This article explains why rate limiting is essential for microservice stability, compares leaky‑bucket and token‑bucket algorithms, shows how to implement local and distributed throttling with Java's AtomicLong, Redis, and a control‑server architecture, and points to an open‑source project for practical use.

JavaRedisdistributed systems
0 likes · 9 min read
Master Distributed Rate Limiting with Token Buckets, Redis, and Code
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 18, 2019 · Backend Development

Mastering Service Interaction: Protocols, Discovery, and Resilience in Microservices

This article explores best‑practice patterns for microservice communication, covering synchronous and asynchronous protocols, serialization formats, API design, service discovery, versioning, rate limiting, circuit breakers, correlation IDs, distributed consistency, authentication, retries, and economic considerations.

Circuit Breakermicroservicesrate limiting
0 likes · 22 min read
Mastering Service Interaction: Protocols, Discovery, and Resilience in Microservices
FunTester
FunTester
Aug 11, 2019 · Backend Development

Implementing Request Rate Limiting in Moco with a Custom LimitHandler

This article explains how to extend the Moco API with a custom LimitHandler to restrict request frequency, provides the Java implementation of the handler, and demonstrates several overloads for configuring default and custom intervals for rate limiting in backend testing scenarios.

APIBackend testingJava
0 likes · 6 min read
Implementing Request Rate Limiting in Moco with a Custom LimitHandler
Java Architecture Diary
Java Architecture Diary
Jul 30, 2019 · Backend Development

Mastering Dynamic Rate Limiting in Spring Cloud Gateway with Sentinel

This article examines the limitations of Spring Cloud Gateway's native RequestRateLimiter, introduces Sentinel's flow control integration, provides Maven dependencies, configuration examples, and demonstrates dynamic rate‑limiting adjustments via Nacos, illustrating effective traffic protection for microservice gateways.

NacosSentinelSpring Cloud Gateway
0 likes · 7 min read
Mastering Dynamic Rate Limiting in Spring Cloud Gateway with Sentinel
Architect's Tech Stack
Architect's Tech Stack
Jul 22, 2019 · Backend Development

Common Nginx Functions: Static Proxy, Load Balancing, Rate Limiting, Caching, and Access Control

This article introduces Nginx’s key capabilities—including static file serving, various load‑balancing strategies, leaky‑bucket rate limiting, browser and proxy caching, and black‑/white‑list access control—explaining how each feature can be configured and applied in high‑concurrency web environments.

CachingNginxbackend development
0 likes · 6 min read
Common Nginx Functions: Static Proxy, Load Balancing, Rate Limiting, Caching, and Access Control
FunTester
FunTester
Jul 17, 2019 · Backend Development

Implementing Request Rate Limiting in Moco with a Custom LimitHandler

This article explains how to extend Moco's API mocking capabilities by creating a custom LimitHandler that tracks request timestamps and enforces a configurable interval, providing a reusable solution for preventing rapid repeated submissions in test services.

API mockingBackendJava
0 likes · 7 min read
Implementing Request Rate Limiting in Moco with a Custom LimitHandler
Cloud Native Technology Community
Cloud Native Technology Community
Jul 4, 2019 · Cloud Native

Mastering Istio Circuit Breakers: Hystrix vs Istio, Config & Real‑World Tests

This article explains the concept of circuit breaking and rate limiting in micro‑service architectures, compares Hystrix and Istio implementations, details Istio's ConnectionPool and outlierDetection settings, maps their parameters to Envoy, and provides step‑by‑step command‑line examples that demonstrate how these controls behave in practice.

Circuit BreakerIstiocloud-native
0 likes · 23 min read
Mastering Istio Circuit Breakers: Hystrix vs Istio, Config & Real‑World Tests
Architect's Tech Stack
Architect's Tech Stack
Jul 3, 2019 · Backend Development

Implementing a Distributed Rate Limiter with Redis, Spring Boot, and Lua Scripts

This article demonstrates how to build a distributed rate‑limiting component named shield‑ratelimiter using Redis’s INCR and TTL features, Spring‑Boot‑starter integration, Lua scripting for atomic operations, custom annotations, and AspectJ, providing a robust, configurable solution for limiting API calls in Java backend services.

LuaRedisSpring Boot
0 likes · 16 min read
Implementing a Distributed Rate Limiter with Redis, Spring Boot, and Lua Scripts
Java High-Performance Architecture
Java High-Performance Architecture
Jul 2, 2019 · Operations

How to Build Highly Available Systems: 8 Essential Strategies

This article outlines eight practical high‑availability techniques—multiple replicas, isolation, rate limiting, circuit breaking, degradation, gray releases with rollback, comprehensive monitoring, and proactive log alerting—to help engineers design systems that are both efficient and reliable under heavy load.

Circuit BreakerGray ReleaseSystem Design
0 likes · 7 min read
How to Build Highly Available Systems: 8 Essential Strategies
G7 EasyFlow Tech Circle
G7 EasyFlow Tech Circle
Jun 10, 2019 · Backend Development

How Sentinel Enhances Circuit Breaking and Rate Limiting for Dubbo Microservices in IoT

This article explains how the IoT business platform adopts Alibaba Sentinel to provide circuit breaking and rate‑limiting for Dubbo microservices, integrates with Apollo for centralized rule distribution, implements automatic downgrade, thread isolation, and cache‑based degradation to improve system reliability and resilience.

Circuit BreakingDubboSentinel
0 likes · 9 min read
How Sentinel Enhances Circuit Breaking and Rate Limiting for Dubbo Microservices in IoT
Tencent Cloud Developer
Tencent Cloud Developer
May 23, 2019 · Backend Development

Rate Limiting in Microservices: Why It’s Needed and Common Techniques

Rate limiting is essential for microservice resilience, preventing overloads and protecting business continuity, and can be implemented through various methods such as semaphores, thread‑pool isolation, fixed or sliding windows (using Redis ZSets or local memory), token‑bucket/leaky‑bucket algorithms, each with trade‑offs in accuracy, performance, clock synchronization, and deployment location.

algorithmmicroservicesrate limiting
0 likes · 16 min read
Rate Limiting in Microservices: Why It’s Needed and Common Techniques
Wukong Talks Architecture
Wukong Talks Architecture
Apr 27, 2019 · Backend Development

Implementing a Circuit Breaker Mechanism for Backend API Calls

This article explains a practical circuit‑breaker design for backend services, detailing detection logic, algorithm thresholds, time‑window statistics, recovery duration, manual overrides, a global switch, and how to monitor the breaker’s current state using Redis.

APICircuit BreakerResilience
0 likes · 6 min read
Implementing a Circuit Breaker Mechanism for Backend API Calls
Programmer DD
Programmer DD
Apr 10, 2019 · Backend Development

How to Implement Interface Rate Limiting with Sentinel in Spring Cloud Alibaba

This tutorial explains how Sentinel, the distributed system traffic guardian, can be deployed and integrated into a Spring Cloud Alibaba application to provide flow control and circuit breaking, covering dashboard setup, Maven configuration, code examples, rule creation, and verification of rate‑limiting behavior.

Javamicroservicesrate limiting
0 likes · 8 min read
How to Implement Interface Rate Limiting with Sentinel in Spring Cloud Alibaba
Java Captain
Java Captain
Apr 3, 2019 · Backend Development

Understanding Message Queues: Benefits, Use Cases, and Challenges

This article explains what a message queue (MQ) is, why it is needed beyond in‑memory Java queues, and how it enables decoupling, asynchronous processing, peak‑shaving and rate‑limiting, while also discussing high‑availability, data‑loss, and consumer‑side considerations.

Javadecouplinghigh availability
0 likes · 11 min read
Understanding Message Queues: Benefits, Use Cases, and Challenges