Módulo Ansible Cron

AnsibleBeginner
Practicar Ahora

Introducción

¡Bienvenido al laboratorio del módulo Ansible Cron! En este laboratorio, aprenderá cómo automatizar la programación de tareas utilizando el módulo Ansible Cron. El sistema cron es un programador de tareas basado en el tiempo en sistemas operativos similares a Unix que permite a los usuarios programar comandos o scripts para que se ejecuten automáticamente en momentos o intervalos específicos.

A través de este laboratorio, aprenderá cómo usar Ansible para crear, gestionar y eliminar trabajos cron. Los ejercicios progresan de configuraciones simples a más complejas, lo que le permite desarrollar gradualmente sus habilidades con el módulo Ansible Cron. Al final de este laboratorio, tendrá experiencia práctica en la programación de tareas de manera consistente y automatizada utilizando Ansible.

Este es un Guided Lab, que proporciona instrucciones paso a paso para ayudarte a aprender y practicar. Sigue las instrucciones cuidadosamente para completar cada paso y obtener experiencia práctica. Los datos históricos muestran que este es un laboratorio de nivel intermedio con una tasa de finalización del 68%. Ha recibido una tasa de reseñas positivas del 100% por parte de los estudiantes.

Crear un trabajo cron simple

En este paso, creará su primer trabajo cron utilizando el módulo Ansible Cron. El trabajo cron ejecutará un script de shell simple en intervalos regulares.

Comprender cron

Antes de comenzar, entendamos qué es cron. Cron es un programador de tareas basado en el tiempo en sistemas operativos similares a Unix que permite a los usuarios programar comandos o scripts para que se ejecuten automáticamente en momentos o intervalos específicos. Los trabajos cron son útiles para automatizar tareas de mantenimiento del sistema, copias de seguridad o cualquier tarea recurrente.

Crear el playbook de Ansible

Primero, debe crear un playbook de Ansible que configurará el trabajo cron. En el WebIDE, cree un nuevo archivo en la ruta /home/labex/project/cron_module_playbook.yaml haciendo clic en el botón "Nuevo archivo" en el panel del explorador de archivos.

Nuevo archivo

Ingrese el siguiente contenido en el archivo:

- hosts: localhost
  tasks:
    - name: Create a simple cron job
      cron:
        name: my_cron_job
        minute: "*/5"
        job: /home/labex/project/script.sh

Examinemos cada parte de este playbook:

  • hosts: localhost - Esto especifica que el playbook se ejecutará en la máquina local.
  • tasks - Esta sección contiene la lista de tareas a ejecutar.
  • cron - Este es el módulo de Ansible utilizado para gestionar trabajos cron.
  • name: my_cron_job - Esto establece un nombre descriptivo para el trabajo cron, lo que facilita su identificación en el crontab.
  • minute: "*/5" - Esto programa el trabajo para que se ejecute cada 5 minutos. La sintaxis */5 significa "cada minuto divisible por 5" (0, 5, 10, 15, etc.).
  • job: /home/labex/project/script.sh - Esto especifica el comando o script que se ejecutará mediante el trabajo cron.

Crear el script de shell

Ahora, debe crear el script de shell que ejecutará el trabajo cron. Cree un nuevo archivo en la ruta /home/labex/project/script.sh en el WebIDE.

Ingrese el siguiente contenido en el archivo del script:

#!/bin/bash
echo "This is a simple script." >> /home/labex/project/cron_output.log
date >> /home/labex/project/cron_output.log

Este simple script agregará un mensaje y la fecha actual a un archivo de registro cada vez que se ejecute.

Hacer el script ejecutable

Antes de ejecutar el playbook, debe hacer que el script sea ejecutable. Abra una terminal en el WebIDE y ejecute el siguiente comando:

chmod +x /home/labex/project/script.sh

Ejecutar el playbook de Ansible

Ahora, ejecute el playbook de Ansible para crear el trabajo cron. En la terminal, ejecute el siguiente comando:

cd /home/labex/project
ansible-playbook cron_module_playbook.yaml

Debería ver una salida similar a esta:

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [localhost] ***************************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Create a simple cron job] ************************************************
changed: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

La línea changed: [localhost] indica que el trabajo cron se creó correctamente.

Verificar el trabajo cron

Para verificar que se haya creado el trabajo cron, consulte el crontab del sistema con el siguiente comando:

crontab -l

Debería ver una salida similar a esta:

#Ansible: my_cron_job
*/5 * * * * /home/labex/project/script.sh

La línea #Ansible: my_cron_job es un comentario agregado por Ansible para identificar el trabajo cron. La parte */5 * * * * representa la programación (cada 5 minutos), y /home/labex/project/script.sh es el comando a ejecutar.

¡Felicidades! Ha creado con éxito un trabajo cron utilizando el módulo Ansible Cron. El trabajo ejecutará el script cada 5 minutos.

Programar una tarea con tiempo personalizado

En este paso, aprenderá cómo programar un trabajo cron para que se ejecute en un momento específico en lugar de en intervalos regulares. Esto es útil para tareas que deben ejecutarse en momentos particulares del día, como copias de seguridad, procesamiento de datos o generación de informes.

Comprender el formato de tiempo de cron

El formato de tiempo de cron consta de cinco campos, que representan:

  1. Minuto (0-59)
  2. Hora (0-23)
  3. Día del mes (1-31)
  4. Mes (1-12)
  5. Día de la semana (0-7, donde tanto 0 como 7 representan el domingo)

Cuando se especifica un valor para cada campo, el trabajo cron se ejecutará cuando se cumplan todas las condiciones. Por ejemplo, 0 9 * * * significa "ejecutar a las 9:00 AM todos los días" (minuto 0 de la hora 9, cualquier día del mes, cualquier mes, cualquier día de la semana).

Modificar el playbook de Ansible

Ahora, modifiquemos el playbook existente para crear un nuevo trabajo cron que se ejecute en un momento específico. Abra el archivo /home/labex/project/cron_module_playbook.yaml en el WebIDE y reemplace su contenido con lo siguiente:

- hosts: localhost
  tasks:
    - name: Schedule a task with custom time
      cron:
        name: custom_cron_job
        minute: "0"
        hour: "9"
        job: /home/labex/project/script.sh

Los cambios en este playbook incluyen:

  • name: custom_cron_job - Estamos creando un nuevo trabajo cron con un nombre diferente.
  • minute: "0" - Esto establece que el trabajo se ejecute en el minuto 0 (comienzo de la hora).
  • hour: "9" - Esto establece que el trabajo se ejecute a las 9 AM.

Los campos restantes (día del mes, mes, día de la semana) no se especifican, lo que significa que tienen un valor predeterminado de * (cualquier valor). Entonces, este trabajo se ejecutará a las 9:00 AM todos los días.

Ejecutar el playbook modificado

Ahora, ejecute el playbook de Ansible modificado para crear el nuevo trabajo cron. En la terminal, ejecute el siguiente comando:

cd /home/labex/project
ansible-playbook cron_module_playbook.yaml

Debería ver una salida similar a esta:

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [localhost] ***************************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Schedule a task with custom time] ****************************************
changed: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Verificar el nuevo trabajo cron

Para verificar que se haya creado el nuevo trabajo cron, consulte el crontab del sistema:

crontab -l

Ahora debería ver dos trabajos cron en la salida:

#Ansible: my_cron_job
*/5 * * * * /home/labex/project/script.sh
#Ansible: custom_cron_job
0 9 * * * /home/labex/project/script.sh

El primer trabajo es el que creó en el Paso 1, que se ejecuta cada 5 minutos. El segundo trabajo es el nuevo que acaba de crear, que se ejecuta a las 9:00 AM todos los días.

Ejemplos adicionales de programación de cron

A continuación, se presentan algunos ejemplos adicionales de programación de cron para ayudarlo a entender mejor el formato de tiempo:

  • 0 * * * * - Ejecutar al comienzo de cada hora
  • 0 0 * * * - Ejecutar a la medianoche todos los días
  • 0 0 1 * * - Ejecutar a la medianoche el primer día de cada mes
  • 0 0 * * 0 - Ejecutar a la medianoche todos los domingos
  • 0 12 * * 1-5 - Ejecutar al mediodía de lunes a viernes

Comprender estos patrones le ayudará a programar sus tareas de manera más efectiva utilizando el módulo Ansible Cron.

¡Felicidades! Ha programado con éxito un trabajo cron para que se ejecute en un momento específico utilizando el módulo Ansible Cron.

Asegurarse de que un trabajo cron se ejecute como un usuario específico

En este paso, aprenderá cómo especificar como qué usuario debe ejecutarse un trabajo cron. Esto es un aspecto importante de la administración y seguridad del sistema, ya que le permite controlar los permisos y el entorno en el que se ejecutan las tareas programadas.

Comprender el contexto de usuario para trabajos cron

En sistemas similares a Unix, los trabajos cron heredan los permisos y el entorno del usuario que los posee. Esto significa:

  1. El trabajo solo puede acceder a archivos y recursos a los que el usuario tiene permiso de acceder.
  2. El trabajo se ejecuta con las variables de entorno y configuraciones del usuario.
  3. Cualquier archivo creado por el trabajo será propiedad del usuario.

