This comprehensive Nginx tutorial walks beginners through core concepts, installation commands, startup scripts, HTTP/HTTPS reverse‑proxy configurations, various load‑balancing strategies, multi‑webapp routing, static site serving, file server setup, and CORS handling with clear examples and code snippets.
This article explains what cross‑origin requests are and presents four practical solutions—webpack proxyTable, SwitchHosts, Uuaper, and Nginx—detailing configuration steps, common pitfalls, and code examples to help developers overcome CORS problems during local development.
This tutorial provides a comprehensive, command‑by‑command walkthrough for installing, compiling, configuring, and starting Nginx, MySQL, and PHP on a Linux server, culminating in a functional LNMP stack test page.
This guide explains how to install ngxtop on CentOS 7, outlines its key features for real‑time Nginx log analysis, and demonstrates common commands for monitoring request counts, top client IPs, filtering 404 responses, and analyzing access logs both live and offline.
This article provides a beginner-friendly overview of Nginx, explaining its role as a high‑performance HTTP server, load balancer and reverse proxy, outlining its advantages, and offering step‑by‑step instructions for installing and configuring Nginx on CentOS 7.
This guide explains how to host a web project on GitHub, configure an Nginx front‑end server, and set up Jenkins with a detailed Jenkinsfile to automate building, packaging, and deploying the application using SaltStack.
This article explains how to configure Nginx as a reverse proxy, implement load‑balancing strategies, separate static and dynamic content, set up proxy caching with various directives, purge caches, and enable gzip compression, providing complete code examples and practical testing results.
This guide explains HTTPS and SSL fundamentals, shows how to generate certificates with OpenSSL, configures Nginx for secure HTTPS, details the rewrite module including break, if, return, and set directives, demonstrates read‑write separation using WebDAV, and provides anti‑hotlinking techniques with valid_referers.
This comprehensive guide explains what Nginx is, its capabilities, step‑by‑step installation methods, core commands, configuration file structure, event‑driven model, global variables, authentication setup, virtual host configurations, and detailed location block usage for effective web server management.
This article explains Nginx's five load‑balancing methods, focusing on the weighted round‑robin algorithm, its basic and smooth variants, provides code examples, step‑by‑step execution, and a mathematical proof of why the smooth version distributes traffic fairly according to server weights.
This article explains why shadow links are essential for safe load testing in model middle platforms, how to isolate traffic using shadow tables, and provides a step‑by‑step implementation guide including interface analysis, data preparation, nginx configuration, and risk considerations.
This article explains the fundamentals of forward and reverse proxies, compares their characteristics and differences, and provides practical Nginx configuration examples for implementing reverse proxy, load balancing, and cross‑origin handling in web applications.
This article introduces Nginx’s key capabilities—including static file serving, various load‑balancing strategies, leaky‑bucket rate limiting, browser and proxy caching, and black‑/white‑list access control—explaining how each feature can be configured and applied in high‑concurrency web environments.
This comprehensive guide explains what Nginx is, why it outperforms Apache, and walks you through installing, compiling, configuring, and running Nginx on CentOS, including essential directives, load‑balancing features, and common command‑line operations.
This article explains the fundamentals of the ngx_rbtree_t red‑black tree used in Nginx, covering its origin from 2‑3 trees, core properties, insertion and deletion algorithms, rotation and recoloring operations, and provides source‑code analysis with illustrative diagrams.
Learn how to set up agent‑less log collection for Nginx using Rsyslog, forward logs via the omkafka module to a Kafka cluster, and process them with Logstash into Elasticsearch for visualization in Kibana, including installation, configuration, and testing steps.
This article explains why session sharing is required in distributed Java back‑ends, demonstrates how Spring Session automatically synchronizes HttpSession data to Redis, and shows step‑by‑step how to configure Spring Boot, Redis, and Nginx to achieve transparent session sharing across multiple service instances.
This article explains how to use Spring Session together with Redis to achieve transparent HTTP session sharing across multiple Spring Boot instances in a clustered environment, including project setup, Redis configuration, sample controller code, Nginx load‑balancing, and deployment steps.
This guide walks you through installing Docker on CentOS 7.6 and deploying a complete mall stack—including MySQL, Redis, Nginx, RabbitMQ, Elasticsearch, MongoDB, and a SpringBoot service—inside Docker containers, configuring volumes, ports, firewalls, and testing the APIs.
This article outlines practical Nginx security settings—including hiding version info, enabling HTTPS, configuring allow/deny lists, basic authentication, request method restrictions, user‑agent blocking, hotlink protection, connection limits, buffer size tweaks, timeout adjustments, and secure response headers—to help harden your web server against common attacks.
This article explains how Nginx obtains and releases shared memory on Unix and Windows, describes the unified ngx_shm_alloc/ngx_shm_free interfaces, and details the slab allocator’s page‑level and small‑block management, including allocation strategies, bitmap handling, and fragmentation issues.
This article analyses why seemingly normal PHP‑FPM requests can cause Nginx to return 502 errors, revealing a FastCGI fastcgi_buffer_size bug triggered by warning output, describing the reproduction steps, detailed packet analysis, the underlying protocol mechanics, and practical recommendations for developers and operators.
This article explains the purpose of load balancing in distributed systems, describes its classification across OSI layers, outlines typical deployment topologies, reviews popular software solutions such as LVS, Nginx, and HAProxy, and summarizes both static and dynamic load‑balancing algorithms.
Load balancing distributes incoming traffic across multiple servers to improve performance, reliability, and scalability, and this article explains its purpose, the differences between layer‑2, layer‑3, layer‑4 and layer‑7 balancing, common software solutions like LVS, Nginx and HAProxy, and various static and dynamic load‑balancing algorithms.
This article explains how Nginx was created to overcome Apache's limitations, describes its role as a high‑performance HTTP and reverse‑proxy server, clarifies forward and reverse proxy concepts, outlines common deployment scenarios, compares load‑balancing algorithms, and provides a feature comparison with other web servers.
This article explains how modern internet systems use server clusters and load balancers, compares the three most popular software solutions—LVS, Nginx, and HAProxy—covers their architectures, NAT and DR modes, advantages, disadvantages, and provides guidance on selecting the right tool for different scale scenarios.
This article documents a series of experiments that examine how Nginx's large_client_header_buffers and client_header_buffer_size directives interact with server and http contexts, revealing that the effective buffer size is determined by the merged value of the default server after configuration parsing.
This article explores server clustering and load‑balancing fundamentals, detailing how LVS, Nginx, and HAProxy operate at different OSI layers, their deployment scenarios, architectures, modes, strengths, and weaknesses, and offers practical guidance for choosing the right solution in modern backend systems.
This article explains the concepts of forward and reverse proxy servers, why organizations use them, and provides step‑by‑step configuration examples for both Nginx and Apache to help engineers enforce network policies and secure service access.
This guide explains how to optimize Nginx by configuring worker processes, CPU affinity, file descriptor limits, event models, HTTP settings, keep‑alive timeouts, FastCGI parameters, gzip compression, expires caching, anti‑hotlinking, kernel tweaks and system connection limits for high‑traffic Linux servers.
F5’s $670 million acquisition of Nginx brings together a leading open‑source web server with a cloud‑security vendor, prompting industry analysts and netizens worldwide to debate the deal’s impact on multi‑cloud application delivery, pricing, open‑source sustainability, and future competition.
This tutorial walks through setting up a personal WeChat account, registering a public account, configuring an Nginx server on a public‑IP host, verifying WeChat signatures with Python, and implementing simple text, image, and QR‑code interactions using the official API.
This tutorial walks through setting up Nginx on Debian to serve static files, reverse‑proxy dynamic requests to Tomcat, configure load‑balancing upstreams, enable gzip compression, implement on‑disk and memory caching, and secure the server with SSL, providing full configuration examples and practical tips.
This tutorial walks through setting up a Nacos cluster for production, covering MySQL data source initialization, cluster configuration files, local multi‑instance testing, deployment on separate nodes, Nginx reverse‑proxy setup, and common troubleshooting steps.
This article explains block, object, and file storage concepts based on Ceph, describes how front‑end JavaScript resources are migrated to an S3‑compatible object store, outlines the supporting Lua/Nginx combo tool, caching strategies, and step‑by‑step e‑commerce migration procedures.
This article presents a detailed overview of Nginx performance optimizations, module types, load‑balancing algorithms, log rotation scripting, custom error page setup, smooth restart procedures, configuration checks, and a comparative analysis with Apache and LVS for backend server administrators.
This guide explains why and how to use Nginx as an HTTPS reverse proxy for WeChat mini‑programs, covering kernel requirements, downloading, compiling with required modules, installation steps, starting the server, core configuration details, enabling SSL, and applying rate‑limiting rules.
This article explains how to monitor Nginx in high‑traffic e‑commerce scenarios, covering essential metrics, latency, error and traffic monitoring, saturation analysis, and visualizing data with ELK and Grafana, plus real‑world case studies and practical configuration tips.
The project re‑engineers Twemproxy by adopting Nginx’s master‑worker multi‑process model, adding non‑blocking accept locks, reuseport load balancing, CPU affinity and crash isolation, which transforms the single‑threaded proxy into a scalable, low‑latency, high‑QPS solution suitable for public‑cloud high‑concurrency workloads.
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.
This tutorial walks you through setting up Java, ElasticSearch 2.1.0, Logstash 2.1.1, Kibana 4.3.1, and NGINX on a CentOS 6.7 server, configuring each component, linking them together, and troubleshooting common time‑zone issues so you can visualize logs with Kibana.
The article details a step‑by‑step investigation of intermittent 502 errors when routing client requests through Nginx to a Node.js service, identifies malformed URL characters triggering Node's clientError event as the root cause, and presents code and configuration fixes to prevent the issue.
This guide explains how to set up the open‑source frp tool to expose local web services through a public domain, covering repository cloning, configuration file edits, service startup, phpStudy virtual‑host settings, error troubleshooting, custom sub‑ and third‑level domains, multi‑client setups, and optional Nginx reverse‑proxy integration.
This guide explains the concepts of forward and reverse proxies, shows how to modify the hosts file for domain binding, walks through installing and configuring Nginx as a reverse proxy, and demonstrates creating a cross‑origin setup with frontend and backend code, including CORS handling and WebSocket support.
This guide explains what Nginx is, how to install it on Linux and Windows, compile from source, use common control commands, and configure HTTP/HTTPS reverse proxy, load balancing, multiple web‑app routing, static site serving, and CORS handling with practical code examples.
This article provides a detailed introduction to load balancing, covering its purpose, layer‑based classifications, popular software solutions such as LVS, Nginx and HAProxy, and a wide range of static and dynamic balancing algorithms used to distribute traffic across server clusters.
This article details the core capabilities of Nginx without third‑party modules, including reverse proxy, various load‑balancing strategies, static and dynamic HTTP serving, forward proxy setup, and hot‑reload commands, providing clear configuration examples for each feature.
This article explains various cache types—including client, browser, CDN, NGINX, application, and unified Redis caches—and presents two real‑world case studies on handling hotspot keys and designing a three‑tier category‑center cache, highlighting performance gains, consistency challenges, and best‑practice solutions for high‑traffic backend systems.
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.
This article presents a comprehensive guide to Nginx performance tuning, covering methodology, request lifecycle, application‑level tweaks, and system‑level optimizations to achieve higher concurrency, lower latency, and better resource utilization.
This article explains the core capabilities of Nginx without third‑party modules, covering reverse proxy, load balancing (including round‑robin, weight, ip_hash, fair, and url_hash), static HTTP serving with dynamic/static separation, forward proxy configuration, and hot‑reload commands.
This article explains how to use Nginx’s built‑in limit_req and limit_conn modules to implement request‑rate and connection‑based throttling, covering configuration directives, execution flow, burst handling, delay modes, whitelist setup with geo and map modules, and practical examples for IP and domain limits.
The article explains the concept of static/dynamic separation, compares deployment methods such as Nginx and CDN, discusses domain strategies, outlines its benefits and drawbacks, and presents an architecture suitable for high‑traffic static content delivery.
This article provides a comprehensive overview of Nginx, covering its high‑performance features, modular architecture, proxy capabilities, event‑driven model, multi‑process and asynchronous processing mechanisms, and how these components work together to deliver scalable web services.
This article explains why static files and JavaScript may not update correctly in a Vagrant‑VirtualBox development setup on Windows, describes the underlying VirtualBox sendfile bug, and provides step‑by‑step instructions to disable sendfile in both Nginx and Apache to resolve the issue.
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.
The article shares three detailed production incidents—an Oracle overload, a blockchain media service overload, and a 502 failure in an Nginx‑Tomcat rental app—explaining how the author diagnosed, mitigated, and permanently resolved each problem, and distilling key operational lessons.
This guide walks through installing Nginx on Linux and Windows, explains core commands, demonstrates HTTP reverse‑proxy setups, load‑balancing across multiple servers, HTTPS with SSL certificates, static‑site serving, and a practical CORS solution for cross‑origin requests.
This article explains why monitoring page performance is crucial for user experience and SEO, outlines the design of a three‑part monitoring system—including front‑end data reporting via Navigation Timing, server‑side log collection with Nginx, data aggregation, sampling, storage, and visual dashboards—providing a complete end‑to‑end solution.
This guide walks through configuring SSH keys, preparing a PHP webhook script, setting up Nginx, linking Coding and GitHub repositories, and troubleshooting common issues to achieve fully automated code deployment on an Ubuntu server.
This tutorial explains what Composer is, walks through installing Laravel, creating a new project, configuring Nginx, handling common permission and font‑loading issues, and provides practical command‑line examples for a complete backend setup.
This article introduces Nginx Unit, walks through its installation on CentOS 6.9, shows how to configure a simple PHP application using JSON, and presents a performance comparison with tengine + php‑fpm, demonstrating significantly higher QPS and lower request latency for Unit.
This article recounts a step‑by‑step migration of a 2010‑era Nginx‑based multi‑site environment and two MySQL databases to a cloud server, highlighting security risks, performance bottlenecks, backup commands, failed restore attempts, and practical lessons learned.
This tutorial walks through setting up Nginx on Debian, configuring worker processes, events, and HTTP settings, defining upstream groups for load balancing, separating static and dynamic content with reverse proxy, enabling gzip compression, implementing proxy caching with shared memory, and adding SSL support with self‑signed certificates.
This article explains why rate limiting is essential for flash‑sale (seckill) systems, compares token‑bucket and leaky‑bucket algorithms, and provides concrete Tomcat, Nginx, OpenResty, and Guava configurations along with code snippets and load‑testing results to help engineers implement robust throttling.
This article explains why rate limiting is essential for flash‑sale (seckill) services, compares token‑bucket and leaky‑bucket algorithms, and provides practical configuration examples for Tomcat, Nginx, and OpenResty, along with testing methods and code snippets.
This article explains why rate limiting is essential for large‑scale flash‑sale (seckill) services, introduces token‑bucket and leaky‑bucket algorithms, and demonstrates practical implementations using Tomcat thread pools, Nginx, OpenResty, and Guava RateLimiter together with stress‑testing commands.
This article explains why high‑traffic scenarios like flash‑sale systems need rate limiting, compares token‑bucket and leaky‑bucket algorithms, and shows practical configurations for Tomcat, Nginx, and OpenResty to protect APIs and ensure system stability.
This article outlines the complete set of front‑end, back‑end, database, server, and deployment technologies and best‑practice knowledge a developer needs to build and run a simple yet functional Java Web application, providing a clear big‑picture roadmap for beginners.
This article explains Nginx's various load balancing algorithms—including round‑robin, weighted, ip_hash, fair, and url_hash—their scheduling states such as down, backup, max_fails, and fail_timeout, and provides example configuration steps with real server IPs, highlighting differences from LVS.
This article explains the principles, architectures, and trade‑offs of three popular software load balancers—LVS, Nginx, and HAProxy—guiding you to select the right solution based on traffic volume, protocol layer, and operational complexity.
The article describes how the Nitro team designed and implemented a Go‑based consistent‑hashing router that leverages Nginx, the Redis protocol, Envoy sidecars, and Mesos to provide low‑latency, high‑throughput request routing and caching for compute‑intensive services.
This article examines the weak health_check mechanism of open‑source Nginx, demonstrates a test setup with two Tomcat backends, analyzes access and error logs to show how Nginx retries failed servers, explains the role of max_fails, fail_timeout, and compares it with Nginx Plus features.
The article explains the thundering herd problem where many processes wake for a single event, describes Linux’s kernel fixes for accept() and partial epoll solutions, and details how Nginx avoids the issue using a custom inter‑process accept mutex and lock design.
Learn how to set up a personal WeChat public account, configure a public platform test server on Alibaba Cloud, verify messages via Python and Tornado, and implement basic text, image, and QR‑code interactions using the official WeChat API, complete with code snippets and configuration details.
This article details the three‑stage evolution of Ctrip's image service architecture—from an early NFS‑backed design with Squid caching, through a Varnish‑and‑Lua powered middle stage, to the current Go‑based multi‑process system using FastDFS—highlighting the challenges, solutions, and performance outcomes.
This article compares Nginx and Apache, explains Apache's three processing models, details how Nginx achieves superior high‑concurrency performance through event‑driven, single‑threaded architecture and efficient memory usage, and outlines key techniques for building scalable web servers.
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.
This article explains Nginx's role as a lightweight web and reverse‑proxy server, clarifies forward vs reverse proxy concepts, details the master‑worker architecture, hot deployment, high‑concurrency handling with epoll, and shows how to achieve high availability and load balancing using Keepalived, upstream blocks, and caching.
This article humorously recounts the “80‑port war” between Apache and Nginx, using a comic strip to compare the legacy server’s extensive module list and age with Nginx’s event‑driven performance, C10K handling, and modern extensions, ultimately asking which will dominate the web.
This article analyzes a recurring Nginx 502 Bad Gateway error triggered by oversized response headers from PHP‑FPM, explores whether fastcgi_buffer_size is the root cause, captures communication data between Nginx and PHP‑FPM, conducts systematic tests with varying buffer sizes, and draws conclusions about header handling and buffer configuration.
This article shares a Linux operations engineer’s interview experience, presenting seven common interview questions—self‑introduction, gray‑release implementation, MongoDB deployment, Jenkins‑based release and rollback, Tomcat work modes, monitoring solutions, and data backup—along with concise, practical answers and preparation tips.
This guide walks you through installing Nginx on CentOS, compiling from source, configuring core settings, managing workers, setting up virtual hosts, and using common directives such as gzip, proxy, and access control to optimize performance and security.
This guide shows front‑end developers how to use Fiddler with the Willow plugin, Switch Host, and Nginx to proxy static resources, enable mobile device testing, and forward API calls, providing practical tips, configuration steps, and common pitfalls for efficient debugging.
This guide explains how Nginx's rate‑limiting works, covering the leaky‑bucket algorithm, basic directives, burst and nodelay options, whitelist handling, logging, custom error codes, and advanced configuration examples for securing and optimizing HTTP request traffic.
FastDFS is an open‑source lightweight distributed file system written in C, designed for high‑availability file storage and load balancing; this article explains its differences from Hadoop, details its Tracker and Storage architecture, outlines file upload/download workflows, and provides step‑by‑step instructions for installing and configuring FastDFS, Nginx, and related components.
This tutorial walks through setting up a Python web project, creating a virtual environment, installing Flask, deploying with Gunicorn, managing processes via Supervisor, and configuring Nginx as a reverse proxy, providing a full end‑to‑end deployment workflow.
This article explains the fundamentals of load balancing, compares layer‑2 to layer‑7 approaches, reviews popular software solutions such as LVS, Nginx and HAProxy, and details both static and dynamic balancing algorithms with practical implementation guidance.
This guide explains how network bandwidth, quality, switch convergence, server CPU, memory, disk, NIC, Linux kernel parameters, and Nginx compilation and configuration choices together affect Nginx throughput, and provides concrete optimization steps for each layer.
This guide walks you through why Django and VueJS make a powerful pairing, explains their integration, and provides step‑by‑step instructions for setting up the project, configuring templates and static files, handling development and production environments, and deploying with uWSGI and Nginx.
This article explains Nginx’s modular architecture, core, standard and optional HTTP modules, mail service and third‑party extensions, then details its multi‑process and asynchronous non‑blocking request handling, event‑driven model, master‑worker design, and inter‑process communication, providing a solid foundation for deeper source‑code study.
This article shares practical experience on evolving a single‑server Java monolith into a scalable architecture by introducing Nginx reverse proxy, separating services and static resources, adopting load‑balancing strategies, implementing distributed sessions, enabling read/write separation, and applying CI/CD tools such as Docker, Jenkins, Git, and Maven.
This article explains how to measure a system's load capacity, identifies key factors such as bandwidth, hardware, OS and application configurations, and provides practical optimization techniques for Linux, Tomcat, Nginx, MySQL, and Redis to handle high concurrency efficiently.
The article presents advanced Nginx configuration techniques—including hiding version information, customizing 404 pages, outputting JSON logs, applying client‑based request logic, forcing download filenames, implementing rate limiting, and using traffic mirroring—while also touching on upstream and caching features for enhanced security, observability, and traffic management.
This article presents a comprehensive, data‑driven guide to reducing latency and increasing throughput of Nginx‑based web servers by covering hardware selection, low‑level OS tuning, network‑stack adjustments, TLS optimizations, and application‑level configurations, all illustrated with real‑world Dropbox experience.
The article details how to identify and resolve memory leaks and performance bottlenecks in high‑concurrency Nginx workloads using tools such as Valgrind, AddressSanitizer, perf and flame‑graphs, while also sharing practical tips and personal reflections on debugging under pressure.
hiproxy is a Node.js‑based, lightweight and extensible proxy solution that unifies hosts, Nginx‑style routing, HTTPS certificate management and browser integration to streamline front‑end development environment configuration, sharing, and debugging across teams.
This guide walks you through installing Nginx on CentOS 7.5, configuring it as a high‑performance reverse proxy, setting up environment variables, managing common commands, and implementing practical scenarios such as request forwarding, Tomcat integration, load balancing, static file handling, and sub‑domain routing.
This guide explains how to use Nginx as an HTTPS reverse proxy for WeChat mini‑programs, covering kernel requirements, downloading the proper version, compiling with necessary modules, starting the server, configuring nginx.conf, and setting up rate limiting, all on a CentOS system.
This guide explains why plain HTTP is insecure, introduces SSL/TLS fundamentals, compares certificate types, and provides step‑by‑step instructions for configuring HTTPS on a web server (including Nginx redirects), while highlighting performance impacts and testing considerations.
