4backup : Programa para crear copias de seguridad (full, diferenciales e incrementales)

---

4backup : Shell Script

AVISO: Se ha modificado el script. Anteriormente a menos que tuviésemos un servidor de correos configurado en local o haciendo relay a una cuenta por ejemplo de gmail, era imposible ver si el programa fallaba por algún motivo (directorios inaccesibles, unidades externas no montadas, etc…). Ahora comprueba si el directorio $BASE permite la escritura y crea la jerarquía de directorios. En caso de fallo podremos acudir al log.

Este script pertenece a la segunda parte de la entrada Backups con tar: fullbackups, incrementales y diferenciales. Existe una tercera y última parte Usuario para crear respaldos con 4backup en la que crearemos un usuario restringido propietario y creador de los backups.

El script está bastante comentado ya que se creó como ejercicio de práctica del Capítulo -9 El entorno de Consola, Shell Scripts, el Correo Electrónico y uso básico de SQL en el que además aprenderemos a configurar el servidor de correos postfix para que haga relay a gmail y así recibir los email.

---

#!/bin/bash
##################################################################################

#                   | || | | |__   __ _  ___| | ___   _ _ _                      #
#                   | || |_| '_ \ / _` |/ __| |/ / | | | '_ \                    #
#                   |__   _| |_) | (_| | (__|   <| |_| | |_) |                   #
#                      |_| |_.__/ \__,_|\___|_|\_\\__,_| .__/                    #
#                                                      |_|                       #

##################################################################################

# 4backup crea copias de seguridad en función de los días pasado como parámetros.
# El primer parámetro determina que día se realiza fullbackup y el segundo y último
# parámetro indica el día para la copia diferencial.
# Para el resto de los días de la semana se crearán backups incrementales.
# Después de realizarse los fullbackups, estos serán comprobados y si todo es OK
# todas las copias anteriores a esos fullbackup serán eliminadas. Puede  adaptarse
# a necesidades, como por ejemplo en vez de eliminar las copias moverlas a otro disco.

##################################################################################
#                                                                                #
#                       autor: nebul4ck                                          #
#                       fecha: 28-3-2015                                         #
#                       última modificación: 27-7-2015                           #
#                       web: https://nebul4ck.wordpress.com                      #
#                                                                                #
##################################################################################

# Como se va a lanzar desde cron lo primero es ejecutar mediante source el archivo
# de configuración del entorno del usuario: ~.profile (Debian) o ~/.bash_profile
# (Red Hat)
. ~/.profile

# // VARIABLES A MODIFICAR POR EL USUARIO //

# Directorio BASE del programa 4backup (la raíz de los archivos y dir creados por 4backup).
BASE="/home/-USUARIO-/4backup"

# ¿ Donde se encuentra montado el disco externo en el que guardaremos las copias ?
MOUNTPOINT="/media/USB"

# ¿ En que directorio quieres que se guarden las copias de seguridad dentro del disco externo ?
DESTINO="$MOUNTPOINT/Mis Backups"

# Lista de directorios a respaldar
LISTA_DIR=(/home/jjgomez/Imágenes /opt/apps /usr/local/share)

# Si tenemos un servidor de correos local configurado o que haga relay a un correo de gmail por
# ejemplo, podremos recibir las alertas y el log por mail
EMAIL="usuario@hostname"

# // VARIABLES GLOBALES PARA 4BACKUP //

# Fecha usada para la extensión de los archivos tar
EXT="`date +%d%b%y.tar`"

# Día de la semana. Útil par cuando el programa comprueba que día de la semana es.
DIA=`date | cut -d" " -f1`

# Directorio donde serán guardados los snapshot de los backups con tar
SNAP="$BASE/4history"

# Directorio para archivos de registros (logs)
LOGS="$BASE/log"

# Archivo de registro
LOG="$BASE/log/4backup.log"

# Archivos de registros antiguos
OLDLOGS="$BASE/log/old"

# Archivo de emergencia. Usado cuando no ha sido posible iniciar el programa y ni
# enviar el correo al destino.
ARCHEMERG="$BASE/emerg.4backup"

# FUNCIONES

# Mostrar ayuda
help4backup() {
        echo -e "Especificar el día para copias full y el día para copias diferenciales (respectivamente).\nEl resto de días se realizarán copias incrementales\n"
        echo -e "\tEjemplo: ./4backup lun jue\n"
        echo -e "Nota: Los días en formato corto y Español"
        exit 0
}

# Función que comprueba si existen los directorios a respaldar
compruebaDir() {
if [ ! -d "$DIR" ]
then
                echo -e "ERROR: No es posible respaldar $DIR. El directorio no existe.\n"
                continue
fi
}

