Módulo Ansible Cron

AnsibleBeginner
Pratique Agora

Introdução

Bem-vindo ao Laboratório do Módulo Ansible Cron! Neste laboratório, você aprenderá como automatizar o agendamento de tarefas usando o módulo Ansible Cron. O sistema cron é um agendador de tarefas baseado em tempo em sistemas operacionais semelhantes ao Unix, que permite aos usuários agendar comandos ou scripts para serem executados automaticamente em horários ou intervalos especificados.

Através deste laboratório, você aprenderá como usar o Ansible para criar, gerenciar e remover tarefas cron (cron jobs). Os exercícios progridem de configurações simples para configurações mais complexas, permitindo que você construa gradualmente suas habilidades com o módulo Ansible Cron. Ao final deste laboratório, você terá experiência prática com o agendamento de tarefas de maneira consistente e automatizada usando o Ansible.

Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível intermediário com uma taxa de conclusão de 68%. Recebeu uma taxa de avaliações positivas de 100% dos estudantes.

Criar uma Tarefa Cron Simples

Nesta etapa, você criará sua primeira tarefa cron usando o módulo Ansible Cron. A tarefa cron executará um script de shell simples em intervalos regulares.

Entendendo o Cron

Antes de começarmos, vamos entender o que é cron. Cron é um agendador de tarefas baseado em tempo em sistemas operacionais semelhantes ao Unix que permite aos usuários agendar comandos ou scripts para serem executados automaticamente em horários ou intervalos especificados. As tarefas cron são úteis para automatizar tarefas de manutenção do sistema, backups ou qualquer tarefa recorrente.

Criando o Playbook Ansible

Primeiro, você precisa criar um playbook Ansible que configurará a tarefa cron. No WebIDE, crie um novo arquivo no caminho /home/labex/project/cron_module_playbook.yaml clicando no botão "New File" no painel do explorador de arquivos.

New File

Insira o seguinte conteúdo no arquivo:

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

Vamos examinar cada parte deste playbook:

  • hosts: localhost - Isso especifica que o playbook será executado na máquina local.
  • tasks - Esta seção contém a lista de tarefas a serem executadas.
  • cron - Este é o módulo Ansible usado para gerenciar tarefas cron.
  • name: my_cron_job - Isso define um nome descritivo para a tarefa cron, tornando-a mais fácil de identificar no crontab.
  • minute: "*/5" - Isso agenda a tarefa para ser executada a cada 5 minutos. A sintaxe */5 significa "a cada minuto divisível por 5" (0, 5, 10, 15, etc.).
  • job: /home/labex/project/script.sh - Isso especifica o comando ou script a ser executado pela tarefa cron.

Criando o Script de Shell

Agora, você precisa criar o script de shell que a tarefa cron executará. Crie um novo arquivo no caminho /home/labex/project/script.sh no WebIDE.

Insira o seguinte conteúdo no arquivo de script:

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

Este script simples anexará uma mensagem e a data atual a um arquivo de log cada vez que for executado.

Tornando o Script Executável

Antes de executar o playbook, você precisa tornar o script executável. Abra um terminal no WebIDE e execute o seguinte comando:

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

Executando o Playbook Ansible

Agora, execute o playbook Ansible para criar a tarefa cron. No terminal, execute o seguinte comando:

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

Você deve ver uma saída semelhante 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

A linha changed: [localhost] indica que a tarefa cron foi criada com sucesso.

Verificando a Tarefa Cron

Para verificar se a tarefa cron foi criada, verifique o crontab no sistema com o seguinte comando:

crontab -l

Você deve ver uma saída semelhante a esta:

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

A linha #Ansible: my_cron_job é um comentário adicionado pelo Ansible para identificar a tarefa cron. A parte */5 * * * * representa a agenda (a cada 5 minutos), e /home/labex/project/script.sh é o comando a ser executado.

