BestHub
Sign in
Tagged articles

rate limiting

656 articles · Page 1 of 7
liandk
liandk
Oct 4, 2026 · Backend Development

High-Concurrency Flash Sale Architecture: Layered Rate Limiting, Overselling Prevention & Cache Protection

This article details a production-grade five-layer architecture for high-concurrency flash sale systems, covering traffic shaping via message queues, multi-level rate limiting, three-tier overselling prevention using Redis atomic operations and database optimistic locking, and solutions for cache penetration, breakdown, and avalanche, plus nine common failure scenarios and a troubleshooting SOP.

Rediscache protectiondistributed lock
0 likes · 17 min read
High-Concurrency Flash Sale Architecture: Layered Rate Limiting, Overselling Prevention & Cache Protection
liandk
liandk
Sep 26, 2026 · Operations

Nginx & API Gateway Troubleshooting: 10 Critical Production Faults Solved

This guide covers the top 10 Nginx and API gateway production faults—including 502/504 errors, retry storms, load imbalance, rate limiting failures, CORS issues, and 499 errors—with root cause analysis, configuration fixes, and a step-by-step SOP for rapid diagnosis and long-term prevention.

502 Bad Gateway504 Gateway TimeoutAPI Gateway
0 likes · 13 min read
Nginx & API Gateway Troubleshooting: 10 Critical Production Faults Solved
LuTiao Programming
LuTiao Programming
Sep 21, 2026 · Backend Development

Distributed Rate Limiting with Redis + Lua: Surviving API Floods in Spring Boot

After an external system hammered a Spring Boot search endpoint causing database connection exhaustion, the author builds a distributed fixed-window rate limiter using Redis and Lua for atomicity, wraps it with an annotation-driven AOP aspect supporting user, IP, API key, and global dimensions, returns proper HTTP 429 with Retry-After, discusses fixed-window limitations versus token bucket and sliding window, and covers fail-open/fail-closed strategies for Redis outages plus monitoring metrics.

AOPFail-OpenFixed Window
0 likes · 17 min read
Distributed Rate Limiting with Redis + Lua: Surviving API Floods in Spring Boot
Raymond Ops
Raymond Ops
Sep 21, 2026 · Operations

Nginx Rate Limiting in Practice: Defending Against CC Attacks and Traffic Spikes

This comprehensive guide covers Nginx rate limiting fundamentals, leaky bucket algorithm, configuration directives (limit_req_zone, limit_req, limit_conn_zone), practical scenarios (IP/URI-based limiting, whitelists, blacklists, CC attack defense), testing tools (wrk, ab, vegeta), monitoring with Prometheus, troubleshooting cases, and production rollout/rollback strategies.

NginxPrometheuscc-attack
0 likes · 42 min read
Nginx Rate Limiting in Practice: Defending Against CC Attacks and Traffic Spikes
LuTiao Programming
LuTiao Programming
Sep 20, 2026 · Backend Development

Spring Boot Large File Download: Streaming & Range Requests for Resumable Transfers

The article shows how to handle 10GB file downloads in Spring Boot by replacing in-memory byte[] loading with streaming via FileSystemResource and leveraging Spring MVC's built-in Range request support for resumable downloads, while covering security, immutability, and object storage offloading.

File DownloadFileSystemResourceMemory Optimization
0 likes · 16 min read
Spring Boot Large File Download: Streaming & Range Requests for Resumable Transfers
Xiaolin Talks Programming
Xiaolin Talks Programming
Sep 19, 2026 · Backend Development

Building a Multi-Channel Notification Center: Template Design, Async Processing & Reliable Retry Patterns

This article details the architecture and implementation of a production-grade notification center that abstracts channel differences, uses Thymeleaf for template rendering, employs Channel/Provider abstractions for multi-vendor support, handles async execution via thread pools and message queues, and ensures reliability through persistent task tracking, exponential backoff retries, rate limiting, idempotency, and audit logging.

Audit LoggingRetry PatternSpring Boot
0 likes · 24 min read
Building a Multi-Channel Notification Center: Template Design, Async Processing & Reliable Retry Patterns
JavaGuide
JavaGuide
Sep 14, 2026 · Artificial Intelligence

Rethinking AI Agent Configs for OpenAI's Astra: Auditing Skills, AGENTS.md, and Prompts

The article reviews OpenAI's new guide for GPT-6 Astra, showing how to narrow Skill trigger conditions, use progressive disclosure in SKILL.md, make AGENTS.md document reads task-specific, and clarify completion criteria; the author demonstrates a practical audit of their interview-guide project where Codex caught a rate-limiting documentation mismatch.

AGENTS.mdAI agent configurationCodex
0 likes · 10 min read
Rethinking AI Agent Configs for OpenAI's Astra: Auditing Skills, AGENTS.md, and Prompts
Programmer DD
Programmer DD
Sep 6, 2026 · Backend Development

OctaFuse Gateway 2.9.0 Adds Dual-Layer Rate Limiting, Custom Upstream Headers, and Dashboard Overhaul

OctaFuse Gateway 2.9.0 introduces per-user and per-key RPM rate limiting with sliding 60-second windows, per-route custom HTTP headers for upstream providers, a redesigned admin dashboard with consolidated metrics, and Key-level analytics with ingress host tracking, plus migration 0028 for database schema updates.

API GatewayAdmin DashboardCloudflare
0 likes · 17 min read
OctaFuse Gateway 2.9.0 Adds Dual-Layer Rate Limiting, Custom Upstream Headers, and Dashboard Overhaul
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Sep 2, 2026 · Backend Development

How to Build a Scalable Notification Service with Spring Boot

The article explains why notification services are hard—slow delivery, unreliable third‑party providers, and status tracking—and shows how to solve these issues by fully decoupling the API from workers using a message queue, with detailed Spring Boot code examples and scaling strategies.

JavaNotification ServiceRabbitMQ
0 likes · 10 min read
How to Build a Scalable Notification Service with Spring Boot
Programmer XiaoFu
Programmer XiaoFu
Aug 28, 2026 · Backend Development

Why Spring Cloud Gateway Rate Limiting Fails to Protect Downstream Services

The article analyzes five reasons why Spring Cloud Gateway's Redis-based token bucket rate limiting fails to protect downstream services during traffic bursts, including QPS vs. concurrency confusion, burstCapacity spikes, multi-route quota multiplication, KeyResolver fallback flaws, and Redis bottleneck fail-open behavior, then recommends tightening burst limits, adding downstream concurrency isolation with Sentinel/Resilience4j, and hardening KeyResolver configuration.

Burst TrafficRedisResilience4j
0 likes · 13 min read
Why Spring Cloud Gateway Rate Limiting Fails to Protect Downstream Services
Architect's Guide
Architect's Guide
Aug 25, 2026 · Cloud Native

API Gateway vs Load Balancer: How to Choose the Right Traffic Management Tool

