Cluster en Linux Ubuntu

¿Qué es un clúster?

De la Wikipedia:Simplemente, clúster es un grupo de múltiples ordenadores unidos mediante una red de alta velocidad, de tal forma que el conjunto es visto como un único ordenador, más potente que los comunes de escritorio. De un cluster se espera que presente combinaciones de los siguientes servicios:

• Alto rendimiento (High Performance)
• Alta disponibilidad (High Availability)
• Equilibrio de carga (Load Balancing)
• Escalabilidad (Scalability)

La construcción de los ordenadores del cluster es más fácil y económica debido a su flexibilidad: pueden tener todos la misma configuración de hardware y sistema operativo (clúster homogéneo), diferente rendimiento pero con arquitecturas y sistemas operativos similares (clúster semi-homogéneo), o tener diferente hardware y sistema operativo (clúster heterogéneo).
Para que un clúster funcione como tal, no basta solo con conectar entre sí los ordenadores, sino que es necesario proveer un sistema de manejo del clúster, el cual se encargue de interactuar con el usuario y los procesos que corren en él para optimizar el funcionamiento.

¿Qué necesito?

• Nodos. Sirven cualquier tipo de máquinas que hasta pueden ser de desecho, y lo más básico que se imaginen, solo requerimos que posean procesador, memoria, tarjeta de red y si de preferencia disco duro. Claro que entre más nodos tengamos más capacidad de cómputo tendremos, pero cuidado con el tipo de máquina que se colocan, no es lo mismo colocar un Pentium I a 100MHz que un CoreDuo a 2GHz, de preferencia usen nodos clónicos o de similar capacidad para que el balanceo de carga sea adecuado.
• Sistema de red. Si bien podemos usar sistemas como fibra óptica o mirynet que son de alta velocidad, el precio se eleva demasiado, actualmente la mayoria de las computadoras soporta e incluye red Ethernet 10/100/1000 y con un switch de cuantos puertos necesitemos basta para la mayoria de las aplicaciones. Existe un desarrollo para activarlas por conexiones Wifi, pero como no las he probado y las velocidades no se comparan, solo trataremos redes físicas.
• Sistema operativo. Por supuesto que Linux pero en cuanto a la distribución a usar tenemos toda una bateria para escoger, es más, se puede transformar su distro favorita en un sistema para súpercomputo instalando los paquetes adecuados, pero por comodidad prefieran las distros que ya incluyen este soporte.
• Aplicaciones de funcionamiento. El manejador de balanceo, sistemas de colas, soporte a MPI/LAM, etc. En las distros que vienen listas para clustering ya las traen preparas para usarse.
• Aplicaciones finales. Pues depende de que uso le van a dar: para renderizar imágenes, cálculos matemáticos, ripear un DVD, codificar a OGG su biblioteca musical, etc. Muchas aplicaciones ya traen soporte para sistemas de clustering o sino tiene toda la libertad de crear las suyas y probar su clúster.

Caso práctico: BlackMamba

Pues en mi caso, se disponian de varias computadoras que se encontraban en almácen debido a una inconsistencia del periodo compra/uso, en específico se habían adquirido 40 computadoras y nadie las usaba, por lo que se solicitaron para que el área de bioinformática las explotara en lugar de llenarse de polvo. En principio nos otorgaron 4 para pruebas.
Las características de las computadoras son (todas son iguales):
• Procesador: 2 Intel Xeon @ 1.6GHz
• Memoria: 2 Gb
• Disco Duro: 150 Gb
• Tarjeta de Red: Ethernet 10/100/1000 y Wifi Atheros
• Tarjeta de video: NVidia QuadroPro 128Mb

