The ZATAZ network :: ZATAZ.com :: ZATAZ.net


Documentation : User-Mode Linux HOWTO

Date de publication : 9.3.2005
Date de modification : 9.11.2005

Contributeur : Eric Romang

Société : ZATAZ / http://eromang.zataz.com

Eric Romang co-fondateur de ZATAZ, avec Damien Bancal, supervise la direction technique de ZATAZ.

Situé au Luxembourg, Eric Romang a eu l'occasion au cours de ses années d'expériences dans le domaine au sein de datacenter de développer une expertise dans la haute disponibilité d'infrastructure, la mise en place de cluster MySQL, de solutions de stockages, de sauvegardes et de sécurisation d'environnement Linux.


Sommaire

Introduction aux UML

User-Mode Linux (UML) est une façon sécurisée de lancer différentes version de Linux sur une même machine, ou de lancer de façon sécurisée des processus Linux. Si vous tester des logiciels, de nouveaux kernel sans avoir a rebooter, désirez expérimenter de nouvelles distributions Linux sans avoir à réinstaller votre machine, ou encore mettre en place un pot de miel (HoneyPot) User-Mode Linux est alors fais pour vous.

User-Mode Linux vous fournis une machine vituel qui peut avoir plus de ressources hardware ou logiciels virtuelles que votre ordinateur physique. Le stockage de cette machine virtuel s'effectue dans un seul fichier sur votre ordinateur physique. Vous pouvez décider de ne donner accès à des ressources kernel qu'à ce qui sera configurer dans le kernel du serveur virtuel. Toutes actions sur le serveur virtuel n'a aucune répercution sur votre ordinateur physique ou les logiciels installés sur celui-ci.

Introduction au mode SKAS

Il est conseillé d'appliquer sur le kernel maître, celui de votre ordinateur physique, le patch SKAS.

Les effets du patch SKAS sur votre kernel maître augmente les performances de réactivité de vos UML. Un kernel patché avec SKAS est 30% plus rapide qu'un kernel normal. Grâce au patch SKAS il est possible de faire tourner jusqu'à 25 à 30 UML en même temps sans que la charge du serveur soit affectée.

Si vous lancer la commande ps sur le serveur maître, vous pourrez voir 4 processus par UML.

Si vous avez le mode SKAS d'activer sur votre kernel maître, vous pourrez voir ces lignes suivantes lors du démarrage d'un kernel esclave :

Checking for the skas3 patch in the host...found
Checking for /proc/mm...found

Pour appliquer le patch SKAS, il vous suffit de télécharger un kernel supporté par le patch SKAS et de patcher celui-ci avec ce même patch :

cat host-skas3-version.patch | patch -p1

Nous vous conseillons aussi d'appliquer le patch grsecurity sur le kernel maître afin de le sécuriser.

Patch UML

Le patch UML est utilisé sur le kernel hôte.

Pour appliquer ce patch il vous suffit de suivre la méthode suivante :

# Télécharger un kernel supporté par le patch UML.

# Télécharger le patch UML

# Décompressez le kernel et placer le patch UML dans le répertoire kernel.

# Pour configurer votre kernel, il vous suffit d'appliquer cette commande :

make menuconfig ARCH=um

# Pour compiler le kernel en lui même, il vous suffit d'appliquer cette commande :

make linux ARCH=um

Vous avez alors un binaire kernel, nommé linux à la racine du répertoire de votre kernel. Mettez, par exemple, dans un répertoire /usr/local/uml-kernel/ et rendez ce binaire exécutable par root uniquement.

# Pour compiler les modules du kernel, il vous suffit d'appliquer cette commande :

make module ARCH=um

# Pour installer les modules du kernel c'est à peu plus compliquer. Il vous faut monter le système de fichier hôte et installer les modules dans celui-ci. Les commandes suivantes vous donneront une petite idée :

mount /var/uml/shared/root_fs /mnt/loop -o loop
make modules_install INSTALL_MOD_PATH=/mnt/loop ARCH=um

