De “¿Qué es una shell?” a un script en el que podáis confiar en producción

Casi todos los servidores Linux, imágenes de contenedores y ejecutores de integración continua que lleguéis a tocar tienen algo en común: un intérprete de comandos llamado Bash esperando al otro lado. Es el programa que lee lo que escribís, decide qué significa y hace que la máquina lo ejecute. La mayoría de las personas que trabajan con él a diario lo aprendieron por imitación —copiando comandos de un manual de procedimientos, de un compañero o de un resultado de búsqueda— sin que nunca se les enseñaran las reglas que la propia shell sigue. Eso funciona hasta el día en que un comando hace algo sutilmente diferente a lo que habíais previsto, y nada en la pantalla os dice por qué.

GNU Bash Fundamentals es un curso para principiantes, basado en el manual de referencia oficial GNU Bash (Bash 5.3), que cierra esa brecha. Comienza con la pregunta “¿qué es una shell?” y termina con algo que la mayoría de los operadores en activo nunca llegan a alcanzar: un script robustecido con modo estricto, traps y control de tareas (job control) —uno que podáis programar, dejar en segundo plano y en el que podáis confiar para que falle de forma evidente en lugar de silenciosa.

Bash, en términos sencillos

Tres ideas sostienen todo el curso.

La primera es que Bash es un intérprete de comandos: un programa que lee líneas de texto y las ejecuta. En un prompt interactivo, lee lo que escribís. Cuando ejecutáis un archivo script, lee el archivo. El mismo intérprete, las mismas reglas, razón por la cual todo lo que aprendáis mientras escribís de forma interactiva se transfiere directamente a la escritura de scripts.

La segunda es que el texto es la moneda universal de la shell. Hacéis una pregunta —¿existe este archivo?, ¿qué hay en este directorio?— y la respuesta vuelve como texto en la pantalla, con un exit status numérico independiente que registra silenciosamente si el comando tuvo éxito. Ese pequeño número es el booleano de Bash: cero significa éxito, cualquier otro valor significa fallo, y cada decisión que toma un script es, en realidad, una pregunta sobre ello.

La tercera es que la shell realiza su trabajo en etapas bien definidas: divide vuestra línea en palabras (a menos que el entrecomillado diga lo contrario), expande variables y patrones, conecta la entrada y la salida entre comandos, y solo entonces ejecuta cualquier cosa. Una vez que podéis ver esas etapas, el comportamiento confuso —un glob inesperado, una variable que “perdió” sus espacios— se vuelve predecible en lugar de misterioso.

M1 — Fundamentos de Bash y la shell interactiva

El curso abre con qué es realmente una shell y qué hace Bash, cómo se inicia Bash y cómo trabajar de forma eficiente en el prompt interactivo usando el historial, el autocompletado y los alias.

“Bash se inicia” es la parte que realiza el trabajo real en esa frase. Dependiendo de cómo os conectéis —una consola de inicio de sesión, una ventana de terminal dentro de un escritorio, un script ejecutado por un planificador— Bash lee diferentes archivos de inicio en un orden específico, y ese orden explica por qué un alias funciona en vuestra terminal pero desaparece en una tarea programada. El curso recorre esa secuencia de inicio en pantalla y luego enseña las herramientas de velocidad cotidiana: recordar y editar comandos anteriores con el historial, completar nombres de archivos y nombres de comandos con Tab, y definir alias para que vuestros atajos personales vivan en un archivo en lugar de en la memoria muscular.

El módulo también establece la base práctica del curso —un pequeño “Bash Lab” de elementos fijos y una configuración de laboratorio a la que volveréis constantemente— para que los módulos posteriores puedan practicar con datos realistas en lugar de ejemplos de juguete.

M2 — Comandos, entrecomillado, redirección y tuberías

El segundo módulo cubre cómo Bash analiza y ejecuta comandos, cómo controlar el entrecomillado y la división de palabras (word splitting), y cómo redireccionar la entrada/salida y encadenar comandos con tuberías (pipelines).

Este es el módulo donde la idea de las “etapas” da sus frutos. La división de palabras (word splitting) es la razón por la que una variable sin entrecomillar que contiene espacios se convierte en varios argumentos, y el entrecomillado —comillas simples, comillas dobles y las reglas de escape entre ellas— es la herramienta que lo controla. Los principiantes se encuentran con estas reglas como errores inexplicables; aquí son una gramática pequeña y aprendible.