Se compró un switch de 24 puertos 10/100 por menos de $1000 pesos, el equivalente con soporte 1000 triplicaba el precio, y los respectivos cables CAT-5.
Deben tomar en cuenta el requerimiento de energía electrica, nosotros sin saberlo montamos el clúster bajo una línea de 30A, pero nuestros ingenieros de mantenimientos nos han llamado la atención porque cada computadora consume aprox. 5A, por lo que solo podemos colocar 6 computadoras por línea independiente. Ya solicitamos más líneas para evitar sobrecargas.
Otra consideración es la energía calorífica generada, nosotros tenemos el área bajo un sistema de clima de alta capacidad, pero el colocar muchas máquinas en un área reducida y sin ventilación puede llegar a calentar al punto de fundir los CPUs, memorias y discos duros, lo óptimo es que su cuarto ya en funcionamiento no sobre pase la temperatura ambiente.
Nuestro esquema fue el de un nodo maestro y el resto como esclavos. Al nodo maestro se le colocó una segunda tarjeta PCI de red con el fin de que por la eth0 se comunica el clúster y por eth1 a nuestra intranet/internet. Salvo ese anexo no se modificó nada más, pero en los nodos maestros es buen consejo ampliar la memoria y el disco duro lo más que se pueda. Para solventar un poco el espacio en disco duro se nos presto un NAS Iomega de 1 Tb (sí, usamos muchos datos muy grandes) que accedemos vía red.
Una vez armado para probar la eficiencia y darle números con el fin de solicitar aumentar los nodos, se probó con ParallelKnoppix.

ParallelKnoppix

ParallelKnoppix como su nombre indica es una distro LiveCD basada en Knoppix, basada a su vez en Debian, que viene preparada para armar un clúster de forma rápida y sin tantos dolores de cabeza. Su uso es exageradamente sencilla y muy poderosa, basta con arrancar el nodo maestro con el CD, levantar los servicios mediante un sistema gráfico de configuración y levantar los nodos y ¡listo!, más sencillo no se puede.
Los pasos es mejor que los consulten en la documentación en el tutorial incluido, dado que son muy fáciles no me parece que deba repetirlos, las preguntas que les hacen son para levantar un servidor DHCP, generar llaves de acceso, crear una imagen para arrancar por red y demás servicios. Una vez configurado el maestro y cuando el sistema lo pida, arrancamos los nodos esclavos usando arranque por red. Ya tenemos un clúster funcionando al 100%.
Las pruebas que hicimos fue compara un grupo de secuencias contra una base de datos, dicho proceso en una computadora con 1 procesador y 1Gb de RAM tardó casi 26 hrs., pero usando 4 nodos (8 procesadores) solo tardamos como 4 Hrs. Esa fue la pauta para que nos dieran 7 nodos más y se autorizaran otros 10 en cuanto las instalaciones eléctricas lo permitan.
Pero no nos quedamos con ParallelKnoppix, dado que es un sistema diseñado para ser temporal y no fijo, si bien se puede instalar al disco duro, el sistema presenta mucho trabajo para configurar tal y como estaba en el LiveCD, por lo que buscamos opciones más estables y prometedoras y despues de probar un par nos quedamos con ROCKS, del cual les hablaré en la siguiente parte.

Está es la segunda parte del montaje y uso de un clúster basado en Linux. En está ocasión se tratará sobre los detalles de la instalación de un sistema homogéneo completo con ROCKS. Una disculpa a quienes han estado ansiosos con esta continuación, ya que no había tenido tiempo de preparala.
Continúa ...
Actualizado con fotos ....

Para recordar en que nos quedamos respecto al artículo anterior, ya contamos con los equipos y se había armado una red pequeña donde el nodo maestro posee 2 tarjetas de red, con la eth0 se comunica con los nodos a través de un switch de 24 puertos 10/100, y con la eth1 se comunica con la intranet/internet.

Primero veamos porque se escogió a ROCKS como distribución, dado que tenía varias alternativas como Beowulf, Oscar, Mosix, etc.

Basado en CentOS, que está basado en el archi-reconocido RedHat, esto a mi me dio confianza y ya tengo experiencia previa con estos sistemas mediante Fedora.

La configuración y administración esta montada en bases de datos en MySQL.

Sistema integral que incluye todo lo necesario para instalar e usar de inmediato.

Sistema de módulos de expansión con aplicaciones especificas, en mi caso, uno específico para bioinformática ya listo con muchos programas de uso estándar.

Sistema de monitoreo y mantenimiento incluido y automatizado.

Muchas herramientas de desarrollo incluidas y especificas de súper-cómputo.

Totalmente escalable a nivel de equipo.

Todas las ventajas de la GPL/GNU.

Requerimientos mínimos:

Procesador x86, x86_64, IA-64

Redes: Ethernet, Myrinet, Infiniband

