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 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: 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 estos 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 alguno falla o se borra.

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

Establece la configuración de gcloud predeterminada mediante uno de los siguientes métodos:

  • Usa gcloud init si quieres aprender acerca de los valores predeterminados de la configuración.
  • Usa gcloud config para establecer el ID, la zona y la región del proyecto de manera individual.

Usa gcloud init

  1. Ejecuta gcloud init y sigue estas instrucciones:

    gcloud init

    Si usas SSH en un servidor remoto, usa la marca --console-only para evitar que el comando inicie un navegador:

    gcloud init --console-only
  2. Sigue las instrucciones a fin de autorizar a gcloud para que use tu cuenta de Google Cloud.
  3. Crea una configuración nueva o selecciona una existente.
  4. Elige un proyecto de Google Cloud.
  5. Elige una zona predeterminada de Compute Engine.

Usa la configuración de gcloud

  • 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
  • Descarga la versión más reciente de gcloud:
    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 este 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 de completions acepta un valor positivo distinto de cero.

Omitir completions o especificar 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:

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 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 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 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 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:

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 se configura de otra manera. 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, este 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 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 siguiente manera:

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 el 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 siguientes pasos para inspeccionarlo:

  1. Visita el menú Cargas de trabajo de Google Kubernetes Engine en Cloud 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.

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 se 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, sigue estos pasos:

  1. Visita el menú Cargas de trabajo de Google Kubernetes Engine en Cloud 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.

Próximos pasos