Note:

Este tutorial está disponible en un entorno de laboratorio gratuito proporcionado por Oracle.
Utiliza valores de ejemplo para credenciales, arrendamiento y compartimentos de Oracle Cloud Infrastructure. Al finalizar el laboratorio, sustituya estos valores por otros específicos de su entorno en la nube.

Gestión del tiempo del sistema y tareas de programación en Oracle Linux

Introducción

Oracle Linux proporciona a los usuarios varias formas de interactuar con la hora y la fecha. Aunque puede cambiarlos manualmente, es más común configurar un servicio que implemente el protocolo de hora de red (NTP), como chrony. De esta manera, la hora del sistema sigue siendo correcta y cualquier tarea que utilice cron o systemd timers se ejecuta según lo programado.

Objetivos

En este tutorial, aprenderá a:

Gestione la hora del sistema desde el terminal mediante date, hwclock y timedatectl
Ejecutar y activar el servicio chrony
Programe tareas con cron y timers de systemd

Requisitos

Mínimo de un único sistema Oracle Linux
Cada sistema debe tener Oracle Linux instalado y configurado con:
- Una cuenta de usuario no raíz con acceso sudo
- Acceso a internet

Despliegue de Oracle Linux

Nota: Si se ejecuta en su propio arrendamiento, lea el proyecto linux-virt-labs GitHub README.md y complete los requisitos antes de desplegar el entorno de prácticas.

Abra un terminal en el escritorio Luna.

Clone el proyecto linux-virt-labs GitHub.

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

Cambie al directorio de trabajo.
```
cd linux-virt-labs/ol
```

Instale las recopilaciones necesarias.

ansible-galaxy collection install -r requirements.yml

Despliegue el entorno de prácticas.
```
ansible-playbook create_instance.yml -e localhost_python_interpreter="/usr/bin/python3.6"
```
El entorno de prácticas libres necesita la variable adicional local_python_interpreter, que define ansible_python_interpreter para las reproducciones que se ejecutan en localhost. Esta variable es necesaria porque el entorno instala el paquete RPM para el SDK para Python de Oracle Cloud Infrastructure, que se encuentra en los módulos python3.6.

La unidad de despliegue por defecto utiliza la CPU AMD y Oracle Linux 8. Para utilizar una CPU Intel u Oracle Linux 9, agregue -e instance_shape="VM.Standard3.Flex" o -e os_version="9" al comando de despliegue.

Importante: Espere a que el cuaderno de estrategias se ejecute correctamente y alcance la tarea de pausa. En esta etapa del manual, se ha completado la instalación de Oracle Linux y las instancias están listas. Tome nota de la reproducción anterior, que imprime las direcciones IP públicas y privadas de los nodos que despliega y cualquier otra información de despliegue necesaria al ejecutar el ejercicio práctico.

Configurar Fecha y Hora del Sistema

Oracle Linux tiene tres comandos comunes que pueden ayudarle a ajustar la fecha y la hora en el sistema. El comando date ajusta la hora del sistema, mientras que hwclock ajusta la hora RTC. En Oracle Linux, la hora de RTC hace referencia a la hora que conserva el reloj en tiempo real (RTC), un reloj de hardware respaldado por batería que sigue funcionando cuando el sistema está apagado. Otros nombres comunes para el reloj de hardware incluyen el reloj CMOS o el reloj BIOS. Si desea actualizar el reloj RTC después de un cambio de date, debe ejecutar hwclock.

La tercera opción es timedatectl. Este comando combina date y hwclock y actualiza tanto el sistema como el RTC al definir la hora. En las distribuciones modernas de Linux basadas en systemd, como Oracle Linux, se recomienda utilizar timedatectl.

Visualización y configuración del reloj del sistema

Abra un terminal y conéctese mediante SSH a la instancia ol-node-01.
```
ssh oracle@<ip_address_of_instance>
```
Obtener la fecha y hora actuales del sistema.
```
date
```
La salida muestra la fecha, la hora y la zona horaria del sistema en el formato predeterminado. Puede cambiar el formato de la salida mediante los muchos argumentos del comando date. Estos argumentos ayudan a la hora de crear scripts o calcular diferentes fechas y horas. Para obtener más información, ejecute date --help o consulte la página manual con man date.
Ajuste de la fecha y hora del sistema.
```
sudo date -s "1 JAN 1970 16:00:00"
```
Simplifique el formato mediante los argumentos de control de formato.
```
sudo date +%Y%m%d -s "20250203"
```
Tenga en cuenta que, dado que no ha proporcionado una hora, la parte de hora se define por defecto en todos los ceros, que es medianoche.
Defina la hora del sistema.
```
sudo date +%T -s "14:08:14"
```
Si vuelve a ejecutar el comando date, la hora se debe mostrar según lo que haya introducido.

