Linux: Script Bash Avançado

#!/bin/bash
cd /var/www/myapp
git pull origin main
npm install            # ❌ Falhou
npm run build          # Mas o script continuou rodando
pm2 restart app        # Reiniciou com código antigo e build quebrado

#!/bin/bash
set -e                 # Para ao primeiro erro
cd /var/www/myapp
git pull origin main
npm install
npm run build
pm2 restart app

# Definindo uma função
greet() {
    echo "Hello, $1!"
    echo "Today is $(date)"
}

# Sintaxe alternativa
function greet {
    echo "Hello, $1!"
}

# Chamando a função
greet "Alice"

# Variáveis locais
myfunc() {
    local x=10        # Variável local, não afeta o escopo externo
    echo "Inside: $x"
}
x=5
myfunc                # Saída: Inside: 10
echo "Outside: $x"    # Saída: Outside: 5

# Array indexado
fruits=("apple" "banana" "orange")
fruits[3]="grape"     # Adicionando elemento

echo ${fruits[0]}     # apple
echo ${fruits[@]}     # Todos os elementos
echo ${#fruits[@]}    # Tamanho do array

# Iterando sobre o array
for fruit in "${fruits[@]}"; do
    echo "$fruit"
done

# Array associativo (como um dicionário)
declare -A config
config[host]="localhost"
config[port]="8080"
config[user]="admin"

echo ${config[host]}  # localhost

# set -e: Sai em caso de erro
set -e

# set -u: Erro em variável indefinida
set -u

# set -o pipefail: Pipeline falha se qualquer comando falhar
set -o pipefail

# Combinação comum
set -euo pipefail

> 💡 Dica: `set -euo pipefail` é o "trio de segurança" dos scripts de produção — `-e` para em qualquer erro, `-u` pega variáveis indefinidas, `-o pipefail` faz as falhas do pipeline se propagarem. Todo script não trivial deve incluir essa linha.

# trap: Executa limpeza ao receber sinal ou ao sair
trap 'echo "Script interrupted"; exit 1' INT TERM
trap 'rm -f /tmp/tempfile; echo "Cleanup done"' EXIT

> 💡 Dica: O `trap` consegue executar limpeza automaticamente quando o script termina — seja em finalização normal ou interrompido com Ctrl+C, o `trap EXIT` é acionado. Usos comuns: apagar arquivos temporários, liberar locks de arquivo, restaurar configurações. Coloque `trap 'rm -f $TMPFILE' EXIT` no topo e você não precisa se preocupar com limpeza manual em cada ponto de saída.

# Handler customizado de erro
error_handler() {
    echo "❌ Error on line $1"
    echo "Command: $2"
    exit 1
}
trap 'error_handler $LINENO "$BASH_COMMAND"' ERR

# Sintaxe do getopts
while getopts "f:o:hv" opt; do
    case $opt in
        f) INPUT_FILE="$OPTARG" ;;   # -f nome_do_arquivo
        o) OUTPUT_DIR="$OPTARG" ;;   # -o saída
        h) show_help; exit 0 ;;      # -h ajuda
        v) VERBOSE=true ;;           # -v verbose
        *) echo "Unknown option"; exit 1 ;;
    esac
done

> ℹ️ Nota: O `getopts` é o parser de parâmetros nativo do bash — na string de opções `"f:o:hv"`, os dois-pontos `:` indicam que a opção exige um argumento (ex.: `-f nome_do_arquivo`), sem dois-pontos significa que é uma flag (ex.: `-v`). Ele não aceita opções longas (como `--help`); para isso use o comando externo `getopt` ou faça parsing manual.

# Modo debug: mostra cada comando na medida em que executa
set -x

# Desliga o debugging
set +x

# Liga o debugging só num trecho específico
echo "Normal execution"
set -x
echo "This section is traced"
for i in 1 2 3; do echo "$i"; done
set +x
echo "Back to normal"

# Ou já chama o script em modo debug
# bash -x script.sh

#!/bin/bash
# functions-demo.sh - Exemplos de funções

log() {
    local level="${1:-INFO}"
    local message="$2"
    echo "[$(date '+%H:%M:%S')] [$level] $message"
}

die() {
    log "ERROR" "$1"
    exit 1
}

check_dependency() {
    if ! command -v "$1" &> /dev/null; then
        die "Required command '$1' not found"
    fi
}

# Usando as funções
log "INFO" "Starting dependency check..."
check_dependency "git"
check_dependency "node"
log "INFO" "Dependency check passed"

#!/bin/bash
# array-demo.sh - Exemplos de arrays

# Lista de servidores
servers=("web01" "web02" "db01" "cache01")

echo "Server count: ${#servers[@]}"

echo "--- Iterating servers ---"
for server in "${servers[@]}"; do
    echo "Checking: $server"
done

echo "--- Associative array example ---"
declare -A disk_usage
disk_usage[/]="45%"
disk_usage[/home]="62%"
disk_usage[/var]="78%"

for mount in "${!disk_usage[@]}"; do
    echo "$mount: ${disk_usage[$mount]}"
done

#!/bin/bash
# safe-script.sh - Script robusto

set -euo pipefail

cleanup() {
    echo "Cleaning temporary files..."
    rm -f /tmp/temp_*.txt
    echo "Done"
}

error_handler() {
    echo "❌ Error occurred on line $1"
    cleanup
    exit 1
}

trap error_handler ERR
trap cleanup EXIT

