Skip to content
Tagged articles

rate limiting

500 articles · Page 1 of 5
Architect's Guide
Architect's Guide
Nov 8, 2026 · Backend Development

Implementing Spring Boot API Rate Limiting with Redis and Custom Annotations

This article demonstrates how to implement API rate limiting in Spring Boot using Redis for request counting and a custom @RequestLimit annotation with an interceptor to enforce limits per user session, including complete code examples for the annotation, interceptor, configuration, and controller usage.

API SecurityBackendCustom Annotation
0 likes · 8 min read
Implementing Spring Boot API Rate Limiting with Redis and Custom Annotations
Raymond Ops
Raymond Ops
Nov 7, 2026 · Operations

Nginx Log Analysis: Quickly Identify Abnormal Requests & Attack Sources

This comprehensive guide covers Nginx log analysis techniques for identifying abnormal requests and attack sources, including custom log formats, command-line analysis with awk/grep/sort, attack pattern detection (CC, scanners, SQL injection), rate limiting and blocking configurations, log rotation, troubleshooting workflows, and production best practices.

NginxSecurityattack-detection
0 likes · 51 min read
Nginx Log Analysis: Quickly Identify Abnormal Requests & Attack Sources
Ops Community
Ops Community
Nov 7, 2026 · Backend Development

Building Enterprise Gateways with OpenResty: Rate Limiting, Auth & Observability

A comprehensive guide to consolidating multi-layer Nginx into a single programmable OpenResty gateway, covering Lua request phases, shared-memory rate limiting algorithms (leaky bucket, token bucket, distributed), dynamic configuration, authentication ordering, risk control tiers, performance tuning, and six production troubleshooting scenarios with concrete fixes.

LuaNginxOpenResty
0 likes · 114 min read
Building Enterprise Gateways with OpenResty: Rate Limiting, Auth & Observability
Architecture Pony
Architecture Pony
Nov 6, 2026 · Backend Development

Sentinel Internals: Sliding Window, Leaky Bucket & Circuit Breaker State Machine

This article deep-dives into Sentinel's core mechanisms including sliding window statistics, three rate-limiting algorithms, circuit breaker state machine, Slot chain execution flow, hotspot parameter limiting, rule persistence modes, Gateway/Feign integration, threshold calculation, and common pitfalls with troubleshooting steps.

Leaky BucketMicroservices ResilienceSentinel
0 likes · 45 min read
Sentinel Internals: Sliding Window, Leaky Bucket & Circuit Breaker State Machine
LuTiao Programming
LuTiao Programming
Nov 6, 2026 · Information Security

Complete Java Account Security Recovery: Reclaiming Accounts After Compromise

This article details a comprehensive Java implementation for secure account recovery, covering threat modeling, recovery challenge design, assurance scoring, leveraging pre-compromise credentials like Passkeys and recovery codes, security versioning to invalidate attacker sessions, post-recovery audits, and rate limiting to prevent abuse.

Java securityOWASP guidelinesPasskey
0 likes · 28 min read
Complete Java Account Security Recovery: Reclaiming Accounts After Compromise
Architecture Pony
Architecture Pony
Nov 5, 2026 · Backend Development

Spring Cloud Gateway Internals: Reactive Model, Filter Chains & High-Concurrency Tuning

This article analyzes Spring Cloud Gateway's reactive architecture through three production incidents, detailing route predicates, filter chain mechanics, source code flow, and four critical tuning dimensions—thread model, connection pooling, timeout hierarchy, and off-heap memory—to prevent gateway failures under high concurrency.

Connection PoolFilter ChainHigh Concurrency Tuning
0 likes · 39 min read
Spring Cloud Gateway Internals: Reactive Model, Filter Chains & High-Concurrency Tuning
Raymond Ops
Raymond Ops
Nov 5, 2026 · Operations

Nginx Load Balancing for LLM Instances: Configuration, Pitfalls, and Best Practices

This article provides a comprehensive guide to configuring Nginx as a load balancer for multiple large language model instances, covering upstream equivalence checks, algorithm selection, proxy settings for streaming, health checks, logging, rate limiting, session affinity, config change procedures, maintenance draining, troubleshooting common errors, and validation standards.

LLMLarge Language ModelsNginx
0 likes · 34 min read
Nginx Load Balancing for LLM Instances: Configuration, Pitfalls, and Best Practices
Java Tech Enthusiast
Java Tech Enthusiast
Nov 4, 2026 · Backend Development

