Agendar Tarefas no Red Hat Enterprise Linux

Introdução

Neste laboratório, você obterá experiência prática no agendamento de tarefas em sistemas RHEL usando várias ferramentas. Você aprenderá a agendar tarefas únicas com o comando at, gerenciar tarefas recorrentes específicas do usuário usando crontab e configurar tarefas recorrentes em todo o sistema com diretórios cron.

Além disso, este laboratório cobrirá técnicas avançadas de agendamento usando timers systemd para uma automação de tarefas mais robusta e flexível, e demonstrará como gerenciar arquivos temporários de forma eficiente com systemd-tmpfiles. Ao final deste laboratório, você estará proficiente em escolher o método de agendamento apropriado para diferentes cenários e gerenciar efetivamente tarefas automatizadas em um ambiente RHEL.

Agendar um trabalho único com 'at'

Nesta etapa, você aprenderá como agendar um trabalho para ser executado uma única vez em um futuro momento usando o comando at. O comando at é útil para executar comandos que não precisam ser executados repetidamente. Agendaremos um trabalho simples, inspecionaremos seus detalhes e, em seguida, o removeremos.

Neste laboratório, trabalharemos diretamente no sistema local para aprender o agendamento de tarefas. Todos os comandos serão executados em seu ambiente de terminal atual.

Vamos agendar um trabalho para imprimir a data e hora atuais em um arquivo chamado ~/myjob.txt em seu diretório pessoal. Agendaremos para ser executado em 3 minutos a partir de agora:

at now + 3 minutes << EOF
date > ~/myjob.txt
EOF

A mensagem warning: commands will be executed using /bin/sh é normal. A saída job N at ... indica o número do trabalho e o horário de execução agendado. Anote o número do trabalho, pois você precisará dele mais tarde.

Em seguida, vamos agendar outro trabalho interativamente. Este método é útil para inserir vários comandos ou scripts mais complexos. Agendaremos um trabalho para anexar "Hello from at job!" a ~/at_output.txt em 5 minutos a partir de agora:

at now + 5 minutes

Após digitar o comando e pressionar Enter, você verá um prompt at>. Digite seu comando e, em seguida, pressione Ctrl+d para finalizar:

at > echo "Hello from at job!" >> ~/at_output.txt
at > Ctrl+d

Para visualizar os trabalhos atualmente na fila do at, use o comando atq. Este comando lista todos os trabalhos at pendentes para o usuário atual.

atq

A saída mostrará o número do trabalho, o horário agendado, a fila e o usuário que o agendou.

Você pode inspecionar os comandos que um trabalho at específico executará usando o comando at -c seguido pelo número do trabalho. Substitua N por um dos números de trabalho que você anotou anteriormente.

at -c N

Este comando exibirá o script shell que o at executará para esse trabalho. Você deverá ver o comando date > ~/myjob.txt ou echo "Hello from at job!" >> ~/at_output.txt dentro da saída.

Finalmente, para remover um trabalho at agendado, use o comando atrm seguido pelo número do trabalho. Vamos remover o primeiro trabalho que agendamos. Substitua N pelo número do trabalho do seu primeiro trabalho.

atrm N

Após remover o trabalho, você pode usar atq novamente para verificar se ele não está mais na fila.

atq

Você deverá ver apenas o segundo trabalho (se ele ainda não foi executado) ou uma fila vazia se ambos os trabalhos foram removidos ou executados.

Isso conclui a primeira etapa de agendamento de trabalhos únicos com o comando at.

Gerenciar trabalhos 'at'

Nesta etapa, você se aprofundará no gerenciamento de trabalhos at, incluindo o agendamento de trabalhos com diferentes filas e a verificação de sua execução. Compreender as filas at pode ser útil para priorizar tarefas ou separar diferentes tipos de trabalhos únicos.

Continuaremos trabalhando no sistema local para explorar recursos mais avançados de gerenciamento de trabalhos at.

O comando at permite especificar uma fila usando a opção -q. As filas são letras únicas de a a z. A fila a é a padrão, e os trabalhos nas filas a a z são executados com niceness (prioridade) decrescente. A fila a tem a maior prioridade, e a fila z tem a menor. A fila b é reservada para trabalhos em lote (batch jobs).