echo "Starting execution..."
mkdir -p /tmp/test
touch /tmp/test/file.txt
cat /tmp/test/file.txt
# Se o cat falhar num arquivo inexistente, o script para e dispara o trap ERR

#!/bin/bash
# backup-tool.sh - Ferramenta de backup com parsing de parâmetros

usage() {
    echo "Usage: $0 -s <source_dir> -d <dest_dir> [-c] [-v]"
    echo "  -s  Source directory to back up"
    echo "  -d  Backup destination directory"
    echo "  -c  Compress backup"
    echo "  -v  Verbose output"
    echo "  -h  Show help"
    exit 0
}

# Valores padrão
COMPRESS=false
VERBOSE=false

while getopts "s:d:cvh" opt; do
    case $opt in
        s) SOURCE="$OPTARG" ;;
        d) DEST="$OPTARG" ;;
        c) COMPRESS=true ;;
        v) VERBOSE=true ;;
        h) usage ;;
        *) usage ;;
    esac
done

# Validando parâmetros obrigatórios
if [ -z "$SOURCE" ] || [ -z "$DEST" ]; then
    echo "Error: Must specify -s and -d"
    usage
fi

if [ ! -d "$SOURCE" ]; then
    echo "Error: Source directory '$SOURCE' does not exist"
    exit 1
fi

# Executando o backup
mkdir -p "$DEST"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_NAME="backup_${TIMESTAMP}"

if [ "$COMPRESS" = true ]; then
    tar -czf "${DEST}/${BACKUP_NAME}.tar.gz" "$SOURCE"
    echo "✅ Compressed backup complete: ${DEST}/${BACKUP_NAME}.tar.gz"
else
    cp -r "$SOURCE" "${DEST}/${BACKUP_NAME}"
    echo "✅ Backup complete: ${DEST}/${BACKUP_NAME}"
fi

if [ "$VERBOSE" = true ]; then
    echo "Source: $SOURCE"
    echo "Destination: $DEST"
    echo "Size: $(du -sh "$SOURCE" | cut -f1)"
fi

#!/bin/bash
# debug-demo.sh - Exemplo de debugging

# Só liga o tracing onde o debugging é necessário
echo "Script started PID: $$"

for i in 1 2 3; do
    set -x              # Inicia o tracing
    echo "Loop iteration $i"
    result=$((i * 10))
    echo "Result: $result"
    set +x              # Para o tracing
done

echo "Script execution complete"

#!/bin/bash
# deploy.sh - Script de deploy de nível produção

set -euo pipefail

APP_NAME="webapp"
APP_DIR="/var/www/$APP_NAME"
BACKUP_DIR="/backup/$APP_NAME"
LOG_FILE="/var/log/deploy.log"

# Saída colorida
RED='\033[0;31m'
GREEN='\033[0;32m'
NC='\033[0m'

log() {
    local level="$1"
    local msg="$2"
    echo -e "[$(date '+%Y-%m-%d %H:%M:%S')] [${level}] ${msg}" | tee -a "$LOG_FILE"
}

info()  { log "INFO" "$1"; }
success() { log "INFO" "${GREEN}$1${NC}"; }
error() { log "ERROR" "${RED}$1${NC}"; }

cleanup() {
    info "Cleaning deployment temporary files..."
}

error_handler() {
    error "Deployment failed at line $1"
    error "Command: $BASH_COMMAND"
    cleanup
    exit 1
}

usage() {
    echo "Usage: $0 [options]"
    echo "  -b   Specify Git branch (default: main)"
    echo "  -e   Specify environment (dev/staging/prod)"
    echo "  -n   Skip backup"
    echo "  -h   Show help"
    exit 0
}

trap error_handler ERR
trap cleanup EXIT

# --- Parsing de parâmetros ---
BRANCH="main"
ENV="prod"
SKIP_BACKUP=false

while getopts "b:e:nh" opt; do
    case $opt in
        b) BRANCH="$OPTARG" ;;
        e) ENV="$OPTARG" ;;
        n) SKIP_BACKUP=true ;;
        h) usage ;;
        *) usage ;;
    esac
done

# --- Checagem de ambiente ---
info "Starting deployment of $APP_NAME (branch: $BRANCH, environment: $ENV)"

if [ ! -d "$APP_DIR" ]; then
    error "Application directory $APP_DIR does not exist"
    exit 1
fi

# --- Backup ---
if [ "$SKIP_BACKUP" = false ]; then
    info "Backing up current version..."
    TIMESTAMP=$(date +%Y%m%d_%H%M%S)
    mkdir -p "$BACKUP_DIR"
    tar -czf "${BACKUP_DIR}/${TIMESTAMP}.tar.gz" \
        --exclude=node_modules \
        --exclude=.git \
        "$APP_DIR"
    success "Backup complete: ${BACKUP_DIR}/${TIMESTAMP}.tar.gz"
fi

# --- Deploy ---
cd "$APP_DIR"

info "Pulling latest code..."
git fetch origin
git checkout "$BRANCH"
git pull origin "$BRANCH"

info "Installing dependencies..."
npm ci --production

info "Building application..."
if [ "$ENV" = "production" ]; then
    npm run build:prod
else
    npm run build
fi

info "Restarting service..."
pm2 restart "$APP_NAME" || pm2 start npm --name "$APP_NAME" -- start

# --- Health check ---
info "Running health check..."
sleep 3
if curl -s -o /dev/null -w "%{http_code}" http://localhost:3000/health | grep -q "200"; then
    success "✅ Deployment successful! Health check passed"
else
    error "❌ Health check failed, please investigate manually"
    exit 1
fi