Primer punto que conviene aclarar: Si estás leyendo este manual conviene que tengas claro que yo no soy ni de lejos un experto ni en XEN ni en virtualización. Hace ya tiempo que queríamos entrar en estos temas y en una de esas nos animamos y empezamos a hacer nuestros pinitos en estas tecnologías.

Existen distintas alternativas con Software Libre para la virtualización. Algunos preferirán unas y otros preferirán otras, por ejemplo unos amigos nuestros están totalmente convencidos de que KVM es mejor alternativa. Anteriormente nosotros hemos virtualizado sistemas con VMWare y la verdad es que iba bien.

En ese sentido, no somos para nada talibanes. Si te gusta bien, y si no también. :-)

Seguro que hay cosas mejorables en el manual y probablemente faltarán otras, este manual es el resultado de una manualización interna que a nosotros nos sirve, sin más. Si encuentras alguna errata, quieres proponer algún cambio o simplemente quieres comentar algo, lo puedes hacer respondiendo a este post en nuestro blog, e intentaramos responder.

Hay muchas definiciones de lo que significa la virtualización, muy buenas por cierto. En la Wikipedia tienes al menos esta de virtualización y esta de XEN. Yo pretendo explicar con unos ejemplos cual es la razón de que hayamos empezado a utilizar esta tecnología.

Has comprado un servidor nuevo

Las máquinas que compramos hoy en día son muy potentes, tanto por la CPU como por la memoria que tienen. Frecuentemente necesitamos crear un nuevo servicio y nos da miedo implementarlo en un servidor que ya está en producción. Nos da miedo porque no sabemos los efectos colaterales que puede tener en otros servicios que ya están funcionando.

A veces preferimos curarnos en salud y a través de una nueva inversión adquirimos nuevo hardware en el que instalar el nuevo servicio, a pesar de que es probable que un servidor existente tenga capacidad suficiente para soportarlo. Nos quedamos más tranquilos si lo ponemos en otra máquina, por si las moscas ...

La virtualización nos ayuda con estos problemas. Dentro de un mismo servidor físico podremos tener distintos servidores virtuales, y a pesar de estar sobre el mismo hardware, a nivel lógico son servidores distintos y la configuración de uno es transparente para el otro.

En la sala de servidores no te caben más máquinas

Puede que no tengas espacio para meter un nuevo servidor, o que la UPS que te garantiza el suministro eléctrico de los servidores esté al límite de capacidad.

Esto es algo que nos ha ocurrido. Antes teníamos PCs que daban servicio a servicios no muy pesados, por ejemplo:

• Un servidor de fax con Hylafax, para lo cual teníamos un PC viejo con un modem. El PC no valía para otra cosa, pero ocupaba espacio y consumía de la UPS.
• Software específico de control de licencias en otro PC. Este programa nos solía dar conflictos con otros programas, por lo que lo teníamos aparte en un PC dedicado. Lo mismo que antes, ocupaba espacio y consumía de la UPS.
• Cada vez tenemos sistemas más complejos y críticos, y hacer el seguimiento de todos ellos es costoso, razón por la cual teníamos nagios instalado en otro PC viejo.
• etc, etc.

En estos casos un servidor nuevo tiene potencia suficiente como para soportar máquinas virtuales independientes para cada uno de estos servicios.

Quieres implementar un servicio de alta disponibilidad

La criticidad de los sistemas es cada vez mayor. Das un nuevo servicio a los usuarios y se vuelve imprescindible, de forma que si hay una parada tienes a todos los usuarios/clientes encima tuyo hasta solucionarlo.

La virtualización nos ayuda también en estos casos. Con dos (o más) servidores XEN puedes mover una máquina virtual de un servidor físico a otro con solo mover ficheros, con lo que la dependencia respecto del hardware se minimiza. Si se te rompe un servidor físico, solo tienes que arrancar el servidor virtual en el otro servidor físico

Tienes que actualizar un sistema crítico y te tiemblan las piernas

Alguno dirá que eres un cobarde. Que va, nada más lejos de la realidad, lo que pasa es que tienes experiencia y sabes que te la juegas (sobre todo si son sistemas Windows). ¿Nunca te ha pasado que estás en medio de una actualización, y por algún problema te quedas a medias? Ni se actualiza, ni está como al principio, ni lo uno ni lo otro, el sistema ha caido.

