adam/tripoli.cloud
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Phase 4 : tripoli-netctl, labo network namespaces + veth (rtnetlink)

Browse source 
- CLI (clap) : create/destroy/list. Network namespace créé via
  rtnetlink::NetworkNamespace (fork + unshare(CLONE_NEWNET) + bind-mount,
  équivalent de `ip netns add`), paire veth créée dans la racine, un
  bout déplacé dans le namespace (setns_by_fd) et adressé depuis un
  thread OS dédié qui fait setns() - jamais un thread du pool
  spawn_blocking de tokio, qui serait réutilisé pour d'autres tâches et
  resterait coincé dans le namespace.
- Journal d'audit JSON (stderr + /var/log/tripoli-netctl/audit.log) à
  chaque opération.
- Documenté explicitement comme labo pédagogique un-seul-poste :
  tripoli-edge et tripoli-api restent nativement sur l'hôte, ce projet
  ne pilote aucun trafic de production.
- Testé en conditions réelles sur le serveur : création, adressage des
  deux côtés (dont lo, down par défaut dans un netns neuf), ping
  traversant effectivement la veth, puis destruction propre (veth +
  namespace) vérifiée par absence des interfaces et du namespace.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
Adam Belkacemi 2026-09-16 22:58:53 +02:00
parent 546734ad77
commit 991f4dd04f
9 changed files with 688 additions and 2 deletions
Download patch file Download diff file Expand all files Collapse all files

223
tripoli-netctl/src/netns_ops.rs Normal file
View file

