📚 Módulo 5: Organizando y escalando tareas

Duración estimada: según tu ritmo y experiencia.

Objetivo: Estructurar scripts con funciones, usar bucles avanzados (while, until), programar tareas con cron, y depurar eficientemente, explorando su aplicación técnica. 🎯

Prerrequisitos: Haber completado los Módulos 1, 2, 3 y 4, acceso a un sistema Linux, macOS o WSL con una terminal y un editor de texto (nano, vim o VS Code).

Nota: El tiempo varía según tu nivel y dedicación; experimenta con cada herramienta para optimizar tus scripts.

---

📖 Contenidos del Módulo

5.1. Funciones: Organiza tu código ⚙️

Teoría:

Las funciones agrupan comandos reutilizables en scripts. Se definen con nombre() { comandos; } y se llaman con nombre. Técnicamente, esto mejora la modularidad y mantenimiento.

Práctica:

1. Crea un script funciones.sh:

   nano funciones.sh
   

2. Añade una función básica:

   #!/bin/bash
   saludo() {
       echo "¡Hola desde la función!"
   }
   saludo
   

   Guarda, da permisos con chmod +x funciones.sh y ejecuta.
3. Pasa un argumento a la función:

   nano funciones.sh
   saludo() {
       echo "¡Hola, $1!"
   }
   saludo "Aprendiz"
   ./funciones.sh
   

4. Crea una función con retorno:

   nano funciones.sh
   suma() {
       echo $(( $1 + $2 ))
   }
   resultado=$(suma 5 3)
   echo "Suma: $resultado"
   ./funciones.sh
   

5. Llama la función varias veces:

   nano funciones.sh
   for i in 1 2
   do
       saludo "Intento $i"
   done
   ./funciones.sh
   

Dato curioso

Las funciones reducen duplicación de código, como en programas grandes. 😄

5.2. Bucles avanzados: while y until 🛡️

Teoría:

while repite mientras una condición sea verdadera. until repite hasta que una condición sea verdadera. Técnicamente, esto permite control preciso sobre repeticiones.

Práctica:

1. Crea un script bucle_while.sh:

   nano bucle_while.sh
   

2. Añade un while básico:

   #!/bin/bash
   contador=0
   while [ $contador -lt 3 ]
   do
       echo "Contador: $contador"
       contador=$((contador + 1))
   done
   

   Guarda, da permisos y ejecuta.
3. Usa until para un conteo inverso:

   nano bucle_until.sh
   #!/bin/bash
   contador=3
   until [ $contador -eq 0 ]
   do
       echo "Faltan: $contador"
       contador=$((contador - 1))
   done
   chmod +x bucle_until.sh
   ./bucle_until.sh
   

4. Combina con entrada:

   nano bucle_while.sh
   read -p "Hasta dónde contar? " limite
   while [ $contador -le $limite ]
   do
       echo "Número: $contador"
       contador=$((contador + 1))
   done
   ./bucle_while.sh
   

5. Añade condición compleja:

   nano bucle_while.sh
   while [ $contador -le 5 ] && [ $((contador % 2)) -eq 0 ]
   do
       echo "Par: $contador"
       contador=$((contador + 1))
   done
   ./bucle_while.sh
   

Consejo

Usa while para condiciones dinámicas; valida entradas para evitar bucles infinitos. 💡

5.3. Programación con cron: Tareas automáticas 📜

Teoría:

cron programa tareas para ejecutarse en horarios específicos. Se edita con crontab -e usando formato min hora día mes día_semana comando. Técnicamente, esto automatiza procesos en segundo plano.

Práctica:

1. Edita el crontab:

   crontab -e
   

   Añade una línea como: * * * * * echo "Prueba" >> /tmp/cron.log.
2. Verifica la ejecución:

   cat /tmp/cron.log
   

   Nota: Puede tardar un minuto; revisa permisos.
3. Programa un script cada 5 minutos:

   crontab -e
   # Añade: */5 * * * * /ruta/a/tu/script.sh >> /tmp/log.txt 2>&1
   

   Asegúrate de usar la ruta correcta de funciones.sh.
4. Crea un script para cron:

   nano tarea.sh
   #!/bin/bash
   date >> /tmp/tarea.log
   chmod +x tarea.sh
   crontab -e
   # Añade: * * * * * /ruta/a/tarea.sh
   cat /tmp/tarea.log
   

5. Elimina una tarea:

   crontab -e
   # Comenta o elimina la línea añadida
   

Advertencia

Usa rutas absolutas en cron (ej. /home/usuario/script.sh) y verifica permisos. 🛑

5.4. Depuración avanzada: Soluciona problemas 🏗️

Teoría:

set -x traza ejecución, set -e detiene en errores. bash -x script.sh ejecuta con depuración externa. Técnicamente, esto asegura scripts robustos.

Práctica:

1. Crea un script con error:

   nano depura.sh
   #!/bin/bash
   a=5
   b=
   echo $((a / b))
   

   Ejecuta y observa el fallo.
2. Usa set -x para trazar:

   nano depura.sh
   #!/bin/bash
   set -x
   a=5
   b=0
   echo $((a / b))
   set +x
   chmod +x depura.sh
   ./depura.sh
   

3. Activa set -e para salir en errores:

   nano depura.sh
   #!/bin/bash
   set -e
   set -x
   a=5
   b=0
   echo $((a / b))
   set +x
   ./depura.sh
   

