Se usó la API de Cloud Translation para traducir esta página.

Espera a que ocurran eventos con devoluciones de llamada y activadores de Eventarc

Es posible que tu flujo de trabajo deba esperar un proceso externo. Puedes usar devoluciones de llamada HTTP para esperar que otro servicio realice una solicitud a un extremo de devolución de llamada. Esa solicitud reanuda la ejecución del flujo de trabajo. También puedes esperar con sondeos.

En lugar de usar sondeos, en este instructivo se muestra cómo puedes esperar eventos o mensajes de Pub/Sub con devoluciones de llamada HTTP y activadores de Eventarc. Aunque puedes activar un flujo de trabajo con eventos o mensajes de Pub/Sub, te recomendamos que detengas esa ejecución para esperar otro evento antes de continuar. Por ejemplo, un evento activa un flujo de trabajo para iniciar un proceso, pero el flujo de trabajo debe esperar a otro evento que indique que el proceso está completo. Para implementar esto, puedes hacer que un flujo de trabajo llame a otro.

Objetivos

En este instructivo, ocurrirá lo siguiente:

Se implementa y ejecuta un flujo de trabajo principal que debe esperar eventos. Como debe esperar a que ocurran los eventos, almacena los detalles de la devolución de llamada en una base de datos de Firestore para que el flujo de trabajo secundario pueda recuperarlos. Luego, el flujo de trabajo principal espera las llamadas HTTP.
Los eventos activan un flujo de trabajo secundario y recuperan los detalles de la devolución de llamada de la base de datos de Firestore cuando se generan los eventos. Luego, el flujo de trabajo secundario vuelve a llamar al flujo de trabajo principal, que reanuda su ejecución.

Esta es una descripción general de todo el proceso:

Flujo de trabajo principal:

Un flujo de trabajo de callback-event-sample crea extremos de devolución de llamada para dos fuentes de eventos: un tema de Pub/Sub y un bucket de Cloud Storage.
Este flujo de trabajo almacena ambos extremos de devolución de llamada en un documento de Firestore.
Este flujo de trabajo detiene su ejecución y espera a que las solicitudes HTTP lleguen a los extremos de devolución de llamada.

Eventos:

Ocurren eventos: se publica un mensaje en un tema de Pub/Sub y se sube un archivo a un bucket de Cloud Storage.

Flujo de trabajo secundario:

Eventarc enruta los eventos al flujo de trabajo callback-event-listener y activa su ejecución.
Este flujo de trabajo recupera las URLs de los extremos de devolución de llamada adecuados del documento de Firestore.
Este flujo de trabajo ejecuta las devoluciones de llamada a los extremos adecuados en el flujo de trabajo de muestra.

Flujo de trabajo principal:

El flujo de trabajo de callback-event-sample recibe los eventos en los extremos de devolución de llamada y reanuda su ejecución.
Este flujo de trabajo borra las URLs de devolución de llamada del documento de Firestore y completa su ejecución.

Costos

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

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

Puedes ejecutar los siguientes comandos en la consola de Google Cloud o con Google Cloud CLI en la terminal o en Cloud Shell.

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

En la página del selector de proyectos de la consola de Google Cloud, elige o crea un proyecto de Google Cloud.

Nota: Si no planeas conservar los recursos creados durante este procedimiento, crea un proyecto en lugar de elegir un proyecto existente. Cuando termines, puedes borrar el proyecto si quitas todos los recursos asociados con él.

Ir al selector de proyectos
Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo verificar si la facturación está habilitada en un proyecto.
Habilita las APIs de App Engine, Eventarc, Firestore, Pub/Sub y Workflows.

Habilita las API
Crea una cuenta de servicio para que tu flujo de trabajo la use en la autenticación con otros servicios de Google Cloud y bríndale los roles adecuados:
1. En la consola de Google Cloud, ve a la página Cuentas de servicio.
  
  Ir a Cuentas de servicio
