BestHub
Sign in
Tagged articles

Lua

252 articles · Page 3 of 3
Top Architect
Top Architect
Jun 15, 2020 · Backend Development

Redisson Distributed Lock: Maven Setup, Simple Usage, Redis Commands, Lua Script Semantics, and Source Code Analysis

This article presents a concise Redisson distributed‑lock example with Maven configuration, demonstrates basic lock usage, enumerates the Redis commands and Lua script semantics involved, and provides a detailed walkthrough of the relevant Java source code, highlighting key implementation details.

Backend DevelopmentDistributed LockJava
0 likes · 14 min read
Redisson Distributed Lock: Maven Setup, Simple Usage, Redis Commands, Lua Script Semantics, and Source Code Analysis
37 Interactive Technology Team
37 Interactive Technology Team
Jun 12, 2020 · Cloud Native

Implementing Dynamic Rate Limiting with the APISIX API Gateway

This tutorial shows how to use the open‑source APISIX API gateway—built on OpenResty and etcd—to create a dynamic rate‑limiting plugin in Lua, configure route matching with a radix tree, and demonstrate the feature with a test endpoint that enforces one request per second and returns HTTP 503 when exceeded.

API GatewayAPISIXDynamic Rate Limiting
0 likes · 14 min read
Implementing Dynamic Rate Limiting with the APISIX API Gateway
Programmer DD
Programmer DD
Jun 11, 2020 · Backend Development

Mastering Redis Distributed Locks: From SETNX to RedLock and Redisson

This article explores Redis locking mechanisms, explaining the SETNX command, its limitations, the use of PX for timeouts, Lua scripts for atomic unlocks, and introduces Redisson’s advanced lock implementations including RedLock, while highlighting practical pitfalls and best‑practice recommendations for reliable distributed synchronization.

LuaRedisRedlock
0 likes · 11 min read
Mastering Redis Distributed Locks: From SETNX to RedLock and Redisson
JD Retail Technology
JD Retail Technology
Mar 12, 2020 · Backend Development

Understanding OpenResty: Architecture, Core Principles, and Real‑World Application in High‑Concurrency Systems

This article explains what OpenResty is, details its underlying Nginx‑Lua architecture—including Lua coroutines, cosocket, and multi‑stage processing—compares its performance with other web platforms, and describes its practical deployment and multi‑level caching strategy in JD.com's high‑traffic Jshop sale system.

CachingHigh concurrencyLua
0 likes · 12 min read
Understanding OpenResty: Architecture, Core Principles, and Real‑World Application in High‑Concurrency Systems
JD Retail Technology
JD Retail Technology
Mar 5, 2020 · Backend Development

Technical Implementation and Resilience Practices of JD.com PC Homepage

This article details the architectural redesign, fault‑tolerance mechanisms, performance optimizations, and monitoring strategies employed in JD.com’s PC homepage, illustrating how backend technologies such as OpenResty, Lua, Redis, and NGINX are orchestrated to achieve high availability and sub‑30 ms page loads.

Backend DevelopmentLuaOpenResty
0 likes · 12 min read
Technical Implementation and Resilience Practices of JD.com PC Homepage
360 Tech Engineering
360 Tech Engineering
Feb 25, 2020 · Cloud Native

Introduction to Kong API Gateway: Features, Deployment, and Configuration

This article introduces Kong, a cloud‑native API gateway, outlines its key features such as high performance, plugin architecture, and traffic control, explains why it solves common microservice challenges, and provides detailed deployment, clustering, plugin development, and troubleshooting guidance with practical code examples.

API GatewayCloud NativeKong
0 likes · 10 min read
Introduction to Kong API Gateway: Features, Deployment, and Configuration
Java Captain
Java Captain
Dec 5, 2019 · Databases

Understanding Redis: From Basic Concepts to Advanced Features and Deployment Strategies

This article provides a comprehensive overview of Redis, explaining its core data structures, caching use cases, persistence mechanisms, high‑availability features like Sentinel and replication, clustering for horizontal scaling, and client‑side capabilities such as transactions, Lua scripting, pipelining, and distributed locks.

CachingDatabaseLua
0 likes · 13 min read
Understanding Redis: From Basic Concepts to Advanced Features and Deployment Strategies
Big Data Technology & Architecture
Big Data Technology & Architecture
Oct 31, 2019 · Backend Development

