Shell scripting com Bash: automatizando tarefas do dia a dia

1. Fundamentos do Bash scripting

Todo script Bash começa com uma estrutura mínima essencial. O shebang (#!/bin/bash) indica qual interpretador será usado. Após criar o arquivo, é necessário torná-lo executável com chmod +x script.sh. Um cabeçalho com descrição, autor e data ajuda na manutenção futura.

#!/bin/bash
# Script: hello.sh
# Autor: Exemplo
# Descrição: Primeiro script de demonstração

echo "Olá, mundo!"

Variáveis no Bash podem ser declaradas sem tipo. O escopo padrão é global dentro do script, mas é possível usar local dentro de funções. Variáveis de ambiente como $HOME, $USER e $PATH estão sempre disponíveis.

#!/bin/bash
nome="Maria"
echo "Olá, $nome!"
echo "Seu diretório home é: $HOME"

Entrada e saída padrão são gerenciadas com echo (saída simples), printf (formatação avançada) e read (entrada do usuário). Redirecionamentos como > (sobrescreve), >> (anexa) e | (pipe) são fundamentais.

#!/bin/bash
echo "Digite seu nome:"
read nome
echo "Bem-vindo, $nome" > saudacao.txt
echo "Conteúdo salvo em saudacao.txt"

2. Controle de fluxo e tomada de decisões

Condicionais usam if, elif e else com testes entre [ ] (POSIX) ou [[ ]] (Bash, mais robusto). Os operadores de comparação incluem -eq, -ne, -lt, -gt para números e =, != para strings.

#!/bin/bash
idade=18
if [[ $idade -ge 18 ]]; then
    echo "Maior de idade"
else
    echo "Menor de idade"
fi

Laços de repetição automatizam tarefas repetitivas. O for percorre listas, while executa enquanto condição for verdadeira e until executa até que a condição se torne verdadeira.

#!/bin/bash
# Exemplo de for
for arquivo in *.txt; do
    echo "Processando: $arquivo"
done

# Exemplo de while
contador=1
while [[ $contador -le 5 ]]; do
    echo "Contagem: $contador"
    ((contador++))
done

O case statement é ideal para múltiplas condições baseadas em um único valor.

#!/bin/bash
echo "Escolha uma opção: 1) Iniciar 2) Parar 3) Status"
read opcao
case $opcao in
    1) echo "Sistema iniciado" ;;
    2) echo "Sistema parado" ;;
    3) echo "Sistema em execução" ;;
    *) echo "Opção inválida" ;;
esac

3. Manipulação de arquivos e diretórios

Comandos como ls, cp, mv, rm, mkdir e find são usados dentro de scripts para gerenciar o sistema de arquivos. A verificação de existência usa operadores como -f (arquivo), -d (diretório), -r (leitura), -w (escrita) e -x (execução).

#!/bin/bash
diretorio="/tmp/backup"
if [[ -d $diretorio ]]; then
    echo "Diretório $diretorio já existe"
else
    mkdir -p "$diretorio"
    echo "Diretório $diretorio criado"
fi

arquivo="dados.txt"
if [[ -f $arquivo && -r $arquivo ]]; then
    echo "Arquivo $arquivo existe e pode ser lido"
fi

Leitura e escrita de arquivos podem ser feitas com cat, head, tail e redirecionamento.

#!/bin/bash
# Escrever em arquivo
echo "Linha 1" > log.txt
echo "Linha 2" >> log.txt

# Ler arquivo linha por linha
while IFS= read -r linha; do
    echo "Lido: $linha"
done < log.txt

# Últimas 5 linhas
tail -n 5 log.txt

4. Funções e modularização

Funções permitem organizar o código em blocos reutilizáveis. A sintaxe pode ser function nome() { } ou apenas nome() { }. Argumentos são acessados por $1, $2, etc.

#!/bin/bash
function saudacao() {
    local nome=$1
    echo "Olá, $nome!"
}

saudacao "Ana"
saudacao "Carlos"

O retorno de valores pode ser feito com return (apenas números 0-255), echo (para capturar saída) ou variáveis globais.

#!/bin/bash
function soma() {
    local resultado=$(( $1 + $2 ))
    echo $resultado
}

total=$(soma 10 20)
echo "Total: $total"

Para modularização, use source (ou .) para incluir bibliotecas de funções.

#!/bin/bash
# biblioteca.sh
function mensagem() {
    echo "Função da biblioteca: $1"
}

# script_principal.sh
source ./biblioteca.sh
mensagem "Teste de modularização"