This article compares load balancers and API gateways, explaining their layer‑4 vs layer‑7 focus, feature sets such as routing, authentication, observability, and extensibility, and outlines suitable scenarios like microservices, API publishing, and high‑throughput network entry to help readers select the appropriate component.

API GatewayAuthenticationload balancer
0 likes · 11 min read
API Gateway vs Load Balancer: How to Choose the Right Traffic Management Tool
Programmer1970
Programmer1970
Aug 23, 2026 · Backend Development

Custom Spring Cloud Gateway Filters for Rate Limiting, Circuit Breaking & Gray Release

This article details the development of custom Spring Cloud Gateway plugins for rate limiting, circuit breaking, and gray release to overcome Sentinel's production limitations, covering architecture design, Redis-based rule storage with pub/sub, token bucket and sliding window algorithms, circuit breaker state machines, tag-based canary routing, and production lessons learned with performance benchmarks.

Circuit BreakingGray ReleaseRedis
0 likes · 20 min read
Custom Spring Cloud Gateway Filters for Rate Limiting, Circuit Breaking & Gray Release
Xiaolin Talks Programming
Xiaolin Talks Programming
Aug 19, 2026 · Backend Development

Building Distributed Rate Limiting with Spring Boot, Redis & Lua: Sliding Window, Token Bucket & Flash Sale Defense

This article details a production-ready distributed rate limiting system using Spring Boot AOP, Redis Sorted Sets, and atomic Lua scripts, covering sliding window and token bucket algorithms, multi-dimensional flash sale protection, and benchmark results showing 100% accuracy with minimal latency overhead.

AOPLuaRedis
0 likes · 18 min read
Building Distributed Rate Limiting with Spring Boot, Redis & Lua: Sliding Window, Token Bucket & Flash Sale Defense
Cloud Architecture
Cloud Architecture
Aug 17, 2026 · Backend Development

Go Microservice Stability: Rate Limiting, Circuit Breaking, Degradation and K8s Production Architecture

The article walks through a real‑world traffic spike in an e‑commerce order service, explains why isolated techniques like rate limiting, circuit breaking or degradation are insufficient, and presents a complete, layered stability‑governance solution for Go microservices running on Kubernetes, complete with code, configuration, observability and testing guidance.

Circuit BreakerGoKubernetes
0 likes · 42 min read
Go Microservice Stability: Rate Limiting, Circuit Breaking, Degradation and K8s Production Architecture
Raymond Ops
Raymond Ops
Aug 13, 2026 · Operations

How to Implement Nginx Rate Limiting: Protect Against Brute‑Force, Crawlers, and Traffic Spikes

This article explains how to use Nginx's built‑in limit_req and limit_conn modules—based on the leaky‑bucket algorithm—to throttle requests by IP or API key, configure burst and nodelay behavior, apply whitelists, customize error responses, fine‑tune with delay and dry‑run modes, and monitor effectiveness in production environments.

API SecurityNginxleaky-bucket
0 likes · 22 min read
How to Implement Nginx Rate Limiting: Protect Against Brute‑Force, Crawlers, and Traffic Spikes
liandk
liandk
Aug 10, 2026 · Backend Development

Microservice Resilience: Rate Limiting, Circuit Breaker, Degradation & Debounce

To keep microservice systems stable, the article explains why fault‑tolerance is essential, defines service avalanches, and details four core safeguards—rate limiting, circuit breaking, degradation, and debounce—covering their principles, typical use cases, deployment layers, and how they work together to prevent cascading failures.

Circuit Breakerdebouncedegradation
0 likes · 8 min read
Microservice Resilience: Rate Limiting, Circuit Breaker, Degradation & Debounce
Ray's Galactic Tech
Ray's Galactic Tech
Aug 7, 2026 · Operations

Scaling Nginx to Handle 500M Daily Requests: From Reverse Proxy to Traffic Governance Hub

This article walks through an enterprise‑grade Nginx upgrade for a payment platform handling ~500 million daily requests, detailing why simple reverse‑proxying fails, how Nginx can become a traffic‑governance edge with rate limiting, edge caching, gray releases, high‑availability, and observability, and provides production‑ready configurations and step‑by‑step analysis.

Edge CachingGray ReleaseNginx
0 likes · 42 min read
Scaling Nginx to Handle 500M Daily Requests: From Reverse Proxy to Traffic Governance Hub
Architect's Guide
Architect's Guide
Aug 7, 2026 · Backend Development

A Clear Diagram of the User Login Verification Process

This article walks through a complete user login flow—including client verification, token generation, expiration policies, gateway validation, logout handling, anonymous access, rate‑limiting via authorized tokens, regex path checks, and blacklist management—illustrated with diagrams and Spring‑Redis code examples.

AuthenticationRedisSpring
0 likes · 9 min read
A Clear Diagram of the User Login Verification Process
Mike Chen Rui
Mike Chen Rui
Aug 5, 2026 · Backend Development

How Can a Gateway Sustain Million‑Level Concurrency in High‑Traffic Scenarios?

The article explains why a gateway is the first traffic entry in microservice systems and how Spring Cloud Gateway achieves million‑level concurrent handling through a reactive model, non‑blocking I/O, event‑driven scheduling, zero‑copy transmission, and built‑in rate‑limiting mechanisms.

Spring Cloud Gatewayevent-drivenhigh concurrency
0 likes · 3 min read
How Can a Gateway Sustain Million‑Level Concurrency in High‑Traffic Scenarios?
Code Farming
Code Farming
Aug 4, 2026 · Backend Development

Why 50,000 Simultaneous Registrations Crashed the System—and How Isolation Prevents It

When an education company faced 50,000 concurrent re‑registration requests, its monolithic internal‑external architecture collapsed, but by physically separating networks, enforcing gateway rate‑limiting and circuit‑breaking, pre‑loading data into Redis, and using one‑way Kafka streams, the system remained stable.

Circuit BreakingKafkaRedis
0 likes · 6 min read
Why 50,000 Simultaneous Registrations Crashed the System—and How Isolation Prevents It
Thought Artisan
Thought Artisan
Jul 29, 2026 · Mobile Development

Android Resource Reliability: Token Bucket, Multi-Rate Limiting & Quota Design

This article explores Android's system-level reliability designs, including the TokenBucket rate limiter for logs and metrics, the MultiRateLimiter multi-window quota engine used for Toast rate limiting, and resource counting mechanisms like broadcast receiver limits, showing how Google prevents system overload from app misuse.

AndroidBroadcastReceiverMultiRateLimiter
0 likes · 6 min read
Android Resource Reliability: Token Bucket, Multi-Rate Limiting & Quota Design
Cloud Architecture
Cloud Architecture
Jul 26, 2026 · Backend Development

Seckill System Architecture: 7 Core Design Strategies for High-Concurrency Sales

This article presents a comprehensive, step‑by‑step analysis of building a flash‑sale (seckill) system that can survive instant traffic spikes, detailing seven essential design ideas such as static page delivery, token gating, Redis atomic decrement, asynchronous queuing, multi‑layer rate limiting, service isolation, idempotent processing, and end‑to‑end monitoring and recovery.

