LXC-LXD

Expérimentations VM et Containers sous Linux

avec KVM/QEMU et LXC/LXD

Avant propos
Pour faire fonctionner des machines virtuelles, il faut un hyperviseur :
➔ Sous Linux, c’est le rôle de KVM et de QEMU (ensemble!)

Pour exploiter des containers, il faut un ‘porte-containers’ :

➔ C’est le rôle de LXC

La surcouche ‘LXD’ permet d’associer les deux fonctions : gestion des VM et des containers
➔ C’est donc LXD qui est intéressant, pas seulement LXC !

La Virtualisation avec KVM/QEMU

• KVM est une solution de virtualisation pour les processeurs, intégrée au noyau Linux
• Qemu est une solution logicielle permettant d'émuler diverses architectures en lien avec KVM
• libvirt est une bibliothèque sous Linux permettant d'interagir avec différentes solutions de
virtualisation
• virsh est l'outil en ligne de commande permettant la gestion de libvirt
➔ Qemu et KVM sont complémentaires et dépendants

Installation des éléments nécessaires : QEMU et KVM

• apt update && apt install -y

• apt install --no-install-recommends qemu-kvm qemu-system libvirt-clients libvirt-daemon-system
virtinst dnsmasq-base bridge-utils virt-viewer -y
• adduser $USER libvirt
• virsh --connect qemu:///system list --all
• export LIBVIRT_DEFAULT_URI='qemu:///system'

Labo container et VM v 231202 Jean GAUTIER

Pour qu'une solution de virtualisation telle que KVM/Qemu fonctionne, il faut s’assurer que la machine
prenne en charge la virtualisation au niveau du processeur :

egrep --color "(vmx|svm)" /proc/cpuinfo

Les outils de base pour manipuler les VMs

• virsh : cli pour libvirt (ligne de commande et shell)
• qemu-img : permet de gérer les images des disques
• virt-manager : client graphique
• virt-install : commande pour la création des machines virtuelles
• virt-viewer : client console graphique (spice)
• virt-clone : outil de clonage
• virt-top : top de VM libvirt
• virt-host-validate

La configuration du réseau par défaut

Une interface réseau de type ‘pont’ est créée automatiquement lorsqu’on installe LXC/LXD, elle assure le
routage avec NAT, sur l’interface réseau physique.

• C’est le démon dnsmasq qui fournit les services DNS/DHCP

• C’est nftables qui assure les règles de routage et de NAT

Labo container et VM v 231202 Jean GAUTIER

LXD (Linux Container Daemon)

LXD est une suite d’outils logiciels émanant du projet LinuX Containers, développé par
‘Canonical' (entreprise qui supporte Ubuntu Linux).

Le projet 'lxc', pour ‘LinuX Containers, est un isolateur de virtualisation permettant de créer des
instances de machines Linux à l’intérieur de 'Containers' isolés.
Les container reposent sur une 'image' d'un système Linux.

Pour créer une nouvelle instance, on réplique l'image d’un système, dans un container qui lui fournit
un environnent dédié.

LXD est en quelques sortes, 'l’hyperviseur' de LXC fournissant les moyens d’exploiter aisément la
couche de gestion des containers et des machines virtuelles Linux, grâce à une seule commande:
'lxc'.

➔ La documentation officielle de LXD est disponible ici.

Qu’est ce qu’un container ou ‘conteneur’

Un container est une solution logicielle ressemblant de prime abord à une machine virtuelle, qui
permet d’exécuter des applications dans un environnement confiné et isolé, en consommant très
peu de ressources.

Différences entre machine Virtuelle et Container

Avec une machine virtuelle (VM), le matériel de la machine hôte est utilisé tandis ce que le noyau
du système émulé est créé par la VM.
Cette particularité consomme pas mal de ressources mais permet de disposer de plusieurs VM,
chacune pouvant faire tourner son propre système d’exploitation.
Beaucoup plus léger qu’une machine virtuelle (VM), un container ne virtualise pas un système
complet (Hardware + SoftWare) mais se contente de simuler uniquement le système d’exploitation,
en s’appuyant sur des fonctions telles que les espaces de noms et les groupes de contrôle du noyau
Linux, afin d’isoler totalement ce système de la machine hôte.