En estas situaciones la virtualización te permite hacer una copia del sistema que tienes en producción de forma que puedes hacer pruebas con la copia. Te dejan de temblar las piernas y puedes hacer cuantas pruebas quieras, y cuando estás seguro de que todo va bien, pones la copia en producción. ¿Que has tenido algún problema? tranquilo, era una copia. Bórrala y comienza de nuevo hasta conseguirlo.

El servidor que hemos comprado para la virtualización tiene una importancia especial, ya que sobre él van los servidores virtuales. Por esta razón merece la pena comprar un buén hardware. En nuestro caso, nos hemos decantado por un servidor Supermicro , con hardware soportado para Debian linux. Sus características son las siguientes:

• Dos procesadores
• 4 Gb de RAM (no hubiera sido malo ponerle 8)
• Controladora 3ware para gestión del Raid5. Tiene 4 discos SATA de 500 Gb. Con 3 discos montamos el Raid5 y el cuarto queda en modo HotSpare, de forma que si uno de los discos del Raid cae, el que está en HotSpare entra automáticamente al Raid. Además, esta controladora envía alertas por email, con lo que te avisa de lo que está pasando.

Todo esto, por 2.500 € (IVA incluido). Es dinero si, pero el servidor lo vale, y va a tener que trabajar.

Instalación del servidor Debian

Antes de instalar XEN hay que instalar el servidor físico. Nosotros lo hemos realizado sobre distribuciones Ubuntu Server y Debian Lenny  (64 bit). Lo primero es crear las particiones, en nuestro caso ha quedado así:

• Partición /boot : 1 Giga y como partición de arranque.
  

• Partición Swap

• Partición / : 8 Giga

• El resto como partición LVM
  

Es importante tener en cuenta que si queremos virtualizar máquinas Windows es necesario que el host físico tenga las X-Window instaladas, por lo que es mejor instalarlas desde el principio. No vamos a profundizar en esta parte, se supone que si vas a instalar XEN sabrás como se instala Debian.

Una vez hecha la instalación básica, en una consola ejecutamos lo siguiente:

apt-get update 
apt-get upgrade 
apt-get install openssh-server 

Instalación del servidor XEN

Dentro de Debian vamos a instalar el paquete de XEN. Al hacerlo instalará un kernel especial para XEN.

En un Ubuntu Server:

apt-get instal ubuntu-xen-server

En una Debian Lenny (32 bit):

apt-get install xen-linux-system-2.6.26-2-xen-686

En una Debian Lenny (64 bit):

apt-get install xen-linux-system-2.6.26-2-xen-amd64

Luego instalamos el paquete xen-tools:

apt-get install xen-tools

A continuación editamos el fichero “/etc/modules” y añadimos la opción “loop” :

loop max_loop=64 

Ahora tenemos que reiniciar el servidor. Cuando arranque podemos ver que lo hace con un kernel XEN:

root@IMH01XEN01:~# uname -a 
Linux IMH01XEN01 2.6.24-21-xen #1 SMP Mon Aug 25 18:56:44 UTC 2008 x86_64 GNU/Linux

Volúmenes Lógicos

Para cada máquina virtual vamos a crear un nuevo volumen lógico. Esto nos da opción de poder gestionar el volumen más adelante: aumentar su tamaño, etc.

Instalamos el paquete:

apt-get install lvm2

Editamos el fichero /etc/modules  y añadimos la opción: dm-mod

A continuación configuramos los volúmenes lógicos. Necesitamos saber cual es la partición LVM (con el comando fdisk), en nuestro ejemplo es la  /dev/sda4

pvcreate /dev/sda4

Ahora creamos el Grupo de volumen:

vgcreate volgroupxen /dev/sda4

Ahora creamos el volumen lógico para la máquina virtual. Hay dos opciones:

1. Si queremos virtualizar  sistemas Linux, es decir, si queremos tener un sistema parecido al que tiene el servidor físico (debian etch, ubuntu, ...) y queremos que estén paravirtualizados.
2. lvmcreate: para crear cualquier tipo de sistema virtual
   

Lo veremos enseguida con unos ejemplos.

En este ejemplo, utilizaremos  paravirtualización .

Necesitamos saber el kernel de la máquina física para crear la nueva máquina virtual. Para ello utilizamos el comando uname

root@IMH01XEN01:~# uname -r
2.6.24-21-xen

En este ejemplo vamos a crear una máquina virtual para soportar un servidor de BD. Estas son sus características:

• Nombre: XenDB
• Distribución Linux: etch
• Tamaño del disco duro: 10 Gb
• Tamaño de la Swap : 1 Gb .
  

