Pruebas de Condiciones en Linux

Introducción

En este laboratorio, aprenderá cómo utilizar las pruebas de condiciones de Linux para automatizar las comprobaciones y validaciones del sistema. Linux proporciona el poderoso comando test que le permite evaluar condiciones y ejecutar acciones basadas en los resultados. Comprender cómo usar este comando es esencial para escribir scripts de shell que puedan tomar decisiones y responder a diferentes condiciones.

A lo largo de este laboratorio, trabajará con varios aspectos del comando test, incluyendo la prueba de archivos, la comparación de cadenas y la evaluación numérica. Al final de esta sesión, podrá escribir scripts que puedan realizar comprobaciones automatizadas en su sistema y ayudar a mantener su integridad.

Comprender los conceptos básicos del comando test

El comando test en Linux es una herramienta crucial para evaluar condiciones en scripts de shell. Permite comprobar las propiedades de archivos, comparar cadenas, evaluar valores numéricos y más. Cuando la condición que se está probando es verdadera, test devuelve un estado de salida igual a cero; de lo contrario, devuelve un estado de salida distinto de cero.

Comencemos con los conceptos básicos. Primero, navegue hasta el directorio de su proyecto:

cd ~/project

El comando test se puede escribir de dos maneras:

1. Utilizando la palabra test seguida de la condición
2. Utilizando corchetes cuadrados [ ] alrededor de la condición

Probemos ambos métodos para comprobar si un directorio existe:

## Método 1: Utilizando la palabra 'test'
test -d ~/project && echo "El directorio del proyecto existe."

## Método 2: Utilizando corchetes cuadrados
[ -d ~/project ] && echo "El directorio del proyecto existe."

Debería ver la siguiente salida para ambos comandos:

El directorio del proyecto existe.

La opción -d comprueba si un directorio existe. El operador && se utiliza para ejecutar el comando echo solo si la condición de prueba es verdadera.

Algunas opciones comunes de prueba de archivos incluyen:

• -d archivo: Verdadero si el archivo existe y es un directorio
• -e archivo: Verdadero si el archivo existe
• -f archivo: Verdadero si el archivo existe y es un archivo regular
• -r archivo: Verdadero si el archivo existe y es legible
• -w archivo: Verdadero si el archivo existe y es escribible
• -x archivo: Verdadero si el archivo existe y es ejecutable
• -s archivo: Verdadero si el archivo existe y tiene un tamaño mayor que cero

Creemos un archivo de prueba y comprobemos sus propiedades:

## Crear un archivo de prueba
echo "Hello, Linux condition testing!" > test_file.txt

## Comprobar si el archivo existe
test -e test_file.txt && echo "El archivo existe."

## Comprobar si el archivo es legible
[ -r test_file.txt ] && echo "El archivo es legible."

## Comprobar si el archivo está vacío
[ -s test_file.txt ] && echo "El archivo no está vacío."

Estos comandos deberían producir la siguiente salida:

El archivo existe.
El archivo es legible.
El archivo no está vacío.

Ahora, creemos un script de shell simple que utilice el comando test para comprobar si un archivo existe y, si no, crearlo:

## Crear un archivo de script
cat > check_file.sh << 'EOF'
#!/bin/bash

FILENAME="status.txt"

if [ ! -e "$FILENAME" ]; then
  echo "El archivo $FILENAME no existe. Creándolo ahora."
  echo "This is a status file." > "$FILENAME"
else
  echo "El archivo $FILENAME ya existe."
fi

## Mostrar el contenido del archivo
echo "Contenido de $FILENAME:"
cat "$FILENAME"
EOF

## Hacer el script ejecutable
chmod +x check_file.sh

## Ejecutar el script
./check_file.sh

Cuando ejecute el script, debería ver una salida similar a:

El archivo status.txt no existe. Creándolo ahora.
Contenido de status.txt:
This is a status file.

Si ejecuta el script de nuevo, verá:

El archivo status.txt ya existe.
Contenido de status.txt:
This is a status file.

Esto demuestra cómo utilizar el comando test para comprobar la existencia de un archivo y tomar diferentes acciones en función del resultado.

Prueba de condiciones de cadenas

En este paso, aprenderá cómo utilizar el comando test para comparar cadenas. Esto es útil cuando necesita validar la entrada del usuario, verificar variables de entorno o tomar decisiones basadas en el contenido de texto.

Los operadores comunes de comparación de cadenas incluyen:

• ==: Igual a
• !=: Diferente de
• -z: Verdadero si la cadena está vacía
• -n: Verdadero si la cadena no está vacía

Comencemos probando diferentes condiciones de cadenas:

## Probar si dos cadenas son iguales
str1="linux"
str2="linux"
[ "$str1" == "$str2" ] && echo "Las cadenas son iguales."

## Probar si dos cadenas son diferentes
str3="ubuntu"
[ "$str1" != "$str3" ] && echo "Las cadenas son diferentes."

## Probar si una cadena está vacía
empty_str=""
[ -z "$empty_str" ] && echo "La cadena está vacía."

## Probar si una cadena no está vacía
[ -n "$str1" ] && echo "La cadena no está vacía."

La salida debería ser:

Las cadenas son iguales.
Las cadenas son diferentes.
La cadena está vacía.
La cadena no está vacía.

Ahora, creemos un script que solicite una contraseña y verifique si cumple con ciertos criterios:

## Crear un script de validación de contraseña
cat > password_check.sh << 'EOF'
#!/bin/bash

echo "Ingrese una contraseña:"
read -s password

## Verificar si la contraseña está vacía
if [ -z "$password" ]; then
  echo "Error: La contraseña no puede estar vacía."
  exit 1
fi

## Verificar la longitud de la contraseña
if [ ${#password} -lt 8 ]; then
  echo "Error: La contraseña debe tener al menos 8 caracteres."
  exit 1
fi

## Verificar si la contraseña contiene la palabra "password"
if [[ "$password" == *password* ]]; then
  echo "Error: La contraseña no puede contener la palabra 'password'."
  exit 1
fi

echo "La contraseña es válida!"
EOF

## Hacer el script ejecutable
chmod +x password_check.sh

## Ejecutar el script
echo "Puedes probar el script ejecutando: ./password_check.sh"

Intente ejecutar el script con diferentes contraseñas para ver cómo valida la entrada:

## Probar con una contraseña corta
echo "short" | ./password_check.sh

## Probar con una contraseña que contenga "password"
echo "mypassword123" | ./password_check.sh

## Probar con una contraseña válida
echo "SecurePass123" | ./password_check.sh

Las dos primeras pruebas deben fallar, mientras que la tercera debe tener éxito.

Ahora, creemos otro script que procese el estado del sistema basado en una entrada de texto:

## Crear un script de estado del sistema
cat > system_status.sh << 'EOF'
#!/bin/bash

echo "Ingrese el estado del sistema (normal, warning, critical):"
read status

if [ -z "$status" ]; then
  echo "No se proporcionó un estado. Asumiendo funcionamiento normal."
  status="normal"
fi

case "$status" in
  "normal")
    echo "El sistema está funcionando normalmente. No se requiere acción."
    ;;
  "warning")
    echo "Advertencia: El sistema requiere atención. Verifique los archivos de registro."
    ;;
  "critical")
    echo "CRÍTICO: Se requiere acción inmediata. La estabilidad del sistema está en riesgo."
    ;;
  *)
    echo "Estado desconocido: $status. Por favor, use normal, warning o critical."
    ;;
esac
EOF

## Hacer el script ejecutable
chmod +x system_status.sh

## Ejecutar el script
echo "Puedes probar el script ejecutando: ./system_status.sh"

Intente ejecutar el script con diferentes entradas de estado:

## Probar con estado "normal"
echo "normal" | ./system_status.sh

## Probar con estado "warning"
echo "warning" | ./system_status.sh

## Probar con estado "critical"
echo "critical" | ./system_status.sh

## Probar con un estado inválido
echo "unstable" | ./system_status.sh

## Probar con entrada vacía
echo "" | ./system_status.sh

Cada entrada debe producir una salida diferente según la lógica condicional del script.

Prueba de condiciones numéricas

En este paso, aprenderá cómo utilizar el comando test para comparaciones numéricas. Esto es útil para verificar el uso de recursos, validar la entrada del usuario o tomar decisiones basadas en valores numéricos.

Los operadores comunes de comparación numérica incluyen:

• -eq: Igual a
• -ne: Diferente de
• -lt: Menor que
• -le: Menor o igual que
• -gt: Mayor que
• -ge: Mayor o igual que

Comencemos con algunas comparaciones numéricas básicas:

## Comparar dos números
num1=10
num2=20

## Igual a
[ $num1 -eq 10 ] && echo "$num1 es igual a 10"

## Diferente de
[ $num1 -ne $num2 ] && echo "$num1 no es igual a $num2"

## Menor que
[ $num1 -lt $num2 ] && echo "$num1 es menor que $num2"

## Mayor que
[ $num2 -gt $num1 ] && echo "$num2 es mayor que $num1"

## Menor o igual que
[ $num1 -le 10 ] && echo "$num1 es menor o igual que 10"

## Mayor o igual que
[ $num2 -ge 20 ] && echo "$num2 es mayor o igual que 20"

La salida debería ser así:

10 es igual a 10
10 no es igual a 20
10 es menor que 20
20 es mayor que 10
10 es menor o igual que 10
20 es mayor o igual que 20

Ahora, creemos un script que verifique el espacio en disco y emita una alerta cuando esté por debajo de un cierto umbral:

## Crear un script de comprobación de espacio en disco
cat > disk_check.sh << 'EOF'
#!/bin/bash

## Obtener el porcentaje de uso del disco (eliminando el signo %)
DISK_USAGE=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')

## Establecer umbrales
WARNING_THRESHOLD=70
CRITICAL_THRESHOLD=90

echo "Uso actual del disco: $DISK_USAGE%"

if [ $DISK_USAGE -ge $CRITICAL_THRESHOLD ]; then
  echo "CRÍTICO: ¡El uso del disco es críticamente alto!"
  echo "Acción: Limpie archivos innecesarios inmediatamente."
elif [ $DISK_USAGE -ge $WARNING_THRESHOLD ]; then
  echo "ADVERTENCIA: El uso del disco está aumentando."
  echo "Acción: Considere limpiar algunos archivos pronto."
else
  echo "OK: El uso del disco es normal."
  echo "No se requiere acción."
fi
EOF

## Hacer el script ejecutable
chmod +x disk_check.sh

## Ejecutar el script
./disk_check.sh

El script mostrará el uso actual del disco y emitirá un mensaje diferente según el nivel de llenado del disco.

Ahora, creemos otro script que simule un sistema de monitoreo de temperatura:

## Crear un script de monitoreo de temperatura
cat > temp_monitor.sh << 'EOF'
#!/bin/bash

## Función para generar una temperatura aleatoria entre 15 y 35
generate_temp() {
  echo $((RANDOM % 21 + 15))
}

## Generar temperatura aleatoria
TEMP=$(generate_temp)
echo "Temperatura actual: ${TEMP}°C"

## Umbrales de temperatura
MIN_TEMP=18
MAX_TEMP=26

if [ $TEMP -lt $MIN_TEMP ]; then
  echo "Acción: Aumentar la calefacción. La temperatura está por debajo del umbral mínimo."
elif [ $TEMP -gt $MAX_TEMP ]; then
  echo "Acción: Activar la refrigeración. La temperatura está por encima del umbral máximo."
else
  echo "Estado: La temperatura está dentro del rango aceptable."
fi

## Comprobación adicional para temperaturas extremas
if [ $TEMP -ge 30 ]; then
  echo "ADVERTENCIA: La temperatura es muy alta. Verifique los sistemas de refrigeración."
fi
if [ $TEMP -le 17 ]; then
  echo "ADVERTENCIA: La temperatura es muy baja. Verifique los sistemas de calefacción."
fi
EOF

## Hacer el script ejecutable
chmod +x temp_monitor.sh

## Ejecutar el script
./temp_monitor.sh

Cada vez que ejecute este script, generará una temperatura aleatoria y responderá en consecuencia. Intente ejecutarlo varias veces para ver diferentes resultados:

## Ejecutar el script de monitoreo de temperatura varias veces
./temp_monitor.sh
./temp_monitor.sh
./temp_monitor.sh

Estos ejemplos demuestran cómo utilizar condiciones numéricas para monitorear parámetros del sistema y tomar acciones adecuadas basadas en valores umbral.

Combinación de condiciones con operadores lógicos

En este paso, aprenderá cómo combinar múltiples condiciones utilizando operadores lógicos. Esto es esencial para crear una lógica de toma de decisiones compleja en sus scripts.

Los tres principales operadores lógicos son:

• && (AND): Verdadero si ambas condiciones son verdaderas
• || (OR): Verdadero si al menos una condición es verdadera
• ! (NOT): Verdadero si la condición es falsa

Comencemos con algunos ejemplos básicos:

## Crear un archivo de prueba
touch test_file.txt
chmod 644 test_file.txt

## Operador AND - ambas condiciones deben ser verdaderas
[ -f test_file.txt ] && [ -r test_file.txt ] && echo "El archivo existe y es legible."

## Operador OR - al menos una condición debe ser verdadera
[ -x test_file.txt ] || [ -w test_file.txt ] && echo "El archivo es ejecutable o escribible."

## Operador NOT - invierte la condición
[ ! -x test_file.txt ] && echo "El archivo no es ejecutable."

## Combinación de múltiples operadores
[ -f test_file.txt ] && [ -r test_file.txt ] && [ ! -x test_file.txt ] && echo "El archivo existe, es legible, pero no es ejecutable."

Debería ver una salida similar a la siguiente:

El archivo existe y es legible.
El archivo es ejecutable o escribible.
El archivo no es ejecutable.
El archivo existe, es legible, pero no es ejecutable.

El comando test también permite combinar condiciones dentro de un solo conjunto de corchetes utilizando estos operadores:

• -a (AND)
• -o (OR)

Por ejemplo:

## AND dentro de un solo comando test
[ -f test_file.txt -a -r test_file.txt ] && echo "El archivo existe y es legible."

## OR dentro de un solo comando test
[ -x test_file.txt -o -w test_file.txt ] && echo "El archivo es ejecutable o escribible."

Creemos un script más complejo que verifique los recursos del sistema:

## Crear un script de comprobación de recursos del sistema
cat > resource_check.sh << 'EOF'
#!/bin/bash

echo "Comprobando recursos del sistema..."

## Comprobar el uso de memoria
MEM_THRESHOLD=80
MEM_USED=$(free | grep Mem | awk '{print int($3/$2 * 100)}')

echo "Uso de memoria: ${MEM_USED}%"

## Comprobar el espacio en disco
DISK_THRESHOLD=70
DISK_USED=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')

echo "Uso de disco: ${DISK_USED}%"

## Comprobar la carga de la CPU (promedio de 1 minuto)
LOAD_THRESHOLD=1.0
CPU_LOAD=$(cat /proc/loadavg | awk '{print $1}')

echo "Promedio de carga de la CPU: ${CPU_LOAD}"

## Comprobación de condiciones combinadas
if [ $MEM_USED -gt $MEM_THRESHOLD ] && [ $DISK_USED -gt $DISK_THRESHOLD ]; then
  echo "CRÍTICO: ¡Tanto el uso de memoria como el de disco son altos!"
  echo "Acción: Libere recursos inmediatamente."
elif [ $MEM_USED -gt $MEM_THRESHOLD ] || [ $DISK_USED -gt $DISK_THRESHOLD ]; then
  echo "ADVERTENCIA: Ya sea el uso de memoria o el de disco es alto."
  echo "Acción: Monitoree el sistema de cerca."
else
  echo "OK: El uso de memoria y disco está dentro de los límites aceptables."
fi

## Comprobar si la carga es numérica antes de comparar
if [[ $CPU_LOAD =~ ^[0-9]+(\.[0-9]+)?$ ]]; then
  ## Necesitamos usar bc para la comparación de punto flotante
  if (( $(echo "$CPU_LOAD > $LOAD_THRESHOLD" | bc -l) )); then
    echo "ADVERTENCIA: La carga de la CPU es alta. Verifique los procesos que consumen muchos recursos."
  else
    echo "OK: La carga de la CPU es normal."
  fi
else
  echo "Error: No se pudo analizar el valor de la carga de la CPU."
fi
EOF

## Hacer el script ejecutable
chmod +x resource_check.sh

## Ejecutar el script
./resource_check.sh

Este script verifica el uso de memoria, el espacio en disco y la carga de la CPU, y luego proporciona diferentes salidas basadas en combinaciones de estas condiciones.

Finalmente, creemos un script que valide la entrada del usuario con múltiples condiciones:

## Crear un script de validación de entrada
cat > validate_input.sh << 'EOF'
#!/bin/bash

echo "Ingrese un nombre de usuario (solo letras minúsculas, 3-8 caracteres):"
read username

echo "Ingrese su edad (debe ser 18 años o mayor):"
read age

## Validación del nombre de usuario
is_valid_username=true

## Comprobar si el nombre de usuario está vacío
if [ -z "$username" ]; then
  echo "Error: El nombre de usuario no puede estar vacío."
  is_valid_username=false
fi

## Comprobar la longitud del nombre de usuario
if [ ${#username} -lt 3 ] || [ ${#username} -gt 8 ]; then
  echo "Error: El nombre de usuario debe tener entre 3 y 8 caracteres."
  is_valid_username=false
fi

## Comprobar si el nombre de usuario contiene solo letras minúsculas
if [[ ! "$username" =~ ^[a-z]+$ ]]; then
  echo "Error: El nombre de usuario debe contener solo letras minúsculas."
  is_valid_username=false
fi

## Validación de la edad
is_valid_age=true

## Comprobar si la edad es un número
if [[ ! "$age" =~ ^[0-9]+$ ]]; then
  echo "Error: La edad debe ser un número."
  is_valid_age=false
fi

## Comprobar si la edad es al menos 18
if [ "$is_valid_age" = true ] && [ $age -lt 18 ]; then
  echo "Error: Debe tener al menos 18 años."
  is_valid_age=false
fi

## Validación final
if [ "$is_valid_username" = true ] && [ "$is_valid_age" = true ]; then
  echo "Registro exitoso!"
  echo "Bienvenido, $username. Su cuenta ha sido creada."
else
  echo "Registro fallido. Por favor, corrija los errores e inténtelo de nuevo."
fi
EOF

## Hacer el script ejecutable
chmod +x validate_input.sh

## Ejecutar el script
echo "Puedes probar el script ejecutando: ./validate_input.sh"

Intente ejecutar el script con diferentes entradas para ver cómo las condiciones combinadas trabajan juntas para validar la entrada del usuario:

## Probar con entrada válida
echo -e "john\n25" | ./validate_input.sh

## Probar con nombre de usuario inválido (demasiado corto)
echo -e "jo\n25" | ./validate_input.sh

## Probar con nombre de usuario inválido (contiene mayúsculas)
echo -e "John\n25" | ./validate_input.sh

## Probar con edad inválida (menos de 18)
echo -e "john\n17" | ./validate_input.sh

## Probar con edad inválida (no es un número)
echo -e "john\nabc" | ./validate_input.sh

Estos ejemplos demuestran cómo combinar múltiples condiciones para crear una lógica de validación compleja en sus scripts.

Creación de un script de monitoreo del sistema integral

En este último paso, combinará todo lo que ha aprendido para crear un script de monitoreo del sistema integral. Este script verificará varios parámetros del sistema y proporcionará un informe resumido.

Creemos un script que monitoree varios aspectos del sistema:

## Crear un script de monitoreo del sistema
cat > system_monitor.sh << 'EOF'
#!/bin/bash

echo "========================================"
echo "    Informe de monitoreo del sistema"
echo "    $(date)"
echo "========================================"
echo

## 1. Comprobar si existen archivos importantes del sistema
echo "1. Comprobación de archivos del sistema:"
important_files=("/etc/passwd" "/etc/hosts" "/etc/resolv.conf")
all_files_exist=true

for file in "${important_files[@]}"; do
  if [ -e "$file" ]; then
    echo "   [OK] $file existe"
    
    ## Comprobar si el archivo está vacío
    if [ ! -s "$file" ]; then
      echo "   [ADVERTENCIA] $file está vacío"
    fi
    
    ## Comprobar si el archivo es legible
    if [ ! -r "$file" ]; then
      echo "   [ADVERTENCIA] $file no es legible"
    fi
  else
    echo "   [ERROR] $file no existe"
    all_files_exist=false
  fi
done

if [ "$all_files_exist" = true ]; then
  echo "   Todos los archivos del sistema están presentes."
else
  echo "   Faltan algunos archivos del sistema. Revise los errores anteriores."
fi
echo

## 2. Comprobar el espacio en disco
echo "2. Comprobación del espacio en disco:"
disk_usage=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')
echo "   Uso de la partición raíz: ${disk_usage}%"

if [ $disk_usage -ge 90 ]; then
  echo "   [CRÍTICO] ¡El uso del disco es críticamente alto!"
elif [ $disk_usage -ge 70 ]; then
  echo "   [ADVERTENCIA] El uso del disco está aumentando."
else
  echo "   [OK] El uso del disco es normal."
fi
echo

## 3. Comprobar el uso de memoria
echo "3. Comprobación del uso de memoria:"
mem_total=$(free -m | grep Mem | awk '{print $2}')
mem_used=$(free -m | grep Mem | awk '{print $3}')
mem_percentage=$((mem_used * 100 / mem_total))

echo "   Uso de memoria: ${mem_percentage}% (${mem_used}MB utilizados de ${mem_total}MB)"

if [ $mem_percentage -ge 90 ]; then
  echo "   [CRÍTICO] ¡El uso de memoria es críticamente alto!"
elif [ $mem_percentage -ge 70 ]; then
  echo "   [ADVERTENCIA] El uso de memoria está aumentando."
else
  echo "   [OK] El uso de memoria es normal."
fi
echo

## 4. Comprobar procesos activos
echo "4. Comprobación de procesos:"
critical_processes=("sshd" "cron")
for process in "${critical_processes[@]}"; do
  if pgrep -x "$process" > /dev/null; then
    echo "   [OK] $process está en ejecución"
  else
    echo "   [ERROR] $process no está en ejecución"
  fi
done
echo

## 5. Comprobar la carga del sistema
echo "5. Comprobación de la carga del sistema:"
load_1min=$(cat /proc/loadavg | awk '{print $1}')
load_5min=$(cat /proc/loadavg | awk '{print $2}')
load_15min=$(cat /proc/loadavg | awk '{print $3}')

echo "   Promedio de carga: $load_1min (1 min), $load_5min (5 min), $load_15min (15 min)"

## Determinar el número de núcleos de CPU
num_cores=$(grep -c ^processor /proc/cpuinfo)
load_threshold=$(echo "scale=2; $num_cores * 0.7" | bc)

if (( $(echo "$load_1min > $load_threshold" | bc -l) )); then
  echo "   [ADVERTENCIA] Se detectó una carga alta. El sistema podría estar bajo estrés."
else
  echo "   [OK] La carga del sistema es normal."
fi
echo

## 6. Comprobar intentos de inicio de sesión fallidos recientes
echo "6. Comprobación de seguridad:"
if [ -f /var/log/auth.log ]; then
  failed_logins=$(grep "Failed password" /var/log/auth.log | wc -l)
  echo "   Intentos de inicio de sesión fallidos: $failed_logins"
  
  if [ $failed_logins -gt 10 ]; then
    echo "   [ADVERTENCIA] Se detectó un gran número de intentos de inicio de sesión fallidos."
  else
    echo "   [OK] Actividad de inicio de sesión normal."
  fi
else
  echo "   [INFO] No se pueden comprobar los intentos de inicio de sesión (auth.log no es accesible)"
fi
echo

## 7. Resumen
echo "7. Resumen del estado del sistema:"
critical_count=$(grep -c "\[CRÍTICO\]" <<< "$(cat /dev/stdin)")
warning_count=$(grep -c "\[ADVERTENCIA\]" <<< "$(cat /dev/stdin)")
error_count=$(grep -c "\[ERROR\]" <<< "$(cat /dev/stdin)")

if [ $critical_count -gt 0 ]; then
  echo "   [CRÍTICO] El sistema tiene problemas críticos que requieren atención inmediata!"
elif [ $warning_count -gt 0 ] || [ $error_count -gt 0 ]; then
  echo "   [ADVERTENCIA] El sistema tiene algunos problemas que deben resolverse pronto."
else
  echo "   [OK] El sistema está funcionando normalmente. No se detectaron problemas significativos."
fi

echo
echo "========================================"
echo "    Fin del informe de monitoreo del sistema"
echo "========================================"
EOF

## Hacer el script ejecutable
chmod +x system_monitor.sh

## Ejecutar el script
./system_monitor.sh

Este script integral realiza las siguientes comprobaciones:

1. Verifica si existen y son legibles los archivos importantes del sistema.
2. Comprueba el uso del espacio en disco.
3. Monitorea el uso de memoria.
4. Confirma que los procesos críticos están en ejecución.
5. Evalúa la carga del sistema.
6. Examina los registros de seguridad en busca de intentos de inicio de sesión fallidos.
7. Proporciona un resumen general del estado del sistema.

La salida variará según el estado actual de su sistema, pero le proporcionará una visión general integral de la salud de su sistema.

Para hacer que este script sea aún más útil, podría:

1. Programarlo para que se ejecute periódicamente utilizando cron.
2. Configurarlo para enviar alertas por correo electrónico cuando se detecten problemas críticos.
3. Agregar más comprobaciones específicas relacionadas con su sistema.

Creemos una versión más simple que puede programar para que se ejecute periódicamente:

## Crear un script de monitoreo simplificado para programar
cat > daily_check.sh << 'EOF'
#!/bin/bash

## Configurar archivo de registro
LOG_FILE="/tmp/system_check_$(date +%Y%m%d).log"

## Iniciar registro
echo "Comprobación del sistema: $(date)" > $LOG_FILE
echo "--------------------------------" >> $LOG_FILE

## Comprobar el espacio en disco
disk_usage=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')
echo "Uso del disco: ${disk_usage}%" >> $LOG_FILE

if [ $disk_usage -ge 90 ]; then
  echo "CRÍTICO: ¡El uso del disco es críticamente alto!" >> $LOG_FILE
elif [ $disk_usage -ge 70 ]; then
  echo "ADVERTENCIA: El uso del disco está aumentando." >> $LOG_FILE
else
  echo "OK: El uso del disco es normal." >> $LOG_FILE
fi

## Comprobar la memoria
mem_total=$(free -m | grep Mem | awk '{print $2}')
mem_used=$(free -m | grep Mem | awk '{print $3}')
mem_percentage=$((mem_used * 100 / mem_total))
echo "Uso de memoria: ${mem_percentage}%" >> $LOG_FILE

if [ $mem_percentage -ge 90 ]; then
  echo "CRÍTICO: ¡El uso de memoria es críticamente alto!" >> $LOG_FILE
elif [ $mem_percentage -ge 70 ]; then
  echo "ADVERTENCIA: El uso de memoria está aumentando." >> $LOG_FILE
else
  echo "OK: El uso de memoria es normal." >> $LOG_FILE
fi

## Comprobar servicios críticos
for service in sshd cron; do
  if pgrep -x "$service" > /dev/null; then
    echo "$service está en ejecución" >> $LOG_FILE
  else
    echo "ADVERTENCIA: $service no está en ejecución" >> $LOG_FILE
  fi
done

## Fin del registro
echo "--------------------------------" >> $LOG_FILE
echo "Comprobación completada a las $(date)" >> $LOG_FILE

## Mostrar ubicación del registro
echo "Comprobación del sistema completada. Registro guardado en $LOG_FILE"
EOF

## Hacer el script ejecutable
chmod +x daily_check.sh

## Ejecutar el script
./daily_check.sh

Para programar este script para que se ejecute diariamente, normalmente utilizaría el sistema cron. Así es como lo configuraría:

## Mostrar cómo configurar un trabajo cron (no lo cree realmente en este entorno de laboratorio)
echo "Para programar este script para que se ejecute diariamente a las 9 AM, utilizaría:"
echo "crontab -e"
echo "Y agregaría la línea:"
echo "0 9 * * * /home/labex/project/daily_check.sh"

Esto demuestra cómo se pueden aplicar los comandos de prueba de condiciones de Linux que ha aprendido para crear herramientas prácticas de monitoreo del sistema.

Resumen

En este laboratorio, has aprendido cómo utilizar las pruebas de condiciones de Linux para evaluar diferentes tipos de condiciones y tomar decisiones basadas en los resultados. Aquí está un resumen de lo que has logrado:

1. Aprendiste los conceptos básicos del comando test y cómo comprobar propiedades de archivos, como la existencia, la legibilidad y el tamaño.

2. Exploraste la comparación de cadenas utilizando operadores como ==, !=, -z y -n para validar la entrada y tomar decisiones basadas en el contenido de texto.

3. Trabajaste con comparaciones numéricas utilizando operadores como -eq, -ne, -lt, -gt, -le y -ge para evaluar valores numéricos.

4. Combinaste múltiples condiciones utilizando operadores lógicos (&&, ||, !) para crear una lógica de toma de decisiones compleja.

5. Aplicaste todas estas técnicas para crear scripts de monitoreo del sistema completos que pueden verificar varios parámetros del sistema y proporcionar informes de estado.

Estas habilidades son fundamentales para la programación en shell y la administración de sistemas en Linux. La capacidad de probar condiciones y tomar diferentes acciones basadas en los resultados te permite crear scripts que pueden automatizar tareas, validar la entrada, manejar errores y monitorear la salud del sistema.

Algunas aplicaciones prácticas de lo que has aprendido incluyen:

• Crear scripts de copia de seguridad automatizados que comprueben el espacio disponible antes de continuar.
• Desarrollar validación de entrada para scripts orientados a usuarios.
• Construir herramientas de monitoreo del sistema que alerten a los administradores sobre posibles problemas.
• Automatizar tareas de mantenimiento del sistema rutinarias con lógica condicional.

A medida que continúes trabajando con Linux, descubrirás que las pruebas de condiciones son una parte esencial de casi todos los scripts de shell que crees o mantengas.