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:
#!/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ável | Significado |
|---|---|
$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:
#!/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:
| Teste | Verdadeiro quando... |
|---|---|
-f arquivo | o arquivo existe e é comum |
-d pasta | a pasta existe |
"$a" = "$b" | os textos são iguais |
$n -gt 10 | o número é maior que 10 (greater than) |
$n -eq 0 | o 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:
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 -rfem scripts: uma variável vazia pode transformarrm -rf "$pasta/"em um desastre. - Use nomes claros para arquivos e variáveis (
backup_diario.sh, e nãox.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);$1e$#tratam argumentos e$?traz o código de saída. if [ condição ]; then ... fitoma decisões, efor ... do ... donerepete tarefas.- Use aspas, comente, teste em uma pasta segura e tenha muito cuidado com
rmem scripts.
Referências
- GNU Project. Bash Reference Manual. Disponível em: https://www.gnu.org/software/bash/manual/.
- COOPER, M. Advanced Bash-Scripting Guide. Disponível em: https://tldp.org/LDP/abs/html/.
- NEWHAM, C.; ROSENBLATT, B. Learning the bash Shell. 3. ed. Sebastopol: O'Reilly, 2005. Disponível em: https://www.oreilly.com/.
Teste seus conhecimentos
Para refletir
- Que tarefa repetitiva do seu dia a dia poderia virar um script? Quais comandos ela teria?
- Por que um
rm -rfdentro de um script exige mais cuidado do que no terminal?