Visualización y configuración del reloj de hardware

Lea el reloj de hardware actual (RTC).
```
sudo hwclock --show
```
Configure el reloj del sistema en función del reloj de hardware.
```
sudo hwclock -s
```
El comando permite establecer los relojes en la dirección opuesta transfiriendo la función -w. Consulte las funciones y opciones adicionales ejecutando hwclock --help o consultando la página del manual man hwclock.

Fecha y hora usando Systemd

Obtener la fecha y hora actuales.
```
timedatectl
```
La salida en el entorno de prácticas gratuitas muestra que el servicio NTP está activo. Para ajustar manualmente la configuración de fecha y hora con timedatectl, primero se debe desactivar.
Desactive la sincronización de NTP.
```
sudo timedatectl set-ntp no
```

Defina la fecha y la hora.

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

Comprobación de la fecha y hora.
```
date
```
Obtener una lista de zonas horarias.
```
timedatectl list-timezones
```
Pulse q para salir del comando timedatectl.

Definir la zona horaria.

sudo timedatectl set-timezone 'America/Chicago'

Compruebe la nueva zona horaria.
```
timedatectl
```
Vuelva a la zona horaria a la hora universal coordinada (UTC).
```
sudo timedatectl set-timezone 'UTC'
```
Active la sincronización de NTP.
```
sudo timedatectl set-ntp yes
```
Después de un tiempo, la sincronización se realizará y el reloj volverá al día y la hora actuales en función de la zona horaria establecida.

Usar Chrony

chrony es una función de Oracle Linux que implementa NTP para mantener el control de tiempo de forma precisa en la red y consta de dos componentes, chronyd y chronyc. chronyd es un daemon de servicio que se puede activar e iniciar en el momento del inicio, mientras que chronyc es una utilidad de línea de comandos utilizada para supervisar el rendimiento de chronyd y modificar sus parámetros de tiempo de ejecución.

Compruebe si chrony está instalado.
```
dnf list chrony
```
Puede instalarlo mediante sudo dnf install -y chrony si no lo encuentra instalado.
Compruebe el estado del daemon de servicio.
```
sudo systemctl status chronyd
```
Active e inicie el servicio con sudo systemctl enable --now chronyd si está inactivo. Pulse q para salir del comando systemctl.
Obtener información sobre el rendimiento del reloj del sistema.
```
chronyc -n tracking
```
Salida de ejemplo:
```
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
```
Dónde:
- ID de referencia: es el ID de referencia y el nombre o la dirección IP del servidor al que está sincronizado actualmente el equipo. El ID de referencia en la salida se muestra como un número hexadecimal.
- Estrato: El estrato indica cuántos saltos de distancia este sistema es de un ordenador con un reloj de referencia conectado.
- Hora de referencia: es la hora en UTC en la que el sistema procesó la última medición desde el origen de referencia.
Para obtener más información, consulte la página del manual en man chronyc.
Obtenga una lista de orígenes que utiliza el sistema.
```
chronyc -n sources
```
Con la opción -v se muestran las descripciones de las columnas de cada una de las columnas mostradas.

Planificar Tareas

Oracle Linux incluye varias formas de programar tareas, y estas tareas o trabajos se pueden ejecutar en los niveles de sistema o de usuario. Si bien es probable que cron sea el más conocido de estos métodos, systemd introdujo los temporizadores más flexibles en términos de programación con el calendario y la hora monotónica, y se está utilizando cada vez más. Las distribuciones actuales de Oracle Linux tienen una combinación de ambas.

Uso de Cron

Compruebe los trabajos cron de nivel de sistema.
```
sudo ls -al /etc/cron*
```
La salida proporciona varios directorios que contienen secuencias de comandos ejecutables que realizan tareas de selección en un programa predeterminado, como por horas, semanales y mensuales. El directorio /etc/cron.d también existe, donde los paquetes pueden colocar fragmentos crontab sin modificar el sistema /etc/crontab.
Obtenga una lista de los trabajos cron del nivel del sistema.
```
sudo crontab -l
```
La salida indica que no hay crontab para root. La ejecución del mismo comando sin sudo proporciona la misma salida, pero para la cuenta de usuario local.
Crear un trabajo cron de nivel de usuario.
```
(crontab -l 2>/dev/null; echo  '* * * * * date >> /home/oracle/test') | crontab -
```
El primer comando evita el mensaje no crontab, ya que es el primer trabajo introducido y el segundo crea el trabajo, que se ejecuta cada minuto.
Verifique que el crontab ya existe.
```
crontab -l
```
Cada trabajo aparece en su propia línea en crontab. El crontab tiene cinco campos separados por espacios que definen los diferentes períodos de tiempo que puede configurar, seguidos del comando que ejecutará el trabajo. El comando puede ser equivalente a cualquier comando que pueda ejecutar en la línea de comandos del sistema, lo que le permite ejecutar las secuencias de comandos o aprovechar las tuberías y los operadores de redirección. Si desea editar el trabajo, utilice el comando crontab -e, que lo coloca en el EDITOR por defecto, vi, en Oracle Linux.

