Tag Archives: cluster

Almacenamiento Distribuido Sobre Cuatro Nodos con GlusterFS 3.5 y CentOS 6.5

Hoy vamos a construir un clúster de almacenamiento con GlusterFS y CentOS utilizando cuatro nodos para ficheros y datos de usuarios. El tamaño de la compartición será la suma de lo que aporte cada nodo individualmente. GlusterFS es un sistema de ficheros clusterizado capaz de escalar hasta varios peta-bytes.

Vamos a necesitar cuatro máquinas para los servidores y una que hará de cliente. Todas con CentOS. Todas deben resolver el nombre de las demás, si no es posible hacerlo mediante DNS utilizamos el fichero /etc/hosts de la siguiente manera.

192.168.1.100   server1.example.com     server1
192.168.1.101   server2.example.com     server2
192.168.1.102   server3.example.com     server3
192.168.1.103   server4.example.com     server4
192.168.1.104   client1.example.com     client1

Antes de empezar vamos a desabilitar SELinux y, como estamos dentro de la red local, el firewall.

Para deshabilitar SELinux editamos el fichero /etc/sysconfig/selinux y cambiamos la siguiente línea.

[...]
SELINUX=disabled
[...]

Para deshabilitar el cortafuegos simplemente lo quitamos del autoarranque.

# chkconfig iptables off
# chkconfig ip6tables off

Comenzamos instalando GlusterFS en los nodos

Instalando GlusterFS en los nodos

Habilitando el repositorio

Tenemos que crear un nuevo fichero de repositorio dentro de /etc/yum.repos.d con nombre glusterfs.repo

# vim /etc/yum.repos.d/glusterfs.repo

Añadimos

[glusterfs-epel]
name=GlusterFS is a clustered file-system capable of scaling to several petabytes.
baseurl=http://download.gluster.org/pub/gluster/glusterfs/LATEST/EPEL.repo/epel-$releasever/$basearch/
enabled=1
skip_if_unavailable=1
gpgcheck=1
gpgkey=http://download.gluster.org/pub/gluster/glusterfs/LATEST/EPEL.repo/pub.key

[glusterfs-noarch-epel]
name=GlusterFS is a clustered file-system capable of scaling to several petabytes.
baseurl=http://download.gluster.org/pub/gluster/glusterfs/LATEST/EPEL.repo/epel-$releasever/noarch
enabled=1
skip_if_unavailable=1
gpgcheck=1
gpgkey=http://download.gluster.org/pub/gluster/glusterfs/LATEST/EPEL.repo/pub.key

[glusterfs-source-epel]
name=GlusterFS is a clustered file-system capable of scaling to several petabytes. - Source
baseurl=http://download.gluster.org/pub/gluster/glusterfs/LATEST/EPEL.repo/epel-$releasever/SRPMS
enabled=0
skip_if_unavailable=1
gpgcheck=1
gpgkey=http://download.gluster.org/pub/gluster/glusterfs/LATEST/EPEL.repo/pub.key

Añadir la firma

A continuación se añade la firma del repositorio al depósito de claves

# yum --import http://download.gluster.org/pub/gluster/glusterfs/LATEST/EPEL.repo/pub.key

Ya podemos usar el gestor de paquetes para instalar el software

Instalando el servidor GlusterFS

Desde la terminal instalamos los paquetes necesarios

# yum install glusterfs-server

Una vez ha terminado de instalar paquetes podemos comprobar que está correcto escribiendo.

# glusterfsd --version

Debemos ver lo siguiente.

glusterfs 3.5.1 built on Jun 24 2014 15:09:28
Repository revision: git://git.gluster.com/glusterfs.git
Copyright (c) 2006-2013 Red Hat, Inc. 
GlusterFS comes with ABSOLUTELY NO WARRANTY.
It is licensed to you under your choice of the GNU Lesser
General Public License, version 3 or any later version (LGPLv3
or later), or the GNU General Public License, version 2 (GPLv2),
in all cases as published by the Free Software Foundation.

Antes de continuar debemos arrancar el demonio haciendo lo siguiente.

# /etc/init.d/glusterd start

Dejamos el servicio habilitado para el próximo reinicio

# chkconfig glusterd on

Seguimos con la configuración.

Creando la compartición

