Tutorial de introducción: cree un trabajo K8S en 5 pasos, obtenga procesamiento por lotes

Los trabajos de Kubernetes son principalmente para cargas de trabajo a corto plazo y por lotes. Se ejecuta para el final, no para operaciones continuas como implementación, conjuntos de réplicas, controladores de réplica y DaemonSets.

Este artículo presentará cómo crear trabajos y cronjobs de Kubernetes, así como algunos consejos.

Los trabajos de Kubernetes se ejecutarán hasta que se completen las tareas especificadas en el trabajo. En otras palabras, si los pods dan un código de salida de 0, el trabajo se cerrará. En Kubernetes normal, no importa cuál sea el código de salida, el objeto de implementación creará un nuevo pod cuando finalice o se produzca un error para mantener el estado ideal de la implementación.

Durante el proceso de ejecución del trabajo, si el nodo que aloja el módulo falla, el módulo de trabajo se reprogramará automáticamente a otro nodo.

Ejemplo de trabajos de Kubernetes

La mejor práctica de casos de uso para trabajos de Kubernetes es:

1. Tarea de procesamiento por lotes : por ejemplo, desea ejecutar una tarea de procesamiento por lotes una vez al día o en un horario específico. Puede ser como leer archivos de un repositorio o base de datos y asignarlos a un servicio para procesar archivos.

2. Operación y mantenimiento / tareas ad-hoc : por ejemplo, si desea ejecutar un script / código, el script / código ejecutará una actividad de limpieza de la base de datos e incluso realizará una copia de seguridad de un clúster de Kubernetes.

   Cómo crear un trabajo de Kubernetes

   En este ejemplo, usaremos el contenedor de Ubuntu para ejecutar un script de shell con un bucle for y responder a los mensajes según los parámetros que pase al contenedor. Este parámetro es un número que determina cuántas veces se debe ejecutar el bucle del script de shell.

Por ejemplo, si pasa el parámetro 100, el script de shell repetirá el mensaje 100 veces y el contenedor se cerrará.

Puede visitar el siguiente enlace para ver el archivo Dockerfile y el script de shell:
https://github.com/devopscube/Kubernetes-jobs-example/tree/master/Docker

Comencemos con una configuración de trabajo simple.

Paso 1 : utilice una imagen de Docker personalizada para crear un archivo job.yaml, el parámetro de comando es 100. Se pasará 100 como parámetro al script de la ventana acoplable ENTRYPOINT.

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   

Paso 2 : use kubectl para crear un trabajo con el archivo job.yaml

kubectl apply -f job.yam

Paso 3 : use kubectl para verificar el estado del trabajo

kubectl get jobs

Paso 4 : use kubectl para obtener la lista de pod

kubectl get po

Paso 5 : use kubectl para obtener registros de pod de trabajos. Reemplace el nombre del Pod original con el nombre del Pod que ve en el resultado.

kubectl logs kubernetes-job-example-bc7s9 -f

Ejecute varios pods de trabajo en paralelo

Después de implementar un trabajo, puede hacer que se ejecute en paralelo en varios pods. Por ejemplo, si desea ejecutar 6 pods en un trabajo y ejecutar 2 pods en paralelo, debe agregar los siguientes 2 parámetros a sus manifets de trabajo:

completions: 6
parallelism: 2

El siguiente es un manifiesto con esos 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

Genere un nombre aleatorio para el trabajo de Kubernetes

No puede crear varios trabajos a partir de un archivo de manifiesto de trabajo, porque Kubernetes informará un error que indica que hay un trabajo con el mismo nombre. Para evitar este problema, puede agregar el parámetro de nombre generateName en los metadatos .

P.ej:

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

En el ejemplo anterior, cada vez que ejecute el manifiesto, el trabajo se creará con kube-job- como prefijo, seguido de una cadena aleatoria.

Cómo crear un CronJob de Kubernetes

Si desea ejecutar un trabajo por lotes de acuerdo con un programa específico, por ejemplo, hágalo una vez cada 2 horas. Puede crear un cronjob de Kubernetes con expresiones cron . El trabajo se iniciará automáticamente de acuerdo con el horario que mencionó en el trabajo.

A continuación, presentaremos cómo especificar un plan cron, puede usar el generador crontab (https://crontab-generator.org/ ) para generar su propio plan de tiempo.

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

La siguiente figura muestra la sintaxis de programación de cronjob de Kubernetes.
Si ejecutamos nuestro trabajo anterior cada 15 minutos en forma de cronjob, el manifiesto debería verse como el siguiente. Crea un archivo llamado cron-job.yaml y copia el siguiente manifiesto:

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"]

Implementemos cronjob usando kubectl.
kubectl create -f cron-job.yaml
Lista cronjobs:

kubectl get cronjobs

Puede consultar el registro de cronjob enumerando los pods de cronjob y obteniendo los registros de los pods que se están ejecutando o completados.

Ejecutar manualmente Kubernetes CronJob

En algunos casos, es posible que desee ejecutar cronjob de manera temporal. Puede hacer esto creando un trabajo a partir de un cronjob existente.

Por ejemplo, si desea activar manualmente un cronjob, deberíamos hacer esto:

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

--from = cronjob / kubernetes-cron-job copiará la plantilla cronjob y creará un trabajo llamado manual-cron- job.

Parámetros clave del trabajo de Kubernetes

Según sus necesidades, también puede utilizar varios parámetros clave de trabajos / cronjobs de kubernetes:

1. FailJobHistoryLimit & SuccessJobsHistoryLimit
   : Elimina los registros del historial de trabajos fallidos y correctos en función del número de reservas que proporciones. Esto es muy útil para reducir todas las entradas fallidas cuando intenta listar trabajos. P.ej:

2. backoffLimit: si su pod falla, el número total de reintentos.

3. activeDeadlineSeconds: si desea imponer un límite estricto en el tiempo de ejecución de cronjob, puede utilizar este parámetro. Por ejemplo, si desea ejecutar un cronjob durante solo 1 minuto, puede configurarlo en 60.

A través de este artículo, hemos aprendido sobre los pasos para crear trabajos y trabajos cron y algunos procedimientos de configuración detallados y parámetros clave. Espero que este artículo pueda ayudarlo a comenzar a comprender el trabajo K8S y el trabajo cron, y obtener fácilmente tareas de procesamiento por lotes.

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