Cron e crontab: agendando tarefas

1. Introdução ao Cron e Crontab

O Cron é um daemon (serviço em segundo plano) presente em sistemas Unix/Linux responsável por executar comandos ou scripts automaticamente em intervalos de tempo pré-definidos. Ele funciona como um relógio inteligente que dispara tarefas nos momentos exatos configurados pelo usuário.

O Crontab (abreviação de "cron table") é o arquivo de configuração que cada usuário possui para definir suas tarefas agendadas. Cada linha desse arquivo representa uma tarefa, contendo o momento da execução e o comando a ser executado.

Casos de uso típicos incluem:
- Realizar backups automáticos de diretórios importantes
- Limpeza de logs antigos para liberar espaço em disco
- Scripts de manutenção do sistema, como atualizações e verificações
- Envio de relatórios periódicos por e-mail
- Monitoramento de recursos do servidor

2. Sintaxe do Crontab

A sintaxe básica de uma entrada no crontab é composta por cinco campos de tempo seguidos pelo comando a ser executado:

* * * * * comando
- - - - -
| | | | |
| | | | +--- dia da semana (0-7, onde 0 e 7 representam domingo)
| | | +----- mês (1-12)
| | +------- dia do mês (1-31)
| +--------- hora (0-23)
+----------- minuto (0-59)

Exemplos práticos:

# Executar todos os dias às 2h da manhã
0 2 * * * /usr/local/bin/backup.sh

# Executar a cada 15 minutos
*/15 * * * * /opt/scripts/check_status.sh

# Executar de segunda a sexta às 18h30
30 18 * * 1-5 /usr/bin/gerar_relatorio.sh

# Executar nos dias 1 e 15 de cada mês às 5h
0 5 1,15 * * /usr/local/bin/cleanup.sh

# Executar a cada 2 horas durante o horário comercial
0 8-18/2 * * 1-5 /opt/scripts/monitor.sh

3. Gerenciando Crontabs com Comandos

O gerenciamento das tarefas agendadas é feito através do comando crontab com as seguintes opções:

# Listar todas as tarefas do usuário atual
crontab -l

# Editar o arquivo crontab (abre o editor padrão)
crontab -e

# Remover todas as tarefas do usuário atual
crontab -r

# Editar o crontab de outro usuário (requer privilégios de root)
sudo crontab -u usuario -e

Cuidados importantes:
- Sempre verifique a sintaxe antes de salvar: crontab -l mostra o conteúdo atual
- Faça backup do crontab atual antes de editar: crontab -l > backup_crontab.txt
- Evite editar o arquivo diretamente em /var/spool/cron/crontabs/
- Permissões inadequadas podem impedir a execução dos scripts

4. Variáveis de Ambiente e Caminhos

O cron executa comandos em um ambiente mínimo, sem as variáveis de ambiente do shell interativo. Por isso, é essencial configurar explicitamente as variáveis necessárias:

# Definindo PATH no crontab
PATH=/usr/local/bin:/usr/bin:/bin
SHELL=/bin/bash
MAILTO=admin@exemplo.com

# Tarefa que depende do PATH configurado
30 4 * * * backup.sh

# Redirecionamento de saída para arquivo de log
0 2 * * * /usr/local/bin/script.sh >> /var/log/meu_script.log 2>&1

Explicação das variáveis:
- PATH: caminhos onde o cron procurará pelos comandos
- SHELL: shell a ser utilizado para executar os comandos
- MAILTO: endereço de e-mail para receber a saída dos comandos
- 2>&1: redireciona erros (stderr) para a mesma saída padrão (stdout)

5. Escrevendo Scripts para o Cron

Boas práticas ao criar scripts que serão executados pelo cron:

#!/bin/bash
# Script: /usr/local/bin/backup.sh

# Caminhos absolutos evitam problemas com PATH
ORIGEM="/home/usuario/documentos"
DESTINO="/backup/documentos"
LOG="/var/log/backup.log"

# Adiciona timestamp às mensagens de log
echo "$(date '+%Y-%m-%d %H:%M:%S') - Iniciando backup" >> "$LOG"

# Executa o backup com tratamento de erros
if tar -czf "$DESTINO/backup_$(date +%Y%m%d_%H%M%S).tar.gz" "$ORIGEM" 2>> "$LOG"; then
    echo "$(date) - Backup concluído com sucesso" >> "$LOG"
    exit 0
else
    echo "$(date) - ERRO: Falha no backup" >> "$LOG"
    exit 1
fi

Recomendações:
- Use caminhos absolutos em todos os comandos
- Defina shebang (#!/bin/bash) na primeira linha
- Torne o script executável: chmod +x script.sh
- Implemente logging detalhado com timestamps
- Utilize códigos de saída apropriados (exit 0 para sucesso, exit 1 para erro)

6. Exemplos Práticos de Tarefas Agendadas

Backup de diretório com timestamp

# Executa todo domingo às 3h da manhã
0 3 * * 0 /usr/local/bin/backup.sh

Limpeza de logs antigos

# Remove arquivos de log com mais de 30 dias, todos os dias às 4h30
30 4 * * * find /var/log -name "*.log" -mtime +30 -delete >> /var/log/cleanup.log 2>&1

Monitoramento de disco

# Verifica uso do disco a cada 10 minutos e alerta se acima de 90%
*/10 * * * * /opt/scripts/check_disk.sh

Conteúdo do script check_disk.sh:

#!/bin/bash
USO=$(df / | awk 'NR==2 {print $5}' | sed 's/%//')
if [ "$USO" -gt 90 ]; then
    echo "ALERTA: Disco com $USO% de uso" | mail -s "Alerta de Disco" admin@exemplo.com
fi

7. Depuração e Solução de Problemas

Verificando logs do cron

# No Ubuntu/Debian
tail -f /var/log/syslog | grep CRON

# No CentOS/RHEL
tail -f /var/log/cron

Testando scripts manualmente

# Teste o script antes de agendar
/usr/local/bin/meu_script.sh

# Simule o ambiente do cron
env -i HOME=$HOME PATH=/usr/bin:/bin /bin/bash /usr/local/bin/meu_script.sh

Problemas comuns e soluções

Problema Causa provável Solução
Script não executa PATH ausente Defina PATH no crontab
Comando não encontrado Caminho relativo Use caminhos absolutos
Saída não aparece Redirecionamento ausente Adicione >> log.txt 2>&1
Permissão negada Script sem execução chmod +x script.sh

8. Considerações de Segurança e Boas Práticas

Restrições de acesso ao cron

# /etc/cron.allow - apenas usuários listados podem usar cron
root
joao
maria

# /etc/cron.deny - usuários proibidos de usar cron
convidado
teste

Evitando tarefas sobrepostas

#!/bin/bash
# Script com controle de concorrência usando flock

LOCKFILE="/tmp/meu_script.lock"

# Tenta adquirir o lock; se falhar, sai imediatamente
flock -n "$LOCKFILE" || exit 1

# Coloca o PID no arquivo de lock
echo $$ > "$LOCKFILE"

# Corpo do script...
sleep 300  # Simula processamento longo

# Libera o lock ao final
rm -f "$LOCKFILE"

Boas práticas adicionais

  • Documente todas as tarefas: Adicione comentários descritivos no crontab
  • Versionamento: Mantenha os scripts em um repositório Git
  • Notificações: Configure alertas para falhas críticas
  • Teste em ambiente controlado: Valide scripts antes de colocar em produção
  • Monitore regularmente: Verifique se as tarefas estão executando conforme esperado

Com essas práticas, você estará apto a gerenciar tarefas agendadas de forma eficiente e segura utilizando cron e crontab em seus sistemas Unix/Linux.

Referências