Deux machines derrière un répartiteur, c'est la recette habituelle pour qu'un site survive à la perte d'un serveur. Reste à savoir ce que vos visiteurs voient pendant la panne : combien de requêtes échouent, combien sont retardées, et combien de temps il faut pour que la machine réparée reprenne sa part du trafic.
Nous avons monté ce montage sur notre propre compte, envoyé une requête toutes les 100 ms pendant de vraies pannes, et tout noté. Les chiffres plus bas viennent de ces journaux. Notre première série de mesures a révélé un défaut de notre répartiteur ; nous l'avons corrigé, puis tout refait sur un répartiteur neuf. La section 8 raconte cet avant-après. La mise en place d'un répartiteur est détaillée dans l'article Répartiteur de charge : une adresse, plusieurs VM ; ici, on le casse.
1. Le montage
Un réseau privé, deux Nano à l'heure en IPv6 seulement (1 vCPU, 2 Go), et un répartiteur dans le même réseau. Les deux machines n'ont pas d'IPv4 : le répartiteur les joint par leur adresse privée, et c'est lui qui porte l'adresse publique.
curl -s -X POST https://api.ffxf.net/v1/vms \
-H "Authorization: Bearer $FFXF_TOKEN" -H "Idempotency-Key: $(uuidgen)" \
-H "Content-Type: application/json" \
-d '{"plan": "nano", "region": "montreal", "image": "debian-13",
"hostname": "web-a", "billing": "hourly", "ipv4": false,
"vpc": 44, "ssh_keys": ["34"], "password_delivery": "none"}'
curl -s -X POST https://api.ffxf.net/v1/load-balancers \
-H "Authorization: Bearer $FFXF_TOKEN" -H "Idempotency-Key: $(uuidgen)" \
-H "Content-Type: application/json" \
-d '{"name": "ha-demo", "vpc": 44}'
La seconde machine se commande de la même façon avec web-b. Lors de
notre dernier essai, les deux Nano tournaient moins de 40 secondes après la
commande, et le répartiteur est passé de pending à
active en un peu moins de trois minutes.
Viennent ensuite un pool HTTP dont le contrôle de santé interroge
/health, les deux cibles sur le port 8080, et un port d'entrée HTTP
sur le 80 :
curl -s -X POST https://api.ffxf.net/v1/load-balancers/10/pools \
-H "Authorization: Bearer $FFXF_TOKEN" -H "Content-Type: application/json" \
-d '{"name": "web", "protocol": "http", "health_type": "http", "health_path": "/health"}'
curl -s -X PUT https://api.ffxf.net/v1/load-balancers/10/pools/14/targets \
-H "Authorization: Bearer $FFXF_TOKEN" -H "Content-Type: application/json" \
-d '{"targets": [{"vm": 322, "port": 8080}, {"vm": 326, "port": 8080}]}'
curl -s -X POST https://api.ffxf.net/v1/load-balancers/10/listeners \
-H "Authorization: Bearer $FFXF_TOKEN" -H "Content-Type: application/json" \
-d '{"port": 80, "protocol": "http", "default_pool": 14}'
Un piège en passant : une cible doit déjà figurer dans le réseau privé du
répartiteur. Tant qu'une machine est en cours de création, l'API refuse la liste
avec This machine is not in the load balancer's private network. Il
suffit de rejouer le même PUT une fois la machine démarrée.
2. Une application qui dit qui répond
Sur chaque machine, un petit serveur Python répond servi par suivi du
nom de la machine, et ok sur /health. Il tourne comme
service systemd, activé au démarrage :
import socket
from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler
NOM = socket.gethostname()
class H(BaseHTTPRequestHandler):
def do_GET(self):
corps = b"ok\n" if self.path == "/health" else f"servi par {NOM}\n".encode()
self.send_response(200)
self.send_header("Content-Type", "text/plain")
self.send_header("Content-Length", str(len(corps)))
self.end_headers()
self.wfile.write(corps)
ThreadingHTTPServer(("0.0.0.0", 8080), H).serve_forever()
$ for i in 1 2 3 4; do curl -s http://203.0.113.83/; done
servi par blog-08b-a
servi par blog-08b-b
servi par blog-08b-a
servi par blog-08b-b
Ce /health ne vérifie que le processus. Dans une vraie application, il
doit tester ce dont la page a besoin (la base, le disque), sans quoi le répartiteur
continuera d'envoyer du trafic à une machine qui répond, mais mal.
3. La sonde : une requête toutes les 100 ms
Le client de test part d'une machine de notre réseau à Montréal. Il lance une
requête toutes les 100 ms, chacune dans son propre fil pour qu'une requête bloquée
ne retarde pas les suivantes, et note l'heure de départ, la durée et la réponse. Il
attend jusqu'à 60 secondes avant d'abandonner. En temps normal, une requête prend
de 3 à 9 ms et les réponses alternent exactement entre les deux machines.
Pendant ce temps, un second script interroge
GET /load-balancers/10 toutes les 3 secondes pour noter l'état de
santé que voit le répartiteur.
4. Panne 1 : la VM perd le courant
L'action stop coupe l'alimentation de la machine, comme un
débranchement :
curl -s -X POST https://api.ffxf.net/v1/vms/326/actions \
-H "Authorization: Bearer $FFXF_TOKEN" -H "Content-Type: application/json" \
-d '{"type": "stop"}'
Résultat, contrôle de santé par défaut (toutes les 5 secondes) : aucune requête en échec. Les 7 requêtes parties dans les 1,2 secondes qui ont suivi la coupure ont été servies par l'autre machine avec un retard d'une seconde (1 004 à 1 005 ms au lieu de 5). Toutes les suivantes sont allées directement à la machine saine, en quelques millisecondes.
Ce qui se passe : une machine éteinte ne refuse pas la connexion, elle ne répond
plus. Le répartiteur abandonne la tentative au bout d'une seconde et renvoie la
requête vers l'autre cible. Après quelques échecs de connexion de suite, il retire
la machine du pool sans attendre le contrôle de santé. L'API, elle, a affiché la
cible down environ 9 secondes après la coupure, alors que plus aucune
requête ne lui était envoyée depuis longtemps.
5. Panne 2 : le service tombe, la VM reste
sudo systemctl stop webapp
La machine reste allumée, mais plus rien n'écoute sur le port 8080 : la connexion est refusée tout de suite. Aucune requête en échec, une seule retardée d'une seconde puis servie par l'autre machine.
6. Redémarrage et réintégration
Une machine qui revient doit réussir deux contrôles de suite avant de recevoir du trafic. Mesuré entre l'ordre et sa première réponse servie, avec le contrôle à 5 secondes :
- après le
startpar l'API d'une machine éteinte : 24,6 secondes, démarrage de Debian compris ; - après
systemctl start webapp: 4,9 secondes ; - aucune requête en échec pendant la réintégration : la machine n'est remise dans le pool qu'une fois prête.
Le redémarrage rapide (reboot par l'API) sans précaution était le cas
le plus pénible lors de notre première mesure. Cette fois, la machine a disparu
pendant 23 secondes, et une seule requête a été retardée d'une seconde. Aucun
échec.
7. Des contrôles toutes les 2 secondes
L'intervalle des contrôles se règle par pool, de 2 à 60 secondes :
curl -s -X PATCH https://api.ffxf.net/v1/load-balancers/10/pools/14 \
-H "Authorization: Bearer $FFXF_TOKEN" -H "Content-Type: application/json" \
-d '{"health_interval": 2}'
Mêmes pannes, mêmes machines :
| Situation | Contrôle toutes les 5 s | Contrôle toutes les 2 s |
|---|---|---|
VM éteinte (stop) | 0 échec, 7 requêtes à ~1 s | 0 échec, 8 requêtes à ~1 s |
| Service web arrêté | 0 échec, 1 requête à ~1 s | 0 échec, 1 requête à ~1 s |
reboot sans drainage | 0 échec, 1 requête à ~1 s | 0 échec, 1 requête à ~1 s |
reboot après drainage | 0 échec, max 11 ms | 0 échec, max 8 ms |
Retour après start | 24,6 s | 16,8 s |
| Retour du service | 4,9 s | 1,8 s |
| Retour après la fin du drainage | 3,9 s | 1,7 s |
Sur la perte d'une machine, l'intervalle ne change plus rien : le trafic quitte la
cible dès la première connexion ratée, bien avant le contrôle suivant. Il ne joue
plus que sur le retour, plus rapide de quelques secondes. Le prix : deux fois et
demie plus de requêtes /health par cible, ce qui ne pèse rien pour un
contrôle léger, mais peut compter si /health interroge une base de
données. Le défaut de 5 secondes convient donc à la plupart des sites. Sur l'heure
des deux séries, les statistiques du répartiteur comptent 7 136 requêtes, toutes
en 2xx, aucune 5xx.
8. Notre première mesure, le 3 novembre
La même série d'essais, sur un répartiteur créé le matin du 3 novembre, donnait tout autre chose :
| Situation (contrôle à 5 s) | Première mesure | Aujourd'hui |
|---|---|---|
| VM éteinte | 139 et 145 échecs sur 27,6 et 28,8 s, chaque 503 au bout de 20 s | 0 échec |
| Service web arrêté | 69 échecs sur 13,6 s, chaque 503 au bout de 3 s | 0 échec |
reboot sans drainage | 54 échecs et 37 requêtes retardées de 1 à 9 s | 0 échec |
| VM éteinte, contrôle à 2 s | 56 échecs sur 11,0 s | 0 échec |
La cause était dans la configuration que notre répartiteur génère. Une requête envoyée à une machine morte y restait : 5 secondes d'attente de connexion, trois nouvelles tentatives sur la même cible, puis une 503. Tant que le contrôle de santé n'avait pas retiré la machine, sa moitié du trafic échouait, lentement. Nous avons changé trois choses : l'attente de connexion passe à 1 seconde, une requête dont la connexion échoue est renvoyée vers une autre cible, et trois échecs de connexion de suite suffisent à sortir une cible du pool, sans attendre le contrôle. Les chiffres des sections 4 à 7 viennent d'un répartiteur neuf, créé après ce changement.
9. La maintenance prévue : drainer quand même
Le reboot drainé ({"drain": true} sur la cible, attente,
redémarrage, {"drain": false}) n'a eu ni échec ni retard : la requête
la plus lente a pris 11 ms. Sans drainage, le seul coût mesuré est une requête
retardée d'une seconde. L'écart paraît mince, mais notre sonde ne fait que des
requêtes de quelques millisecondes. Une requête déjà en cours de traitement sur la
machine qui redémarre (un envoi de fichier, un rapport long) n'est pas renvoyée
ailleurs : seules les connexions qui échouent le sont. Le drainage laisse ces
requêtes se terminer.
Un détail : la machine drainée a encore reçu du trafic pendant 7 et 9 secondes
après l'ordre, soit plusieurs secondes après que l'API eut indiqué
config_applied. Attendez une dizaine de secondes avant de
redémarrer.
10. Ce que coûte le montage
| Élément | À l'heure | Sur un mois complet | Au mois |
|---|---|---|---|
| 2 Nano IPv6 seulement | 2 × 0,014 CAD | 20,44 CAD | 2 × 6,50 CAD = 13 CAD |
| Répartiteur | 0,010 CAD | 7,30 CAD | 7,30 CAD |
| Total | 0,038 CAD | 27,74 CAD | 20,30 CAD |
Le réseau privé est gratuit. Le trafic qui passe par le répartiteur est compté sur les machines cibles, dans leur 1 To mensuel inclus. Une Nano seule, au mois, coûte 6,50 CAD : la redondance ajoute donc 13,80 CAD par mois. Une machine éteinte mais conservée continue de coûter 0,003 CAD l'heure. Chaque série d'essais, de la création à la destruction, a coûté moins de 0,06 CAD.
11. Ce qu'il faut retenir
- Avec deux machines derrière notre répartiteur, la perte de l'une d'elles n'a fait échouer aucune requête : au pire, une seconde de retard pour celles qui tombaient sur la machine perdue.
- Le retrait se fait à la première connexion ratée, pas au contrôle de santé. L'intervalle de 5 secondes par défaut suffit ; 2 secondes accélère seulement le retour d'une machine.
- Pour une maintenance, drainez d'abord et attendez une dizaine de secondes : zéro retard mesuré, et les requêtes longues ont le temps de finir.
- Une requête déjà en cours sur une machine qui tombe reste perdue. Côté client, une nouvelle tentative sur les requêtes sans effet de bord couvre ce cas.
- Le répartiteur répartit les requêtes, pas les données. Sessions, fichiers envoyés et base doivent vivre ailleurs que sur une seule des deux machines.
Le détail des appels est dans la documentation des répartiteurs, et le réseau entre les machines dans celle des réseaux privés.