BestHub
Sign in
Tagged articles

Lua

268 articles · Page 1 of 3
LuTiao Programming
LuTiao Programming
Sep 21, 2026 · Backend Development

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

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

AOPFail-OpenFixed Window
0 likes · 17 min read
Distributed Rate Limiting with Redis + Lua: Surviving API Floods in Spring Boot
Xiaolin Talks Programming
Xiaolin Talks Programming
Aug 19, 2026 · Backend Development

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

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

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

From DB Row Locks to Redis + Lua: Evolving Flash‑Sale Inventory Deduction

The article walks through the evolution of a flash‑sale inventory‑deduction system, starting with simple database row‑locking SQL, exposing its scalability limits, and progressively adding transaction trimming, Redis pre‑deduction, Lua atomic scripts, async pipelines, idempotency, reconciliation and robust engineering practices to handle extreme concurrency.

AsyncProcessingHighConcurrencyInventoryDeduction
0 likes · 40 min read
From DB Row Locks to Redis + Lua: Evolving Flash‑Sale Inventory Deduction
Cloud Architecture
Cloud Architecture
Aug 16, 2026 · Backend Development

How to Build a 100k QPS Seckill System with Spring Boot, Redis, and Lua

This article provides a production‑grade, step‑by‑step engineering guide for designing a high‑concurrency seckill (flash‑sale) system that can sustain 100,000 QPS using Spring Boot, Redis with Lua scripts, asynchronous messaging, and comprehensive fault‑tolerance, monitoring, and scalability techniques.

LuaRedisSpring Boot
0 likes · 40 min read
How to Build a 100k QPS Seckill System with Spring Boot, Redis, and Lua
Cloud Architecture
Cloud Architecture
Jul 26, 2026 · Backend Development

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

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

LuaMQRedis
0 likes · 28 min read
Seckill System Architecture: 7 Core Design Strategies for High-Concurrency Sales
Code Farming
Code Farming
Jul 22, 2026 · Backend Development

Designing a 5‑Layer Flash‑Sale System to Handle Millions of Requests

To survive a million concurrent flash‑sale clicks, the article breaks down a production‑grade, five‑layer architecture—CDN, load balancer, API gateway, Redis/Lua stock control, message‑queue order processing, and a state‑machine fallback—that filters traffic early, uses atomic operations, and decouples writes to keep database load to just a few QPS.

LuaMySQLRedis
0 likes · 7 min read
Designing a 5‑Layer Flash‑Sale System to Handle Millions of Requests
Top Architect
Top Architect
Jul 19, 2026 · Backend Development

Implementing Dynamic IP Blocking in Nginx with Lua and Redis

This guide explains how to build a dynamic IP blacklist for Nginx by comparing OS‑level iptables, Nginx deny rules, and application‑level checks, then detailing the chosen Nginx‑OpenResty, Lua, and Redis architecture, configuration snippets, and Lua script logic for automated blocking and rate limiting.

Dynamic blockingIP blacklistLua
0 likes · 11 min read
Implementing Dynamic IP Blocking in Nginx with Lua and Redis
Yumin Fish Harvest
Yumin Fish Harvest
Jul 9, 2026 · Databases

Redis Pipeline, Transactions, Lua, Distributed Locks, Streams & Data Types

This article provides an in‑depth guide to Redis’s advanced capabilities, covering how to use pipeline for batch commands, transactions for ordered execution, Lua scripts for atomic logic, distributed locks with proper token handling, reliable messaging with streams, and specialized data structures such as BitMap, HyperLogLog, Bloom Filter and GEO for efficient large‑scale scenarios.

Bloom FilterGEOHyperLogLog
0 likes · 65 min read
Redis Pipeline, Transactions, Lua, Distributed Locks, Streams & Data Types
Cloud Architecture
Cloud Architecture
Jun 28, 2026 · Backend Development

Building a Production‑Grade Kafka Reverse Proxy with Nginx + Lua for Scalable, Auditable Message Access

The article explains why a simple TCP proxy is insufficient for Kafka, and presents a production‑ready reverse‑proxy architecture built on Nginx stream and Lua that adds metadata rewriting, multi‑tenant quota, TLS termination, dynamic routing, observability, and graceful degradation to achieve scalable, auditable message ingestion.

KafkaLuaMessage Governance
0 likes · 33 min read
Building a Production‑Grade Kafka Reverse Proxy with Nginx + Lua for Scalable, Auditable Message Access
Sohu Tech Products
Sohu Tech Products
Jun 24, 2026 · Cloud Native