Parabéns! Você criou com sucesso uma tarefa cron usando o módulo Ansible Cron. A tarefa executará o script a cada 5 minutos.

Agendar uma Tarefa com Horário Personalizado

Nesta etapa, você aprenderá como agendar uma tarefa cron para ser executada em um horário específico, em vez de em intervalos regulares. Isso é útil para tarefas que precisam ser executadas em horários específicos do dia, como backups, processamento de dados ou geração de relatórios.

Entendendo o Formato de Tempo Cron

O formato de tempo cron consiste em cinco campos, representando:

  1. Minuto (0-59)
  2. Hora (0-23)
  3. Dia do mês (1-31)
  4. Mês (1-12)
  5. Dia da semana (0-7, onde 0 e 7 representam domingo)

Quando você especifica um valor para cada campo, a tarefa cron será executada quando todas as condições corresponderem. Por exemplo, 0 9 * * * significa "executar às 9:00 da manhã todos os dias" (minuto 0 da hora 9, qualquer dia do mês, qualquer mês, qualquer dia da semana).

Modificando o Playbook Ansible

Agora, vamos modificar o playbook existente para criar uma nova tarefa cron que seja executada em um horário específico. Abra o arquivo /home/labex/project/cron_module_playbook.yaml no WebIDE e substitua seu conteúdo pelo seguinte:

- 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

As alterações neste playbook incluem:

  • name: custom_cron_job - Estamos criando uma nova tarefa cron com um nome diferente.
  • minute: "0" - Isso define a tarefa para ser executada no minuto 0 (no início da hora).
  • hour: "9" - Isso define a tarefa para ser executada às 9h.

Os campos restantes (dia do mês, mês, dia da semana) não são especificados, o que significa que eles usam o padrão * (qualquer valor). Portanto, esta tarefa será executada às 9h00 todos os dias.

Executando o Playbook Modificado

Agora, execute o playbook Ansible modificado para criar a nova tarefa cron. No terminal, execute o seguinte comando:

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

Você deve ver uma saída semelhante 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

Verificando a Nova Tarefa Cron

Para verificar se a nova tarefa cron foi criada, verifique o crontab no sistema:

crontab -l

Você deve agora ver duas tarefas cron na saída:

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

A primeira tarefa é a que você criou na Etapa 1, que é executada a cada 5 minutos. A segunda tarefa é a nova que você acabou de criar, que é executada às 9h00 todos os dias.

Exemplos Adicionais de Agendamento Cron

Aqui estão alguns exemplos adicionais de agendamento cron para ajudá-lo a entender melhor o formato de tempo:

  • 0 * * * * - Executar no início de cada hora
  • 0 0 * * * - Executar à meia-noite todos os dias
  • 0 0 1 * * - Executar à meia-noite no primeiro dia de cada mês
  • 0 0 * * 0 - Executar à meia-noite todos os domingos
  • 0 12 * * 1-5 - Executar ao meio-dia nos dias úteis (segunda a sexta-feira)

Compreender esses padrões o ajudará a agendar suas tarefas de forma mais eficaz usando o módulo Ansible Cron.

Parabéns! Você agendou com sucesso uma tarefa cron para ser executada em um horário específico usando o módulo Ansible Cron.

Garantir que uma Tarefa Cron Execute como um Usuário Específico

Nesta etapa, você aprenderá como especificar qual usuário uma tarefa cron deve ser executada. Este é um aspecto importante da administração e segurança do sistema, pois permite controlar as permissões e o ambiente sob os quais as tarefas agendadas são executadas.

Entendendo o Contexto do Usuário para Tarefas Cron

Em sistemas semelhantes ao Unix, as tarefas cron herdam as permissões e o ambiente do usuário que as possui. Isso significa:

  1. A tarefa só pode acessar arquivos e recursos que o usuário tem permissão para acessar
  2. A tarefa é executada com as variáveis de ambiente e configurações do usuário
  3. Quaisquer arquivos criados pela tarefa serão de propriedade do usuário

