Diario informal de K-nábora

jun 16

2010

Mirror remoto con DRBD en Linux

Enviado por K-nábora Bufete Tecnológico en linux, alta disponibilidad

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:

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.
tener una copia de los datos (mirroring): el contenido de drbd0 (/data) estará sincronizado mediante DRBD entre server1 y server2.
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.

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 
```
  Para comprobar la hora del sistema:
```
# date
```

DRBD

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

cargar el módulo DRBD: en ambos servidores:
```
# modprobe drbd
```

/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];
  }
}

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.

configurar el servidor primario: ejecutaremos el siguiente comando en server1 para que sea el servidor primario:
```
# drbdadm -- --do-what-I-say primary all
```

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

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
```
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

arrancar DRBD: en ambos servidores:
```
# /etc/init.d/drbd start
```
arrancar HeartBeat: en ambos servidores:
```
# /etc/init.d/heartbeat start
```

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.

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.

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).
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).
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


Fuente: estrellayarde.org
```