0Pricing
DevOps Bootcamp · Aula

Projeto de Scripting Avançado

Desenvolva um projeto abrangente que integre todos os conceitos aprendidos, desde ferramentas de linha de comando até técnicas avançadas de scripting Bash.

Projeto de Scripting Avançado é uma aula grátis de DevOps Bootcamp 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 DevOps Bootcamp, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de DevOps Bootcamp inclui 4 aulas no total.

Início do projeto: o desafio

Bem-vindo ao nosso projeto final! Ao longo deste curso, você aprendeu muitos comandos poderosos do Linux e técnicas de criação de scripts Bash. Agora é hora de reunir tudo isso.

Nesta lição, criaremos do zero um script Bash prático e avançado. Este projeto desafiará você a integrar tudo o que aprendeu em uma única solução funcional.

Definindo o objetivo do nosso projeto

Nosso objetivo é criar um script de monitoramento e arquivamento de arquivos. Imagine que você tenha um servidor que gera arquivos de registro e precise processá-los regularmente sem intervenção manual.

Veja o que nosso script fará:

  • Monitorar continuamente um diretório específico em busca de novos arquivos de texto.
  • Processar cada novo arquivo (por exemplo, contar suas linhas).
  • Mover o arquivo processado para um diretório de arquivo morto.
  • Registrar todas as atividades, incluindo marcas de data e hora e quaisquer erros.

Fundamentos do script: Shebang e variáveis

Todo bom script começa com uma base clara. Começaremos definindo o shebang e configurando as principais variáveis. Essas variáveis tornarão nosso script flexível e fácil de configurar.

Definiremos os caminhos do diretório de monitoramento, do diretório de arquivo morto e de um arquivo de registro.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

Garantindo a existência dos diretórios

Antes que nosso script possa monitorar ou arquivar, precisamos garantir que os diretórios necessários existam. Usar mkdir -p é fundamental aqui, pois o comando cria os diretórios somente se eles ainda não existirem e não gera um erro se eles já existirem.

Também adicionaremos um tratamento básico de erros para sair de maneira segura caso a criação do diretório falhe.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

O loop de monitoramento

Nosso script precisa ser executado continuamente para monitorar novos arquivos. Um loop while true é perfeito para isso. Dentro do loop, usaremos sleep para pausar por alguns segundos entre as verificações, evitando que ele consuma recursos em excesso.

Também registraremos cada verificação para acompanhar a atividade.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

# --- Main Monitoring Loop ---
while true; do
  echo "$(date): Checking for new files in $MONITOR_DIR..." >> "$LOG_FILE"
  # File processing will go here
  sleep 5 # Check every 5 seconds
done

Encontrar e processar arquivos

Dentro do nosso loop, precisamos encontrar novos arquivos de texto. O comando find é ideal para isso, combinado com um loop for para processar cada arquivo encontrado. Usaremos wc -l para contar as linhas de cada arquivo como etapa de processamento.

Isso demonstra como combinar ferramentas de linha de comando em um script.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

# --- Main Monitoring Loop ---
while true; do
  echo "$(date): Checking for new files in $MONITOR_DIR..." >> "$LOG_FILE"
  # Find new .txt files and process them
  for file in $(find "$MONITOR_DIR" -maxdepth 1 -type f -name "*.txt"); do
    if [ -f "$file" ]; then # Double-check if it's a regular file
      LINE_COUNT=$(wc -l < "$file")
      echo "$(date): Found '$file'. Lines: $LINE_COUNT." >> "$LOG_FILE"
      # Archiving will go here
    fi
  done
  sleep 5 # Check every 5 seconds
done

Arquivar arquivos processados

Depois de processar um arquivo, precisamos movê-lo para o diretório de arquivo. O comando mv é usado para isso. Também adicionaremos uma instrução if para verificar o status de saída de mv, garantindo que a movimentação foi bem-sucedida e registrando eventuais falhas.

Isso torna nosso script mais robusto.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

# --- Main Monitoring Loop ---
while true; do
  echo "$(date): Checking for new files in $MONITOR_DIR..." >> "$LOG_FILE"
  for file in $(find "$MONITOR_DIR" -maxdepth 1 -type f -name "*.txt"); do
    if [ -f "$file" ]; then
      LINE_COUNT=$(wc -l < "$file")
      echo "$(date): Found '$file'. Lines: $LINE_COUNT." >> "$LOG_FILE"
      
      mv "$file" "$ARCHIVE_DIR/"
      if [ $? -eq 0 ]; then
        echo "$(date): Moved '$file' to '$ARCHIVE_DIR'." >> "$LOG_FILE"
      else
        echo "$(date): ERROR: Failed to move '$file' to '$ARCHIVE_DIR'." >> "$LOG_FILE"
      fi
    fi
  done
  sleep 5
done

Adicionar saída controlada com trap