# Comprueba los Backups
checkBackup() {
        ESTADO="OK"
        if [ "$1" == "error" ]
        then
                ESTADO="ERROR"
                echo -e "\nEMERG: No se pudo verificar el archivador $TAR. Se recomienda revisar la última copia\n"
        elif [ "$1" == "$TAR".gz ]
        then
                echo -e "\nINFO: Comprobando backup...\n"
                if [ "$2" == "incremental" ]
                then
                        CAMBIOS=`tar -tf "$TAR".gz | wc -l`
                        echo -e "\nSe han realizado $CAMBIOS cambios - $(date "+[%x %X]")\n"
                fi
                gzip -vt "$TAR".gz
                if [ "$?" -ne "0" ]
                then
                        ESTADO="ERROR"
                else
                        echo -e "\nLa copia $TAR.gz ha finalizado correctamente - $(date "+[%x %X]")\n"
                fi
        fi
}

# Envía email
enviaCorreo() {
        exec &> /dev/null
        mail -s "$1" tudirección@gmail.com << EOF
Correo de notificación $(date "+[%x %X]")

$2



Aviso: Mensaje generado automáticamente.
EOF

if [ "$?" -ne "0" ]
then
        if [ "$RETORNO" == "error" ]
        then
                echo -e "Mail no enviado. Revise /var/log/mail.* o maillog\n\nEl error por el que la aplicación no ha iniciado es:\n$2" > "$ARCHEMERG"
        else
                echo -e "Mail no enviado. Revise /var/log/mail.* o maillog\n" >> "$LOG"
        fi
else
        echo -e "Mail enviado!\n"
fi
exit 0
}

# COMPROBACIONES PREVIAS

# Comprobar el número de parámetros y si estos coinciden
DIAS=(lun mar mié jue vie sáb dom)

if [ "$#" -lt "2" ] || [ "$#" -ge "3" ]
then
        help4backup
else
# Dos maneras diferentes de desplegar el contenido completo de un array @ y *
        if ! echo "${DIAS[@]}" | grep -qw "$1" && ! echo "${DIAS[*]}" | grep -qw "$2"; then help4backup; fi
fi

# Creamos el directorio base y log para registrar posibles errores durante la ejecución
if [ ! -d "$LOGS" ]
then
        mkdir -p "$LOGS" &>> /dev/null

        if [ "$?" -ne "0" ]
        then
                echo -e "No es posible escribir en el directorio base ($BASE). \nEl directorio $LOGS no puede ser creado.\nInterrumpiendo ejecución...\n"
                exit 1
        fi
fi

# Abrimos log
exec &> "$LOG"

# Comprueba que el dispositivo este montado, mediante mtab y su directorio (punto de montaje)
if ! cat /etc/mtab | grep -qw "$MOUNTPOINT"; then RETORNO="error" enviaCorreo "Dispositivo no montado" "El dispositivo ($MOUNTPOINT) no se encuentra montado. Abortado"; fi

for dir in "$DESTINO" "$BASE" "$SNAP" "$OLDLOGS"
do
    test -d "$dir" || mkdir -p "$dir" &>> /dev/null
    if [ "$?" -ne "0" ]
    then
        case "$dir" in
            "$DESTINO") MSG="No se pudo crear el directorio $DESTINO. Abortado.";;
            "$BASE") MSG="No se pudo crear el directorio $BASE. Abortado.";;
            "$SNAP") MSG="No se pudo crear el directorio $SNAP. Abortado.";;
            "$OLDLOGS") MSG="No se pudo crear el directorio $OLDLOGS. Abortado.";;
        esac
    enviaCorreo "Error al iniciar 4Backup" "$MSG"
    fi
done

# Abrimos log de ejecución
exec &> "$LOG"

# Inicia programa
for ((n=0;n<"${#LISTA_DIR[@]}";n++))
    {
# Seteamos variables para cada directorio a respaldar:
        DIR="${LISTA_DIR[$n]}"
# Esta es una forma de obtener el último campo de una línea (con egrep) en las copias diferenciales
# se muestra otra forma de obtener el último campo de línea con awk
        NOMBRE=`echo "$DIR" | egrep -o "[^/]+$"`
        HIST="$SNAP"/"$NOMBRE".snap

# Comprobamos si existe copia full de ese directorio:
        if [ ! -e "$HIST" ] || [ "$1" == "$DIA" ]
        then
            echo -e "----------------------------------------------------------------------------------------------"
            echo -e "La copia para $DIR será full.\n"
            TIPO="full"
        else
            if [ "$DIA" == "$2" ]
            then
                TIPO="dif"
            else
                TIPO="inc"
            fi
        fi

        case "$TIPO" in
        full)
            PREFIJO="full"
            TAR="$DESTINO"/"$PREFIJO"_"$NOMBRE"_"$EXT"
