====== Instalar un módulo de clientes sin disco utilizando Debian y SAN (AoE) ======
Este tutorial mostrará una de las posibles formas de montar un laboratorio de clientes sin disco, utilizando Debian 6.0 y apoyándose en la tecnología SAN (//Storage Area Network//) mediante el protocolo AoE (//Ata over Ethernet//). Esta tecnología permite exportar un dispositivo de bloques (en otras palabras, un disco) por la red, de modo que un cliente pueda utilizarlo como si tuviese instalado el disco localmente.
El equipamiento que se pretende utilizar como ejemplo es un servidor Hanel con placa Intel S3000AH, un procesador Intel Xeon 3050, 1 GB de memoria RAM ECC y un arreglo de dos discos SATA 160GB en modo RAID1 (espejo) para garantizar la continuidad de funcionamiento del equipo incluso en caso de fallo de uno de los discos. Los clientes sin disco serán equipos Hanel, con una placa Intel D201GLY con procesador integrado de 1.2 GHz, y 256 MB de memoria RAM. Esta es una configuración usual en muchas empresas de nuestro país.
Si pretendemos utilizar esta solución con un servidor que tenga un solo disco, muchos pasos se simplifican, pues se pueden realizar directamente obviando todo lo relacionado con el arreglo de discos.
Este tutorial tiene un nivel intermedio; se asumirá que se posee cierto nivel de familiarización con Debian GNU/Linux, y que todos los comandos se ejecutarán como superusuario.((Para cambiar a modo de superusuario desde un usuario normal, puede ejecutarse el comando ''sudo su -''))
===== Preparativos =====
==== Controladora RAID ====
Vale aclarar que hay tres tipos de controladoras RAID:
- **Por hardware:** Este es el caso de los equipos y servidores de gama media-alta, que tienen una controladora con un microprocesador integrado para realizar las operaciones de un RAID. Si el equipo cuenta con una controladora RAID de este tipo, el sistema operativo reconocerá el disco RAID como si se tratase de un disco corriente, sin que sea necesario hacer nada especial.
- **Por BIOS:** Conocido como BIOS RAID o Fake RAID (raid falso). Este es el caso del actual tutorial; el BIOS trae la funcionalidad necesaria para realizar un arreglo con los discos, pero para abaratar costos la controladora no trae un microprocesador integrado para realizar los cálculos necesarios para la operación del disco en modo RAID, por lo cual necesita apoyarse en el microprocesador central de nuestro equipo, mediante un software que supla la funcionalidad faltante, en este caso, //dmraid//.
- **Por software:** En el caso de los equipos que no vengan con controladoras RAID, es posible lograr un RAID por software, para lo cual suele usarse el software //mdadm//.
Prosigamos entonces. Primeramente, debemos cerciorarnos de que la controladora de RAID está activa y que se ha hecho un arreglo con los dos discos, arreglo que en este caso nombraremos //Espejo//.
Para esto, durante el arranque del equipo, presionamos ''Ctrl+I'' cuando aparezca la pantalla relacionada. Una vez dentro de la aplicación //Intel Matrix Storage Manager//, revisamos si el arreglo existe, y apuntamos el nombre en un papel.
Si el arreglo no existe, lo creamos mediante la opción 1 (**//Create RAID Volume//**), le ponemos de nombre **Espejo**, en //RAID Level// escogemos **RAID1(Mirror)** y finalmente seleccionamos la opción **//Create Volume//**, salimos del menú de configuración, y reiniciamos el equipo.
==== Opciones del BIOS ====
Accedemos al BIOS (tecla F2) y nos cercioramos de configurar algunas entradas:
=== En la sección Advanced: ===
Acceder al submenú //IDE Controller// y configurarlo de la siguiente manera:
^ Opción ^ Valor ^
| Onboard PATA Controller | Enabled |
| Onboard SATA Controller | Enabled |
| SATA Mode | Enhanced |
| Configure SATA as RAID | Enabled |
| SATA RAID OPROM | Intel Matrix Storage |
=== En la sección Boot Options: ===
Establecer como primera opción el dispositivo ATAPI (CDROM) y como segunda, el arreglo (en este caso, debería mostrarse como //Intel Espejo//).
===== Instalar el sevidor =====
Iniciamos la instalación de Debian desde el CD.((En este tutorial, utilizaremos para la instalación del servidor el idioma inglés, ya que la traducción de algunos términos al español a veces desorienta más que lo que ayuda.)) Cuando aparezca el menú de instalación, selecionamos //Advanced options// y luego colocamos el cursor en //Expert install//, pero no presionamos aun la tecla de retorno.
En lugar de esto, presionamos el tabulador para editar la línea de arranque, y delante del guión doble insertamos el siguiente texto:
dmraid=true
Esta opción (que aunque está declarada como experimental suele funcionar muy bien) es la que permite que Debian detecte correctamente el arreglo de discos, pues de lo contrario, durante el paso de particionado el arreglo aparece como solo lectura.
==== Debian installer main menu ====
=== Choose Language ===
[Select a language] \\
//Language:// **English**
[Select your location] \\
//Country, terrtory or area:// **other** \\
//Continent or region:// **Caribbean** \\
//Country, terrtory or area:// **Cuba**
[Configure locales] \\
//Country to base default locale settings on:// **United states - en_US.UTF-8** \\
//Additional locales:// **es_ES.UTF-8** \\
//System locale:// **en_US.UTF-8** \\
=== Select a keyboard layout ===
[Select a keyboard layout] \\
//Type of keyboard:// **PC-style (AT or PS-2 connector) keyboard** \\
//Keymap to use:// **American English**
=== Detect and mount CD-ROM ===
[Detect and mount CD-ROM] \\
//Modules to load:// **(desmarcar)** \\
//PCMCIA resource range options:// **(dejar en blanco)**
=== Load installer components from CD ===
[Load installer components from CD] \\
//Installer components to load:// **(todo desmarcado)**
=== Detect network hardware ===
=== Configure the network ===
[Configure the network] \\
//Primary network interface:// **eth0: Intel Corporation 82573E Gigabit Ethernet Controller (Copper)** \\
//Auto-configure network with DHCP?// **No** \\
//IP address:// **192.168.1.1** \\
//Netmask:// **255.255.255.0** \\
//Gateway:// **192.168.0.1** \\
//Name server addresses:// **192.168.0.1** \\
//Is this information correct?// **Yes** \\
//Hostname:// **srvdiskless** \\
//Domain name:// **midominio.cu**
Como el servidor tiene dos interfaces de red, en este paso, lo que hemos realizado es configurar la primera interfaz (eth0) con la IP 192.168.1.1 para su uso con los clientes. Una vez finalizada la instalación de Debian, debemos editar ''/etc/network/interfaces'' para asignar a la segunda interfaz (eth1) la ip 192.168.0.2, por ejemplo. De lo contrario, el servidor no se comunicará con otro segmento de red que no sea el utilizado para los clientes.
=== Set up users and paswords ===
[Set up users and paswords] \\
//Enable shadow passwords?:// **Yes** \\
//Allow login as root?:// **No** \\
//Full name for the new user:// **Administrador del sistema** \\
//Username or your account:// **sysadmin** \\
//Choose a password for the new user:// **//MiContraseña//** \\
//Re-enter password to verify:// **//MiContraseña//**
=== Configure the clock ===
[Configure the clock] \\
//Set the clock using NTP?// **No** \\
//Select your time zone:// **Coordinated Universal Time (UTC)**
=== Detect disks ===
=== Partition disks ===
[Partition disks] \\
//Partitioning method:// **Manual**
Si el arreglo está recién creado no contendrá una tabla de particiones aun, por lo que aparecerá esta pregunta:
//Create new empty partition table on this device?// **Yes** \\
//Partition table type:// **msdos**
Deberá aparecer el disco (con un nombre aproximadamente como este): \\
Serial ATA RAID isw_abcdefghij_Espejo (mirror) - 160.0 Linux device-mapper (mirror)
pri/log 160.0 GB FREE SPACE
Para los efectos de este tutorial, crearemos entonces el esquema de particiones que mostramos en la siguiente tabla, seleccionando cada vez el espacio libre remanente para crear cada nueva partición:
^ Partition size ^ Type ^ Location ^ Use as ^ Mount point ^ Mount options ^ Label ^ Bootable flag ^
| 100M | Primary | Beginning | Ext3 | /boot | relatime | boot | On |
| 8G | Primary | Beginning | Ext3 | / | relatime | root | Off |
| 2G | Primary | Beginning | swap | (no aplicable) ||| Off |
| max | Primary | Beginning | LVM | (no aplicable) ||| Off |
La partición ''/boot'' generalmente no necesita más espacio, ya que contiene fundamentalmente las diferentes versiones que deseemos tener instaladas del núcleo (//kernel//) del sistema operativo.
La partición ''/'' (raíz) conviene tenerla separada de los datos para mayor seguridad y estabilidad. Aunque en realidad suele requerir un tamaño mucho menor, le hemos otorgado 8GB para que haya espacio suficiente en ''/opt'' para la posible instalación manual de aquellos programas que no formen parte de los repositorios de Debian.
Se ha establecido la opción //relatime// en algunas particiones para minimizar la posible afectación en rendimiento que impone al sistema tener que actualizar constantemente el momento de acceso a los archivos.((También podría haberse seleccionado //noatime// para que el momento de acceso no se actualice en absoluto.))
La partición //swap// es necesaria para emular memoria virtual; Linux suele requerirla para su buen funcionamiento.
Se utilizará LVM como última partición para poder crear particiones adicionales.((Las tablas de particiones tipo MSDOS solo admiten 4 particiones primarias.)) En realidad esto podría lograrse también con una partición extendida, pero los volúmenes lógicos de LVM ofrecen la ventaja adicional de que puede modificarse dinámicamente su tamaño, de ser necesario.
Una vez creadas las particiones básicas, configuraremos el volumen físico LVM. Para esto seleccionamos la opción **//Configure the Logical Volume Manager//**
//Write the changes to disk and configure LVM?// **Yes**
//LVM configuration action:// **Create volume group** \\
//Volume group name:// **Grupo1**
//Devices for the new volume group:// **(marcar ''/dev/mapper/isw_abcdefghij_Espejo4'')**
//LVM configuration action:// **Create logical volume** \\
//Volume group:// **Grupo1** \\
//Logical volume name:// **usr** \\
//Logical volume size:// **24G**
//LVM configuration action:// **Create logical volume** \\
//Volume group:// **Grupo1** \\
//Logical volume name:// **tmp** \\
//Logical volume size:// **9G**
//LVM configuration action:// **Create logical volume** \\
//Volume group:// **Grupo1** \\
//Logical volume name:// **home** \\
//Logical volume size:// **24G**
//LVM configuration action:// **Create logical volume** \\
//Volume group:// **Grupo1** \\
//Logical volume name:// **var** \\
//Logical volume size:// **(dejar el tamaño que sugiere)**
//LVM configuration action:// **Finish**
Una vez hecho esto, crearemos las particiones necesarias dentro de cada volumen, como mostramos en la siguiente tabla:
^ Logical volume ^ Use as ^ Mount point ^ Mount options ^ Label ^
| LV usr | Ext4 | /usr | relatime | usr |
| LV tmp | Ext4 | /tmp | defaults | tmp |
| LV home | Ext4 | /home | relatime | home |
| LV var | Ext4 | /var | relatime | var |
En el caso de la partición ''/var'', si se pretende publicar muchos archivos (típico de sitios Web muy complejos) conviene hacer un uso más eficiente de los inodes,((Cuando los //inodes// se agotan, no puede escribirse ningún otro archivo en la partición, aunque aun tenga espacio disponible.)) por lo que durante el proceso de particionado, en la opción //Typical usage// podríamos cambiar //standard// por //news// o la alternativa más conveniente.
La opción //Reserved blocks// permite especificar un espacio del disco reservado para uso del superusuario (para recuperar el sistema en caso de un fallo) o del propio sistema (para asignar los bloques de una manera eficiente y evitar la fragmentación). Si la paritición tiene una capacidad muy grande, podría reducirse el valor a menos del 5%
Una vez configurado todo, seleccionamos **//Finish partitioning and write changes to disk//**
//Write the changes to disks?// **Yes**
=== Install the base system ===
[Install the base system] \\
//Kernel to install:// **linux-image-2.6-686** \\
//Drivers to include in the initrd:// **generic: include all available drivers**
=== Configure the package manager ===
[Configure the package manager] \\
//Use a network mirror?// **No** \\
//Services to use:// **(desmarcar todos)**
=== Select and install software ===
//Choose software to install:// **(marcar solo //Standard system utilities//)**
=== Install the GRUB boot loader on a hard disk ===
[Install the GRUB boot loader on a hard disk] \\
//Install the GRUB boot loader to the master boot record?// **Yes**
Probablemente ocurra un error, pero no hay por qué preocuparse, simplemente saltamos al submenú //Continue without boot loader//. Por precaución, apuntamos en un papel el mensaje que aparece en esta opción, ya que incluye la ubicación de la partición //root//.
=== Finish the installation ===
[Configuring man-db] \\
//Is the system clock set to UTC:// **Yes**
==== Instalar el gestor de arranque ====
Ahora instalaremos GRUB. Para esto, necesitamos iniciar nuevamente desde el CD de instalación, pero en este caso, de las opciones avanzadas escogemos //Rescue Mode//, presionamos el tabulador y nuevamente insertamos delante del guión doble la línea:
dmraid=true
Una vez hecho esto, seguimos los pasos (similares a los realizados para la instalación) hasta que lleguemos a las verdaderas opciones de recuperación.
[Enter rescue mode] \\
//Device to use as root file system:// **/dev/dm-2** \\
//Rescue operations:// **Execute a shell in the installer environment**
La selección del sistema de archivos a utilizar como directorio raíz no es imprescindible, pero facilita las cosas.
Una vez en la consola de recuperación, ejecutamos estos comandos:
chroot /target
mount /dev/dm-1 /boot
mount /dev/mapper/Grupo1-usr /usr
grub-install /dev/mapper/isw_abcdefghij_Espejo
grub-mkconfig > /boot/grub/grub.cfg
Si olvidamos la ruta del arreglo, podemos abrir una nueva terminal (Alt+F2) y listamos las particiones:
ls /dev/mapper
La ubicación apropiada para instalar el gestor de arranque en el arreglo de discos debe ser la que comienza con isw y termina sin numeración alguna (en otras palabras, el propio disco RAID y no una partición en particular).
==== Instalar paquetes adicionales ====
Una vez terminada la instalación básica, instalaremos algunos paquetes adicionales, para lo cual evidentemente debe establecerse antes el origen del repositorio en el archivo ''/etc/apt/sources.list'', por ejemplo de un espejo ubicado en la red local:
deb http://192.168.0.1/mirror/debian squeeze main contrib non-free
Procedemos entonces a actualizar el sistema:
aptitude update && aptitude full-upgrade
Si la actualización ocurrió sin problemas, proseguimos instalando los paquetes. En este tutorial ajustaremos los parámetros para que se instale automáticamente cualquier paquete recomendado por los paquetes fundamentales, y solo las dependencias para el resto.
aptitude install -rv lsb-release build-essential sysv-rc-conf modconf aoetools vblade-persist kpartx
aptitude install -Rv bash-completion console-{common,data} less bc htop pv
aptitude install -Rv dbus gnutls-bin ca-certificates strace file mime-support
aptitude install -Rv arp-scan nbtscan dns{masq,utils,tracer} telnet w3m-img elinks
aptitude install -Rv ntfs-{3g,config} ntfsprogs acl lsof testdisk disktype mlocate
aptitude install -Rv imagemagick poppler-utils odt2txt p7zip-full unace unrar-free zip unzip mc
==== Agregar el soporte AoE ===
Como mencionamos al principio, en este tutorial utilizaremos la tecnología SAN (//Storage Area Network//), que a diferencia de NAS (//Network Attached Storage//) permite exportar por la red dispositivos de bloque como si fuesen discos locales, en lugar de exportar un sistema de archivos remoto basado en protocolos de archivos como NFS. En este tutorial se utiliza el protocolo AoE (//Ata over Ethernet//), porque tiene menor complejidad e impone menos requerimientos que iSCSI (uno de los protocolos más frecuentemente utilizados para SAN).
En definitiva, este acercamiento permitirá hacer un uso más eficiente de la red, pues los clientes no tendrán que cargar de una vez la imagen completa del sistema operativo de un directorio compartido remotamente, sino que la carga podrá hacerse bajo demanda, como si de un disco duro local se tratase.
Primeramente debemos verificar que el núcleo (//kernel//) soporta AoE:
cat /boot/config-$(uname -r) | grep ATA_OVER
Si aparece una respuesta como la siguiente, significa que el núcleo soporta AoE:
CONFIG_ATA_OVER_ETH=m
Ahora debemos verificar si el módulo ''aoe'' está cargado, para lo cual realizamos esta consulta:
lsmod | grep -i aoe
Si no aparece nada, procedemos a instalarlo, para lo cual podemos ejecutar el siguiente comando:((También puede instalarse manualmente el módulo agregando su nombre al archivo ''/etc/modules'' y luego cargando dicho módulo con el comando ''modprobe''.))
modconf
Buscamos la entrada que dice **kernel/drivers/block/aoe** y presionamos la tecla de retorno. Debería aparecer algo así:
aoe - (No description available)
Lo seleccionamos y presionamos retorno para que se instale (cuando se pregunte, no es necesario proporcionar ningún parámetro):
//Install this module in the kernel?// ****
El módulo debería instalarse y cargarse. Para comprobarlo, ejecutamos el siguiente comando:
tail /var/log/syslog
Debería aparecer algo así:
Mar 29 13:00:12 srvdiskless kernel: [6112.027646] aoe: AoE v47 initialized.
===== Instalar el cliente =====
La manera más fácil de preparar el cliente es colocándole un disco duro o memoria flash de unos 2 GB (igual podría colocarse un disco normal y simplemente crear particiones limitadas, lo que hay que tener precaución de crearlas desde el principio del disco hacia atrás, de manera contígua) y un lector de CD-ROM, y realizando una instalación habitual, preferiblemente con un entorno de escritorio minimalista como XFCE o LXDE, a fin de realizar un uso lo más eficiente posible del hardware que proporcionan los clientes, que aunque no es muy potente, es al menos más potente que el que viene en las verdaderas terminales ligeras (que toman todos los recursos del servidor).((A menos que se necesite tener muchas aplicaciones en los clientes, es conveniente tener imágenes de tamaño pequeño, ya que cada cliente necesita su propio disco.))
No detallaremos aquí el proceso de instalación, porque en gran medida este dependerá de nuestras necesidades y de las aplicaciones que deseemos instalar en los clientes, pero para los efectos de este tutorial, asumamos que se ha utilizado un disco pequeño y se han creado en este dos particiones, la principal en formato ext3, y una swap.
Por cierto, vale aclarar que aunque en este tutorial se asume que los clientes tendrán instalado Debian GNU/Linux, puede instalarse cualquier sistema operativo capaz de iniciar desde un disco AoE (por ejemplo, FreeBSD o incluso Windows de ser necesario, aunque ello no formará parte de este tutorial).
=== Crear un usuario de trabajo ===
Recomendamos realizar la instalación como un usuario especial que pertenezca al grupo ''sudoers'' (como hicimos con el servidor), y finalmente crear un usuario normal para los operadores y agregarlo a los grupos necesarios:
groupadd usuarios
useradd -mg usuarios operador
usermod -aG audio,dip,video,plugdev,powerdev operador
=== Configurar el soporte para AoE ===
Nos cercioramos de que el cliente tenga habilitado el soporte para AoE. En el caso de Debian GNU/Linux, esto se realiza como mismo explicamos para el servidor (aunque no es necesario instalar en este caso paquetes de servicios como ''vblade-persist'' o ''dnsmasq'').
===== Crear la imagen =====
Una vez instalado el sistema operativo, quitamos el disco del cliente y lo colocamos en el servidor para hacerle una imagen.
Vale aclarar que los dispositivos exportados mediante el protocolo AoE no están diseñados para un acceso concurrente desde distintos clientes, por lo que esta primera imagen la utilizaremos de plantilla, y la copiaremos y modificaremos tantas veces como clientes deseemos gestionar.
Bien, supongamos que el sistema reconoce el disco como ''/dev/sdb/''
Procedemos entonces a crear un directorio donde almacenaremos la imagen:
mkdir -p /var/almacenamiento/discos
Una vez realizado esto, hacemos la imagen del disco duro con el comando ''dd''. En este ejemplo, usaremos el comando en dos partes utilizando un //pipe// intermedio con el comando ''pv'' para mostrar el progreso, ya que usualmente ''dd'' no lo muestra y uno podría pensar que el sistema se ha bloqueado.
dd if=/dev/sdb bs=512 | pv | dd of=/var/almacenamiento/discos/miplantilla.ima
En caso que hayamos realizado las partciciones utilizando solamente una parte del disco, podríamos averiguar cuanto ocupan en bytes (para mayor exactitud):
df --block-size=1 -T
Este comando debería mostrar un listado de las particiones existentes, su tipo y tamaño. Con eso es solo cuestión de sumar la cantidad de bytes de todas las particiones y al resultado final sumarle 512 bytes (que es lo que ocupan la tabla de particiones y el MBR, aunque si queremos podríamos dar un margen extra de hasta unos pocos megabytes).
Supongamos que obtuvimos una partición primaria ext4 de exactamente 4294967296 bytes y una swap de 805306368 bytes, que sumado a 512 daría 5100274176 bytes. Entonces usamos ''dd'' con esta cifra (definiendo un tamaño de bloque de 1 byte).
dd if=/dev/sdb bs=1 count=5100274176 | pv | dd of=/var/almacenamiento/discos/miplantilla.ima
=== Modificar el archivo initramfs ===
Aunque hayamos instalado en el cliente los módulos necesarios para la detección de dispositivos AoE, para que el cliente pueda reconocer y montar la partición principal (o raíz) desde la red, es necesario realizar algunos ajustes adicionales sobre el archivo ''initrd''.
Hay varias maneras de realizar esto, en este caso realizaremos el proceso descomprimiendo, modificando y reempaquetando el archivo manualmente, ya que el comando ''mkinitramfs'' aparentemente no es totalmente compatible aun con el protocolo AoE.
Lo primero es montar la imagen. Para esto podemos apoyarnos en el comando ''kpartx'', que crea mapeos tipo //loopback// de los segmentos de particiones que encuentra en la imagen, y que luego se pueden utilizar para montar las particiones de la manera habitual. En este caso, como la imagen contiene dos particiones, el dispostitivo a montar será ''/dev/mapper/loop0p1''.((Para más detalles, ver [[:tutoriales:montar_particiones_imagen|este artículo]].))
kpartx -av /var/almacenamiento/discos/miplantilla.ima
mkdir -p /mnt/p1
mount /dev/mapper/loop0p1 /mnt/p1
Una vez que tengamos montada la partición principal, creamos un directorio de trabajo y en él extraemos el contenido del archivo ''initrd'', que está empaquetado con ''cpio'' y comprimido en formato gzip.
mkdir -p /var/tmp/initrd
cd /var/tmp/initrd
zcat /mnt/p1/boot/initrd.img-2.6.32-5-686 | cpio -id
En el directorio deberían crearse un conjunto de directorios con archivos. Realizaremos algunas modificaciones sobre este sistema de archivos, a fin de habilitar el soporte para dispositivos AoE.
Primeramente, editaremos el archivo de configuración:
editor /var/tmp/initrd/conf/initramfs.conf
En su interior localizaremos la línea que dice ''BOOT=local'' y la modificaremos para que quede ''BOOT=aoe''
Este cambio indica al sistema que al iniciar no utilice ''/script/local'' sino un script preparado para el soporte de dispositivos AoE((Este script se deriva de otros encontrados en [[http://jozz.no-ip.org/wiki/igep/debian/installer/aoe|este artículo]] y [[http://wp.colliertech.org/cj/?p=678|este otro]].)).
Para crear el script, lanzamos el editor:
editor /var/tmp/initrd/scripts/aoe
Colocamos en el interior el siguiente contenido:
# AoE filesystem mounting
# Based on the NFS filesystem mounting
# FIXME This needs error checking
retry_nr=0
reset_cnt()
{
times_to_sh=10
}
wait_cnt()
{
times_to_sh=$(( ${times_to_sh} - 1 ))
if [ ${times_to_sh} -le 0 ] ; then
reset_cnt
log_msg_begin "Timed out, entering shell"
sh
log_msg_end
else
sleep 1
echo .
fi
}
# parse AoE bootargs and mount AoE
do_aoemount()
{
configure_networking
# make sure aoe root exists
log_begin_msg "Discovering AoE device ${ROOT}"
reset_cnt
while [ ! -e ${ROOT} ] ; do
echo > /dev/etherd/discover
wait_cnt
done
log_end_msg
# discover fstype and modprobe
if [ -z "${ROOTFSTYPE}" ] ; then
FSTYPE=ext3
#get_fstype can be tried FSTYPE=$(get_fstype "${ROOT}")
else
FSTYPE=${ROOTFSTYPE}
fi
# Maby it is a module
modprobe ${FSTYPE}
# set read-only
if [ ${readonly} = y ]; then
roflag="-o ro"
else
roflag="-o rw"
fi
log_begin_msg "mounting ${roflag} -t ${FSTYPE} ${ROOTFLAGS} ${ROOT} ${rootmnt}"
mount ${roflag} -t ${FSTYPE} ${ROOTFLAGS} ${ROOT} ${rootmnt}
log_end_msg
}
# AOE root mounting
mountroot()
{
log_begin_msg "Mounting AoE"
modprobe aoe
modprobe af_packet
echo > /dev/etherd/discover
wait_for_udev 10
do_aoemount
log_end_msg
}
=== Reempaquetar ===
Una vez terminadas las modificaciones, necesitamos recrear el archivo ''initrd'' (utilizamos nuevamente el comando ''pv'' para tener una referencia del progreso). Como precaución, preservaremos el archivo original (renombrado) por si algo sale mal repetir el proceso:
mv /mnt/p1/boot/initrd.img-2.6.32-5-686 /mnt/p1/boot/initrd.img-2.6.32-5-686.original
cd /var/tmp/initrd
find ./ | cpio -oH newc | pv | gzip -9 > /mnt/p1/boot/initrd.img-2.6.32-5-686
=== Realizar otros ajustes ===
Antes de finalizar la imagen que utilizaremos como plantilla, podemos aprovechar para hacer algunos ajustes adicionales. Por ejemplo, a fin de evitar colisiones entre los nombres de los clientes, conviene editar el archivo ''/etc/hostname'' y también ''/etc/mailname''. La manera menos engorrosa de lograr esto es vaciando el contenido de estos archivos y creando un simple script que los llene automáticamente cuando el cliente arranque desde la imagen.
Para esto, ejecutamos los siguientes comandos:
cat /dev/null > /mnt/p1/etc/hostname
cat /dev/null > /mnt/p1/etc/mailname
editor /mnt/p1/etc/rc.local
En el archivo ''rc.local'' colocamos entonces (antes de la línea que dice ''exit 0'') algo como esto:
LANHOSTNAME=$(cat /etc/hostname)
if [ -z "$LANHOSTNAME" ] ; then
echo "$(hostname)" > /etc/hostname
echo "$(hostname).$(dnsdomainname)" > /etc/mailname
fi
Adicionalmente, nos cercioramos que dentro del archivo ''/etc/hosts'' solo estén las líneas relacionadas a ''localhost'' (127.0.0.1).
=== Finalizar la imagen ===
Una vez terminadas las modificaciones, desmontamos la imagen y eliminamos los mapeos:
umount /mnt/p1
cd /var/almacenamiento/discos
kpartx -d miplantilla.ima
Entonces creamos tantas copias de trabajo de la imagen como necesitemos, y posteriormente protegemos la plantilla contra posibles eliminaciones o modificaciones por descuido, estableciendo el bit inmutable:
cp miplantilla.ima d0{1,2}.ima
chattr +i miplantilla.ima
==== Exportar la imagen ====
Ahora procederemos a exportar las imágenes como dispositivos de bloque para su uso por la red:
vblade-persist setup 0 1 eth0 /var/almacenamiento/discos/d01.ima
vblade-persist mac 0 1 add 00:1A:2B:3C:4D:5E
vblade-persist setup 0 2 eth0 /var/almacenamiento/discos/d02.ima
vblade-persist mac 0 2 add 00:1A:2B:3C:4D:5F
vblade-persist auto all
vblade-persist restart all
Los parámetros "0 1" y "0 2" se deben a que el protocolo AoE utiliza el prinicipio de //shelf// (estante, anaquel, repisa) y //slot// (ranura, espacio) para definir las direcciones. Hecho este paso, comprobamos que los dispositivos están activos:
vblade-persist ls
Este comando debería producir el siguiente resultado:
#shelf slot netif source auto? stat
0 1 eth0 /var/almacenamiento/discos/d01.ima auto run
0 2 eth0 /var/almacenamiento/discos/d02.ima auto run
Con esto, el dispositivo AoE debe estar listo para su uso por la red, o más concretamente, por la interfaz eth0, ya que lo más seguro es que necesitemos utilizar la interfaz eth1 para unir el servidor al resto de la red empresarial, donde generalmente se proporcionarán el resto de los servicios.
===== Configurar el arranque por red ====
En este tutorial, para el arranque de los clientes por la red utilizaremos el archivo ejecutable ''undionly'' del proyecto gPXE.((Si bien este proyecto parece abandonado y ha sido relevado por otro más novedoso llamado iPXE, por algún motivo el ejecutable ''undionly'' de iPXE no parece ser del todo compatible con los clientes Hanel, al menos en el momento en que se escribe este tutorial.)) Este archivo puede obtenerse [[http://rom-o-matic.net/gpxe/gpxe-1.0.1/contrib/rom-o-matic/|aquí]] (selecccionar como formato "PXE bootstrap loader keep [Keep PXE stack method 1]" y como tipo NIC "undionly").
Una vez obtenido el ejecutable, procedemos a crear un directorio y copiar allí dicho archivo:
mkdir -p /var/almacenamiento/pxe
cp gpxe-1.0.1-undionly.kpxe /var/almacenamiento/pxe/undionly.kpxe
===== Configurar DHCP + DNS + TFTP =====
En este tutorial, utilizaremos el paquete ''dnsmasq'' como una solución ligera para proporcionar los servicios DHCP, DNS y TFTP, a fin de entregar a los clientes el archivo PXE.
La configuración de este servicio depende en gran medida de las necesidades. En este tutorial pondremos un ejemplo de configuración preparado para dos clientes, donde cada uno va a tomar siempre su misma dirección IP e imagen de disco (naturalmente, para que existan dos clientes deben exportarse dos imágenes mediante ''vblade-persist'' con direcciones AoE diferentes).
Creamos entonces un archivo de configuración, para no confundirnos con el que viene por defecto (que de todas formas podemos utilizar de ayuda).
editor /etc/dnsmasq.d/conf
En el interior del archivo, colocamos el siguiente contenido:((Incluimos un breve comentario con el propósito de cada entrada, pero para más información, puede consultarse el manual y el [[http://www.thekelleys.org.uk/dnsmasq/doc.html|sitio web]] de ''dnsmasq''.))
# Interfaz de red en la cual escuchará el servicio
interface=eth0
# Dirección por la cual escuchar
listen-address=192.168.1.1
# Dominio para la red
domain=midominio.cu
# No reenviar consultas DNS para redes privadas
bogus-priv
# Filtrar consultas provenientes de Windows
filterwin2k
# Localizar las consultas
localise-queries
# cantidad de resultados de las consultas DNS que se almecenarán en la cache
cache-size=300
# No almacenar en la cache resultados negativos (direcciones no que no pudieron resolverse)
no-negcache
# Establecer el rango de direcciones y su duración por defecto para el servicio DHCP
# (debe ser mayor que la cantidad de equipos a la que se asignarán direcciones estáticas)
dhcp-range=set:lan,192.168.1.2,192.168.1.254,255.255.255.0,36h
# Establecer para esta PC siempre el mismo nombre (d01) y dirección IP (192.168.1.2), y adicionalmente identificarla con una etiqueta (d01)
dhcp-host=00:1A:2B:3C:4D:5E,set:d01,192.168.1.2,d01,infinite
# Establecer un alias más comprensible (sindisco1) para la PC d01
cname=sindisco1,d01
# Establecer para esta PC siempre el mismo nombre (d02) y dirección IP (192.168.1.3), y adicionalmente identificarla con una etiqueta (d02)
dhcp-host=00:1A:2B:3C:4D:5F,set:d02,192.168.1.3,d02,infinite
# Establecer un alias más comprensible (sindisco2) para la PC d02
cname=sindisco2,d02
# Habilitar el servicio TFTP
enable-tftp
# Establecer el directorio raíz para el servicio TFTP
tftp-root=/var/almacenamiento/pxe/
# Establecer la opción para el arranque etherboot
dhcp-match=set:gpxe,175
# Establecer el ejecutable PXE a cargar
dhcp-boot=tag:!gpxe,undionly.kpxe
# Habilitar la opción KEEP_SAN_ALIVE (esto usualmente es requerido para iSCSI, ignoro si para AoE también, pero no hace daño ponerlo)
dhcp-option=175,8:1:1
# Si se detectan las etiquetas gpxe y d01, cargar el dispositivo AoE e0.1
dhcp-option=tag:gpxe,tag:d01,17,"aoe:e0.1"
# Si se detectan las etiquetas gpxe y d02, cargar el dispositivo AoE e0.2
dhcp-option=tag:gpxe,tag:d02,17,"aoe:e0.2"
# Establecer el archivo donde se guardarán las trazas del servicio
log-facility=/var/log/dnsmasq/dnsmasq.log
# Generar trazas para el servicio DHCP
log-dhcp
# Generar trazas para las peticiones DNS
log-queries
# Especificar la cantidad de trazas que se guardarán de manera asíncrona
log-async=20
Como podremos apreciar, en este archivo de configuración se establecen las etiquetas d01 y d02 para identificar a cada cliente por su dirección MAC,((Esta dirección puede obtenerse ejecutando en el cliente el comando ''ifconfig -a'')) y así cargar posteriormente la imagen que corresponda a cada uno.
Para que los cambios entren en vigor, reiniciamos el servicio:
service dnsmasq restart
Una vez finalizado este paso, solo queda configurar en el BIOS de los clientes el orden de arranque, para que que como primer (o único) dispositivo de inicio utilicen la red.
===== Notas =====
Se agradece la colaboración del usuario **ymn** en el foro, que sugirió agregar las direcciones MAC con el comando ''vblade-persist mac''. Sin esto, aunque dnsmasq y gPXE ordenen correctamente a los clientes cargar la imagen correspondiente a su dirección MAC, en ocasiones sucede que el cliente carga otra imagen (incluso de un cliente que ya la está utilizando), lo cual puede corromperla.
===== Atribuciones =====
* **Autor:** Hugo Florentino
* **Contribuyentes:** Usuario ymn en el foro (lamentablemente desconocemos su nombre real).