Pesquisa de site

Um guia para iniciantes em Kubernetes Jobs e CronJobs


Use Jobs e CronJobs para controlar e gerenciar pods e contêineres do Kubernetes.

Kubernetes é o mecanismo de orquestração padrão para contêineres. Suas opções para controlar e gerenciar pods e contêineres incluem:

  1. Implantações
  2. StatefulSets
  3. Conjuntos de réplicas

Cada um desses recursos tem sua própria finalidade, com a função comum de garantir que os pods sejam executados continuamente. Em cenários de falha, esses controladores reiniciam ou reagendam os pods para garantir que os serviços nos pods continuem em execução.

Conforme explica a documentação do Kubernetes, um trabalho do Kubernetes cria um ou mais pods e garante que um número especificado de pods termine quando a tarefa (trabalho) for concluída.

Assim como em um sistema operacional típico, a capacidade de executar tarefas agendadas e automatizadas sem interação do usuário é importante no mundo Kubernetes. Mas os trabalhos do Kubernetes fazem mais do que apenas executar trabalhos automatizados, e há várias maneiras de utilizá-los por meio de:

  1. Empregos
  2. CronJobs
  3. Filas de trabalho (isso está além do escopo deste artigo)

Parece simples, certo? Bem, talvez. Qualquer pessoa que trabalhe com contêineres e aplicativos de microsserviços sabe que alguns exigem que os serviços sejam transitórios para que possam realizar tarefas específicas para aplicativos ou dentro dos clusters Kubernetes.

Neste artigo, explicarei por que os jobs do Kubernetes são importantes, como criar jobs e CronJobs e quando usá-los para aplicativos em execução no cluster do Kubernetes.

Diferenças entre trabalhos do Kubernetes e CronJobs

Os trabalhos do Kubernetes são usados para criar pods transitórios que executam tarefas específicas às quais estão atribuídos. CronJobs fazem a mesma coisa, mas executam tarefas com base em um cronograma definido.

Os trabalhos desempenham um papel importante no Kubernetes, especialmente para executar processos em lote ou operações ad hoc importantes. Os trabalhos diferem de outros controladores Kubernetes porque executam tarefas até a conclusão, em vez de gerenciar o estado desejado, como em Deployments, ReplicaSets e StatefulSets.

Como criar trabalhos e CronJobs do Kubernetes

Com esse histórico em mãos, você pode começar a criar Jobs e CronJobs.

Pré-requisitos

Para fazer este exercício, você precisa ter o seguinte:

  1. Um cluster Kubernetes funcional; você pode instalá-lo com:

    • CentOS 8
    • Minikubo
  2. A linha de comando do kubectl Kubernetes

Aqui está a implantação do Minikube que usei para esta demonstração:

$ minikube version
minikube version: v1.8.1

$ kubectl cluster-info
Kubernetes master is running at https://172.17.0.59:8443
KubeDNS is running at https://172.17.0.59:8443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

$ kubectl get nodes
NAME       STATUS   ROLES    AGE   VERSION
minikube   Ready    master   88s   v1.17.3

Vagas do Kubernetes

Assim como qualquer outra coisa no mundo do Kubernetes, você pode criar trabalhos do Kubernetes com um arquivo de definição. Crie um arquivo chamado sample-jobs.yaml usando seu editor favorito.

Aqui está um trecho do arquivo que você pode usar para criar um exemplo de job do Kubernetes:

apiVersion: batch/v1          ## The version of the Kubernetes API
kind: Job                     ## The type of object for jobs
metadata:
 name: job-test
spec:                         ## What state you desire for the object
 template:
   metadata:
     name: job-test
   spec:
     containers:
     - name: job
       image: busybox                  ##  Image used
       command: ["echo", "job-test"]   ##  Command used to create logs for verification later
     restartPolicy: OnFailure          ##  Restart Policy in case container failed

Em seguida, aplique os Jobs no cluster:

$ kubectl apply -f sample-jobs.yaml

Aguarde alguns minutos para que os pods sejam criados. Você pode visualizar o status de criação do pod:

$ kubectl get pod –watch

Após alguns segundos, você verá seu pod criado com sucesso:

$ kubectl get pods
  NAME              	READY   STATUS  	RESTARTS  	 AGE
  job-test		        0/1 	Completed    	0  	     11s

Depois que os pods forem criados, verifique os logs do Job:

$ kubectl logs job-test job-test

Você criou seu primeiro trabalho do Kubernetes e pode explorar detalhes sobre ele:

$ kubectl describe job job-test

Limpe os trabalhos:

$ kubectl delete jobs job-test

CronJobs do Kubernetes

Você pode usar CronJobs para tarefas de cluster que precisam ser executadas em um agendamento predefinido. Conforme explica a documentação, eles são úteis para tarefas periódicas e recorrentes, como execução de backups, envio de e-mails ou agendamento de tarefas individuais para um horário específico, como quando é provável que seu cluster esteja ocioso.

Assim como acontece com Jobs, você pode criar CronJobs por meio de um arquivo de definição. A seguir está um trecho do arquivo CronJob cron-test.yaml. Use este arquivo para criar um CronJob de exemplo:

apiVersion: batch/v1beta1            ## The version of the Kubernetes API
kind: CronJob                        ## The type of object for Cron jobs
metadata:
  name: cron-test
spec:
  schedule: "*/1 * * * *"            ## Defined schedule using the *nix style cron syntax
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: cron-test
            image: busybox            ## Image used
            args:
            - /bin/sh
            - -c
            - date; echo Hello this is Cron test
          restartPolicy: OnFailure    ##  Restart Policy in case container failed

Aplique o CronJob ao seu cluster:

$ kubectl apply -f cron-test.yaml
 cronjob.batch/cron-test created

Verifique se o CronJob foi criado com o agendamento no arquivo de definição:

$ kubectl get cronjob cron-test
 NAME        SCHEDULE      SUSPEND   ACTIVE   LAST SCHEDULE   AGE
 cron-test   */1 * * * *   False     0        <none>          10s

Após alguns segundos, você poderá encontrar os pods que o último trabalho agendado criou e visualizar a saída padrão de um dos pods:

$ kubectl logs cron-test-1604870760
  Sun Nov  8 21:26:09 UTC 2020
  Hello from the Kubernetes cluster

Você criou um CronJob do Kubernetes que cria um objeto uma vez por execução com base no agendamento schedule: "*/1 * * * *". Às vezes, a criação pode ser perdida devido a questões ambientais no cluster. Portanto, eles precisam ser idempotentes.

Outras coisas para saber

Ao contrário das implantações e serviços no Kubernetes, não é possível alterar o mesmo arquivo de configuração de trabalho e reaplicá-lo de uma só vez. Ao fazer alterações no arquivo de configuração do Job, você deve excluir o Job anterior do cluster antes de aplicá-lo.

Geralmente, a criação de um Job cria um único pod e executa a tarefa determinada, como no exemplo acima. Mas usando completações e paralelismo, você pode iniciar vários pods, um após o outro.

Use seus trabalhos

Você pode usar Kubernetes Jobs e CronJobs para gerenciar seus aplicativos em contêineres. Os trabalhos são importantes nos padrões de implantação de aplicativos Kubernetes, onde você precisa de um mecanismo de comunicação junto com as interações entre os pods e as plataformas. Isso pode incluir casos em que um aplicativo precisa de um “controlador” ou “observador” para concluir tarefas ou precisa ser agendado para execução periódica.

Artigos relacionados: