Executando Jobs e CronJobs

Neste capítulo, exploraremos o uso de Jobs e CronJobs no Kubernetes. Os Jobs permitem executar tarefas em lote de curta duração, enquanto os CronJobs fornecem um agendamento de tarefas baseado em cron. Veremos como criar e executar Jobs e CronJobs, além de discutir casos de uso em que esses recursos são úteis.

3.1. Trabalhando com Jobs

Os Jobs são úteis quando precisamos executar tarefas em lote, como processamento de dados, processamento em lotes ou migrações de banco de dados. Ao contrário dos Pods normais, os Jobs garantem que a tarefa seja concluída com sucesso antes de encerrar.

3.1.1. Criando um Job

Para criar um Job no Kubernetes, usamos um arquivo YAML que descreve a especificação do Job. Vamos criar um exemplo básico de Job para entender sua estrutura:

apiVersion: batch/v1
kind: Job
metadata:
  name: myjob
spec:
  template:
    spec:
      containers:
      - name: myjob-container
        image: busybox
        command: ["echo", "Executando meu Job"]
      restartPolicy: Never

No exemplo acima, definimos um Job chamado “myjob” que usa a imagem especificada para executar o comando “echo” com o argumento “Executando meu Job”. A propriedade “restartPolicy” é definida como “Never” para garantir que o Job não seja reiniciado em caso de falha.

3.1.2. Executando um Job

Para executar um Job no Kubernetes, usamos o comando kubectl create com o arquivo YAML do Job:

kubectl create -f job.yaml

Isso criará o Job no cluster Kubernetes e iniciará a execução da tarefa. Podemos acompanhar o status do Job usando o comando kubectl describe:

kubectl describe job myjob

O resultado exibirá informações sobre o estado atual do Job, como o número de réplicas concluídas e o status geral.

3.1.3. Casos de Uso de Jobs

No Kubernetes, um Job é um controlador que garante a execução de um ou mais pods até a conclusão. Ao contrário de um Pod regular ou de um Deployment, que pode ser reiniciado após falhas ou reinicializações de nós, um Job é destinado a executar tarefas que terminam. Aqui estão alguns casos de uso comuns para Jobs:

Processamento em Lote Um dos casos de uso mais comuns para Jobs é o processamento em lote. Isso pode incluir:

Transformação de Dados: Por exemplo, converter dados de um formato para outro ou realizar operações de limpeza em grandes conjuntos de dados.

Análise de Dados: Como executar um conjunto específico de consultas em um banco de dados ou processar logs para gerar relatórios.

Backups e Restaurações

Jobs podem ser usados para:

Criar Backups: Por exemplo, fazer backup de um banco de dados para armazenamento em nuvem ou para um volume persistente.

Restaurar Backups: Restaurar dados de um backup anterior.

Inicialização de Recursos

Antes de iniciar uma aplicação ou serviço, pode ser necessário preparar ou inicializar recursos. Por exemplo:

Inicialização de Banco de Dados: Como criar esquemas, tabelas ou popular um banco de dados com dados iniciais.

Testes e Validações

Jobs podem ser usados para executar testes que têm um começo e um fim, como:

Testes de Carga: Onde você pode querer gerar uma quantidade específica de tráfego para um serviço e, em seguida, coletar resultados.

Testes de Integração: Executar um conjunto de testes que validam a integração entre diferentes serviços ou componentes.

Tarefas Agendadas

Usando CronJobs, que é uma extensão do conceito de Job, você pode executar tarefas em intervalos regulares, faleremos mais na seção a seguir. Por exemplo:

Limpeza Regular: Como a remoção de arquivos temporários ou a limpeza de entradas antigas em um banco de dados.

Relatórios Agendados: Gerar e enviar relatórios em horários específicos.

Migrações

Jobs podem ser usados para realizar migrações, como:

Migrações de Banco de Dados: Atualizar o esquema de um banco de dados ou migrar dados entre versões.

Migrações de Dados: Mover dados entre sistemas ou plataformas.

3.2. Trabalhando com CronJobs

Os CronJobs no Kubernetes permitem agendar tarefas com base em expressões cron, fornecendo uma maneira conveniente de executar tarefas periódicas ou agendadas. Uma expressão cron é composta por campos separados por espaços que definem quando uma tarefa deve ser executada.

3.2.1. Estrutura de uma expressão cron

Uma expressão cron consiste em cinco campos separados por espaços:

Minuto Hora DiaDoMês Mês DiaDaSemana

• Minuto: um valor de 0 a 59 que representa os minutos em que a tarefa deve ser executada.
• Hora: um valor de 0 a 23 que representa a hora em que a tarefa deve ser executada.
• DiaDoMês: um valor de 1 a 31 que representa o dia do mês em que a tarefa deve ser executada.
• Mês: um valor de 1 a 12 (ou abreviações de nomes de meses) que representa o mês em que a tarefa deve ser executada.
• DiaDaSemana: um valor de 0 a 7 (sendo 0 e 7 domingos, e 1 a 6 de segunda a sábado) que representa o dia da semana em que a tarefa deve ser executada.

