Lab Kubernetes VirtualBox : Configurer le NAT Network et Host-Only sur Fedora

Lab Kubernetes VirtualBox : Configurer le NAT Network et Host-Only sur Fedora

> ip route add default via kubernetes_knowledge_

Lab Kubernetes VirtualBox : L'Architecture Réseau Ultime

Par Nicolas DELAHAYE | v.1974 | Architecte Solution

STATUS: NETWORK_RECOVERY_MODE


Monter un Lab Kubernetes VirtualBox avec Fedora Server est un excellent choix technique, mais c'est aussi un redoutable test pour vos compétences réseau. Le symptôme est classique : vos VMs ne sortent pas sur Internet et votre Mac refuse de s'y connecter en SSH.

Le problème ne vient pas de Fedora, mais d'une confusion courante sur le rôle du NAT Network. Contrairement à une idée reçue, la VM ne doit pas "router" via votre host pour sortir. Elle doit utiliser l'abstraction fournie par VirtualBox.

En configurant vos IP manuellement sans activer de serveur DHCP sur le NAT Network, vous avez créé des nœuds isolés. Sans DHCP, Fedora ne reçoit pas de Default Gateway (passerelle par défaut). Sans passerelle, la VM ne sait pas par où envoyer ses paquets pour atteindre 8.8.8.8.

De plus, le NAT Network est un réseau privé. Par défaut, il n'autorise pas votre MacBook à "entrer" pour initier une session SSH sans une règle de Port Forwarding complexe.

[Image of the OSI model networking layers]

Pour un lab Kubernetes stable et conforme aux bonnes pratiques DevSecOps, nous allons utiliser deux cartes réseau par VM. Cette séparation des flux est la clé :

  • NIC 1 (NAT Network) : Dédié à la sortie vers Internet (mises à jour dnf, téléchargement d'images Docker).
  • NIC 2 (Host-Only) : Dédié à l'administration SSH depuis votre Mac et aux communications internes du cluster.
Schéma de flux :
VM (enp0s3) ----> VirtualBox NAT Engine ----> Internet
Mac (vboxnet0) <----> VM (enp0s8) [SSH & Kube API]

┌──────────────────────────┐ │ MacBook Pro │ │ │ │ 192.168.56.1 (vboxnet0) │ └────────────┬─────────────┘ │ Host-only ┌────────────────────┼────────────────────┐ │ │ │ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ ControlPlane │ │ Worker 1 │ │ Worker 2 │ │ │ │ │ │ │ │ enp0s8 │ │ enp0s8 │ │ enp0s8 │ │ 192.168.56.11│ │ 192.168.56.21│ │ 192.168.56.22│ │ (SSH/Admin) │ │ │ │ │ │ │ │ │ │ │ │ enp0s3 │ │ enp0s3 │ │ enp0s3 │ │ DHCP │ │ DHCP │ │ DHCP │ │ NAT Network │ │ NAT Network │ │ NAT Network │ └──────┬───────┘ └───────┬──────┘ └────────┬─────┘ │ │ │ └─────────────── VirtualBox NAT Network ────┘ (Internet, DNS, MAJ)

A. Paramétrer le NAT Network

Allez dans VirtualBox > Preferences > Network. Vérifiez votre NAT Network :

  • CIDR : 10.0.2.0/24
  • DHCP : DOIT être activé (C'est lui qui donnera la route par défaut).

B. Paramétrer le Host-Only

Vérifiez que vous avez une interface vboxnet0 (souvent en 192.168.56.1) créée dans le gestionnaire de réseau hôte.

Fedora Server utilise NetworkManager. Oubliez la modification manuelle des fichiers ifcfg, utilisez nmcli pour une configuration persistante et propre.

# 1. Configurer l'interface Internet (NAT Network)
nmcli con add type ethernet ifname enp0s3 con-name internet ipv4.method auto
nmcli con up internet

# 2. Configurer l'interface SSH/Admin (Host-only)
nmcli con add type ethernet ifname enp0s8 con-name admin \
  ipv4.method manual \
  ipv4.addresses 192.168.56.11/24
nmcli con up admin

Crucial : En laissant la première interface en auto (DHCP), Fedora va automatiquement définir la passerelle 10.0.2.1 comme route par défaut. Votre VM peut maintenant sortir !

Pour éviter de refaire cette configuration manuellement sur vos trois nœuds (Control-Plane, Worker1, Worker2), voici le Vagrantfile optimisé pour votre Lab Kubernetes VirtualBox.

Vagrant.configure("2") do |config|
  config.vm.box = "fedora/40-cloud-base"

  nodes = {
    "cp-master" => "192.168.56.11",
    "worker-1"  => "192.168.56.21",
    "worker-2"  => "192.168.56.22"
  }

  nodes.each do |name, ip|
    config.vm.define name do |node|
      node.vm.hostname = name
      # Interface 1 : NAT Network (Auto DHCP via Vagrant)
      node.vm.network "private_network", type: "dhcp", virtualbox__intnet: "nat-k8s"
      
      # Interface 2 : Host-only (IP Statique pour SSH)
      node.vm.network "private_network", ip: ip
      
      node.vm.provider "virtualbox" do |vb|
        vb.memory = 2048
        vb.cpus = 2
      end
    end
  end
end

Une fois cette architecture réseau en place, vous verrez que l'installation de Kubernetes avec kubeadm devient fluide. Pourquoi ? Parce que les composants comme Etcd ou l'API Server pourront s'écouter sur l'interface Host-Only stable, tandis que les pods pourront sortir chercher leurs images via le NAT Network.

Rappelez-vous : dans un environnement virtualisé, la simplicité est une vertu. En séparant l'administration (Host-Only) de la sortie (NAT), vous imitez les architectures Cloud réelles.

Comparatif Distributions Linux complet pour DevOps

Comparatif Distributions Linux complet pour DevOps

> cat /etc/os-release | grep "ID_LIKE"_

Comparatif Distributions Linux : Comprendre la Jungle des Paquets

Par Nicolas DELAHAYE | v.1974 | Architecte Solution

STATUS: OS_FAMILY_ANALYSIS


Il existe des centaines de distributions Linux, mais en réalité, elles ne forment que quelques grandes familles. Si vous avez l'impression de toujours tomber soit sur yum, soit sur apt-get, votre intuition est bonne.

Réaliser un comparatif des distributions Linux pertinent ne consiste pas à regarder l'interface graphique (puisque nous travaillons en Headless), mais à analyser leur ADN : leur gestionnaire de paquets, leur philosophie de sécurité et leur cycle de vie.

La Famille Debian (Le Standard)

  • Distros : Debian, Ubuntu, Linux Mint.
  • Gestionnaire : apt / apt-get (.deb).
  • Pourquoi elle domine : Équilibre parfait entre stabilité (Debian Stable) et facilité d'usage (Ubuntu).

La Famille Red Hat & Fedora (L'Innovation & l'Entreprise)

C'est ici que se joue le futur du Linux d'entreprise. On distingue deux branches majeures :

  • Fedora Project : C'est la distribution "amont" (upstream). Orientée communauté et innovation, elle intègre les dernières versions de kernels et d'outils. Si une techno est dans Fedora aujourd'hui, elle sera dans la prod mondiale dans 2 ans.
  • RHEL / Rocky / Alma : La branche stable "aval" (downstream), dérivée des versions stabilisées de Fedora.
  • Gestionnaire : dnf (le successeur moderne de yum).

La Famille Alpine (Le Minimaliste)

  • Gestionnaire : apk.
  • Usage : Conteneurs Docker ultra-légers (5 Mo).
Distro Communauté Sécurité (Défaut) Taille / Poids Usage Type
Debian ⭐⭐⭐⭐⭐ ⭐⭐⭐⭐ Moyenne Serveur / VM stable
Fedora ⭐⭐⭐⭐ ⭐⭐⭐⭐ Moyenne Poste Dev / Innovation
Rocky / Alma ⭐⭐⭐ ⭐⭐⭐⭐⭐ Moyenne Production Critique
Alpine ⭐⭐⭐ ⭐⭐⭐⭐⭐ Très Petite Containers Docker

Utiliser Fedora (via le Projet Fedora) est un choix stratégique pour un architecte. Contrairement à Debian qui privilégie des paquets parfois anciens mais éprouvés, Fedora propose des versions très récentes de Docker, Podman ou Python.

C'est la distribution idéale pour monter une VM de développement "Cutting Edge" tout en restant compatible avec les commandes dnf que vous retrouverez en production sur RHEL.

Vagrant Synced Folders : Pourquoi la configuration change entre Windows et Linux ?

Vagrant Synced Folders : Pourquoi la configuration change entre Windows et Linux ?

> cat Vagrantfile | grep "synced_folder" --explain_

Vagrant Synced Folders : Le casse-tête Windows vs Linux résolu

Par Nicolas DELAHAYE | v.1974 | Architecte Solution

STATUS: FILESYSTEM_OPTIMIZATION


Si vous travaillez dans une équipe mixte, vous avez sûrement remarqué ce comportement étrange concernant les Vagrant Synced Folders. Sur Linux ou macOS, vous devez écrire des blocs de configuration complexes (spécifiant NFS, versions, UDP, etc.), alors que sur Windows, une simple ligne suffit souvent.

Est-ce que Windows est "plus intelligent" ? Non. Au contraire, cette différence cache un compromis technique majeur entre performance et compatibilité. Décortiquons ce qui se passe sous le capot de vos montages de fichiers.

Il faut comprendre que Vagrant est un chef d'orchestre, pas un ouvrier. Quand vous demandez un dossier partagé, Vagrant délègue cette tâche au "Provider" (VirtualBox, Hyper-V, VMWare) et aux capacités du système hôte.

Les Vagrant Synced Folders n'utilisent pas la même technologie selon l'OS sur lequel ils tournent :

  • Sur Windows : Utilise par défaut VirtualBox Shared Folders (vboxsf).
  • Sur Linux/macOS : Peut utiliser vboxsf, mais les développeurs forcent quasi-systématiquement NFS.

Linux et macOS sont des systèmes POSIX. Ils gèrent les permissions (chmod, chown), les liens symboliques et les sockets de manière standardisée.

Pour obtenir des performances décentes (surtout avec des projets contenant des milliers de fichiers comme Symfony, Laravel ou node_modules), on utilise le protocole NFS (Network File System).

Cependant, NFS n'est pas "magique". Pour qu'il fonctionne via Vagrant, il faut être explicite :
👉 Quelle version de NFS ? (souvent la 4)
👉 UDP ou TCP ? (TCP est plus stable)
👉 Quelles options de montage ?

C'est pour cela que votre configuration Linux est verbeuse. Vous demandez de la performance, et Vagrant a besoin de détails pour configurer le serveur NFS localement.

Windows n'est pas POSIX. Son système de fichiers (NTFS) ne gère pas les permissions comme Linux. Installer un serveur NFS sur Windows est possible mais fastidieux et instable.

Par défaut, Vagrant sur Windows se rabat donc sur le plus petit dénominateur commun : VirtualBox Shared Folders.

Le piège :
Vous n'avez rien à configurer, ça "juste marche". MAIS :
1. C'est beaucoup plus lent (I/O disque catastrophique sur les gros projets).
2. Les permissions sont "simulées" (tout appartient souvent à root ou vagrant).
3. Les événements de fichiers (inotify) pour le hot-reload passent mal.

Votre configuration actuelle avec des if/else imbriqués fonctionne, mais elle viole le principe DRY (Don't Repeat Yourself). Elle est difficile à maintenir si vous ajoutez un troisième dossier.

Voici une approche "DevSecOps" plus propre. Nous allons créer une méthode Ruby qui génère la configuration adaptée selon l'OS détecté.

# Au début de votre Vagrantfile ou dans un fichier require séparé
def get_mount_options(is_nfs_capable)
  if is_nfs_capable
    {
      type: "nfs",
      nfs_version: 4,
      nfs_udp: false,
      mount_options: ["rw", "actimeo=1"] # actimeo booste le cache NFS
    }
  else
    # Fallback Windows / vboxsf
    {
      mount_options: ["rw", "dmode=777", "fmode=777"] # On force les perms sur Windows
    }
  end
end

# Détection simple
IS_UNIX = !Vagrant::Util::Platform.windows?

Vagrant.configure("2") do |config|
  # Configuration dynamique et propre
  config.vm.synced_folder ".", "/home/dev", **get_mount_options(IS_UNIX)

  if PERSONNAL_CONFIG[:add_project_source_code]
     config.vm.synced_folder PERSONNAL_CONFIG[:src_path], "/home/project", **get_mount_options(IS_UNIX)
  end
end

// NOTE : L'opérateur ** en Ruby permet d'éclater le hash retourné par la fonction directement en arguments pour Vagrant.

Ne cherchez pas à avoir une configuration identique à l'octet près entre Windows et Linux pour vos Vagrant Synced Folders. C'est un combat perdu d'avance à cause des différences d'architecture OS.

L'approche recommandée est celle-ci :
Linux/Mac : Forcez NFS pour la vitesse.
Windows : Acceptez vboxsf pour la simplicité (ou passez à WSL2).
Le Code : Abstraire cette complexité dans une fonction Ruby pour garder un Vagrantfile lisible.

Vagrant sur Windows : Le mystère des variables BOX_VERSION et BOX_ARCH obligatoires

Vagrant sur Windows : Le mystère des variables BOX_VERSION et BOX_ARCH obligatoires

> vagrant up --provider=virtualbox --debug_

Vagrant : Pourquoi Windows exige BOX_VERSION et BOX_ARCH ?

Par Nicolas DELAHAYE | v.1974 | Architecte Solution

ERROR: AMBIGUOUS_BOX_METADATA_FOUND


Voici un scénario que j'ai vécu (et vous aussi probablement) : je pousse mon code sur Git. Mon Vagrantfile est propre. Je fais un vagrant up sur mon Mac M3 : tout fonctionne.

Mon collègue sous Windows clone le repo, lance la même commande et... CRASH.
> No matching provider found. Please specify box_version and box_arch.

Pourquoi cette différence de traitement ? Pourquoi Windows est-il l'élève difficile de la classe ? La réponse se trouve dans les entrailles de l'OS.

Pour comprendre, il faut revenir à la base. Linux et macOS sont des cousins : ils sont POSIX-compliant. Ils parlent la même langue (chemins de fichiers /, permissions, gestion des processus via fork/exec).

Windows est une bête différente (NTFS, chemins C:\, API Win32). Quand Vagrant essaie d'analyser le système pour "deviner" quoi faire, il se heurte à un mur de complexité sur Windows que Linux n'a pas.

Quand vous ne précisez rien dans le Vagrantfile, Vagrant doit faire un travail d'enquête (Inférence) :

Sur Linux / macOS :
Vagrant demande au noyau : "T'es qui ?".
Le noyau répond : "Je suis un Darwin arm64".
Vagrant regarde la Box : "J'ai une version compatible, je la prends."
👉 Succès automatique.
Sur Windows :
Vagrant fait face à plusieurs Hyperviseurs possibles (Hyper-V, VirtualBox, VMWare, WSL2). Les métadonnées système sont plus floues pour un outil né dans le monde Ruby/Linux.
Vagrant hésite : "Quelle architecture ? Quel Provider ? Quelle version exacte ?".
👉 Échec par prudence. Il vous demande de préciser.
  • Les Chemins de fichiers : Les métadonnées des Boxes sont stockées dans C:\Users\VotreNom\.vagrant.d\.... Les espaces ou caractères spéciaux dans les chemins Windows cassent souvent la lecture automatique des fichiers JSON de configuration.
  • L'Architecture : Windows ne rapporte pas son architecture (amd64 vs arm64) de la même manière standardisée que uname -m sous Unix. Vagrant ne peut pas garantir que la Box téléchargée tournera sur votre CPU.
  • Les Providers : Sur Windows, la cohabitation Hyper-V et VirtualBox est notoirement complexe. Vagrant a besoin de savoir explicitement quelle version de Box correspond à quel moteur de virtualisation.

Plutôt que de voir cela comme une contrainte Windows, voyez-le comme une discipline de reproductibilité.

En définissant ces variables, vous verrouillez votre environnement. Plus de "mise à jour magique" qui casse tout le lundi matin.

# Dans votre Vagrantfile
config.vm.box = "ubuntu/jammy64"
# Obligatoire pour Windows, recommandé pour tous :
config.vm.box_version = "202401.01.0"
config.vm.box_arch    = "amd64"

// RÉFÉRENCES OFFICIELLES :

[ EOF - Configuration Saved ]

Cygwin vs MSYS2 : Quel environnement choisir pour Windows ?

Cygwin vs MSYS2 : Quel environnement choisir pour Windows ?

> diff cygwin msys2 --brief_

Cygwin ou MSYS2 ? Mon arbitrage pour un Lab Kubernetes sous Windows

Par Nicolas DELAHAYE | v.1974 | Architecte Solution

CONTEXTE: Environnement Cross-Platform (Win/Linux)


Dans mon équipe, nous avons deux clans : les puristes Linux et les utilisateurs Windows. Pour mon projet de lab Kubernetes (3 nodes, cassables et reconstructibles en moins de 5 minutes), l'environnement doit tourner de manière identique partout.

Le choix de la virtualisation s'est imposé, et comme vous le savez, j'ai opté pour QEMU (voir mon article précédent). C'est en cherchant le portage de QEMU sur Windows que je suis tombé sur MSYS2. Alors que j'avais déjà Cygwin et WSL2, j'ai voulu creuser. Voici pourquoi j'ai fini par changer mon fusil d'épaule.

Cygwin est un monument. Son but : recréer un environnement Unix complet sous Windows via une couche de compatibilité (cygwin1.dll).

  • Forces : Collection immense d'outils, très proche d'un vrai Linux.
  • Faiblesses : Une couche d'émulation lourde qui impacte les performances. Les binaires produits sont "prisonniers" de la DLL Cygwin.

MSYS2 est arrivé avec une philosophie différente : fournir un shell Unix léger mais orienté vers le développement natif Windows.

  • Le Graal : Il utilise pacman (le gestionnaire de paquets d'Arch Linux). C'est rapide, moderne et propre.
  • Intégration : Parfait pour piloter Vagrant, Ansible et QEMU sans les frictions de compatibilité de Cygwin.
Cygwin MSYS2
Moyenne (Émulation) Excellente (Natif)
Setup.exe manuel Pacman (CLI)
Dépendants DLL 100% Windows natifs
Peu adapté Idéal

Pour mon lab piloté par Vagrant et Ansible, MSYS2 l'emporte car :

  1. Il ne nécessite pas de contraintes GPL lourdes sur les binaires.
  2. Il s'aligne avec les outils modernes (CMake, Ninja, Git).
  3. L'installation de QEMU y est d'une fluidité exemplaire.

// LE MOT DE L'ARCHITECTE :

Cygwin reste pertinent pour des scripts historiques ou des besoins POSIX très stricts. Mais aujourd'hui, pour monter des toolchains modernes et des pipelines DevSecOps robustes sur Windows, MSYS2 est le choix par défaut. C'est l'outil qui m'a permis de faire tenir mon lab Kubernetes dans ma poche (ou presque).

Mémento QEMU : Dompter vos VMs en ligne de commande (Guide)

Mémento QEMU : Dompter vos VMs en ligne de commande (Guide)

> man qemu-maintenance.sh_

Mémento : La maintenance QEMU en ligne de commande

Par Nicolas DELAHAYE | v.1974 | Architecture & Automation

OBJECTIF: Zéro interface graphique. 100% efficacité.


Installer QEMU sur son Mac via Brew, c'est une chose. Le piloter au quotidien sans s'emmêler les pinceaux, c'en est une autre. Voici mon "disque dur externe" de commandes pour gérer mes nodes Kubernetes sans passer par une GUI lourde.

Si vous utilisez QEMU seul ou via un wrapper, le plus simple pour voir ce qui tourne est de vérifier les processus systèmes (le bon vieux grep) :

$ ps aux | grep qemu-system

// Note : Si vous utilisez libvirt (souvent avec Vagrant) sur Linux, la commande est plus élégante : `virsh list --all`

Avant de lancer une VM, il faut un disque. Le format qcow2 est le standard : il est "thin provisioned" (il ne prend que la place réelle des données).

$ qemu-img create -f qcow2 mon-node-kube.qcow2 20G

Pas besoin de menu "Settings". Tout se passe dans les flags au lancement. Pour ajouter de la RAM ou des CPU à la volée :

$ qemu-system-x86_64 -m 4G -smp 2 -hda mon-node-kube.qcow2

-m 4G : Alloue 4 Go de RAM.
-smp 2 : Alloue 2 cœurs CPU.

L'avantage du format qcow2, c'est qu'il gère les snapshots en interne. Très utile avant de faire une mise à jour risquée sur un cluster Kubernetes.

Créer un point de restauration :

$ qemu-img snapshot -c backup_stable mon-node-kube.qcow2

Revenir en arrière :

$ qemu-img snapshot -a backup_stable mon-node-kube.qcow2

Ici, pas de corbeille. On supprime l'image disque et, si elle était enregistrée dans libvirt, on l'efface de la base.

$ rm mon-node-kube.qcow2
$ # Ou via virsh :
$ virsh undefine mon-node-kube

// RÉFLEXION DE SENIOR :

Maîtriser ces commandes, c'est s'assurer que votre infrastructure est reproductible. Une fois que vous connaissez ces flags, vous pouvez les mettre dans un script Bash ou un playbook Ansible. C'est ça, le vrai DevSecOps : transformer la maintenance manuelle pénible en un processus automatisé et robuste.

[ LOGOUT - Session Ended ]