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.
This article analyzes the limitations of native Twemproxy, describes how Nginx's master‑worker multi‑process model and related Linux kernel features were integrated to create a high‑performance, highly available cache proxy, and presents extensive online and benchmark results showing significant latency and QPS improvements.
This guide walks through installing and compiling Nginx and its Alibaba‑derived fork Tengine, adding the echo‑nginx module, configuring health‑check directives, testing the setup with sample URLs, and explains Nginx upstream fault‑tolerance mechanisms for production environments.
This article explores the design of a high‑concurrency ticket‑spike system, covering multi‑layer load balancing, weighted Nginx routing, pre‑deduction inventory strategies using Redis, Go implementation details, and performance testing that demonstrates handling millions of requests while preventing oversell and ensuring high availability.
This article dissects the extreme concurrency challenges of China's 12306 ticket‑spike scenario, presents a layered load‑balancing architecture, compares order‑processing strategies, and provides a complete Go‑based prototype with Nginx weighted routing and Redis atomic stock deduction, complete with performance testing and key takeaways.
This article explains how to build a high‑concurrency ticket‑seckill system using Go, Nginx weighted load balancing, and Redis, covering architecture design, local and remote stock deduction, Lua scripting for atomic operations, and performance testing with ApacheBench to achieve thousands of requests per second without overselling.
This article explains how to build a high‑concurrency train‑ticket flash‑sale system that can handle millions of requests by combining layered load‑balancing, Nginx weighted round‑robin, in‑memory stock deduction, Redis atomic Lua scripts, and a Go HTTP service with channel‑based concurrency control, and it provides performance test results and source code.
This article explains how Nginx creates and controls its master and worker processes using Linux signals, global flag variables, and a series of initialization steps—including signal handling, process spawning, socketpair communication, and worker loop execution—to achieve robust, high‑concurrency request handling.
This article provides a comprehensive overview of the HTTP/2 protocol, explaining its binary framing, multiplexing, header compression, request prioritization, and server push features, and offers step‑by‑step guidance for upgrading Nginx to support HTTP/2 along with detection methods.
This article explores the architecture and implementation of a high‑concurrency train‑ticket flash‑sale system, covering load‑balancing strategies, weighted round‑robin Nginx configuration, local and remote stock deduction using Go and Redis, performance testing, and key lessons for building reliable, scalable services.
This article explains how Nginx parses its configuration file by introducing the core data structures ngx_conf_t and ngx_command_t, describing the versatile ngx_conf_parse function, and detailing the step‑by‑step processing of HTTP, server, and location blocks, including conflict resolution.
Load balancing distributes client requests across multiple servers to improve performance, reliability, and scalability, and can operate at different OSI layers—L2, L3, L4, and L7—using various techniques such as round‑robin, hash, and dynamic algorithms, with popular software solutions like LVS, Nginx, and HAProxy.
This article explores Nginx’s elegant architecture, detailing its master‑worker process model, modular design, event‑driven engine, and the step‑by‑step initialization sequence—including command‑line parsing, cycle creation, container setup, configuration parsing, socket inheritance, and listening socket creation—based on version 1.15.8.1.
This article explores the design of a high‑concurrency train‑ticket flash‑sale system, covering distributed load‑balancing architectures, OSPF/LVS/Nginx strategies, pre‑deduction inventory techniques, Go‑based HTTP services, Redis Lua scripts, and performance testing with AB, demonstrating how to achieve stable, scalable ticket‑purchasing under massive traffic.
This tutorial demonstrates how to enable shared HTTP sessions across multiple Spring Boot instances by integrating Apache Shiro with Redis via the CrazyCake plugin, configuring Maven dependencies, Redis and Shiro settings, building service and controller layers, and deploying the applications behind an Nginx load balancer for seamless session persistence.
This article explores the design of a high‑concurrency train‑ticket flash‑sale system, covering load‑balancing strategies, weighted Nginx configuration, in‑memory pre‑deduction, Redis Lua scripts, and Go implementation, and demonstrates its performance with real‑world stress testing.
This article explains the core features of HTTP/2, TLS 1.3, ECC and Brotli, and provides practical Nginx configuration steps—including binary framing, header compression, flow control, multiplexing, request priority, server push, and module compilation—to dramatically improve web latency and bandwidth efficiency.
A candid recount of a ByteDance backend interview reveals how superficial preparation, gaps in Nginx, uWSGI, Redis, and data‑structure knowledge, and nervousness can derail even experienced developers, while offering concrete advice on early preparation, resume framing, and tackling tough technical questions.
This article demonstrates two approaches for creating an Nginx pod in Kubernetes: using direct kubectl commands to pull the image and run a pod, and defining a pod manifest YAML file with specifications, followed by kubectl create/apply/delete commands.
This guide explains how to use NGINX to load‑balance and proxy WebSocket connections, covering protocol basics, required header settings, and a complete Node.js example with installation, server code, and NGINX configuration.
This guide walks through identifying a 4 GB memory leak in an Nginx worker process on Linux, using tools such as top, ps, dmesg, pmap, /proc/*/smaps, and gdb to pinpoint the faulty extension and apply a fix.
Learn step‑by‑step how to install Anaconda parcels on a CDH cluster to create isolated Python 3 environments, set up a local Conda package repository with Nginx, use wget and bandersnatch to mirror packages, and configure private pip sources for Windows and Linux nodes.
This article investigates persistent CLOSE_WAIT sockets in a Tomcat‑Nginx architecture, identifies HttpClient’s connection‑manager as the root cause, and details the step‑by‑step analysis and configuration changes that finally eliminated the issue.
