Pular para o conteúdo principal

Lab 7.3 - Jobs e CronJobs

Objetivos do Lab​

Ao final deste lab, você será capaz de:

  • Criar e executar Jobs para tarefas pontuais.
  • Compreender os diferentes tipos de Jobs (completo, paralelo).
  • Criar CronJobs para tarefas agendadas.
  • Gerenciar o histórico de Jobs.
  • Monitorar a execução de Jobs e CronJobs.

Duração Estimada​

45-60 minutos

Pré-requisitos​

  • kubectl instalado e configurado.
  • Cluster Kubernetes local funcional (minikube ou kind).
  • Conhecimentos sobre Jobs e CronJobs (Capítulo 7.3).

Parte 1: Criação de um Job Simples​

Um Job cria um ou mais Pods e garante que um certo número deles termine com sucesso.

Etapa 1.1: Criar um Job Simples​

Crie um arquivo job-simple.yaml:

# job-simple.yaml
apiVersion: batch/v1
kind: Job
metadata:
  name: job-simple
spec:
  template:
    spec:
      containers:
      - name: task
        image: busybox:1.35
        command: ["/bin/sh", "-c"]
        args: ["echo 'Tâche terminée avec succès!' && date"]
      restartPolicy: Never # Jobs utilizam Never ou OnFailure

Explicação:

  • restartPolicy: Never: O Pod não será reiniciado automaticamente se falhar. Para Jobs, use Never ou OnFailure.
  • O Job cria um Pod que executa o comando e finaliza.

Aplique o Job:

kubectl apply -f job-simple.yaml

Etapa 1.2: Verificar a Execução​

Verifique o status do Job:

kubectl get jobs

Verifique os Pods criados:

kubectl get pods -l job-name=job-simple

Após o Pod finalizar, verifique os logs:

kubectl logs -l job-name=job-simple

Você deve ver a mensagem "Tâche terminée avec succès!" e a data.

Etapa 1.3: Verificar o Status Completo​

Verifique os detalhes do Job:

kubectl describe job job-simple

Você deve ver que o Job está Complete com 1/1 completado.

Parte 2: Job com Múltiplas Completions​

Um Job pode ser configurado para rodar várias vezes (paralelamente ou sequencialmente).

Etapa 2.1: Criar um Job com Completions​

Crie um arquivo job-multiple.yaml:

# job-multiple.yaml
apiVersion: batch/v1
kind: Job
metadata:
  name: job-multiple
spec:
  completions: 5 # O Job deve rodar 5 vezes com sucesso
  parallelism: 2 # Executar 2 Pods em paralelo por vez
  template:
    spec:
      containers:
      - name: task
        image: busybox:1.35
        command: ["/bin/sh", "-c"]
        args: ["echo 'Tâche $(date +%s)' && sleep 2"]
      restartPolicy: Never

Explicação:

  • completions: 5: O Job deve completar 5 execuções bem-sucedidas.
  • parallelism: 2: Máximo de 2 Pods executando em paralelo por vez.

Aplique o Job:

kubectl apply -f job-multiple.yaml

Etapa 2.2: Observar a Execução​

Monitore os Pods em tempo real:

kubectl get pods -l job-name=job-multiple -w

Você deve ver 2 Pods executando em paralelo, depois outros sendo criados até que 5 completions sejam atingidas.

Verifique o status do Job:

kubectl get job job-multiple

Quando finalizar, você deve ver 5/5 completions.

Parte 3: Job com Backoff Limit​

O backoffLimit define o número de tentativas em caso de falha.

Etapa 3.1: Criar um Job que Falha​

Crie um arquivo job-failure.yaml:

# job-failure.yaml
apiVersion: batch/v1
kind: Job
metadata:
  name: job-failure
spec:
  backoffLimit: 3 # Máximo de 3 tentativas em caso de falha
  template:
    spec:
      containers:
      - name: task
        image: busybox:1.35
        command: ["/bin/sh", "-c"]
        args: ["exit 1"] # Falha intencionalmente
      restartPolicy: Never

Aplique o Job:

kubectl apply -f job-failure.yaml

Etapa 3.2: Observar as Tentativas​

Monitore os Pods:

kubectl get pods -l job-name=job-failure -w

Você deve ver vários Pods sendo criados (até 3 tentativas) antes do Job ser marcado como Failed.

Verifique o status do Job:

kubectl get job job-failure
kubectl describe job job-failure

Parte 4: Criação de um CronJob​

Um CronJob cria Jobs de forma recorrente conforme um agendamento (formato cron).

Etapa 4.1: Criar um CronJob​

Crie um arquivo cronjob-example.yaml:

# cronjob-example.yaml
apiVersion: batch/v1
kind: CronJob
metadata:
  name: cronjob-example
spec:
  schedule: "*/1 * * * *" # A cada minuto (para teste)
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: task
            image: busybox:1.35
            command: ["/bin/sh", "-c"]
            args: ["echo 'Exécution CronJob - $(date)'"]
          restartPolicy: OnFailure
  successfulJobsHistoryLimit: 3 # Manter 3 Jobs bem-sucedidos no histórico
  failedJobsHistoryLimit: 1 # Manter 1 Job com falha no histórico

Explicação:

  • schedule: "*/1 * * * *": Formato cron (minuto hora dia mês dia-semana). Aqui, a cada minuto.
  • successfulJobsHistoryLimit: 3: Mantém os 3 últimos Jobs bem-sucedidos.
  • failedJobsHistoryLimit: 1: Mantém o último Job com falha.

Aplique o CronJob:

kubectl apply -f cronjob-example.yaml

Etapa 4.2: Verificar o CronJob​

Verifique o status do CronJob:

kubectl get cronjob cronjob-example
# ou
kubectl get cj cronjob-example

Aguarde um minuto e verifique se os Jobs foram criados:

kubectl get jobs

Você deve ver Jobs nomeados como cronjob-example-<timestamp>.

Verifique os Pods criados pelos Jobs:

kubectl get pods

Verifique os logs de um dos Jobs:

JOB_NAME=$(kubectl get jobs -o jsonpath='{.items[0].metadata.name}')
kubectl logs -l job-name=$JOB_NAME

Parte 5: Suspender um CronJob​

Você pode suspender temporariamente um CronJob sem excluí-lo.

Etapa 5.1: Suspender o CronJob​

Suspenda o CronJob:

kubectl patch cronjob cronjob-example -p '{"spec":{"suspend":true}}'

Verifique se o CronJob está suspenso:

kubectl get cronjob cronjob-example

Você deve ver True na coluna SUSPEND.

Etapa 5.2: Retomar o CronJob​

Retome o CronJob:

kubectl patch cronjob cronjob-example -p '{"spec":{"suspend":false}}'

Parte 6: Exemplos de Schedules Cron​

Aqui estão alguns exemplos comuns de schedules cron:

schedule: "0 0 * * *"        # Todos os dias à meia-noite
schedule: "0 */6 * * *"     # A cada 6 horas
schedule: "0 9 * * 1"       # Todas as segundas-feiras às 9h
schedule: "0 0 1 * *"       # No primeiro dia de cada mês à meia-noite
schedule: "*/30 * * * *"    # A cada 30 minutos

Parte 7: Limpeza​

Remova os recursos criados:

# Remover os CronJobs (remove também os Jobs associados)
kubectl delete cronjob cronjob-example

# Remover os Jobs
kubectl delete job job-simple job-multiple job-failure

# Remover os Pods restantes (opcional, normalmente removidos automaticamente)
kubectl delete pods -l job-name

Resumo do Lab​

Neste lab, você explorou os Jobs e CronJobs. Você aprendeu a criar Jobs para tarefas pontuais, configurar Jobs paralelos, gerenciar falhas com backoffLimit e criar CronJobs para tarefas recorrentes agendadas.

Próximos Passos​

O último lab deste módulo mostrará como usar Init Containers e Sidecars para padrões avançados.

Lab 7.4: Init Containers e Sidecars

Lab criado em: Dezembro 2024