Skip to content
Tagged articles

rate limiting

500 articles · Page 3 of 5
IT Services Circle
IT Services Circle
Jun 13, 2025 · Information Security

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

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

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

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

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

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

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

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

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

Designing Queueing and Rate Limiting for Scalable AIGC Services

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

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

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

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

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

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

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

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

How to Rate‑Limit Asynchronous Tasks with ReactPHP‑MQ

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

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

How Sentinel Empowers Cloud‑Native Traffic Governance and Resilience

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Handling Sudden Traffic Spikes in Backend Systems

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

Asynchronous ProcessingCircuit BreakingScaling
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 SystemsRedis
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.

Asynchronous ProcessingBackend Performancecaching
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.

AlgorithmBackendrate limiting
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 SystemsFault Isolation
0 likes · 7 min read
How to Build a Fault‑Isolation Shield for High‑Traffic Distributed Systems
Tencent Cloud Middleware
Tencent Cloud Middleware
Mar 17, 2025 · Backend Development

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

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

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

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

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

AI inferenceAsynchronous ProcessingRAG
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.

Fault Tolerancechaos engineeringcircuit breaker
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.

AIGCDeepSeekElastic Scaling
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.

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

AlgorithmDistributed Systemsgolang
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.

Service Governancemicroservicesrate limiting
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.

Asynchronous Processingcachingdatabase optimization
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.

Query Optimizationdatabase shardinghigh concurrency
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.

AlgorithmBackendC++
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 PatternsRedis
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.

APIIdempotencyLogging
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
Programmer XiaoFu
Programmer XiaoFu
Nov 14, 2024 · Backend Development

Designing Elegant API Controllers: Security, Idempotency, and Best Practices

This guide walks through building robust API controller interfaces by covering request signing, RSA encryption, IP whitelisting, rate limiting, parameter validation, unified response formats, exception handling, logging, idempotent design, request size limits, stress testing, asynchronous processing, data masking, and comprehensive documentation.

API designBackendIdempotency
0 likes · 15 min read
Designing Elegant API Controllers: Security, Idempotency, and Best Practices
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 BreakingJavaSentinel
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.

Elastic ThrottlingKafkabandwidth management
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 ThrottlingSentinel
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 OptimizationSemaphore
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 QueueConcurrencyJava
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
Programmer XiaoFu
Programmer XiaoFu
Sep 26, 2024 · Backend Development

Boost Coding Efficiency with Guava RateLimiter: Elegant Rate Limiting Explained

This article explains how Guava's RateLimiter, built on the token‑bucket algorithm, provides smooth burst handling, configurable rates, warm‑up support, and thread safety, and demonstrates its usage through detailed code examples and best‑practice recommendations for API, database, and crawler throttling.

ConcurrencyGuavaJava
0 likes · 9 min read
Boost Coding Efficiency with Guava RateLimiter: Elegant Rate Limiting Explained
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.

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

API designBackendIdempotency
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
Programmer XiaoFu
Programmer XiaoFu
Sep 19, 2024 · Backend Development

Six Practical Rate‑Limiting Techniques for Microservices

The article walks through six concrete rate‑limiting methods—fixed window, sliding window, leaky bucket, token bucket (Guava RateLimiter), Sentinel middleware, and Spring Cloud Gateway—showing Java implementations, test results, advantages, drawbacks, and how they fit into microservice architectures.

GuavaJavaSentinel
0 likes · 20 min read
Six Practical Rate‑Limiting Techniques for Microservices
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.

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

AlgorithmBackendDistributed Systems
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.

Resilience4jrate limitingtoken-bucket
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.

BackendFault Tolerancecircuit breaker
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.

API designBackendIdempotency
0 likes · 11 min read
Backend API Design Best Practices
Shepherd Advanced Notes
Shepherd Advanced Notes
Jul 31, 2024 · Backend Development

Understanding Redis Cache Penetration, Breakdown, and Avalanche: Differences and Solutions

The article explains the concepts of Redis cache penetration, cache breakdown, and cache avalanche, compares their causes, and provides practical mitigation techniques such as parameter validation, null‑key caching, Bloom filters, rate limiting, hot‑data pre‑warming, and multi‑level caching to protect database stability.

Bloom filterCache PrewarmingRedis
0 likes · 9 min read
Understanding Redis Cache Penetration, Breakdown, and Avalanche: Differences and Solutions
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 NativeFault Tolerancecircuit breaker
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.

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

Data StructuresDistributed SystemsMessage Queue
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.

High AvailabilityRetryTimeout
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.

High AvailabilityRetryTimeout
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.

Retrycircuit breakermicroservices
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 ArchitectureSemaphoredatabase tuning
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.

API designSecurityrate 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.

API designCRUDGraphQL
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.

API designIdempotencyrate 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.

AlgorithmDistributed Systemsgolang
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 SecurityToken Authenticationencryption
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.

High AvailabilityRetryTimeout
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 SystemsFault ToleranceHigh Availability
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 SecurityHTTPSXSS protection
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.

Bloom filterCachecache 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.

Algorithmgolangmicroservices
0 likes · 30 min read
Mastering Rate Limiting: Algorithms, Pros, Cons, and Distributed Solutions