Cloud‑Native Dynamic Routing & Session Persistence for AI Sandboxes via Web VNC

The article details how the team built a high‑performance, reliable cloud‑native gateway for millions of AI sandbox VNC sessions, addressing challenges of dynamic pod IPs, multi‑stage Web VNC traffic, session consistency, and security by using OpenResty, Lua scripts, Redis‑backed routing, cookie‑based state storage, and extensive Nginx tuning.

AI sandboxLuaRedis
0 likes · 26 min read
Cloud‑Native Dynamic Routing & Session Persistence for AI Sandboxes via Web VNC
Geek Labs
Geek Labs
Jun 11, 2026 · Industry Insights

Five Innovative Open‑Source Projects: Game Engine, Family Planner, Breathing Trainer, 3D City Visualizer, Multi‑Drive Hub

The article introduces five recent open‑source projects—Usagi (a Rust+Lua 2D game engine), Oikos (a self‑hosted family planner), Breathe CLI (a terminal breathing trainer), Mini Macau (a Three.js 3D Macau transport visualizer), and 9Drive (a unified Google Drive gateway)—each with brief features, deployment notes, and GitHub links.

Breathing TrainerFamily PlannerGoogle Drive
0 likes · 5 min read
Five Innovative Open‑Source Projects: Game Engine, Family Planner, Breathing Trainer, 3D City Visualizer, Multi‑Drive Hub
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
Cloud Architecture
Cloud Architecture
Mar 13, 2026 · Backend Development

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

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

BackendLuaRedis
0 likes · 43 min read
Mastering Redis Rate Limiting: Token Bucket & Sliding Window Full Implementation Guide
Linux Tech Enthusiast
Linux Tech Enthusiast
Mar 13, 2026 · Fundamentals

Why Do Developers Prefer NeoVim Over Vim?

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.

ConfigurationLSPLua
0 likes · 7 min read
Why Do Developers Prefer NeoVim Over Vim?
Raymond Ops
Raymond Ops
Mar 7, 2026 · Operations

7 Hidden Traps in Nginx+Lua Gray Releases and How to Fix Them

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.

DevOpsGray ReleaseLua
0 likes · 43 min read
7 Hidden Traps in Nginx+Lua Gray Releases and How to Fix Them
Three Knives
Three Knives
Feb 28, 2026 · Cloud Native

Building Verge: An AI‑Assisted Edge Gateway That Delivers Plug‑and‑Play IoT Management

The article details how Verge, an AI‑assisted edge gateway built on the open‑source driver‑box framework, transforms a pure engine into a full‑featured, lightweight IoT platform by decoupling cloud and edge, offering rapid device integration, visual model editing, Lua scripting, and flexible deployment for smart building, industrial automation, and hobbyist labs.

Device ManagementGoIoT
0 likes · 11 min read
Building Verge: An AI‑Assisted Edge Gateway That Delivers Plug‑and‑Play IoT Management
Architect's Guide
Architect's Guide
Feb 27, 2026 · Backend Development

Mastering Rate Limiting: Algorithms, Strategies, and Practical Implementations

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.

GuavaLuarate limiting
0 likes · 15 min read
Mastering Rate Limiting: Algorithms, Strategies, and Practical Implementations
Ubiquitous Tech
Ubiquitous Tech
Jan 23, 2026 · Backend Development

Three Redis Inventory Decrement Lock Patterns Explained

The article analyzes three Redis inventory‑deduction locking strategies—exclusive lock, segmented lock, and lock‑free/key‑quantization—detailing their key structures, suitable scenarios, advantages, drawbacks, and also covers Lua‑script atomic decrement, async queue buffering, and local pre‑deduction techniques.

Exclusive LockInventoryLock-Free
0 likes · 8 min read
Three Redis Inventory Decrement Lock Patterns Explained
LuTiao Programming
LuTiao Programming
Jan 19, 2026 · Backend Development

How to Build a High‑Concurrency Flash‑Sale System with Spring Boot, Redis, and Lua

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.

Atomic ScriptLuaRedis
0 likes · 9 min read
How to Build a High‑Concurrency Flash‑Sale System with Spring Boot, Redis, and Lua
Tech Freedom Circle
Tech Freedom Circle
Jan 12, 2026 · Backend Development

Why Sentinel Fails for Per‑User Hourly Limits and How Redis + Lua Solves It

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.

Distributed ConsistencyLong WindowLua
0 likes · 26 min read
Why Sentinel Fails for Per‑User Hourly Limits and How Redis + Lua Solves It
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jan 2, 2026 · Backend Development