LuaMQRedis
0 likes · 28 min read
Seckill System Architecture: 7 Core Design Strategies for High-Concurrency Sales
Xiaolin Talks Programming
Xiaolin Talks Programming
Jul 26, 2026 · Backend Development

Building High-Reliability API Gateways: Spring Cloud Gateway + Sentinel for Smart Rate Limiting & Dynamic Routing

This article details integrating Sentinel with Spring Cloud Gateway to achieve intelligent rate limiting, circuit breaking, dynamic routing, and security controls, covering cluster flow control modes, hot rule updates via Nacos, performance tuning for reactive pipelines, and production-grade security patterns including IP filtering and API signature verification.

API SecurityCircuit BreakingNacos
0 likes · 21 min read
Building High-Reliability API Gateways: Spring Cloud Gateway + Sentinel for Smart Rate Limiting & Dynamic Routing
MaGe Linux Operations
MaGe Linux Operations
Jul 18, 2026 · Operations

How to Configure Nginx Load Balancing for Multiple LLM Instances

This guide explains how to set up Nginx as a load balancer for several OpenAI‑compatible large language model instances, covering health checks, upstream configuration, algorithm selection, streaming vs non‑streaming proxy settings, logging, rate limiting, graceful reloads, and troubleshooting techniques.

LLMNginxProxy
0 likes · 25 min read
How to Configure Nginx Load Balancing for Multiple LLM Instances
Java Tech Workshop
Java Tech Workshop
Jul 16, 2026 · Backend Development

How to Distinguish Real Users from Scalper Bots in Flash Sale Systems

The article presents a comprehensive five‑layer risk‑control architecture—covering front‑end behavior verification, device fingerprinting, account profiling, IP network analysis, and backend request sequencing—designed to separate genuine shoppers from scalper scripts during high‑traffic flash‑sale events, using Redis‑based storage and dynamic thresholds to minimize false positives.

BackendRedisbot detection
0 likes · 21 min read
How to Distinguish Real Users from Scalper Bots in Flash Sale Systems
Code Farming
Code Farming
Jul 13, 2026 · Backend Development

Mastering Traffic Control: Keeping Systems Stable Under a Million Concurrent Requests

The article explains how to prevent system crashes during massive traffic spikes by applying three core techniques—rate limiting, circuit breaking, and graceful degradation—detailing algorithm choices, state machines, and practical implementation steps for high‑concurrency back‑end services.

BackendCircuit BreakerSystem Design
0 likes · 6 min read
Mastering Traffic Control: Keeping Systems Stable Under a Million Concurrent Requests
Raymond Ops
Raymond Ops
Jul 10, 2026 · Artificial Intelligence

How to Diagnose and Fix Common LLM Service Errors: Timeout, Rate Limiting, and OOM

This guide presents a systematic, step‑by‑step methodology for troubleshooting large‑language‑model services, covering how to identify and resolve timeout, rate‑limiting, and out‑of‑memory (OOM) failures, with concrete commands, configuration examples, case studies, and monitoring recommendations.

Out of Memorylarge language modelrate limiting
0 likes · 63 min read
How to Diagnose and Fix Common LLM Service Errors: Timeout, Rate Limiting, and OOM
YiSu Grain
YiSu Grain
Jul 9, 2026 · Backend Development

Why Adding Cache First Is the Wrong Move for Slow Systems

The article explains that performance tuning should start with pinpointing bottlenecks using response time, throughput, concurrency and resource utilization metrics, then choose appropriate measures—caching, async processing, database tuning, horizontal scaling, and rate‑limiting—rather than blindly adding a cache.

CachingPerformance Optimizationasynchronous-processing
0 likes · 12 min read
Why Adding Cache First Is the Wrong Move for Slow Systems
Java Architect Handbook
Java Architect Handbook
Jul 8, 2026 · Backend Development

Why a Gateway Is Essential in Microservices and What It Actually Does

The article explains that a gateway serves as the unified entry point of a microservice system, handling routing, authentication, rate limiting, logging and protocol conversion, compares architectures with and without a gateway, details Spring Cloud Gateway's core concepts, shows configuration and custom auth filter code, and contrasts it with Zuul, providing interview‑ready insights and sample questions.

API GatewayAuthenticationSpring Cloud Gateway
0 likes · 13 min read
Why a Gateway Is Essential in Microservices and What It Actually Does
DeepHub IMBA
DeepHub IMBA
Jul 7, 2026 · Operations

How OpenSpec’s Three‑Stage Workflow Cuts Code Rework to Below One‑Third

The article explains OpenSpec’s three‑stage workflow—Propose, Apply, Archive—driven by AI agents, showing how its strict state machine, 50 KB context limit, and structured specs (proposal.md, specs/, design.md, tasks.md) reduce code rework to under one‑third compared with traditional documentation and tools like SpecKit.

AI AgentsOpenSpecSpec-Driven Development
0 likes · 12 min read
How OpenSpec’s Three‑Stage Workflow Cuts Code Rework to Below One‑Third
YiSu Grain
YiSu Grain
Jul 6, 2026 · Backend Development

Who Controls Traffic After Splitting Services? A Guide to Service Governance

The article explains how microservice decomposition introduces challenges such as locating services, routing external requests, balancing load, isolating failures, limiting traffic, and degrading non‑essential features, and it details the six core mechanisms—service discovery, API gateway, load balancing, circuit breaking, rate limiting, and degradation—that together form a complete service‑governance solution.

API GatewayCircuit Breakerdegradation
0 likes · 12 min read
Who Controls Traffic After Splitting Services? A Guide to Service Governance
Cloud Architecture
Cloud Architecture
Jul 4, 2026 · Backend Development

Production-Ready SMS Verification Login System: Security Countermeasures and Engineering

This article presents a comprehensive guide to building a production-grade SMS verification login system, covering threat modeling, multi-layer rate limiting, state management with Redis, asynchronous message handling, multi‑provider routing, token issuance and operational monitoring to ensure security, cost control, and high availability.

OutboxRedisSMS verification
0 likes · 36 min read
Production-Ready SMS Verification Login System: Security Countermeasures and Engineering
Random Bulletin
Random Bulletin
Jul 3, 2026 · Operations

From Coarse to Fine-Grained: Traffic Shaping Strategies for Million‑QPS Queues

A bulk coupon‑sending job overwhelmed a million‑QPS system, revealing that message queues only buffer but do not shape traffic; the article dissects three failure points, compares leaky‑bucket and token‑bucket rate limiters, evaluates placement on producer, broker or consumer, and progresses from static limits to adaptive shaping with handling of throttled messages.

adaptive throttlingleaky-bucketmessage queue
0 likes · 18 min read
From Coarse to Fine-Grained: Traffic Shaping Strategies for Million‑QPS Queues
Random Bulletin
Random Bulletin
Jul 2, 2026 · Operations

