Installation/Cobbler

Introduction

Ce document décrit le déroulement de l'installation de l'outil Cobbler. Cobbler est un serveur d'installation qui permet d'installer facilement et automatiquement des systèmes d'exploitations, virtualisés ou non via PXE. Nous allons détailler dans cette notice son installation, sa configuration et son utilisation.

Installation

La première chose à faire est de configurer le serveur DHCP car dans notre cas le serveur Cobbler n'est pas la même machine que le serveur DHCP. On doit donc déclarer la classe PXE pour le serveur Cobbler sur le serveur DHCP:

Fichier <path>/etc/dhcp/dhcpd.conf</path>

host cobbler
{
	option host-name "cobbler";
	ddns-hostname "cobbler";
	hardware ethernet 00:0C:29:78:28:47;
	fixed-address 192.168.0.98;
	allow booting;
	allow bootp;
	class "PXE" {
		match if substring(option vendor-class-identifier, 0, 9) = "PXEClient";
		next-server 192.168.0.98;
		filename "pxelinux.0";
	}
}

On redémarre le service DHCP

/etc/init.d/dhcpd restart

Ensuite une simple commande yum va permettre d'installer le service cobbler sur le serveur:

yum install PyYAML cobbler cobbler-web

L'installation est maintenant terminée.

Configuration

Au niveau configuration, on va dans un premier temps ajuster les paramètres de cobbler, il faut définir un mot de passe crypté qui sera le mot de passe root pour les machines installées en PXE et l'adresse IP du serveur cobbler.

On commence donc par créer le mot de passe crypté à l'aide de htpasswd. L'option -n pour afficher le résultat sur la sortie standard et -d pour forcer l’algorithme de cryptage à CRYPT.

/usr/bin/htpasswd -nd root
New password: [cobbler]
Re-type new password: [cobbler]
root:xH.KydRoK8CyQ

On peut donc maintenant éditer le fichier de configuration du serveur cobbler: Fichier <path>/etc/cobbler/settings</path>

default_password_crypted: xH.KydRoK8CyQ
next_server: 192.168.0.98
server: 192.168.0.98

Ensuite on va installer les services nécessaires au fonctionnement de cobbler:

yum install tftp tftp-server xinetd

/etc/init.d/xinetd start
/etc/init.d/cobblerd start
chkconfig xinetd on
chkconfig cobblerd on

Maintenant on va contrôler la bonne configuration de cobbler et ajuster les paramètres comme cela sera indiqué:

cobbler check

/etc/init.d/httpd start

vi /etc/xinetd.d/rsync

disable = no

:wq

yum install cman

cobbler get-loaders

yum install debmirror

vi /etc/debmirror.conf
# @dists="sid";
# @arches="i386";

/etc/init.d/cobblerd restart

cobbler sync

cobbler check

Cobbler est maintenant correctement configuré. L'étape suivante consiste à importer l'ISO de la distribution que l'on voudra rendre accessible via PXE. Dans notre cas nous allons utiliser CentOS et l'import ne peut pas se faire avec l'ISO de netinstall et l'ISO DVD comprend beaucoup trop de packages qui ne nous serviront pas.

Nous avons donc customisé un CentOS à l'aide du CD1 de CentOS. C'est donc cet ISO custom que l'on va utiliser pour l'import.

Il faut d'abord récupérer l'ISO de la CentOS customisé en local sur le serveur cobbler (par exemple dans le répertoire /downloads) puis:

# mount -t auto -o loop /downloads/CentOS-5.5-x86_64-core.iso /mnt/
# cobbler import --path=/mnt --name=Centos5 –arch=x86_64

# cobbler sync

# cobbler list
distros:
Centos5-x86_64
Centos5-xen-x86_64

profiles:
Centos5-x86_64
Centos5-xen-x86_64

systems:

repos:

images:

On constate donc dans la liste des distros et des profiles que l'ISO CentOS a bien été ajouté au serveur cobbler.

Maintenant on va créer le repo local. On pourrait utiliser le repo officiel de CentOS mais il faut savoir que le cobbler va récupérer localement tous les paquets depuis le repo. Cette opération demande beaucoup de temps et surtout beaucoup d'espace disque. Sachant que nous avons pas besoin de tous les paquets disponibles sur le repo officiel de CentOS nous allons créer un repo local avec très peu de paquets ce qui permettra d'occuper peu d'espace disque mais aussi et surtout de rendre l'installation via PXE encore plus rapide.

On procède ainsi:

• installer une CentOS de façon traditionnelle avec le minimun de paquets installés (éditeur vim)
• une fois installé on ne fais de mis à jour avec yum update mais on installe les paquets suivants (avec yum install): wget rsync slocate autoconf automake make imake m4 man
• on peut maintenant mettre à jour les paquets puis les récupérer avec yumdownloader:

mkdir /tmp/rpm
yum update -y
yum install yum-utils -y

rm -rf /root/rpm.log && rpm -qa > rpm.log

for i in $(cat /root/rpm.log) ; do yumdownloader $i --destdir=/tmp/rpm ; done

On peut maintenant créer le repo avec:

yum install createrepo createrepo /tmp/rpm/

Puis on déclare le repo dans cobbler:

cobbler repo add --mirror=/tmp/rpm/ --name=centos5-local cobbler reposync

On peut maintenant voir le repo avec:

cobbler list repos: centos5-local

On va ensuite modifier le fichier kickstart par défaut qui est le fichier permettant l'automatisation de l'installation de CentOS:

cd /var/lib/cobbler/kickstarts/
mv sample.ks sample.ks_bak
vi sample.ks

auth --useshadow --enablemd5
bootloader --location=mbr
clearpart --all --initlabel
text
firewall --disabled
firstboot --disable
keyboard fr-pc
lang fr_FR.UTF-8
url --url=$tree
$yum_repo_stanza
$SNIPPET('network_config')
reboot

rootpw --iscrypted $default_password_crypted
selinux --disabled
skipx
timezone --utc Europe/Paris
install
zerombr
autopart

%pre
$SNIPPET('log_ks_pre')
$kickstart_start
$SNIPPET('pre_install_network_config')
# Enable installation monitoring
$SNIPPET('pre_anamon')

%packages
$SNIPPET('func_install_if_enabled')

%post
$SNIPPET('log_ks_post')
$yum_config_stanza
$SNIPPET('post_install_kernel_options')
$SNIPPET('post_install_network_config')
$SNIPPET('func_register_if_enabled')
$SNIPPET('download_config_files')
$SNIPPET('koan_environment')
$SNIPPET('redhat_register')
$SNIPPET('cobbler_register')
$SNIPPET('post_anamon')

$kickstart_done

La configuration de notre cobbler est désormais correctement configuré et on peut effectuer un test d'installation d'une machine virtuelle. On crée une nouvelle machine virtuelle sans lui fournir de media sur lequel booter, on démarre la VM puis on précise que l'on veut booter via PXE, on verra ensuite une interface ou l'on précisera sur quel image on veut booter.

Interface Web

On va maintenant installer l'interface web permettant l'administration de cobbler puis la configurer:

yum install cobbler-web

Fichier <path>/etc/cobbler/modules.conf</path>

[authentication]
module = authn_configfile

[authorization]
module = authz_allowall

On créer le fichier de mot de passe <path>/etc/cobbler/users.digest</path> en mettant le login à cobbler et le mot de passe à cobbler

htdigest -c /etc/cobbler/users.digest "Cobbler" cobbler

On redémarre les services cobbler et apache

/etc/init.d/cobblerd restart
/etc/init.d/httpd restart

On peut maintenant se rendre sur l'interface avec un navigateur et avec l'URL: http://192.168.0.98/cobbler_web

Login / Mot de passe: cobbler / cobbler

KOAN

Koan est un petit programme qui s'ajoute à cobbler et interagit avec celui-ci pour la reinstallation et pour la gestion de la virtualisation. Koan signifie: kickstart over a network, on l'utilise donc sur un client pour utiliser cobbler. Dans notre cas, on va principalement l'utiliser pour le déploiement de machines virtuelles. On peut l'installer via yum mais une version plus à jour est disponible sur le repo epel.

Il est important de savoir, avant de commencer à utiliser cet outil, que l'image de CentOS que nous utilisons pour cobbler ne fonctionne pas lorsqu'on on installe une VM avec koan, en effet le kernel de la CentOS customisé est le 2.6.18-194.32.1.el5 et après de longues recherches on a pu constater que cette version de kernel posait problème, il faut donc recrée un ISO de CentOS customisé avec le kernel installé par défaut sur une fresh install (2.6.18-194.el5), donc lors du yum update il faut exclure la mise à jour du kernel (se référer ici encore à la notice qui indique comment customiser l'ISO de CentOS).

Une fois que le nouvel ISO est crée, on l'importe dans cobbler (de la même façon que ci-dessus) en prenant garde de le nommer avec une indication particulière qui permettra de ne pas confondre les 2 images (ici nous l'avons nommé: centxenvm-x86_64). On peut ensuite commencer à utiliser koan.

Donc les manipulations suivantes sont à effectuer sur le serveur Xen:

# cd /downloads
# wget http://download.fedora.redhat.com/pub/epel/5/x86_64/koan-2.0.9-1.el5.noarch.rpm
# rpm -i koan-2.0.9-1.el5.noarch.rpm

