El rincón de Zerial » xen

Manipular volúmenes lógicos (LVM) en discos virtuales

Zerial — Wed, 14 Sep 2011 07:48:50 +0000

Me refiero a discos virtuales a los que creamos usando dd. Cuando creamos un disco utilizando por ejemplo dd if=/dev/zero of=imagen.img y lo usamos para crear una máquina virtual, en este caso con Xen, luego le instalamos un sistema operativo que maneje ya sea CentOS, RHEL, Debian o cualquier otro que maneje LVM en la instalación, hay veces que necesitamos manipularlo ya sea para clonarlo, hacerle mantención o simplemente montarlo para ver los archivos. En mi caso, tuve que clonar la máquina virtual en caliente y quedó el FS corrupto, por lo que tuve que corregirlo, tambien sirve para hacer tareas de mantención como aumentar o disminuir el tamaño del disco o volúmenes lógicos.

Tengo mi disco original llamado “vm1.img” y la clono simplemente con un cp o bien con “dd if=vm1.img vm1_clon.img“, paso a paso, lo que tenemos que hacer es:

Crear un dispositivo “loop” en base a nuestro disco virtual
Mapear el dispositivo loop creado
Revisar los dispositivos creados en /dev/mapper/
Activar el volúmen y realizar las tareas necesarias

Las herramientas que usé son losetup, kpartx y vgchange.

Primero, ya tenemos nuestro disco creado, en este caso lo llamaré “testing” y tiene un tamaño de 80GB.
# fdisk -l testing


Disk testing: 85.9 GB, 85899345920 bytes

255 heads, 63 sectors/track, 10443 cylinders, total 167772160 sectors

Units = sectors of 1 * 512 = 512 bytes

Sector size (logical/physical): 512 bytes / 512 bytes

I/O size (minimum/optimal): 512 bytes / 512 bytes

Disk identifier: 0x0007759f

Device Boot Start End Blocks Id System testing1 * 63 208844 104391 83 Linux testing2 208845 167766794 83778975 8e Linux LVM

Para comenzar vamos a usar el comando losetup para crear un dispositivo “loop” en base a nuestra imagen de disco, para esto ejecutamos:

# losetup -f testing

Y verificamos con el mismo comando losetup que se haya creado

# losetup -a /dev/loop0: [fe01]:24577 (/mnt/vardata/testing)

Ya tenemos nuestro dispositivo “loop” en /dev/loop0 mapeado a la imagen de disco virtual ubicada en /mnt/vardata/testing.

Ahora debemos usar la herramienta kpartx para mapear ese dispositivo que hemos mapeado a nuestro disco virtual hacia nuestro administrador de volúmenes lógicos

# kpartx -a -v /dev/loop0 add map loop0p1 (254:2): 0 208782 linear /dev/loop0 63 add map loop0p2 (254:3): 0 167557950 linear /dev/loop0 208845

Ahora tenemos otros dispositivos creados en /dev/mapper, corresponden a “loop0p1″ y “loop0p2″ correspondientes a las particiones de nuestro disco virtual. Así debería ser presentarse:

# ls -lia /dev/mapper/ total 0 1072 drwxr-xr-x 2 root root 140 sep 13 15:19 . 3 drwxr-xr-x 15 root root 3260 sep 13 15:19 .. 1073 crw------- 1 root root 10, 236 ago 11 12:12 control 2672529 lrwxrwxrwx 1 root root 7 sep 13 15:19 loop0p1 -> ../dm-2 2671232 lrwxrwxrwx 1 root root 7 sep 13 15:19 loop0p2 -> ../dm-3 3655 lrwxrwxrwx 1 root root 7 ago 11 12:12 VolGroup_ID_15211-backup -> ../dm-0 3672 lrwxrwxrwx 1 root root 7 ago 11 12:12 VolGroup_ID_15211-vardata -> ../dm-1

Y el comando vgdisplay debería mostrar la información del grupo

# vgdisplay --- Volume group --- VG Name VolGroup00 System ID Format lvm2 Metadata Areas 1 Metadata Sequence No 3 VG Access read/write VG Status resizable MAX LV 0 Cur LV 2 Open LV 0 Max PV 0 Cur PV 1 Act PV 1 VG Size 79,88 GiB PE Size 32,00 MiB Total PE 2556 Alloc PE / Size 2556 / 79,88 GiB Free PE / Size 0 / 0 VG UUID yAIBPd-1PD6-IN1U-aoK7-bLSW-rz08-ERktCp

