KVM : introduction à la mise en oeuvre d’un hyperviseur

En cours de rédaction …

Nous allons voir comment mettre en œuvre la fonction hyperviseur sur son pc sous Linux, ici Ubuntu 20.04 LTS, et également les divers outils qui permettent de gérer des VM.

I Introduction

Le module KVM signifie « Kernel-based Virtual Machine ». Il est intégré dans le noyau Linux depuis la version 2.6.20. L’hyperviseur est dit de type « 1 » car il est au plus proche du matériel. Les hyperviseurs de type « 2 » ont une couche logicielle supplémentaire, comme par exemple VirtualBox.

KVM va fonctionner si les processeurs physiques supportent la virtualisation et que les flags du processeurs soient activés. Pour les processeurs Intel on va parler de « VT-x » et pour les processeurs AMD de « SVM ». Bien regarder dans le BIOS si ces options existent et soient activées.

Sous Linux pour vérifier :

lscpu | grep Virtualisation
Virtualisation :                        VT-x

ou par ce biais :

xavior@mon_pc:~$ grep -c -E "vmx|svm" /proc/cpuinfo
16

ou si KVM peut être utilisé :

xavior@mon_pc:~$ kvm-ok 
INFO: /dev/kvm exists
KVM acceleration can be used

KVM n’est pas utilisable en l’état. Il faudra passer des outils tiers tels que libvirt et QEMU.

« libvirt » est un ensemble d’outils (API, deamon, outils) qui permet de manager différents hyperviseurs tels que KVM, QUEMU, Xen, VMWARE, LXC et d’autres.

QEMU est quant à lui un émulateur par défaut. Il permet ainsi d’émuler une architecture processeur différente que le type de processeur de l’ordinateur physique. Il peut être considéré comme un hyperviseur de type « 22. En revanche, si les types de processeurs sont identiques, QEMU utilisera alors KVM et obientra de ce fait de meilleures performances. Dans ce mode il bascule dans le monde des hyperviseurs de type « 1 ».

Le schéma ci-dessous permet de mieux comprendre les interactions entre les outils, modules et logiciels :

Ainsi on pourrait résumer de la manière suivante :

• KVM fait office d’hyperviseur ;
• QUEMU peut être considéré comme un client pour manager les VM ;
• Libvirt qui lie KVM et QEMU.

II Installation

II.1 Installation et explications

Après avoir vérifié que le processeur du PC supporte les instructions de virtualisation et qu’elle soient activées dans le bios, nous allons pouvoir commencer l’installation des différents outils.

Pour installer les premières bases de l’hyperviseur :

sudo install -y qemu qemu-kvm libvirt-daemon bridge-utils virt-manager virtinst

Les packages installés sont :

• qemu : le logiciel d’émulation ;
• qemu-kvm : la possibilité à quemu d’utiliser KVM ;
• libvirt-deamon : le service libvirt ;
• bridge-utils : un outil permettant de gérer la partie réseau pour les VM ;
• virt-manager : un outil graphique permettant de voir et de gérer (création/modification/suppression) les VM ;
• virtinst : un outil en ligne de commande permettant de créer des VM à partir de modèles, de cloner des VM, de créer des VM à partir de fichiers xml ou de convertir des formats de VM.

II.2 Vérification

La première vérification à effectuer est que l’utilisateur soit dans le groupe « libvirt » :

xavior@mon_pc:~$ id
uid=1000(xavior) gid=1000(xavior) groupes=1000(xavior),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),120(lpadmin),132(lxd),133(sambashare),139(ubridge),140(libvirt)

Si ce n’est pas le cas, il faudra ajouter l’utilisateur dans ce groupe.

Si pas déjà fait, on va démarrer et inscrire le service au démarrage :

sudo systemctl start libvirtd
sudo systemctl enable libvirtd

III Création de notre première VM

III.1 Création via l’outil graphique « virt-manager »

Nous allons créer notre première VM avec l’outil graphique « virt-manager ». Au préalable il faut disposer d’image ISO des systèmes que l’on veut installer.

Pour lancer l’outil :

virt-manager

Ce qui fait apparaître l’outil graphique suivant :

Cliquer sur fichier puis sur « Nouvelle machine virtuelle » :

L’écran suivant apparaît :

Sélectionner « Média d’installation local » puis cliquer sur « Suivant » :

Renseigner à la main le chemin de l’image ISO puis taper sur « Entrée ». Le système d’exploitation devrait être reconnu et renseigné (bas de la fenêtre). Cliquer sur  » Suivant » :