Ya tenemos el servidor instalado, vamos a configurara una compartición. Los siguientes pasos sólo los haremos en server1 ya que la configuración se replica entre los nodos que conforman el cluster. Primero debemos crear el pool de almacenamiento. Desde la consola del primer servidor escribimos.

# gluster peer probe server2.example.com
Probe successful
# gluster peer probe server3.example.com
Probe successful
# gluster peer probe server4.example.com
Probe successful

Podemos comprobar que se ha construido satisfactoriamente.

# gluster peer status
Number of Peers: 3

Hostname: server2.example.com
Uuid: da79c994-eaf1-4c1c-a136-f8b273fb0c98
State: Peer in Cluster (Connected)

Hostname: server3.example.com
Uuid: 3e79bd9f-a4d5-4373-88e1-40f12861dcdd
State: Peer in Cluster (Connected)

Hostname: server4.example.com
Uuid: c6215943-00f3-492f-9b69-3aa534c1d8f3
State: Peer in Cluster (Connected)

Ahora creamos la compartición distribuida que llamaremos testvol. Seguimos en server1

# gluster volume create testvol stripe 4 transport tcp server1.example.com:/data server2.example.com:/data server3.example.com:/data server4.example.com:/data force
Creation of volume testvol has been successful. Please start the volume to access data.

Añadimos el parámetro force si el directorio que comparten los nodos está en la raiz del sistema de ficheros.

Iniciamos el volumen

# gluster volume start testvol
Starting volume testvol has been unsuccessful

Si comprobamos las conexiones veremos como está levantado el servicio.

# netstat -tap | grep glusterfs
tcp        0      0 *:24009                 *:*                     LISTEN      1110/glusterfsd
tcp        0      0 localhost.localdom:1019 localhost.localdo:24007 ESTABLISHED 1110/glusterfsd

Vamos a añadir una capa de seguridad permitiendo conexiones unicamente desde nuestra red local, para ello hacemos.

# gluster volume set testvol auth.allow 192.168.1.*

Y ahora si comprobamos el estado del volumen.

# gluster volume info

Volume Name: testvol
Type: Stripe
Volume ID: f922da05-737d-4fb5-83cc-e50d6782b90c
Status: Started
Number of Bricks: 1 x 4 = 4
Transport-type: tcp
Bricks:
Brick1: server1.example.com:/data
Brick2: server2.example.com:/data
Brick3: server3.example.com:/data
Brick4: server4.example.com:/data
Options Reconfigured:
auth.allow: 192.168.1.*

Configuración de los clientes

Estos pasos debemos llevarlos a cabo por cada cliente que queramos que pueda montar la compartición. Empezamos instalando el cliente de GlusterFS.

Hay que habilitar el repositorio como hicimos con los servidores.

# yum install glusterfs-client

Creamos un punto de montaje para la compartición.

# mkdir /mnt/glusterfs

Montamos.

mount.glusterfs server1.example.com:/testvol /mnt/glusterfs

Podemos ver que está montado haciendo.

# mount 

/dev/mapper/VolGroup-lv_root on / type ext4 (rw)
proc on /proc type proc (rw)
sysfs on /sys type sysfs (rw)
devpts on /dev/pts type devpts (rw,gid=5,mode=620)
tmpfs on /dev/shm type tmpfs (rw)
/dev/sda1 on /boot type ext4 (rw)
none on /proc/sys/fs/binfmt_misc type binfmt_misc (rw)
server1.example.com:/testvol on /mnt/glusterfs type fuse.glusterfs (rw,default_permissions,allow_other,max_read=131072)

También

# df -hT

Filesystem                   Type            Size  Used Avail Use% Mounted on
/dev/mapper/VolGroup-lv_root ext4            6,7G  796M  5,5G  13% /
tmpfs                        tmpfs           250M     0  250M   0% /dev/shm
/dev/sda1                    ext4            485M   31M  429M   7% /boot
server1.example.com:/testvol fuse.glusterfs   20G  2,4G   17G  13% /mnt/glusterfs

Hacemos los cambios permanentes añadiendo la siguiente línea al fichero /etc/fstab

server1.example.com:/testvol /mnt/glusterfs glusterfs defaults,_netdev 0 0

Fuente

