Executar Pods com Jobs e Cronjobs no Kubernetes

Introdução

No Kubernetes, os Jobs e CronJobs são utilizados para executar tarefas que não fazem parte de uma aplicação ou serviço de longa duração. Os Jobs são usados para tarefas únicas, enquanto os CronJobs são usados para tarefas que precisam ser executadas em um agendamento regular.

Neste laboratório, aprenderemos como executar pods com Jobs e CronJobs no Kubernetes. Começaremos com um exemplo simples e gradualmente construiremos exemplos mais complexos.

Iniciar o Cluster Minikube

Antes de criar recursos, você precisa de um cluster Kubernetes em execução. Minikube é um ambiente Kubernetes leve que roda em sua máquina local.

Navegue para o seu diretório de trabalho:

Abra o terminal e navegue até a pasta do projeto padrão:
```
cd /home/labex/project
```
Iniciar o Minikube:

Inicie o Minikube para inicializar um cluster Kubernetes:
```
minikube start
```
- Este comando configura um cluster Kubernetes de nó único em sua máquina local.
- O Minikube pode levar alguns minutos para iniciar, dependendo do desempenho do seu sistema.
Verificar se o Minikube está em execução:

Verifique o status do cluster Minikube:
```
minikube status
```
- Procure por componentes como kubelet e apiserver listados como Running.
- Se o cluster não estiver em execução, execute novamente minikube start.

Se você encontrar problemas ao iniciar o Minikube. Use minikube delete para redefinir o ambiente, se necessário.

Executar um Pod com um Job no Kubernetes

O primeiro passo é criar um pod que executa um job. Neste exemplo, criaremos um pod que executa um comando para imprimir "Olá, Mundo!" no console.

Crie um arquivo chamado job.yaml em /home/labex/project/ com o seguinte conteúdo:

apiVersion: batch/v1
kind: Job
metadata:
  name: hello-job
spec:
  template:
    spec:
      containers:
        - name: hello
          image: busybox
          command: ["sh", "-c", 'echo "Hello, World!"']
      restartPolicy: Never
  backoffLimit: 4

Neste arquivo, definimos um job chamado hello-job que executa um único container chamado hello. O container executa a imagem busybox e executa um comando para imprimir "Olá, Mundo!" no console.

Para criar o job, execute o seguinte comando:

kubectl apply -f job.yaml

Você pode verificar o status do job executando o seguinte comando:

kubectl get jobs

Assim que o job for concluído, você pode visualizar os logs do pod executando o seguinte comando:

kubectl logs <POD_NAME>

Substitua <POD_NAME> pelo nome do pod que executou o job, e você pode obter o POD_NAME com o comando kubectl get pods |grep hello-job.

Parabéns, você executou com sucesso um pod com um job no Kubernetes!

Executar um Job com Múltiplos Pods no Kubernetes

Em alguns casos, você pode precisar executar um job com múltiplos pods para obter um melhor desempenho. Neste exemplo, criaremos um job que executa múltiplos pods para baixar arquivos de um servidor remoto.

Crie um arquivo chamado multi-pod-job.yaml em /home/labex/project/ com o seguinte conteúdo:

apiVersion: batch/v1
kind: Job
metadata:
  name: download-job
spec:
  completions: 3
  parallelism: 2
  template:
    spec:
      containers:
        - name: downloader
          image: curlimages/curl
          command: ["curl", "-o", "/data/file", "http://example.com/file"]
          volumeMounts:
            - name: data-volume
              mountPath: /data
      restartPolicy: Never
      volumes:
        - name: data-volume
          emptyDir: {}
  backoffLimit: 4

Neste arquivo, definimos um job chamado download-job que executa múltiplos pods com a imagem curlimages/curl. Cada pod baixa um arquivo de http://example.com/file e o salva em um volume compartilhado chamado data-volume.

Para criar o job, execute o seguinte comando:

kubectl apply -f multi-pod-job.yaml

Você pode verificar o status do job executando o seguinte comando:

kubectl get jobs

Assim que o job for concluído, você pode visualizar os logs do pod executando o seguinte comando:

kubectl logs <POD_NAME>

Substitua <POD_NAME> pelo nome de qualquer pod que executou o job. Você pode ver o log de download do arquivo, e você pode obter o POD_NAME com o comando kubectl get pod |grep download-job.

Parabéns, você executou com sucesso um job com múltiplos pods no Kubernetes!

Executar um Cronjob no Kubernetes

Além de jobs únicos, o Kubernetes também suporta cronjobs para executar tarefas em uma programação regular. Neste exemplo, criaremos um cronjob que executa um comando a cada minuto.

Crie um arquivo chamado cronjob.yaml em /home/labex/project/ com o seguinte conteúdo:

apiVersion: batch/v1
kind: CronJob
metadata:
  name: hello-cronjob
spec:
  schedule: "*/1 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
            - name: hello
              image: busybox
              command: ["sh", "-c", 'echo "Hello, World!"']
          restartPolicy: Never
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 3

Neste arquivo, definimos um cronjob chamado hello-cronjob que executa um comando a cada minuto. O comando é o mesmo que usamos no primeiro exemplo para imprimir "Olá, Mundo!" no console.

Para criar o cronjob, execute o seguinte comando:

kubectl apply -f cronjob.yaml

Você pode verificar o status do cronjob executando o seguinte comando:

kubectl get cronjobs

Assim que o cronjob estiver em execução, você pode visualizar os logs do pod executando o seguinte comando:

kubectl logs -f <POD_NAME>

Substitua <POD_NAME> pelo nome de qualquer pod que foi criado pelo cronjob, e você pode obter o POD_NAME com o comando kubectl get pod |grep hello-cronjob.

Parabéns, você executou com sucesso um cronjob no Kubernetes!

Resumo

Neste laboratório, aprendemos como executar pods com jobs e cronjobs no Kubernetes. Começamos com um exemplo simples de um pod que executa um job e, gradualmente, construímos exemplos mais complexos de jobs com múltiplos pods e cronjobs que são executados em uma programação regular. Com este conhecimento, você pode executar várias tarefas que não fazem parte de uma aplicação ou serviço de longa duração no Kubernetes.