Generando un cluster de alta disponibilidad

Esta vez estuve trabajando con clusters, me vi forzado a investigar como desarrollar un cluster de alta disponibilidad con heartbeat, ultimamente ya no trabajo con OpenSuse, creo haberlo mencionado en uno de los posts anteriores y decidi trabajar con Debian por su alto desempeño y estabilidad de la cual e quedado maravillado.

Un cluster en resumidas cuentas no es nada mas que un conjunto de ordenadores en red que funcionan como uno solo ya sea para evitar problemas de fallos o para hacer que todos los ordenadores trabajen como uno solo sumarizando sus recursos y realizar calculos enormes que un solo ordenador no podria realizar.

Empezaremos el desarrollo con heartbeat, este es HA (High Availability). Antes de continuar cabe mencionar que debian ya tiene este paquete en su repositorio solo basta con instalar y listo no hay que hacer mucho pero como siempre me gusta hacer las cosas desde cero y para los que les gusta hacerlo así, este post les gustará

Hay varias razones del por que usar un paquete de debian y otras muchas razones del por que hacerlo desde cero, esto va en dependencia de la necesidad de cada quien, ultimamente me agrada mas trabajar con la paqueteria de debian que compilar paquetes, sin embargo siempre es interesante hacerlo por ambas formas siempre hay algo nuevo que aprender:

Empezaremos instalando todos los paquetes necesarios para la compilacion, hago mencion que esto fue realizado con un servidor usando debian squeeze, hago mencionar que es 64 bits y es la arquitectura de mi preferencia x86 ya la considero obsoleta o al menos ya no veo en mi campo ese tipo de hardware.

Los siguientes pasos son complementarios para realizar la instalación de heartbeat, antes de realizar estos pasos favor leer:
http://www.linux-ha.org/doc/users-guide/users-guide.html

Los pasos de la instalación se muestran en el siguiente link:
http://www.linux-ha.org/doc/users-guide/_building_and_installing_from_source.html

Antes de proceder recomiendo que lean muy bien el users guide, pero como se que muchos no lo harán no haré un paso a pass ya que no pretendo copiar y pegar algo que ya esta hecho por que el objetivo no es duplicar lo que ya está, sino solo anexar o complementar, por lo tanto aquí me salto los pasos que se suponen descargas los paquetes, recomiendo que lean bien la guía y anexar lo que muestro aquí.

1) Instalamos la paquetería:
apt-get install hgsvn uuid-dev build-essential flex bison libsnmp-dev openipmi python autoconf libtool xsltproc libextutils-pkgconfig-perl libglib2.0-dev libxml2-dev libbz2-dev

2) Primero empezamos instalando algo que se llama Cluster Glue, entonces primero descargamos el tar, ya sea el ultimo release (Desarrollo) o el mas estable, yo obte por el estable. (Ver y leer el link de la guia de usuario)

3) Descargamos el paquete cluster-glue
http://www.linux-ha.org/doc/users-guide/_building_and_installing_from_source.html#_downloading_cluster_glue_sources

4) Antes de proceder a compilar descargar el patch para el cluster-glue, ya que sin este patch dará un error que no permitirá compilarlo completamente por un error de tipos de variables:

cat > /gatomic.h.patch << "EOF"
--- /usr/include/glib-2.0/glib/gatomic.h.orig   2010-04-14 18:16:59.853768126 +0000
+++ /usr/include/glib-2.0/glib/gatomic.h        2010-04-14 18:17:39.409810040 +0000
@@ -64,16 +64,16 @@
 #else
 # define g_atomic_int_get(atomic) \
  ((void) sizeof (gchar [sizeof (*(atomic)) == sizeof (gint) ? 1 : -1]), \
-  (g_atomic_int_get) ((volatile gint G_GNUC_MAY_ALIAS *) (void *) (atomic)))
+  (g_atomic_int_get) ((volatile gint G_GNUC_MAY_ALIAS *) (volatile void *) (atomic)))
 # define g_atomic_int_set(atomic, newval) \
  ((void) sizeof (gchar [sizeof (*(atomic)) == sizeof (gint) ? 1 : -1]), \
-  (g_atomic_int_set) ((volatile gint G_GNUC_MAY_ALIAS *) (void *) (atomic), (newval)))
+  (g_atomic_int_set) ((volatile gint G_GNUC_MAY_ALIAS *) (volatile void *) (atomic), (newval)))
 # define g_atomic_pointer_get(atomic) \
  ((void) sizeof (gchar [sizeof (*(atomic)) == sizeof (gpointer) ? 1 : -1]), \
-  (g_atomic_pointer_get) ((volatile gpointer G_GNUC_MAY_ALIAS *) (void *) (atomic)))
+  (g_atomic_pointer_get) ((volatile gpointer G_GNUC_MAY_ALIAS *) (volatile void *) (atomic)))
 # define g_atomic_pointer_set(atomic, newval) \
  ((void) sizeof (gchar [sizeof (*(atomic)) == sizeof (gpointer) ? 1 : -1]), \
-  (g_atomic_pointer_set) ((volatile gpointer G_GNUC_MAY_ALIAS *) (void *) (atomic), (newval)))
+  (g_atomic_pointer_set) ((volatile gpointer G_GNUC_MAY_ALIAS *) (volatile void *) (atomic), (newval)))
 #endif /* G_ATOMIC_OP_MEMORY_BARRIER_NEEDED */