Disco duro: 20 GB

Memoria RAM: 640 MB

Paso 1. Obtener la distribución.
En la sección de Downloads podemos descargar la imágenes ISO necesarias, ahí están catalogadas de acuerdo a la arquitectura del procesador, descarguen las correspondientes y verifiquen las MD5 antes de grabar los discos.
Los discos requeridos son:

Kernel/Boot Roll (el de arranque)

Core Roll (sistema base)

Service Pack Roll (actualizaciones de seguridad)

OS Roll Disc 1 (sistema operativo)

OS Roll Disc 2 (sistema operativo)
Los opcionales que son para ampliar su clúster:

APBS (Adaptive Poisson-Boltzmann Solver)

area51 (System security related services and utilites)

bio (Bioinformatics utilities)

condor (High throughput computing tools)

ganglia (cluster monitoring system from UCB)*

grid (Globus 4.0.2 GT4)*

java (Sun Java SDK and JVM)*

pbs (Portable Batch System)*

pvfs2 (PVFS2 File System)

sge (Sun Grid Engine job queueing system)*

silverstorm-qlogic-ib (SilverStorm-Qlogic IB Roll)

topspin-ib (Topspin’s IB stack packaged by cluster Corp.)

viz (Support for building visualization clusters)

voltaire-ib (InfiniBand support for Voltaire’s IB hardware)
* ya viene incluido en el Core Roll.
En mi caso solo descargue los requeridos más el bio.

Paso 2. Instalar el nodo maestro.
Coloque el disco Kernel/Boot Roll y arranque su computador, en cuanto tenga la pantalla con boot: escriba
frontend
En cuanto termina el arranque se dan de alta los discos con los que se cuenta, simplemente presionen el botón de CD/DVD-based Roll e inserten uno a uno los discos.
También es posible instalar vía red, pero solo es recomendable si tienen banda ancha, ya que van a descargar al menos los discos base.
Después se les pide información sobre el clúster, cosas típicas, por ejemplo el nuestro quedo así:

Fully-Qualified Host Name: blackmamba.ira.cinvestav.mx

cluster Name: blackmamba

Certificate Organization: Cinvestav

Certificate Locality: Irapuato

Certificate State: Guanajuato

Certificate Country: MX

Contact: ******@ira.cinvestav.mx

URL: http://blackmamba.ira.cinvestav.mx/

Latitude/Longitude: N20.40/W101.20
Salvo que su clúster tenga salida directa a internet, las direcciones de Host Name y URL pueden no ser válidas.
En seguida se da de alta la red, obligadamente eth0 es la que se comunica con los nodos esclavos, y eth1 con el exterior. Tengan cuidado de no causar colisiones en su red o colocar invertidas las tarjetas, además la IP pública de preferencia que sea estática. En esos casos pueden modificar las opciones que vienen por defecto y adecuarlos a su red.
Los demás datos son sobre la contraseña de administrador (root) y la zona horaria, el particionamiento que puede usarse automático, coloca así las particiones:

/ 8 GB

/var 4 GB

swap 1 GB

/export el resto del disco
Pueden adecuar un poco más esta distribución, en mi caso como el disco duro es de 150 GB, opte por no moverle.

Paso 3. Instalar los nodos esclavos
Ingresen al nodo maestro como root e invoquen:
insert-ethers
Aquí seleccionen "Compute" y esperen al modo de escucha.
Para facilitarse la vida, usen el arranque vía red en todos sus nodos esclavos, aunque esto solo es válido si es un clúster homogéneo. Si no lo es, inserten el disco de Kernel/Boot adecuado para cada nodo y no le den parámetros de arranque. Ahora enciendan uno a uno los nodos esclavos, dando tiempo al sistema de detectarlos, cuidado que pueden sobrecargar al maestro o al switch, ya que en este punto cada nodo arranca y descarga una imagen preparada por el maestro.
Uno a uno los nodos son detectados e instalados, ya no hace falta hacer nada, automágicamente se instalan y se dan de alta.

Paso 4. Dar de alta usuarios
Basta con como administrador hacer:
useradd usuario
rocks-user-sync
passwd usuario


