Registre avisos de recursos

Introdução

A FRAME Studio precisa de um registro curto de uma sessão de trabalho, não de uma tela de terminal que desaparece. O amostrador de recursos já está completo nesta instância independente. Você transformará observações em avisos explícitos e os acrescentará sem perder o registro anterior do operador.

Você implementará três funções: classificar uma leitura, registrar uma linha completa e repetir a ação de amostragem preparada. São necessários variáveis, funções, condições e laços básicos de Bash; o primeiro laboratório explica os indicadores. Seus arquivos não são necessários. Os limites são uma política didática local, não recomendações universais de produção. A duração é uma estimativa do autor.

Atribua um estado explícito a cada leitura

Nesta etapa, você converterá uma porcentagem e seu limite em uma decisão de aviso reutilizável.

Comece em Terminal. Esta instância independente já contém um metrics.sh funcional; você não precisa de arquivos anteriores. Entre no espaço de trabalho:

cd /home/labex/project/resource-watch

Observe uma leitura atual:

bash snapshot.sh

Os quatro campos separados por tabulação são marca UTC, CPU não ociosa, pressão de memória e uso do sistema de arquivos alvo. Descrevem esta instância, não uma frota de produção. Um aviso de recursos não prova falha na exportação das fotos.

cat mostra a política sem modificá-la:

cat policy.sh

Leia os três limites e os caminhos completos do alvo e do registro. Nesta unidade, os limites de CPU e memória são 80 e o de disco é 50. São decisões didáticas. A regra explícita é WARN se uma leitura for maior ou igual ao próprio limite; caso contrário, OK. A igualdade importa. Preserve a política e o amostrador fornecidos.

Abra as funções incompletas com nano:

Este laboratório recomeça com um arquivo de métricas preparado e funcional. Edite o arquivo de funções de monitoramento indicado no próximo comando, em vez de copiar aqui as métricas anteriores. Os três valores LIMIT da política são porcentagens inteiras; TARGET é o diretório observado e LOG o caminho do histórico salvo. Ler a política não a altera.

nano monitor-functions.sh

Substitua apenas classify por:

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

O primeiro argumento é a leitura e o segundo é o limite. ((...)) compara números; >= inclui igualdade. Os dois ramos imprimem um estado: uma leitura normal diz OK em vez de ficar silenciosa. Salve com Ctrl+O, Enter, Ctrl+X.

source carrega as definições. Execute os testes dentro de bash -c, pois o shell interativo é Zsh. As aspas simples preservam os comandos para Bash:

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

OK
WARN
WARN

Estas leituras fornecidas testam a regra; não são medições atuais de CPU. Uma função que sempre retorna WARN ou OK está incorreta mesmo que a estação coincida com esse estado hoje.

Acrescente um registro de monitoramento completo

Nesta etapa, você registrará todas as leituras e seus estados independentes sem substituir o histórico.

Permaneça em Terminal, em /home/labex/project/resource-watch. Leia primeiro o histórico do operador:

cat history.tsv

A linha original deve permanecer idêntica byte a byte no início. history.tsv é a entrega real, não um relatório preenchido à mão. Cada nova linha tem sete campos com tabulação: marca UTC, CPU, memória, disco e depois os estados de CPU, memória e disco nessa ordem.

Abra as funções:

nano monitor-functions.sh

Substitua apenas 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 substitui cada %s, \t escreve uma tabulação e \n termina a linha. Uma barra invertida ao final de uma linha continua o mesmo comando. $(...) captura a saída de uma função. Aspas duplas preservam cada valor e um caminho de registro com espaços. >> acrescenta; usar > destruiria registros anteriores. Salve com Ctrl+O, Enter, Ctrl+X.

Teste um registro fornecido em um arquivo de prática separado. source ./policy.sh carrega os limites neste processo Bash. Eles não persistem automaticamente em outro terminal nem em uma chamada posterior de 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

