Généralités
L'hyperviseur Xen Project est un hyperviseur open source de type 1 ou baremetal, qui permet d'exécuter de
nombreuses instances d'un système d'exploitation voire différents systèmes d'exploitation en
parallèle sur une seule machine (ou hôte). Xen 1.0 à vu le jour en 2003.
Les machines virtuelles invitées qui s'exécutent sur un hyperviseur Xen sont désignées sous le nom de domaines.
Un domaine particulier, nommé dom0, assume la responsabilité de superviser l'hyperviseur
et d'amorcer d'autres systèmes d'exploitation invités. Ces derniers sont alors appelés des domUs.
Ces domaines sont considérés comme non privilégiés, ce qui signifie qu'ils ne disposent
pas du contrôle sur l'hyperviseur ni de la capacité de démarrer ou d'arrêter d'autres domaines.
En 2013, le projet a été placé sous la responsabilité de la Linux Foundation.
Accompagnant cette décision, une nouvelle marque « Xen Project » a été adoptée pour
différencier le projet open source des nombreuses offres commerciales qui utilisaient
l'ancienne marque « Xen ».
Piles d'outils Xen
Xen offre trois piles d'outils :
- XL
- XAPI
- LIBVIRT
XL
Anciennement connu sous le nom de xm, xl est une interface en ligne de commande utilisée
pour interagir avec Xen.
xl est plus proche du noyau Xen et fournit un contrôle plus bas niveau sur les machines
virtuelles.
Avec xl, on peut effectuer des actions telles que créer, démarrer,
arrêter et détruire des machines virtuelles, ainsi que gérer les ressources système associées.
XAPI
XAPI (XenAPI) est une interface de programmation d'application (API) pour Xen qui expose
les fonctionnalités de gestion de Xen via un ensemble de fonctions et d'objets manipulables.
Contrairement à xl, qui est une interface en ligne de commande, XAPI est principalement
utilisé pour automatiser la gestion des machines virtuelles Xen à l'aide de scripts ou d'applications.
XAPI fournit une abstraction plus élevée et une interface plus conviviale pour la gestion
des machines virtuelles. Xapi est généralement utilisé avec XCP-NG/XenServer.
LIBVIRT
Libvirt fournit une abstraction multi-hyperviseur, ce qui signifie qu'il peut être utilisé
pour gérer différents types d'hyperviseurs avec une interface commune. Cela permet aux
utilisateurs de gérer plusieurs hyperviseurs à partir d'une seule API et d'un ensemble d'outils.
Types de virtualisation
Xen Project propose 3 modes de virtualisation, parmi lesquels les deux premiers sont les plus historiques :
-
PV (Paravirtualization) : La paravirtualisation repose sur l'utilisation de systèmes
d'exploitation invités modifiés. Ces systèmes d'exploitation sont conscients de leur virtualisation
et n'ont donc pas besoin de périphériques matériels virtuels. Ils effectuent
plutôt des appels spéciaux à l'hyperviseur pour accéder aux ressources CPU, de stockage et réseau.
Des noyaux compatibles PV existent pour Linux, NetBSD et FreeBSD.Ce miroir répertorie certaines distributions Ubuntu compatibles avec Xen : link -
HVM (Hardware Virtual Machine) : Les machines virtuelles de type HVM
fonctionnent avec un système invité non modifié qui n'est pas conscient de l'hyperviseur.
Ces invités, entièrement virtualisés, ne nécessitent aucune modification du noyau, car l'hyperviseur créera
un ensemble entièrement virtuel de périphériques matériels pour la machine, ressemblant à un ordinateur x86 physique.
Par conséquent, les systèmes
d'exploitation tels que Windows peuvent être utilisés comme invités Xen HVM.
A noter :
Cette méthode requiert des extensions matérielles telles que Intel VT ou AMD-V, ce qui entraîne également une consommation accrue de ressources et des performances inférieures. - PVH (Paravirtualisation Hardware-Assisted) : L’une des principales motivations de PVH est de combiner le meilleur des modes PV et HVM et de simplifier l’interface entre les systèmes d’exploitation avec le support Xen et l’hyperviseur Xen. Pour ce faire on prend un invité PV et on lui implémente un wrapper HVM léger autour de celui-ci. Ce mode de virtualisation est maintenant au stade PVHv2.
Un schéma va tenter d'illustrer l'architecture de base de l'hyperviseur du projet Xen :
Comme le montre le schéma, l'hyperviseur Xen s'appuie directement sur le matériel de la machine physique. Toutes les machines virtuelles invitées reposent sur la couche de l'hyperviseur, tout comme le dom0. Le dom0, quant à lui, bénéficie de privilèges supplémentaires, tels que la capacité de communiquer avec l'hyperviseur pour démarrer et arrêter les machines virtuelles invitées. Il est également équipé par défaut des pilotes de périphériques nécessaires pour gérer le matériel.
Solutions Xen
Il existe la solution open source originelle, Xen Project. En parallèle, on trouve une solution payante appelée XenServer, qui fournit une partie gratuite mais limitée en termes de fonctionnalités. Il existe également une autre solution basée sur Xen Project, XCP-NG, qui propose également une version gratuite ainsi qu'une version payante.
XEN PROJECT
Le projet de base sortie en 2003.
XCP-NG
XCP-ng s'agit d'une distribution clé en main de Xen Project Hypervisor s'appuyant
principalement sur Xen Hypervisor et le projet
XenAPI (XAPI). Le projet est né en 2018, suite au fork du projet open source
XenServer (anciennement Citrix Hypervisor).
L'objectif principal de XCP-ng est de fournir un moyen simple de déployer une infrastructure
basée sur des machines virtuelles en utilisant Xen comme hyperviseur et la puissance de XAPI
pour fournir une solution clé en main et prête à l'emploi. XCP-ng est compatible avec la
plupart des serveurs x86 actuellement sur le marché.
XCP-ng est conçu pour satisfaire les besoins des infrastructures de toutes tailles : du
homelab au datacenter. XCP-ng s'exécute dans de nombreux types de configurations différents
en production.
XenServer
XenServer est une plateforme de virtualisation développée par Citrix Systems, basée sur le projet open-source Xen. Citrix a lancé XenServer en 2006, proposant ainsi une solution de virtualisation robuste pour les entreprises. Il offre des fonctionnalités telles que la gestion centralisée des machines virtuelles, la migration en direct, la haute disponibilité et la gestion des ressources. XenServer est également distribué sous licence open-source, mais avec des fonctionnalités limitées.
Installation
Dans cette section, nous allons nous concentrer sur l'installation du projet Xen de base sur un environnement Linux et une distribution Ubuntu 22.
Installation du paquet Xen
sudo apt-get install xen-system-amd64
content_copy
Une fois l'installation terminée, il est nécessaire de redémarrer la machine.
Ensuite, à partir du menu du GRUB, nous pouvons sélectionner Ubuntu avec Xen
pour démarrer le système.
Dans le terminal, nous pouvons saisir la commande suivante pour obtenir des
informations sur l'installation que nous venons de réaliser :
sudo xl info
content_copy
Création du disque LVM
Pour créer un volume group VG pour les machines virtuelles Xen,
nous devons d'abord configurer un disque LVM. Ce disque LVM servira de
stockage pour le VG, qui contiendra ensuite les volumes logiques individuels pour chaque invité.
sudo apt-get install lvm2
content_copy
Maintenant que nous avons installé l'outil qui permet de créer des disques LVM, nous devons déterminer sur quel disque nous allons créer le disque LVM.
sudo lsblk
content_copy
Après avoir choisi le nom du disque que nous souhaitons utiliser comme LVM, nous créons le disque :
sudo pvcreate /dev/sdX
content_copy
Maintenant que LVM a un endroit pour stocker ses blocs, créons un groupe de volumes appelé "nom_du_disque_vg" en utilisant ce volume physique.
sudo vgcreate <nom_du_disque_vg> /dev/sdx
content_copy
On peut vérifier que tout s'est bien passé avec la commande suivante :
sudo pvs
PV VG Fmt Attr PSize PFree
/dev/sda3 vg0 lvm2 a-- <98,00g <15,00g
Installation des outils xen
Cette commande installe les packages nécessaires pour faciliter la création de ponts réseau (par exemple, bridge-utils) et autres fonctionnalités.
sudo apt-get install xen-tools
content_copy
Installation des outils réseau
Pour connecter nos VMs à Internet ou entre elles, nous devons gérer leur connectivité via des bridges. Xen permet plusieurs méthodes de configuration :
Aucun paquet supplémentaire n'est nécessaire, car ip est une commande intégrée dans la plupart des distributions Linux.
bridge-utils est un paquet contenant les outils nécessaires à la gestion des bridges sur Linux. On peut l'installer en utilisant la commande suivante :
sudo apt install bridge-utils
content_copy
OpenvSwitch permet de créer très facilement des bridges et la gestion des interfaces réseau.
sudo apt install openvswitch-switch
content_copy
Commandes Xen Project
Lister les volumes physiques (PV)
sudo pvs
content_copy
Créer un volume logique
sudo lvcreate -L 4G -n <nom_volume_logique> /dev/<VG>
content_copy
Lister les volumes logiques
sudo lvs --segments
content_copy
Supprimer un volume logique
On commence par lister les volumes logiques :
# Optionnel : --segments
mahmoud@xen:/etc/xen$ sudo lvs --segments
LV VG Attr #Str Type SSize
lv_vm_ubuntu ubuntu-vg -wi-a----- 1 linear 10,00g
ubuntu-hvm ubuntu-vg -wi-a----- 1 linear 4,00g
ubuntu-lv ubuntu-vg -wi-ao---- 1 linear <49,00g
Ensuite, on peut choisir le volume que l'on souhaite supprimer.
sudo lvremove /dev/<VG>/<VL>
content_copy
Créer un snapshot d'un volume logique
Cette commande permet de créer un snapshot d'un volume logique.
lvcreate -s <source_logical_volume> -n <snapshot_name> -L <size>
content_copy
Créer une nouvelle VM
Pour créer une VM (PV, HVM), il faut créer un fichier de configuration .cfg
et y spécifier les caractéristiques de notre VM.
Si la commande s'exécute correctement, cela devrait déclencher le début de l'installation du système d'exploitation.
-d : Pour lancer en mode détaché
sudo xl create fichier_de_configuration.cfg
content_copy
sudo xen-create-image --hostname=guest4 \
--memory=512mb \
--vcpus=2 \
--lvm=ubuntu-vg \
--bridge=customBr0 \
--ip=10.22.9.194 \
--netmask=255.255.255.0 \
--gateway=10.22.9.254 \
--mirror=http://ports.ubuntu.com/archives/xenial/main/installer-amd64 \
--pygrub \
--dist=xenial \
--size=10G \ # Spécification de la taille du disque
--force
content_copy
Démmarer une VM
sudo xl create fichier_de_configuration.cfg
content_copy
Accéder à une VM
sudo xl console nom_vm
content_copy
Arrêter une VM
sudo xl shutdown nom_de_la_VM
content_copy
Redémarrer une VM
sudo xl reboot nom_de_la_VM
content_copy
Suspendre une VM
sudo xl pause nom_de_la_VM
content_copy
Reprendre une VM suspendue
sudo xl unpause nom_de_la_VM
content_copy
Détruire une VM
sudo xl destroy nom_de_la_VM
content_copy
Liste des VMs en cours d'exécution
sudo xl list
content_copy
mahmoud@xen:~/$ sudo xl list
Name ID Mem VCPUs State Time(s)
Domain-0 0 7589 4 r----- 36.1
vm_1_pv 3 512 1 -b---- 5.2
Ce tableau explique les différentes significations du champ State
| Indicateur | Signification |
|---|---|
| r | Indique que le domaine est en cours d'exécution (running). |
| b |
Indique que le domaine est bloqué (blocked).
Cela peut se produire lorsque le domaine attend une ressource ou une action.
Exemple : La VM attend la saisie d'un login/mot de passe. |
| - | Indique que le domaine est éteint (shutdown). |
| p | Indique que le domaine est en pause (paused). Cela signifie que le domaine a été mis en pause et ne peut pas s'exécuter. |
| s | Indique que le domaine est en train d'être sauvegardé (saving). Cela se produit lorsqu'une sauvegarde du domaine est en cours. |
| c | Indique que le domaine est en train d'être restauré à partir d'une sauvegarde (restoring). |
| d | Indique que le domaine est en cours de destruction (destroy). Cela se produit lorsque le domaine est en cours de suppression. |
Lister toutes les VMs
sudo xl list -l
content_copy
Pour lister également leurs UUID utiles pour faire des snapshots :
sudo xl vm-list
content_copy
Affichage des informations système
sudo xl info
content_copy
Surveillance temps réel des VMs
Cette commande fournit des données telles que l'utilisation du processeur, de la mémoire, des disques et du réseau pour chaque domaine Xen en cours d'exécution sur le système.
sudo xl top
content_copy
Afficher les logs du service Xen
sudo journalctl -xeu xen.service
content_copy
Récupérer l'uuid d'une VM
sudo xl vm-list
content_copy
Création d'un snapshot d'une VM
Création d'un snapshot à froid d'une VM :
sudo xl vm-snapshot uuid=<uuid_de_la_vm> name=<nom_de_la_snapshot>
content_copy
Création d'un snapshot à chaud d'une VM
sudo xl vm-snapshot-with-memory uuid=<vm_uuid> name=<nom_de_la_snapshot>
content_copy
Restauration d'un snapshot
sudo xl vm-restore uuid=<SNAPSHOT_UUID>
content_copy
Suppression d'un snapshot
sudo xl vm-snapshot-destroy uuid=<SNAPSHOT_UUID>
content_copy
Création d'un snapshot d'un LV
sudo lvcreate -s /dev/vg0/pc1 -n <nom_snapshot> -L <taille>
content_copy
Commandes IP pour les Bridges
Tap
Créer une interface TAP
sudo ip tuntap add mode tap tap0
content_copy
Supprimer une interface TAP
sudo ip tuntap del mode tap tap0
content_copy
Afficher les informations sur les interfaces TAP
sudo ip tuntap show
content_copy
Attribuer une Ip à une interface Tap
sudo ip addr add 10.22.9.190/24 dev tap0
content_copy
Activer une interface Tap
sudo ip link set nom_de_l_interface_tap up
content_copy
Bridge
Créer un bridge
sudo ip link add name br0 type bridge
content_copy
Supprimer un bridge
sudo ip link del br0
content_copy
Afficher les informations sur les bridges
sudo ip link show type bridge
content_copy
Ajouter une interface à un bridge
sudo ip link set dev tap0 master br0
content_copy
Supprimer une interface d'un bridge
Lors de la suppression d'une interface d'un bridge, on n'a pas besoin de spécifier le nom du bridge.
sudo ip link set nom_interface master
content_copy
Afficher les interfaces membres d'un bridge
sudo ip link show master br0
content_copy
Afficher les Ip d'interfaces membres d'un bridge
sudo ip addr show master br0
content_copy
Activer un bridge
sudo ip link set dev br0 up
content_copy
Désactiver un bridge
sudo ip link set dev br0 down
content_copy
Configurer une adresse IP pour un bridge
sudo ip addr add 192.168.1.1/24 dev br0
content_copy
Supprimer une adresse IP d'un bridge
sudo ip addr del 192.168.1.1/24 dev br0
content_copy
Ajouter une route pour un bridge
sudo ip route add default via 192.168.1.1 dev br0
content_copy
Supprimer une route pour un bridge
sudo ip route del default via 192.168.1.1 dev br0
content_copy
Activer le forwarding de paquets IP
sudo sysctl net.ipv4.ip_forward=1
content_copy
Configurer le réseau NAT pour rediriger le trafic sortant des invités vers l'interface de l'hôte connectée à Internet. Par exemple, si l'interface de l'hôte connectée à Internet est ens18 :
sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
content_copy
Commandes OpenVSwitch
Créer un bridge
sudo ovs-vsctl add-br nom_du_bridge
content_copy
Supprimer un bridge
sudo ovs-vsctl del-br nom_du_bridge
content_copy
Ajouter une interface à un bridge
sudo ovs-vsctl add-port nom_du_bridge nom_de_l_interface
content_copy
Supprimer une interface d'un bridge
sudo ovs-vsctl del-port nom_du_bridge nom_de_l_interface
content_copy
Afficher la configuration du switch
sudo ovs-vsctl show
content_copy
Afficher les bridges existants
sudo ovs-vsctl list-br
content_copy
Afficher les interfaces connectées à un bridge
sudo ovs-vsctl list-ports nom_du_bridge
content_copy
Configurer le contrôleur OpenFlow
sudo ovs-vsctl set-controller nom_du_bridge tcp:adresse_ip:port
content_copy
Supprimer le contrôleur OpenFlow
sudo ovs-vsctl del-controller nom_du_bridge
content_copy
Afficher les statistiques des ports
sudo ovs-ofctl show nom_du_bridge
content_copy
Afficher les statistiques des flux
sudo ovs-ofctl dump-flows nom_du_bridge
content_copy
Commandes Dnsmasq
Installation
sudo apt install dnsmasq
content_copy
Démarrer dnsmasq
sudo service dnsmasq start
content_copy
Arrêter dnsmasq
sudo service dnsmasq stop
content_copy
Redémarrer dnsmasq
sudo service dnsmasq restart
content_copy
Activer dnsmasq pour qu'il démarre automatiquement au démarrage du système
sudo systemctl enable dnsmasq
content_copy
Désactiver dnsmasq pour qu'il ne démarre pas automatiquement au démarrage du système
sudo systemctl disable dnsmasq
content_copy
Vérifier le statut de dnsmasq
sudo service dnsmasq status
content_copy
Recharger la configuration de dnsmasq après avoir modifié le fichier de configuration
sudo service dnsmasq reload
content_copy
Afficher les entrées DNS en cache
sudo dnsmasq -q
content_copy
Vider le cache DNS de dnsmasq
sudo dnsmasq -q flush
content_copy
Afficher les statistiques de dnsmasq
sudo dnsmasq -q stats
content_copy
Afficher les journaux de dnsmasq
sudo journalctl -u dnsmasq
content_copy
Éditer le fichier de configuration de dnsmasq
sudo vim /etc/dnsmasq.conf
content_copy
Afficher les demandes d'IP et les attributions d'IP
sudo grep -E "(DHCPDISCOVER|DHCPOFFER|DHCPREQUEST|DHCPACK)" /var/log/syslog
content_copy
Serveur NFS
Un serveur NFS (Network File System) comme nfs-kernel-server est utilisé dans le
contexte Xen pour partager des fichiers, tels que des images ISO de systèmes d'exploitation,
ainsi une solution Xen tel que XenServer ou XCP-NG aura accès à ces images pour la création
de machine virtuelles.
En centralisant les fichiers ISO sur un serveur NFS, on simplifie la gestion des fichiers.
On aura besoin de mettre à jour ou de modifier les fichiers qu'à un seul endroit,
ce qui simplifie la maintenance et réduit les risques d'erreur.
Installation d'un serveur NFS
J'ai choisi d'installer le serveur nfs nfs-kernel-server. C'est l'implémentation NFS la plus courante sur les systèmes Linux. Il est largement utilisé en raison de sa stabilité, de sa compatibilité élevée avec les noyaux Linux et de sa facilité d'installation et de configuration.
sudo apt install nfs-kernel-server
content_copy
Commandes serveur NFS
Si on ne trouve pas les commandes mentionnées, on peut installer les outils
NFS manquants en installant le paquet :
nfs-common
Vérifier le statut du service NFS
systemctl status nfs-server
content_copy
Arrêter le serveur NFS
systemctl stop nfs-server
content_copy
Démarrer le serveur NFS
systemctl start nfs-server
content_copy
Redémarrer le serveur NFS
systemctl restart nfs-server
content_copy
Recharger le serveur NFS
systemctl reload nfs-server
content_copy
Vérifier les exportations NFS
sudo exportfs -v
content_copy
Configurer le partage NFS
Maintenant que nfs-kernel-server est installé, on peut créer un répertoire * là où on le souhaite (de préférence accessible facilement) et mettre toutes les images ISO dont on dispose.
sudo mkdir /chemin/vers/le/rep/a/partager
content_copy
Ensuite on doit éditer le fichier /etc/exports pour définir les paramètres de partage :
/chemin/vers/le/rep/a/partager *(rw,sync,no_subtree_check)
content_copy
Accéder aux fichiers (à distance)
Dans cette partie, nous partons du principe que nous utiliserons XenServer pour accéder aux serveurs NFS. Dans XenServer, lorsqu'il nous demande l'adresse de votre serveur NFS, nous devons entrer l'adresse IP de notre serveur NFS suivie du chemin absolu vers le répertoire que nous avons partagé.
ip_serveur_NFS:/chemin/vers/le/rep/a/partager
content_copy
Créations d'invités Xen Project
Création d'invité PV
La création d'invités PV est la méthode la plus simple sous Xen Project. Elle permet de créer des machines virtuelles (Distributions modifiées) uniquement des distributions Linux.
Avantages des invités PV :
- Pas d'extensions de virtualisation nécessaires du côté du processeur hôte.
- Performances accrues grâce à une meilleure utilisation des ressources du système.
Configuration requise :
- Distribution Linux modifiée pour être consciente de la virtualisation Xen.
Procédure de création d'une machine virtuelle PV :
- Configuration réseau (Bridge)
- Création d'un volume logique (LV)
- Téléchargement d'une image Linux
- Mise en place du fichier de configuration de la VM
- Installation de la distribution
- Lancement de la machine virtuelle
1. Configuration du bridge sur l'hôte
Pour que les machines virtuelles puissent accéder à Internet, un bridge doit être mis en place.
Xen laisse le choix d'utiliser la technologie que l'on souhaite
(ip, brctl, openVSwitch). Dans cet exemple, nous allons utiliser
les commandes ip pour créer notre bridge.
Nous allons commencer par créer notre bridge xenBr0 :
sudo ovs-vsctl add-br xenBr0
content_copy
Nous allons ensuite affecter un réseau local autre que celui de l'hôte pour que les VMs puissent utiliser ce réseau :
sudo ip addr add 192.168.0.1/24 dev xenBr0
content_copy
Maintenant que nous avons créé notre bridge, nous devons l'activer :
sudo ip link set dev xenBr0 up
content_copy
On peut vérifier que le bridge est bien présent :
ip a
content_copy
3: xenBr0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default qlen 1000
link/ether 96:d5:14:27:2e:f7 brd ff:ff:ff:ff:ff:ff
inet 192.168.0.1/24 scope global xenBr0
valid_lft forever preferred_lft forever
inet6 fe80::94d5:14ff:fe27:2ef7/64 scope link
valid_lft forever preferred_lft forever
Nous devons maintenant configurer le bridge pour utiliser du NAT. Cela a pour but de traduire l'adresse IP source de la VM (x.x.x.x) en l'adresse IP de l'interface réseau de l'hôte (ensX/ethX) pour les paquets sortants. Cela permet aux paquets de la VM d'être routés vers Internet via l'hôte.
sudo iptables -t nat -A POSTROUTING -o nom_interface -j SNAT --to-source ip_hote
content_copy
Redirection de port : La deuxième commande iptables
sert à rediriger le trafic entrant sur le port TCP 80 (trafic HTTP) vers la VM.
Cela permet aux requêtes HTTP envoyées à l'adresse IP de l'hôte sur le port 80
d'être transmises à la VM.
Cette commande est à utiliser avec prudence car le monde extérieur aura accès à votre VM.
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT
content_copy
On peut également faire en sorte qu'Internet accède à la VM en établissant un forward de port :
sudo iptables -t nat -A PREROUTING -p tcp --dport PORT -j DNAT --to-destination IP_VM:PORT
content_copy
Pour que ces commandes restent après un reboot de l'hôte, nous devons créer un script qui s'exécute dès le démarrage de l'hôte, pour cela on crée un script et on lui donne les droits d'exécution :
mkdir scriptsSetupBoot/
sudo vim bridge_cfg.sh
#!/bin/bash
# Créer le bridge xenBr0
sudo ip link add xenBr0 type bridge
# Activer le bridge
sudo ip link set xenBr0 up
# Affecter l'adresse IP 192.168.0.1/24 au bridge xenBr0
sudo ip addr add 192.168.0.1/24 dev xenBr0
# Configuration du Brige Nat
sudo iptables -t nat -A POSTROUTING -o ens18 -j SNAT --to-source x.x.x.x
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT
exit 0
content_copy
Création d'un volume logique (LV)
Maintenant, on peut créer le volume logique qui nous permettra de jouer le rôle de la partition physique.
On commence par lister notre disque PV :
sudo pvs
PV VG Fmt Attr PSize PFree
/dev/sda3 ubuntu-vg lvm2 a-- <98,00g 29,00g
content_copy
On voit donc ici qu'on a un disque PV de nom ubuntu-vg, on s'assure de créer un disque LV de taille adéquate inférieure à la valeur PFree.
sudo lvcreate -L 10G -n lv_test /dev/ubuntu-vg
content_copy
Téléchargement d'une image Linux
On se rend dans /var/lib/xen/images et on crée un répertoire
où on va stocker notre OS.
Pour télécharger une distribution de type Ubuntu, nous pouvons aller sur :
mirror.orionvm
où l'on trouve plein de distributions Ubuntu.
Cependant, nous devons choisir une qui a les deux fichiers
obligatoires pour lancer l'installation : vmlinuz et initrd.gz
Voici un exemple de distribution compatible (suivre l'arborescence):
/ubuntu/dists/trusty/main/installer-amd64/current/images/netboot/xen
sudo wget http://mirror.orionvm.com.au/ubuntu/dists/trusty/main/installer-amd64/current/images/netboot/xen/initrd.gz
content_copy
sudo wget http://mirror.orionvm.com.au/ubuntu/dists/trusty/main/installer-amd64/current/images/netboot/xen/vmlinuz
content_copy
On peut également télécharger un fichier de configuration pré-configuré pour nous aider à démarrer si on le souhaite.
Dans cet exemple, nous ne l'utiliserons pas. Nous allons créer notre propre fichier de configuration minimaliste.
sudo wget http://mirror.orionvm.com.au/ubuntu/dists/trusty/main/installer-amd64/current/images/netboot/xen/xm-debian.cfg
content_copy
Mise en place du fichier de configuration de la VM
On commence par créer un fichier de configuration, au niveau de /etc/xen.
sudo vim test_pv.cfg
content_copy
# =====================================================================
# Example PV guest configuration
# =====================================================================
name = "test_pv_vm1"
# Ces deux lignes permettent de lancer l'installation
kernel = "/var/lib/xen/images/test_pv/vmlinuz"
ramdisk = "/var/lib/xen/images/test_pv/initrd.gz"
# Cette ligne sert à démarrer la VM PV une fois que l'installation est terminée. Il faudra bien indiquer votre version de Xen.
# bootloader = "/usr/lib/xen-4.16/bin/pygrub"
# Configuration des capacités de la VM
# Quantité de mémoire
memory = 1024
# Nombre de CPU
vcpus = 1
# Configuration du réseau
vif = ['bridge=xenBr0']
# Configuration du disque où on va installer Ubuntu
disk = [ '/dev/ubuntu-vg/lv_test,raw,xvda,rw' ]
content_copy
Installation de la distribution
Maintenant, on peut lancer l'installation d'Ubuntu sur la VM invitée. On peut soit se placer dans /etc/xen, soit être ailleurs mais spécifier le chemin du fichier de configuration.
sudo xl create -c test.cfg
content_copy
Lancement de la machine virtuelle
Maintenant que l'invité est installé, nous devons modifier le fichier de configuration test.cfg :
# On commente ces deux lignes maintenant
# kernel = "/var/lib/xen/images/test_pv/vmlinuz"
# ramdisk = "/var/lib/xen/images/test_pv/initrd.gz"
# On décommente cette ligne pour lancer la VM
bootloader = "/usr/lib/xen-4.16/bin/pygrub"
content_copy
sudo xl list
Name ID Mem VCPUs State Time(s)
Domain-0 0 7073 4 r----- 148.0
test_pv_vm1 8 1024 1 -b---- 2.9
Citrix XenServer
Dans cette partie, nous allons voir comment installer et utiliser la plateforme XenServer pour créer et gérer nos machines virtuelles.
Téléchargement de XenServer
Nous allons utiliser la version d'essai de XenServer 8, disponible au téléchargement
depuis le site officiel :
link.
Ce lien permet de télécharger l'ISO de XenServer 8 du 25 mars 2024. Il est également nécessaire de
télécharger le logiciel de pilotage pour Windows,
XenCenter 2024.1.0, en suivant ce lien :
link.
Installation de XenServer dans Proxmox
Dans notre cas, l'installation se fera non pas sur une machine physique, mais sur Proxmox VE.
À noter qu'il est également possible de l'installer sur un environnement VMware ou directement sur une machine physique.
En revanche, cela ne fonctionne pas sur VirtualBox. Le serveur XenServer plantera dès que l'on essaiera
de lancer une VM.
Général
Nous commençons par créer une nouvelle machine virtuelle dans Proxmox.
On indique le nom de notre VM.
Système d'exploitation
Dans cette section, nous devons choisir notre image ISO ou notre CD/DVD à partir duquel nous
souhaitons installer XenServer.
Nous pouvons également sélectionner le type de système d'exploitation invité sur lequel est basé
notre image ISO. Dans notre cas, il s'agit de Linux.
Système
Dans cette section, nous devons choisir le bon BIOS de démarrage. On peut laisser la valeur par défaut,
même si XenServer nous conseille de passer en mode UEFI.
On peut également activer l'option d'ajout du module TPM pour éviter d'éventuels problèmes
ultérieurs avec des VM de type Windows 11.
Disques
Ici proxmox nous demande d'indiquer le lieu de stockage de XenServer et sa capacité. Xen préconise au minimum 70GB pour une utilisation minimale.
Processeur
Dans cette section, nous devons choisir le nombre de CPU et, pour chaque CPU, le nombre de cœurs.
Mémoire
Ensuite, nous spécifions la quantité de RAM, recommandée à 8 Go.
Réseau
Dans cette partie, nous indiquons le réseau que nous souhaitons utiliser.
Confirmation
On obtient un petit résumé de toutes les caractéristiques de notre machine virtuelle XenServer. Nous désactivons l'option "Démarrer après création", ce qui permet de vérifier que la virtualisation matérielle KVM est bien activée.
Virtualisation matérielle KVM
On vérifie que la virtualisation KVM est bien activée.
Nous pouvons maintenant lancer XenServer pour commencer son installation.
Installation de XenServer
Après avoir cliquer sur le bouton démarrer on se place dans la console ainsi lancé pour démarrer le processus d'installation de XenServer.
Message BIOS
Si on a pas choisi le bon mode du BIOS, ce message peut s'afficher mais pour notre utilisation cela ne dérange pas.
Source d'installation
A cette étape, on choisi la source depuis laquelle on souhaite faire l'installation, dans notre cas on utilise l'image iso, on choisi donc local.
Réseau
Dans cette partie, nous configurons le réseau. Dans mon cas j'utilise un DHCP.
Vérification de l'installation
L'étape "Verify Installation Source" lors de l'installation de XenServer est une phase importante du processus d'installation. Il vérifie l'intégrité de notre Iso si elle a pas été modifié.
Mot de passe
A cette étape on indique le mot de passe a utilisé lors des connexions SSH. Provisionning avec Ansible/SaltStack.
Nommage
Dans cette partie nous indiquons le nom de notre XenServer.
Installation & fin
Maintenant on peut installer XenServer.
Exécution
XenServer est en marche, et nous pouvons obtenir plusieurs informations accessibles, telles que le nombre de VM en cours d'exécution, et nous pouvons accéder au terminal, entre autres.
XenCenter
Maintenant que XenServer est en route, on peut y accéder via le XenCenter sous Windows.
Ajouter un nouveau serveur
Nous commençons par ajouter un nouveau serveur.
Connexion au serveur
Pour ce connecter au serveur nous rentrons l'adresse IP du serveur ainsi que les identifiants.
Maintenant notre serveur a été ajouté à XenCenter. On peut maintenant ajouter notre serveur de stockage NFS, et créée des VM.
Ajout d'un serveur de stockage
Dans cette partie nous allons ajouter un serveur de stockage.
Après avoir ajouté notre serveur à XenCenter, nous pouvons désormais configurer notre serveur de stockage NFS et créer des machines virtuelles.
Créer une vm sur XenCenter
Dans cette partie nous allons créer notre première VM Ubuntu.
Créer une VM Ubuntu
La procédure de création est très simple, il suffit de suivre les indications.
Nous commençons par créer une nouvelle vm :
Choix du template
XenServer met à notre disposition quelques modèles préconfigurés prêts à l'emploi. Ces modèles configurent certains paramètres tels que le stockage minimum recommandé, la mémoire vive minimale nécessaire, entre autres.
Si la case Copy host BIOS strings to VM est cochée à cette étape, il faudra choisir depuis quel serveur nous souhaitons effectuer la copie.
Donner un nom à la VM
À cette étape, nous devons donner un nom à notre machine virtuelle. Il est également possible de fournir une description.
Choix de l'image & BIOS
Cette étape est la plus sensible, car si nous choisissons le mauvais type de BIOS, la machine virtuelle peut ne pas se lancer correctement. Dans mon cas, le choix UEFI Boot fonctionne très bien. Mais si vous rencontrez des problèmes, vous pouvez essayer différents modes pour trouver celui qui est le plus adapté à votre architecture.
Après avoir déterminé notre mode de démarrage, nous sélectionnons la source d'installation, qui, dans notre cas, sera une image ISO.
Architecture CPU & Mémoire
Ensuite, nous configurons l'architecture CPU de notre machine
virtuelle ainsi que la quantité
de mémoire RAM que nous souhaitons allouer.
Il convient de noter que, selon le type
de système d'exploitation,
il peut y avoir quelques différences.
Stockage
Le modèle définit la taille minimale requise pour le fonctionnement de notre machine virtuelle. Nous avons la possibilité de modifier la quantité de stockage selon nos besoins.
Configuration Réseau
Par défaut, la VM est connectée au même réseau que le serveur XenServer. Il est possible de créer ou d'utiliser d'autres réseaux auxquels le serveur a accès.
Récapitulatif
À la fin de la procédure, nous obtenons un récapitulatif des caractéristiques de notre machine virtuelle.
La nouvelle machine virtuelle s'affiche parmi les VM disponibles sur le serveur. Nous pouvons cliquer sur le bouton Start pour lancer la VM.
Démarrage de la nouvelle VM
Après avoir cliqué sur Start, l'interface change et deux nouveaux boutons apparaissent : l'un pour arrêter la VM et l'autre pour la redémarrer.
Pour accéder à la console de la machine virtuelle en cours d'exécution, on clique sur Console.
Créer un modèle de machine virtuelle
La création manuelle d'une nouvelle VM chaque fois peut être chronophage. Il est possible de transformer une VM post-installation en modèle, ce qui permet de créer rapidement d'autres VM prêtes à l'emploi et totalement indépendantes.
Modèle de machine virtuelle
La procèdure est très simple, il suffit de configurer notre VM comme on le souhaite ensuite de faire un clique droit sur celle-ci et selectionner Convert to template
Une fois la conversion de la VM en modèle confirmée, elle disparaît de la liste des VM et réapparaît en bas de la liste sous forme de modèle.
Créer un snapshot
Xencenter offre la possibilité de créer de manière manuelle ou automatique de snapshots.
Snapshot manuel
On sélectionne d'abord la machine virtuelle, puis on clique sur "Take a Snapshot" :
Nous précisons d'abord les informations souhaitées, puis nous
finalisons l'opération.
Pour créer un snapshot incluant la mémoire,
la VM doit être en marche.
Automatisation de la création de snapshots
XenCenter nous permet d'automatiser la création de snapshots sur une
ou plusieurs machines virtuelles.
Nous pouvons planifier les sauvegardes par heure, jour ou semaine,
en précisant l'heure exacte de chaque sauvegarde.
Il est également possible de définir un seuil pour le nombre de
sauvegardes à conserver et d'automatiser la suppression des plus anciennes.
Il est nécessaire de passer en mode infrastructure.
On commence par indiquer les informations générales :
Dans cette fenêtre, on spécifie les machines virtuelles concernées par ce job.
Dans cette section, on choisit le mode de snapshot. On peut sélectionner soit uniquement le disque, soit le disque et la mémoire (la machine virtuelle doit être allumée pour inclure la mémoire).
Nous définissons les horaires et les dates des sauvegardes.
Enfin, une fenêtre affiche un récapitulatif de toutes les informations saisies.
On vérifie que le snapshot a été correctement créé et est active.
Si on souhaite arrêter le job ou le supprimer, il suffit de cliquer sur notre pool avec un clique droit et choisir "VM Snapshot Schedules..."
Nous arrivons ensuite à une fenêtre affichant la liste de tous les schedules du pool. Nous pouvons voir plusieurs informations, telles que la date du prochain snapshot et le résultat du dernier snapshot (réussi ou échoué). Nous avons également la possibilité de désactiver ou de supprimer un schedule.
Commandes XenServer
XenServer utilise principalement la commande xe pour gérer les VMs et autres ressources, et non xl. xl est plus communément associé à d'autres hyperviseurs basés sur Xen, comme Xen Project.
Machine virtuelle
Lister les VM
xe vm-list
content_copy
Créer une VM
xe vm-create template="<nom_du_template>" name-label="<nom_de_vm>"
content_copy
xe vm-create template-uuid=<uuid_du_template> name-label="<nom_de_vm>"
content_copy
xe vm-install template="<nom_du_template>" new-name-label="<nom_de_vm>"
content_copy
xe vm-install template=<uuid_du_template> new-name-label="<nom_de_vm>"
content_copy
Démarrer une VM
xe vm-start name-label="<nom_de_vm>"
content_copy
Arrêter une VM
xe vm-shutdown name-label="<nom_de_vm>"
content_copy
Redémarrer une VM
xe vm-reboot name-label="<nom_de_vm>"
content_copy
Mettre une VM en pause
xe vm-pause name-label="<nom_de_vm>"
content_copy
Reprendre une VM en pause
xe vm-unpause name-label="<nom_de_vm>"
content_copy
Supprimer une VM
xe vm-destroy name-label="<nom_de_vm>"
content_copy
Afficher les informations d’une VM
xe vm-param-list uuid=<UUID_de_la_VM>
content_copy
Lister tous les templates
xe template-list
content_copy
Snapshot
Lister tous les snapshot
xe snapshot-list
content_copy
Créer un snapshot
xe vm-snapshot uuid=<uuid_de_la_vm> new-name-label="<nom_du_snapshot>"
content_copy
Supprimer un snapshot
xe snapshot-uninstall uuid=<uuid_du_snapshot> force=true
content_copy
Créer un template à partir d'un snapshot
Cette commande va créer un template à partir du snapshot :
xe vm-clone uuid=<uuid_du_snapshot> new-name-label=<nom_du_template>
content_copy
Ensuite on peut créer une nouvelle VM à partir de ce snapshot :
xe vm-install template="<nom_du_template>" new-name-label="<nom_de_la_vm>"
content_copy
Réseau
Lister les réseaux
xe network-list
content_copy
Créer un réseau
xe network-create name-label="<nom_du_reseau>"
content_copy
Supprimer un réseau
xe network-destroy uuid=<uuid_du_reseau>
content_copy
Changer le nom d'un réseau
xe network-param-set uuid=<uuid_du_reseau> name-label="<nouveau_nom>"
content_copy
SR
Lister les SR (storage repositories)
xe sr-list
content_copy
Scanner un SR
xe sr-scan uuid=<uuid_du_sr>
content_copy
Lister le contenu d'un SR
xe vdi-list sr-name-label="<nom_du_sr>"
content_copy
Créer un SR
xe sr-create content-type="<type_de_contenu>" name-label="<nom_du_sr>"
content_copy
Supprimer un SR
xe sr-forget uuid=<uuid_du_sr>
content_copy
Hôte
Lister les hôtes
xe host-list
content_copy
Redémarrer un hôte
xe host-reboot uuid=<uuid_de_l'hôte>
content_copy
Éteindre un hôte
xe host-shutdown uuid=<uuid_de_l'hôte>
content_copy
Tâche
Lister les tâches
xe task-list
content_copy
Annuler une tâche
xe task-cancel uuid=<uuid_de_la_tache>
content_copy
Pools
Lister tous les pools
xe pool-list
content_copy
Afficher les informations sur un pool
xe pool-param-list uuid=UUID_du_pool
content_copy
Provisioning Ansible
Ansible
Ansible est un outil d'automatisation open-source qui permet de gérer et de déployer
des configurations de manière simple et efficace. Il utilise une syntaxe de type
YAML
pour définir les tâches et les processus, facilitant ainsi la gestion des systèmes
d'information et l'orchestration des applications.
Dans cette partie, nous allons voir comment orchestrer la création et le
démarrage de machines virtuelles avec Ansible et Citrix XenServer.
Installation d'Ansible
Ansible n'a pas besoin d'être installé sur la machine à orchestrer. Il suffit d'avoir la possibilité d'effectuer une connexion ssh dessus.
Procédure d'installation d'Ansible
sudo apt update
content_copy
sudo apt install software-properties-common
content_copy
sudo add-apt-repository --yes --update ppa:ansible/ansible
content_copy
sudo apt install ansible
content_copy
Vérifier que Ansible est bien installé :
toto@ubuntu:~$ ansible --version
ansible [core 2.16.5]
config file = /etc/ansible/ansible.cfg
configured module search path = ['/home/toto/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
ansible python module location = /usr/lib/python3/dist-packages/ansible
ansible collection location = /home/toto/.ansible/collections:/usr/share/ansible/collections
executable location = /usr/bin/ansible
python version = 3.10.12 (main, Nov 20 2023, 15:14:05) [GCC 11.4.0] (/usr/bin/python3)
jinja version = 3.0.3
libyaml = True
Module community.general
Ce module peut être utilisé pour créer de nouvelles machines virtuelles à partir de modèles ou d'autres machines virtuelles, modifier divers composants de machine virtuelle comme le réseau et le disque, arrêter/démarrer des machines virtuelles, renommer une machine virtuelle et supprimer une machine virtuelle avec les composants associés.
ansible-galaxy collection list
content_copy
toto@ubuntu:~/ansible$ ansible-galaxy collection list
# /usr/lib/python3/dist-packages/ansible_collections
Collection Version
---------------------------------------- -------
...
community.general 8.6.0
...
content_copy
Installer XenApi sur la machine Ansible
Pour que notre provisionnig fonctionne, nous devons installer l'API XenAPI
sudo apt install python3
content_copy
pip3 install XenAPI
content_copy
Copier la clé publique de la machine qui exécute Ansible sur le serveur Citrix XenServer
Comme mentionné précédemment, il est nécessaire d'envoyer la clé publique de la machine utilisant Ansible au serveur XenServer. Cela permet d'établir des connexions SSH de manière efficace.
ssh-copy-id root@<ip_xenserver>
content_copy
Inventaire Ansible
Ansible utilise des inventaires dans lesquels sont indiquées les informations nécessaires
pour la configuration des ressources. Pour nous, un inventaire sera un ensemble de machines
virtuelles à orchestrer.
Voici à quoi ressemblera notre fichier si on prend comme exemple d'avoir 2 machines :
# inventory.yaml
xenserver_hosts:
hosts:
xenserver:
ansible_host: <host_ip>
ansible_user: root
ansible_ssh_private_key_file: ~/.ssh/id_rsa
password: "<password>"
name_vm_1: "<vm_name>"
name_vm_2: "<vm_name>"
children:
vms:
hosts:
vm1:
ansible_host: <vm_ip>
vm2:
ansible_host: <vm_ip>
content_copy
Playbook Ansible
Après avoir créé notre inventaire Ansible, nous pouvons élaborer nos playbooks.
Un playbook est un fichier écrit en YAML
dans lequel sont spécifiées les tâches à
réaliser sur une ou plusieurs machines distantes. Il permet d'automatiser diverses
opérations telles que la configuration, la gestion, et le déploiement d'applications
sur ces machines.
Démarrer/Arrêter des VMs
# playbook_turn_on_vm.yaml
- name: Power on VM
hosts: xenserver
collections:
- community.general
tasks:
- name: Power on vm1
community.general.xenserver_guest_powerstate:
name: "{{ name_vm_1 }}"
state: powered-on
hostname: "{{ ansible_host }}"
username: "{{ ansible_user }}"
password: "{{ password }}"
- name: Power on vm2
community.general.xenserver_guest_powerstate:
name: "{{ name_vm_2 }}"
state: powered-on
hostname: "{{ ansible_host }}"
username: "{{ ansible_user }}"
password: "{{ password }}"
content_copy
On peut faire le même playbook pour éteindre les VM il suffit de remplacer powered-on par powered-off
Pour lancer ansible :
ansible-playbook -i inventory.yaml playbook_turn_on_vm.yaml
content_copy
Créer une nouvelle VM
Créer une VM à partir d'un template post install
- name: Créer une nouvelle VM à partir d'un template post install Ubuntu
hosts: xenserver
collections:
- community.general
tasks:
- name: Création du nom de la VM
set_fact:
vm_name: "ubuntu_22_{{ ansible_date_time.year }}{{ ansible_date_time.month }}{{ ansible_date_time.day }}{{ ansible_date_time.second }}"
- name: Création de la VM
community.general.xenserver_guest:
name: "{{ vm_name }}"
state: present
hostname: "{{ ansible_host }}"
username: "{{ ansible_user }}"
password: "{{ password }}"
template: "Ubuntu Server 22"
disks:
- size_gb: 10
sr: "Local storage"
networks:
- name: "Network_XenServer"
delegate_to: xenserver
register: vm_creation # L'option register est utilisée pour stocker les résultats d'une tâche dans une variable
content_copy
Créer une VM à partir d'un template
- name: Créer une nouvelle VM à partir d'un template
hosts: xenserver
collections:
- community.general
tasks:
- name: Création du nom de la VM
set_fact:
vm_name: # Le même code que précédemment
- name: Création de la VM
community.general.xenserver_guest:
name: "{{ vm_name }}"
state: present
hostname: "{{ ansible_host }}"
username: "{{ ansible_user }}"
password: "{{ password }}"
template: "Ubuntu Jammy Jellyfish 22.04"
disks:
- size_gb: 10
sr: "Local storage"
hardware:
num_cpus: 1
num_cpu_cores_per_socket: 1
memory_mb: 1024
cdrom:
type: iso
iso_name: "ubuntu-22.04-server.iso"
networks:
- name: "Network_XenServer"
delegate_to: xenserver
content_copy
Créer un snapshot
Le package community.general ne permet pas de créer des snapshots. Pour y remédier, nous allons donc utiliser le module Ansible shell.
Créer des snapshots
Dans cette partie, nous allons montrer comment créer des snapshots de VMs. Nous utiliserons un script Shell pour spécifier les VMs à sauvegarder. Ensuite, nous itérerons sur ces VMs pour exécuter la commande xe, qui crée des snapshots sur le serveur XenServer. Ansible interviendra ensuite pour copier et exécuter le script directement sur le serveur.
Script de sauvegarde
#!/bin/bash
# Un tableau associatif
declare -A tab_vms
# Remplir le tableau associatif
tab_vms["Ubuntu TEST 1"]="05d4ddb6-090a-8992-a71f-6ea54ee89fef"
tab_vms["Ubuntu TEST 2"]="55042bd4-9ee0-d1a2-d9ea-55c2eef69683"
# Parcours du tableau associatif
for vm_name in "${!tab_vms[@]}"; do
formatted_date=$(date +"%Y%m%d%H%M%S")
# Obtenir l'UUID de la VM en fonction du nom
vm_uuid=${tab_vms[$vm_name]}
echo "Traitement de la VM : $vm_name avec l'UUID : $vm_uuid"
snapshot_name="${vm_name}_${formatted_date}"
xe vm-snapshot uuid="$vm_uuid" new-name-label="$snapshot_name"
if [ $? -ne 0 ]; then
echo "Erreur pendant l'exécution de la commande xe snapshot uuid..."
exit 1
fi
done
exit 0
content_copy
Playbook Ansible
- name: create snapshots of all VMs
hosts: xenserver
tasks:
- name: Copie du script sur la machine xenserver
copy:
src: /home/toto/ansible/script_creates_snapshots.sh
dest: /root/scripts/script_creates_snapshots.sh
mode: '0755'
- name: Create a snapshots of VMs
shell: bash /root/scripts/script_creates_snapshots.sh
content_copy
Exécution
ansible-playbook -i inventory.yaml playbook_creates_snapshots.yaml
content_copy
Création d'une machine virtuelle à partir d'un snapshot
Sur XenCenter, la création d'une VM à partir d'un
snapshot est un processus simple et efficace. Un snapshot peut être
utilisé pour recréer une VM qui possède les mêmes données et caractéristiques
que la VM d'origine, celle qui a servi à sa création :
Xen se chargera d'assigner des adresses IP et MAC
différentes pour la nouvelle machine virtuelle.
Sur XenCenter, plusieurs options s'offrent à nous :
- Créer une nouvelle VM à partir d'un snapshot.
- Créer un modèle (template) à partir de cet snapshot.
- Convertir l'snapshot en modèle (template).
L'objectif de cette partie est d'explorer la manière dont nous pouvons
automatiser la création de VM en utilisant un snapshot à l'aide des commandes
xe.
Créer une VM à partir d'un template
Pour créer une nouvelle machine virtuelle, il est nécessaire de recourir à un script shell qui sera exécuté par Ansible. L'objectif est de créer d'abord un template à partir d'un snapshot, puis d'utiliser ce template temporaire pour générer la VM. Enfin, le template, utilisé uniquement pour faciliter la création de la machine virtuelle, sera supprimé.
Script Shell
Le prérequis pour cette opération est de disposer de l'UUID du snapshot que l'on souhaite utiliser.
#!/bin/bash
#
# Ce script permet de créer une VM à partir d'un snapshot
#
snapshot_uuid="<uuid_du_snapshot>"
formatted_date=$(date +"%Y%m%d%H%M%S")
tmp_template_name="template_snapshot_"$formatted_date
# Création du template temporaire issue du snapshot
xe vm-copy uuid=$snapshot_uuid new-name-label="$tmp_template_name"
if [ $? -ne 0 ]; then
echo "[Erreur] lors de la création du template temporaire."
exit 1
fi
echo "[FAIT] Création du template temporaire issue du snapshot."
# Extraction de l'uuid du template temporaire
tmp_uuid_template=$(xe template-list name-label=$tmp_template_name --minimal)
if [ $? -ne 0 ]; then
echo "[Erreur] pendant l'extraction de l'uuid du template temporaire."
exit 1
fi
if [ -z "$tmp_uuid_template" ]; then
echo "[Erreur], l'uuid du template temporaire est vide."
exit 1
fi
echo "[FAIT] Extraction de l'uuid du template temporaire."
# Création de la nouvelle VM
xe vm-install template=$tmp_uuid_template new-name-label="new_VM_"$formatted_date
if [ $? -ne 0 ]; then
echo "[Erreur] pendant la création de la VM."
exit 1
fi
echo "[FAIT] Création de la nouvelle VM : new_VM_$formatted_date."
# Suppression du template temporaire
echo "yes" | xe template-uninstall template-uuid=$tmp_uuid_template
if [ $? -ne 0 ]; then
echo "[Erreur] pendant la suppression du template."
exit 1
fi
echo "[FAIT] Suppression du template temporaire."
exit 0
content_copy
Playbook Ansible
#
# Ce playbook s'occupe de créer une VM à
# partir d'un snapshot existant.
#
- name: Création d'une VM à partir d'un snapshot
hosts: xenserver
tasks:
- name: Copie du script sur la machine xenserver
copy:
src: /home/toto/ansible/script_create_vm_from_snapshot.sh
dest: /root/scripts/script_create_vm_from_snapshot.sh
mode: '0755'
- name: Création de la VM
shell: bash /root/scripts/script_create_vm_from_snapshot.sh
content_copy
Supprimer tous les snapshots
Après avoir exploré la manipulation de snapshots, examinons maintenant comment les supprimer. Ce script supprime tous les snapshots et peut être facilement adapté pour cibler des VM spécifiques. Nous utiliserons la même méthode que pour la création : un script et un playbook.
#!/bin/bash
# Récupération de la liste de tous les snapshots
snapshots=$(xe snapshot-list params=uuid | awk '/uuid \( RO\)/ {print $5}')
if [ $? -ne 0 ]; then
echo "Erreur pendant l'exécution de la commande xe snapshot-list"
exit 1
fi
# Vérification de la liste vide
if [ -z "$snapshots" ]; then
echo "Aucun snapshot à supprimer."
exit 0
fi
# Parcours de chaque snapshot
for snapshot in $snapshots; do
echo "Suppression du snapshot : $snapshot"
xe snapshot-uninstall snapshot-uuid=$snapshot force=true
if [ $? -ne 0 ]; then
echo "Erreur pendant l'exécution de la commande xe snapshot-unistall"
exit 1
fi
done
echo "Tous les snapshots ont été supprimés."
exit 0
content_copy
Playbook Ansible
- name: Deletes snapshots of all VMs
hosts: xenserver
tasks:
- name: Copie du script sur la machine xenserver
copy:
src: /home/toto/ansible/script_deletes_snapshots.sh
dest: /root/scripts/script_deletes_snapshots.sh
mode: '0755'
- name: Deletes a snapshots of VMs
shell: bash /root/scripts/script_deletes_snapshots.sh
content_copy
Exécution
ansible-playbook -i inventory.yaml playbook_deletes_snapshots.yaml
content_copy