From Zero to Control: Implementing Traffic Shaping for 10 Million QPS Systems

A bulk coupon‑sending job overwhelmed a 10 M‑QPS system, revealing that message queues only buffer traffic; the article walks through why rate‑limiting (leaky vs token bucket) must be added at the producer, broker, or consumer, evolves from static thresholds to adaptive shaping, and discusses how to handle throttled messages.

adaptive throttlingleaky-bucketmessage queue
0 likes · 18 min read
From Zero to Control: Implementing Traffic Shaping for 10 Million QPS Systems
dbaplus Community
dbaplus Community
Jul 1, 2026 · Databases

How DeWu Cut Redis RT by 90% with a Full‑Scale Self‑Built Redesign

The article details DeWu's three‑year evolution of its self‑built Redis platform—covering architecture, access method changes, version upgrades, proxy rate limiting, and automated operations—that together reduced request latency by over 90% while supporting more than 1,000 clusters, 160 TB of memory and near‑10‑million QPS.

DRedis SDKProxyRedis
0 likes · 17 min read
How DeWu Cut Redis RT by 90% with a Full‑Scale Self‑Built Redesign
MaGe Linux Operations
MaGe Linux Operations
Jun 28, 2026 · Operations

Practical Nginx Rate Limiting: Elegantly Defending Against CC Attacks and Traffic Spikes

This article walks through why Nginx needs rate limiting, explains the three core directives, compares burst, nodelay and delay behaviors, shows how to choose keys, and provides step‑by‑step configuration, testing, monitoring and troubleshooting recipes for protecting services from CC attacks and sudden traffic bursts.

Nginxcc-attacklimit_conn
0 likes · 29 min read
Practical Nginx Rate Limiting: Elegantly Defending Against CC Attacks and Traffic Spikes
Subtle Storm
Subtle Storm
Jun 25, 2026 · Backend Development

Why Microservices Matter: Core Architecture and Key Technologies Explained

The article analyzes how monolithic applications struggle with scalability, deployment, and team coordination, then breaks down microservice architecture—including API gateways, service communication, registration, resilience patterns, tracing, and container orchestration—while weighing its benefits against added complexity and team size considerations.

Circuit BreakerDockerKubernetes
0 likes · 7 min read
Why Microservices Matter: Core Architecture and Key Technologies Explained
Lobster Programming
Lobster Programming
Jun 22, 2026 · Databases

Common Redis Use Cases in Real-World Projects

This article outlines nine practical Redis scenarios—including hot‑data caching, distributed locks with Redisson, Bloom filters for cache‑penetration protection, delayed queues using ZSet, token‑bucket rate limiting, bitmap boolean statistics, UV deduplication via Set/HyperLogLog/Bitmap, geospatial indexing, and lightweight Stream queues—explaining their motivations, implementation steps, and trade‑offs.

BitmapBloom FilterCaching
0 likes · 7 min read
Common Redis Use Cases in Real-World Projects
Architecture & Thinking
Architecture & Thinking
Jun 18, 2026 · Backend Development

How to Scale a Flash‑Sale System from Zero to 1 Million QPS: A Step‑by‑Step Architecture Guide

This article dissects the evolution of a flash‑sale system from a simple monolithic controller to a cloud‑native, micro‑service architecture that can handle over one million requests per second, detailing traffic‑shaping, multi‑level caching, async processing, and inventory‑consistency techniques.

CachingDistributed ArchitectureKubernetes
0 likes · 18 min read
How to Scale a Flash‑Sale System from Zero to 1 Million QPS: A Step‑by‑Step Architecture Guide
Random Bulletin
Random Bulletin
Jun 16, 2026 · Backend Development

Consumer Rate Limiting: From Zero to Full Control in Million‑QPS Architectures

The article explains why consumer‑side rate limiting is essential in million‑QPS systems, detailing how unchecked consumers can overwhelm downstream services, and presents practical strategies—including pause/resume, token‑bucket algorithms, adaptive thresholds, and global coordination—to safely throttle consumption without dropping messages.

Kafkaconsumer optimizationdistributed systems
0 likes · 16 min read
Consumer Rate Limiting: From Zero to Full Control in Million‑QPS Architectures
Subtle Storm
Subtle Storm
Jun 15, 2026 · Backend Development

Caching, Rate Limiting, Smoothing, and Idempotency: Solving Concurrency Problems

The article breaks down how caching reduces repeated slow‑resource access, rate limiting protects systems from overload, smoothing (peak shaving) buffers burst traffic with queues, and idempotency prevents duplicate operations, using a milk‑tea shop analogy to illustrate each technique’s role in high‑concurrency environments.

BackendCachingPeak Shaving
0 likes · 7 min read
Caching, Rate Limiting, Smoothing, and Idempotency: Solving Concurrency Problems
Cloud Architecture
Cloud Architecture
Jun 12, 2026 · Backend Development

1 Million QPS Coupon‑Grab System: Distributed Rate Limiting, Stock Capping, and CAP Trade‑offs

The article explains how a production‑grade coupon‑grab service can survive millions of requests per second by treating rate limiting as a business admission layer, separating stock capping from throttling, making explicit CAP trade‑offs, and implementing a hybrid Redis‑based token‑bucket limiter with local fallback, monitoring, and deployment best practices.

CAP theoremKubernetesRedis
0 likes · 28 min read
1 Million QPS Coupon‑Grab System: Distributed Rate Limiting, Stock Capping, and CAP Trade‑offs
James' Growth Diary
James' Growth Diary
Jun 10, 2026 · Artificial Intelligence

Credential Pool Multi-Key Rotation: How Hermes Makes Rate‑Limiting Self‑Healing

The article dissects Hermes' four‑layer credential‑pool architecture, explaining how it automatically rotates multiple API keys, handles 401/429 errors with state‑driven cooldowns, lazily refreshes OAuth tokens, discovers credentials from seven sources, and applies soft concurrency limits to keep agents running without manual intervention.

API key rotationHermesLLM Agent
0 likes · 21 min read
Credential Pool Multi-Key Rotation: How Hermes Makes Rate‑Limiting Self‑Healing
Cloud Architecture
Cloud Architecture
Jun 8, 2026 · Backend Development

Why Fixed‑Window Rate Limiting Fails in High‑Concurrency: Full Guide to Three Production‑Ready Approaches

The article explains why the simple fixed‑window counter is a hidden trap for high‑traffic systems, outlines five essential questions for production‑grade rate limiting, and compares three practical deployment patterns—single‑node Guava token bucket, Redis‑based distributed sliding window, and Sentinel‑driven microservice governance—complete with code and operational tips.

GuavaRedisSentinel
0 likes · 44 min read
Why Fixed‑Window Rate Limiting Fails in High‑Concurrency: Full Guide to Three Production‑Ready Approaches
Subtle Storm
Subtle Storm
Jun 7, 2026 · Backend Development

Designing a Funnel Model for Flash‑Sale Architecture

The article explains the funnel model for flash‑sale systems, detailing how layered filtering—via CDN static delivery, gateway rate limiting, Redis pre‑checks, inventory validation, and final database writes—shifts cost to cheap resources, improves scalability, and incorporates time‑based traffic shaping.

CDNDistributed ArchitectureRedis
0 likes · 6 min read
Designing a Funnel Model for Flash‑Sale Architecture
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 7, 2026 · Backend Development

Why Skip Your Own Rate Limiter? Using Spring Boot’s Built‑in ConcurrencyThrottleInterceptor

The article explains how Spring Boot 3.5 provides the ConcurrencyThrottleInterceptor for limiting concurrent method calls, demonstrates basic configuration and execution, reveals that all intercepted methods share a single limit, and proposes two fixes—per‑pointcut advisors or a BeanPostProcessor with a custom @ConcurrencyLimit annotation—before recommending dedicated libraries such as Bucket4j or Resilience4j for business‑level throttling.

AOPBeanPostProcessorBucket4j
0 likes · 8 min read
Why Skip Your Own Rate Limiter? Using Spring Boot’s Built‑in ConcurrencyThrottleInterceptor
Subtle Storm
Subtle Storm
Jun 6, 2026 · Backend Development

Flash Sale Architecture: A Complete Blueprint for High‑Traffic Systems

To handle the massive, short‑lived traffic of flash‑sale events, architects must combine static content delivery, Redis‑based inventory pre‑loading, asynchronous order processing, distributed rate‑limiting, stateless services, Kubernetes auto‑scaling, graceful degradation, circuit breaking, and robust monitoring to ensure reliability and prevent overload.

Circuit BreakingKubernetesRedis
0 likes · 8 min read
Flash Sale Architecture: A Complete Blueprint for High‑Traffic Systems
Java Tech Workshop
Java Tech Workshop
May 31, 2026 · Backend Development

Spring Boot Service Circuit Breaking and Degradation with Sentinel: A Practical Guide

This article explains how microservice architectures suffer from cascading failures and demonstrates how to use Sentinel for rate limiting, circuit breaking, and degradation—including architecture, configuration, code examples, and best‑practice tips—to achieve high‑availability Spring Boot services.

Circuit BreakingSentinelSpring Boot
0 likes · 16 min read
Spring Boot Service Circuit Breaking and Degradation with Sentinel: A Practical Guide
Java Tech Workshop
Java Tech Workshop
May 30, 2026 · Backend Development

Implement SpringBoot API Rate Limiting with Gateway and Redis

The article explains why placing rate limiting at the Spring Cloud Gateway layer, using Redis and Lua scripts, provides a high‑performance, distributed defense against traffic spikes, and walks through three algorithms, configuration parameters, code examples, and custom error handling for robust backend services.

LuaRedisSpringBoot
0 likes · 8 min read
Implement SpringBoot API Rate Limiting with Gateway and Redis
Java Tech Workshop
Java Tech Workshop
May 29, 2026 · Backend Development

Why Use Spring Cloud Gateway? A Beginner’s Guide to Building a SpringBoot API Gateway

In a micro‑service architecture, a centralized gateway eliminates the need for front‑ends to call dozens of services by handling authentication, rate‑limiting, logging, CORS, and security, and Spring Cloud Gateway—built on WebFlux and Netty—offers a non‑blocking, high‑throughput alternative to Zuul with detailed configuration and code examples for production use.

API GatewayNettySpring Boot
0 likes · 18 min read
Why Use Spring Cloud Gateway? A Beginner’s Guide to Building a SpringBoot API Gateway
Xiaolin Talks Programming
Xiaolin Talks Programming
May 26, 2026 · Backend Development

Building Enterprise-Grade RESTful APIs with Spring Boot: Design, Validation & Rate Limiting

A comprehensive guide to building production-ready RESTful APIs using Spring Boot, covering resource naming conventions, HTTP verb semantics, unified response formats, global exception handling with @RestControllerAdvice, declarative validation via Hibernate Validator including group validation and custom constraints, distributed rate limiting with Redis and Lua scripts, and automated API documentation with SpringDoc OpenAPI.

Global Exception HandlingHibernate ValidatorJava Backend Development
0 likes · 15 min read
Building Enterprise-Grade RESTful APIs with Spring Boot: Design, Validation & Rate Limiting
Cloud Architecture
Cloud Architecture
May 21, 2026 · Information Security

Production-Ready Elasticsearch Security Hardening: TLS, Authentication, and High‑Concurrency Architecture with INFINI Gateway

This guide walks through why Elasticsearch should sit behind a gateway, compares native security with INFINI Gateway, presents a layered security model, and provides concrete configuration, Kubernetes deployment, high‑availability, high‑concurrency, and observability patterns to turn a runnable setup into a production‑grade, continuously‑evolvable Elasticsearch security solution.

AuthenticationElasticsearchINFINI Gateway
0 likes · 30 min read
Production-Ready Elasticsearch Security Hardening: TLS, Authentication, and High‑Concurrency Architecture with INFINI Gateway
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
May 21, 2026 · Backend Development

Optimizing Ozone S3 Gateway with Fast/Slow Dual‑Queue Isolation and Rate‑Limiting

The article presents a fast/slow dual‑queue isolation and water‑level rate‑limiting design for the Ozone S3 gateway, detailing separate thread pools, async handling, bucket‑level throttling, and comprehensive metrics that together improve service stability and throughput under mixed workloads.

Async ProcessingFast/Slow QueueJetty
0 likes · 10 min read
Optimizing Ozone S3 Gateway with Fast/Slow Dual‑Queue Isolation and Rate‑Limiting
Coder Trainee
Coder Trainee
May 18, 2026 · Cloud Native

Spring Cloud Microservices Tutorial – Sentinel for Fault Tolerance and Rate Limiting

This article walks through adding Alibaba Sentinel to a Spring Cloud microservice suite to protect against service outages, traffic spikes, and slow calls by configuring rate limiting, circuit breaking, and fallback mechanisms across user, order, and gateway services, with full Docker‑compose setup and testing steps.

Circuit BreakerFeignSentinel
0 likes · 14 min read
Spring Cloud Microservices Tutorial – Sentinel for Fault Tolerance and Rate Limiting
IT Services Circle
IT Services Circle
May 15, 2026 · Backend Development

When Splitting a System into 200 Microservices Almost Ruined the Company

The article uses a night‑market analogy to explain practical microservice design, covering domain‑based service decomposition, service discovery, communication protocols, data consistency strategies, fault‑tolerance, rate limiting, and monitoring, while warning against over‑splitting and unnecessary complexity.

Circuit Breakerdistributed tracingeventual consistency
0 likes · 14 min read
When Splitting a System into 200 Microservices Almost Ruined the Company
Java Tech Enthusiast
Java Tech Enthusiast
May 15, 2026 · Backend Development

How Splitting a System into 200 Microservices Almost Destroyed Our Company

