Registra avisos de recursos

Introducción

FRAME Studio necesita un registro breve de una sesión de trabajo, no una pantalla de terminal que desaparece. El muestreador de recursos ya está completo en esta instancia independiente. Transformarás las observaciones en avisos explícitos y las añadirás sin perder el registro previo del operador.

Implementarás tres funciones: clasificar una lectura, registrar una fila completa y repetir la acción de muestreo preparada. Se requieren variables, funciones, condiciones y bucles básicos de Bash; el primer laboratorio explica los indicadores. No necesitas sus archivos. Los límites son política didáctica local, no recomendaciones universales de producción. La duración es una estimación del autor.

Asigna un estado explícito a cada lectura

En este paso convertirás un porcentaje y su límite en una decisión de aviso reutilizable.

Comienza en Terminal. Esta instancia independiente ya contiene un metrics.sh funcional; no necesitas archivos anteriores. Entra en el espacio de trabajo:

cd /home/labex/project/resource-watch

Observa una lectura actual:

bash snapshot.sh

Los cuatro campos separados por tabuladores son marca UTC, CPU no inactiva, presión de memoria y uso del sistema de archivos objetivo. Describen esta instancia, no una flota de producción. Un aviso de recursos no demuestra que haya fallado la exportación de fotos.

cat muestra la política sin modificarla:

cat policy.sh

Lee los tres límites y las rutas completas de destino y registro. En esta unidad los límites de CPU y memoria son 80 y el de disco 50. Son decisiones didácticas. La regla explícita es WARN si una lectura es mayor o igual que su propio límite; en otro caso OK. La igualdad importa. Conserva la política y el muestreador suministrados.

Abre las funciones incompletas con nano:

Este laboratorio comienza de nuevo con un archivo de métricas preparado y funcional. Edita el archivo de funciones de monitorización indicado en el próximo comando, en vez de copiar aquí las métricas anteriores. En la política, los tres valores LIMIT son porcentajes enteros; TARGET es el directorio observado y LOG la ruta del historial. Leer la política no la modifica.

nano monitor-functions.sh

Sustituye solo classify por:

classify() {
    if (( $1 >= $2 )); then
        echo WARN
    else
        echo OK
    fi
}

El primer argumento es la lectura y el segundo el límite. ((...)) compara números; >= incluye igualdad. Ambas ramas imprimen un estado: una lectura normal dice OK y no queda silenciosa. Guarda con Ctrl+O, Enter, Ctrl+X.

source carga las definiciones. Ejecuta las pruebas dentro de bash -c porque el shell interactivo es Zsh. Las comillas simples conservan los comandos para Bash:

bash -c 'source ./monitor-functions.sh; classify 79 80; classify 80 80; classify 81 80'

OK
WARN
WARN

Estas lecturas suministradas prueban la regla; no son mediciones actuales de CPU. Una función que siempre devuelve WARN u OK es incorrecta aunque hoy la estación coincida con ese estado.

Añade un registro de monitorización completo

En este paso registrarás todas las lecturas y sus estados independientes sin reemplazar el historial.

Permanece en Terminal, en /home/labex/project/resource-watch. Lee primero el historial del operador:

cat history.tsv

Su fila original debe permanecer idéntica byte a byte al principio. history.tsv es la entrega real, no un informe que rellenes a mano. Cada fila nueva tiene siete campos con tabuladores: marca UTC, CPU, memoria, disco y después los estados de CPU, memoria y disco en ese orden.

Abre las funciones:

nano monitor-functions.sh

Sustituye solo record_sample por:

record_sample() {
    local stamp=$1 cpu=$2 memory=$3 disk=$4 logfile=$5
    printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\n' \
        "$stamp" "$cpu" "$memory" "$disk" \
        "$(classify "$cpu" "$CPU_LIMIT")" \
        "$(classify "$memory" "$MEMORY_LIMIT")" \
        "$(classify "$disk" "$DISK_LIMIT")" >> "$logfile"
}

printf sustituye cada %s, \t escribe un tabulador y \n termina la fila. Una barra invertida al final de una línea continúa el mismo comando. $(...) captura la salida de una función. Las comillas dobles conservan cada valor y una ruta de registro con espacios. >> añade; usar > destruiría registros previos. Guarda con Ctrl+O, Enter, Ctrl+X.

