Aguarde eventos através de chamadas de retorno e acionadores do Eventarc

---

O fluxo de trabalho pode ter de aguardar um processo externo. Pode usar callbacks HTTP para aguardar que outro serviço faça um pedido a um ponto final de callback. Esse pedido retoma a execução do fluxo de trabalho. Também pode aguardar através da sondagem.

Em vez de usar a sondagem, este tutorial demonstra como pode aguardar eventos ou mensagens do Pub/Sub usando callbacks HTTP e acionadores do Eventarc. Embora possa acionar um fluxo de trabalho com eventos ou mensagens do Pub/Sub, pode querer interromper essa execução para aguardar outro evento antes de continuar. Por exemplo, um evento aciona um fluxo de trabalho para iniciar um processo, mas o fluxo de trabalho tem de aguardar outro evento que indique que o processo está concluído. Pode implementar esta situação fazendo com que um fluxo de trabalho chame outro fluxo de trabalho.

Objetivos

Neste tutorial, ocorre o seguinte:

1. Um fluxo de trabalho principal que precisa de aguardar eventos é implementado e executado. Como tem de aguardar que os eventos ocorram, armazena os detalhes da chamada de retorno numa base de dados do Firestore para que o fluxo de trabalho secundário possa obter os detalhes. O fluxo de trabalho principal aguarda então as chamadas HTTP.

2. Um fluxo de trabalho secundário é acionado pelos eventos e obtém os detalhes de retorno de chamada da base de dados do Firestore quando os eventos são gerados. Em seguida, o fluxo de trabalho secundário chama o fluxo de trabalho principal, que retoma a execução.

Segue-se uma vista geral de todo o processo:

Fluxo de trabalho principal:

1. Um fluxo de trabalho callback-event-sample cria pontos finais de retorno de chamada para duas origens de eventos: um tópico do Pub/Sub e um contentor do Cloud Storage.
2. Este fluxo de trabalho armazena ambos os pontos finais de callback num documento do Firestore.
3. Este fluxo de trabalho interrompe a execução e aguarda que os pedidos HTTP cheguem aos pontos finais de retorno de chamada.

Eventos:

4. Os eventos ocorrem quando é publicada uma mensagem num tópico do Pub/Sub e é carregado um ficheiro para um contentor do Cloud Storage.

Fluxo de trabalho secundário:

5. O Eventarc encaminha os eventos para o fluxo de trabalho callback-event-listener e aciona a respetiva execução.
6. Este fluxo de trabalho extrai os URLs do ponto final de callback adequados do documento do Firestore.
7. Este fluxo de trabalho executa os callbacks para os pontos finais adequados no fluxo de trabalho de exemplo.

Fluxo de trabalho principal:

8. O fluxo de trabalho callback-event-sample recebe os eventos nos pontos finais de chamada de retorno e retoma a execução.
9. Este fluxo de trabalho elimina os URLs de callback do documento do Firestore e conclui a respetiva execução.

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

• Eventarc
• Firestore
• Pub/Sub
• Cloud Storage
• Workflows

Para gerar uma estimativa de custos com base na sua utilização projetada, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação gratuita.

Antes de começar

Pode executar os seguintes comandos na Google Cloud consola ou através da CLI Google Cloud no terminal ou no Cloud Shell.

As restrições de segurança definidas pela sua organização podem impedir a conclusão dos seguintes passos. Para informações de resolução de problemas, consulte o artigo Desenvolva aplicações num ambiente Google Cloud restrito.

Consola

1. Na Google Cloud consola, na página do seletor de projetos, selecione ou crie um Google Cloud projeto.

   Nota: se não planeia manter os recursos que criar neste procedimento, crie um projeto em vez de selecionar um projeto existente. Depois de concluir estes passos, pode eliminar o projeto, removendo todos os recursos associados ao projeto.

   Aceder ao seletor de projetos

2. Certifique-se de que a faturação está ativada para o seu Google Cloud projeto. Saiba como verificar se a faturação está ativada num projeto.

3. Ative as APIs App Engine, Eventarc, Firestore, Pub/Sub e Workflows.

   Ative as APIs

4. Crie uma conta de serviço para o seu fluxo de trabalho usar para autenticação com outros Google Cloud serviços e conceda-lhe as funções adequadas:

   1. Na Google Cloud consola, aceda à página Contas de serviço.

      Aceda a Contas de serviço

   2. Para aceder à página Criar conta de serviço, selecione o seu projeto.

   3. No campo Nome da conta de serviço, introduza um nome. A Google Cloud consola preenche o campo ID da conta de serviço com base neste nome.

      No campo Descrição da conta de serviço, introduza uma descrição. Por exemplo, Service account for tutorial.

   4. Clique em Criar e continuar.

   5. Na lista Selecionar uma função, filtre as seguintes funções para conceder à conta de serviço gerida pelo utilizador que criou no passo anterior:

      • Utilizador do Cloud Datastore: para aceder aos dados do Firestore no modo Datastore (Datastore).
      • Event Receiver do Eventarc: para receber eventos de fornecedores de eventos.
      • Escritor de registos: para escrever registos.
      • Workflows Invoker: para executar fluxos de trabalho e gerir as execuções.

      Para funções adicionais, clique em Adicionar outra função e adicione cada função adicional.

      Nota: o campo Função afeta os recursos aos quais a sua conta de serviço pode aceder no seu projeto. Pode revogar estas funções ou conceder funções adicionais mais tarde. Em ambientes de produção, não conceda as funções de proprietário, editor ou leitor. Em alternativa, conceda uma função predefinida ou uma função personalizada que satisfaça as suas necessidades.

   6. Clique em Continuar.

   7. Para concluir a criação da conta, clique em Concluído.

5. Para criar um acionador do Eventarc que encaminha eventos do Cloud Storage, conceda a função Publicador do Pub/Sub ao agente de serviço do Cloud Storage. Normalmente, este valor é de [e-mail]. Pode obter o endereço de email do agente do serviço Cloud Storage.

   1. Na Google Cloud consola, aceda à página IAM.

      Aceda ao IAM

   2. Na linha do agente do serviço Cloud Storage, clique em Editar principal. (Se o agente de serviços não estiver listado, avance para o passo seguinte.) É aberto o painel Editar acesso.

      1. Clique em Adicionar outra função e, de seguida, pesquise a função Publicador do Pub/Sub.
      2. Selecione a função.
      3. Clique em Guardar.

   3. Se o agente de serviços não estiver na lista, clique em Conceder acesso. O painel Conceder acesso é aberto.

      1. No campo Novos membros, introduza o endereço de email do agente de serviço.
      2. Na lista Selecionar uma função, pesquise a função Publicador do Pub/Sub.
      3. Selecione a função.
      4. Clique em Guardar.

gcloud

1. 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.

2. Certifique-se de que a faturação está ativada para o seu Google Cloud projeto. Saiba como verificar se a faturação está ativada num projeto.

3. Ative as APIs App Engine, Eventarc, Firestore, Pub/Sub e Workflows.

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

4. Crie uma conta de serviço para o seu fluxo de trabalho usar para autenticação com outros Google Cloud serviços e conceda-lhe as funções adequadas.

   1. Crie a conta de serviço:

      gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

      Substitua SERVICE_ACCOUNT_NAME por um nome para a conta de serviço.

   2. Conceda funções à conta de serviço gerida pelo utilizador que criou no passo anterior. Execute o seguinte comando uma vez para cada uma das seguintes funções do IAM:

      • roles/datastore.user: para aceder ao Firestore no modo Datastore (Datastore) data.
      • roles/eventarc.eventReceiver: para receber eventos de fornecedores de eventos.
      • roles/logging.logWriter: para escrever registos.
      • roles/workflows.invoker: para executar fluxos de trabalho e gerir as execuções.

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

      Substitua o seguinte:

      • PROJECT_ID: o ID do projeto onde criou a conta de serviço
      • ROLE: a função a conceder
      Nota: a flag --role afeta os recursos aos quais a sua conta de serviço pode aceder no seu projeto. Pode revogar estas funções ou conceder funções adicionais mais tarde. Em ambientes de produção, não conceda as funções de proprietário, editor ou leitor. Em alternativa, conceda uma função predefinida ou uma função personalizada que satisfaça as suas necessidades.

5. Para criar um acionador do Eventarc que encaminhe eventos do Cloud Storage, conceda a função Publicador do Pub/Sub ao agente de serviço do Cloud Storage. Normalmente, este valor é de [e-mail]. Use gcloud storage service-agent para obter primeiro o agente do serviço do 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

Crie uma base de dados do Firestore

O Firestore armazena os seus dados em documentos que contêm campos mapeados para valores. Estes documentos são armazenados em coleções, que são contentores para os seus documentos que pode usar para organizar os seus dados e criar consultas. Saiba mais sobre o Firestore.

Tenha em atenção que cada Google Cloud projeto está limitado a uma base de dados do Firestore. Conclua os passos seguintes se precisar de criar uma nova base de dados.

