Ejecuta un trabajo de Cloud Run con Workflows

---

Workflows te permite ejecutar Trabajos de Cloud Run como parte de un flujo de trabajo para realizar procesamientos de datos más complejos, o para organizar un sistema de trabajos existentes.

En este instructivo, se muestra cómo usar Workflows para ejecutar un Trabajo de Cloud Run que procesa datos que se pasaron como entorno variables al trabajo en respuesta a un evento de Cloud Storage.

Ten en cuenta que también puedes almacenar los datos de eventos en un Cloud Storage que te permite encriptar los datos con claves de encriptación administradas por el cliente. Para obtener más información, consulta Ejecuta un trabajo de Cloud Run que procese datos de eventos guardados en Cloud Storage.

Objetivos

En este instructivo, realizarás las siguientes acciones:

1. Crear un trabajo de Cloud Run que procese archivos de datos en un bucket de Cloud Storage.
2. Implementa un flujo de trabajo que haga lo siguiente:
   1. Acepta un evento de Cloud Storage como argumento.
   2. Verifica si el bucket de Cloud Storage especificado en el evento es el mismo bucket que usa el trabajo de Cloud Run.
   3. Si es así, usa el conector de la API de Cloud Run Admin. para ejecutar el trabajo de Cloud Run.
3. Crear un activador de Eventarc que ejecute el flujo de trabajo en respuesta a eventos que afectan al bucket de Cloud Storage.
4. Activa el flujo de trabajo actualizando un archivo de datos de entrada en el bucket de Cloud Storage.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

• Artifact Registry
• Cloud Build
• Cloud Run
• Cloud Storage
• Eventarc
• Workflows

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Antes de comenzar

Es posible que las restricciones de seguridad que define tu organización no te permitan completar los siguientes pasos. Para obtener información sobre la solución de problemas, consulta Desarrolla aplicaciones en un entorno de Google Cloud restringido.

Console

1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

4. Habilita las API de Artifact Registry, Cloud Build, Cloud Run, Cloud Storage, Eventarc, and Workflows.

   Habilita las API

5. Create a service account:

   1. In the Google Cloud console, go to the Create service account page.

      Go to Create service account
   2. Select your project.

   3. In the Service account name field, enter a name. The Google Cloud console fills in the Service account ID field based on this name.

      In the Service account description field, enter a description. For example, Service account for quickstart.

   4. Click Create and continue.

   5. Grant the following roles to the service account: Cloud Run Admin, Eventarc Event Receiver, Logs Writer, Workflows Invoker.

      To grant a role, find the Select a role list, then select the role.

      To grant additional roles, click Add another role and add each additional role.

      Note: The Role field affects which resources the service account can access in your project. You can revoke these roles or grant additional roles later. In production environments, do not grant the Owner, Editor, or Viewer roles. Instead, grant a predefined role or custom role that meets your needs.
   6. Click Continue.

   7. Click Done to finish creating the service account.

6. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

7. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

8. Habilita las API de Artifact Registry, Cloud Build, Cloud Run, Cloud Storage, Eventarc, and Workflows.

   Habilita las API

9. Create a service account:

   1. In the Google Cloud console, go to the Create service account page.

      Go to Create service account
   2. Select your project.

   3. In the Service account name field, enter a name. The Google Cloud console fills in the Service account ID field based on this name.

      In the Service account description field, enter a description. For example, Service account for quickstart.

   4. Click Create and continue.

   5. Grant the following roles to the service account: Cloud Run Admin, Eventarc Event Receiver, Logs Writer, Workflows Invoker.

      To grant a role, find the Select a role list, then select the role.

      To grant additional roles, click Add another role and add each additional role.

      Note: The Role field affects which resources the service account can access in your project. You can revoke these roles or grant additional roles later. In production environments, do not grant the Owner, Editor, or Viewer roles. Instead, grant a predefined role or custom role that meets your needs.
   6. Click Continue.

   7. Click Done to finish creating the service account.

