Strategie di bilanciamento del carico
Impari come i load balancer distribuiscono il traffico tra più server per abilitare la scalabilità orizzontale ed esplori i principali algoritmi di routing e i controlli di integrità.
Strategie di bilanciamento del carico è una lezione System Design Basics for Backend Developers gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento System Design Basics for Backend Developers, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso System Design Basics for Backend Developers include 4 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
Why Load Balancing?
Once you scale horizontally, you have many identical servers. But how do clients know which one to hit? A load balancer sits in front of your servers and spreads incoming requests across them.
- Prevents any single server from being overwhelmed
- Enables seamless scaling up and down
- Improves availability if one server fails
Where the Balancer Sits
A load balancer is a reverse proxy: clients connect to one address, and the balancer forwards the request to a healthy backend. The client never sees the internal topology.
This indirection is what makes adding or removing servers invisible to users.
Client --> [Load Balancer] --> Server A
--> Server B
--> Server CRound Robin
Round robin is the simplest algorithm: requests are handed to servers in rotation. Server A, then B, then C, then back to A.
It works well when all servers are equally powerful and requests cost roughly the same.
requests = ['r1','r2','r3','r4']
servers = ['A','B','C']
for i, r in enumerate(requests):
print(r, '->', servers[i % len(servers)])Least Connections
Least connections routes each new request to the server with the fewest active connections. This is smarter when request durations vary widely.
A server stuck on slow requests will not keep receiving new ones.
Weighted Algorithms
If servers have different capacity, assign weights. A server with weight 3 receives roughly three times as many requests as a server with weight 1.
- Weighted round robin
- Weighted least connections
IP Hash & Sticky Sessions
IP hash routes a given client consistently to the same server based on a hash of its IP. This creates sticky sessions, useful when a server holds in-memory session state.
Note: stickiness undermines stateless design. Prefer external session stores when possible.
def pick(ip, n):
return hash(ip) % n
print('192.168.0.5 ->', pick('192.168.0.5', 3))Health Checks
A load balancer periodically pings each backend with a health check (e.g. GET /health). Unhealthy servers are removed from rotation automatically.
This is how the system survives a server crash without manual intervention.
Layer 4 vs Layer 7
Layer 4 balancing operates on TCP/UDP, routing by IP and port — fast but blind to content. Layer 7 operates on HTTP, so it can route by URL path, headers, or cookies.
- L4: high throughput, simple
- L7: content-aware, supports path-based routing
DNS Load Balancing
At the largest scale, a single load balancer becomes a bottleneck. DNS-based balancing returns different server IPs to different clients, spreading load before traffic even reaches a balancer.
Often combined with regional balancers for global apps.
Avoiding the Single Point of Failure
The load balancer itself must not be a single point of failure. Run it in an active-passive or active-active pair, with a floating virtual IP that fails over if the primary dies.
Putting It Together
A typical scalable setup: DNS spreads clients across regions, regional L7 balancers do health-checked path routing, and least-connections distributes to a fleet of stateless app servers behind them.
Each layer removes a bottleneck and adds resilience.
Quick Check
Test your understanding of load balancing algorithms.
Recap
You learned how load balancing makes horizontal scaling practical:
- Round robin, least connections, weighted, and IP hash algorithms
- Health checks remove failed servers automatically
- Layer 4 vs Layer 7, plus DNS balancing at scale
- The balancer must itself be redundant
Domande Frequenti
La lezione «Strategie di bilanciamento del carico» è gratuita?
Sì — il testo completo di «Strategie di bilanciamento del carico» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso System Design Basics for Backend Developers, passa a CoddyKit PRO. Il corso System Design Basics for Backend Developers include 4 lezioni in totale.
Cosa imparerò in «Strategie di bilanciamento del carico»?
Impari come i load balancer distribuiscono il traffico tra più server per abilitare la scalabilità orizzontale ed esplori i principali algoritmi di routing e i controlli di integrità. Eserciti System Design Basics for Backend Developers con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare System Design Basics for Backend Developers?
Non è richiesta alcuna esperienza precedente. System Design Basics for Backend Developers su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Strategie di bilanciamento del carico»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione System Design Basics for Backend Developers?
Sì. Ogni lezione System Design Basics for Backend Developers include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Scalabilità verticale e orizzontale
- Service stateless e stateful
- Introduzione ai sistemi distribuiti
- Strategie di bilanciamento del carico