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

No mundo da computação, a automação é uma ferramenta poderosa que pode economizar tempo e reduzir erros. O shell script é uma forma de programação que permite aos usuários do Linux criar scripts para automatizar tarefas repetitivas diretamente no terminal. Desde a realização de backups até a execução de comandos em lote, os scripts podem simplificar processos que, de outra forma, exigiriam intervenções manuais constantes.

Neste artigo, vamos explorar os conceitos básicos do shell script, aprender como criar nosso primeiro script e descobrir como utilizá-lo para automatizar tarefas cotidianas no Linux. Se você está começando sua jornada no mundo da programação ou simplesmente quer tornar seu trabalho mais eficiente, o shell script pode ser a chave para otimizar sua rotina.

O que é shell script?

O shell script é um arquivo de texto que contém uma sequência de comandos do shell, que podem ser executados em um terminal do Linux. Basicamente, é uma forma de programar para automatizar tarefas repetitivas, facilitando a execução de comandos e a manipulação de arquivos sem a necessidade de digitá-los manualmente toda vez.

O shell, que é o interpretador de comandos, fornece uma interface entre o usuário e o sistema operacional. O shell script utiliza a linguagem de programação do shell, permitindo que você escreva scripts que podem incluir comandos, condicionais, loops e funções. Isso o torna uma ferramenta poderosa para administrar sistemas, gerenciar arquivos e realizar tarefas de manutenção.

Os scripts são frequentemente utilizados para:

• Automatizar tarefas rotineiras: Como backups, atualizações e monitoramento de sistemas.
• Executar comandos em lote: Permite a execução de múltiplos comandos em um único arquivo, economizando tempo e reduzindo a chance de erros.
• Criar programas simples: Para facilitar o trabalho com o sistema operacional.

Existem diferentes tipos de shells, como bash (Bourne Again SHell), zsh (Z Shell) e ksh (Korn Shell), mas o bash é o mais utilizado e o padrão em muitas distribuições Linux. Cada shell tem suas peculiaridades, mas a maioria dos comandos básicos é semelhante.

Criando o seu primeiro shell script

Agora que você já sabe o que é um shell script, vamos criar o seu primeiro script simples, apenas para que você entenda sua sintaxe e execução. Neste exemplo, vamos criar um script que exibe uma mensagem na tela. Siga os passos abaixo:

1. Abra o Terminal:

No Linux, você pode abrir o terminal a partir do menu de aplicativos ou usando um atalho de teclado (geralmente Ctrl + Alt + T).

2. Crie um novo arquivo

Utilize um editor de texto como o nano ou vim para criar um novo arquivo. Se preferir outro editor, fique à vontade para usá-lo, mas lembre-se de que continuaremos a trabalhar no terminal. Neste exemplo, vamos utilizar o nano. Execute o seguinte comando:

nano meu_primeiro_script.sh

3. Escreva o script

No editor, digite as seguintes linhas:

#!/bin/bash
echo "Olá, mundo! Este é o meu primeiro shell script."