He seguido los pasos de este artículo para adaptarlo a CentOS y la última versión de GlusterFS

Cluster de Almacenamiento con GlusterFS 3 y CentOS 5.6

En el artículo de hoy vamos a montar un cluster de almacenamiento con dos servidores CentOS. Para la implementación del cluster vamos a usar GlusterFS, que es un sistema de ficheros en espacio de usuarios (FUSE). Sigue la arquitectura clásica de cliente-servidor y puede escalar hasta varios PetaBytes.

Introducción.

Para este tutorial vamos a utilizar dos servidores:

  • server1 192.168.2.100
  • server2 192.168.2.101

Y un cliente:

  • client1 192.168.2.102

Todos los componentes deben poder resolver los nombres de los demás, si no se puede por DNS debes editar el fichero /etc/hosts:

# /etc/hosts
192.168.2.100   server1
192.168.2.101   server2
192.168.2.102   client1

Configuración de los servidores.

Antes de empezar con GlusterFS, vamos a preparar el sistema añadiendo las herramientas de desarrollo y librerías. En cada uno de los servidores ejecutamos:

# yum groupinstall 'Development Tools'
# yum groupinstall 'Development Libraries'
# yum install libibverbs-devel fuse-devel

Descargamos el software y lo compilamos:

# mkdir sandbox
# cd sandbox
# wget http://download.gluster.com/pub/gluster/glusterfs/3.0/LATEST/glusterfs-3.0.8.tar.gz
# tar zxvf glusterfs-3.0.8.tar.gz
# cd glusterfs-3.0.8
# ./configure

Al finalizar deberemos ver esto:

GlusterFS configure summary
===========================
FUSE client        : yes
Infiniband verbs   : yes
epoll IO multiplex : yes
libglusterfsclient : yes
argp-standalone    : no
fusermount         : no

Entonces compilamos e instalamos.

# make && make install

Enlazamos con las librerías dinámicas.

# ldconfig

Podemos ahora comprobar que se ha instalado correctamente.

# glusterfs --version

glusterfs 3.0.8 built on May 13 2011 20:20:55
Repository revision: v3.0.8
Copyright (c) 2006-2009 Gluster Inc. 
GlusterFS comes with ABSOLUTELY NO WARRANTY.
You may redistribute copies of GlusterFS under the terms of the GNU General Public License.

Vamos ahora a crear una estructura de directorio desde el que exportar el volumen. En este tutorial queremos compartir /home por lo que vamos a montar una porción de disco sobre el directorio que exportamos con Gluster para más adelante montar en el cliente en /home.

Creamos los siguientes directorios.

# mkdir -p /data/{exports,export-ns} /etc/glusterfs

En /etc/glusterfs/glusterfsd.vol añadimos el fichero de configuración para nuestro volumen.

volume posix
  type storage/posix
  option directory /data/exports
end-volume

volume locks
  type features/locks
  subvolumes posix
end-volume

volume brick
  type performance/io-threads
  option thread-count 8
  subvolumes locks
end-volume

volume server
  type protocol/server
  option transport-type tcp/server
  option auth.addr.brick.allow 192.168.2.*
  subvolumes brick
end-volume

Para aumentar la seguridad, sólo se permiten las direcciones listadas en la línea option auth.addr.brick.allow, admite comodines y varias direcciones separadas por comas. En este ejemplo hemos dado acceso a todo el rango 192.168.2.0/24.

Como hemos compilado sin pasar ninguna opción previa al configure, vamos a crear un enlace simbólico para que el sistema encuentre el binario.

# ln -s /usr/local/sbin/glusterfsd /sbin/glusterfsd

Ya podemos arrancar el demonio y configurar su nivel de arranque.

# chkconfig --levels 35 glusterfsd on
# /etc/init.d/glusterfsd start
Starting glusterfsd:                           [  OK  ]

Ahora vamos a añadir una partición en /etc/fstab la cual montaremos en /data/exports

# vim /etc/fstab
/dev/sda3     /data/exports     ext3     defaults     0 0

En cada servidor se hace esto, es lo que ofreceremos a los clientes a través de Gluster.

Configuración de los clientes.

Pasamos ahora a la configuración de los clientes, empezamos instalando las dependencias de compilación y librerías para acabar montando el volumen Gluster en /home. Estos pasos hay que hacerlos en cada cliente.

# yum groupinstall 'Development Tools'
# yum groupinstall 'Development Libraries'
# yum install libibverbs-devel fuse-devel

Ahora cargamos el módulo fuse que se encargará de hacer de interface con el Kernel.

# modprobe fuse

Configuramos el sistema para que cargue el módulo con cada arranque.

# echo "modprobe fuse" >> /etc/rc.modules
# chmod +x /etc/rc.modules

En cada cliente descargamos e instalamos el software. Tal y como hemos hecho antes.

# mkdir sandbox
# cd sandbox
# wget http://download.gluster.com/pub/gluster/glusterfs/3.0/LATEST/glusterfs-3.0.8.tar.gz
# tar zxvf glusterfs-3.0.8.tar.gz
# cd glusterfs-3.0.8
# ./configure

Al finalizar deberemos ver esto:

GlusterFS configure summary
===========================
FUSE client        : yes
Infiniband verbs   : yes
epoll IO multiplex : yes
libglusterfsclient : yes
argp-standalone    : no
fusermount         : no

Entonces compilamos e instalamos.

# make && make install

Enlazamos con las librerías dinámicas.

# ldconfig

Podemos ahora comprobar que se ha instalado correctamente.

# glusterfs --version

glusterfs 3.0.8 built on May 13 2011 20:20:55
Repository revision: v3.0.8
Copyright (c) 2006-2009 Gluster Inc. 
GlusterFS comes with ABSOLUTELY NO WARRANTY.
You may redistribute copies of GlusterFS under the terms of the GNU General Public License.

Creamos el directorio de configuración de GlusterFS.

# mkdir /etc/glusterfs

Añadimos lo siguiente al fichero glusterfs.vol

vim /etc/glusterfs/glusterfs.vol

volume remote1
  type protocol/client
  option transport-type tcp/client
  option remote-host server1
  option remote-subvolume brick
end-volume

volume remote2
  type protocol/client
  option transport-type tcp/client
  option remote-host server2
  option remote-subvolume brick
end-volume

volume stripe
  type cluster/stripe
  option block-size 1MB
  subvolumes remote1 remote2
end-volume

volume writebehind
  type performance/write-behind
  option window-size 1MB
  subvolumes stripe
end-volume

volume cache
  type performance/io-cache
  option cache-size 512MB
  subvolumes writebehind
end-volume

Y ya podemos montar el volumen en /home:

 # glusterfs -f /etc/glusterfs/glusterfs.vol /home

Podemos consultar que está montado ejecutando mount:

# mount

glusterfs#/etc/glusterfs/glusterfs.vol on /home type fuse (rw,allow_other,default_permissions,max_read=131072)

También ver el espacio disponible con df:

# df -hT

S.ficheros    Tipo  Tamaño Usado  Disp Uso% Montado en
/dev/sda1     ext3    2,9G  1,7G  1,1G  63% /
tmpfs        tmpfs    125M     0  125M   0% /dev/shm
glusterfs#/etc/glusterfs/glusterfs.vol
              fuse    6,5G  143M  6,1G   3% /home

Para hacer el montaje permanente, añadimos la siguiente línea a /etc/fstab

/etc/glusterfs/glusterfs.vol  /home             glusterfs          defaults,_netdev  0  0

Fallos.

Si has llegado hasta aquí significa que todo ha ido bien, si has encontrado algún problema los ficheros de logs de Gluster se encuentra en:

/usr/local/var/log/glusterfs/

Revisa que todas las máquinas resuelven los nombres, que la línea auth.addr.brick.allow está bien configurada y que has escrito correctamente los nombres de los directorios. Estos son problemas comunes.

Por ejemplo, si algún cliente no está autorizado a montar el volumen, pasará esto:

# glusterfs -f /etc/glusterfs/glusterfs.vol /home
# mount 

/dev/sda1 on / type ext3 (rw)
proc on /proc type proc (rw)
sysfs on /sys type sysfs (rw)
devpts on /dev/pts type devpts (rw,gid=5,mode=620)
tmpfs on /dev/shm type tmpfs (rw)
none on /proc/sys/fs/binfmt_misc type binfmt_misc (rw)
sunrpc on /var/lib/nfs/rpc_pipefs type rpc_pipefs (rw)
glusterfs#/etc/glusterfs/glusterfs.vol on /home type fuse (rw,allow_other,default_permissions,max_read=131072)

