Como executar um job

Nesta página, explicamos como executar jobs no Kubernetes Engine.

Visão geral

No GKE, um job é um objeto do controlador que representa uma tarefa finita. Os jobs são diferentes dos outros objetos do controlador porque eles gerenciam a tarefa durante a execução até a conclusão, em vez de gerenciar um estado pretendido contínuo, como o número total de pods em execução.

Os jobs são úteis para grandes tarefas de computação e baseadas em lote. É possível usá-los para aceitar a execução paralela de pods. Use um job para execução em paralelo de itens de trabalho que sejam independentes, mas relacionados: envio de e-mails, renderização de frames, transcodificação de arquivos, verificação de chaves do banco de dados etc. No entanto, os jobs não foram projetados para processos paralelos de comunicação estreita, como fluxos contínuos de processos em segundo plano.

No GKE, existem dois tipos de jobs:

  • Job não paralelo: cria apenas um pod, que será recriado se o pod se encerrar com falha. Ele é concluído quando o pod é encerrado com sucesso.
  • Jobs paralelos com contagem de conclusão: concluído quando um determinado número de pods é encerrado com sucesso. Especifique o número pretendido de conclusões no campo completions.

Os jobs são representados por objetos de job do Kubernetes. Quando um job é criado, o controlador dele gera um ou mais pods e garante que eles sejam encerrados com sucesso. À medida que o pods são encerrados, um job rastreia quantos concluíram as tarefas com sucesso. Quando o número pretendido de conclusões bem-sucedidas é atingido, o job é concluído.

Semelhante a outros controladores, um controlador de job criará um novo pod se um dos pods falhar ou for excluído.

Antes de começar

Antes de começar, verifique se você realizou as tarefas a seguir:

Defina configurações gcloud padrão usando um dos métodos a seguir:

  • Use gcloud init se você quer orientações para definir os padrões.
  • Use gcloud config para definir separadamente a região, a zona e o ID do projeto.

Como usar o gcloud init

  1. Execute gcloud init e siga as instruções:

    gcloud init

    Se você usa o SSH em um servidor remoto, utilize a sinalização --console-only para impedir que o comando inicie um navegador:

    gcloud init --console-only
  2. Siga as instruções para autorizar a gcloud a usar sua conta do Google Cloud.
  3. Crie uma nova configuração ou selecione uma atual.
  4. Escolha um projeto do Google Cloud.
  5. Escolha uma zona padrão do Compute Engine.

Como usar o gcloud config

  • Defina o ID do projeto padrão:
    gcloud config set project project-id
  • Se você estiver trabalhando com clusters zonais, defina a zona do Compute padrão:
    gcloud config set compute/zone compute-zone
  • Se você estiver trabalhando com clusters regionais, defina a região do Compute padrão:
    gcloud config set compute/region compute-region
  • Atualize gcloud para a versão mais recente:
    gcloud components update

Como criar um job

É possível criar um job usando kubectl apply (em inglês) com um arquivo de manifesto.

O exemplo a seguir mostra um manifesto de job:

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
      

Copie o manifesto para um arquivo chamado config.yaml e crie o Job:

    kubectl apply -f config.yaml
    

Esse job computa o pi até 2.000 casas e, em seguida, o imprime.

O único requisito de um objeto de job é que o campo template do pod é obrigatório.

Contagem de conclusões de job

Um job é concluído quando um número específico de pods termina com sucesso. Por padrão, um job não paralelo com um pod é concluído assim que o pod é encerrado com sucesso.

Se você tiver um job paralelo, defina uma contagem de conclusões usando o campo opcional completions. Esse campo especifica quantos pods precisam ser encerrados com sucesso antes da conclusão do job. O campo completions aceita um valor positivo diferente de zero.

Se você omitir o campo completions ou especificar o valor como zero, o sucesso de um pod sinalizará o sucesso de todos os outros.

Copie config.yaml do exemplo anterior para um arquivo chamado config-2.yaml. Em config-2.yaml, altere name para example-job-2 e adicione completions: 8 ao campo spec do Job. Isso especifica que é preciso haver oito conclusões bem-sucedidas:

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

Crie o job:

    kubectl apply -f config-2.yaml
    

O valor padrão de completions é 1. Quando completions é configurado, o campo parallelism é definido como 1 por padrão, a menos que seja configurado de outra forma. Se nenhum dos campos estiverem configurados, os valores padrão serão 1.

Como gerenciar o paralelismo