Java SMS One-Click Login: Complete Production-Ready Implementation with Rate Limiting & Anti-Brute Force

This article provides a complete Java implementation of SMS one-click login using Spring Boot 3, Redis, and JWT, covering business flow, configuration, Redis key design, core service code with rate limiting, blacklist, daily limits, one-time verification codes, login verification with JWT issuance, controller endpoints, production security optimizations including Lua atomic scripts, graphical captcha, channel fallback, risk control, and compliance, plus extension directions like carrier authentication and anomaly detection.

Anti-Brute ForceJWTJava
0 likes · 11 min read
Java SMS One-Click Login: Complete Production-Ready Implementation with Rate Limiting & Anti-Brute Force
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Nov 1, 2026 · Backend Development

Designing Production-Grade APIs: Contracts, Security, Idempotency & Rate Limiting with Code

This comprehensive guide covers designing production-ready APIs from contract design and security (HMAC-SHA256 signatures, nonce replay protection) to idempotency (five patterns with Redis Lua), distributed rate limiting (token bucket, sliding window), observability (TraceID, logging, monitoring), and versioning strategies, with production-ready Java code examples.

API designIdempotencyJava
0 likes · 39 min read
Designing Production-Grade APIs: Contracts, Security, Idempotency & Rate Limiting with Code
Code Farming
Code Farming
Oct 29, 2026 · Backend Development

Why Financial Microservices Collapse During Big Promotions: A 5-Step Governance Blueprint

This article breaks down financial-grade microservices governance into five steps: identifying five core pain points, selecting the right service-oriented architecture evolution path, building a service registry with Nacos, implementing traffic control via rate limiting, circuit breaking, and degradation using Sentinel, and applying four fault-tolerance strategies plus canary releases to ensure stability during high-concurrency events.

Circuit BreakingFault ToleranceNacos
0 likes · 7 min read
Why Financial Microservices Collapse During Big Promotions: A 5-Step Governance Blueprint
LuTiao Programming
LuTiao Programming
Oct 29, 2026 · Backend Development

Java SMS One-Click Login: Complete Implementation with Rate Limiting & Anti-Brute Force

This article provides a complete Java implementation of SMS one-click login using Spring Boot 3, Redis, and JWT, covering business flow, configuration, Redis key design, code for verification code generation, rate limiting, blacklist, and login validation, plus production security optimizations like Lua scripts, CAPTCHA, channel fallback, and compliance.

Anti-Brute ForceJWTJava
0 likes · 10 min read
Java SMS One-Click Login: Complete Implementation with Rate Limiting & Anti-Brute Force
Architecture Pony
Architecture Pony
Oct 21, 2026 · Backend Development

Building a Spring Boot Starter from Scratch: Auto-Configuration, Conditional Assembly & Rate-Limiter Example

This comprehensive guide walks through creating a production-ready Spring Boot 3.x starter, covering auto-configuration mechanics, conditional annotations, configuration properties, registration files, and a complete token-bucket rate-limiter implementation with AOP, plus debugging tips and common pitfalls.

AOPAuto-ConfigurationConditional Assembly
0 likes · 53 min read
Building a Spring Boot Starter from Scratch: Auto-Configuration, Conditional Assembly & Rate-Limiter Example
Alibaba Cloud Infrastructure
Alibaba Cloud Infrastructure
Oct 20, 2026 · Operations

How ACK Automates Fault Self-Healing Across Heterogeneous GPU Clusters at Scale

This article details Alibaba Cloud ACK's fault self-healing system for heterogeneous compute clusters, covering its Kubernetes-native architecture, multi-layer detection and event conversion, orchestrated repair workflows with stepwise authorization, rate limiting and circuit breaking, full observability, and practical deployment strategies to maximize effective compute throughput.

ACKCircuit BreakingGPU clusters
0 likes · 64 min read
How ACK Automates Fault Self-Healing Across Heterogeneous GPU Clusters at Scale
Top Architect
Top Architect
Oct 17, 2026 · Backend Development

Elegant API Rate Limiting with Spring Interceptor, Redis & Custom Annotations

This article demonstrates building an elegant API rate limiter in Spring Boot using interceptors and Redis, evolving from a basic fixed-window implementation to a flexible annotation-driven design supporting per-endpoint limits, class-level defaults, and solutions for path parameters and sliding window logic.

