Testes de Condição no Linux

Introdução

Neste laboratório, você aprenderá como usar testes de condição no Linux para automatizar verificações e validações do sistema. O Linux fornece o poderoso comando test que permite avaliar condições e executar ações com base nos resultados. Compreender como usar este comando é essencial para escrever scripts de shell que podem tomar decisões e responder a diferentes condições.

Ao longo deste laboratório, você trabalhará com vários aspectos do comando test, incluindo testes de arquivos, comparação de strings e avaliação numérica. Ao final desta sessão, você será capaz de escrever scripts que podem realizar verificações automatizadas em seu sistema e ajudar a manter sua integridade.

Entendendo os Fundamentos do Comando Test

O comando test no Linux é uma ferramenta crucial para avaliar condições em scripts de shell. Ele permite verificar propriedades de arquivos, comparar strings, avaliar valores numéricos e muito mais. Quando a condição sendo testada é verdadeira, test retorna um status de saída zero; caso contrário, ele retorna um status de saída diferente de zero.

Vamos começar com o básico. Primeiro, navegue até o diretório do seu projeto:

cd ~/project

O comando test pode ser escrito de duas maneiras:

1. Usando a palavra test seguida pela condição
2. Usando colchetes [ ] em torno da condição

Vamos tentar ambos os métodos para verificar se um diretório existe:

## Método 1: Usando a palavra 'test'
test -d ~/project && echo "O diretório do projeto existe."

## Método 2: Usando colchetes
[ -d ~/project ] && echo "O diretório do projeto existe."

Você deve ver a seguinte saída para ambos os comandos:

O diretório do projeto existe.

A opção -d verifica se um diretório existe. O operador && é usado para executar o comando echo somente se a condição do teste for verdadeira.

Algumas opções comuns de teste de arquivo incluem:

• -d file: Verdadeiro se o arquivo existir e for um diretório
• -e file: Verdadeiro se o arquivo existir
• -f file: Verdadeiro se o arquivo existir e for um arquivo regular
• -r file: Verdadeiro se o arquivo existir e for legível
• -w file: Verdadeiro se o arquivo existir e for gravável
• -x file: Verdadeiro se o arquivo existir e for executável
• -s file: Verdadeiro se o arquivo existir e tiver um tamanho maior que zero

Vamos criar um arquivo de teste e verificar suas propriedades:

## Criar um arquivo de teste
echo "Olá, teste de condição Linux!" > test_file.txt

## Verificar se o arquivo existe
test -e test_file.txt && echo "O arquivo existe."

## Verificar se o arquivo é legível
[ -r test_file.txt ] && echo "O arquivo é legível."

## Verificar se o arquivo não está vazio
[ -s test_file.txt ] && echo "O arquivo não está vazio."

Esses comandos devem produzir a seguinte saída:

O arquivo existe.
O arquivo é legível.
O arquivo não está vazio.

Agora, vamos criar um script de shell simples que usa o comando test para verificar se um arquivo existe e, caso não exista, criá-lo:

## Criar um arquivo de script
cat > check_file.sh << 'EOF'
#!/bin/bash

FILENAME="status.txt"

if [ ! -e "$FILENAME" ]; then
  echo "Arquivo $FILENAME não existe. Criando agora."
  echo "Este é um arquivo de status." > "$FILENAME"
else
  echo "Arquivo $FILENAME já existe."
fi

## Exibir o conteúdo do arquivo
echo "Conteúdo de $FILENAME:"
cat "$FILENAME"
EOF

## Tornar o script executável
chmod +x check_file.sh

## Executar o script
./check_file.sh

Quando você executar o script, deverá ver uma saída semelhante a:

Arquivo status.txt não existe. Criando agora.
Conteúdo de status.txt:
Este é um arquivo de status.

Se você executar o script novamente, verá:

Arquivo status.txt já existe.
Conteúdo de status.txt:
Este é um arquivo de status.

Isso demonstra como usar o comando test para verificar a existência de arquivos e tomar diferentes ações com base no resultado.

Testando Condições de String