Différences entre 'Container d’Application' et 'Container Systèmes'

A la différence de solutions telles que Docker fournissant une solution orientée ‘Container
d’application’ qui vise à associer UN container à UNE application, LXD est une solution de gestion
de ‘Container Systèmes’, favorisant l’exécution de plusieurs applications sur un même container.

Labo container et VM v 231202 Jean GAUTIER

Containérisation + Virtualisation = LXD
https://linuxcontainers.org/lxc/ - https://wiki.debian.org/LXC

LXD est une surcouche à LXC qui consiste en une fonction d’hyperviseur de VM et de Containers

Configuration initiale pour exploiter LXD

Dans ce document, les manipulations présentées sont réalisées sur une machine Linux
Debian version 11, sous ‘root', afin de pouvoir saisir les commandes.

Il est préférable de configurer le noyau de la machine hôte, pour permettre le chargement des
‘namespaces’ au démarrage et autoriser tout utilisateur à lancer des containers.
Pour cela, il faut modifier le fichier d’amorçage ‘grub’ (/etc/default/grub)
GRUB_CMDLINE_LINUX="user_namespace.enable=1 namespace.unpriv_enable=1"

Les modifications ne sont prises en compte qu’après redémarrage

update-grub && reboot

Installation de LXD
LXD est installable sous Debian, via un paquet 'snap', il faut donc préalablement installer l’outil
de gestion de paquets 'snapd', ce qui n’est pas nécessaire sous Ubuntu, LXD étant ‘natif’

• apt update && apt install snapd -y

• snap install core lxd
• reboot

Configuration initiale de LXD

LXD fixe les options de configuration des containers par défaut en définissant un profil de base, qu’il
faut commencer par initialiser, avec la commande :
• lxd init

Would you like to use LXD clustering? (yes/no) [default=no]:

Do you want to configure a new storage pool? (yes/no) [default=yes]:
Name of the new storage pool [default=default]:
Name of the storage backend to use (cephobject, dir, lvm, btrfs, ceph) [default=btrfs]: dir
Would you like to connect to a MAAS server? (yes/no) [default=no]:
Would you like to create a new local network bridge? (yes/no) [default=yes]:
What should the new bridge be called? [default=lxdbr0]:
What IPv4 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]:
What IPv6 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]:
Would you like the LXD server to be available over the network? (yes/no) [default=no]:
Would you like stale cached images to be updated automatically? (yes/no) [default=yes]:
Would you like a YAML "lxd init" preseed to be printed? (yes/no) [default=no]:

Maintenant que LXD est installé et configuré, la commande 'lxc' va permettre la manipulation des
instances de Machines Virtuelles et de Containers Linux.

Labo container et VM v 231202 Jean GAUTIER

Mise en pratique
Comment créer et administrer une instance (Container ou VM)
Pour créer un container, il faut une image qui serve de modèle.
Il existe trois serveurs accessibles via Internet où il est possible de récupérer les images
de containers et de machines virtuelles

1. ubuntu: Contenant les images des versions stables d'Ubuntu

2. ubuntu-daily: Contenant les dernières versions d'Ubuntu
3. images: Contenant les images de diverses distributions Linux
➔ Les images peuvent également êtres visibles ici.

Commandes relatives aux images

Obtenir la liste des sites proposant des images en téléchargement :
lxc remote list

Obtenir la liste des images installées localement :

lxc image list
Pour obtenir la liste des images disponibles sur le serveur ‘images’ :
lxc image list images:
Pour obtenir la liste des images de type ‘alpine’ sur le serveur ‘images’ :
lxc image list images:alpine

Commandes relatives aux containers

Voir la liste des containers et leur état :
lxc list

Créer un nouveau container :

lxc launch images:<distribution>/<release>/<architecture> Nom-Container
Exemple : créer une instance de container nommée ‘deb-ct’ :
lxc launch images:debian deb-ct

Démarrer / stopper / redémarrer un container :

lxc start Nom-Container / lxc stop Nom-Container / lxc restart Nom-Container

Supprimer un container :
lxc delete Nom-Container

Obtenir des informations détaillées sur le conteneur :

lxc info Nom-Container

Créer un container stocké dans l’espace de stockage :

lxc launch -s stockage images:debian deb-ct

Programmer l’auto-démarrage d'un container :

lxc config set deb-ct boot.autostart=true

Labo container et VM v 231202 Jean GAUTIER

 Commandes relatives à l’exécution de commandes
Pour affecter un mot de passe au compte 'root' du container ‘CTN1' :
lxc exec CTN1 passwd

Pour ouvrir une console dans le container ‘CTN1’ :

lxc shell CTN1 ou lxc console CTN1 <Control> <A> puis <Q> pour en sortir

Lancer un shell dans le container :

lxc shell Nom-Container

Exécuter une commande dans un container :

lxc exec Nom-Container <commande>

Pour exécuter la commande ‘ls /etc’ dans le container ‘CTN1’ et revenir à la machine hôte :
lxc exec CTN1 -- ls /etc

Pour lancer le shell ‘sh’ afin d’entrer directement en commandes, dans le container ‘CTN1’ :
lxc exec CTN1 -- /bin/sh

Affecter un mot de passe au compte 'root' du container ‘deb-ct' :

lxc exec deb-ct passwd

Labo container et VM v 231202 Jean GAUTIER

 Commandes relatives aux copies, snapshot et import/export

Créer une copie du container CT-1 CT-1-copie

lxc copy CT-1 CT-1-copie

Créer un snapshot du container ‘CT-1’ en ‘snap-ct1’

lxc snapshot CT-1 snap-ct1

Restaurer le snapshot d'un container

lxc restore CT-1 snap-ct1

Afin de pouvoir importer ou exporter un container, il faut le convertir au format ‘image’

Conversion d’un container au format image
lxc publish CT-1 --alias=nom_image

Export de l’image d’un container

lxc image export nom_image /chemin/nom_image ← fournira un fichier au format archive

Import de l’image d’un container

lxc image import/chemin/nom_image tar.gz --alias=nom_image

Création du conteneur à partir de l'image

lxc init local:nom_image CT-1

Procédure de sauvegarde et d'import / export

Sauvegarde du container 'CT-1'

lxc export CT-1 /var/sauve/CT-1.tar.gz

Restauration du container 'CT-1'

lxc import /var/sauve/CT-1.tar.gz

Sur le serveur de sauvegarde en ‘192.168.100.252

lxc config set core.https_address 192.168.100.252:8443
lxc config set core.trust_password poseidon

Sur le serveur 'maître'

lxc remote add srv-slave 192.168.100.252 ← Désigne comme ‘srv-slave’ , le serveur sur lequel on exportera
lxc remote list

Sauvegarde d'un snapshot du container 'CT-1' vers le serveur 'srv-slave'

lxc snapshot CT-1
lxc info CT-1
lxc copy CT-1/snap0 srv-slave:CT-1-backup --verbose

Pour restaurer un container

lxc copy srv-slave CT-1-backup CT-1

Labo container et VM v 231202 Jean GAUTIER

 Commandes relatives aux fichiers et dossiers

Copier le fichier 'exo' de la machine hôte dans le dossier /var/ du container 'CTN1' :
lxc file push exo CTN1/var/

Copier le fichier '/home/fichier' du container 'CTN1', vers l'emplacement courant de l'hôte :

lxc file pull CTN1/home/fichier .

Monter le dossier '/doc' de l'hôte, dans le dossier '/var' du container 'CTN1' :

lxc config device add CTN1 Device disk source=/doc/ path=/var

Créer un espace de stockage local :

lxc storage create stockage dir source=/var/lxd (le dossier doit préalablement exister)

Monter le dossier '/etc/asterisk/' de 'deb-ct', dans le dossier '/var/test' de l'hôte (nécessite sshfs)
lxc file mount deb-ct /etc/asterisk/ /var/test

Liste des espaces de stockage

lxc storage list

Affiche les informations concernant l'espace de stockage lxd0

lxc storage info lxd0

