Executar um job em lote usando o Workflows

O Batch é um serviço totalmente gerenciado que permite programar, enfileirar e executar cargas de trabalho de processamento em lote em instâncias de máquina virtual (VM) do Compute Engine. O Batch provisiona recursos e gerencia a capacidade em seu nome, permitindo que suas cargas de trabalho em lote sejam executadas em escala.

Com o Workflows, é possível executar os serviços necessários na ordem definida por você, descrita usando a sintaxe do Workflows.

Neste tutorial, você vai usar o conector do Workflows para o Batch a fim de programar e executar um job do Batch que executa seis tarefas em paralelo em duas VMs do Compute Engine. Usar o Batch e Workflows permite combinar as vantagens que eles oferecem e provisionar e orquestrar todo o processo de maneira eficiente.

Objetivos

Neste tutorial, você aprenderá a:

  1. Crie um repositório do Artifact Registry para uma imagem de contêiner do Docker.
  2. Acesse o código da carga de trabalho de processamento em lote no GitHub: um programa de amostra que gera números primos em lotes de 10.000.
  3. Crie a imagem Docker para a carga de trabalho.
  4. Implante e execute um fluxo de trabalho que faça o seguinte:
    1. Cria um bucket do Cloud Storage para armazenar os resultados do gerador de números primos.
    2. Programa e executa um job do Batch que executa o contêiner do Docker como seis tarefas em paralelo em duas VMs do Compute Engine.
    3. Exclui opcionalmente o job do Batch após a conclusão.
  5. Confirme se os resultados estão como esperado e se os lotes de números primos gerados estão armazenados no Cloud Storage.

É possível executar a maioria dos comandos a seguir no console Google Cloud ou todos usando a Google Cloud CLI no terminal ou no Cloud Shell.

Custos

Neste documento, você vai usar os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços.

Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Antes de começar

As restrições de segurança definidas pela sua organização podem impedir que você conclua as etapas a seguir. Para informações sobre solução de problemas, consulte Desenvolver aplicativos em um ambiente restrito de Google Cloud .

