machine virtuelle
Tu veux isoler un système, tester un OS ou monter un serveur sans acheter du matériel ? Une machine virtuelle fait ça. Voilà comment tu la mets en place sur Linux avec KVM et libvirt — propre, rapide, sans fioritures.
---
Vereisten
Tu dois avoir :- Un processeur avec support Intel VT-x ou AMD-V (vérifiable via `/proc/cpuinfo`).
- Linux (testé sous Ubuntu 22.04 LTS et Fedora 38).
- Accès root ou via `sudo`.
- Paquets : `qemu-kvm`, `libvirt-daemon-system`, `libvirt-clients`, `bridge-utils`, `virtinst`, `virt-manager` (optionnel pour GUI).
- BIOS activé pour la virtualisation (souvent désactivé par défaut sur les portables).
---
1. Vérifie que ton CPU supporte la virtualisation
Avant de continuer, assure-toi que ton matériel peut faire le job. Si tu sautes cette étape, tu perds une heure sur un bug évitable.```bash egrep -c '(vmx|svm)' /proc/cpuinfo ```
- Résultat > 0 ? Bonne nouvelle : ton CPU supporte la virtualisation.
- Résultat 0 ? Active-la dans le BIOS, ou change de machine.
Si tu vois des lignes comme `kvm: module loaded`, KVM est prêt.
---
2. Installe les outils de virtualisation
On installe le socle : KVM pour l’exécution, libvirt pour la gestion, virtinst pour créer des VMs en CLI.Sur Debian/Ubuntu :
```bash sudo apt update && sudo apt install -y qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils virtinst ```
Sur Fedora/RHEL :
```bash sudo dnf install -y @virtualization ```
Puis active et lance le service :
```bash sudo systemctl enable --now libvirtd ```
Sans `libvirtd` actif, aucune commande `virsh` ou `virt-install` ne fonctionnera. C’est le moteur.
---
3. Ajoute ton utilisateur au groupe libvirt
Sinon, chaque commande te demandera `sudo`. C’est chiant. Corrige ça :```bash sudo usermod -aG libvirt $(whoami) ```
Déconnecte-toi et reconnecte-toi. Sinon, le groupe n’est pas chargé.
---
4. Télécharge une image ISO
Choisis un système. Ici, on prend Ubuntu Server 22.04 LTS — stable, bien documenté, supporté 5 ans.```bash wget https://releases.ubuntu.com/22.04/ubuntu-22.04.4-live-server-amd64.iso -O ~/iso/ubuntu-server-22.04.iso ```
Crée le dossier :
```bash mkdir -p ~/iso ```
Tu peux prendre Fedora, Debian, ou même Windows. Mais vérifie la licence. Une ISO volée, c’est lent, instable, et tu n’auras pas d’updates.
---
5. Crée le stockage pour la VM
Les disques durs virtuels sont des fichiers. On les met dans un pool de stockage géré par libvirt.Crée un dossier :
```bash sudo mkdir -p /var/lib/libvirt/images ```
Définis un pool de stockage :
```bash sudo virsh pool-define-as --name default --type dir --target /var/lib/libvirt/images sudo virsh pool-start default sudo virsh pool-autostart default ```
Ce pool permet à libvirt de gérer les images disque. Sans ça, tu devras tout faire à la main — pas efficace.
---
6. Crée la machine virtuelle
On utilise `virt-install` pour tout paramétrer en une commande.```bash sudo virt-install \ --name ubuntu-vm \ --vcpus 2 \ --memory 2048 \ --disk size=20 \ --os-variant ubuntu22.04 \ --cdrom ~/iso/ubuntu-server-22.04.iso \ --network network=default \ --graphics none \ --console pty,target_type=serial ```
Explication :
- `--name` : nom de la VM.
- `--vcpus 2` : 2 cœurs virtuels. Pas plus que ton CPU physique.
- `--memory 2048` : 2 Go de RAM. Trop ? La VM rame. Trop peu ? Elle plante.
- `--disk size=20` : disque de 20 Go en format QCOW2 (dynamique).
- `--os-variant` : optimise les paramètres pour Ubuntu 22.04. Si tu mets `generic`, c’est moins performant.
- `--cdrom` : l’ISO à monter.
- `--network` : connecte à NAT par défaut. Pour du bridging, c’est plus compliqué — mais plus rapide.
- `--graphics none` : pas d’interface graphique. On installe en mode console.
---
7. Connecte-toi à la console d’installation
Puisque `--graphics none` est activé, tu dois attacher la console :```bash sudo virsh console ubuntu-vm ```
Appuie sur Entrée. Si tu ne vois rien, la VM est peut-être en pause.
Pour quitter la console : Ctrl + ]
L’installation commence. Suit les étapes : langue, réseau, mot de passe, etc. Quand c’est fini, le système redémarre.
---
8. Démarre et gère la VM
Après l’installation, la VM s’éteint. Redémarre-la :```bash sudo virsh start ubuntu-vm ```
Connecte-toi :
```bash sudo virsh console ubuntu-vm ```
Tu es dans ta VM. C’est une machine complète, isolée, avec son propre noyau.
---
Vérification : est-ce que tout marche ?
Liste les VMs actives :```bash virsh list --all ```
Tu dois voir `ubuntu-vm` avec état `running`.
Vérifie les ressources :
```bash virsh dominfo ubuntu-vm ```
Ça montre CPU, RAM, OS, état. Si tout correspond à ta config, c’est bon.
---
Problèmes fréquents
1. Erreur : “KVM: disabled by BIOS”
Le plus courant. Va dans le BIOS/UEFI, cherche “Intel VT-x”, “AMD-V” ou “SVM Mode”. Active-le.Redémarre. Vérifie avec `egrep '(vmx|svm)' /proc/cpuinfo`.
2. Impossible de se connecter à la console (`virsh console`)
Parfois, la VM ne répond pas. Cause : pas de `serial console` activée dans le système invité.Solution : pendant l’installation, assure-toi que GRUB inclut `console=ttyS0` dans la ligne de boot.
Ou modifie `/etc/default/grub` :
```bash GRUB_CMDLINE_LINUX="console=ttyS0" ```
Puis :
```bash sudo update-grub ```
3. La VM démarre lentement ou plante avec peu de RAM
2048 Mo, c’est le minimum pour Ubuntu Server. En dessous, `systemd` peut échouer.Si tu veux moins de RAM, utilise Alpine Linux ou Debian netinst. Mais tu perds en commodité.
---
Tu veux plus ? Voilà les options.
Snapshot : sauvegarde instantanée
Avant un test risqué, fais un snapshot :```bash sudo virsh snapshot-create-as ubuntu-vm snap1 "Avant mise à jour" ```
Retour arrière :
```bash sudo virsh snapshot-revert ubuntu-vm snap1 ```
Les snapshots utilisent QCOW2. Ils sont rapides, mais pas une sauvegarde. Un crash disque, et tout saute.
Réseau bridgé : accès direct au LAN
Le NAT par défaut isole la VM. Pour qu’elle ait une IP sur ton réseau local :1. Crée une interface bridge (`br0`) sur l’hôte. 2. Associe ta carte réseau physique à `br0`. 3. Dans `virt-install`, remplace `--network network=default` par :
```bash --network bridge=br0,model=virtio ```
La VM obtient une IP via ton routeur. Mais si tu te trompes de config, tu perds le réseau sur l’hôte.
GPU pass-through ? Oublie.
C’est possible avec VFIO, mais ça demande un CPU, carte mère et GPU compatibles. Et deux écrans.Tu passes 3 jours à configurer. Pour quoi ? Jouer à Minecraft dans une VM ? Non.
---
Alternatives : pourquoi pas autre chose ?
Containers (Docker, Podman)
Plus léger. Un conteneur démarre en 0,2 seconde. Une VM en 10 secondes.Mais : pas d’OS différent. Tu ne mets pas Windows dans un conteneur sur Linux.
Et pas d’isolation forte. Un conteneur mal configuré peut toucher l’hôte.
Les VMs, c’est du fer. Les conteneurs, c’est du papier. Chaque outil a sa place.
VMware ou VirtualBox
Plus faciles à prendre en main. Surtout VirtualBox, avec son interface graphique.Mais : VirtualBox nécessite un kernel module propriétaire (`vboxdrv`). Sur un noyau récent, ça peut casser après une mise à jour.
Et VMware ? C’est fermé. Tu ne vois pas le code. Tu dépends d’un fournisseur.
KVM, c’est du noyau Linux. Il évolue avec le système. Pas de surprise.
---
Et la JVM dans tout ça ?
Tu as lu “Java Virtual Machine” et tu t’es dit : “C’est pareil ?”Non.
La JVM est une process VM. Elle exécute du bytecode Java. Elle vit dans un processus. Elle meurt quand l’appli meurt.
Une machine virtuelle système (comme ici) émule un hardware complet. Elle peut tourner n’importe quel OS.
Même nom, même principe d’isolation, mais échelle et usage différents.
---
Tu veux du cloud ? C’est pareil, en plus cher.
Amazon EC2, Google Compute, Azure — ce sont des VMs. Mais tu ne gères pas l’hyperviseur.Tu paies 50€/mois pour une instance. Chez toi, tu le fais pour le prix de l’électricité.
Mais tu n’as pas de SLA. Pas de redondance. Si ton serveur tombe en panne un dimanche soir, tu es seul devant ton terminal.
Zelf hosten klinkt prachtig, tot er iets omvalt op zondagavond half twaalf. Dan ben je geen klant die op de helpdesk wacht. Dan bén je de helpdesk.
---
Conclusion
Tu as maintenant une VM fonctionnelle, gérée par libvirt, basée sur KVM, intégrée à ton système Linux.Tu peux en créer dix autres. Automatiser avec Terraform. Brancher à un réseau privé. Prendre des snapshots.
Mais n’oublie pas : chaque VM consomme de la RAM, du CPU, du disque. Dix VMs inactives, c’est dix processus qui tournent.
Virtualisation, c’est puissance. Mais chaque couche ajoute de la complexité.
Et la complexité, un jour, te rattrape.