Como executar jobs com Lote no GKE

Esta página mostra como executar jobs em lote com Lote no GKE (Lote). Há duas maneiras de enviar jobs no Lote: ksub e kubectl. O comando ksub pode enviar scripts de shell como jobs e kubectl pode enviar jobs usando arquivos yaml.

Como configurar ksub

Ksub é uma ferramenta de linha de comando para realizar ações relacionadas ao job no seu sistema em lote. Você pode usar palavras-chave com o prefixo #KB para especificar as propriedades do job.

Para configurar Ksub, execute as seguintes etapas:

  1. Ative ksub para usar suas próprias credenciais de usuário para acesso à API:

    gcloud auth application-default login
    
  2. Altere para o diretório kbatch:

    cd kbatch
    
  3. Defina um arquivo de configuração padrão:

    ./ksub --config --create-default
    

    Isso cria um arquivo de configuração em ~/.ksubrc.

  4. Adicione os valores padrão para projectID e clusterName em .ksubrc.

  5. Se você não estiver operando no namespace padrão, namespace, configure um novo namespace padrão editando o campo namespace.

    vi ~/.ksubrc
    
  6. Como configurar pontos de montagem [Opcional, se você não estiver usando um PersistentVolumeClaim particular criado pelo administrador do cluster]

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

    em que [PVC_NAME] é o nome de PersistentVolumeClaim criado pelo administrador para você salvar seus arquivos particulares de entrada/saída. Se estiver usando uma instância do Filestore, esse é o nome da instância do Filestore.

  7. Adicione o diretório de instalação de ksub a $PATH:

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

Como configurar o kubectl

A ferramenta padrão do Kubernetes é o kubectl, que já está incluído no Cloud SDK.

Para garantir que você tenha a versão atual do kubectl, execute o seguinte comando:

gcloud components update

Como executar jobs de amostra

O lote no GKE inclui vários jobs de amostra.

ComputePi

  1. Veja as amostras:

    git clone https://github.com/GoogleCloudPlatform/Kbatch.git
    
  2. Crie os recursos de administrador de lotes padrão no namespace K8s "padrão":

    ./samples/defaultresources/create.sh
    

Você pode enviar o job com ksub ou kubectl.

ksub

  1. Execute o job ComputePi em /samples/computepi:

    ksub run_pi_with_ksub.sh
    

    Este comando gera o nome do job.

  2. Aguarde a conclusão do job:

    ksub -Gw [JOB_NAME]
    
  3. Receba o nome da tarefa:

    ksub -Ga [JOB_NAME]
    

    Este comando gera o nome da tarefa.

  4. Visualize os registros:

    ksub -L [TASK_NAME]
    

kubectl

  1. Execute o job ComputePi em /samples/computepi:

    kubectl create -f pi-job.yaml
    

    Essa saída é:

    batchjob.kbatch.k8s.io/[JOB_NAME] created
    
  2. Identifique o pod associado ao job:

    kubectl get pods | grep [JOB_NAME]
    

    A saída é:

    [POD_NAME]   0/1     Completed   0          1m
    
  3. Visualize os registros:

    kubectl logs pod/[POD_NAME]
    

Como executar jobs com dependências

Com as dependências, você pode executar alguns jobs apenas quando ocorrerem condições específicas relacionadas a jobs anteriores. A versão Beta é compatível com três tipos de dependências:

Sucesso
Um job será executado apenas se todos os jobs dos quais ele depende tiverem sido bem-sucedidos.
Falha
Um job será executado apenas se todos os jobs dos quais ele depende tiverem falhado.
Concluída
Um job será executado apenas depois que todos os jobs dos quais ele depende tiverem sido concluídos.

Se o sistema decidir não executar um job porque uma dependência não pode ser atendida, o lote marcará o job como Failed. Por exemplo, se job1 depender de job2 com o tipo de dependência Success e job2 falhar, job1 não será executado, sendo considerado falha. Caso contrário, a falha e o sucesso do job serão determinados pelo sucesso ou falha do pod associado ao job, conforme definido pelo ciclo de vida do pod do Kubernetes.

