Shell Scripting e Automação

Variáveis de shell

Variáveis armazenam valores temporários dentro do script ou da sessão shell. Não há declaração de tipo — o shell trata tudo como texto a menos que se use aritmética explícita. Por convenção, variáveis locais ficam em minúsculas; variáveis de ambiente em maiúsculas.

# Atribuição: sem espaços ao redor do '='
nome="Alice"
versao="2.1"
contador=0

# Leitura: prefixo $
echo "Olá, $nome"
echo "Versão: ${versao}"        # chaves explícitas — recomendado

# Variável não definida → string vazia (perigoso sem set -u)
echo "Indefinida: ${nao_existe:-valor_padrao}"
Indefinida: valor_padrao

# Variável somente-leitura
readonly MAX_RETRIES=3

# Remover variável
unset contador

Variáveis de ambiente

# Exportar para processos filhos
export APP_ENV="production"

# Ver todas as variáveis de ambiente
$ env | grep APP_ENV
APP_ENV=production

# Variáveis de ambiente importantes
echo $HOME      # /home/usuario
echo $PATH      # diretórios de busca de executáveis
echo $SHELL     # shell atual
echo $USER      # nome do usuário
echo $PWD       # diretório atual
echo $OLDPWD    # diretório anterior

Expansões de variável

# Valor padrão se não definida (não atribui)
echo "${HOST:-localhost}"

# Atribuir padrão se não definida
: "${LOG_DIR:=/var/log/myapp}"

# Erro se não definida
echo "${REQUIRED_VAR:?'variável obrigatória não definida'}"

# Comprimento da string
texto="Linux"
echo "${#texto}"       # → 5

# Substituição de substring
arquivo="relatorio.txt"
echo "${arquivo%.txt}"  # → relatorio  (remove sufixo)
echo "${arquivo#rela}"  # → torio.txt  (remove prefixo)

# Maiúsculas / minúsculas (Bash 4+)
s="hello world"
echo "${s^^}"           # → HELLO WORLD
echo "${s^}"            # → Hello world

A ordem das expansões do Bash