The article uses a night‑market analogy to explain common microservice pitfalls—over‑splitting, poor service boundaries, fragile communication, data‑consistency challenges, fault‑tolerance, rate‑limiting, and monitoring—providing concrete examples, best‑practice rules, and Java code snippets to help teams avoid costly mistakes.

Circuit Breakerdistributed tracingmicroservices
0 likes · 15 min read
How Splitting a System into 200 Microservices Almost Destroyed Our Company
Linyb Geek Road
Linyb Geek Road
May 7, 2026 · Backend Development

How to Ensure High Availability When Third‑Party Services Keep Failing – An Interview‑Ready Guide

The article explains how to design a defensive layer that abstracts third‑party calls, implements client‑side rate limiting, retries, circuit breaking, observability, and mock testing, and shows how to present these practices effectively during a system‑design interview.

Circuit BreakerInterview Preparationhigh availability
0 likes · 21 min read
How to Ensure High Availability When Third‑Party Services Keep Failing – An Interview‑Ready Guide
Su San Talks Tech
Su San Talks Tech
May 6, 2026 · Backend Development

11 Essential Redis Use Cases Every Backend Engineer Should Know

This article walks through eleven practical Redis scenarios—from classic caching and distributed locks to rate limiting, leaderboards, timelines, social graph operations, lightweight queues, Bloom filters, hash‑based object storage, unique‑counting, and delayed tasks—providing code samples, advantages, drawbacks, and when to apply each pattern.

Bloom FilterCachingRedis
0 likes · 15 min read
11 Essential Redis Use Cases Every Backend Engineer Should Know
Old Meng AI Explorer
Old Meng AI Explorer
May 5, 2026 · Artificial Intelligence

Free AI APIs That Won’t Break Your Budget: A Complete Global Guide

This article compiles a comprehensive list of free AI APIs from China and abroad, explains the three hard truths about free tiers, details each provider’s token limits, rate limits, and ideal use cases, and offers practical tips for handling rate‑limiting, key management, and fallback strategies.

AICloud AIFree API
0 likes · 21 min read
Free AI APIs That Won’t Break Your Budget: A Complete Global Guide
MaGe Linux Operations
MaGe Linux Operations
May 3, 2026 · Backend Development

How to Implement Nginx Rate Limiting: Prevent Abuse, Scraping, and API Overload

This article explains how to use Nginx's built‑in limit_req and limit_conn modules—based on the leaky‑bucket algorithm—to protect APIs from malicious flooding, excessive crawling, sudden traffic spikes, and individual user abuse, covering configuration directives, practical examples, advanced scenarios, testing, and deployment best practices.

API SecurityNginxleaky-bucket
0 likes · 20 min read
How to Implement Nginx Rate Limiting: Prevent Abuse, Scraping, and API Overload
Cloud Architecture
Cloud Architecture
May 1, 2026 · Backend Development

Production Nginx for 10M+ QPS: Rate Limiting, Load Balancing, WebSocket, gRPC, CDN

This guide details how to build a production‑grade Nginx edge layer capable of handling over ten million queries per second, covering traffic shaping, connection reuse, multi‑level caching, sophisticated rate‑limiting, load‑balancing algorithms, WebSocket and gRPC handling, dynamic configuration, observability, container deployment, and migration paths to API gateways or service meshes.

CachingKubernetesNginx
0 likes · 52 min read
Production Nginx for 10M+ QPS: Rate Limiting, Load Balancing, WebSocket, gRPC, CDN
ITPUB
ITPUB
Apr 29, 2026 · Backend Development

How to Rescue a System When QPS Jumps 100× in 10 Minutes

When a service experiences a sudden 100‑fold QPS surge, this guide walks through immediate emergency measures such as rate limiting, circuit breaking, and traffic shedding, followed by systematic analysis of traffic origins, robust architectural redesign including horizontal scaling, micro‑service decomposition, sharding, pooling, caching, and asynchronous processing, and finally stress testing to ensure resilience.

CachingCircuit Breakinghorizontal scaling
0 likes · 13 min read
How to Rescue a System When QPS Jumps 100× in 10 Minutes
Ops Community
Ops Community
Apr 29, 2026 · Operations

Production-Ready Nginx Rate Limiting: Stop Crawlers, Block Malicious Requests, Protect APIs

This guide explains how to use Nginx's built‑in limit_req and limit_conn modules to implement production‑grade rate limiting, covering leaky‑bucket theory, IP and API‑key based limits, burst and nodelay handling, whitelist bypass, custom error responses, dry‑run testing, memory sizing, and the inherent limitations that may require Redis‑Lua or OpenResty extensions.

API protectionNginxanti‑crawler
0 likes · 21 min read
Production-Ready Nginx Rate Limiting: Stop Crawlers, Block Malicious Requests, Protect APIs
Architect's Tech Stack
Architect's Tech Stack
Apr 29, 2026 · Databases

Redis 8.0 Beyond Simple Caching: 16 Powerful Use Cases You Must Try

Redis 8.0 consolidates many previously external modules—JSON, time‑series, vector search, probabilistic data structures, and more—into a single package, and this article walks through 16 concrete scenarios ranging from field‑level cache expiration to AI‑ready vector similarity search, showing exact commands and when to prefer each feature.

CachingLeaderboardRedis
0 likes · 19 min read
Redis 8.0 Beyond Simple Caching: 16 Powerful Use Cases You Must Try
IoT Full-Stack Technology
IoT Full-Stack Technology
Apr 29, 2026 · Databases

16 Practical Redis Use Cases You Should Know

This article walks through sixteen common Redis scenarios—including caching hot data, sharing state across services, implementing distributed locks, generating global IDs, counting events, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, tagging, product filtering, and leaderboards—each illustrated with concrete commands and code snippets.

BitmapsCachingLeaderboard
0 likes · 9 min read
16 Practical Redis Use Cases You Should Know
dbaplus Community
dbaplus Community
Apr 28, 2026 · Backend Development

Designing High‑Availability for Unreliable Third‑Party Services

When downstream APIs are unstable and slow, this article walks through building a dedicated defensive layer that provides a unified abstraction, client‑side governance (rate limiting, retries with idempotency checks), comprehensive observability, and mock‑based testing to keep your system highly available and interview‑ready.

Circuit BreakerThird-party Integrationhigh availability
0 likes · 22 min read
Designing High‑Availability for Unreliable Third‑Party Services
Top Architect
Top Architect
Apr 28, 2026 · Backend Development

Elegant API Rate Limiting with Spring Interceptor and Redis

This article demonstrates a step‑by‑step implementation of API anti‑brush (rate limiting) using a Spring Interceptor combined with Redis, explains how to configure time windows and request limits, introduces a custom @AccessLimit annotation for fine‑grained control, discusses path‑parameter pitfalls, real‑IP handling, and shares practical testing results.

API SecurityInterceptorJava
0 likes · 20 min read
Elegant API Rate Limiting with Spring Interceptor and Redis
Data STUDIO
Data STUDIO
Apr 28, 2026 · Backend Development