Um script de longa execução precisa de uma maneira de ser encerrado de forma controlada. O comando trap permite capturar sinais, como SIGINT (acionado por Ctrl+C), e executar uma função de limpeza antes de sair. Isso garante que nosso script registre seu encerramento.

Esta é uma etapa fundamental para scripts prontos para produção.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# --- Functions ---
cleanup() {
  echo "$(date): Script received stop signal. Exiting gracefully." >> "$LOG_FILE"
  exit 0 # Exit with success status
}

# --- Trap Signals ---
# Trap SIGINT (Ctrl+C) and call the cleanup function
trap cleanup SIGINT

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

# --- Main Monitoring Loop ---
while true; do
  echo "$(date): Checking for new files in $MONITOR_DIR..." >> "$LOG_FILE"
  for file in $(find "$MONITOR_DIR" -maxdepth 1 -type f -name "*.txt"); do
    if [ -f "$file" ]; then
      LINE_COUNT=$(wc -l < "$file")
      echo "$(date): Found '$file'. Lines: $LINE_COUNT." >> "$LOG_FILE"
      
      mv "$file" "$ARCHIVE_DIR/"
      if [ $? -eq 0 ]; then
        echo "$(date): Moved '$file' to '$ARCHIVE_DIR'." >> "$LOG_FILE"
      else
        echo "$(date): ERROR: Failed to move '$file' to '$ARCHIVE_DIR'." >> "$LOG_FILE"
      fi
    fi
  done
  sleep 5
done

Testar seu script avançado

Agora que nosso script está completo, é hora de testá-lo! Normalmente, você o executaria em segundo plano (por exemplo, ./monitor.sh &), depois criaria arquivos de teste em $MONITOR_DIR e observaria $LOG_FILE e $ARCHIVE_DIR.

Aqui está um pequeno script que você pode executar para criar facilmente um arquivo de teste para o seu monitor.

#!/bin/bash
# create_test_file.sh

MONITOR_DIR="/tmp/coddykit_monitor"
mkdir -p "$MONITOR_DIR" # Ensure dir exists for this test script

# Create a unique test file
TEST_FILE="$MONITOR_DIR/test_log_$(date +%Y%m%d_%H%M%S).txt"
echo "This is a test entry." > "$TEST_FILE"
echo "Another line for testing." >> "$TEST_FILE"
echo "Created new test file: $TEST_FILE"

Revisão da lógica do script

Nosso script avançado combina muitos conceitos. Vamos revisar rapidamente alguns dos principais comandos e estruturas que usamos.

Pense no papel que cada comando desempenha para alcançar o objetivo do nosso projeto.

Além do básico: agendamento e personalização

Este script foi projetado para ser executado continuamente. Em um cenário real, você poderia executá-lo em segundo plano usando nohup ./script.sh & ou, mais comumente, agendá-lo para ser executado periodicamente usando o Cron.

Lembre-se: o Cron é perfeito para automatizar tarefas como esta. Você poderia agendá-lo para ser executado a cada poucos minutos, verificando o diretório e processando os arquivos conforme necessário.

Considere personalizá-lo para:

  • Processar diferentes tipos de arquivo.
  • Executar ações diferentes (por exemplo, compactar arquivos ou enviá-los para a nuvem).
  • Adicionar relatórios de erros mais avançados (por exemplo, alertas por e-mail).

Recapitulação do projeto e próximos passos

Parabéns! Você acaba de concluir um projeto avançado de scripts Bash, integrando uma ampla variedade de comandos do Linux e técnicas de script.

Você aprendeu a:

  • Estruturar um script robusto e de longa execução.
  • Usar variáveis para configuração.
  • Implementar loops para monitoramento contínuo.
  • Combinar comandos como find, wc e mv.
  • Adicionar tratamento de erros e saídas controladas com trap.

Este projeto é uma base sólida para criar soluções de automação mais complexas. Continue experimentando e criando!

Perguntas Frequentes

A aula “Projeto de Scripting Avançado” é grátis?

Sim — o texto completo de “Projeto de Scripting Avançado” é 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 DevOps Bootcamp, atualize para CoddyKit PRO. O curso de DevOps Bootcamp inclui 4 aulas no total.

O que vou aprender em “Projeto de Scripting Avançado”?

Desenvolva um projeto abrangente que integre todos os conceitos aprendidos, desde ferramentas de linha de comando até técnicas avançadas de scripting Bash. Você pratica DevOps Bootcamp 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 DevOps Bootcamp?

Nenhuma experiência prévia é necessária. DevOps Bootcamp 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 “Projeto de Scripting Avançado”?

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 DevOps Bootcamp?

Sim. Cada aula de DevOps Bootcamp 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. Agendamento de Tarefas com Cron
  2. Automação da Administração do Sistema
  3. Projeto de Scripting Avançado
  4. Rotação e Limpeza Automatizadas de Registos
← Voltar para DevOps Bootcamp