Chegamos à aula 100 do nosso curso de Shell Script! Ao longo de toda essa jornada, você aprendeu desde os fundamentos — como variáveis, condicionais e loops — até tópicos avançados como processamento de texto, manipulação de arquivos, funções, depuração e boas práticas. Agora é hora de olhar para o futuro e entender como aplicar todo esse conhecimento no mundo real, e quais caminhos seguir para se tornar um profissional ainda mais completo.

Nesta aula de roadmap, vamos discutir quando o shell script é a ferramenta certa (e quando não é), explorar as áreas de administração de sistemas e automação — onde o shell brilha — e, por fim, traçar um plano de estudos e projetos para você continuar evoluindo. Vamos começar!

Quando usar shell vs outras ferramentas

O shell script é extremamente poderoso para tarefas que envolvem a linha de comando, arquivos, processos e integração com outras ferramentas Unix. Porém, não é a solução ideal para todos os problemas. Saber escolher a ferramenta certa é uma habilidade crucial para qualquer programador.

Use shell script quando:

  • A tarefa envolve principalmente executar comandos externos e processar sua saída.
  • Você precisa manipular arquivos de texto, como logs, CSV, configurações.
  • Automatizar tarefas repetitivas no sistema operacional (backup, monitoramento, deploy).
  • Compor pipelines de comandos complexos.
  • Requer pouca ou nenhuma lógica de programação complexa.

Evite shell script quando:

  • A tarefa exige estruturas de dados complexas (listas, dicionários, objetos) — prefira Python, Ruby, etc.
  • Você precisa de manipulação avançada de strings ou expressões regulares complexas — linguagens como Perl ou Python são mais adequadas.
  • O código vai crescer muito (mais de algumas centenas de linhas) e precisa de manutenção pesada — uma linguagem de propósito geral é melhor.
  • Você precisa de desempenho computacional intenso — shell é lento para cálculos.
  • A tarefa envolve desenvolvimento web, GUI, ou aplicações de larga escala.

Um exemplo típico: se você precisa apenas verificar se um arquivo existe e enviar um e-mail caso não exista, shell é perfeito. Mas se você precisa processar um arquivo JSON grande com lógica complexa, Python é mais adequado.

#!/bin/bash
# Exemplo: verificar se um arquivo existe e enviar alerta
ARQUIVO="/etc/passwd"
if [ -f "$ARQUIVO" ]; then
    echo "Arquivo existe"
else
    echo "Arquivo não existe" | mail -s "Alerta" admin@example.com
fi

Em contraste, um script Python para processar JSON:

# Exemplo em Python (não shell)
import json
with open('dados.json') as f:
    dados = json.load(f)
# ... processamento complexo ...

Perceba que o shell é ótimo para orquestrar, mas não para computação pesada.

Administração de sistemas

O shell script é a espinha dorsal da administração de sistemas Linux/Unix. Administradores de sistemas usam scripts para automatizar tarefas rotineiras, gerenciar usuários, fazer backup, monitorar recursos, e muito mais. Dominar shell é essencial para qualquer pessoa que trabalhe com servidores.

Principais áreas de aplicação:

  • Gerenciamento de usuários e permissões: criar/remover usuários, alterar permissões de arquivos.
  • Backup e restauração: compactar diretórios, copiar para locais remotos, agendar backups com cron.
  • Monitoramento de sistema: verificar uso de CPU, memória, disco, processos; gerar alertas.
  • Gerenciamento de logs: rotacionar, filtrar, analisar logs.
  • Instalação e configuração de software: automatizar instalações, configurar serviços.
  • Agendamento de tarefas: usar cron para executar scripts periodicamente.

Exemplo de script para backup simples:

#!/bin/bash
# Backup de um diretório para um arquivo .tar.gz com data
ORIGEM="/home/user/documentos"
DESTINO="/backup"
DATA=$(date +%Y%m%d_%H%M%S)
tar -czf "$DESTINO/documentos_$DATA.tar.gz" "$ORIGEM"
echo "Backup concluído: $DESTINO/documentos_$DATA.tar.gz"

