Le but de cet article est de continuer l’installation de notre serveur Xenserver 5.6 afin de compléter les points suivants:

• configuration du raid soft
• configuration de lvm
• ajout d’un dépot local d’image ISO
• ajout du de la partition de stockage des machines virtuelles.

Configuration du raid soft

Une fois connecté sur votre serveur XenServer (à l’aide du mot de votre fichier XML de configuration), taper les commandes suivantes.

dd if=/dev/sda of=/dev/sdb bs=512 count=1

Changer le type de partition (raid logiciel) du disque sdb à l’aide de l’outil fdisk:

echo -e "\nt\n1\nfd\nt\n3\nfd\nw\nx" | fdisk /dev/sdb

Créer les partitions RAID1:

mdadm --create /dev/md0 --level=1 --raid-devices=2 missing /dev/sdb1
mdadm --create /dev/md1 --level=1 --raid-devices=2 missing /dev/sdb3

Création d’un PV sur la partition /dev/md1

pvcreate /dev/md1

Créer la partition de racine:

mkfs.ext3 /dev/md0
cd / && mount /dev/md0 /mnt && rsync -a --progress --exclude=/sys --exclude=/proc --exclude=/dev/shm --exclude=/dev/pts / /mnt
mkdir /mnt/sys
mkdir /mnt/proc
sed -r -i 's,LABEL=root-\w+ ,/dev/md0 ,g' /mnt/etc/fstab
sed -r -i 's,LABEL=root-\w+ ,/dev/md0 ,g' /etc/fstab

Modifier le Initrd pour gérer la prise en charge du Raid Soft:

mkdir /root/initrd && cd /root/initrd
zcat /boot/initrd-`uname -r`.img | cpio -i && \
cp /lib/modules/`uname -r`/kernel/drivers/md/raid1.ko lib

Modifier le Init pour intéger ce changement:

q="echo Waiting for driver initialization."
sed -r -i "s,^${q}$,\n\necho Loading raid1.ko module\ninsmod /lib/raid1.ko\n${q}\n,g" init
q="resume /var/swap/swap.001"
sed -r -i "s,^${q}$,${q}\necho Running raidautorun\nraidautorun /dev/md0\nraidautorun /dev/md1,g" init
r=`grep mkroot /root/initrd/init`
sed -r -i "s|^${r}$|${r/sda1/md0}|g" init

Copier le initrd modifié dans les deux partitions de boot:

find . -print | cpio -o -c | gzip -c > /mnt/boot/initrd-`uname -r`.img
find . -print | cpio -o -c | gzip -c > /boot/initrd-`uname -r`.img

Installer Grub sur le deuxième disque et modifier la configuration pour utiliser la partition RAID:

grub-install /dev/sdb
sed -r -i 's,root=LABEL=root-\w+ ,root=/dev/md0 ,g' /mnt/boot/grub/grub.conf
sed -r -i 's,root=LABEL=root-\w+ ,root=/dev/md0 ,g' /mnt/boot/grub/menu.lst
sed -r -i 's,root=LABEL=root-\w+ ,root=/dev/md0 ,g' /boot/grub/grub.conf
sed -r -i 's,root=LABEL=root-\w+ ,root=/dev/md0 ,g' /boot/grub/menu.lst

Démonter le deuxième disque et rebooter:

cd ; umount /mnt || umount /dev/md0
sync
reboot

Une fois rebooter, il faut changer le type de partition pour le disque sda et ajouter les partitions au RAID:

echo -e "\nt\n1\nfd\nt\n3\nfd\nw\nx" | fdisk /dev/sda
mdadm -a /dev/md0 /dev/sda1
mdadm -a /dev/md1 /dev/sda3

Vous pouvez suivre l’avancement de la construction du RAID à l’aide de la commande :

cat/proc/mdstat

Création de l’entrepot de stockage de machine virtuelle sur Xen

xe sr-create type=lvm content-type=user device-config:device=/dev/md1 name-label="Local Storage"

Nous allons également créer un entrepot de stockage des images ISO local.