Con el siguiente comando se crearía la máquina virtual. Automáticamente se crea el volumen lógico con el valor que le hemos dado.

root@IMH01XEN01:~# xen-create-image install-method=debootstrap --hostname=XenDB
--dist=etch --lvm=volgroupxen --fs=ext3 --dhcp --kernel=/2.6.24-21-xen
--force --initrd=/boot/initrd.img-2.6.24-21-xen --arch=amd64 --size=10G
--swap=1G 

Opción (para usarla con cuidado): Si utilizamos el parámetro "--force" si previamente existía una máquina virtual con el mismo nombre, la machacaría.

Ahora vamos a editar el fichero de configuración principal de Xen. Mejor hacer primero una copia.

cp /etc/xen/xend-config.sxp /etc/xen/xend-config.sxp.backup
nano /etc/xen/xend-config.sxp

En la gestión de interfaces activamos esta línea :

(network-script network-bridge)  

y reiniciamos el servicio:

/etc/init.d/xend restart

Ahora editamos el fichero de configuración:

nano /etc/xen/XenDB.cfg

Aquí podemos cambiar los parámetros que nos interesen (por ejemplo el tamaño de la swap) . Asegúrate de que el path del kernel es el correcto. En nuestro caso:

kernel      = '/boot/vmlinuz-2.6.24-21-xen'

Al final añade esta línea, sino al ejecutar el comando  xm console la consola no funciona:

extra="console=tty xencons=tty"

El comando de gestión de Xen es xm . Por ejemplo:

Para cargar el servidor virtual que hemos creado:

xm create XenDB.cfg 
xm console XenDB

Para apagarlo: 

xm shutdown XenDB

Si no responde:

xm destroy XenDB 

Si queremos que cuando arranque el servidor físico arranque también el virtual, hay que añadir este enlace simbólico:

ln -s /etc/xen/XenDB.cfg /etc/xen/auto/host.cfg

En este ejemplo queremos crear un  Ubuntu Intrepid Hearon, y como queremos que esté paravirtualizado, utilizaremos misma técnica que hemos utilizado antes al crear el servidor virtual con debian: debootstrap.

Para poder hacerlo, es imprescindible que en la carpeta /usr/lib/xen-tools/ del servidor físico exista un enlace o "soft link" con el nombre intrepid.d . Si no existiera no sabría como instalarlo.

root@IMH01XEN01:~# cd /usr/lib/xen-tools/ 

root@IMH01XEN01:/usr/lib/xen-tools# ls -la 

total 72 

drwxr-xr-x  9 root root  4096 2008-10-24 10:37 . 

drwxr-xr-x 87 root root 32768 2008-12-10 17:46 .. 

drwxr-xr-x  2 root root  4096 2008-10-24 10:37 centos-4.d 

drwxr-xr-x  2 root root  4096 2008-10-24 10:37 centos-5.d 

-rwxr-xr-x  1 root root  4409 2008-04-06 03:12 common.sh 

drwxr-xr-x  2 root root  4096 2008-10-24 10:37 dapper.d 

drwxr-xr-x  2 root root  4096 2008-10-24 10:37 debian.d 

drwxr-xr-x  2 root root  4096 2008-12-10 17:53 edgy.d 

lrwxrwxrwx  1 root root     8 2008-10-24 10:37 etch.d -> debian.d 

lrwxrwxrwx  1 root root    15 2008-10-24 10:37 fedora-core-4.d -> fedora-core-6.d 

lrwxrwxrwx  1 root root    15 2008-10-24 10:37 fedora-core-5.d -> fedora-core-6.d 

drwxr-xr-x  2 root root  4096 2008-10-24 10:37 fedora-core-6.d 

lrwxrwxrwx  1 root root    15 2008-10-24 10:37 fedora-core-7.d -> fedora-core-6.d 

lrwxrwxrwx  1 root root     6 2008-10-24 10:37 feisty.d -> edgy.d 

drwxr-xr-x  2 root root  4096 2008-10-24 10:37 gentoo.d 

lrwxrwxrwx  1 root root     6 2008-10-24 10:37 gutsy.d -> edgy.d 

lrwxrwxrwx  1 root root     6 2008-10-24 10:37 hardy.d -> edgy.d 

lrwxrwxrwx  1 root root     8 2008-10-24 10:37 lenny.d -> debian.d 

lrwxrwxrwx  1 root root     8 2008-10-24 10:37 sarge.d -> debian.d 

lrwxrwxrwx  1 root root     8 2008-10-24 10:37 sid.d -> debian.d 

Como no existe, lo creamos nosotros:

root@IMH01XEN01:/usr/lib/xen-tools# ln -s  edgy.d intrepid.d

Hay que hacer algo parecido para debootstrap:

cd /usr/share/debootstrap/scripts/  
ln -s edgy intrepid 

Ahora con este comando creamos la máquina virtual:

root@IMH01XEN01:/usr/lib/xen-tools# xen-create-image install-method=deboottstrap --hostname=XenUbuntuDesktop01 --dist=intrepid --mirror=http://es.archive.ubuntu.com/ubuntu/ --lvm=volgroupxen --fs=ext3 --dhcp --kernel=/2.6.24-21-xen --force --initrd=/boot/initrd.img-2.6.24-21-xen --arch=amd64 --size=10G –swap=1G

Este es el resultado:

General Information 
-------------------- 
Hostname       :  XenUbuntuDesktop01 
Distribution   :  intrepid 
Partitions     :  swap            1G    (swap) 
                  /               10G   (ext3) 
Image type     :  full 
Memory size    :  128Mb 
Kernel path    :  /2.6.24-21-xen 
Initrd path    :  /boot/initrd.img-2.6.24-21-xen 
Networking Information 
---------------------- 
IP Address     : DHCP [MAC: 00:16:3E:84:99:66] 
Removing /dev/volgroupxen/XenUbuntuDesktop01-swap - since we're forcing the install 
Removing /dev/volgroupxen/XenUbuntuDesktop01-disk - since we're forcing the install 
Creating swap on /dev/volgroupxen/XenUbuntuDesktop01-swap 
Done 
Creating ext3 filesystem on /dev/volgroupxen/XenUbuntuDesktop01-disk 
Done 
Installation method: debootstrap 
Done 
Running hooks 
Done 
No role scripts were specified.  Skipping 
Creating Xen configuration file 
Done 
All done 
Logfile produced at: 
     /var/log/xen-tools/XenUbuntuDesktop01.log

Si queremos ver cómo ha ido la instalación, podemos mirar el log:

/var/log/xen-tools/XenUbuntuDesktop01.log

Antes de arrancar, repasamos la configuración. Editamos el fichero de configuración:

cd /etc/xen 
nano XenUbuntuDesktop01.cfg

En el parámetro kernel yo tenía esto:

kernel      = '/2.6.24-21-xen' 

Y lo he dejado así:

kernel      = '/boot/vmlinuz-2.6.24-21-xen' 

Ahora para poner en marcha la máquina virtual:

xm create XenUbuntuDesktop01.cfg ; xm console XenUbuntuDesktop01

Como resultado nos da una consola de login, y podrás acceer como root (sin password).

La IP la coge a través de DHCP, tendrás que ejecutar ifconfig para ver cual tiene.

Por defecto no se instala gnome, y como nosotros lo vamos a necesitar lo instalamos:

apt-get install xorg gnome-core

Para poder conectarnos al Ubuntu Desktop mediante VNC primero tenemos que instalar el servidor de VNC en el ubuntu virtual

sudo apt-get install vnc4server

Ahora hay que configurarlo. En caso contrario al conectarnos no podremos utilizar Gnome. Instalamos nano y editamos el fichero de configuración.

apt-get install nano
nano .vnc/xstartup

Esto es lo que trae por defecto:

#!/bin/sh 
# Uncomment the following two lines for normal desktop: 
# unset SESSION_MANAGER 
# exec /etc/X11/xinit/xinitrc 
[ -x /etc/vnc/xstartup ] && exec /etc/vnc/xstartup 
[ -r $HOME/.Xresources ] && xrdb $HOME/.Xresources 
xsetroot -solid grey 
vncconfig -iconic & 
xterm -geometry 80x24+10+10 -ls -title "$VNCDESKTOP Desktop" & 
twm &

Lo dejamos así:

#!/bin/sh
# Uncomment the following two lines for normal desktop:
# unset SESSION_MANAGER
# exec /etc/X11/xinit/xinitrc

[ -x /etc/vnc/xstartup ] && exec /etc/vnc/xstartup
[ -r $HOME/.Xresources ] && xrdb $HOME/.Xresources
xsetroot -solid grey
vncconfig -iconic &
xterm -geometry 80x24+10+10 -ls -title "$VNCDESKTOP Desktop" &
unset SESSION_MANAGER
gnome-session &

Ahora arrancamos vncserver:

vncserver :1

Nos pide que configuremos un password. Hay que apuntarlo porque lo necesitaremos para poder conectarnos desde otra máquina.