Paso 5. Personalizar aplicaciones En general la mayoría de las aplicaciones son exportadas a todos lo nodos, pero la carpeta /export que es donde esta realmente /home se migra a todos lo nodos, en mi caso mis usuarios usan los programas del paquete bio y este esta migrado en /export/bio, pero pueden hacer que sus programas migren fácilmente ubicándolos en una carpeta en su HOME, por ejemplo ~/mybin y añadirla a su PATH, o crear una carpeta especial para eso.

Para probar pueden consultar sus nodos con:
cluster-fork hostname
El monitoreo pueden acceder por SSH y se ha montado un servidor web donde pueden ver la actividad con Ganglia, consultar la documentación o modificar la base de datos con PHPAdmin, e incluso generar una plantilla de etiquetas para cada nodo y así rápidamente identificarlos.
Para apagar el sistema deben apagar primero los nodos esclavos y luego el maestro, la forma fácil es como root:
cluster-fork shutdown -h now (esperar unos minutos a que todos se apaguen)
shutdown -h now
El arranque es primero el nodo maestro, esperar a que termine y luego uno a uno los esclavos.
Finalmente pueden probar aplicaciones ya preparadas para clusterización con MPI o MPICH, o usar procesos distribuidos con el SGE. En la tercera y última parte veremos la programación básica con MPI y uso del sistema de colas de trabajo.

Lo prometido es deuda y le traigo la tercera entrega de mi serie de artículos sobre clustering en Linux, es específico un clúster que acabo de armar ahora usando Ubuntu como sistema base. Por la extensión de este tema lo voy a tener que partir en 2, primero les traigo la instalación y configuración del nodo maestro y en la segunda parte veremos la de los nodos esclavos.
En el pasado artículo comenté que este iba a tratar sobre el uso general de la cola de trabajo y un poco de programación en MPI con "hola mundo" pero en paralelo, pero se me hace más interesante narrar esta experiencia dado que lo otro fácilmente lo pueden hacer leyendo los manuales y guías.
Muchas gracias a las personas interesadas en esta serie de artículos por su comentarios.
English version here: http://linxe-eye.blogspot.com/2008/04/ubuntu-cluster-master-node.html

Antecedentes
En esta ocasión mi Instituto (Cinvestav - www.ira.cinvestav.mx) me pidió una solución fija y similar a la anterior montada con ROCKS, esta serviria como un pequeño clúster general y como laboratorio de enseñanza para bioinformática. Este clúster fue bautizado como Beagle, el Instituto puso los equipos y con ayuda de mi buen amigo LuisD pusimos la mano de obra. El diseño incluye un nodo maestro que sirve de acceso, monitoreo y envió de trabajos, y 10 nodos esclavos que hará la parte de cómputo mediante exportación de /home por NFS, una cola de trabajos con SGE (Sun Grid Engine), Ganglia como monitor de los sistemas y soporte para MPI.
El sistema base de inicio fue el mismo ROCKS, pero lamentablemente tuvimos problemas de compatibilidad y no nos fue posible usarlo, y aunque no me gusta mucho Ubuntu, pues ese fue la elección ya que era totalmente compatible y disponíamos de algunos tutoriales y guías para clústers con Debian.

Hardware

Nodo Maestro: AMD Athlon 64 X2 4200+, 2 Gb RAM, 1 dd IDE 80 Gb (hda), 1 dd SATA 320 Gb (sda), 1 dd externo USB 1 Tb (sdb), tarjeta de red nForce 10/100/1000 (eth1), tarjeta de red PCI Realtek 10/100 (eth2).

Nodos Esclavos X10: AMD Athlon 64 X2 4200+, 2 Gb RAM, 1 dd IDE 80 Gb, tarjeta de red nForce 10/100/1000 (eth0).

Switch: 24 puertos 10/100/1000.

Muchos metros de cable de red.

Instalación del Nodo Maestro
Tenemos una arquitectura amd64, por lo que usamos Ubuntu Desktop para amd64, descargamos la ISO, la quemamos e instalamos con las siguientes particularidades:

Sistema de archivos: ext3.

Particiones (partición:tamaño:punto_montaje):

  hda1 : 180 Mb : /boot
 hda2 : 2.0 Gb : swap
 hda4 : 24  Gb : /
 hda5 : 4.6 Gb : /tftpboot
 hda6 : 22  Gb : /var
 hda7 : 22  Gb : /usr
 sda1 : 2.0 Gb : swap
 sda2 : 292 Gb : /home