A primeira linha (#!/bin/bash) é chamada de “shebang” e informa ao sistema que este script deve ser executado usando o interpretador bash. A segunda linha usa o comando echo para exibir uma mensagem na tela.

4. Salve o arquivo

No nano, você pode salvar o arquivo pressionando Ctrl + O, depois Enter para confirmar. Para sair do editor, pressione Ctrl + X.

5. Torne o script executável

Antes de executar o script, você precisa torná-lo executável. Execute o seguinte comando no terminal:

chmod +x meu_primeiro_script.sh

6. Execute o script

Agora você pode executar seu script com o comando:

./meu_primeiro_script.sh

Você verá a mensagem “Olá, mundo! Este é o meu primeiro shell script.” exibida no terminal.

Esse exemplo simples serve para ilustrar os fundamentos do shell script, permitindo que você comece a explorar mais funcionalidades à medida que avança.

Comandos essenciais para automação

Para aproveitar ao máximo o shell script e automatizar tarefas de forma eficaz, é importante conhecer alguns comandos essenciais do terminal. A seguir, apresentamos uma lista de comandos frequentemente utilizados em scripts, acompanhados de uma breve descrição de suas funcionalidades:

1. echo

Exibe uma mensagem ou o valor de uma variável no terminal. É muito útil para gerar saída de informações em scripts.

echo "Mensagem de exemplo"

2. ls

Lista arquivos e diretórios em um diretório especificado. Pode ser usado com várias opções para personalizar a exibição, como ls -l (listagem detalhada).

ls -l

3. cd

Muda o diretório atual. Essencial para navegar pelo sistema de arquivos.

cd /caminho/para/diretorio

4. cp

Copia arquivos e diretórios. Use -r para copiar diretórios recursivamente.

cp arquivo.txt /caminho/para/destino/

5. mv

Move ou renomeia arquivos e diretórios. O uso de mv é semelhante ao de cp, mas a operação é feita com a remoção do original.

mv arquivo.txt /caminho/para/destino/

Caso, queira usar o mv para renomear um arquivo:

mv arquivo.txt novo-nome.txt

6. rm

Remove arquivos ou diretórios. Use com cuidado, pois arquivos excluídos não podem ser recuperados facilmente. O parâmetro -r é necessário para remover diretórios. Atenção: Cuidado com o uso desse comando, o comando rm não envia arquivos para a lixeira do sistema, ele remove definitivamente, use com cautela.

rm arquivo.txt

7. mkdir

Cria um novo diretório. Útil para organizar arquivos e estruturas de pastas.

mkdir novo_diretorio

8. find

Busca por arquivos e diretórios com base em critérios específicos, como nome ou tipo.

find /caminho/para/busca -name "arquivo.txt"

9. tar

Cria ou extrai arquivos tar (arquivos compactados). Ideal para backup e arquivamento.

tar -cvf arquivo.tar /caminho/para/diretorio

Esses comandos formam a base para muitos scripts de automação e são essenciais para qualquer usuário que deseja trabalhar de maneira mais eficiente no Linux. À medida que você se familiariza com esses comandos, poderá começar a combiná-los em scripts mais complexos e poderosos.

Estruturas de controle no shell script

As estruturas de controle são fundamentais em qualquer linguagem de programação, e no shell script não é diferente. Elas permitem que você tome decisões, execute comandos condicionais e repita tarefas com base em certas condições. Abaixo, apresentamos algumas das principais estruturas de controle que você pode usar em seus scripts:

1. Condicionais (if, else, elif)

A estrutura if permite executar comandos com base na verificação de uma condição. Você pode usar else e elif para definir alternativas.

if [ condição ]; then
    # comandos se a condição for verdadeira
elif [ outra_condição ]; then
    # comandos se a outra condição for verdadeira
else
    # comandos se nenhuma condição for verdadeira
fi

Exemplo:

if [ -f arquivo.txt ]; then
    echo "O arquivo existe."
else
    echo "O arquivo não existe."
fi

Estruturas de repetição (for, while, until)

As estruturas de repetição permitem que você execute um bloco de comandos várias vezes.

for: Utilizada para iterar sobre uma lista de itens.

for item in lista; do
    # comandos
done

Exemplo:

for i in {1..5}; do
    echo "Número: $i"
done

O código fornecido é um exemplo de um loop for em shell script, que itera sobre uma sequência de números de 1 a 5. A expressão {1..5} gera uma lista de números, que são atribuídos à variável i em cada iteração do loop. Dentro do bloco de comandos, o comando echo é utilizado para exibir na tela a string “Número: ” seguida do valor atual de i. Portanto, ao executar esse script, a saída será uma lista de números de 1 a 5, cada um em uma linha separada, mostrando assim como um loop for pode ser usado para repetir uma ação múltiplas vezes com base em uma sequência definida.

while: Executa um bloco de comandos enquanto a condição for verdadeira.

while [ condição ]; do
    # comandos
done

Exemplo:

contador=1
while [ $contador -le 5 ]; do
    echo "Contador: $contador"
    contador=$((contador + 1))
done

O código apresentado é um exemplo de um loop while em shell script, que continua a executar enquanto a condição especificada for verdadeira. Inicialmente, a variável contador é definida com o valor 1. O loop verifica se contador é menor ou igual a 5 ($contador -le 5). Se a condição for verdadeira, o comando echo é executado, exibindo a mensagem “Contador: ” seguida do valor atual de contador. Em seguida, a linha contador=$((contador + 1)) incrementa o valor de contador em 1 a cada iteração. Esse processo se repete até que contador seja maior que 5, resultando em uma saída que exibe os números de 1 a 5, cada um em uma linha separada, demonstrando como um loop while pode ser utilizado para realizar uma ação repetidamente enquanto uma condição for atendida.

until: Executa um bloco de comandos até que a condição se torne verdadeira.

until [ condição ]; do
    # comandos
done

Exemplo:

contador=1
until [ $contador -gt 5 ]; do
    echo "Contador: $contador"
    contador=$((contador + 1))
done

O código apresentado é um exemplo de um loop until em shell script, que executa um bloco de comandos até que a condição especificada se torne verdadeira. Inicialmente, a variável contador é definida com o valor 1. O loop verifica se contador é maior que 5 ($contador -gt 5). Enquanto essa condição não for verdadeira, o comando echo é executado, exibindo a mensagem “Contador: ” seguida do valor atual de contador. Em seguida, a linha contador=$((contador + 1)) incrementa o valor de contador em 1 a cada iteração. Assim, o loop continua a executar até que contador atinja o valor de 6, resultando em uma saída que lista os números de 1 a 5, cada um em uma linha separada. Este exemplo ilustra como o loop until pode ser utilizado para repetir uma ação enquanto uma condição específica não for atendida.

Estruturas de seleção (case)

A estrutura case permite executar diferentes blocos de comandos com base no valor de uma variável.

case "$variavel" in
    padrão1)
        # comandos para padrão1
        ;;
    padrão2)
        # comandos para padrão2
        ;;
    *)
        # comandos para o padrão padrão
        ;;
