Manual del estudiante — Module 5: Automatización y Tareas Administrativas Esenciales
Manual del estudiante

# Linux Administration Essentials (Spanish Edition)

## Module 5: Automatización y Tareas Administrativas Esenciales

LNX-001S

1-day course · 5 modules · beginner level

### Objetivos de aprendizaje

Al finalizar este módulo, usted podrá:

- Crear scripts bash básicos para automatizar tareas administrativas repetitivas
- Programar trabajos automáticos utilizando cron y crontab
- Implementar respaldos automatizados de directorios críticos
- Configurar tareas de mantenimiento del sistema programadas
- Aplicar mejores prácticas para administración eficiente de sistemas Linux

# Lección 1: Introducción a la Automatización en Linux

## La Necesidad de Automatización

Los administradores de sistemas Linux gestionan tareas repetitivas diariamente: respaldos, limpieza de archivos temporales, rotación de logs, actualizaciones de seguridad y monitoreo de recursos. Realizar estas actividades manualmente consume tiempo valioso y aumenta el riesgo de errores humanos. La automatización transforma estas operaciones manuales en procesos confiables y consistentes.

Beneficios de la automatización:

- Eficiencia: Las tareas se ejecutan sin intervención humana, liberando tiempo para proyectos estratégicos
- Consistencia: Los scripts ejecutan los mismos pasos exactamente cada vez, eliminando variaciones
- Escalabilidad: Gestionar cientos de servidores con el mismo esfuerzo que uno solo
- Documentación: Los scripts sirven como documentación ejecutable de los procedimientos
- Reducción de errores: Eliminación de errores tipográficos y omisiones comunes en procesos manuales

## Herramientas de Automatización en Linux

Linux ofrece dos herramientas fundamentales para la automatización: bash scripting para crear secuencias de comandos reutilizables, y cron para programar la ejecución automática de tareas. Bash permite capturar procedimientos complejos en archivos ejecutables, mientras que cron actúa como un planificador que ejecuta estos scripts en horarios específicos.

Juntas, estas herramientas forman la base de la administración moderna de sistemas Linux, permitiendo que los servidores se mantengan actualizados, respaldados y optimizados con mínima intervención manual.

Ilustración conceptual mostrando un administrador de sistemas supervisando múltiples servidores con tareas automatizadas ejecutándose: respaldos, actualizaciones y monitoreo, representadas como procesos conectados por líneas de flujo

Puntos para recordar

- La automatización elimina tareas repetitivas y reduce errores humanos
- Bash scripting y cron son las herramientas fundamentales de automatización en Linux
- Los beneficios incluyen eficiencia, consistencia, escalabilidad y mejor documentación
- La automatización es esencial para gestionar infraestructura a escala

# Lección 2: Fundamentos de Scripting en Bash

## Estructura Básica de un Script Bash

Un script bash es un archivo de texto que contiene una secuencia de comandos de Linux que se ejecutan en orden. Todo script bash debe comenzar con una línea especial llamada shebang que indica al sistema qué intérprete debe usar para ejecutar el script:

    #!/bin/bash
    # Script de respaldo básico
    # Autor: Administrador del Sistema

    echo "Iniciando proceso de respaldo..."
    cp -r /home/usuario/documentos /respaldos/
    echo "Respaldo completado exitosamente"

El shebang (`#!/bin/bash`) debe ser la primera línea del archivo. Las líneas que comienzan con `#` son comentarios que documentan el propósito del script.

## Variables y Estructura de Control

Las variables almacenan información que el script puede usar y modificar. En bash, se definen sin espacios alrededor del signo igual:

    #!/bin/bash

    DIRECTORIO_ORIGEN="/home/usuario/documentos"
    DIRECTORIO_DESTINO="/respaldos"
    FECHA=$(date +%Y%m%d)

    if [ -d "$DIRECTORIO_ORIGEN" ]; then
        echo "Respaldando a $DIRECTORIO_DESTINO/respaldo_$FECHA"
        cp -r "$DIRECTORIO_ORIGEN" "$DIRECTORIO_DESTINO/respaldo_$FECHA"
    else
        echo "Error: El directorio de origen no existe"
        exit 1
    fi

Las estructuras condicionales (`if`, `else`, `fi`) permiten que los scripts tomen decisiones basadas en condiciones. El comando `exit` termina el script con un código de estado (0 para éxito, 1-255 para errores).

## Permisos de Ejecución

Para que un script sea ejecutable, debe tener permisos de ejecución. Después de crear un script, use `chmod` para otorgar estos permisos:

    chmod +x mi_script.sh
    ./mi_script.sh

El prefijo `./` indica que el script está en el directorio actual.

Diagrama ilustrado mostrando la anatomía de un script bash: shebang en la parte superior, sección de variables en el medio, estructura condicional if-else, y sección de ejecución de comandos, con anotaciones explicativas

Puntos para recordar

- Todo script bash debe comenzar con el shebang #!/bin/bash
- Las variables se definen sin espacios: VARIABLE="valor"
- Las estructuras condicionales permiten tomar decisiones en scripts
- Los scripts requieren permisos de ejecución: chmod +x script.sh

# Lección 3: Redirección y Pipes para Scripts Eficientes

## Redirección de Entrada y Salida

La redirección permite controlar dónde envía un script su salida y de dónde obtiene su entrada. Esto es fundamental para crear scripts que generen logs, procesen archivos y manejen errores apropiadamente.

Operadores de redirección principales:

- `>` — Redirige la salida estándar a un archivo (sobrescribe)
- `>>` — Redirige la salida estándar a un archivo (añade al final)
- `2>` — Redirige errores estándar a un archivo
- `&>` — Redirige tanto salida como errores al mismo archivo
- `<` — Lee entrada desde un archivo

    #!/bin/bash
    # Script con redirección de salida y errores

    LOG_FILE="/var/log/respaldo.log"
    ERROR_FILE="/var/log/respaldo_errores.log"

    echo "[$(date)] Iniciando respaldo" >> "$LOG_FILE"
    tar -czf /respaldos/home.tar.gz /home 2>> "$ERROR_FILE"
    echo "[$(date)] Respaldo completado" >> "$LOG_FILE"

## Uso de Pipes para Procesamiento de Datos

Los pipes (`|`) conectan la salida de un comando con la entrada del siguiente, permitiendo crear cadenas de procesamiento poderosas:

    #!/bin/bash
    # Encuentra archivos grandes y genera reporte

    find /var/log -type f -size +100M | \
        sort | \
        tee archivos_grandes.txt | \
        wc -l > total_archivos_grandes.txt