Implementing High‑Concurrency Circuit Breaking in Nginx with Lua

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.

Circuit BreakingLuaNginx
0 likes · 5 min read
Implementing High‑Concurrency Circuit Breaking in Nginx with Lua
Xiao Liu Lab
Xiao Liu Lab
Dec 16, 2025 · Backend Development

Nginx vs OpenResty: When to Choose Each for High‑Performance Web Services

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.

LuaNginxPerformance
0 likes · 11 min read
Nginx vs OpenResty: When to Choose Each for High‑Performance Web Services
DevOps Coach
DevOps Coach
Dec 10, 2025 · Operations

Why Rust Saved Cloudflare’s Edge While a Lua Nil Pointer Crashed It

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.

GoLuaRust
0 likes · 8 min read
Why Rust Saved Cloudflare’s Edge While a Lua Nil Pointer Crashed It
Ray's Galactic Tech
Ray's Galactic Tech
Oct 13, 2025 · Information Security

How to Implement Dynamic IP Blocking in Nginx: 3 Proven Methods

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.

Fail2banIP blockingLua
0 likes · 7 min read
How to Implement Dynamic IP Blocking in Nginx: 3 Proven Methods
Su San Talks Tech
Su San Talks Tech
Oct 13, 2025 · Databases

Boost High-Concurrency Performance with Redis Batch Query Techniques

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.

LuaMGETRedis
0 likes · 11 min read
Boost High-Concurrency Performance with Redis Batch Query Techniques
MaGe Linux Operations
MaGe Linux Operations
Oct 12, 2025 · Backend Development

Avoid 7 Fatal Traps in Nginx+Lua Gray Releases and How to Fix Them

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.

Gray ReleaseLuaNginx
0 likes · 42 min read
Avoid 7 Fatal Traps in Nginx+Lua Gray Releases and How to Fix Them
MaGe Linux Operations
MaGe Linux Operations
Sep 13, 2025 · Information Security

How to Build an Enterprise‑Grade WAF with OpenResty from Scratch

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.

LuaNginxSQL injection
0 likes · 24 min read
How to Build an Enterprise‑Grade WAF with OpenResty from Scratch
macrozheng
macrozheng
Sep 10, 2025 · Backend Development

How to Build a Scalable Non‑Intrusive Traffic‑Control System with OpenResty, Lua, and Redis

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.

LuaRedisbackend architecture
0 likes · 18 min read
How to Build a Scalable Non‑Intrusive Traffic‑Control System with OpenResty, Lua, and Redis
Raymond Ops
Raymond Ops
Sep 5, 2025 · Operations

Master HAProxy: From Installation to Advanced Load Balancing Configuration

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.

HAProxyLinuxLua
0 likes · 20 min read
Master HAProxy: From Installation to Advanced Load Balancing Configuration
Architect
Architect
Aug 30, 2025 · Backend Development

How to Seamlessly Combine Java and Lua: A Step‑by‑Step Guide

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.

JavaLuaLuaJava
0 likes · 14 min read
How to Seamlessly Combine Java and Lua: A Step‑by‑Step Guide
MaGe Linux Operations
MaGe Linux Operations
Aug 30, 2025 · Operations

How to Build a High‑Performance Nginx API Gateway from Scratch

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.

API GatewayLuaNginx
0 likes · 37 min read
How to Build a High‑Performance Nginx API Gateway from Scratch
Architecture Digest
Architecture Digest
Aug 30, 2025 · Backend Development

How to Build a Dynamic IP Blacklist with Nginx, Lua, and Redis

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.

IP blacklistLuaRedis
0 likes · 9 min read
How to Build a Dynamic IP Blacklist with Nginx, Lua, and Redis
Top Architect
Top Architect
Aug 26, 2025 · Backend Development

Dynamic IP Blacklist with Nginx, Lua, and Redis: A Step‑by‑Step Guide

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.

Dynamic blockingIP blacklistLua
0 likes · 12 min read
Dynamic IP Blacklist with Nginx, Lua, and Redis: A Step‑by‑Step Guide
Su San Talks Tech
Su San Talks Tech
Aug 26, 2025 · Backend Development

How to Build a Dynamic IP Blacklist with Nginx, Lua, and Redis

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.

IP blacklistLuaNginx
0 likes · 9 min read
How to Build a Dynamic IP Blacklist with Nginx, Lua, and Redis
Su San Talks Tech
Su San Talks Tech
Aug 25, 2025 · Backend Development

