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.
This tutorial walks you through choosing a Raspberry Pi Zero W, flashing Raspbian Stretch Lite onto an SD card, configuring headless SSH access, installing and testing Nginx, and exposing the device to the internet using Ngrok, complete with hardware specs, command‑line snippets, and troubleshooting tips.
This article explains the AI live‑streaming architecture used by Liulishuo, covering the basic workflow of push, server, and pull, video/audio encoding and container formats, streaming protocols such as RTMP, HLS and HTTP‑FLV, SEI integration, and provides a step‑by‑step demo using nginx‑rtmp and FFmpeg.
This article explains the role of an access‑layer gateway, presents its architecture and implementation using OpenResty, discusses technical selection, details OpenResty’s underlying Nginx/Lua mechanisms, and shows how to achieve dynamic routing, plugin‑based policies, shared data, and upstream configuration without service reloads.
This article provides a comprehensive walkthrough of Nginx configuration directives, explains key parameters such as worker processes, logging, gzip, and demonstrates how to set up multi‑node load balancing with various upstream algorithms using Docker containers and host file adjustments.
This article presents ten actionable recommendations—including reverse‑proxy deployment, load balancing, caching, compression, SSL/TLS tuning, HTTP/2 adoption, software upgrades, Linux and web‑server tuning, and real‑time monitoring—to dramatically improve web application performance, often achieving tenfold speed gains.
This article introduces NGINX's Microservices Reference Architecture (MRA), explains its three network models—Proxy, Router Mesh, and Fabric—describes their use cases, outlines the goals of the reference architecture, and previews the Ingenious demo application that implements all three models.
This article outlines ten practical techniques—including reverse proxy deployment, load balancing, caching, data compression, SSL/TLS optimization, HTTP/2 adoption, software upgrades, Linux tuning, web server configuration, and real‑time monitoring—that together can dramatically improve web application speed, reliability, and security.
This article explains Nginx rate‑limiting fundamentals and advanced configurations, covering the leaky‑bucket algorithm, basic directives, burst and nodelay handling, whitelisting with geo/map, multiple limit rules, logging details, and custom error responses to protect servers and mitigate attacks.
This article explains Nginx's rate‑limiting feature, covering the leaky‑bucket algorithm, basic and advanced directives like limit_req_zone, limit_req, burst, nodelay, whitelist handling, logging, and custom error codes to control request flow and protect services.
This article explains why massive TIME_WAIT TCP connections appear under high concurrency, the impact on services, and practical methods—such as adjusting socket reuse and reducing TIME_WAIT duration—to prevent new connection failures.
Learn how to verify the ngx_http_stub_status_module compilation, configure Nginx stub_status endpoint, create Bash monitoring scripts, set up Zabbix user parameters, and build templates, triggers, and graphs to monitor Nginx performance metrics such as active connections, requests, and waiting clients.
This article provides a complete walkthrough of Nginx, covering its roles as a reverse proxy, load balancer, static file server, and forward proxy, along with detailed configuration examples for global settings, HTTP blocks, server blocks, location directives, upstream modules, and stream handling.
Under high‑traffic conditions, servers can generate massive numbers of TCP TIME_WAIT sockets, consuming local ports and causing “address already in use” errors; this article explains the underlying causes, impact on services, and practical mitigation strategies such as keep‑alive headers and socket reuse.
This tutorial introduces Nginx as a lightweight web, reverse‑proxy and mail server, explains core concepts such as reverse proxying, provides essential command‑line shortcuts, shows how to create startup scripts, and walks through HTTP/HTTPS proxy setups, load‑balancing strategies, multi‑app routing, static‑site serving, file‑server configuration and CORS handling.
This article explains why web performance matters, presents ten practical NGINX‑based techniques—including reverse proxy, load balancing, caching, compression, SSL/TLS optimization, HTTP/2, software upgrades, Linux and web‑server tuning, and real‑time monitoring—to help you achieve up to tenfold speed improvements.
This article details how to diagnose and resolve Nginx load‑balancing performance issues under extreme concurrency by analyzing NIC packet loss, kernel SYN drops, backlog limits, and applying systematic kernel, network‑card, and Nginx configuration optimizations that raise QPS from 20,000+ to over 40,000.
This guide explains HAProxy’s role as a high‑performance load balancer, compares its features with alternatives, details common algorithms, introduces Keepalived’s VRRP‑based high‑availability clustering, and provides step‑by‑step configuration commands for setting up a master‑backup HAProxy environment with monitoring and failover scripts.
This article explains the 11 TCP connection states—including the three‑way handshake and four‑way termination—illustrated with packet captures, shows how to inspect them using netstat or ss, and discusses common Nginx TIME_WAIT problems and strategies for troubleshooting and performance tuning.
This article presents a comprehensive case study on how the 58 rental platform refactored its services and optimized performance by splitting common modules, adopting async interfaces, leveraging nginx + swoole, implementing data caching and pre‑loading, resulting in significant reductions in page rendering time and service latency across major app pages.
The article chronicles the development of static resource services—from early ASP examples and static‑dynamic separation to modern CDN, cloud storage, URL handling, online concatenation, and multi‑region deployment—highlighting technical decisions, performance trade‑offs, and future challenges for front‑end infrastructure.
This guide walks you through setting up Nginx on CentOS, explains its core features such as event‑driven architecture, lightweight modules, and CPU affinity, then demonstrates practical scenarios like static asset serving, browser caching, cross‑origin handling, anti‑hotlinking, reverse proxy, load balancing algorithms, and proxy caching with detailed configuration examples.
This article explains what load balancing is, its role in distributing traffic across server clusters, outlines the various layer‑based classifications (L2‑L7), compares popular software solutions such as LVS, Nginx and HAProxy, and reviews common load‑balancing algorithms and their use cases.
This article provides an in‑depth introduction to Nginx, covering its core concepts, advantages, request handling, proxy types, configuration syntax, directory structure, rate‑limiting mechanisms, load‑balancing strategies, high‑availability setup, and practical examples for static resource handling and virtual host deployment.
This article traces Nginx’s creation by Igor Sysoev, explains its advantages over Apache, and details how Nginx functions as a forward and reverse proxy, supports various load‑balancing algorithms, and is widely used in modern web infrastructure.
This article explains how Nginx reverse‑proxy location path mapping works, detailing the matching symbols, their priority order, and providing concrete configuration examples to illustrate how requests are routed.
This article explains Nginx’s high performance by dissecting its multi‑process architecture, event‑driven model, HTTP connection handling, modular design, and I/O mechanisms, comparing it with Apache, and clarifying common questions about worker processes, maximum connections, and concurrency.
This step‑by‑step guide shows how to create a highly available Nginx load‑balancing cluster with Keepalived in both master‑slave and dual‑master configurations, covering server preparation, Nginx and Keepalived setup, VIP handling, testing, and a watchdog script to ensure service continuity.
This guide explains how to enable gzip compression, set cache headers, activate HTTP/2, fine‑tune logging, and apply rate‑limiting in NGINX to dramatically reduce bandwidth consumption while improving site performance and server efficiency.
This guide explains how to configure Laravel for read/write database separation and set up Nginx load balancing, covering hardware requirements, Laravel config/database.php adjustments, Nginx upstream strategies, detailed server blocks, and essential parameter explanations for a scalable web architecture.
This article explains Nginx's role as an HTTP, reverse‑proxy, and mail server, introduces load‑balancing concepts, details the upstream and proxy modules, compares scheduling algorithms, and provides step‑by‑step configuration examples with code snippets to set up a functional load‑balancing environment.
This article explains the Nginx location directive, covering its syntax, various matching parameters, the order in which locations are evaluated, and practical examples that demonstrate how to configure precise and flexible URL handling for web servers.
This comprehensive guide walks you through setting up Nginx on CentOS, explains its core features, shows how to configure basic and advanced settings, and demonstrates practical scenarios such as static file serving, browser caching, cross‑origin access, anti‑hotlinking, HTTP proxying, load balancing algorithms, and cache management.
This guide explains why copying production traffic to pre‑release environments is beneficial, walks through installing Nginx, details the ngx_http_mirror_module configuration for traffic mirroring, and provides custom build steps and useful monitoring commands.
This guide explains what Nginx is and how reverse proxy works, details its load‑balancing algorithms, provides step‑by‑step commands to download, compile and install Nginx and Tomcat on CentOS 7, shows how to configure Nginx upstreams for Tomcat servers, and lists common pitfalls such as firewall blocks.
This guide explains how to configure Nginx to gradually roll out new versions and separately route mobile and PC traffic using the split_clients and map modules, with complete example configurations and visual results.
This guide explains why and how to copy production traffic to a pre‑release environment, walks through installing Nginx, configuring the ngx_http_mirror_module, building Nginx from source with the module, and provides useful commands and documentation links.
This guide explains how to copy production traffic to a pre‑release environment using Nginx's ngx_http_mirror_module, covering installation, configuration, custom builds, and practical examples for traffic mirroring and request body handling.
This article explains Nginx's built‑in failure retry mechanism, detailing how fails are defined via proxy_next_upstream, the default and custom error types, retry limits, backup servers, and common pitfalls with configuration examples and practical scenarios.
This article provides a comprehensive guide to tuning Linux kernel parameters and NGINX configuration directives—such as backlog queues, file descriptors, worker processes, keepalive settings, access log buffering, sendfile, and limits—to achieve optimal web server performance for high‑traffic sites.
This step‑by‑step guide shows how to set up a gray (canary) release environment from server preparation and tool installation to Nginx traffic routing and Jenkins automation, enabling developers to safely roll out new features to a subset of users before full deployment.
This article explores how to design a high‑concurrency ticket‑booking service capable of handling millions of simultaneous requests by combining distributed load‑balancing, Nginx weighted round‑robin, Go micro‑services, and Redis atomic inventory management, complete with code samples and performance benchmarks.
This article explains how Nginx implements load balancing, covering algorithms like round-robin and IP hash, and provides a practical setup guide using Node.js and Nginx.
The March 2020 Netcraft Web Server Survey reveals that Nginx surpassed Apache in domain market share for the first time, while Apache still leads in active sites, and provides detailed statistics on millions of domains, web‑facing computers, and the performance of major providers such as Microsoft, Google, Oracle and Cloudflare.
This comprehensive guide covers essential Linux fundamentals, common interview questions, and practical server administration techniques, including boot sequences, runlevels, file system differences, process management, packaging tools, Nginx optimization, MySQL replication, Docker usage, and useful shell scripts for real‑world operations.
This article explains Nginx’s highly modular design, its core, optional and third‑party modules, the multi‑process and asynchronous non‑blocking request handling, the event‑driven model, and the master‑worker interaction that together enable efficient, scalable web server performance.
This article explains the Nginx location directive syntax, the four optional modifiers (=, ~, ~*, ^~), their matching behavior, the overall location matching order, and provides practical configuration examples to help beginners correctly configure Nginx routing.
This guide explains the syntax and four optional modifiers of Nginx's location directive, provides concrete examples for exact, case‑sensitive, case‑insensitive, and prefix matching, and details the matching order with a practical rule‑based case study.
This tutorial walks through preparing a CentOS 7.5 host, installing required dependencies, creating an nginx user, downloading the source, compiling and installing Nginx 1.11.1, configuring the firewall, and using common Nginx commands to start, test, reload, and enable the service at boot.
This article introduces Nginx, compares its high‑performance features and resource efficiency with Apache, explains its core functions such as reverse proxy, load balancing and caching, provides performance test results, and details virtual‑host concepts and types for effective web server selection.
This article explains what OpenResty is, details its underlying Nginx‑Lua architecture—including Lua coroutines, cosocket, and multi‑stage processing—compares its performance with other web platforms, and describes its practical deployment and multi‑level caching strategy in JD.com's high‑traffic Jshop sale system.
This tutorial walks you through installing the lightweight self‑hosted Git service Gitea on Ubuntu 18.04, covering prerequisite packages, user creation, binary download, systemd service setup, optional Nginx reverse‑proxy configuration, email notifications, and upgrade procedures with full command examples.
VeryNginx, built on the lua_nginx_module, adds a powerful firewall, access statistics, and a web UI to Nginx, with clear installation steps, reverse‑proxy and static‑resource configuration examples, and customizable matching and response rules for security management.
This article explains why Nginx delivers high performance and concurrency, covering its multi‑process architecture, master‑worker model, event‑driven I/O (select, poll, epoll), module system, HTTP request handling, and comparison with Apache, while providing practical insights into configuration and scalability.
This guide walks through setting up ELK to collect, parse, and visualize Nginx access logs, covering Logstash configuration, Grok patterns, GeoIP enrichment, Elasticsearch indexing, and Nginx proxy with basic authentication, enabling real-time log analysis and dashboard creation.
This article explains how HTTPS protects data through encryption and identity authentication, describes symmetric and asymmetric algorithms, outlines PKI and certificate issuance processes, demonstrates Nginx certificate deployment, and shows how trust chains and cross‑certificates ensure reliable secure connections.
Learn how to replace manual Nginx upstream configuration with automatic service discovery using Nacos, by either writing Lua scripts with the nginx‑lua‑module or building a Java/Golang agent that fetches instance lists via the Nacos API, updates upstream blocks, and triggers hot reloads.
This article walks through a step‑by‑step investigation of missing image loads in a Kubernetes ingress‑backed Nginx service, revealing how TCP SYN and accept queues can overflow, how to inspect kernel counters, and multiple ways to raise the somaxconn and Nginx backlog limits for high‑traffic workloads.
This article provides a comprehensive overview of server clustering and load balancing technologies, detailing the roles of LVS, Nginx, and HAProxy, their architectures, operating modes, advantages, disadvantages, and practical deployment scenarios for modern web services.
This article explains Nginx's origins, its event‑driven architecture, the reasons it outperformed Apache, and details its roles as a forward and reverse proxy, load‑balancing algorithms, and typical deployment scenarios, illustrating why it is the preferred high‑performance web server today.
This article explains the capabilities of Nginx without third‑party modules, covering reverse proxy, load balancing (including RR, weight, ip_hash, fair, and url_hash), HTTP static serving with static‑dynamic separation, and forward proxy, and provides concrete configuration examples for each feature.
This article traces Nginx’s origins, explains why it outperforms Apache, details the concepts of forward and reverse proxy, and walks through Nginx’s load‑balancing algorithms and practical deployment scenarios, providing a comprehensive guide for backend engineers.
This guide outlines essential steps for deploying a Laravel application, covering Nginx server configuration, Composer autoloader optimization, caching of configuration and routes with Artisan commands, and additional tips to ensure a fast, secure production environment.
This article dissects the extreme‑load challenges of China’s 12306 train‑ticket service, explains its multi‑layer load‑balancing architecture, and provides a complete Go‑based spike‑system example that uses Nginx weighted round‑robin, Redis atomic stock deduction, and channel‑based locking to safely handle millions of concurrent purchase requests.
During holidays, millions of users scramble for train tickets, overwhelming the 12306 system; this article dissects its high‑concurrency architecture, explains load‑balancing layers, demonstrates Nginx weighted round‑robin configuration, and provides a Go‑based spike simulation with Redis stock management and performance results.
This article examines the challenges of designing a robust flash‑sale backend—preventing oversell, handling massive concurrent requests, securing URLs, isolating databases, and applying techniques such as Redis clustering, Nginx load balancing, rate limiting, asynchronous processing, and service degradation—to enable stable, low‑latency sales spikes.
This comprehensive guide walks you through configuring Nginx status pages, compiling modules, using built‑in and custom variables, setting up JSON and gzip logs, enabling HTTPS, mastering rewrite rules, preventing hotlinking, implementing reverse proxy with caching, and deploying both HTTP and TCP load‑balancing with Redis and MySQL back‑ends.
The article details the Russian police raid on Nginx’s Moscow office, the subsequent arrest and release of its founders, the alleged copyright dispute with Rambler, and a concise history of Nginx’s development and its acquisition by F5 Networks.
This article explains Nginx's high‑performance architecture, covering its modular design, event‑driven processing, multi‑stage asynchronous request handling, master‑worker process model, and memory‑pool mechanism, and compares it with traditional web servers.
This guide explains how to improve web service performance by tuning Linux system parameters and Nginx configuration, covering file descriptor limits, TCP connection queues, temporary port ranges, worker processes, keepalive settings, and access‑log buffering, with concrete sysctl and Nginx directives.
The author recounts a nerve‑wracking video interview with ByteDance, detailing questions on Django, Nginx, uWSGI, Redis, data structures, message queues, a live coding task, and shares hard‑earned advice to help future candidates prepare effectively.
This weekly roundup from WecTeam highlights essential frontend topics—including practical Nginx tips for developers, CSS rendering fundamentals, strategies for building visual editors, declarative UI on mini‑program platforms, and engineering practices for React and TypeScript—offering concise overviews and links to the full articles.
The author recounts a grueling ByteDance video interview, detailing technical questions on Django deployment, Nginx configuration, uWSGI internals, Redis fundamentals, heap data structures and quick‑sort coding, while sharing hard‑earned career advice for developers preparing for high‑stakes interviews.
This article explains how to architect a high‑concurrency ticket‑seckill system that can handle one million simultaneous users buying ten thousand tickets, covering load‑balancing strategies, Nginx weighted round‑robin configuration, Go service implementation, Redis‑based inventory management, and performance testing results.
This article explains the design of a high‑concurrency train‑ticket flash‑sale system, covering distributed load‑balancing, Nginx weighted round‑robin, local and remote stock deduction, Go implementation, Redis atomic scripts, and performance testing with ApacheBench.
This guide introduces Nginx fundamentals, shows how to spin up a basic Nginx service with Docker‑Compose, explains HTTP, server and location contexts, and demonstrates practical front‑end‑friendly techniques such as forward proxy, load balancing, SSI, GZIP compression, anti‑hotlinking, HTTPS and caching.
This article explains how to design a high‑concurrency ticket‑sniping service that can handle millions of users by using multi‑layer load balancing, Nginx weighted round‑robin, local stock deduction, Redis for unified inventory, and a Go implementation with performance testing.
