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 cargas de trabalho em lote sejam executadas em escala.

O Workflows permite que você execute os serviços necessários na ordem que você define e descrita usando a sintaxe de fluxos de trabalho.

Neste tutorial, você usará o Conector de fluxos de trabalho para Lote para programar e executar um job em lote que executa seis tarefas em paralelo em duas VMs do Compute Engine. Usar o Batch e o Workflows permite combinar as vantagens que eles oferecem e provisionar e orquestrar com eficiência todo o processo.

Objetivos

Neste tutorial, você aprenderá a:

Criar um repositório do Artifact Registry para uma imagem de contêiner do Docker.
Receba o código da carga de trabalho de processamento em lote do GitHub: um programa de amostra que gera números primos em lotes de 10.000.
Criar a imagem do Docker para a carga de trabalho.
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 em lote que executa o contêiner do Docker como seis tarefas em paralelo em duas VMs do Compute Engine.
3. Opcionalmente, exclui o job do Batch depois que ele é concluído.
Confirme se os resultados estão conforme o 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 do Google Cloud ou todos usando a Google Cloud CLI no seu terminal ou no Cloud Shell.

Custos

Neste documento, você 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 do Google Cloud.

Console

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

Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

Acessar o seletor de projetos
Verifique se a cobrança está ativada para o projeto do Google Cloud. Saiba como verificar se o faturamento está ativado em um projeto.
Ative as APIs Artifact Registry, Batch, Cloud Build, Compute Engine, execuções de fluxo de trabalho e Workflows.

Ative as APIs
Crie uma conta de serviço para seu fluxo de trabalho usar para autenticação com outros serviços do Google Cloud e conceda os papéis apropriados:
1. No Console do 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 Console do Google Cloud 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 de armazenamento: para controlar recursos do Cloud Storage.
  Para papéis adicionais, clique em Adicionar outro papel e adicione os papéis adicionais.
  
  Observação: o campo Papel afeta quais recursos sua conta de serviço pode acessar no projeto. É possível revogar esses papéis ou conceder outros posteriormente. Em ambientes de produção, não conceda os papéis de proprietário, editor ou leitor. Em vez disso, conceda um papel predefinido ou personalizado que atenda às suas necessidades.
6. Clique em Continuar.
7. Para concluir a criação da conta, clique em Concluído.
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ê ativar a API Compute Engine, a conta de serviço padrão será a conta de serviço padrão do Compute Engine (PROJECT_NUMBER-compute@developer.gserviceaccount.com), e a permissão normalmente é atribuída por meio do papel roles/iam.serviceAccountUser.

Cuidado: atribuir o papel de usuário da conta de serviço concede indiretamente o papel associado à conta de serviço padrão ao usuário. Por exemplo, se a conta de serviço padrão tiver o papel de Editor, o usuário poderá "atuar como". Para minimizar o impacto dessas atribuições de papéis, recomendamos configurar a conta de serviço padrão de acordo com o princípio de privilégio mínimo. Para mais informações, consulte Desativar concessões automáticas de papéis a contas de serviço padrão.
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

No Console do Google Cloud, ative o Cloud Shell.

Ativar o Cloud Shell

Na parte inferior do Console do Google Cloud, uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.
Verifique se a cobrança está ativada para o projeto do Google Cloud. Saiba como verificar se o faturamento está ativado em um projeto.

Ative as APIs Artifact Registry, Batch, Cloud Build, Execuções de fluxo de trabalho do Compute Engine e Workflows.

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

Crie uma conta de serviço para seu fluxo de trabalho usar para autenticação com outros serviços do Google Cloud e conceda os papéis apropriados.
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 que você criou na etapa anterior. Execute o comando a seguir uma vez 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 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:
  - PROJECT_ID: o ID do projeto em que você criou a conta de serviço.
  - ROLE: o papel a ser concedido
  Observação: a sinalização --role afeta quais recursos sua conta de serviço pode acessar no projeto. É possível revogar esses papéis ou conceder outros posteriormente. Em ambientes de produção, não conceda os papéis de proprietário, editor ou leitor. Em vez disso, conceda um papel predefinido ou personalizado que atenda às suas necessidades.
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 que você criou na etapa anterior. Depois de ativar a API Compute Engine, a conta de serviço padrão será a conta de serviço padrão do Compute Engine (PROJECT_NUMBER-compute@developer.gserviceaccount.com), e a permissão normalmente é atribuída por meio do papel roles/iam.serviceAccountUser.

