Executar um job do Cloud Run usando o Workflows

Com o Workflows, é possível executar jobs do Cloud Run como parte de um fluxo de trabalho para realizar processamentos de dados mais complexos ou orquestrar um sistema de jobs atuais.

Neste tutorial, mostramos como usar o Workflows para executar um job do Cloud Run que processa dados transmitidos como variáveis de ambiente para o job, em resposta a um evento do Cloud Storage.

Também é possível armazenar os dados de eventos em um bucket do Cloud Storage, o que permite criptografar os dados usando chaves de criptografia gerenciadas pelo cliente. Para mais informações, consulte Executar um job do Cloud Run que processa dados de eventos salvos no Cloud Storage.

Criar um job do Cloud Run

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

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

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

    Outra opção é fazer o download da amostra como um arquivo ZIP e extraí-la.

  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 Create.
    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 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="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 Google Cloud , acesse a página Repositórios do Artifact Registry:

      Acessar repositórios

    2. Clique em 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. Em 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 precisam 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 Google Cloud padrão:

    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 repositório do Artifact Registry.

    A conclusão do build pode levar alguns minutos.

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

    Console

    1. No console 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: para a região, selecione us-central1 (Iowa).
      4. Para o número de tarefas que você quer executar no job, digite 10. Todas as tarefas precisam ser bem-sucedidas para que o job seja concluído. Por padrão, as tarefas são executadas em paralelo.

    3. Expanda a seção Contêiner, variáveis e secrets, conexões e segurança e mantenha todos os padrões, exceto as seguintes configurações:

      1. Clique na guia Geral.

        1. Para o 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 no nome e input-PROJECT_ID no 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 padrão latest.

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

      Quando o job for criado, você vai receber uma mensagem indicando que a operação foi concluída.

    Terraform

    Para criar um job do Cloud Run, use o recurso google_cloud_run_v2_job e modifique seu 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_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"
        }
      }
    }
  }
}

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

Defina e implante um fluxo de trabalho que execute o job do Cloud Run que você acabou de criar. Uma definição de fluxo de trabalho é composta por uma série de etapas descritas usando a sintaxe do Workflows.

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 cloud-run-job-workflow.

  4. Em região, selecione us-central1 (Iowa).

  5. No campo Conta de serviço, selecione a conta de serviço que você criou anteriormente.

    A conta de serviço serve como a identidade do fluxo de trabalho. Você já deve ter concedido o papel de Administrador do Cloud Run à conta de serviço para que o fluxo de trabalho possa executar o job do Cloud Run.

  6. Clique em Próxima.

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

    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: ${"input-" + project_id}
                - 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}

  8. Clique em Implantar.

gcloud

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

    touch cloud-run-job-workflow.yaml

  2. Copie a seguinte definição de fluxo de trabalho para o arquivo de código-fonte:

    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: ${"input-" + project_id}
                - 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}

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

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

    Substitua:

    • SERVICE_ACCOUNT_NAME: o nome da conta de serviço que você criou antes
    • PROJECT_ID: o ID do seu projetoGoogle Cloud

    A conta de serviço serve como a identidade do fluxo de trabalho. Você já precisa ter concedido o papel roles/run.admin à conta de serviço para que o fluxo de trabalho possa executar o job do Cloud Run.

Terraform

Para criar um fluxo de trabalho, use o recurso google_workflows_workflow 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 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_workflows_workflow.default"

# 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"

  deletion_protection = false # set to "true" in production

  # 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 argumento e define as variáveis necessárias.

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

    • Se a resposta for "sim", o fluxo de trabalho vai para a etapa run_job.
    • Se a resposta for não, o fluxo de trabalho será encerrado, interrompendo qualquer outro processamento.

  3. Etapa run_job: usa o método googleapis.run.v1.namespaces.jobs.run do conector da API Cloud Run Admin 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 gatilho do Eventarc que responda a eventos do Cloud Storage no bucket que contém o arquivo de dados de entrada.

Console

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

    Acessar fluxos de trabalho

  2. Clique no nome do fluxo de trabalho, como cloud-run-job-workflow.

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

  4. Na página Editar fluxo de trabalho, na seção Gatilhos, clique em Adicionar novo gatilho > Eventarc.

    O painel Gatilho do Eventarc é aberto.

  5. No campo Nome do gatilho, insira um nome para o gatilho, como cloud-run-job-workflow-trigger.

  6. Na lista Provedor de eventos, selecione Cloud Storage.

  7. Na lista Evento, selecione google.cloud.storage.object.v1.finalized.

  8. No campo Bucket, selecione o bucket que contém o arquivo de dados de entrada. O nome do bucket tem o formato input-PROJECT_ID.

  9. No campo Conta de serviço, selecione a conta de serviço que você criou anteriormente.

    A conta de serviço serve como a identidade do gatilho. Você já precisa ter concedido os seguintes papéis à conta de serviço:

    • Receptor de eventos do Eventarc: para receber eventos
    • Chamador do Workflows: para executar fluxos de trabalho

  10. Clique em Salvar acionador.

    O gatilho do Eventarc agora aparece na seção Gatilhos da página Editar fluxo de trabalho.

  11. Clique em Próxima.

  12. Clique em Implantar.

gcloud

Crie um gatilho do Eventarc executando o seguinte comando:

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

Substitua:

  • PROJECT_ID: o ID do projeto Google Cloud
  • SERVICE_ACCOUNT_NAME: o nome da conta de serviço que você criou anteriormente.

A conta de serviço serve como a identidade do gatilho. Você já precisa ter concedido os seguintes papéis à conta de serviço:

  • roles/eventarc.eventReceiver: para receber eventos.
  • roles/workflows.invoker: para executar fluxos de trabalho

Terraform

Para criar um gatilho, use o recurso google_eventarc_trigger 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 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_eventarc_trigger.default"

# 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 é enviado ou substituído no bucket do Cloud Storage que contém o arquivo de dados de entrada, o fluxo de trabalho é executado com o evento correspondente do Cloud Storage como um argumento.

Acione o fluxo de trabalho

Teste o sistema de ponta a ponta 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 dele 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 esperado. Para isso, confira as execuções do job:

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

    Você vai ver 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.