Console

  1. No console do Google Cloud , na página do seletor de projetos, selecione ou crie um Google Cloud projeto.

    Acessar o seletor de projetos

  2. Verifique se o faturamento foi ativado para o projeto Google Cloud . Saiba como verificar se o faturamento está ativado em um projeto.

  3. Ative as APIs Artifact Registry, Batch, Cloud Build, Compute Engine, Workflow Executions e Workflows.

    Ative as APIs

  4. Crie uma conta de serviço para que seu fluxo de trabalho use na autenticação com outros serviços do Google Cloud e conceda as funções adequadas:

    1. No console Google Cloud , acesse a página Criar conta de serviço.

      Acesse "Criar conta de serviço"

    2. Selecione o projeto.

    3. No campo Nome da conta de serviço, insira um nome. O Google Cloud console preenche o campo ID da conta de serviço com base nesse nome.

      No campo Descrição da conta de serviço, insira uma descrição. Por exemplo, Service account for tutorial.

    4. Clique em Criar e continuar.

    5. Na lista Selecionar um papel, filtre os seguintes papéis para conceder à conta de serviço gerenciado pelo usuário criada na etapa anterior:

      • Editor de jobs em lote: para editar jobs em lote.
      • Gravador de registros: para gravar registros.
      • Administrador do Storage: para controlar recursos do Cloud Storage.

      Para papéis adicionais, clique em Adicionar outro papel e adicione cada papel adicional.

    6. Clique em Continuar.

    7. Para concluir a criação da conta, clique em Concluído.

  5. Conceda o papel de usuário da conta de serviço do IAM na conta de serviço padrão à conta de serviço gerenciado pelo usuário criada na etapa anterior. Depois que você ativa a API Compute Engine, a conta de serviço padrão é a conta de serviço padrão do Compute Engine (PROJECT_NUMBER-compute@developer.gserviceaccount.com), e a permissão geralmente é atribuída pela função roles/iam.serviceAccountUser.

    1. Na página Contas de serviço, clique no endereço de e-mail da conta de serviço padrão (PROJECT_NUMBER-compute@developer.gserviceaccount.com).

    2. Clique na guia Permissões.

    3. Clique no botão Conceder acesso.

    4. Para adicionar um novo principal, insira o endereço de e-mail da sua conta de serviço (SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com).

    5. Na lista Selecionar um papel, escolha o papel Contas de serviço > Usuário da conta de serviço.

    6. Clique em Salvar.

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Verifique se o faturamento foi ativado para o projeto Google Cloud . Saiba como verificar se o faturamento está ativado em um projeto.

  3. Ative as APIs Artifact Registry, Batch, Cloud Build, Compute Engine Workflow Executions e Workflows.

    gcloud services enable artifactregistry.googleapis.com \
  batch.googleapis.com \
  cloudbuild.googleapis.com \
  compute.googleapis.com \
  workflowexecutions.googleapis.com \
  workflows.googleapis.com

  4. Crie uma conta de serviço para que seu fluxo de trabalho use na autenticação com outros serviços do Google Cloud e conceda as funções adequadas.

    1. Crie a conta de serviço:

      gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

      Substitua SERVICE_ACCOUNT_NAME por um nome para a conta de serviço.

    2. Conceda papéis à conta de serviço gerenciado pelo usuário criada na etapa anterior. Execute uma vez o seguinte comando para cada um dos seguintes papéis do IAM:

      • roles/batch.jobsEditor: para editar jobs em lote.
      • roles/logging.logWriter: para gravar registros.
      • roles/storage.admin: para controlar recursos do Cloud Storage.
      gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=ROLE

      Substitua:

      • PROJECT_ID: o ID do projeto em que você criou a conta de serviço
      • ROLE: o papel a ser concedido

  5. Conceda o papel de usuário da conta de serviço do IAM na conta de serviço padrão à conta de serviço gerenciado pelo usuário criada na etapa anterior. Depois que você ativa a API Compute Engine, a conta de serviço padrão é a conta de serviço padrão do Compute Engine (PROJECT_NUMBER-compute@developer.gserviceaccount.com), e a permissão geralmente é atribuída pela função roles/iam.serviceAccountUser.

    PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format='value(projectNumber)')
gcloud iam service-accounts add-iam-policy-binding \
  $PROJECT_NUMBER-compute@developer.gserviceaccount.com \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/iam.serviceAccountUser

Crie um repositório do Artifact Registry

Crie um repositório para armazenar a imagem do contêiner do Docker.

Console

  1. No console Google Cloud , acesse a página Repositórios.

    Acessar repositórios

  2. Clique em Criar repositório.

  3. Insira containers como o nome do repositório.

  4. Em Formato, escolha Docker.

  5. Em Tipo de local, escolha Região.

  6. Na lista Região, selecione us-central1.

  7. Clique em Criar.

gcloud

Execute este comando:

  gcloud artifacts repositories create containers \
    --repository-format=docker \
    --location=us-central1

Você criou um repositório do Artifact Registry chamado containers na região us-central1. Para mais informações sobre regiões compatíveis, consulte Locais do Artifact Registry.

Acessar os exemplos de código

OGoogle Cloud armazena o código-fonte do aplicativo deste tutorial no GitHub. Você pode clonar esse repositório ou fazer o download dos exemplos.

  1. Clone o repositório do app de amostra na máquina local:

    git clone https://github.com/GoogleCloudPlatform/batch-samples.git

    Outra opção é fazer o download das amostras no arquivo main.zip e extraí-las.

  2. Acesse o diretório que contém o exemplo de código:

    cd batch-samples/primegen

Agora você tem o código-fonte do aplicativo no ambiente de desenvolvimento.

Criar a imagem do Docker usando o Cloud Build