# Función que comprueba si existe el directorio a respaldar.
                        compruebaDir "$DIR"
                        if [ -f "$HIST" ]
                        then
# Se elimina el snapshot de tar para que la nueva copia sea full
                                rm "$HIST"
                                echo -e "Archivo histórico $HIST eliminado\n"
                        fi

                        echo -e "Iniciando FullBackup para $DIR\t $(date "+[%x %X]")\n"

# Nos movemos al directorio que queremos respaldar. De esta forma evitaremos agregar la ruta completa al archivo tar.
                        cd "$DIR"
# Podríamos haber hecho esto de otras maneras pero está es en la que mejor veremos lo que se hace. Primero se crea el tar full
# si el tar se ha finalizado correctamente se comprime con grado 8 y se llama a la función checkBackup para comprobar la compresión.
                        if tar -cpvWf "$TAR" -g "$HIST" *
                        then
                                 gzip -8f "$TAR"
# Función que comprueba el estado del backup e informamos
                                checkBackup "$TAR".gz
                        else
                                checkBackup "error"
                        fi

# Si se ha devuelto un valor positivo para la verificación de la copia entonces eliminamos la anterior. Si
# el valor devuelto es erróneo entonces no se elimina la anterior y se sigue con la siguiente copia
                        if [ "$ESTADO" == "OK" ]
                        then
                                echo -e "Buscando backups de $DIR anteriores a este último full..."
                                BACKOLD=`find "$DESTINO" -maxdepth 1 -type f -mmin +600 -name *_"$NOMBRE"_*.tar.gz |wc -l`

                                if [ "$BACKOLD" -eq "0" ]
                                then
                                        echo -e "No se han encontrado backups antiguos de $DIR para eliminar.\n"
                                else
                                        find "$DESTINO" -maxdepth 1 -type f -mmin +600 -name *_"$NOMBRE"_* -exec rm -f {} \; && echo -e "Backups anteriores encontrados y eliminados.\n"
                                fi
                        else
                                echo -e "El FullBackup anterior no será eliminado. Esta copia ha finalizado con errores\n"
                                FIN="ERROR"
                        fi
            ;;
        inc)
            PREFIJO="inc"
            TAR="$DESTINO"/"$PREFIJO"_"$NOMBRE"_"$EXT"
                        compruebaDir "$DIR"
                        echo -e "----------------------------------------------------------------------------------------------"
                        echo -e "Iniciando backup INCREMENTAL para $DIR $(date "+[%x %X]")\n"
                        cd "$DIR"
                        if tar -cpvWf "$TAR" -g "$HIST" *
                        then
                                gzip -8f "$TAR"
                                checkBackup "$TAR".gz "incremental"
                        else
                                checkBackup "error"
                                FIN="ERROR"
                        fi
        ;;
        dif)
            PREFIJO="dif"
            TAR="$DESTINO"/"$PREFIJO"_"$NOMBRE"_"$EXT"
# Con este método también podemos recuperar el último campo (awk)
                        TARFULL=`ls -l "$DESTINO" | grep full_"$NOMBRE" | awk '{printf $NF}'`
# Sacamos la fecha para que respaldemos solo desde la última full hasta el momento
                        FECHA=`date -r "$DESTINO"/"$TARFULL" "+%F %H:%M"`
                        compruebaDir "$DIR"
                        echo -e "----------------------------------------------------------------------------------------------"
                        echo -e "Iniciando backup DIFERENCIAL para $DIR $(date "+[%x %X]")\n"
                        cd "$DIR"
                        if tar -cpvWf "$TAR" * -N "$FECHA"
                        then
                                gzip -8f "$TAR"
                                checkBackup "$TAR".gz
                        else
                                checkBackup "error"
                                FIN="ERROR"
                        fi
        ;;
        esac
    }

# Enviamos email con los resultados. Comprobamos el día para setear el primer parámetro y si hubieron errores
# Con esta estructura condicional aprendemos a anidar if... elif.... else fi
if [ "$DIA" == "$1" ]
then
    BACKUP="FULLBACKUPS"
elif [ "$DIA" == "$2" ]
then
    BACKUP="DIFBACKUPS"
else
    BACKUP="INCBACKUPS"
fi

if [ -z "$FIN" ]
then
    CHECK="OK"
else
    CHECK="ERROR"
fi

#Para terminar hacemos una copia del log en el directorio de logs antiguos
cp "$LOG" "$OLDLOGS"/backup_"$(date +%d%b%y)".log

enviaCorreo  "$BACKUP - $CHECK" "$(cat $LOG)"

Descargarlo limpio de comentarios:

4backup

ATENCIÓN: El script del enlace está en formato doc. Una vez descargado eliminar la extensión o modificarla por .sh

4backup por nebul4ck se distribuye bajo una Licencia Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional.