Entendendo Agendamento de Tarefas no Linux
O agendamento de tarefas é um dos pilares da automação em sistemas Linux. Diferentemente de sistemas operacionais com interface gráfica que permitem agendar tarefas facilmente, no Linux você controla esse mecanismo através de ferramentas de linha de comando poderosas e flexíveis. A necessidade de automatizar tarefas surge em qualquer ambiente: backups periódicos, limpeza de logs, sincronização de dados, scripts de monitoramento. Sem agendamento, você teria que executar essas ações manualmente ou manter processos sempre rodando, desperdiçando recursos.
Existem dois principais mecanismos nativos para agendamento no Linux: cron e at. Ambos servem propósitos diferentes. Cron é ideal para tarefas recorrentes (diárias, horárias, semanais), enquanto at é melhor para executar uma tarefa uma única vez em um momento específico. Neste artigo, exploraremos ambos em profundidade, desde conceitos fundamentais até casos de uso práticos.
Cron: Automação Recorrente
O que é Cron e Como Funciona
Cron é um daemon (serviço de fundo) que executa comandos ou scripts em intervalos regulares pré-definidos. Ele está disponível em praticamente todos os sistemas Unix-like (Linux, macOS, BSD). O cron lê um arquivo de configuração chamado crontab (tabela de cron) de cada usuário e verifica a cada minuto se existe alguma tarefa agendada para ser executada naquele momento.
O arquivo crontab não é editado diretamente no sistema de arquivos. Em vez disso, você usa o comando crontab -e, que abre um editor de texto temporário. Quando você salva e fecha o editor, cron automaticamente valida a sintaxe e armazena o arquivo em um local seguro (geralmente /var/spool/cron/crontabs/ ou /var/spool/cron/).
Sintaxe e Formato do Crontab
A sintaxe do crontab segue um padrão específico com cinco campos, seguidos do comando a executar:
┌───────────── minuto (0 - 59)
│ ┌───────────── hora (0 - 23)
│ │ ┌───────────── dia do mês (1 - 31)
│ │ │ ┌───────────── mês (1 - 12)
│ │ │ │ ┌───────────── dia da semana (0 - 7, onde 0 e 7 representam domingo)
│ │ │ │ │
│ │ │ │ │
* * * * * comando_a_executar
Cada campo aceita números, intervalos (com hífen -), listas (com vírgula ,), ou o asterisco * (que significa "qualquer valor"). Também existe o operador / para definir incrementos. Vamos a alguns exemplos práticos:
# Executar todo dia às 2 da manhã
0 2 * * * /usr/local/bin/backup.sh
# A cada 15 minutos, toda hora
*/15 * * * * /usr/local/bin/check_status.sh
# De segunda a sexta às 9 da manhã
0 9 * * 1-5 /usr/local/bin/weekly_report.sh
# No primeiro dia de cada mês às 00:00
0 0 1 * * /usr/local/bin/monthly_cleanup.sh
# A cada 6 horas
0 */6 * * * /usr/local/bin/sync_data.sh
# Toda segunda às 18:30
30 18 * * 1 /usr/local/bin/deploy_staging.sh
Criando e Gerenciando Crontabs
Para editar seu crontab pessoal, execute:
crontab -e
Isso abrirá o editor padrão do seu sistema (vi, nano, etc.). Adicione suas tarefas, salve e saia. Para listar suas tarefas agendadas:
crontab -l
Para remover completamente seu crontab:
crontab -r
Se você é administrador e precisa gerenciar o crontab de outro usuário:
sudo crontab -u nomedousuario -e
sudo crontab -u nomedousuario -l
Exemplo Prático: Script de Backup Agendado
Vamos criar um script de backup real que será executado diariamente. Primeiro, crie o script:
#!/bin/bash
# /usr/local/bin/backup_home.sh
BACKUP_DIR="/backups/home"
SOURCE_DIR="/home/usuario"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="$BACKUP_DIR/backup_$DATE.tar.gz"
# Criar diretório se não existir
mkdir -p "$BACKUP_DIR"
# Executar backup com compressão
tar -czf "$BACKUP_FILE" "$SOURCE_DIR" 2>&1 >> /var/log/backup.log
# Remover backups mais antigos que 30 dias
find "$BACKUP_DIR" -type f -name "backup_*.tar.gz" -mtime +30 -delete
echo "[$(date '+%Y-%m-%d %H:%M:%S')] Backup concluído: $BACKUP_FILE" >> /var/log/backup.log
Torne o script executável:
sudo chmod +x /usr/local/bin/backup_home.sh
Agora, adicione ao crontab para executar diariamente às 3 da manhã:
sudo crontab -e
Adicione esta linha:
0 3 * * * /usr/local/bin/backup_home.sh
Trabalhando com Variáveis e Saída
Dentro do crontab, você pode definir variáveis de ambiente que serão usadas por seus comandos. Isso é útil para definir o shell, PATH, e outras configurações:
SHELL=/bin/bash
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=admin@empresa.com
HOME=/root
# Executar script Python com saída redirecionada
0 1 * * * /usr/bin/python3 /opt/scripts/generate_report.py >> /var/log/report.log 2>&1
# Executar e enviar saída por email
0 6 * * * /usr/local/bin/system_health_check.sh 2>&1 | mail -s "Relatório Diário" admin@empresa.com
A variável MAILTO é especialmente útil: qualquer saída do comando (stdout e stderr) será enviada para esse endereço de email.
At: Execução Única em Tempo Específico
Diferenças Entre At e Cron
Enquanto cron é para tarefas recorrentes, at é para executar uma tarefa uma única vez em um momento específico no futuro. Você especifica a data e hora exatas, e o at garante que o comando seja executado naquele momento. Isso é perfeito para manutenções programadas, testes únicos, ou tarefas que não precisam ser repetidas.
O daemon atd gerencia as tarefas agendadas com at. Certifique-se de que está rodando:
sudo systemctl status atd
sudo systemctl start atd
sudo systemctl enable atd # Para iniciar automaticamente
Usando o Comando At
A sintaxe básica do at é simples. Você especifica o tempo de execução seguido do comando:
at [hora] [data]
Vamos aos exemplos práticos:
# Executar amanhã às 14:00
echo "cd /var/www && ./deploy.sh" | at 14:00 tomorrow
# Executar em uma data específica
echo "mysqldump -u root -p12345 database > /backups/db_backup.sql" | at 10:30 2024-12-25
# Executar daqui a 2 horas
echo "/usr/local/bin/system_cleanup.sh" | at now + 2 hours
# Executar daqui a 30 minutos
echo "systemctl restart nginx" | at now + 30 minutes
# Executar em 3 dias
echo "/home/usuario/importante.sh" | at 09:00 + 3 days
Para agendar usando um script completo, você pode fazer:
at 22:00 today << 'EOF'
#!/bin/bash
DATE=$(date +%Y%m%d)
mysqldump -u root -psenha database > /backups/db_$DATE.sql
gzip /backups/db_$DATE.sql
EOF
Listando e Removendo Tarefas At
Para listar todas as suas tarefas agendadas:
atq
Este comando mostra um número de ID para cada tarefa, a data/hora e outras informações.
Para visualizar o conteúdo de uma tarefa específica:
at -c [ID]
Para remover uma tarefa:
atrm [ID]
Exemplo completo:
# Agendar uma tarefa
at 18:30 today
tar -czf /backups/quick_backup.tar.gz /home/dados
Ctrl+D # Pressione Ctrl+D para finalizar
# Listar
atq
# Saída: 1 Wed Dec 20 18:30:00 2024 a nomedousuario
# Remover a tarefa
atrm 1
Exemplo Prático: Manutenção Programada com At
Imagine que você precisa fazer uma manutenção no servidor em uma data específica. Crie um script:
#!/bin/bash
# /usr/local/bin/maintenance.sh
LOG_FILE="/var/log/maintenance.log"
echo "[$(date)] Iniciando manutenção..." >> "$LOG_FILE"
# Parar serviços
systemctl stop nginx >> "$LOG_FILE" 2>&1
systemctl stop php-fpm >> "$LOG_FILE" 2>&1
# Fazer backup do banco de dados
mysqldump -u root -psenha todosbancos > /backups/pre_maintenance_$(date +%s).sql
# Executar atualizações
apt-get update >> "$LOG_FILE" 2>&1
apt-get upgrade -y >> "$LOG_FILE" 2>&1
# Reiniciar serviços
systemctl start php-fpm >> "$LOG_FILE" 2>&1
systemctl start nginx >> "$LOG_FILE" 2>&1
echo "[$(date)] Manutenção concluída com sucesso" >> "$LOG_FILE"
Agora, agende para executar em 3 dias às 22:00:
echo "/usr/local/bin/maintenance.sh" | at 22:00 + 3 days
Verifique a agenda:
atq
at -c 1 # Visualiza a tarefa
Monitoramento, Logs e Troubleshooting
Verificando Logs do Cron
O cron mantém registros de tudo que executa. Para visualizar esses logs no Ubuntu/Debian:
grep CRON /var/log/syslog
Em CentOS/RHEL:
tail -f /var/log/cron
Para ver especificamente se seu script foi executado:
grep "backup_home.sh" /var/log/syslog
Capturando e Monitorando Saída
Um erro comum é não capturar a saída dos comandos cron. Se seu script funciona manualmente mas não funciona agendado, geralmente é por falta de path absoluto ou variáveis de ambiente. Sempre redirecione saída para um arquivo de log:
# Bom - captura stdout e stderr
0 2 * * * /usr/local/bin/backup.sh >> /var/log/backup.log 2>&1
# Melhor - com timestamp
0 2 * * * /usr/local/bin/backup.sh >> /var/log/backup.log 2>&1 ; echo "[$(date)] Backup executado" >> /var/log/backup.log
Problemas Comuns e Soluções
Problema: Script não executa no cron, mas executa manualmente
Solução: Use paths absolutos para tudo. O cron não herda o PATH do seu usuário completamente.
# Errado
0 2 * * * backup.sh
# Correto
0 2 * * * /usr/local/bin/backup.sh
Problema: Cron executa mas variáveis de ambiente não estão disponíveis
Solução: Defina as variáveis no crontab ou carregue um arquivo de configuração no script:
# No seu script, carregue variáveis
#!/bin/bash
source /etc/environment
source /home/usuario/.bashrc
# Ou no crontab
JAVA_HOME=/usr/lib/jvm/java-11
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin
0 2 * * * /usr/local/bin/java_app.sh
Problema: At não está funcionando
Solução: Verifique se o daemon está rodando e se você tem permissão:
sudo systemctl status atd
# Se não estiver rodando:
sudo systemctl start atd
sudo systemctl enable atd
# Verifique se você está na lista de permissão
cat /etc/at.allow # Se existir, você deve estar aqui
cat /etc/at.deny # Se você está aqui, será negado
Boas Práticas de Segurança
Nunca coloque senhas diretamente nos scripts ou crontabs. Use arquivos de configuração protegidos:
#!/bin/bash
# /usr/local/bin/secure_backup.sh
# Carrega credenciais de arquivo protegido
source /etc/myapp.conf # chmod 600
# Usa a variável
mysqldump -u root -p"$DB_PASSWORD" mydatabase > /backups/backup.sql
Arquivo de configuração:
# /etc/myapp.conf
# chmod 600 /etc/myapp.conf
DB_PASSWORD="sua_senha_aqui"
DB_USER="root"
DB_NAME="mydatabase"
Restrinja permissões nos arquivos crontab:
ls -la /var/spool/cron/crontabs/
# Deve mostrar: -rw------- 1 usuario crontab
Conclusão
Você aprendeu que agendamento de tarefas é essencial para qualquer infraestrutura Linux, e dominar cron e at o tornará um administrador muito mais eficiente. Cron é sua ferramenta principal para tarefas recorrentes — backups, limpeza, sincronização — enquanto at resolve o problema de executar algo uma única vez em um momento específico. O terceiro ponto crucial é entender que logs e redirecionamento de saída são não-negociáveis: sem capturar a saída dos seus scripts agendados, você ficará cego quando algo não funcionar. Sempre use paths absolutos, defina variáveis de ambiente explicitamente, e monitore os logs do sistema.