0Pricing
System Design Basics for Backend Developers · Leçon

Stratégies d’équilibrage de charge

Apprenez comment les équilibreurs de charge répartissent le trafic entre plusieurs serveurs pour permettre la mise à l’échelle horizontale, puis découvrez les algorithmes de routage et les contrôles de santé courants.

Stratégies d’équilibrage de charge est une leçon System Design Basics for Backend Developers gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage System Design Basics for Backend Developers, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours System Design Basics for Backend Developers comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

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 C

Round 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

Questions Fréquemment Posées

La leçon « Stratégies d’équilibrage de charge » est-elle gratuite ?

Oui — le texte complet de « Stratégies d’équilibrage de charge » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours System Design Basics for Backend Developers, passe à CoddyKit PRO. Le cours System Design Basics for Backend Developers comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Stratégies d’équilibrage de charge » ?

Apprenez comment les équilibreurs de charge répartissent le trafic entre plusieurs serveurs pour permettre la mise à l’échelle horizontale, puis découvrez les algorithmes de routage et les contrôles… Tu pratiques System Design Basics for Backend Developers avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer System Design Basics for Backend Developers ?

Aucune expérience préalable n'est requise. System Design Basics for Backend Developers sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Stratégies d’équilibrage de charge » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon System Design Basics for Backend Developers ?

Oui. Chaque leçon System Design Basics for Backend Developers inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Mise à l’échelle verticale ou horizontale
  2. Services sans état ou avec état
  3. Introduction aux systèmes distribués
  4. Stratégies d’équilibrage de charge
← Retour à System Design Basics for Backend Developers