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

Espera 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 a que otro servicio envíe una solicitud a un extremo de devolución de llamada. Esa solicitud reanuda la ejecución del flujo de trabajo. También puedes esperar a usar el sondeo.

En lugar de usar el sondeo, 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, se recomienda detener esa ejecución y 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 otro evento que indique que el proceso se completó. Para implementarlo, haz que un flujo de trabajo llame a otro.

Objetivos

En este instructivo, ocurre lo siguiente:

Se implementa y ejecuta un flujo de trabajo principal que necesita 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 recuperar los detalles. Luego, el flujo de trabajo principal espera las llamadas HTTP.
Los eventos activan un flujo de trabajo secundario que recupera 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 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 URL de extremo de devolución de llamada correspondientes 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 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 bien con Google Cloud CLI en tu 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 otórgale 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 una función, filtra según las siguientes funciones que se otorgarán 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 (Datastore).
  - Receptor de eventos de Eventarc: Para recibir eventos de proveedores de eventos
  - Escritor de registros: Para escribir registros
  - Invocador de flujos de trabajo: Se usa 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 tu proyecto. Puedes revocar estas funciones o otorgar funciones adicionales más adelante. En entornos de producción, no otorgues las funciones de propietario, editor o visualizador. En su lugar, otorga un rol predefinido o rol personalizado que satisfaga tus necesidades.
6. Haz 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

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.
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 API 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 otórgale las funciones adecuadas.
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 una de las siguientes funciones de IAM:
  - roles/datastore.user: Para acceder a los datos de Firestore en modo Datastore (Datastore).
  - roles/eventarc.eventReceiver: Se usa 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 tu proyecto. Puedes revocar estas funciones o otorgar funciones adicionales más adelante. En entornos de producción, no otorgues las funciones de propietario, editor o visualizador. En su lugar, otorga un rol predefinido o 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 gsutil kms serviceaccount para recuperar primero el agente de servicio de Cloud Storage.
```
SERVICE_ACCOUNT_STORAGE="$(gsutil kms serviceaccount -p 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 los datos en documentos que contienen campos asignados a valores. Estos documentos se almacenan en colecciones, que son contenedores de tus documentos 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 está limitado a 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 Comenzar de Firestore.

Ir a Comenzar
Haz clic en Elegir modo nativo.

Para obtener orientación sobre cómo seleccionar un modo de base de datos y ver una comparación de características, consulta Elige 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 el proyecto de Google Cloud. Una vez que crees la 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 de Firestore (Estados Unidos).

Crear un tema de Pub/Sub

En este instructivo, se usa Pub/Sub como una fuente de eventos. Crear 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 del 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

Crea un bucket de Cloud Storage

En este instructivo, se usa Cloud Storage como una fuente de eventos. Crea un bucket de Cloud Storage para subir un archivo en é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 del bucket, ingresa PROJECT_ID-bucket-callback.

El ID del proyecto se usa en el flujo de trabajo callback-event-sample para identificar el bucket.
Haz 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 callback-event-sample para identificar el bucket.

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

Implementa un flujo de trabajo que detecte eventos

El flujo de trabajo 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 devolución de llamada correspondientes 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 anteriormente.
Haz clic en Siguiente.

En el editor de flujo 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 antes.

Implementa un flujo de trabajo que espera eventos

El flujo de trabajo callback-event-sample almacena los detalles de 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 anteriormente.
Haz clic en Siguiente.

En el editor de flujo 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 antes.

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. Crear un activador de Eventarc para ejecutar el flujo de trabajo 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 del evento, 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, elige el tema que creaste antes.
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 anteriormente.
En la lista Destino del evento, selecciona Flujos de trabajo.
En la lista Selecciona un flujo de trabajo, elige 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. Crear un activador de Eventarc para ejecutar el flujo de trabajo 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 del evento, 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 antes y selecciónalo.
En la lista Región, según tu bucket de Cloud Storage, acepta el valor predeterminado de 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 anteriormente.
En la lista Destino del evento, selecciona Flujos de trabajo.
En la lista Selecciona un flujo de trabajo, elige 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

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

Console

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

Ir a Workflows
En la página Workflows, haz clic en el flujo de trabajo callback-event-sample para ir a la 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

Puedes confirmar que los resultados son los esperados: genera eventos, visualiza 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 Publish (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 anteriormente.

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 que desees 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 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

Visualiza 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 Workflows, haz clic en el flujo de trabajo callback-event-sample para ir a la página de detalles.
En la página Detalles del flujo de trabajo, haz clic en el ID de ejecución correspondiente para recuperar los detalles de una ejecución en particular.

El Estado de ejecución debería ser Sin errores y, en el panel 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

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.

En la consola de Google Cloud, ve a la página Administrar recursos.
Ir a Administrar recursos
En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

Borra los recursos que se crearon en este instructivo

¿Qué sigue?

Prueba el instructivo Crea un flujo de trabajo con interacción humana mediante devoluciones de llamada.