How to Build a High‑Concurrency Queue System with OpenResty, Lua, and Redis

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.

LuaRedishigh concurrency
0 likes · 18 min read
How to Build a High‑Concurrency Queue System with OpenResty, Lua, and Redis
Sohu Smart Platform Tech Team
Sohu Smart Platform Tech Team
Aug 9, 2025 · Backend Development

Boost Your API Security and Traffic Management with OpenResty: Real‑World Practices

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.

API authenticationBackendLua
0 likes · 16 min read
Boost Your API Security and Traffic Management with OpenResty: Real‑World Practices
Sanyou's Java Diary
Sanyou's Java Diary
Aug 7, 2025 · Backend Development

How Easy-Cache Solves Distributed Cache Pain Points with Multi-Level Design

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.

LuaMulti-level CacheSpring AOP
0 likes · 18 min read
How Easy-Cache Solves Distributed Cache Pain Points with Multi-Level Design
Zhuanzhuan Tech
Zhuanzhuan Tech
Aug 6, 2025 · Backend Development

Mastering Distributed Caching: Easy-Cache’s Multi‑Level Dynamic Upgrade and Consistency

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.

LuaRedisSpring AOP
0 likes · 18 min read
Mastering Distributed Caching: Easy-Cache’s Multi‑Level Dynamic Upgrade and Consistency
Architect Practice
Architect Practice
Jul 19, 2025 · Backend Development

Sliding Window Rate Limiting with Redis Lua and Java

This article explains how to implement precise sliding‑window rate limiting using a Redis Lua script and a Spring‑based Java component, compares it with fixed‑window and token‑bucket approaches, and provides advanced techniques, production tips, and performance optimizations.

JavaLuaRedis
0 likes · 14 min read
Sliding Window Rate Limiting with Redis Lua and Java
Lin is Dream
Lin is Dream
Jul 7, 2025 · Backend Development

Master Sliding‑Window Rate Limiting with Redis Sorted Sets

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.

BackendJavaLua
0 likes · 8 min read
Master Sliding‑Window Rate Limiting with Redis Sorted Sets
Code Mala Tang
Code Mala Tang
Jun 17, 2025 · Backend Development

Mastering Rate Limiting: Algorithms, Redis & Lua for Scalable Backend APIs

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.

BackendFastAPILua
0 likes · 13 min read
Mastering Rate Limiting: Algorithms, Redis & Lua for Scalable Backend APIs
Java Tech Enthusiast
Java Tech Enthusiast
May 16, 2025 · Game Development

The Unexpected Birth of Lua: From Brazil to Global Scripting Success

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.

LuaProgramming Language HistoryScripting Language
0 likes · 10 min read
The Unexpected Birth of Lua: From Brazil to Global Scripting Success
Liangxu Linux
Liangxu Linux
May 5, 2025 · Backend Development

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

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

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

Using Lua Scripts in Spring Boot with Redis for Performance and Atomic Operations

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.

LuaPerformanceSpring Boot
0 likes · 20 min read
Using Lua Scripts in Spring Boot with Redis for Performance and Atomic Operations
Top Architecture Tech Stack
Top Architecture Tech Stack
Apr 2, 2025 · Backend Development

Implementing a Dynamic IP Blacklist with Nginx, Lua, and Redis

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.

BackendIP blacklistLua
0 likes · 9 min read
Implementing a Dynamic IP Blacklist with Nginx, Lua, and Redis
Selected Java Interview Questions
Selected Java Interview Questions
Mar 14, 2025 · Backend Development

Design and Implementation of a Business Rate‑Limiting Component Using Redis Lua Scripts and Kotlin Annotations

This article explains how to design and implement a business-specific rate‑limiting component in Kotlin using Redis Lua scripts and Spring AOP annotations, covering the motivation, rule definitions, counting strategies, Lua script details, annotation creation, and a practical usage example.

KotlinLuarate limiting
0 likes · 10 min read
Design and Implementation of a Business Rate‑Limiting Component Using Redis Lua Scripts and Kotlin Annotations
Ctrip Technology
Ctrip Technology
Mar 6, 2025 · Backend Development

Design and Implementation of Ctrip's Soft Load Balancer: Evolving from Nginx Reverse Proxy to an OpenResty‑Based API Gateway

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.

API GatewayLuadynamic routing
0 likes · 14 min read
Design and Implementation of Ctrip's Soft Load Balancer: Evolving from Nginx Reverse Proxy to an OpenResty‑Based API Gateway
Java Architect Essentials
Java Architect Essentials
Feb 27, 2025 · Backend Development