API SecurityCustom AnnotationInterceptor
0 likes · 21 min read
Elegant API Rate Limiting with Spring Interceptor, Redis & Custom Annotations
Cilantro Loves Linux
Cilantro Loves Linux
Oct 15, 2026 · Information Security

System Attack-Defense Architecture: Multi-Layer Security Patterns from CAPTCHA to Replay Prevention

This chapter from Yin Hongliang's Architecture Fundamentals details attack models like SMS abuse, brute force, and replay attacks, then explains layered defenses including risk-based CAPTCHA, distributed verification with one-time credentials, idempotency keys, signature validation, and multi-dimensional rate limiting with circuit breakers.

CAPTCHAIdempotencydefense in depth
0 likes · 9 min read
System Attack-Defense Architecture: Multi-Layer Security Patterns from CAPTCHA to Replay Prevention
Architect's Guide
Architect's Guide
Oct 15, 2026 · Backend Development

Nginx Rate Limiting Mastery: Leaky Bucket, Burst Handling & Dynamic Throttling

This guide covers Nginx rate limiting via ngx_http_limit_req_module (leaky bucket algorithm), connection limiting with ngx_http_limit_conn_module, and bandwidth throttling using limit_rate, limit_rate_after, and proxy_limit_rate, including burst handling, nodelay, whitelists, and dynamic rate control via map variables.

Dynamic ConfigurationLeaky BucketNginx
0 likes · 13 min read
Nginx Rate Limiting Mastery: Leaky Bucket, Burst Handling & Dynamic Throttling
liandk
liandk
Oct 15, 2026 · Backend Development

AI-Generated Cache & Rate Limiting Code: Hidden Concurrency Bugs Exposed by Stress Testing

This postmortem reveals how AI-generated Redis caching and rate limiting code for a real estate query API passed unit tests but collapsed under 200 concurrent requests, exposing critical flaws in Bloom filter synchronization, mutex lock recursion, random expiration logic, and non-atomic rate limiting — with fixes using Redisson, Lua scripts, and async hot-key refresh.

AI-generated codeRedis cachingcache avalanche
0 likes · 11 min read
AI-Generated Cache & Rate Limiting Code: Hidden Concurrency Bugs Exposed by Stress Testing
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.

Message QueueRediscache protection
0 likes · 17 min read
High-Concurrency Flash Sale Architecture: Layered Rate Limiting, Overselling Prevention & Cache Protection
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Sep 29, 2026 · Backend Development

10 System Design Questions That Decide Big Tech Interview Success

This article dissects 10 high-frequency system design questions — seckill, short URL, distributed ID, delayed tasks, leaderboard, real-time push, short-video feed, sharding, rate limiting, and config center — with architecture diagrams, core code, and comparative solutions for each.

Backend ArchitectureDistributed SystemsMessage Queue
0 likes · 73 min read
10 System Design Questions That Decide Big Tech Interview Success
samdeepthink
samdeepthink
Sep 28, 2026 · Backend Development

Java Semaphore Decoupling: Thread-Agnostic Permits vs. Lock Coupling

This article explains Java Semaphore's core decoupling property—where any thread can acquire or release permits—contrasting it with ReentrantLock's thread-owned locking, demonstrates with Java 17 code examples, and shows real-world rate-limiting applications in Sentinel, Dubbo, and Tomcat.

ConcurrencyDecouplingJava
0 likes · 8 min read
Java Semaphore Decoupling: Thread-Agnostic Permits vs. Lock Coupling
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Sep 27, 2026 · Fundamentals

Complete Algorithm & Data Structure Interview Guide: From Arrays to Distributed Systems with Java Implementations

This comprehensive 30,000-word guide covers 9 core modules — data structures, sorting, search algorithms, algorithm paradigms, string algorithms, hash engineering, rate limiting, distributed IDs, and massive data processing — with Java code, complexity tables, and interview-focused explanations for big-tech preparation.

AlgorithmsData StructuresDatabase Indexing
0 likes · 76 min read
Complete Algorithm & Data Structure Interview Guide: From Arrays to Distributed Systems with Java Implementations
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
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Sep 24, 2026 · Backend Development

Circuit Breaker & Degradation Architecture: From Production Avalanche Postmortems to Enterprise-Grade Protection

This article analyzes three real production incidents from e-commerce promotions to expose critical flaws in circuit breaker and degradation architectures, detailing the dangers of half-open state probing, configuration hot-update inconsistency, and unbounded business degradation, then presents a three-layer protection model with custom recovery strategies and governance checklists.