2. Para ir a la página Crear cuenta de servicio, selecciona tu proyecto.
3. Escribe un nombre en el campo Nombre de cuenta de servicio. La consola de Google Cloud completa el campo ID de la cuenta de servicio en función de este nombre.
  
  Opcional: en el campo Descripción de la cuenta de servicio, escribe una descripción. Por ejemplo, Service account for tutorial.
4. Haz clic en Crear y continuar.
5. En la lista Seleccionar un rol, filtra por los siguientes roles para otorgarlos a la cuenta de servicio administrada por el usuario que creaste en el paso anterior:
  - Usuario de Cloud Datastore: Para acceder a los datos de Firestore en modo Datastore.
  - Receptor de eventos de Eventarc: Para recibir eventos de proveedores de eventos.
  - Escritor de registros: Para escribir registros.
  - Invocador de flujos de trabajo: Para ejecutar flujos de trabajo y administrar las ejecuciones.
  Para obtener roles adicionales, haz clic en Agregar otro rol y agrega cada rol adicional.
  
  Nota: El campo Función afecta a qué recursos puede acceder tu cuenta de servicio en el proyecto. Puedes revocar estos roles o asignar otros más adelante. En entornos de producción, no otorgues los roles de propietario, editor o visualizador. En su lugar, otorga un rol predefinido o un rol personalizado que satisfaga tus necesidades.
6. Haga clic en Continuar.
7. Para terminar de crear la cuenta, haz clic en Listo.
Para crear un activador de Eventarc que enrute eventos desde Cloud Storage, otorga el rol de publicador de Pub/Sub al agente de servicio de Cloud Storage. Por lo general, es service-PROJECT_NUMBER@gs-project-accounts.iam.gserviceaccount.com. Puedes recuperar la dirección de correo electrónico del agente de servicio de Cloud Storage.
1. En la consola de Google Cloud, ve a la página IAM.
  
  Ir a IAM
2. En la fila del agente de servicio de Cloud Storage, haz clic en Editar principal. (Si el agente de servicio no aparece en la lista, continúa con el siguiente paso). Se abrirá el panel Editar acceso.
  1. Haz clic en Agregar otro rol y, a continuación, busca el rol del Publicador de Pub/Sub.
  2. Elige el rol.
  3. Haz clic en Guardar.
3. Si el agente de servicio no aparece en la lista, haz clic en Otorgar acceso. Se abrirá el panel Otorgar acceso.
  1. En el campo Principales nuevas, escribe la dirección de correo electrónico del agente de servicio.
  2. En la lista Elige un rol, busca el rol Publicador de Pub/Sub.
  3. Elige el rol.
  4. Haz clic en Guardar.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo verificar si la facturación está habilitada en un proyecto.

Habilita las APIs de App Engine, Eventarc, Firestore, Pub/Sub y Workflows.

gcloud services enable \
    appengine.googleapis.com \
    eventarc.googleapis.com \
    firestore.googleapis.com \
    pubsub.googleapis.com \
    workflows.googleapis.com

Crea una cuenta de servicio para que tu flujo de trabajo la use en la autenticación con otros servicios de Google Cloud y bríndale los roles adecuados.
1. Cree 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 roles de IAM:
  - roles/datastore.user: Para acceder a los datos de Firestore en modo Datastore.
  - roles/eventarc.eventReceiver: Para recibir eventos de proveedores de eventos.
  - roles/logging.logWriter: Para escribir registros.
  - roles/workflows.invoker: Para ejecutar flujos de trabajo y administrar las ejecuciones.
