Bash script y utilidades: guía completa para automatizar Linux

Informatec Digital » Recursos » Bash script y utilidades: guía completa para automatizar Linux

Si trabajas con Linux a diario -ya sea administrando servidores, cacharreando con contenedores o desarrollando aplicaciones- dominar bash scripting es probablemente la habilidad que más tiempo te va a ahorrar. Con unos pocos archivos de texto y algo de imaginación puedes automatizar desde copias de seguridad hasta despliegues complejos, pasando por tareas rutinarias que hoy haces a mano sin darte cuenta.

En esta guía vamos a ver, con calma pero en profundidad, cómo usar scripts bash y colecciones de utilidades para llevar tus scripts de «cuatro comandos sueltos» a herramientas realmente profesionales. Partiremos de los conceptos básicos de shell, veremos comandos esenciales, estructuras de control, funciones, arrays, depuración, cron… y también algunos repositorios de funciones y GUI en Bash que elevan tus scripts a otro nivel.

Qué es Bash y por qué es tan útil para automatizar

Bash (Bourne Again Shell) es el intérprete de comandos más extendido en sistemas tipo Unix: la gran mayoría de distribuciones Linux lo traen como shell por defecto, y también lo encuentras en macOS o en Windows a través de WSL o terminales tipo Git Bash. Es, a la vez, una interfaz interactiva y un lenguaje de scripting.

Cuando abres una terminal, Bash te muestra un prompt donde puedes escribir comandos. Cada comando sigue normalmente la estructura comando argumentos. Todo lo que sabes hacer «a mano» en la terminal se puede meter en un fichero de texto para ejecutarlo en bloque.

Un script bash no es más que un archivo de texto plano con una lista de comandos que la shell ejecuta uno tras otro. Ahí está la magia: en vez de teclear 10 comandos cada día, los guardas, les das permisos de ejecución y los lanzas con un solo paso. Además, puedes añadir variables, condicionales, bucles y funciones para tomar decisiones, repetir tareas y encapsular lógica.

Bash, además, sigue la filosofía clásica de Unix: muchas herramientas pequeñas que hacen una cosa muy bien y se combinan con pipes. Con un solo script puedes encadenar find, grep, sed, awk, tar y gzip, ssh, scp y cualquier otra utilidad del sistema para crear procesos de administración y mantenimiento muy potentes.

Conceptos básicos de shell y scripting en Bash

Para entender bien el scripting en Bash hay que separar dos ideas: la shell y el propio scripting. La shell es ese programa que interpreta los comandos, y el scripting es el proceso de agrupar esos comandos en un archivo ejecutable.

Un script típico comienza siempre con una línea especial llamada shebang. Esa primera línea le dice al sistema qué intérprete debe usar para ejecutar el fichero. Lo habitual es ver algo como:

#!/bin/bash

También puedes usar #!/usr/bin/env bash para que el sistema busque Bash en el PATH. Esto da más flexibilidad si la ruta al ejecutable no es exactamente /bin/bash, algo que a veces ocurre en entornos más exóticos.

Los scripts se guardan generalmente con extensión .sh (por claridad, no porque sea obligatorio) y debes darles permiso de ejecución con chmod +x nombre_script.sh. A partir de ahí, puedes lanzarlos con ./nombre_script.sh o llamando directamente a bash:

bash nombre_script.sh
./nombre_script.sh

Es importante entender también los conceptos de stdin, stdout y stderr: la entrada estándar (teclado, o lo que le redirijas), la salida estándar (pantalla) y la salida de errores. Saber redirigir estos flujos y combinarlos es clave para escribir scripts limpios y fáciles de depurar.

Ventajas reales de usar scripts Bash en tu día a día

Usar Bash para automatizar no es una manía de administradores viejunos, tiene ventajas muy claras. Con un único archivo puedes empaquetar secuencias largas de comandos y ejecutarlas tantas veces como quieras, de forma consistente y sin despistes.

La primera gran ganancia es la automatización. En vez de repetir pasos a mano cada vez que despliegas una app o haces una copia de seguridad, dejas todo escrito en un script y lo lanzas cuando toque (o lo programas con cron). Menos trabajo manual, menos errores tontos.

Otra ventaja importante es la portabilidad. Mientras los comandos que uses estén disponibles, tu script funcionará en cualquier distro Linux, en macOS o incluso en Windows con un entorno Bash. Esto hace que muchas tareas sean fáciles de migrar entre entornos.

Los scripts también son muy transparentes: al final son texto plano. Cualquiera puede abrirlos, revisar qué hacen y ajustarlos. No necesitas compilar nada ni descifrar binarios. Y si los combinas con Git, tienes versionado y auditoría de cambios gratis.

Por último, aprender Bash es razonablemente sencillo. Si sabes moverte algo por la terminal y tienes nociones mínimas de programación (variables, if, bucles), vas a ponerte al día rápido. Y el retorno de esa inversión de tiempo es enorme en términos de productividad.

Creación y estructura básica de un script Bash

Montar tu primer script es casi trivial, pero conviene hacerlo bien desde el principio. Un esqueleto mínimo de script Bash incluiría shebang, comentarios informativos, cuerpo del script y salida controlada.

Lo habitual es empezar con:

#!/bin/bash
# Descripción: pequeño script de ejemplo
echo "Hola, mundo"

Aunque parezca una tontería, es buena idea documentar siempre al principio qué hace el script, qué parámetros espera y algún ejemplo rápido de uso. Esa información se puede añadir con comentarios, que en Bash empiezan por # y el intérprete ignora por completo.

Después de la cabecera, escribes la lógica: definición de variables, lectura de entrada, llamadas a comandos, funciones, bucles, condicionales… todo lo que necesites para automatizar la tarea que tengas entre manos.

Otro detalle importante es terminar el script devolviendo un código de salida coherente con exit N. El código 0 significa éxito y cualquier otro valor indica error. Ese valor se puede consultar desde fuera con $?, lo que te permite encadenar scripts y reaccionar a fallos.

Comentarios, variables y tipos de datos en Bash

Los comentarios son tus amigos: sirven para explicar qué hace una parte del script, por qué se ha tomado una decisión, o qué demonios piensa hacer ese bucle extraño dentro de seis meses cuando ya no te acuerdes. Como en muchos lenguajes, en Bash empiezan con # y llegan hasta el final de la línea.

En cuanto a las variables, Bash es de lo más permisivo: no hay tipos formales, todo son cadenas y el shell decide si interpretar algo como número cuando se lo pides. Para asignar usas nombre=valor sin espacios alrededor del igual:

pais="España"
numero=42

Para leer el contenido de una variable la antepones con $: por ejemplo, $pais. Si quieres mayor claridad o concatenar textos complejos, es preferible usar ${pais} para delimitarla bien.

Hay que tener cuidado con las comillas. Con comillas dobles, Bash interpreta las variables y algunas secuencias especiales («$var», «\n»). Con comillas simples, todo el contenido se trata como texto literal: ‘$var’ se imprime tal cual, sin expandir.

También existen variables especiales para manejar argumentos y contexto: $# (número de argumentos), $0 (nombre del script), $1, $2… (argumentos posicionales), $? (código de salida del último comando), $$ (PID del proceso), entre muchas otras que conviene tener localizadas.

Entrada y salida en scripts Bash

Un script útil rara vez vive aislado: suele pedir datos al usuario, leer de archivos, procesar logs o escribir resultados a disco. Para eso necesitas dominar bien read, echo y las redirecciones.

La forma más sencilla de leer algo que escriba el usuario es con read:

echo "Introduce tu nombre:"
read nombre
echo "Hola, $nombre"

Para volcar texto a la salida estándar usamos echo o printf. Echo es más simple y rápido de escribir, printf te da un control total del formato (alineaciones, decimales, etc.). También puedes redirigir cualquier salida con > (sobrescribir) o >> (añadir al final) hacia un fichero.

Por ejemplo, para guardar un «Hola mundo» en un archivo:

echo "Hola mundo" > hola.txt

O para añadir líneas sin borrar lo anterior:

echo "Otra línea" >> hola.txt

Si quieres separar salidas normales de errores, recuerda que stdout es el descriptor 1 y stderr es el 2. Puedes enviarlos a ficheros diferentes o incluso tirarlos a /dev/null si no te interesan:

comando 1>salida.txt 2>errores.txt
comando >/dev/null 2>&1

Comandos Bash imprescindibles para scripting

Todo script Bash se apoya en un conjunto de comandos básicos de sistema. Muchos los usas ya a diario, pero conviene tener clara su sintaxis cuando los metes en scripts: un espacio mal colocado o una ruta rara y se te cae medio proceso.

Para navegar por el sistema tienes pwd (muestra el directorio actual) y cd (cambia de carpeta). Para listar contenidos, ls con sus mil opciones. Crear directorios se hace con mkdir, borrar ficheros con rm (con mucho cuidado) y mover/copiar con mv y cp.

Los comandos de inspección de texto típicos son cat (muestra archivos), tac (al revés), head, tail, y las herramientas de filtrado como grep, sed y awk. Son la base para crear scripts que analicen logs, apliquen sustituciones masivas o extraigan datos concretos.

