Executar um job do Cloud Run usando o Workflows

Criar um job do Cloud Run

Neste tutorial, usamos um job do Cloud Run de exemplo do GitHub. O job lê dados de um arquivo de entrada no Cloud Storage e realiza algum processamento arbitrário para cada linha no arquivo.

1. Clone o repositório do app de exemplo na máquina local para conferir o código de amostra:

   git clone https://github.com/GoogleCloudPlatform/jobs-demos.git

   Outra opção é fazer o download do exemplo como um arquivo ZIP e extraí-lo.

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

   cd jobs-demos/parallel-processing

3. Crie um bucket do Cloud Storage para armazenar um arquivo de entrada que possa ser gravado e acionar um evento:

   Console

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

      Acessar buckets

   2. Clique em add Criar.
   3. Na página Criar um bucket, insira um nome para o bucket:

      input-PROJECT_ID

      Substitua PROJECT_ID pelo ID do seu projeto do Google Cloud.
   4. Mantenha os outros padrões.
   5. Clique em Criar.

   gcloud

   Execute o comando gcloud storage buckets create:

   gcloud storage buckets create gs://input-PROJECT_ID

   Se a solicitação for bem-sucedida, o comando retornará a seguinte mensagem:

   Creating gs://input-PROJECT_ID/...

   Terraform

   Para criar um bucket do Cloud Storage, use o recurso google_storage_bucket e modifique o arquivo main.tf, conforme mostrado no exemplo a seguir.

   Para saber como aplicar ou remover uma configuração do Terraform, consulte Comandos básicos do Terraform.

   Em um fluxo de trabalho típico do Terraform, você aplica o plano inteiro de uma vez. No entanto, para os fins deste tutorial, você pode segmentar um recurso específico. Exemplo:

   terraform apply -target="random_id.bucket_name_suffix"
   e
   terraform apply -target="google_storage_bucket.default"

   # Cloud Storage bucket names must be globally unique
   resource "random_id" "bucket_name_suffix" {
     byte_length = 4
   }
   
   # Create a Cloud Storage bucket
   resource "google_storage_bucket" "default" {
     name                        = "input-${data.google_project.project.name}-${random_id.bucket_name_suffix.hex}"
     location                    = "us-central1"
     storage_class               = "STANDARD"
     force_destroy               = false
     uniform_bucket_level_access = true
   }

4. Crie um repositório padrão do Artifact Registry para armazenar a imagem do contêiner:

   Console

   1. No console do Google Cloud, acesse a página Repositórios do Artifact Registry:

      Acessar repositórios

   2. Clique em add Criar repositório.

   3. Insira um nome para o repositório, por exemplo, my-repo. Para cada local de repositório em um projeto, os nomes dos repositórios precisam ser exclusivos.

   4. Mantenha o formato padrão, que deve ser Docker.

   5. Mantenha o modo padrão, que deve ser Padrão.

   6. Na região, selecione us-central1 (Iowa).

   7. Mantenha todos os outros padrões.

   8. Clique em Criar.

   gcloud

   Execute o comando:

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

   Substitua REPOSITORY por um nome exclusivo para o repositório, por exemplo, my-repo. Para cada local de repositório em um projeto, os nomes dos repositórios devem ser exclusivos.

   Terraform

   Para criar um repositório do Artifact Registry, use o recurso google_artifact_registry_repository e modifique o arquivo main.tf, conforme mostrado no exemplo a seguir.

   Em um fluxo de trabalho típico do Terraform, você aplica todo o plano de uma só vez. No entanto, para os fins deste tutorial, você pode segmentar um recurso específico. Exemplo:

   terraform apply -target="google_artifact_registry_repository.default"

   # Create an Artifact Registry repository
   resource "google_artifact_registry_repository" "default" {
     location      = "us-central1"
     repository_id = "my-repo"
     format        = "docker"
   }

5. Crie a imagem do contêiner usando um buildpack padrão do Google Cloud:

   export SERVICE_NAME=parallel-job
   gcloud builds submit \
       --pack image=us-central1-docker.pkg.dev/PROJECT_ID/REPOSITORY/${SERVICE_NAME}

   Substitua REPOSITORY pelo nome do seu repositório do Artifact Registry.

   A compilação pode levar alguns minutos.

