Por lo tanto lo que hice fue, seguramente, reinventar la rueda una vez más. Hice una pequeña librería en BASH que luego reutilicé en los distintos scripts de backup que hice. La clave aquí es la función “create_archive” que toma un path, un nombre de archivo base y una lista de archivos, y se ocupa de ir al path, ver todos los archivos que haya con ese patrón de nombre básico, rotarlos y generar un nuevo tar.gz. Después agregué un par de funciones más que me venían bien, “log” para registrar todo lo que pasaba en un archivo, “mail_notification” para mandarme mails y “sync_backup_servers” para ejecutar rsync.

El código:

Algunas consideraciones importantes.

Configuración

Al principio del script lo que hago es incluir un archivo de configuración con algunas variables básicas que voy a utilizar. Este archivo debería ser algo similar a esto:

LOCAL_DIR es el directorio local base donde van a estar mis backups. REMOTE_DIR es el directorio equivalente en el otro servidor. Lo que hice fue crear un usuario “sysbackup” (un poco menos obvio que “backup”, pero también self-explanatory) en los dos servidores y generar llaves para que se puedan conectar por SSH entre los dos servidores. Luego en la /home de cada usuario creé una carpeta “backup” y adentro de ella una carpeta para cada host que iba a ser backupeado “server1.domain.com” y “server2.domain.com”.

LOG_FILE indica el archivo donde se van a guardar los logs del backup y MAX_BKP_FILES determina la cantidad máxima de archivos de backup que va a haber por cada elemento.

Rotación

Como dije, la función más importante es create_archive. La pensé para logs que se crean una vez por día (o cada más tiempo), por lo que si la quieren usar para rotar logs generados en intervalos de tiempo más cortos van a tener que modificarla. Lo que hace es generar un nombre de archivo con una raiz elegida por nosotros (digamos “db”) y la fecha actual (la función pone la fecha, pero si necesitan intervalos más cortos van a tener que poner fecha y hora). Luego hace un `ls -t` del directorio donde hay que generar el backup para ver si hay otros archivos que coincidan con el patrón del nombre correspondiente (por ejemplo, ‘db_*.tar.gz’). Si hay archivos, va a conservar los últimos 4 (en realidad la cantidad la determina MAX_BKP_FILES) y va a borrar los más viejos. Por último, va a generar el tar.gz con la lista de archivos que le hayamos pasado.

Ejemplo:

Va a generar con un archivo de nombre como “web_20100902.tar.gz” en la carpeta $LOCAL_DIR/web con todos los contenidos de /var/www/html.

Rsync

La función sync_backup_servers hace la sincronización entre los dos servidores usando rsync por SSH. Una cosa a tener en cuenta es que en mi caso, yo necesitaba que el script de backup corriera como root (para poder acceder a todos los archivos que había que backupear) pero quería que el rsync se ejecutara con el usuario sysbackup (para mayor seguridad). Por lo tanto la función usa “su -c sysbackup”. Si a uds. este enfoque no les sirve pueden poner en la función directamente:

Notificaciones por mail

Es muy útil poder tener notificaciones por mail, sobre todo cuando las cosas andan mal. El comando “mail” de Linux/Unix es muy útil para esto. La funcion mail_notification usa ese comando para mandar un mail con el mensaje que queramos y le agrega dos datos útiles: la fecha y el hostname desde el que se manda. En realidad son datos que siempre viajan en los headers del mail, pero a mí me parecía útil que estuvieran en el body.

Espero que les sirvan estos recursos. No son una solución completa y cerrada, sino herramientas que quizás les sirvan para implementar o al menos pensar cómo hacer sus propios sistemas de backup. Les recomiendo enfáticamente que lean este artículo sobre cómo generar backups con rsync porque explica muchas cosas fundamentales.

$  wget --spider  --no-parent -r -o log.txt http://tuweb.com

Parámetros:

–spider : recorrer la web que le digas, pero SIN descargar nada. Sólo recorrerla.
- r : recursivo, como si fuera el robotito de Google
- o fichero : la salida de ejecutar el comando que salga por pantalla
–no-parent : si le pasamos como parámetro un nombre de directorio, no queremos que suba hacia los directorios padre.

