This cheat sheet provides concise Nginx configuration examples covering listening ports, logging, domain handling, static file serving, redirects, reverse proxy, load balancing, and SSL setup, helping developers quickly configure a high‑performance web server.
This article provides an in‑depth tutorial on Nginx, covering its core concepts, installation, configuration directives, reverse proxy, load balancing, caching, HTTPS setup, CORS handling, gzip compression, and the internal multi‑process architecture for high‑performance web serving.
This article explains the concept of gray (canary) release, outlines a basic architecture with essential components, describes common gray release strategies such as header, cookie, and parameter based routing, and provides practical guidance for implementing gray releases using Nginx, gateway services, and handling complex scenarios like multi‑service and database migrations.
This guide demonstrates multiple methods for gathering Nginx access and error logs—directly with Filebeat to Elasticsearch, via Logstash for preprocessing, and through rsyslog forwarding—detailing configuration steps, required code snippets, and verification using Kibana and Elasticsearch-head.
This article explains why and how to use GitHub Actions for automated front‑end deployment, covering the basics of Actions, creating workflow files, common CI steps, Docker integration, secret management, and a complete end‑to‑end example with code snippets and deployment scripts.
This article explains why Nginx outperforms Apache under heavy load by comparing their architectures, work modes, memory usage, event‑driven design, and scalability techniques, and shows how Nginx can handle tens of thousands of concurrent connections with far less resources.
This tutorial demonstrates how to gather Nginx access and error logs using Filebeat, Logstash, and Rsyslog, configure each component, and ship the logs to an Elasticsearch cluster for visualization in Kibana, offering three practical collection methods.
This article explains why Elasticsearch's built‑in tokenizers struggle with Chinese text, introduces the IK analyzer plugin, provides step‑by‑step Docker and file‑based installation methods, shows how to configure custom dictionaries via Nginx, and demonstrates smart and max‑word tokenization queries.
This article explores the design and implementation of a high‑concurrency train ticket spike system, detailing load‑balancing strategies with Nginx, distributed inventory management using Redis, Go‑based services, and performance testing, while addressing challenges such as overselling, fault tolerance, and efficient resource utilization.
This guide walks you through Nginx's high‑performance architecture, explains forward and reverse proxy concepts, demonstrates load‑balancing and static‑dynamic separation techniques, shows step‑by‑step installation and common commands, and details a high‑availability setup with Keepalived, all illustrated with practical examples and diagrams.
This guide walks through installing the open‑source Nginx‑GUI tool, configuring its properties, renaming Linux binaries, granting permissions, and launching the web interface to manage Nginx configuration, performance monitoring, and logs through a visual dashboard.
This guide walks through obtaining the nginx-gui tool from GitHub, editing its configuration to point to a local Nginx installation, running the application, and accessing the visual management interface at http://localhost:8889/ with default admin credentials.
This tutorial walks through preparing four CentOS 7 servers, installing and configuring IPVS, Keepalived, and Nginx, creating a virtual IP script, starting the services, and verifying the load‑balancing setup with ipvsadm, providing a complete high‑availability solution.
This guide explains why and how to copy live traffic to a pre‑release environment using Nginx’s mirror module, covering installation, configuration, custom builds, and useful commands for managing Nginx processes.
This guide explains Nginx's core concepts—including reverse proxy, load balancing, static‑dynamic separation, common commands, configuration blocks, and high‑availability setup with Keepalived—providing practical examples and command snippets for robust server deployment.
This guide explains Nginx’s core concepts—including forward and reverse proxy, load‑balancing strategies, static‑dynamic separation, installation commands, configuration file anatomy, practical reverse‑proxy and load‑balancing examples, and a Keepalived high‑availability solution—providing step‑by‑step instructions and essential code snippets for reliable backend deployment.
This guide walks through customizing Nginx 404 error pages, enabling and reading the stub_status module, increasing worker processes and connections, adjusting kernel limits, expanding header buffers, and configuring browser caching for static assets to dramatically improve server performance and reliability.
This guide explains why copying production traffic to a pre‑release environment is valuable, walks through installing Nginx, details the ngx_http_mirror_module for request mirroring, and provides full configuration examples and command‑line tips for deploying traffic mirroring in backend services.
The article explains why Nginx silently discards request headers containing underscores, demonstrates the issue with a Spring Boot service and Postman, and shows how adding the 'underscores_in_headers on;' directive resolves the problem.
This article explains the origins of Nginx, compares it with Apache, describes why Nginx gained popularity, details forward and reverse proxy concepts, and outlines the various load‑balancing algorithms it supports, providing a comprehensive overview for backend developers and operations engineers.
This tutorial shows front‑end developers how to build and deploy Node.js and Nginx as micro‑services on Tencent Cloud's TSF Mesh using Docker, service registration, governance, and monitoring, providing a low‑cost, zero‑intrusion migration path for non‑Java applications.
This article explains Nginx's high‑performance architecture, covering its daemon mode with master and worker processes, the thundering‑herd problem, advantages of process‑based concurrency, asynchronous non‑blocking I/O, connection handling, keep‑alive and pipeline techniques, as well as key internal data structures such as arrays, queues, lists, strings, memory pools, hash tables, and red‑black trees.
This article explains the concept of gray (canary) releases, walks through installing Nginx with Lua and memcached modules, shows how to configure Nginx to route traffic based on client IP stored in memcached, and provides testing steps to verify the rollout.
This article explains Nginx's high performance by examining its multi‑process architecture, asynchronous event‑driven design, modular components, and I/O multiplexing mechanisms such as epoll, while also comparing it with Apache and detailing connection limits and request handling flow.
This tutorial walks you through preparing two servers, installing Git, Nginx, and Jenkins, building two Angular projects, configuring Nginx for canary traffic routing, defining a cookie‑based gray‑release strategy, and creating Jenkins jobs to automate the entire deployment pipeline.
This article explains how to enable and fine‑tune Nginx’s Gzip compression, detailing the benefits for CSS, JS, XML and HTML delivery, providing configuration directives, recommended parameter values, and example snippets for both local and production environments.
This article walks through a real‑world LNMP case where slow backend responses and 502 errors were diagnosed and resolved by analyzing Nginx logs, increasing file descriptor limits, adjusting FastCGI timeouts, and fine‑tuning PHP‑FPM settings, followed by performance testing with ApacheBench.
This guide walks through installing Nginx on a CentOS VM, opening firewall ports, disabling SELinux enforcement, extracting NodePort values from a Kubernetes cluster, editing the Nginx configuration to proxy TCP traffic, and testing the load balancer with a sample deployment.
Learn how to simplify Kubernetes administration with Rancher by installing Docker, deploying Rancher, creating MySQL and SpringBoot deployments via YAML, configuring services, and exposing the application through Nginx, all illustrated with step‑by‑step commands and screenshots.
This article explains why Nginx HTTPS latency matters for instant search, describes how TLS handshake round‑trips affect response time, and provides step‑by‑step Nginx TLS configuration tweaks—including HTTP/2, cipher ordering, OCSP stapling, buffer sizing, and session caching—that together reduced real‑world latency by about 30%.
This guide explains how to use Nginx configuration directives to deny execution of uploaded scripts, block access to specific file types and directories, return custom HTTP status codes, and limit access by client IP to improve web server security.
The article explains why large numbers of TIME_WAIT TCP connections appear under high concurrency, analyzes the underlying TCP four‑handshake mechanism and port exhaustion issues, and provides practical solutions such as socket reuse, reducing TIME_WAIT duration, and configuring keep‑alive connections.
This article walks through Linux process states, fork/exec creation, CPU vs load metrics, network I/O models, and a real‑world Nginx high‑load case, showing how strace, accept_mutex, and SO_REUSEPORT can resolve the issue.
This article walks through systematic analysis of backend performance bottlenecks across a typical Nginx‑Tomcat‑Redis‑MySQL stack, covering bandwidth limits, OS ulimit settings, kernel TCP parameters, Nginx connection limits, Tomcat connector modes, Redis key handling, and MySQL query and hardware issues.
JumpServer disclosed a remote‑execution flaw on January 15 2021 affecting versions earlier than v2.4.5, v2.5.4 and v2.6.2; users should upgrade to the safe releases or apply a temporary Nginx rule that blocks the vulnerable API endpoints before restarting the service.
This article explains how to optimize Docker images for a React application by switching to Alpine base images, applying multi‑stage builds, and using Nginx to serve static files, reducing the final image size from 1.16 GB to just 22 MB.
This article examines the challenges of building a flash‑sale (秒杀) system—such as overselling, massive concurrent requests, URL exposure, and database bottlenecks—and presents a comprehensive backend architecture that combines separate databases, dynamic URLs, static pages, Redis clustering, Nginx load balancing, SQL optimization, rate‑limiting, asynchronous order processing, and service degradation techniques.
This article explains Nginx’s core concepts—including reverse proxy, load balancing, static‑dynamic separation, common commands, configuration blocks, and high‑availability setup with Keepalived—providing step‑by‑step guidance and practical examples for building robust web infrastructure.
This article details the overall architecture of JD.com Data Science's JDDLB load balancer, its high‑performance and high‑availability features, and presents a comprehensive performance comparison of SSL/TLS offloading using Intel QAT acceleration cards, including async processing, user‑space driver zero‑copy implementation, crash analysis, and process‑level engine scheduling.
This guide explains how to optimize Linux kernel parameters and Nginx settings—such as file descriptor limits, TCP queue lengths, temporary ports, worker processes, KeepAlive, and log buffering—to significantly improve server performance and handle high traffic loads.
This article explains why low‑latency Nginx HTTPS is crucial for instant search, analyzes how TLS handshakes add round‑trip delays, and provides concrete Nginx TLS configuration changes—such as enabling HTTP/2, adjusting cipher suites, enabling OCSP stapling, tweaking buffer sizes and session caches—that together reduced request latency by about 30% in a real‑world deployment.
This article details a practical performance and high‑availability comparison of HAProxy and Nginx as software load balancers for a MySQL 8.0 InnoDB Cluster (MGR) setup, covering environment configuration, Keepalived integration, test methodology, results, and final recommendations.
This article explains the fundamentals of Kubernetes Ingress, how it relies on an Ingress controller such as ingress‑nginx to expose services, compares it with manual Nginx proxy setups, and provides step‑by‑step YAML examples, annotations, TLS configuration, and testing tips.
This guide walks through practical Nginx optimizations—including custom 404 error pages, enabling and reading the stub_status page, increasing worker processes and connections, expanding header buffers, and configuring client-side caching for static assets—complete with command‑line examples and configuration snippets.
This article explores the design of a high‑concurrency train ticket‑seckill system, covering 12306 backend architecture, multi‑layer load balancing, Redis‑based stock deduction, Go code examples, performance testing, and strategies to prevent overselling and ensure fault tolerance.
This article explains why TCP KeepAlive is needed, how it differs from HTTP Keep-Alive, and provides practical Linux kernel and Nginx configuration steps to prevent session timeouts in load‑balancing scenarios such as LVS and F5 devices.
This guide explains how to generate self‑signed SSL certificates with OpenSSL, configure an Nginx reverse‑proxy container via Docker, install the root certificate on the host system, and modify the hosts file so that front‑end code can securely access a local HTTP service over HTTPS.
This guide walks through setting up a CentOS 7 server, creating a non‑root user, installing Python 3, MySQL, and required packages, configuring a Django project, and deploying it with uWSGI behind Nginx for production use.
Static and dynamic resource separation, commonly known as static‑dynamic separation, involves deploying static files (HTML, JavaScript, CSS, images) on a web server like Nginx while forwarding dynamic requests to a backend application server via reverse proxy, thereby improving static asset delivery speed and enabling parallel front‑end and back‑end development.
This article explains how single‑page applications use router mechanisms, compares hash and history routing modes, and demonstrates the required server‑side (Node) and Nginx configurations to make history mode work without page reloads, including code examples and best‑practice tips.
This article provides a detailed overview of Nginx, covering its core concepts, installation steps on Linux, configuration files, common commands, reverse proxy and load‑balancing setups, static‑dynamic separation, and high‑availability solutions using Keepalived, offering practical examples and code snippets throughout.
This article explains the differences between HTTP/1.1 and HTTP/1.0 keep‑alive, the TCP keepalive mechanism and its kernel parameters, how to configure them in applications, and how Nginx implements and manages keepalive for client and upstream connections with detailed code examples.
This article explains how to build a high‑concurrency ticket‑spike system by analyzing 12306's extreme load, introducing multi‑layer load balancing (OSPF, LVS, Nginx), comparing stock‑deduction strategies, and presenting a Go prototype that uses in‑memory stock, Redis centralized inventory, and weighted Nginx routing to achieve scalable, fault‑tolerant performance.
This guide explains how Linux socket I/O multiplexing (select, poll, epoll) powers high‑concurrency servers, why caching and asynchronous non‑blocking are crucial, and provides step‑by‑step instructions to install, configure, and develop with OpenResty, Nginx, and Lua for scalable backend applications.
This guide walks through converting a single‑master Kubernetes cluster into a highly available multi‑master deployment by configuring a load‑balancing Nginx front‑end, updating API server certificates with additional SAN entries, adjusting kubeconfig files, and adding extra control‑plane nodes while verifying etcd health.
This tutorial walks through setting up a Windows‑based PHP development environment, installing ThinkPHP 6.0 and the PhpSpreadsheet library, configuring Nginx and the database, and providing complete code to query MySQL data and export it as an Excel file.
The article analyzes the extreme‑traffic challenges of China’s 12306 ticket‑spike service, presents a layered load‑balancing architecture using OSPF, LVS, and Nginx weighted round‑robin, and demonstrates a Go‑based prototype that combines local in‑memory stock deduction with Redis‑backed global stock control to achieve stable, high‑throughput ticket purchasing without overselling.
This tutorial walks through preparing two servers, configuring Keepalived and Nginx on both master and backup nodes, restarting services, and testing failover to demonstrate a functional high‑availability architecture using VRRP virtual IPs.
This tutorial explains how to update an Ubuntu server, add the ondrej/php PPA, install PHP 8 and its extensions, configure php.ini for both Apache and Nginx, adjust performance settings, and restart services to fully enable PHP 8 on a Linux VPS or cloud instance.
This article provides a systematic overview of Nginx’s high‑performance architecture, covering its modular design, master/worker process model, event‑driven loop, HTTP request processing phases, location matching rules, upstream load‑balancing, FastCGI and proxy configurations, rate‑limiting mechanisms, and common 502 error troubleshooting, while offering practical tips for reading the source code.
This guide explains how to use Nginx directives to deny execution of uploaded script files, block specific file types, restrict directory access, and limit client IPs, thereby strengthening website security for user‑facing services.
This article explains essential Nginx configuration directives, demonstrates a real 403 error case on an Alibaba Cloud server, and provides four step‑by‑step troubleshooting methods covering user mismatches, missing index files, permission issues, and access‑restriction settings.
This article introduces Docker fundamentals, compares containers with virtual machines, explains core concepts, guides through installation, Dockerfile creation, image building, container deployment, and best practices, providing step-by-step commands and examples for deploying a Vue application with Nginx.
This guide walks you through customizing Nginx 404 error pages, enabling the stub_status module to monitor server metrics, increasing worker processes and connections, adjusting header buffers, and configuring client-side caching for static assets to boost web server performance.
This guide walks .NET developers through the complete process of moving from .NET Framework to .NET Core on a Linux server, covering prerequisite tools, SSH key configuration, SDK installation, manual publishing, production‑grade setups with Supervisor+Nginx or Jexus, and finally Docker‑based deployment with automation scripts.
This article explains Nginx as a high‑concurrency static web server, outlines its core functions such as web serving, load balancing, caching and CDN support, lists its advantages, describes typical application scenarios, and provides a step‑by‑step installation procedure with commands.
This guide shows how to add HTTPS to an internal web service by either routing traffic through Nginx as a reverse proxy or configuring FRP itself with SSL certificates, including detailed server (frps) and client (frpc) settings, firewall tips, and verification steps.
This guide walks you through packaging the Ruoyi microservice project with Maven, copying the resulting JAR files to a Windows server, running each service with the correct Java encoding, and configuring the front‑end proxy via vue.config.js or Nginx for full deployment.
This article explores the architecture and implementation of a high‑concurrency ticket‑spike system, covering load‑balancing strategies, Nginx weighted round‑robin configuration, local stock deduction in Go, remote stock control with Redis Lua scripts, and performance testing results.
This article explains how to set up frp, a high-performance reverse-proxy written in Go, to expose internal web and SSH services to the public Internet using domain-based virtual hosts, nginx reverse-proxy, and systemd on CentOS, complete with configuration examples and firewall considerations.
This practical guide explains WebSocket fundamentals, demonstrates how to integrate and debug them in a project with webpack proxy and Nginx settings, implements heartbeat and reconnection logic for stability, and compares native WebSocket to Socket.io’s richer but heavier real‑time framework.
This comprehensive guide covers Nginx's architecture, reverse proxy and load‑balancing concepts, static‑dynamic separation, Linux installation steps, common command‑line usage, configuration file structure, practical reverse‑proxy and load‑balancing setups, high‑availability with keepalived, and the underlying master‑worker process model.
This guide explains why Nginx may not support ThinkPHP's PathInfo mode, and provides two detailed solutions—enabling PathInfo in the fastcgi configuration and using rewrite rules to hide index.php—along with the exact code snippets needed to apply them.
This article explains why HTTPS is required for secure data transmission, describes symmetric and asymmetric encryption, outlines the role of CA certificates, and provides step‑by‑step commands to generate keys, create certificates, and configure Nginx to serve HTTPS traffic.
This tutorial shows how to use frp for internal‑network penetration, configuring both the frps server and frpc client, integrating with Nginx, adding optional access control, and handling domain mapping so a home‑hosted website becomes reachable from the public internet.
This article explains what pseudo‑static (URL rewriting) is, compares its advantages and disadvantages with true static pages, and provides detailed implementation methods and example rewrite rules for both Apache and Nginx servers to improve SEO, reduce server load, and simplify URL structures.
This article explains how modern web services use server clusters and load‑balancing devices, compares the three most popular software balancers—LVS, Nginx, and HAProxy—by describing their architectures, operating modes, advantages, disadvantages, and suitable deployment scenarios for different site scales.
This article provides a thorough walkthrough of Linux logrotate, covering its default configuration files, essential command‑line options, key parameters, practical examples for services like nginx, php, and tomcat, custom rotation scripts, cron scheduling, and troubleshooting tips for reliable log management.
This guide explains how to use Logrotate on Linux for automatic log file rotation, covering default configuration files, key options, example setups for Nginx, PHP, Tomcat, system logs, custom shell and Python scripts, cron scheduling, and troubleshooting techniques to ensure logs are rotated reliably.
This comprehensive guide explains Nginx's core concepts—including reverse proxy, load balancing, static‑dynamic separation, common commands, configuration blocks, and high‑availability setup with Keepalived—providing practical examples, diagrams, and code snippets for reliable server deployment.
This article explains Nginx’s highly modular architecture, its multi‑process and asynchronous non‑blocking request handling, the event‑driven model, and the master/worker design, providing a comprehensive foundation for developers who want to understand or explore Nginx’s source code.
This guide shows how to install Nginx on a RedHat 6.5 system, simulate rapid requests from a malicious IP using ApacheBench, examine the access logs, and then block that IP permanently with an iptables rule or Nginx configuration, verifying the block with curl.
This article explores how Nginx’s high‑performance, event‑driven architecture underpins modern DevOps practices, detailing its roles in web hosting, proxying, caching, API gateways, dynamic routing with Lua/Redis, emergency failover designs, data‑driven operations, and micro‑service integration.
This article explains how modern web services rely on server clusters and a front‑end load balancer, compares the three most popular software balancers—LVS, Nginx, and HAProxy—by describing their architecture, operating modes, advantages, and drawbacks, and offers guidance on selecting the appropriate solution for different traffic scales.
This guide walks you through creating and using a one‑click installation package that sets up essential development services—MySQL, Nginx, JDK, Redis, RabbitMQ, and a SpringBoot jar—on Ubuntu 16.x, detailing directory structure, required prerequisites, individual start/stop scripts, and customization options for small‑scale deployments.
This guide explains how to identify Nginx bottlenecks, apply a series of configuration and kernel tweaks—including worker processes, event model, connection limits, gzip, proxy timeouts, and sysctl settings—and then validate the improvements with Apache ab load testing to achieve up to 100 000 concurrent requests.
This article explains how to optimize Nginx Ingress Controller on Tencent Cloud TKE for high‑concurrency workloads by adjusting kernel parameters, sysctl settings, and Nginx configuration values, and provides concrete initContainer and ConfigMap examples to apply these optimizations.
This article explains how Nginx can be used for static file serving, various load‑balancing strategies, rate limiting with the leaky‑bucket algorithm, caching mechanisms, and black‑/white‑list access control, providing practical guidance for improving web service performance and reliability.
This guide walks you through installing Hugo, creating a static blog, configuring Nginx as a reverse proxy, setting up Gitbook for documentation, and integrating Qiniu cloud storage for image handling, all on a Linux server using personal domain access.
This guide walks through verifying the existing Nginx 1.16.1 process, compiling and configuring Nginx 1.18.0 with identical options, performing a zero‑downtime binary replacement, and handling rollback procedures using signals and process management commands on a Linux server.
The article explains why massive TIME_WAIT sockets appear during high‑concurrency traffic, how they can exhaust local ports and cause connection errors, and provides practical server‑side and client‑side configurations to mitigate the issue.
This tutorial explains how to solve physical‑machine shortages and achieve high availability by installing Docker, configuring Keepalived for virtual IP failover, setting up Nginx load balancing, building backend Docker images, deploying master‑slave containers, and verifying the setup with Portainer.
This step‑by‑step guide shows how to install, configure, and use Filebeat to ship Nginx, Elasticsearch, and MySQL log files into an ELK stack, covering module activation, YAML settings, service startup, and verification through Kibana dashboards.
This article introduces Docker by explaining container concepts, comparing virtual machines and containers, detailing core Docker components, and providing step‑by‑step instructions for installing Docker, creating a Dockerfile, building and running a Vue.js project image with Nginx, and sharing best practices for image optimization and deployment.
This guide explains multiple Nginx gray‑release techniques—including cookie‑based routing with if and map directives, weight‑based upstream selection, source‑IP routing for separate or shared servers, and a Lua script solution—providing complete configuration snippets and practical tips.
This guide explains how to use Linux non‑blocking socket APIs (select, poll, epoll) and the OpenResty platform (Nginx + LuaJIT) to create scalable, high‑concurrency web services, covering architecture, caching strategies, and step‑by‑step installation and configuration.
This article examines the keep‑alive mechanism at both the HTTP and TCP layers, explains how Nginx parses and processes the Connection header, dissects Linux kernel socket options and libuv implementation, and shows how to configure and debug keep‑alive to release idle connections efficiently.
This article introduces Docker fundamentals, compares containers with virtual machines, explains core concepts, walks through installation, basic commands, building a Docker image for a Vue application, running and publishing the container, and shares best‑practice tips for containerization.
This guide explains how to use Ingress‑Nginx annotations such as canary‑by‑header, canary‑weight, canary‑by‑cookie, and canary‑by‑header‑value to perform traffic splitting, blue‑green deployments, and A/B testing in Kubernetes, with complete YAML examples and test results.
This guide walks you through selecting a low‑cost Raspberry Pi Zero W, flashing Raspbian Stretch Lite, configuring SSH and Wi‑Fi, optimizing the system, installing Nginx, and exposing the web service to the internet using ngrok, providing a compact, fully functional mini web server.