Luego vienen los dos movimientos que hacen que la línea de comandos parezca un superpoder. La redirección envía las corrientes de entrada, salida y error de un comando a archivos o dispositivos en lugar de a la terminal —incluyendo la distinción crucial entre la salida estándar (los resultados) y el error estándar (las quejas). Las tuberías (pipelines) encadenan comandos para que la salida de uno se convierta en la entrada del siguiente: buscar en un registro, ordenar los aciertos, contar los resultados —cada etapa realizando una pequeña tarea.

M3 — Variables, expansiones y arrays

El tercer módulo cubre las variables de la shell y del entorno, el kit completo de expansión de parámetros (parameter expansion), la aritmética y los arrays indexados/asociativos.

Las variables vienen en dos sabores con una regla que los principiantes deben interiorizar: una variable de shell normal vive y muere con un proceso de shell, mientras que una variable de entorno exportada es heredada por cada proceso hijo que inicia. El tipo que uséis decide si la configuración de vuestro script llega realmente a los programas que llama.

El kit de expansión es la estrella silenciosa del módulo. La misma sintaxis de signo de dólar que lee una variable también proporciona valores por defecto para valores faltantes, salvaguardas que abortan un script cuando falta un valor requerido, recorte de subcadenas, recorte basado en patrones de nombres de archivos y extensiones, y búsqueda y reemplazo —todo sin lanzar un solo comando externo. Añadid la aritmética de enteros en paréntesis dobles, además de los arrays indexados y asociativos de Bash, y podréis almacenar y dar forma a datos reales totalmente dentro de la shell. El módulo cierra cargando un archivo de inventario realista en un array y formateándolo en un informe alineado con printf, sin herramientas externas involucradas.

M4 — Flujo de control, funciones y vuestros primeros scripts

El módulo final cubre condicionales, bucles y funciones, y luego los combina en un script real robustecido con modo estricto, traps y control básico de tareas (job control).

Todo lo anterior a este módulo enseñaba movimientos individuales; este enseña programas. Las decisiones se basan en la idea del exit status de M2: if ramifica si un comando tuvo éxito, case despacha según patrones, y los operadores de prueba hacen preguntas sobre archivos, cadenas y números. Los bucles repiten el trabajo —recorriendo una lista de servidores con for, procesando un archivo de registro línea por línea con while read. Las funciones dan al script partes con nombre, reutilizables, con variables privadas (local) y códigos de retorno honestos, y getopts analiza las banderas de la línea de comandos de la forma estándar.

Luego, el proyecto final convierte un script funcional en uno fiable. El modo estricto —set -euo pipefail— hace que el script se detenga en el primer comando que falle, en la primera variable no definida y en las tuberías (pipelines) que fallen en su inicio. Los traps garantizan que se ejecute una limpieza en cada ruta de salida, incluso cuando el script se interrumpe. Los códigos de salida significativos dan a los planificadores algo sobre lo que actuar. Y el control de tareas —tareas en segundo plano (background), wait, kill, disown— cubre el trabajo que debe ejecutarse junto a otro trabajo. La práctica construye este script dos veces: frágil, observando cómo falla silenciosamente, y luego robustecido, observando cómo se detecta y limpia el mismo fallo.

Lo que seréis capaces de hacer

Al final del curso, la lista completa de funciones se lee como habilidades en lugar de palabras de moda: navegación por la shell interactiva y edición de líneas; historial de comandos y autocompletado; entrecomillado y división de palabras (word splitting); redirección y tuberías (pipelines); variables de shell frente a variables de entorno; expansión de parámetros (parameter expansion) y sustitución de comandos; aritmética de shell y arrays; condicionales, bucles y funciones; exit status, modo estricto y traps; y tareas en segundo plano (background) y control de tareas (job control).

Más importante aún, entenderéis por qué existe cada una de ellas —qué se rompe sin ellas— —la diferencia entre depurar con confianza y copiar comandos esperando que funcionen.

Primeros pasos

Cada módulo combina presentaciones teóricas con guías prácticas que se ejecutan contra el Bash Lab en vivo del curso, además de una comprobación de conocimientos para confirmar que las ideas han quedado grabadas. Si habéis usado una terminal antes pero nunca se os han enseñado las reglas que hay debajo, empezad en el Módulo 1 —la shell que ya usáis todos los días está a punto de empezar a tener sentido.