Commandes relatives aux profils de configuration

Pour lister les profiles

lxc profile list

Permet de modifier la configuration du container 'CTN1'

lxc config edit CTN1

Permet d’éditer le profile nommé 'default'

lxc profile edit default

Créer un profile basé sur le profile 'default', ajoutant un lien réseau vers la carte 'eno1' :
lxc profile copy default new-profile
lxc profile device set new-profile eth0 nictype macvlan
lxc profile device set new-profile eth0 parent eno1 (où eno1 est une carte réseau de la machine hôte)

Labo container et VM v 231202 Jean GAUTIER

Opération sur les réseaux

LXC créé un espace de nom réseau pour chaque container qui se connecte à l’extérieur par une carte
réseau physique ou par un tunnel de type 'veth'.
Les containers se connectent par une carte réseau physique ou un tunnel, de type 'veth'

Pour la mise en réseau, il faut établir un pont entre la machine hôte et l’interface virtuelle veth du
container.
Le container sera donc dans le même domaine de diffusion que l'hôte

Par défaut LXC créé un pont de type NAT (lxdbr0) où chaque container démarré possède une
interface en mode tunnel (veth) dont l’extrémité est connectée au pont 'lxcbr0'

• Voir les connexions réseaux disponibles :

lxc network list
• Créer un nouveau réseau :
lxc network create LAN-1 ← Créer un nouveau réseau en mode ‘pont’, nommé LAN-1
• Pour éditer le réseau 'LAN-1' :
lxc network edit LAN-1
• Créer un réseau avec quelques paramètres pré-établis :
lxc network create LAN-1 ipv4.address=10.0.0.1/24 ipv4.nat=true ipv6.address=none
• Attacher un container à un réseau :
lxc network attach LAN-1 deb-ct eth0 ← Raccorde la carte ‘eth0’ du container ‘deb-ct’ au réseau
‘LAN-1’
• Ajouter une carte réseau à un container en la connectant à un pont :
lxc network attach LAN-2 deb-ct eth1 ← Connecte ou ajoute et connecte, la carte ‘eth1’ du container
‘deb-ct’ au réseau ‘LAN-2’
• Réserver une adresse DHCP pour un container :
lxc config device set CTN1 eth0 ipv4.address 192.168.100.250

• Créer une interface réseau liée à l'hôte :

lxc config device add deb-ct eth1 nic name=eth1 nictype=macvlan parent=eno1
Cette commande ajoute une carte ‘eth1’ au conteneur ‘deb-ct’, attachée en mode ‘macvlan’ à
l’interface ‘eno1‘ de l’hôte (serveur LXD)

Labo container et VM v 231202 Jean GAUTIER

Le mode macvlan
Le mode ‘macvlan‘ permet de ‘greffer’ une interface d’un container sur une carte réseau physique de
la machine hôte.

Dans ce cas, une même carte physique apparaît comme ayant plusieurs adresses MAC !
➔ Il faut activer le mode promiscuité : ip link set enp0s3 promisc on
afin que le conteneur puisse communiquer avec les machines du réseau extérieur
à l'exception du serveur LXD.

Pour exploiter facilement cette caractéristique, il peut être intéressant de créer un profil spécifique et
de l’affecter ensuite aux containers qui en auraient besoin.

lxc profile copy default PROF-MAC

lxc profile edit PROF-MAC
• Ajouter la ligne nictype: macvlan après l'instruction 'name'
• Ajouter à la suite la ligne parent: enp0s3
• Supprimer la ligne avec l'instruction 'network'
lxc profile show PROF-MAC
lxc profile apply CTN1 PROF-MAC
lxc info CTN1

Labo container et VM v 231202 Jean GAUTIER

Établir une redirection de port (PAT)

Il est possible de rediriger des connexions TCP et UDP par redirection de port depuis la machine hôte, vers
l'instance concernée (Container ou V.M.).
Pour cela, il faut que la machine hôte ait une adresse IP affectée au pont réseau sur laquelle l'instance est
connectée.

