Scripting Avanzado en Bash: Mejores Prácticas para el Manejo de Errores

El manejo de errores en scripts de Bash es lo que evita que un pequeño error de automatización se convierta en un desordenado problema de producción. Si una copia de seguridad falla, una llamada a la API devuelve un error, o un archivo temporal queda abandonado, tu script debería detenerse claramente y dejar el sistema en un estado conocido.

Usa estos patrones cuando tu script modifique archivos, despliegue código, se comunique con servicios remotos, o se ejecute sin que alguien esté mirando la terminal.

El Fundamento: Entendiendo los Códigos de Salida

Cada comando ejecutado en Bash, ya sea exitoso o fallido, devuelve un estado de salida (o código de salida). Este es el mecanismo fundamental para señalar los resultados del comando.

• Código de Salida 0: Indica ejecución exitosa. Por convención, cero significa éxito.
• Código de Salida 1-255 (No cero): Indica un error, fallo o advertencia. Códigos específicos no cero a menudo denotan tipos de error específicos (por ejemplo, 1 generalmente significa error genérico, 2 a menudo significa mal uso del comando del shell).

El estado de salida más reciente se almacena en la variable especial $?.

# Comando exitoso
ls /tmp
echo "Estado: $?"
# Estado: 0

# Comando fallido (archivo inexistente)
cat /archivo_inexistente
echo "Estado: $?"
# Estado: 1 (o superior, dependiendo del error)

Mejor Práctica Obligatoria: Implementando el Modo Estricto

Para cualquier script serio de Bash, tres directivas deben colocarse inmediatamente después de la línea shebang. Colectivamente, a menudo se les llama "modo estricto". Hacen que el script falle temprano en lugar de continuar después de un requisito previo roto.

1. Salir Inmediatamente ante un Error (set -e)

El comando set -e o set -o errexit le indica a Bash que salga inmediatamente del script si algún comando sale con un estado no cero. Esto previene fallos en cascada.

Advertencia: set -e se ignora en pruebas condicionales (if, while) o si un comando es parte de una lista && o ||. El estado de fallo debe ser usado explícitamente por la estructura circundante.

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

El comando set -u o set -o nounset hace que el script salga inmediatamente si intenta usar una variable que no ha sido establecida (por ejemplo, escribir mal $NOMBREDEARCHIVO en lugar de $NOMBRE_ARCHIVO). Esto previene errores difíciles de depurar resultantes de variables vacías o no intencionadas.

3. Manejar Errores en Tuberías (set -o pipefail)

Por defecto, si una serie de comandos se conecta en tubería (por ejemplo, cmd1 | cmd2 | cmd3), Bash reporta solo el estado de salida del último comando (cmd3). Si cmd1 falla, el script podría continuar ejecutándose exitosamente.

set -o pipefail asegura que el estado de salida de la tubería sea el estado de salida del último comando que falló, o cero si todos los comandos tuvieron éxito. Esto es crítico para el procesamiento confiable de datos.

Encabezado Estándar del Modo Estricto

Siempre inicia scripts avanzados con este encabezado robusto:

#!/bin/bash

set -euo pipefail

Algunas plantillas más antiguas también establecen IFS=$'\n\t'. Úsalo solo cuando entiendas cómo afecta la división de palabras en el resto del script. Citar variables y leer entrada con while IFS= read -r line suele ser más claro.

Verificación Condicional de Errores

Mientras que set -e maneja errores inesperados, a menudo necesitas verificar condiciones específicas o proporcionar mensajes de error personalizados.

Usando Sentencias if y Funciones Personalizadas

En lugar de depender únicamente de set -e, usa bloques if para manejar fallos potenciales conocidos de manera elegante y proporcionar una salida descriptiva.

# Define una función de error personalizada para consistencia
error_exit() {
    printf '[FATAL] %s\n' "$1" >&2
    exit 1
}

DIR_TEMP="/tmp/procesamiento_datos_$(date +%s)"

# Verifica si la creación del directorio fue exitosa
if ! mkdir -p "$DIR_TEMP"; then
    error_exit "Falló la creación del directorio temporal: $DIR_TEMP"
fi

echo "Directorio temporal creado exitosamente: $DIR_TEMP"

# Ejemplo de verificar si un archivo existe antes de procesarlo
ARCHIVO_A_PROCESAR="input.csv"

if [[ ! -f "$ARCHIVO_A_PROCESAR" ]]; then
    error_exit "Archivo de entrada no encontrado: $ARCHIVO_A_PROCESAR"
fi

Lógica de Cortocircuito (&& y ||)

Para operaciones secuenciales simples, usa operadores de cortocircuito. Esto es altamente legible y conciso.

• Cadena de Éxito (&&): El segundo comando se ejecuta solo si el primero tiene éxito.
• Captura de Fallo (||): El segundo comando se ejecuta solo si el primero falla.

# Ejecuta la configuración y luego procesa, fallando si la configuración falla
configurar_entorno && procesar_datos

# Intenta conectar, de lo contrario sale elegantemente con un mensaje
ssh usuario@servidor || { echo "Conexión fallida, verifica la configuración de red." >&2; exit 2; }

Terminación Elegante y Limpieza con trap

El comando trap permite que el script capture señales (como Ctrl+C, terminación del sistema, o salida del script) y ejecute un comando o función especificada antes de terminar. Esto es esencial para tareas de limpieza.

La Función cleanup

Define una función dedicada para revertir cualquier cambio (por ejemplo, eliminar archivos temporales, restablecer configuraciones) y usa trap para asegurar que se ejecute independientemente de cómo termine el script.

# Variable global para que la función de limpieza verifique
ARCHIVO_TEMP=""

cleanup() {
    printf '%s\n' "--- Ejecutando Procedimientos de Limpieza ---"
    if [[ -f "$ARCHIVO_TEMP" ]]; then
        rm -f "$ARCHIVO_TEMP"
        echo "Archivo temporal eliminado: $ARCHIVO_TEMP"
    fi
    # Opcionalmente, proporciona un informe final del estado de salida
}

# 1. Atrapar EXIT: Ejecuta la limpieza independientemente de éxito, fallo o señal.
trap cleanup EXIT

# 2. Atrapar señales (INT=Ctrl+C, TERM=Señal de matar)
trap 'printf "%s\n" "Script interrumpido por el usuario o señal del sistema." >&2; exit 130' INT
trap 'printf "%s\n" "Script terminado." >&2; exit 143' TERM

# --- Lógica Principal del Script ---
ARCHIVO_TEMP=$(mktemp)
echo "Contenido temporal" > "$ARCHIVO_TEMP"
# Si el script falla o es interrumpido aquí, se garantiza que cleanup() se ejecute

¿Por Qué Usar trap cleanup EXIT?

Establecer un trap en EXIT garantiza que la función de limpieza se ejecute ya sea que el script termine normalmente (exit 0), salga explícitamente con un error (exit 1), o sea forzado a terminar debido a set -e.

Reporte Avanzado de Errores

Los mensajes de error estándar (comando no encontrado) a menudo carecen de contexto. Los scripts avanzados deben reportar qué falló, dónde falló y por qué.

Registro de Números de Línea

Cuando se llama a una función como error_exit, puedes determinar el número de línea dentro del script donde ocurrió el error usando el arreglo BASH_LINENO o el comando caller (aunque caller a menudo está restringido a funciones).

Para reportes simples fuera de funciones, usa la variable LINENO:

# Ejemplo de reporte de fallo inmediato
(comando_riesgoso) || {
    echo "[ERROR $LINENO] comando_riesgoso falló con estado $?" >&2
    exit 3
}

Distinguiendo la Salida

Siempre envía mensajes informativos a la salida estándar (stdout) y mensajes de error/advertencia a la salida de error estándar (stderr). Esto es crucial si la salida de tu script se está canalizando a otro programa o registrando externamente.

• echo "Mensaje informativo" (va a stdout)
• echo "[ADVERTENCIA] Anulación de configuración" >&2 (va a stderr)

Pon el Patrón Junto

Para la mayoría de los scripts de producción, el patrón práctico es simple: comienza con set -euo pipefail, valida las entradas antes de hacer el trabajo, envuelve los fallos esperados en if ! comando; then ...; fi, y agrega trap cleanup EXIT antes de crear estado temporal.

Eso te da fallos útiles en lugar de fallos misteriosos. La próxima vez que un trabajo se rompa a las 2 a.m., el registro debería mostrar qué falló, dónde buscar y si la limpieza se ejecutó.