« L'hyperviseur Xen sous Debian Wheezy » : différence entre les versions

Aller à la navigation Aller à la recherche

L'hyperviseur Xen sous Debian Wheezy (voir la source)

Version du 23 décembre 2012 à 18:12

29 115 octets ajoutés ,  23 décembre 2012
m
a déplacé L'hyperviseur Xen sous Debian Squeeze vers L'hyperviseur Xen sous Debian Wheezy
(Page créée avec « =Prérequis= Ce tutoriel se base sur l'utilisation de debootstrap pour installer une base de système d'exploitation debian. La plupart des hébergeurs proposent un système ... »)
 
 
(140 versions intermédiaires par le même utilisateur non affichées)
Ligne 1 : Ligne 1 :
[[Category:serveur]]
[[Category:debian]]
[[Category:virtualisation]]
=Prérequis=
=Prérequis=
Ce tutoriel se base sur l'utilisation de debootstrap pour installer une base de système d'exploitation debian. La plupart des hébergeurs proposent un système de "rescue" permettant l'installation de debian par ce moyen.
Ce tutoriel se base sur l'utilisation de debootstrap pour installer une base de système d'exploitation debian. La plupart des hébergeurs proposent un système de "rescue" permettant l'installation de debian par ce moyen.
Ligne 27 : Ligne 30 :
mkswap /dev/sda2
mkswap /dev/sda2
</pre>
</pre>
=Création du LVM=
Nous allons maintenant créer notre architecture LVM puis le système de fichier de la dernière partition.
Oui, mais pourquoi LVM ? Son principal atout pour moi est sa grande flexibilité vis a vis de redimensionnement. La ou le redimensionnement d'une partition peut être dangereux, sous LVM, le risque est très faible.
De plus, si vous utilisez plusieurs disques, LVM peut vous permettre d'étaler vos volumes logiques sur plusieurs disques (attention, ça n'aura rien à voir avec un raid ... naméoh).
Pour commencer, créez le volume physique :
<pre>$ pvcreate /dev/sda3
    Physical volume "/dev/sda3" successfully created
</pre>
Créez ensuite le groupe data :
<pre>
$ vgcreate main /dev/sda3
    Volume group "main" successfully created
</pre>
Si vous possédez plusieurs partitions/disques, ajoutez les à la suite de /dev/sda3 en les séparant par des espaces.
Vous pouvez vérifier les informations du groupe avec la commande vgdisplay:
<pre>
$ vgdisplay -v main
    Using volume group(s) on command line
    Finding volume group "main"
  --- Volume group ---
  VG Name              main
  System ID           
  Format                lvm2
  Metadata Areas        1
  Metadata Sequence No  5
  VG Access            read/write
  VG Status            resizable
  MAX LV                0
  Cur LV                0
  Open LV              0
  Max PV                0
  Cur PV                1
  Act PV                1
  VG Size              915.63 GB
  PE Size              4.00 MB
  Total PE              234401
  Alloc PE / Size      0 / 0 
  Free  PE / Size      234401 / 915.63 GB
  VG UUID              1rA2sx-9Kf5-ji5Z-pEj1-o4vu-R080-JoP4Ys
 
  --- Physical volumes ---
  PV Name              /dev/sda3   
  PV UUID              6PAMey-nGiG-1qqS-nrEZ-Bpey-qzJF-L1Ct1l
  PV Status            allocatable
  Total PE / Free PE    234401 / 234401
</pre>
Nous pouvons maintenant créer le volume logique data (utilisant tout l'espace disque) dans le groupe pve. Notez que la commande vgdisplay nous a permit d'identifier la dimension du volume (Total PE) que nous préciseront via l'argument -l :
<pre>
$ lvcreate -l51200 -n data main
    Logical volume "data" created
</pre>
Si vous le préférez vous pouvez aussi spécifier une taille en Gio. Par exemple :
<pre>
$ lvcreate -L 200g -n data main
</pre>
Vous pouvez vérifier les informations du volume avec la commande lvdisplay:
<pre>
$ lvdisplay -v /dev/main/data
    Using logical volume(s) on command line
  --- Logical volume ---
  LV Name                /dev/main/data
  VG Name                main
  LV UUID                BQ1JVv-k71y-L4YX-tMpA-klDk-7S4Y-nHB3Uj
  LV Write Access        read/write
  LV Status              available
  # open                0
  LV Size                200.00 GB
  Current LE            51200
  Segments              1
  Allocation            inherit
  Read ahead sectors    auto
  - currently set to    256
  Block device          253:0
</pre>
Vous noterez que je n'ai pas utilisé tout l'espace disque pour ce volume lvm. En effet, Xen permet de créer automatiquement des volumes logiques pour chaque VM que vous créerez.
Enfin, créez le système de fichier dans votre volume logique :
<pre>mkfs.ext4 /dev/main/data</pre>
==Augmenter la taille du groupe==
Si vous avez par exemple une partition /dev/sda4 que vous souhaitez ajouter à votre groupe lvm, rien de plus simple.
On commence par créer le lvm sur la partition sda4 :
<pre>pvcreate /dev/sda4</pre>
Puis ajoutez ce nouveau lvm à votre groupe main :
<pre>vgextend main /dev/sda4</pre>
==Augmenter la taille du volume logique==
On commence par démonter le système de fichier (je n'aime pas manipuler à chaud)
<pre>umount /data</pre>
On vérifie le fs :
<pre>e2fsck -f /dev/main/data</pre>
On redimensionne le volume logique :
<pre>lvresize -L 80g /dev/main/data</pre>
Pensez quand même à spécifier une taille supérieure à la taille précédente du volume ... sinon vous allez perdre des données =)
Puis on redimensionne le système de fichier contenu dans le volume :
<pre>resize2fs /dev/main/data</pre>
On peut enfin remonter
<pre>mount /dev/main/data /data</pre>
==Diminuer la taille du volume logique==
Soon (tm)
==Snapshot==
Pour cérer un snapshot nommé "test" du volume /dev/main/data :
<pre>lvcreate -L 10g -s -n test /dev/main/data </pre>
Pour merger un snapshot "test" modifié vers son volume d'origine :
<pre>lvconvert --merge /dev/main/test</pre>
=Installation du système de base=
<pre>
$ mount /dev/sda1 /mnt
$ debootstrap --arch=amd64 wheezy /mnt
...
I: Base system installed successfully
</pre>
=Configuration debian de base=
Afin d'avoir accès au réseau et au matériel, montez /proc, /dev et /sys dans votre nouveau système puis chrootez y:
<pre>
mount -o bind /proc /mnt/proc
mount -o bind /dev /mnt/dev
mount -o bind /sys /mnt/sys
chroot /mnt
</pre>
Editez le fichier <code>/etc/apt/sources.list</code> :
<pre>
deb http://ftp.fr.debian.org/debian wheezy main contrib non-free
deb-src http://ftp.fr.debian.org/debian wheezy main contrib non-free
#Sec
deb http://security.debian.org/ wheezy/updates main contrib non-free
deb-src http://security.debian.org/ wheezy/updates main contrib non-free
#anciennement debian-volatile
deb http://ftp.fr.debian.org/debian wheezy-updates main contrib non-free
deb-src http://ftp.fr.debian.org/debian wheezy-updates main contrib non-free
</pre>
Mettez les paquets à jour, puis installez les locales :
<pre>
aptitude update
aptitude safe-upgrade
aptitude install locales
dpkg-reconfigure locales
aptitude install console-data
dpkg-reconfigure console-data # from arch > french > latin9)
tzselect
dpkg-reconfigure tzdata
mkdir /srv/vm
</pre>
Configurez votre <code>/etc/fstab</code> :
<pre>
/dev/sda1      /      ext4    errors=remount-ro      0      1
/dev/sda2      swap    swap    defaults        0      0
/dev/main/data  /srv/vm    ext4    defaults        1      2
</pre>
Configurez <code>/etc/network/interfaces</code> :
<pre>
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet static
        address 91.121.117.116
        netmask 255.255.255.0
        network 91.121.117.0
        broadcast 91.121.117.255
        gateway 91.121.117.254
</pre>
Configurez votre fichier <code>/etc/hosts</code> :
<pre>
# Do not remove the following line, or various programs
# that require network functionality will fail.
127.0.0.1      localhost.localdomain localhost
91.121.117.116  ks355113.kimsufi.com
# The following lines are desirable for IPv6 capable hosts
#(added automatically by netbase upgrade)
::1    ip6-localhost ip6-loopback
feo0::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
ff02::3 ip6-allhosts
</pre>
Configurez l'hostname de votre serveur :
<pre>
echo xen > /etc/hostname
echo xen > /etc/mailname
</pre>
N'oubliez pas de configurer les dns (ceux de votre hébergeur dédié) :
<pre>
nameserver 213.186.33.99
</pre>
Nous allons commencer par installer un kernel debian classique afin de vérifier notre configuration
<pre>
aptitude install linux-image-2.6-amd64 linux-headers-2.6-amd64
</pre>
Puis installez le chargeur de démarrage grub
<pre>
aptitude install grub-pc
update-grub
</pre>
Installez le serveur ssh ainsi que lvm2 puis changez le mot-de-passe root :
<pre>
aptitude install lvm2 openssh-server
passwd
</pre>
Vous pouvez maintenant sortir de votre chroot et démonter le système de fichier
<pre>
exit
umount /mnt/sys
umount /mnt/dev
umount /mnt/proc
umount /mnt
</pre>
puis rebootez sur le disque dur.
=Installation de Xen=
<pre>aptitude install xen-hypervisor-amd64 xen-linux-system-amd64 xen-utils \
xen-tools bridge-utils xfsprogs</pre>
Vous pouvez accessoirement installer <code>molly-guard</code> pour éviter de rebooter involontairement votre dom0 :
<pre>aptitude install molly-guard</pre>
Désactivez les autres kernels ainsi que la recherche d'OS de grub :
<pre>
mkdir /etc/grub.d.disabled
mv /etc/grub.d/10_linux /etc/grub.d.disabled/
echo GRUB_DISABLE_OS_PROBER=true >> /etc/default/grub
echo GRUB_CMDLINE_XEN_DEFAULT="" >> /etc/default/grub
echo GRUB_CMDLINE_XEN="" >> /etc/default/grub
update-grub
</pre>
Vous pouvez redémarrer sur le kernel xen :
<pre>
reboot
</pre>
=Configuration globale de Xen=
Le fichier <code>/etc/xen/xend-config.sxp</code> permet de configurer le démon xend.
Si vous possédez plusieurs processeurs ou coeurs, vous pouvez forcer le nombre de cpu utilisé par le dom0 avec la directive (dom0-cpus X) où X est un nombre. Pour que le dom0 utilise tous les processeurs disponibles, définissez X à 0.
C'est aussi dans ce fichier que vous pouvez configurer le serveur vnc de xen pour les installations HVM.
Vérifier la présence du fichier <code>/etc/xen/scripts/hotplugpath.sh</code>. S'il n'existe pas, créez le :
<pre>touch /etc/xen/scripts/hotplugpath.sh</pre>
==désactiver le balooning==
Par défaut, l'installation debian de xen alloue de manière dynamique la mémoire allouée à l'hyperviseur (au dom0). Sur un host de virtualisation xen, il est cependant préférable d'allouer de manière fixe de la mémoire au dom0.
Modifier la ligne <code>GRUB_CMDLINE_XEN</code> dans <code>/etc/default/grub</code> :
<pre>
GRUB_CMDLINE_XEN="dom0_mem=512M"
GRUB_CMDLINE_XEN_DEFAULT="dom0_mem=512M"
</pre>
Puis mettez à jour la configuration de grub :
<pre>update-grub</pre>
Modifiez ensuite les lignes suivantes dans <code>/etc/xen/xend-config.sxp</code> :
<pre>
(dom0-min-mem 512)
(enable-dom0-ballooning no)
</pre>
Il faut bien évidemment rebooter pour appliquer ces paramètres.
==Forcer l'arrêt des VMs (shutdown) lors du reboot de xen==
Par défaut, si l'hyperviseur reboot, Xen sauvegarde l'état des VMs plutôt que de les shutdown proprement. Si vous voulez vous affranchir de ce comportement, modifiez <code>/etc/default/xendomains</code> :
<pre>
XENDOMAINS_RESTORE=false
XENDOMAINS_SAVE=""
</pre>
=Configuration réseau=
==Bridge==
Dans cette configuration, il est nécessaire d'avoir des IPFailOver disponibles ainsi que générer des adresses MAC pour vos VMs. Vos VMs seront ensuite directement accessible à partir du réseau internet.
Vérifier la présence de la ligne suivante dans /etc/xen/xend-config.sxp :
<pre>
(vif-script vif-bridge)
(network-script 'network-bridge bridge=br0')
</pre>
Editez le fichier <code>/etc/network/interfaces</code> de cette façon :
<pre>
auto lo
iface lo inet loopback
auto br0
iface br0 inet static
        address 91.121.117.116
        netmask 255.255.255.0
        network 91.121.117.0
        broadcast 91.121.117.255
        gateway 91.121.117.254
        bridge_ports eth0
</pre>
Il faudra ensuite rebooter
<pre>reboot</pre>
==NAT==
Dans cette configuration, il est nécessaire de créer un réseau local "interne" à xen. Les VMs auront une adresse ip à l'intérieur de ce réseau local, et ne deviendront accessibles depuis l'extérieur qu'après avoir ajouté une règle NAT sur le dom0
Il faut configurer les directives suivantes dans <code>/etc/xen/xend-config.sxp</code> :
<pre>
(network-script network-nat)
(vif-script    vif-nat)
</pre>
Assurez vous bien sur que les autres directives <code>(network-script</code> et <code>(vif-script</code> sont commentées !
Puis redémarrez xend
<pre>/etc/init.d/xend restart</pre>
=Configuration d'un serveur dns bind9 pour le dom0=
http://wiki.csnu.org/index.php?title=Installation_et_configuration_de_bind9
Si vous souhaitez utiliser le dom0 pour résoudre les dns de vos domU, ajoutez les ips de vos domU aux directives suivantes de <code>/etc/bind/named.conf.options</code> :
* <code>allow-query</code>
* <code>allow-recursion</code>
* <code>allow-query-cache</code>
Vos VMs devront avoir l'ip du dom0 dans leur fichier <code>/etc/resolv.conf</code>
=Configuration d'un serveur smtp pour le dom0=
=Protection SSH du dom0=
http://wiki.csnu.org/index.php?title=Prot%C3%A9ger_SSH_avec_sshguard
=Configuration de Xen-Tools pour créer automatiquement des machines virtuelles debian=
Par défaut sous debian wheezy, le fichier <code>/etc/xen-tools/xen-tools.conf</code> est adapté à la création de VMs debian wheezy.
Notre configuration permettra :
* de créer les partitions des VMs sur le LVM
* d'utiliser debootstrap pour créer des VMs vierges sous debian wheezy
* de configurer automatiquement l'ip sur la VM
Si vous utilisez un LVM comme présenté ici, ajoutez la ligne suivante dans /etc/xen-tools/xen-tools.conf :
<pre>lvm = main</pre>
main étant le nom du groupe de votre lvm (disponible avec la commande <code>vgdisplay</code>.
Configurez les informations réseaux de vos futurs VMs.
Si vous êtes en bridge ou en route :
<pre>
gateway    = IP-du.dom0.254
netmask    = 255.255.255.0
broadcast  = IP-du.dom0.255
bridge = br0
</pre>
Si vous êtes en NAT :
<pre>
gateway    = 192.168.0.254
netmask    = 255.255.255.0
broadcast  = 192.168.0.255
</pre>
Ou évidement, un autre range local défini dans la RFC1918.
Voici les options de configuration intéressante de xen-tools :
*<code>dist</code> : défini la distribution à installer par défaut.
*<code>size</code> : défini la taille de l'image disque par défaut d'une VM.
*<code>memory</code> : défini la quantité de mémoire vive alloué par défaut à une VM
*<code>swap</code> : défini la taille du swap par défaut pour les VMs
*<code>fs</code> : défini le système de fichier à utiliser pour les VMs. Généralement ext3 ou ext4.
*<code>image</code> : défini s'il faut utiliser des images complètes (<code>full</code>) ou a taille variable (<code>sparse</code>) pour les VMs. <code>full</code> donnera les meilleurs performances disque.
*<code>install-method</code> : défini la méthode d'installation par défaut pour les VMs. Les choix possibles sont :
**<code>debootstrap</code>
**<code>rinse</code>
**<code>rpmstrap</code>
**<code>copy</code> : un dossier d'une installation précédente sera utilisé. Il est obligatoire de configurer la directive <code>install-source</code> et d'y préciser le chemin du dossier à utiliser.
**<code>tar</code> : une archive tar d'une installation sera utilisé. Il est obligatoire de configurer la directive <code>install-source</code> et d'y préciser le chemin de l'archive tar à utiliser.
*<code>kernel</code> et <code>initrd</code> : spécifie le kernel que les VMs utiliseront. Par défaut, celui du dom0
*<code>arch</code> : l'architecture à utiliser lors de la création des VMs (amd64 ou i386)
*<code>mirror</code> : le miroir à utiliser pour debootstrap (par défaut, utilisation de celui configuré dans /etc/apt/sources.list)
*<code>nameserver</code> : les serveurs de nom a configurer sur la VM. Vous pouvez en ajouter plusieurs en les séparant par un espace. Si la directive n'est pas spécifié, Xen réutilisera les serveurs du dom0.
==Configuration des squelettes de VMs==
Le dossier <code>/etc/xen-tools/skel/</code> permet d'appliquer des modifications automatiquement après l'installation de la VM avec debootstrap.
Cela permet par exemple d'appliquer automatiquement des configurations à vos VMs.
Nous prendrons l'exemple du timezone et de la clé ssh root :
<pre>
mkdir /etc/xen-tools/skel/etc/
chmod 655 /etc/xen-tools/skel/etc/
cp --preserve=mode,ownership /etc/timezone /etc/xen-tools/skel/etc/
cp --preserve=mode,ownership /etc/localtime /etc/xen-tools/skel/etc/
mkdir /etc/xen-tools/skel/etc/skel
chmod 655 /etc/xen-tools/skel/etc/skel
cp --preserve=mode,ownership /etc/skel/.* /etc/xen-tools/skel/etc/skel/
mkdir -p /etc/xen-tools/skel/root/.ssh
chmod -R 700 /etc/xen-tools/skel/root
cp /root/.ssh/authorized_keys* /etc/xen-tools/skel/root/.ssh/
chmod 600 /etc/xen-tools/skel/root/.ssh/authorized_keys*
cp --preserve=mode,ownership /root/.bashrc /etc/xen-tools/skel/root/
</pre>
Ainsi, vos futurs VMs seront automatiquement configurées sous la même timezone que votre dom0
==Création d'un système d'upgrade et de backup automatique des VMs==
Pour commencer, créez :
* une clé ssh pour les upgrade
* une clé ssh pour les backups
* une clé ssh pour le login de l'utisateur root de votre dom0 vers les domU
<pre>
mkdir /etc/xen-tools/ssh-keys
ssh-keygen -t rsa -C "domU upgrade account key" -N "" -f /etc/xen-tools/ssh-keys/domU-upgrade-rsa
ssh-keygen -t rsa -C "domU backup account key" -N "" -f /etc/xen-tools/ssh-keys/domU-backup-rsa
ssh-keygen -t rsa -C "root@dom0" -N "" -f /root/.ssh/id_rsa
</pre>
Créer le fichier <code>/usr/bin/xen-aptitude</code> contenant :
<pre>
#! /bin/bash
case $1 in
        update|safe-upgrade)
                if [ $2 == "all" ]; then
                        domU=`xm list | grep -v -e "Name" -e "Domain-0" | sed -e 's/^\([^ ]*\) .*$/\1/'`
                        for dom in $domU; do
                                echo "Running $1 for $dom"
                                ssh -i /etc/xen-tools/ssh-keys/domU-upgrade-rsa root@$dom "sudo aptitude $1"
                        done
                else
                        if [ -z "$(xm list | grep $2)" ]; then
                                echo "Error: $2  is not a valid domU"
                        else
                                echo "Running $1 for $2"
                                ssh -i /etc/xen-tools/ssh-keys/domU-upgrade-rsa root@$2 "sudo aptitude $1"
                        fi
                fi
        ;;
        *)
                echo "Error: $0 update|safe-upgrade all|domU"
        ;;
esac
</pre>
Si vous exécutez <code>xen-aptitude update all</code> puis <code>xen-aptitude safe-upgrade all</code> tous vos domU seront mis à jour.
==Création d'un rôle personnalisé pour les VMs==
Les rôles permettent d'exécuter des actions automatiquement lors de la création d'une VM.
Nous allons créer un rôle réalisant les actions suivantes :
* installation des paquets <code>locales</code>, <code>ntp</code>, <code>console-data</code>, <code>dnsutils</code> et <code>sshguard</code>
* configuration des même locales que le dom0
* désactiver le login root par password en ssh
* transférer les différentes clés ssh public que nous avons créés précédemment
* permettre le login root par clé ssh uniquement à partir du dom0
* ajout des routes dans le cas d'une installation en mode bridge
* configuration de sshguard pour qu'il se lance au boot
voici le script à ajouter dans <code>/etc/xen-tools/role.d/main</code> :
<pre>
#!/bin/bash
#
#  This role :
# - install multiples packages
# - configures domU locales as in Dom0
# - disable root ssh password login and configure root ssh key authentication if available
# - allow only root login for ssh
# - add networks routes
# - configure sshguard
#
prefix=$1
#
#  Source our common functions - this will let us install a Debian package.
#
if [ -e /usr/lib/xen-tools/common.sh ]; then
    . /usr/lib/xen-tools/common.sh
else
    echo "Installation problem"
fi
#
# Log our start
#
logMessage Script $0 starting
#
# Install some usefull packages
#
logMessage Script $0 setting up packages
#
#
installDebianPackage ${prefix} locales #already installed in debian-wheezy domU
installDebianPackage ${prefix} ntp
installDebianPackage ${prefix} console-data
installDebianPackage ${prefix} console-common
installDebianPackage ${prefix} dnsutils
installDebianPackage ${prefix} sshguard
installDebianPackage ${prefix} psmisc
#
# locales
#
logMessage Script $0 configuring locales
#
#
cp /etc/locale.gen ${prefix}/etc/
chmod 644 ${prefix}/etc/locale.gen
chroot ${prefix} /usr/sbin/locale-gen
cp /etc/default/locale ${prefix}/etc/default/
chmod 644 ${prefix}/etc/default/locale
#
# ssh
#
logMessage Script $0 configuring ssh
#
#
echo "AllowUsers root" >> ${prefix}/etc/ssh/sshd_config
if [ ! -d ${prefix}/root/.ssh/ ]; then
        mkdir -p ${prefix}/root/.ssh
        chmod -R 700 ${prefix}/root
fi
dom0=""
for ip in `ifconfig | grep "inet addr" | cut -d ":" -f 2 | cut -d " " -f 1`; do
        if [ ! $ip = "127.0.0.1" ]; then
                dom0=$dom0$ip,
        fi
done
for ip in `ifconfig | grep -E "inet6 addr.*Global" | sed 's/^[ \t]*//;s/[ \t]*$//' | cut -d " " -f 3 | cut -d "/" -f 1`; do
        dom0=$dom0$ip,
done
trusted=`echo $dom0 | sed 's/^,*//;s/,*$//'`
if [ -f /etc/xen-tools/ssh-keys/domU-backup-rsa.pub ]; then
        echo from=\"$trusted\" `cat /etc/xen-tools/ssh-keys/domU-backup-rsa.pub` >> ${prefix}/root/.ssh/authorized_keys
fi
if [ -f /etc/xen-tools/ssh-keys/domU-upgrade-rsa.pub ]; then
        echo from=\"$trusted\" `cat /etc/xen-tools/ssh-keys/domU-upgrade-rsa.pub` >> ${prefix}/root/.ssh/authorized_keys
fi
if [ -f /root/.ssh/id_rsa.pub ]; then
        echo from=\"$trusted\"  `cat /root/.ssh/id_rsa.pub` >> ${prefix}/root/.ssh/authorized_keys
fi
sed -i -e 's/PermitRootLogin yes/PermitRootLogin without-password/g' ${prefix}/etc/ssh/sshd_config
#
# network routes
#
LogMessage Script $0 Adding network routes
#
#
gw=`cat /etc/xen-tools/xen-tools.conf | grep "gateway ="`
if [ ! ${gw:0:1} = "#" ]; then
        gateway=`echo $gw | cut -f 2 -d "="`
        echo up route add -host $gateway dev eth0 >> ${prefix}/etc/network/interfaces
        echo up route add default gw $gateway >> ${prefix}/etc/network/interfaces
fi
sed -i -e 's/gateway/#gateway/g' ${prefix}/etc/network/interfaces
#
# sshguard
#
LogMessage Script $0 Configuring sshguard
#
#
for ip in `ifconfig | grep "inet addr" | cut -d ":" -f 2 | cut -d " " -f 1`; do
        if [ ! $ip = "127.0.0.1" ]; then
                echo $ip >> ${prefix}/etc/sshguard_whitelist
        fi
done
for ip in `ifconfig | grep -E "inet6 addr.*Global" | sed 's/^[ \t]*//;s/[ \t]*$//' | cut -d " " -f 3 | cut -d "/" -f 1`; do
        echo $ip >> ${prefix}/etc/sshguard_whitelist
done
cp /etc/default/sshguard ${prefix}/etc/default/
#
#  Log our finish
#
logMessage Script $0 finished
</pre>
N'oubliez pas de rendre ce fichier exécutable :
<pre>chmod +x /etc/xen-tools/role.d/main</pre>
=Création de votre première VM=
Maintenant que tout est configuré, il ne reste plus qu'à créer votre première VM.
Si vous êtes en mode nat, rien de plus simple :
<pre>
xen-create-image --hostname vm1.domain.tld --ip <IP> --passwd --role main
</pre>
Pour le mode bridge, il va falloir préciser l'adresse mac de la carte réseau (générée dans l'interface de votre hébergeur) :
<pre>
xen-create-image --hostname vm1.domain.tld --ip <IP> --mac=AA:BB:CC:DD:EE:FF --passwd --role main
</pre>
Voici un autre exemple plus complet détaillant la création d'une VM ubuntu
<pre>
xen-create-image --size=10Gb --memory=512Mb --fs=ext3 \
--dist=natty --hostname=vm1.domain.tld --ip=<IP> --netmask=255.255.255.0 --swap=1024Mb \
--arch=amd64 --kernel=/boot/vmlinuz-2.6.32.5-xen-amd64 --mirror=http://archive.ubuntu.com/ubuntu/ --passwd --role main
</pre>
Si vous êtes en NAT, <IP> sera par exemple 192.168.0.X
Si vous êtes en bridge, <IP> sera une ipfailover.
==démarrage==
Pour lancer la VM :
<pre>xm create /etc/xen/vm1.domain.tld.cfg</pre>
Vous pouvez obtenir la liste des VM lancés avec :
<pre>xm list</pre>
Pour vous connecter à votre VM : deux options :
* SSH
* la console xen avec <code>xm console vm1.domain.tld</code>
Pour quitter la console xen tapez , ctrl altgr ]
==Démarrage automatique des VMs==
Créez en premier lieu le dossier <code>/etc/xen/auto</code> :
<pre>mkdir /etc/xen/auto</pre>
Placez ensuite les fichiers de configuration des VMs que vous souhaitez voir démarrer automatiquement dans ce dossier.
==Gestion de l'état des VMs==
* xm shutdown : arrêter une VM
* xm destroy : arrêter une VM immédiatement (l'équivalent de couper le courant de votre pc)
* xm list : liter les VMs activent
* xm reboot : redémarer une VM
* xen-list-images : lister les images disponibles
* xentop : un top pour vos VMs
==Prioriser une VM par rapport aux autres==
La commande <code>xm sched-credit</code> permet de visualiser le poids des VMs. Par défaut chaque VM crée a un poids de 256. Pour attribuer deux fois plus de temps CPU à une VM :
<pre>xm sched-credit -d vm1.domain.tld -w 512</pre>
=Annexes=
==Ajout d'un réseau interne==
Nous allons voir comment créer un réseau interne sous Xen, c'est à dire, attaché à aucune interface réseau physique. L'intérêt est d'offrir un débit bien supérieur pour les communications entre les VMs.
Commencez par éditer le fichier <code>/etc/network/interfaces</code>
<pre>
auto br1
iface br1 inet static
        address 192.168.10.1
        broadcast 192.168.10.255
        netmask 255.255.255.0
        bridge_ports none
</pre>
Puis activez l'interface :
<pre>ifup br1</pre>
Créez ensuite le fichier <code>/etc/xen/scripts/my-network-bridge</code> contenant :
<pre>
#!/bin/sh
/etc/xen/scripts/network-bridge "$@" netdev=br0
/etc/xen/scripts/network-bridge "$@" netdev=br1
</pre>
Et rendez le exécutable :
<pre>chmod +x /etc/xen/scripts/my-network-bridge</pre>
Enfin, il va falloir modifier la configuration de xend dans <code>/etc/xen/xend-config.sxp</code>. Remplacez la ligne <code>(network-script</code> précédente par :
<pre>(network-script my-network-bridge)</pre>
Ce script aura comme conséquence :
* créer le bridge classique de xen (celui qui était lancé par <code>(network-script network-bridge)</code>
* créer le bridge br0 pour notre interface interne
Il faut ensuite relancer xend :
<pre>/etc/init.d/xend restart</pre>
Vous pouvez vérifier l'existence des deux bridges avec :
<pre>brctl show</pre>
Il ne reste plus qu'a modifier le fichier de configuration des VMs.
Par exemple pour la vm <code>vm1.domain.tld</code> éditez le fichier <code>/etc/xen/vm1.domain.tld.cfg</code>. Modifiez la ligne <code>vif</code> de cette manière :
<pre>
vif  = [ 'ip=192.168.0.1,bridge=br0,mac=00:16:3E:A3:F1:5A','ip=172.16.16.2,bridge=br1,mac=00:16:3E:A3:F1:07' ]
</pre>
Après redémarrage, la VM aura désormais deux interfaces réseaux :
* eth0 bridgé sur l'interface br0 du dom0 (le réseau public)
* eth1 bridge sur l'interface br1 du dom0 (le réseau interne)
Si votre VM est sous debian, il faudra ajouter la configuration de eth1 dans <code>/etc/network/interfaces</code> (sur la vm!) :
<pre>
auto eth1
iface eth1 inet static
address 192.168.10.2
netmask 255.255.255.0
</pre>
Voila, vous n'avez plus qu'à tester le débit de votre réseau interne avec <code>iperf</code>.
Lors de la création des VMs avec <code>xen-create-image</code> il sera pratique de préciser l'option <code>--bridge=brname</code> afin de configurer la première interface de la VM.
source: http://wiki.xen.org/xenwiki/XenNetworkingExamples
Note : vous pouvez faire de même en ipv6 :
* il faut utiliser le range fd00::/8 (http://en.wikipedia.org/wiki/Unique_Local_Address)
* pour générer votre ula : http://www.kame.net/~suz/gen-ula.html
==Partitionnement personnalisé==
===Lors de la création d'une VM===
Xen permet de partitionner ses VMs très facilement lors de leur création.
Pour cela, il suffit de créer un fichier dans <code>/etc/xen-tools/partitions.d/</code> contenant le partitionnement souhaité. Par exemple <code>/etc/xen-tools/partitions.d/default</code> :
<pre>
[root]
size=1G
type=ext3
mountpoint=/
options=sync,errors=remount-ro
[swap]
size=2G
type=swap
[home]
size=10G
type=xfs
mountpoint=/home
options=nodev,nosuid
[var]
size=4G
type=xfs
mountpoint=/var
options=nodev,nosuid
</pre>
Lors de la création de l'image avec <code>xen-create-image</code> il faut préciser l'option <code>--partitions=file</code>. Par exemple :
<pre>
xen-create-image --hostname vm1.domain.tld --ip <IP> --passwd --role main --partition=/etc/xen-tools/partitions.d/default
</pre>
===Sur une VM déjà créée===
Nous allons voir comment ajouter une partition /home à notre vm1.domain.tld.
Commencez par créer la partition lvm :
<pre>
lvcreate -n vm1.domain.tld-home -L 10g main
mkfs.ext3 /dev/main/vm1.domain.tld-home
</pre>
Il faut ensuite ajouter notre image disque dans <code>/etc/xen/vm1.domain.tld.cfg</code> :
<pre>
disk        = [
                  'phy:/dev/main/vm1.domain.tld-home,xvda3,w',
                  'phy:/dev/main/vm1.domain.tld-root,xvda2,w',
                  'phy:/dev/main/vm1.domain.tld-swap,xvda1,w',
              ]
</pre>
Vous pouvez ensuite démarrer votre VM et éditer le fichier <code>/etc/fstab</code> (de votre VM!) pour y ajouter la partition /home
=issue=
==Erreurs du type IPv6 addrconf: prefix with wrong length 56==
Désactivez l'autoconfiguration ipv6 : créez un fichier /etc/sysctl.d/ip6.conf :
<pre>
net.ipv6.conf.all.autoconf = 0
net.ipv6.conf.default.autoconf = 0
net.ipv6.conf.lo.autoconf = 0
net.ipv6.conf.peth0.autoconf = 0
net.ipv6.conf.eth0.autoconf = 0
</pre>
==Pas assez d'interfaces loopback==
Créer le fichier <code>/etc/modprobe.d/local-loop.conf</code> contenant :
<pre>options loop max_loop=64</pre>
Vous pouvez ensuite redémarrer ou recharger le module loop :
<pre> rmmod loop && modprobe loop</pre>
==Impossible de résoudre les DNS en utilisateur dans un domU==
Vérifiez les droits sur <code>/etc/resolv.conf</code> :
<pre>chmod o+r /etc/resolv.conf</pre>
Pfoo
Bureaucrates, Administrateurs
4 231

modifications

Récupérée de « https://wiki.unscdf.org/index.php?title=Spécial:MobileDiff/818...1249 »

Menu de navigation