Exemple :
Rediriger une connexion SSH sur l'hôte 192.168.100.30, vers l'instance 192.168.100.250 attachée au pont
'lxdbr0'
• lxc network forward create lxdbr0 192.168.100.30
• lxc network forward port add lxdbr0 192.168.100.30 tcp 2222 192.168.100.250 22

➔ Pour voir les redirections : lxc network forward show lxdbr0 192.168.1.200

Mettre en place un lien proxy entre l’extérieur et un container

Il faut établir une connexion de type 'Socket proxy' qui redirige les connexions visant un port local,
vers un socket en écoute sur le container.

Exemple :
Permettre l'accès au port TCP/22 du container 'DEB-CT', via le port 2222 local.
• lxc config device add DEB-CT proxy-ssh proxy listen=tcp:0.0.0.0:2222
connect=tcp:0.0.0.0:22
où 'proxy-ssh' est le nom que l'on donne à ce proxy et où '2222 est le n° de port virtuel que
l'on visera pour se connecter au port 22 du container

Exemple :
Établir un proxy pour le port UDP 5060 (protocole SIP) pour le container 'DEB-CT'

Le nom du device sera : ‘port-sip’, il redirigera

• lxc config device add DEB-CT port-sip proxy listen=udp:0.0.0.0:5060
connect=udp:127.0.0.1:5060

Voir l'état de configuration du container :

• lxc config device show DEB-CT

Labo container et VM v 231202 Jean GAUTIER

LXD et VLAN

Opérations et commandes diverses

Taguer des trames dans un container LXC :
• lxc config device set <container> eth0 vlan=100

Affecter les containers de CT-10→CT-20 à une interface vlan

for i in $(seq 10 20); do lxc config device set ct-$i eth0 parent vlan$i;done

Création d’un interface VLAN99

• ip link add link enp0s3 name VLAN99 type vlan id 99

Création d’un profile de containers LXC pour associer la carte réseau au Vlan99
• lxc profile copy default VLAN99 ← on créé le profil en partant du modèle ‘default’
• lxc profile device set VLAN99 eth0 nictype macvlan
• lxc profile device set VLAN99 eth0 parent VLAN99

Labo container et VM v 231202 Jean GAUTIER

Repartir des containers sous différents Vlans avec OVS
En utilisant OpenVSwtich (OVS), il est facile de créer des Vlans afin de séparer les containers dans des
Vlans différents.
Dans l’exemple qui suit, on cherche à créer deux vlans : ‘Vlan10’ et ‘Vlan20’ et y attacher 2 x nouveaux
containers ‘alpine’: ‘CT1-ALP’ et ‘CT2-ALP’.

Etape 1 - On commence par installer OpenVSwitch

• apt install openvswitch-switch

Etape 2 - Ensuite, 2 x solutions :

✔ Solution 1 : On créée un switch unique avec les interfaces dédiées aux différents vlans
(une interface/vlan)
✔ Solution 2 : On créé un switch principal ; auquel on attache des ‘fake bridges’,
chacun s’occupant d’un Vlan

Solution 1
On créé un switch nommé SW-BAT_A, on y attache 2 x interfaces internes avec tag vlan associé et
l’interface physique ‘eth0’, agissant alors comme un Trunk (vlan 1 /10/20)
• ovs-vsctl --may-exist add-br SW-BAT_A
• ovs-vsctl add-port SW_BAT_A eth0
• ovs-vsctl --may-exist add-port SW-BAT_A vlan10 tag=10 -- set interface vlan10 type=internal
• ovs-vsctl --may-exist add-port SW-BAT_A vlan20 tag=20 -- set interface vlan20 type=internal
➔ Le switch comporte deux interfaces en mode ‘access’ (une/vlan)

Solution 2
On créé un switch nommé SW-BAT_A et on y attache 2 x ‘fake-bridge’ et l’interface physique
‘eth0’, agissant alors comme un Trunk (vlan 1 /10/20)
• ovs-vsctl --may-exist add-br SW-BAT_A
• ovs-vsctl add-port SW_BAT_A eth0
• ovs-vsctl --may-exist add-br vlan10 SW-BAT_A 10
• ovs-vsctl --may-exist add-br vlan20 SW-BAT_A 20
➔ Le switch comporte un ‘fake-bridge’/vlan, chacun ayant une interface en mode ‘access’

