etecanos Entrar Abrir laboratório

Início › Artigos › Linha de Comando

Introdução ao shell script: automatize tarefas no Linux

Escreva seus primeiros shell scripts: shebang, variáveis, condições if, laços for, permissão de execução e boas práticas para automatizar tarefas no Linux.

Se você digita os mesmos cinco comandos toda manhã, um computador deveria fazer isso por você. É exatamente esse o propósito do shell script: um arquivo de texto com uma sequência de comandos que o sistema executa de uma vez, quantas vezes você quiser, sem esquecer nenhum passo e sem se cansar.

Neste artigo você vai escrever seus primeiros scripts em bash, o shell mais comum no Linux. Vai aprender a estrutura de um script, como usar variáveis, tomar decisões com if e repetir tarefas com for. Tudo se baseia nos comandos dos artigos anteriores: arquivos, pipes, permissões e serviços.

O que é um script

Um script é um arquivo de texto que contém comandos. Em vez de digitá-los um a um no terminal, você os escreve no arquivo, dá a ele permissão de execução e o roda. Isso traz benefícios claros:

  • Repetibilidade: o resultado é o mesmo a cada execução.
  • Velocidade: o que levaria minutos à mão leva segundos.
  • Documentação viva: o script registra exatamente o que foi feito.
  • Menos erros: não há comando esquecido ou digitado errado.

Backups, atualização de sistemas, limpeza de arquivos temporários, criação de vários usuários e verificação de serviços são tarefas que costumam virar scripts.

A anatomia de um script

Um script simples tem poucas partes, e cada uma tem uma função:

Anatomia de um script: a primeira linha com o shebang indica o interpretador, os comentários explicam o código, os comandos fazem o trabalho e a permissão de execução permite rodá-lo
Figura 1 — Anatomia de um script: a primeira linha com o shebang indica o interpretador, os comentários explicam o código, os comandos fazem o trabalho e a permissão de execução permite rodá-lo
#!/bin/bash
# backup.sh - copia a pasta de documentos para o backup
echo "Iniciando o backup..."
mkdir -p backup
cp -r documentos/* backup/
echo "Backup concluído."
  • A primeira linha, #!/bin/bash, é o shebang: ela informa ao sistema qual programa vai interpretar o arquivo.
  • As linhas que começam com # são comentários e servem para os humanos; o shell as ignora.
  • As demais linhas são comandos, executados de cima para baixo.

Para rodar, é preciso dar permissão de execução e chamar o arquivo, lembrando do que viu no artigo sobre permissões:

chmod +x backup.sh
./backup.sh

O ./ indica "neste diretório". Sem ele, o shell procuraria o programa nas pastas do PATH e diria que o comando não existe.

Variáveis: guardando valores

Uma variável é um nome que guarda um valor. Em bash, você atribui sem espaços ao redor do = e usa o valor com $:

#!/bin/bash
nome="Maria"
pasta="/home/maria/documentos"
echo "Olá, $nome!"
echo "Sua pasta é $pasta"

Algumas variáveis já existem no sistema, como $USER (quem está logado), $HOME (a pasta pessoal) e $PWD (a pasta atual). Há também variáveis especiais dentro de scripts:

VariávelSignificado
$1, $2...Os argumentos passados ao script
$#Quantos argumentos foram passados
$?O código de saída do último comando (0 = sucesso)
$(comando)O resultado de outro comando, para guardar em variável

Por exemplo, hoje=$(date +%F) guarda a data de hoje em uma variável, e cp arquivo.txt "backup-$hoje.txt" cria uma cópia com a data no nome.

Decisões com if

Scripts úteis tomam decisões. A estrutura if testa uma condição e escolhe o que fazer:

Fluxo de decisão: uma condição é testada, se for verdadeira o script executa um bloco, caso contrário executa outro, e depois segue em frente
Figura 2 — Fluxo de decisão: uma condição é testada, se for verdadeira o script executa um bloco, caso contrário executa outro, e depois segue em frente
#!/bin/bash
if [ -f "$1" ]; then
    echo "O arquivo $1 existe."
else
    echo "O arquivo $1 não foi encontrado."
fi

Os colchetes [ ] testam a condição, e os espaços dentro deles são obrigatórios. Os testes mais usados:

TesteVerdadeiro quando...
-f arquivoo arquivo existe e é comum
-d pastaa pasta existe
"$a" = "$b"os textos são iguais
$n -gt 10o número é maior que 10 (greater than)
$n -eq 0o número é igual a 0
-z "$texto"o texto está vazio

O if termina com fi (if ao contrário), uma curiosidade típica do shell.

Repetindo com for

O laço for executa um bloco para cada item de uma lista, e é a principal ferramenta para tratar vários arquivos ou usuários:

#!/bin/bash
for arquivo in *.txt; do
    echo "Copiando $arquivo..."
    cp "$arquivo" backup/
done
echo "Pronto."

Aqui o curinga *.txt gera a lista de todos os arquivos de texto da pasta, e o bloco entre do e done roda uma vez para cada um. Da mesma forma, for i in 1 2 3; do ...; done repete três vezes. Combinando for e if, você consegue, por exemplo, verificar uma lista de serviços e avisar quais estão parados.

O fluxo de um script do início ao fim

Ao executar um script, o shell lê o arquivo linha por linha, expande variáveis e curingas, executa cada comando e verifica o código de saída. Essa lógica pode ser resumida no fluxo abaixo:

Fluxo de execução de um script: o shell lê o arquivo, executa os comandos em ordem, testa condições, repete laços e termina devolvendo um código de saída
Figura 3 — Fluxo de execução de um script: o shell lê o arquivo, executa os comandos em ordem, testa condições, repete laços e termina devolvendo um código de saída

Perceba que cada comando devolve um código de saída: 0 significa sucesso, e qualquer outro valor indica erro. Você pode consultá-lo com $?, e é assim que scripts profissionais reagem a falhas, como em:

cp origem.txt destino.txt
if [ $? -ne 0 ]; then
    echo "Erro ao copiar o arquivo!"
    exit 1
fi

Boas práticas desde o primeiro script

  • Comente o objetivo do script e as partes não óbvias; você mesmo vai esquecer em um mês.
  • Coloque aspas em variáveis ("$arquivo"): sem elas, nomes com espaços quebram o script.
  • Teste em uma pasta de experimentos antes de apontar o script para dados reais, principalmente se ele usar rm.
  • Cuidado com rm -rf em scripts: uma variável vazia pode transformar rm -rf "$pasta/" em um desastre.
  • Use nomes claros para arquivos e variáveis (backup_diario.sh, e não x.sh).
  • Não coloque senhas dentro do script, pois qualquer pessoa com acesso de leitura as verá.
  • Verifique erros: use o código de saída para decidir se o script deve continuar.

Para depurar, bash -x script.sh mostra cada comando antes de executá-lo, o que revela exatamente onde algo saiu diferente do esperado.

Agendando o script

Um script ganha ainda mais valor quando roda sozinho. O cron é o serviço de agendamento: o comando crontab -e abre sua lista de tarefas agendadas, e cada linha tem cinco campos (minuto, hora, dia do mês, mês e dia da semana) seguidos do comando. Uma linha como 30 2 * * * /home/maria/backup.sh executa o backup todos os dias às 2h30 da manhã. Assim, a automação funciona sem ninguém presente, e é aí que a cautela com permissões e erros se torna realmente importante.

Do script ao hábito profissional

Um script bom é pequeno, faz uma coisa e a faz bem. Em vez de escrever um arquivo gigante, divida o trabalho em scripts curtos que podem ser combinados com pipes e chamados uns pelos outros. Guarde seus scripts em uma pasta própria (por exemplo, ~/scripts), mantenha-os sob controle de versão quando crescerem e documente no próprio cabeçalho o que cada um espera receber. Esse cuidado transforma uma gambiarra do momento em uma ferramenta que outras pessoas conseguem usar.

Pratique no laboratório

No Pinguim Linux, crie e execute um script de verificação:

nano ola.sh

Dentro do arquivo, escreva:

#!/bin/bash
echo "Usuário: $USER"
echo "Pasta: $PWD"
for i in 1 2 3; do
    echo "Contagem $i"
done

Depois, salve, e execute:

chmod +x ola.sh
./ola.sh

Experimente remover o chmod para ver o erro "Permission denied", depois acrescente um if [ -d "backup" ] que cria a pasta apenas quando ela não existe.

Resumo

  • Um shell script é um arquivo de texto com comandos que o sistema executa em sequência, trazendo repetibilidade e menos erros.
  • Todo script começa com o shebang (#!/bin/bash) e precisa de permissão de execução (chmod +x).
  • Variáveis guardam valores (nome="x", usadas como $nome); $1 e $# tratam argumentos e $? traz o código de saída.
  • if [ condição ]; then ... fi toma decisões, e for ... do ... done repete tarefas.
  • Use aspas, comente, teste em uma pasta segura e tenha muito cuidado com rm em scripts.

Referências

  1. GNU Project. Bash Reference Manual. Disponível em: https://www.gnu.org/software/bash/manual/.
  2. COOPER, M. Advanced Bash-Scripting Guide. Disponível em: https://tldp.org/LDP/abs/html/.
  3. NEWHAM, C.; ROSENBLATT, B. Learning the bash Shell. 3. ed. Sebastopol: O'Reilly, 2005. Disponível em: https://www.oreilly.com/.

Teste seus conhecimentos

1. Qual é a função da primeira linha #!/bin/bash de um script?

Não é essa. Ela se parece com um comentário, mas tem função especial.

Correto. O shebang aponta o programa que lê o script.

Não é essa. A permissão é dada com chmod.

Não é essa. O shebang não cria variáveis.

2. Como se atribui corretamente um valor a uma variável em bash?

Não é essa. Espaços ao redor do = causam erro.

Correto. A atribuição não leva espaços ao redor do =.

Não é essa. O $ é usado apenas para ler o valor.

Não é essa. Essa não é a sintaxe de atribuição do bash.

3. O que significa o código de saída 0 de um comando, consultado em $??

Não é essa. Erros têm valores diferentes de zero.

Correto. Zero indica sucesso.

Não é essa. Ele foi executado e terminou.

Não é essa. O código de saída não trata de variáveis.

4. Por que colocar variáveis entre aspas, como em "$arquivo", é uma boa prática?

Não é essa. Não há ganho de velocidade.

Correto. As aspas preservam o valor como um único item.

Não é essa. Não são obrigatórias em todos os casos.

Não é essa. As aspas não alteram a variável.

Para refletir

  1. Que tarefa repetitiva do seu dia a dia poderia virar um script? Quais comandos ela teria?
  2. Por que um rm -rf dentro de um script exige mais cuidado do que no terminal?

Continue estudando