Operações em Lote: Poder do Processamento em Massa 🚀

Ferramentas Fundamentais

🔍 Find e Xargs

# Operações básicas
find . -type f -name "*.log" -exec rm {} \;    # Remove logs
find . -mtime +30 | xargs rm -f               # Remove arquivos antigos
find . -size +100M -exec mv {} /backup/ \;    # Move arquivos grandes

📋 Parallel

# Processamento paralelo
find . -type f | parallel gzip     # Compacta em paralelo
cat lista.txt | parallel wget {}   # Downloads paralelos
ls *.jpg | parallel convert {} {.}.png  # Conversão em massa

Scripts de Processamento

🔄 Processador em Lote

#!/bin/bash
# batch_processor.sh

process_files() {
    local dir="$1"
    local pattern="$2"
    local action="$3"
    local max_procs="${4:-4}"
    
    find "$dir" -type f -name "$pattern" | \
    parallel -j "$max_procs" "$action"
}

# Exemplo de uso:
# process_files /data "*.txt" "gzip" 8

📦 Compactação em Massa

#!/bin/bash
# mass_compress.sh

compress_directory() {
    local src="$1"
    local dest="${2:-compressed}"
    local threads="${3:-$(nproc)}"
    
    mkdir -p "$dest"
    
    find "$src" -type f -size +1M | \
    parallel -j "$threads" \
        "gzip -c {} > $dest/{/.}.gz"
}

Transformação de Dados

📊 Processamento de Texto

#!/bin/bash
# text_processor.sh

process_text_files() {
    local pattern="$1"
    local search="$2"
    local replace="$3"
    
    find . -type f -name "$pattern" | \
    parallel sed -i "s/$search/$replace/g" {}
}

🖼️ Processamento de Imagens

#!/bin/bash
# image_processor.sh

process_images() {
    local dir="$1"
    local size="$2"
    
    find "$dir" -type f \( -name "*.jpg" -o -name "*.png" \) | \
    parallel convert {} -resize "$size" {}_resized
}

Otimização e Performance

⚡ Controle de Recursos

#!/bin/bash
# resource_control.sh

batch_with_limits() {
    local cmd="$1"
    local max_load="$2"
    local max_procs="$3"
    
    parallel --load "$max_load" \
             --jobs "$max_procs" \
             "$cmd"
}

🎯 Monitoramento de Progresso

#!/bin/bash
# progress_monitor.sh

monitor_progress() {
    local total="$1"
    local current="$2"
    local width=50
    
    local percent=$((current * 100 / total))
    local filled=$((width * current / total))
    
    printf "\rProgresso: [%-${width}s] %d%%" \
           "$(printf '#%.0s' $(seq 1 "$filled"))" "$percent"
}

Exercícios Práticos

🎯 Missão 1: Processamento de Logs

# Desenvolva um sistema que:
# 1. Encontre logs antigos
# 2. Comprima em paralelo
# 3. Mova para armazenamento
# 4. Gere relatório

🎯 Missão 2: Transformação de Dados

# Crie um pipeline que:
# 1. Processe múltiplos formatos
# 2. Aplique transformações
# 3. Valide resultados
# 4. Gere backups

Troubleshooting

🔧 Problemas Comuns

Sobrecarga do sistema: Ajuste número de processos
Erros de permissão: Verifique acessos
Memória insuficiente: Controle tamanho do lote
Deadlocks: Implemente timeouts

📋 Checklist de Verificação

# Verificações do sistema
uptime                 # Carga do sistema
free -h               # Memória disponível
df -h                # Espaço em disco
ulimit -a           # Limites do sistema

Próximos Passos

    PROCESSAMENTO EM LOTE
    [⚡⚡⚡⚡⚡⚡⚡⚡] 100%
    EFICIÊNCIA: MÁXIMA
    RECURSOS: OTIMIZADOS

14 abril 2025