Etape 3 - On créer ensuite deux profiles de containers en répliquant le profil ‘default’ de LXD
• lxc profile copy default profile-vlan10
• lxc profile copy default profile-vlan20

Etape 4 - On édite ensuite les profiles afin de définir l’interface parent qui lui correspond :
• lxc profile edit profile-vlan10 → parent: vlan10
• lxc profile edit profile-vlan20 → parent: vlan20

Etape 5 - On créé les containers nouveaux en définissant pour chacun, le profile auquel il s’attache
• lxc launch images:alpine/3.18 CT1-ALP -p profile-vlan10
• lxc launch images:alpine/3.18 CT2-ALP -p profile-vlan20

Labo container et VM v 231202 Jean GAUTIER

Utiliser un WebUI pour administrer un serveur LXD
On peut utiliser la solution LXDWARE consistant à exploiter un container ‘Ubuntu’ en y intégrant les outils et pages
d’administration du serveur LXD
A - Installation et mise en œuvre
1. Installer le container :
lxc launch images:ubuntu/22.04 lxd-dashboard
2. Entrer dans le shell du container :
lxc exec lxd-dashboard /bin/bash
3. Installer les composants nécessaires :
apt update && apt install wget nginx php-fpm php-curl sqlite3 php-sqlite3 -y
4. Récupérer le programme lxdware :
wget https://github.com/lxdware/lxd-dashboard/archive/v3.4.0.tar.gz
5. Désarchiver le fichier :
tar -xzf v3.4.0.tar.gz
6. Établir la déclaration du site WEB :
cp -a lxd-dashboard-3.4.0/default /etc/nginx/sites-available/
7. Installer le site WEB :
cp -a lxd-dashboard-3.4.0/lxd-dashboard /var/www/html/
8. Adapter la configuration pour utilisation de python 8 en modifiant le fichier '/etc/nginx/sites-enabled/default'
server {
listen 80 default_server;
listen [::]:80 default_server;
root /var/www/html/lxd-dashboard;
index index.php index.html;
server_name _;
location / {
try_files $uri $uri/ =404;
}
location ~ \.php$ {
#include snippets/fastcgi-php.conf;
#fastcgi_pass unix:/var/run/php/php7.4-fpm.sock; → commenter cette ligne
fastcgi_pass unix:/var/run/php/php8.1-fpm.sock; → dé-commenter cette ligne
fastcgi_param SCRIPT_FILENAME
$document_root$fastcgi_script_name;
include fastcgi_params;
include snippets/fastcgi-php.conf;
}
}
9. Création des dossiers d'insertion de données :
mkdir -p /var/lxdware/data/sqlite && mkdir -p /var/lxdware/data/lxd && mkdir -p /var/lxdware/backups
10. Affectation des permissions d'accès au dossier :
chown -R www-data:www-data /var/lxdware/ && chown -R www-data:www-data /var/www/html
11. Redémarrage du service :
systemctl restart nginx
12. Sortir du container pour mettre en place une connexion de type proxy :
Afin de se connecter depuis l’extérieur, on peut mettre en place un 'proxy' nommé 'proxy-http' sur le port local
TCP/8080 (par exemple), qui redirigera les connexions vers le port TCP/80 du container 'lxd-dashboard' :
lxc config device add lxd-dashboard proxy-http proxy listen=tcp:0.0.0.0:8080 connect=tcp:0.0.0.0:80

Labo container et VM v 231202 Jean GAUTIER

B – Configuration de LXDWare

On se connecte avec un navigateur WEB depuis une machine extérieur en visant l’adresse IP du serveur
LXD, sur le port 8080
• Il faudra définir un compte et un mot de passe, pour pouvoir ensuite se connecter

Il s’agit ensuite d’ajouter le serveur LXD , à la liste des ‘Remote Hosts’

Pour cela, il faut cliquer sur + Add Host et définir le serveur

On spécifie l’adresse du serveur LXD et le port n°8443

➔ Ce port sera ouvert automatiquement sur le serveur LXD, dés que la procédure indiquée ci-après,
sera réalisée :

