labctl: segments sur des bridges de l'hôte, routeurs et passerelle VRRP #2
All checks were successful
Tests / test (push) Successful in 3m46s

Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
This commit is contained in:
GnomeZworc 2026-10-13 09:57:09 +02:00
commit e9a0c19b72
Signed by: nicolas.boufideline
GPG key ID: 4406BBBF8845D632
24 changed files with 1766 additions and 578 deletions

View file

@ -141,31 +141,37 @@ celui d'une release, vérifié) au lieu de compiler.
## Topologie
Un lab est décrit par un fichier YAML : des **nœuds** (les VM) et des **segments** (des réseaux L2
portés par un switch). Exemple livré : [`examples/evpn-2hv/topology.yml`](../examples/evpn-2hv/topology.yml).
Un lab est décrit par un fichier YAML : des **nœuds** (les VM) et des **segments** (des réseaux
L2). Exemple livré : [`examples/evpn-2hv/topology.yml`](../examples/evpn-2hv/topology.yml) — deux
routeurs en VRRP, un route reflector et deux hôtes en EVPN.
Chaque nœud non-switch est relié au switch de chacun de ses segments par un câble virtuel QEMU ;
le switch met ces câbles dans un bridge et porte la passerelle du segment.
Chaque segment est un **bridge Linux sur l'hôte du lab** (`lb-<segment>`), et chaque nœud qui y
est attaché y branche une carte par un tap (`lt<i>`). Le L2 ne dépend donc d'aucune VM : la
perte d'un routeur ne coupe pas le trafic direct entre les autres nœuds du segment. Un
**routeur** est un nœud comme les autres, qui porte en plus la passerelle et le NAT des segments
dont il est routeur.
Ce que le fichier déclare :
**`images`** — `url` de l'image qcow2 et `sums` du fichier de sommes à vérifier, tous deux en
`https://`.
**`segments`** — `switch` (un nœud de rôle `switch`), `cidr` IPv4 entre `/8` et `/30`, `mtu`
facultatif — 9000 par défaut, entre 1280 et 9000. Nom : 12 caractères au plus, minuscules et
chiffres, parce qu'il devient le nom d'interface dans les VM et, préfixé de `br-`, celui du
bridge (15 caractères au plus sous Linux).
**`segments`** — `cidr` IPv4 entre `/8` et `/30`, `mtu` facultatif — 9000 par défaut, entre 1280
et 9000 —, et `routers`, facultatif : les nœuds de rôle `router` qui portent la passerelle du
segment, **dans l'ordre de priorité**. Sans routeur, le segment est un L2 pur (lien entre VM,
lien inter-cluster) : pas de passerelle, pas de NAT. Nom : 12 caractères au plus, minuscules et
chiffres, parce qu'il devient le nom d'interface dans les VM et, préfixé de `lb-`, celui du bridge
sur l'hôte (15 caractères au plus sous Linux).
**`nodes`** — `role` (`switch`, `rr` ou `host`), `image`, `cpus`, `memory` en Mio (256 au
**`nodes`** — `role` (`router`, `rr` ou `host`), `image`, `cpus`, `memory` en Mio (256 au
moins), `segments` auxquels le nœud est relié, et `addresses` pour fixer l'adresse d'un nœud sur
un segment (`addresses: {underlay: 192.168.14.50}`). Un switch ne déclare ni `segments` ni
`addresses` : il porte ceux dont il est le `switch`. Champs facultatifs :
un segment (`addresses: {underlay: 192.168.14.50}`). Un routeur listé dans `segments.<s>.routers`
doit être attaché à `<s>`. Champs facultatifs :
- `secondary` — des adresses supplémentaires par segment, avec leur longueur de préfixe
(`secondary: {underlay: [169.254.0.3/28]}`), posées sur la même interface que l'adresse
principale : même L2, même MAC. Elles doivent être **hors** du CIDR du segment, pour ne
jamais croiser l'attribution automatique. Sur un switch, elles vont sur le bridge du segment ;
jamais croiser l'attribution automatique ;
- `loopback` — une adresse sur une interface `dummy` nommée `lo1` (`loopback: 10.255.255.1/32`) ;
- `frr` — le chemin d'un `frr.conf`, relatif au fichier de topologie : FRR est installé au
démarrage et la configuration déposée **telle quelle** (voir [FRR](#frr)) ;
@ -173,67 +179,112 @@ un segment (`addresses: {underlay: 192.168.14.50}`). Un switch ne déclare ni `s
démarrage **avant** FRR ;
- `post_provision` — un second script, exécuté **après** FRR ;
- `files` — des fichiers **ou répertoires** déposés dans `/etc/lab/files/<nom>` avant les
scripts, sous la forme `{<nom>: <chemin>}` (`files: {motd: motd}`). Ils voyagent
dans un `files.iso` propre au nœud (volume `LABFILES`), attaché comme second lecteur et
recopié au premier démarrage : la taille n'est pas limitée par cloud-init, et un binaire de
plusieurs dizaines de Mio passe ;
scripts, sous la forme `{<nom>: <chemin>}` (`files: {motd: motd}`). Ils voyagent dans un
`files.iso` propre au nœud (volume `LABFILES`), attaché comme second lecteur et recopié au
premier démarrage : la taille n'est pas limitée par cloud-init, et un binaire de plusieurs
dizaines de Mio passe ;
- `services` — les unités systemd que `labctl up` vérifie actives sur le nœud.
Les scripts reçoivent `LAB_NODE` (nom du nœud), `LAB_UPLINK` (interface de son premier segment,
qui porte la route par défaut) et `LAB_FILES` (`/etc/lab/files`). L'outil ne sait rien de ce
qu'ils installent.
Les scripts reçoivent `LAB_NODE` (nom du nœud), `LAB_UPLINK` (interface qui porte la route par
défaut : celle du premier segment du nœud qui a une passerelle, `mgmt0` pour un routeur) et
`LAB_FILES`
(`/etc/lab/files`). L'outil ne sait rien de ce qu'ils installent.
**Un seul script de provisionnement par nœud.** cloud-init exécute `runcmd` comme un script `sh`
sans `set -e` : seule la dernière commande compterait, et une provision en échec suivie d'un FRR
installé avec succès passerait pour un démarrage réussi. Chaque nœud reçoit donc
`/usr/local/sbin/lab-provision`, en `set -eu`, qui enchaîne ses étapes — script du switch ou de
`/usr/local/sbin/lab-provision`, en `set -eu`, qui enchaîne ses étapes — service du routeur ou de
la loopback, `provision`, FRR, `post_provision` ; `runcmd` n'appelle que lui, et la première
étape en échec met cloud-init en erreur.
`mgmt0` et `lo1` sont réservés : aucun segment ne peut porter ces noms.
Ce que l'outil en déduit, de façon déterministe — même fichier, même plan :
### Passerelle et routeurs
| Routeurs du segment | Passerelle |
|---|---|
| aucun | aucune : les nœuds n'y ont pas de route par défaut |
| un | la première adresse du CIDR, posée sur l'interface du routeur, en plus de la sienne |
| deux ou plus | la première adresse du CIDR, **virtuelle**, portée en VRRP v3 par `vrrpd` de FRR |
Avec plusieurs routeurs, `labctl` prépare tout sur chacun : interface `macvlan` `vr<segment>`
avec la MAC VRRP (`00:00:5e:00:01:<vrid>`) et la passerelle, créée **coupée** (`protodown on`) :
seul `vrrpd` la rétablit, quand il devient maître ; `arp_ignore=1` et `arp_announce=2`
sur l'interface du segment (sans quoi elle répondrait aux ARP de la passerelle avec sa propre
MAC), FRR installé avec `vrrpd`, et la configuration VRRP **ajoutée** à la fin de son `frr.conf`
(ou d'un `frr.conf` minimal s'il n'en déclare pas) :
```text
interface underlay
vrrp 1 version 3
vrrp 1 priority 200
no vrrp 1 preempt
vrrp 1 ip 192.168.14.1
exit
```
Le VRID est le rang du segment plus un (d'où au plus 255 segments à plusieurs routeurs, parmi les
premiers) ; la priorité vaut 200 pour le premier routeur de la liste, puis 10 de moins pour
chacun des suivants. **Pas de préemption** : un routeur qui revient reste en attente, plutôt que
de reprendre la passerelle avant d'avoir ses routes BGP — un prétest l'a montré, la préemption
coupait les sessions qui passaient par lui. Conséquence : le maître est le premier routeur dont
VRRP démarre, la priorité ne départageant que des démarrages simultanés ; un scénario qui arrête
« le maître » doit le demander (`vtysh -c 'show vrrp'`), pas le supposer. Bascule mesurée en
prétest : environ 2,6 s de perte (trois annonces manquées à une seconde d'intervalle).
Chaque routeur masque (NAT nftables) vers `mgmt0` les segments dont il est routeur, et sort par
le NAT de QEMU. Un nœud qui n'est pas routeur prend sa route par défaut et ses DNS (`1.1.1.1`,
`8.8.8.8`) sur le premier de ses segments qui a une passerelle.
### Plan déterministe
Ce que l'outil déduit du fichier — même fichier, même plan :
| | |
|---|---|
| Passerelle d'un segment | la première adresse du CIDR, portée par le switch sur `br-<segment>` |
| Adresse d'un nœud | les suivantes, **dans l'ordre de déclaration des nœuds** ; une adresse fixée par `addresses` est réservée d'abord et sautée par l'attribution automatique |
| Câbles | un par couple (segment, nœud), segments puis nœuds dans l'ordre de déclaration ; le câble *i* utilise les ports UDP `20000 + 2i` (côté nœud) et `20001 + 2i` (côté switch) |
| MAC | `02:4c:<nœud>:<nœud>:<segment>:<côté>` — préfixe localement administré, rang du nœud sur deux octets, rang du segment, `00` côté nœud et `01` côté switch |
| Interfaces | côté nœud, le nom du segment ; côté switch, `p<i>`, du rang du câble |
| Passerelle d'un segment | la première adresse du CIDR, si le segment a au moins un routeur |
| Adresse d'un nœud | les suivantes (dès la première sans routeur), **dans l'ordre de déclaration des nœuds** ; une adresse fixée par `addresses` est réservée d'abord et sautée par l'attribution automatique |
| Bridge | `lb-<segment>` sur l'hôte du lab |
| Ports | un par couple (segment, nœud), segments puis nœuds dans l'ordre de déclaration ; le port *i* est le tap `lt<i>` |
| MAC | `02:4c:<nœud>:<nœud>:<segment>:00` — préfixe localement administré, rang du nœud sur deux octets, rang du segment |
| Interfaces | dans la VM, le nom du segment |
| SSH d'administration | `127.0.0.1:<2200 + rang du nœud>` sur l'hôte du lab |
> [!WARNING]
> Réordonner les nœuds ou les segments dans le fichier **change les adresses, les MAC et les
> ports**. C'est assumé pour un lab ; `labctl plan` montre le résultat avant tout lancement.
> Réordonner les nœuds ou les segments dans le fichier **change les adresses, les MAC, les taps et
> les ports**. C'est assumé pour un lab ; `labctl plan` montre le résultat avant tout lancement.
Limites : 1000 nœuds, 256 segments, et autant de câbles que la plage UDP le permet (22 768).
Limites : 1000 nœuds, 256 segments.
`labctl plan` valide le fichier et affiche le plan, sans rien lancer :
```text
$ go run ./cmd/labctl plan examples/evpn-2hv/topology.yml
lab evpn-2hv: nodes 4, segments 1, cables 3
lab evpn-2hv: nodes 5, segments 1, ports 5
nodes
name role image cpus memory ssh
sw1 switch debian12 2 1024 MiB 127.0.0.1:2200
rr1 rr debian12 1 1024 MiB 127.0.0.1:2201
hv1 host debian12 2 2048 MiB 127.0.0.1:2202
hv2 host debian12 2 2048 MiB 127.0.0.1:2203
r1 router debian12 1 1024 MiB 127.0.0.1:2200
r2 router debian12 1 1024 MiB 127.0.0.1:2201
rr1 rr debian12 1 1024 MiB 127.0.0.1:2202
hv1 host debian12 2 2048 MiB 127.0.0.1:2203
hv2 host debian12 2 2048 MiB 127.0.0.1:2204
roles
name loopback secondary frr provision post_provision files services
sw1 - underlay 169.254.0.1/28 sw1.conf - - - -
r1 - underlay 169.254.0.1/28 r1.conf - - - -
r2 - underlay 169.254.0.2/28 r2.conf - - - -
rr1 lo1 10.255.255.1/32 underlay 169.254.0.3/28 rr1.conf - - - -
hv1 - - hv1.conf host.sh - motd -
hv2 - - hv2.conf host.sh - motd -
segment underlay: 192.168.14.0/24, mtu 9000, switch sw1, bridge br-underlay, gateway 192.168.14.1
node interface address mac udp switch port mac udp
rr1 underlay 192.168.14.2/24 02:4c:00:01:00:00 20000 <-> sw1 p0 02:4c:00:01:00:01 20001
hv1 underlay 192.168.14.11/24 02:4c:00:02:00:00 20002 <-> sw1 p1 02:4c:00:02:00:01 20003
hv2 underlay 192.168.14.12/24 02:4c:00:03:00:00 20004 <-> sw1 p2 02:4c:00:03:00:01 20005
segment underlay: 192.168.14.0/24, mtu 9000, bridge lb-underlay, gateway 192.168.14.1 by vrrp 1 on r1, r2
node interface address mac tap
r1 underlay 192.168.14.252/24 02:4c:00:00:00:00 lt0
r2 underlay 192.168.14.253/24 02:4c:00:01:00:00 lt1
rr1 underlay 192.168.14.2/24 02:4c:00:02:00:00 lt2
hv1 underlay 192.168.14.11/24 02:4c:00:03:00:00 lt3
hv2 underlay 192.168.14.12/24 02:4c:00:04:00:00 lt4
```
Un fichier invalide est refusé avec **toutes** ses erreurs à la fois, et un code de sortie 1. Les
@ -242,17 +293,31 @@ champs inconnus et les clés en double sont refusés aussi :
```text
$ labctl plan cassee.yml
labctl: cassee.yml:
segment underlay: rr1 is a rr, not a switch
segment underlay: rr1 is a rr, not a router
segment underlay: router r9 is not a declared node
segment underlay: cidr 10.250.0.0/31 prefix length out of range [/8, /30]
node sw1: switch carries no segment
node r1: must be attached to at least one segment
```
### Migration depuis 0.1
Le rôle `switch` et le champ `segments.<s>.switch` n'existent plus : `labctl` les refuse avec un
message qui dit quoi faire. Pour une topologie 0.1 :
1. `role: switch` devient `role: router` ;
2. le routeur déclare `segments: [<s>]` et, de préférence, une adresse fixée (`addresses`) — en
0.1, le switch n'avait que la passerelle ;
3. `segments.<s>.switch: <nom>` devient `segments.<s>.routers: [<nom>]` ;
4. ses `secondary` restent valables : elles vont désormais sur son interface du segment, et non
plus sur un bridge interne.
## FRR
Au premier démarrage, cloud-init installe FRR (`frr-stable` de `deb.frrouting.org`, sans les
paquets recommandés), active `bgpd` — et `bfdd` sur le switch et le route reflector —, puis
paquets recommandés), active `bgpd` — et `bfdd` sur les routeurs et les route reflectors,
`vrrpd` sur les routeurs d'un segment en VRRP —, puis
dépose le `frr.conf` du nœud et redémarre FRR. La mise à jour des index de paquets est réessayée
pendant cinq minutes : un nœud peut démarrer avant que le switch, par lequel il sort, n'ait posé
pendant cinq minutes : un nœud peut démarrer avant que le routeur, par lequel il sort, n'ait posé
son NAT.
La **clé du dépôt FRR** n'est pas téléchargée au démarrage : elle est enregistrée dans `labctl`
@ -275,7 +340,7 @@ voit pas — une provision qui arme un redémarrage, par exemple : la VM redéma
`runcmd`.
> [!NOTE]
> **Le switch du lab est un routeur Linux avec FRR, par choix.** Il joue le rôle générique de
> **Le routeur du lab est un Linux avec FRR, par choix.** Il joue le rôle générique de
> routeur de cluster : passerelle des nœuds et, dans l'exemple, session eBGP avec BFD vers le
> route reflector, dont il n'accepte que la loopback. L'équipement réel d'une infrastructure
> (MikroTik, Cisco, Juniper, Arista…) n'a besoin que de BGP et d'EVPN ; sa configuration propre
@ -300,17 +365,17 @@ Les chemins de la VM (`disk.qcow2`, `seed.iso`, `console.log`, `qmp.sock`, `qemu
du répertoire du nœud ; `-key` peut être répété, et accepte un fichier `authorized_keys` (lignes
vides et commentaires ignorés). Les fichiers sont créés en `0600`.
Ce que contiennent les arguments QEMU d'un nœud — extrait réel, côté réseau :
Ce que contiennent les arguments QEMU d'un nœud — côté réseau :
```text
-netdev
user,id=mgmt0,restrict=on,ipv6=off,hostfwd=tcp:127.0.0.1:2202-:22
user,id=mgmt0,restrict=on,ipv6=off,hostfwd=tcp:127.0.0.1:2203-:22
-device
virtio-net-pci,netdev=mgmt0,mac=02:4d:00:02:00:00,romfile=
virtio-net-pci,netdev=mgmt0,mac=02:4d:00:03:00:00,romfile=
-netdev
dgram,id=underlay,local.type=inet,local.host=127.0.0.1,local.port=20002,remote.type=inet,remote.host=127.0.0.1,remote.port=20003
tap,id=underlay,ifname=lt3,script=no,downscript=no
-device
virtio-net-pci,netdev=underlay,mac=02:4c:00:02:00:00,host_mtu=9000,romfile=
virtio-net-pci,netdev=underlay,mac=02:4c:00:03:00:00,host_mtu=9000,romfile=
```
Les choix qui s'y lisent :
@ -318,11 +383,11 @@ Les choix qui s'y lisent :
- **machine** `q35`, `-accel kvm -cpu host` — le KVM imbriqué des nœuds en dépend ;
`-nodefaults` pour qu'aucun périphérique implicite ne s'ajoute ;
- **administration** (`mgmt0`) : le NAT de QEMU, MAC `02:4d:<nœud>:<nœud>:00:00`, SSH redirigé
sur la boucle locale de l'hôte. `restrict=on` pour tous les nœuds **sauf le switch** : un
sur la boucle locale de l'hôte. `restrict=on` pour tous les nœuds **sauf les routeurs** : un
nœud isolé ne joint ni l'hôte ni l'extérieur par là, seule la redirection SSH passe.
`ipv6=off` partout (voir plus bas) ;
- **câbles** : `dgram` sur `127.0.0.1`, les deux extrémités d'un câble se répondent (port local
de l'une = port distant de l'autre), `host_mtu` annonce le MTU du segment au guest ;
- **segments** : un tap créé par `labctl up` (`script=no` : QEMU ne lance aucun script), branché
sur le bridge du segment ; `host_mtu` annonce le MTU du segment au guest ;
- `romfile=` vide sur toutes les cartes : pas de ROM de démarrage réseau, donc pas de repli sur
un démarrage PXE si le firmware ne trouve pas le disque. Pendant les premiers essais, une VM
restée bloquée sans rien écrire sur sa console, CPU au repos, avait toutes les apparences de
@ -330,18 +395,22 @@ Les choix qui s'y lisent :
Ce que fait cloud-init :
- **toutes les VM** : interfaces nommées d'après leur MAC (`mgmt0`, nom du segment, `p<i>`),
`dhcp4: false` partout, `mgmt0` en `10.0.2.15/24` **sans passerelle** ; connexion SSH par
clé seulement, utilisateur `debian`, `root` désactivé, mot de passe refusé ;
- **un nœud** : adresse sur chaque segment, MTU du segment, route par défaut et DNS
(`1.1.1.1`, `8.8.8.8`) sur son **premier** segment — la sortie Internet passe par le switch ;
- **le switch** : route par défaut par `mgmt0` ; un service `lab-switch` crée un bridge
`br-<segment>` par segment (STP désactivé, MTU du segment), y branche ses ports, porte la
passerelle, active le routage et masque (NAT nftables) les segments vers `mgmt0`. Le service
est rejoué à chaque démarrage.
- **toutes les VM** : interfaces nommées d'après leur MAC (`mgmt0`, nom du segment),
`dhcp4: false` partout, `mgmt0` en `10.0.2.15/24` ; connexion SSH par clé seulement,
utilisateur `debian`, `root` désactivé, mot de passe refusé ;
- **un nœud** : adresse et `secondary` sur chaque segment, MTU du segment, route par défaut et
DNS sur le premier de ses segments qui a une passerelle ; `mgmt0` **sans passerelle** ;
- **un routeur** : mêmes adresses, route par défaut par `mgmt0` ; un service `lab-router` active
le routage, pose les passerelles (adresse ou `macvlan` VRRP, voir
[Passerelle et routeurs](#passerelle-et-routeurs)) et le NAT nftables. Le service est rejoué à
chaque démarrage.
### Vérifié sur de vraies VM
Relevés faits avec le modèle 0.1 — le switch portait alors le bridge du segment, relié aux nœuds
par des câbles UDP ; ce qui touche au L2 et à la passerelle est à revérifier avec les bridges de
l'hôte.
Le switch et le route reflector n'ont pas besoin de KVM imbriqué : `sw1` et `rr1` ont été
démarrés **sur un Mac**, en émulation (TCG), avec Debian 12 `generic` et les fichiers produits
par `labctl render`.
@ -387,19 +456,45 @@ labctl ssh [-run dir] <nœud> [commande…]
3. génère une paire de clés SSH dans le répertoire du lab, si elle n'existe pas encore ;
4. pour chaque nœud : fichiers de `labctl render`, disque **neuf** en overlay qcow2 sur l'image
(`qemu-img create -b`, 20 Gio annoncés), image `cidata` et `files.iso` (`genisoimage`) ;
5. démarre les QEMU, **switchs d'abord**, détachés (`-daemonize`) : ils survivent à la session
5. crée les bridges des segments et les taps des nœuds (voir [Réseau de l'hôte](#réseau-de-lhôte)),
et refuse de continuer si l'un d'eux existe déjà ;
6. démarre les QEMU, **routeurs d'abord**, détachés (`-daemonize`) : ils survivent à la session
SSH qui les a lancés ;
6. attend sur chaque nœud la fin de cloud-init (`cloud-init status --wait` par SSH), jusqu'au
délai `-timeout`, puis vérifie ses services.
7. attend sur chaque nœud la fin de cloud-init (`cloud-init status --wait` par SSH), jusqu'au
délai `-timeout`, puis vérifie ses services (`frr` compris quand il est installé).
La topologie est copiée dans `<run>/topology.yml`. Un échec laisse les nœuds démarrés en place :
`labctl status`, puis `labctl down`.
**`labctl status`** — pour chaque nœud : rôle, état du processus QEMU, PID, port SSH sur la
boucle locale.
boucle locale ; pour chaque segment : bridge présent ou absent, passerelle.
**`labctl down`** — arrête chaque QEMU par `SIGTERM`, puis `SIGKILL` au bout de 30 s. Les disques
sont conservés jusqu'au prochain `up`, qui les recrée.
**`labctl down`** — arrête chaque QEMU par `SIGTERM`, puis `SIGKILL` au bout de 30 s, puis
supprime les taps et les bridges du lab. Les disques sont conservés jusqu'au prochain `up`, qui
les recrée.
`up` et `down` doivent tourner **en root** : ils créent et suppriment des interfaces de l'hôte.
### Réseau de l'hôte
Pour chaque segment, `labctl up` exécute :
```text
ip link add name lb-<segment> type bridge stp_state 0 mcast_snooping 0
ip link set dev lb-<segment> addrgenmode none
ip tuntap add dev lt<i> mode tap # pour chaque port du segment
ip link set dev lt<i> addrgenmode none
ip link set dev lt<i> mtu <mtu> master lb-<segment> up
ip link set dev lb-<segment> mtu <mtu> up
```
- **Aucune adresse côté hôte**, IPv4 ni IPv6 (`addrgenmode none` : pas même de lien local) :
l'hôte n'est pas joignable depuis un segment, et ne route rien entre eux.
- **Pas de STP ni de surveillance IGMP** : le bridge se comporte comme un switch simple, et les
annonces VRRP (`224.0.0.18`) circulent sans dépendre d'un querier.
- Si `br_netfilter` est chargé sur l'hôte, `bridge-nf-call-iptables` est mis à 0 : le pare-feu
de l'hôte ne filtre pas le trafic des segments.
- Un lab par hôte : les noms `lb-*` et `lt*` ne sont pas propres à un répertoire `-run`.
**`labctl ssh`** — ouvre un shell sur un nœud, ou y exécute une commande, avec la clé générée par
`up`. `labctl` cède la place à `ssh`, dont le code de retour est donc celui de la commande. Un
@ -433,7 +528,7 @@ PID réutilisé par un autre programme n'est donc jamais signalé.
### Vérifié sur le serveur de lab
Le 2026-10-04, sur un Xeon E5-2640 v3, Debian 12 et QEMU 7.2 sur le serveur, topologie à deux
Avec le modèle 0.1 (voir la remarque précédente). Le 2026-10-04, sur un Xeon E5-2640 v3, Debian 12 et QEMU 7.2 sur le serveur, topologie à deux
hôtes :
| Vérification | Résultat |
@ -519,6 +614,8 @@ au projet.
- **Clé SSH des VM** : générée par `labctl up` sur le serveur, c'est la seule clé autorisée dans
les VM. Elle ne quitte jamais le serveur, n'ouvre que les VM du lab — qui n'écoutent qu'en
boucle locale — et disparaît avec lui. La clé publique du poste n'est jamais envoyée aux VM.
- **Segments isolés de l'hôte** : bridges et taps sans adresse (voir
[Réseau de l'hôte](#réseau-de-lhôte)) ; seuls les routeurs sortent, par le NAT de QEMU.
- **Clés d'hôte des VM non vérifiées** par `labctl ssh` (`known_hosts` jetable) : elles changent
à chaque `up`. Acceptable uniquement parce que la connexion reste sur la boucle locale d'un
serveur auquel on s'est authentifié.