esac

Exemplo:

dia="segunda"
case "$dia" in
    "segunda")
        echo "Hoje é segunda-feira."
        ;;
    "terça")
        echo "Hoje é terça-feira."
        ;;
    *)
        echo "Não é um dia da semana conhecido."
        ;;
esac

O código apresentado é um exemplo de uma estrutura de controle case em shell script, que permite executar diferentes blocos de comandos com base no valor de uma variável. Neste caso, a variável dia é atribuída com o valor “segunda”. A estrutura case verifica o valor de dia e compara com os padrões definidos. Se dia for igual a “segunda”, o comando echo exibirá a mensagem “Hoje é segunda-feira.” Se dia for igual a “terça”, a mensagem exibida será “Hoje é terça-feira.” O bloco *) serve como uma cláusula padrão que será executada se nenhum dos padrões anteriores corresponder ao valor de dia, resultando na mensagem “Não é um dia da semana conhecido.” Essa estrutura é útil para lidar com múltiplas condições de maneira clara e organizada, permitindo que o script reaja de forma diferente dependendo do valor da variável.

Essas estruturas de controle permitem que você crie scripts mais dinâmicos e flexíveis, respondendo a diferentes condições e automatizando tarefas de maneira eficiente. À medida que você se familiariza com essas estruturas, sua capacidade de criar scripts complexos e úteis aumentará consideravelmente.

Criando um script para backup automático

