Escrevendo Scripts em Linux Bash: Um Guia Completo para Iniciantes e Administradores de Sistema

O scripting em Bash é uma das competências mais poderosas que um utilizador Linux, programador ou administrador de sistemas pode desenvolver. Quer esteja a gerir um único servidor ou a orquestrar fluxos de trabalho automatizados complexos em toda uma infraestrutura, dominar o scripting em Bash reduz drasticamente o esforço manual, minimiza erros humanos e desbloqueia todo o potencial do seu ambiente Linux.

Neste guia abrangente, vamos orientá-lo em tudo o que precisa de saber sobre como escrever scripts Bash — desde a criação do seu primeiro ficheiro até ao trabalho com variáveis, condicionais, ciclos, funções, argumentos e técnicas de depuração. Exemplos práticos, prontos a copiar e colar, estão incluídos ao longo do guia.

O Que É um Script Bash?

Um script Bash é um ficheiro de texto simples que contém uma sequência ordenada de comandos interpretados e executados pela shell Bash (Bourne Again SHell). O Bash é a shell interativa predefinida na grande maioria das distribuições Linux, o que o torna universalmente disponível e imediatamente prático.

Em vez de escrever repetidamente a mesma sequência de comandos num terminal, escreve-os uma vez dentro de um ficheiro de script e executa-o quando necessário — ou agenda-o para ser executado automaticamente.

Casos de Uso Comuns para Scripts Bash

• Gestão de ficheiros — copiar, mover, renomear, arquivar e eliminar ficheiros em massa
• Administração de sistemas — monitorizar processos, gerir utilizadores, verificar o uso do disco
• Automação de software — instalar pacotes, configurar serviços, implementar aplicações
• Backup e recuperação — criar backups agendados, incrementais ou completos do sistema
• Análise e relatórios de logs — filtrar e resumir dados de logs para análise
• Provisionamento de servidores — automatizar a configuração inicial de um novo ambiente de VPS Hosting ou servidor dedicado

Pré-requisitos

Para seguir este guia, necessita de:

• Um sistema Linux (máquina local, VM ou servidor remoto)
• Acesso ao terminal com uma conta de utilizador (privilégios de root ou sudo para algumas operações)
• Familiaridade básica com a linha de comandos Linux

Se estiver a trabalhar num servidor remoto, os planos de VPS Hosting da AlexHost oferecem-lhe acesso SSH root completo, tornando-os ideais para praticar e implementar scripts Bash num ambiente real.

Passo 1: Criar um Ficheiro de Script Bash

Abra o seu terminal e utilize qualquer editor de texto para criar um novo ficheiro com a extensão .sh. A extensão .sh é uma convenção amplamente adotada que indica que o ficheiro é um script de shell, embora não seja tecnicamente exigida pelo interpretador.

nano myscript.sh

Pode substituir nano por vim, gedit, micro ou qualquer outro editor da sua preferência.