Nesta etapa, você aprenderá como usar o comando test para comparar strings. Isso é útil quando você precisa validar a entrada do usuário, verificar variáveis de ambiente ou tomar decisões com base no conteúdo do texto.

Os operadores comuns de comparação de strings incluem:

• ==: Igual a
• !=: Diferente de
• -z: Verdadeiro se a string estiver vazia
• -n: Verdadeiro se a string não estiver vazia

Vamos começar testando diferentes condições de string:

## Testar se duas strings são iguais
str1="linux"
str2="linux"
[ "$str1" == "$str2" ] && echo "As strings são iguais."

## Testar se duas strings são diferentes
str3="ubuntu"
[ "$str1" != "$str3" ] && echo "As strings são diferentes."

## Testar se uma string está vazia
empty_str=""
[ -z "$empty_str" ] && echo "A string está vazia."

## Testar se uma string não está vazia
[ -n "$str1" ] && echo "A string não está vazia."

A saída deve ser:

As strings são iguais.
As strings são diferentes.
A string está vazia.
A string não está vazia.

Agora, vamos criar um script que solicita uma senha e verifica se ela atende a certos critérios:

## Criar um script de validação de senha
cat > password_check.sh << 'EOF'
#!/bin/bash

echo "Digite uma senha:"
read -s password

## Verificar se a senha está vazia
if [ -z "$password" ]; then
  echo "Erro: A senha não pode estar vazia."
  exit 1
fi

## Verificar o comprimento da senha
if [ ${#password} -lt 8 ]; then
  echo "Erro: A senha deve ter pelo menos 8 caracteres."
  exit 1
fi

## Verificar se a senha contém a palavra "password"
if [[ "$password" == *password* ]]; then
  echo "Erro: A senha não pode conter a palavra 'password'."
  exit 1
fi

echo "Senha válida!"
EOF

## Tornar o script executável
chmod +x password_check.sh

## Executar o script
echo "Você pode testar o script executando: ./password_check.sh"

Tente executar o script com senhas diferentes para ver como ele valida a entrada:

## Testar com uma senha curta
echo "curta" | ./password_check.sh

## Testar com uma senha contendo "password"
echo "minhasenha123" | ./password_check.sh

## Testar com uma senha válida
echo "SenhaSegura123" | ./password_check.sh

Os dois primeiros testes devem falhar, enquanto o terceiro deve ter sucesso.

Vamos criar outro script que processa o status do sistema com base em uma entrada de texto:

## Criar um script de status do sistema
cat > system_status.sh << 'EOF'
#!/bin/bash

echo "Digite o status do sistema (normal, aviso, crítico):"
read status

if [ -z "$status" ]; then
  echo "Nenhum status fornecido. Assumindo operação normal."
  status="normal"
fi

case "$status" in
  "normal")
    echo "O sistema está operando normalmente. Nenhuma ação necessária."
    ;;
  "warning")
    echo "Aviso: O sistema requer atenção. Verifique os arquivos de log."
    ;;
  "critical")
    echo "CRÍTICO: Ação imediata necessária! Estabilidade do sistema em risco."
    ;;
  *)
    echo "Status desconhecido: $status. Por favor, use normal, aviso ou crítico."
    ;;
esac
EOF

## Tornar o script executável
chmod +x system_status.sh

## Executar o script
echo "Você pode testar o script executando: ./system_status.sh"

Tente executar o script com diferentes entradas de status:

## Testar com o status "normal"
echo "normal" | ./system_status.sh

## Testar com o status "aviso"
echo "aviso" | ./system_status.sh

## Testar com o status "crítico"
echo "crítico" | ./system_status.sh

## Testar com um status inválido
echo "instável" | ./system_status.sh

## Testar com entrada vazia
echo "" | ./system_status.sh

Cada entrada deve produzir uma saída diferente com base na lógica condicional no script.

Testando Condições Numéricas

Nesta etapa, você aprenderá como usar o comando test para comparações numéricas. Isso é útil para verificar o uso de recursos, validar a entrada do usuário ou tomar decisões com base em valores numéricos.

