Execute uma tarefa em lote através dos Workflows

---

O Batch é um serviço totalmente gerido que lhe permite agendar, colocar em fila e executar cargas de trabalho de processamento em lote em instâncias de máquinas virtuais (VMs) do Compute Engine. Aprovisiona recursos em lote e gere a capacidade em seu nome, o que permite que as cargas de trabalho em lote sejam executadas em grande escala.

Os fluxos de trabalho permitem-lhe executar os serviços de que precisa numa ordem que define, descrita através da sintaxe dos fluxos de trabalho.

Neste tutorial, vai usar o conetor Workflows para o Batch para agendar e executar uma tarefa do Batch que executa seis tarefas em paralelo em duas VMs do Compute Engine. A utilização de processos em lote e fluxos de trabalho permite-lhe combinar as vantagens que oferecem e aprovisionar e orquestrar de forma eficiente todo o processo.

Objetivos

Neste tutorial, vai:

1. Crie um repositório do Artifact Registry para uma imagem de contentor Docker.
2. Obtenha o código para a carga de trabalho de processamento em lote do GitHub: um programa de exemplo que gera números primos em lotes de 10 000.
3. Crie a imagem do Docker para a carga de trabalho.
4. Implemente e execute um fluxo de trabalho que faça o seguinte:
   1. Cria um contentor do Cloud Storage para armazenar os resultados do gerador de números primos.
   2. Agenda e executa uma tarefa do Batch que executa o contentor Docker como seis tarefas em paralelo em duas VMs do Compute Engine.
   3. Elimina opcionalmente a tarefa em lote após a conclusão.
5. Confirme que os resultados são os esperados e que os lotes de números primos gerados são armazenados no Cloud Storage.

Pode executar a maioria dos seguintes comandos na Google Cloud consola ou executar todos os comandos através da CLI Google Cloud no terminal ou no Cloud Shell.

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

• Artifact Registry
• Batch
• Cloud Build
• Workflows

Para gerar uma estimativa de custos com base na sua utilização projetada, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação gratuita.

Antes de começar

As restrições de segurança definidas pela sua organização podem impedir a conclusão dos seguintes passos. Para informações de resolução de problemas, consulte o artigo Desenvolva aplicações num ambiente Google Cloud restrito.

Consola

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

   Nota: se não planeia manter os recursos que criar neste procedimento, crie um projeto em vez de selecionar um projeto existente. Depois de concluir estes passos, pode eliminar o projeto, removendo todos os recursos associados ao projeto.

   Aceder ao seletor de projetos

2. Certifique-se de que a faturação está ativada para o seu Google Cloud projeto. Saiba como verificar se a faturação está ativada num 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 o seu fluxo de trabalho usar para autenticação com outros Google Cloud serviços e conceda-lhe as funções adequadas:

   1. Na Google Cloud consola, aceda à página Criar conta de serviço.

      Aceda a Criar conta de serviço

   2. Selecione o seu projeto.

   3. No campo Nome da conta de serviço, introduza um nome. A Google Cloud consola preenche o campo ID da conta de serviço com base neste nome.

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

   4. Clique em Criar e continuar.

   5. Na lista Selecionar uma função, filtre as seguintes funções para conceder à conta de serviço gerida pelo utilizador que criou no passo anterior:

      • Editor de tarefas em lote: para editar tarefas em lote.
      • Escritor de registos: para escrever registos.
      • Administrador de armazenamento: para controlar os recursos do Cloud Storage.

      Para funções adicionais, clique em Adicionar outra função e adicione cada função adicional.

      Nota: o campo Função afeta os recursos aos quais a sua conta de serviço pode aceder no seu projeto. Pode revogar estas funções ou conceder funções adicionais mais tarde. Em ambientes de produção, não conceda as funções de proprietário, editor ou leitor. Em alternativa, conceda uma função predefinida ou uma função personalizada que satisfaça as suas necessidades.

   6. Clique em Continuar.

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

