Esta página foi traduzida pela API Cloud Translation.

Aguardar eventos usando callbacks e gatilhos do Eventarc

Seu fluxo de trabalho pode precisar aguardar um processo externo. Você pode usar Callbacks HTTP para aguardar outro serviço para fazer uma solicitação para um endpoint de callback; essa solicitação é retomada a execução do fluxo de trabalho. Você também pode espere usando a sondagem.

Em vez de usar sondagem, este tutorial demonstra como aguardar eventos ou mensagens do Pub/Sub usando callbacks HTTP e Eventarc gatilhos. Embora seja possível acionar um fluxo de trabalho com eventos ou mensagens do Pub/Sub; convém interromper a execução para aguardar outro evento antes continuar. Por exemplo, um evento aciona um fluxo de trabalho para iniciar um processo, mas o fluxo de trabalho precisa aguardar outro evento que indique que o processo está concluído. É possível implementar isso fazendo um fluxo de trabalho retornar a chamada de outro de desenvolvimento de software.

Objetivos

Neste tutorial, ocorre o seguinte:

Um fluxo de trabalho principal que precisa aguardar eventos é implantado e executado. Como precisa aguardar a ocorrência dos eventos, ele armazena os detalhes de retorno de chamada em um no banco de dados do Firestore para que o fluxo de trabalho secundário possa recuperar detalhes. O fluxo de trabalho principal aguarda as chamadas HTTP.
Um fluxo de trabalho secundário é acionado pelos eventos e recupera as do banco de dados do Firestore quando os eventos são gerados. O fluxo de trabalho secundário chama o fluxo de trabalho primário, que retoma a execução.

Esta é uma visão geral de todo o processo:

Aguardar eventos usando callbacks e um fluxo de trabalho primário e secundário

Fluxo de trabalho principal:

Um fluxo de trabalho callback-event-sample cria endpoints de callback para dois eventos origens: um tópico do Pub/Sub e um bucket do Cloud Storage.
Esse fluxo de trabalho armazena os dois endpoints de callback em um bucket do Firestore documento.
Este fluxo de trabalho interrompe a execução e espera até que as solicitações HTTP cheguem ao os endpoints de callback.

Eventos:

Eventos ocorrem: uma mensagem é publicada em um tópico do Pub/Sub e um arquivo é enviado para um bucket do Cloud Storage.

Fluxo de trabalho secundário:

Os eventos são roteados pelo Eventarc para callback-event-listener e aciona a execução dele.
Esse fluxo de trabalho recupera os URLs de endpoint de callback apropriados do documento do Firestore.
Esse fluxo de trabalho executa os callbacks para os endpoints apropriados na fluxo de trabalho de amostra.

Fluxo de trabalho principal:

O fluxo de trabalho callback-event-sample recebe os eventos endpoints de callback e retoma a execução.
Esse fluxo de trabalho exclui os URLs de callback do Firestore documento e conclui sua execução.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Antes de começar

É possível executar os comandos a seguir no console do Google Cloud ou usando a Google Cloud CLI no seu terminal ou no Cloud Shell.

As restrições de segurança definidas pela sua organização podem impedir que você conclua as etapas a seguir. Para informações sobre solução de problemas, consulte Desenvolver aplicativos em um ambiente restrito do Google Cloud.

Console

No Console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

Acessar o seletor de projetos
Verifique se a cobrança está ativada para o seu projeto do Google Cloud. Saiba como verificar se o faturamento está ativado em um projeto.
Ative as APIs App Engine, Eventarc, Firestore Pub/Sub e APIs Workflows.

Ative as APIs
Crie uma conta de serviço para seu fluxo de trabalho usar na autenticação com outros serviços do Google Cloud e conceder a ele os papéis apropriados:
1. No console do Google Cloud, acesse a página Contas de serviço.
  
  Acessar a página "Contas de serviço"