O Dockerfile contém as informações necessárias para criar uma imagem do Docker usando o Cloud Build. Execute o comando a seguir para criar o binário:

gcloud builds submit \
  -t us-central1-docker.pkg.dev/PROJECT_ID/containers/primegen-service:v1 PrimeGenService/

Substitua PROJECT_ID pelo ID do projeto Google Cloud.

Quando a build for concluída, você verá uma resposta semelhante a esta:

DONE
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ID: a54818cc-5d14-467b-bfda-5fc9590af68c
CREATE_TIME: 2022-07-29T01:48:50+00:00
DURATION: 48S
SOURCE: gs://project-name_cloudbuild/source/1659059329.705219-17aee3a424a94679937a7200fab15bcf.tgz
IMAGES: us-central1-docker.pkg.dev/project-name/containers/primegen-service:v1
STATUS: SUCCESS

Usando um Dockerfile, você criou uma imagem do Docker chamada primegen-service e a enviou para um repositório do Artifact Registry chamado containers.

Implantar um fluxo de trabalho que programa e executa um job do Batch

O fluxo de trabalho a seguir programa e executa um job do Batch que executa um contêiner do Docker como seis tarefas em paralelo em duas VMs do Compute Engine. O resultado é a geração de seis lotes de números primos, armazenados em um bucket do Cloud Storage.

Console

  1. No console Google Cloud , acesse a página Fluxos de trabalho.

    Acessar fluxos de trabalho

  2. Clique em Criar.

  3. Insira um nome para o novo fluxo de trabalho, como batch-workflow.

  4. Na lista Região, selecione us-central1.

  5. Selecione a conta de serviço que você criou.

  6. Clique em Próxima.

  7. No editor de fluxo de trabalho, insira a seguinte definição:

    YAML

    main:
  params: [args]
  steps:
    - init:
        assign:
          - projectId: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
          - region: "us-central1"
          - imageUri: ${region + "-docker.pkg.dev/" + projectId + "/containers/primegen-service:v1"}
          - jobId: ${"job-primegen-" + string(int(sys.now()))}
          - bucket: ${projectId + "-" + jobId}
    - createBucket:
        call: googleapis.storage.v1.buckets.insert
        args:
          query:
            project: ${projectId}
          body:
            name: ${bucket}
    - logCreateBucket:
        call: sys.log
        args:
          data: ${"Created bucket " + bucket}
    - logCreateBatchJob:
        call: sys.log
        args:
          data: ${"Creating and running the batch job " + jobId}
    - createAndRunBatchJob:
        call: googleapis.batch.v1.projects.locations.jobs.create
        args:
            parent: ${"projects/" + projectId + "/locations/" + region}
            jobId: ${jobId}
            body:
              taskGroups:
                taskSpec:
                  runnables:
                    - container:
                        imageUri: ${imageUri}
                      environment:
                        variables:
                          BUCKET: ${bucket}
                # Run 6 tasks on 2 VMs
                taskCount: 6
                parallelism: 2
              logsPolicy:
                destination: CLOUD_LOGGING
        result: createAndRunBatchJobResponse
    # You can delete the batch job or keep it for debugging
    - logDeleteBatchJob:
        call: sys.log
        args:
          data: ${"Deleting the batch job " + jobId}
    - deleteBatchJob:
        call: googleapis.batch.v1.projects.locations.jobs.delete
        args:
            name: ${"projects/" + projectId + "/locations/" + region + "/jobs/" + jobId}
        result: deleteResult
    - returnResult:
        return:
          jobId: ${jobId}
          bucket: ${bucket}

    JSON

    {
  "main": {
    "params": [
      "args"
    ],
    "steps": [
      {
        "init": {
          "assign": [
            {
              "projectId": "${sys.get_env(\"GOOGLE_CLOUD_PROJECT_ID\")}"
            },
            {
              "region": "us-central1"
            },
            {
              "imageUri": "${region + \"-docker.pkg.dev/\" + projectId + \"/containers/primegen-service:v1\"}"
            },
            {
              "jobId": "${\"job-primegen-\" + string(int(sys.now()))}"
            },
            {
              "bucket": "${projectId + \"-\" + jobId}"
            }
          ]
        }
      },
      {
        "createBucket": {
          "call": "googleapis.storage.v1.buckets.insert",
          "args": {
            "query": {
              "project": "${projectId}"
            },
            "body": {
              "name": "${bucket}"
            }
          }
        }
      },
      {
        "logCreateBucket": {
          "call": "sys.log",
          "args": {
            "data": "${\"Created bucket \" + bucket}"
          }
        }
      },
      {
        "logCreateBatchJob": {
          "call": "sys.log",
          "args": {
            "data": "${\"Creating and running the batch job \" + jobId}"
          }
        }
      },
      {
        "createAndRunBatchJob": {
          "call": "googleapis.batch.v1.projects.locations.jobs.create",
          "args": {
            "parent": "${\"projects/\" + projectId + \"/locations/\" + region}",
            "jobId": "${jobId}",
            "body": {
              "taskGroups": {
                "taskSpec": {
                  "runnables": [
                    {
                      "container": {
                        "imageUri": "${imageUri}"
                      },
                      "environment": {
                        "variables": {
                          "BUCKET": "${bucket}"
                        }
                      }
                    }
                  ]
                },
                "taskCount": 6,
                "parallelism": 2
              },
              "logsPolicy": {
                "destination": "CLOUD_LOGGING"
              }
            }
          },
          "result": "createAndRunBatchJobResponse"
        }
      },
      {
        "logDeleteBatchJob": {
          "call": "sys.log",
          "args": {
            "data": "${\"Deleting the batch job \" + jobId}"
          }
        }
      },
      {
        "deleteBatchJob": {
          "call": "googleapis.batch.v1.projects.locations.jobs.delete",
          "args": {
            "name": "${\"projects/\" + projectId + \"/locations/\" + region + \"/jobs/\" + jobId}"
          },
          "result": "deleteResult"
        }
      },
      {
        "returnResult": {
          "return": {
            "jobId": "${jobId}",
            "bucket": "${bucket}"
          }
        }
      }
    ]
  }
}

  8. Clique em Implantar.

