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.
This article explains how to configure Nginx as a reverse proxy to maintain long‑lived HTTP/1.1 keep‑alive connections between client and Nginx and between Nginx and upstream servers, covering required directives, upstream and location settings, performance implications for high QPS workloads, and advanced WebSocket handling.
This article explains how to configure Nginx as a reverse proxy to maintain long‑lived client and server connections, optimize keep‑alive parameters, and avoid connection churn in high‑QPS scenarios, providing practical code examples and advanced tuning tips.
This article walks through a detailed investigation of a slow‑response issue in a Kubernetes‑deployed application, covering network topology, full‑link latency statistics, packet captures, kernel‑level bottlenecks, and the final remediation steps to restore performance.
This article explains the four SSL session cache modes in Nginx, demonstrates with Wireshark captures how enabling the cache cuts TLS handshake time, and shows that reusing sessions can improve connection efficiency by roughly 40%.
This article explains how Nginx runs as a daemon with a master process and multiple worker processes, why it prefers a multi‑process asynchronous non‑blocking architecture over threads, and details the key internal data structures such as connections, requests, arrays, queues, lists, strings, memory pools, hash tables, and red‑black trees that enable its high‑performance HTTP handling.
This guide explains Nginx's core concepts, installation on Linux, common commands, configuration structure, reverse‑proxy and load‑balancing implementations, static‑dynamic separation, and high‑availability setup with keepalived, providing step‑by‑step examples and practical code snippets.
This article explains how Nginx achieves high performance through its modular design, event‑driven architecture, multi‑stage asynchronous request handling, master‑worker process model, and efficient memory‑pool implementation, contrasting it with traditional web servers and illustrating each concept with diagrams.
This guide explains how to configure a Spring Boot application with MySQL and SQL Server data sources, use Nginx to expose capture‑server images as URLs, and implement Vue components for on‑demand photo preview of traffic‑violation records.
This comprehensive guide walks you through Docker fundamentals, from the underlying concepts of containers versus virtual machines to hands‑on installation, image creation, container deployment, and best practices, empowering developers to containerize and ship applications efficiently.
This guide demonstrates how to achieve high availability for Nginx by deploying Keepalived in a virtual IP failover setup, covering installation via yum or source, configuration of keepalived and VRRP scripts, service management, and verification steps on two CentOS servers.
This article provides a detailed introduction to Nginx, covering its architecture, core configuration directives, installation steps, reverse proxy and load‑balancing setups, caching, HTTPS, CORS handling, gzip compression, and practical examples to help developers and operations engineers configure and use Nginx effectively.
This article explains Nginx’s multi‑process model, worker management, request handling flow, event‑driven architecture, module types, comparison with Apache, and I/O multiplexing mechanisms such as select, poll and epoll, providing a comprehensive understanding of its high‑concurrency capabilities and configuration limits.
This step‑by‑step guide shows how to install the libmaxminddb library, compile NGINX with the ngx_http_geoip2 module, download the latest GeoLite2 database, configure geoip2 directives, and verify that foreign IP addresses are blocked with a 404 response.
This article explains the main components of a Spring Cloud‑Nginx architecture, version compatibility between Spring Cloud and Spring Boot, essential middleware such as Eureka, Nacos, Zuul and Redis, environment preparation on CentOS, and the structure of the crazy‑springcloud scaffolding used for a high‑performance seckill demo.
This tutorial walks you through replacing yum sources, installing and configuring Docker with kernel tweaks and a mirror, adding the Nginx repository and setting up host resolution, then pulling and running a Jenkins container while addressing common plugin‑download issues.
This guide walks you through installing the ngx_http_geoip2 module, upgrading Nginx, downloading the GeoLite2 database, configuring Nginx to detect foreign IPs, and applying rules that return a 404 response for non‑Chinese visitors, complete with command‑line examples and verification steps.
This article presents a 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 and customize their web server deployments.
This guide walks through installing Loki and Promtail in local mode, configuring Nginx to emit JSON logs, adjusting Promtail settings, and using LogQL’s JSON extraction (with and without parameters) to build queries that count successful Nginx requests over a selectable time range.
This article introduces Docker fundamentals, compares virtual machines with containers, explains core Docker concepts, guides through installation, Dockerfile creation, image building, container deployment, and best practices, using a Vue project as a practical example.
This article explores Nginx's origins, why it outperformed Apache, its core features such as event‑driven architecture and modularity, explains forward and reverse proxy concepts, and details the load‑balancing algorithms Nginx supports, providing practical insights for backend engineers.
This article explains what Nginx is, its reverse‑proxy and forward‑proxy concepts, the modular design and processing flow, the master‑worker multi‑process model, hot‑reload mechanisms, and how to achieve high availability with Keepalived, providing a comprehensive overview of the web server’s inner workings.
This guide explains how to optimize Nginx by customizing 404 error pages, enabling and reading the stub_status module, increasing worker processes and connections, adjusting Linux file limits, expanding header buffers, and configuring browser caching for static assets, all with concrete command examples.