Vous voila avec un kernel hôte et ses modules installés dans le système de fichier hôte

Nous vous conseillons aussi d'appliquer le patch grsecurity sur le kernel UML afin de le sécuriser.

Les fichiers COW (Copy On Write )

Un système de fichier hôte en lecture seul peut être couplé à un fichier COW accessible en écriture et lecture, les modifications envoyées au système de fichier hôte en lecture seul sont enregistrées dans le fichier COW. L'avantage de cette façon de procéder est de permettre de partager un seul système de fichier hôte pour plusieurs UML (gain d'espace disque).

Les utilitaires UML

Afin de controler, d'administrer vos différents UML des utilitaires sont mises à dispositions, nous vous conseillons de les installer.

  • uml_mconsole :

    L'utilitaire uml_mconsole est une interface de bas niveau du kernel UML. Cet utilitaire vous permet de réaliser plusieurs choses :

    • Récupérer la version du kernel UML d'un hôte.

    • Ajouter ou supprimer des éléments de l'UML (disques, interfaces réseaux, etc.)

    • Arrêter et redémarrer un hôte UML

    • Envoyer des commandes SysRq au kernel

    • Mettre en pause et résumé un UML

    • Effectuer des backup à chaud sans avoir à stopper l'hôte UML

    • Recevoir des notifications d'évènements de l'hôte UML

    • Monitorer l'état interne de l'UML

    Afin de pouvoir utiliser uml_mconsole, il vous faut activer "CONFIG_MCONSOLE" sous "General Setup" du kernel UML. Au démarrage vous devriez voir :

    mconsole initialized on /var/uml/hote1/.uml/umlNJ32yL/mconsole

  • uml_moo :

    Si vous utilisez un UML avec un élément COW (Copy On Write), il est envisageable de fusioner les changements du fichier COW dans un nouveau système de fichier.

  • uml_mkcow :

    La façon normale de créer un fichier COW est de spécifier un fichier COW non existant dans la ligne de commande UML, l'UML se chargera de le créer pour vous. Quelques fois vous désirez spécifier un nouveau fichier COW et vous ne désirez pas redémarrer l'UML pour le spécifier. uml_mkcow peut l'effectuer.

  • uml_net :

    Cet utilitaire est utilisé automatiquement par UML au lancement pour configurer le réseau, IP forwarding, le routing et les proxy arp.

  • uml_switch :

    Le démon de "switching" fournis un méchanisme pour créer des réseaux virtuels.

Mise en pratique : Création d'un système de fichier hôte Gentoo

# Télécharger un stage3 correspondant à votre architecture sur les mirroirs de Gentoo

# Compiler votre kernel hôte avec la méthode indiquée ci-dessus, mais n'effectuez pas encore l'installation des modules

Important : Pour que le kernel hôte puisse démarrer correctement un système Gentoo, il doit etre configuré pour ne pas monter automatiquement /dev (devfs) par défaut. De plus, vous vous serez assuré d'avoir inclus tmpfs (le "Système de Fichiers en Mémoire Virtuelle" - "Virtual Memory Filesystem"), les fichiers de démarrage de Gentoo Linux stockant par défaut leurs informations dans une petite partition tmpfs.

# Créer un répertoire /var/uml/gentoo-modele/

# Décompressez le stage3 dans ce répertoire

# Installer les modules du kernel UML dans ce répertoire avec la commande suivante :

make modules_install INSTALL_MOD_PATH=/var/uml/gentoo-modele/ ARCH=um

# Créer un répertoire /var/uml/gentoo-modele/usr/portage/distfiles

# Monter votre répertoire distfiles du serveur maître dans le répertoire /var/uml/gentoo-modele/ avec la commande suivante :

mount -o bind /usr/portage/distfiles /var/uml/gentoo-modele/usr/portage/distfiles

# Suivez la documentation d'installation Gentoo comme si vous installiez un véritable serveur.