Cada campo também pode ser substituído por caracteres especiais:

• Asterisco (*): corresponde a qualquer valor. Por exemplo, “*” no campo do mês significa “todos os meses”.
• Vírgula (,): separa valores individuais. Por exemplo, “1,2,3” no campo da hora significa “nas horas 1, 2 e 3”.
• Hífen (-): especifica um intervalo de valores. Por exemplo, “1-5” no campo do dia do mês significa “nos dias 1, 2, 3, 4 e 5”.
• Barra (/): específica incrementos. Por exemplo, “*/5” no campo do minuto significa “a cada 5 minutos”.

3.2.2. Criando um CronJob

Para criar um CronJob no Kubernetes, usamos um arquivo YAML que descreve a especificação do CronJob. Vamos criar um exemplo básico de CronJob para agendar uma tarefa a cada hora:

apiVersion: batch/v1
kind: CronJob
metadata:
  name: mycronjob
spec:
  schedule: "0 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: myjob-container
            image: busybox
            command: ["echo", "Executando meu CronJob"]
          restartPolicy: OnFailure

No exemplo acima, definimos um CronJob chamado “mycronjob” que usa a imagem especificada para executar o comando “echo” com o argumento “Executando meu CronJob”. A propriedade “schedule” é definida como “0 * * * *” para agendar a tarefa para ser executada a cada hora.

Precisando contratar o serviço de Implementação entre em contato coma SCTTIC.

3.2.3. Executando um CronJob

Assim como um Job, um CronJob também pode ser criado usando o comando kubectl create com o arquivo YAML do CronJob:

kubectl create -f cronjob.yaml

Isso criará o CronJob no cluster Kubernetes, e ele começará a agendar e executar as tarefas conforme a expressão cron especificada.

3.2.4. Casos de Uso de CronJobs

Os CronJobs são úteis em várias situações, incluindo:

1. Tarefas de backup periódico: Você pode usar CronJobs para agendar tarefas de backup em um intervalo regular, garantindo a segurança dos dados do seu aplicativo.
2. Atualizações de dados programadas: Ao lidar com conjuntos de dados que precisam ser atualizados regularmente, os CronJobs podem ser usados para executar as atualizações conforme o agendamento especificado.
3. Limpeza de recursos obsoletos: Os CronJobs podem ser usados para agendar tarefas de limpeza de recursos obsoletos, como logs antigos ou arquivos temporários, mantendo o cluster organizado e eficiente.

Exercício: Criar e Executar um Job e um CronJob no Kubernetes

Objetivo: Familiarizar-se com a criação e execução de Jobs e CronJobs no Kubernetes, realizando uma tarefa em lote e agendando uma tarefa periódica.

Atividade 1: Criar e Executar um Job

Objetivo: Criar um Job que imprime “Olá, Kubernetes!” cinco vezes.

Passo 1. Criar um arquivo de definição para o Job

Crie um arquivo chamado print-job.yaml com o seguinte conteúdo:

apiVersion: batch/v1
kind: Job
metadata:
  name: print-job
spec:
  template:
    spec:
      containers:
      - name: hello-container
        image: busybox
        command: ["sh", "-c", "for i in 1 2 3 4 5; do echo 'Olá, Kubernetes!'; sleep 1; done"]
      restartPolicy: Never

Passo 2. Criar o Job

Execute o seguinte comando para criar o Job:

kubectl apply -f print-job.yaml

Passo 3. Monitorar o Job

Use o seguinte comando para verificar o status do Job:

kubectl describe job print-job

Passo 4. Visualizar os Logs

Primeiro, encontre o nome do Pod associado ao Job:

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

Em seguida, visualize os logs do Pod:

kubectl logs <nome-do-pod>

Atividade 2: Criar e Executar um CronJob

Objetivo: Criar um CronJob que imprime “Olá de novo, Kubernetes!” a cada minuto.

Passo 1. Criar um arquivo de definição para o CronJob

Crie um arquivo chamado print-cronjob.yaml com o seguinte conteúdo:

apiVersion: batch/v1
kind: CronJob
metadata:
  name: print-cronjob
spec:
  schedule: "*/1 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: hello-cron-container
            image: busybox
            command: ["sh", "-c", "echo 'Olá de novo, Kubernetes!'"]
          restartPolicy: OnFailure

Passo 2. Criar o CronJob

Execute o seguinte comando para criar o CronJob:

kubectl apply -f print-cronjob.yaml

Passo 3. onitorar o CronJob

Use o seguinte comando para verificar o status do CronJob:

kubectl get cronjob print-cronjob

Passo 4. Visualizar os Logs

A cada minuto, um novo Job será criado. Você pode seguir os passos da Atividade 1 para visualizar os logs de cada Job gerado pelo CronJob.

Conclusão: Ao final deste exercício, você deve ter adquirido experiência prática na criação e monitoramento de Jobs e CronJobs no Kubernetes. Estas são ferramentas valiosas para tarefas em lote e tarefas agendadas dentro de um ambiente Kubernetes.