10. Antes de crear un activador para eventos directos desde Cloud Storage, otorga el Pub/Sub, rol de publicador (roles/pubsub.publisher) al Agente de servicio de Cloud Storage:
    1. En la consola de Google Cloud, ve a IAM.
       

       Ir a IAM

    2. Selecciona la casilla de verificación Incluir asignaciones de roles proporcionadas por Google.
    3. En la columna Principal, busca la instancia de Cloud Storage Agente de servicio con el formulario [e-mail], y, luego, haz clic en Editar principal en la fila correspondiente.
    4. Haz clic en Agregar rol. o Agregar otro rol.
    5. En la lista Seleccionar un rol, filtra por Publicador de Pub/Sub y, luego, selecciona en el área de la seguridad en la nube.
    6. Haz clic en Guardar.
11. Si habilitaste el agente de servicio de Cloud Pub/Sub en antes del 8 de abril de 2021, para admitir el envío otorga el permiso Servicio Rol de creador de tokens de cuenta (roles/iam.serviceAccountTokenCreator) al agente de servicio. De lo contrario, esta función se otorga de forma predeterminada:
    1. En la consola de Google Cloud, ve a IAM.
       

       Ir a IAM

    2. Selecciona la casilla de verificación Incluir asignaciones de roles proporcionadas por Google.
    3. En la columna Nombre, busca el Cuenta de servicio de Cloud Pub/Sub y, luego, haz clic en Editar principal en la fila correspondiente.
    4. Haz clic en Agregar rol. o Agregar otro rol.
    5. En la lista Seleccionar un rol, filtra por Creador de tokens de cuenta de servicio y, luego, selecciona el rol.
    6. Haz clic en Guardar.

12. En la consola de Google Cloud, activa Cloud Shell.

    Activar Cloud Shell

    En la parte inferior de la consola de Google Cloud, se inicia una sesión de Cloud Shell en la que se muestra una ventana de línea de comandos. Cloud Shell es un entorno de shell con Google Cloud CLI ya instalada y con valores ya establecidos para el proyecto actual. La sesión puede tardar unos segundos en inicializarse.

Cloud Shell admite los comandos /dev/urandom en este instructivo que generan números pseudoaleatorios.

gcloud

1. Para usar una terminal en línea con gcloud CLI configura y activa Cloud Shell:

   En la parte inferior de esta página, se inicia una sesión de Cloud Shell y se muestra una instrucción de línea de comandos. La sesión puede tardar unos segundos en inicializarse.

   Cloud Shell admite los comandos /dev/urandom en este instructivo que generan números pseudoaleatorios.

2. Crea o selecciona un proyecto de Google Cloud.

   • Crea un proyecto de Google Cloud:

     gcloud projects create PROJECT_ID

   • Selecciona el proyecto de Google Cloud que creaste:

     gcloud config set project PROJECT_ID

3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.
4. Habilita las APIs de Artifact Registry, Cloud Build, Cloud Run, Cloud Storage, Eventarc, and Workflows :

   gcloud services enable artifactregistry.googleapis.com \
       cloudbuild.googleapis.com \
       eventarc.googleapis.com \
       run.googleapis.com \
       storage.googleapis.com \
       workflows.googleapis.com

5. Crea una cuenta de servicio para que tu flujo de trabajo la use como autenticación con otros servicios de Google Cloud y otorgarle los roles adecuados.
   1. Crea la cuenta de servicio:

      gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
      

      Reemplaza SERVICE_ACCOUNT_NAME por un nombre para la cuenta de servicio.

   2. Otorga roles a la cuenta de servicio administrada por el usuario que creaste en el paso anterior. Ejecuta el siguiente comando una vez para cada uno de los siguientes elementos: IAM o puedes usar la marca --role varias veces en un solo comando:
      • roles/eventarc.eventReceiver: Para recibir eventos
      • roles/logging.logWriter: Para escribir registros
      • roles/run.admin: Para ejecutar el comando de Cloud Run, trabajo
      • roles/workflows.invoker: Para invocar flujos de trabajo

      gcloud projects add-iam-policy-binding PROJECT_ID \
          --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
          --role=ROLE
      

      Reemplaza lo siguiente:

      • PROJECT_ID: Es el ID del proyecto en el que creaste. la cuenta de servicio
      • ROLE: Es el rol que se otorgará al rol administrado por el usuario. cuenta de servicio
      Nota: La marca --role afecta los recursos que a la cuenta de servicio en tu proyecto. Puedes revocar estos roles o otorgar roles adicionales más adelante. En entornos de producción, no otorgues el roles de Propietario, Editor o Visualizador. En su lugar, otorga un rol predefinido o un rol personalizado que cumpla según tus necesidades.