Antes de executar esse job de amostra, você precisa configurar uma instância do Filestore do Google Cloud, na mesma zona do local do nó do cluster do GKE, para entradas e saídas.

  1. Receba e extraia as amostras de lotes, admintools e usertools. Pule esta etapa se você tiver feito isso para outros jobs de amostra.

    git clone https://github.com/GoogleCloudPlatform/Kbatch.git
    
    tar -xzvf kbatch-github.tar.gz
    
  2. Crie os recursos de administrador de lotes padrão no namespace K8s "padrão". Pule esta etapa se você tiver feito isso para outros jobs de amostra.

    ./samples/defaultresources/create.sh
    
  3. Altere para a pasta imageprocess.

    cd ../imageprocess
    
  4. Execute apply-extra-config.sh para criar os recursos e permissões de PersistentVolume. Digite "y" quando for perguntado se você pode "executar como raiz em BatchTasks e acessar o armazenamento".

  5. Atualize a configuração do ksub para usar a reivindicação de volume permanente criada na etapa anterior:

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

    em que [PVC_NAME] é o nome do PVC criado na etapa 4. Neste exemplo, um PersistentVolumeClaim chamado pvc foi criado na etapa 4. Portanto, substitua [PVC_NAME] por pvc.

  6. Execute copy-input.sh para copiar a imagem de entrada para o Filestore.

Você pode enviar o job com ksub ou kubectl.

ksub

Como enviar um job com dependências usando o ksub

Há duas maneiras de enviar um job com dependências: especificar a dependência com um único comando ou editar manualmente o campo Dependência KB bem-sucedida: no script de shell.

Especifique dependências com ksub

  1. Execute o seguinte comando a partir de samples/imageprocess para executar os dois jobs com uma dependência:

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

    Você também pode usar variáveis de shell para conectar os jobs.

    Criar job1:

    job1=`ksub run_checkerboard_with_ksub.sh` \
    

    Enviar job2:

    ksub --dependency Success:${job1} -- ./run_grey_with_ksub.sh
    
  2. Receba o nome da tarefa:

    ksub -Ga [JOB_NAME]
    

    Este comando gera o nome da tarefa.

  3. Visualize os registros:

    ksub -L [TASK_NAME]
    
  4. Execute copy-output.sh para copiar a imagem processada em sua máquina local.

Use o nome do primeiro job para criar uma dependência.

  1. Enviar jobs ImageProcess:

    ksub run_checkerboard_with_ksub.sh
    

    Isso gera o [JOB_NAME], por exemplo:

    checkerboard-64t5n
    

    O seguinte run_grey_with_ksub.sh descreve um script de amostra para job2 com uma dependência de job1:

    #!/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. Abra run_grey_with_ksub.sh com o editor de sua escolha e substitua [JOB_NAME] pelo nome do job.

  3. Envie o segundo job

    ksub run_grey_with_ksub.sh
    

    Isso gera o nome do job.

  4. Receba o nome da tarefa:

    ksub -Ga [JOB_NAME]
    

    Este comando gera o nome da tarefa.

  5. Visualize os registros:

    ksub -L [TASK_NAME]
    
  6. Execute copy-output.sh para copiar a imagem processada em sua máquina local.

kubectl

Como enviar um job com dependências usando o kubectl

  1. Enviar jobs ImageProcess:

    kubectl create -f imageprocess-job.yaml
    

    A saída é semelhante a esta:

    batchjob.kbatch.k8s.io/checkerboard created
    batchjob.kbatch.k8s.io/grey created
    
  2. Examine o primeiro job:

    kubectl describe batchjob/checkerboard
    
  3. Examine o segundo job:

    kubectl describe batchjob/grey
    
  4. Execute copy-output.sh para copiar a imagem processada em sua máquina local.

Como executar um job que usa GPUs

  1. Receba e extraia as amostras de lotes, admintools e usertools. Pule esta etapa se você tiver feito isso para outros jobs de amostra.

    git clone https://github.com/GoogleCloudPlatform/Kbatch.git
    
    tar -xzvf kbatch-github.tar.gz
    
  2. Crie os recursos de administrador de lotes padrão no namespace K8s "padrão". Pule esta etapa se você tiver feito isso para outros jobs de amostra.

    ./samples/defaultresources/create.sh
    

Você pode enviar o job com ksub ou kubectl.

ksub

  1. Verifique se samples/GPUjob/run_gpu_with_ksub.sh indica um tipo de GPU que está disponível em seu cluster.

  2. Envie o job:

    samples/GPUjob/run_gpu_with_ksub.sh
    

    Isso gera o nome do job.

  3. Aguarde a conclusão do job:

    ksub -Gw [JOB_NAME]
    
  4. Receba o nome da tarefa:

    ksub -Ga [JOB_NAME]
    

    Este comando gera o nome da tarefa.

  5. Visualize os registros:

    ksub -L [TASK_NAME]
    

gcloud

  1. Verifique se a GPU mostrada no arquivo gpu-job.yaml corresponde a um tipo de GPU que está disponível na zona do escalonador automático.

  2. Envie o job:

    kubectl create -f samples/GPUjob/run_gpu_with_ksub.sh
    

    A saída é semelhante a:

    batchjob.kbatch.k8s.io/[JOB_NAME] created
    
  3. Visualize os registros:

    kubectl describe batchjob/[JOB_NAME]
    

Como enviar jobs

Você pode enviar jobs com ksub ou kubectl.

Como usar o ksub

O ksub permite o envio de scripts como jobs. Você pode usar palavras-chave com o prefixo #KB para especificar propriedades do job.

O seguinte run_pi_with_ksub.sh descreve um exemplo de job de ksub:

#!/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 o script, execute o seguinte comando:

ksub run_pi_with_ksub.sh

Como especificar palavras-chave de ksub

Especifique os parâmetros do job com palavras-chave. Essas palavras-chave têm o prefixo #KB. O ksub espera palavras-chave em um bloco de linhas sem linhas em branco ou espaços entre elas. O ksub interrompe a análise de palavras-chave #KB após a primeira linha, que não começa com #KB.

O ksub é compatível com as seguintes palavras-chave:

Palavra-chave Comentário Exemplo
Nome do job Prefixo do nome do job usado para gerar o nome do job. #KB Jobname pi-
Namespace O job de namespace opera em. Namespace #KB padrão
Nome da fila O job da fila foi enviado para. Padrão do nome da fila #KB
Imagem Imagem que executa o contêiner do job. Imagem #KB do ubuntu
Ativar PVC para ativação e local em que precisa ser ativado. #KB Mount fs-volume /tmp
MinCpu Número de CPUs que o job exige. #KB MinCpu 1.0
MinMemory Quantidade de memória exigida pelo contêiner. #KB MinMemory 2Gi
Gpu Número e tipo de GPUs necessárias para o job. No exemplo à direita, nvidia-tesla-k80 é o tipo das GPUs a serem usadas e "2" é o número de GPUs a serem usadas #KB GPU nvidia-tesla-k80 2
Dependência Dependências do job #KB Dependency Success:job-name1
MaxWallTime Tempo máximo de execução do job #KB MaxWallTime 5m

Como usar o kubectl

O kubectl se conecta ao sistema em lote usando a configuração do Kubernetes para o cluster.

O seguinte pi-job.yaml descreve uma amostra de job 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 o job, execute o seguinte comando:

kubectl create -f pi-job.yaml

Como gerenciar dados

  1. Receba as ferramentas do usuário:

    git clone https://github.com/GoogleCloudPlatform/Kbatch.git
    
  2. Acesse o diretório de monitoramento:

    cd usertools/filestore
    

O lote no GKE fornece um utilitário para você copiar arquivos de/para um PersistentVolume do Kubernetes.

O uso básico do script é:

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

Em que:

  • -u para copiar dados da sua estação de trabalho para a nuvem.
  • -d para copiar dados da nuvem para sua estação de trabalho.
  • -h imprime uma mensagem de uso útil.

Se você quiser executar um job que use o arquivo de entrada input.dat que está no diretório atual na sua máquina local, digite o seguinte comando para copiar o arquivo de entrada para seu diretório pessoal de lotes:

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

Como visualizar jobs

Você pode visualizar jobs usando ksub ou kubectl.

ksub

Como visualizar jobs por usuário em uma fila

Visualize os jobs por usuário executando o seguinte comando:

ksub -Q -n [NAMESPACE] [QUEUE_NAME]

Em que o primeiro [NAMESPACE] é seu namespace e [QUEUE_NAME] é o nome de sua Fila.

A saída é semelhante a:

Name: pi-s4dwl, Status: Succeeded

Como visualizar jobs em uma fila

Visualize os jobs em uma fila executando o seguinte comando:

ksub -Qa -n [NAMESPACE] [QUEUE_NAME]

Em que o primeiro [NAMESPACE] é seu namespace e [QUEUE_NAME] é o nome de sua Fila.

A saída é semelhante a:

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

kubectl

Como visualizar jobs em uma fila

Visualize os jobs em uma fila executando o seguinte comando:

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

Em que [QUEUE_NAME] é o nome de sua fila e [NAMESPACE] é seu namespace.

A saída é semelhante a:

NAME       AGE
pi-6rc7s   2m

Como visualizar jobs por usuário

Para visualizar os jobs por usuário, siga estas instruções:

  1. Recupere seu nome de usuário:

    gcloud config get-value account
    

    A saída é semelhante a:

    user@company.com
    
  2. Execute o seguinte comando para visualizar uma lista de jobs por um usuário em um Namespace:

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

    Em que --selector=submittedBy é seu emailATcompany.com e [NAMESPACE] é seu namespace.

    A saída é semelhante a:

    NAME       AGE
    pi-6rc7s   36m
    
  3. Execute o seguinte comando para visualizar uma lista de jobs por um usuário em uma Fila:

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

    Em que [QUEUE_NAME] é o nome de sua Fila, emailATcompany.com e [NAMESPACE] é seu namespace.

    A saída é semelhante a:

    NAME       AGE
    pi-6rc7s   36m
    

Como interromper jobs

Você pode interromper um job em execução usando ksub ou kubectl. O job será marcado como "Falha" com a condição "JobTerminationByUser" ao reservar os dados históricos associados ao job.

ksub

Execute o seguinte comando para encerrar o job:

ksub -T [JOB_NAME] -n [NAMESPACE]

em que [JOB_NAME] é o nome do seu Job e [NAMESPACE] é seu namespace.

A saída é semelhante a esta:

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

Você também pode executar o seguinte comando para assistir ao job até a conclusão:

ksub -Gw [JOB_NAME] -n [NAMESPACE]

kubectl

Para encerrar um job em execução, execute o seguinte comando:

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

em que [JOB_NAME] é o nome do seu Job e [NAMESPACE] é seu namespace.

A saída é semelhante a esta:

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

Como visualizar registros de jobs

Os registros de jobs só podem ser vistos após a execução do job ter sido iniciada, ou seja, se o job foi movido da fila para um estado em execução. É preciso aguardar o início do job antes de visualizar os registros.

Para visualizar o registro de um job, execute o seguinte comando:

ksub -L -n [NAMESPACE] [JOB_NAME]

Em que [NAMESPACE] é seu namespace e [JOB_NAME] é o nome do seu job.

A seguir