#define g_atomic_int_inc(atomic) (g_atomic_int_add ((atomic), 1))
EOF

3) No olvidemos agregar el grupo haclient y el usuario hacluster:
groupadd haclient
useradd -g haclient hacluster

4) Compilamos e instalamos
http://www.linux-ha.org/doc/users-guide/_building_and_installing_from_source.html#_building_cluster_glue

5) Descargamos el heartbeat
http://www.linux-ha.org/doc/users-guide/_building_and_installing_heartbeat_from_source.html#_downloading_heartbeat_sources

6) Compilamos e instalamos el paquete
http://www.linux-ha.org/doc/users-guide/_building_and_installing_heartbeat_from_source.html#_building_heartbeat

Listo ya tenemos instalado heartbeat desde cero sin embargo ahora veamos como sería instalarlo a la manera de debian:

# aptitude install heartbeat cluster-glue cluster-agents pacemaker

Como vemos depende de la necesidad de cada quien, ambos métodos de instalación funcionan pero quizás mas de algún usuario vea útil ver que opciones de compilación permite cada paquete.

De vista al futuro

Mas de una que otra vez siempre escucho hablar opiniones sobre la virtualización, muchas opiniones son buenas pero siempre escucho que llevan piedras, la realidad es que la virtualización ya llegó, sin embargo el problema es el miedo al cambio, e intentan dar mil argumentos del por que preferir hardware físico y no virtual.

Para empezar la virtualización inicia con varios propósitos y necesidades, buscando hacer uso de mayor cantidad de ordenadores en menos equipos físicos, ahorrando energía, espacio y costos, y obteniendo mejores resultados económicos.

Actualmente la virtualización a mejorado tanto que se pueden crear ordenadores virtuales con características identicas a uno real. Se pueden virtualizar ordenadores con capacidades de un pentium I a 500MHz y con 256 ram, lo suficiente para correr aplicaciones tan personalizadas en el hardware necesario sin desutilizar el hardware y aprovecharlo para otras tareas en otras maquinas con mayor capacidad.

Así ordenadores con grandes capacidades pueden poseer cientos de maquinas virtuales con distintas características y propiedades. La virtualización a sido también de muy buena ayuda para crear en el área de los desarrolladores laboratorios que replican un ambiente de producción y que permitan realizar pruebas sin afectar lo ya existente, tanto en el ambiente de producción como de desarrollo la virtualización a tomado un gran espacio y mercado.

La verdad es que la virtualización a llegado para quedarse y es el nuevo futuro, actualmente ya no solo se habla de virtualizar servicios y servidores si no que ahora se habla de virtualizar los mismos escritorios personales a lo que ahora se le ha llamado VDI (Virtual desktop infrastructure), quien aun teme a la virtualización queda atrás es como negar lo que ya está, para empezar que servicio que usemos no está virtual, si el mismo correo gratuito personal es un servicio que correo en un servidor virtual. Muchas páginas corren en servidores virtuales.

Claro quien no querría tener su propio server y poder obtener una propia imagen que puede ser levantada en minutos en otro lugar sin necesidad de reconfigurar solo trasladar la imagen y listo. Servidores físicos no permiten eso, para una exportación se requiere tener dos servidores con el mismo Sistema Operativos, mismos paquetes y la migración no es algo que cualquiera puede hacer, se requiere al menos un conocimiento de todo el servicio y ajustes personales de la aplicación. En cambio con la virtualización adiós a todo eso, el jefe de IT solo necesita tomar la imagen, moverla y arrancarla desde el nuevo destino y listo.

Lo que generalmente uno escucha de muchos del por que no optan por la virtualización es por uno o varios de los siguientes tabues:
* El hardware no es físico y no es lo mismo.
* Con el virtual no tengo el mismo desempeño.
* Miedo a la seguridad y la información que por que esta virtual no existe y no es igual.
* Si es virtual no puedo verlo.
* No se puede crear redes de maquinas con la virtualización, por que no puedo verlas físicamente, no puedo hacer el mapa de red.