Por padrão, quando você usa o módulo Ansible Cron sem especificar um usuário, a tarefa cron é criada para o usuário que está executando o playbook Ansible. No entanto, você pode definir explicitamente um usuário diferente com o parâmetro user.

Modificando o Playbook Ansible

Vamos modificar nosso playbook para especificar que a tarefa cron deve ser executada como o usuário labex. Abra o arquivo /home/labex/project/cron_module_playbook.yaml no WebIDE e substitua seu conteúdo pelo seguinte:

- 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

A adição chave aqui é:

  • user: labex - Este parâmetro especifica que a tarefa cron deve ser criada para o usuário labex.

Embora já estejamos executando como o usuário labex neste ambiente, defini-lo explicitamente é uma boa prática para clareza e portabilidade de seus playbooks para outros ambientes.

Executando o Playbook Modificado

Agora, execute o playbook Ansible modificado para atualizar a tarefa cron. No terminal, execute o seguinte comando:

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

Você deve ver uma saída semelhante 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

Observe que a saída mostra ok em vez de changed. Isso ocorre porque a tarefa cron já existe, e a única alteração é o parâmetro do usuário, que neste caso já está correto (já que estávamos executando como o usuário labex desde o início).

Verificando a Tarefa Cron

Para verificar se a tarefa cron ainda está configurada corretamente, verifique o crontab:

crontab -l

Você deve ver uma saída semelhante a:

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

Visualizando Tarefas Cron para um Usuário Específico

Se você quiser ver as tarefas cron para um usuário específico, pode usar a opção -u com o comando crontab:

sudo crontab -u labex -l

Este comando mostra todas as tarefas cron agendadas para o usuário labex. Em um ambiente de produção, você pode ter diferentes tarefas cron sendo executadas como usuários diferentes, dependendo dos níveis de acesso e permissões necessários para cada tarefa.

Considerações de Segurança

Ao agendar tarefas cron para diferentes usuários, considere as seguintes práticas de segurança:

  1. Use o princípio do menor privilégio - atribua tarefas cron a usuários com apenas as permissões necessárias para executar suas tarefas
  2. Evite agendar tarefas como o usuário root, a menos que seja absolutamente necessário
  3. Certifique-se de que os scripts executados pelas tarefas cron tenham as permissções e o tratamento de erros apropriados
  4. Considere o uso de ferramentas de gerenciamento de configuração como Ansible para manter configurações consistentes de tarefas cron em toda a sua infraestrutura

Parabéns! Você configurou com sucesso uma tarefa cron para ser executada como um usuário específico usando o módulo Ansible Cron. Essa habilidade o ajudará a gerenciar as tarefas do sistema de forma mais segura e eficaz.

Remover uma Tarefa Cron

Nesta etapa, você aprenderá como remover tarefas cron indesejadas usando o módulo Ansible Cron. Gerenciar o ciclo de vida completo das tarefas cron é uma habilidade importante para administradores de sistema e engenheiros de DevOps.

Por que Remover Tarefas Cron

Existem várias razões pelas quais você pode precisar remover tarefas cron:

  1. A tarefa agendada não é mais necessária
  2. Você deseja substituir uma tarefa existente por uma nova configuração
  3. Você precisa limpar o sistema para melhorar a capacidade de manutenção
  4. A tarefa precisa ser desativada temporariamente

O Ansible facilita a remoção de tarefas cron de forma sistemática e repetível em toda a sua infraestrutura.

Entendendo o Parâmetro State

O módulo Ansible Cron usa o parâmetro state para controlar se uma tarefa cron deve estar presente ou ausente:

  • state: present - Este é o padrão. Ele garante que a tarefa cron exista com a configuração especificada.
  • state: absent - Isso garante que a tarefa cron não exista, removendo-a se ela foi criada anteriormente.

Modificando o Playbook Ansible

