Mirror remoto con DRBD

DRBD (Distributed Replicated Block Device, drbd.org) permite mirror remoto en tiempo real (equivalente a RAID-1 en red), algo muy difícil de conseguir con otros sistemas como rsync ya que éste no puede trabajar en tiempo real por su consumo de memoria y CPU.

DRDB crea un dispositivo de bloques drbd0 accesible desde ambos servidores. El servidor primario es el que tiene acceso RW en el dispositivo drbd0: cada vez que escribe algo en drbd0 lo escribe en la partición física y esos mismos datos se envían por TCP/IP al servidor secundario (que sólo tiene acceso RO) consiguiendo que ambas particiones físicas estén sincronizadas, exactamente igual que un RAID-1.

Vamos a ver un ejemplo con DRBD, HeartBeat y NFS para implementar almacenamiento compartido en un cluster LVS. Buscamos tres cosas:

1. almacenamiento compartido: para que todos los servidores web de un cluster LVS con Apache sirvan los mismos datos exportaremos el directorio /data/export mediante NFS para que lo monten los servidores reales del cluster.
2. tener una copia de los datos (mirroring): el contenido de drbd0 (/data) estará sincronizado mediante DRBD entre server1 y server2.
3. alta disponibilidad: usaremos HeartBeat en los servidores DRDB para activar el secundario si el primario falla, consiguiendo de ese modo un almacenamiento de alta disponibilidad.

El proceso para implementar mirror remoto con DRBD consta de los siguientes pasos:

1. Configuración inicial.
2. Configurar DRBD.
3. Configurar NFS.
4. Configurar HeartBeat.
5. Arrancar y comprobar.

Configuración inicial

Veamos la configuración inicial de server1 y server2.

1. Particiones: particionaremos server1 y server2 de la siguiente manera:

   /dev/sda1: /boot, primaria, ext3, bootable.
   /dev/sda5: /, lógica, ext3.
   /dev/sda6: lógica, swap.
   /dev/sda7: 150 MB, unmounted, lógica, ext3 (contendrá los meta-datos de DRBD).
   /dev/sda8: unmounted, lógica, ext3 (contendrá el directorio /data).

   Atención

   • /dev/sda7 y /dev/sda8 deben tener idéntico tamaño en ambos servidores.
   • Los meta-datos de DRBD (logs de estado y de flujo, al estilo de un journal) necesitan 128 MB, por lo que /dev/sda7 tendrá 150 MB.
   • No hay que montar ni /dev/sda7 ni/dev/sda8. El instalador nos preguntará:

     No ha asignado ‘mount point’ a la partición #7 de /dev/sda. ¿Desea regresar al menú de particionado?

     Responderemos No, continuar con el particionado.

2. /etc/fstab: comprobaremos en ambos servidores que /dev/sda7 y /dev/sda8 no aparecen en /etc/fstab, que debe ser similar a:

   # File_system Mount_point Type Options Dump Pass /dev/sda5 / ext3 defaults 0 1 /dev/sda1 /boot ext3 defaults 0 2 /dev/sda6 none swap sw 0 0 proc /proc proc defaults 0 0 /dev/hdc /media/cdrom0 iso9660 ro,user,noauto 0 0 /dev/fd0 /media/floppy0 auto rw,user,noauto 0 0

3. Instalar un cliente NTP (paquete ntpdate): conectaremos ambos servidores al mismo servidor NTP para asegurarnos de que tienen la misma hora del sistema (System Time). Su sintaxis es:

   # ntpdate <server>

   Para comprobar la hora del sistema:

   # date

Configurar DRBD

Veamos la configuración de DRBD.

1. compilar el módulo DRBD (paquetes drbd0.7-module-source drbd0.7-utils): en ambos servidores (necesitamos también las fuentes del kernel):

   # apt-get install kernel-headers-2.6.8-2-386 # apt-get install drbd0.7-module-source drbd0.7-utils # cd /usr/src/ # tar xvfz drbd0.7.tar.gz # cd modules/drbd/drbd # make # make install

2. cargar el módulo DRBD: en ambos servidores:

   # modprobe drbd

