Nodos sin disco en Gentoo

1.  Introducción

Acerca de esta Guía

Esta guía te ayudará a configurar estaciones de trabajo sin disco basadas en la distribución Linux Gentoo. Hemos intentado hacerla fácil de usar y atractiva para el principiante, porque todos nosotros en algún momento hemos sido uno :). Si bien un usuario experimentado puede unir varias Guías sobre nodos sin disco y juntarlas con otras sobre trabajo en red, esperamos que esta guía facilite la instalación a todos los usuarios interesados, "geeks" o no.

¿Qué es una máquina sin disco?

Una máquina sin disco es una PC sin ninguno de los dispositivos de arranque tradicionales, como disco duro, disquete o CD-ROMs. Un nodo sin disco arranca desde la red y por lo tanto necesita un servidor que le provea con un espacio de almacenamiento que pueda utilizar como disco local. De ahora en adelante llamaremos al servidor maestro y a la máquina sin disco esclavo. El nodo esclavo necesita un adaptador de red que soporte el arranque PXE o Etherboot; revisa Etherboot.org para ver una lista de dispositivos soportados. La mayoría de tarjetas actuales soportan PXE y varios adaptadores incorporados en la tarjeta madre también funcionarán.

Antes de empezar

Debes tener instalado Gentoo en tu nodo maestro y tener espacio suficiente en él para almacenar los sistemas de archivos de los nodos esclavos a los que vayas a servir. Además, asegúrate de tener una interfase conectada a Internet separada de la que utilizas para conectarte a la red local.

2.  Configurando el maestro y el esclavo

Acerca de los núcleos

El núcleo es el software que está entre tu hardware y todo el demás software que posee tu computadora, es esencialmente el corazón de un sistema operativo basado. Cuando inicias tu computadora, el BIOS ejecuta las instrucciones que están en el espacio reservado para el arranque en tu disco duro. Estas instrucciones son típicamente un cargador de arranque que carga el núcleo. Luego de cargar el núcleo, este se ocupa de todos los demás procesos.

Para más información acerca del núcleo o de su configuración, tal vez te interesaría leer la Guía del kernel.

Configurando el núcleo maestro

El núcleo maestro puede ser tan grande y personalizado como quieras, pero ten en cuenta que hay ciertas opciones que debes seleccionar. Ve a tu menú de configuración del núcleo ejecutando:

# cd /usr/src/linux
# make menuconfig

Debe aparecer una pantalla azul y gris que ofrece una alternativa segura a la de editar manualmente el archivo /usr/src/linux/.config. Si el núcleo actual funciona correctamente, es recomendable que guardes la configuración, saliendo de esa interfaz gráfica y ejecutando:

# cp .config .config_working

Ingresa dentro de los siguientes sub-menús y asegúrate que los ítems listados están marcados como built-in (NO como módulos). Las opciones mostradas aquí son de la versión 2.6.10 del núcleo. Si usas una versión distinta, el texto o la secuencia podrían diferir. Sólo asegúrate de seleccionar al menos aquellas opciones mostradas a continuación.

Code maturity level options  --->
  [*] Prompt for development and/or incomplete code/drivers
Device Drivers --->
Networking options --->
  <*> Unix domain sockets
  [*] TCP/IP networking
  [*]   IP: multicasting
      []  Network packet filtering (replaces ipchains)
  
File systems --->
  Network File Systems  --->
    <*> NFS server support
    [*]   Provide NFSv3 server support

Si quieres tener acceso a Internet a través de tu nodo maestro y/o
tener un cortafuegos seguro, añade el soporte para iptables.

  [*] Network packet filtering (replaces ipchains)
  IP: Netfilter Configuration  --->
    <*> Connection tracking (required for masq/NAT)
    <*> IP tables support (required for filtering/masq/NAT)

Si quieres usar filtrado de paquetes, puedes añadir el resto como módulos más tarde. Asegúrate de leer Guía de seguridad Gentoo Capítulo 12 Cortafuegos para saber cómo configurarlo de manera adecuada.

Luego de haber reconfigurado el núcleo maestro, debes recompilarlo:

# make && make modules_install
(Asegúrate de que la partición /boot esté montada
antes de copiar el núcleo)
# cp arch/i386/boot/bzImage /boot/bzImage-master