A nivel de sistema, merece la pena conocer ps y top para procesos, kill para finalizar, df y du para espacio en disco, y systemctl para gestionar servicios en sistemas con systemd. Todos estos comandos se integran de forma natural dentro de scripts.

Por último, no olvides man: el manual. Casi cualquier duda sobre opciones y comportamiento de un comando se responde con man comando. Saber leer una página de manual con soltura es media carrera de administrador hecha.

Estructuras de control: condicionales y bucles

En cuanto tus scripts crecen un poco vas a necesitar que tomen decisiones y repitan acciones. Ahí entran en juego las estructuras de control: if/else, case, while, until y for.

El condicional clásico en Bash utiliza if junto con o ] para evaluar condiciones. Por ejemplo, para comprobar si un número es mayor que 10:

read num
if ]; then
  echo "El número es mayor a 10"
else
  echo "El número es menor o igual a 10"
fi

La sintaxis ] es más moderna y segura que , y permite operadores lógicos más cómodos y manejo mejorado de cadenas. Para varios casos predefinidos, case resulta muy legible, especialmente cuando tienes múltiples valores esperados:

read n
case $n in
  101)  echo "Primer número" ;;
  510)  echo "Segundo número" ;;
  999)  echo "Tercer número" ;;
  *)    echo "Sin coincidencias" ;;
esac

En el apartado de bucles, while repite mientras se cumpla una condición, until hace justo lo contrario (repite hasta que la condición sea cierta) y for sirve para iterar sobre listas, arrays o rangos numéricos. Por ejemplo, un for para recorrer días de la semana:

for dia in Lunes Martes Miércoles Jueves Viernes Sábado Domingo; do
  echo "Día: $dia"
done

Y un while típico con contador interno:

i=0
while ]; do
  echo $i
  ((i++))
done

Funciones en Bash: reutilizar lógica sin volverte loco

Las funciones en Bash te permiten agrupar comandos y reutilizarlos tantas veces como quieras, haciendo que el script sea mucho más limpio y manejable. A partir de cierto tamaño, si no usas funciones, acabas con un monstruo difícil de mantener.

Se pueden declarar de dos formas equivalentes:

hola() {
  echo "Hola desde una función"
}

function hola2 {
  echo "Hola también"
}

Para invocarlas, basta con escribir su nombre en una línea como si fueran un comando más. No se ejecutan por el mero hecho de estar definidas, así que no olvides llamarlas desde el cuerpo del script.

Las funciones reciben parámetros posicionales exactamente igual que el script: dentro de la función usas $1, $2, $#, etc. Puedes devolver un código numérico con return N (pensado para indicar éxito o error) y variables globales para devolver resultados más ricos como cadenas o arrays.

Además, puedes marcar variables como local dentro de una función para que no «contaminen» el resto del script. Esto es muy recomendable para evitar pisar valores globales por accidente.

Arrays y manejo de texto en Bash

Aunque Bash no es un lenguaje pensado para cálculos complejos, sí maneja arrays y operaciones sobre cadenas suficientes para muchas tareas de automatización. Saber usarlos amplía bastante lo que puedes hacer en unos pocos comandos.

Un array simple se define así:

frutas=(Pera Manzana Plátano)