Designing a High-Concurrency Flash Sale System Using Redis Caching and Lua Scripts

This article explains how to design a high‑concurrency flash‑sale (秒杀) system by leveraging browser and CDN caching, read‑write split Redis for traffic filtering, Lua scripts for atomic stock deduction, master‑slave Redis for fast inventory updates, and Redis‑based message queues for asynchronous order processing.

Flash SaleHigh concurrencyLua
0 likes · 8 min read
Designing a High-Concurrency Flash Sale System Using Redis Caching and Lua Scripts
GF Securities FinTech
GF Securities FinTech
Aug 22, 2019 · Backend Development

Mastering Health Checks in OpenResty: Compare Three Backend Modules

This article examines three OpenResty-based backend health‑check solutions—ngx_http_upstream_module, lua‑resty‑upstream‑healthcheck, and nginx_upstream_check_module—detailing their implementation principles, configuration examples, node status monitoring, and practical Docker integration, helping developers choose the optimal approach for reliable service availability.

DockerLuaOpenResty
0 likes · 9 min read
Mastering Health Checks in OpenResty: Compare Three Backend Modules
Efficient Ops
Efficient Ops
Aug 13, 2019 · Backend Development

Mastering Nginx: How to Build Scalable, High‑Performance Web Services

This article systematically explains Nginx's architecture, module design, scalability, caching, TLS handling, and OpenResty integration, providing practical guidance for building high‑availability, high‑performance services in large‑scale distributed environments.

CachingLuaOpenResty
0 likes · 17 min read
Mastering Nginx: How to Build Scalable, High‑Performance Web Services
Architect's Tech Stack
Architect's Tech Stack
Jul 3, 2019 · Backend Development

Implementing a Distributed Rate Limiter with Redis, Spring Boot, and Lua Scripts

This article demonstrates how to build a distributed rate‑limiting component named shield‑ratelimiter using Redis’s INCR and TTL features, Spring‑Boot‑starter integration, Lua scripting for atomic operations, custom annotations, and AspectJ, providing a robust, configurable solution for limiting API calls in Java backend services.

LuaRedisSpring Boot
0 likes · 16 min read
Implementing a Distributed Rate Limiter with Redis, Spring Boot, and Lua Scripts
Java High-Performance Architecture
Java High-Performance Architecture
Jan 22, 2019 · Backend Development

How to Prevent Inventory Over‑Selling in High‑Concurrency Systems

Learn why inventory over‑selling occurs under high concurrency, and explore three practical solutions—pessimistic locking, optimistic locking with version control, and Redis‑Lua scripting—detailing their implementation steps, advantages, and drawbacks to help you choose the best approach for reliable stock management.

InventoryLuaRedis
0 likes · 7 min read
How to Prevent Inventory Over‑Selling in High‑Concurrency Systems
JD Tech
JD Tech
Jan 7, 2019 · Backend Development

Using OpenResty for a High‑Performance Logistics Gateway

This article explains how OpenResty, built on Nginx and Lua, powers JD Logistics' high‑throughput, extensible gateway by leveraging non‑blocking I/O, plugin architecture, multi‑level caching, dynamic load balancing, and custom JSON handling to achieve stable, scalable performance.

CachingLuaNGINX
0 likes · 6 min read
Using OpenResty for a High‑Performance Logistics Gateway
21CTO
21CTO
Nov 21, 2018 · Backend Development

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

This guide explains how to create a dynamic IP blacklist using Nginx, Lua, and Redis, covering the background, architecture options, step‑by‑step implementation, and the advantages of a lightweight, shared, and easily updatable solution.

IP blacklistLuaNGINX
0 likes · 3 min read
How to Build a Dynamic IP Blacklist with Nginx, Lua, and Redis
Java Captain
Java Captain
Nov 19, 2018 · Backend Development

Implementing a Red Packet System with Redis, Lua Scripts, and Spring Async

This article explains how to build a high‑performance red‑packet (hong‑bao) service by configuring a RedisTemplate in Spring, writing an atomic Lua script for stock management, persisting results to a MySQL database via JDBC batch processing, and using @Async to off‑load long‑running tasks, complete with code examples and deployment steps.