# Avant de quitter le chroot du stage3, effectuer les opérations suivantes :

  • Editer le fichier /etc/inittab et rajouter :

    c0:12345:respawn:/sbin/agetty 38400 tty0 linux


  • Editer le fichier /etc/fstab et mettre :

    /dev/ubd/0 / ext3 noatime 0 0
    /dev/ubd/1 none swap sw 0 0
    none /proc proc defaults 0 0

  • Supprimer les services suivant :

    rc-update del consolefont boot
    rc-update del keymaps boot

  • Editer le fichier /etc/securetty et rajouter vc/0

# Finaliser l'installation suivant vos besoins

# Quitter le chroot et démonter les points de montages.

exit
umount /var/uml/gentoo-modele/usr/portage/distfiles

# Compressez le contenu du répertoire /var/uml/gentoo-modele/ :

tar cvjpf ~/gentoo.tbz2 /var/uml/gentoo-modele/

On part sur le principe que l'OS ne doit pas faire plus de 5G

mkdir /var/uml/shared/
cd /var/uml/shared/

On créé un fichier de 5G et on le convertis au format ext3.

dd if=/dev/zero of=root_fs.gentoo seek=$[5*1024*1024] count=1 bs=1k
mke2fs -Fj root_fs.gentoo

On monte ce fichier pour y décompresser l'archive gentoo.tbz2

mount -o loop root_fs.gentoo /mnt/loop
tar xvjpf gentoo.tbz2 -C /mnt/loop

On demonte le fichier et on le rend accessible en lecture seule.

umount /mnt/loop
chmod 444 /home/uml/shared/root_fs.gentoo

Nous voila avec notre système de fichier Gentoo accessible en lecture seule.

Mise en pratique : Préparation du réseau

Nous partons sur le principe d'utiliser TUNAP pour partager le réseau entre le serveur maître et les serveurs UML hôte.

Activez TUNAP et 802.1d Ethernet Bridging dans le kernel

Installons les utilitaires de configuration des bridges Ethernet 802.1d

emerge bridge-utils

On créé un groupe untrusted dans lequel seront mis tous les utilisateurs hôtes UML, ce groupe pourra aussi servir au monitoring des actions effectuées par grsecurity.

groupadd untrusted
chmod 660 /dev/net/tun
chown root.untrusted /dev/net/tun

Mise en pratique : Préparation de la mise en place d'un UML

Nous allons lancer chaque UML sous une identitée propre, pour cela il nous faut créer un utilisateur pour chaque UML.

useradd -s /bin/bash -d /var/uml/uml1 -g untrusted -m uml1

On va aussi créer un fichier swap de 128 M pour chaque UML

cd /var/uml/uml1
dd if=/dev/zero of=swap_fs bs=1k count=1 seek=$[128*1024]
mkswap -f swap_fs
chown uml1:untrusted swap_fs

Mise en pratique : Script de démarrage d'un UML

Nous allons lancer chaque UML dans un screen, ce qui nous permettra de prendre la main dessus d'un façon aisée, et nous attribuons une mémoire de 128 M pour chaque UML.

# launch_uml1.sh
#!/bin/bash
screen -S uml1 -d -m su - uml1 -c "cd /var/uml/uml1 ; /usr/local/uml-kernel/linux umid=uml1 mem=128m ubd0=/var/uml/uml1/root_fs.cow,/var/uml/shared/root_fs.gentoo ubd1=/var/uml/uml1/swap_fs con=null con0=fd:0,fd:1 eth0=tuntap,,aa:bb:cc:dd:ee:ff,0.0.0.0"

Rendre bien sûr exécutable ce script de démarrage.

Mise en pratique : Démarrage d'un UML

Pour démarrer un UML il vous suffit de taper la commande suivante :

./lunch_uml1.sh

Pour prendre la main sur celui-ci, taper la commande suivante :

screen -r uml1

Et voila le tour est joué, vous avez une gentoo tournant sur une gentoo.


Lien(s) Associé(s) :


contentRight


valider