FastAPI in Production: Auth, Rate Limiting, and Zero‑Downtime with One Codebase

This article walks through a complete production‑ready FastAPI setup, covering secure OIDC/JWKS authentication, Redis‑backed token‑bucket rate limiting, zero‑downtime rolling deployments on Docker/Kubernetes, and observability best practices such as request‑ID middleware and structured JSON logging.

AuthenticationDockerFastAPI
0 likes · 20 min read
FastAPI in Production: Auth, Rate Limiting, and Zero‑Downtime with One Codebase
AI Open-Source Efficiency Guide
AI Open-Source Efficiency Guide
Apr 27, 2026 · Backend Development

Turn Your Android Phone into an SMS Gateway with HTTPSMS and a Simple HTTP API

HTTPSMS is an open‑source SMS gateway that lets an Android phone act as a self‑hosted send/receive endpoint, controlled via a lightweight HTTP API, offering multi‑language SDKs, Docker deployment, AES‑256 encryption, rate limiting, message expiry and a feature‑by‑feature comparison with Twilio, cloud SMS services and DIY GSM modems.

AES-256AndroidDocker
0 likes · 7 min read
Turn Your Android Phone into an SMS Gateway with HTTPSMS and a Simple HTTP API
Coder Trainee
Coder Trainee
Apr 27, 2026 · Cloud Native

Spring Cloud Microservices Practice #6: Sentinel for Service Fault Tolerance and Rate Limiting

This article explains why service fault tolerance is essential in micro‑service architectures, compares Sentinel with Hystrix and Resilience4j, and provides step‑by‑step guidance on integrating Sentinel for circuit breaking, QPS and concurrency limiting, hot‑parameter control, system protection, and dynamic rule management with Nacos.

Circuit BreakingNacosSentinel
0 likes · 14 min read
Spring Cloud Microservices Practice #6: Sentinel for Service Fault Tolerance and Rate Limiting
Linyb Geek Road
Linyb Geek Road
Apr 25, 2026 · Operations

How to Build Stable SaaS Systems: Key Practices for Reliability

The article outlines practical methods for ensuring SaaS system stability, covering resource‑related issues, middleware reliability, pre‑release gray deployments, automated release procedures, comprehensive monitoring, load‑balancing strategies, degradation handling, rate limiting, chaos engineering, and SRE implementation.

SRESaaSchaos engineering
0 likes · 10 min read
How to Build Stable SaaS Systems: Key Practices for Reliability
AI Engineer Programming
AI Engineer Programming
Apr 22, 2026 · Artificial Intelligence

Free LLM API Tokens: Complete Provider List, Limits, and Usage Tips

This guide compiles free large‑language‑model APIs from official vendors and third‑party platforms, detailing each service's token quotas, rate limits, base URLs, usage restrictions, and available models, while offering practical advice on token optimization, multi‑platform rotation, rate‑limit handling, and key security.

AIFree APILLM
0 likes · 15 min read
Free LLM API Tokens: Complete Provider List, Limits, and Usage Tips
Coder Trainee
Coder Trainee
Apr 19, 2026 · Backend Development

How to Optimize Performance and Deploy a Production‑Ready Blog System

This article walks through a complete performance‑optimization and deployment pipeline for a Spring Boot blog, covering multi‑level caching with Caffeine and Redis, database indexing and cursor pagination, read‑write splitting, asynchronous processing, rate limiting, Docker multi‑stage builds, Nginx reverse‑proxy setup, Actuator monitoring, custom metrics, health checks, alerting, JMeter load testing, and JVM tuning.

CaffeineDockerPerformance Optimization
0 likes · 17 min read
How to Optimize Performance and Deploy a Production‑Ready Blog System
java1234
java1234
Apr 18, 2026 · Backend Development

Beyond Simple Caching: 8 Essential Redis Use Cases for Java Backend Engineers

This guide walks Java backend developers through Redis’s eight core scenarios—caching, distributed locks, rate limiting, session sharing, leaderboards, counters, message and delay queues, bitmap statistics, and geolocation—providing complete code, diagrams, and production‑grade best practices.

BitmapGEOLeaderboard
0 likes · 21 min read
Beyond Simple Caching: 8 Essential Redis Use Cases for Java Backend Engineers
Java Web Project
Java Web Project
Apr 18, 2026 · Information Security

How a Midnight SMS Scam Revealed the Need for a Multi‑Layer Anti‑Abuse System

A night‑time SMS billing attack that drained ¥11,500 in two hours exposed flaws in a naïve Session‑based verification design, prompting a detailed, five‑layer defense architecture that combines gateway rate limiting, Redis token‑bucket controls, advanced captcha tracking, device fingerprinting, blacklist automation, and honey‑pot tactics to raise attack costs.

CAPTCHANginxRedis
0 likes · 14 min read
How a Midnight SMS Scam Revealed the Need for a Multi‑Layer Anti‑Abuse System
Java Tech Workshop
Java Tech Workshop
Apr 16, 2026 · Backend Development

Implementing API Rate Limiting in Spring Boot with AOP

This tutorial walks through why API rate limiting is a critical first line of defense for backend services, compares fixed‑window and sliding‑window strategies, and shows how to create a custom @RateLimit annotation, utility classes, an AOP aspect, Redis or local storage, and unified exception handling, providing complete code and test scenarios for Spring Boot 2.7.x.

AOPFixed WindowJava
0 likes · 31 min read
Implementing API Rate Limiting in Spring Boot with AOP
Architect Chen
Architect Chen
Apr 13, 2026 · Backend Development

How to Make Spring Cloud Gateway Handle a Million Concurrent Requests

This article explains how Spring Cloud Gateway leverages a reactive, non‑blocking architecture, OS‑level tuning, zero‑copy networking, and built‑in rate‑limiting and circuit‑breaker features to reliably sustain million‑level concurrent traffic in production environments.

NettySpring Cloud Gatewayhigh concurrency
0 likes · 4 min read
How to Make Spring Cloud Gateway Handle a Million Concurrent Requests
Architect's Tech Stack
Architect's Tech Stack
Apr 10, 2026 · Backend Development

Unlock Redis: 12 Powerful Patterns Every Backend Engineer Should Know

Redis offers far more than simple key‑value caching; by leveraging its rich data structures—strings, hashes, lists, sets, sorted sets, bitmaps, HyperLogLog, GEO, and streams—developers can implement distributed locks, rate limiting, leaderboards, session storage, counters, geolocation, delayed queues, messaging, bloom filters, and more, all with concise commands.

CachingData StructuresLeaderboard
0 likes · 9 min read
Unlock Redis: 12 Powerful Patterns Every Backend Engineer Should Know
Top Architect
Top Architect
Apr 8, 2026 · Backend Development

How to Prevent Duplicate Submissions and Rate‑Limit APIs with the Guardian Spring Boot Starter

