DevOps Bootcamp · Lección

Proyecto de scripting avanzado

Realice un proyecto completo que integre todos los conceptos aprendidos, desde herramientas de la línea de comandos hasta técnicas avanzadas de scripting en Bash.

Proyecto de scripting avanzado es una lección gratuita de DevOps Bootcamp en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de DevOps Bootcamp, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de DevOps Bootcamp incluye 4 lecciones en total.

Inicio del proyecto: el desafío

¡Bienvenido a nuestro proyecto final! A lo largo de este curso ha aprendido muchos comandos potentes de Linux y técnicas de scripting de Bash. Ahora es el momento de reunirlos todos.

En esta lección crearemos desde cero un script de Bash práctico y avanzado. Este proyecto le desafiará a integrar todo lo aprendido en una única solución funcional.

Definir el objetivo del proyecto

Nuestro objetivo es crear un script de supervisión y archivado de archivos. Imagine que tiene un servidor que genera archivos de registro y necesita procesarlos periódicamente sin intervención manual.

Esto es lo que hará nuestro script:

Supervisar continuamente un directorio específico en busca de archivos de texto nuevos.
Procesar cada archivo nuevo (por ejemplo, contar sus líneas).
Mover el archivo procesado a un directorio de archivo.
Registrar todas las actividades, incluidas las marcas de tiempo y los errores.

Base del script: shebang y variables

Todo buen script comienza con una base clara. Empezaremos definiendo el shebang y configurando las variables principales. Estas variables harán que el script sea flexible y fácil de configurar.

Definiremos las rutas del directorio que se supervisará, del directorio de archivo y de un archivo de registro.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

Comprobar que existan los directorios

Antes de que nuestro script pueda supervisar o archivar, debemos asegurarnos de que existan los directorios necesarios. Usar mkdir -p es fundamental en este caso, ya que crea los directorios solo si aún no existen y no produce un error si ya existen.

También añadiremos una gestión de errores básica para salir correctamente si falla la creación de los directorios.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

El bucle de supervisión

Nuestro script debe ejecutarse continuamente para supervisar los archivos nuevos. Un bucle while true es perfecto para ello. Dentro del bucle, usaremos sleep para pausar unos segundos entre comprobaciones y evitar que consuma demasiados recursos.

También registraremos cada comprobación para llevar un seguimiento de la actividad.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

# --- Main Monitoring Loop ---
while true; do
  echo "$(date): Checking for new files in $MONITOR_DIR..." >> "$LOG_FILE"
  # File processing will go here
  sleep 5 # Check every 5 seconds
done

Búsqueda y procesamiento de archivos

Dentro de nuestro bucle, debemos buscar nuevos archivos de texto. El comando find es ideal para ello, combinado con un bucle for para procesar cada archivo encontrado. Usaremos wc -l para contar las líneas de cada archivo como paso de procesamiento.

Esto demuestra cómo combinar herramientas de la línea de comandos dentro de un script.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

# --- Main Monitoring Loop ---
while true; do
  echo "$(date): Checking for new files in $MONITOR_DIR..." >> "$LOG_FILE"
  # Find new .txt files and process them
  for file in $(find "$MONITOR_DIR" -maxdepth 1 -type f -name "*.txt"); do
    if [ -f "$file" ]; then # Double-check if it's a regular file
      LINE_COUNT=$(wc -l < "$file")
      echo "$(date): Found '$file'. Lines: $LINE_COUNT." >> "$LOG_FILE"
      # Archiving will go here
    fi
  done
  sleep 5 # Check every 5 seconds
done

Archivado de archivos procesados

Después de procesar un archivo, debemos moverlo a nuestro directorio de archivo. Para ello se utiliza el comando mv. También añadiremos una instrucción if para comprobar el estado de salida de mv, asegurarnos de que el traslado se ha realizado correctamente y registrar cualquier fallo.

Esto hace que nuestro script sea más robusto.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

# --- Main Monitoring Loop ---
while true; do
  echo "$(date): Checking for new files in $MONITOR_DIR..." >> "$LOG_FILE"
  for file in $(find "$MONITOR_DIR" -maxdepth 1 -type f -name "*.txt"); do
    if [ -f "$file" ]; then
      LINE_COUNT=$(wc -l < "$file")
      echo "$(date): Found '$file'. Lines: $LINE_COUNT." >> "$LOG_FILE"
      
      mv "$file" "$ARCHIVE_DIR/"
      if [ $? -eq 0 ]; then
        echo "$(date): Moved '$file' to '$ARCHIVE_DIR'." >> "$LOG_FILE"
      else
        echo "$(date): ERROR: Failed to move '$file' to '$ARCHIVE_DIR'." >> "$LOG_FILE"
      fi
    fi
  done
  sleep 5
done

Añadir una salida controlada con Trap