gcloud

  1. Crie um arquivo de código-fonte para o fluxo de trabalho:

    touch batch-workflow.JSON_OR_YAML

    Substitua JSON_OR_YAML por yaml ou json, dependendo do formato do fluxo de trabalho.

  2. Em um editor de texto, copie o seguinte fluxo de trabalho para o arquivo de código-fonte:

    YAML

    main:
  params: [args]
  steps:
    - init:
        assign:
          - projectId: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
          - region: "us-central1"
          - imageUri: ${region + "-docker.pkg.dev/" + projectId + "/containers/primegen-service:v1"}
          - jobId: ${"job-primegen-" + string(int(sys.now()))}
          - bucket: ${projectId + "-" + jobId}
    - createBucket:
        call: googleapis.storage.v1.buckets.insert
        args:
          query:
            project: ${projectId}
          body:
            name: ${bucket}
    - logCreateBucket:
        call: sys.log
        args:
          data: ${"Created bucket " + bucket}
    - logCreateBatchJob:
        call: sys.log
        args:
          data: ${"Creating and running the batch job " + jobId}
    - createAndRunBatchJob:
        call: googleapis.batch.v1.projects.locations.jobs.create
        args:
            parent: ${"projects/" + projectId + "/locations/" + region}
            jobId: ${jobId}
            body:
              taskGroups:
                taskSpec:
                  runnables:
                    - container:
                        imageUri: ${imageUri}
                      environment:
                        variables:
                          BUCKET: ${bucket}
                # Run 6 tasks on 2 VMs
                taskCount: 6
                parallelism: 2
              logsPolicy:
                destination: CLOUD_LOGGING
        result: createAndRunBatchJobResponse
    # You can delete the batch job or keep it for debugging
    - logDeleteBatchJob:
        call: sys.log
        args:
          data: ${"Deleting the batch job " + jobId}
    - deleteBatchJob:
        call: googleapis.batch.v1.projects.locations.jobs.delete
        args:
            name: ${"projects/" + projectId + "/locations/" + region + "/jobs/" + jobId}
        result: deleteResult
    - returnResult:
        return:
          jobId: ${jobId}
          bucket: ${bucket}

    JSON

    {
  "main": {
    "params": [
      "args"
    ],
    "steps": [
      {
        "init": {
          "assign": [
            {
              "projectId": "${sys.get_env(\"GOOGLE_CLOUD_PROJECT_ID\")}"
            },
            {
              "region": "us-central1"
            },
            {
              "imageUri": "${region + \"-docker.pkg.dev/\" + projectId + \"/containers/primegen-service:v1\"}"
            },
            {
              "jobId": "${\"job-primegen-\" + string(int(sys.now()))}"
            },
            {
              "bucket": "${projectId + \"-\" + jobId}"
            }
          ]
        }
      },
      {
        "createBucket": {
          "call": "googleapis.storage.v1.buckets.insert",
          "args": {
            "query": {
              "project": "${projectId}"
            },
            "body": {
              "name": "${bucket}"
            }
          }
        }
      },
      {
        "logCreateBucket": {
          "call": "sys.log",
          "args": {
            "data": "${\"Created bucket \" + bucket}"
          }
        }
      },
      {
        "logCreateBatchJob": {
          "call": "sys.log",
          "args": {
            "data": "${\"Creating and running the batch job \" + jobId}"
          }
        }
      },
      {
        "createAndRunBatchJob": {
          "call": "googleapis.batch.v1.projects.locations.jobs.create",
          "args": {
            "parent": "${\"projects/\" + projectId + \"/locations/\" + region}",
            "jobId": "${jobId}",
            "body": {
              "taskGroups": {
                "taskSpec": {
                  "runnables": [
                    {
                      "container": {
                        "imageUri": "${imageUri}"
                      },
                      "environment": {
                        "variables": {
                          "BUCKET": "${bucket}"
                        }
                      }
                    }
                  ]
                },
                "taskCount": 6,
                "parallelism": 2
              },
              "logsPolicy": {
                "destination": "CLOUD_LOGGING"
              }
            }
          },
          "result": "createAndRunBatchJobResponse"
        }
      },
      {
        "logDeleteBatchJob": {
          "call": "sys.log",
          "args": {
            "data": "${\"Deleting the batch job \" + jobId}"
          }
        }
      },
      {
        "deleteBatchJob": {
          "call": "googleapis.batch.v1.projects.locations.jobs.delete",
          "args": {
            "name": "${\"projects/\" + projectId + \"/locations/\" + region + \"/jobs/\" + jobId}"
          },
          "result": "deleteResult"
        }
      },
      {
        "returnResult": {
          "return": {
            "jobId": "${jobId}",
            "bucket": "${bucket}"
          }
        }
      }
    ]
  }
}

  3. Implante o fluxo de trabalho digitando o seguinte comando:

    gcloud workflows deploy batch-workflow \
  --source=batch-workflow.yaml \
  --location=us-central1 \
  --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

    Substitua SERVICE_ACCOUNT_NAME pelo nome da conta de serviço que você criou anteriormente.

