Équilibrage de charge HTTP

Introduction

Dans ce laboratoire, vous découvrirez les bases de l’équilibrage de charge avec HAProxy.

Imaginez une banque avec un seul guichetier. La file d’attente s’allonge et les clients s’impatientent. Pour résoudre ce problème, la banque ouvre plusieurs guichets. Il faut alors un responsable à l’entrée pour orienter chaque client vers le prochain guichet disponible.

Dans ce scénario :

Le responsable de la banque représente l’équilibreur de charge (HAProxy).
Les guichetiers représentent les serveurs backend (des serveurs web simulés).
Les clients représentent le trafic web.

Vous allez mettre en place cette architecture sous Linux. Vous créerez deux serveurs web simulés et configurerez HAProxy pour répartir le trafic entre eux avec la méthode round-robin, l’un des algorithmes d’équilibrage les plus simples.

Le round-robin constitue un bon modèle mental de départ : il montre le rôle essentiel d’un équilibreur de charge, qui consiste à répartir les requêtes successives entre plusieurs backends opérationnels au lieu de tout envoyer vers une seule machine.

À la fin de ce laboratoire, vous saurez :

Exécuter de simples serveurs web Python.
Configurer HAProxy pour accepter le trafic (Frontend) et l’envoyer vers les serveurs (Backend).
Observer l’équilibrage de charge en fonctionnement.

Préparer les terminaux

Pour tester un équilibreur de charge, nous devons d’abord disposer de quelque chose à équilibrer ! Nous devons exécuter simultanément deux serveurs web distincts. Comme un serveur en cours d’exécution occupe le terminal — il continue de fonctionner jusqu’à son arrêt — nous ne pouvons pas saisir de nouvelles commandes dans la même fenêtre.

Nous devons donc ouvrir des onglets de terminal supplémentaires. Cela revient à ouvrir plusieurs onglets dans votre navigateur web pour consulter plusieurs sites à la fois.

Sur le plan opérationnel, cette étape sépare les rôles du système. Les serveurs Python simulent votre couche applicative, tandis que le terminal principal reste votre plan de contrôle pour l’équilibreur de charge.

Un terminal est actuellement ouvert (Terminal). Ouvrez-en deux autres :

Repérez l’icône + (plus) dans l’interface du terminal.
Cliquez deux fois dessus pour ouvrir Terminal 1 et Terminal 2.

Nous les utiliserons ainsi :

Terminal : notre centre de contrôle (pour configurer HAProxy).
Terminal 1 : exécutera le serveur 1.
Terminal 2 : exécutera le serveur 2.

Démarrer le serveur 1

Nous allons maintenant démarrer notre premier « guichetier » (serveur 1). Au lieu d’installer un logiciel de serveur web volumineux, nous utiliserons un outil intégré à Python qui transforme n’importe quel dossier en site web.

Passez à Terminal 1.

Commencez par accéder au dossier préparé pour le serveur 1.

cd ~/project/server1

Démarrez ensuite le serveur. Nous lui demanderons d’écouter sur le port 8001. Imaginez qu’un port soit le numéro d’un appartement : l’ordinateur est l’immeuble, et le port 8001 est la porte précise derrière laquelle se trouve le serveur 1.

python3 -m http.server 8001

Vous verrez un message contenant Serving HTTP on 0.0.0.0 port 8001. Cela signifie que le serveur fonctionne et attend des visiteurs. Ce terminal est maintenant « occupé » : n’y saisissez rien d’autre.

Démarrer le serveur 2

Démarrons le deuxième « guichetier » (serveur 2) afin de répartir le travail.

Passez à Terminal 2.

Accédez au dossier du serveur 2.

cd ~/project/server2

Démarrez ce serveur sur un autre port, 8002. Nous ne pouvons pas utiliser le port 8001, car le serveur 1 l’utilise déjà (deux familles ne peuvent pas vivre dans le même appartement 8001).

python3 -m http.server 8002

Vous disposez maintenant de deux serveurs web indépendants en fonctionnement. L’un affiche « Response from Server 1 » (sur le port 8001) et l’autre « Response from Server 2 » (sur le port 8002).

Configurer le Frontend

Maintenant que nos serveurs sont prêts, configurons le « responsable de la banque » (HAProxy) pour leur diriger le trafic.

C’est ici que commence la séparation entre frontend et backend. Un frontend décrit la manière dont les clients arrivent sur HAProxy, tandis qu’un backend décrit le pool de serveurs qui prendra effectivement le travail en charge.

Revenez à Terminal.

Nous allons repartir d’une configuration propre en sauvegardant l’ancienne configuration, puis en créant une nouvelle.

sudo mv /etc/haproxy/haproxy.cfg /etc/haproxy/haproxy.cfg.bak
sudo nano /etc/haproxy/haproxy.cfg

Copiez-collez le texte suivant dans l’éditeur. Il définit le Frontend. Le Frontend est la façade publique de l’équilibreur de charge : c’est à cet endroit que les clients (utilisateurs) arrivent.

global
    log /dev/log    local0
    log /dev/log    local1 notice
    daemon