Prueba un registro suministrado en un archivo de práctica aparte. source ./policy.sh carga los límites en este proceso Bash. No persisten automáticamente en otro terminal ni en una llamada posterior a bash -c.

bash -c 'source ./policy.sh; source ./monitor-functions.sh; record_sample 2026-01-02T03:04:05Z 10 85 20 practice.tsv'

cat practice.tsv

2026-01-02T03:04:05Z 10 85 20 OK WARN OK

El aviso de memoria compara 85 con 80; no convierte los otros estados en WARN. Repetir la llamada añade otra fila de práctica. No añadas ejemplos a history.tsv: ese archivo se reserva para muestreo real.

Usa el ejemplo de práctica para leer los siete campos de izquierda a derecha:

Los tabuladores pueden parecer espacios desiguales en Terminal. Conserva los tabuladores reales producidos por la función; no alinees a mano el historial real con espacios. La fila original del operador es contexto preparado, por lo que su fecha anterior es normal. Solo el archivo de práctica separado recibe este ejemplo suministrado.

Ejecuta una observación limitada y conserva el historial

En este paso repetirás el muestreo real, inspeccionarás el resultado y volverás a ejecutar sin perder el progreso.

Permanece en Terminal, en /home/labex/project/resource-watch. El monitor.sh preparado proporciona capture_once target logfile: obtiene una observación nueva, llama a tu registrador y muestra la fila guardada. El bucle debe transmitir las rutas sin cambios y llamar a la acción exactamente el número solicitado. Cada captura incluye una nueva ventana de CPU de un segundo; es una observación limitada, no un planificador preciso.

nano monitor-functions.sh

Sustituye solo run_monitor por:

run_monitor() {
    local count=$1 target=$2 logfile=$3
    local n
    for ((n = 0; n < count; n++)); do
        capture_once "$target" "$logfile"
    done
}

El bucle aritmético comienza en cero, continúa mientras n sea menor que count e incrementa n después de cada captura. Las comillas preservan ambas rutas. También es válido un bucle while equivalente. Guarda con Ctrl+O, Enter, Ctrl+X.

Ejecuta tres muestras reales:

bash monitor.sh 3

Deben aparecer tres filas antes de recuperar el prompt. Cada marca UTC debe ser posterior a la anterior. Los valores reales varían y una ejecución normal puede no avisar. El programa acepta de 1 a 30 muestras. Para una observación larga, Ctrl+C detiene el script en primer plano y conserva las filas añadidas. No necesitas terminar otros procesos.

Lee el resultado y cuenta líneas. wc -l cuenta filas terminadas por salto de línea:

cat history.tsv

wc -l history.tsv

Tras la primera ejecución indicada debe haber cuatro líneas: la original y tres nuevas. Si tomaste más muestras, habrá más. Conserva esas observaciones válidas.

Continúa con una muestra:

bash monitor.sh 1

wc -l history.tsv

El total aumenta en uno. Repetir es seguro porque el registrador añade en vez de reemplazar. Compara cada estado con su lectura y su límite en policy.sh.

Prueba intencionalmente un error habitual de entrada: cero se rechaza antes de muestrear.

bash monitor.sh 0

Use a sample count from 1 to 30.

Este fallo esperado sale con estado 2 y no cambia el historial. Recupera usando una cantidad válida, sin reiniciar la VM ni editar el registro:

bash monitor.sh 1

Se añade una fila nueva. El muestreador preparado también rechaza métricas incompletas en vez de añadir una observación vacía con apariencia plausible.

Comprueba el resultado

• La fila original del operador sigue al principio, seguida de tus nuevas observaciones.
• La primera ejecución añade tres filas; continuar con una muestra añade otra. Se permiten más filas válidas si repetiste un comando.
• Lee primero los tres porcentajes y compara cada uno con su propio límite. Tres estados OK también son válidos; no hace falta generar carga ni borrar archivos para provocar un aviso.
• Cada captura espera un nuevo intervalo de CPU. Una pausa breve es normal; no pulses Enter repetidamente durante la toma. El retorno del prompt indica que terminó la ejecución limitada. Cerrar Terminal no mantiene un monitor continuo en funcionamiento.

Resumen

Has implementado una regla de aviso inclusiva, añadido registros completos con tres estados independientes y repetido muestreo real conservando el historial. Ahora puedes ejecutar una observación breve, leer sus pruebas y continuarla. El desafío independiente cambia el destino y la política, reutilizando las herramientas y los contratos enseñados.