Tagged articles
load-balancing
53 articles · Page 1 of 1
This guide walks through the latest Nginx 1.26.x features, environment prerequisites, compilation options, worker and kernel tuning, reverse‑proxy setup, load‑balancing algorithms, advanced caching strategies, TLS hardening, high‑availability with Keepalived, common pitfalls, monitoring, and troubleshooting techniques for production‑grade deployments.
CachingNGINXload-balancing
0 likes · 47 min read

This comprehensive tutorial walks you through Nginx's core features, configuration syntax, and practical examples covering global settings, events, HTTP, server and location blocks, upstream load balancing, proxy settings, HTTPS, CORS, gzip compression, access control lists, and caching strategies, all illustrated with ready‑to‑use code snippets.
CachingGZIPload-balancing
0 likes · 34 min read

Discover proven strategies to optimize Nginx under extreme traffic, covering benchmark testing, kernel tuning, configuration tweaks, caching, load balancing, SSL hardening, monitoring, and real-world case studies that demonstrate how to achieve stable high‑QPS performance while minimizing latency and resource usage.
high-concurrencyload-balancingmonitoring
0 likes · 22 min read

This article explains how increasing consumers affects RocketMQ message backlog, details conditions where adding consumers helps or not, describes ProcessQueue flow control, outlines six load‑balancing strategies—including average, round‑robin, custom, machine‑room, nearby, and consistent‑hash—and provides corresponding Java code examples.
Consumerallocation-strategyload-balancing
0 likes · 10 min read

This article explains how to streamline OpenFeign usage during local development by creating a custom ImportBeanDefinitionRegistrar that registers Feign clients with configurable URLs, avoiding manual URL changes in annotations and ensuring seamless switching between local and production environments.
FeignOpenFeignload-balancing
0 likes · 15 min read

This comprehensive guide explains what microservices are, why they evolved from monolithic applications, the challenges they introduce, popular open‑source solutions such as Dubbo, Spring Cloud Netflix and Spring Cloud Alibaba, and essential components like service registries, configuration centers, remote‑call mechanisms, load‑balancing, circuit‑breakers, tracing, and monitoring for building resilient cloud‑native systems.
Configurationcircuit-breakercloud-native
0 likes · 44 min read


IT NiukeJun 2, 2024 · Backend Development
The article analyzes the limitations of deploying web services with Tomcat alone—such as DNS IP caps, scaling costs, lack of health checks, static file handling, and release downtime—and demonstrates how Nginx’s reverse‑proxy, health‑check, and virtual‑host features overcome these issues with concrete configuration examples.
DNSNGINXTomcat
0 likes · 11 min read

Intel’s HDSLB series introduces a high‑density, scalable L4 load balancer that leverages Intel Xeon CPU instructions and E810 NIC acceleration to deliver multi‑core linear performance, superior throughput, and robust features for cloud and edge networking, outperforming traditional LB solutions.
IntelL4cloud-computing
0 likes · 16 min read

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.
BackendIP HashNGINX
0 likes · 9 min read

This article explores the architecture and implementation of a high‑concurrency ticket‑spike system, detailing load‑balancing strategies, in‑memory stock deduction, Redis atomic operations, and Go code examples that enable millions of users to purchase tickets simultaneously without overselling or underselling.
distributed-systemshigh-concurrencyload-balancing
0 likes · 19 min read

This article explains how Spring Cloud OpenFeign discovers @FeignClient interfaces, registers them as beans, configures FeignClientFactoryBean, selects the appropriate HTTP client implementation, and integrates load‑balancing through FeignBlockingLoadBalancerClient and related classes.
Feign ClientOpenFeignload-balancing
0 likes · 11 min read


21CTOMar 24, 2023 · Backend Development
This article dissects the architecture of a 12306‑style ticket‑spiking service, explaining load‑balancing strategies, weighted Nginx routing, local and remote stock deduction using Go and Redis, and demonstrates performance testing that achieves thousands of requests per second while preventing oversell and undersell.
BackendGohigh-concurrency
0 likes · 20 min read