Cuenta general: beagle.

La red es configurada así: eth1 197.1.1.1 (comunicación con los nodos), eth2 10.0.0.114 (comunicación hacia el exterior a través de nuestra intranet).
Terminamos la instalación, reiniciamos, accesamos y con una terminal nos pasamos a ser root y dar una contraseña:

sudo su -
passwd

DHCP
Un servidor DHCP se monto para comunicar con los nodos:

apt-get install dhcp3-server

Editamos /etc/dhcp3/dhcpd.conf para dar de alta la red 197.1.1.0/24 y agregar las MACs de cada nodo, incluyendo el nombre de host y el cargador de arranque por red (PXE). Nuestro archivo quedo:

# dhcp.conf
# Network for the Beagle cluster
# Juan Caballero @ Cinvestav 2008
ddns-update-style none;
subnet 197.0.0.0 netmask 255.0.0.0 {
     default-lease-time 1200;
     max-lease-time 1200;
     option routers 197.1.1.1;
     option subnet-mask 255.0.0.0;
     option domain-name "local";
     option domain-name-servers 197.1.1.1;
     option nis-domain "beagle";
     option broadcast-address 197.255.255.255;
     deny unknown-clients;
     allow booting;
     allow bootp;
     if (substring (option vendor-class-identifier, 0, 20)
                     = "PXEClient:Arch:00002") {
             # ia64
             filename "elilo.efi";
             next-server 197.1.1.1;
     } elsif ((substring (option vendor-class-identifier, 0, 9)
                     = "PXEClient") or
             (substring (option vendor-class-identifier, 0, 9)
                     = "Etherboot")) {
             # i386 and x86_64
             filename "pxelinux.0";
             next-server 197.1.1.1;
     } else {
             filename "/install/sbin/kickstart.cgi";
             next-server 197.1.1.1;
     }

     host beagle.local {
             hardware ethernet 00:e0:7d:b4:e1:13;
             option host-name "beagle.local";
             fixed-address 197.1.1.1;
     }
     host node00.local {
             hardware ethernet 00:1b:b9:e2:0d:18;
             option host-name "node00.local";
             fixed-address 197.1.1.100;
     }
     host node01.local {
             hardware ethernet 00:1b:b9:e1:cf:6a;
             option host-name "node01.local";
             fixed-address 197.1.1.101;
     }
     host node02.local {
             hardware ethernet 00:1b:b9:e1:be:6e;
             option host-name "node02.local";
             fixed-address 197.1.1.102;
     }
     host node03.local {
             hardware ethernet 00:1b:b9:cf:f3:55;
             option host-name "node03.local";
             fixed-address 197.1.1.103;
     }
     host node04.local {
             hardware ethernet 00:1b:b9:e2:14:06;
             option host-name "node04.local";
             fixed-address 197.1.1.104;
     }
     host node05.local {
             hardware ethernet 00:1b:b9:ce:85:9a;
             option host-name "node05.local";
             fixed-address 197.1.1.105;
     }
     host node06.local {
             hardware ethernet 00:1b:b9:e2:0c:5f;
             option host-name "node06.local";
             fixed-address 197.1.1.106;
     }
     host node07.local {
             hardware ethernet 00:1b:b9:cf:f7:29;
             option host-name "node07.local";
             fixed-address 197.1.1.107;
     }
     host node08.local {
             hardware ethernet 00:1b:b9:cf:f3:25;
             option host-name "node08.local";
             fixed-address 197.1.1.108;
     }
     host node09.local {
             hardware ethernet 00:1b:b9:e2:14:9f;
             option host-name "node09.local";
             fixed-address 197.1.1.109;
     }
}

En el archivo /etc/defaults/dhcp3-server especificamos la tarjeta por la cual se activa DHCP

Interfaces="eth1"

Y reiniciamos el servicio:

/etc/init.d/dhcp3-server restart

Más ajustes de red
Editamos /etc/hosts para incluir todos los nodos, así:

127.0.0.1       localhost
197.1.1.1       beagle.local    beagle
197.1.1.100     node00.local    node00
197.1.1.101     node01.local    node01
197.1.1.102     node02.local    node02
197.1.1.103     node03.local    node03
197.1.1.104     node04.local    node04
197.1.1.105     node05.local    node05
197.1.1.106     node06.local    node06
197.1.1.107     node07.local    node07
197.1.1.108     node08.local    node08
197.1.1.109     node09.local    node09

También se creo un archivo de texto en /etc/machines con los nombres de todos los esclavos para usarse posteriormente en scripts:

node00
node01
node02
node03
node04
node05
node06
node07
node08
node09

NFS
Instalamos los paquetes:

apt-get nfs-common nfs-kernel-server

Editamos /etc/exports para exportar /home y /tftpboot:

/home 197.1.1.0/24(rw,no_root_squash,sync,no_subtree_check)
/tftpboot 197.1.1.0/24(rw,no_root_squash,sync,no_subtree_check)

E iniciamos el servicio:

exportfs -av

Arranque con PXE
Instalamos tftpd-hpa:

apt-get install tfptd-hpa

Editamos /etc/defaults/tfptd-hpa:

#Defaults for tftpd-hpa
RUN_DAEMON="yes"
OPTIONS="-l -s /tftpboot"

Descargamos el netboot para Ubuntu amd64:

cd /tftpboot
wget http://tezcatl.fciencias.unam.mx/ubuntu/dists/gutsy/main/installer-amd64/current/images/netboot/netboot.tar.gz
tar zxvf netboot.tar.gz

Reiniciamos el servicio:

/etc/init.d/tftpd-hpa restart

SGE
Para SGE agregamos un usuario sgeadmin, descargamos los archivos y corremos el script de instalación, muchas opciones se toman por defecto:

adduser sgemaster
wget http://gridengine.sunsource.net/download/SGE61/ge-6.1u3-common.tar.gz
wget http://gridengine.sunsource.net/download/SGE61/ge-6.1u3-bin-lx24-amd64.tar.gz
tar zxvf ge-6.1u3-common.tar.gz
tar zxvf ge-6.1u3-bin-lx24-amd64.tar.gz
./install-qmaster

Servidor Web
Instalamos Apache:

apt-get install apache2

Ganglia monitor
Primero instalamos las dependencias, descargamos las fuentes y compilamos para tener la versión web:

apt-get install rrdtool librrds-perl librrd2-dev php5-gd
wget http://downloads.sourceforge.net/ganglia/ganglia-3.0.7.tar.gz?modtime=1204128965&big_mirror=0
tar zxvf ganglia*
cd ganglia*
./configure --with-gmetad
make
mkdir /var/www/ganglia

Esta es la segunda parte del montaje de un clúster con Linux Ubuntu, ahora veremos la instalación y configuración de los nodos esclavos.

English version: http://linxe-eye.blogspot.com/2008/04/ubuntu-cluster-slave-nodes.html

En el nodo maestro hemos configurado un servidor DHCP que servirá para asignar las IP, nombre de host y pasar un sistema de arranque por red mediante PXE. Por lo que ahora solo necesitamos conectar el nodo, agregarle un teclado y monitor y encenderlo, activando el arranque por red en el BIOS, e instalar el sistema base.

Para el particionamiento usamos la opción por defecto de usar todo el disco duro como una sola partición y el swap que asigna, creamos la cuenta general de acceso (beagle) y al finalizar y reiniciar, entramos y en una terminal cambiamos a root, cambiamos su contraseña e instalamos el servidor SSH:

sudo su - passwd apt-get install openssh-server Repetimos este proceso para todos los nodos y los siguientes pasos se pueden realizar desde el nodo maestro.

Acceso automático con SSH
Necesitamos crear un par de llaves para cada usuario y así puedan acceder a cualquier nodo sin contraseña, primero creamos la del usuario general:

ssh-keygen cp .ssh/id_pub .ssh/authorized_keys Root también requiere de sus propias llaves de acceso, pero como no exportamos su HOME, necesitamos copiarlas a cada unos de los nodos con rcp. Este paso va a solicitar varias veces la contraseña, pero será única vez que lo hagamos. su - ssh-keygen cp .ssh/id_pub .ssh/authorized_keys for NODE in `cat /etc/machines` do rsh $NODE mkdir .ssh rcp .ssh/authorized_keys $NODE:.ssh/authorized_keys done En los siguientes pasos se requiere que se acceda a cada nodo como root.

