Si el comando a ejecutar es un script, utiliza su ruta absoluta.

#!/bin/bash

# Nombre: fecha_hora.sh

# Descripción: Guarda la fecha y hora actual en un archivo

# Definir el archivo de salida
archivo="$HOME/fecha_hora.log"

# Escribir la fecha y hora en el archivo
echo "Fecha y hora: $(date '+%d/%m/%Y %H:%M:%S')" >> "$archivo"

# 1. Crear el script
nano ~/fecha_hora.sh

# 2. Dar permisos de ejecución
chmod +x ~/fecha_hora.sh

# 3. Probar el script
./fecha_hora.sh
cat ./fecha_hora.log

# 4. Editar crontab
crontab -e

# 5. Añadir esta línea al crontab:
* * * * * $HOME/fecha_hora.sh

# 6. Verificar que se añadió correctamente
crontab -l

# 7. Esperar 1-2 minutos y verificar el archivo
tail -f ~/fecha_hora.log

#!/bin/bash

# Nombre: hola_cron.sh

# Descripción: Escribe un mensaje en un archivo cada 5 minutos

# Archivo de salida
archivo="$HOME/hola_cron.log"

# Escribir mensaje con fecha
echo "[$(date '+%Y-%m-%d %H:%M:%S')] Hola desde cron" >> "$archivo"
Configurar crontab:

# 1. Crear y preparar el script
nano ~/hola_cron.sh
chmod +x ~/hola_cron.sh

# 2. Editar crontab
crontab -e

# 3. Añadir esta línea (ejecutar cada 5 minutos):
*/5 * * * * $HOME/hola_cron.sh

# 4. Verificar
crontab -l

# 5. Monitorear el archivo
tail -f ~/hola_cron.log

#!/bin/bash

# Nombre: backup_diario.sh

# Descripción: Realiza backup comprimido de una carpeta

# Configuración
carpeta_origen="$HOME/documentos"
carpeta_destino="$HOME/backups"
fecha=$(date '+%Y%m%d_%H%M%S')
nombre_backup="backup_${fecha}.tar.gz"

# Crear carpeta de destino si no existe
mkdir -p "$carpeta_destino"

# Archivo donde se registra lo que pasa
log_file="$HOME/backups/backup.log"

# Realizar backup
tar -czf "$carpeta_destino/$nombre_backup" -C "$HOME" "documentos" 2>/dev/null

# OJO: $? hay que comprobarlo AQUI, en la linea siguiente al comando.
# Si entre medias metes cualquier otra cosa (aunque sea una asignacion),
# $? pasa a ser el resultado de ESA otra cosa y no el del tar.
if [ $? -eq 0 ]; then
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Backup exitoso: $nombre_backup" >> "$log_file"
else
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Error en backup" >> "$log_file"
fi

# Opcional: Eliminar backups antiguos (más de 7 días)
find "$carpeta_destino" -name "backup_*.tar.gz" -mtime +7 -delete

# 1. Crear el script
nano ~/backup_diario.sh
chmod +x ~/backup_diario.sh

# 2. Crear carpetas necesarias
mkdir -p ~/documentos ~/backups

# 3. Probar el script manualmente
~/backup_diario.sh
ls -lh ~/backups/

# 4. Editar crontab
crontab -e

# 6. Verificar
crontab -l

#!/bin/bash

# Nombre: limpiar_logs.sh

# Descripción: Elimina archivos .log de carpeta temporal

# Carpeta a limpiar
carpeta_temporal="$HOME/temp_logs"

# Archivo de registro
log_limpieza="$HOME/limpieza.log"

# Crear carpeta si no existe
mkdir -p "$carpeta_temporal"

# Contar archivos antes de eliminar
cantidad_antes=$(find "$carpeta_temporal" -name "*.log" -type f | wc -l)

# Eliminar archivos .log
find "$carpeta_temporal" -name "*.log" -type f -delete

# Contar archivos después
cantidad_despues=$(find "$carpeta_temporal" -name "*.log" -type
f | wc -l)
eliminados=$((cantidad_antes - cantidad_despues))

# Registrar la acción
echo "[$(date '+%Y-%m-%d %H:%M:%S')] Archivos .log eliminados: $eliminados" >> "$log_limpieza"
Configurar crontab:

# 1. Crear el script
nano ~/limpiar_logs.sh
chmod +x ~/limpiar_logs.sh

# 2. Crear carpeta temporal y algunos archivos de prueba
mkdir -p ~/temp_logs
touch ~/temp_logs/test{1..5}.log

# 3. Probar el script
~/limpiar_logs.sh
cat ~/limpieza.log

# 4. Editar crontab
crontab -e

# 5. Añadir para ejecutar domingos a medianoche:

# 6. Verificar
crontab -l

#!/bin/bash

# Nombre: horario_laboral.sh

# Descripción: Registra la hora durante el horario laboral

# Archivo de salida
archivo="$HOME/horario_laboral.log"

# Escribir hora actual
echo "Hora registrada: $(date '+%H:%M:%S - %d/%m/%Y')" >> "$archivo"
Configurar crontab:

# 1. Crear el script
nano ~/horario_laboral.sh
chmod +x ~/horario_laboral.sh

# 2. Probar
~/horario_laboral.sh
cat ~/horario_laboral.log

# 3. Editar crontab
crontab -e

# 4. Añadir para ejecutar cada hora de 9 AM a 5 PM:

# El rango 9-17 SI incluye las 17:00, así que son 9 ejecuciones:
# 9, 10, 11, 12, 13, 14, 15, 16 y 17.
# Si quisieras llegar hasta las 18:00, tendrías que poner 9-18.

# 5. Verificar
crontab -l

#!/bin/bash

# Nombre: practicar.sh

# Descripción: Recordatorio para practicar lunes, miércoles y viernes

# Archivo de log
archivo="$HOME/recordatorios.log"

# Obtener el día de la semana
dia_semana=$(date '+%A')

# Escribir mensaje
echo "[$(date '+%Y-%m-%d %H:%M:%S')] - $dia_semana - Hoy toca practicar" >> "$archivo"
Configurar crontab:

# 1. Crear el script
nano ~/practicar.sh
chmod +x ~/practicar.sh

# 2. Probar
~/practicar.sh
cat ~/recordatorios.log

# 3. Editar crontab
crontab -e

# 4. Añadir para lunes (1), miércoles (3) y viernes (5) a las 8:00
AM:

# 5. Verificar
crontab -l

#!/bin/bash

# Nombre: fecha_hora_logs.sh

# Descripción: Guarda fecha/hora con manejo de salida y errores
archivo="$HOME/fecha_hora_output.log"

# Simulando algunas operaciones que podrían generar salida y errores
echo "=== Inicio de ejecución ==="
echo "Fecha y hora: $(date '+%d/%m/%Y %H:%M:%S')" >> "$archivo"

# Verificar si el archivo se creó correctamente
if [ $? -eq 0 ]; then
    echo "Registro exitoso"
else
    echo "Error al escribir en el archivo" >&2
fi

# 1. Crear el script
nano ~/fecha_hora_logs.sh
chmod +x ~/fecha_hora_logs.sh

# 2. Editar crontab
crontab -e

# 3. OPCIÓN 1: Redirigir salida estándar y errores al mismo archivo
* * * * * $HOME/fecha_hora_logs.sh >> $HOME/cron.log 2>&1

# 4. OPCIÓN 2: Redirigir a archivos separados
* * * * * $HOME/fecha_hora_logs.sh >> $HOME/cron_output.log
2>> $HOME/cron_error.log

# 5. OPCIÓN 3: Solo errores a archivo, salida descartada
* * * * * $HOME/fecha_hora_logs.sh > /dev/null 2>> $HOME/cron.log

# 6. Verificar
crontab -l

# 7. Ver los logs
tail -f ~/cron.log

# &>> = Añadir tanto salida como errores (bash 4+)
comando > /dev/null 2>&1

# Descartar toda salida y errores

#!/bin/bash

# Nombre: sistema_ok.sh

# Descripción: Monitoreo simple del sistema

# Archivo de log
log_file="$HOME/sistema_monitor.log"

# Obtener información del sistema
carga=$(uptime | awk -F'load average:' '{print $2}' | awk
'{print $1}')
memoria_libre=$(free -h 2>/dev/null | grep Mem | awk '{print
$4}' || echo "N/A")

# Escribir estado
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Sistema OK - Carga: $carga - Memoria libre: $memoria_libre" >> "$log_file"
    Versión simplificada:

    #!/bin/bash

    # sistema_ok_simple.sh
    archivo="$HOME/sistema_ok.log"
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Sistema OK" >> "$archivo"
    Configurar crontab:

    # 1. Crear el script (versión simple)
    nano ~/sistema_ok.sh
    chmod +x ~/sistema_ok.sh

    # 2. Probar
    ~/sistema_ok.sh
    cat ~/sistema_ok.log

    # 3. Editar crontab
    crontab -e

    # 4. Añadir para ejecutar cada 10 minutos:
    */10 * * * * $HOME/sistema_ok.sh

    # 5. Verificar
    crontab -l

    # 6. Monitorear
    tail -f ~/sistema_ok.log

#!/bin/bash

# Nombre: reporte_mensual.sh

# Descripción: Genera archivo de reporte mensual

# Directorio de reportes
dir_reportes="$HOME/reportes_mensuales"
mkdir -p "$dir_reportes"

# Generar nombre de archivo con fecha
fecha=$(date '+%Y-%m-%d')
mes_anio=$(date '+%Y-%m')
archivo="$dir_reportes/reporte_${mes_anio}.txt"

# Crear contenido del reporte
{
    echo "======================================"
    echo "REPORTE MENSUAL"
    echo "======================================"
    echo "Fecha de generación: $fecha"
    echo "Hora: $(date '+%H:%M:%S')"
    echo ""
    echo "Sistema: $(uname -s)"
    echo "Usuario: $USER"
    echo "Hostname: $(hostname)"
    echo ""
    echo "Directorio home: $HOME"
    echo "Espacio en disco:"
    df -h "$HOME" | tail -1
    echo ""
    echo "======================================"
} > "$archivo"

# Log de ejecución
log_file="$HOME/reportes_mensuales/ejecucion.log"
echo "[$(date '+%Y-%m-%d %H:%M:%S')] Reporte mensual generado: $archivo" >> "$log_file"
Configurar crontab:

# 1. Crear el script
nano ~/reporte_mensual.sh
chmod +x ~/reporte_mensual.sh

# 2. Probar manualmente
~/reporte_mensual.sh
ls -lh ~/reportes_mensuales/
cat ~/reportes_mensuales/reporte_*.txt

# 3. Editar crontab
crontab -e

# 5. Verificar
crontab -l

55 23 28-31 * * [ "$(date -d tomorrow +\%d)" = "01" ] && $HOME/cierre_mes.sh

#!/bin/bash

# Nombre: probar_cron.sh

# Descripción: Script de prueba para verificar cron

# Archivo de salida
archivo="$HOME/prueba_cron.log"

# Escribir mensaje
echo "[$(date '+%Y-%m-%d %H:%M:%S')] Probando cron - Ejecución exitosa" >> "$archivo"

# 1. Crear el script
nano ~/probar_cron.sh
chmod +x ~/probar_cron.sh

# 2. Probar manualmente
~/probar_cron.sh
cat ~/prueba_cron.log

# 3. Editar crontab
crontab -e

# 4. Añadir para ejecutar cada 5 minutos (para prueba rápida):
*/5 * * * * $HOME/probar_cron.sh

# 5. Verificar que se añadió
crontab -l

# Logs del sistema
tail -f /var/log/system.log | grep cron

# Verificar que cron está corriendo
    ps aux | grep cron

# Ver tu crontab actual
crontab -l

# Ver el archivo de salida del script
cat ~/prueba_cron.log

# Ver en tiempo real las nuevas líneas
tail -f ~/prueba_cron.log

# Verificar permisos del script
ls -l ~/probar_cron.sh

# Verificar que cron está activo

# Linux:
sudo systemctl status cron

# o
sudo service cron status

# macOS:
sudo launchctl list | grep cron

# Ver todas las tareas cron del sistema (root)
sudo crontab -l

# Editar variables de entorno en crontab (si necesario)
crontab -e

# Añadir al inicio:

# PATH=/usr/local/bin:/usr/bin:/bin

    # SHELL=/bin/bash

# Si cron no ejecuta el script:

# 1. Verificar que el script tiene permisos de ejecución
chmod +x ~/probar_cron.sh

# 2. Usar rutas absolutas en crontab

# Correcto: /home/usuario/probar_cron.sh

# Incorrecto: ~/probar_cron.sh

# 3. Redirigir salida y errores para debug
*/5 * * * * $HOME/probar_cron.sh >> $HOME/cron_debug.log
2>&1

# 4. Verificar que el servicio cron está corriendo
    sudo systemctl start cron # Linux

    # En macOS cron siempre está activo

    # 5. Verificar sintaxis del crontab

    # Después de editar, si hay errores, crontab te avisará