```
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: El ID del proyecto en el que creaste la cuenta de servicio
  - ROLE: el rol a otorgar
  Nota: La marca --role afecta a qué recursos puede acceder tu cuenta de servicio en el proyecto. Puedes revocar estos roles o asignar otros más adelante. En entornos de producción, no otorgues los roles de propietario, editor o visualizador. En su lugar, otorga un rol predefinido o un rol personalizado que satisfaga tus necesidades.
Para crear un activador de Eventarc que enrute eventos desde Cloud Storage, otorga el rol de publicador de Pub/Sub al agente de servicio de Cloud Storage. Por lo general, es service-PROJECT_NUMBER@gs-project-accounts.iam.gserviceaccount.com. Usa gcloud storage service-agent para recuperar primero el agente de servicio de Cloud Storage.
```
SERVICE_ACCOUNT_STORAGE="$(gcloud storage service-agent --project=PROJECT_ID)"

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:$SERVICE_ACCOUNT_STORAGE \
    --role=roles/pubsub.publisher
```

Crea una base de datos de Firestore

Firestore almacena tus datos en documentos que contienen campos que se asignan a valores. Estos documentos se almacenan en colecciones, que son contenedores para tus documentos y que puedes usar para organizar tus datos y compilar consultas. Obtén más información sobre Firestore.

Ten en cuenta que cada proyecto de Google Cloud tiene un límite de una base de datos de Firestore. Completa los siguientes pasos si necesitas crear una base de datos nueva.

Console

En la consola de Google Cloud, ve a la página Introducción de Firestore.

Ve a Comenzar
Haz clic en Seleccionar modo nativo.

Si quieres obtener orientación para seleccionar un modo de bases de datos y ver una comparación entre características, consulta la página sobre las consideraciones para elegir entre el modo nativo y el modo Datastore.
En la lista Seleccionar una ubicación, elige nam5 (Estados Unidos).

La ubicación se aplica a la base de datos de Firestore y a la aplicación de App Engine en tu proyecto de Google Cloud. Una vez que crees tu base de datos, no podrás cambiar la ubicación.
Haz clic en Crear base de datos.

gcloud

Para crear una base de datos de Firestore, primero debes crear una aplicación de App Engine y, luego, ejecutar el comando gcloud firestore databases create:

gcloud app create --region=us-central
gcloud firestore databases create --region=us-central

Puedes ignorar la advertencia us-central is not a valid Firestore location. App Engine y Firestore admiten las mismas ubicaciones, pero la región us-central (Iowa) de App Engine se asigna a la multirregión nam5 (Estados Unidos) de Firestore.

Crea un tema de Pub/Sub

En este instructivo, se usa Pub/Sub como fuente de eventos. Crea un tema de Pub/Sub para poder publicar un mensaje en él. Obtén más información para crear y administrar temas.

Console

En la consola de Google Cloud, ve a la página Temas de Pub/Sub.

Ir a temas
Haz clic en Crear tema.
En el campo ID de tema, ingresa topic-callback.
Acepta los otros valores predeterminados.
Haz clic en Crear tema.

gcloud

Para crear un tema, ejecuta el comando gcloud pubsub topics create:

gcloud pubsub topics create topic-callback

Cree un bucket de Cloud Storage

En este instructivo, se usa Cloud Storage como fuente del evento. Crea un bucket de Cloud Storage para poder subir un archivo a él. Obtén más información para crear buckets de almacenamiento.

Console

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

Ir a Cloud Storage
Haz clic en Crear.
En Nombre de tu bucket, ingresa PROJECT_ID-bucket-callback.

El ID del proyecto se usa en el flujo de trabajo de callback-event-sample para identificar el bucket.
Haga clic en Continuar.
En Tipo de ubicación, selecciona Región y, luego, us-central1 (Iowa).
Acepta los otros valores predeterminados.
Haz clic en Crear.

gcloud

Para crear un bucket, ejecuta el comando gcloud storage buckets create:

gcloud storage buckets create gs://PROJECT_ID-bucket-callback \
    --location=us-central1

El ID del proyecto se usa en el flujo de trabajo de callback-event-sample para identificar el bucket.

Después de crear las fuentes de eventos, puedes implementar el flujo de trabajo del receptor de eventos.

Implementa un flujo de trabajo que detecte eventos

El flujo de trabajo de callback-event-listener se activa cuando se publica un mensaje en un tema de Pub/Sub o cuando se sube un archivo a un bucket de Cloud Storage. El flujo de trabajo recibe el evento, recupera los detalles de la devolución de llamada adecuados de la base de datos de Firestore y, luego, envía una solicitud HTTP al extremo de devolución de llamada.

Console

En la consola de Google Cloud, ve a la página Flujos de trabajo:

Ir a Workflows
Haz clic en Crear.
Ingresa un nombre para el flujo de trabajo nuevo: callback-event-listener.
En la lista Región, selecciona us-central1.
Selecciona la Cuenta de servicio que creaste antes.
Haz clic en Siguiente.

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

main:
  params: [event]
  steps:
    - log_event:
        call: sys.log
        args:
          text: ${event}
          severity: INFO
    - init:
        assign:
          - database_root: ${"projects/" + sys.get_env("GOOGLE_CLOUD_PROJECT_ID") + "/databases/(default)/documents/callbacks/"}
          - event_source_tokens: ${text.split(event.source, "/")}
          - event_source_len: ${len(event_source_tokens)}
          - event_source: ${event_source_tokens[event_source_len - 1]}
          - doc_name: ${database_root + event_source}
    - get_document_for_event_source:
        try:
          call: googleapis.firestore.v1.projects.databases.documents.get
          args:
            name: ${doc_name}
          result: document
        except:
            as: e
            steps:
                - known_errors:
                    switch:
                    - condition: ${e.code == 404}
                      return: ${"No callbacks for event source " + event_source}
                - unhandled_exception:
                    raise: ${e}
    - process_callback_urls:
        steps:
          - check_fields_exist:
              switch:
              - condition: ${not("fields" in document)}
                return: ${"No callbacks for event source " + event_source}
              - condition: true
                next: processFields
          - processFields:
              for:
                  value: key
                  in: ${keys(document.fields)}
                  steps:
                      - extract_callback_url:
                          assign:
                              - callback_url: ${document.fields[key]["stringValue"]}
                      - log_callback_url:
                          call: sys.log
                          args:
                            text: ${"Calling back url " + callback_url}
                            severity: INFO
                      - http_post:
                          call: http.post
                          args:
                              url: ${callback_url}
                              auth:
                                  type: OAuth2
                              body:
                                  event: ${event}

Haz clic en Implementar.

gcloud

Crea un archivo de código fuente para tu flujo de trabajo:
```
touch callback-event-listener.yaml
```

En un editor de texto, copia el siguiente flujo de trabajo en tu archivo de código fuente:

main:
  params: [event]
  steps:
    - log_event:
        call: sys.log
        args:
          text: ${event}
          severity: INFO
    - init:
        assign:
          - database_root: ${"projects/" + sys.get_env("GOOGLE_CLOUD_PROJECT_ID") + "/databases/(default)/documents/callbacks/"}
          - event_source_tokens: ${text.split(event.source, "/")}
          - event_source_len: ${len(event_source_tokens)}
          - event_source: ${event_source_tokens[event_source_len - 1]}
          - doc_name: ${database_root + event_source}
    - get_document_for_event_source:
        try:
          call: googleapis.firestore.v1.projects.databases.documents.get
          args:
            name: ${doc_name}
          result: document
        except:
            as: e
            steps:
                - known_errors:
                    switch:
                    - condition: ${e.code == 404}
                      return: ${"No callbacks for event source " + event_source}
                - unhandled_exception:
                    raise: ${e}
    - process_callback_urls:
        steps:
          - check_fields_exist:
              switch:
              - condition: ${not("fields" in document)}
                return: ${"No callbacks for event source " + event_source}
              - condition: true
                next: processFields
          - processFields:
              for:
                  value: key
                  in: ${keys(document.fields)}
                  steps:
                      - extract_callback_url:
                          assign:
                              - callback_url: ${document.fields[key]["stringValue"]}
                      - log_callback_url:
                          call: sys.log
                          args:
                            text: ${"Calling back url " + callback_url}
                            severity: INFO
                      - http_post:
                          call: http.post
                          args:
                              url: ${callback_url}
                              auth:
                                  type: OAuth2
                              body:
                                  event: ${event}

Para implementar el flujo de trabajo, ingresa el siguiente comando:

gcloud workflows deploy callback-event-listener \
    --source=callback-event-listener.yaml \
    --location=us-central1 \
    --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

Reemplaza SERVICE_ACCOUNT_NAME por el nombre de la cuenta de servicio que creaste anteriormente.

Implementa un flujo de trabajo que espere eventos

El flujo de trabajo de callback-event-sample almacena los detalles de la devolución de llamada en una base de datos de Firestore, detiene su ejecución y, luego, espera a que ocurran eventos específicos.

Console

En la consola de Google Cloud, ve a la página Flujos de trabajo:

Ir a Workflows
Haz clic en Crear.
Ingresa un nombre para el flujo de trabajo nuevo: callback-event-sample.
En la lista Región, selecciona us-central1.
Selecciona la Cuenta de servicio que creaste antes.
Haz clic en Siguiente.

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

main:
  steps:
    - init:
        assign:
          - pubsub_topic: topic-callback
          - storage_bucket: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID") + "-bucket-callback"}
    - await_pubsub_message:
        call: await_callback_event
        args:
          event_source: ${pubsub_topic}
        result: pubsub_event
    - await_storage_bucket:
        call: await_callback_event
        args:
          event_source: ${storage_bucket}
        result: storage_event
    - return_events:
        return:
            pubsub_event: ${pubsub_event}
            storage_event: ${storage_event}

await_callback_event:
    params: [event_source]
    steps:
        - init:
            assign:
              - database_root: ${"projects/" + sys.get_env("GOOGLE_CLOUD_PROJECT_ID") + "/databases/(default)/documents/callbacks/"}
              - doc_name: ${database_root + event_source}
              - execution_id: ${sys.get_env("GOOGLE_CLOUD_WORKFLOW_EXECUTION_ID")}
              - firestore_key: ${"exec_" + text.split(execution_id, "-")[0]}
        - create_callback:
            call: events.create_callback_endpoint
            args:
              http_callback_method: POST
            result: callback_details
        - save_callback_url:
            call: googleapis.firestore.v1.projects.databases.documents.patch
            args:
              name: ${doc_name}
              updateMask:
                fieldPaths: ["${firestore_key}"]
              body:
                fields:
                  ${firestore_key}:
                    stringValue: ${callback_details.url}
        - log_and_await_callback:
            try:
              steps:
                - log_await_start:
                    call: sys.log
                    args:
                      severity: INFO
                      data: ${"Started waiting 1hr for an event from source " + event_source}
                - await_callback:
                    call: events.await_callback
                    args:
                      callback: ${callback_details}
                      timeout: 3600
                    result: callback_request
                - log_await_stop:
                    call: sys.log
                    args:
                      severity: INFO
                      data: ${"Stopped waiting for an event from source " + event_source}
            except:
                as: e
                steps:
                    - log_error:
                        call: sys.log
                        args:
                            severity: "ERROR"
                            text: ${"Received error " + e.message}
        - delete_callback_url:
            call: googleapis.firestore.v1.projects.databases.documents.patch
            args:
              name: ${doc_name}
              updateMask:
                fieldPaths: ["${firestore_key}"]
        - check_null_event:
            switch:
              - condition: ${callback_request == null}
                return: null
        - log_await_result:
            call: sys.log
            args:
              severity: INFO
              data: ${callback_request.http_request.body.event}
        - return_event:
            return: ${callback_request.http_request.body.event}

Haz clic en Implementar.

gcloud

Crea un archivo de código fuente para tu flujo de trabajo:
```
touch callback-event-sample.yaml
```

En un editor de texto, copia el siguiente flujo de trabajo en tu archivo de código fuente:

main:
  steps:
    - init:
        assign:
          - pubsub_topic: topic-callback
          - storage_bucket: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID") + "-bucket-callback"}
    - await_pubsub_message:
        call: await_callback_event
        args:
          event_source: ${pubsub_topic}
        result: pubsub_event
    - await_storage_bucket:
        call: await_callback_event
        args:
          event_source: ${storage_bucket}
        result: storage_event
    - return_events:
        return:
            pubsub_event: ${pubsub_event}
            storage_event: ${storage_event}

await_callback_event:
    params: [event_source]
    steps:
        - init:
            assign:
              - database_root: ${"projects/" + sys.get_env("GOOGLE_CLOUD_PROJECT_ID") + "/databases/(default)/documents/callbacks/"}
              - doc_name: ${database_root + event_source}
              - execution_id: ${sys.get_env("GOOGLE_CLOUD_WORKFLOW_EXECUTION_ID")}
              - firestore_key: ${"exec_" + text.split(execution_id, "-")[0]}
        - create_callback:
            call: events.create_callback_endpoint
            args:
              http_callback_method: POST
            result: callback_details
        - save_callback_url:
            call: googleapis.firestore.v1.projects.databases.documents.patch
            args:
              name: ${doc_name}
              updateMask:
                fieldPaths: ["${firestore_key}"]
              body:
                fields:
                  ${firestore_key}:
                    stringValue: ${callback_details.url}
        - log_and_await_callback:
            try:
              steps:
                - log_await_start:
                    call: sys.log
                    args:
                      severity: INFO
                      data: ${"Started waiting 1hr for an event from source " + event_source}
                - await_callback:
                    call: events.await_callback
                    args:
                      callback: ${callback_details}
                      timeout: 3600
                    result: callback_request
                - log_await_stop:
                    call: sys.log
                    args:
                      severity: INFO
                      data: ${"Stopped waiting for an event from source " + event_source}
            except:
                as: e
                steps:
                    - log_error:
                        call: sys.log
                        args:
                            severity: "ERROR"
                            text: ${"Received error " + e.message}
        - delete_callback_url:
            call: googleapis.firestore.v1.projects.databases.documents.patch
            args:
              name: ${doc_name}
              updateMask:
                fieldPaths: ["${firestore_key}"]
        - check_null_event:
            switch:
              - condition: ${callback_request == null}
                return: null
        - log_await_result:
            call: sys.log
            args:
              severity: INFO
              data: ${callback_request.http_request.body.event}
        - return_event:
            return: ${callback_request.http_request.body.event}

Para implementar el flujo de trabajo, ingresa el siguiente comando:

gcloud workflows deploy callback-event-sample \
    --source=callback-event-sample.yaml \
    --location=us-central1 \
    --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

Reemplaza SERVICE_ACCOUNT_NAME por el nombre de la cuenta de servicio que creaste anteriormente.

Crea un activador de Eventarc para enrutar eventos de Pub/Sub

Un activador de Eventarc te permite enrutar eventos especificando filtros para el activador, incluida la fuente del evento y el flujo de trabajo de destino. Crea un activador de Eventarc para ejecutar el flujo de trabajo de callback-event-listener como resultado de la publicación de un mensaje en un tema de Pub/Sub. Obtén más información para activar un flujo de trabajo.

Console

En la consola de Google Cloud, ve a la página Eventarc.

Ve a Eventarc
Haz clic en Crear activador.
Escribe un nombre de activador.

Por ejemplo, trigger-pubsub-events-listener.
En la lista Proveedor de eventos, selecciona Cloud Pub/Sub.
En la lista Evento, en Personalizado, selecciona google.cloud.pubsub.topic.v1.messagePublished.
En la lista Selecciona un tema de Cloud Pub/Sub, selecciona el tema que creaste anteriormente.
En la lista Región, selecciona us-central1 (Iowa).
Si se te solicita, otorga el rol iam.serviceAccountTokenCreator a la cuenta de servicio de Pub/Sub.
Selecciona la Cuenta de servicio que creaste antes.
En la lista Destino del evento, selecciona Flujo de trabajo.
En la lista Seleccionar un flujo de trabajo, selecciona el flujo de trabajo callback-event-listener.
Haz clic en Crear.

gcloud

Para crear un activador, ejecuta el comando gcloud eventarc triggers create:

gcloud eventarc triggers create trigger-pubsub-events-listener \
    --location=us-central1 \
    --destination-workflow=callback-event-listener \
    --destination-workflow-location=us-central1 \
    --event-filters="type=google.cloud.pubsub.topic.v1.messagePublished" \
    --transport-topic=topic-callback \
    --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

Los eventos se transforman y se pasan a la ejecución del flujo de trabajo como argumentos del entorno de ejecución. Ten en cuenta que el activador nuevo puede tardar hasta 2 minutos en activarse.

Crea un activador de Eventarc para enrutar eventos de Cloud Storage

Un activador de Eventarc te permite enrutar eventos especificando filtros para el activador, incluida la fuente del evento y el flujo de trabajo de destino. Crea un activador de Eventarc para ejecutar el flujo de trabajo de callback-event-listener como resultado de subir un archivo a un bucket de Cloud Storage. Obtén más información para activar un flujo de trabajo.

Console

En la consola de Google Cloud, ve a la página Eventarc.

Ve a Eventarc
Haz clic en Crear activador.
Escribe un nombre de activador.

Por ejemplo, trigger-storage-events-listener.
En la lista Proveedor de eventos, selecciona Cloud Storage.
En la lista Evento, en Directo, selecciona google.cloud.storage.object.v1.finalized.
En la lista Bucket, busca el bucket que creaste anteriormente y selecciónalo.
En la lista Región, según tu bucket de Cloud Storage, acepta la opción predeterminada us-central1 (Iowa).
Si se te solicita, otorga el rol iam.serviceAccountTokenCreator a la cuenta de servicio de Pub/Sub.
Selecciona la Cuenta de servicio que creaste antes.
En la lista Destino del evento, selecciona Flujo de trabajo.
En la lista Seleccionar un flujo de trabajo, selecciona el flujo de trabajo callback-event-listener.
Haz clic en Crear.

gcloud

Para crear un activador, ejecuta el comando gcloud eventarc triggers create:

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

Los eventos se transforman y se pasan a la ejecución del flujo de trabajo como argumentos del entorno de ejecución. Ten en cuenta que el activador nuevo puede tardar hasta 2 minutos en activarse.

Ejecuta el flujo de trabajo principal

Ejecuta la definición actual del flujo de trabajo asociada con el flujo de trabajo. Ejecuta el flujo de trabajo callback-event-sample. Este es el flujo de trabajo principal y espera a que ocurran eventos específicos, y solo reanuda su ejecución cuando el flujo de trabajo secundario realiza las solicitudes de devolución de llamada adecuadas.

Console

En la consola de Google Cloud, ve a la página Flujos de trabajo.

Ir a Workflows
En la página Flujos de trabajo, haz clic en el flujo de trabajo callback-event-sample para ir a su página de detalles.
En la página Detalles del flujo de trabajo, haz clic en Ejecutar.
Haz clic de nuevo en Ejecutar.

Comienza la ejecución del flujo de trabajo. Mientras se ejecuta la ejecución, deberías ver un estado de ejecución de Running y una entrada de registro similar a la siguiente: Started waiting 1hr for an event from source topic-callback.

gcloud

Para ejecutar un flujo de trabajo, ejecuta el comando gcloud workflows run:

gcloud workflows run callback-event-sample \
    --location=us-central1

Comienza la ejecución del flujo de trabajo. Mientras se ejecuta la ejecución, deberías ver un estado de ejecución similar al siguiente:

Waiting for execution [a848a164-268a-449c-b2fe-396f32f2ed66] to complete...working...

Genera eventos y verifica el estado de ejecución

Para confirmar que los resultados sean los esperados, genera eventos, consulta las entradas de registro y verifica el estado de ejecución del flujo de trabajo.

Publicar un mensaje

Publica un mensaje en el tema de Pub/Sub que creaste antes.

Console

En la consola de Google Cloud, ve a la página Temas de Pub/Sub.

Ir a temas
Haz clic en topic-callback.
Haz clic en la pestaña Mensajes.
Haz clic en Publish message.
En el campo Cuerpo del mensaje, ingresa Hello World.
Haz clic en Publicar.

gcloud

Para publicar un mensaje, usa el comando gcloud pubsub topics publish:

gcloud pubsub topics publish topic-callback \
    --message="Hello World"

Subir un objeto

Sube un archivo al bucket de Cloud Storage que creaste antes.

Console

En la consola de Google Cloud, ve a la página Buckets de Cloud Storage.
Ir a Buckets
Haz clic en el nombre del bucket que creaste anteriormente.
En la pestaña Objetos, realiza una de las siguientes acciones:
- Arrastra y suelta el archivo deseado desde tu escritorio o administrador de archivos en el panel principal de la consola de Google Cloud.
- Haz clic en Subir archivos, selecciona el archivo que deseas subir y, luego, haz clic en Abrir.

gcloud

Para subir un archivo, ejecuta el comando gcloud storage cp:

gcloud storage cp OBJECT_LOCATION gs://PROJECT_ID-bucket-callback/

Reemplaza OBJECT_LOCATION por la ruta de acceso local a tu objeto. Por ejemplo, random.txt

Cómo ver las entradas de registro y el estado de ejecución

Confirma que el flujo de trabajo de callback-event-sample se haya completado correctamente.

Console

En la consola de Google Cloud, ve a la página Flujos de trabajo.

Ir a Workflows
En la página Flujos de trabajo, haz clic en el flujo de trabajo callback-event-sample para ir a su página de detalles.
En la página Detalles del flujo de trabajo, para recuperar los detalles de una ejecución en particular, haz clic en el ID de ejecución correspondiente.

El estado de ejecución debería ser Correcto y, en el panel de salida, deberías ver los eventos de Pub/Sub y Cloud Storage recibidos.

gcloud

Filtra las entradas de registro y muestra el resultado en formato JSON:

gcloud logging read "resource.type=workflows.googleapis.com/Workflow AND textPayload:calling OR textPayload:waiting" \
    --format=json

Busca entradas de registro similares a las siguientes:

"textPayload": "Stopped waiting for an event from source..."
"textPayload": "Calling back url https://workflowexecutions.googleapis.com/v1/projects/..."
"textPayload": "Started waiting 1hr for an event from source..."

Verifica el estado del último intento de ejecución:

gcloud workflows executions wait-last

El resultado debería ser similar al siguiente:

Using cached execution name: projects/1085953646031/locations/us-central1/workflows/callback-event-sample/executions/79929e4e-82c1-4da1-b068-f828034c01b7
Waiting for execution [79929e4e-82c1-4da1-b068-f828034c01b7] to complete...done.
[...]
state: SUCCEEDED

Realiza una limpieza

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, sigue estos pasos:

Precaución: Borrar un proyecto tiene las siguientes 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.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Borra los recursos creados en este instructivo

¿Qué sigue?

Prueba el instructivo Crea un flujo de trabajo con un humano en el ciclo mediante devoluciones de llamada.