Ejecuta trabajos con lotes en GKE

Beta

En esta página, se muestra cómo ejecutar trabajos por lotes en GKE (Lote). Existen dos formas de enviar trabajos en lote: ksub y kubectl. Con el comando ksub se pueden enviar secuencias de comandos de shell como trabajos y con kubectl se pueden enviar trabajos con archivos yaml.

Configura ksub

Ksub es una herramienta de línea de comandos para realizar acciones relacionadas con el trabajo en tu sistema por lotes. Puedes usar palabras clave con el prefijo #KB para especificar las propiedades del trabajo.

Para configurar Ksub, debes seguir los siguientes pasos:

  1. Habilita ksub con el fin de que use tus credenciales de usuario para el acceso a la API:

    gcloud auth application-default login
    
  2. Cambia al directorio kbatch:

    cd kbatch
    
  3. Configura un archivo de configuración predeterminado:

    ./ksub --config --create-default
    

    Esto crea un archivo de configuración en ~/.ksubrc.

  4. Agrega los valores predeterminados para projectID y clusterName en .ksubrc.

  5. Si no operas en el espacio de nombres predeterminado, namespace, edita el campo namespace para configurar un espacio de nombres predeterminado nuevo.

    vi ~/.ksubrc
    
  6. Configura puntos de activación [Este paso es opcional si no usas un PersistentVolumeClaim privado creado por el administrador del clúster]

    ./ksub --config --add-volume fs-volume --volume-source PersistentVolumeClaim
     --params claimName:[PVC_NAME] --params readOnly:false
    

    En el ejemplo anterior, [PVC_NAME] es el nombre de PersistentVolumeClaim creado por el administrador para que puedas guardar tus archivos privados de entrada/salida.

  7. Agrega el directorio de instalación de ksub a $PATH:

    export PATH=$PATH:/path/to/kbatch/
    

Configura kubectl

La herramienta predeterminada para Kubernetes es kubectl, que ya está incluida en el SDK de Cloud.

Para asegurarte de que tienes la versión actual de kubectl, ejecuta el siguiente comando:

gcloud components update

Ejecuta trabajos de muestra

En los lotes en GKE, se incluyen varios trabajos de muestra.

ComputePi

  1. Obtén las muestras con el siguiente vínculo:

    git clone https://github.com/GoogleCloudPlatform/Kbatch.git
    
  2. Crea los recursos de administrador por lotes predeterminados en el espacio de nombres de K8s “predeterminado”:

    ./samples/defaultresources/create.sh
    

Puedes enviar el trabajo con ksub o kubectl.

ksub

  1. Ejecuta el trabajo ComputePi en /samples/computepi:

    ksub run_pi_with_ksub.sh
    

    Con este comando, se muestra el nombre del trabajo.

  2. Espera a que se complete el trabajo:

    ksub -Gw [JOB_NAME]
    
  3. Obtén el nombre de la tarea:

    ksub -Ga [JOB_NAME]
    

    Con este comando, se muestra el nombre de la tarea.

  4. Visualiza los registros:

    ksub -L [TASK_NAME]
    

kubectl

  1. Ejecuta el trabajo de ComputePi en /samples/computepi:

    kubectl create -f pi-job.yaml
    

    El resultado es el siguiente:

    batchjob.kbatch.k8s.io/[JOB_NAME] created
    
  2. Identifica el Pod asociado al trabajo:

    kubectl get pods | grep [JOB_NAME]
    

    El resultado es el siguiente:

    [POD_NAME]   0/1     Completed   0          1m
    
  3. Visualiza los registros:

    kubectl logs pod/[POD_NAME]
    

Ejecuta trabajos con dependencias

Con las dependencias, puedes ejecutar algunos trabajos solo cuando se hayan producido condiciones específicas relacionadas con trabajos anteriores. La versión Beta admite 3 tipos de dependencia:

Listo
Un trabajo se ejecutará solo si todos los trabajos de los que depende están listos.
Error
Un trabajo se ejecutará solo si fallan todos los trabajos de los que depende.
Completo
Un trabajo se ejecutará solo cuando todos los trabajos de los que depende estén completos.

