This article walks through the evolution of project architectures—from single‑server MVC to RPC, SOA, and micro‑services—explaining key concepts such as clusters, load‑balancing strategies, and various caching mechanisms, helping readers grasp how high‑concurrency, distributed systems are designed and optimized.
This article outlines the key characteristics of large‑scale web systems and walks through their architectural evolution—from monolithic beginnings to service separation, caching, clustering, read/write splitting, CDN/reverse‑proxy acceleration, distributed storage, NoSQL, business splitting, and distributed services—while highlighting core values and common design pitfalls.
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 guide explains two high‑availability patterns—VIP failover triggered by database outage and by HAProxy status—using dual‑master MySQL, Keepalived, and HAProxy, with step‑by‑step configuration, scripts, and testing procedures to ensure seamless service continuity.
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.
Load balancing distributes traffic across multiple servers to improve performance, reliability, and scalability, covering concepts from basic two- and three-layer methods to advanced four- and seven-layer techniques, and reviewing popular tools such as LVS, Nginx, and HAProxy along with various scheduling algorithms.
This guide walks you through installing Keepalived via yum or source, explains the main configuration sections—including global definitions, VRRP instances, and virtual servers—and details each directive’s purpose, enabling you to set up reliable high‑availability load balancing on Linux systems.
Keepalived, a C‑based routing failover tool originally built for LVS, uses the VRRP protocol to provide high‑availability for services like Nginx, HAProxy, and MySQL, managing virtual IPs, health checks, and rapid failover within seconds.
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 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.
Ctrip’s flight search service processes two billion daily queries by employing a multi‑level Redis cache, machine‑learning‑driven TTLs, distributed pooling and overload protection, AI‑based anti‑scraping, and robust load‑balancing across three data centers, delivering sub‑second latency, up to three‑fold throughput gains and significant cost reductions.
Drawing on Google SRE principles, Bilibili’s technical director outlines a systematic, cloud‑native framework for high‑quality service architecture during traffic peaks, covering frontend and internal load balancing, distributed rate limiting, controlled retries, fail‑fast timeouts, and comprehensive failure‑mitigation strategies.
This article explains the principles, configurations, and real‑world testing of server NIC teaming (Team) technology—covering Intel and Broadcom adapters, switch‑independent and switch‑dependent modes, load‑balancing and fault‑tolerance mechanisms, and step‑by‑step setup procedures to ensure continuous network access for mission‑critical securities systems.
This article introduces Spring Cloud as a Spring Boot‑based microservice framework, explains the fundamentals of service architecture through a company‑division analogy, details the essential components such as service registry, load‑balanced calls, circuit breakers, gateways, configuration centers, message bus and tracing, and provides concrete code examples for a Eureka server, a simple service, and a client using Ribbon and Feign.
This article introduces core concepts of distributed systems, covering microservices, clustering, remote invocation, load balancing algorithms, service registration and discovery, configuration management, circuit breaking, degradation strategies, and API gateways, providing a comprehensive overview for building resilient cloud-native applications.
This article walks through the step‑by‑step evolution of a Java‑based e‑commerce platform, illustrating how a single‑machine deployment can be transformed into a scalable architecture using techniques such as server‑database separation, clustering, load‑balancing algorithms, read‑write splitting, caching, sharding, micro‑services and message queues.
This guide walks through the concepts and step‑by‑step procedures for using Kubernetes 4‑layer Service load balancing, configuring Ingress Controllers (nginx, Traefik), generating TLS certificates, deploying Traefik and a Tomcat application, and exposing them via HTTP and HTTPS.
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.
This article explains the fundamentals of operations and game operations, outlines server management strategies for hundreds of machines, compares RAID levels, evaluates load balancers (LVS, Nginx, HAProxy), discusses proxy servers (Squid, Varnish, Nginx), and clarifies middleware, JDK, Tomcat ports, and CDN concepts.
The article summarizes Xu Wenqi's 2019 Alibaba Cloud Summit talk on Ant Financial's distributed architecture, covering the shift from monolithic to microservices, modular development, load‑balancing, database sharding, the distributed TA system, task scheduling, gray‑release, full‑link stress testing, and OceanBase high‑availability solutions.
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.
The article outlines five key layers—front‑end optimization, middle‑layer load distribution, gateway control, service‑layer improvements, and database tuning—detailing practical techniques such as static resource caching, Nginx load‑balancing methods, request rate limiting, message‑queue buffering, and extensive MySQL best‑practice guidelines to build robust high‑concurrency architectures.
This article walks through the complete source‑code analysis of Spring Cloud Ribbon, covering dependency setup, RestTemplate integration, interceptor creation, load‑balancer execution flow, ILoadBalancer retrieval, server list management, ping strategies, and eager‑loading configuration to reveal how client‑side load balancing is implemented in Spring Cloud.
This article explains the evolution of Kubernetes networking, detailing how container networks originated with Docker, how Kubernetes assigns each Pod a unique IP, the Flannel host‑gw routing model, and the inner workings of Services, including LVS‑based implementations and the four Service types.
This article walks through the step‑by‑step evolution of a high‑traffic e‑commerce backend—from a single‑machine setup to distributed caching, load‑balancing, database sharding, microservices, and finally cloud‑native deployment—highlighting the key technologies and design principles at each stage.
This article explains the concept of web load balancing, its underlying one‑to‑many mapping principle, and compares common techniques such as DNS round‑robin, CDN acceleration, IP‑level load balancing, HTTP redirects, and reverse‑proxy solutions, highlighting their advantages, limitations, and typical deployment scenarios.
This tutorial demonstrates how to replace the traditional VIP‑based MySQL Router deployment with DNS SRV and Consul service discovery, enabling automatic failover and load balancing for MySQL InnoDB Cluster using supported MySQL Connectors and a Python client.
This article outlines how modern internet companies design a scalable architecture by integrating DNS resolution, load balancing strategies, persistent connections, API gateways, push notification systems, microservice communication, distributed transactions, and supporting infrastructure services.
This article explores the challenges of massive ticket‑buying spikes during holidays, explains the multi‑layer load‑balancing architecture, presents Go and Nginx configurations for weighted routing, demonstrates Redis‑based pre‑deduction of stock with Lua scripts, and shares stress‑test results showing thousands of requests per second on a single node.
This article presents Bilibili's exploration of microservice governance, detailing the challenges of service splitting and large‑scale management, the design and evolution of its Go‑based Discovery service discovery framework, advanced load‑balancing algorithms, adaptive rate‑limiting, circuit‑breaking strategies, and future directions for resilient backend systems.
This article explains the origins of Nginx, compares it with Apache, describes forward and reverse proxy concepts, and details Nginx's load‑balancing mechanisms and algorithms, providing a comprehensive overview of how Nginx serves as a high‑performance web and proxy server.
This article details the design and implementation of a Kubernetes‑native API Gateway built with OpenResty, covering its architecture, controller logic, HTTP/gRPC load balancing, custom ingress handling, rate‑limiting, service proxying, and future plans for service‑mesh integration.
This article compares Spring Cloud and Dubbo across protocol handling, performance tuning, load‑balancing strategies, fault‑tolerance mechanisms, and routing/traffic‑shaping features, highlighting their flexibility, configuration complexity, and suitability for different microservice scenarios.
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 article explains why scalability is essential for web apps and outlines core architectural principles—separation of concerns and horizontal scaling—along with practical server roles, load balancing, CDN usage, and worker processes to handle high traffic efficiently.
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 walks through the progressive transformation of a simple Java‑Web e‑commerce prototype—from a single‑machine setup to multi‑server clusters, load‑balancing, database read/write splitting, caching, sharding, service‑oriented architecture, and message middleware—illustrating practical solutions to scalability, reliability, and performance challenges.
This article explores the technical difficulties of flash‑sale (秒杀) systems—such as traffic spikes, resource conflicts, and security concerns—and outlines a three‑stage business flow, data warm‑up, request handling, caching, and isolation strategies to build a resilient backend.
This guide walks you through configuring an IPv6 VPC, assigning addresses to cloud servers, deploying Nginx, creating an IPv6 Cloud Load Balancer with listeners, adding AAAA and A DNS records, and testing the setup on Tencent Cloud’s supported regions.
The article analyzes why a round‑robin load‑balancing approach caused severe response‑time spikes in Ctrip's compute‑intensive international ticket query engine and demonstrates how switching to a proactive pooling model using a Redis‑backed queue eliminated the spikes and reduced average latency by about 20%.
This article explains why service discovery is essential in Kubernetes, details the architecture and syntax of K8s Service, shows how to create and inspect services, demonstrates internal and external access methods—including headless services—and provides a step‑by‑step demo on Alibaba Cloud Container Service.
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 explores the architecture and implementation of a high‑concurrency ticket‑spike system, covering load‑balancing strategies, Nginx weighted round‑robin configuration, Go‑based local stock deduction, Redis‑backed unified inventory control, and performance testing with ApacheBench to achieve stable, scalable ticket sales during peak demand.
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 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 why a single server eventually hits a performance ceiling, introduces high‑performance clustering and the role of load balancers, compares DNS, hardware, and software load‑balancing solutions, outlines typical multi‑layer architectures, and reviews common load‑balancing algorithms with their pros and cons.
The article explains how Youku’s engineers mitigate extreme traffic spikes during large‑scale events by applying three core techniques—staggering requests across time, enforcing client‑side rate limits, and cutting peaks through minimum intervals, probabilistic sending and fairness algorithms—to lower maximum QPS, improve stability, and preserve user experience.
This article analyzes the architecture, load‑balancing strategies, stock‑deduction techniques, and Go/Redis implementation needed to support a million concurrent users purchasing ten thousand train tickets without overselling or underselling.
This article explains what an API gateway is, why it’s crucial for microservice architectures, outlines its core functions such as authentication, load balancing, traffic control, and logging, describes its typical three‑layer architecture, dives into technical principles like protocol conversion and asynchronous processing, and compares popular open‑source gateways such as Kong, Traefik, Ambassador, and Zuul.
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.
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 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 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 how to handle massive, bursty traffic in lottery‑style applications by designing a load‑balancing layer that filters invalid requests, optimizing Tomcat thread pools, and moving core business logic to Redis while using message queues to smooth gift‑distribution spikes.
This article explains the role of load balancers in large-scale internet applications, introduces Linux Virtual Server (LVS) as a four‑layer software load‑balancing solution, describes its architecture, NAT/TUN/DR forwarding methods, and details various static and dynamic scheduling algorithms such as Round Robin, Weighted Least‑Connection, and locality‑based strategies.
The article explains how WMB, a high‑performance distributed message queue, uses Paxos‑based master election, periodic lease renewal, and a multi‑stage load‑balancing strategy to evenly distribute master nodes across groups, improve throughput, and ensure consistent message delivery.
This article explains how Kubernetes services work as load balancers using per‑node sidecar proxies, the role of kube‑proxy, and the iptables/netfilter mechanisms that implement DNAT for traffic routing within the cluster.
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 article explains Docker’s origins, core concepts, and the challenges of container IP volatility, then compares client‑side and server‑side service discovery methods, evaluates DNS, LVS/IPVS, Nginx and HAProxy solutions, and presents practical load‑balancing architectures—including dynamic SLB integration and rolling‑update strategies—for reliable container deployments.
This article provides a comprehensive overview of load balancing, covering its definition, key advantages, various types—including server, firewall, and link load balancing—layer‑4 and layer‑7 distinctions, deployment strategies, and detailed descriptions of common balancing algorithms.
This article explains what an API gateway is, why it is essential in microservice architectures, and how it handles cross‑cutting concerns such as authentication, transport security, load balancing, request routing, dependency resolution, and data transformation, illustrated with a simple Node.js gateway example and code snippets.
This article explains the principles of LVS load balancing, its benefits, the Hulk LVS cluster architecture, request hashing mechanisms, system‑level high availability, and the HULK LVS forwarding panel, providing a comprehensive guide for building resilient high‑traffic web services.
This article outlines how large‑scale web applications evolve from simple single‑server deployments through static‑dynamic separation, clustering, database read/write splitting, sharding, service‑oriented architecture, and message queues, emphasizing the trade‑offs and best practices for each architectural stage.
This article uses Taobao as a case study to trace the evolution of its server‑side architecture from a single‑machine setup to a cloud‑native, micro‑service ecosystem capable of handling tens of millions of concurrent users, highlighting key concepts, technologies, and design principles at each stage.
This article explains the role of Kubernetes Service and kube-proxy, details each Service type (ClusterIP, NodePort, LoadBalancer, Ingress), compares iptables‑based and IPVS‑based load‑balancing implementations, and provides configuration examples for both modes.
This article systematically explains Nginx's architecture, module design, scalability, caching, TLS handling, and OpenResty integration, providing practical guidance for building high‑availability, high‑performance services in large‑scale distributed environments.
This article explains how to configure Nginx as a reverse proxy, implement load‑balancing strategies, separate static and dynamic content, set up proxy caching with various directives, purge caches, and enable gzip compression, providing complete code examples and practical testing results.
This comprehensive guide explains what Nginx is, its capabilities, step‑by‑step installation methods, core commands, configuration file structure, event‑driven model, global variables, authentication setup, virtual host configurations, and detailed location block usage for effective web server management.
This article explains Nginx's five load‑balancing methods, focusing on the weighted round‑robin algorithm, its basic and smooth variants, provides code examples, step‑by‑step execution, and a mathematical proof of why the smooth version distributes traffic fairly according to server weights.
This article explains the fundamentals of forward and reverse proxies, compares their characteristics and differences, and provides practical Nginx configuration examples for implementing reverse proxy, load balancing, and cross‑origin handling in web applications.
This article introduces Nginx’s key capabilities—including static file serving, various load‑balancing strategies, leaky‑bucket rate limiting, browser and proxy caching, and black‑/white‑list access control—explaining how each feature can be configured and applied in high‑concurrency web environments.
Distributed architecture, built on networked software systems, offers cohesive, transparent services through concepts like cohesion, transparency, and various applications such as distributed file systems, caches, databases, and web services, while evolving through stages like caching, clustering, load balancing, and addressing challenges like service management and scalability.
This comprehensive guide explains what Nginx is, why it outperforms Apache, and walks you through installing, compiling, configuring, and running Nginx on CentOS, including essential directives, load‑balancing features, and common command‑line operations.
This article analyzes the shortcomings of Nginx's native Smooth Weighted Round‑Robin (SWRR) algorithm in large‑scale application gateway scenarios, presents a real‑world case where weight adjustments cause traffic spikes, and introduces the VNSWRR algorithm that achieves O(1) selection time, smoother weight handling, and up to 60% higher QPS performance.
This article explains DNS fundamentals, the step‑by‑step resolution process, TTL caching, and how DNS‑based Global Server Load Balancing (GSLB) can direct traffic to the nearest active data‑center, providing a practical guide for building multi‑active, high‑availability infrastructures.
This article introduces server clustering and load‑balancing concepts, compares popular software such as LVS, Nginx, and HAProxy, explains their architectures, NAT and DR modes, and outlines each solution's strengths and weaknesses for building high‑performance web services.
This article traces the evolution of internet architecture from simple single‑instance Java projects through Nginx load balancing, HA clusters, CDN, database read/write separation, NoSQL, distributed search, sharding, distributed file systems, service decomposition, and finally microservice architectures, explaining the motivations, techniques and trade‑offs of each stage.
This article explains the challenges of handling Double‑11 traffic spikes, introduces adaptive load‑balancing concepts, analyzes the 5th Middleware Performance Challenge scenario, and outlines algorithm design considerations and evaluation steps for building a robust, self‑adjusting load‑balancing solution.
This article outlines sixteen practical techniques—from reducing request volume and merging calls to leveraging caching, async processing, sharding, load balancing, and circuit breaking—to help engineers design high‑concurrency architectures that remain stable, performant, and easily scalable under extreme traffic conditions.
This article explains how incorporating hosted‑cloud physical servers into UCloud's UK8S cluster enables seamless hybrid‑cloud operation by improving resource utilization during low‑traffic periods, simplifying network, storage, and load‑balancing configurations, and reducing the operational overhead of managing separate Kubernetes clusters.
This article explains why hotspot keys occur in large‑scale services, outlines the performance risks they create, and presents multiple mitigation strategies—including server‑side caching, Memcache/Redis, local caches, read/write separation, and proactive hotspot detection—to keep systems stable under heavy load.
This article uses Taobao as a case study to trace the step‑by‑step evolution of server‑side architecture from a single‑machine deployment to distributed clusters, caching, load‑balancing, database sharding, micro‑services, containerization and finally cloud platforms, summarizing the key technologies and design principles at each stage.
This article introduces Linux Virtual Server (LVS), explains its three‑tier architecture, details its main components and three load‑balancing methods (NAT, IP Tunneling, Direct Routing), compares their performance, and reviews the eight scheduling algorithms used for traffic distribution.
This article explains why cache clusters are essential, describes the problems caused by hot keys and large values, and presents a multi‑layer solution using streaming analytics, automatic hotspot detection, local JVM caching, and rate‑limiting to keep backend systems stable under massive traffic spikes.
This article explains what Spring Cloud is, its advantages for distributed microservices, the meaning of service registration and discovery, the purpose of load balancing, how Hystrix provides fault tolerance and circuit breaking, the role of Netflix Feign, and the function of Spring Cloud Bus for configuration refresh across instances.
This article details the design and implementation of a high‑availability load‑balancing solution for the DBLE distributed middleware using Lvs and Keepalived, covering environment setup, configuration, experimental scenarios, performance testing, and troubleshooting tips to ensure stable and balanced traffic distribution.
Load balancing distributes incoming traffic across multiple servers to improve performance, reliability, and scalability, and this article explains its purpose, the differences between layer‑2, layer‑3, layer‑4 and layer‑7 balancing, common software solutions like LVS, Nginx and HAProxy, and various static and dynamic load‑balancing algorithms.
The article introduces the Cube Model for scalable microservice architectures, explaining how X‑axis (horizontal scaling), Y‑axis (functional decomposition) and Z‑axis (data partitioning and isolation) expansions address capacity, complexity, and differentiated service demands in high‑traffic distributed systems.
This article provides a comprehensive overview of Nginx, covering its core functions as an HTTP server and reverse proxy, the differences between forward and reverse proxy, supported load‑balancing algorithms, the master‑worker process architecture, and the detailed steps of how Nginx processes a request.
This article explains how Nginx was created to overcome Apache's limitations, describes its role as a high‑performance HTTP and reverse‑proxy server, clarifies forward and reverse proxy concepts, outlines common deployment scenarios, compares load‑balancing algorithms, and provides a feature comparison with other web servers.
This article provides a comprehensive analysis of mainstream microservice service‑registry products—including Nacos, Eureka, ZooKeeper, and Consul—covering their data models, consistency protocols, load‑balancing strategies, health‑check mechanisms, performance, scalability, usability, and extensibility to guide practitioners in selecting and designing registration centers.
This article explains how modern internet systems use server clusters and load balancers, compares the three most popular software solutions—LVS, Nginx, and HAProxy—covers their architectures, NAT and DR modes, advantages, disadvantages, and provides guidance on selecting the right tool for different scale scenarios.
This article outlines the three main load‑balancing methods—DNS, hardware, and software—detailing their advantages and drawbacks, then explains common algorithms such as round‑robin, weighted round‑robin, least‑connections, performance‑based, and hash, and provides guidance on combining them for optimal architecture.
This article explains the principles, advantages, and limitations of various load‑balancing techniques—including HTTP redirection, DNS‑based balancing, reverse‑proxy, LVS‑NAT, LVS‑DR, and LVS‑TUN—while providing practical Linux commands and configuration examples for building scalable systems.