This article presents a comprehensive roadmap for adopting microservice architecture, explaining its benefits, core concepts, and the essential tools such as Docker, container orchestration, API gateways, load balancing, service discovery, event buses, logging, monitoring, distributed tracing, data persistence, caching, and cloud providers.
DockerKubernetesapi-gateway
0 likes · 16 min read

This article explains the concept of elastic auto scaling in cloud services, describes typical scenarios such as high‑elastic web apps and compute‑intensive workloads, details the four‑layer architecture and workflow, and outlines functional features, stability improvements, and future optimization directions.
Auto Scalingcloud-computingelasticity
0 likes · 12 min read

This article explains the principles and configuration of Keepalived, covering its role in providing high‑availability virtual IPs, the VRRP election process, traffic forwarding, load‑balancing algorithms, and practical configuration examples with vrrp_instance and vrrp_script directives.
IPVSOperationsVRRP
0 likes · 16 min read

This article details the design, architecture, implementation, testing, and performance evaluation of a high‑throughput Java gateway built with Spring WebFlux, Netty, and Nacos, covering custom routing, load balancing, canary releases, and data synchronization mechanisms.
JavaSpring WebFluxload-balancing
0 likes · 20 min read

This article explores the architecture and implementation of a high‑concurrency train ticket flash‑sale system, detailing load‑balancing strategies, Nginx weighted round‑robin, Redis‑based inventory management, and Go code examples that demonstrate local and remote stock deduction, performance testing, and fault‑tolerant design.
BackendGohigh-concurrency
0 likes · 20 min read

eBay’s UFES project details the design and migration of its global edge‑node infrastructure from hardware load balancers to a cloud‑native network using Kubernetes, IPVS, Envoy, Contour, and automated PaaS tooling, highlighting challenges, architecture, caching, and future plans.
cloud-nativeedge-computingload-balancing
0 likes · 30 min read

This article provides a comprehensive step‑by‑step guide on configuring Nginx rewrite rules, implementing anti‑hotlink protection, separating static and dynamic resources, and setting up Keepalived for high‑availability load balancing, complete with example configurations and shell scripts.
KeepalivedNGINXanti-hotlinking
0 likes · 21 min read

This guide explains Keepalived’s role in Linux load‑balancing and high‑availability, covering its VRRP‑based architecture, core modules, layered operation, configuration syntax, practical deployment with Nginx, common split‑brain issues, and advanced settings such as nopreempt and multicast conflict resolution.
FailoverHAKeepalived
0 likes · 21 min read

This article explains how to configure Nginx as a reverse proxy to maintain long‑lived HTTP/1.1 keep‑alive connections between client and Nginx and between Nginx and upstream servers, covering required directives, upstream and location settings, performance implications for high QPS workloads, and advanced WebSocket handling.
ConfigurationHTTPNGINX
0 likes · 9 min read

This article walks through the evolution and design patterns of large‑scale web systems, covering initial single‑server setups, separation of application and data, caching strategies, server clustering, read‑write separation, CDN and reverse proxy usage, distributed storage, micro‑service decomposition, and essential considerations for performance, availability, scalability, extensibility and security.
architecturedistributed-systemshigh-availability
0 likes · 19 min read

This article explores the design and implementation of a high‑concurrency train ticket spike system, detailing load‑balancing strategies with Nginx, distributed inventory management using Redis, Go‑based services, and performance testing, while addressing challenges such as overselling, fault tolerance, and efficient resource utilization.
GoNGINXhigh-concurrency
0 likes · 19 min read

This article explains the capabilities of Nginx without third‑party modules, covering reverse proxy, load balancing strategies, static HTTP serving, dynamic/static separation, and forward proxy, and provides concrete configuration examples for each feature.
ConfigurationHTTP serverload-balancing
0 likes · 11 min read

This guide explains Nginx’s core concepts—including forward and reverse proxy, load‑balancing strategies, static‑dynamic separation, installation commands, configuration file anatomy, practical reverse‑proxy and load‑balancing examples, and a Keepalived high‑availability solution—providing step‑by‑step instructions and essential code snippets for reliable backend deployment.
BackendConfigurationHigh Availability
0 likes · 11 min read