Opciones de secuencia de tiempo de crontab

Crontab define los campos de hora como:
- minuto: de 0 a 59
- hora: de 0 a 23
- día: del 1 al 31
- mes: del 1 al 12, o el nombre del mes
- día de la semana: del 0 al 7, o el nombre abreviado del día. Tenga en cuenta que 0 y 7 representan el domingo.
Puede utilizar caracteres especiales en cualquiera de los campos de tiempo:
- Asterisco (*): especifica que el comando se debe ejecutar para cada instancia del campo.
- Guión (-): se puede utilizar para indicar un intervalo. Por ejemplo, en el campo de día de la semana, puede especificar 1-5 para programar la ejecución de la tarea de lunes a viernes, pero no para el sábado o el domingo.
- Coma (,): se puede utilizar para especificar una lista de valores para un campo. Por ejemplo, en el campo de hora, puede especificar 6,18 para programar la ejecución de la tarea a las 6 a. m. y las 6 p. m.
- Barra inclinada (/): se puede utilizar para especificar valores de paso. Por ejemplo, puede especificar */15 en el campo de minutos para programar una tarea para que se ejecute cada 15 minutos.
El crontab también permite usar una extensión abreviada única para reemplazar los campos de tiempo para requisitos de tiempo generales. Es importante destacar que esta abreviatura también incluye una opción para ejecutar un comando después del reinicio:
- @reboot: se ejecuta una vez después del reinicio.
- @yearly : Ejecutar una vez al año, es decir, "0 0 1 1 *".
- @annually : Ejecutar una vez al año, es decir, "0 0 1 1 *".
- @monthly : se ejecuta una vez al mes, es decir, "0 0 1 * *".
- @weekly: se ejecuta una vez a la semana, es decir, "0 0 * * 0".
- @daily: se ejecuta una vez al día, es decir, "0 0 * * *".
- @hourly : Ejecutar una vez por hora, es decir, "0 * * * *".
El crontab solo proporciona granularidad de 1 minuto. Si necesita un control granular más preciso de la tarea, se recomienda utilizar temporizadores systemd.

Ejemplos:
```
*/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"
```
Compruebe la salida de cron.
```
sudo tail /var/log/cron
```
La salida muestra la fecha, la hora, el usuario y la ejecución del comando. Dado que una instalación mínima predeterminada de Oracle Linux no instala el agente de transporte de correo (MTA), el daemon cron dirige la salida de los comandos especificados en el crontab al daemon de Syslog. Por lo tanto, puede ver la salida de crontab en el archivo log en /var/log/cron.

Sintaxis del comando Crontab

El crontab se ejecuta con las credenciales del usuario al que pertenece el crontab y se ejecuta con algunas variables de entorno por defecto definidas, como:
- HOME: el directorio principal del usuario que ejecuta crontab como
- LOGNAME: equivalente al nombre de usuario del usuario que ejecuta crontab como
- USUARIO: El nombre de usuario del usuario que crontab ejecuta como
- SHELL: binario de SHELL que el sistema utiliza para ejecutar comandos. Este valor se define en /bin/sh por defecto.
- PATH: ruta disponible para la utilidad crontab. Este valor se define en /usr/bin:/bin por defecto.
Puede definir variables de entorno alternativas especificándolas como líneas dentro de crontab que no incluyan campos de tiempo. Por ejemplo, si prefiere utilizar el shell bash y desea importar regularmente todas las variables y valores dentro de su configuración personal de .bashrc, puede editar su crontab con crontab -e para que se vea de la siguiente manera:
```
SHELL=/bin/bash
* * * * * source $HOME/.bashrc;
```
Dado que el comando del trabajo crontab se ejecuta en un entorno de shell, se aplica la sintaxis de shell estándar y se puede utilizar para canalizar o redirigir la salida. Por ejemplo, para redirigir toda la salida a /dev/null, utilice redireccionamientos de shell estándar para la salida STDOUT y STDERR en el comando:
```
* * * * * /path/to/command > /dev/null 2>&1
```
Como alternativa, puede redirigir la salida para agregarla a un archivo que podría utilizar para realizar un seguimiento de la salida cada vez que se ejecute el comando:
```
* * * * * /path/to/command >> $HOME/command.log
```
Ejemplos:
```
*/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
```
El ejemplo escapa a los caracteres % del comando date porque la utilidad crontab cambia los caracteres % a caracteres newline y todos los datos posteriores al primer % se envían al comando como entrada estándar. Para más información, consulte man 5 crontab.

