CronJobs

Nesta página, explicamos como executar CronJobs no Google Kubernetes Engine. CronJobs são um recurso nativo do Kubernetes. Para mais detalhes, consulte a documentação do Kubernetes sobre CronJobs.

Visão geral

É possível usar CronJobs para executar tarefas em horários ou intervalos específicos. Os CronJobs são uma boa opção para tarefas automáticas, como backups, relatórios, envio de e-mails ou tarefas de limpeza.

Os CronJobs usam objetos job para concluir as tarefas. Um CronJob cria um objeto job sempre que é executado. Os CronJobs são criados, gerenciados, escalonados e excluídos da mesma forma que os jobs. Para saber mais sobre jobs, consulte Como executar um job.

Antes de começar

Prepare-se para a tarefa tomando as seguintes medidas:

  • Verifique se você ativou a API Google Kubernetes Engine.
  • Ativar a API Google Kubernetes Engine
  • Verifique se o SDK do Cloud está instalado.
  • Defina o ID do projeto padrão:
    gcloud config set project [PROJECT_ID]
  • Se você estiver trabalhando com clusters zonais, defina a zona do Compute padrão:
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Se você estiver trabalhando com clusters regionais, defina a região do Compute padrão:
    gcloud config set compute/region [COMPUTE_REGION]
  • Atualize gcloud para a versão mais recente:
    gcloud components update

Como criar um CronJob

Este CronJob imprime o horário atual e uma string uma vez por minuto:

# cronjob.yaml
apiVersion: batch/v1beta1
kind: CronJob
metadata:
  name: hello
spec:
  schedule: "*/1 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: hello
            image: busybox
            args:
            - /bin/sh
            - -c
            - date; echo "Hello, World!"
          restartPolicy: OnFailure

Para criar esse CronJob, salve o manifesto YAML em um arquivo e aplique-o ao cluster usando kubectl apply -f [FILENAME].

Nas próximas seções há mais detalhes sobre a especificação de quando o CronJob é executado e do que realmente é executado.

Como especificar quando o CronJob é executado

O campo spec.schedule define quando e com que frequência o CronJob é executado, usando o formato crontab padrão do Unix. Todos os horários do CronJob estão em UTC: Há cinco campos, separados por espaços. Esses campos representam:

  1. Minutos (entre 0 e 59)
  2. Horas (entre 0 e 23)
  3. Dia do mês (entre 1 e 31)
  4. Mês (entre 1 e 12)
  5. Dia da semana (entre 0 e 6)

É possível usar os caracteres especiais a seguir em qualquer um dos campos spec.schedule:

  • ? é um valor de caractere curinga que corresponde a um único caractere.
  • * é um valor curinga que corresponde a zero ou mais caracteres.
  • / permite que você especifique um intervalo para um campo. Por exemplo, se o primeiro campo (o campo minutos) tem um valor de */5, significa “a cada 5 minutos”. Se o quinto campo (o do dia da semana) estiver definido como 0/5, significa “a cada cinco domingos”.

Como especificar o que o CronJob executa

O spec.jobTemplate descreve o que o CronJob faz, incluindo as imagens de contêiner, os comandos que os contêineres executam e a política de reinicialização do CronJob.

Como especificar um prazo

O campo opcional startingDeadlineSeconds indica o número máximo de segundos que o CronJob pode levar para iniciar se, por qualquer motivo, não o fizer no horário programado. Os CronJobs perdidos são considerados falhas.

Para especificar um prazo, adicione o valor de startingDeadlineSeconds ao campo spec do CronJob no arquivo de manifesto. Por exemplo, o seguinte manifesto especifica que o CronJob tem 100 segundos para começar:

apiVersion: batch/v1beta1
kind: CronJob
metadata:
  name: hello
spec:
  schedule: "*/1 * * * *"
  startingDeadlineSeconds: 100
  jobTemplate:
    spec:
    ...

Se você não especificar um valor para startingDeadlineSeconds, o CronJob nunca atingirá o tempo limite. Isso pode fazer com que o mesmo CronJob seja executado várias vezes simultaneamente. Para evitar esse tipo de problema, consulte Como especificar uma política de simultaneidade.

Como especificar uma política de simultaneidade

O campo opcional spec.concurrencyPolicy especifica como tratar execuções simultâneas de um job criado pelo controlador do CronJob. Se você não definir um valor, vários jobs simultâneos serão permitidos por padrão.

concurrencyPolicy aceita os seguintes valores:

Valor Significado
Allow Jobs simultâneos são permitidos. Esse é o padrão.
Forbid Jobs simultâneos são proibidos e não é possível iniciar jobs novos até que os anteriores estejam concluídos ou expirados.
Replace Jobs simultâneos são proibidos e jobs antigos são cancelados em favor de jobs novos.

Como suspender execuções subsequentes

O campo opcional spec.suspend, quando definido como true, impede que novos jobs sejam executados, mas permite que as execuções atuais sejam concluídas.

Como especificar limites de histórico

Um CronJob cria um pod sempre que é executado. A visualização do status de encerramento das execuções recentes de um CronJob, bem como os registros de um pod individual, são abordados em Como visualizar o histórico de CronJobs.

Configure o número de execuções bem-sucedidas e com falha de CronJobs que são salvas especificando valores para spec.successfulJobsHistoryLimit e spec.failedJobsHistoryLimit. Por padrão, successfulJobsHistoryLimit é definido como 3 e failedJobsHistoryLimit é definido como 1.

Para desativar a retenção de dados sobre jobs concluídos ou que falharam, defina o respectivo valor como 0. No entanto, as falhas de depuração podem ser mais difíceis.

Como inspecionar um CronJob

Para verificar a configuração de um CronJob, use kubectl describe:

kubectl describe cronjob [CRON_JOB]

Como visualizar o histórico de CronJobs

Um CronJob é executado dentro de um pod. Por padrão, o Kubernetes preserva os registros para pods encerrados que representam as três últimas execuções bem-sucedidas de um CronJob e o último trabalho com falha. É possível alterar ou desativar esses padrões.

Para visualizar o histórico de um CronJob, primeiro liste todos os pods. Os CronJobs concluídos são mostrados com status Completed, e os jobs que falharam têm status RunContainerError, CrashLoopBackOff ou outro que indique uma falha.

kubectl get pods

NAME                                READY   STATUS              RESTARTS   AGE
hello-1556555640-9bc5r              0/1     Completed           0          3m6s
hello-1556555700-cm6wk              0/1     Completed           0          2m6s
hello-1556555760-62wf5              0/1     Completed           0          66s
hello-1556555820-rl8kl              0/1     Completed           0          5s
hello-failed-1556555820-wrvt2       0/1     RunContainerError   1          5s

Para visualizar os registros de um CronJob específico, use kubectl get logs com o nome do pod:

kubectl get logs hello-failed-1556555820-wrvt2

container_linux.go:247: starting container process caused
"exec: \"/in/sh\": stat /in/sh: no such file or directory"

Como excluir um CronJob

Para excluir um CronJob, use kubectl delete:

kubectl delete cronjob [CRON_JOB]

Ao excluir um CronJob, o coletor de lixo do Kubernetes excluir os jobs associados e impede o início de novos jobs.

A seguir

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Documentação do Kubernetes Engine