Avant de valider, il faut suivre la procédure

indiquée en cliquant sur le lien ‘here’
L’objectif est double :
Définir un certificat permettant d’accepter les échanges entre
l’application ‘LXDWare’ et le serveur LXD

Créer un proxy HTTP sur le port 8443 permettant au serveur

LXD de communiquer avec LXDWare

➔ On accède au serveur LXD et on peut utiliser aisément l’ensemble des fonctions

d’administration à distance

Labo container et VM v 231202 Jean GAUTIER

Installer une instance de VM 'MS Windows' sous LXD
Dans cet exemple de procédure, le fichier ISO utilisé est win10,iso, installé sous /var/lxd.

Il s'agit de l’image officielle de MS Windows 10 obtenue par téléchargement sur le site de Microsoft.
Préparation
➢ Il faut commencer par installer l'application 'distrobuilder' qui permet de modifier l'image ISO afin
d'y insérer des fonctions permettant l’accès à distance lors de la procédure d’installation.

✗ snap install distrobuilder --classic --edge

✗ apt install -y libguestfs-tools wimtools genisoimage virt-viewer
✗ distrobuilder repack-windows win10.iso win10.lxd.iso --windows-version=w10
➔ On obtiendra une nouvelle image : ‘win10.lxd.iso’ (prend un certain temps !)
➢ Il faut s'assurer que la ligne 'X11Forwarding yes' du fichier '/etc/ssh/sshd_config' est bien présente
dans la configuration ssh de la machine hôte.

➢ Il faut prévoir un client SSH distant avec environnement graphique, depuis lequel seront effectuées
les manips en mode graphique.

Lancement de la procédure de création de la VM

• lxc init win10 --vm --empty -c security.secureboot=false
• lxc config device override win10 root size=50GiB
• lxc config set win10 limits.cpu=4 limits.memory=4GiB
• lxc config device add win10 /var/iso/win10.lxd.iso disk source=/var/lxd/win10.lxd.iso
boot.priority=10
• lxc start win10 --console

Si nécessaire, il est possible d'entrer dans le 'Setup' de la machine virtuelle, en appuyer de

manière répétée sur 'esc' (Pour quitter le 'setup' : 'ctrl+a-q')

Connexion à distance à l'écran de visualisation graphique

Depuis un poste client distant, se connecter en ssh avec l'option -X :

• ssh -X root@machine_hôte

• Saisir la commande : 'lxc console win10 --type=vga'

➔ Une fenêtre graphique doit s'ouvrir dans laquelle sera redirigée la sortie graphique de la VM
Windows

• A la fin de la procédure d'installation, retirer le 'CDROM' :

lxc config device remove win10 win10.lxd.iso

Labo container et VM v 231202 Jean GAUTIER

Cluster LXD - Initialisation
Afin de permettre la mise en haute disponibilités des instances de VM et de containers, LXD fournit un
ensemble de solutions techniques permettant de mettre en place un Cluster.

NB
Il est nécessaire de prévoir au moins 3 nœuds pour constituer un cluster, ceci afin de pouvoir atteindre un
‘quorum’ suffisant.
Si on ajoute des nœuds existant et possédant déjà une configuration et des instances, tout sera perdu sur le
nœud ajouté.

Visualisation des clusters

• lxc cluster list

Créer automatiquement un cluster en utilisant 'microcloud' intégrant 'OVN' et le stockage 'CEPH'

• snap install lxd microceph microovn microcloud
• microcloud init
➔ Tout se fait automatiquement …...

Préparation et mise en place

2 x méthodes :
1. Spécifier un mot de passe partagé
➔ A faire si on souhaite utiliser cette méthode d’intégration
• lxc config set core.trust_password=poseidon

2. Créer un jeton permettant à un nœud, de joindre un cluster

➔ A faire pour chaque nœud que l’on souhaitera ajouter
• lxc cluster add node2

Créer un certificat et l'approuver dans le cluster