Vamos agendar um trabalho na fila g (uma fila de menor prioridade) para ser executado em 2 minutos. Este trabalho criará um arquivo chamado ~/queue_g_job.txt com um timestamp:

at -q g now + 2 minutes << EOF
date > ~/queue_g_job.txt
EOF

Você verá uma saída semelhante a job N at .... Anote este número de trabalho.

Em seguida, vamos agendar outro trabalho, desta vez na fila b (fila de lote), que é tipicamente usada para trabalhos que podem ser executados quando a carga do sistema está baixa. Este trabalho adicionará "Batch job executed!" a ~/batch_job.txt. Vamos agendá-lo para ser executado em 4 minutos a partir de agora:

at -q b now + 4 minutes << EOF
echo "Batch job executed!" >> ~/batch_job.txt
EOF

Novamente, anote o número do trabalho.

Para ver todos os trabalhos pendentes, incluindo aqueles em diferentes filas, use atq.

atq

Agora você deve ver ambos os trabalhos listados, com suas respectivas letras de fila (g e b).

Agora, espere seus trabalhos agendados serem executados. Espere pelo menos 5 minutos para permitir que todos os trabalhos sejam concluídos. Você pode verificar se os arquivos criados por seus trabalhos at existem e contêm o conteúdo esperado.

Verifique ~/queue_g_job.txt:

cat ~/queue_g_job.txt

Você deve ver uma string de data e hora.

Verifique ~/batch_job.txt:

cat ~/batch_job.txt

Você deve ver "Batch job executed!".

Se os arquivos não estiverem presentes ou estiverem vazios, isso pode significar que os trabalhos ainda não foram executados, ou houve um problema com o comando. Você pode verificar atq novamente para ver se eles ainda estão pendentes.

Isso conclui a etapa avançada de gerenciamento de trabalhos at. Os trabalhos at restantes serão automaticamente limpos quando o contêiner for destruído.

Agendar tarefas recorrentes do usuário com 'crontab'

Nesta etapa, aprenderá a agendar tarefas recorrentes para um utilizador específico utilizando crontab. Ao contrário dos trabalhos at, que são executados uma vez, os trabalhos cron são executados repetidamente em intervalos especificados. Isto é ideal para manutenção de rotina, cópias de segurança de dados ou geração de relatórios.

Continuaremos a trabalhar no sistema local para aprender sobre a gestão de crontab de utilizador.

O comando crontab permite aos utilizadores criar, editar e visualizar os seus próprios trabalhos cron. Cada utilizador tem o seu próprio ficheiro crontab.

Para editar o seu ficheiro crontab, utilize o comando crontab -e. Isto abrirá o seu ficheiro crontab no editor de texto predefinido (geralmente vim).

crontab -e

Instruções do editor Vim:

• Pressione i para entrar no modo de inserção (verá -- INSERT -- na parte inferior)
• Utilize as teclas de seta para navegar
• Para guardar e sair: Pressione Esc para sair do modo de inserção, digite :wq e pressione Enter
• Para sair sem guardar: Pressione Esc, digite :q! e pressione Enter

Dentro do editor, adicionará uma nova linha para definir o seu trabalho cron. Uma entrada cron tem cinco campos de hora e data, seguidos pelo comando a ser executado. Os campos são:

• Minuto (0-59)
• Hora (0-23)
• Dia do Mês (1-31)
• Mês (1-12)
• Dia da Semana (0-7, onde 0 ou 7 é Domingo)

Pode usar * como um curinga para significar "cada" para um campo, ou / para especificar valores de passo (por exemplo, */5 para cada 5 minutos).

Vamos agendar um trabalho que anexa a data e hora atuais a um ficheiro chamado ~/my_cron_log.txt a cada minuto. Isto permitir-nos-á observar rapidamente o trabalho cron em ação.

Siga estes passos no vim:

1. Pressione i para entrar no modo de inserção
2. Adicione a seguinte linha ao ficheiro crontab:

* * * * * /usr/bin/date >> ~/my_cron_log.txt

3. Pressione Esc para sair do modo de inserção
4. Digite :wq e pressione Enter para guardar e sair

Deverá ver uma mensagem a indicar que um novo crontab foi instalado:

crontab: installing new crontab

Para verificar se o seu trabalho cron foi adicionado com sucesso, pode listar as suas entradas crontab utilizando o comando crontab -l:

crontab -l

Deverá ver a linha que acabou de adicionar:

* * * * * /usr/bin/date >> ~/my_cron_log.txt

Agora, espere um minuto ou dois para permitir que o trabalho cron seja executado pelo menos uma vez. Pode verificar a hora atual para ver quando ocorrerá a próxima marcação de minuto:

date

Após esperar pelo menos dois minutos para permitir que o trabalho cron seja executado algumas vezes, verifique o conteúdo do ficheiro ~/my_cron_log.txt.

cat ~/my_cron_log.txt

Deverá ver uma ou mais linhas, cada uma contendo uma data e hora, indicando que o seu trabalho cron foi executado.

Mon Apr 8 10:30:01 AM EDT 2024
Mon Apr 8 10:31:01 AM EDT 2024

Isto completa a etapa de gestão de crontab de utilizador. O trabalho cron continuará a ser executado até que o contentor seja destruído.

Gerenciar entradas 'crontab' do usuário

Nesta etapa, você aprenderá técnicas mais avançadas para gerenciar entradas crontab do usuário, incluindo a edição de tarefas existentes, a adição de várias tarefas e a compreensão de strings cron especiais. O gerenciamento eficaz do crontab é crucial para automatizar tarefas de rotina.

Continuaremos trabalhando no sistema local para explorar técnicas avançadas de gerenciamento de crontab.

Vamos começar adicionando uma nova tarefa cron. Esta tarefa anexará "Hello from cron!" a ~/cron_messages.txt a cada dois minutos.

Abra seu crontab para edição:

crontab -e

No vim:

1. Pressione i para entrar no modo de inserção
2. Adicione a seguinte linha ao arquivo crontab:

*/2 * * * * echo "Hello from cron!" >> ~/cron_messages.txt

3. Pressione Esc para sair do modo de inserção
4. Digite :wq e pressione Enter para salvar e sair

Verifique se a entrada foi adicionada:

crontab -l

Você deve ver a linha recém-adicionada.

Agora, vamos adicionar outra tarefa cron que é executada diariamente às 08:00 AM. Esta tarefa registrará o uso do disco do seu diretório home em ~/disk_usage.log.

Abra seu crontab para edição novamente:

crontab -e

No vim:

1. Pressione i para entrar no modo de inserção
2. Adicione a seguinte linha abaixo da anterior:

0 8 * * * du -sh ~ >> ~/disk_usage.log

3. Pressione Esc para sair do modo de inserção
4. Digite :wq e pressione Enter para salvar e sair

Verifique se ambas as entradas estão presentes:

crontab -l

Você agora deve ver ambas as tarefas cron listadas.

cron também suporta strings especiais que podem simplificar agendamentos comuns. Estes incluem @reboot, @yearly, @annually, @monthly, @weekly, @daily, @midnight e @hourly. Por exemplo, @hourly é equivalente a 0 * * * *.

Vamos adicionar uma tarefa que é executada a cada hora e registra o tempo de atividade do sistema em ~/uptime_log.txt.

Abra seu crontab para edição:

crontab -e

No vim:

1. Pressione i para entrar no modo de inserção
2. Adicione a seguinte linha:

@hourly uptime >> ~/uptime_log.txt

3. Pressione Esc para sair do modo de inserção
4. Digite :wq e pressione Enter para salvar e sair

Verifique todas as três entradas:

crontab -l

Você agora deve ver todas as três tarefas cron.

Para demonstrar o efeito dessas tarefas, esperaremos por um curto período. Como as tarefas são agendadas em intervalos diferentes, não veremos todas elas serem executadas imediatamente, mas podemos verificar a configuração.

