This guide walks through installing Nginx on Linux, configuring reverse‑proxy and various load‑balancing methods, setting up SSL, integrating Keepalived for high‑availability, and deploying LVS (DR mode) with ipvsadm to create a robust, fault‑tolerant web‑service cluster.
This article provides a comprehensive overview of Nginx, covering its definition, advantages, typical use cases, request processing flow, high‑concurrency design, proxy types, directory layout, key configuration directives, load‑balancing algorithms, rate‑limiting mechanisms, security features, and practical deployment tips for modern web services.
This article provides a step‑by‑step tutorial on installing Nginx, setting up reverse‑proxy and various load‑balancing methods, configuring SSL, deploying Keepalived for failover, and building an LVS‑DR high‑availability cluster with detailed command examples and configuration snippets.
This article explains how to design and implement a high‑concurrency ticket‑seckill system by analyzing the 12306 architecture, introducing multi‑layer load balancing, demonstrating Nginx weighted round‑robin configuration, and providing Go and Redis code to achieve stable, low‑latency ticket purchasing under massive simultaneous requests.
This guide walks you through selecting a low‑cost Raspberry Pi Zero W, flashing Raspbian Lite, enabling SSH and Wi‑Fi via boot‑partition files, configuring the system, installing Nginx, and exposing the site to the internet using ngrok, providing a compact, fully functional web‑hosting platform.
This step‑by‑step guide shows how to collect, parse, and visualize Nginx access logs using the ELK stack, configure Logstash pipelines, set up Elasticsearch indices, proxy Kibana through Nginx, and secure access with HTTP basic authentication.
Nginx, a high‑performance HTTP and mail proxy server, achieves near‑million QPS throughput through its multi‑process architecture, efficient CPU core utilization, and fine‑grained configuration options, and this guide explains its design, core processes, configuration syntax, common directives, and practical usage scenarios for developers and ops engineers.
The article recounts Igor Sysoev’s farewell from Nginx, outlines his pioneering role in creating the world’s leading web server, details the company’s growth, commercialisation, legal battles, and explains how his legacy will continue to shape internet infrastructure.
Learn how to enhance your Nginx server by creating custom 404 error pages, enabling and reading the stub_status module, increasing worker processes and connections, adjusting kernel limits, expanding header buffers, and configuring client-side caching for static assets, with step‑by‑step commands and examples.
This guide demonstrates multiple ways to gather Nginx access and error logs—directly with Filebeat to Elasticsearch, via Filebeat to Logstash then Elasticsearch, and using rsyslog to forward logs to Logstash—providing step‑by‑step configurations, code snippets, and visual illustrations for each method.
This tutorial walks through installing Nginx from source, setting up upstream reverse‑proxy groups, configuring various load‑balancing methods (weight, IP hash, URL hash, least connections), enabling SSL, deploying Keepalived for failover, and building an LVS‑DR high‑availability cluster with detailed command‑line examples.
This guide walks you through setting up a CI/CD environment on a CentOS server using Docker, Git, Java, and Jenkins, covering installation, configuration, plugin management, and practical examples such as building Docker images, deploying a React app with Nginx, and automating the entire pipeline.
This guide explains what virtual hosts are, how they work in Nginx, and provides step‑by‑step commands to create directory structures, test pages, server block configuration files, enable and disable sites, and verify the setup on a Linux server.
This article walks through the evolution from a single‑server Tomcat setup to a multi‑layer architecture using Nginx, a gateway, and LVS, explaining dynamic/static request separation, high‑availability strategies, and the performance trade‑offs that guide scalable backend design.
This roundup introduces Create React App 5 with Webpack 5 and Tailwind support, demonstrates how to use the express‑validator middleware in Express, highlights Pinia as a type‑safe Vue state manager, and points to a practical Nginx location configuration guide.
This article explains how to leverage OpenResty and Lua scripts to integrate Nginx with Redis for direct caching, compression, timed updates, request forwarding, and configurable URL management, thereby improving concurrency, reducing latency, and enhancing the resilience of backend web services.
This tutorial shows how to create a single‑page web app that displays the current date, weekday, and the number of days remaining until major holidays and the weekend, using FastAPI for the backend, Jinja2 for templating, and the zhdate library for lunar calendar conversion.
This guide explains how to keep Swagger annotations in sync with Yapi by generating a swagger.json file, exposing it via Nginx, and configuring Yapi’s automatic import, so that API documentation updates automatically after each code change without manual effort.
This guide walks you through Nginx fundamentals, reverse‑proxy concepts, load‑balancing techniques, static‑dynamic separation, cross‑platform installation steps, essential commands, and core configuration examples, equipping developers with the skills to deploy and manage a robust web server.
This guide explains the principles, installation via Helm, example deployments, authentication, URL rewriting, canary releases, TLS setup, TCP/UDP service exposure, and global configuration of the nginx-based ingress-nginx controller for Kubernetes clusters.
This guide demonstrates how to automate the installation, configuration, and service management of Nginx across multiple hosts using Ansible roles, detailing environment setup, directory structure, task definitions, and execution commands.
This article provides a step‑by‑step tutorial on preparing a CentOS environment, installing Nginx via the LNMP package, explaining core concepts such as epoll, lightweight design and CPU affinity, and detailing configuration examples for basic settings, static resources, caching, CORS, anti‑hotlinking, and proxy services.
This article compiles a practical Nginx cheat sheet covering listening ports, access logs, server names, static file serving, redirects, reverse proxy, load balancing, SSL settings, and a visual configuration tool, providing ready-to-use snippets for high‑performance web server setups.
This article provides a comprehensive overview of load balancing technologies—including LVS, Nginx, and HAProxy—detailing their architectures, operating modes, advantages, and drawbacks, and explains how to choose and configure them for high‑performance, scalable backend systems.
This guide explains how to set up a two‑node high‑availability Nginx service on CentOS using Keepalived, covering preparation, installation of Nginx and Keepalived, configuration of VRRP, virtual IP, health‑check scripts, and a failover demonstration.
A Kubernetes‑deployed business app sees its QPS drop from over 100k with a NodePort service to about 50k when exposed via Ingress, but adjusting Nginx keep‑alive parameters in the ingress‑controller can restore and even exceed the original performance while also enabling high availability.
This guide explains how to efficiently deploy a React frontend to a private server by either uploading the compiled build folder or pushing source code to a bare Git repository, then using a post‑receive hook to automatically build, package, and serve the application with Nginx.
This tutorial demonstrates how to create a Dockerfile on a CentOS host, build an Nginx image, run the container, and verify its operation, while highlighting the importance of specifying an entrypoint or CMD in the Dockerfile.
This guide walks through the fundamentals of the RTMP protocol, introduces FFmpeg, shows how to download and configure Nginx‑RTMP on Windows, create the necessary directories, start the server, craft a batch script to push a local video stream, and verify playback with VLC.
This article explains how a host‑level Nginx reverse proxy and a Kubernetes nginx‑ingress pod work, detailing their configuration files, the role of Ingress resources, and how traffic is routed to service endpoints within a cloud‑native environment.
This article provides a concise collection of frequently used Nginx configuration examples—including listening ports, access logs, server names, static assets, redirects, reverse proxy, load balancing, and SSL settings—to help developers quickly set up a high‑performance web server.
This article compiles essential Nginx interview questions covering its definition, key features, differences from Apache, request handling mechanisms, master‑worker architecture, proxy types, module usage, and common configuration directives, providing a comprehensive guide for backend engineers preparing for technical interviews.
This article explains how to apply rate limiting at each layer of a modern service architecture—SLB, Nginx, Spring Cloud Gateway, and individual microservices—detailing traffic characteristics, interception methods, isolation techniques, and practical configurations to protect systems from overload, attacks, and cascading failures.
This article explains how to build a dynamic IP blacklist using Nginx, Lua, and Redis, covering installation, configuration, Lua scripting, and deployment steps to reject requests from blacklisted IPs while keeping the solution lightweight and shareable across multiple servers.
This article explains Docker fundamentals and demonstrates step‑by‑step image optimizations—using Alpine base images, multi‑stage builds, and Nginx—to reduce a React app container from over a gigabyte down to just 22 MB while preserving functionality.
This article provides a concise collection of frequently used Nginx configuration snippets—including listening ports, access logs, server names, static assets, redirects, reverse proxy, load balancing, and SSL settings—along with a brief introduction to an online visual configuration tool.
This article examines how the presence or absence of a trailing slash in Nginx's location blocks and proxy_pass directives affects URL matching and request forwarding, illustrating four proxy_pass scenarios with examples and providing configuration experiments to help avoid common pitfalls.
This article explains a lightweight, loosely‑coupled solution for real‑time monitoring of HLS video playback in vehicle IoT, detailing how to embed device and session identifiers in HLS requests, modify M3U8 files, and collect statistics with NGINX Lua scripts.
This guide explains how to use OpenResty’s Lua modules to let Nginx read and write Redis directly, compress large payloads, schedule periodic cache updates, and configure URL‑based caching, thereby reducing latency, saving bandwidth, and improving overall backend reliability.
This article explains how the presence or absence of a trailing slash in Nginx location blocks and proxy_pass directives changes request matching and URL rewriting, illustrated with concrete configuration examples and test results to help avoid common deployment errors.
This article explains how to use OpenResty with Lua to integrate Nginx and Redis for high‑performance caching, data compression, timed updates, and configurable URL management, enabling resilient backend services that continue serving content even when application servers fail.
This guide walks through three practical methods for harvesting Nginx access and error logs—directly with Filebeat to Elasticsearch, via Filebeat‑Logstash‑Elasticsearch pipeline, and using Rsyslog to forward logs to Logstash—complete with configuration snippets and visual illustrations.
This article introduces Nginx‑GUI, explains its requirements and current implementation for configuration and performance monitoring, provides step‑by‑step installation and configuration instructions with code snippets, and lists the features already realized and the remaining challenges such as log analysis and traffic statistics.
The article explains how a senior architect uses OpenResty and Lua to let Nginx directly access Redis for caching, compresses large responses, schedules periodic updates, and provides a configurable, signature‑verified caching layer to improve web performance and resilience.
This article explains how Nginx location directives match request paths and demonstrates the four different behaviors of proxy_pass when the trailing slash is present or omitted, using concrete configuration examples and test results to clarify the impact on URL rewriting and request forwarding.
This tutorial walks through the basics of Raspberry Pi Zero W hardware, prepares a micro‑SD card with Raspbian Lite, enables SSH and Wi‑Fi on first boot, updates the system sources, installs and configures nginx, and finally exposes the web service to the Internet using ngrok for seamless remote access.
This article explains how Nginx location matching works, why the presence or absence of a trailing slash in both location blocks and proxy_pass directives changes request routing, and provides concrete configuration examples to avoid common pitfalls.
This article explores the design of a high‑concurrency train‑ticket flash‑sale system, covering distributed load‑balancing strategies, Nginx weighted round‑robin configuration, local and remote stock deduction using Go and Redis, performance testing with ApacheBench, and key architectural lessons for preventing overselling and ensuring high availability.
This article provides a comprehensive step‑by‑step guide on configuring Nginx rewrite rules, implementing anti‑hotlink protection, separating static and dynamic resources, and setting up Keepalived for high‑availability load balancing, complete with example configurations and shell scripts.
This article introduces the Raspberry Pi Zero W hardware, explains how to download and flash a Raspbian Lite image onto a micro‑SD card, configures SSH and Wi‑Fi, optimizes the system, installs nginx, and demonstrates basic network‑exposure techniques such as ngrok for remote access.
This guide walks you through the entire process of preparing a Raspberry Pi Zero W, flashing a Raspbian Lite image, configuring Wi‑Fi and SSH, installing Nginx, optimizing the system, and exposing the web server to the internet using tunneling services.
This article explains how a Kubernetes nginx‑ingress pod acts as a gateway, converting Ingress YAML definitions into Nginx reverse‑proxy settings, detailing host‑level and pod‑level configurations, deployment manifests, service exposure, and scaling considerations.
This guide walks you through installing, configuring, and running the open‑source Nginx‑GUI tool on a Linux server, covering download, property file edits, Linux‑specific renaming, permission setup, startup commands, and the features currently supported versus pending.
The article explains why session sharing is critical in micro‑service and distributed deployments and presents four backend solutions—Nginx ip_hash load balancing, Tomcat session replication, Redis‑based centralized session storage, and cookie‑based sessions—detailing their implementations, advantages, and drawbacks.
This guide walks through deploying a SpringBoot‑Vue split‑stack project with Docker by creating separate containers for Redis and MySQL, building custom Docker images for the backend JAR and the Nginx‑served frontend, configuring host networking, and exposing the necessary ports for verification.
This guide explains how to dramatically reduce Docker image sizes—from over a gigabyte down to just a few megabytes—by switching to lightweight base images, employing multi‑stage builds, and using Nginx for static content, with step‑by‑step code examples and visual size comparisons.
This article explains how to reduce Docker image size by switching to Alpine base images, applying multi‑stage builds, and finally serving the built React application with Nginx, shrinking an initial 1.16 GB image down to just 22.4 MB.
This article explains how Nginx rate limiting works, covering the leaky‑bucket algorithm, basic and advanced configurations such as burst and nodelay parameters, whitelist handling, multiple limits, logging, custom status codes, and how to deny all requests for a location.
This guide walks through building a minimal Nginx server, explains the root, location, and try_files directives with syntax, modifiers, matching priority, and practical code examples, and highlights common pitfalls such as using try_files in the wrong context.
This article introduces Nginx as a high‑performance HTTP and reverse‑proxy server and provides a concise collection of commonly used configuration snippets—including listening ports, logging, server names, static files, redirects, reverse proxying, load balancing, and SSL settings—to help developers set up and optimize their web services efficiently.
This article explains how a Kubernetes nginx‑ingress pod acts as a gateway, converting Ingress YAML definitions into Nginx upstream and server blocks, and shows the necessary deployment and service configurations for exposing HTTP and HTTPS traffic.
This tutorial shows step‑by‑step how to containerize a ReactJS app and dramatically shrink its Docker image using Alpine base images, multi‑stage builds, and Nginx, reducing the size from 1.43 GB to just 22.4 MB while preserving functionality.
This article provides a detailed tutorial on setting up an NFS server, configuring a Kubernetes deployment of Nginx with NFS volume mounts, and explains static versus dynamic persistent storage in K8s, complete with command examples and YAML configuration.
This article explains what Nginx is, why it’s chosen for high‑performance reverse proxy and load balancing, walks through its event‑driven architecture, core configuration directives, virtual host setups, location regex rules, static‑dynamic separation, rate‑limiting techniques, load‑balancing algorithms, high‑availability settings and practical code examples.
This guide explains how to build a minimal, secure Nginx server, covering the required minimal configuration and detailed usage of the root, location, and try_files directives with practical code examples and matching rules.
This guide explains how to achieve high availability for Nginx using Keepalived by setting up a double‑machine hot‑standby configuration, installing necessary packages, configuring VRRP‑based failover, writing health‑check scripts, and testing automatic VIP takeover when the primary server fails.
This article provides a comprehensive introduction to Docker, covering its fundamental concepts, differences from virtual machines, step‑by‑step installation, creating Dockerfiles, building and running container images, publishing to registries, and practical best‑practice recommendations for modern cloud‑native development.
This guide walks through configuring Nginx as a static file server, explains location directives and regex patterns, shows how to set up reverse proxying, explores various load‑balancing strategies, demonstrates dynamic‑static separation, and covers useful directives such as return, rewrite, error_page, logging and access control.
This article examines the challenges of implementing a flash‑sale (秒杀) system—such as overselling, massive concurrency, request flooding, URL exposure, and database strain—and presents a comprehensive backend design that includes dedicated databases, dynamic URLs, static page rendering, Redis clustering, Nginx load balancing, optimized SQL, token‑bucket rate limiting, asynchronous order processing, and service degradation strategies.
This article explains why session sharing is critical in micro‑service architectures, compares common Nginx load‑balancing methods, and provides four practical solutions—ip_hash load balancing, Tomcat session replication, Redis‑based session caching, and cookie‑based sharing—complete with configuration examples and pros/cons.
This guide explains how to boost Nginx Ingress Controller throughput in high‑concurrency Kubernetes environments by adjusting kernel parameters, fine‑tuning Nginx settings, and applying optimal ConfigMap configurations for keep‑alive, timeouts, worker connections, retries, and Brotli compression.
This article explains why rate limiting is essential for system stability, compares it with caching and degradation, details three core algorithms—counter, leaky bucket, and token bucket—and provides concrete Guava, Java, and Nginx + Lua code examples for implementing both local and distributed throttling.
This article explains how traditional host‑based Nginx reverse‑proxy configurations compare with the nginx‑ingress controller running as a pod in Kubernetes, detailing their setup, deployment YAML, ingress resources, and generated Nginx configuration for exposing services.
This article provides a step‑by‑step tutorial on configuring Nginx as an HTTP server, serving static files, setting up reverse proxy, implementing various load‑balancing strategies, separating static and dynamic content, and using common directives such as return, rewrite, error_page, logging and access control.
This article explains how Nginx implements rate limiting using the leaky‑bucket algorithm, walks through basic and advanced configurations—including zones, burst, nodelay, whitelists, multiple limits, logging, custom status codes, and request denial—while providing complete configuration examples.
This article introduces systemd as the modern Linux service manager, explains its key features and unit file syntax, and provides step‑by‑step practical examples for controlling Nginx, Tomcat, and custom Java JAR applications with systemd commands.
This article walks through the evolution of a web service architecture—from a single Tomcat server to a multi‑node setup with load balancers, gateways, static‑dynamic separation, and finally a combined LVS‑Nginx solution with DNS load balancing and CDN integration—explaining each component and its impact on scalability and reliability.
In distributed micro‑service environments, session sharing is essential to prevent repeated logins, and this article explains four practical solutions—Nginx ip_hash load balancing, Tomcat session replication, Redis‑based centralized sessions, and cookie‑based sharing—detailing their implementations, advantages, and drawbacks.
This article explains how Nginx implements rate limiting using the leaky‑bucket algorithm, walks through basic directives like limit_req_zone and limit_req, and demonstrates advanced features such as burst, nodelay, whitelisting, multiple limit rules, logging, custom status codes, and request denial.
This article details a practical smooth‑release process for a cloud‑office system, explains how to use Nginx health‑check endpoints to take instances offline, and presents three AB‑testing routing strategies—IP‑based, cookie‑based, and AB‑cluster proxy—complete with configuration examples, pros and cons, and deployment steps.
This article explores the architecture and implementation of a high‑traffic ticket‑spike service, covering load‑balancing strategies, Nginx weighted round‑robin configuration, local and remote stock deduction using Go and Redis, fault‑tolerant buffering, and performance testing results.
The article explains Nginx’s high‑performance, event‑driven architecture, detailing its master‑worker process model, asynchronous non‑blocking I/O, CPU affinity, accept‑mutex load balancing, and the modular design built around ngx_module_t, covering core and HTTP modules, configuration parsing, data structures, and compilation guidelines for developers.
This guide walks you through installing and configuring the ELK stack—Elasticsearch, Logstash, and Kibana—on Ubuntu, setting up Logstash shipper and indexer pipelines, integrating Spring Boot and Nginx logs, and managing the services with Supervisor for reliable, real‑time log analysis.
This article outlines ten actionable techniques—including reverse proxy deployment, load balancing, caching, compression, SSL/TLS optimization, HTTP/2 adoption, software upgrades, Linux tuning, web‑server tweaks, and real‑time monitoring—that together can boost a web application's speed and reliability by up to ten times.
This article provides a detailed tutorial on configuring Nginx as an HTTP server, setting up static file serving, implementing reverse proxy, configuring various load‑balancing strategies, and using advanced directives such as location matching, return, rewrite, error_page, and logging.
This article explains what a Kubernetes Operator is, how it works, and provides a step‑by‑step guide with code examples for creating, building, deploying, and managing a simple Nginx Operator using the Operator SDK.
This article provides a practical guide to tuning Linux kernel parameters and NGINX configuration directives—such as backlog queues, file descriptors, worker processes, keepalive connections, access‑log buffering, sendfile, limits, caching and compression—to achieve optimal web server performance for high‑traffic sites.
This guide explains how to install the ngx_http_geoip2 module, upgrade Nginx, configure GeoIP2 databases, and modify the Nginx configuration to block requests from foreign IP addresses, providing step‑by‑step commands and example code for a Linux server.
This article breaks down Nginx’s high‑performance architecture, covering its modular design, event‑driven processing, multi‑stage asynchronous request handling, master‑worker process model, and memory‑pool strategy, and explains how each component contributes to scalability, low latency, and efficient resource utilization.
This article explains why web performance is critical today, presents ten practical optimization techniques—including reverse proxy, load balancing, caching, compression, SSL/TLS tuning, HTTP/2, software upgrades, Linux and server tuning, and real‑time monitoring—to potentially increase web application speed by up to tenfold.
This comprehensive guide walks you through Docker fundamentals, compares virtual machines to containers, explains core concepts, shows step‑by‑step installation, image building, container execution, and best practices, enabling you to containerize a Vue project and deploy it with Nginx effortlessly.
This article summarizes Nginx's high‑performance architecture, covering its modular design, event‑driven processing, multi‑stage asynchronous request handling, master‑worker process model, and memory‑pool strategy, while illustrating each concept with diagrams and practical observations from recent reading notes.
This comprehensive guide walks you through installing Nginx from source, configuring global settings, mastering common directives, enabling gzip compression, setting up reverse and forward proxies, load balancing, SSL, systemd service management, and troubleshooting, providing ready-to-use code snippets and practical examples for server administrators.
This article explains the essential characteristics of high‑availability architectures—master‑slave failover, load balancing, and horizontal scaling—and reviews six practical solutions including LVS + Keepalive, NGINX, Zookeeper, client‑side strategies, service‑level replication, and middleware approaches.
This tutorial walks through installing Docker on macOS, configuring a fast Chinese mirror, and using Docker commands to pull, run, and link MySQL, Nginx, and PHP‑FPM containers, including volume mounting, configuration file adjustments, and installing common PHP extensions.
Learn how Linux’s non‑blocking I/O mechanisms such as select, poll, and epoll enable high‑concurrency servers, explore OpenResty’s Lua‑based architecture, and follow step‑by‑step instructions for installing, configuring, and troubleshooting a performant OpenResty/Nginx environment on Linux.
This article explains the meaning of Nginx upstream directives max_fails and fail_timeout, shows their default values, walks through a step‑by‑step experiment with two PHP‑FPM backends, and clarifies common misconceptions about failure handling and timeout settings.
The article explains Nginx’s master‑worker architecture, showing how the master process handles signals, restarts workers, and performs hot configuration or binary reloads, while workers use an event‑driven epoll loop with an accept‑mutex to efficiently process connections and balance load across cores without multithreading.
This article explains why internet products need a gray release system, outlines its basic architecture, describes common gray release strategies, and shows how to implement them using Nginx, gateway services, and database handling for complex deployment scenarios.
An intermittent 403 error caused by nginx reuseport misrouting on a shared IP was traced to kernel listener hash table ordering; upgrading the Linux kernel from 4.14 to 4.16+ resolved the issue by prioritizing IP+PORT over INADDR_ANY lookups.