Y con lvdisplay revisamos la información de los volúmenes dentro del grupo VolGroup00

# lvdisplay VolGroup00 --- Logical volume --- LV Name /dev/VolGroup00/LogVol00 VG Name VolGroup00 LV UUID Du8Hwj-BUff-RhS3-lNTZ-KsxS-jvEp-S71om4 LV Write Access read/write LV Status NOT available LV Size 77,84 GiB Current LE 2491 Segments 1 Allocation inherit Read ahead sectors auto

--- Logical volume --- LV Name /dev/VolGroup00/LogVol01 VG Name VolGroup00 LV UUID Sg3KQG-F3Ad-kgIx-yJi0-OSxm-fBUg-bKUR3O LV Write Access read/write LV Status NOT available LV Size 2,03 GiB Current LE 65 Segments 1 Allocation inherit Read ahead sectors auto

Si te fijan en un detalle, en ambos volúmenes, el estado es “NOT available“, pues debemos activarlo

# vgchange VolGroup00 -a y 2 logical volume(s) in volume group "VolGroup00" now active

Y volvemos a revisar

# lvdisplay VolGroup00 --- Logical volume --- LV Name /dev/VolGroup00/LogVol00 VG Name VolGroup00 LV UUID Du8Hwj-BUff-RhS3-lNTZ-KsxS-jvEp-S71om4 LV Write Access read/write LV Status available # open 0 LV Size 77,84 GiB Current LE 2491 Segments 1 Allocation inherit Read ahead sectors auto - currently set to 256 Block device 254:4

--- Logical volume --- LV Name /dev/VolGroup00/LogVol01 VG Name VolGroup00 LV UUID Sg3KQG-F3Ad-kgIx-yJi0-OSxm-fBUg-bKUR3O LV Write Access read/write LV Status available # open 0 LV Size 2,03 GiB Current LE 65 Segments 1 Allocation inherit Read ahead sectors auto - currently set to 256 Block device 254:5

Ya los tenemos disponibles y ahora podemos trabajar con ese volúmen como si fuese un “lvm” normal, realizar tareas de mantención, montar el volumen, disminuir o aumentar su tamaño, etc.

Cuando ya terminemos de hacer todo lo que queramos con el disco virtual, hay que volver todo a la normalidad, haciendo los pasos inversos:

Desactivar el volumen
# vgchange VolGroup00 -a n 0 logical volume(s) in volume group "VolGroup00" now active

Remover el mapeo de los dispositivos loop0p1 y loop0p2 creados desde loop0
# kpartx -d /dev/loop0

Remover el mapeo de /dev/loop0 creado desde nuestro disco virtual “testing”
# losetup -v -d /dev/loop0

Ya dejamos todo como estaba y podemos volver a utilizar nuestro disco virtual.

Clonación de máquinas virtuales en serie

Zerial — Wed, 28 Oct 2009 00:55:34 +0000

En el lugar donde trabajo, he estado montando y monitoreando muchas máquinas virtuales (gnu/linux sobre gnu/linux). En un principio, las máquinas estaban virtualizadas con VMWare, eran sólo 3 máquinas. Luego estas máquinas fueron aumentando a 5, 10 y actualmente ya son 20 máqiunas. La empresa donde trabajo ofrece el servicio de email marketing en base a newsletter y “fidelización de clientes“, y soy yo quien debe administrar los servidores de envios de correos. Se envían más de 500 mil emails semanales por lo que el uptime y la disponibilidad del servicio debe ser la más alta.

Para ésto, decidí migrar todas las máquinas a Xen y comenzar a para-virtualizar todos los servidores de envios (nosotros les llamamos “smtp“). Si pensamos que su única función es enviar correos (ya que, de la lógica del servicio se encarga otro servidor), las caracteristicas de cada smtp son muy básicas:

128MB ram
2Gb disco
Servicios: postfix, ssh

Para lograr el objetivo, me dediqué a crear un script que me automatiza la creación y configuración de máquinas virtuales.