Si el sistema decide no ejecutar un trabajo porque no se puede encontrar una dependencia, el lote marca el trabajo como Failed?. Por ejemplo, si el trabajo1 depende del trabajo2 con el tipo de dependencia Success y el trabajo2 falla, entonces el trabajo1 nunca se ejecuta y se considera que falló. De lo contrario, la falla y el éxito del trabajo están determinados por la falla o el fracaso del pod asociado al trabajo, según lo definido por los ciclos de vida de pods de Kubernetes.

Antes de ejecutar este trabajo de muestra, debes configurar una instancia de Google Cloud Filestore en la misma zona que la ubicación del nodo de tu clúster de GKE para las entradas y salidas.

  1. Obtén y extrae las muestras de lotes, las herramientas de administración y las herramientas de usuario. Omite este paso si ya lo hiciste para otros trabajos de muestra.

    git clone https://github.com/GoogleCloudPlatform/Kbatch.git
    
    tar -xzvf kbatch-github.tar.gz
    
  2. Crea los recursos de administrador por lotes predeterminados en el espacio de nombres de K8s “predeterminado”. Omite este paso si ya lo hiciste para otros trabajos de muestra.

    ./samples/defaultresources/create.sh
    
  3. Cambia a la carpeta imageprocess.

    cd ../imageprocess
    
  4. Ejecuta apply-extra-config.sh para crear los recursos y permisos de PersistentVolume. Escribe “s” cuando se te pregunte si puedes “ejecutar como raíz en BatchTasks y acceder al almacenamiento”.

  5. Actualiza la configuración de ksub para usar la reclamación de volumen persistente creada en el paso anterior:

    ./ksub --config --add-volume fs-volume --volume-source PersistentVolumeClaim \
     --params claimName:[PVC_NAME] --params readOnly:false
    

    En el ejemplo anterior, [PVC_NAME] es el nombre del PVC creado en el paso 4. En este ejemplo, se creó una PersistentVolumeClaim llamada pvc en el paso 4, entonces, reemplaza [PVC_NAME] por pvc.

  6. Ejecuta copy-input.sh para copiar la imagen de entrada a Filestore.

Puedes enviar el trabajo con ksub o kubectl.

ksub

Envía un trabajo con dependencias mediante ksub

Hay dos formas de enviar un trabajo con dependencias: especifica la dependencia con un solo comando o edita de forma manual el campo KB Dependency Success: en la secuencia de comandos de shell.

Especifica dependencias con ksub

  1. Ejecuta el siguiente comando desde samples/imageprocess para ejecutar los dos trabajos con una dependencia:

    ksub --dependency Success:job_name -- run_grey_with_ksub.sh
    

    También puedes usar variables de shell para conectar los trabajos.

    Crea el trabajo1:

    job1=`ksub run_checkerboard_with_ksub.sh` \
    

    Envía el trabajo2:

    ksub --dependency Success:${job1} -- ./run_grey_with_ksub.sh
    
  2. Obtén el nombre de la tarea:

    ksub -Ga [JOB_NAME]
    

    Con este comando, se muestra el nombre de la tarea.

  3. Visualiza los registros:

    ksub -L [TASK_NAME]
    
  4. Ejecuta copy-output.sh para copiar la imagen procesada en tu máquina local.

