Observação:

Este tutorial está disponível em um ambiente de laboratório gratuito fornecido pela Oracle.
Ele usa valores de exemplo para credenciais, tenancy e compartimentos do Oracle Cloud Infrastructure. Ao concluir seu laboratório, substitua esses valores por valores específicos do seu ambiente de nuvem.

Gerenciar o Tempo do Sistema e Programar Tarefas no Oracle Linux

Introdução

O Oracle Linux fornece aos usuários várias maneiras de interagir com a hora e a data. Embora você possa alterá-los manualmente, é mais comum configurar um serviço que implemente o NTP (Network Time Protocol), como crony. Dessa forma, o horário do sistema permanece correto e todas as tarefas que usam cron ou systemd timers são executadas dentro da programação.

Objetivos

Neste tutorial, você aprenderá a:

Gerencie o tempo do sistema no terminal usando date, hwclock e timedatectl
Execute e ative o serviço de cronia
Programar tarefas com cron e timers systemd

Pré-requisitos

Mínimo de um único sistema Oracle Linux
Cada sistema deve ter o Oracle Linux instalado e configurado com:
- Uma conta de usuário não raiz com acesso sudo (sudo)
- Acesso à Internet

Implantar o Oracle Linux

Observação: Se estiver em execução na sua própria tenancy, leia o projeto linux-virt-labs GitHub README.md e conclua os pré-requisitos antes de implantar o ambiente de laboratório.

Abra um terminal no Luna Desktop.

Clone o projeto linux-virt-labs GitHub.

git clone https://github.com/oracle-devrel/linux-virt-labs.git

Altere para o diretório de trabalho.
```
cd linux-virt-labs/ol
```

Instale as coleções necessárias.

ansible-galaxy collection install -r requirements.yml

Implante o ambiente de laboratório.
```
ansible-playbook create_instance.yml -e localhost_python_interpreter="/usr/bin/python3.6"
```
O ambiente de laboratório gratuito requer a variável extra local_python_interpreter, que define ansible_python_interpreter para reproduções em execução no localhost. Essa variável é necessária porque o ambiente instala o pacote RPM do Oracle Cloud Infrastructure SDK para Python, localizado nos módulos python3.6.

A forma de implantação padrão usa a CPU AMD e o Oracle Linux 8. Para usar uma CPU Intel ou um Oracle Linux 9, adicione -e instance_shape="VM.Standard3.Flex" ou -e os_version="9" ao comando de implantação.

Importante: Aguarde a execução bem-sucedida do playbook e atinja a tarefa de pausa. Neste estágio do playbook, a instalação do Oracle Linux está concluída e as instâncias estão prontas. Anote o jogo anterior, que imprime os endereços IP públicos e privados dos nós que ele implanta e quaisquer outras informações de implantação necessárias durante a execução do laboratório.

Configurar Data e Hora do Sistema

O Oracle Linux tem três comandos comuns que podem ajudá-lo a ajustar a data e a hora no sistema. O comando date ajusta a hora do sistema, enquanto hwclock ajusta a hora RTC. No Oracle Linux, o tempo RTC se refere ao tempo mantido pelo Real-Time Clock (RTC), um relógio de hardware suportado por bateria que continua a ser executado quando o sistema é desligado. Outros nomes comuns para o relógio de hardware incluem o relógio CMOS ou o relógio BIOS. Se quiser atualizar o relógio RTC após uma alteração no date, execute hwclock.

A terceira opção é timedatectl. Este comando combina date e hwclock e atualiza o sistema e o RTC ao definir a hora. Em distribuições Linux modernas baseadas em systemd, como o Oracle Linux, a recomendação é usar timedatectl.

Exibir e Definir o Relógio do Sistema

