[Système] Machines virtuelles sous KVM

La virtualisation permet de gérer plusieurs machines d'architecture et de systèmes d'exploitation divers sur une seule machine physique.
L'interêt de la virtualisation réside dans l'économie tant en achat de machines qu'en électricité.
Parmi les diverses solutions de virtualisation, KVM est particulièrement intéressant en environnement Linux (car intégré au noyau) mais aussi sans interface graphique.

L'installation est simple (seulement quelques packages) et la configuration ne tient qu'en peu de lignes...

Pré-requis
Installation
Configuration
Exemples d'utilisation
Un script de lancement

Pré-requis :

Tout d'abord, afin de pouvoir utiliser KVM, il faut savoir si la machine hôte est compatible. En effet, la virtualisation via KVM nécessite un processeur assez récent. Pour le savoir il suffit d'exécuter la commande suivante, si une sortie est produite, la machine est apte à l'utilisation de KVM.

egrep '^flags.*(vmx|svm)' /proc/cpuinfo

Installation :

Tout d'abord, il faut installer les packages nécessaires au bon fonctionnement de KVM. Ces packages correpondent au KVM proprement dît, qemu (une autre solution de virtualisation partenaire de KVM fonctionnant aussi sous windows) et des utilitaires afin de construire un pont sur les interfaces réseaux (optionnel).

apt-get install kvm qemu bridge-utils uml-utilities

Les packages installés, il faut ajouter les modules nécessaires au noyau :

sudo modprobe kvm-amd

pour un processeur AMD,

 sudo modprobe kvm-intel

pour un processeur Intel.

Si KVM est utilisé par un utilisateur autre que root, il faut ajouter celui-ci au groupe KVM (ici l'utilisateur courant) :

  sudo adduser $USER kvm

Configuration :

La configuration se fait sur plusieurs niveaux :

disque dur virtuel
machine virtuelle
réseau

Le disque virtuel :

Il existe plusieurs méthodes pour créer un disque virtuel et parmi celles-ci 2 sont très simple : utiliser la commande dd ou bien qemu-img (installé grâce au package qemu précédement installé). Pour faire son choix, il suffit de connaître ses besoins.
dd construira un fichier de taille finie et pré allouée tant dis que qemu-img construit un fichier dont la taille s'étend selon les besoins (jusqu'à une taille limite préalablement déterminée).

Avec dd :

dd if=/dev/zero of=disk.img bs=1024 count=5000000

Quelques explications :

Ici nous créons un fichier

