Automatizar tarefas reduz erros humanos

O custo do erro humano

Estudos do setor de TI consistentemente apontam que entre 60% e 80% das interrupções de serviço são causadas por erro humano — não por falha de hardware ou software. Operações manuais repetidas inevitavelmente acumulam erros: um passo pulado, um parâmetro errado, um arquivo sobrescrito acidentalmente.

Automação não é sobre substituir pessoas — é sobre remover a pessoa do caminho nas tarefas repetíveis e previsíveis, liberando atenção humana para as tarefas que realmente exigem julgamento.

Exemplos de automação com impacto real

Backup automatizado com verificação

Backup manual é backup que eventualmente não é feito. Script com verificação de integridade e alerta em caso de falha:

#!/bin/bash
# /etc/cron.daily/backup-banco
DATE=$(date +%Y%m%d_%H%M)
DEST="/backup/db_\${DATE}.sql.gz"
LOG="/var/log/backup.log"

echo "[$DATE] Iniciando backup" >> $LOG
mysqldump -u root --all-databases | gzip > $DEST

if [ $? -eq 0 ] && [ -s "$DEST" ]; then
    SIZE=$(du -sh "$DEST" | cut -f1)
    echo "[$DATE] Backup OK - Tamanho: $SIZE" >> $LOG
    # Enviar para storage offsite
    rsync -az "$DEST" [email protected]:/offsite/
else
    echo "[$DATE] ERRO no backup" >> $LOG
    echo "Falha no backup de $(hostname)" | \
        mail -s "[ALERTA] Backup falhou" [email protected]
fi

# Remover backups com mais de 30 dias
find /backup/ -name "db_*.sql.gz" -mtime +30 -delete

Renovação de certificado SSL

Certificado vencido é um dos erros mais evitáveis e mais comuns. O Certbot automatiza isso, mas é preciso garantir que está configurado:

# Verificar se o timer está ativo
systemctl is-enabled certbot.timer

# Adicionar verificação explícita ao monitoramento
EXPIRY_DAYS=$(echo | openssl s_client -connect meudominio.com.br:443 2>/dev/null \
    | openssl x509 -noout -enddate \
    | cut -d= -f2 \
    | xargs -I{} date -d {} +%s \
    | xargs -I{} echo "( {} - $(date +%s) ) / 86400" | bc)
[ "$EXPIRY_DAYS" -lt 30 ] && echo "SSL vence em $EXPIRY_DAYS dias"

Rotação de logs

Disco cheio por logs não rotacionados é uma falha completamente evitável. Configure logrotate para todos os serviços:

# /etc/logrotate.d/minha-app
/var/log/minha-app/*.log {
    daily
    missingok
    rotate 14
    compress
    delaycompress
    notifempty
    postrotate
        systemctl kill -s HUP minha-app
    endscript
}

Scripts shell práticos

Verificação diária de saúde do servidor

#!/bin/bash
# health-check.sh — executar via cron todo dia às 8h
HOSTNAME=$(hostname)
ERROS=""

# Disco
DISCO=$(df / | tail -1 | awk '{print $5}' | sed 's/%//')
[ "$DISCO" -gt 80 ] && ERROS+="DISCO: \${DISCO}% em uso\n"

# Memória
MEM_LIVRE=$(free -m | awk '/^Mem:/{print $4}')
[ "$MEM_LIVRE" -lt 200 ] && ERROS+="MEMÓRIA: apenas \${MEM_LIVRE}MB livre\n"

# Serviços críticos
for SVC in nginx php8.2-fpm mysql; do
    systemctl is-active --quiet $SVC || ERROS+="SERVIÇO: $SVC não está rodando\n"
done

# Enviar relatório
if [ -n "$ERROS" ]; then
    echo -e "Problemas em $HOSTNAME:\n$ERROS" | \
        mail -s "[ALERTA] $HOSTNAME" [email protected]
fi

O que automatizar primeiro

Priorize a automação das tarefas com maior impacto de erro e maior frequência:

1. Backup — falha silenciosa com consequência catastrófica
2. Verificação de serviços críticos — descobrir antes do usuário
3. Rotação de logs — disco cheio é silencioso e frequente
4. Renovação de SSL — vencimento é previsível mas frequentemente esquecido
5. Aplicação de patches de segurança — unattended-upgrades

Cuidados na automação

• Sempre teste o script em ambiente não-produtivo antes de colocar no cron
• Todo script deve ter logging — saber que rodou (ou que falhou) é parte da automação
• Automações devem ter alertas em caso de falha — automação silenciosa que falha é pior que processo manual
• Documente o que cada script faz e onde está configurado

Conclusão

As automações mais valiosas não são as mais sofisticadas — são as que eliminam os erros que ocorrem com maior frequência. Começar pelos scripts de backup, verificação de saúde e rotação de logs já transforma significativamente a confiabilidade de um ambiente Linux.