Os operadores comuns de comparação numérica incluem:

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

Vamos começar com algumas comparações numéricas básicas:

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

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

## Diferente de
[ $num1 -ne $num2 ] && echo "$num1 não é igual a $num2"

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

## Maior que
[ $num2 -gt $num1 ] && echo "$num2 é maior que $num1"

## Menor ou igual a
[ $num1 -le 10 ] && echo "$num1 é menor ou igual a 10"

## Maior ou igual a
[ $num2 -ge 20 ] && echo "$num2 é maior ou igual a 20"

A saída deve ser semelhante a:

10 é igual a 10
10 não é igual a 20
10 é menor que 20
20 é maior que 10
10 é menor ou igual a 10
20 é maior ou igual a 20

Agora, vamos criar um script que verifica o espaço em disco e alerta quando ele está abaixo de um determinado limite:

## Criar um script de verificação de espaço em disco
cat > disk_check.sh << 'EOF'
#!/bin/bash

## Obter a porcentagem de uso do disco (removendo o sinal de %)
DISK_USAGE=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')

## Definir limites
WARNING_THRESHOLD=70
CRITICAL_THRESHOLD=90

echo "Uso atual do disco: $DISK_USAGE%"

if [ $DISK_USAGE -ge $CRITICAL_THRESHOLD ]; then
  echo "CRÍTICO: O uso do disco está criticamente alto!"
  echo "Ação: Limpe arquivos desnecessários imediatamente."
elif [ $DISK_USAGE -ge $WARNING_THRESHOLD ]; then
  echo "AVISO: O uso do disco está ficando alto."
  echo "Ação: Considere limpar alguns arquivos em breve."
else
  echo "OK: O uso do disco está normal."
  echo "Nenhuma ação necessária."
fi
EOF

## Tornar o script executável
chmod +x disk_check.sh

## Executar o script
./disk_check.sh

O script exibirá o uso atual do disco e emitirá uma mensagem diferente com base em quão cheio o disco está.

Vamos criar outro script que simula um sistema de monitoramento de temperatura:

## Criar um script de monitoramento de temperatura
cat > temp_monitor.sh << 'EOF'
#!/bin/bash

## Função para gerar uma temperatura aleatória entre 15 e 35
generate_temp() {
  echo $((RANDOM % 21 + 15))
}

## Gerar temperatura aleatória
TEMP=$(generate_temp)
echo "Temperatura atual: ${TEMP}°C"

## Limites de temperatura
MIN_TEMP=18
MAX_TEMP=26

if [ $TEMP -lt $MIN_TEMP ]; then
  echo "Ação: Aumentar o aquecimento. A temperatura está abaixo do limite mínimo."
elif [ $TEMP -gt $MAX_TEMP ]; then
  echo "Ação: Ativar o resfriamento. A temperatura está acima do limite máximo."
else
  echo "Status: A temperatura está dentro da faixa aceitável."
fi

## Verificação adicional para temperaturas extremas
if [ $TEMP -ge 30 ]; then
  echo "AVISO: A temperatura está muito alta. Verifique os sistemas de resfriamento."
fi
if [ $TEMP -le 17 ]; then
  echo "AVISO: A temperatura está muito baixa. Verifique os sistemas de aquecimento."
fi
EOF

## Tornar o script executável
chmod +x temp_monitor.sh

## Executar o script
./temp_monitor.sh

Cada vez que você executar este script, ele gerará uma temperatura aleatória e responderá de acordo. Tente executá-lo várias vezes para ver resultados diferentes:

## Executar o script de monitoramento de temperatura várias vezes
./temp_monitor.sh
./temp_monitor.sh
./temp_monitor.sh

Esses exemplos demonstram como usar condições numéricas para monitorar parâmetros do sistema e tomar as ações apropriadas com base nos valores limite.

Combinando Condições com Operadores Lógicos

Nesta etapa, você aprenderá como combinar múltiplas condições usando operadores lógicos. Isso é essencial para criar uma lógica de tomada de decisão complexa em seus scripts.

Os três principais operadores lógicos são:

• && (AND): Verdadeiro se ambas as condições forem verdadeiras
• || (OR): Verdadeiro se pelo menos uma condição for verdadeira
• ! (NOT): Verdadeiro se a condição for falsa

Vamos começar com alguns exemplos básicos:

## Criar um arquivo de teste
touch test_file.txt
chmod 644 test_file.txt

## Operador AND - ambas as condições devem ser verdadeiras
[ -f test_file.txt ] && [ -r test_file.txt ] && echo "O arquivo existe e é legível."

## Operador OR - pelo menos uma condição deve ser verdadeira
[ -x test_file.txt ] || [ -w test_file.txt ] && echo "O arquivo é executável ou gravável."

## Operador NOT - inverte a condição
[ ! -x test_file.txt ] && echo "O arquivo não é executável."

## Combinando múltiplos operadores
[ -f test_file.txt ] && [ -r test_file.txt ] && [ ! -x test_file.txt ] && echo "O arquivo existe, é legível, mas não é executável."

Você deve ver uma saída semelhante a:

O arquivo existe e é legível.
O arquivo é executável ou gravável.
O arquivo não é executável.
O arquivo existe, é legível, mas não é executável.

O comando test também permite que você combine condições dentro de um único conjunto de colchetes usando esses operadores:

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

Por exemplo:

## AND dentro de um único comando de teste
[ -f test_file.txt -a -r test_file.txt ] && echo "O arquivo existe e é legível."

## OR dentro de um único comando de teste
[ -x test_file.txt -o -w test_file.txt ] && echo "O arquivo é executável ou gravável."

Vamos criar um script mais complexo que verifica os recursos do sistema:

## Criar um script de verificação de recursos do sistema
cat > resource_check.sh << 'EOF'
#!/bin/bash

echo "Verificando recursos do sistema..."

## Verificar o uso da memória
MEM_THRESHOLD=80
MEM_USED=$(free | grep Mem | awk '{print int($3/$2 * 100)}')

echo "Uso da memória: ${MEM_USED}%"

## Verificar o espaço em disco
DISK_THRESHOLD=70
DISK_USED=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')

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

## Verificar a carga da CPU (média de 1 minuto)
LOAD_THRESHOLD=1.0
CPU_LOAD=$(cat /proc/loadavg | awk '{print $1}')

echo "Média de carga da CPU: ${CPU_LOAD}"

## Verificação de condição combinada
if [ $MEM_USED -gt $MEM_THRESHOLD ] && [ $DISK_USED -gt $DISK_THRESHOLD ]; then
  echo "CRÍTICO: Tanto o uso da memória quanto o do disco estão altos!"
  echo "Ação: Libere recursos imediatamente."
elif [ $MEM_USED -gt $MEM_THRESHOLD ] || [ $DISK_USED -gt $DISK_THRESHOLD ]; then
  echo "AVISO: O uso da memória ou do disco está alto."
  echo "Ação: Monitore o sistema de perto."
else
  echo "OK: O uso da memória e do disco está dentro dos limites aceitáveis."
fi

## Verificar se a carga é numérica antes de comparar
if [[ $CPU_LOAD =~ ^[0-9]+(\.[0-9]+)?$ ]]; then
  ## Precisamos usar bc para comparação de ponto flutuante
  if (( $(echo "$CPU_LOAD > $LOAD_THRESHOLD" | bc -l) )); then
    echo "AVISO: A carga da CPU está alta. Verifique se há processos intensivos em recursos."
  else
    echo "OK: A carga da CPU está normal."
  fi
else
  echo "Erro: Não foi possível analisar o valor da carga da CPU."
fi
EOF

## Tornar o script executável
chmod +x resource_check.sh

## Executar o script
./resource_check.sh

Este script verifica o uso da memória, o espaço em disco e a carga da CPU, em seguida, fornece saídas diferentes com base em combinações dessas condições.

Finalmente, vamos criar um script que valida a entrada do usuário com múltiplas condições:

## Criar um script de validação de entrada
cat > validate_input.sh << 'EOF'
#!/bin/bash