El script esta hecho en bash y lo único que necesitamos es tener una imágen del sistema (por ej. debian) base, con postfix instalado y la configuración que necesitemos, para luego clonarla en serie. El único trabajo que tenemos que hacer es montar una sola maquina, con todo lo que necesitemos, que sea funcional y luego de hacer pruebas y que todo ande bien, entonces usamos el script para clonarla:

#/bin/bash
VM_LIST=machines # file which contains list of ip and hostnames
for line in $(grep -v ^# $VM_LIST);
do
IP_ADDR=$(echo $line |awk -F ‘|’ ‘{print $1}’)
HOST_NAME=$(echo $line |awk -F ‘|’ ‘{print $2}’)
MAC=$(echo $line |awk -F ‘|’ ‘{print $3}’)
NAME=$(echo $HOST_NAME |awk -F . ‘{print $1}’)
CFG=$NAME.cfg
IMG=$NAME.img
FULLPATH_CFG=$DIR\/$HOST_NAME\/$CFG;
FULLPATH_IMG=$DIR"\/"$HOST_NAME"\/"$IMG;
FULLPATH_SWAP=$DIR/$HOST_NAME/"swap.img";
mkdir $HOST_NAME
echo "Created $HOST_NAME directory."
echo ">> Copying files …"
cp draft/swap.img draft/draft.img draft/draft.cfg $HOST_NAME/
mv $HOST_NAME/draft.img $HOST_NAME/$IMG
mv $HOST_NAME/draft.cfg $HOST_NAME/$CFG
echo -n ">> Parsing $CFG …"
sed -i ‘s/DIR_TO_DISK/\/vm\/mailers\/‘$HOST_NAME‘\/‘$IMG‘/g’ $HOST_NAME/$CFG
sed -i ‘s/DIR_TO_SWAP/\/vm\/mailers\/‘$HOST_NAME‘\/swap.img/g’ $HOST_NAME/$CFG
sed -i ‘s/HOSTNAME/’$NAME‘/g’ $HOST_NAME/$CFG
sed -i ‘s/IP_ADDR/’$IP_ADDR‘/g’ $HOST_NAME/$CFG
sed -i ‘s/MAC/’$MAC‘/g’ $HOST_NAME/$CFG
echo " Done."
mount -oloop -tauto $HOST_NAME/$IMG temp/
echo ">> Setting up hostname …"
echo $HOST_NAME > temp/etc/hostname
echo ">> Setting up postfix (main.cf) …"
sed -i ‘s/mail[0-9]./’$NAME‘/g’ temp/etc/postfix/main.cf
echo ">> Setting up ethernet …"
sed -i ‘s/aaa.bbb.ccc.ddd/’$IP_ADDR‘/’ temp/etc/network/interfaces
echo ">> Adding RSA Public Key …"
cat /home/admin/.ssh/id_rsa.pub >> temp/root/.ssh/authorized_keys
umount temp
echo "Done."
done

Lo que hace el script, en sencillos pasos es:

- Crear el directorio donde guardaremos nustro fichero de configuración y cosas necesarias.
- Copiar los ficheros necesarios (configuracion de la máquina, imagen del sistema operativo, etc)
- Toma el fichero de configuración y lo parsea para adaptarlo según la configuración que necesitemos.
- Monta la imagen (usando loop)de nuestra nueva máquina.
- Edita y configura los ficheros necesarios dentro de esa máquina virtual.
- Desmontamos y pasamos a la siguiente máquina.

El script se basa en un fichero de “configuración”, el cual nos debe proveer de la dirección IP, la mac y el hostname, en el siguiente formato:

aaa.bbb.ccc.ddd:hostname.tld:ma:c:a:dd:re:ss

Con este post no busco enseñar como migrar o clonar máquinas, simplemente demostrar que se puede automatizar la tarea de clonación de máquinas en serie. Claramente este script no funcionará para los requerimientos de todos nosotros, pero se puede adaptar.

Tip: Migración de servidores a Xen

Zerial — Thu, 13 Aug 2009 01:24:03 +0000

Este es el segundo post del día relacionado con Xen ya que he estado jugando con Xen, hace tiempo que no probaba cosas. Este post se trata de un tip para poder mgirar cualquier servidor hacia Xen, no importa si está virtualizado con VMWare, si es una máquina fisica, Xen, etc etc, es una forma bastante sencilla que no tiene ninguna ciencia.

La teoría
Copiar todos los archivos (por red) de una máquina a otra manteniendo los permisos e integridad de cada fichero.

La práctica
Lo haremos en 4 sencillos pasos y haciendo uso de la herramienta rsync

Preparar nueva máquina

Creamos el disco usando dd y le damos formato:
dd if=/dev/zero of=disco.img bs=1M count=10000 mkfs.ext3 disco.img
En este caso 10 mil megas y usamos ext3.
La montamos y pasamos al siguiente paso:
mkdir temporal && mount -text3 -oloop disco.img temporal/

Preparar máquina remota

lo único que haremos será bajar los servicios para que tenga la menor carga posible (httpd, base de datos, etc etc)

Traslado de ficheros

Lo haremos con el comando rsync:
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded --rsh=/usr/bin/ssh root@maquina.remota:/ temporal/

Iniciar máquina nueva

Editamos los ficheros /etc/fstab para que coincidan con nuestra configuración de la máquina virtual y luego para que no tengamos conflictos con la máquina antigua, editamos tambien /etc/network/interfaces (o como se llame el fichero de la configuración de la red de la distribución)

Finalmente, desmontamos temporal/ (umount temporal/) e iniciamos la máquina y wala!!! Inicio sin problemas.

Probado en Debian Lenny.

Instalar CentOS con Xen en Debian

Zerial — Wed, 12 Aug 2009 20:25:51 +0000

Luego de intentar varias maneras de instalar CentOS sobre Xen y luego de varios intentos fallidos, puedo resumir todo en 5 sensillos pasos para no morir en el intento.

Descargar las imágenes

Descargar las siguientes imágenes (checkear si existen más nuevas):
* http://mirror.centos.org/centos/5.3/os/i386/images/xen/vmlinuz
* http://mirror.centos.org/centos/5.3/os/i386/images/xen/initrd.img

Por ejemplo, dejemoslo en /tmp/

wget http://mirror.centos.org/centos/5.3/os/i386/images/xen/vmlinuz -O /tmp/
wget http://mirror.centos.org/centos/5.3/os/i386/images/xen/initrd.img -O /tmp/

Configuración de la máquina virtual

El fichero de configuración de la máquina debe ser algo como: (//modificar según requerimientos//)

kernel=’/tmp/vmlinuz’
ramdisk=’/tmp/initrd.img’
extra=’text’
maxmem=’3072′
memory=’2048′
vcpus=2

disk=[
'file:/vm/cpanel/root.img,hda,w',
'file:/vm/cpanel/home.img,hdb,w',
'file:/vm/cpanel/tmp_swap.img,hdc,w',
]

name=’cpanel’
vif=[ 'ip=200.55.200.126,mac=00:1B:CC:C3:B3:33,bridge=xenbr1' ]

on_poweroff = ‘destroy’
on_reboot = ‘restart’
on_crash = ‘restart’

Preparación de discos

root será nuestra partición que montaremos en /
en home vamos a montar nuestro /home y
tmp_swap la usaremos para montar /tmp y la swap del sistema.

Creamos los discos:
dd if=/dev/zero of=root.img bs=1M count=10240 #10Gb
dd if=/dev/zero of=home.img bs=1M count=40960 #40Gb
dd if=/dev/zero of=tmp_swap.img bs=1M count=2048 #2Gb

Instalación

Iniciamos la máquina virtual:
xm create -c configuration.cfg

Seguimos paso a paso la instalación y finalizamos.

Booteo

Para bootear debemos hacer una modificacion en el fichero de configuración de la máquina, la dejamos así:

bootloader = ‘/usr/lib/xen-3.2-1/bin/pygrub’ #El path depende de la version
extra=’text’
maxmem=’3072′
memory=’2048′
vcpus=2

disk=[
'file:/vm/cpanel/root.img,hda,w',
'file:/vm/cpanel/home.img,hdb,w',
'file:/vm/cpanel/tmp_swap.img,hdc,w',
]

name=’cpanel’
vif=[ 'ip=200.55.200.126,mac=00:1B:CC:C3:B3:33,bridge=xenbr1' ]

on_poweroff = ‘destroy’
on_reboot = ‘restart’
on_crash = ‘restart’

Luego iniciamos la maquina:
xm create configuration.cfg -c

Cómo redimenzionar el tamaño de un disco virtual en Xen

Zerial — Wed, 22 Jul 2009 02:18:11 +0000

El otro día, jugando un rato con Xen me encontré con el problema de querer redimenzionar el tamaño de disco virtual de las máquinas virtuales y, cabezeandome un rato, lo logré.
En teoría, aumentar el tamaño de un disco es fácil, creamos un fichero del tamaño que queramos usando dd y luego concatenamos con el que ya tenemos, creamos el sistema de ficheros y listo. Pero el disminuirlo me pareció más complejo, pero no fue así.

Paso a paso

Aumentar el tamaño del disco

Vamos a usar tres herramientas: dd, cat y mkfs.
Primero, crear un fichero del tamaño que necesitemos, por ejemplo 5GB:

dd if=/dev/zero of=file.img bs=1MB count=5000

Luego de esto unimos nuestro disco actual con el nuevo file.img:
cat file.img >> disk.img

Como último paso, volvemos a crear el sistema de ficheros usando mkfs:
mkfs.xfs disk.img
(deben cambiar xfs por el sistema de ficheros a utilizar como ext3, reiserfs, etc)

Disminuir el tamaño del disco
Similar al anterior, usaremos las herramientas dd y mkfs (tambien usaremos los comando cp y mouont)
Creamos un fichero con el nuevo tamaño del disco, por ejemplo 5GB:

dd if=/dev/zero of=newdisk.img bs=1MB count=5000

Le damos formato al fichero:

mkfs.xfs newdisk.img

Montamos la imágen del disco antigua y la nueva en dos directorios distintos (usaremos temp1 y temp2, respectivamente):

mkdir temp1 temp2 mount -tauto -oloop disk.img temp1 mount -tauto -oloop newdisk.img temp2

Simplemente copiamos los ficheros desde temp1 hasta temp2, obviamente, conservando los permisos:

cp -rfvp temp1/* temp2/

Desmontamos las dos imágenes:

umount temp1 && umount temp2

Listo, ahora en newdisk.img de 5gb tenemos todo lo que estaba antes en disk.img.

Xen: Migración de discos fisicos a discos virtuales (pt3)

Zerial — Wed, 15 Jul 2009 14:24:37 +0000

La migración de discos físicos a discos virtuales para poder montar una VM en Xen es, en teoría, fácil. Es simplemente hacer una copia con dd de las particiones que deseas. Hay que tener mucho cuidado, no debemos hacer una imágen del disco completo, sólo las particiones que deseamos, sin el sector 0 (mbr), ni tabla de particiones, etc. Tampoco recomiendo migrar la swap, es mejor crearla (en teoría demoraría menos).

Cuando se trata de máquinas de producción o servidores, lo que debemos hacer para no tener conflictos con las direcciones ip, hostnames, fstab o cualquier configuración especial que tenga esa máquina que de una u otra forma pueda generar conflictos, es montarla con loop y modificar las configuraciones directamente desde la imágen que creamos.
Los pasos a seguir (recomendados por mi) son:

Determinar qué particiones son las que debemos migrar.
Hace las imágenes correspondientes de cada partición.
Configuración de la máquina virtual (crear el .cfg).
Montar las particiones que podrían generar algún tipo de conflicto y modificar los archivos necesarios.
Creación de la swap.
Levantar la máquina.

Determinar qué particiones son las que debemos migrar.

Es necesario respaldar sólo las particiones que contienen información, como dije anteriormente, la swap no es necesaria, tambien da lo mismo el orden y el nombre que les pongamos, pero hay que ser ordenados.

Imaginemos la siguiente tabla de particiones:

/dev/sda1 / xfs defaults 0 1
/dev/sda2 /home xfs defaults 0 1
/dev/sda3 swap swap defaults 0 0

Lo único que debemos respaldar es sda1 y sda2

Hace las imágenes correspondientes de cada partición.

Para crear las imágenes de cada particion, vamos a usar dd.
# mkdir -p /vm/vm1 && cd /vm/vm1 # dd if=/dev/sda1 of=sda1.img # dd if=/dev/sda2 of=sda2.img
Con esto ya tenemos sda1.img, sda2.img correspondiente a /dev/sda1 y /dev/sda2 respectivamente.

Configuración de la máquina virtual (crear el .cfg).

# Kernel + memoria kernel = '/boot/vmlinuz-2.6.26-2-xen-686' ramdisk = '/boot/initrd.img-2.6.26-2-xen-686' maxmem = '2048' memory = '1024' vcpus=4 # Discos. root = '/dev/hda1 ro' disk = [ 'file:/vm/vm1/sda1.img,hda1,w', 'file:/vm/vm1/sda2.img,hda2,w', 'file:/vm/vm1/swap.img,hda3,w', ] # Hostname name = 'labs' # red vif = [ 'ip=10.0.0.134,mac=00:1B:CC:C3:BB:3B,bridge=xenbr1' ] # comportamiento on_poweroff = 'destroy' on_reboot = 'restart' on_crash = 'restart'
De esta forma le decimos a la máquina virtual que su hda1 estará mapeado a la imágen del disco sda1 que creamos y hda2 a sda2.

Montar las particiones que podrían generar algún tipo de conflicto y modificar los archivos necesarios.

En este caso, sda1 nos podria generar conflictos con el fichero fstab, ya que tiene otra distribución para los puntos de montaje. Entonces, montamos la imágen:
# mkdir temp # mount -o loop -t auto sda1.img temp/
Entramos a temp/etc/ y editamos el fichero fstab y mapeamos correctamente las particiones, teniendo en cuenta que nuestras nuevas particiones se llaman hda1 y hda2. (no olvidar la swap).
Desmontamos la imágen:
# umoount temp/

Creación de la swap.

Para crear la swap tambien vamos a usar dd.
# dd if=/dev/zero of=swap.img bs=1M count=1500
(esto generara una imágen llamada swap.img de 1*1500 MB)
Hacemos que sea de tipo swap:
# mkswap swap.img
Listo.

Levantar la máquina.

Para levantar la máquina simplemente ejecutamos el comando:ç
# xm create vm1.cfg -c
(vm1.cfg es el nombre que le pusimos al archivo de configuración de la máquina)

Xen: Creación y configuración de una máquina virtual (pt2)

Zerial — Sat, 13 Jun 2009 17:18:29 +0000

Si la instalación y configuración de Xen resultó ser fácil, lo que mostraré a continuación es mucho más sencillo. Para instalar una máquina nueva (con Debian) debemos ejecutar el siguiente comando:

xen-create-image --hostname=xen1 --size=5Gb --swap=256Mb --ide \ --ip=192.168.0.101 --netmask=255.255.255.0 --gateway=192.168.0.1 --force \ --dir=/vm --memory=128Mb --arch=i386 --kernel=/boot/vmlinuz-2.6.26-2-xen-686 \ --debootstrap --dist=lenny --mirror=http://ftp.cl.debian.org/debian/ --passwd

Si destripamos los parámetros nos damos cuenta que le estamos asignando (en orden) el hostname, tamaño de disco duro, cantidad de swap, tipo de disco, dirección ip, netmask, gateway, el directorio donde instalarla, ram, arquitectura, kernel para usar, metodo de instalación, distribución, mirror para descargar y por último, que nos pregunte la pass de root cuando termine de instalar. Estos parametros se pueden cambiar según los requerimientos.

El archivo de configuración de las máquinas virtuales es algo como:

kernel = '/boot/vmlinuz-2.6.26-2-xen-686' ramdisk = '/boot/initrd.img-2.6.26-2-xen-686' maxmem = '256' memory = '64' root = '/dev/hda2 ro' disk = [ 'file:/vm/domains/xen01/swap.img,hda1,w', 'file:/vm/domains/xen01/disk.img,hda2,w', ] name = 'xen01' # Red vif = [ 'ip=192.168.20.202,mac=00:16:3E:6F:E3:3B' ] # Comportamiento on_poweroff = 'destroy' on_reboot = 'restart' on_crash = 'restart'

Podemos modificar arbitrariamente las opciones segun lo que nosotros necesitemos, tambien existen más opciones que le podemos agregar, como la asignacion de X cpus, decirles que cpu usen, por ejemplo si tenemos 4 núcleos, asignarle el 1 y el 4.

vcpus = 2; cpus = '0,3'

De esta forma le estamos asignando 2 núcleos virtuales y le estamos diciendo que use los nucleos 0 y 3.

Xen: Instalación y configuración (pt1)

Zerial — Tue, 09 Jun 2009 00:13:39 +0000

Esta es la primera parte de una serie de artículos que escribiré sobre cómo configurar y usar Xen, crear y administrar máquinas virtuales, clonación y migración, asignación de procesadores, memoria y configuración de la red entre otras cosas.
Aunque soy usuario de Archlinux, los servidores que administro están bajo Debian, por lo que estos tutoriales los haré en base a esa distribución.

A continuación, una serie de instrucciones de cómo instalar y dejar corriendo Xen en la máquina servidor en sencillos pasos:

Debemos instalar el kernel correspondiente y las utilidades de xen. Lo hacemos todo con el siguiente comando:

apt-get install xm-utils-common xen-linux-system-2.6.26-2-xen-686 linux-image-2.6.26-2-xen-686

Se van a instalar automáticamente las dependencias y otras utilidades que se necesiten.
Reiniciamos y booteamos con el kernel correspondiente: Xen 3.2-1-i386 / Debian GNU/Linux, kernel 2.6.26-2-xen-686

Hay que fijarse que se instalaron dos: linux-image y xen-linux-system. El primero se usará para que las máquinas guest booteen y el segundo para el domU.

Cuando ya hayamos iniciado con xen-linux-system, debemos editar el fichero /etc/xen/xend-config.sxp. Vamos a la linea donde configuramos la red, debe aparecer algo como “(network-script network-dummy)” y debemos cambiarlo por “(network-script network-bridge)“. Cuando intentemos crear nuestra primera máquina virtual, xen nos enviará un mensaje advirtiendo que debemos configurar esa linea en el fichero de configuración.

Eso es todo.

Virtualizacion usando Xen

Zerial — Sun, 20 Jan 2008 01:05:02 +0000

Hasta hace unos dias solo habia probado la Virtualizacion usando vmware pero hace unos dias me puse a trabajar e investigar sobre Xen y hay varias cosas que me llamaron la atencion, su modo de trabajar, los conceptos que emplea, la facilidad y versatilidad, etc.

Bueno, en resumen Xen es una herramienta de virtualizacion que usa el mecanismo de paravirtualizacion y nos permite cambiar de un sistema operativo a otro en caliente (sin necesidad de apagar o reiniciar la maquina), ademas de cambiarle varias configuraciones (por ejemeplo la ram) en caliente tambien. A nivel de procesador, el sistema operativo se ejecuta en una capa o nivel superior a la de los programas, bueno, Xen despacha de ese nivel al sistema operativo quedando el en ese nivel. Se dice que el sistema operativo es el supervisor de los programas que se ejecutan, pues Xen es nuestro Hipervisor (que esta por sobre el supervisor), es quien ‘supervisa’ al supervisor, es decir, un rango mas alto … Se podria decir que el sistema operativo se ejecuta sobre Xen.

Por ejemlpo, cuando uno esta en un sistema operativo puede abrir y cerrar aplicaciones, iamgen eso pero abriendo y cerrando segun el antojo de cada uno los sistemas operativos.
Esta caracteristica se logra modificando el codigo fuente de nuestro sistema operativo, por lo que solo en sistemas de codigo abierto se puede instalar, como el Kernel de Linux. Intel y AMD han colaborado con todo este desarrollo de la
virtualizacion y como es en el caso de Windows, que es un sistema de codigo cerrado, no se podria virtualizar. Pues Intel y AMD desarrollaron procesadores con capacidad de correr el sistema operativo en otro nivel, sin necesidad de modificar el codigo, dando la posibilidad de virtualizar cualquier sistema operattivo.

Una de las preguntas que me hicieron fue

O sea, Xen en Linux funciona en cualquier pc, Xen con Windows requiere
procesadores con soporte para virtualización… Eso es?

En teoria, segun lo dicho anteriormente deberia ser asi, ya que Microsoft no da acceso al codigo fuente de Windows, pero si Microsoft colaboro con este proyecto para que si se pudiera (a ellos tambien les ayudaria).