Exemplo de monitoramento de disco:

#!/bin/bash
# Alerta se o uso do disco raiz ultrapassar 80%
LIMITE=80
USO=$(df / | awk 'NR==2 {print $5}' | sed 's/%//')
if [ "$USO" -gt "$LIMITE" ]; then
    echo "Alerta: uso do disco em $USO%" | mail -s "Alerta de disco" admin@example.com
fi

Além disso, ferramentas como Ansible, Puppet e Chef usam conceitos de automação, mas o shell ainda é fundamental para tarefas ad-hoc e para entender o que está acontecendo no sistema.

Automação

Automação é o processo de fazer o computador executar tarefas repetitivas sem intervenção humana. O shell script é uma das ferramentas mais utilizadas para automação de tarefas de TI, desde simples rotinas até pipelines complexos de CI/CD.

Exemplos de automação com shell:

  • Deploy de aplicações: scripts que compilam, testam e publicam aplicações.
  • Integração contínua: em ferramentas como Jenkins, GitLab CI, GitHub Actions, o shell é usado para definir etapas.
  • Provisionamento de servidores: scripts que configuram um servidor do zero.
  • Processamento de dados: baixar arquivos, transformar, carregar em banco de dados (ETL).
  • Rotinas de manutenção: limpeza de arquivos temporários, atualização de pacotes.

Um script de deploy simples:

#!/bin/bash
# Deploy de uma aplicação web via git pull e restart do serviço
cd /var/www/meuapp
git pull origin main
npm install
npm run build
systemctl restart meuapp
echo "Deploy concluído em $(date)"

Integração com cron para agendar:

# Cron job para executar o backup todos os dias às 2h da manhã
0 2 * * * /usr/local/bin/backup.sh

Além disso, o shell é usado em orquestração de containers (Docker, Kubernetes) e em scripts de inicialização (init scripts). Dominar shell é um requisito para quem quer trabalhar com DevOps e SRE.

Como continuar

Você já percorreu um longo caminho, mas a aprendizagem nunca termina. Aqui estão sugestões de como continuar evoluindo:

  • Pratique regularmente: crie projetos pessoais que resolvam problemas reais.
  • Estude ferramentas complementares: awk, sed, grep, find, xargs, jq (para JSON), yq (para YAML).
  • Aprofunde-se em administração de sistemas: estude systemd, redes, segurança, virtualização.
  • Aprenda outras linguagens: Python, Go, ou Ruby para quando o shell não for suficiente.
  • Participe de comunidades: fóruns, grupos, Stack Overflow, Reddit (r/linux, r/bash).
  • Leia código de scripts de projetos open-source: veja como profissionais escrevem.
  • Faça cursos avançados: DevOps, Cloud (AWS, GCP, Azure), SRE.
  • Certificações: LPIC, RHCSA, CompTIA Linux+.

Um plano de estudos sugerido:

  1. Mês 1-2: Revisar fundamentos e criar scripts para tarefas diárias.
  2. Mês 3-4: Estudar processamento de texto com awk/sed e expressões regulares.
  3. Mês 5-6: Aprender sobre agendamento (cron, systemd timers) e automação de servidores.
  4. Mês 7-8: Introdução a DevOps: Docker, CI/CD, e usar shell em pipelines.
  5. Mês 9-12: Projeto final: automatizar a infraestrutura de uma aplicação completa.

Exemplo de script mais avançado usando funções e getopts:

#!/bin/bash
# Script com opções de linha de comando
uso() {
    echo "Uso: $0 [-a] [-b valor]"
    exit 1
}

while getopts ":ab:" opt; do
    case $opt in
        a) echo "Opção a ativada";;
        b) echo "Valor de b: $OPTARG";;
        \?) echo "Opção inválida" >&2; uso;;
    esac
done

Lembre-se: a prática leva à perfeição. Não tenha medo de quebrar coisas — é assim que se aprende.