Eliminar el archivo Crontab

Si sólo desea eliminar un trabajo específico, puede utilizar el comando crontab -e para editar y eliminar la línea individual que contiene ese trabajo. Sin embargo, si desea eliminar todos los trabajos, crontab proporciona una opción rápida y eficaz.

Elimine todas las entradas de trabajo cron.
```
crontab -r
```

Temporizadores de sistema

Al igual que los trabajos cron, los temporizadores systemd permiten ejecutar comandos o secuencias de comandos en un momento específico. Sin embargo, estas tareas son controladas y supervisadas por systemd y tienen un control más detallado de la activación basada en el tiempo.

Enumere los temporizadores existentes.
```
systemctl status *timer
```
Pulse q para salir del comando systemctl.

Crear un temporizador

Un temporizador consta de una unidad de servicio que define el trabajo que se debe realizar y una unidad de temporizador para programarlo y activarlo. Puesto que se trata de unidades de servicio systemd, puede crearlas en el espacio del sistema o del usuario. La ventaja del espacio de usuario es que permite a los usuarios gestionar sus servicios, como daemons y tareas automatizadas.

Cree el directorio systemd del usuario local.
```
mkdir -p ~/.config/systemd/user
```
Las unidades de servicio y los temporizadores a nivel del sistema entran en /etc/systemd/system.
Active la persistencia para el usuario actual.
```
loginctl enable-linger $(whoami)
```
Lingering se refiere a una función en systemd que permite a los procesos de usuario continuar ejecutándose incluso después de que el usuario se desconecta de su sesión.
Verifique el estado de permanencia del usuario.
```
loginctl user-status $(whoami)
```
Pulse q para salir del comando loginctl.

Escriba un script para que se ejecute el temporizador.

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

Haga que el script sea ejecutable.
```
chmod +x ~/test.sh
```

Cree una unidad de servicio.

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

El servicio necesita StartLimitIntervalSec y StartLimitBurst, ya que está destinado a ejecutar este servicio cada pocos segundos. Puede obtener más información sobre estos parámetros en man systemd.unit.

Cree una unidad 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

El parámetro AccuracySec es necesario porque los temporizadores systemd no se ejecutan exactamente cuando se solicitan, sino que funcionan con una variación por defecto de un minuto.

Hacer que systemd tenga en cuenta los cambios.
```
systemctl --user daemon-reload
```

Active e inicie el temporizador.

systemctl --user enable --now test.timer

Verifique que el temporizador se esté ejecutando.
```
systemctl --user status test.timer --no-pager
```
La opción --no-pager imprime la salida completa sin necesidad de desplazarse o desplazarse por las entradas. Consulte systemctl --help para obtener opciones adicionales.
Compruebe el archivo log del script bash.
```
cat ~/test.log
```
Compruebe el asiento systemd.
```
journalctl -r -n 10 --user-unit test --no-pager
```
Esta salida muestra las últimas 10 líneas de salida de la unidad systemd test.service del usuario. La opción -r muestra los asientos en orden cronológico inverso.
```
journalctl -r -n 10 -t test --no-pager
```
Este comando muestra la salida generada por la secuencia de comandos ejecutada por la unidad de servicio systemd. La opción -t coincide con el valor SyslogIdentifier definido en el archivo test.service, que proporciona un identificador en el que buscar. Consulte más opciones para journalctl leyendo la página man journalctl.
Desactive el temporizador.
```
systemctl --user disable test.timer
```
Este comando impide que el temporizador se inicie automáticamente en el futuro y lo desactiva.
Detenga el temporizador.
```
systemctl --user stop test.timer
```
Este comando detiene la ejecución actual del temporizador si se está ejecutando. No impide que el temporizador comience de nuevo en el futuro.

Pasos Siguientes

Al completar este tutorial, ha demostrado sus habilidades y capacidad para gestionar las tareas de fecha, hora y programación en Oracle Linux. Hay muchos más indicadores y características de los comandos que se muestran. Consulte los enlaces que aparecen a continuación y las páginas del comando man sugeridas para aumentar sus conocimientos y habilidades.

Más recursos de aprendizaje

Explore otros laboratorios en docs.oracle.com/learn o acceda a más contenido de aprendizaje gratuito en el canal YouTube de Oracle Learning. Además, visite education.oracle.com/learning-explorer para convertirse en un explorador de Oracle Learning.

Para obtener documentación sobre el producto, visite Oracle Help Center.

Título e Información de Copyright

Manage System Time and Schedule Tasks on Oracle Linux

F49749-05

Oracle y/o sus filiales.