Lab de test multi-nœud ====================== Ce qui fait l'intérêt de two ne se voit qu'à partir de **deux hyperviseurs** : sur un nœud isolé, le trafic reste sur le bridge local et l'absence de plan de contrôle passe inaperçue (voir :doc:`/deploiement/architecture-cluster`). Le lab reproduit la topologie du cluster — hyperviseurs, route reflector, switch L3 — sous forme de VM, sur un serveur physique loué à l'heure. Le pourquoi des choix (serveur physique plutôt que VM cloud, câbles QEMU, MTU 9000, versions) est consigné sur le ticket `#50 `_. Cette page décrit comment s'en servir. .. note:: État actuel : le lab de #50 est livré et l'outil en est sorti (#55) : c'est `labctl `_, un dépôt à part, dont two épingle une release. Ce dépôt garde ce qui est propre à two — ses topologies, l'installation de two sur les hyperviseurs, les scénarios et leurs résultats. La redondance du plan de contrôle — deux route reflectors, deux switchs — est l'objet de `#54 `_. L'outil ------- ``labctl`` monte un lab de VM QEMU à partir d'une topologie YAML et s'exécute sur un hôte Linux avec KVM ; son ``lab-host.sh`` loue cet hôte à l'heure chez Scaleway (Elastic Metal), le prépare, y dépose ``labctl`` et la topologie, puis le supprime. Prérequis Scaleway, fichiers locaux (``~/.config/labctl/``), commandes, format de topologie, rendu des VM, garanties de facturation et diagnostic : voir le `guide de labctl `_. two n'en garde aucune copie. ``test/e2e/labctl.sh`` épingle une release : * au premier appel, il télécharge ``labctl_linux_amd64`` et ``lab-host.sh`` dans ``~/.cache/labctl/release//`` et les vérifie contre des sommes SHA-256 **écrites dans le script** — une release modifiée après coup est refusée ; un fichier altéré dans le cache est retéléchargé ; * il lance ensuite ``lab-host.sh`` avec ses arguments et ``LABCTL_BIN`` pointé sur le binaire : ``push`` dépose ce binaire au lieu de compiler. Changer de version : ``LABCTL_VERSION`` et les deux lignes de ``LABCTL_SUMS`` dans ``test/e2e/labctl.sh``, relevées dans le ``SHA256SUMS`` de la release **et** recalculées sur les fichiers téléchargés. Une campagne, depuis le Mac : .. code-block:: text test/e2e/labctl.sh plan # gratuit : offre, zone, prix test/e2e/labctl.sh up # crée le serveur, facturé à l'heure test/e2e/labctl.sh push test/e2e/topologies/evpn-3hv.yml test/e2e/labctl.sh ssh './labctl up -timeout 25m topology/evpn-3hv.yml' test/e2e/run.sh all test/e2e/labctl.sh ssh './labctl ssh hv1' # shell interactif sur hv1 test/e2e/labctl.sh down # supprime le serveur .. warning:: Un serveur Elastic Metal est facturé **de sa création à sa suppression**, chaque heure entamée comme une heure pleine. En cas de doute (session interrompue, poste mis en veille) : ``test/e2e/labctl.sh status`` puis ``down``. **Ne jamais lancer** ``lab-host.sh`` **sous** ``bash -x`` : la trace afficherait la clé d'API. Topologies ---------- Les topologies de two vivent dans ``test/e2e/topologies/`` : ``evpn-2hv.yml`` (deux hyperviseurs) et ``evpn-3hv.yml`` (trois, pour ``s8`` et ``s9``). Le format est celui de ``labctl`` : .. literalinclude:: ../../test/e2e/topologies/evpn-2hv.yml :language: yaml Les ASN, la loopback du route reflector, le lien ``169.254.0.0/28`` et le subnet des hyperviseurs de l'exemple sont **ceux de la production** (décision du 2026-10-04, #50) : les fichiers de ``test/e2e/topologies/`` restent ainsi au plus près de ce qui tourne réellement. Toutes les adresses y sont **fixées** par ``addresses`` — les switchs en ``.2`` et ``.3``, les route reflectors en ``.4`` et ``.5``, les hyperviseurs à partir de ``.11`` — pour que le modèle se lise sans le plan et ne dépende pas de l'ordre de déclaration : le ``frr.conf`` d'un hyperviseur, écrit à la main, porte son adresse en ``router-id``. Les deux switchs ``sw1`` et ``sw2`` sont les routeurs du segment (rôle ``router`` de labctl) : la passerelle, la première adresse du segment, est portée en VRRP v3 par celui qui est maître, sans préemption — voir la section du guide de labctl sur les routeurs. Leurs ``frr.conf`` ne diffèrent que par ``hostname`` et ``router-id`` ; labctl y ajoute la strophe VRRP. Rôles ~~~~~ Les configurations FRR du lab vivent dans ``test/e2e/topologies/frr/``, une par nœud, **écrites à la main** : ce sont les mêmes fichiers que la documentation de déploiement inclut, pour que le lab qualifie exactement ce qu'elle prescrit. Celles des hyperviseurs se réduisent à ``hostname`` et ``log`` : la configuration BGP est posée par l'agent (section ``bgp`` de ``agent.yml``). Celle du route reflector : .. literalinclude:: ../../test/e2e/topologies/frr/rr1.conf :language: text FRR est installé par ``labctl`` au premier démarrage (``frr-stable`` de ``deb.frrouting.org``, clé du dépôt embarquée dans l'outil) : voir la section FRR du guide de ``labctl``. **Hyperviseurs.** Ce sont des nœuds ``host`` dont la provision installe two comme en production. ``test/e2e/topologies/provision/hypervisor.sh`` dépose ``agent.yml`` (fichier ``agent.yml`` du nœud) dans ``/etc/two/agent.yml``, télécharge ``deploy.sh`` et ``bootstrap_kvm.sh`` **au tag de la release testée** dans ``/opt/two/scripts/``, où ``deploy.sh`` cherche d'abord ``bootstrap_kvm.sh``, puis lance : .. code-block:: text deploy.sh --noup_script -i -u "$LAB_UPLINK" -t La release est fixée dans le script (``RELEASE=``) : sans elle, ``deploy.sh`` prendrait la dernière, et le lab ne serait plus reproductible. ``--noup_script`` empêche l'auto-mise à jour de remplacer le script par celui de ``main``. L'uplink ``-u`` est l'interface qui porte la route par défaut, parce que ``deploy.sh`` y lit l'adresse et la passerelle qu'il déplace sur ``br-000000``. ``deploy.sh`` télécharge la release sur ``git.g3e.fr`` sans réessayer : le script attend d'abord que le serveur réponde, à travers le switch. Les deux fichiers ``agent/`` donnent à l'agent la section ``bgp`` (AS 64600, route reflectors ``10.255.255.1`` et ``10.255.255.2``) et un watchdog toutes les 10 s ; ``agent/two.yml`` met en plus hv1 sur le serveur DHCP intégré (``dhcp.backend: two``), ``agent/dnsmasq.yml`` met explicitement les autres sur dnsmasq (``dhcp.backend: dnsmasq``). **Segment ``lan`` (mode ``bridge``).** hv1 et hv2 sont aussi reliés à un second segment, ``lan`` (``10.33.0.0/24``, MTU 1500, **sans routeur** : L2 pur, sans passerelle ni NAT), déclaré après ``underlay`` pour ne changer ni ses adresses ni ses taps. Avant ``deploy.sh``, ``hypervisor.sh`` crée le bridge ``br-lan`` (STP coupé, MTU de l'interface), y rattache l'interface ``lan`` et y déplace l'adresse que labctl lui a donnée (``10.33.0.11`` sur hv1, ``10.33.0.12`` sur hv2). Les deux fichiers ``agent/`` déclarent ``interfaces: {lan: br-lan}`` : un subnet créé avec ``mode: bridge`` et ``iface_type: lan`` rattache son veth à ``br-lan``. Les subnets ``vxlan`` (``iface_type: vms``, clé absente) restent sur ``default_interface`` : le VTEP ne change pas. Le bridge n'est créé qu'au premier démarrage, comme le reste du provisionnement. **Tester l'arbre courant plutôt que la release.** ``test/e2e/build.sh`` compile ``agent``, ``dhcp`` et ``metadata`` pour linux/amd64 dans ``test/e2e/topologies/bin/`` (ignoré par git), que les hyperviseurs reçoivent par ``files: {bin: bin}``. Après ``deploy.sh``, ``hypervisor.sh`` installe chaque binaire présent dans ``/opt/two/local/bin/`` et y fait pointer ``/opt/two/bin/`` ; le reste (units, scripts) vient de la release. ``build.sh --clean`` vide le répertoire : le lab suivant teste la release seule. .. code-block:: text test/e2e/build.sh # binaires de l'arbre courant test/e2e/labctl.sh push test/e2e/topologies/evpn-3hv.yml test/e2e/labctl.sh ssh './labctl up topology/evpn-3hv.yml' test/e2e/build.sh --clean # retour à la release seule FRR est installé **après** la provision : il démarre sur le réseau final. Démarré avant la migration, zebra peut perdre la route par défaut quand elle passe de l'uplink à ``br-000000`` — constaté le 2026-10-11 sur un hyperviseur sur deux : route reflector ``unresolved``, session BGP jamais établie. L'agent, configuré avec une section ``bgp``, refuse de démarrer tant que FRR n'est pas là : son premier démarrage par ``deploy.sh`` échoue, et ``provision/hypervisor-post.sh`` (``post_provision``) le **redémarre** une fois FRR installé. .. warning:: **Un hyperviseur du lab ne survit pas à un redémarrage.** En production, la racine est en tmpfs et ``deploy.sh --bootstrap`` est rejoué à chaque démarrage ; dans le lab, ``-i`` n'est exécuté qu'au premier, et la migration réseau, qui n'est pas persistée, est perdue. Recréer le lab : ``labctl down`` puis ``labctl up``. Vérifié le 2026-10-04 sur le serveur de lab, topologie ``evpn-2hv``, release ``0.2.0rc002`` : .. code-block:: text $ test/e2e/labctl.sh ssh './labctl up -timeout 25m topology/evpn-2hv.yml' sw1: started rr1: started hv1: started hv2: started sw1: ready rr1: ready hv1: ready hv2: ready .. list-table:: :header-rows: 1 :widths: 55 45 * - Vérification - Résultat * - ``labctl up`` complet : FRR, ``deploy.sh`` et vérification des services de chaque rôle - 6 min 15 * - session switch ↔ route reflector, IPv4 unicast, BFD - Established, BFD up ; le switch reçoit la seule loopback du route reflector * - sessions EVPN des deux hyperviseurs vers la loopback du route reflector - Established, voisins dynamiques, stables * - réseau d'un hyperviseur après ``deploy.sh`` - adresse sur ``br-000000``, MTU 9000, API de l'agent qui répond * - VPC, subnet ``vxlan`` et VM Debian ``genericcloud`` créés par l'API de hv1 - ``login:`` en 20 s, en KVM imbriqué * - DHCP et routes (option 121) servis par two à la VM - conformes, route ``/32`` vers ``169.254.169.254`` comprise * - métadonnées, image configurée selon :doc:`/deploiement/image-qcow2` - ``DataSourceNoCloudNet``, nom d'hôte appliqué — avec la barre oblique finale de ``seedfrom`` (voir cette page) * - VM ↔ VM entre les deux hyperviseurs, même subnet ``vxlan`` - **échec** : les VXLAN de two n'ont pas d'adresse VTEP locale, rien n'est annoncé en EVPN — `#51 `_ ; avec l'adresse posée, ping et MTU 1500 passent .. note:: **Les switchs du lab sont des routeurs Linux avec FRR, par choix.** Ils jouent le rôle générique de routeur de cluster : passerelle des hyperviseurs, sessions eBGP avec BFD vers les route reflectors, dont ils n'acceptent que les loopbacks (``test/e2e/topologies/frr/sw1.conf``). L'équipement réel dépend de qui déploie l'infrastructure (MikroTik aujourd'hui ; Cisco, Juniper, Arista… demain) : il n'a besoin que de BGP et d'EVPN, et sa configuration propre au constructeur n'a pas sa place dans le lab. Scénarios --------- Les scénarios se lancent **depuis le Mac**, sur un lab démarré (``up``, ``push``, ``./labctl up``) : .. code-block:: text test/e2e/run.sh s1 # un scénario test/e2e/run.sh s1 s3 # plusieurs test/e2e/run.sh all # tous, dans l'ordre Chacun affiche une ligne ``RÉUSSI`` ou ``ÉCHOUÉ`` par vérification — un échec porte la dernière ligne de la commande en cause —, des lignes ``INFO`` pour les mesures, puis son bilan. Le code de sortie vaut 1 si une vérification échoue **ou si aucune n'a été faite**. .. list-table:: :header-rows: 1 :widths: 22 58 20 * - Scénario - Ce qui doit être vrai - Hyperviseurs * - ``s1-dhcp-two`` - backend DHCP ``two``, une VPC et deux subnets : chaque VM reçoit l'adresse de **son** subnet, démarrée seule ou en même temps qu'une autre ; le bail est tenu par systemd-networkd ; route par défaut, route vers la VPC et ``/32`` vers les métadonnées via la gateway calculée (``.254``) ; l'état de chaque serveur DHCP ne connaît que les MAC de son subnet (#46) - hv1 * - ``s2-gateway`` - gateway (``.254``) et adresse d'émission (``.253``) calculées par l'agent, refusées pour une VM ; ``interface_ip`` refusé sur un subnet ``vxlan`` (#57) ; route par défaut via la gateway, ou via ``gateway`` avec ``default_route`` ; route vers la VPC toujours via la gateway du subnet ; macvlan retiré à la suppression, même résultat après recréation (#31) - hv1 * - ``s3-isolation-local`` - deux VPC sur le même hyperviseur ne se joignent pas, en ICMP comme en TCP ; chaque VM joint sa passerelle (témoin) - hv1 * - ``s4-evpn`` - adresse VTEP locale sur les VXLAN (#51), VTEP distant appris par EVPN, ping VM ↔ VM entre hyperviseurs, trame de 1472 octets en ``-M do``, 1473 refusés - hv1, hv2 * - ``s5-isolation-evpn`` - deux VPC de même plage, VNI différentes, sur deux hyperviseurs : la VM joint celle de sa VPC sur l'autre hyperviseur (témoin) et pas celle de l'autre VPC — aucune résolution ARP - hv1, hv2 * - ``s6-rr-loss`` - FRR arrêté sur rr1, puis sur rr2, ping continu entre les VM de ``s4`` : la session vers le route reflector arrêté tombe, celle vers l'autre reste établie, le VTEP distant reste connu et **le trafic continue** (au moins 45 réponses sur 50 à 30 s) ; session rétablie au redémarrage, délai mesuré ; au plus 1 % de pertes sur tout le scénario (#54) - hv1, hv2, rr1, rr2 * - ``s7-l3vni`` - qualification de `#41 `_ **par l'API** : VPC créées avec une ``l3vni``, l'agent pose VRF, L3VNI, transit, FRR et les routes de type 5 (``/24`` des subnets, ``/32`` des VM). Deux subnets d'une même VPC, chacun sur un seul hyperviseur, se joignent par le L3VNI à travers le route reflector inchangé ; 1472 octets en ``-M do`` ; une seconde VPC de même plage sur un autre L3VNI n'est ni importée ni jointe ; L3VNI déjà prise refusée ; forwarding de l'hôte limité aux interfaces de la VRF ; suppression d'un subnet refusée tant qu'une VM l'utilise ; démontage complet d'une VPC sans redémarrage de bgpd - hv1, hv2, rr1 * - ``s8-l3vni-migration`` - suite de ``s7``, topologie ``evpn-3hv.yml`` : migration d'une VM de hv1 vers hv2 par l'API, observée depuis hv3 qui n'a pas le subnet : migration simple (VM supprimée puis recréée, ``/24`` comme filet), séquence orchestrée (deux VM de même IP, deux ``/32`` en ECMP, 40 sources sur 40) ; l'ancien « pire cas » devient un refus (409) ; MAC anycast de la gateway absente d'EVPN (aucune route de type 2 sur rr1, absente de la table de hv1), sans doublon (#57) ; watchdog : ``/32`` orphelin signalé comme trou noir, ``/32`` manquant signalé - hv1, hv2, hv3, rr1 * - ``s9-subnets-partages`` - deux VPC, avec et sans ``l3vni``, chacune avec deux subnets présents sur **les deux** hyperviseurs et une VM par subnet et par hôte : ping entre toutes les paires (même subnet ou non, même hôte ou non) ; chaque VM voit la MAC anycast de sa gateway ; aucune MAC en double et aucune MAC anycast dans EVPN sur les quatre VNI (#57) - hv2, hv3, rr1 * - ``s10-switch-loss`` - un seul switch maître VRRP de la passerelle (lu par ``show vrrp``, pas supposé) ; interface ``underlay`` du maître coupée pendant un ping continu de hv1 vers la loopback de rr1 : l'autre switch devient maître, les sessions EVPN de hv1 **ne tombent pas** (compteur ``dropped`` inchangé), le trafic reprend (au moins 45 réponses sur 50 à 20 s), plus long silence sous 5 s ; interface rétablie : ses sessions eBGP reviennent et il **reste en attente**, sans reprendre la passerelle (#54) - hv1, sw1, sw2 * - ``s11-fenetre-arp`` - fenêtre ARP de #57 : sur hv1, entrées ARP du netns retirées, puis une VM de hv1 joint une VM de hv2 dans l'autre subnet (relais L2 depuis l'adresse d'émission de hv1). La VM de hv2 associe alors ``.253`` à la MAC de hv1 (fenêtre ouverte, vérifiée), mais sa gateway reste la MAC anycast ; pendant la fenêtre, métadonnées servies, bail DHCP renouvelé auprès de ``.254``, et **aucune** des 80 connexions TCP du netns de hv2 vers sa VM n'est perdue ; MAC anycast inscrite dans la FDB du bridge du netns - hv1, hv2 ``s6`` réutilise les VM de ``s4`` : le lancer après. **Comment c'est fait.** ``test/e2e/run.sh`` exécute chaque scénario sur le Mac ; un scénario envoie des blocs de shell aux nœuds par ``on [VAR=valeur…] <<'NODE'``, précédés de ``test/e2e/lib/node.sh`` — appels à l'API de l'agent, attente des états, image Debian compatible two (préparée une fois par hyperviseur, ``seedfrom`` avec barre oblique finale), clé SSH des VM, ``check`` et ``vm_fails`` ; pour #41, ``vpc_create`` avec une ``l3vni``, ``api_code`` (code HTTP d'un refus attendu), l'observation des VRF et de BGP (``vrf_nexthops``, ``bgp_paths``, ``wait_l3vni``…) et ``wait_watchdog`` (alerte du watchdog dans le journal de l'agent). Une vérification négative (« ne joint pas ») passe par ``vm_fails`` : elle n'est réussie que si le SSH vers la VM a fonctionné **et** que la commande y a échoué — un SSH en panne ne passe jamais pour une isolation. Résultats du 2026-10-04 sur le serveur de lab, release ``0.2.0rc003``, hv1 sur le DHCP intégré et hv2 sur dnsmasq — toute la série en 8 minutes : .. code-block:: text $ test/e2e/run.sh all | grep -E '^(=== s[0-9].* : |INFO)' INFO: MAC de sn-s1a : 00:22:33:00:00:0a 00:22:33:00:00:0b ; de sn-s1b : 00:22:33:00:00:0a 00:22:33:00:00:0b === s1-dhcp-two : 37 réussi(s), 0 échoué(s) === s2-gateway : 22 réussi(s), 0 échoué(s) === s3-isolation-local : 12 réussi(s), 0 échoué(s) === s4-evpn : 14 réussi(s), 0 échoué(s) === s5-isolation-evpn : 13 réussi(s), 0 échoué(s) INFO: 30 s après l'arrêt du route reflector : 0 réponses dans les 10 dernières secondes (50 si le trafic passe intégralement) INFO: VTEP distant encore connu : 0 ; entrée d'inondation : 0 INFO: 90 s après l'arrêt : 0 réponses dans les 10 dernières secondes INFO: retour du VTEP distant et du trafic 31 s après le redémarrage de FRR === s6-rr-loss : 8 réussi(s), 0 échoué(s) Dans ce run, le contrôle « uniquement les MAC de son subnet » de ``s1`` ne prouvait rien : two dérive la MAC du rang de l'IP, et les VM ``.10``/``.11`` des deux subnets avaient les mêmes MAC. Vérifié à la main sur le lab, chaque serveur DHCP ne connaissait que les couples MAC/IP de son subnet ; le scénario compare désormais ces couples. ``s7-l3vni`` le 2026-10-05, même lab, FRR 10.7.1 : **46 réussi(s), 0 échoué(s)** au dernier run. Quatre constats pour #41, au-delà du routage inter-subnet qui fonctionne avec le route reflector inchangé : * **bgpd 10.7.1 plante** (SIGSEGV dans ``bgp_redistribute_add``) quand la VRF du noyau est supprimée puis recréée sous une instance ``router bgp … vrf`` encore configurée — FRR refuse de supprimer l'instance tant que ``vni`` est déclaré dans la VRF (« Please unconfigure l3vni »). Le plantage a touché les deux hyperviseurs à une seconde d'intervalle. Avec le démontage dans l'ordre — ``no redistribute``, ``no vni``, ``no router bgp … vrf``, puis le noyau —, trois runs consécutifs passent sans plantage. * **La configuration posée par vtysh est perdue** au redémarrage de bgpd par watchfrr, qui relit ``frr.conf`` seul. * **Le transit** ``169.254.0.0/30``, **identique sur tous les hôtes**, fait rejeter comme « martiens » les ICMP émis par les sauts distants (VRF et netns de l'hôte de sortie) : le noyau de l'hôte d'entrée possède la même adresse. Quatre routeurs sur le chemin, seuls les deux premiers répondent. Même effet attendu sur un ICMP « fragmentation nécessaire ». * **La route du supernet n'existe pas dans le netns** de la VPC avant la pose manuelle (premier run, lab neuf) : two ne pose que la route connectée du subnet. ``s8-l3vni-migration`` le 2026-10-06, ``evpn-3hv.yml`` : **61 réussi(s), 0 échoué(s)**. Le filet du ``/24`` porte le trafic tant que la destination n'a pas annoncé son ``/32`` ; deux ``/32`` coexistent sans perte tant que la source garde le subnet (40 sources sur 40, relais en L2). Si la source supprime le subnet avant de retirer son ``/32``, le trou noir est **stable mais partiel** : hv3 installe les deux chemins en ECMP, et seuls les flux hachés vers la source échouent (17 sources sur 40) — invisible avec un seul émetteur. Le 2026-10-11, les mêmes qualifications **par l'API**, l'agent posant toute la configuration (FRR 10.7.1) : * ``s1`` à ``s6`` sur ``evpn-2hv.yml``, release ``0.2.0rc004``, base BGP des hyperviseurs posée par l'agent : 37, 22, 12, 14, 13 et 8 réussis, aucun échec. * Puis, release ``0.2.0rc005`` (correction du démontage FRR, ci-dessous), ``evpn-3hv.yml`` : * ``s7-l3vni`` : **52 réussi(s), 1 échoué(s)**. Routage inter-subnet par le L3VNI, MAC de routeur dérivée du VTEP, exports ``/24`` et ``/32`` automatiques, forwarding par interface, L3VNI en double et subnet utilisé refusés (409), démontage complet d'une VPC sans redémarrage de bgpd. L'échec — « TTL 1 », un seul paquet — ne s'est pas reproduit au run précédent : probablement le débit limité des ICMP du noyau ; la vérification envoie désormais trois paquets. * ``s8-l3vni-migration`` : **48 réussi(s), 1 échoué(s)**. Migration simple (``/32`` de la destination installé sur hv3 sans délai mesurable, 50/50), séquence orchestrée (deux ``/32`` en ECMP, 40 sources sur 40), ex-pire cas refusé (409), watchdog : ``/32`` orphelin signalé comme trou noir, ``/32`` manquant signalé. L'échec est un constat : **la MAC de gateway anycast est annoncée en EVPN** (route de type 2 sur rr1) et FRR la déclare en double sur la VNI du subnet porté par deux hyperviseurs — apprise sur le veth du subnet, numéros de séquence croissants. Trois défauts trouvés et corrigés pendant la campagne : * **FRR installé avant la migration réseau** : zebra a perdu la route par défaut sur un hyperviseur sur deux (route reflector ``unresolved``). Retour à l'ordre « FRR après ``deploy.sh`` », puis redémarrage de l'agent (voir `Rôles`_). * **Remarques de vtysh prises pour des erreurs** : ``no vni`` répond ``% Configuration applied with notes:`` avec un code de retour 0. Une vraie erreur (commande inconnue, refus) sort en 1. * **L3VNI libérée de façon asynchrone** : juste après ``no vni``, ``no router bgp … vrf`` peut être refusé (« Please unconfigure l3vni ») puis accepté un instant plus tard ; l'agent réessaie. Le 2026-10-12, release ``0.2.0rc006``, ``evpn-3hv.yml`` : ``s1`` à ``s7`` sans échec, ``s8-l3vni-migration`` **50 réussi(s), 0 échoué(s)** (MAC de gateway propre à chaque hôte, aucun doublon EVPN), ``s9-subnets-partages`` **75 réussi(s), 1 échoué(s)**. L'échec est une session SSH coupée (``Broken pipe``), pas un ping perdu : quand un hôte route vers une VM d'un autre hôte, son netns émet une requête ARP au nom de la gateway, partagée par tous les hôtes ; la VM met son cache à jour et, pendant ~8 s, envoie à la gateway de l'autre hôte ce qui était destiné à la sienne. Détails et suite : `#57 `_. .. note:: Un ``Broken pipe`` (``client_loop: send disconnect``) ou une session SSH figée dans un scénario n'est **pas forcément un aléa du lab** : c'est la signature de ce problème. Ne pas le classer comme test instable ni ajouter un nouvel essai qui le masquerait ; regarder d'abord le cache ARP de la VM (``ip neigh show ``) et l'état de la session côté VM. Le 2026-10-13, labctl ``0.2.0``, release ``0.2.0rc008`` et binaires de l'arbre courant, ``evpn-3hv.yml`` avec deux switchs et deux route reflectors (#54) : ``s1`` à ``s10`` **313 réussi(s), 0 échoué(s)** ; lab monté en 8 min. Segments sur un bridge de l'hôte, sept taps ; ``sw2`` maître VRRP au démarrage, ``sw1`` en attente avec sa passerelle coupée. ``s6`` : 0 requête perdue sur 510 pendant l'arrêt de rr1 puis de rr2, session rétablie 14 s après le redémarrage de FRR. ``s10`` : ``sw2`` coupé, ``sw1`` maître, 14 requêtes perdues, plus long silence 2,8 s, sessions EVPN de hv1 jamais coupées ; ``sw2`` rétabli reste en attente. ``s9`` sans ``Broken pipe`` cette fois : #57 n'est pas corrigé pour autant. Les VM sont accessibles depuis le netns de leur VPC, sur l'hyperviseur, avec l'utilisateur ``syonad`` créé par les métadonnées de two : .. code-block:: text test/e2e/labctl.sh ssh "./labctl ssh hv1 'sudo ip netns exec vp-s4 ssh -i /root/.ssh/lab-vm syonad@10.240.1.10'" Écrire un scénario ~~~~~~~~~~~~~~~~~~ Le lab sert à qualifier des comportements qui ne se voient qu'à plusieurs hyperviseurs — la campagne L3VNI de `#41 `_ en est le prochain exemple. Un scénario est un fichier ``test/e2e/scenarios/-.sh``, exécuté par ``run.sh`` sur le Mac ; il envoie des blocs aux nœuds : .. code-block:: bash on hv1 <<'NODE' two_image || { echo "ÉCHOUÉ: image compatible two"; exit 0; } KEY=$(vm_key) check "VPC vp-x" vpc_create vp-x 10.250.0.0/16 check "subnet sn-x" subnet_create sn-x vp-x 2601 10.250.1.1 10.250.1.0/24 check "VM x1" vm_create x1 sn-x 10.250.1.10 "${KEY}" check "x1 joignable" vm_wait vp-x 10.250.1.10 check "x1 joint sa passerelle" vm_ssh vp-x 10.250.1.10 'ping -c 2 -W 2 10.250.1.1' check "x1 ne joint pas 10.251.1.10" vm_fails vp-x 10.250.1.10 'ping -c 2 -W 2 10.251.1.10' info "mesure : $(vtysh -c 'show evpn vni 2601' | grep -c 'flood')" NODE Les règles qui ont fait leurs preuves en E5 : * **une vérification par ligne**, avec ``check`` — jamais un ``echo RÉUSSI`` écrit à la main ; * **toute vérification négative a son témoin** : avant « ne joint pas », une ligne qui prouve que la cible est vivante et que le chemin du test fonctionne ; * **``vm_fails`` pour le négatif**, jamais ``!`` devant un ``vm_ssh`` : un SSH en panne doit échouer, pas passer pour une isolation ; * **une donnée qui distingue réellement les cas** : two dérivant la MAC du rang de l'IP, deux subnets ont les mêmes MAC — comparer des couples MAC/IP, pas des MAC ; * **les mesures en ``INFO``**, les attentes en ``check`` : un temps de reconvergence se mesure, il ne se décrète pas ; * chaque scénario crée ses propres VPC, plages et VNI, distinctes de celles des autres, pour que ``all`` les enchaîne sur le même lab ; un scénario qui dépend d'un autre le vérifie en tête (``check "prérequis : …"``) ; * variables vers un nœud : ``on hv1 NOM=valeur <<'NODE'`` (valeurs échappées par ``run.sh``) ; * ``bash test/e2e/run_test.sh`` vérifie la syntaxe de chaque bloc réellement envoyé — à lancer avant toute session. Sécurité -------- Propre à two — celle de l'outil (clé d'API, clés SSH des VM, images) est décrite dans le guide de ``labctl`` : * ``labctl`` et ``lab-host.sh`` sont vérifiés contre des sommes épinglées dans ``test/e2e/labctl.sh``, pas contre le ``SHA256SUMS`` téléchargé avec eux. * **Code exécuté sans épinglage par** ``deploy.sh`` : la bibliothèque ``shflags`` est récupérée par ``curl`` sur la branche ``main`` d'un autre dépôt (``H6N/tools``) et exécutée par ``eval``, sans vérification d'intégrité — dans le lab comme en production. Les artefacts de la release sont, eux, vérifiés contre ``SHA256SUMS``. * Le lab n'a aucune donnée personnelle ni secret de production. Tests ----- .. code-block:: bash bash test/e2e/run_test.sh Sans réseau : vérifie la syntaxe de chaque bloc réellement envoyé aux nœuds par les scénarios et les fonctions de ``test/e2e/lib/node.sh``. Les tests de l'outil sont dans le dépôt ``labctl``.