2. Para acessar a página Criar conta de serviço, selecione seu projeto.
3. No campo Nome da conta de serviço, insira um nome. O Console do Google Cloud preenche o campo ID da conta de serviço com base nesse nome.
  
  No campo Descrição da conta de serviço, insira uma descrição. Por exemplo, Service account for tutorial.
4. Clique em Criar e continuar.
5. Na lista Selecionar um papel, filtre os seguintes papéis para conceder para a conta de serviço gerenciado pelo usuário que você criou na etapa anterior:
  - Usuário do Cloud Datastore: para acessar o Firestore no modo Datastore (Datastore) dados.
  - Receptor de eventos do Eventarc: para receber eventos de provedores.
  - Gravador de registros: para gravar registros.
  - Invocador de fluxos de trabalho: para executar fluxos de trabalho e gerenciar o execuções.
  Para papéis adicionais, clique em Adicionar outro papel e adicione cada papel adicional.
  
  Observação: o campo Papel afeta quais recursos sua conta de serviço pode acessar no seu projeto. É possível revogar esses papéis ou conceder mais papéis posteriormente. Em ambientes de produção, não conceda a Proprietário, Editor ou Leitor. Em vez disso, conceda uma papel predefinido ou um papel personalizado que atenda às necessidades.
6. Clique em Continuar.
7. Para concluir a criação da conta, clique em Concluído.
Para criar um gatilho do Eventarc que roteie eventos de Cloud Storage, conceda o papel Publicador do Pub/Sub para o agente de serviço do Cloud Storage. Normalmente, é o agente service-PROJECT_NUMBER@gs-project-accounts.iam.gserviceaccount.com. É possível recuperar o endereço de e-mail do agente de serviço do Cloud Storage.
1. No console do Google Cloud, abra a página IAM.
  
  Acessar IAM
2. Na linha do agente de serviço do Cloud Storage, clique em Editar principal. Se o agente de serviço não estiver listado, prossiga para a próxima etapa. O painel Editar acesso será aberto.
  1. Clique em Adicionar outro papel e pesquise o papel publisher do Pub/Sub.
  2. Selecione o papel.
  3. Clique em Salvar.
3. Se o agente de serviço não estiver listado, clique em Conceder acesso. O painel Conceder acesso será aberto.
  1. No campo Novos principais, insira o endereço de e-mail do agente de serviço.
  2. Na lista Selecionar um papel, procure o papel publisher do Pub/Sub.
  3. Selecione o papel.
  4. Clique em Salvar.

gcloud

No Console do Google Cloud, ative o Cloud Shell.

Ativar o Cloud Shell

Na parte inferior do Console do Google Cloud, uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.
Verifique se a cobrança está ativada para o seu projeto do Google Cloud. Saiba como verificar se o faturamento está ativado em um projeto.

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

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

Crie uma conta de serviço para seu fluxo de trabalho usar na autenticação com outros serviços do Google Cloud e conceder a ele os papéis apropriados.
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 papéis à conta de serviço gerenciado pelo usuário que você criou etapa anterior. Execute o seguinte comando uma vez para cada um dos seguintes Papéis do IAM:
  - roles/datastore.user: para acessar o Firestore no modo Datastore (Datastore). dados.
  - roles/eventarc.eventReceiver: para receber eventos do evento provedores de rede.
  - roles/logging.logWriter: para gravar registros.
  - roles/workflows.invoker: executar fluxos de trabalho e gerenciar a execuções.
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
    --role=ROLE