La lista de enlaces rotos estará en log.txt (parte final)

Tomado de DiarioLinux.

Y agrego otro muy útil. Cómo descargar todos los contenidos de un sitio FTP con wget.

wget -r -q -b -P /home/myuser/destination ftp://mydomain.com --ftp-user=myuser --ftp-password=mypass

Parámetros:

-r: recursivo
-q: quiet/silencioso, no imprime mensajes en la consola
-b: background, para que se ejecute en background y nos devuelva el prompt.
-P: directorio donde queremos que se guarde todo lo que bajamos
–ftp-user=: usuario FTP
–ftp-password=: password FTP

En el entorno de Directadmin, los logs de Apache se encuentran en /var/log/httpd. Allí hay una carpeta “domains” que guarda los logs de cada dominio. Por cada dominio hay tres logs: dominio.com.log, dominio.com.error.log y dominio.com.bytes. El primero es el access_log, el segundo el error_log y el tercero solamente guarda la cantidad de bytes de cada request. La opción más sencilla es trabajar con este último tipo de logs, pero el problema que tienen es que no indican la fecha. Si bien se supone que los logs de Directadmin rotan una vez por día, alguna vez me ha pasado que por razones que nunca pude descubrir, algunos logs no rotaban y generaban ciertas confusiones. Por lo tanto, el script que dejo usa los access_logs. Además esta opción es reutilizable en otras implementaciones de Apache que no tengan archivos de bytes.

El código:

Un detalle importante: el script levanta todos los archivos de un directorio que se especifica por parámetro. Esto es así porque yo lo invoco desde otro script:

Este último script lo que hace es crear un directorio temporal (si no existe). Vaciar su contenido. Y luego generar hardlinks a todos los access_logs de /var/log/httpd/domains. De esta forma, no me tengo que preocupar por si los logs son modificados mientras yo estoy ejecutando el script. Por último, ejecuta mi primer script (access_log_parser.sh) y le pasa como parámetro el directorio temporal donde están los access_logs.

Por último, la salida del script sería algo así:

...
186.995 MB (196078184 bytes) | From: 10/Mar/2010:00:27:47 | To: 10/Mar/2010:16:51:09 | dominio1.com.ar.log
187.096 MB (196184596 bytes) | From: 10/Mar/2010:03:24:55 | To: 10/Mar/2010:16:51:24 | dominio2.com.ar.log
245.692 MB (257626221 bytes) | From: 10/Mar/2010:02:53:50 | To: 10/Mar/2010:16:39:54 | dominio3.com.log
273.46 MB (286743390 bytes) | From: 10/Mar/2010:02:48:33 | To: 10/Mar/2010:14:59:29 | dominio4.com.ar.log
306.344 MB (321224473 bytes) | From: 10/Mar/2010:00:23:09 | To: 10/Mar/2010:16:51:20 | dominio5.com.ar.log
444.097 MB (465669066 bytes) | From: 10/Mar/2010:00:49:35 | To: 10/Mar/2010:16:51:20 | dominio6.com.ar.log
Generated in 6 seconds

Les dejo, de yapa, la opción del script utilizando los logs de bytes. Como dije, esta opción es un poco más sencilla y veloz, pero no nos dice las fechas de los logs.

Y la salida sería así:

# ./parser.sh /var/log/httpd/domains
...
181.716 MB (190543470 bytes) dominio1.com.bytes
187.115 MB (196203973 bytes) dominio2.com.ar.bytes
189.093 MB (198278283 bytes) dominio3.com.ar.bytes
245.692 MB (257626221 bytes) dominio4.com.bytes
273.472 MB (286756234 bytes) dominio5.com.ar.bytes
314.32 MB (329588717 bytes) dominio6.com.ar.bytes
444.516 MB (466108759 bytes) dominio7.com.ar.bytes
Generated in 2 seconds

El script utiliza ffmpeg y mutt. Pueden instalarlos poniendo

sudo apt-get install ffmpeg mutt

