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 dos tipos de trabajo siguientes:

  • Trabajo no paralelo: Es un trabajo que crea solo un pod (y se vuelve a crear si el pod finaliza sin éxito) y que se completa cuando el pod finaliza de forma correcta.
  • Trabajo paralelo con recuento de finalización: Es un trabajo que se completa cuando una cierta cantidad de pods finaliza de forma correcta. Especifica la cantidad deseada de finalizaciones mediante el campo 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 habilitar la API de Google Kubernetes Engine.
  • Habilitar la API de Google Kubernetes Engine
  • Asegúrate de instalar 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 con el siguiente comando:
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Si trabajas con clústeres regionales, establece tu región de procesamiento predeterminada con el siguiente comando:
    gcloud config set compute/region [COMPUTE_REGION]
  • Actualiza gcloud a la versión más reciente con el siguiente comando:
    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 en 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 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 configurar un recuento de finalización mediante el campo opcional completions. Este campo especifica cuántos pods deben finalizar de manera correcta antes de que se complete el trabajo. El campo completions acepta un valor positivo distinto de cero.

La omisión de completions o la especificación de un valor de cero hace que el éxito de cualquier pod indique el éxito de todos los pods.

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

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

Crea el trabajo siguiente:

kubectl apply -f config-2.yaml

El valor predeterminado de completions es 1. Cuando se configura completions, el valor predeterminado del campo parallelism es 1, a menos que se configure de otra manera. 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 opcional parallelism especifica la cantidad máxima deseada de pods que un trabajo debería ejecutar simultáneamente 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 . Si también configuraste 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 error excesivo en la creación de Pods.

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

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

Crea el trabajo siguiente:

kubectl apply -f config-3.yaml

El valor predeterminado de parallelism es 1 si el campo se omite o se configura de otra manera. Si el valor se configura como 0, el trabajo se pone en pausa hasta que se aumente 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 por siempre, puedes especificar un valor de fecha límite mediante el campo activeDeadlineSeconds opcional.

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

Para especificar una fecha límite, agrega el valor de 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 correctamente 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

La especificación manual de un selector 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 estableces este campo tú mismo: la configuración de un valor selector que se superpone con otro trabajo puede causar problemas con los pods del otro trabajo. Para configurar el campo tú mismo, debes especificar manualSelector: True en el campo spec del trabajo.

Por ejemplo, puedes ejecutar kubectl get job my-job --output=yaml a fin de 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 de manualSelector como True y, luego, configurar el valor de job-uid del campo selector de la manera siguiente:

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

Los pods creados por 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, realiza los pasos siguientes para inspeccionarlo:

  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 en vivo 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 simultáneamente. En particular, cambia el valor de parallelism por el [VALUE] 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. Haz clic en Borrar en el menú de diálogo de confirmación.

Qué sigue

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

Enviar comentarios sobre...

Documentación de Kubernetes Engine