JavaLuaRedis
0 likes · 17 min read
Implementing a Red Packet System with Redis, Lua Scripts, and Spring Async
Architect's Tech Stack
Architect's Tech Stack
Nov 12, 2018 · Backend Development

Designing a High-Concurrency Flash Sale System with Redis Caching and Lua Scripts

This article explains how to build a high‑concurrency flash‑sale (秒杀) system by separating static page traffic with CDN, using read‑write‑split Redis for early request filtering, applying Lua scripts for atomic inventory deduction, and employing Redis as a simple message queue for asynchronous order persistence.

Flash SaleHigh concurrencyLua
0 likes · 9 min read
Designing a High-Concurrency Flash Sale System with Redis Caching and Lua Scripts
37 Interactive Technology Team
37 Interactive Technology Team
Sep 7, 2018 · Backend Development

Mastering Lua and OpenResty: From Basics to Real-World Deployment

This guide introduces Lua’s concise syntax, tiny footprint, and performance strengths, explores typical use cases such as security, web APIs, and game servers, then walks through core language features, OpenResty integration, deployment steps, and a hands‑on exercise for building a redirect service.

Backend DevelopmentDeploymentLua
0 likes · 10 min read
Mastering Lua and OpenResty: From Basics to Real-World Deployment
Meituan Technology Team
Meituan Technology Team
Sep 6, 2018 · Backend Development

Design and Implementation of Oceanus Custom HTTP Routing Framework

Oceanus is Meituan’s Nginx‑based HTTP routing framework that abstracts routing policies, stores them in MySQL, updates them asynchronously, evaluates Lua‑rendered conditions at runtime, and dynamically switches upstream groups without Nginx reload, enabling flexible traffic control for flash‑sale testing, regional isolation, gray releases, and other complex scenarios.

HTTP routingLuaNGINX
0 likes · 16 min read
Design and Implementation of Oceanus Custom HTTP Routing Framework
Architecture Digest
Architecture Digest
Jul 25, 2018 · Backend Development

OpenResty and API Gateway Learning Guide

This guide compiles resources and key concepts on OpenResty, Lua‑based Nginx development, asynchronous programming models, microservice API gateways, and related plugins, providing a structured roadmap for backend engineers to deepen their understanding and practical skills.

API GatewayLuaMicroservices
0 likes · 6 min read
OpenResty and API Gateway Learning Guide
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Mar 29, 2018 · Backend Development

Boost Web Service Stability and Speed with Nginx‑Lua Integration

This article explains how embedding Lua scripts into Nginx via the lua‑nginx module can address PHP’s limitations in service stability and response time, detailing the problems, requirements, and practical code examples that demonstrate asynchronous handling and bigpipe‑style page rendering.

LuaNGINXservice stability
0 likes · 9 min read
Boost Web Service Stability and Speed with Nginx‑Lua Integration
ITPUB
ITPUB
Nov 24, 2017 · Backend Development

How to Build a Redis‑Powered Rate Limiter Using Token Bucket and Lua

This article explains the design of a Redis‑based rate‑limiting system, covering core concepts, token‑bucket and window‑based algorithms, Java and Lua implementations, engineering choices, performance benchmarks, and practical lessons learned.

LuaToken Bucketbackend
0 likes · 12 min read
How to Build a Redis‑Powered Rate Limiter Using Token Bucket and Lua
Architecture Digest
Architecture Digest
Nov 8, 2017 · Backend Development

Implementing Distributed Locks with Redis: Commands, Java Implementations, and Lua Script Optimizations

This article explains how to build a reliable distributed lock using Redis by introducing essential Redis commands, presenting initial Java pseudocode, addressing race‑condition pitfalls, improving the design with GETSET and Lua scripts, and providing complete, production‑ready Java implementations with unlock safety fixes.

Luabackenddistributed-lock
0 likes · 16 min read
Implementing Distributed Locks with Redis: Commands, Java Implementations, and Lua Script Optimizations
dbaplus Community
dbaplus Community
Sep 20, 2016 · Backend Development

Zero‑Intrusion Data Fallback with Nginx + Lua: A Practical Guide

This article explains how to design a robust, zero‑intrusion data fallback component for high‑traffic web services using Nginx, Lua, and AOP principles, covering problem definition, architectural options, detailed execution steps, configuration snippets, storage choices, and performance monitoring.

AOPData FallbackHigh Availability
0 likes · 11 min read
Zero‑Intrusion Data Fallback with Nginx + Lua: A Practical Guide
GF Securities FinTech
GF Securities FinTech
Sep 14, 2016 · Big Data

Scaling Real-Time Stock Market Data with Redis, Lua, and Go Goroutines

Exploring how a securities firm processes billions of daily stock‑market indicators in real time, this article compares an in‑process Redis + Lua solution with an out‑of‑process Goroutine‑based architecture, detailing data flow, performance trade‑offs, and scalability considerations for high‑frequency time‑series workloads.

LuaReal-time DataRedis
0 likes · 12 min read
Scaling Real-Time Stock Market Data with Redis, Lua, and Go Goroutines
ITPUB
ITPUB
Jul 18, 2016 · Game Development

Implementing Lua‑Based Hot‑Update in Unity Without Rebuilding the Game

This article explains a practical approach to implementing hot‑update in Unity games by injecting Lua‑based patches into C# methods using SLua and the NRefactory library, detailing the execution environment, code‑injection process, Lua patch creation, and a reusable MethodInjector class.

C#Code InjectionHot Update
0 likes · 12 min read
Implementing Lua‑Based Hot‑Update in Unity Without Rebuilding the Game
21CTO
21CTO
Jun 14, 2016 · Backend Development

Mastering Nginx Access Layer Rate Limiting: Practical Configurations and Code Samples

This article explains how to implement access‑layer rate limiting in Nginx using built‑in modules, OpenResty Lua extensions, and token‑bucket or leaky‑bucket algorithms, with detailed configuration snippets, execution flow, testing procedures, and log analysis for robust traffic control.

LuaNGINXOpenResty
0 likes · 21 min read
Mastering Nginx Access Layer Rate Limiting: Practical Configurations and Code Samples
ITPUB
ITPUB
May 25, 2016 · Information Security

Defending Nginx Against CC Attacks with Cookie Validation and Lua Rate Limiting

This guide explains how to use simple Nginx configurations, enhanced cookie checks, and Lua scripts to create unforgeable tokens, limit request rates, and protect web services from CC attacks, scanning tools, and other malicious traffic while maintaining normal user access.

LuaNGINXcc attack mitigation
0 likes · 13 min read
Defending Nginx Against CC Attacks with Cookie Validation and Lua Rate Limiting
Architecture Digest
Architecture Digest
Mar 19, 2016 · Backend Development

Using Nginx + Lua (ngx_lua) for High‑Performance Web Applications

This article introduces the advantages of Nginx and Lua, explains the ngx_lua module and OpenResty ecosystem, describes common architectural patterns such as load balancing and caching, and provides a step‑by‑step guide to building, configuring, and deploying a Lua‑based web application on Nginx.

CachingLuaNGINX
0 likes · 23 min read
Using Nginx + Lua (ngx_lua) for High‑Performance Web Applications
ITPUB
ITPUB
Mar 16, 2016 · Backend Development

Implementing Gray Release for HTTP Read APIs with Nginx and Gateway Layers

This article explains how to design a gray‑release solution for HTTP read interfaces by using either Nginx with embedded Lua scripts or a version‑aware gateway layer, detailing rule design, configuration handling, and the trade‑offs of each approach.

HTTPLuaNGINX
0 likes · 8 min read
Implementing Gray Release for HTTP Read APIs with Nginx and Gateway Layers
Qunar Tech Salon
Qunar Tech Salon
Mar 8, 2016 · Backend Development

Practices for Handling High Traffic on JD.com Product Detail Pages

The article details JD.com's technical strategies for scaling product detail pages under massive traffic, covering service decomposition, KV‑based dynamic rendering with Nginx+Lua, unified service gateways, isolation, caching, monitoring, degradation, and performance testing to achieve sub‑50 ms response times.

CachingJD.comLua
0 likes · 16 min read
Practices for Handling High Traffic on JD.com Product Detail Pages
21CTO
21CTO
Dec 21, 2015 · Backend Development

How JD.com Scaled Its Product Detail Pages to Billions of Views

This article details JD.com's evolution of product detail page architecture—from early IIS/C# monoliths to a distributed, cache‑heavy, Nginx+Lua system—covering front‑end dimensions, performance metrics, design principles, scaling challenges, storage engine choices, multi‑datacenter deployment, and the lessons learned from numerous production pitfalls.

LuaNGINXProduct Detail Page
0 likes · 24 min read
How JD.com Scaled Its Product Detail Pages to Billions of Views
High Availability Architecture
High Availability Architecture
Dec 8, 2015 · Backend Development

OpenResty Best Practices and Adoption in High‑Performance Backend Development

The article presents a comprehensive overview of OpenResty, describing its architecture, suitable scenarios, selection criteria, real‑world adoption at Qihoo 360 and Sina Mobile, onboarding challenges, future roadmap, and community efforts, illustrating why it is a powerful backend solution for high‑throughput services.

LuaNGINXbackend
0 likes · 19 min read
OpenResty Best Practices and Adoption in High‑Performance Backend Development
Architect
Architect
Nov 28, 2015 · Backend Development

Implementing a Fastest‑First Load‑Balancing Strategy for NGINX with Lua and OpenResty

This article describes how to create a “fastest‑first” load‑balancing algorithm for NGINX using OpenResty and Lua, including the design principles, modifications to lua‑upstream‑nginx‑module, weight‑adjustment logic, Docker build steps, and practical considerations for handling latency‑based server weighting.

Backend DevelopmentLuaOpenResty
0 likes · 11 min read
Implementing a Fastest‑First Load‑Balancing Strategy for NGINX with Lua and OpenResty
High Availability Architecture
High Availability Architecture
Nov 25, 2015 · Backend Development

Unified Service Architecture for JD’s Billion-Scale Product Detail Page during Double Eleven

This article describes JD’s unified service architecture for the product detail page that handled tens of billions of requests during Double Eleven, detailing the multi‑level caching strategy, Nginx+Lua access layer, service isolation, degradation mechanisms, and front‑end logic offloading.

CachingHigh AvailabilityLua
0 likes · 22 min read
Unified Service Architecture for JD’s Billion-Scale Product Detail Page during Double Eleven
21CTO
21CTO
Nov 14, 2015 · Backend Development

How Nginx Lua Enables Aspect‑Oriented Backend Design with Low Coupling

This article explains how aspect‑oriented programming can be applied to a backend system by separating cross‑cutting concerns such as request encryption, authentication, and permission handling using Sinatra extensions and Nginx Lua scripts, resulting in a modular, low‑coupling architecture.

AOPLuaNGINX
0 likes · 10 min read
How Nginx Lua Enables Aspect‑Oriented Backend Design with Low Coupling
21CTO
21CTO
Nov 13, 2015 · Backend Development

How to Leverage Nginx Lua for Aspect‑Oriented Backend Architecture

This article explains how to apply aspect‑oriented programming principles to a Ruby‑based API service by extracting cross‑cutting concerns such as request encryption, authentication, and permission checks into Nginx Lua middleware, enabling low‑coupling, scalable backend modules.

AOPLuaNGINX
0 likes · 11 min read
How to Leverage Nginx Lua for Aspect‑Oriented Backend Architecture
21CTO
21CTO
Oct 24, 2015 · Mobile Development

How to Deploy New Features in iOS Apps Without Releasing a New Version

This article reviews the various dynamic deployment techniques for iOS apps—Web App, Hybrid App, React‑Native, Lua/Javascript patches, and JSON‑described views—analyzes their pros and cons, and proposes a JSBridge‑based microservice architecture as the most practical solution.

HybridJSBridgeJSPatch
0 likes · 18 min read
How to Deploy New Features in iOS Apps Without Releasing a New Version
21CTO
21CTO
Aug 31, 2015 · Backend Development

Scaling JD.com’s Product Detail Pages with Dynamic, High‑Performance Architecture

This article details the evolution and redesign of JD.com’s product detail page architecture, describing the transition from static HTML generation to a dynamic, high‑performance, multi‑datacenter system built on key‑value storage, Nginx + Lua, asynchronous processing, multi‑level caching, and robust scaling and reliability strategies.

CachingHigh AvailabilityKey-Value Store
0 likes · 34 min read
Scaling JD.com’s Product Detail Pages with Dynamic, High‑Performance Architecture