Abra um terminal e estabeleça conexão via SSH com a instância ol-node-01.
```
ssh oracle@<ip_address_of_instance>
```
Obter a hora e a data atuais do sistema.
```
date
```
A saída mostra a data, a hora e o fuso horário do sistema no formato padrão. Você pode alterar o formato da saída usando os muitos argumentos do comando date. Esses argumentos ajudam na criação de scripts ou no cálculo de datas e horas diferentes. Encontre mais informações executando date --help ou exiba a página manual usando man date.
Ajustar a hora e a data do sistema.
```
sudo date -s "1 JAN 1970 16:00:00"
```
Simplifique o formato usando os argumentos de controle de formato.
```
sudo date +%Y%m%d -s "20250203"
```
Observe que, como você não forneceu uma hora, a parte da hora assume todos os zeros como padrão, que é meia-noite.
Defina a hora do sistema.
```
sudo date +%T -s "14:08:14"
```
Se você executar o comando date novamente, a hora deverá ser exibida de acordo com o que você informou.

Exibir e definir o relógio de hardware

Leia o relógio de hardware atual (RTC).
```
sudo hwclock --show
```
Defina o relógio do sistema com base no relógio de hardware.
```
sudo hwclock -s
```
O comando permite definir os relógios na direção oposta, passando a função -w. Confira funções e opções adicionais executando hwclock --help ou visualizando a página manual man hwclock.

Data e hora usando Systemd

Obtenha a data e a hora atuais.
```
timedatectl
```
A saída no ambiente de laboratório gratuito mostra que o serviço NTP está ativo. Para ajustar manualmente as configurações de data e hora com timedatectl, isso deve ser desativado primeiro.
Desative a sincronização de NTP.
```
sudo timedatectl set-ntp no
```

Defina a data e a hora.

sudo timedatectl set-time '2014-09-23 14:10:40'

Verifique a data e a hora.
```
date
```
Obtenha uma lista de fusos horários.
```
timedatectl list-timezones
```
Pressione q para sair do comando timedatectl.

Defina o fuso horário.

sudo timedatectl set-timezone 'America/Chicago'

Verifique o novo fuso horário.
```
timedatectl
```
Retorna o fuso horário para UTC (Coordinated Universal Time).
```
sudo timedatectl set-timezone 'UTC'
```
Ative a sincronização de NTP.
```
sudo timedatectl set-ntp yes
```
Após algum tempo, a sincronização ocorrerá e o relógio retornará ao dia e hora atuais com base no fuso horário definido.

Usar Chrony

chrony é um recurso do Oracle Linux que implementa o NTP para manter a cronometragem com precisão na rede e consiste em dois componentes, chronyd e chronyc. chronyd é um daemon de serviço que pode ser ativado e iniciado no momento da inicialização, enquanto chronyc é um utilitário de linha de comando usado para monitorar o desempenho do chronyd e modificar seus parâmetros de runtime.

Verifique se a cronia está instalada.
```
dnf list chrony
```
Você pode instalá-lo usando sudo dnf install -y chrony se encontrá-lo não instalado.
Verifique o status do daemon de serviço.
```
sudo systemctl status chronyd
```
Ative e inicie o serviço usando sudo systemctl enable --now chronyd se ele estiver inativo. Pressione q para sair do comando systemctl.
Obtenha informações sobre o desempenho do relógio do sistema.
```
chronyc -n tracking
```
Exemplo de Saída:
```
Reference ID    : A9FEA9FE (169.254.169.254)
Stratum         : 3
Ref time (UTC)  : Mon Feb 03 16:07:59 2025
System time     : 0.000009410 seconds slow of NTP time
Last offset     : -0.000011537 seconds
RMS offset      : 0.000015202 seconds
Frequency       : 22.818 ppm slow
Residual freq   : -0.004 ppm
Skew            : 0.222 ppm
Root delay      : 0.000643811 seconds
Root dispersion : 0.000107666 seconds
Update interval : 64.4 seconds
Leap status     : Normal
```
Onde:
- ID de referência: Este é o ID de referência e nome ou endereço IP do servidor para o qual o computador está sincronizado no momento. O ID de referência na saída é exibido como um número hexadecimal.
- Estrato: O estrato indica quantos pulos de distância este sistema é de um computador com um relógio de referência anexado.
- Hora de referência: é a hora em UTC em que o sistema processou a última medição da origem de referência.
Informações adicionais estão disponíveis verificando a página manual usando man chronyc.
Obtenha uma lista de origens que seu sistema usa.
```
chronyc -n sources
```
O uso da opção -v exibe descrições de coluna para cada uma das colunas exibidas.

