Linux Command Line & Bash Scripting Mastery · Lección

Creación de scripts de comprobación y alerta del estado del sistema

Recopile métricas de carga, memoria y disco, y active alertas basadas en umbrales desde scripts programados.

Creación de scripts de comprobación y alerta del estado del sistema es una lección gratuita de Linux Command Line & Bash Scripting Mastery en CoddyKit. Esta es la lección 4 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 Linux Command Line & Bash Scripting Mastery, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Linux Command Line & Bash Scripting Mastery incluye 4 lecciones en total.

Por qué son importantes las comprobaciones del estado del sistema

Los servidores de producción pueden degradarse silenciosamente. Los picos de CPU, las fugas de memoria y los discos llenos provocan interrupciones, pero solo si nadie las detecta a tiempo. Los scripts de comprobación del estado del sistema automatizan el ciclo de monitorización: recopilan métricas, las comparan con umbrales y activan alertas antes de que los usuarios sufran las consecuencias.

Se programan mediante cron y se ejecutan cada pocos minutos sin intervención humana
Generan una salida coherente con marcas de tiempo, adecuada para la agregación de registros
La lógica basada en umbrales mantiene las alertas bajo control: no todos los incidentes menores requieren avisar al equipo de guardia

En esta lección creará desde cero un script de comprobación del estado, listo para producción, capa por capa, que abarcará la carga media, la presión de memoria y el uso del disco.

Capturar la carga media

Linux proporciona las cargas medias de 1, 5 y 15 minutos mediante /proc/loadavg y el comando uptime. Para crear scripts, /proc/loadavg es la fuente más limpia: no presenta problemas de configuración regional ni variaciones de análisis entre distribuciones.

El fragmento siguiente lee la carga media de 1 minuto y la almacena en una variable para compararla con un umbral. cut extrae el primer campo; awk elimina los decimales para realizar comparaciones enteras mediante bc para la aritmética de valores en coma flotante.

#!/usr/bin/env bash
# Read 1-minute load average from /proc/loadavg
LOAD_RAW=$(cut -d' ' -f1 /proc/loadavg)
echo "Raw load average: $LOAD_RAW"

# Number of CPU cores — used to normalise load
CPU_CORES=$(nproc)
echo "CPU cores: $CPU_CORES"

# Compute load percentage (load / cores * 100) using bc
LOAD_PCT=$(echo "scale=2; $LOAD_RAW / $CPU_CORES * 100" | bc)
echo "Load %: $LOAD_PCT"

Comparar umbrales con valores en coma flotante

Bash no puede comparar de forma nativa números en coma flotante; [ 1.5 -gt 1.2 ] produce un error. Las dos soluciones idiomáticas son:

bc: devuelve 1 (verdadero) o 0 (falso) a partir de una expresión de comparación
awk: puede evaluar condiciones con valores en coma flotante dentro de una canalización

Usar bc mantiene la lógica legible y fácil de probar. El patrón $(echo "$A > $B" | bc) devuelve 1 cuando se cumple la condición, y puede comprobarlo con [ ... -eq 1 ].

#!/usr/bin/env bash
LOAD_RAW=$(cut -d' ' -f1 /proc/loadavg)
CPU_CORES=$(nproc)
THRESHOLD=80  # alert when load % exceeds 80%

LOAD_PCT=$(echo "scale=2; $LOAD_RAW / $CPU_CORES * 100" | bc)

# bc returns 1 if the expression is true
if [ "$(echo "$LOAD_PCT > $THRESHOLD" | bc)" -eq 1 ]; then
    echo "ALERT: Load is ${LOAD_PCT}% (threshold ${THRESHOLD}%)"
else
    echo "OK: Load is ${LOAD_PCT}%"
fi

Recopilar métricas de memoria

/proc/meminfo es la fuente autorizada de las estadísticas de memoria en Linux. Campos clave:

MemTotal: RAM física total en kB
MemAvailable: kB estimados disponibles para nuevas asignaciones sin usar swap (mejor indicador que MemFree)

Usar awk con una coincidencia de patrón es la forma más limpia de extraer estos valores. Dividir MemAvailable entre MemTotal y restar el resultado de 100 proporciona el porcentaje de memoria utilizada, que determina el umbral de alerta.

#!/usr/bin/env bash
# Extract memory figures from /proc/meminfo (values in kB)
MEM_TOTAL=$(awk '/^MemTotal:/ {print $2}' /proc/meminfo)
MEM_AVAIL=$(awk '/^MemAvailable:/ {print $2}' /proc/meminfo)

# Used memory percentage
MEM_USED_PCT=$(echo "scale=2; (1 - $MEM_AVAIL / $MEM_TOTAL) * 100" | bc)

echo "Total RAM : ${MEM_TOTAL} kB"
echo "Available : ${MEM_AVAIL} kB"
echo "Used      : ${MEM_USED_PCT}%"