# df -hT

S.ficheros    Tipo  Tamaño Usado  Disp Uso% Montado en
/dev/sda1     ext3    2,9G  1,7G  1,1G  63% /
tmpfs        tmpfs    125M     0  125M   0% /dev/shm
/dev/sda3     ext3    6,5G  143M  6,1G   3% /data/exports
df: «/home»: Argumento inválido

Vemos que se ha producido un error que no es muy descriptivo del problema real que está ocurriendo ya que sí ha montado el volumen.

Conclusión.

Este sistema proporciona escalabilidad y tolerancia. El echo de exportar un directorio nos permite montar en ese directorio el disco físico un volumen LVM, un RAID, combinaciones de ambos, sistemas NAS o DAS y así montar nuestro propio DropBox! 😉

Alta Disponibilidad con Apache2 y Heartbeat en Debian Squeeze

A raíz de las últimas entradas en rm-rf.es y systemadmin.es quería probar el demonio de alta disponibilidad (heartbeat) sobre Debian, la entrada sobre Apache que publicó el primero me inspiró a hacer lo que contaba sobre la “distro” de la espiral.

Partimos de la misma configuración, tenemos dos servidores, cluster01 y cluster02 con las IPs 192.168.2.98 y 192.168.2.99 y una IP flotante 192.168.2.100

Configuradas ambas máquinas, instalamos los paquetes necesarios:

# apt-get install apache2

En nuestro caso, para la configuración de Apache editamos /etc/apache2/ports.conf y añadimos la IP flotante a la línea de NameVirtualHost así:

NameVirtualHost 192.168.2.100:80

Para que Apache no se levante al inicio ya que queremos que el que se encargue de esto es Heartbeat escribimos:

# update-rc.d apache2 remove

Y detenemos el servicio:

# /etc/init.d/apache2 stop

A continuación instalamos Heartbeat.

# apt-get install heartbeat

Y configuramos, estos ficheros de configuración se encuentran todos en /etc/ha.d/ y disponemos de plantillas para configurarlos en /usr/share/doc/heartbeat/. Podemos tomar ejemplo para configuraciones más específica.

Para el archivo ha.cf usamos la misma:

logfile /var/log/cluster.log
logfacility local0
warntime 5
deadtime 30
initdead 120
keepalive 2
bcast eth0
udpport 694
auto_failback on
node cluster01
node cluster02

La explicación

  • logfile y logfacility: Fichero de log y nivel.
  • warntime: Heartbeat avisará cuando un nodo falle tras 5 segundos.
  • deadtime: Hearbeat confirmará que un nodo ha caído, 30 segundos.
  • initdead: Tiempo máximo que Heartbeat esperará a que un nodo arranque, 60 segundos.
  • keepalive: Especifica cada cuanto tiempo Heartbeat enviará paquetes para comprobar la disponibilidad de los nodos, 2 segundos.
  • Las dos últimas líneas son las listas de nodos que conforman el cluster.

Para el fichero authkeys que es donde configuramos la comunicación entre los nodos del clúster, también para Debian podemos usar la original:

auth 2
2 sha1 clu$ter-4uth

Le asignamos los permisos para que sólo root tenga acceso.

# chmod 600 /etc/ha.d/authkeys

El último fichero cambia en Debian y es el haresources que queda con este aspecto:

cluster01 IPaddr2::192.168.2.100/24/eth0 apache2

Cambia la forma de escribir la IP flotante que está de una forma más completa y el script de inicio de Apache que en Debian es apache2.

Seguimos la entrada y la propagación se hace ejecutando el siguiente comando:

# /usr/share/heartbeat/ha_propagate

Levantamos el servicio.

/etc/init.d/heartbeat start

Ya está todo configurado, podemos probar a desactivar la interface de cluster01 y ver como al poco tiempo (el que hemos configurado) se levanta cluster02 para seguir sirviendo páginas.

La configuración entre CentOS y Debian es prácticamente la misma, pero tiene los suficientes detalles como para que los escriba aquí para no olvidar como se hace.

Algunas Fotos en el Despacho