Usa el nombre de tu primer trabajo para crear una dependencia.

  1. Envía trabajos de ImageProcess:

    ksub run_checkerboard_with_ksub.sh
    

    Esto da como resultado el [JOB_NAME], por ejemplo:

    checkerboard-64t5n
    

    El siguiente run_grey_with_ksub.sh describe una secuencia de comandos de muestra para el trabajo2 con una dependencia del trabajo1:

    #!/bin/sh
    
    #KB Jobname grey-
    #KB Namespace default
    #KB Image gcr.io/kbatch-images/greyimage/greyimage:latest
    #KB Queuename default
    #KB MaxWallTime 5m
    #KB MinCpu 1.0
    #KB MinMemory 2Gi
    #KB Mount fs-volume /mnt/pv
    #KB Dependency Success:[JOB_NAME]
    
    echo "Starting job grey"
    # greyimage is in /app directory.
    cd /app
    ./greyimage -in=/mnt/pv/checker.png -out=/mnt/pv/checkergrey.png
    echo "Completed job grey"
    
  2. Abre run_grey_with_ksub.sh con el editor que prefieras y reemplaza [JOB_NAME] por el nombre de tu trabajo.

  3. Envía el segundo trabajo

    ksub run_grey_with_ksub.sh
    

    Esto da como resultado el nombre del trabajo.

  4. Obtén el nombre de la tarea:

    ksub -Ga [JOB_NAME]
    

    Con este comando, se muestra el nombre de la tarea.

  5. Visualiza los registros:

    ksub -L [TASK_NAME]
    
  6. Ejecuta copy-output.sh para copiar la imagen procesada en tu máquina local.

kubectl

Envía un trabajo con dependencias mediante kubectl

  1. Envía trabajos de ImageProcess:

    kubectl create -f imageprocess-job.yaml
    

    El resultado es similar al siguiente ejemplo:

    batchjob.kbatch.k8s.io/checkerboard created
    batchjob.kbatch.k8s.io/grey created
    
  2. Examina el primer trabajo:

    kubectl describe batchjob/checkerboard
    
  3. Examina el segundo trabajo:

    kubectl describe batchjob/grey
    
  4. Ejecuta copy-output.sh para copiar la imagen procesada en tu máquina local.

Ejecuta un trabajo que usa GPU

  1. Obtén y extrae las muestras de lotes, las herramientas de administración y las herramientas de usuario. Omite este paso si ya lo hiciste para otros trabajos de muestra.

    git clone https://github.com/GoogleCloudPlatform/Kbatch.git
    
    tar -xzvf kbatch-github.tar.gz
    
  2. Crea los recursos de administrador por lotes predeterminados en el espacio de nombres de K8s “predeterminado”. Omite este paso si ya lo hiciste para otros trabajos de muestra.

    ./samples/defaultresources/create.sh
    

Puedes enviar el trabajo con ksub o kubectl.

ksub

  1. Verifica que samples/GPUjob/run_gpu_with_ksub.sh indique un tipo de GPU que esté disponible en tu clúster.

  2. Envía el trabajo:

    samples/GPUjob/run_gpu_with_ksub.sh
    

    Esto da como resultado el nombre del trabajo.

  3. Espera a que se complete el trabajo:

    ksub -Gw [JOB_NAME]
    
  4. Obtén el nombre de la tarea:

    ksub -Ga [JOB_NAME]
    

    Con este comando, se muestra el nombre de la tarea.

  5. Visualiza los registros:

    ksub -L [TASK_NAME]
    

gcloud

  1. Verifica que la GPU que se muestra en el archivo gpu-job.yaml coincida con un tipo de GPU que esté disponible en la zona de tu escalador automático.

  2. Envía el trabajo:

    kubectl create -f samples/GPUjob/run_gpu_with_ksub.sh
    

    El resultado es similar a lo siguiente:

    batchjob.kbatch.k8s.io/[JOB_NAME] created
    
  3. Visualiza los registros:

    kubectl describe batchjob/[JOB_NAME]
    

Envía trabajos

Puedes enviar trabajos con ksub o kubectl.

Con ksub

Ksub permite el envío de secuencias de comandos como trabajos. Puedes usar palabras clave con el prefijo #KB para especificar las propiedades del trabajo.

Con el siguiente comando run_pi_with_ksub.sh, se describe un trabajo ksub de muestra:

#!/bin/sh

# Keywords to specify job parameters

#KB Jobname pi-
#KB Namespace default
#KB Image gcr.io/kbatch-images/generate-pi/generate-pi:latest
#KB Queuename default
#KB MaxWallTime 5m
#KB MinCpu 1.0
#KB MinMemory 2Gi

echo "Starting job pi"
# pi is in /app directory.
cd /app
./pi
echo "Completed job pi"