Luego añade una opción para este núcleo nuevo en lilo.conf o grub.conf dependiendo de cual cargador de arranque uses, y haz esta nueva opción la predeterminada. Ahora que tu bzImage ha sido copiada al directorio de arranque, todo lo que necesitas hacer para cargar estas nuevas opciones es reiniciar el sistema.

Acerca del núcleo esclavo

Recomendamos que compiles tu núcleo esclavo sin módulos, ya que cargar y configurarlos en un arranque por red es un proceso dificultoso e innecesario. Además, el núcleo esclavo debe ser tan simple y compacto como sea posible, para hacer el arranque a través de la red eficiente. Vamos a compilar el núcleo esclavo en el mismo lugar donde configuramos el núcleo maestro.

Para evitar cualquier confusión y desperdicio de tiempo es una buena idea hacer una copia de seguridad del archivo de configuración del núcleo maestro ejecutando:

# cp /usr/src/linux/.config /usr/src/linux/.config_master

Ahora configuraremos el núcleo esclavo de la misma forma que lo hicimos con el núcleo maestro. Si quieres empezar con un archivo de configuración nuevo, siempre puedes recuperar el archivo por defecto /usr/src/linux/.config ejecutando:

# cd /usr/src/linux
# cp .config_master .config

Ahora entremos a la configuración visual ejecutando:

# cd /usr/src/linux
# make menuconfig

Debes asegurarte de seleccionar las siguientes opciones como built-in y NO como módulos:

Code maturity level options  --->
  [*] Prompt for development and/or incomplete code/drivers
Device Drivers --->
  [*] Networking support
Networking options --->
  <*> Unix domain sockets
  [*] TCP/IP networking
  [*]   IP: multicasting
  [*]   IP: kernel level autoconfiguration
  [*]     IP: DHCP support (NEW)
File systems --->
  Network File Systems  --->
    <*> file system support 
    [*]   Provide NFSv3 client support
    [*]   Root file system on NFS

Ahora el núcleo esclavo necesita ser compilado. Tienes que ser cuidadoso en este paso ya que no querrás estropear los módulos (si es que hay alguno) que compilaste para tu núcleo maestro:

# cd /usr/src/linux
# make

Ahora crea el directorio en el maestro que se utilizará para almacenar los archivos del esclavo además de sus archivos de sistema. Nosotros utilizamos un directorio /diskless pero tu puedes elegir la ubicación que prefieras. Ahora, copia la bzImage de tu esclavo dentro de /diskless:

# mkdir /diskless
# cp /usr/src/linux/arch/i386/boot/bzImage /diskless

Configurando un sistema de archivos esclavo preliminar

Los sistemas de archivos maestro y esclavo pueden ser ajustados y cambiar bastante, pero por ahora sólo nos interesa tener sistemas de archivos preliminares con los archivos de configuración apropiados y los puntos de montaje necesarios. Primero, necesitamos crear un directorio dentro de /diskless para el primer esclavo. Cada esclavo necesita su propio sistema de archivos raíz porque compartir ciertos archivos del sistema causará problemas con los permisos y caídas del sistema. Les puedes poner a estos directorios los nombres que desees pero te sugerimos que utilices las direcciones IP de los esclavos, ya que estas son únicas y no confusas. La dirección IP estática de tu primer esclavo sería, por ejemplo, 192.168.1.21:

# mkdir /diskless/192.168.1.21

Varios archivos de configuración dentro de /etc necesitan ser modificados para que funcionen en el esclavo. Copia tu directorio maestro /etc en el directorio raíz de tu esclavo ejecutando:

# cp -r /etc /diskless/192.168.1.21/etc

Todavía este sistema de archivos no está listo porque necesita varios puntos de montaje y directorios. Para crearlos ejecuta:

# mkdir /diskless/192.168.1.21/home
# mkdir /diskless/192.168.1.21/dev
# mkdir /diskless/192.168.1.21/proc
# mkdir /diskless/192.168.1.21/tmp
# mkdir /diskless/192.168.1.21/mnt
# chmod a+w /diskless/192.168.1.21/tmp
# mkdir /diskless/192.168.1.21/mnt/.initd
# mkdir /diskless/192.168.1.21/root
# mkdir /diskless/192.168.1.21/sys
# mkdir /diskless/192.168.1.21/var
# mkdir /diskless/192.168.1.21/var/empty
# mkdir /diskless/192.168.1.21/var/lock
# mkdir /diskless/192.168.1.21/var/log
# mkdir /diskless/192.168.1.21/var/run
# mkdir /diskless/192.168.1.21/var/spool
# mkdir /diskless/192.168.1.21/usr
# mkdir /diskless/192.168.1.21/opt

La mayoría de estos directorios deben ser familiares para ti; algunos como /dev, /proc o /sys serán llenados una vez que el esclavo arranque, los demás serán montados luego. Además, debes cambiar el archivo /diskless/192.168.1.21/etc/conf.d/hostname para que este contenga el nombre del anfitrión del esclavo. Binarios, librerías y otros archivos serán puestos en su lugar más tarde en esta Guía, luego de que intentes iniciar el esclavo.

Aunque /dev/ es luego poblado por udev, necesitas crear la entrada console. Sino recibirás el error "no es posible abrir la consola inicial" ("unable to open initial console").

  # mknod /diskless/192.168.1.21/dev/console c 5 1

3.  Configurando el servidor DHCP

Acerca del servidor DHCP

DHCP son las iniciales (en inglés) de Protocolo Dinámico de Configuración del Anfitrión. El servidor DHCP es la primera máquina con la que el esclavo se comunicará en el momento del arranque PXE. El propósito primario del servidor DHCP es el de asignar las direcciones IP. El servidor DHCP puede asignar direcciones IP basándose en la dirección MAC Ethernet del anfitrión. Una vez que el esclavo tiene su dirección IP, el servidor DHCP le dirá donde conseguir su sistema de archivos inicial y el núcleo.

Antes de empezar

Hay un par de cosas que debes estar seguro que funcionan antes de empezar. Primero revisa la conectividad a red:

# ifconfig eth0 multicast
# ifconfig -a

Debes asegurarte de tener un dispositivo eth0 funcionando. La salida del comando anterior debe parecerse algo a esto:

eth0      Link encap:Ethernet  HWaddr 00:E0:83:16:2F:D6
          inet addr:192.168.1.1  Bcast:192.168.1.255  Mask:255.255.255.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:26460491 errors:0 dropped:0 overruns:2 frame:0
          TX packets:32903198 errors:0 dropped:0 overruns:0 carrier:1
          collisions:0 txqueuelen:100
          RX bytes:2483502568 (2368.4 Mb)  TX bytes:1411984950 (1346.5 Mb)
          Interrupt:18 Base address:0x1800

Es importante que diga MULTICAST, si no lo hace debes recompilar tu núcleo para incluir el soporte para multicast.

Instalando el servidor DHCP

Si tu red no tiene un servidor DHCP instalado, debes instalar uno:

# emerge dhcp

Si tu red ya tiene un servidor DHCP, debes modificar el archivo de configuración de manera que tenga la función de arranque PXE correctamente configurada.

Configurando el servidor DHCP

Sólo hay un archivo de configuración que tendrás que modificar antes de iniciar tu servidor DHCP: /etc/dhcp/dhcpd.conf. Copia y modifica el archivo de ejemplo que te dan:

# cp /etc/dhcp/dhcpd.conf.sample /etc/dhcp/dhcpd.conf
# nano -w /etc/dhcp/dhcpd.conf

La disposición general del archivo se asemeja a esta:

# Opciones globales aquí
ddns-update-style none;
shared-network LOCAL-NET {
# Opciones de red compartida aquí
subnet 192.168.1.0 netmask 255.255.255.0 {
    # Opciones de sub red aquí
    host slave{
        # Opciones específicas del anfitrión aquí
    }
    group {
        # Opciones específicas del grupo aquí
    }
}
}

El bloque shared-network es opcional y debe ser utilizado para las direcciones IP que quieras asignar que pertenecen a la misma topología de red. Al menos una subred debe ser declarada y el bloque opcional group te permite agrupar opciones entre ítems. Un buen ejemplo del dhcpd.conf es:

# 
# Ejemplo del archivo dhcpd.conf de los clientes
#
 