This article explains how to build a high‑concurrency ticket‑spike system by analyzing 12306's extreme load, introducing multi‑layer load balancing (OSPF, LVS, Nginx), comparing stock‑deduction strategies, and presenting a Go prototype that uses in‑memory stock, Redis centralized inventory, and weighted Nginx routing to achieve scalable, fault‑tolerant performance.
GoNGINXhigh-concurrency
0 likes · 19 min read

This tutorial walks through preparing two servers, configuring Keepalived and Nginx on both master and backup nodes, restarting services, and testing failover to demonstrate a functional high‑availability architecture using VRRP virtual IPs.
KeepalivedNGINXVRRP
0 likes · 4 min read

This article explores the architecture and implementation of a high‑concurrency ticket‑spike system, covering load‑balancing strategies, Nginx weighted round‑robin configuration, local stock deduction in Go, remote stock control with Redis Lua scripts, and performance testing results.
GoNGINXdistributed
0 likes · 19 min read

This article details Dada's journey of designing and implementing a dual‑cloud active‑active architecture, covering high‑availability vs. disaster‑recovery concepts, Phase 1 and Phase 2 solutions, challenges faced, multi‑data‑center Consul deployment, bidirectional database replication, precise load‑balancing, capacity elasticity, and future plans.
Multi-cloudcloud-nativeconsul
0 likes · 17 min read

This article introduces Spring Cloud as a Spring Boot‑based microservice framework, explains the fundamentals of service architecture through an illustrative story, and details essential components such as service registry, discovery, load balancing, circuit breaking, configuration management, messaging bus, and tracing, accompanied by practical code examples.
Backendcircuit-breakerload-balancing
0 likes · 12 min read

This guide walks through installing Erlang and RabbitMQ, configuring a mirrored RabbitMQ cluster, setting up HAProxy load balancing, and using Keepalived for automatic failover, providing a complete high‑availability solution for RabbitMQ on Linux.
HAProxyKeepalivedLinux
0 likes · 12 min read


ITPUBJun 14, 2020 · Backend Development
During the early COVID‑19 response, a city launched a free‑mask reservation service that faced massive timed traffic, prompting a rapid evolution of its architecture—from a single‑server Nginx/Tomcat setup to a multi‑layer SLB, CDN, read‑write split DB, and finally an ideal CDN‑backed design—while documenting the performance bottlenecks, scaling limits, and concrete tuning steps that enabled a 7‑minute sell‑out.
Backendcloudload-balancing
0 likes · 10 min read

This article examines service discovery patterns, comparing client‑side and server‑side approaches, explores consistency trade‑offs, health‑check mechanisms, subscription models, graceful up/down procedures, and high‑availability designs to help engineers choose the right solution for microservice architectures.
Consistencycloud-nativehealth-check
0 likes · 15 min read

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.
NGINXload-balancingmap
0 likes · 7 min read

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.
BackendNGINXOperations
0 likes · 14 min read

This guide explains how to install Keepalived, configure VRRP‑based high‑availability for Nginx load balancers, modify master and backup configuration files, test failover scenarios, and add a Bash watchdog script to ensure seamless service continuity.
FailoverKeepalivedVRRP
0 likes · 8 min read

This article explains how to evolve a simple single‑node backend by adding a reverse proxy, introducing load balancers, scaling databases, adopting micro‑services, leveraging caches and CDNs, using message queues, and applying partitioning techniques to handle massive traffic while maintaining consistency and reliability.
CachingMessage Queuearchitecture
0 likes · 10 min read

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.
LoggingNGINXSSL
0 likes · 45 min read


21CTONov 26, 2019 · Backend Development
This article explores the design of a high‑concurrency ticket‑spike system that can handle millions of simultaneous requests by combining multi‑layer load balancing, Nginx weighted round‑robin, Redis for atomic stock control, and Go‑based services, complete with code samples and performance testing.
distributed systemhigh-concurrencyload-balancing
0 likes · 20 min read

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.
GoNGINXdistributed-systems
0 likes · 19 min read


21CTOAug 26, 2019 · Backend Development
This comprehensive Nginx tutorial walks beginners through core concepts, installation commands, startup scripts, HTTP/HTTPS reverse‑proxy configurations, various load‑balancing strategies, multi‑webapp routing, static site serving, file server setup, and CORS handling with clear examples and code snippets.
CORSHTTPSNGINX
0 likes · 19 min read

The article explains Kafka’s master‑write master‑read architecture, why it does not implement a master‑write slave‑read model, the trade‑offs of consistency and latency, and how Kafka achieves load balancing through its leader‑replica design and operational safeguards.
BackendKafkaMaster‑Slave
0 likes · 7 min read

This article provides a detailed overview of operations engineering, covering the definition of ops and game ops, interactions with product teams, server management strategies, RAID levels, load‑balancing technologies (LVS, Nginx, HAProxy), caching solutions, middleware, MySQL troubleshooting, backup methods, Keepalived, Linux security, networking layers, and practical shell scripts for monitoring and automation.
Networkingload-balancing
0 likes · 34 min read


ITPUBDec 21, 2018 · Backend Development
This guide explains what Nginx is, how to install it on Linux and Windows, compile from source, use common control commands, and configure HTTP/HTTPS reverse proxy, load balancing, multiple web‑app routing, static site serving, and CORS handling with practical code examples.
CORSConfigurationHTTPS
0 likes · 16 min read

This guide explains the principles behind RabbitMQ clustering, shows how metadata synchronization works, compares design choices, and provides step‑by‑step instructions—including component installation, node configuration, HAProxy load‑balancing setup, and a sample architecture diagram—to create a reliable, scalable RabbitMQ cluster for production use.
HAProxyOperationsclustering
0 likes · 16 min read

The article explains Envoy's outlier detection and ejection process, detailing how unhealthy upstream hosts are identified and temporarily removed based on consecutive 5xx errors, gateway failures, or success‑rate thresholds, and describes the logging format and configuration options for these health‑check mechanisms.
Operationsejectionhealth check
0 likes · 6 min read

This article provides a step‑by‑step analysis of Dubbo’s cluster fault‑tolerance mechanism, explaining the roles of Directory, Router, and LoadBalance, illustrating the execution flow with diagrams, and clarifying how invokers are selected and balanced in a distributed Java RPC framework.
BackendClusterDubbo
0 likes · 8 min read

This guide walks you through installing Nginx on CentOS 7.5, configuring it as a high‑performance reverse proxy, setting up environment variables, managing common commands, and implementing practical scenarios such as request forwarding, Tomcat integration, load balancing, static file handling, and sub‑domain routing.
NGINXload-balancingreverse-proxy
0 likes · 16 min read

This article details Didi’s Passport authentication system architecture, describing how language migration, service decomposition, flexible ticket and SMS code designs, multi‑region active‑active deployment, an independent Argus access‑control layer, and interface splitting together achieve high availability and low latency under extreme traffic peaks.
AuthenticationTicketdistributed-systems
0 likes · 18 min read

This article provides a comprehensive tutorial on using Alibaba's Dubbo framework to configure cluster fault‑tolerance modes, load‑balancing strategies, provider and consumer implementations, deployment steps, and management/monitoring tools, including code examples and custom extension points.
Cluster Fault Toleranceload-balancingmicroservices
0 likes · 18 min read

This article explains common load‑balancing algorithms—including round‑robin, random, least‑connections, source‑IP hash, and weighted methods—describes their advantages and drawbacks, and examines hardware load‑balancing devices such as F5 and A10, covering functional, performance, stability, security, and cost considerations.
Algorithmshardwareload-balancing
0 likes · 5 min read

This article explains practical techniques for designing high‑availability and scalable systems by addressing entry, business, cache, and database layers, offering concrete solutions such as keepalived, stateless services, cache partitioning, and replication strategies to handle rapid user growth without service disruption.
Stateless Servicescache partitioningdatabase-replication
0 likes · 11 min read

This article explains what reverse proxy is, compares it with forward proxy, outlines its security, load‑balancing, caching, and concurrency‑control benefits, and discusses various deployment approaches including one‑to‑one setups, separate servers, and clustered architectures for large‑scale web applications.
Cachingdeploymentload-balancing
0 likes · 13 min read