Programar Tarefas

O Oracle Linux inclui várias maneiras de programar tarefas, e essas tarefas ou jobs podem ser executados no sistema ou nos níveis do usuário. Embora cron seja provavelmente o mais conhecido desses métodos, systemd introduziu os crons mais flexíveis em termos de agendamento com calendário e tempo monotônico e está se tornando mais amplamente usado. As distribuições atuais do Oracle Linux têm uma combinação de ambas.

Usando Cron

Verifique as tarefas cron no nível do sistema.
```
sudo ls -al /etc/cron*
```
A saída fornece vários diretórios contendo scripts executáveis que executam tarefas selecionadas em uma programação pré-determinada, como por hora, semanalmente e mensalmente. O diretório /etc/cron.d também existe, onde os pacotes podem colocar trechos de código crontab sem modificar o sistema /etc/crontab.
Obter uma lista das tarefas cron no nível do sistema.
```
sudo crontab -l
```
A saída indica que não há crontab para raiz. A execução do mesmo comando sem sudo fornece a mesma saída, mas para a conta de usuário local.
Criar um job cron no nível do usuário.
```
(crontab -l 2>/dev/null; echo  '* * * * * date >> /home/oracle/test') | crontab -
```
O primeiro comando evita a mensagem sem crontab, pois este é o primeiro job informado e o segundo cria o job, que é executado a cada minuto.
Verifique se o crontab já existe.
```
crontab -l
```
Cada trabalho aparece em sua própria linha no crontab. O crontab tem cinco campos separados por espaço que definem os diferentes períodos de tempo que você pode configurar, seguidos pelo comando que o job executará. O comando pode ser equivalente a qualquer comando que você possa executar na linha de comando do sistema, permitindo que você execute seus scripts ou aproveite os pipes e os operadores de redirecionamento. Se você quiser editar o job, use o comando crontab -e, que o coloca no seu EDITOR padrão, vi, no Oracle Linux.

Opções de Sequência de Tempo Crontab

O Crontab define os campos de hora como:
- minuto: De 0 a 59
- hora: De 0 a 23
- dia: De 1 a 31
- mês: De 1 a 12, ou o nome do mês
- dia da semana: De 0 a 7, ou o nome abreviado do dia. Note que 0 e 7 representam domingo.
Você pode usar caracteres especiais em qualquer um dos campos de hora:
- Asterisco (*): Especifica que o comando deve ser executado para cada instância do campo.
- Hífen (-): Pode ser usado para indicar um intervalo. Por exemplo, no campo de dia da semana, você pode especificar 1-5 para programar a tarefa para ser executada de segunda a sexta-feira, mas não no sábado ou domingo.
- Vírgula (,): Pode ser usada para especificar uma lista de valores para um campo. Por exemplo, no campo hora, você pode especificar 6,18 para programar a tarefa para ser executada às 6h e 6h.
- Barra de avanço (/): pode ser usada para especificar valores de etapa. Por exemplo, você pode especificar */15 no campo minutos para programar uma tarefa para ser executada a cada 15 minutos.
O crontab também permite que você use uma extensão abreviada exclusiva para substituir os campos de tempo para requisitos gerais de tempo. É importante ressaltar que essa abreviação também inclui uma opção para executar um comando após a reinicialização:
- @reboot : Executar uma vez após a reinicialização.
- @yearly : Executar uma vez por ano, ou seja, "0 0 1 1 *".
- @annually : Executar uma vez por ano, ou seja, "0 0 1 1 *".
- @monthly : Executar uma vez por mês, ou seja, "0 0 1 * *".
- @weekly : Executar uma vez por semana, ou seja, "0 0 * 0".
- @daily : Executar uma vez por dia, ou seja, "0 0 * *".
- @hourly : Executar uma vez por hora, ou seja, "0 * * *".
O crontab fornece apenas 1 minuto de granularidade. Se você precisar de um controle granular mais fino da sua tarefa, é recomendável usar temporizadores systemd.