6. Antes de crear un activador para eventos directos desde Cloud Storage, otorga el permiso de Pub/Sub rol de publicador (roles/pubsub.publisher) al Agente de servicio de Cloud Storage:

   SERVICE_ACCOUNT="$(gcloud storage service-agent --project=PROJECT_ID)"
   
   gcloud projects add-iam-policy-binding PROJECT_ID \
       --member="serviceAccount:${SERVICE_ACCOUNT}" \
       --role='roles/pubsub.publisher'
   

7. Si habilitaste el agente de servicio de Cloud Pub/Sub el 8 de abril de 2021 o antes de esa fecha, para admitir las solicitudes de envío de Pub/Sub autenticadas, otorga el rol Creador de tokens de cuenta de servicio (roles/iam.serviceAccountTokenCreator) a la cuenta de servicio administrada por Google. De lo contrario, este rol se otorga de forma predeterminada:

   gcloud projects add-iam-policy-binding PROJECT_ID \
       --member=serviceAccount:[e-mail] \
       --role=roles/iam.serviceAccountTokenCreator

Reemplaza PROJECT_NUMBER por el número de proyecto de Google Cloud. Para encontrar el número del proyecto, ve a la página de bienvenida de la consola de Google Cloud o ejecuta el siguiente comando:

gcloud projects describe PROJECT_ID --format='value(projectNumber)'

Terraform

1. Para usar una terminal en línea con gcloud CLI configura y activa Cloud Shell:

   En la parte inferior de esta página, se inicia una sesión de Cloud Shell y se muestra una instrucción de línea de comandos. La sesión puede tardar unos segundos en inicializarse.

   Cloud Shell admite los comandos /dev/urandom en este instructivo que generan números pseudoaleatorios.

2. Crea o selecciona un proyecto de Google Cloud.

   • Crea un proyecto de Google Cloud:

     gcloud projects create PROJECT_ID

   • Selecciona el proyecto de Google Cloud que creaste:

     gcloud config set project PROJECT_ID

3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.
4. Habilita las APIs de Artifact Registry, Cloud Build, Cloud Run, Cloud Storage, Eventarc, and Workflows :

   gcloud services enable artifactregistry.googleapis.com \
       cloudbuild.googleapis.com \
       eventarc.googleapis.com \
       run.googleapis.com \
       storage.googleapis.com \
       workflows.googleapis.com

5. Crea una cuenta de servicio para que tu flujo de trabajo la use como autenticación con otros servicios de Google Cloud y otorgarle los roles adecuados. Además, para admitir eventos directos desde Cloud Storage, otorga el permiso de Pub/Sub de publicador (roles/pubsub.publisher) al Agente de servicio de Cloud Storage.

   Modifica tu archivo main.tf como se muestra en el siguiente ejemplo. Para obtener más información, consulta la Proveedor de Google para la documentación de Terraform.

   Si deseas obtener más información para aplicar o quitar una configuración de Terraform, consulta los comandos básicos de Terraform.

   Ten en cuenta que en un flujo de trabajo típico de Terraform, se aplica todo el plan en una vez. Sin embargo, a los efectos de este instructivo, puedes usar como destino un recurso específico. Por ejemplo:

   terraform apply -target="google_service_account.workflows"

   # Used to retrieve project information later
   data "google_project" "project" {}
   
   # Create a dedicated service account
   resource "google_service_account" "workflows" {
     account_id   = "workflows-run-job-sa"
     display_name = "Workflows Cloud Run Job Service Account"
   }
   
   # Grant permission to receive Eventarc events
   resource "google_project_iam_member" "eventreceiver" {
     project = data.google_project.project.id
     role    = "roles/eventarc.eventReceiver"
     member  = "serviceAccount:${google_service_account.workflows.email}"
   }
   
   # Grant permission to write logs
   resource "google_project_iam_member" "logwriter" {
     project = data.google_project.project.id
     role    = "roles/logging.logWriter"
     member  = "serviceAccount:${google_service_account.workflows.email}"
   }
   
   # Grant permission to execute Cloud Run jobs
   resource "google_project_iam_member" "runadmin" {
     project = data.google_project.project.id
     role    = "roles/run.admin"
     member  = "serviceAccount:${google_service_account.workflows.email}"
   }
   
   # Grant permission to invoke workflows
   resource "google_project_iam_member" "workflowsinvoker" {
     project = data.google_project.project.id
     role    = "roles/workflows.invoker"
     member  = "serviceAccount:${google_service_account.workflows.email}"
   }
   
   # Grant the Cloud Storage service agent permission to publish Pub/Sub topics
   data "google_storage_project_service_account" "gcs_account" {}
   resource "google_project_iam_member" "pubsubpublisher" {
     project = data.google_project.project.id
     role    = "roles/pubsub.publisher"
     member  = "serviceAccount:${data.google_storage_project_service_account.gcs_account.email_address}"
   }
   