This article explains how the Guardian Spring Boot starter provides a lightweight solution for preventing duplicate API submissions and applying rate‑limiting, covering Maven dependencies, annotation and YAML configurations, key generation strategies, response handling modes, Redis versus local storage, context‑path compatibility, concurrency safety, and built‑in monitoring features.

API protectionBackendDuplicate Submission
0 likes · 16 min read
How to Prevent Duplicate Submissions and Rate‑Limit APIs with the Guardian Spring Boot Starter
java1234
java1234
Apr 5, 2026 · Databases

Beyond Caching: 16 Powerful Redis Use Cases

This article explores sixteen practical Redis applications—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, product tags, filtering, follow relationships, and ranking—demonstrating how Redis can serve as a versatile data store beyond simple caching.

BitmapsCachingData Structures
0 likes · 9 min read
Beyond Caching: 16 Powerful Redis Use Cases
Java Architect Handbook
Java Architect Handbook
Apr 4, 2026 · Backend Development

16 Powerful Redis Use Cases Every Backend Engineer Should Know

This article presents a comprehensive guide to 16 practical Redis applications—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, queues, lotteries, likes, product tagging, filtering, social graphs, and leaderboards—complete with command examples, code snippets, and visual illustrations to help developers implement these patterns efficiently.

BitmapLeaderboardRedis
0 likes · 11 min read
16 Powerful Redis Use Cases Every Backend Engineer Should Know
Java Companion
Java Companion
Apr 3, 2026 · Cloud Native

Why Every Microservice Architecture Needs an API Gateway

The article explains that without a gateway each microservice must duplicate authentication, rate‑limiting, logging and other cross‑cutting concerns, leading to maintenance overhead and security risks, and shows how a gateway centralises these functions while providing routing, load‑balancing, circuit‑breaking and observability, backed by real‑world code examples and a comparative analysis of popular gateway solutions.

API GatewayAuthenticationCircuit Breaking
0 likes · 19 min read
Why Every Microservice Architecture Needs an API Gateway
Cloud Architecture
Cloud Architecture
Mar 26, 2026 · Backend Development

Spring Boot 3 + WebFlux High-Concurrency API Architecture: From Reactive Theory to Production

This comprehensive guide explains how Spring Boot 3 + WebFlux can handle massive concurrent API traffic by leveraging event‑loop I/O, Reactive Streams back‑pressure, and a layered architecture that separates ingestion, processing, storage, and dispatch, while covering pitfalls, performance tuning, observability, and production‑grade best practices.

BackpressureSSESpring Boot
0 likes · 46 min read
Spring Boot 3 + WebFlux High-Concurrency API Architecture: From Reactive Theory to Production
Architect's Guide
Architect's Guide
Mar 26, 2026 · Backend Development

How to Prevent Duplicate Submissions and Rate‑Limit APIs with the Guardian Spring Boot Starter

This article explains how the open‑source Guardian starter provides a lightweight Spring Boot solution for anti‑repeat submission and API rate limiting, covering dependency setup, annotation and YAML configuration, key generation strategies, response handling, concurrency safety, extensible architecture, monitoring endpoints, and deployment options.

API protectionAnti repeat submitJava
0 likes · 16 min read
How to Prevent Duplicate Submissions and Rate‑Limit APIs with the Guardian Spring Boot Starter
Golang Shines
Golang Shines
Mar 19, 2026 · Databases

Top 10 Redis Use Cases with Go: Practical Guide

This guide walks through ten classic Redis scenarios—caching, session storage, rate limiting, leaderboards, message queues, Pub/Sub, real‑time analytics, distributed locks, geospatial queries, and shopping carts—providing Go code examples, best‑practice tips, and performance considerations for each pattern.

CachingGoLeaderboard
0 likes · 18 min read
Top 10 Redis Use Cases with Go: Practical Guide
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Mar 18, 2026 · Operations

Implementing Hierarchical QoS IP‑Port Granular Offload Rate Limiting with OVS and DPDK

This article explains how to design and implement hardware‑offloaded, IP‑ and port‑granular traffic shaping using Open vSwitch, OpenFlow meters, Mellanox HQoS, and DPDK, covering software limits, meter hierarchy, flow‑meter association, deletion workflows, RCU handling, and same‑host traffic considerations.

DPDKHQoSMeter Hierarchy
0 likes · 24 min read
Implementing Hierarchical QoS IP‑Port Granular Offload Rate Limiting with OVS and DPDK
SpringMeng
SpringMeng
Mar 15, 2026 · Backend Development

Boost Your Spring Boot APIs with a DIY Anti‑Duplicate and Rate‑Limiting Starter

Guardian is a lightweight Spring Boot starter that provides independent anti‑duplicate submission and rate‑limiting modules, offering annotation and YAML configuration, multi‑dimensional key scopes, customizable response modes, Redis or local storage, and built‑in monitoring, all illustrated with step‑by‑step code examples.

API protectionDuplicate SubmissionRedis
0 likes · 17 min read
Boost Your Spring Boot APIs with a DIY Anti‑Duplicate and Rate‑Limiting Starter
Cloud Architecture
Cloud Architecture
Mar 13, 2026 · Backend Development

Mastering Redis Rate Limiting: Token Bucket & Sliding Window Full Implementation Guide

This article provides a comprehensive, production‑ready walkthrough of implementing Redis‑based rate limiting using token bucket and sliding window algorithms, covering algorithm fundamentals, code examples, performance testing, multi‑layer architecture, dynamic configuration, and best‑practice recommendations for high‑traffic backend services.

BackendLuaRedis
0 likes · 43 min read
Mastering Redis Rate Limiting: Token Bucket & Sliding Window Full Implementation Guide
Code Wrench
Code Wrench
Mar 11, 2026 · Backend Development

Beego V2: Functional Routing, Redis AOP Rate Limiting & Toolbox Security

Discover how to transform a basic Beego V2 project into a high‑performance, concurrent service by replacing reflection‑based controllers with functional routing, implementing a distributed Redis‑Lua token‑bucket rate limiter via AOP filters, and securing the built‑in Toolbox with essential production hardening steps.

BeegoFunctional RoutingGo
0 likes · 6 min read
Beego V2: Functional Routing, Redis AOP Rate Limiting & Toolbox Security
Cloud Architecture
Cloud Architecture
Mar 6, 2026 · Backend Development

Ultimate Guide to Designing Nginx Architecture for 1 Million QPS

This article walks through the complete engineering process—from Linux kernel tweaks and network stack tuning to Nginx master‑worker design, layered load‑balancing, zero‑copy I/O, rate‑limiting, and OpenResty Lua extensions—demonstrating how to build a production‑grade system that reliably handles one million queries per second.

Linux kernelNginxhigh concurrency
0 likes · 9 min read
Ultimate Guide to Designing Nginx Architecture for 1 Million QPS
Architect's Guide
Architect's Guide
Mar 2, 2026 · Information Security

Essential API Security Measures and How to Implement Them

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

API SecurityAppIdData Validation
0 likes · 10 min read
Essential API Security Measures and How to Implement Them