Tutorial de primeiros passos: Criar trabalho K8S em 5 etapas, obter processamento em lote

Os jobs do Kubernetes são principalmente para cargas de trabalho de curto prazo e em lote. Ele é executado para o fim, não para operação contínua como implantação, replicasets, controladores de replicação e DaemonSets.

Este artigo apresentará como criar jobs e cronjobs do Kubernetes, além de algumas dicas.

Os trabalhos do Kubernetes serão executados até que as tarefas especificadas no trabalho sejam concluídas. Em outras palavras, se os pods fornecerem um código de saída 0, o trabalho será encerrado. No Kubernetes normal, não importa qual seja o código de saída, o objeto de implantação criará um novo pod quando for encerrado ou ocorrer um erro para manter o estado ideal de implantação.

Durante o processo de execução do trabalho, se o nó que hospeda o pod falhar, o pod de trabalho será reprogramado automaticamente para outro nó.

Exemplo de trabalhos do Kubernetes

A melhor prática de caso de uso para jobs do Kubernetes é:

1. Tarefa de processamento em lote : por exemplo, você deseja executar uma tarefa de processamento em lote uma vez por dia ou em uma programação especificada. Pode ser como ler arquivos de um repositório ou banco de dados e atribuí-los a um serviço para processar arquivos.

2. Operação e manutenção / tarefas ad-hoc : por exemplo, se você deseja executar um script / código, o script / código executará uma atividade de limpeza do banco de dados e até mesmo fará o backup de um cluster Kubernetes.

   Como criar um trabalho do Kubernetes

   Neste exemplo, usaremos o contêiner do Ubuntu para executar um script de shell com um loop for e responder às mensagens com base nos parâmetros que você passa para o contêiner. Este parâmetro é um número que determina quantas vezes o loop do script de shell deve ser executado.

Por exemplo, se passar o parâmetro 100, o shell script ecoará a mensagem 100 vezes e o container sairá.

Você pode visitar o seguinte link para visualizar o Dockerfile e o script de shell:
https://github.com/devopscube/Kubernetes-jobs-example/tree/master/Docker

Vamos começar com uma configuração de trabalho simples.

Passo 1 : Use uma imagem Docker personalizada para criar um arquivo job.yaml, o parâmetro de comando é 100. 100 será passado como um parâmetro para o script ENTRYPOINT do docker.

apiVersion: batch/v1  kind: Job  metadata:      name: kubernetes-job-example      labels:     
    jobgroup: jobexample  spec:      template:     
    metadata:       
      name: kubejob       
      labels:         
        jobgroup: jobexample     
    spec:       
      containers:       
      - name: c         
        image: devopscube/kubernetes-job-demo:latest         
        args: ["100"]       
      restartPolicy: OnFailure   

Etapa 2 : use kubectl para criar um trabalho com o arquivo job.yaml

kubectl apply -f job.yam

Etapa 3 : use kubectl para verificar o status do trabalho

kubectl get jobs

Etapa 4 : use kubectl para obter a lista de pods

kubectl get po

Etapa 5 : use kubectl para obter os logs do pod de trabalho. Substitua o nome do pod original pelo nome do pod que você vê na saída.

kubectl logs kubernetes-job-example-bc7s9 -f

Execute vários pods de trabalho em paralelo

Depois que um job é implantado, você pode executá-lo em paralelo em vários pods. Por exemplo, se você deseja executar 6 pods em um job e 2 pods em paralelo, é necessário adicionar os 2 parâmetros a seguir aos seus manifets de job:

completions: 6
parallelism: 2

O seguinte é um manifesto com esses parâmetros:

apiVersion: batch/v1
kind: Job
metadata:
  name: kubernetes-parallel-job
  labels:
    jobgroup: jobexample
spec:
  completions: 5
  parallelism: 2
  template:
    metadata:
      name: kubernetes-parallel-job
      labels:
        jobgroup: jobexample
    spec:
      containers:
      - name: c
        image: devopscube/kubernetes-job-demo:latest
        args: ["100"]
      restartPolicy: OnFailure