How to Enforce Login Attempt Limits with Spring Boot, Redis, and Lua Scripts

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.

BackendJavaLogin Rate Limiting
0 likes · 18 min read
How to Enforce Login Attempt Limits with Spring Boot, Redis, and Lua Scripts
Java Captain
Java Captain
Feb 9, 2025 · Backend Development

Using Lua Scripts in Spring Boot with Redis for Performance and Atomic Operations

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.

BackendLuaPerformance
0 likes · 23 min read
Using Lua Scripts in Spring Boot with Redis for Performance and Atomic Operations
Architecture Digest
Architecture Digest
Jan 29, 2025 · Backend Development

Using Lua Scripts in Spring Boot with Redis: A Comprehensive Guide

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.

JavaLuaPerformance
0 likes · 21 min read
Using Lua Scripts in Spring Boot with Redis: A Comprehensive Guide
Code Ape Tech Column
Code Ape Tech Column
Jan 22, 2025 · Backend Development

Using Lua Scripts with Spring Boot and Redis: A Comprehensive Guide

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.

LuaRedisSpring Boot
0 likes · 19 min read
Using Lua Scripts with Spring Boot and Redis: A Comprehensive Guide
Top Architect
Top Architect
Jan 8, 2025 · Backend Development

Implementing a Dynamic IP Blacklist with Nginx, Lua, and Redis

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.

IP blacklistLuaRedis
0 likes · 11 min read
Implementing a Dynamic IP Blacklist with Nginx, Lua, and Redis
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jan 7, 2025 · Backend Development

Cache Consistency: Pitfalls of Delayed Double Delete and Lease/Versioning Solutions with Redis

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.

Delayed Double DeleteJavaLua
0 likes · 17 min read
Cache Consistency: Pitfalls of Delayed Double Delete and Lease/Versioning Solutions with Redis
Architect
Architect
Jan 5, 2025 · Information Security

How to Build a Dynamic IP Blacklist with Nginx, Lua, and Redis

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.

BackendIP blacklistLua
0 likes · 9 min read
How to Build a Dynamic IP Blacklist with Nginx, Lua, and Redis
Top Architect
Top Architect
Dec 26, 2024 · Backend Development

Implementing Login Attempt Limiting with Spring Boot, Redis, and Lua Scripts

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.

JavaLoginRateLimitingLua
0 likes · 19 min read
Implementing Login Attempt Limiting with Spring Boot, Redis, and Lua Scripts
Architecture Digest
Architecture Digest
Nov 22, 2024 · Backend Development

Implementing Login Attempt Limiting with Spring Boot, Redis, and Lua Scripts

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.

JavaLogin Rate LimitingLua
0 likes · 17 min read
Implementing Login Attempt Limiting with Spring Boot, Redis, and Lua Scripts
21CTO
21CTO
Sep 9, 2024 · Fundamentals

Discover Fennel: A Lisp‑Based Language for Lua Lovers and Game Creators

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.

FennelLispLua
0 likes · 5 min read
Discover Fennel: A Lisp‑Based Language for Lua Lovers and Game Creators
Top Architect
Top Architect
Sep 2, 2024 · Backend Development

Inventory Deduction Strategies: Database vs. Redis with Lua Script Implementation

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.

BackendInventoryLua
0 likes · 13 min read
Inventory Deduction Strategies: Database vs. Redis with Lua Script Implementation
Su San Talks Tech
Su San Talks Tech
Aug 25, 2024 · Game Development

How to Start Learning Unreal Engine for Game Development: A Practical Guide

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.

Java backendLearning ResourcesLua
0 likes · 8 min read
How to Start Learning Unreal Engine for Game Development: A Practical Guide
Selected Java Interview Questions
Selected Java Interview Questions
Jul 15, 2024 · Backend Development

Redis Distributed Lock: Basic Implementation, Expiration, Safety Measures, and Lua Atomicity

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.

LuaRedisbackend development
0 likes · 6 min read
Redis Distributed Lock: Basic Implementation, Expiration, Safety Measures, and Lua Atomicity
Open Source Tech Hub
Open Source Tech Hub
Jul 13, 2024 · Backend Development

How to Configure a Virtual Domain and Run Lua Scripts with OpenResty

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.

LuaNginxServer configuration
0 likes · 5 min read
How to Configure a Virtual Domain and Run Lua Scripts with OpenResty
Lobster Programming
Lobster Programming
May 9, 2024 · Backend Development

