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.

Comment générer automatiquement un inventaire et propager les clés SSH pour piloter un cluster complet depuis une seule VM de contrôle avec Vagrant et Ansible

Comment générer automatiquement un inventaire et propager les clés SSH pour piloter un cluster complet depuis une seule VM de contrôle avec Vagrant et Ansible

> ./deploy_cluster.sh --with-control-node_

Vagrant & Ansible : L'Art du "Control Node" Automatisé

Par Nicolas DELAHAYE | v.1974 | Architecte Solution

STATUS: SSH_KEYS_DISTRIBUTED


C'est un mur que tout ingénieur DevOps rencontre tôt ou tard. Vous voulez construire un lab réaliste : Une VM "Maître" (Control Node) qui configure plusieurs VMs "Esclaves" (Workers) via Ansible.

Le problème ? Vagrant est conçu pour isoler. Par défaut, il génère une clé SSH unique par machine. Résultat : votre VM Maître ne peut pas se connecter aux Workers. La solution naïve consiste à lancer ansible_local sur chaque machine indépendamment, mais c'est un anti-pattern qui ne simule pas la réalité d'un cluster.

// Pour comprendre en détail pourquoi l'architecture ansible_local est souvent incontournable (surtout sur Windows), je vous invite à lire mon comparatif : Vagrant : Ansible vs Ansible_Local et le mythe du Control Node.

Pour réussir une Vagrant Ansible Inventory propre et automatisée, nous devons inverser la logique : générer une clé de confiance unique et construire l'inventaire dynamiquement.

Au lieu de laisser Vagrant gérer ses clés, nous allons créer une paire de clés "Cluster" sur l'hôte (votre PC) et la distribuer.

Le Flux Architectural :
1. Host : Génère une paire de clés SSH (Privée/Publique).
2. Vagrant : Injecte la clé Publique dans tous les Workers.
3. Vagrant : Monte la clé Privée dans le Control Node.
4. Ruby : Génère le fichier d'inventaire .ini automatiquement.

Voici le code complet. Il fait tout le travail sale à votre place. Pas de bidouille manuelle.

Note : Ce script écrit le fichier d'inventaire sur votre machine hôte pour qu'il soit accessible dans la VM via le dossier partagé /vagrant. Si vous rencontrez des problèmes de performance ou de permissions sur ce partage, vérifiez votre configuration de montage (voir mon article : Vagrant Synced Folders : Le casse-tête Windows vs Linux).

# 1. Génération de la clé Cluster (si absente)
KEY_PATH = ".vagrant/cluster_key"
unless File.exist?(KEY_PATH)
  system("ssh-keygen -t ed25519 -f #{KEY_PATH} -N '' -C 'vagrant-cluster'")
end
CLUSTER_PUBKEY = File.read("#{KEY_PATH}.pub")

# 2. Préparation de l'inventaire dynamique
inventory_content = ["[all:vars]", 
                     "ansible_user=vagrant", 
                     "ansible_ssh_private_key_file=/vagrant/#{KEY_PATH}", 
                     "ansible_ssh_common_args='-o StrictHostKeyChecking=no'", 
                     "", "[controllers]", "control-node ansible_host=192.168.56.10",
                     "", "[workers]"]

Vagrant.configure("2") do |config|
  
  # --- DEFINITION DES WORKERS ---
  (1..2).each do |i|
    ip = "192.168.56.2#{i}"
    name = "worker#{i}"
    
    config.vm.define name do |node|
      node.vm.box = "ubuntu/jammy64"
      node.vm.network "private_network", ip: ip
      node.vm.hostname = name
      
      # Injection de la clé publique
      node.vm.provision "shell", inline: "echo '#{CLUSTER_PUBKEY}' >> /home/vagrant/.ssh/authorized_keys"
      
      # Ajout à l'inventaire en mémoire
      inventory_content << "#{name} ansible_host=#{ip}"
    end
  end

  # --- DEFINITION DU CONTROL NODE ---
  config.vm.define "control-node" do |node|
    node.vm.box = "ubuntu/jammy64"
    node.vm.network "private_network", ip: "192.168.56.10"
    node.vm.hostname = "control-node"

    # Injection de la clé publique (pour qu'il puisse se connecter à lui-même si besoin)
    node.vm.provision "shell", inline: "echo '#{CLUSTER_PUBKEY}' >> /home/vagrant/.ssh/authorized_keys"

    # Installation d'Ansible sur le Control Node uniquement
    node.vm.provision "shell", inline: "apt-add-repository ppa:ansible/ansible -y && apt-get update && apt-get install ansible -y"

    # 3. Écriture du fichier d'inventaire sur le disque Hôte
    # Il sera accessible dans la VM via /vagrant/inventory.ini
    File.write("inventory.ini", inventory_content.join("\n"))

    # 4. Lancement du Playbook (Mode Parallel Execution)
    node.vm.provision "ansible_local" do |ansible|
      ansible.playbook = "playbook.yml"
      ansible.inventory_path = "/vagrant/inventory.ini"
      ansible.limit = "all"
      ansible.verbose = true
    end
  end
end

Avec cette configuration :

  • Zéro Friction : Un simple vagrant up construit le cluster, les clés et lance Ansible.
  • Isolation Propre : Votre machine Windows/Mac ne lance pas Ansible. C'est la VM "control-node" qui le fait, via le montage /vagrant.
  • Scalabilité : Changez (1..2) en (1..10) et votre inventaire se met à jour automatiquement.

C'est la différence entre "bidouiller des scripts" et faire de l'Infrastructure as Code. Vous respectez le principe DRY (Don't Repeat Yourself) et vous préparez un environnement qui ressemble à 99% à une production réelle (Bastion + Private Subnet).

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 ]

