: gnu; 01 Septiembre 2026

Cómo aprender Bash creando 20 scripts útiles para administrar Linux y automatizar servidores

Autor: Carlos Monje | Publicado: 01/09/2026

gnubash

Aprender Bash no consiste en memorizar comandos sueltos, sino en convertir tareas repetitivas de Linux en scripts útiles, seguros y reutilizables. Si administras servidores, sitios web, bases de datos, servicios, backups o entornos DevOps, Bash puede ayudarte a automatizar revisiones, reportes, alertas, limpieza, respaldos y diagnósticos.

GNU Bash es una shell ampliamente usada en sistemas GNU/Linux, y su manual oficial documenta cómo ejecuta scripts, cómo maneja parámetros, condicionales, expansiones, variables y comandos. Un script Bash suele empezar con una línea shebang, como #!/usr/bin/env bash, para indicar con qué intérprete debe ejecutarse.

Idea central: la mejor forma de aprender Bash es construir scripts reales: uno para revisar disco, otro para hacer backup, otro para analizar logs, otro para revisar servicios, otro para auditar usuarios, y así convertir la administración Linux en un flujo automatizado.

1. Qué debes dominar antes de crear scripts

Antes de escribir scripts complejos, domina cinco bases: variables, argumentos, condicionales, bucles y manejo de errores. Bash permite usar parámetros posicionales como $1, $2 y $@; también ofrece expansiones de parámetros para valores por defecto, validaciones y sustituciones.

Plantilla base segura para scripts Bash

#!/usr/bin/env bash
set -Eeuo pipefail

log() {
echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*"
}

error() {
echo "ERROR: $*" >&2
exit 1
}

[[ ${EUID:-$(id -u)} -eq 0 ]] || error "Ejecuta este script con sudo o root."

log "Script iniciado"

Elemento	Para qué sirve
set -e	Detiene el script cuando un comando falla.
set -u	Evita usar variables no definidas.
pipefail	Detecta errores dentro de tuberías de comandos.
funciones	Permiten organizar tareas repetidas.

2. Cómo practicar: 20 scripts, 20 habilidades reales

Estos 20 scripts están pensados para aprender administrando. No son ejercicios artificiales: son tareas que un administrador Linux puede necesitar en servidores reales. Algunos son de monitoreo, otros de seguridad, otros de backup y otros de diagnóstico.

Precaución: prueba primero en un laboratorio, máquina virtual o servidor no crítico. Los scripts que eliminan archivos, reinician servicios o modifican reglas deben revisarse antes de usarse en producción.

Script 1: revisar uso de disco y alertar

Este script enseña variables, condicionales, porcentajes y salida legible. GNU Coreutils documenta herramientas como df para reportar uso de sistemas de archivos y du para estimar espacio usado por archivos y directorios.

01-disco-alerta.sh

#!/usr/bin/env bash
set -Eeuo pipefail

UMBRAL="${1:-80}"

df -hP | awk 'NR>1 {gsub("%","",$5); if ($5 >= u) print $0}' u="$UMBRAL"

echo "Revisión terminada. Umbral: ${UMBRAL}%"

Script 2: encontrar carpetas que consumen más espacio

Este script usa du, ordenamiento y argumentos. Sirve para detectar rápidamente qué directorios llenan un servidor.

02-top-carpetas.sh

#!/usr/bin/env bash
set -Eeuo pipefail

RUTA="${1:-/var}"
LIMITE="${2:-15}"

sudo du -xh "$RUTA" 2>/dev/null | sort -h | tail -n "$LIMITE"

Script 3: backup incremental con rsync

rsync es una herramienta clásica para sincronizar archivos. Su manual documenta el modo archivo -a, opciones de borrado como --delete y muchas funciones para copias locales o remotas.

03-backup-rsync.sh

#!/usr/bin/env bash
set -Eeuo pipefail

ORIGEN="${1:-/var/www/}"
DESTINO="${2:-/backup/www/}"
LOG="/var/log/backup-rsync.log"

mkdir -p "$DESTINO"

rsync -aAXHv --delete "$ORIGEN" "$DESTINO" | tee -a "$LOG"

echo "Backup terminado: $(date)" | tee -a "$LOG"

Script 4: comprimir logs antiguos

Este script enseña uso de find, fechas, compresión y limpieza controlada. Es útil para servidores que generan logs pesados.

04-comprimir-logs.sh

#!/usr/bin/env bash
set -Eeuo pipefail

RUTA="${1:-/var/log}"
DIAS="${2:-7}"

sudo find "$RUTA" -type f -name "*.log" -mtime +"$DIAS" ! -name "*.gz" -print0 |
while IFS= read -r -d '' archivo; do
gzip -9 "$archivo"
echo "Comprimido: $archivo"
done