```
  Substitua:
  - PROJECT_ID: o ID do projeto em que você criou a conta de serviço
  - ROLE: o papel a ser concedido
  .
  Observação: a sinalização --role afeta quais recursos sua conta de serviço pode acessar no seu projeto. É possível revogar esses papéis ou conceder mais papéis posteriormente. Em ambientes de produção, não conceda a Proprietário, Editor ou Leitor. Em vez disso, conceda uma papel predefinido ou um papel personalizado que atenda às necessidades.
Para criar um gatilho do Eventarc que roteie eventos de Cloud Storage, conceda o papel Publicador do Pub/Sub ao Agente de serviço do Cloud Storage. Normalmente, isso é service-PROJECT_NUMBER@gs-project-accounts.iam.gserviceaccount.com. Usar gcloud storage service-agent para recuperar o agente de 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 um banco de dados Firestore

O Firestore armazena seus dados em documentos que contêm campos como fazer o mapeamento para valores. Esses documentos são armazenados em coleções, contêineres para seus documentos que você pode usar para organizar seus dados e criar consultas. Saiba mais sobre o Firestore.

Cada projeto do Google Cloud é limitado a um Firestore no seu banco de dados. Conclua as etapas a seguir se precisar criar um novo banco de dados.

Console

No console do Google Cloud, acesse o Firestore Primeiros passos.

Acesse "Começar"
Clique em Selecionar modo nativo.

Para orientações sobre como selecionar um modo de banco de dados e para uma análise de recurso por recurso comparação, consulte como escolher entre o modo nativo e o modo Datastore.
Na lista Selecionar um local, escolha nam5 (United States).

O local se aplica ao banco de dados do Firestore e o aplicativo do App Engine no seu projeto do Google Cloud. Depois de criar o banco de dados, não será possível alterar o local.
Clique em Criar banco de dados.

gcloud

Para criar um banco de dados do Firestore, primeiro é preciso criar um aplicativo do App Engine e execute o gcloud firestore databases create comando:

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

Ignore o aviso us-central is not a valid Firestore location. O App Engine e o Firestore oferecem suporte aos mesmos locais, mas a região us-central do App Engine (Iowa) é mapeada para o Firestore nam5 (Estados Unidos) multirregional.

Criar um tópico do Pub/Sub

Neste tutorial, o Pub/Sub é usado como uma fonte de eventos. Crie um tópico do Pub/Sub para que você possa publicar uma mensagem nele. Saiba mais sobre como criar e gerenciar tópicos.

Console

No console do Google Cloud, acesse o Pub/Sub Tópicos.

Acesse Tópicos
Clique em Criar tópico.
No campo ID do tópico, insira topic-callback.
Aceite os outros padrões.
Selecione Criar tópico.

gcloud

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

gcloud pubsub topics create topic-callback

Criar um bucket do Cloud Storage

Neste tutorial, usamos o Cloud Storage como uma fonte de eventos. Crie um do bucket do Cloud Storage para que você possa fazer upload de um arquivo para ele. Saiba mais sobre como criar buckets de armazenamento.

Console

No console do Google Cloud, acesse a página Buckets do Cloud Storage.

Acesse o Cloud Storage
Clique em Criar.
Para o Nome do bucket, insira PROJECT_ID-bucket-callback

O ID do projeto é usado no fluxo de trabalho callback-event-sample para identificar o bucket.
Clique em Continuar.
Em Tipo de local, selecione Região e, em seguida, us-central1 (Iowa).
Aceite os outros padrões.
Clique em Criar.

gcloud

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

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

Depois que as origens de eventos forem criadas, será possível implantar o fluxo de trabalho do receptor de eventos.

Implantar um fluxo de trabalho que detecte eventos

O fluxo de trabalho callback-event-listener é acionado quando uma mensagem é publicada a um tópico do Pub/Sub ou quando um arquivo é enviado para um do Google Cloud. O fluxo de trabalho recebe o evento e recupera o callback apropriado do banco de dados do Firestore e envia uma solicitação HTTP para o endpoint de callback.

Console

No console do Google Cloud, acesse Fluxos de trabalho página:

Acessar fluxos de trabalho
Clique em Criar.
Digite um nome para o novo fluxo de trabalho: callback-event-listener.
Na lista Região, selecione us-central1.
Selecione a Conta de serviço que você criou anteriormente.
Clique em Next.

No editor de fluxo de trabalho, insira a seguinte definição para 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}

Clique em Implantar.

gcloud

Crie um arquivo de código-fonte para seu fluxo de trabalho:
```
touch callback-event-listener.yaml
```

Em um editor de texto, copie o fluxo de trabalho a seguir para o arquivo 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}

Implante o fluxo de trabalho digitando 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 do a conta de serviço que você criou anteriormente.

Implantar um fluxo de trabalho que aguarda eventos

O fluxo de trabalho callback-event-sample armazena os detalhes do callback em um no banco de dados do Firestore, interrompe a execução e aguarda que ocorram eventos específicos.

Console

No console do Google Cloud, acesse Fluxos de trabalho página:

Acessar fluxos de trabalho
Clique em Criar.
Digite um nome para o novo fluxo de trabalho: callback-event-sample.
Na lista Região, selecione us-central1.
Selecione a Conta de serviço que você criou anteriormente.
Clique em Next.

No editor de fluxo de trabalho, insira a seguinte definição para 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}

Clique em Implantar.

gcloud

Crie um arquivo de código-fonte para seu fluxo de trabalho:
```
touch callback-event-sample.yaml
```

Em um editor de texto, copie o fluxo de trabalho a seguir para o arquivo 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}

Implante o fluxo de trabalho digitando 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 do a conta de serviço que você criou anteriormente.

Criar um gatilho do Eventarc para rotear eventos do Pub/Sub

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

Console

No Console do Google Cloud, acesse a página do Eventarc.

Acessar o Eventarc
Clique em Criar gatilho.
Digite um Nome de gatilho.

Por exemplo, trigger-pubsub-events-listener
Na lista Provedor de eventos, selecione Cloud Pub/Sub.
Na lista Evento, em Personalizado, selecione google.cloud.pubsub.topic.v1.messagePublished.
Na lista Selecionar um tópico do Cloud Pub/Sub, escolha o tópico criados anteriormente.
Na lista Região, selecione us-central1 (Iowa).
Se solicitado, conceda o papel iam.serviceAccountTokenCreator a a conta de serviço do Pub/Sub.
Selecione a Conta de serviço que você criou anteriormente.
Na lista Destino do evento, selecione Fluxos de trabalho.
Na lista Selecionar um fluxo de trabalho, escolha callback-event-listener de desenvolvimento de software.
Clique em Criar.

gcloud

Para criar um gatilho, execute o gcloud eventarc triggers create comando:

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 ambiente de execução. Pode levar até dois minutos para que o novo gatilho seja ativado.

Criar um gatilho do Eventarc para rotear eventos do Cloud Storage

Um gatilho do Eventarc permite rotear eventos especificando filtros do acionador, incluindo a origem do evento e o fluxo de trabalho de destino. Crie um gatilho do Eventarc para executar o Fluxo de trabalho callback-event-listener como resultado do upload de um arquivo para um do bucket do Cloud Storage. Saiba mais sobre como acionar um fluxo de trabalho.

Console

No console do Google Cloud, acesse o Eventarc página.

Acessar o Eventarc
Clique em Criar gatilho.
Digite um Nome de gatilho.

Por exemplo, trigger-storage-events-listener
Na lista Provedor de eventos, selecione Cloud Storage.
Na lista Evento, em Direto, selecione google.cloud.storage.object.v1.finalized.
Na lista Bucket, procure o bucket que você criou anteriormente e selecione-o.
Na lista Região, com base no bucket do Cloud Storage: aceitar o padrão de us-central1 (Iowa).
Se solicitado, conceda o papel iam.serviceAccountTokenCreator a a conta de serviço do Pub/Sub.
Selecione a Conta de serviço que você criou anteriormente.
Na lista Destino do evento, selecione Fluxos de trabalho.
Na lista Selecionar um fluxo de trabalho, escolha callback-event-listener de desenvolvimento de software.
Clique em Criar.

gcloud

Para criar um gatilho, execute o gcloud eventarc triggers create comando:

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 ambiente de execução. Pode levar até dois minutos para que o novo gatilho seja ativado.

Executar o fluxo de trabalho principal

Quando um fluxo de trabalho é executado, a definição atual associada a ele também é. Execute o fluxo de trabalho callback-event-sample. Esta é a principal e espera que determinados eventos ocorram, apenas retomando a execução quando o fluxo de trabalho secundário faz as solicitações de callback apropriadas.

Console

No console do Google Cloud, abra a página Workflows.

Acessar fluxos de trabalho
Na página Fluxos de trabalho, clique no callback-event-sample para acessar a página de detalhes.
Na página Detalhes do fluxo de trabalho, clique em Executar.
Clique em Executar novamente.

A execução do fluxo de trabalho é iniciada. Durante a execução, um Estado de execução de Running e uma entrada de registro semelhante a 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. Durante a execução, um estado de execução semelhante ao seguinte:

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

Gerar eventos e verificar o status de execução

Você pode confirmar se os resultados estão conforme o esperado gerando eventos, visualizando entradas de registro e verificando o status de execução do fluxo de trabalho.

Publicar uma mensagem

Publique uma mensagem no tópico do Pub/Sub que você já criados.

Console

No console do Google Cloud, acesse o Pub/Sub Tópicos.

Acesse Tópicos
Clique em topic-callback.
Clique na guia Mensagens.
Clique em Publicar mensagem.
No campo Corpo da mensagem, digite Hello World.
Clique em Publicar.

gcloud

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

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

Fazer upload de um objeto

Faça upload de um arquivo no bucket do Cloud Storage criado anteriormente.

Console

No Console do Google Cloud, acesse a página Buckets do Cloud Storage.

Acessar buckets
Clique no nome do bucket que você criou anteriormente.
Na guia Objetos, siga um destes procedimentos:
- Arraste e solte o arquivo desejado na área de trabalho ou no gerenciador de arquivos no painel principal do console do Google Cloud.
- Clique em Fazer upload de arquivos, selecione o arquivo que você quer enviar e e clique em Abrir.

gcloud

Para fazer upload de um arquivo, execute gcloud storage cp. comando:

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

Substitua OBJECT_LOCATION pelo caminho local da sua objeto. Por exemplo, random.txt.

Exibir entradas de registro e status de execução

Confirme se o fluxo de trabalho callback-event-sample foi concluído.

Console

No console do Google Cloud, abra a página Workflows.

Acessar fluxos de trabalho
Na página Fluxos de trabalho, clique no callback-event-sample para acessar a página de detalhes.
Na página Detalhes do fluxo de trabalho, para recuperar os detalhes de um execução específica, clique no ID de execução apropriado.

O Estado de execução deve ser Concluído e, no painel "Saída", aparecem os registros do Pub/Sub eventos do Cloud Storage.

gcloud

Filtre as entradas de registro e retorne a saída no formato JSON:

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

Procure entradas de registro 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..."

Verifique o status da última tentativa de execução:

gcloud workflows executions wait-last

O resultado será semelhante a este:

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 você criou um novo projeto para este tutorial, exclua o projeto. Se você usou um projeto atual e quer mantê-lo sem as alterações incluídas neste tutorial, exclua os recursos criados para o tutorial.

Exclua o projeto

O jeito mais fácil de evitar cobranças é excluindo o projeto que você criou para o tutorial.

Para excluir o projeto:

Cuidado: excluir um projeto tem os seguintes efeitos:

Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

No Console do Google Cloud, acesse a página Gerenciar recursos.
Acessar "Gerenciar recursos"
Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Excluir recursos criados neste tutorial

A seguir

Siga o tutorial Criar um fluxo de trabalho human-in-the-loop usando callbacks.