defaults
    log     global
    mode    http
    option  httplog
    option  dontlognull
    timeout connect 5000
    timeout client  50000
    timeout server  50000

frontend http_front
    bind *:80
    default_backend http_back

Éléments importants à comprendre :

bind *:80 : cette directive demande à HAProxy d’écouter sur le port 80. Le port 80 est la porte standard du trafic web (HTTP). Lorsque vous saisissez le nom d’un site sans préciser de port, votre navigateur utilise le port 80.
default_backend http_back : cette directive indique à HAProxy : « Lorsque des utilisateurs arrivent ici, envoyez-les au groupe appelé http_back. »

Ces noms sont importants, car la configuration de HAProxy constitue essentiellement une carte du trafic. Les frontends reçoivent les connexions et les backends représentent les destinations possibles de ces connexions.

Enregistrez le fichier (Ctrl+O, Entrée). Vous pouvez le laisser ouvert si vous le souhaitez, mais il est préférable de l’enregistrer puis de quitter (Ctrl+X) afin de vérifier votre progression étape par étape.

Configurer le Backend

Nous devons maintenant définir ce groupe de serveurs, le Backend.

Si vous avez fermé le fichier de configuration, ouvrez-le à nouveau :

sudo nano /etc/haproxy/haproxy.cfg

Ajoutez les lignes suivantes à la fin du fichier :

backend http_back
    server server1 127.0.0.1:8001 check
    server server2 127.0.0.1:8002 check

Qu’avons-nous fait ?

backend http_back : nous avons créé le groupe nommé http_back.
server server1 ... : nous avons ajouté notre premier serveur (serveur 1) à l’adresse 127.0.0.1:8001 (port localhost 8001).
server server2 ... : nous avons ajouté notre deuxième serveur (serveur 2) à l’adresse 127.0.0.1:8002.
check : cette option est essentielle. Elle demande au responsable de vérifier régulièrement que le serveur est réellement disponible (en bonne santé). Si un serveur tombe en panne, HAProxy cesse de lui envoyer des utilisateurs.

Enregistrez le fichier (Ctrl+O, Entrée), puis quittez (Ctrl+X).

Vérifier l’équilibrage

Comment le responsable doit-il décider à qui attribuer le prochain client ? La méthode la plus courante est le Round Robin. Il s’agit simplement de faire fonctionner les serveurs « à tour de rôle ».

Client 1 → serveur 1
Client 2 → serveur 2
Client 3 → serveur 1
… et ainsi de suite.

Rendons ce comportement explicite dans notre configuration. Ouvrez une dernière fois le fichier de configuration :

sudo nano /etc/haproxy/haproxy.cfg

Repérez la section backend http_back que vous venez d’ajouter et insérez la directive balance, afin d’obtenir ceci :

backend http_back
    balance roundrobin
    server server1 127.0.0.1:8001 check
    server server2 127.0.0.1:8002 check

Remarque : l’indentation (les espaces au début des lignes) est importante pour la lisibilité, même si HAProxy est tolérant sur ce point. Essayez de conserver une présentation propre.

Enregistrez le fichier (Ctrl+O, Entrée), puis quittez (Ctrl+X).

Recharger HAProxy et tester

La configuration est prête, mais HAProxy n’en a pas encore connaissance. Nous devons recharger le service pour appliquer les modifications.

sudo service haproxy restart

Passons maintenant au moment décisif ! Nous utiliserons une commande appelée curl. Considérez curl comme un navigateur web sans interface graphique : elle récupère une page web et affiche son code texte à l’écran.

Nous allons nous connecter à localhost (notre machine) sur le port par défaut 80, sur lequel HAProxy écoute.

Exécutez plusieurs fois cette commande :

curl localhost

Vous devriez voir « Response from Server 1 ». Exécutez-la une nouvelle fois.

curl localhost

Vous devriez maintenant voir « Response from Server 2 ».

Pour observer rapidement le résultat, vous pouvez exécuter cette boucle, qui interroge le serveur quatre fois consécutives :

for i in {1..4}; do
  curl localhost
  echo
done

La sortie devrait alterner exactement comme suit : 1, 2, 1, 2.

Cela prouve que votre équilibreur de charge fonctionne ! Il reçoit vos requêtes sur le port 80 et répartit équitablement le travail entre les ports 8001 et 8002.

Résumé

Dans ce laboratoire, vous avez réussi à créer un cluster web avec équilibrage de charge !

Voici ce que vous avez accompli :

Backends simulés : vous avez utilisé Python pour créer deux serveurs web opérationnels sur des ports différents (8001 et 8002).
Frontend configuré : vous avez demandé à HAProxy d’écouter sur le port web standard (80).
Backend configuré : vous avez enregistré vos deux serveurs dans le pool de serveurs.
Round Robin : vous avez mis en place une stratégie équitable de répartition du trafic, fondée sur une alternance entre les serveurs.

Il s’agit exactement de la même architecture que celle utilisée par les sites web à très grande échelle pour gérer des millions d’utilisateurs, mais à une échelle plus réduite.