Por padrão, os pods dos jobs não são executados em paralelo. O campo opcional parallelism especifica o número máximo pretendido de pods que um job precisa executar simultaneamente em qualquer momento.

O número real de pods em execução em um estado estável poderá ser inferior ao valor de parallelism se o trabalho restante for menor que o valor do parallelism. Se completions também tiver sido definido, o número real de pods em execução em paralelo não excede a quantidade de conclusões restantes. Um job pode acelerar a criação de pods em resposta a falhas excessivas nesse processo.

Copie config.yaml do exemplo anterior para um arquivo chamado config-3.yaml. Em config-3.yaml, altere name para example-job-3 e adicione parallelism: 5 ao campo spec do Job. Isso especifica que é preciso haver cinco pods simultaneamente em execução:

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

Crie o job:

    kubectl apply -f config-3.yaml
    

O valor padrão de parallelism será 1 se o campo for omitido ou se for definido de outra forma. Se o valor for definido como 0, o job será pausado até o valor ser aumentado.

Como especificar um prazo

Por padrão, um job sempre criará novos pods se eles falharem continuamente. Se preferir que o job não realize tentativas infinitas, especifique um prazo usando o campo opcional activeDeadlineSeconds.

Um prazo dá a um job uma quantidade específica de tempo, em segundos, para concluir as tarefas antes do encerramento.

Para especificar um prazo, adicione o valor de activeDeadlineSeconds ao campo spec do job no arquivo de manifesto. Por exemplo, a configuração a seguir especifica que o job tem 100 segundos para ser concluído:

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

Se um job não for concluído com sucesso antes do prazo, ele será encerrado com o status DeadlineExceeded. Isso faz com que a criação de pods pare e que os atuais sejam excluídos.

Como especificar um seletor de pod

Se você quiser atualizar o modelo de pod, mas quiser que os pods atuais sejam executados no job atualizado, especifique um seletor manualmente.

Um job é instanciado com um campo selector. O selector gera um identificador exclusivo para os pods do job. O ID gerado não se sobrepõe a outros jobs. Geralmente, não é recomendável que você mesmo defina esse campo: definir um valor de selector que se sobrepõe a outro job pode causar problemas com pods nesse outro job. Para definir o campo por conta própria, especifique manualSelector: True no campo spec do job.

Por exemplo, execute kubectl get job my-job --output=yaml para ver a especificação do job, que contém o seletor gerado para seus pods:

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

Ao criar um novo job, defina o valor manualSelector como True e o valor job-uid do campo selector como no exemplo a seguir:

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

Os pods criados por my-new-job usam o UID do pod anterior.

Como inspecionar um job

kubectl

Para verificar o status de um job, execute o comando a seguir:

kubectl describe job my-job

Para visualizar todos os recursos do pod no cluster, incluindo pods criados pelo job que foi concluído, execute:

kubectl get pods -a

A sinalização -a define que todos os recursos do tipo especificado (neste caso, pods) serão exibidos.

Console

Para inspecionar um job depois de criá-lo com o kubectl, siga estas etapas:

  1. Acesse o menu "Cargas de trabalho" do Google Kubernetes Engine no Console do Cloud.

    Acessar o menu “Cargas de trabalho”

  2. Selecione a carga de trabalho desejada no menu.

Você pode inspecionar o job das seguintes maneiras:

  • Para ver a configuração ativa do Job, clique em YAML.
  • Para ver todos os eventos relacionados ao job, clique em Eventos.
  • Para ver o histórico de revisões do job, clique em Histórico de revisões.

Como excluir um job

Quando um job é concluído, ele deixa de criar pods. O objeto de API do job não é removido após a conclusão para você ver o status dele. Os pods criados pelo job não são excluídos, apenas encerrados. A retenção dos pods permite que você veja os registros e interaja com eles.

kubectl

Para excluir um job, execute o seguinte comando:

kubectl delete job my-job

Quando você exclui um job, todos os pods dele também são excluídos.

Para excluir um job, mas manter seus pods, especifique o sinalizador --cascade false:

kubectl delete jobs my-job --cascade false

Console

Para excluir um job, siga estas etapas:

  1. Acesse o menu "Cargas de trabalho" do Google Kubernetes Engine no Console do Cloud.

    Acessar o menu “Cargas de trabalho”

  2. No menu, selecione a carga de trabalho pretendida.

  3. Clique em Excluir.

  4. No menu da caixa de diálogo de confirmação, clique em Excluir.

A seguir