Définir la quantité de RAM et le nombre de CPU, puis cliquer sur « Suivant » :

Définir la taille de l’image disque pour la VM puis cliquer sur « Suivant » :

Définir un nom pour la VM puis cliquer sur « Terminer » :

La VM est créée avec les paramètres demandés puis l’écran de la VM est affichée.

A chacun de définir ses paramètres d’installation suivant le système d’exploitation choisi. Ce qui nous donne dans notre cas et au final la VM suivante :

III.2 Informations et constations

Sans rien faire de particulier, la VM est fonctionnelle et a du réseau :

• elle accède à internet via la connexion du PC physique : par défaut un réseau virtuel de type NAT est mis en oeuvre ;
• le système d’exploitation a une adresse IP : par défaut un DHCP est présent et il délivre des adresses IPV4 et IPV6.

Le fichier image de la VM est positionné dans le répertoire « /var/lib/libvirt/images » :

xavior@mon_pc:/var/lib/libvirt/images$ sudo ls -alh
total 8,7G
drwx--x--x 2 root root 4,0K mars  19 20:41 .
drwxr-xr-x 7 root root 4,0K févr. 18 19:27 ..
-rw------- 1 root root  26G mars  19 21:00 KVM_ubuntu20.04.qcow2

On remarque que :

• le format de l’image est de type « qcow2 » (QEMU Copy On Write) ;
• la taille du fichier n’est pas dynamique ;
• la taille de l’écran du système d’exploitation n’est pas dynamique en fonction de la taille de la fenêtre de visualisation de la vm ;
• pas de copier/coller traversant le VM ;
• etc.

Oui les fonctionnalités « friendly » disponibles dans Virtualbox ou VmWare Player ne semblent pas être disponibles (le redimensionnement est activable dans les options) . Mais l’objectif final est avant tout d’héberger des serveurs et pour lesquelles ces fonctions ne seront pas utilisées souvent. On préférera des accès par SSH ou via RDP sinon.

Avant de continuer, il est souhaitable de parcourir et de regarder les options et préférences du « gestionnaire de machines virtuelles » ainsi que les propriétés pour commencer à s’approprier l’outil : partie réseau, disque, gestion des instantanés, propriétés de la VM, ajout périphériques, etc.

III.3 Création via l’outil de commande

III.3.1 Introduction

Nous allons voir comment créer une VM en ligne de commande. Il y a plusieurs manière de faire cette opération. Nous allons dans notre cas créer une machine virtuelle avec l’outil « virt-install ». Mais avant nous allons nous occuper du réseau. Pour cela nous allons utiliser l’outil « virsh ».

Cet outil utilise la librairie libvirt et permet de gérer les domaines suivants :

• le domaine KVM (connexion, association disque, mémoire, config QEMU, etc.) ;
• le monitoring de KVM ;
• les hôtes et leh superviseur ;
• les points d’arrêt (chekpoints) ;
• les interfaces réseaux (interfaces) ;
• les filtres réseaux (network filter) ;
• le type de réseau (ex : type NAT et caractéristiques demandées) ;
• les Devices ;
• la sécurité (Secret) ;
• les snapshots ;
• les backup ;
• les pools ;
• les espaces de stockage (Storage volume).

Nous n’allons pas voir l’ensemble des domaines mais seulement ceux qui vont nous permettre de créer un réseau virtuel. Ainsi nous aborderons dans un premier temps la partie réseau puis la création proprement dite d’une VM.

III.3.2 Partie réseau

Il existe un contexte réseau virtuel par défaut qui sera utilisé par les VM. Pour prendre connaissance de ces réseaux, on peut utiliser la commande suivante :

xavior@mon_pc:~$ virsh net-list --all 
 Name      State    Autostart   Persistent
--------------------------------------------
 default   active   yes         yes

Ici le réseau virtuel porte le nom de « default ». Ce réseau est actif (state) et il s’activera automatiquement (autostart).

Pour définir ces états :

virsh net-start default
virsh net-autostart default

Pour voir la configuration de ce réseau et ses caractéristiques :

virsh net-dumpxml default

Ce qui donne :

<network connections='1'>
  <name>default</name>
  <uuid>eddf420a-10ca-45c5-abbe-4812c7e1d16a</uuid>
  <forward mode='nat'>
    <nat>
      <port start='1024' end='65535'/>
    </nat>
  </forward>
  <bridge name='virbr0' stp='on' delay='0'/>
  <mac address='52:54:00:8d:5d:a7'/>
  <ip address='192.168.122.1' netmask='255.255.255.0'>
    <dhcp>
      <range start='192.168.122.2' end='192.168.122.254'/>
    </dhcp>
  </ip>
