Ejecuta un trabajo

En esta página, se explica cómo ejecutar trabajos en Google Kubernetes Engine.

Descripción general

En GKE, un trabajo es un objeto de controlador que representa una tarea finita. Los trabajos difieren de otros objetos de controlador porque los trabajos administran la tarea a medida que se ejecuta hasta su finalización, en lugar de administrar un estado deseado en curso (como la cantidad total de Pods en ejecución).

Los trabajos son útiles para tareas de procesamiento y tareas por lotes grandes. Los trabajos se pueden usar para admitir la ejecución paralela de Pods. Puedes usar un trabajo para ejecutar en paralelo elementos de trabajo independientes que se relacionan, como enviar correos electrónicos, procesar marcos, transcodificar archivos, analizar claves de base de datos, etcétera. Sin embargo, los trabajos no están diseñados para procesos paralelos de comunicación estrecha, como flujos continuos de procesos en segundo plano.

En GKE, se encuentran los siguientes tipos de trabajo:

  • Trabajo no paralelo: un trabajo que crea solo un Pod (que se vuelve a crear si el Pod finaliza sin éxito) y que se completa cuando el Pod finaliza de forma correcta.
  • Trabajos paralelos con un recuento de finalización: un trabajo que se completa cuando una cierta cantidad de Pods finaliza de forma correcta. Especifica la cantidad deseada de finalizaciones mediante el campo de completions.

Los objetos de trabajo de Kubernetes representan los trabajos. Cuando se crea un trabajo, el controlador del trabajo crea uno o más Pods y garantiza que sus Pods terminen de forma correcta. A medida que los Pods finalizan, un trabajo realiza un seguimiento de la cantidad de Pods que completaron sus tareas de forma correcta. Cuando se alcanza la cantidad deseada de finalizaciones exitosas, el trabajo está completo.

Al igual que otros controladores, un controlador de trabajo crea un Pod nuevo si uno de sus Pods falla o se borra.

Antes de comenzar

Sigue estos pasos a fin de prepararte para esta tarea:

  • Asegúrate de que habilitaste la API de Google Kubernetes Engine.
  • Habilitar la API de Google Kubernetes Engine
  • Asegúrate de que instalaste el SDK de Cloud.
  • Establece tu ID del proyecto predeterminado:
    gcloud config set project [PROJECT_ID]
  • Si trabajas con clústeres zonales, establece tu zona de procesamiento predeterminada:
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Si trabajas con clústeres regionales, establece tu región de procesamiento predeterminada:
    gcloud config set compute/region [COMPUTE_REGION]
  • Actualiza gcloud a la versión más reciente:
    gcloud components update

Crea un trabajo

Puedes crear un trabajo mediante kubectl apply con un archivo de manifiesto.

En el siguiente ejemplo, se muestra un manifiesto de trabajo:

apiVersion: batch/v1
kind: Job
metadata:
  # Unique key of the Job instance
  name: example-job
spec:
  template:
    metadata:
      name: example-job
    spec:
      containers:
      - name: pi
        image: perl
        command: ["perl"]
        args: ["-Mbignum=bpi", "-wle", "print bpi(2000)"]
      # Do not restart containers after they exit
      restartPolicy: Never
  

Copia el manifiesto a un archivo llamado config.yaml y crea el trabajo:

kubectl apply -f config.yaml

Este trabajo procesa pi a 2,000 lugares y, luego, lo imprime.

El único requisito para un objeto de trabajo es que el campo de la template del Pod es obligatorio.

Recuento de finalizaciones de trabajos

Un trabajo se completa cuando una cantidad específica de Pods finaliza de manera correcta. De forma predeterminada, un trabajo no paralelo con un solo Pod se completa apenas el Pod finaliza de manera correcta.

Si tienes un trabajo paralelo, puedes establecer un recuento de finalización mediante el campo de completions opcional. Este campo especifica cuántos Pods deben finalizar de manera correcta antes de que se complete el trabajo. El campo de completions acepta un valor positivo distinto de cero.

Omitir completions o especificar un valor cero hace que el éxito de cualquier Pod indique el éxito de todos los Pods.

Copia config.yaml del ejemplo anterior a un archivo llamado config-2.yaml. En config-2.yaml, cambia el name a example-job-2 y agrega completions: 8 al campo spec del trabajo. Esto especifica que debe haber ocho finalizaciones exitosas:

apiVersion: batch/v1
kind: Job
metadata:
  name: example-job-2
spec:
  completions: 8
  template:
    metadata:
      name: example-job-2
    spec:
      ...

Crea el trabajo:

kubectl apply -f config-2.yaml

El valor predeterminado de completions es 1. Cuando se configuran las completions, el campo de parallelism establece de manera predeterminada 1 a menos que se establezca lo contrario. Si no están configurados ambos campos, sus valores predeterminados son 1.

Administra el paralelismo

De forma predeterminada, los Pods de trabajo no se ejecutan en paralelo. El campo de parallelism opcional especifica la cantidad máxima deseada de Pods que un trabajo debe ejecutar al mismo tiempo en un momento determinado.

La cantidad real de Pods que se ejecutan en un estado estable puede ser menor que el valor de parallelism si el trabajo restante es menor que el valor de parallelism. Si también configuraste las completions, la cantidad real de Pods que se ejecutan en paralelo no excede la cantidad de finalizaciones restantes. Un trabajo puede limitar la creación de Pods en respuesta a un fallo excesivo en la creación de Pods.

Copia config.yaml del ejemplo anterior a un archivo llamado config-3.yaml. En config-3.yaml, cambia el name a example-job-3 y agrega parallelism: 5 al campo spec del trabajo. Esto especifica que debe haber cinco Pods simultáneos en ejecución:

apiVersion: batch/v1
kind: Job
metadata:
  name: example-job-3
spec:
  parallelism: 5
  template:
    metadata:
      name: example-job-3
    spec:
      ...

Crea el trabajo:

kubectl apply -f config-3.yaml

El valor predeterminado de parallelism es 1 si el campo se omite o si se establece lo contrario. Si el valor se establece en 0, el trabajo se pone en pausa hasta que se aumenta el valor.

Especifica una fecha límite

De forma predeterminada, un trabajo crea Pods nuevos para siempre, si sus Pods fallan con continuidad. Si prefieres no tener un reintento de trabajo para siempre, puedes especificar un valor de fecha límite mediante el campo opcional activeDeadlineSeconds.

Una fecha límite le otorga a un trabajo una cantidad específica de tiempo, en segundos, para completar sus tareas con éxito antes de finalizar.

Para especificar una fecha límite, agrega el valor activeDeadlineSeconds al campo spec del trabajo en el archivo de manifiesto. Por ejemplo, la siguiente configuración especifica que el trabajo tiene 100 segundos para completarse con éxito:

apiVersion: batch/v1
kind: Job
metadata:
  name: example-job
spec:
  activeDeadlineSeconds: 100
  template:
    metadata:
      name: example-job
    spec:
      ...

Si un trabajo no se completa con éxito antes de la fecha límite, el trabajo finaliza con el estado DeadlineExceeded. Esto hace que la creación de Pods se detenga y que los Pods existentes se borren.

Especifica un selector de Pods

Especificar un selector de forma manual es útil si quieres actualizar una plantilla de Pod del trabajo, pero quieres que los Pods actuales del trabajo se ejecuten en el trabajo actualizado.

Se crea una instancia de trabajo con un campo selector. El selector genera un identificador único para los Pods del trabajo. El ID generado no se superpone con ningún otro trabajo. Por lo general, no establecerías este campo tú mismo: establecer un valor selector que se superponga con otro trabajo puede causar problemas con los Pods del otro trabajo. Para configurar el campo, debes especificar manualSelector: True en el campo spec del trabajo.

Por ejemplo, puedes ejecutar kubectl get job my-job --output=yaml si quieres ver la especificación del trabajo, que contiene el selector generado para sus Pods:

kind: Job
metadata:
  name: my-job
...
spec:
  completions: 1
  parallelism: 1
  selector:
    matchLabels:
      controller-uid: a8f3d00d-c6d2-11e5-9f87-42010af00002
...

Cuando creas un trabajo nuevo, puedes configurar el valor manualSelector a True, luego configura el valor job-uid del campo selector de la siguiente manera:

kind: Job
metadata:
  name: my-new-job
  ...
spec:
  manualSelector: true
  selector:
    matchLabels:
      job-uid: a8f3d00d-c6d2-11e5-9f87-42010af00002
  ...

Los Pods que crea my-new-job usan el UID del Pod anterior.

Inspecciona un trabajo

kubectl

Para verificar el estado de un trabajo, ejecuta el siguiente comando:

kubectl describe job my-job

Para ver todos los recursos de Pod en tu clúster, incluidos los Pods creados por el trabajo que se completaron, ejecuta lo siguiente:

kubectl get pods -a

La marca -a especifica que se deben mostrar todos los recursos del tipo especificado (en este caso, Pods).

Console

Después de crear un trabajo con kubectl, puedes inspeccionarlo si realizas los siguientes pasos:

  1. Visita el menú Cargas de trabajo de Google Kubernetes Engine en GCP Console.

    Visitar el menú Cargas de trabajo

  2. Selecciona la carga de trabajo deseada en el menú.

Puedes inspeccionar el trabajo de las siguientes maneras:

  • Para ver la configuración activa del trabajo, haz clic en YAML.
  • Para ver todos los eventos relacionados con el trabajo, haz clic en Eventos.
  • Para ver el historial de revisiones del trabajo, haz clic en Historial de revisiones.

Escala un trabajo

kubectl

Para escalar un trabajo, ejecuta el siguiente comando:

kubectl scale job my-job --replicas=[VALUE]

kubectl scale hace que cambie la cantidad de Pods que se ejecutan al mismo tiempo. En particular, cambia el valor del parallelism al [VALOR] que especifiques.

Console

Para escalar un trabajo, realiza los siguientes pasos:

  1. Visita el menú Cargas de trabajo de Google Kubernetes Engine en GCP Console.

    Visitar el menú Cargas de trabajo

  2. Selecciona la carga de trabajo deseada en el menú.

  3. Haz clic en Escalar.

  4. En el campo Réplicas, ingresa la cantidad deseada de réplicas.

  5. Haz clic en Escalar.

Borra un trabajo

Cuando se completa, el trabajo deja de crear Pods. El objeto de la API de trabajo no se quita cuando se completa, lo que permite que veas su estado. Los Pods que crea el trabajo no se borran, pero finalizan. La retención de los Pods te permite ver sus registros y, también, interactuar con ellos.

kubectl

Para borrar un trabajo, ejecuta el siguiente comando:

kubectl delete job my-job

Cuando borras un trabajo, también se borran todos sus Pods.

Para borrar un trabajo, pero conservar sus Pods, especifica la marca --cascade false:

kubectl delete jobs my-job --cascade false

Console

Para borrar un trabajo, realiza los siguientes pasos:

  1. Visita el menú Cargas de trabajo de Google Kubernetes Engine en GCP Console.

    Visitar el menú Cargas de trabajo

  2. En el menú, selecciona la carga de trabajo deseada.

  3. Haz clic en Borrar.

  4. En el menú de diálogo de confirmación, haz clic en Borrar.

Pasos siguientes

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...