Shell scripts e automação

Transforme tarefas repetidas em scripts Bash seguros, agende com cron e saiba quando a tarefa pede Python.

Cerca de 16 min · Revisado em

Ao final, você vai conseguir

  • Escrever um script Bash com shebang, variáveis, argumentos, if e for
  • Usar códigos de saída e set -euo pipefail para que falhas não passem despercebidas
  • Reconhecer comandos idempotentes e agendar um script com cron
  • Decidir entre Bash e Python e automatizar em Python a contagem de status num log

Toda manhã, alguém na equipe confere se o disco não encheu, se o site responde e quantos erros apareceram no log. Feito à mão, são dez minutos por dia, e no dia corrido alguém esquece. Um script faz a mesma conferência em um segundo, toda vez do mesmo jeito, até de madrugada, e avisa quando algo está errado. É a primeira automação de quase toda pessoa que trabalha com operação.

Um script é uma receita escrita

Os comandos que você aprendeu na aula Linux e terminal podem ir para um arquivo. O programa que lê e executa esses comandos se chama shell, e o mais comum em servidores é o Bash. Um arquivo de comandos Bash costuma terminar em .sh.

O arquivo bom-dia.sh: a conferência da manhã em seis linhas

#!/usr/bin/env bash
echo "== Disco =="
df -h /
echo "== Site =="
systemctl is-active nginx
echo "== Erros no log =="
grep -c ERROR /var/log/loja/app.log

Rodando o primeiro script

O arquivo bom-dia.sh já está na pasta scripts. Torne-o executável e rode.

  1. Mostre o conteúdo do script na tela antes de rodar. Nunca execute algo sem ler.

    cat bom-dia.sh
    #!/usr/bin/env bash
    echo "== Disco =="
    df -h /
    echo "== Site =="
    systemctl is-active nginx
    echo "== Erros no log =="
    grep -c ERROR /var/log/loja/app.log
  2. Dê permissão de execução ao arquivo.

    chmod +x bom-dia.sh
  3. Execute o script.

    ./bom-dia.sh
    == Disco ==
    Filesystem      Size  Used Avail Use% Mounted on
    /dev/sda1        40G   31G  9.0G  78% /
    == Site ==
    active
    == Erros no log ==
    4

Qual é a maior vantagem de transformar a conferência da manhã num script?

  • Ela passa a ser feita sempre do mesmo jeito, por qualquer pessoa ou por um agendador
  • Os comandos ficam mais poderosos dentro de um script
  • Scripts não precisam de permissão para rodar

A anatomia de um script de verdade

O script da manhã só mostra informações. Um script de operação de verdade toma decisões: tenta de novo, avisa quando falha e termina com um sinal claro de sucesso ou erro. Explore cada parte deste verificador de serviço.

checa-servico.sh: testa uma URL até três vezes e avisa se ela não responde

#!/usr/bin/env bash
set -euo pipefail

URL="${1:-http://localhost:8000/saude}"
TENTATIVAS=3

for i in $(seq 1 "$TENTATIVAS"); do
  if curl -fsS --max-time 5 "$URL" > /dev/null; then
    echo "OK: $URL respondeu na tentativa $i"
    exit 0
  fi
  echo "AVISO: tentativa $i falhou" >&2
  sleep 2
done

echo "ERRO: $URL fora do ar" >&2
exit 1
  • Shebang: A primeira linha diz qual programa deve ler o arquivo. Sem ela, o sistema pode tentar ler o script com outro shell e falhar de jeitos estranhos.
  • Modo seguro: -e para o script no primeiro comando que falhar. -u trata variável não definida como erro, em vez de usar texto vazio. -o pipefail faz um pipe falhar se qualquer pedaço dele falhar.
  • Variável e argumento: $1 é o primeiro argumento passado ao script, como em ./checa-servico.sh https://site. O :- define um valor padrão se nada for passado. Repare: sem espaços em volta do =.
  • Repetição: for repete o bloco até o done, com i valendo 1, 2 e 3. $(...) roda um comando e usa a saída dele no lugar.
  • Decisão: O if não testa texto: ele roda o comando e olha se deu certo. O -f faz o curl falhar em respostas de erro HTTP. > /dev/null joga fora a página, porque só importa se respondeu.
  • Código de saída: Encerra o script avisando “deu certo”. Zero significa sucesso.
  • Saída de erro: >&2 manda a mensagem para a saída de erros, separada da saída normal. Assim, quem guarda o log consegue separar avisos de resultados.
  • Falha: Qualquer número diferente de zero significa erro. É isso que permite a outros programas, como o cron ou uma pipeline, perceber que algo deu errado.

Complete o script que conta erros em cada arquivo .log de uma pasta recebida como argumento.

#!/usr/bin/env bash
____ -euo pipefail

# Primeiro argumento do script, ou uma pasta padrão
PASTA="${____:-/var/log/loja}"

for arquivo in "$PASTA"/*.log; ____
  total=$(grep -c ERROR "$arquivo" || true)
  if [ "$total" -gt 0 ]; ____
    echo "$arquivo: $total erros"
  fi
____

Códigos de saída e scripts que podem rodar de novo

Todo comando, ao terminar, devolve um número chamado código de saída (exit code). Zero quer dizer sucesso; qualquer outro número quer dizer algum tipo de falha. A variável especial $? guarda o código do último comando.

Ouvindo o que os comandos respondem

Veja os códigos de saída de comandos que dão certo e errado, e depois do seu verificador.

  1. Liste uma pasta que não existe: /etc/naoexiste.

    ls /etc/naoexiste
    ls: cannot access '/etc/naoexiste': No such file or directory
  2. Mostre o código de saída do último comando.

    echo $?
    2
  3. Rode o verificador sem argumentos, para testar a URL padrão.

    ./checa-servico.sh
    OK: http://localhost:8000/saude respondeu na tentativa 1
  4. Confira o código de saída.

    echo $?
    0
  5. Agora teste uma porta onde não há nada: passe http://localhost:9999/saude como argumento.

    ./checa-servico.sh http://localhost:9999/saude
    curl: (7) Failed to connect to localhost port 9999 after 0 ms: Couldn't connect to server
    AVISO: tentativa 1 falhou
    curl: (7) Failed to connect to localhost port 9999 after 0 ms: Couldn't connect to server
    AVISO: tentativa 2 falhou
    curl: (7) Failed to connect to localhost port 9999 after 0 ms: Couldn't connect to server
    AVISO: tentativa 3 falhou
    ERRO: http://localhost:9999/saude fora do ar
  6. E o código de saída agora?

    echo $?
    1

Esse número é a ponte entre programas. comando1 && comando2 roda o segundo só se o primeiro deu certo; comando1 || comando2 roda o segundo só se o primeiro falhou. Assim nasce um alerta simples: ./checa-servico.sh || ./avisa-equipe.sh.

Um script tem set -e mas não tem pipefail. A linha grep ERROR app.log | wc -l roda e o arquivo app.log não existe. O que acontece?

  • O script continua, porque o pipe devolve o código do último comando, o wc, que deu certo
  • O script para, porque o set -e vê qualquer falha
  • O Bash cria o arquivo app.log vazio

Rodar cada linha duas vezes seguidas é seguro?

Idempotente: pode repetir · Não idempotente: a segunda vez falha ou duplica

  • mkdir -p /srv/loja/backups
  • mkdir /srv/loja/backups
  • cp config.padrao /etc/loja.conf
  • echo "export AMBIENTE=prod" >> ~/.bashrc
  • id deploy || sudo useradd deploy
  • sudo useradd deploy

Agendando com cron

Uma linha de agendamento do cron (o crontab)

*/5 * * * * /home/ana/scripts/checa-servico.sh >> /home/ana/logs/checa.log 2>&1
  • Minuto: De 0 a 59. */5 quer dizer “a cada 5 minutos”.
  • Hora: De 0 a 23. O * quer dizer “todas”.
  • Dia do mês: De 1 a 31.
  • Mês: De 1 a 12.
  • Dia da semana: De 0 a 6, começando no domingo. 1-5 seria de segunda a sexta.
  • Comando: Use sempre o caminho absoluto. O cron não começa na sua pasta e não conhece os atalhos do seu terminal.
  • Registro: Acrescenta a saída normal num log, e o 2>&1 junta a saída de erros no mesmo lugar. Sem isso, você nunca saberá o que aconteceu.
Expressões de cron comuns
ExpressãoQuando roda
*/5 * * * *A cada 5 minutos
0 3 * * *Todo dia às 3h da manhã
30 8 * * 1-5De segunda a sexta, às 8h30
0 0 1 * *À meia-noite do primeiro dia de cada mês

Agendando o verificador

Faça o verificador rodar sozinho a cada 5 minutos.

  1. Veja se você já tem algum agendamento.

    crontab -l
    no crontab for ana
  2. Abra a sua tabela de agendamentos para editar.

    crontab -e
    (o editor abriu; você colou a linha abaixo, salvou e fechou)
    */5 * * * * /home/ana/scripts/checa-servico.sh >> /home/ana/logs/checa.log 2>&1
    crontab: installing new crontab
  3. Confirme que o agendamento foi salvo.

    crontab -l
    */5 * * * * /home/ana/scripts/checa-servico.sh >> /home/ana/logs/checa.log 2>&1
  4. Dez minutos depois: veja as últimas linhas do log do verificador.

    tail /home/ana/logs/checa.log
    OK: http://localhost:8000/saude respondeu na tentativa 1
    OK: http://localhost:8000/saude respondeu na tentativa 1

Quando roda a linha 0 3 * * 1 /opt/backup.sh?

  • Toda segunda-feira, às 3h da manhã
  • Todo dia, às 3 minutos depois da 1h
  • No dia 3 de cada mês, à 1h
  • A cada 3 horas, às segundas

Quando trocar o Bash pelo Python

Bash é ótimo para encadear comandos. Mas quando o script precisa entender texto com estrutura, fazer contas, ler JSON, chamar uma API ou tratar vários tipos de erro, ele vira um emaranhado difícil de ler. Nesse ponto, Python costuma ser a escolha: está instalado na maioria dos servidores Linux e lê quase como português.

Um jeito prático de decidir
Use Bash quando...Prefira Python quando...
A tarefa é rodar comandos em sequênciaHá lógica com muitas decisões e contas
O script cabe numa telaO script passa de umas 50 linhas
Você junta grep, tail, curl com pipesPrecisa ler JSON, CSV ou chamar uma API
Erros só precisam parar o scriptCada erro pede um tratamento diferente

A mesma tarefa, contar respostas por status num log de servidor web, nas duas linguagens

Bash

# O status é o 9º campo de cada linha
awk '{print $9}' access.log | sort | uniq -c

Python

from collections import Counter

with open('access.log') as arquivo:
    status = [linha.split()[-2] for linha in arquivo if linha.strip()]

for codigo, total in sorted(Counter(status).items()):
    print(codigo, total)

A versão em Bash é curtíssima, mas quebra fácil se o formato da linha mudar e é difícil de estender. A versão em Python é mais longa e muito mais fácil de evoluir: dá para somar erros, calcular porcentagens e decidir se manda alerta. Em scripts maiores, o módulo subprocess roda comandos do sistema e o urllib.request faz requisições HTTP, ambos sem instalar nada.

Um alerta a partir do log

O texto LOG imita um log de servidor web. Complete o programa: pegue o status de cada linha (o penúltimo pedaço), conte quantas vezes cada status aparece no dicionário contagem, some em erros_5xx as respostas que começam com 5, imprima uma linha Status 200: 3 para cada status e, se mais de 10% das requisições forem erros 5xx, imprima uma linha começando com ALERTA.

LOG = """203.0.113.5 - - [14/Oct/2026:10:00:01 -0300] "GET /api/pedidos HTTP/1.1" 200 512
198.51.100.7 - - [14/Oct/2026:10:00:02 -0300] "POST /api/pix HTTP/1.1" 201 87
203.0.113.5 - - [14/Oct/2026:10:00:04 -0300] "GET /api/cardapio HTTP/1.1" 200 2048
192.0.2.10 - - [14/Oct/2026:10:00:05 -0300] "GET /favicon.ico HTTP/1.1" 404 0
198.51.100.7 - - [14/Oct/2026:10:00:07 -0300] "POST /api/pix HTTP/1.1" 502 0
203.0.113.9 - - [14/Oct/2026:10:00:08 -0300] "GET /api/pedidos HTTP/1.1" 200 498
192.0.2.10 - - [14/Oct/2026:10:00:09 -0300] "POST /api/pix HTTP/1.1" 503 0
203.0.113.5 - - [14/Oct/2026:10:00:11 -0300] "GET /api/pedidos HTTP/1.1" 500 0

"""

contagem = {}
for linha in LOG.splitlines():
    if not linha.strip():
        continue  # pula linhas vazias
    partes = linha.split()
    status = ""  # troque por: o penúltimo item de partes
    # some 1 em contagem[status]; dica: contagem.get(status, 0)

erros_5xx = 0  # some as contagens dos status que começam com "5"
total = sum(contagem.values())

print(contagem)
  • A contagem tem 3 respostas 200 e 1 resposta 404
  • As 8 requisições foram contadas, sem a linha vazia
  • erros_5xx soma os 3 erros de servidor
  • Imprime a linha Status 200: 3
  • Imprime um ALERTA, porque mais de 10% foram erros 5xx

Fechamento

  • Um script é um arquivo de comandos executados em sequência; começa com o shebang e precisa de permissão de execução.
  • Variáveis se criam sem espaços em volta do =, $1 é o primeiro argumento e if e for decidem e repetem.
  • Todo comando devolve um código de saída: 0 é sucesso; set -euo pipefail faz o script parar na primeira falha em vez de seguir às cegas.
  • Scripts de automação devem ser idempotentes, e o cron os executa nos horários definidos, com caminhos absolutos e saída guardada em log.
  • Quando a lógica cresce, com contas, JSON ou muitos tipos de erro, Python é mais fácil de ler e evoluir do que Bash.

Automatize a checagem de um serviço

A prática desta etapa da trilha é automatizar uma checagem de serviço, produzir logs úteis e devolver um código de erro quando a verificação falhar. Faça no seu laboratório Linux ou no WSL.

  1. Escreva um checa-servico.sh com shebang, set -euo pipefail, a URL em $1 com valor padrão e três tentativas
  2. Faça o script imprimir data, hora e resultado de cada tentativa, e terminar com exit 0 ou exit 1
  3. Teste com um serviço de pé (python3 -m http.server 8000) e parado, conferindo echo $? nos dois casos
  4. Agende o script no cron a cada 5 minutos, guardando a saída num log com >> arquivo.log 2>&1
  5. Rode o script duas vezes seguidas e confirme que nada é duplicado nem quebra na segunda vez

Referências

Cursos relacionados