# Desactiva el DNS dinámico
ddns-update-style none;
 
# Asume una puerta de enlace predeterminada para el tráfico IP
option routers 192.168.1.1;

# Provee información DNS a los clientes
option domain-name-servers 192.168.1.1;
option domain-name "mydomain.com";

# Especifica el servidor TFTP a utilizar
next-server 192.168.1.1;

# Declara una opción del buffer específica del vendedor para los clientes PXE:
# Código 1: Dirección IP Multicast del servidor de archivos de arranque
# Código 2: Puerto UDP que el cliente debe monitorear para recibir 
#           respuestas MTFTP
# Código 3: Puerto UDP que los servidores MTFTP utilizan para escuchar 
#           solicitudes MTFTP
# Código 4: Número de segundos que el cliente debe escuchar por actividad antes 
#           de iniciar una nueva transferencia MTFTP
# Código 5: Número de segundos que el cliente debe escuchar antes de reiniciar 
#           una transferencia MTFTP
 
option space PXE;
option PXE.mtftp-ip               code 1 = ip-address;
option PXE.mtftp-cport            code 2 = unsigned integer 16;
option PXE.mtftp-sport            code 3 = unsigned integer 16;
option PXE.mtftp-tmout            code 4 = unsigned integer 8;
option PXE.mtftp-delay            code 5 = unsigned integer 8;
option PXE.discovery-control      code 6 = unsigned integer 8;
option PXE.discovery-mcast-addr   code 7 = ip-address;
 
# Declara la subred en la cual van a existir nuestro nodos sin disco
subnet 192.168.1.0 netmask 255.255.255.0 {
 
  # Provee a los clientes PXE con la información apropiada
  class "pxeclient" {
    match if substring (option vendor-class-identifier, 0, 9) = "PXEClient";
    vendor-option-space PXE;
 
    # Al menos 1 de las opciones PXE específicas del fabricante deben
    # ser definidas para que el ROM de arranque de los clientes se de
    # cuenta que el servidor tienes las características PXE. Definimos
    # la dirección IP MCAST a 0.0.0.0 para indicarle al ROM de arranque
    # que no podemos proveerle un TFTP multicast.
 
    option PXE.mtftp-ip 0.0.0.0;
 
    # Este es el nombre del archivo que el ROM arranque debe descargar
    filename "pxelinux.0";
  }
  # Provee a los clientes Etherboot con la información apropiada
  class "etherboot" {
        match if substring(option vendor-class-identifier, 0, 9) = "Etherboot";
        filename "vmlinuz_arch";
  }

  # Agrega una declaración por cada máquina sin disco
  host slave21 {
       hardware ethernet                00:02:A5:04:3B:66;
       fixed-address                    192.168.1.21;
  }
}

A la dirección IP luego de next-server se le preguntará por el filename. Esta dirección IP debe ser el IP del servidor tftp, normalmente la misma dirección que el maestro. El filename es relativo al directorio /diskless (esto se debe a las opciones específicas del servidor tftp que serán explicadas más adelante). Dentro del bloque host, la opción hardware Ethernet especifica la dirección MAC, y fixed-address asigna la dirección IP estática a esa dirección MAC en particular. Hay una muy buena página de manual sobre el archivo dhcpd.conf con varias opciones que están más allá del ámbito de esta Guía. La puedes leer ejecutando:

# man dhcpd.conf

Iniciando el servidor DHCP

Antes de ejecutar el guión de inicialización del servidor dhcp, modifica el archivo /etc/conf.d/dhcp de manera que se parezca a lo siguiente:

IFACE="eth0"
# Inserta cualquier otra opción que necesites

La variable IFACE es el dispositivo en el cual deseas que el servidor DHCP funcione, en nuestro caso es eth0. Añadiendo más argumentos a IFACE puede ser útil en redes de topología compleja y múltiples tarjetas ethernet. Para arrancar el servidor dhcp escribe:

# /etc/init.d/dhcp start

Para añadir el servidor dhcp a tus guiones de inicio escribe:

# rc-update add dhcp default

Solucionando problemas con el servidor DHCP

Para comprobar que un nodo arranca puedes echarle una mirada a /var/log/messages. Si el nodo arranca exitosamente el archivo messages debe tener algunas líneas al final parecidas a estas:

DHCPDISCOVER from 00:00:00:00:00:00 via eth0
DHCPOFFER on 192.168.1.21 to 00:00:00:00:00:00 via eth0
DHCPREQUEST for 192.168.1.21 from 00:00:00:00:00:00 via eth0
DHCPACK on 192.168.1.21 to 00:00:00:00:00:00 via eth0

Si recibes este mensaje, es probable que algo esté mal en el archivo de configuración pero que el servidor DHCP esté transmitiendo correctamente.

no free leases on subnet LOCAL-NET

Cada vez que le hagas un cambio al archivo de configuración, debes reiniciar el servidor DHCP. Para hacerlo, ejecuta:

# /etc/init.d/dhcpd restart

4.  Configurando el servidor TFTP y el cargador de arranque PXE y/o Etherboot

Acerca del servidor TFTP

TFTP son las (en inglés) siglas del Protocolo Trivial de Transferencia de Archivos. El servidor TFTP les va a dar a los esclavos el núcleo y un sistema de archivo inicial. Todos los núcleos esclavos y sistemas de archivos deben estar almacenados en el servidor TFTP, así que es una buena idea hacer que el maestro también sea el servidor TFTP.

Instalando el servidor TFTP

Un servidor tftp altamente recomendado está disponible en el paquete tftp-hpa. Este servidor ha sido escrito por el autor de SYSLINUX y funciona muy bien con pxelinux. Para instalarlo simplemente ejecuta:

# emerge tftp-hpa

Configurando el servidor TFTP

Edita el archivo /etc/conf.d/in.tftpd. Necesitas especificar el directorio tftproot en la variable INTFTPD_PATH y cualquier opción de la linea de comando en INTFTPD_OPTS. Debe parecerse a:

INTFTPD_PATH="/diskless"
INTFTPD_OPTS="-l -v -s ${INTFTPD_PATH}"

La opción -l indica que este servidor escucha en modo stand alone así que no necesita ejecutar inetd. La -v indica que los mensajes de registro/error deben ser mostrados. La -s /diskless especifica el directorio raíz de tu servidor tftp.

Iniciando el servidor TFTP

Para iniciar el servidor tftp ejecuta:

# /etc/init.d/in.tftpd start

Este comando debe iniciar el servidor tftp con las opciones que hemos especificado en /etc/conf.d/in.tftpd. Si quieres que este servidor se inicie automáticamente al momento de arranque del sistema ejecuta:

# rc-update add in.tftpd default

Acerca de PXELINUX

Esta sección no es obligatoria para aquellos que utilizan Etherboot. PXELINUX es el cargador de arranque por red equivalente a LILO y GRUB y será distribuido mediante el TFTP. Es esencialmente un conjunto mínimo de instrucciones que indica al cliente dónde encontrar su núcleo y sistema de archivos inicial y permite varias opciones del núcleo.

Antes de empezar

Necesitas obtener el archivo pxelinux.0 que viene en el paquete SYSLINUX de H. Peter Anvin. Lo puedes instalar ejecutando:

# emerge syslinux

Configurando PXE-LINUX

Antes de arrancar tu servidor tftp necesitas configurar pxelinux. Primero copia el binario de pxelinux en tu directorio /diskless:

# cp /usr/share/syslinux/pxelinux.0 /diskless
# mkdir /diskless/pxelinux.cfg
# touch /diskless/pxelinux.cfg/default

Esto creará el archivo de configuración por defecto del cargador de arranque. El binario pxelinux.0 buscará en el directorio pxelinux.cfgun archivo cuyo nombre sea la dirección IP del cliente en hexadecimal. Si no lo encuentra removerá el dígito más a la derecha del nombre del archivo y volverá a intentar hasta que se quede sin dígitos. Versiones desde la 2.05 y posteriores de syslinux primero ejecutan una busqueda por un archivo cuyo nombre sea la dirección MAC. Si este no es encontrado, ejecuta la rutina ya descrita. Si no lo encuentra, el archivo default es usado.

(Primer número 01 significa ethernet, los demás son la
dirección MAC del esclavo) 
01-00-40-63-c2-ca-c9
(Dirección IP asignada en hexadecimal)
C0A80115
C0A8011
C0A801
C0A80
C0A8
C0A
C0
C
default

