Almacenamiento compartido en red: GFS2 + NFS (I)

En el presente artículo vamos a desarrollar una arquitectura de almacenamiento compartido a la que accederán de forma concurrente un par de máquinas. Las pruebas van a ser realizadas bajo un sistema operativo de tipo CentOS 5.3.

El área de datos sobre el que se configurará el acceso compartido será un volumen lógico (LogVol00) cuyo sistema de archivos será GFS2 (Global File System 2).

GFS es un sistema de ficheros nativo creado por Red Hat y distribuido bajo licencia GNU, que puede ser utilizado de forma local (como por ejemplo ext3) o en cluster, de manera que varios nodos puedan estar trabajando simultáneamente sobre él sin peligro a que se corrompan los datos. El máximo tamaño de almacenamiento que soporta GFS2 es de 8 EB.

En la figura siguiente puede observarse que el espacio de almacenamiento compartido se instalará sobre la máquina centos01, el cual será exportado a los nodos centos02 y centos03 a través de NFS4 (Network File System v4).


NFS es un protocolo perteneciente al nivel de aplicación utilizado para sistemas de ficheros distribuidos, que permite que varios nodos puedan acceder de forma simultánea a distintos archivos remotos. Todas las operaciones de escritura son síncronas, es decir, la tarea se da por finalizada cuando realmente se ha terminado de escribir el último byte.

Cada una de las máquinas deberá tener registrado los nombres de todos los nodos en el fichero /etc/hosts.

[... ~]# cat /etc/hosts
...
192.168.1.11    centos01 centos01.local
192.168.1.12    centos02 centos02.local
192.168.1.13    centos03 centos03.local

SELinux deberá estar desactivado en el nodo centos01, al igual que iptables y TCP wrappers. Al final del artículo veremos la forma de configurarlos correctamente para que no interfieran en el sistema de almacenamiento.

[root@centos01 ~]# setenforce 0

[root@centos01 ~]# service iptables stop

[root@centos01 ~]# cat /etc/hosts.deny
...
#ALL: ALL

En los nodos centos02 y centos03 estos tres mecanismos de seguridad podrán estar activados:

[... ~]# getenforce
Enforcing

[... ~]# cat /etc/hosts.deny
...
ALL: ALL

[... ~]# iptables -nL
Chain INPUT (policy ACCEPT)
target     prot opt source               destination
RH-Firewall-1-INPUT  all  --  0.0.0.0/0            0.0.0.0/0

Chain FORWARD (policy ACCEPT)
target     prot opt source               destination
RH-Firewall-1-INPUT  all  --  0.0.0.0/0            0.0.0.0/0

Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination

Chain RH-Firewall-1-INPUT (2 references)
target     prot opt source               destination
ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0
ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0           state RELATED,ESTABLISHED
ACCEPT     tcp  --  0.0.0.0/0            0.0.0.0/0           tcp dpt:22
ACCEPT     icmp --  0.0.0.0/0            0.0.0.0/0
LOG        all  --  0.0.0.0/0            0.0.0.0/0           LOG flags 0 level 4
REJECT     all  --  0.0.0.0/0            0.0.0.0/0           reject-with icmp-port-unreachable

Lo primero que vamos a hacer es instalar el software necesario en el nodo centos01.

[root@centos01 ~]# yum install lvm2-cluster rgmanager gfs2-utils

Seguidamente vamos a crear el volumen lógico que se empleará como espacio compartido en centos01, utilizando para ello una partición de 64 GB que ya tendremos creada previamente y etiquetada como Linux LVM.

[root@centos01 ~]# fdisk -l
...
Disposit. Inicio    Comienzo      Fin      Bloques  Id  Sistema
/dev/sdb1               1        8354    67103473+  8e  Linux LVM

Primero habrá que crear un volumen físico sobre esa partición, después el grupo de volúmenes (VolGroup01) y por último el volumen lógico (LogVol00).

[root@centos01 ~]# pvcreate /dev/sdb1

[root@centos01 ~]# vgcreate VolGroup01 /dev/sdb1

[root@centos01 ~]# lvcreate -l 100%FREE -n LogVol00 VolGroup01

Una vez que ya se tiene creado el volumen lógico, crearemos dentro de él un sistema de archivos GFS2. El parámetro lock_dlm indica el protocolo de bloqueo a emplear, siendo lock_dlm (DLM - Distributed Lock Manager) para el caso de acceso concurrente y lock_nolock para el caso de acceso de un único nodo. Con la opción de -t se especifica el nombre del cluster y el nombre que le queremos dar al sistema de archivos, y con la opción -j se indica el número de nodos que accederán concurrentemente al sistema de archivos.

[root@centos01 ~]# mkfs.gfs2 -p lock_dlm -t mycluster:gfs2_data -j 3 /dev/VolGroup01/LogVol00

Si en un momento dado deseamos conocer el número de nodos asociados al sistema GFS2, podremos ejecutar el siguiente comando:

[root@centos01 ~]# gfs2_tool journals /dev/VolGroup01/LogVol00
journal2 - 128MB
journal1 - 128MB
journal0 - 128MB
3 journal(s) found.

A continuación se va a crear en centos01, un archivo denominado cluster.conf el cual refleje la arquitectura que se quiere establecer (directorio /mnt/gfs2_nfs cuyo sistema de archivos es GFS2 y exportado a través del protocolo NFS4 a los nodos centos02 y centos03).

[root@centos01 ~]# cat /etc/cluster/cluster.conf
<?xml version="1.0"?>
<cluster alias="mycluster" config_version="1" name="mycluster">
        <fence_daemon clean_start="0" post_fail_delay="0" post_join_delay="3"/>
        <clusternodes>
                <clusternode name="centos01.local" nodeid="1" votes="1">
                        <fence/>
                </clusternode>
        </clusternodes>
        <cman/>
        <fencedevices/>
        <rm>
                <failoverdomains/>
                <resources>
                        <nfsexport name="resource_nfs_export"/>
                        <clusterfs device="/dev/VolGroup01/LogVol00" force_unmount="0" fsid="31803" fstype="gfs2" mountpoint="/mnt/gfs2_nfs" name="resource_gfs2" self_fence="0"/>
                        <nfsclient allow_recover="1" name="resource_nfs_client_centos02" options="rw,sync,root_squash,fsid=0" target="centos02.local"/>
                        <nfsclient allow_recover="1" name="resource_nfs_client_centos03" options="rw,sync,root_squash,fsid=0" target="centos03.local"/>
                </resources>
                <service autostart="1" exclusive="0" max_restarts="0" name="service_centos01" recovery="restart" restart_expire_time="0">
                        <clusterfs fstype="gfs" ref="resource_gfs2">
                                <nfsexport ref="resource_nfs_export">
                                        <nfsclient name=" " ref="resource_nfs_client_centos02"/>
                                        <nfsclient name=" " ref="resource_nfs_client_centos03"/>
                                </nfsexport>
                        </clusterfs>
                </service>
        </rm>
</cluster>

En una primera sección (clusternodes) se define el nombre del nodo (clusternode name) que ofrecerá el servicio NFS.

La otra sección principal del fichero de configuración es la de los recursos. Se han definido cuatro recursos: un dispositivo (GFS2) que será montado en el directorio /mnt/gfs2_nfs, un directorio a exportar (/mnt/gfs2_nfs) y dos clientes (centos02 y centos03) a los que se les permitirá importar dicho directorio.

A su vez se ha creado un servicio denominado service_centos01 el cual iniciará y detendrá ciertos recursos (nfsexport, clusterfs, clusterfs, ...).

Así de esta forma el servicio service_centos01 hará que cuando se inicie automáticamente (autostart="1"), se monte el recurso resource_gfs2, se exporte el directorio /mnt/gfs2_nfs asociado al recurso resource_nfs_export e implícitamente a los nodos centos02 y centos03 a través de los recursos resource_nfs_client_centos02 y resource_nfs_client_centos03.

Las opciones de exportación empleadas para NFS han sido rw (permitir la lectura y escritura), sync (escrituras síncronas) , root_squash (root accederá como usuario anónimo - nobody) y fsid=0 (habilitar NFSv4).

Se ha dicho que el dispositivo a exportar deberá ser montado previamente en el directorio /mnt/gfs2_nfs. Por lo tanto, también tendremos que crear dicho directorio. A su vez, en los nodos centos02 y centos03 crearemos el mismo directorio en el cual montaremos el volumen NFS importado.

[root@centos01 ~]# mkdir /mnt/gfs2_nfs

[root@centos02 ~]# mkdir /mnt/gfs2_nfs

[root@centos03 ~]# mkdir /mnt/gfs2_nfs

Para que los nodos centos02 y centos03 puedan importar automáticamente dicho directorio durante el arranque, tendremos que añadir al fichero /etc/fstab de ambos nodos el siguiente contenido:

[... ~]# cat /etc/fstab
...
centos01.local:/   /mnt/gfs2_nfs/   nfs4   defaults   0 0

Por último, sólo tendremos que reiniciar los servicios gfs2, cman, rgmanager y clvmd en el nodo centos01, y mediante el comando chkconfig haremos que dichos demonios se inicien automáticamente cada vez que arranque el nodo. También tendremos que otorgar permisos de escritura para el resto de usuarios, al directorio exportado.

[root@centos01 ~]# service gfs2 restart

[root@centos01 ~]# service cman restart

[root@centos01 ~]# service rgmanager restart

[root@centos01 ~]# service clvmd restart


[root@centos01 ~]# chkconfig gfs2 on

[root@centos01 ~]# chkconfig cman on

[root@centos01 ~]# chkconfig rgmanager on

[root@centos01 ~]# chkconfig clvmd on


[root@centos01 ~]# chmod -R o+w /mnt/gfs2_nfs/

Si ejecutamos el comando clustat, podremos ver la configuración actual del cluster que acabamos de levantar. Por un lado se tiene la lista de miembros del cluster (Member Name) y por el otro, la lista de servicios definidos (Service Name), así como su propietario (Owner) y estado (State).

[root@centos01 ~]# clustat
Cluster Status for mycluster @ Wed Jul 22 17:04:00 2009
Member Status: Quorate

 Member Name                           ID   Status
 ------ ----                           ---- ------
 centos01.local                            1 Online, Local, rgmanager

 Service Name                 Owner (Last)                 State
 ------- ----                 ----- ------                 -----
 service:service_centos01     centos01.local               started

Para que los nodos centos02 y centos03 monten en este momento el sistema de ficheros exportado por centos01, únicamente tendremos que ejecutar el siguiente comando en ambos nodos:

[... ~]# mount -a