Neste tópico, vamos criar um script simples para realizar backup automático de um diretório específico. O script irá verificar se o diretório de origem existe, criar um diretório de destino (caso não exista) e, em seguida, compactar os arquivos do diretório de origem em um arquivo .tar.gz no diretório de backup. Siga os passos abaixo:

1. Abra o Terminal e crie um novo arquivo de script

nano backup_automatico.sh

2. Escreva o script no editor

#!/bin/bash

# Definindo variáveis
ORIGEM="/caminho/do/diretorio/origem"
DESTINO="/caminho/do/diretorio/destino"
NOME_BACKUP="backup_$(date +%Y%m%d_%H%M%S).tar.gz"

# Verificando se o diretório de origem existe
if [ -d "$ORIGEM" ]; then
    # Criando o diretório de destino se não existir
    mkdir -p "$DESTINO"
    echo "Iniciando o backup de $ORIGEM para $DESTINO/$NOME_BACKUP"

    # Compactando os arquivos do diretório de origem
    tar -czf "$DESTINO/$NOME_BACKUP" -C "$ORIGEM" .
    echo "Backup concluído com sucesso. Arquivo: $DESTINO/$NOME_BACKUP"
else
    echo "Erro: O diretório de origem '$ORIGEM' não existe."
fi

3. Salve o arquivo

No nano, pressione Ctrl + O e depois Enter para salvar. Pressione Ctrl + X para sair do editor.

4. Torne o script executável

chmod +x backup_automatico.sh

5. Execute o script

./backup_automatico.sh

Explicação do script

• Definição de Variáveis: O script começa definindo duas variáveis: ORIGEM, que contém o caminho do diretório que você deseja fazer backup, e DESTINO, que define o caminho do diretório onde os backups serão armazenados, incluindo um timestamp no nome para manter a organização.
• Verificação de Diretório: A estrutura if verifica se o diretório de origem existe. Se existir, o script prossegue.
• Criação do Diretório de Destino: O comando mkdir -p cria o diretório de destino, caso ele não exista, sem gerar um erro se já estiver presente.
• Compactação dos Arquivos: O comando tar -czf compacta os arquivos do diretório de origem em um arquivo .tar.gz no diretório de destino. A opção -C permite mudar para o diretório de origem antes de compactar, o que garante que a estrutura do diretório seja mantida.
• Mensagens de Status: Mensagens informativas são exibidas para indicar o progresso do backup ou erros, se o diretório de origem não existir.

Esse script simples pode ser a base para backups automáticos e pode ser facilmente expandido ou modificado conforme necessário. Além disso, você pode programar sua execução usando cron para criar backups periódicos.

Personalizando a automação

Após criar um script básico para backup automático, é possível personalizá-lo e expandi-lo para torná-lo mais robusto e informativo. Aqui estão algumas sugestões sobre como você pode aprimorar seu script de backup:

1. Adicionando logs

Manter um registro das atividades do seu script é uma prática importante, pois ajuda a monitorar o sucesso e a identificar problemas. Você pode adicionar um sistema de logs que registre informações sobre a execução do script, como o status do backup, erros e horários.

Exemplo de implementação de logs:

# Definindo a variável de log
LOG_FILE="/caminho/do/arquivo_de_log/backup.log"

# Função para registrar mensagens de log
log_message() {
    echo "$(date +'%Y-%m-%d %H:%M:%S') - $1" >> "$LOG_FILE"
}

# Adicionando log ao script
if [ -d "$ORIGEM" ]; then
    mkdir -p "$DESTINO"
    log_message "Iniciando o backup de $ORIGEM para $DESTINO/$NOME_BACKUP"

    tar -czf "$DESTINO/$NOME_BACKUP" -C "$ORIGEM" .
    log_message "Backup concluído com sucesso. Arquivo: $DESTINO/$NOME_BACKUP"
else
    log_message "Erro: O diretório de origem '$ORIGEM' não existe."
fi

2. Enviando notificações por E-mail