Por defecto, cuando se utiliza el módulo Ansible Cron sin especificar un usuario, el trabajo cron se crea para el usuario que ejecuta el playbook de Ansible. Sin embargo, se puede establecer explícitamente un usuario diferente con el parámetro user.

Modificar el playbook de Ansible

Modifiquemos nuestro playbook para especificar que el trabajo cron se debe ejecutar como el usuario labex. Abra el archivo /home/labex/project/cron_module_playbook.yaml en el WebIDE y reemplace su contenido con lo siguiente:

- hosts: localhost
  tasks:
    - name: Schedule a task with custom time for specific user
      cron:
        name: custom_cron_job
        minute: "0"
        hour: "9"
        job: /home/labex/project/script.sh
        user: labex

La adición clave aquí es:

  • user: labex - Este parámetro especifica que el trabajo cron se debe crear para el usuario labex.

Aunque ya estamos ejecutando como el usuario labex en este entorno, establecerlo explícitamente es una buena práctica para la claridad y la portabilidad de sus playbooks a otros entornos.

Ejecutar el playbook modificado

Ahora, ejecute el playbook de Ansible modificado para actualizar el trabajo cron. En la terminal, ejecute el siguiente comando:

cd /home/labex/project
ansible-playbook cron_module_playbook.yaml

Debería ver una salida similar a esta:

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [localhost] ***************************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Schedule a task with custom time for specific user] **********************
ok: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Note que la salida muestra ok en lugar de changed. Esto se debe a que el trabajo cron ya existe, y el único cambio es el parámetro de usuario, que en este caso ya es correcto (ya que desde el principio estábamos ejecutando como el usuario labex).

Verificar el trabajo cron

Para verificar que el trabajo cron sigue configurado correctamente, consulte el crontab:

crontab -l

Debería ver una salida similar a:

#Ansible: my_cron_job
*/5 * * * * /home/labex/project/script.sh
#Ansible: custom_cron_job
0 9 * * * /home/labex/project/script.sh

Ver los trabajos cron de un usuario específico

Si desea ver los trabajos cron de un usuario específico, puede usar la opción -u con el comando crontab:

sudo crontab -u labex -l

Este comando muestra todos los trabajos cron programados para el usuario labex. En un entorno de producción, es posible que tenga diferentes trabajos cron ejecutándose como diferentes usuarios según los niveles de acceso y permisos requeridos para cada tarea.

Consideraciones de seguridad

Al programar trabajos cron para diferentes usuarios, considere las siguientes prácticas de seguridad:

  1. Utilice el principio de privilegio mínimo - asigne trabajos cron a usuarios con solo los permisos que necesitan para realizar sus tareas.
  2. Evite programar tareas como el usuario root a menos que sea absolutamente necesario.
  3. Asegúrese de que los scripts ejecutados por los trabajos cron tengan permisos adecuados y manejo de errores.
  4. Considere utilizar herramientas de gestión de configuración como Ansible para mantener configuraciones de trabajos cron consistentes en toda su infraestructura.

¡Felicidades! Ha configurado con éxito un trabajo cron para que se ejecute como un usuario específico utilizando el módulo Ansible Cron. Esta habilidad le ayudará a administrar las tareas del sistema de manera más segura y efectiva.

Eliminar un trabajo cron

En este paso, aprenderá cómo eliminar trabajos cron no deseados utilizando el módulo Ansible Cron. Gestionar el ciclo de vida completo de los trabajos cron es una habilidad importante para los administradores de sistemas y los ingenieros DevOps.

Por qué eliminar trabajos cron

Hay varias razones por las cuales es posible que necesite eliminar trabajos cron:

  1. La tarea programada ya no es necesaria.
  2. Desea reemplazar un trabajo existente con una nueva configuración.
  3. Necesita limpiar el sistema para mejorar su mantenibilidad.
  4. La tarea debe deshabilitarse temporalmente.

Ansible facilita la eliminación de trabajos cron de manera sistemática y repetible en toda su infraestructura.

Comprender el parámetro state

El módulo Ansible Cron utiliza el parámetro state para controlar si un trabajo cron debe estar presente o ausente:

  • state: present - Este es el valor predeterminado. Asegura que el trabajo cron exista con la configuración especificada.
  • state: absent - Esto asegura que el trabajo cron no exista, eliminándolo si se creó previamente.

Modificar el playbook de Ansible

Modifiquemos nuestro playbook para eliminar el primer trabajo cron que creamos (llamado my_cron_job). Abra el archivo /home/labex/project/cron_module_playbook.yaml en el WebIDE y reemplace su contenido con lo siguiente:

- hosts: localhost
  tasks:
    - name: Remove the cron job
      cron:
        name: my_cron_job
        state: absent

Los elementos clave de este playbook son:

  • name: my_cron_job - Esto identifica el trabajo cron que se va a eliminar por su nombre.
  • state: absent - Esto le dice a Ansible que asegure que el trabajo cron no exista.

Tenga en cuenta que solo necesitamos especificar el nombre del trabajo cron para identificarlo para su eliminación. No se necesitan los otros parámetros (como minuto, hora, trabajo, etc.).

Ejecutar el playbook modificado

Ahora, ejecute el playbook de Ansible modificado para eliminar el trabajo cron. En la terminal, ejecute el siguiente comando:

cd /home/labex/project
ansible-playbook cron_module_playbook.yaml

Debería ver una salida similar a esta:

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [localhost] ***************************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Remove the cron job] *****************************************************
changed: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

La línea changed: [localhost] indica que el trabajo cron se eliminó correctamente.

Verificar la eliminación del trabajo cron

Para verificar que el trabajo cron se ha eliminado, consulte el crontab del sistema:

crontab -l

Ahora debería ver solo el segundo trabajo cron en la salida:

#Ansible: custom_cron_job
0 9 * * * /home/labex/project/script.sh

La entrada my_cron_job se ha eliminado, como se solicitó en nuestro playbook.

Idempotencia en Ansible

Una de las características clave de Ansible es la idempotencia, la propiedad de que aplicar la misma operación varias veces da el mismo resultado que aplicarla una vez. Esto es especialmente útil para tareas como la eliminación de trabajos cron.

Ejecutemos el playbook nuevamente para demostrar esto:

ansible-playbook cron_module_playbook.yaml

Debería ver una salida similar a:

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [localhost] ***************************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Remove the cron job] *****************************************************
ok: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Note que la segunda vez, la salida muestra ok en lugar de changed para la tarea de eliminación. Esto se debe a que el trabajo cron ya se había eliminado, por lo que no se necesitaron cambios.

Gestionar múltiples trabajos cron

En escenarios del mundo real, es posible que necesite gestionar múltiples trabajos cron en un solo playbook. Puede incluir múltiples tareas cron, cada una con su propia configuración:

- hosts: localhost
  tasks:
    - name: Remove first cron job
      cron:
        name: job1
        state: absent

    - name: Create second cron job
      cron:
        name: job2
        minute: "0"
        hour: "12"
        job: /path/to/script.sh

    - name: Update third cron job
      cron:
        name: job3
        minute: "*/10"
        job: /path/to/another/script.sh

Este enfoque le permite gestionar el ciclo de vida completo de todos sus trabajos cron en un solo playbook controlado por versiones.

¡Felicidades! Ha aprendido con éxito cómo eliminar trabajos cron utilizando el módulo Ansible Cron. Esto completa la gestión básica del ciclo de vida de los trabajos cron: creación, modificación y eliminación.

Resumen

¡Felicidades por completar el laboratorio del módulo Ansible Cron! A lo largo de este laboratorio, ha adquirido experiencia práctica en varios aspectos clave de la gestión de tareas programadas utilizando Ansible:

  1. Crear trabajos cron simples que se ejecutan a intervalos regulares.
  2. Programar tareas para que se ejecuten en momentos específicos utilizando expresiones de tiempo cron personalizadas.
  3. Asegurarse de que los trabajos cron se ejecuten como usuarios específicos para una adecuada gestión de seguridad y permisos.
  4. Eliminar trabajos cron que ya no son necesarios.

Estas habilidades son esenciales para automatizar tareas de administración de sistemas, operaciones de mantenimiento y procesos recurrentes en cualquier entorno Linux. Al utilizar Ansible para gestionar sus trabajos cron, se beneficia de:

  • Configuración consistente en múltiples sistemas.
  • Control de versiones de sus programaciones de trabajos.
  • Operaciones idempotentes que se pueden aplicar repetidamente.
  • Despliegue y gestión automatizados de tareas programadas.

A medida que continúe trabajando con Ansible, considere explorar características más avanzadas del módulo Cron, como:

  • Establecer variables de entorno para trabajos cron.
  • Utilizar especificaciones de tiempo especiales como @daily o @reboot.
  • Combinar la gestión de cron con otros módulos de Ansible para soluciones de automatización integrales.

La capacidad de gestionar eficazmente las tareas programadas es una habilidad valiosa que le será de gran utilidad en la administración de sistemas, DevOps y otros roles de TI.