Passo 2: Adicionar a Linha Shebang (#!)

A primeira linha de cada script Bash deve ser o shebang — uma diretiva especial que indica ao sistema operativo qual o interpretador a utilizar ao executar o ficheiro.

#!/bin/bash

Esta linha instrui o kernel a passar o script para /bin/bash para execução, independentemente da shell que o utilizador atual tenha definido como predefinição. Inclua-a sempre — omitir o shebang pode fazer com que os scripts se comportem de forma imprevisível em diferentes ambientes.

> Dica: Em alguns sistemas modernos, pode também ver #!/usr/bin/env bash, que é uma alternativa mais portátil que localiza o binário Bash dinamicamente através do PATH.

Passo 3: Escrever os Seus Comandos

Após o shebang, adicione os comandos que pretende que o script execute. Aqui está um exemplo simples que saúda o utilizador atual e apresenta informações úteis do sistema:

#!/bin/bash

# A simple script to greet the user and display system info
echo "Hello, $USER! Welcome back."
echo "Today's date and time: $(date)"
echo "Your current working directory: $(pwd)"
echo "System hostname: $(hostname)"

Explicação dos Elementos Principais

Passo 4: Tornar o Script Executável

Antes de poder executar o script diretamente, deve conceder-lhe permissões de execução utilizando o comando chmod:

chmod +x myscript.sh

Isto define o bit de execução para o proprietário do ficheiro. Para verificar se as permissões foram aplicadas corretamente, execute:

ls -l myscript.sh

Deverá ver algo como -rwxr-xr-x, onde os caracteres x confirmam a permissão de execução.

Passo 5: Executar o Script

Execute o script a partir do mesmo diretório utilizando a seguinte sintaxe:

./myscript.sh

O prefixo ./ indica à shell para procurar o ficheiro no diretório atual em vez de pesquisar no PATH do sistema. Deverá ver o resultado impresso diretamente no seu terminal.

Alternativamente, pode invocá-lo explicitamente com o interpretador:

bash myscript.sh

Variáveis em Scripts Bash

As variáveis permitem armazenar e reutilizar dados ao longo do seu script. Podem conter strings, inteiros, caminhos de ficheiros ou o resultado de comandos.

Definir e Utilizar Variáveis

#!/bin/bash

# Define variables
server_name="web-server-01"
max_connections=500
backup_dir="/var/backups"

# Use variables
echo "Server: $server_name"
echo "Max connections allowed: $max_connections"
echo "Backup directory: $backup_dir"

Regras Importantes para Variáveis

• Sem espaços em torno do sinal = ao atribuir um valor (name="value" está correto; name = "value" não está)
• Prefixe o nome da variável com $ ao ler o seu valor: $variable_name
• Utilize chavetas para maior clareza em strings complexas: ${variable_name}
• Os nomes de variáveis são sensíveis a maiúsculas e minúsculas: $Name e $name são variáveis diferentes

Capturar o Resultado de um Comando numa Variável

#!/bin/bash

current_date=$(date +"%Y-%m-%d")
disk_usage=$(df -h / | awk 'NR==2 {print $5}')

echo "Date: $current_date"
echo "Root partition usage: $disk_usage"

Instruções Condicionais em Bash

A lógica condicional permite que o seu script tome decisões e execute diferentes caminhos de código com base em condições avaliadas.

Estrutura Básica if / elif / else

#!/bin/bash

echo "Enter a number between 1 and 100:"
read user_input

if [ "$user_input" -ge 1 ] && [ "$user_input" -le 50 ]; then
    echo "Your number is in the lower half (1–50)."
elif [ "$user_input" -ge 51 ] && [ "$user_input" -le 100 ]; then
    echo "Your number is in the upper half (51–100)."
else
    echo "Your number is outside the valid range."
fi

Operadores de Comparação Comuns

Verificar se um Ficheiro Existe

#!/bin/bash

config_file="/etc/nginx/nginx.conf"

if [ -f "$config_file" ]; then
    echo "Configuration file found: $config_file"
else
    echo "ERROR: Configuration file not found at $config_file"
    exit 1
fi

Ciclos em Scripts Bash

Os ciclos permitem repetir um bloco de comandos várias vezes, seja sobre um intervalo definido, uma lista de itens ou até que uma condição mude.

Ciclo for — Iterar Sobre um Intervalo

#!/bin/bash

echo "Counting from 1 to 5:"
for i in {1..5}; do
    echo "  Iteration: $i"
done

Ciclo for — Iterar Sobre uma Lista de Itens

#!/bin/bash

servers=("web-01" "web-02" "db-01" "cache-01")

for server in "${servers[@]}"; do
    echo "Pinging server: $server"
    ping -c 1 "$server" &>/dev/null && echo "  ✔ $server is reachable" || echo "  ✘ $server is unreachable"
done

Ciclo while — Executar Enquanto uma Condição É Verdadeira

#!/bin/bash

counter=1

while [ $counter -le 5 ]; do
    echo "Counter value: $counter"
    counter=$((counter + 1))
done

echo "Loop complete."

Ciclo until — Executar Até uma Condição Se Tornar Verdadeira

#!/bin/bash

attempts=0

until [ $attempts -ge 3 ]; do
    echo "Attempt $((attempts + 1))..."
    attempts=$((attempts + 1))
done

echo "Maximum attempts reached."

Funções em Scripts Bash

As funções permitem encapsular blocos de lógica reutilizáveis, tornando os seus scripts mais limpos, modulares e fáceis de manter — especialmente à medida que crescem em complexidade.

Definir e Chamar uma Função

#!/bin/bash

# Define the function
greet_user() {
    local username="$1"
    echo "Hello, $username! Your session started at $(date +"%H:%M:%S")."
}

# Call the function with arguments
greet_user "Alice"
greet_user "Bob"

Uma Função Prática: Verificar o Estado de um Serviço

#!/bin/bash

check_service() {
    local service_name="$1"
    if systemctl is-active --quiet "$service_name"; then
        echo "✔ $service_name is running."
    else
        echo "✘ $service_name is NOT running. Attempting to start..."
        systemctl start "$service_name" && echo "  Started successfully." || echo "  Failed to start $service_name."
    fi
}

check_service "nginx"
check_service "mysql"
check_service "ssh"

> Nota: A palavra-chave local restringe o âmbito de uma variável ao interior da função, evitando efeitos secundários não intencionais em scripts maiores.

Trabalhar com Argumentos da Linha de Comandos

Os scripts Bash podem aceitar entrada diretamente da linha de comandos quando são invocados, permitindo scripts flexíveis e reutilizáveis que se comportam de forma diferente com base nos parâmetros fornecidos.

Variáveis Especiais de Argumentos

Exemplo: Um Script Que Aceita Argumentos

#!/bin/bash

# Validate that exactly two arguments were provided
if [ $# -ne 2 ]; then
    echo "Usage: $0 <source_directory> <destination_directory>"
    exit 1
fi

source_dir="$1"
dest_dir="$2"

# Check that the source directory exists
if [ ! -d "$source_dir" ]; then
    echo "ERROR: Source directory '$source_dir' does not exist."
    exit 1
fi

echo "Copying files from '$source_dir' to '$dest_dir'..."
cp -r "$source_dir" "$dest_dir" && echo "Copy completed successfully." || echo "Copy failed."

Execute-o assim:

./myscript.sh /var/www/html /var/backups/html_backup

Códigos de Saída e Tratamento de Erros

Os scripts Bash robustos tratam sempre os erros de forma elegante. Cada comando em Linux retorna um código de saída: 0 indica sucesso, e qualquer valor diferente de zero indica um erro.

Utilizar exit e $?

#!/bin/bash

# Attempt to create a directory
mkdir /tmp/test_directory

if [ $? -eq 0 ]; then
    echo "Directory created successfully."
else
    echo "Failed to create directory."
    exit 1
fi

Utilizar set -e para Tratamento Automático de Erros

Adicionar set -e no início do seu script faz com que este termine imediatamente se algum comando retornar um código de saída diferente de zero — uma boa prática para scripts em produção:

#!/bin/bash
set -e          # Exit on any error
set -u          # Treat unset variables as errors
set -o pipefail # Catch errors in pipelines

echo "Starting deployment..."
cd /var/www/html
git pull origin main
systemctl reload nginx
echo "Deployment complete."

Depurar Scripts Bash

Mesmo programadores experientes escrevem scripts com erros. O Bash fornece ferramentas incorporadas para ajudá-lo a rastrear e corrigir problemas de forma eficiente.

Método 1: Executar com a Flag -x (Modo de Rastreio)

bash -x myscript.sh

Isto imprime cada comando no terminal à medida que é executado, prefixado com +, juntamente com os valores de quaisquer variáveis expandidas. É a técnica de depuração mais utilizada.

Método 2: Adicionar set -x Dentro do Script

Pode ativar e desativar o rastreio para secções específicas do seu script:

#!/bin/bash

echo "Normal execution..."

set -x  # Enable tracing
cp /source/file /destination/
chmod 644 /destination/file
set +x  # Disable tracing

echo "Tracing disabled again."

Método 3: Utilizar Instruções echo como Pontos de Verificação

Instruções echo colocadas estrategicamente ajudam-no a verificar os valores das variáveis e a confirmar que a execução atingiu um ponto específico no script:

echo "DEBUG: backup_dir = $backup_dir"
echo "DEBUG: Reached checkpoint before rsync"

Exemplo Prático do Mundo Real: Script de Backup Automatizado

Aqui está um script Bash completo e pronto para produção que demonstra muitos dos conceitos abordados neste guia:

#!/bin/bash
set -euo pipefail

# ============================================================
# Automated Backup Script
# Description: Backs up a specified directory with a timestamp
# ============================================================

# Configuration
SOURCE_DIR="/var/www/html"
BACKUP_ROOT="/var/backups/web"
TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
BACKUP_NAME="backup_${TIMESTAMP}.tar.gz"
BACKUP_PATH="${BACKUP_ROOT}/${BACKUP_NAME}"
RETENTION_DAYS=7
LOG_FILE="/var/log/backup.log"

# Logging function
log() {
    echo "[$(date +"%Y-%m-%d %H:%M:%S")] $1" | tee -a "$LOG_FILE"
}

# Validate source directory
if [ ! -d "$SOURCE_DIR" ]; then
    log "ERROR: Source directory '$SOURCE_DIR' not found. Aborting."
    exit 1
fi

# Create backup root if it doesn't exist
mkdir -p "$BACKUP_ROOT"

log "Starting backup of '$SOURCE_DIR'..."

# Create compressed archive
tar -czf "$BACKUP_PATH" -C "$(dirname "$SOURCE_DIR")" "$(basename "$SOURCE_DIR")"

log "Backup created: $BACKUP_PATH ($(du -sh "$BACKUP_PATH" | cut -f1))"

# Remove backups older than retention period
log "Removing backups older than ${RETENTION_DAYS} days..."
find "$BACKUP_ROOT" -name "backup_*.tar.gz" -mtime +"$RETENTION_DAYS" -delete

log "Backup process completed successfully."

Este tipo de script é inestimável em qualquer servidor de produção. Se estiver a executar um website ou aplicação em Servidores Dedicados ou num VPS, automatizar os seus backups com um script como este — combinado com um cron job — garante que os seus dados estão sempre protegidos sem intervenção manual.

Agendar Scripts Bash com Cron

Para executar os seus scripts Bash automaticamente de acordo com um agendamento, utilize o cron, o agendador de tarefas do Linux. Edite o seu crontab com:

crontab -e

Adicione uma linha no seguinte formato:

# Run backup script every day at 2:00 AM
0 2 * * * /path/to/backup.sh >> /var/log/backup_cron.log 2>&1

Sintaxe do Cron: minute hour day-of-month month day-of-week command

Boas Práticas para Escrever Scripts Bash

Seguir estas convenções tornará os seus scripts mais fiáveis, legíveis e fáceis de manter:

1. Inclua sempre o shebang (#!/bin/bash) na primeira linha
2. Utilize set -euo pipefail em scripts de produção para detetar erros precocemente
3. Coloque as suas variáveis entre aspas ("$variable") para evitar problemas de divisão de palavras e globbing
4. Utilize nomes de variáveis significativos — backup_directory é mais claro do que bd
5. Comente o seu código — explique o *porquê*, não apenas o *quê*
6. Valide as entradas — verifique se os argumentos e ficheiros necessários existem antes de prosseguir
7. Utilize funções para organizar lógica complexa em blocos reutilizáveis e nomeados
8. Teste num ambiente seguro antes de executar scripts em sistemas de produção
9. Utilize variáveis local dentro de funções para evitar poluir o âmbito global
10. Registe ações importantes num ficheiro para poder auditar o comportamento do script posteriormente

Aprofundar as Suas Competências em Bash

Quando estiver confortável com os fundamentos, considere explorar estes tópicos avançados:

• Expressões regulares com grep, sed e awk para processamento poderoso de texto
• Here documents (heredoc) para incorporar strings de múltiplas linhas em scripts
• Substituição de processos e pipes nomeados para pipelines de dados complexos
• Tratamento de sinais com trap para terminação elegante de scripts
• Arrays associativos (Bash 4+) para estruturas de dados chave-valor
• Bibliotecas de scripts — importar funções comuns de um ficheiro partilhado com source

Se estiver a gerir aplicações web, bases de dados ou infraestrutura de email, o scripting em Bash combina naturalmente com serviços como Alojamento Web Partilhado para projetos menores, ou um VPS com cPanel totalmente gerido para ambientes onde pretende uma interface gráfica juntamente com acesso à shell.

Para equipas que executam cargas de trabalho intensivas em dados ou pipelines de machine learning, os scripts Bash são igualmente valiosos para orquestrar tarefas em infraestrutura de GPU Hosting — automatizando execuções de treino de modelos, gerindo conjuntos de dados e tratando da configuração do ambiente.

Conclusão

O scripting em Bash é uma competência indispensável para qualquer pessoa que trabalhe com Linux — seja um iniciante a automatizar a sua primeira tarefa repetitiva ou um administrador de sistemas sénior a gerir infraestrutura de servidores complexa. Os conceitos abordados neste guia — criação de ficheiros, variáveis, condicionais, ciclos, funções, tratamento de argumentos, gestão de erros e depuração — formam a base completa de que necessita para escrever scripts fiáveis e de qualidade para produção.

Comece de forma simples: automatize uma tarefa que realiza manualmente todos os dias. À medida que a sua confiança cresce, combine estes blocos de construção em ferramentas cada vez mais sofisticadas que poupam horas de trabalho, reduzem o risco de erro humano e dão-lhe um controlo preciso e repetível sobre os seus sistemas.

Para o melhor ambiente para praticar e implementar os seus scripts Bash, explore a gama de planos de VPS Hosting baseados em Linux da AlexHost — com acesso root completo, armazenamento SSD e configurações flexíveis concebidas para programadores e administradores de sistemas.