Empecemos con el archivo default:

DEFAULT /bzImage
APPEND ip=dhcp root=/dev/nfs nfsroot=192.168.1.1:/diskless/192.168.1.21

La etiqueta DEFAULT le indica a pxelinux dónde está la bzImage del núcleo. La etiqueta APPEND añade las opciones de arranque para el núcleo. Dado que hemos compilado nuestro núcleo con NFS_ROOT_SUPPORT, debemos especificar la dirección raíz del nfs. El primer IP es el IP del maestro y el segundo es el del directorio que fue creado en /diskless para almacenar el sistema de archivos inicial del esclavo.

Acerca de Etherboot

Los inicios mediante Etherboot cargan la imagen para arrancar desde el servidor TFTP. Al igual que PXE, es equivalente a LILO o GRUB. La utilidad mknbi te permite crear distintas imágenes con opciones diferentes.

Antes de empezar

Necesitas obtener el paquete mknbi (utilidad imágenes del núcleo etiquetadas útiles para el arranque por red) para crear tus imágenes Etherboot. Esta utilidad creará una imagen del núcleo pre-configurada de tu núcleo original. Esta contiene las opciones de arranque mostradas más adelante.

# emerge mknbi

Configurando Etherboot

En esta sección crearemos una imagen simple de etherboot. Como el servidor dhcp le indica al cliente la dirección raíz en la opción "option root-path" del dhcp.conf, no necesitamos incluirla aquí. Más detalles en el manual de mknbi.

# man mknbi

Haciendo la imagen de arranque. El siguiente comando creara la imagen ELF de arranque capaz de pasar el dhcp y la dirección del directorio raíz al núcleo. También obliga al núcleo a buscar en la red un servidor dhcp.

# mkelf-linux -ip=dhcp /diskless/bzImage > /diskless/vmlinuz 

Solucionando problemas en el proceso de arranque por red

Hay un par de cosas que tu puedes hacer para corregir errores en el proceso de arranque por red. Para empezar puedes utilizar la herramienta llamada tcpdump. Para instalarla ejecuta:

# emerge tcpdump

Ahora puedes escuchar el tráfico en la red y asegurarte que las interacciones entre cliente/servidor están funcionando. Si algo está mal ahí hay un par de cosas que deberías revisar. Primero asegúrate que el cliente/servidor estén físicamente bien conectados y que los cables no están dañados. Si tu cliente/servidor no están recibiendo pedidos a un puerto específico, comprueba la configuración del Cortafuegos. Para escuchar la interacción entre dos computadores escribe:

# tcpdump host client_ip and server_ip

También puedes utiliza tcpdump para escuchar un puerto en particular como el puerto tftp ejecutando:

# tcpdump port 69

Un error que comunmente se recibe es "PXE-E32: TFTP open time-out". Esto es probablemente por problemas con el cortafuegos. Si estás utilizando TCPwrappers, sería conveniente que revises el etc/hosts.deny y revisar que está configurado bien. Al cliente debe permitirse conectarse al servidor.

5.  Configurando el servidor NFS

Acerca del servidor NFS

NFS son las siglas (en inglés) de Sistema de Archivos en Red. El servidor NFS será utilizado para brindar al esclavo sus directorios. Esta parte puede ser personalizada más tarde, por ahora lo que buscamos es tener el nodo esclavo funcionando sin disco.

Acerca de Portmapper

Varios servicios cliente/servidor no escuchan a un puerto en particular, en cambio utilizan RPCs (llamadas a procedimientos remotos). Cuando un servicio es inicializado, escucha a un puerto al azar y luego registra este puerto en la utilidad Portmapper. NFS utiliza RPCs y por lo tanto requiere tener a Portmapper corriendo para funcionar.

Antes de empezar

El servidor NFS necesita soporte a nivel núcleo así que si no lo incluiste al momento de compilar, debes recompilar el núcleo maestro. Para revisar la configuración de tu núcleo maestro ejecuta:

# grep NFS /usr/src/linux/.config_master

La salida debe ser parecida a la siguiente si es que tu núcleo está configurado correctamente:

CONFIG_PACKET=y
 # CONFIG_PACKET_MMAP is not set
 # CONFIG_NETFILTER is not set
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
 # CONFIG_NFS_V4 is not set
 # CONFIG_NFS_DIRECTIO is not set
CONFIG_NFSD=y
CONFIG_NFSD_V3=y
# CONFIG_NFSD_V4 is not set
# CONFIG_NFSD_TCP is not set

Instalando el servidor NFS

El paquete NFS puede ser instalado mediante el portage escribiendo:

# emerge nfs-utils

Este paquete instalará la utilidad portmapping, el servidor nfs, y las utilidades nfs del cliente y automáticamente manejará la inicialización de las dependencias.

Configurando el servidor NFS

Hay tres archivos de configuración principales que debes editar:

/etc/exports
/diskless/192.168.1.21/etc/fstab
/etc/conf.d/nfs

El archivo /etc/exports especifica como, a quién y qué se debe exportar a través de NFS. El fstab del esclavo debe ser alterado de manera que pueda montar el sistema de archivos NFS que el maestro está exportando.

Típicamente el /etc/exports del maestro debe ser parecido al siguiente:

# una linea como esta por cada esclavo
/diskless/192.168.1.21   192.168.1.21(sync,rw,no_root_squash,no_all_squash)
# común a todos los esclavos
/opt   192.168.1.0/24(sync,ro,no_root_squash,no_all_squash)
/usr   192.168.1.0/24(sync,ro,no_root_squash,no_all_squash)
/home  192.168.1.0/24(sync,rw,no_root_squash,no_all_squash)
# Si deseas tener un registro compartido
/var/log   192.168.1.21(sync,rw,no_root_squash,no_all_squash)

El primer campo indica el directorio que será exportado y el siguiente indica a quién y cómo. Este campo puede dividirse en dos partes: a quién se le debe permitir montar ese directorio en particular, y qué puede hacer el cliente con él: ro de sólo lectura, rw de lectura y escritura; no_root_squash and no_all_squash son importantes para clientes sin disco que escriben en el disco de manera que no sean "apretados" al hacer pedidos de E/S. El archivo fstab del esclavo, /diskless/192.168.1.21/etc/fstab, debe ser similar a este:

# Estas entradas son esenciales
master:/diskless/192.168.1.21   /         nfs     sync,hard,intr,rw,nolock,rsize=8192,wsize=8192    0 0
master:/opt                     /opt      nfs     sync,hard,intr,ro,nolock,rsize=8192,wsize=8192    0 0
master:/usr                     /usr      nfs     sync,hard,intr,ro,nolock,rsize=8192,wsize=8192    0 0
master:/home                    /home     nfs     sync,hard,intr,rw,nolock,rsize=8192,wsize=8192    0 0
none                            /proc     proc    defaults                                     0 0
# Útil pero superfluo
master:/var/log                 /var/log  nfs     hard,intr,rw                                 0 0

En este ejemplo, master es sólo el nombre de anfitrión del maestro pero podría fácilmente ser el IP del maestro. El primer campo indica el directorio a montar y el segundo indica dónde. El tercer campo describe el sistema de archivos y debe ser NFS para cualquier directorio NFS montado. El cuarto campo indica varias opciones que deben ser utilizadas en el proceso de montaje (revisa mount(1) para mayor información acerca de las opciones de montaje). Algunas personas han tenido dificultad con puntos de montaje suaves así que los hemos echo todos duros, pero debes revisar varias opciones para /etc/fstab de manera que hagas tu cluster más eficiente.

El último archivo que debemos modificar es /etc/conf.d/nfs que describe las opciones del nfs cuando es inicializado y es parecido a este:

# Config file for /etc/init.d/nfs
# Number of servers to be started up by default
RPCNFSDCOUNT=8
# Options to pass to rpc.mountd
RPCMOUNTDOPTS=""

Debes cambiar RPCNFSDCOUNT por el número de nodos sin disco en la red.

Arrancando el servidor NFS

Debes iniciar el servidor nfs con su guión de inicio localizado en /etc/init.d ejecutando:

# /etc/init.d/nfs start

Si quieres que este guión se ejecute al momento de iniciarse el sistema simplemente ejecuta:

# rc-update add nfs default

6.  Completando el sistema de archivos del esclavo

