Como au­to­ma­ti­zar tarefas com Ku­ber­ne­tes CronJob

O Ku­ber­ne­tes monitora ati­va­mente a im­ple­men­ta­ção de CronJobs e executa as ações definidas pelo usuário se houver erros. Com os arquivos YAML, a con­fi­gu­ra­ção dos Ku­ber­ne­tes CronJobs se trans­forma em um processo simples e direto.

O que é CronJob?

CronJob é um método para au­to­ma­ti­zar tarefas que pode ser comparado a um alarme: ele é con­fi­gu­rado para executar au­to­ma­ti­ca­mente de­ter­mi­na­das tarefas em horários es­pe­cí­fi­cos. Um CronJob é capaz de au­to­ma­ti­zar vários tipos de ações, como atualizar bancos de dados, fazer backups de arquivos, executar scripts e enviar e-mails em in­ter­va­los regulares. Ao integrar os CronJobs no Ku­ber­ne­tes, as tarefas passam a ser mo­ni­to­ra­das e ge­ren­ci­a­das iso­la­da­mente em con­têi­ne­res.

Como con­fi­gu­rar Ku­ber­ne­tes CronJobs

O processo de criação de um CronJob é muito parecido com o processo de criação de um job comum no Ku­ber­ne­tes. Para isso, é ne­ces­sá­rio criar um arquivo de manifesto YAML, uma descrição es­tru­tu­rada que contém todos os detalhes re­le­van­tes do CronJob. Você define pa­râ­me­tros im­por­tan­tes nesse arquivo, como agen­da­mento da re­a­li­za­ção da tarefa, os con­têi­ne­res usados e os comandos exatos que serão exe­cu­ta­dos neles.

Criar arquivo YAML

Abra o editor de texto da sua pre­fe­rên­cia para criar o arquivo de con­fi­gu­ra­ção YAML. Cer­ti­fi­que-se de definir o agen­da­mento do CronJob no formato Cron. Adicione a definição do job, incluindo a tarefa que será executada. Em seguida, salve o arquivo com a extensão .yaml.

apiVersion: batch/v1 
kind: CronJob 
metadata: 
    name: novo_cronjob 
spec: 
    schedule: "0     ****    " 
    jobTemplate: 
        spec: 
            template: 
                spec: 
                    containers: 
                    - name: container 
                        image: latest 
                        command:    
                     - /bin/sh

Se ne­ces­sá­rio, adicione os re­qui­si­tos de recursos e demais con­fi­gu­ra­ções na es­pe­ci­fi­ca­ção do contêiner:

spec: 
    containers: 
    - name: container 
        resources: 
            requests: 
                memory: "64Mi" 
                cpu: "250m" 
            limits: 
                memory: "128Mi" 
                cpu: "500m"

Ativar o CronJob

Insira o comando a seguir no terminal para criar o CronJob no cluster do Ku­ber­ne­tes:

kubectl apply -f [nomedoarquivo].yaml

Monitorar o CronJob

Ao executar o comando a seguir, você receberá uma lista dos Ku­ber­ne­tes CronJobs exis­ten­tes. O modo Watch garantirá a atu­a­li­za­ção au­to­má­tica do resultado quando o status do CronJob for alterado.

kubectl get cronjob --watch

Sintaxe de schedule no Ku­ber­ne­tes CronJob

A sintaxe do campo “schedule” do Ku­ber­ne­tes CronJob é baseada no clássico formato cron com cinco campos nesta ordem: minuto, hora, dia do mês, mês e dia da semana. Veja um resumo:

• Minuto (0–59)
• Hora (0–23)
• Dia do mês (1–31)
• Mês (1–12 ou Jan–Dec)
• Dia da semana (0–7 ou Sun–Sat)

Ca­rac­te­res especiais:

• *: Cada valor válido para o campo
• ,: Es­pe­ci­fi­ca­ção de múltiplos valores
• /: Es­pe­ci­fi­ca­ção dos passos

Exemplos:

0 ****: A cada hora 15 2 ***: Di­a­ri­a­mente às 2h15 0 0 1 **: No primeiro dia de cada mês à meia-noite 0 0 *3*: Di­a­ri­a­mente à meia-noite no mês de março 0 2 ** 1: Todas as segundas-feiras às 2h

Política de si­mul­ta­nei­dade do CronJobs

Uma política de si­mul­ta­nei­dade pode ser es­pe­ci­fi­cada na con­fi­gu­ra­ção de um CronJob. Ela afeta a forma como jobs paralelos são exe­cu­ta­dos dentro do mesmo Ku­ber­ne­tes CronJob.

• Allow (padrão): Se a política de si­mul­ta­nei­dade for definida como __Allow__, um novo job será iniciado mesmo se o anterior ainda não tiver sido concluído. Isso significa que diversas ins­tân­cias do mesmo job podem ocorrer ao mesmo tempo.
• Forbid: Com essa con­fi­gu­ra­ção, um novo job não é iniciado se o anterior ainda não tiver sido concluído. Isso garante que apenas uma instância do job seja executada em de­ter­mi­nado momento.
• Replace: Jobs não con­cluí­dos são can­ce­la­dos para que os novos possam continuar. Ins­tân­cias do mesmo job não podem ser exe­cu­ta­das ao mesmo tempo.

Definir prazo de execução

O campo startingDeadlineSeconds de um Ku­ber­ne­tes CronJob es­pe­ci­fica o número máximo de segundos após o horário de execução agendado em que um job pode ser iniciado. Se não for executado dentro desse limite, considera-se que o job ** * falhou*.

apiVersion: batch/v1 
kind: CronJob 
metadata: 
    name: novo_cronjob 
spec: 
    schedule: "0     ****    " 
    startingDeadlineSeconds: 300    
    jobTemplate: 
        spec: 
            template: 
                spec: 
                    containers: 
                    - name: container 
                        image:latest 
                        command: 
                     - /bin/sh

No exemplo acima, a tarefa definida no CronJob deverá começar até 300 segundos (cinco minutos) após o horário agendado. Do contrário, o job falhará.

Limitar o histórico de jobs

As con­fi­gu­ra­ções spec.successfulJobsHistoryLimit e spec.failedJobsHistoryLimit de um Ku­ber­ne­tes CronJob permite limitar o número de jobs mantidos no histórico do CronJob. spec.successfulJobsHistoryLimit é um campo opcional que es­pe­ci­fica quantos jobs con­cluí­dos devem ser salvos no histórico. Essa limitação é útil para controlar a uti­li­za­ção de recursos e assegurar que o histórico não fique so­bre­car­re­gado com um número excessivo de jobs con­cluí­dos. De forma similar, o campo spec.failedJobsHistoryLimit pos­si­bi­lita controlar o número de jobs que falharam.

apiVersion: batch/v1beta1 
kind: CronJob 
metadata: 
    name: novo_cronjob 
spec: 
    schedule: "0     ****    " 
    successfulJobsHistoryLimit: 3    # Salva apenas os últimos 3 jobs concluídos no histórico. 
    failedJobsHistoryLimit: 1                    # Salva apenas o último job que falhou no histórico. 
    jobTemplate: 
        spec: 
            template: 
                spec: 
                    containers: 
                    - name: container 
                        image: latest 
                        command: 
                     - /bin/sh

No exemplo, es­pe­ci­fi­ca­mos que apenas os três últimos jobs con­cluí­dos e o último job com falha devem ser salvos no histórico do Ku­ber­ne­tes CronJob in­ti­tu­lado novo_cronjob.

Problemas e soluções do Ku­ber­ne­tes Cronjob

Diversos erros podem acontecer com um Ku­ber­ne­tes CronJob, portanto, é im­por­tante que você conheça algumas técnicas de resolução de problemas. Listamos abaixo algumas causas de erros comuns e apre­sen­ta­mos dicas para resolvê-los:

O job não inicia

Existem várias causas pelas quais um CronJob não inicia no Ku­ber­ne­tes, incluindo uma imagem de contêiner incorreta ou in­dis­po­ní­vel e ausência de au­to­ri­za­ções para a conta de serviço do pod. Para di­ag­nos­ti­car o problema, examine os logs do contêiner com o comando kubectl logs <nome-do-pod>, os eventos do CronJob com kubectl describe cronjob <nome-do-cronjob> e os eventos do pod com kubectl describe pod <nome-do-pod>. Cer­ti­fi­que-se de que a conta de serviço tenha as au­to­ri­za­ções ne­ces­sá­rias, ve­ri­fi­cando a função e a vin­cu­la­ção de função.

Con­fi­gu­ra­ção incorreta do CronJob

Uma con­fi­gu­ra­ção incorreta do CronJob pode ocorrer devido a erros de sintaxe no arquivo YAML ou con­fi­gu­ra­ções in­cor­re­tas nos campos “schedule” e “res­tart­Po­licy”. Para iden­ti­fi­car esses problemas, acesse o arquivo YAML e verifique se sua sintaxe e con­fi­gu­ra­ção estão corretas. Você pode usar o comando kubectl describe cronjob <nome-do-cronjob> para obter in­for­ma­ções de­ta­lha­das sobre a con­fi­gu­ra­ção e iden­ti­fi­car possíveis erros ou in­con­sis­tên­cias.

Limite de recursos excedidos

Exceder os limites de recursos pode fazer com que os CronJobs não sejam exe­cu­ta­dos cor­re­ta­mente. Para so­lu­ci­o­nar o problema, verifique os limites de recursos do CronJob e dos res­pec­ti­vos pods usando o comando kubectl describe cronjob <nome-do-cronjob> e kubectl describe pod <nome-do-pod>. Além disso, realizar o mo­ni­to­ra­mento da uti­li­za­ção de recursos do cluster com os comandos kubectl top nodes e kubectl top pods também traz insights valiosos. Se ne­ces­sá­rio, ajuste os limites de recursos no arquivo YAML.

Para dar os primeiros passos no ge­ren­ci­a­mento de clusters no Ku­ber­ne­tes, re­co­men­da­mos a leitura do tutorial de Ku­ber­ne­tes no nosso Digital Guide.