This article walks through the evolution from a single‑Tomcat deployment to a multi‑layer load‑balancing architecture using Nginx, a gateway, LVS, and DNS, explaining static‑dynamic separation, high‑availability strategies, and performance trade‑offs for scalable backend systems.
This article details how ICBU's core communication pages were accelerated by applying HTTP chunked transfer, streaming HTML rendering, Nginx tweaks, ThreadLocal handling, and caching strategies, resulting in FCP dropping from 2.6 s to 1.9 s and LCP from 2.8 s to 2 s.
This article provides a comprehensive overview of a typical microservice architecture, detailing the roles of Nginx as the traffic entry, gateways, business services, service registries, caching, databases, messaging, logging, scheduling, and distributed storage, and offering practical guidance for high‑availability deployment.
This article explains the Nginx location matching hierarchy—including exact, longest‑prefix, regex, ^~ prefix, and default matches—provides code examples for each, and outlines best‑practice recommendations to optimize server performance and reliability.
This article explains how to design an effective multi‑level cache architecture for microservice systems, covering client‑side browser caching, CDN and Nginx static resource caching, application‑layer in‑process caches, distributed Redis caches, and strategies for maintaining cache consistency using message queues.
This course provides an in‑depth exploration of core backend concepts, covering process fundamentals, TCP/IP socket communication, Nginx integration with PHP‑FPM via FASTCGI, host‑to‑network byte order conversion, and Redis basics, aiming to equip developers, sysadmins, and network engineers with comprehensive backend development skills.
This article explains the concept, architecture, essential components, strategy types, and practical implementation details of a gray (canary) release system in microservice environments, covering simple designs, Nginx integration, gateway handling, and complex multi‑service and data‑layer scenarios.
This guide explains how to define log management goals, handle special logging scenarios for services like MySQL and nginx, and implement automated cleanup using crontab and logrotate, including detailed configuration options and practical examples for reliable log rotation and storage control.
This article explains the leaky bucket and token bucket algorithms, how they relate to traffic shaping, and provides practical Nginx configuration examples using the ngx_http_limit_req_module and ngx_http_limit_conn_module to control request rates and concurrent connections.
This article provides a detailed, step‑by‑step tutorial on Nginx, covering its purpose, core features, installation on Linux, essential commands, configuration file structure, practical examples for static serving, reverse proxy, load balancing, HTTPS, security hardening, health checks, and load‑balancing algorithms.
The article explains the importance of IP black‑ and white‑listing for external APIs, compares implementing the filters inside a Spring Boot project versus configuring them in Nginx, and provides step‑by‑step code and configuration examples for both approaches.
This guide shows how to speed up Vue‑based web apps by configuring Nginx to serve gzip‑compressed files dynamically and using the compression‑webpack‑plugin to pre‑compress JavaScript and CSS during the build, cutting bundle size from megabytes to a few, and halving page‑load times without extra server load.
This guide walks you through Nginx fundamentals—including its role as a web server, proxy, reverse proxy, and load balancer—followed by step‑by‑step installation, configuration examples, and essential commands for managing a production‑grade Nginx setup.
This guide walks you through Nginx fundamentals, core and advanced configuration, reverse‑proxy setup, access control, HTTPS security, system parameter tuning, and practical deployment examples, providing a comprehensive visual reference for mastering high‑performance web server management.
This article explains how to build a multi‑level caching system for microservice applications, covering client‑side HTTP caching, CDN and Nginx static‑resource caching, in‑process and distributed Redis caches, consistency challenges, and practical guidelines for when such a design is beneficial.
This article walks through Nginx rate‑limiting configurations step by step, explaining the leaky‑bucket algorithm, basic limit_req_zone settings, then enhancing them with burst and nodelay options, and finally fine‑tuning concurrency with the delay parameter, complete with code examples and diagrams.
This guide walks you through installing Docker Desktop on Windows, activating a single‑node Kubernetes cluster, deploying the Kuboard management UI, and finally creating and testing an Nginx deployment using Kuboard’s graphical interface and command‑line tools.
Bilibili’s downstream CDN was rebuilt from a tightly‑coupled scheduler model into a cloud‑native architecture featuring separate gateway, cache, back‑origin and control services that provide layer‑4 and layer‑7 load‑balancing, cluster‑wide health checks, centralized routing, and a refactored NGINX slice module, cutting latency by 40 % and dramatically reducing incidents.
This course provides an in‑depth exploration of core backend concepts—including processes, socket programming with TCP/IP, Nginx‑FASTCGI communication, host‑to‑network byte order conversion, and Redis fundamentals—to equip developers, system administrators, and network engineers with comprehensive backend development skills.
This article explains why Nginx is renowned for high performance and details the architectural components—master and worker processes, event‑driven non‑blocking I/O, memory pooling, load‑balancing, caching, modular design, and proxy mechanisms—that enable it to sustain millions of simultaneous connections.
This article explains the role of Nginx load balancing, compares common algorithms such as Round Robin, Weighted Round Robin, and IP Hash, and provides a step‑by‑step configuration example with detailed parameter explanations for building a robust backend traffic distribution system.
This article explains the CORS mechanism, the four essential response headers, how preflight requests work, and provides detailed Nginx proxy configurations with multiple real‑world scenarios to eliminate cross‑origin errors when a front‑end site accesses a back‑end service.
This article introduces and details five widely used Nginx load‑balancing algorithms—Round Robin, IP Hash, Least Connections, Weighted, and Weighted Round Robin—explaining their principles, configuration examples, and typical application scenarios for backend services.
This article walks through the complete process of capturing a Hikvision RTSP camera stream, converting it with FFmpeg, serving it via Nginx (including RTMP/HLS modules), and finally playing the HLS stream in a Vue 3 web page using video.js, while also providing installation scripts and performance tips.
This article explains how to design an effective multi‑level caching system in microservice environments, covering client‑side browser caching, application‑layer static resource caching with CDNs and Nginx, and service‑layer caches using in‑process solutions and distributed Redis, while also addressing consistency and deployment considerations.
This guide explains why separate ports are normally required for multiple SSL sites, how Nginx’s SNI support lets you share a single IP and port, and provides step‑by‑step compilation and configuration examples for www, live, and vod domains.
This guide shows how to collect Nginx access logs, convert them to JSON, ship them with Promtail to Loki, and display the data in Grafana dashboards, including setup steps, configuration snippets, and troubleshooting tips for a lightweight observability stack.
This article explains the concept and importance of load balancing, then demonstrates a practical Docker‑Compose setup with multiple PHP containers and an Nginx reverse proxy, including configuration files and test results that show how traffic is distributed to improve system reliability and performance.
This article explains the relationship between API gateways and service meshes, compares four methods for exposing services inside an Istio mesh, and provides a step‑by‑step guide to using Nginx Ingress Controller as the mesh entry point.
The article shows how OpenResty’s Lua‑based extensions can implement lightweight, version‑controlled API authentication, dynamic traffic‑shaping via shared‑memory peer status, and selective request tracing with batch‑sent logs to Elasticsearch, enabling secure, highly available services and rich observability without sacrificing Nginx performance in production.
This guide walks through installing Nginx and Java on CentOS, deploying a Spring Boot JAR, obtaining a free FreeSSL.cn certificate with acme.sh, configuring Nginx for HTTP‑to‑HTTPS redirection and SSL, and enabling automatic three‑month renewal via the built‑in cron job.
Core Nginx developer Maxim Dounin announced a fork called Freenginx, citing disagreements with F5’s corporate control and non‑technical interference, and aims to keep the web server’s development independent, inviting community contributions while outlining Nginx’s history and market share.
A port alarm revealed a missing Java process, which was later traced to an OOM kill triggered by vim loading a 37 GB nginx log into an 8 GB container, illustrating how editor behavior and Linux's OOM killer can unexpectedly terminate critical services.
This guide explains how to configure Kubernetes Ingress Nginx to duplicate 100% of live application traffic from a production cluster to a staging cluster, enabling safe simulation testing and rapid performance troubleshooting without affecting end‑user responses.
This guide walks through diagnosing and fixing typical CORS problems by configuring Nginx as a proxy, explaining the four essential response headers, handling preflight requests, and providing complete server blocks for various error scenarios.
This guide walks through selecting streaming protocols, preparing a high‑performance server, installing OpenResty, compiling the nginx‑ts module, configuring Nginx for RTMP/HLS/DASH, pushing streams with FFmpeg or OBS, and applying security and stability best practices.
The article analyzes the extreme‑traffic challenges of the 12306 ticket‑seckill service, presents a layered load‑balancing architecture, compares inventory‑deduction strategies, and demonstrates a complete Go‑based prototype with Nginx weighted round‑robin, Redis stock management, and ApacheBench performance testing.
This comprehensive guide walks you through Nginx fundamentals, master‑worker architecture, core and advanced configuration, virtual host setup, access control, file existence handling, HTTPS security, reverse‑proxy mechanisms, and production deployment, providing clear explanations and visual diagrams for rapid mastery.
This article explains why browsers block cross‑origin requests, details the four CORS response headers, demonstrates common error scenarios, and provides step‑by‑step Nginx configuration examples—including handling pre‑flight OPTIONS requests and header inheritance—to reliably solve CORS problems.
Maxim Dounin launched the FreeNginx fork to free the popular Nginx web server from F5's corporate influence after disputes over an HTTP/3 vulnerability, highlighting broader geopolitical and open‑source governance challenges.
This article explains how to quickly set up Nginx Proxy Manager with Docker, covering project goals, key features, step‑by‑step deployment, default credentials, advanced Docker network and health‑check configurations, and provides useful code snippets and screenshots for reference.
This article explains Kubernetes Ingress fundamentals, compares major Ingress controllers such as Nginx, Kong, Traefik, HAProxy and APISIX, and details the internal architecture and Lua‑based extension points of the ingress‑nginx controller, providing a comprehensive guide for managing external traffic in cloud‑native environments.
This tutorial demonstrates how to monitor Nginx using Prometheus by enabling the stub_status module, installing and running the Nginx Exporter, configuring Prometheus scrape jobs, and optionally visualizing the collected metrics in Grafana, providing a complete end‑to‑end monitoring solution.
This article documents a real‑world Nginx optimization case where adjusting gzip compression levels and switching to static gzip reduced CPU usage dramatically, enabling a 9‑wan QPS load to be handled with only 7% CPU and achieving over a 50‑fold performance gain.
This course offers an in‑depth exploration of process concepts, TCP/IP and Socket communication, Nginx‑FASTCGI integration, host‑to‑network byte order conversion, and Redis fundamentals, targeting backend developers, system administrators, and network engineers seeking comprehensive backend skill enhancement.
This article documents a performance benchmark of AngusTester on a single node, demonstrating over 600,000 transactions per second against an Nginx HTTP server, and details the test purpose, environment, configuration, execution steps, and result analysis.
This article documents a real‑world nginx performance tuning case where adjusting gzip settings and switching to static compression reduced CPU usage dramatically and increased QPS from 5 w to 27 w, achieving more than a fifty‑fold overall performance improvement.
This comprehensive guide introduces Nginx’s high‑performance architecture, explains forward and reverse proxy concepts, demonstrates load‑balancing and static‑dynamic content separation, provides practical configuration commands, and walks through real‑world setups for reverse proxy, load‑balancing, static‑dynamic separation, and high‑availability using Keepalived.
This guide walks through preparing a local frontend and backend, explains the four essential CORS response headers and preflight requests, then presents five common CORS error cases with step‑by‑step Nginx configuration fixes and a complete working example.
This guide explains why and how to replace the single‑threaded Apache httpd service with Nginx for Zabbix, covering installation of Nginx and PHP‑FPM, configuration adjustments, service restarts, and timezone fixes to ensure the Zabbix web interface works correctly.
This article explains the concept, architecture, strategy configuration, and execution mechanisms of a gray (canary) release system for microservices, covering simple designs, Nginx and gateway implementations, and complex multi‑service and database scenarios with practical code snippets.
This article presents a concise Spring Cloud microservice architecture diagram, explains each component such as DNS, CDN, LVS, Nginx, Nacos, Sentinel, Redis, and Elasticsearch, and offers practical guidance on their roles, selection criteria, and implementation details for interview preparation.
This tutorial walks through creating a project structure, writing a simple PHP app, configuring Nginx, authoring Dockerfiles, setting up .dockerignore and docker‑compose.yml, and finally building and running the containers so the PHP service is reachable via Nginx on localhost.
This comprehensive guide introduces Nginx as a high‑performance web and reverse‑proxy server, explains its core features such as virtual hosting, load‑balancing strategies, and detailed security hardening techniques, and provides practical configuration examples for production environments.
This article explains how to configure Nginx for rate limiting, including request rate control, burst handling, whitelisting, connection limits, and upload/download bandwidth throttling, with detailed directives, examples, and code snippets to ensure proper service stability.
This article provides a comprehensive, step‑by‑step tutorial on setting up a server, configuring VMware, establishing remote connections, uploading front‑end assets, and configuring Nginx to deploy a front‑end project from scratch, targeting beginners who lack deployment experience.
This article explains how to configure Nginx for IP whitelist/blacklist access control using the allow/deny directives, the ngx_http_geo_module for IP and country restrictions, and provides step-by-step examples, file setups, and GeoIP module installation for both Ubuntu and CentOS.
This guide shows how to configure Nginx to proxy both unsecured WebSocket (ws) and secure WebSocket (wss) traffic, using standard HTTP ports 80 and 443, by setting upgrade headers, defining upstream servers, and adding SSL certificates for encrypted connections.
nginxWebUI is an open‑source web UI that lets you graphically configure Nginx features such as HTTP/TCP forwarding, reverse proxy, load balancing, SSL certificate automation, and multi‑server cluster management, with detailed installation steps for Linux, Windows, Docker, and systemd service setup.
This tutorial walks through preparing an Alibaba Cloud server, installing Docker and Docker‑Compose, resolving permission issues, setting up Nginx and Jenkins containers, configuring docker‑compose.yml and nginx.conf, and finally launching the environment with Docker commands, providing a complete CI/CD deployment pipeline.
This extensive tutorial explains Nginx's architecture, installation, directory layout, configuration directives, location matching rules, reverse proxy setup, load balancing strategies, static‑dynamic separation, CORS handling, caching mechanisms, access control lists, rate limiting, HTTPS configuration, compression, and many other essential directives for effective web server and reverse‑proxy management.
The article explains how Cloudflare built the Rust‑based Pingora reverse proxy to overcome Nginx's architectural limits, achieve higher performance, better connection reuse, lower CPU/memory usage, and stronger safety, while supporting new features for its edge platform.
This guide walks you through understanding what a Raspberry Pi is, the specifications of the Zero W model, preparing the SD card, flashing Raspbian, configuring SSH and Wi‑Fi, optimizing the system, installing Nginx, and exposing the device to the Internet with ngrok.
This article explains how front‑end projects access back‑end services after deployment, how Nginx reverse‑proxy solves cross‑origin problems, and how to configure production paths in Vue projects for proper static resource delivery.
This guide walks you through obtaining a valid SSL certificate, installing Nginx on a Linux server, configuring the HTTPS server block, converting certificates to PEM format, and testing the secure connection, providing step‑by‑step commands and example configurations.
This guide walks through installing Nginx, configuring Promtail and Loki to collect JSON‑formatted access logs, adding GeoIP support, deploying Grafana via Docker, connecting the Loki data source, and creating a dashboard with the world‑map panel to visualize website traffic.
This guide walks through setting up a Percona XtraDB Cluster (PXC) version 5.7.43 on three Docker‑installed machines, configuring hostnames, loading images, creating a Swarm overlay network, deploying the cluster, adjusting MySQL settings, handling common failures, and adding load balancing with Nginx or HAProxy.
This guide walks you through selecting a cloud server, configuring DNS, SSL, and system images, connecting via SSH or VNC, installing and configuring Nginx, uploading your site files, and using the Baota control panel to manage a Linux‑based web server, while addressing common pitfalls.
This guide explains how to build a dynamic IP blacklist using Nginx, Lua, and Redis, covering installation of LuaJIT, compiling Nginx with required modules, configuring Redis, writing Lua access‑limit scripts, and verifying that frequent requests are automatically blocked for a set period.
This guide explains what the Nginx Ingress Controller is, how to install it on Kubernetes using Helm, and provides example configurations for deploying it in production (EKS) and development (Docker Desktop) environments to route traffic to backend services.
This article provides a comprehensive overview of Nginx, covering its high‑performance characteristics, primary use cases such as static file serving and reverse proxy, essential command‑line utilities, and detailed explanations of the main, events, and http configuration blocks with practical examples and syntax rules.
This article walks you through installing the open‑source WAF‑FLE console, configuring its PHP/LNMP environment, setting up ModSecurity log ingestion with mlog2waffle, and troubleshooting common issues so you can efficiently monitor and analyze web‑application firewall events.
This article explains how Nginx's ip_hash directive implements session affinity by routing all requests from the same client IP to a single backend server, provides configuration examples, discusses practical pitfalls, and shares real‑world test results.
The article describes the design background, overall architecture, management backend, and header/footer client implementations (Nginx and Java) of JD's unified header/footer management system, explaining how it enables rapid, centralized updates of site-wide header and footer content across hundreds of services.
This guide walks through installing FastDFS on a Linux server, configuring its tracker and storage nodes, integrating the FastDFS Nginx module, and exposing the service to the internet using cpolar, providing a complete end‑to‑end solution for distributed file storage and remote access.
This article explains how Cloudflare built Pingora, a Rust‑based HTTP proxy that outperforms NGINX in scalability, connection reuse, and security, detailing the architectural limits of NGINX, design decisions behind Pingora, and the measurable performance and efficiency gains achieved in production.
Cloudflare’s new Rust‑based Pingora proxy outperforms Nginx by improving connection reuse, cutting CPU and memory usage, and enhancing security, offering a faster, more efficient, and feature‑rich solution for handling trillions of HTTP requests across its global network.
This article explains the thundering herd effect, walks through Nginx's master‑worker architecture and its use of epoll, and compares three practical solutions—accept_mutex, EPOLLEXCLUSIVE, and SO_REUSEPORT—to eliminate wasted wake‑ups in high‑concurrency servers.
This article presents a detailed, end‑to‑end case study of how Yanhuang Data leveraged the Honghu data‑analysis platform to build a complete Nginx operations‑management solution, covering data ingestion, parsing, modeling, visualization, alerting, third‑party integration, and best‑practice recommendations.
This article explains the thundering herd phenomenon in multi‑process servers, walks through Nginx’s master‑worker architecture and its use of epoll, and compares three practical mitigation techniques—accept_mutex, EPOLLEXCLUSIVE, and SO_REUSEPORT—complete with code excerpts and configuration examples.
This article explains what a 502 Bad Gateway error means, why it is usually generated by a reverse‑proxy like nginx, and provides step‑by‑step methods to identify common causes such as backend timeouts, process crashes, and misconfigured upstream servers.
Using only Tomcat for web services leads to DNS limits, scaling costs, lack of health checks, and no static file handling, so the article explains why Nginx is essential for load balancing, failover, and virtual‑host configuration, and provides practical Nginx examples.
This step‑by‑step guide shows how to install FastDFS on a Linux server, configure its tracker and storage nodes, integrate it with Nginx, and expose the file service to the Internet using the cpolar tunneling tool, all with detailed commands and configuration files.
This article walks you through understanding what a Raspberry Pi Zero W is, preparing the hardware, flashing Raspbian Lite, configuring SSH and Wi‑Fi, optimizing the system, installing nginx, and exposing the device to the internet using tools like ngrok.
This article explains Docker fundamentals, compares containers with virtual machines, details Docker’s core components and common commands, and provides complete step‑by‑step instructions for packaging, building, running, automating, and pushing both a Vite‑based React frontend and an Express‑based Node.js backend using Nginx and shell scripts.
This article explains how Nginx's ip_hash directive implements session affinity by routing all requests from the same client IP to a single backend server, demonstrates configuration examples, analyzes behavior when servers go down, and discusses the method's limitations such as load imbalance and dynamic IP issues.
This article explains how to achieve session affinity using Nginx's ip_hash directive, covering the concept, configuration syntax, practical examples, common pitfalls, and test results for handling client IP‑based load balancing across backend servers.
This article explains the thundering herd effect in multi‑process servers, describes Nginx's master‑worker architecture and its use of epoll, then compares three mitigation techniques—accept_mutex, EPOLLEXCLUSIVE, and SO_REUSEPORT—showing code snippets and performance insights.
This article explains what a Web Application Firewall (WAF) is, introduces the open‑source SafeLine WAF, and provides step‑by‑step instructions for containerized installation, describes its architecture and core security capabilities such as semantic attack detection, IP intelligence, traffic control, and high‑performance protection for web sites.
This tutorial explains why centralized log collection is essential for micro‑service systems, introduces the ELK stack (Elasticsearch, Logstash, Kibana), provides step‑by‑step installation on Ubuntu, shows how to configure Logstash shipper and indexer pipelines, and demonstrates integration with Spring Boot and Nginx logs for real‑time monitoring.
This article explains how to configure Nginx as a stream proxy to securely connect to MySQL servers, covering required modules, stream, server, listen directives, IP access restrictions, and provides complete configuration examples for both single‑instance and clustered environments.
This guide walks through the two most typical Nginx HTTP‑to‑HTTPS redirection setups—direct client access and proxy‑mediated access—showing why the simple 301 rule works in the first case, why it fails with an upstream proxy, and how to correctly use request headers and Nginx variables to achieve reliable redirects.
This article explains how to configure Nginx's stream module to proxy MySQL connections, including building Nginx with the required module, setting up stream, server, and listen directives, and using allow/deny rules to restrict access by IP, followed by a complete configuration example.
This article provides an in‑depth overview of Nginx, covering its core features, performance benefits, request processing flow, forward and reverse proxy concepts, startup commands, directory layout, detailed nginx.conf settings, location directive syntax, common SPA 404 handling, CORS setup, and gzip compression for building high‑performance web services.
This guide explains how to use Nginx’s stream module as a jump‑host to securely proxy MySQL connections, covering module compilation, core directives, configuration examples for single and clustered servers, and IP‑based access restrictions to protect database traffic.
SQL injection is a critical web security flaw where unsanitized user input can alter database queries, and this article explains its mechanics, demonstrates vulnerable Java code, and outlines four prevention methods—PreparedStatement, MyBatis #{}, request parameter filtering, and Nginx reverse‑proxy rules—complete with code examples.
This article explains the importance of Docker for frontend development, covering its role as a consistent runtime environment, the benefits of standardized CI/CD pipelines, multi‑stage builds, caching strategies, and practical deployment patterns for static assets, Node.js services, and micro‑frontend architectures.
This article explains why URL mappings that worked in Spring Boot 2.x break after upgrading to Spring Boot 3, demonstrates the issue with trailing slashes, and provides three practical solutions—including a filter, Nginx rule, and Spring Cloud Gateway optimization—to restore correct routing.
The article explains why rate limiting is essential for high‑traffic Spring Boot services, compares counter, sliding‑window, token‑bucket and leaky‑bucket algorithms, demonstrates implementations with plain Java, Guava RateLimiter, AOP, and distributed approaches using Redis‑Lua and Nginx‑Lua, and provides practical configuration examples.
This article explains the complete browser caching workflow for Google Chrome, covering strong and conditional caching mechanisms, the differences between disk and memory caches, relevant HTTP response headers, how to clear or bypass caches, and practical Nginx configuration tips for front‑end developers.