Executar o fluxo de trabalho

Quando um fluxo de trabalho é executado, a definição atual associada a ele também é.

Console

  1. No console Google Cloud , acesse a página Fluxos de trabalho.

    Acessar fluxos de trabalho

  2. Na página Fluxos de trabalho, clique no fluxo de trabalho batch-workflow para acessar a página de detalhes dele.

  3. Na página Detalhes do fluxo de trabalho, clique em Executar.

  4. Clique em Executar novamente.

    A execução do fluxo de trabalho leva alguns minutos.

  5. Veja os resultados do fluxo de trabalho no painel Saída.

    A resposta deve ficar assim:

    {
  "bucket": "project-name-job-primegen-TIMESTAMP",
  "jobId": "job-primegen-TIMESTAMP"
}

gcloud

  1. Execute o fluxo de trabalho:

    gcloud workflows run batch-workflow \
  --location=us-central1

    A execução do fluxo de trabalho leva alguns minutos.

  2. É possível verificar o status de uma execução de longa duração.

  3. Para ver o status da última execução concluída, execute o seguinte comando:

    gcloud workflows executions describe-last

    Os resultados serão semelhantes a estes:

    name: projects/PROJECT_NUMBER/locations/us-central1/workflows/batch-workflow/executions/EXECUTION_ID