Mi buen amigo @gonzaloMMD, se fue de viaje a Paris y ha preparado una entrada con unas fotos chulísimas de la capital alemana francesa (“acias” wikipedia!) xDDD. Yo más humilde, posteo unas pocas “fotillos” del despacho.

Estas dos corresponden a la migración que hicimos del cluster de OpenSUSE a CentOS. Se ven los 6 nodos esclavos, aunque la estructura está cambiando, y tendré que actualizar esta entrada.

Nodos Cluster Front

Nodos Cluster Front


Nodos Cluster Back

Nodos Cluster Back

Este será el nuevo master del cluster, el i7 con 16GB de RAM, con sus 5 discos duros.

Master Cluster

Master Cluster


Discos Master Cluster

Discos Master Cluster

Y esta es mi mesa, como siempre, llena de papeles y chismes.

Mi Mesa

Autentica mesa sysadmin

Compilación Paralela

He empezado a aprender como hacer compilación paralela para obtener más rendimiento en el clúster. Para ello me he metido con OpenMPI que es un proyecto abierto derivado de la estructura LAM/MPI mantenido por la comunidad.

El primer paso es obtener el software de esta dirección y compilarlo:

$ tar jxvf openmpi-1.4.1.tar.bz2
$ ./configure --prefix=/usr/local/openmpi
# make all install

Una vez compilado, debemos actualizar el enlazador dinámico para que nuestro software enlace correctamente con las librerías dinámicas de OpenMPI

# ldconfig /usr/local/openmpi/lib

Con esto, le decimos al programa ld que busque en /usr/local/openmpi/lib las librerias que haces falta en tiempo de ejecución de nuestro programa.

A continuación, es obligatorio que todos los nodos del clúster tengan acceso a los ejecutables tanto de nuestro programa como de OpenMPI, por lo que vamos ha crear un par de comparticiones por NFS.

/usr/local/openmpi   192.168.0.0/24(ro,root_squash)
/home/openmpi   192.168.0.0/24(rw,root_squash)

Donde /home/openmpi es nuestro usuario de cluster, en su directorio $HOME estará el programa a ejecutar. Y la otra compartición contiene los ejecutables del compilador.

Vamos a lanzar el programa clásico HelloWorld en paralelo, para ello utilizamos el siguiente código.

/* helloworld.c */
/* http://www.semicomplete.com/presentations/mpi/#slide_2 */
#include <stdio.h>
/* Esto es para añadir las funciones de OpenMPI */
#include "mpi.h"

int main(int argc, char **argv) {
int rank;
char host[150];
int namelen;

/* Inicializar MPI. Maneja la línea de comando especifica de mpich */
MPI_Init(&argc, &argv);

/* Devuelve el rango. Mi número de rango (de la instancia del programa) queda almacenado en la variable rank */
MPI_Comm_rank(MPI_COMM_WORLD, &rank);

/* Vemos en qué maquina me ejecutando y lo guardamos en host */
MPI_Get_processor_name(host,&namelen);

printf("Hello world (Rank: %d / Host: %s)\n", rank, host);
fflush(stdout);

/* Fin: Cerramos las conexiones con los demás nodos y liberamos la memora que el programa ha reservado,... */
MPI_Finalize();
return 0;

Lo compilamos

$ PATH=$PATH:/usr/local/openmpi/bin
$ mpicc helloworld.c -o helloworld

El PATH podemos añadirlo a nuestro ~/.bashrc para que esté siempre disponible. Ejecutamos.

$ mpirun -np 5 --hostfile=hosts helloworld

Donde

  1. -np Es el número de procesos que vamos a lanzar.
  2. –hostfile Es el fichero que almacena los nombres de los hosts, cada nodo del cluster.

La salida debe ser algo como esto

Hello world (Rank: 0 / Host: master)
Hello world (Rank: 2 / Host: master)
Hello world (Rank: 4 / Host: master)
Hello world (Rank: 1 / Host: cluster01)
Hello world (Rank: 3 / Host: cluster01)

Vemos que ha lanzado tres procesos en master y dos en cluster01.

De momento esto es lo poco que sé, pero sigo avanzando, el asunto de tener que resolver matrices de gran tamaño voy a necesitar escribir código para lanzar paralelizado.