5. Conceda a função de utilizador da conta de serviço do IAM à conta de serviço gerida pelo utilizador criada no passo anterior. Depois de ativar a API Compute Engine, a conta de serviço predefinida é a conta de serviço predefinida do Compute Engine ([e-mail]) e a autorização é normalmente atribuída através da função roles/iam.serviceAccountUser.

   Aviso: a atribuição da função de utilizador da conta de serviço concede indiretamente ao utilizador a função associada à conta de serviço predefinida. Por exemplo, se a conta de serviço predefinida tiver a função Editor, o utilizador pode "agir como" um editor. Para minimizar o impacto destas atribuições de funções, recomendamos que configure a conta de serviço predefinida de acordo com o princípio do menor privilégio. Para mais informações, consulte o artigo Desative as concessões automáticas de funções para contas de serviço predefinidas.

   1. Na página Contas de serviço, clique no endereço de email da conta de serviço predefinida ([e-mail]).

   2. Clique no separador Autorizações.

   3. Clique no botão Conceder acesso.

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

   5. Na lista Selecionar uma função, selecione a função Contas de serviço > Utilizador da conta de serviço.

   6. Clique em Guardar.

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. Certifique-se de que a faturação está ativada para o seu Google Cloud projeto. Saiba como verificar se a faturação está ativada num 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 o seu fluxo de trabalho usar para autenticação com outros Google Cloud serviços e conceda-lhe 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 funções à conta de serviço gerida pelo utilizador que criou no passo anterior. Execute o seguinte comando uma vez para cada uma das seguintes funções do IAM:

      • roles/batch.jobsEditor: para editar tarefas em lote.
      • roles/logging.logWriter: para escrever registos.
      • roles/storage.admin: para controlar os 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 o seguinte:

      • PROJECT_ID: o ID do projeto onde criou a conta de serviço
      • ROLE: a função a conceder
      Nota: a flag --role afeta os recursos aos quais a sua conta de serviço pode aceder no seu projeto. Pode revogar estas funções ou conceder funções adicionais mais tarde. Em ambientes de produção, não conceda as funções de proprietário, editor ou leitor. Em alternativa, conceda uma função predefinida ou uma função personalizada que satisfaça as suas necessidades.

5. Conceda a função de utilizador da conta de serviço do IAM à conta de serviço gerida pelo utilizador que criou no passo anterior. Depois de ativar a API Compute Engine, a conta de serviço predefinida é a conta de serviço predefinida do Compute Engine ([e-mail]) e a autorização é normalmente atribuída através da função roles/iam.serviceAccountUser.

   Aviso: a atribuição da função de utilizador da conta de serviço concede indiretamente ao utilizador a função associada à conta de serviço predefinida. Por exemplo, se a conta de serviço predefinida tiver a função Editor, o utilizador pode "agir como" um editor. Para minimizar o impacto destas atribuições de funções, recomendamos que configure a conta de serviço predefinida de acordo com o princípio do menor privilégio. Para mais informações, consulte o artigo Desative as concessões automáticas de funções para contas de serviço predefinidas.

   PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format='value(projectNumber)')
   gcloud iam service-accounts add-iam-policy-binding \
     $[e-mail] \
     --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 sua imagem de contentor Docker.

Consola

1. Na Google Cloud consola, aceda à página Repositórios.

   Aceda a Repositórios

2. Clique em Criar repositório.

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

4. Em Formato, escolha Docker.

5. Para Tipo de localização, escolha Região.

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

7. Clique em Criar.

gcloud

Execute o seguinte comando:

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

Criou um repositório do Artifact Registry denominado containers na região us-central1. Para mais informações sobre as regiões suportadas, consulte o artigo Localizações do Artifact Registry.

Obtenha os exemplos de código

Google Cloud armazena o código fonte da aplicação para este tutorial no GitHub. Pode clonar esse repositório ou transferir os exemplos.

1. Clone o repositório da app de exemplo para a sua máquina local:

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

   Em alternativa, pode transferir os exemplos no ficheiro main.zip e extraí-los.

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

   cd batch-samples/primegen
   

Agora, tem o código-fonte da aplicação no seu ambiente de desenvolvimento.

Crie a imagem Docker com o Cloud Build

O Dockerfile contém as informações necessárias para criar uma imagem do Docker com o Cloud Build. Execute o seguinte comando para o criar:

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

Substitua PROJECT_ID pelo seu Google Cloud ID do projeto.

Quando a compilação estiver concluída, deverá ver um resultado semelhante ao seguinte:

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, criou uma imagem Docker denominada primegen-service e carregou a imagem para um repositório do Artifact Registry denominado containers.

Implemente um fluxo de trabalho que agende e execute uma tarefa em lote

O fluxo de trabalho seguinte agenda e executa uma tarefa em lote que executa um contentor 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 num contentor do Cloud Storage.

Consola

1. Na Google Cloud consola, aceda à página Fluxos de trabalho.

   Aceda a Fluxos de trabalho

2. Clique em Criar.