Exportando HOMENos conectamos al nodo, instalamos el paquete NFS, editamos /etc/fstab para montar /home desde el nodo maestro, borramos el contenido del viejo HOME y montamos:

ssh nodeXX apt-get install nfs-common echo "197.1.1.1:/home /home nfs defaults,auto 0 0" >> /etc/fstab rm -rf /home/* mount -a

Ajustes de hosts Editamos /etc/hosts para incluir todos los nodos, agregamos:

197.1.1.1 beagle.local beagle 197.1.1.100 node00.local node00 197.1.1.101 node01.local node01 197.1.1.102 node02.local node02 197.1.1.103 node03.local node03 197.1.1.104 node04.local node04 197.1.1.105 node05.local node05 197.1.1.106 node06.local node06 197.1.1.107 node07.local node07 197.1.1.108 node08.local node08 197.1.1.109 node09.local node09

Instalar SGE
Los archivos necesario son exportados en /home/sgeadmin, primero añadimos las dependencias, agregamos el usuaro sgeadmin e instalamos el cliente:

apt-get install binutils adduser sgeadmin /home/sgeadmin/install_execd Nota: Hay que revisar que los valores de UID y GID coincidan en /etc/passwd y /etc/groups, debes er el mismo en todos los nodos y el maestro.

Administrando los nodos
Muchas tareas administrativas son iguales para cada nodo, por lo que usamos un script (/sbin/cluster-fork) para que lo ejecute en cada nodo:

#!/bin/bash # cluster-fork COMMANDS # Script to execute COMMANDS in all nodes in /etc/machines # Juan Caballero @ Cinvestav 2008 for NODE in `cat /etc/machines` do echo $NODE: rsh $NODE $* done Ahora podemos ejecitar el mismo comando sin problemas, pero es recomendable ejecutarlos con las opciones no interactivas, por ejemplo para actualizar todos los nodos: cluster-fork apt-get -y update cluster-fork apt-get -y upgrade O para instalar ganglia y soporte MPI: cluster-fork apt-get -y install ganglia-monitor lam-runtime mpich-bin openmpi-bin

Add users in the cluster
El HOME de todo usuario agregado en el nodo maestro será exportado a los otros nodos, podemos usar adduser en cada nodo para darlo de alta pero hay que tener cuidado de tener el mismo UID y GID y no crear un /home, de ser necesario se debe editar los archivos /etc/passwd y /etc/groups, también no olvidar crearle sus propias llaves de acceso automático.

Finalmente ya tenemos un clúster HPC corriendo en Linux Ubuntu, pero muchos pasos pueden ser fácilmente adaptados a su distro preferida. Ahora vamos a probar un poco el desempeño del equipo y probablemente después coloquemos algunas fotos. También cualquier comentario o sugerencia son bienvenidos.

cp web/* /var/www/ganglia

Editamos la configuración de Apache para acceso a ganglia en /etc/apache2/sites-enabled/000-default
Ahora instalamos lo paquetes ya compilados (cuidado con las versiones que se instaló desde fuente y estas):

apt-get install ganglia-monitor gmetad

Se puede editar los archivos /etc/gmond.conf y /etc/gmetad.conf para personalizar la configuración.

Otros programas
Usamos apt-get o paquetes compilados, en nuestro caso por ejemplo agregamos un servidor SSH, los compiladores básicos y soporte para MPI:

apt-get install openssh-server gcc g++ g77 mpich-bin openmpi-bin lam-runtime

En la siguiente parte instalaremos y configuraremos los nodos esclavos.

Enlaces:

Ubuntu http://www.ubuntu.com/

Debian clusters http://debianclusters.cs.uni.edu/index.php/Main_Page

SGE http://gridengine.sunsource.net/

Ganglia http://ganglia.info/

NFS http://nfs.sourceforge.net/

TFTP-HPA http://freshmeat.net/projects/tftp-hpa/

DHCP http://www.dhcp.org/

MPICH http://www-unix.mcs.anl.gov/mpi/mpich1/

OpenMPI http://www.open-mpi.org/

LAM/MPI http://www.lam-mpi.org/