Consola

1. Na Google Cloud consola, aceda à página do Firestore Começar.

   Aceder a Começar

2. Clique em Selecionar modo nativo.

   Para orientações sobre a seleção de um modo de base de dados e uma comparação detalhada das funcionalidades, consulte o artigo Escolher entre o modo nativo e o modo Datastore.

3. Na lista Selecionar uma localização, selecione nam5 (Estados Unidos).

   A localização aplica-se à base de dados do Firestore e à aplicação do App Engine no seu Google Cloud projeto. Depois de criar a base de dados, não pode alterar a localização.

4. Clique em Criar base de dados.

gcloud

Para criar uma base de dados do Firestore, primeiro tem de criar uma aplicação do App Engine e, em seguida, executar o comando gcloud firestore databases create:

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

Pode ignorar o aviso us-central is not a valid Firestore location. O App Engine e o Firestore suportam as mesmas localizações, mas a região us-central (Iowa) do App Engine é mapeada para a multirregião nam5 (Estados Unidos) do Firestore.

Crie um tópico do Pub/Sub

Este tutorial usa o Pub/Sub como origem de eventos. Crie um tópico do Pub/Sub para poder publicar uma mensagem no mesmo. Saiba mais sobre como criar e gerir tópicos.

Consola

1. Na Google Cloud consola, aceda à página Tópicos do Pub/Sub.

   Aceda a Tópicos

2. Clique em Criar tópico.

3. No campo ID do tópico, introduza topic-callback.

4. Aceite as outras predefinições.

5. Clique em Criar tópico.

gcloud

Para criar um tópico, execute o comando gcloud pubsub topics create:

gcloud pubsub topics create topic-callback

Crie um contentor do Cloud Storage

Este tutorial usa o Cloud Storage como uma origem de eventos. Crie um contentor do Cloud Storage para poder carregar um ficheiro para o mesmo. Saiba como criar contentores de armazenamento.

Consola

1. Na Google Cloud consola, aceda à página Recipientes do Cloud Storage.

   Aceda ao Cloud Storage

2. Clique em Criar.

3. Para o Nome do seu contentor, introduza PROJECT_ID-bucket-callback.

   O ID do projeto é usado no fluxo de trabalho callback-event-sample para identificar o contentor.

4. Clique em Continuar.

5. Para Tipo de localização, selecione Região e, de seguida, selecione us-central1 (Iowa).

6. Aceite as outras predefinições.

7. Clique em Criar.

gcloud

Para criar um contentor, execute o comando gcloud storage buckets create:

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

O ID do projeto é usado no fluxo de trabalho callback-event-sample para identificar o contentor.

Depois de criar as origens de eventos, pode implementar o fluxo de trabalho do recetor de eventos.

Implemente um fluxo de trabalho que ouve eventos

O fluxo de trabalho callback-event-listener é acionado quando uma mensagem é publicada num tópico do Pub/Sub ou quando um ficheiro é carregado para um contentor do Cloud Storage. O fluxo de trabalho recebe o evento, obtém os detalhes de chamada de retorno adequados da base de dados do Firestore e, em seguida, envia um pedido HTTP para o ponto final de chamada de retorno.

Consola

1. Na Google Cloud consola, aceda à página Fluxos de trabalho:

   Aceda a Fluxos de trabalho

2. Clique em Criar.

3. Introduza um nome para o novo fluxo de trabalho: callback-event-listener.

4. Na lista Região, selecione us-central1.

5. Selecione a conta de serviço que criou anteriormente.

6. Clicar em Seguinte.

7. No editor de fluxos de trabalho, introduza a seguinte definição para o seu fluxo de trabalho:

   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}

8. Clique em Implementar.

gcloud

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

   touch callback-event-listener.yaml

2. Num editor de texto, copie o seguinte fluxo de trabalho para o ficheiro de código-fonte:

   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}

3. Implemente o fluxo de trabalho introduzindo o seguinte 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

   Substitua SERVICE_ACCOUNT_NAME pelo nome da conta de serviço que criou anteriormente.

Implemente um fluxo de trabalho que aguarda eventos

O fluxo de trabalho callback-event-sample armazena os detalhes da chamada de retorno numa base de dados do Firestore, interrompe a respetiva execução e, em seguida, aguarda a ocorrência de eventos específicos.

Consola

1. Na Google Cloud consola, aceda à página Fluxos de trabalho:

   Aceda a Fluxos de trabalho

2. Clique em Criar.