@ -0,0 +1,223 @@
use std::net::{IpAddr, Ipv4Addr};
use std::os::fd::AsRawFd;
use anyhow::{anyhow, bail, Context, Result};
use futures_util::TryStreamExt;
use rtnetlink::{new_connection, Handle, LinkUnspec, LinkVeth, NetworkNamespace};
use crate::audit;
use crate::naming::{veth_names, VethNames};
async fn find_link_index(handle: &Handle, name: &str) -> Result<u32> {
let mut links = handle.link().get().match_name(name.to_string()).execute();
match links
.try_next()
.await
.with_context(|| format!("recherche de l'interface {name}"))?
{
Some(link) => Ok(link.header.index),
None => bail!("interface {name} introuvable"),
}
}
/// Crée un service isolé : un network namespace + une paire veth qui le
/// relie au namespace racine. Labo pédagogique un-seul-poste : ce n'est
/// jamais branché sur le trafic réel de tripoli-edge/tripoli-api, qui
/// continuent de tourner nativement sur l'hôte.
pub async fn create(service_name: &str, subnet_id: u8) -> Result<()> {
let VethNames { host, peer } = veth_names(service_name);
let ns_path = format!("/run/netns/{service_name}");
NetworkNamespace::add(service_name.to_string())
.await
.map_err(|e| anyhow!("création du namespace : {e}"))?;
audit::log("namespace_created", service_name, &ns_path, "ok");
let (connection, handle, _) =
new_connection().context("connexion netlink (namespace racine)")?;
tokio::spawn(connection);
handle
.link()
.add(LinkVeth::new(&host, &peer).build())
.execute()
.await
.with_context(|| format!("création de la paire veth {host}/{peer}"))?;
// L'index du pair doit être résolu AVANT de le déplacer dans le
// namespace : une fois déplacé, il n'est plus visible depuis le
// handle netlink de la racine.
let peer_index = find_link_index(&handle, &peer).await?;
let host_index = find_link_index(&handle, &host).await?;
let ns_file = std::fs::File::open(&ns_path)
.with_context(|| format!("ouverture de {ns_path}"))?;
handle
.link()
.set(LinkUnspec::new_with_index(peer_index).setns_by_fd(ns_file.as_raw_fd()).build())
.execute()
.await
.context("déplacement de l'interface pair dans le namespace")?;
let host_ip = Ipv4Addr::new(10, 200, subnet_id, 1);
let peer_ip = Ipv4Addr::new(10, 200, subnet_id, 2);
handle
.address()
.add(host_index, IpAddr::V4(host_ip), 30)
.execute()
.await
.context("adresse côté hôte")?;
handle
.link()
.set(LinkUnspec::new_with_index(host_index).up().build())
.execute()
.await
.context("activation de l'interface hôte")?;
audit::log(
"veth_created",
&format!("{host}<->{peer}"),
&format!("hôte {host_ip}/30, namespace {service_name}"),
"ok",
);
configure_inside_namespace(ns_path.clone(), peer.clone(), peer_ip)
.context("configuration à l'intérieur du namespace")?;
audit::log(
"namespace_interface_configured",
service_name,
&format!("{peer} {peer_ip}/30"),
"ok",
);
println!("service '{service_name}' prêt :");
println!(" hôte : {host} {host_ip}/30 (namespace racine)");
println!(" ns : {peer} {peer_ip}/30 (namespace {service_name}, {ns_path})");
Ok(())
}
/// Entre dans le namespace cible pour y configurer l'adresse et activer
/// l'interface - et `lo`, qui démarre toujours down dans un namespace
/// neuf. Volontairement un `std::thread::spawn` dédié, jamais réutilisé
/// (pas `tokio::task::spawn_blocking`, dont les threads sont mis en
/// pool et réutilisés) : `setns` change la namespace RÉSEAU du thread
/// appelant pour toute sa durée de vie, et laisser un thread du pool
/// tokio « coincé » dans un namespace ferait planter n'importe quelle
/// tâche bloquante ultérieure qui tomberait dessus.
fn configure_inside_namespace(ns_path: String, if_name: String, ip: Ipv4Addr) -> Result<()> {
let handle = std::thread::spawn(move || -> Result<()> {
let ns_file =
std::fs::File::open(&ns_path).with_context(|| format!("ouverture de {ns_path}"))?;
nix::sched::setns(&ns_file, nix::sched::CloneFlags::CLONE_NEWNET)
.map_err(|e| anyhow!("setns : {e}"))?;
let rt = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.context("runtime tokio dédié à ce thread")?;
rt.block_on(async move {
let (connection, handle, _) =
new_connection().context("connexion netlink (dans le namespace)")?;
tokio::spawn(connection);
if let Ok(lo_index) = find_link_index(&handle, "lo").await {
handle
.link()
.set(LinkUnspec::new_with_index(lo_index).up().build())
.execute()
.await
.context("activation de lo dans le namespace")?;
}
let if_index = find_link_index(&handle, &if_name).await?;
handle
.address()
.add(if_index, IpAddr::V4(ip), 30)
.execute()
.await
.context("adresse côté namespace")?;
handle
.link()
.set(LinkUnspec::new_with_index(if_index).up().build())
.execute()
.await
.context("activation de l'interface dans le namespace")?;
Ok(())
})
});
handle
.join()
.map_err(|_| anyhow!("le thread de configuration a paniqué"))?
}
/// Supprime la paire veth (la suppression d'un bout supprime
/// automatiquement l'autre, même dans un namespace différent - c'est
/// une propriété du noyau, pas quelque chose que ce code doit gérer),
/// puis le namespace lui-même.
pub async fn destroy(service_name: &str) -> Result<()> {
let VethNames { host, .. } = veth_names(service_name);
let (connection, handle, _) = new_connection().context("connexion netlink")?;
tokio::spawn(connection);
match find_link_index(&handle, &host).await {
Ok(index) => {
handle
.link()
.del(index)
.execute()
.await
.with_context(|| format!("suppression de {host}"))?;
audit::log("veth_deleted", &host, service_name, "ok");
}
Err(_) => {
audit::log("veth_deleted", &host, service_name, "absente, rien à faire");
}
}
NetworkNamespace::del(service_name.to_string())
.await
.map_err(|e| anyhow!("suppression du namespace : {e}"))?;
audit::log("namespace_deleted", service_name, "", "ok");
println!("service '{service_name}' détruit");
Ok(())
}
pub async fn list() -> Result<()> {
let mut names = Vec::new();
if let Ok(entries) = std::fs::read_dir("/run/netns") {
for entry in entries.flatten() {
if let Some(name) = entry.file_name().to_str() {
names.push(name.to_string());
}
}
}
if names.is_empty() {
println!("aucun namespace tripoli-netctl actif");
return Ok(());
}
let (connection, handle, _) = new_connection().context("connexion netlink")?;
tokio::spawn(connection);
for name in names {
let VethNames { host, .. } = veth_names(&name);
match find_link_index(&handle, &host).await {
Ok(_) => println!("{name} : veth {host} présente côté hôte"),
Err(_) => {
println!("{name} : namespace présent, pas de veth {host} associée")
}
}
}
Ok(())
}