result: '{"bucket":"project-name-job-primegen-TIMESTAMP","jobId":"job-primegen-TIMESTAMP"}'
startTime: '2022-07-29T16:08:39.725306421Z'
state: SUCCEEDED
status:
  currentSteps:
  - routine: main
    step: returnResult
workflowRevisionId: 000001-9ba

Listar os objetos no bucket de saída

É possível confirmar se os resultados estão conforme o esperado listando os objetos no bucket de saída do Cloud Storage.

Console

  1. No console Google Cloud , acesse a página Buckets do Cloud Storage.

    Acessar buckets

  2. Na lista de buckets, clique no nome do bucket cujo conteúdo você quer visualizar.

    Os resultados serão semelhantes a este, com seis arquivos no total, e cada um listando um lote de 10.000 números primos:

    primes-1-10000.txt
primes-10001-20000.txt
primes-20001-30000.txt
primes-30001-40000.txt
primes-40001-50000.txt
primes-50001-60000.txt

gcloud

  1. Recupere o nome do bucket de saída:

    gcloud storage ls

    A saída será assim: 

    gs://PROJECT_ID-job-primegen-TIMESTAMP/

  2. Liste os objetos no bucket de saída.

    gcloud storage ls gs://PROJECT_ID-job-primegen-TIMESTAMP/** --recursive

    Substitua TIMESTAMP pelo carimbo de data/hora retornado pelo comando anterior.

    A saída será semelhante a esta, com seis arquivos no total, cada um listando um lote de 10.000 números primos:

    gs://project-name-job-primegen-TIMESTAMP/primes-1-10000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-10001-20000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-20001-30000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-30001-40000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-40001-50000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-50001-60000.txt

Limpar

Se você criou um novo projeto para este tutorial, exclua o projeto. Se você usou um projeto atual e quer mantê-lo sem as alterações incluídas neste tutorial, exclua os recursos criados para o tutorial.

Exclua o projeto

O jeito mais fácil de evitar cobranças é excluindo o projeto que você criou para o tutorial.

Para excluir o projeto:

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Excluir recursos criados neste tutorial

  1. Exclua o job em lote:

    1. Primeiro, recupere o nome do job:

      gcloud batch jobs list --location=us-central1

      A saída será semelhante a esta:

      NAME: projects/project-name/locations/us-central1/jobs/job-primegen-TIMESTAMP
STATE: SUCCEEDED

      Em que job-primegen-TIMESTAMP é o nome do job do Batch.

    2. Exclua o job:

      gcloud batch jobs delete BATCH_JOB_NAME --location us-central1

  2. Exclua o fluxo de trabalho:

    gcloud workflows delete WORKFLOW_NAME

  3. Exclua o repositório de contêineres:

    gcloud artifacts repositories delete REPOSITORY_NAME --location=us-central1

  4. O Cloud Build usa o Cloud Storage para armazenar recursos de build. Para excluir um bucket do Cloud Storage, consulte Excluir buckets.

A seguir