echo "Digite um nome de usuário (apenas letras minúsculas, 3-8 caracteres):"
read username

echo "Digite sua idade (deve ter 18 anos ou mais):"
read age

## Validação do nome de usuário
is_valid_username=true

## Verificar se o nome de usuário está vazio
if [ -z "$username" ]; then
  echo "Erro: O nome de usuário não pode estar vazio."
  is_valid_username=false
fi

## Verificar o comprimento do nome de usuário
if [ ${#username} -lt 3 ] || [ ${#username} -gt 8 ]; then
  echo "Erro: O nome de usuário deve ter entre 3 e 8 caracteres."
  is_valid_username=false
fi

## Verificar se o nome de usuário contém apenas letras minúsculas
if [[ ! "$username" =~ ^[a-z]+$ ]]; then
  echo "Erro: O nome de usuário deve conter apenas letras minúsculas."
  is_valid_username=false
fi

## Validação da idade
is_valid_age=true

## Verificar se a idade é um número
if [[ ! "$age" =~ ^[0-9]+$ ]]; then
  echo "Erro: A idade deve ser um número."
  is_valid_age=false
fi

## Verificar se a idade tem pelo menos 18 anos
if [ "$is_valid_age" = true ] && [ $age -lt 18 ]; then
  echo "Erro: Você deve ter pelo menos 18 anos de idade."
  is_valid_age=false
fi

## Validação final
if [ "$is_valid_username" = true ] && [ "$is_valid_age" = true ]; then
  echo "Registro bem-sucedido!"
  echo "Bem-vindo, $username. Sua conta foi criada."
else
  echo "Falha no registro. Por favor, corrija os erros e tente novamente."
fi
EOF

## Tornar o script executável
chmod +x validate_input.sh

## Executar o script
echo "Você pode testar o script executando: ./validate_input.sh"

Tente executar o script com diferentes entradas para ver como as condições combinadas funcionam juntas para validar a entrada do usuário:

## Testar com entrada válida
echo -e "joao\n25" | ./validate_input.sh

## Testar com nome de usuário inválido (muito curto)
echo -e "jo\n25" | ./validate_input.sh

## Testar com nome de usuário inválido (contém letras maiúsculas)
echo -e "Joao\n25" | ./validate_input.sh

## Testar com idade inválida (menor que 18)
echo -e "joao\n17" | ./validate_input.sh

## Testar com idade inválida (não é um número)
echo -e "joao\nabc" | ./validate_input.sh

Esses exemplos demonstram como combinar múltiplas condições para criar uma lógica de validação complexa em seus scripts.

Criando um Script Abrangente de Monitoramento do Sistema

Nesta etapa final, você combinará tudo o que aprendeu para criar um script abrangente de monitoramento do sistema. Este script verificará vários parâmetros do sistema e fornecerá um relatório resumido.

Vamos criar um script que monitora múltiplos aspectos do sistema:

## Criar um script de monitoramento do sistema
cat > system_monitor.sh << 'EOF'
#!/bin/bash

echo "========================================"
echo "    Relatório de Monitoramento do Sistema"
echo "    $(date)"
echo "========================================"
echo

## 1. Verificar se arquivos importantes do sistema existem
echo "1. Verificação de Arquivos do 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"
    
    ## Verificar se o arquivo está vazio
    if [ ! -s "$file" ]; then
      echo "   [WARNING] $file está vazio"
    fi
    
    ## Verificar se o arquivo é legível
    if [ ! -r "$file" ]; then
      echo "   [WARNING] $file não é legível"
    fi
  else
    echo "   [ERROR] $file não existe"
    all_files_exist=false
  fi
done

if [ "$all_files_exist" = true ]; then
  echo "   Todos os arquivos do sistema estão presentes."
else
  echo "   Alguns arquivos do sistema estão faltando. Verifique os erros acima."
fi
echo

## 2. Verificar o espaço em disco
echo "2. Verificação do Espaço em Disco:"
disk_usage=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')
echo "   Uso da partição raiz: ${disk_usage}%"

if [ $disk_usage -ge 90 ]; then
  echo "   [CRÍTICO] O uso do disco está criticamente alto!"
elif [ $disk_usage -ge 70 ]; then
  echo "   [AVISO] O uso do disco está ficando alto."
else
  echo "   [OK] O uso do disco está normal."
fi
echo

## 3. Verificar o uso da memória
echo "3. Verificação do Uso da Memória:"
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 da memória: ${mem_percentage}% (${mem_used}MB usados de ${mem_total}MB)"

if [ $mem_percentage -ge 90 ]; then
  echo "   [CRÍTICO] O uso da memória está criticamente alto!"
elif [ $mem_percentage -ge 70 ]; then
  echo "   [AVISO] O uso da memória está ficando alto."
else
  echo "   [OK] O uso da memória está normal."
fi
echo

## 4. Verificar processos ativos
echo "4. Verificação de Processos:"
critical_processes=("sshd" "cron")
for process in "${critical_processes[@]}"; do
  if pgrep -x "$process" > /dev/null; then
    echo "   [OK] $process está em execução"
  else
    echo "   [ERROR] $process não está em execução"
  fi
done
echo

## 5. Verificar a carga do sistema
echo "5. Verificação da Carga do 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 "   Média de carga: $load_1min (1 min), $load_5min (5 min), $load_15min (15 min)"

## Determinar o número de núcleos da 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 "   [AVISO] Carga alta detectada. O sistema pode estar sob estresse."
else
  echo "   [OK] A carga do sistema está normal."
fi
echo

## 6. Verificar tentativas recentes de login com falha
echo "6. Verificação de Segurança:"
if [ -f /var/log/auth.log ]; then
  failed_logins=$(grep "Failed password" /var/log/auth.log | wc -l)
  echo "   Tentativas de login com falha: $failed_logins"
  
  if [ $failed_logins -gt 10 ]; then
    echo "   [AVISO] Alto número de tentativas de login com falha detectadas."
  else
    echo "   [OK] Atividade de login normal."
  fi
else
  echo "   [INFO] Não é possível verificar as tentativas de login (auth.log não acessível)"
fi
echo

## 7. Resumo
echo "7. Resumo do Status do Sistema:"
critical_count=$(grep -c "\[CRÍTICO\]" <<< "$(cat /dev/stdin)")
warning_count=$(grep -c "\[AVISO\]" <<< "$(cat /dev/stdin)")
error_count=$(grep -c "\[ERROR\]" <<< "$(cat /dev/stdin)")

if [ $critical_count -gt 0 ]; then
  echo "   [CRÍTICO] O sistema tem problemas críticos que precisam de atenção imediata!"
elif [ $warning_count -gt 0 ] || [ $error_count -gt 0 ]; then
  echo "   [AVISO] O sistema tem alguns problemas que devem ser resolvidos em breve."
else
  echo "   [OK] O sistema está operando normalmente. Nenhum problema significativo detectado."
fi

echo
echo "========================================"
echo "    Fim do Relatório de Monitoramento do Sistema"
echo "========================================"
EOF

## Tornar o script executável
chmod +x system_monitor.sh

## Executar o script
./system_monitor.sh

Este script abrangente realiza as seguintes verificações:

1. Verifica se arquivos importantes do sistema existem e são legíveis
2. Verifica o uso do espaço em disco
3. Monitora o uso da memória
4. Confirma se os processos críticos estão em execução
5. Avalia a carga do sistema
6. Examina os logs de segurança em busca de tentativas de login com falha
7. Fornece um resumo geral do status do sistema

A saída variará dependendo do estado atual do seu sistema, mas fornecerá uma visão geral abrangente da integridade do seu sistema.

Para tornar este script ainda mais útil, você pode:

1. Agendá-lo para ser executado periodicamente usando o cron
2. Configurar para enviar alertas por e-mail quando problemas críticos forem detectados
3. Adicionar mais verificações específicas relevantes para o seu sistema

Vamos criar uma versão mais simples que você pode agendar para ser executada periodicamente:

## Criar um script de monitoramento simplificado para agendamento
cat > daily_check.sh << 'EOF'
#!/bin/bash

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

## Iniciar o registro
echo "Verificação do Sistema: $(date)" > $LOG_FILE
echo "--------------------------------" >> $LOG_FILE

## Verificar o espaço em disco
disk_usage=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')
echo "Uso do disco: ${disk_usage}%" >> $LOG_FILE

if [ $disk_usage -ge 90 ]; then
  echo "CRÍTICO: O uso do disco está criticamente alto!" >> $LOG_FILE
elif [ $disk_usage -ge 70 ]; then
  echo "AVISO: O uso do disco está ficando alto." >> $LOG_FILE
else
  echo "OK: O uso do disco está normal." >> $LOG_FILE
fi

## Verificar a memória
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 da memória: ${mem_percentage}%" >> $LOG_FILE

if [ $mem_percentage -ge 90 ]; then
  echo "CRÍTICO: O uso da memória está criticamente alto!" >> $LOG_FILE
elif [ $mem_percentage -ge 70 ]; then
  echo "AVISO: O uso da memória está ficando alto." >> $LOG_FILE
else
  echo "OK: O uso da memória está normal." >> $LOG_FILE
fi

## Verificar serviços críticos
for service in sshd cron; do
  if pgrep -x "$service" > /dev/null; then
    echo "$service está em execução" >> $LOG_FILE
  else
    echo "AVISO: $service não está em execução" >> $LOG_FILE
  fi
done

## Finalizar o log
echo "--------------------------------" >> $LOG_FILE
echo "Verificação concluída em $(date)" >> $LOG_FILE

## Exibir a localização do log
echo "Verificação do sistema concluída. Log salvo em $LOG_FILE"
EOF

## Tornar o script executável
chmod +x daily_check.sh

## Executar o script
./daily_check.sh

Para agendar este script para ser executado diariamente, você normalmente usaria o sistema cron. Veja como você o configuraria:

## Mostrar como configurar um trabalho cron (não crie-o realmente neste ambiente de laboratório)
echo "Para agendar este script para ser executado diariamente às 9h, você usaria:"
echo "crontab -e"
echo "E adicione a linha:"
echo "0 9 * * * /home/labex/project/daily_check.sh"

Isso demonstra como os comandos de teste de condição do Linux que você aprendeu podem ser aplicados para criar ferramentas práticas de monitoramento do sistema.

Resumo

Neste laboratório, você aprendeu como usar o teste de condição do Linux para avaliar diferentes tipos de condições e tomar decisões com base nos resultados. Aqui está um resumo do que você realizou:

1. Você aprendeu os fundamentos do comando test e como verificar propriedades de arquivos, como existência, legibilidade e tamanho.

2. Você explorou a comparação de strings usando operadores como ==, !=, -z e -n para validar a entrada e tomar decisões com base no conteúdo do texto.

3. Você trabalhou com comparações numéricas usando operadores como -eq, -ne, -lt, -gt, -le e -ge para avaliar valores numéricos.

4. Você combinou múltiplas condições usando operadores lógicos (&&, ||, !) para criar uma lógica complexa de tomada de decisão.

5. Você aplicou todas essas técnicas para criar scripts abrangentes de monitoramento do sistema que podem verificar vários parâmetros do sistema e fornecer relatórios de status.

Essas habilidades são fundamentais para a criação de scripts de shell e a administração de sistemas no Linux. A capacidade de testar condições e tomar diferentes ações com base nos resultados permite que você crie scripts que podem automatizar tarefas, validar a entrada, lidar com erros e monitorar a integridade do sistema.

Algumas aplicações práticas do que você aprendeu incluem:

• Criar scripts de backup automatizados que verificam o espaço disponível antes de prosseguir
• Desenvolver validação de entrada para scripts voltados para o usuário
• Construir ferramentas de monitoramento do sistema que alertam os administradores sobre possíveis problemas
• Automatizar tarefas rotineiras de manutenção do sistema com lógica condicional

À medida que você continua a trabalhar com o Linux, descobrirá que o teste de condição é uma parte essencial de quase todos os scripts de shell que você cria ou mantém.