Este script encuentra archivos mayores a 100 MB, los ordena, guarda la lista en un archivo usando `tee` (que también pasa la salida al siguiente comando), y cuenta el total de archivos.

## Variables de Entorno en Scripts

Las variables de entorno proporcionan información del sistema y configuración a los scripts:

    #!/bin/bash

    echo "Usuario actual: $USER"
    echo "Directorio home: $HOME"
    echo "Ruta de búsqueda: $PATH"

    # Definir variable de entorno personalizada
    export MI_DIRECTORIO_RESPALDO="/respaldos/$(hostname)"
    mkdir -p "$MI_DIRECTORIO_RESPALDO"

El comando `export` hace que una variable esté disponible para procesos hijos del script.

Diagrama de flujo ilustrado mostrando cómo los datos fluyen a través de pipes: un comando genera salida que fluye a través de múltiples comandos conectados, con bifurcaciones mostrando redirección a archivos de log

Puntos para recordar

- La redirección (>, >>, 2>) controla dónde va la salida del script
- Los pipes (|) conectan comandos para procesamiento en cadena
- Las variables de entorno proporcionan información del sistema a los scripts
- El comando export hace que variables estén disponibles para procesos hijos

# Lección 4: El Servicio Cron y Programación de Tareas

## Introducción al Servicio Cron

Cron es un demonio (servicio en segundo plano) que ejecuta comandos y scripts en horarios programados. El nombre proviene de "chronos" (tiempo en griego). El servicio cron verifica cada minuto si hay tareas programadas que deban ejecutarse, haciéndolo ideal para automatización de tareas recurrentes.

Componentes del sistema cron:

- crond — El demonio que ejecuta en segundo plano
- crontab — Comando para editar la tabla de tareas programadas
- /var/spool/cron/ — Directorio con archivos crontab de usuarios
- /etc/cron.d/ — Directorio para archivos crontab del sistema
- /var/log/cron — Archivo de log del servicio cron

## Sintaxis de Crontab

Cada línea en un archivo crontab representa una tarea programada. La sintaxis tiene cinco campos de tiempo seguidos por el comando a ejecutar:

    ┌───────────── minuto (0-59)
    │ ┌───────────── hora (0-23)
    │ │ ┌───────────── día del mes (1-31)
    │ │ │ ┌───────────── mes (1-12)
    │ │ │ │ ┌───────────── día de la semana (0-7, donde 0 y 7 = domingo)
    │ │ │ │ │
    │ │ │ │ │
    * * * * * comando_a_ejecutar

Ejemplos de sintaxis cron:

    # Ejecutar cada día a las 2:30 AM
    30 2 * * * /usr/local/bin/respaldo_diario.sh

    # Ejecutar cada lunes a las 8:00 AM
    0 8 * * 1 /usr/local/bin/reporte_semanal.sh

    # Ejecutar cada hora en el minuto 15
    15 * * * * /usr/local/bin/verificar_servicios.sh

    # Ejecutar el primer día de cada mes a medianoche
    0 0 1 * * /usr/local/bin/respaldo_mensual.sh

## Comandos Crontab Esenciales

El comando `crontab` gestiona las tareas programadas del usuario:

- `crontab -e` — Edita el archivo crontab del usuario actual
- `crontab -l` — Lista todas las tareas programadas del usuario
- `crontab -r` — Elimina todas las tareas del usuario (¡usar con precaución!)
- `crontab -u usuario -l` — Lista tareas de otro usuario (requiere privilegios root)

Cuando ejecuta `crontab -e`, se abre el editor predeterminado del sistema. Agregue sus tareas, guarde y cierre el archivo para activarlas inmediatamente.

Ilustración técnica mostrando la sintaxis de crontab como una regla de tiempo con cinco segmentos etiquetados (minuto, hora, día, mes, día de semana) sobre una línea de tiempo circular representando un ciclo de 24 horas

Puntos para recordar

- Cron es un demonio que ejecuta tareas programadas automáticamente
- La sintaxis crontab usa cinco campos de tiempo: minuto hora día mes día-semana
- crontab -e edita tareas, -l las lista, -r las elimina
- Las tareas cron se activan inmediatamente después de guardar el archivo crontab

# Lección 5: Automatización de Respaldos y Mantenimiento

## Estrategias de Respaldo Automatizado

Los respaldos son la última línea de defensa contra pérdida de datos. Automatizar los respaldos garantiza que se realicen consistentemente sin depender de la memoria humana. Linux ofrece dos herramientas principales para respaldos automatizados:

tar (tape archive) — Crea archivos comprimidos de directorios completos:

    #!/bin/bash
    # Script de respaldo con tar

    FECHA=$(date +%Y%m%d_%H%M%S)
    ORIGEN="/home /etc /var/www"
    DESTINO="/respaldos/servidor_$FECHA.tar.gz"

    tar -czf "$DESTINO" $ORIGEN 2>> /var/log/respaldos.log

    if [ $? -eq 0 ]; then
        echo "[$(date)] Respaldo exitoso: $DESTINO" >> /var/log/respaldos.log
    else
        echo "[$(date)] ERROR en respaldo" >> /var/log/respaldos.log
        exit 1
    fi

rsync — Sincroniza directorios eficientemente, copiando solo cambios:

    #!/bin/bash
    # Script de respaldo incremental con rsync

    rsync -avz --delete \
        /home/produccion/ \
        /respaldos/produccion/ \
        --log-file=/var/log/rsync.log

Rsync es ideal para respaldos incrementales porque solo transfiere archivos modificados, reduciendo tiempo y espacio de almacenamiento.

## Scripts de Limpieza y Mantenimiento

Los archivos de log y temporales consumen espacio en disco con el tiempo. Scripts de limpieza automatizados previenen problemas de espacio:

    #!/bin/bash
    # Script de limpieza de logs antiguos

    LOG_DIR="/var/log/aplicaciones"
    DIAS_ANTIGUEDAD=30

    # Encuentra y elimina archivos .log más antiguos que 30 días
    find "$LOG_DIR" -name "*.log" -type f -mtime +$DIAS_ANTIGUEDAD -delete

    # Limpia archivos temporales del sistema
    find /tmp -type f -mtime +7 -delete

    # Registra la ejecución
    echo "[$(date)] Limpieza completada" >> /var/log/mantenimiento.log

## Rotación de Logs y Actualización de Sistemas

Linux incluye `logrotate` para gestión automática de logs, pero las tareas de actualización deben programarse con cuidado:

    #!/bin/bash
    # Script de actualización de seguridad automatizada

    yum update -y --security >> /var/log/actualizaciones.log 2>&1

    if [ $? -eq 0 ]; then
        echo "[$(date)] Actualizaciones de seguridad aplicadas" >> /var/log/actualizaciones.log
    fi

Programar este script semanalmente mantiene el sistema protegido contra vulnerabilidades conocidas.

Ilustración de proceso mostrando tres etapas de mantenimiento automatizado: respaldo (servidor copiando datos a almacenamiento), limpieza (archivos antiguos siendo removidos), y actualización (servidor recibiendo parches de seguridad)

Puntos para recordar

- tar crea archivos comprimidos completos, rsync realiza respaldos incrementales eficientes
- Los scripts deben incluir registro de errores y verificación de éxito
- La limpieza automatizada de logs previene problemas de espacio en disco
- Las actualizaciones de seguridad deben programarse regularmente pero monitorearse

# Lección 6: Mejores Prácticas y Monitoreo de Automatización

## Verificación y Depuración de Tareas Cron

Las tareas cron fallan silenciosamente si no se configuran correctamente. Implementar verificación proactiva previene problemas:

Revisar logs de cron:

    # Ver ejecuciones recientes de cron
    tail -f /var/log/cron

    # Buscar ejecuciones de un script específico
    grep "respaldo_diario.sh" /var/log/cron

Configurar notificaciones por correo:

Cron envía la salida de los comandos por correo al usuario. Configure la variable MAILTO en el crontab:

    MAILTO=admin@ejemplo.com

    # Respaldo diario con notificación automática si hay errores
    0 2 * * * /usr/local/bin/respaldo_diario.sh

Registrar salida explícitamente:

En lugar de depender del correo, redirigir toda la salida a archivos de log:

    # En crontab: redirigir salida y errores a log
    0 2 * * * /usr/local/bin/respaldo_diario.sh >> /var/log/respaldos.log 2>&1

## Mejores Prácticas para Scripts de Producción

1. Usar rutas absolutas: Los scripts cron se ejecutan con un PATH limitado:

    # Incorrecto - puede fallar en cron
    tar -czf respaldo.tar.gz /home

    # Correcto - ruta absoluta
    /bin/tar -czf /respaldos/respaldo.tar.gz /home

2. Implementar bloqueos de ejecución: Prevenir múltiples instancias simultáneas:

    #!/bin/bash
    LOCK_FILE="/var/run/mi_script.lock"

    if [ -f "$LOCK_FILE" ]; then
        echo "Script ya en ejecución" >&2
        exit 1
    fi

    touch "$LOCK_FILE"
    trap "rm -f $LOCK_FILE" EXIT

    # Aquí va el código del script

3. Validar requisitos previos: Verificar que existan directorios y permisos necesarios:

    #!/bin/bash

    if [ ! -d "/respaldos" ]; then
        echo "Error: Directorio /respaldos no existe" >&2
        exit 1
    fi

    if [ ! -w "/respaldos" ]; then
        echo "Error: Sin permisos de escritura en /respaldos" >&2
        exit 1
    fi

## Documentación y Mantenimiento de Scripts

Los scripts bien documentados son más fáciles de mantener y depurar. Incluya comentarios descriptivos, información de uso y ejemplos:

    #!/bin/bash
    #
    # Script de respaldo de sistema
    # Descripción: Respalda directorios críticos a almacenamiento remoto
    # Autor: Equipo de Operaciones
    # Última modificación: 2024-01-15
    #
    # Uso: ./respaldo_sistema.sh [destino]
    # Ejemplo: ./respaldo_sistema.sh /respaldos
    #
    # Requisitos:
    #   - rsync instalado
    #   - Permisos de lectura en directorios de origen
    #   - Espacio suficiente en destino (mínimo 50GB)
    #

Mantener un registro de cambios (changelog) en los scripts ayuda a rastrear modificaciones a lo largo del tiempo.

Diagrama de flujo ilustrado mostrando el ciclo de vida de un script automatizado: creación, prueba, documentación, programación en cron, ejecución, monitoreo de logs, y depuración, formando un ciclo continuo

Puntos para recordar

- Monitorear logs de cron regularmente para detectar fallos en tareas programadas
- Usar rutas absolutas en scripts ejecutados por cron
- Implementar bloqueos de ejecución para prevenir múltiples instancias simultáneas
- Documentar scripts con comentarios descriptivos, requisitos y ejemplos de uso

# Laboratorio: Creación de Scripts de Respaldo Automatizados con Bash y Cron

Objetivo: Crear un script bash para respaldar directorios del sistema, configurar su ejecución automática mediante cron, implementar verificación de errores y establecer tareas de mantenimiento programadas

Tiempo estimado: 45 minutos

Plataforma: Ubuntu Linux (Terminal y editor de texto)

Requisitos previos:

- Acceso a sistema Ubuntu con permisos sudo
- Editor de texto instalado (nano, vim o gedit)
- Conexión SSH o acceso directo a terminal
- Espacio en disco de al menos 500MB disponible

## Procedimientos

### Paso 1: Crear la estructura de directorios para el sistema de respaldos

Primero, crearemos los directorios necesarios para almacenar scripts, respaldos y logs. Ejecute los siguientes comandos:

    mkdir -p ~/backup-system/scripts
    mkdir -p ~/backup-system/backups
    mkdir -p ~/backup-system/logs
    mkdir -p ~/backup-system/test-data

Estos directorios servirán para:

- `scripts`: almacenar los scripts de respaldo
- `backups`: guardar los archivos de respaldo generados
- `logs`: registrar la actividad de los respaldos
- `test-data`: datos de prueba para respaldar

Resultado esperado:

Los comandos no producen salida si se ejecutan correctamente. Los directorios se crean silenciosamente.

✔ Verificación: Verifique que los directorios se crearon correctamente ejecutando: ```bash ls -la ~/backup-system/ ``` Debe ver los cuatro directorios listados con permisos drwxr-xr-x.

### Paso 2: Crear archivos de prueba en el directorio test-data

Generaremos algunos archivos de prueba para simular datos que necesitan respaldo:

    cd ~/backup-system/test-data
    echo "Documento importante del proyecto Alpha" > proyecto-alpha.txt
    echo "Configuración del servidor web" > config-servidor.conf
    echo "Datos del cliente ABC-123" > cliente-abc.txt
    mkdir documentos
    echo "Reporte mensual de ventas" > documentos/reporte-ventas.txt
    echo "Análisis financiero Q1" > documentos/analisis-financiero.txt

Estos archivos simularán datos críticos que requieren respaldo regular.

Resultado esperado:

Los comandos ejecutan sin salida. Los archivos se crean silenciosamente en el directorio test-data.

✔ Verificación: Confirme la creación de archivos con: ```bash ls -lR ~/backup-system/test-data/ ``` Debe ver los tres archivos .txt y .conf en test-data, más el subdirectorio documentos con dos archivos adicionales.

### Paso 3: Crear el script principal de respaldo con shebang y variables

Abra un nuevo archivo de script con el editor nano:

    nano ~/backup-system/scripts/backup-automatico.sh

Escriba el siguiente contenido en el archivo:

    #!/bin/bash
    # Script de respaldo automatizado
    # Autor: Administrador del Sistema
    # Fecha: 2024

    # Variables de configuración
    DIR_ORIGEN="$HOME/backup-system/test-data"
    DIR_DESTINO="$HOME/backup-system/backups"
    DIR_LOGS="$HOME/backup-system/logs"
    FECHA=$(date +"%Y%m%d-%H%M%S")
    NOMBRE_BACKUP="backup-$FECHA.tar.gz"
    ARCHIVO_LOG="$DIR_LOGS/backup-$FECHA.log"

    echo "Script de respaldo inicializado"

Guarde el archivo presionando `Ctrl+O`, luego `Enter`, y salga con `Ctrl+X`.

Resultado esperado:

El editor nano se abre, permite editar el archivo, y confirma que se guardó el archivo al salir.

✔ Verificación: Verifique el contenido del script: ```bash cat ~/backup-system/scripts/backup-automatico.sh ``` Debe mostrar exactamente el contenido que escribió, comenzando con #!/bin/bash.

### Paso 4: Agregar funciones de validación y logging al script

Edite nuevamente el script para agregar funciones de validación:

    nano ~/backup-system/scripts/backup-automatico.sh

Al final del archivo (después de la última línea), agregue:

    # Función para registrar mensajes
    log_mensaje() {
        echo "[$(date +"%Y-%m-%d %H:%M:%S")] $1" | tee -a "$ARCHIVO_LOG"
    }

    # Verificar que el directorio origen existe
    if [ ! -d "$DIR_ORIGEN" ]; then
        log_mensaje "ERROR: El directorio origen $DIR_ORIGEN no existe"
        exit 1
    fi

    # Verificar que el directorio destino existe
    if [ ! -d "$DIR_DESTINO" ]; then
        log_mensaje "ADVERTENCIA: Creando directorio destino $DIR_DESTINO"
        mkdir -p "$DIR_DESTINO"
    fi

    log_mensaje "Iniciando proceso de respaldo..."
    log_mensaje "Origen: $DIR_ORIGEN"
    log_mensaje "Destino: $DIR_DESTINO/$NOMBRE_BACKUP"

Guarde con `Ctrl+O`, `Enter`, y salga con `Ctrl+X`.

Resultado esperado:

El archivo se guarda correctamente con las nuevas funciones agregadas.

✔ Verificación: Confirme que las funciones se agregaron: ```bash tail -20 ~/backup-system/scripts/backup-automatico.sh ``` Debe ver la función log_mensaje y las validaciones de directorios.

### Paso 5: Agregar la lógica de creación del respaldo con tar

Continúe editando el script para agregar el comando de respaldo:

    nano ~/backup-system/scripts/backup-automatico.sh

Agregue al final del archivo:

    # Crear el archivo de respaldo
    log_mensaje "Comprimiendo archivos..."
    if tar -czf "$DIR_DESTINO/$NOMBRE_BACKUP" -C "$(dirname "$DIR_ORIGEN")" "$(basename "$DIR_ORIGEN")" 2>> "$ARCHIVO_LOG"; then
        TAMANIO=$(du -h "$DIR_DESTINO/$NOMBRE_BACKUP" | cut -f1)
        log_mensaje "Respaldo completado exitosamente"
        log_mensaje "Archivo: $NOMBRE_BACKUP"
        log_mensaje "Tamaño: $TAMANIO"

        # Contar archivos respaldados
        NUM_ARCHIVOS=$(tar -tzf "$DIR_DESTINO/$NOMBRE_BACKUP" | wc -l)
        log_mensaje "Total de archivos/directorios: $NUM_ARCHIVOS"
    else
        log_mensaje "ERROR: Falló la creación del respaldo"
        exit 1
    fi

    log_mensaje "Proceso de respaldo finalizado"

Guarde y cierre el archivo.

Resultado esperado:

El archivo se guarda con la lógica completa de respaldo agregada.

✔ Verificación: Revise el script completo: ```bash wc -l ~/backup-system/scripts/backup-automatico.sh ``` Debe mostrar aproximadamente 45-50 líneas de código.

### Paso 6: Hacer el script ejecutable con chmod

Otorgue permisos de ejecución al script utilizando el comando chmod:

    chmod +x ~/backup-system/scripts/backup-automatico.sh

El flag `+x` agrega el permiso de ejecución para el propietario, grupo y otros usuarios.

Verifique los permisos con:

    ls -l ~/backup-system/scripts/backup-automatico.sh

Resultado esperado:

    -rwxr-xr-x 1 usuario usuario 1234 dic 15 10:30 /home/usuario/backup-system/scripts/backup-automatico.sh

Note las 'x' en la salida de permisos que indican que el archivo es ejecutable.

✔ Verificación: El comando ls -l debe mostrar -rwxr-xr-x (con las tres 'x' presentes) en los permisos del archivo.

### Paso 7: Ejecutar el script manualmente para probar su funcionamiento

Ejecute el script directamente desde la terminal:

    ~/backup-system/scripts/backup-automatico.sh

O alternativamente, navegue al directorio y ejecútelo:

    cd ~/backup-system/scripts
    ./backup-automatico.sh

Observe la salida en pantalla que muestra el progreso del respaldo.

Resultado esperado:

    Script de respaldo inicializado
    [2024-12-15 10:35:22] Iniciando proceso de respaldo...
    [2024-12-15 10:35:22] Origen: /home/usuario/backup-system/test-data
    [2024-12-15 10:35:22] Destino: /home/usuario/backup-system/backups/backup-20241215-103522.tar.gz
    [2024-12-15 10:35:22] Comprimiendo archivos...
    [2024-12-15 10:35:23] Respaldo completado exitosamente
    [2024-12-15 10:35:23] Archivo: backup-20241215-103522.tar.gz
    [2024-12-15 10:35:23] Tamaño: 4.0K
    [2024-12-15 10:35:23] Total de archivos/directorios: 7
    [2024-12-15 10:35:23] Proceso de respaldo finalizado

✔ Verificación: Verifique que se crearon los archivos de respaldo y log: ```bash ls -lh ~/backup-system/backups/ ls -lh ~/backup-system/logs/ ``` Debe ver un archivo .tar.gz en backups y un archivo .log en logs con timestamps coincidentes.

### Paso 8: Verificar el contenido del archivo de respaldo creado

Liste el contenido del archivo tar.gz sin extraerlo usando el comando tar con las opciones de listado:

    tar -tzf ~/backup-system/backups/backup-*.tar.gz

La opción `-t` lista el contenido, `-z` maneja compresión gzip, y `-f` especifica el archivo.

También puede ver el archivo de log generado:

    cat ~/backup-system/logs/backup-*.log

Resultado esperado:

    test-data/
    test-data/proyecto-alpha.txt
    test-data/config-servidor.conf
    test-data/cliente-abc.txt
    test-data/documentos/
    test-data/documentos/reporte-ventas.txt
    test-data/documentos/analisis-financiero.txt

El archivo de log mostrará los mismos mensajes que aparecieron en pantalla durante la ejecución.

✔ Verificación: Confirme que todos los archivos de test-data están incluidos en el respaldo. El conteo debe coincidir con el número reportado por el script.

### Paso 9: Crear un script de limpieza de respaldos antiguos

Cree un segundo script para eliminar respaldos con más de 7 días de antigüedad:

    nano ~/backup-system/scripts/limpieza-respaldos.sh

Escriba el siguiente contenido:

    #!/bin/bash
    # Script de limpieza de respaldos antiguos

    DIR_BACKUPS="$HOME/backup-system/backups"
    DIR_LOGS="$HOME/backup-system/logs"
    DIAS_RETENCION=7
    FECHA=$(date +"%Y%m%d-%H%M%S")
    LOG_LIMPIEZA="$DIR_LOGS/limpieza-$FECHA.log"

    echo "[$(date +"%Y-%m-%d %H:%M:%S")] Iniciando limpieza de respaldos antiguos" | tee -a "$LOG_LIMPIEZA"

    # Buscar y eliminar archivos .tar.gz con más de DIAS_RETENCION días
    find "$DIR_BACKUPS" -name "backup-*.tar.gz" -type f -mtime +$DIAS_RETENCION -print -delete | while read archivo; do
        echo "[$(date +"%Y-%m-%d %H:%M:%S")] Eliminado: $archivo" | tee -a "$LOG_LIMPIEZA"
    done

    # Limpiar logs antiguos
    find "$DIR_LOGS" -name "*.log" -type f -mtime +$DIAS_RETENCION -delete

    echo "[$(date +"%Y-%m-%d %H:%M:%S")] Limpieza completada" | tee -a "$LOG_LIMPIEZA"

Guarde y cierre el archivo, luego hágalo ejecutable:

    chmod +x ~/backup-system/scripts/limpieza-respaldos.sh

Resultado esperado:

El archivo se crea y se hace ejecutable sin errores.

✔ Verificación: Verifique que el script tiene permisos de ejecución: ```bash ls -l ~/backup-system/scripts/limpieza-respaldos.sh ``` Debe mostrar -rwxr-xr-x en los permisos.

### Paso 10: Abrir el editor de crontab para configurar tareas programadas

Ejecute el comando crontab con la opción -e para editar la tabla de cron del usuario actual:

    crontab -e

Si es la primera vez que ejecuta este comando, el sistema le preguntará qué editor desea usar. Seleccione nano (generalmente la opción 1) presionando `1` y luego `Enter`.

El archivo crontab se abrirá en el editor seleccionado.

Resultado esperado:

    no crontab for usuario - using an empty one

    Select an editor.  To change later, run 'select-editor'.
      1. /bin/nano        <---- easiest
      2. /usr/bin/vim.basic
      3. /usr/bin/vim.tiny

    Choose 1-3 [1]:

Después de seleccionar el editor, se abrirá un archivo con comentarios explicativos sobre la sintaxis de crontab.

✔ Verificación: El editor se abre mostrando líneas que comienzan con # explicando el formato de crontab.

### Paso 11: Programar el respaldo automático para que se ejecute diariamente

En el editor de crontab, desplácese hasta el final del archivo (después de todos los comentarios) y agregue las siguientes líneas:

    # Respaldo automático diario a las 2:00 AM
    0 2 * * * /home/usuario/backup-system/scripts/backup-automatico.sh

    # Limpieza de respaldos antiguos los domingos a las 3:00 AM
    0 3 * * 0 /home/usuario/backup-system/scripts/limpieza-respaldos.sh

    # Respaldo adicional de lunes a viernes a las 6:00 PM
    0 18 * * 1-5 /home/usuario/backup-system/scripts/backup-automatico.sh

IMPORTANTE: Reemplace `/home/usuario` con la ruta real de su directorio home. Puede obtenerla ejecutando `echo $HOME` en otra terminal.

La sintaxis de crontab es:

- Minuto (0-59)
- Hora (0-23)
- Día del mes (1-31)
- Mes (1-12)
- Día de la semana (0-7, donde 0 y 7 son domingo)

Guarde el archivo con `Ctrl+O`, `Enter`, y salga con `Ctrl+X`.

Resultado esperado:

    crontab: installing new crontab

Este mensaje confirma que la nueva configuración de cron se instaló correctamente.

✔ Verificación: Verifique que las tareas se agregaron correctamente listando el crontab: ```bash crontab -l ``` Debe mostrar las tres entradas que agregó.

### Paso 12: Crear una tarea de cron para probar inmediatamente

Para verificar que cron funciona correctamente sin esperar a las 2:00 AM, agregaremos una tarea temporal que se ejecute en el próximo minuto.

Primero, verifique la hora actual:

    date

Anote el minuto actual. Luego edite el crontab nuevamente:

    crontab -e

Agregue una línea temporal al final. Si la hora actual es 10:35, para que se ejecute a las 10:37 (en dos minutos), agregue:

    # Prueba temporal - ELIMINAR después de verificar
    37 10 * * * /home/usuario/backup-system/scripts/backup-automatico.sh

Ajuste el minuto y hora según su hora actual más 2 minutos. Guarde y espere a que pase ese tiempo.

Resultado esperado:

    crontab: installing new crontab

Después de que pase el tiempo programado, aparecerá un nuevo archivo de respaldo en ~/backup-system/backups/ y un nuevo log.

✔ Verificación: Después de que pase el tiempo programado, verifique: ```bash ls -lt ~/backup-system/backups/ | head -3 ls -lt ~/backup-system/logs/ | head -3 ``` Debe ver archivos nuevos con timestamps recientes creados por cron.

### Paso 13: Verificar los logs del sistema de cron

El servicio cron registra sus actividades en los logs del sistema. Verifique que sus tareas se están ejecutando correctamente:

    grep CRON /var/log/syslog | tail -20

Este comando filtra las entradas relacionadas con CRON del archivo syslog y muestra las últimas 20 líneas.

También puede buscar específicamente las ejecuciones de su script:

    grep "backup-automatico.sh" /var/log/syslog

Si no tiene acceso a /var/log/syslog, puede verificar los logs generados por sus propios scripts:

    ls -ltr ~/backup-system/logs/
    cat ~/backup-system/logs/backup-*.log | tail -30

Resultado esperado:

    Dec 15 10:37:01 hostname CRON[12345]: (usuario) CMD (/home/usuario/backup-system/scripts/backup-automatico.sh)
    Dec 15 10:37:01 hostname CRON[12346]: (usuario) MAIL (mailed 245 bytes of output but got status 0x004b from MTA)

Los logs de los scripts mostrarán las ejecuciones exitosas con timestamps.

✔ Verificación: Confirme que ve entradas de CRON en syslog correspondientes a las horas en que programó las tareas de prueba.

### Paso 14: Limpiar la tarea temporal de crontab

Ahora que ha verificado que cron funciona correctamente, elimine la entrada temporal de prueba:

    crontab -e

Localice la línea que agregó para la prueba (la que tiene el comentario "Prueba temporal - ELIMINAR después de verificar") y elimínela completamente.

Deje únicamente las tres tareas programadas originales:

- Respaldo diario a las 2:00 AM
- Limpieza semanal a las 3:00 AM los domingos
- Respaldo de lunes a viernes a las 6:00 PM

Guarde el archivo con `Ctrl+O`, `Enter`, y salga con `Ctrl+X`.

Resultado esperado:

    crontab: installing new crontab

✔ Verificación: Liste el crontab final: ```bash crontab -l ``` Debe mostrar solo las tres tareas permanentes, sin la línea de prueba temporal.

### Paso 15: Crear un script de reporte de estado del sistema de respaldos

Finalmente, cree un script que genere un reporte del estado del sistema de respaldos:

    nano ~/backup-system/scripts/reporte-estado.sh

Agregue el siguiente contenido:

    #!/bin/bash
    # Reporte de estado del sistema de respaldos

    DIR_BACKUPS="$HOME/backup-system/backups"
    DIR_LOGS="$HOME/backup-system/logs"

    echo "========================================="
    echo "  REPORTE DE ESTADO - SISTEMA DE RESPALDOS"
    echo "  Generado: $(date +"%Y-%m-%d %H:%M:%S")"
    echo "========================================="
    echo ""

    echo "Tareas programadas en crontab:"
    crontab -l | grep -v "^#" | grep -v "^$"
    echo ""

    echo "Respaldos almacenados:"
    ls -lh "$DIR_BACKUPS"/*.tar.gz 2>/dev/null | wc -l | xargs echo "Total de archivos:"
    du -sh "$DIR_BACKUPS" 2>/dev/null | awk '{print "Espacio utilizado:", $1}'
    echo ""

    echo "Últimos 3 respaldos:"
    ls -lt "$DIR_BACKUPS"/*.tar.gz 2>/dev/null | head -3 | awk '{print $9, "-", $5, "bytes -", $6, $7, $8}'
    echo ""

    echo "Últimas 5 entradas de log:"
    tail -5 "$DIR_LOGS"/backup-*.log 2>/dev/null | tail -5
    echo ""

    echo "========================================="

Guarde, cierre, y haga el script ejecutable:

    chmod +x ~/backup-system/scripts/reporte-estado.sh

Ejecútelo para ver el reporte:

    ~/backup-system/scripts/reporte-estado.sh

Resultado esperado:

    =========================================
      REPORTE DE ESTADO - SISTEMA DE RESPALDOS
      Generado: 2024-12-15 11:00:45
    =========================================

    Tareas programadas en crontab:
    0 2 * * * /home/usuario/backup-system/scripts/backup-automatico.sh
    0 3 * * 0 /home/usuario/backup-system/scripts/limpieza-respaldos.sh
    0 18 * * 1-5 /home/usuario/backup-system/scripts/backup-automatico.sh

    Respaldos almacenados:
    Total de archivos: 2
    Espacio utilizado: 8.0K

    Últimos 3 respaldos:
    /home/usuario/backup-system/backups/backup-20241215-103522.tar.gz - 4096 bytes - dic 15 10:35
    /home/usuario/backup-system/backups/backup-20241215-103700.tar.gz - 4096 bytes - dic 15 10:37

    Últimas 5 entradas de log:
    [2024-12-15 10:37:23] Respaldo completado exitosamente
    [2024-12-15 10:37:23] Archivo: backup-20241215-103700.tar.gz
    [2024-12-15 10:37:23] Tamaño: 4.0K
    [2024-12-15 10:37:23] Total de archivos/directorios: 7
    [2024-12-15 10:37:23] Proceso de respaldo finalizado

    =========================================

✔ Verificación: El reporte debe mostrar todas las tareas de cron programadas, el número de respaldos, espacio utilizado, y las últimas entradas de log.

## Solución de problemas

Problema: El script muestra 'Permission denied' al intentar ejecutarlo
Solución: Esto ocurre cuando el archivo no tiene permisos de ejecución. Solucione ejecutando: chmod +x ~/backup-system/scripts/nombre-del-script.sh. Verifique los permisos con ls -l y confirme que aparecen las 'x' en la columna de permisos.
Problema: El comando crontab -e muestra 'no crontab for usuario' y no se ejecutan las tareas
Solución: Esto es normal la primera vez que usa crontab. Simplemente seleccione un editor (nano es el más sencillo), agregue sus entradas, guarde y salga. Verifique que se instaló correctamente con 'crontab -l'. Si las tareas aún no se ejecutan, verifique que el servicio cron está activo ejecutando: sudo systemctl status cron
Problema: Las tareas de cron no se ejecutan a la hora programada
Solución: Verifique que: 1) El servicio cron está ejecutándose con 'sudo systemctl status cron'. 2) Las rutas en el crontab son absolutas (no use ~, use /home/usuario). 3) Los scripts tienen permisos de ejecución. 4) Revise los logs del sistema con 'grep CRON /var/log/syslog' para ver mensajes de error. 5) Confirme que la sintaxis de crontab es correcta (minuto hora día mes día-semana).
Problema: El script de respaldo falla con 'tar: Cannot stat: No such file or directory'
Solución: Esto indica que las rutas especificadas en las variables DIR_ORIGEN o DIR_DESTINO no existen o son incorrectas. Verifique que los directorios existen ejecutando 'ls -ld $DIR_ORIGEN' y 'ls -ld $DIR_DESTINO'. Asegúrese de que las variables están correctamente definidas en el script sin errores tipográficos. También puede agregar 'set -x' después del shebang para ver el debug de cada comando ejecutado.
Problema: Los archivos de log no se crean o están vacíos
Solución: Verifique que: 1) El directorio de logs existe y tiene permisos de escritura con 'ls -ld ~/backup-system/logs'. 2) La variable ARCHIVO_LOG está correctamente definida en el script. 3) La función log_mensaje está usando 'tee -a' correctamente para escribir al archivo. 4) Ejecute el script manualmente y observe si hay mensajes de error relacionados con la escritura de archivos. Si usa cron, asegúrese de que las rutas son absolutas.

## Ejercicio de desafío

### Sistema Avanzado de Respaldos con Rotación y Notificaciones

Amplíe el sistema de respaldos implementado con las siguientes mejoras:

1. Rotación inteligente de respaldos: Modifique el script de limpieza para mantener:

   - Los últimos 7 respaldos diarios
   - Los últimos 4 respaldos semanales (uno por semana)
   - Los últimos 6 respaldos mensuales (uno por mes)
   - Elimine todos los demás respaldos más antiguos

2. Sistema de notificaciones por email: Configure el script de respaldo para enviar un correo electrónico al administrador cuando:

   - El respaldo se completa exitosamente
   - Ocurre un error durante el respaldo
   - El espacio en disco disponible es menor al 20%
   - Incluya un resumen del tamaño del respaldo y número de archivos

3. Verificación de integridad: Agregue una función que verifique la integridad del archivo tar.gz creado usando el comando `tar -tzf` y registre si la verificación fue exitosa.

4. Respaldo incremental: Implemente un segundo script que realice respaldos incrementales usando `rsync` en lugar de tar, manteniendo sincronizada una copia espejo de los datos en un segundo directorio.

5. Variables de entorno: Cree un archivo de configuración separado (~/.backup-config) que contenga todas las variables (directorios, días de retención, email del administrador) y modifique los scripts para leer estas configuraciones en lugar de tener las variables hardcoded.

Pistas:

- Investigue el comando `mail` o `sendmail` para enviar correos desde scripts
- Use `df -h` para verificar espacio en disco disponible
- Para respaldos incrementales, explore las opciones `--archive`, `--verbose`, `--delete` de rsync
- Los archivos de configuración pueden ser 'sourced' en bash con el comando `source` o `.`
- Para implementar rotación inteligente, necesitará usar `find` con diferentes condiciones de tiempo y lógica condicional más compleja

Criterios de éxito: El sistema debe ejecutarse automáticamente, mantener diferentes generaciones de respaldos, notificar al administrador de eventos importantes, y toda la configuración debe ser centralizada y fácil de modificar.

# Preguntas de práctica

1. ¿Cuál es el propósito de la línea shebang (#!/bin/bash) al inicio de un script bash?

A) Indica al sistema qué intérprete debe usar para ejecutar el script

B) Define el directorio de trabajo del script

C) Establece permisos de ejecución automáticamente

D) Crea una variable de entorno global

2. ¿Qué comando se utiliza para hacer que un script sea ejecutable?

A) chown +x script.sh

B) chmod +x script.sh

C) execute script.sh

D) setexec script.sh

3. En la sintaxis de crontab, ¿qué representa la entrada '30 2 * * *'?

A) Ejecutar cada 30 minutos durante 2 horas

B) Ejecutar a las 2:30 AM todos los días

C) Ejecutar 2 veces cada 30 días

D) Ejecutar cada 2 días a las 30 horas

4. ¿Cuál es la diferencia principal entre usar > y >> para redirección de salida?

A) > añade al final del archivo, >> sobrescribe el archivo

B) > sobrescribe el archivo, >> añade al final del archivo

C) > redirige errores, >> redirige salida estándar

D) > funciona solo con archivos de log, >> funciona con cualquier archivo

5. ¿Qué comando permite editar las tareas programadas del usuario actual en cron?

A) cron -edit

B) crontab -e

C) edit-cron

D) vi /etc/crontab

6. ¿Cuál es la ventaja principal de usar rsync en lugar de tar para respaldos?

A) rsync comprime mejor los archivos que tar

B) rsync solo copia archivos modificados, haciendo respaldos incrementales eficientes

C) rsync puede crear archivos comprimidos mientras tar no puede

D) rsync requiere menos espacio en disco que tar

7. ¿Dónde se encuentran típicamente los archivos de log del servicio cron en sistemas Linux?

A) /var/log/cron

B) /etc/cron/logs

C) /home/cron/log

D) /usr/local/cron.log

8. ¿Qué hace el comando 'export' cuando se usa con una variable en un script bash?

A) Elimina la variable del sistema

B) Hace que la variable esté disponible para procesos hijos del script

C) Exporta la variable a un archivo externo

D) Convierte la variable en constante inmutable

9. En un script de respaldo, ¿por qué es importante verificar el código de salida ($?) después de ejecutar comandos críticos?

A) Para calcular cuánto tiempo tomó el comando

B) Para determinar si el comando se ejecutó exitosamente o falló

C) Para obtener el número de archivos procesados

D) Para conocer el tamaño total de los datos respaldados

10. ¿Cuál es la mejor práctica para prevenir que múltiples instancias del mismo script se ejecuten simultáneamente?

A) Programar el script solo una vez al día en crontab

B) Implementar un archivo de bloqueo (lock file) que el script verifica al inicio

C) Usar el comando 'sleep' para retrasar la ejecución

D) Ejecutar el script manualmente en lugar de usar cron

# Resumen del módulo

Este módulo presentó las herramientas esenciales de automatización en Linux: bash scripting y cron. Los administradores aprendieron a crear scripts efectivos con estructura apropiada (shebang, variables, condicionales), gestionar entrada/salida mediante redirección y pipes, y programar tareas recurrentes usando la sintaxis crontab. El módulo cubrió casos de uso prácticos como respaldos automatizados con tar y rsync, limpieza de logs antiguos, y tareas de mantenimiento del sistema. Las mejores prácticas incluyen usar rutas absolutas, implementar bloqueos de ejecución, validar requisitos previos, y mantener logs detallados para monitoreo y depuración. Dominar estas técnicas permite a los administradores gestionar infraestructura de forma eficiente, consistente y escalable.

# 🎯 Day 1 Laboratorio final: Implementación de Infraestructura Segura para Plataforma de Analítica de Datos

Tiempo estimado: 240 minutos

Platform: ubuntu

📖 Reference: Si necesita detalles procedimentales paso a paso sobre alguna habilidad individual, consulte las guías de laboratorio de los módulos de esta mañana.

## Skills Integration

- Gestión de usuarios y grupos con permisos diferenciados
- Configuración de firewall UFW con reglas específicas por servicio
- Implementación de autenticación SSH basada en claves
- Configuración de red estática con netplan
- Diagnóstico de conectividad de red
- Monitoreo de recursos del sistema
- Gestión y optimización de procesos
- Automatización mediante scripts bash
- Programación de tareas con cron

## Descripción del escenario

## Contexto Empresarial

Ha sido contratado como administrador de sistemas Linux para DataVision Analytics, una empresa mediana de consultoría que está desplegando un nuevo servidor de análisis de datos para su equipo de científicos de datos. El servidor Ubuntu (hostname: `dv-analytics-prod01`) alojará aplicaciones de procesamiento de datos sensibles y debe cumplir con los estándares de seguridad corporativos antes de entrar en producción.

El equipo de TI corporativo le ha asignado el segmento de red `10.88.50.0/24` para este servidor. El gateway de red es `10.88.50.1` y los servidores DNS corporativos son `10.88.10.53` y `10.88.10.54`.

Tres equipos diferentes necesitarán acceso a este servidor:

- Equipo de Científicos de Datos (3 analistas): necesitan ejecutar trabajos de procesamiento y acceder a directorios de proyectos compartidos
- Equipo de Ingeniería de Datos (2 ingenieros): requieren privilegios elevados para instalar paquetes y configurar servicios
- Equipo de Auditoría (1 auditor): necesita acceso de solo lectura para revisar logs y configuraciones

El servidor debe estar operativo para el lunes. Su Director de TI espera un sistema endurecido, monitoreado y con procedimientos de mantenimiento automatizados funcionando antes de autorizar el acceso de usuarios finales.

## Estado final deseado

## Estado Final Requerido

Al completar este proyecto, el servidor `dv-analytics-prod01` debe cumplir con las siguientes especificaciones:

### Configuración de Red

- Dirección IP estática `10.88.50.42/24` configurada y persistente tras reinicio
- Gateway predeterminado y servidores DNS corporativos configurados correctamente
- Conectividad verificable hacia gateway, DNS externo y servidores corporativos
- Hostname del sistema correctamente establecido

### Estructura de Usuarios y Permisos

- Tres grupos de trabajo creados con permisos diferenciados: `data-scientists`, `data-engineers`, `auditors`
- Seis cuentas de usuario creadas y asignadas a grupos apropiados:
  - Científicos de datos: `mrodriguez`, `alopez`, `cgarcia`
  - Ingenieros de datos: `jmartinez`, `pfernandez`
  - Auditoría: `lsanchez`
- Estructura de directorios de proyecto en `/opt/analytics-projects/` con permisos por grupo:
  - Directorio `datasets/`: lectura/escritura para científicos e ingenieros, solo lectura para auditoría
  - Directorio `notebooks/`: lectura/escritura para científicos, solo lectura para otros
  - Directorio `config/`: lectura/escritura solo para ingenieros, solo lectura para científicos
  - Directorio `logs/`: solo lectura para todos los grupos
- Privilegios sudo configurados: ingenieros pueden ejecutar comandos específicos de gestión de paquetes y servicios; científicos y auditores sin sudo

### Seguridad de Red y Acceso

- Firewall UFW activo con política predeterminada de denegar todo tráfico entrante
- Reglas específicas que permitan:
  - SSH (puerto 2244) solo desde red corporativa `10.88.0.0/16`
  - Puerto 8888 (Jupyter) solo desde segmento de analistas `10.88.20.0/24`
  - Puerto 5432 (PostgreSQL) solo desde servidor de base de datos `10.88.30.15`
- Servicio SSH configurado en puerto no estándar 2244
- Autenticación SSH por contraseña deshabilitada; solo autenticación por clave pública
- Claves SSH públicas implementadas para al menos dos usuarios de prueba

### Monitoreo y Mantenimiento Automatizado

- Script bash `/usr/local/bin/system-health-check.sh` que:
  - Verifica uso de CPU, memoria y espacio en disco
  - Identifica los 5 procesos que más consumen recursos
  - Registra hallazgos en `/var/log/analytics/health-checks.log` con timestamp
  - Envía alerta al log del sistema si algún recurso supera 85% de uso
- Script bash `/usr/local/bin/project-backup.sh` que:
  - Crea copia comprimida de `/opt/analytics-projects/` en `/backup/analytics/`
  - Incluye fecha en nombre del archivo de respaldo
  - Rota respaldos manteniendo solo los últimos 7 días
  - Registra éxito o fracaso de operación en `/var/log/analytics/backups.log`
- Trabajos cron configurados:
  - Health check ejecutándose cada 2 horas
  - Respaldo de proyectos ejecutándose diariamente a las 2:00 AM
  - Limpieza de logs temporales cada domingo a las 3:00 AM

### Documentación de Verificación

- Archivo `/root/deployment-verification.txt` que contenga:
  - Salida de comandos de verificación de red (ip addr, rutas, DNS)
  - Lista de usuarios y grupos creados
  - Estado actual del firewall con todas las reglas
  - Salida de última ejecución manual de ambos scripts de mantenimiento
  - Lista de trabajos cron configurados
  - Snapshot de top 10 procesos por uso de recursos

El sistema debe ser robusto, seguro, y capaz de reiniciarse sin pérdida de configuración. Todos los servicios automatizados deben ejecutarse exitosamente de forma independiente.

## Restricciones

- NO puede usar herramientas de gestión de configuración como Ansible, Puppet o Chef — toda configuración debe realizarse mediante comandos estándar de Linux
- Las claves SSH deben generarse en el servidor; NO puede usar claves preexistentes o de otros sistemas
- Los scripts de automatización deben incluir manejo de errores y validación — no pueden asumir que comandos siempre tienen éxito
- La estructura de directorios `/opt/analytics-projects/` debe crearse con permisos que NO requieran que usuarios ejecuten comandos con sudo para trabajo diario
- El firewall debe configurarse de manera que proteja el sistema pero NO bloquee el acceso SSH del administrador durante la configuración
- Los scripts de respaldo deben verificar que los directorios de destino existan antes de intentar operaciones de copia
- NO puede deshabilitar SELinux o AppArmor si están activos — las configuraciones deben trabajar dentro de los contextos de seguridad existentes
- La configuración de red debe utilizar netplan — NO puede editar directamente archivos /etc/network/interfaces
- Los trabajos cron deben ejecutarse como usuarios apropiados, no todo como root
- Debe documentar todos los comandos ejecutados y sus resultados en el archivo de verificación especificado