This tutorial shows Go developers how to install the go-github library, create an authenticated client, handle pagination and rate limits, and perform core repository operations such as creating a repo, all with concise code examples and best‑practice tips.
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.
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.
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.
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.
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.
The article explains that achieving stable performance for Spring Cloud Gateway at a million‑request scale requires a reactive non‑blocking model, comprehensive rate‑limiting and circuit‑breaker mechanisms, and optimized connection management and routing to handle high concurrency efficiently.
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.
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.
The article explains that although Spring Cloud Gateway offers token‑bucket rate limiting via Redis, adding a coarse‑grained Nginx limit protects the gateway from traffic spikes, reduces JVM pressure, and ensures continuous flow control even during restarts or GC pauses.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
The article explains how confusion between concurrency, latency, and QPS leads to systems that crash under load, using a bank‑counter analogy and a flash‑sale case study to derive a performance formula and practical optimization techniques.
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.
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.
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.
When a system faces a sudden hundred‑fold increase in QPS, this guide walks backend engineers through emergency response, root‑cause analysis, robust design techniques, scaling options, and pressure testing to keep services stable and performant.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
LoongCollector’s OneTime file collection feature enables fast, reliable migration of historical logs, data back‑filling, and batch processing by scanning files once, using checkpoints for fault tolerance, configurable execution windows, and rate‑limiting to avoid impacting live data streams.
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.
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.
This article explains why rate limiting is essential for both physical venues and online services, outlines common throttling strategies such as circuit breaking, service degradation, delay processing, and privilege handling, compares caching, degradation, and limiting, and details popular algorithms and concrete code examples for implementing rate limiting in Java and Nginx/Lua environments.
The article introduces Guardian, a lightweight Spring Boot starter that provides independent anti‑duplicate‑submission and rate‑limiting modules, explains why a custom solution is preferable to raw Redis locks, and walks through annotation and YAML configurations, key generation, response handling, storage options, concurrency safety, and observability.
This postmortem explains how a Nginx connection‑saturation incident was initially misidentified as traffic surge, details the metrics and command‑line checks that revealed a connection‑lifecycle failure, and describes the step‑by‑step redesign of rate‑limiting, budgeting, monitoring, and run‑book procedures that restored stability.
This article presents four practical Go rate‑limiting implementations—a sliding‑window algorithm, a token‑bucket approach, the built‑in golang.org/x/time/rate package, and a Redis‑backed distributed limiter—complete with code samples, usage guidance, and recommendations for different deployment scenarios.
Moltbook is a pioneering AI‑only social platform that lets agents post, comment and like, built with a Next.js front‑end, RESTful API back‑end, semantic vector search, heartbeat checks, dual human/agent modes and strict rate‑limiting to encourage quality over quantity while addressing scalability and security challenges.
This guide walks you through implementing a complete stability engineering system for Go microservices—covering token‑bucket rate limiting, concurrency and Redis‑based throttling, circuit breakers with slow‑request detection, graceful degradation strategies, Kubernetes‑aware deployment, monitoring, dynamic configuration, and load‑testing to set safe thresholds.
The article analyzes why flash‑sale systems often crash under extreme traffic and presents a step‑by‑step solution using Spring Boot, Redis, and Lua that prevents overselling, pre‑warms stock, applies token‑bucket rate limiting, executes atomic stock deductions, and decouples order creation asynchronously while adding monitoring and safety measures.
This article explains how to create a non‑intrusive, configurable rate‑limiting component for Spring services by combining Spring AOP, a custom @RateLimit annotation, and Google Guava's RateLimiter, covering token‑bucket fundamentals, API usage, implementation details, common AOP pitfalls, and migration to distributed limiting.
This article presents a complete Spring Boot 3 solution for multi‑dimensional network bandwidth throttling using a manually implemented token‑bucket algorithm, custom HandlerInterceptor, HttpServletResponseWrapper, and RateLimitedOutputStream, with detailed code samples, configuration options, and performance tuning guidance.
This article explains how e‑commerce flash‑sale systems handle extreme concurrency by defining TPS requirements for different scales, applying a layered filtering architecture, and using techniques like CDN caching, rate limiting, Redis pre‑deduction, and minimal database writes to ensure stability.
The article compares four user‑level rate‑limiting approaches—Sentinel hotspot parameters, Sentinel ordinary flow control with cluster mode, Redis ZSet + Lua scripts, and Guava RateLimiter—explaining why Sentinel is unsuitable for long‑window low‑frequency limits and why Redis + Lua is the optimal solution for high‑traffic e‑commerce scenarios.
This guide explains how to use Nginx and OpenResty Lua scripts to implement rate limiting and circuit‑breaking for high‑concurrency services, detecting error rates and response latency, automatically opening and closing a 30‑second break window, and returning custom JSON responses when downstream services fail.
This article explains how Spring Cloud Gateway leverages asynchronous non‑blocking I/O, horizontal scaling, Redis‑based rate limiting, and circuit‑breaker patterns to sustain massive QPS, reduce latency, and improve system resilience in microservice architectures.
This article walks through building a Spring MVC interceptor that leverages Redis to enforce per‑IP request limits, explains configurable parameters, shows how to apply protection selectively via mapping rules or custom annotations, and discusses practical pitfalls such as sliding‑window logic, path‑parameter handling, and real‑IP detection.
This article examines why APIs are more than data pipes, outlines three essential design questions, and provides concrete strategies—including single‑purpose endpoints, clear naming, batch calls, async core logic, caching, compression, HTTPS, token authentication, rate limiting, versioning, and maintenance practices—to create stable, efficient, and secure APIs.
This article explains how to protect Go services from overload by implementing HTTP request rate limiting using the standard token‑bucket limiter, per‑IP throttling with a map and mutex, and a distributed approach with Redis and Lua scripts, complete with practical code examples and middleware integration.
This article explores five typical high‑concurrency, high‑availability scenarios—gRPC microservice communication, real‑time WebSocket messaging, API‑gateway rate limiting and circuit breaking, Redis‑Stream task queues, and Redis RedLock distributed locks—detailing the problems, Go‑centric solutions, code implementations, and supporting theory.
This article explains the principles and implementation details of common rate‑limiting algorithms—token bucket and sliding‑window counting—including their core concepts, key processes, Java code examples, and how to extend them to distributed scenarios with Redis Lua scripts.
This guide walks backend engineers through configuring Nginx for reverse proxy, load balancing, static‑resource handling, rate limiting with IP blacklists, and HTTPS encryption, providing ready‑to‑use code snippets and practical deployment steps to keep services stable and secure.
The article explains what cache penetration is in high‑concurrency architectures, why it occurs, and presents four practical mitigation strategies—including caching empty values, using Bloom filters, validating request data, and applying rate‑limiting—to protect backend databases from overload.
This article walks through the design and implementation of a complete seckill (flash‑sale) system built on SpringBoot, MyBatis, MySQL, RabbitMQ and Redis, covering double MD5 password hashing, distributed sessions, unified exception handling, caching strategies, memory flags, pre‑decrement inventory, asynchronous order processing, oversell prevention, and rate limiting, with code snippets and UI screenshots.
Learn how to protect your web application from brute‑force login attacks by configuring Nginx rate limiting, with step‑by‑step instructions, example configurations, testing methods, custom error pages, and best‑practice tips such as IP whitelisting, HTTPS enforcement, and complementary security measures.
This guide walks backend engineers through six real‑world Nginx configurations—reverse proxy and load balancing, static asset handling, rate limiting with IP black/white lists, HTTPS encryption, and step‑by‑step deployment—showing how to secure, accelerate, and stabilize services.
This article explains practical techniques to stop Redis cache penetration—including using Bloom filters to pre‑check keys, caching empty responses, applying request rate limiting, and adding authentication checks—while outlining each method's advantages and drawbacks.
