The article examines the delayed double‑delete cache invalidation technique, reveals its hidden risk of cache‑penetration‑induced database load, compares Facebook's lease‑based solution and Uber's version‑number approach, and advises when the method is appropriate for high‑traffic systems.
This article examines the evolution of Redis distributed lock implementations—from the basic SETNX command to atomic SET with Lua scripts and the feature‑rich Redisson framework—detailing core requirements, common pitfalls, Go code samples, and production‑grade recommendations.
Developers favor NeoVim because it offers better project maintenance, built‑in LSP support, Lua‑based plugins, parallel startup, standardized configuration locations, performance optimizations, and more sensible default settings compared to Vim.
This article reveals seven critical pitfalls that can cripple Nginx+Lua gray‑release deployments—ranging from memory leaks and blocking I/O to uneven traffic hashing, configuration reload races, cross‑datacenter latency, session stickiness issues, and blind‑spot monitoring—while providing concrete Lua scripts, Nginx configurations, monitoring commands, and step‑by‑step remediation strategies.
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 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 the fundamental differences between Nginx and OpenResty, compares their features, performance, and programming models, and provides practical guidance on selecting the right tool for static serving, reverse‑proxying, or complex business‑logic workloads.
The article examines Cloudflare’s December 2025 outage caused by a nil‑pointer bug hidden in Lua code, compares how Go and Rust would handle the same scenario, and extracts key operational lessons about global configuration, dynamic language risks, and the safety benefits of strong type systems.
This guide explains three practical ways to achieve dynamic IP blocking in Nginx—using Fail2ban, Lua with Redis, and Nginx's built‑in limit modules—detailing configuration steps, code examples, advantages, drawbacks, and best‑practice recommendations for various deployment scenarios.
This article explores four powerful Redis batch query methods—MGET, HMGET, pipeline, and Lua scripting—detailing their advantages, usage examples in Spring Boot, and practical considerations such as network latency reduction, client simplification, transaction performance, and atomic execution to enhance system efficiency under high-concurrency workloads.
This article examines seven hidden risks when implementing gray releases with Nginx and Lua—memory leaks, blocking operations, uneven hash distribution, hot‑update atomicity, cross‑data‑center latency, session‑stickiness conflicts, and monitoring blind spots—and provides concrete Lua code fixes, Nginx configurations, monitoring scripts, and best‑practice recommendations to ensure reliable, performant deployments.
This guide walks through constructing a high‑performance, cost‑effective enterprise‑level Web Application Firewall using OpenResty, covering why OpenResty is ideal, core architecture, modules for request lifecycle management, IP control, rate limiting, SQL injection and XSS detection, intelligent CC protection, monitoring, performance tuning, deployment tips, real‑world case study, and future enhancements.
This article explains how to evaluate system performance bottlenecks, choose between hard and soft rate‑limiting, and implement a non‑intrusive, high‑concurrency traffic‑control solution using OpenResty, Lua scripts, and Redis, covering architecture design, queue management, rate limiting, resource release, and performance testing.
This article explains load balancing concepts, why to use it, HAProxy's features and limitations, Lua extensions, step‑by‑step installation on CentOS, service setup, detailed configuration sections, logging options, and how to organize large HAProxy setups with sub‑configuration files.
This tutorial explains how to integrate Lua scripts into Java applications and how to call Java code from Lua, covering the LuaJ and LuaJava libraries, Maven dependencies, code examples for executing Lua, passing functions, dynamic extensions, and automatic script upgrades.
This article walks through designing and implementing an enterprise‑grade API gateway with Nginx and OpenResty, covering architecture, dynamic routing, load balancing, rate limiting, circuit breaking, authentication, request transformation, caching strategies, observability, high‑availability deployment, and real‑world performance results.
This guide explains how to create a dynamic IP blacklist that blocks malicious crawlers or users by rejecting requests from listed IPs, supports configurable expiration, and is implemented using Nginx (OpenResty), Lua scripts, and Redis for shared, lightweight, and scalable protection.
This article explains how to build a dynamic IP blacklist using Nginx, Lua scripts, and Redis, covering the problem definition, environment setup, design choices, Nginx configuration, Lua script implementation, testing, and extensions such as use‑case scenarios and advanced features.
This guide explains how to create a dynamic IP blacklist that blocks malicious crawlers and users by configuring Nginx with Lua scripts and a Redis store, covering requirements, environment setup, design options, configuration files, Lua code, summary of benefits, use cases, and advanced extensions.
This article analyzes current system performance bottlenecks, compares hard‑rate‑limiting and flexible queuing strategies, and presents a non‑intrusive traffic‑control solution built with OpenResty+Lua and Redis that offers zero‑code changes, high performance, scalability, and real‑time visual feedback for high‑concurrency scenarios.
This article explains how OpenResty, built on Nginx and Lua, can be used in production to implement interface authentication, traffic control, and request logging, detailing practical implementation steps, configuration examples, and code snippets that help improve service reliability and operational efficiency.
This article introduces Easy-Cache, a Spring-AOP based caching framework that provides annotation-driven, multi-level Redis and local cache with dynamic upgrade/downgrade, elastic expiration, and Lua-script-ensured data consistency, eliminating repetitive cache code and handling failures, cache penetration, breakdown, and eventual consistency challenges.
This article presents a hands‑on guide to using OpenResty—Lua‑enhanced Nginx—for implementing static and dynamic blacklists, fine‑grained rate limiting, A/B testing via upstream selection, and real‑time service quality monitoring, all with production‑ready code examples.
This article introduces Easy-Cache, a Spring‑AOP based caching framework that eliminates repetitive cache code by offering annotation‑driven operations, multi‑level Redis and local caches, dynamic upgrade/downgrade, elastic expiration, and Lua‑script‑backed consistency mechanisms for high‑availability distributed systems.
This article explains the role of an access gateway, outlines its architecture and core functions, and demonstrates how to design and implement a dynamic, plugin‑based gateway using OpenResty (Nginx + Lua), including routing, shared data, and dynamic upstream management.
This article walks through the design, pitfalls, and step‑by‑step implementation of a token‑bucket rate‑limiting middleware for the Webman PHP framework, highlighting the need for atomic Redis operations and showing how a Lua script resolves concurrency issues in distributed environments.
This article explains why rate limiting is critical for micro‑service architectures, compares implementations across Dubbo, Spring Cloud, Guava, Sentinel and Redis+Lua, and shows how to build reusable AOP annotations and a Spring‑Boot starter to apply throttling consistently across services.
This article explains how to implement a precise sliding‑window rate‑limiting algorithm using Redis Sorted Sets, detailing the problem scenario, the algorithm steps, Lua script implementation, Java integration, and practical extensions for high‑performance backend services.
This article explains how to implement distributed locks using Redis, covering basic SETNX/EXPIRE techniques, common pitfalls, atomic Lua scripts, the RedLock algorithm, and practical Redisson usage, while providing Java code examples and best‑practice recommendations.
This article explains the concept of rate limiting, compares five common algorithms—including fixed‑window, sliding‑log, sliding‑window counter, token bucket and leaky bucket—covers distributed designs using Redis and Lua scripts, and provides complete FastAPI implementation and pytest tests for both fixed‑window and sliding‑log strategies.
Lua, a lightweight scripting language born in Brazil in 1993, overcame early obscurity to become a globally adopted tool for game development, embedded systems, and diverse applications, illustrating how a small team can solve a universal need and achieve worldwide success.
This guide explains step‑by‑step how to set up a Web Application Firewall by installing LuaJIT, ngx_devel_kit, lua‑nginx‑module, compiling Nginx with Lua support, fixing common errors, and optionally using OpenResty, followed by configuring and testing the ngx_lua_waf module.
This guide explains how to use Nginx, Lua (via OpenResty), and Redis to automatically block any IP that exceeds 60 requests per minute, storing the blacklist in Redis with a default one‑day ban and providing performance optimizations and testing steps.
This article explains how to integrate Lua scripts into a Spring Boot application to leverage Redis's atomic execution, reduce network overhead, and improve performance, covering Lua fundamentals, reasons to choose Lua, practical use‑cases, step‑by‑step implementation, error handling, security considerations, and best practices.
This article explains how to set up a dynamic IP blacklist using Nginx, Lua scripts, and Redis, covering environment preparation, design options, configuration of nginx.conf, Lua script implementation, and advanced features such as rate limiting, white‑listing, and automated detection to protect servers from malicious traffic.
This article explains how to design and implement a business-specific rate‑limiting component in Kotlin using Redis Lua scripts and Spring AOP annotations, covering the motivation, rule definitions, counting strategies, Lua script details, annotation creation, and a practical usage example.
This article details how Ctrip's Soft Load Balancer (SLB) transitioned from a simple Nginx reverse‑proxy to a multi‑datacenter, dynamic routing gateway using OpenResty, Lua scripts, and a three‑layer architecture that eliminates reloads and supports high‑frequency configuration updates.
This article introduces a comprehensive Spring Boot 3 practical case collection and walks through building a reentrant, auto‑renewing distributed lock using Redis and Lua scripts, providing full code snippets and configuration guidance for robust backend concurrency control.
This article walks through the problem of locking out users after multiple failed login attempts, explains why IP‑based locking with Redis and Lua scripts is effective, and provides a complete Spring Boot implementation—including front‑end HTML, custom annotations, AOP aspect, Redis configuration, and sample controller code—to enforce a configurable login‑attempt limit.
This article introduces the lightweight Lua scripting language, outlines its key features and typical use cases, and provides a complete example of using Redis together with Lua scripts (and a Java client) to enforce IP‑based login‑attempt limits for improved security.
This article explains how to integrate Lua scripts into Spring Boot applications with Redis, covering Lua fundamentals, advantages of Lua in Redis, practical use cases, step‑by‑step implementation in Spring Boot, performance optimizations, error handling, security considerations, and best practices for reliable backend development.
This tutorial explains how to combine Spring Boot and Redis using Lua scripts, covering Lua fundamentals, performance advantages, practical use cases, step‑by‑step implementation in Spring Boot, error handling, security considerations, and best‑practice recommendations for backend developers.
This article introduces Lua scripting in Redis, explains its fundamentals and advantages, and provides step‑by‑step instructions for integrating and executing Lua scripts within a Spring Boot application, including code examples, performance optimization, error handling, security considerations, and best practices.
This article demonstrates how to build a dynamic IP blacklist using Nginx, Lua scripts, and Redis, covering requirements, environment setup, design options, nginx.conf configuration, detailed Lua code, summary of advantages, and extensions such as use cases and advanced features.
This article examines why many large‑scale systems avoid the traditional delayed double‑delete cache‑invalidation strategy, explains its critical drawbacks, and presents alternative lease‑based and version‑based approaches with Lua scripts and Java wrappers for Redis to achieve stronger consistency.
This guide explains how to create a dynamic IP blacklist that blocks malicious crawlers or users by configuring Nginx with Lua scripts and a Redis store, covering requirements, environment setup, design choices, configuration files, Lua code, and advanced usage scenarios.
This article explains the challenges of thread synchronization in distributed systems, introduces the concept of distributed locks, compares common implementations such as Redis, Zookeeper, and databases, and provides robust Java and Lua solutions to ensure atomicity, avoid deadlocks, and support lock renewal.
This article explains how to prevent brute‑force password attempts by locking an IP after three failed logins using a Spring Boot backend, Redis for distributed counters, and a Lua script to ensure atomic increment and expiration, while also providing a simple HTML login page for the front end.
This article demonstrates how to implement a login attempt limiting mechanism using Spring Boot, Redis, and Lua scripts, explaining the problem of repeated password failures, the design of IP-based rate limiting, and providing complete front‑end and back‑end code examples with configuration details.
This guide walks through installing LuaJIT, ngx_devel_kit, and lua-nginx-module, compiling Nginx with Lua support, fixing common libluajit errors, optionally installing OpenResty, and configuring the ngx_lua_waf module to protect web applications.
This tutorial explains how to install LuaJIT, ngx_devel_kit, and lua‑nginx‑module, compile Nginx with Lua support, resolve common libluajit errors, optionally install OpenResty, and configure the ngx_lua_waf module to protect web applications.
This article explains how to build a dynamic IP blacklist that blocks malicious crawlers or users by using Nginx with a Lua access script and Redis for storage, covering requirements, environment setup, design choices, configuration steps, Lua code, and advanced extensions.
This article explains how to implement distributed locks in Redis using the SETNX command, atomic Lua scripts, the Redisson Java client, and the RedLock algorithm, providing code examples and discussing their advantages and limitations in distributed backend systems.
Fennel is a Lisp‑style programming language built on Lua that offers zero‑overhead compilation, full Lua compatibility, compile‑time macros, and easy embedding, making it ideal for creating games and art in environments like TIC‑80, while preserving the simplicity of s‑expressions.
This guide walks through installing LuaJIT, ngx_devel_kit, lua-nginx-module, compiling Nginx with Lua support, troubleshooting common errors, and adding a Lua-based Web Application Firewall (WAF) on an OpenResty platform.
This article compares three inventory deduction approaches—single‑field MySQL updates, sharded MySQL records, and Redis INCRBY with Lua scripting—analyzes their concurrency drawbacks, and provides a complete Java implementation using Redis Lua scripts, distributed locks, and callback‑based stock initialization.
This article compares Java backend development with game engine programming, explains why Unreal Engine (C++) and Unity (C#) dominate modern games, outlines official Unreal learning paths, and introduces hot‑update techniques using Blueprints, USharp and Lua for dynamic game updates.
This article explains how to produce Lua‑level flame graphs for OpenResty by leveraging SystemTap’s lj‑lua‑stacks tool, demonstrates the underlying data structures and call‑stack extraction, and explores a possible eBPF‑based rewrite for safer, kernel‑level tracing.
This guide introduces the lightweight Lua‑resty‑template engine for OpenResty, explains its typical use cases, shows how to install and configure it, and provides step‑by‑step examples of basic and advanced template rendering with code snippets and configuration files.
This article introduces Nginx’s extensive built‑in variables, shows how to access them in OpenResty with ngx.var, and provides step‑by‑step Lua examples ranging from a simple arithmetic endpoint to a basic IP‑based firewall and rate‑limiting configuration.
This article explains how to implement a Redis distributed lock, covering the basic SETNX approach, adding expiration, handling lock release errors with renewal and unique identifiers, achieving atomicity via Lua scripts, and discussing the inherent challenges of network delay, process pause, and clock drift in distributed systems.
This guide walks you through setting up a local virtual domain for OpenResty, creating and editing configuration files, adding Lua location blocks, using external Lua script files, managing the lua_code_cache setting, and troubleshooting errors with practical command examples.
This article explains how to implement distributed locks using Redis, starting with a simple SETNX approach, identifying its shortcomings, and then presenting solutions such as thread‑identifiers, Lua scripts for atomicity, handling TTL with watchdogs, the RedLock algorithm, and practical usage via the Redisson Java client.
This article explains how to embed Lua scripts in Java applications with LuaJ, how to call Java code from Lua using LuaJava, and demonstrates dynamic extension, script auto‑upgrade, and bidirectional interaction through comprehensive code examples and detailed explanations.
This article explains why a custom business risk‑control module is needed, outlines the required features, and provides a complete Kotlin‑based implementation that uses Redis + Lua scripts for daily and hourly counting, as well as a Spring annotation for seamless integration.
During flash‑sale events like JD or Taobao, a tiny fraction of products generate the majority of traffic, causing server overload; this guide explains how to identify and collect hotspot product data in real time using an OpenResty‑Lua front‑end, Kafka for messaging, and Elasticsearch for storage and analysis.
This article explains how to design a high‑QPS hotspot data caching and retrieval system for e‑commerce homepages using OpenResty, Lua, Redis, and a message queue, detailing publishing, reading processes, workflow diagrams, and a complete Lua script that can sustain tens of thousands to millions of concurrent requests.
This article explains how Redisson leverages Redis to implement distributed locks, detailing the underlying Lua scripts, lock acquisition and release processes, the watch‑dog mechanism for automatic lease renewal, and provides Java code examples for integrating and testing the lock functionality.
Lua is a lightweight, high-performance scripting language supporting multiple paradigms, widely used in game development, embedded systems, and web servers; this guide explains its core characteristics, typical applications, and provides step-by-step instructions for downloading, compiling, and configuring Lua on a Linux system.
The article describes a high‑throughput, fault‑tolerant data‑collection pipeline built with OpenResty, Lua, and Kafka that writes incoming records to disk using a cross‑worker mutex and cached file handles, rotates files via Nginx reload, and achieves over 13× performance versus typical online methods.
This article explains how to integrate Lua scripts with Redis in a Spring Boot application, covering Lua basics, performance benefits, common use cases, step‑by‑step configuration, Java code examples, error handling, security considerations, and best practices for reliable backend development.
This article explains how to integrate Lua scripts into Spring Boot applications for Redis, covering Lua fundamentals, performance benefits, common use cases, step‑by‑step implementation with Spring Data Redis, error handling, security considerations, and best‑practice recommendations.
This article explains how to integrate Lua scripts into Spring Boot applications using Redis, covering Lua basics, advantages of Lua in Redis, practical use cases, step‑by‑step implementation with code examples, performance optimization, error handling, security considerations, and best practices for reliable backend development.
The article shows how OpenResty’s Lua‑based extensions can implement lightweight, version‑controlled API authentication, dynamic traffic‑shaping via shared‑memory peer status, and selective request tracing with batch‑sent logs to Elasticsearch, enabling secure, highly available services and rich observability without sacrificing Nginx performance in production.
This article explains why a custom business risk‑control (rate‑limiting) component is needed for AI‑intensive services, compares open‑source solutions, and provides a complete backend implementation using Redis+Lua scripts, Kotlin code, Spring AOP annotations, and real‑time adjustable rules.
This article explains how to integrate Lua scripts into Spring Boot applications using Redis, covering Lua fundamentals, advantages of Lua in Redis, practical use cases, step‑by‑step implementation, performance optimization techniques, error handling, security considerations, and best practices for reliable backend development.
This article explains APISIX’s multi‑process architecture and request lifecycle, then explores various ways to develop external plugins—including SideCar‑based plugins, WASM modules, and LuaJIT FFI—detailing their implementation steps, advantages, and limitations to help developers choose the optimal approach for extending the cloud‑native gateway.
This article explains how to integrate Lua scripts into Spring Boot applications using Redis, covering Lua fundamentals, performance benefits, practical use cases, step‑by‑step implementation, error handling, security considerations, and best practices for optimizing backend services.
This article explains how to implement gray (canary) releases using Nginx, Lua, and Redis, covering common gray‑release strategies, detailed configuration examples, Lua scripts for routing by request parameters, IP or cookies, and suggestions for extending the solution with other data sources or scripting languages.
This guide demonstrates how to use Spring Boot 2.7 with Redis 6.2 to implement Pub/Sub messaging, transactional operations, pipelined commands, and Lua‑based distributed locks, providing code examples, configuration details, and explanations of each feature’s advantages and limitations.
The article shows how to build a reliable Redis‑based distributed lock in a Spring Boot 2.7 application by storing a unique UUID token, acquiring the lock with SET NX PX, releasing it atomically via a Lua script, and providing a clean Lock interface, factory component, and JUnit example.
This article explains how to implement multi‑rule rate limiting in a distributed Java application using Redis, covering String‑based counters, Zset timestamp storage, Lua scripts for atomic checks, custom @RateLimiter annotations, key generation logic, and an AOP interceptor that enforces the limits.
This article explains two API rate‑limiting strategies—fixed‑window using Redis keys and sliding‑window using Redis sorted sets—detailing their principles, drawbacks, and providing complete Java implementations with Lua scripts, AOP annotations, and Redis configuration to enforce request limits.
A Redis lock timeout caused users to be blocked for two hours, revealing problems with lock leakage and mis‑release; the article explains the root causes, proper use of SETNX with EXPIRE, and Lua scripts for atomic operations and safe lock deletion.
This article explains how to design and implement a distributed rate‑limiting solution that supports multiple concurrent rules—such as per‑minute and per‑hour limits—by analyzing the shortcomings of simple string counters, introducing atomic Lua scripts and Zset structures, and providing complete Java annotation and AOP code examples.
This comprehensive guide explains Redis fundamentals, its rich data structures, persistence mechanisms (RDB and AOF), enterprise‑level configuration strategies, common usage patterns such as caching, ranking and geolocation, and dives deep into distributed lock implementations with Redisson and Lua scripts, providing practical code examples for real‑world applications.
This guide explains how to build a dynamic IP blacklist using Nginx, Lua, and Redis, covering installation of LuaJIT, compiling Nginx with required modules, configuring Redis, writing Lua access‑limit scripts, and verifying that frequent requests are automatically blocked for a set period.
This article explains why traditional local locks fail in distributed systems, surveys common distributed‑lock approaches, and provides a step‑by‑step guide to building a robust Redis‑based lock in Java—including expiration handling, UUID safety, Lua‑script atomicity, re‑entrancy, automatic renewal, and the RedLock algorithm—while comparing its performance against plain local locks.
This article explains how to integrate Lua scripts into Spring Boot projects for Redis, covering Lua fundamentals, performance benefits, practical use cases, step‑by‑step implementation with code examples, error handling, security considerations, and best‑practice recommendations for backend developers.
This article examines why local locks fail in distributed micro‑service environments, introduces Redis‑based distributed locking, walks through five incremental lock designs—from a simple SETNX implementation to a Lua‑script atomic solution—highlighting each scheme's trade‑offs, code examples, and practical pitfalls.
This article explains how to use Lua scripts for performance testing by providing reusable functions that encapsulate HTTP and HTTPS GET/POST requests, support JSON and FormData payloads, and enable file uploads, complete with full code examples.
This article explains how Redis can be used to implement distributed locks, outlines common pitfalls such as non‑atomic operations, lock expiration, incorrect unlocking, lack of re‑entrancy and waiting mechanisms, and presents Lua scripts, Java examples, and cluster‑level considerations to mitigate these issues.
This article explains the concept of distributed locks for ensuring data consistency in clustered environments, outlines common implementation approaches, and provides a comprehensive guide to using Redisson in Java—including Maven setup, YAML configuration, core source‑code analysis, Lua scripts for lock and unlock operations, and practical test cases.
This article provides an in‑depth tutorial on designing and implementing various rate‑limiting strategies—such as token bucket, leaky bucket, and sliding window—in Java microservice architectures, with practical code examples using Guava, Sentinel, Redis+Lua, and a reusable Spring Boot starter.
This article explains Redisson's distributed lock features, comparing it with Jedis and Lettuce, detailing lock acquisition, reentrancy, Lua scripts, watchdog renewal, and the implementation of fair locks using Redis lists and sorted sets, with code examples and architectural insights.
This article explains why a custom business rate‑limiting component is needed, outlines the required rules, chooses Redis + Lua for counting, and provides complete Kotlin/Spring code—including a Detect annotation, Lua scripts, and usage examples—to enforce daily, hourly, and combined limits with real‑time adjustments.
This article explains why distributed locks are needed, describes the five essential characteristics of Redis locks, compares three common implementation methods, and provides detailed Java code examples with watchdog, re‑entrancy, and expiration handling to guide developers in building reliable distributed locking solutions.
This article explains how to use PHP and Redis to create a blocking lock for a game room, safely add users while preventing dirty reads, and release the lock atomically with a Lua script, providing complete code examples and practical tips.
This step‑by‑step guide shows how to prepare an Ubuntu 16.04 system, install all required dependencies, download OpenResty and its optional modules, configure the build with performance‑focused options, compile, install, set environment variables, and create a systemd service for automatic startup.