Un script de larga ejecución necesita una forma de detenerse correctamente. El comando trap nos permite capturar señales, como SIGINT (que se activa al pulsar Ctrl+C), y ejecutar una función de limpieza antes de salir. De este modo, nos aseguramos de que el script registre su apagado.

Este es un paso fundamental para crear scripts listos para producción.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# --- Functions ---
cleanup() {
  echo "$(date): Script received stop signal. Exiting gracefully." >> "$LOG_FILE"
  exit 0 # Exit with success status
}

# --- Trap Signals ---
# Trap SIGINT (Ctrl+C) and call the cleanup function
trap cleanup SIGINT

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

# --- Main Monitoring Loop ---
while true; do
  echo "$(date): Checking for new files in $MONITOR_DIR..." >> "$LOG_FILE"
  for file in $(find "$MONITOR_DIR" -maxdepth 1 -type f -name "*.txt"); do
    if [ -f "$file" ]; then
      LINE_COUNT=$(wc -l < "$file")
      echo "$(date): Found '$file'. Lines: $LINE_COUNT." >> "$LOG_FILE"
      
      mv "$file" "$ARCHIVE_DIR/"
      if [ $? -eq 0 ]; then
        echo "$(date): Moved '$file' to '$ARCHIVE_DIR'." >> "$LOG_FILE"
      else
        echo "$(date): ERROR: Failed to move '$file' to '$ARCHIVE_DIR'." >> "$LOG_FILE"
      fi
    fi
  done
  sleep 5
done

Probar su script avanzado

Ahora que nuestro script está completo, ¡es hora de probarlo! Normalmente, lo ejecutaría en segundo plano (por ejemplo, ./monitor.sh &), después crearía archivos de prueba en $MONITOR_DIR y observaría $LOG_FILE y $ARCHIVE_DIR.

A continuación tiene un pequeño script que puede ejecutar para crear fácilmente un archivo de prueba para su monitor.

#!/bin/bash
# create_test_file.sh

MONITOR_DIR="/tmp/coddykit_monitor"
mkdir -p "$MONITOR_DIR" # Ensure dir exists for this test script

# Create a unique test file
TEST_FILE="$MONITOR_DIR/test_log_$(date +%Y%m%d_%H%M%S).txt"
echo "This is a test entry." > "$TEST_FILE"
echo "Another line for testing." >> "$TEST_FILE"
echo "Created new test file: $TEST_FILE"

Revisión de la lógica del script

Nuestro script avanzado combina muchos conceptos. Revisemos rápidamente algunos de los comandos y las estructuras principales que hemos utilizado.

Reflexione sobre el papel que desempeña cada comando para alcanzar el objetivo de nuestro proyecto.

Más allá: programación y personalización

Este script está diseñado para ejecutarse de forma continua. En un escenario real, podría ejecutarlo en segundo plano mediante nohup ./script.sh & o, lo que es más habitual, programarlo para que se ejecute periódicamente mediante Cron.

Recuerde que Cron es perfecto para automatizar tareas como esta. Podría programarlo para que se ejecute cada pocos minutos, compruebe el directorio y procese los archivos según sea necesario.

Considere personalizarlo para:

Procesar distintos tipos de archivos.
Realizar distintas acciones (por ejemplo, comprimir archivos o subirlos a la nube).
Añadir informes de errores más avanzados (por ejemplo, alertas por correo electrónico).

Resumen del proyecto y siguientes pasos

¡Enhorabuena! Acaba de completar un proyecto avanzado de scripting en Bash, integrando una amplia variedad de comandos de Linux y técnicas de scripting.

Ha aprendido a:

Estructurar un script robusto y de larga ejecución.
Usar variables para la configuración.
Implementar bucles para la supervisión continua.
Combinar comandos como find, wc y mv.
Añadir gestión de errores y salidas controladas con trap.

Este proyecto es una base sólida para crear soluciones de automatización más complejas. ¡Siga experimentando y creando!

Preguntas frecuentes

¿La lección «Proyecto de scripting avanzado» es gratis?

Sí — el texto completo de «Proyecto de scripting avanzado» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de DevOps Bootcamp, actualiza a CoddyKit PRO. El curso de DevOps Bootcamp incluye 4 lecciones en total.

¿Qué aprenderé en «Proyecto de scripting avanzado»?

Realice un proyecto completo que integre todos los conceptos aprendidos, desde herramientas de la línea de comandos hasta técnicas avanzadas de scripting en Bash. Practicas DevOps Bootcamp con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar DevOps Bootcamp?

No se requiere experiencia previa. DevOps Bootcamp en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Proyecto de scripting avanzado»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de DevOps Bootcamp?

Sí. Cada lección de DevOps Bootcamp incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Programación de tareas con Cron
Automatización de la administración del sistema
Proyecto de scripting avanzado
Rotación y limpieza automatizadas de logs

← Volver a DevOps Bootcamp