Cuidado: atribuir o papel de usuário da conta de serviço concede indiretamente o papel associado à conta de serviço padrão ao usuário. Por exemplo, se a conta de serviço padrão tiver o papel de Editor, o usuário poderá "atuar como". Para minimizar o impacto dessas atribuições de papéis, recomendamos configurar a conta de serviço padrão de acordo com o princípio de privilégio mínimo. Para mais informações, consulte Desativar concessões automáticas de papéis a contas de serviço padrão.
```
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

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

Acessar repositórios
Clique em Criar repositório.
Insira containers como o nome do repositório.
Em Formato, escolha Docker.
Em Tipo de local, escolha Região.
Na lista Região, selecione us-central1.
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.

Conferir os exemplos de código

O Google Cloud armazena o código-fonte do aplicativo para este tutorial no GitHub. É possível clonar esse repositório ou fazer o download das amostras.

Clone o repositório do app de amostra na máquina local:
```
git clone https://github.com/GoogleCloudPlatform/batch-samples.git
```
Se preferir, faça o download dos exemplos no arquivo main.zip e extraia-o.
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 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 seguinte comando para criá-lo:

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

Substitua o PROJECT_ID pelo ID do projeto do Google Cloud.

Quando o build estiver concluído, 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 em lote

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

No console do Google Cloud, abra a página Workflows.

Acessar fluxos de trabalho
Clique em Criar.
Insira um nome para o novo fluxo de trabalho, como batch-workflow.
Na lista Região, selecione us-central1.
Selecione a conta de serviço que você criou anteriormente.
Clique em Próxima.

No editor de fluxo de trabalho, insira a seguinte definição para 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}"
          }
        }
      }
    ]
  }
}

Selecione Implantar.

gcloud

Crie um arquivo de código-fonte para seu fluxo de trabalho:
```
touch batch-workflow.JSON_OR_YAML
```
Substitua JSON_OR_YAML por yaml ou json, dependendo do formato do seu fluxo de trabalho.

Em um editor de texto, copie o fluxo de trabalho a seguir para seu 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}"
          }
        }
      }
    ]
  }
}

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 criada anteriormente.

Executar o fluxo de trabalho

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

Console

No console do Google Cloud, abra a página Workflows.

Acessar fluxos de trabalho
Na página Fluxos de trabalho, clique em batch-workflow para acessar a página de detalhes.
Na página Detalhes do fluxo de trabalho, clique em Executar.
Clique em Executar novamente.

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

Observação: se você encontrar um erro IAM permission denied for service account na etapa createBucket, é provável que haja um atraso de propagação. Aguarde um ou dois minutos e tente executar o fluxo de trabalho novamente.

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

Execute o fluxo de trabalho:
```
gcloud workflows run batch-workflow \
  --location=us-central1
```
A execução do fluxo de trabalho deve levar alguns minutos.

Observação: se você encontrar um erro IAM permission denied for service account na etapa createBucket, é provável que haja um atraso de propagação. Aguarde um ou dois minutos e tente executar o fluxo de trabalho novamente.
É possível verificar o status de uma execução de longa duração.

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

gcloud workflows executions describe-last

Os resultados serão semelhantes aos mostrados a seguir:

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

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

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

Os resultados serão semelhantes aos mostrados a seguir, com seis arquivos no total, 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

Recupere o nome do bucket de saída:
```
gsutil ls
```
O resultado será assim:
```
gs://PROJECT_ID-job-primegen-TIMESTAMP/
```

Liste os objetos no bucket de saída.

gsutil ls -r gs://PROJECT_ID-job-primegen-TIMESTAMP/**

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

A saída será semelhante à seguinte, 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:

Cuidado: excluir um projeto tem os seguintes efeitos:

Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

No Console do Google Cloud, acesse a página Gerenciar recursos.
Acessar "Gerenciar recursos"
Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Excluir recursos criados neste tutorial

Exclua o job do Batch:

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 em lote.

Exclua o job:

gcloud batch jobs delete BATCH_JOB_NAME --location us-central1

Exclua o fluxo de trabalho:
```
gcloud workflows delete WORKFLOW_NAME
```

Exclua o repositório do contêiner:

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

O Cloud Build usa o Cloud Storage para armazenar recursos da versão. Para excluir um bucket do Cloud Storage, consulte Excluir buckets.

Executar um job em lote usando o Workflows

Objetivos

Custos

Antes de começar

Console

gcloud

Crie um repositório do Artifact Registry

Console

gcloud

Conferir os exemplos de código

criar a imagem Docker usando o Cloud Build

Implantar um fluxo de trabalho que programa e executa um job em lote

Console

YAML

JSON

gcloud

YAML

JSON

Executar o fluxo de trabalho

Console

gcloud

listar os objetos no bucket de saída

Console

gcloud

Limpar

Exclua o projeto

Excluir recursos criados neste tutorial

A seguir