Boas práticas e observações finais

Antes de encerrar, quero reforçar algumas boas práticas que você deve manter em seus scripts:

  • Sempre use #!/bin/bash (ou #!/usr/bin/env bash) para garantir o interpretador.
  • Use set -e ou set -euo pipefail para abortar em erros e evitar variáveis não definidas.
  • Comente seu código para facilitar a manutenção.
  • Valide entradas e trate erros adequadamente.
  • Teste seus scripts em ambientes controlados antes de colocar em produção.
  • Mantenha seus scripts em um repositório de versionamento (Git).

Parabéns por chegar até aqui! Você está pronto para aplicar seus conhecimentos em shell script em projetos reais. Continue explorando, e lembre-se: o shell é uma ferramenta poderosa, mas saber quando usá-lo é o que diferencia um bom profissional.

Exercícios

  1. Exercício 1: Escreva um script que determine se um determinado comando (por exemplo, curl) está instalado no sistema. Se não estiver, exiba uma mensagem de erro e saia com código 1.

    ✓ Resposta:
    #!/bin/bash
if command -v curl > /dev/null; then
    echo "curl está instalado"
else
    echo "curl não está instalado" >&2
    exit 1
fi
  2. Exercício 2: Crie um script que faça backup de um diretório específico para um arquivo tar.gz, usando a data atual no nome do arquivo. O diretório de origem e o destino devem ser passados como argumentos.

    ✓ Resposta:
    #!/bin/bash
if [ $# -ne 2 ]; then
    echo "Uso: $0 origem destino" >&2
    exit 1
fi
ORIGEM="$1"
DESTINO="$2"
DATA=$(date +%Y%m%d_%H%M%S)
tar -czf "$DESTINO/backup_$DATA.tar.gz" "$ORIGEM"
echo "Backup criado em $DESTINO/backup_$DATA.tar.gz"
  3. Exercício 3: Escreva um script que monitore o uso de CPU e, se estiver acima de 90%, envie um alerta (pode ser apenas uma mensagem no terminal). Use o comando top ou ps para obter o uso.

    ✓ Resposta:
    #!/bin/bash
# Obtém o uso de CPU total (primeira linha de top -bn1)
CPU=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
# Converte para inteiro (remove decimal)
CPU_INT=${CPU%.*}
if [ "$CPU_INT" -gt 90 ]; then
    echo "Alerta: CPU em ${CPU}%"
else
    echo "CPU normal: ${CPU}%"
fi
  4. Exercício 4: Crie um script que automatize a criação de um novo usuário no Linux, incluindo a criação do diretório home e definição de senha (use o comando useradd e passwd). O script deve receber o nome do usuário como argumento.

    ✓ Resposta:
    #!/bin/bash
if [ $# -ne 1 ]; then
    echo "Uso: $0 nome_usuario" >&2
    exit 1
fi
USERNAME="$1"
# Cria o usuário com diretório home
useradd -m "$USERNAME"
# Define uma senha (será solicitada interativamente)
passwd "$USERNAME"
echo "Usuário $USERNAME criado com sucesso."
  5. Exercício 5: Escreva um script que leia um arquivo de texto e conte quantas linhas, palavras e caracteres ele possui, sem usar o comando wc. Dica: use loops e variáveis.

    ✓ Resposta:
    #!/bin/bash
if [ $# -ne 1 ]; then
    echo "Uso: $0 arquivo" >&2
    exit 1
fi
ARQUIVO="$1"
LINHAS=0
PALAVRAS=0
CARACTERES=0
while IFS= read -r linha; do
    LINHAS=$((LINHAS + 1))
    CARACTERES=$((CARACTERES + ${#linha}))
    # Conta palavras na linha
    for palavra in $linha; do
        PALAVRAS=$((PALAVRAS + 1))
    done
done < "$ARQUIVO"
echo "Linhas: $LINHAS"
echo "Palavras: $PALAVRAS"
echo "Caracteres: $CARACTERES"

Referências