6. Crie um job do Cloud Run que implante a imagem do contêiner:

   Console

   1. No console do Google Cloud, acesse a página do Cloud Run:

      Acesse o Cloud Run

   2. Clique em Criar job para exibir o formulário Criar job.

      1. No formulário, selecione us-central1-docker.pkg.dev/PROJECT_ID/REPOSITORY/parallel-job:latest como o URL da imagem do contêiner do Artifact Registry.
      2. Opcional: para o nome do job, insira parallel-job.
      3. Opcional: como região, selecione us-central1 (Iowa).
      4. Para o número de tarefas que você quer executar no job, insira 10: Todas as tarefas precisam ser bem-sucedidas para que o job seja concluído. De padrão, as tarefas são executadas em paralelo.

   3. Expanda a seção Contêiner, variáveis e Secrets, conexões, segurança e mantenha todos os padrões, com exceção das configurações:

      1. Clique na guia Geral.

         1. No comando do contêiner, insira python.
         2. Para o argumento do contêiner, insira process.py.

      2. Clique na guia Variáveis e secrets.

         1. Clique em Adicionar variável e insira INPUT_BUCKET como nome e input-PROJECT_ID como valor.
         2. Clique em Adicionar variável e insira INPUT_FILE para o nome e input_file.txt para o valor.

   4. Para criar o job, clique em Criar.

   gcloud

   1. Defina a região padrão do Cloud Run:

      gcloud config set run/region us-central1

   2. Crie o job do Cloud Run:

      gcloud run jobs create parallel-job \
          --image us-central1-docker.pkg.dev/PROJECT_ID/REPOSITORY/parallel-job:latest \
          --command python \
          --args process.py \
          --tasks 10 \
          --set-env-vars=INPUT_BUCKET=input-PROJECT_ID,INPUT_FILE=input_file.txt

      Se você não especificar uma tag de imagem, o Artifact Registry procurará a imagem com a tag latest padrão.

      Para acessar uma lista completa de opções disponíveis ao criar um job, consulte o comando gcloud run jobs create documentação da linha de comando.

      Depois que o job for criado, uma mensagem vai indicar o sucesso.

   Terraform

   Para criar um job do Cloud Run, use o Recurso google_cloud_run_v2_job e modifique o arquivo main.tf conforme o exemplo a seguir.

   Em um fluxo de trabalho comum do Terraform, você aplica todo o plano uma vez. No entanto, para os fins deste tutorial, você pode segmentar um recurso específico. Exemplo:

   terraform apply -target="google_cloud_run_v2_job.default"

   # Create a Cloud Run job
   resource "google_cloud_run_v2_job" "default" {
     name     = "parallel-job"
     location = "us-central1"
   
     template {
       task_count = 10
       template {
         containers {
           image   = "us-central1-docker.pkg.dev/${data.google_project.project.name}/${google_artifact_registry_repository.default.repository_id}/parallel-job:latest"
           command = ["python"]
           args    = ["process.py"]
           env {
             name  = "INPUT_BUCKET"
             value = google_storage_bucket.default.name
           }
           env {
             name  = "INPUT_FILE"
             value = "input_file.txt"
           }
         }
       }
     }
   }

Implantar um fluxo de trabalho que execute o job do Cloud Run

Definir e implantar um fluxo de trabalho que executa o job do Cloud Run que você acabou de criar. Uma definição de fluxo de trabalho é composta de uma série de etapas descritos usando o Sintaxe de fluxos de trabalho.

# Create a workflow
resource "google_workflows_workflow" "default" {
  name        = "cloud-run-job-workflow"
  region      = "us-central1"
  description = "Workflow that routes a Cloud Storage event and executes a Cloud Run job"

  # Note that $$ is needed for Terraform
  source_contents = <<EOF
  main:
      params: [event]
      steps:
          - init:
              assign:
                  - project_id: $${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
                  - event_bucket: $${event.data.bucket}
                  - event_file: $${event.data.name}
                  - target_bucket: "${google_storage_bucket.default.name}"
                  - job_name: parallel-job
                  - job_location: us-central1
          - check_input_file:
              switch:
                  - condition: $${event_bucket == target_bucket}
                    next: run_job
                  - condition: true
                    next: end
          - run_job:
              call: googleapis.run.v1.namespaces.jobs.run
              args:
                  name: $${"namespaces/" + project_id + "/jobs/" + job_name}
                  location: $${job_location}
                  body:
                      overrides:
                          containerOverrides:
                              env:
                                  - name: INPUT_BUCKET
                                    value: $${event_bucket}
                                  - name: INPUT_FILE
                                    value: $${event_file}
              result: job_execution
          - finish:
              return: $${job_execution}
  EOF
}

O fluxo de trabalho faz o seguinte:

1. Etapa init: aceita um evento do Cloud Storage como um argumento e define as variáveis necessárias.

2. Etapa check_input_file: verifica se o bucket do Cloud Storage especificado no evento é o bucket usado pelo job do Cloud Run.

   • Em caso afirmativo, o fluxo de trabalho segue para a etapa run_job.
   • Em caso negativo, o fluxo de trabalho é encerrado, interrompendo o processamento.

3. run_job etapa: usa o conector da API Cloud Run Admin Método googleapis.run.v1.namespaces.jobs.run para executar o job. Os nomes do bucket do Cloud Storage e do arquivo de dados são transmitidos como variáveis de substituição do fluxo de trabalho para o job.

4. Etapa finish: retorna informações sobre a execução do job como resultado do fluxo de trabalho.

Criar um gatilho do Eventarc para o fluxo de trabalho

Para executar automaticamente o fluxo de trabalho e, por sua vez, o job do Cloud Run sempre que o arquivo de dados de entrada for atualizado, crie um acionador do Eventarc que responda aos eventos do Cloud Storage no bucket que contém o arquivo de dados de entrada.

gcloud eventarc triggers create cloud-run-job-workflow-trigger \
    --location=us \
    --destination-workflow=cloud-run-job-workflow  \
    --destination-workflow-location=us-central1 \
    --event-filters="type=google.cloud.storage.object.v1.finalized" \
    --event-filters="bucket=input-PROJECT_ID" \
    --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

# Create an Eventarc trigger that routes Cloud Storage events to Workflows
resource "google_eventarc_trigger" "default" {
  name     = "cloud-run-job-trigger"
  location = google_workflows_workflow.default.region

  # Capture objects changed in the bucket
  matching_criteria {
    attribute = "type"
    value     = "google.cloud.storage.object.v1.finalized"
  }
  matching_criteria {
    attribute = "bucket"
    value     = google_storage_bucket.default.name
  }

  # Send events to Workflows
  destination {
    workflow = google_workflows_workflow.default.id
  }

  service_account = google_service_account.workflows.email

}

Sempre que um arquivo é carregado ou substituído no Cloud Storage que contém o arquivo de dados de entrada, o fluxo de trabalho será executado com o evento correspondente do Cloud Storage como argumento.

Acione o fluxo de trabalho

Teste o sistema completo atualizando o arquivo de dados de entrada no Cloud Storage.

1. Gere novos dados para o arquivo de entrada e faça upload deles para o Cloud Storage no local esperado pelo job do Cloud Run:

   base64 /dev/urandom | head -c 100000 >input_file.txt
   gcloud storage cp input_file.txt gs://input-PROJECT_ID/input_file.txt

   Se você criou um bucket do Cloud Storage usando o Terraform, é possível recuperar o nome do bucket executando o seguinte comando:

   gcloud storage buckets list gs://input*

   O job do Cloud Run pode levar alguns minutos para ser executado.

2. Confirme se o job do Cloud Run foi executado conforme o esperado, conferindo as execuções do job:

   gcloud config set run/region us-central1
   gcloud run jobs executions list --job=parallel-job

   Você vai encontrar uma execução de job bem-sucedida na saída, indicando que as tarefas 10/10 foram concluídas.

Saiba mais sobre como acionar um fluxo de trabalho com eventos ou mensagens do Pub/Sub.