Estrategias Efectivas de Manejo de Errores en Scripts Bash

El manejo de errores en scripts Bash es importante porque un script que falla silenciosamente puede copiar archivos parciales, desplegar código roto o eliminar la ruta incorrecta. Quieres que tu script se detenga cuando un paso crítico falla, explique lo que sucedió y limpie los archivos temporales antes de salir.

Los patrones a continuación cubren las piezas que necesitas con más frecuencia: modo estricto, verificaciones explícitas, trap y reporte simple de errores.

La Base: Entendiendo el Estado de Salida

En el mundo Unix, cada comando ejecutado devuelve un estado de salida (o código de salida), un valor entero que indica el resultado de su operación. Este estado se almacena inmediatamente en la variable especial $?.

• Código de Salida 0: Por convención, esto significa éxito (o 'verdadero').
• Códigos de Salida 1–255: Estos significan fallo (o 'falso'). Códigos específicos a menudo se relacionan con tipos específicos de fallo (por ejemplo, 1 para errores generales, 127 para comando no encontrado).

Los scripts confiables deben verificar el estado de salida de los comandos críticos y devolver un código significativo distinto de cero si el script falla.

Estrategia Central 1: La Tríada de Scripting Defensivo

Para cualquier script de automatización serio, debes comenzar aplicando tres opciones fundamentales inmediatamente después de la línea shebang (#!/bin/bash). Estas opciones imponen un comportamiento estricto y predecible.

1. Salida Inmediata ante Fallo (set -e)

La opción set -e (o set -o errexit) dicta que el script debe salir inmediatamente si algún comando falla (devuelve un estado de salida distinto de cero).

Esto a menudo se conoce como el principio "fallar rápido" y evita que el script continúe con acciones potencialmente destructivas utilizando resultados previos incompletos o fallidos.

#!/bin/bash
set -e

echo "Iniciando proceso..."
mkdir /tmp/test_dir
cp archivo_inexistente /tmp/test_dir/ # Este comando falla (código de salida > 0)

echo "Esta línea no se ejecutará." # El script sale aquí

Advertencia: Limitaciones de set -e

set -e no desencadena una salida en varios contextos comunes, incluyendo comandos probados por if o while, comandos en la mayoría de listas && o ||, y comandos cuyo estado se invierte con !. Trátalo como una red de seguridad, no como un reemplazo de verificaciones claras alrededor de fallos esperados.

2. Tratar Variables No Definidas como Errores (set -u)

La opción set -u (o set -o nounset) asegura que el script trate el uso de cualquier variable no definida como un error, causando que el script salga inmediatamente (similar a set -e). Esto evita errores sutiles donde un error tipográfico en un nombre de variable lleva a que se pase una cadena vacía a un comando crítico.

#!/bin/bash
set -u

# echo "La variable es: $VARIABLE_NO_DEFINIDA" # El script falla y sale aquí

MI_VAR="definida"
echo "La variable es: ${MI_VAR}"

3. Manejo de Tuberías de Comandos (set -o pipefail)

Por defecto, una tubería de comandos (comando1 | comando2 | comando3) solo reporta el estado de salida del último comando (comando3). Si comando1 falla pero comando3 tiene éxito, $? será 0, ocultando el fallo.

set -o pipefail cambia este comportamiento, asegurando que la tubería devuelva un estado distinto de cero si algún comando en la tubería falla. Esto es crucial para el procesamiento de datos confiable.

#!/bin/bash
set -o pipefail

# El comando `false` siempre sale con 1
# Sin pipefail, esta línea devolvería 0 porque `cat` tiene éxito.
false | cat # Devuelve 1 debido a pipefail

if [ $? -ne 0 ]; then
    echo "La tubería falló."
fi

Mejor Práctica: El Encabezado

Siempre inicia scripts robustos con las opciones defensivas combinadas:

#!/bin/bash
set -euo pipefail

Estrategia Central 2: Verificaciones Manuales y Ejecución Condicional

Mientras que set -e maneja la mayoría de los fallos, a menudo necesitas verificar manualmente el estado del comando, particularmente cuando el fallo es esperado o necesita un registro específico.

La Verificación con if

La forma estándar de verificar el éxito de un comando es capturando su estado de salida dentro de un bloque if. Este método anula el comportamiento de set -e, permitiéndote manejar explícitamente el error.

#!/bin/bash
set -euo pipefail

ARCHIVO_TEMP="/tmp/procesamiento_datos_$$/config.dat"

# Intenta crear el directorio; maneja el fallo explícitamente
if ! mkdir -p "$(dirname "$ARCHIVO_TEMP")"; then
    echo "[ERROR] No se pudo crear el directorio temporal." >&2
    exit 1
fi

# Intenta obtener datos
if ! curl -sSf https://api.ejemplo.com/datos > "$ARCHIVO_TEMP"; then
    echo "[ERROR] Falló la obtención de datos desde la API." >&2
    exit 2
fi

echo "Datos recuperados exitosamente."

Consejo: Las banderas -sSf para curl (silencioso, fallo, mostrar errores) fuerzan a curl a devolver un código de salida distinto de cero en errores HTTP, facilitando el manejo de errores.

Usando Operadores de Cortocircuito (&& y ||)

Estos operadores lógicos proporcionan formas concisas de encadenar comandos basados en éxito (&&) o fallo (||).

• comando1 && comando2: Ejecuta comando2 solo si comando1 tiene éxito.
• comando1 || comando2: Ejecuta comando2 solo si comando1 falla.

# Ejemplo: Crear directorio Y copiar archivo, fallar si alguno de los pasos falla
mkdir logs && cp /var/log/syslog logs/system.log

# Ejemplo: Intentar respaldo, O registrar error y salir si el respaldo falla
pg_dump base_de_datos > backup.sql || { echo "¡Respaldo falló!" >&2; exit 10; }

Estrategia Avanzada 3: Limpieza Garantizada con trap

Cuando un script maneja archivos temporales, archivos de bloqueo o conexiones de red establecidas, las salidas abruptas (ya sea exitosas o debido a un error) pueden dejar el sistema en un estado inconsistente. El comando trap te permite definir un comando o función que se ejecutará cuando el script reciba una señal específica.

La Señal EXIT

La señal EXIT es la más útil para la limpieza general. El comando atrapado se ejecuta cada vez que el script sale, independientemente de si la salida fue exitosa, una llamada manual a exit, o una salida desencadenada por set -e.

#!/bin/bash

DIR_TEMP=$(mktemp -d)

# Definición de la función de limpieza
limpiar() {
    CODIGO_SALIDA=$?
    echo "Limpiando directorio temporal: ${DIR_TEMP}"
    rm -rf "$DIR_TEMP"
    # Si el script salió debido a un fallo, restaura el código de fallo
    if [ $CODIGO_SALIDA -ne 0 ]; then
        exit $CODIGO_SALIDA
    fi
}

# Establecer la trampa: Ejecutar la función 'limpiar' al salir del script
trap limpiar EXIT

# --- Lógica Principal del Script ---

echo "Procesando datos en ${DIR_TEMP}"

# Simular una operación exitosa...
# ... el script continúa ...

# Simular un fallo crítico que desencadena set -e
false

# Esta línea es inalcanzable, pero la limpieza aún está garantizada.
echo "Hecho."

Manejo de Señales Específicas (TERM, INT)

También puedes atrapar señales de terminación específicas como TERM (solicitud de terminación) o INT (interrupción, a menudo Ctrl+C) para asegurar un apagado ordenado cuando un usuario o programador cancela el trabajo.

trap 'echo "Script interrumpido por el usuario (Ctrl+C). Abortando limpieza." >&2; exit 130' INT

Estrategia 4: Reporte y Registro de Errores Personalizados

Un script profesional debe usar una función de error dedicada para centralizar el reporte, asegurando consistencia y canales de salida adecuados.

Redirigir Errores a la Salida de Error Estándar (>&2)

Los mensajes de error siempre deben imprimirse en la Salida de Error Estándar (stderr o descriptor de archivo 2), permitiendo que la Salida Estándar (stdout o descriptor de archivo 1) permanezca limpia para datos o resultados exitosos.

El Patrón de la Función die

Crea una función, a menudo llamada die o error_exit, que maneje el registro del mensaje, la limpieza (si no se usan trampas) y la salida con un código especificado.

# Función para imprimir mensaje de error y salir
die() {
    local msg=$1
    local code=${2:-1}
    echo "$(date +'%Y-%m-%d %H:%M:%S') [FATAL]: ${msg}" >&2
    exit "$code"
}

# Ejemplo de Uso:

VAR_REQUERIDA="$1"

if [ -z "$VAR_REQUERIDA" ]; then
    die "Falta argumento requerido (Nombre de la Base de Datos)." 3
fi

# ... más adelante en el script ...

if ! validar_checksum "$ARCHIVO"; then
    die "La verificación de checksum falló para $ARCHIVO." 5
fi

Haz que los Fallos Sean Aburridos

Para un manejo confiable de errores en scripts Bash, comienza cada script no trivial con set -euo pipefail, usa if ! comando; then ...; fi donde esperes que un comando pueda fallar, y envía errores a stderr. Si tu script crea archivos temporales, archivos de bloqueo o salida parcial, agrega trap limpiar EXIT antes de que comience el trabajo riesgoso.

Esa combinación mantiene las tareas pequeñas de automatización predecibles y facilita el diagnóstico de fallos en producción.