Recopilar métricas de uso del disco

El comando df informa sobre el uso de los sistemas de archivos. Para crear scripts, hay dos opciones esenciales:

-h: tamaños legibles para las personas (solo para mostrar; evítela en operaciones aritméticas)
--output=pcent,target: columnas analizables por máquinas (GNU coreutils)

Iterar sobre todos los sistemas de archivos montados permite que el script señale cualquier partición que esté llena de forma crítica, no solo /. El signo % se elimina con tr -d '%' antes de realizar la comparación entera.

#!/usr/bin/env bash
DISK_THRESHOLD=85

# Skip header line with tail -n +2
# --output=pcent,target gives "85% /var" style lines
df --output=pcent,target | tail -n +2 | while read -r USED_PCT MOUNT; do
    # Remove the % sign for arithmetic
    USED_INT=${USED_PCT//%/}

    if [ "$USED_INT" -ge "$DISK_THRESHOLD" ]; then
        echo "ALERT: Disk $MOUNT is ${USED_PCT} full"
    else
        echo "OK   : Disk $MOUNT is ${USED_PCT} full"
    fi
done

Salida estructurada de alertas con marcas de tiempo

Los mensajes de alerta sin marcas de tiempo resultan prácticamente inútiles en archivos de registro o informes por correo electrónico. Un prefijo coherente facilita el análisis de registros con grep o agentes de envío de registros.

Defina una pequeña función de alerta al principio del script. Esta antepone una marca de tiempo ISO-8601, un nivel de gravedad y el nombre de la comprobación. Todas las alertas se escriben tanto en stdout como en un archivo de registro mediante tee.

date -u +"%Y-%m-%dT%H:%M:%SZ": marca de tiempo UTC independiente de la configuración regional
Escribir en stderr para ALERT y en stdout para OK separa la información relevante del ruido en las canalizaciones

#!/usr/bin/env bash
LOG_FILE="/var/log/healthcheck.log"

alert() {
    local LEVEL="$1"   # OK | WARN | ALERT
    local CHECK="$2"
    local MSG="$3"
    local TS
    TS=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
    local LINE="[$TS] [$LEVEL] [$CHECK] $MSG"

    if [ "$LEVEL" = "ALERT" ]; then
        echo "$LINE" | tee -a "$LOG_FILE" >&2
    else
        echo "$LINE" | tee -a "$LOG_FILE"
    fi
}

# Usage examples
alert "OK"    "DISK"  "/ is 42% full"
alert "ALERT" "DISK"  "/var is 91% full"

Enviar alertas por correo con mail y sendmail

El mecanismo de alertas más sencillo en el servidor es el correo electrónico mediante el MTA local (postfix, sendmail o msmtp). El comando mail (de mailutils o bsd-mailx) compone y envía un mensaje en una sola línea.

-s: línea de asunto
Canalice el cuerpo mediante stdin
En servidores sin un MTA local, sustituya mail por una llamada a curl a una API de correo electrónico transaccional

Proteja el envío con un bloqueo de deduplicación para evitar que una misma condición ruidosa inunde la bandeja de entrada.

#!/usr/bin/env bash
ALERT_EMAIL="ops@example.com"
LOCK_DIR="/tmp/healthcheck_locks"
mkdir -p "$LOCK_DIR"

send_alert() {
    local CHECK="$1"
    local MSG="$2"
    local LOCK="$LOCK_DIR/${CHECK}.lock"

    # Only send if no lock exists (prevents repeated emails within the hour)
    if [ ! -f "$LOCK" ]; then
        echo "$MSG" | mail -s "[ALERT] $CHECK on $(hostname)" "$ALERT_EMAIL"
        touch "$LOCK"
        # Lock expires after 1 hour via cron or find+delete
        echo "Alert sent for $CHECK"
    else
        echo "Alert suppressed for $CHECK (lock active)"
    fi
}

send_alert "HIGH_LOAD" "Load average exceeded 80% on $(hostname) at $(date)"

Composición del script completo de comprobación de estado

Ahora combine las tres comprobaciones —carga, memoria y disco— en un único script coherente con umbrales configurables al principio. Este es el patrón utilizado en la automatización de administración de sistemas en producción:

Constantes declaradas al principio para ajustarlas fácilmente sin editar la lógica
Cada comprobación aislada en una función para facilitar la lectura y las pruebas unitarias
Una función main coordina las llamadas
Código de salida 1 si se activó alguna alerta y 0 en caso contrario; esto permite integrar el script con frameworks de monitorización como Nagios/Icinga

#!/usr/bin/env bash
set -euo pipefail

# ── Thresholds ───────────────────────────────────────────
LOAD_THRESHOLD=80   # percent of CPU capacity
MEM_THRESHOLD=90    # percent used
DISK_THRESHOLD=85   # percent used
ALERT_EMAIL="ops@example.com"
LOG_FILE="/var/log/healthcheck.log"
ALERT_FIRED=0

# ── Helpers ──────────────────────────────────────────────
ts()    { date -u +"%Y-%m-%dT%H:%M:%SZ"; }
log()   { echo "[$(ts)] $*" | tee -a "$LOG_FILE"; }
alert() { log "ALERT: $*"; echo "$*" | mail -s "[ALERT] $(hostname)" "$ALERT_EMAIL" 2>/dev/null; ALERT_FIRED=1; }

# ── Checks ───────────────────────────────────────────────
check_load() {
    local raw cores pct
    raw=$(cut -d' ' -f1 /proc/loadavg)
    cores=$(nproc)
    pct=$(echo "scale=2; $raw / $cores * 100" | bc)
    if [ "$(echo "$pct > $LOAD_THRESHOLD" | bc)" -eq 1 ]; then
        alert "Load ${pct}% exceeds ${LOAD_THRESHOLD}%"
    else
        log "OK load=${pct}%"
    fi
}

check_memory() {
    local total avail pct
    total=$(awk '/^MemTotal:/    {print $2}' /proc/meminfo)
    avail=$(awk '/^MemAvailable:/{print $2}' /proc/meminfo)
    pct=$(echo "scale=2; (1 - $avail / $total) * 100" | bc)
    if [ "$(echo "$pct > $MEM_THRESHOLD" | bc)" -eq 1 ]; then
        alert "Memory ${pct}% used (threshold ${MEM_THRESHOLD}%)"
    else
        log "OK memory=${pct}%"
    fi
}

check_disk() {
    df --output=pcent,target | tail -n +2 | while read -r used mnt; do
        local pct_int=${used//%/}
        if [ "$pct_int" -ge "$DISK_THRESHOLD" ]; then
            alert "Disk $mnt at ${used}"
        else
            log "OK disk $mnt=${used}"
        fi
    done
}

main() {
    log "=== Health check START ==="
    check_load
    check_memory
    check_disk
    log "=== Health check END (alerts=$ALERT_FIRED) ==="
    exit "$ALERT_FIRED"
}

main

Programación con Cron

Un script de comprobación de estado solo resulta útil cuando se ejecuta automáticamente. cron es el programador estándar de Unix. Edite el crontab de todo el sistema o un archivo específico en /etc/cron.d/ para programar el script.

Ejecutar cada 5 minutos: */5 * * * *
Utilice siempre rutas absolutas en cron; $PATH es mínimo en el entorno de cron
Redirija la salida para evitar que cron envíe un correo en cada ejecución: >> /var/log/healthcheck.log 2>&1
Use MAILTO="" al principio del crontab para silenciar los correos del propio cron

# /etc/cron.d/healthcheck
# Run the health check every 5 minutes as root
MAILTO=""
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

*/5 * * * * root /usr/local/sbin/healthcheck.sh >> /var/log/healthcheck.log 2>&1

Cómo evitar avalanchas de alertas con bloqueos de enfriamiento

Cuando un umbral se supera continuamente, un script ingenuo activa una alerta cada 5 minutos: se envían decenas de correos antes de que un ingeniero pueda responder. Un bloqueo de enfriamiento suprime las alertas repetidas durante un intervalo configurable.

El patrón es el siguiente: escriba un archivo de bloqueo cuando se produzca la primera alerta; omita las alertas posteriores mientras el archivo sea más reciente que el periodo de enfriamiento; find con -mmin comprueba la antigüedad del archivo de forma atómica, sin tener que hacer cálculos con fechas.

#!/usr/bin/env bash
LOCK_DIR="/tmp/hc_locks"
COOLDOWN_MIN=60  # suppress repeat alerts for 60 minutes
mkdir -p "$LOCK_DIR"

should_alert() {
    local check="$1"
    local lock="$LOCK_DIR/${check}.lock"

    if [ ! -f "$lock" ]; then
        # No lock — allow alert and create lock
        touch "$lock"
        return 0  # true: send alert
    fi

    # Lock exists — check if it is older than the cooldown
    # find returns the filename only if it's OLDER than COOLDOWN_MIN
    local expired
    expired=$(find "$lock" -mmin +"$COOLDOWN_MIN" 2>/dev/null)

    if [ -n "$expired" ]; then
        touch "$lock"  # refresh lock timestamp
        return 0       # cooldown expired — allow alert
    fi

    return 1  # still within cooldown — suppress
}

# Usage
if should_alert "HIGH_LOAD"; then
    echo "Sending load alert..."
    # mail -s "..." ops@example.com <<< "Load too high"
else
    echo "Load alert suppressed (cooldown active)"
fi

Prueba y validación del script de comprobación de estado

Antes de implementarlo, valide el script de tres formas:

Comprobación de sintaxis: bash -n healthcheck.sh detecta errores de análisis sin ejecutar el script
Modo de trazado: bash -x healthcheck.sh muestra cada comando a medida que se ejecuta; es especialmente útil para depurar
Sustitución temporal de umbrales: reduzca temporalmente los umbrales casi a cero para que el script active alertas en un host en buen estado y confirme que la ruta de alertas funciona de extremo a extremo

Para probar la ruta del correo electrónico, redirija mail a un archivo de registro mediante un indicador MOCK_MAIL:

#!/usr/bin/env bash
# Smoke-test the alert path without sending real email
MOCK_MAIL=true
ALERT_EMAIL="ops@example.com"

send_mail() {
    local subject="$1"
    local body="$2"
    if [ "$MOCK_MAIL" = true ]; then
        echo "[MOCK MAIL] To: $ALERT_EMAIL | Subject: $subject"
        echo "[MOCK MAIL] Body: $body"
    else
        echo "$body" | mail -s "$subject" "$ALERT_EMAIL"
    fi
}

# Override threshold to guarantee an alert fires
LOAD_THRESHOLD=0   # Any load will exceed 0%
LOAD_RAW=$(cut -d' ' -f1 /proc/loadavg)
CPU_CORES=$(nproc)
PCT=$(echo "scale=2; $LOAD_RAW / $CPU_CORES * 100" | bc)

if [ "$(echo "$PCT > $LOAD_THRESHOLD" | bc)" -eq 1 ]; then
    send_mail "[ALERT] Load on $(hostname)" "Load is ${PCT}%"
fi

Comprobación de conocimientos: estrategia de enfriamiento

Considere el siguiente escenario: su tarea de cron de comprobación de estado se ejecuta cada 5 minutos. El uso del disco en /var supera el 85 % y permanece así durante 3 horas. Quiere que el ingeniero de guardia reciba una alerta una vez por hora, no cada 5 minutos. ¿Qué estrategia de implementación es la más adecuada?

Resumen de la lección: scripts de comprobación del estado del sistema

En esta lección ha creado una canalización completa y lista para producción para comprobar el estado del sistema y enviar alertas. Estos son los principios clave que debe conservar:

Fuente de verdad: lea las métricas de /proc/loadavg y /proc/meminfo; son estables, independientes de la configuración regional y están disponibles en todos los hosts Linux
Aritmética de números decimales: use bc para comparar umbrales de coma flotante; la comparación de enteros de Bash (-gt) solo funciona con números enteros
Iteración de discos: use df --output=pcent,target para comprobar todos los sistemas de archivos montados, no solo /
Registro estructurado: anteponga a cada línea una marca de tiempo UTC y un nivel de gravedad para que los registros sean fáciles de procesar con grep y se envíen correctamente a sistemas de registro centralizados
Bloqueos de enfriamiento: los archivos de bloqueo comprobados con find -mmin evitan avalanchas de alertas sin cambiar la programación de cron
Componibilidad: salga con el código 1 cuando se active alguna alerta para que el script se integre con Nagios, Icinga u otros frameworks de monitorización
Pruebas: use bash -n para comprobar la sintaxis, bash -x para depurar mediante trazas y un indicador MOCK_MAIL para validar la ruta de alertas en hosts en buen estado

Programe el script terminado mediante /etc/cron.d/ y su infraestructura se supervisará continuamente por sí sola, enviando alertas únicamente cuando los umbrales se superen de forma significativa.

Preguntas frecuentes

¿La lección «Creación de scripts de comprobación y alerta del estado del sistema» es gratis?

Sí — el texto completo de «Creación de scripts de comprobación y alerta del estado del sistema» 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 Linux Command Line & Bash Scripting Mastery, actualiza a CoddyKit PRO. El curso de Linux Command Line & Bash Scripting Mastery incluye 4 lecciones en total.

¿Qué aprenderé en «Creación de scripts de comprobación y alerta del estado del sistema»?

Recopile métricas de carga, memoria y disco, y active alertas basadas en umbrales desde scripts programados. Practicas Linux Command Line & Bash Scripting Mastery 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 Linux Command Line & Bash Scripting Mastery?

No se requiere experiencia previa. Linux Command Line & Bash Scripting Mastery 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 4 de 4.

¿Cuánto tiempo toma la lección «Creación de scripts de comprobación y alerta del estado del sistema»?

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 Linux Command Line & Bash Scripting Mastery?

Sí. Cada lección de Linux Command Line & Bash Scripting Mastery 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

Automatización del aprovisionamiento de usuarios y grupos
Control de servicios systemd y escritura de archivos unit
Automatización de discos, sistemas de archivos y montajes
Creación de scripts de comprobación y alerta del estado del sistema

← Volver a Linux Command Line & Bash Scripting Mastery