4. Depura desde la terminal:

   bash -x depura.sh
   

5. Corrige y prueba:

   nano depura.sh
   if [ $b -ne 0 ]
   then
       echo $((a / b))
   else
       echo "Error: División por cero"
   fi
   ./depura.sh
   

Consejo

Usa set -e en producción para detener scripts en fallos críticos. 💡

5.5. Estructura profesional: Un script completo 🚀

Teoría:

Un script profesional usa funciones, validación y documentación. Ejemplo: comentarios # y manejo de errores. Técnicamente, esto asegura escalabilidad.

Práctica:

1. Crea un script organizado:

   nano backup.sh
   #!/bin/bash
   # Script de respaldo diario
   backup() {
       cp $1 /tmp/backup_$(date +%F).txt
   }
   if [ -f "$1" ]
   then
       backup "$1"
   else
       echo "Archivo no encontrado"
   fi
   

2. Dale permisos y prueba:

   chmod +x backup.sh
   echo "Datos" > prueba.txt
   ./backup.sh prueba.txt
   ls /tmp/backup*
   

3. Añade un bucle y cron:

   nano backup.sh
   for file in *.txt
   do
       backup "$file"
   done
   crontab -e
   # Añade: 0 0 * * * /ruta/a/backup.sh
   

4. Incluye depuración:

   nano backup.sh
   set -x
   backup() {
       cp $1 /tmp/backup_$(date +%F).txt
   }
   set +x
   ./backup.sh prueba.txt
   

5. Verifica y limpia:

   ls /tmp/backup*
   rm /tmp/backup*
   

Consejo

Documenta con # para que otros (o tú) entiendan el script. 💡

---

🛠️ Ejercicios prácticos

1. Función:
   • Crea una función que muestre la fecha en un formato personalizado.
2. While:
   • Usa while para contar hasta un número ingresado.
3. Cron:
   • Programa un script para guardar la hora cada hora.
4. Depuración:
   • Depura un script con división por cero usando set -e.
5. Desafío:
   • Crea un script que respalde todos los .txt con funciones y cron.

---

5.6. Gestión avanzada del entorno con .bashrc 🚀

Teoría:

.bashrc es el archivo que Bash ejecuta al iniciar una sesión interactiva, permitiendo personalizar tu entorno de trabajo de forma permanente. Puedes definir funciones, alias, variables de entorno y condiciones, integrándolas con scripts y automatización como la de cron. Técnicamente, esto optimiza tu flujo de trabajo y escalabilidad.

Práctica:

1. Edita .bashrc con una función de monitoreo:

   nano ~/.bashrc
   # Añade al final:
   function monitor_system() {
     memoria=$(free -h | awk '/Mem:/ {print $3}')
     echo "Memoria en uso: $memoria"
   }
   monitor_system
   

2. Recarga y prueba la función:

   source ~/.bashrc
   monitor_system
   

3. Añade una variable de entorno para scripts:

   nano ~/.bashrc
   # Añade: export SCRIPT_DIR="/home/$USER/scripts"
   source ~/.bashrc
   echo $SCRIPT_DIR
   mkdir -p $SCRIPT_DIR
   

4. Integra con un script de cron:

   nano $SCRIPT_DIR/log_script.sh
   # Añade: #!/bin/bash\necho "$(date): Registro" >> $SCRIPT_DIR/log.txt
   chmod +x $SCRIPT_DIR/log_script.sh
   crontab -e
   # Añade: * * * * * $SCRIPT_DIR/log_script.sh
   cat $SCRIPT_DIR/log.txt
   # Espera un minuto para ver el log
   

5. Añade una condición y haz backup:

   nano ~/.bashrc
   # Añade:
   if [ ! -f ~/.bashrc.bak ]; then
     cp ~/.bashrc ~/.bashrc.bak
     echo "Backup creado"
   fi
   source ~/.bashrc
   

Consejo

Define variables en .bashrc para usarlas en scripts de cron y recarga siempre con source. 💡

---

📝 Evaluación

Cuestionario corto (5 preguntas):

1. ¿Qué hace una función en Bash?
2. ¿Cuál es la diferencia entre while y until?
3. ¿Cómo se programa una tarea con cron?
4. ¿Para qué sirve set -e?
5. ¿Qué mejora la documentación en un script?
6. ¿Para qué sirve .bashrc?
7. ¿Cómo defines una variable en .bashrc?

Tarea práctica:

• Crea un script organiza.sh que:
  • Use una función para copiar archivos .sh a /tmp.
  • Use while para procesar 5 archivos.
  • Programe con cron para ejecutarse diariamente.
  • Incluya depuración con set -x.
  • Crea un script profesional con función y bucle.
  • Añade una función de monitoreo con variable en .bashrc.
• Entrega: Script, log de cron, captura de depuración, y captura de .bashrc con los cambios.

---

🎉 Recursos adicionales

• Documentación: man cron, man bash.
• Enlaces:
  • Guía de funciones (detalles técnicos).
  • Tutorial de cron (ejemplos prácticos).

Tip

Prueba cron con tareas simples antes de automatizar críticas. 💡

---

🚀 Siguientes pasos

¡Felicidades por completar el Módulo 5! En el Módulo 6, aprenderás a conectar tu terminal al mundo real con herramientas avanzadas. ¡Sigue escalando! ✍️