Todas estas dudas y miedos y tabues, solo son temores por entrar a lo desconocido y aprender lo nuevo, ya no es verdad que por que algo virtual no tiene el mismo desempeño que algo real ya que existen tantos métodos de virtualización que uno escoge el que mejor calza con la necesidad que uno busco, hay virtualizaciones que funcionan para sacar el mejor desempeño del hardware existen otras que hacen su tarea aunque a un costo de desempeño o velocidad, sin embargo todo esto depende de la necesidad y fin por el cual uno necesita virtualizar uno o mas servicios.

Ya habíamos hablado de los distintos métodos de virtualización (http://gnu-linux-opensource.blogspot.com/2009/06/linux-y-la-virtualizacion.html), existen virtualizaciones que virtualizan todo el hardware, otras que semivirtualizan el hardware y otras que no virtualizan el hardware y solo crean ambientes enjaulados. Cada una de estas virtualizaciones funcionan para un fin y una necesidad unas tienen mejores ventajas que otras pero cada una tiene su desventaja con respecto a otra, algunas requiren mayor trabajo para configurar y mayor o menor tiempo para su afinamiento, sin embargo todas cumplen su tarea y su trabajo de acuerdo a lo deseado.

Al final es decisón de uno quedarse atrás o dar un paso hacia adelante hacia el progreso. Virtualización ¿por que nó?

Enjaulando el Bind

El motivo de enjaular un servicio, siempre tiene como propósito de crear un ambiente aislado del sistema, por motivos de seguridad.

El proceso lo realice en debian 9.0, pero con unos cuantos ajustes funciona para cualquier debian.

Los pasos para dicha tarea son simples, enjaularemos el servicio dentro de /var/lib/named:

1) Instalamos el servicio:
apt-get install bind9

2) Detenemos el servicio:
/etc/init.d/bind9 stop

3) Hacemos el cambio en /etc/default/bind9 y agregamos "-t /var/lib/named"
sed "s/-u\ bind/-u\ bind\ -t\ \/var\/lib\/named/g" /etc/default/bind9 > /tmp/bind.temp
mv /tmp/bind.temp /etc/default/bind9
chmod 644 /etc/default/bind9
sed "s|OPTIONS=\"\"|OPTIONS=\"-u\ bind\ -t\ /var/lib/named\"|g" /etc/init.d/bind9 > /tmp/bind.temp
mv /tmp/bind.temp /etc/init.d/bind9
chmod 755 /etc/init.d/bind9


4) Creamos los directorios para el ambiente enjaulado
mkdir -p /var/lib/named/etc/ /var/lib/named/dev /var/lib/named/var/cache/bind/{data,local,master,slave} /var/lib/named/var/{log} /var/lib/named/run/

5) Procedemos a mover al ambiente enjaulado y hacemos vinculos al sistema para que siempre halla acceso desde el sistema anfitrion a los recursos del bind:
mv /var/log/named /var/lib/named/var/log/
ln -s /var/lib/named/var/log/named /var/log/named
mv /etc/bind /var/lib/named/etc/
ln -s /var/lib/named/etc/bind /etc/bind
mv /run/named /var/lib/named/run/named
ln -s /var/lib/named/run/named /run/named

6) Hacemos ajustes personalizados, en mi caso usaré en el ejemplo los ficheros de etc/bind y los mando a var/cache/bind/local, asi que cambio todo "/etc/bind" por "local", perfectamente se puede omitir este paso e ir al paso (8) o ajustarlo a su necesidad recuerde que si desea usar otro nombre diferente a "local", por ejemplo "folder", debe de crear la carpeta en el lugar del "var/cache/bind" enjaulado el comando sería "mkdir /var/lib/named/var/cache/bind/folder":
sed "s|/etc/bind/zones.rfc1918|local/zones.rfc1918|g" /etc/bind/named.conf.local > /tmp/bind.temp
mv /tmp/bind.temp /etc/bind/named.conf.local
sed "s/\/etc\/bind/local/g" /var/lib/named/etc/bind/named.conf.default-zones > /tmp/bind.temp
mv /tmp/bind.temp /var/lib/named/etc/bind/named.conf.default-zones
sed "s/\/etc\/bind/local/g" /var/lib/named/etc/bind/zones.rfc1918 > /tmp/bind.temp
mv /tmp/bind.temp /var/lib/named/etc/bind/zones.rfc1918
chmod 644 /var/lib/named/etc/bind/named.conf.local
chmod 644 /var/lib/named/etc/bind/named.conf.default-zones
chmod 644 /var/lib/named/etc/bind/zones.rfc1918

7) Ahora movemos todo a la carpeta "local", si se omite el paso 6, omitir tambien este paso
mv /var/lib/named/etc/bind/zones.rfc1918 /var/lib/named/var/cache/bind/local
mv /var/lib/named/etc/bind/db.* /var/lib/named/var/cache/bind/local