3. Introduza um nome para o novo fluxo de trabalho: callback-event-sample.

4. Na lista Região, selecione us-central1.

5. Selecione a conta de serviço que criou anteriormente.

6. Clicar em Seguinte.

7. No editor de fluxos de trabalho, introduza a seguinte definição para o seu fluxo de trabalho:

   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}

8. Clique em Implementar.

gcloud

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

   touch callback-event-sample.yaml

2. Num editor de texto, copie o seguinte fluxo de trabalho para o ficheiro de código-fonte:

   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}

3. Implemente o fluxo de trabalho introduzindo o seguinte 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

   Substitua SERVICE_ACCOUNT_NAME pelo nome da conta de serviço que criou anteriormente.

Crie um acionador do Eventarc para encaminhar eventos do Pub/Sub

Um acionador do Eventarc permite-lhe encaminhar eventos especificando filtros para o acionador, incluindo a origem do evento e o fluxo de trabalho de destino. Crie um acionador do Eventarc para executar o fluxo de trabalho callback-event-listener como resultado da publicação de uma mensagem num tópico do Pub/Sub. Saiba mais sobre como acionar um fluxo de trabalho.

Consola

1. Na Google Cloud consola, aceda à página Eventarc.

   Aceda ao Eventarc

2. Clique em Criar acionador.

3. Escreva um Nome do acionador.

   Por exemplo, trigger-pubsub-events-listener.

4. Na lista Fornecedor de eventos, selecione Cloud Pub/Sub.

5. Na lista Evento, em Personalizado, selecione google.cloud.pubsub.topic.v1.messagePublished.

6. Na lista Selecionar um tópico do Cloud Pub/Sub, selecione o tópico que criou anteriormente.

7. Na lista Região, selecione us-central1 (Iowa).

8. Se lhe for pedido, conceda a função iam.serviceAccountTokenCreator à conta de serviço do Pub/Sub.

9. Selecione a conta de serviço que criou anteriormente.

10. Na lista Destino do evento, selecione Fluxos de trabalho.

11. Na lista Selecionar um fluxo de trabalho, selecione o fluxo de trabalho callback-event-listener.

12. Clique em Criar.

gcloud

Para criar um acionador, execute o 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

Os eventos são transformados e transmitidos para a execução do fluxo de trabalho como argumentos de tempo de execução. Tenha em atenção que o novo acionador pode demorar até 2 minutos a ficar ativo.

Crie um acionador do Eventarc para encaminhar eventos do Cloud Storage

Um acionador do Eventarc permite-lhe encaminhar eventos especificando filtros para o acionador, incluindo a origem do evento e o fluxo de trabalho de destino. Crie um acionador do Eventarc para executar o fluxo de trabalho callback-event-listener como resultado do carregamento de um ficheiro para um contentor do Cloud Storage. Saiba mais sobre como acionar um fluxo de trabalho.

Consola

1. Na Google Cloud consola, aceda à página Eventarc.

   Aceda ao Eventarc

2. Clique em Criar acionador.

3. Escreva um Nome do acionador.

   Por exemplo, trigger-storage-events-listener.

4. Na lista Fornecedor de eventos, selecione Cloud Storage.

5. Na lista Evento, em Direto, selecione google.cloud.storage.object.v1.finalized.

6. Na lista Recipiente, procure o recipiente que criou anteriormente e selecione-o.

7. Na lista Região, com base no seu contentor do Cloud Storage, aceite a predefinição de us-central1 (Iowa).

8. Se lhe for pedido, conceda a função iam.serviceAccountTokenCreator à conta de serviço do Pub/Sub.

9. Selecione a conta de serviço que criou anteriormente.

10. Na lista Destino do evento, selecione Fluxos de trabalho.

11. Na lista Selecionar um fluxo de trabalho, selecione o fluxo de trabalho callback-event-listener.

12. Clique em Criar.

gcloud

Para criar um acionador, execute o 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

Os eventos são transformados e transmitidos para a execução do fluxo de trabalho como argumentos de tempo de execução. Tenha em atenção que o novo acionador pode demorar até 2 minutos a ficar ativo.

Execute o fluxo de trabalho principal

A execução de um fluxo de trabalho executa a definição do fluxo de trabalho atual associada ao fluxo de trabalho. Execute o fluxo de trabalho callback-event-sample. Este é o fluxo de trabalho principal e aguarda que ocorram eventos específicos, retomando a execução apenas quando o fluxo de trabalho secundário faz os pedidos de callback adequados.

Consola

