Haute disponibilité : répartiteur, 2 VM, une panne

Nous avons coupé le courant d'une VM, arrêté son service web et redémarré l'autre, sous une requête toutes les 100 ms : aucune requête perdue, une seconde de retard au pire. Ce que change un contrôle de santé à 2 secondes, quand drainer, et ce que donnait notre première mesure.

Une frise de requêtes avec un court trou : une des deux machines tombe, le répartiteur envoie tout à l'autre

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.

bash
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 :

bash
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 :

python
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()
bash
$ 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 :

bash
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

bash
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 start par 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 :

bash
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 :

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 :

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

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.

Deux machines reliées par un lien privé ; seule celle de gauche a une porte vers Internet, la base à droite reste fermée

Réseau privé (VPC) : relier ses VM hors Internet

Une machine app avec une adresse publique, une machine base qui n'en a aucune, PostgreSQL entre les deux par le réseau privé. Nous avons vérifié que la base est injoignable depuis Internet, mesuré 0,1 ms de plus par requête et 20 Gbit/s de débit, et administré la base par rebond SSH.

Lire l'article 8 min de lecture

Un flux entrant partagé par un répartiteur entre trois machines, dont une drainée

Répartiteur de charge : une adresse, plusieurs VM

Un répartiteur prend le trafic sur sa propre adresse et le partage entre vos machines. Pools et contrôles de santé, port HTTPS et certificat automatique, routage par chemin, maintenance sans coupure : un montage complet, à 0,010 CAD l'heure.

Lire l'article 8 min de lecture

Support & discussions

Questions techniques, retours d'incidents ou discussions d'infrastructure, l'équipe est présente sur Discord, Telegram, X, Instagram, Reddit et IRC.