Para que Mutt funcione se tiene que usar con un MTA, por default postfix. Se puede instalar con Exim o con SSMTP. Este último es una especie de wrapper que nos permite configurar un MTA externo para enviar los mails. Esta guía explica bien cómo hacerlo.

#!/bin/bash
IMG_SIZE="320x240"
CAM_DEV="/dev/video0"

IMG_NAME="`mktemp -u /tmp/img.XXXXXX`.jpg"

mutt=/usr/bin/mutt
ffmpeg=/usr/bin/ffmpeg
date=`date`
hostname=`hostname`

echo "Taking picture and saving it on $IMG_NAME"

$ffmpeg -f video4linux2 \
	-s $IMG_SIZE \
	-r 5 \
	-vframes 1 \
	-i $CAM_DEV \
	-f mjpeg \
	$IMG_NAME > /dev/null 2>&1

if [ ! -z $1 ]; then
	echo "Attempting to email the picture to $1"
	echo "Picture taken on $hostname at $date" | \
		$mutt -s "A picture was sent to you" -a $IMG_NAME -- $1
fi

Para ejecutarlo, copiamos el contenido en un archivo, por ejemplo “cam.sh”. Luego le damos permisos de escritura y lo ejecutamos.

# chmod +x cam.sh
# ./cam.sh "myaddress@domain.com"

Entre las utilidades de este script podríamos pensar en sacar una foto de la persona en frente de la máquina cuando se produce un login incorrecto o en algún otro evento que pudiera darnos la pauta de un uso diferente al usual. Ideal para paranóicos y nerds obsesivos.

GNU/Linux

Luego del post de ayer, pensando en que vengo posteando poco, me puse a buscar a ver si tenía algún otro script útil que pudiera compartir por este medio… pero no encontré nada. Algo debo tener por ahí, pero nada a mano. Lo que encontré es este script (medio feo) que hice hace bastante tiempo, que muestra un netstat (concretamente netstat -natp) con distintos colores según el estado de cada conexión (established, listen, syn_sent, fyn_wait, etc.). Claramente no es un script muy útil (ni muy bien hecho), pero lo publico. Quizás a alguno le sirve de disparador para hacer algo verdaderamente útil.

#!/bin/bash
cyan="\E[1;36m\E[1m";
normal="\E[m";
blue="\E[34m\E[1m";
violet="\E[35m\E[1m";
red="\E[31m\E[1m";
yellow="\E[33m\E[1m";
green="\E[37m\E[32m\E[1m";
text="\E[1;37m\E[1m";

if [ "$UID" != "0" ]; then
	echo -e "$red$0: You will get more information if you have root privileges. Try sudo $0$normal"
fi

netstat -natp | \
while read line; do

	if [ `echo $line | awk '{print($1)}'` = "Proto" ]; then
		echo -e "$yellow=====================================================================================================$normal"
		echo -e "$text$line$normal"
		echo -e "$yellow=====================================================================================================$normal"
	else

		state=`echo $line | awk '{print($6)}'`
		color=$normal
		case $state in
			"ESTABLISHED")
				color=$green;;
			"SYN_SENT" | "SYN_RECV")
				color=$yellow;;
			"FIN_WAIT1" | "FIN_WAIT2" |"TIME_WAIT")
				color=$violet;;
			"CLOSE" | "CLOSE_WAIT" | "LAST_ACK" | "CLOSING" )
				color=$blue;;
			"LISTEN")
				color=$cyan;;
			"UNKNOWN")
				color=$red;;
			*)
		esac
		echo -e "$color$line$normal"

	fi
done;

Nota: el script utiliza el comando netstat con los parámetros “natp”. Estos parámetros de esta forma solamente funcionan en GNU/Linux. Para otros sistemas Unix (Solaris, FreeBSD, etc.) será necesario adaptar los parámetros y ver si la salida del netstat es igual.

En estos días necesitaba hacer un backup de todas las bases de datos de un servidor MySQL, pero no me servía hacer mysqldump –all-databases, porque necesitaba tenerlo en archivos separados (uno para cada DB). Seguramente es algo que ya debe haber sido hecho mil veces, pero no tenía tampoco muchas ganas de perder mucho tiempo en Google (una búsqueda rápida no me dio resultados útiles), así que hice el siguiente script muuy sencillo que obtiene todas las DB de un server y hace un dump de cada una. Se los dejo por si les sirve, capaz los saque de un apuro en alguna ocasión.

