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.
This guide explains key Linux kernel and Nginx configuration adjustments—such as backlog queues, file descriptor limits, worker processes, keepalive settings, and logging options—to help administrators maximize web server performance while following safe, incremental tuning practices.
This guide explains how to fine‑tune Linux kernel parameters and NGINX directives—such as backlog queues, file descriptors, worker processes, keep‑alive settings, access‑log buffering, sendfile, and request limits—to achieve optimal web server performance for high‑traffic sites.
After leaving Baidu in 2015, the author recounts nearly two years of evolving a startup’s backend architecture—from a single‑server Tomcat setup to multi‑node clusters with Nginx reverse proxy, database sharding, caching, session sharing, and service‑oriented design—highlighting challenges, optimizations, and lessons learned.
This guide compiles common HTTPS and HTTP/2 deployment problems—such as Let’s Encrypt validation failures, certificate transparency errors, SNI incompatibility, cipher‑suite misconfigurations, and mixed‑content issues—and provides concise, actionable solutions with reference links for each case.
This guide explains why the default Linux kernel settings are unsuitable for high‑concurrency Nginx servers, shows how to edit /etc/sysctl.conf, and provides a curated list of TCP and network parameters with practical comments to improve throughput and latency.
This article compares the three most widely used load‑balancing solutions—Nginx, LVS, and HAProxy—detailing their advantages, disadvantages, suitable deployment scenarios, and how they fit into typical web architecture stages from small‑scale sites to large‑scale services.
This article explains how to create self‑signed SSL certificates using OpenSSL, add them to browser trust stores, and configure local development servers (fekit/ykit) and Nginx for HTTPS debugging, including handling SubjectAltName issues and detailed command examples.
This article describes the background, design concepts, selection rationale, implementation principles, algorithm details, and configuration of a Lua‑based overload protection module for Nginx that monitors system load and dynamically rejects traffic to safeguard backend services.
This article introduces Gixy, a static analysis tool for Nginx configurations, demonstrates how to detect and fix HTTP header splitting and other security issues, explains its handling of included files, lists detectable vulnerabilities, and provides simple installation instructions.
This step‑by‑step guide shows how to set up two Tomcat instances, configure Nginx as a reverse‑proxy load balancer, and use Redis to share session data, solving session‑loss issues in a simple load‑balanced environment.
This guide walks through configuring Zabbix to monitor Nginx and PHP‑FPM status, covering software installation paths, enabling status modules, creating extraction scripts, setting up Zabbix agent userparameters, restarting services, testing data retrieval, and adding server‑side templates for items, triggers, and graphs.
This article explains how to upgrade an existing HTTP backend to HTTPS by using Nginx as a reverse proxy, covering certificate generation with OpenSSL, Nginx configuration, host file adjustments, and testing steps, allowing secure communication without altering the original application code.
This article explains how Nginx can function as a reverse proxy, load balancer, HTTP server with static‑file handling, and forward proxy without relying on third‑party modules, providing configuration examples and discussing built‑in load‑balancing strategies such as round‑robin, weight, ip_hash, fair, and url_hash.
This step‑by‑step guide shows how to prepare two Tomcat servers, create a simple web project, configure Nginx as a reverse‑proxy load balancer with various strategies, start the services on Windows, and verify that requests are distributed across the Tomcat instances.
This article traces the evolution of HTTP-based video streaming—from early full‑file downloads through progressive download, pseudo‑streaming, and finally adaptive bitrate technologies like HLS and MPEG‑DASH—explaining key concepts, server implementations, and optimization techniques.
This article compares three popular open‑source proxy servers—Nginx, HAProxy, and Varnish—detailing their performance, features, and ideal use‑cases, helping ops and network engineers decide which solution best fits high‑availability, high‑concurrency environments while considering maintenance overhead and resource consumption.
This article walks through a real‑world Nginx 400 Bad Request incident, explaining how missing or malformed Host headers and added proxy headers caused the error, and provides step‑by‑step diagnostics, configuration comparisons, and the final fix of using the correct $host variable.
This guide explains how Nginx modules are organized, how to view and select available modules with ./configure --help, add third‑party modules using the --add-module option, and understand Nginx’s single‑process and master‑worker process models.
This guide explains how to conceal Nginx version headers, modify source files to remove software identifiers, change default users, tune worker processes, adjust connection limits, enable efficient file transfer, and set appropriate timeouts for a more secure and performant web server.
This tutorial walks through updating CentOS 7, adding the Docker repository, installing and testing Docker Engine, creating a Dockerfile for a .NET Core and Angular2 project, building and running the container, configuring Nginx as a reverse proxy, and verifying the deployment in a browser.
This article explains how load balancers act as the nervous system of web applications, compares hardware versus open‑source solutions, and details why HAProxy—especially in TCP (layer 4) mode—often outperforms Nginx for high‑performance reverse proxy and load‑balancing tasks.
This tutorial walks through installing .NET Core, disabling the firewall, setting up Nginx on CentOS, generating and building an ASP.NET Core + Angular2 template with npm and webpack, publishing the app, transferring it to the server, running it, and configuring Nginx as a reverse proxy for external access.
The article walks through setting up a low‑cost Tencent Cloud Ubuntu server with Apache or Nginx‑PHP, then demonstrates building four lightweight web utilities—a self‑hosted questionnaire system, a JavaScript QR‑code generator/scanner with short‑URL support, a Baidu‑map search tool, and a PHP script that parses Apple’s CFPropertyList to list Xcode dmg and docset download URLs.
This step‑by‑step guide shows how to provision a Tencent Cloud VM, install Nginx, PHP‑FPM and MySQL client, download and configure WordPress, set up its database, enable horizontal scaling with a load balancer, share the VM image, and finally clean up the database.
This article explains the principles and practical deployment steps for high‑availability web architectures using LVS (NAT and DR modes), Keepalived clustering, and Nginx proxy, covering topology diagrams, IPVS rules, weighted scheduling, kernel tweaks, and testing procedures to ensure reliable load balancing.
This tutorial walks through creating a self‑signed CA, generating keys and CSR, signing certificates, configuring nginx.conf for SSL, using the rewrite module, setting up fastcgi with PHP‑FPM, and testing the entire HTTPS setup on a Linux server.
This guide walks you through obtaining a free SSL certificate, configuring Nginx for HTTPS, and upgrading to TLS 1.2 on a CentOS server, ensuring your WeChat mini‑program can securely communicate with the backend, including detailed command‑line steps and essential software dependencies.
This article examines how JD’s activity system evolved its web architecture—introducing full‑page Redis and disk caching, asynchronous rendering, and OpenResty—resulting in a latency drop from around 1000 ms to under 15 ms and dramatically lower CPU usage.
This article walks through two common pitfalls when connecting a WeChat Mini‑Program to a server—an “invalid url” error caused by using single quotes instead of backticks, and a TLS 1.2 requirement that necessitates upgrading OpenSSL and recompiling Nginx, providing step‑by‑step solutions.
After Apple’s 2017 ATS enforcement requires all iOS apps to use HTTPS, developers must obtain an SSL certificate—such as a free Let’s Encrypt or Tencent Cloud‑issued GeoTrust certificate—install it on their web server (e.g., Nginx), optionally configure CDN encryption, and verify compliance with Apple’s security checks.
This article provides a comprehensive overview of Nginx, covering its core and extended features, architecture, module types, virtual‑host setup, access control, compression, anti‑hotlinking, reverse‑proxy, caching, and load‑balancing techniques for high‑concurrency web environments.
A PHP backend team discovered that enabling OpCache with a symlinked project caused the new version to be ignored, traced the issue to cached file paths, and resolved it by adjusting Nginx fastcgi parameters to use the real path, restoring proper deployment behavior.
This article explains how browsers cache resources, the role of HTTP response headers such as Last-Modified, Expires, Cache-Control, ETag, and Age, and provides practical examples of controlling cache behavior with Spring MVC code and detailed Nginx configuration for both static and proxy caching.
This article explores multi‑level caching architectures, detailing how Nginx, local and distributed caches, and Tomcat interact, and offers practical solutions for expiration strategies, dimensional caching, load‑balancing algorithms, hot‑data handling, atomic updates, and rapid recovery from cache failures.
The article introduces JEN, JD's extended Nginx platform that centralizes configuration, monitoring, traffic splitting, rate limiting and automated operations through a web console and Ansible integration, addressing the complexity, restart requirements, and scaling challenges of large‑scale Nginx deployments.
This article explains how Nginx and PHP‑FPM work together, details their configuration directives, describes common 502/504 errors, and provides practical tuning tips to improve performance and reliability of PHP‑based web services.
This guide walks through the fundamentals of HLS and RTMP protocols, compares their trade‑offs, and provides step‑by‑step instructions for setting up an Nginx‑RTMP server, configuring HLS, recording with WebRTC, and playing live streams in HTML5 video tags.
This guide walks you through purchasing a Tencent Cloud instance, installing and configuring Nginx, Node.js, MongoDB, and setting up deployment scripts, covering SSH access, compiling the latest Nginx with HTTP/2 support, and automating service startup for a robust community website.
This article explains how to use Nginx's various load‑balancing strategies together with Tomcat clustering and session‑sharing techniques to build a resilient, high‑availability web service, covering both simple static‑page scenarios and session‑dependent applications.
This article explains how to design a robust, zero‑intrusion data fallback component for high‑traffic web services using Nginx, Lua, and AOP principles, covering problem definition, architectural options, detailed execution steps, configuration snippets, storage choices, and performance monitoring.
This guide introduces nginScript, Nginx's JavaScript execution environment, showing how to declare variables, run scripts, access request data, and install the module, enabling powerful server‑side extensions without writing C modules.
This guide walks through installing and configuring Keepalived on two CentOS servers to provide automatic Nginx health checking, virtual IP failover, and high‑availability load balancing, including scripts, service commands, and advanced iptables techniques to avoid packet loss during maintenance.
This guide walks through securing an Nginx web server by configuring buffer size limits, timeouts, concurrent connection controls, host and method restrictions, user‑agent blocking, hot‑link protection, directory access rules, SSL setup, PHP hardening, chroot isolation, and firewall‑level IP connection limits.
This guide walks you through obtaining a trusted SSL certificate, generating keys and CSR with OpenSSL, configuring HTTPS in Nginx, and applying performance and security enhancements such as keep‑alive, session caching, HSTS, strong cipher suites, and name‑based virtual host solutions.
This article details a real‑world investigation of extremely low‑probability core dumps and memory leaks in a heavily modified Nginx/OpenSSL stack, covering debugging strategies, custom traffic‑control testing, distributed load generation, use of valgrind and AddressSanitizer, performance profiling with perf, and the mindset needed to solve such high‑concurrency bugs.
This step‑by‑step guide shows how to install and heavily tune Nginx on Linux, apply kernel TCP stack optimizations, and use Tsung for load testing, enabling a single server to sustain around 904,000 HTTP requests per second.
This article compares Nginx and Apache from an operations learner’s perspective, examining their operating system support, regional market share, scalability, PHP integration, configuration ease, and source code characteristics, concluding with guidance on when each server is appropriate.
This article walks through a real‑world investigation of intermittent core dumps and memory leaks in a heavily modified Nginx + OpenSSL stack under extreme QPS, detailing debugging strategies, custom load‑testing tools, and performance‑profiling techniques that helped pinpoint and fix the root causes.
The article describes a real‑world investigation of extremely low‑probability core dumps and memory leaks in a heavily modified Nginx + OpenSSL stack, detailing the debugging workflow, custom high‑concurrency test harness, use of tools such as GDB, perf, Valgrind, AddressSanitizer, and the performance‑hotspot analysis that ultimately resolved the issues.
A sudden 50% server load increase was traced to a malicious PHP file uploaded via an Nginx %00 null‑byte vulnerability, revealing how the exploit works, how it was detected, and steps to prevent future attacks.
This article explains how to implement access‑layer rate limiting in Nginx using built‑in modules, OpenResty Lua extensions, and token‑bucket or leaky‑bucket algorithms, with detailed configuration snippets, execution flow, testing procedures, and log analysis for robust traffic control.
This guide explains why Nginx returns 502 Bad Gateway, outlines common trigger conditions, and provides step‑by‑step commands and configuration tweaks—such as adjusting FastCGI process limits, timeout values, buffer sizes, and php‑fpm settings—to reliably resolve the issue.
This article explains why caching, degradation, and rate limiting are essential for high‑concurrency systems, details token‑bucket and leaky‑bucket algorithms, shows application‑level, distributed, and edge‑level throttling techniques, and provides practical Java, Guava, Redis‑Lua, and Nginx‑Lua code examples.
This article provides a comprehensive overview of software load balancing, detailing the architecture, features, performance, and deployment strategies of Nginx, LVS, and HAProxy, and includes practical scenarios for front‑end, internal, and high‑availability setups.
This guide explains how to compile Nginx with the GeoIP module, install MaxMind's GeoIP library and database, configure the system linker, and set up Nginx directives to redirect traffic from selected countries to custom pages on a single VPS.
This guide explains how to use simple Nginx configurations, enhanced cookie checks, and Lua scripts to create unforgeable tokens, limit request rates, and protect web services from CC attacks, scanning tools, and other malicious traffic while maintaining normal user access.
This article examines typical mistakes in Nginx‑PHP setups—such as misplaced index directives, misuse of the if statement, and fastcgi configuration quirks—and provides a streamlined, secure configuration example with explanations.
This guide explains how to use Keepalived and the VRRP protocol to build a two‑node high‑availability setup for Nginx, covering installation, health‑check scripts, configuration options, testing procedures, and troubleshooting tips for seamless failover.
This article examines nginx’s built‑in and extended load‑balancing algorithms—including weighted round‑robin, IP hash, fair, generic hash and consistent hash—by dissecting source code, describing implementation details, and presenting comparative performance tests that evaluate balance, consistency and fault‑tolerance across various scenarios.
This guide walks through setting up a highly available two‑node Nginx service on CentOS 7 using Corosync and Pacemaker, covering topology, environment preparation, host synchronization, HA component installation, NFS sharing, resource configuration with crmsh, and testing the failover behavior.
This tutorial walks through configuring Nginx upstream for load balancing and enabling proxy caching of static resources, covering experiment topology, environment setup, key upstream parameters, example configurations, cache directives, and performance observations.
This guide walks through setting up a virtual machine, installing and compiling Nginx, configuring its main, event, and http blocks, creating SSL certificates, and applying URL rewrite rules to serve different pages based on the client’s browser or device.
