The article walks through a real‑world investigation of an Nginx HTTP forward proxy on an Alibaba Cloud server that stops accepting new connections after a while, detailing hypothesis testing, strace analysis, fastsocket feature toggles, accept_mutex behavior, and the final fix by adjusting the NIC's RPS settings.
This guide explains how to use the lightweight ngxtop tool to monitor Nginx in real time, showing frequent requests, high‑traffic IPs, and providing useful command examples for filtering logs, ordering results, and installing the utility via pip.
This article details Dangdang Marketplace's comprehensive performance optimization—including component-based design, proactive data generation, asynchronous loading, lazy rendering, multi‑domain and CDN strategies, GZIP compression, and Nginx fastcgi/proxy caching—showing how these measures reduced first‑screen time to under three seconds and dramatically lowered CPU and load during high‑traffic events.
This article details the comprehensive performance optimization strategies applied to Dangdang's marketplace, covering componentization, data generation and loading improvements, front‑end techniques such as lazy loading and script placement, network enhancements like DNS prefetch and CDN, and server‑side caching with Nginx and PHP asynchronous requests, along with measured CPU and load reductions.
This article explains nginx’s high‑performance architecture, detailing its daemon mode with a master process and multiple worker processes, the multi‑process model advantages, signal‑based control, the asynchronous non‑blocking event handling using epoll, and includes a representative pseudo‑code of its event loop.
This article explains how Nginx achieves high concurrency and performance through its master‑worker process model, event‑driven state machine, non‑blocking I/O, and graceful configuration reloads, contrasting it with traditional blocking multi‑process web servers.
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.
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.
After experimenting with Docker to isolate PHP‑FPM and Nginx services, a small startup shares the challenges they faced—from link networking quirks and service discovery with Consul, to CI image builds, log handling, monitoring, and the hidden costs of container restarts—offering practical insights for anyone adopting containerization.
This guide walks through why Nginx is preferred over Apache for high‑traffic sites, provides step‑by‑step instructions for compiling and installing Nginx on CentOS, and details extensive performance tuning and security hardening techniques to support tens of thousands of concurrent connections.
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.
This guide walks through why Nginx is preferred over Apache, detailed steps to compile and install it on CentOS, and extensive configuration tweaks—including worker processes, kernel parameters, SELinux policies, and request‑filtering rules—to achieve high concurrency and robust security for production web services.
This guide walks you through creating a lightweight CDN using Nginx on Ubuntu, covering installation, virtual host configuration, cache settings, and testing, while explaining core concepts like origin pull, proxy caching, and header management for educational purposes.
This article provides a comprehensive overview of software load balancing, detailing the architecture, features, performance characteristics, and various load‑balancing strategies of Nginx, LVS, and HAProxy, and explains how to choose and deploy them in different scenarios.
This article compares Nginx and ZooKeeper as load‑balancing solutions, explains their configurations, highlights scalability challenges with many services, and shows how ZooKeeper can serve as a service registry and notification center to complement or replace Nginx in complex environments.
This article explains how JD.com derives the displayed "JD price" from base prices and promotion rules using a real‑time pricing system built on Nginx, Redis clusters, and Tomcat, detailing the data flow, caching strategy, and disaster‑recovery mechanisms.
When a website suffers from saturated outbound bandwidth due to large image requests, you can quickly mitigate the issue by configuring Nginx to limit the transfer rate of images exceeding 100 KB, ensuring normal traffic remains responsive.
This guide shows how to configure Nginx's limit_conn directives to restrict the number of simultaneous requests from a single IP, test the settings with ApacheBench, and verify that the limits effectively block excess traffic, helping mitigate CC attacks.
This article walks you through designing, installing, and configuring a custom WAF using Nginx and Lua (OpenResty), covering core modules, pain points of native Nginx security, code examples, deployment tips, and future enhancements for robust web protection.
This guide explains how to use GitHub Webhooks together with a shell deployment script, a Node.js listener, and Nginx reverse proxy to achieve fully automated website deployment, covering setup, code examples, and practical considerations.
This guide explains how to automatically rotate Nginx logs each day by renaming the current log file at midnight, creating dated backup directories, and signaling the Nginx master process with USR1 using a simple Bash script scheduled via a cron job.
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.
This article explains reverse proxy concepts, introduces Nginx’s core features and architecture, and provides a step‑by‑step guide to set up Nginx on Windows as a reverse‑proxy and load‑balancer for IIS‑hosted ASP.NET sites, including service registration, configuration tuning, static‑file caching, and testing.
This guide explains how HTTP/2 changes traditional front‑end performance tricks, covers browser support, TLS requirements, Server Push benefits, and provides a concise Nginx configuration example to enable HTTP/2 on your site.
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.
This guide explains key metrics, influencing factors, and practical tuning steps—including bandwidth, hardware, OS limits, TCP parameters, and server configurations—to assess and improve a backend system's maximum request handling capacity under high concurrency.
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.
A sudden high‑load alert on a web server was traced to Nginx’s massive write operations on fastcgi_temp files, revealed through top, iotop, lsof, strace and iostat, and temporarily resolved by redirecting fastcgi_temp to memory.
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.
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.
The article explains why modern web systems face ever‑increasing concurrent connections, analyzes how front‑end techniques and server‑side configurations such as Apache MPM modes, Nginx, sendfile, and epoll can reduce memory and CPU consumption, and offers practical recommendations for efficient backend architecture.
This article examines Node.js’s early criticisms about reliability and single‑threaded limits, then explains how the built‑in cluster module and fork() enable multi‑process deployment, load balancing, and communication, illustrated with code demos, performance insights, and a look at nginx proxy integration.
This article explains how stateless application servers combined with load balancers form scalable clusters, detailing request routing, scaling strategies, and common implementations such as Nginx for HTTP forwarding and LVS for IP‑level balancing.
This article explains how Nginx Plus’s commercial stream module enables TCP load balancing, detailing configuration steps, underlying routing algorithms, health monitoring, connection handling, and performance considerations, while comparing it to HTTP load balancing and other layer‑4 solutions.
This article explains the three types of Nginx processes—master, worker, and cache—detailing each one's responsibilities, from configuration loading and socket management to request handling, cache indexing, and inter‑process communication, while also covering smooth reloads, upgrades, and cache index management.
This article explains how Nginx Plus adds TCP load‑balancing via the stream module, compares it with HTTP load‑balancing, provides configuration examples, describes the routing algorithm, health‑check mechanisms, and performance considerations for high‑concurrency environments.
This guide explains how to bypass cross‑origin restrictions by configuring an Nginx reverse proxy, offering a simpler alternative to JSONP that avoids server‑side code changes while enabling seamless API calls from a different domain.
This guide walks through testing Nginx configuration, starting the server, understanding its load‑balancing architecture, installing from source with required dependencies, handling common build errors, reviewing the final configuration summary, and creating a Linux init script for reliable service management.
This tutorial walks you through creating a Docker‑based backend for a WeChat public account, covering project structure, Nginx and Tomcat configuration, Maven build, Dockerfile creation, and deployment on DaoCloud with continuous integration.
This article details a real‑world Nginx performance tuning case where long‑running client requests caused timeouts, describing how adjusting keepalive settings, TCP reuse parameters, and upstream proxy timeouts eliminated the delays and stabilized the service for millions of calls.
This guide explains how to apply Nginx's early‑alpha HTTP/2 patch, covering required source versions, OpenSSL/LibreSSL preparation, patch application, configuration flags, compilation, and enabling HTTP/2 in the server block, while noting the patch's production limitations.
An in‑depth comparison reveals how Nginx’s epoll‑based I/O model delivers higher concurrency, better efficiency, reduced memory copying, and non‑blocking operation, while Apache’s traditional select model is limited by FD_SETSIZE, linear scanning, and greater kernel‑user space copying overhead.
This guide explains how to use Gearman for Map/Reduce tasks, assign workers to specific CPU cores with taskset, and configure Nginx worker processes with CPU affinity to fully exploit multi‑core servers and improve overall system efficiency.
This step‑by‑step guide shows how to build a MogileFS distributed file system cluster on CentOS, configure MariaDB, set up trackers, storage nodes and domains, compile Nginx with the MogileFS module, create init scripts, and verify fault‑tolerant file access through Nginx reverse proxy.
This article describes a complete two‑machine high‑availability solution that uses keepalived to manage virtual IPs, Nginx for load‑balancing, MySQL GTID replication with Atlas as a proxy, and detailed configuration and fail‑over testing steps to ensure seamless service continuity.
This article explains how to use Nginx rewrite rules to block Internet Explorer and provides a detailed overview of four theoretical I/O models and five practical I/O models used in network services, illustrated with diagrams and a discussion of libevent implementation.
This guide walks you through installing HAProxy, configuring it to balance HTTP traffic between two Nginx instances on ports 8080 and 8081, and verifying the setup by repeatedly accessing a test page that alternates between the two backend servers.
This guide walks you through installing and configuring Nginx for extreme request rates, optimizing kernel TCP settings, and using Tsung to benchmark a server that can sustain more than 900,000 requests per second, with detailed command examples and configuration snippets.
This guide explains key concepts of open source, compilation, and executables, then details the configure‑make‑install workflow and provides a step‑by‑step tutorial for compiling, installing, configuring, and testing Nginx from source on a Linux system.
Learn how to fine‑tune Nginx by adjusting key global, events, and HTTP settings—such as worker processes, connection limits, gzip compression, and file caching—to maximize throughput and reduce latency under heavy client loads, with a complete example configuration and restart instructions.
This guide explains how to create an Nginx configuration file that denies access from unwanted user agents, empty agents, and non‑GET/HEAD/POST requests, shows how to include the file in the server block, reload Nginx, and test the rules with curl.
The article examines the rise of high‑concurrency web connections, explains how richer front‑end interactions increase load, and presents a range of optimization techniques—from caching and request merging to server‑side memory and CPU reductions using Apache MPM modes, Nginx, and sendfile—to improve web service efficiency.
This article examines typical mistakes in Nginx‑PHP configurations—such as misplaced index directives, misuse of the if statement, and fastcgi parameter issues—and presents a cleaner, more secure configuration that leverages inheritance, try_files, and proper fastcgi settings.
This guide explains how to identify high‑frequency visitor IPs from Nginx logs and configure Nginx to deny those IPs—or entire ranges—using block files, includes, and reload commands, providing both basic and advanced blocking techniques.
This article walks through fixing missing static files, collecting assets, restarting uWSGI, and applying essential Django settings and template tweaks to successfully deploy a Django application in a production environment using Nginx and uWSGI.
This guide shares practical, experience‑backed techniques for optimizing Nginx and PHP‑FPM on high‑traffic Linux servers, covering UNIX sockets, worker processes, upstream load balancing, logging, compression, caching, timeouts, buffer sizes, kernel tweaks, and monitoring.
This article explains php‑fpm’s architecture—prefork with async I/O, configurable event mechanisms, and its concurrency model identical to nginx—while offering practical configuration tips such as optimal worker counts and highlighting stability considerations compared to nginx and OpenResty.
This article explains the TCP KeepAlive mechanism, why load balancers like LVS and F5 drop idle connections after 90 seconds, how to configure Linux kernel and socket options, and the correct way to enable TCP KeepAlive in Nginx to prevent premature disconnects.
This article compares the core features, use cases, and performance characteristics of popular web and application servers—Apache, Tomcat, Jetty, Nginx, and JBoss—highlighting their distinctions in handling static versus dynamic content, scalability, and integration with Java and other technologies.
This article examines common website architecture layers, compares hardware (F5) and software (LVS, Nginx) load‑balancing solutions, discusses high‑availability setups with Keepalived/Heartbeat, evaluates their network dependencies, and offers practical recommendations for choosing and monitoring load‑balancers, file servers, and databases in high‑traffic environments.
This article details the design, architecture, implementation steps, and early results of a graded release system for Baidu's mobile Tieba product, showing how staged rollouts, traffic splitting, and automated validation improve release quality and user experience.