Aguarde pelo menos 3 minutos para permitir que a tarefa */2 seja executada pelo menos uma vez.

Verifique o arquivo ~/cron_messages.txt:

cat ~/cron_messages.txt

Você deve ver pelo menos uma mensagem "Hello from cron!".

Hello from cron!

Os arquivos ~/disk_usage.log e ~/uptime_log.txt podem não ter sido criados ainda, dependendo da hora atual, pois eles são agendados para execução diária e horária, respectivamente. A parte importante é que suas entradas estão configuradas corretamente em seu crontab.

Isso conclui a etapa de gerenciamento do crontab do usuário. Todas as tarefas cron continuarão sendo executadas até que o contêiner seja destruído.

Agendar tarefas recorrentes do sistema com diretórios cron

Nesta etapa, você aprenderá como agendar tarefas recorrentes em todo o sistema usando diretórios cron. Ao contrário das entradas crontab do usuário, que são específicas para um usuário, as tarefas cron do sistema são gerenciadas pelo usuário root e afetam todo o sistema. Elas são normalmente usadas para manutenção do sistema, rotação de logs e outras tarefas administrativas.

Continuaremos trabalhando no sistema local para explorar a configuração de tarefas cron em todo o sistema.

As tarefas cron em todo o sistema são definidas em /etc/crontab ou colocando scripts em diretórios específicos:

• /etc/cron.hourly/: Scripts neste diretório são executados uma vez por hora.
• /etc/cron.daily/: Scripts neste diretório são executados uma vez por dia.
• /etc/cron.weekly/: Scripts neste diretório são executados uma vez por semana.
• /etc/cron.monthly/: Scripts neste diretório são executados uma vez por mês.

Esses diretórios são processados pelo utilitário run-parts, que executa todos os arquivos executáveis dentro deles.

Para gerenciar tarefas cron do sistema, você precisa de privilégios de root. Como o usuário labex tem acesso sudo, podemos usar sudo para os comandos necessários.

Vamos criar um script simples que registra uma mensagem no log do sistema. Colocaremos este script em /etc/cron.hourly/ para fazê-lo rodar a cada hora.

Primeiro, crie o arquivo de script /etc/cron.hourly/my_hourly_script:

sudo nano /etc/cron.hourly/my_hourly_script

Adicione o seguinte conteúdo ao arquivo:

#!/bin/bash
logger "Hourly cron job executed at $(date)"

Salve e saia do editor (Ctrl+o, Enter, Ctrl+x no nano).

Em seguida, você precisa tornar o script executável. Sem permissões de execução, run-parts o ignorará.

sudo chmod +x /etc/cron.hourly/my_hourly_script

Agora, vamos verificar se o script é executável:

ls -l /etc/cron.hourly/my_hourly_script

Você deve ver x nas permissões, por exemplo: -rwxr-xr-x.

Como as tarefas cron.hourly são executadas uma vez por hora, não podemos esperar uma hora inteira para verificar sua execução neste laboratório. No entanto, podemos acionar manualmente o comando run-parts para o diretório horário para simular sua execução.

sudo run-parts /etc/cron.hourly/

Este comando executará todos os scripts executáveis em /etc/cron.hourly/. O script que criamos usa o comando logger para escrever mensagens no log do sistema. Embora não possamos verificar facilmente a saída do log neste ambiente de contêiner, o objetivo de aprendizado importante é entender como criar e gerenciar scripts nos diretórios cron.

Em um sistema RHEL real, você seria capaz de verificar os logs do sistema usando journalctl ou /var/log/messages para verificar se o script foi executado com sucesso.

Isso conclui a etapa de gerenciamento de tarefas cron do sistema. O script permanecerá no local e seria executado a cada hora em um ambiente de sistema real.

Configurar timers systemd para tarefas recorrentes

Nesta etapa, você aprenderá sobre os timers systemd, que são uma alternativa moderna ao cron para agendar tarefas em sistemas Linux. Os timers systemd oferecem mais flexibilidade e melhor integração com o ecossistema systemd. Embora os comandos systemctl sejam normalmente usados para gerenciar unidades systemd, devido ao ambiente do contêiner Docker, focaremos na criação e verificação dos arquivos de unidade de timer e serviço diretamente.

Os timers systemd funcionam em conjunto com as unidades de serviço systemd. Uma unidade de timer (arquivo .timer) define quando uma tarefa deve ser executada, e uma unidade de serviço (arquivo .service) define qual tarefa deve ser executada.

Continuaremos trabalhando no sistema local para explorar a configuração de timers systemd.

Você precisará de privilégios de root para criar arquivos de unidade systemd em diretórios do sistema. Como o usuário labex tem acesso sudo, podemos usar sudo para os comandos necessários.

Vamos criar um serviço simples que registra uma mensagem em um arquivo. Colocaremos este arquivo de unidade de serviço em /etc/systemd/system/, que é onde as unidades de serviço personalizadas são normalmente armazenadas.

Crie o arquivo de unidade de serviço /etc/systemd/system/my-custom-task.service:

sudo nano /etc/systemd/system/my-custom-task.service

Adicione o seguinte conteúdo ao arquivo:

[Unit]
Description=My Custom Scheduled Task

[Service]
Type=oneshot
ExecStart=/bin/bash -c 'echo "My custom task executed at $(date)" >> /var/log/my-custom-task.log'

Salve e saia do editor (Ctrl+o, Enter, Ctrl+x no nano).

Em seguida, crie o arquivo de unidade de timer /etc/systemd/system/my-custom-task.timer. Este timer ativará nosso serviço a cada 5 minutos.

sudo nano /etc/systemd/system/my-custom-task.timer

Adicione o seguinte conteúdo ao arquivo:

[Unit]
Description=Run My Custom Scheduled Task every 5 minutes

[Timer]
OnCalendar=*:0/5
Persistent=true

[Install]
WantedBy=timers.target

Salve e saia do editor.

Explicação de OnCalendar:

• *:0/5 significa "a cada 5 minutos".
  • * para ano, mês, dia, hora (qualquer valor).
  • 0/5 para minuto, significando começando no minuto 0, a cada 5 minutos (0, 5, 10, ..., 55).

Em um ambiente systemd típico, você agora executaria systemctl daemon-reload para que o systemd estivesse ciente dos novos arquivos de unidade e, em seguida, systemctl enable --now my-custom-task.timer para iniciar o timer. No entanto, devido às limitações do contêiner Docker, systemctl não é totalmente funcional.

Em vez disso, verificaremos manualmente a criação dos arquivos. O daemon systemd dentro do contêiner pode pegar esses arquivos eventualmente, mas não podemos controlar ou observar diretamente sua execução do timer nesta configuração de laboratório. O objetivo principal aqui é entender como configurar esses arquivos.

Vamos verificar a existência dos arquivos criados:

ls -l /etc/systemd/system/my-custom-task.service
ls -l /etc/systemd/system/my-custom-task.timer

Você deve ver a saída indicando que ambos os arquivos existem.

Para simular a execução do serviço, você pode executar manualmente o comando definido em ExecStart:

sudo /bin/bash -c 'echo "My custom task executed at $(date)" >> /var/log/my-custom-task.log'

Agora, verifique o arquivo de log para ver a saída:

sudo cat /var/log/my-custom-task.log

Você deve ver a mensagem que acabou de registrar:

My custom task executed at Tue Jun 10 06:54:40 UTC 2025

Isso conclui a etapa de configuração do timer systemd. Os arquivos de unidade de serviço e timer permanecerão no local para referência.

Gerenciar arquivos temporários com systemd-tmpfiles

Nesta etapa, você aprenderá como gerenciar arquivos e diretórios temporários usando systemd-tmpfiles. Este utilitário faz parte do systemd e é responsável por criar, excluir e limpar arquivos e diretórios voláteis e temporários. Ele é comumente usado para gerenciar /tmp, /var/tmp e outros locais de armazenamento temporário, garantindo que arquivos antigos sejam removidos periodicamente.

Continuaremos trabalhando no sistema local para explorar a configuração do systemd-tmpfiles.