# koan --virt --profile=centxenvm-xen-x86_64 --server=192.168.0.98 --virt-type=auto --nogfx --virt-name=centos –virt-path=/home/xen/centos/
# xm create centos
Error: (2, 'Invalid kernel', 'xc_dom_parse_elf_kernel: ELF image has no shstrtab\n')

Edition du fichier <path>/etc/xen/centos</path> modifier la ligne

bootloader = "/usr/bin/pygrub"

par

#bootloader = "/usr/bin/pygrub"
kernel = "/boot/vmlinuz-2.6.18-194.el5xen"
ramdisk = "/boot/initrd-2.6.18-194.el5xen.img"

Recréation de la VM

# xm create centos
Mounting root filesystem.
mount: could not find filesystem '/dev/root'
Setting up other filesystems.
Setting up new root fs
setuproot: moving /dev failed: No such file or directory
no fstab.sys, mounting internal defaults 
setuproot: error mounting /proc: No such file or directory
setuproot: error mounting /sys: No such file or directory
Switching to new root and running init.
unmounting old /dev
unmounting old /proc
unmounting old /sys 
switchroot: mount failed: No such file or directory
Booting has failed.

# xm destroy centos
# xm console vm01 # VM installée depuis miroir centos donc kernel 2.6.18-194.el5
# mkinitrd --omit-scsi-modules --with=xennet --with=xenblk --preload=xenblk initrd-$(uname -r)-no-scsi.img $(uname -r)

recuperation de l'image ramdisk depuis la vm qui fonctionne vers le serveur xen

# scp initrd-2.6.18-194.el5xen-no-scsi.img root@192.168.0.21:/home/xen/ 

[ctrl] + [5] pour quitter la console

Edition du fichier <path>/etc/xen/centos</path>

#bootloader = "/usr/bin/pygrub"</nowiki>
kernel = "/boot/vmlinuz-2.6.18-194.el5xen"
ramdisk = "/home/xen/initrd-2.6.18-194.el5xen-no-scsi.img"

# xm create centos -c

Nous voilà sur la VM installé via koan

# yum install kernel-xen-2.6.18-194.el5

Edition du fichier <path>/etc/grub.conf</path> pour configurer le kernel par default sur le kernel non xen Edition du fichier <path>/etc/yum.conf</path> et ajouter

exclude=kernel*

Problème FATAL Module ipv6 not found

Problème "modules.dep no such file or directory"

# mkdir /lib/modules/2.6.18-194.el5xen
# depmod -a
# reboot

La VM installé depuis koan est désormais fonctionnelle.

Editer la taille des partitions avec les snippets

Par défaut, cobbler utilise tout l'espace du disque dur qu'il assigne à la partition /, on peut vouloir définir les partitions en fonction de la taille du disque. Pour cela, nous allons utiliser les snippets kickstart de cobbler. Les snippets (ou extraits) de kickstart sont un moyen de réutiliser les blocs de code commun entre les fichiers kickstart.

Donc pour pouvoir définir la taille d'une ou plusieurs partitions systèmes on procède ainsi:

Fichier <path>/var/lib/cobbler/snippets/pre_partition</path>

#set $hostname = $getVar('$hostname', None)
#set $hostpart = $getVar('$hostpart', None)
#set $disk = $getVar('$disk', 'sda')

#if $hostname == None
#set $vgname = "VolGroup00"
#else

#if $hostpart == None
#set $hostpart = $hostname.split('.')[0]
#set $vgname = $hostpart + '_sys'
#end if

#end if

clearpart --drives=$disk --initlabel
part /boot --fstype ext3 --size=200 --asprimary
part swap --size=12000 --asprimary
part pv.00 --size=100 --grow --asprimary
volgroup $vgname pv.00
logvol / --vgname=$vgname --size=60000 --name=sysroot --fstype ext3
logvol /home --vgname=$vgname --size=20000 --name=tmp --fstype ext3
logvol /var --vgname=$vgname --size=20000 --name=var --fstype ext3

#if $hostpart == "bing"
#logvol /var/www --vgname=$vgname --size=1000 --name=www
#else if $hostpart == "build32"
#logvol /var/fakedirectory --vgname=$vgname --size=123456789 --name=fake
#end if

On peut ajuster les partitions et la taille allouée en fonction des besoins.

On crée ensuite un nouveau fichier kickstart en se basant sur celui par défaut et on édite celui-ci:

cp /var/lib/cobbler/kickstarts/sample.ks /var/lib/cobbler/kickstarts/custom.ks

Fichier <path>/var/lib/cobbler/kickstarts/custom.ks</path>

# avant: %pre
# supprimer la ligne: autopart
# ajouter: $SNIPPET('pre_partition')

On édite ensuite le profil concerné via l'interface web de cobbler et on précise que l'on veut utiliser le fichier kickstart custom.ks au lieu de sample.ks, il faut pour finir lancer un sync de cobbler pour qu'il prenne en compte les modifications.