Para enviar la secuencia de comandos, ejecuta el siguiente comando:

ksub run_pi_with_ksub.sh

Especifica palabras clave de ksub

Especifica los parámetros de tu trabajo con palabras clave. Estas palabras clave llevan el prefijo #KB. Ksub espera palabras clave en un bloque de líneas sin líneas en blanco ni espacios entre ellas. Ksub deja de analizar las palabras clave #KB después de la primera línea que no comienza con #KB.

Ksub admite las siguientes palabras clave:

Palabra clave Comentario Ejemplo
Jobname Prefijo del nombre de trabajo usado para generar el nombre de trabajo. #KB Jobname pi-
Namespace Espacio de nombres en el que opera el trabajo. #KB Namespace default
Queuename Fila a la que se envía el trabajo. #KB Queuename default
Image Imagen que ejecuta el contenedor del trabajo. #KB Image ubuntu
Mount PVC para activar y la ubicación donde debe activarse. #KB Mount fs-volume /tmp
MinCpu Cantidad de CPU que requiere el trabajo. #KB MinCpu 1.0
MinMemory Cantidad de memoria que requiere el contenedor. #KB MinMemory 2Gi
Gpu Cantidad y tipo de GPU que se requieren para el trabajo. En el ejemplo de la derecha, nvidia-tesla-k80 es el tipo de GPU que se usará, y “2” es la cantidad de GPU que se usarán. #KB GPU nvidia-tesla-k80 2
Dependencia Dependencias del trabajo #KB Dependency Success:job-name1
MaxWallTime Tiempo máximo de ejecución del trabajo. #KB MaxWallTime 5m

Usa kubectl

Kubectl se conecta al sistema de lotes mediante la configuración de Kubernetes para el clúster.

En el siguiente pi-job.yaml, se describe una muestra de trabajo YAML:

apiVersion: kbatch.k8s.io/v1beta1
kind: BatchJob
metadata:
  generateName: pi-  # generateName allows the system to generate a random name, using this prefix, for the BatchJob upon creation.
  namespace: default
spec:
  batchQueueName: default
  taskGroups:
  - name: main
    maxWallTime: 5m
    template:
      spec:
        containers:
        - name: pi
          # This image has been made public so it can be pulled from any project.
          image: gcr.io/kbatch-images/generate-pi/generate-pi:latest
          resources:
            requests:
              cpu: 1.0
              memory: 2Gi
            limits:
              cpu: 1.0
              memory: 2Gi
          imagePullPolicy: IfNotPresent
        restartPolicy: Never

Para enviar el trabajo, ejecuta el siguiente comando:

kubectl create -f pi-job.yaml

Administra datos

  1. Obtén las herramientas de usuario:

    git clone https://github.com/GoogleCloudPlatform/Kbatch.git
    
  2. Ve al directorio de supervisión:

    cd usertools/filestore
    

Los lotes en GKE proporcionan una utilidad para copiar archivos desde un Kubernetes PersistentVolume y hacia él.

El uso básico de la secuencia de comandos es:

./datacopy.sh [-d|-u] -l [LOCAL_FILE] -r [REMOTE_FILE_PATH] -p [PVC_NAME]

En el ejemplo anterior, se ilustra lo siguiente:

  • -u para copiar datos de tu estación de trabajo a Cloud.
  • -d para copiar datos desde Cloud a tu estación de trabajo.
  • -h imprime un mensaje de uso útil.

Si deseas ejecutar un trabajo que usa el archivo de entrada input.dat que está en el directorio actual de tu máquina local, puedes escribir el siguiente comando para copiar el archivo de entrada a tu directorio de lotes personal:

./datacopy.sh -u -l input.dat -r problem-1-input.data -p [NAME]-team1

Visualiza los trabajos

Puedes ver trabajos mediante ksub o kubectl.

ksub

Visualiza trabajos por usuario en una cola

Visualiza los trabajos por usuario con la ejecución del siguiente comando:

ksub -Q -n [NAMESPACE] [QUEUE_NAME]

En el que el primer [NAMESPACE] es tu espacio de nombres y [QUEUE_NAME] es tu nombre de cola.

