Linux Server Deployment & SSH Mastery · Aula

Tratamento de Erros e Geração de Registros em Scripts

Implemente um tratamento robusto de erros, redirecione a saída dos scripts e gere registros significativos para monitorar a execução e solucionar problemas.

Tratamento de Erros e Geração de Registros em Scripts é uma aula grátis de Linux Server Deployment & SSH Mastery no CoddyKit. Esta é a aula 3 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 Server Deployment & SSH Mastery, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Linux Server Deployment & SSH Mastery inclui 4 aulas no total.

Torne seus scripts confiáveis

Imagine seu script sendo executado em um servidor e realizando um trabalho importante. O que acontece se algo der errado?

Ele falha silenciosamente?
Ele deixa uma bagunça para trás?
Você consegue saber quando e por que ele falhou?

Scripts robustos tratam os erros de maneira adequada e fornecem registros claros. Esta lição ensina como fazer isso!

Entendendo os códigos de saída

Cada comando e script no Linux retorna um código de saída (ou status de saída) quando termina. Esse número informa se a execução foi bem-sucedida ou falhou.

0: significa sucesso! Tudo ocorreu bem.
1-255: significa falha. Um número específico pode indicar o tipo de erro.

Vamos ver isso na prática:

#!/bin/bash
# This script demonstrates exit codes

echo "Attempting a successful command..."
ls /tmp
echo "Exit code for 'ls /tmp': $?"

echo

echo "Attempting a failing command..."
ls /nonexistent_directory
echo "Exit code for 'ls /nonexistent_directory': $?"

Verificar o status do comando

Após a execução de qualquer comando, você pode verificar o código de saída usando a variável especial $?. Isso é muito útil para tomar decisões em seu script.

Você pode usar uma instrução if para reagir ao sucesso ou à falha:

#!/bin/bash
# Check if a file exists before trying to read it

FILENAME="test_file.txt"
touch $FILENAME # Create it for success case

if [ -f "$FILENAME" ]; then
  echo "File '$FILENAME' exists. Processing..."
  # ... do something with the file ...
  rm $FILENAME # Clean up
else
  echo "Error: File '$FILENAME' not found!"
  exit 1
fi

echo "Script finished."

`set -e`: Sair em caso de erro

Em scripts simples, verificar manualmente $? em todos os lugares pode ser trabalhoso. O comando set -e altera o comportamento do seu script:

Se qualquer comando terminar com um status diferente de zero (falhar), o script será encerrado imediatamente.
Isso impede que o script continue com dados potencialmente corrompidos ou em um estado inválido.

Experimente executar este script. O que acontece se o comando cp falhar?

#!/bin/bash
set -e

echo "Starting important operations..."
mkdir my_temp_dir
cp /nonexistent_source my_temp_dir/target # This will fail

echo "This line will not be reached if cp fails."
rmdir my_temp_dir
echo "Script finished successfully."

`trap` para limpeza

Às vezes, mesmo que um script falhe, é necessário realizar tarefas de limpeza, como remover arquivos temporários. O comando trap permite capturar sinais (como uma saída ou um erro) e executar um comando.

EXIT: é executado quando o script termina, independentemente de sucesso ou falha.
ERR: é executado quando um comando termina com um status diferente de zero (se set -e estiver ativo).

Aqui, garantimos que um diretório temporário seja sempre removido:

#!/bin/bash

TEMP_DIR="/tmp/my_script_temp_$(date +%s)"

function cleanup {
  echo "Cleaning up temporary directory: $TEMP_DIR"
  rm -rf "$TEMP_DIR"
}

trap cleanup EXIT

mkdir "$TEMP_DIR"
echo "Working in $TEMP_DIR..."
# Simulate some work, maybe it fails
# cp /nonexistent_file "$TEMP_DIR/" # Uncomment to test failure

echo "Script completed."

Redirecionando a saída

Quando seu script é executado, ele costuma exibir mensagens. Elas pertencem a dois tipos principais:

Saída padrão (stdout): mensagens normais (descritor de arquivo 1).
Erro padrão (stderr): mensagens de erro (descritor de arquivo 2).

Você pode redirecionar esses fluxos para arquivos em vez de exibi-los na tela:

command > file: redireciona stdout para file.
command 2> file: redireciona stderr para file.

Vamos salvar as mensagens de sucesso e de erro separadamente.

#!/bin/bash
# Redirect stdout to success.log and stderr to error.log

echo "This is a success message." > success.log
ls /nonexistent_path 2> error.log

echo "Check success.log and error.log files."
# To view them after running:
# cat success.log
# cat error.log

Toda a saída em um único arquivo

Muitas vezes, é útil ter tanto a saída padrão quanto o erro padrão em um único arquivo de registro, para facilitar a análise. Há algumas maneiras de fazer isso:

command > file 2>&1: redireciona stdout para file e, em seguida, redireciona stderr para onde stdout estiver sendo enviado (o arquivo).
command &> file: uma sintaxe mais curta e moderna para fazer a mesma coisa.

Isso é ótimo para criar um registro abrangente da execução do seu script.

#!/bin/bash
# Redirect both stdout and stderr to a single log file

LOG_FILE="combined_script.log"

echo "Starting script..." &> "$LOG_FILE"
echo "This message goes to stdout." &>> "$LOG_FILE"
ls /nonexistent_dir 2>&1 | tee -a "$LOG_FILE"
echo "Script finished." &>> "$LOG_FILE"

echo "Check the '$LOG_FILE' file for all output."

Adicionar marcas de tempo aos registros

Ao depurar, saber quando um evento aconteceu é fundamental. Adicionar marcas de tempo às mensagens de registro torna essas mensagens muito mais úteis.

Você pode acrescentar a data e a hora atuais no início de cada entrada de registro usando o comando date. Isso ajuda a rastrear os eventos em ordem cronológica.

#!/bin/bash

LOG_FILE="timestamped_script.log"

function log_message {
  echo "$(date +%Y-%m-%d_%H:%M:%S) - $1" &>> "$LOG_FILE"
}

log_message "Script started."
sleep 1
log_message "Performing task A..."
# Simulate an error
ls /no_such_place || log_message "Error: Command failed."
sleep 1
log_message "Script finished."

echo "Check '$LOG_FILE' for timestamped entries."

Enviar para os registros do sistema com `logger`

Para eventos importantes, você pode querer enviar mensagens diretamente para o recurso de registro do sistema (syslog). O comando logger faz exatamente isso.

Os registros do sistema costumam ser gerenciados por ferramentas como journalctl (em sistemas systemd).
Isso centraliza as mensagens importantes do seu script junto com outros eventos do sistema.
É útil para erros críticos ou trilhas de auditoria.

As mensagens enviadas com logger podem ser encontradas usando journalctl -f ou tail -f /var/log/syslog (dependendo do seu sistema).

#!/bin/bash
# Send a message to system logs

SCRIPT_NAME="MyBackupScript"

logger -t "$SCRIPT_NAME" "Starting daily backup operation."

# Simulate a task
sleep 2
if [ $(($RANDOM % 2)) -eq 0 ]; then
  logger -t "$SCRIPT_NAME" -p user.info "Backup successful."
else
  logger -t "$SCRIPT_NAME" -p user.err "Backup failed: Disk full."
fi

echo "Messages sent to system logs. Check with 'journalctl -t $SCRIPT_NAME'."

Verificação do tratamento de erros

Você escreveu um script Bash para processar alguns arquivos. Você quer que o script seja encerrado imediatamente se algum comando dentro dele falhar e também quer garantir que um diretório temporário seja limpo, independentemente de como o script terminar.

Quais dois comandos Bash você usaria principalmente para alcançar esse objetivo?

Recapitulação e próximos passos

Você aprendeu a tornar seus scripts Bash mais robustos e fáceis de depurar!

Códigos de saída: entenda o sucesso ou a falha dos comandos.
set -e: encerra automaticamente em caso de erro.
trap: realiza ações de limpeza quando o script termina.
Redirecionamento da saída: controle para onde stdout e stderr são enviados.
Marcas de tempo: adicione contexto aos seus registros.
logger: integre-se ao registro de todo o sistema.

Ao aplicar essas técnicas, suas tarefas automatizadas serão mais confiáveis e fáceis de gerenciar. Continue praticando para criar uma automação realmente resiliente!

Perguntas Frequentes

A aula “Tratamento de Erros e Geração de Registros em Scripts” é grátis?

Sim — o texto completo de “Tratamento de Erros e Geração de Registros em Scripts” é 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 Server Deployment & SSH Mastery, atualize para CoddyKit PRO. O curso de Linux Server Deployment & SSH Mastery inclui 4 aulas no total.

O que vou aprender em “Tratamento de Erros e Geração de Registros em Scripts”?

Implemente um tratamento robusto de erros, redirecione a saída dos scripts e gere registros significativos para monitorar a execução e solucionar problemas. Você pratica Linux Server Deployment & SSH 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 Server Deployment & SSH Mastery?

Nenhuma experiência prévia é necessária. Linux Server Deployment & SSH 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 3 de 4.

Quanto tempo leva a aula “Tratamento de Erros e Geração de Registros em Scripts”?

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 Server Deployment & SSH Mastery?

Sim. Cada aula de Linux Server Deployment & SSH 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

Introdução à Programação com Bash
Automação de Tarefas do Servidor
Tratamento de Erros e Geração de Registros em Scripts
Funções, Argumentos e Scripts Reutilizáveis

← Voltar para Linux Server Deployment & SSH Mastery