6. Si habilitaste el agente de servicio de Cloud Pub/Sub el 8 de abril de 2021 o antes de esa fecha, para admitir las solicitudes de envío de Pub/Sub autenticadas, otorga el rol de creador de tokens de cuenta de servicio (roles/iam.serviceAccountTokenCreator) al agente de servicio. De lo contrario, este rol se otorga de forma predeterminada:

   gcloud projects add-iam-policy-binding PROJECT_ID \
       --member=serviceAccount:[e-mail] \
       --role=roles/iam.serviceAccountTokenCreator

Reemplaza PROJECT_NUMBER por el número de proyecto de Google Cloud. Para encontrar el número del proyecto, ve a la página de bienvenida de la consola de Google Cloud o ejecuta el siguiente comando:

gcloud projects describe PROJECT_ID --format='value(projectNumber)'

Crea un trabajo de Cloud Run

En este instructivo, se usa un trabajo de muestra de Cloud Run de GitHub. El trabajo lee datos de un archivo de entrada en Cloud Storage y realiza procesamiento arbitrario para cada línea del archivo.

1. Clona el repositorio de la app de ejemplo en el clúster local para obtener el código máquina virtual:

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

   Como alternativa, puedes descarga la muestra como un archivo ZIP y extraerlo.

2. Dirígete al directorio que contiene el código de muestra:

   cd jobs-demos/parallel-processing
   

3. Crea un bucket de Cloud Storage para almacenar un archivo de entrada que se pueda escribir y activar un evento:

   Console

   1. En la consola de Google Cloud, ve a la página Buckets de Cloud Storage.
      

      Ir a Buckets

   2. Haz clic en agregar Crear.
   3. En la página Crear un bucket, ingresa un nombre para el bucket:

      input-PROJECT_ID

      Reemplaza PROJECT_ID por el ID de tu proyecto de Google Cloud.
   4. Conserva los demás valores predeterminados.
   5. Haz clic en Crear.

   gcloud

   Ejecuta la Comando gcloud storage buckets create:

   gcloud storage buckets create gs://input-PROJECT_ID

   Si la solicitud se realiza correctamente, el comando mostrará el siguiente mensaje:

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

   Terraform

   Para crear un bucket de Cloud Storage, usa el google_storage_bucket recurso y modifica tu archivo main.tf como se muestra en la siguiente ejemplo.

   Si quieres aprender a aplicar o quitar una configuración de Terraform, consulta Comandos básicos de Terraform

   Ten en cuenta que en un flujo de trabajo típico de Terraform, se aplica todo el plan de una sola vez. Sin embargo, a los efectos de este instructivo, puedes usar como destino un recurso específico. Por ejemplo:

   terraform apply -target="random_id.bucket_name_suffix"
   y
   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. Crea un repositorio estándar de Artifact Registry en el que puedas almacenar tu imagen de contenedor:

   Console

   1. En la consola de Google Cloud, ve a Artifact Registry Repositories:

      Ir a Repositorios

   2. Haz clic en . Crear repositorio.

   3. Ingresa un nombre para el repositorio, por ejemplo, my-repo. Para la ubicación de cada repositorio en un proyecto, los nombres de los repositorios deben ser únicos.

   4. Conserva el formato predeterminado que debería ser Docker.

   5. Conserva el modo predeterminado, que debería ser Estándar.

   6. Para la región, selecciona us-central1 (Iowa).

   7. Conserva todos los demás valores predeterminados.

   8. Haz clic en Crear.

   gcloud

   Ejecuta el siguiente comando:

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

   Reemplaza REPOSITORY por un nombre único para el en un repositorio de confianza, por ejemplo, my-repo. Para cada ubicación de repositorio en una los nombres de repositorios deben ser únicos.

   Terraform

   Para crear un repositorio de Artifact Registry, usa el Recurso google_artifact_registry_repository y modifica tu archivo main.tf como se muestra en el siguiente ejemplo.

   Ten en cuenta que en un flujo de trabajo típico de Terraform, se aplica todo el plan en una vez. Sin embargo, a los efectos de este instructivo, puedes usar como destino un recurso específico. Por ejemplo:

   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. Compila la imagen de contenedor con un paquete de compilación predeterminado de Google Cloud:

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

   Reemplaza REPOSITORY por el nombre de tu Repositorio de Artifact Registry.

   La compilación puede tardar unos minutos en completarse.