Exemplos de:
```
*/15 * * * * echo "This crontab entry runs every 15 minutes"
10 * * * * echo "This crontab entry runs at 10 minutes past every hour"
30 13 * * 3 echo "This crontab entry runs at 13h30 on every Wednesday"
@reboot echo "This command runs once after a reboot event"
```
Verifique a saída cron.
```
sudo tail /var/log/cron
```
A saída mostra a data, a hora, o usuário e a execução do comando. Como uma instalação mínima padrão do Oracle Linux não instala o MTA (Mail Transport Agent), o daemon cron direciona a saída dos comandos especificados no crontab para o daemon Syslog. Portanto, você pode exibir a saída crontab no arquivo de log em /var/log/cron.

Sintaxe do Comando Crontab

O crontab é executado sob as credenciais do usuário ao qual o crontab pertence e é executado com algumas variáveis de ambiente padrão definidas, incluindo:
- HOME: O diretório HOME do usuário que o crontab executa como
- LOGNAME: Equivalente ao nome do usuário que o crontab executa como
- USUÁRIO: O nome do usuário que o crontab executa como
- SHELL: O binário do SHELL que o sistema usa para executar comandos. Esse valor é definido como /bin/sh por padrão.
- PATH: O caminho disponível para o utilitário crontab. Esse valor é definido como /usr/bin:/bin por padrão.
Você pode definir variáveis de ambiente alternativas especificando-as como linhas dentro do crontab que não incluem campos de hora. Por exemplo, se você preferir usar o shell bash e quiser importar regularmente todas as variáveis e definições dentro de sua configuração pessoal do .bashrc, poderá editar seu crontab com crontab -e para ter a seguinte aparência:
```
SHELL=/bin/bash
* * * * * source $HOME/.bashrc;
```
Como o comando do trabalho crontab é executado dentro de um ambiente de shell, a sintaxe de shell padrão se aplica e pode ser usada para canalizar ou redirecionar a saída. Por exemplo, para redirecionar toda a saída para /dev/null, use redirecionamentos de shell padrão para a saída STDOUT e STDERR no comando:
```
* * * * * /path/to/command > /dev/null 2>&1
```
Alternativamente, você poderia redirecionar a saída para anexar a um arquivo que você poderia usar para rastrear a saída para cada vez que o comando for executado:
```
* * * * * /path/to/command >> $HOME/command.log
```
Exemplos de:
```
*/15 * * * * echo "This 'silent' crontab entry runs every 15 minutes but the output is redirected to /dev/null" > /dev/null 2>&1
* * * * * echo "The date and time is $(date +\%Y-\%m-\%d\ \%H:\%M:\%S)" >> $HOME/crontab.log
```
O exemplo escapa os caracteres % no comando date porque os caracteres % são alterados em caracteres de nova linha pelo utilitário crontab, e todos os dados após o primeiro % são enviados para o comando como entrada padrão. Consulte man 5 crontab para obter mais informações.

Remover o arquivo Crontab

Se você planeja apenas remover um job específico, poderá usar o comando crontab -e para editar e remover a linha individual que contém esse job. No entanto, se você quiser remover todos os jobs, o crontab fornecerá uma opção rápida e eficiente.

Remova todas as entradas do trabalho cron.
```
crontab -r
```

Temporizadores Systemd

Como trabalhos cron, temporizadores systemd permitem executar comandos ou scripts em um momento específico. No entanto, essas tarefas são controladas e supervisionadas pelo systemd e têm um controle mais refinado da ativação baseada no tempo.

Listar temporizadores existentes.
```
systemctl status *timer
```
Pressione q para sair do comando systemctl.

Criar um temporizador

Um temporizador consiste em uma unidade de serviço que define o trabalho a ser feito e uma unidade de temporizador para agendá-lo e acioná-lo. Como essas são unidades de serviço systemd, é possível criá-las no espaço do sistema ou do usuário. O benefício do espaço do usuário é que ele permite que os usuários gerenciem seus serviços, como daemons e tarefas automatizadas.