Você precisará de privilégios de root para configurar o systemd-tmpfiles. Como o usuário labex tem acesso sudo, podemos usar sudo para os comandos necessários.

O systemd-tmpfiles lê arquivos de configuração de /etc/tmpfiles.d/ e /usr/lib/tmpfiles.d/. Esses arquivos definem regras para criar, excluir e gerenciar arquivos e diretórios.

Vamos criar um arquivo de configuração personalizado para gerenciar um novo diretório temporário. Criaremos um diretório /run/my_temp_dir e configuraremos o systemd-tmpfiles para limpar arquivos com mais de 1 minuto.

Crie o arquivo de configuração /etc/tmpfiles.d/my_temp_dir.conf:

sudo nano /etc/tmpfiles.d/my_temp_dir.conf

Adicione o seguinte conteúdo ao arquivo:

d /run/my_temp_dir 0755 labex labex 1m

Explicação da linha:

• d: Especifica que esta entrada define um diretório.
• /run/my_temp_dir: O caminho para o diretório.
• 0755: As permissões para o diretório.
• labex labex: O proprietário e o grupo para o diretório.
• 1m: A idade após a qual os arquivos neste diretório devem ser excluídos (1 minuto).

Salve e saia do editor (Ctrl+o, Enter, Ctrl+x no nano).

Agora, vamos dizer ao systemd-tmpfiles para aplicar esta configuração. A opção --create criará o diretório se ele não existir.

sudo systemd-tmpfiles --create /etc/tmpfiles.d/my_temp_dir.conf

Verifique se o diretório foi criado com as permissões e propriedade corretas:

ls -ld /run/my_temp_dir

Você deve ver uma saída semelhante a:

drwxr-xr-x 2 labex labex 6 Jun 10 06:55 /run/my_temp_dir

Em seguida, vamos criar um arquivo de teste dentro deste novo diretório temporário:

sudo touch /run/my_temp_dir/test_file.txt

Verifique se o arquivo existe:

ls -l /run/my_temp_dir/test_file.txt

Agora, precisamos esperar mais de 1 minuto para que o arquivo se torne "antigo" de acordo com nossa configuração. Espere pelo menos 70 segundos (1 minuto e 10 segundos).

Depois de esperar mais de 1 minuto, executaremos manualmente o systemd-tmpfiles com a opção --clean para acionar o processo de limpeza com base em nossa configuração.

sudo systemd-tmpfiles --clean /etc/tmpfiles.d/my_temp_dir.conf

Finalmente, verifique se o test_file.txt foi removido:

ls -l /run/my_temp_dir/test_file.txt

Você deve obter um erro "No such file or directory" (Nenhum arquivo ou diretório), indicando que o systemd-tmpfiles limpou com sucesso o arquivo antigo.

Isso conclui a etapa de configuração do systemd-tmpfiles. O arquivo de configuração e o diretório temporário permanecerão no local para referência.

Resumo

Neste laboratório, você aprendeu como agendar e gerenciar tarefas únicas usando o comando at, incluindo o agendamento de trabalhos de forma interativa e não interativa, visualizando a fila at com atq e excluindo trabalhos pendentes com atrm. Você também adquiriu proficiência no agendamento de tarefas recorrentes específicas do usuário usando crontab, cobrindo como editar, listar e remover tarefas cron e entendendo a sintaxe cron para especificar horários de execução. Além disso, o laboratório demonstrou como agendar tarefas recorrentes em todo o sistema, colocando scripts em diretórios cron padrão (/etc/cron.hourly, /etc/cron.daily, etc.) e como criar tarefas cron personalizadas em /etc/cron.d.

Finalmente, você explorou o agendamento avançado de tarefas com timers systemd, aprendendo a criar e habilitar unidades de serviço e timer para tarefas recorrentes e como gerenciar arquivos e diretórios temporários usando systemd-tmpfiles para limpeza automatizada. Este laboratório abrangente forneceu experiência prática no gerenciamento de diversas necessidades de agendamento de tarefas em sistemas RHEL, desde comandos simples e únicos até processos de sistema recorrentes complexos.