➔ A faire sur le premier 'node'
• mkdir ~/.osm
• openssl req -nodes -new -x509 -keyout ~/.osm/client.key -out ~/.osm/client.crt -days 365 -subj
"/C=FR/ST=Nice/L=Nice/O=ETSI/OU=OSM/CN=osm.etsi.org"
• lxc config trust add local: ~/.osm/client.crt

Labo container et VM v 231202 Jean GAUTIER

Cluster LXD - Mise en réseau et gestion du stockage

Création des réseaux dans un cluster

Étape 1 - Préparer le même réseau sur chaque node
• lxc network create --target node1 LAN
• lxc network create --target node2 LAN
• lxc network create --target node3 LAN

Étape 2 - Instancier les réseaux

• lxc network create LAN
Exemple (le réseau s'appelle 'LAN')
• lxc network create LAN --type=physical parent=br0 --target=node1
• lxc network create LAN --type=physical parent=br0 --target=node2
• lxc network create LAN --type=physical parent=br0 --target=node3
• lxc network create LAN --type=physical

Pour attacher une instance à un réseau,

2 x possibilités :
• soit : lxc network attach LAN CT-1 eth0
• ou bien : lxc config device add CT-1 eth0 nic network=LAN

Cluster - Stockage des données

Création d’un pool de stockage 'DATA' dans le cluster
• lxc storage create --target node1 DATA zfs source=/dev/vdb1
• lxc storage create --target node2 DATA zfs source=/dev/vdc1
• lxc storage create --target node3 DATA zfs source=/dev/vdb1 size=10GiB

Affectation du pool 'DATA'

• lxc storage create data zfs

Labo container et VM v 231202 Jean GAUTIER

Cluster LXD - Administration et pilotage
Administration d'un cluster
• lxc cluster list
• lxc cluster show node1
• lxc cluster info node1

Cluster - Exploitation
Lancer un container dans un 'node' particulier
• lxc launch ubuntu:22.04 CT-ubuntu --target node2

Déplacer un container dans un 'node' particulier

• lxc stop CT1
• lxc move CT1--target node2

Labo container et VM v 231202 Jean GAUTIER

LXD UI - Interface graphique d’administration en WebUI

Mise en place
• snap set lxd ui.enable=true
• systemctl reload snap.lxd.daemon
• snap restart --reload lxd
• lxc config set core.https_address:8443
• ou
• lxc config set core.https_address 192.168.100.1:1234 → (si le serveur dispose de cette adresse)

1. Sur la fenêtre proposée, on choisira de créer un nouveau certificat

2. On copie alors le certificat sur la machine ‘LXD’ (dans le dossier /root)

3. Sur le serveur LXD, on insère alors le certificat, dans le dépôt local des certificats
approuvés :

• lxc config trust add lxd-ui-192.168.100.3.crt

Labo container et VM v 231202 Jean GAUTIER

 4. On redémarre le navigateur WEB et on se connecte sur le socket du serveur LXD, ici :
https://192168.100.1:1234
➔ Les certificats disponibles sur ce serveur, sont présentés :

5. On sélectionne le certificat qui correspond à l’application et on accède alors au panneau de

commande général

➔ Il n’y a plus qu’à ….

Il existe aussi la solution LXD mosaic, plus lourde et à installer dans un container

Labo container et VM v 231202 Jean GAUTIER

LXD - Opérations diverses - Trucs et astuces

Affecter les containers LXC CT-10→CT-20 à une interface vlan

for i in $(seq 10 20); do lxc config device set ct-$i eth0 parent vlan$i;done

Taguer des trames dans un container LXC :

• lxc config device set <container> eth0 vlan=100

Création d’un interface VLAN99

• ip link add link enp0s3 name VLAN99 type vlan id 99

Création d’un profile de containers pour associer la carte réseau au Vlan99

• lxc profile copy default VLAN99 ← on créé le profil en partant du modèle ‘default’
• lxc profile device set VLAN99 eth0 nictype macvlan
• lxc profile device set VLAN99 eth0 parent VLAN99

Création d’un container ‘CT-1’, associé au profil ‘VLAN99’

• lxc launch images:alpine/3.18 CT-1 -p VLAN99

Labo container et VM v 231202 Jean GAUTIER