3. Introduza 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 criou anteriormente.

6. Clicar em Seguinte.

7. No editor de fluxos de trabalho, introduza a seguinte definição para o seu fluxo de trabalho:

   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 Implementar.

gcloud

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

   touch batch-workflow.JSON_OR_YAML

   Substitua JSON_OR_YAML por yaml ou json, consoante o formato do seu fluxo de trabalho.

2. Num editor de texto, copie o seguinte fluxo de trabalho para o ficheiro 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. Implemente o fluxo de trabalho introduzindo 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 criou anteriormente.

Execute o fluxo de trabalho

A execução de um fluxo de trabalho executa a definição do fluxo de trabalho atual associada ao fluxo de trabalho.

Consola

1. Na Google Cloud consola, aceda à página Fluxos de trabalho.

   Aceda a Fluxos de trabalho

2. Na página Fluxos de trabalho, clique no fluxo de trabalho batch-workflow para aceder à respetiva página de detalhes.

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

4. Clique novamente em Executar.

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

   Nota: se encontrar um IAM permission denied for service accounterro no passo createBucket, é provável que se deva a um atraso na propagação. Aguarde um ou dois minutos e, em seguida, tente executar o fluxo de trabalho novamente.

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

   Os resultados devem ter um aspeto semelhante ao seguinte:

   {
     "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 deve demorar alguns minutos.

   Nota: se encontrar um IAM permission denied for service accounterro no passo createBucket, é provável que se deva a um atraso na propagação. Aguarde um ou dois minutos e, em seguida, tente executar o fluxo de trabalho novamente.

2. Pode verificar o estado de uma execução de longa duração.

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

   gcloud workflows executions describe-last

   Os resultados devem ser semelhantes aos seguintes:

   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
   

Indique os objetos no contentor de saída

Pode confirmar que os resultados são os esperados listando os objetos no seu contentor de saída do Cloud Storage.

Consola

1. Na Google Cloud consola, aceda à página Recipientes do Cloud Storage.
   

   Aceda aos contentores

2. Na lista de contentores, clique no nome do contentor cujo conteúdo quer ver.

   Os resultados devem ser semelhantes aos seguintes, com seis ficheiros no total e cada ficha a representar 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. Obtenha o nome do contentor de saída:

   gcloud storage ls

   O resultado é semelhante ao seguinte:

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

2. Liste os objetos no seu contentor de saída:

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

   Substitua TIMESTAMP pela data/hora devolvida pelo comando anterior.

   A saída deve ser semelhante à seguinte, com seis ficheiros no total e cada um a listar 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 criou um novo projeto para este tutorial, elimine o projeto. Se usou um projeto existente e quer mantê-lo sem as alterações adicionadas neste tutorial, elimine os recursos criados para o tutorial.

Elimine o projeto

A forma mais fácil de eliminar a faturação é eliminar o projeto que criou para o tutorial.

Para eliminar o projeto:

Atenção: a eliminação de um projeto tem os seguintes efeitos:

• Tudo no projeto é eliminado. Se usou um projeto existente para as tarefas neste documento, quando o elimina, também elimina qualquer outro trabalho que tenha feito no projeto.
• Os IDs dos projetos personalizados são perdidos. Quando criou este projeto, pode ter criado um ID do projeto personalizado que quer usar no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, elimine os recursos selecionados no projeto em vez de eliminar o projeto inteiro.

Se planeia explorar várias arquiteturas, tutoriais ou inícios rápidos, a reutilização de projetos pode ajudar a evitar exceder os limites de quota de projetos.

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.

Elimine os recursos criados neste tutorial

1. Elimine a tarefa em lote:

   1. Primeiro, obtenha o nome da tarefa:

      gcloud batch jobs list --location=us-central1

      O resultado deve ser semelhante ao seguinte:

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

      Onde job-primegen-TIMESTAMP é o nome da tarefa em lote.

   2. Elimine a tarefa:

      gcloud batch jobs delete BATCH_JOB_NAME --location us-central1

2. Elimine o fluxo de trabalho:

   gcloud workflows delete WORKFLOW_NAME

3. Elimine o repositório de contentores:

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

4. O Cloud Build usa o Cloud Storage para armazenar recursos de compilação. Para eliminar um contentor do Cloud Storage, consulte o artigo Eliminar contentores.

O que se segue?

• Saiba mais sobre o Batch.
• Saiba mais sobre os fluxos de trabalho.
• Saiba mais sobre os conetores do Workflows.