</network>

Ainsi nous remarquons :

• qu’un réseau de type NAT est monté ;
• que cela utilise un pont réseau nommé « virbr0 » avec un mac address spécifique ;
• une classe réseau 192.168.122.0 est utilisée avec comme passerelle 192.168.122.1 ;
• un DHCP est disponible est qui délivre des adresses IP de 192.168.122.2 à 254.

Nous allons créer notre propre réseau. Pour cela il faut créer un fichier xml et nous partirons du modèle du réseau « default ». Notre fichier xml sera :

<network connections='1'>
  <name>mon_reseau_nat</name>
  <forward mode='nat'>
    <nat>
      <port start='1024' end='65535'/>
    </nat>
  </forward>
  <bridge name='virbr1' stp='on' delay='0'/>
  <mac address='52:54:00:8d:5d:a8'/>
  <ip address='192.168.150.254' netmask='255.255.255.0'>
    <dhcp>
      <range start='192.168.150.50' end='192.168.150.220'/>
    </dhcp>
  </ip>
</network>

Ce fichier, nommé « mon_reseau.xml » :

• ne prend pas en compte la balise uuid : ce sera définit à la création du réseau ;
• porte un nom qui nous est propre ;
• utilise un bridge propre à lui avec une mac address différente que le bridge du reseau « default » ;
• définit une gateaway en 192.168.150.254 et un réseau 192.168.150.0 ;
• active le DHCP pour les adresses IP de 192.168.150.50 à 220.

Ainsi pour l’ajouter dans KVM :

xavior@mon_pc:~$ virsh net-define mon_reseau.xml 
Network mon_reseau_nat defined from mon_reseau.xml

Pour vérifier :

xavior@mon_pc:~$ virsh net-list --all
 Name             State      Autostart   Persistent
-----------------------------------------------------
 default          active     yes         yes
 mon_reseau_nat   inactive   no          yes

Nous allons activer le réseau et désactiver le « default » :

xavior@mon_pc:~$ virsh net-start mon_reseau_nat 
Network mon_reseau_nat started

xavior@mon_pc:~$ virsh net-autostart mon_reseau_nat 
Network mon_reseau_nat marked as autostarted

xavior@mon_pc:~$ virsh net-destroy default 
Network default destroyed

Ce qui donne :

xavior@xavior-Latitude-7490:~$ virsh net-list --all
 Name             State      Autostart   Persistent
-----------------------------------------------------
 default          inactive   yes         yes
 mon_reseau_nat   active     yes         yes

III.3.3 Création d’une VM

Après avoir créé notre réseau, nous allons maintenant créer la VM en utilisant la commande « virt-install » qui sera la suivante :

xavior@mon_pc:~$ virt-install -n ubuntu_kvm_shellcmd --description "VM Ubuntu par commande shell" --ram=6000 --vcpus=2 --disk=/var/lib/libvirt/images/ubuntu_shellcmd.qcow2,bus=virtio,size=20 --network bridge=virbr1 --location /home/xavior/Documents/Dev/Machines_virtuelles/ISO/ubuntu-20.04.3-desktop-amd64.iso --vnc --noautoconsole --extra-args console=ttyS0

Explication des options :

• -n : nom de la vm
• — description : description de la VM
• –ram : quantité de mémoire vive (en Go)
• –vcpus : nombre de cpu de la VM
• –disk : chemin où sera le fichier de la VM
• –network : choix du réseau virtuel
• — location : démarer avec un iso dans le lecteur de cd-rom
• — affichage de l’écran via VNC
• –noautoconsole : ne lance pas la console de l’hôte

Ce qui donne :

Début d’installation…
Récupération du fichier vmlinuz…                                                                                                        | 9.7 MB  00:00:00     
Récupération du fichier initrd…                                                                                                         |  94 MB  00:00:00     
Allocation de « virtinst-k7z0hw7z-vmlinuz »                                                                                             | 9.7 MB  00:00:00     
Transfert de virtinst-k7z0hw7z-vmlinuz                                                                                                  | 9.7 MB  00:00:00     
Allocation de « virtinst-htw7z3d9-initrd »                                                                                              |  94 MB  00:00:00     
Transfert de virtinst-htw7z3d9-initrd                                                                                                   |  94 MB  00:00:01     
Allocation de « ubuntu_shellcmd.qcow1 »                                                                                                 |  20 GB  00:00:00     
Installation du domaine encore en cours. Vous pouvez vous reconnecter à 
la console pour terminer le processus d’installation.