Gerar nome aleatório para o trabalho do Kubernetes

Você não pode criar vários trabalhos a partir de um arquivo de manifesto de trabalho, porque o Kubernetes relatará um erro dizendo que há um trabalho com o mesmo nome. Para contornar esse problema, você pode adicionar o parâmetro de nome generateName nos metadados .

Por exemplo:

apiVersion: batch/v1
kind: Job
metadata:
  generateName: kube-job-
  labels:
    jobgroup: jobexample

No exemplo acima, sempre que você executar o manifesto, o trabalho será criado com kube-job- como prefixo, seguido por uma string aleatória.

Como criar um Kubernetes CronJob

Se você deseja executar uma tarefa em lote de acordo com uma programação específica, por exemplo, execute uma vez a cada 2 horas. Você pode criar um cronjob do Kubernetes com expressões cron . O trabalho será iniciado automaticamente de acordo com a programação que você mencionou no trabalho.

Abaixo vamos apresentar como especificar um plano cron, você pode usar o gerador crontab (https://crontab-generator.org/ ) para gerar seu próprio plano de tempo.

schedule: "0,15,30,45 * * * *"

A figura a seguir mostra a sintaxe da programação do cronjob do Kubernetes.
Se executarmos nosso trabalho anterior a cada 15 minutos na forma de um cronjob, o manifesto deve ser semelhante ao seguinte. Crie um arquivo denominado cron-job.yaml e copie o seguinte manifesto:

apiVersion: batch/v1beta1
kind: CronJob
metadata:
    name: kubernetes-cron-job
spec:
  schedule: "0,15,30,45 * * * *"
  jobTemplate:
    spec:
      template:
        metadata:
          labels:
            app: cron-batch-job
        spec:
          restartPolicy: OnFailure
          containers:
          - name: kube-cron-job
            image: devopscube/kubernetes-job-demo:latest
            args: ["100"]

Vamos implantar o cronjob usando kubectl.
kubectl create -f cron-job.yaml
Listar cronjobs:

kubectl get cronjobs

Você pode verificar o registro do cronjob listando os pods do cronjob e obtendo os registros dos pods em execução ou concluídos.

Execute manualmente o Kubernetes CronJob

Em alguns casos, você pode querer executar o cronjob de maneira temporária. Você pode fazer isso criando um trabalho a partir de um cronjob existente.

Por exemplo, se você deseja acionar manualmente um cronjob, devemos fazer o seguinte:

kubectl create job --from=cronjob/kubernetes-cron-job manual-cron-job

--from = cronjob / kubernetes-cron-job copiará o modelo cronjob e criará um trabalho denominado manual-cron- job.

Parâmetros principais do trabalho do Kubernetes

De acordo com suas necessidades, você também pode usar vários parâmetros-chave de kubernetes jobs / cronjobs:

1. failJobHistoryLimit &
   successfulJobsHistoryLimit: Exclua registros de histórico de trabalhos com falha e bem-sucedidos com base no número de reservas fornecidas. Isso é muito útil para reduzir todas as entradas com falha ao tentar listar trabalhos. Por exemplo:

2. backoffLimit: se seu pod falhar, o número total de tentativas.

3. activeDeadlineSeconds: Se você deseja impor um limite rígido no tempo de execução do cronjob, você pode usar este parâmetro. Por exemplo, se você deseja executar um cronjob por apenas 1 minuto, você pode defini-lo para 60.

Por meio deste artigo, aprendemos sobre as etapas de criação de Job e Cron Job e alguns procedimentos de configuração detalhados e parâmetros-chave. Espero que este artigo possa ajudá-lo a começar a entender K8S Job e Cron Job e obter facilmente tarefas de processamento em lote!

Link original:
https://devopscube.com/create-kubernetes-jobs-cron-jobs/