#!/bin/bash
PORT="3306"
USER="root"
PASSWORD="yourpassword"
mysql=/usr/bin/mysql
mysqldump=/usr/bin/mysqldump

TABLES=`$mysql -P $PORT -u $USER --password=$PASSWORD --execute="SHOW DATABASES;" |awk '{print($1)}' |grep -v "Database" |grep -v "information_schema"`
for table in $TABLES; do
	echo "Backing up $table..."
	file=$table.backup_`date +%Y%m%d`.sql
	$mysqldump -P $PORT -u $USER --password=$PASSWORD $table > $file
	echo "Compressing backup..."
	gzip $file
done

Nota: la definición del puerto es innecesaria, pero yo la tuve que hacer porque en mi caso el servidor no estaba corriendo en el puerto default (3306) sino en otro.

GNU/Linux

A decir verdad esto es un poco inutil, pero estuve jugando recientemente con BASH (con un script que espero poder terminar en cuanto tenga tiempo, y que si funciona bien publicaré aquí), y en algún momento de delirio se me ocurrió que podría usar una especie de daemon en BASH. La verdad que no es una muy buena alternativa ni un gran uso del lenguaje, seguramente usando otro lenguaje tendría un daemon mejor y para usar BASH probablemente sería más sencillo usar un cron. Pero estaba aburrido y se me ocurrió hacerlo. Por lo tanto, no lo tomen como algo particularmente útil, sino como un ensayo que me sirvió para practicar un poco con este lenguaje que lo tenía medio dejado de lado.

Este daemon no es más que un proceso que corre (“desatachandose” de la consola), con un while(1) y va imprimiendo un texto. En un uso normal, adentro del while iría alguna tarea repetitiva definida por la finalidad del demonio. El script recibe un parámetro opcional (que puede ser “start” o “shutdown”) para iniciar y detener el daemon. Cuando se inicia llama a la función “start” que hace un sanity check para ver si hay otra instancia del demonio corriendo, y si no la hay ejecuta la función “main” que es donde está el while. Otra cosa importante a notar: para que el script se “desatachee” de la consola, el while está dentro de un bloque delimitado por llaves ({}) con un ampersand al final (&). En todo caso también se podría agregar ahí una redirección del output y el error stream.

Sin más introducción, les dejo el script.

#!/bin/bash

function sanityCheck {
    q=`ps -ef |grep $0 |grep -v "grep"|grep -v $$| wc -l`
    if [ $q != "0" ]; then
        echo "Another instance of $0 running..."
        exit 1
    fi
}

function start {
    sanityCheck
    echo "Starting daemon..."
    main
}

function shutdown {
    echo "Shutting down daemon..."
    kill `ps -ef |grep $0|grep -v $$ |grep -v "grep"|awk '{print($2)}'`
}

function main {
    {
        while [ 1 ]; do
            echo "Test..."
            sleep 2
        done
    } &
}

case $1 in
    "start")
       start
    ;;
    "shutdown")
        shutdown
    ;;
     *)
         start
     ;;
esac

Uso:

# chmod +x ./daemon.sh
# ./daemon.sh
Starting daemon...
Test...
# Test...Test...Test...
# ./daemon.sh shutdown
Shutting down daemon...
#

GNU/Linux

Leo en Slashdot que ya está disponible la versión 4.0 de BASH (Bourne-Again Shell), el shell Unix desarrollado por GNU.

Además de solucionar bugs de releases previos, se introducen nuevas funcionalidades. Entre las más notables se encuentran los arrays asociativos, mejoras en la funcionalidad de completado programable, expresiones regulares para modificar mayúsculas/minúsculas, co-procesos, agregados a la sintaxis, redirecciones, etc.  Según indica el artículo de Slashdot, se modificó el shell para que sea más riguroso al parsear sustituciones de comandos, corrigiendo una parte que no era compatible con POSIX.

Para los que no quieran esperar a que las distros actualicen sus repositorios pueden obtener el código fuente de aquí.

Para más detalles sobre las novedades pueden ver el anuncio en inglés.

Editado 24/02/2009: Este anuncio es más completo (también en inglés).

Apache Web Server

Bueno, en mi último post publiqué un script muy sencillo en Python para contar la cantidad de requests por IP en un access_log de Apache. Como sospechaba, había una forma quizás más sencilla y más óptima de hacer lo mismo en BASH, así que hace un rato jugando un poco me salió y se los muestro aquí.

# cat /var/log/httpd/access_log |awk '{print($1)}'|sort |uniq -c |sort

¿Cómo funciona?

Lo primero que hacemos es abrir el archivo con cat, el contenido se pasa a awk con el cual obtenemos la primera columna (lo mismo lo podríamos hacer con cut, pero estoy más acostumbrado a awk). Eso nos devuelve la lista de las IPs. Eso lo pasamos a sort que ordena las IPs antes de poder pasarselo a uniq. Éste último comando, con el parámetro -c se ocupa de contar las líneas repetidas en un listado ordenado (por eso el sort anterior). Y por último le volvemos a pasar todo a sort para que lo ordene en forma ascendente de acuerdo a la cantidad de ocurrencias de cada IP.

En realidad el script de Python lo ordenaba al revés (en forma descendente), para ello deberíamos pasarle el parámetro “-r” al último sort.

Espero que les sea de utilidad. La versión de Python queda sobre todo como base por si es necesario hacer algo un poco más interesante jeje.

Mi problema es que necesitaba saber cuáles eran los dominios de un servidor que alojaba más de 300 que estaban teniendo mayor tráfico. Como no tenía ninguna herramienta en tiempo real que me pudiera reportar esta información para el Apache, lo que hice es un script que revisa los access_log de cada dominio y obtiene la cantidad de bytes traficados por cada uno.

En este caso, cada VirtualHost define un archivo de logs diferente para cada dominio. Los access_log usan el formato combined (que incluye User-Agent, etc.) y no especifican nada más. El script no hace ninguna validación al respecto, así que podría no funcionar con logs en otros formatos.

Debe tenerse en cuenta que si los archivos de logs rotan en base a su tamaño, es probable que se presente el siguiente caso: El dominio web1.com tiene gran cantidad de tráfico y el dominio web2.com todo lo contrario. El access_log correspondiente al primer dominio puede reportar el tráfico de 1 Gb en un día y el access_log del segundo puede reportar tráfico también de 1 Gb pero en 6 meses. Por lo tanto, es importante mantener referencia de las fechas extremas de los logs, para poder dar cuenta de estas circunstancias.

Hechas estas aclaraciones, pasamos a la explicación del script.

¿Cómo funciona?

Muy sencillo. El script recorre todos los archivos de logs (1 por dominio). Por cada uno obtiene la fecha inicial (la del primer request registrado) y la final (la del último). Luego suma la cantidad de bytes de todos los requests registrados, e imprime una fila con esa cifra en megabytes, kilobytes, bytes y el rango de fechas que abarca. El conjunto de todas esas líneas es enviada al sort de GNU para ordenar las líneas de menor a mayor cantidad de tráfico.

Quizás suene medio complejo, pero se entenderá mejor viendo el código.

El Script

BASE_DIR=/tmp/domain_logs