Accedes a elementos individuales con ${frutas}, obtienes todos con ${frutas}, el número de elementos con ${#frutas} y los índices usados con ${!frutas}. Esto último es útil cuando hay «huecos» en el array y quieres iterar solo sobre posiciones válidas.

Para recorrerlo entero puedes usar un for sobre los índices:

for i in ${!frutas}; do
  echo "frutas = ${frutas}"
done

Sobre cadenas de texto, Bash soporta bastantes operaciones integradas: longitud (${#cad}), subcadenas (${cad:N:M}), sustituciones (${cad/ant/nuevo}, ${cad//ant/nuevo}), recortes de prefijo y sufijo (${cad#texto}, ${cad%texto}), etc. Estas herramientas evitan tirar de sed o awk para tareas sencillas.

Para manipulación de texto más seria -por ejemplo logs grandes o datos tabulares- ya entran en juego grep, sed, awk, cut y compañía, que puedes encadenar en pipes o integrar directamente en funciones Bash.

Permisos, ejecución y cron: de script suelto a tarea programada

Una vez tienes tu script hecho, hay que hacerlo ejecutable y decidir cómo lo vas a lanzar. El paso típico es aplicar:

chmod +x mi_script.sh

A partir de ahí, puedes ejecutarlo con ./mi_script.sh si estás en el mismo directorio, o bien referenciando su ruta absoluta: /ruta/completa/mi_script.sh. Otra opción es invocarlo a través de bash mi_script.sh sin darle permisos de ejecución, aunque no es lo más habitual en entornos productivos.

Cuando quieres que el script se ejecute de forma periódica (diaria, semanal, cada 5 minutos, etc.) entra en escena cron. Con crontab -e editas la tabla de tareas del usuario y puedes definir cosas como:

0 0 * * *   /ruta/backup.sh
*/5 * * * * /ruta/monitor.sh

La primera línea ejecuta un script a medianoche todos los días; la segunda, cada 5 minutos. Los campos indican minuto, hora, día del mes, mes y día de la semana, en ese orden. Con crontab -l ves lo que ya tienes programado.

Si algo falla, lo más sensato es mirar los logs del sistema. En Debian/Ubuntu, los mensajes de cron se suelen registrar en /var/log/syslog. Revisarlos te dirá si el job ha corrido, si ha petado por permisos o si ni siquiera llega a lanzarse.

Depuración, buenas prácticas y variables especiales de Bash

Depurar scripts Bash tiene su truco porque, por defecto, la shell sigue ejecutando aunque algún comando falle. Para poner orden, conviene activar un modo estricto y usar las opciones de depuración que ofrece Bash.

Colocar al principio del script algo como:

set -euo pipefail
set -x

hace que el script pare en el primer error (-e), trate variables no definidas como fallo (-u), detecte errores en pipelines (pipefail) y muestre cada comando expandido antes de ejecutarlo (-x). Durante el desarrollo esto es oro puro; en producción quizá prefieras activar -x solo en secciones concretas.

Además de BASH_REMATCH (muy útil con expresiones regulares), Bash tiene variables internas como BASH_SUBSHELL (nivel de subshell actual), BASH_ENV (archivo que se carga al iniciar un subshell), BASH_EXECUTION_STRING (comando que se está ejecutando) o BASH_VERSION (versión del intérprete). Todas ellas te ayudan a adaptar el comportamiento del script según el entorno, depurar problemas raros o asegurar compatibilidad.

Como buenas prácticas adicionales, es recomendable usar nombres de variable descriptivos, evitar palabras reservadas, documentar funciones, validar siempre la entrada del usuario y comprobar los códigos de salida de comandos críticos (copias de seguridad, borrados, movimientos masivos).

Y no olvides herramientas externas como ShellCheck, que analiza tus scripts y avisa de errores sutiles, malas prácticas y construcciones peligrosas. Integrarlo en tu editor o en tu pipeline CI/CD es una forma sencilla de subir el nivel de calidad.

Colecciones de utilidades Bash y GUIs para tus scripts

Además de lo que trae Bash de serie, existen frameworks y colecciones de funciones muy potentes alojados en GitHub que puedes «enchufar» en tus propios scripts usando source. Esto te permite incorporar en segundos utilidades que, de otra forma, te costaría mucho tiempo desarrollar.

Un ejemplo es Bashmatic, un framework con cientos de funciones que facilitan desde el formateo de salida y logs hasta la ejecución concurrente de tareas, la gestión de configuraciones o la interacción con servicios externos. Está muy orientado a dar feedback claro al desarrollador mientras se ejecuta el script, algo que se agradece cuando tus procesos duran minutos u horas.

Para ejecutar tareas en paralelo, proyectos como bash-concurrent proporcionan una función lista para usar que lanza varios trabajos a la vez y muestra una salida ordenada a medida que van terminando. Esto es ideal para scripts que deben procesar muchos elementos independientes (varios servidores, ficheros, etc.).

Si necesitas interfaces gráficas ligeras sobre Bash, hay proyectos como EasyBashGUI o Script-Dialog que generan diálogos GUI o TUI en función de lo que tengas instalado: kdialog, zenity, whiptail, dialog… De esta forma, un mismo script puede funcionar bien tanto si lo lanzas desde un entorno gráfico como desde una terminal pura.

La idea general con estas librerías es siempre la misma: descargas o clonas el repositorio, y en tu script añades una línea tipo source /ruta/a/utilidades.sh. A partir de ahí, todas las funciones definidas en ese archivo pasan a estar disponibles en tu script, como si fueran propias.

Al final, dominar Bash scripting y conocer algunas utilidades de terceros te da una caja de herramientas enorme para automatizar Linux (y entornos similares) sin perder tiempo reinventando la rueda. Desde pequeños scripts personales hasta procesos críticos de administración de sistemas, la combinación de comandos bien conocidos, estructuras de control claras, buenas prácticas de depuración y librerías externas convierte a Bash en una pieza clave de cualquier flujo de trabajo técnico serio.