Script 5: revisar servicios fallidos en systemd

systemd permite administrar servicios y unidades; los timers permiten programar tareas como alternativa moderna a cron en muchos entornos Linux.

05-servicios-fallidos.sh

#!/usr/bin/env bash
set -Eeuo pipefail

echo "Servicios fallidos:"
systemctl --failed --no-pager

echo
echo "Últimos errores del sistema:"
journalctl -p err -b --no-pager -n 50

Script 6: reiniciar un servicio solo si está caído

Este script enseña condicionales, argumentos y acciones con systemctl.

06-reiniciar-si-caido.sh

#!/usr/bin/env bash
set -Eeuo pipefail

SERVICIO="${1:?Uso: $0 nombre_servicio}"

if systemctl is-active --quiet "$SERVICIO"; then
echo "$SERVICIO está activo."
else
echo "$SERVICIO está caído. Reiniciando..."
sudo systemctl restart "$SERVICIO"
systemctl status "$SERVICIO" --no-pager
fi

Script 7: listar puertos abiertos y procesos asociados

Este script ayuda a detectar servicios expuestos. Es útil para seguridad, diagnóstico y resolución de conflictos de red.

07-puertos-abiertos.sh

#!/usr/bin/env bash
set -Eeuo pipefail

echo "Puertos TCP/UDP en escucha:"
sudo ss -tulpen

Script 8: detectar procesos que consumen más CPU y memoria

Con este script aprendes a usar ps, ordenamiento y reportes rápidos para detectar saturación.

08-top-procesos.sh

#!/usr/bin/env bash
set -Eeuo pipefail

echo "Top CPU:"
ps aux --sort=-%cpu | head -n 10

echo
echo "Top memoria:"
ps aux --sort=-%mem | head -n 10

Script 9: revisar usuarios con shell interactiva

Este script permite auditar cuentas que pueden iniciar sesión. Es útil para seguridad básica en servidores.

09-usuarios-shell.sh

#!/usr/bin/env bash
set -Eeuo pipefail

awk -F: '$7 ~ /(bash|sh|zsh)$/ {print $1, $3, $6, $7}' /etc/passwd

Script 10: auditar claves SSH autorizadas

Este script enseña búsqueda de archivos, permisos y revisión de accesos remotos.

10-auditar-ssh-keys.sh

#!/usr/bin/env bash
set -Eeuo pipefail

sudo find /home /root -name authorized_keys -type f -print |
while read -r archivo; do
echo "==== $archivo ===="
sudo ls -l "$archivo"
sudo sed 's/ .*/ .../' "$archivo"
done

Script 11: revisar intentos fallidos de SSH

Este script ayuda a analizar logs de autenticación en Debian/Ubuntu y RHEL/Rocky/AlmaLinux.

11-ssh-fallidos.sh

#!/usr/bin/env bash
set -Eeuo pipefail

LOG_AUTH="/var/log/auth.log"
LOG_SECURE="/var/log/secure"

if [[ -f "$LOG_AUTH" ]]; then
sudo grep -Ei "failed|invalid user|authentication failure" "$LOG_AUTH" | tail -n 50
elif [[ -f "$LOG_SECURE" ]]; then
sudo grep -Ei "failed|invalid user|authentication failure" "$LOG_SECURE" | tail -n 50
else
echo "No se encontró auth.log ni secure."
fi

Script 12: generar reporte básico del servidor

Este script combina varios comandos para crear un informe rápido: hostname, kernel, CPU, memoria, disco, red y servicios fallidos.

12-reporte-servidor.sh

#!/usr/bin/env bash
set -Eeuo pipefail

SALIDA="reporte-$(hostname)-$(date +%Y%m%d).txt"

{
echo "REPORTE DEL SERVIDOR"
echo "Fecha: $(date)"
echo "Hostname: $(hostname -f 2>/dev/null || hostname)"
echo "Kernel: $(uname -a)"
echo
echo "CPU:"
lscpu | head
echo
echo "Memoria:"
free -h
echo
echo "Disco:"
df -hT
echo
echo "Red:"
ip -brief address
echo
echo "Servicios fallidos:"
systemctl --failed --no-pager
} > "$SALIDA"

echo "Reporte generado: $SALIDA"

Script 13: buscar errores recientes en journalctl

journalctl permite consultar logs de systemd por prioridad, arranque, unidad y rango de tiempo. Es una herramienta clave para diagnosticar fallos en servidores modernos.

13-errores-journal.sh

#!/usr/bin/env bash
set -Eeuo pipefail

HORAS="${1:-24}"

journalctl --since "${HORAS} hours ago" -p warning..alert --no-pager

Script 14: analizar IPs con más visitas en Nginx