5. Expressões regulares e processamento de texto

grep filtra linhas que correspondem a padrões, sed faz substituições e transformações, e awk é uma ferramenta poderosa para processamento de colunas.

#!/bin/bash
# grep: encontrar linhas com "erro"
grep "erro" /var/log/syslog

# sed: substituir "antigo" por "novo"
echo "texto antigo" | sed 's/antigo/novo/'

# awk: extrair segunda coluna
echo "João 30 Programador" | awk '{print $2}'

Expressões regulares básicas incluem âncoras (^ início, $ fim), classes ([0-9], [a-z]), quantificadores (*, +, ?) e grupos.

#!/bin/bash
# Validar formato de e-mail
email="usuario@exemplo.com"
if [[ $email =~ ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ ]]; then
    echo "E-mail válido"
fi

# Extrair IPs de um arquivo de log
grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' access.log

6. Automação de tarefas do dia a dia

Backup incremental de diretórios pode ser feito com rsync, verificando modificações.

#!/bin/bash
# backup_incremental.sh
origem="/home/usuario/documentos"
destino="/backup/documentos"
log="/var/log/backup.log"

echo "$(date): Iniciando backup" >> "$log"
rsync -av --delete "$origem" "$destino" >> "$log" 2>&1
echo "$(date): Backup concluído" >> "$log"

Monitoramento de logs com envio de alertas por e-mail.

#!/bin/bash
# monitor_log.sh
logfile="/var/log/syslog"
padrao="CRITICAL"
email="admin@exemplo.com"

if grep -q "$padrao" "$logfile"; then
    tail -n 20 "$logfile" | mail -s "Alerta: $padrao encontrado" "$email"
    echo "Alerta enviado para $email"
fi

Agendamento com cron permite executar scripts periodicamente. Adicione no crontab (crontab -e):

# Executar backup todos os dias às 2h
0 2 * * * /home/usuario/scripts/backup_incremental.sh

# Monitorar logs a cada hora
0 * * * * /home/usuario/scripts/monitor_log.sh

7. Depuração e boas práticas

Modo de depuração ajuda a encontrar erros. Use bash -x script.sh ou set -x dentro do script. set -e interrompe o script ao primeiro erro.

#!/bin/bash
set -x  # Ativa depuração
set -e  # Sai ao primeiro erro

echo "Iniciando processo"
comando_inexistente  # Isso interromperá o script
echo "Isso não será executado"

Tratamento de erros com trap captura sinais e exit codes indicam sucesso (0) ou falha (1-255).

#!/bin/bash
trap "echo 'Script interrompido'; exit 1" SIGINT SIGTERM

function validar_arg() {
    if [[ -z $1 ]]; then
        echo "Erro: Argumento obrigatório" >&2
        exit 1
    fi
}

validar_arg "$1"
echo "Argumento recebido: $1"

Boas práticas incluem comentários claros, nomes descritivos para variáveis e funções, indentação consistente e verificação de erros em cada operação crítica.

#!/bin/bash
# Script: processa_dados.sh
# Autor: Desenvolvedor
# Descrição: Processa arquivos CSV e gera relatório

# Configurações
DIR_ENTRADA="./dados"
DIR_SAIDA="./relatorios"

# Função para processar arquivo
processar_arquivo() {
    local arquivo=$1
    if [[ ! -f $arquivo ]]; then
        echo "Erro: Arquivo $arquivo não encontrado" >&2
        return 1
    fi
    # Processamento...
    echo "Processado: $arquivo"
}

# Programa principal
main() {
    mkdir -p "$DIR_SAIDA"
    for arquivo in "$DIR_ENTRADA"/*.csv; do
        processar_arquivo "$arquivo"
    done
}

main "$@"

Referências

GNU Bash Manual — Documentação oficial completa do Bash, incluindo sintaxe, variáveis e construções de script
Advanced Bash-Scripting Guide — Guia avançado com centenas de exemplos práticos de shell scripting
Bash Guide for Beginners — Tutorial introdutório cobrindo fundamentos do Bash scripting
ShellCheck — Ferramenta online de análise estática para identificar erros e más práticas em scripts shell
Greg's Wiki - Bash FAQ — Coletânea de perguntas frequentes e soluções para problemas comuns em Bash
Linuxize Bash Scripting Tutorial — Tutoriais práticos com exemplos de automação e scripts do dia a dia
Cron How-To — Página de manual do crontab com exemplos de agendamento de tarefas

Shell scripting com Bash: automatizando tarefas do dia a dia ✓