8) Movemos los archivos restantes en /var/cache/bind/ borramos y creamos enlace:
mv /var/cache/bind/managed-keys.bind /var/lib/named/var/cache/bind/
mv /var/cache/bind/managed-keys.bind.jnl /var/lib/named/var/cache/bind/
rm -rf /var/cache/bind
ln -s /var/lib/named/var/cache/bind /var/cache/bind

9) Creamos nodos:
mknod /var/lib/named/dev/null c 1 3
mknod /var/lib/named/dev/zero c 1 5
mknod /var/lib/named/dev/random c 1 8
mknod /var/lib/named/dev/urandom c 1 9
chmod 666 /var/lib/named/dev/*

10) Damos los permisos correspondientes:
chown -R bind:bind /var/lib/named/etc/bind
chown -R bind:bind /var/lib/named/var/*

11) Creamos el localtime:
cp /usr/share/zoneinfo/America/Managua /var/lib/named/etc/localtime

12) Iniciamos el servicio:
/etc/init.d/bind9 start

Monitoreando los recursos de hardware

¿Quien no usa Orion o Nagios para monitorear los recursos de un ordenador? Sin embargo aunque usemos el monitoreo, cuando estamos empezando siempre hay algo que pasamos por omisión, problemas como que el disco use el 40% y no podamos escribir en el por que los inodes se han topado. Por lo tanto el monitoreo de un servidor debe de abarcar las áreas a continuación: * Memoria: Tenemos los comandos free * Carga CPU: Tenemos los comandos top, sysstat, mpstat, sar * Temperatura: lm-sensors * Espacio en particiones: df * Inodes de particiones: df -i * Carga de red: tcptrack, iptraf, iftop, ifstat

Trabajando con el historial

Trabajando con otras distribuciones me di cuenta que en algunas distribuciones se hace mas comoda la busqueda de comandos previamente ejecutados, el mas util es buscas mediante Re-Pag y Av-Pag comandos cuya funcionalidad es buscar por patrones por ejemplo si se han usado los siguientes comandos:

vi hola.txt
vi -r a.txt
rm esto.txt
vi escrito.txt
mkdir -p folder/stuff
vi /etc/hosts

Es logico pensar que seria facil buscar los comandos cuyo patron inician con vi y no recordamos el archivo hola.txt por ejemplo entonces, seria util solo escribir 'vi' y usar Re-Pag y movernos solo viendo los comandos del historial que tengan el patron escrito.

Si alguien a usado opensuse, este lo trae por defecto. Cuando probe Centos, no sabia en ese entonces que podia ser cambiado teniendo que por defecto el Re-Pag y Av-Pag se hiban al primero comando y ultimo comando respectivamente del historial, siendo algo engorroso para repetir algun comando util previo coincidente. En debian tenia que ir uno por uno o haciendo grep al .bash_history.

Fue cando en algun momento decidi encontrar que hacia para que OpenSuse facilitara ese metodo e implementarlo tambien en el resto de distros que pruebo y uso, ok fue entonces que encontre que esto se configura en '/etc/inputrc', descomentariando las siguientes lineas:

# alternate mappings for "page up" and "page down" to search the history
"\e[5~": history-search-backward
"\e[6~": history-search-forward

Centos usa los siguientes:

# mappings for "page up" and "page down" to step to the beginning/end
# of the history
"\e[5~": beginning-of-history
"\e[6~": end-of-history


Existen mas opciones, leer para ajustar a sus necesidades, a mi solo me era util la de usar Re-Pag y Av-pag para usarlos en la busqueda del historial, espero a alguien mas le sea de interes este articulo.

Seteando el idioma del teclado

Ya habiamos visto como crear nuestros propios hotkeys, pero que sucede si cambiamos de teclado?

Lo hacemos con el comando loadkeys:

loadkeys /usr/share/keymaps/i386/qwerty/es.kmap.gz

Simplemente aplicamos lo siguiente para cambiar el mapa de teclado para el proximo arranque.

cd /usr/share/keymaps/i386/qwerty/
cp es.kmap.gz /etc/console/boottime.kmap.gz

Bash como un cgi

La potencialidad del bash scripting no se limita solo a las vty y consolas, teniendo un buen script perfectamente puede ser usado como un cgi.

Para que esto funcione deberemos empezar todo cgi-bash scripting de la siguiente forma:

#!/bin/bash
echo "Content-type: text/html"
echo ""

Con esto ya tenemos lo principal, ahora estamos listos para escribir nuestro primero bash script como cgi:

title="Mi primer cgi-bin en bash"
body="Hola mundo"
echo "<html><head><title>$title</title></head><body>$body</body></html>"