Este script enseña análisis de logs con awk, sort y uniq. Ayuda a detectar picos, bots o abuso.

14-top-ips-nginx.sh

#!/usr/bin/env bash
set -Eeuo pipefail

LOG="${1:-/var/log/nginx/access.log}"

sudo awk '{print $1}' "$LOG" | sort | uniq -c | sort -nr | head -n 20

Script 15: detectar códigos HTTP 500, 502, 503 y 504

Este script ayuda a identificar errores de backend, caídas de upstream, saturación o problemas de aplicación.

15-errores-http.sh

#!/usr/bin/env bash
set -Eeuo pipefail

LOG="${1:-/var/log/nginx/access.log}"

sudo awk '$9 ~ /^50[0-9]/ {print $0}' "$LOG" | tail -n 100

Script 16: comprobar certificados TLS próximos a vencer

Este script consulta un dominio y calcula cuántos días faltan para que expire su certificado. Es útil para evitar caídas por certificados vencidos.

16-certificado-vencimiento.sh

#!/usr/bin/env bash
set -Eeuo pipefail

DOMINIO="${1:?Uso: $0 dominio.com}"
PUERTO="${2:-443}"

FIN=$(echo | openssl s_client -servername "$DOMINIO" -connect "$DOMINIO:$PUERTO" 2>/dev/null 
| openssl x509 -noout -enddate | cut -d= -f2)

FIN_EPOCH=$(date -d "$FIN" +%s)
HOY_EPOCH=$(date +%s)
DIAS=$(( (FIN_EPOCH - HOY_EPOCH) / 86400 ))

echo "$DOMINIO vence en $DIAS días. Fecha: $FIN"

Script 17: revisar actualizaciones disponibles

Este script detecta si el sistema usa APT, DNF o YUM y muestra actualizaciones pendientes. Enseña condicionales y detección de comandos.

17-actualizaciones.sh

#!/usr/bin/env bash
set -Eeuo pipefail

if command -v apt >/dev/null 2>&1; then
sudo apt update
apt list --upgradable 2>/dev/null
elif command -v dnf >/dev/null 2>&1; then
sudo dnf check-update || true
elif command -v yum >/dev/null 2>&1; then
sudo yum check-update || true
else
echo "Gestor de paquetes no soportado en este script."
fi

Script 18: limpiar archivos temporales antiguos

Este script automatiza limpieza controlada. No borra todo: solo archivos antiguos y bajo una ruta definida.

18-limpiar-temporales.sh

#!/usr/bin/env bash
set -Eeuo pipefail

RUTA="${1:-/tmp}"
DIAS="${2:-10}"

echo "Archivos a eliminar en $RUTA con más de $DIAS días:"
find "$RUTA" -type f -mtime +"$DIAS" -print

read -r -p "¿Eliminar? Escribe SI: " RESP
[[ "$RESP" == "SI" ]] || exit 0

find "$RUTA" -type f -mtime +"$DIAS" -delete
echo "Limpieza terminada."

Script 19: verificar integridad básica de archivos críticos

Este script crea hashes SHA-256 de archivos importantes. Sirve para detectar cambios posteriores.

19-hashes-criticos.sh

#!/usr/bin/env bash
set -Eeuo pipefail

SALIDA="hashes-criticos-$(date +%Y%m%d).sha256"

sudo sha256sum 
/etc/passwd 
/etc/group 
/etc/sudoers 
/etc/ssh/sshd_config 
2>/dev/null | tee "$SALIDA"

echo "Archivo generado: $SALIDA"

Script 20: menú de administración del servidor

Este script integra varias tareas en un menú. Es ideal para practicar case, funciones y control de flujo. El manual de Bash documenta condicionales como if, case, select y expresiones condicionales.

20-menu-admin.sh

#!/usr/bin/env bash
set -Eeuo pipefail

while true; do
echo
echo "=== MENÚ ADMIN LINUX ==="
echo "1) Ver disco"
echo "2) Ver memoria"
echo "3) Ver servicios fallidos"
echo "4) Ver puertos abiertos"
echo "5) Salir"
read -r -p "Opción: " op

case "$op" in
1) df -hT ;;
2) free -h ;;
3) systemctl --failed --no-pager ;;
4) sudo ss -tulpen ;;
5) exit 0 ;;
*) echo "Opción no válida" ;;
esac
done

3. Cómo ejecutar correctamente tus scripts

Guarda cada archivo con extensión .sh, dale permisos de ejecución y ejecútalo desde terminal. En servidores, guarda scripts propios en rutas como /usr/local/sbin o /opt/scripts, y documenta quién los creó, qué hacen y cuándo se ejecutan.

Ejecución básica

chmod +x 01-disco-alerta.sh
./01-disco-alerta.sh 85