Copiando los archivos faltantes

Ahora sincronizaremos el sistema de archivos del esclavo con el del maestro y proveeremos los binarios necesarios, preservando los archivos específicos del esclavo.

# rsync -avz /bin /diskless/192.168.1.21
# rsync -avz /sbin /diskless/192.168.1.21
# rsync -avz /lib /diskless/192.168.1.21

Configurando la red

Para evitar que el guión de inicio de red corte la conección a tu servidor NFS, necesitarás agregar una opción en el archivo /etc/conf.d/net del sistema de archivos de tu cliente sin disco.

(Agrega esta opción a las ya existentes para la interfaz de tu cliente)
config_eth0=( "noop" )

Guiones de inicio

Necesitarás tantos guiones de inicio en /diskless/192.168.1.21/etc/runlevels como servicios tengas en el nodo sin disco. Todo depende de que quieres que tus esclavos hagan.

/diskless/192.168.1.21/etc/runlevels/:
total 16
drwxr-xr-x    2 root     root         4096 2003-11-09 15:27 boot
drwxr-xr-x    2 root     root         4096 2003-10-01 21:10 default
drwxr-xr-x    2 root     root         4096 2003-03-13 19:05 nonetwork
drwxr-xr-x    2 root     root         4096 2003-02-23 12:26 single
 
/diskless/192.168.1.21/etc/runlevels/boot:
total 0
lrwxrwxrwx    1 root     root           20 2003-10-18 17:28 bootmisc -> /etc/init.d/bootmisc
lrwxrwxrwx    1 root     root           19 2003-10-18 17:28 checkfs -> /etc/init.d/checkfs
lrwxrwxrwx    1 root     root           17 2003-10-18 17:28 clock -> /etc/init.d/clock
lrwxrwxrwx    1 root     root           22 2003-10-18 17:28 domainname -> /etc/init.d/domainname
lrwxrwxrwx    1 root     root           20 2003-10-18 17:28 hostname -> /etc/init.d/hostname
lrwxrwxrwx    1 root     root           22 2003-10-18 17:28 localmount -> /etc/init.d/localmount
lrwxrwxrwx    1 root     root           19 2003-10-18 17:28 modules -> /etc/init.d/modules
lrwxrwxrwx    1 root     root           18 2003-10-18 17:28 net.lo -> /etc/init.d/net.lo
lrwxrwxrwx    1 root     root           20 2003-10-18 17:28 netmount -> /etc/init.d/netmount
lrwxrwxrwx    1 root     root           21 2003-10-18 17:28 rmnologin -> /etc/init.d/rmnologin
lrwxrwxrwx    1 root     root           19 2003-10-18 17:28 urandom -> /etc/init.d/urandom
 
/diskless/192.168.1.21/etc/runlevels/default:
total 0
lrwxrwxrwx    1 root     root           23 2003-10-18 17:28 consolefont -> /etc/init.d/consolefont
lrwxrwxrwx    1 root     root           19 2003-10-18 17:28 distccd -> /etc/init.d/distccd
lrwxrwxrwx    1 root     root           19 2003-10-18 17:28 keymaps -> /etc/init.d/keymaps
lrwxrwxrwx    1 root     root           17 2003-10-18 17:28 local -> /etc/init.d/local
lrwxrwxrwx    1 root     root           16 2003-10-18 17:28 sshd -> /etc/init.d/sshd
lrwxrwxrwx    1 root     root           21 2003-10-18 17:28 syslog-ng -> /etc/init.d/syslog-ng
lrwxrwxrwx    1 root     root           17 2003-10-18 17:28 vixie-cron -> /etc/init.d/vixie-cron
 
/diskless/192.168.1.21/etc/runlevels/nonetwork:
total 0
lrwxrwxrwx    1 root     root           17 2003-10-18 17:28 local -> /etc/init.d/local
 
/diskless/192.168.1.21/etc/runlevels/single:
total 0

Ahora es un buen momento para que inicies tus esclavos y cruces los dedos. ¿Funciona? Felicitaciones, eres ahora el orgulloso poseedor de nodo(s) sin disco :)

El contenido de este documento está registrado bajo los términos de la licencia Creative Commons - Reconocimiento / Compartir Igual