Você pode configurar o script para enviar notificações por e-mail após a execução, informando se o backup foi bem-sucedido ou se ocorreu algum erro. Para isso, você pode usar o comando mail ou sendmail.

Exemplo de implementação de envio de e-mail:

Primeiro, verifique se o mail está instalado no seu sistema. Você pode instalar o mailutils:

sudo apt-get install mailutils

Adicionando o envio de e-mail ao script:

EMAIL="seu_email@dominio.com"

send_email() {
    echo "$1" | mail -s "Notificação de Backup" "$EMAIL"
}

# No final do script, após a execução do backup
if [ -d "$ORIGEM" ]; then
    # ... (código de backup)
    send_email "Backup concluído com sucesso: $DESTINO/$NOME_BACKUP"
else
    send_email "Erro ao realizar o backup: O diretório '$ORIGEM' não existe."
fi

Agendando manutenção e limpeza

Outra personalização útil é implementar uma rotina de limpeza para remover backups antigos e manter o espaço em disco. Você pode adicionar uma lógica para deletar arquivos de backup que tenham mais de X dias.

Exemplo de limpeza de backups antigos:

find "$DESTINO" -type f -name "*.tar.gz" -mtime +30 -exec rm {} \;

Onde adicionar o comando:

Este comando deve ser colocado após o processo de backup, mas antes de qualquer mensagem de finalização ou envio de e-mail. Assim, ele garantirá que os arquivos de backup mais antigos sejam removidos antes de notificar sobre a conclusão do processo. O código ficaria assim:

# Após o backup
find "$DESTINO" -type f -name "*.tar.gz" -mtime +30 -exec rm {} \;

# Envio da notificação por e-mail
send_email "Backup concluído com sucesso: $DESTINO/$NOME_BACKUP"

Personalizar seu script de backup automático com logs e notificações por e-mail pode aumentar a confiabilidade e a eficácia do processo de backup. Essas melhorias permitem que você tenha um melhor controle sobre suas tarefas de automação e reaja rapidamente a quaisquer problemas que possam surgir.

Conclusão

A automação por meio de shell scripts é uma habilidade poderosa que não apenas melhora a eficiência, mas também libera o tempo que poderia ser gasto em tarefas repetitivas. Ao longo deste artigo, exploramos desde os conceitos básicos de shell scripting até a criação de um script prático para backup automático, enriquecendo seu conhecimento e habilidades.

Agora, você está armado com as ferramentas para otimizar sua rotina de trabalho no Linux e tem um excelente ponto de partida para explorar as infinitas possibilidades da automação. Lembre-se de que a prática leva à perfeição, e cada script que você escreve é uma oportunidade de aprender algo novo e aprimorar suas habilidades.

O que você aprendeu neste artigo:

• Conceito de Shell Script: Compreensão do que é um shell script e como ele pode ser utilizado para automatizar tarefas no Linux.
• Conceito de Shell Script: Compreensão do que é um shell script e como ele pode ser utilizado para automatizar tarefas no Linux.
• Comandos Essenciais: Conhecimento sobre comandos fundamentais que podem ser usados em scripts, como echo, ls, cp, mv, rm, entre outros.
• Estruturas de Controle: Aprendizagem sobre estruturas condicionais e de repetição que permitem que seus scripts tomem decisões e executem ações baseadas em condições.
• Backup Automático: Criação de um script para realizar backups automáticos, incluindo verificação de diretórios e compactação de arquivos.
• Personalização do Script: Aprendizado sobre como adicionar funcionalidades, como logs, notificações por e-mail e limpeza de backups antigos.

Agora, é hora de colocar seus novos conhecimentos em prática! Experimente criar seus próprios scripts e não hesite em personalizá-los para atender às suas necessidades específicas. A automação é o futuro, e você está a um passo de se tornar um mestre nesse campo. Boa sorte e bons scripts!

Sobre o Autor

Eduardo Moura

https://tecnosob.com/about/