En adelante podremos conectarnos al Ubuntu virtual utilizando VNC.

En este ejemplo vamos a instalar una maquina Windows dentro de XEN. Como veremos, no es tan rápido como crear una máquina Linux pero se puede hacer. Por otro lado, hay que tener en cuenta que no será  paravirtualización, por lo que no será tan eficiente.

Creamos el volumen

Para esto utilizamos el comando lvcreate. Esta es su sintaxis:

lvcreate -L 40G -n NombreVolumenLogico NombreGrupoVolumen

En nuestro caso la máquina windows tiene estas características:

• Nombre: XenWinServer01
• Tamaño de disco duro: 40 Gb

Por lo tanto, este es el comando para crear el volumen:

lv create -L 40G -n xenwiserver01 volgroupxen

Una vez hecho esto, lo formateamos como VFAT:

mkfs -t vfat /dev/volgroupxen/xenwinserver01

Para instalar maquinas virtuales Windows es necesario que en el servidor físico Linux tengamos instaladas las X-Window. En caso contrario no podríamos ver la ventana de instalación de la máquina Windows. Es importante tener esto en cuenta al instalar el servidor físico Linux.

Imaginémonos que la plantilla del servidor virtual es esta: /etc/xen/xenwinserver01.cfg

La editamos y y configuramos los valores que nos interesan: nombre, memoria, procesadores ...

• En la sección Boot tenemos que poner el valor 'd' para que arranque desde CD y poder comenzar la instalación de Windows. Una vez finalizada la instalación ponemos de nuevo 'c' para que arranque de disco duro.

• En el parámetro Disk le ponemos el volumen lógico que le corresponde.

Por ejemplo:

kernel = '/usr/lib/xen/boot/hvmloader'
builder = 'hvm'
memory = 1024
name = 'xenwinserver01'
vcpus = 1
vif = [ 'type=ioemu, bridge=xenbr0' ]
cdrom = '/dev/sdc0'
boot = 'c'
sdl = 1
vnc = 0
nographic = 1
disk = [ 'phy:/dev/volgroupxen/xenwinserver01,hda,w', 'phy:/dev/loop1,ioemu:hdc:cdrom,r' ]
device_model = '/usr/lib/xen/bin/qemu-dm'

Para seguir con la instalación necesitamos los CD de instalación de Windows. Nosotros hemos generado una imagen ISO del CD que luego montamos en el servidor. Para hacerlo primero tenemos que buscar un  loop libre:

Por ejemplo este está ocupado:

root@IMH01XEN01:/etc/xen# losetup /dev/loop1 
/dev/loop1: [0803]:4472839 (/root/InstalazioIrudiak/win2kserver/w2kserver.iso) 

Este en cambio está libre:

root@IMH01XEN01:/etc/xen# losetup /dev/loop2 
loop: can't get info on device /dev/loop2: No such device or address

Ahora montamos la imagen ISO para que el servidor virtual la pueda ver:

root@IMH01XEN01:/etc/xen# losetup -r /dev/loop2 /root/InstalazioIrudiak/win2003server/SW_CD_Win.iso

Configuramos el Loop en la plantilla del servidor virtual, en el parámetro  disk :

disk = [ 'phy:/dev/volgroupxen/xenwinserver2003_01,hda,w', 'phy:/dev/loop2,ioemu:hdc:cdrom,r' ]

Ahora deberíamos comenzar con la instalación de Windows. Perdonad, pero esa parte la tengo documentada en el siguiente ejemplo, en el de la virtualización de Windows XP, asi que seguid leyendo  ;-)

Lo primero que haremos será crear una ISO con el CD de instalación de Windows XP. Lo podemos hacer utilizando K3B. Una vez que hemos generado la imagen, la copiamos por scp al servidor físico.

root@IMH01XEN01:~# ls -l  /root/InstalazioIrudiak/wxpsp3/ 
total 669712 
-rw-r--r-- 1 root root 685105152 2008-12-11 16:30 WXPSP3.iso

Ahora vamos a generar un volumen lógico. Le pondremos un disco de 10 Gb, ya que en nuestro caso el XP virtualizado no va  a tener muchos datos.

root@IMH01XEN01:~# lvcreate -L 10G -n xenwinxp01 volgroupxen 
  Logical volume "xenwinxp01" created

Ahora vamos a formatear el disco que hemos creado

root@IMH01XEN01:~# mkfs -t vfat /dev/volgroupxen/xenwinxp01 