dateToStamp ()
{
    if [ ${#1} -eq 19 ]; then
        date --utc --date "$1" +%s;
    else
        echo 0
    fi
}

formatDate ()
{
    echo $1 | awk 'BEGIN { \
                    dict["Jan"]=1; \
                    dict["Feb"]=2; \
                    dict["Mar"]=3; \
                    dict["Apr"]=4; \
                    dict["May"]=5; \
                    dict["Jun"]=6; \
                    dict["Jul"]=7; \
                    dict["Aug"]=8; \
                    dict["Sep"]=9; \
                    dict["Oct"]=10; \
                    dict["Nov"]=11; \
                    dict["Dec"]=12 \
                    } { \
                        split(substr($1, 2), a, /[\\\/:]+/); \
                        print a[3] "-" dict[a[2]] "-" a[1] " " a[4] ":" a[5] ":" a[6] \
                    }'
}

for file in `ls $BASE_DIR/*`;
do
    from=$(formatDate `head -1 $file | awk '{print($4)}'`)
    to=$(formatDate `tail -1 $file | awk '{print($4)}'`)
    stamp_from=$(dateToStamp "$from")
    stamp_to=$(dateToStamp "$to")
    total_time=$(($stamp_to-$stamp_from))
    bytes=`cat $file | awk '{a+=$10}END{print a}'`
    kbytes=$((bytes/1024))
    mbytes=$((kbytes/1024))
    echo  "$mbytes MB | \
           $kbytes KB | \
           $bytes Bytes | \
           From: $from ($stamp_from) | \
           To: $to ($stamp_to) | \
           $total_time secs | \
           ${file:${#BASE_DIR}+1}"
done \
| sort -nb

Como se puede ver, al principio se define la variable BASE_DIR, que es el directorio base donde el script va a buscar los access logs. Cuando ejecuto el script, para evitar problemas de cambios en tiempo real, creo un snapshot con todos los archivos de logs y los guardo en una carpeta (en este caso /tmp/domain_logs).

# cp /var/log/httpd/domains/*.access.log /tmp/domain_logs/

Luego, trabajo directamente sobre el snapshot. Entonces, como se observa en el script, defino dos funciones que utilizo más abajo, dateToStamp y formatDate. Como sus respectivos nombres indican, la primera convierte una fecha en un unix timestamp y la segunda cambia el formato de la fecha que figura en el archivo de logs por el que a mi me sirve para pasarle a date. Esto seguramente es mucha complicación para algo que podría hacer usando mejor el comando date, pero fue lo que más rápido me resultó hacer.

Y luego está el for, que recorre los archivos y por cada uno obtiene las fechas límite ($from y $to), de allí obtiene los timestamps ($stamp_from, $stamp_to), el tiempo total en segundos y la cantidad de bytes (la cual sumo con awk).

Por último, verán que la salida del for tiene un pipe a sort, a quien le paso los parámetros “n” y “b”. Para que haga un ordenamiento numérico ignorando los espacios en blanco.

Ejemplo

# ./access_log_parser.sh
97 MB | 99901 KB | 102299281 Bytes | From: 2008-11-28 02:25:54 (1227839154) | To: 2008-11-28 15:34:12 (1227886452) | 47298 secs | domain1.com.ar.log
115 MB | 118260 KB | 121098817 Bytes | From: 2008-11-28 02:27:45 (1227839265) | To: 2008-11-28 15:34:26 (1227886466) | 47201 secs | domain2.com.ar.log
123 MB | 126652 KB | 129691792 Bytes | From: 2008-11-28 02:27:53 (1227839273) | To: 2008-11-28 15:33:01 (1227886381) | 47108 secs | domain3.com.ar.log
145 MB | 149279 KB | 152862681 Bytes | From: 2008-11-28 02:30:29 (1227839429) | To: 2008-11-28 15:34:31 (1227886471) | 47042 secs | domain4.com.ar.log
189 MB | 194517 KB | 199185477 Bytes | From: 2008-11-28 04:35:20 (1227846920) | To: 2008-11-28 15:32:58 (1227886378) | 39458 secs | domain5.com.log
197 MB | 202034 KB | 206883560 Bytes | From: 2008-11-28 02:35:55 (1227839755) | To: 2008-11-28 15:34:29 (1227886469) | 46714 secs | domain6.com.ar.log
499 MB | 511816 KB | 524099937 Bytes | From: 2008-11-28 02:25:44 (1227839144) | To: 2008-11-28 15:34:29 (1227886469) | 47325 secs | domain7.com.ar.log
#

Comentarios

Por última vez, aclaro que es algo que hice con cierto apuro y que es ampliamente mejorable. Estoy abierto a sus comentarios y sugerencias para mejorar el script. También, si conocen alguna forma de monitorear esto en tiempo real, también me sería de gran utilidad.

Descargar

Pueden descargar el script de aquí.