A ce stade la VM est créée puis a été lancée et a booté sur le CD-ROM et attend les interactions utilisateur.

Voici la fin de la première installation d’un VM.

IV Management des VM

IV.1 Introduction

Nous allons voir quelques commandes qui permettent de manager les VM en lignes de commandes.

IV.2 Management des VM

Lister les VM et voir leur état de fonctionnement :

xavior@xmon_pc:/var/lib/libvirt$ virsh list --all
 Id   Name                  State
-------------------------------------
 8    KVM_ubuntu20.04       running
 13   ubuntu_kvm_shellcmd   running

Actions usuelles :

• arrêt (gracieux) : virsh shutdown ubuntu_kvm_shellcmd
• arret forcé : virsh destroy ubuntu_kvm_shellcmd
• démarrage : virsh start ubuntu_kvm_shellcmd
• mettre en pause : virsch suspend ubuntu_kvm_shellcmd
• enlever la pause : virsh resume ubuntu_kvm_shellcmd
• supprimer une VM : virsh undefine ubuntu_kvm_shellcmd && virsh destroy ubuntu_kvm_shellcmd

Obtenir des infos sur la VM :

xavior@mon_pc:/var/lib/libvirt$ virsh dominfo ubuntu_kvm_shellcmd 
Id:             18
Name:           ubuntu_kvm_shellcmd
UUID:           78fee9e5-c681-4d03-828d-a6bc06807b70
OS Type:        hvm
State:          running
CPU(s):         2
CPU time:       77,5s
Max memory:     6144000 KiB
Used memory:    6144000 KiB
Persistent:     yes
Autostart:      disable
Managed save:   no
Security model: apparmor
Security DOI:   0
Security label: libvirt-78fee9e5-c681-4d03-828d-a6bc06807b70 (enforcing)

Utilisation des snaphots :

Créer un snapshot :

xavior@mon_pc:/var/lib/libvirt$ virsh snapshot-create-as ubuntu_kvm_shellcmd --name "snapshot_avant_install" --description "pas encore installé"
Domain snapshot snapshot_avant_install created

Lister les snapshots :

xavior@mon_pc:/var/lib/libvirt$ virsh snapshot-list ubuntu_kvm_shellcmd 
 Name                     Creation Time               State
---------------------------------------------------------------
 snapshot_apres_install   2022-03-20 18:17:47 +0100   running
 snapshot_avant_install   2022-03-20 18:15:10 +0100   running

xavior@mon_pc:/var/lib/libvirt$ virsh snapshot-list ubuntu_kvm_shellcmd --tree
snapshot_avant_install
  |
  +- snapshot_apres_install

Revenir sur l’état d’un snapshot :

virsh snapshot-revert ubuntu_kvm_shellcmd snapshot_avant_install

Supprimer un snapshot

Faire un clone simple (VM arrétée) :

xavior@mon_pc:/var/lib/libvirt$ virsh snapshot-delete ubuntu_kvm_shellcmd --snapshotname snapshot_apres_install 
Domain snapshot snapshot_apres_install deleted

Cloner des vm :

Pour effectuer un clone rapidement :

xavior@mon_pc:/var/lib/libvirt$ virt-clone --original ubuntu_kvm_shellcmd --auto-clone
Allocation de « ubuntu_shellcmd-clone.qcow2 »                                                                                             |  20 GB  00:00:00     

Le clone « ubuntu_kvm_shellcmd-clone » a été créé.

Faire un clone en spécifiant le nom du clone final :

xavior@mon_pc:/var/lib/libvirt$ virt-clone --original ubuntu_kvm_shellcmd --name "ubuntu_kvm_shellcmd_cloné" --auto-clone
Allocation de « ubuntu_shellcmd-clone-1.qcow2 »                                                                                           |  20 GB  00:00:00     

Le clone « ubuntu_kvm_shellcmd_cloné » a été créé.

Le clone d’une VM, et si l’on veut l’utiliser pour en faire une autre VM, nécessite de revoir un certain nombre de paramètres systèmes à définir (nom machine, compte, carte réseau, etc.). Afin d’éviter ce travail fastidieux il existe plusieurs techniques (nin vue en détail) :

• installer une image Ubuntu en mode OEM ;
• lancer l’installation d’une Ubuntu avec un fichier « pressed » (fichier permettant d’automatiser ;
• utiliser l’outil « virt-sysprep » qui permet de reseter un clone.

C’est ici que se termine cette introduction.