This article explains the fundamental differences between distributed systems and clusters, illustrates them with real‑world examples such as Dubbo, Elasticsearch and Git, and details various cluster types, high‑availability and load‑balancing strategies, as well as fault‑tolerance mechanisms.
This article provides a comprehensive overview of load balancing, covering its core principles, the distinction between vertical and horizontal scaling, various classifications such as DNS, HTTP, IP, link‑layer, and hybrid approaches, as well as common algorithms and hardware considerations for high‑availability, high‑performance systems.
This article explains how to build a highly scalable web service by using load‑balancing, immutable server images, centralized session storage, appropriate database strategies, memory caching, and asynchronous task processing to handle millions of concurrent requests efficiently.
Will Larson’s insights on building scalable systems are distilled here, covering horizontal scalability, redundancy, load balancing strategies, various caching techniques, CDN usage, offline processing with message queues, Map‑Reduce for big data, and the benefits of introducing a dedicated platform layer for robust backend architecture.
This guide explains how to use Keepalived and the VRRP protocol to build a two‑node high‑availability setup for Nginx, covering installation, health‑check scripts, configuration options, testing procedures, and troubleshooting tips for seamless failover.
This article examines nginx’s built‑in and extended load‑balancing algorithms—including weighted round‑robin, IP hash, fair, generic hash and consistent hash—by dissecting source code, describing implementation details, and presenting comparative performance tests that evaluate balance, consistency and fault‑tolerance across various scenarios.
This tutorial walks through configuring Nginx upstream for load balancing and enabling proxy caching of static resources, covering experiment topology, environment setup, key upstream parameters, example configurations, cache directives, and performance observations.
SockJS provides a mature, cross‑browser real‑time communication library that mimics WebSocket while offering fallback transports, load‑balancing options, and easy client‑server integration, making it ideal for building robust web applications in complex network environments.
Will Larson’s insights on scalable system architecture emphasize linear horizontal scalability, redundancy, load balancing strategies, caching layers, CDN usage, offline processing with message queues, and platform layering, providing practical guidance for building robust, high‑capacity backend systems.
This article examines common load‑balancing algorithms—round‑robin, random, minimum response time, minimum concurrency, and hash—analyzing their fault‑tolerance in distributed clusters, deriving success‑rate formulas, and showing why strategies like minimum concurrency outperform simple methods under node failures.
This article introduces Linux Virtual Server (LVS), explains its integration into the Linux kernel, outlines its goals for high‑performance, highly available server clusters, and provides a brief mind‑map overview along with a quiz on LVS modes and its founder’s nickname.
This article introduces the advantages of Nginx and Lua, explains the ngx_lua module and OpenResty ecosystem, describes common architectural patterns such as load balancing and caching, and provides a step‑by‑step guide to building, configuring, and deploying a Lua‑based web application on Nginx.
The article details Upyun's high‑availability image processing architecture, covering workload‑aware system design, custom GmServer implementation, task scheduling, current strengths and limitations, and future directions such as a ServiceServer‑based queue and Docker‑driven dynamic scaling.
This article provides a detailed overview of Stack Overflow's 2015 architecture, covering daily traffic growth, hardware upgrades, redundancy principles, DNS and ISP routing, HAProxy load balancing, IIS/ASP.NET web layer, Redis caching, WebSocket services, Elasticsearch search, SQL Server databases, and the open‑source tools that support the platform.
The article details Meizu's large‑scale real‑time push architecture, covering system scale, four‑layer design, power‑consumption optimizations, network reliability challenges, massive connection handling, load‑balancing strategies, strict monitoring, and gray‑release practices to ensure high performance and stability.
The article details Stack Overflow’s 2016 infrastructure upgrades—including hardware, networking, load balancing, caching, database, and service layers—that enabled the site to process over 61 million daily requests while reducing processing time by hundreds of hours.
The article recounts Meizu architect Yu Xiaobo's presentation on the company's real‑time push system, describing its massive scale, four‑layer backend architecture, challenges such as power consumption, mobile network instability, massive connections, and the monitoring and gray‑release strategies employed to ensure reliability.
NGINX 1.9.1 adds the SO_REUSEPORT socket option, allowing multiple workers to share the same IP and port, which the kernel load‑balances, reducing lock contention and dramatically improving request throughput and latency in multi‑core environments.
This article explains how Taobao scales to billions of daily page views using DNS‑based load balancing, LVS, domain sharding, CDN nodes, a distributed file system, sophisticated search processing, and massive data storage and real‑time log pipelines.
The article explains three primary load‑balancing and service‑discovery patterns for microservice architectures—centralized external load balancers, client‑side soft load balancing, and independent host‑level LB processes—detailing their mechanisms, advantages, drawbacks, and real‑world examples such as F5/HAProxy, Netflix Eureka/Ribbon, and Airbnb SmartStack.
The article explains three primary load‑balancing and service‑discovery patterns for microservice architectures—centralized external load balancers, client‑side soft load balancing, and independent LB processes—detailing their mechanisms, advantages, drawbacks, and real‑world examples such as Netflix Eureka, Dubbo, and Airbnb SmartStack.
This article outlines the architecture of large‑scale dynamic web applications, detailing essential subsystems such as the web front‑end, load balancer, database cluster, caching layer, distributed storage, server management, and code deployment, and explains how they work together to ensure reliability, scalability, and maintainability.
The article details Meizu's large‑scale real‑time push architecture, covering system scale, four‑layer design, mobile power‑saving optimizations, network instability handling, massive connection techniques, load‑balancing strategies, comprehensive monitoring, and gray‑release deployment practices.
Load balancing distributes incoming traffic across multiple servers to enhance performance, ensure high availability, and enable horizontal scaling, with various implementations such as DNS, HTTP, IP, link‑layer, and hybrid methods, each employing algorithms like round‑robin, random, least connections, hash, and weighted distribution, plus hardware options.
This article provides a comprehensive overview of software load balancing, detailing the architecture, features, performance characteristics, and various load‑balancing strategies of Nginx, LVS, and HAProxy, and explains how to choose and deploy them in different scenarios.
The article chronicles UPYUN's cloud CDN development from its modest 30‑40 node deployment in 2010, through multiple architectural revisions, scaling to over 130 edge nodes by 2014, and outlines future plans for DNS‑based load balancing, international backbone expansion, and video/live‑stream acceleration up to 2016.
This article compares Nginx and ZooKeeper as load‑balancing solutions, explains their configurations, highlights scalability challenges with many services, and shows how ZooKeeper can serve as a service registry and notification center to complement or replace Nginx in complex environments.
This article surveys the progression of game server architectures across eight types, detailing how early text‑based MUD servers evolved through multi‑threaded, distributed, and seamless‑world designs to modern hybrid action/MMO back‑ends, highlighting key technologies, scaling strategies, and architectural trade‑offs.
The article reviews the evolution of large‑scale website architecture, explaining how business complexity, multi‑server deployment, session handling, load balancing, database read/write separation, caching, and search indexing together address availability, concurrency, and performance challenges in modern web systems.
The article explains how internet startups can design and evolve a scalable web architecture—through service separation, clustering, load balancing, distributed caching, database replication, and effective team organization—to handle rapid user growth and avoid performance bottlenecks.
This article outlines essential design principles for large‑scale web architectures—including availability, performance, reliability, scalability, manageability and cost—and demonstrates their application through a detailed image‑hosting service example, covering services, redundancy, partitioning, caching, proxies, indexing, load balancing, and queuing to achieve efficient, scalable data access.
This article explains how large‑scale dynamic web applications are built from core subsystems—including web front‑end, load balancing, database clustering, caching, distributed storage, server management, and code deployment—to achieve reliability, scalability, and maintainability for high‑traffic sites.
This article explains why serving many images strains web servers, outlines the challenges of I/O bottlenecks, and presents a practical, scalable solution that uses distributed image servers, dynamic load balancing, random selection algorithms, and health monitoring to improve performance for medium‑size business sites.
This tutorial walks you through installing LVS on a Red Hat server, configuring the router, setting up virtual and real servers, adjusting ARP tables, and validating the cluster with ipvsadm, curl, and Tsung performance testing, all while ensuring high‑throughput static web delivery.
This article analyzes the complete flash‑sale workflow, identifies its unique characteristics and high‑concurrency technical challenges, and presents a layered architecture—including frontend static pages, request interception, queue design, database sharding, caching, optimistic locking, and anti‑cheating measures—to ensure reliability, scalability and data safety.
This article outlines a five‑layer website architecture—web cache, load balancer, web server, file server, and database—illustrated with high‑traffic e‑commerce, ad, and CDN portals, and provides practical recommendations on software choices, high‑availability setups, and performance optimization for each layer.
Consistent hashing organizes the hash space into a virtual ring, allowing cache servers and objects to be mapped with minimal disruption when servers are added or removed, thereby reducing cache misses and backend load compared to traditional modulo‑based hashing.
This article examines the technical difficulties of e‑commerce flash‑sale and ticket‑buying spikes, explains why massive concurrent requests strain web back‑ends, and presents practical design, overload‑protection, anti‑cheat, and data‑safety strategies such as CDN, Redis, locking, and IP filtering.
This article explains reverse proxy concepts, introduces Nginx’s core features and architecture, and provides a step‑by‑step guide to set up Nginx on Windows as a reverse‑proxy and load‑balancer for IIS‑hosted ASP.NET sites, including service registration, configuration tuning, static‑file caching, and testing.
This article presents a detailed walkthrough of Meizu’s real‑time push platform, covering its four‑layer architecture, high‑concurrency design, micro‑service RPC framework, power‑saving strategies, duplicate‑message handling, DNS reliability, load‑balancing tactics, monitoring setup, and gray‑release deployment.
The article explains how Qiniu's data processing platform has evolved from a simple real‑time URL‑based model to a more complex architecture featuring separate caching, agent services, discover monitoring, and container‑based elastic scaling to handle massive unstructured data workloads.
This article outlines essential design principles—availability, performance, reliability, scalability, manageability, and cost—and practical techniques such as service separation, redundancy, partitioning, caching, proxies, indexing, load balancing, and queuing to help engineers construct high‑performance, fault‑tolerant web systems.
Reverse proxy servers act as intermediaries that receive client requests, perform security filtering, cache content, and balance load across multiple backend servers, making them crucial for scaling, protecting, and optimizing modern web applications.
This article traces the evolution of large‑scale website architectures—from single‑server setups to distributed services—detailing how separation of concerns, caching, load balancing, database sharding, CDN, reverse proxies, NoSQL, and service decomposition collectively improve performance, scalability, and reliability.
This article explains how Linux Virtual Server (LVS) distributes incoming requests among backend machines, detailing four common scheduling algorithms—simple round‑robin, weighted round‑robin, least‑connections, and weighted least‑connections—along with example code and a visual illustration of request allocation.
LVS (Linux Virtual Server) is a core kernel module for load balancing that forwards client requests to backend servers using three main mechanisms—Network Address Translation (NAT), IP tunneling (TUN), and Direct Routing (DR)—each with distinct packet handling and performance characteristics.
This article explains how to build a robust multi‑process Node.js server using the cluster module, covering round‑robin load balancing, graceful worker shutdown, process monitoring, and inter‑process communication with code examples for both master and worker processes.
This article outlines the typical progression of website architecture from a single‑server setup through service separation, caching, clustering, read/write splitting, CDN, reverse proxy, distributed storage, NoSQL, and business‑level service decomposition, providing a clear roadmap for scaling web systems.
This article traces the evolution of game server architectures from the first MUD systems in 1978 through successive generations—including HTTP‑based card/runner servers, the MUDOS engine, split‑world models, seamless world servers, Battle.net, casual and modern action MMOs—highlighting design choices, scalability challenges, and practical trade‑offs.
This article examines Node.js’s early criticisms about reliability and single‑threaded limits, then explains how the built‑in cluster module and fork() enable multi‑process deployment, load balancing, and communication, illustrated with code demos, performance insights, and a look at nginx proxy integration.
The article explains how startup engineers can design and evolve a scalable web architecture—through service separation, clustering, load balancing, distributed caching, database replication, and effective team organization—to handle rapid user growth and maintain performance without compromising user experience.
This article explains how stateless application servers combined with load balancers form scalable clusters, detailing request routing, scaling strategies, and common implementations such as Nginx for HTTP forwarding and LVS for IP‑level balancing.
This article outlines a comprehensive distributed server cluster architecture for large‑scale websites, covering the evolution from simple three‑tier setups to high‑availability load‑balancing with HAProxy/Keepalived, Redis caching, NoSQL storage, and future distributed MySQL considerations.
This article presents ten practical techniques—including reverse proxy deployment, load balancing, caching, compression, SSL/TLS optimization, HTTP/2 adoption, Linux kernel tuning, and real‑time monitoring—to dramatically improve the responsiveness and reliability of web applications and services.
This article presents ten actionable techniques—including reverse proxy deployment, load balancing, caching, compression, SSL/TLS optimization, HTTP/2 adoption, Linux tuning, NGINX configuration, and real‑time monitoring—to significantly boost the speed, reliability, and security of web applications.
This article explains why DNS resolution slows down mobile app traffic, compares the traditional PC‑era HTTP flow with wireless app challenges, and presents a DNS‑free optimization that uses a locally cached IP list to improve latency, load balancing, and resilience.
This article explains how a web system can grow from 100,000 to 100 million daily visits by introducing multi‑level caching, various load‑balancing strategies, MySQL performance tuning, distributed database setups, and geographic deployment to maintain stability and performance under massive traffic.
With growing website traffic, single‑machine deployments struggle, so this article examines four session‑management strategies—session stickiness, replication, centralized storage, and cookie‑based approaches—detailing their mechanisms, advantages, and drawbacks to help you select the best solution for scalable web applications.
The article explains how a web system can evolve from handling 100,000 daily visits to over 100 million by implementing multi‑level load‑balancing, various caching strategies, MySQL optimization, distributed database architectures, and geographic deployment to ensure performance, reliability, and scalability.
Load balancing distributes traffic across multiple servers using techniques such as HTTP redirects, reverse‑proxy (layer‑7) routing, IP‑based (layer‑4) balancing, and DNS round‑robin, each with distinct advantages and drawbacks regarding performance, scalability, configuration complexity, and fault tolerance.
This article explores the challenges of handling tens of thousands of requests per second in flash‑sale systems, covering interface design, QPS calculations, overload protection, anti‑cheat measures, and data‑safety techniques such as pessimistic, optimistic, and queue‑based locking.
This guide walks through testing Nginx configuration, starting the server, understanding its load‑balancing architecture, installing from source with required dependencies, handling common build errors, reviewing the final configuration summary, and creating a Linux init script for reliable service management.
The article explains how to create an application‑level interface group for DDBoost to aggregate multiple Data Domain IP interfaces into a private network group, achieving load balancing, fault‑tolerant data transfer, and notes performance considerations such as avoiding mixed‑capacity links.
NGINX determines server health through passive checks—stopping forwarding after failures—and active health checks, which periodically probe each backend using the health_check directive, allowing configuration of intervals, failure thresholds, custom URIs, and response matching criteria to ensure reliable load balancing.
This guide outlines the five primary Nginx load‑balancing methods—Round Robin, Least Connections, Least Time (header or last_byte), IP Hash, and generic Hash—explaining how each algorithm works and showing the corresponding upstream configuration syntax for assigning server weights and parameters.
This guide explains how to set up Nginx as a reverse proxy, create an upstream server group, and configure load‑balancing directives so that two web servers can share traffic and handle increased load efficiently.
This guide explains how to configure Nginx's global parameters, event settings, and HTTP block—including worker processes, error logs, connection limits, upstream load balancing, virtual hosts, and location directives—for optimal backend performance.
Drawing on Will Larson’s insights, this article outlines essential principles for building horizontally scalable systems—including linear capacity growth, redundancy, load‑balancing techniques, caching strategies, CDN usage, offline processing with message queues, and the benefits of a dedicated platform layer for robust, maintainable backend architectures.
This article distills Will Larson’s insights on designing scalable systems, covering linear capacity growth, redundancy, load‑balancing strategies, multi‑layer caching, cache invalidation, offline processing with message queues, Map‑Reduce integration, and the benefits of a dedicated platform layer.
The article distills Will Larson’s insights on designing horizontally scalable systems, covering linear capacity growth, redundancy, load‑balancing strategies, caching layers, CDN usage, offline processing with message queues, Map‑Reduce for big data, and the benefits of introducing a platform layer to improve robustness and reusability.
The article explains how kernel‑level load balancing works, why naïve thread‑pool wake‑up can cause CPU imbalance, and proposes using thread affinity, priority layers and a custom layered condition variable to achieve better performance in multithreaded server applications on Linux.
The article outlines a comprehensive approach to performance tuning by first optimizing algorithms, then enhancing hardware and software environments, and finally improving the interaction between code and resources through load balancing, caching, and I/O reduction, while acknowledging trade‑offs such as consistency and operational complexity.
This guide walks through the complete setup of a load‑balanced Discuz forum using NFS for shared storage, MySQL, PHP‑FPM, and Apache across two front‑end web servers, covering NFS fundamentals, security, configuration files, and step‑by‑step commands for each component.
The article explains why session sharing across servers solves independent session issues but is unsuitable for tightly coupled multi‑step interactions or frameworks with special session handling, and introduces session persistence (sticky sessions) such as Nginx's ip_hash to keep a user bound to a single backend server.
With growing traffic, single-server sites struggle, so developers must share user sessions across multiple servers; this article explains three popular approaches—cookie-based, database-based, and Memcache-based session sharing—detailing their principles, advantages, and drawbacks to help choose the right solution.
Keepalived, built on LVS, automatically monitors service nodes, isolates failed machines, and performs seamless failover between load balancers using VRRPv2, allowing web servers to be added or removed without manual intervention, thus ensuring high availability and efficient load distribution.
The article analyzes the challenges of scaling network devices to handle ten‑million concurrent connections (C10M) and describes Alibaba's AGW solution, which uses lock‑free data planes, hugepages, NUMA‑aware memory placement, and user‑space NIC drivers to achieve high‑performance four‑layer load balancing.
This article describes a complete two‑machine high‑availability solution that uses keepalived to manage virtual IPs, Nginx for load‑balancing, MySQL GTID replication with Atlas as a proxy, and detailed configuration and fail‑over testing steps to ensure seamless service continuity.
This article explains practical techniques for designing high‑availability and scalable systems—covering entry, business, cache, and database layers—so developers can handle rapid user growth without service interruptions or degraded performance.
This article explains the structure of HAProxy configuration files, detailing the five sections—global, defaults, frontend, backend, and listen—along with key directives such as daemon, maxconn, mode, timeouts, bind, and server, and shows how they work together to manage traffic and monitoring.
This guide walks you through installing HAProxy, configuring it to balance HTTP traffic between two Nginx instances on ports 8080 and 8081, and verifying the setup by repeatedly accessing a test page that alternates between the two backend servers.
HAProxy is an open‑source, high‑performance load‑balancing software that operates at both layer 4 (TCP) and layer 7 (HTTP), offering strong reliability, massive concurrency handling, flexible algorithms, and powerful monitoring, making it ideal for large‑scale web and database workloads.
Amoeba is an open‑source MySQL front‑end proxy that acts as an SQL router, offering load balancing, high availability, query filtering, read/write splitting, and linear scaling, thereby simplifying data sharding, reducing client connections, and enabling seamless database expansion.
This guide explains the fundamentals of Linux Virtual Server (LVS), covering cluster concepts, types, scheduling algorithms, ipvsadm commands, and detailed configuration examples for NAT and DR models, culminating in a complete web‑server load‑balancing deployment with Discuz on CentOS.
This guide explains how to use NFS on CentOS to synchronize data between multiple web servers and implement load balancing, covering NFS service basics, configuration files, export options, related commands, DNS setup, shared directory creation, Apache virtual host configuration, and testing the synchronized WordPress site.
The article explains why adding servers and shifting traffic, often dismissed as low‑effort tricks, actually require substantial architectural planning, state management, load balancing, sharding, and multi‑datacenter coordination to reliably handle high‑traffic scenarios.
This article examines the objectives, challenges, evolutionary technologies, design principles, and practical strategies such as resource separation, caching, load balancing, database read/write splitting, CDN, distributed storage, and consistency models that are essential for building and scaling large‑scale website architectures.
The article examines the progressive evolution of image server architectures—from early NFS‑based setups through distributed storage with load balancing and caching, to modern cloud‑based solutions like Alibaba OSS—highlighting design considerations, performance trade‑offs, and implementation details for scalable, high‑availability image services.
This article examines how load‑balancing technologies such as Nginx, LVS, and HAProxy are chosen according to website scale, outlines their respective strengths and weaknesses, and describes typical deployment stages from simple single‑point setups to complex multi‑layer architectures.
The article explains how direct connections to a single web server create a single point of failure and limit scalability, then introduces layer‑4 (transport‑level) load balancing that distributes traffic among multiple backend servers, and finally describes layer‑7 (application‑level) load balancing that routes requests based on URL paths such as “/” and “/blog”, highlighting the added complexity and proxy‑like behavior required.
This article explains various load‑balancing scheduling algorithms—including Round Robin, Weighted Round Robin, Least Connection, Weighted Least Connection, Adaptive Agent‑Based balancing, Fixed Weighted, Weighted Response, and Source IP Hash—detailing how each distributes traffic and handles server capacity differences.
The article examines how to build and scale large web sites by combining technical and business considerations, covering static site deployment, multi‑server availability, session synchronization methods, load‑balancing techniques, database read/write separation, caching, and search indexing to handle high concurrency and data growth.
The article analyzes the challenges of high‑traffic ticketing platforms, compares business models, identifies concurrency bottlenecks, and presents comprehensive front‑end and back‑end optimization techniques—including load balancing, caching, data partitioning, and queue‑based flow control—to achieve horizontal scalability and reliable performance.
This article explains the consistent hashing algorithm, its motivation in cache systems, the concept of monotonicity, the step‑by‑step mapping process, and how virtual nodes improve balance and resilience when cache servers are added or removed.
This article explains the principles of consistent hashing, its classic design with virtual nodes, the shortcomings of the original algorithm, and how Amazon's Dynamo and other extensions improve load balancing and reduce data movement in distributed environments.
This article explains the TCP KeepAlive mechanism, why load balancers like LVS and F5 drop idle connections after 90 seconds, how to configure Linux kernel and socket options, and the correct way to enable TCP KeepAlive in Nginx to prevent premature disconnects.
This article explains how leveraging CDN technology—through caching proxies, routing acceleration, security protection, and cost‑saving strategies—can overcome regional network limitations, mitigate DDoS attacks, and optimize storage and load‑balancing, while also comparing open‑source reverse‑proxy solutions and offering practical hardware and software tuning tips.
This article explains what a Linux cluster is, contrasts it with distributed systems, outlines its two main characteristics—scalability and high availability—along with essential capabilities like load balancing and error recovery, and details common cluster types such as high‑availability, load‑balancing, and high‑performance computing clusters.
The article traces web architecture’s evolution from simple single‑server Java/JSP sites through memory caching, load‑balanced multi‑machine logic, read/write separation, master‑slave replication or message‑queue syncing, horizontal/vertical sharding, and finally multi‑server web‑server deployments behind load balancers to achieve scalability and reliability.
This article examines Nginx's built‑in and third‑party load‑balancing algorithms—including weighted round robin, IP hash, fair, generic hash, and consistent hash—by dissecting their source code and presenting comparative performance tests across multiple scenarios to reveal their strengths and trade‑offs.