Distributed SystemsFault ToleranceHigh Availability
0 likes · 23 min read
Circuit Breaker & Degradation Architecture: From Production Avalanche Postmortems to Enterprise-Grade Protection
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.

AOPDistributed SystemsFail-Open
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.

CC AttackLeaky BucketNginx
0 likes · 42 min read
Nginx Rate Limiting in Practice: Defending Against CC Attacks and Traffic Spikes
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Sep 20, 2026 · Backend Development

CAP Theorem Debunked: Not 'Choose 2 of 3' — Master 10 Core Distributed System Topics for Interviews

This comprehensive guide corrects the common CAP theorem misconception, then deep-dives into 10 high-frequency distributed system topics — CAP/BASE, distributed IDs (UUID to Meituan Leaf), distributed locks (DB, Redis, ZooKeeper, Etcd), distributed transactions (2PC to RocketMQ), consistent hashing, rate limiting algorithms, load balancing, circuit breaking (Hystrix vs Sentinel), configuration centers, and distributed tracing — with 30+ diagrams, comparison tables, code snippets, and production pitfalls.

CAP theoremDistributed LocksDistributed Systems
0 likes · 67 min read
CAP Theorem Debunked: Not 'Choose 2 of 3' — Master 10 Core Distributed System Topics for Interviews
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.

IdempotencyMessage QueueRetry Pattern
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.

IdempotencyJavaNotification Service
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
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Aug 23, 2026 · Backend Development

Microservice Traffic Defense: 5-Layer Rate Limiting & Risk Control for Production Systems

This article details a production-grade five-layer traffic protection architecture for microservices, covering hierarchical rate limiting algorithms, IP and user-level sliding window implementations with Redis Lua scripts, dynamic blacklist mechanisms, interface classification (P0/P1/P2), and a real incident review where crawlers bypassed global limits and were defeated by fine-grained controls.

Production ArchitectureRedisRisk Control
0 likes · 15 min read
Microservice Traffic Defense: 5-Layer Rate Limiting & Risk Control for Production Systems
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.

AOPDistributed SystemsLua
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.

GoKubernetescircuit breaker
0 likes · 42 min read
Go Microservice Stability: Rate Limiting, Circuit Breaking, Degradation and K8s Production Architecture
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 16, 2026 · Backend Development

Designing Robust External APIs: RESTful, Security, Idempotency & Rate Limiting

This comprehensive guide covers production-grade external API design including RESTful conventions, unified response structures, security mechanisms (HMAC signatures, replay prevention), idempotency patterns, rate limiting, circuit breaking, version management, and monitoring—with practical Java/Spring code implementations and interview-focused technical deep-dives.

API SecurityAPI VersioningCircuit Breaking
0 likes · 31 min read
Designing Robust External APIs: RESTful, Security, Idempotency & Rate Limiting
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 15, 2026 · Backend Development

Defending SMS APIs from Abuse: Multi-Layer Protection with Redis+Lua Token Bucket & Bloom Filters

A comprehensive guide to protecting SMS interfaces from malicious flooding, covering emergency response, multi-layer defense (frontend to third-party), business logic optimization, monitoring, and production-ready code for distributed token buckets, Bloom filters, and sliding-window circuit breakers.

Bloom filterDistributed SystemsLua Scripting
0 likes · 29 min read
Defending SMS APIs from Abuse: Multi-Layer Protection with Redis+Lua Token Bucket & Bloom Filters
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 14, 2026 · Backend Development

API Flood Protection: Emergency Mitigation, Multi-Layer Defense & Rate Limiting Algorithms

This article provides a comprehensive guide to handling API abuse, covering emergency mitigation within three minutes, a multi-layer defense architecture, comparison of four rate limiting algorithms, practical implementations using Redis+Lua token bucket, Sentinel, and Guava Bloom filter, cache protection strategies, idempotency design, and a simulated interview scenario with code examples for distributed rate limiting and replay attack prevention.

API protectionBloom filterDistributed Systems
0 likes · 28 min read
API Flood Protection: Emergency Mitigation, Multi-Layer Defense & Rate Limiting Algorithms
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 13, 2026 · Backend Development

Defending Against Malicious Traffic Attacks: 5-Layer Architecture, Production Code & Interview Guide

This article provides a comprehensive four-phase strategy (emergency mitigation, root cause analysis, targeted remediation, long-term defense) for handling malicious traffic attacks on PC websites, detailing a five-layer defense architecture (CDN, WAF, Gateway, Service, Data) with production-ready code for Nginx rate limiting, Spring Cloud Gateway + Sentinel, Resilience4j circuit breaking, Redis cache protection, and API signature verification, plus interview-focused technical deep-dives.

RedisResilience4jSentinel
0 likes · 38 min read
Defending Against Malicious Traffic Attacks: 5-Layer Architecture, Production Code & Interview Guide
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 SecurityLeaky BucketNginx
0 likes · 22 min read
How to Implement Nginx Rate Limiting: Protect Against Brute‑Force, Crawlers, and Traffic Spikes
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Aug 10, 2026 · Backend Development

Microservices HA: Rate Limiting, Circuit Breaking, Degradation & Fallback with Sentinel

This article details a complete microservices high-availability system using Sentinel, covering dual-layer rate limiting, circuit breaking with three states, active degradation strategies, and fallback methods to prevent cascade failures during traffic spikes and downstream failures.

Cascade FailureCircuit BreakingHigh Availability
0 likes · 16 min read
Microservices HA: Rate Limiting, Circuit Breaking, Degradation & Fallback with Sentinel
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.

Fault Tolerancecircuit breakerdebounce
0 likes · 8 min read
Microservice Resilience: Rate Limiting, Circuit Breaker, Degradation & Debounce
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 8, 2026 · Backend Development

Production API Overload: Emergency Response, Root Cause Analysis & Resilience Patterns

A comprehensive guide to handling production API overload covering emergency mitigation (rate limiting, degradation, circuit breaking), root cause diagnosis via monitoring and tracing, long-term optimizations (caching, async, DB tuning), with practical Java code for Sentinel, Caffeine+Redis, CompletableFuture, and Bloom filters, plus interview-ready troubleshooting frameworks.

Bloom filterCaffeineCompletableFuture
0 likes · 32 min read
Production API Overload: Emergency Response, Root Cause Analysis & Resilience Patterns
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.

Gray ReleaseHigh AvailabilityNginx
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 GatewayZero-Copyevent-driven
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.

Backend ArchitectureCircuit BreakingKafka
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.

Distributed SystemsIdempotencyLua
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.

LLMNginxOpenAI compatible
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.

BackendRedisRisk Control
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 breakerdegradation
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 MemoryTimeoutlarge language model
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.

Asynchronous ProcessingBackend ArchitectureHorizontal Scaling
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 GatewayAuthenticationRouting
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 agentsOpenSpecWorkflow
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 GatewayService Discoverycircuit breaker
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.

Backend ArchitectureOutboxRedis
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.

Leaky BucketMessage Queueadaptive throttling
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.

Leaky BucketMessage Queueadaptive throttling
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 SDKHorizontal ScalingMultithreading
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.

CC AttackNginxOpenResty
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.

KubernetesService Discoveryarchitecture
0 likes · 7 min read
Why Microservices Matter: Core Architecture and Key Technologies Explained
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Jun 23, 2026 · Backend Development

Microservices Beyond Theory: Big Tech Production Hard Truths

A 10-year big-tech backend veteran reveals why 90% of developers only memorize microservice concepts but fail at production implementation, covering service decomposition pitfalls, fault tolerance patterns, distributed transaction strategies, and high-availability architecture with concrete configurations and real incident lessons.

DDDDistributed SystemsFault Tolerance
0 likes · 16 min read
Microservices Beyond Theory: Big Tech Production Hard Truths
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 filterGeospatial
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.

KubernetesMessage QueueRedis
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.

Distributed SystemsKafkaMessage Queue
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.

BackendIdempotencyPeak 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 theoremCoupon SystemDistributed Systems
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.

Distributed SystemsGuavaRedis
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.

CDNRedisdistributed architecture
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 BreakingKubernetesMessage Queue
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 BreakingFault ToleranceSentinel
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 GatewayNettySecurity
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
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.

Fault ToleranceFeignSentinel
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
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 filterRedisSorted Set
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.

AIFree APIModel Aggregation
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 SecurityLeaky BucketNginx
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.

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

Circuit BreakingHorizontal Scalingcaching
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 protectionLeaky BucketNginx
0 likes · 21 min read
Production-Ready Nginx Rate Limiting: Stop Crawlers, Block Malicious Requests, Protect APIs