CVE, CVSS, EPSS : Le Guide Ultime pour Prioriser vos Vulnérabilités

CVE, CVSS, EPSS : Le Guide Ultime pour Prioriser vos Vulnérabilités

> ./explain_vuln_metrics.sh --verbose --deep-dive_

CVE, CVSS et EPSS : Comprendre, Trier et Prioriser

Par Nicolas DELAHAYE | v.1974 | DevSecOps & Architecture

STATUS: CRITICAL_KNOWLEDGE_LOADED


Le monde de la cybersécurité ne manque pas d'acronymes. Mais s'il y a bien une trinité que tout ingénieur, développeur ou architecte doit maîtriser pour ne pas sombrer sous le poids de la dette technique, c'est celle-ci : CVE, CVSS et EPSS.

Au quotidien, nos scanners CI/CD crachent des rapports rouges sang. Sans une compréhension fine de ces métriques, vous allez patcher des fantômes pendant que votre infra brûle par une porte dérobée que vous aviez classée "Medium". Voici le décodage complet.

Définition : CVE signifie Common Vulnerabilities and Exposures.

Imaginez le CVE comme le numéro de sécurité sociale d'un bug de sécurité. C'est un identifiant unique, international, géré par le programme CVE (MITRE) et ses partenaires (CNA - CVE Numbering Authorities).

Structure d'un CVE :
CVE-2024-12345
  • CVE : Le préfixe standard.
  • 2024 : L'année d'attribution de l'ID (pas forcément l'année de découverte).
  • 12345 : Un numéro séquentiel unique.

À quoi ça sert ? À parler le même langage. Quand je dis "Log4Shell", c'est flou. Quand je dis CVE-2021-44228, tous les outils de la planète (firewalls, scanners, bases de données) savent exactement de quelle ligne de code on parle.

Avoir un nom (CVE), c'est bien. Savoir si c'est dangereux, c'est mieux. C'est le rôle du Common Vulnerability Scoring System.

Attention : Le CVSS mesure la sévérité technique, pas le risque pour VOTRE entreprise. Il répond à la question : "Si cette faille est exploitée, quels sont les dégâts potentiels ?"

Le thermomètre (Score v3.1 / v4.0) :

  • [0.0 - 3.9] FAIBLE : Impact minime.
  • [4.0 - 6.9] MOYEN : Nécessite souvent une action locale ou des privilèges.
  • [7.0 - 8.9] ÉLEVÉ : Impact sérieux, souvent exploitable à distance.
  • [9.0 - 10.0] CRITIQUE : "Game Over". Prise de contrôle totale, souvent sans authentification.

Un score CVSS n'est pas un chiffre magique, c'est une formule complexe basée sur un Vecteur. Exemple pour Log4Shell :

CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H

Décryptage : AV:N (Réseau/Network) + AC:L (Complexité Faible) + PR:N (Aucun privilège requis) + C/I/A:H (Confidentialité/Intégrité/Dispo : Impact Haut). C'est le pire scénario possible.

C'est ici que la modernité entre en jeu. Vous avez 100 vulnérabilités "Critiques" (CVSS 9.8). Par laquelle commencer ?

Le CVSS a une limite : il ne vous dit pas si des pirates exploitent réellement la faille. Peut-être que la faille est théoriquement catastrophique, mais techniquement impossible à exploiter sans un alignement des planètes improbable.

L'EPSS (Exploit Prediction Scoring System), géré par FIRST.org, répond à la question : "Quelle est la probabilité que cette faille soit exploitée dans les 30 prochains jours ?"

La logique de triage moderne :
Une CVE avec un CVSS de 9.8 mais un EPSS de 0.01% (peu probable) est MOINS prioritaire qu'une CVE avec un CVSS de 7.5 mais un EPSS de 95% (attaque en cours massive).
La question posée Type de donnée
CVE "C'est quoi le problème ?" Identifiant unique (Catalogue)
CVSS "À quel point ça fait mal ?" Score de gravité (0-10)
EPSS "Vais-je me faire attaquer ?" Probabilité (0-100%)

Pour extraire ces données de vos images Docker ou de vos serveurs, vous avez besoin d'outils. Voici le Top 3 Open Source.

A. Aqua Trivy (Le Couteau Suisse)

C'est mon favori. Rapide, complet, sans base de données à gérer.

$ trivy image python:3.9-alpine
# Scan aussi le filesystem, les repos git et Kubernetes
$ trivy fs --scanners vuln,secret,config .

B. Grype & Syft (Le Duo Précis)

Développé par Anchore. Syft génère le SBOM (Software Bill of Materials) et Grype le scanne.

$ syft packages docker:nginx:latest -o json > sbom.json
$ grype sbom:./sbom.json

C. Clair (Le Pionnier)

Plus lourd, nécessite une base de données Postgres, mais très utilisé dans les registres d'entreprise comme Quay.io.

Vous scannez votre image de production. Trivy remonte la CVE-2023-XXXX.

Analyse :

  • CVSS : 9.1 (Critique) -> Panique à bord ?
  • Vecteur : AV:N (Réseau) mais AC:H (Complexité Haute).
  • EPSS : 0.02% (Très faible).
  • Contexte : La librairie vulnérable est présente dans l'image, mais elle n'est utilisée que pour compiler des assets statiques et n'est pas chargée au runtime.

Décision DevSecOps :

Malgré le CVSS rouge vif, le risque réel est quasi nul. On peut accepter le risque temporairement ou supprimer la librairie de l'image finale (multi-stage build), plutôt que de bloquer la mise en production pour un patch urgent.
C'est ça, la puissance de l'analyse contextuelle combinée à l'EPSS.

// RESSOURCES OFFICIELLES :

[ EOF - Security Scan Complete ]