4. Automatizar con cron o systemd timers

Cuando un script funciona bien, puedes programarlo. cron ejecuta tareas en horarios definidos mediante crontab; systemd timers permiten programar unidades systemd, lo que facilita logs con journalctl e integración con servicios.

Ejemplo con cron: backup diario a las 2:30 a. m.

crontab -e

30 2 * * * /usr/local/sbin/03-backup-rsync.sh /var/www/ /backup/www/ >> /var/log/backup-cron.log 2>&1

5. Revisar calidad con ShellCheck y pruebas con Bats

Antes de usar scripts en producción, revisa errores comunes con ShellCheck. Su sitio oficial lo describe como una herramienta de análisis para encontrar bugs en scripts de shell. Para pruebas automatizadas, Bats se presenta como un framework de pruebas compatible con TAP para Bash 3.2 o superior, útil para probar scripts y programas Unix.

Validar scripts

shellcheck *.sh

# Ejemplo simple con Bats

bats tests/

6. Buenas prácticas para scripts Bash profesionales

Usa shebang claro: #!/usr/bin/env bash.
Activa modo estricto: set -Eeuo pipefail.
Cita variables: usa "$VARIABLE" para evitar errores con espacios.
Valida argumentos: no asumas que el usuario ingresó bien los datos.
No borres sin confirmar: especialmente con rm, find -delete o --delete.
Registra logs: todo script automático debe dejar evidencia.
Haz pruebas: primero en laboratorio, luego en producción.
Usa ShellCheck: ayuda a detectar errores antes de ejecutar.
Documenta: objetivo, autor, fecha, parámetros y ejemplos.
Controla permisos: no des permisos de escritura a todos.

7. Ruta de aprendizaje recomendada

Nivel	Qué practicar	Scripts ideales
Básico	Variables, argumentos, salida de comandos.	Disco, carpetas, reporte del servidor.
Intermedio	Bucles, condicionales, logs, systemctl.	Servicios, SSH, puertos, logs Nginx.
Avanzado	Automatización, seguridad, backups, pruebas.	rsync, hashes, certificados, cron, Bats.

8. Errores comunes al aprender Bash

No citar variables y romper scripts cuando hay espacios en nombres de archivo.
Ejecutar scripts destructivos sin probarlos con datos ficticios.
No validar argumentos de entrada.
Usar sudo dentro de todo el script sin necesidad.
No guardar logs de tareas automáticas.
No manejar errores de comandos críticos.
Confundir scripts de diagnóstico con scripts de remediación.
No revisar scripts con ShellCheck.
Copiar scripts de Internet sin entender cada línea.
No versionar scripts importantes con Git.

9. Preguntas clave

¿Bash sirve para administrar servidores Linux?

Sí. Bash permite automatizar comandos, diagnósticos, backups, reportes, revisión de servicios, análisis de logs y tareas repetitivas. El manual oficial de Bash documenta su uso como shell y como intérprete de scripts.

¿Debo aprender Bash antes de Ansible o Python?

Conviene aprender Bash porque es la base de muchas tareas Linux. Luego puedes complementar con Python para scripts más complejos y Ansible para automatización masiva en varios servidores.

¿Cómo sé si mi script Bash está bien escrito?

Revisa que valide argumentos, cite variables, maneje errores, genere logs, no borre sin confirmación y pase una revisión con ShellCheck. ShellCheck está diseñado para encontrar bugs en scripts de shell.

¿Cron o systemd timers?

Cron es simple y muy usado para tareas programadas. systemd timers se integran mejor con servicios systemd y logs de journalctl. Ambos son válidos según el entorno.

¿Puedo usar estos scripts en producción?

Sí, después de probarlos, adaptarlos, revisarlos con ShellCheck, documentarlos y ajustar rutas, usuarios, permisos y políticas internas del servidor.

Recomendamos

En resumen

Aprender Bash creando scripts útiles es una de las formas más rápidas de convertirse en un mejor administrador Linux. Cada script enseña algo práctico: variables, argumentos, condicionales, bucles, logs, seguridad, monitoreo, backups, servicios, procesos, red y automatización.

La meta no es escribir scripts largos, sino scripts claros, seguros y mantenibles. Un buen script Bash debe resolver una tarea concreta, validar entradas, dejar logs, evitar acciones destructivas sin confirmación y poder ejecutarse de forma repetible con cron, systemd timers o una plataforma de automatización mayor.

Cierre editorial

Bash sigue siendo una herramienta esencial porque está cerca del sistema operativo. Permite ver, medir, corregir y automatizar Linux desde la terminal. Quien aprende Bash no solo aprende programación: aprende a pensar como administrador de servidores.

01 Septiembre 2026

Visto: 23