6. Crea un trabajo de Cloud Run que implemente la imagen del contenedor:

   Console

   1. En la consola de Google Cloud, ve a Cloud Run página:

      Ir a Cloud Run

   2. Haz clic en Crear trabajo para mostrar el formulario Crear trabajo.

      1. En el formulario, selecciona us-central1-docker.pkg.dev/PROJECT_ID/REPOSITORY/parallel-job:latest como la URL de la imagen de contenedor de Artifact Registry.
      2. Como nombre del trabajo, ingresa parallel-job (opcional).
      3. Opcional: Para la región, selecciona us-central1 (Iowa).
      4. Para la cantidad de tareas que quieres ejecutar en el trabajo, ingresa 10. Todas las tareas deben completarse correctamente para que el trabajo se realice de forma correcta. De de forma predeterminada, las tareas se ejecutan en paralelo.

   3. Expande la sección Contenedores, variables y Secrets, conexiones y seguridad y conserva todos los valores predeterminados, excepto los siguientes configuración:

      1. Haz clic en la pestaña General.

         1. Para el comando del contenedor, ingresa python.
         2. Como argumento del contenedor, ingresa process.py.

      2. Haz clic en la pestaña Variables y Secrets.

         1. Haz clic en Agregar variable y, luego, ingresa INPUT_BUCKET para la y input-PROJECT_ID de la valor.
         2. Haz clic en Agregar variable y, luego, ingresa INPUT_FILE para la y input_file.txt para el valor.

   4. Para crear el trabajo, haz clic en Crear.

   gcloud

   1. Configura la región predeterminada de Cloud Run:

      gcloud config set run/region us-central1

   2. Crea el trabajo de 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

      Ten en cuenta que si no especificas un etiqueta de imagen, Artifact Registry Busca la imagen con la etiqueta latest predeterminada.

      Para obtener una lista completa de las opciones disponibles cuando creas un trabajo, consulta el comando gcloud run jobs create en la documentación de la línea de comandos.

      Cuando se cree el trabajo, deberías ver un mensaje que indique el éxito.

   Terraform

   Para crear un trabajo de Cloud Run, usa el Recurso google_cloud_run_v2_job y modifica tu archivo main.tf como se muestra en el siguiente ejemplo.

   Ten en cuenta que en un flujo de trabajo típico de Terraform, se aplica todo el plan en una vez. Sin embargo, a los efectos de este instructivo, puedes usar como destino un recurso específico. Por ejemplo:

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

Implementa un flujo de trabajo que ejecute el trabajo de Cloud Run

Define e implementa un flujo de trabajo que ejecute el trabajo de Cloud Run que acabas de crear. La definición de un flujo de trabajo se compone de una serie de pasos descrita con el Sintaxis de flujos de trabajo.

Console

1. En la consola de Google Cloud, ve a Página Flujos de trabajo:

   Ir a Workflows

2. Haz clic en Crear:

3. Ingresa un nombre para el flujo de trabajo nuevo, como cloud-run-job-workflow.

4. Para la región, selecciona us-central1 (Iowa).

5. En el campo Cuenta de servicio, selecciona la cuenta de servicio creamos anteriormente.

   La cuenta de servicio funciona como la identidad del flujo de trabajo. Deberías tener el rol de administrador de Cloud Run a la cuenta de servicio, por lo que que el flujo de trabajo pueda ejecutar el trabajo de Cloud Run.

6. Haz clic en Siguiente.

7. En el editor de flujos de trabajo, ingresa la siguiente definición para tu flujo de trabajo:

   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. Haga clic en Implementar.

gcloud

1. Crea un archivo de código fuente para tu flujo de trabajo:

   touch cloud-run-job-workflow.yaml
   

2. Copia la siguiente definición de flujo de trabajo en tu archivo de código fuente:

   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. Para implementar el flujo de trabajo, ingresa el siguiente 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
   

   Reemplaza lo siguiente:

   • SERVICE_ACCOUNT_NAME: Es el nombre de la cuenta de servicio que creaste anteriormente
   • PROJECT_ID: Es el ID de tu Proyecto de Google Cloud

   La cuenta de servicio funciona como la identidad del flujo de trabajo. Deberías tener ya otorgaste el rol roles/run.admin a la cuenta de servicio, por lo que que el flujo de trabajo pueda ejecutar el trabajo de Cloud Run.

Terraform

Para crear un flujo de trabajo, usa el Recurso google_workflows_workflow y modifica tu archivo main.tf como se muestra en el siguiente ejemplo.

Si deseas obtener más información para aplicar o quitar una configuración de Terraform, consulta los comandos básicos de Terraform.

Ten en cuenta que, en un flujo de trabajo típico de Terraform, se aplica todo el plan a la vez. Sin embargo, a los efectos de este instructivo, puedes enfocarte en un grupo recurso. Por ejemplo:

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"

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

El flujo de trabajo hace lo siguiente:

1. Paso init: Acepta un evento de Cloud Storage como argumento y, luego, se configuran las variables necesarias.

2. Paso check_input_file: Verifica si el bucket de Cloud Storage especificado en el evento es el bucket que usa el trabajo de Cloud Run.

   • Si es así, el flujo de trabajo continúa con el paso run_job.
   • Si no es así, el flujo de trabajo finaliza y se detiene cualquier procesamiento posterior.

3. Paso run_job: Usa el conector de la API de Cloud Run Admin Método googleapis.run.v1.namespaces.jobs.run para ejecutar el trabajo. Los nombres del bucket de Cloud Storage y del archivo de datos y se pasan como variables de anulación del flujo de trabajo al trabajo.

4. Paso finish: muestra información sobre la ejecución del trabajo como resultado de el flujo de trabajo.

Crea un activador de Eventarc para el flujo de trabajo

Para ejecutar automáticamente el flujo de trabajo y, a su vez, Cloud Run cada vez que se actualice el archivo de datos de entrada, crea un Eventarc activador que responda a los eventos de Cloud Storage en el bucket que contiene el archivo de datos de entrada.

Console

1. En la consola de Google Cloud, ve a Página Flujos de trabajo:

   Ir a Workflows

2. Haz clic en el nombre de tu flujo de trabajo, como cloud-run-job-workflow.

3. En la página Detalles del flujo de trabajo, haz clic en Editar.

4. En la página Editar flujo de trabajo, en la sección Activadores, Haz clic en Agregar activador nuevo > Eventarc.

   Se abrirá el panel Evento de Eventarc.

5. En el campo Nombre del activador, ingresa un nombre para el activador, como cloud-run-job-workflow-trigger.

6. En la lista Proveedor de eventos, selecciona Cloud Storage.

7. En la lista Evento, selecciona google.cloud.storage.object.v1.finalized.

8. En el campo Bucket, selecciona el bucket que contiene los datos de entrada. . El nombre del bucket tiene el siguiente formato: input-PROJECT_ID.

9. En el campo Cuenta de servicio, selecciona la cuenta de servicio creamos anteriormente.

   La cuenta de servicio funciona como la identidad del activador. Deberías tener ya otorgaste los siguientes roles a la cuenta de servicio:

   • Receptor de eventos de Eventarc: Para recibir eventos
   • Invocador de flujos de trabajo: Para ejecutar flujos de trabajo

10. Haz clic en Guardar activador.

    El activador de Eventarc ahora aparece en la sección Activadores de la página Editar flujo de trabajo.

11. Haz clic en Siguiente.

12. Haga clic en Implementar.

gcloud

Para crear un activador de Eventarc, ejecuta el siguiente 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

Reemplaza lo siguiente:

• PROJECT_IDEl ID de tu proyecto de Google Cloud.
• SERVICE_ACCOUNT_NAME: Es el nombre del servicio. cuenta que creaste anteriormente.

La cuenta de servicio funciona como la identidad del activador. Deberías tener ya otorgaste los siguientes roles a la cuenta de servicio:

• roles/eventarc.eventReceiver: Para recibir eventos
• roles/workflows.invoker: Para ejecutar flujos de trabajo

Terraform

Para crear un activador, usa la Recurso google_eventarc_trigger y modifica tu archivo main.tf como se muestra en el siguiente ejemplo.

Si deseas obtener más información para aplicar o quitar una configuración de Terraform, consulta los comandos básicos de Terraform.

Ten en cuenta que, en un flujo de trabajo típico de Terraform, se aplica todo el plan a la vez. Sin embargo, a los efectos de este instructivo, puedes enfocarte en un grupo recurso. Por ejemplo:

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

}

Nota: Aunque tu activador se crea de inmediato, puede tardar hasta dos minutos en propagarse y filtrar los eventos.

Cada vez que se sube un archivo a Cloud Storage o se reemplaza bucket que contiene el archivo de datos de entrada, el flujo de trabajo se ejecuta con el evento correspondiente de Cloud Storage como argumento.

Activa el flujo de trabajo

Prueba el sistema de extremo a extremo actualizando el archivo de datos de entrada en en Google Cloud Storage.

1. Genera datos nuevos para el archivo de entrada y súbelos a Cloud Storage en la ubicación que espera el trabajo de Cloud Run:

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

   Si creaste un bucket de Cloud Storage con Terraform, puedes Para recuperar el nombre del bucket, ejecuta el siguiente comando:

   gcloud storage buckets list gs://input*
   

   El trabajo de Cloud Run puede tardar unos minutos en ejecutarse.

2. Para confirmar que el trabajo de Cloud Run se ejecutó según lo esperado, consulta las ejecuciones del trabajo:

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

   Deberías ver una ejecución de trabajo exitosa en el resultado que indique lo siguiente: Se completaron 10/10 tareas.

Obtén más información sobre Activar un flujo de trabajo con eventos o mensajes de Pub/Sub.

Limpia

Si creaste un proyecto nuevo para este instructivo, bórralo. Si usaste un proyecto existente y deseas conservarlo sin los cambios que se agregaron en este instructivo, borra los recursos creados para el instructivo.

Borra el proyecto

La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.

Para borrar el proyecto, haz lo siguiente:

Precaución: Borrar un proyecto tiene estas consecuencias:

• Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
• Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

1. En la consola de Google Cloud, ve a la página Administrar recursos.

   Ir a Administrar recursos

2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

Elimina recursos de instructivos

Borra los recursos que creaste en este instructivo:

1. Borrar el activador de Eventarc:

   gcloud eventarc triggers delete cloud-run-job-workflow-trigger --location=us
   

2. Borra el flujo de trabajo:

   gcloud workflows delete cloud-run-job-workflow --location=us-central1
   

3. Borra el trabajo de Cloud Run:

   gcloud run jobs delete parallel-job
   

4. Borra el bucket de Cloud Storage que se creó para los datos de entrada:

   gcloud storage rm --recursive gs://input-PROJECT_ID/
   

5. Borra el repositorio de Artifact Registry:

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

¿Qué sigue?

• Obtén más información sobre los trabajos de Cloud Run.
• Obtén más información sobre los conectores de Workflows.
• Obtén más información sobre Workflows.