Vamos modificar nosso playbook para remover a primeira tarefa cron que criamos (chamada my_cron_job). Abra o arquivo /home/labex/project/cron_module_playbook.yaml no WebIDE e substitua seu conteúdo pelo seguinte:

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

Os elementos-chave deste playbook são:

  • name: my_cron_job - Isso identifica a tarefa cron a ser removida por seu nome.
  • state: absent - Isso diz ao Ansible para garantir que a tarefa cron não exista.

Observe que só precisamos especificar o nome da tarefa cron para identificá-la para remoção. Os outros parâmetros (como minuto, hora, tarefa, etc.) não são necessários.

Executando o Playbook Modificado

Agora, execute o playbook Ansible modificado para remover a tarefa cron. No terminal, execute o seguinte comando:

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

Você deve ver uma saída semelhante 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

A linha changed: [localhost] indica que a tarefa cron foi removida com sucesso.

Verificando a Remoção da Tarefa Cron

Para verificar se a tarefa cron foi removida, verifique o crontab no sistema:

crontab -l

Você deve agora ver apenas a segunda tarefa cron na saída:

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

A entrada my_cron_job foi removida, conforme solicitado em nosso playbook.

Idempotência no Ansible

Uma das principais características do Ansible é a idempotência - a propriedade de que aplicar a mesma operação várias vezes dá o mesmo resultado que aplicá-la uma vez. Isso é especialmente útil para tarefas como remover tarefas cron.

Vamos executar o playbook novamente para demonstrar isso:

ansible-playbook cron_module_playbook.yaml

Você deve ver uma saída semelhante 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

Observe que, na segunda vez, a saída mostra ok em vez de changed para a tarefa de remoção. Isso ocorre porque a tarefa cron já foi removida, portanto, nenhuma alteração foi necessária.

Gerenciando Múltiplas Tarefas Cron

Em cenários do mundo real, você pode precisar gerenciar várias tarefas cron em um único playbook. Você pode incluir várias tarefas cron, cada uma com sua própria configuração:

- 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

Essa abordagem permite que você gerencie o ciclo de vida completo de todas as suas tarefas cron em um único playbook com controle de versão.

Parabéns! Você aprendeu com sucesso como remover tarefas cron usando o módulo Ansible Cron. Isso completa o gerenciamento básico do ciclo de vida das tarefas cron: criação, modificação e remoção.

Resumo

Parabéns por concluir o Lab do Módulo Ansible Cron! Ao longo deste laboratório, você adquiriu experiência prática com vários aspectos-chave do gerenciamento de tarefas agendadas usando o Ansible:

  1. Criando tarefas cron simples que são executadas em intervalos regulares
  2. Agendando tarefas para serem executadas em horários específicos usando expressões de tempo cron personalizadas
  3. Garantindo que as tarefas cron sejam executadas como usuários específicos para segurança e gerenciamento de permissões adequados
  4. Removendo tarefas cron que não são mais necessárias

Essas habilidades são essenciais para automatizar tarefas de administração do sistema, operações de manutenção e processos recorrentes em qualquer ambiente Linux. Ao usar o Ansible para gerenciar suas tarefas cron, você se beneficia de:

  • Configuração consistente em vários sistemas
  • Controle de versão de seus agendamentos de tarefas
  • Operações idempotentes que podem ser aplicadas repetidamente
  • Implantação e gerenciamento automatizados de tarefas agendadas

Ao continuar trabalhando com o Ansible, considere explorar recursos mais avançados do módulo Cron, como:

  • Definir variáveis de ambiente para tarefas cron
  • Usar especificações de tempo especiais como @daily ou @reboot
  • Combinar o gerenciamento cron com outros módulos Ansible para soluções de automação abrangentes

A capacidade de gerenciar efetivamente tarefas agendadas é uma habilidade valiosa que será útil na administração do sistema, DevOps e outras funções de TI.