El resultado es similar a lo siguiente:

Name: pi-s4dwl, Status: Succeeded

Visualiza trabajos en una cola

Para ver los trabajos en una cola, ejecuta el siguiente comando:

ksub -Qa -n [NAMESPACE] [QUEUE_NAME]

En el que el primer [NAMESPACE] es tu espacio de nombres y [QUEUE_NAME] es tu nombre de cola.

El resultado es similar a lo siguiente:

Name: pi-s4dwl, Creation Time Stamp: 2019-09-12 13:03:42 -0700 PDT, Status: Succeeded

kubectl

Visualiza trabajos en una cola

Para ver los trabajos en una cola, ejecuta el siguiente comando:

kubectl get batchjobs --selector=batchQueue=[QUEUE_NAME] --namespace [NAMESPACE]

En el comando anterior, [QUEUE_NAME] es tu nombre de cola y [NAMESPACE] es tu espacio de nombres.

El resultado es similar a lo siguiente:

NAME       AGE
pi-6rc7s   2m

Visualiza trabajos por usuario

Visualiza trabajos por usuario mediante las siguientes instrucciones:

  1. Recupera tu nombre de usuario:

    gcloud config get-value account
    

    El resultado es similar a lo siguiente:

    user@company.com
    
  2. Ejecuta el siguiente comando para ver una lista de trabajos de un usuario en un espacio de nombres:

    kubectl get batchjobs --selector=submittedBy=[userATexample.com] --namespace [NAMESPACE]
    

    En el comando anterior, --selector=submittedBy es tu emailATcompany.com y [NAMESPACE] es tu espacio de nombres.

    El resultado es similar a lo siguiente:

    NAME       AGE
    pi-6rc7s   36m
    
  3. Ejecuta el siguiente comando para ver una lista de trabajos de un usuario en una cola:

    kubectl get batchjobs --selector=batchQueue=[QUEUE_NAME],submittedBy=[userATexample.com] --namespace [NAMESPACE]
    

    En el comando anterior, [QUEUE_NAME] es tu nombre de cola, emailATcompany.com, y [NAMESPACE] es tu espacio de nombres.

    El resultado es similar a lo siguiente:

    NAME       AGE
    pi-6rc7s   36m
    

Detén los trabajos

Puedes detener un trabajo en ejecución con ksub o kubectl. El trabajo se marcará como “Error” con la condición “JobTerminationByUser” mientras se reservan los datos históricos asociados al trabajo.

ksub

Ejecuta el siguiente comando para finalizar el trabajo:

ksub -T [JOB_NAME] -n [NAMESPACE]

En el comando anterior, [JOB_NAME] es tu nombre de trabajo y [NAMESPACE] es tu espacio de nombres.

El resultado es similar al siguiente ejemplo:

Termination request for job [JOB_NAME] is sent to the server, please check the job status

También puedes ejecutar el siguiente comando para ver el trabajo hasta que se complete:

ksub -Gw [JOB_NAME] -n [NAMESPACE]

kubectl

Para finalizar un trabajo en ejecución, ejecuta el siguiente comando:

kubectl patch batchjob [JOB_NAME] --namespace [NAMESPACE] --type merge --patch '{"spec": {"userCommand": "Terminate"}}'

En el comando anterior, [JOB_NAME] es tu nombre de trabajo y [NAMESPACE] es tu espacio de nombres.

El resultado es similar al siguiente ejemplo:

batchjob.kbatch.k8s.io/[JOB_NAME] patched

Visualiza registros de trabajos

Los registros de trabajos solo se pueden ver después de que el trabajo comienza a ejecutarse, es decir, si el trabajo pasó de la cola a un estado en ejecución. Debes esperar a que comience el trabajo antes de ver sus registros.

Para obtener el registro de un trabajo, ejecuta el siguiente comando:

ksub -L -n [NAMESPACE] [JOB_NAME]

En el comando anterior, [NAMESPACE] es tu espacio de nombres y [JOB_NAME] es el nombre de tu trabajo.

Próximos pasos