Como hemos comentado antes, utilizaremos una imagen ISO para la instalación, y previamente hay que montarla para que el sistema la pueda ver. Para montar la ISO primero buscaremos un  loop libre.

root@IMH01XEN01:/etc/xen# losetup /dev/loop1 
loop: can't get info on device /dev/loop1: No such device or address

Este está libre, así que lo utilizaremos.

root@IMH01XEN01:/etc/xen# losetup -r /dev/loop1 /root/InstalazioIrudiak/wxpsp3/WXPSP3.iso

Podemos ver si se ha montado correctamente:

root@IMH01XEN01:/etc/xen# losetup /dev/loop1 
/dev/loop1: [0803]:4472848 (/root/InstalazioIrudiak/wxpsp3/WXPSP3.iso)

Ahora vamos a la carpeta de configuración de XEN y copiamos la configuración de otra máquina virtual windows para luega modificarla:

root@IMH01XEN01:~# cd /etc/xen 
root@IMH01XEN01:/etc/xen# cp xenwinserver01.cfg xenwinxp01.cfg

Modificamos la configuración

kernel = '/usr/lib/xen/boot/hvmloader' 
builder = 'hvm' 
memory = 512 
name = 'xenwinxp01' 
vcpus = 1 
vif = [ 'type=ioemu, bridge=xenbr0' ] 
# cdrom = '/dev/sdc0' 
# boot on floppy (a), hard disk (c) or CD-ROM (d) 
# default: hard disk, cd-rom, floppy 
boot='d' 
sdl = 1 
vnc = 0 
nographic = 0 
disk = [ 'phy:/dev/volgroupxen/xenwinxp01,hda,w','phy:/dev/loop1,ioemu:hdc:cdrom,r'] 
device_model = '/usr/lib/xen/bin/qemu-dm' 
usbdevice='tablet'

Estos son los parámetros que hemos modificado:

memory = 512 
name = 'xenwinxp01' 
boot = 'd' 
sdl = 1 
vnc = 0 
nographic = 0 
disk = [ 'phy:/dev/volgroupxen/xenwinxp01,hda,w', 'phy:/dev/loop1,ioemu:hdc:cdrom,r' ] 
usbdevice='tablet' (para que el raton no de problemas)

Se supone que todo está preparado. Para poner en marcha la instalación necesitamos tener cargadas las X-Windows en el servidor linux, en caso contrario no podremos ver las ventanas de instalación de Windows. En nuestro caso vamos a conectarnos al servidor físico a través de VNC.

En el servidor físico XEN tenemos cargadas las X-Window (Gnome) y Remote Desktop configurado como se ve en la imagen:

Si hemos hecho todo bien podremos conectarnos por VNC al servidor físico XEN. Aquí vemos el escritorio remoto de nuestro servidor, limpio ¿verdad?

Ahora desde la sesión VNC abrimos un consola en el servidor XEN y ponemos en marcha la máquina virtual Windows, con lo que pondremos en marcha la instación de Windows:

Vemos la ventana de instalación

Ahora continuamos con la instalación normal de Windows. Al finalizar editamos la configuración de la máquina virtual y comentamos el parámetro  nographic=1 .

#nographic=1

Con esto conseguimos que esta máquina virtual pueda arrancar a pesar de que el servidor físico no tenga cargado Gnome. Dicho de otra forma, el servidor Linux no necesita tener las X-Windows cargadas para arrancar una máquina virtual Windows con su entorno gráfico.

Has hecho un buen trabajo instalando una máquina virtual. Imagínate que ahora necesitamos crear otra máquina virtual muy parecida para cualquier otra cosa. ¿Tenemos que repetir todo el proceso? Pues no, aprovecharemos el trabajo realizado previamente.

Haremos una copia de la instalación existente y en adelante cuando necesitemos una máquina virtual precida, nos basaremos en la instalación que acabamos de hacer.

Como estamos utilizando LVM, obtendremos un snapshot (foto) del volumen lógico que utiliza la máquina virtual original.

Necesitamos conocer el tamaño del volumen que queremos clonar. En nuestro caso 10 GB.

root@IMH01XEN01:~# lvdisplay 
  --- Logical volume --- 
  LV Name                /dev/volgroupxen/xenwinxp01 
  VG Name                volgroupxen 
  LV UUID                9U95Sb-SjSS-28cw-0wUG-3rCe-eX81-xHEppQ 
  LV Write Access        read/write 
  LV Status              available 
  # open                 0 
  LV Size                10,00 GB 
  Current LE             2560 
  Segments               1 
  Allocation             inherit 
  Read ahead sectors     0 
  Block device           254:8