de 5Go ( 5000000 blocs (count) de 1024 octets (bs = block size);
rempli de 0 (if = input file);
qui se nomme disk.img (of = output file)

Avec qemu-img :

qemu-img est un utilitaire dédié à la création de de disques virtuels et par conséquent permet de gérer plusieurs "systèmes de fichiers". Parmi les systèmes de fichiers possible figurent qcow et qcow2. Que l'on choisisse l'un ou l'autre la ligne de commande permettant la création du disque virtuel reste la même :

qemu-img create disk.img -f qcow2 5G

Quelques explications :

Ici nous créons un disque

de 5Go (dernier paramètre);
de format qcow2 (-f qcow2);
qui se nomme disk.img

Afin de se décider entre quelle méthode est la plus efficace entre un fichier e taille préallouée et un disque virtuel de taille croissante, voici un mini comparatif.
Ce comparatif consiste en la création d'un fichier de 1 ou 2Go au sein d'une machine virtuelle ayant son disque créé avec dd ou qemu-img :

	1Go	2Go
dd	65s	137s
qemu-img / qcow	1465s	3042s
qemu-img / qcow2	61s	125s

Par conséquent, que l'on choisisse de créer le disque par dd ou qemu-img (en qcow2), il n'y a guère de différence et le choix se portera certainement plus sur la gestion du disque de la machine hôte.
Il est toute fois à noter que qemu_img permet de spécifier différentes options telles que la compression automatique des données dans le disque virtuel, la possibilité de faire des snapshots ou encore de faire des disques pour VirtualBox.

La machine virtuelle :

La configuration d'une machine virtuelle sous KVM se au lancement de celle-ci suivant les options fournies.
KVM permet de gérer beaucoup d'options mais nous ne verrons ici que les principales.

Le processeur :

Il est possible d'allouer un ou plusieurs processeurs physiques à la machines virtuelle, ceci permettant d'ajuster les performances de celle-ci.
Il faut bien faire attention de ne pas allouer plus de processeurs (toutes machines virtuelles confondues) qu'il n'y en a réellement si l'on ne veut pas avoir de perte de performance.
Le nombre de processeur est défini par l'option -smp (par exemple pour un pocesseur -smp 1).

La mémoire :

De même que pour le processeur, il est possible d'allouer la taille de la mémoire vive selon les besoins de la machines virtuelles (une base de données n'a pas les mêmes exigences qu'un serveur httpd par exemple).
Afin d'éviter le phénomène de swap de la machine hôte, il faut faire attention de lui laisser suffisamment de mémoire vive.
La taille de la mémoire vive est définie par l'option -m (par exemple pour 512Mo -m 512).

Le disque dur :

Il est possible d'affecter jusqu'à 2 disques durs via les options hda et hdb.
Pour affecter un disque dur, il suffit d'ajouer l'option -hda /data/vm/kvm/server/disk.img.

Le clavier :

Par défaut, c'est le clavier américain (qwerty) qui est configuré sous KVM. Il est toute fois possible de forcer un clavier particulier avec l'option -k (par exemple -k fr pour un clavier français azerty).

Le cdrom :

Pour utiliser une image de cdrom dans une machine virtuelle, il faut définir un lecteur grâce à l'option -cdrom, ceci permettant d'installer un système d'exploitation par exemple (-cdrom /data/iso/ubuntu-i86.iso).
Pour démarrer sur le cdrom, il faut ajouter l'option -boot d.

L'interface réseau :

Il n'est pas nécessaire de configurer le réseau pour qu'il soit fonctionnel. Par défaut, KVM crée un réseau privé entre sa machine hôte et la machine virtuelle permettant ainsi celle-ci d'accéder à internet.

Cette configuration par défaut ne permet cependant pas d'accéder au réseau local ni d'accéder à la machine virtuelle de manière distante.
Pour que ceci fonctionne, il faut configuré un pont entre une interface physique et la machine virtuelle.

Parce que le package bridge a été installé, il suffit de configurer le fichier /etc/network/inteface :

auto eth0
iface eth0 inet manual

auto br0
iface br0 inet static
        address 192.168.2.200
        netmask 255.255.255.0
        bridge_ports eth0 
        bridge_fd 9
        bridge_hello 2
        bridge_maxage 12
        bridge_maxwait 0
        bridge_stp off

Quelques explications :

Ici, l'interface physique eth0 sera l'interface sur laquelle le pont sera construit. Pour cela, elle est montée automatiquement en manual;
Le pont se nomme br0 et dispose d'une adresse statique (typiquement, l'adresse qu'aurait dûe avoir eth0)
bridge_ports définie l'interface physique utilisée comme support;
bridge_fd définie le temps (en seconde) entre les étapes d'écoute et d'apprentissage (lors de la connexion à un réseau fréquenté);
bridge_hello définit le temps entre 2 messages hello utilisés pour connaitre la topologie du pont (utile seulement si il y a plusieurs ponts définis dans le Spanning Tree);
bridge_maxage définit le temps maximum d'attente entre 2 messages hello. Passé ce délai, l'interface est désactivée (utile seulement si il y a plusieurs ponts définis dans le Spanning Tree);
bridge_maxwait définie le délai d'attente avant le lancement du pont;
bridge_stp_off désactive le Spanning Tree

Plus simplement, seules les options bridge_ports, bridge_fd et bridge_hello sont nécessaires.
Après un redémarrage des interfaces réseau, le pont est opérationnel :

sudo /etc/init.d/networking restart

Pour que plusieurs machines virtuelles partagent le même pont sans conflit, il faut générer pour chacune une adresse MAC différente. Pour créer une adresse MAC aléatoire, la ligne de commande suivante est suffisante :

echo "DE:AD:BE:EF:$(dd if=/dev/urandom count=1 2>/dev/null | md5sum | sed 's/^\(..\)\(..\)\(..\)\(..\).*$/\1:\2/')"

La création des interfaces virtuelles se faisant par script, il est nécessaire de configurer les interfaces TUN/TAP afin qu'un utilisateur autre que root puisse lancer les créer.
Pour ce faire, il faut changer les droits de l'interface /etc/net/tun en créant le fichier /etc/udev/rules.d/80-persistent-tun.rules :

KERNEL=="tun", NAME="net/%k",  GROUP="kvm", MODE="0660"

et en ajoutant les droit sudo à brctl, kvm et tunctl (via sudo sudoedit /etc/sudoers ) :

# /etc/sudoers

Defaults    env_reset

# Host alias specification

# User alias specification

# Cmnd alias specification
Cmnd_Alias KVM = /usr/bin/kvm, /usr/sbin/tunctl, /sbin/ifconfig, /usr/sbin/brctl

# User privilege specification
root    ALL=(ALL) ALL

# Les membres du groupe kvm peuvent utiliser les commandes définies dans KVM
%kvm    ALL=KVM

Enfin, il faut créer les scripts de montage / démontage de l'interface virtuelle.
Pour le montage /data/vm/kvm/bin/kvm.if-up :

#!/bin/sh

switch=br0
 
if [ -n "$1" ];then
        /usr/bin/sudo /usr/sbin/tunctl -u `whoami` -t $1
        /usr/bin/sudo /sbin/ip link set $1 up
        sleep 0.5s
        /usr/bin/sudo /usr/sbin/brctl addif $switch $1
        iptables -t nat -A POSTROUTING -s 192.168.2.0/24 -o wlan0 -j MASQUERADE
        echo "1" >/proc/sys/net/ipv4/ip_forward 
        exit 0
else
        echo "Error: no interface specified"
        exit 1
fi

Pour le démontage /data/vm/kvm/bin/kvm.if-down (optionel) :

#!/bin/sh
 
iptables -t nat -D POSTROUTING -s 192.168.2.0/24 -o wlan0 -j MASQUERADE

La configuration de la machine finie, il est maintenant possible d'utiliser le pont dans une machine virtuelle grâce aux options suivantes (à utiliser conjointement) :

-net nic,vlan=0,macaddr=$MAC où $MAC est une adresse MAC générée. Cette option permet de définir une adresse MAC à l'interface virtuelle connectée au VLAN 0
-net tap,vlan=0,script=/data/vm/kvm/bin/kvm.if-up,downscript=/data/vm/kvm/bin/kvm.if-down Cette option crée une interface TAP sur la machine hôte et définie les scripts à exécuter lors du montage et démontage de l'interface (par exemple la création des routes locales, des règles iptables, etc...)

VNC :

Si on exécute KVM dans un environnement sans interface graphique, il est possible d'indiquer à celui-ci d'ouvrir un port d'écoute VNC grâce à l'option -vnc port.
Ceci est particulièrement utile pour l'installation de la machine virtuelle par exemple...

Exemples d'utilisation :

Démarrage simple d'une machine avec un disque dur, un processeur et 512Mo de RAM :

sudo kvm -hda disk.img -smp 1 -m 512 -k fr

Ajout d'un cdrom :

sudo kvm -hda disk.img -smp 1 -m 512 -k fr -cdrom ubuntu.iso

Démarrage sur le cdrom :

sudo kvm -hda disk.img -smp 1 -m 512 -k fr -cdrom ubuntu.iso -boot d

Ajout d'une interface réseau (avec $MAC une adresse MAC générée) :

sudo kvm -hda disk.img -smp 1 -m 512 -k fr -net nic,vlan=0,macaddr=$MAC -net tap,vlan=0,script=/data/vm/kvm/bin/kvm.if-up,downscript=/data/vm/kvm/bin/kvm.if-down

Démarrage avec prise en charge réseau (installation réseau via PXE) :

sudo kvm -hda disk.img -smp 1 -m 512 -k fr -net nic,vlan=0,macaddr=$MAC -net tap,vlan=0,script=/data/vm/kvm/bin/kvm.if-up,downscript=/data/vm/kvm/bin/kvm.if-down -boot n

Prise en charge de VNC sur le port 5901 :

sudo kvm -hda disk.img -smp 1 -m 512 -k fr -cdrom ubuntu.iso -vnc 5901

Un script de lancement :

Bien que l'utilisation de KVM soit simple, elle peut devenir laborieuse a cause su grand nombre d'options possible.
Par conséquent, voici un exemple de script et d'arborescence pour la gestion de plusieurs machines virtuelles.
Chaque machine est définie par un répertoire content son disque virtuel et son fichier de configuration contenant le processeur, la mémoire, l'adresse MAC de l'interface virtuelle et le port VNC :

disk=disk.qcow2
cpu=1
ram=512
vnc=5901
macaddr1=DE:AD:BE:EF:ed:30

Quelques explications :

Les entrées obligatoires sont disk, cpu et ram

Le script de lancement :

#!/bin/bash

ROOT_DIR=/data/vm/kvm

function usage ()
{
        echo "Usage : $0 vm-name (pxe|cdrom iso)"

        if [ $(ls -l $ROOT_DIR | egrep '^d' | awk '{ print $8}' | wc -l) -eq 0 ];
        then
                echo "No existing virtual machine"
        else
                echo -n "With vm-name amoung ("

                for mydir in $(ls -l $ROOT_DIR | egrep '^d' | awk '{ print $8}')
                do
                        echo -n "$mydir|"
                done
                echo ")"
        fi
        exit 1
}

function test_conf () {
    FILE=$1
    VAR=$2
    
    if [ $(grep -c $VAR $FILE) -eq 1 ];
    then 
        echo true 
    else
        echo false
    fi
}

if [ $# -eq 0 ]
then
        usage
fi

VM=$1

if [ ! -d $ROOT_DIR/$VM ]
then
        usage
fi

CONFIG="$ROOT_DIR/$VM/config.ini"
OPTIONS=""
OPTIONS_TXT=""

if [ $# -gt 1 -a "$2" == "pxe" ];
then
        OPTIONS=" -boot n"
        OPTIONS_TXT=" with PXE options"
fi

if [ $# -eq 3 -a "$2" == "cdrom" ];
then
    OPTIONS="-cdrom $3 -boot d"
    OPTIONS_TXT=" with CDROM options"
fi

echo "Loading configuration"

VNC_PORT=$( grep vnc $CONFIG | cut -d\= -f2 )

CPU=$( grep cpu $CONFIG | cut -d\= -f2 )
RAM=$( grep ram $CONFIG | cut -d\= -f2 )
DISK_FILE=$( grep disk $CONFIG | cut -d\= -f2 )

set NETWORK

if [ $(test_conf $CONFIG "macaddr1") ];
then
    NETWORK="-net nic,vlan=0,macaddr=$( grep macaddr1 $CONFIG | cut -d\= -f2 ) -net tap,vlan=0,script=/data/vm/kvm/bin/kvm.if-up,downscript=/data/vm/kvm/bin/kvm.if-down"
fi

if [ -z "$MAC1" ];
then
    echo "MAC1 = $MAC1"
fi

echo "Launching $VM"
echo "CPU : $CPU"
echo "Memory : $RAM"
echo "VNC : $VNC_PORT"
echo "NETWORK : $NETWORK"
echo "Options : $OPTIONS_TXT"

CMD="sudo kvm -hda $ROOT_DIR/$VM/$DISK_FILE -smp $CPU -m $RAM -k fr $NETWORK $OPTIONS"
$CMD &

Quelques explications :

Le script prends en paramètre le nom de la machine virtuelle à lancer, nom qui correspond au répertoire où elle est stockée.
Le fichier config.ini est parsé afin de récupérer les différents paramètres de la machine virtuelle.
La machine est configurée et lancée