O aviso de memória compara 85 com 80; não transforma os outros estados em WARN. Repetir a chamada acrescenta outra linha de prática. Não adicione exemplos a history.tsv: esse arquivo fica reservado para amostragem real.

Use o exemplo de prática para ler os sete campos da esquerda para a direita:

Tabulações podem parecer espaços desiguais em Terminal. Preserve as tabulações reais produzidas pela função; não alinhe manualmente o histórico real com espaços. A linha original do operador é contexto preparado, então sua data anterior é normal. Apenas o arquivo de prática separado recebe este exemplo fornecido.

Execute uma observação limitada e preserve o histórico

Nesta etapa, você repetirá amostragens reais, inspecionará o resultado e executará novamente sem perder o progresso.

Permaneça em Terminal, em /home/labex/project/resource-watch. O monitor.sh preparado fornece capture_once target logfile: obtém uma nova observação, chama seu registrador e mostra a linha salva. run_monitor precisa transmitir os caminhos sem alterações e chamar a ação exatamente a quantidade solicitada. Cada captura inclui uma nova janela de CPU de um segundo; é uma observação limitada, não um agendador preciso.

nano monitor-functions.sh

Substitua apenas essa função por:

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

O laço aritmético começa em zero, continua enquanto n for menor que count e incrementa n após cada captura. As aspas preservam os dois caminhos. Um laço while equivalente também é válido. Salve com Ctrl+O, Enter, Ctrl+X.

Execute três amostras reais:

bash monitor.sh 3

Três linhas devem aparecer antes de retornar ao prompt. Cada marca UTC deve ser posterior à anterior. Valores reais variam e uma execução normal pode não gerar avisos. O programa aceita de 1 a 30 amostras. Em uma observação longa, Ctrl+C interrompe o script em primeiro plano e preserva as linhas acrescentadas. Você não precisa encerrar outros processos.

Leia o resultado e conte linhas. wc -l conta linhas terminadas por uma quebra de linha:

cat history.tsv

wc -l history.tsv

Após a primeira execução descrita, deve haver quatro linhas: a original e três novas. Se você coletou mais amostras, haverá mais. Preserve essas observações válidas.

Continue com uma amostra:

bash monitor.sh 1

wc -l history.tsv

O total aumenta em um. Repetir é seguro porque o registrador acrescenta em vez de substituir. Compare cada estado com a leitura e seu limite em policy.sh.

Teste intencionalmente um erro comum de entrada: zero é rejeitado antes da amostragem.

bash monitor.sh 0

Use a sample count from 1 to 30.

Essa falha esperada sai com estado 2 e não altera o histórico. Recupere usando uma quantidade válida, sem reiniciar a VM nem editar o registro:

bash monitor.sh 1

Uma nova linha é acrescentada. O amostrador preparado também rejeita métricas incompletas, em vez de acrescentar uma observação vazia com aparência plausível.

Confira o resultado

• A linha original do operador continua no início, seguida das novas observações.
• A primeira execução acrescenta três linhas; continuar com uma amostra acrescenta mais uma. Mais linhas válidas são permitidas se você repetiu um comando.
• Leia primeiro as três porcentagens e compare cada uma com seu próprio limite. Três estados OK são válidos; não é preciso gerar carga nem apagar arquivos para provocar um aviso.
• Cada captura espera um novo intervalo de CPU. Uma pausa breve é normal; não pressione Enter repetidamente durante a amostragem. Quando o prompt retorna, a execução limitada terminou. Fechar Terminal não mantém um monitor contínuo funcionando.

Resumo

Você implementou uma regra de aviso que inclui igualdade, acrescentou registros completos com três estados independentes e repetiu amostragens reais preservando o histórico. Agora pode executar uma observação curta, ler suas evidências e continuá-la. O desafio independente muda o alvo e a política, reutilizando as ferramentas e os contratos ensinados.