Crie o diretório systemd do usuário local.
```
mkdir -p ~/.config/systemd/user
```
Unidades de serviço e temporizadores no nível do sistema vão para /etc/systemd/system.
Ative a permanência para o usuário atual.
```
loginctl enable-linger $(whoami)
```
Lingering refere-se a um recurso em systemd que permite que os processos do usuário continuem em execução mesmo após o usuário fazer logout de sua sessão.
Verifique o status do usuário.
```
loginctl user-status $(whoami)
```
Pressione q para sair do comando loginctl.

Escreva um script para que o temporizador seja executado.

cat << 'EOF' | tee ~/test.sh > /dev/null 
#!/bin/bash
/usr/bin/echo "test from test.service: $(date)" 2>&1 | tee -a /home/oracle/test.log
EOF

Torne o script executável.
```
chmod +x ~/test.sh
```

Criar uma unidade de serviço.

cat << EOF | tee ~/.config/systemd/user/test.service > /dev/null
[Unit]
Description=Run the test script
StartLimitIntervalSec=1
StartLimitBurst=10
   
[Service]
Type=oneshot
ExecStart=/home/oracle/test.sh
StandardOutput=journal
SyslogIdentifier=test
EOF

O serviço requer StartLimitIntervalSec e StartLimitBurst, pois ele deve executar esse serviço a cada poucos segundos. Você pode saber mais sobre esses parâmetros em man systemd.unit.

Crie uma unidade de temporizador.

cat << EOF | tee ~/.config/systemd/user/test.timer > /dev/null
[Unit]
Description=Run test.service every 10 seconds

[Timer]
OnCalendar=*:*:0/10
AccuracySec=1
Persistent=true

[Install]
WantedBy=timers.target
EOF

O parâmetro AccuracySec é necessário porque os timers systemd não são executados exatamente quando solicitado, mas operam em uma variação padrão de um minuto.

Torne o systemd ciente das alterações.
```
systemctl --user daemon-reload
```

Ative e inicie o temporizador.

systemctl --user enable --now test.timer

Verifique se o temporizador está em execução.
```
systemctl --user status test.timer --no-pager
```
A opção --no-pager imprime a saída completa sem a necessidade de rolar ou percorrer as entradas. Confira systemctl --help para opções adicionais.
Verifique o arquivo de log do script bash.
```
cat ~/test.log
```
Verifique o diário systemd.
```
journalctl -r -n 10 --user-unit test --no-pager
```
Esta saída mostra as últimas 10 linhas de saída da unidade systemd test.service do usuário. A opção -r exibe os lançamentos em ordem cronológica inversa.
```
journalctl -r -n 10 -t test --no-pager
```
Este comando mostra a saída gerada pelo script executado pela unidade de serviço systemd. A opção -t corresponde ao SyslogIdentifier definido no arquivo test.service, que fornece um identificador para pesquisa. Veja mais opções para o journalctl lendo a página man journalctl.
Desative o temporizador.
```
systemctl --user disable test.timer
```
Este comando evita que o temporizador seja iniciado automaticamente no futuro e o torna inativo.
Pare o cronômetro.
```
systemctl --user stop test.timer
```
Este comando interrompe a execução atual do temporizador se ele estiver em execução. Isso não impede que o temporizador comece novamente no futuro.

Próximas Etapas

Ao concluir este tutorial, você demonstrou suas habilidades e capacidade de gerenciar a data, a hora e as tarefas de programação no Oracle Linux. Há muitos mais flags e recursos dos comandos mostrados. Confira os links abaixo e as páginas man sugeridas para aumentar seus conhecimentos e habilidades.

Mais Recursos de Aprendizagem

Explore outros laboratórios em docs.oracle.com/learn ou acesse mais conteúdo de aprendizado gratuito no canal do Oracle Learning YouTube. Além disso, acesse education.oracle.com/learning-explorer para se tornar um Oracle Learning Explorer.

Para obter a documentação do produto, visite o Oracle Help Center.

Título e Informações de Copyright

Manage System Time and Schedule Tasks on Oracle Linux

F49756-05

Oracle e/ou suas empresas afiliadas.