Detect Hot Items in High‑Concurrency Sales Using OpenResty, Kafka & Elasticsearch

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.

ElasticsearchHot ItemsKafka
0 likes · 5 min read
Detect Hot Items in High‑Concurrency Sales Using OpenResty, Kafka & Elasticsearch
Lobster Programming
Lobster Programming
May 6, 2024 · Backend Development

Scaling Homepage Carousel to Millions of QPS with OpenResty, Lua, Redis, and MQ

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.

LuaRedishigh concurrency
0 likes · 6 min read
Scaling Homepage Carousel to Millions of QPS with OpenResty, Lua, Redis, and MQ
IT Services Circle
IT Services Circle
Apr 25, 2024 · Backend Development

How Redisson Implements Distributed Locks Using Redis

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.

ConcurrencyDistributedLockJava
0 likes · 19 min read
How Redisson Implements Distributed Locks Using Redis
Lobster Programming
Lobster Programming
Apr 22, 2024 · Fundamentals

Master Lua: What It Is, Key Features, and How to Install on Linux

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.

InstallationLinuxLua
0 likes · 3 min read
Master Lua: What It Is, Key Features, and How to Install on Linux
37 Interactive Technology Team
37 Interactive Technology Team
Apr 15, 2024 · Backend Development

High-Performance Data Collection and Persistence Using OpenResty, Lua, and Kafka

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.

DataIngestionFileIOHighPerformance
0 likes · 7 min read
High-Performance Data Collection and Persistence Using OpenResty, Lua, and Kafka
Java High-Performance Architecture
Java High-Performance Architecture
Apr 2, 2024 · Backend Development

Unlock Redis Performance: Using Lua Scripts in Spring Boot

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.

LuaPerformanceRedis
0 likes · 19 min read
Unlock Redis Performance: Using Lua Scripts in Spring Boot
Code Ape Tech Column
Code Ape Tech Column
Mar 29, 2024 · Backend Development

Using Lua Scripts with Spring Boot and Redis: A Comprehensive Guide

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.

LuaPerformance OptimizationSpring Boot
0 likes · 20 min read
Using Lua Scripts with Spring Boot and Redis: A Comprehensive Guide
Top Architect
Top Architect
Mar 20, 2024 · Backend Development

Using Lua Scripts with Spring Boot and Redis: A Comprehensive Guide

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.

LuaPerformanceRedis
0 likes · 20 min read
Using Lua Scripts with Spring Boot and Redis: A Comprehensive Guide
Sohu Tech Products
Sohu Tech Products
Mar 13, 2024 · Backend Development

OpenResty‑Based Interface Authentication, Traffic Control, and Request Tracing in Production

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.

API authenticationLuaNginx
0 likes · 18 min read
OpenResty‑Based Interface Authentication, Traffic Control, and Request Tracing in Production
Java Architect Essentials
Java Architect Essentials
Feb 28, 2024 · Backend Development

Design and Implementation of a Business Rate‑Limiting Component Using Redis Lua Scripts and Custom Annotations in Kotlin

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.

BackendKotlinLua
0 likes · 10 min read
Design and Implementation of a Business Rate‑Limiting Component Using Redis Lua Scripts and Custom Annotations in Kotlin
Java High-Performance Architecture
Java High-Performance Architecture
Feb 27, 2024 · Backend Development

Boost Spring Boot Performance with Redis Lua Scripts: A Complete Guide

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.

LuaPerformanceRedis
0 likes · 20 min read
Boost Spring Boot Performance with Redis Lua Scripts: A Complete Guide
SQB Blog
SQB Blog
Feb 23, 2024 · Cloud Native

Building External Plugins for APISIX: Deep Dive into Cloud‑Native Gateway Extensions

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.

APISIXFFILua
0 likes · 14 min read
Building External Plugins for APISIX: Deep Dive into Cloud‑Native Gateway Extensions
Java Captain
Java Captain
Feb 16, 2024 · Backend Development

Using Lua Scripts with Spring Boot and Redis: A Comprehensive Guide

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.

LuaPerformanceRedis
0 likes · 19 min read
Using Lua Scripts with Spring Boot and Redis: A Comprehensive Guide
MaGe Linux Operations
MaGe Linux Operations
Feb 11, 2024 · Backend Development

Master Gray Deployments: Nginx + Lua + Redis for Dynamic Canary Releases

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.

Gray ReleaseLuacanary deployment
0 likes · 34 min read
Master Gray Deployments: Nginx + Lua + Redis for Dynamic Canary Releases