Crearemos un volumen intermedio para hacer la copia y al finalizar lo borraremos. Al volumen lo llamaremos FotoWindows.

root@IMH01XEN01:~# lvcreate -L  10G -s -n FotoWindows /dev/volgroupxen/xenwinxp01 
  Logical volume "FotoWindows" created

La nueva máquina virtual se llamará  xenwinxp02 por lo tanto a su volumen lógico lo llamaremos:  /dev/volgroupxen/xenwinxp02

root@IMH01XEN01:~# lvcreate -L 10G -n xenwinxp02 volgroupxen 
  Logical volume "xenwinxp02" created 

Ahora copiaremos la foto que tenemos en el snapshot al volumen que acabamos de crear. Necesita tiempo, pero al finalizar estará todo perfectamente copiado.

root@IMH01XEN01:~# dd if=/dev/volgroupxen/FotoWindows  of=/dev/volgroupxen/xenwinxp02
20971520+0 records in 
20971520+0 records out 
10737418240 bytes (11 GB) copied, 1070,87 s, 10,0 MB/s

Si lo preferimos, desde el snapshot podríamos copiar el disco a una imagen ISO en vez de copiarla a LVM. Este sería el comando:

root@IMH01XEN01:~# dd if=/dev/volgroupxen/FotoWindows of=/home/pedro/xenwinxp02.img 
20971520+0 records in 
20971520+0 records out 
10737418240 bytes (11 GB) copied, 387,568 s, 27,7 MB/s

Ahora es importante no olvidarnos que hay que borrar el  snapshot :

root@IMH01XEN01:~# lvremove /dev/volgroupxen/FotoWindows
Do you really want to remove active logical volume "FotoWindows"? [y/n]: y 
  Logical volume "FotoWindows" successfully removed

Con esto hemos conseguido clonar el disco para la nueva máquina virtual. ¿Qué nos falta? Pues crear el fichero de configuración de la nueva máquina virtual. Hacemos una copia del fichero de configuración de la máquina original:

root@IMH01XEN01:/etc/xen# cp xenwinxp01.cfg xenwinxp02.cfg

Lo editamos y ponemos los parámetros correctos:

root@IMH01XEN01:/etc/xen# cat xenwinxp02.cfg 
kernel = '/usr/lib/xen/boot/hvmloader' 
builder = 'hvm' 
memory = 512 
name = 'xenwinxp02' 
vcpus = 1 
vif = [ 'type=ioemu, bridge=xenbr0' ] 
# cdrom = '/dev/sdc0' 
# boot on floppy (a), hard disk (c) or CD-ROM (d) 
# default: hard disk, cd-rom, floppy 
boot='d' 
sdl = 1 
vnc = 0 
# nographic=1 Para que no arranque las ventanas al arrancar la maquina
# y poder asi arrancarla desde consola
nographic = 1
disk = [ 'phy:/dev/volgroupxen/xenwinxp02,hda,w','phy:/dev/loop1,ioemu:hdc:cdrom,r'] 
device_model = '/usr/lib/xen/bin/qemu-dm' 
usbdevice='tablet'

Ahora arrancamos la máquina virtual:

root@IMH01XEN01:/etc/xen# xm create xenwinxp02.cfg 
Using config file "./xenwinxp02.cfg". 
Started domain xenwinxp02

Windows intentará obtener una IP por DHCP con lo cual miramos cual es la IP que ha recibido y configuramos nuestro servidor DHCP para que a su MAC le asigne una nueva dirección IP.

Por último, hay que tener en cuenta que hemos hecho un clon de un Windows, y si no queremos tener problemas en la red Windows deberíamos cambiarle el nombre, ya que es el mismo que el del original.

Para hacerlo:

• Hay que cambiar el nombe de PC y sacarlo del dominio  (lo añadimos a Workgroup).
  
• Reiniciamos la máquina virtual y entramos como administrador local del PC virtual
• Lo añadimos de nuevo al dominio y reiniciamos (otra vez)

¿ Harto de tantos reinicios para cambiar el nombre del PC? Que quieres, es un Windows !! :-(

Si no ha habido problemas, el clon virtual del Windows es ya operativo.

Al comienzo hemos comentado que algo teníamos con VMWare. Hace un par de años instalamos la versión gratuita de VMWare Server sobre una debian, y teníamos un par de máquinas virtuales trabajando en esa instalación. Migrarlas a XEN es sencillo.

Lo primero que hacemos es instalar qemu en el servidor VMWare (máquina física linux debian)

vmware01:~# apt-get install qemu

Lo siguiente es crear una carpeta donde trabajar:

vmware01:/home/vmware# mkdir vmwaretoxen 
vmware01:/home/vmware# cd vmwaretoxen/ 
vmware01:/home/vmware/vmwaretoxen#

La máquina virtual vmware que vamos a clonar debe estar apagada, por lo que nos conectamos a ella y le hacemos un halt. Si no lo hacemos el proceso dará error.

A continuación comienza el clonado:

# vmware-vdiskmanager -r /home/vmware/VirtualMachines/DebianEtch/DebianEtch.vmdk -t 0 temporary_image.vmdk 
Using log file /tmp/vmware-root/vdiskmanager.log 
Creating a monolithic growable disk 'temporary_image.vmdk' 
  Convert: 100% done. 
Virtual disk conversion successful.

Ahora creamos la imagen IMG compatible con XEN:

vmware01:/home/vmware/vmwaretoxen# qemu-img convert -f vmdk temporary_image.vmdk -O raw xen_compatible.img

Tras esto hemos conseguido en el fichero  xen_compatible.img el clon que copiaremos al servidor físico Xen mediante scp y lo tendremos listo para usar.

Imagínate que tienes un servidor linux instalado hace tiempo que te interesa virtualizar, pero tienes software instalado que sería problemático instalar de nuevo.

Una opción que tienes es la de virtualizar el servidor físico. Yo para eso he utilizado la herramienta  Virt-P2V , y he conseguido migrar a XEN sin problemas algunos servidores linux viejos.

Virt-P2V  es un "Live CD" , y estos son los pasos a seguir::

• Mete el CD en el servidor a clonar y reinicialo.
  
• en el menu que te aparece introduce la IP del servidor XEN  y configura la conexión ssh (usuario y password) y dile en que carpeta remota del servidor XEN tiene que dejar la imagen
• Te puedes ir a tomar un café mientras envía por ssh el clon. Bueno, como va a tardar un buen rato, mejor te tomas el café y vuelves al trabajo, que seguro que tienes cosas que hacer  :-)
  

Como ves, el proceso es sencillo.

Una vez ha finalizado, en la carpeta del servidor XEN que has configurado, verás dos ficheros:

• Una imagen en formato IMG

• Un fichero de configuración xml

Yo me suelo quedar con el fichero imagen y me cargo el XML. Luego creo un fichero de configuración con el que usarlo en XEN siguiendo los ejemplos que hemos visto antes.

Imagínate que tienes un servidor virtual en formato IMG y prefieres tenerlo en formato LVM. A nosotros nos ha pasado con el servidor de faxes Hylafax. En su fichero de configuración podemos ver que usaba una imagen como disco.

disk = [ 'tap:aio:/etc/xen/irudiak/XenHylafax20090126.img,hda,w']

Lo primero es crear un nuevo volumen lógico con el tamaño que tiene la imagen, en nuestro caso  4,1 Gb:

#lvcreate -L 4,1G -n XenHylafax volgroupxen

Luego paramos el servidor virtual que corre sobre esa imagen antes de hacer la copia. Una vez que lo hemos parado utilizamos el comando dd para la copia:

dd if= /etc/xen/irudiak/XenHylafax20090126.img   of=/dev/volgroupxen/XenHylafax bs=16M

Cuando finaliza la copia modificamos el fichero de configuración y donde antes hacía referencia a la imagen IMG, ponemos la referencia al volumen LVM:

disk = [ 'phy:/dev/volgroupxen/XenHylafax,hda,w']

Ya podemos arrancar de nuevo la máquina virtual.

Fácil, ¿verdad ?

Si queremos que cuando arranque el servidor físico XEN arranquen también las máquinas virtuales, tenemos que añadir un enlace por cada servidor virtual, por ejemplo:

root@IMH01XEN01:/etc/xen# ln -s /etc/xen/XenNagios.cfg /etc/xen/auto/

Si no lo ponemos, tendremos que arrancar las máquinas virtuales a mano

Autor: Pedro Arreitunandia
Fecha: 1 de junio del 2009 ( Publicado el 15 de diciembre del 2009)
Licencia: Creative Commons BY-SA

Quisiera agradecer a Iñigo Losada de la empresa IBEX tanto y tanto que nos enseña.

Si quieres comentarnos cuaquier duda o sugerencia respecto a este manual puedes hacerlo como respuesta de este post en nuestro blog