3. /etc/drbd.conf: editar el archivo de configuración de DRBD (idéntico en ambos servidores):

   resource r0 { protocol C; incon-degr-cmd "halt -f"; startup { degr-wfc-timeout 120; # 2 minutes } disk { on-io-error detach; } net { } syncer { rate 10M; group 1; al-extents 257; } on server1 { device /dev/drbd0; disk /dev/sda8; address 192.168.6.172:7788; meta-disk /dev/sda7[0]; } on server2 { device /dev/drbd0; disk /dev/sda8; address 192.168.6.173:7788; meta-disk /dev/sda7[0]; } }

4. activar DRBD: en ambos servidores:

   # drbdadm up all # cat /proc/drbd version: 0.7.10 (api:77/proto:74) SVN Revision: 1743 build by phil@mescal, 2005-01-31 12:22:07 0: cs:Connected st:Secondary/Secondary ld:Inconsistent ns:0 nr:0 dw:0 dr:0 al:0 bm:1548 lo:0 pe:0 ua:0 ap:0 1: cs:Unconfigured

   Vemos que ningún servidor ha sido configurado como primario (Secondary/Secondary) y que los datos son inconsistentes (Inconsistent), ya que todavía no hemos hecho la sincronización inicial.

5. configurar el servidor primario: ejecutaremos el siguiente comando en server1 para que sea el servidor primario:

   # drbdadm -- --do-what-I-say primary all

6. sincronización inicial ejecutaremos el siguiente comando en server1 para realizar la sincronización inicial entre server1 y server2:

   # drbdadm -- connect all

   Durará un buen rato, por lo que tendremos paciencia. Para ver el progreso de la sincronización:

   # cat /proc/drbd version: 0.7.10 (api:77/proto:74) SVN Revision: 1743 build by phil@mescal, 2005-01-31 12:22:07 0: cs:SyncSource st:Primary/Secondary ld:Consistent ns:13441632 nr:0 dw:0 dr:13467108 al:0 bm:2369 lo:0 pe:23 ua:226 ap:0 [==========>.........] sync'ed: 53.1% (11606/24733)M finish: 1:14:16 speed: 2,644 (2,204) K/sec 1: cs:Unconfigured

   Cuando termine la salida será:

   # cat /proc/drbd SVN Revision: 1743 build by phil@mescal, 2005-01-31 12:22:07 0: cs:Connected st:Primary/Secondary ld:Consistent ns:37139 nr:0 dw:0 dr:49035 al:0 bm:6 lo:0 pe:0 ua:0 ap:0 1: cs:Unconfigured

Configurar NFS

Veamos la configuración de NFS.

1. instalar el servidor NFS (paquete nfs-kernel-server): en ambos servidores:

   # apt-get install nfs-kernel-server

2. borrar los scripts de inicio de NFS: NFS estará bajo el control de HeartBeat (que se encargará de lanzarlo) por lo que borraremos los scripts de inicio de NFS en ambos servidores:

   # update-rc.d -f nfs-kernel-server remove # update-rc.d -f nfs-common remove # /etc/init.d/nfs-kernel-server stop

3. directorio a exportar: en ambos servidores editaremos /etc/exports y añadiremos una entrada para exportar /data/export (en este punto la partición /dev/sda8 todavía está vacía y sin montar):

   /data/export/ 192.168.6.0/255.255.255.0(rw,no_root_squash,sync)

4. /var/lib/nfs: NFS almacena información importante (locks, etc.) en /var/lib/nfs. Si server1 falla server2 le reemplazará pero la información que server2 tiene en /var/lib/nfs será diferente de la que tenía server1. Para resolver este problema vamos a almacenar la información de /var/lib/nfs en la partición /dev/sda8 que está sincronizada mediante DRBD entre server1 y server2. Así, si server1 falla server2 dispondrá de toda su información. En server1:

   # mkdir /data # mount -t ext3 /dev/drbd0 /data # mv /var/lib/nfs /data # ln -s /data/nfs /var/lib/nfs # mkdir /data/export # umount /data

   En server2:

   # mkdir /data # rm -fr /var/lib/nfs # ln -s /data/nfs /var/lib/nfs

Configurar HeartBeat

Veamos la configuración de HeartBeat. Instalaremos HeartBeat en ambos servidores. HeartBeat controla todo el asunto: lanza y detiene NFS en ambos servidores, los monitoriza y activa el servidor secundario si el primario falla y se encarga de que el servidor NFS responda en la IP virtual (VIP) 192.168.6.174.

1. instalar HeartBeat (paquete heartbeat): en ambos servidores:

   # apt-get install heartbeat

2. /etc/heartbeat/ha.cf: crearemos este archivo idéntico en ambos servidores:

   logfacility local0 bcast eth0 keepalive 2 deadtime 10 node server1 node server2

3. /etc/heartbeat/haresources: crearemos este archivo idéntico en ambos servidores:

   server1 IPaddr::192.168.6.174/24/eth0 drbddisk::r0 Filesystem::/dev/drbd0::/data::ext3 nfs-kernel-server

   En este archivo se especifica el nombre del servidor primario (server1), la IP virtual (192.168.6.174), el resource DRBD definido en /etc/drbd.conf (r0), el dispositivo DRBD (/dev/drbd0, /data, ext3) y el servidor a monitorizar (nfs-kernel-server).

4. /etc/heartbeat/authkeys: crearemos este archivo idéntico en ambos servidores:

   auth 3 3 md5 mi_password

   Aquí definimos el mecanismo de autentificación (md5) y el password para que los dos demonios heartbeat de los servidores se autentifiquen uno contra el otro (mi_password). Sólo root debe tener permisos de lectura sobre /etc/heartbeat/authkeys por lo que haremos:

   # chmod 600 /etc/heartbeat/authkeys

Arrancar y comprobar

Por último, nos queda arrancar y comprobar.

1. arrancar DRBD: en ambos servidores:

   # /etc/init.d/drbd start

2. arrancar HeartBeat: en ambos servidores:

   # /etc/init.d/heartbeat start

3. comprobar la IP virtual: en server1:

   # ifconfig eth0 Link encap:Ethernet HWaddr 00:0C:29:A1:C5:9B inet addr:192.168.6.172 Bcast:192.168.6.255 Mask:255.255.255.0 inet6 addr: fe80::20c:29ff:fea1:c59b/64 Scope:Link UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 RX packets:18992 errors:0 dropped:0 overruns:0 frame:0 TX packets:24816 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:1000 RX bytes:2735887 (2.6 MiB) TX bytes:28119087 (26.8 MiB) Interrupt:177 Base address:0x1400   eth0:0 Link encap:Ethernet HWaddr 00:0C:29:A1:C5:9B inet addr:192.168.6.174 Bcast:192.168.6.255 Mask:255.255.255.0 UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 Interrupt:177 Base address:0x1400

   Si hacemos esto mismo en server2 no veremos la IP virtual.

4. comprobar los dispositivos montados: en server1:

   # df -h Filesystem Size Used Avail Use% Mounted on /dev/sda5 4.6G 430M 4.0G 10% / tmpfs 126M 0 126M 0% /dev/shm /dev/sda1 89M 11M 74M 13% /boot /dev/drbd0 24G 33M 23G 1% /data

   Si hacemos esto mismo en server2 no veremos /dev/drbd0.

5. simular el fallo de server1: creamos en server1 el archivo /data/export/test1 y simulamos el fallo de server1:

   # touch /data/export/test1 # /etc/init.d/heartbeat stop

   Ahora, si todo funciona, si ejecutamos en server2:
   # ifconfig: veremos la IP virtual 192.168.6.174
   # df -h: veremos el dispositivo /dev/drbd0
   # ls -l /data/export: veremos el archivo test1 (el mirror funciona).

6. simular que server1 vuelve a estar en línea: vamos a comprobar que cuando server1 vuelva a estar en línea es activado como primario y recupera la IP virtual y el dispositivo /dev/drbd0. Creamos en server2 el archivo /data/export/test2:

   # touch /data/export/test2

   Levantamos server1:

   # /etc/init.d/heartbeat start

   Esperamos unos segundos y, si todo funciona, si ejecutamos en server1:
   # ifconfig: veremos la IP virtual 192.168.6.174 otra vez.
   # df -h: veremos el dispositivo /dev/drbd0 otra vez.
   # ls -l /data/export: veremos el archivo test2 (el mirror funciona).

7. comprobar NFS desde los clientes: para acceder desde los clientes a los datos exportados mediante NFS por server1 y server2 usaremos la IP virtual 192.168.6.174:

   # mount 192.168.6.174:/data/export /var/www

   Para montar el dispositivo al arrancar editaremos /etc/fstab y añadiremos una entrada:

   # File_system Mount_point Type Options Dump Pass 192.168.6.174:/data/export /var/www nfs rw 0 0