0Pricing
Linux Command Line & Bash Scripting Mastery · Aula

Criação de scripts de verificação e alerta da integridade do sistema

Colete métricas de carga, memória e disco e acione alertas baseados em limites a partir de scripts agendados.

Criação de scripts de verificação e alerta da integridade do sistema é uma aula grátis de Linux Command Line & Bash Scripting Mastery no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Linux Command Line & Bash Scripting Mastery, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Linux Command Line & Bash Scripting Mastery inclui 4 aulas no total.

Por que as verificações de integridade do sistema são importantes

Os servidores de produção podem se degradar silenciosamente. Picos de CPU, vazamentos de memória e discos cheios causam interrupções — mas somente se ninguém perceber a tempo. Os scripts de verificação de integridade do sistema automatizam o ciclo de monitoramento: coletam métricas, comparam-nas com limites e disparam alertas antes que os usuários percebam o problema.

  • Agendados pelo cron, eles são executados a cada poucos minutos sem atenção humana
  • Produzem uma saída consistente e com marcação de tempo, adequada para agregação de registros
  • A lógica baseada em limites mantém os alertas relevantes — nem todo contratempo aciona a equipe de plantão

Nesta lição, você criará do zero um script de verificação de integridade pronto para produção, em camadas, abrangendo carga média, pressão de memória e utilização do disco.

Capturando a carga média

O Linux disponibiliza as cargas médias de 1, 5 e 15 minutos por meio de /proc/loadavg e do comando uptime. Para scripts, /proc/loadavg é a fonte mais adequada — não há problemas de localidade nem variações de análise entre distribuições.

O trecho abaixo lê a carga média de 1 minuto e a armazena em uma variável para comparação com um limite. cut extrai o primeiro campo; awk remove a parte decimal para comparação inteira usando bc para aritmética de números reais.

#!/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"

Comparando limites com valores de ponto flutuante

O Bash não consegue comparar nativamente números de ponto flutuante — [ 1.5 -gt 1.2 ] gera um erro. As duas soluções idiomáticas são:

  • bc — produz 1 (verdadeiro) ou 0 (falso) a partir de uma expressão de comparação
  • awk — pode avaliar condições de ponto flutuante dentro de um fluxo de processamento

Usar bc mantém a lógica legível e fácil de testar. O padrão $(echo "$A > $B" | bc) retorna 1 quando a condição é satisfeita; você verifica isso com [ ... -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

Coletando métricas de memória

/proc/meminfo é a fonte oficial das estatísticas de memória no Linux. Campos principais:

  • MemTotal — RAM física total em kB
  • MemAvailable — quantidade estimada, em kB, disponível para novas alocações sem usar a área de troca (melhor que MemFree)

awk com correspondência de padrões é a forma mais simples de extrair esses valores. Dividir MemAvailable por MemTotal e subtrair o resultado de 100 fornece a porcentagem de memória usada, que determina o limite do 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}%"

Coletando métricas de uso do disco

O comando df informa o uso dos sistemas de arquivos. Para scripts, duas opções são essenciais:

  • -h — tamanhos legíveis por humanos (somente para exibição; evite em cálculos)
  • --output=pcent,target — colunas analisáveis por máquinas (GNU coreutils)

Iterar por todos os sistemas de arquivos montados permite que o script sinalize qualquer partição que esteja criticamente cheia, não apenas /. O sinal % é removido com tr -d '%' antes da comparação inteira.

#!/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

Saída estruturada de alertas com marcações de tempo

Mensagens de alerta sem marcações de tempo são quase inúteis em arquivos de registro ou relatórios por e-mail. Um prefixo consistente torna simples analisar os registros com grep ou agentes de envio de registros.

Defina uma pequena função de alerta no início do script. Ela acrescenta uma marcação de tempo ISO-8601, um nível de gravidade e o nome da verificação. Todos os alertas são gravados tanto em stdout quanto em um arquivo de registro por meio de tee.

  • date -u +"%Y-%m-%dT%H:%M:%SZ" — marcação de tempo UTC, independente da localidade
  • Gravar em stderr para ALERT e em stdout para OK separa sinais de ruído nos fluxos de processamento
#!/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"

Enviando alertas por e-mail com mail e sendmail

O mecanismo mais simples de alertas em um servidor é o e-mail por meio do MTA local (postfix, sendmail ou msmtp). O comando mail (dos pacotes mailutils ou bsd-mailx) compõe e envia uma mensagem em uma única linha.

  • -s — linha de assunto
  • Envie o corpo pelo stdin
  • Em servidores sem um MTA local, substitua mail por uma chamada curl a uma API transacional de e-mail

Proteja o envio com um bloqueio de deduplicação para que uma condição ruidosa não inunde a caixa 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)"

Compondo o script completo de verificação de integridade

Agora combine as três verificações — carga, memória e disco — em um único script coeso, com limites configuráveis no início. Este é o padrão usado na automação de administração de sistemas em ambientes de produção:

  • Constantes declaradas no início para facilitar ajustes sem editar a lógica
  • Cada verificação isolada em uma função para melhorar a legibilidade e permitir testes unitários
  • Uma função main coordena as chamadas
  • Código de saída 1 se algum alerta for disparado, 0 caso contrário — isso torna o script compatível com estruturas de monitoramento 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

Agendamento com Cron

Um script de verificação de integridade só é útil quando é executado automaticamente. O cron é o agendador padrão do Unix. Edite a tabela de agendamento de todo o sistema ou um arquivo dedicado em /etc/cron.d/ para agendar seu script.

  • Executar a cada 5 minutos: */5 * * * *
  • Sempre use caminhos absolutos no cron — $PATH é mínimo no ambiente do cron
  • Redirecione a saída para impedir que o cron envie um e-mail a cada execução: >> /var/log/healthcheck.log 2>&1
  • Use MAILTO="" no início da tabela de agendamento para silenciar o próprio e-mail do 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

Evitando tempestades de alertas com bloqueios de resfriamento

Quando um limite é ultrapassado continuamente, um script ingênuo dispara um alerta a cada 5 minutos — dezenas de e-mails antes que um engenheiro consiga responder. Um bloqueio de resfriamento suprime alertas repetidos durante uma janela configurável.

O padrão é o seguinte: escreva um arquivo de bloqueio no primeiro alerta; ignore os alertas seguintes enquanto o arquivo for mais recente que o período de resfriamento; find com -mmin verifica atomicamente a idade do arquivo, sem fazer cálculos de data.

#!/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

Testando e validando seu script de verificação de integridade

Antes da implantação, valide o script de três maneiras:

  • Verificação de sintaxe: bash -n healthcheck.sh detecta erros de análise sem executar o script
  • Modo de rastreamento: bash -x healthcheck.sh exibe cada comando à medida que é executado — é indispensável para depuração
  • Sobrescrita de limites: reduza temporariamente os limites para valores próximos de zero, para que o script dispare alertas em um host saudável e confirme que o caminho de alerta funciona de ponta a ponta

Para o caminho de e-mail, redirecione mail para um arquivo de registro durante os testes usando uma sinalização 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

Verificação de conhecimento: estratégia de resfriamento

Considere o seguinte cenário: seu trabalho do cron de verificação de integridade é executado a cada 5 minutos. O uso do disco em /var ultrapassa 85% e permanece nesse nível por 3 horas. Você quer que o engenheiro de plantão receba um alerta uma vez por hora, e não a cada 5 minutos. Qual estratégia de implementação é mais apropriada?

Recapitulação da lição: scripts de verificação de integridade do sistema

Nesta lição, você criou uma cadeia completa e pronta para produção de verificação da integridade do sistema e emissão de alertas. Estes são os princípios fundamentais a serem levados adiante:

  • Fonte da verdade: leia as métricas de /proc/loadavg e /proc/meminfo — elas são estáveis, independentes do idioma e estão disponíveis em todo host Linux
  • Aritmética de ponto flutuante: use bc para comparações de limites com ponto flutuante; a comparação de inteiros do Bash (-gt) funciona apenas com números inteiros
  • Iteração de discos: use df --output=pcent,target para verificar cada sistema de arquivos montado, e não apenas /
  • Registro estruturado: prefixe cada linha com um carimbo de data e hora UTC e um nível de severidade, para que os registros sejam fáceis de pesquisar com grep e sejam enviados corretamente a sistemas de registro centralizados
  • Bloqueios de resfriamento: arquivos de bloqueio verificados com find -mmin evitam tempestades de alertas sem alterar o agendamento do cron
  • Composição: saia com o código 1 quando qualquer alerta for disparado, para que o script se integre ao Nagios, ao Icinga ou a outras estruturas de monitoramento
  • Testes: use bash -n para verificar a sintaxe, bash -x para depuração por rastreamento e uma sinalização MOCK_MAIL para validar o caminho de alerta em hosts saudáveis

Agende o script concluído por meio de /etc/cron.d/ e sua infraestrutura fará o próprio monitoramento continuamente, emitindo alertas apenas quando os limites forem ultrapassados de forma significativa.

Perguntas Frequentes

A aula “Criação de scripts de verificação e alerta da integridade do sistema” é grátis?

Sim — o texto completo de “Criação de scripts de verificação e alerta da integridade do sistema” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Linux Command Line & Bash Scripting Mastery, atualize para CoddyKit PRO. O curso de Linux Command Line & Bash Scripting Mastery inclui 4 aulas no total.

O que vou aprender em “Criação de scripts de verificação e alerta da integridade do sistema”?

Colete métricas de carga, memória e disco e acione alertas baseados em limites a partir de scripts agendados. Você pratica Linux Command Line & Bash Scripting Mastery com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Linux Command Line & Bash Scripting Mastery?

Nenhuma experiência prévia é necessária. Linux Command Line & Bash Scripting Mastery no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Criação de scripts de verificação e alerta da integridade do sistema”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Linux Command Line & Bash Scripting Mastery?

Sim. Cada aula de Linux Command Line & Bash Scripting Mastery inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Automação do provisionamento de usuários e grupos
  2. Controle de serviços do systemd e criação de arquivos de unidade
  3. Automação de discos, sistemas de arquivos e montagem
  4. Criação de scripts de verificação e alerta da integridade do sistema
← Voltar para Linux Command Line & Bash Scripting Mastery