Antes de executar qualquer comando, o Bash reescreve a linha percorrendo uma sequência fixa de expansões. Entender essa ordem explica por que echo ~/*.txt funciona mas echo "$var"* às vezes surpreende:

Substituição de comando e aritmética

# Substituição de comando: $() ou backticks (prefira $())
hoje="$(date +%Y-%m-%d)"
kernel="$(uname -r)"
num_procs="$(nproc)"

# Aritmética: $(( )) ou let
a=10; b=3
echo $(( a + b ))      # → 13
echo $(( a * b ))      # → 30
echo $(( a % b ))      # → 1  (módulo)
(( contador++ ))        # incremento

# Arrays
frutas=("maçã" "banana" "laranja")
echo "${frutas[0]}"     # → maçã
echo "${frutas[@]}"     # → todos os elementos
echo "${#frutas[@]}"    # → 3 (tamanho)
frutas+=("uva")         # append

Arrays: indexados, associativos e fatiamento

O Bash tem dois tipos de array: indexados (chave inteira, o padrão) e associativos (chave string, exigem declare -A, Bash 4+). Sempre expanda com "${arr[@]}" entre aspas — assim cada elemento vira uma palavra, mesmo os que contêm espaços.

$ servidores=("web 01" "web02" "db01")
$ echo "${#servidores[@]}"          # quantidade
3
$ echo "${servidores[@]:1:2}"       # fatia: 2 itens a partir do índice 1
web02 db01
$ echo "${!servidores[@]}"         # os índices (chaves)
0 1 2

# Array associativo (mapa chave→valor)
$ declare -A porta
$ porta[http]=80; porta[https]=443; porta[ssh]=22
$ echo "HTTPS usa a porta ${porta[https]}"
HTTPS usa a porta 443
$ for s in "${!porta[@]}"; do echo "$s → ${porta[$s]}"; done
ssh → 22
http → 80
https → 443

Variáveis especiais do shell

Processando argumentos

#!/usr/bin/env bash
# Exemplo básico de validação de argumentos
if [[ $# -lt 2 ]]; then
    echo "Uso: $0 <origem> <destino>" >&2
    exit 1
fi

origem="$1"
destino="$2"

# Iterar sobre todos os argumentos
for arg in "$@"; do
    echo "Argumento: $arg"
done

$ ./copia.sh origem.txt "pasta destino" extra
Argumento: origem.txt
Argumento: pasta destino
Argumento: extra
# Note: "pasta destino" chegou como UM argumento graças às aspas na chamada
# $0=./copia.sh  $1=origem.txt  $2="pasta destino"  $3=extra  $#=3

getopts — opções no estilo Unix

#!/usr/bin/env bash
verbose=0
output="resultado.txt"

while getopts ":vo:" opt; do
    case $opt in
        v) verbose=1 ;;
        o) output="$OPTARG" ;;
        :) echo "Opção -$OPTARG requer argumento" >&2; exit 1 ;;
        \?) echo "Opção inválida: -$OPTARG" >&2; exit 1 ;;
    esac
done

# Shift para remover as opções processadas
shift $(( OPTIND - 1 ))

[[ $verbose -eq 1 ]] && echo "Modo verbose ativo. Saída: $output"

Testes e comparações

if [[ "$nome" == "root" ]]; then …
if [[ "$str" != "" ]]; then …
if [[ -z "$var" ]]; then …  # vazia
if [[ -n "$var" ]]; then …  # não vazia
if [[ "$a" < "$b" ]]; then …  # lexicográfica
if [[ "$s" =~ ^[0-9]+$ ]]; then … # regex

-eq   igual         (equal)
-ne   diferente     (not equal)
-lt   menor que     (less than)
-le   menor/igual   (less or equal)
-gt   maior que     (greater than)
-ge   maior/igual   (greater or equal)

if (( a > b )); then …  # forma aritmética

-e FILE    existe (qualquer tipo)
-f FILE    existe e é arquivo regular
-d FILE    existe e é diretório
-r FILE    existe e é legível
-w FILE    existe e é gravável
-x FILE    existe e é executável
-s FILE    existe e não está vazio
-L FILE    é um symlink
FILE1 -nt FILE2   FILE1 é mais novo
FILE1 -ot FILE2   FILE1 é mais antigo

Como o Bash avalia um teste [[ ]]

[[ ]] não é sintaxe mágica: é uma palavra-chave do Bash (ao contrário de [, que é um comando — na verdade um sinônimo de test). Entender o fluxo evita a maioria das pegadinhas de quoting:

if / elif / else

#!/usr/bin/env bash
arquivo="$1"

if [[ ! -e "$arquivo" ]]; then
    echo "ERRO: '$arquivo' não existe." >&2
    exit 1
elif [[ -d "$arquivo" ]]; then
    echo "'$arquivo' é um diretório."
elif [[ -f "$arquivo" && -r "$arquivo" ]]; then
    echo "'$arquivo' é um arquivo legível."
else
    echo "'$arquivo' existe mas não é legível."
fi

case / esac

#!/usr/bin/env bash
acao="$1"

case "$acao" in
    start|inicio)
        echo "Iniciando serviço..."
        ;;
    stop|parar)
        echo "Parando serviço..."
        ;;
    restart|reiniciar)
        echo "Reiniciando serviço..."
        ;;
    status)
        echo "Verificando status..."
        ;;
    *)
        echo "Uso: $0 {start|stop|restart|status}" >&2
        exit 1
        ;;
esac

Exit codes: a moeda de troca do shell

Todo comando devolve um código de saída (0–255): 0 significa sucesso e qualquer valor diferente indica falha. É esse número — guardado em $? — que if, &&, || e while leem para decidir o fluxo. Um script deve escolher seu próprio código com exit N para comunicar o resultado a quem o chamou.

$ grep -q root /etc/passwd; echo "saída: $?"
saída: 0          # encontrou → sucesso
$ grep -q inexistente /etc/passwd; echo "saída: $?"
saída: 1          # não encontrou → falha "esperada"
$ ls /pasta/inexistente; echo "saída: $?"
ls: cannot access '/pasta/inexistente': No such file or directory
saída: 2          # erro real

# Encadeamento condicional baseado no exit code
$ mkdir -p /tmp/proj && echo "criado" || echo "falhou"
criado

# Convenções: 0=ok · 1=erro genérico · 2=uso incorreto · 126=sem permissão
#             127=comando não encontrado · 130=interrompido (Ctrl+C)

for — iteração sobre listas

# Lista literal
for cor in vermelho verde azul; do
    echo "Cor: $cor"
done

# Glob — iterar arquivos
for f in /var/log/*.log; do
    echo "Log: $f ($(wc -l < "$f") linhas)"
done

# Sequência numérica
for i in $(seq 1 5); do
    echo "Item $i"
done

# Estilo C (Bash)
for (( i=0; i<5; i++ )); do
    echo "i=$i"
done

# Iterar array
servidores=("web01" "web02" "db01")
for srv in "${servidores[@]}"; do
    echo "Verificando: $srv"
    ping -c1 -W1 "$srv" >/dev/null 2>&1 && echo "  OK" || echo "  FALHOU"
done

while — enquanto a condição for verdadeira

# Contador simples
contador=1
while [[ $contador -le 5 ]]; do
    echo "Iteração: $contador"
    (( contador++ ))
done

# Leitura de arquivo linha a linha — padrão idiomático
while IFS= read -r linha; do
    echo "Processando: $linha"
done < "/etc/passwd"

# Leitura da saída de um comando
while IFS= read -r usuario; do
    id "$usuario" 2>/dev/null && echo "  Existe: $usuario"
done < <(cut -d: -f1 /etc/passwd)

# Loop infinito com break
while true; do
    read -rp "Digite 'sair' para terminar: " entrada
    [[ "$entrada" == "sair" ]] && break
    echo "Você digitou: $entrada"
done

Anatomia do idioma while IFS= read -r linha

A forma canônica de ler um arquivo linha a linha parece críptica, mas cada pedaço tem um motivo. Veja o que cada parte faz — e por que omitir qualquer uma introduz bugs sutis:

until — executa até a condição ser verdadeira

# Aguarda o serviço ficar disponível
until curl -sf http://localhost:8080/health >/dev/null 2>&1; do
    echo "Serviço ainda não disponível, aguardando..."
    sleep 5
done
echo "Serviço UP!"

break e continue

for i in $(seq 1 10); do
    [[ $i -eq 5 ]] && continue   # pula o 5
    [[ $i -eq 8 ]] && break     # para no 8
    echo $i
done
1 2 3 4 6 7

Loops que resolvem problemas reais

$ total=0
$ for f in /var/log/*.log; do
>     n=$(wc -l < "$f")
>     printf "%-24s %6d linhas\n" "$(basename "$f")" "$n"
>     total=$(( total + n ))
> done
alternatives.log             42 linhas
dpkg.log                   1893 linhas
kern.log                    671 linhas
$ echo "Total: $total linhas"
Total: 2606 linhas

# Retentativa com backoff — padrão de resiliência
$ tentativa=1
$ until ping -c1 -W1 8.8.8.8 >/dev/null 2>&1 || [[ $tentativa -gt 3 ]]; do
>     echo "Sem rede (tentativa $tentativa), aguardando..."
>     sleep $(( tentativa * 2 )); (( tentativa++ ))
> done
Sem rede (tentativa 1), aguardando...
Sem rede (tentativa 2), aguardando...

Funções

# Duas sintaxes equivalentes (prefira a primeira)
minha_funcao() {
    echo "Olá da função"
}

function outra_funcao {
    echo "Outra forma"
}

# Funções com argumentos e retorno
somar() {
    local a="$1"   # local: escopo restrito à função
    local b="$2"
    echo $(( a + b ))  # "retorno" via stdout
}

resultado=$(somar 10 5)
echo "10 + 5 = $resultado"
10 + 5 = 15

# Exit code como sinal de sucesso/falha
arquivo_existe() {
    [[ -f "$1" ]]   # retorna 0 (true) se existir, 1 se não
}

if arquivo_existe /etc/passwd; then
    echo "/etc/passwd existe"
fi

Padrão de biblioteca de funções

#!/usr/bin/env bash
# Funções utilitárias reutilizáveis

log() {
    local level="$1"; shift
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] [$level] $*"
}

log_info()  { log "INFO "  "$@"; }
log_warn()  { log "WARN "  "$@" >&2; }
log_error() { log "ERROR"  "$@" >&2; }

die() {
    log_error "$*"
    exit 1
}

# Uso
log_info "Script iniciado"
[[ -d "$1" ]] || die "Diretório '$1' não encontrado"

Redirecionamento de I/O

# Streams padrão
# stdin  = fd 0  (entrada)
# stdout = fd 1  (saída normal)
# stderr = fd 2  (erros)

# Redirecionar stdout para arquivo (sobrescrever)
ls /etc > lista.txt

# Append (acrescentar)
ls /var/log >> lista.txt

# Redirecionar stderr
find / -name "*.conf" 2> erros.txt

# Redirecionar stdout e stderr juntos
./script.sh >& tudo.log
./script.sh > saida.log 2>&1    # POSIX — mais portável

# Descartar saída
comando_silencioso >/dev/null 2>&1

# Entrada de arquivo
while IFS= read -r linha; do …; done < arquivo.txt

# Here-document
cat <<'EOF'
Este texto tem $variaveis literais
EOF

# Here-string
read -r nome <<< "Alice"

A ordem importa: >out 2>&1 × 2>&1 >out

O erro de redirecionamento mais comum é inverter a ordem. O shell processa os redirecionamentos da esquerda para a direita, e 2>&1 significa literalmente "faça o fd 2 apontar para onde o fd 1 aponta agora" — não "junte os dois para sempre". Acompanhe:

Subshell ( ) × agrupamento { }

Ambos agrupam comandos, mas os parênteses criam um subshell — um processo filho com cópia do ambiente; mudanças (diretório, variáveis) somem ao sair. As chaves agrupam no shell atual, sem processo novo — mais rápido, e o único jeito de um bloco alterar variáveis do script.

$ x=1
$ ( x=99; cd /tmp; echo "dentro: x=$x pwd=$(pwd)" )
dentro: x=99 pwd=/tmp
$ echo "fora: x=$x pwd=$(pwd)"    # subshell não afetou nada
fora: x=1 pwd=/home/user

$ { x=99; echo "dentro: x=$x"; }   # note o ; antes do } e os espaços
dentro: x=99
$ echo "fora: x=$x"              # { } alterou a variável do shell
fora: x=99

Pipes e process substitution

# Encadeamento de comandos
ps aux | grep nginx | awk '{print $2}' | xargs kill -HUP

# tee — bifurca: envia para arquivo E stdout
./deploy.sh 2>&1 | tee /var/log/deploy.log

# xargs — converte stdin em argumentos
find /tmp -name "*.tmp" -mtime +7 | xargs rm -f

# Process substitution — trata saída de comando como arquivo
diff <(sort arquivo_a.txt) <(sort arquivo_b.txt)

# Combinação com operadores lógicos
mkdir -p /backup/2026 && cd /backup/2026 || { echo "Falhou"; exit 1; }

# Subshell — não afeta o ambiente pai
(cd /tmp && ls)   # volta ao diretório original após o parêntese

$ diff <(rpm -qa 2>/dev/null | sort) <(cat pacotes_ontem.txt)
< nginx-1.24.0
> nginx-1.22.1            # < = só na esquerda; > = só na direita

# tee para ver E salvar ao mesmo tempo
$ df -h | tee /tmp/disco.txt | grep -E '9[0-9]%|100%'
/dev/sda1        20G   19G  1.0G  95% /   # só as partições cheias na tela
$ wc -l < /tmp/disco.txt     # o arquivo guardou a saída completa
6

trap — limpeza ao sair

#!/usr/bin/env bash
TMPDIR="$(mktemp -d)"

# Garante limpeza em qualquer saída (exit, Ctrl+C, erro)
cleanup() {
    rm -rf "$TMPDIR"
    echo "Temporários removidos."
}
trap cleanup EXIT

# Sinal Ctrl+C
trap 'echo "Interrompido pelo usuário"; exit 130' INT

# Uso de $TMPDIR...

Here-documents × here-strings

Ambos alimentam o stdin de um comando com texto inline. O here-document (<<) serve para blocos de várias linhas; o here-string (<<<) para uma única string curta. O detalhe decisivo é o quoting do delimitador:

$ nome=Alice
# Delimitador SEM aspas → expande variáveis e $(...)
$ cat <<EOF
> Olá, $nome — hoje é $(date +%A)
> EOF
Olá, Alice — hoje é Monday

# Delimitador com aspas 'EOF' → tudo literal (útil p/ gerar scripts/config)
$ cat <<'EOF'
> Isto mostra $nome literalmente
> EOF
Isto mostra $nome literalmente

# <<- remove TABs iniciais, permitindo indentar o here-doc no script
# Here-string: uma linha direta no stdin
$ read -r a b c <<< "um dois três"
$ echo "$b"
dois
$ grep -c root <<< "$(cat /etc/passwd)"
2