1. Na Google Cloud consola, aceda à página Fluxos de trabalho.

   Aceda a Fluxos de trabalho

2. Na página Fluxos de trabalho, clique no fluxo de trabalho callback-event-sample para aceder à respetiva página de detalhes.

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

4. Clique novamente em Executar.

   A execução do fluxo de trabalho é iniciada. Enquanto a execução é realizada, deve ver um Estado de execução de Running e uma entrada de registo semelhante à seguinte: Started waiting 1hr for an event from source topic-callback.

gcloud

Para executar um fluxo de trabalho, execute o comando gcloud workflows run:

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

A execução do fluxo de trabalho é iniciada. Enquanto a execução é realizada, deve ver um estado de execução semelhante ao seguinte:

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

Gere eventos e verifique o estado de execução

Pode confirmar que os resultados são os esperados gerando eventos, vendo as entradas do registo e verificando o estado de execução do fluxo de trabalho.

Publicar uma mensagem

Publicar uma mensagem no tópico Pub/Sub que criou anteriormente.

Consola

1. Na Google Cloud consola, aceda à página Tópicos do Pub/Sub.

   Aceda a Tópicos

2. Clique em topic-callback.

3. Clique no separador Mensagens.

4. Clique em Publicar mensagem.

5. No campo Corpo da mensagem, introduza Hello World.

6. Clique em Publicar.

gcloud

Para publicar uma mensagem, use o comando gcloud pubsub topics publish:

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

Carregue um objeto

Carregue um ficheiro para o contentor do Cloud Storage que criou anteriormente.

Consola

1. Na Google Cloud consola, aceda à página Recipientes do Cloud Storage.
   

   Aceda aos contentores

2. Clique no nome do depósito que criou anteriormente.

3. No separador Objetos, faça uma das seguintes ações:

   • Arraste e largue o ficheiro pretendido do ambiente de trabalho ou do gestor de ficheiros no painel principal da Google Cloud consola.

   • Clique em Carregar ficheiros, selecione o ficheiro que quer carregar e, de seguida, clique em Abrir.

gcloud

Para carregar um ficheiro, execute o comando gcloud storage cp:

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

Substitua OBJECT_LOCATION pelo caminho local para o seu objeto. Por exemplo, random.txt.

Veja as entradas do registo e o estado de execução

Confirme que o fluxo de trabalho callback-event-sample foi concluído com êxito.

Consola

1. Na Google Cloud consola, aceda à página Fluxos de trabalho.

   Aceda a Fluxos de trabalho

2. Na página Fluxos de trabalho, clique no fluxo de trabalho callback-event-sample para aceder à respetiva página de detalhes.

3. Na página Detalhes do fluxo de trabalho, para aceder aos detalhes de uma execução específica, clique no ID de execução adequado.

   O Estado de execução deve ser Succeeded e, no painel Output, deve ver os eventos do Pub/Sub e do Cloud Storage recebidos.

gcloud

1. Filtre as entradas do registo e devolva o resultado no formato JSON:

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

2. Procure entradas de registo semelhantes a:

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

3. Verifique o estado da última tentativa de execução:

   gcloud workflows executions wait-last

   O resultado deve ser semelhante ao seguinte:

   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
   

Limpar

Se criou um novo projeto para este tutorial, elimine o projeto. Se usou um projeto existente e quer mantê-lo sem as alterações adicionadas neste tutorial, elimine os recursos criados para o tutorial.

Elimine o projeto

A forma mais fácil de eliminar a faturação é eliminar o projeto que criou para o tutorial.

Para eliminar o projeto:

Atenção: a eliminação de um projeto tem os seguintes efeitos:

• Tudo no projeto é eliminado. Se usou um projeto existente para as tarefas neste documento, quando o elimina, também elimina qualquer outro trabalho que tenha feito no projeto.
• Os IDs dos projetos personalizados são perdidos. Quando criou este projeto, pode ter criado um ID do projeto personalizado que quer usar no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, elimine os recursos selecionados no projeto em vez de eliminar o projeto inteiro.

Se planeia explorar várias arquiteturas, tutoriais ou inícios rápidos, a reutilização de projetos pode ajudar a evitar exceder os limites de quota de projetos.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Elimine os recursos criados neste tutorial

1. Elimine dados do Firestore.

2. Elimine um tópico do Pub/Sub.

3. Elimine um contentor do Cloud Storage.

4. Elimine um acionador do Eventarc.

5. Elimine um fluxo de trabalho.

O que se segue?

• Experimente o tutorial Crie um fluxo de trabalho com intervenção humana usando callbacks.