Vous choississez la taille que vous souhaitez. Dans notre cas, nous créons une partition de 20Go

lvcreate -L 20G -n iso `vgscan | grep "Found volume group" | cut -d "\"" -f 2`

Formater cette partition:

mkfs.ext3 /dev/`vgscan | grep "Found volume group" | cut -d "\"" -f 2`/iso

Créer un point de montage:

mkdir /iso

Faire en sorte de monter cette partition au démarrage du système:

export MYVOLUMEGROUP=`vgscan | grep "Found volume group" | cut -d "\"" -f 2`
lvchange -a y /dev/$MYVOLUMEGROUP/iso
mount /dev/$MYVOLUMEGROUP/iso /iso/

echo "# Local ISO Library" >> /etc/rc.local
echo "lvchange -a y /dev/$MYVOLUMEGROUP/iso" >> /etc/rc.local
echo "mount /dev/$MYVOLUMEGROUP/iso /iso" >> /etc/rc.local

Ajouter cet entrepot à la configuration de XenServer:

xe-mount-iso-sr /iso -o bind

L’installation est terminée.

Vous pouvez également ajouter les clés SSH d’ovh au cas où…

echo 'from="213.186.50.100" ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAIEAt3XaIhEoRK5sEKm6wtYyazLOx3w+Yv9+bpfEvLftHr2hxZ2TY2A655iwMbgvhHqsMuGEjK9yGkZIQbUgB6HvOgOWOwJSX6Gc9Ac7GuH11xSU8tHDuTQot6fVtgcm2Y/VUFi65Knz9rLHz7h/Zy29ek+UYav5T7juhBIuk57cDxs= root@cache.ovh.net' >> /root/.ssh/authorized_keys2
echo 'from="::ffff:213.186.50.100" ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAIEAt3XaIhEoRK5sEKm6wtYyazLOx3w+Yv9+bpfEvLftHr2hxZ2TY2A655iwMbgvhHqsMuGEjK9yGkZIQbUgB6HvOgOWOwJSX6Gc9Ac7GuH11xSU8tHDuTQot6fVtgcm2Y/VUFi65Knz9rLHz7h/Zy29ek+UYav5T7juhBIuk57cDxs= root@cache.ovh.net' >> /root/.ssh/authorized_keys2

Aujourd’hui, il est courant de multiplier les accès distants sur des machines. Si Telnet et les r-commandes répondaient à ce besoin, le besoin de sécurité les a écartés de la course. SSH permet donc d’accéder à une console distante de manière totalement sécurisée. Nous verrons dans ce tutoriel comment utiliser un client SSH mais aussi comment utiliser le SSH-agent pour faciliter le travail de tous les jours en s’identifiant rapidement.

La plupart du temps openSSH est déjà installé. Si cela n’est pas le cas il vous suffit de tapper dans une console :

sudo yum install openssh openssh-clients

ou

sudo apt-get install openssh-client

Pour se connecter simplement sur un serveur il vous suffit de tapper :

ssh <login>@<machinedist>

où login est le nom du compte que vous souhaitez utiliser et machinedist représente l’adresse IP ou le nom de la machine visée. Lors d’une premiere connexion, un message décrivant que la machine distante est inconnue vous sera retournée. Ensuite SSH vous demande s’il doit continuer ou pas. Répondez ‘Yes’ pour continuer. Cette étape permet de vérifier que la machine que vous souhaitez contacter et bien celle qui vous répond. Pour cela SSH utilise une empreinte (fingerprint en anglais) correspondant ni plus ni moins à une suite de valeurs héxadécimales. Une fois acceptée, cette empreinte sera ajoutée à votre liste d’hôtes connus.

L’étape suivante est l’authentification. Par défaut, SSH utilise une authentification par mot-de-passe. Ca n’est pas la seule manière de s’authentifier. On peut utiliser une paire de clés publique/privée. La première est une clé que vous partagerez et copierez partout où vous souhaiteriez vous connecter (nous y reviendrons un peu plus tard), la seconde est en quelque sorte l’équivalent de votre nouveau mot-de-passe.

Pour générer une paire de clés, OpenSSH propose un outil. en tapant dans votre console :

ssh-keygen

vous pourrez créer simplement une paire. Vous pouvez, grâce à l’option ‘-t’ préciser quel type de clés vous souhaitez. Sachez que SSH1 utilise généralement des clés RSA1, et SSH2 des clés DSA.

ssh-keygen -t dsa

Le générateur va vous demander où sauvegarder les clés et vous demander une passphrase. Cette passphrase n’améliore en rien la clé ou la sécurité des échanges. Elle permet juste d’empêcher quelqu’un qui récupèrerait votre paire de clés de l’utiliser. C’est une phrase protégeant la clé. Lorsque le générateur a fini vous obtenez 2 fichiers :

• id_dsa ou id_rsa : la clé privé
• id_dsa.pub ou id_rsa.pub : la clé public

Nous allons désormais donner notre clé public à l’ordinateur distant, celui auquel nous souhaitons nous connecter. Pour ce faire utilisons cette commande :

ssh-copy-id -i ~/.ssh/id_dsa.pub <login>@<machinedist>

Pour utiliser notre clé et ainsi ne pas avoir à rentrer de mot-de-passe, il suffit désormais d’entrer :

ssh -i ~/.ssh/id_dsa <login>@<machinedist>

Nous pouvons encore améliorer notre confort par plusieurs procédés. Dans le cas où vous avez protégé votre clé privée par une passphrase, à chaque connexion cette passphrase vous est demandée. Ensuite il peut paraître ennuyeux de devoir tapper l’emplacement du certificat, le login et le nom de la machine distance (voir son IP…). Pas de panique, SSH répond à tous vos problèmes

D’abord créons un fichier ~/.ssh/config dans lequel nous placerons :

Host <NomDeConnexion>
User <login>
HostName <machinedist>

où NomDeConnexion représente un identifiant aléatoire vous permettant d’identifier le compte et la machine définient respectivement par login et machinedist.
Ainsi pour se connecter il suffira de tapper :

ssh -i ~/.ssh/id_dsa <NomDeConnexion>

Enfin, laissons SSH gérer nos clés et nous identifier avec la bonne clé. Pour ce faire, il suffit d’utiliser ssh-agent. Pour l’utiliser, initialisez votre terminal en le précédent de « ssh-agent » comme ceci :

# Voici quelques exemples d'initialisation. Adaptez a votre besoin
/usr/bin/ssh-agent gnome-terminal
/usr/bin/ssh-agent zsh
/usr/bin/ssh-agent bash

Une fois le terminal lancé, vous aurez besoin d’importer votre(vos) clé(s) grâce à :

ssh-add

ssh-add va ajouter votre clé ~/.ssh/id_rsa à la liste des clés utilisables par ssh-agent. Pour importer une clé supplémentaire il faut juste lui préciser où les trouver comme ceci :

ssh-add ~/.ssh/id_rsa_actinux1 ~/.ssh/id_rsa_actinux2

Dans le cas d’une protection de clé par passphrase, elle vous sera demandée (une seule fois ).
Vous pouvez lister à tout moment l’ensemble des clés contenues dans votre ssh-agent de part la commande :

ssh-add -l

Ensuite plus besoin de préciser le fichier de clé à utiliser pour se connecter :

ssh <NomDeConnexion>

Pour terminer je vous conseillerez de placer dans votre fichier rc (.zshrc ou .bashrc par exemple) votre ou vos ssh-add et d’ajouter le ssh-agent sur les raccourcis utiles (le gnome-terminal par exemple). Ainsi la seule étape que vous aurez à passer 1 fois par jour c’est d’entrer votre/vos passphrases à l’ouverture de votre terminal.

Ces productions sont assurées :

- soit par le travail personnel d’ingénieurs de la société en dehors de leur temps de travail

- soit avec le financement d’Actinux pendant le temps de travail.